diff --git a/base.Dockerfile b/base.Dockerfile index 37a53776aa..c97b5f0992 100644 --- a/base.Dockerfile +++ b/base.Dockerfile @@ -13,11 +13,11 @@ ARG KUBEBUILDER_RELEASE=2.3.1 # Note(tflannag): We ran into some issues curling from the https://go.kubebuilder.io/dl # domain as the output file was HTLM-based, so curl from the github releases # until this has been resolved. +ENV PATH="/usr/local/kubebuilder/bin:${PATH}" RUN yum install -y skopeo && \ export OS=$(go env GOOS) && \ export ARCH=$(go env GOARCH) && \ curl -L "https://github.com/kubernetes-sigs/kubebuilder/releases/download/v${KUBEBUILDER_RELEASE}/kubebuilder_${KUBEBUILDER_RELEASE}_${OS}_${ARCH}.tar.gz" | tar -xz -C /tmp/ && \ mv /tmp/kubebuilder_${KUBEBUILDER_RELEASE}_${OS}_${ARCH}/ /usr/local/kubebuilder && \ - export PATH=$PATH:/usr/local/kubebuilder/bin && \ kubebuilder version && \ echo "Kubebuilder installation complete!" diff --git a/commits.txt b/commits.txt new file mode 100644 index 0000000000..03e1a3be04 --- /dev/null +++ b/commits.txt @@ -0,0 +1,8446 @@ +09fd124d6 fix apidif +a83913da2 fix: bundle size validator: ammount compressed scenarios should be lower than < ~1MB and add improvement to show uncompressed ammount +83f54fb91 fix: ensure that all load bundle methods will check the size (#227) +f3020cb05 add bundle size validator check (#210) +447bc9dfd add some extra clarifications (#222) +c0df2142e .github/workflows: Update the pull_request trigger for the Go workflow (#224) +f26d95a78 feat: add warning for olm.properties being defined when validating csv (#217) +0f4bb3351 .github/workflows: Add workflow_dispatch event trigger (#214) +18b8a45d3 Purge the root vendor directory (#213) +3f7eaca28 deprecate-api validator: add checks for removed APIs on 1.25 and 1.26 (#208) +e02b0c82d Add perdasilva to approvers +3f727364a (catsrc) add custom unmarshaller for registry poll interval (#169) +ae0da0ed5 Add awgreene to list of approvers in OWNERS file (#218) +8f57b5bfb Update OWNERS (#216) +f7893af5e Added field for optional manifests (#209) +cf9801f23 fix: alm-example parse check should not fail when the annotation if empty (#215) +95132180d chore: Bump k8s dependencies to 1.23 (#212) +ce0eb3266 csv_validator: add check to ensure that the example is a valid JSON (#207) +4a8d766f5 validator/good practices: Improve message (#206) +1f091bee4 Add perdasilva to list of reviewers (#201) +19432e845 chore(modules): vendor dependencies +3725e1e0d Remove operator-registry from vendor folder +d7e151aa4 chore(modules): update vendor directory +08e78fa2e chore(modules): update vendor directory +353c9f9f1 with vendor directory +76d1f5a30 Remove unused cache.AtLeast function. (#2681) +be44ec354 Remove cache.OperatorCacheProvider interface. (#2680) +e5c8de4b1 fix(operatorconditions): don't retry on 404 (#2679) +03729c3f9 Remove ConstraintProvider from the exported solver package API. (#2675) +3bab7c39e decrease logging level to debug for noisy catalog and olm operator logs +0dc886807 Update Catalog e2e tests to use rawInterval +845b4ec11 Bump k8s dependencies to 1.23 to align with o-f/api - logr updated from v0.4.0 to v1.2.0 (cascading implications) - Bumped to go 1.17 in Dockerfile - Amended the github action for unit tests: - the envtest binaries were very very old (K8 1.16) - the distribution of kubebuilder binaries and envtest changed in the meantime - kubebuilder is not really needed for the tests and not part of the envtest installation -> check disabled in Makefile - Used `kubectl create` instead of `kubectl apply` to avoid too long annotations for CRDs +18a2b947b Mitigate flaky install plan e2e test (#2668) +181b6b886 Remove import of operators.coreos.com lister package from resolver. (#2661) +ae0ca1e51 .github: Avoid disabling the go mod pkg cache for the golangci-lint action (#2660) +440c7f8ad Remove unused ttl field from cache.Cache. (#2658) +b478c7708 Remove vestigal cache.OperatorSet type. (#2656) +6dbccd82c cmd/catalog: Migrate to using cobra for CLI flag management (#2362) +33572e6ca Give Sources control of invalidation for Snapshots they produce. +b73845712 Replace hardcoded resolver cache mutation with CSV cache.Source. (#2632) +031b21336 Remove unused GHA workflows (#2650) +5c6bf8a8e Remove generated and unused resolver/fakes subpackage. +ac516dad5 Remove CatalogSourceLister usage from resolver/cache. (#2648) +004e1ae22 (Partially) mitigate flaky tests (#2625) +6f4a176db Clarify solver package responsibility. (#2647) +98eb1cb86 Fix cpb traverses unneeded paths (#2239) +0a915a5e8 docs: add logo for github dark mode (#2622) +3aecccf97 README: Remove reference to subscribing to packages through the tectonic UI (#2301) +8471feded .github: Remove the automatic rebase action (#2620) +804512ca4 cmd/catalog: Default to the $KUBECONFIG environment variable (#2303) +710c96e8d [BZ #2048441] Fix a bug in deletion of webhook service for replacement (#2606) +897a53add change Lister to DynamicClient for subscription clean up (#2616) +ac9236f7c Remove the out-of-date CHANGELOG.md (#2608) +5d7eff1ae Add workflow for automatically rebasing open PRs (#2612) +b12032a75 fix: remove hardcoded minikube version from build_local.sh to support minikube users locally (#2607) +59fdf61c4 wait for operatorhubio-catalog ready before test starts (#2605) +f9ca416da Stop corrupting resolver cache. (#2604) +7238d11ba Makefile: Remove unused targets/variables (#2567) +e348996d8 count only active ns and wait for namespace clean up (#2585) +de32e593a OWNERS: Add akihikokuroda as a reviewer (#2602) +c55f7783f wait for catalogsource ready (#2601) +f1bd02858 Remove unused ipLister field from OperatorStepResolver. (#2587) +6fb02d292 put mutex around installplan creation (#2545) +50799623e ci: Support configuring the logging level for the splitter package (#2579) +864d921d3 Introduce Experimental Metrics (#2435) +5b014484e use unique name for each test (#2541) +1631f3e49 chore(e2e): naively parallelize CI jobs by chunking alphabetically (#2520) +37a7ac7d9 recover nil GRPCConnectionState by update failure (#2561) +5752fa97d wait for catalogsource pod deletion (#2444) +107e14ff0 wait for condition update (#2510) +ba3d06fd9 fix e2e config map update triggers registry pod rollout failure (#2532) +918e393b7 add possible error message patterns (#2565) +2f70f164d add wait for config injection in e2e test (#2547) +ee469ae84 CSV e2e - wait for 2 pods ready before delete one pod (#2554) +74d8e2575 Bump olmConfig controller logging message to debug (#2568) +5faf373a1 Update goreleaser go version to 1.17 (#2557) +ca99f270c Bump repository to Go 1.17 (#2556) +3135ea9a8 Remove the unused 'lint' Makefile target (#2555) +a8df88582 fix disable copied csv e2e test failure (#2543) +55452a94f doc/design: Update the release documentation (#2549) +7d6a04c95 Update OWNERS file (#2551) +1b1b094b6 Fix goreleaser image repository configuration (#2548) +2f8b4be05 Remove NamespaceSourceQuerier API that is no longer in use (#2380) +e1ade2169 fix registry grpc unit test intermittent failure (#2521) +fde47792d Add MagicCatalog for creating arbitrary file-based catalogs (#2527) +44654f283 Integrate golangci-lint to run aggregate linting checks for CI (#2536) +483bbe0b5 Remove bill-of-materials.json (#2535) +24985a7aa chore(github): run e2e workflow against master periodically (#2528) +2bfc3795e chore(api): Vendor the new version of api repo (#2525) +9d3db1d1a .github/workflows: Enable workflow_dispatch event triggers (#2464) +9c47cd6c0 .github/workflows: Update the checkouts action to use the v1 version (#2463) +06d5c0d30 Fix github alias links in MAINTAINERS.md (#2533) +6ea929d31 Add system constraint provider logic to resolver and add step resolver init hooks (#2523) +c6f885f2d Introduce GRPC Proxy unit tests (#2428) +6fa712d60 (vendor) bump go-sqlite to 1.14.10 (#896) +f445d567b Update extract.go (#876) +fe41e9b13 feat(constraint): Add constraint type validation to bundle validation (#888) +d045f587f (.gitignore): Do not ignore debug/ (#890) +8112836b1 (vendor) bump api to v0.11.0 (#887) +5fb335a9e bump grpc dependency to latest (#810) +5f7fb114e Bump operator-framework API to 0.10.5 (#737) +ca5bcd0e8 remove darwin builds, disable goreleaser github releasers, re-add .github/workflows/release.yaml +198d00f16 Merge pull request #258 from perdasilva/fix_kubebuilder_install +59947b919 Fix install_kubebuilder.sh script +99d2f8c64 Merge pull request #257 from timflannagan/ci/bump-base-dockerfile-go-version +62ddd2079 Update the build root Dockerfile base image +1b60477a5 Merge pull request #250 from openshift-bot/art-consistency-openshift-4.11-operator-lifecycle-manager +f96daca5a Merge pull request #249 from openshift-bot/art-consistency-openshift-4.11-operator-registry +6858269bd Merge pull request #228 from eggfoobar/leader_election_config +6182cf61f Merge pull request #227 from ankitathomas/cleanup-scripts +928cd2246 Updating operator-lifecycle-manager images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/0059e470a61eba28225165168b22d9e77c33c926/images/operator-lifecycle-manager.yml +fbc18d65c Updating operator-registry images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/0059e470a61eba28225165168b22d9e77c33c926/images/operator-registry.yml +5863540f4 Merge pull request #248 from tylerslaton/sync-constraint-changes +fbfd54eeb feat: update api version to be 0.12.0 in order to use new Not constraint (#2603) +a2896729a chore: update o-f/api version to v0.12.0 (#911) +6a95e25a7 refactor(constraint): update none compound constraint to be not (#221) +0d3db5544 fix(render/diff): Support olm.constraint in opm render/diff cmd (#901) +6dce29c1b chore(constraint): Correct message to failureMessage in olm.constraint schema (#2572) +46ea48565 fix(constraint): Correct the message field to be failureMessage (#211) +b2d3ba890 test: added unit tests for leader election +da97b0d3f upkeep: ran make verify +9e56f4f53 feat: added leader election conventons +d795a1d8e Merge pull request #240 from awgreene/grpc-address-bug-fix +e8f3aa69a Merge pull request #247 from benluddy/patch-1 +06306d85d Remove benluddy from approvers. +3820d16f4 Merge pull request #241 from perdasilva/add_per_to_owners +9379df58f Merge pull request #242 from awgreene/bz-2003164 +2cd20d241 Do not modify object from the lister cache (#2562) +79c782526 Merge pull request #239 from timflannagan/bz-1952576 +78d2b0af3 Merge pull request #238 from kevinrizza/master +4c4835a0c Add perdasilva to OWNERS +12e83f9b9 Address Invalid Address in GRPC Catalogs (#2499) +7baca835c fix e2e CSV metric is preserved failure (#2530) +91b949ae2 Emit CSV metric on startup (#2216) +0bb2c07f6 Bug 2037168: Remove incorrect cvo annotations +13f7723ba Merge pull request #237 from awgreene/olmconfig-create-only-annotation +423c68713 Add the create-only annotation to the olmconfig/cluster manifest +6efdf7acb Merge pull request #236 from timflannagan/sync-olm-copied-csv +9c548f2fd manifests: Add the OLMConfig CRD +e3ea532e5 Introduce olmConfig controller (#2466) +cf218f7fe Merge pull request #232 from dinhxuanvu/synx-12-14-test +325983e6d feat: catalog source pod scheduling config overrides (#2512) +4efba59f3 feat(resolver): support generic constraint using CEL (#2506) +b59e7342c feat(resolver): resolve compound dep constraints from bundle properties (#2418) +9e65a9a5b chore(deps): bump o-f/api for new constraint types (#2515) +d87c0de02 go.*,pkg,vendor: Bump controller-runtime to v0.10.1 (#2368) +a494ce140 doc: further information and example of usage (#205) +f73f86c7c feat(constraints): add compound constraints and olm.constraint value parser (#203) +7ff5e4a1f test: skip image polling test if running in a kind cluster (#2445) +0c319f5c7 test/e2e: Fix unset when gathering CI testing artifacts (#2450) +5bb028dbf Introduce a mechanism for gathering test artifacts during individual test failures (#2442) +6b141273d Merge pull request #231 from anik120/sync-registry-12-15 +7e3871875 fix(diff): prune empty channel when old model is empty (#884) +30b39543f chore(deps): upgrade of/api for new constraint type (#880) +e58ffe0dd Merge pull request #225 from anik120/sync-api-10-12-2021 +aafc7b5fe clean up unused scripts +5485c64e2 bugfix: make spec.grpcPodConfig.priorityClassName a *string +54b083fd5 feat(cel): Add CEL custom library for semver comparison (#202) +ddc7ca9ce add new good-practices validator (#197) +2ae9059da Introduce OLMConfig CRD (#198) +ff03d62c6 Merge pull request #223 from anik120/sync-olm-12-10-21 +33fa1102c Add grpcPodConfig attribute to spec (#173) +d065c9745 Add format as a prerequisite to verify target (#200) +6d609e9bd deprecate: CommunityValidator (#199) +d073e45eb doc: fix layout of the doc (#171) +923c6c035 Merge pull request #224 from anik120/op-registry-sync-10-09-2021 +dbd7e9a77 Introduce Maintainers File (#2456) +635f3c78f Add instructions for setting up envtest and checking go version (#2504) +0c485c8a0 .github/workflows: Avoid specifying the paths-ignore keyword (#2511) +184f0ae86 cmd: Silence warning about logrus.Fatal usage when directive has been supplied (#2462) +93fc88a07 fix unexpected deployment hash value change (#2508) +7bd61f0fa test/e2e: Collect CatalogSource testing artifacts and delete empty files (#2460) +5f9ca66da pkg,test: Remove duplicate package imports (#2501) +f84457507 Rename CI github workflows (#2446) +09a43ac78 alpha/declcfg: re-encode olm.bundle.object data to JSON when loading (#874) +dc5f6de60 Merge pull request #218 from timflannagan/sync/11-30-and-registry-no-grpc-bump +5ba7d1af0 drop trailing slash for catalog directory on opm alpha generate dockerfile (#831) +8957e5ebc pkg/sqlite: use consistent starting depth when building channel_entry table (#868) +02663b502 (fix) database is locked during removal (#828) +b95ad9bfc Block cross-package skips/replaces on add (#826) +32b7b0653 Adding equivalent opm index flags to opm registry (#827) +3099308f3 opm validate: fail on duplicate packages, channels, and bundles (#824) +6b96c00a3 feat(diff): change default behavior to prune by omission (#819) +ada17ab6e goreleaser: use netgo and osusergo to ensure completely static binary builds (#821) +64ce5b90e render: include olm.bundle.object properties in rendered bundle images (#807) +76dfb74c2 .github/workflows/goreleaser.yaml: fix cross-compiler install step (#818) +fb9d689ba Log a warning when loading bundle manifests with multiple documents (#708) +442bcb774 retain single bundle default channel for overwrite (#812) +26c0883d1 e2e local test for mac (#785) +8f7c15376 alpha/declcfg: Include bundle name in version parsing failure message (#811) +67d84fdde Makefile: Add a .PHONY target for the opm build target (#813) +6b326f926 fix(opm): ignore empty include file args (#808) +ea627a90a build(deps): bump github.com/containerd/containerd from 1.4.8 to 1.4.11 (#806) +3ac596922 (opm) Introduce deprecatetruncate for `opm registry` (#804) +bbdb874c7 registry: vacuum db on commands that remove data (#803) +f85f31221 ensure use of bash as Makefile shell (#802) +e1229be42 Makefile: fix major and major-minor docker release tags (#801) +ed6edb359 Check only for new bundles on add (#798) +6f0b8ebe1 Use the proper grpc_health_probe command per architectures. (#796) +254dfdd84 render: populate related images even when CSV has none explicitly defined (#797) +a7fdfdf9f Enable cgo in multiarch builds (#793) +b8e5cc27d migrate: add subcommand to migrate sqlite catalogs to file-based catalogs (#770) +52e90015a handle deprecating branch points (#767) +4947f3406 fix: update opm commands to specify if they don't take args (#786) +47cee9b7a fix(alpha): update long description indentation (#789) +80e4a9241 feat(diff): optionally include bundle names (#787) +8dca80f68 fix: Unable to deprecate bundles that are head of a NOT default channel with opm deprecatetruncate (#780) +121ef6b7c Update CASE to match resource. (#694) +a4fe1851e opm serve: pre-compute and store api.Bundles to disk; requests read from disk (#783) +41c7be418 feat(opm): include arbitrary packages, channels, and versions in diffs (#716) +ccc08edd1 use static distroless image instead of base (#778) +a28216b0b fix: clarifies message error regards service account (#174) +798dfd6af fix: Scorecard configuration ServiceAccount tag (#166) +8a250a513 fix: add missing allowed category (#164) +704d0ad3e doc operatorhub validator (#159) +ad3f39546 chore(docs): emphasize release versioning requirements (#162) +509e6725d fix(validators): check object GVK in bundle service account validator (#161) +840c9134c Validate SA names do not match csv deployment spec (#144) +6af63ed22 Add Service Account Config to Scorecard (#153) +84f7ca58f feat: add new validator to only check the usage of deprecate apis (#156) +d1d38138a Merge pull request #213 from njhale/sync/10-18 +a4147d89f fix(sub): Only update subscriptions that have changes in status (#2399) +a6861acaf remove panic (#2448) +4a0f091dc test/e2e: Fix 'resource name may not be empty' failure in catalog templating test case (#2457) +a2f4723f1 test/e2e: Reduce subscription e2e test pollution (#2438) +b57566008 .github,test: Upload container logs during e2e runs as artifacts (#2432) +f7fdf89cf Makefile: Explicitly override the default OLM install and test namespaces +47d8f3cd8 Fix typo and add clarity to replacing transition (#2426) +a42e9b430 Expose pprof endpoint if tls is not configured (#2422) +55508edd9 Makefile: Update the e2e-local target and add CI-friendly ginkgo options (#2414) +bd293096d Improve reliability of e2e tests that include GRPC CatalogSources (#2419) +e37952b2f fix: use v1 pdb object under e2e bundle test (#2398) +2248662df fix: wrap csv e2e test create in Eventually statements in the BeforeEach block (#2387) +5d2375154 test/e2e: Wrap flake-prone garbage collection tests in eventually assertions (#2403) +baea59c5b chore(make): add e2e test options (#2393) +2f2caa4d1 Rename resolver/cache.Operator to Entry. (#2359) +fb8b0f463 fix(e2e): Remove the PreExistingCRDOwnerIsReplaced e2e test case (#2388) +26182b4f5 fix(e2e): Using Eventually to check subscription state (#2396) +5cfd98e82 fix: wrap subscription e2e test logic in Eventually statement (#2392) +09bc47556 test(e2e): use server-side apply to update fixture (#2385) +9941e120b Makefile: Update the e2e target to use ginkgo (#2367) +295c1dcb7 Integrate goreleaser to produce draft releases when new tags are pushed (#2365) +e37e7d67c Update default catalog namespace (#2371) +064c435dd pkg/controller: Fix panic when creating cluster-scoped RBAC in OG controller (#2349) +1023034ab Add olm-managed label to configmap-based catalogsource for e2e test (#2370) +fb8b5724a test/e2e: Remove the unused e2e.sh and tap.jq files (#2366) +336f02eb7 Add summary and description for prometheus alerts (#2361) +25fb2651e Makefile,test: Remove the test/rh-operators directory (#2354) +cb3b165d1 .github/workflows: Don't run the sanity jobs for markdown-only updates (#2356) +9674465bd fail gracefully when client-ca file is not set or doesn't exist (#2358) +eb55029e4 .github/workflows: Bump the docker/build-push-action to the v2 version +afa6ef4dc Update the CONTRIBUTING.md guidelines (#2344) +5c838276a pkg,test: Fix linting violations in relevant packages +b33b6b58d .github/workflows: Introduce a sanity check that runs static linting/style checks +011db68b5 Makefile: Add a linting target that runs gofmt/goimports +e02906a77 fix(og): Fix missing MultiOperatorGroups condition in some cases (#2305) +8970fc081 Merge pull request #211 from dinhxuanvu/upgrade-delay +807c857a6 pkg/controller: Migrate to using a read lock instead of a readwrite lock when checking for any namespace caching errors (#2382) +f70bd92b8 Remove oudated subscription update logic to improve resolution delay (#2369) +6d684d4d9 Merge pull request #208 from awgreene/update-collect-profile-namespace +0c261a1fa Use arguments to configure pprof-secret +dde7292f1 Merge pull request #206 from njhale/sync/grpc-no-proxy +76afb08a4 Merge pull request #205 from njhale/sync/quarter-2 +c4e244763 Introduce GRPC_PROXY EnvVar Support (#2364) +6a39a9a46 feat(opm): fine-grained dependency selection in diffs (#756) +8fa95ac5c .github/workflows: Don't run CI checks for markdown-only updates (#2347) +b1e86958c fix(release): upgrade goreleaser so script requests correct checksum file (#773) +e3dc18c5c chore: update manifests +b3bc3eba3 Bump OLM_VERSION to 0.19.0 (#2348) +d7faee734 doc(readme): add chat badge (#2345) +f1f6a3343 .github/workflows: Separate out the e2e jobs into workflows (#2158) +f610b0985 chore: update manifests +dcbe7701f modified the controller-runtime and controller-tools versions (#154) +4314d89a7 Remove hardcoded references to the registry gRPC API from the resolver packages. (#2340) +63b841586 Add validation for Kind and APIVersion (#152) +5ee92ca8d Add Timestamp to Scorecard Test Results (#137) +a46d4c876 Remove unneeded replace pin for sigs.k8s.io/structured-merge-diff (#2338) +9f1a51d79 Reduce resolver dependencies on operator-registry and operator-lifecycle-manager. (#2337) +af5c4c2ed fix: ensure operator images are included in rendered bundles related images (#771) +301587ba0 Merge pull request #200 from njhale/sync/half +c98b23dee update default scaffolded opm base image (#762) +44b39b1ae Fix 2327: Detecting OLM existence before start to install (#2334) +1b1751a31 (fix) : Fix check to verify OCP label versions when it is =v4.x (#148) +54a82e931 bump gini (#2336) +2eda531c1 fix broken URL in unit.yaml GH action (#2335) +baf84fad5 move internal to alpha to make subpackages available for importing from other projects (#759) +b5953c971 feat(opm): configure diff to not include dependency bundles with --skip-deps (#753) +0b7711578 Fix upstream-opm-builder (#758) +1fca926f8 Use of/gini instead of inifrance/gini (#2331) +42dc86b42 Add vu dinh to OLM approvers (#2332) +da994b77a Prune API of the resolver package. (#2330) +a8ad0d24f Add joelanford as an approver in OWNERS (#751) +f8cb8dbb5 cli doc: opm serve does not detect DC changes after startup (#750) +13f3cc8be add further console customization types (#2319) +4e8f0d541 feat(release): X.Y, X, and latest opm image tags (#738) +7cff3298b feat: support removing the default channel head in deprecatetrunace (#734) +761b51f93 .github/workflows: Replace the e2e-kind job name with e2e in the test workflow (#730) +ef6614148 add further console customization types +efbfe0477 Move operator caching from resolver into a new package. (#2316) +84c660776 setup multi-arch builds with goreleaser +c553dde9a internal/declcfg: Avoid processing the .indexignore file when walking the root fs (#733) +f405a8ecb let net.Listen pick a port for grpc servers generated in tests (#2310) +9e3125208 don't return an error if the singleton rbac doesn't exist (#2309) +999506f9a .github/workflows: Avoid running the e2e-tests workflow on doc-only pull requests (#2299) +327f6b774 doc/design: Update the changelog release documentation (#2298) +e9be950d8 Update containerd dependency to fix vulnerabilities (#719) +a2c7df0e6 v0.18.3 OLM release +2b6872781 Expose errors generated while retrieving catalog content. +282bb6e1f .github/workflows: Fix the release quickstart.yaml GH action +001135e9b Merge pull request #199 from kevinrizza/add-readme +bf964279f Add a readme +a768ef8e8 Merge pull request #189 from openshift-bot/art-consistency-openshift-4.10-operator-lifecycle-manager +3cef91bfe Merge pull request #188 from openshift-bot/art-consistency-openshift-4.10-operator-registry +a5303ed3d Updating operator-lifecycle-manager images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/79fa14aac4fe70e2d6b85876bf225f546a8e73a7/images/operator-lifecycle-manager.yml +206d2a09c Updating operator-registry images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/79fa14aac4fe70e2d6b85876bf225f546a8e73a7/images/operator-registry.yml +f2feb108c Merge pull request #185 from timflannagan/remove-scripts-readme +4a8195458 scripts: Update the README.md to point to the downstream gdoc +e80f0524b Merge pull request #183 from timflannagan/update-build-root-config +7a7c6b453 Introduce the .ci-operator.yaml file +32eb25914 Merge pull request #179 from benluddy/bz-2000144 +247887f1f Merge pull request #181 from joelanford/bz-2000146 +bbd687b8e Introduce olm.channel schema, remove channel metadata-related bundle properties +98b8c0fbc Mark GetBundleForChannel as deprecated and trim its response. +01e1cf8ca Merge pull request #178 from awgreene/owners-update +ca5d761a8 Merge pull request #137 from timflannagan/packageserver-ha-expectations +9647632b7 pkg,scripts: Ensure the PackageServer CSV contains a hard pod anti-affinity configuration +f4e67294b manifests,scripts: Add a PodDisruptionBudget resources for the PackageServer component +5f4c7ea2a Update OWNERS file +859291e1c Merge pull request #176 from joelanford/bz-1994648 +d4a3aa1c3 Merge pull request #177 from joelanford/bz-1996878 +c3c64d40c Add deprecation warnings for CLIs that use or depend on sqlite +7a6282c8b manifests,scripts: Update the PSM deployment filename to be consistent with the rest of the YAML manifests +0178564d0 Merge pull request #175 from joelanford/bz-1995300 +52aa59c71 fix(sub): Reset ResolutionFailed cond when error is resolved (#2296) +6ee2f331d Merge pull request #157 from timflannagan/fix-multi-arch-opm-version +1841f3076 opm validate: check for cycles and stranded bundles in channel validation (#755) +d1dea1028 Merge pull request #170 from timflannagan/k8s-bump +0ba8af9f5 Merge pull request #172 from timflannagan/fix-build-root-dockerfile +f55f561cd Update kubebuilder installation in the build root dockerfile +0934d42a4 Merge pull request #150 from timflannagan/fix-opm-index-prune-panic +b82547dc5 scripts: Ignore upstream commits touching the root go.[sum,mod] files +b5bc8b5fb fix: update make generate directive to be crossplatform +97e684566 feat: bump k8s dependencies to v0.22.0 (#2323) +e65faeb8c feat: bump k8s dependencies to v0.22.0 (#747) +6a09badd6 feat: bump k8s to v0.22.0 (#145) +b5600cf63 Merge pull request #171 from njhale/fix/verify-commits +40493e689 Merge pull request #169 from ankitathomas/maxocperror +69171128d chore(verify-commits): initialize variable +5bd4cad68 Merge pull request #138 from njhale/verify-commits +43b502193 chore: add verify-commits make target +a5bcfe06a add maxOpenShiftVersion test for parsing full version string (#147) +9caf73f4e warn on maxOpenShiftVersion specifying more than major.minor (#146) +cc481dfd4 clarify maxOpenShiftVersion upgrade error message (#2326) +fc5e9b57f Merge pull request #164 from estroz/bz/1989431 +4f3624c69 Merge pull request #166 from njhale/fix/drop-z +9f21b6b0d fix(opm): clarify that bundle declcfgs are not valid refs alone (#741) +f9bff9e54 fix(openshift): drop z from next calculated y-stream (#2324) +edcddea0f Merge pull request #163 from estroz/bz/1989796 +859431bd1 Merge pull request #161 from estroz/bz/1989460 +f62aaf31c Merge pull request #162 from njhale/fix/rmpkg-deprecate +a856ed067 Merge pull request #160 from ankitathomas/bz1983673 +4895c84a9 docs(diff): add point about versions that differ (#735) +b3c146f57 chore(opm): note that whole dependency packages are added to the diff for now (#740) +c41b52357 fix(deprecate): explicit pkg rm drops latest deprecated +fb92eba59 Merge pull request #144 from kevinrizza/catalog-switcher +a766f625d check for pruned bundles on add in replaces mode (#732) +e6840f9ce Merge pull request #159 from benluddy/bz-1990850 +512dde7b5 Handle property and dependency values of type BLOB in ListBundles. +3a21821b7 Merge pull request #136 from timflannagan/update-leader-election-psm-config +e47245b42 Merge pull request #154 from njhale/fix/invalid-max +e4e78e51f Makefile: Ensure cross-compiled opm binaries produce non-empty version information +9889a1ad7 Merge pull request #151 from dinhxuanvu/catsrc-priorityclass +a47e7c1b4 Merge pull request #149 from benluddy/bz-1989710 +f848f27a1 Use GitVersion to parse version from discovery (#2312) +552292e08 Merge pull request #147 from benluddy/bz-1989600 +90140470a fix(openshift): block upgrades on invalid max properties (#2302) +06abc61a5 Merge pull request #148 from dinhxuanvu/catsrc-priority +42f4b533e Add PriorityClass setting to registry pods for default CatalogSource (#2304) +bb05a865e Fix nil function in buildContext return values (#610) +4f39a6fb6 Prune unused ClusterServiceVersion fields from catalog's informer. +64cf2683c fix(og): Fix missing MultiOperatorGroups condition in some cases (#2305) +d4bc691a2 Set soft_heap_limit for SQLite-based registry servers. (#728) +36a8575d9 Omit manifests from ListBundles result if bundle image is available. (#725) +d6d2b6d14 Update Registry to stream bundles (#723) +1b907c7ed Set legacy API fields in ListBundles using available properties. (#724) +ba7041aac Aggregate properties/dependencies in-query for ListBundles. (#720) +82328e004 Wrap catalog update test with retry logic (#2311) +85f5cf292 Catalog switcher (#2281) +cf7140bf3 Merge pull request #143 from joelanford/bz-1923111 +298bdf6da Merge pull request #142 from joelanford/bz-1987160 +b6361dd3f installplans: retry crd updates on conflicts (#2293) +295bf0213 fix(diff): heads-only mode should not attempt to parse old refs (#727) +5c57b2841 Merge pull request #139 from timflannagan/opm-alpha-diff-fix +4e6b4bad7 cmd/opm: Fix panic in opm alpha diff when accessing the --skip-tls flag (#721) +088bd07ea Merge pull request #135 from joelanford/bz-1969902 +50b71a7ec cmd/psm: Update the leader election configurations +e736f4e14 resolver: remove legacy support for fallback parsing of CSVs +3475b1d5d Merge pull request #130 from awgreene/remove-cluster-monitoring-label +4a5ad031b Merge pull request #133 from kevinrizza/staging-temp-sync +633919c08 Add managed label to configmap to reduce cache size +6c855c7d1 Drop inline manifests from resolver cache. +d20b7197f Hash and prune copied ClusterServiceVersions in olm-operator. +eb186f880 Add openapi markers for csv (#141) +e64a02403 opm alpha diff: generate a diff between two sets of catalog/bundle refs +759381e2d Bump to k8s.io 1.22-rc.0. +8b7f5fffe add declcfg.WalkFS function +5fb2bda3a Add conditions to catalog source +a37952102 feat(resolver): Indicate dependency class in resolution constraint text +48a386dad Merge pull request #131 from kevinrizza/sync +e5ee15397 Merge pull request #112 from awgreene/continuous-profiling +887534217 feat(resolver): Move all predicates to its own file +8e85501b5 add short description for generate subcommand +6f67054dc add note explaining duplicate label keys +25485737a add generate_dockerfile_test.go, fix format string +352cceb3b add command to generate DC dockerfile +a21216621 fix psm deployment +0c3dd77e3 Introduce continuous profiling +74ed30d7f feat(sub): Indicate resolution conflicts on Subscription statuses +814dfec7c vendor of/api v0.10.2 +d3eb9c841 Add filter labels to catalog pod cache +5e7648af0 Remove monitoring label from openshift-operators namespace +ae9214651 Merge pull request #129 from kevinrizza/upstream-sync-branch +ec51a3dd2 Update getMetricsFromPort to infer port number +b77c2c064 Add optional opm image argument to chart template +b04906462 Update OLM Deployment template +a85c6423c feat: add GVK existence check for OLM supported resources by querying discovery in case of 404 not found errors when applying installplan steps. +6eb4891e5 type(sub): Add ResolutionFailed condition type for subscription (#138) +aa687ed16 Update olm and catalog deployment templates +327d2471a Temporarily use controller-runtime fork with data race patch. +a18a15545 remove unused scripts +56a5579e3 fix(openshift): handle unquoted short max versions +cf30b9f75 Use metadata-only watches when possible for Operator component APIs. +62bd80fe3 Update extractMessage func +0a118aa92 improve tests +0a07b4624 Add list subcommands for packages, channels, and bundles +c23e5ec56 add a resolver test for completely disjoint graphs within a channel +92abe27ba feat(sub): Include IP failure condition message in sub status condition +d8e537ed3 Don't cache copied CSVs in the controller-runtime-based controllers. +9951b9553 Fix ClusterOperator selector for excluding copied CSVs. +aad1cb2f0 Correctly omit skipped channel entries during resolution. +7d0d57246 Explain unique replaces chain requirement in channel sort errors. +e95915d80 Update test-scripts check to use go1.16 +ba29f0fa0 Regenerate mocks +3626e03b2 Bump operator-registry to v1.17.5 +83eb1ce14 Enable gzip compression when unpacking bundles to ConfigMap +cb9cb9fc7 Add a catalog-operator flag to set opmImage +0d1d1f22a Remove unused trace log from LegacySyncHandler. +0745028cb Use one HTTP server for healthz, metrics, and profiling. +1529be474 Translate legacy "bundle dependencies" to properties. +1e5aef296 move DC opm commands out of alpha +246e0ce81 Remove pin of etcd and grpc (resolved in etcd v3.5.0). +a0c78850a declcfg: improve and fix model tests to eliminate possibility of false negatives +1dc76f08e Merge pull request #99 from timflannagan/packageserver-csv +f465cc354 cmd,pkg: Filter out non-PackageServer CSV resources at the cache level +1389cc834 pkg,scripts: Fix quoting around the release annotations key value +d7ef83204 manifests,scripts: Fix environment variable not being evaluated +40c7a64c7 pkg,scripts: Re-add the release annotations and default values in the PackageServer CSV resource +41cdf6323 manifests: Update manifests after modifying manifest generation script +9708bdda7 scripts: Update the manifest generation script +a95a2d226 Makefile,Dockerfile: Add the package-server-manager binary to OLM container image +91496b668 cmd,pkg: Introduce a secondary-level controller that manages the PackageServer CSV +490b91128 manifests: Remove the PackageServer CSV YAML manifest +f105c2f5d go.*,vendor: Update the o/api, k8s, and controller-runtime dependencies +8740cee32 Merge pull request #116 from timflannagan/rebase-master-bluddy-main +6c75da9ca OWNERS: Add additional reviewers +94234302f Create OWNERS +23c71d219 Fix release manifest generation and regenerate manifests. +1f8f81035 Bump root module to Go 1.16, tidy, and vendor. +dae62e798 Add grpc-health-probe to cmds (part of registry image build). +8c2e98ae1 Build cpb directly from staging. +2797a1bc0 Fixes to CRD v1 compatibility in tests. +145c9df74 Fix endless loop +4559b89fd fix: update e2e test CRDs to use v1 structural schemas +625fd6f8c bump VPA crd to v1; use new embed directive in vpa e2e test +1d3f32990 fix: remove v1beta1 CRDs from all e2e tests; add deprecation e2e tests +0c5cc08cf don't watch unlabelled secrets in the operator controller +21973f1d8 Fix error check for list operatorgroup call +43299f840 Vendor api v0.10.1 and regen code and manifests +0bdf52d9a feat(og): Project OperatorGroup errors to status conditions +3461fb97a feat(render): render sqlite database files +dc800e161 model: fix test for ReplacesNotInChannel +e4d6a3101 Add a label to secrets managed by OLM, and don't watch secrets that omit the label. +fcdd8831f declcfg: validation should allow non-existent replaces value +bc1b56e50 feat: bump k8s.io/* components to v0.22.0-beta.0 +4bb90c822 doc/design: Fix broken milestone link in the release.md +b67943920 remove cleanup from startup +a49736922 doc/design: Add a version prefix to the release tag in release.md +6d4870098 Cleanup residual appregistry-server image references +b05e7f74a Bump OLM to v0.18.3 +4de6a5b95 (fix)InstallPlan: Do not tranisition IP to failed on OG/SA failure +056e101b9 add storage spec to scorecard config (#135) +06dff04e8 Add conditions array to OperatorGroup v1 status (#133) +65673206b Add validation to CSV name length (#134) +4d9061009 Add UID Optional field to scorecard config types (#110) +6dd3f7078 feat: update the channel nammming conv (#129) +03b6e7e51 chore: bump k8s to 1.21 (#130) +7dc6cb5ce Fixed CSV deployments label field doc +929df256b Add an option to store Gzip-encoded bundle data in ConfigMaps +2f8ddb603 remove testdata index.db (generate it instead) +3871c6ab0 add defer statements to close rows and db +05aca3841 Query related_image table when rendering DC from sqlite +d03380e06 bump kind to 0.11.1, print bundle unpack pod logs in e2e test +a44654cc5 (fix)registry: fix configmap registry server liveness probe timeouts +5bbc8b894 ignore recursive self referential suberrors +777620be8 fix formatting issue for empty leaf suberrors +8d98b256f use filesystem instead of directory path string, other minor improvements +da01c7232 declcfg validation: output errors as tree +6ea414b45 declcfg: validation should allow non-existent replaces value +79ea08c06 remove path checks from deprecate +8952c05ef Resolve InstallPlanStepAppliedWithWarnings alert after some time. +ab4b3509d install.sh should not abort if openshift olm is not installed +a2dd2b9c2 check presence of all bundles before deprecate +e982c882d improve code coverage +0e4024e38 change LoadFS argument name back to root +21c772dfd declcfg: change LoadDir to LoadFS +817d4ede7 Registry ensure methods error out if resource is not found +ef9b01826 Resurrect deleted metrics Service templates. +c42124c1b Remove travis build badge from README.md +8235f338c improve code coverage +681e5d07f Add support for .indexignore files in DC dirs +e8cfebf3d feat(bundle): consume explicit properties +4d814222f Address various issues with OperatorCondition codebase +167137831 Update OperatorCondition Role and e2e test case +44ded2699 Add OperatorCondition status sync and update operator upgradeable check +b67b3e161 Fix Template Annotations on Webhooks/API Service CSVs +559e733f6 Bump OLM version to 0.18.2 +bcfba8b4a Check for conflicting install +bc194d2c1 fix example bundle dockerfile +9552d455c improve code coverage +cb60b277e Remove `opm alpha add`, `declcfg.WriteDir`, and related now-unused code/tests +cc1be30fe Surface API server warnings when applying plan steps. +4d6169ce4 Bump kind dependency to v0.11.1. +442fcd003 Fix verify target +aba268ae5 Fix nil pointer dereference while reporting bundle unpack status. +793ffb31a Introduce verify github action (#127) +5229f0fde Update generated deepcopy (#128) +17423d53c address review comments +83e793a9f Regen go-bindata for crd changes for OperatorCondition (#125) +b56cd6d61 Add `opm alpha init/render` commands. +4a4b236ab Add draft release info to opm release doc +728fe6a14 fix(sqlite): upsert deprecation table entries +fb14c70e9 Update 0000_50_olm_17-upstream-operators.catalogsource.yaml +46dab665e community-validator: improve msgs raised (#124) +2758fc261 Add polling interval for default catalogsource +b4feafd90 Add ConditionType to v2 api (#123) +34c4e15b9 Add conditions array to OperatorCondition's spec (#119) +96d494863 Update OWNERS (#121) +2c7ca5c58 additionals and improvements to dealing with deprecated API(s) (#120) +ac555acce fix(containerd): drop xattrs during unpack +18ca6d0a9 Remove component adoption labels before initial CSV copy. +260261946 Explicitly set `readOnlyRootFilesystem: false` on created registry pods. +9d79329a1 Filter secret names for registry pod's sa +a18d45953 test(sqlite): ensure tolerant bundle removal +2f16427ea fix: elide channels with deprecated bundle heads +be89f91ff Make ClusterOperator Available condition sticky. +76dfca71a fix race in test with mockRepo/mockBlobStore +c495b766c use snake case for catalogsource_ready metric +e278d003c Call cleanup sync.Once.Do +fc416f754 consistently use latest go1.16 in all workflows +3162de6ba feat(metrics): Emit metrics for CatalogSource state +a877d40f7 deploy/charts: Any monitoring configuration for the PrometheusRule/ServiceMonitor resources +9a7103a72 deploy/chart: Remove any OCP-related helm chart conditionals +063cace09 Remove the deploy/ocp directory +e2a220b11 Makefile: Remove references to the internal ART team +0c8e70b91 Makefile,scripts: Remove references to handling OCP helm charts/manifests +0812d1567 Add eventually to e2e test crud operations +bed4e3617 Add unit test for varying job timeout +e401c7691 Add unit tests for UnpackBundle +843a0c70c Parse timeout annotation before UnpackBundle() +e13938b97 installplan e2e test fixes +070268778 Add annotation to override default timeout +f41a3d389 Check for bundle unpack failure via status conditions +4c132b124 Cleanup e2e tests and add case for invalid bundle image +a454c1be1 Fail InstallPlan on bundle unpack timeout +864ad064c update readme to link to olm docs +28883598f Fix for resolution error on channels with deprecated inner entries. +4c43a0db1 Simplify deployment status check to reduce flapping. +ac935726e doc/design,Makefile: Remove references to root manifest directory +c5a18bacf Remove the root list of YAML manifests stored in manifests/ +22686cfb0 pinning apiserver for delegated authentication watch request bug fix +23aeccc97 fix(packageserver): add tolerant delegating auth config +93b0f7b1e add SetEscapeHTML method to declcfg yamlEncoder +0ca2008a7 always write yaml start separator +5140b438b improve test coverage in internal/declcfg +51c2bee14 revert WriteDir to use JSON, but keep WriteYAML support +8edc6b1d2 Set yaml.NewYAMLOrJSONDecoder buffer size to 4096 +cdb386159 Support and default to YAML formatting for declarative config +1b4115e48 fix(deprecated): don't verify deprecated replaces +bf53a57fa pkg/validation: set v1 and v1beta1 CRD defaults using the correct function +c9ccd5317 Annotate CRDs that are installed alongside CSVs. +2eb5deb4c fix(deprecated): add sqlite table and migration +cb99b9e2a Improve load func error handling to expose more information +b600ecfd5 Revert "Test for bundlepaths before deprecate" +e3de97a06 Remove OpenShift-specific Dockerfiles. +92d8ada89 Set reason/message for Available condition in packageserver co +b61df977a .github/workflows: Add the unit and verify workflows +266d9e291 Add -kind.verbosity provisioner option and reduce default verbosity. +f5881c0df v0.18.1 release +cbf398c9e Fix mishandling of log format strings in Kind test provisioner. +c67cf05c8 .github/workflows: Enable GH action that retests failed workflows +a0e7b1f45 bump kube-openapi to get validation fix +a1a7940e0 add unit test showing cr validation bug +1320da45f v0.18.1 version bump +6613a5042 fix(bundles): symlink cp at expected path +5b1c56525 revert api signatures +0d8f2542e check presence of all bundles before deprecate +61e76c4cd .github/workflows: Remove the e2e-minikube action job +f62f1b4f3 .github/workflows: Add action that emulates tide commands +507752940 Use DeploymentAvailable instead of custom test for CSV status. +5dbc27b04 Bump ginkgo to v1.16.1 and gomega to v1.11.0. +1f48edc02 Move config serve and validate to opm alpha +8105826d1 Add optional go-apidiff test to CI +8bb7f1b31 Force latest install of podman to fix currently broken e2e tests +58439d47e changelog for v0.18.0 release +67b3f1412 v0.18.0 OLM release +b23f0cf57 Delete operator-lifecycle-manager.Dockerfile +43cb5c042 Bug 1952238: Report catalog pod termination logs to catalog operator on exit +cfcb62ad0 replace dockerhub images on the upstream dockerfile +ebdc14c13 (bug) add after deprecation +fc7d1d8b4 bump OLM version to 0.18.0 +c0c4ecef7 Add unit test to verify resolver error handling for sync namespace +88e89fb64 fix(catalog): Reduce namespace resync in resolution failure +f684b8e2f Add retries when pulling images +138139926 Fix panic due to empty version in the ClusterOperator controller. +01549abe5 Fix resolution error if inner entry doesn't provide a required API. +19ef710b0 fix(openshift): prevent race condition in the clusteroperator controller +ff84b85e2 refactor(openshift): use a label selector to filter copied csvs +25b301670 refactor(openshift): use mutator interface directly +3723de2ba refactor(openshift): build skew message more efficiently +dedfd87dc refactor(openshift): don't rely on reflection as version predicate +a62b5294b test(openshift): use local timezone for timestamps +9714f2dc4 chore(modules): bump controller-runtime +b215ec29a feat: block openshift upgrades for incompatible operators +7fe6b78cb Replace codecov-action with vendored upload script. +c35e58db3 go.*,vendor: Bump the k8s dependencies to v1.20.6 +035012090 go.*,vendor: Bump the k8s dependencies to v1.20.6 +e4aea633e Update api version, vendor & enhance testing +f2cac5762 Add resource requests for bundle unpacker +d8acff403 .github/workflows: Fix error when installing podman +60f84a7d9 .github/workflows: Remove unneeded docker-env command +e40329f6a go.*: Update Go module version to 1.16 +69e7b9126 rename k8s optional key for k8s-version (#111) +ec8fd6b0b fix merging envvars from subscription.config +f21660dae add failing test for merging envvars from subscription.config +8af1635cd test(sqlite): ensure annotation property validations +3b409194a deduplicate properties from different sources +fa5e33209 feat(sqlite): accept any property type +d9622bd82 Revert "set packageserver replicas to 1 for single node" +8638cc766 adding --enable-alpha feature flag +6eb4fec2f (feat) substitutes-for logic +fbc23fb5d Always validate CR upgrade compatibility. +0adcd5413 Add time-limited retries to InstallPlan execution. +ebd301563 (opm) move add from root to alpha +d816f2c62 Add tests and fix bugs for declcfg server +73db35eac Improve the declcfg and model validation +dc1759e14 feat(validate): Add opm validate cmd to validate config files +85dbd598e Delete the symbolically linked operator-registry.Dockerfile +c9a4ae5ce add/modify e2e and unit tests +ca3b54c01 enable tests on internal package +0fc84d8e7 introduce space between blocks of code # Please enter the commit message for your changes. Lines starting +7f08e8d02 rename getNoOfBundles to countBundles in model_test +52dab5ec6 unpack and remove bundle direcotires after creating registry bundle +da16481a9 use OnError to retry bundle pulling job +c9a5f8da4 feat(declarative-config): opm add creates declarative configs +9a009c1fd Bump github.com/operator-framework/api to v0.8.0. +45f46a1ec Copy all CatalogSource annotations to its Pod +2218d9e64 Remove more testify assertions +346ea7b00 Fix e2e test with incorrect gomega matcher and remove testify usage +6639326c3 Add .status.message and .status.startTime to InstallPlan. (#108) +3ac7baf1b Consider InstallPlan phase=Complete as terminal +6d0c894b4 Clarify status condition error message, and update architecture docs +f1fb6d5de Add e2e tests for installplan failed on invalid operatorgroups +51722db91 Indicate invalid OperatorGroup on InstallPlan status +97e9c8842 Give more precise reasons for Subscriptions with no candidates. +062a42928 go.*,vendor: Bump to k8s v0.20.4 +829737ef9 add checks for operatorhub validator (#103) +e49b35527 add server for model.Model +13867a1a9 disown copied csvs +ec0560110 remove component labels when copying CSVs +aad84fdbe test that the operator api never adopts copied CSVs +d0b1a18d1 Preserve existing ServiceAccount owner references during installs. +24bb8bf1a update of api dependency to 0.7.1 +468b7a4b6 bump api version to v0.7.1 +c87cb8d48 use equalsDeclarativeConfig function in load_test.go +d574c2bb9 move newly introduced packages to internal +996ba15e9 declcfg_to_model.go: ensure package field and property align +4c5da9f6d pkg/(declcfg|property): PR review feedback +24e76ecf8 Avoid stuttering "mkdir " errors +6bae6a5ba feat(declarative config): add base packages +ff11b3635 .github: Separate the jobs in the test workflow into their own workflows +b9766f13b Update OWNERS (#107) +da28dd255 go.sum: Re-sync vendor dependencies +dd98dfc4f Update 0000_90_olm_01-prometheus-rule.yaml +779bc586c add CsvAbnornalReplacing alerts +dc9a25092 Bump test dependency on kind to v0.10.0. +e731b2c18 set packageserver replicas to 1 for single node +e5f917cd9 Dockerfile: Avoid hardcoding the kubebuilder version in the build root image +74cdc267e Fix inconsistent dependency candidate order. +7aa1ed5dc Allow to override download url in install.sh +d1b737042 remove appregistry-related tooling +e8d2a8e71 opm registry add: add --ca-file to add a PEM to the cert pool used by the command +0c6c0e6a9 Dockerfile: Add a symbolically linked release Dockerfile +b04bb16d8 pkg,test: Avoid setting metadata.GracePeriodSeconds to zero seconds +c85802a6f Update the template of PRs +c2c72f01d go.*,vendor: Bump module Go version to 1.16 +7b7bbe65a Dockerfile: Use Go 1.16 image tags +68089a824 Dockerfile: Add a symbolically linked release Dockerfile +fddf59338 test/e2e: Disable the bundle unpack opm e2e tests +bc1ae68c4 .github,Makefile: Add linting check against Golang packages +11e465220 *.go: Commit changes after running 'make lint' locally +f81b5ef6c test: patch existing CSV for a hotfix +db3d584af Update editverbs and Make the instruction clearer +a6b214075 Set labels for the operator Deployment created via the ClusterServiceVersion +cd1c5f8bf Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/e3b61ff1dde2bfc2bc7f2b5efdd155d1d3299cd7/images/operator-lifecycle-manager.yml +154810eea test/e2e: Remove duplicate package imports +7ae79f13d bump to Go 1.16 +45683368a test/e2e: Capture stderr output when checking for docker and podman +55eb49d81 test/e2e: Fix output log message when Podman is not found +c82343867 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/e3b61ff1dde2bfc2bc7f2b5efdd155d1d3299cd7/images/operator-registry.yml +15a28d424 go.sum: Run 'make vendor' locally +40d8800ef tools.go,vendor: Remove trailing slash in github.com/go-bindata/go-bindata module +88274df70 Add optional go-apidiff test to CI +ca77a30e7 Add skips & relatedImages to CSV Spec +b541208ae doc: moving channel naming doc to website +641e7a672 Bump github.com/operator-framework/api dependency to v0.7.0. +f01584a99 fix: add lifecycle/frozen tag to exempt list to stalebot closing certain issues +916683b54 Remove package msodbcsql17 during e2e tests +6b082c7c5 Bump all Go binary builds to 1.15 +7be30c83c Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/5a1293dd0f380abf50c12d65c36655486d7745d0/images/operator-lifecycle-manager.yml +a0805419f Support jittering relatively small resync intervals. +3d8c55bd4 feat: add cleanup phase; fixup cleanup api +44fd10578 don't change CSV phase on service unavailable error +f099052d1 Gracefully handle service unavailable errors from kube-apiserver +616ff1a37 Allow non-CSV-owned ServiceAccounts to satisfy CSV requirements. +4585a8d4b Use reflect IsZero() method for checking zero values +b5e404062 Add API for cleanup spec and status +11e774d2c Expand validation to annotations +862e31227 only override deployment resources when explicitly defined in subscription.spec.config +a00af2d07 README: Address markdown violations +55b8f4cf0 go.*,vendor: Update vendorered dependencies +7e5579949 Makefile: Add the tidy and verify subcommands to the vendor target +d02da0afe cmd,pkg: Deflate unnecessary conditionals +8f1266cf1 OWNERS: Update the owner file +1173b459a Infer package name property for unannotated CSVs, if possible. +ef8def4ca pkg/operators/v1alpha1/subscription_types.go: make config and resources structs optional via pointer +139232eff test/e2e: Revert disable Podman-related e2e tests +44d597863 .github: Fix Podman installation steps +fcfbe36ba Additional changes based on feedback +366dbe22c Changes based on PR feedback: +033c9ebc6 update makefile, workflow, and docs +c5f114658 pkg/controller/operators/operator_controller_test.go: fix flaky test +3943cfb40 test(e2e): add bundle unpack test cases +8c8d1d4f2 chore(lib): reduce log noise from image registry test facet +aaec691ce refactor(opm): export root cmd +3b1b713ca style(logs): reduce info log noise +3132dc1f2 feat(opm): add alpha bundle unpack command +29777953b upgrade to use go 1.15 +26f354450 Add details for starting a local server to README +13c7ffb24 doc: clarifies opm usage and what tool can help with bundles +76e40142b Deprecate initializer and registry-server +83d19536a fix: add apt-get-upgrade to ci script, skip podman-based tests until fix is identified +932b6e3aa Specify cluster name when there is only one cluster in kind +a25dcd2e8 Enable debug messgaes via klog +263f485fd Annotate manifests for single-node-developer cluster profile +48ec5419f Don't create default ServiceAccounts +82c261b55 bump to go 1.15 +7095864ed Update release.md with milestone step +8ef6f5f04 update development document to add more informations for the e2e environments +30b2627fe chore(adoption): use debug level to log missing components +9f853662c add missing closes +d4accff88 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/a74468426e8d0524b2fca64bbbcda77afef25b80/images/operator-registry.yml +eaf24068d docs/design: Remove all references to the bundle alpha opm commands +2da4d80f4 docs/design: Minor documentation fixes +e655c312f Fix typo in deprecate+truncate command help +811d94bc5 .github: Use the pre-installed Podman dependency +61838426f fix(resolver): Allow skipped versions to be installed initially +e143c928e Fix typo in docs +73af1b0d5 support multiple subscriptions resolving the same bundles +481ace0e5 add package property to unit test cases +04baa720a collapse resolver tests +bcba38ca5 Add meaningful string representations for resolution invariants. +7b1d7c443 Correct timflannagan GH ID on ownerfile +48c4d5f76 Update OWNERS file +2baf7110b Fix upstream example dockerfile +b14f6445c Various from PR comments +ccf62da0e fix(index): add build id ordering to channel head selection +53f9e5d60 test(e2e): make index add regression test pluggable +d7a06e9b1 (e2e) regression check with existing catalogs +17be23411 Fix OperatorGroup Documentation Example +82208735b bump k8s.io/apiserver for webhook auth panic fix +12d8f6087 Clarify subscription constraint strings in resolution failures. +7f96a43d0 fix: use none driver without sudo in upstream minikube e2e tests +fa7e4ae16 fix e2e test order +27fda6b2d Address comments from PR review: added e2e, improve unit +7e6df5b5f operator_controller_test.go: use JustBeforeEach to ensure correct test setup order +494108d49 Only re-create operator resource if it has existing components +d23ea4600 Add unit tests for Operator controller deletion handling. +6c6fb2899 Fix time comparison in CSV reconcile loop +edc880a4c Fix zero-delay resyncs for certain registry update policies. +a70ff7077 Use docker driver for minikube installation test. +e29631dea add shorName for operatorcondition +707d3f3cc fix error on missing icon +afc259b0c fix: improve stalebot configuration for github issue tracking +0e2b21d73 feat: use secure local registry for e2e tests +ff436d69e Fix infinite loop when a CSV replacement chain contains a cycle. +07f0ac6fa remove stranded bundles when packages are pruned +735ee792f ensure foreign keys are always enabled +06e1e2a4d RELEASE.md: add release guide +5aee47837 chore: bump c-r to 0.8.0 +5285b1a00 Update shields +632899a01 Bug 1909992: Allow private bundle images within private indexes +5efeced30 Update OperatorCondition controller to watch deps +5b1df68a3 fix: create installplan directly in e2e test +f77b94158 fix: use OLM client when installing CRDs +ce1b12b52 fix: load required docker images for kind cluster in ci e2e test +ba696f755 Add joelanford to OWNERS as reviewer +8a8c81973 Create CSV Deployments with OpCond EnvVar +bd07f8ee4 Fix operatorcondition role verbs +c5b60fc76 Updating Dockerfile baseimages to match ocp-build-data config +6e2197ef6 fix: update moby/term dependency due to undefined: unix.SYS_IOCTL on macOS error when running locally +5b3b80ee2 Use correct caBundle for 'olmcahash' annotation +fb76eec77 Update /manifests with default cluster profile annotation +7a8ee9480 Add the release annotation to all documents in all files +2e03006a4 Change the "OperatorUpgradeable" condition to "Upgradeable" +5d5c64d73 Multiple operatorconditions should not update the same deployment +94359f6e3 CSV Annotations override pod annotations +c161839b3 Reduce e2e test failure rate +4de7d447f Fix windows build with golang 1.15 +d58361049 Update manifests +d59dedc94 Fix manager start commands +0053fea4e fix zap logger +da304188e Fix controllers and run codegen +764b474dd Update semver import and update SSA +9a1c2a17e bump k8s deps +11056a829 Rename OperatorUpgradeable condition +669446027 Bump k8s to 1.20 +c8515dfc7 Remove operatorCondition lastTransitionTime +0285acc3a Bump yq dependency to v3 +f0194d13c deps: bump k8s deps to v1.20 +f99f433ed Bump controller-runtime to 0.7.0 +324003da5 feat: move upstream tests from travisCI +6838951ab cleanup formatting +5aa8734f1 initial channel naming doc and related images +f94e87c08 fix(olm): Verify ServiceAccount ownership before installing deployment +93be770da Don't create OperatorConditions for copied CSVs +b03509597 Reduce log noise from OLM +7a20b814e Update go version to 1.15 +059877eb8 Preserve original .status.lastUpdateTime in copied CSVs. +13753d676 fix(e2e): Fix subscription manual approval flaky test +fcc5fd1c8 Add OLM support for the Upgradeable OperatorCondition +af0f41914 Avoid duplicate registry binaries across downstream image layers. +8dcf48819 Disable broken ppc64le and s390x release builds. +89c288ed9 Change OperatorUpgradeable type to string and add utils func +325f42b01 revert the change for e2e test +488b082c8 format the import order +d0820446a Only check the owner of the service account if the service account has owner +9da07b24f update e2e test +768fd9e65 check the service account owner in the requirement check +2c267134a Introduce OperatorConditions +c3fee72a0 update manifests +a1ddc4487 Add authentication for private index images +87107d326 Support InstallPlan steps upgrading existing ClusterIP Services. +6d779af35 fix: remove extra test output +42670177d fix(index): account for default channel in index add order +3c33a9606 Include the bundle image itself as a related image. +d3f6dd79b Add OperatorUpgradeable condition type to OperatorCondition api +cc2b7c1a5 Update OperatorConditionSpec +546ab4200 Add release annotation +6d6e033ae Bump yq from v2 to v3 +fac7d135e fix(catalog): be defensive about directly indexing catalog pods +7f4070d4b feat: bump api dep to v0.3.22; add support for operatorhub and bundle object validation +e17260bb7 (fix) make operatorhub validation consistent with courier +d6f5336d1 Add OperatorCondition to the client schema +ef2af7725 Update github action setup-go to version 1.1.3 +c9f5f4458 add default label to issues. add config file with upstream OLM contact information. +151dc90b4 Using subscription reconciliation to clean installplan status instead +b3a1a0419 fix(indexing): respect strict mode +84dac3d16 fix(ip): Recreate pending installplan if deleted before approval +51c28582e copy .git directory for build tag info +dc0d980c1 fix(indexing): pick channel heads by semver +b41ee2c64 fix(indexing): order bulk add by version field +979806dd6 Introduce the OperatorCondition CRD +d1aac6955 fix the description of validation "RegistryV1" format +1d96b8e4e Add ConsoleYamlSamples to the supported resources +decf662ab Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/f82a216a6a3707b80a635bace9367f1a8288b7a7/images/operator-registry.yml +81cff1941 Generate code +8720918a1 Bump k8s dependencies to v0.19.3 +25e0cbb07 Reconstruct replaces and skips for ListBundles from channel_entry. +b6684c289 add skippatch unit test +90975862d Bump k8s dependencies to v0.19.3 +d55da101e Bump k8s dependencies to v0.19.3 +19a41f8e0 Allow ConsoleYAMLSample resources from bundle manifests +20fc6ffe6 test(certs): add a test the ensures services do not get the same ownerref added twice +060718c64 test: scaffold a basic unit test for certresources +f6a331a49 chore: generate fakes with inline go:generate directives +0f182b191 Fix Go version used by release job to 1.14.z. +6f9738842 (fix) close connection to db +88c437768 fix the comment in package-server +f0812c733 Generate changelog for v0.17.0. +fd6cee1aa Replace assertions with Gomega's matcher library +ec6a7f61b Add unit test case to grpc and configmap reconciler test +a8d2e90b9 Add spec hash to service's label to ensure service is correct +769dc4188 Generate manifests for v0.17.0. +39d593c0b Bump version to 0.17.0. +a119a3fa4 Build upstream releases with Go 1.14 instead of 1.15. +54ce01380 Produce opm linux release binaries for ppc64le and s390x. +9c82927c3 Convert scoped_client_test to ginkgo +21b32d630 Add Github Actions release workflow. +77dc76369 Replace assertions to use Gomega's Matcher library +551710c0c Set default, min, and max values on Webhook ports +cb6b1d2af Completely populate test database before executing tests. +179e088f6 Remove unused file. +f8255e1ce Add coverage report job. +33f55c76a Set replaces in ListBundles query result using channel entries. +f356b0e8f Default containerPort to 443 +57e9578e9 Set min and max values on Webhook Container Port +7dfdd7be7 Start listening on test server port before running tests. +4997cfb82 check prerelease version for semver-skippatch mode +0897133be feat: support custom categories via environmental variable +244aaf8ff fix(opm): properly deprecate export flag '-o' +c732109dd fix race in Operator reconciliation +7596881d7 Fix path separator in generated bundle Dockerfiles on Windows. +fe312f353 prevent no-op hotlooping on Operators +6f40c1a40 Add writable workdir to configmap registry image. +8a5966ec3 Fix test flake based on random aggregate error order. +60d2d4fe5 fix typo +7fd3d1c50 Update pkg/controller/registry/resolver/resolver.go +00513f578 update error logs for channel head querying +0dcdb4393 OLM mounts CA Certs where Kubebuilder expects +6c24a1f32 Make the inability to create /etc/nsswitch.conf non-fatal. +d25fe21a1 Improve transitionCSVState error logs +27ba9bdc9 fix typo in the error message +2c61ceb05 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/ac81dd4ff0bd57c4e75058d25b40615b92948259/images/operator-lifecycle-manager.yml +3d2cf4608 Retrieve CA from conversion webhooks for CA Hash +da043a289 fix: remove extraenous manifest assignment and update CRD stepper. Add e2e test to verify configmap-based manifests. +bef8c443c (fix) concurrent writes during image pulls +7677c9bc1 fix(dockerfile): clean out tmp directory after binaries are placed +ef2491b3a update the help info of the export subcommand +0c8f594f2 Add USER for non-root image usage +6c0a0d50d fix the comments of LabelDependency in the type definition +c57ff1627 OWNERS: add operator-sdk reviewers estroz, joelanford, jmrodri +645a16bfe LICENSE: add apache 2.0 license +7cbbcc6a0 fix: pass in bundle objects +c29c22ddd Apply suggestions from code review +4214b5b76 doc: add reporting bugs doc and small nit improvements in the README +168a521c7 Regenerate downstream InstallPlan CRD manifest. +b9007041b Annotate CSVs with the properties used during dependency resolution. +29b8930fc Bump operator-framework/api dependency to v0.3.16. +a35b39491 Enable default channel inference for the first bundle of the package +122b2bc9f Update upstream-builder.Dockerfile +72a18659f set group permissions on /tmp +5e0108fdb Bundle validation will not fail if default channel is not provided +e5f271bd3 feat: bundle object validation +0be88d2c3 (fix) bundle inference should not use skiprange +a44127257 Update index add func to handle optional default channel +8b61e24a8 The default channel info/annotation is optional & not required +a11896d41 (fix) erroring when replacement not found +b81f31383 fix(mockgen): use "go run" in all go:generate comments +086ae52a5 chore(modules): bump k8s deps to v0.18.9 +fa2556e4e (fix) index add --overwrite-latest +95314797c Add a "properties" field to bundle lookups. +468c3c76d fix: update check from previous polling implementation +4dcec936a Make a subscription without at least one candidate fail resolution. +b21763379 Allow ConversionWebhooks to define targetPort +2e631d704 Bump operator-framework/api dependency +61df859c0 Add ConversionWebhook const +37ca92f33 Update CSV WebhookDescription struct +3a6af663a Add test to verify empty bundles in addition does not break +81af525f8 Updating Dockerfile baseimages to mach ocp-build-data config +04824ccbe Updating Dockerfile baseimages to mach ocp-build-data config +efd42bc92 (fix) csv name should not be constrained +686d3a407 should not compare if no imageID +a42167a9d doc: default polling +ff98a69a1 OLM should use valid CA certs if available +e4269e01a Parallelize opm index export +5eedba91b Use vanilla Alpine instead of Alpine+go for the registry image base. +1d2129a4b Use multi-stage build for registry image. +5c661c151 add cross build back +4b5509802 disable cross compilation while build issues are resolved +cc8755292 fix: update catalog pull policy to Always in case the image is not digest-based. +157b0484c fix(build): copy bins to a tmp directory first +2eb1f3d2d add workdir permissions back +f5ad42fb8 fix(operator): map top-level csv phase to component conditions +dc804f685 add correct polling interval based on modulus +a7d23bf42 fix: resync catalogs with jitter if polling enabled +d12d8fac6 test(install): expect revision history = 1 +e34afec44 fix(bin): don't overwrite /bin +6eb8bdb36 Set RevisionHistoryLimit per Deployment +b21979282 fix: remove catalog update pod if it's in a failed state to prevent cycles in the catalog reconciler. +6dc415fa4 fix: requeue catalog source sync if update pod has not reported ready; remove duplicate pod immediately after imageID check; turn down polling logging +0e349b031 Handle mutliple skips and add unit test +92702cdb3 Add skips information to Operator representation +bff757fad Genereate 0.16.1 changelog +360e63d99 Release: Generate Manifests +78887a8e8 Bump OLM Version to 0.16.1 +470b5332f add mac and windows binaries to the amd64 build +34cb22d2a [typo] fixing typo in deprecatetruncate command +21f4a58df Update OWNERS +019bb4f17 Update OWNERS +ac0912068 Update OWNERS +4ae40219b Updating Dockerfile baseimages to mach ocp-build-data config +d1d830210 Updating Dockerfile baseimages to mach ocp-build-data config +946761b44 Move server side apply patch code to library, use ssa to update catalog source pods +ec857b743 Update Owners file +51d3a32ee Fix install plan creation for subscriptions that omit channel. +32ca0cdf7 Bug 1861605: Update manifests to include the bug fix +9e0f1375e Bug: Fix nodeSelector subscription config override +eef955cbc set default for flag --skip-tls=false +911539782 extend skipTLS option to podman +7f7dbdfa2 skip TLS option for pulling indexes +ae7d9120a fix: add dashes to semver range example +0c5049015 Fix typos +8bde9e6b7 Remove label dependency from bundle docs. +a816903e9 Return empty properties and dependencies in ListBundles responses. +3774ef812 rebased +ccd715c54 Fix stale content in configmap due to stale bundle image in the node +90752efa1 fix(operator): re-adopt manually disowned crds +4fbd74dec Add Total Test Number to report +de74109b1 Bug: Fix SubscriptionConfig NodeSelector field +6a0274b09 Bug Clean up stranded bundles +f5e963450 Bug 1861605: Reduce length of explanation of status of Operator resource +851e6372c Bug 1861605: Reduce length of explanation of status of Operator resource +0bb7fbb26 Approval: Clarify possible values +dc85a9fca [docs] Update out of date compile step +1e0277f22 Add Catalog Source priority for dependency resolution +1881123f0 Vendor registry 1.13.6 and fix unit test +42aebb4f1 feat(resolver): filtering deprecated bundles in resolver +d75bf5b5a Add unit test to resolver for label dependency +5acd71446 Vendor the registry changes for label dependency constraint +f9beec09c feat(resolver): Add label dependency type to new resolver +72242c1e7 test(e2e): pass ip test w/ created or present steps +6888cfaf6 feat(operator): adopt referenced installplans +e979fe72d remove legacy resolver +0a16d8810 Remove spurious check for duplicate operators in resolver. +9058508ba Addressed review comments +bb0a0f6cf WIP: Add Conversion Webhook support for OLM +b5fb6addb feat(registry): add graceful shutdown to grpc server +64105c14e fix(query): return bundles in all channels +e9c56be94 Remove unneeded toleration from catalog source pod +8a4e5c0cc change default catalog to index image +d07eb3000 chore(vendor): include v1 operator api version bump +ccd092a6f feat(operators): reconcile v1 operator resources +5a84ea9f1 chore(manifests): add v1 operator crd spec +1a787a400 chore(codegen): drop v2alpha1 clients/listers/informers, add v1 +17681e567 chore(scripts): drop v2alpha1 from codegen +a9fb39fa3 chore(modules): bump api dep to include the v1 operator spec +ad0f19536 Add OWNERS to the repo +c5a823429 remove scheme-related variables and scorecard output coloring +91288de53 pkg/apis: add scorecard v1alpha3 API +ac6994ec7 fix(codegen): add doc.go in operators/v1 to support informer-gen +5e62dafb8 Remove unnecessary ENV directives from base.Dockerfile. +e99d787a8 Remove sanity check from `make all` +783aefd1f Add sanity test for opm registry serve +1ed1a96c0 Add timeout to opm serve +136c18a16 Update label property extraction from CSV +bff982857 feat(registry): Add label dependency constraint and property +d003cf1d0 Adding deprecated property type to bundles +cb6f21038 fix(validation): Remove default channel validation from bundle lib +63cce5ae6 Add installMode validation check for Singleton Operator conversion webhook support +8d7b00722 feat(operators): move type to v1 from v2alpha1 +d2f0ea29a configure metrics for new resolver +c28661f79 check for cache consistency issues when querying for a dependency +192d912ff look in all catalogs when no catalog specified +49e86eb54 emit events when resolution fails +bdd657c08 fallback to standard path for kubebuilder assets +46336752b fix catalog grpc connection state updates +1d166e551 don't include docker image in the docker build test for kind test runs +3d694b8ad fix crd upgrade e2e test +7b09cff19 retry for flakes +83df7b503 make catalog delete tests less flakey +8c7ba08e4 add a parity test for transferring api ownership between operators +e40737846 make catalog updates in tests less flakey +e3818f4eb update package anti-affinity test +230e372a0 properly handle solver invariants +78c6e5598 track existing CSVs without subscriptions as mandatory +c9d43d87b handle csvs that are already installed but don't have subscriptions +f7f1c8324 extract properties/dependencies from existing operators in the cluster +6dd346244 Fix check for whether or not a sub was added during resolution. +1957d2295 Prefer bundles from the default channel in resolution. +15b28d240 Try to detect kubebuilder installation path if not explicitly set. +d266a043b Regenerate registry client test fake. +84be8a7db Bump operator-registry dependency to v1.13.3. +eb1a04e90 deduplicate input installables +7645e4dac expire cache when grpc connection is READY +831775936 fix sorting of inputs for dependencies +1860af04c enable new resolver by default +7a8fe42ca prefer the same catalog for dependencies +57393d6b5 fix resolver bugs, fix cache race, and re-enable tests +25ea8f9d7 fix nested dependency resolution +994a99dbf fix verify +67d71af7c feat: add parity tests to resolver +337404579 ensure cache is filled with content before marking it as not a miss +3c06499df renaming / refactoring +39ffac870 rename solve package +d9997fdca treat dependencies generically +2ed0cfd1f refactor dependency walking to avoid recursing +44d01f714 support skip list in bundles +182df8da0 support startingCSV +55b96e301 pin etcd and grpc +db629d470 split old/new resolver and tests +bcad82a53 test updating to a package with skiprange that is not head +6eada4168 search for operators in catalog order +d7babec9f move csvname filter to a predicate when finding bundles in the cache +884c46a9a use cardinality-based AtMost constraint +4bb534d06 resolver can resolve updates +6773de588 chore(deps): bump operator-registry +96affef98 don't mark virtual package nodes visited +fe4783f25 Decouple filter predicates from the operator cache itself. +f3990cc8f memoize bundle walking +330eb5cf3 support semver ranges +33d513011 use new solver interface in satresolver +615acdeb3 Adapt resolver unit tests to run with both implementations. +86de75273 Fix unit tests and add GVK dependencies extraction +f530effb4 Strip plural from APISets in resolver cache +9387be67a Extract dependencies info from bundle and add to Operator object +a1a1a06bc (feat): Add sat resolver for version dependencies +ba343e0bd fix(install): account for installplans when calculating generation +9af80c094 [metrics] Dependency resolution metrics +4d366b0f2 Added .spec.priority field on catalog source +31bd7cf90 fix(query): list bundles would elide all but one property +a1a738e85 Add busybox-dependencies-index image manifests +c135637d3 Add conversionCrds field to WebhookDescriptions +c9373188c Add additional logs to syncCatalogSources +0eae770a7 fix(e2e): pass build tags to e2e +7752f02ed fix(dockerfile): remove unneeded static dependencies +4f1e14251 Bug: Fix incorrect deployment annotations +78eec1b59 fix(installplans): GC older installplans +cb19971fc Remove nonexistent group from Dockerfile +9547d6da7 Embed version at link time based on git tags instead of a file. +3fc237a52 Require csv spec.Version to be set for operatorhub +097257259 Add flake analyzer +068c5c6b6 fix: explicitly delete collection of catalog source pods in grpc e2e test +a058b02ff Add GetPackage to the client interface. +31aa9d2b7 Update OPM_VERSION +530d21cef Update the e2e test case +54ff40064 fix(resolver): Exclude all installed packages in dependency search +70b28137b Omit (hopefully) redundant yum update from downstream builder stage. +69ecef260 Fix UpdateSingleExistingCRDOwner test case +3872318fd Fix validate CRD compatibility check and deprecated CRD test case +5bfbcf4cb Return an error when solver input contains duplicate identifiers. +6864de30c fix: use server-side apply in crd e2e test when changing the subscription to point to a new channel to avoid transient object modified errors +689a8eb5d Refactor solver preference searching. +e3f56352c Updating based on feedback +dbab66ca8 Bug 1855088: generate unique role and binding names When same permission rules are defined for different ServiceAccounts, OLM would generate same name for (Cluster)Role and (Cluster)RoleBinding related to this rules. This change should ensure that unique names are generated, taking into account ServiceAccount name and CSV Name and CSV namespace (for ClusterRole) +772f603d8 Bug 1855088: generate unique (Cluster)RoleBinding names +ee5da016a fix: remove bundle e2e skip +57d58cdea fix: Use PR head commit in artifact naming instead of merge commit +31375e585 fix(metrics): query cache found object count metrics +e2f65700e Setting resource to plural in relatedObjects +f1c227a6b test(e2e): delete all subs, installplans, catalogs, and csvs in test teardown +7e80746bc fix(e2e): make problematic test specs eventual +fda6d7a4a fix(e2e): copy rest config from test ctx +14d0618e0 fix(csv): prevent duplicate service ownerrefs +18d6a8e02 feat(operator): automatically adopt generated resources +af199f79d fixing up to return exit codes +2cb8d1e16 Changed address for readiness probe and liveness probe on registry-server +079a5b156 fix: install VPA CRD directly on clusterfor bundle e2e test. +5f0093093 Adding sanity check and error message for inserting the same bundle +a0ecedab3 Updating: adding sanity checks before insert into index +fc5e1f301 fix(containerd): always [also] pull layers from linux/amd64 +c1f261542 fix(validate): pull bundle images before unpacking +15a3cdaaa test(e2e): skip bundle cr install test +45feebf6f Use go env to get architecture for building +6a35e8e67 fix: add installplan check after subscription status check for gc tests. this will help reduce the e2e test flakiness as resources were sometimes checked before the installplan completed. +605ab3a58 Add Label field in StrategyDeploymentSpec +dc451bd4b fix(build): don't set -race when testing on s390x +a79b14ea6 feat(api): add skips/replaces to listbundles api +75747a16f fix: checkinstallplan status in bundle e2e test +7b2414489 fix: add kubebuilder to development requirements +b5d5ad0fd fix: broken link in PR template +54fbe6c3e Add an AtMost cardinality constraint to the solver package. +513b7692f Retry update in flaky test of CSV w/owned API Service. +54783684e refactor(solver): small naming changes and iterative search +993ee6b8d pkg/lib/bundle/generate.go: add JSON tag to AnnotationMetadata +e0db8e7aa Introduce preference order for solver. +ec56ad20a Bump GRPC version +52c0daeaf feat(release): add builds for s390x and ppc64le +753a5befa fix(opm): refactor indexer +b941ade64 Use /. as the directory root to copy from. +e059c5169 feat(deps): nest dependency values +4d2c6f0c3 Add workflow to save e2e test artifacts +837dc61a1 feat: support new bundle object types: priorityclass, pdb, and vpa objects are now resolved from the bundle by OLM. +39f1516cc test(e2e): patch installplans w/ server-side apply +ea09a5de0 feat(store): store provided apis and package info as generic properties +9b44e17eb fix(docker): build grpc probe outside of gopath +59e6e640a Update OPM_VERSION +21586e294 Separate build/pull tool for index rm +36e7c25a2 feat: add design docs for including additional objects in bundles +8007c0a70 Bug 1822396: Update metric when Subscription is updated +af4220200 feat: add pdb, vpa, and priorityclass object support to registry +2d7f37c31 (fix) Update to go 1.14 +bdbbb1ab7 Update OPM version to 1.12.6 +f71745996 chore(deps): bump containerd +ee0184cda fix: update README to point to the OLM book website instead of github repository +d1e86c8fb Add more precise matching to the metric end-to-end tests. +f011476a5 Update ocp manifests with latest template +cd14be584 Remove failfast from operator e2e test +51be87a6e Fix a flaky CRD test. +e5aafa2b2 Replace assertions within async assertions. +4922e6a10 Disable parallel e2e-local runs by default. +03f574cac bump olm version to 0.16.0 +7ebea2fd6 Add operatorhub validation +98a747d0b fix(installplan): don't store the manifest contents on the installplan +01366b6dd (fix) Actually validate csv fields +c2351f888 fix(crd): Fix CRD validation falsely error on unused CRD versions +fb747a938 Bug 1822396: Delete subscription metric when an operator is uninstalled +d1f76ebd6 Bug 1847540: resolve only default channels +e08860c65 Add BugZilla component to OWNERS file +41c23a17b test(server): wait for connection to go healthy before running tests +389929591 Fix broken link to CONTRIBUTING.md +4947764eb pkg/lib/bundle/generate.go: ValidateAnnotations does not compare number of annotations in existing vs expected so arbitrary annotations can be added to annotations.yaml +53873646e beta.kubernetes.io/os deprecated since v1.14, removed in v1.19 +799b23560 fix(package-server): get icons from default channel +59bfb459d doc: add CONTRIBUTING.md +5c4db409d chore(modules): bump api dep to v0.3.7 +112d8a6f3 fix(copy): make tmpdir relative to current directory +300881afb fix(images): use docker/podman create and cp for exec unpacking +bb6d23e0b chore(crds): regenerate manifests to drop status +318728664 chore(make): drop generated crd manifest status +d551f752c chore(make): rename yq var +0ed21428d Update OWNERS +368b298a9 The api repo is now pinned to the latest commit which contains bugfix https://github.com/operator-framework/api/pull/39. This update also removes the bou.ke/monkey dependency that has a very restrictive license. +7bf9f1d5d Modify prow ci logging for e2e tests +ed140c71a feat: add uninstall +bb33e2451 Changelog for 0.15.1 +4914787af Update grpc-health-probe version +f304d2ab6 [e2e] Fix opm test +cb54b5ba4 validation: bundle CRDs are compared by definition key instead of name +bb93d81f8 Add test for release installation instructions. +0dfd78134 Remove CRD manifests from 0.15.1 quickstart's olm.yaml. +186d25e1f Preserve .crd.yaml suffix for manifests copied from api. +87034d380 Don't put CRD manifests into olm.yaml. +e098dd067 Catch failed Ginkgo assertion in test goroutine. +7441b9ce3 Reduce install.sh flakiness. +84189d5ab Convert metrics_e2e_test to ginkgo +55e76d51a cleanup: delete duplicated import in olm +d6234be9b feat(resolver): don't build new clauses for weights +be95e235f add info over where the bundle files are or will be written +69b2ebe65 fix: add err check before defer +8b53b9833 chore: fixed a typo in bundle manifest format +1481b4d94 docs: remove typo from dependencies example +d9fdb9d99 feat: add OPM_VERSION notes to release docs +cf9e51091 Doc: Remove legacy webhook proposal +6f433623d fix: add check for storage version changes when installing CRDs. This prevents data loss when a CRD is upgraded and no longer supports existing stored versions of CRs on the cluster. +438fcd1bb fix(unpack): support unpacking readonly folders +b107cf050 pkg/manifests: return error if a bundle manifests dir has a subdir or hidden file +ac74d6004 fix(catalog): no operatorgroups in a namespace should be an error when resolving +0d0e77a06 Update PkgManifest upon catsrc update +cdaed1d40 pkg/manifests: use yaml decoder instead of unstructured to avoid conversion issues, and close all files +50cef154c Configure "podman build" to produce images with Docker manifests. +3a9f54f27 Fix delay when OLM applies label to Namespaces +ae23a0e48 opm bundle extract shouldn't validate annotations +597eba274 Add more comments on e2e test case to clarify test flow +01ce79c53 fix(server): make a copy of the db before migrating it +296568bed Address feedbacks on registry client interface +a47ce37ec Compose registry client & interface under a new interface +b531ac38f Add e2e test case to test multiple dependencies with same package +5b1aaa72f Update unit test cases to adapt to new changes in NamespaceSourceQuerier +291bd4c98 Edit test cases to work with new changes on NamespaceSourceQuerier +6d0b88590 Mockgen for registry client +b910d5e18 fix(resolver): don't pick operator from same package when resolve requiredAPI +ac1f2e5c0 fix(webhook): Wire ContainerPort to Webhook +925b4d514 Remove registry dependency +3e77564e6 fix(validation): Fix CRD v1beta int-float conversion error +07c7d7560 WebhookDesc should use containerPort field +5694cbbab fix: add ownerrefs to bundle objects; add e2e tests for bundle object gc +815da1c84 Manifests for OLM 0.15.1 +ce80022d5 Bump OLM to 0.15.1 +96e55d50b Deleting a CSV removes related CSV metrics +83510c270 Changelog for 0.15.0 +27b597d66 Pod Config Deployment Hash Error +5c2bdcfd7 Manifests for OLM 0.15.0 +2912b3932 Update scripts to include crds during release +dccdd506b Converted packagemanifest_e2e to ginkgo test +e0771b9d9 upstream-opm-builder.Dockerfile: don't install bash; sh is sufficient +3012ff6ef PackageManifests should include CSV Metadata +28e173ea2 fix(queues): requeue events against all-namespace queue if present +7ded3a39a Modify dynamic_resource_e2e_test to ginkgo +62d656e9f Update Webhook E2E Namespace Labels +d85d5ea3e upstream-opm-builder.Dockerfile: add bash and ca-certificates to runtime index image +ce0084039 feat: add build flags to opm to show version information +43b923e91 Adding error message for more than one CSV in bundle dir +5e262241d Convert gc_e2e to use ginkgo +ccb44f523 Detect WebhookDescription changes in CSVs +f4f1061fb feat(opm): add version command +496e6820c Make default channel optional +f5155ff43 Make default channel optional +48bbe2d08 Bump OLM version to 0.15.0 +be5bab281 (fix) Admission Webhook names must be unique +6a6c3e9d2 Fix upstream.Dockerfile +bc0cc96bb Update OLM to use UID for OG Labels +ba44be8c4 Update CSV Validation +fede0f0e6 Update Webhook Installation Failure to be generic +a48013449 Update WebhookDescription struct +66c5f2ed2 fix(auth): use fixed containerd authorizer +d3c22d214 Move bundle validator back to registry under validation package +5276ae623 fix: use runtime.Object instead of interface for CRD return type +768e7d2b9 Remove Bundle validator from the validator list +a8c2049af validation: bundle CRDs are compared by definition key instead of name +46ae2d03f feat: add test for v1 CRDs in registry bundle +02a152557 feat: Enable v1 CRD validation in bundle library +8d507d50f feat: support loading v1 CRDs into index from a bundle +0e58e0d40 Split build and push command runners +e4f0814a4 (bug) Always overwrite local db when copying +03c562cfa Update OLM to use UID for OG Labels +2f95c9b37 Clarify log message to indicate that dependencies.yaml is optional. +7dce17776 *: bump to k8s v1.18 +610df2273 refactor(crds): decode to v1 directly w/o conversions +eb7e00cf5 fix(types): Fix GetDependencies func that returns duplicate items +59bc8f83b fix: address sttts feedback +5b96c24c1 fix: support creating v1beta CRDs to avoid data loss during conversion to v1. Due to data loss during client side conversions OLM will support two different paths for v1 and v1beta1 CRDs. +7871e6486 feature: opm (index|registry) prune command +69e95d8c3 (fix) Use opm builder image for opm indexes +2b401d2c5 fix(resolver): Transferring API Ownership +69945af22 Fix Operator Generation code +622564c5e Bug 1820438: Slim down upstream builder +7b2ffe887 test(e2e): correct tls detection in metrics spec +6cb639fcd test(e2e): make operator resource creation eventual +2fb9d9aab test(e2e): simplify csv requirement event spec +97901a1f7 chore(modules): pin controller-runtime to master +53c28b19d chore(manifests): include double-hyphen olm deployment options +3960780e2 fix(client): supply missing params +3af4abf06 test(operator): gracefully stop test controller manager +2aeb3505a fix(operator): swap top-level update for status update +4c8e489ad feat(operator): enable configmaps to be operator components +eefb21697 test(lib): add unit test for metav1 time conversion hook +98a6871d0 chore(make): use existing kubebuilder installation +db1af5dd0 chore(logs): set manager setup log level to 4 +9440e420e test(operators): add e2e test for the v2alpha1 operator resource +2fd8cedb2 feat(operators): add v2alpha1 operator controller +faf929150 feat(opm): add unprivileged index extract +caa685961 fix(indexcmd): use a separate directory for unpacking a previous index +ffb2bf284 Address the metadata read files loop to work regardless files order +18bd22456 Add an operator cache for use by the resolver. +8f55d0ab5 Add unit test cases +8e445b144 Add Validate() for each dependency type +338cba6a7 Add dependencies validation +fc2490b71 Add dependencies.yaml validation to opm +994d99697 chore(api): switch to operator-framework/api +36401b385 fix(secret): use a synthetic kind instead of an api field to determine bundle secrets from pull secrets +9919c4dc4 chore(make): copy crd manifests from apis repo +c0c6a63ea chore(deps): bump to kube 1.18 +d68232e1a Fix failing E2E bundle unpacking test. +b7aea1e95 Add initial SAT solver package. +11b26af18 (feat): Bundle commutativity +452c04c2a feat: support secrets from bundle +8d30b2913 fix(schemas): remove installplan generation field requirement +00b5fac1e fix: add empty go file to packge to fix make verify +3008b35ce Fix panic in AddToRegistry when using podman. +f29b17b0a feat: support v1 CRDS in OLM. Simplify InstallPlan Execution via new Stepper interface. All CRDs will be converted and handled at the v1 APIVersion. +2624d1f97 Regenerate the chart embedded in the test installer as needed. +e891fac25 fix(index-add): docker index add failing +3511cbb9b chore(gh-actions): install conntrack before minikube +47f57a912 fix(docker): include util dir in upstream image build +a56d8a0ff test(gh-actions): add upstream image build test +195fd70cc Add ListBundles to the client interface. +00938978e fix(query): ListBundles returns all bundles even without dependencies +4b8be0343 fix(registry) Update the addDependencies to add requiredAPIs +a75d99c1e OLM Support for Admission Webhooks +79b39c1b0 Move APIService to installer +e2d6e343a Added Github workflow for running e2e tests +fa1f8a40f fix(add): allow containertool to be specified for registry add +0211a173d chore(docker): add kubebuilder to base image +6ed6cd70d fix(crds): add missing status subresource to schema +022c73e09 bug(opm): use db dir when modifying existing index +9644be3cf Address feedbacks (second round) +3d24b440e Add BugZilla component to OWNERS file +22092a80c feat: support configmap creation from the bundle +1a2969719 fix: use busybox csv for polling e2e test +e5d708779 Address feedbacks and fix test cases +32c04f650 Update OG and CSV for Webhooks +fb3addd35 fix(operators): add missing v1alpha2 types and update crds +a610ef24d Codegen for registry API changes +d6987d37f Add bundle dependencies specification documentation +9026431f1 feat(registry): Add operator version dependency metadata +f40eff62b fix(load): shouldn't clear bundle/csv field from non-default heads +31c0743e6 fix(operators): sync v1alpha1 types with olm repo +45e9423c9 feat(crds): add unmarshaled convenience getters +7c64f8b89 test(e2e): login w/ docker first to prevent failures +c52863016 feat: add support for configmap and secret objects when generating a bundle +c7eefdc83 bug(opm): packages flag on registry rm required +e25ff74c4 fix(imageloader): image loader should consider existing channels when adding to an index +51b00418e (feat) Add semver insert mode +bfb349d84 chore(deps): bump to kube 1.18 +20e115c73 chore(crds): add crds and manifests make rule to generate them +885a59229 chore(travis): add conntrack package +40b0dd25c fix(populator): set bundle name +dbbacff0b fix(populator): put correct argument in decode call +33b090c64 Create APIService after API server deployment +5e7dcb8b1 test commit please ignore +91fe5d2f5 refactor(populator): ensure file descriptors are closed +8a8f2f068 refactor(image): add image reference interface +902074d2d feat(deamonless): add buildah-based deamonless image puller +6b71f6573 docs(opm): add self-contained container-tools section +ccb818dcb feat(opm): add unprivileged registry add +9a5c3c0f0 chore(codegen): update to drop license year +cf1eae75d chore(codegen): use controller-gen for deepcopy +283f5aa4c chore(codegen): update deepcopy types +422133acb chore(make): add generate and vendor rules +19aa8d24a refactor(csv): don't use pointers for rawmessage fields +931b4dea5 feat(operators): add v2alpha1 operator types +53e97f670 fix the `validate` command in the docs +7d3f5ea0f test(migrations): add tests for api provider and requires migrations +8fae3ba1a fix(load): add synthetic nodes in every channel that a replacement is in +01ab07dd1 feat(bundle): extract replaces/skips data on load +6043ce87d refactor(db): remove denormalization that associated provided and required apis with channel entries, rather than bundles. +5c6d88f2f [feature] Understanding packages from directory +af6ff5d9b chore(codegen): remove license year from boilerplate +473863b3d Rewrite +754662662 PackageManifest isn't actually a CRD +e448e6b89 Remove specific client tool names +1499093a4 Clarify roles and adds info about Package Server +5ac2ad1f3 feat(catalogs): add spec validation for sourcetypes +ea7dfddc2 fix(dns): fix slow dns resolution of localhost for grpc health probe +4faaecbf1 pkg/lib/bundle: fix copyManifestDir so it actually copies file contents +fab72d5ca [travis] pinning minikube version +45b0c29c9 [dockerfile] removing dev directory permission change +a1eef3a29 Revert "[feature] Understanding packages from directory" +84152693a fix(sub): prevent nil pointer access +55cb829b1 [feature] Understanding packages from directory +c5d6a7b46 Update the code and test case +6a79699b4 Update related images func and test case +f4897ca6b make codegen for packagemanifest changes +2d798e9e8 Add more CSV information to the PackageManifest +a44caddce Reconcile Namespace OG Labels in Namespace Syncer +746ccf47b Update graphFromEntries to be a private function +31fa297a2 use query interface in sql graph loader +90541c7b2 address pr feedback +9ef3f960c Update graph format for runtime concerns +a8ea1bfb2 Graph Loader initial implementation +575d92a92 Add tests for GC assumptions. +03b2db1d7 chore(apis): Regenerate API types for openapi3 specification +e55a4431c chore(deps): bump to kube 1.17.3 +75ec17ee3 Change to using a hash instead of ordering +c044cd401 Add alm-examples-metadata +6f4c9f3d5 chore(deploy): update manifests +e10945113 fix(bundles): include csv name in installplan for bundle images +e303dcbef Add OG label to namespaces in OperatorGroup +44a5741f8 Update chart to use the new "crds" directory. +f75829b27 Convert e2e go tests to ginkgo +72a396937 Add e2e test for multiple APIServices on a pod +d0fecef3b fix(catsrc): remove limits on catalogsource pods +9115b31e2 Fix typo in subscription.crd template file +8a79a98b1 Ignore differences in CSV .status.conditions in unit tests. +6e597918c Support multiple At PIServices on a single Deployment +6e67f2c44 Add updated manifests from make release +1b9ebf463 Optionally lock down package server runtime environment +2a57de06b manifests(prometheus): failing operators should be a warning +7181da8cb Add opm E2E test. +e6dd01dab chore(deps): Bump to kube 1.17 +7b7940cc0 chore(deps): Bump to kube 1.17 +b05891a8c update examples for Subscription config features +9145ef1e7 (test) update e2e test +d022ede6f (feat) inject 'Tolerations' & 'Resources' from config +9d031339d add link to olm-book definition of subscription +76aa9fbcf Make provided API ClusterRoles be owned by the corresponding API. +6531eea45 Generalize manifest copy +ffd62133e update go.mod to remove unneeded license dependency +80ec4d5e0 Update operator-registry OWNERS file +9a92f73a5 Match bundle image directory structure +60cbefcc1 feat(jitter): add jitter to controllers to smooth out our spiky resource usage. +e24a30431 Add test target +3d289ad65 Have a Makefile to install operator-verify +f08f7ee8a GitHub action +6df3786ab fix(installplan): crs are ownerreferenced to their resolving csv +ece76cb27 test(installplan): add cr ownerref unit testcase +60d9c9b7e Bug 1809294: Update subscription_sync_count to include the package name +b8e519622 add stalebot +1cff59d94 fix(make): build cpb as prereq of e2e-local +65fe08e51 Use k8s version instead of replace in go.mod +662f4591a Unbreak the minikube mode of build_local.sh. +a4a430838 style(logs): mention generations instead of manifests for subs +11a583d57 fix(subs): retry status update on conflict +b06240fff Removing olm dependency +8068c205b depend on registry v1.5.3 +7dfadbce1 test(installplan): ensure single installplan per resolution +9b8dd25f5 Removing olm dependency +0b39510ad fix(index): gen index dockerfiles from opm image +fafb016e0 fix(resolution): add generation to installplan +b5c72e2eb fix(deployment): remove separate operatorgroup annotation updater +93eb7f183 fix(deployment): use deployment spec hash for determining if change is needed on cluster +82d43867b Fix TestUpdateCSVInPlace e2e test case +ed94e0f23 Remove run-level 1 from olm and openshift-operators namespaces +2b3d40150 fix: use label selectors in package server List response for all namespaces if label selectors are provided +75162c2e6 Don't block on ctx.Done() if startup fails. +0bb00ee1c Fix kind detection for local builds. +689e64e93 Add stale bot +0c173c69f test(meta-pruning): ensure pathless nodes keep data +0fb8e2d7e Add stale bot +fb0489b70 Produce binaries without target platform prefixes by default. +537d03995 Update README to include OLM-Book +e1c406909 chore(deps): remove helm as a dependency +f04515c78 Update subscription-config.md +d7a93457b Add some examples for Subscription config feature +f6ef85d61 fix(docker): add entrypoint +53bde4b33 Bug 1798051: Reinstate v1alpha2 operatorgroup +bf5010ce9 fix(packagemanifests): Fix index key func to avoid key collision +74c1cbe22 feat(util): add cpb command +d3437399a fix(bundles): execute opm from tooling container +aa753bfca Bump version to 0.14.2 +f76ea21db fix: update e2e test to use internal docker registry and openshift registry. removes quay credentials. +9d780ed68 mention OLMs features in the introduction +d5053fdb4 Fix cases where an operator's ready channel may never close. +38955c133 fix(index): copy correct opm bin builder path +df43ac7d5 Update operator-bundle to clarify the bundle format directories +d2f6e6086 BUG 1238: Fix configmap registry server readiness probe timeouts +2ae275102 fix: update existing robot credentials +3ebc7c33a refactor rh-operator test directory +52db6fd8b Delete junk SQLite journal files. +bea99c650 feat(appr): exit build early if no manifests were downloaded +f913c128b chore(ci): update owners +48f8d6cb9 Generate manifests for version 0.14.1. +5d3650ff6 Generate changelog for 0.14.0 and 0.14.1. +24d607545 fix(gc): clean up copied csvs that have incorrect operatorgroups +230ed91fc test(e2e): add test to reproduce bug where copied csvs with annotations +6a857172d fix(operatorgroup): don't overwrite operatorgroup annotations on copied +1eab138b7 test(ci): add failing test assertion showing that operatorgroup annotations on copied csvs will get overwritten to the wrong thing +1cc4c0b98 Addresses the bug where updating the packageserver fails with a unable to adopt APIService status message. This is a result of ownership mismatches between the packageserver (owner) and the APIService (the owned object). This can be resolved by setting the actual k8s owner references or the label-based references that OLM uses. This commit ensures that ownership references for the APIService are cleaned up on OLM restart and that the olm.owner:packageserver label is set on the corresponding APIService object. +6dd781751 Bump version to 0.14.1. +3bc3a3a07 Update operator-registry dependency to v1.5.8. +29263b0a4 Add bundle validation test cases +61f7aca09 Add validate bundle test cases +64f5acb45 Remove dependency on sqlite from pkg/configmap. +078a6f8c9 Fixing wrong database loaded in memory for export cmd +52bf1dcd3 Fix overly broad .gitignore pattern that was excluding a vendored package. +b797473b0 Revert "fix(ci): build opm statically in CI" +0cab8a53d Add support for Prometheus Custom Resources +3a0309a28 Adding ability to export package from index +7cdf29dae fix(ci): build opm statically in CI +fd5b5456e Bump version to 0.14.0. +6de6829fa Vendor helm, since it is used for templating manifests. +4a113bfa9 adding e2e test framework for rh-operator metrics +01c22044e Update README.md +2399fc36d Update docs to reflect index/bundle image changes +1bad1e5c9 Bug 1784028: Updating summary for 'Operator Registry ' containers +d0ce30eb5 Add support for choosing the package's release +9abf38906 chore(release): use robot for deploys +33a3a875d Fix issue with empty docker error output +9e393e615 chore(release): add a travis.yml to build and release opm +bba572390 Address feedbacks from comments/reviews +12dff198f Add unit test case for CRD validation +bb4139601 Refactor validate CRD to fix conversion error +17f67d0ab Refactor bundle validation code to seperate format and contend validation +e58102dbc Add validate bundle contents +dfef906ed Fix IPv6 incompatibility in TestGrpcAddressCatalogSource. +084cc4650 Update release script to require version 3 of helm. +f3f78e48f update internal objects proposal +4f926286d chore(build): only enable cgo for ci/prod builds +617a1da83 Remove pyjq and yq from the release documentation prereqs. +da188bd21 fix: typo in catalog polling doc +977079d7f feat(packagemanifest): add default os/arch labels if not present +921414bd5 feat(packageserver): support label queries and copy CSV labels onto the packagemanifest +f54690791 fix: refactor catalog polling spec to use more general update strategy field +ec92318a7 Delete file that was renamed +9df9d528b Swap annotation namespace +b2ca9020d Use the correct title +6d8cfdce1 Ammend proposal to include data CRDs and new annotation names. +97879df57 doc: add internal image proposal +44c2a9513 Reconcile manifests with templates. +1fb8497e4 test(e2e): fix subscription update flake by retrying +579ad84ce docs(design): add bundle image unpack design +a29885434 refactor(resolve): simplify bundle lookups +629c26fb1 fix(catalog): add ownerreferences for bundle image resources +d30eec482 fix(e2e): remove local dev test registry image +0ac5d7834 fix(e2e): remove local dev test image +824b575a5 test(e2e): add test for bundle image +261d22ef9 chore(fakes): make mockgen +d2f6a1692 chore(codegen): make codegen +8d0620093 feat(bundleimage): resolve bundle images +7a4130a65 feat(catalog): make install possible from bundle image +7b0c870a1 chore(vendor): get latest operator-registry +cfccb8bce feat: add polling doc +28bd26930 fix: update Poll to be pointer +ef660b62d feat: implementation of catalog polling feature with e2e test +26a08dcf5 Revert "feat(packageserver): support label queries and copy CSV labels onto the packagemanifest" +af3dab3c4 feat(packageserver): support label queries and copy CSV labels onto the packagemanifest +81919f512 Make downloader.go testable +7510a1793 fix(build): grpc-health-probe was not building properly in 1.13 +91f4eeee4 Use vendored transitive dependencies for "go run" of vendored yq. +f4927441c Enable CGO and CGO_DEBUG +98a9e79d1 fix(bundle): set csv name field on configmap loading +7d7d73046 chore(codegen): update generated code for 2020 +351f482b3 Vendor helm library to enable helm chart validation +8ed495541 Fix a few minor issues +b0a5cdf77 Update bundle validation lib for sdk consumption +ca90fd1b4 add tests +158d8771e Add bundle image validation feature to bundle library and bundle cli +1b0352188 chore(ci): add dockerfile as a base for building in CI +a87892fd7 Detect replacement cycles while adding package channels +08e7975e4 Fix tiny typo +3e8b6904d fix(configmap): remove packagemanifest parsing +c8a374612 chore(makefile): add selective unit test execution +9ee71a10d add cp to configmap-registry image +a2d3a67d5 Add opm to configmap-registry image +3cc8d20b0 fix: add err check before further operation +434e736e4 feat: make run_console_local.sh sh compatible +3c9c4e40e fix: make run_console_local.sh working on WSLv1 +5a2c09762 test(e2e): testing CRD upgrades shouldn't create a new subscription +f9dc11c9f feat(resolver): rely on info from catalog to determine updates +e674ac7df Add note for version field +e17efd934 fix(deploy): remove resource limits +3cc2aede2 chore(modules): update vendor +923200984 refactor(opm): add examples to index add subcommand +33e472eb6 chore(codgen): regenerate code, mocks, and openapi +56c53d2bc refactor(pkgsvr): remove apps group +b3c31e88e chore(codegen): clean up codegen make rules and scripts +24208ed04 chore(ci): remove old gitlab ci config +d7ff63fca docs(design): add general design goals +14b60c426 feat(resolver): fallback to csv parsing if grcp api does not contain the information required +d18bbe4b3 Update manifest CRDs +b821e5a5e Implement controller-gen +531f3162b Update CRD go types +66bd02946 Corrected etcd CRD URL. +18a528e3d Added `keywords` in operator metadata. +6672ec680 add a mention of bundles to the README to help users find bundle information +a89f54259 Dep is not required. +a59d446ba chore(git): remove and ignore packageserver test key pair +ccda3c5dc fix(packageserver): cache packagemanifests +076003433 Fix CI unit tests +b98f2d15d Change index func to return list of ns instead +d9845a62a Fix updateInternalCatalog namespace bug +95a0619fc Add e2e test case for syncSourceState +ccd54c5db Enable multiple namespaces sync if catsrc is updated in global ns +aad455fb0 bug(metrics): serve metrics using new certs when replaced +062584436 feat(filemonitor): add new filemonitor package +82e72d337 chore(modules): add fsnotify +13057a042 Bug 1769030 Replacing (updating) operator creates duplicate secrets for the operator's ServiceAccount +87618fc45 go.mod,go.sum: bump k8s deps to kubernetes-1.16.2 +84585c6fd Fix minor namespace bug with NewFakeOperator +55974007a Update k8s version for local cluster (1.16.2) +ed1935b21 chore(mocks): use new counterfeiter directives +b019db1d4 fix(appr): use given cache dir for image builds +c95aa6a25 fix: double limits +66ab840f9 fix: double packge server limits for CI +5b12e385e Bug 1774630: relocate test data +5f481ce3c Bug 1774630: Fix panic caused by incorrect bundle data +6ab2895f1 feat: add resource limits to all OLM pods for OLM releases on OCP above 0.13.0 +9cc5fac0f Bug 1771850: Error logging for opm alpha bundle extract command +4f8dd8c4d vendor in github.com/pkg/errors +903eab048 fix: defer RUnlock in AsClients +940c3fb3b fix: use defer cancel to cancel context waiting for state changes +0fa8201ed [docs] update changelog command +3e469c477 fix: simplify test by removing additional map +0d9b81a23 feat: add test to confirm node selector behavior +c34e80a38 fix: add NodeSelector to catalogsource pod spec +1957d0cb4 Clarify the directory requirement in docs and help menu +17e1fac98 [release] updating changelog +da3fc2e34 pkg/validation/interfaces: Validator's implement WithValidators to append non-default Validators to the Validator; ValidatorFunc implements Validator +1324a97e0 [release] - making new release +548d017b0 Ensure provided directory has at least one yaml manifest file +475a9fda7 Add directory check to ensure the directory exists +6ec0bba73 Fix bundle build command with Docker and update documentation +e9ae4be82 fix(e2e): update ginkgo configmap test +92acda8bf fix(olm): defer provided api update in operator groups +f20ad06da [release] - version bump +f0c2b06bd [docs] - update release docs +9a4e3b3cb [bug] - add version and skiprange to operatorbundle table +31d85cfd9 pkg/validation/interfaces: Validator's implement Validate() to return errors.ManifestResult. +645f73f7c Make imagereader work for all layer paths +a26089a5a Fixing doc typo +f7bdf8284 fix: t.Fatal should be used in main goroutine +a8ff97b42 Fix flaky subscription e2e test case +80f25361e Fix several flaky e2e test cases +b27d28666 fix(configmap): bump base image for configmap registry image +3775f1d9a Add `opm index` commands +9fc13ce3e fix(mirror): canonicalize names before swapping domain +e5a4c8dbe feat(api): return version and skiprange in bundle +bc3c953c5 Alerts for failing OLM operators +43b7d8462 [opm] - Add registry add and rm bundle commands +b270b73ea fix(builder): Add AppRegistry org to `ToOption` +f89f7e09e feat(metrics) Report subscription channel +088c142d5 fix(configmap): make launch bundle work +a28729347 feat(resolver): use provided and required apis from grpc instead of calculating from the csv +48128f96d feat(metrics) Limit Cardinality of CSV metrics +8586d5946 feat(client): return api bundles in client +95f956aee feat(sql): extract required apis when loading +9dd281b4f feat(imagebuild): add opm binary to registry image build +ff9ac78b8 docs: Corrected CSV upgrade version. +c04b9eda0 Add unit test for minKubeVersionStatus +0065ffd46 fix(bundle): Fix the build paramater order mix-up +5a9e2085e test(mirror): add tests for mirroring +924bdfeba feat(opm): add registry mirror command to mirror the contents of a catalog +f09d1f48a feat(opm): add registry build command to build a catalog from an appregistry namespace +396d51306 chore(configmap): load packagemanifest data from annotations +9c9fcb834 test(unit): add test case from generated configmap +f49d8d513 (feat) Load operator registry bundle from ConfigMap +80ec02aa6 Update registry gitignore to be consistent with OLM +9c2b5bea1 fix(bundle): Fix manifest directory issue in generated Dockerfile +317dd2aab fix(olm): No longer report status if minKubeVersion not specified +e7e204be9 test(e2e): add bundle data image extraction test +127b4c8f2 test(e2e): add initial test bootstrap +3a29503b7 feat(cli): add bundle extractor binary +59a75cd86 feat(configmap): add configmap writer +c0f8325ad chore(client): move k8s clientset generation +461d6985f Change const to upper case so it can be used +aa26d805e Updated values.yaml location. +602fabf72 fix: refresh architecture and philosophy +ce488d190 Clean up minor issues with command-line code and documentation +c625b267c Fix bundle library doc to reflect new changes/features +f7dee84cf Fix bundle library unit tests to cover new code +df3d617ac Fix bundle library to add package and channels info to annotations +c5c42cfad Clean up library code, unit tests and documentation details +e87847714 Add CLI tool to build Operator Bundle image +062cfa9c2 Image digests for referencing bundles +38e90e00f Update resolver.go +a3259165f Fix log message in resolver +df6ef4d11 fix: fix particular typo in clusterserviceversion_types.go +cf24622fd feat(migrate): migrate from current version up to the latest +46088dfb0 feat(images): add support for storing and querying related images +b3f5273ac feat(migrations): switch to go-based migrator +58b7f3d33 URL with modified manifest directory structure +b2afe6a00 Update OWNERS +7678f6edc bug(dependencies) Prioritize APIs from same CatSrc +906690334 Adding opm cli +d7081859f Update PackageManfiest table handler +4688a9dcc bugfix: assignment to nil map will cause panic +d0e22e9b2 (proposal): add bundle image deployment text +6779f0b26 (proposal) Make bundle accessible to a cluster +313d15f7b update OWNERS +6aa2b7499 Bundle migrations in binary +82f97db28 Database migration initialization +fc99a2ba3 fix(sqlite): enable foreign keys for sqlite +7344cbf0e proposal(relatedimages): combine the two previous proposals +bf587f26d proposal(relatedImages): update related images proposal to use kustomize +775fbf92a proposal(relatedImages): add a proposal for specifying related images in CSVs +f31c876b5 Fix InstallPlan stale variable issue +e70eb17fc Add e2e test case +542d8d2d9 Bug 1758008: Manual approval strategy ignored for subsequent releases +22477b866 Add document for SubscriptionConfig +bd975dcb9 feat(subscription) Config Volume and VolumeMounts +5f25627b7 Rename envVar package to overrides +23ac744d2 Add `apk upgrade` to upstream builder +c26ac3099 Fix links to console repo for moved packages +e54770d4f bug(install) Fix packageserver name in install.sh +183c6a860 feat(metrics) record CSV sync events +f0f7f9d23 Bug: Fix olm chart +fde8c0553 chore(modules): bump openshift/client-go pseudoversion +6d8449d89 (release) Update changelog +46406f126 pkg/registry/bundle.go: use v1beta1.CustomResourceDefinition, as the apiextensions type is internal +b96fcdd54 Add migration proposal +f8d3c4824 chore(deps): bump to kube 1.16 +9aa8674c3 feat(scripts): add shell lib with some common helper funcs +0a48b1c72 fix(subscriptionconfig): add missing merge struct tags +bcf781ec6 refactor(operatorstatus): make monitor constructor variadic +122de9ae0 (release) Generate manifests for 0.12.0 +865609081 chore(deps): refactor load_test so that OLM is no longer imported at all +9394c1452 chore(schema): remove schema +7d0279468 feat(csv): support extracting version from bundle's csv +227c5f994 (release) cut a release for 0.12.0 +08eab6477 (docs) Update release.md documentation +afe956695 chore(deps): bump to kube 1.16 +a31af892c Create PULL_REQUEST_TEMPLATE.md +7ecae3cc9 Update PULL_REQUEST_TEMPLATE.md +a887ff0fa Update PULL_REQUEST_TEMPLATE.md +db19d9fee Update PULL_REQUEST_TEMPLATE.md +823ca8fbc (doc) How to update operators documentation +e45258d22 test(e2e): add operator group SA permission tests +25cbc86a4 fix(olm): requeue as needed upon permission changes +e954cf8f9 fix(olm): handle CSV install failure gracefully +9ec40d12b Enable vendoring on Go 1.1x +7a8c5589f feat(olm): don't calculate a patch when updating via a replacement chain +973e9c395 Add unit and e2e test cases for deprecating a CRD version +cec93f8b4 Remove deprecated CRD's stored versions to allow CRD update +55f068e4a (doc) Add deprecated CRD version procedure and note +a256f5f88 chore(docs): consolidate doc directories +b7819af96 Fix broken doc links +998809eec fix(registry): return all valid packages +3dc775536 chore(mocks): generate mock list packages client +42969ebc0 fix name of dir - replace Documentation for doc +bc02e9d6e feat(github) : Add github files in order to follow org standard +16494cd03 feat(readme) : Ajustments +cf8c2bfdc Drop the hard-coded DNS suffix +bede912c8 add default for packagemanifests/icon subresource +ea78704b6 fix(clusteroperator): update status after initial creation +e9501878e fix(clusteroperator): fix naming of related objects +1fca6a1f3 feat(clusteroperator): plumb additional clients +8ff1a2abd Bugzilla 1744245: Subscription should not point to deleted ip +4ce17d2f0 fix(init): cleanup leftover cross-namespace ownerreferences +09e846ad0 Stop relying on pgrep -q +31898fd5b [CatalogSource] Set Global Catalog NS with EnvVar +8b9d8b18c Remove InstallPlan Source, SourceNamespace from UX +d354b682f fix(olm): report name and group for related objects +f16ca4ad2 [lib] add two methods to validator interface +072bc751f [lib] add bundle validator +5496e4e09 [lib] add package validator +a31c68463 [lib] add crd validator +6b0b69706 [lib] parse operator manifest directory +b9207a2fe [lib] csv validator for example annotations +a1dafde35 [lib] add support for handling manifest +254ff6d88 [cli] change from verify to manifest command +13e77238f [lib] refactor logic for csv validation +28ef243a6 [lib] refactoring the library +f6b32131c go.mod,go.sum: add modfiles +db8ca031a fix comment +c23e76ac6 refactor Validator and error/result types into pkg/validate/validator +10cd8b511 pkg/validate: add Validator interface to add k8s objects and run validation logic, refactoring around interface +36f17aa27 [lib] Handling mandatory/optional fields and reporting custom errors +bc4a45f97 [cli] Handling error reporting through cli +ff518e877 [cli] Adding verify command +de5eab427 [lib] Adding serialization for CSV type +c63198ac9 fix(sqlite): defer rollbacks to prevent db lock +dafa3719c chore(deps): update grpc to latest +6952403d0 feat(operatorstatus): report packageserver as upgradeable +9e7039fc5 Bugzilla 1737057: Sub CRD does not validate config +e9e115eee feat(sources): syncronize access to lastupdatetime for sources +e209a4e08 chore(deps): update grpc dependency +d7d1ff1b8 Bug 1740332: OLM should resume operator install +5fb22c2c3 add packagemanifests/icon to aggregated OLM RBAC roles +2172020fd filter icon fields from PackageManifest object (use packagemanifests/icon subresource instead) +65c4666d8 test(e2e): add test verifying permissions are updated during an operator upgrade +6877b58e0 Bug 1702552: Two "NAME" fields by command "oc get catalogsource" +6525b53f4 Bug 1732914: Operator upgrades fail when versions field is not set +734cd61f4 fix(spelling): just a comment correction +1c631bf63 fix(olm): clean up resources on CSV deletion +43904bac0 test(e2e): ensure resources are deleted after CSV delete +a4020e3a3 (proposal) improved csv status reporting +88885ba20 [doc] Add fake README to the project proposal +d9ad0f893 Operator validation library project proposal +e89735b13 Bug 1744245: recreate of sub should not fail install +d82e763f2 packagemanifests/icon subresource +9147efeb1 add proposal for 'packagemanifests/logo' subresource +1d70f3048 Bug 1737081: catsrc status should show error +33d39768c test(grpc): add basic connection event tests for source manager +fc5b01acc feat(grpc): adds grpc source manager which notifies main controller when grpc events occur. +fa442cb0c fix(deploy): change local deploy to use olm namespace +0b44cdec2 fix(registry) Fix incorrect error return and handle +f5e8bf6d2 refactor(cmd): change command scope to make testing easier +10f4bfb8e feat(configmap-server): tolerate load errors +4bf956652 feat(registry-server): tolerate load errors +38c956b56 feat(appregistry-server): add strict load option +7da728f31 feat(configmap-server): add permissive load option +af591e9df feat(initializer): add permissive load option +e08f0e390 feat(log): make termination-log setup failure non-fatal +2eb8e4f30 test(load): add test of unpacked appregistry format +ae4493d4f fix(sqlite): correct directory load error collection +ad310d64e feat(appregistry-server): use empty querier on fatal load error +82722d27c feat(sqlite): make configmap loading best-effort +242baf625 feat(sqlite): make directory loading best-effort +ef61b9e60 feat(sqlite): make package loading best-effort +efd0c3fd6 feat(appregistry): avoid panics in flattened processor +05d4d864b chore(git): keep testdata/download +f7f47a0f0 Initial commit +c22cea8eb bug(1717636): Add relatedObjects to cluster operator status +ab835aa69 chore(deps): add glide.yaml for importing to oc +58f3ccb93 feat(appregistry): have appregistry transform configmap bundles into directories +6bb21c271 chore(deps): remove dependency on marketplace +eccfa7060 chore(deps): remove dependency on openapi and go-appr +105d723dd (doc) add doc for scoped operator install +9ea876e78 (doc) update make new release doc +106f9e507 Report `Upgradeable` in ClusterOperator status +e2b2b7470 fix(unit): allow logrus log level to be adjusted +8c5cfd708 fix(catalog): re-install resources in existing installplan +e6fea4bb0 (release) update changelog +59305c77e (release) generate manifests for 0.11.0 +5471a5b80 bz-1662263: include git sha in ART builds +55cf20a68 (e2e) fix e2e test flakes +57d5167bf (feat) requeue the csv when subscription changes +50d8af9b8 Rename and remove commented code +900846502 (feat) empty proxy env var should result in unset +8f044c03e (release) cut a release for 0.11.0 +b74b184e1 Fix panic when binding already exists +89076d623 fix(dockerfile): missing image alias +9012b067c fix(unit): refactor to use shared pod resource +82b89d2cc feat(deploy): add resource requests to all pods +cba79661f fix(manifest): fix env var projection in command +df9418c85 (test) add e2e test +2045208a9 (feat) inject 'Env' from config to deployment spec +38decf71d (feat) incorporate proxy configuration support +e9b8e3c75 add operator configuration to subscription spec +391012587 Add e2e test case for existing CR validation +39d9fa5ca Validate existing Custom Resources against new schema prior updating +70701ea86 add dockerfile that just contains the registry server +979c4fa39 refactor(load, query): don't rely on json extensions to sqlite, and don't rely on types imported from OLM +4db7fc736 feat(load): allow multiple csvs in the same directory +bcbd5e9f1 chore(modules): re-vendor +6ac6e1ef2 chore(generated): run code/mockgen +86276ae2c chore(modules): pin k8s 1.14 +de66a717b feat(metrics): record sync count for subscriptions, labeled with name and most recently installed CSV version +aa599f91d feat(metrics): record sync count for CSVs, labeled with name and phase +232ab6a9d fix(init): move cleanup to olm startup +98cc0a6ba feat(init): add init container to olm operator that can clean previous deployments +4711b0aca chore(deploy): remove packageserver subscription and catalog from chart +d3c232d3d fix(build): don't build static in downstream images +128449632 chore(image): change base image to go 1.12 +0164effea feat(olm): allow CRD updates with multiple owners +fa7fcf9d1 chore(logging): logging fixes / small enhancements +a655bbaf2 test(catalog): add sync resolving namespace benchmark +2060152e1 fix(olm): List does not return NotFound error +7e7a20d7d fix(e2e): fix baremetal e2e +9aa00c871 chore(dockerfile): switch to go 1.11 +19a892236 proposal(operator-config): initial proposal for persisting configuration of operators +be55365d0 feat(csv): detect changes to a deployment and persist them +6cb475990 fix(query): return all channels when querying +423ecf606 docs(profiling): add basic usage doc +2be069c49 feat(cmd): add profiling option to olm and catalog commands +40a34b5c8 feat(profiling): add pprof handler registration function for mux servers +62ba254c4 test(e2e): remove extra resource comparison +7a8a21df2 Add webhook proposal +6df186031 1723818: package server 4.1 to 4.2 upgrade should not fail +4d07ecab8 feat(makefile): add target for compiling e2e +24e3bdda3 (bug) CSV name change causes upgrade to fail +89f4d288f (e2e) add e2e test for user defined service account +cfff29c30 (feat) validate that secret is valid api token +6d56a74d0 (feat) use scoped client for plan execution +5a378a491 (feat) create scoped client from bearer token +5943b2223 (codegen) generate operator group type changes +1d1406292 manifests: move ServiceMonitor manifest to runlevel 90 so it will be applied after ServiceMonitor CRD is created +6ba46b3e1 [bug] Remove duplicate packages from list +c7831f5e7 chore(modules): add hashstructure and revendor +55c4a61e4 test(sub): add subscription installplan condition e2e test +4b976ae87 feat(sub): add installplan reconciler to syncer +dd58ec73d feat(sub): add installplan status reconciler +c6e0f24c1 feat(state): add subscription installplan states +3b56f8ade feat(sub): add subscription installplan status conditions +666942c4e feat(equalitor): add equalitor interface and hash implementation +fe942aa77 (feat) monitor package API server CSV progress +65566179d Receive notification of CSV(s) being watched +0549c5f52 (deploy) add cluster operator for package server +9153703c5 fix(test): fixup bare test imports and vars +5a48ba8bd Add a new test case to cover preexisting CRD case +befedc7cc Add e2e test case for single owner CRD update +7a2263d9f Add IndexFunc using ProvidedAPIs as key to look up CSVs +b17a0f946 Enable OLM to update CRD when there is only one owner of that CRD +1a01baa0a Update CHANGELOG to include changelogs from 0.10.0 and 0.10.1 +98a9a20e6 docs(release): add additional clarifying details +f39e000df fix(build): set GO111MODULE=on +7ec84feb2 Switch to go 1.12 in the root Dockerfile +73d86fde9 make release 0.10.1 +56a83e9fb fix(unit): fix unit test flake +16d1d8318 fix(build): don't use helm in src image +2434f1b77 fix(catalog): do not add owner references to clusterroles or crbs +ac617f597 fix(chart): add missing descriptions to operator group +112248d93 feat(queueinformer): add config options +300403724 test(subscription): add e2e tests for catalog health +547910899 test(bare): use new operator constructors +951bbaa8b chore(codegen): generate conversions/deepcopy +5a7ae300d feat(subscriptions): add catalog health conditions +14d1f34bd refactor(packageserver): plumb context throughout +30d315892 refactor(main): use signal context and new operator contructors +c0231ed15 refactor(olm-operator): replace factory method parameters with options +e162d49b3 refactor(catalog-operator): use new queueinformers +2c1adf0a0 feat(subscriptions): add subscription catalog health syncer +a9272bf5a feat(registryreconciler): add now function +3bc29f8b2 refactor(operatorstatus): make sync channel receive-only +884ecd94d refactor(queueinformer): use kubestate resource events +97abc9440 feat(kubestate): add generic typestates and interfaces +16b5ad074 refactor(signals): replace stop channel with signal context +314e02ce7 feat(e2e): allow KUBECONFIG to be set from env +5e019f32d add -l option to $POD_MANAGER attach +e8bde0245 clone labels from CatalogSource to PackageManifest to prevent concurrent map writes +25caff25e (proposal) Add user defined service account +948ae2d98 change packageserver global namespace to openshift-marketplace +951fb43fd add --rm, remove cleanup func, and attach to block +b8114b3ac repair run_console_run.sh script +8c76fa321 Bump release version to 0.10.1 +fae07921d change global catalog namespace to openshift-marketplace +3445c4b50 chore(deps): bump kube deps to 1.14 +b5dadcdd6 feat(install): Add new install scripts for releases, update release instructions. +77461fcea Documentation: Fix a few typos +fe51b8578 chore(types): codegen internal convs, clients, listers, and informers +d53e34e64 refactor(codegen): add conversion to make rule +bc2fecc42 refactor(types): add internal types for olm resources +36fe1227f Remove pragma lines that reference the files that can’t be found +dd4c1d6f2 fix(registry): Validate alm-examples in operator registry +18e9d9228 Documentation: Small typo fixes to README.md +32c1e6607 fix(operatorgroup): Remove namespaces requirement for opgroup status +ca98f467c docs(release): add basic steps for making release +e46653c90 fix(catalog): close grpc connections before deleting them +d26e3af03 update manifests to 0.10.0 +d313ede32 bump version to 0.10.0 +d192632e5 add provided APIs to PackageManifest +8f867e81a (refactor) Move csv set and replace to a package +f79fcb60d feat(client): add health check to high-level client interface +9d6999b55 test(e2e): add test for orphaned api services +530a8a6ed end-to-end test for cleaning up apiservices after CSV delete +7ec8864bd fix(olm): add deletion monitoring for api services +6a31c507c fix(unit): fix flake in TestUpdate +6b540dcca fix(unit): operator group test flakes +19e9ed6c9 fix(olm): unit test flakes +fbd218514 feat(unit): allow specific unit test execution +2e6f3c5b3 test(olm): test role aggregation for aggregate apiservices +f96abcf34 added e2e test for garbage collecting ClusterRoles +8a7af925c fix(unit): Remove leftover println causing excessive log in unit test +cc6ff6f65 fix(operatorgroup): No targetNamespaces matched namespace selector +c63e7678f chore(deploy): install helm in `src` image so that verify manifests job can run +73715797c chore(deploy): re-sync manifests with the chart +b06422292 chore(deploy): add `verify-manifests` command to ensure chart and manifests are synced +6ca9f429f chore(deploy): fix release scripts +0b59c5adf fix(catalog): Fix subscriptions without a sourceNamespace hang forever +668e596dd fix(run_console_loca): Fix command and improve output message +2cc6173c4 Add validation details for `spec.maturity` field +da1622e49 fix(unit): TestUpdate no longer flakes +bf7364e1f One more doco typo fix +703262267 documentation: Fix a few typos. +330e9cab2 Fix small typo. +4d3470876 Add support for Windows WSL in run_console_local.sh +0932515cd Fixing indentation for spec field +84bb8a405 fix(deploy): add missing descriptions to manifests +6f43ee44d Fix tolerations +667805d5e fix olm-operators tolerations +51f14be2f fix(catalog): fix issue where subscriptions sometimes get "stuck" +352f82693 add terminationMessagePolicy: FallbackToLogsOnError to OLM deployments +e16b2bccb fix(deploy): add missing descriptions +7e7410caa Fix tolerations +1efa117fd fix(e2e): fix installplan test cleanup +31e906c90 fix(operatorgroups): fixes rbac checking for multinamespace groups +f41a55265 feat(olm): speed up csv updates +39adb606e test(catalog): add tests for catalog reconciliation +033c4119a feat(catalog): check catalog health and recreate if bad +c74e3ad5e fix(roles): use correct group for package permissions +65007eb54 fix(e2e): test changes +dc2de2d6a feat(resolver): treat the registry as the source of truth for replaces fields +f506fba6d fix(olm): race when a subscription updates many versions +30354384b fix(resolver): resolved dependent subscriptions don't detect updates +fb6cca459 Set limit on length of Status.Conditions of a csv +6067ef7c9 feat(load): validate that packages have a default channel when loading +6c4d21f76 feat(resolver): allow skipping a set of updates if the channel head explicitly states that a range of existing operators can update directly +2c8d2be4f chore(deps): switch to blang/semver from coreos/semver +69204952d fix labels.provider issue +da68073dd fix(catalogs): make grpc registry check for < 1 pods +e5a7d5c5f test(reconciler): refactor reconciler tests with k8s decorator +94c99d71e test(clientfakes): add k8s client decorator and shared options +68611698a Add e2e test case to verify the events flow +f02824374 fix(olm): Fix the issue with missing events due to rate limit +a6e5ba291 fix(permissions): the aggregated edit role should grant view access to operatorgroups +e548c63b8 fix(olm): don't requeue operatorgroups for deleted copied csvs +499802def test(e2e): wait for deployment to exist in csv replacement test +c9c674c06 Always set LastTransitionTime in OperatorStatusCondition +1c04f1302 Revert "chore(cvo): remove ClusterOperator from manifests" +5ed875b87 Add node-selector annotation to namespace +bf6e905d1 chore(cvo): remove ClusterOperator from manifests +8e8499219 chore(deploy): update manifests +f646c0d1a add priorityClassName attribute +a9393b30d chore(cvo): update openshift/api so that OperatorFailing is changed to OperatorDegraded +f71593ea5 refactor(queueinformer): prevent > 1 run calls for duplicate informers +6c94c8d90 refactor(subs): add objectreference installplan refs +1b7b64903 feat(types): add reference for olm types +0b7509aa6 feat(loader): don't require file suffixes +aba81c5ca feat(rbac): restrict permissions for namespace admins +ba14de1f9 chore(cvo): report progressing=true if the version has updated +fa5da9eb7 Modify and improve unit test on deployment +fff1c6912 Rework cleanupOrphanedDeployments +d3bdadbcf fix(deployment): Clean up orphaned deployments +379187617 feat(packageserver): add additional info to package server output +8b084675e fix(e2e): metrics are now served 8081 +f67a44ef7 fix(metrics): remove optional from secret parameters +8b7cf67da fix(metrics): add logging and separate muxer in catalog +f6738b2f9 fix(metrics): add logging and separate muxer in OLM +037fd1170 fix(catsrc): force registry update on dep resource deletion +e9078df6d feat(registry): add registrychecker +01763d417 feat(lister): add catalogsources to operatorlister +a69e8aea6 chore(mocks): regenerate mocks/fakes +0f6920873 chore(mockgen): use modules for mockgen +75b365b44 test(catalog): add registry pod delete e2e test +d7e8e144f Add unit test(s) +a00d721ab Support nested operator bundle format +d9a964ffd fix(e2e): remove ip count check +31805c44b fix(olm): generate rbac roles for ownnamespace operators correctly +0d59b4760 test(aggregation): Add test for operatorgroup role aggregation +7a0a48446 test(e2e): add sanity check for project admin permissions +f5e868766 test(subscription): add additional testing around installplan generation during manual approval subscriptions +6478efadc docs(changelog): regenerate changelog for 0.9.0 +a8195a728 docs(release): add release doc with changelog generation section +68bd541cc cut release 0.9.0 +96a5e2e86 fix(git): remove nuget ignore rules +2e4c2eb57 chore(modules): revendor +ca07037f6 fix(modules): update replaces fields +091a80097 bump version to 0.9.0 +2a69d8d0a docs(subscriptions): add improved sub status proposal +098024d87 chore(deploy): set priorityclass on olm pods +ec943c50a chore(package-server): adjust to new API +3dbf29e63 chore(vendor): add jsonpatch +87b9d09b3 chore(codegen): regenerated due to vendor updates +629d46aee chore(vendor): update vendor directory +44f118f0d chore(vendor): prep for update to 1.12.7 +ce738c402 fix(annotation): don't annotate deployments that aren't owned by a CSV +9e244e665 fix(packageserver): add struct tags to PackageManifestList +b0c3752e4 chore(codegen): run codegen and mockgen +0d74e0458 feat(packageserver): support apps.redhat.com and operators.coreos.com +1b570285a chore(deploy): regen /manifests +6eb30ae64 refactor(charts): normalize packageserver templates +de5fcdb95 Support v1 OperatorGroup and v1alpha2 OperatorGroup +ac22aed7d chore(api): bump operatorgroup and packagemanifest to v1 and group operators.coreos.com +3af623ac3 feat(load): use a new "skips" field to specify additional operators that +abd818bcb chore(deploy): don't include openshift stuff in upstream +bdf965108 fix(deploy): move service creation to new file +f9270ad15 fix(metrics): add service monitor config +3254744db feat(templates): make use of TLS options in deployments +b9de856aa feat(olm,catalog): add TLS support for metrics +6d333867e chore(deploy): renumber files from 02* onwards +bca81d76f fix(olm): use hashes for provided api labels +63c3d3a44 chore(deps): bump openshift/api to get new ClusterOperator types +ae72383de chore(catalog): add ClusterOperator status for catalog operator +c2b442a50 chore(build): build binaries locally and load them into containers +d67704a56 Remove OperatorSource dependency +4432c798f chore(manifests): recut 0.8.1 +6cfd1eb45 docs(git): add changelog +f86f9bd31 fix(build): add some minor support for building locally with kind +12342747c feat(operatorgroup): operators in operatorgroups that select all namespaces are now granted namespace view roles (get/list/watch) +3e2c9012c test(e2e): add failing e2e test for operators in global operatorgroups +00e6a85cd feat(csv): label CSVs with provided/required apis +86139cc75 update upstream configmap-registry image to use the builder image +7827f6775 fix(chart): persist operatorstatus reporting changes to chart +2b6f52876 feat(upstream): add operatorhubio catalog to upstream release +898752aa2 add instructions how to use grpc catalog +c6a2e9a05 fix reference to Dockerfile +6c3f537da Fix typo - k8s version format +002e902bd fix(installer): include generated manifests +b4c925fa5 fix(ocp): add csv and deployment for package server +6dc8f6051 feat(e2e): generate a larger set of namespaces during testing +1ad71dac5 fix(e2e): use ifnotpresent for all test images +d1a92cf4b fix(olm): don't attempt to annotate deployments if the deployment hasn't yet been created +99b065778 fix(catalog): kind was omitted from ownerlabels +0061f4ffb fix(operatorgroups): gc copied csvs from a separate queue +eed7b3ef4 fix(e2e): e2e test for pre-existing crd owner tested incorrect behavior +28c092f45 fixes typos in README.md +64ac4303a feat(builder): add builder dockerfile (contains tools for building a registry image) +177e3166b fix(resolver): take a snapshot of the current generation before updates +f3d7fc544 fix(catalog): fill the csv cache with informers +cb82894d5 test(subscription): add an e2e test for validating that subscriptions step through multiple intermediate versions +3694a941a refactor(images): use operator-framework namespace for all olm images +00c7367c9 feat(make): add quickstart generation to release rule +943c42c48 chore(docker): update upstream.Dockerfile base to go 1.12 +64750a89b refactor(scripts): use existing manifests in package_quickstart.sh +c6b87a205 style(scripts): rename package-release.sh to package_release.sh +7eeb33542 chore(modules): revendor +b0be6e4c9 clusteroperator: Report when OLM reaches "level" and check syncs +6d4af4ce1 fix(csv): properly detect owner conflicts for crds and apiservices +4abff4adb fix(transitionCSV): reorder apiservice resource check +78dd09e4a more event emitting for CSV phase transitions +5526dde6c more event emitting for CSV phase transitions +3700a5ecd fix(contraction): requeue any csv that may need it after operatorgroup expansion/contraction +e707be584 feat(olm): update deployment annotations as soon as the csv annotations are available +c986d6ab6 fix(e2e): fixing e2e test after rebase +0f53418e8 chore(rebase): fix errors from rebasing +58a8184ae fix(opgroup): incorrectly detecting CSVs as "copyable" +f9d906484 fix(operatorgroup): set labels on copied resources correctly +3c89f1439 fix(olm): move csv copying into its own workqueue to free up csv processing +ae0737164 fix(e2e): fix e2e tests for operatorgroups +bb16a4643 refactor(olm): refactor provided api pruning +5434dec4c refactor(olm): simplify CSV copying/pruning +c08c52e28 feat(namespaceSet): add Contains method to namespace set +2259009e0 feat(olm): don't copy csv to operatorgroups if it's not in certain copyable states +b136cf416 fix(olm): delete copied child csvs with no parent annotations +85fe51df3 fix(operatorgroup): annotate all csvs and allow collisions +a0f16e77a fix(olm): delete stale resources after op group change +2024a6214 fix(opgroup): revert order of operatorgroup updates +dad85617c fix(requeue): requeue owners that are referenced with labels +973fb2418 fix(olm): change operator group / CSV requeuing +680f06e07 chore(opgroup): allow selector to be nullable so that marshaller can output an allnamespace operatorgroup +7060f104a remove minishift support +99c2fc603 docs: update CSV link +7622b74f4 feat(test): adds CSV phase reporting for package server +7553d1019 fix(test): fix labelselector pointer +b7d71876e fix(olm): delete api services upon CSV deletion +2046ca519 chore(olm): add debugging logging and handle potential list failure +4725ccdd6 fix(util): fill in GVK info from InferGroupVersionKind +c5877b578 fix(olm): Fix CSVs api-servers battle for ownership of APIServices +e7e7a2632 Make release +6e27f0f3d Add minKubeVersion validation to templates +57c9ef437 chore(manifests): regenerate manifests to include new validation +4ba65f585 fix(operatorgroups): use pointer for labelselector +31d873167 refactor(operatorgroups): bail out after successful namespace update +307e13d6e fix(csv): fix unsupported operatorgroup status update +916de307d test(operatorgroups): add installmode support e2e test +c8aeee46a fix(installmodes): update support logic to match expected behavior +bd5d352d5 fix(packageserver): set packageserver to IfNotPresent +045977b06 fix(load): return an error if a CSV specifies a replacement that doesn't exist +18cc7e4ef fix API validation for OperatorGroup spec +b607311e3 chore(deploy): run release scripts to get view permissions on edit/admin +cda5a387c remove rbac changes to 0.7.1 deploy maniftest +6f062ab11 update aggregate clusterrole to chart template +043151a92 add view rbac to 'admin' and 'edit' default roles +b77478e4a docs(operatorgroups): add more extensive docs +dd7fb76bf fix(packagesever): add missing name field to api definition +0ea74cf6a fix(owners): remove cross-namespace and cluster->namespace ownerrefs +9cef4dd35 add all-in-one yaml and helper script +9a3740171 fix(csv): remove regex on base64 image data +d7222352c fix(csv): icons in csv schema should be an array +9dc027fd2 feat(csv): allow use verb in permissions +cc9908053 Update README.md +9a3902a45 Rename upstream.Dockerfile to upstream-example.Dockerfile +053f32da5 Update docker commands in example to use upstream +e417e1d2b Add authentication to apprclient +9eb34b5fb fix(olm): properly detect cluster operator API +f17f0dd5b feat(catalogsource): allow grpc source types that don't require an image +ccd77162a fix(registry-pods): add everything toleration to registry pods +1c4ddd2a7 Incorporate new binary into docker images +d20b4936e Add appregistry-server binary +c29a6e3cc Add apprclient package that talks to app registry +b570441c7 graceful shutdown for PackageManifest server +9203775f9 fix(manifests): start manifest file names with 0000_50_olm_* +d91217121 Refactor configMap loader to work with appregistry +f1940f847 fix(csv): only allow one CSV per provided API across intersecting operatorgroups +50fbf6458 Add godoc for InstallModeTypes +57a7afcb3 test(registry): add InstallModes to CSV +d31025f10 fix(openapi): add InstallMode definition +925655bcc revendor and run codegen +25d72b41a fix(packagemanifest): Add InstallModes info from CSV to PackageManifest +e8f8655cc fix(olm): Remove the "v" prefix in minKubeVersion if presents +9f912b0e3 fix(e2e): fix instability in test runs +8f14c334e fix(e2e): add MinKubeVersion to helper function +67e3d1ef8 fix(build): remove dep usage +8c9136482 chore(build): make vendor +caf326347 fix(build): update grpc-health-probe for module support +b97a84d42 fix(deploy): Add a component prefix to manifests +2ae16e15f fix(build): make static build work +c178f5d48 chore(modules): update operator-registry module to v1.0.6 +d82344597 fix(deploy): fix image references +a65328f14 fix(deploy): set writeStatusName for ocp builds +868528e3c Update README.md +7b7ae8dcb fix(subscriptions): respect startingCSV +ae5c508d3 fix(installplans): only create installplans if something new has been resolved. +b5d0fa058 fix(reconciler): set command in pod spec of registry images +78a126960 chore(olm): run make vendor +975ad4c55 feat(olm): write operator status by default +1d6b495c8 fix(subscriptions): add check for csv manifest dif before applying new installplans +b1fa131ff fix(e2e): ensure all subscriptions are deleted in replacing test +e027882a1 fix(subscriptions): fix race between subscription sync and cache +d6fe1d4db fix(dockerfile): user needs enough access to read from the filesystem +30e6fd6ba fix(permissions): Generate unique Names for permissions +7e5d76415 chore(modules): update version of OLM module and revendor +cbb8b85fb fix link for Package Server CSV +3c8e6ad5a add ownerReference to backing ConfigMap for given CatalogSource +83d7c58b0 fix(catalog): use installplan lister instead of api client +6e29b7ea9 feat(lister): add installplan lister +7dadd63f8 fix(e2e): only select installplans owned by subscriptions +4fc1890f4 feat(catalog/olm): add tracking ids to logging +cc707d518 fix(catalog): remove gate on operatorgroups for resolution +b0d8941aa fix(dockerfile): move configmap-server into path +32550468e test(subscription): update unit tests to use the namespace resolver for subscription tests +7b07a12ca fix(catalog): move write of installplan state from installplan execution into namespace resolution - this prevents races where installplans are created twice. +8f86ad348 fix(installplan): only resolve if there's a subscription in the ns that isn't up to date +8a4121934 fix(installplan): fix bug where too many installplans can be created +46794f8ec fix(cm-reconciler): query for pods to overwrite by CatalogSource label +a8d9c7769 chore(deploy): change 30 prefix to 50 +1b9468098 chore(style): run goimports +55438ab31 fix(installplans): add ability to apply Services +047cd1971 fix(test): get kube version from client go for tests +a524d1674 chore(deps): vendor +39cdaad0d fix(catalogsources): omit unhealthy catalogs from resolution +459d86b0a fix(installplan): fix race in installplan resolution +5698be925 fix(e2e): make e2e-local-docker work again +8c89b3464 feat(catalog): add grpc sourcetype to CatalogSources +4a5183c74 fix(registry): service label selector doesn't include resourceversion +eb1de5179 fix(catalog): use a different queue for each namespace +4be186cf6 test(catalog): add e2e test to verify configmap changes are detected +95ed12de6 feat(bundles): add GetBundle request +c146f9abd fix(olm): Provide correct format of kube version in CSV +5288a5ed5 fix(olm): always return a status on minKubeVersion checks +be95cc5a8 Add minimum kube version to CSV & check it against server version +e307808e5 WIP: add new minimum version field for kube +f3b3f36c6 test(validation): add test to verify OLM can use bundles with CRDs with min/max fields +b59f9bd7f fix(bundle): fix CRD conversion with minimum validation field +b5a2b47ea fix(packageserver): don't error out when listing +8ecc5da64 fix(operatorgroups): write out CSV status on OperatorGroup issues +6a46d07b2 chore(deps): update vendor directory +ef58599f5 fix(metrics): create another endpoint for prometheus +92c857223 cut 0.8.1 +4c48fe3de fix(deploy): add linux nodeselector +07e1cd7fd fix(operatorgroups): use copied csv for update status +ba067f232 test(unit): fix TestAPIMultiOwnerSet_PopAPIKey tests +a9bdff870 feat(packageserver): consume registry pods +4d1502429 Update metering InstallModes to support SingleNamespace +275186f2b Watch all namespaces in local setup by removing watchedNamespaces in local-values +ede8ca0d9 chore(ci): remove ci checks for PRs +a5c0963fd feat(registry): remove in-mem registry implementation +ef5b2b669 feat(resolver): take all subscriptions into account when resolving +c1c195036 Remove operatorsource installation +506edc8a1 fix(dep): bump olm types so that registry can serve new CSVs +5e6ec00e5 feat(client): expose underlying clients +43b5c8c3e fix 1663113. Add component image ENV vars to cluster-logging-operator fix 1662397. Add permissions to create shared-config roles and bindings +165b3440c update Service Catalog memory & cpu limits +3f68bd4d2 adding csv, crds, package for metering operator +00ee55020 feat(installmodes): add installmodes to templates +406474b17 feat(installmode): add InstallModeSet +7d6753bd3 refactor(operatorgroup): account for TargetNamespace field in updateNamespaceList(...) +022a23a85 feat(csv): add installmodes to CSV spec +574534883 update codegen for 2019 +b7174678a fix(configmap-server): switch dockerfile to go 1.10 +f276c7bab fix(configmap-server): gvk parsed for owned CRDs incorrectly, so bundles were omitting CRDs +f2c19df89 Updated MongoDB Operator to 0.6 +37aaaab06 test(catalog): add an e2e test verifying that the rh-operators catalog starts up correctly +e786106bb fix(crds): remove category all from CRDs +936f30312 refactor(schema): split groupOrName into group and plural fields +99af1d8a3 chore(codegen): run codegen +8724cf751 chore(tools): add golang/protobuf as a tool dep +24203a998 feat(codegen): add container-codegen make rule +5f9b21f63 feat(olm): add message to requirement statuses +03b6ff80d fix(unit): fix tests involving CRD status +50227493c fix(unit): use global logrus logging instance +36ca0f607 Verify CRD's condition to ensure it's registered with k8s API +2213da1bd fix(packages): add sourceNamespace to packages apiserver +780c7da9b requeue dependent subscriptions when a catalog syncs +35cb43134 fix(sub): set subscription to failed if there's no catalogsource +d3f7e2e68 fix(charts): add operator_namespace to run-local values +5d637db1e chore(ci): add OWNERS file +adecf7d47 Install operatorsource crd and default cr +166bdcdc9 increase memory limits on all service catalog pods +85754a591 chore(fake): add fake for registry client +20b0487b0 refactor(Makefile): rename test rule to unit +79a4b1b5e chore(Dockerfile): remove directory check +474834c10 fix(build): enable cgo +9040a39e4 chore(go.sum): regenerate go.sum +324aa4786 feat(make): prevent test caching +bf072023f fix(test): add missing fields to expected bundle +aec9d5950 fix(client): correct package used for healthcheck client +cd5b6d7fb feat(image): add CI compatible Dockerfile +fd5f8758f chore(deps): vendor +d1c52bff6 test(registry): add checks for registry pods +e7fbda496 feat(catalog): use operatorlister in catalog operator +e6a525627 feat(registry): when syncing catalogsources, generate pods that serve the operator registry api for configmaps +d643abb1f feat(catalog): add configmap server image config flag +a338c9d2e feat(api): add registryservice to catalogsource status +3e0e45f64 chore(olm): make use of operator group constants +67653a5c9 fix(olm): don't annotate target namespace on copied CSVs +24e120898 feat(rbac): generate cluster role for viewing CRD for each provided api +4614df31a add 'get' permission for the CRD itself to the created Role +d0f57b81e fix(deploy): fix marketplace manifests +c8d4d3879 fix(health): move health to its own package with the right package name +f4f14e91b feat(health): add gRPC health probe tool to docker images +263d1d506 Add Marketplace csv +77292f514 Creating csv, crd, and packages for clusterlogging and elasticsearch operators +77fc133c7 fix(deploy): add runlevel to openshift-operators +84d2c53ef fix(schema-check): fix schema check error bug and update manifests +93a7f370c feat(csv): make apiservicedefinition pluralname required +0741fe54f refactor(logs): factor out default writer hook setup +07a1114fc feat(configmap-server): write panic and fatal log levels to a termination log - adds `termination-log` flag to `configmap-server` binary to specify termination log path - writes panic and fatal log levels to a termination log +25bfdcca0 feat(registry-server): write panic and fatal log levels to a termination log +10670752d feat(logs): add WriterHook type for splitting log levels between writers +f4e93cf64 fix(go-mod): fix checksum issue with client-go go module +de7a6951c feat(olm): generate clusterroles for provided apis in csv loop and aggregate them to operatorgroup clusterroles +9e88aac5f feat(operatorgroups): don't process CSVs that aren't in an operatorgroup +5543d0032 chore(manifests): regenerate manifests +d62e71aa0 test(packagemanifests): add wait for package-server to be ready +655b10ba3 feat(subscriptions): requeue dependent Subscriptions on CatalogSource sync +df410b47f feat(helm): create helm templates for package-server subscription +5abc4daf3 Updating: adding description to package manifest object - solves ALM-819 +9055ba276 add rbac for servicebindings/finalizers +377ec21d4 Make use a valid clusterPermissions rule verb +772f1db38 chore(docs): fix markdown lint warnings +86d4b4d62 docs(arch): add operator groups +98970c61e increase limits for embedded etcd +1a627c1d0 chore(release): switch image-reference tag to operator-lifecycle-manager +e7d66c8f4 use quay.io vs registry.reg-aws.openshift.com +76581508d regen manifests +c5cc09aa0 fix(scripts): clean up all resources when done +0be9286ae feat(deploy): add operator group to watch all namespaces +1640fe921 chore(scripts): add quoting for safer bash +00e70a34e chore(docs): fix up whitespacing +846f1f95f Descheduler operator CRD, CSV +285de2730 fix(e2e): make operator group test more robust +f45a4f45a feat(ci): remove e2e tests from gitlab +31766b91d chore(manifests): make release +5815ef4a6 feat(package-server): self-host package-server with CSV +7e0447ebb fix(e2e): create CSV first to use in CRD ownerref +d1df2b6a2 fix(e2e): use testNamespace for ownedAPIService test +db65feb62 Fix a typo in documentation +4703e7c9a fix panics in package-server +c43cf67b8 fix(e2e): set up variables for non-bare e2e runs +d87b352b7 feat(e2e-bare): add utilities for running olm and e2e locally against a remote cluster +820e9e5a6 feat(make): add e2e command for running from ci-operator +6f3600144 test(csv): use mock-ext-server for owned apiservice e2e test +d201e7396 fix(annotations): merge CSV and pod template annotations instead of replacing +220616c44 fix client-go in gomodules +61ceea9d1 fix(bundle): fix CRD . parsing +05f4f3cff add packagemanifest:aggregated-apiserver-clusterrole +360ce2fde Add packagemanifest:aggregated-apiserver-clusterrole +c73307e23 feat(operatorgroups): move annotation projection to csv loop +2730daf40 test(operatorgroups): more comprehensive tests of operator group copying and rbac generation behavior +27b195273 fix(e2e): add operator namespace to target ns list +4ad704dd6 fix(unit): account for correct rbac resource parsing +e02bca22b fix(e2e): account for operator group type change +a4fd04eec feat(operatorgroup): create role bindings for operator service accounts in target namespaces +55e67a96a propagate labels from 'CatalogSource' to each 'PackageManifest' +61480a0e3 fix(csv-requeue): requeue on namespace all if all namespaces are watched +ab3883aff fix(olm): create cleanup function for olm deploy mod +5578e8a4e fix(olm): fix RBAC cluster role creation +4e4f50087 chore(olm): add additional debug in requirements +a7ec12e50 fix(olm): add additional validation for operator groups +b0ed43694 feat(olm): use cache listers in olm-operator +097341675 cut 0.8.0 +20e6155ee chore(build): remove vendor commands from base dockerfile +1a90ec0c6 chore(release): bump version to 0.8.0 +410eae4f9 feat(mocks): generate fakes and mocks in a container +26f089585 fix(rbac): use separate queues for each rbac resource +b9c1b02c5 fix(queueInformers): use separate queue for each namespace +1a4fa284b fix(logging): use structure logging in checkAPIServiceResources +759d9005a chore(olm): remove cleanup func from operator +5af8a7878 remove namespace annotator +ab09d5ab4 fix gomodules (broken by client-go mutating their release tag) +35191e341 chore(ci): remove verify step from gitlab +a26ef5745 feat(container): make container builds faster +5acebac83 chore(codegen): run all codegen in a container +546ca8fc6 chore(deps): switch to go modules +da014b133 feat(csv): detect deployment and requirement changes in Succeeded and Failed phases +934a667b8 use OpenShift's ServiceCatalog build, fix rbac + more +05248e810 Update AMQ logo to new brand standard +fd6d9d41f Fix template values for 'olm' parameters +3ad3d5250 feat(build): allow skipping minikube during local builds +86eedf88c fix(olm): make operator group copy CSVs more efficiently +f095b0cfa fix(olm): remove duplicated code +3bb7e25d5 chore(olm): refactor updateNamespaceList +e7bce974f fix(unit): create OperatorGroups with initial fakes +777e33cd6 chore(docs): update readme with configmap-sever and pkg/client +08ee59ca5 feat(health): add healthcheck endpoint +2de662325 feat(schema): add validators to directory loader +3bc77b9e9 feat(client): add grpc client interface +bcb4ef9b7 feat(bundle): add package/channel name to bundle +eb2ab43a4 chore(deps): switch to go modules +59ca95847 fix(olm): do not check namespace if casting failed +80c876ef8 fix(olm): operator group annotations and listers +33f83dc49 fix(e2e): slightly improves execution time +59d7698eb fix(olm): set event handler functions correctly +c89aa9cbb fix(olm): refactor e2e and check annotations +2e8cd467b WIP: cvs in operator namespace are being annotated, csvs in target namespaces should be annotated +a4ccb4ea9 fix(olm): adds debug logging for operator groups +7af0b4274 feat(olm): detect dangling child csvs in olm operator +7a65c2b84 fix(olm): handle copied CSVs when deletion occurs +48279b413 fix(e2e): update e2e for refactoring +4b5070abf fix(unit): fix race condition +bc96bb9ea fix(unit): set expected owner refs for deployments +c969049c0 refactor(operatorgroup): split apart the larger sync functions +43f64db30 fix(e2e): ensure created objects are deleted +df5b760fc fix(olm): make RBAC creation resilient +552699b61 test(e2e): add second e2e for operator groups +efafe6cc8 fix(unit): call Run on operator directly +24ceed696 test(e2e): add e2e test for operator groups +c12dd0acb fix(olm): make status updates on deployments, not CSVs +090e09169 test(unit): add unit tests for operator groups +2e3b84bba fix(olm): change annotations to be allocation safe +8f954fef8 feat(olm): copy "dummy" CSVs to target namespaces +891f247bf feat(olm): handle required RBAC permissions +c39e3bd0d feat(olm): make namespace updates trigger annotation updates +65fc370a2 chore(olm): rename annotateNamespace to syncNamespace +245092f00 feat(olm): add operator group control loop +e88b05108 feat(olm): add CRD definition for OperatorGroup +81c635217 chore(olm): generated files +9c2e92f3d feat(olm): add OperatorGroup types +6b80c5e4c Add test case for supporting multi-version CRD +a086ddbfb fix(build): add cleanup for package release files +c92d07ede Fix olm pod name so log to be written correctly to olm.log +a686d26c2 fix(olm): set lister up for deployments +927097c9c add 'spec.nativeAPIs' field to CSV and check that native APIs exist before install +dd9d1effa add Service as owned resource for Prometheus/Alertmanager CRDs +2057a5a8f feat(listers): add and use aggregate informer lister +ee5b4ae1a feat(csv): add generated APIService resource check +d35c0e44b fix(ci): cleanup packagemanifest APIService during deploy stop job +63a08e6ff feat(csv): add succeeded to pending transition on cert refresh +4aa3dc9c9 feat(csv): add configurable APIService cert expiration +af7aaef7b feat(apiservices): add APIService adoption logic +c357affb0 refactor(ownerutil): make HasOwnerConflicts generic +4b65ea613 chore(test): bump minikube kube version to 1.12.0 +40b9aca47 fix ClusterServiceVersion CRD to allow any descriptor default value +a5b2c7e06 added spec/status descriptors for Dynatrace Operator +09d5d2c67 feat(grpc): enable reflection on grpc endpoints +8e464096f feat(configmap-server): add dockerfile which builds and runs configmap-server +b975d8cb5 feat(configmap-server): add configmap-server binary +16d58cbcc chore(deps): update dependencies for version-config +51bffd94f feat(registry-server): add server binary that speaks grpc +7ccd900bf feat(grpc): adds basic gRPC interface to querier +18e518dce emit events when setting CSV phase +29fe5db4d Add `assign` verb to csv crd +a3db7f955 chore(release): cut release 0.7.4 +9b2995211 add ConfigMap as an owned resource for Prometheus CR +197e96843 [Doc] Add note about helm binary requirement +4145a1806 chore(release): bump version number to 0.7.4 +7b8b4d965 feat(load/query): support provided APIs that are apiservices +e3c57bf55 chore(deps): depend on latest OLM +78cd6aef2 feat(configmap): add configmap loader +2d79c5e74 fix(e2e): switch to port 5443 for owned apiservice test +762b71f4c chore(e2e): change package port to 5443 +b404cbf8d fix(olm): don't annotate namespaces on operator creation +082cc655d feat(deploy): add debug variable to all deployments +c18a09fe6 fix(package-server): make secure port configurable and default to 5443 +68ea1a40c chore(package-server): enable auth by default +c7f7d014f pass annotations from CSVs to associated PackageManifest +6ce20c55d adding more spec/status descriptors for CouchbaseCluster +993bfaf65 fix(metrics): use CRD client instead of k8s +383ecd915 Update OKD install instructions +05a785a87 fix(requirements): add CRD served version requirement check +11fb00bf5 fix(requirements): add support for non resource url rules +2134f0bc8 rewrite 'metadata.namespace' of global PackageManifests +5ca5dff37 bump olm version to 0.7.3 +8d1dc0cdf chore(deploy): remove unneeded dockerfiles +bec794bc3 fix(csv): make invalid install strategy transition from pending to failed +3deda8696 fix(requirements): remove extra empty permission requirement statuses +c7002dc28 Add missing nonResourceURL verbs to csv validation +860d44536 cut 0.7.2 +78d575e32 chore(deploy): update release scripts to not use 3 different images +fb851e585 chore(deploy): put all binaries in the same image +c402e10fc add 'catalogSourceDisplayName' to PackageManifest status +8105c238f fix(ci): use deployment namespace as catalog_namespace +50272f783 Small log statement fix +d62c141af chore(deps): remove unneeded dependencies +33c3455fd chore(pkg): make more like a kube-style go package +cee0231ed feat(query): open db as immutable for querying +5c4df7f1d feat(query): add query interface and refactor tables +57c11c154 feat(load): add package and channel loading +f1543cde6 refactor(store): add storage abstraction +853ef172f feat(loader): create basic loader that puts csvs and bundles into a sqllite db +812dfaceb Initial commit +42db65951 chore(deploy): use runlevel label on namespace +01ad7f88e docs(apiservices): add some detail on APIServices in CSVs +ffc9f1ffa feat(svcat): add service-catalog manifests +ccc90f8c1 feat(csv): install owned APIServices +80d5d4d72 chore(deploy): Add runlevels to release +576bd7f97 chore(ci): Use a single Dockerfile for ci +a4e548c1e Make use a valid clusterPermissions rule verb +ba4c536a2 Remove explain 'annotations' and 'replaces' +79f74adf3 add example and additional info about optional CSV metadata (replaces, annotations, labels, selectors) +b6eb190be return PackageManifests from 'global' namespace +10e333f6f fix 30_14-imagestream.yaml formatting +5f4124db2 add 'spec.provider' to Federation CSV +0720b00da Update registry unit test for FederationV2 +0c5f96f9d Split out FederationV2 CRD file into many files +2f423feeb Update FederationV2 CSV to add spec fields +d9d694c89 rh-operators: add FederationV2 v0.0.2 +577a4fc82 Add missing binary to fix run-local-shift +a6a89d1a7 fix(deploy): add base images for ci-operator +90ea442dc Dropping label for origin releasepayload +372ccfda7 implement watch for PackageManifest resource +228bcfd4b feat(package-server): add minimal watch +f6d7f7bc4 fix(build): don't vendor +32849e132 change go build to use 1.10 +bf4a190a1 fix(submodules): remove submodules +84df81088 fix(deploy): only use replace on configmaps +442b1efcb Revert "fix(deploy): remove package-server until ci-operator is outputting the package-server tag" +86dfcb241 fix(deploy): remove package-server until ci-operator is outputting the package-server tag +7a6397510 fix(deploy): yaml error in imagereferences +9810bc424 fix(deploy) rename image stream to `image_references` +9c2407f17 Add manifests to dockerfile +d8d886adf re-cut 0.7.1 +ad49bfffb docs(rule_checker): update hasOwnerConflicts comment wording +c4c1daa7d test(rule_checker): wait for informers to sync before continuing tests +db157196f refactor(olm): use SharedIndexInformer listers for RBAC resources +8ec2872c7 docs(rule_checker): add reasoning note to hasOwnerConflicts method +f786d5ad0 chore(dep): constrain k8s.io/kubernetes to the release-1.11 branch +4bee692f0 chore(comments): correct comment mistakes +d93643dc7 test(deployment): remove/refactor tests expecting RBAC installation +5de6abb67 chore(code_gen): regen mocks and openapi +9f786750a refactor(olm): add DependentStatus message field +96c41c543 test(csv_e2e): add e2e tests for permission requirements +4bb2ddf53 feat(olm): add ClusterRole/Binding requirement checking +4db66160f refactor(rule_checker): move rule_checker to install package +015b67ee4 feat(permissions): add RBAC permissions as CSV requirement +4282e8606 refine cluster-admin OLM workflow +4687eae95 certified-operators: rectify form of business for Dynatrace +19b060924 test(installplan): test clusterrole and clusterrolebinding resolution +907830ea5 refactor(resolver): move step resolution to resolver package +728b77743 feat(catalog): resolve ClusterPermissions on CSVs as part of an installplan resolution +9895763b2 feat(deploy): add clusterPermissions to CSV +3078c946f fix(deploy): update upstream release +df5006c58 fix(ci): don't create namespace (it's in the chart now) +cc7ba87e7 cut 0.7.1 +e04dec6bc feat(ci): push tags to quay +438f78da0 re-cut 0.7.0 +201b9be82 chore(deploy): add package server to release scripts +db0185040 Issue #469 update the service catalog instruction for minishift. +4a10ee634 fix(olm): don't both checking for GVK in discovery for CRDs +7febb04bd feat(e2e): use newNginxInstallStrategy helper to clean up csv e2e tests +07ffd1cc0 test(olm): add e2e tests for depending on apiservices +81230fd72 test(olm): add unit tests for depending on apiservices +17b25b08a feat(olm): check for the existence of required APIServices before installing +033abf478 chore(deps): add kube-aggregator to get APIService types +2794c3a1b feat(apiservices): add support in CSV for apiservices +725a0cc69 chore(catalog): remove TODO comment +00d077b6c chore(mocks): regen client mocks +57eca037a refactor(resolver): rename resolved RBAC resources +4fd31ca37 feat(catalog): add OwnerRef patching for ServiceAccounts, Roles, and RoleBindings +21585d6f0 feat(operatorclient): add Role and RoleBinding clients +65d2c98f5 fix(catalog): update OwnerReferences with stored CSV UIDs +b9d21d166 refactor(installplan): move scheme build to init +7b685f654 feat(resolver): generate UIDs for freshly resolved CSVs +8b87f1bf2 fix(catalog): handle creation of RBAC resources in plan execution +b5a4713fa test(catalog): add e2e test for InstallPlan RBAC resolution/execution +8094fc49e feat(installplan): resolve RBAC resources during InstallPlan resolution +a2d5f4eac feat(installplan): enable creating step resources from runtime.Object +32cfc26ec return all 'PackageManifests' for 'all-namespaces' +d2eab9cf6 feat(olm): add metrics +0e4167295 Documentation: Change to full path +14b3482ef Create OWNERS +b6e34b70b Improvements on the MongoDB Enterprise Operator CSV. +113407d06 List out options for Descriptors +e7cfbac65 test(e2e): add OwnerReference GC behavior test +73a292419 style(e2e): re-order imports +9245fe5e8 cut 0.7.0 release +bb8f78305 feat(deploy): update makefile to generate deploy artifacts for okd +e140db8ea cut 0.7.0 images +07e3fb437 fix(vendor): revendor dependencies +780ce7c75 feat(olm): attempt to cleanup namespace annotations on shutdown +1ddf8b5ab fix(scripts): short-circuit up to length 1 running pipelines +e6c8b7258 style(scripts): snake_case is_head function +55786a805 fix(ci): move wait-in-queue job before deploy-preview +427da0761 feat(ci): add wait in queue job to test_setup stage +2f8a379d9 feat(scripts): add pipeline queue wait script +fc5d4626f fix(e2e): update prometheus channel +5764db8e2 rh-operators: use preview as channel for Prometheus +5402a4c69 rh-operators: use preview as channel for AMQ +621f218cf certified-operators: use preview as channel for Dynatrace +efcfc1a6f certified-operators: use preview as channel for MongoDB +92c39c7e1 certified-operators: use preview as channel for Couchbase +542e4c5f8 certified-operators: add double spaces in Mongo markdown +84c08e330 certified-operators: fix Mongo markdown lists +67402a8e5 certified-operators: add required parameters for MongoDB +d09dde676 certified-operators: add required parameters for Dynatrace +4f8eb35d8 certified-operators: add required parameters for Couchbase +793e813b0 Fix certified operators packages csv refs +4423d7afc include certified-operators catalog in deploy on CI +8420ccf4d Update directory loader test for amq-streams +ed31d09f2 certified-operators: update Dynatrace version +1f68e32f4 certified-operators: add Dynatrace CSV + CRD +c7126206b certified-operators: add Couchbase CSV + CRD +3f440bfc6 certified-operators: add MongoDB CSV + CRDs +7797a6643 rh-operators: add AMQ Streams CSV + CRDs +051f57e7d feat(catalog): add aggregated roles for each crd we resolve +0a608ad7e fix(reststorage): start with empty slice when filtering +db3942765 feat(inmem): collect CSV data in PackageManifestStatus +77cee5d03 chore(server): remove commented packages +94935273b test(e2e): use CSVDescription in expected PackageManifestStatus +66bd1bd4a chore(openapi): regenerate openapi spec +b7cacfab5 feat(packagemanifest): add CSVDescription to PackageManifest +2267c5ac0 fix(build): add OLM_VERSION file and .git directory to e2e.Dockerfile +1eeb7b32d test(packagemanifest): add fetch function for packagemanifests +9eb5b27c9 test(e2e): add logging to TestPackageManifestLoading +a66cb8fb4 fix(charts): change cert secret mount path +b4fd5c712 fix(charts): change default package-server internal port value to 443 +c57cd7365 fix(charts): update expected package-server chart value name +49fdd3f24 refactor(charts): use olm-operator-serviceaccount for package-server +4d97b9bac fix(charts): correct indentation +39f009bb7 fix(charts): add missing coreos pull secret +3c5621d13 fix(scripts): uncomment cleanup +0cc75e2fd feat(ci): add package-server to ci +d01ba48da feat(scripts): add package-server to build scripts +698832f56 feat(docker): add package-server to Dockerfiles +2e527c6d4 feat(reststorage): return NotFoundError if manifest not found +b74429868 fix(provider): don't use pointer in manifest selection loop +e7f4f99c1 feat(package-server): add debug flag +7c29094cb fix(package-server): surface cobra flags to package level +8555e6cb8 feat(package-server): add run-local package-server helm values +c677e3b99 test(package-server): add basic e2e test +7dcd3763a feat(deploy): update package-server templates +3d9744815 fix(inmem): change struct tags +978e9fed1 refactor(packagemanifest): move all package data to status +b37b5821d chore(package-server): remove and ignore local config +5ee54cd3c feat(package-server): enable openapi +dd56ae77a feat(package-server): adds skeleton of package server +bd3d54fd7 fix(prometheus): add securityContext to alertmanager example +85108765a Recommend installing OLM with `kubectl create` instead of `kubectl apply` +8b1abe1a2 docs: update broken link +81d09f937 docs: text -> label +36ea39607 docs: move desc to bottom +530bc0518 docs: add CSV guide +56ff27a19 fix(build): remove GOOS and GOARCH settings +52b5296e9 feat(build): add version injection to go test build +acc784adf style(flags): change version output format +0f90e0009 fix(build): point version build ldflag to correct package path +5b503d2a6 feat(cmd): add version flags +7c93f7155 chore(osbs): remove unused Dockerfile.single +78b9b0a7b feat(run_console_local): add docker pull for console image +c19ac11a0 fix console script to work with both Linux and MacOS +ee48d103e chore(broker): remove servicebroker from CI +8dcd2a8c7 chore(rbac): add olm-specific ClusterRole +94b3b30f7 Remove outdated install instructions +9e7956d19 remove non-go references to broker +62dadcee2 prune dependencies via dep ensure +dde0a7e48 fix(servicebroker): remove broker from repository +c108aea18 chore(deploy): remove ansible scripts for install +d4741172a feat(osbs): add non-multistage docker build +76dd0dbd0 fix(scripts): allow use of existing KUBECONFIG env var +ad56ecc22 chore(catalog): rename ocs -> rh-operators +68f1a9e91 chore(rbac): remove view verbs from edit role +59ad7e3cf chore(prometheus): remove namespaceSelector from ServiceMonitor +2c211124a fix(scripts): make cp cross-platform +6acd8a48c chore(api): move non-generated apiclients out of the api dir +07b5110ac add script and instructions for running OpenShift console +97b27fab3 fix(Dockerfile): fix catalog copy typo +ab70f7dba fix(Dockerfile): add catalog bin to final docker image +2256df73c chore(ci): update gitlab-ci.jsonnet to reflect Dockerfile name change +bb59bfdb5 refactor(Dockerfile): make Dockerfile.rhel7 OSBS compliant +31e3eba25 chore(dep): vendor dependencies +4125547c2 updated prometheus csv according to the integration into openshift +6b80809d5 test(e2e): add catalog loading between operator restart test +5d9e452eb add actionDescriptors block +b23c8efe6 feat(subscription): add dedicated currentCSV field to subscription status +2203111f4 fix(catalog): add check for loaded catalogs +439256825 fix(operatorclient): remove wait for deployment rollout +374290c40 set 'status' on Subscription when 'spec.source' is invalid +6a7518a31 fix(e2e): remove deployment cleanup +3f4e27e07 refactor(operatorclient): remove error return in deployment poll +4491d8403 fix(operatorclient): return error from infinite deployment poll +6b4d2eba7 test(e2e): add wait for deletion during OLM cleanup +bf4a14a1f fix(catalog): ensure pre-existing check does not interfere with upgrades +c60ae953e refactor(resolver): incorporate custom error type +cb588e9c5 feat(catalog): add namespace awareness to plan execution +b8a269e99 feat(controllers): add custom error type for multiple existing CRD owners +27edc7317 style(operator_test): reorder import statements +7cb66c4ee refactor(catalog): return early from sync catalog +1c4bcb219 test(e2e): add deferred global cleanup calls to subscription tests +c14bc66c7 fix(e2e): move log after nil check +ad7caa09f fix(ocs): reduce prometheus requested resources +1d420641a fix(olm): restrict deployment watches to the watched namespaces of the operator +b71a302ca feat(operators): log which queue items are coming from +9efec1a28 test(e2e): remove cleanupOLM calls +745e5f78a refactor(catalog): only load in-mem when a change is detected +58feeb875 test(installplan): add helper functions for building test CSVs +7c1b83953 fix(catalog): correct sync logic to accept catalog spec changes +1187ed015 test(catalog): add wait for catalog sync to e2e tests +0719e0326 refactor(catalog): enable status subresource +0474469ac test(catalog): add catalog source sync unit tests +380940256 refactor(types): remove Hash field from ConfigMapResourceReference +1fb79a741 feat(catalog): add catalog status block updates +387f164ba fix(e2e): re-enable prometheus test +602285003 chore(rbac): update roles to include resources +4cf17efb4 chore(rbac): list out verbs in edit role +668805c04 update 0.6.0 release +db9a9f07a fix(ocs): add securityContext to prometheus example +cfdedb7b5 chore(deploy): update 0.6.0 for okd +111a95643 fix(ocs): update prometheus operator +c69496bb3 Fixes #416 +197bde49b Make key resources linkable in philosophy doc +b317a5eb2 cut 0.6.0 +9de59fd19 style(resolver): remove nesting from owner CSV selection logic +9f6c1d6e9 refactor(catalog): remove map-based subscription caching +1743c95c5 chore(dep): re-vendor with dep stable +cd85776a8 feat(resolver): add namespace and channel awareness +cf617c20f chore(docs): update docs for newer types +84868ef46 chore(ci): update catalognamespace for olm +0f1bbb332 fix(e2e): don't use vault in e2e tests +2d4b06951 chore(ci): disable teamui deploy +039988967 chore(catalog): update prometheus deployment for 0.22.2 +391c5928b fix(catalog_versions_test): test all releases +78547f8c3 chore(deploy): remove tectonic-alm-operator +517f061d1 chore(deploy): remove old catalog entries +8f5525034 chore(vendor): remove vendor directory +662609500 fix(e2e): use fetchinstallplan in subscription tests +08af520eb chore(e2e): delete duplicated test from merging +295d802cd refactor(opclient): remove fake operatorclient +38f4c25d1 fix(olm): re-enable a requeue +de2752e7a chore(fmt): order imports correctly +ea9bf4e92 fix(e2e): update fetchSubscription call to new use version +ab97ddc1c feat(deploy): add OLM type access to aggregated cluster roles +c8ec51dbf fix(csv): delete csvs immediately +83d17c7b0 feat(subscriptions): pick up installplan changes more quickly +2660204eb chore(logs): add debug logs if item can't be found in index +3376c3cba fix(deploy): key the rolebinding to the namespace so that serviceaccount won't lose its access when a new binding is created +0f8bfd5a5 fix(e2e): clear existing CSVs before running subscription tests +4a6ed5c60 fix(installplan_e2e): add deferred cleanup calls to installplan e2e tests +e4985b308 fix(subscription_e2e): ensure subscriptions are completely cleaned up +607b52f9d fix(subscription_e2e): add check and wait for subscription status +1e023d067 fix(cvs_e2e_test): move old serviceaccount existence check +e39f55bbe wip(olm): fix leaks +98d38f7ed chore(api): update apps/v1beta2 to apps/v1 +9c9e4533e fix(subscriptions): don't update subscription when there are no status changes +d05219d5f feat(olm): set up watches on deployments so that csv status can be updated more frequently +60010413e chore(tests): remove old mock-based tests in favor of fakes +e31534859 chore(tests): rewrite TestIsBeingReplaced with fakes +1d7360b12 chore(tests): rewrite TestIsReplacing with fakes +95c72be4c fix(olm): add fixes for GC optimization +06920b014 wip(olm): add failing upgrade csv test +07a2812b1 minor: broken link +c481d2225 chore(deploy): update deployment resources to use apps/v1 +5c2a51aef chore(api): bump deployments from apps/v1beta2 to apps/v1 +c606b220c update 'urn:alm:descriptor:com.tectonic.ui:selector' to use GroupVersionKind +f2a205b0b chore(ocs): Update to prometheus 0.22.2 but disable e2e test +6b8ff7cf0 feat(makefile): allow running a single e2e test from the make command +6d88c5f00 chore(e2e): switch to using the versioned clients in e2e tests +4abf88438 feat(api): migrate apis to common group and regen apis/clients +27800d810 fix(csv): update CatalogSource for 1.11 +b5f088377 fix(catalog): update Subscription control loops for 1.11 +f72e9f948 fix(csv): update Subscription for 1.11 +4e4368cf9 fix(catalogs): remove outdated EtcdCluster validation +a7d7dd653 fix(catalog): update InstallPlan control loops for 1.11 +95c2f5802 fix(catalogs): update catalog data to use ClusterServiceVersion +28ab3c373 fix(ip): update InstallPlan for 1.11 +e7072f953 fix(olm): update ClusterServiceVersion control loops for 1.11 +a9e652fff fix(csv): update ClusterServiceVersion for 1.11 +bbd1255b3 fix(build_local): don't start minikube if already running +608913485 fix(csv): k8sjson encoders don't properly omitempty on json.RawMessage serialization. +097c4f2f2 fix(crds): update CRDs to validate in 1.11 (versions field now required) +44a72746e chore(codegen): update codegen for 1.11 +0194241fe chore(deps): update k8s libs to 1.11 versions +036ae5481 chore(catalog_versions): remove extra lines in import +f9c8f2339 test(catalog_versions): add resolveCatalogs test for catlogs in each version +ee0196f45 refactor(resolver): make resolved step logging more helpful +0ff6cfd45 add 'spec.sourceNamespace' to the Subscription CRD validation block +0105c944c docs: add access control workflow +ca90d23aa fix(ci): deploy files to ci cluster in order +32d8e90f6 fix(makefile): fix run-local and run-local-shift +a1486e2cb fix(e2e): update prometheus serviceaccount +f10bc0f90 fix(make): fix local e2e +e211d3e23 fix(e2e): update e2e prometheus test for 0.22.0 +2edc560a6 fix(deploy): put prometheus in ocs catalog +351cb3d88 fix(ci): update ci to use replace +d2dda9d52 deploy/chart: bump prometheus to 0.22.1 +8cbffb90a feat(catalog_resources): add prometheus 0.22.0 +03124436a test(installplan_e2e): change main package name to avoid conflicts +271600231 style(catalog): add missing semicolon to log +bfe9ac670 fix(catalog): remove required CRD existence check for service additions +b749aac27 test(installplan_e2e): add multi source install test +4f27e0baa test(util): add internal catalog source creation helper function +31dc52771 Fix invalid `minishift start` option in install_local_shift.sh +3a66ebc5e chore(ci): update gitlab-ci.yml from jsonnet +3cdcbf16a fix(installplan): type InstallPlan.Status.CatalogSources to []string for backwards compatibility +bfd82e638 chore(ci): update gitlab-ci.yml from jsonnet +8910b0f54 need to use 'operator-lifecycle-manager' namespace but ffctl is broked +a17754f00 fix(subscriptions_test): replace single source resolver with multi source +e21e79ec2 refactor(resolver): accept prioritized list of source refs as a parameter +03f8b6a04 refactor(catalog): change parameters of getPrefferedSourceKey to take a source snapshot +d93c54b8b fix(e2e-local): remove extra RBAC config on minikube start (default in newer kubeadm versions) +c549f66c7 fix(e2e): apply charts from templates directory +d01ac8c39 refactor(InstallPlan): add source name and namespace to install plan custom resource +a92fe931e refactor(catalog): limit sources snapshot to global and install plan namespaces +9e3df88a0 feat(catalog): add catalog and catalog namespace to install plan spec +bb8078868 feat(catalog): add helper method to get preferred source key from plan owning subscription +9545f2152 feat(registry): add subscription key type +d5769bfb8 test(resolve): decouple expected results from test input +bbcf01ca1 refactor(resolver): return used catalog sources slice from ResolveInstallPlan +9e743b3f4 chore(registry): dedupe to in comment +9354895a0 refactor(InstallPlan): use registry.SourceKey to keep track of used CatalogSources +4d69b3cfa chore(.gitignore): remove vscode file exceptions +f632f4010 fix(resolver): set resolved csv namespace to plan namespace in MultiSourceResolver +eae597485 feat(catalog): use MultiSourceResolver in catalog operator +c7b14e40f test(resolver): add tests for MultiSourceResolver +3c7d33482 refactor(catalog): add helper method for getting a sources snapshot +0d6bb9c47 refactor(resolver): remove extra functions from DependencyResolver interface +1a45332bf feat(resolver): add CatalogSourceNamespace field to StepResource struct +1165abfab vendor: re-run `dep ensure` +25511b20b cut 0.5.0 release +50c897e3a feat(release): build a release package from a tag +91c38ab3d fix SingleSourceResolver to use plan namespace for resolved CSVs +06b50db63 refactor catalogLabel to catalogLabelKey +325261689 fix namespace used for CatalogSource lookup +abe61f64f refactor resolver to be in separate package +3b182f3bc refactor interface method parameters +50490e0e3 fix remove .vscode/launch.json +654e93e88 remove test for MultiDependencyResolver +bddbf013c add test for step resource catalog source +b3c455587 add DependencyResolver interface and SingleSourceResolver implementation +d23e85a8f refactor interface method parameters +6b40120fc fix remove .vscode/launch.json from .gitignore explicit include +16589abea fix remove .vscode/launch.json +543c64122 remove test for MultiDependencyResolver +4d003a0e3 fix CatalogSourceStatus.ConfigMapResourceReference json struct tag spelling +980db9111 add test for step resource catalog source +6b8b5ff57 add DependencyResolver interface and SingleSourceResolver implementation +cff0db1a3 add 'spec.catalogNamespace' field to Subscription-v1 +bd7b58c2f fix catalog_namespace for deploying to OpenShift +e55a60890 deploy to TeamUI's OpenShift cluster +b36fd16a0 fix(docs): correct spelling of philosopy.md +17ffa434b fix(docs): typos in architecture.md +250af4476 feat(olm-operator): prevent a CSV from installing if there is another CSV in the namespace that owns the same CRD, but isn't being replaced. +a2108bf9a Fix a small typo +a5c8eacfd add checks for runaway control loops in e2e tests +3daf90d41 fix(servicebroker): add main_test.go to servicebroker cmd +2348ddff2 fix(make): fixes run-local and run-local-shift +da4468ecc fixed panic(err) calls +dd623f1e1 check upgrade path per package directory +075c815aa changed filepath for pragmas +910b7f3f3 remove testing.T from manifest validation files +54dd79093 moved schema validation +9c6b98db0 chore(deps): remove tectonic-operators as a dependency +2bba14a79 feat(operatorclient): add minimal operatorclient types +194bd8c65 fix(make): set version var for run-local +94418b29d make 'InstallPlanPhaseInstalling' come before 'InstallPlanPhaseRequiresApproval' +caf34fd70 added docs for RequiresApproval phase +868a28ecc readme: fix broken link to CSV example +363c84034 fix(catalog): catalogsources should only read from their configured namespace, not all namespaces +d5d05c0c0 fix(catalog): release memory after loading catalog +b801bfc8d fix(ansible): make sure git submodules are checked out before ansible build +79ca1dc62 feat(build): add rhel build +d7d7a1177 chore(deploy): add openshift_ansible as a submodule in order to symlink lib_openshift and lib_utils +ce3b229f4 chore(deploy): add ansible playbook for deploying OLM +7d00b5e89 feat(ownerutil): update ownerutil to infer GVK for OLM types +c879cc35d fix(subscriptions): directly include apiversion/kind of created resource +c9dce1d7d fix(e2e): make e2e local scripts work again +3fc0a8d3d Fix the deploy to kubernetes command in install.md +fc6a7a7a5 do not update Subscription-v1 if nothing has changed +d1b6e23d2 chore(deploy): add upstream release and deployment pipeline +f9768c04c chore(build): use helm to template the catalog files in +8b1f7ee9d chore(deploy): which catalogs get included in a release is configurable +89fbf9a1d feat(servicebroker): list one serviceclass per package +9ad912554 fix(ci): codegen needs apimachinary to not be pruned +17f6121c2 chore(deps): update servicebroker for newer servicebroker libs +1f3d81f5a chore(deps): commit vendored dependencies so that project can be built by people without access to tectonic-operators +f6e8e3342 fix(e2e): fix local e2e scripts +9783645f9 test(e2e): add e2e test for Subscription/installPlanApproval +4ad6c1f0b feat(subscription): installPlanApproval field +b9e80e193 implement manual approval of install plans +e6810e636 strip Markdown from descriptions for OSB +222d82960 fix(servicebroker): reverse map check bool order +fade2fc00 test(servicebroker): check validatation of broker api version endpoint +4e49b72ee fix(apiserver): fixes rebase problems also removes the apiserver tests, which are empty +41f65aaff fix(apiserver): update imports +d11988b8c fix(servicebroker/types): dedup description +a97ea1654 fix(servicebroker/types): set bindable to false on serviceplans +ad074103e fix(servicebroker/types): use link url for support url in serviceclasses +a285b5402 fix(servicebroker): grab namespace from interface object +f156b318e chore(servicebroker): update types from broker libs +bcdc69033 feat(servicebroker): display icons and pretty names in catalog +92af257ed fix(servicebroker/apiserver): use un-normalized CSV name +7daa34551 temp(servicebroker/apiserver): log debug lines +d21077bc5 wip(broker/sources): implement LastOperation handler logic +5923fe185 fix(ci): fix e2e test runner +7f8419538 fix(makefile): add build-coverage command back for e2e testing +f93bfac38 feat(ci): multi-stage builds and verify codegen and catalog during build +bb724dfbe chore(ci): simplify container builds +54905993b fix(makefile): fix release scripts +b9fe8395c fix(deploy): chart naming after rebase +d1d8c984f fix(makefile): support ocs and ccomponent catalogs +6adef178e fix(makefile): always build targets so that dockerfile builds work +75314ee29 fix(broker): use updated imports for osb +e3c90bcde fix(makefile): xargs working cross-platform +dcfa5355e chore(deps): update lockfile +0aededa15 chore(rename): fix path in catalog version tests +e788c53cc fix(Makefile): update makefile recipes for rearrangement +e4a207468 chore(servicebroker/apiserver): update broker interface types +44e654018 chore(Makefile): add target to run e2e with minishift +b51858ba6 fix(deploy/chart/templates/01-alm-operator.serviceaccount): specify pullsecret +fcded45ae rearrange(deploy/chart/templates): create secret before clusterservicebroker obj +9f32512ea fix(.): update scripts with e2e dir move +792d366c1 fix(Makefile): codegen clients correctly +11b0fd0f2 chore(*): update github repo org +2f270b789 chore(makefile): clean up build +faf8375dc fix(Makefile): add '-' back to flag (rebase fix) +3a2416e86 feat(deploy): add servicebroker templates +5746da11f feat(broker): add service broker service for alm +499afff02 fixup(api/client/util): return err instead of panicking +84498f5fd use environment variable for TEAMUI_HOST +19f0b8263 use InstallCheckFailed instead of DependenciesConflict +d6e77454b s/ALM/OLM for Slack webhook +93eaddc6d Update manifests for 0.4.0 release +0ed1cf517 fix(catalog): pull secrets are no longer needed for vault and chargeback +a7f943afe Update README.md +bd6b73565 Update README.md +9f4b4027c Update architecture.md +24bc4f7d4 chore(rename): ALM -> OLM in design docs +19adb6066 Add simple install instructions for using a released OLM +72d4974f5 chore(rename): rename ALM -> OLM in install docs +19e95d9cf Remove unneeded install steps (minikube fix and pull secret) +45cc1d27d chore(rename): rename quay.io/coreos/alm -> quay.io/coreos/olm +3f8dc2891 readme: restrict SVG height +5721eed44 added intro for framework +edc68169a fix(ci): update paths in dockerfiles +a0e81f0b3 chore(codegen): run codegen on renamed codebase +4d7d550e7 chore(rename): rename alm -> operator-lifecycle-manager +0ba0253dd chore(ci): update ci to use new operator-lifecycle-manager repo +8a40137cf Add pipeline status to readme +2a2ddebaa Update readme +7c5b7c638 *: add code of conduct 🎉 +0133f3c7e re-cut 0.4.0 +1176500c9 fix(e2e): same deployment install strategy shouldn't change label selectors, which are immutable +2a4ea0533 fix(ci): better names for e2e test objects +0200909b7 fix(e2e): generate different label selectors for test deployments +73f48f7cb fix(e2e): use different csv names for each test case +63fee6903 fix(ci): don't error if serviceaccount is already patched +f6d3ec674 fix(subscriptions): startingCSV is not required +13eedc74a fix(rename): coreos-inc -> coreos +3b6dfcb15 fix(ci): vendor in sanity check to remove codegen error +64b49f0f3 fix(e2e): use name of catalogsource instead of name of configmap +9ab4a6e66 fix(deploy): update x-operator version to one that supports CRs +408c98dad fix(deploy): use DeleteAndRecreate strategy for CatalogSource updates +3b5db85c8 fix(deploy): catalogsources should have different names +6f9c8c7f5 fix(deploy): put catalogsources in catalog namespace, not hardcoded to tectonic system +41f95a011 remove generation of catalogsources from catalog/main +a0b72c722 write out both ocs and component catalogsources +f2ce7b1c1 update catalog version test to handle multiple catalogs +3b9f54ecc split catalogs into OCS and cluster components, package 0.4.0 +6843afc77 chore(Gopkg.lock): update dependencies +230b40367 chore(*): update github repo org +594320503 Review docs for outdated information +4a46dd1cf move Slack webhook URL to environment variable +e29a3f463 catalog: update etcd-operator to 0.9.2 +f77ed56e5 fix(ci): switch to short sha for naming +2ddf08d73 fix(ci): update failfast namespace for new ci cluster +c2396d176 do not update Subscription-v1 if unmodified +1b3b603e3 add bill of materials +fd26e1adf add Apache 2.0 License +f39bb583f fix(ci): change $SHA8 gitlab var to new $CI_COMMIT_SHA +fa8d8e1d7 fix(ci): update docker host path +43288c869 removed UICatalogEntry-v1 +1a00232a1 added docs for Subscription control loop +1d3949357 fix(e2e/subscription): update import paths +ccdb1e7d9 chore(Makefile): clean up all test files +2609e6b36 refactor(e2e/subscriptions): add cleanup fns +f1fcf6db9 test(e2e): test subscriptions control loops +dfd51c10e chore(.gitlab): use commit sha in ns +81b35edce refactor Subscription control loop to only call Update() once +51278d5f7 fix Slack notification +5190d338d fix Slack notification webhook in CI +84e87486c send Slack update when deploying to Team UI cluster +49546168a GitLab CI deploys to Team UI cluster watching all namespaces +3e204955b modify GitLab CI to deploy master branch to Team UI cluster +8a9ad12a0 fix example YAML +29c97d309 fix subscriptions being stuck in UpgradePending state +f65c33a94 chore(.gitignore): ignore all generated resources +34127a659 set Subscription 'status.state' +2814325a6 refactor(tests): split source and calculate coverage over non-generated code. +686eecd4e docs(development.md): encourage test running after dependency update +56eeea37a fix(ci): pull common variable out into vars.libsonnet +42044973e test(e2e): add coverage generation to e2e tests +94f02c00f fix(tests): update tests to use the new client fakes +2c9bc4052 refactor(clients): switch to using generated apiclients +bb1f39afa feat(ci): add sanity check step which does basic verification before building the images +9a980093a fix(ci): update fmt-ci to handle multiple files +879f8ae61 feat(ci): run verify-codegen and verify-catalog before building +ab3b4a853 remove gocoverutil, go 1.10 coverage tools can aggregate coverage now +0e55de464 switch to go 1.10 +db6b96d25 fix(e2e): fix invalid CSV in e2e test +e6fde0804 fix(catalog_resources): update deployment specs for 1.9 +a628f9ce7 fix(makefile): separate vet and docs testing +ee0851e39 fix(e2e): use newer apiversions +82470a72f Add $(DEP) as prereq to vendor make commands +59e34092e Switch references from glide to dep +a9104b930 Generate clients with code-generator +9cf4b9e71 Update api usage to 1.9 apis +92704e89b Update api usage for 1.9 +529d0db00 switch to k8s.io/code-generator +4bbb40f27 Switch to dep and update dependencies +df945292c update ALM templates with correct JSON schema +5ff5cb62e fix subscription status +0a6f63510 Cut 0.3.1 +dba789582 add annotations for example custom resources to CSV +abd4db71d Update install instructions and add a `make run-local-shift` command to run locally in minishift. +54caa1e24 update csv requirements +f806d1cb4 fix(crds): nest csv, uice, sub, and installplan validation under "spec" +cb2f61710 fix(crds): nest catalogsource validation under "spec" +47dd92950 cut 0.3.0-5 +e33db7287 cut 0.3.0-4 +a401495eb cut 0.3.0-3 +a06451b82 clean up during e2e tests +ff0c05956 Remove vault podstatus descriptor +961c4d3f6 Add prometheus 0.14.0 and update 0.3.0 release of alm +e4d985385 feat(operators/catalog): label resolved CSVs and CRDs with the catalog source they come from +fdf467182 fix(operators/catalog): set phase to failed when resolution fails and enable the e2e test for it +90ea9b8a7 catalog: update etcd-operator to 0.9.0 +2649b50e7 hack(ownerutil): hardcode groupkindversion for ownerreferences to CSV +508d7de9f fix(install/deployment): use ownerreferences when checking for SAs +8d86ec12b refactor(uicatalogentry): minor renaming / refactoring +93a225841 e2e test for uicatalogentry updates and pruning +a437bce4d Prune old UICatalogEntries from the cluster on catalog sync +dc789396f When a watched object is deleted, purge it from the queue +2c43f0070 fix(client/installplan): use correct resource name +18dc0affa catalog operator ensures labels on Subscriptions +ca9789ae0 fix(alm/operator): don't update the status timestamp if we aren't transitioning +2a20b2c5e catalog: update vault-operator to 0.1.9 +ed5cdae7d Fix chargeback e2e test +e96dc5816 Fix e2e test reporting in gitlab +befb6dfff Update images for 0.3.0 +6d8f959ab fix imports +92230e644 fix(catalog): add tests for compatibility between versions of the catalog configmap and fix the errors that the tests revealed +4df53d390 cut 0.3.0 +eb43a1383 add alm-catalog label to Vault CSV +f59cd0f12 Revert changes to labels/match labels on the deployments +ac872b1fb fix(pkg/client/installplan): only set name if provided +58c4f231f fix(operators/catalog): don't update catalogsource status when processed +fd6948338 fix(operators/catalog): don't share informers between installplan and subscriptions +12bd02664 pkg/registry: Update tests for Chargeback +3f1249351 catalog_resources: Add Chargeback resources to catalog +a5e86df9b fix(operators/catalog/subscription): specify csv in installplan (duh) +682f736eb fix(apis/uicatalogentry,subscription): set list items to correct type +d055915f8 fix logs in e2e tests +6a3753b75 Add package loading to catalog directory loader (only used for tests) +78b1b279c Add additional logging to catalog loading +b9e83e77b Fix makefile build directive +4c5f5b751 Remove `replaces` from prometheus operator since we don't have an older version +217bf7dd4 fix(apis/subscription): correct meta in List obj +750cf4ed0 fix(operators/catalog): use the right plural name to list subscriptions +08884b64d Switch from gomock to counterfeiter and update tests +b430e12ec feat(operators/catalog): standardize to UTC time +97b42de74 fixup(apis/subscription): use the sane json tag +cc3f2b29d chore(zz_generated.mock*): regenerate code for k8s types +833e86ef9 chore(.gitlab-ci): ignore not found errors on delete +436502185 feat(operators/catalog/subscription): use startcsv if specified +f94f23981 fixup(subscriptions): use CurrentCSV in status block +e22af3da0 test(operators/catalog/subscriptions): test lastupdate times +5abb528b4 fix(operator/catalog/operator): ensure safe concurrent map access +2bb164e4a fix(operator/catalog/operator): update queueinformer fun signature +c9132b48b fixup(operators/catalog/subscription): store apiversion/kind info +1509eee14 test(operators/catalog/subscriptions): ensure installplan existence checked +0d399fb31 fixup(subscriptions): check for installplan existance +2e5700adb fixup(operators/catalog/subscriptions): regen mocks and such +8f07e3510 chore(operators/catalog): generate mock catalog +45725cbb5 test(operators/catalog/subscriptions): add unit tests +7fa8321f9 fix(operators/catalog/subscriptions): save subscription +aecdd376e chore(operators/catalog): generate mock clients for subscription tests +2ebf1e111 chore(**/zz_generated.mock_*): update mocks +c7c45203c feat(operators/catalog/subscriptions): add subscription ctrl loop +0888ca77a feat(subscription): save install reference +9922e4ef9 feat(pkg/client/installplan): add create method +956217442 feat(pkg/client/subscription): wrap subscription ops in client +226ddce54 feat(apis/subscription): add subscription crd back in +c5dd8c29b Add package metadata to UICatalogEntries +4e8d25920 Update philosopy.md +22eb68587 catalog: update etcd-operator to 0.8.3 +2c511b072 e2e: Load catalog entries from the in-cluster catalog and verify they install +03aa72130 Requeue more often when we know we can shortcut a resync +bbfd7cf11 Add a doc on tracing errors through from ALM resources +fead9d149 Minor renaming / refactoring +624401d39 Refactor e2e test utils +f89f6711f Port drive design docs to the repo +ae7a328a6 Add docs on GCing and the new packaging format +35463b1c9 Fix e2e tests +904ebf401 Only query for csvsInNamespace once per loop +634aae599 Add requeuing logic to simplify state handling +1365bb1f2 e2e tests for CSV upgrades +2c04a95e3 Clean up old CSVs if they're successfully replaced. +280269bd6 Don't queue up delete events (we take no actions for any of them) +05242e5dc catalog: update etcd-operator 0.8.2 and vault-operator 0.1.8 +588d3f895 Update packaging for vault and etcd to use the new package format +101505cd1 catalog_resources: add etcd backup/restore operator and bump up etcd/vault operator version +c6f78ed31 Implement ListLatestCSVsForCRD, which finds the latest CSV holding a CRD, per channel +d08554284 Add concept of packages to catalog, for tracking of services at a grouped level +87bb06ff9 better description for EtcdCluster in Vault CSV to drive UI +785a2da51 add spec descriptor for ResourceRequirements for etcd +cff77eb40 modify spec descriptors for Prometheus OCS +66a511262 Use generate unique name for e2e job +cb003b061 Rename and export FindReplacementCSVForName method +2c1778093 Remove references to Service Name in catalog +a82badb22 Don't use helm upgrade +32137bc9e Move all scripts to /scripts +bc5e7154a Seperate update-catalog into its own script +f9d34fdbf Update e2e tests to run in separate cluster +f6ac082f0 CD to separate cluster +1016b59af Cleanup Catalog interface in prep for fixing how we handle service names +f39c27046 add labels to OCS catalog ClusterServiceVersion templates +265c661f4 add visibility annotation to catalog resources +5abc89166 move build catalog script to hack/ +3f64f6bca fix whitespace stripping from configmap generation +efb7fab9b deploy/TAO: use stable release of x-operator +2d8e689b3 update EtcdCluster s/service/serviceName +472e92f8f chore(.gitignore): ignore test artifacts +fce062f24 chore(Makefile): remove vendor update from e2e-local +2ebe712b8 style(buiild_catalog_configmap.sh): trim trailing whitespace +68ba7ea6a test(e2e): test catalog entries visibility set correctly +790d1dfb0 style(catalog_resources): add newline at end of file +9b7dbd571 feat(catalog/uicatalogentries): add label via csv annotation for visiblity +a022f0ae9 Consolidate vault operator version references +507014eca Add errors package to vendored dependencies +4ea3d4af3 Add readme for tests +c24afe788 Add note for running single test +81c9205ec Add test ensuring Vault cluster is created with etcd pods +f8b23f4c1 Cleanup +182e3fbaa Add failed InstallPlan phase and skip test for it +3f302d165 Refactor InstallPlan fetching and allow passing an anonymous checker function +801931dee Add test for creating InstallPlans with invalid CSV names +23382b230 Add test for creating InstallPlans with invalid CSV names without a Failed plan state +bab2e24ae Add test for creating InstallPlans from UICatalogEntry list +f5128701d Adds test for expected UICatalogEntries +546a48ec2 Add the ability to run a single test +5799be2a8 fix(package-release): use gnu compatible cp options +ddb3356a7 Tag e2e test container with latest when master builds +3a8c21629 Take $NAMESPACE as an argument for updating the catalog +b9f63ffe6 Put jq script for convert to tap format into a separate file +312798ec9 Containerize e2e testing and output TAP format +076c69558 catalog: fix inconsistent header size +df5651396 catalog: fix markdown formatting/rendering +fe9eecc43 [e2e] Add a test for InstallPlans with manual approval +3c8e22d78 Release alm 0.2.1 +608fb47e2 Fix parameter count comparisons +f58c9bb3f Bump vault OCS version +0ed9cf51b remove alpha files +5349127f8 Add docs for packaging +21fa5c5ed Fix catalog resource tests and remove samples +281e3e75f Add packaging script to generate x-operator manifests +61bb093a6 rename chart directory to "chart" +b904f44e5 operators/catalog: only add catalogsources once +4a4798bb9 Update 0.2.0 manifests +6167b5c7c Update etcd-operator +f576758b9 Update alm versions in 0.2.0 release +a39745b80 operators/catalog: add Type field to copied Secret +a690fa00e Update etcd and prometheus to latest operator versions +b0c91cf94 update Vault OCS SHA w/ make update-catalog +b81582bbd run 'make update-catalog' for ALM-316 +4e7f05062 reorder CRD resources to correctly match ownerrefs +e694cfe6d run codegen for ALM-316 +fa204a9e7 add resources to Operator CSVs to complete the ownerref chain +8b8d4b40b add 'resources' block to ClusterServiceVersion types +9848a321b Remove catalogsource cr from helm chart (catalog creates it on start) +3b6f9afc6 tectonic-alm-operator: bump operator SHAs +7a0dde528 operators/catalog: only copy secret data +cefb160e5 Update the OCS to pick up the latest changes +5b5f4a2e5 Fix the defective CSV schema +1383b475a Fix up the alm_resources install directory +c4251a38d Update manifests for v0.2.0. +9e78175bb Copy over the resource for the 0.1.2 release and renumber +a0fbef077 Don't use full apiversion as resource name in CSV client +99aabd7f5 Remove incomplete e2e test +df705b24f Fix nil pointer error in CatalogSourceClient +f4e13b325 Add catalog source to helm chart +c4163044a helm: add configmap +ae6921d48 glide: bump lock file +f03292c37 install: add CatalogSource CRD +06ae38ff4 cmd/catalog: bootstrap OCS catalog +9b14c85c1 operators/catalog: rename aceClient uiceClient +3036dc2e6 operators/catalog: fix grammar in comments +1954e0631 operators/catalog: support secrets in InstallPlans +a68258310 Update OCS configmap +65f7bf3e4 update Vault ClusterServiceVersion +3d0e32ef7 for posterity +675ef4936 Refactor install strategy deployment check +de1ba79d8 CSV upgrades: look for deployments by name, upgrade any with the same name in the new CSV, delete any that are in the old but not the new, create any that are in the new but not the old. +d35a90cc4 feat(*): specify objectmeta for CSV to replace +255877f7c test(pkg/client/deployment): add serviceaccount tests +0b6aa0bc4 refactor(pkg/client/deployment): use operator-client service account fns directly +77282a019 Add resources blocks for the CRDs defined in the OCS +f66cf399c Fix typo in CSV schema +eea242edb Properly label all resources that will be managed by x-operator +1f1b680ae Prepare test cluster with CatalogSource CRD +3afc0f031 Rename AlphaCatalogEntry to UICatalogEntry +36279ae9a Fixes for the Catalog configmap generator +defc572ed Add the OCS catalog as a ConfigMap +d31260a5b operators/catalog: return error instead of fatal +826ea5136 operators/catalog: init CatalogSource control loop +b812e70f0 fix Prometheus specDescriptors +5a75f4203 Add a config map loader for catalog sources +3f66ad2ea catalog: link to OCS user docs +5c892b826 catalog: beta -> alpha +b0560a994 catalog: update OCS descriptions +6cf87e688 add more spec descriptors for Prometheus CRDs +24e2dbb12 Update prometheusoperator.clusterserviceversion.yaml +cbc39d4b1 Add prometheus role +7dff085ab Add a catalogsource client with create and update function +0380fecd2 Tiny fix to use a const to set the CSV CRD name +6ed4e9706 Remove URL from catalogsource CRD until we have a remote catalog type +13c1d7f85 Set catalog namespace when deploying for preview +989a30bf6 Fix runtime panic due to client-go changes in new operator-client version +105fe43c3 Support both kube-1.7 and kube-1.8 in deploy charts +fdd0f03cc Update to tectonic-operators +0ae6887e5 Throw error when validating resources if asked to validate a kind we don't handle +b071dd1fb Add local e2e testing scripts and an example e2e test +864647d96 chart: Remove unused ClusterRole and make catalog namespace configurable +76a7ba8f9 Refactor installplan name into constant +e42e7fd83 Update all catalog resources with the new CSV format +2efc9ca19 fix(pkg/install/deployment): compare deps by name/ownerref only +126028e00 fix(pkg/operators/alm/operator): put correct error in status on install failure +2b687dfc5 Add cluster size status descriptor to prometheus +c8a2704bf test(pkg/install/deployment): create suite of table tests +531d6bd28 test(pkg/install/deployment): make more explicit tests +705110b18 refactor(pkg/install/deployment): break up install function +43d4803e1 fix(pkg/install): use Create*OrUpdate*Deployment +17eeee9f8 style(pkg/install/deployment_test): remove unnecessary struct init +ecf714e56 refactor(pkg/install/deployment): use semantic comparision +413c0deff fix(pkg/client/deployment): use cascading delete for deployments +efffa7d92 style(pkg/client/deployment): add newline b/w functions +077e973c5 hack(install/deployment): make current tests for dep updates pass +bd1744651 fix(install/deployment_test): use correct type in array +a9b227ae1 feat(install/deployment): create or update or delete deployments +7b3eb97ad feat(install/deployment): check deployments installed by name/spec +ed593bc8d feat(client/deployment_install): create OR update deployment by name +a34819087 feat(install/deployment): create consistent dep names +3cdd68632 catalogsource: add metadata fields +1ca09c108 catalogsource: add omitempty tags +ae24fbb09 installplan: add catalogSources to status +b0757e8c7 catalog: init ocs catalog source resource +0b61b810f catalogsource: add k8s interface codegen +1f42090f7 init catalogsource type +b354c75a6 remove placeholder statusDescriptors +5258e579f Update appversion.yaml +c1e38eade TAO: README w/ tectonic-operators build instructions +e3a22ea4d tectonic-alm-operator: bump operator image SHAs +a1c5c315b tectonic-alm-operator: copy v0.1.1 to v0.1.2 +e1d164e76 Swap namespace/name in annotation so that they match the env vars +459680e23 add version to deployment ownerReference +dec2fc26c alpha: explicitly pass manifests directory +e6fb23c7c x-operator: build image based on alpine x-operator +d534db1f2 x-operator: fix CSV CRD schema in v0.1.1 manifests +b71c1e7ca alpha: bump v0.1.1 +8f8908909 alpha: init +2f924f289 deploy: cut v0.1.1 tectonic-alm-operator +344fcb925 deploy: copy v0.1.0 manifests to v0.1.1 +d3d38c941 Fix generate-mock-client to generate from/into the pkg directory +9046613b0 Add missing dependency tools to the DEVELOPMENT file +8039a3888 pkg/catalog/directory_loader.go: skip hidden nodes +a03db1ed8 style(cmd/alm): format usage string on flag better +adf2cf45d refactor(alm/operator): clarify watched namespaces +7a0a9f89e fix(alm/operator): use non-wrapped client +a79dd39e3 fix(Makefile): make 'all' the default target +9d0cc0425 refactor(alm): pass in annotations from main +aa7bd3a96 style(alm/operator): simplify variable name +49c4f136c style(alm/operator): rename function args +b297c38f9 fix(alm/operator): watch all namespaces if none provided +6ca4bfe0c fix+refactor(pkg/operators/alm): watch specific namespaces only +0bbd6734e feat(pkg/annotator,pkg/operators/alm): add control loop for annotating namespaces +7eb7997a6 rearrange(pkg/annotater->pkg/annotator): spell annotator correctly +3c421922e allow icon to be empty in CSV +6096d77f6 chore(apis/csv): regenerate api objects +89359b89e Fixes clusterserviceversion schema +c15dc45bf docs/architecture: add control loop details +f8900df14 docs/design: add manual install stub +e0f5fc74d docs/design: add architecture doc and fix readme +214e1a1af docs/design: delete stale design docs +0d286d41a docs/design: delete old mocks +c64bb7716 docs/install: remove coreos-pull-secret +c32dd09b4 Update install docs for the cut branch of Console +359ce53c9 add SpecDescriptors to ClusterServiceVersion +40d3139dc Add the required resources to let x-operator install ALM in minikube +4da37ff6a Add a specialization of the x-operator for ALM +d51f448e2 README: add quay badge +05b9a3637 style(*): alias core/v1 import everywhere as corev1 +59fc735d3 refactor(installplan): abstract away conditions array in status +3c8e268cf style(catalog): use consistent import names +64a973aec test(pkg/apis/installplan/v1alpha1/types): test setting conditions in status +ad89d6392 refactor(pkg/operators/catalog): explicitly switch on err to set conditions +c51fe6311 chore(apis/installplan/v1alpha1/types): use conditions instead of phase in status +a45cfd4b8 README: fix install link and JIRA link +5c550caa5 Test our catalog resources for consistency +3f2651a05 Adjust CSV status descriptors for Vault to reflect new status block +e7664d5cc Update alm/catalog images in install resources +56449cc44 Remove commented code +620f7b53f Fix namespace labelling bug +da0a83367 Move code into /pkg and create coverage report +2a0ae297c Add more unit tests +d41cee464 Add "coverage" (html) and "cover" (cli) commands, update to exclude mocks +390466790 Add various shortNames to the various CRDs +3be03c819 Change maintainers and add useful links to our CSVs +8e336c313 Update etcd Cluster CSV to have it display real status information +e2bcc7862 spellcheck +8bf4159a4 Fix catalog resources +a81f24207 Refactor deployment strategy client + naming fixes +2c01e155b Deploy install strategy: Add tests for error cases +3008cf157 Add tests for deployment install strategy with role generation +a0719aa9f Refactor install strategies +bebc30076 Switch to patch for updating namespace +7c4bc0512 Annotate namespaces on ALM operator start +1398a2429 apis/installplan: test JSON manifest on StepRes +5cc41d6cf operators/catalog: test creation of dependent CRDs +a3f97f43e operators/catalog: s/CreatePlan/ResolvePlan +747bc9e5a apis/csv: fix nondeterminism in GetAllCRDDescs +cdb61ea81 operators/catalog: refactor and table-testify +67566c234 apis/installplan: add StepResource constructors +45fa62f89 apis/csv: rename GetAllCrds and table test +b559bea5a csv/customresourcedefinitions: add version and kind +a904d2f6f test(client/alphacatalogentry): refactor tests into table fmt +b1d59a84b fix(apis/clusterserviceversion): correct json tag +0999e77e3 wip +ac4c2d8ca test(client/alphacatalogclient): more thoroughly test update cases +08c692918 test(client/alphacatalogentry): test error case +9810213ad test(client/alphacatalogentry): test upsert behavior +0adb952fb test(client/alphacatalogentry): add test machinery +8107f25c7 Update alm and catalog images to latest +1d46d2f45 catalog: resources should use correct sha256 image names +63c25443b alm/operator: Add a test for transitioning to pending if component goes unhealthy +45ff9b877 alm/operator: check if resource has gone missing and replace it if so +bb3b9aa7a remove pull secret from install +c5f9bb6c2 fix(catalog/alphacatalogentries): set sync status correctly +cbec3997d test(catalog): test store sync +a2eb3f62f Update etcd and vault to latest releases +b651f109e Update install.md +3af0e65db Set ownerreferences on all objects created from install strategy +5619f85ef Add omittempty to fields on CSV +f61bb87f3 fix(client/alphacatalogentry): use put not patch +e262f54da doc(catalog): add debug lines +ee7bd4146 style(client/alphaservicecatalog): remove nested ifs +701c00a1c feat(client/alphacatalogentry): patch existing catalogentries +6ae1fc13f WIP +f8f27fdfe refactor(cmd/catalog/main): clean up file +16824272a Install instructions for ALM + Bridge locally with minikube +8d362fa0d Add serviceaccount for vault +58bba6153 (temporarily) use dev versions of vault and etcd operator +3e420d0f4 Update catalog resource labelling +bdb10b70f apis/csv: make OwnsCRD a CSV method +a654189aa operators/catalog: decouple phases from logic +10f39d462 queueinformer: move MockListWatcher +ab2f2c6a8 operators/catalog: table-driven csvOwnsCRD test +2099aacee Add command for generating coverage report +2d71dba20 Update install instructions +ee3420c56 Update rendered yamls for installation +ed9f3fbd1 Update prometheus defintions +9f24cf1b9 doc(control-loops): update CRD name to InstallPlan +b106dce31 Update prometheus +4e0806c23 Better naming and log levels +4d00d9fc9 Update prometheus CSV to 0.14.0 +c66895406 InstallPlanList should be a list of InstallPlans, not InstallPlanSpecs +940a0c528 wait for caches to sync before processing queue +9ac472ac6 Prometheus CSV should use the same serviceaccount in permissions and deployment +e0abb4dbd Better log messages on catalog operator +66f32b798 Add entry matcher for alphacatalogentry client tests +a99fb05bb Restore alphacatalogentry test +e79f3769f Switch to log.Fatalf +dca4ee0a5 Update vault CSV to point to latest version, and use coreos-pull-secret +1840452d3 Fix operator tests +d7e703eb9 Ignore if alphacatalogentry exists +c88e66a04 If AlphaCatalogEntry exists, update with a put +93b5a4c43 re-enable alphacatalogentry generation +e8dcb9de9 Installplan should resolve to objects in the same namespace +4631ca47c Serialize resolved resources as json +0a5cff653 Fix operator loop +fb2917cbf Add logging to installplan resolution +6e0fb8f20 Add more logging to queueinformer +7d97811a8 Add more logging to catalog operator +2c337cf01 Update installplan types +a034a8434 don't generate alphacatalogentries for now +f4b7a9477 Ignore if catalog entries exist +c9cefa7b9 Delete/recreate alphacatalog entries +1df9ac708 Update even if there's a transition error +2c39416da Patch don't put +7e799d6d2 Set initial phase to planning on installplan +58e9a72cc Fix alphacatalogentry api calls +1a5693c3d Install alphacatalogentries into configured namespace +1bf0a87b5 Add logging to alphacatalogclient +6facb06d1 Return early if no error creating resources +0b52863f2 create AlphaCatalogEntry if it doesn't exist +bda30d238 Update catalog resources for self-consistancy +bbebdce26 Add more descriptive errors +2653dfbc4 add catalog files to container +9ee3656d3 catalog: more logging +711248cc9 Load catalog resources into cluster as AlphaCatalogEntries +f59759b77 Create alphacatalogentry on deploy +0dcf06218 Fix vet error +bb64463d2 test(operators/catalog): add ListServices method to test impl of interface +fea5f52f3 test(catalog/alphacatalogentries): fix test mocks +e79b47be7 fix(catalog/alphacatalogentries): correct pt/receiver types' +c74fcba99 test(alphacatalogentries): test catalog sync +c85632ced chore(mock_alphacatalogentry_client): generate mock +6a8896f85 feat(catalog,client/alphacatalogentry): sync catalog to CRs functionality +8e20f82b4 feat(catalog/types,mem): add method on interface for listing all services +8ca885420 operators/catalog: add multi-source TODO +061ca277e operators/catalog: transition to install phase +061d28a78 makefile: generate installplan mocks +4a873601c makefile: add gen-all command and run +c803ac260 operators/catalog: init installing a plan +5bb648ab9 Load in memory catalog from a directory +a9bb74a2b Add CSV to install plan resolution +c47878196 Fix tests +2d3a4ddc0 feat(operators/catalog/install_plan.go): adding resources to install plan +15aed12b0 apis/csv: add missing provider field +c710a88ac Add prometheus and vault catalog resources +05db140ed Add catalog resources directory and test catalog resources +49770e000 test(catalog/mem): sort CSVs returned by version +59f555dab chore(catalog/mem): update data types +2f5c2cac1 test(catalog): simplify tests +1308bb5f8 doc(catalog/mem): update comments +ed4418e49 feat(catalog/manifest): add loading manifests from file +d70c252ac test(catalog/mem): test basic catalog fns +3b2415ab8 Update regex for resolved etcd cluster +15eabb81c Fix tests +c005f8902 Update etcd resource permissions +88ebc7ae0 Fix sync +d1db0d1e6 Remove unused config mount +38446bce4 Fix rebase +e2b17ea35 Dob't create serviceaccount if it already exists +a704f37bb Fix role creation +bd53114a3 Log error when install fails +4c77cb46a Validate that example CSVs can be parsed into CSV type +1db49526d Rename capability -> descriptor +f154e458d Add implementation of permissions generation for CSVs +0c1237352 Add permissions block to install strategy on CSV +6c62f169d Update CSV types and parsing to match new CRD description design +c0c199f58 Move labels -> template/labels for CRDs +0c1cb783a Rename x-alm-capabilities -> x-descriptors +3d664e2d0 Move output definitions to CSV and move output values to status block +6dbcd1c3d operators/alm: replace config map with flags +e7dcc1689 ci: add missing pre-step for catalog +778a6a9e0 helm/gitlab: add new deployment for catalog +bf2fde6d3 operators: init installplan operator +a37d12678 installplan: fix inconsistent samples +886fa6435 Update etcd installplan to match schema +080361953 chore(catalog/mem): update fns for mem catalog +6f75a2c0f refactor(catalog/types): shorten interface fn names +4b742e819 temp +8e74e359f refactor(catalog): embed ClusterServiceVersion spec in AlphaCatalogEntrySpec +dd3f07b90 feat(catalog): map CSVs to the versions they replace +68071da7b style(catalog/mem): use variadic fn arg variable names +f261fccda refactor(catalog): rename in-memory golang maps catalog implementation +0debb3a0a refactor(catalog): rename fn to remove ambiguity +7d8b19e5f style(catalog/mem): order import blocks +0288a79ba style(catalog/mem): use explicit key/vals for struct +099d721c3 refactor(catalog/mem): remove sources subpackage, enforce interface +5aa5f294d feat(catalog/sources/mem): add simple catalog implementation +3265de347 installplan: add types for Install Plan Status +1144aabfe Fix rebase +5d751fcad Fix rebase issues +1b20c558a use return instead of break in switch +b257b7f0a Fix icon parsing +87706f290 Add full state transition tests for clusterserviceversion status +595593b10 Refactor phase transitions for clarity and testability +b36cc7ec7 Update codegen +95f6fd6db Fix typos +a6c96bd86 Fix CSV type (deprecated fields) +3e3a65b32 Add missing return from phase transition caused double install +052910bb2 Use switch for phases +3fba6d318 Check if deployment is installed before attempting install +b47c5af16 Update etcd cluster crd to be versioned +c3e42f555 Adds a state transition test +14ceef52a Add mock alm operator for testing +f1a980d87 towards a mock alm operator +23e510c90 Write conditions to status during state transitions +bcf7ad8dc Add conditions as a history of state transitions to csv status +a9b5df197 Resolve rebase conflicts +e1e23bf4d Write requirement status back to status block +43344c92f Cleanup phase transitions +128b9726b Only check for CRD existance +74805fb08 Update gitlab pipeline +8920a0828 sketch out phase transitions +ee5c9bb50 Check for phase before attempting to install +ddd75b83e Add ClusterServiceVersionStatus +6948be17b Add schema for ClusterServiceVersion status +c333b65c2 Look for requirements in same namespace as ClusterServiceVersion is defined +84e2cadea Move config handling to its own package +1961aa00b doc(vault.alphacatalogentry): fix sample name +3b41d59cf fix(alphacatalogentry): regen code for alphacatalogentry types +ef1dc178a fix(alphacatalogentry.crd.yaml): add names +7a8580f66 doc(catalogsource.yaml): remove example catalogsource resource defs +672a1efe0 doc(vault.alphacatalogentry): add vault catalog entry example +bdb8d0262 doc(alphacatalogentry.yaml): create CRD yaml +a3b1fa2c2 feat(alphacatalogentry): add provider field +f3dfa01b1 refactor(apis/catalogsource): remove for now +5e45d1ddb doc(catalogsource): remove extraneous comment +94454bfac refactor(apptype->alphacatalogentry): rename crd for catalog +452439011 feat(apis/apptype): add back in apptype crds +7c2500b22 chore(catalogsource): only have one url per src +13c2fc89f feat(catalogsource): update spec for console to consume +409a9aec5 feat(apis/catalogsource): add new CRD for catalog +cfd483677 style(catalog/mem): use variadic fn arg variable names +fd6a29639 refactor(catalog): rename in-memory golang maps catalog implementation +b76868e00 refactor(catalog): rename fn to remove ambiguity +bfc0ed0ac style(catalog/mem): order import blocks +623569bbc style(catalog/mem): use explicit key/vals for struct +e80807a54 refactor(catalog/mem): remove sources subpackage, enforce interface +915bd0e1e feat(catalog/sources/mem): add simple catalog implementation +be31fa525 gitlab: run glide install in test stage +137aa0d4c Revert "Merge pull request #86 from jzelinskie/ci-uniq-base" +c9c63b6fd feat(alm,install): adding in owner reference to deployment +9a58d6bbd gitlab: base image now unique per git ref +a4bd736e6 Add tests to validate object metadata +8c39859d9 csv: add json tags to CRDs +6236f0e0f init Required/Owned CRDs for CSVs +dd1fc7224 fix(cmd): fixed config parsing +2ab07117f fix samples to reflect new updates +7f5e83fd6 Rename InstallDeclaration -> InstallPlan +ef30e8282 fix validation of approval types +fd12b8680 remove apptype from codegen +96d8df57c add initial ownedCRDs field to CSV +657431f7d fix apiVersion for etcd installplan +ac3d76d32 move Approval type into installplan +c73543aba add dashes back to apigroups +bfac2fbef add install plan validation +44205bd66 subscription: fix apptype references +95757422b fix inconsistencies +59908332b capitalize approval types +22aee6531 s/update only/update-only/ +448bfb4a7 s/desired// && s/cloud/cluster +53450305e installplan: add approvals +21b885bb5 installplan: add RequiresReview status +55c455202 samples/installplan: remove inconsistencies +b25b67b67 installplan: refactor status +1f612577f installplan/v1alpha1: add spec +284b2855e installplan: add status.status field +35fe128ba samples: add status for installplan +f7c4bef81 init installplan +5616422e2 Remove AppType and merge its fields with ClusterServiceVersion +e3a0a62fa Merge apptype into clusterserviceversion (examples only) +d3b58016b Remove namespaces from requirements +09216cec7 refactor(catalog/mock->catalog/sources/mem)): organize catalog types +bf6b79575 feat(deploy): add in config map +1c92f598c fix merge of namespacing PR +84ba58a64 feat(alm): adding in namespace list support +5a0de06f9 refactor(client/{opver->clusterserviceversion}_client): rename file +7a7946d3d refactor(catalog->planner): rename component +b5d4834bf refactor(appcache): use new crd name ClusterServiceVersion +1b1e687db refactor(subscriptions): change pkg name and remove unused mock +d160ebab9 feat(appcache/mock): add simple implementation of appcache interface +02ecf1055 refactor(appcache/types): use simpler name for interface method +104b78717 wip(subscriptions): remove logic for now +78be96063 refactor(subscriptions): rename to installplan +9d9b80e0d feat(apis/catalogsource): remove for now +ae62b493a rearrange(subscriptions): move out of catalog pkg +2b632f60b feat(catalog/types): simplify interface +52e30a2e5 feat(appcache): add interface for app catalog cache +e8f97bd4f rearrange(apis): rename installdeclaration as installplan +4c68167f5 feat(catalog): use k8s typed objects +48d445803 feat(hack|apis): codegen new types +9bbf19ceb feat(apis/installdeclaration): add installdeclaration crd types +0d1cb901d feat(apis): add catalogsource crd type +64b3e75bc feat(apis/subscription): add cdr structs +d6b347f4a fix(catalog): fix type inconsistencies +b474582d9 test(catalog): finish memCatalog mock implementation +1e1237cf6 fix(catalog): change fn arg to ptr type +77508acac doc(catalog): comment on functions +57701228f doc(catalog): add comment on temporary type decl +7bbebc1d9 refactor(catalog): move resolve dependencies to catalog interface +6907f970a test(catalog/subscribe): add empty test file +43cef7d4e WIP(v2 catalog): update for new control loops pt 1 +93889211d WIP(catalog): sketch out loop ops +01bbf53a7 Fix tests +2306e06bd Fix apiversions and naming +a14e729ad Add prometheus example (has multiple resources) +d1909e888 Add a newline +e435bf229 Namespaced examples +87ddda3ff WIP namespace samples +ae2a89c1c Don't install self-hosted in install instructions +88679b971 Namespace alm +57050f3ea Fix api versions +edd50d350 Inline instructions +42564ac66 Update etcd examples +3b9087d1e Fix etcd operatorversion sample so that pod starts +601c01cfc update samples for UI testing +00f73ba96 Add sourceType and secretName to CatalogSource +9c46f2eec Add example resources for Subscription and CatalogSource +b9fa8a7c9 feat(alm): added in check for requirements +7634b012c Fix deployment test +e4cefe9fd Rename operator -> queueinformer Add queueinformer registration function +4d4cfcd71 Rename ControlLoop -> QueueInformer +27dee133c Formatting fixes +34bc9b9c1 Add codegen for runtime.Object deepcopy methods +d8b31dc44 Factor out common operator functionality into a parent Operator and ControlLoop object +e5f426c05 Move opver client to its own package +d4a120632 Refactor install strategies +f4c675e25 Move opver api registration to apis package, rename alm.go to operator.go remove unused interfaces move apptype type declarations to their own api package +351b067f7 init v1alpha package for OperatorVersion +616171c79 doc(control-loops): fix typo +af7d58c96 attempt to fix dependencies +420b8cd61 Update control-loops.md +bfc715d42 Update control-loops.md +d3f2256d5 Update control-loops.md +41728518d makefile: add -i flag to `go build` +782baa0ab Add testing framework for testing sample resources +a1ae656f0 glide: update operator-client +8d4624350 rename operator -> installstrategies +3ad865fa9 Check for existing managed deployment before installing new one +69d550261 Remove vendor from `make build` +f4a007d8f Update gitlab +1aeb4ca32 Add hack for GKE plus some formatting fixes +bdf97f20b Fix imports +9d736e7ff Add logs on successful install +df9d353f0 WIP: can't use unstructured for subtypes +c325aa295 WIP: can't use unstructured for subtypes +1d7f07269 Register ListKind properly +38d739125 Add api registration for operatorversion +865a592b2 Create a new client for watching OperatorVersions +beb27a9c2 Fix watching operatorversions +c6e95ead5 Fix operatorversion reference +3315b7a93 Install OperatorVersion and AppType before ALM +9de7b0b09 Fix serviceaccount +d71bf92ea Fix merge conflict in operatorversion +c058bdb08 Add CRDs and serviceaccount to helm chart +5cc44ed72 Control loop runs install strategy Also `cmd` will run operator +99f55c397 Gitlab-ci with jsonnet lib +9836a8d72 Update helm-chart +34f52bfd0 Add deepcopy methods to `OperatorVersionResource` +af9689681 Fix glide.yaml +caa783ffe Add WIP glide +cbb514e94 Add coreosbot credentials +6f1e38f34 Vendor before test +5f4d2a5ba Fix dependencies +b8eef3d5e doc(scheme/loader): comment on function not for prod +0b1d069a2 style(installers): format imports by type +0ec025daa rearrange(installers): organize pkgs better +935080fcb feat(schema/loader): add util to load CRD from file +855531003 feat(operatorinstaller): add initial deployment strategy +593e79bd7 rearrange(alm/types): remove unnecessary interfaces files +7104b537b Add install strategies +3860743bf Update example.vaultservice.yaml +0e81b93f1 docs: update walkthrough with validated resources +df7cc0969 Change replaces to a direct resource reference instead of a version +b1cc63cf8 Better formatting for outputs +9a879da4b Add displayName to outputs +acd595d98 Move outputs to an annotation and add displayName and description +6c13d7fb8 Add install instructions and make samples kubectlable again +efaf40012 feat(alm): adding in basic operator version watch +c78b1965e Change to `alm-owner-` +49cd41cf8 Add labels to propagate in addition to labels to match +c5a11eb2d Add labels for AppType +f1a592e30 Add labels and selectors +b4fc772d8 add field to examples +9de811b72 fix apiVersion in samples +8e6304655 Update loops +835248845 Remove ALM-managed upgrade option +29dee2f52 Fix typo +73df421db Split loops by piece of software, and add upgrade and GC loop descriptions +c6887f77d Add explicit creation note to `AppType` loop +c28ea2367 Update control loops to match newest design +32a8b2e87 Add reconciliation loop docs +3bd81fd43 Fix invalid CRDs and CRs +b86a6b0e8 docs/design: init walkthrough +2314078fd Remove blocksInstall from examples +5c90effc8 Depend on `CRD` not instances of CRD +91ad56094 Fix etcdoperator operatorversion +996790f43 fix almoperatorversion formatting +fe5b5d8b6 Fix formatting on etcdoperatorversion +067405b53 Update vault example to use new requirements format +f3cc3d2ba Update etcd operatorversion to match spec +e6dc168a3 Update operatorversion spec and alm.operatorversion.yaml +9b14af09e Add UIDs and update apiVersions +0c2820412 Add status and ownership to etcd sample +5a1594026 Move the examples back under their directories +890a12a24 doc(DEVELOPMENT.md): outline glide and make usages +85bacad09 fix(vendor): go back to glide for golang dep mgmt +7b2a2bde3 style(alm/types): use golang conventional func naming +8d4769d71 fix(.gitlab-ci.yml): pull correct image +2a5e74818 fix(values.yaml): moved from quay to coreos +65bff4625 fix(.gitlab-ci): put in sha at wrong place +2ecd4effd fix(.gitlab-ci.yml): remove except branches +21ba3b24f chore(.gitlab-ci.yml): add in deploy staging +72075931d Put `example.` prefix on example CRDs +1c1eabd36 Add vault sample +f4c111e8f Move etcd samples into their own directory +8b5e23e76 cmd/alm: init +ab40c950f Fix merge and add important.link capability +cafd7feb7 Add sample etcd cluster instance +b7ee33a2c Add sample outputs +86a24dad4 Add sample proposal for metrics and links as outputs +d129b2c3f Fix rebase issues +cd49d2338 Update requirements version +b88ee5766 Model RBAC requirements as requirements +4ba6e2cbf Add example for including cluster features as requirements +071dc0c94 fix(alm): consolidate apptype cr creation +5675cf344 chore(Gopkg.lock): update dependencies for interface tests +fd818310f test(alm/interfaces): add basic unit tests +ca804421f feat(alm/interfaces): define alm functionalities in interface +a165ea80c chore(godep): update dependencies +c4e8db891 feat(alm/types): add type schemas +3ed37b792 README: init +a0f5b96c0 docs: move design work into Documentation directory +f8582bc39 chore(Makefile): set up Makefile for test, builds +64dac2e4c fix(.gitlab-ci.yml): stop ci build on master +f0713bda1 dep: init +1e05a0449 chorse(.gitlab-ci.yml): add in manual deploy of branch +859e15347 Add schema examples +0cddacb97 Switch to the proper JSON field name for the schema https://github.com/kubernetes/kubernetes/commit/6133d84835c59f157a8fb4596f98d2d3cf828bef#diff-3029a18192feb70af52de676209da9b6R149 +62734f345 Make the icon information embedded and more strict +9d4ec1969 Add schemas for the initial resource types that ALM will manage. +62ab83d68 chore(deploy): add in health check for k8s +15c381352 feat(deploy): added in basic helm chart +2e086d0ba fix(misnamed from): adding in golang +129c0426d chore(.gitlab-ci.yml): Adding in basics for ci +7b20d7108 chore(.gitignore): Added in a basic gitignore +0ea751807 Add ALM mocks +eca4f1566 Check in the original propsal README as a straw man. +ddfdf72e3 initial +5503a2a58 scripts: Update the scripts/generate_crds_manifests.sh +f1dbd0d07 Makefile: Add additional verification checks to the verify target +fb555af8c scripts: Introduce a script that ensures nested modules are up-to-date +65ceea044 Updating operator-registry images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/691e628254f318ce56efda5edc7448ec743c37b8/images/operator-registry.yml +f92115001 Updating operator-lifecycle-manager images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/691e628254f318ce56efda5edc7448ec743c37b8/images/operator-lifecycle-manager.yml +199f2b6a6 .gitignore: Ignore the sqlite journal binary files +34318f9a0 Add verify target to Makefile. +da3e496c6 Add IBM managed cloud profile annotations to manifests +1a571a501 correct top level files and vendoring +5a5d31a22 Remove overrides for GOOS and GOARCH in cpb Makefile recipe. +773c28855 Makefile: Use the full git commit hash when building binaries +96b6cc3da base.Dockerfile: Bump the Go base image to use a 1.16 tag +24c413998 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/b7ea3c7f495e67d5b790e3698b5c319b67e98b35/images/operator-lifecycle-manager.yml +a0c9ca7f4 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/b7ea3c7f495e67d5b790e3698b5c319b67e98b35/images/operator-registry.yml +2543e6035 Dockerfile,Makefile: Add opm binary and cross compilation target(s) +08daeb0ab remove top level deploy, crds directories +17bd9976e add crd and manifest generation +aa5df6359 Makefile,Dockerfile: Add additional registry and OLM build targets +73d36e080 scripts: Address markdown violations in the README.md +a6cc02add cmds.go,vendor: Introduce the non-opm registry binary packages +a5c25b3de scripts: Check if the vendor directory needs to be populated first before running e2e packages +e05ed8f90 scripts: Avoid hardcoding the test e2e function called +785ec7b2f Makefile: Update the e2e-related targets +2d2b03f39 README.md +39717cadc Use staged tests +aa1b622be Update scripts to track specific commit +633072a36 scripts: Update the unit.sh helper script and populate the nested staging directory +495385b84 Makefile: Introduce additional test targets +e99ac9167 scripts: Introduce an e2e helper script +3c4fb81ca Dockerfile: Copy the entire repository while building binaries +75238ed4d Update the base image for the operator-registry image +ba7683370 WIP: Update root Dockerfile(s)/Makefile to build downstream images +3c6897fe6 .gitignore: Ignore nested staging vendor directories +69ef1b59d Add the package-server to the list of local command packages +13d97c031 Makefile: Add build and basic test targets +f4cc0f1ef Introduce cmds package that tracks the staging operator-framework directories +9269b835c Makefile: Reduce the number of targets +5f5016efa scripts: Add unit test helper scripts +1ac24811e Dockerfile: Avoid hardcoding the kubebuilder version in multiple places +e4e7f4fb5 Dockerfile: Avoid using the registry.svc.ci container registry +d4cf305d3 *.Dockerfile: Manually bump the image tags to 4.8 +1c272ee39 Add root .gitignore +fa34d3f53 Initial commit +84f6a5c15 Revert everything back to the initial commit +7de770d3f Merge pull request #109 from timflannagan/remove-doc-dir +087ba82f6 Remove the doc/install directory +121f35e9d Merge pull request #106 from anik120/registry-liveness-probe +b165a4cd7 Bug 1976326: fix configmap registry server liveness probe timeouts +2a45f5230 Merge pull request #95 from timflannagan/update-verify-check +e6894b43f scripts: Update the scripts/generate_crds_manifests.sh +f0b75da18 manifests: Update PackageServer CSV YAML manifest with re-generated keys +3fa2fc48e Merge pull request #103 from benluddy/bz-1975824 +76d53422c Resolve InstallPlanStepAppliedWithWarnings alert after some time. +c6208b0b0 Merge pull request #100 from timflannagan/update-owners +3dec0fb30 Makefile: Add additional verification checks to the verify target +db4bb2c0e scripts: Introduce a script that ensures nested modules are up-to-date +ccd5a62e7 OWNERS: Add additional reviewers +e7f18ff88 Merge pull request #97 from openshift-bot/art-consistency-openshift-4.9-operator-registry +48534ab06 Merge pull request #98 from openshift-bot/art-consistency-openshift-4.9-operator-lifecycle-manager +a4f1f3b83 Updating operator-lifecycle-manager images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/691e628254f318ce56efda5edc7448ec743c37b8/images/operator-lifecycle-manager.yml +4c14d475c Updating operator-registry images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/691e628254f318ce56efda5edc7448ec743c37b8/images/operator-registry.yml +f25f670c0 Merge pull request #92 from dinhxuanvu/opcon-gen +659bac3c6 Merge pull request #90 from awgreene/bz-1950047 +4327486a3 Update OperatorCondition CRD in manifests +8a3545331 Address various issues with OperatorCondition codebase +56d5faa1d Update OperatorCondition Role and e2e test case +06fb38628 Add OperatorCondition status sync and update operator upgradeable check +6156d25a1 Regen go-bindata for crd changes for OperatorCondition (#125) +952306bbf Add ConditionType to v2 api (#123) +927e6bba2 Add conditions array to OperatorCondition's spec (#119) +59934e50e Merge pull request #85 from benluddy/bz-1958296 +d19ffb361 Fix Template Annotations on Webhooks/API Service CSVs +41991c626 Merge pull request #88 from benluddy/bz-1968700 +44c25e24c Merge pull request #86 from njhale/fix/xattrs +4b4a76318 Fix nil pointer dereference while reporting bundle unpack status. +da96f3dcd fix(containerd): drop xattrs during unpack +1adb4495a Merge pull request #84 from vrutkovs/cvo-hotlooping +220c152f8 Surface API server warnings when applying plan steps. +78d224c4e Bump kind dependency to v0.11.1. +afcaa062b packageserver CSV: add missing properties +ca1f0b69c Merge pull request #83 from hasbro17/fix-ssa-error +0e9f3bffa Merge pull request #82 from joelanford/bz-1961472 +365495eae Filter secret names for registry pod's sa +9557387ca Explicitly set `readOnlyRootFilesystem: false` on created registry pods. +4a318fee1 Merge pull request #81 from benluddy/bz-1959158 +d3b5c5bc4 Merge pull request #80 from anik120/catsrc-metrics +8b1eb28aa Make ClusterOperator Available condition sticky. +b133dce55 Merge pull request #79 from joelanford/bz-1961314 +030b4afe5 Merge pull request #67 from gallettilance/sync +2281ea529 (bug) add after deprecation +630cc8e04 vendor changes to metrics(catsrc) from of/olm +625b70006 use snake case for catalogsource_ready metric +406828629 Call cleanup sync.Once.Do +82dc386c4 feat(metrics): Emit metrics for CatalogSource state +c1e3716e0 fix race in test with mockRepo/mockBlobStore +ac7c85de0 Merge pull request #75 from benluddy/bz-1947946 +5b9124dfa Merge pull request #76 from benluddy/bz-1958285 +0b7700ee0 Merge pull request #78 from hasbro17/bundle-unpack-timeout-bz +a5f4f3bf6 Merge pull request #77 from timflannagan/fix-packageserver-delegated-auth +fdbcd8e1f Annotate CRDs that are installed alongside CSVs. +b1923328c Bump ginkgo to v1.16.1 and gomega to v1.11.0. +b7a83ec5e Add eventually to e2e test crud operations +79616b38d Add unit test for varying job timeout +ce892120d Add unit tests for UnpackBundle +cc3e38e0f Parse timeout annotation before UnpackBundle() +86976b0bb installplan e2e test fixes +51d65b188 Add annotation to override default timeout +805d22917 Check for bundle unpack failure via status conditions +0f2dff6d2 Cleanup e2e tests and add case for invalid bundle image +782238935 Fail InstallPlan on bundle unpack timeout +b0798d0aa fix(packageserver): add tolerant delegating auth config +f82e4e14b Merge pull request #74 from ankitathomas/bump-apiserver +44c8bea85 pinning apiserver for delegated authentication watch request bug fix +d29099fba Simplify deployment status check to reduce flapping. +9498948b6 Merge pull request #72 from anik120/packageserver-co-message/reason +9ec5651af Bug 1955761: Set reason/message for Available condition in packageserver co +69fbfdf2d Merge pull request #70 from ecordell/cr-valbug +24d012397 Merge pull request #71 from dinhxuanvu/config-alpha +6eacf7ffa Move config serve and validate to opm alpha +fa23e819c bump kube-openapi to get validation fix +d9201a5c2 add unit test showing cr validation bug +cabb2c9bb Merge pull request #68 from benluddy/bz-1945443 +d44d9fd80 Use DeploymentAvailable instead of custom test for CSV status. +1751d4a12 Merge pull request #61 from lack/management-workload-annotation-rename +531b8b6a0 Merge pull request #56 from timflannagan/bump-k8s-to-v1.20.6 +9fa1f1249 Merge pull request #65 from anik120/termination-policy +7cf3faad6 go.*,vendor: Update the Go module version and re-generate root vendor tree +e50564af0 .gitignore: Ignore the sqlite journal binary files +15cadfada staging/operator-registry: Bump the k8s dependencies to v1.20.6 +b3227bd0c staging/operator-lifecycle-manager: Bump the k8s dependencies to v1.20.6 +35090f520 Merge pull request #62 from dinhxuanvu/olm-resolver-events +d552bf9cb Bug 1952238: Report catalog pod termination logs to catalog operator on exit +3440fa2c1 Merge pull request #64 from benluddy/verify-makefile-target +1a4a2176a Merge pull request #63 from joelanford/bz-1937097 +701e2a0b3 Add verify target to Makefile. +49bcc3eb1 Add unit test to verify resolver error handling for sync namespace +0083d6a7f fix(catalog): Reduce namespace resync in resolution failure +c227a5117 Add retries when pulling images +21fbc6ac4 Merge pull request #60 from benluddy/bz-1942522 +8281e2926 Rename workload annotations +85f8278d5 Fix resolution error if inner entry doesn't provide a required API. +ec8be6157 Merge pull request #42 from lack/management-workload-annotations +2df1ac175 Merge pull request #55 from kevinrizza/bundle-unpacker-resource-requests +b35304d6b Add management workload annotations +9d2fc1f57 vendor staging updates +8831a0457 Add resource requests for bundle unpacker +8c384e081 Merge pull request #53 from joelanford/fix/subscription-env-merge +e0b47b0f4 Merge pull request #50 from csrwng/roks_profile_patch +03e31a8ab Merge pull request #41 from timflannagan/bug-preserver-existing-sa-owner-refs-install +e3a385f7a vendor staging updates +f0c181d0e fix merging envvars from subscription.config +e6b5fdf7c add failing test for merging envvars from subscription.config +873f908ed Merge pull request #51 from timflannagan/revert-sno-packageserver-bug +f08b0a629 Revert "set packageserver replicas to 1 for single node" +fcc049e3b Add IBM managed cloud profile annotations to manifests +b5814a0b1 Merge pull request #47 from timflannagan/registry-sync-declconfig-updates +840f00345 staging/operator-lifecycle-manager: Update go.sum after running 'make vendor' +a66dfa929 Preserve existing ServiceAccount owner references during installs. +bdc74e956 Merge pull request #49 from benluddy/ip-retry-sync +f9f580dfb Resync manifests with latest sync of staged OLM. +8240f5c3e Update upstream tracking commits. +bb9c47fdc Revendor for staging/api v0.8.0 sync. +8a474173c Add .status.message and .status.startTime to InstallPlan. (#108) +b7a62ba82 add checks for operatorhub validator (#103) +ee94e8d34 Update OWNERS (#107) +454234f12 Add skips & relatedImages to CSV Spec +8ebe01432 Add optional go-apidiff test to CI +673453383 Revendor after latest staging sync. +25a783253 Always validate CR upgrade compatibility. +a56ab3a97 Add time-limited retries to InstallPlan execution. +def4a723b Bump github.com/operator-framework/api to v0.8.0. +56d0f84f7 Re-generate vendor after cherrypicking commit(s) +5c8db0aec Improve the declcfg and model validation +deed5877e feat(validate): Add opm validate cmd to validate config files +647c5a164 Delete the symbolically linked operator-registry.Dockerfile +b0f60a570 Add tests and fix bugs for declcfg server +385b96773 Merge pull request #45 from timflannagan/registry-sync +91d03b25e Merge pull request #46 from timflannagan/olm-sync +8c413c3f6 Update root vendor and staging/OLM go.sum +e45356ed7 go.*,vendor: Bump to k8s v0.20.4 +d87c907d4 Remove more testify assertions +38cc76f72 Fix e2e test with incorrect gomega matcher and remove testify usage +ca3266e14 Copy all CatalogSource annotations to its Pod +eabc62d9b Consider InstallPlan phase=Complete as terminal +007621c06 Give more precise reasons for Subscriptions with no candidates. +35fc7ef79 Clarify status condition error message, and update architecture docs +67296298f Add e2e tests for installplan failed on invalid operatorgroups +16e685b2c Indicate invalid OperatorGroup on InstallPlan status +de697a364 Merge pull request #44 from ecordell/no-adopt-copies +2e3a7fe5a Merge pull request #40 from timflannagan/bump-k8s-root-go-mod +c97146c19 go.sum,vendor: Run 'make vendor' +df6f50605 Purge staging/operator-registry/vendor +263f2e708 add server for model.Model +f981968b8 .github: Separate the jobs in the test workflow into their own workflows +de1e8a3a2 use equalsDeclarativeConfig function in load_test.go +adb078ecb move newly introduced packages to internal +3d19f70e6 declcfg_to_model.go: ensure package field and property align +185cd9e8b pkg/(declcfg|property): PR review feedback +da9688ffe Avoid stuttering "mkdir " errors +7c021e36c feat(declarative config): add base packages +06868cb4a bump vendor +11bb700a4 disown copied csvs +3466dbbff remove component labels when copying CSVs +312b92016 test that the operator api never adopts copied CSVs +f9fbc30ab go.*,vendor: Bump the k8s dependencies to v0.20.4 +fc92cb718 Merge pull request #38 from ankitathomas/operator-lifecycle-manager-sync +fad0f266a Merge remote-tracking branch 'main/master' into operator-lifecycle-manager-sync +2cea7f3c5 Merge pull request #39 from timflannagan/fix-olm-unit-tests +964b2a6df Merge pull request #39 from timflannagan/fix-olm-unit-tests +c00da97d0 correct top level files and vendoring +5f87deb2c Merge pull request #1653 from yeya24/add-CsvAbnormalReplacingOver30MinSRE-alert +50ce93ede Merge pull request #2075 from benluddy/bump-kind-v0.10.0 +d251e7e0f Update 0000_90_olm_01-prometheus-rule.yaml +28c2ab77c Bump test dependency on kind to v0.10.0. +eca9859ae Merge pull request #2062 from ankitathomas/single-node-packageserver +47d8851a8 Merge pull request #2061 from timflannagan/avoid-hardcoding-kubebuilder-version +a04d7d223 Merge pull request #2068 from benluddy/inconsistent-candidate-order-with-csv-in-two-channels +1b75db8ca set packageserver replicas to 1 for single node +343325d7e Fix inconsistent dependency candidate order. +78407c21f Merge branch 'master' into avoid-hardcoding-kubebuilder-version +f3430d1f8 Merge pull request #2070 from sathieu/patch-1 +733cc390f Allow to override download url in install.sh +b494ac1e1 Merge pull request #2047 from timflannagan/avoid-graceperiod-delete-zero +83c0c5daf Merge pull request #1937 from horis233/update-pr-template +8e798b6f4 Merge pull request #2060 from timflannagan/go-1.16-bump +26387563c Merge pull request #2064 from timflannagan/add-ci-dockerfile +caf72b787 Dockerfile: Add a symbolically linked release Dockerfile +0d654f80a go.*,vendor: Bump module Go version to 1.16 +70642817a Dockerfile: Use Go 1.16 image tags +bd5bfe089 Merge pull request #1817 from jeyaramashok/1774-csv-hotfix +de317b4b4 Dockerfile: Avoid hardcoding the kubebuilder version in the build root image +2d7e0292b Merge pull request #1936 from horis233/update-og-doc +0daaa46f4 Merge pull request #2054 from dmvolod/issue-1522 +9c46d43fa Merge pull request #2058 from openshift-bot/art-consistency-openshift-4.8-operator-lifecycle-manager +417a1853c Merge pull request #2059 from timflannagan/remove-duplicate-apierrors-package +a93f726a2 test: patch existing CSV for a hotfix +d5b23bc06 test/e2e: Remove duplicate package imports +f728dacf0 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/e3b61ff1dde2bfc2bc7f2b5efdd155d1d3299cd7/images/operator-lifecycle-manager.yml +552bbb54a Merge pull request #2055 from timflannagan/fix-trailing-slash-module-tools +c5321a5f2 Merge pull request #2045 from camilamacedo86/remove-ch-name +5443887a7 Set labels for the operator Deployment created via the ClusterServiceVersion +c13365df1 Merge pull request #2048 from benluddy/operator-framework-api-0.7.0 +aa7fb08fe go.sum: Run 'make vendor' locally +a083c072a tools.go,vendor: Remove trailing slash in github.com/go-bindata/go-bindata module +7d3c1de4a pkg,test: Avoid setting metadata.GracePeriodSeconds to zero seconds +98b8f42c1 Bump github.com/operator-framework/api dependency to v0.7.0. +a8f961074 doc: moving channel naming doc to website +5c6a9c6da Merge pull request #2044 from exdx/fix/exempt-labels +af8265057 Merge pull request #1999 from openshift-bot/art-consistency-openshift-4.8-operator-lifecycle-manager +5cc05a212 fix: add lifecycle/frozen tag to exempt list to stalebot closing certain issues +29573edff Merge pull request #2025 from benluddy/small-jitters +743495e91 Merge pull request #2024 from joelanford/fix/upgrade-alert +980537c37 Support jittering relatively small resync intervals. +d225f6beb Merge pull request #2029 from benluddy/sa-present-when-owned-by-non-csv +12ff8606a Allow non-CSV-owned ServiceAccounts to satisfy CSV requirements. +4eabd3d28 Merge pull request #2010 from joelanford/fix/dep-resources +36dcb5461 don't change CSV phase on service unavailable error +9c9a0a0c0 Gracefully handle service unavailable errors from kube-apiserver +23d4ea963 only override deployment resources when explicitly defined in subscription.spec.config +ba3182516 Merge pull request #1993 from benluddy/package-name-inference +b68402260 Merge pull request #1972 from jchunkins/modify_makefiles +710b0dc04 Infer package name property for unannotated CSVs, if possible. +d6133be3b Merge pull request #2016 from joelanford/fix/operator-controller-test-flake +60906a102 pkg/controller/operators/operator_controller_test.go: fix flaky test +0779756bb Merge pull request #1828 from zkyle95/master +27f495475 Merge pull request #1834 from errordeveloper/enable-debug-messages-via-klog +148100ca8 Merge pull request #1886 from cfergeau/single-node-developer +d1fc78db8 Merge pull request #1863 from jeloba/dont-create-default-service-accounts +5de59e426 Merge pull request #2012 from joelanford/go-1.15 +4bfb7b529 Merge branch 'master' into modify_makefiles +b744a8106 bump to go 1.15 +1bb711dc9 Merge pull request #1846 from awgreene/release-md +7e4f4b003 Merge pull request #1882 from horis233/update-developemnet-docs +038151010 Merge pull request #2011 from njhale/fix/adoption-log +195ce72f3 chore(adoption): use debug level to log missing components +bcb80ada7 Merge pull request #1951 from dinhxuanvu/pinned-skips +e7ae0eef4 Merge pull request #1965 from nikhil-thomas/fixes/doc +00c73acff Merge pull request #2005 from ecordell/benluddy-nicer-invariants +5c23b7c92 Merge pull request #1986 from awgreene/update-OWNERS-file +09e406869 Correct timflannagan GH ID on ownerfile +04c08702e fix(resolver): Allow skipped versions to be installed initially +659a9e517 support multiple subscriptions resolving the same bundles +710a3784e add package property to unit test cases +e77fb17e6 collapse resolver tests +3de932b82 Add meaningful string representations for resolution invariants. +7b82f2192 Update OWNERS file +7c710f373 Merge pull request #1995 from awgreene/operator-group-doc +32d3d89de Merge pull request #1958 from ankitathomas/apiserver-version-bump +50dfff447 bump k8s.io/apiserver for webhook auth panic fix +0cc658399 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/5a1293dd0f380abf50c12d65c36655486d7745d0/images/operator-lifecycle-manager.yml +c18f87a40 Fix OperatorGroup Documentation Example +59e29f836 Merge pull request #1990 from benluddy/subscription-constraint-strings +a63ae05d5 Merge pull request #1938 from joelanford/fix/zombie-operator +0416116c5 Clarify subscription constraint strings in resolution failures. +7b1731d86 Merge pull request #1974 from hasbro17/fix-csv-status-time-comparison +2e989308f Merge pull request #1982 from benluddy/continuous-registry-resync +785fb9829 Fix zero-delay resyncs for certain registry update policies. +086c4ba07 Merge pull request #1983 from benluddy/test-minikube-driver +3a7c42980 Use docker driver for minikube installation test. +2a283a382 Merge pull request #1975 from exdx/fix/stalebot +c51a83df7 fix: improve stalebot configuration for github issue tracking +dc7829327 Additional changes based on feedback +51dfe457b Changes based on PR feedback: +c89e1c655 update makefile, workflow, and docs +e8e768ecb Fix time comparison in CSV reconcile loop +e212f002c Merge pull request #1966 from benluddy/replacement-chain-cycle +af5cb8b6a Fix infinite loop when a CSV replacement chain contains a cycle. +5bad05410 Fix typo in docs +3a6bab227 Annotate manifests for single-node-developer cluster profile +75309020f Update shields +85ef01a85 Merge pull request #1941 from anik120/job-secrets +a047501de Merge pull request #1942 from awgreene/operatorcondition-controller-watch-deps +15436e9ca Merge pull request #1888 from exdx/fix/scoped-install +cd3130cd4 fix: create installplan directly in e2e test +0971e280e fix: use OLM client when installing CRDs +a6506b568 fix e2e test order +380872d59 Address comments from PR review: added e2e, improve unit +04c8fd442 Update OperatorCondition controller to watch deps +3e766cbe8 Merge pull request #1948 from joelanford/joelanford-reviewer +4795635cb Add joelanford to OWNERS as reviewer +6b8d6b799 operator_controller_test.go: use JustBeforeEach to ensure correct test setup order +891a1ee64 Only re-create operator resource if it has existing components +cac4593b9 Add unit tests for Operator controller deletion handling. +f5925b55c Merge pull request #1943 from awgreene/initialize-deps-with-opcond-name +16ae6c26b Create CSV Deployments with OpCond EnvVar +fbc4c77cc Bug 1909992: Allow private bundle images within private indexes +d06430e4f Merge pull request #1939 from awgreene/fix-operatorcondition-status-verbs +f6c273e9c Fix operatorcondition role verbs +8eb4b0f64 Merge pull request #1918 from exdx/fix/pin-sys +a64448940 Merge pull request #1933 from zcahana/fix_webhook_cabundle +113649e05 Merge pull request #1887 from guillaumerose/master +7e3f40d38 Update the template of PRs +493f70f60 Update editverbs and Make the instruction clearer +0b956b6ac Use correct caBundle for 'olmcahash' annotation +fa22f8002 fix: update moby/term dependency due to undefined: unix.SYS_IOCTL on macOS error when running locally +df6353105 Merge pull request #1911 from dinhxuanvu/upgradeable-type +d26451fb5 Change the "OperatorUpgradeable" condition to "Upgradeable" +4e1a54142 Update /manifests with default cluster profile annotation +bd76882dc Add the release annotation to all documents in all files +feebee760 Merge pull request #1900 from awgreene/post-pending-operatorconditions +d2042c24d Merge pull request #1913 from awgreene/fix-deployment-annotation-bug +b3d8a7a17 Multiple operatorconditions should not update the same deployment +fa18a49fd Merge pull request #1903 from awgreene/bump-deps-k8s-1.20 +ca9016c2b Reduce e2e test failure rate +f55da6e71 Update manifests +28a57c668 Fix manager start commands +49c31f460 fix zap logger +240a39081 Fix controllers and run codegen +e72261981 Update semver import and update SSA +983b63d05 bump k8s deps +6e14b48a4 CSV Annotations override pod annotations +a6e29ef53 Merge pull request #1905 from jmccormick2001/docs-channel-naming-design +7f36227dd Merge pull request #1904 from dinhxuanvu/sa-csv-check +a59b4e882 Merge pull request #1899 from awgreene/fix-operatorcondition-generation +32edd682c fix(olm): Verify ServiceAccount ownership before installing deployment +a3cd4afaa cleanup formatting +a1f114b2a initial channel naming doc and related images +8d9c02ee0 Merge pull request #1901 from awgreene/stop-printing-debug-noise +bbe5a321f Don't create OperatorConditions for copied CSVs +eaed5e11a Reduce log noise from OLM +64bff0dd6 Merge pull request #1892 from benluddy/copied-csv-updatetime +9c08a13de Merge pull request #1896 from dinhxuanvu/manual-approve-flake +2f75d6a98 fix(e2e): Fix subscription manual approval flaky test +eba4ff8c7 Preserve original .status.lastUpdateTime in copied CSVs. +f1df66830 Merge pull request #1885 from dinhxuanvu/create-operatorconditions-for-operator +8451f0847 Add OLM support for the Upgradeable OperatorCondition +44e70e6b7 Merge pull request #1881 from horis233/check-sa-owner +eed758a73 Merge pull request #1875 from awgreene/create-operatorconditions-for-operator +5f3c090a4 Merge pull request #1878 from anik120/auth-catsrc +f9cedec6b Merge pull request #1884 from benluddy/service-updates +b438028a0 Support InstallPlan steps upgrading existing ClusterIP Services. +4e7f8bf6a Add authentication for private index images +798238998 Introduce OperatorConditions +2e1a6d03d revert the change for e2e test +b3940c21b format the import order +4cef35525 Merge pull request #1832 from guillaumerose/master +c52ab20b0 update manifests +45543f4a4 update development document to add more informations for the e2e environments +fe16404f4 Only check the owner of the service account if the service account has owner +ecc7689b6 update e2e test +d83855f0b check the service account owner in the requirement check +8a4330529 Merge pull request #1876 from njhale/fix-ioob +fe468ab5f Add release annotation +97c46f9e5 Bump yq from v2 to v3 +9cb137587 fix(catalog): be defensive about directly indexing catalog pods +0c38f49d1 Merge pull request #1873 from exdx/feat/issue-labeler +0ec97565b Merge pull request #1843 from dinhxuanvu/ip-recreate +2a01d116e add default label to issues. add config file with upstream OLM contact information. +60a4dc1cf Using subscription reconciliation to clean installplan status instead +e0763e5a3 Merge pull request #1862 from awgreene/bump-k8s +551a7fe40 fix(ip): Recreate pending installplan if deleted before approval +84ac0895e Merge pull request #1616 from Jamstah/patch-1 +46087ef5e Generate code +8439d2243 Bump k8s dependencies to v0.19.3 +dd03e5234 Don't create default ServiceAccounts +070fbd3a3 Merge pull request #1855 from ecordell/service-duplicate-ownerrefs +bf03bcda9 test(certs): add a test the ensures services do not get the same ownerref added twice +03b34ce5a Update release.md with milestone step +8d80d58d9 Merge pull request #1844 from dongwenjuan/master +310b9107d test: scaffold a basic unit test for certresources +f445b924b chore: generate fakes with inline go:generate directives +9b496c696 Merge pull request #1850 from benluddy/changelog-0.17.0 +86f6e9cfc Merge pull request #1507 from harishsurf/csv-e2e +82074324f Merge pull request #1848 from dinhxuanvu/svc-hash +757c5aa7c Add unit test case to grpc and configmap reconciler test +f18b5312c Generate changelog for v0.17.0. +adfbdc34d Merge pull request #1849 from benluddy/manifests-0.17.0 +be6f02ffa Add spec hash to service's label to ensure service is correct +6a7298bfa Generate manifests for v0.17.0. +c0d4cff41 Merge pull request #1842 from benluddy/version-bump-0-17-0 +487a896ba fix the comment in package-server +76d68d543 Bump version to 0.17.0. +e3e4a37b8 Replace assertions with Gomega's matcher library +10410a899 Merge pull request #1500 from harishsurf/scoped-e2e +c4620406e Merge pull request #1502 from harishsurf/catalog-e2e +28bda9e47 Convert scoped_client_test to ginkgo +309954456 Merge pull request #1835 from awgreene/update-manifests +5c4bd9521 Replace assertions to use Gomega's Matcher library +0b242675f Set default, min, and max values on Webhook ports +212cc45b8 Enable debug messgaes via klog +5aa5fed0a Specify cluster name when there is only one cluster in kind +2cbc79f3b Merge pull request #1823 from sjenning/bz1889838 +fb6c473ef fix race in Operator reconciliation +fd261994f Merge pull request #1816 from sjenning/bz1888073-master +bbc75c7e8 prevent no-op hotlooping on Operators +799c353d3 Merge pull request #1807 from dongwenjuan/master +0e063188e Merge pull request #1748 from jianzhangbjz/channel +fd2a8f41c Merge pull request #1808 from awgreene/default-kubebuilder-ca-mount +ca3b00e3e OLM mounts CA Certs where Kubebuilder expects +a83ce2baa fix typo +51cc83a5c Merge pull request #1803 from awgreene/improve-transistion-csv-logs +4b47a3a6e Improve transitionCSVState error logs +4171a2183 Merge pull request #1741 from horis233/fix-typo +0ca7d6b54 Merge pull request #1799 from jupierce/art-consistency-openshift-4.7-operator-lifecycle-manager +a3fff4b30 Merge pull request #1797 from awgreene/retrieve-ca-from-cw +e12a78547 Merge pull request #1798 from exdx/fix/inflate-ip +3f34aabde Retrieve CA from conversion webhooks for CA Hash +34c4f2fc6 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/ac81dd4ff0bd57c4e75058d25b40615b92948259/images/operator-lifecycle-manager.yml +ebf370e20 fix: remove extraenous manifest assignment and update CRD stepper. Add e2e test to verify configmap-based manifests. +6e803bb8a Merge pull request #1480 from camilamacedo86/add-bug-report +092e0d41a Merge pull request #1791 from benluddy/downstream-installplan-properties +bdd163f70 Regenerate downstream InstallPlan CRD manifest. +aef200abd Merge pull request #1781 from benluddy/property-projection +5928c67c9 Annotate CSVs with the properties used during dependency resolution. +101989643 Bump operator-framework/api dependency to v0.3.16. +8a5004267 Merge pull request #1775 from njhale/bump-k +4e686be46 Merge pull request #1773 from exdx/fix/polling-cycle +488004863 fix(mockgen): use "go run" in all go:generate comments +00c20978b chore(modules): update vendored deps +64bf0c4c4 chore(modules): bump k8s deps to v0.18.9 +3231653c8 fix: update check from previous polling implementation +be036c9de Merge pull request #1766 from benluddy/unresolvable-sub-error +99b811f72 Merge pull request #1767 from awgreene/fix-conversion-webhooks +dccb4d570 Allow ConversionWebhooks to define targetPort +b162272a1 Bump operator-framework/api dependency +8104bc4c2 Merge pull request #1763 from openshift-bot/updating-dockerfile-baseimages-to-mach-ocp-build-data-config +95f6796fd Update pkg/controller/registry/resolver/resolver.go +004f4ef52 Make a subscription without at least one candidate fail resolution. +67c4ccdec Merge pull request #1729 from jianzhangbjz/catalog +97d3d41d9 update error logs for channel head querying +18425e141 Merge pull request #1756 from exdx/doc/default-polling-design +971eec7e8 Updating Dockerfile baseimages to mach ocp-build-data config +ecbff191e Merge pull request #1761 from awgreene/reusue-active-certs +cabaf08b4 OLM should use valid CA certs if available +cf99c6ef2 should not compare if no imageID +9c29e9835 Merge pull request #1755 from exdx/fix/update-pull-policy +5f02268eb Merge pull request #1732 from njhale/fix-op-csv-cond +8380a9ab7 Merge pull request #1731 from exdx/fix/catalog-sync +c4221e7e9 Merge pull request #1745 from awgreene/hco-bug +488b9a98c fix: update catalog pull policy to Always in case the image is not digest-based. +bb2d1f9c1 Merge pull request #1723 from exdx/fix/duplicate-pods +431446661 doc: default polling +9dbee83f8 Merge pull request #1735 from dinhxuanvu/add-skips-operator +4c83276a9 Merge pull request #1 from njhale/hco-bug +1c0c6d759 test(install): expect revision history = 1 +ab10b80da Merge pull request #1751 from awgreene/changelog +f03d4aa21 Genereate 0.16.1 changelog +8a1c5c478 Merge pull request #1750 from awgreene/0.16.1-manifests +3089813cd Release: Generate Manifests +c6eae26ea Merge pull request #1749 from awgreene/bump-olm-0.16.1 +2ad4bb577 Bump OLM Version to 0.16.1 +e4de9a206 fix: remove catalog update pod if it's in a failed state to prevent cycles in the catalog reconciler. +5615cfde1 fix: requeue catalog source sync if update pod has not reported ready; remove duplicate pod immediately after imageID check; turn down polling logging +3229876cd add correct polling interval based on modulus +b556fef5d Handle mutliple skips and add unit test +2be67979d Set RevisionHistoryLimit per Deployment +21a75f3af Merge pull request #1739 from operator-framework/update-OWNERS +1916b0391 fix typo in the error message +a6c3ed229 Update OWNERS +2ee3f9d1b Merge pull request #1738 from openshift-bot/updating-dockerfile-baseimages-to-mach-ocp-build-data-config +113d6e40b Updating Dockerfile baseimages to mach ocp-build-data config +922f80ba0 Add skips information to Operator representation +29ad22b82 chore(modules): update vendor +e163e0c72 fix(operator): map top-level csv phase to component conditions +1a9425858 fix: resync catalogs with jitter if polling enabled +e1fc1b741 Merge pull request #1624 from ankitathomas/registry_poll_interval_retry +025c57fb9 Merge pull request #1727 from awgreene/ownerz +04dfd27ef Merge pull request #1725 from benluddy/fix-subscription-without-channel +55abcbe27 Merge pull request #1720 from simrandhaliw/update-manifests-to-include-bug-fix +03e14b465 Merge pull request #1728 from awgreene/node-selector-bug +28d41bb77 Bug: Fix nodeSelector subscription config override +bbff47839 Bug 1861605: Update manifests to include the bug fix +c36b26fc8 Update Owners file +1fd8c055c Apply suggestions from code review +56a72a9c8 doc: add reporting bugs doc and small nit improvements in the README +377d39126 Fix install plan creation for subscriptions that omit channel. +979464bc5 Merge pull request #1613 from konsotirop/installplan +3fe1a7169 Move server side apply patch code to library, use ssa to update catalog source pods +107eb20b4 Merge pull request #1715 from dinhxuanvu/fix-stale-bundle +4c2de89bc Merge pull request #1721 from njhale/fix-crd-adopt +349a617dd Merge pull request #1717 from Bowenislandsong/total_test +9fa50a815 Merge pull request #1716 from awgreene/nodeSelector-support +ba9a5238d Bug: Fix SubscriptionConfig NodeSelector field +558dc887f fix(operator): re-adopt manually disowned crds +d6b742e85 Add Total Test Number to report +6a2f1f6c7 Fix stale content in configmap due to stale bundle image in the node +61447446b Merge pull request #1713 from simrandhaliw/operatorstatus-description-bug-fix +8f47f42e1 Bug 1861605: Reduce length of explanation of status of Operator resource +79b073783 Merge pull request #1706 from Bowenislandsong/catsrc_weighting +294de7359 Add Catalog Source priority for dependency resolution +81e19588a Merge pull request #1699 from dinhxuanvu/deprecated-filter +e52905795 Vendor registry 1.13.6 and fix unit test +599a6a4c6 feat(resolver): filtering deprecated bundles in resolver +be5540368 Merge pull request #1687 from dinhxuanvu/add-label-type +93be814b4 Add unit test to resolver for label dependency +e3023d9c7 Vendor the registry changes for label dependency constraint +af0e53552 feat(resolver): Add label dependency type to new resolver +258584b1c Merge pull request #1661 from njhale/ext-adopt +ce6aa2dd4 Merge pull request #1696 from ecordell/remove-legacy-resolver +c19e532ab Merge pull request #1702 from benluddy/spurious-bundle-cardinality-error +59af78a3a Remove spurious check for duplicate operators in resolver. +9d815df1e Merge pull request #1649 from simrandhaliw/add-conversion-webhook-support-for-olm +49d15bae4 Addressed review comments +1797b8835 Merge pull request #1680 from kramvan1/patch-1 +4819decd2 WIP: Add Conversion Webhook support for OLM +ad1eb2ee6 test(e2e): pass ip test w/ created or present steps +7a3c40ef9 Merge pull request #1695 from dmesser/update-default-catalog +c0ec73047 feat(operator): adopt referenced installplans +27b072d64 remove legacy resolver +9c259b8ad Merge pull request #1694 from njhale/v1-default +52254226e change default catalog to index image +a2fab316a chore(vendor): include v1 operator api version bump +e5113cd39 feat(operators): reconcile v1 operator resources +3adebe965 chore(manifests): add v1 operator crd spec +31ea82c96 chore(codegen): drop v2alpha1 clients/listers/informers, add v1 +9c6e9bbeb chore(scripts): drop v2alpha1 from codegen +1c9ba958f chore(modules): bump api dep to include the v1 operator spec +fddbe484a Merge pull request #1692 from benluddy/baseimage-path +19489c72b Remove unnecessary ENV directives from base.Dockerfile. +e88a8971f Merge pull request #1652 from operator-framework/new-resolver +bbaaf7651 Merge pull request #1684 from njhale/fix-ip-gen +b7d3b9e7f add CsvAbnornalReplacing alerts +a73b45e48 configure metrics for new resolver +6131cc467 rebased +17e553ae1 check for cache consistency issues when querying for a dependency +d0d574645 look in all catalogs when no catalog specified +0d00bfc8c emit events when resolution fails +7c49aef22 fallback to standard path for kubebuilder assets +16c810d7e fix catalog grpc connection state updates +123c6cfcd don't include docker image in the docker build test for kind test runs +b37f67697 fix crd upgrade e2e test +ebd4b9a5e retry for flakes +3712fd8be make catalog delete tests less flakey +7f66ef02d add a parity test for transferring api ownership between operators +5351327b4 make catalog updates in tests less flakey +849a2aa41 update package anti-affinity test +e4134dfff properly handle solver invariants +5875675e4 track existing CSVs without subscriptions as mandatory +614a7a8ff handle csvs that are already installed but don't have subscriptions +0b02783b4 extract properties/dependencies from existing operators in the cluster +4665d355c Fix check for whether or not a sub was added during resolution. +4a35e1780 Prefer bundles from the default channel in resolution. +bbd94f70e Try to detect kubebuilder installation path if not explicitly set. +3c10ae8f3 Regenerate registry client test fake. +1e5d3e5c4 Bump operator-registry dependency to v1.13.3. +90de599d5 deduplicate input installables +fec1bf7bb expire cache when grpc connection is READY +8d036cb9d fix sorting of inputs for dependencies +96cef9cec enable new resolver by default +2e2a50512 prefer the same catalog for dependencies +69aaf5cce fix resolver bugs, fix cache race, and re-enable tests +eaa4a5790 fix nested dependency resolution +0b20f2b20 fix verify +74573bce9 ensure cache is filled with content before marking it as not a miss +a91786a6f renaming / refactoring +8b4439bfe rename solve package +0df4f6c09 treat dependencies generically +8bed2cff2 refactor dependency walking to avoid recursing +236ab6523 support skip list in bundles +131f6870e support startingCSV +359a5d640 pin etcd and grpc +05a5abdd7 split old/new resolver and tests +e0afeb7bc test updating to a package with skiprange that is not head +c6b66150c search for operators in catalog order +5552fe6d9 move csvname filter to a predicate when finding bundles in the cache +7ab5dca1f use cardinality-based AtMost constraint +376167a77 resolver can resolve updates +be82373d9 chore(deps): bump operator-registry +7cae89364 don't mark virtual package nodes visited +1afecb8eb Decouple filter predicates from the operator cache itself. +e9f83b6ca memoize bundle walking +fb7f6754d support semver ranges +4083aa6ff use new solver interface in satresolver +8f79243c5 Adapt resolver unit tests to run with both implementations. +964862934 Fix unit tests and add GVK dependencies extraction +8a4dd1a4d Strip plural from APISets in resolver cache +774e83054 Extract dependencies info from bundle and add to Operator object +b56ac763b (feat): Add sat resolver for version dependencies +ac25cb747 fix(install): account for installplans when calculating generation +b6ab64dbe Merge pull request #1657 from anik120/dependency-resolution-metrics +01d2def74 [metrics] Dependency resolution metrics +20241c60c Merge pull request #1678 from awgreene/rebuild-busybox-operator-index-image +f6b4cd739 Add busybox-dependencies-index image manifests +3502ac2ab Remove unneeded toleration from catalog source pod +8188429e4 Add additional logs to syncCatalogSources +b3effc618 Merge pull request #1662 from awgreene/fix-webhook-e2e-test +f019f85cb Merge pull request #1669 from ecordell/gc-installplans +ff2ee560f fix(installplans): GC older installplans +7ca6ce962 Merge pull request #1645 from Bowenislandsong/feat/add-flake-analyzer +c6d569901 Merge pull request #1656 from exdx/fix/delete-grpc-e2e-fix +55ea14156 Merge pull request #1642 from dinhxuanvu/ocs-lib-fix +690347a67 Merge pull request #1655 from benluddy/unyum +305d4ea15 Bug: Fix incorrect deployment annotations +3ba83affa Merge pull request #1659 from dinhxuanvu/fix-deprecated-test +820db5c86 fix: explicitly delete collection of catalog source pods in grpc e2e test +28fe1bb5c Fix UpdateSingleExistingCRDOwner test case +54ec2f5e8 Merge pull request #1654 from benluddy/error-duplicated-solver-inputs +44d441f8d Fix validate CRD compatibility check and deprecated CRD test case +59995d9a9 Omit (hopefully) redundant yum update from downstream builder stage. +0e59b2509 Return an error when solver input contains duplicate identifiers. +9e5c6c421 Merge pull request #1641 from exdx/fix/crd-e2e-test +c581bb237 Merge pull request #1650 from benluddy/preferences-refactor +cc6e86884 Merge pull request #1629 from matskiv/unique-binding-names +9c9f305be Merge pull request #1647 from exdx/fix/remove-e2e-skip +d5cdd52e3 Refactor solver preference searching. +23c48dfe1 Merge pull request #1643 from Bowenislandsong/feat/e2e-artifacts +afb72be15 fix: remove bundle e2e skip +bac1cbd7c Add flake analyzer +18150f98d Update the e2e test case +c2dbcd51b fix(resolver): Exclude all installed packages in dependency search +bc1841d55 Merge pull request #1639 from ecordell/fix-metrics +84fc5feb0 Merge pull request #1623 from ankitathomas/plural_resource_in_relatedObjects +a6962c83c Bug 1855088: generate unique role and binding names When same permission rules are defined for different ServiceAccounts, OLM would generate same name for (Cluster)Role and (Cluster)RoleBinding related to this rules. This change should ensure that unique names are generated, taking into account ServiceAccount name and CSV Name and CSV namespace (for ClusterRole) +65c355cbf Merge pull request #1635 from njhale/fix-always-cleanup-e2e +7bd6c2276 feat: add parity tests to resolver +a97ce0076 fix: use server-side apply in crd e2e test when changing the subscription to point to a new channel to avoid transient object modified errors +9e63ad488 Merge pull request #1607 from njhale/adoption +dc4f6894f renaming / refactoring +aad28cd0a fix: Use PR head commit in artifact naming instead of merge commit +4438cc1f1 rename solve package +8e90ac0c5 Merge pull request #1478 from marcusportmann/master +543b569c5 Merge pull request #1637 from exdx/fix/vpa-crd-e2e +a5b29b4c6 fix(e2e): make problematic test specs eventual +092d68751 fix(e2e): copy rest config from test ctx +0870a36c3 fix(csv): prevent duplicate service ownerrefs +f03ceeb0a feat(operator): automatically adopt generated resources +1db5869c4 Merge pull request #1640 from njhale/skip-cr-test +42a972bdd treat dependencies generically +3b895b771 refactor dependency walking to avoid recursing +0f800116b fix: install VPA CRD directly on clusterfor bundle e2e test. +a5096dd30 support skip list in bundles +7341a41fc support startingCSV +cabdc2bd7 test(e2e): skip bundle cr install test +408a24b3e fix(metrics): query cache found object count metrics +8e1c299b0 Merge pull request #1636 from exdx/fix/check-installplan-e2e +a82db70fd pin etcd and grpc +465df39dd split old/new resolver and tests +33c9587bb test updating to a package with skiprange that is not head +de9d35d6f fix: add installplan check after subscription status check for gc tests. this will help reduce the e2e test flakiness as resources were sometimes checked before the installplan completed. +92c781053 test(e2e): delete all subs, installplans, catalogs, and csvs in test teardown +c1af96599 Merge pull request #1631 from exdx/fix/bundle-objects-test +6b3c309ce Merge pull request #1630 from matskiv/documentation-improvements +35ef62299 search for operators in catalog order +dac555dd3 move csvname filter to a predicate when finding bundles in the cache +768a8dd80 use cardinality-based AtMost constraint +5e2cec7bb resolver can resolve updates +665390c8b chore(deps): bump operator-registry +0f8841f62 don't mark virtual package nodes visited +3bdcaa030 Decouple filter predicates from the operator cache itself. +6fe6abc14 memoize bundle walking +ec3dc5c5f support semver ranges +d72759da9 use new solver interface in satresolver +836d35cb2 Adapt resolver unit tests to run with both implementations. +bac7177db Fix unit tests and add GVK dependencies extraction +d4ada84aa Strip plural from APISets in resolver cache +ee898423f Extract dependencies info from bundle and add to Operator object +717b951cc (feat): Add sat resolver for version dependencies +2b2c4cfe1 Merge pull request #1632 from benluddy/atmost-constraint +c4cd7ad83 Merge pull request #1604 from benluddy/test-csv-owned-api-retry-update +1147ce9d6 Add an AtMost cardinality constraint to the solver package. +9ff5ad0b6 fix: checkinstallplan status in bundle e2e test +b84d6989d fix: add kubebuilder to development requirements +50cdb32e1 fix: broken link in PR template +02060ef38 Bug 1855088: generate unique (Cluster)RoleBinding names +e0561c2c8 Setting resource to plural in relatedObjects +9febd1677 Merge pull request #1619 from benluddy/solver-preferences +a73043275 refactor(solver): small naming changes and iterative search +3a68739e3 Merge pull request #1618 from Bowenislandsong/feat/e2e-artifacts +d1c13c63b Retry update in flaky test of CSV w/owned API Service. +e4f48e0f5 Introduce preference order for solver. +745bd8e96 Allow ConsoleYAMLSample resources from bundle manifests +b6995763e Add workflow to save e2e test artifacts +fb2a2e988 Merge pull request #1577 from exdx/feat/support-pdbs +54258b940 Merge pull request #1617 from njhale/fix-e2e +61a270d43 test(e2e): patch installplans w/ server-side apply +3ea8e306b Merge pull request #1564 from exdx/feat/gardener-objects-bundle +486ca4b96 Merge pull request #1603 from anik120/subs_sync_metric_re-fix +4bed98128 Bug 1822396: Update metric when Subscription is updated +b3af2089e feat: add design docs for including additional objects in bundles +5deac9513 Merge pull request #1611 from exdx/fix/olm-book-link +d78799b02 Merge pull request #1610 from benluddy/metrics-test-matcher +5558d501c fix: update README to point to the OLM book website instead of github repository +86fba414c Merge pull request #1600 from kevinrizza/node-selector-update +20edf9fdf Merge pull request #1592 from Bowenislandsong/e2e-operator-failfast +856be6fba Add more precise matching to the metric end-to-end tests. +509fac3c4 feat: support new bundle object types: priorityclass, pdb, and vpa objects are now resolved from the bundle by OLM. +41feee706 Merge pull request #1596 from benluddy/assertions-in-assertions +7e610de6d Merge pull request #1598 from benluddy/e2e-local-nodes +68dd6da4c Fix a flaky CRD test. +4eb7bfed4 Merge pull request #1601 from kevinrizza/bump-version-0.16.0 +5cc19b361 Disable parallel e2e-local runs by default. +a41857056 bump olm version to 0.16.0 +1275235ad Update ocp manifests with latest template +24e78eaf6 Replace assertions within async assertions. +4e76eba9b Merge pull request #1589 from ecordell/ip-status-is-status +2525d918e Remove failfast from operator e2e test +db4cbcbc7 fix(installplan): don't store the manifest contents on the installplan +feaf1977b Merge pull request #1519 from anik120/subs_sync_metric_fix +64f80e7a5 Merge pull request #1583 from kevinrizza/bug-1847540 +fe88505ed Bug 1847540: resolve only default channels +c8b448430 Bug 1822396: Delete subscription metric when an operator is uninstalled +8e05b8e83 Merge pull request #1562 from kramvan1/remove-deprecated-os-label +112a1035d Merge pull request #1579 from njhale/fix-default-logo +6242436b7 Merge pull request #1479 from camilamacedo86/add-contribution-doc +d3da93782 fix(package-server): get icons from default channel +eae7d0a46 Merge pull request #1578 from njhale/bump-api +5a00be47f chore(modules): bump api dep to v0.3.7 +a401b7194 doc: add CONTRIBUTING.md +67d4ac887 Merge pull request #1512 from harishsurf/reporting +96cd8c4ee Merge pull request #1438 from camilamacedo86/uninstall-2 +40e8b308d Merge pull request #1539 from anik120/0.15.1-changelog +2b4233852 Changelog for 0.15.1 +40d46789c Merge pull request #1542 from benluddy/release-fixes +fa6c0a6a2 Merge pull request #1465 from benluddy/fix-goroutine-panic +4b18ae463 Merge pull request #1558 from benluddy/install-flakes +c8e001b31 Merge pull request #1443 from harishsurf/metrics-e2e +0a52ac8b1 Merge pull request #1501 from beautytiger/cleanup/duplicate_import +861d9990d Merge pull request #1563 from ecordell/weights +710493bd1 feat(resolver): don't build new clauses for weights +55eec053b feat: add uninstall +3018c771a beta.kubernetes.io/os deprecated since v1.14, removed in v1.19 +39bf0c782 Merge pull request #1379 from awgreene/remove-webhook-enhancement +da441902e Merge pull request #1535 from exdx/fix/block-storage-version-crd +649df59ee Reduce install.sh flakiness. +11151c8c2 Merge pull request #1549 from ecordell/rbac-fix +7646ccbf6 fix: add check for storage version changes when installing CRDs. This prevents data loss when a CRD is upgraded and no longer supports existing stored versions of CRs on the cluster. +5f045c0b2 Merge pull request #1482 from Bowenislandsong/bug/updateDisplayName +7473aec47 Update PkgManifest upon catsrc update +9b507ca14 fix(catalog): no operatorgroups in a namespace should be an error when resolving +1e10c12bf Merge pull request #1550 from harishsurf/bug-1822040-og +0869e8db4 Convert metrics_e2e_test to ginkgo +cb7e74edc Fix delay when OLM applies label to Namespaces +5131c6860 Merge pull request #1521 from dinhxuanvu/required-api-package +b712bf1df Add more comments on e2e test case to clarify test flow +cf32df90c Add test for release installation instructions. +d166546a3 Merge pull request #1540 from awgreene/webhook-container-port +49c1fde91 Remove CRD manifests from 0.15.1 quickstart's olm.yaml. +bd15e2400 Preserve .crd.yaml suffix for manifests copied from api. +f3550584f Don't put CRD manifests into olm.yaml. +0e17c44da Merge pull request #1516 from exdx/fix/bug-1833195 +34bbcc959 fix(webhook): Wire ContainerPort to Webhook +aca04c257 Merge pull request #1538 from anik120/manifests-0.15.1 +ab0e18356 Manifests for OLM 0.15.1 +b7891aa28 Merge pull request #1537 from anik120/bump-0.15.1 +cef848348 Bump OLM to 0.15.1 +92ec23767 Merge pull request #1525 from harishsurf/bug-1819308 +f063fdbfa Address feedbacks on registry client interface +0f13ffff5 Compose registry client & interface under a new interface +923b93f2b Merge pull request #1533 from anik120/0.15.0-changelog +1e77c07f2 Changelog for 0.15.0 +6bdb86b90 Add e2e test case to test multiple dependencies with same package +f9adcc282 Update unit test cases to adapt to new changes in NamespaceSourceQuerier +3480006cd Edit test cases to work with new changes on NamespaceSourceQuerier +a16ec47a7 Mockgen for registry client +abc44c8c2 fix(resolver): don't pick operator from same package when resolve requiredAPI +4d7cd4d69 Merge pull request #1472 from awgreene/podconfig-test-flake +f34530f60 Manifests for OLM 0.15.0 +ba2cb1b3b Update scripts to include crds during release +55b9124b2 fix: add ownerrefs to bundle objects; add e2e tests for bundle object gc +14fae5e9a Merge pull request #1439 from harishsurf/pkg-msft-e2e +4181bcce3 Converted packagemanifest_e2e to ginkgo test +1d0bcd5a2 Merge pull request #1520 from awgreene/packagemanifests-keywords +dd49980c3 Merge pull request #1513 from njhale/fix-qset +06e71752c Deleting a CSV removes related CSV metrics +424dc2928 Pod Config Deployment Hash Error +74ce8c1c0 PackageManifests should include CSV Metadata +fce8caf9d fix(queues): requeue events against all-namespace queue if present +552187525 Merge pull request #1424 from harishsurf/e2e-part1 +4bac72c0f Modify dynamic_resource_e2e_test to ginkgo +eb9959d86 Merge pull request #1515 from awgreene/robust-webhook-selector-test +b2098e361 Modify prow ci logging for e2e tests +b12c6244f Update Webhook E2E Namespace Labels +3566b2442 Merge pull request #1429 from harishsurf/e2e-gc +46b6c1b26 Merge pull request #1509 from awgreene/csv-updated-on-webhook-change +de8797b47 Detect WebhookDescription changes in CSVs +620986f1b Merge pull request #1503 from anik120/bump-olm-version +b6da2f600 Convert gc_e2e to use ginkgo +e533e19b7 Merge pull request #1489 from awgreene/webhook-unique-names +ffe908629 (fix) Admission Webhook names must be unique +4b8166082 Bump OLM version to 0.15.0 +e52a0cd1a Merge pull request #1496 from awgreene/operatorgroup +df543faf2 Fix upstream.Dockerfile +51ae73552 Update OLM to use UID for OG Labels +5a46a5dce cleanup: delete duplicated import in olm +8f8a1a86d Merge pull request #1470 from exdx/fix/bug-1825330 +2f9a54c2c fix: address sttts feedback +fb457991d fix: support creating v1beta CRDs to avoid data loss during conversion to v1. Due to data loss during client side conversions OLM will support two different paths for v1 and v1beta1 CRDs. +90a8b4aa8 Merge pull request #1483 from awgreene/dependency-bug +af714e91b fix(resolver): Transferring API Ownership +44cf5cf8b Fix Operator Generation code +38098eedd Changed address for readiness probe and liveness probe on registry-server +105cf4b61 Merge pull request #1468 from njhale/op-disc +db879834d test(e2e): correct tls detection in metrics spec +8c8e60bf6 test(e2e): make operator resource creation eventual +a6afaddc1 test(e2e): simplify csv requirement event spec +ef7257da7 chore(modules): pin controller-runtime to master +335a24af9 chore(manifests): include double-hyphen olm deployment options +9adb4efdb fix(client): supply missing params +da527ce92 test(operator): gracefully stop test controller manager +9c5a9337d fix(operator): swap top-level update for status update +8840a5a65 feat(operator): enable configmaps to be operator components +9322a0fa1 test(lib): add unit test for metav1 time conversion hook +1b519dbf6 chore(make): use existing kubebuilder installation +e428e8b84 chore(logs): set manager setup log level to 4 +0e759d6f1 test(operators): add e2e test for the v2alpha1 operator resource +738e9ee07 feat(operators): add v2alpha1 operator controller +08e085e83 Merge pull request #1458 from benluddy/resolver-cache +a9a42c2ed Add an operator cache for use by the resolver. +b2b68b9a4 Merge pull request #1464 from ecordell/ofapi2 +5f230069e Catch failed Ginkgo assertion in test goroutine. +fe19a530c chore(api): switch to operator-framework/api +b664fed89 fix(secret): use a synthetic kind instead of an api field to determine bundle secrets from pull secrets +81650bbaf chore(make): copy crd manifests from apis repo +4745e326f chore(deps): bump to kube 1.18 +56f1a45b6 Merge pull request #1447 from exdx/feat/support-secrets +3cbeec064 Merge branch 'master' into feat/support-secrets +09cd6b564 Merge pull request #1460 from benluddy/fix-unpack-test +10e77a9ad Fix failing E2E bundle unpacking test. +bfccbaa7a Merge pull request #1440 from benluddy/sat +274e03836 Add initial SAT solver package. +9f0784075 feat: support secrets from bundle +cc9352619 Merge pull request #1455 from exdx/fix/add-empty +62d866165 fix: add empty go file to packge to fix make verify +2795e5660 Merge pull request #1416 from exdx/feat/v1-crds +6a37a199a feat: support v1 CRDS in OLM. Simplify InstallPlan Execution via new Stepper interface. All CRDs will be converted and handled at the v1 APIVersion. +15825bacc Merge pull request #1454 from benluddy/regenerate-test-chart +7c893c486 Regenerate the chart embedded in the test installer as needed. +88654beec Merge pull request #1451 from harishsurf/github-workflow +4e90e55a5 Merge branch 'master' into github-workflow +27610abe5 Merge pull request #1452 from njhale/fix-image-build +f1c2eb3a2 chore(gh-actions): install conntrack before minikube +906b22a0a fix(docker): include util dir in upstream image build +42a64c175 test(gh-actions): add upstream image build test +783882c70 Merge pull request #1436 from awgreene/admission-webhoooks +68aafcc8a Added Github workflow for running e2e tests +478af2f24 OLM Support for Admission Webhooks +86057a491 Move APIService to installer +ceb8545f3 Merge pull request #1446 from njhale/kb-assets +84a82d3ae chore(docker): add kubebuilder to base image +5fb92c868 Merge pull request #1442 from dinhxuanvu/owners-component +0b3bcb1bc Merge pull request #1434 from exdx/feat/support-configmaps +edc57f3af feat: support configmap creation from the bundle +1cda8b82c Merge pull request #1444 from exdx/fix/fix-catalog-polling-test +3c024be07 fix: use busybox csv for polling e2e test +c7d109aa7 Add BugZilla component to OWNERS file +4f5b08c84 Doc: Remove legacy webhook proposal +1c49808fd Merge pull request #1418 from awgreene/apiservce-reorder +182566ed9 Merge pull request #1410 from benluddy/e2e-go +d35504c2f Create APIService after API server deployment +5c619adc6 test commit please ignore +1e50f968a Merge pull request #1419 from njhale/fix-codegen +6023448e0 chore(codegen): update to drop license year +68b1a703f chore(codegen): use controller-gen for deepcopy +f5ece8e07 chore(codegen): remove license year from boilerplate +91afbda97 Merge pull request #1350 from flickerfly/patch-1 +f0fee0b7d Merge pull request #1414 from njhale/fix-nilref +c4824d268 feat(catalogs): add spec validation for sourcetypes +6ee3f23a7 Merge pull request #1387 from dinhxuanvu/pkgm-csv +95a7bfcb2 Merge pull request #1408 from awgreene/reconcile-namespace-og +1b73afe38 fix(sub): prevent nil pointer access +0195afb06 Merge pull request #1411 from benluddy/clusterscoped-gc-tests +9d422bc25 Reconcile Namespace OG Labels in Namespace Syncer +2b2b1858d Update the code and test case +ef8614707 Add tests for GC assumptions. +7d8987a18 Update related images func and test case +338586617 make codegen for packagemanifest changes +0fc809408 Add more CSV information to the PackageManifest +4a2d1a014 Merge pull request #1370 from anik120/bump-k8s-1.17-rm-k/k +030e6841e Merge pull request #1224 from Jamstah/master +d9ac63c9a Merge pull request #1401 from ecordell/fix-bundle-install +64aabcb89 chore(apis): Regenerate API types for openapi3 specification +c418778b5 Merge pull request #1398 from awgreene/operatorgroup-labels +a5142bc73 chore(deploy): update manifests +ac0c454f0 fix(bundles): include csv name in installplan for bundle images +96a15cc02 Add OG label to namespaces in OperatorGroup +5ccb5f9d0 chore(deps): bump to kube 1.17.3 +f9473fee0 Merge pull request #1391 from benluddy/helm3-chart +c2e7151c9 Merge pull request #1372 from harishsurf/ginkgo-e2e +00568b748 Convert e2e go tests to ginkgo +d6d8f0531 Merge pull request #1388 from awgreene/test-2-apiservices +63848c351 Merge pull request #1389 from ecordell/remove-catsrc-memlim +ec04c310c Update chart to use the new "crds" directory. +86437faac Merge pull request #1381 from harishsurf/fix-typo +e043b38f0 Merge pull request #1390 from benluddy/og-conditions-flake +6ea521dba Ignore differences in CSV .status.conditions in unit tests. +6237dc399 Add e2e test for multiple APIServices on a pod +88b5b1ba1 fix(catsrc): remove limits on catalogsource pods +1ab6a9452 Fix typo in subscription.crd template file +06d852196 Merge pull request #1339 from awgreene/bug-1805412 +b1dce629c Rewrite +6e3932972 Merge pull request #1073 from javanthropus/add-security-context +9d236a8dd Merge pull request #1371 from ecordell/alert-sev +f81ec068c Merge pull request #1334 from umangachapagain/subs_config +8630695db Add updated manifests from make release +c499308f5 Optionally lock down package server runtime environment +33cc7da0d manifests(prometheus): failing operators should be a warning +dcb5971da Merge pull request #1313 from madorn/patch-2 +785ddd6d1 Merge pull request #1348 from benluddy/api-clusterrole-ownerrefs +8a0754125 Support multiple At PIServices on a single Deployment +528363f3f Make provided API ClusterRoles be owned by the corresponding API. +0b36b4b17 update examples for Subscription config features +e3ed855eb (test) update e2e test +aa94aa77e (feat) inject 'Tolerations' & 'Resources' from config +beb129520 Merge pull request #1353 from ecordell/jittery +d273283fa feat(jitter): add jitter to controllers to smooth out our spiky resource usage. +3d3422b97 PackageManifest isn't actually a CRD +f18f89376 Remove specific client tool names +73680b27d Merge pull request #1341 from njhale/fix-ip-orefs +8a820c936 Clarify roles and adds info about Package Server +403a33371 Merge pull request #1340 from simrandhaliw/update-subs-sync-total-metric +cf35327ec fix(installplan): crs are ownerreferenced to their resolving csv +4dcad6720 test(installplan): add cr ownerref unit testcase +b462e7ddb Bug 1809294: Update subscription_sync_count to include the package name +12a8b69bd Merge pull request #1337 from njhale/fix-run-local +ccd6755ee Merge pull request #1332 from benluddy/unbreak-minikube-script +f99d7e9fc fix(make): build cpb as prereq of e2e-local +72e50d5f3 Merge pull request #1316 from njhale/installplangen +b96cbc5ea Merge pull request #1301 from ecordell/depspec-hash +93e29bea8 Unbreak the minikube mode of build_local.sh. +92c7d1921 style(logs): mention generations instead of manifests for subs +0f2d1790a fix(subs): retry status update on conflict +9aa59eff6 Merge pull request #1308 from dinhxuanvu/remove-run-level +66fdeb024 Merge pull request #1322 from exdx/fix/duplicate-packages +b4dbade36 Merge pull request #1323 from benluddy/unblock-on-start-error +149a7c0b7 test(installplan): ensure single installplan per resolution +887102abb fix: use label selectors in package server List response for all namespaces if label selectors are provided +fe0fb1cc9 fix(deployment): remove separate operatorgroup annotation updater +a74c49f41 Merge pull request #1324 from benluddy/local-kind-detection +abacf871f Merge pull request #1319 from Bowenislandsong/stalebot +3e79ee5a8 fix(deployment): use deployment spec hash for determining if change is needed on cluster +0dad6c092 Fix kind detection for local builds. +2787f38ac Don't block on ctx.Done() if startup fails. +90b291a37 Fix TestUpdateCSVInPlace e2e test case +4bccd9087 fix(resolution): add generation to installplan +7d230384e Add stale bot +f77eb7018 Merge pull request #1314 from awgreene/olm-book-doc +b42cc1699 Update README to include OLM-Book +4ae604918 add link to olm-book definition of subscription +edf563cfd Merge pull request #1307 from madorn/patch-1 +1da145e91 Remove run-level 1 from olm and openshift-operators namespaces +e25a75c33 Update subscription-config.md +376197a97 Add some examples for Subscription config feature +5c5423670 Merge pull request #1300 from awgreene/bug-1798051-copy +cf72e5b4d Bug 1798051: Reinstate v1alpha2 operatorgroup +da45918d8 Merge pull request #1284 from dinhxuanvu/pkgm-fix +f23312756 Merge pull request #1252 from njhale/fix-bundle-extract +112de3e2e Merge pull request #1278 from kevinrizza/version-0.14.2 +40fa07a45 feat(util): add cpb command +a60a41166 Merge pull request #1257 from exdx/fix/polling-e2e-test-registry +f56148540 Merge pull request #1282 from dmesser/readme-update +1803e5a4c fix: update e2e test to use internal docker registry and openshift registry. removes quay credentials. +23631fba1 fix(packagemanifests): Fix index key func to avoid key collision +ad0638098 mention OLMs features in the introduction +4202372e0 fix(bundles): execute opm from tooling container +4fb7859fe Merge pull request #1277 from benluddy/fix-ready-not-closed +fdcc6ecb7 Fix cases where an operator's ready channel may never close. +ab96e3061 Bump version to 0.14.2 +4c2d221f3 Merge pull request #1268 from kramvan1/fix-1238-configmap-probes +2a0f757b9 Merge pull request #1276 from exdx/fix/update-robot-creds +861c4c56e fix: update existing robot credentials +172b16f38 Merge pull request #1274 from Bowenislandsong/Makefile +6722fc968 refactor rh-operator test directory +662564c78 Merge pull request #1261 from njhale/update-owners +e285a00a8 Merge pull request #1265 from benluddy/manifests-for-0.14.1 +c9a31cea1 Merge pull request #1266 from benluddy/changelog-0.14.1 +26f3fd842 Merge pull request #1267 from ecordell/fix-bad-opgroup-annotations +c049549c5 Merge pull request #1171 from exdx/bug-1777144 +8752b897e BUG 1238: Fix configmap registry server readiness probe timeouts +6ec6514d6 fix(gc): clean up copied csvs that have incorrect operatorgroups +368caf0cb test(e2e): add test to reproduce bug where copied csvs with annotations +7f9657813 Generate changelog for 0.14.0 and 0.14.1. +2c8af04ec Generate manifests for version 0.14.1. +aedaf153f Merge pull request #1264 from benluddy/version-0.14.1 +e3c18253f fix(operatorgroup): don't overwrite operatorgroup annotations on copied +121fb85ed test(ci): add failing test assertion showing that operatorgroup annotations on copied csvs will get overwritten to the wrong thing +11945b37a Bump version to 0.14.1. +43dd62290 Merge pull request #1258 from benluddy/revendor-registry +5d3e7e771 chore(ci): update owners +ae082363c Update operator-registry dependency to v1.5.8. +c6ad718fe Merge pull request #1250 from benluddy/fix-release-gitignore-pattern +04a07526a Merge pull request #1253 from awgreene/dynamic-client +0b24bdb1d Fix overly broad .gitignore pattern that was excluding a vendored package. +184e1e1c4 Add support for Prometheus Custom Resources +20c1033be Merge pull request #1248 from benluddy/version-bump-0.14.0 +4123504a4 Bump version to 0.14.0. +6c7320ce2 Merge pull request #1247 from benluddy/vendor-helm +2d252327b Vendor helm, since it is used for templating manifests. +a135d9d9a Merge pull request #1233 from Bowenislandsong/e2e_metric +1a1940514 adding e2e test framework for rh-operator metrics +6858f165b Merge pull request #1231 from benluddy/e2e-test-ipv6 +ce7b927af Merge pull request #1228 from benluddy/helm-template-v3 +bb30b1ddc Change to using a hash instead of ordering +a81253d9b Addresses the bug where updating the packageserver fails with a unable to adopt APIService status message. This is a result of ownership mismatches between the packageserver (owner) and the APIService (the owned object). This can be resolved by setting the actual k8s owner references or the label-based references that OLM uses. This commit ensures that ownership references for the APIService are cleaned up on OLM restart and that the olm.owner:packageserver label is set on the corresponding APIService object. +aa7a49034 Merge pull request #1235 from robszumski/update-proposal +92dde5519 Merge pull request #1219 from ecordell/test-ci +193ba4980 update internal objects proposal +2d442b3a8 Merge pull request #1229 from benluddy/release-doc-prereqs +44ebf7c7b Merge pull request #1232 from exdx/fix/doc +ca965a2d9 fix: typo in catalog polling doc +af11ce01a Merge pull request #1220 from ecordell/packagserver-labels +ebcc695f8 Fix IPv6 incompatibility in TestGrpcAddressCatalogSource. +13772ff2a feat(packagemanifest): add default os/arch labels if not present +e6d0273bc Merge pull request #1226 from exdx/fix/catalog-polling-spec +2653e086e Remove pyjq and yq from the release documentation prereqs. +ad3d9140d Update release script to require version 3 of helm. +ce31edd6c Merge pull request #1097 from robszumski/proposal-internal-image +285b9ca05 Merge pull request #1225 from benluddy/manifest-templates +f7ba83ccf fix: refactor catalog polling spec to use more general update strategy field +042d7fa19 Reconcile manifests with templates. +3217fd46c Add alm-examples-metadata +cdd04e244 Merge pull request #1215 from njhale/unpack-bundles +302ae173e test(e2e): fix subscription update flake by retrying +d8d902573 docs(design): add bundle image unpack design +bead4ccab refactor(resolve): simplify bundle lookups +7f339d092 fix(catalog): add ownerreferences for bundle image resources +c01fa467c fix(e2e): remove local dev test registry image +f7ab7e3eb fix(e2e): remove local dev test image +1df508a4c test(e2e): add test for bundle image +3396ed2b5 chore(fakes): make mockgen +15a5147f7 chore(codegen): make codegen +2aadb869f feat(bundleimage): resolve bundle images +40cb8ccab feat(catalog): make install possible from bundle image +47697f399 chore(vendor): get latest operator-registry +a99cf0776 Merge pull request #1161 from exdx/feat/catalog-polling +7978bb9cd chore(build): only enable cgo for ci/prod builds +c5f2e9758 Revert "feat(packageserver): support label queries and copy CSV labels onto the packagemanifest" +88d76135d feat(packageserver): support label queries and copy CSV labels onto the packagemanifest +d5917a5ea feat(packageserver): support label queries and copy CSV labels onto the packagemanifest +a241df47b feat: add polling doc +ac4864ca3 fix: update Poll to be pointer +ca65ac3af Merge pull request #1217 from benluddy/vendored-yq +099921692 feat: implementation of catalog polling feature with e2e test +6cdf06d3f Use vendored transitive dependencies for "go run" of vendored yq. +62691f243 Merge pull request #1216 from jianzhangbjz/kuryr +dcd4db1f2 Enable CGO and CGO_DEBUG +a7fb3e9a8 Merge pull request #1212 from ecordell/ci-base +2cb787f4a chore(codegen): update generated code for 2020 +43458956b chore(ci): add dockerfile as a base for building in CI +1a21520e6 Merge pull request #1173 from beautytiger/dev-191205-errcheck +d6e406f9b Merge pull request #1154 from Intermax-Cloudsourcing/fix-run-console +61f1b24ed Merge pull request #1105 from ecordell/trust-grpc +2c0e34f4b Merge pull request #1185 from clyang82/br_olm_versions +db14fd512 Merge pull request #1207 from ecordell/remove-limits +45b0907cb test(e2e): testing CRD upgrades shouldn't create a new subscription +3f3bd125a feat(resolver): rely on info from catalog to determine updates +02b289dd4 fix(deploy): remove resource limits +fb4548dda Merge pull request #1202 from njhale/cleanup-codegen +47c7e969b chore(vendor): update +db5bad726 chore(codgen): regenerate code, mocks, and openapi +17b39d0a0 refactor(pkgsvr): remove apps group +04d2c823d chore(codegen): clean up codegen make rules and scripts +0cab798bc chore(ci): remove old gitlab ci config +46aa2a5bf Merge pull request #1152 from njhale/design-goals +0cae336db Merge pull request #1194 from ecordell/csv-fallback +8e4880401 Merge pull request #1157 from awgreene/prune-unknown-fields +f6767bb59 feat(resolver): fallback to csv parsing if grcp api does not contain the information required +41c8c8d2e Merge pull request #1192 from gyliu513/etcd +330999145 Corrected etcd CRD URL. +b69a18fee Merge pull request #1163 from gyliu513/high-light-yaml +05124913e Merge pull request #1176 from jmccormick2001/doc-bundle-breadcrumb +75f4ff122 Merge pull request #1187 from gyliu513/dep +a948f986c Dep is not required. +57e76cac2 Add note for version field +d8c26fd45 docs(design): add general design goals +bdc3e72e2 Update manifest CRDs +b1d4c8712 Implement controller-gen +1d74e7d4e Update CRD go types +ce298fcab Merge pull request #1150 from njhale/spur-pkgsvr +4ba847801 chore(git): remove and ignore packageserver test key pair +bb936402e chore(modules): vendor deps +f69ddb6dd fix(packageserver): cache packagemanifests +8d5a38c18 Merge pull request #1175 from awgreene/test +e9ab0d60b Fix CI unit tests +d6b393db9 add a mention of bundles to the README to help users find bundle information +b697bbb17 fix: add err check before further operation +b9541d4f6 Merge pull request #1125 from dinhxuanvu/sync-improve +5fef82d31 Change index func to return list of ns instead +20a473cac Added `keywords` in operator metadata. +3316e73ef Merge pull request #1151 from jpeeler/cert-rotation +e2136b71f Merge pull request #1123 from Bowenislandsong/bugfix_dup_secrets +baef6f536 Fix updateInternalCatalog namespace bug +f8a759c74 Add e2e test case for syncSourceState +10e929350 Enable multiple namespaces sync if catsrc is updated in global ns +4cf347298 Bug 1769030 Replacing (updating) operator creates duplicate secrets for the operator's ServiceAccount +5435cfaf3 feat: make run_console_local.sh sh compatible +0792b0f52 fix: make run_console_local.sh working on WSLv1 +e9e8f4985 bug(metrics): serve metrics using new certs when replaced +d78b41f18 feat(filemonitor): add new filemonitor package +0645ebeb6 chore(modules): add fsnotify +1a95d31ce Merge pull request #1147 from dinhxuanvu/unit-fix +13860d5d9 Merge pull request #1142 from Denton24646/bug-1760608-resource-limits +1138f3510 Fix minor namespace bug with NewFakeOperator +a0301923f Update k8s version for local cluster (1.16.2) +70e8c2159 fix: double limits +b17f500f9 fix: double packge server limits for CI +e1574e34c feat: add resource limits to all OLM pods for OLM releases on OCP above 0.13.0 +3d9b0c6ab Merge pull request #1116 from Denton24646/fix/catalogsource-context-leak +49bb20259 Merge pull request #1137 from gallettilance/release-docs +eedfb5100 Merge pull request #1132 from Denton24646/fix/operatorhub-catalog-windows-vm-scheduling-bug +9e0318d85 fix: simplify test by removing additional map +570808327 feat: add test to confirm node selector behavior +40d868a9c fix: add NodeSelector to catalogsource pod spec +e24ca3a33 Merge pull request #1135 from gallettilance/release-changelog +57a200dbb Merge pull request #1134 from gallettilance/make-new-release +c5f7ee9bf [release] updating changelog +3c7f94379 [docs] update changelog command +6bd05fba8 Merge pull request #1114 from jpeeler/fix-status-invalid-csv +665319353 [release] - making new release +ea140d7be Merge pull request #1130 from gallettilance/version-bump +5ce35a378 Merge pull request #1131 from gallettilance/new-release +c2fa1a492 [docs] - update release docs +e531d001c [release] - version bump +a0d1ea445 fix: defer RUnlock in AsClients +18c15a386 fix: use defer cancel to cancel context waiting for state changes +cbcf7796a Merge pull request #1115 from bandrade/subscription-config-doc-adjust +24653792d Fixing doc typo +9527d7d9e fix(olm): defer provided api update in operator groups +f510cc902 Merge pull request #1096 from beautytiger/dev-191029-tfatal +21e57eefe Merge pull request #1111 from dinhxuanvu/fix-flaky-e2e +25ddd845a Fix flaky subscription e2e test case +07af0d106 Fix several flaky e2e test cases +3b41a4dc4 Merge pull request #1104 from anik120/add-promethues-rule +8bec5a0af Alerts for failing OLM operators +e1a383faa Delete file that was renamed +6085eb699 Merge pull request #1100 from awgreene/increase-cardinality-on-csv-metrics +417a973f4 Swap annotation namespace +1d463935e feat(metrics) Report subscription channel +c53417f2f Merge pull request #1101 from ecordell/resolver-required-apis +2dc06d2ac feat(resolver): use provided and required apis from grpc instead of calculating from the csv +c6f1304b8 Merge pull request #1099 from awgreene/limit-cardinality-on-csv-metrics +3674abbbd Use the correct title +7c814f265 Ammend proposal to include data CRDs and new annotation names. +a35c3b29c feat(metrics) Limit Cardinality of CSV metrics +5b4afbb7d Merge pull request #1095 from gyliu513/update-operators +def5f2e48 Merge pull request #1094 from dinhxuanvu/minkube-status-fix +d41cd0bb9 Add unit test for minKubeVersionStatus +009151be1 Merge pull request #1089 from gyliu513/customize +6730f38b6 doc: add internal image proposal +f0a3566fc fix: t.Fatal should be used in main goroutine +ccda1d25a docs: Corrected CSV upgrade version. +46f72fbe6 Merge pull request #1092 from Denton24646/fix/docs-fixup +40cc6459a fix(olm): No longer report status if minKubeVersion not specified +7ef66b823 fix: refresh architecture and philosophy +b6208c864 Updated values.yaml location. +d45959783 Merge pull request #1085 from operator-framework/ecordell-fix-logs +129997451 Merge pull request #1086 from Denton24646/fix/csv-documentation-typo +0fcaa0d0d fix: fix particular typo in clusterserviceversion_types.go +5f42cdfe8 Update resolver.go +6939b516e Fix log message in resolver +97d9c7a75 Merge pull request #1083 from sbose78/patch-1 +bcd443dbd URL with modified manifest directory structure +5d3831f7f Merge pull request #1080 from awgreene/initialSource +c1d2699d5 Merge pull request #1078 from awgreene/update-package-table +2810eaa13 Merge pull request #1071 from beautytiger/dev-191011-nilmap +99c780af6 Merge pull request #1054 from tkashem/proposal +ba5a9d197 bug(dependencies) Prioritize APIs from same CatSrc +930279b29 Merge pull request #1079 from alecmerdler/remove-alecmerdler-owners +c0fa43829 Merge pull request #1069 from ecordell/relatedimages-proposal +8a0e2f31d update OWNERS +1e5e2e957 Update PackageManfiest table handler +70e41728a Merge pull request #1059 from dinhxuanvu/installplan-approval +cde129861 Merge pull request #1058 from awgreene/sub-config +0dc42b12d Merge pull request #1067 from operator-framework/apk-up-1 +420a2847a bugfix: assignment to nil map will cause panic +560325a59 Fix InstallPlan stale variable issue +fc6f6233d Add e2e test case +0843f7499 proposal(relatedimages): combine the two previous proposals +80aadbd2c proposal(relatedImages): update related images proposal to use kustomize +816662558 proposal(relatedImages): add a proposal for specifying related images in CSVs +02355a625 Add document for SubscriptionConfig +5942fea8d feat(subscription) Config Volume and VolumeMounts +29e1854e4 Rename envVar package to overrides +7d2db3312 Add `apk upgrade` to upstream builder +b77cc4ace Merge pull request #1065 from spadgett/fix-console-link +652bc5c63 Fix links to console repo for moved packages +14d6f0798 Merge pull request #1062 from awgreene/fix-install-script +1ccd84303 bug(install) Fix packageserver name in install.sh +807db4999 Bug 1758008: Manual approval strategy ignored for subsequent releases +b30729903 (proposal): add bundle image deployment text +7a004cf12 Merge pull request #1055 from awgreene/csv-health-metrics +3b86f8648 feat(metrics) record CSV sync events +2ef3ef37c Merge pull request #1056 from awgreene/make-e2e-bug +59c8596b9 Bug: Fix olm chart +05f703022 (proposal) Make bundle accessible to a cluster +f0bfbb67a Merge pull request #1052 from njhale/bump-openshift-client-go-version +7a898691c chore(modules): update vendor dir +cac3406a7 chore(modules): bump openshift/client-go pseudoversion +45bdb14d9 Merge pull request #1051 from awgreene/changelog +f3a42bec6 Merge pull request #1048 from ecordell/k8s-1.16 +cef67da2c Merge pull request #994 from njhale/shell-lib +b54586244 Merge pull request #996 from njhale/fix-tags +21e0b2277 Merge pull request #995 from njhale/refactor-opstatus +8daaa439f (release) Update changelog +e3dd1540e Merge pull request #1050 from awgreene/manifest-0.12.0 +39d24fd50 (release) Generate manifests for 0.12.0 +e58e3d43d Merge pull request #1046 from awgreene/release-0.12.0 +1f979f072 chore(deps): bump to kube 1.16 +370e31ec1 Merge pull request #1047 from awgreene/docs +74295d326 (docs) Update release.md documentation +a89680d52 (release) cut a release for 0.12.0 +c5c9efabb Update PULL_REQUEST_TEMPLATE.md +f995cc631 Update PULL_REQUEST_TEMPLATE.md +2dfa925b2 Update PULL_REQUEST_TEMPLATE.md +79a92fbb1 Merge pull request #988 from dinhxuanvu/update-csv +b5f0f797c Merge pull request #1039 from jpeeler/bug1749036 +160f52e26 (doc) How to update operators documentation +03d4e769a test(e2e): add operator group SA permission tests +17c04dc5a fix(olm): requeue as needed upon permission changes +fed600926 fix(olm): handle CSV install failure gracefully +0cbd28c9b Merge pull request #1038 from skitt/go-1.1x +17bb059cc Enable vendoring on Go 1.1x +2595af7f0 Merge pull request #1027 from ecordell/depup +d82e71cd9 feat(olm): don't calculate a patch when updating via a replacement chain +bb6413343 Merge pull request #983 from dinhxuanvu/removeDeprecated +9c295523d Merge pull request #984 from dinhxuanvu/crd-update-docs +07ea73c61 Merge pull request #1033 from njhale/fix-docs +54923da18 chore(docs): consolidate doc directories +dd81460e4 (doc) Add deprecated CRD version procedure and note +3fb49bb14 Merge pull request #1031 from dimitraz/fix-links +a92826603 Fix broken doc links +7fb132565 Add unit and e2e test cases for deprecating a CRD version +987952733 Merge pull request #1029 from njhale/fix-pkg-list +089c7c915 Merge pull request #992 from camilamacedo86/fix-doc +c05682e09 Merge pull request #991 from camilamacedo86/github-templates +a9b2fa632 fix name of dir - replace Documentation for doc +816ff27e2 Merge pull request #993 from camilamacedo86/README +9ef425419 Merge pull request #1019 from skitt/dns-suffix +fc77d31a1 fix(registry): return all valid packages +6c2cb4840 chore(mocks): generate mock list packages client +6a5fd922a Merge pull request #1026 from alecmerdler/bugzilla-1748771 +f934999cf Merge pull request #1018 from jpeeler/add-fields-related-objects-2 +b176583bf fix(clusteroperator): update status after initial creation +77cce5479 fix(clusteroperator): fix naming of related objects +85bfc4312 add default for packagemanifests/icon subresource +4b9969934 Merge pull request #1023 from tkashem/bz-1744245 +f79647bfb Merge pull request #1025 from njhale/clean-env +e64f62286 fix(init): cleanup leftover cross-namespace ownerreferences +79143ac99 feat(readme) : Ajustments +bfefa59e5 feat(github) : Add github files in order to follow org standard +0141a890d Bugzilla 1744245: Subscription should not point to deleted ip +109153ae7 Drop the hard-coded DNS suffix +0cd00dd5a Merge pull request #1011 from skitt/pgrep-no-q +72b6a8d5e Remove deprecated CRD's stored versions to allow CRD update +fe8dff2a9 Merge pull request #1014 from awgreene/configure-global-catalog-ns +37467b317 feat(clusteroperator): plumb additional clients +34a934f79 [CatalogSource] Set Global Catalog NS with EnvVar +f67454030 Merge pull request #1013 from kevinrizza/bug-1741799 +86810199f Remove InstallPlan Source, SourceNamespace from UX +da3c9fcd0 Merge pull request #1012 from jpeeler/add-fields-related-objects +83341f520 fix(olm): report name and group for related objects +be15bd5cb Stop relying on pgrep -q +fd42877ef Merge pull request #989 from ecordell/packageserver-upgradeable +5174ca8c6 Merge pull request #978 from tkashem/bz-1737057 +7b850f99c Merge pull request #1008 from ecordell/grpc-update +19dfe701a Merge pull request #1006 from tkashem/bz-1740332 +5edeb9c0e feat(sources): syncronize access to lastupdatetime for sources +73fdcf346 chore(deps): update grpc dependency +1c75ca4c8 Bug 1740332: OLM should resume operator install +9cb7d109d Merge pull request #1005 from alecmerdler/bugzilla-1744490 +ae365b171 Merge pull request #1002 from alecmerdler/bugzilla-1727800 +dc39aeaab add packagemanifests/icon to aggregated OLM RBAC roles +2445a1902 Merge pull request #998 from ecordell/update-perms +335bb6c01 Merge pull request #980 from dinhxuanvu/display-catalog +b4d5adf5d Merge pull request #973 from dinhxuanvu/crd-versions-fix +64ab35654 Merge pull request #970 from jpeeler/cleanup-roles-sa +4a4ae9c85 Merge pull request #939 from tkashem/csv-reporting +543a27d08 Merge pull request #924 from galletti94/master +f489d8cd9 feat(operatorstatus): report packageserver as upgradeable +200084864 test(e2e): add test verifying permissions are updated during an operator upgrade +3ea223264 Bugzilla 1737057: Sub CRD does not validate config +daba5228a Merge pull request #1001 from tkashem/fix-missing-ip +73d5df35f filter icon fields from PackageManifest object (use packagemanifests/icon subresource instead) +73e74d015 Bug 1744245: recreate of sub should not fail install +6a81f7f0a Merge pull request #990 from alecmerdler/OLM-1211 +e1ade4bb0 packagemanifests/icon subresource +5b4a0053f fix(spelling): just a comment correction +1a0325a02 fix(olm): clean up resources on CSV deletion +cf4349220 fix(subscriptionconfig): add missing merge struct tags +ce42d8bac refactor(operatorstatus): make monitor constructor variadic +9bd7065bf feat(scripts): add shell lib with some common helper funcs +0b60b8ee7 test(e2e): ensure resources are deleted after CSV delete +d885cf2ad Merge pull request #985 from alecmerdler/OLM-1211-proposal +5209579a0 Merge pull request #974 from tkashem/catsrc-status +987609830 Bug 1737081: catsrc status should show error +beda2d82d Merge pull request #987 from jpeeler/local-ns-rename +3b10b4189 Bug 1732914: Operator upgrades fail when versions field is not set +a6605bd75 fix(deploy): change local deploy to use olm namespace +75d7ad1fe add proposal for 'packagemanifests/logo' subresource +7281b9125 test(grpc): add basic connection event tests for source manager +f9ae16b49 feat(grpc): adds grpc source manager which notifies main controller when grpc events occur. +c485cad60 Merge pull request #960 from dinhxuanvu/relatedobjects +4dba884c8 Bug 1702552: Two "NAME" fields by command "oc get catalogsource" +3c06e88e9 Merge pull request #969 from tkashem/doc +9c683f5ae Merge pull request #968 from tkashem/release-doc +6bd80c98b bug(1717636): Add relatedObjects to cluster operator status +4edaafada Merge pull request #971 from kevinrizza/report-upgradeable-clusteroperator +c8bfa53a4 Merge pull request #965 from jpeeler/existing-installplan +e781b89fb (doc) add doc for scoped operator install +98c23f6ea Report `Upgradeable` in ClusterOperator status +974bf5509 Merge pull request #967 from tkashem/changelog +f77932cef (doc) update make new release doc +67d15b445 (release) update changelog +5b7433362 Merge pull request #966 from tkashem/release-0.11.0 +be4c7f2c9 Merge pull request #961 from tkashem/bz-662263 +8fa586d30 fix(unit): allow logrus log level to be adjusted +695f6d776 fix(catalog): re-install resources in existing installplan +6e109b4ea Merge pull request #958 from tkashem/follow-up +8f85cafc3 (release) generate manifests for 0.11.0 +27b5042b7 (e2e) fix e2e test flakes +202406f45 (feat) requeue the csv when subscription changes +360f75b35 Rename and remove commented code +c5564e7cd Merge pull request #962 from tkashem/release +3e65dc786 (feat) empty proxy env var should result in unset +484b866ca Merge pull request #959 from cblecker/label-panic +db884e743 (release) cut a release for 0.11.0 +25e399052 bz-1662263: include git sha in ART builds +ca02a92b2 Fix panic when binding already exists +497b67c66 Merge pull request #955 from jpeeler/set-resource-requests +76a3554ed Merge pull request #957 from ecordell/fix-env +1ab0d8b96 Merge pull request #950 from tkashem/pod-configuration +c613ffc1b Merge pull request #933 from dinhxuanvu/cr-validation +c0e4f825e Add e2e test case for existing CR validation +8a48e657f Validate existing Custom Resources against new schema prior updating +34f07ed3b (test) add e2e test +74e6e3059 (feat) inject 'Env' from config to deployment spec +3c56773db (feat) incorporate proxy configuration support +b52e789a7 add operator configuration to subscription spec +d4d3428b0 Merge pull request #954 from njhale/pin-1.14 +a2f47f1d6 fix(unit): refactor to use shared pod resource +77ce42156 fix(manifest): fix env var projection in command +1cad4c865 feat(deploy): add resource requests to all pods +e176196fc Merge pull request #951 from ecordell/metrics +2808ec7e6 chore(modules): re-vendor +a359bf757 chore(generated): run code/mockgen +7aaa69e45 chore(modules): pin k8s 1.14 +cd6fb9a51 feat(metrics): record sync count for subscriptions, labeled with name and most recently installed CSV version +b4e3f5de2 Merge pull request #2 from dweepgogia/project-proposal +64b09c24f [doc] Add fake README to the project proposal +d4825c74b Merge pull request #942 from ecordell/csv-packageserver +c1ea748d2 fix(init): move cleanup to olm startup +fecaec053 feat(metrics): record sync count for CSVs, labeled with name and phase +b4f8827e9 feat(init): add init container to olm operator that can clean previous deployments +6065197ee chore(deploy): remove packageserver subscription and catalog from chart +f226d7255 Merge pull request #902 from jpeeler/crd-schema-change +a116896c9 Merge pull request #943 from njhale/catalog-benchmarks +767b0fd70 Merge pull request #945 from jpeeler/minor-fixes +7f8c31725 fix(olm): List does not return NotFound error +477b0affa fix(e2e): fix baremetal e2e +7a38a5d04 Merge pull request #941 from ecordell/config-proposal +71c15a6fb test(catalog): add sync resolving namespace benchmark +752740f21 Merge pull request #931 from operator-framework/depupdate +4c60d4c64 feat(olm): allow CRD updates with multiple owners +861fa27bd feat(csv): detect changes to a deployment and persist them +55478901a proposal(operator-config): initial proposal for persisting configuration of operators +1940f7bd0 Operator validation library project proposal +30d6fa5e6 Merge pull request #929 from njhale/pprof-option +11687df4c Merge pull request #938 from njhale/remove-extra-comparison +cf83a2842 Merge pull request #913 from jpeeler/proposal-webhooks +2b551453a (proposal) improved csv status reporting +58378e8af test(e2e): remove extra resource comparison +7cbf34848 Merge pull request #937 from tkashem/bz-1723818 +0c5c34bc9 1723818: package server 4.1 to 4.2 upgrade should not fail +c236361d2 Merge pull request #921 from jpeeler/compile-bare-target +f058be7b3 Merge pull request #925 from tkashem/bz-1723818 +9c7f7d278 (bug) CSV name change causes upgrade to fail +79684d6bb Merge pull request #892 from tkashem/user-defined-sa +d9043cfc1 Add webhook proposal +224ada1dd docs(profiling): add basic usage doc +00826e8e1 feat(cmd): add profiling option to olm and catalog commands +3a7164c7a feat(profiling): add pprof handler registration function for mux servers +752da4774 Merge pull request #928 from paulfantom/servicemonitor +6458351fc manifests: move ServiceMonitor manifest to runlevel 90 so it will be applied after ServiceMonitor CRD is created +3ac82ee37 (e2e) add e2e test for user defined service account +47260e13d (feat) validate that secret is valid api token +3fb4bb161 (feat) use scoped client for plan execution +7eb33d819 Merge pull request #923 from njhale/sub-ips +a532d6c85 chore(logging): logging fixes / small enhancements +53c918399 chore(modules): add hashstructure and revendor +7d238a85e test(sub): add subscription installplan condition e2e test +521979f76 feat(sub): add installplan reconciler to syncer +593589aab feat(sub): add installplan status reconciler +65593bd22 feat(state): add subscription installplan states +6305b1324 feat(sub): add subscription installplan status conditions +f16d8f0c9 feat(equalitor): add equalitor interface and hash implementation +465214e5c (feat) create scoped client from bearer token +f436600b1 (codegen) generate operator group type changes +71b4951ac Merge pull request #863 from tkashem/csv-monitoring +72d20ecf5 Merge pull request #920 from jpeeler/does-anybody-ever-read-these +5f5f2eda6 feat(makefile): add target for compiling e2e +14d62744f Merge pull request #878 from dinhxuanvu/update-crd-one +729de7a54 fix(test): fixup bare test imports and vars +54441a84f Merge pull request #917 from dinhxuanvu/update-changelog-0.10.1 +1b14b82fc Update CHANGELOG to include changelogs from 0.10.0 and 0.10.1 +e4ecf57fb Merge pull request #916 from jpeeler/release-docs-2 +73b071c57 (feat) monitor package API server CSV progress +75590ea49 Receive notification of CSV(s) being watched +b4b70b918 (deploy) add cluster operator for package server +d89e8353f Merge pull request #918 from jpeeler/fix-go-build +da97549ac fix(build): set GO111MODULE=on +bec3a473f docs(release): add additional clarifying details +eb110c940 Merge pull request #914 from ecordell/go-1.11 +5a9c3ca03 Merge pull request #889 from dinhxuanvu/release-0.10.1 +100a23bb8 Switch to go 1.12 in the root Dockerfile +a486f5aba Add a new test case to cover preexisting CRD case +0e806f146 fix(unit): fix unit test flake +90229baa4 Merge pull request #912 from ecordell/remove-helm +c6905c3e1 Add e2e test case for single owner CRD update +9a16d4a92 Add IndexFunc using ProvidedAPIs as key to look up CSVs +86faf88b0 Enable OLM to update CRD when there is only one owner of that CRD +d523fb5c3 make release 0.10.1 +33a13e5fe Merge pull request #900 from ecordell/fix-owner +5ee8bce5b Merge pull request #910 from jpeeler/crd-descriptions-3 +3fe51df5f Merge pull request #911 from njhale/sub-csh +b62dc0a67 fix(build): don't use helm in src image +bf05d0477 feat(queueinformer): add config options +f09e47ad0 fix(chart): add missing descriptions to operator group +579aa8ddd fix(catalog): do not add owner references to clusterroles or crbs +d8084e48c Merge pull request #881 from njhale/sub-csh +f8a5ca06a Merge pull request #909 from jpeeler/kubeconfig-env +b2c649bae feat(e2e): allow KUBECONFIG to be set from env +8be3ad854 Merge pull request #907 from madorn/patch-5 +bb4c35aa7 add -l option to $POD_MANAGER attach +83fd61813 test(subscription): add e2e tests for catalog health +aa6c82b93 test(bare): use new operator constructors +cc58cc72e chore(codegen): generate conversions/deepcopy +8892cd38d feat(subscriptions): add catalog health conditions +162483988 refactor(packageserver): plumb context throughout +3707deed5 refactor(main): use signal context and new operator contructors +ca20e6350 refactor(olm-operator): replace factory method parameters with options +49fc05754 refactor(catalog-operator): use new queueinformers +25e078a77 feat(subscriptions): add subscription catalog health syncer +7f2bcbc5a feat(registryreconciler): add now function +9cdccba5a refactor(operatorstatus): make sync channel receive-only +2e4bc7f77 refactor(queueinformer): use kubestate resource events +55295262c feat(kubestate): add generic typestates and interfaces +10ae9f8f0 refactor(signals): replace stop channel with signal context +2d43a3749 Merge pull request #904 from alecmerdler/OLM-1111 +fc4a5ea62 clone labels from CatalogSource to PackageManifest to prevent concurrent map writes +485474201 Merge pull request #880 from tkashem/operator-group-sa +248c669be (proposal) Add user defined service account +e68056973 Merge pull request #890 from alecmerdler/OLM-1080-redux +6269a6792 Merge pull request #885 from madorn/patch-4 +619c2035b change packageserver global namespace to openshift-marketplace +4acee7fbf Merge pull request #887 from dinhxuanvu/release-version-0.10.1 +2db8ef0d3 Bump release version to 0.10.1 +4f147c4bc Merge pull request #871 from alecmerdler/OLM-1080 +84ad7ab88 Merge pull request #864 from ecordell/1.14 +2df701059 add --rm, remove cleanup func, and attach to block +2b167dd5e chore(deps): bump kube deps to 1.14 +c4d210a71 repair run_console_run.sh script +74dfdf377 change global catalog namespace to openshift-marketplace +a4b8ea757 Merge pull request #875 from ecordell/installer +2ee6f96af Merge pull request #876 from marcoderama/doco +c05651951 Merge pull request #877 from njhale/internal-types +02ec025a2 chore(types): codegen internal convs, clients, listers, and informers +74aa5da51 refactor(codegen): add conversion to make rule +513db51ae refactor(types): add internal types for olm resources +97ad48e5c Documentation: Fix a few typos +a16cf0f6e feat(install): Add new install scripts for releases, update release instructions. +1c16bd4b5 Merge pull request #869 from dinhxuanvu/opgroup-status-ns +b9de76ad7 fix(operatorgroup): Remove namespaces requirement for opgroup status +1aa1059df Merge pull request #867 from jpeeler/release-docs +712241bb0 Merge pull request #861 from ecordell/grpc-close +f57626747 Merge pull request #866 from jpeeler/manifests-bump-0.10.0 +0cac27e56 docs(release): add basic steps for making release +8bcd68729 update manifests to 0.10.0 +775721557 Merge pull request #865 from jpeeler/version-bump-0.10.0 +7fdeba2a2 bump version to 0.10.0 +393ec5613 Merge pull request #754 from alecmerdler/OLM-954 +4d650f944 Merge pull request #860 from tkashem/refactor +5e2b3d8ab fix(catalog): close grpc connections before deleting them +a29307be8 (refactor) Move csv set and replace to a package +ef08dc726 Merge pull request #750 from jpeeler/apiservice-sync +7e04af578 Merge pull request #837 from jpeeler/unit-flake-fix +26af2e8cd Merge pull request #856 from ecordell/adming-ag-test +20c1d0760 add provided APIs to PackageManifest +c0f804775 Merge pull request #795 from alecmerdler/OLM-974 +df7c96c56 fix(unit): fix flake in TestUpdate +c16b50b28 fix(unit): operator group test flakes +4562dc0a8 fix(olm): unit test flakes +043d9a059 feat(unit): allow specific unit test execution +7ca42e8c5 added e2e test for garbage collecting ClusterRoles +3c911f062 Merge pull request #859 from dinhxuanvu/util-test +e5b27ae45 Merge pull request #851 from dinhxuanvu/op-ns +ad50da316 Merge pull request #852 from ecordell/fix-release-scripts +290a2b95b fix(unit): Remove leftover println causing excessive log in unit test +45ce08c51 fix(operatorgroup): No targetNamespaces matched namespace selector +235928b97 Merge pull request #839 from dinhxuanvu/catalogSourceNS +734031b1a test(olm): test role aggregation for aggregate apiservices +acda68d68 Merge pull request #858 from camilamacedo86/ISSUE_785 +458ebf0b1 fix(run_console_loca): Fix command and improve output message +3d61dac26 chore(deploy): install helm in `src` image so that verify manifests job can run +9cd805b5a chore(deploy): re-sync manifests with the chart +e3e248a60 chore(deploy): add `verify-manifests` command to ensure chart and manifests are synced +a52e043e4 chore(deploy): fix release scripts +2cc4af52a Merge pull request #821 from tlwu2013/patch-2 +ae27eea1f fix(catalog): Fix subscriptions without a sourceNamespace hang forever +e900058b7 Merge pull request #855 from ecordell/fix-testupdate-flake +414aa3be2 Merge pull request #806 from marcoderama/doco +9bdf1de7b Merge pull request #751 from lveyde/patch-1 +6184c4682 Merge pull request #768 from leszko/support-windows +6804a283a fix(unit): TestUpdate no longer flakes +d0e13ea7b Merge pull request #787 from bergerhoffer/fixing-indentation +01b28833b Merge pull request #848 from jpeeler/crd-descriptions-2 +5a9c4e370 Merge pull request #850 from ravisantoshgudimetla/fix-tolerations +3d549003c Fix tolerations +ac3a5d268 fix olm-operators tolerations +4a4d4b4fd Merge pull request #847 from ecordell/fix-stuck-subscriptions +c369b8040 Merge pull request #844 from alecmerdler/bugzilla-1707071 +23a2a2f70 fix(deploy): add missing descriptions to manifests +fd2f765e8 Merge pull request #845 from jpeeler/crd-descriptions +c5173bf50 Merge pull request #843 from ravisantoshgudimetla/fix-tolerations +3db37f805 fix(catalog): fix issue where subscriptions sometimes get "stuck" +f5ed53df4 fix(deploy): add missing descriptions +9679a7b1a Fix tolerations +0d7cb55c3 add terminationMessagePolicy: FallbackToLogsOnError to OLM deployments +7682b0c4e Merge pull request #816 from ecordell/udpate-catalog +dfe90fbed fix(e2e): fix installplan test cleanup +0111c45df fix(operatorgroups): fixes rbac checking for multinamespace groups +ea0d3fc86 feat(olm): speed up csv updates +5fc146ac8 test(catalog): add tests for catalog reconciliation +2ede4ad35 feat(catalog): check catalog health and recreate if bad +dffcbd5c2 fix(roles): use correct group for package permissions +f20a80348 Merge pull request #838 from ecordell/fix-dependent-subs +78e6f5110 fix(e2e): test changes +f78dd528e Merge pull request #836 from tkashem/csv-conditions-length +7fba013a2 feat(resolver): treat the registry as the source of truth for replaces fields +ee20bf553 fix(olm): race when a subscription updates many versions +13853d1e5 fix(resolver): resolved dependent subscriptions don't detect updates +9b9996139 Merge pull request #834 from ecordell/semver-range +6ad4be7ee Set limit on length of Status.Conditions of a csv +c8ac766c4 Merge pull request #766 from jianzhangbjz/fix-provider +269395ff6 fix labels.provider issue +a6a3dde51 Merge pull request #835 from njhale/fix-registry-recreation +46de47618 feat(resolver): allow skipping a set of updates if the channel head explicitly states that a range of existing operators can update directly +974f55c36 fix(catalogs): make grpc registry check for < 1 pods +12f359087 chore(deps): switch to blang/semver from coreos/semver +a0dcab078 Merge pull request #827 from dinhxuanvu/missing-events +561653551 Add e2e test case to verify the events flow +ad4e44a3d test(reconciler): refactor reconciler tests with k8s decorator +dcd80b0eb test(clientfakes): add k8s client decorator and shared options +6da60367b Merge pull request #833 from ecordell/fix-e2e +65c2c7ec7 fix(permissions): the aggregated edit role should grant view access to operatorgroups +41d292433 fix(olm): don't requeue operatorgroups for deleted copied csvs +0084a2cb7 test(e2e): wait for deployment to exist in csv replacement test +e51da8160 Merge pull request #830 from soltysh/fix_nil +f357dce93 Always set LastTransitionTime in OperatorStatusCondition +5cc96d51e Merge pull request #828 from ecordell/revert +bc697200d Revert "chore(cvo): remove ClusterOperator from manifests" +3205c4f7f fix(olm): Fix the issue with missing events due to rate limit +bc0524ca2 Merge pull request #824 from ravisantoshgudimetla/add-annotation +7f77eb0c3 Merge pull request #826 from ecordell/upgrade-ts +dce549eb0 chore(cvo): remove ClusterOperator from manifests +283c67b89 Merge pull request #817 from jianzhangbjz/priority +0a3e83439 Add node-selector annotation to namespace +b05b06a17 Merge pull request #823 from ecordell/update-cvo-libs +065e52da6 chore(cvo): update openshift/api so that OperatorFailing is changed to OperatorDegraded +b5bb2cdde One more doco typo fix +0f9416ed7 documentation: Fix a few typos. +463caa2a0 Merge pull request #820 from njhale/sub-ip-ref +de57dceee Add validation details for `spec.maturity` field +3f5a8fecd refactor(queueinformer): prevent > 1 run calls for duplicate informers +d01b225f1 refactor(subs): add objectreference installplan refs +0092750c5 feat(types): add reference for olm types +50dbe5e51 chore(deploy): update manifests +9d3034efa add priorityClassName attribute +4af9f7b4c Merge pull request #812 from ecordell/admin-perms +3f4906359 Merge pull request #811 from ecordell/progressing-timestamp +90c8a604d Merge pull request #759 from dinhxuanvu/deployment-update +fcdebc4e6 Merge pull request #813 from ecordell/packages-ns +9f3f393a3 Merge pull request #809 from jpeeler/wip-test-mux +ef518dcff feat(packageserver): add additional info to package server output +30defa3e0 Modify and improve unit test on deployment +c7d6cae8d Rework cleanupOrphanedDeployments +74f236c2c fix(deployment): Clean up orphaned deployments +3726aed3a Merge pull request #807 from njhale/fix-registry-recreation +11ee3da7d fix(catsrc): force registry update on dep resource deletion +232bd9ad1 feat(registry): add registrychecker +29c6d4b43 feat(lister): add catalogsources to operatorlister +5f55b4279 chore(mocks): regenerate mocks/fakes +3b2cdd80f chore(vendor): vendor mock/fake dependencies +fc5805d02 chore(mockgen): use modules for mockgen +a4085910a test(catalog): add registry pod delete e2e test +0eb0a4d80 feat(rbac): restrict permissions for namespace admins +a6a368013 chore(cvo): report progressing=true if the version has updated +affc657d3 fix(e2e): metrics are now served 8081 +eeff07c7a fix(metrics): remove optional from secret parameters +5490daeac fix(metrics): add logging and separate muxer in catalog +54f6dc0ec Merge pull request #794 from ecordell/starting-csv-multiple-ips +58d3c806f fix(metrics): add logging and separate muxer in OLM +ecae4ef2b fix(e2e): remove ip count check +e7efbc995 fix(olm): generate rbac roles for ownnamespace operators correctly +c83204b18 test(aggregation): Add test for operatorgroup role aggregation +9d04dc404 Merge pull request #810 from njhale/changelog-0.9.0 +c3b888e32 docs(changelog): regenerate changelog for 0.9.0 +d62135c00 docs(release): add release doc with changelog generation section +68006792b Merge pull request #802 from alecmerdler/OLM-1017 +7b6d2fcc0 test(e2e): add sanity check for project admin permissions +11c7da475 test(subscription): add additional testing around installplan generation during manual approval subscriptions +77dd28b3e Merge pull request #805 from njhale/fix-modules +1b34ba16c fix(git): remove nuget ignore rules +327865338 chore(modules): revendor +35a7f1301 cut release 0.9.0 +aea532d65 fix(modules): update replaces fields +378fabf39 Merge pull request #801 from alecmerdler/cut-0.9.0 +0fc1030a1 test(e2e): add test for orphaned api services +5de67db91 bump version to 0.9.0 +8d459b889 end-to-end test for cleaning up apiservices after CSV delete +9290d5345 fix(olm): add deletion monitoring for api services +c84c2540f Merge pull request #741 from njhale/sub-status-proposal +b5c396c60 Merge pull request #775 from ecordell/priorityclass +232422018 docs(subscriptions): add improved sub status proposal +f30961255 Merge pull request #793 from jpeeler/rebase-1.12 +ceb060a99 chore(deploy): set priorityclass on olm pods +b6d295303 Merge pull request #792 from ecordell/fix-deploy-annotation +83d1d4195 fix(annotation): don't annotate deployments that aren't owned by a CSV +9981cadc0 Merge pull request #791 from njhale/fix-back-support +a76cdf732 chore(package-server): adjust to new API +c7cc3067c chore(vendor): add jsonpatch +949333e51 chore(codegen): regenerated due to vendor updates +940e2a673 chore(vendor): update vendor directory +b69917ae6 chore(vendor): prep for update to 1.12.7 +04ec6ba04 fix(packageserver): add struct tags to PackageManifestList +24e5f435b Merge pull request #788 from njhale/back-support-pkgs +60cfcc8eb chore(codegen): run codegen and mockgen +375682d11 feat(packageserver): support apps.redhat.com and operators.coreos.com +a1e329edf Fixing indentation for spec field +5fcebfbaa Merge pull request #774 from ecordell/api-v1 +5521fd34f chore(deploy): regen /manifests +13c9c6ed9 refactor(charts): normalize packageserver templates +df200f5fc Support v1 OperatorGroup and v1alpha2 OperatorGroup +647666533 chore(api): bump operatorgroup and packagemanifest to v1 and group operators.coreos.com +85dd72356 Merge pull request #682 from jpeeler/metrics-add-servicemonitor +a3dd5dab4 chore(deploy): don't include openshift stuff in upstream +64194fdc4 fix(deploy): move service creation to new file +84948471d fix(metrics): add service monitor config +544ec926b feat(templates): make use of TLS options in deployments +d65ca70dd feat(olm,catalog): add TLS support for metrics +cbdd04dd5 chore(deploy): renumber files from 02* onwards +ce6651da0 Merge pull request #778 from ecordell/fix-api-labels +a5953899d Merge pull request #776 from ecordell/progressing-metrics +a960f43d0 Merge pull request #777 from ecordell/faster-local +044e1af26 chore(deps): bump openshift/api to get new ClusterOperator types +4327a42f8 fix(olm): use hashes for provided api labels +4443b14a0 chore(build): build binaries locally and load them into containers +ba1e984c0 chore(catalog): add ClusterOperator status for catalog operator +0826a7f90 Merge pull request #771 from njhale/recut-0.8.1 +47103b038 chore(manifests): recut 0.8.1 +396935e4d Merge pull request #765 from njhale/add-changelog +10dd7c2ab docs(git): add changelog +b265e8455 Merge pull request #764 from ecordell/ns-list-for-all +e850b337e Add support for Windows WSL in run_console_local.sh +06f50aecc Merge pull request #763 from njhale/csv-crd-requeue +daef19a8a feat(csv): label CSVs with provided/required apis +4b5c59de2 fix(build): add some minor support for building locally with kind +72376e8fc feat(operatorgroup): operators in operatorgroups that select all namespaces are now granted namespace view roles (get/list/watch) +f6baedc32 test(e2e): add failing e2e test for operators in global operatorgroups +c4bb8b126 Merge pull request #762 from ecordell/upstream-catalog +91ac21027 fix(chart): persist operatorstatus reporting changes to chart +deb826a73 feat(upstream): add operatorhubio catalog to upstream release +a4cb71cdf Merge pull request #760 from tlwu2013/patch-1 +c9e7be947 Merge pull request #722 from jpeeler/cvo-upgrade +bde122446 fix(installer): include generated manifests +5e0b2ea2d fix(ocp): add csv and deployment for package server +caaa4a3ce Merge pull request #761 from ecordell/multiple-upgrades +43a6a75e0 feat(e2e): generate a larger set of namespaces during testing +49fff8558 fix(e2e): use ifnotpresent for all test images +bc1a2efe8 fix(olm): don't attempt to annotate deployments if the deployment hasn't yet been created +c3a87aff3 fix(catalog): kind was omitted from ownerlabels +150e5e774 fix(operatorgroups): gc copied csvs from a separate queue +87a468e04 fix(e2e): e2e test for pre-existing crd owner tested incorrect behavior +aad72bd04 fix(resolver): take a snapshot of the current generation before updates +7e402189d fix(catalog): fill the csv cache with informers +dfafa089b test(subscription): add an e2e test for validating that subscriptions step through multiple intermediate versions +1c5cd4c8b Merge pull request #752 from njhale/change-upstream-base +e56fe1134 refactor(images): use operator-framework namespace for all olm images +77119f2db feat(make): add quickstart generation to release rule +37b777559 chore(docker): update upstream.Dockerfile base to go 1.12 +7a7e799cf refactor(scripts): use existing manifests in package_quickstart.sh +8e749eaa0 style(scripts): rename package-release.sh to package_release.sh +f48dd912f chore(modules): revendor +c543c6de7 Merge pull request #748 from smarterclayton/report_level_status +0a1f38560 clusteroperator: Report when OLM reaches "level" and check syncs +e8bb5e7c0 Merge pull request #758 from njhale/fix-conflict-detection +cf9b23893 Fix typo - k8s version format +0f7f70b60 fix(csv): properly detect owner conflicts for crds and apiservices +a56211824 fix(transitionCSV): reorder apiservice resource check +bea78fcb5 Merge pull request #749 from alecmerdler/bugzilla-1654977 +54c581ecd more event emitting for CSV phase transitions +7065a6af9 more event emitting for CSV phase transitions +4b74799ce Fix small typo. +e14a4d9dc Merge pull request #736 from ecordell/opgroup-expand-contract +99e2789b9 fix(contraction): requeue any csv that may need it after operatorgroup expansion/contraction +fa5a473c8 feat(olm): update deployment annotations as soon as the csv annotations are available +d61293557 fix(e2e): fixing e2e test after rebase +4b373f2d4 chore(rebase): fix errors from rebasing +5520800a6 fix(opgroup): incorrectly detecting CSVs as "copyable" +7d192ef48 fix(operatorgroup): set labels on copied resources correctly +f53e33ae3 fix(olm): move csv copying into its own workqueue to free up csv processing +b316d13d0 fix(e2e): fix e2e tests for operatorgroups +aef7bb9f2 refactor(olm): refactor provided api pruning +24e1f5b78 refactor(olm): simplify CSV copying/pruning +d4f6e448c feat(namespaceSet): add Contains method to namespace set +229a7640c feat(olm): don't copy csv to operatorgroups if it's not in certain copyable states +02bb42210 fix(olm): delete copied child csvs with no parent annotations +299d1f62d fix(operatorgroup): annotate all csvs and allow collisions +55f60797a fix(olm): delete stale resources after op group change +0d2443f71 fix(opgroup): revert order of operatorgroup updates +880c3bcb4 fix(requeue): requeue owners that are referenced with labels +5ad676ac8 fix(olm): change operator group / CSV requeuing +82bd6628d chore(opgroup): allow selector to be nullable so that marshaller can output an allnamespace operatorgroup +995a686cb Merge pull request #704 from leseb/git-objects +ee078b270 Merge pull request #713 from operator-framework/update-csv-link +8d599a1bc Merge pull request #745 from jpeeler/deploy-status +7dcfade0a Merge pull request #690 from dinhxuanvu/api-owner +400c2a8e1 feat(test): adds CSV phase reporting for package server +47f938c6c fix(test): fix labelselector pointer +7904558b1 fix(olm): delete api services upon CSV deletion +2525021e7 chore(olm): add debugging logging and handle potential list failure +2676da569 fix(util): fill in GVK info from InferGroupVersionKind +33a71df8e fix(olm): Fix CSVs api-servers battle for ownership of APIServices +684b7e51f Merge pull request #739 from dinhxuanvu/minkube-validation +1ec96efc4 Make release +1bcaded95 Add minKubeVersion validation to templates +f6e7cdc30 Merge pull request #744 from njhale/update-group-manifests +8bda3c94a chore(manifests): regenerate manifests to include new validation +2d87dd9c3 fix(operatorgroups): use pointer for labelselector +1164ff67a Merge pull request #733 from njhale/fix-installmodes +65007bf93 Merge pull request #738 from ecordell/ifnotpresent-packageserver +206a2c418 fix(packageserver): set packageserver to IfNotPresent +541bc8eb5 refactor(operatorgroups): bail out after successful namespace update +a39619335 Merge pull request #716 from alecmerdler/ALM-913 +c348d6f2b Merge pull request #671 from aweiteka/rbac +df6116e36 fix(csv): fix unsupported operatorgroup status update +7d017d5a7 test(operatorgroups): add installmode support e2e test +28f94c0cd Merge pull request #721 from njhale/operatorgroup-docs +4b00253c1 fix(installmodes): update support logic to match expected behavior +92bb1510b docs(operatorgroups): add more extensive docs +83a62d13a Merge pull request #731 from ecordell/pkgmanifest-api +1e3248dbc fix(packagesever): add missing name field to api definition +7148266d7 Merge pull request #729 from ecordell/cross-ns-ownerrefs +5843601e4 fix(owners): remove cross-namespace and cluster->namespace ownerrefs +50ebe7b8c chore(deploy): run release scripts to get view permissions on edit/admin +c2e9072ee Merge pull request #720 from dmesser/quickstart +812ce8a35 Merge pull request #723 from ecordell/remove-regex +29dc1c34e fix(csv): remove regex on base64 image data +d94cc58ef add all-in-one yaml and helper script +4b95eeaa4 Merge pull request #717 from ecordell/add-use +d8ae7c5c3 fix(csv): icons in csv schema should be an array +3cca62d35 feat(csv): allow use verb in permissions +bc48633c3 fix API validation for OperatorGroup spec +33b98af21 remove minishift support +8be006590 Merge pull request #710 from jpeeler/clusteroperator-discovery +c04306f22 Merge pull request #709 from njhale/grpc-address +5bf5bbbe0 Merge pull request #708 from njhale/tolerate-masters +b3869c50b fix(registry-pods): add everything toleration to registry pods +acfadef73 feat(catalogsource): allow grpc source types that don't require an image +75ad2fb44 Merge pull request #711 from alecmerdler/ALM-910 +8b5c584fc fix(olm): properly detect cluster operator API +c49999a1c docs: update CSV link +039e47176 remove rbac changes to 0.7.1 deploy maniftest +c44d485a8 update aggregate clusterrole to chart template +24bbd94f7 add view rbac to 'admin' and 'edit' default roles +952d5eba8 graceful shutdown for PackageManifest server +a3092c17b Merge pull request #712 from njhale/fix-prefixes +745728d12 fix(manifests): start manifest file names with 0000_50_olm_* +794268b25 Merge pull request #701 from njhale/group-intersection +52831522d Merge pull request #683 from pmorie/doc-install-mode +3f92a704e fix(csv): only allow one CSV per provided API across intersecting operatorgroups +6515a11be Merge pull request #697 from dinhxuanvu/add-installmodes-pkgm +fbcf63306 test(registry): add InstallModes to CSV +cc05e9bff fix(openapi): add InstallMode definition +6e77ba0f6 Merge pull request #699 from dinhxuanvu/minkube-fix +794f2cae0 fix(olm): Remove the "v" prefix in minKubeVersion if presents +6a466f953 revendor and run codegen +7d9b9ee97 fix(packagemanifest): Add InstallModes info from CSV to PackageManifest +c8fe8b023 Merge pull request #703 from jpeeler/e2e-fixes +ca547f2df fix(e2e): fix instability in test runs +7e2ca2e1c fix(e2e): add MinKubeVersion to helper function +4289671f9 Merge pull request #702 from smarterclayton/add_prefix +1563b1912 fix(deploy): Add a component prefix to manifests +9961aa332 Merge pull request #691 from njhale/update-registry-version +7d5cd25dd Merge pull request #693 from ecordell/downstream-registry +ffecc1f1e chore(modules): update operator-registry module to v1.0.6 +77c6fb3a9 Merge pull request #695 from ron1/patch-1 +aeeba1161 Update README.md +6a65344bb Merge pull request #676 from njhale/fix-startingcsv +1cca69c52 fix(subscriptions): respect startingCSV +85cc30498 fix(deploy): fix image references +b51fc99c3 fix(deploy): set writeStatusName for ocp builds +302070fa3 Merge pull request #688 from ecordell/command-pod +03ac86373 Merge pull request #652 from jpeeler/operator-status-2 +f07c0def0 fix(installplans): only create installplans if something new has been resolved. +4d4253a3a chore(olm): run make vendor +f58894422 feat(olm): write operator status by default +c89cef935 fix(reconciler): set command in pod spec of registry images +ff8c20dc8 Merge pull request #689 from njhale/fix-ip-race +a8e57bb9d fix(subscriptions): add check for csv manifest dif before applying new installplans +000a4b3b0 fix(e2e): ensure all subscriptions are deleted in replacing test +d5a3c2502 fix(subscriptions): fix race between subscription sync and cache +9b43046b6 Merge pull request #687 from ecordell/fix-perms +683f9d7eb fix(permissions): Generate unique Names for permissions +6a74e5d54 Merge pull request #685 from alecmerdler/ALM-873 +73a8ea8e7 Merge pull request #681 from alecmerdler/ALM-878 +03b814372 add ownerReference to backing ConfigMap for given CatalogSource +87acfcab0 Merge pull request #679 from ecordell/fix-multiple-installplans +6e84542ac fix link for Package Server CSV +5c73d1404 fix(catalog): use installplan lister instead of api client +9bb9f5f94 feat(lister): add installplan lister +13db70106 Add godoc for InstallModeTypes +d2a4eb107 fix(e2e): only select installplans owned by subscriptions +b612cf5e5 feat(catalog/olm): add tracking ids to logging +f6145e85e fix(catalog): remove gate on operatorgroups for resolution +72fc2a293 test(subscription): update unit tests to use the namespace resolver for subscription tests +a6e32462a fix(catalog): move write of installplan state from installplan execution into namespace resolution - this prevents races where installplans are created twice. +19bf93ed9 fix(installplan): only resolve if there's a subscription in the ns that isn't up to date +9d5f6d77d fix(installplan): fix bug where too many installplans can be created +753982892 Merge pull request #680 from njhale/fix-registry-pod-overwrite +39afd79a9 fix(cm-reconciler): query for pods to overwrite by CatalogSource label +b6dc9b7f5 Merge pull request #678 from ecordell/change-runlevel +55f43b9a6 chore(deploy): change 30 prefix to 50 +8d41d3bc8 Merge pull request #674 from njhale/support-services +6f593941e chore(style): run goimports +fc4f30796 fix(installplans): add ability to apply Services +77c39c393 Merge pull request #670 from ecordell/configmap-changes +7aa6f6d79 fix(test): get kube version from client go for tests +e8177cf17 chore(deps): vendor +a47a41d60 fix(catalogsources): omit unhealthy catalogs from resolution +0d408adc6 fix(installplan): fix race in installplan resolution +f14b1bf2c fix(e2e): make e2e-local-docker work again +ae47a6b8d feat(catalog): add grpc sourcetype to CatalogSources +8bac3e9ef fix(registry): service label selector doesn't include resourceversion +51d644563 fix(catalog): use a different queue for each namespace +99c2341b7 test(catalog): add e2e test to verify configmap changes are detected +45eb3bd23 Merge pull request #663 from dinhxuanvu/min-kube +33bc9b39d fix(olm): Provide correct format of kube version in CSV +81211b825 fix(olm): always return a status on minKubeVersion checks +5bb1fa22b Add minimum kube version to CSV & check it against server version +cca23e2dd WIP: add new minimum version field for kube +30dfa6b9d Merge pull request #672 from njhale/fix-minimums +cb80326e0 test(validation): add test to verify OLM can use bundles with CRDs with min/max fields +768446ae8 Merge pull request #667 from njhale/fix-listing +9244f819b fix(packageserver): don't error out when listing +49cf7b8b0 Merge pull request #669 from njhale/csv-installmode-status +10d383166 fix(operatorgroups): write out CSV status on OperatorGroup issues +d8f98fada Merge pull request #637 from jpeeler/metrics-fix +1e6fa8cb9 chore(deps): update vendor directory +44c8d7a38 fix(metrics): create another endpoint for prometheus +a5c5bfc17 Merge pull request #662 from ecordell/rm-rh-ops +41c69e975 cut 0.8.1 +a57b51747 Merge pull request #653 from ecordell/linux-hosts +e795f339d Merge pull request #665 from njhale/fix-target-csv-update +68d4db92e Merge pull request #650 from njhale/packageserver-use-registry +13be5df1c fix(operatorgroups): use copied csv for update status +60e5583e4 test(unit): fix TestAPIMultiOwnerSet_PopAPIKey tests +ed82334af feat(packageserver): consume registry pods +3443609f1 Merge pull request #658 from chancez/update_metering_install_modes +3c5bda7c7 Merge pull request #657 from chancez/local_watch_all_Ns +2f82ff79c Merge pull request #654 from ecordell/no-gitlab +b4c8ded42 Update metering InstallModes to support SingleNamespace +ef0b8062c Watch all namespaces in local setup by removing watchedNamespaces in local-values +4fd0c6691 chore(ci): remove ci checks for PRs +10f16edaf Merge pull request #638 from ecordell/new-resolver +e760e888b fix(deploy): add linux nodeselector +c309e83f5 feat(registry): remove in-mem registry implementation +77ddabd89 feat(resolver): take all subscriptions into account when resolving +53559a257 Merge pull request #651 from kevinrizza/remove-opsrc-installation +1a9533551 Merge pull request #645 from jcantrill/1663113_env_log_vars +8a431d3fd Remove operatorsource installation +e308a8102 Merge pull request #649 from jboyd01/refine-limits +582ef02a6 Merge pull request #647 from EmilyM1/add-metering-to-OLM +47f8c286d adding csv, crds, package for metering operator +831b6dba5 Merge pull request #640 from njhale/csv-installmodes +c52328bc8 fix 1663113. Add component image ENV vars to cluster-logging-operator fix 1662397. Add permissions to create shared-config roles and bindings +15d2bd814 update Service Catalog memory & cpu limits +521b70045 Merge pull request #646 from jcantrill/update_code_gen +939fabd48 update codegen for 2019 +fb05ebc86 chore(codegen): run codegen to satisfy validation due to year change +12d0a1a4d feat(installmodes): add installmodes to templates +14f94f939 feat(installmode): add InstallModeSet +4b9ba8f44 refactor(operatorgroup): account for TargetNamespace field in updateNamespaceList(...) +fcebf86bf feat(csv): add installmodes to CSV spec +73201241d Merge pull request #641 from rodrigovalin/mongodb_operator_update_06 +8e6b35965 Merge pull request #643 from ecordell/e2e-registry-pod +63277ac15 test(catalog): add an e2e test verifying that the rh-operators catalog starts up correctly +8cc24e049 Updated MongoDB Operator to 0.6 +5c38ea112 Merge pull request #636 from ecordell/remove-all +e44a86e5a fix(crds): remove category all from CRDs +7bfbac8df Merge pull request #614 from jpeeler/jeff-533 +96eb5d267 Merge pull request #633 from ecordell/requeue-subs +0317cb73b fix(packages): add sourceNamespace to packages apiserver +896dec301 requeue dependent subscriptions when a catalog syncs +964e57e41 fix(sub): set subscription to failed if there's no catalogsource +387e1c64e Merge pull request #634 from njhale/fix-run-local +4433e8982 Merge pull request #622 from kevinrizza/master +f1564e340 fix(charts): add operator_namespace to run-local values +dbf5cc968 Merge pull request #629 from jboyd01/bump-up-mem-for-cm +52da24fd7 Merge pull request #630 from ecordell/fake-registry-client +37fbb88e3 chore(fake): add fake for registry client +b9e0a5af5 Merge pull request #556 from ecordell/registry-pods +e97c4a879 increase memory limits on all service catalog pods +af2055a52 chore(deps): vendor +8f2451f39 feat(olm): add message to requirement statuses +8a9723e87 Install operatorsource crd and default cr +0b97ff52c Merge pull request #616 from jpeeler/jeff-601 +60235d973 Merge pull request #618 from ecordell/ALM-785 +43b915d0e Merge pull request #621 from ecordell/awgreene-marketplace-csv +6bf8f5c85 fix(deploy): fix marketplace manifests +1c48eedcd Merge branch 'marketplace-csv' of github.com:awgreene/operator-lifecycle-manager into awgreene-marketplace-csv +30c149139 Merge pull request #570 from jcantrill/aggregated_logging_csv_edits +85cff0223 Creating csv, crd, and packages for clusterlogging and elasticsearch operators +4d51a44e4 feat(rbac): generate cluster role for viewing CRD for each provided api +a92f652d5 Add Marketplace csv +5420a1fca test(registry): add checks for registry pods +5ebf78847 feat(catalog): use operatorlister in catalog operator +7820e5f36 feat(registry): when syncing catalogsources, generate pods that serve the operator registry api for configmaps +e04534c48 feat(catalog): add configmap server image config flag +f2bcb3759 feat(api): add registryservice to catalogsource status +ba15afaae add 'get' permission for the CRD itself to the created Role +97160b54e Merge pull request #620 from ecordell/runlevel +bda466e37 fix(deploy): add runlevel to openshift-operators +6c0451731 Merge pull request #617 from ecordell/require-apiservice-name +574d29d3f fix(schema-check): fix schema check error bug and update manifests +83dbd51ff feat(csv): make apiservicedefinition pluralname required +4bcf04b59 chore(olm): make use of operator group constants +241269fb0 fix(olm): don't annotate target namespace on copied CSVs +543711d06 Merge pull request #589 from ecordell/copying-in-csv-loop +7efdfc198 fix(unit): fix tests involving CRD status +f8baea449 feat(olm): generate clusterroles for provided apis in csv loop and aggregate them to operatorgroup clusterroles +51dde613e feat(operatorgroups): don't process CSVs that aren't in an operatorgroup +56df9f650 Merge pull request #609 from njhale/package-server-subscription +616b5904f Merge pull request #587 from galletti94/master +3596b3dd7 Merge pull request #615 from jboyd01/serv-binding-finalizers +7a3cc0337 chore(manifests): regenerate manifests +220912653 Merge pull request #575 from wongma7/use +d421664b8 Merge pull request #574 from jpeeler/architecture-linted +d4417629d Merge pull request #573 from jpeeler/docs-operator-group +da23b2067 add rbac for servicebindings/finalizers +69f314566 fix(unit): use global logrus logging instance +f284ab0f4 Merge pull request #562 from jboyd01/remove-resource-limits +ef067d2b0 Verify CRD's condition to ensure it's registered with k8s API +87284dc52 test(packagemanifests): add wait for package-server to be ready +16fb5c033 feat(subscriptions): requeue dependent Subscriptions on CatalogSource sync +1747b92f2 feat(helm): create helm templates for package-server subscription +a930e1855 Merge pull request #612 from ecordell/image-refs +ab2af2eac chore(release): switch image-reference tag to operator-lifecycle-manager +b509e1e02 Merge pull request #608 from jboyd01/fix-image-repo +bd34aad44 Merge pull request #611 from ecordell/regen-manifests +66bb41a6e regen manifests +290923657 chore(docs): fix markdown lint warnings +8dd4743e2 Merge pull request #591 from jpeeler/global-namespace +9964fb376 Merge pull request #584 from ravisantoshgudimetla/add-descheduler-crds +2d4f256e7 docs(arch): add operator groups +94b211a90 fix(scripts): clean up all resources when done +0fb838472 feat(deploy): add operator group to watch all namespaces +d6727651a chore(scripts): add quoting for safer bash +0af032085 chore(docs): fix up whitespacing +643d19baf Merge pull request #603 from jpeeler/operator-group-robust +4e4e11d7c increase limits for embedded etcd +441d9a76c use quay.io vs registry.reg-aws.openshift.com +deae2f7b1 fix(e2e): make operator group test more robust +451c378f1 Merge pull request #602 from ecordell/slightly-mame-gitlab +da0f248c1 feat(ci): remove e2e tests from gitlab +71ac2f7e6 Descheduler operator CRD, CSV +8dee386d8 Merge pull request #594 from njhale/selfhost-package-server +8fee1575e chore(manifests): make release +922a67d5a feat(package-server): self-host package-server with CSV +c931a433b Merge pull request #599 from njhale/fix-tests +3d941d976 Merge pull request #596 from smanpathak/patch-1 +fdb68cfc1 fix(e2e): create CSV first to use in CRD ownerref +5597fd3b9 fix(e2e): use testNamespace for ownedAPIService test +1ef129f4f Merge pull request #590 from alecmerdler/ALM-823 +7e861bb79 fix panics in package-server +368514919 Fix a typo in documentation +fcdadcc35 Merge pull request #552 from ecordell/e2e +b8e634bbd fix(e2e): set up variables for non-bare e2e runs +7d309e83e feat(e2e-bare): add utilities for running olm and e2e locally against a remote cluster +6a5ab53a8 feat(make): add e2e command for running from ci-operator +5090f4140 Merge pull request #593 from njhale/use-mock-ext +3afe9b539 test(csv): use mock-ext-server for owned apiservice e2e test +f8455ebac Merge pull request #585 from njhale/fix-mod-checksum +0cf3efeba fix(annotations): merge CSV and pod template annotations instead of replacing +01ede6835 Merge pull request #592 from alecmerdler/fix-client-go +ecaf794d3 fix client-go in gomodules +feb00156e Merge pull request #583 from alecmerdler/issue-577 +a1fcb7965 Updating: adding description to package manifest object - solves ALM-819 +fa72497d9 Merge pull request #571 from ecordell/serviceaccount-rbac +b15c2a945 feat(operatorgroups): move annotation projection to csv loop +57a542525 test(operatorgroups): more comprehensive tests of operator group copying and rbac generation behavior +b7935e6bb fix(e2e): add operator namespace to target ns list +cada67262 fix(unit): account for correct rbac resource parsing +f0565a877 fix(e2e): account for operator group type change +c01878878 feat(operatorgroup): create role bindings for operator service accounts in target namespaces +c7493bce5 add packagemanifest:aggregated-apiserver-clusterrole +ed9c15e02 Merge pull request #576 from alecmerdler/ALM-809 +6176cc402 Add packagemanifest:aggregated-apiserver-clusterrole +799d6b594 propagate labels from 'CatalogSource' to each 'PackageManifest' +f8ade6d5e Make use a valid clusterPermissions rule verb +dec89d2a8 Merge pull request #572 from njhale/fix-slowness +a6e1a3c87 fix(csv-requeue): requeue on namespace all if all namespaces are watched +32f42f6bc Merge pull request #568 from jpeeler/add-operator-group-2 +60df92c7d fix(olm): create cleanup function for olm deploy mod +662dbc452 fix(olm): fix RBAC cluster role creation +933452c2e Merge pull request #569 from njhale/caches-for-everyone +a37c37162 feat(olm): use cache listers in olm-operator +bb78f61e9 Merge pull request #567 from ecordell/cut-0.8.0 +ecb4902b0 cut 0.8.0 +a7deb0601 Merge pull request #566 from ecordell/fix-it +d9177db1d chore(build): remove vendor commands from base dockerfile +b607b33a0 Merge pull request #565 from ecordell/bump-0.8.0 +4ac8ae1ea chore(olm): add additional debug in requirements +564bba7e9 fix(olm): add additional validation for operator groups +3bc39b9d2 chore(release): bump version to 0.8.0 +fba0f380b Merge pull request #564 from njhale/container-mockgen +91afee829 feat(mocks): generate fakes and mocks in a container +74216ea18 Merge pull request #560 from njhale/redetect-deployments +9c3ced389 fix(rbac): use separate queues for each rbac resource +1e32a28c6 fix(queueInformers): use separate queue for each namespace +73930379e fix(logging): use structure logging in checkAPIServiceResources +e2289683a Merge pull request #563 from ecordell/remove-ns-annotator +616eb9333 chore(olm): remove cleanup func from operator +225511192 remove namespace annotator +fe8f13cda Merge pull request #561 from alecmerdler/fix-gomodules +06e74ef2d fix gomodules (broken by client-go mutating their release tag) +a04f4b84f Merge pull request #554 from ecordell/go-modules +766cc0276 chore(ci): remove verify step from gitlab +d682ea346 feat(container): make container builds faster +856339b9c chore(codegen): run all codegen in a container +c63f1fd90 chore(deps): switch to go modules +cfca0c433 Merge pull request #536 from njhale/redetect-deployments +e1dab8b54 feat(csv): detect deployment and requirement changes in Succeeded and Failed phases +7d4fd988b Merge pull request #545 from jboyd01/initial-rework-on-csv +56c7d7ad6 Merge pull request #547 from rhamilto/amq-icon-update +8fb473f33 Merge pull request #537 from rhuss/patch-1 +b5b5625c2 Merge pull request #516 from jpeeler/no-minikube +b06aea6dd Merge pull request #480 from jpeeler/add-operator-group +59edcdf55 fix(olm): make operator group copy CSVs more efficiently +ff44fc7bf fix(olm): remove duplicated code +2a76048cf chore(olm): refactor updateNamespaceList +c91260ddd fix(unit): create OperatorGroups with initial fakes +d6978a43c Merge pull request #548 from dinhxuanvu/multi-crd-test +e8ac902b6 feat(build): allow skipping minikube during local builds +316f7c0d7 Merge pull request #517 from jpeeler/fix-clean +2535b3950 Merge pull request #549 from dinhxuanvu/olm-log-fix +dada508cd Merge pull request #550 from jpeeler/fix-deployment-lister +b05747619 fix(olm): set lister up for deployments +4f7cfcb43 fix(olm): do not check namespace if casting failed +aed3d3764 Merge pull request #541 from alecmerdler/ALM-666 +12aa70d8a fix(build): add cleanup for package release files +f34e52b38 add 'spec.nativeAPIs' field to CSV and check that native APIs exist before install +8c6171c56 Merge pull request #539 from alecmerdler/prometheus-service-ownerref +a6b1a2c97 fix(olm): operator group annotations and listers +7b8f5efd0 fix(e2e): slightly improves execution time +8b0dab168 fix(olm): set event handler functions correctly +1943e1880 fix(olm): refactor e2e and check annotations +e3bb3a9ef WIP: cvs in operator namespace are being annotated, csvs in target namespaces should be annotated +c5f7d9b35 fix(olm): adds debug logging for operator groups +e30e107a7 Update AMQ logo to new brand standard +35ecdcc14 Add test case for supporting multi-version CRD +e5f4d6c93 Fix olm pod name so log to be written correctly to olm.log +fa806225b use OpenShift's ServiceCatalog build, fix rbac + more +d3661f9cd feat(olm): detect dangling child csvs in olm operator +7a49edc10 fix(olm): handle copied CSVs when deletion occurs +5c2319536 fix(e2e): update e2e for refactoring +388f228ae fix(unit): fix race condition +9113d09a6 fix(unit): set expected owner refs for deployments +c03447195 refactor(operatorgroup): split apart the larger sync functions +d8dff17ba fix(e2e): ensure created objects are deleted +f71f79868 fix(olm): make RBAC creation resilient +b5c332293 test(e2e): add second e2e for operator groups +6f0cfc49c fix(unit): call Run on operator directly +8f32e3bf3 test(e2e): add e2e test for operator groups +956773962 fix(olm): make status updates on deployments, not CSVs +358ece0ab test(unit): add unit tests for operator groups +1194918a6 fix(olm): change annotations to be allocation safe +9ec09bce4 feat(olm): copy "dummy" CSVs to target namespaces +00914f8c8 feat(olm): handle required RBAC permissions +ff07844dc feat(olm): make namespace updates trigger annotation updates +7665de86f chore(olm): rename annotateNamespace to syncNamespace +e69d38f94 feat(olm): add operator group control loop +28fceea4d feat(olm): add CRD definition for OperatorGroup +83c8ddae0 chore(olm): generated files +d9528d426 feat(olm): add OperatorGroup types +016d80f63 Merge pull request #525 from njhale/refresh-certs +8ee21d58d feat(listers): add and use aggregate informer lister +c6f116c99 add Service as owned resource for Prometheus/Alertmanager CRDs +09daab0a8 feat(csv): add generated APIService resource check +c874b5125 fix(ci): cleanup packagemanifest APIService during deploy stop job +8601151b0 feat(csv): add succeeded to pending transition on cert refresh +29e6ca79d feat(csv): add configurable APIService cert expiration +44ccec038 feat(apiservices): add APIService adoption logic +8764b2ca1 refactor(ownerutil): make HasOwnerConflicts generic +27c684884 chore(test): bump minikube kube version to 1.12.0 +c0cb86182 Fix template values for 'olm' parameters +bea6183ba Merge pull request #522 from alecmerdler/ALM-754 +bb32660ba fix ClusterServiceVersion CRD to allow any descriptor default value +80442ecd0 added spec/status descriptors for Dynatrace Operator +300e7a008 Merge pull request #530 from alecmerdler/ALM-378 +2797fbce0 Merge pull request #531 from eriknelson/add-assign-verb +2d0164a4a emit events when setting CSV phase +1d9d4c45e Merge pull request #534 from njhale/release-0.7.4 +72218e7c0 Merge pull request #535 from alecmerdler/add-prometheus-configmap +2f7fb6e26 add ConfigMap as an owned resource for Prometheus CR +aa65ab4b8 Merge pull request #528 from aditya-konarde/patch-1 +d89177d0b chore(release): cut release 0.7.4 +c5b58ca29 Merge pull request #533 from njhale/bump-version +de07a94d3 chore(release): bump version number to 0.7.4 +47f0b771b Add `assign` verb to csv crd +27bb0da72 Merge pull request #526 from njhale/enable-auth +0c04d0e29 Merge branch 'master' into enable-auth +6f5f588d6 Merge pull request #518 from jpeeler/deploy-debug +8f98411e1 Merge branch 'master' into deploy-debug +c15c38eef Merge pull request #523 from ecordell/dont-annotate-immediately +2367013fd Merge branch 'master' into dont-annotate-immediately +4eebac945 Merge branch 'master' into patch-1 +bedd37ef0 Merge pull request #527 from njhale/fix-ports +dd7edeedb [Doc] Add note about helm binary requirement +ee5fa093c fix(e2e): switch to port 5443 for owned apiservice test +e2acf29d2 chore(e2e): change package port to 5443 +7c5dfac0f Merge branch 'master' into dont-annotate-immediately +7682a397a Merge branch 'master' into enable-auth +69c5223c7 Merge branch 'master' into deploy-debug +a68257eca Merge pull request #524 from ecordell/pkgserver-port +8b077e998 chore(package-server): enable auth by default +2c7b4a945 fix(package-server): make secure port configurable and default to 5443 +c0994b7cd fix(olm): don't annotate namespaces on operator creation +fde481faf Merge pull request #521 from alecmerdler/ALM-774 +1ddefbafd pass annotations from CSVs to associated PackageManifest +624901992 Merge pull request #520 from alecmerdler/ALM-753 +ee0bbd0ea adding more spec/status descriptors for CouchbaseCluster +a469acd4a Merge pull request #519 from font/install +d0749dce0 Merge branch 'master' into deploy-debug +8384a09ee Merge branch 'master' into install +69306979b Merge pull request #515 from jpeeler/crd-client-metrics +2460160ee feat(deploy): add debug variable to all deployments +be8625420 fix(metrics): use CRD client instead of k8s +58ebd4978 Update OKD install instructions +4194983ab Merge pull request #514 from njhale/non-resource-perms +51b6a8a46 fix(requirements): add CRD served version requirement check +66e04f524 fix(requirements): add support for non resource url rules +c660c0784 Merge pull request #513 from alecmerdler/ALM-752 +36c5e1d2d rewrite 'metadata.namespace' of global PackageManifests +59c835188 Merge pull request #512 from ecordell/0.7.3 +1af271d52 bump olm version to 0.7.3 +4e1317470 chore(deploy): remove unneeded dockerfiles +84800de83 Merge pull request #511 from eriknelson/nonresourceurl-verbs +9570511ca Merge branch 'master' into nonresourceurl-verbs +a9ae9794f Merge pull request #506 from njhale/fix-blank-req +34d53acd3 Add missing nonResourceURL verbs to csv validation +ebf12385b fix(csv): make invalid install strategy transition from pending to failed +9ffecba09 fix(requirements): remove extra empty permission requirement statuses +8d5ed0436 Merge pull request #510 from ecordell/singleimage +c9118b394 cut 0.7.2 +6c3c95b0e chore(deploy): update release scripts to not use 3 different images +cf5a2dcda Merge pull request #508 from eriknelson/logfix +1eaf17ad5 Merge branch 'master' into logfix +a41cfbd3c Merge pull request #509 from ecordell/olm-deploy-singleimage +ce535c211 Merge branch 'master' into logfix +589e9dcca chore(deploy): put all binaries in the same image +851518689 Small log statement fix +1c13c1cce Merge pull request #505 from alecmerdler/ALM-750 +94e378dbb add 'catalogSourceDisplayName' to PackageManifest status +8e7a25f8d Merge pull request #504 from njhale/fix-deploy-staging +f3f096492 fix(ci): use deployment namespace as catalog_namespace +ffe9e0c2c Merge pull request #503 from smarterclayton/labels +1812c4c4a chore(deploy): use runlevel label on namespace +7e6bccf6f Merge pull request #492 from njhale/manage-apiservices +710055877 docs(apiservices): add some detail on APIServices in CSVs +3b729ef60 feat(svcat): add service-catalog manifests +e73e72ece feat(csv): install owned APIServices +0e9ba409c Merge pull request #502 from ecordell/runlevels +00dee8016 chore(deploy): Add runlevels to release +55901eda7 chore(ci): Use a single Dockerfile for ci +b10f31114 Merge pull request #501 from madorn/patch-3 +a5cd11e51 Merge branch 'master' into patch-3 +c7f7f7af6 Merge pull request #499 from wongma7/use-scc +38b8043b9 Merge branch 'master' into use-scc +0e0705a86 Remove explain 'annotations' and 'replaces' +1b99ccd15 add example and additional info about optional CSV metadata (replaces, annotations, labels, selectors) +40f1ec2b9 Merge pull request #494 from alecmerdler/ALM-735 +36c2fa492 return PackageManifests from 'global' namespace +6c4e92ea3 Merge pull request #500 from mrogers950/fix_imagestream_yaml +ac77a6652 fix 30_14-imagestream.yaml formatting +230f30537 Merge branch 'master' into use-scc +0209fabd5 Merge pull request #498 from alecmerdler/federation-csv-provider +e75ec5aae Make use a valid clusterPermissions rule verb +1776a6d37 add 'spec.provider' to Federation CSV +ef237384c Merge pull request #497 from font/e2elocalshift +b4357182c Merge branch 'master' into e2elocalshift +3eee10107 Merge pull request #491 from font/fedv2-v0.0.2 +49f8ed880 Add missing binary to fix run-local-shift +fc80eaea3 Update registry unit test for FederationV2 +85b1ba98d Split out FederationV2 CRD file into many files +40cdef4d2 Update FederationV2 CSV to add spec fields +ed1f978b0 rh-operators: add FederationV2 v0.0.2 +89d2e37b4 Merge pull request #493 from ecordell/ci-fixes +fc8054537 fix(deploy): add base images for ci-operator +5b55ada20 Merge pull request #496 from abhinavdahiya/remove_label +be70bd26f Dropping label for origin releasepayload +3b3e69cac Merge pull request #476 from alecmerdler/ALM-722 +0b1d2408f implement watch for PackageManifest resource +8909a2610 feat(package-server): add minimal watch +3f5133c6c Merge pull request #490 from ecordell/remove-vendor +ea90420af fix(build): don't vendor +341d9c1e0 Merge pull request #489 from jpeeler/build-golang-1.10 +c85b44dea change go build to use 1.10 +28ce23571 Merge pull request #482 from madorn/patch-2 +f54911a34 Merge branch 'master' into patch-2 +76a534266 Merge pull request #483 from ecordell/deployment-fixes +a981e480f fix(submodules): remove submodules +cd0c8e0a6 fix(deploy): only use replace on configmaps +ee1d27627 Merge branch 'master' into patch-2 +3734b9ae6 Merge pull request #487 from ecordell/add-package-image-stream +490f273d9 Revert "fix(deploy): remove package-server until ci-operator is outputting the package-server tag" +9ff1a27d1 Merge pull request #486 from ecordell/fix-image-stream +a2a0acbcf fix(deploy): remove package-server until ci-operator is outputting the package-server tag +01fea7099 fix(deploy): yaml error in imagereferences +ac1456c93 Merge pull request #484 from ecordell/fix-manifests +2bf227bdb fix(deploy) rename image stream to `image_references` +e78ab125a Add manifests to dockerfile +a9aec1f56 re-cut 0.7.1 +7f3c3d1a1 Merge pull request #479 from njhale/rbac-requirements +c9875bba5 docs(rule_checker): update hasOwnerConflicts comment wording +9e3d2a4f3 test(rule_checker): wait for informers to sync before continuing tests +3881e4212 refactor(olm): use SharedIndexInformer listers for RBAC resources +bd79623e1 docs(rule_checker): add reasoning note to hasOwnerConflicts method +2a78522e7 chore(dep): constrain k8s.io/kubernetes to the release-1.11 branch +0f4d07325 chore(comments): correct comment mistakes +6bcb9a1e0 test(deployment): remove/refactor tests expecting RBAC installation +441e2bae8 chore(code_gen): regen mocks and openapi +ee7d3a4b4 refactor(olm): add DependentStatus message field +2b2cde5d7 test(csv_e2e): add e2e tests for permission requirements +4591823f2 feat(olm): add ClusterRole/Binding requirement checking +d94767798 refactor(rule_checker): move rule_checker to install package +edf824218 feat(permissions): add RBAC permissions as CSV requirement +7a3a24056 refine cluster-admin OLM workflow +9f4351730 Merge pull request #478 from baichinger/dynatrace-rectify-form-of-business +584eb0f22 certified-operators: rectify form of business for Dynatrace +f207fc104 Merge pull request #477 from ecordell/clusterroles +7039b333b test(installplan): test clusterrole and clusterrolebinding resolution +78e5bb81b refactor(resolver): move step resolution to resolver package +59f2c880f feat(catalog): resolve ClusterPermissions on CSVs as part of an installplan resolution +e24427b9f feat(deploy): add clusterPermissions to CSV +639b8dbc2 fix(deploy): update upstream release +5d0d0c772 Merge pull request #475 from ecordell/0.7.1 +1b2605f76 fix(ci): don't create namespace (it's in the chart now) +cfada3c7b cut 0.7.1 +e9d04101e Merge pull request #474 from ecordell/push-tags +c771a29d9 feat(ci): push tags to quay +3a4c9f0c0 Merge pull request #472 from ecordell/0.7.0-packages-api +c82e275b3 re-cut 0.7.0 +0183fe87f chore(deploy): add package server to release scripts +dd3c005d0 Merge pull request #470 from praveenkumar/patch-2 +c8645173d Issue #469 update the service catalog instruction for minishift. +6c243bb4d Merge pull request #459 from ecordell/apiserver-dependency +d64eceef7 fix(olm): don't both checking for GVK in discovery for CRDs +4b47c0049 feat(e2e): use newNginxInstallStrategy helper to clean up csv e2e tests +49d0d484c test(olm): add e2e tests for depending on apiservices +ac7f222dd test(olm): add unit tests for depending on apiservices +ee39338e4 feat(olm): check for the existence of required APIServices before installing +fa6287214 chore(deps): add kube-aggregator to get APIService types +fb974a42d feat(apiservices): add support in CSV for apiservices +639f296b7 Merge pull request #457 from njhale/rbac-plans +f18a02595 chore(catalog): remove TODO comment +3d3e7692b chore(mocks): regen client mocks +2ab5b404b refactor(resolver): rename resolved RBAC resources +0e83d35ed feat(catalog): add OwnerRef patching for ServiceAccounts, Roles, and RoleBindings +2972534d4 feat(operatorclient): add Role and RoleBinding clients +a33ba616b fix(catalog): update OwnerReferences with stored CSV UIDs +f3fb63f3c refactor(installplan): move scheme build to init +736ed7a8c feat(resolver): generate UIDs for freshly resolved CSVs +ed0d96692 fix(catalog): handle creation of RBAC resources in plan execution +e9c5d18ad test(catalog): add e2e test for InstallPlan RBAC resolution/execution +4a6566748 feat(installplan): resolve RBAC resources during InstallPlan resolution +c44695f7b feat(installplan): enable creating step resources from runtime.Object +37c80b316 Merge pull request #466 from LiliC/lili/fix-install +af3cd6f8e Merge branch 'master' into lili/fix-install +eb5eb7250 Merge pull request #465 from alecmerdler/ALM-721 +2aa0546df return all 'PackageManifests' for 'all-namespaces' +8d35ef469 Documentation: Change to full path +3e7535ae2 Merge pull request #452 from jpeeler/add-metrics +d0273a559 feat(olm): add metrics +b8b8c9734 Merge pull request #464 from operator-framework/add-owners +0976485ea Create OWNERS +db1e0e0b7 Merge pull request #458 from rodrigovalin/mongodb_operator_csv_updates +00c8044f9 Merge pull request #461 from madorn/patch-1 +e11fa9ce2 Merge pull request #463 from njhale/test-ownerref-gc +d0e94518a Merge pull request #462 from ecordell/cut-0.7.0 +821d3968c test(e2e): add OwnerReference GC behavior test +f28afd701 style(e2e): re-order imports +fc98155bf cut 0.7.0 release +04ab7bd26 feat(deploy): update makefile to generate deploy artifacts for okd +07ff80e8a List out options for Descriptors +7a0984c7f Merge pull request #460 from ecordell/0.7.0 +9941f036c cut 0.7.0 images +7a8840955 Improvements on the MongoDB Enterprise Operator CSV. +9a7deedb8 Merge pull request #455 from njhale/revendor +720ad7110 fix(vendor): revendor dependencies +0a48190c6 Merge pull request #453 from ecordell/remove-annotations +793079cd2 feat(olm): attempt to cleanup namespace annotations on shutdown +c1942075f Merge pull request #451 from njhale/queue-pipeline +b9b308766 Merge pull request #440 from robszumski/update-csv +e908d7132 fix(scripts): short-circuit up to length 1 running pipelines +526a3e6c1 style(scripts): snake_case is_head function +0ff9d2013 fix(ci): move wait-in-queue job before deploy-preview +a1d6d032d feat(ci): add wait in queue job to test_setup stage +68385ce1a feat(scripts): add pipeline queue wait script +09cba2fb9 fix(e2e): update prometheus channel +93901f33d rh-operators: use preview as channel for Prometheus +96677e996 rh-operators: use preview as channel for AMQ +7ddb9b517 certified-operators: use preview as channel for Dynatrace +490c662e2 certified-operators: use preview as channel for MongoDB +db8f2659d certified-operators: use preview as channel for Couchbase +8c960c927 certified-operators: add double spaces in Mongo markdown +e20203f82 certified-operators: fix Mongo markdown lists +9bec7dc92 certified-operators: add required parameters for MongoDB +3c5c32230 certified-operators: add required parameters for Dynatrace +9d8ac6727 certified-operators: add required parameters for Couchbase +42657c62d Fix certified operators packages csv refs +edf552ab8 include certified-operators catalog in deploy on CI +0f27723b1 Update directory loader test for amq-streams +186236a98 certified-operators: update Dynatrace version +730b26dd0 certified-operators: add Dynatrace CSV + CRD +0459412e2 certified-operators: add Couchbase CSV + CRD +02994afd6 certified-operators: add MongoDB CSV + CRDs +c2d8e68ba rh-operators: add AMQ Streams CSV + CRDs +6bf3cad97 Merge pull request #447 from ecordell/generate-aggregated-roles +7c800d986 feat(catalog): add aggregated roles for each crd we resolve +f0d3b21c0 Merge pull request #433 from njhale/pkg-api +0ed929b8a Merge pull request #450 from ecordell/prom-update +391d51e32 fix(reststorage): start with empty slice when filtering +0936f3159 feat(inmem): collect CSV data in PackageManifestStatus +e95b93ba0 chore(server): remove commented packages +9b07a0c4c test(e2e): use CSVDescription in expected PackageManifestStatus +ed207e334 chore(openapi): regenerate openapi spec +2258a4eb7 feat(packagemanifest): add CSVDescription to PackageManifest +824d02dc8 fix(build): add OLM_VERSION file and .git directory to e2e.Dockerfile +adff217d2 fix(prometheus): add securityContext to alertmanager example +89ae2d1d1 test(packagemanifest): add fetch function for packagemanifests +faca2adad test(e2e): add logging to TestPackageManifestLoading +348edd45c fix(charts): change cert secret mount path +4c91f46ae fix(charts): change default package-server internal port value to 443 +a07ff5ca3 fix(charts): update expected package-server chart value name +36f61d982 refactor(charts): use olm-operator-serviceaccount for package-server +db2d4d7ab fix(charts): correct indentation +46dabbd0a fix(charts): add missing coreos pull secret +d9130b966 fix(scripts): uncomment cleanup +ed9c71291 feat(ci): add package-server to ci +b723612b6 feat(scripts): add package-server to build scripts +1d516db51 feat(docker): add package-server to Dockerfiles +6d1df15fd feat(reststorage): return NotFoundError if manifest not found +7f9e37671 fix(provider): don't use pointer in manifest selection loop +e78eeb197 feat(package-server): add debug flag +dac5c051d fix(package-server): surface cobra flags to package level +8252d706d feat(package-server): add run-local package-server helm values +228fa902b test(package-server): add basic e2e test +cab422840 feat(deploy): update package-server templates +9a612461d fix(inmem): change struct tags +b6e03761c refactor(packagemanifest): move all package data to status +895898db4 chore(package-server): remove and ignore local config +e82d823e4 feat(package-server): enable openapi +d8ad5bb2e feat(package-server): adds skeleton of package server +7a2a804da Merge pull request #449 from djwhatle/fix-install-doc +1ab94b034 Merge pull request #446 from operator-framework/csv-guide +c1f4466a3 docs: update broken link +3c05b4dbb Merge pull request #448 from njhale/version-flags +0723f2167 Recommend installing OLM with `kubectl create` instead of `kubectl apply` +89dbea144 fix(build): remove GOOS and GOARCH settings +2aa971062 feat(build): add version injection to go test build +d743c7d51 style(flags): change version output format +eef8635a5 fix(build): point version build ldflag to correct package path +340c852f6 feat(cmd): add version flags +dada4703c chore(osbs): remove unused Dockerfile.single +989a71d52 docs: text -> label +23e0797d9 docs: move desc to bottom +8702b466e docs: add CSV guide +f5fef4abb Merge pull request #445 from njhale/pull-console +42da71917 feat(run_console_local): add docker pull for console image +e967cee84 Merge pull request #441 from alecmerdler/fix-console-script +cf392e3bb fix console script to work with both Linux and MacOS +232748ead Merge pull request #444 from ecordell/perms +b3f7069c7 chore(broker): remove servicebroker from CI +289d1e0ab chore(rbac): add olm-specific ClusterRole +00a4ba7c7 Merge pull request #443 from operator-framework/ecordell-patch-2 +cdcfa6f0f Remove outdated install instructions +67f54b3d9 Merge pull request #438 from jpeeler/ALM-630-remove-broker +9d5348444 Merge pull request #442 from ecordell/remove-aos +a29b6f667 chore(deploy): remove ansible scripts for install +2c99b206c Merge pull request #439 from njhale/dockerfile-single +004a7615d feat(osbs): add non-multistage docker build +d0e573efe remove non-go references to broker +9cf92348a prune dependencies via dep ensure +1b038d7fb fix(servicebroker): remove broker from repository +4a342a5a5 Merge pull request #435 from jpeeler/e2e-fix +42bde3739 Merge pull request #429 from ecordell/catalog-rename +bc49404ef fix(scripts): allow use of existing KUBECONFIG env var +84d0ebaf7 Merge pull request #432 from ecordell/mv-api +0ff8f38a1 fix(scripts): make cp cross-platform +30519eb8d chore(api): move non-generated apiclients out of the api dir +ab96af79b chore(catalog): rename ocs -> rh-operators +3d31e3519 Merge pull request #431 from alecmerdler/ALM-620 +f20ef2b19 add script and instructions for running OpenShift console +b382d3557 chore(rbac): remove view verbs from edit role +41bfb18fc chore(prometheus): remove namespaceSelector from ServiceMonitor +bfd26cefa Merge pull request #428 from njhale/osbs-ready +3e09a705f fix(Dockerfile): fix catalog copy typo +7d0a42a17 fix(Dockerfile): add catalog bin to final docker image +d44140f67 chore(ci): update gitlab-ci.jsonnet to reflect Dockerfile name change +2525f996b refactor(Dockerfile): make Dockerfile.rhel7 OSBS compliant +934c9c557 chore(dep): vendor dependencies +23f62e7db Merge pull request #425 from sichvoge/update_prometheus_csv +e49a88d86 Merge pull request #427 from njhale/catalog-e2e +da020c364 test(e2e): add catalog loading between operator restart test +479299d58 Merge pull request #426 from alecmerdler/action-descriptors +37a2a154b add actionDescriptors block +141a6d0de Merge pull request #423 from njhale/subscription-current-csv +39d857795 Merge pull request #424 from njhale/fix-catalog-loading +1234b1e7b fix(catalog): add check for loaded catalogs +393082db9 feat(subscription): add dedicated currentCSV field to subscription status +8cbefca49 Merge pull request #422 from njhale/fix-deployment-monitoring +0a9638ecb fix(operatorclient): remove wait for deployment rollout +9252bc43f updated prometheus csv according to the integration into openshift +b20aefa3b Merge pull request #420 from alecmerdler/ALM-681 +87ba2785a set 'status' on Subscription when 'spec.source' is invalid +9853c632e Merge pull request #421 from njhale/remove-deployment-cleanup +be2e26571 fix(e2e): remove deployment cleanup +4ec2ddca7 Merge pull request #415 from njhale/namespace-aware-plan-execution +55707f79c refactor(operatorclient): remove error return in deployment poll +9b4c22776 fix(operatorclient): return error from infinite deployment poll +db27ccc03 test(e2e): add wait for deletion during OLM cleanup +2f8fdcdb3 fix(catalog): ensure pre-existing check does not interfere with upgrades +e5ac72fe6 refactor(resolver): incorporate custom error type +0a494d098 feat(catalog): add namespace awareness to plan execution +ec98eeec2 feat(controllers): add custom error type for multiple existing CRD owners +312df3b1d Merge pull request #419 from njhale/catalog-status +e87bdedf3 style(operator_test): reorder import statements +7d90484e2 refactor(catalog): return early from sync catalog +50341cf08 test(e2e): add deferred global cleanup calls to subscription tests +4d64d0ae8 fix(e2e): move log after nil check +d5d2a3737 fix(ocs): reduce prometheus requested resources +f24fac129 fix(olm): restrict deployment watches to the watched namespaces of the operator +44ea5a68d feat(operators): log which queue items are coming from +167d97221 test(e2e): remove cleanupOLM calls +2d070fa91 refactor(catalog): only load in-mem when a change is detected +5dff27973 test(installplan): add helper functions for building test CSVs +c17e14f5a fix(catalog): correct sync logic to accept catalog spec changes +44a517c42 test(catalog): add wait for catalog sync to e2e tests +22dd40de6 refactor(catalog): enable status subresource +b8152490f test(catalog): add catalog source sync unit tests +09dded4b9 refactor(types): remove Hash field from ConfigMapResourceReference +a112bb36d feat(catalog): add catalog status block updates +f727f4d13 Merge pull request #418 from ecordell/prom-fixes +720a55b2b fix(e2e): re-enable prometheus test +9916a718a chore(rbac): update roles to include resources +6cdae285a chore(rbac): list out verbs in edit role +44d13ab8a update 0.6.0 release +160da9e80 fix(ocs): add securityContext to prometheus example +6eeb650a3 Merge pull request #417 from mvazquezc/master +70a244051 Fixes #416 +84153f348 chore(deploy): update 0.6.0 for okd +82513b3b2 fix(ocs): update prometheus operator +de1a4f994 Merge pull request #414 from pmorie/docs +29dbfe460 Make key resources linkable in philosophy doc +fc0d50908 Merge pull request #413 from ecordell/0.6.0 +5a2ae2f40 Merge pull request #402 from njhale/namespace-aware-resolution +6dd73f6af style(resolver): remove nesting from owner CSV selection logic +567b0dd62 refactor(catalog): remove map-based subscription caching +dbf4e61d6 chore(dep): re-vendor with dep stable +569e82e80 feat(resolver): add namespace and channel awareness +569489cb3 cut 0.6.0 +2ad0128b5 Merge pull request #404 from ecordell/catalog-updates +28142eb77 chore(docs): update docs for newer types +96e313f1e chore(ci): update catalognamespace for olm +259e1acbe fix(e2e): don't use vault in e2e tests +1d89136bf chore(ci): disable teamui deploy +de6a9916a chore(catalog): update prometheus deployment for 0.22.2 +050575729 fix(catalog_versions_test): test all releases +b0c8fc91b chore(deploy): remove tectonic-alm-operator +7de243e9c chore(deploy): remove old catalog entries +05e52524c Merge pull request #412 from ecordell/remove-vendor +35af681db chore(vendor): remove vendor directory +058f7ad44 Merge pull request #411 from ecordell/csv-fixes-plus-e2e-fixes +42db0fa23 fix(e2e): use fetchinstallplan in subscription tests +6904c8f3b chore(e2e): delete duplicated test from merging +534123bf9 refactor(opclient): remove fake operatorclient +9b226365c fix(olm): re-enable a requeue +b5f047e35 chore(fmt): order imports correctly +dd0fd247f fix(e2e): update fetchSubscription call to new use version +1cc429a27 feat(deploy): add OLM type access to aggregated cluster roles +a7c9d5fce fix(csv): delete csvs immediately +9b3324f7d feat(subscriptions): pick up installplan changes more quickly +f4a25dc0c chore(logs): add debug logs if item can't be found in index +0869ea288 fix(deploy): key the rolebinding to the namespace so that serviceaccount won't lose its access when a new binding is created +85bc154a4 fix(e2e): clear existing CSVs before running subscription tests +5a73be3a0 fix(installplan_e2e): add deferred cleanup calls to installplan e2e tests +fd693873a fix(subscription_e2e): ensure subscriptions are completely cleaned up +e3daf7743 fix(subscription_e2e): add check and wait for subscription status +192f37bda fix(cvs_e2e_test): move old serviceaccount existence check +0d992700e Merge pull request #408 from Jiri-Kremser/broken-link-architecture +55bd22037 wip(olm): fix leaks +e1d989a93 minor: broken link +0a4fa4d76 chore(api): update apps/v1beta2 to apps/v1 +7bce13d5b fix(subscriptions): don't update subscription when there are no status changes +d9bc7926d feat(olm): set up watches on deployments so that csv status can be updated more frequently +fb15243a9 chore(tests): remove old mock-based tests in favor of fakes +1b1508c77 chore(tests): rewrite TestIsBeingReplaced with fakes +77490abfb chore(tests): rewrite TestIsReplacing with fakes +db0fa43e9 fix(olm): add fixes for GC optimization +75127e586 wip(olm): add failing upgrade csv test +222e54012 Merge pull request #403 from ecordell/1.11-updates +53fe8844e Merge pull request #405 from alecmerdler/spec-descriptor-selector +d706d792e update 'urn:alm:descriptor:com.tectonic.ui:selector' to use GroupVersionKind +631759eb7 chore(deploy): update deployment resources to use apps/v1 +45acaeedc chore(api): bump deployments from apps/v1beta2 to apps/v1 +4345b4e28 Merge pull request #398 from ecordell/1.11-libs +2658e97ec chore(ocs): Update to prometheus 0.22.2 but disable e2e test +a051a62b4 feat(makefile): allow running a single e2e test from the make command +5b7dade3f chore(e2e): switch to using the versioned clients in e2e tests +d1ebf93a7 feat(api): migrate apis to common group and regen apis/clients +fc82cae77 fix(csv): update CatalogSource for 1.11 +07b1d1b01 fix(catalog): update Subscription control loops for 1.11 +188442aa5 fix(csv): update Subscription for 1.11 +529602d90 fix(catalogs): remove outdated EtcdCluster validation +cdaf4073c fix(catalog): update InstallPlan control loops for 1.11 +fe58b4c0a fix(catalogs): update catalog data to use ClusterServiceVersion +cff2f9a4a fix(ip): update InstallPlan for 1.11 +d7dfb072e fix(olm): update ClusterServiceVersion control loops for 1.11 +2ca630fde fix(csv): update ClusterServiceVersion for 1.11 +0757d12cd fix(build_local): don't start minikube if already running +d69715b41 fix(csv): k8sjson encoders don't properly omitempty on json.RawMessage serialization. +30473c953 fix(crds): update CRDs to validate in 1.11 (versions field now required) +5303271ad chore(codegen): update codegen for 1.11 +26f1fc06e chore(deps): update k8s libs to 1.11 versions +facde3cf4 Merge pull request #401 from njhale/verify-multi-source +b29b319eb chore(catalog_versions): remove extra lines in import +adbc87091 test(catalog_versions): add resolveCatalogs test for catlogs in each version +0d3c126da refactor(resolver): make resolved step logging more helpful +3e70e76cb Merge pull request #399 from alecmerdler/ALM-644 +a2a6a02ef add 'spec.sourceNamespace' to the Subscription CRD validation block +f72890f47 Merge pull request #397 from robszumski/access-docs +87a7cd43c Merge pull request #388 from ecordell/prometheus-0-22-0 +cdc506f5e Merge pull request #396 from njhale/multi-source-e2e +7ac344194 docs: add access control workflow +0b50c2154 test(installplan_e2e): change main package name to avoid conflicts +376439ebb style(catalog): add missing semicolon to log +c23d727f4 fix(catalog): remove required CRD existence check for service additions +6eb7fe69e test(installplan_e2e): add multi source install test +0c9b2e0fa test(util): add internal catalog source creation helper function +4e331b89f fix(ci): deploy files to ci cluster in order +e97fbf94d fix(makefile): fix run-local and run-local-shift +ea0930d5c fix(e2e): update prometheus serviceaccount +49d37c078 fix(make): fix local e2e +3e1b9c1ce fix(e2e): update e2e prometheus test for 0.22.0 +a1321109c fix(deploy): put prometheus in ocs catalog +c7bed1cb8 fix(ci): update ci to use replace +9e2c188d4 deploy/chart: bump prometheus to 0.22.1 +135e2efa5 feat(catalog_resources): add prometheus 0.22.0 +56e15b8b0 Merge pull request #392 from jsm84/master +cd72756cf Merge pull request #395 from ecordell/alecmerdler-openshift-ci +2a201af79 chore(ci): update gitlab-ci.yml from jsonnet +c25ab627d Merge pull request #394 from njhale/installplan-status-fix +bc80df8fd fix(installplan): type InstallPlan.Status.CatalogSources to []string for backwards compatibility +b11c289e5 Merge pull request #393 from alecmerdler/openshift-ci +17592da9c chore(ci): update gitlab-ci.yml from jsonnet +261e45475 need to use 'operator-lifecycle-manager' namespace but ffctl is broked +e415a10cd Merge pull request #386 from njhale/multi-source-resolution +e8c12e624 Merge pull request #390 from jzelinskie/depfix +453e1c592 fix(subscriptions_test): replace single source resolver with multi source +64fa9e875 refactor(resolver): accept prioritized list of source refs as a parameter +6473a9e2b refactor(catalog): change parameters of getPrefferedSourceKey to take a source snapshot +7534147ff fix(e2e-local): remove extra RBAC config on minikube start (default in newer kubeadm versions) +1e5eed308 fix(e2e): apply charts from templates directory +47265e610 refactor(InstallPlan): add source name and namespace to install plan custom resource +67cd39ab4 refactor(catalog): limit sources snapshot to global and install plan namespaces +6058d9e51 feat(catalog): add catalog and catalog namespace to install plan spec +4a58b08a0 feat(catalog): add helper method to get preferred source key from plan owning subscription +290cc908b feat(registry): add subscription key type +96fa0d51b test(resolve): decouple expected results from test input +ec8cad8d7 refactor(resolver): return used catalog sources slice from ResolveInstallPlan +c62647668 chore(registry): dedupe to in comment +ca85176e6 refactor(InstallPlan): use registry.SourceKey to keep track of used CatalogSources +2b2c51758 chore(.gitignore): remove vscode file exceptions +719d848c3 fix(resolver): set resolved csv namespace to plan namespace in MultiSourceResolver +ac2e9fe33 feat(catalog): use MultiSourceResolver in catalog operator +f18d1b3e3 test(resolver): add tests for MultiSourceResolver +2643b9903 refactor(catalog): add helper method for getting a sources snapshot +d0a068551 refactor(resolver): remove extra functions from DependencyResolver interface +0449c930d feat(resolver): add CatalogSourceNamespace field to StepResource struct +d020b84e9 Fix invalid `minishift start` option in install_local_shift.sh +b08a54bbe Merge pull request #381 from ecordell/0.5.0 +7c6d25f02 vendor: re-run `dep ensure` +6656c6ae8 Merge pull request #387 from njhale/fix-csv-namespace +17e627ca7 fix SingleSourceResolver to use plan namespace for resolved CSVs +f0814434c cut 0.5.0 release +f2a4d4e14 Merge pull request #385 from njhale/step-catalog-source +0995b5fa0 refactor catalogLabel to catalogLabelKey +ebf8f18f7 fix namespace used for CatalogSource lookup +fd59310cb refactor resolver to be in separate package +8638ba5e1 refactor interface method parameters +c759db72b fix remove .vscode/launch.json from .gitignore explicit include +9df2501ee fix remove .vscode/launch.json +476a9e8bd remove test for MultiDependencyResolver +509bb2b56 fix CatalogSourceStatus.ConfigMapResourceReference json struct tag spelling +03d5bd1a8 add test for step resource catalog source +56f03a242 add DependencyResolver interface and SingleSourceResolver implementation +3e383febf refactor interface method parameters +d643d0724 fix remove .vscode/launch.json from .gitignore explicit include +47dcd7d45 fix remove .vscode/launch.json +f876c89b7 remove test for MultiDependencyResolver +1fff51d79 fix CatalogSourceStatus.ConfigMapResourceReference json struct tag spelling +e1b91e17a add test for step resource catalog source +0f40860a8 add DependencyResolver interface and SingleSourceResolver implementation +009810605 Merge pull request #380 from alecmerdler/ALM-639 +45ca4486c add 'spec.catalogNamespace' field to Subscription-v1 +3c6e4ba00 Merge pull request #384 from alecmerdler/ci-openshift-fixed +f16a8eef9 fix catalog_namespace for deploying to OpenShift +65e7d3f31 Merge pull request #383 from alecmerdler/ci-openshift +15d8a6c2e Merge pull request #382 from aravindhp/master +8b1cf8b10 deploy to TeamUI's OpenShift cluster +1d29537bb fix(docs): correct spelling of philosopy.md +2ea88d2a9 feat(release): build a release package from a tag +7e69bb980 Merge pull request #377 from operator-framework/ecordell-patch-3 +3ab77867f fix(docs): typos in architecture.md +34faa5c50 Merge pull request #375 from ecordell/check-doubleowner +6d407d93a feat(olm-operator): prevent a CSV from installing if there is another CSV in the namespace that owns the same CRD, but isn't being replaced. +856037c28 Merge pull request #374 from fabiand/patch-1 +43b4897f7 Fix a small typo +11c8910f4 Merge pull request #361 from alecmerdler/ALM-581 +b2ac1856c add checks for runaway control loops in e2e tests +58d0e1862 Merge pull request #372 from ecordell/fix-coveragebuild +953e8cf0d fix(servicebroker): add main_test.go to servicebroker cmd +cd8d9ec75 Merge pull request #371 from ecordell/fix-makefile +714d75167 fix(make): fixes run-local and run-local-shift +ddd865b42 Merge pull request #365 from alecmerdler/ALM-593 +0f745670b fixed panic(err) calls +463a113ee Merge pull request #370 from ecordell/remove-tectonic-operators +11ab35f06 check upgrade path per package directory +d2aa0cd1f changed filepath for pragmas +f9d9892c6 remove testing.T from manifest validation files +3ad07e1f3 moved schema validation +1683df4b2 chore(deps): remove tectonic-operators as a dependency +efc318f8c feat(operatorclient): add minimal operatorclient types +07f41092e Merge pull request #367 from operator-framework/make-run-local +c73c02452 fix(make): set version var for run-local +3acb562cb Merge pull request #364 from alecmerdler/ALM-623 +a39f5051f make 'InstallPlanPhaseInstalling' come before 'InstallPlanPhaseRequiresApproval' +b7be2306f added docs for RequiresApproval phase +76a7c967d Merge pull request #363 from operator-framework/reame +5f750e8f1 readme: fix broken link to CSV example +053103a8a Merge pull request #362 from ecordell/catalog-fixes +e931a9a92 fix(catalog): catalogsources should only read from their configured namespace, not all namespaces +2acef658a fix(catalog): release memory after loading catalog +f1c2353ae Merge pull request #356 from ecordell/ansible +d30204a80 fix(ansible): make sure git submodules are checked out before ansible build +f4941de5d feat(build): add rhel build +4e807c874 chore(deploy): add openshift_ansible as a submodule in order to symlink lib_openshift and lib_utils +80d0373f3 chore(deploy): add ansible playbook for deploying OLM +5b5b35e9a Merge pull request #359 from ecordell/fix-uid +fafda6cc6 feat(ownerutil): update ownerutil to infer GVK for OLM types +7ad3a4671 fix(subscriptions): directly include apiversion/kind of created resource +d6c089ff9 fix(e2e): make e2e local scripts work again +0c6f9c77e Merge pull request #358 from aravindhp/patch-1 +5051d9fb2 Fix the deploy to kubernetes command in install.md +eb01e08e3 Merge pull request #357 from alecmerdler/ALM-601 +21c158eb6 do not update Subscription-v1 if nothing has changed +fd5b256c7 Merge pull request #354 from ecordell/metering +168d37f96 chore(deploy): add upstream release and deployment pipeline +4ce8a80ef chore(build): use helm to template the catalog files in +be81b22fd chore(deploy): which catalogs get included in a release is configurable +b329f3fb1 Merge pull request #349 from ericavonb/ALM-568/serviceclass-per-pkg +5ec07140d feat(servicebroker): list one serviceclass per package +fdf597a11 Merge pull request #352 from ecordell/vendor-deps +3d09ef271 fix(ci): codegen needs apimachinary to not be pruned +f9196a883 chore(deps): update servicebroker for newer servicebroker libs +28eed314a chore(deps): commit vendored dependencies so that project can be built by people without access to tectonic-operators +7bab5b6d6 Merge pull request #348 from ecordell/subscription-approvalmode +a954d2d34 fix(e2e): fix local e2e scripts +8a134eaff test(e2e): add e2e test for Subscription/installPlanApproval +4211c6a71 feat(subscription): installPlanApproval field +be842e599 Merge pull request #347 from alecmerdler/ALM-339 +dd41d1887 Merge pull request #346 from alecmerdler/ALM-567 +a258fd5d8 implement manual approval of install plans +6cb7b8bc8 strip Markdown from descriptions for OSB +f59daf7f4 Merge pull request #345 from ericavonb/ALM-538/listcatalog +7e8316a36 fix(servicebroker): reverse map check bool order +9cc1a2eb5 test(servicebroker): check validatation of broker api version endpoint +e1bcfa068 Merge pull request #344 from ecordell/osb-part2 +678f0a560 fix(apiserver): fixes rebase problems also removes the apiserver tests, which are empty +a3ed14d2b fix(apiserver): update imports +102aeabea fix(servicebroker/types): dedup description +ed955eef8 fix(servicebroker/types): set bindable to false on serviceplans +0d2a5198a fix(servicebroker/types): use link url for support url in serviceclasses +73b1cfecc fix(servicebroker): grab namespace from interface object +ed610876c chore(servicebroker): update types from broker libs +471be7531 feat(servicebroker): display icons and pretty names in catalog +50ba07844 fix(servicebroker/apiserver): use un-normalized CSV name +6941a6f1f temp(servicebroker/apiserver): log debug lines +117af7a36 wip(broker/sources): implement LastOperation handler logic +855cc3cfc Merge pull request #342 from ecordell/rebase-osb +b9c413639 fix(ci): fix e2e test runner +97c09a5b6 fix(makefile): add build-coverage command back for e2e testing +9ebe6f770 feat(ci): multi-stage builds and verify codegen and catalog during build +aed1cdc92 chore(ci): simplify container builds +71673e188 fix(makefile): fix release scripts +ec2c6cca9 fix(deploy): chart naming after rebase +91c8cd6f6 fix(makefile): support ocs and ccomponent catalogs +822d4e0da fix(makefile): always build targets so that dockerfile builds work +f7081f717 fix(broker): use updated imports for osb +a3a886ce8 fix(makefile): xargs working cross-platform +28e8af57c chore(deps): update lockfile +213233f22 chore(rename): fix path in catalog version tests +b50d813ec fix(Makefile): update makefile recipes for rearrangement +dfbcb7157 chore(servicebroker/apiserver): update broker interface types +897cc0060 chore(Makefile): add target to run e2e with minishift +8847db68a fix(deploy/chart/templates/01-alm-operator.serviceaccount): specify pullsecret +3a22e3bd4 rearrange(deploy/chart/templates): create secret before clusterservicebroker obj +5360b35e5 fix(.): update scripts with e2e dir move +90e10ab66 fix(Makefile): codegen clients correctly +09e797cfb chore(*): update github repo org +c2f775a94 chore(makefile): clean up build +d5ad6ed55 fix(Makefile): add '-' back to flag (rebase fix) +8ba65f256 feat(deploy): add servicebroker templates +88c782a69 feat(broker): add service broker service for alm +1967560ae fixup(api/client/util): return err instead of panicking +989f5c6a1 Merge pull request #341 from alecmerdler/teamui-host-var +7d925aeff use environment variable for TEAMUI_HOST +1c30ff285 Merge pull request #335 from alecmerdler/ALM-572 +e21ee7c07 Merge pull request #337 from alecmerdler/webhook-olm +3145b14b2 Merge pull request #340 from ecordell/recut-0.4.0 +9849ac381 Update manifests for 0.4.0 release +e4f41e039 Merge pull request #339 from ecordell/remove-pull-secret +183ee949f fix(catalog): pull secrets are no longer needed for vault and chargeback +1a11f6f6e use InstallCheckFailed instead of DependenciesConflict +a31f51028 s/ALM/OLM for Slack webhook +940e3ff5c Merge pull request #336 from wallyqs/patch-1 +63d9031b4 Update README.md +a4e256433 Merge pull request #334 from operator-framework/ecordell-patch-2 +9057ecfc1 Merge pull request #333 from operator-framework/ecordell-patch-1 +2099041d0 Update README.md +c570251ca Update architecture.md +6d863b2cd Merge pull request #332 from ecordell/renaming +08a80891e chore(rename): ALM -> OLM in design docs +6381cc736 Merge pull request #331 from ecordell/update-install +9fa313c0a Add simple install instructions for using a released OLM +de5bbc846 chore(rename): rename ALM -> OLM in install docs +eeabc9227 Remove unneeded install steps (minikube fix and pull secret) +fb86364a6 Merge pull request #330 from operator-framework/update-quay-repo +7e41d8f4c chore(rename): rename quay.io/coreos/alm -> quay.io/coreos/olm +e1ac9c4a0 Merge pull request #329 from operator-framework/robszumski-patch-1 +0070d819b readme: restrict SVG height +c898afe42 Merge pull request #328 from sichvoge/master +0dd62abb1 Merge pull request #327 from operator-framework/pipeline-status +3b19c2612 fix(ci): update paths in dockerfiles +6412c50cc added intro for framework +916ba2a5b chore(codegen): run codegen on renamed codebase +36176c6e1 chore(rename): rename alm -> operator-lifecycle-manager +5b40d9673 chore(ci): update ci to use new operator-lifecycle-manager repo +b9c0e32df Add pipeline status to readme +f09f63bae Merge pull request #326 from coreos/readme-update +66e226bbb Update readme +cf4f50a23 Merge pull request #325 from jzelinskie/coc +60ef57954 *: add code of conduct 🎉 +1b3927531 Merge pull request #322 from ecordell/v0.4.0 +a900e1e51 re-cut 0.4.0 +a7dff677f fix(e2e): same deployment install strategy shouldn't change label selectors, which are immutable +5c17f64cf fix(ci): better names for e2e test objects +260af5d52 fix(e2e): generate different label selectors for test deployments +a503a46b4 fix(e2e): use different csv names for each test case +c6de6e03e fix(ci): don't error if serviceaccount is already patched +2917401f0 fix(subscriptions): startingCSV is not required +5bc4fc0df fix(rename): coreos-inc -> coreos +8b31486e7 fix(ci): vendor in sanity check to remove codegen error +fabdd576e fix(e2e): use name of catalogsource instead of name of configmap +0bf38f34f fix(deploy): update x-operator version to one that supports CRs +0511a2124 fix(deploy): use DeleteAndRecreate strategy for CatalogSource updates +e798660fd fix(deploy): catalogsources should have different names +48e7a8cf1 fix(deploy): put catalogsources in catalog namespace, not hardcoded to tectonic system +71140acf8 remove generation of catalogsources from catalog/main +a4330ce8b write out both ocs and component catalogsources +897f7e02f update catalog version test to handle multiple catalogs +2617cfdbb split catalogs into OCS and cluster components, package 0.4.0 +a774a5a3c Merge pull request #323 from ericavonb/org-change +3ffce335c chore(Gopkg.lock): update dependencies +97f460edf chore(*): update github repo org +6e87311ab Merge pull request #321 from ecordell/review-docs +b81c38aa9 Review docs for outdated information +8f74697eb Merge pull request #315 from alecmerdler/hide-slack-url +58aeb1d02 Merge pull request #318 from ecordell/etcd +7ec83bf2c move Slack webhook URL to environment variable +4d240e48d catalog: update etcd-operator to 0.9.2 +3bf8c1810 Merge pull request #317 from ecordell/failfast-fix +3c0b23664 fix(ci): switch to short sha for naming +71c800252 fix(ci): update failfast namespace for new ci cluster +2232d43f3 Merge pull request #314 from alecmerdler/ALM-562 +c6a2bafd1 do not update Subscription-v1 if unmodified +791f1c214 Merge pull request #309 from alecmerdler/ALM-514 +75e7f7b6a Merge pull request #291 from jzelinskie/apache2 +332daf717 Merge pull request #312 from coreos/docker-login-ci +5b6e4b4b8 fix(ci): change $SHA8 gitlab var to new $CI_COMMIT_SHA +1c97e2502 fix(ci): update docker host path +3a4c13a88 add bill of materials +b32acbd28 Merge pull request #308 from alecmerdler/ALM-556 +65ab3c77d removed UICatalogEntry-v1 +f44e42a5c Merge pull request #304 from alecmerdler/ALM-517-again +f5d13283d added docs for Subscription control loop +df1dd4623 fix(e2e/subscription): update import paths +3d114cd40 chore(Makefile): clean up all test files +6e2925aa2 refactor(e2e/subscriptions): add cleanup fns +85c088cab test(e2e): test subscriptions control loops +f21f668b6 Merge pull request #305 from ericavonb/ci-namespace +f6dbb9c59 chore(.gitlab): use commit sha in ns +79746d284 Merge pull request #300 from alecmerdler/ALM-517 +b59d49cfa refactor Subscription control loop to only call Update() once +70e009236 Merge pull request #298 from alecmerdler/fix-slack-again +9af4fbe4b fix Slack notification +92cdd850c Merge pull request #297 from alecmerdler/fix-slack-webhook +5509ad892 fix Slack notification webhook in CI +bdb711983 Merge pull request #296 from alecmerdler/slack-webhook +b0aad99b9 send Slack update when deploying to Team UI cluster +429d1e2b2 Merge pull request #295 from alecmerdler/ALM-518 +74beda753 GitLab CI deploys to Team UI cluster watching all namespaces +c2772b214 Merge pull request #294 from alecmerdler/ALM-518 +50cf85768 modify GitLab CI to deploy master branch to Team UI cluster +1b4cd8bf3 Merge pull request #293 from alecmerdler/ALM-519 +c1da279ac fix example YAML +04805c98b Merge pull request #292 from alecmerdler/ALM-517 +63c74f24c fix subscriptions being stuck in UpgradePending state +1b3611100 add Apache 2.0 License +2593e41ca Merge pull request #290 from ericavonb/fixups +77b13702d chore(.gitignore): ignore all generated resources +e721e53ad Merge pull request #289 from alecmerdler/ALM-513 +a65cc4591 set Subscription 'status.state' +f417c4703 Merge pull request #286 from ecordell/update-deps +2a777a7b2 refactor(tests): split source and calculate coverage over non-generated code. +1c9cfd95e docs(development.md): encourage test running after dependency update +514948720 fix(ci): pull common variable out into vars.libsonnet +37bab8896 test(e2e): add coverage generation to e2e tests +dd28b65fb Merge pull request #287 from alecmerdler/ALM-310 +e26e6eb5f update ALM templates with correct JSON schema +4e45eee6b fix(tests): update tests to use the new client fakes +e3bc1546d refactor(clients): switch to using generated apiclients +10bcf45e0 feat(ci): add sanity check step which does basic verification before building the images +2dff2314a fix(ci): update fmt-ci to handle multiple files +ec5fe26d4 feat(ci): run verify-codegen and verify-catalog before building +92f479534 remove gocoverutil, go 1.10 coverage tools can aggregate coverage now +6aae532b6 switch to go 1.10 +7480a5a8d fix(e2e): fix invalid CSV in e2e test +e0ac387f0 fix(catalog_resources): update deployment specs for 1.9 +593a94bc3 fix(makefile): separate vet and docs testing +65046a066 fix(e2e): use newer apiversions +6da5d5969 Add $(DEP) as prereq to vendor make commands +4222a20ae Switch references from glide to dep +c292db210 Generate clients with code-generator +afe6cb041 Update api usage to 1.9 apis +daac0fbdf Update api usage for 1.9 +d92b7fcbc switch to k8s.io/code-generator +24e57a7f3 Switch to dep and update dependencies +01c4de0eb Merge pull request #281 from alecmerdler/ALM-462 +250f70471 fix subscription status +628febd16 Merge pull request #285 from ecordell/cut-0.3.1 +138d8d36d Merge pull request #283 from alecmerdler/ALM-397 +77a65bb9b add annotations for example custom resources to CSV +6f2c9ffd0 Merge pull request #284 from ecordell/update-install +cba3b5abb Cut 0.3.1 +afc94a115 Update install instructions and add a `make run-local-shift` command to run locally in minishift. +34dcafeb8 Merge pull request #282 from ecordell/fix-for-1.9 +60fc4bd6c Merge pull request #279 from ecordell/cut-0.3.0-2 +f7c0f56d9 cut 0.3.0-5 +a10cc2f6e update csv requirements +12fcc5b9b cut 0.3.0-4 +2dabeb696 cut 0.3.0-3 +3831ad9f4 Merge pull request #280 from ecordell/remove-vault-pod-status +8b3069d47 clean up during e2e tests +303dbfc7a fix(crds): nest csv, uice, sub, and installplan validation under "spec" +b45cf3bd0 Remove vault podstatus descriptor +118767c77 fix(crds): nest catalogsource validation under "spec" +842f1bd0e Merge pull request #278 from ecordell/cut-0.3.0-2 +8674c88ba Add prometheus 0.14.0 and update 0.3.0 release of alm +b18efb38f Merge pull request #275 from ecordell/ALM-415/label-csvs-with-catalog +b6beb807e feat(operators/catalog): label resolved CSVs and CRDs with the catalog source they come from +ea719b26e fix(operators/catalog): set phase to failed when resolution fails and enable the e2e test for it +333c43f24 Merge pull request #277 from hongchaodeng/up +8aa46d920 Merge pull request #276 from ecordell/orphaned-resources-csv-upgrade +7a730d80a Merge pull request #269 from ecordell/uicatalog-cleanup +9a0f720be hack(ownerutil): hardcode groupkindversion for ownerreferences to CSV +e35094d77 Merge pull request #271 from ecordell/csvs-stay-dead +bb4987dd2 refactor(uicatalogentry): minor renaming / refactoring +82c09aaa0 When a watched object is deleted, purge it from the queue +53cf3c410 e2e test for uicatalogentry updates and pruning +b70b9b9eb Prune old UICatalogEntries from the cluster on catalog sync +243b8ee35 catalog: update etcd-operator to 0.9.0 +0dacb994a fix(install/deployment): use ownerreferences when checking for SAs +8d532e499 Merge pull request #273 from ericavonb/ALM-463-installplan-spam +6dcca4ea5 fix(client/installplan): use correct resource name +f6c51b9cb Merge pull request #272 from alecmerdler/ALM-452 +047cd3215 catalog operator ensures labels on Subscriptions +cc4fbe914 Merge pull request #270 from ecordell/fix-update-frequency-csvs +1de8a3105 fix(alm/operator): don't update the status timestamp if we aren't transitioning +7885505d9 Merge pull request #268 from hasbro17/haseeb/update-catalog-vault-operator-0.1.9 +1d63245c7 catalog: update vault-operator to 0.1.9 +135396abf Merge pull request #263 from ecordell/fix-e2e-reporting +fcb548755 Fix chargeback e2e test +af30d23e8 Fix e2e test reporting in gitlab +877e5332b Merge pull request #266 from ecordell/update-0.3.0 +588109443 Update images for 0.3.0 +b4d6900ac Merge pull request #265 from ecordell/test-catalog-version-compatibility +735aa9a91 fix imports +1b67f2386 Merge pull request #264 from ecordell/test-catalog-version-compatibility +aa7e593f9 fix(catalog): add tests for compatibility between versions of the catalog configmap and fix the errors that the tests revealed +c30733a31 Merge pull request #261 from ecordell/0.3.0 +5e53f0ed3 cut 0.3.0 +acfa8cec5 Merge pull request #262 from alecmerdler/vault-ocs-label +2091d7314 add alm-catalog label to Vault CSV +dbfa09021 Merge pull request #260 from ecordell/fix-matchlabels +afa80c885 Revert changes to labels/match labels on the deployments +79b8e551c Merge pull request #259 from coreos-inc/HOTFIX/ericavonb/ALM-280/fix-subscriptions +5baff2c9e fix(pkg/client/installplan): only set name if provided +ea9e30d90 Merge pull request #258 from ecordell/fix-overloop-catalogsource +f47d734d6 fix(operators/catalog): don't update catalogsource status when processed +e63a22231 Merge pull request #257 from ecordell/fix-subscription-loop +cb3ca1579 fix(operators/catalog): don't share informers between installplan and subscriptions +6b5f84a7f Merge pull request #249 from chancez/add_chargeback_to_catalog +3539b245f Merge pull request #256 from coreos-inc/ericavonb/ALM-280/fix-subscriptions +7b5e7e9f5 pkg/registry: Update tests for Chargeback +2014e31d0 catalog_resources: Add Chargeback resources to catalog +751d48d9b fix(operators/catalog/subscription): specify csv in installplan (duh) +b956294d3 fix(apis/uicatalogentry,subscription): set list items to correct type +d26070076 Merge pull request #255 from ecordell/fix-uicatalogentries +2f82f3122 fix logs in e2e tests +6fd549df2 Add package loading to catalog directory loader (only used for tests) +6f8b2bfff Add additional logging to catalog loading +353ff363b Fix makefile build directive +6f78d53d4 Remove `replaces` from prometheus operator since we don't have an older version +4d481cb1a Merge pull request #254 from coreos-inc/ericavonb/ALM-280/fix-subscriptions +8e0d02cbf fix(apis/subscription): correct meta in List obj +32f98ac78 Merge pull request #253 from ecordell/fix-subscriptions +249cb27b9 fix(operators/catalog): use the right plural name to list subscriptions +53fc7c1d0 Merge pull request #252 from ecordell/fix-bad-merge +f0414c14a Switch from gomock to counterfeiter and update tests +32ffa33f9 Merge pull request #233 from coreos-inc/ericavonb/ALM-280/subscriptions +f584f78c7 Merge pull request #251 from ecordell/packages-in-uicatalogentries +42ebb6277 feat(operators/catalog): standardize to UTC time +cc8db4627 Add package metadata to UICatalogEntries +c9633339e fixup(apis/subscription): use the sane json tag +03555deb1 Merge pull request #250 from coreos-inc/ecordell-patch-1 +9fa0a5851 Update philosopy.md +71688e824 chore(zz_generated.mock*): regenerate code for k8s types +2c11385e4 chore(.gitlab-ci): ignore not found errors on delete +f4e9bb264 feat(operators/catalog/subscription): use startcsv if specified +67df0abf8 fixup(subscriptions): use CurrentCSV in status block +f3de8d35d test(operators/catalog/subscriptions): test lastupdate times +fe88b45cd fix(operator/catalog/operator): ensure safe concurrent map access +62d093947 Merge pull request #248 from hongchaodeng/up +a185673b5 fix(operator/catalog/operator): update queueinformer fun signature +dabf649e6 fixup(operators/catalog/subscription): store apiversion/kind info +5f962f041 test(operators/catalog/subscriptions): ensure installplan existence checked +331522962 fixup(subscriptions): check for installplan existance +402637b34 fixup(operators/catalog/subscriptions): regen mocks and such +f894bb664 chore(operators/catalog): generate mock catalog +a2c3662ef test(operators/catalog/subscriptions): add unit tests +b567a24dc fix(operators/catalog/subscriptions): save subscription +7a42bf1f4 chore(operators/catalog): generate mock clients for subscription tests +936b01de6 chore(**/zz_generated.mock_*): update mocks +6e61c85c9 feat(operators/catalog/subscriptions): add subscription ctrl loop +216f10206 feat(subscription): save install reference +75ad7b356 feat(pkg/client/installplan): add create method +0ddaf47cf feat(pkg/client/subscription): wrap subscription ops in client +58645801e feat(apis/subscription): add subscription crd back in +2f86b6f39 catalog: update etcd-operator to 0.8.3 +0256ecc54 Merge pull request #247 from ecordell/resync +2f33d3268 e2e: Load catalog entries from the in-cluster catalog and verify they install +9f7f18051 Requeue more often when we know we can shortcut a resync +290a00f28 Merge pull request #246 from ecordell/debugging-docs +3695458cf Merge pull request #188 from ecordell/GC-CSVs +68f7ab026 Add a doc on tracing errors through from ALM resources +b099acc14 Merge pull request #245 from hongchaodeng/up +bdfa7f0e1 Minor renaming / refactoring +b0cecb698 Refactor e2e test utils +cbdf8579c Port drive design docs to the repo +55cf862f5 Add docs on GCing and the new packaging format +428cede68 catalog: update etcd-operator 0.8.2 and vault-operator 0.1.8 +3d84b8786 Fix e2e tests +f9ec5b11e Only query for csvsInNamespace once per loop +4770ac7ad Add requeuing logic to simplify state handling +7914ea6b3 e2e tests for CSV upgrades +c74887f7b Clean up old CSVs if they're successfully replaced. +c7067efb0 Don't queue up delete events (we take no actions for any of them) +4ace6f49a Merge pull request #243 from ecordell/update-vault-etcd +b9cc6ef7f Update packaging for vault and etcd to use the new package format +5ff9c26d6 catalog_resources: add etcd backup/restore operator and bump up etcd/vault operator version +05fa73b64 Merge pull request #242 from josephschorr/joseph.schorr/ALM-394/package-crd +f0ac71ce3 Implement ListLatestCSVsForCRD, which finds the latest CSV holding a CRD, per channel +23de2bafd Merge pull request #238 from josephschorr/joseph.schorr/ALM-394/channel +8641ec583 Add concept of packages to catalog, for tracking of services at a grouped level +11817365e Merge pull request #240 from alecmerdler/ALM-412 +817290acd better description for EtcdCluster in Vault CSV to drive UI +049c95247 Merge pull request #239 from alecmerdler/etcd-resource-requirements +26d56074c add spec descriptor for ResourceRequirements for etcd +ddcf8ac5f Merge pull request #237 from alecmerdler/prometheus-resource-requirements +fa6f10b59 modify spec descriptors for Prometheus OCS +824c629a8 Merge pull request #235 from ecordell/fix-master-e2e +e70ebc763 Use generate unique name for e2e job +d44d23df7 Merge pull request #234 from josephschorr/joseph.schorr/ALM-392/latest-lookup +b08f555c7 Rename and export FindReplacementCSVForName method +406668fab Merge pull request #232 from josephschorr/joseph.schorr/ALM-392/catalog-lookup +a8b7d23c6 Remove references to Service Name in catalog +bec809cc4 Merge pull request #225 from ecordell/cd-to-separate-cluster +94c0b2930 Merge pull request #231 from josephschorr/joseph.schorr/ALM-392/catalog-sort +6e76a45fe Merge pull request #230 from alecmerdler/ALM-395 +ab2c65122 Cleanup Catalog interface in prep for fixing how we handle service names +0a66aee97 Don't use helm upgrade +c99e53ddf add labels to OCS catalog ClusterServiceVersion templates +5408b2e77 Move all scripts to /scripts +5d6d6f134 Seperate update-catalog into its own script +4c7502bdc Update e2e tests to run in separate cluster +c5b1d2db9 CD to separate cluster +6c5dd48ec Merge pull request #226 from jzelinskie/tectonic-visibility +9a01b400a add visibility annotation to catalog resources +d5049fa56 move build catalog script to hack/ +49f7593b8 fix whitespace stripping from configmap generation +2eb49ee52 Merge pull request #223 from jzelinskie/lithium-x-operator +f630af96d deploy/TAO: use stable release of x-operator +a8c2a814f Merge pull request #224 from alecmerdler/etcd-csv-servicename +e002a5b9e update EtcdCluster s/service/serviceName +6a7996901 Merge pull request #222 from coreos-inc/chore/ericavonb/clean-up-artifacts +2a0bf3cc7 chore(.gitignore): ignore test artifacts +bc9a49f45 chore(Makefile): remove vendor update from e2e-local +572b8fc62 style(buiild_catalog_configmap.sh): trim trailing whitespace +6c4d6077d test(e2e): test catalog entries visibility set correctly +b7af133ff Merge pull request #217 from coreos-inc/ericavonb/ALM-347/label-uice-visibility +62e196288 style(catalog_resources): add newline at end of file +14d01bf07 feat(catalog/uicatalogentries): add label via csv annotation for visiblity +55ee69b91 Merge pull request #213 from dcondomitti/e2e-backend-1 +6e4520468 Consolidate vault operator version references +9aa3216b9 Merge pull request #220 from coreos-inc/fix-cp +461b9e3a4 fix(package-release): use gnu compatible cp options +0be59144f Add errors package to vendored dependencies +5e73bef6c Add readme for tests +126917d77 Add note for running single test +b360fe530 Add test ensuring Vault cluster is created with etcd pods +b85e8b968 Cleanup +14e18c4ea Add failed InstallPlan phase and skip test for it +301a44bfd Refactor InstallPlan fetching and allow passing an anonymous checker function +0793b6146 Add test for creating InstallPlans with invalid CSV names +f587bd2db Add test for creating InstallPlans with invalid CSV names without a Failed plan state +ae1f1716d Add test for creating InstallPlans from UICatalogEntry list +ccdf79627 Adds test for expected UICatalogEntries +55bfd5824 Add the ability to run a single test +e68c42720 Merge pull request #219 from ecordell/containerized-e2e +e8fa1278e Tag e2e test container with latest when master builds +97d44bc31 Take $NAMESPACE as an argument for updating the catalog +715202dbd Put jq script for convert to tap format into a separate file +d99da25c6 Containerize e2e testing and output TAP format +87bef05ef Merge pull request #216 from robszumski/fix-list +324022bac catalog: fix inconsistent header size +9de742bc4 catalog: fix markdown formatting/rendering +12abca115 Merge pull request #215 from hhoover/testmanualapproval +478bb1ee4 [e2e] Add a test for InstallPlans with manual approval +91b819803 Merge pull request #214 from ecordell/0.2.1 +df7abf39d Release alm 0.2.1 +cec6e9c1f Merge pull request #212 from dcondomitti/test_bash_fix +7991570bc Fix parameter count comparisons +542650a3f Merge pull request #211 from ecordell/bump-vault +3ee73d9a9 Bump vault OCS version +0549b28a1 Merge pull request #210 from ecordell/remove-alpha +8075158e9 remove alpha files +eba63db69 Merge pull request #193 from ecordell/release-packaging +9eaa5404c Merge pull request #209 from jzelinskie/fix-source-list +7e3223c1f operators/catalog: only add catalogsources once +51716139b Add docs for packaging +e8e0b0c30 Fix catalog resource tests and remove samples +e1a5b8ebc Add packaging script to generate x-operator manifests +03a1a9d1c rename chart directory to "chart" +3bd1252af Merge pull request #208 from ecordell/update-0-2-0 +6814bc295 Update 0.2.0 manifests +20f6bbc81 Merge pull request #207 from ecordell/update-0-2-0 +d20dbd98a Update etcd-operator +5a3c2fcaa Merge pull request #206 from ecordell/update-0-2-0 +48485c1c6 Update alm versions in 0.2.0 release +a644a04e0 Merge pull request #205 from jzelinskie/add-type +b45efefee Merge pull request #204 from ecordell/ALM-268/latest-catalog-versions +53d5e230f operators/catalog: add Type field to copied Secret +99ba86547 Update etcd and prometheus to latest operator versions +8daa2d8a3 Merge pull request #203 from alecmerdler/update-vault +9155159a8 update Vault OCS SHA w/ make update-catalog +1f521ad59 Merge pull request #202 from alecmerdler/update-catalog-resources +6c3738a54 run 'make update-catalog' for ALM-316 +05d807ab4 Merge pull request #201 from alecmerdler/vault-resources +044a21808 reorder CRD resources to correctly match ownerrefs +e4da75fcf Merge pull request #200 from alecmerdler/ALM-316-codegen +f3f3c8737 run codegen for ALM-316 +d12018e8a Merge pull request #198 from alecmerdler/ALM-316 +7ea21a602 add resources to Operator CSVs to complete the ownerref chain +ee27f503e add 'resources' block to ClusterServiceVersion types +6dba184a0 Merge pull request #195 from ecordell/remove-catalogsource-cr +311e3a139 Merge pull request #197 from jzelinskie/bump-ops +51042fe05 tectonic-alm-operator: bump operator SHAs +789ffa735 Merge pull request #196 from jzelinskie/cp-secret +c7b61f856 operators/catalog: only copy secret data +39d358c86 Merge pull request #194 from jakedt/ohtwozero +de5d5b387 Update the OCS to pick up the latest changes +6cbf8ab64 Fix the defective CSV schema +4afd9d27e Fix up the alm_resources install directory +55a0feb65 Update manifests for v0.2.0. +f8eca24b4 Remove catalogsource cr from helm chart (catalog creates it on start) +de0e1b25c Copy over the resource for the 0.1.2 release and renumber +7bfdabbf9 Merge pull request #189 from jzelinskie/ip-secret +4c0e33bb8 Don't use full apiversion as resource name in CSV client +e644327b1 Remove incomplete e2e test +1f9115a39 Fix nil pointer error in CatalogSourceClient +44e32a2c4 Add catalog source to helm chart +d1068f851 Merge branch 'ip-secret' of github.com:jzelinskie/alm into jzelinskie-ip-secret +9b629a516 Merge pull request #175 from alecmerdler/vault-operator-update +46fb2d0bb Update OCS configmap +7fd9a5e88 Merge branch 'vault-operator-update' of github.com:alecmerdler/alm into alecmerdler-vault-operator-update +337723789 update Vault ClusterServiceVersion +841314c9c helm: add configmap +d9d9f4553 glide: bump lock file +bb2b24729 install: add CatalogSource CRD +503487dbb Merge pull request #191 from alecmerdler/catalogsource-configmap +66a8e7888 cmd/catalog: bootstrap OCS catalog +bba0cde5e for posterity +a1141f55b Merge pull request #178 from ecordell/ALM-308/csv-replaces +893d5ee01 Refactor install strategy deployment check +2893e4720 Merge pull request #190 from josephschorr/joseph.schorr/ALM-311/resources +d98d9c9c5 Add resources blocks for the CRDs defined in the OCS +ab7464b58 CSV upgrades: look for deployments by name, upgrade any with the same name in the new CSV, delete any that are in the old but not the new, create any that are in the new but not the old. +58678730b operators/catalog: rename aceClient uiceClient +ef8d93ee7 feat(*): specify objectmeta for CSV to replace +7ccbcaa82 test(pkg/client/deployment): add serviceaccount tests +18f91f980 refactor(pkg/client/deployment): use operator-client service account fns directly +ad1987618 operators/catalog: fix grammar in comments +ee7efb253 operators/catalog: support secrets in InstallPlans +187f38542 Merge pull request #187 from jakedt/renameace +8e99876c2 Properly label all resources that will be managed by x-operator +a5c2565eb Prepare test cluster with CatalogSource CRD +fb4c1bc25 Rename AlphaCatalogEntry to UICatalogEntry +05a7c746a Fixes for the Catalog configmap generator +7b3e28dff Merge pull request #185 from jakedt/csclient +c90fcd264 Add the OCS catalog as a ConfigMap +a660e8c0e Fix typo in CSV schema +a505195bd Merge pull request #181 from jzelinskie/catentries +5bda1381d operators/catalog: return error instead of fatal +c8746426e Merge pull request #186 from alecmerdler/prometheus-spec-descriptors +a0cca6078 fix Prometheus specDescriptors +c34cdf663 operators/catalog: init CatalogSource control loop +f11cb1ade Merge pull request #183 from jakedt/csclient +fc5b81ee2 Merge pull request #184 from robszumski/link-to-docs +4fa118562 Add a config map loader for catalog sources +ff5b90a13 catalog: link to OCS user docs +eea8ea28a Merge pull request #182 from robszumski/update-desc +dca4f406d catalog: beta -> alpha +69f9a51a1 catalog: update OCS descriptions +f67cc65cd Merge pull request #179 from alecmerdler/prometheus-spec-descriptors +37ddb3851 add more spec descriptors for Prometheus CRDs +a626be6b1 Merge pull request #177 from josephschorr/prom-service-account +17457cd9e Merge pull request #176 from jakedt/csclient +1cd9b1ee1 Update prometheusoperator.clusterserviceversion.yaml +a0b03ff97 Add prometheus role +51fa6dd49 Add a catalogsource client with create and update function +797f2c294 Tiny fix to use a const to set the CSV CRD name +5cd9318e4 Remove URL from catalogsource CRD until we have a remote catalog type +84bf532c6 Merge pull request #172 from ecordell/e2e-testing-harness +6b0e966fc Set catalog namespace when deploying for preview +da41202d1 Fix runtime panic due to client-go changes in new operator-client version +25d24dad5 Support both kube-1.7 and kube-1.8 in deploy charts +23a1c50fe Update to tectonic-operators +8995af638 Throw error when validating resources if asked to validate a kind we don't handle +8a3303352 Add local e2e testing scripts and an example e2e test +e8c2a217a chart: Remove unused ClusterRole and make catalog namespace configurable +36dfc9f08 Refactor installplan name into constant +2e9649597 Merge pull request #173 from ecordell/fix-catalog-resources +a7cd4c6b4 Update all catalog resources with the new CSV format +97dda8d93 Merge pull request #174 from coreos-inc/ericavonb/ALM-307/deployment-compare +9b80d3fce fix(pkg/install/deployment): compare deps by name/ownerref only +61aff8f26 Merge pull request #171 from coreos-inc/fix-error-returned +4ccac1dd8 Merge pull request #170 from coreos-inc/prom-status-spec +ef71a168c fix(pkg/operators/alm/operator): put correct error in status on install failure +e6399bab2 Add cluster size status descriptor to prometheus +237990a9f Merge pull request #162 from coreos-inc/ericavonb/ALM-268/operator-upgrades +6d4798fcc test(pkg/install/deployment): create suite of table tests +a42dbf0c8 test(pkg/install/deployment): make more explicit tests +b4bde65d3 refactor(pkg/install/deployment): break up install function +df3a5f855 fix(pkg/install): use Create*OrUpdate*Deployment +12475d0dd style(pkg/install/deployment_test): remove unnecessary struct init +5f0a9199e refactor(pkg/install/deployment): use semantic comparision +d05e18b69 fix(pkg/client/deployment): use cascading delete for deployments +92376d704 style(pkg/client/deployment): add newline b/w functions +3915349e7 hack(install/deployment): make current tests for dep updates pass +9a2572b86 fix(install/deployment_test): use correct type in array +fd15f84da feat(install/deployment): create or update or delete deployments +650310df4 feat(install/deployment): check deployments installed by name/spec +217a408cf feat(client/deployment_install): create OR update deployment by name +011792069 feat(install/deployment): create consistent dep names +b2d0f201e Merge pull request #168 from jzelinskie/pull-secret +606dbbc2e catalogsource: add metadata fields +eadf663db catalogsource: add omitempty tags +d2e3fc60b installplan: add catalogSources to status +b6453006c catalog: init ocs catalog source resource +a998f80f6 catalogsource: add k8s interface codegen +ccaf36d2a init catalogsource type +8a8c8903c Merge pull request #167 from alecmerdler/ALM-293 +1297eda32 remove placeholder statusDescriptors +18862579e Merge pull request #166 from coreos-inc/update-app-version +6480e9998 Update appversion.yaml +9e2965186 Merge pull request #165 from jzelinskie/0-1-2 +4207407cd TAO: README w/ tectonic-operators build instructions +cadcfb152 tectonic-alm-operator: bump operator image SHAs +8db996403 tectonic-alm-operator: copy v0.1.1 to v0.1.2 +68a58b747 Merge pull request #164 from ecordell/fix-namespaces +db1469644 Swap namespace/name in annotation so that they match the env vars +5e399a100 Merge pull request #161 from alecmerdler/ALM-290 +4fd53e65a add version to deployment ownerReference +165513979 Merge pull request #158 from jzelinskie/alpha +7bd20e2b5 alpha: explicitly pass manifests directory +52f2803a0 x-operator: build image based on alpine x-operator +5b1a33fa6 x-operator: fix CSV CRD schema in v0.1.1 manifests +d5ad65dd2 Merge pull request #159 from josephschorr/fix-tooling-and-docs +c46680642 Fix generate-mock-client to generate from/into the pkg directory +eb7f330c1 Add missing dependency tools to the DEVELOPMENT file +d65acfda5 alpha: bump v0.1.1 +b8850478f Merge pull request #156 from dgonyeo/master +9188f4de9 alpha: init +01cb6b3e2 deploy: cut v0.1.1 tectonic-alm-operator +ce8d1fd33 deploy: copy v0.1.0 manifests to v0.1.1 +6fb77bedd pkg/catalog/directory_loader.go: skip hidden nodes +1a34120ff Merge pull request #157 from coreos-inc/ericavonb/ALM-256/annotate-namespaces +67e4caeeb style(cmd/alm): format usage string on flag better +c45c3e2b7 Merge pull request #150 from coreos-inc/ericavonb/ALM-256/annotate-namespaces +f4d1a35af Merge pull request #155 from alecmerdler/empty-csv-icon +a103f14ab refactor(alm/operator): clarify watched namespaces +83283061e fix(alm/operator): use non-wrapped client +76099de61 fix(Makefile): make 'all' the default target +1720f1573 refactor(alm): pass in annotations from main +15bdb2549 style(alm/operator): simplify variable name +6afd3cafb style(alm/operator): rename function args +25f4ec424 fix(alm/operator): watch all namespaces if none provided +518f5beb4 fix+refactor(pkg/operators/alm): watch specific namespaces only +d493055a1 feat(pkg/annotator,pkg/operators/alm): add control loop for annotating namespaces +9d3c44cd7 rearrange(pkg/annotater->pkg/annotator): spell annotator correctly +e6ece3fd9 allow icon to be empty in CSV +dc92a7ec1 Merge pull request #154 from coreos-inc/ericavonb/fixup/codegen-csvs +3685e3b3f chore(apis/csv): regenerate api objects +77a4efe7d Merge pull request #153 from ecordell/fix-csv +c4263dc7e Fixes clusterserviceversion schema +cb7a85123 Merge pull request #148 from jzelinskie/docs-reboot +06f528b0d docs/architecture: add control loop details +389f58ec8 Merge pull request #152 from coreos-inc/rm-pull-secret +5e27c8a59 docs/install: remove coreos-pull-secret +fee3b0ddb Merge pull request #151 from josephschorr/console-guide +220c0342e Update install docs for the cut branch of Console +96b736d7d Merge pull request #149 from alecmerdler/spec-descriptors +c8adf0e65 add SpecDescriptors to ClusterServiceVersion +61c761acf Merge pull request #145 from jakedt/xoperator +9ffa4c0d1 Add the required resources to let x-operator install ALM in minikube +3136f0081 Add a specialization of the x-operator for ALM +3b2758751 Merge pull request #147 from jzelinskie/coverage-badge +2c91aadf3 docs/design: add manual install stub +878df9f5d docs/design: add architecture doc and fix readme +0bd266438 docs/design: delete stale design docs +f4a9c0061 docs/design: delete old mocks +66e425a02 README: add quay badge +ea1f12665 Merge pull request #134 from coreos-inc/ericavonb/ALM-212/installplan-status +335619cb1 style(*): alias core/v1 import everywhere as corev1 +4fa080932 Merge pull request #146 from ericchiang/readme-link-fix +e038534b9 README: fix install link and JIRA link +9952d4569 refactor(installplan): abstract away conditions array in status +67c247bc0 style(catalog): use consistent import names +810f34129 test(pkg/apis/installplan/v1alpha1/types): test setting conditions in status +477bca533 refactor(pkg/operators/catalog): explicitly switch on err to set conditions +8c0aed101 chore(apis/installplan/v1alpha1/types): use conditions instead of phase in status +b1d637171 Merge pull request #143 from ecordell/test-catalog-resources +4a5e04fc8 Test our catalog resources for consistency +cb1f07b7d Merge pull request #142 from josephschorr/joseph.schorr/ALM-248/vault-csv +c01f977ea Adjust CSV status descriptors for Vault to reflect new status block +6dcae0af5 Merge pull request #141 from ecordell/update-package +55b62a8b7 Update alm/catalog images in install resources +98c7b0a51 Merge pull request #140 from ecordell/unit-tests +ac53025c3 Remove commented code +53e2b814e Fix namespace labelling bug +92879d724 Move code into /pkg and create coverage report +987afaed8 Add more unit tests +462a147e1 Merge pull request #138 from josephschorr/joseph.schorr/ALM-228/short-names +01583dba0 Add various shortNames to the various CRDs +dc681f98f Merge pull request #139 from josephschorr/joseph.schorr/ALM-202/proper-contact-info +ee4d755b9 Change maintainers and add useful links to our CSVs +df5fb769f Merge pull request #137 from josephschorr/joseph.schorr/ALM-248/fix-csvs +eb3669ae5 Update etcd Cluster CSV to have it display real status information +bdc2e42f5 Merge pull request #136 from alecmerdler/wrong-alertmanager-crd +b460d91d2 Add "coverage" (html) and "cover" (cli) commands, update to exclude mocks +90204948e spellcheck +b6c40ce67 Merge pull request #135 from ecordell/fix-catalog +757a28ae6 Fix catalog resources +a82cc1d04 Merge pull request #132 from ecordell/unit-test-install-strategy +58df3f0fb Merge pull request #133 from ecordell/ALM-226/annotate-namespaces +a9441b778 Refactor deployment strategy client + naming fixes +04006ca64 Switch to patch for updating namespace +f55998e70 Annotate namespaces on ALM operator start +76e2d4f14 Deploy install strategy: Add tests for error cases +23831465c Add tests for deployment install strategy with role generation +5f702eb13 Refactor install strategies +b0d6fb376 Merge pull request #128 from jzelinskie/ip-test2 +811cff1d5 Merge pull request #131 from ecordell/ALM-211/more-crd-info +2e71fe157 apis/installplan: test JSON manifest on StepRes +00e457085 operators/catalog: test creation of dependent CRDs +af1d33f59 csv/customresourcedefinitions: add version and kind +b7c8fe2ab Merge pull request #127 from coreos-inc/ericavonb/ALM-179/clean-up +44008212e test(client/alphacatalogentry): refactor tests into table fmt +3bebeae20 fix(apis/clusterserviceversion): correct json tag +8dca0c6c4 Merge pull request #130 from ecordell/update-images +ab1baaa76 wip +e1260daa4 Update alm and catalog images to latest +6ad416d9d test(client/alphacatalogclient): more thoroughly test update cases +c8d3f9b2c test(client/alphacatalogentry): test error case +62557efb0 test(client/alphacatalogentry): test upsert behavior +51a7c34bf test(client/alphacatalogentry): add test machinery +370c10ba4 operators/catalog: s/CreatePlan/ResolvePlan +143ba6991 apis/csv: fix nondeterminism in GetAllCRDDescs +85f17ae6b Merge pull request #124 from ecordell/ALM-190/recreate-missing-resources-csv +7af7f6c30 operators/catalog: refactor and table-testify +6e9da6a37 apis/installplan: add StepResource constructors +91debfc17 apis/csv: rename GetAllCrds and table test +b86464ebb catalog: resources should use correct sha256 image names +9c9c7097f alm/operator: Add a test for transitioning to pending if component goes unhealthy +14370a1d6 alm/operator: check if resource has gone missing and replace it if so +03e41a2da Merge pull request #126 from ecordell/pull-secret-clean +98891186b remove pull secret from install +c457adbb6 Merge pull request #125 from coreos-inc/ericavonb/ALM-179/clean-up +5dec900e0 Merge pull request #123 from ecordell/update-catalog +b45019ef7 fix(catalog/alphacatalogentries): set sync status correctly +184d14ff6 test(catalog): test store sync +9f3579e3a Merge pull request #118 from coreos-inc/robszumski-patch-1 +f95121062 Merge pull request #121 from ecordell/ALM-193/gc-rbac +0e96b11d9 Update etcd and vault to latest releases +e68b22415 Merge pull request #120 from ecordell/ALM-196/omittempty +4cfe1e0f4 Merge pull request #122 from coreos-inc/ericavonb/ALM-176/idempotent-aces +37af472a0 fix(client/alphacatalogentry): use put not patch +86fa7cc00 doc(catalog): add debug lines +23cff0795 style(client/alphaservicecatalog): remove nested ifs +77780f336 feat(client/alphacatalogentry): patch existing catalogentries +1bd9c3d6d WIP +494096e2d refactor(cmd/catalog/main): clean up file +f36488533 Set ownerreferences on all objects created from install strategy +273c51929 Add omittempty to fields on CSV +fb8ae2e4a Update install.md +2c65697f0 Merge pull request #117 from ecordell/local-install +8e1cb54b7 Install instructions for ALM + Bridge locally with minikube +c60fcfe88 Merge pull request #113 from ecordell/update-catalog-labeling +c1af2910d Add serviceaccount for vault +b2b23fd11 (temporarily) use dev versions of vault and etcd operator +77875e693 Update catalog resource labelling +e5b72c9a9 Merge pull request #115 from jzelinskie/ip-test +4f244c99d Merge pull request #112 from ecordell/add-coverage +7712ad1e3 Merge pull request #111 from ecordell/update-install-manifests +4aa8a32b7 apis/csv: make OwnsCRD a CSV method +e39f22265 operators/catalog: decouple phases from logic +872aab831 queueinformer: move MockListWatcher +1abd54a26 operators/catalog: table-driven csvOwnsCRD test +5297b6760 Add command for generating coverage report +2a1f47933 Update install instructions +b88d29635 Update rendered yamls for installation +35663cbee Merge pull request #109 from ecordell/prometheus-working +9d67f083f Update prometheus defintions +c0f43fcb3 Merge pull request #110 from coreos-inc/ericavonb/quick-doc-fix +2fc8a8741 doc(control-loops): update CRD name to InstallPlan +68a1ff41a Merge pull request #108 from ecordell/alpha-catalog-and-bugfixes +693287b78 Update prometheus +e9b809b3e Better naming and log levels +82302814c Update prometheus CSV to 0.14.0 +9ac84d5fa InstallPlanList should be a list of InstallPlans, not InstallPlanSpecs +aa3b5a71f wait for caches to sync before processing queue +68379bf2c Prometheus CSV should use the same serviceaccount in permissions and deployment +81e203cb5 Better log messages on catalog operator +d4cbbdedd Add entry matcher for alphacatalogentry client tests +120908d36 Restore alphacatalogentry test +1e13cf7bf Switch to log.Fatalf +bf13acc1b Update vault CSV to point to latest version, and use coreos-pull-secret +5a314066a Fix operator tests +eb2195549 Ignore if alphacatalogentry exists +5f755525d If AlphaCatalogEntry exists, update with a put +a229712a9 re-enable alphacatalogentry generation +eec650218 Installplan should resolve to objects in the same namespace +304622e68 Serialize resolved resources as json +c24aa8381 Fix operator loop +561a8cb4c Add logging to installplan resolution +56ebf9d21 Add more logging to queueinformer +8820c18c1 Add more logging to catalog operator +a29688d29 Update installplan types +415567ead don't generate alphacatalogentries for now +820dde7a6 Ignore if catalog entries exist +62ab7ff16 Delete/recreate alphacatalog entries +1d8e60836 Update even if there's a transition error +9b511d237 Patch don't put +1d6fc4fd9 Set initial phase to planning on installplan +bef73f951 Fix alphacatalogentry api calls +e621d84d3 Install alphacatalogentries into configured namespace +3aeb6c346 Add logging to alphacatalogclient +c4654c533 Return early if no error creating resources +39534c680 create AlphaCatalogEntry if it doesn't exist +a32cd932b Update catalog resources for self-consistancy +228c57389 Add more descriptive errors +df31254be add catalog files to container +33e26a10a catalog: more logging +8a5047640 Load catalog resources into cluster as AlphaCatalogEntries +061616272 Create alphacatalogentry on deploy +94d474ae2 Merge pull request #103 from coreos-inc/ericavonb/ALM-124/service-catalog/ALM-173/alphacatalogentries +35222264e Fix vet error +460703c1a test(operators/catalog): add ListServices method to test impl of interface +dc117bbc2 test(catalog/alphacatalogentries): fix test mocks +bce5c5c18 fix(catalog/alphacatalogentries): correct pt/receiver types' +dff6d6db9 test(alphacatalogentries): test catalog sync +aed9b2f2f chore(mock_alphacatalogentry_client): generate mock +6a442d511 feat(catalog,client/alphacatalogentry): sync catalog to CRs functionality +5d11423bd feat(catalog/types,mem): add method on interface for listing all services +76f465f2b Merge pull request #102 from jzelinskie/installinstallplan +274fb8d0d operators/catalog: add multi-source TODO +8363ffae3 operators/catalog: transition to install phase +92f6103f3 makefile: generate installplan mocks +9c3317819 Merge pull request #106 from ecordell/load-catalog-from-files +00320dda1 Load in memory catalog from a directory +17b7996d9 makefile: add gen-all command and run +0525e7641 operators/catalog: init installing a plan +ca44d4b71 Merge pull request #95 from coreos-inc/ALM-158-install-plan +243b5d009 Add CSV to install plan resolution +d6752bfe2 Merge pull request #105 from jzelinskie/csv-provider +3877eb87d apis/csv: add missing provider field +de6a2c2fe Merge pull request #100 from ecordell/catalog-resources +aac599c18 Add prometheus and vault catalog resources +3f1bb5d23 Fix tests +fc4a46002 feat(operators/catalog/install_plan.go): adding resources to install plan +a9aa77792 Merge pull request #97 from coreos-inc/ericavonb/ALM-124/service-catalog/ALM-173/tests +f413aa091 test(catalog/mem): sort CSVs returned by version +c96101ed9 chore(catalog/mem): update data types +a831e90b6 test(catalog): simplify tests +9d71d36c9 Add catalog resources directory and test catalog resources +a4313abea doc(catalog/mem): update comments +a67cd731b feat(catalog/manifest): add loading manifests from file +443f46668 test(catalog/mem): test basic catalog fns +7db6f5327 Merge pull request #99 from ecordell/move-outputs-to-csv +22b0c9b4c Merge pull request #94 from ecordell/move-outputs-to-csv +152b0c961 Update regex for resolved etcd cluster +660523b70 Fix tests +0d5602740 Update etcd resource permissions +cf4193b99 Fix sync +2ec7fcdb2 Remove unused config mount +efc5b820f Fix rebase +0538e6375 Dob't create serviceaccount if it already exists +ad8eef8c3 Fix role creation +3ee37df6b Log error when install fails +a472de848 Validate that example CSVs can be parsed into CSV type +71d896a91 Rename capability -> descriptor +24369398d Add implementation of permissions generation for CSVs +10f88384a Add permissions block to install strategy on CSV +87fe45612 Update CSV types and parsing to match new CRD description design +d06dd2d37 Move labels -> template/labels for CRDs +571f1e7be Rename x-alm-capabilities -> x-descriptors +1383af90c Move output definitions to CSV and move output values to status block +a3e4a3cf6 Merge pull request #96 from jzelinskie/installplanctrl +acbb410bf operators/alm: replace config map with flags +28176c40d ci: add missing pre-step for catalog +641a1342a helm/gitlab: add new deployment for catalog +227271de9 operators: init installplan operator +1486c1b27 Merge pull request #93 from jzelinskie/fix-fuckups +7168eb11c installplan: fix inconsistent samples +9ece589c5 Merge pull request #91 from ecordell/fix-etcd-installplan +53e003cf8 Update etcd installplan to match schema +84eb3c116 Merge pull request #77 from coreos-inc/ericavonb/ALM-124/service-catalog/ALM-152-catalog-implementation +bece1a043 chore(catalog/mem): update fns for mem catalog +ba1e3b0fd refactor(catalog/types): shorten interface fn names +bf09c0426 Merge pull request #90 from jzelinskie/installplan +7b44fdb0d installplan: add types for Install Plan Status +84fbe362d temp +1958ee917 refactor(catalog): embed ClusterServiceVersion spec in AlphaCatalogEntrySpec +5b26cdbe2 feat(catalog): map CSVs to the versions they replace +b70208116 Merge master into ericavonb/ALM-124/service-catalog/ALM-152-catalog-implementation +e155e8834 Merge pull request #83 from coreos-inc/req-status +8f682dd4d Merge pull request #85 from coreos-inc/ericavonb/ALM-124/service-catalog/withentrycrds/ALM-152-catalog-source +84d7e3f10 Fix rebase +094624327 doc(vault.alphacatalogentry): fix sample name +33cd3c848 fix(alphacatalogentry): regen code for alphacatalogentry types +e2ff74f4b Merge pull request #89 from jzelinskie/fix-ci +bb886bd69 Fix rebase issues +5fd058ad0 use return instead of break in switch +1f883b2e0 Fix icon parsing +7885cbd6a Add full state transition tests for clusterserviceversion status +b9cdb834c gitlab: run glide install in test stage +a418e5c02 Revert "Merge pull request #86 from jzelinskie/ci-uniq-base" +8c1806f95 Refactor phase transitions for clarity and testability +4557f6dc9 Update codegen +67d3ef518 Fix typos +6af6f45b6 Fix CSV type (deprecated fields) +123b97514 Add missing return from phase transition caused double install +baa023f51 Use switch for phases +b2e45f787 Check if deployment is installed before attempting install +c27f3404c fix(alphacatalogentry.crd.yaml): add names +d02d92a39 Update etcd cluster crd to be versioned +8871532bd Adds a state transition test +1c864082b Add mock alm operator for testing +f444c721e towards a mock alm operator +5988f7a0f Write conditions to status during state transitions +16b745178 Add conditions as a history of state transitions to csv status +8fd783fbb Resolve rebase conflicts +f85814d4a Write requirement status back to status block +df6e46aa4 Cleanup phase transitions +8df808b08 Only check for CRD existance +0ad75fe98 Update gitlab pipeline +fdcc6c531 sketch out phase transitions +bfd87540a Check for phase before attempting to install +46310f300 Add ClusterServiceVersionStatus +dd119dd51 Add schema for ClusterServiceVersion status +e069292f2 Look for requirements in same namespace as ClusterServiceVersion is defined +70a7ce024 Move config handling to its own package +83d7a4afb Merge pull request #84 from coreos-inc/ALM-142-add-owner-ref +8e0115169 doc(catalogsource.yaml): remove example catalogsource resource defs +805c59547 feat(alm,install): adding in owner reference to deployment +bef5f9d19 doc(vault.alphacatalogentry): add vault catalog entry example +9ce7e9b4e doc(alphacatalogentry.yaml): create CRD yaml +f015e7c36 feat(alphacatalogentry): add provider field +968b0a61f refactor(apis/catalogsource): remove for now +335cca566 Merge pull request #86 from jzelinskie/ci-uniq-base +4fb37402d gitlab: base image now unique per git ref +1efbc9087 doc(catalogsource): remove extraneous comment +7b8476845 refactor(apptype->alphacatalogentry): rename crd for catalog +beb9ec957 feat(apis/apptype): add back in apptype crds +0b2e6bdcf chore(catalogsource): only have one url per src +f8a33bafc feat(catalogsource): update spec for console to consume +8b5860f4b feat(apis/catalogsource): add new CRD for catalog +0d6abe848 style(catalog/mem): use variadic fn arg variable names +c636f5116 refactor(catalog): rename in-memory golang maps catalog implementation +83e1fb2ce refactor(catalog): rename fn to remove ambiguity +2a501322c style(catalog/mem): order import blocks +ea31478eb style(catalog/mem): use explicit key/vals for struct +cf8eb296e refactor(catalog/mem): remove sources subpackage, enforce interface +ae55f856b feat(catalog/sources/mem): add simple catalog implementation +718ce0946 style(catalog/mem): use variadic fn arg variable names +10bdbace5 refactor(catalog): rename in-memory golang maps catalog implementation +3725b942f refactor(catalog): rename fn to remove ambiguity +eeb1c0adc style(catalog/mem): order import blocks +00f2c7934 Merge pull request #82 from coreos-inc/validate-objmeta +cc3096894 style(catalog/mem): use explicit key/vals for struct +d09ab7670 refactor(catalog/mem): remove sources subpackage, enforce interface +4dfb5ec5c Merge pull request #81 from jzelinskie/crds-split +29e645330 csv: add json tags to CRDs +d3f658b29 Add tests to validate object metadata +910df1e1b init Required/Owned CRDs for CSVs +bf53109f0 Merge pull request #80 from coreos-inc/add-minikube +2ab5d1478 fix(cmd): fixed config parsing +c4d10078d Merge pull request #79 from alecmerdler/revise-samples +baa874a32 fix samples to reflect new updates +5a2346192 Merge pull request #76 from coreos-inc/ci-fix +dbf5286b3 Merge pull request #70 from jzelinskie/manages-spec +73ad50bff fix validation of approval types +4897b538a remove apptype from codegen +f60510864 add initial ownedCRDs field to CSV +9839e295e feat(catalog/sources/mem): add simple catalog implementation +71d4463b9 Merge pull request #71 from jzelinskie/installplan +189bd5ce6 fix apiVersion for etcd installplan +e2fd33ace move Approval type into installplan +377eefbdd add dashes back to apigroups +8ff1be6ed add install plan validation +6557ac009 subscription: fix apptype references +788441dd7 fix inconsistencies +8c0730238 capitalize approval types +e83e5940a s/update only/update-only/ +5484737f4 s/desired// && s/cloud/cluster +d2dab3168 installplan: add approvals +9b2caac86 installplan: add RequiresReview status +a50908fd3 samples/installplan: remove inconsistencies +e50adb0ed installplan: refactor status +80aacac78 installplan/v1alpha1: add spec +c2ef80c91 installplan: add status.status field +3f4e08aa8 samples: add status for installplan +46a3bed8a init installplan +4b5a5a1bc Rename InstallDeclaration -> InstallPlan +554643d36 Merge pull request #72 from coreos-inc/remove-requirement-namespaces +824832144 Merge pull request #75 from coreos-inc/ericavonb/ALM-124/service-catalog/ALM-152-catalog-implementation +29b4c4848 Remove AppType and merge its fields with ClusterServiceVersion +995d56b5b Merge apptype into clusterserviceversion (examples only) +dbc627a4a refactor(catalog/mock->catalog/sources/mem)): organize catalog types +2eaf567b0 Remove namespaces from requirements +a347d1905 Merge pull request #74 from coreos-inc/alm-151-config +9dd95919f feat(deploy): add in config map +ac68250e5 Merge pull request #73 from coreos-inc/fix-merge +5341eaef0 fix merge of namespacing PR +18f385fc2 Merge pull request #67 from coreos-inc/alm-151-namespaces +cac055852 feat(alm): adding in namespace list support +11d5b9810 Merge pull request #54 from coreos-inc/ericavonb/ALM-124-service-catalog +8ec965353 refactor(client/{opver->clusterserviceversion}_client): rename file +8dc5d5c43 refactor(catalog->planner): rename component +97905c574 refactor(appcache): use new crd name ClusterServiceVersion +b27da0693 refactor(subscriptions): change pkg name and remove unused mock +c8adad1b7 feat(appcache/mock): add simple implementation of appcache interface +9e77b6b48 refactor(appcache/types): use simpler name for interface method +9274c1231 wip(subscriptions): remove logic for now +51cf9abff refactor(subscriptions): rename to installplan +79d12996b feat(apis/catalogsource): remove for now +3b1999f4e rearrange(subscriptions): move out of catalog pkg +6dfa868fd feat(catalog/types): simplify interface +a4cc20f11 feat(appcache): add interface for app catalog cache +e5a50ea3a rearrange(apis): rename installdeclaration as installplan +e3ec5a360 feat(catalog): use k8s typed objects +bb5895395 feat(hack|apis): codegen new types +9c9cc9d20 feat(apis/installdeclaration): add installdeclaration crd types +5815ccf1d feat(apis): add catalogsource crd type +9c5666177 feat(apis/subscription): add cdr structs +03abf3f8f fix(catalog): fix type inconsistencies +474bcfbf2 test(catalog): finish memCatalog mock implementation +9db7d6808 fix(catalog): change fn arg to ptr type +f065705ec doc(catalog): comment on functions +7437f5f98 doc(catalog): add comment on temporary type decl +71fc94818 refactor(catalog): move resolve dependencies to catalog interface +3c8d83236 test(catalog/subscribe): add empty test file +6a5c25f03 WIP(v2 catalog): update for new control loops pt 1 +85d70e149 WIP(catalog): sketch out loop ops +da52eccac Merge pull request #68 from coreos-inc/fix-tests +3561ec0b4 Fix tests +d64d70023 Merge pull request #66 from coreos-inc/multiresource-example +63659d78c Fix apiversions and naming +409c867e1 Add prometheus example (has multiple resources) +6e9a2ec8f Merge pull request #63 from coreos-inc/install-instructions +0af3d2bdb Add a newline +ab9c40f8d Namespaced examples +997b1663d Merge pull request #65 from alecmerdler/ui-samples +ea6542f3d update samples for UI testing +ac04b4e6c WIP namespace samples +2ff886217 Don't install self-hosted in install instructions +41a8d455e Namespace alm +b2c1a9d99 Fix api versions +87799109e Inline instructions +6b52a432b Merge pull request #61 from coreos-inc/subscription-yamls +9052aa31d Merge pull request #64 from coreos-inc/alm-125-opervar +1d1bb393d feat(alm): added in check for requirements +6e1785cf3 Update etcd examples +b86b5cd90 Fix etcd operatorversion sample so that pod starts +ba273ba2f Add sourceType and secretName to CatalogSource +64be21184 Add example resources for Subscription and CatalogSource +3e7e732ef Merge pull request #53 from jzelinskie/refactor-this-shit +f86da09f4 Fix deployment test +3f00cc0a1 Merge pull request #60 from coreos-inc/ericavonb-docs-typo-fix +4a9bd4960 doc(control-loops): fix typo +34c222b07 Rename operator -> queueinformer Add queueinformer registration function +acdf784e3 Rename ControlLoop -> QueueInformer +b71f70bc6 Formatting fixes +30e0ac48e Merge pull request #59 from coreos-inc/dep-fix +658eb0247 attempt to fix dependencies +76b4d377a Merge pull request #56 from coreos-inc/update-control-loops +8ad00acd9 Update control-loops.md +485878039 Update control-loops.md +f4920a914 Add codegen for runtime.Object deepcopy methods +791506992 Factor out common operator functionality into a parent Operator and ControlLoop object +c8e425873 Merge pull request #57 from jzelinskie/glide-k8s +412c04b0e makefile: add -i flag to `go build` +45f9b2ccf Move opver client to its own package +a57c5abf4 Merge pull request #41 from coreos-inc/tested-crds +7dd10d2ba Refactor install strategies +89f9295cc Add testing framework for testing sample resources +957333543 Move opver api registration to apis package, rename alm.go to operator.go remove unused interfaces move apptype type declarations to their own api package +41034b852 init v1alpha package for OperatorVersion +7617fcb74 Merge pull request #55 from jzelinskie/glide-k8s +af1aa02ff Update control-loops.md +210da533d glide: update operator-client +6cd14fc45 Merge pull request #52 from coreos-inc/ALM-124/operatorversion-install +a96d160c5 rename operator -> installstrategies +096a7bdd7 Check for existing managed deployment before installing new one +8d92fe31d Remove vendor from `make build` +36b0c52e5 Update gitlab +0a8faa10c Add hack for GKE plus some formatting fixes +1e9aa3c14 Fix imports +dcb67b95a Add logs on successful install +5fc66483c WIP: can't use unstructured for subtypes +3ae0678e7 WIP: can't use unstructured for subtypes +3958a9bed Register ListKind properly +2cf765eba Add api registration for operatorversion +e56a54f82 Create a new client for watching OperatorVersions +0f49f4d32 Fix watching operatorversions +f35296e14 Fix operatorversion reference +aada1399d Install OperatorVersion and AppType before ALM +17f32044f Fix serviceaccount +43577c7aa Fix merge conflict in operatorversion +3ebf36b29 Don't create ns if already exists +c5fea556f Add CRDs and serviceaccount to helm chart +aac943550 Control loop runs install strategy Also `cmd` will run operator +08e4bb5b7 Merge pull request #51 from coreos-inc/test_ci +26ecc9fe9 Gitlab-ci with jsonnet lib +11047a242 Update helm-chart +f6c336018 Merge pull request #40 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton-operatorversion +ff8f323b5 Add deepcopy methods to `OperatorVersionResource` +cab1ac225 Fix glide.yaml +7dbe9ced3 Add WIP glide +adbb0f239 Merge pull request #50 from coreos-inc/ALM-76/install +234334ccd Merge pull request #49 from coreos-inc/update-vault-example +7cfec9cea Add install strategies +64b4389a8 Update example.vaultservice.yaml +81202b135 Merge pull request #48 from jzelinskie/update-walkthru +bd70740b3 docs: update walkthrough with validated resources +283adf4e3 Merge pull request #47 from coreos-inc/ALM-73/ALM-117/ALM-116/kubectlable-resources +ead0dbe8e Change replaces to a direct resource reference instead of a version +807567382 Add coreosbot credentials +bf1197a89 Vendor before test +3aa9bc9b0 Fix dependencies +5103da1d9 chore(glide.lock): update dependencies +22c729f35 doc(scheme/loader): comment on function not for prod +eae2d9856 style(installers): format imports by type +5aaf1a566 rearrange(installers): organize pkgs better +3da14fb3a feat(schema/loader): add util to load CRD from file +ddb3eb88c feat(operatorinstaller): add initial deployment strategy +ada4e3f6e rearrange(alm/types): remove unnecessary interfaces files +92f453195 Better formatting for outputs +3178246f3 Merge pull request #46 from coreos-inc/add_in_operator_skeleton +74c75b123 feat(alm): adding in basic operator version watch +3e17b5bf9 Add displayName to outputs +f9c0b8590 Move outputs to an annotation and add displayName and description +1901409e2 Add install instructions and make samples kubectlable again +30f1c784f Merge pull request #43 from coreos-inc/add-labels +7f43d7fc3 Change to `alm-owner-` +86fbc3aaf Add labels to propagate in addition to labels to match +71d629f29 Add labels for AppType +a235fa27b Add labels and selectors +3bd6274be Merge pull request #45 from alecmerdler/fix-yamls +a9cbecba0 Update loops +69055ccf1 Remove ALM-managed upgrade option +85285ecaa Fix typo +08cdef7f2 Split loops by piece of software, and add upgrade and GC loop descriptions +6b6f50568 Add explicit creation note to `AppType` loop +2dac16eae Update control loops to match newest design +0ff3b259b Add reconciliation loop docs +9ed79d492 add field to examples +238ef405e fix apiVersion in samples +64675e0ce Merge pull request #42 from coreos-inc/fix-examples +becf1df62 Fix invalid CRDs and CRs +ec841a262 Merge pull request #39 from jzelinskie/walkthrough +b2a102c68 Merge pull request #31 from coreos-inc/opver-spec +d19cb0b04 Remove blocksInstall from examples +01b0e7c93 Depend on `CRD` not instances of CRD +97dd80ff2 Fix etcdoperator operatorversion +ee302662f Merge pull request #32 from coreos-inc/resolved-resources +cf40e8dad Add UIDs and update apiVersions +0ee4f1754 docs/design: init walkthrough +04f80e6e2 Merge pull request #35 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton-fix-deps +72b7fbbf2 doc(DEVELOPMENT.md): outline glide and make usages +001951b70 Merge pull request #38 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton-k8s-utils +af41f66be style(alm/types): use golang conventional func naming +67dc684b5 fix(vendor): go back to glide for golang dep mgmt +4a15dcb4a Merge pull request #37 from coreos-inc/fix_image_deployment_is_pointing_too +87196f07a fix(.gitlab-ci.yml): pull correct image +5539cc8fd Merge pull request #36 from coreos-inc/fix_image_deployment_is_pointing_too +51a0c7776 fix(values.yaml): moved from quay to coreos +972f0e35c fix almoperatorversion formatting +227146dfd Fix formatting on etcdoperatorversion +8130c7d56 Merge pull request #34 from coreos-inc/fix_deploy_staging +f803740a6 fix(.gitlab-ci): put in sha at wrong place +12d057ae0 Merge pull request #33 from coreos-inc/fix_deploy_staging +afee3cbb2 fix(.gitlab-ci.yml): remove except branches +7d69cee27 Update vault example to use new requirements format +46df9b6a2 Update etcd operatorversion to match spec +45e781f6a Update operatorversion spec and alm.operatorversion.yaml +33adb51dd Merge pull request #26 from coreos-inc/add_in_deploy_staging +223341c30 chore(.gitlab-ci.yml): add in deploy staging +10a1b5305 Add status and ownership to etcd sample +c74b500a9 Move the examples back under their directories +843f2bac9 Merge pull request #30 from coreos-inc/vault-example +f728ebd66 Put `example.` prefix on example CRDs +bf7b87b1c Add vault sample +4df1ebad5 Move etcd samples into their own directory +992dfea5f Merge pull request #28 from jzelinskie/cmd +73b65bc52 Merge pull request #23 from coreos-inc/metrics-and-links +ff4e242f1 Merge pull request #21 from coreos-inc/cluster-features-proposal +32f5e718b cmd/alm: init +0fb977cdc Merge pull request #14 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton +38d8c12fc Fix merge and add important.link capability +8f591b5e7 Add sample etcd cluster instance +95fb64a81 Add sample outputs +c487cdacd Add sample proposal for metrics and links as outputs +ae433aaed Fix rebase issues +a59f67afc Update requirements version +a290f2013 Model RBAC requirements as requirements +b41aacf38 Add example for including cluster features as requirements +a08a1e292 Merge pull request #25 from jzelinskie/move +e367e4ae6 README: init +f6954b8b6 docs: move design work into Documentation directory +881113123 fix(alm): consolidate apptype cr creation +b72a36edc chore(Gopkg.lock): update dependencies for interface tests +64d73613f test(alm/interfaces): add basic unit tests +aefda21d7 feat(alm/interfaces): define alm functionalities in interface +66f0ef6d3 chore(godep): update dependencies +8d2a8b440 feat(alm/types): add type schemas +f3d0a5081 Merge pull request #22 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton-makefile +1d3b884b5 chore(Makefile): set up Makefile for test, builds +0489a95cb Merge pull request #20 from coreos-inc/clean_up_gitlab_ci_yml +e71f65265 fix(.gitlab-ci.yml): stop ci build on master +0c5733eb3 Merge pull request #19 from jzelinskie/dep +55f4fc668 dep: init +d8c9aa0f0 Merge pull request #16 from coreos-inc/add_in_manual_deploy_of_branch +3ad841650 chorse(.gitlab-ci.yml): add in manual deploy of branch +58381352f Merge pull request #15 from coreos-inc/schema-examples +6feb902d1 Add schema examples +8bca8366b Merge pull request #17 from jakedt/oopsv3 +6d3d91c9a Switch to the proper JSON field name for the schema https://github.com/kubernetes/kubernetes/commit/6133d84835c59f157a8fb4596f98d2d3cf828bef#diff-3029a18192feb70af52de676209da9b6R149 +8e5c40d5b Merge pull request #10 from jakedt/schemata +7ff047487 Make the icon information embedded and more strict +0c285d285 Add schemas for the initial resource types that ALM will manage. +c63b826cd Merge pull request #12 from coreos-inc/add_in_k8_health_check +120a5aff1 chore(deploy): add in health check for k8s +ed8399076 Merge pull request #9 from coreos-inc/add_in_cd +909b43a14 feat(deploy): added in basic helm chart +177086968 Merge pull request #5 from coreos-inc/add_in_gitlab_ci_yml +cc371399b fix(misnamed from): adding in golang +de37d4e61 Merge pull request #4 from coreos-inc/add_in_gitlab_ci_yml +4da6e660a chore(.gitlab-ci.yml): Adding in basics for ci +00841adca Merge pull request #3 from coreos-inc/add_in_gitignore +ae078dd68 chore(.gitignore): Added in a basic gitignore +08a044242 Merge pull request #1 from coreos-inc/mocks +b3aff3451 Add ALM mocks +6bf9e3252 Check in the original propsal README as a straw man. +f58bb3302 reset staging/operator-lifecycle-manager +7c7ae56ea staging/olm: Re-generate test fake package(s) +3cd949ad9 Merge pull request #36 from ankitathomas/operator-registry-sync +827a137b5 correct top level files and vendoring +669c5c606 Merge pull request #35 from benluddy/fix-cpb-target-os-arch +8aeb37773 Merge pull request #608 from ecordell/rm-appr +660b2c3ac Merge pull request #611 from estroz/feature/opm-registry-add-ca-file +559e2dd91 Merge pull request #614 from timflannagan/add-symlink-release-dockerfile +a9961fb4f Dockerfile: Add a symbolically linked release Dockerfile +483c7bb49 Merge pull request #613 from timflannagan/disable-bundle-unpack-tests +ae526bbde test/e2e: Disable the bundle unpack opm e2e tests +3f6dc6c77 opm registry add: add --ca-file to add a PEM to the cert pool used by the command +1d65a0f48 Merge pull request #596 from timflannagan/add-vendor-check +923eb37dc .github,Makefile: Add linting check against Golang packages +39e25f967 *.go: Commit changes after running 'make lint' locally +ee24b336a Merge pull request #607 from joelanford/go-1.16 +357ec4b69 remove appregistry-related tooling +6307e6e44 Merge pull request #598 from timflannagan/fix-test-log +6398cb3a0 bump to Go 1.16 +673a1f8c6 Merge pull request #606 from openshift-bot/art-consistency-openshift-4.8-operator-registry +67a052d30 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/e3b61ff1dde2bfc2bc7f2b5efdd155d1d3299cd7/images/operator-registry.yml +5448405d8 Merge pull request #604 from joelanford/go-1-15 +f4de6eaed Remove package msodbcsql17 during e2e tests +ff1059e92 Bump all Go binary builds to 1.15 +36a5f36f6 Merge pull request #587 from cdjohnson/patch-1 +3140e034a Merge branch 'master' into patch-1 +ff518a977 test/e2e: Capture stderr output when checking for docker and podman +8dae74b2f Merge pull request #594 from timflannagan/update-readme +631d37538 test/e2e: Fix output log message when Podman is not found +b88086999 Merge pull request #590 from timflannagan/update-vendoring +8c3495efb Merge pull request #591 from timflannagan/deflate-populate-helper-function +735241176 Merge pull request #593 from timflannagan/update-owners +10853edb9 README: Address markdown violations +73bf73d5d OWNERS: Update the owner file +1bc5b8cee cmd,pkg: Deflate unnecessary conditionals +2ab0e1b22 go.*,vendor: Update vendorered dependencies +54ff6e026 Makefile: Add the tidy and verify subcommands to the vendor target +42f681381 Merge pull request #588 from timflannagan/fix-ci +e7485d115 Merge branch 'master' into patch-1 +8fb17ef5f test/e2e: Revert disable Podman-related e2e tests +3318a59c7 .github: Fix Podman installation steps +9bae995c8 Merge pull request #418 from njhale/unpack-cmd +2dda35f38 Merge pull request #565 from camilamacedo86/go +65cf65dc9 test(e2e): add bundle unpack test cases +e2651a62d chore(lib): reduce log noise from image registry test facet +c1b89418a refactor(opm): export root cmd +08e7e4b6c style(logs): reduce info log noise +5d8cf07ba feat(opm): add alpha bundle unpack command +044c5b39c Merge pull request #557 from operator-framework/start-server-readme +028edac2d Merge pull request #564 from camilamacedo86/readme +cfe3d519e Deprecate initializer and registry-server +2898223a3 Merge pull request #585 from exdx/fix/apt-get-upgrade +c347a339f fix: add apt-get-upgrade to ci script, skip podman-based tests until fix is identified +c29c64eb9 doc: clarifies opm usage and what tool can help with bundles +cad166898 Merge pull request #570 from rphillips/fixes/closes +88d9086f0 Merge pull request #576 from openshift-bot/art-consistency-openshift-4.8-operator-registry +909c9587f Merge pull request #546 from timflannagan/minor-doc-fixes +20f3cecf1 Merge pull request #580 from bparees/typo +68a1f2286 Fix typo in deprecate+truncate command help +16df98322 Merge pull request #579 from timflannagan/fix-e2e-tests +7c25ac277 .github: Use the pre-installed Podman dependency +43ec5dbe2 docs/design: Remove all references to the bundle alpha opm commands +e22c9b4cb docs/design: Minor documentation fixes +89009c166 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/a74468426e8d0524b2fca64bbbcda77afef25b80/images/operator-registry.yml +a99d4dd69 Merge pull request #558 from ecordell/fix-upstream-example +59d29faef Merge pull request #559 from bentito/opm_doc_add_v1.15.3_idx_add +42bdf021f Merge pull request #571 from njhale/feat/no-sort +6cd5cf762 fix(index): add build id ordering to channel head selection +472eceda0 test(e2e): make index add regression test pluggable +549f2f540 (e2e) regression check with existing catalogs +75743c103 add missing closes +68da77d74 Merge pull request #572 from exdx/fix/test-minikube-driver +f21d1d8c0 fix: use none driver without sudo in upstream minikube e2e tests +7b1ba928b Various from PR comments +60dca8c0e Merge pull request #552 from exdx/feat/e2e-registry +70f687c62 feat: use secure local registry for e2e tests +86eb95ad7 upgrade to use go 1.15 +a6bd08670 Merge pull request #556 from ecordell/fix-prune +909c33e06 Fix upstream example dockerfile +a9d60bb7b Add details for starting a local server to README +4ad4383b9 remove stranded bundles when packages are pruned +29f0e43a3 ensure foreign keys are always enabled +94eb6b533 Merge pull request #548 from exdx/fix/kind-ci +34f20180b fix: load required docker images for kind cluster in ci e2e test +3c9314a2f Merge pull request #541 from multi-arch/master +4a98d6e87 Updating Dockerfile baseimages to match ocp-build-data config +eb972be40 Fix windows build with golang 1.15 +693a3c359 Merge pull request #537 from awgreene/bump-k8s-1.20 +807704d66 Bump k8s to 1.20 +bb3f14444 Merge pull request #536 from exdx/feat/github-actions +bbc22b808 feat: move upstream tests from travisCI +6ce54b83f Merge pull request #531 from benluddy/downstream-image-size +732c7eac8 Avoid duplicate registry binaries across downstream image layers. +8c2030987 Merge pull request #530 from benluddy/disable-broken-builds +3817ecce7 Disable broken ppc64le and s390x release builds. +c3613a00b Merge pull request #528 from njhale/fix-default-chan +977e7cbe0 Merge pull request #527 from benluddy/bundle-image-in-related-images +e78e3c468 fix(index): account for default channel in index add order +b08b7dfcf Include the bundle image itself as a related image. +d967a502f Merge pull request #495 from exdx/feat/custom-validation-categories +df5d89927 feat: bump api dep to v0.3.22; add support for operatorhub and bundle object validation +86cdd0293 Merge pull request #523 from njhale/fix-permissive +8177b464a fix(indexing): respect strict mode +ec3ce9568 Merge pull request #509 from ankitathomas/dockerfile-version +5af74c792 Merge pull request #503 from njhale/fix-bulk-add +d44e03791 Merge pull request #480 from dongwenjuan/master +6b0737fdf Merge pull request #432 from Jamstah/AddConsoleYamlSamples +59c5eaadd Merge pull request #516 from openshift-bot/art-consistency-openshift-4.7-operator-registry +82b84c156 fix(indexing): pick channel heads by semver +2abd6fb2a fix(indexing): order bulk add by version field +033f76244 Merge pull request #512 from benluddy/listbundles-multiple-incoming-edges +721acf93b Merge pull request #505 from ankitathomas/skippatch-fix +2bd47a1b6 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/f82a216a6a3707b80a635bace9367f1a8288b7a7/images/operator-registry.yml +83e1d90c3 Merge pull request #515 from awgreene/bump-k8s +400ecd04a Bump k8s dependencies to v0.19.3 +cfd127a18 copy .git directory for build tag info +dc554f210 add skippatch unit test +3123bca81 Reconstruct replaces and skips for ListBundles from channel_entry. +012815148 Merge pull request #508 from benluddy/fix-go-114 +abe2f1304 Fix Go version used by release job to 1.14.z. +d9e282012 Merge pull request #506 from gallettilance/db-lock-fix +ba0c22659 (fix) close connection to db +57c0a0443 Merge pull request #501 from benluddy/upstream-release-go-114 +1bde7883c Build upstream releases with Go 1.14 instead of 1.15. +dc4dfeaf6 Merge pull request #500 from benluddy/release-ppc64le-s390x +0f6d85bd1 Produce opm linux release binaries for ppc64le and s390x. +c562082e6 Merge pull request #496 from benluddy/release-workflow +092245646 Add Github Actions release workflow. +fadb6197c Merge pull request #494 from benluddy/server-test-populate-fixtures-before-start +d6515e28f Merge pull request #493 from benluddy/cruft-file +2a6b56289 Merge pull request #490 from benluddy/coverage-report +d1514e4a7 Merge pull request #483 from benluddy/listbundles-channel-entry-replacement +dfcd0af2c Completely populate test database before executing tests. +66f559cfd Remove unused file. +480a3673f Set replaces in ListBundles query result using channel entries. +8ba0620c9 Merge pull request #491 from benluddy/grpc-server-flakes +2de9582a8 Start listening on test server port before running tests. +92e7566d0 Add coverage report job. +dc637b882 Merge pull request #486 from ankitathomas/skippatch-fix +7835fff66 Merge pull request #485 from njhale/alias-p +d9980c427 check prerelease version for semver-skippatch mode +a4966be2b fix(opm): properly deprecate export flag '-o' +c4e99ebd3 Merge pull request #481 from benluddy/generated-dockerfile-windows-paths +605a4d8a1 Fix path separator in generated bundle Dockerfiles on Windows. +0f63cc756 fix the description of validation "RegistryV1" format +70ff6f43a Merge pull request #475 from benluddy/configmap-image-workdir +86daa8928 Merge pull request #477 from benluddy/flaky-aggregate-error-test +7e7d38f45 Fix test flake based on random aggregate error order. +74cf2adee Add writable workdir to configmap registry image. +b3dc8e709 Merge pull request #474 from benluddy/scratch-nsswitch +b29563395 Make the inability to create /etc/nsswitch.conf non-fatal. +8f8bb658d Merge pull request #464 from gallettilance/fix-race-condition +29794a47d Merge pull request #461 from ecordell/clean-tmp +bff991361 Merge pull request #290 from jianzhangbjz/help +99df95427 Merge pull request #425 from kramvan1/patch-1 +b6a3567a3 Merge pull request #454 from dongwenjuan/master +0653a7f3b Merge pull request #469 from estroz/chore/sdk-owners +ceca05190 OWNERS: add operator-sdk reviewers estroz, joelanford, jmrodri +ca959c234 Merge pull request #465 from dinhxuanvu/semver-default +83cef31f1 Enable default channel inference for the first bundle of the package +a3be6469e Merge pull request #466 from operator-framework/ecordell-patch-1 +ca1ec0333 Update upstream-builder.Dockerfile +8b94dcd8c set group permissions on /tmp +467ceb9d2 (fix) concurrent writes during image pulls +c03b8bca5 fix(dockerfile): clean out tmp directory after binaries are placed +e0ec3a665 Merge pull request #459 from dinhxuanvu/defaulchan-val +79492e087 Bundle validation will not fail if default channel is not provided +0e583eecd Merge pull request #458 from gallettilance/fix-inference +1f48ea073 (fix) bundle inference should not use skiprange +9f533519b Merge pull request #451 from dinhxuanvu/default-chan +2048435cd Merge pull request #455 from gallettilance/fix-add +92d1a2318 (fix) erroring when replacement not found +d4ab2fad5 Update index add func to handle optional default channel +7824b0b6f fix the comments of LabelDependency in the type definition +5a9d631aa Merge pull request #448 from gallettilance/force-bundle +cd852bfc5 (fix) index add --overwrite-latest +62416afbc The default channel info/annotation is optional & not required +f5ab349f6 Merge pull request #416 from shawn-hurley/add-empty-list +bf8ea5c89 Merge pull request #446 from openshift-bot/updating-dockerfile-baseimages-to-mach-ocp-build-data-config +62ced6cf6 update the help info of the export subcommand +a038b83f9 Merge pull request #429 from harishsurf/parallelize-export +076241e92 Updating Dockerfile baseimages to mach ocp-build-data config +80e61b0a3 Merge pull request #439 from benluddy/upstream-image-multistage +0714d171e Merge pull request #443 from ecordell/readd-cross +809107b8e add cross build back +4a27170c2 Merge pull request #442 from ecordell/tmp-rm-cross +f281238bf disable cross compilation while build issues are resolved +e13b6ac80 Use vanilla Alpine instead of Alpine+go for the registry image base. +1277aee10 Use multi-stage build for registry image. +e0ca6f74a Parallelize opm index export +22aa19a48 Merge pull request #437 from ecordell/fix-workdir +b31b0463d fix(build): copy bins to a tmp directory first +66f2ab5d1 add workdir permissions back +2931c1faf Merge pull request #435 from ecordell/fix-bin +c479f22a2 fix(bin): don't overwrite /bin +12b741255 Merge pull request #430 from ecordell/macwin +6209da7d3 Add ConsoleYamlSamples to the supported resources +51732abac add mac and windows binaries to the amd64 build +36d4ae3da Merge pull request #421 from gallettilance/add-deprecated +82102ef36 [typo] fixing typo in deprecatetruncate command +2e0d0d22f Merge pull request #427 from operator-framework/add-haseeb-to-OWNERS +5661e2a12 Update OWNERS +4f2b54039 Update OWNERS +4e6392f70 Merge pull request #426 from openshift-bot/updating-dockerfile-baseimages-to-mach-ocp-build-data-config +ca574edfb Updating Dockerfile baseimages to mach ocp-build-data config +091b76d56 Add USER for non-root image usage +02dfed2d4 Merge pull request #402 from ankitathomas/skiptls +31be09d14 Merge pull request #422 from bandrade/fix-doc-semver-range-example +caf034e45 fix: add dashes to semver range example +c7e25eed1 Merge pull request #419 from akram/patch-2 +5a82f1569 set default for flag --skip-tls=false +37efbea43 Merge pull request #420 from benluddy/undocument-label +67331c5ea Merge pull request #417 from benluddy/listbundles-zero-dependencies-properties +ea30dcd9f Remove label dependency from bundle docs. +4e892fc41 Fix typos +44c6435a0 Return empty properties and dependencies in ListBundles responses. +a928124bb Add test to verify empty bundles in addition does not break +4475a62bd extend skipTLS option to podman +d06c41526 skip TLS option for pulling indexes +ce66a306d Merge pull request #413 from kevinrizza/cleanup-command +4927fe1bb Bug Clean up stranded bundles +23af6a15d Merge pull request #411 from operator-framework/kevinrizza-patch-2 +437b9c82c Merge pull request #404 from ecordell/graceful +c3f74412b [docs] Update out of date compile step +eb88036c5 Merge pull request #410 from ecordell/listbundles-broken +b5c513244 fix(query): return bundles in all channels +7b935c8d7 Merge pull request #370 from Jobava/timeout +17e7b5c5b Merge pull request #406 from dinhxuanvu/add-label-type +2233f313c Update label property extraction from CSV +6f22b37f5 feat(registry): Add label dependency constraint and property +1c65e3611 Merge pull request #397 from gallettilance/deprecate-bundles +d99911274 Merge pull request #408 from dinhxuanvu/remove-defaultchan-validation +cf9c51d93 fix(validation): Remove default channel validation from bundle lib +13acba6d9 Adding deprecated property type to bundles +b654090f8 Merge pull request #405 from ecordell/fix-prop-listbundle +fb75b6ca0 fix(query): list bundles would elide all but one property +bf0be224d feat(registry): add graceful shutdown to grpc server +4f4102b47 Merge pull request #399 from ecordell/static +57ef54480 fix(e2e): pass build tags to e2e +94bd0cf6b fix(dockerfile): remove unneeded static dependencies +8f78d681e Merge pull request #394 from multi-arch/master +da8df3a9e Remove nonexistent group from Dockerfile +829bf2e66 Merge pull request #393 from benluddy/version-from-tag +4e87d20cf Embed version at link time based on git tags instead of a file. +50e2ae30b Merge pull request #391 from benluddy/get-package-client +3c65685ff Merge pull request #392 from operator-framework/kevinrizza-patch-1 +c2c0574a7 Update OPM_VERSION +9e47bd0b3 Add GetPackage to the client interface. +9fb26eb48 Merge pull request #384 from gallettilance/check-before-insert +460123922 Updating based on feedback +91224f615 Merge pull request #390 from njhale/fix-validate +4021942ee Merge pull request #388 from Jamstah/s390x-env-fix +1e196700c fixing up to return exit codes +c8da54d39 fix(containerd): always [also] pull layers from linux/amd64 +3f8656b55 fix(validate): pull bundle images before unpacking +2e3df21a4 Use go env to get architecture for building +d83bc1d42 Remove sanity check from `make all` +70ae404c3 Merge pull request #382 from ecordell/s390x +fe2bcd80f fix(build): don't set -race when testing on s390x +c4ebb4b61 Merge pull request #381 from ecordell/replace-skips-listbundles +a7dfb043c feat(api): add skips/replaces to listbundles api +03a5e3343 Adding sanity check and error message for inserting the same bundle +e9bcdcc11 Updating: adding sanity checks before insert into index +922bcf4a0 Merge pull request #380 from estroz/chore/add-annotations-json-tags +1160ce889 pkg/lib/bundle/generate.go: add JSON tag to AnnotationMetadata +6eb5e9dc0 Merge pull request #379 from Jamstah/patch-1 +d9e3aba11 Merge pull request #378 from operator-framework/arch +4489dbbff Merge pull request #300 from ecordell/refactor-indexer +f1bb81504 Merge pull request #361 from Jamstah/cp-dir +c63c9d0ec Merge pull request #363 from ecordell/generic-props +77f795e59 Bump GRPC version +ba0313684 feat(release): add builds for s390x and ppc64le +35a47a4d4 fix(opm): refactor indexer +454b702b9 feat(deps): nest dependency values +9d88ef4a7 Merge pull request #377 from njhale/vendor-grpc +4d850e57e feat(store): store provided apis and package info as generic properties +3fccb235d Merge pull request #375 from operator-framework/1.12.7-version-bump +ee8997d1e Merge pull request #374 from kevinrizza/separate-rm +a913943f8 Merge pull request #346 from exdx/feat/add-gardener-objects +7f9fc5ef2 chore(modules): update vendored deps +574eff086 fix(docker): build grpc probe outside of gopath +b5860c7e8 Update OPM_VERSION +9eb4fe709 Add sanity test for opm registry serve +d2187785c Add timeout to opm serve +d3651599b Separate build/pull tool for index rm +15092bb8d Merge pull request #373 from kevinrizza/go-1.14 +5c9e80ef5 (fix) Update to go 1.14 +4eea45df5 Merge pull request #372 from operator-framework/1.12.6 +547be0859 Merge pull request #371 from ecordell/403fix +4b4094843 Update OPM version to 1.12.6 +7ca5b1d28 chore(deps): bump containerd +52c605e30 Merge pull request #270 from dinhxuanvu/bz-component +9e79ddbba Merge pull request #119 from ecordell/fix-test-flake +1b88b94da Merge pull request #360 from Jamstah/pull-template-broken-link +990cd1095 Use /. as the directory root to copy from. +ee21f88d0 Fix broken link to CONTRIBUTING.md +9fbe617e6 Merge pull request #358 from estroz/bugfix/annotation-compare-validation +99717e015 pkg/lib/bundle/generate.go: ValidateAnnotations does not compare number of annotations in existing vs expected so arbitrary annotations can be added to annotations.yaml +3ba5b6ff8 Merge pull request #353 from ecordell/tmpdir +c3bedd910 fix(copy): make tmpdir relative to current directory +453c23114 Merge pull request #351 from njhale/fix-unpack +566a79cd5 fix(images): use docker/podman create and cp for exec unpacking +b3cb795e8 Merge pull request #350 from operator-framework/kevinrizza-update-owners +15d753d8e Merge pull request #349 from estroz/bugfix/bump-api-version +5a79c33ea Update OWNERS +7b1c617c3 The api repo is now pinned to the latest commit which contains bugfix https://github.com/operator-framework/api/pull/39. This update also removes the bou.ke/monkey dependency that has a very restrictive license. +6907c1b19 Merge pull request #210 from multi-arch/master +cf50e86ba Merge pull request #347 from anik120/fix-opm-test +e55ef70ab [e2e] Fix opm test +1c609e7d1 feat: add pdb, vpa, and priorityclass object support to registry +aac52ee04 Merge pull request #296 from camilamacedo86/add-info-bundle-files-gen +23803afdb Merge pull request #319 from beautytiger/fix/nil_check_before_defer +cf3061ca5 Merge pull request #333 from kpiwko/patch-1 +42a4d3f9b Merge pull request #335 from bandrade/fix_bundle_doc +4986d43ad add info over where the bundle files are or will be written +3dcc91a1f Merge pull request #341 from exdx/feat/add-release-doc +82953e6e3 feat: add OPM_VERSION notes to release docs +bb9cbaff0 Merge pull request #340 from ecordell/ro +afdf9e442 fix(unpack): support unpacking readonly folders +c3a9acaf0 Merge pull request #337 from benluddy/podman-index-docker-format +cbcb220da Merge pull request #338 from kevinrizza/bug-1835884 +6896dbd8d Configure "podman build" to produce images with Docker manifests. +de8db4d45 opm bundle extract shouldn't validate annotations +efe955d6a Merge pull request #332 from ecordell/opm-server +d9bc32851 Merge pull request #334 from dinhxuanvu/fix-unstructured +3790d9de4 fix(server): make a copy of the db before migrating it +a2e8354a5 docs: remove typo from dependencies example +bb3445833 fix(validation): Fix CRD v1beta int-float conversion error +d2a3a95c5 chore: fixed a typo in bundle manifest format +3582f1cd2 Merge pull request #320 from joelanford/dynamic-upstream-olm-builder +a71b8afe4 upstream-opm-builder.Dockerfile: don't install bash; sh is sufficient +c48e67749 Merge pull request #321 from exdx/fix/update-opm-buildflags +110a4dedc Merge pull request #324 from Bowenislandsong/bug/understandsingBundles1827723 +2752dba53 Adding error message for more than one CSV in bundle dir +efb4d5323 feat: add build flags to opm to show version information +225ad1155 Merge pull request #306 from djzager/version +80878b5b9 Merge pull request #318 from Bowenislandsong/bug/understandsingBundles1827723 +a2f721b94 Make default channel optional +a9b107b2a Make default channel optional +e73a50a28 Merge pull request #316 from ecordell/containerd-authorizer +a82af2d0e Merge pull request #295 from exdx/feat/support-v1-crds-in-index +5d15c662a fix: add err check before defer +f14e6d543 Move bundle validator back to registry under validation package +44ca66553 fix: use runtime.Object instead of interface for CRD return type +b7b281be7 Merge pull request #314 from kevinrizza/index-generate-dameonless +7b08c9e45 fix(auth): use fixed containerd authorizer +57c46da8e Split build and push command runners +46d9cbfba (bug) Always overwrite local db when copying +ec16c49cb upstream-opm-builder.Dockerfile: add bash and ca-certificates to runtime index image +18f74c7c1 Merge pull request #312 from benluddy/deps-not-found-optional +8852286a2 Clarify log message to indicate that dependencies.yaml is optional. +e3a7f4e9e feat: add test for v1 CRDs in registry bundle +16a388a86 feat: Enable v1 CRD validation in bundle library +c6c8d8123 feat: support loading v1 CRDs into index from a bundle +41d933e9f feat(opm): add version command +1616423d2 Merge pull request #289 from dinhxuanvu/fix-dep-types +d13cc864d fix(types): Fix GetDependencies func that returns duplicate items +9b7365d85 Merge pull request #243 from djzager/filtercmd +a6f3b3344 Merge pull request #299 from kevinrizza/bug-1820438 +7998e2115 (fix) Use opm builder image for opm indexes +b0b2270c4 Merge pull request #298 from kevinrizza/bug-1820438 +378699c46 Bug 1820438: Slim down upstream builder +e3d6a223b feature: opm (index|registry) prune command +f028701f9 Merge pull request #283 from ecordell/index-separate-dirs +d0615a8b2 Merge pull request #277 from dinhxuanvu/opm-dep +65fed64c2 Address the metadata read files loop to work regardless files order +8355a08d3 Add unit test cases +63e952637 Add Validate() for each dependency type +8aa3d3a63 Add dependencies validation +8572f569e Add dependencies.yaml validation to opm +e00cf4182 Merge pull request #285 from kevinrizza/bundle-add-commutativity +61b200175 feat(opm): add unprivileged index extract +181ea3a2c (feat): Bundle commutativity +2662ffbf8 fix(indexcmd): use a separate directory for unpacking a previous index +b7641c508 Merge pull request #284 from benluddy/fix-podman-panic +b701022ba Fix panic in AddToRegistry when using podman. +df99b2ccf Merge pull request #281 from ecordell/fix-docker-add +c17db7979 fix(index-add): docker index add failing +95585c745 Merge pull request #280 from dinhxuanvu/dep-registry-comb +bcef6fddd Add ListBundles to the client interface. +191a85e47 fix(query): ListBundles returns all bundles even without dependencies +7f19d5f13 fix(registry) Update the addDependencies to add requiredAPIs +55fa9c787 Merge pull request #279 from ecordell/demonless-index-cmds +8541af595 fix(add): allow containertool to be specified for registry add +4807c9a1d Merge pull request #244 from djzager/indexadd +ed32d7a12 Merge pull request #254 from dinhxuanvu/dep-yaml +e501f66c8 Address feedbacks (second round) +aa3432879 bug(opm): use db dir when modifying existing index +30bc8aa25 Add BugZilla component to OWNERS file +95fede4af Address feedbacks and fix test cases +09d650c2a Merge pull request #265 from ecordell/fix-channel-heads +eb11ce644 fix(load): shouldn't clear bundle/csv field from non-default heads +06e7733f5 Codegen for registry API changes +0024d5cfb Merge pull request #262 from njhale/docker-login +00af1da53 Add bundle dependencies specification documentation +41f1c55e8 feat(registry): Add operator version dependency metadata +9b65effe4 test(e2e): login w/ docker first to prevent failures +b82634749 Merge pull request #256 from exdx/feat/add-bundle-objects +a4467d99c Merge pull request #251 from djzager/registryrm +1d855e13b Merge pull request #260 from ecordell/fix-imgload +e3a98c3d3 fix(imageloader): image loader should consider existing channels when adding to an index +f01d6ddcd Merge pull request #247 from kevinrizza/semver-mode +8db3160ee (feat) Add semver insert mode +1f9153736 feat: add support for configmap and secret objects when generating a bundle +27d4e6e44 Merge pull request #246 from ecordell/k18 +c65e46b34 chore(deps): bump to kube 1.18 +371e1406b Merge pull request #253 from operator-framework/add-conntrack +8674af077 chore(travis): add conntrack package +56f5b0e4c bug(opm): packages flag on registry rm required +36b92b67f Merge pull request #248 from njhale/fix-panic +55fe6819d fix(populator): set bundle name +a1573df44 fix(populator): put correct argument in decode call +1e32c8581 Merge pull request #213 from njhale/daemonless +393f32379 refactor(populator): ensure file descriptors are closed +9b456bc5c chore(modules): update vendor directory +f048fc0e6 refactor(image): add image reference interface +5d26cce45 feat(deamonless): add buildah-based deamonless image puller +9e88099f3 docs(opm): add self-contained container-tools section +1af9bf96f feat(opm): add unprivileged registry add +19a8c1890 Merge pull request #242 from dongwenjuan/master +9762ed555 Merge pull request #236 from ecordell/fix-add-err +d838b9a47 Merge pull request #241 from Bowenislandsong/understand-packages +177fef741 [feature] Understanding packages from directory +16f389279 test(migrations): add tests for api provider and requires migrations +5b102d2a6 fix(load): add synthetic nodes in every channel that a replacement is in +a48b4c6fe feat(bundle): extract replaces/skips data on load +8ac8863ca fix the `validate` command in the docs +37eb42d99 Merge pull request #227 from ecordell/nsswitch +5902db2c5 Merge pull request #237 from estroz/bugfix/manifest-copy +9e5cd742f refactor(db): remove denormalization that associated provided and required apis with channel entries, rather than bundles. +04a8234ec Merge pull request #234 from Bowenislandsong/fixtests +768692da1 [travis] pinning minikube version +3e2816947 Merge pull request #239 from operator-framework/revert-229-understand-packages +4f35231af Revert "[feature] Understanding packages from directory" +29df24750 [dockerfile] removing dev directory permission change +3be8cbf3f pkg/lib/bundle: fix copyManifestDir so it actually copies file contents +fff4eefbc Merge pull request #229 from Bowenislandsong/understand-packages +44ee96d39 [feature] Understanding packages from directory +cc093ebfe fix(dns): fix slow dns resolution of localhost for grpc health probe +ad7470387 Merge pull request #224 from kevinrizza/graph-loader +b712cbbc0 Update graphFromEntries to be a private function +3542b5484 use query interface in sql graph loader +843ec70a0 address pr feedback +3dc50c479 Update graph format for runtime concerns +4ed3d3db7 Graph Loader initial implementation +81a48979f Merge pull request #196 from operator-framework/opm-test +5bb2104be Add opm E2E test. +994ab606f Merge pull request #212 from anik120/bump-k8s-version +66f6f5efb chore(deps): Bump to kube 1.17 +262153399 Update grpc-health-probe version +44dacd0bf Merge pull request #209 from kevinrizza/opm-bundle-generate-dir-structure +5b73e0c91 Generalize manifest copy +b583b6fcb Merge pull request #193 from ecordell/adrian555-master +b57e48c37 Merge pull request #164 from dinhxuanvu/update-owners +e737486be Merge pull request #206 from kevinrizza/opm-bundle-generate-dir-structure +db0661a28 Match bundle image directory structure +7a06d84c3 update go.mod to remove unneeded license dependency +72c38400c Merge pull request #198 from Bowenislandsong/resolvingCycDependency +ac4ee7eaa Removing olm dependency +dd02edcfb Merge pull request #197 from njhale/fix-dockerfile-gen +f3796dfb0 fix(index): gen index dockerfiles from opm image +d1f8f4958 Merge pull request #194 from Bowenislandsong/stalebot +3af90d238 Merge pull request #195 from njhale/fix-meta-prune +538352136 test(meta-pruning): ensure pathless nodes keep data +2683308c8 Add stale bot +1f1a704a0 Merge pull request #189 from benluddy/sorry-amd64 +25a9e5332 Produce binaries without target platform prefixes by default. +87718aab2 Merge pull request #186 from ecordell/rm-rf-helm +d097f9a4d chore(deps): remove helm as a dependency +702ab31fe Merge pull request #183 from ecordell/opreg-entrypoint +38e875be6 fix(docker): add entrypoint +f6df4f430 Merge pull request #173 from njhale/fix-opm-cp +2aa7ca414 Merge pull request #172 from dinhxuanvu/bundle-docs-update +640075070 Merge pull request #167 from benluddy/delete-sqlite-junk +1746ac0aa fix(index): copy correct opm bin builder path +0463ddcad Update operator-bundle to clarify the bundle format directories +6f049490b Merge pull request #148 from ecordell/failfast-builder +4a8424920 feat(appr): exit build early if no manifests were downloaded +f6db5f3ed Delete junk SQLite journal files. +8702bface Merge pull request #166 from dinhxuanvu/validate-bundle-test-2 +6f1ce0f43 Add validate bundle test cases +15d92f2d5 Merge pull request #161 from benluddy/remove-sqlite-dep-from-configmap +2669b49c6 Update operator-registry OWNERS file +11c61f83f Merge pull request #163 from gallettilance/export-bug-fix +ca1603789 Fixing wrong database loaded in memory for export cmd +414d8b637 Merge pull request #162 from operator-framework/revert-160-static-ci +5998143c4 Revert "fix(ci): build opm statically in CI" +594ba2e20 Merge pull request #154 from gallettilance/index-to-appreg +5c08cdb24 Remove dependency on sqlite from pkg/configmap. +8d4cc3b79 Adding ability to export package from index +c97191ab1 Merge pull request #160 from ecordell/static-ci +ea6a48f80 fix(ci): build opm statically in CI +c9e2f548e Merge pull request #149 from kevinrizza/opm-docs +185b4a8c7 Merge pull request #153 from simrandhaliw/patch-1 +9622e938b Merge pull request #141 from gbenhaim/add_support_for_choosing_a_version +9fe0a1ace Merge pull request #158 from operator-framework/mkrelease +5fa39be6c chore(release): use robot for deploys +d760749f3 Bug 1784028: Updating summary for 'Operator Registry ' containers +759dd0b18 Merge pull request #156 from dinhxuanvu/fix/docker-error-output +fe3c7d07d Fix issue with empty docker error output +bae1e9ad6 Merge pull request #155 from ecordell/bins +fd4ded680 chore(release): add a travis.yml to build and release opm +c7fc4dc57 Merge pull request #146 from exdx/feat/validate-bundle-files +07496ed07 Address feedbacks from comments/reviews +4444617ad Update README.md +80f7dd11d Add support for choosing the package's release +c1f18051e Update docs to reflect index/bundle image changes +bb10148e4 Refactor bundle validation code to seperate format and contend validation +618c93e38 Add validate bundle contents +56d0ebd99 Merge pull request #139 from gbenhaim/make_downloader_testable +27c2ca979 Merge pull request #147 from ecordell/fix-build +43cb58a95 fix(build): grpc-health-probe was not building properly in 1.13 +2c6a866f3 Make downloader.go testable +163605a1d Merge pull request #145 from njhale/load-csv-name +5d8d1f968 fix(bundle): set csv name field on configmap loading +117fde9d0 Merge pull request #143 from kevinrizza/bundle-validate +24edbb8e4 Vendor helm library to enable helm chart validation +c746b8219 Fix a few minor issues +2654fe103 Update bundle validation lib for sdk consumption +5de9853d7 add tests +f6b5f0797 Add bundle image validation feature to bundle library and bundle cli +b93aee167 Merge pull request #63 from tmckayus/replacecircuit +d68a99b4b Merge pull request #135 from vincent-pli/tiny-typo +3c68d0ca6 Merge pull request #137 from jpeeler/switch-bundle +713a21faa Merge pull request #144 from jpeeler/add-cp +6c5d3d004 add cp to configmap-registry image +fd50b98ac Merge pull request #142 from operator-framework/opm-to-configmap +19d0971af Add opm to configmap-registry image +d62d52a4c Merge pull request #140 from njhale/index-docs +1f109438f chore(modules): update vendor +6ea1b04cd refactor(opm): add examples to index add subcommand +7223d41d6 fix(configmap): remove packagemanifest parsing +e92c3c15a chore(makefile): add selective unit test execution +0657f62c1 Fix tiny typo +09d7e1c1b Merge pull request #130 from njhale/fix-ignored-cachedir +e8805a66b chore(mocks): use new counterfeiter directives +23777e0a3 fix(appr): use given cache dir for image builds +9ebe14ad0 Merge pull request #129 from anik120/bug-rearrange-dir +4389019fa Bug 1774630: relocate test data +d0cde7e52 Merge pull request #128 from anik120/bug-fix-incorrect-bundledata-panic +92bc45361 Bug 1774630: Fix panic caused by incorrect bundle data +4998a0e7f Merge pull request #125 from anik120/opm-bundle-extract-bug +7b3da5830 Bug 1771850: Error logging for opm alpha bundle extract command +97a63dc5e vendor in github.com/pkg/errors +abc8771ee Merge pull request #127 from dinhxuanvu/bundle-build-fix-2 +a60ea60c9 Detect replacement cycles while adding package channels +feefcd953 Clarify the directory requirement in docs and help menu +96a395048 Ensure provided directory has at least one yaml manifest file +0233cfc8f Merge pull request #124 from dinhxuanvu/bundle-build-fix +4133a9d0a Merge pull request #126 from jpeeler/update-ginkgo-test +ae6601658 Add directory check to ensure the directory exists +215d838e2 fix(e2e): update ginkgo configmap test +eb9a1ebe4 Fix bundle build command with Docker and update documentation +d78058642 Merge pull request #122 from gallettilance/bundle-table-insert +d9a6dc84d [bug] - add version and skiprange to operatorbundle table +47f48e5c7 Merge pull request #121 from kevinrizza/fix-docker-image-unpack +80164bf87 Make imagereader work for all layer paths +a37bc867c Merge pull request #118 from ecordell/fix-upstream-configmap +3bedcfebe test(server): wait for connection to go healthy before running tests +6221359f7 fix(configmap): bump base image for configmap registry image +abb24c012 Merge pull request #106 from kevinrizza/index-command +12b62c11f Add `opm index` commands +2fb07b855 Merge pull request #113 from ecordell/rest-of-it +214fca47e fix(mirror): canonicalize names before swapping domain +c0a1e66c7 feat(api): return version and skiprange in bundle +380d944c4 Merge pull request #89 from gallettilance/operator-registry-cli +5e4ed7104 Merge pull request #115 from ecordell/fix-to-option +669be0cd3 [opm] - Add registry add and rm bundle commands +596134f3c fix(builder): Add AppRegistry org to `ToOption` +cbda71412 Merge pull request #114 from jpeeler/fix-launch-bundle-image +4a41a4273 fix(configmap): make launch bundle work +c62af6239 Merge pull request #112 from ecordell/api-bundle-client +f5bd7b31b feat(client): return api bundles in client +cf19596a5 Merge pull request #111 from ecordell/required-apis +1fff59226 feat(sql): extract required apis when loading +143bee961 Merge pull request #110 from jpeeler/add-opm-binary-into-container +4f5fca9f9 feat(imagebuild): add opm binary to registry image build +1c48ed8f4 Merge pull request #109 from dinhxuanvu/bundle-order-fix +4b97e6fe6 Merge pull request #105 from ecordell/opm-catalog +498228060 Merge pull request #92 from tkashem/configmap-bundle +4a7e3c320 Merge pull request #108 from dinhxuanvu/mac-gitignore +f403531ee Merge pull request #107 from dinhxuanvu/fix-bundle-dockerfile +1ecae6b15 Merge pull request #94 from jpeeler/expose-bundle-data +801d2e396 test(mirror): add tests for mirroring +1b6105ec6 feat(opm): add registry mirror command to mirror the contents of a catalog +0d0f4201e fix(bundle): Fix the build paramater order mix-up +bee08a723 fix(bundle): Fix manifest directory issue in generated Dockerfile +12b622668 Update registry gitignore to be consistent with OLM +9de195760 feat(opm): add registry build command to build a catalog from an appregistry namespace +8c7c3f498 test(e2e): add bundle data image extraction test +652e8a396 test(e2e): add initial test bootstrap +92568f12b feat(cli): add bundle extractor binary +98e9b709d feat(configmap): add configmap writer +f5444e285 chore(client): move k8s clientset generation +ed733cf96 chore(configmap): load packagemanifest data from annotations +5c4a88e77 test(unit): add test case from generated configmap +9519e7973 (feat) Load operator registry bundle from ConfigMap +1e3a9a685 Merge pull request #97 from dinhxuanvu/bundle-lib +b1aaf2526 Change const to upper case so it can be used +e42de32db Merge pull request #103 from anik120/image-digests2 +c62fdb4bb Image digests for referencing bundles +dbca245b1 Clean up minor issues with command-line code and documentation +d84454578 Merge pull request #101 from ecordell/relatedimages +1600fab9c feat(migrate): migrate from current version up to the latest +f7f554b3e feat(images): add support for storing and querying related images +9f0f125e7 feat(migrations): switch to go-based migrator +93f2f687e Fix bundle library doc to reflect new changes/features +2434e337b Fix bundle library unit tests to cover new code +1c113bcb6 Fix bundle library to add package and channels info to annotations +e061d9a36 Clean up library code, unit tests and documentation details +4dc452ba0 Add CLI tool to build Operator Bundle image +c649037aa Merge pull request #102 from operator-framework/update-owners +7d088609b Update OWNERS +47f4e56cf Merge pull request #77 from njhale/remove-schema +325e8ee89 Merge pull request #96 from gallettilance/opm-cli +bd347d3a6 Adding opm cli +e679e0049 Merge pull request #90 from kevinrizza/db-migration-scaffold +d64ca7d77 Bundle migrations in binary +8f1e20a6d Database migration initialization +4df186f63 Merge pull request #98 from ecordell/foreign-keys +adfbcbe98 Merge pull request #86 from estroz/fix-crd-encoding +50b725a67 fix(sqlite): enable foreign keys for sqlite +dddf15793 Merge pull request #88 from kevinrizza/migrations-proposal +01461dce2 Add migration proposal +15f725527 Merge pull request #87 from ecordell/kube-1.16 +bacb60372 chore(deps): refactor load_test so that OLM is no longer imported at all +3f9f3d83c chore(schema): remove schema +5d8bf321e feat(csv): support extracting version from bundle's csv +bc107ecac chore(deps): bump to kube 1.16 +85ae208e9 Create PULL_REQUEST_TEMPLATE.md +28f99b0ac pkg/registry/bundle.go: use v1beta1.CustomResourceDefinition, as the apiextensions type is internal +709cb007b Merge pull request #84 from njhale/fix-transactions +6ca85bf52 fix(sqlite): defer rollbacks to prevent db lock +4e83e7e01 Merge pull request #82 from ecordell/grpc-update +3b6857c91 chore(deps): update grpc to latest +f0509fa8f chore(schema): remove unused upgrade path code +4633997c6 Merge pull request #75 from dinhxuanvu/error-fix +f1e0e88c1 Merge pull request #74 from njhale/permissive +851783377 fix(registry) Fix incorrect error return and handle +284be6981 refactor(cmd): change command scope to make testing easier +b9e346e81 feat(configmap-server): tolerate load errors +a89b379b4 feat(registry-server): tolerate load errors +2414acd71 feat(appregistry-server): add strict load option +72e0be383 feat(configmap-server): add permissive load option +4d40a2042 feat(initializer): add permissive load option +ba3de1f89 feat(log): make termination-log setup failure non-fatal +efb96a667 Merge pull request #72 from njhale/fix-best-effort +a0e1c4248 test(load): add test of unpacked appregistry format +6b11844a7 fix(sqlite): correct directory load error collection +2788358a7 Merge pull request #69 from njhale/best-effort +0547f57aa feat(appregistry-server): use empty querier on fatal load error +3ba8eb920 feat(sqlite): make configmap loading best-effort +b7830a9e7 feat(sqlite): make directory loading best-effort +6ca59e3a4 feat(sqlite): make package loading best-effort +e230b9411 Merge pull request #65 from ecordell/catalog-cmd +dbafcc040 Merge pull request #65 from ecordell/catalog-cmd +b0a4454d9 feat(appregistry): avoid panics in flattened processor +82ee13e48 chore(git): keep testdata/download +aeeca6db6 chore(deps): add glide.yaml for importing to oc +c9c256967 feat(appregistry): have appregistry transform configmap bundles into directories +fb38816aa chore(deps): remove dependency on marketplace +f4d156a44 chore(deps): remove dependency on openapi and go-appr +8cb5471f6 Merge pull request #61 from ecordell/fix-registry-dockerfile +13a6a429b fix(dockerfile): missing image alias +3a731e5ce Merge pull request #60 from ecordell/registry-dockerfile +178706333 Merge pull request #59 from ecordell/remove-olm-and-json +283f75108 add dockerfile that just contains the registry server +4326318c1 refactor(load, query): don't rely on json extensions to sqlite, and don't rely on types imported from OLM +da787d605 feat(load): allow multiple csvs in the same directory +2676630d6 Merge pull request #56 from ecordell/dynlib +ff2a93259 fix(build): don't build static in downstream images +f73badbf8 Merge pull request #55 from ecordell/go-1.12 +1256393b1 chore(image): change base image to go 1.12 +b52e8d312 chore(dockerfile): switch to go 1.11 +9297dc4c9 Merge pull request #54 from ecordell/fix-channel-count +a34303066 fix(query): return all channels when querying +d622bca51 Merge pull request #52 from awgreene/fix-duplicate-package-bug +e778e13fe [bug] Remove duplicate packages from list +e005bc432 Merge pull request #48 from dinhxuanvu/validate-examples +c71e1ba4a Merge pull request #51 from marcoderama/smallfixes +207fb0de8 Documentation: Small typo fixes to README.md +6380d8970 Remove pragma lines that reference the files that can’t be found +9f43f541d fix(registry): Validate alm-examples in operator registry +d3b9026e9 Merge pull request #49 from ecordell/healthcheck +0f2a31d2a feat(client): add health check to high-level client interface +a7b02d504 Merge pull request #46 from ecordell/default-channel +e57914eb3 feat(load): validate that packages have a default channel when loading +dcbbdf28e Merge pull request #45 from ecordell/permissive-files +e7d87768d feat(loader): don't require file suffixes +2552478be Merge pull request #43 from tkashem/bundle +9685d18c6 Add unit test(s) +33a7fd259 Support nested operator bundle format +3420338ca Merge pull request #41 from ecordell/z-stream +66f5d27ad feat(load): use a new "skips" field to specify additional operators that +dedae1c2f Merge pull request #40 from tkashem/no-opsrc-dependency +2320552a5 Remove OperatorSource dependency +0739cde3f Merge pull request #39 from ecordell/update-cm-reg +df9fbe258 update upstream configmap-registry image to use the builder image +28784f8cf Merge pull request #34 from dmesser/readme-docs +882430eb1 Merge pull request #38 from dmesser/build-fixes +8457a4339 add instructions how to use grpc catalog +8e058560d fix reference to Dockerfile +eeb5b814b Merge pull request #35 from mhrivnak/typos +67c9f7285 Merge pull request #36 from ecordell/upstream-builder +a0ac5c83d feat(builder): add builder dockerfile (contains tools for building a registry image) +f2088a8b3 fixes typos in README.md +f2b220be7 Merge pull request #32 from ecordell/detect-bad-replaces +e91301562 fix(load): return an error if a CSV specifies a replacement that doesn't exist +55f857fe2 Merge pull request #29 from operator-framework/upstream-readme +a41f89491 Update README.md +342439fe1 Rename upstream.Dockerfile to upstream-example.Dockerfile +e8fc5840e Update docker commands in example to use upstream +b37da018a Merge pull request #28 from kevinrizza/auth-in-appregistry +6905544c3 Add authentication to apprclient +2a5bf4eda Merge pull request #27 from tkashem/remote-registry +7dc5913be Incorporate new binary into docker images +d3a852d1f Add appregistry-server binary +91668083b Add apprclient package that talks to app registry +ba5b82ace Refactor configMap loader to work with appregistry +1ee61e256 Merge pull request #26 from jpeeler/remove-dep +851dba318 fix(build): remove dep usage +67841cfe8 chore(build): make vendor +40396880c fix(build): update grpc-health-probe for module support +6c51b6c05 Merge pull request #25 from jpeeler/static-build +cefbc8e00 fix(build): make static build work +88d15100f Merge pull request #24 from ecordell/root-downstream +2bdc5a8e3 fix(dockerfile): user needs enough access to read from the filesystem +353808d71 Merge pull request #23 from njhale/revendor-olm +8b4b1703f chore(modules): update version of OLM module and revendor +f30dd21db Merge pull request #21 from operator-framework/configmap-server-path +f272de540 fix(dockerfile): move configmap-server into path +59cf23fa1 Merge pull request #20 from njhale/get-bundle +3c6870896 feat(bundles): add GetBundle request +85923f676 Merge pull request #19 from njhale/fix-minimum +880995e47 fix(bundle): fix CRD conversion with minimum validation field +973e2f25f Merge pull request #18 from ecordell/update-olm-types +e7d02c2b3 fix(dep): bump olm types so that registry can serve new CSVs +2875581ae Merge pull request #17 from ecordell/expose-clients +e82f243eb feat(client): expose underlying clients +a121b5d37 fix(configmap-server): switch dockerfile to go 1.10 +45f0a61bf Merge pull request #16 from ecordell/fix-configmap-bundle-parsing +3175ccbb1 fix(configmap-server): gvk parsed for owned CRDs incorrectly, so bundles were omitting CRDs +3dd0bd6a8 Merge pull request #14 from njhale/group-and-plural +c43c54102 refactor(schema): split groupOrName into group and plural fields +43b9be2b7 Merge pull request #13 from njhale/container-codegen +d898e2cd8 chore(codegen): run codegen +14b04ed4d chore(tools): add golang/protobuf as a tool dep +ca3334dea feat(codegen): add container-codegen make rule +4c5211261 Merge pull request #12 from njhale/add-owners +1a19641b8 chore(ci): add OWNERS file +6f84a5529 Merge pull request #11 from njhale/okd-dockerfile +5753cb475 refactor(Makefile): rename test rule to unit +9af6a9ffe chore(Dockerfile): remove directory check +f4b787383 fix(build): enable cgo +e33c1c0a7 chore(go.sum): regenerate go.sum +584c8197c feat(make): prevent test caching +fc5eefe70 fix(test): add missing fields to expected bundle +c226b2f21 fix(client): correct package used for healthcheck client +42d57e1fd feat(image): add CI compatible Dockerfile +156c40986 Merge pull request #10 from ecordell/move-health +b05b41925 fix(health): move health to its own package with the right package name +acb1e805a Merge pull request #9 from njhale/grpc-health-probe +561ba55fd feat(health): add gRPC health probe tool to docker images +f01b157c3 Merge pull request #8 from njhale/termination-log +755bba780 refactor(logs): factor out default writer hook setup +217e9fde5 feat(configmap-server): write panic and fatal log levels to a termination log - adds `termination-log` flag to `configmap-server` binary to specify termination log path - writes panic and fatal log levels to a termination log +0e5829177 feat(registry-server): write panic and fatal log levels to a termination log +b02598f48 feat(logs): add WriterHook type for splitting log levels between writers +bd9135471 fix(go-mod): fix checksum issue with client-go go module +4a95f4762 Merge pull request #7 from ecordell/fix-crd-parsing +344e126b5 fix(bundle): fix CRD . parsing +eed1e3c20 Merge pull request #6 from ecordell/readme +a22de90bd chore(docs): update readme with configmap-sever and pkg/client +7a2481a19 feat(health): add healthcheck endpoint +07842f742 feat(schema): add validators to directory loader +4e431bcd2 feat(client): add grpc client interface +f2e497cc8 feat(bundle): add package/channel name to bundle +106a8d98d chore(deps): switch to go modules +0e5cda08f Merge pull request #5 from ecordell/reflection +c66a4d03a feat(grpc): enable reflection on grpc endpoints +02055cf87 Merge pull request #4 from ecordell/grpc +3f59e9f6d feat(configmap-server): add dockerfile which builds and runs configmap-server +1a0cf5eb7 feat(configmap-server): add configmap-server binary +59c175ed3 chore(deps): update dependencies for version-config +e003bf393 feat(registry-server): add server binary that speaks grpc +f3c8394a7 chore(deps): add proto dependencies +948c18dfc feat(grpc): adds basic gRPC interface to querier +527540792 Merge pull request #3 from ecordell/configmap +2fe122016 feat(load/query): support provided APIs that are apiservices +083292293 chore(deps): depend on latest OLM +fe5fc0213 feat(configmap): add configmap loader +256f3223e Merge pull request #2 from ecordell/basic-registry +fbe246ab0 Merge pull request #1 from ecordell/basic-registry +15b0a40f3 chore(deps): remove unneeded dependencies +5aa6d970e chore(pkg): make more like a kube-style go package +a52c3e1a6 feat(query): open db as immutable for querying +87a57dc25 feat(query): add query interface and refactor tables +8aafbd49f feat(load): add package and channel loading +0bacbf2b0 refactor(store): add storage abstraction +199af66f3 feat(loader): create basic loader that puts csvs and bundles into a sqllite db +b4f844f65 Remove overrides for GOOS and GOARCH in cpb Makefile recipe. +076370a4a reset staging/operator-registry +b2c0188f2 Merge pull request #33 from timflannagan/fix-version +eb653bcaa Makefile: Use the full git commit hash when building binaries +fc8fceebf Merge pull request #32 from timflannagan/cleanup +5674d1a72 base.Dockerfile: Bump the Go base image to use a 1.16 tag +a1dd03100 Remove root OLM_VERSION file +9dd58651d Merge pull request #31 from openshift-bot/art-consistency-openshift-4.8-operator-lifecycle-manager +5cf062295 Merge pull request #30 from openshift-bot/art-consistency-openshift-4.8-operator-registry +fe8af7ba1 Merge pull request #29 from timflannagan/build-opm-binary +ae248a830 Dockerfile,Makefile: Add opm binary and cross compilation target(s) +d1cbee907 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/b7ea3c7f495e67d5b790e3698b5c319b67e98b35/images/operator-lifecycle-manager.yml +0a0c4e3f2 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/b7ea3c7f495e67d5b790e3698b5c319b67e98b35/images/operator-registry.yml +6cc52b3f7 Merge pull request #27 from ankitathomas/manifest-crd-gen +637012048 remove top level deploy, crds directories +efd971ec8 add crd and manifest generation +30836f7ae Merge pull request #26 from timflannagan/updates +416ae4117 Makefile,Dockerfile: Add additional registry and OLM build targets +138cb4289 scripts: Address markdown violations in the README.md +a137de7eb cmds.go,vendor: Introduce the non-opm registry binary packages +1c46643a1 scripts: Check if the vendor directory needs to be populated first before running e2e packages +9869d83fb scripts: Avoid hardcoding the test e2e function called +4979ef16a Makefile: Update the e2e-related targets +f3f041098 staging: Update OLM modules after recent changes +3e7d2256f Merge pull request #25 from ankitathomas/release-4.8 +e15c0d7c5 go mod tidy and vendor +c45c5ddd4 Sync upstream operator-lifecycle-manager release-4.8 +d4db74a7a Sync upstream operator-registry v1.13.6 +6c922ea8c Sync upstream api v0.7.0 +7687486a0 README.md +0bbcb6c43 Use staged tests +7b32e4e3d Update scripts to track specific commit +f9bb28356 Merge pull request #21 from timflannagan/fix-unit-script +c5b021539 scripts: Update the unit.sh helper script and populate the nested staging directory +b3559db98 Merge pull request #20 from timflannagan/minor-updates +6b9b9d6b8 Makefile: Introduce additional test targets +0b2acc7a7 scripts: Introduce an e2e helper script +a2b4d716f Dockerfile: Copy the entire repository while building binaries +e057b1cba vendor: Re-sync vendor after adding debug statement to staging package +f712e45d9 Merge pull request #19 from timflannagan/update-root-registry-tag +ca2f7cdae Merge pull request #18 from timflannagan/single-go-mod +2a481b8da Update the base image for the operator-registry image +62a5ee560 WIP: Update root Dockerfile(s)/Makefile to build downstream images +ad38f168b .gitignore: Ignore nested staging vendor directories +90d992bde go.sum,vendor: Update vendor directory after adding package-server +09e96f17d Add the package-server to the list of local command packages +02af3f211 Makefile: Add build and basic test targets +1e76453fa Introduce cmds package that tracks the staging operator-framework directories +84711e296 go.sum,vendor: Update root vendorered dependencies +feff05e7c Remove any mirrored cmd,pkg staging packages +31e2e318c staging: Remove nested vendor directories +10fdf0150 Merge pull request #12 from timflannagan/update-root-makefile +aa3ed9f55 Makefile: Reduce the number of targets +be45d688a scripts: Add unit test helper scripts +8e343401b Dockerfile: Avoid hardcoding the kubebuilder version in multiple places +671db25a8 Merge pull request #10 from timflannagan/minor-updates +cef149683 Dockerfile: Avoid using the registry.svc.ci container registry +918821840 Copy OLM_VERSION from staging/operator-lifecycle-manager to root +55b5b469c Merge pull request #6 from timflannagan/bump-image-tags +543265256 Merge pull request #9 from timflannagan/sync-vendor-prow +13041aa9f staging/olm: Remove invalid trailing slash in the go-bindata dependency +6ba5fb361 staging: Ensure staging modules are synced +ee542782b Merge pull request #7 from timflannagan/add-minimal-gitignore +e18eb1b0f Add root .gitignore +1c679d74f *.Dockerfile: Manually bump the image tags to 4.8 +4694b1d65 Merge pull request #5 from timflannagan/ankitathomas/master +3f9b44835 staging: Remove the OWNERS files from the OLM-related staging repositories +a65e8778e Initial commit +584696e84 Merge pull request #1 from timflannagan/patch-2 +8ce5a0f97 Create OWNERS +1f6ab6366 Initial commit diff --git a/go.mod b/go.mod index 23f900bac4..05e7734d2a 100644 --- a/go.mod +++ b/go.mod @@ -4,13 +4,13 @@ go 1.16 require ( github.com/go-bindata/go-bindata/v3 v3.1.3 - github.com/go-logr/logr v0.4.0 + github.com/go-logr/logr v1.2.0 github.com/golang/mock v1.6.0 github.com/googleapis/gnostic v0.5.5 github.com/grpc-ecosystem/grpc-health-probe v0.4.4 github.com/maxbrunsfeld/counterfeiter/v6 v6.4.1 github.com/mikefarah/yq/v3 v3.0.0-20201202084205-8846255d1c37 - github.com/onsi/ginkgo v1.16.4 + github.com/onsi/ginkgo v1.16.5 github.com/openshift/api v0.0.0-20200331152225-585af27e34fd github.com/operator-framework/api v0.12.0 github.com/operator-framework/operator-lifecycle-manager v0.0.0-00010101000000-000000000000 @@ -22,14 +22,14 @@ require ( google.golang.org/protobuf v1.27.1 gopkg.in/yaml.v2 v2.4.0 helm.sh/helm/v3 v3.6.2 - k8s.io/api v0.22.2 - k8s.io/apimachinery v0.22.2 - k8s.io/client-go v0.22.2 - k8s.io/code-generator v0.22.2 - k8s.io/kube-openapi v0.0.0-20210527164424-3c818078ee3d - k8s.io/utils v0.0.0-20210819203725-bdf08cb9a70a - sigs.k8s.io/controller-runtime v0.10.0 - sigs.k8s.io/controller-tools v0.6.2 + k8s.io/api v0.23.1 + k8s.io/apimachinery v0.23.1 + k8s.io/client-go v0.23.1 + k8s.io/code-generator v0.23.1 + k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65 + k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b + sigs.k8s.io/controller-runtime v0.11.0 + sigs.k8s.io/controller-tools v0.8.0 ) replace ( diff --git a/go.sum b/go.sum index b5edf65a15..7e168a750f 100644 --- a/go.sum +++ b/go.sum @@ -114,6 +114,8 @@ github.com/Shopify/logrus-bugsnag v0.0.0-20171204204709-577dee27f20d/go.mod h1:H github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= +github.com/adrg/xdg v0.4.0 h1:RzRqFcjH4nE5C6oTAxhBtoE2IRyjBSa62SCbyPidvls= +github.com/adrg/xdg v0.4.0/go.mod h1:N6ag73EX4wyxeaoeHctc1mas01KZgsj5tYiAIwqJE/E= github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c= github.com/agnivade/levenshtein v1.0.1/go.mod h1:CURSv5d9Uaml+FovSIICkLbAUZ9S4RqaHDIsdSBg7lM= github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7/go.mod h1:6zEj6s6u/ghQa61ZWa/C2Aw3RkjiTBOix7dkqa1VLIs= @@ -182,6 +184,7 @@ github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/chai2010/gettext-go v0.0.0-20160711120539-c6fed771bfd5 h1:7aWHqerlJ41y6FOsEUvknqgXnGmJyJSbjhAWq5pO4F8= github.com/chai2010/gettext-go v0.0.0-20160711120539-c6fed771bfd5/go.mod h1:/iP1qXHoty45bqomnu2LM+VVyAEdWN+vtSHGlQgyxbw= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= @@ -268,9 +271,9 @@ github.com/dhui/dktest v0.3.0/go.mod h1:cyzIUfGsBEbZ6BT7tnXqAShHSXCZhSNmFl70sZ7c github.com/distribution/distribution v2.7.1+incompatible h1:aGFx4EvJWKEh//lHPLwFhFgwFHKH06TzNVPamrMn04M= github.com/distribution/distribution v2.7.1+incompatible/go.mod h1:EgLm2NgWtdKgzF9NpMzUKgzmR7AMmb0VQi2B+ZzDRjc= github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E= -github.com/docker/cli v0.0.0-20200130152716-5d0cf8839492/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= -github.com/docker/cli v20.10.5+incompatible h1:bjflayQbWg+xOkF2WPEAOi4Y7zWhR7ptoPhV/VqLVDE= github.com/docker/cli v20.10.5+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= +github.com/docker/cli v20.10.12+incompatible h1:lZlz0uzG+GH+c0plStMUdF/qk3ppmgnswpR5EbqzVGA= +github.com/docker/cli v20.10.12+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= github.com/docker/distribution v0.0.0-20191216044856-a8371794149d h1:jC8tT/S0OGx2cswpeUTn4gOIea8P08lD3VFQT0cOZ50= github.com/docker/distribution v0.0.0-20191216044856-a8371794149d/go.mod h1:0+TTO4EOBfRPhZXAeF1Vu+W3hHZ8eLp8PgKVZlcvtFY= github.com/docker/docker v0.7.3-0.20190103212154-2b7e084dc98b/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= @@ -324,8 +327,9 @@ github.com/evanphx/json-patch v0.5.2/go.mod h1:ZWS5hhDbVDyob71nXKNL0+PWn6ToqBHMi github.com/evanphx/json-patch v4.2.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/evanphx/json-patch v4.5.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= -github.com/evanphx/json-patch v4.11.0+incompatible h1:glyUF9yIYtMHzn8xaKw5rMhdWcwsYV8dZHIq5567/xs= github.com/evanphx/json-patch v4.11.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= +github.com/evanphx/json-patch v4.12.0+incompatible h1:4onqiflcdA9EOZ4RxV643DvftH5pOlLGNtQ5lPWQu84= +github.com/evanphx/json-patch v4.12.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/evanphx/json-patch/v5 v5.2.0/go.mod h1:G79N1coSVB93tBe7j6PhzjmR3/2VvlbKOFpnXhI9Bw4= github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d h1:105gxyaGwCFad8crR9dcMQWvV9Hvulu6hwUh4tWPJnM= github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d/go.mod h1:ZZMPRZwes7CROmyNKgQzC3XPs6L/G2EJLHddWejkmf4= @@ -345,13 +349,15 @@ github.com/form3tech-oss/jwt-go v3.2.3+incompatible/go.mod h1:pbq4aXjuKjdthFRnoD github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4= github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWpgI= +github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU= github.com/fsouza/fake-gcs-server v1.7.0/go.mod h1:5XIRs4YvwNbNoz+1JF8j6KLAyDh7RHGAyAK3EP2EsNk= github.com/fvbommel/sortorder v1.0.1/go.mod h1:uk88iVf1ovNn1iLfgUVU2F9o5eO30ui720w+kxuqRs0= github.com/garyburd/redigo v0.0.0-20150301180006-535138d7bcd7/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY= github.com/garyburd/redigo v1.6.0 h1:0VruCpn7yAIIu7pWVClQC8wxCJEcG3nyzpMSHKi1PQc= github.com/garyburd/redigo v1.6.0/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY= +github.com/getkin/kin-openapi v0.76.0/go.mod h1:660oXbgy5JFMKreazJaQTw7o+X00qeSyhcnluiMv+Xg= github.com/getsentry/raven-go v0.2.0/go.mod h1:KungGk8q33+aIAZUIVWZDr2OfAEBsO49PX4NzFV5kcQ= github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= @@ -386,10 +392,12 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas= github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= -github.com/go-logr/logr v0.4.0 h1:K7/B1jt6fIBQVd4Owv2MqGQClcgf0R266+7C/QjRcLc= github.com/go-logr/logr v0.4.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= -github.com/go-logr/zapr v0.4.0 h1:uc1uML3hRYL9/ZZPdgHS/n8Nzo+eaYL/Efxkkamf7OM= +github.com/go-logr/logr v1.2.0 h1:QK40JKJyMdUDz+h+xvCsru/bJhvG0UxvePV0ufL/AcE= +github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/zapr v0.4.0/go.mod h1:tabnROwaDl0UNxkVeFRbY8bwB37GwRv0P8lg6aAiEnk= +github.com/go-logr/zapr v1.2.0 h1:n4JnPI1T3Qq1SFEi/F8rwLrZERp2bso19PJZDB9dayk= +github.com/go-logr/zapr v1.2.0/go.mod h1:Qa4Bsj2Vb+FAVeAKsLD8RLQ+YRJB8YDmOAKxaBQf7Ro= github.com/go-openapi/analysis v0.0.0-20180825180245-b006789cd277/go.mod h1:k70tL6pCuVxPJOHXQ+wIac1FUrvNkHolPie/cLEU6hI= github.com/go-openapi/analysis v0.17.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik= github.com/go-openapi/analysis v0.18.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik= @@ -590,8 +598,9 @@ github.com/gorilla/handlers v1.4.2/go.mod h1:Qkdc/uu4tH4g6mTK6auzZ766c4CA0Ng8+o/ github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= github.com/gorilla/mux v1.7.1/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= github.com/gorilla/mux v1.7.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= -github.com/gorilla/mux v1.7.3 h1:gnP5JzjVOuiZD07fKKToCAOjS0yOpj/qPETTXCCS6hw= github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= +github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI= +github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= @@ -688,8 +697,9 @@ github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCV github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/json-iterator/go v1.1.11 h1:uVUAXhF2To8cbw/3xN3pxj6kk7TYKs98NIrTqPlMWAQ= github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= @@ -775,8 +785,9 @@ github.com/mattn/go-shellwords v1.0.11 h1:vCoR9VPpsk/TZFW2JwK5I9S0xdrtUq2bph6/Yj github.com/mattn/go-shellwords v1.0.11/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y= github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= github.com/mattn/go-sqlite3 v1.12.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= -github.com/mattn/go-sqlite3 v1.14.6 h1:dNPt6NO46WmLVt2DLNpwczCmdV5boIZ6g/tlDrlRUbg= github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= +github.com/mattn/go-sqlite3 v1.14.10 h1:MLn+5bFRlWMGoSRmJour3CL1w/qL96mvipqpwQW/Sfk= +github.com/mattn/go-sqlite3 v1.14.10/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= @@ -818,8 +829,9 @@ github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 h1:n6/2gBQ3RWajuToeY6ZtZTIKv2v7ThUy5KKusIT0yc0= github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00/go.mod h1:Pm3mSP3c5uWn86xMLZ5Sa7JB9GsEZySvHYXCTK4E9q4= github.com/morikuni/aec v0.0.0-20170113033406-39771216ff4c/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= @@ -859,8 +871,9 @@ github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+ github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= -github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= +github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= +github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= @@ -868,9 +881,9 @@ github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1Cpa github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= github.com/onsi/gomega v1.11.0/go.mod h1:azGKhqFUon9Vuj0YmTfLSmx0FUwqXYSTl5re8lQLTUg= -github.com/onsi/gomega v1.14.0/go.mod h1:cIuvLEne0aoVhAgh/O6ac0Op8WWw9H6eYCriF+tEHG0= -github.com/onsi/gomega v1.15.0 h1:WjP/FQ/sk43MRmnEcT+MlDw2TFvkrXlprrPST/IudjU= github.com/onsi/gomega v1.15.0/go.mod h1:cIuvLEne0aoVhAgh/O6ac0Op8WWw9H6eYCriF+tEHG0= +github.com/onsi/gomega v1.17.0 h1:9Luw4uT5HTjHTN8+aNcSThgH1vdXnmdJ8xIfZ4wyTRE= +github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk= github.com/opencontainers/go-digest v0.0.0-20170106003457-a6d0ee40d420/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s= github.com/opencontainers/go-digest v0.0.0-20180430190053-c9281466c8b2/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s= @@ -959,8 +972,9 @@ github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y8 github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc= github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA= github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= -github.com/prometheus/common v0.26.0 h1:iMAkS2TDoNWnKM+Kopnx/8tnEStIfpYA0ur0xQzzhMQ= github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= +github.com/prometheus/common v0.28.0 h1:vGVfV9KrDTvWt5boZO0I19g2E3CsWfpPPKZM9dt3mEw= +github.com/prometheus/common v0.28.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= github.com/prometheus/procfs v0.0.0-20180125133057-cb4147076ac7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= @@ -1101,6 +1115,7 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= github.com/yvasiyarov/go-metrics v0.0.0-20140926110328-57bccd1ccd43/go.mod h1:aX5oPXxHm3bOH+xeAttToC8pqch2ScQN/JoXYupl6xs= github.com/yvasiyarov/go-metrics v0.0.0-20150112132944-c25f46c4b940 h1:p7OofyZ509h8DmPLh8Hn+EIIZm/xYhdZHJ9GnXHdr6U= github.com/yvasiyarov/go-metrics v0.0.0-20150112132944-c25f46c4b940/go.mod h1:aX5oPXxHm3bOH+xeAttToC8pqch2ScQN/JoXYupl6xs= @@ -1182,8 +1197,10 @@ go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/goleak v1.1.10 h1:z+mqJhf6ss6BSfSM671tgKyZBFPTTJM+HLxnhPC3wu0= go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/goleak v1.1.12 h1:gZAh5/EyT/HQwlpkCy6wTpqfH9H8Lz8zbm3dZh+OyzA= +go.uber.org/goleak v1.1.12/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4= @@ -1192,8 +1209,9 @@ go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9E go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= -go.uber.org/zap v1.19.0 h1:mZQZefskPPCMIBCSEH0v2/iUqqLrYtaeqwD6FUGUnFE= go.uber.org/zap v1.19.0/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= +go.uber.org/zap v1.19.1 h1:ue41HOKd1vGURxrmeKIgELGb3jPW9DMUDGtsinblHwI= +go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI= golang.org/x/crypto v0.0.0-20171113213409-9f005a07e0d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= @@ -1219,8 +1237,9 @@ golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPh golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= -golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a h1:kr2P4QFmQr29mSLA43kwrOcgcReGTfbE9N577tCTuBc= golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= +golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ= +golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -1319,8 +1338,11 @@ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96b golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= golang.org/x/net v0.0.0-20210510120150-4163338589ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210520170846-37e1c6afe023/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20210825183410-e898025ed96a h1:bRuuGXV8wwSdGTB+CtJf+FjgO1APK1CoO39T4BN/XBw= +golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210825183410-e898025ed96a/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211209124913-491a49abca63 h1:iocB37TsdFuN6IBRZ+ry36wrkoV51/tl5vOWqkcPGvY= +golang.org/x/net v0.0.0-20211209124913-491a49abca63/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181106182150-f42d05182288/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -1334,8 +1356,10 @@ golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602 h1:0Ja1LBD+yisY6RWM/BH7TJVXWsSjs2VwBSmvSX4HdBc= golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f h1:Qmd2pbz05z7z6lm0DrgQVVPuBm92jqujBKMHMOlOQEw= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -1433,18 +1457,23 @@ golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210817190340-bfb29a6856f2/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e h1:XMgFehsDnnLGtjvjOfqWSUzt0alpTR1RSEuznObga2c= golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211029165221-6e7872819dc8 h1:M69LAlWZCshgp0QSzyDcSsSIejIEeuaCVpmwcKwyLMk= +golang.org/x/sys v0.0.0-20211029165221-6e7872819dc8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE= golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE= +golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1533,8 +1562,9 @@ golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.5 h1:ouewzE6p+/VEB31YYnTbEJdi8pFqKp4P4n85vwo3DHA= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff h1:VX/uD7MK0AHXGiScH3fsieUQUcpmRERPDYtqZdJnA+Q= +golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff/go.mod h1:YD9qOF0M9xpSpdWTBbzEl5e/RnCefISl8E5Noe10jFM= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -1751,62 +1781,63 @@ honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9 k8s.io/api v0.18.0/go.mod h1:q2HRQkfDzHMBZL9l/y9rH63PkQl4vae0xRT+8prbrK8= k8s.io/api v0.21.0-rc.0/go.mod h1:Dkc/ZauWJrgZhjOjeBgW89xZQiTBJA2RaBKYHXPsi2Y= k8s.io/api v0.21.0/go.mod h1:+YbrhBBGgsxbF6o6Kj4KJPJnBmAKuXDeS3E18bgHNVU= -k8s.io/api v0.21.3/go.mod h1:hUgeYHUbBp23Ue4qdX9tR8/ANi/g3ehylAqDn9NWVOg= k8s.io/api v0.22.0/go.mod h1:0AoXXqst47OI/L0oGKq9DG61dvGRPXs7X4/B7KyjBCU= k8s.io/api v0.22.1/go.mod h1:bh13rkTp3F1XEaLGykbyRD2QaTTzPm0e/BMd8ptFONY= -k8s.io/api v0.22.2 h1:M8ZzAD0V6725Fjg53fKeTJxGsJvRbk4TEm/fexHMtfw= -k8s.io/api v0.22.2/go.mod h1:y3ydYpLJAaDI+BbSe2xmGcqxiWHmWjkEeIbiwHvnPR8= +k8s.io/api v0.23.0/go.mod h1:8wmDdLBHBNxtOIytwLstXt5E9PddnZb0GaMcqsvDBpg= +k8s.io/api v0.23.1 h1:ncu/qfBfUoClqwkTGbeRqqOqBCRoUAflMuOaOD7J0c8= +k8s.io/api v0.23.1/go.mod h1:WfXnOnwSqNtG62Y1CdjoMxh7r7u9QXGCkA1u0na2jgo= k8s.io/apiextensions-apiserver v0.21.0/go.mod h1:gsQGNtGkc/YoDG9loKI0V+oLZM4ljRPjc/sql5tmvzc= -k8s.io/apiextensions-apiserver v0.21.3/go.mod h1:kl6dap3Gd45+21Jnh6utCx8Z2xxLm8LGDkprcd+KbsE= k8s.io/apiextensions-apiserver v0.22.1/go.mod h1:HeGmorjtRmRLE+Q8dJu6AYRoZccvCMsghwS8XTUYb2c= -k8s.io/apiextensions-apiserver v0.22.2 h1:zK7qI8Ery7j2CaN23UCFaC1hj7dMiI87n01+nKuewd4= -k8s.io/apiextensions-apiserver v0.22.2/go.mod h1:2E0Ve/isxNl7tWLSUDgi6+cmwHi5fQRdwGVCxbC+KFA= +k8s.io/apiextensions-apiserver v0.23.0 h1:uii8BYmHYiT2ZTAJxmvc3X8UhNYMxl2A0z0Xq3Pm+WY= +k8s.io/apiextensions-apiserver v0.23.0/go.mod h1:xIFAEEDlAZgpVBl/1VSjGDmLoXAWRG40+GsWhKhAxY4= k8s.io/apimachinery v0.18.0/go.mod h1:9SnR/e11v5IbyPCGbvJViimtJ0SwHG4nfZFjU77ftcA= k8s.io/apimachinery v0.20.2/go.mod h1:WlLqWAHZGg07AeltaI0MV5uk1Omp8xaN0JGLY6gkRpU= k8s.io/apimachinery v0.21.0-rc.0/go.mod h1:jbreFvJo3ov9rj7eWT7+sYiRx+qZuCYXwWT1bcDswPY= k8s.io/apimachinery v0.21.0/go.mod h1:jbreFvJo3ov9rj7eWT7+sYiRx+qZuCYXwWT1bcDswPY= -k8s.io/apimachinery v0.21.3/go.mod h1:H/IM+5vH9kZRNJ4l3x/fXP/5bOPJaVP/guptnZPeCFI= k8s.io/apimachinery v0.22.0/go.mod h1:O3oNtNadZdeOMxHFVxOreoznohCpy0z6mocxbZr7oJ0= k8s.io/apimachinery v0.22.1/go.mod h1:O3oNtNadZdeOMxHFVxOreoznohCpy0z6mocxbZr7oJ0= -k8s.io/apimachinery v0.22.2 h1:ejz6y/zNma8clPVfNDLnPbleBo6MpoFy/HBiBqCouVk= -k8s.io/apimachinery v0.22.2/go.mod h1:O3oNtNadZdeOMxHFVxOreoznohCpy0z6mocxbZr7oJ0= +k8s.io/apimachinery v0.23.0/go.mod h1:fFCTTBKvKcwTPFzjlcxp91uPFZr+JA0FubU4fLzzFYc= +k8s.io/apimachinery v0.23.1 h1:sfBjlDFwj2onG0Ijx5C+SrAoeUscPrmghm7wHP+uXlo= +k8s.io/apimachinery v0.23.1/go.mod h1:SADt2Kl8/sttJ62RRsi9MIV4o8f5S3coArm0Iu3fBno= k8s.io/apiserver v0.21.0/go.mod h1:w2YSn4/WIwYuxG5zJmcqtRdtqgW/J2JRgFAqps3bBpg= -k8s.io/apiserver v0.21.3/go.mod h1:eDPWlZG6/cCCMj/JBcEpDoK+I+6i3r9GsChYBHSbAzU= k8s.io/apiserver v0.22.0/go.mod h1:04kaIEzIQrTGJ5syLppQWvpkLJXQtJECHmae+ZGc/nc= k8s.io/apiserver v0.22.1/go.mod h1:2mcM6dzSt+XndzVQJX21Gx0/Klo7Aen7i0Ai6tIa400= -k8s.io/apiserver v0.22.2 h1:TdIfZJc6YNhu2WxeAOWq1TvukHF0Sfx0+ln4XK9qnL4= -k8s.io/apiserver v0.22.2/go.mod h1:vrpMmbyjWrgdyOvZTSpsusQq5iigKNWv9o9KlDAbBHI= +k8s.io/apiserver v0.23.0 h1:Ds/QveXWi9aJ8ISB0CJa4zBNc5njxAs5u3rmMIexqCY= +k8s.io/apiserver v0.23.0/go.mod h1:Cec35u/9zAepDPPFyT+UMrgqOCjgJ5qtfVJDxjZYmt4= k8s.io/cli-runtime v0.21.0/go.mod h1:XoaHP93mGPF37MkLbjGVYqg3S1MnsFdKtiA/RZzzxOo= -k8s.io/cli-runtime v0.22.0 h1:xM0UJ91iPKvPeooS/LS4U3sPVRAeUrUslJ0sUtE7a7Q= k8s.io/cli-runtime v0.22.0/go.mod h1:An6zELQ7udUI0GaXvkuMqyopPA14dIgNqpH8cZu1vig= +k8s.io/cli-runtime v0.23.1 h1:vHUZrq1Oejs0WaJnxs09mLHKScvIIl2hMSthhS8o8Yo= +k8s.io/cli-runtime v0.23.1/go.mod h1:r9r8H/qfXo9w+69vwUL7LokKlLRKW5D6A8vUKCx+YL0= k8s.io/client-go v0.18.0/go.mod h1:uQSYDYs4WhVZ9i6AIoEZuwUggLVEF64HOD37boKAtF8= k8s.io/client-go v0.21.0/go.mod h1:nNBytTF9qPFDEhoqgEPaarobC8QPae13bElIVHzIglA= -k8s.io/client-go v0.21.3/go.mod h1:+VPhCgTsaFmGILxR/7E1N0S+ryO010QBeNCv5JwRGYU= k8s.io/client-go v0.22.0/go.mod h1:GUjIuXR5PiEv/RVK5OODUsm6eZk7wtSWZSaSJbpFdGg= k8s.io/client-go v0.22.1/go.mod h1:BquC5A4UOo4qVDUtoc04/+Nxp1MeHcVc1HJm1KmG8kk= -k8s.io/client-go v0.22.2 h1:DaSQgs02aCC1QcwUdkKZWOeaVsQjYvWv8ZazcZ6JcHc= -k8s.io/client-go v0.22.2/go.mod h1:sAlhrkVDf50ZHx6z4K0S40wISNTarf1r800F+RlCF6U= +k8s.io/client-go v0.23.0/go.mod h1:hrDnpnK1mSr65lHHcUuIZIXDgEbzc7/683c6hyG4jTA= +k8s.io/client-go v0.23.1 h1:Ma4Fhf/p07Nmj9yAB1H7UwbFHEBrSPg8lviR24U2GiQ= +k8s.io/client-go v0.23.1/go.mod h1:6QSI8fEuqD4zgFK0xbdwfB/PthBsIxCJMa3s17WlcO0= k8s.io/code-generator v0.18.0/go.mod h1:+UHX5rSbxmR8kzS+FAv7um6dtYrZokQvjHpDSYRVkTc= k8s.io/code-generator v0.21.0-rc.0/go.mod h1:hUlps5+9QaTrKx+jiM4rmq7YmH8wPOIko64uZCHDh6Q= k8s.io/code-generator v0.21.0/go.mod h1:hUlps5+9QaTrKx+jiM4rmq7YmH8wPOIko64uZCHDh6Q= -k8s.io/code-generator v0.21.3/go.mod h1:K3y0Bv9Cz2cOW2vXUrNZlFbflhuPvuadW6JdnN6gGKo= k8s.io/code-generator v0.22.0/go.mod h1:eV77Y09IopzeXOJzndrDyCI88UBok2h6WxAlBwpxa+o= k8s.io/code-generator v0.22.1/go.mod h1:eV77Y09IopzeXOJzndrDyCI88UBok2h6WxAlBwpxa+o= -k8s.io/code-generator v0.22.2 h1:+bUv9lpTnAWABtPkvO4x0kfz7j/kDEchVt0P/wXU3jQ= -k8s.io/code-generator v0.22.2/go.mod h1:eV77Y09IopzeXOJzndrDyCI88UBok2h6WxAlBwpxa+o= +k8s.io/code-generator v0.23.0/go.mod h1:vQvOhDXhuzqiVfM/YHp+dmg10WDZCchJVObc9MvowsE= +k8s.io/code-generator v0.23.1 h1:ViFOlP/0bYD7VrnUDS+ch5ej5EIuMawFmHcRuv9Yxyw= +k8s.io/code-generator v0.23.1/go.mod h1:V7yn6VNTCWW8GqodYCESVo95fuiEg713S8B7WacWZDA= k8s.io/component-base v0.21.0/go.mod h1:qvtjz6X0USWXbgmbfXR+Agik4RZ3jv2Bgr5QnZzdPYw= -k8s.io/component-base v0.21.3/go.mod h1:kkuhtfEHeZM6LkX0saqSK8PbdO7A0HigUngmhhrwfGQ= k8s.io/component-base v0.22.0/go.mod h1:SXj6Z+V6P6GsBhHZVbWCw9hFjUdUYnJerlhhPnYCBCg= k8s.io/component-base v0.22.1/go.mod h1:0D+Bl8rrnsPN9v0dyYvkqFfBeAd4u7n77ze+p8CMiPo= -k8s.io/component-base v0.22.2 h1:vNIvE0AIrLhjX8drH0BgCNJcR4QZxMXcJzBsDplDx9M= -k8s.io/component-base v0.22.2/go.mod h1:5Br2QhI9OTe79p+TzPe9JKNQYvEKbq9rTJDWllunGug= +k8s.io/component-base v0.23.0/go.mod h1:DHH5uiFvLC1edCpvcTDV++NKULdYYU6pR9Tt3HIKMKI= +k8s.io/component-base v0.23.1 h1:j/BqdZUWeWKCy2v/jcgnOJAzpRYWSbGcjGVYICko8Uc= +k8s.io/component-base v0.23.1/go.mod h1:6llmap8QtJIXGDd4uIWJhAq0Op8AtQo6bDW2RrNMTeo= k8s.io/component-helpers v0.21.0/go.mod h1:tezqefP7lxfvJyR+0a+6QtVrkZ/wIkyMLK4WcQ3Cj8U= k8s.io/component-helpers v0.22.0/go.mod h1:YNIbQI59ayNiU8JHlPIxVkOUYycbKhk5Niy0pcyJOEY= +k8s.io/component-helpers v0.23.1/go.mod h1:ZK24U+2oXnBPcas2KolLigVVN9g5zOzaHLkHiQMFGr0= k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= k8s.io/gengo v0.0.0-20200114144118-36b2048a9120/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= k8s.io/gengo v0.0.0-20200413195148-3a45101e95ac/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= -k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027 h1:Uusb3oh8XcdzDF/ndlI4ToKTYVlkCSJP39SRY2mfRAw= k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E= +k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c h1:GohjlNKauSai7gN4wsJkeZ3WAJx4Sh+oT/b5IYn5suA= +k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E= k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk= k8s.io/klog v0.3.0/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk= k8s.io/klog v1.0.0 h1:Pt+yjF5aB1xDSVbau4VsWe+dQNzA0qv1LlXdC2dF6Q8= @@ -1815,57 +1846,69 @@ k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE= k8s.io/klog/v2 v2.2.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y= k8s.io/klog/v2 v2.4.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y= k8s.io/klog/v2 v2.8.0/go.mod h1:hy9LJ/NvuK+iVyP4Ehqva4HxZG/oXyIS3n3Jmire4Ec= -k8s.io/klog/v2 v2.9.0 h1:D7HV+n1V57XeZ0m6tdRkfknthUaM06VFbWldOFh8kzM= k8s.io/klog/v2 v2.9.0/go.mod h1:hy9LJ/NvuK+iVyP4Ehqva4HxZG/oXyIS3n3Jmire4Ec= +k8s.io/klog/v2 v2.30.0 h1:bUO6drIvCIsvZ/XFgfxoGFQU/a4Qkh0iAlvUR7vlHJw= +k8s.io/klog/v2 v2.30.0/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= k8s.io/kube-aggregator v0.22.0 h1:he3plI8vlaPJxR9vsy/lL5ga1V8CoA8M8x1Bn8eTCeM= k8s.io/kube-aggregator v0.22.0/go.mod h1:zHTepg0Q4tKzru7Pwg1QYHWrU/wrvIXM8hUdDAH66qg= k8s.io/kube-openapi v0.0.0-20200121204235-bf4fb3bd569c/go.mod h1:GRQhZsXIAJ1xR0C9bd8UpWHZ5plfAS9fzPjJuQ6JL3E= k8s.io/kube-openapi v0.0.0-20201113171705-d219536bb9fd/go.mod h1:WOJ3KddDSol4tAGcJo0Tvi+dK12EcqSLqcWsryKMpfM= k8s.io/kube-openapi v0.0.0-20210305001622-591a79e4bda7/go.mod h1:wXW5VT87nVfh/iLV8FpR2uDvrFyomxbtb1KivDbvPTE= k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e/go.mod h1:vHXdDvt9+2spS2Rx9ql3I8tycm3H9FDfdUoIuKCefvw= -k8s.io/kube-openapi v0.0.0-20210527164424-3c818078ee3d h1:lUK8GPtuJy8ClWZhuvKoaLdKGPLq9H1PxWp7VPBZBkU= -k8s.io/kube-openapi v0.0.0-20210527164424-3c818078ee3d/go.mod h1:vHXdDvt9+2spS2Rx9ql3I8tycm3H9FDfdUoIuKCefvw= +k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65 h1:E3J9oCLlaobFUqsjG9DfKbP2BmgwBL2p7pn0A3dG9W4= +k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65/go.mod h1:sX9MT8g7NVZM5lVL/j8QyCCJe8YSMW30QvGZWaCIDIk= k8s.io/kubectl v0.21.0/go.mod h1:EU37NukZRXn1TpAkMUoy8Z/B2u6wjHDS4aInsDzVvks= -k8s.io/kubectl v0.22.0 h1:EBb7xLUaidG/YXAI5AXam3lK2VlnoFShhlMjnJVTbGA= k8s.io/kubectl v0.22.0/go.mod h1:eeuP92uZbVL2UnOaf0nj9OjtI0hi/nekHU+0isURer0= +k8s.io/kubectl v0.23.1 h1:gmscOiV4Y4XIRIn14gQBBADoyyVrDZPbxRCTDga4RSA= +k8s.io/kubectl v0.23.1/go.mod h1:Ui7dJKdUludF8yWAOSN7JZEkOuYixX5yF6E6NjoukKE= k8s.io/metrics v0.21.0/go.mod h1:L3Ji9EGPP1YBbfm9sPfEXSpnj8i24bfQbAFAsW0NueQ= k8s.io/metrics v0.22.0/go.mod h1:eYnwafAUNLLpVmY/msoq0RKIKH5C4TzfjKnMZ0Xrt3A= +k8s.io/metrics v0.23.1/go.mod h1:qXvsM1KANrc+ZZeFwj6Phvf0NLiC+d3RwcsLcdGc+xs= k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew= k8s.io/utils v0.0.0-20201110183641-67b214c5f920/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= k8s.io/utils v0.0.0-20210707171843-4b05e18ac7d9/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= k8s.io/utils v0.0.0-20210802155522-efc7438f0176/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= -k8s.io/utils v0.0.0-20210819203725-bdf08cb9a70a h1:8dYfu/Fc9Gz2rNJKB9IQRGgQOh2clmRzNIPPY1xLY5g= -k8s.io/utils v0.0.0-20210819203725-bdf08cb9a70a/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= +k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b h1:wxEMGetGMur3J1xuGLQY7GEQYg9bZxKn3tKo5k/eYcs= +k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/letsencrypt v0.0.3/go.mod h1:buyQKZ6IXrRnB7TdkHP0RyEybLx18HHyOSoTyoOLqNY= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.15/go.mod h1:LEScyzhFmoF5pso/YSeBstl57mOzx9xlU9n85RGrDQg= -sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.19/go.mod h1:LEScyzhFmoF5pso/YSeBstl57mOzx9xlU9n85RGrDQg= -sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.22 h1:fmRfl9WJ4ApJn7LxNuED4m0t18qivVQOxP6aAYG9J6c= sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.22/go.mod h1:LEScyzhFmoF5pso/YSeBstl57mOzx9xlU9n85RGrDQg= -sigs.k8s.io/controller-runtime v0.10.0 h1:HgyZmMpjUOrtkaFtCnfxsR1bGRuFoAczSNbn2MoKj5U= +sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.25 h1:DEQ12ZRxJjsglk5JIi5bLgpKaHihGervKmg5uryaEHw= +sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.25/go.mod h1:Mlj9PNLmG9bZ6BHFwFKDo5afkpWyUISkb9Me0GnK66I= sigs.k8s.io/controller-runtime v0.10.0/go.mod h1:GCdh6kqV6IY4LK0JLwX0Zm6g233RtVGdb/f0+KSfprg= -sigs.k8s.io/controller-tools v0.6.2 h1:+Y8L0UsAugDipGRw8lrkPoAi6XqlQVZuf1DQHME3PgU= -sigs.k8s.io/controller-tools v0.6.2/go.mod h1:oaeGpjXn6+ZSEIQkUe/+3I40PNiDYp9aeawbt3xTgJ8= +sigs.k8s.io/controller-runtime v0.11.0 h1:DqO+c8mywcZLFJWILq4iktoECTyn30Bkj0CwgqMpZWQ= +sigs.k8s.io/controller-runtime v0.11.0/go.mod h1:KKwLiTooNGu+JmLZGn9Sl3Gjmfj66eMbCQznLP5zcqA= +sigs.k8s.io/controller-tools v0.8.0 h1:uUkfTGEwrguqYYfcI2RRGUnC8mYdCFDqfwPKUcNJh1o= +sigs.k8s.io/controller-tools v0.8.0/go.mod h1:qE2DXhVOiEq5ijmINcFbqi9GZrrUjzB1TuJU0xa6eoY= +sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6 h1:fD1pz4yfdADVNfFmcP2aBEtudwUQ1AlLnRBALr33v3s= +sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6/go.mod h1:p4QtZmO4uMYipTQNzagwnNoseA6OxSUutVw05NhYDRs= sigs.k8s.io/kind v0.11.1/go.mod h1:fRpgVhtqAWrtLB9ED7zQahUimpUXuG/iHT88xYqEGIA= sigs.k8s.io/kustomize/api v0.8.5/go.mod h1:M377apnKT5ZHJS++6H4rQoCHmWtt6qTpp3mbe7p6OLY= -sigs.k8s.io/kustomize/api v0.8.11 h1:LzQzlq6Z023b+mBtc6v72N2mSHYmN8x7ssgbf/hv0H8= sigs.k8s.io/kustomize/api v0.8.11/go.mod h1:a77Ls36JdfCWojpUqR6m60pdGY1AYFix4AH83nJtY1g= +sigs.k8s.io/kustomize/api v0.10.1 h1:KgU7hfYoscuqag84kxtzKdEC3mKMb99DPI3a0eaV1d0= +sigs.k8s.io/kustomize/api v0.10.1/go.mod h1:2FigT1QN6xKdcnGS2Ppp1uIWrtWN28Ms8A3OZUZhwr8= sigs.k8s.io/kustomize/cmd/config v0.9.7/go.mod h1:MvXCpHs77cfyxRmCNUQjIqCmZyYsbn5PyQpWiq44nW0= sigs.k8s.io/kustomize/cmd/config v0.9.13/go.mod h1:7547FLF8W/lTaDf0BDqFTbZxM9zqwEJqCKN9sSR0xSs= +sigs.k8s.io/kustomize/cmd/config v0.10.2/go.mod h1:K2aW7nXJ0AaT+VA/eO0/dzFLxmpFcTzudmAgDwPY1HQ= sigs.k8s.io/kustomize/kustomize/v4 v4.0.5/go.mod h1:C7rYla7sI8EnxHE/xEhRBSHMNfcL91fx0uKmUlUhrBk= sigs.k8s.io/kustomize/kustomize/v4 v4.2.0/go.mod h1:MOkR6fmhwG7hEDRXBYELTi5GSFcLwfqwzTRHW3kv5go= +sigs.k8s.io/kustomize/kustomize/v4 v4.4.1/go.mod h1:qOKJMMz2mBP+vcS7vK+mNz4HBLjaQSWRY22EF6Tb7Io= sigs.k8s.io/kustomize/kyaml v0.10.15/go.mod h1:mlQFagmkm1P+W4lZJbJ/yaxMd8PqMRSC4cPcfUVt5Hg= -sigs.k8s.io/kustomize/kyaml v0.11.0 h1:9KhiCPKaVyuPcgOLJXkvytOvjMJLoxpjodiycb4gHsA= sigs.k8s.io/kustomize/kyaml v0.11.0/go.mod h1:GNMwjim4Ypgp/MueD3zXHLRJEjz7RvtPae0AwlvEMFM= +sigs.k8s.io/kustomize/kyaml v0.13.0 h1:9c+ETyNfSrVhxvphs+K2dzT3dh5oVPPEqPOE/cUpScY= +sigs.k8s.io/kustomize/kyaml v0.13.0/go.mod h1:FTJxEZ86ScK184NpGSAQcfEqee0nul8oLCK30D47m4E= sigs.k8s.io/structured-merge-diff/v3 v3.0.0-20200116222232-67a7b8c61874/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw= sigs.k8s.io/structured-merge-diff/v3 v3.0.0/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw= sigs.k8s.io/structured-merge-diff/v4 v4.0.2/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw= sigs.k8s.io/structured-merge-diff/v4 v4.1.0/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw= -sigs.k8s.io/structured-merge-diff/v4 v4.1.2 h1:Hr/htKFmJEbtMgS/UD0N+gtgctAqz81t3nu+sPzynno= sigs.k8s.io/structured-merge-diff/v4 v4.1.2/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4= +sigs.k8s.io/structured-merge-diff/v4 v4.2.0 h1:kDvPBbnPk+qYmkHmSo8vKGp438IASWofnbbUKDE/bv0= +sigs.k8s.io/structured-merge-diff/v4 v4.2.0/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4= sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= -sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q= sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc= +sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= +sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU= diff --git a/manifests/0000_50_olm_00-catalogsources.crd.yaml b/manifests/0000_50_olm_00-catalogsources.crd.yaml index c32ea2be6f..2bbfe0ca48 100644 --- a/manifests/0000_50_olm_00-catalogsources.crd.yaml +++ b/manifests/0000_50_olm_00-catalogsources.crd.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" creationTimestamp: null @@ -147,7 +147,7 @@ spec: description: Represents the state of a CatalogSource. Note that Message and Reason represent the original status information, which may be migrated to be conditions based in the future. Any new features introduced will use conditions. type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/manifests/0000_50_olm_00-clusterserviceversions.crd.yaml b/manifests/0000_50_olm_00-clusterserviceversions.crd.yaml index 726547b388..a9e323db3b 100644 --- a/manifests/0000_50_olm_00-clusterserviceversions.crd.yaml +++ b/manifests/0000_50_olm_00-clusterserviceversions.crd.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" creationTimestamp: null @@ -572,7 +572,7 @@ spec: items: type: string verbs: - description: Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + description: Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. type: array items: type: string @@ -1299,7 +1299,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1345,7 +1345,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -1360,11 +1360,11 @@ spec: - type: string x-kubernetes-int-or-string: true preStop: - description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod''s termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' + description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod''s termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1410,7 +1410,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -1429,7 +1429,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1441,6 +1441,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -1491,7 +1504,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -1552,7 +1565,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1564,6 +1577,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -1614,7 +1640,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -1663,10 +1689,10 @@ spec: type: object properties: allowPrivilegeEscalation: - description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN' + description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.' type: boolean capabilities: - description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. + description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. type: object properties: add: @@ -1682,27 +1708,27 @@ spec: description: Capability represent POSIX capabilities type type: string privileged: - description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. type: boolean procMount: - description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. + description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. type: string readOnlyRootFilesystem: - description: Whether this container has a read-only root filesystem. Default is false. + description: Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. type: boolean runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -1718,7 +1744,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. + description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -1730,7 +1756,7 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -1750,7 +1776,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1762,6 +1788,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -1812,7 +1851,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -1929,10 +1968,10 @@ spec: description: 'EnableServiceLinks indicates whether information about services should be injected into pod''s environment variables, matching the syntax of Docker links. Optional: Defaults to true.' type: boolean ephemeralContainers: - description: List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is alpha-level and is only honored by servers that enable the EphemeralContainers feature. + description: List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate. type: array items: - description: An EphemeralContainer is a container that may be added temporarily to an existing pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a pod is removed or restarted. If an ephemeral container causes a pod to exceed its resource allocation, the pod may be evicted. Ephemeral containers may not be added by directly updating the pod spec. They must be added via the pod's ephemeralcontainers subresource, and they will appear in the pod spec once added. This is an alpha feature enabled by the EphemeralContainers feature flag. + description: "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation. \n To add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted. \n This is a beta feature available on clusters that haven't disabled the EphemeralContainers feature gate." type: object required: - name @@ -2072,7 +2111,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2118,7 +2157,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2133,11 +2172,11 @@ spec: - type: string x-kubernetes-int-or-string: true preStop: - description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod''s termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' + description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod''s termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2183,7 +2222,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2202,7 +2241,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2214,6 +2253,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -2264,7 +2316,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -2316,12 +2368,16 @@ spec: description: Protocol for port. Must be UDP, TCP, or SCTP. Defaults to "TCP". type: string default: TCP + x-kubernetes-list-map-keys: + - containerPort + - protocol + x-kubernetes-list-type: map readinessProbe: description: Probes are not allowed for ephemeral containers. type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2333,6 +2389,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -2383,7 +2452,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -2432,10 +2501,10 @@ spec: type: object properties: allowPrivilegeEscalation: - description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN' + description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.' type: boolean capabilities: - description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. + description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. type: object properties: add: @@ -2451,27 +2520,27 @@ spec: description: Capability represent POSIX capabilities type type: string privileged: - description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. type: boolean procMount: - description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. + description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. type: string readOnlyRootFilesystem: - description: Whether this container has a read-only root filesystem. Default is false. + description: Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. type: boolean runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -2487,7 +2556,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. + description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -2499,7 +2568,7 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -2519,7 +2588,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2531,6 +2600,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -2581,7 +2663,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -2610,7 +2692,7 @@ spec: description: Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false type: boolean targetContainerName: - description: If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container is run in whatever namespaces are shared for the pod. Note that the container runtime must support this feature. + description: "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec. \n The container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined." type: string terminationMessagePath: description: 'Optional: Path at which the file to which the container''s termination message will be written is mounted into the container''s filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.' @@ -2638,7 +2720,7 @@ spec: description: name must match the name of a persistentVolumeClaim in the pod type: string volumeMounts: - description: Pod volumes to mount into the container's filesystem. Cannot be updated. + description: Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated. type: array items: description: VolumeMount describes a mounting of a Volume within a container. @@ -2849,7 +2931,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2895,7 +2977,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2910,11 +2992,11 @@ spec: - type: string x-kubernetes-int-or-string: true preStop: - description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod''s termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' + description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod''s termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2960,7 +3042,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2979,7 +3061,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2991,6 +3073,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -3041,7 +3136,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -3102,7 +3197,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -3114,6 +3209,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -3164,7 +3272,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -3213,10 +3321,10 @@ spec: type: object properties: allowPrivilegeEscalation: - description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN' + description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.' type: boolean capabilities: - description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. + description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. type: object properties: add: @@ -3232,27 +3340,27 @@ spec: description: Capability represent POSIX capabilities type type: string privileged: - description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. type: boolean procMount: - description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. + description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. type: string readOnlyRootFilesystem: - description: Whether this container has a read-only root filesystem. Default is false. + description: Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. type: boolean runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -3268,7 +3376,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. + description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -3280,7 +3388,7 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -3300,7 +3408,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -3312,6 +3420,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -3362,7 +3483,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -3455,6 +3576,15 @@ spec: additionalProperties: type: string x-kubernetes-map-type: atomic + os: + description: "Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set. \n If the OS field is set to linux, the following fields must be unset: -securityContext.windowsOptions \n If the OS field is set to windows, following fields must be unset: - spec.hostPID - spec.hostIPC - spec.securityContext.seLinuxOptions - spec.securityContext.seccompProfile - spec.securityContext.fsGroup - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls - spec.shareProcessNamespace - spec.securityContext.runAsUser - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups - spec.containers[*].securityContext.seLinuxOptions - spec.containers[*].securityContext.seccompProfile - spec.containers[*].securityContext.capabilities - spec.containers[*].securityContext.readOnlyRootFilesystem - spec.containers[*].securityContext.privileged - spec.containers[*].securityContext.allowPrivilegeEscalation - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser - spec.containers[*].securityContext.runAsGroup This is an alpha field and requires the IdentifyPodOS feature" + type: object + required: + - name + properties: + name: + description: 'Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null' + type: string overhead: description: 'Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md This field is beta-level as of Kubernetes v1.18, and is only honored by servers that enable the PodOverhead feature.' type: object @@ -3500,25 +3630,25 @@ spec: type: object properties: fsGroup: - description: "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: \n 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- \n If unset, the Kubelet will not modify the ownership and permissions of any volume." + description: "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: \n 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- \n If unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows." type: integer format: int64 fsGroupChangePolicy: - description: 'fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used.' + description: 'fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used. Note that this field cannot be set when spec.os.name is windows.' type: string runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + description: The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -3534,7 +3664,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by the containers in this pod. + description: The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -3546,13 +3676,13 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string supplementalGroups: - description: A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. + description: A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows. type: array items: type: integer format: int64 sysctls: - description: Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. + description: Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows. type: array items: description: Sysctl defines a kernel parameter to be set @@ -3568,7 +3698,7 @@ spec: description: Value of a property to set type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -3674,7 +3804,7 @@ spec: description: TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a "bucket", and try to put balanced number of pods into each bucket. It's a required field. type: string whenUnsatisfiable: - description: 'WhenUnsatisfiable indicates how to deal with a pod if it doesn''t satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered "Unsatisfiable" for an incoming pod if and only if every possible node assigment for that pod would violate "MaxSkew" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won''t make it *more* imbalanced. It''s a required field.' + description: 'WhenUnsatisfiable indicates how to deal with a pod if it doesn''t satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered "Unsatisfiable" for an incoming pod if and only if every possible node assignment for that pod would violate "MaxSkew" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won''t make it *more* imbalanced. It''s a required field.' type: string x-kubernetes-list-map-keys: - topologyKey @@ -3932,7 +4062,7 @@ spec: - type: string x-kubernetes-int-or-string: true ephemeral: - description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time. \n This is a beta feature and only available when the GenericEphemeralVolume feature gate is enabled." + description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time." type: object properties: volumeClaimTemplate: @@ -3970,7 +4100,7 @@ spec: description: Name is the name of resource being referenced type: string dataSourceRef: - description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' + description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' type: object required: - kind @@ -3986,7 +4116,7 @@ spec: description: Name is the name of resource being referenced type: string resources: - description: 'Resources represents the minimum resources the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' + description: 'Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' type: object properties: limits: @@ -4634,7 +4764,7 @@ spec: items: type: string verbs: - description: Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + description: Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. type: array items: type: string @@ -4691,7 +4821,7 @@ spec: nativeAPIs: type: array items: - description: GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling + description: GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling type: object required: - group @@ -4763,7 +4893,6 @@ spec: items: type: string version: - description: OperatorVersion is a wrapper around semver.Version which supports correct marshaling to YAML and JSON. type: string webhookdefinitions: type: array diff --git a/manifests/0000_50_olm_00-installplans.crd.yaml b/manifests/0000_50_olm_00-installplans.crd.yaml index a600554030..34e5c391d7 100644 --- a/manifests/0000_50_olm_00-installplans.crd.yaml +++ b/manifests/0000_50_olm_00-installplans.crd.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" creationTimestamp: null @@ -224,6 +224,8 @@ spec: - resource - status properties: + optional: + type: boolean resolving: type: string resource: diff --git a/manifests/0000_50_olm_00-olmconfigs.crd.yaml b/manifests/0000_50_olm_00-olmconfigs.crd.yaml index 5c1aa492f9..b3ac8db0ad 100644 --- a/manifests/0000_50_olm_00-olmconfigs.crd.yaml +++ b/manifests/0000_50_olm_00-olmconfigs.crd.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" creationTimestamp: null @@ -52,7 +52,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/manifests/0000_50_olm_00-operatorconditions.crd.yaml b/manifests/0000_50_olm_00-operatorconditions.crd.yaml index 158212d858..e51f6289d5 100644 --- a/manifests/0000_50_olm_00-operatorconditions.crd.yaml +++ b/manifests/0000_50_olm_00-operatorconditions.crd.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" creationTimestamp: null @@ -47,7 +47,7 @@ spec: overrides: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - message @@ -97,7 +97,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime @@ -164,7 +164,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime @@ -211,7 +211,7 @@ spec: overrides: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - message @@ -261,7 +261,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/manifests/0000_50_olm_00-operatorgroups.crd.yaml b/manifests/0000_50_olm_00-operatorgroups.crd.yaml index 211ecd4c9b..36e90f667f 100644 --- a/manifests/0000_50_olm_00-operatorgroups.crd.yaml +++ b/manifests/0000_50_olm_00-operatorgroups.crd.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" creationTimestamp: null @@ -92,7 +92,7 @@ spec: description: Conditions is an array of the OperatorGroup's conditions. type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/manifests/0000_50_olm_00-operators.crd.yaml b/manifests/0000_50_olm_00-operators.crd.yaml index 744a205bfb..1b62806c08 100644 --- a/manifests/0000_50_olm_00-operators.crd.yaml +++ b/manifests/0000_50_olm_00-operators.crd.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" creationTimestamp: null diff --git a/manifests/0000_50_olm_00-subscriptions.crd.yaml b/manifests/0000_50_olm_00-subscriptions.crd.yaml index 435980cff8..7c57d66109 100644 --- a/manifests/0000_50_olm_00-subscriptions.crd.yaml +++ b/manifests/0000_50_olm_00-subscriptions.crd.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" creationTimestamp: null @@ -535,7 +535,7 @@ spec: - type: string x-kubernetes-int-or-string: true ephemeral: - description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time. \n This is a beta feature and only available when the GenericEphemeralVolume feature gate is enabled." + description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time." type: object properties: volumeClaimTemplate: @@ -573,7 +573,7 @@ spec: description: Name is the name of resource being referenced type: string dataSourceRef: - description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' + description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' type: object required: - kind @@ -589,7 +589,7 @@ spec: description: Name is the name of resource being referenced type: string resources: - description: 'Resources represents the minimum resources the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' + description: 'Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' type: object properties: limits: diff --git a/manifests/0000_50_olm_08-catalog-operator.deployment.ibm-cloud-managed.yaml b/manifests/0000_50_olm_08-catalog-operator.deployment.ibm-cloud-managed.yaml index 7ade5acae9..830bef1f58 100644 --- a/manifests/0000_50_olm_08-catalog-operator.deployment.ibm-cloud-managed.yaml +++ b/manifests/0000_50_olm_08-catalog-operator.deployment.ibm-cloud-managed.yaml @@ -41,13 +41,13 @@ spec: command: - /bin/catalog args: - - '-namespace' + - '--namespace' - openshift-marketplace - - -configmapServerImage=quay.io/operator-framework/configmap-operator-registry:latest - - -opmImage=quay.io/operator-framework/configmap-operator-registry:latest - - -util-image + - --configmapServerImage=quay.io/operator-framework/configmap-operator-registry:latest + - --opmImage=quay.io/operator-framework/configmap-operator-registry:latest + - --util-image - quay.io/operator-framework/olm@sha256:de396b540b82219812061d0d753440d5655250c621c753ed1dc67d6154741607 - - -writeStatusName + - --writeStatusName - operator-lifecycle-manager-catalog - --tls-cert - /srv-cert/tls.crt diff --git a/manifests/0000_50_olm_08-catalog-operator.deployment.yaml b/manifests/0000_50_olm_08-catalog-operator.deployment.yaml index 1ef53f9c74..54cec129d9 100644 --- a/manifests/0000_50_olm_08-catalog-operator.deployment.yaml +++ b/manifests/0000_50_olm_08-catalog-operator.deployment.yaml @@ -41,13 +41,13 @@ spec: command: - /bin/catalog args: - - '-namespace' + - '--namespace' - openshift-marketplace - - -configmapServerImage=quay.io/operator-framework/configmap-operator-registry:latest - - -opmImage=quay.io/operator-framework/configmap-operator-registry:latest - - -util-image + - --configmapServerImage=quay.io/operator-framework/configmap-operator-registry:latest + - --opmImage=quay.io/operator-framework/configmap-operator-registry:latest + - --util-image - quay.io/operator-framework/olm@sha256:de396b540b82219812061d0d753440d5655250c621c753ed1dc67d6154741607 - - -writeStatusName + - --writeStatusName - operator-lifecycle-manager-catalog - --tls-cert - /srv-cert/tls.crt diff --git a/staging/api/.github/workflows/go.yaml b/staging/api/.github/workflows/go.yaml index 9a8b7d699a..21c4e6a762 100644 --- a/staging/api/.github/workflows/go.yaml +++ b/staging/api/.github/workflows/go.yaml @@ -1,11 +1,12 @@ name: Go on: push: - branches: + branches: - master pull_request: - branches: - - master + branches: + - '**' + workflow_dispatch: jobs: build: name: Build @@ -14,12 +15,21 @@ jobs: - name: Set up Go uses: actions/setup-go@v2 with: - go-version: 1.16 + go-version: 1.17 id: go - name: Check out code into the Go module directory uses: actions/checkout@v2 + - name: Cache dependencies + uses: actions/cache@v2 + with: + path: | + ~/.cache/go-build + ~/go/pkg/mod + key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} + restore-keys: | + ${{ runner.os }}-go- - name: unit-test - run: go test -mod=vendor -v ./... + run: go test -v ./... go-apidiff: name: go-apidiff @@ -29,11 +39,13 @@ jobs: - name: Set up Go uses: actions/setup-go@v2 with: - go-version: 1.16 + go-version: 1.17 id: go + - name: Print out Go env + run: go env - name: Check out code into the Go module directory uses: actions/checkout@v2 with: fetch-depth: 0 - name: Run go-apidiff - uses: joelanford/go-apidiff@master + uses: joelanford/go-apidiff@main diff --git a/staging/api/.github/workflows/verify.yml b/staging/api/.github/workflows/verify.yml index 6696488a7c..cbba26a4ae 100644 --- a/staging/api/.github/workflows/verify.yml +++ b/staging/api/.github/workflows/verify.yml @@ -6,6 +6,7 @@ on: pull_request: paths: - '**' + workflow_dispatch: jobs: verify: runs-on: ubuntu-latest @@ -13,7 +14,7 @@ jobs: - uses: actions/checkout@v2 - uses: actions/setup-go@v2 with: - go-version: '~1.16' + go-version: '~1.17' - name: Run the verify target run: | export GOPATH=$(go env GOPATH) diff --git a/staging/api/.gitignore b/staging/api/.gitignore index 06000d4c49..d6395083f0 100644 --- a/staging/api/.gitignore +++ b/staging/api/.gitignore @@ -18,3 +18,5 @@ .LSOverride .idea/* +vendor/ +bin/ diff --git a/staging/api/Makefile b/staging/api/Makefile index ada005e912..dc5e1f5cf2 100644 --- a/staging/api/Makefile +++ b/staging/api/Makefile @@ -12,7 +12,6 @@ endif REPO = github.com/operator-framework/api BUILD_PATH = $(REPO)/cmd/operator-verify PKGS = $(shell go list ./... | grep -v /vendor/) -YQ := go run $(MOD_FLAGS) ./vendor/github.com/mikefarah/yq/v3/ .PHONY: help help: ## Show this help screen @@ -25,7 +24,6 @@ help: ## Show this help screen .PHONY: install install: ## Build & install operator-verify - $(Q)go install \ -gcflags "all=-trimpath=${GOPATH}" \ -asmflags "all=-trimpath=${GOPATH}" \ @@ -35,17 +33,17 @@ install: ## Build & install operator-verify " \ $(BUILD_PATH) +### # Code management. -.PHONY: format tidy clean vendor generate manifests +### +.PHONY: format tidy clean generate manifests format: ## Format the source code $(Q)go fmt $(PKGS) tidy: ## Update dependencies $(Q)go mod tidy -v - -vendor: tidy ## Update vendor directory - $(Q)go mod vendor + $(Q)go mod verify clean: ## Clean up the build artifacts $(Q)rm -rf build @@ -53,7 +51,7 @@ clean: ## Clean up the build artifacts generate: controller-gen ## Generate code $(CONTROLLER_GEN) object:headerFile=./hack/boilerplate.go.txt paths=./... -manifests: controller-gen ## Generate manifests e.g. CRD, RBAC etc +manifests: yq controller-gen ## Generate manifests e.g. CRD, RBAC etc @# Create CRDs for new APIs $(CONTROLLER_GEN) crd:crdVersions=v1 output:crd:dir=./crds paths=./pkg/operators/... @@ -88,9 +86,28 @@ test-unit: ## Run the unit tests verify: manifests generate format git diff --exit-code +### # Utilities. -.PHONY: controller-gen - -controller-gen: vendor ## Find or download controller-gen -CONTROLLER_GEN=$(Q)go run -mod=vendor ./vendor/sigs.k8s.io/controller-tools/cmd/controller-gen - +### + +# go-get-tool will 'go get' any package $2 and install it to $1. +PROJECT_DIR := $(shell dirname $(abspath $(lastword $(MAKEFILE_LIST)))) +define go-get-tool +@[ -f $(1) ] || { \ +set -e ;\ +TMP_DIR=$$(mktemp -d) ;\ +cd $$TMP_DIR ;\ +go mod init tmp ;\ +echo "Downloading $(2)" ;\ +GOBIN=$(PROJECT_DIR)/bin go get $(2) ;\ +rm -rf $$TMP_DIR ;\ +} +endef + +CONTROLLER_GEN = $(shell pwd)/bin/controller-gen +controller-gen: ## Download controller-gen locally if necessary. + $(call go-get-tool,$(CONTROLLER_GEN),sigs.k8s.io/controller-tools/cmd/controller-gen@v0.8.0) + +YQ = $(shell pwd)/bin/yq +yq: + $(call go-get-tool,$(YQ),github.com/mikefarah/yq/v3) diff --git a/staging/api/OWNERS b/staging/api/OWNERS index eb8bbf4ccc..cb3e6f7ea5 100644 --- a/staging/api/OWNERS +++ b/staging/api/OWNERS @@ -5,9 +5,10 @@ approvers: - dinhxuanvu - kevinrizza - benluddy + - awgreene - joelanford - - estroz - jmrodri + - perdasilva # review == this code is good /lgtm reviewers: - ecordell @@ -22,5 +23,5 @@ reviewers: - joelanford - benluddy - ankitathomas - - estroz - jmrodri + - perdasilva diff --git a/staging/api/README.md b/staging/api/README.md index 611e368725..086021c176 100644 --- a/staging/api/README.md +++ b/staging/api/README.md @@ -70,6 +70,50 @@ Following an example. return nonEmptyResults ``` +#### Passing optional key/values to the validators + +Validators may accept pass optional key/values which will be used in the checks made. +These values are global and if the key/value pair provided is not used for 1 or more +validators called then, it is ignored. + +The following example calls `AlphaDeprecatedAPIsValidator`, which allows us to inform +the K8s version intended to publish the OLM Bundle: + +```go + validators := apivalidation.DefaultBundleValidators + validators = validators.WithValidators(apivalidation.OperatorHubValidator) + validators = validators.WithValidators(apivalidation.ObjectValidator) + validators = validators.WithValidators(apivalidation.AlphaDeprecatedAPIsValidator) + validators = validators.WithValidators(apivalidation.GoodPracticesValidator) + + objs := auditBundle.Bundle.ObjectsToValidate() + + // Pass the --optional-values. e.g. --optional-values="k8s-version=1.22" + // or --optional-values="image-path=bundle.Dockerfile" + var optionalValues = map[string]string{ + "k8s-version":"1.22", + } + objs = append(objs, optionalValues) + + results := validators.Validate(objs...) + nonEmptyResults := []errors.ManifestResult{} + + for _, result := range results { + if result.HasError() || result.HasWarn() { + nonEmptyResults = append(nonEmptyResults, result) + } + } +``` + +**How the optional key/values are informed via the CLI?** + +By using [Operator-SDK][sdk] you can pass a list of key/values via the flag `--optional-values`, for example, +to validate that your manifests can work with a Kubernetes cluster of a particular version using the `k8s-version`: + +```sh +$ operator-sdk bundle validate ./bundle --select-optional suite=operatorframework --optional-values=k8s-version=1.22 +``` + ## API CLI Usage You can install the `operator-verify` tool from source using: diff --git a/staging/api/crds/operators.coreos.com_catalogsources.yaml b/staging/api/crds/operators.coreos.com_catalogsources.yaml index 192cf663fb..318393f814 100644 --- a/staging/api/crds/operators.coreos.com_catalogsources.yaml +++ b/staging/api/crds/operators.coreos.com_catalogsources.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: catalogsources.operators.coreos.com spec: @@ -145,7 +145,7 @@ spec: description: Represents the state of a CatalogSource. Note that Message and Reason represent the original status information, which may be migrated to be conditions based in the future. Any new features introduced will use conditions. type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/staging/api/crds/operators.coreos.com_clusterserviceversions.yaml b/staging/api/crds/operators.coreos.com_clusterserviceversions.yaml index 7d3a2abe33..4f2753d321 100644 --- a/staging/api/crds/operators.coreos.com_clusterserviceversions.yaml +++ b/staging/api/crds/operators.coreos.com_clusterserviceversions.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: clusterserviceversions.operators.coreos.com spec: @@ -570,7 +570,7 @@ spec: items: type: string verbs: - description: Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + description: Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. type: array items: type: string @@ -1297,7 +1297,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1343,7 +1343,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -1358,11 +1358,11 @@ spec: - type: string x-kubernetes-int-or-string: true preStop: - description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod''s termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' + description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod''s termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1408,7 +1408,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -1427,7 +1427,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1439,6 +1439,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -1489,7 +1502,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -1550,7 +1563,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1562,6 +1575,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -1612,7 +1638,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -1661,10 +1687,10 @@ spec: type: object properties: allowPrivilegeEscalation: - description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN' + description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.' type: boolean capabilities: - description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. + description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. type: object properties: add: @@ -1680,27 +1706,27 @@ spec: description: Capability represent POSIX capabilities type type: string privileged: - description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. type: boolean procMount: - description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. + description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. type: string readOnlyRootFilesystem: - description: Whether this container has a read-only root filesystem. Default is false. + description: Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. type: boolean runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -1716,7 +1742,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. + description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -1728,7 +1754,7 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -1748,7 +1774,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1760,6 +1786,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -1810,7 +1849,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -1927,10 +1966,10 @@ spec: description: 'EnableServiceLinks indicates whether information about services should be injected into pod''s environment variables, matching the syntax of Docker links. Optional: Defaults to true.' type: boolean ephemeralContainers: - description: List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is alpha-level and is only honored by servers that enable the EphemeralContainers feature. + description: List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate. type: array items: - description: An EphemeralContainer is a container that may be added temporarily to an existing pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a pod is removed or restarted. If an ephemeral container causes a pod to exceed its resource allocation, the pod may be evicted. Ephemeral containers may not be added by directly updating the pod spec. They must be added via the pod's ephemeralcontainers subresource, and they will appear in the pod spec once added. This is an alpha feature enabled by the EphemeralContainers feature flag. + description: "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation. \n To add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted. \n This is a beta feature available on clusters that haven't disabled the EphemeralContainers feature gate." type: object required: - name @@ -2070,7 +2109,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2116,7 +2155,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2131,11 +2170,11 @@ spec: - type: string x-kubernetes-int-or-string: true preStop: - description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod''s termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' + description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod''s termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2181,7 +2220,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2200,7 +2239,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2212,6 +2251,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -2262,7 +2314,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -2314,12 +2366,16 @@ spec: description: Protocol for port. Must be UDP, TCP, or SCTP. Defaults to "TCP". type: string default: TCP + x-kubernetes-list-map-keys: + - containerPort + - protocol + x-kubernetes-list-type: map readinessProbe: description: Probes are not allowed for ephemeral containers. type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2331,6 +2387,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -2381,7 +2450,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -2430,10 +2499,10 @@ spec: type: object properties: allowPrivilegeEscalation: - description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN' + description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.' type: boolean capabilities: - description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. + description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. type: object properties: add: @@ -2449,27 +2518,27 @@ spec: description: Capability represent POSIX capabilities type type: string privileged: - description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. type: boolean procMount: - description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. + description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. type: string readOnlyRootFilesystem: - description: Whether this container has a read-only root filesystem. Default is false. + description: Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. type: boolean runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -2485,7 +2554,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. + description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -2497,7 +2566,7 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -2517,7 +2586,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2529,6 +2598,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -2579,7 +2661,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -2608,7 +2690,7 @@ spec: description: Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false type: boolean targetContainerName: - description: If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container is run in whatever namespaces are shared for the pod. Note that the container runtime must support this feature. + description: "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec. \n The container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined." type: string terminationMessagePath: description: 'Optional: Path at which the file to which the container''s termination message will be written is mounted into the container''s filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.' @@ -2636,7 +2718,7 @@ spec: description: name must match the name of a persistentVolumeClaim in the pod type: string volumeMounts: - description: Pod volumes to mount into the container's filesystem. Cannot be updated. + description: Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated. type: array items: description: VolumeMount describes a mounting of a Volume within a container. @@ -2847,7 +2929,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2893,7 +2975,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2908,11 +2990,11 @@ spec: - type: string x-kubernetes-int-or-string: true preStop: - description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod''s termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' + description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod''s termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2958,7 +3040,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2977,7 +3059,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2989,6 +3071,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -3039,7 +3134,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -3100,7 +3195,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -3112,6 +3207,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -3162,7 +3270,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -3211,10 +3319,10 @@ spec: type: object properties: allowPrivilegeEscalation: - description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN' + description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.' type: boolean capabilities: - description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. + description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. type: object properties: add: @@ -3230,27 +3338,27 @@ spec: description: Capability represent POSIX capabilities type type: string privileged: - description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. type: boolean procMount: - description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. + description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. type: string readOnlyRootFilesystem: - description: Whether this container has a read-only root filesystem. Default is false. + description: Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. type: boolean runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -3266,7 +3374,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. + description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -3278,7 +3386,7 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -3298,7 +3406,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -3310,6 +3418,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -3360,7 +3481,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -3453,6 +3574,15 @@ spec: additionalProperties: type: string x-kubernetes-map-type: atomic + os: + description: "Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set. \n If the OS field is set to linux, the following fields must be unset: -securityContext.windowsOptions \n If the OS field is set to windows, following fields must be unset: - spec.hostPID - spec.hostIPC - spec.securityContext.seLinuxOptions - spec.securityContext.seccompProfile - spec.securityContext.fsGroup - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls - spec.shareProcessNamespace - spec.securityContext.runAsUser - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups - spec.containers[*].securityContext.seLinuxOptions - spec.containers[*].securityContext.seccompProfile - spec.containers[*].securityContext.capabilities - spec.containers[*].securityContext.readOnlyRootFilesystem - spec.containers[*].securityContext.privileged - spec.containers[*].securityContext.allowPrivilegeEscalation - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser - spec.containers[*].securityContext.runAsGroup This is an alpha field and requires the IdentifyPodOS feature" + type: object + required: + - name + properties: + name: + description: 'Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null' + type: string overhead: description: 'Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md This field is beta-level as of Kubernetes v1.18, and is only honored by servers that enable the PodOverhead feature.' type: object @@ -3498,25 +3628,25 @@ spec: type: object properties: fsGroup: - description: "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: \n 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- \n If unset, the Kubelet will not modify the ownership and permissions of any volume." + description: "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: \n 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- \n If unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows." type: integer format: int64 fsGroupChangePolicy: - description: 'fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used.' + description: 'fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used. Note that this field cannot be set when spec.os.name is windows.' type: string runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + description: The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -3532,7 +3662,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by the containers in this pod. + description: The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -3544,13 +3674,13 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string supplementalGroups: - description: A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. + description: A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows. type: array items: type: integer format: int64 sysctls: - description: Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. + description: Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows. type: array items: description: Sysctl defines a kernel parameter to be set @@ -3566,7 +3696,7 @@ spec: description: Value of a property to set type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -3672,7 +3802,7 @@ spec: description: TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a "bucket", and try to put balanced number of pods into each bucket. It's a required field. type: string whenUnsatisfiable: - description: 'WhenUnsatisfiable indicates how to deal with a pod if it doesn''t satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered "Unsatisfiable" for an incoming pod if and only if every possible node assigment for that pod would violate "MaxSkew" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won''t make it *more* imbalanced. It''s a required field.' + description: 'WhenUnsatisfiable indicates how to deal with a pod if it doesn''t satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered "Unsatisfiable" for an incoming pod if and only if every possible node assignment for that pod would violate "MaxSkew" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won''t make it *more* imbalanced. It''s a required field.' type: string x-kubernetes-list-map-keys: - topologyKey @@ -3930,7 +4060,7 @@ spec: - type: string x-kubernetes-int-or-string: true ephemeral: - description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time. \n This is a beta feature and only available when the GenericEphemeralVolume feature gate is enabled." + description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time." type: object properties: volumeClaimTemplate: @@ -3968,7 +4098,7 @@ spec: description: Name is the name of resource being referenced type: string dataSourceRef: - description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' + description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' type: object required: - kind @@ -3984,7 +4114,7 @@ spec: description: Name is the name of resource being referenced type: string resources: - description: 'Resources represents the minimum resources the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' + description: 'Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' type: object properties: limits: @@ -4632,7 +4762,7 @@ spec: items: type: string verbs: - description: Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + description: Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. type: array items: type: string @@ -4689,7 +4819,7 @@ spec: nativeAPIs: type: array items: - description: GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling + description: GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling type: object required: - group @@ -4761,7 +4891,6 @@ spec: items: type: string version: - description: OperatorVersion is a wrapper around semver.Version which supports correct marshaling to YAML and JSON. type: string webhookdefinitions: type: array diff --git a/staging/api/crds/operators.coreos.com_installplans.yaml b/staging/api/crds/operators.coreos.com_installplans.yaml index 616f51ba0d..8e9b85e371 100644 --- a/staging/api/crds/operators.coreos.com_installplans.yaml +++ b/staging/api/crds/operators.coreos.com_installplans.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: installplans.operators.coreos.com spec: @@ -222,6 +222,8 @@ spec: - resource - status properties: + optional: + type: boolean resolving: type: string resource: diff --git a/staging/api/crds/operators.coreos.com_olmconfigs.yaml b/staging/api/crds/operators.coreos.com_olmconfigs.yaml index 58c07d034a..44dfcd937e 100644 --- a/staging/api/crds/operators.coreos.com_olmconfigs.yaml +++ b/staging/api/crds/operators.coreos.com_olmconfigs.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: olmconfigs.operators.coreos.com spec: @@ -50,7 +50,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/staging/api/crds/operators.coreos.com_operatorconditions.yaml b/staging/api/crds/operators.coreos.com_operatorconditions.yaml index eb9a6d5a79..aa6bd41955 100644 --- a/staging/api/crds/operators.coreos.com_operatorconditions.yaml +++ b/staging/api/crds/operators.coreos.com_operatorconditions.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: operatorconditions.operators.coreos.com spec: @@ -45,7 +45,7 @@ spec: overrides: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - message @@ -95,7 +95,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime @@ -162,7 +162,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime @@ -209,7 +209,7 @@ spec: overrides: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - message @@ -259,7 +259,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/staging/api/crds/operators.coreos.com_operatorgroups.yaml b/staging/api/crds/operators.coreos.com_operatorgroups.yaml index e59131ac3a..56ef0b5c4f 100644 --- a/staging/api/crds/operators.coreos.com_operatorgroups.yaml +++ b/staging/api/crds/operators.coreos.com_operatorgroups.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: operatorgroups.operators.coreos.com spec: @@ -90,7 +90,7 @@ spec: description: Conditions is an array of the OperatorGroup's conditions. type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/staging/api/crds/operators.coreos.com_operators.yaml b/staging/api/crds/operators.coreos.com_operators.yaml index ef206c5e7a..e7dce32925 100644 --- a/staging/api/crds/operators.coreos.com_operators.yaml +++ b/staging/api/crds/operators.coreos.com_operators.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: operators.operators.coreos.com spec: diff --git a/staging/api/crds/operators.coreos.com_subscriptions.yaml b/staging/api/crds/operators.coreos.com_subscriptions.yaml index f4070f0878..5a67668800 100644 --- a/staging/api/crds/operators.coreos.com_subscriptions.yaml +++ b/staging/api/crds/operators.coreos.com_subscriptions.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: subscriptions.operators.coreos.com spec: @@ -533,7 +533,7 @@ spec: - type: string x-kubernetes-int-or-string: true ephemeral: - description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time. \n This is a beta feature and only available when the GenericEphemeralVolume feature gate is enabled." + description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time." type: object properties: volumeClaimTemplate: @@ -571,7 +571,7 @@ spec: description: Name is the name of resource being referenced type: string dataSourceRef: - description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' + description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' type: object required: - kind @@ -587,7 +587,7 @@ spec: description: Name is the name of resource being referenced type: string resources: - description: 'Resources represents the minimum resources the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' + description: 'Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' type: object properties: limits: diff --git a/staging/api/crds/zz_defs.go b/staging/api/crds/zz_defs.go index fc6f90c368..31a7d8bb5e 100644 --- a/staging/api/crds/zz_defs.go +++ b/staging/api/crds/zz_defs.go @@ -85,7 +85,7 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _operatorsCoreosCom_catalogsourcesYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x3b\x6b\x73\xdc\x36\x92\xdf\xfd\x2b\xba\x74\x57\x65\x29\x37\x43\x59\xce\x96\x6f\x77\x2e\x4e\x4a\x91\xed\x9c\x2a\xb1\xad\xb2\x6c\x5f\xdd\x5a\xbe\x5b\x0c\xd9\xc3\x41\x04\x02\x34\x00\x4a\x9a\x6c\xe5\xbf\x6f\x75\x03\x20\x39\x2f\xce\x48\x71\xe6\x8b\x45\x3c\x1a\xfd\x7e\x01\x16\xb5\xfc\x88\xd6\x49\xa3\x27\x20\x6a\x89\x77\x1e\x35\x7d\xb9\xec\xfa\xaf\x2e\x93\xe6\xf8\xe6\xe4\xd1\xb5\xd4\xc5\x04\xce\x1a\xe7\x4d\xf5\x0e\x9d\x69\x6c\x8e\x2f\x70\x26\xb5\xf4\xd2\xe8\x47\x15\x7a\x51\x08\x2f\x26\x8f\x00\x84\xd6\xc6\x0b\x1a\x76\xf4\x09\x90\x1b\xed\xad\x51\x0a\xed\xb8\x44\x9d\x5d\x37\x53\x9c\x36\x52\x15\x68\x19\x78\x3a\xfa\xe6\x49\xf6\x2c\x7b\xfa\x08\x20\xb7\xc8\xdb\xdf\xcb\x0a\x9d\x17\x55\x3d\x01\xdd\x28\xf5\x08\x40\x8b\x0a\x27\x90\x0b\x2f\x94\x29\x03\x12\x2e\x33\x35\x5a\xe1\x8d\x75\x59\x6e\x2c\x1a\xfa\xa7\x7a\xe4\x6a\xcc\xe9\xf4\xd2\x9a\xa6\x9e\xc0\xc6\x35\x01\x5e\x42\x52\x78\x2c\x8d\x95\xe9\x1b\x60\x0c\x46\x55\xfc\x77\x24\x3e\x1c\x7b\xc9\xc7\xf2\xb8\x92\xce\xff\xbc\x3e\xf7\x8b\x74\x9e\xe7\x6b\xd5\x58\xa1\x56\x11\xe6\x29\x37\x37\xd6\xbf\xe9\x8e\xa7\xe3\x72\xe1\x9d\xcd\xc3\xb4\xd4\x65\xa3\x84\x5d\xd9\xfb\x08\xc0\xe5\xa6\xc6\x09\xf0\xd6\x5a\xe4\x58\x3c\x02\x88\x2c\x8c\xa0\xc6\x20\x8a\x82\xc5\x22\xd4\x85\x95\xda\xa3\x3d\x33\xaa\xa9\x74\x7b\x14\xad\x29\xd0\xe5\x56\xd6\x9e\x59\xff\x7e\x8e\x50\x5b\xf4\x7e\xc1\x2c\x01\x33\x03\x3f\xc7\x74\x76\xbb\x0b\xe0\x57\x67\xf4\x85\xf0\xf3\x09\x64\xc4\xe1\xac\x90\xae\x56\x62\x41\xd8\xf4\x56\x05\x31\xbd\x08\x73\xbd\x71\xbf\x20\xd4\x9d\xb7\x52\x97\x43\xa8\xd0\xba\xfd\x71\x08\xac\x79\xbf\xa8\xd7\x51\x58\x19\xdc\xf7\xfc\xba\x99\x2a\xe9\xe6\x68\xf7\x47\xa2\xdd\xb2\x86\xc3\xc5\x86\x99\x2d\x88\xf4\x80\x26\x83\xca\xd6\x8c\x61\xed\x80\xd3\x72\x9d\xc6\x42\xf8\x34\x18\x16\xdd\x9c\x08\x55\xcf\xc5\x49\x1c\x74\xf9\x1c\x2b\xd1\xe9\x83\xa9\x51\x9f\x5e\x9c\x7f\xfc\xf6\x72\x65\x02\x96\xb9\xb3\xa4\xe7\x20\x1d\x08\xb0\x58\x1b\x27\xbd\xb1\x0b\xe2\xd6\xd9\xe5\x47\x37\x82\xb3\x77\x2f\xdc\x08\x84\x2e\x5a\xc3\x83\x5a\xe4\xd7\xa2\x44\x97\xad\xe1\x6a\xa6\xbf\x62\xee\x7b\xc3\x16\xbf\x34\xd2\x62\xd1\xc7\x82\xd8\x93\x78\xb2\x32\x4c\xfc\xef\x0d\xd5\x96\xce\xf4\x3d\x43\x0e\xbf\x9e\x97\x5b\x1a\x5f\xa1\xf0\x31\xb1\x21\xac\x83\x82\x1c\x1c\x3a\x56\x81\x68\x63\x58\x44\xde\x05\xd5\x90\x8e\xe8\xb7\xe8\x50\x07\x97\x47\xc3\x42\x47\x9a\x32\xb8\x44\x4b\x1b\xc9\xdc\x1b\x55\x90\x27\xbc\x41\xeb\xc1\x62\x6e\x4a\x2d\x7f\x6b\xa1\x39\xf0\x86\x8f\x51\xc2\xa3\xf3\xc0\x56\xab\x85\x82\x1b\xa1\x1a\x0c\xac\xac\xc4\x02\x2c\x12\x5c\x68\x74\x0f\x02\x2f\x71\x19\xbc\x36\x16\x41\xea\x99\x99\xc0\xdc\xfb\xda\x4d\x8e\x8f\x4b\xe9\x93\x0f\xcf\x4d\x55\x35\x5a\xfa\xc5\x31\xbb\x63\x39\x6d\xc8\x1d\x1e\x17\x78\x83\xea\xd8\xc9\x72\x2c\x6c\x3e\x97\x1e\x73\xdf\x58\x3c\x16\xb5\x1c\x33\xb2\x9a\xfd\x78\x56\x15\xff\x66\xa3\xd7\x77\x8f\x57\xd8\xb7\x51\x99\x21\xb9\xcd\x41\x5e\x93\xf3\x0c\x5a\x14\xb6\x07\x5a\x3a\x96\xd2\x10\x71\xe5\xdd\xcb\xcb\xf7\x90\x10\x08\x6c\x0f\x1c\xee\x96\xba\x8e\xd9\xc4\x28\xa9\x67\x68\xc3\xca\x99\x35\x15\x43\x41\x5d\xd4\x46\x6a\x1f\x4c\x5a\x49\xd4\x1e\x5c\x33\xad\xa4\x77\xac\x73\xe8\x3c\xc9\x21\x83\x33\x0e\x61\x30\x45\x68\x6a\xb2\xa4\x22\x83\x73\x0d\x67\xa2\x42\x75\x26\x1c\xfe\xe9\xac\x26\x8e\xba\x31\xb1\x6f\x7f\x66\xf7\x23\xf0\xfa\x86\x35\x1b\x03\x48\x11\x72\xaf\xc5\xdb\x8c\x12\x82\x05\x6e\xf2\xc0\x30\x60\x8b\xf4\x13\x45\x61\xd1\x6d\x98\x58\x33\xc8\xb0\x30\xe8\xc9\xdc\x38\x92\x9f\xf0\xf0\xf6\x97\xd7\x90\x0b\x0d\x8d\x43\x32\x9e\xdc\x68\x4d\x0a\xe1\x0d\x08\x8a\x65\x63\xbc\x93\x8e\x15\xc8\x62\x29\x9d\xb7\x8b\x0c\x5e\x19\x5b\x09\x3f\x81\xef\xd2\xd0\x98\xc1\x19\x0b\xb2\xfe\x7e\xf2\x5d\x6d\xac\xff\x1e\xde\x6a\xb5\x20\xa0\x05\xdc\xce\x51\xc3\x65\x4b\x1b\x3c\xef\x7d\xfc\x64\xeb\x3c\x83\xf3\x52\x1b\x9b\x56\x92\x56\x9d\x57\xa2\x44\x98\x49\x54\xac\xd7\x0e\x7d\xb6\x2a\xc1\x41\x29\x42\x48\x97\x66\xb2\x7c\x2d\xea\x9d\xac\x39\x4b\x2b\xe9\x2c\x3a\xbe\x1f\xbc\xbb\x49\x6f\x58\x95\x89\x24\xfa\x53\xe4\xd7\x20\xe2\x29\x95\xa8\xc7\x8e\xcd\xa6\xc7\xa6\xfd\x38\x70\x96\x00\x10\xff\xba\xe1\xf3\xe8\xb9\xb2\xfb\x92\xdd\xa7\xec\xde\x7b\xbb\x34\x64\x27\xd3\x5e\x6f\x8a\x22\x7b\x9c\x51\xda\x3a\xbf\x30\x45\x20\x7b\xe7\x29\x3f\xf5\x57\x03\xde\xd5\xc6\xa1\x83\x42\xce\x66\x68\xc9\xef\x98\x1b\xb4\x56\x16\xe8\x60\x66\x2c\xcb\xab\x36\x05\xdb\x64\x2b\xbf\xa5\x50\x7b\x61\x8a\x7d\x05\x43\x47\x73\xc0\x08\xca\x18\xd5\x70\x2b\xb9\x1b\xad\x1d\x76\x18\x2f\xfd\xb4\x29\xf0\x12\x15\xe6\xde\xd8\xcd\x2b\x56\x78\xf2\xa6\xb7\x21\x7a\xfd\xf4\x75\x3b\x97\xf9\x1c\xaa\xc6\xb1\xd7\xf5\xb6\xc1\x25\xbe\x78\x03\x33\xe9\xc1\x68\x10\x7c\x2c\xf9\xfa\xf5\x9d\x95\xf0\xf9\x3c\xae\x78\xec\x40\x89\x29\x2a\xb7\x0a\x67\x8a\x1c\x72\x8b\x46\x61\x41\x00\xd9\x97\x30\xcc\x2d\x24\xec\xe0\x12\x04\x57\xd6\xe6\xdb\xc3\x3c\x83\x5d\x5a\x16\x18\x2f\x8d\x95\x7e\x71\xa6\x84\x73\xdb\x74\x7a\x8d\xbb\xe7\x33\x56\x1f\x39\x93\x58\x8c\x40\xea\x42\x52\x49\xe3\x12\xed\x8f\x5d\x0b\x37\xa3\xb5\x14\xe0\x7a\xeb\x13\x87\xd2\x1a\xb8\x95\x4a\x11\xb3\x0a\x9c\x89\x46\xb1\x93\xfc\x0d\xad\x01\xc9\xda\x69\x59\xaf\xb4\x49\xd3\xc3\xcc\x1b\xa0\xd5\x1b\x45\x09\x62\x57\xbd\xec\xa0\xf2\x7d\xb7\x1e\x84\xc5\x7e\x76\x1e\xc3\x10\x11\xca\xe4\xf6\x40\x0f\xa3\x27\xac\x5d\x2a\x53\xfa\x3f\xe9\xb1\x1a\x90\xe5\x7a\xe9\x40\x5a\x46\x59\x47\x87\x28\xab\xba\xf7\x82\xb4\x8e\xd3\xbc\x30\x83\x0e\x84\x5e\x80\x17\x21\x23\x11\x51\x7f\xa3\xc4\xbc\x95\xb5\x42\xf8\xee\x1a\x17\xa3\x90\x03\xe2\x6c\x86\xb9\xff\x1e\x1a\x97\xb2\x22\x5e\x4f\x1f\x6d\x92\xfd\x5d\xfa\xeb\xfb\x6d\x14\xef\xa5\xcf\xbb\x6d\x3f\xfc\x02\x4a\x43\x2b\x56\x38\xf4\x92\x37\xac\x28\x67\xe0\x40\x80\x45\xfc\x61\xb2\x32\x78\x59\xd5\x7e\x01\x15\x0a\xed\x92\x65\x2b\xb5\xb4\xd8\x65\xf0\x3f\xe4\x07\x7b\x6a\x2c\x94\x32\xb7\x6d\x4e\xcc\x1a\xf2\xc6\x5c\x46\x7b\x1f\xc1\x85\xc5\x19\xda\x6e\x84\xdd\xe4\x1b\xf3\xf2\x0e\xf3\xc6\x6f\xf5\x00\x7d\xbe\x0d\xa8\x72\xf8\x5d\xe3\xe2\x1e\x0c\xf9\x19\x17\x29\x76\x07\xca\xae\x71\x11\x94\x81\x87\x3a\x1d\x12\x75\xad\x24\x86\xf4\x74\x88\x33\xd7\xb8\x70\x6c\xdf\xb4\xff\x3a\x40\x47\x5a\x3f\xea\xb4\x24\xb9\xd9\x97\x94\x21\xb9\xff\x0a\xfa\x9a\x9b\x6a\x2a\x75\x38\x2c\x80\x4e\xa2\x60\xe8\x89\xa1\xba\xe0\x4f\x3e\xe6\x6b\xb0\x2b\x21\x75\x0f\x9e\xbd\x4d\x74\x74\xb9\x3f\x08\xc2\xe8\x31\xa5\xf1\x2a\x58\xfc\x5c\xd6\xa9\xa4\x62\xd4\x33\xf8\x28\x94\xec\xea\xd1\xa0\x1b\x81\x03\x4c\xd5\xcb\x2f\x8d\x50\x19\xbc\x08\xfe\x8c\xa9\x8f\x43\x71\x11\x31\xf2\x4b\x23\x6f\x84\xa2\xf8\xed\x0d\x79\xc8\x22\x17\xb6\xe0\x08\x13\xeb\x34\x67\x82\xf4\x04\x3b\x02\x4a\x4f\x93\xb5\x77\x32\x72\x5c\x23\x42\x2d\xac\x97\x79\xa3\x84\x4d\xbd\xa7\xc5\x57\xe1\x68\xa7\x34\x97\x98\x1b\x5d\x0c\x5a\xf0\x56\xef\x1a\xf7\xf6\x79\xcc\x21\x02\xad\x34\x05\xa7\x28\xb2\xc2\x55\x25\x3d\x5c\x0e\xe3\x66\x96\xac\xba\x35\xb1\x11\x18\x8a\x1e\xb7\xd2\xc5\x32\xae\x4d\x95\x65\x48\xa5\x8f\x7a\xee\xb1\xb5\x8a\x0c\x7e\x5c\xa4\x48\x33\x02\xe9\x43\xec\xf1\x94\xd7\x8c\x52\x02\x10\x55\x36\x32\xbb\x33\xa8\x99\xb1\x48\xe9\xed\x61\x61\x78\x0f\xde\xc8\xdc\x1f\x65\xf0\x77\x0a\x66\x24\x78\x8d\xa5\xf0\xf2\x06\x93\x8a\xa7\xc0\xe7\x2d\x52\xe9\x07\xc2\xc1\x13\x38\xe4\x6d\x20\xab\x0a\x0b\x29\x3c\xaa\xc5\x11\x4c\x17\x7c\x8c\x5b\x38\x8f\xd5\x3e\xa2\xa3\xa2\xbe\x5c\xea\x03\xad\xff\x66\xb1\x44\x91\xda\x3f\xfb\xcb\xc0\x4a\x46\xf6\x1e\x92\xfd\xc8\x85\xf5\x92\xab\x09\xb5\xf6\x8a\x08\xdb\x18\x64\x5a\x2f\xd2\xfa\x0d\xe9\xa2\x2d\x8c\x3a\xbb\x4a\x9d\x8d\x29\xb6\x6e\xa6\x15\xf0\xaf\xa4\x07\x82\x0a\x0b\xd6\xf2\xa0\xb9\x7f\x40\xc7\x65\x3e\x54\x1a\x6c\x8d\x68\xdb\x2b\x57\xe0\xea\x75\x2a\x1c\x3e\xfb\xcb\x96\x92\x20\xf4\x9d\x48\xe6\xeb\xd5\x2d\xec\x11\x28\x3b\xe0\xdb\x84\xb5\xd3\xac\xdb\xe3\x1f\x04\x41\x52\x11\xb0\xb3\x5c\x69\x4b\x05\xa1\x5b\x79\x8f\x53\x45\xc8\x0d\x7c\x21\x35\xda\x00\x8d\x9c\x9f\xd4\xce\x0b\xed\x25\x7b\xb6\xb6\x76\x4c\xb5\xe4\xad\xf4\xf3\xfb\x94\x2b\xac\x6b\xd1\xd1\x04\xe5\x8a\xdd\x81\x35\xff\x70\xef\xb2\x32\x25\xb4\xbb\xfb\x0c\x17\x29\xf5\x0d\x67\x0a\xe7\x64\x49\x59\x26\xdc\xa2\x2c\xe7\x3e\x85\x93\xe5\x6c\x93\x46\xe3\x11\xf2\x37\xb6\xa6\xaa\x0d\x02\xd2\x73\x04\x98\x22\x31\xd0\x35\x15\x16\xc9\x67\x14\x58\xa3\x2e\x50\xe7\x0b\xee\x6a\xa9\x1b\xb4\x19\x7c\x70\x24\x29\xf8\x6f\x59\xce\x89\x85\xe1\xd0\x7e\xaa\xc4\x59\x01\x85\xea\x65\x0c\x24\x65\xf6\x94\xd7\x58\xaa\x68\x88\xfd\x94\x03\x25\x08\x58\xac\xac\x77\x50\x34\xdc\x6b\x5b\x45\xa2\x21\x3e\x64\x9c\xc5\x5a\xa1\xcb\xb6\x91\xd0\x96\x04\xc1\xe0\x89\xa4\xd2\x84\xae\x1a\x77\x7e\xc9\x77\x7a\xd3\xf9\x51\x19\x5a\x21\x2d\x0c\xa9\xfd\xb7\x4f\x03\xdc\x54\x4c\x44\xd7\x63\x40\xac\x12\x43\x9a\x03\x8d\x0e\xcc\xc7\x7e\x3d\x92\xdc\xcc\x93\x00\x6a\xd3\x3e\x76\xc7\xa2\x5a\x45\xb9\xf3\xe9\x56\xe8\x6b\x2c\x40\xe1\x9d\xcc\x4d\x69\x45\x3d\x97\xb9\x50\x6a\xc1\x66\xca\xe5\xa0\xf4\x8e\xbb\x28\x03\x6d\x9b\x6d\x6e\xbc\xbd\x02\xb8\x77\xfb\xc2\x61\x6e\xd1\xef\x6e\x85\x5d\x86\x75\x5d\x50\xa6\x08\x48\x2c\x8e\x00\x82\x8e\x44\x9d\x4b\xfd\x1e\x91\xe7\x64\x48\xac\xba\x46\x7b\x8c\x09\x48\x4f\x95\x33\x38\xe7\x90\x3a\x45\xc7\x5a\x7e\x8d\x58\x07\x4d\x53\xd2\x79\x70\x95\x50\x6a\x04\x4e\xea\x1c\x01\x45\x3e\x0f\xec\xd4\x88\xa9\xa0\xf6\x56\x62\x48\x83\x28\xd4\x2e\x5a\xd9\xa0\xf6\x9b\x93\x9a\xe1\xba\x6b\xa0\xe6\x1a\x66\x63\xeb\x53\x76\x73\xb2\xf3\x45\x29\x26\xc6\x3b\x27\xd7\x5d\xef\xdd\xe3\xe8\xd0\x27\xbe\xf4\x94\x7c\x94\xbb\x7d\xcd\x87\xa5\xe5\xed\x3d\xc3\xdc\xdc\xa6\x8e\xf3\x9a\x91\x93\xe3\x75\x49\xb6\x85\x74\x39\x59\x3a\x16\x70\x66\xb4\xe3\xfc\x34\x5c\x3c\xf0\xc5\xc1\x8d\x50\x41\x15\x12\xe0\xda\x28\xc5\x26\xdf\xa4\x72\x82\xf2\x78\x0d\x58\x4d\xb1\x28\xb0\x20\xb2\x02\x2a\x5b\xc2\xdc\x1f\x6c\x15\xa5\xf8\x70\x61\x94\x1a\x8e\x62\x83\x75\xe9\x3e\x55\x69\x62\xc0\x50\x6e\xb4\x1c\xfa\x12\xc7\xa4\x6b\x6d\xa6\x40\x8f\xb6\x92\x3a\xa6\x47\x94\xea\xb6\x8c\x9d\xa2\xbf\x45\xd4\x90\xcf\x31\xbf\x6e\x4d\x29\xde\xdb\xac\x48\x2d\x5e\x1a\x2d\x7b\xac\xee\x4a\xcc\x28\xc5\x85\x86\x43\x04\x49\x35\x81\xc6\xdb\xb4\x67\xc5\x46\x7b\xce\x5e\xdc\x08\xa9\xc4\x54\x21\x47\xcd\xf6\x6b\xb4\x74\x7f\x94\xe2\x79\xdd\x28\x45\x49\xac\x2e\xa0\x7c\x77\x71\x06\xde\x8a\xd9\x4c\xe6\x34\x55\x48\x8b\xb9\x8f\x3d\x89\x6d\x24\x0c\xa5\x6b\x5b\x2d\xc2\x79\xe1\x9b\x35\x19\x0d\x08\x78\x48\xb0\x54\x87\xc8\xad\x0d\xa2\x25\x51\xbe\x5b\x2e\x56\x08\x0d\x0c\xc5\xd6\x52\x33\x35\x83\x37\x86\x6b\x04\xe1\xe1\x35\x3a\x0a\xbb\xcc\xa0\x77\x28\x9c\xd1\x3d\xef\xca\xd9\xaf\x95\xa5\xd4\x42\x45\xa2\xf8\xd6\x87\x52\x74\x69\x74\x5b\x7b\x88\x05\x19\x65\x25\x4b\x2b\x7c\xeb\x14\x3b\xbc\x63\x74\x89\x71\x71\xd6\xf8\xc6\x62\x06\xa7\x7a\xc1\xf2\x9e\xa1\xa0\x01\x82\xec\xad\x29\x9a\x9c\xf2\x25\x72\xb0\x8d\xeb\x03\xf9\xaa\x6e\x74\x89\x6b\x07\x67\xe9\x90\x94\xe8\x39\x32\x00\x21\x63\xf3\xd4\x68\x04\xe1\x6a\xaa\xe3\x92\x4e\x36\x96\x9b\xd8\x2d\x83\x39\x58\x9c\x5e\x9c\x43\x7a\x1a\x92\xc1\x78\x3c\x86\xf7\x34\xec\xbc\x6d\x72\x8e\x2f\x64\x42\xba\x88\x91\x22\x68\x1f\x13\x29\x38\xed\x64\x32\x20\x76\x3e\x42\x0a\x56\x0b\x3f\x87\x2c\x30\x3e\xeb\xb1\x02\xe0\x15\xc5\x9a\x3b\x51\xd5\xac\xf7\xe4\xba\x5f\x19\x73\x19\x24\x14\x0e\xfc\x27\x13\x7a\x7c\xbc\xaa\x14\x66\x4a\x39\x6a\xec\x20\xb2\x6e\xcc\x8c\x79\xec\x96\x69\xca\xd2\xe6\x9f\xb5\xb9\xd5\x9b\x50\xe0\x33\x85\xc5\x09\x5c\x1d\x9c\x26\x13\xbc\x3a\x18\xc1\xd5\xc1\x85\x35\x25\xe5\xae\x52\x97\x34\x40\x9a\x75\x75\xf0\x02\x4b\x2b\x0a\x2c\xae\x0e\x12\xe8\xff\xa8\xa9\xd4\x7a\x8d\xb6\xc4\x9f\x71\xf1\x9c\x01\x2e\x4d\xa5\xf0\xf0\xbc\xa2\x35\xed\x1c\xc5\x64\x0a\x5c\xcf\x2b\x51\x2f\x0d\xbe\x16\xf5\x12\xa0\xb3\x4e\x01\x3f\x7d\xae\xd0\x8b\x9b\x93\xac\x13\xf5\x3f\x7e\x75\x46\x4f\xae\x0e\x3a\x9a\x46\xa6\x22\x95\xa9\xfd\xe2\xea\x00\x96\x30\x98\x5c\x1d\x30\x0e\x69\x3c\x21\x3d\xb9\x3a\xa0\xd3\x68\xd8\x1a\x6f\xa6\xcd\x6c\x72\x75\x30\x5d\x78\x74\xa3\x93\x91\xc5\x7a\x44\x99\xd4\xf3\xee\x84\xab\x83\x7f\xc0\x95\x4e\x48\x73\xa1\x18\x24\xed\xe0\xf7\x83\x81\x78\x3f\x10\x14\x86\x8b\x3b\xaa\xde\x94\x70\xfe\xbd\x15\xda\xc9\xf4\x8c\x62\xeb\xd2\x2a\x38\x83\xad\xf3\x96\x1d\xc4\xd6\xe9\xa0\x25\x5b\xa7\xb7\x84\xd6\x7d\xc2\xda\x3a\x0d\x7b\xb6\xa4\xd7\x37\xa6\x7c\x87\x66\xba\x26\x4e\x2b\x23\x0a\x10\x71\x35\x19\x2a\x25\xf9\x64\xff\xd1\xf9\x51\x3a\xa9\x59\x6e\x59\x34\xee\xb6\xfa\x6f\xaf\x40\x1b\x5d\xa0\x55\x0b\x4a\x37\x3a\xa8\xf9\x9c\xaa\x81\x22\x83\xd0\x54\x10\x6d\x0b\xe7\x9a\x0c\x8c\x43\x97\xee\x75\xb6\x19\xaf\x16\x22\x39\x96\xe0\x10\x22\x18\x8e\x82\x79\x8e\xb5\xe7\x30\xf8\xf0\x9b\x16\xe8\x75\x5c\x28\xed\x1a\xfb\xed\xea\x11\x95\x63\x4f\xc6\xc7\xd5\xf1\xd2\xba\xa9\x04\xc5\x15\x51\x10\xbe\xdd\x5c\xa8\xed\x42\x2d\x16\xfc\xad\x98\x9a\x26\xf6\x7e\x5b\x39\x44\x56\xc7\x28\xc3\x59\x5b\xed\x17\x3b\xdb\x29\x7b\x11\x5f\x89\xbb\x5f\x50\x97\x7e\x3e\x81\x6f\x9f\xfe\xe7\xb3\xbf\x6e\x59\x18\x9c\x26\x16\x3f\xa1\x8e\x8d\xa2\x3d\xd9\xb0\xbe\x71\xb5\xa3\xd8\xbd\x74\x2a\xbb\x35\x6d\x07\xbc\xd3\xa0\x5b\xc1\xf7\x98\x31\x96\x36\x35\xf1\x85\xa2\x40\x68\x44\xe4\x38\xa2\x0c\x6a\x23\x30\xd9\x3a\x77\xb5\x80\x93\xa7\x23\x98\x46\x16\xaf\xbb\xf5\x4f\x77\x9f\xb3\x0d\x28\x4b\x07\x7f\x1b\xad\xe0\x23\x1d\x90\xa8\xcc\x8c\x15\x27\xd4\x9f\x16\x43\x98\x4c\x9d\x82\xf5\x30\x89\x2d\xbe\xbb\x04\xb7\xab\x59\xb8\x5f\xa3\xb0\x92\x5a\x56\x4d\x35\x81\x27\x5b\x96\x04\x97\xb6\xa7\x34\xc3\xe2\x2e\x4b\x10\xe4\xba\x4a\x2b\x2a\xca\x87\x72\x90\x05\x6a\x2f\x67\x12\x6d\x5f\xb5\xb9\x17\x10\x36\xa6\xab\xd8\x96\x8b\x7c\x4b\x4b\x7e\xa8\xa7\xec\x17\x21\x09\xb2\x1c\x9d\xe3\xd5\x4e\xde\x77\x50\x8b\x1a\x83\x35\x84\xea\x06\xf0\xae\x0e\x79\x6c\xef\x8e\xa2\x42\xa1\xa5\x2e\xd3\xed\x6f\x6a\x34\x87\x68\x7c\x3b\x47\x0e\x3d\x6d\x13\x33\x5c\x06\xe4\x54\x49\x15\x5c\x54\x09\x28\x1b\x61\x85\xf6\x54\xe3\x9e\x5e\x9c\x87\x04\x7e\xb5\xe1\x29\xba\x27\x41\xc9\x1a\x83\xa9\x06\x67\x45\x28\xc6\x67\x44\x6c\xb1\x5f\xcf\x54\x4f\x9e\x3c\x1d\x14\x79\xbb\x6e\xfb\xfd\x9e\xf0\x1e\xad\x9e\xc0\xff\x7d\x3a\x1d\xff\x5d\x8c\x7f\xfb\x7c\x18\xff\x78\x32\xfe\xdb\xff\x8f\x26\x9f\xbf\xe9\x7d\x7e\x3e\xfa\xe1\xdf\xb7\x40\xda\x9c\xe9\x6f\x51\x9f\x18\x44\x52\x12\x99\x24\x3a\xe2\x08\x63\x66\xf0\xde\x36\x38\x82\x57\x42\x39\x1c\xc1\x07\xcd\xa1\xe1\x0f\x32\x0d\x75\x53\x0d\x55\x82\x63\x38\xa0\x53\x37\x27\x1f\xed\x12\x46\x69\x78\x4d\x44\x77\xa8\xb6\xdd\x8f\x49\xa9\x0f\xd1\xf3\x34\xbd\xa7\x67\xfc\x56\x89\x0c\xc9\x64\x31\xfd\xcd\x72\x53\x1d\xf7\x9e\xa6\x51\xde\xfd\x5a\xe8\x05\x74\x6e\x2d\x24\xab\xab\x9a\xee\x3c\xf9\x26\x91\x5b\xe3\x5c\xfb\xb6\xce\x81\x92\xd7\x08\xa7\x5d\x51\x49\xce\x72\x8a\xb9\xe0\x44\xdd\x4e\xa5\xb7\x22\x74\x84\x53\x6e\xd9\xb5\x9b\x66\x8d\x82\x43\xaa\x65\x33\x7e\x4f\xb1\xe6\x5d\x8f\x62\x6b\x77\x2a\x95\xf4\x8b\x50\x67\xe7\x46\xcf\x94\x8c\xf5\x41\x55\x1b\xeb\x85\xf6\xb1\x09\x89\x25\xde\x81\xec\xee\xc5\xa5\x83\xc3\x42\xbb\x93\x93\xa7\xdf\x5e\x36\xd3\xc2\x54\x42\xea\x57\x95\x3f\x3e\xfa\xe1\xf0\x4b\x23\x14\x5f\x01\xbf\x11\x15\xbe\xaa\xfc\xd1\xd7\x0b\x8b\x27\xcf\xf6\xb0\xa2\xc3\x4f\xc1\x56\x3e\x1f\x7e\x1a\xc7\xbf\xbe\x49\x43\x47\x3f\x1c\x5e\x65\x83\xf3\x47\xdf\x10\x0d\x3d\x0b\xfc\xfc\x69\xdc\x99\x5f\xf6\xf9\x9b\xa3\x1f\x7a\x73\x47\x9b\x8c\xf1\x6e\x7c\xdd\x4c\xd1\x6a\xf4\xe8\xc6\x54\x0d\x8c\x2b\x51\x8f\xaf\x71\xb1\xc5\x38\xb7\xa6\xa3\xeb\x80\x02\xc7\x2a\x51\x6f\x2a\xcd\xc3\x13\xb3\x77\xc8\xcf\x9a\xf2\x8d\x4a\xfe\x07\xaf\x67\xb4\xd8\x92\x92\x85\x29\x7e\x04\xff\x80\x96\x14\xc5\x9d\xd0\x86\x1b\x4a\xa7\xf7\xd0\x96\xfd\xf2\x47\x3d\xf0\x8c\x67\xe7\x21\x2d\x9d\x0f\x86\x90\xec\x7b\xcb\x0b\xe8\xbd\xe1\x34\x72\x6b\xa5\xb5\xdc\xe0\x3c\x7f\x11\x52\x5f\x76\x3d\x9c\xce\xcd\x0d\xd5\x79\x8d\x96\x5f\x1a\x84\xf3\x17\xd1\x1f\x8d\x40\xea\x5c\x35\x05\x65\x0a\x1f\x3e\x9c\xbf\xa0\xe2\xfe\xc7\xe8\x6e\x6e\x11\x0a\xa3\x1f\x7b\x78\xfb\xe6\x97\xff\xe5\x4e\x01\xaf\x18\x85\x80\x1e\x2e\xab\x84\x92\xe1\xf1\x74\x0a\xc0\xf0\x23\x12\xac\x78\x72\x2e\xea\xb6\xb9\xc2\xee\x4e\x17\x30\x47\x55\x53\x02\x71\x8d\xe0\x1a\x1b\xb1\x23\xc0\xe1\x3a\x98\x78\x0d\xf1\xb2\xb8\x44\xcf\x4a\xae\xf8\x11\xf0\x43\x98\x16\x9f\xa5\x4a\xa3\x2f\x29\x0b\xfc\x13\xec\x83\x14\xf9\x6d\xcc\x59\xf9\x8c\x07\x18\xc3\xc0\x5b\xdc\x9d\x14\x42\x34\xa6\xb3\x40\xe9\x9f\x6e\x49\x6b\xf4\x3e\xe8\xc4\xd0\xec\xe4\x6b\xcf\x77\x3b\x9a\xd3\x6b\x6f\xbc\x96\x4b\xe7\x95\xff\x12\xc1\x8d\xd7\xf6\xe6\x74\x2e\x1c\x4c\x11\x35\xf7\x7a\x43\x6b\x10\x75\xd4\x3a\xec\xba\xb4\x4d\x3d\xf6\x66\x5c\x6c\x16\xde\x0e\xce\xed\xe6\xda\x40\xe5\xba\x44\xdb\xe9\xbd\x0b\xd5\xdb\xf9\x62\x13\x0f\x5c\xe8\x75\xf2\xab\xa2\x94\x83\xdc\x97\xb0\xed\x85\xc9\x4a\xcb\x97\x2b\x8b\xd8\xd4\x88\x75\xc6\x3a\x4a\x54\x3d\x2e\x75\x36\xbc\xe1\xab\xbe\xe5\xae\xdf\xfd\x71\x0c\x62\xbe\x44\x7b\x23\x1f\x14\xfc\x76\x19\x66\x1e\x1e\xa1\x9c\xfe\xf9\x66\x45\xa9\xd7\x83\x0f\xe1\xf6\x5f\x6e\x76\xdc\xed\x0c\x00\x70\x81\x83\x43\x8f\x5d\xef\x03\xe3\xbe\xc1\x32\x78\x93\x09\x3f\x3c\x4e\x43\xde\x58\xbe\x8f\xef\x8f\x35\xd3\x36\x51\xee\xa0\xc7\x1a\x08\xfe\xf9\xfb\xa3\x7f\x05\x00\x00\xff\xff\x53\x7d\x47\x3d\x4a\x39\x00\x00") +var _operatorsCoreosCom_catalogsourcesYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x5b\x7b\x73\xdc\x36\x92\xff\xdf\x9f\xa2\x4b\x77\x55\x96\x72\x33\x94\x95\x6c\xe5\xb2\x73\x79\x94\x22\xdb\x39\x55\x62\x47\x65\x39\xb9\xba\xb5\x7c\xb7\x18\xb2\x87\x83\x08\x04\x68\x00\x94\xc4\x6c\xed\x77\xdf\xea\x06\x40\x72\x5e\x9c\x91\xe3\xcc\x3f\x16\xf1\x68\x00\xfd\xfc\x75\x03\x16\xb5\xfc\x15\xad\x93\x46\xcf\x40\xd4\x12\x1f\x3c\x6a\xfa\x72\xd9\xed\x57\x2e\x93\xe6\xf4\xee\xec\xc9\xad\xd4\xc5\x0c\x2e\x1a\xe7\x4d\xf5\x06\x9d\x69\x6c\x8e\xcf\x71\x21\xb5\xf4\xd2\xe8\x27\x15\x7a\x51\x08\x2f\x66\x4f\x00\x84\xd6\xc6\x0b\x6a\x76\xf4\x09\x90\x1b\xed\xad\x51\x0a\xed\xb4\x44\x9d\xdd\x36\x73\x9c\x37\x52\x15\x68\x99\x78\x5a\xfa\xee\x59\xf6\x55\xf6\xec\x09\x40\x6e\x91\xa7\xbf\x95\x15\x3a\x2f\xaa\x7a\x06\xba\x51\xea\x09\x80\x16\x15\xce\x20\x17\x5e\x28\x53\x86\x4d\xb8\xcc\xd4\x68\x85\x37\xd6\x65\xb9\xb1\x68\xe8\x9f\xea\x89\xab\x31\xa7\xd5\x4b\x6b\x9a\x7a\x06\x5b\xc7\x04\x7a\x69\x93\xc2\x63\x69\xac\x4c\xdf\x00\x53\x30\xaa\xe2\xbf\xe3\xe1\xc3\xb2\xd7\xbc\x2c\xb7\x2b\xe9\xfc\x8f\x9b\x7d\x3f\x49\xe7\xb9\xbf\x56\x8d\x15\x6a\x7d\xc3\xdc\xe5\x96\xc6\xfa\xd7\xfd\xf2\xb4\x5c\x2e\xbc\xb3\x79\xe8\x96\xba\x6c\x94\xb0\x6b\x73\x9f\x00\xb8\xdc\xd4\x38\x03\x9e\x5a\x8b\x1c\x8b\x27\x00\x91\x85\x91\xd4\x14\x44\x51\xb0\x58\x84\xba\xb2\x52\x7b\xb4\x17\x46\x35\x95\xee\x96\xa2\x31\x05\xba\xdc\xca\xda\x33\xeb\xdf\x2e\x11\x6a\x8b\xde\xb7\xcc\x12\x30\x0b\xf0\x4b\x4c\x6b\x77\xb3\x00\x7e\x73\x46\x5f\x09\xbf\x9c\x41\x46\x1c\xce\x0a\xe9\x6a\x25\x5a\xda\xcd\x60\x54\x10\xd3\xf3\xd0\x37\x68\xf7\x2d\x6d\xdd\x79\x2b\x75\x39\xb6\x15\x1a\x77\xf8\x1e\x02\x6b\xde\xb6\xf5\xe6\x16\xd6\x1a\x0f\x5d\xbf\x6e\xe6\x4a\xba\x25\xda\xc3\x37\xd1\x4d\xd9\xd8\xc3\xd5\x96\x9e\x1d\x1b\x19\x10\x4d\x06\x95\x6d\x18\xc3\xc6\x02\xe7\xe5\xe6\x19\x0b\xe1\x53\x63\x18\x74\x77\x26\x54\xbd\x14\x67\xb1\xd1\xe5\x4b\xac\x44\xaf\x0f\xa6\x46\x7d\x7e\x75\xf9\xeb\x17\xd7\x6b\x1d\xb0\xca\x9d\x15\x3d\x07\xe9\x40\x80\xc5\xda\x38\xe9\x8d\x6d\x89\x5b\x17\xd7\xbf\xba\x09\x5c\xbc\x79\xee\x26\x20\x74\xd1\x19\x1e\xd4\x22\xbf\x15\x25\xba\x6c\x63\xaf\x66\xfe\x1b\xe6\x7e\xd0\x6c\xf1\x43\x23\x2d\x16\xc3\x5d\x10\x7b\x12\x4f\xd6\x9a\x89\xff\x83\xa6\xda\xd2\x9a\x7e\x60\xc8\xe1\x37\xf0\x72\x2b\xed\x6b\x27\x7c\x4a\x6c\x08\xe3\xa0\x20\x07\x87\x8e\x55\x20\xda\x18\x16\x91\x77\x41\x35\xa4\xa3\xf3\x5b\x74\xa8\x83\xcb\xa3\x66\xa1\xe3\x99\x32\xb8\x46\x4b\x13\xc9\xdc\x1b\x55\x90\x27\xbc\x43\xeb\xc1\x62\x6e\x4a\x2d\x7f\xef\xa8\x39\xf0\x86\x97\x51\xc2\xa3\xf3\xc0\x56\xab\x85\x82\x3b\xa1\x1a\x0c\xac\xac\x44\x0b\x16\x89\x2e\x34\x7a\x40\x81\x87\xb8\x0c\x5e\x19\x8b\x20\xf5\xc2\xcc\x60\xe9\x7d\xed\x66\xa7\xa7\xa5\xf4\xc9\x87\xe7\xa6\xaa\x1a\x2d\x7d\x7b\xca\xee\x58\xce\x1b\x72\x87\xa7\x05\xde\xa1\x3a\x75\xb2\x9c\x0a\x9b\x2f\xa5\xc7\xdc\x37\x16\x4f\x45\x2d\xa7\xbc\x59\xcd\x7e\x3c\xab\x8a\x7f\xb3\xd1\xeb\xbb\xa7\x6b\xec\xdb\xaa\xcc\x90\xdc\xe6\x28\xaf\xc9\x79\x06\x2d\x0a\xd3\xc3\x59\x7a\x96\x52\x13\x71\xe5\xcd\x8b\xeb\xb7\x90\x36\x10\xd8\x1e\x38\xdc\x0f\x75\x3d\xb3\x89\x51\x52\x2f\xd0\x86\x91\x0b\x6b\x2a\xa6\x82\xba\xa8\x8d\xd4\x3e\x98\xb4\x92\xa8\x3d\xb8\x66\x5e\x49\xef\x58\xe7\xd0\x79\x92\x43\x06\x17\x1c\xc2\x60\x8e\xd0\xd4\x64\x49\x45\x06\x97\x1a\x2e\x44\x85\xea\x42\x38\xfc\xd3\x59\x4d\x1c\x75\x53\x62\xdf\xe1\xcc\x1e\x46\xe0\xcd\x09\x1b\x36\x06\x90\x22\xe4\x41\x83\x77\x19\x25\x04\x0b\xdc\xe6\x81\x61\xc4\x16\xe9\x27\x8a\xc2\xa2\xdb\xd2\xb1\x61\x90\x61\x60\xd0\x93\xa5\x71\x24\x3f\xe1\xe1\xe7\x9f\x5e\x41\x2e\x34\x34\x0e\xc9\x78\x72\xa3\x35\x29\x84\x37\x20\x28\x96\x4d\xf1\x41\x3a\x56\x20\x8b\xa5\x74\xde\xb6\x19\xbc\x34\xb6\x12\x7e\x06\x5f\xa7\xa6\x29\x93\x33\x16\x64\xfd\xed\xec\xeb\xda\x58\xff\x2d\xfc\xac\x55\x4b\x44\x0b\xb8\x5f\xa2\x86\xeb\xee\x6c\xf0\xcd\xe0\xe3\x07\x5b\xe7\x19\x5c\x96\xda\xd8\x34\x92\xb4\xea\xb2\x12\x25\xc2\x42\xa2\x62\xbd\x76\xe8\xb3\x75\x09\x8e\x4a\x11\x02\x5c\x5a\xc8\xf2\x95\xa8\xf7\xb2\xe6\x22\x8d\xa4\xb5\x68\xf9\x61\xf0\xee\x3b\xbd\x61\x55\xa6\x23\xd1\x9f\x22\xbf\x05\x11\x57\xa9\x44\x3d\x75\x6c\x36\x03\x36\x1d\xc6\x81\x8b\x44\x80\xf8\xd7\x37\x5f\x46\xcf\x95\x3d\xf6\xd8\xc3\x93\x3d\x7a\x6e\x0f\x43\xf6\x32\xed\xd5\xb6\x28\x72\xc0\x1a\xa5\xad\xf3\x2b\x53\x84\x63\xef\x5d\xe5\x87\xe1\x68\xc0\x87\xda\x38\x74\x50\xc8\xc5\x02\x2d\xf9\x1d\x73\x87\xd6\xca\x02\x1d\x2c\x8c\x65\x79\xd5\xa6\x60\x9b\xec\xe4\xb7\x12\x6a\xaf\x4c\x71\xa8\x60\x68\x69\x0e\x18\x41\x19\xa3\x1a\xee\x3c\xee\x56\x6b\x87\x3d\xc6\x4b\x3f\x6d\x0a\xbc\x46\x85\xb9\x37\x76\xfb\x88\x35\x9e\xbc\x1e\x4c\x88\x5e\x3f\x7d\xdd\x2f\x65\xbe\x84\xaa\x71\xec\x75\xbd\x6d\x70\x85\x2f\xde\xc0\x42\x7a\x30\x1a\x04\x2f\x4b\xbe\x7e\x73\x66\x25\x7c\xbe\x8c\x23\x9e\x3a\x50\x62\x8e\xca\xad\xd3\x99\x23\x87\xdc\xa2\x51\x58\x10\x41\xf6\x25\x4c\x73\xc7\x11\xf6\x70\x09\x82\x2b\xeb\xf0\xf6\x38\xcf\x60\x9f\x96\x05\xc6\x4b\x63\xa5\x6f\x2f\x94\x70\x6e\x97\x4e\x6f\x70\xf7\x72\xc1\xea\x23\x17\x12\x8b\x09\x48\x5d\x48\x4a\x69\x5c\x3a\xfb\x53\xd7\xd1\xcd\x68\x2c\x05\xb8\xc1\xf8\xc4\xa1\x34\x06\xee\xa5\x52\xc4\xac\x02\x17\xa2\x51\xec\x24\x7f\x47\x6b\x40\xb2\x76\x5a\xd6\x2b\x6d\x52\xf7\x38\xf3\x46\xce\xea\x8d\x22\x80\xd8\x67\x2f\x7b\x4e\xf9\xb6\x1f\x0f\xc2\xe2\x10\x9d\xc7\x30\x44\x07\xe5\xe3\x0e\x48\x8f\x6f\x4f\x58\xbb\x92\xa6\x0c\x7f\xd2\x63\x35\x22\xcb\xcd\xd4\x81\xb4\x8c\x50\x47\xbf\x51\x56\x75\xef\x05\x69\x1d\xc3\xbc\xd0\x83\x0e\x84\x6e\xc1\x8b\x80\x48\x44\xd4\xdf\x28\x31\x6f\x65\xad\x10\xbe\xbe\xc5\x76\x12\x30\x20\x2e\x16\x98\xfb\x6f\xa1\x71\x09\x15\xf1\x78\xfa\xe8\x40\xf6\xd7\xe9\xaf\x6f\x77\x9d\xf8\x20\x7d\xde\x6f\xfb\xe1\x17\xb6\x34\x36\x62\x8d\x43\x2f\x78\xc2\x9a\x72\x06\x0e\x04\x5a\xc4\x1f\x3e\x56\x06\x2f\xaa\xda\xb7\x50\xa1\xd0\x2e\x59\xb6\x52\x2b\x83\x5d\x06\xff\x43\x7e\x70\xa0\xc6\x42\x29\x73\xdf\x61\x62\xd6\x90\xd7\xe6\x3a\xda\xfb\x04\xae\x2c\x2e\xd0\xf6\x2d\xec\x26\x5f\x9b\x17\x0f\x98\x37\x7e\xa7\x07\x18\xf2\x6d\x44\x95\xc3\xef\x16\xdb\x47\x30\xe4\x47\x6c\x53\xec\x0e\x27\xbb\xc5\x36\x28\x03\x37\xf5\x3a\x24\xea\x5a\x49\x0c\xf0\x74\x8c\x33\xb7\xd8\x3a\xb6\x6f\x9a\x7f\x1b\xa8\x23\x8d\x9f\xf4\x5a\x92\xdc\xec\x0b\x42\x48\xee\xbf\x82\xbe\xe6\xa6\x9a\x4b\x1d\x16\x0b\xa4\x93\x28\x98\x7a\x62\xa8\x2e\xf8\x93\x97\xf9\x14\xec\x4a\x9b\x7a\x04\xcf\x7e\x4e\xe7\xe8\xb1\x3f\x08\xda\xd1\x53\x82\xf1\x2a\x58\xfc\x52\xd6\x29\xa5\xe2\xad\x67\xf0\xab\x50\xb2\xcf\x47\x83\x6e\x04\x0e\xf0\xa9\x5e\x7c\x68\x84\xca\xe0\x79\xf0\x67\x7c\xfa\xd8\x14\x07\x11\x23\x3f\x34\xf2\x4e\x28\x8a\xdf\xde\x90\x87\x2c\x72\x61\x0b\x8e\x30\x31\x4f\x73\x26\x48\x4f\xb0\x23\x20\x78\x9a\xac\xbd\x97\x91\xe3\x1c\x11\x6a\x61\xbd\xcc\x1b\x25\x6c\xaa\x3d\xb5\x9f\x84\xa3\xbd\xd2\x5c\x63\x6e\x74\x31\x6a\xc1\x3b\xbd\x6b\x9c\x3b\xe4\x31\x87\x08\xb4\xd2\x14\x0c\x51\x64\x85\xeb\x4a\x7a\xbc\x1a\xc6\xcd\x22\x59\x75\x67\x62\x13\x30\x14\x3d\xee\xa5\x8b\x69\x5c\x07\x95\x65\x80\xd2\x27\x03\xf7\xd8\x59\x45\x06\xdf\xb7\x29\xd2\x4c\x40\xfa\x10\x7b\x3c\xe1\x9a\x49\x02\x00\x51\x65\x23\xb3\x7b\x83\x5a\x18\x8b\x04\x6f\x8f\x0b\xc3\x73\xf0\x4e\xe6\xfe\x24\x83\xbf\x51\x30\x23\xc1\x6b\x2c\x85\x97\x77\x98\x54\x3c\x05\x3e\x6f\x91\x52\x3f\x10\x0e\x9e\xc1\x31\x4f\x03\x59\x55\x58\x48\xe1\x51\xb5\x27\x30\x6f\x79\x19\xd7\x3a\x8f\xd5\x21\xa2\xa3\xa4\xbe\x5c\xa9\x03\x6d\xfe\x16\x31\x45\x91\xda\x7f\xf9\x97\x91\x91\xbc\xd9\x47\x48\xf6\x57\x4e\xac\x57\x5c\x4d\xc8\xb5\xd7\x44\xd8\xc5\x20\xd3\x79\x91\xce\x6f\x48\x17\x6d\x61\xd2\xdb\x55\xaa\x6c\xcc\xb1\x73\x33\x9d\x80\x7f\x23\x3d\x10\x94\x58\xb0\x96\x07\xcd\xfd\x03\x3a\x2e\xf3\xb1\xd4\x60\x67\x44\xdb\x9d\xb9\x02\x67\xaf\x73\xe1\xf0\xcb\xbf\xec\x48\x09\x42\xdd\x89\x64\xbe\x99\xdd\xc2\x01\x81\xb2\x27\xbe\x4b\x58\x7b\xcd\xba\x5b\xfe\xa3\x28\x48\x4a\x02\xf6\xa6\x2b\x5d\xaa\x20\x74\x27\xef\x69\xca\x08\xb9\x80\x2f\xa4\x46\x1b\xa8\x91\xf3\x93\xda\x79\xa1\xbd\x64\xcf\xd6\xe5\x8e\x29\x97\xbc\x97\x7e\xf9\x98\x74\x85\x75\x2d\x3a\x9a\xa0\x5c\xb1\x3a\xb0\xe1\x1f\x1e\x9d\x56\x26\x40\xbb\xbf\xce\x70\x95\xa0\x6f\x58\x53\x38\x27\x4b\x42\x99\x70\x8f\xb2\x5c\xfa\x14\x4e\x56\xd1\x26\xb5\xc6\x25\xe4\xef\x6c\x4d\x55\x17\x04\xa4\xe7\x08\x30\x47\x62\xa0\x6b\x2a\x2c\x92\xcf\x28\xb0\x46\x5d\xa0\xce\x5b\xae\x6a\xa9\x3b\xb4\x19\xfc\xe2\x48\x52\xf0\xdf\xb2\x5c\x12\x0b\xc3\xa2\x43\xa8\xc4\xa8\x80\x42\xf5\xea\x0e\x24\x21\x7b\xc2\x35\x96\x32\x1a\x62\x3f\x61\xa0\x44\x01\x8b\xb5\xf1\x0e\x8a\x86\x6b\x6d\xeb\x9b\x68\x88\x0f\x19\xa3\x58\x2b\x74\xd9\x15\x12\xba\x94\x20\x18\x3c\x1d\xa9\x34\xa1\xaa\xc6\x95\x5f\xf2\x9d\xde\xf4\x7e\x54\x86\x52\x48\x47\x43\x6a\xff\xc5\xe7\x81\x6e\x4a\x26\xa2\xeb\x31\x20\xd6\x0f\x43\x9a\x03\x8d\x0e\xcc\xc7\x61\x3e\x92\xdc\xcc\xb3\x40\x6a\xdb\x3c\x76\xc7\xa2\x5a\xdf\x72\xef\xd3\xad\xd0\xb7\x58\x80\xc2\x07\x99\x9b\xd2\x8a\x7a\x29\x73\xa1\x54\xcb\x66\xca\xe9\xa0\xf4\x8e\xab\x28\x23\x65\x9b\x5d\x6e\xbc\xbb\x02\x78\x74\xf9\xc2\x61\x6e\xd1\xef\x2f\x85\x5d\x87\x71\x7d\x50\xa6\x08\x48\x2c\x8e\x04\x82\x8e\x44\x9d\x4b\xf5\x1e\x91\xe7\x64\x48\xac\xba\x46\x7b\x8c\x00\x64\xa0\xca\x19\x5c\x72\x48\x9d\xa3\x63\x2d\xbf\x45\xac\x83\xa6\x29\xe9\x3c\xb8\x4a\x28\x35\x01\x27\x75\x8e\x80\x22\x5f\x06\x76\x6a\xc4\x94\x50\x7b\x2b\x31\xc0\x20\x0a\xb5\x6d\x27\x1b\xd4\x7e\x3b\xa8\x19\xcf\xbb\x46\x72\xae\x71\x36\x76\x3e\x65\x3f\x27\x7b\x5f\x94\x62\x62\xbc\x73\x72\xfd\xf5\xde\x23\x96\x0e\x75\xe2\x6b\x4f\xe0\xa3\xdc\xef\x6b\x7e\x59\x19\xde\xdd\x33\x2c\xcd\x7d\xaa\x38\x6f\x18\x39\x39\x5e\x97\x64\x5b\x48\x97\x93\xa5\x63\x01\x17\x46\x3b\xc6\xa7\xe1\xe2\x81\x2f\x0e\xee\x84\x0a\xaa\x90\x08\xd7\x46\x29\x36\xf9\x26\xa5\x13\x84\xe3\x35\x60\x35\xc7\xa2\xc0\x82\x8e\x15\xb6\xb2\x23\xcc\xfd\xc1\x52\x51\x8a\x0f\x57\x46\xa9\xf1\x28\x36\x9a\x97\x1e\x92\x95\x26\x06\x8c\x61\xa3\xd5\xd0\x97\x38\x26\x5d\x67\x33\x05\x7a\xb4\x95\xd4\x11\x1e\x11\xd4\xed\x18\x3b\x47\x7f\x8f\xa8\x21\x5f\x62\x7e\xdb\x99\x52\xbc\xb7\x59\x93\x5a\xbc\x34\x5a\xf5\x58\xfd\x95\x98\x51\x8a\x13\x0d\x87\x08\x92\x72\x02\x8d\xf7\x69\xce\x9a\x8d\x0e\x9c\xbd\xb8\x13\x52\x89\xb9\x42\x8e\x9a\xdd\xd7\x64\xe5\xfe\x28\xc5\xf3\xba\x51\x8a\x40\xac\x2e\xa0\x7c\x73\x75\x01\xde\x8a\xc5\x42\xe6\xd4\x55\x48\x8b\xb9\x8f\x35\x89\x5d\x47\x18\x83\x6b\x3b\x2d\xc2\x79\xe1\x9b\x0d\x19\x8d\x08\x78\x4c\xb0\x94\x87\xc8\x9d\x05\xa2\x15\x51\xbe\x59\x4d\x56\x68\x1b\x18\x92\xad\x95\x62\x6a\x06\xaf\x0d\xe7\x08\xc2\xc3\x2b\x74\x14\x76\x99\x41\x6f\x50\x38\xa3\x07\xde\x95\xd1\xaf\x95\xa5\xd4\x42\xc5\x43\xf1\xad\x0f\x41\x74\x69\x74\x97\x7b\x88\x96\x8c\xb2\x92\xa5\x15\xbe\x73\x8a\xfd\xbe\x63\x74\x89\x71\x71\xd1\xf8\xc6\x62\x06\xe7\xba\x65\x79\x2f\x50\x50\x03\x51\xf6\xd6\x14\x4d\x4e\x78\x89\x1c\x6c\xe3\x86\x44\x3e\xa9\x1b\x5d\xe1\xda\xd1\x45\x5a\x24\x01\x3d\x47\x06\x20\x64\x2c\x9e\x1a\x8d\x20\x5c\x4d\x79\x5c\xd2\xc9\xc6\x72\x11\xbb\x63\x30\x07\x8b\xf3\xab\x4b\x48\x4f\x43\x32\x98\x4e\xa7\xf0\x96\x9a\x9d\xb7\x4d\xce\xf1\x85\x4c\x48\x17\x31\x52\x04\xed\xe3\x43\x0a\x86\x9d\x7c\x0c\x88\x95\x8f\x00\xc1\x6a\xe1\x97\x90\x05\xc6\x67\x03\x56\x00\xbc\xa4\x58\xf3\x20\xaa\x9a\xf5\x9e\x5c\xf7\x4b\x63\xae\x83\x84\xc2\x82\xff\x80\xd3\xd3\x75\x85\x30\x73\xc2\xa7\xb1\x7a\xc8\x7a\xb1\x30\xe6\xa9\x5b\x3d\x4f\x46\x13\x7f\xd4\xe6\x5e\x6f\x5b\x9a\xd7\x12\x16\x67\x70\x73\x74\x9e\x4c\xef\xe6\x68\x02\x37\x47\x57\xd6\x94\x84\x59\xa5\x2e\xa9\x81\x34\xea\xe6\xe8\x39\x96\x56\x14\x58\xdc\x1c\x11\xd9\xff\xa8\x29\xbd\x7a\x85\xb6\xc4\x1f\xb1\xfd\x86\x89\x75\xcd\x29\x1c\x7c\x53\x51\x3f\xb7\x53\xfc\xa5\x20\xf5\x4d\x25\xea\xae\xe1\x95\xa8\xbb\xc9\x17\xbd\x92\xbd\x7b\x5f\xa1\x17\x77\x67\x59\x2f\xce\xbf\xff\xe6\x8c\x9e\xdd\x1c\xf5\xfb\x9f\x98\x8a\xd4\xa2\xf6\xed\xcd\x11\xac\xac\x3a\xbb\x39\xe2\x75\x53\x7b\xda\xe4\xec\xe6\x88\x56\xa2\x66\x6b\xbc\x99\x37\x8b\xd9\xcd\xd1\xbc\xf5\xe8\x26\x67\x13\x8b\xf5\x84\xd0\xd2\x37\xfd\x0a\x37\x47\x7f\x87\x1b\x4d\x9b\xe5\x44\x30\x48\xd2\xc1\x3f\x8f\x46\xe2\xf9\x88\xd3\x1f\x4f\xde\x28\x3b\x53\xc2\xf9\xb7\x56\x68\x27\xd3\x33\x89\x9d\x43\xab\x60\xec\x3b\xfb\x2d\x3b\x80\x9d\xdd\x41\x1b\x76\x76\xef\x08\x9d\x87\x84\xad\xcd\x33\x1c\x58\x72\xde\x9c\x98\xf0\x0c\xf5\xf4\x45\x9a\x4e\x3e\x14\x00\xe2\x68\x32\x44\x02\xf1\x64\xdf\xd1\xb9\x11\x5c\xd4\x2c\xb7\x2c\x1a\x6f\x97\xdd\x77\x57\x9c\x8d\x2e\xd0\xaa\x96\xe0\x44\x4f\x35\x5f\x12\xda\x2f\x32\x08\x45\x03\xd1\x95\x68\x6e\xc9\x90\x38\x34\xe9\x41\xe5\x9a\xf7\xd5\x51\x24\xc7\x11\x0c\x3e\x92\xe1\x28\x97\xe7\x58\x7b\x0e\x73\x1f\x7f\x93\x02\x83\x8a\x0a\xc1\xaa\xa9\xdf\xad\x1e\x51\x39\x0e\x64\x7c\x1c\x1d\x2f\xa5\x9b\x4a\x50\xdc\x10\x05\xed\xb7\xef\x0b\xb9\x5b\xc8\xb5\x82\x3f\x15\x73\xd3\xc4\xda\x6e\x27\x87\xc8\xea\x18\x45\x18\x95\xd5\xbe\xdd\x5b\x2e\x39\xe8\xf0\x95\x78\xf8\x09\x75\xe9\x97\x33\xf8\xe2\xf3\xff\xfc\xf2\xab\x1d\x03\x83\x63\xc4\xe2\x07\xd4\xb1\x10\x74\x20\x1b\x36\x27\xae\x57\x0c\xfb\x97\x4c\x65\x3f\xa6\xab\x70\xf7\x1a\x74\x2f\xf8\x9e\x32\xc6\xca\xa6\x26\xbe\x90\x97\x0f\x85\x86\x1c\x27\x84\x90\xb6\x12\x93\x9d\x03\x57\x2d\x9c\x7d\x3e\x81\x79\x64\xf1\xa6\xfb\x7e\xf7\xf0\x3e\xdb\xb2\x65\xe9\xe0\xaf\x93\xb5\xfd\x48\x07\x24\x2a\xb3\x60\xc5\x09\xf9\xa5\xc5\x10\x06\x53\x25\x60\x33\x0c\x62\xb7\xdf\x7d\x82\xdb\x57\x0c\x3c\xac\x10\x58\x49\x2d\xab\xa6\x9a\xc1\xb3\x1d\x43\x82\x4b\x3b\x50\x9a\x61\x70\x8f\x02\x04\xb9\xae\xd2\x8a\x8a\xf0\x4e\x0e\xb2\x40\xed\xe5\x42\xa2\x1d\xaa\x36\xe7\xfa\x61\x62\xba\x6a\xed\xb8\xc8\xb7\xb0\xe4\x87\x06\xca\x7e\x15\x40\x8e\xe5\x08\x1c\xaf\x6e\xf2\xa1\x83\x6a\x6b\x0c\xd6\x10\xb2\x17\xc0\x87\x3a\xe0\xd4\xc1\x1d\x44\x85\x42\x4b\x5d\xa6\xdb\xdd\x54\x48\x0e\x51\xf7\x7e\x89\x1c\x7a\xba\x22\x65\x28\xf6\xe7\x94\x29\x15\x9c\x34\x09\x28\x1b\x61\x85\xf6\x94\xc3\x9e\x5f\x5d\x06\x80\xbe\x5e\xd0\x14\xfd\x93\x9f\x64\x8d\xc1\x54\x83\xb3\xa2\x2d\xc6\x67\x42\x6c\xb1\x9f\xce\x54\xcf\x9e\x7d\x3e\x2a\xf2\x6e\xdc\xee\xfb\x3b\xe1\x3d\x5a\x3d\x83\xff\x7b\x77\x3e\xfd\x9b\x98\xfe\xfe\xfe\x38\xfe\xf1\x6c\xfa\xd7\xff\x9f\xcc\xde\x7f\x36\xf8\x7c\x7f\xf2\xdd\xbf\xef\xa0\xb4\x1d\xc9\xef\x50\x9f\x18\x44\x12\x48\x4c\x12\x9d\x70\x84\x31\x0b\x78\x6b\x1b\x9c\xc0\x4b\xa1\x1c\x4e\xe0\x17\xcd\xa1\xe1\x0f\x32\x0d\x75\x53\x8d\x65\x7a\x53\x38\xa2\x55\xb7\x83\x8f\x6e\x08\x6f\x69\x7c\x4c\xdc\xee\x58\xee\x7a\x18\x93\x52\x9d\x61\xe0\x69\x06\x4f\xcb\xf8\x2d\x12\x19\x92\xc9\x22\xbc\xcd\x72\x53\x9d\x0e\x9e\x9e\x11\xae\x7e\x25\x74\x0b\xbd\x5b\x0b\xa0\x74\x5d\xd3\x9d\x27\xdf\x24\x72\x6b\x9c\xeb\xde\xce\x39\x50\xf2\x16\xe1\xbc\x4f\x1a\xc9\x59\xce\x31\x17\x0c\xc4\xed\x5c\x7a\x2b\x42\xc5\x37\xe1\xca\xbe\x9c\xb4\x68\x14\x1c\x53\xae\x9a\xf1\x7b\x89\x0d\xef\x7a\x12\x4b\xb7\x73\xa9\xa4\x6f\x43\x1e\x9d\x1b\xbd\x50\x32\xe2\xff\xaa\x36\xd6\x0b\xed\x63\x91\x11\x4b\x7c\x00\xd9\xdf\x7b\x4b\x07\xc7\x85\x76\x67\x67\x9f\x7f\x71\xdd\xcc\x0b\x53\x09\xa9\x5f\x56\xfe\xf4\xe4\xbb\xe3\x0f\x8d\x50\x7c\xc5\xfb\x5a\x54\xf8\xb2\xf2\x27\x9f\x2e\x2c\x9e\x7d\x79\x80\x15\x1d\xbf\x0b\xb6\xf2\xfe\xf8\xdd\x34\xfe\xf5\x59\x6a\x3a\xf9\xee\xf8\x26\x1b\xed\x3f\xf9\x8c\xce\x30\xb0\xc0\xf7\xef\xa6\xbd\xf9\x65\xef\x3f\x3b\xf9\x6e\xd0\x77\xb2\xcd\x18\x1f\xa6\xb7\xcd\x1c\xad\x46\x8f\x6e\x4a\x59\xc0\xb4\x12\xf5\xf4\x16\xdb\x1d\xc6\xb9\x13\x8e\x6e\x12\x0a\x1c\xab\x44\xbd\x2d\xf5\x0e\x4f\xc8\xde\x20\x3f\x5b\xca\xb7\x2a\xf9\x1f\xbc\x7e\xd1\x62\x07\x24\x0b\x5d\xfc\xc8\xfd\x23\x4a\x4e\x14\x77\x42\x99\x6d\x0c\x4e\x1f\xa0\x2d\x87\xe1\x47\x3d\xf2\x4c\x67\xef\x22\xdd\x39\x3f\x9a\x42\xb2\xef\x1d\x2f\x9c\x0f\xa6\xd3\xc8\x9d\x99\xd6\x6a\x01\xf3\xf2\x79\x80\xbe\xec\x7a\x18\xce\x2d\x0d\xe5\x79\x8d\x96\x1f\x1a\x84\xcb\xe7\xd1\x1f\x4d\x40\xea\x5c\x35\x05\x21\x85\x5f\x7e\xb9\x7c\x4e\xc9\xfb\xf7\xd1\xdd\xdc\x23\x14\x46\x3f\xf5\xf0\xf3\xeb\x9f\xfe\x97\x2b\x01\x3c\x62\x12\x02\x7a\xb8\x8c\x12\x4a\x86\xc7\xd1\x29\x00\xc3\xf7\x48\xb4\xe2\xca\xb9\xa8\xbb\xe2\x09\xbb\x3b\x5d\xc0\x12\x55\x4d\x00\xe2\x16\xc1\x35\x36\xee\x8e\x08\x87\xeb\x5e\xe2\x35\xc4\xcb\xe0\x12\x3d\x2b\xb9\xe2\x47\xbe\x1f\xc3\xb4\xf8\xec\x54\x1a\x7d\x4d\x28\xf0\x4f\xb0\x0f\x52\xe4\x9f\x23\x66\xe5\x35\x3e\xc2\x18\x46\xde\xda\xee\x3d\x21\x44\x63\xba\x08\x27\xfd\xd3\x2d\x69\xe3\xbc\x1f\xb5\x62\x28\x66\xf2\xb5\xe6\x9b\x3d\xc5\xe7\x8d\x37\x5c\xab\xa9\xf3\xda\x7f\x79\xe0\xc2\x6a\x77\x33\xba\x14\x0e\xe6\x88\x9a\x6b\xb9\xa1\xf4\x87\x3a\x6a\x1d\xf6\x55\xd8\xa6\x9e\x7a\x33\x2d\xb6\x0b\x6f\x0f\xe7\xf6\x73\x6d\x24\x73\x5d\x39\xdb\xf9\xa3\x13\xd5\xfb\x65\xbb\x8d\x07\x2e\xd4\x32\xf9\xd5\x50\xc2\x20\x8f\x3d\xd8\xee\xc4\x64\xad\xa4\xcb\x99\x45\x2c\x6a\xc4\x3c\x63\x73\x4b\x94\x3d\xae\x54\x36\xbc\xe1\xab\xbc\xd5\xca\xde\xe3\xf7\x18\xc4\x7c\x8d\xf6\x4e\x7e\x54\xf0\xdb\x67\x98\x79\x78\x64\x72\xfe\xe7\x9b\x15\x41\xaf\x8f\x5e\x84\x4b\x7f\xb9\xd9\x73\x77\x33\x42\xc0\x05\x0e\x8e\x3d\x66\x7d\x0c\x8d\xc7\x06\xcb\xe0\x4d\x66\xfc\xb0\x38\x35\x79\x63\xf9\xbe\x7d\xd8\xd6\xcc\x3b\xa0\xdc\x53\x8f\x39\x10\xfc\xe3\x9f\x4f\xfe\x15\x00\x00\xff\xff\xfd\x93\x0e\xb4\x2a\x39\x00\x00") func operatorsCoreosCom_catalogsourcesYamlBytes() ([]byte, error) { return bindataRead( @@ -105,7 +105,7 @@ func operatorsCoreosCom_catalogsourcesYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_clusterserviceversionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xfd\x7b\x73\xe4\xb6\x95\x30\x8c\xff\x9f\x4f\x81\x92\xbd\x8f\xa4\x75\x77\x6b\x26\xc9\xe6\xb7\x3b\xbf\xbc\xeb\xd2\x4a\xb2\xa3\xd7\x33\x1a\x95\x24\xdb\x4f\xca\xf1\x3a\x68\xf2\x74\x37\x56\x24\xc0\x00\x60\x4b\x9d\xc7\xcf\x77\x7f\x0b\x07\x00\x09\xf6\x45\xea\x26\x39\xa3\x8b\x81\x54\xc5\xa3\x26\x09\x82\x07\x07\xe7\x7e\xa1\x05\xfb\x01\xa4\x62\x82\xbf\x23\xb4\x60\x70\xaf\x81\x9b\xbf\xd4\xe8\xf6\xdf\xd5\x88\x89\xa3\xf9\xdb\xdf\xdd\x32\x9e\xbe\x23\x27\xa5\xd2\x22\xbf\x02\x25\x4a\x99\xc0\x29\x4c\x18\x67\x9a\x09\xfe\xbb\x1c\x34\x4d\xa9\xa6\xef\x7e\x47\x08\xe5\x5c\x68\x6a\x7e\x56\xe6\x4f\x42\x12\xc1\xb5\x14\x59\x06\x72\x38\x05\x3e\xba\x2d\xc7\x30\x2e\x59\x96\x82\xc4\xc9\xfd\xab\xe7\x6f\x46\x7f\x1a\xfd\xfe\x77\x84\x24\x12\xf0\xf1\x1b\x96\x83\xd2\x34\x2f\xde\x11\x5e\x66\xd9\xef\x08\xe1\x34\x87\x77\x24\xc9\x4a\xa5\x41\x2a\x90\x73\x96\x80\x7b\x5e\x8d\x44\x01\x92\x6a\x21\xd5\x28\x11\x12\x84\xf9\x4f\xfe\x3b\x55\x40\x62\x56\x31\x95\xa2\x2c\xde\x91\xb5\xf7\xd8\x79\xfd\x62\xa9\x86\xa9\x90\xcc\xff\x4d\xc8\x90\x88\x2c\xc7\x7f\x3b\x20\xd8\xd7\x5f\xdb\xd7\x3b\xc8\xe1\xf5\x8c\x29\xfd\xdd\xe6\x7b\xde\x33\xa5\xf1\xbe\x22\x2b\x25\xcd\x36\x7d\x08\xde\xa2\x66\x42\xea\x8b\x7a\x59\x66\x19\x89\x9a\x87\xff\x76\x37\x32\x3e\x2d\x33\x2a\x37\xcc\xf6\x3b\x42\x54\x22\x0a\x78\x47\x70\xb2\x82\x26\x90\xfe\x8e\x10\xff\x2e\x3b\xf9\x90\xd0\x34\xc5\x8d\xa4\xd9\xa5\x64\x5c\x83\x3c\x11\x59\x99\xf3\xea\xe5\xe6\x9e\x14\x54\x22\x59\xa1\x71\xb3\x6e\x66\x80\x50\x23\x62\x42\xf4\x0c\xc8\xc9\xf5\x0f\xd5\xad\x84\xfc\x8f\x12\xfc\x92\xea\xd9\x3b\x32\x32\x1b\x30\x4a\x99\x2a\x32\xba\x30\x4b\x08\xee\xb2\xbb\x79\x6a\xaf\x05\xbf\xeb\x85\x59\xaf\xd2\x92\xf1\xe9\x43\xef\x77\x1f\xb1\xdd\x12\xe6\xc1\x3e\x85\xaf\xff\x61\xe5\xf7\x6d\x5f\xef\x3f\x9f\x9a\x37\x13\x3d\xa3\x9a\xe8\x19\x53\x44\x70\x20\x12\x8a\x8c\x26\xa0\x1e\x58\xd0\x9a\x5b\xec\x8a\xae\x56\x2f\x6c\x58\x52\x38\xa5\xa6\xba\x54\xa3\x62\x46\xd5\x2a\x88\x2f\x97\x7e\x5d\x33\x9d\xbd\x71\xfe\x96\x66\xc5\x8c\xbe\x75\x3f\xaa\x64\x06\x39\xad\x71\x40\x14\xc0\x8f\x2f\xcf\x7f\xf8\xc3\xf5\xd2\x05\xd2\x84\xce\x5a\xec\x27\x4c\x19\x50\x21\x05\x21\x9e\x84\xe0\xde\x2d\x0a\x20\x7f\x5f\xfb\xcc\x75\x01\xc9\xdf\x47\x2b\x2b\x17\xe3\xff\x81\x44\x07\x3f\x4b\xf8\x47\xc9\x24\xa4\xe1\x8a\x0c\x80\x3c\x59\x5a\xfa\xd9\xc0\x3f\xf8\xa9\x90\x86\x2c\xe8\xe0\xc8\xdb\x11\xd0\xc5\xc6\xef\x4b\x5f\xbb\x6f\x40\xe2\xbe\x31\x35\x24\x11\x14\xe2\xa3\xc3\x38\x48\x1d\x1c\x2d\x9e\x32\x65\x90\x43\x82\x02\x6e\x89\x24\xa2\x10\x77\xdf\x34\x22\x06\x00\x20\x95\x21\x00\x65\x96\x1a\xda\x39\x07\xa9\x89\x84\x44\x4c\x39\xfb\x67\x35\x9b\x22\x5a\xe0\x6b\x32\xaa\x41\x69\x82\xa7\x96\xd3\x8c\xcc\x69\x56\xc2\x80\x50\x9e\x92\x9c\x2e\x88\x04\x33\x2f\x29\x79\x30\x03\xde\xa2\x46\xe4\x83\x90\x40\x18\x9f\x88\x77\x64\xa6\x75\xa1\xde\x1d\x1d\x4d\x99\xf6\x54\x3f\x11\x79\x5e\x72\xa6\x17\x47\x48\xc0\xd9\xb8\x34\x84\xf3\x28\x85\x39\x64\x47\x8a\x4d\x87\x54\x26\x33\xa6\x21\xd1\xa5\x84\x23\x5a\xb0\x21\x2e\x96\x23\xe5\x1f\xe5\xe9\x17\xd2\x6d\xb2\xda\x5f\x02\xdf\x5a\x74\x26\x9e\xc0\x3e\x08\x6b\x43\x5e\x2d\x26\xd9\xc7\xed\xb7\xd4\x20\x35\x3f\x19\xa8\x5c\x9d\x5d\xdf\x10\xbf\x00\x77\x2e\x11\xc2\xf5\xad\xaa\x06\xb6\x01\x14\xe3\x13\x90\xf6\xce\x89\x14\x39\xce\x02\x3c\x2d\x04\xe3\x1a\xff\x48\x32\x06\x5c\x13\x55\x8e\x73\xa6\x15\xe2\x1c\x28\x6d\xf6\x61\x44\x4e\x90\xe9\x91\x31\x90\xb2\x48\xa9\x86\x74\x44\xce\x39\x39\xa1\x39\x64\x27\x54\xc1\x27\x07\xb5\x81\xa8\x1a\x1a\xf0\x6d\x0f\xec\x90\x67\xaf\x3e\xb0\x72\xc6\x08\xf1\xbc\x74\xe3\xee\x6c\x3c\xc3\x24\x85\x24\xa3\xd2\x0a\x05\x44\x43\x96\x91\x8f\xef\x3f\x90\x99\xb8\x33\x58\xcc\xb8\xd2\x34\xcb\xf0\x14\x38\xfe\x6c\xc9\x69\x42\x39\xc9\x29\xa7\x53\x20\xb4\x28\x14\x99\x08\x49\x28\x99\xb2\x39\x70\x7f\xba\x46\xdb\x2e\x7e\x13\x91\x20\x96\xb8\xaf\x65\x50\xfe\xaa\x5b\xe0\xd2\x95\x4d\x64\xc3\x8c\x15\x19\xe8\x01\xa8\x1d\xd7\xf7\x22\x66\x73\x52\x72\xa5\x65\x89\x9b\x9d\x92\x5b\x58\x38\x24\xcf\x69\x41\x94\x16\xe6\xc7\x3b\xa6\x67\x84\x86\x08\x4e\x35\x62\xf1\x18\x88\x02\x4d\xc6\x0b\x62\xc4\x38\x24\x08\x5a\x88\x0c\xa9\x05\x3e\x8b\x84\x41\x82\x96\x0c\xe6\x40\xa8\x1c\x33\x2d\xa9\x5c\x54\xd8\xb0\x0c\xd0\x47\x80\x8a\x1f\x1b\x08\x0f\x9b\x41\x42\x1e\xc2\x45\x62\xc9\xad\x93\x5d\xd2\x4a\xb0\xdc\x02\x7a\x97\xe7\x0e\xdf\x6a\x71\x54\x39\x7c\x03\x45\x0c\x5e\x39\xf9\xa0\x92\x6b\xf1\x4d\x0e\xb1\x52\x22\x64\x85\x19\x06\x6c\x21\x12\x8e\xc1\x90\x13\x49\xb9\xb9\xb0\x16\xb9\x5b\x40\xeb\x21\xb4\x31\x43\xdc\xf1\x75\x38\x1a\xce\x4d\xa5\x6c\x08\x4c\xe1\x60\x1a\xf2\x0d\x33\x3f\x08\xbb\xea\x67\xb3\xc0\x39\x4b\xc1\x00\x51\x53\x66\x51\xc7\x9c\x56\x3a\x16\xa5\xb6\xb0\x73\xb7\xa4\x64\xce\x28\xa1\xd3\xa9\x84\x29\x22\xf0\xc6\xd7\x3e\x02\x13\x3b\x36\x1f\xd0\x7a\x0c\xad\x24\xff\xe0\x1d\x86\x0c\x3e\x78\x03\x5f\x77\xcc\xc3\x1b\x56\x85\xc5\xe6\x78\x6c\x0f\xed\xa0\x89\x81\x89\x07\xad\x90\x0f\xde\xbc\xcd\xde\xda\xf1\xc8\x0e\xdb\xd1\xdc\xe7\xa5\x85\xb8\xab\x63\x73\x3e\x6a\xd2\x6c\xc8\x01\xde\x58\x13\xdf\x31\x90\x02\xe4\x44\xc8\xdc\x1c\x14\x4e\x28\x49\xac\xfc\x56\x11\x1e\x24\x8d\x3c\x79\x08\x9c\x64\xdb\xfd\xb7\x63\x1b\x2c\xb0\x63\x48\x0a\xaa\x67\x8f\xdc\xb6\xdd\x56\xd9\x11\x02\xed\xd1\x9b\x1f\xa1\x66\x2b\x73\xd7\x1c\xa6\xf7\xb9\x0d\x18\x7a\x9f\x14\x79\xce\x36\xb3\x36\x50\xed\x8a\xde\x7d\x00\xa5\x0c\xcb\x46\x29\x4d\xd2\x3b\x02\x3c\x11\x86\x58\xfc\xbf\xd7\x1f\x2f\xec\xb4\x23\x72\xae\x09\xcb\x8b\x0c\x72\x23\x88\x91\x0f\x54\xaa\x19\xcd\x40\x22\x77\xfa\x9e\xe7\x8d\xbf\x1d\x26\x96\x0a\x52\x43\x8b\x52\xc8\xe8\xc2\x4e\x96\x42\x22\x52\x43\xa3\x85\x24\x85\x11\x70\xf3\xa2\xd4\x40\xa8\xbd\x8a\xef\x65\x7c\xba\x8e\x48\x77\x02\x0d\x31\x92\x48\x4e\xf5\x3b\x32\x5e\xe8\xc7\x50\x9f\x90\xfb\x61\xba\x2d\x0d\x08\x17\xf3\x38\x25\xb0\x63\x2b\x7a\x10\x4e\xfc\xe8\x57\x1a\x21\x94\x32\x0e\xf2\x52\x48\xbd\x0d\xd1\x32\xca\xc7\x14\xe4\x83\x77\x7a\x90\x31\xae\xff\xf0\xfb\x07\xee\x4c\xa1\xc8\xc4\xc2\xe0\xc5\xe3\x67\x65\xcb\xef\xd9\xfa\x5c\x6f\x3b\xdf\xb6\x67\x79\xcb\xf9\xac\x71\xaa\x8f\x99\xd6\x29\x50\xad\x26\xe2\x7d\x7d\x5b\xa5\x04\x3e\x19\xf3\xbb\x3c\xf7\xd6\x86\x2b\x98\x80\x04\x9e\x38\xda\xf4\x5d\x39\x06\xc9\x41\x83\x0a\x04\xe9\x45\xe1\x28\x8d\x91\x05\x97\xd9\xdd\xd3\x70\xb9\x47\xe4\x19\x7f\xdb\x23\x52\x8d\xbf\xed\x31\xd9\xc6\x8e\x5d\xd8\xe6\xe3\x48\x67\xc7\x4e\x34\xf6\x71\x04\x6c\x31\xe9\x7c\xbd\x39\xa7\xc3\xbc\x46\x27\x7e\x06\x12\xde\x75\x63\x19\x0d\xf9\x6e\xc2\x20\x4b\x09\x33\xc2\x9b\x59\x2c\x19\x67\x22\xb9\x75\x76\xcb\xab\x53\xa2\x84\x15\xf7\x8c\x84\x6f\x18\x6d\x22\xb8\x2a\x73\x20\xec\x31\x0c\x8e\x22\x5d\x14\xe9\xa2\x48\xf7\x52\x44\x3a\xeb\x1f\x78\x0e\x94\x6a\x69\x21\x1b\x69\x15\xde\x17\xa9\xd5\x43\x23\x52\x2b\x1c\x91\x5a\x3d\x32\x5e\x1c\xb5\xda\x4a\x4e\x7b\x74\xae\xc7\x0e\x72\x34\xa6\x46\x63\x6a\x34\xa6\xba\x11\x79\x99\x1b\x91\x97\x45\x5e\x16\x8d\xa9\x0f\x4d\x19\x8d\xa9\x3b\x4e\x14\x8d\xa9\xd1\x98\x1a\x8d\xa9\xd1\x98\xfa\xd8\xc7\x44\x91\x2e\x8a\x74\x51\xa4\xdb\x76\x31\xd1\x98\x1a\x8d\xa9\x0f\x8d\x48\xad\x82\x11\xa9\xd5\x03\xe3\x75\x53\xab\xee\xc6\xd4\x24\x03\xca\xd7\x2b\x55\x4b\xf1\xdf\x78\x1f\x8a\x46\x6c\xc2\x5c\x1e\x84\x7b\x9a\x8c\x61\x46\xe7\x4c\x94\x92\xdc\xcd\x80\xfb\x94\x1d\x32\x05\xad\x0c\x16\x80\x86\x75\x82\xf9\x23\xb4\xe6\x61\xfa\x32\x24\xc0\xe9\x38\x5b\x3b\xf1\x63\xa4\xc4\x3d\xf9\xb0\xf1\x78\x2c\x84\xf9\xba\x55\x88\xa1\xaa\xe3\x35\x9d\x5d\xe2\x99\xf7\x36\xe5\xd8\xad\x0f\x6a\x3e\xb9\x3a\xed\x2b\x94\x99\xfc\x8d\x93\xf3\x6a\x56\x82\x96\x69\x4c\x94\x30\x3c\xc4\xfc\xfa\xf1\x8e\x43\x8a\x49\x6e\x03\xc2\xb4\xb9\xc1\x1c\x7a\x96\x30\x9d\x2d\xaa\x17\x8f\xf6\x76\xdf\xc4\x67\x14\x12\x7d\x72\x75\xba\xbd\xf9\xde\x6f\xc0\xe7\xb0\xd4\x47\x3b\x7c\xb4\xc3\x57\x23\x8a\x41\x2d\x27\x8d\x62\xd0\x03\xe3\x75\x8b\x41\xcf\xdd\x6e\x1d\xad\xcd\x24\x5a\x9b\x1f\xbe\x2d\x5a\x9b\xa3\xb5\x39\xda\x6f\x36\x8c\x28\xb8\xe0\x88\x82\xcb\x23\xe3\xc5\x09\x2e\xd1\xda\x1c\xa9\x55\xa4\x56\x91\x5a\xbd\x0c\x6a\xf5\x12\x43\x77\xa3\xd1\x2f\x1a\xfd\xa2\xd1\x2f\x72\xa3\xc8\x8d\x1e\x19\x2f\x8e\x1b\x45\xa3\xdf\xae\x13\x45\xa3\xdf\xda\x11\x8d\x7e\x8f\x8c\x68\xf4\x8b\x46\xbf\x0d\x23\x0a\x2e\x2d\x27\x8d\x82\xcb\x03\xe3\x75\x0b\x2e\xd1\xe8\x17\xa9\x55\xa4\x56\x91\x5a\xbd\x0c\x6a\xd5\xdd\xe8\xf7\xc8\x49\x7a\xf8\xd9\x87\x4f\xca\x83\xcf\xb2\xe4\xa1\x17\x6e\x82\xe8\x03\x10\x7c\x94\x70\x3d\x46\xae\x86\x64\x4c\x15\xfc\xe9\x8f\x2b\x75\xcb\xc3\x5b\x72\x48\x19\x35\xaf\x5a\x7b\xc7\xe3\x24\xac\x7e\xc5\xe6\x3d\xdb\x62\xef\xab\x65\xb4\x9c\xc5\x15\x56\x7e\x34\x28\xd6\x6c\x6d\x7a\x6e\x6f\xbe\xd6\x92\x6a\x98\x2e\x82\x42\xde\x68\x93\xad\x39\x0f\xdf\x50\x80\xbe\x52\x1a\xef\x66\x20\x01\x1f\xf2\xa5\xa7\x95\x9f\x94\xa9\x2a\x7a\x39\x6d\x51\xdc\xf7\xb1\x70\x64\xff\x9e\x35\x97\x1f\xdb\xb4\x75\xd5\xb7\xd7\x02\xcb\x03\xe8\xd4\x5a\xaf\x4f\xab\x14\xe0\x65\x88\x15\x54\x1a\x0a\xe9\xad\xdc\xc8\xb4\x83\xbb\x97\xe0\xbd\x89\x28\x6e\xc1\xa9\x1f\xe7\xd0\xc3\x20\x53\x79\x93\x65\x7d\x1b\xc6\xec\x7a\x60\x5c\x82\xcc\x99\x52\x9b\x02\xae\x9b\x4b\x7f\x8c\x6c\x6e\x41\x2e\x37\xc0\xdf\x7f\x51\xb0\x9c\x4a\x7c\xc2\x1d\x90\x63\x9a\x10\x59\x66\x46\x98\xe2\x29\x71\xe5\xaf\x09\x4d\x12\x51\x72\x4d\x38\x40\x6a\x2d\x1b\xeb\x70\x75\x0b\x62\xbb\x85\xfc\xb4\xad\xf4\x34\xb4\xeb\x7c\xf4\x2e\xf7\x0d\xc7\xf6\x13\xd6\x16\x54\x0f\xc7\xf6\xd2\x16\xbe\xfe\x71\xae\xb5\x0b\x2b\xdc\x9a\x11\x36\xf6\xf7\x52\x64\x2c\x59\x5c\x95\x19\x90\x99\xc8\x52\x85\x65\xfd\x0d\x77\xaf\x1c\x0e\xa1\x88\x5c\xe0\xdd\xb8\xfa\x01\x19\x97\x9a\xa4\x02\x14\xe1\x42\xfb\xc2\x00\x8d\xc7\xad\x8b\xe9\x6e\x66\x5b\x3b\x98\x87\x08\x2d\x8a\x0c\x53\x29\x84\x11\x5a\xee\x66\x2c\x99\xd9\x7e\x35\x05\x4d\x60\xdd\x6d\xdb\x4b\x2f\x5b\x89\xd7\x64\x27\x11\x9b\x78\x9b\xd5\xf8\x31\x54\x21\x3b\xca\xda\xc4\x96\x88\xff\x56\x8a\xb2\xd8\xf2\xf6\x55\xcb\xa2\x7d\xda\x50\x79\xbd\xd4\xc0\xc6\x5f\x74\x2e\x23\xbb\x37\xf6\xb6\xca\x24\x3a\x22\xe4\x7c\x42\xf2\x32\xd3\xac\xc8\xf0\x11\x5b\x6d\x40\x11\x2a\xa1\xe6\x1b\x03\x42\xf9\xc2\x7b\xa0\x5c\x9b\x08\x48\x09\x9d\x9a\x19\x35\xf6\x87\xf1\x25\xe9\x79\x99\x83\x39\xcd\x69\xfd\x12\x54\xa7\xf8\xa2\x9e\x9d\xdc\xb1\x2c\x33\xf2\x2c\xcd\x32\x71\xb7\x9e\x2d\xad\x1b\xbb\x09\x85\x64\x37\xc1\x90\xec\x2e\x02\x13\xc2\x05\xf7\xa6\xdd\xef\xaf\xde\xb7\xdb\xc4\x8b\xe6\x1c\xae\x17\x08\x68\x03\xd2\x82\x4a\xcd\x68\x46\x4a\x99\x29\xbb\x8f\xd4\x28\x01\xd2\x37\x53\x99\x51\xf4\x0c\x26\xa0\x6c\xd7\x0e\xf2\xaf\x76\xe7\x1c\x60\xed\xf9\x14\x3c\x5b\x10\x6a\x77\x7e\x52\x66\xd9\x80\x4c\x18\xa7\x86\xec\x42\xe1\x33\x61\x8c\xfe\x44\xae\x19\x4f\xc0\x7c\xd3\xb0\x12\x2c\x70\x45\x66\x46\x73\xbe\xab\x43\x9a\x0e\x5c\x5b\x11\xab\x2d\x2b\xf7\x0a\x73\x60\x13\x3a\xce\x00\xfb\x5a\x38\x91\xe5\x4a\x64\x68\xde\x76\x86\xef\xd4\xf6\x22\xa1\xe1\xe5\xff\x62\x1c\x95\x14\x72\x85\x8c\xc3\x28\x3b\xc0\xf4\xcc\xe8\x3e\x45\x91\x2d\x0c\xa1\x30\xb8\x53\x23\xd4\x81\x2a\x93\x99\xf9\xa4\xbd\x42\xa4\x6a\xcf\x90\x91\x3d\x05\x89\x04\xad\xf6\x0e\xcd\x5f\xcb\xdf\x80\xdf\x17\x3e\x77\x44\x0b\xb6\x77\x38\x20\x08\x20\x6c\x74\x22\xf4\xec\xe5\xe2\xa1\xff\xd6\x46\x7f\xad\xc7\x46\x53\x6b\x0d\x67\x70\x5d\x3b\x44\x61\x9b\x60\x18\x1a\xad\x01\xf3\xa4\x0c\x52\x22\x1a\xf8\xf6\x50\xab\xc4\x9a\x90\x63\x4e\x20\x2f\xf4\x02\xb1\x38\x07\xca\xdd\xdd\x30\x07\xb9\xd0\x33\xa3\xad\x32\xf5\xf2\x0f\xff\x96\x8e\xa5\x7a\xac\x05\xb8\x3b\xf0\x1e\xb8\x35\x92\xdb\xce\x4a\xcb\xc0\xdd\xff\xd7\xfd\x50\xea\x35\xe2\x53\x4d\xcd\x5f\x2c\x28\x91\xbd\xb6\x02\xe3\x0f\xe6\xc9\x26\x08\xed\x4f\x96\x5a\x56\xf4\xe3\xfd\x7b\xdb\x45\xc9\xc1\xea\x3b\xc6\x53\x2b\xa2\x1e\x6b\xdb\x9e\x08\xae\xc0\x2c\x38\xb1\x99\x89\xbe\xc6\x51\x6a\x09\xa4\xdb\x89\xb5\xe0\xc7\xb5\xbf\x44\xd0\xaf\x0a\xb6\xdb\x0a\xa3\x8f\x4c\x1f\x68\x3e\xcf\x41\x59\xc1\x7e\x4d\x0d\xf9\xc7\x50\xb0\x81\x75\x46\x19\x14\xc8\xe8\x18\x32\xdb\x8c\xc9\x5c\xad\x97\x4f\x8e\xdf\x7f\xa8\xfa\x96\x49\xa0\x8f\x58\xba\x3e\x81\x8a\xb2\x85\x4b\x75\xa5\xfb\xdb\xea\xd8\x5e\x2a\x45\x50\xec\x66\x26\x26\xd7\xa0\xed\x01\xcc\x69\x61\xce\x9f\x9d\x63\xad\x95\xf3\x3d\x42\xfa\xf1\xc3\xb2\x93\x34\xbf\x7d\xb7\xa6\x75\x2f\xd9\xea\xa8\x6c\xe7\x0b\xde\xe5\xec\x3d\x60\xfb\xa8\x47\x03\xcc\x4b\x08\xed\x24\x7e\x27\xa3\x27\x55\xe7\x3d\x8b\xc1\xca\xa6\x4c\xdb\x04\x75\xe9\x7f\xaf\xa7\xe8\x79\x0b\x76\x51\xa7\x8c\x46\x9d\x41\xa2\xc5\xc3\x05\xe1\xfc\xcd\x1a\xf2\x22\x7b\xec\xe4\x91\x9d\x55\xaf\x9c\xf1\x2b\xa0\xe9\xe2\x1a\x12\xc1\xd3\x2d\x09\x6c\x63\x3f\x3e\x30\xce\xf2\x32\x27\xbc\xcc\xc7\x80\x20\x56\x76\x2e\x24\x24\x56\xad\xa5\x84\xc3\x5d\xb6\x70\xc4\x23\x25\x85\x48\x3d\x3d\x19\x1b\x35\x8c\xa6\x0b\xec\x7c\x86\xa5\x53\xf9\xc2\x4c\xc2\x74\xcd\x7d\x24\x49\x24\x55\x46\x60\x1a\xe0\xa4\x4c\x1b\x5e\x36\x06\xf4\x3a\xb1\x14\xcc\x1e\xd3\x39\x65\x99\x11\xba\x47\xe4\x14\x26\xb4\xcc\xb0\x81\x1f\x79\x43\x0e\xcc\xcb\xbc\xa6\xb5\xee\x01\x23\x08\x2b\x61\x74\x74\xe5\xb2\xdf\x71\x41\x87\x3b\xd8\xd1\xb7\xa9\xec\xe7\xc7\xb6\x15\xfe\xfc\x28\x68\xa9\xb6\x55\xd0\x1b\x1b\x73\xce\x53\x73\x1e\x42\x19\x35\x20\xe9\x4c\xb9\x99\xb7\x63\xd9\x0f\x57\x45\x58\xb3\x6a\x29\xa6\x12\x94\x3a\x05\x9a\x66\x8c\x43\x7b\xfc\xba\x99\x01\xc9\xe9\x3d\xe2\x98\x66\x39\x18\x49\x24\xc4\x30\x1a\x7e\x95\x16\x24\xa7\xb7\x50\xbd\x9e\x8c\x61\x82\x0d\x1a\xf1\x83\x83\xdd\xb7\xf8\x33\xa1\x2c\x83\x74\x84\xef\x08\x66\xa9\xfb\x1a\x5b\xc4\x31\x7f\x33\x5e\x82\x79\xaa\x90\x02\xd5\x4c\xfb\x68\xc8\xe3\x91\x87\x52\x73\xb3\xa5\xc3\xbe\x97\xdf\xe5\x12\x28\xce\xee\x13\x6b\xfe\x93\x40\x15\xde\x66\x71\x53\x95\x72\x62\x94\x4a\xaf\x8b\x06\x0b\x72\x4d\x60\xc9\x85\xd0\xae\x25\x60\xf5\x81\xf8\xb4\x6b\x51\x09\x4a\xb3\x1c\x0f\x58\x5a\x4a\xdf\x30\x13\x61\x46\xd7\x6f\x7d\xe3\xa8\xfc\xe9\xcd\x9b\x2d\xe5\xb7\x4f\x8f\xf4\x12\x50\x87\x6e\x83\x2f\x17\x15\x1d\xf2\xe4\xdf\x28\xc7\x66\x8f\x99\x13\x90\xb1\xf3\x27\x48\xf4\x20\x32\xa5\x19\x9f\x96\x4c\xcd\xc8\x18\xf4\x1d\x00\x27\x70\x6f\x6b\x5f\x90\x7f\x82\x14\xb8\xa9\x06\xbc\xb5\xf3\xa0\x01\xb4\xb7\xcf\x07\x62\x73\xa6\x98\xe0\x7f\x61\x4a\x0b\xb9\x78\xcf\x72\xf6\x48\x51\x52\x3f\x56\xfb\x1f\x57\x10\x14\x59\x8a\x5d\x8b\x59\x42\xaf\xc1\x7e\xb0\x04\xb4\x6d\x6a\x61\x15\x57\x62\xce\xc9\x98\x26\xb7\x9f\x0c\xc0\x6f\x9e\x0b\x84\x3d\xbb\x6e\x01\x55\x94\xf7\xaa\x09\x90\x6c\x59\xa4\x3c\xbb\xb7\xf0\x69\x40\xf9\x6e\x26\x14\xe0\x0d\xd6\xfc\x88\x8f\x79\x77\x01\x53\x15\xc1\x30\xa7\x5b\x70\x50\x84\x4e\x26\xcd\x3b\xea\xc3\x8e\x92\x67\x5e\x2a\x4d\x72\xaa\x93\x99\x35\x72\x89\xb4\x12\x27\xf6\x95\x13\xfb\x77\x81\xf2\xd6\xe6\xe5\xdd\x0d\xc1\xc4\xae\xf3\xec\xde\xe8\x96\x8f\xfa\x79\x9a\xa3\x01\xf2\xe5\x69\x9a\xba\x71\xd6\xdc\x10\x27\xb7\xe5\xb6\x79\xf0\x0d\x9a\x86\xeb\x5f\x70\x17\x8e\x2f\x4e\xb7\x37\xd2\xb4\x51\x70\x77\x56\x71\x97\x8d\xe0\x0f\x7c\x94\x37\xa6\xba\x2b\x4d\x4b\xb8\x6d\x1a\x3d\x20\x94\xdc\xc2\xc2\xf6\x97\x5e\x69\xd8\x2b\x21\x73\x92\x04\x60\xdf\x5a\x73\x93\x6b\x36\xbd\xc3\x7a\x77\xc6\x1e\x3b\x76\x73\x52\xf8\x31\x34\x0b\xdd\xf1\x09\xff\xd1\x3b\x3c\xb6\x3b\x82\xdb\x71\x0b\x8b\xdd\x1e\x58\xda\x6e\xb3\x0b\x4e\xf7\xb1\xfb\x6e\x7e\xa8\x04\xbd\x6a\xab\x77\xf3\x1e\x85\x63\x67\xe3\x95\x1f\x1e\x88\x9d\x3e\xaf\x42\xbf\xd0\xca\x64\xbe\x71\x5f\x59\x64\x34\x67\x7a\xc6\x0a\x64\x44\xde\x4d\xe0\xdb\x9f\xff\x40\x33\x96\x56\x53\xd8\xf3\x7b\xce\x07\x46\x7c\x32\xff\x41\xa2\x6b\xc5\xb5\x53\x01\xea\x42\x68\xfc\xe5\xb3\x01\xc8\x2e\xb3\x13\x78\xec\x14\xce\x3e\x8d\x54\x06\x15\xaf\xa0\x73\xba\x1a\xf9\x9a\x5f\x15\x28\x99\x22\xe7\x9c\x08\xe9\xe1\x80\xbd\xec\xed\x44\x76\x0a\xe4\x13\x63\xeb\xfa\x40\xcb\xf5\xda\x39\x1c\xf8\x84\x6c\x40\xef\x81\xe9\xdc\x54\x28\x1f\xd8\x2b\xb6\x57\x7e\x86\xd2\xae\x13\x55\xa9\x77\x7f\xb3\x84\xe4\x20\xa7\xe8\x8b\x49\xb6\xf6\x45\x34\x37\x65\x37\xba\x6b\xc7\xce\xd4\x37\x7c\xe1\x4e\x58\x80\xac\xc9\x9a\x80\xba\x30\x37\x3b\x43\xc3\xe4\xf4\x7f\x0c\x05\xc7\x3d\xf8\xbf\xa4\xa0\x4c\xaa\x11\x39\x26\x8a\xf1\x69\x06\x8d\x6b\x4e\xc3\x08\xa7\x31\x33\x30\x45\x0c\xa9\x9d\xd3\xcc\xe9\x52\x94\x13\xb0\x36\x2b\x33\xfb\x32\x4b\x1d\x38\x49\xc5\x50\x9e\xca\x05\xb6\x77\x0b\x8b\xbd\xc1\x0a\xd2\xec\x9d\xf3\x3d\xcb\x5b\x56\xd0\xa4\x62\x44\xe8\x3d\xdb\xc3\x6b\x7b\x7d\x72\xe1\x1d\x19\x4e\x5b\x3b\x5a\xf3\xa5\x5b\x63\x84\x8f\xfa\x68\x29\xac\x37\xb4\x44\x17\xeb\xa4\x05\x29\x15\x58\x69\x1d\x4f\x19\x01\x2f\x67\xa2\x54\x89\x8a\x29\x87\x3b\x94\x1e\x9f\x8d\xe0\x67\x34\x09\xc6\xa7\xdf\x17\x29\xd5\x5b\x85\x9b\xda\xd1\x80\xc8\xfe\x95\x9d\x84\x94\x38\x8b\xc1\xad\x09\x9b\x92\x82\x4a\x9a\xab\x11\xb9\x74\x75\x0f\x11\xd3\xd8\x24\xb4\x25\x3a\xd8\xdd\x2c\x0a\x20\xff\x0f\xb9\x0a\xd7\x32\x22\xc3\xe1\x90\xdc\x7c\x3c\xfd\xf8\x8e\xd8\x5f\xac\x94\xad\x05\x99\x08\x54\x82\x44\x29\xcd\xab\xe6\xc0\x51\xf1\x37\xf2\xbd\xe0\xf0\x71\x62\x4e\x08\xd5\x30\x07\x49\xee\xcc\x56\x25\x2c\x85\xca\x7a\x35\xda\xff\xb4\x78\xdc\x4e\x32\xc9\xe9\xfd\x75\x29\xa7\x3b\x6c\x00\x59\xd9\x84\xd0\x64\x53\x2b\x93\x88\x7a\x61\xde\xae\x4a\x66\x90\x96\x19\xa4\x84\x8e\xc5\x1c\x1a\x26\xdb\xe6\x63\xc8\xd2\x4b\xf0\x0f\x1a\x9e\x37\x56\x22\x2b\x75\xa5\xac\x1e\xc0\xfd\x3b\xf2\x6f\xe8\xf4\xa6\xa4\x00\x99\x00\xd7\x74\x0a\xcb\x66\x00\x7b\xdf\xdb\x37\xff\x72\xe8\xf8\x91\x99\xd1\x59\x4f\xde\x18\x8c\xf8\x40\xef\xbf\xe7\xb5\x69\x90\x29\xf2\x66\x44\x8e\x97\x5e\x86\xcf\x65\x49\x99\xa1\xad\x05\x1d\xf9\xc1\x2b\xc7\x0b\x22\x45\x89\xae\x7c\x52\x16\x4d\x6d\xf6\xf7\xff\xf6\x2f\x46\xe9\xa3\x79\x91\xc1\x3b\x5f\x2e\xd5\xaa\xcd\x46\x86\xd1\x82\xfc\xe1\xcd\xbf\x58\xea\x69\xce\x67\xad\x15\xd6\x30\xa3\x06\x60\x65\x41\x58\x6e\x83\x34\x21\x5b\xd4\x75\x57\x65\x13\xfd\x95\xa6\x52\xab\x01\x41\x7f\x7f\x25\x1c\x6a\xa1\x69\xb6\xa4\xe5\xa3\x16\x0e\x77\x16\x48\xa9\x40\x98\x00\x1a\xaa\xc8\xdb\x3f\xbc\xf9\x97\x55\x73\xca\x47\x9e\x00\x3e\x89\x4f\x60\x00\xc6\xd8\x28\xf7\xb7\x2c\xcb\x20\x1d\x3c\xba\xfc\x49\x29\xf5\x0c\xe4\x80\x00\x57\xde\x58\x65\xd6\xb7\xb4\x36\x9c\x5d\x96\x9c\xa3\x8c\x60\xad\xc3\x68\xd1\x0a\x2c\x5c\xee\x63\x0d\x23\xd4\x24\x17\x4a\xaf\x5f\xf2\xf6\xc7\xcd\x0c\xca\x17\x1f\x27\xbb\x8a\x03\xc3\x16\x66\x88\xd5\xa7\x5b\x88\x94\xf7\xc3\xdb\x2a\x87\x72\xc8\xb8\x1e\x0a\x39\xb4\xd3\xbc\x23\x5a\x96\x8f\x7b\x0d\xea\x91\x37\x4e\xc0\x67\x20\x03\x65\x70\xde\x56\x76\xf5\x93\x9c\xfc\xf6\xe7\x39\x15\x77\x7c\x33\xe5\x40\xc2\xe9\x68\x46\xcb\x53\xdf\xb4\xb8\x2d\x1d\x1b\xf3\x76\x73\xf7\xff\x6f\x15\xbb\x77\x20\x07\xee\xec\x56\xa7\xdd\xc8\x55\xe8\xf1\x18\x6c\xf1\xf6\xea\xd8\x5a\xce\x67\x6d\x4e\xe6\x06\xfb\x9a\x35\x94\x6b\xe5\x84\xaf\xa1\x40\x76\x1d\xb5\x43\x46\x63\x44\x81\x39\xe7\x6a\xe3\x41\xcf\x80\x2a\xbd\x0e\x14\xf1\xa0\x3f\x3e\x1e\x0e\xed\x5f\x1e\x4d\xa1\xd3\x48\x48\x08\xf2\xda\xc6\x78\x62\x11\x65\xef\x0a\xac\x87\xcf\x86\xa2\x35\x84\xa8\xbd\xea\x48\x98\xfd\x6b\xca\x57\x9f\x2a\xa0\xc6\x1b\x39\xdb\x88\xd6\xee\xd1\x20\xe4\xd7\x99\x4e\x1d\xf1\xaa\x3c\x8a\xd6\xa5\xf9\x6c\xa4\xe8\x1c\x34\x7d\x38\xfd\x63\x79\x34\x89\xf6\xb5\xa6\x3c\xa5\x32\x75\xab\xdc\xdf\x57\xd5\x94\x23\xf2\x01\x7d\x69\x7c\x22\xde\x91\x99\xd6\x85\x7a\x77\x74\x34\x65\x7a\x74\xfb\xef\x6a\xc4\xc4\x51\x22\xf2\xbc\xe4\x4c\x2f\x8e\xd0\x81\xc6\xc6\xa5\x16\x52\x1d\xa5\x30\x87\xec\x48\xb1\xe9\x90\xca\x64\xc6\x34\x24\xba\x94\x70\x44\x0b\x36\xac\x65\x66\x35\xca\xd3\x2f\xfc\x8b\x3e\xb1\x60\xdc\x38\x43\x68\x5d\x92\x73\x18\x96\xfc\x96\x8b\x3b\x3e\x44\x4d\x56\xed\x74\x9a\xb6\x8b\x62\xf0\x63\x09\xde\xbb\x04\x2e\x14\x22\xfd\xe4\x9b\x60\x3e\x66\x48\x79\x3a\xb4\x4e\xc7\x4f\xbc\x17\x6d\x6c\xbb\xc3\x3a\x30\x60\x9b\x58\x74\x3b\xda\x69\x43\x34\xd1\x6c\x0e\xad\x9c\xd8\x7e\x34\xb6\xfb\xa3\x0f\x25\x4d\x4b\x69\x77\x3c\xf0\x66\x7b\xdf\x4c\x4e\x17\x28\xeb\xe0\xbb\x89\xb0\xac\x9c\x8b\x14\x9c\xe5\x73\x8e\xaa\xfd\xb5\x61\xe6\x37\x46\x14\x76\x3e\x6e\xb4\xfb\x2e\x94\x86\xdc\x12\x27\xfb\x7c\xb6\x20\x5a\x2e\xac\x63\x5c\xde\x1a\xe5\xd3\x79\xae\x8d\xc4\x7f\x8b\xf7\x29\x25\x12\x86\xa2\x4f\x0d\x57\x2f\x77\x79\x1b\x1e\x25\x85\x50\x0c\xdf\xed\x78\xde\x6e\x96\xb9\xf6\xec\x32\x70\xd3\xfd\xe9\x8f\xbb\x6c\xdd\x04\x1b\x2c\xec\x68\x65\x6f\x46\x50\x4c\xc2\xd8\x7f\xb7\x3d\xfb\xca\x2b\xae\x46\x2c\x49\x04\x57\x5a\x52\xb6\x39\xbb\x69\xfd\x68\xe9\x0a\x69\xef\x6f\x20\x88\x41\xc7\xad\x80\x42\x56\x63\xb0\x3c\x53\x44\xb4\xf4\xa0\x0e\x01\x63\x93\x9f\x7c\x2c\xa1\x21\x5c\x2d\x4d\xab\x2d\x60\x44\x3a\xc1\xc9\x3e\x0d\x13\x90\x12\xd2\x53\x94\x3e\xaf\xab\xef\x3a\x9f\x72\x51\xfd\x7c\x76\x0f\x49\xb9\x6d\x8e\xf8\xea\x58\xb1\xe5\x79\x83\x88\x0b\x3b\xb1\x8b\x30\x47\xd7\x5f\x70\xf2\x87\x40\xb0\x3b\x41\x44\x51\xcd\xd4\xc4\x66\x92\x55\x1b\x01\x81\xe3\xb3\x42\xe1\xca\x3d\x8c\x2c\xce\x26\x45\x30\x8d\xe4\x26\x99\x09\xa1\xcc\x29\xc7\xfd\xc4\x79\xe7\x4c\x58\x9f\x1f\xa6\xb5\x48\x92\x1b\x1a\xe3\xd3\x5b\xea\xe9\xad\xa1\xb6\x7e\x8c\x29\xab\x82\x57\x10\xf4\x5e\x2a\x33\x0d\x1a\x1e\xcd\x1f\x53\x94\x9a\x94\x26\xaa\xcc\xcd\xa4\x77\xc0\xa6\x33\xad\x06\x84\x8d\x60\x84\x58\x03\x34\x99\x05\xd3\xe6\x00\xba\xd1\x1f\x25\x44\xb5\xd0\x4a\x7c\x50\xe5\x3b\xb8\x04\x9d\x41\xc5\x63\x96\xf7\x72\x2d\xb8\x06\x04\x74\x32\x3a\x1c\x90\x3a\x85\xdc\xac\x71\xbc\x20\x4c\x83\xa1\xd9\xa8\x8b\x48\x51\x4e\xed\x97\x80\x8f\xe9\xc4\x75\x55\xc9\x20\xe8\x45\x4d\x51\x67\xdc\xb3\x1f\xb7\x67\xf6\x0d\x57\x5e\xe6\x46\x5f\xac\x88\x3a\x9a\xd5\x7d\x4b\x1d\x21\x25\xa8\x42\x58\x6d\x73\xd9\xe0\xfe\xff\xaf\x1e\x3a\x50\x87\x35\x30\x67\x6c\x3a\xf3\xb0\xa4\x8e\x11\x34\xf7\x60\xf7\xb3\x47\x3a\xf9\x52\xec\x68\xe9\x51\xb1\xa3\xe9\xdb\xf6\x99\x14\x35\x56\x05\xfb\xaf\x41\xe6\x15\x14\x11\x45\x90\x64\x38\x3b\xb7\x6f\x65\xe3\x70\x8c\xbc\x21\x07\x88\x64\x4c\xef\x2b\x44\xf8\xa1\x28\x0e\x47\xe4\x98\xf0\xb2\x3a\x73\x0f\xbd\x80\x8b\x6a\x7e\x37\x91\x79\xa9\x12\xf5\x5c\x2d\xbf\xb8\x13\xb9\xb3\xa3\x9d\xa7\x3c\x1c\x43\x07\x01\x78\xbc\x60\xe2\x43\x93\x58\x58\xb7\x9c\xa0\x1b\xe9\xf6\x73\xf8\xaf\x68\x3f\xc7\x4a\x80\x05\x1e\xd7\x3a\x8a\x02\x64\x3e\x08\xa5\xa7\xea\x40\x36\x4f\xb1\x85\x45\x5b\xac\x20\xfd\x60\x06\xe9\x09\xae\xa4\x53\x84\xce\xfa\xb1\x1c\xc6\xe2\xf3\xab\x1a\xd0\x6e\x10\xf9\xf1\x02\xaf\xee\x18\xbc\xb4\x79\x74\xa5\x74\xf5\xe8\x44\xf3\xea\xf1\x20\xe2\x3d\xbf\xc0\x9e\xf5\xa3\x27\xb4\xb5\xa3\x3b\x69\xab\xc7\xee\xa1\x41\x9b\xe6\x69\x11\x30\xb4\x7e\xf4\x75\x36\xed\x68\x11\x5c\xb4\x7e\xac\x88\xa8\x9f\x26\xd6\x68\xfd\x68\x6d\x24\x5d\x3f\xda\xc6\x25\xad\x1f\x4b\x49\x8c\x9f\x28\x48\x69\xd0\x8c\x50\x22\xdf\x6a\x7b\x8e\xdf\x77\xe2\x27\xf5\xe8\x19\xc4\xed\x22\x9b\xd6\x8f\x65\x01\xf0\x85\x44\x39\xad\x99\xea\x5b\x6d\xa6\x79\xbf\xf1\x61\x9b\xbd\xee\xe3\x74\x9c\x42\x31\x70\xa9\x33\xde\xce\x8c\x11\xd5\x85\x04\x2c\x38\x80\x61\x5f\xde\x0e\xf3\x79\x02\xab\xd6\x8f\xfe\x18\xa7\x1d\x3d\xb1\x4f\x3b\x7a\x43\x6e\x14\x78\xbe\xb1\x76\xe1\x27\x94\x75\xac\x65\x3a\xca\x3a\x51\xd6\xd9\x61\x44\x59\x67\xdb\x11\x65\x9d\x4d\x23\xca\x3a\x6b\x46\x94\x75\xa2\xac\xd3\x69\x3c\x3f\x59\xc7\x5a\xaa\x7a\x33\x98\xfd\x68\x0d\xae\xcb\x16\x32\x94\xa6\x7c\x48\x4f\xd3\x54\x66\x78\xff\xb5\x23\xb1\x37\x68\x5e\x73\x91\xea\x92\xf2\x29\x90\xb7\xc3\xb7\x6f\xb6\x4c\x07\x5c\x3f\xba\x04\xed\x84\x63\xd7\xd4\xc1\xe5\xb1\xc9\x23\xf1\xc9\xbc\x4b\xee\xa4\x56\x0e\x8f\x86\x84\xb9\xc1\x41\x54\xd5\xbb\xca\x41\x13\xaa\x1b\x06\x71\x96\x43\xe5\x10\x6d\xa4\x20\xd7\x31\xbd\x82\x3b\x7f\x87\xd9\xd4\x51\xbb\x15\x24\x40\x6d\x1c\xfb\x18\xaa\x55\x88\x1c\x6c\x82\xa9\x3f\xf4\x66\x09\xe0\x61\x45\x0e\x60\x34\x1d\x91\xd4\x26\x6b\x53\xee\x62\xc6\x0e\x07\xa1\x7b\x3c\x37\xc4\x55\xe2\x7f\xcc\xb2\x9d\x7f\x1c\xe6\xc0\x75\x49\xb3\x6c\x41\x60\xce\x12\x5d\x7d\x1f\x06\x04\x32\x6d\x9d\x9d\x5d\x5c\x29\x1d\xc4\xc3\xae\x22\xe1\x70\xe5\x6c\xed\xe6\xaf\xf6\xa3\xbb\xec\xb6\xb2\x8e\xf6\xf4\x66\x49\x2e\xb1\x10\x1a\x6d\x54\xab\xb4\x79\x9b\xf5\x57\xe2\x3f\x11\xc1\x3f\x5e\xb5\x75\x8f\x91\x9e\x78\x42\x67\x3e\xb0\xac\x40\x95\x59\x66\xd0\xdb\x7a\xcc\x56\x41\xb0\xc6\x93\xb5\x26\xdb\xc6\xba\x59\xf3\x20\xeb\x06\xef\xb9\x11\x85\xc8\xc4\x74\x11\xee\xa0\xed\xd5\x12\x94\xb7\xa1\x44\x95\x63\x27\x02\x9a\x43\x74\xb1\xb4\xe5\xd1\x17\xb2\x71\x44\x5f\xc8\xca\x88\xf6\x81\xe5\x11\xed\x03\x3b\x8c\x68\x1f\x58\x33\xa2\x7d\x60\x75\x44\xfb\x40\xb4\x0f\x74\x19\xaf\xdf\x3e\x40\xa2\x2f\x64\xd3\x88\xb2\x4e\x3d\xa2\xac\xb3\xfd\x88\xb2\xce\xea\x88\xb2\x4e\x94\x75\xa2\xac\x13\x65\x9d\xb6\xa3\x03\x72\x17\x22\xed\x3d\x45\xa6\x10\xe9\x03\x19\x32\xd6\x5e\x9d\x88\x61\x26\x92\xaa\xb2\x88\x79\xc4\x79\x3e\x14\xcd\xad\x09\x7d\x40\xfe\x29\x38\xd8\xf4\x04\x5b\xb2\x36\x07\x22\xb0\x3d\x44\x21\xd2\x03\x75\xd8\x22\xf0\x3c\x66\xd8\xc4\x0c\x9b\xdf\x40\x86\xcd\x8c\x2a\x57\xf8\x08\x49\xeb\xe6\x84\x9b\xe0\xf8\xdf\x80\xcc\x7f\xb3\xf9\x36\x06\xe1\x1c\xc2\x60\xf7\xb8\x1a\x29\x2c\xec\x52\xe7\xdb\x85\xf4\xb2\x09\x31\xa7\x97\xd9\xe6\x3b\x69\x0a\x29\x29\x40\x0e\x2d\x92\x09\x32\x61\xae\xfe\xd7\x12\xfe\x3a\x08\xbf\xf0\xbc\x99\x26\x24\x5e\x74\xf2\x4c\xf3\x53\x7a\xf3\x4d\x85\x2e\xba\x06\x57\x7c\x71\xa9\x34\xfd\x68\xa5\x43\xa2\x9d\x3b\xed\xbb\x4e\x7a\x69\x5f\x4a\x24\x2a\x79\xd7\x3b\x95\x39\xde\x3c\xd6\x16\xa7\xfd\x47\x09\x72\x41\xc4\x1c\x64\xad\x18\x55\x7d\x7b\x06\x55\x93\x99\x84\xba\x02\xc8\xfd\x18\x78\x7a\x31\x45\xf4\xa9\xa9\xf7\xed\x35\x24\xcf\xac\xfa\xf1\xe6\xd1\xaf\xe2\xd0\xa3\xda\xf0\xd2\x6a\x29\x6f\x1e\xbd\x9a\xdf\x48\xcf\x26\x38\xd2\xa3\x19\x8e\xf4\x6b\x8a\x23\xbd\x9b\xe3\x48\x9f\x26\x39\xf2\xd9\x2b\x40\x6f\x1e\x3d\x9b\x8f\x48\xef\x56\x3a\xf2\x02\xeb\x49\x6f\x1e\x9f\x00\xdc\x7d\x5a\xec\x48\xac\x4e\xdd\x79\xf4\x6d\x50\x23\x7d\x1b\xd5\x48\xdf\x78\xd8\xaa\x0a\xf6\xe6\x11\xeb\x63\x7f\x02\x39\xad\x37\x21\xa2\x6b\x4d\xed\xc7\x16\xda\x03\x4e\x56\x5d\x7d\x3f\x97\x02\x64\xb9\x74\xdd\x4a\xd6\xbc\x3b\xe8\xd5\x85\xa1\x9a\x61\xcb\x53\x1f\xb7\x8a\x18\x8d\xbf\xa7\xde\xe0\x55\xf2\xa0\x78\x5c\x30\xd9\x4a\xeb\x98\xda\x74\x56\x35\x8f\x31\x4a\x41\xdd\x74\x2a\x78\x18\xef\x1d\xd9\x70\xd2\x5a\x9a\xe0\xe9\x72\x80\x69\xfd\x04\xea\x17\xb6\xd1\xed\x9e\xb7\x63\xef\xab\xfa\x8e\xbd\x51\xd8\x13\xd7\xcd\x78\xf0\x7f\xfe\xef\x61\xa3\x7a\x4b\x3d\xa1\xa3\xca\xd5\xd9\x19\x83\xa6\xc3\x0c\xe6\x90\xe1\x3a\x7c\xc3\xe5\x99\x40\x8b\xb1\x2d\x7b\x1a\x18\xa4\x2e\x96\x77\x94\x4c\x80\xea\x52\x62\x05\x51\xe0\x74\x9c\x75\x3f\x2b\x51\xc1\x8c\x0a\xe6\x76\x23\x2a\x98\x1b\x47\x54\x30\x3b\x8c\xa8\x60\x6e\x37\xa2\x82\xb9\x79\x44\x05\x33\x2a\x98\x2d\x46\x54\x30\xa3\x82\xd9\x76\xfc\x86\x15\xcc\x7e\x03\xa7\x43\x75\xcf\xc5\xa1\xa0\xfc\xa8\xa9\x66\x49\x1d\x54\xed\xef\xb2\xff\xea\x57\xcd\x0c\x55\xc8\xf5\x4a\x66\xa8\x88\xae\x28\xda\xa3\x47\x34\xca\x4a\xe7\x5c\x79\xf2\x41\x65\xf3\xb5\xc5\x86\xf7\x86\x88\x81\xd3\xb9\x57\x4c\xbc\xf1\xa1\x6b\x75\x6b\xf7\x2a\xae\x2d\x25\x07\xde\xdb\x8f\xad\x5a\xb8\xd0\xcd\x8b\x5c\xb3\x61\x7d\x47\xe5\xff\xc7\xb0\x9d\x46\xc5\x80\x86\x93\xba\x8a\x92\xab\x22\xb0\x6a\xe4\x31\xd4\x11\x64\x63\x0d\xd8\x1a\x77\xc2\xb8\x8d\xa5\xf4\x6d\x85\x04\xf7\x61\x59\x96\x9c\x22\x01\xf4\x68\x6e\x25\x5f\x5c\x0f\x8a\xbf\x35\xec\x82\x38\x22\x8a\x67\x8c\x72\x97\x6e\x2b\xb8\xef\x7b\x6f\x7b\xd9\xd7\xe2\x72\xd5\xad\xa5\x7a\xfb\x88\x9c\x21\xd2\x87\x13\x33\x85\xf0\xa1\xb6\xc3\x4a\x3f\x26\x8a\xe7\x55\x1a\xe2\x6e\xe7\xd2\x10\x4b\x31\x29\xb1\x32\x44\xac\x0c\xd1\xa9\x32\x04\x5e\xb4\x87\xbb\xf7\x12\x11\xe4\x47\xd7\x80\x49\x02\x82\x2a\x2f\x33\xcd\x8a\x3a\xc6\x5b\xd9\x57\x65\x56\x91\x98\xb8\x58\xd3\x26\xbe\x9b\xb7\xd1\x64\xb6\x8c\xf7\x38\x1f\xc6\x84\x2b\x24\x27\x2e\x9e\x13\xdb\x25\x61\x4d\x03\xaf\x75\xd8\xa0\x55\xf6\xf2\x63\x11\x4f\x91\x60\xab\x5a\x69\xb6\xdd\xbc\x0c\x9d\xcf\x0c\x4a\x18\x8a\xfd\x00\x83\x08\x5b\x66\x60\x5c\x2c\x9b\x03\xaf\xb9\xc4\x81\x3a\x3c\xf4\xc2\x50\xaf\xdc\xeb\x93\x70\x9f\x3f\x07\x5c\xe2\x3f\xb7\xe1\x3f\xf8\x41\x15\x07\xaa\xc1\x57\xf3\x9f\x97\x1d\x74\xd9\x3d\x7e\xae\x0f\x83\x5c\x6f\x71\x73\x4f\x1e\x33\xf7\x5b\xaa\xae\xf1\x2c\x5d\x18\xcf\x4e\xeb\x78\x1d\x6e\x8b\x98\x92\xba\xfd\x78\x09\x29\xa9\x4f\xe4\x9a\x78\x39\x99\xa9\x2f\xd6\x1d\xf1\x52\x32\x53\xa3\x0b\x62\xa7\xf1\x5a\x13\x46\x9b\xa3\x47\x97\x43\x74\x37\xf4\x2c\x53\xf5\xc2\xfc\x3f\x8d\x9b\xa1\x17\xfc\xeb\x35\x7e\x2d\xc6\xae\xbd\xf2\xd8\xb5\xa8\xe8\x45\x45\xaf\x39\xa2\xa2\xb7\x32\xa2\xa2\xb7\xc3\x88\x8a\xde\xe6\x11\x15\xbd\xd5\x11\x15\xbd\xa8\xe8\x6d\x31\xa2\xa2\x17\x15\xbd\x6d\xc7\x6f\x4c\xd1\xeb\xaf\x68\x7c\x8c\x21\xeb\x3f\x86\xac\x1f\x42\xd8\x03\xf9\xeb\x05\xe9\x7a\x8a\x19\x8b\xf1\x62\xcf\x3b\x5e\xac\x63\xe9\x3c\xae\xd9\xa7\x29\x9f\x17\xee\xf6\xa6\x1a\x7a\x74\x2e\x58\x4a\x8a\x52\xbb\x0a\x62\xb1\x8e\xde\x73\xae\xa3\xd7\xd8\xd1\x58\x4c\x6f\xab\x62\x7a\x9b\x60\x16\x2b\xea\x6d\x18\xcf\x27\x8a\x2d\x56\xd4\xdb\x75\xc4\x8a\x7a\xeb\x47\xac\xa8\xf7\xc0\x88\x15\xf5\x62\x45\xbd\x58\xf0\xa0\xc3\x88\x05\x0f\xd6\x8c\x58\xf0\xa0\xfd\x88\x05\x0f\xb6\x1a\xb1\xe0\x41\x2c\x78\xd0\x1c\xd1\x09\xd5\x6d\xc4\x82\x07\x1d\x47\x74\x4c\xc5\x82\x07\x9d\x26\x8c\x15\xf5\x62\x54\xe2\xee\x23\x2a\x98\x51\xc1\xdc\x6e\x44\x05\x73\xe3\x88\x0a\x66\x87\x11\x15\xcc\xed\x46\x54\x30\x37\x8f\xa8\x60\x46\x05\xb3\xc5\x88\x0a\x66\x54\x30\xdb\x8e\xdf\xb0\x82\x19\x2b\xea\x3d\xf7\x68\x48\xf2\x1c\x53\x9e\x62\x45\xbd\x18\x21\xd9\x6a\xbb\x63\x45\xbd\xc7\xc7\x6f\xbe\xa2\x5e\x23\x5a\xef\xe9\xca\xea\xed\xbe\x8c\x58\x5b\x2f\xd6\xd6\x8b\xb5\xf5\x62\x6d\xbd\x58\x5b\x2f\xd6\xd6\xdb\x7e\x3c\x7f\x67\xc6\xb3\xd3\x3f\x5e\x87\x03\x23\x96\x5c\xd8\x7e\xc4\x92\x0b\x1b\x47\x2c\xb9\x10\x4b\x2e\x44\x67\x44\x9b\x11\x4b\x2e\xec\x38\xa2\xe3\x21\x96\x5c\xd8\x69\xc4\xda\x7a\x31\x8a\x6d\xfb\x11\x15\xbd\xa8\xe8\x35\x47\x54\xf4\x56\x46\x54\xf4\x76\x18\x51\xd1\xdb\x3c\xa2\xa2\xb7\x3a\xa2\xa2\x17\x15\xbd\x2d\x46\x54\xf4\xa2\xa2\xb7\xed\xf8\x8d\x29\x7a\xb1\xb6\xde\x73\x8e\x26\x8b\xb5\xf5\xd6\x8c\x18\x39\xf6\xbc\x23\xc7\x5a\xe2\x0a\x2d\xb5\xc8\x45\xc9\xf5\x35\xc8\x39\x4b\xe0\x38\x49\xcc\x5f\x37\xe2\x16\x76\x8c\x56\x6a\x6a\xa1\x0f\x4c\x4b\x18\x4f\x59\x82\x7a\xe4\xdd\x0c\xb0\x34\x9e\x11\x6f\xf1\x3e\x42\xed\x8d\x44\xe3\x9d\x35\x7a\xe1\x3a\x0d\x4d\xc3\x10\x1e\x9c\x7a\x57\x78\x59\x08\x8d\x85\xc8\x80\xf2\x1d\x9e\x74\xcc\x10\xe4\x8e\xa7\xb9\x01\x90\xf7\x8e\x12\xd7\x93\x91\x31\x64\x82\x4f\x5d\xc4\x90\x3b\x01\x23\x72\x52\xdf\x90\x50\x8e\x87\xa7\x94\x12\xb8\xce\x16\x08\x07\x2c\xd2\x85\x4a\x43\x2e\xe6\x90\x22\xc5\xc6\x40\x25\x2b\x46\x52\x4d\x32\xa0\xe6\x5d\x1c\xea\x97\x99\xc3\x43\xc9\x25\xce\x6f\x27\x1d\x83\x0b\x9e\x6a\x05\xc4\xdd\x69\x63\x2b\x6a\xb8\x64\xd8\x70\x52\x13\xb2\xa5\x04\xd5\xa3\xe0\x0b\xf1\x68\x2e\x44\x49\xee\xa8\x15\x94\x64\xc9\xf1\x30\xe3\xa7\x1b\xd0\xee\xf8\xf2\x0e\x22\x49\x7b\xeb\xc3\x10\xa9\xda\x8e\x8f\x75\xb1\x06\x50\x39\x6d\xc5\xa4\x1a\x5b\xb3\x7f\x2c\xa7\xa5\x95\x08\x1d\x2a\x03\xd7\x72\x81\x11\x7d\x56\xa4\x48\x45\x72\x6b\xd0\x30\xa7\x53\xd8\xdf\x57\xe4\xe4\xc3\xa9\xa1\x7d\xa5\x32\xa4\xda\x95\x09\x74\xb4\xb0\x90\x62\xce\x52\x83\xd9\x3f\x50\xc9\xe8\x38\x33\x32\xe7\x04\x24\x70\x23\x12\x7c\x79\xf0\xc3\xf1\xd5\x2f\x17\xc7\x1f\xce\x0e\x51\xfa\x84\xfb\x82\x72\x73\x24\x4a\x55\xc7\xa1\x3a\x9c\x30\x2f\x02\x3e\x67\x52\x70\xb3\x38\xd4\xd3\x28\x99\xfb\x59\x93\xea\x24\x48\x50\x22\x9b\x43\x6a\x65\xe4\xea\x6d\x9e\xe5\x30\x5e\x94\xda\xeb\x8d\x18\x1d\x69\x4e\x0f\x4f\x66\x94\x4f\xcd\x3a\x4f\x45\x69\xe6\xfb\xf2\x4b\x5c\x91\x84\xb4\x4c\xac\xd4\x44\x3d\xca\x7e\x39\xf0\x6c\xc2\x10\x7a\x65\x6b\x3a\xaa\x84\x16\x7e\xcd\xe1\x67\xa9\x05\xd7\xf4\xfe\x9d\x0d\x0f\xdc\xfb\x32\xb8\xb4\xe7\xeb\x61\x0a\xf3\x0a\xcb\x6c\xec\xaa\x32\x2c\xc5\x98\x91\xbd\xf0\xee\x11\x39\x33\xef\x80\x34\x04\xa0\x8d\xee\x84\x39\x48\xd4\x3a\x1d\xf8\x06\x44\xc2\x94\xca\x34\x03\x85\x71\x8d\x9e\x30\x5b\xcd\xc0\x01\x0c\x2a\x9d\x96\x0b\xbd\x8e\x92\x90\x0f\x02\x63\x1c\x27\xe2\x1d\x99\x69\x5d\xa8\x77\x47\x47\xb7\xe5\x18\x24\x07\x0d\x6a\xc4\xc4\x51\x2a\x12\x75\xa4\xa9\xba\x55\x47\x8c\x9b\x93\x35\x4c\xa9\xa6\xc3\xe0\x48\x1f\x59\xb6\x3d\x4c\x44\x9e\x53\x9e\x0e\xa9\x43\xad\x61\xb5\xad\x47\x5f\x38\x86\x3a\xa4\xd5\x5d\x8c\x0f\xe9\x50\xcd\x20\xcb\xf6\x5b\x20\x73\x37\x81\xaf\x83\xa0\xd7\x49\xc0\x73\xdf\xde\xfd\xf4\x9e\x55\x87\xd5\xc2\x60\x44\x2e\x84\x76\xe1\xb7\x2e\xd2\x1b\x89\x28\xc2\x77\xfd\x79\x3e\xbb\xb8\xb9\xfa\xeb\xe5\xc7\xf3\x8b\x9b\x78\xac\xe3\xb1\x8e\xc7\xba\xc3\xb1\x06\x3e\xef\x7c\xa4\xbd\xb4\x19\x1c\x93\x6a\xbf\x91\x47\x2b\xd0\xfe\x18\x54\x1b\xd0\x59\x36\xb4\xe3\xc9\xa0\xde\x80\xc0\x19\x9f\xff\x40\x9b\xa6\x75\xbe\x16\x1c\xc4\xdd\x60\x45\xe4\x4a\xfa\xee\x12\x7b\xdf\xc1\x8c\xd5\xd5\x6f\xd5\x4a\x7e\xb4\xa3\xbb\x4f\xc9\xbc\xba\xbd\x89\xa1\xb1\x7d\x17\x34\xaf\xeb\x6b\xaf\xd9\xb5\x11\xf9\xe0\x15\x1e\x72\xf2\xcb\xf9\xe9\xd9\xc5\xcd\xf9\x37\xe7\x67\x57\xed\x35\xe8\x1e\x6c\x2d\x68\x4d\xe8\x09\x00\xfb\x2d\xb9\x64\x21\x61\xce\x44\xa9\xb2\x45\x65\xff\x58\x4f\x04\x96\x4f\xbf\x73\xf8\x2e\x2a\x4d\x7c\xed\x63\x91\xd9\xf6\xcb\x6c\x4f\x61\x42\xcb\xcc\xea\x4d\x7b\x7b\xa3\x36\x5c\xce\x8e\xbe\xd0\xf7\x1b\x29\x3a\xd4\x8f\x6e\xa0\xf0\xb5\xad\x3c\x3f\x11\x72\xe3\x31\xde\x77\x61\x07\x0d\xd6\xe3\x84\x47\x6b\x9b\x73\xd2\xa3\xf5\x8e\x75\x84\x4e\x47\xf7\x42\x3f\x4e\xf7\x44\xf0\x09\x9b\x7e\xa0\xc5\x77\xb0\xb8\x82\x49\x37\x03\x71\x13\xde\x68\x77\x74\x3e\x64\xb4\x52\x1a\x76\x66\x5f\xd6\xcd\x3f\xd3\x9b\x77\xa6\xaf\xb0\x8c\xee\x21\x19\xfd\x45\x50\xf4\x12\x3d\xb1\x52\xcd\xdf\x5a\xa0\x9d\x2d\xb9\xaf\xe0\x9a\x5e\x5c\xf6\xdd\xb8\xbc\x1f\x4d\x66\x17\xb2\x7b\x47\x67\xf5\xb6\x6a\x47\x22\x78\x02\x85\x56\x47\x62\x6e\x38\x17\xdc\x1d\xdd\x09\x79\x6b\xf4\x08\xa3\xb8\x0e\x2d\xd6\xaa\x23\xf4\x16\x1c\x7d\x61\xfd\x5f\x37\x1f\x4f\x3f\xbe\x23\xc7\x69\xea\x5a\xb3\x94\x0a\x26\x65\xe6\x9a\x21\x8c\x08\x2d\xd8\x0f\x20\x15\x13\x7c\x40\x6e\x19\x4f\x07\xa4\x64\xe9\xd7\xed\x89\xb3\x1f\x3d\xee\x82\x28\xac\x8f\xb3\xe7\x9d\xb8\x46\xef\xca\xa2\xc1\xbb\x2a\x22\x62\xb8\x16\xd3\x0a\x71\xd3\xdb\x9b\x9d\x90\xd1\x13\x68\x76\x37\xce\x2f\x0f\xdc\xc2\x7e\xe9\xea\x7e\x4d\x58\xad\x6f\xd3\x21\x6a\x21\xd2\x77\x44\x95\x45\x21\xa4\x56\x24\x07\x4d\x8d\xd2\x3b\x32\x18\x36\x68\xfe\x89\x5e\xaa\x01\xf9\x7b\xf5\x23\xba\x9a\xd4\x4f\xfb\xfb\x7f\xfe\xee\xec\xaf\xff\xb9\xbf\xff\xf3\xdf\xc3\xab\xc8\x0a\x6d\xf8\x4f\xf3\x16\x55\x40\x32\xe2\x22\x85\x0b\x7c\x07\xfe\xa9\x1a\x0e\x16\x77\x41\x53\x5d\xaa\xd1\x4c\x28\x7d\x7e\x59\xfd\x59\x88\x74\xf9\x2f\xd5\x41\xe2\x20\xcf\x93\x31\xe0\x16\x5d\x52\x3d\x7b\x26\xec\xa1\xa6\x25\x3d\x1f\x55\x37\x6b\xd8\x02\x28\xa7\xf8\xcf\x6f\x3c\x08\x8c\xf4\x74\x27\x99\xd6\xe8\x74\x73\x69\xe6\x62\x32\x30\xa7\xb6\x16\x3b\xe7\x6f\xf7\x9e\x15\x83\xa9\x76\xb0\x67\x80\x21\x44\x1c\xb4\xec\x41\xae\x18\xec\xaa\x73\xf9\xf8\xf2\x9c\xcc\x2d\x84\x9f\x0d\x70\x7c\xea\xf0\x37\x9f\x94\xc6\x55\x2d\xa3\x1c\xa8\x2a\x0d\xf1\x9d\x8d\x06\xaa\x12\x98\x49\xc6\x72\xe6\x82\x0c\x5d\x7b\x29\x45\x0e\xec\x8f\xa3\xa4\x28\x07\xee\x86\x51\x0e\xb9\x90\x8b\xea\x4f\x28\x66\x90\x1b\x4d\x6b\xa8\xb4\x90\x74\x0a\x83\xea\x71\xfb\x58\xf5\x97\x7d\xb0\xf1\x82\xd5\xa7\xad\x2a\x5c\x3b\x49\x1d\x45\x86\xf4\xf5\xd1\x36\x0f\xfa\x67\x42\xda\x2a\xcc\xb8\xf8\x04\x22\x61\x65\x89\xb3\x02\x67\x05\x45\xd4\x27\xe7\x22\x2b\x73\x50\x83\x4a\x0c\xb2\xd6\x00\x3e\x37\x9a\xa5\x7a\x56\x82\x5a\xca\xe6\x4c\xf5\x11\x3f\xbc\x46\x4e\x63\x2e\x14\x5f\x94\xba\x28\xb5\xab\x65\x13\xb4\xa5\x13\x0a\xed\x16\x55\xc1\x81\x06\xd9\x7f\xdb\xb5\xe0\x16\x21\x05\xd5\x1a\x24\x7f\x47\xfe\xfb\xe0\x6f\x5f\xfd\x3a\x3c\xfc\xfa\xe0\xe0\xa7\x37\xc3\xff\xf8\xf9\xab\x83\xbf\x8d\xf0\x1f\xff\x7a\xf8\xf5\xe1\xaf\xfe\x8f\xaf\x0e\x0f\x0f\x0e\x7e\xfa\xee\xc3\xb7\x37\x97\x67\x3f\xb3\xc3\x5f\x7f\xe2\x65\x7e\x6b\xff\xfa\xf5\xe0\x27\x38\xfb\x79\xcb\x49\x0e\x0f\xbf\xfe\xb2\xf3\xd2\x29\x5f\x7c\xec\x48\x40\xed\x18\xf6\x56\x8a\x68\x79\xc6\x9e\x02\xac\xef\x87\xb5\xd2\x34\x64\x5c\x0f\x85\x1c\xda\xa9\xdf\x11\x2d\xcb\x6e\xc4\xa4\x66\x4a\x7d\x9f\x7f\xdf\x7b\xec\x5d\xcd\x90\x2a\x76\xfd\x6c\x0e\xb8\x82\x44\x82\xfe\x1c\x96\x1c\xfb\x26\x2f\xa7\x2c\x05\x3b\xbe\x36\x3e\xf7\x5b\x30\xee\x54\xc1\x82\xb8\xaf\xb5\x24\x3a\x91\x22\x1f\x91\xc0\xbd\x31\xc7\x4c\x0f\x77\xdf\x2d\x74\xb0\x82\xfa\x11\x8d\x41\xd1\x18\xb4\x61\x3c\x6a\x0c\xba\xb6\x78\xf8\x6c\x2d\x41\xc0\xe7\x6d\x5d\x18\x6b\x3d\xe8\x5e\xd7\xd1\x82\x14\xa2\x28\x33\xaa\x37\x78\xc6\xd6\xb8\xd3\xdd\x51\xaf\x23\x91\xeb\x48\x1a\xcb\xd0\xf2\xf5\x3e\x4c\x72\x9c\x65\x84\x71\x7b\xf0\x71\x02\xef\x30\x93\x60\x55\x1b\x42\xad\x3f\x7b\x6e\x96\x70\xe7\x4a\xd6\x85\xe1\x9e\x8a\x28\x4d\xa5\xc6\xa8\x63\x2c\x69\x67\x59\x89\xf3\x3e\x31\x5e\x17\xb6\xab\x84\xc3\x2a\x09\x64\x6d\x5f\xcf\x8c\x2a\xed\x97\x8d\xab\xd1\xf4\x16\xbd\x8d\x09\xa4\xc0\x13\xc0\x8c\xb4\x12\xea\x6f\x1d\x1b\xbd\x8d\x9c\xf1\xb9\x9d\x83\x92\xb4\xb4\xc1\x20\x96\xfc\xad\x9f\xe3\x75\x05\x20\x18\x44\xbc\xf6\xed\x97\xab\x38\x04\xa4\xfa\x95\x86\x5d\x25\xf6\x55\x56\x56\xf5\x34\x91\x07\xdd\x79\x66\xe5\xd9\xea\x24\x0c\xad\x30\xcb\xda\xfc\xdc\x64\x92\xaf\xc1\x19\xd8\x9d\x7d\xfe\xe6\x58\x67\x4f\x6c\xb3\x1f\x96\xb9\x83\xef\xa4\x4f\x36\xd9\x87\xb3\xa4\x90\x30\x61\xf7\x3d\x9d\xd3\x63\x5e\x5b\x62\x58\x0a\x5c\xb3\x09\xb3\x1d\xfb\x0b\x09\x05\xf0\xb4\x2a\x8a\x8a\x59\xe1\xbc\x09\x9b\x67\x19\xcc\x63\x05\xee\x7e\x49\xd9\xf5\x3a\x61\x3f\xd2\x31\x12\xe9\x58\xeb\xf1\x99\xe8\x98\xc3\xdc\xe7\x43\xc4\x30\xf2\xbc\x7b\xe8\xfb\x69\x10\xc7\x8e\x58\xbc\x33\x96\xd5\x09\x5d\x47\x38\x8b\x5a\xaa\x1e\x54\xd1\x45\x2d\x6c\xe4\x1a\x99\xb1\xa9\x01\xab\xad\x28\x64\x85\x26\x92\x53\x4e\xa7\x36\xab\x5b\x0b\x6f\xa7\x35\x5a\x96\x41\x62\xc9\xd2\x86\x70\x6f\x5f\xc3\x38\x31\x88\x9d\x09\x9a\xe2\x45\x29\xb2\x0c\xa4\x22\x19\xbb\x05\x72\x0a\x45\x26\x16\x2e\x49\x9b\xa7\xe4\x5a\x53\x6d\x50\xfa\x1a\x74\x3b\x9f\x6f\x27\x74\xc5\x15\x5f\x96\x59\x76\x29\x32\x96\xb4\xb2\xa8\x34\xb7\xed\x1c\xf7\xab\x28\xb3\x8c\x14\x38\xe5\x88\x7c\xe4\x48\x31\x8e\xb3\x3b\xba\x50\x03\x72\x01\x73\x90\x03\x72\x3e\xb9\x10\xfa\xd2\x8a\xde\xcd\x68\x3b\x7b\x23\x61\x13\xf2\x0e\x6b\xda\x68\xa2\xe9\x14\x15\x27\xef\x03\x1c\x18\xf8\x87\x13\x58\xe2\x70\xc7\xd4\x5a\x4d\xa5\x33\xe2\x7c\x81\x33\x19\x42\x65\xff\xfe\xec\xdb\x94\xb1\x09\x24\x8b\x24\xeb\x7e\xae\x8e\x13\x8c\x5e\xa8\xf3\xcc\x03\xfc\x76\x65\xda\x5d\x6a\x27\xaa\x80\x8c\x13\x5b\x3f\xdd\x16\x86\xaf\x51\xbd\x5a\x91\x55\x75\x55\xaf\x1a\x62\x6b\xce\xd9\x95\x67\x16\x42\xe9\x6b\xa3\x9e\xf7\x52\x65\x7d\xff\xd2\x4f\x47\xb0\x96\x74\x96\x41\x4a\x58\x9e\x43\x6a\x54\xf8\x6c\x41\xe8\x44\x63\x8a\x6d\xc3\x3c\x90\x48\xb0\x58\xeb\x6a\x97\xcc\x28\x4f\x33\x90\x64\x42\x59\xe6\x8c\x01\x8d\xfb\x35\xc8\x9c\x71\xb4\x09\x58\x77\x2c\xda\x17\xcc\x5f\x49\x22\xa4\xaf\x7b\xcf\xb4\xf2\x97\xea\x83\x89\x4c\x24\x40\x80\x65\xbf\x32\x19\x67\x22\xb9\x55\xa4\xe4\x9a\x65\x76\x31\x42\xdc\x92\x44\xe4\x45\x86\x47\xa7\xc3\xc9\xaa\xfe\x39\xac\x50\x69\x68\x66\x57\x47\x5f\xd4\x97\xf0\x87\xb6\xdc\xbc\x07\x29\xac\x0f\x19\x0c\xee\x21\xe9\x2d\xbd\xdf\xd0\x52\xb3\xcb\xe8\xef\x17\xbc\x12\xc5\x26\xc2\x30\x30\xb3\xd7\x75\x62\x76\x45\x2e\x47\xe4\xec\x1e\x92\xa0\x0a\x05\xf6\x87\x40\x42\x80\x59\xa1\xf4\x16\x5e\x51\xd9\xbb\x0e\xc9\x77\xe1\x68\x80\xfd\xc4\xce\xe9\xab\x66\xb9\x57\x90\x8c\x71\x24\x8b\x2e\x21\x8f\x30\xae\x8c\x40\xd0\x38\x43\xf6\xc4\x3a\x41\x97\xa4\x4c\x62\xcd\x84\x45\x15\x7c\xed\xe7\xc2\x72\x04\x42\x68\x72\xb0\x7f\xb4\x7f\xb8\x62\xb3\xdc\x37\x82\x4b\x06\x96\x44\x5b\x03\x66\x52\x2f\x4a\xb1\xbc\xc8\x16\xb8\x8e\xfd\x74\x40\x98\xf6\xd1\xd9\xb2\xe4\x7e\x55\x2e\x4b\x70\x40\x94\x20\x5a\x52\x5f\x8a\xc5\xfe\x6a\x6e\xd2\xb2\x74\xcc\xe1\x60\xff\xd7\xfd\x01\x01\x9d\x1c\x92\x3b\xc1\xf7\x35\x2e\x7f\x44\x6e\x84\x11\xbf\xeb\x89\x16\xa2\x24\x1c\x6c\x32\x00\xdc\x17\x19\x4b\x98\xce\x16\x48\xe8\x88\x28\xb5\xcd\x38\xa6\xda\x67\x27\x9e\xdd\x33\xed\x62\xdc\x0c\xda\xbe\x41\x68\x5a\x62\x47\xa8\x91\x8e\xe6\x70\x34\x03\x9a\xe9\x99\x0d\x2c\xe1\x82\x0f\xff\x09\x52\x60\xde\x22\x77\x57\x5e\x5d\x89\xc0\x5e\xb4\x0d\x43\x7b\xbf\x85\xfe\x9a\x0a\xfd\xe5\xe6\xe6\xf2\x5b\xd0\x4b\x24\xc3\xbc\xc5\x87\xfb\xa0\x05\x01\xe4\x44\xc8\xfc\x19\xd0\x8e\x7e\x1c\x9c\x43\x52\x08\xf9\x1c\x48\xd8\x4c\xa8\x4e\x7b\x49\x56\xf6\x53\x28\x8d\x4a\x94\x13\xe2\x38\x24\x66\x07\x9b\x71\x27\xbe\xef\xce\xf9\xe5\x88\xfc\x55\x94\xe6\x6b\xc6\x74\x9c\x2d\xaa\xba\x0d\x0a\x34\xd9\x33\x53\xed\x19\xf2\x64\xb0\xe1\x2f\x40\x53\xa3\xd9\x18\xea\x01\xf4\x79\xf4\xd7\x22\xee\x3c\xb8\xb5\xf5\xcb\x07\x4a\xa5\x45\x4e\x66\xee\xb3\x9b\xe9\x9a\xee\x64\x8c\xf0\xf4\xf8\x5c\x28\x09\x85\xa5\x70\xee\x99\x57\x47\xbf\x56\xe8\x86\x85\xbb\xfb\x7d\x8c\x35\xaf\x92\x10\x6c\xae\xc1\x94\x4d\x26\xe2\x16\x58\x06\xd5\xa0\x9d\x7b\x25\x1c\xcf\xb8\x50\x69\xeb\xe4\xcf\xe5\x89\xd0\x11\xd8\x3d\x3e\xac\xd7\x32\xa5\xfd\xc4\x1a\x90\x75\x86\x59\x87\x33\xd6\x68\xd3\x13\x10\x3f\x4d\x9d\xcc\xcf\x01\x80\x7e\x36\x9f\xf4\x09\x81\xa2\x87\x70\xf0\xd5\x60\x70\x2d\x8c\xfa\x8a\xe9\x9a\x96\xb8\x22\x99\x50\x20\xe7\x6d\x13\xc0\xeb\xd1\xdf\xa7\x8b\xf6\x86\x02\x3f\xd6\xe4\x56\x4b\xc2\xcb\x7c\x0c\xb2\xce\x66\x91\x7a\x15\x20\x41\x34\xc3\x85\xbd\xdd\x9b\x80\x9b\xed\x1c\xcd\x93\x7f\xfa\xb7\x7f\xfb\xc3\xbf\x8d\xec\xf4\x55\x64\x03\x27\xe7\xc7\x17\xc7\xbf\x5c\xff\x70\x82\x09\xb5\x5d\xa1\xda\x53\xd8\x66\xdf\x41\x9b\xbd\x86\x6c\x7e\xd2\x80\x4d\x4c\x13\xe9\x4c\x45\x9a\xfe\x02\x9c\xd2\x60\x80\xd1\xdb\x8c\xc6\xe9\x64\xbf\xa0\xb4\x99\x91\x35\x9b\xf6\x57\x73\xd4\x9e\xc5\x19\xd3\x49\x71\x2d\x92\xdb\x1e\xf5\x9a\xfd\x9b\x93\x4b\x3b\x65\x58\x93\x93\x7b\x63\x08\xe3\x73\x91\xcd\x6d\x39\xdf\x9b\x93\x4b\x3c\x79\x23\xfc\x17\x1a\xa2\x50\xa3\x5e\x98\x67\x7d\x22\x83\x73\x4f\x19\xed\xdb\x5a\xd0\x28\x91\x40\x33\xa6\x34\x4b\xf0\xb9\xda\x4c\x6a\x66\xe8\xe2\x97\x8a\x9a\xd2\xba\xd1\xbb\xa6\xb4\xff\xd1\xbb\xed\x76\x56\x9a\xba\x06\x1e\x3e\x63\xbe\xe4\xf8\x91\xcd\xf8\x88\x7c\xe9\x37\xc1\x97\x0a\x09\xd7\x5a\x14\x3d\x79\x42\xec\x64\x1b\xfc\x20\x63\x98\x08\x09\xcb\x8e\x90\xc0\xb1\xe1\x1b\x0c\x73\xcc\xfe\xf3\x26\x28\xd1\x70\x5e\xd8\x90\x4b\x55\x26\x33\x6f\x4d\xe4\xa0\xd4\x11\xba\x3c\xca\xc2\xaa\x98\xe8\x44\x29\x25\x0c\xcc\xd7\x41\x8e\xab\x1b\xd4\x69\x0c\xe6\xf5\xc0\xed\x8f\xa0\x13\x6b\x66\xf5\xfe\x17\x67\x51\xf5\xcb\x5f\x76\x95\x24\x92\xaa\x19\x60\xfd\x10\xb8\x67\x75\x9f\x13\xaa\x04\xb7\xc6\x5e\xf7\x39\xc8\x68\x14\x29\xa8\x52\x75\x05\x67\xf7\x12\xfb\xd0\xa5\x48\xf7\xf7\x55\xe3\x81\xa9\xa4\x09\x90\x02\x24\x13\x29\xc1\x7c\xe2\x54\xdc\x71\x32\x86\x29\xe3\xca\xc3\xcf\x4c\xe4\x01\x6d\xd8\x8d\x2d\xb6\xeb\xab\xc5\x8d\xc8\x55\xa3\x08\x8a\x4b\x4f\x4a\x44\x7d\xa2\xdd\x2a\x96\x9d\x4c\x18\x11\x1a\xb4\x69\xae\x36\xc6\x87\xcd\xea\xc7\x17\xdd\x83\xb7\xc9\x80\xb6\xbe\xb6\x11\x3a\x58\x9c\x9f\x26\xb3\x6e\x8e\xdf\xe8\x9e\xda\x72\x44\xf7\xd4\x6e\x23\xba\xa7\xa2\x7b\x6a\xf3\x78\x76\xe6\xdd\xe8\x9e\x8a\x4a\xd7\xf2\x88\xee\xa9\xe8\x9e\xda\x30\x9e\x1d\xfd\x8a\xee\xa9\x2d\x46\x74\x4f\x6d\x39\xa2\x7b\x2a\xba\xa7\xa2\x7b\x2a\xba\xa7\x7e\x43\x66\x40\x3f\xa2\x7b\x6a\x65\x92\xe8\x9e\x0a\x80\x11\x35\xa5\x35\x23\xba\xa7\xd6\x8c\xe8\x9e\x0a\x46\xe4\x4b\x2d\xf8\x92\x77\xee\x5c\x1a\xbd\xac\x7b\xce\xda\x25\x3a\x0e\x58\xe2\x7c\x44\x61\x2f\xb8\xea\x55\x41\xfb\xb7\xa0\xe6\x87\x4f\xb5\x71\xde\xa0\xda\xc7\xb4\x36\x1f\x6a\x57\x77\x84\x4f\x22\x54\x47\x85\xb0\xff\x57\x3b\x23\x02\x2f\x84\xd5\x4e\xdb\xe7\xa4\x3d\x59\xb6\x55\x17\xd7\xc3\xb3\x76\x3b\x3c\x13\xd7\x4e\x0f\xae\x86\xe8\x66\x78\x75\x6e\x86\xd7\xd3\x43\xd7\x39\xf3\x6f\x66\x12\xd4\x4c\x64\xad\x11\xbd\x81\xe4\x1f\x18\x67\x79\x99\x1b\x9c\x53\x06\x9f\xd9\xbc\x8a\x1a\x50\x15\xba\x5a\x42\x6f\x2d\x85\xe6\x46\x96\x02\x16\x40\xa5\x2c\x33\xdb\x88\x69\x9d\x33\x8a\xa2\xba\x2a\x93\x04\x00\xdb\xab\x85\x5a\xcc\x1f\x46\xd5\x9b\xaa\x76\x1a\x6f\xbb\xd1\x9b\x6e\xbc\xdf\x96\x28\xc5\x59\xfe\xf0\xfb\x56\x73\x74\xf4\xf2\x7c\x7e\x0f\x4f\x0f\x64\xba\xbb\xbe\xd2\x49\x57\xe9\x83\x4b\x74\xd5\x51\x5e\x9a\x27\xa7\x37\x8f\x66\x0f\x1e\x9c\x67\xe4\xbd\x79\x36\x6c\xe1\xb9\x78\x6c\x9e\x61\xf5\xd5\x1e\x1c\x0c\x7d\x78\x68\xfa\xf3\xce\x7c\x82\x22\xa5\x9f\xc6\x2b\xd3\xa3\x36\xdc\x93\x37\xe6\x73\x78\x62\x7a\xf9\xea\xae\x1e\x98\xcf\xe7\x7d\xe9\xe7\x73\x3b\x5a\xb7\x5e\x85\xc7\xa5\x07\xab\x56\x9f\x16\xad\xde\xac\x59\x9f\xcc\xc3\xd2\xdd\xbb\xf2\x0c\x3c\x2b\x9d\x81\xcc\x38\xd3\x8c\x66\xa7\x90\xd1\xc5\x35\x24\x82\xa7\xad\x39\xcc\x52\xd5\xba\xea\xfc\x28\x3b\xad\xd3\xd1\x9a\xf1\xc7\x33\xea\x8a\xf3\x42\xea\x43\xaa\xbd\xf9\xcf\x09\x14\xd8\xd0\xc4\xae\xf2\x59\x1a\xf4\xc8\xb3\x51\x06\x6d\x30\x76\x9f\x9b\xf8\x17\x71\x47\xc4\x44\x03\x27\x07\x8c\xfb\x7d\x3c\x0c\xd4\xc0\x5a\x33\xaf\xd0\xda\x5c\x7d\xfb\xc6\xdf\xfc\xfa\x54\x6e\x34\x2e\x28\xf5\xe9\x2d\x20\xee\x45\x8f\x9b\x40\xdc\x8d\x93\x32\x6b\x9a\x41\xac\x69\xa4\x49\x6f\xde\xd6\xe5\x45\xdf\xe2\xbc\xd5\x69\xa3\x3c\x25\x2e\x71\xe3\xf5\x6d\x5a\x67\xbf\xf1\x6b\xf0\x19\x47\xdb\x0b\xe9\xdb\xf6\xf2\x44\xbe\xe1\x67\x28\x35\xbf\x50\x7f\x70\x94\x9a\x77\x18\x41\xfe\xd7\xb7\x92\x26\x70\xd9\xbb\xc0\xe1\x8f\x13\x49\x4b\xe9\xd2\xf6\x2a\xb9\xa3\x3a\x3c\x1c\x20\xb5\xa7\xa9\x4a\x8a\xc3\x6c\xb4\x49\x99\x65\x0b\x52\x16\x82\x37\x33\x0f\xad\xd3\x6a\x39\x61\xcd\xcc\xb6\xee\x2d\xb5\x94\x5a\x48\xe1\x18\xb0\x2c\x39\x37\xf4\xbc\x6e\x38\x84\x52\xa9\xb2\xb4\x3a\x4c\x8b\x53\x6c\x6a\x96\x6f\x98\x29\x66\xcc\xb1\x1c\xea\x96\x14\xf5\x84\xe6\xe9\x89\x90\x09\x1b\x67\x0b\x32\xa3\x59\xd5\x5d\x82\x92\x5b\x96\x65\x6e\x9a\x11\xb9\x06\x4d\xf4\x8c\xb9\xc6\xe0\x24\x13\x7c\x8a\x8b\xa3\xdc\x77\x35\x83\xc4\x3c\x9b\x64\x40\x79\x59\xd8\xf7\x19\xb6\xbe\x10\xa5\xf4\xef\x73\x65\x2d\xab\x59\x98\x22\x9c\x65\x83\xa0\x77\xd2\x83\x1b\x5b\x37\xa8\x57\xe0\x73\x0a\xef\x98\x82\x41\x38\xa7\xaf\xcc\xab\x82\xce\x19\x85\x14\x73\x96\xda\xee\x17\x1e\x6c\xd8\xa5\xd5\x76\xc7\xa8\xce\x33\x17\x7c\xc8\x61\x4a\x51\xea\x71\xa7\xc8\xee\x99\x9d\xc7\xba\xe2\x78\x8a\xfd\x32\x8c\xba\x20\x8a\x46\x2a\xeb\x9c\xd9\x4e\x9f\x01\xe4\xc8\x01\x17\x44\x20\x7b\x2d\x39\xd3\xb6\x7b\xf4\xac\xd4\x24\x15\x77\xfc\x70\x64\xab\x12\x33\x45\x28\x19\x83\xf6\x9d\x6c\x7d\x67\x45\x26\x41\x11\xe0\x74\x9c\x99\x3d\xc7\x80\x87\x9b\xb5\x00\x22\x13\xa0\xba\x94\x40\xa6\x54\xc3\x5a\xa1\xc9\x7e\xef\xc3\xe0\x65\xaa\xea\xf2\x5e\x72\x05\xad\xfb\x5b\xf7\x2c\x69\xfd\xe9\x8f\xed\x68\x04\xcb\x41\x94\xfa\xb3\xa8\x92\x77\x33\x96\xcc\x42\xc9\x98\xe5\xa0\x88\x28\x97\x74\xec\xb7\xee\xb1\xf5\x3b\x14\xf5\xc9\x75\xa3\xad\x95\x78\x8d\x29\x6d\x39\xe5\xb8\x6e\x2b\x4b\xcd\x01\x3c\xbd\xb8\xfe\xe5\xfd\xf1\x7f\x9d\xbd\x1f\x91\x33\x9a\xcc\xc2\x7c\x74\x4e\x28\x12\x0d\x24\x14\x33\x3a\x07\x42\x49\xc9\xd9\x3f\x4a\x5b\x9d\x9c\x1c\x54\xcf\x1e\xf6\x5a\x0b\xb9\x25\xf7\xc5\xd6\xd7\xbd\xf5\x5a\xb2\x8d\xb4\x6d\x80\x83\x50\x80\xdd\x11\x96\xc5\xa7\x33\x73\xc9\x2a\x1a\x28\x6a\xcd\xc0\x10\x23\x36\x77\x64\xd8\x15\x97\xa6\x69\x15\x72\x61\xf0\xdc\xa0\x85\x61\x55\x74\x8c\xa1\x12\x33\x20\x1c\xb4\x41\xeb\xca\x60\x25\xb8\x6a\x14\x06\x28\x15\xa8\x01\x19\x97\x18\xdc\x51\x48\x96\x53\xc9\xb2\x45\x38\x99\xe1\x55\x17\xc2\xab\x43\x8b\xe5\x25\x9d\x7e\x3c\xbb\x26\x17\x1f\x6f\x48\x21\x6d\xc9\x00\x8c\xce\xc0\xeb\xf8\x59\x63\x30\x4f\xb8\x1e\x9d\x23\x72\xcc\x17\xf6\xa2\x3d\xe0\x4c\x11\xa3\x0b\x01\xb2\x60\x27\x43\xfa\xa2\xf0\x7b\x6f\x46\xf8\xbf\x3d\xf3\x95\xd2\x08\x99\x55\xd0\x49\xb2\x12\x3c\x66\xc5\x50\x36\xce\x02\x68\xba\x6f\x7f\x55\xdd\x96\xaa\xb0\xb9\x4b\x03\xc4\xa0\xdb\x12\xad\xb6\x1a\xc1\x6b\xbb\x6f\x31\x3e\xcd\x42\xac\x6a\x47\xf6\xbb\xea\x96\x5d\x35\xcb\x61\xfd\x05\x97\x6d\x15\xcc\x5e\xba\x3e\xd5\x6b\xe8\xa9\x57\x4a\xcd\xfd\xbc\x3a\xe5\x28\x82\x08\xdb\x5f\x9e\x5f\xfa\x13\xe0\xa4\x9b\x7c\xa9\x67\x22\x3e\x6c\x9d\x1a\x03\xf2\x86\xfc\x99\xdc\x93\x3f\xa3\x7a\xf5\xa7\xae\x9d\x65\xba\x2a\x3e\xdd\xcd\x3b\x56\xab\x3f\xbf\xec\x09\xe2\x3f\x1a\xea\x64\x66\x34\x50\xd5\x82\x8c\x99\x13\xe7\xe1\x5e\x83\x34\x74\xd4\xed\xc4\x93\xf6\xe4\x31\x0b\xfc\x8c\x68\x66\x7d\x17\xe7\x93\xb0\x25\x84\xde\x11\xd1\xcc\xe3\x7f\x11\x4a\x5f\x38\x2a\xd4\x6c\x30\x51\xcf\x96\x53\x9d\xcc\x9a\x64\xcc\x08\x6a\x4a\xd7\x07\x4c\x91\x54\xa0\x25\xcd\xc6\x01\xce\x58\x87\x48\x8c\xe7\x83\xc6\xdd\x9c\xf3\x8d\xfd\x7c\x68\xa7\x96\x0c\x28\xa8\xf9\x38\xc1\x2a\x28\x2f\x53\x88\xd4\xc9\x64\x66\x59\x69\xc0\x33\x1e\x10\xca\x9c\xad\xa6\x32\x59\x23\x2e\x99\xf3\x94\x50\x6e\x03\xb8\x27\x20\xa5\x0d\xdd\x1c\x2f\xd0\x83\xcc\x12\xe8\xbc\x79\x9d\x4e\x52\x21\x85\x16\x89\xe8\xd0\x36\xa8\xe9\x30\x77\xd3\x21\x10\xac\xf1\xd7\xdb\xdc\xbf\x3f\xbd\x1c\x90\x9b\x93\x4b\xec\xa6\x72\x7d\x72\x73\xd9\xd4\x54\xf6\x6e\x4e\x2e\xf7\x9e\x14\x14\xc4\x4b\x56\xef\xcc\x32\x5b\x4c\xd2\x30\x3c\x19\xb1\x6d\x98\xd3\x62\x78\x0b\x8b\x96\x3c\xb5\x0f\xbe\x3e\xac\x76\xb8\x97\x0f\xb2\x60\xce\x69\xb1\xf3\x6c\x12\x68\xca\x3e\x53\x16\x85\x3b\x59\xf5\x3b\xd7\xa7\x53\xe4\x62\x0e\xa9\x15\x87\xfd\x13\xc0\xd3\x42\x30\x23\x2f\xc6\x1c\x8b\xdd\x9f\x8e\x39\x16\x0f\x8d\x98\x63\x11\x73\x2c\x62\x8e\xc5\xc3\x23\xe6\x58\xb8\xf1\xf4\x66\x50\x12\x73\x2c\x5a\x8e\xd7\xe5\xe7\x8f\x39\x16\x3b\x8d\x98\x63\xb1\x3a\x62\x8e\xc5\x86\x11\x73\x2c\x36\x8c\x98\x63\x11\x73\x2c\x62\x8e\x45\x8c\x16\x7b\x74\xae\xe7\x19\x2d\x46\x62\x8e\x85\x1b\x31\xc7\xe2\x55\xc4\xc4\x90\x98\x63\xb1\xd5\x88\x39\x16\x31\xc7\xa2\xcd\x88\x39\x16\x38\xa2\xed\x25\xe6\x58\xf8\x11\x73\x2c\xec\xf8\xed\x48\xcd\x31\xc7\x22\xe6\x58\xc4\x1c\x8b\x98\x63\xf1\xe0\x2a\x62\x8e\xc5\x6b\xd0\x27\x7d\x0f\xbc\xee\x39\x03\xfb\x27\x22\x2f\x4a\x0d\xe4\xca\x4f\x59\x49\x91\x96\x30\x30\x15\x4a\x04\xdd\x43\x78\x12\xc1\x27\x6c\xea\x28\xfb\x91\x6d\x30\x37\xac\xbe\x67\x18\x34\x75\x7b\x81\xf1\x3b\x19\xcb\x59\xbb\x44\x0e\xb2\xb2\x31\xef\x71\xae\xc0\xc9\x63\x4e\x52\x4e\xef\xf1\x88\xd0\x5c\x94\xb6\x29\x5f\xe2\xf6\xaf\x02\xa1\x75\x85\x3d\xbb\x9d\x21\xfd\xa8\x38\x75\x46\xca\x65\x0f\xda\x46\x41\xb5\x06\xc9\xdf\x91\xff\x3e\xf8\xdb\x57\xbf\x0e\x0f\xbf\x3e\x38\xf8\xe9\xcd\xf0\x3f\x7e\xfe\xea\xe0\x6f\x23\xfc\xc7\xbf\x1e\x7e\x7d\xf8\xab\xff\xe3\xab\xc3\xc3\x83\x83\x9f\xbe\xfb\xf0\xed\xcd\xe5\xd9\xcf\xec\xf0\xd7\x9f\x78\x99\xdf\xda\xbf\x7e\x3d\xf8\x09\xce\x7e\xde\x72\x92\xc3\xc3\xaf\xbf\x6c\xbd\xe4\xce\x22\x71\x7f\x02\x71\x4f\xe2\xf0\x27\x11\x86\x9d\x77\xb8\xa7\xb3\x78\xe5\x66\x5b\x3e\x8d\x8e\x61\x3d\x74\x1a\x3d\x35\x45\x31\xaf\x9a\x87\x29\x22\x72\xa6\x8d\x70\x68\xe4\x41\x1a\xc6\x85\x31\xdd\x50\x4a\x1d\x1d\xc0\x80\x4a\xaa\x6d\x8f\xd0\x2a\xa6\x2a\x88\xd3\x16\x5e\xf2\x73\xbd\x57\x2b\x7b\x05\x9e\xe7\x61\x0a\x13\xc6\xc1\xf9\xc1\x22\x6d\x78\x7c\x44\xda\xf0\x1a\x69\x83\x82\xa4\x94\x4c\x2f\x4e\x04\xd7\x70\xdf\xca\xc2\xd2\x24\x0d\xd7\xcd\x09\x89\x3d\x67\x2e\x8b\xd2\x5d\x23\xa2\xb0\x01\x94\x4b\xe9\xac\x55\x08\xae\x2c\x39\x2a\x98\x36\x4b\x06\xb4\xd5\xfe\x50\xef\xc1\x98\xc8\xe5\x97\x78\x7d\xce\xaa\x99\xff\x28\xd9\x9c\x66\x46\xdb\xad\x9f\xb8\x44\x0d\x26\x7c\x68\xdb\x33\xaf\xa9\xba\xad\x0f\x3c\x0c\x8d\x0c\x5d\xad\xf9\xc8\x7f\x12\xfe\x04\xf7\xfa\x25\x4a\x69\x28\x20\x5d\x4a\x36\x67\x19\x4c\xe1\x4c\x25\x34\x43\xba\xd6\x0f\xaf\x38\xde\x30\x3b\x6e\xbc\x14\x99\x22\x77\x33\xc0\xee\xca\xd4\x9b\x00\x30\xc3\x65\x4a\x19\x27\xb9\xd9\xa2\xc2\x3f\xac\xac\x2d\xc1\x90\xff\x82\x4a\xb3\xc1\x95\xcd\x00\x55\xe4\xb1\x10\x99\x0b\x1d\xce\x16\xf5\xfc\x2e\xf6\x9e\x8b\x5f\x38\xdc\xfd\x62\x66\x53\x64\x92\xd1\x69\x65\x2a\x50\xa0\x57\xac\x7d\xf5\xd4\x1b\x3f\x00\xe3\x72\x4b\x20\x34\xbb\xa3\x0b\x55\x1b\x4e\xc2\x3e\xe0\xef\xc8\xdb\x43\x44\x67\xaa\x48\x35\x47\x4a\x7e\x7f\x88\xbe\xc4\x93\xe3\xcb\x5f\xae\xff\x7a\xfd\xcb\xf1\xe9\x87\xf3\x8b\x6e\x9c\xc2\x7c\x3b\x50\xde\x6a\x8e\x84\x16\x74\xcc\x32\xd6\x85\x41\xac\x44\x9b\x84\x93\x22\x0b\x4e\xd3\xa3\x54\x8a\xc2\xc2\xc9\xdb\xa8\x6a\x4e\xd9\xd4\x82\xc3\xcc\x64\xdc\x9e\x49\x73\xc2\xa9\xa4\x5c\xd7\xc6\x9a\x1a\xe4\xb2\xe4\x46\xb1\x7e\xe1\x81\xf9\x34\xed\x2f\x28\xff\x38\x4d\x21\x6d\x40\xef\xd5\x05\x01\x9e\xf8\x8f\x5b\xd4\x39\xda\xe4\xf2\xe3\xf5\xf9\xff\x5e\x42\xc3\x45\xd1\x2d\xe6\xa9\x9f\xbc\x30\x29\x8a\xde\x76\xf7\xca\xe5\x1d\xc5\xfd\x7d\x16\xfb\x5b\xf1\xaa\x7e\x3c\xed\x57\x25\x6f\x96\xf1\xa8\xe7\x27\xb9\x48\x61\x44\x2e\x2b\x2b\x7d\xf3\x6a\x90\xde\x4b\x25\x10\x73\x0b\xd7\x8c\x66\xd9\x22\x14\x90\xb4\xb0\xc9\x34\x8d\xcc\xe4\x90\x0e\x4f\x68\xa6\x3a\x12\xd3\x2e\x9c\xc9\x30\xe1\x0f\x46\x99\xec\x05\x9a\xd5\x6c\x24\x05\x2e\xb4\x93\x4a\xcd\x2a\x31\x59\x5b\x8a\x84\x58\xcd\x35\x08\x8b\x6a\x70\x17\x65\x0d\xfd\x9e\x31\x31\xe5\x61\x75\x59\xcd\x6c\xad\xbc\xa5\x82\x65\xe9\xd6\x31\xa6\x5a\x97\x35\xb3\x4b\xa0\x29\xe6\xa4\x15\x54\xcf\x6c\x54\x43\x4e\xd5\x2d\xa4\xf6\x07\x27\xd7\x54\x66\x7e\x33\x63\xf5\xaa\x1b\xb3\x6e\x6f\xd3\x47\x79\xc6\xc6\x5a\xa0\x2f\xa0\x5d\xd1\x0d\xd2\xc7\x11\x30\xdf\xf4\x91\x67\x8b\x2b\x21\xf4\x37\x55\x2e\x56\x2f\x1b\xf8\xa3\x93\x14\x9b\x66\x58\x14\xa5\x30\x08\x21\x1d\x22\x30\x11\xa5\xc3\x34\xb0\xd3\x7a\xc3\x9e\x18\xa1\x65\xc9\x8f\xd5\xb7\x52\x94\xad\x39\xc0\x8a\xa0\xf5\xed\xf9\x29\x9e\xe3\xd2\x79\xd9\xb8\x96\x0b\xcc\x3a\x5d\x2d\x18\x54\xc9\xb4\xdf\x3b\x3f\x61\x88\x91\xb5\x4b\x87\x7c\xa0\x0b\x42\x33\x25\xbc\x70\xcc\xf8\x5a\x05\xca\x69\x67\xe6\xf2\x58\xe8\xd9\x8a\x5a\x66\xd0\x79\xf5\xb9\x41\xe0\x74\xab\x2b\x18\x31\xbe\xf2\xb8\xa6\xb7\xa0\x48\x21\x21\x81\x14\x78\xd2\x71\xd7\x9e\xda\xd5\x84\x3b\x7f\x21\xb8\x39\x16\xbd\xec\xfd\x79\xe5\x63\x44\x43\x58\x73\xa7\xd1\x5b\xe9\xf4\x0e\x8a\x3e\x4b\x3c\x14\xa5\x02\x69\x1d\xac\xb2\x04\xbb\x11\xdf\x95\x63\xc8\x40\x5b\x65\x08\xeb\x4e\x50\x6d\x15\x69\x96\xd3\x29\x10\xaa\x2b\x44\xd1\x82\x00\x57\x86\xdc\x58\xd3\x9b\x26\xa9\x80\x3a\x81\x92\x2a\xf2\xfd\xf9\x29\x79\x43\x0e\xcc\xbb\x0e\x71\xfb\x27\x94\x65\xe8\xce\xd4\x54\x2e\xaf\x91\x4d\xfc\x14\xb8\x24\xc4\x3d\x22\xa4\x3d\xa2\x03\xc2\x05\x51\x65\x32\xf3\x6b\x32\x1a\x97\x57\xd8\x5c\x3c\x1f\x1a\xf5\x5f\x21\xaa\x76\x26\x30\xdf\x2b\x90\xbd\xd1\x97\xef\x5b\xd0\x97\x50\x84\x30\x38\xd7\x84\x9e\x45\xac\x1c\x34\x4d\xa9\xa6\x8e\xee\xd4\x59\xd7\xaf\x71\x4b\x9f\x9a\xfa\x28\x78\xcf\x78\x79\x6f\x23\x56\xfa\x53\xf2\xaf\xcf\x70\x5a\x92\x78\xa0\xe1\xa6\xd1\xa2\xc8\x98\xcd\x77\x5e\x8a\xa0\x3a\x6f\x6c\xf5\x60\x83\x88\x84\xc7\x9c\x66\x99\x30\xe4\xcd\x70\x76\xca\x53\x91\xaf\xbc\xcc\x08\x50\xd0\x28\x74\x37\x22\xaf\x12\x79\x9e\xdc\x1c\x91\xc1\x1c\x3a\xd4\x74\x59\xae\xcb\x67\x66\x33\xb2\x98\xdf\x50\x9c\x9e\x64\x74\x0c\x99\xe5\x2c\x16\x81\xd4\x2a\x02\x3d\x75\x14\xa2\x14\x59\x7f\x39\x18\x57\x22\x03\x1b\xd6\xe3\x01\x61\xa6\x7f\x11\x70\xc0\x49\xfa\x82\x03\x2a\x32\x0d\x38\xa0\x4a\xf6\x12\xe0\x50\x76\x60\xb4\x64\x19\x0e\x86\x6b\x37\xe1\x80\xac\xf3\xb9\xc3\x41\x41\x92\x88\xbc\xb8\x94\xc2\xa8\x5c\xbd\xb1\x16\x37\x6d\xed\x2b\xb2\x3a\xf9\x9a\x20\x1c\x24\xe5\xcd\x9b\xa9\x0c\x02\xfa\xa8\xb6\x34\xde\x47\xf5\xfd\xaf\xb0\x43\xb2\x21\x3d\xcb\x7c\xc8\xcf\xd2\x70\x2b\x99\x27\xdd\x85\x17\x5e\x4e\xa0\x83\x95\xac\x17\x66\x22\x12\x9a\x61\xc9\xbd\x6e\x18\x43\x96\xb1\x66\x79\xe2\x20\x0a\x13\x5d\x4b\xf8\x9b\xf7\xfb\x63\xf5\x35\xfc\xc5\xd9\xbe\xb8\x48\x21\x70\x41\xda\xf0\xd1\x1b\x1b\xad\x87\xf7\xf9\x00\x50\xc3\xd5\xbd\x37\x30\x6d\x3c\xad\x85\xab\x00\xf3\xa1\x2a\xe4\x67\x16\x08\x3c\x65\x7c\x8a\x16\x9d\x01\x91\x90\xd9\xd0\x51\x77\x86\x6f\xad\xfa\xb5\x8f\x18\xed\x27\xf5\xe8\xec\x5f\x8d\x92\x10\x13\xdc\xcd\x8c\x46\x0e\x2f\xdf\x4c\x2c\xb5\x64\x8a\xec\xbd\xf7\x00\xe8\x50\xf9\xec\x39\x32\x88\x3d\xfb\x85\xd5\x6e\x5a\x1b\xdb\x2d\xe3\xa9\x8b\xb2\x6c\x00\xab\xaa\x51\x6b\xa5\x50\x8c\xdf\x65\x69\x48\x1a\xde\x91\xbf\x71\x52\x01\x8b\x0c\x5b\xa3\xc7\x95\x15\x58\xbd\x79\x69\xf8\xb0\xc9\xaf\x7a\xc9\xf2\x34\xdf\x73\xdc\x7b\xf3\xde\xa1\x51\x7b\x57\xef\xf3\xdf\xb2\xf7\x94\xfb\x7a\xc7\x78\x2a\xee\x54\xdf\x3a\xc4\x8f\x76\x5a\x2f\x50\x27\x06\xad\x35\xe3\x53\x15\xea\x11\x34\xcb\x1a\x66\xd8\x75\x8a\x84\xdf\xe1\xaa\x22\xf1\xaa\x00\xbf\x14\x1d\x1e\x95\x80\x1d\xc6\x34\x57\xf4\x44\x9a\x4f\xd1\x8c\x66\xd7\x45\xfb\xd2\x6c\x64\x19\x0d\xbe\xfd\x70\x7d\xdc\x9c\xda\xd0\xb3\x3b\xac\x78\x6d\x80\x6d\xae\x13\x9a\xe6\x4c\x29\x34\x03\xc1\x78\x26\xc4\x2d\x39\xf0\x61\x1b\x53\xa6\x67\xe5\x78\x94\x88\x3c\x88\xe0\x18\x2a\x36\x55\x47\x0e\x69\x87\x66\xf5\x87\x84\xf1\xac\x8a\x46\x41\x35\x92\x6b\xe5\xcd\x18\xf8\x92\xa4\x5a\x05\xee\xad\xab\xd7\xe9\xbc\xcc\xab\xcb\xb4\x15\x3a\x19\x64\x4f\x5f\x70\x66\x75\x7b\x2e\x3a\xd6\xce\x78\x64\x8b\xf0\xdb\x5d\x6a\x4a\x98\x46\xb5\x16\x8e\x56\x7a\x7b\x72\x20\x39\xe9\x20\x01\xd5\x5f\x55\x9e\xbf\xd4\x73\x92\x14\x6c\xf6\x04\x60\xd4\x09\xdd\x18\xdc\x84\x56\xd9\x7d\x4c\xc2\x73\x8f\xee\x87\x12\x2d\x7a\x7d\x6c\x9a\x87\xd1\x07\xb2\x62\x46\x87\x56\x49\x36\x24\x09\x69\x98\x97\x01\x66\x82\x0b\x17\x9c\x6e\xb8\xa0\xe0\x88\xd2\xa8\x2d\x58\x47\x10\xee\x89\xa3\xb1\xc1\x52\x4f\x6a\xff\x60\xe8\x43\xc2\x24\x1e\x5b\x04\xa0\x5e\xc3\x1d\xd3\x33\x5f\xe1\xbe\xe1\x70\xc2\x95\x48\x50\xe8\x3d\xe0\x04\xa4\x14\xd2\x05\xc2\x78\xab\x2d\xce\x84\xa4\x18\x23\x69\x0c\x92\x50\xf3\xd7\xbe\x0a\x5d\x94\x75\x09\x5c\x8c\x13\x33\xd8\x04\x93\x09\x24\x28\x29\x85\x00\xb6\x64\xf7\xa0\xae\xdc\xe7\xa2\xbb\x0d\x82\xb9\x12\xba\x39\xbb\x37\x6f\x09\x9f\x0a\x9d\xa1\xae\x62\xde\xfa\xcb\x87\x23\x42\xce\x79\x15\x39\x39\x30\xbb\x18\xde\xe9\x43\x7e\xb4\xf9\xc4\xb0\xfe\x32\x7e\x40\x68\x77\x32\xe2\x9d\x2c\x7b\xc0\xf8\x2e\xc6\x60\x12\x1a\x84\x7b\x25\x07\x68\x18\x76\x93\x9a\xad\xf7\x4c\xbc\x8b\xa1\xd8\xdc\xf2\xa9\x8c\xc5\x2f\x83\xd3\x93\xae\x74\xce\xa5\xc4\xf7\x54\x14\xf7\x3a\x98\x2d\x10\xbf\x2b\x77\xd3\xa5\x48\x6d\x49\x8c\x2a\xa5\x1f\x7b\x59\x60\x89\x0e\xf6\x4f\x2f\x60\xd5\x42\x1a\x17\x36\x2a\x3b\xac\x95\xe1\x6a\x82\xa6\xc4\xc8\xca\x99\xd7\xed\xf3\x22\x03\xcc\x9e\x0b\x66\xae\x13\x03\x83\x2a\xba\x83\x6a\x21\x75\x21\x5e\x57\xa1\x63\x40\xfe\x07\x0f\x65\x15\x00\xe8\x8b\x07\x5c\x56\x8f\x5b\x15\x8f\x29\x5f\x52\x1b\x33\xdb\xb4\xf0\xa6\x03\x92\xb2\xc9\x04\x7c\xa0\xa1\x51\xfd\xa8\xa4\xb9\x21\xf1\x8a\x38\x10\x8c\x61\xca\x6c\x24\x5b\x45\xd8\xf6\x55\x9d\x01\x3f\xb0\xc4\x90\x69\x92\xb3\xe9\xcc\x22\x0a\xa1\x98\x19\x49\xbc\x4b\x2d\x13\x34\x25\x88\xdb\x42\x92\x3b\x2a\x73\xc3\x37\x68\x32\x43\xff\x1c\xe5\x24\x2d\x25\x96\x89\xd4\x40\xd3\xc5\x50\x69\xaa\x8d\xa8\x0b\xd2\x69\x84\x7e\xfd\xb1\x94\xf0\x83\x23\x96\x12\xde\x3c\x62\x29\xe1\x58\x4a\x38\x96\x12\x7e\x78\xc4\x52\xc2\x6e\x3c\x7d\xb6\x2f\x89\xa5\x84\x5b\x8e\xd7\x55\xce\x26\x96\x12\xde\x69\xc4\x52\xc2\xab\x23\x96\x12\xde\x30\x62\x29\xe1\x0d\x23\x96\x12\x8e\xa5\x84\x63\x29\xe1\x58\x14\xed\xd1\xb9\x9e\x67\x51\x34\x12\x4b\x09\xbb\x11\x4b\x09\xbf\x8a\xd2\x4f\x24\x96\x12\xde\x6a\xc4\x52\xc2\xb1\x94\x70\x9b\x11\x4b\x09\xe3\x88\xb6\x97\x58\x4a\xd8\x8f\x58\x4a\xd8\x8e\xdf\x8e\xd4\x1c\x4b\x09\xc7\x52\xc2\xb1\x94\x70\x2c\x25\xfc\xe0\x2a\x62\x29\xe1\xd7\xa0\x4f\x2a\x9d\xb2\x56\x95\xcf\xb6\x29\x54\xe1\x22\x43\x82\xd4\xd6\x71\x39\x99\x80\x44\xca\x85\x6f\x5e\x89\x42\xa8\x0a\x5a\x55\xb4\xcc\xc5\x19\x60\x59\x3c\x09\x34\x75\x01\xef\x1b\x1e\x77\xb9\xb4\x58\xa1\xac\x8e\xd4\x3c\xfb\xf8\x4d\x3f\x55\x31\xba\xc5\x28\xe2\x9a\x3f\xf2\xa4\x7b\xac\x5a\x0d\xf0\x75\x09\x18\x0e\xee\x49\x26\x94\x8b\x30\x45\x60\x25\x33\xca\x39\x78\xe5\x91\x69\x34\xca\x8c\x01\x38\x11\x05\x70\x4b\xbf\x29\x51\x8c\x4f\x33\x20\x54\x6b\x9a\xcc\x46\xe6\x4d\xdc\x03\xbb\x8e\x06\x75\xbf\x28\x2d\x81\xe6\x3e\x2e\x36\xa7\xcc\x4e\x45\x68\x22\x85\x52\x24\x2f\x33\xcd\x8a\x6a\x32\xa2\x00\x03\xda\x2d\xa3\xaa\x80\x81\xe1\x25\x75\x08\xe9\xa0\x7e\x9b\x5b\x96\x08\x8b\x02\xa1\xea\x3a\xc0\x3a\xa8\x79\xa1\x17\x55\x1c\x1d\x90\x09\x93\x4a\x93\x24\x63\xc8\xad\xf1\x8d\x36\x77\x10\xe7\x1b\x78\x5e\xcd\xdd\x4a\x95\x5b\x2a\x4f\x51\x6c\x2d\xb4\xb2\x51\x69\xf5\x84\x6e\xaa\x94\x29\x27\xe6\xab\x01\xa1\xbe\xe4\x8d\x05\xb4\x5f\x29\x82\xda\x73\x16\x3b\xbb\xfb\x29\x98\x2e\xa8\x93\x57\x87\xed\xd5\x88\x8e\x21\xc6\x1e\x39\x07\x8d\x68\xea\x5a\xa0\xc0\x70\x97\x95\x63\x80\x1b\xc0\x61\x6e\x70\x00\x12\x30\xfc\x95\x6e\xc0\xfa\xcf\x8e\xf4\x01\x53\xfc\x00\x4a\xd1\x29\x5c\xb6\xf4\x5a\x6c\xd2\xc8\xd0\x71\x51\x6f\x0c\xa2\x42\x66\xd3\xd3\xaa\x5f\xea\x30\xa7\xa6\x18\x44\x72\xbb\xa6\x4a\xf8\xb9\x93\x4c\x6b\xc0\x4d\xc5\xe2\x48\xe8\xf8\x5c\x4e\x40\xdd\x5f\x0a\x96\xfa\xe0\x27\xa9\x1f\x36\x44\x9d\xa7\x36\x74\x69\x0c\x64\x2c\x19\x4c\xc8\x84\x61\x3c\x14\x46\x28\x0d\x6c\xb9\x0f\x6a\x2d\x0a\x4a\x19\x7d\x57\x70\x2f\xcb\xfa\x75\x8d\xc8\x8f\x6e\x61\x5a\x96\x3c\xa1\x41\x11\x40\x4c\xd1\x62\x13\x32\xc5\x08\x27\x27\x2d\xfe\xf1\xcd\x7f\xfc\x89\x8c\x17\x86\xa5\xa1\x64\xa5\x85\xa6\x59\xf5\x91\x19\xf0\xa9\x81\x95\x3d\x9e\xcd\x24\xa3\x0a\x02\x58\xc5\xdc\x2e\xfc\xed\xef\x6f\xc7\x4d\x1e\x7b\x94\xc2\xfc\x28\x80\xdf\x30\x13\xd3\x75\x75\xe1\xdb\x87\x4c\xb6\x54\x89\xd6\xa0\x99\xc8\x58\xb2\xe8\x8c\x68\xbe\xee\x0c\x99\x89\x3b\x2b\xeb\xaf\xc1\x9e\x3a\x06\xb2\x10\x45\x99\x59\x0b\xf6\x37\x55\x7a\x5e\xa9\x60\x35\x07\x67\xed\xb9\x40\x9b\xab\x9b\x62\xb9\x5e\xac\x0d\x6c\xf3\xaf\x14\x2e\xb6\xdb\x59\x05\xab\xf2\x33\xa8\x08\x7d\x43\xb3\x6c\x4c\x93\xdb\x1b\xf1\x5e\x4c\xd5\x47\x7e\x26\xa5\x90\xcd\xb5\x64\xd4\x50\xcb\x59\xc9\x6f\x6d\xe5\xea\x2a\x45\x58\x4c\x8d\x68\x55\x94\xda\x07\x12\xaf\xfb\x60\x9b\x70\xea\x89\xb0\x57\x83\xea\x59\xe0\x9e\xd5\xba\x8e\x4b\x95\xb0\x18\x19\xce\xaf\x42\x64\xfb\xfd\x9b\x3f\xfe\xbb\x45\x5d\x22\x24\xf9\xf7\x37\x18\xfc\xa8\x06\xf6\x10\x23\x6d\x33\x8c\x22\xa7\x59\x66\xd4\x86\x10\x29\x0d\xa0\xd7\x21\xe1\x67\xc7\x41\xdd\x1d\xdd\xb6\x16\xa5\x6e\x6e\xfe\x8a\x72\x14\xd3\x0a\xb2\xc9\xc0\x66\x05\x54\x6a\xcd\x3e\x32\x86\x7d\x47\x7d\x30\x35\xe3\x19\x08\x40\x73\x91\x95\x39\x9c\xc2\x9c\xf5\xd1\xbc\xa2\x31\x9b\x57\xf5\x33\xa6\x30\x01\x63\x9c\x89\xe4\x96\xa4\xee\x62\x10\xc6\xb2\x5c\x42\xb5\x3d\x14\xda\x06\xf4\x74\x08\xe4\xd9\xf8\xfd\x8d\x10\x9e\x9c\x16\x45\x15\xa3\x2f\xe9\x5d\x03\x18\x78\x26\x31\xdf\xb7\x63\x3d\x85\xce\x66\xe6\xae\x46\xe6\xa1\xfb\x22\x43\x37\x5b\x4f\xd1\x3a\x84\xa5\xbb\x8d\xba\x5e\x7d\x7b\xc3\x64\x03\x21\xea\x09\xfd\x69\x28\xf0\xdf\x36\x3c\x7b\x25\x2b\xa9\x4a\x6c\xa9\x10\xc3\x0a\x00\x06\x7d\x90\x24\xb7\x37\xb8\xf6\x60\xdd\xec\x16\xbf\xd4\x80\x0b\xaf\xac\xca\x39\xd5\x4e\x20\xf4\xe6\x6b\x4a\x0a\x90\x8a\x29\xc3\x97\x7f\xc0\x03\x75\x92\x51\x96\x07\x26\xc0\xa7\x01\x82\x3d\xdc\x58\xf9\xb2\x3b\xa5\xbc\x14\xa9\x9b\x10\x49\xa1\xad\xfa\xb9\x46\xac\x6d\x4a\xb5\x3d\x32\xd4\xa7\x26\x95\x3f\xd4\xd0\x6c\x52\x4a\xf3\x4b\x45\x2a\xed\x5d\xaf\x89\x40\xe2\xf7\xbd\x54\xfa\x58\x2d\xbe\x27\x32\x80\x84\xd1\x6d\x6e\x93\x12\x36\x94\x47\x7b\x50\x02\x91\xde\xe9\x81\x23\x62\x5d\xea\xe6\x4c\xb8\x47\xc9\xfe\xbb\xfd\x27\x25\x92\x16\x44\x52\x14\x74\xda\xa9\x87\xc1\x12\xa4\x96\xa7\x0d\x13\xbd\x8d\x1a\x84\xd7\xab\xb2\x43\x78\x17\xa4\x75\x21\x0a\x2c\x33\x62\xbd\xa3\x1e\xc0\x4e\x41\xb0\xf9\x90\x77\x74\x41\xa8\x14\x25\x4f\x9d\x7d\xa9\x32\xf0\x7d\x58\x7a\xf1\x85\xe0\xe0\x0d\xe7\xcb\x79\xe2\x68\xd1\x67\x9c\xbc\x1d\xbd\x7d\xf3\x5a\x38\x15\x7e\xe1\x12\xa7\xba\xa8\x38\x95\xa5\x4f\x4f\xfa\xad\xbe\xda\x71\x4f\xdf\xfb\xc1\x99\x58\xea\x62\xc6\xcc\x17\x6b\xc5\x9f\xee\x24\xd3\x10\xf4\x36\x3a\x40\xc5\xc5\xe8\x87\x41\x56\xf4\x61\x8f\x35\xbc\xfb\x49\x43\x57\xe5\xf8\x13\xd2\x2d\x47\xa0\xf0\xb8\xad\xb3\x70\xa9\x07\x48\x58\x08\xa8\xbd\x3d\x72\x60\xef\xdc\xb7\x99\x81\x87\x4f\x8a\x5a\x0e\x68\x67\xf7\x45\x87\x1a\x73\x0d\xc0\x9d\xdd\x17\x14\x6d\x70\x45\x8f\x10\xfc\x2f\x98\xd1\x39\x60\x46\x24\xcb\xa8\xcc\xd0\xe7\x78\x6d\xd7\x4e\xc6\xa5\x26\xc0\xe7\x4c\x0a\x8e\x01\x3e\x73\x2a\x19\x56\xa5\x90\x80\x99\xd5\x46\x17\xfd\xf2\xe0\x87\xe3\x2b\x0c\x68\x38\x74\x29\xe1\x6e\x95\xa5\xf2\xe5\x23\xc2\x95\x04\xd3\x3d\xba\x7d\x7e\x1d\x06\x86\x48\x73\xfd\xba\xcc\x7b\xf2\x52\x97\xb6\x20\xfe\x7d\x92\x95\x8a\xcd\x9f\x8a\x92\xb8\x54\xd5\x53\xd6\x6a\x9f\x97\xd2\x66\x6b\x40\xad\x64\xc0\xa2\x69\x1d\x59\xcb\x23\x15\x58\xf7\x55\x55\xb3\x2a\xf4\x81\x3b\xd3\x93\xcb\x65\xb7\xb1\x78\xbe\x64\xd9\x8a\x08\x81\x75\x1b\x9e\xd6\x08\x95\x72\x75\x82\x2b\xdc\x0d\xac\xcd\xe8\xe6\x46\x52\xe0\xe9\xc5\x75\x58\x04\xc0\xaa\x4b\x22\x1d\x91\xcb\xfa\xc7\xba\x52\x04\xd6\x2f\xaa\x94\x48\x90\xd3\xba\x26\xee\x14\x38\x48\x14\x12\xcc\x94\x8d\x76\x72\x64\x4c\x95\x75\xf2\x9c\x5e\x5c\x5b\x9b\xed\x6e\x30\x6b\x2d\x66\xb7\x97\x50\x0d\xc7\xb7\x39\x11\x2d\x84\xdb\x66\xb7\x9a\xca\x60\x65\x00\x83\x4a\xa9\x9d\x98\x9c\x5f\x12\x9a\xa6\x12\xdd\x3e\x4e\xf4\x09\x4a\xbd\x55\xbe\x05\xac\xca\x40\x15\x84\x6b\x0a\xc0\x8d\x24\xae\x06\x2c\x39\x2d\x8b\x8c\x59\x37\x42\xf8\x40\x5d\x4d\x02\xdb\xab\xec\x8e\xb4\x5d\xd4\xbc\xd6\x4a\x5e\x07\x2a\x24\xda\x56\x75\x7b\x60\xf7\x24\x28\x91\xcd\xeb\x82\x9a\x4b\xbb\xe6\x4e\x04\x9a\xc4\xab\x5d\xf3\x45\xdc\xb6\xda\x31\xe0\x5a\x9a\xa3\xb9\xbc\x5b\xd8\xbd\x37\x2b\xf1\x34\x55\x13\xb2\x39\xa0\x7f\xdc\xd5\xaf\x73\x65\x94\xea\x12\x9f\xd6\x37\x6c\xab\xac\x02\x95\x9e\xa2\xe1\xaa\x5a\x9e\x44\xf2\x54\x88\xb0\x6c\xec\x38\xbd\xb8\xb6\x94\xd0\x7e\x7c\xd5\x95\x6f\xdd\x2e\xd5\x54\xad\x35\x06\x3e\x59\x95\x8f\x2e\x9a\xc7\x52\x5b\x25\xd7\xa6\xb4\x53\x20\x4b\x07\xf1\xaf\x53\xe6\x5e\x87\xb7\x2b\xa0\x32\x99\xb5\x81\xff\x03\x84\xc0\x4e\x4a\x52\x61\x23\x01\x26\x42\xa2\x4a\x3c\x44\xf2\x9e\x09\x71\x5b\x16\xdb\x50\x74\x37\x8d\xed\x95\xb3\x15\x81\x68\x3c\xf1\x9b\xa2\xe9\x29\x57\x6d\xfc\xbd\x4d\xd9\x07\xb4\x95\x78\x70\xa2\x3a\x1b\x43\x2c\xeb\x4d\x27\x59\xa9\x34\xc8\x6f\x98\x54\x7a\xcf\x17\x5c\x45\x0c\xb6\x36\x91\xfd\xf0\x86\x1f\x99\x9e\xb9\xd2\x69\xfb\x83\xe6\x25\xf3\xb7\x9b\x78\xdf\xe8\xb4\xfb\x17\x82\xc3\xfe\x68\x59\xec\xaa\x48\x79\x45\xd6\x36\xf2\x14\xb7\x74\x05\x99\x8d\x17\xc5\x0b\x01\xae\xdc\xb8\xb2\x71\xe6\x0d\x9e\xfe\x29\xd0\x84\x62\x89\x26\xbc\x7b\x56\x97\x79\xb3\x05\x58\x6c\x9d\x3a\xe1\x04\xbd\x45\x08\xa2\xa0\x26\x8b\x16\x9b\x3f\xbb\x8d\x3c\xb7\x33\x06\xd8\xf2\x7f\xd7\x20\xe7\x2c\x81\xf7\x8c\xdf\xee\x88\x7e\xcd\xe8\x92\xb3\x95\xd9\x1a\x05\x79\xad\x8f\x96\x71\x1b\x7c\x67\x58\x0c\x1d\x8b\x52\xa3\xec\x86\x0e\xc7\x5a\x71\x64\xfc\x7f\xec\x5e\xa0\xbd\xbd\xb0\x15\xb3\xd6\xe9\x88\x6a\x60\x8d\x3e\x5e\x09\x54\x0b\xae\x29\xd6\xf6\x3b\x15\xc9\x2d\x48\x92\x99\x65\x8c\x48\x1d\xf8\xd2\xa8\x26\x27\x4b\xd8\x31\xea\xa2\xad\xa5\x03\x8a\x19\xe4\x20\x69\x56\x17\x55\xec\x00\xea\xf7\x8e\x70\x56\xb3\x86\x31\x29\xb6\xba\x90\x2b\x83\x66\xce\xe1\xd9\xba\xbb\x72\xba\xf0\x95\x26\x19\xc7\x70\x83\x7b\xa6\xd0\xac\x5f\x88\x34\xcc\x62\x2b\x15\xc8\x61\x95\x63\xe8\xf2\x78\x54\x15\x88\x93\xc2\xb8\x9c\x4e\x19\x9f\x3a\xea\x8c\x34\xbd\xae\x35\x56\x6b\x3a\x18\xe9\x9d\x48\xb0\x05\x1f\x51\x7a\xb0\xf1\x65\x2c\xbc\x3f\x17\xa9\xbd\x7d\xbc\xb0\xda\xa0\xdf\xd9\x3a\x40\xfa\x9c\x13\x21\x5d\x9d\x05\x9a\xa6\xb8\xf6\xd5\x2f\x74\x2d\xbd\xc3\xaf\x1a\x54\x71\x1c\x36\xb2\xbb\x7a\x2a\x00\x8b\x2a\xc7\xbe\x47\xf7\x63\x35\x36\x99\xb2\x05\xbe\x82\xf2\x9a\x5e\x35\x58\xae\xad\x79\xb6\xba\xfb\x3e\x3e\xba\xcd\x39\xdf\x9d\xbd\xb4\x62\x2d\x4d\x6e\xcd\xd7\x7c\x85\x0d\x13\x5f\xf2\x8e\x3a\xcc\xa2\xd8\x53\x54\x43\x5e\x08\x49\x25\xb3\xe4\x6e\x19\xcf\x0c\xbf\x58\x83\x60\x73\xdb\xab\x71\x0d\x8e\xad\xc5\x65\xa4\xb6\x5c\x54\x2d\xe4\x0d\x5f\x50\xc9\x0c\xd2\x12\xa3\xd4\xa7\x25\xc5\x56\xb0\x86\x5a\x38\xa3\xfa\xc2\x85\xff\x59\xa4\xab\x02\x0b\xab\x74\x84\x05\x06\xe3\x60\xb5\x3d\xf3\x0b\x62\xab\x0d\x41\xb4\xad\x34\xb1\x2f\x5f\x18\x8d\xb8\x01\x09\x13\x8a\x6d\xfe\xa8\x3f\x54\x70\x9f\x80\x21\x6b\x5a\xd5\x8b\x75\xf1\x29\x58\x4b\xd4\x63\xba\x83\x21\xcc\x59\x82\x6f\xd8\x78\x84\xdd\x17\x58\x60\x8f\x17\x75\x6b\xe3\x0d\x87\xe7\xc6\x7c\x5b\x95\x2c\x84\x4f\xf9\x14\x81\xad\x0e\xc5\x32\x04\x9b\x8a\x90\x7f\x0f\x11\x3c\x71\xd3\x07\xf9\x04\xdc\x1e\xa1\x2a\x33\xc0\x75\x21\xf4\xd1\x25\x0f\x1c\x12\x5b\x77\x76\x47\xf4\xed\xa0\x67\xb4\x77\x22\xb6\x72\xfe\x75\x51\x69\xa8\x9c\x76\x57\xff\xf6\x8f\xe5\xb4\xcc\x6d\x59\x60\xb1\x54\x99\xd5\xf5\xb3\xb4\xec\x14\x2d\x76\x86\x19\x9f\x7c\x38\x0d\x93\x33\xc2\xa8\x73\x9f\xda\x62\x84\xbc\x8e\x96\xdc\x65\x53\xae\x39\x68\xb5\x7d\xb8\xe6\x1a\x4e\x3f\x75\xb6\xca\xea\x6d\x1e\x2d\x19\x2f\x8c\x9c\x81\xd2\x51\x6d\xad\xe4\xc9\x8c\xf2\x29\x1a\xf8\x45\x69\xe6\xfb\xf2\x4b\x5c\x91\x84\xb4\x4c\x5c\x49\x79\x1f\xd9\xfd\xa5\xb7\x6b\xba\x4a\x47\xd8\x57\x4a\x25\xb4\xf0\x6b\x0e\x3f\xcb\x0a\x21\xef\x08\x1b\xc1\x88\xec\x7d\x19\x5c\xda\xb3\x6f\x2f\xa4\x30\xaf\x70\x41\xe1\xb8\xaa\x8c\x69\x3c\xde\x7b\xe1\xdd\x23\x72\x66\xde\x81\xbe\x9e\x0a\x80\x41\xdc\xf2\xb8\x06\xdf\x80\x48\x98\x52\x99\x66\x98\x4b\x38\xa9\xc4\x2d\x9b\x71\xe4\x00\x86\xa4\x17\x23\x05\xb9\xd0\xeb\xec\xae\x3b\xf5\xbb\xb7\x42\xda\x30\xa5\x9a\x0e\xb1\x0c\xbf\x25\x62\x47\xd6\x70\x30\x74\x85\x10\x87\xd4\xa1\x56\xd0\x11\xff\x0b\x97\x33\x36\xa4\xd5\x5d\x8c\x0f\xe9\x10\x4b\x12\xb6\x8f\x82\x7d\x82\x80\x89\x4e\x3a\x7c\x87\x7a\x98\xcb\x82\x77\x55\x46\x19\x61\x30\x22\x17\x42\xd7\x65\x73\xab\xd8\x0c\x57\xf2\x71\xdd\x79\x3e\xbb\xb8\xb9\xfa\xeb\xe5\xc7\xf3\x8b\x9b\x78\xac\xe3\xb1\x8e\xc7\xba\xc3\xb1\x06\x3e\xef\x7c\xa4\x2b\x05\x6f\x9d\xce\xbb\x54\x8a\x2f\x48\x19\x7f\x45\xd1\x67\x67\x7c\xfe\x03\x95\x75\x2f\x77\x94\x1f\xd7\xba\x89\x7d\xb3\x77\x24\x71\x27\x2f\x3e\xfc\xec\x09\x83\xc7\x7a\x0c\xca\xb9\x08\x2a\x1d\xac\xdb\xb5\xb0\x01\xd6\xc9\x2f\xe7\xa7\x67\x17\x37\xe7\xdf\x9c\x9f\x5d\x3d\x69\x34\x45\xc7\x52\x78\x4d\xa6\xdc\x92\x4b\x16\x12\xe6\x4c\x94\x2a\x5b\x54\x8d\xa6\xd6\x13\x81\xd5\x80\x3c\x9e\x12\xca\x17\xde\x9e\xb6\xfe\xb1\xc8\x6c\xfb\x65\xb6\xcd\xe0\x92\x0e\x85\x4b\xfa\x42\xdf\x6f\xa4\x68\xdd\x48\x7f\xd9\xb6\x6f\xed\x13\xde\xa6\xbf\x0e\x9f\xf6\x5d\x8d\x83\x06\xeb\x71\xc2\x63\x5d\x50\xc1\x08\xa3\x79\xa1\x3b\x94\x09\xef\xa5\xf8\x69\x3f\x75\x42\x6d\x20\xc6\x07\x5a\x7c\x07\x8b\x2b\xe8\x58\x1f\x65\xc9\x97\x92\x41\x62\x18\x1d\xb9\x85\x85\x75\xb1\x9e\xf8\x97\x75\xa9\xe3\xf2\x2c\x6b\xc7\xde\x42\x97\xba\xbe\x7d\x16\x7d\xbd\x85\x0e\x91\x99\x7e\xac\x94\x3f\x35\x5b\x88\x72\x9a\xd9\xd3\x6e\xbb\x47\xfa\x2d\xf8\xfa\x09\x8a\xdc\xee\x87\xec\xde\xd1\x59\xbd\x73\xf9\x08\x31\x37\x9c\x0b\xee\x8e\x5c\x54\xda\xd0\x28\xae\x43\x8b\xb5\xea\x08\x43\x6f\x8e\xbe\xc0\xff\xb8\xa2\x60\xc7\x69\xea\xa2\xa3\x4b\x05\x93\x32\xb3\xb6\x7a\x35\x22\xb4\x60\x3f\x80\x54\x68\x52\xbd\x65\x3c\x1d\x90\x92\xa5\x5f\x77\xa9\x2a\x65\x47\x8f\xbb\x20\xbc\x47\xaa\xdf\x9d\xb8\x76\x0e\xc7\x90\x77\x55\x44\x84\xd8\xd4\x47\xc4\x4d\x6f\x03\x76\x42\x46\x4f\xa0\xe9\xda\x89\x8a\xd8\x2d\xec\x97\xae\xee\xd7\x84\xd5\x3a\x73\xaa\x0a\x5c\xe9\x3b\x5f\x68\x4e\x55\xed\xa3\x46\x06\xc3\x06\xcd\x3f\x55\x41\x13\x18\x90\xbf\x57\x3f\x62\xc3\x65\xf5\xd3\xfe\xfe\x9f\xbf\x3b\xfb\xeb\x7f\xee\xef\xff\xfc\xf7\xf0\x2a\xb2\x42\xd4\x9a\x97\x6e\x41\x1b\x3c\x17\x29\x5c\xe0\x3b\xf0\x4f\x27\xae\x1d\x27\x89\x28\xb9\x76\x17\x30\x6d\x79\x34\x13\x4a\x9f\x5f\x56\x7f\x16\x22\x5d\xfe\x4b\x75\x2a\x95\xf6\x2c\x19\x03\x6e\x51\x87\xf4\x1b\x3b\xfa\x63\x0f\x35\x2d\xe9\xf9\xa8\xba\x59\x3d\x36\x62\xc9\x5d\xeb\x89\xf9\xc6\x83\x00\x5b\x5c\xfa\xfa\x08\x1c\x93\xca\x8d\x64\xda\xac\x9b\xb7\x37\x7f\xdb\xa9\x99\xaf\x1d\x3d\x92\xb6\x6a\x07\x7b\x06\x18\x42\xc4\xb7\x52\xc2\x83\x5c\x31\x58\xaf\xa5\xd4\xee\xe6\xe3\xcb\x73\x32\xb7\x10\x7e\x36\xc0\xf1\x4e\xb4\x6f\x3e\x29\x8d\xab\xbd\xa0\x4b\xc9\xab\xef\xac\xbf\xda\x5f\x77\x85\x04\x54\x55\xdb\x0b\x8c\x62\x73\x60\x7f\x1c\x25\x45\x39\x70\x37\x8c\x72\xc8\x85\x5c\x54\x7f\x56\x2e\xc2\xa1\xd2\x42\xd2\x29\x26\x9e\xd8\xc7\xed\x63\xd5\x5f\xf6\xc1\xc6\x0b\x56\x9f\xb6\xaa\x70\x52\x4a\x23\x34\x64\x8b\xba\xf4\xe7\xeb\xa3\x6d\x1e\xf4\xcf\x84\xb4\x55\x98\xd1\xb5\xef\xa3\x1d\x4d\x84\xac\x83\x04\x50\xe0\xac\xa0\x88\xfa\xa4\x4b\xac\x1d\x54\x62\x90\xb5\x06\xf0\xb9\xd1\x2c\x5b\x97\x06\xab\x47\x8f\xd4\x2c\x65\x73\xa6\x44\x87\xf4\x9a\x6a\xa2\xcd\x39\x03\xae\xb6\x87\x8d\x8c\xaa\xcc\x66\xf7\x05\x56\x43\xaa\xce\xeb\x12\xd9\x7f\xdb\xa5\xd3\xb7\x1d\x05\xd5\x1a\x24\x7f\x47\xfe\xfb\xe0\x6f\x5f\xfd\x3a\x3c\xfc\xfa\xe0\xe0\xa7\x37\xc3\xff\xf8\xf9\xab\x83\xbf\x8d\xf0\x1f\xff\x7a\xf8\xf5\xe1\xaf\xfe\x8f\xaf\x0e\x0f\x0f\x0e\x7e\xfa\xee\xc3\xb7\x37\x97\x67\x3f\xb3\xc3\x5f\x7f\xe2\x65\x7e\x6b\xff\xfa\xf5\xe0\x27\x38\xfb\x79\xcb\x49\x0e\x0f\xbf\xfe\xb2\xf3\xd2\x7b\x28\x4e\x6a\x47\x9f\x25\x4a\x9b\x33\xf6\x82\x7e\x9f\xb0\xc8\xbf\x1d\x1e\xbd\xfa\x3e\xff\x3e\x3c\xfa\x5d\xcd\x90\x2a\x76\xfd\x6c\x0e\xb8\x82\x44\x82\xfe\x1c\x96\x1c\xfb\xa6\x20\x50\x66\x5f\x91\x4a\xb5\x78\x6d\x7c\xee\xb7\x60\xdc\xf1\x62\xbb\xdd\xd7\x5a\x12\x9d\x48\x91\xfb\xb4\x77\x74\x6f\x60\x9b\x6b\x7f\xdf\x2d\x74\x6a\x96\x68\x47\x34\x06\x45\x63\xd0\x86\xf1\xa8\x31\xe8\xda\xe2\xe1\xb3\xb5\x04\x01\x9f\xb7\x75\x61\xac\xf5\xa0\x7b\x5d\x27\xac\x11\xb7\x9d\x43\x6d\xe4\x8f\xba\xaa\x3c\x71\x75\x24\x8d\x65\x68\xf9\x7a\x1f\x26\x76\xb1\x67\xdc\x1e\x7c\x9c\xa0\xce\x2b\x71\x5d\x0d\x6c\x09\x43\x98\x9b\x25\x54\x35\xb0\x1b\xd5\x2e\x31\xba\x14\x63\x5e\x7f\xb4\x21\xa8\xb7\x36\x2a\xd5\x28\x69\x8c\xd7\x75\x42\x2b\xe1\xb0\x2e\x2e\x4d\x95\x12\x89\x8d\xa6\xad\xb2\x1c\xb0\x74\x9d\x5b\x36\xae\x06\xfb\x4c\x07\xfd\xc8\x6d\xe1\xe9\xfa\x5b\xc7\x0b\xac\x87\xc9\xe7\xbe\xf8\x76\xea\x73\x66\x70\x25\xeb\xe7\x78\x5d\x01\x08\x06\x11\x9d\x13\x2c\x88\x43\x40\xaa\x5f\x69\xd8\x14\x43\x31\xc4\xa4\xb6\xb2\xb6\x6b\xf3\xd7\x99\x8b\x77\xe7\x99\x95\x67\xab\x93\x30\xb4\xc2\x2c\x6b\xf3\x73\x93\x49\xbe\x06\x67\x60\x77\xf6\xf9\x9b\x63\x9d\x3d\xb1\xcd\x7e\x58\xe6\x0e\xbe\x93\x3e\xd9\x64\x1f\xce\x92\x42\xc2\x84\xdd\xf7\x74\x4e\x8f\x79\x6d\x89\x61\x29\x70\xcd\x26\xcc\xe6\xd0\x14\x12\x0a\xe0\x36\x79\x81\x26\x33\xa4\xfd\x8e\x53\xd6\xce\xe9\xe7\x18\xcc\x63\x05\xee\x7e\x49\xd9\xf5\x3a\x61\x3f\xd2\x31\x12\xe9\x58\xeb\xf1\x99\xe8\x98\xc3\xdc\xe7\x43\xc4\x30\xf2\xbc\x7b\xe8\xfb\x69\x10\xc7\x8e\x58\xbc\x33\x96\xd5\x79\x4e\x47\x38\x4b\x2b\xeb\x73\x27\x64\xc0\xd7\x5e\x96\x59\xd6\x53\xf5\xed\xfd\x73\x84\x46\x51\x66\x99\x4b\x3a\x1e\x91\x8f\x1c\xcf\xe3\x31\x76\x79\x18\x90\x0b\x98\x83\x1c\x90\xf3\xc9\x85\xd0\x97\x56\xb0\x6d\xc6\xb2\xd9\x1b\x09\x9b\x90\x77\x46\x65\x52\x9a\x68\x5b\x69\x3f\xa8\x0b\x24\x64\x63\x82\xba\xe4\x58\x87\x18\xf4\xcd\xdb\xf2\x85\xcf\x68\x1b\x3e\xd1\x36\x55\xad\x4c\x7a\xd0\x4d\x7d\xcb\x3a\x17\x1d\x87\x11\x91\xce\x35\xb2\x2e\xa7\xf7\x05\x96\xd9\x28\x84\xd2\xd7\x46\x85\xed\xa7\xcd\xcd\xa5\x9f\x0e\x3b\x47\xd0\x2c\x83\xb4\xd1\xe7\xc8\xf6\xe7\xa0\x4d\x15\x1a\xb3\x8d\xab\x76\x11\x40\x66\x94\xa7\x19\x48\x2c\xf9\xae\x96\xeb\x5a\xb1\xba\xc7\x41\xd5\x95\xc2\xa7\x85\xd2\x24\x11\x32\x75\xcd\x6a\x5d\xf2\x26\x2e\xa6\x3a\x5e\x48\x68\x73\xca\xe9\xd4\x76\x29\x5c\x29\x1c\x8c\xe5\xa4\x55\xd0\xda\x62\x26\xc4\x2d\x49\x44\x5e\x64\x78\x00\x3a\x9c\x8f\xba\xb3\x4e\x85\xa2\x43\xec\xa6\x78\x14\x34\xdd\xc1\x1f\x9e\xb0\x3b\x62\x1f\x72\x0a\xdc\x43\xd2\x5b\x57\x3e\x43\x11\xcd\x2e\xa3\x4f\x5c\xf0\x4a\x5c\x99\x08\x73\x18\xcd\x5e\xd7\xf5\x08\x2a\xa2\x37\x22\x67\xf7\x90\x04\x9d\x2d\xcd\x13\xae\xb5\xa5\x16\x68\x0f\xe9\xde\xb1\xb8\xb3\x29\xbf\x2f\xf3\x79\x87\x04\xb5\x70\x2c\x55\x9f\xc3\x39\x7d\xb1\x6d\xf7\x0a\xec\x5b\x60\x13\xa4\x31\x69\xcd\xd7\xdf\x6e\x9c\x21\x7b\x62\x57\x4a\xd6\x55\x01\xca\x7e\x2e\x4c\xd4\x16\x42\x93\x83\xfd\xa3\xfd\xc3\x15\xbb\xde\x52\xc5\xe6\x9b\xe0\x49\x86\x25\x0a\x0b\xac\xf7\x07\xc9\x7e\x3a\x20\x4c\x7b\x1a\x6d\x2b\x25\xe0\xaa\x5c\x26\xdd\x80\x28\x41\xb4\xa4\x29\x73\x9a\x13\xfe\x6a\x6e\xd2\xb2\x74\x65\x12\x0e\xf6\x7f\xdd\x1f\x10\xd0\xc9\x21\xb9\x13\x7c\x5f\xe3\xf2\xb1\xa6\x48\xa9\x82\x89\x16\xa2\xc4\xd6\x7d\x16\x04\x55\x81\x10\x43\xe8\x88\x28\x6d\x9f\x9f\x19\xd5\x3e\x83\xef\xec\x9e\x69\xdf\xdb\x42\x4c\xc8\x1b\xdb\x66\x08\xa8\xb3\x2c\x66\x6c\x0e\x47\x33\xa0\x99\x9e\xd9\xe0\x0b\x2e\xf8\xd0\x76\x8a\x33\x14\xc8\x5d\xe9\xea\x87\xe8\x66\xa6\x0b\x47\x07\x93\xdd\xea\x82\x3a\x4a\xe4\x86\xf6\x7e\xdb\xbe\x17\x2e\x59\x69\x13\x7d\x73\x73\xf9\x6d\xa3\x19\x2e\x12\x7f\xad\x0b\x1f\x12\x13\x14\xdb\x78\x06\xb4\xa3\x1f\x27\x60\xa7\x4e\xb6\xa4\x47\x12\xd6\xb5\xa3\x2d\x59\x6d\xfb\xbd\x5b\x2b\x5b\xf2\x57\x51\x62\x0b\x3e\x3a\xce\x16\xe4\x8e\x72\xed\xd3\xf7\xf6\xcc\x54\x7b\x86\x3c\x19\x6c\xf8\x0b\xd0\x14\xa4\x42\xea\x01\xb4\x75\x51\x31\x3f\x7a\x73\x4e\x05\x6b\xeb\x97\x0f\x94\x4a\x8b\x9c\xcc\xdc\x67\x37\x53\x1a\xdd\xc9\x18\xe1\xe9\xf1\xf9\x42\x12\x0a\x4b\xe1\xdc\x33\xaf\x8e\x7e\xad\xd0\x0d\x0b\xf7\x46\xf1\xfd\x24\x04\x5b\xd8\xa2\x85\x71\x0b\x2c\xdb\x5c\xb1\x27\x5a\xda\x43\x50\x01\xe9\x31\xb0\x80\x74\x4b\x90\x5c\x9e\x08\x9d\x65\xdd\x63\xa8\x7a\x8b\x55\x20\xbd\xf9\xe3\xc9\x3a\xe3\xa5\xc3\x19\x1b\x39\xdb\x13\x10\x7b\xf5\x82\x93\xee\x29\x98\xe1\x78\x18\x00\xfd\x6c\x3e\xe9\x13\x02\x45\x0f\x21\xd3\xab\x01\xd3\x2b\x2d\xc6\x91\x4c\xd8\x4a\x55\xcf\x86\xcb\x74\xed\xb7\x4e\xd6\xe7\x1f\x4b\xc2\xab\xf6\xb8\xfa\x45\xf4\x5c\x27\xfd\x85\x36\xf6\x1d\xd8\xd8\x6b\x58\xe3\x27\x0d\x6a\xc4\x54\x8a\xce\x54\xa4\x69\x53\xc7\x29\x0d\x06\x18\xbd\xcd\x68\x9c\x4e\xf6\x73\x46\x21\xdf\xc2\xa3\x69\x45\x35\x47\xed\x59\x9c\x31\x9d\x14\xd7\x22\xb9\xed\x51\xaf\xd9\xbf\x39\xb9\xb4\x53\x06\xaa\x0d\xe5\xde\x18\xc2\xf8\x5c\x64\x73\x5b\xe9\xef\xe6\xe4\x12\x4f\xde\x08\xff\x85\x86\x28\xd4\xa8\x17\xe6\x59\x1f\xec\xef\x5c\x38\x46\xfb\xb6\x16\x34\x4a\x24\xd0\x8c\x29\xcd\x12\x7c\xae\xb2\x6d\xe1\x0c\x5d\x7c\x37\x51\x53\x5a\x37\x7a\xd7\x94\x82\x6e\xb3\xbb\x2a\x4d\x5d\x83\xf3\x9e\x31\x5f\x72\xfc\x48\x56\xcd\xd4\x22\x5f\xea\x69\xbe\xe7\xcb\x97\x0a\x09\xd7\x5a\x14\x3d\x79\x42\xec\x64\x1b\xfc\x20\x63\x98\x08\x09\xcb\x8e\x90\xc0\xb1\x91\x96\xe0\x0a\x71\x1e\x5f\x9e\x57\x26\x28\xd1\x70\x5e\xd8\xb0\x44\x5f\x7d\x33\x63\x73\xe0\xa0\xd4\x11\xba\x3c\xca\xc2\xaa\x98\xbe\x6f\xee\xc0\x7c\x1d\xe4\x85\xad\x5f\x59\x85\xfa\xbb\xae\xbd\xf8\x23\x68\x5b\x78\xb2\xf2\xbf\x38\x8b\xaa\x5f\xfe\xb2\xab\x24\x91\x54\xcd\x6c\x47\x5b\xb8\x67\xda\x75\x65\x96\x40\x95\xe0\xd6\xd8\x1b\x34\xd7\x65\x8a\x14\x54\xa9\xba\x0c\xb8\x7b\x89\x7d\xe8\xd2\x96\x0e\x0e\x1f\x98\x4a\x9a\x00\x29\x40\x32\x91\x12\xcc\xb9\x4d\xc5\x1d\x27\x63\x98\x32\xae\x3c\xfc\xcc\x44\x1e\xd0\x86\xdd\x00\xda\x86\x7d\x45\xb5\x11\xb9\x6a\x14\x0a\x71\x29\x3c\x89\xa8\x4f\xb4\x5b\xc5\xb2\x93\x09\xa3\x26\x11\xbc\xb6\xad\x4c\xb5\x31\x61\xa7\x9d\x47\x16\xdd\x83\xb7\xc9\x36\x83\xf2\xd7\x36\x42\x07\x0b\x9e\xd2\x64\xd6\xcd\x7d\x1b\xdd\x53\x5b\x8e\xe8\x9e\xda\x6d\x44\xf7\x54\x74\x4f\x6d\x1e\xcf\xce\xbc\x1b\xdd\x53\x51\xe9\x5a\x1e\xd1\x3d\x15\xdd\x53\x1b\xc6\xb3\xa3\x5f\xd1\x3d\xb5\xc5\x88\xee\xa9\x2d\x47\x74\x4f\x45\xf7\x54\x74\x4f\x45\xf7\xd4\x6f\xc8\x0c\xe8\x47\x74\x4f\xad\x4c\x12\xdd\x53\x01\x30\xa2\xa6\xb4\x66\x44\xf7\xd4\x9a\x11\xdd\x53\xc1\x88\x7c\xa9\x05\x5f\xf2\xce\x9d\x4b\xa3\x97\x75\x6f\x23\x8c\xda\x1d\xd6\xf3\x7b\xa5\x69\x4d\x5d\x6c\xfc\xcf\xda\xbe\xff\x4c\x7c\x28\x3d\xd8\xf4\xa3\x3d\xff\xd5\xd9\xf3\xfb\xb1\x85\xf5\x60\x07\xeb\x4c\xca\x9d\xd7\xfc\x66\x26\x41\xcd\x44\xd6\x1a\xd1\x1b\x48\xfe\x81\x71\x96\x97\xb9\xc1\x39\x65\xf0\x99\xcd\x2b\xf7\xbc\xaa\x5b\x32\xa3\xd7\xde\x9a\xe4\xcc\x8d\x2c\x05\xac\xc6\x49\x59\x66\xb6\x11\xf3\x27\x67\x14\x65\x62\x55\x26\x09\x00\xf6\xfa\x0a\xd5\x85\x3f\x8c\xaa\x37\x55\xbd\x1d\xde\x76\xa3\x37\xdd\x98\xac\xad\x97\x89\xb3\xfc\xe1\xf7\xad\xe6\xe8\xe8\x4e\xf9\xfc\xae\x94\x1e\xc8\x74\x77\xc5\xa0\x93\x52\xd0\x07\x97\xe8\xaa\x0c\xbc\x34\x97\x49\x6f\xae\xc3\x1e\x5c\x25\xcf\xc8\x4d\xf2\x6c\xd8\xc2\x73\x71\x8d\x3c\xc3\x52\xa0\x3d\x58\xf2\xfb\x70\x85\xf4\xe7\x06\xf9\x04\x15\x33\x3f\x8d\xfb\xa3\x47\xb5\xb3\x27\xb7\xc7\xe7\x70\x79\xf4\xf2\xd5\x5d\x5d\x1d\x9f\xcf\xcd\xd1\xcf\xe7\x76\x34\x23\xbd\x0a\xd7\x46\x0f\xe6\xa3\x3e\x4d\x47\xbd\x99\x8d\x3e\x99\x2b\xa3\xbb\x1b\xe3\x19\xb8\x30\x3a\x03\x99\x71\xa6\x19\xcd\x4e\x21\xa3\x8b\x6b\x48\x04\x4f\x5b\x73\x98\xa5\x12\x6a\xd5\xf9\x51\x76\x5a\xa7\xa3\x35\x03\x7d\x67\xd4\x55\x8a\x85\xd4\xc7\x2e\x7b\x93\x9e\x13\x28\xd0\x1a\x67\x57\xd9\xa6\x0e\xd3\x9d\x90\xb7\x99\xa0\xa9\x3a\x2a\x84\xfd\xbf\x3a\x8c\x37\x88\xdf\xb5\xef\xea\x16\xc0\xfb\xd4\xca\xa0\x8d\x7a\xee\x73\x13\xff\x22\xee\x88\x98\x68\xe0\xe4\x80\x71\xbf\x8f\x87\x81\x1a\x58\x6b\xe6\x15\x5a\x9b\xab\x6f\xdf\xf8\x9b\x5f\x9f\xca\x8d\xc6\x05\xa5\x3e\xbd\x05\xc4\xbd\xe8\x71\x13\x88\xbb\x71\x52\x66\x4d\x33\x88\x35\x8d\x34\xe9\xcd\xdb\xba\xd6\xe5\x5b\x9c\xb7\x3a\x6d\x94\xa7\xc4\x65\x48\xbc\xbe\x4d\xeb\xec\xa0\x7d\x0d\xce\xd9\x68\x7b\x21\x7d\xdb\x5e\x9e\xc8\x09\xfb\x0c\xa5\xe6\x17\xea\x78\x8d\x52\xf3\x0e\x23\x48\xb4\xfa\x56\xd2\x04\x2e\x7b\x17\x38\xfc\x71\x22\x69\x29\x5d\x7e\x5c\x25\x77\x54\x87\x87\x03\xa4\xf6\x34\x55\xd9\x67\x98\xf6\x35\x29\xb3\x6c\x41\xca\x42\xf0\x66\x8a\x9f\x75\x5a\x2d\x67\x86\x99\xd9\xd6\xbd\xa5\x96\x52\x0b\x29\x1c\x03\x96\x25\xe7\x86\x9e\xd7\xdd\x6f\x50\x2a\x55\x96\x56\x87\xf9\x67\x8a\x4d\xcd\xf2\x0d\x33\xc5\xd4\x34\x96\x43\xdd\x1f\xa1\x9e\xd0\x3c\x3d\x11\x32\x61\xe3\x6c\x41\x66\x34\xab\x5a\x1d\x50\x72\xcb\xb2\xcc\x4d\x33\x22\xd7\xa0\x89\x9e\x31\xd7\xa5\x9a\x64\x82\x4f\x71\x71\x94\xfb\x16\x5b\x90\x98\x67\x93\x0c\x28\x2f\x0b\xfb\x3e\xc3\xd6\x17\xa2\x94\xfe\x7d\xae\x7e\x64\x35\x0b\x53\x84\xb3\x6c\x10\x34\xf2\x79\x70\x63\xeb\x6e\xe9\x0a\x7c\xf2\xde\x1d\x53\x30\x08\xe7\x14\x73\x90\x92\xa5\xce\x69\x60\x7f\x2b\xa4\x98\xb3\xd4\xb6\x62\xf0\x60\xc3\x96\xa1\xb6\x55\x43\x75\x9e\xb9\xe0\x43\x0e\x53\x8a\x52\x8f\x3b\x45\x76\xcf\xec\x3c\xd6\x15\xc7\x53\x6c\xde\x60\xd4\x05\x51\x34\x72\x46\xe7\xcc\xb6\x9d\x0c\x20\x47\x0e\xb8\x20\x02\xd9\x6b\xc9\x99\xb6\xad\x8c\x67\xa5\x26\xa9\xb8\xe3\x87\x66\x72\xa6\x0c\x1c\x28\x19\x83\xf6\x6d\x55\x7d\x9b\x3f\x26\x41\x11\xe0\x74\x9c\x99\x3d\xc7\x98\x80\x9b\xb5\x00\x22\x13\xa0\xba\x94\x40\xa6\x54\xc3\x5a\xa1\xc9\x7e\xef\xc3\xe0\x65\xaa\x6a\x39\x5e\x72\x05\xad\x9b\x2d\xf7\x2c\x69\xfd\xe9\x8f\xed\x68\x04\xcb\x41\x94\xfa\xb3\xa8\x92\xb6\x1d\x7f\x20\x19\xb3\x1c\x14\x11\xe5\x92\x8e\xfd\xd6\x3d\xb6\x7e\x87\xa2\x3e\xb9\x6e\xb4\xb5\x12\xaf\x31\xa5\xb9\x6e\x80\xab\xf1\x33\x41\xb7\x53\x6a\x8e\xe2\xe9\xc5\xf5\x2f\xef\x8f\xff\xeb\xec\xbd\x3b\x9f\x3c\x64\xfa\x25\x67\xff\x28\x81\xd0\x5c\x18\xb9\x3a\x0b\xc3\x70\x06\x68\x1e\x08\x7e\xc0\x93\xdc\x6f\xc0\x4e\x4b\x86\x8c\xad\x99\xbb\x87\x25\x61\x83\xe7\x4f\x1f\x95\xf4\xd4\x2d\x6b\xaa\x96\x9b\xe6\x83\xc3\x96\x35\x94\x70\xd0\xe6\xe4\x59\x89\xd2\xb6\x30\x62\x7c\x9a\x85\xc2\x64\x3b\x72\xd5\x55\x27\xea\xaa\x11\x0d\xeb\x2f\xb8\x6c\xab\x18\xf5\xd2\x3a\xa7\x5e\x43\x4f\x0d\x27\x6a\xaa\xed\xd5\x00\xdb\x11\xd4\xab\x01\x56\xf4\x38\xbf\x24\x34\x4d\x25\x8a\x29\x78\xea\xf3\xa5\xc6\x73\xf8\xb0\x35\xc6\x0f\xc8\x1b\xf2\x67\x72\x4f\xfe\x8c\x6a\xc1\x9f\xba\xb6\xe7\xe8\x2a\xb0\x77\x37\x4b\x58\x6d\xf4\xfc\xb2\x27\x88\xff\x38\xa3\x1a\x67\x34\x50\xd5\x82\x8c\x99\x13\x43\xe1\x5e\x83\x34\x62\x91\xdb\x89\x27\x6d\x6c\x62\x16\xf8\x19\xd1\xcc\xda\xdc\xcf\x27\x61\xe5\x7f\xbd\x23\xa2\x99\xc7\x8d\x7e\x7f\xe1\xa8\x50\xb3\x8f\x40\x3d\x5b\x4e\x75\x32\x6b\x92\x31\x23\x60\xa8\x06\x73\x4a\x05\x92\x71\x1b\xbf\x36\x63\x1d\x22\x08\x9e\x0f\x1a\x77\x73\x2a\x37\xf6\xf3\xa1\x9d\x5a\x52\xfc\x91\xcf\x3b\xc1\x20\xa8\x3f\x52\x88\x74\x44\xce\x68\x32\xc3\x65\xa5\x01\xcf\x30\x1a\x08\x4e\x36\xa3\x73\xb3\xf1\xee\x59\xdb\x77\x03\xa5\x95\xca\xd4\x8a\xb8\x64\xce\x53\x42\xb9\xed\x7c\x37\x01\x29\x6d\xc8\xe1\x78\x81\x9e\x4f\x96\x40\xe7\xcd\xeb\x74\x92\x0a\x29\xb4\x48\x44\x87\xde\x2b\xcb\xd1\xcf\x38\x1d\x02\xc1\x1a\x2d\xbd\xad\xf8\xfb\xd3\xcb\x01\xb9\x39\xb9\xc4\xa6\x19\xd7\x27\x37\x97\x4d\x09\x7b\xef\xe6\xe4\xb2\x43\x0f\xff\x5e\x6c\x1e\xce\xcc\xf6\xce\x2c\x73\xe7\x49\x24\xd0\x94\xc5\x38\xf2\xed\x47\x8c\x23\xdf\x3c\x62\x1c\x79\x8c\x23\x8f\x71\xe4\x0f\x8f\x18\x47\xee\xc6\xd3\x9b\x7a\x48\x8c\x23\x6f\x39\x5e\x97\x2f\x33\xc6\x91\xef\x34\x62\x1c\xf9\xea\x88\x71\xe4\x1b\x46\x8c\x23\xdf\x30\x62\x1c\x79\x8c\x23\x8f\x71\xe4\x31\x22\xe6\xd1\xb9\x9e\x67\x44\x0c\x89\x71\xe4\x6e\xc4\x38\xf2\x57\xe1\xf7\x27\x31\x8e\x7c\xab\x11\xe3\xc8\x63\x1c\x79\x9b\x11\xe3\xc8\x71\x44\xdb\x4b\x8c\x23\xf7\x23\xc6\x91\xdb\xf1\xdb\x91\x9a\x63\x1c\x79\x8c\x23\x8f\x71\xe4\x31\x8e\xfc\xc1\x55\xc4\x38\xf2\xd7\xa0\x4f\xfa\x86\x5a\xdd\x83\xa0\xaf\xfc\x4c\xdb\x87\xd5\x90\xb3\x35\xbf\xa2\x59\x45\x15\x66\x12\x59\x4f\x99\x49\xa0\xe9\x02\xa7\x4c\xd0\x2d\x53\x0b\x59\x2f\x30\x3a\x27\x63\x39\x6b\x17\x77\x4e\x56\x0e\xcd\x7b\x9c\x2b\x70\xe1\x18\xb0\xe4\xf4\x1e\x0f\x00\xcd\x45\x69\xfb\x77\x25\x22\x2f\x4a\xdd\x84\x29\x6e\x4f\x9b\xd6\x5b\x13\x36\x75\x1c\xf5\xc8\x76\x09\x1b\x56\xd3\x0e\x83\xce\x5c\x4f\xa8\xc0\xd0\xd4\x87\x9f\x5c\xf6\xa0\x4b\x14\x54\x6b\x90\xfc\x1d\xf9\xef\x83\xbf\x7d\xf5\xeb\xf0\xf0\xeb\x83\x83\x9f\xde\x0c\xff\xe3\xe7\xaf\x0e\xfe\x36\xc2\x7f\xfc\xeb\xe1\xd7\x87\xbf\xfa\x3f\xbe\x3a\x3c\x3c\x38\xf8\xe9\xbb\x0f\xdf\xde\x5c\x9e\xfd\xcc\x0e\x7f\xfd\x89\x97\xf9\xad\xfd\xeb\xd7\x83\x9f\xe0\xec\xe7\x2d\x27\x39\x3c\xfc\xfa\xcb\xd6\x4b\xee\x2c\xf0\xf6\x27\xee\xf6\x24\xec\x7e\x12\x51\xd7\xf9\x7e\x7b\x3a\x8b\x57\x6e\xb6\xe5\xd3\xe8\xd8\xd1\x43\xa7\xd1\x6b\xdc\x28\xc4\x55\xf3\x30\x45\x44\xce\xb4\x76\x54\x94\x86\x51\x5f\x4c\x37\x54\x4e\x47\x07\xb0\xdb\x21\xd5\xb6\x9d\x60\x15\x31\x15\x44\xec\x0a\x2f\xd7\xb9\x36\x8d\x95\x35\x02\xcf\xf3\x30\x85\x09\xe3\xe0\xbc\x5c\x91\x36\x3c\x3e\x22\x6d\x78\x8d\xb4\x41\x41\x52\x4a\xa6\x17\x27\x82\x6b\xb8\x6f\x65\x3f\xd9\x64\x40\xba\x6e\x4e\x4d\xec\x89\xb3\x94\xc2\xbf\x96\x88\xc2\x06\x4a\x6e\x4c\xcd\xab\x82\x6e\x65\xc9\x51\xa5\xb4\x39\x14\xa0\xad\xbe\x87\x9a\x0e\x46\x41\x2e\xbf\xce\x6b\x70\x76\xea\x7f\x94\x6c\x4e\x33\xa3\xdf\xd6\x4f\x5c\xa2\xce\x12\x3e\xd4\xca\x88\xf5\xc4\x32\x16\x8a\x37\x97\x92\xcd\x59\x06\x53\x38\x53\x09\xcd\x90\x2a\xf5\x43\xe9\x8f\x37\xcc\x8e\x5b\x24\x45\xa6\xc8\xdd\x0c\xb0\x8d\x2a\xf5\xea\x39\x66\x2a\x4c\x29\xe3\x24\x37\x44\xb5\xf0\x0f\x2b\xab\xe7\x1b\xe2\x6d\xa4\x5e\xae\x6b\x7d\x1e\xd5\xd7\xb1\x10\x99\x0b\xeb\xcd\x16\xf5\xfc\xae\xad\x2d\x17\xbf\x70\xb8\xfb\xc5\xcc\xa6\xc8\x24\xa3\xd3\x4a\x8d\x57\xa0\x57\x2c\x71\xf5\xd4\x1b\x3f\x00\x63\x66\x4b\x20\x34\xbb\xa3\x0b\x55\x1b\x35\xc2\x86\xbf\xef\xc8\xdb\x43\x44\x3c\xaa\x48\x35\x47\x4a\x7e\x7f\x88\x7e\xbe\x93\xe3\xcb\x5f\xae\xff\x7a\xfd\xcb\xf1\xe9\x87\xf3\x8b\x6e\x74\xde\x7c\x3b\x50\xde\x6a\x8e\x84\x16\x74\xcc\x32\xd6\x85\xbc\xaf\x44\x82\x84\x93\x22\x03\x4d\xd3\xa3\x54\x8a\xc2\xc2\xc9\xdb\x8f\x42\x1d\xe7\x74\xc9\x2c\xec\x78\xb6\xdd\x9e\x49\x73\xc2\xa9\xa4\x5c\xd7\x86\x94\x1a\xe4\xb2\xe4\x46\xe9\x7d\xe1\x41\xf3\x34\xed\x2f\x60\xfe\x38\x4d\x21\x6d\x40\xef\xd5\x05\xe8\x9d\xf8\x8f\x5b\xd4\xb9\xb6\xe4\xf2\xe3\xf5\xf9\xff\x5e\x42\xc3\x45\xd1\x2d\x1e\xa9\x9f\xfc\x1e\xd9\xbe\x03\x39\x59\x35\x26\xe4\x62\x1e\xf7\xf7\xb9\xec\x6f\xc5\xab\xfa\xf1\x82\x5f\x95\x3c\x64\x27\x3c\x98\x9f\xe4\x22\x85\x11\xb9\xac\x2c\xe8\xcd\xab\x61\x0d\x01\x09\xc4\xdc\xc2\x35\xc3\x56\xe7\x81\x28\xa3\x85\x4d\x74\x69\x64\x98\x86\x74\x78\x42\x33\xd5\x91\x98\x76\xe1\x4c\x86\x09\x7f\x30\xaa\x60\x2f\xd0\xac\x66\x23\x29\x70\xa1\x9d\x24\x69\x56\x89\x49\xb7\x52\x24\xc4\xea\x9d\x41\xc8\x52\x83\xbb\xb8\x06\xf8\x9e\x31\x31\xe5\x61\x75\x59\xcd\x6c\x2d\xb0\xa5\x02\xb5\x9e\x31\xd5\x9a\xa8\x99\x5d\x02\x4d\x31\x5f\xac\xa0\x7a\x66\x23\x0e\x72\xaa\x6e\x21\xb5\x3f\x38\xb9\xa6\x32\xc1\xdb\x66\xf8\xee\x55\x37\x66\xdd\xde\xde\x8e\xf2\x8c\x8d\x83\x40\x3b\x3d\xb4\x8e\x4e\xef\x7c\x04\xcc\x37\x7d\xe4\xd9\xe2\x4a\x08\xfd\x4d\x95\x27\xd5\xcb\x06\xfe\xe8\x24\x45\x74\xb3\x34\x43\xa6\x30\x40\x20\x1d\x22\x30\x11\xa5\xc3\x14\xad\xd3\x7a\xc3\x9e\x18\xa1\x65\xc9\x8f\xd5\xb7\x52\x94\xad\x39\xc0\x8a\xa0\xf5\xed\xf9\x29\x9e\xe3\xd2\x79\xc0\xb8\x96\x8b\x42\x30\x6b\x3e\xd9\x20\xd3\x7e\xef\x7c\x78\x21\x46\xd6\xee\x16\xf2\x81\x2e\x08\xcd\x94\xf0\xc2\x31\xe3\xeb\x54\x1d\xe2\xf4\x28\x73\x79\x2c\xf4\x6c\x45\x81\x32\xe8\xbc\xfa\xdc\x20\x70\x88\xd5\x75\x53\x18\x5f\x79\x5c\xd3\x5b\x50\xa4\x90\x90\x40\x0a\x3c\xe9\xb8\x6b\x4f\xed\x06\xc2\x9d\xbf\x10\xdc\x1c\x8b\x5e\xf6\xfe\xbc\xf2\xff\xa1\x19\xab\xb9\xd3\xe8\x49\x74\x7a\x07\x45\x7f\x22\x1e\x8a\x52\x81\xb4\xce\x4f\x59\x82\xdd\x88\xef\xca\x31\x64\xa0\xad\x32\x84\xf5\x03\xa8\xb6\x2a\x2f\xcb\xe9\x14\x08\xd5\x15\xa2\x68\x41\x80\x2b\x43\x6e\xac\xe1\x4c\x93\x54\x40\x9d\xdc\x48\x15\xf9\xfe\xfc\x94\xbc\x21\x07\xe6\x5d\x87\xb8\xfd\x13\xca\x32\x74\x35\x6a\x2a\x97\xd7\xc8\x26\x7e\x0a\x5c\x12\xe2\x1e\x11\xd2\x1e\xd1\x01\xe1\x82\xa8\x32\x99\xf9\x35\x19\x8d\xcb\x2b\x6c\x2e\xd6\x0e\x4d\xf2\xaf\x10\x55\x3b\x13\x98\xef\x15\xc8\xde\xe8\xcb\xf7\x2d\xe8\x4b\x28\x42\x18\x9c\x6b\x42\xcf\x22\x56\x0e\x9a\xa6\x54\x53\x47\x77\xea\x8c\xe8\xd7\xb8\xa5\x4f\x4d\x7d\x14\xbc\x67\xbc\xbc\xb7\xb6\xb5\xfe\x94\xfc\xeb\x33\x9c\x16\x51\x00\x81\x86\x9b\x46\x8b\x22\x63\xb5\xe7\x31\x88\x6e\x3a\x6f\x6c\xf5\x60\x83\x88\x84\xc7\xdc\x3b\x30\x0d\x67\xa7\x3c\x15\xf9\xca\xcb\xd0\x5b\x4a\x93\x59\xf8\x82\x57\x89\x3c\x4f\x6e\x8e\xc8\x60\x0e\x1d\x6a\x73\x2c\x21\xce\x7b\x33\x9b\x91\xc5\xfc\x86\xe2\xf4\x24\xa3\x63\xc8\x2c\x67\xb1\x08\xa4\x56\x11\xe8\xa9\x23\x04\xa5\xc8\xfa\xcb\x8f\xb8\x12\x19\xd8\x90\x1b\x0f\x08\x33\xfd\x8b\x80\x03\x4e\xd2\x17\x1c\x50\x91\x69\xc0\x01\x55\xb2\x97\x00\x87\xb2\x03\xa3\x25\xcb\x70\x30\x5c\xbb\x09\x07\x64\x9d\xcf\x1d\x0e\x0a\x92\x44\xe4\xc5\xa5\x14\x46\xe5\xea\x8d\xb5\xb8\x69\x6b\xff\x8e\xd5\xc9\xd1\xe0\x1b\x6a\x7f\xce\x9b\xd3\xbc\x99\xca\x20\xd8\x8e\x6a\x4b\xe3\x7d\xc4\xdd\xff\x0a\x58\x0e\x92\x9e\x65\x3e\xe4\x67\x69\x38\x80\xcc\x93\xee\xc2\x0b\x4f\xf5\xef\x60\x25\xeb\x85\x99\x88\x84\x66\x58\x3a\xad\x1b\xc6\x90\x65\xac\x59\x9e\x38\x88\x90\x44\xd7\x12\xfe\xe6\xbd\xf6\x58\x45\x0b\x7f\x71\xb6\x2f\x2e\x52\x08\x9c\x85\x36\xb4\xf3\xc6\x46\xd2\xe1\x7d\x3e\x38\xd3\x70\x75\xe7\xbc\x87\xb4\xf1\xb4\x16\xae\x3a\xcb\x87\xaa\x20\x9b\x59\x20\xf0\x94\xf1\x29\x5a\x74\x06\x44\x42\x66\xc3\x3a\xdd\x19\xbe\xb5\xea\xd7\x3e\x62\xb4\x9f\xd4\xa3\xb3\x7f\x35\x4a\x42\x4c\x70\x37\x33\x1a\x39\xbc\x7c\x33\xb1\xd4\x92\x29\xb2\xf7\xde\x03\xa0\x43\x05\xab\xe7\xc8\x20\xf6\xec\x17\x56\xbb\x69\x6d\x6c\xb7\x8c\xa7\x2e\x02\xb2\x01\x2c\xaf\x24\x3a\x29\x14\x63\x6b\x59\x1a\x92\x86\x77\xe4\x6f\x9c\x54\xc0\x22\xc3\xd6\xe8\x71\x65\x05\x56\x6f\x5e\x1a\x3e\x6c\xf2\xab\x5e\xb2\x3c\xcd\xf7\x1c\xf7\xde\xbc\x77\x68\xd4\xde\xd5\xfb\xfc\xb7\xec\x3d\xe5\xbe\xde\x31\x9e\x8a\x3b\xd5\xb7\x0e\xf1\xa3\x9d\xd6\x0b\xd4\x89\x41\x6b\xcd\xf8\x54\x85\x7a\x44\xb3\x4e\xee\x7a\x45\xc2\xef\xf0\x44\x0a\x9b\x86\xb7\x2a\xc0\x2f\x45\x6e\x47\x25\x60\x87\x31\xcd\x15\x3d\x91\xe6\x53\x34\xa3\xd9\x75\xd1\xbe\x6c\x1a\x59\x46\x83\x6f\x3f\x5c\x1f\x37\xa7\x36\xf4\xec\x6e\x06\xd2\xf2\x5e\x73\x9d\xd0\x34\x67\x4a\xa1\x19\x08\xc6\x33\x21\x6e\xc9\x81\x0f\xb4\x9a\x32\x3d\x2b\xc7\xa3\x44\xe4\x41\xcc\xd5\x50\xb1\xa9\x3a\x72\x48\x3b\x34\xab\x3f\x24\x8c\x67\x55\x04\x09\xaa\x91\x5c\x2b\x6f\xc6\xc0\x97\x24\xd5\x2a\x70\x6f\x5d\xdd\x45\xe7\x65\x5e\x5d\xa6\xad\xb4\xc8\x20\x7b\xfa\x62\x30\xab\xdb\x73\xd1\xb1\xae\xc5\x23\x5b\x84\xdf\xee\xd2\x46\xc2\x14\xa7\xb5\x70\xb4\xd2\xdb\x93\x03\xc9\x49\x07\x09\xa8\xfe\x2a\xe6\xfc\xa5\x9e\x93\xa4\x60\x33\x1b\x00\xa3\x4e\xe8\xc6\x30\x24\xb4\xca\xee\x63\x82\x9c\x7b\x74\x3f\x94\x68\xd1\xeb\x63\x53\x30\x8c\x3e\x90\x15\x33\x3a\xb4\x4a\xb2\x21\x49\x48\xc3\xbc\x0c\x30\x13\x5c\x48\x8b\xa2\x86\x0b\x0a\x8e\x28\x8d\xda\x82\x75\x04\xe1\x9e\x38\x1a\x1b\x2c\xf5\xa4\xf6\x0f\x86\x3e\x24\x4c\xb0\xb1\x09\xfa\xf5\x1a\xee\x98\x9e\x61\x11\xb9\xd9\x92\xc3\x09\x57\x22\x41\xa1\xf7\x80\x13\x90\x52\x48\x17\x08\xe3\xad\xb6\x38\x13\x92\x62\x8c\xa4\x31\x48\x42\xcd\x5f\xfb\x2a\x74\x51\xd6\xa5\x4c\x31\xb6\xcb\x60\x13\x4c\x26\x90\xa0\xa4\x14\x02\xd8\x92\xdd\x83\xba\xaa\x9e\x0f\x9d\xd7\xc2\x97\x42\xcd\xd9\xbd\x79\x4b\xf8\xd4\x52\x41\x75\x2e\xf8\x70\xfd\xe5\xc3\x11\x21\xe7\xbc\x8a\x7b\x1c\x98\x5d\x0c\xef\xf4\x21\x3f\xda\x7c\x62\x58\x47\x17\x3f\x20\xb4\x3b\x19\xf1\x4e\x96\x3d\x60\x7c\x17\x63\x30\x09\x0d\xc2\xbd\x92\x03\x34\x0c\xbb\x49\xcd\xd6\x7b\x26\xde\xc5\x50\x6c\x6e\xf9\x54\xc6\xe2\x97\xc1\xe9\x49\x57\x3a\xe7\xd2\xd5\x63\xed\xd7\xed\x46\xac\xfd\xba\x79\xc4\xda\xaf\xb1\xf6\x6b\xac\xfd\xfa\xf0\x88\xb5\x5f\xdd\x78\xfa\xf4\x4c\x12\x6b\xbf\xb6\x1c\xaf\xab\xfe\x48\xac\xfd\xba\xd3\x88\xb5\x5f\x57\x47\xac\xfd\xba\x61\xc4\xda\xaf\x1b\x46\xac\xfd\x1a\x6b\xbf\xc6\xda\xaf\xb1\x8a\xd5\xa3\x73\x3d\xcf\x2a\x56\x24\xd6\x7e\x75\x23\xd6\x7e\x7d\x15\xb5\x7a\x48\xac\xfd\xba\xd5\x88\xb5\x5f\x63\xed\xd7\x36\x23\xd6\x7e\xc5\x11\x6d\x2f\xb1\xf6\xab\x1f\xb1\xf6\xab\x1d\xbf\x1d\xa9\x39\xd6\x7e\x8d\xb5\x5f\x63\xed\xd7\x58\xfb\xf5\xc1\x55\xc4\xda\xaf\xaf\x41\x9f\x54\x3a\x65\xad\xca\x61\x6d\x53\xbd\xc0\x45\x86\x04\xf9\x8e\xe3\x72\x32\x01\x89\x94\x0b\xdf\xbc\x12\x85\x50\x55\x39\xaa\x68\x99\x8b\x33\xc0\xaa\x66\x12\x68\xea\xa2\xa0\x37\x3c\xee\x12\x2c\xb1\x6c\x55\x1d\xbe\x77\xf6\xf1\x9b\x7e\x4a\x25\x74\x0b\x5c\xc3\x35\x7f\xe4\x49\xf7\x00\xa6\x1a\xe0\xeb\xa2\xf2\x1d\xdc\x93\x4c\x28\x17\x76\x88\xc0\x4a\x66\x94\x73\xf0\xca\x23\xd3\x68\x94\x19\x03\x70\x22\x0a\xe0\x96\x7e\x53\xa2\x18\x9f\x66\x40\xa8\xd6\x34\x99\x8d\xcc\x9b\xb8\x07\x76\x1d\x22\xe8\x7e\x51\x5a\x02\xcd\x7d\xb0\x64\x4e\x99\x9d\x8a\xd0\x44\x0a\xa5\x48\x5e\x66\x9a\x15\xd5\x64\x44\x01\x46\x39\x5b\x46\x55\x01\x03\xc3\x4b\xea\xb8\xc2\x41\xfd\x36\xb7\x2c\x11\x56\x8a\x41\xd5\x75\x80\xa5\x2d\xf3\x42\x2f\x88\xf9\xe4\xcc\x95\xbb\x93\x4a\x93\x24\x63\xc8\xad\xf1\x8d\x36\xa1\x0c\xe7\x1b\x78\x5e\xcd\xdd\x4a\x95\x5b\x2a\x4f\x51\x6c\x2d\xb4\x22\x18\x86\x57\x4f\xe8\xa6\x4a\x99\x72\x62\xbe\x1a\x10\xea\xeb\xa0\x58\x40\xfb\x95\x22\xa8\x3d\x67\xb1\xb3\xbb\x9f\x82\xe9\x82\xe2\x69\x06\x37\xad\x35\xac\x46\x74\x8c\x3b\xf5\xc8\x39\x68\x84\xd8\xd6\x02\x05\x86\xbb\xac\x1c\x03\xdc\x00\x0e\x73\x83\x03\x90\x80\xe1\xaf\x74\x03\xd6\x7f\x76\xa4\xd7\x54\x4e\x41\x57\x41\xb9\x6d\x63\x35\x9b\x05\x22\x82\x2a\x87\xa1\x1e\x52\x43\x0c\x81\x73\x29\x52\x8c\xb8\x77\x55\x24\x0c\xce\xac\x29\xa3\x68\x17\xe8\x0a\xe0\xac\xbb\xc1\xcb\x45\x36\xd4\xa9\x7a\xa9\x2a\x68\x02\x8a\x1c\x9c\x5f\x9e\x0c\xc8\xe5\xf9\xa9\x8b\x67\x12\x93\x75\x69\x7c\x8e\x84\x59\x04\xdc\x54\xd0\x91\x29\xff\x8e\xbb\x19\xd5\xb8\x9d\xc1\x8b\x50\x12\x9d\x51\xe9\x02\x15\x7d\xe5\x6b\x72\x21\x34\xac\x2b\x94\xe1\xa9\x01\x8a\x5f\xce\x06\xe1\x30\xcd\x8a\x33\xed\x09\x60\x4b\xb5\x25\x90\x8f\x3e\x80\x52\x74\x0a\x97\x2d\x1d\x58\x9b\x94\x73\xf4\x61\xd5\x67\x14\xa9\x42\x66\xd3\xd7\xaa\x5f\xea\x88\xb7\xa6\x44\x4c\x72\xbb\xa6\x6a\xbf\xef\x24\xd3\x1a\xf0\x7c\x63\xf1\x24\xf4\x81\x2f\x27\xa8\xee\x2f\xc5\xcd\x7d\xf0\x93\xd4\x0f\x1b\xfe\xce\x53\x1b\xc5\x36\x06\x32\x96\x0c\x26\x64\xc2\x30\x34\x0e\x83\xd5\x06\xb6\x1c\x08\xb5\xc6\x25\xa5\x40\xe2\x7a\x9c\x5a\xe3\xd7\x35\x22\x3f\xba\x85\x69\x59\x72\x5b\x01\xdd\x49\xdc\x98\xc2\xc5\x26\x64\x8a\xc1\x6e\x4e\x71\xf8\xe3\x9b\xff\xf8\x13\x19\x2f\x8c\x74\x83\xa8\xad\x85\xa6\x59\xf5\x91\x19\xf0\xa9\x81\x95\xa5\xd4\xcd\x24\xa4\x0a\x02\x58\xa3\xdc\x2e\xfc\xed\xef\x6f\xc7\x4d\x71\xeb\x28\x85\xf9\x51\x00\xbf\x61\x26\xa6\x23\x72\x42\xb9\xc1\x75\xa3\x46\x14\x29\x5a\xf2\xdb\xd7\x0d\xed\x0f\xcd\x44\xc6\x92\x45\x77\xb2\xe3\x74\x13\x32\x13\x77\x56\xed\x5b\x83\x3d\x75\x38\x6c\x21\x8a\x32\xb3\xce\x8c\x6f\xaa\xf4\xbd\x52\xc1\x6a\x8e\xce\xda\x73\x81\xe6\x77\x37\xc5\xd2\xd1\x76\x31\x8e\xfe\x95\xc2\xc5\x7e\x3b\x03\x71\x55\x9e\x06\x75\xe2\x6f\x68\x96\x8d\x69\x72\x7b\x23\xde\x8b\xa9\xfa\xc8\xcf\xa4\x14\xb2\xb9\x96\x8c\x1a\xc6\x39\x2b\xf9\xad\xad\x4b\x5d\xa5\x10\x8b\xa9\x91\xb2\x8b\x52\xfb\x4a\xa3\xeb\x3e\xd8\x26\xa4\x7a\x7e\xec\x35\xe2\x7a\x16\xb8\x67\xb5\xda\xeb\x52\x29\x2c\x46\x86\xf3\xab\x10\xd9\x7e\xff\xe6\x8f\xff\x6e\x51\x97\x08\x49\xfe\xfd\x0d\xc6\xc1\xaa\x81\x3d\xc4\x48\x17\x8d\xcc\x90\xd3\x2c\x33\xe4\x35\x44\x4a\x03\xe8\x75\x48\xf8\xd9\x71\x50\x77\x47\xb7\xad\xa5\xea\x9b\x9b\xbf\x22\x4b\x60\x5a\x41\x36\x19\xd8\xac\x81\x4a\xc3\xdd\x47\x19\x61\xdf\x51\x1f\x4c\xdd\x78\x06\xb2\xf0\x5c\x64\x65\x0e\xa7\x30\x67\x7d\x34\x9e\x68\xcc\xe6\xad\x3e\x19\x53\x98\xa0\x31\xce\x44\x72\x4b\x52\x77\x31\x88\x68\x5a\x2e\xb1\xda\x1e\x0a\x6d\x63\xbb\x3a\xc4\x74\x6d\xfc\xfe\x46\x34\x57\x4e\x8b\x82\xf1\xa9\x4d\x4e\x92\xf4\xae\x01\x0c\x3c\x93\x98\x0f\xdc\xb1\xde\x42\x67\x8f\x43\x57\x7f\xc3\xd0\x7d\x91\xa1\x9b\xad\xa7\x68\x1d\xcd\xd4\xdd\x5d\x51\xaf\xbe\xbd\x8d\xba\x81\x10\xf5\x84\xfe\x34\x14\xf8\x6f\x1b\xa9\xbf\x22\x2e\x57\xe2\x63\x85\x18\x56\x00\x30\xe8\x83\x24\xb9\xbd\xed\xbd\x07\x43\x77\xb7\x50\xb6\x06\x5c\x78\xe5\x60\xc8\xa9\x76\x02\xa1\xd7\x20\x28\x29\x40\x2a\xa6\x0c\x5f\xfe\x01\x0f\xd4\x49\x46\x59\x1e\x58\x83\x9f\x06\x08\xf6\x70\x63\x65\xcc\xee\x94\xf2\x52\xa4\x6e\x42\x24\x85\xb6\x2a\xe8\x1a\xb1\xb6\x29\xd5\xf6\xc8\x50\x9f\x9a\x54\xfe\x50\x43\xb3\x49\x29\xcd\x2f\x15\xa9\xb4\x77\xbd\x26\x02\x89\xdf\xf7\x52\xe9\x63\xb5\xf8\x9e\xc8\x00\x12\x46\xb7\xb9\x4d\x4a\xd8\x50\x1e\xed\x41\x09\x44\x7a\xa7\x07\x8e\x88\x8d\xae\x30\x67\xc2\x3d\x4a\xf6\xdf\xed\x3f\x29\x91\xb4\x20\x92\xa2\xa0\xd3\x4e\x3d\x0e\x96\x20\xb5\x3c\x6d\x98\x08\x6e\xd4\x20\xbc\x5e\x95\x25\xc2\xbb\x20\xad\x0b\x55\x60\x19\x12\xeb\x28\xf7\x00\x76\x0a\x02\xf6\xa0\x21\x77\x74\x41\xa8\x14\x25\x4f\x9d\xa9\xb1\xb2\xf5\x7e\x58\x7a\xf1\x85\xe0\xe0\x7d\x28\xcb\x79\xe4\xe8\xdc\x61\x9c\xbc\x1d\xbd\x7d\xf3\x5a\x38\x15\x7e\xe1\x12\xa7\xba\xa8\x38\x95\xa5\x4f\x4f\xfa\xad\xbe\x1a\x72\x4f\xdf\xfb\xc1\x99\x58\xea\x62\xc7\xcc\x17\x73\xc5\x9f\xee\x24\xd3\x10\x74\x2e\x3a\x40\xc5\xc5\xe8\x87\x41\xd6\xf4\x61\x8f\x35\xbe\xfb\x49\x53\x57\xe5\xf8\x13\xd2\x2d\x47\xa0\xf0\xb8\xad\xb3\x70\xa9\x07\x48\x58\x08\xa8\xbd\x3d\x72\x60\xef\xdc\xb7\x49\xa2\x87\x4f\x8a\x5a\x0e\x68\x67\xf7\x45\x87\x1a\x74\x0d\xc0\x9d\xdd\x17\x14\x6d\x70\x45\x8f\x10\xfc\x2f\x98\xd1\x39\x60\x72\x2c\xcb\xa8\xcc\xd0\xfd\x7c\x6d\xd7\x4e\xc6\xa5\x26\xc0\xe7\x4c\x0a\x8e\xb1\x5e\x73\x2a\x19\x56\xad\x90\x30\x01\x09\xdc\xe8\xa2\x5f\x1e\xfc\x70\x7c\x85\xb1\x2d\x87\xb6\x96\xbd\x5f\x65\xa9\x7c\x79\x89\x70\x25\xc1\x74\x8f\x6e\x9f\x5f\x87\x81\x21\xd2\x5c\xbf\x2e\xf3\x9e\xbc\xd4\xa5\x2d\x98\x7f\x9f\x64\xa5\x62\xf3\xa7\xa2\x24\x2e\x6b\xf9\x94\xb5\xda\xe7\xa5\x0c\xea\x1a\x50\x2b\xc9\xd0\xb5\x0d\xfe\x91\x0a\xad\xfb\xaa\xaa\x69\x15\x86\x43\x38\xd3\x13\xc9\xd9\x74\xa6\x5d\x58\xa6\x2f\x69\xb6\x22\x42\x60\x5d\x87\xa7\x35\x42\x19\xb6\x7b\x9c\x31\xaa\x76\x15\xb9\x56\x32\x0e\xdd\x2c\x18\x44\xc1\x5d\x21\x2a\x9a\x55\xb6\x15\xf3\x22\x6b\x70\x3c\xbf\x74\xde\x29\x0f\x37\xc6\xff\xc7\x06\xad\x54\xda\x85\x0d\x42\xb1\x8f\x58\xab\xe1\x24\xac\x19\xe0\x83\x35\x90\xf8\x63\x95\x15\xb4\x6a\x71\xc1\x87\xb3\xa0\x20\x49\x21\xd2\x1d\xb3\xf1\xda\x2a\x1e\xad\x54\x8e\xf5\x10\x24\x33\x91\xa5\xbe\x2f\xa7\x35\xc9\x8c\x41\xdf\x01\x70\x72\x7e\x89\xf0\x33\x9f\x88\xde\x9e\x0d\x50\xb4\xde\x01\x2c\x3d\x12\x68\xa4\x0d\x78\xee\x8a\x60\x1d\xb4\x92\x2e\x22\x7d\xf5\xa5\x9d\xcf\xfc\x5f\x2a\x98\x79\x8f\x18\x1d\x8b\x39\x20\x48\xd3\x54\x82\xea\x50\xba\xe3\x09\xf4\xd4\x4e\xa4\x94\xb5\xea\xbb\xd0\xf4\x6f\x54\x60\xf3\x16\x22\x14\xdf\xf1\xa8\x22\xe2\x7d\x66\x0a\x76\x7e\x79\xd2\x81\x7a\xed\x7f\xef\xdc\x1b\x66\xaa\xfd\x7d\x45\x58\x91\xd4\xfe\xd4\x11\xa9\xbd\x86\x41\x46\x83\x95\x18\x77\x73\x59\xb5\x15\x13\x03\xa2\xd6\x91\x48\x13\x6e\xa7\x31\x64\xc5\x65\x33\x57\x5e\x62\xa6\xac\x9b\xb8\x01\x0d\xe5\x9f\x08\x01\xe2\x03\x11\x2c\x91\x77\x61\x19\x83\x2a\xc0\x77\x89\x30\xa1\x05\xdd\x87\xf6\x05\x54\x7c\x05\x98\x9f\x0d\x96\x97\xe7\xa7\x7d\xa2\x4b\xc1\xd2\x67\x87\x2e\xbb\xeb\x97\xcd\xdc\xb5\x66\xc9\x07\x37\xa1\x3f\xec\x97\x22\xdd\x20\x26\xd5\x8c\x06\xef\x0f\xbb\x0b\x6a\x41\x28\xb1\x66\xc2\xa5\xbe\xb1\x2d\x80\xb2\x33\x95\x40\x51\xeb\xb2\xcc\xb2\x6b\x48\x24\xec\x6a\x1e\x6d\xee\xff\xf9\xd2\x5c\x9b\x44\x9e\x40\x7e\xc7\x3a\x02\xee\x66\x5e\x17\x78\xab\xb0\x26\xcc\x12\x2c\xca\x0c\xe3\x4c\x29\x5f\x78\x80\xe3\xea\x55\xe0\x8b\x62\xca\xc7\xac\xd8\x10\xa9\xc6\x2e\x28\xa8\x5e\x56\x75\x0b\xa1\x4a\x59\x8f\x29\xe3\x29\x9b\xb3\xb4\xa4\x19\xbe\x08\xa5\xd0\xb0\xa7\x6f\xc5\x21\x73\x5f\xb0\x90\x7c\x23\x24\x81\x7b\x6a\x6e\x1b\x54\x42\x2c\x55\x88\x0e\xa9\x48\x6e\x41\x0e\xac\x28\x76\x8a\x7f\x9c\xa0\xc4\x6b\x4b\xf2\xfa\x75\x18\x5d\xc2\x95\xe9\x6b\xd3\x26\xd8\xf7\x01\xb6\x70\xf8\xc2\x7e\xee\x82\xf1\xe9\x10\x7f\x31\x1f\xe2\xde\x34\x14\x7c\x48\x87\x06\x0d\x5f\x88\xe0\x87\x35\x78\x3f\xa2\x64\x75\xe5\xf1\xc5\xab\x08\x46\x91\x13\xe5\x74\x86\xc0\x92\x39\xf5\x65\xb1\x32\xd0\x58\xf1\xc8\xf9\x75\x6d\x69\x0a\xf7\x6c\xea\xc4\xb4\xb0\x02\x54\x13\xd7\x5e\x88\xf0\xd7\xd6\x42\xb6\x14\x29\x1c\x90\x2d\x07\x23\xbd\x33\x06\x8a\x39\xc8\x39\x83\xbb\x23\xc7\x3a\x87\x77\x4c\xcf\x86\x16\x22\xea\x08\x01\x7b\xf4\x85\x15\x2f\x6d\xe2\xd6\x71\x9a\x3a\xb3\x65\xa9\x60\x52\x66\xae\x5f\xee\x88\xd0\x82\xfd\x00\x52\x61\x5d\xc5\x5b\xc6\xd3\x01\x29\x59\xfa\xf5\x67\x0c\x7c\x61\x9c\xd5\x21\x76\x9d\xa8\xe0\x7b\x47\xe5\x5c\xbe\x30\xfb\x67\xdd\xd2\xd6\x05\x07\x8d\x21\x13\x7c\x1a\x64\x3b\xa3\x78\x71\xce\x99\x5e\x69\xcd\x67\xab\x96\xa1\x8a\x2c\x64\x8a\x81\x8c\x4c\xc8\x86\x3d\xd8\xcc\x87\xb5\x9c\x82\x70\x48\x43\x22\x59\x63\x3e\x0c\x67\x51\x15\x33\x22\x36\x20\xc2\x27\x46\xfa\x0a\x99\xbe\x46\x94\x2d\x59\x36\xa3\x3c\xc5\x3f\x93\x44\xc8\xd4\xad\x97\xe9\x2a\xf6\xd2\x06\x05\xd9\x48\x14\x64\x6b\xd8\x5d\x9d\x2f\xbf\x19\x35\x50\x99\x37\x02\xf5\xbc\xd8\x53\x72\xf6\x8f\x12\x08\xcd\x85\x21\xec\xcb\x85\x9c\x97\x20\x92\xd3\x05\xf2\x56\x5c\xea\xfb\x2a\xd3\xcf\x26\x13\xaa\x01\xb9\x02\x9a\xb2\x20\x21\x7a\x40\xde\x37\x33\xa4\x07\x66\x2d\xd7\x36\x75\xd3\xfd\x64\x57\xef\x9b\xab\x5f\x59\x27\x51\xee\xe3\x8a\x56\x3f\xc6\xec\x8a\xa6\xb7\xc0\xad\x52\x6e\x40\x83\x7e\xb0\x52\xe2\x1e\x24\x33\x48\x4b\xe4\x52\xe3\x05\x99\x30\x5b\xdd\x1d\x45\x05\x36\x9d\x81\xd2\x5e\xb8\x3c\xc2\x58\x9d\xba\x4d\x8d\x5f\x00\xa2\x6f\x10\x69\x5b\x9b\xb1\x72\x8a\xa5\x4b\x85\xeb\x4c\xef\x92\x49\xac\xce\xa6\xca\xdc\x9f\xe5\x65\x48\xab\x91\xef\x69\x6f\x56\x1e\x54\xcd\x66\x4b\xc0\x45\x27\x9d\xb3\xc3\x91\x09\x55\x33\xac\x29\xbf\xbc\x05\x89\x35\xc9\x24\xa5\x34\x04\xc3\x96\x99\xa5\xd8\x44\x16\x3b\x16\x62\xbf\xd1\x75\x86\x9b\x8e\xc9\x03\x66\xb1\xed\xfb\xde\x3f\x1d\x13\x3b\xae\x82\xc1\x0d\xe0\x93\x25\x4a\x60\x77\xd2\x30\x2c\x5f\x5b\xca\xb7\x21\xc7\xcd\x30\x54\xe1\xf3\xb1\xa4\xf6\xfe\xd1\x56\x7e\xcd\x2e\x1c\x90\xca\x69\x77\xcb\xc7\xfe\xb1\x9c\x96\xf6\xa0\x3b\x2a\x5c\x17\xa5\x75\xad\x3c\x51\x6a\xb3\x32\xa6\x51\x67\x4e\x3e\x9c\x86\x29\x48\x61\x6e\x85\x4f\xe0\x1a\x91\x1f\xba\x1a\xa9\x97\xad\xd4\x86\x9a\xd7\xa6\xef\xa4\x3a\x59\x86\x62\x64\x73\xaf\x5f\x54\x6f\xf3\x72\x28\xe3\x45\xa9\x1d\x1b\xac\x35\x4e\x9e\xcc\x28\x9f\xa2\x92\x29\x4a\x33\xdf\x97\x5f\xe2\x8a\x24\xa4\x65\xe2\xaa\xe9\x7b\x94\xfd\xd2\x9b\x6c\x5d\x3d\x2f\xa4\x55\x2a\xa1\x85\x5f\x73\xf8\x59\x6a\xc1\x35\xbd\x7f\x47\xd8\x08\x46\x64\xef\xcb\xe0\xd2\x9e\x7d\x7b\x21\x85\x79\x85\x4b\x7d\xc0\x55\x65\x4c\x63\xf8\xf6\x5e\x78\xf7\x88\x9c\x99\x77\xa0\x1b\xab\x02\x60\x10\x9d\x3f\xae\xc1\x37\x20\x12\xa6\x54\xa6\x99\x33\xb7\xdc\x05\x29\x1d\x15\xc0\xe0\x9e\x29\xad\x2c\x0f\xd2\x1d\x28\x93\xa6\xea\xd6\xd0\x21\x73\xb2\x86\x29\xd5\x74\x18\x1c\xe9\x23\xab\xb7\x0d\x5d\xb9\xcf\x21\x75\xa8\x55\x93\xac\xa3\x2f\x5c\x66\xe4\x90\x56\x77\x31\x23\x91\x63\xe1\xcd\xf6\x72\xce\x4b\xb3\xb1\x75\xa8\xfa\xda\x3c\xbd\x67\x75\x05\x69\x84\x01\x46\xf1\xd7\xf2\x52\x45\x44\x5d\x61\xd3\x75\xe7\xf9\xec\xe2\xe6\xea\xaf\x97\x1f\xcf\x2f\x6e\xe2\xb1\x8e\xc7\x3a\x1e\xeb\x0e\xc7\x1a\xf8\xbc\xf3\x91\xf6\x7a\xd3\x3a\x97\xef\x72\xc1\xc9\x20\x35\xe8\x15\x05\xd6\x9d\xf1\xf9\x0f\x54\xd6\x6d\xec\x9d\xbf\x6a\x8d\x07\xdc\xf7\xb9\x47\x12\x77\xf2\xe2\x23\xeb\x9e\x30\x2e\xae\xc7\x78\xa3\xd0\xa4\xb2\x6e\xd7\xc2\xde\x5f\x27\xbf\x9c\x9f\x9e\x5d\xdc\x9c\x7f\x73\x7e\x76\xf5\xa4\x81\x22\x1d\x0b\x3e\x36\x99\x72\x4b\x2e\x59\x48\x98\x33\x51\xaa\x6c\x51\xf5\xd8\x5a\x4f\x04\x56\x63\x0d\x79\x8a\xb6\x0e\x05\x12\xa3\xae\xd7\x3e\x16\x99\x6d\xbf\xcc\xb6\x19\x37\xd3\xa1\x3c\x4f\x5f\xe8\xfb\x8d\x14\x79\x4f\x28\x7c\x6d\xad\x30\xde\x19\xbe\x0e\x9f\xf6\x5d\x25\x8f\x06\xeb\x71\xc2\x63\x5d\x36\xc4\x08\xa3\x79\xa1\x3b\x14\xc3\xef\xa5\xc4\x6f\x3f\xd5\x70\x6d\xac\xce\x07\x5a\x7c\x07\x8b\x2b\xe8\x58\x05\xa8\x09\x6f\xc8\x20\x31\x8c\x8e\xdc\xc2\xc2\x06\x66\x9e\xf8\x97\x75\xa9\x56\xf4\xff\xb1\xf7\x3f\xdc\x8d\xdb\x48\xde\x28\xfc\x55\x70\x3c\x7b\x5e\xdb\x89\x24\x77\x27\x99\x99\x6c\x3f\x79\x93\xe3\xd8\xee\x8c\x9f\x74\xbb\xbd\xb6\x3b\xb9\x73\xd3\xd9\x19\x88\x84\x24\x8c\x49\x80\x01\x40\xb9\x35\x9b\xfd\xee\xf7\xa0\x0a\x00\x41\x49\xb6\x65\x92\x6e\xc9\x8e\x38\xe7\x4c\xc7\x12\x05\x82\x85\x42\xa1\xfe\xfe\x6a\x23\x11\x92\xaf\x59\x1b\xf4\xea\x2e\xa1\x8d\xaf\x59\x8b\xa4\x53\x7f\x2d\x80\xfc\xda\x25\x04\x3d\xcd\xae\x69\xbb\xd5\x23\xdd\xc2\x1a\x3f\x02\x94\xf3\xf3\x8d\xa0\xd4\xaf\x0e\x57\xc1\x07\x82\x3b\x5e\x09\x8c\xc9\xcf\x6a\x67\x57\x10\x22\x04\xab\x3a\x81\x37\x7d\xd0\xc1\x29\x19\x1d\x91\xa6\x6d\x13\x2e\x82\x4b\xd8\xad\x5c\xdd\xad\x04\x2b\xe6\xf8\x07\x9c\xb9\xf4\x95\x87\x32\xd0\xa1\x73\xd6\xc0\x72\x58\xaf\xfe\x27\x84\x44\x7b\xe4\x9f\xe1\x43\xe8\x35\xad\x7f\xd9\xdd\xfd\xe6\xc7\x93\xbf\x7f\xbb\xbb\xfb\xeb\x3f\xe3\x6f\xe1\x28\xc4\x40\x79\xfd\x16\xc0\x75\x12\x32\x65\x67\xf0\x0c\xf8\xd3\xa9\x6b\x87\x18\x3c\x71\x5f\x40\x45\xf6\x00\xb3\x96\xc2\x9f\x85\x4c\xe7\xff\xd2\xad\x00\x01\x37\xf2\x60\x80\x25\x6a\x51\x59\x84\x57\x77\xc7\x43\x25\x4b\x3a\xde\xaa\x6e\x54\xcf\x8d\x00\x2c\x8d\x90\x64\xaf\x3d\x09\xa0\xbb\xa7\x87\x7e\x10\x50\x2f\x6f\x35\xd3\x3a\x3a\xe4\xce\xf4\x65\xab\x3e\xc6\x78\x75\x28\xda\xc2\x0a\x76\x4c\x30\xa0\x88\x6f\x18\x06\x1b\x39\x1c\xb0\x21\x61\x26\x74\x9f\x3b\x3c\x3f\x25\x53\xa4\xf0\xc6\x10\xc7\x07\x36\x5f\x3f\xaa\x8c\x0b\xe1\xd3\xf9\xba\xdc\x57\x98\x80\xe3\xbf\x77\x18\x09\x3a\x20\xd8\x31\x6b\xd8\xec\xe1\x87\x83\xa4\x28\x7b\xee\x86\x41\xce\x72\xa9\x66\xe1\xcf\x00\x36\xd3\xd7\x46\x2a\x3a\x86\x9a\x1a\xfc\x39\xfe\x2c\xfc\x85\x3f\xac\x3d\x60\xf1\xd7\x68\x0a\x57\x51\xd4\x00\x70\xfb\xfc\x64\x9b\x27\xfd\x86\x88\xb6\xa4\x2d\x8c\x52\xfd\xaa\x33\x64\xf0\xc4\xa1\xc2\x19\xa8\x08\xf6\xa4\xab\x19\xee\x55\xf9\x70\xe0\x0d\x10\x53\x6b\x59\x36\x06\xc0\xab\xae\x0e\xa5\x59\xca\xa7\x5c\xcb\x16\x95\x43\x61\xa0\xdb\x73\x27\x1d\x6c\x09\xe6\x6f\x05\xb7\xd9\xc7\x02\x30\xbf\xc2\x7e\x9d\x13\xfb\x2f\xdb\x34\x39\xc7\xab\xa0\xc6\x30\x25\x5e\x91\xff\xde\xfb\xf0\xf9\xef\xfd\xfd\xef\xf6\xf6\x7e\x79\xd1\xff\xcf\x5f\x3f\xdf\xfb\x30\x80\xff\xf8\x6c\xff\xbb\xfd\xdf\xfd\x1f\x9f\xef\xef\xef\xed\xfd\xf2\xe3\xdb\x1f\xae\xce\x4f\x7e\xe5\xfb\xbf\xff\x22\xca\xfc\x1a\xff\xfa\x7d\xef\x17\x76\xf2\xeb\x8a\x83\xec\xef\x7f\xf7\x1f\xad\xa7\xde\x01\x04\x2f\x5e\x5d\x02\xf1\xd6\x47\xec\x84\xfd\x1e\xb1\x95\x05\x5e\x9e\xbd\xba\xde\xff\x17\x5e\x6a\x46\xf9\x3c\xfe\xb8\xde\x98\x0d\x8e\x09\xa1\x9f\xc2\x93\x83\x4f\xaa\xd7\xda\x04\xd3\xe2\xb9\x9d\x73\x7f\x04\xe7\x8e\x57\xdb\x71\x5d\x2b\x4d\x74\xa4\x64\xee\x2b\xfa\x21\xbc\x81\xb5\x67\xee\xbe\x6b\xd6\xaa\x25\x28\x5e\x5b\x67\xd0\xd6\x19\x74\xcb\x75\xaf\x33\x08\xcb\x11\x36\xd7\x13\xc4\xc4\xb4\x69\x08\x63\x69\x04\xdd\xdb\x3a\x31\xfc\xdd\x6a\x01\xb5\x81\xdf\xea\x3a\x44\xe2\xaa\x4c\x1a\x3c\xd0\xf2\xe5\x31\x4c\x68\xe0\xcf\x05\x6e\x7c\x18\x20\x80\x7e\x32\xd7\xbb\xc3\xd5\x5f\x4e\xed\x14\x02\xd2\x7b\x0d\xbb\x13\xb2\x8a\xb9\x18\x3b\x24\x0b\x3c\x4a\x5c\xf4\x89\x8b\x0a\x0d\x37\x28\x87\x15\x84\x3a\xd5\x5a\x26\xd0\xf8\x08\x71\xf2\x02\x2a\x9f\x9b\x36\xcc\xc6\xd0\x6b\x16\xb7\x62\x47\x78\xf5\xea\x5d\x87\x33\x40\x7d\x15\x53\x0f\x31\x9f\x96\x98\x0c\x82\xe2\x6f\xf9\x18\xcf\x2b\x01\xc1\x32\xa2\x0b\x82\x45\x79\x08\x20\xf5\x83\x85\x4d\x21\x15\x43\x8e\x2a\x2f\x6b\xb3\x66\x96\xad\x4f\xf1\xf6\x67\x66\x88\x6c\xb5\x52\x86\x16\x0e\xcb\xca\xfd\x5c\x3f\x24\x9f\x43\x30\xb0\xfd\xf1\xf9\x87\x3b\x3a\x3b\x3a\x36\xbb\x39\x32\x1f\x10\x3b\xe9\xf2\x98\xec\x22\x58\x52\x28\x36\xe2\x1f\x3b\xda\xa7\x87\x51\x65\x22\x4f\x99\x30\x7c\xc4\xb1\x5f\x6f\xa1\x58\xc1\x04\xf6\xcc\xa7\xc9\x04\x64\xbf\x3b\x29\xab\xe0\xf4\x26\x26\xf3\xa0\xc2\xdd\xad\x28\xbb\x5c\xa6\xec\x6f\xe5\x18\xd9\xca\xb1\xc6\xd7\x27\x92\x63\x8e\x73\x37\x47\x88\x41\xe6\x79\xfb\xd4\xf7\xe3\x28\x8f\x1d\xb8\xb8\x7d\xe5\xf0\x1c\x1a\x5c\x90\x8b\x46\x62\xe6\x1a\x96\xaf\x29\x92\xb1\x29\xcb\x9c\xd2\x44\x72\x2a\xe8\x18\xdb\xf0\x19\x19\x40\x7f\xa4\x0a\x2d\x8e\xe6\x11\x7d\x40\x89\xf7\x95\x5d\xf0\xa5\x92\x59\xc6\x94\x26\x19\xbf\x66\xe4\x98\x15\x99\x9c\xe5\x2e\xf1\x35\x25\x97\x86\x1a\xcb\xd2\x97\xcc\x34\x8b\xf9\xb6\x43\x03\xf1\xc5\xec\x1d\x41\x9f\x63\x75\x3c\xd4\x96\x93\xc2\x15\x4e\xbe\x13\x20\x31\x0e\xa1\xdb\x4a\x8f\x9c\xb1\x29\x53\x3d\x72\x3a\x3a\x93\xe6\x1c\x55\xef\x7a\xb6\x1d\xde\x48\xf8\x88\xbc\xb2\x46\x9d\x36\xc4\x60\xc7\x8b\xa8\xce\x5d\xaa\xda\x00\x15\xde\x5b\x17\x65\x79\x8b\x25\xe7\x30\x52\x28\x38\x6f\x14\xc6\x68\xb5\x4c\xa1\xa5\x50\xeb\x05\x3a\xc4\x32\xd2\x0a\xc9\x37\xe2\x6f\x84\x67\xf0\x08\x66\x60\x02\x72\x41\x14\xd3\x85\x14\x9a\xd5\xe1\x19\xab\x16\x94\x60\xea\xea\x4e\x2d\xc4\xc6\x27\x67\xdb\x33\xb3\x90\xda\x40\xe5\x6c\x37\x8d\xaa\xce\xfd\x70\x50\x88\x4c\xb3\x8c\xa5\xb5\x4e\x65\xd8\x61\x87\xd6\xdd\x03\x09\x34\x67\xf0\x0d\x5f\x98\xab\x4f\xae\x95\x36\xd7\xee\x0f\x5d\xef\x7c\x5f\x19\xdf\x3f\xf9\xb6\x82\xe6\x6a\x63\xc2\x21\x12\x31\xc0\x02\xde\x33\xa0\x80\xeb\xa8\x39\xcd\x44\xca\x6b\x92\xc8\xbc\xc8\x60\xeb\xb4\xd8\x59\x55\x6f\xac\xc0\x4a\x7d\xe8\x87\x7a\x10\xb5\xcd\x82\x0f\xd6\xd8\xdf\xb4\x0b\x1d\x8c\x7d\x64\x49\x67\x7d\x35\xad\x2c\xb5\xab\x0c\xf1\x7e\x29\x82\x2a\x36\x92\xf6\x00\x83\xe2\xec\x80\x3f\x18\x81\xed\x9c\x7c\x64\x49\xd4\x9b\x16\x10\xb0\x12\x8f\x27\x61\x37\x7a\xfb\x9e\xe3\xad\xc3\x14\x5d\x85\x06\x5a\x14\xdf\xc5\xd7\x1c\x68\x20\x8c\xe9\x31\xd2\xdd\x23\xa0\xdd\x04\xd8\x4f\x58\x90\x17\x83\x6e\x04\x1e\xc6\x1d\xbb\x80\x34\x18\x92\xaf\xfd\x58\xd0\xd5\x47\x4a\x43\xf6\x76\x0f\x76\xf7\x17\x7c\x96\x73\x40\xdb\x57\xd1\x2f\x39\x20\x4b\x16\x00\xd3\xc8\x92\xdd\xb4\x47\xb8\xf1\xd9\xd9\xd8\x27\x08\x66\xe5\xaa\x04\x7b\x44\x4b\x62\x14\x4d\xb9\xd3\x7e\xe0\x53\x7b\x93\x51\xa5\x3b\x1c\xf6\x76\x7f\xdf\x75\x6d\x8a\x6e\xa4\xd8\x35\x30\xfd\x01\xb9\x42\x94\x9a\x30\xd0\x4c\x96\xd0\x7c\x13\x49\x50\x64\x3c\xe1\x26\x9b\x81\xa0\x23\xb2\xc4\x4e\x5d\xf6\x98\x71\xd5\x89\x27\x1f\xb9\xf1\x2d\x49\xe4\x88\xbc\xc0\x46\x61\x8c\x3a\xaf\x69\xc6\xa7\xec\x60\xc2\x68\x66\x26\x98\x58\x22\xa4\xe8\x63\xaf\x47\x2b\x81\xdc\x37\x6d\x63\x2c\xed\x5c\x90\xf1\xd5\xc2\x1d\xb9\x38\xa1\x96\xd6\x86\x95\xbd\x3f\x34\xef\x66\x4d\x16\xc0\xc2\xae\xae\xce\x7f\xa8\xb5\xb3\x06\xe1\x6f\x4c\xe1\xd3\x7d\xa2\xa6\xef\x1b\x20\x3b\xba\x09\x70\xb6\xea\x45\x4d\x3a\x14\x61\x6d\x7b\x52\x93\xe5\xe0\x6f\xab\x37\xa3\x26\x7f\x97\x25\x40\x87\xd0\x61\x36\x0b\xb8\x0d\x9a\x19\xb2\x63\x87\xda\xb1\xe2\xc9\x72\xc3\xdf\x18\x4d\x11\x56\x43\x1b\x46\x1b\x69\x7c\xf1\xd5\x59\xe0\x2d\x9a\x5b\xb7\xe7\x40\xa9\x8d\xcc\xc9\xc4\xbd\x76\xbd\x5c\xd3\xed\x8c\x01\xec\x1e\x5f\x0b\xa5\x58\x81\x12\xce\xfd\xe6\xd9\xc9\xaf\x05\xb9\x81\x74\xaf\xf5\x4c\x48\x62\xb2\xc5\x9d\x75\xb8\x40\x62\x21\x4a\x4d\x47\xb2\xb4\x83\x84\x09\xd2\x61\xd2\x04\x69\x57\xfc\x39\x3f\x10\x04\x02\xdb\xe7\x87\x75\x96\x87\x41\x3a\xcb\x35\x20\xcb\x1c\xb3\x8e\x67\xd0\x69\xd3\x11\x11\x3b\x8d\xf0\x93\xf6\xe5\xa5\xf1\x75\x37\x01\xba\x59\x7c\xd2\x25\x05\x8a\x0e\xd2\xc1\x17\x93\xc1\x11\x74\x0a\xca\x35\x51\xb8\x82\x98\xd0\x4c\x4d\x9b\x16\x80\x57\x57\x77\xaf\x2e\x9b\x3b\x0a\xfc\xb5\xa4\xb6\x5a\x11\x11\x1a\x5c\x7b\x50\xd5\x45\x82\x44\xd9\x0c\xae\x1f\xb6\x77\x01\xfb\xe3\x88\x8a\x31\x23\x2f\xed\x2f\xff\xf2\xe7\x3f\x7f\xf9\xe7\x01\x0e\x1f\x32\x1b\x04\x39\x3d\x3c\x3b\xfc\xc7\xe5\x4f\x47\x50\x50\xdb\x96\xaa\x1d\xa5\x6d\x76\x9d\xb4\xd9\x69\xca\xe6\xa3\x26\x6c\x42\x99\x48\x6b\x29\x52\x8f\x17\xc0\x90\x31\xba\xa8\xd3\xfd\x22\x54\x3e\xab\x6b\xd6\xfd\xaf\x76\xab\x6d\xc4\x1e\x33\x49\x71\x29\x93\xeb\x0e\xed\x9a\xdd\xab\xa3\x73\x1c\x32\x32\x6d\xa8\xf0\xce\x10\x2e\xa6\x32\x9b\x02\xfa\x2a\xb9\x3a\x3a\x87\x9d\x37\x80\xff\x02\x47\x14\x58\xd4\x33\x66\xaa\x42\x06\x17\x9e\x0a\x18\xaa\x50\xa4\x41\x33\xae\x0d\x4f\xe0\x77\x95\x9b\xd4\x8e\xd0\x26\x2e\xb5\xb5\x94\x96\x5d\x9d\x5b\x4a\x51\x93\xe0\x87\x1a\x4d\x6d\x13\x0f\x37\xf8\x5c\x72\xe7\x91\xaa\x75\xd1\xde\x9e\x4b\x1d\x8c\xb7\xb9\xe7\x52\xa1\xd8\xa5\x91\x8d\xba\x05\x90\xc5\x48\x08\x0e\x76\x4b\x1c\x64\xc8\x46\x52\xb1\xf9\x40\x48\x14\xd8\x48\x4b\xd8\x84\x54\x40\xf5\x9f\x77\x41\xc9\x5a\xf0\x02\x53\x2e\x7d\x87\xec\xcc\x61\xa2\x1e\xe8\x18\x08\xd5\xb7\x3b\xee\xd9\xb7\x63\x39\xcc\xae\x57\x95\x31\xb8\x66\xcb\xf0\x21\x33\x09\xba\x59\x7d\xfc\xc5\x79\x54\xfd\xf4\xe7\x43\x25\x89\xa2\x7a\x82\x8d\x88\xd9\x47\x6e\x02\xe4\x2a\xd5\x52\xa0\xb3\x37\xea\x89\xcc\x75\x84\xc9\x1d\x05\x79\xf0\x47\xe7\x32\x9d\xef\x39\x3e\x56\x34\x61\xa4\x60\x8a\xcb\x94\x40\x3d\x71\x2a\x6f\x04\x19\xb2\x31\x17\xda\xd3\x0f\xc0\xd9\x1d\xa1\xed\x71\xc3\xc0\x37\xec\xd1\xe2\x06\xe4\xa2\x06\x82\xe2\xca\x93\x12\x59\xed\x68\x37\x8b\xf9\x20\x13\x64\x84\x02\x79\xb1\x1b\x50\x58\x98\xb8\x41\xd2\x3d\x93\xee\x20\xda\x84\x3d\xbc\xfc\x77\xb7\x52\x87\x6b\x4b\xf5\x64\xd2\x2e\xf0\xbb\x0d\x4f\xad\x78\x6d\xc3\x53\x0f\xbb\xb6\xe1\xa9\x6d\x78\xea\xf6\x6b\xe3\xdc\xbb\xdb\xf0\xd4\xd6\xe8\x9a\xbf\xb6\xe1\xa9\x6d\x78\xea\x96\x6b\xe3\xe4\xd7\x36\x3c\xb5\xc2\xb5\x0d\x4f\xad\x78\x6d\xc3\x53\xdb\xf0\xd4\x36\x3c\xb5\x0d\x4f\xfd\x81\xdc\x80\xfe\xda\x86\xa7\x16\x06\xd9\x86\xa7\x22\x62\x6c\x2d\xa5\x25\xd7\x36\x3c\xb5\xe4\xda\x86\xa7\xa2\x6b\x7b\x2e\x35\x38\x97\x7c\x70\xe7\xdc\xda\x65\xed\x6b\xd6\xce\x21\x70\xc0\x13\x17\x23\x92\xa3\x5a\x9d\x13\x3e\x6a\x50\x35\xa0\x88\x30\x3f\x7c\xa9\x8d\x8b\x06\x55\x31\xa6\xa5\xf5\x50\x2d\xdb\xc3\x15\x32\xad\x82\x11\x51\x14\x02\xad\xd3\xe6\x35\x69\x6b\xab\xb6\x6a\x13\x7a\xd8\xe8\xb0\xc3\x86\x84\x76\x3a\x08\x35\x6c\xc3\x0c\xcf\x2e\xcc\xd0\x8d\x8b\xae\x03\xf7\x5c\xeb\x13\xc6\x05\xf3\xaf\x26\x8a\xe9\x89\xcc\x1a\x33\x7a\x8d\xc9\xdf\x72\xc1\xf3\x32\x87\xbe\xb1\x96\x9f\xf9\x34\x64\x0d\x84\xe6\xd8\x4e\xd0\xa3\xa7\x30\x6a\x30\xeb\x1b\xcb\x42\x59\xe7\x84\x82\xaa\xae\xcb\x24\x61\x2c\x8d\x5a\xde\x83\x62\xf6\xe5\x20\x3c\x29\xb4\xd3\x78\xd9\x4e\xde\xb4\x3b\xfb\x11\xa2\x14\x46\xf9\xf2\x8b\x46\x63\xb4\x8c\xf2\x7c\xfa\x08\x4f\x07\x62\xba\xbd\xbd\xd2\xca\x56\xe9\xe2\x94\x68\x6b\xa3\x3c\xb5\x48\x4e\x67\x11\xcd\x0e\x22\x38\x1b\x14\xbd\xd9\x98\x63\x61\x53\x22\x36\x1b\x88\xbe\xda\x41\x80\xa1\x8b\x08\x4d\x77\xd1\x99\x47\x00\x29\x7d\x9c\xa8\x4c\x87\xd6\x70\x47\xd1\x98\x4f\x11\x89\xe9\xe4\xad\xdb\x46\x60\x3e\x5d\xf4\xa5\x9b\xd7\x6d\xe9\xdd\x7a\x16\x11\x97\x0e\xbc\x5a\x5d\x7a\xb4\x3a\xf3\x66\x3d\x5a\x84\xa5\x7d\x74\x65\x03\x22\x2b\xad\x89\xcc\x05\x37\x9c\x66\xc7\x2c\xa3\xb3\x4b\x96\x48\x91\x36\x3e\x61\xe6\x50\xeb\xc2\xfe\xd1\x38\xac\xb3\xd1\xea\xf9\xc7\x13\xea\xc0\x79\x59\xea\x53\xaa\xbd\xfb\xcf\x29\x14\xd0\xd0\x04\x67\xb9\x91\x0e\x3d\xb2\x31\xc6\x20\x26\x63\x77\xb9\x88\x7f\x93\x37\x44\x8e\x0c\x13\x64\x8f\x0b\xbf\x8e\xfb\x91\x19\x58\x59\xe6\x81\xad\xed\xb7\x2f\x5f\xf8\x9b\x9f\x9f\xc9\x0d\xce\x05\xad\x1f\xdf\x03\xe2\x1e\x74\xbf\x0b\xc4\xdd\x38\x2a\xb3\xba\x1b\x04\x5d\x23\x75\x79\xf3\xb2\x82\x17\x7d\x09\xe3\x86\xdd\x46\x45\x4a\x5c\xe1\xc6\xf3\x5b\xb4\xd6\x71\xe3\xe7\x10\x33\xde\xfa\x5e\x48\xd7\xbe\x97\x35\xc5\x86\x37\x50\x6b\x7e\xa2\xf1\xe0\xad\xd6\xfc\x80\x2b\xaa\xff\xfa\x41\xd1\x84\x9d\x77\xae\x70\xf8\xed\x44\xd2\x52\xb9\xb2\xbd\xa0\x77\x84\xcd\x23\x18\x4b\x71\x37\x85\xa2\x38\xa8\x46\x1b\x95\x59\x36\x23\x65\x21\x45\xbd\xf2\x10\x83\x56\xf3\x05\x6b\x76\xb4\x65\x4f\xa9\xb4\xd4\x42\x49\x77\x00\xab\x52\x08\x2b\xcf\xab\x86\x43\xa0\x95\x6a\x94\xd5\x71\x59\x9c\xe6\x63\x3b\x7d\x7b\x98\x42\xc5\x1c\xcf\x59\xd5\x92\xa2\x1a\xd0\xfe\x7a\x24\x55\xc2\x87\xd9\x8c\x4c\x68\x16\xba\x4b\x50\x72\xcd\xb3\xcc\x0d\x33\x20\x97\xcc\x10\x33\xe1\xae\x31\x38\xc9\xa4\x18\xc3\xe4\xa8\xf0\x5d\xcd\x58\x62\x7f\x9b\x64\x8c\x8a\xb2\xc0\xe7\xd9\x63\x7d\x26\x4b\xe5\x9f\xe7\x60\x2d\xc3\x28\x5c\x13\xc1\xb3\x5e\xd4\x3b\xe9\xce\x85\xad\x1a\xd4\x6b\xe6\x6b\x0a\x6f\xb8\x66\xbd\x78\x4c\x8f\xcc\xab\xa3\xce\x19\x85\x92\x53\x9e\x62\xf7\x0b\x4f\x36\xe8\xd2\x8a\xdd\x31\xc2\x7e\x16\x52\xf4\x05\x1b\x53\xd0\x7a\xdc\x2e\xc2\x35\xc3\x71\x30\x14\x27\x52\xe8\x97\x61\xcd\x05\x59\xd4\x4a\x59\xa7\x1c\x3b\x7d\x46\x94\x23\x7b\x42\x12\x09\xc7\x6b\x29\xb8\xc1\xee\xd1\x93\xd2\x90\x54\xde\x88\xfd\x01\xa2\x12\x73\x4d\x28\x19\x32\xe3\x3b\xd9\xfa\xce\x8a\x5c\x31\x4d\x98\xa0\xc3\xcc\xae\x39\x24\x3c\x5c\x2d\x25\x10\x19\x31\x6a\x4a\xc5\xc8\x98\x1a\xb6\x54\x69\xc2\xf7\xbd\x9b\xbc\x5c\x87\x2e\xef\xa5\xd0\xac\x71\x7f\xeb\x8e\x35\xad\xbf\x7c\xd5\x4c\x46\xf0\x9c\xc9\xd2\x7c\x12\x53\xf2\x66\xc2\x93\x49\xac\x19\xf3\x9c\x69\x22\xcb\x39\x1b\xfb\xa5\xfb\xd9\xf2\x15\xda\xda\x93\xcb\xae\xa6\x5e\xe2\x25\xae\xb4\xf9\x92\xe3\xaa\xad\x2c\xb5\x1b\xf0\xf8\xec\xf2\x1f\x6f\x0e\xbf\x3f\x79\x33\x20\x27\x34\x99\xc4\xf5\xe8\x82\x50\x10\x1a\x20\x28\x26\x74\xca\x08\x25\xa5\xe0\xbf\x95\x88\x4e\x4e\xf6\xc2\x6f\xf7\x3b\xc5\x42\x6e\x78\xfa\x42\xeb\xeb\xce\x7a\x2d\x61\x23\x6d\x4c\x70\x90\x9a\x41\x77\x84\x79\xf5\xe9\xc4\x7e\x85\x86\x06\xa8\x5a\x13\x66\x85\x11\x9f\x3a\x31\xec\xc0\xa5\x69\x1a\x52\x2e\x2c\x9f\x5b\xb6\xb0\x47\x15\x1d\x42\xaa\xc4\x84\x11\xc1\x8c\x65\xeb\xe0\xb0\x92\x42\xd7\x80\x01\x4a\xcd\x74\x8f\x0c\x4b\x48\xee\x28\x14\xcf\xa9\xe2\xd9\x2c\x1e\xcc\x9e\x55\x67\xd2\x9b\x43\xb3\xf9\x29\x1d\xbf\x3b\xb9\x24\x67\xef\xae\x48\xa1\x10\x32\x00\xb2\x33\xe0\x7b\x78\xad\x21\xb3\xbf\x70\x3d\x3a\x07\xe4\x50\xcc\xf0\x4b\xdc\xe0\x5c\x13\x6b\x0b\x31\x38\x82\x9d\x0e\xe9\x41\xe1\x77\x5e\x0c\xe0\x7f\x3b\xf6\x2d\x95\x55\x32\x43\xd2\x49\xb2\x90\x3c\x86\x6a\x28\x1f\x66\x11\x35\xdd\xbb\x3f\xab\x6e\x4b\x21\x6d\xee\xdc\x12\x31\xea\xb6\x44\xc3\x52\x03\x79\xb1\xfb\x16\x17\xe3\x2c\xe6\xaa\x66\x62\xbf\xad\x6d\xd9\xd6\xb2\xec\x57\x6f\x70\xde\xd4\xc0\xec\xa4\xeb\x53\x35\x87\x8e\x7a\xa5\x54\xa7\x9f\x37\xa7\x9c\x44\x90\x71\xfb\xcb\xd3\x73\xbf\x03\x9c\x76\x93\xcf\xf5\x4c\x84\x1f\x63\x50\xa3\x47\x5e\x90\x6f\xc8\x47\xf2\x0d\x98\x57\x7f\x69\xdb\x59\xa6\xad\xe1\xd3\xde\xbd\x83\x56\xfd\xe9\x79\x47\x14\xff\xd9\x4a\x27\x3b\xa2\xa5\xaa\x91\x64\xc8\x9d\x3a\xcf\x3e\x1a\xa6\xac\x1c\x75\x2b\xb1\xd6\x9e\x3c\x76\x82\x9f\x90\xcd\x30\x76\x71\x3a\x8a\x5b\x42\x98\x07\x32\x9a\xfd\xf9\xdf\xa4\x36\x67\x4e\x0a\xd5\x1b\x4c\x54\xa3\xe5\xd4\x24\x93\xba\x18\xb3\x8a\x9a\x36\xd5\x06\xd3\x24\x95\xe0\x49\xc3\x3c\xc0\x09\x6f\x91\x89\xb1\x39\x6c\xdc\x2e\x38\x5f\x5b\xcf\xbb\x56\x6a\xce\x81\x02\x96\x8f\x53\xac\x22\x78\x99\x42\xa6\x4e\x27\xb3\xd3\x4a\xa3\x33\xe3\x0e\xa5\xcc\xf9\x6a\x82\xcb\x1a\x78\xc9\xee\xa7\x84\x0a\x4c\xe0\x1e\x31\xa5\x30\x75\x73\x38\x83\x08\x32\x4f\x58\xeb\xc5\x6b\xb5\x93\x0a\x25\x8d\x4c\x64\x8b\xb6\x41\xf5\x80\xb9\x1b\x0e\x88\x80\xce\x5f\xef\x73\x7f\x7f\x7c\xde\x23\x57\x47\xe7\xd0\x4d\xe5\xf2\xe8\xea\xbc\x6e\xa9\xec\x5c\x1d\x9d\xef\xac\x95\x14\xc4\x6b\x56\xaf\xec\x34\x1b\x0c\x52\x73\x3c\x59\xb5\xad\x9f\xd3\xa2\x7f\xcd\x66\x0d\xcf\xd4\x2e\xce\xf5\x7e\x58\xe1\x4e\x5e\x08\xc9\x9c\xd3\xe2\xc1\xa3\x29\x46\x53\xfe\x89\xaa\x28\xdc\xce\xaa\x9e\xb9\xbc\x9c\x22\x97\x53\x96\xa2\x3a\xec\x7f\xc1\x44\x5a\x48\x6e\xf5\xc5\x6d\x8d\xc5\xc3\x7f\xbd\xad\xb1\xb8\xeb\xda\xd6\x58\x6c\x6b\x2c\xb6\x35\x16\x77\x5f\xdb\x1a\x0b\x77\xad\xdf\x0d\x4a\xb6\x35\x16\x0d\xaf\xe7\x15\xe7\xdf\xd6\x58\x3c\xe8\xda\xd6\x58\x2c\x5e\xdb\x1a\x8b\x5b\xae\x6d\x8d\xc5\x2d\xd7\xb6\xc6\x62\x5b\x63\xb1\xad\xb1\xd8\x66\x8b\xdd\x3b\xd6\x66\x66\x8b\x91\x6d\x8d\x85\xbb\xb6\x35\x16\xcf\x22\x27\x86\x6c\x6b\x2c\x56\xba\xb6\x35\x16\xdb\x1a\x8b\x26\xd7\xb6\xc6\x02\xae\xad\xef\x65\x5b\x63\xe1\xaf\x6d\x8d\x05\x5e\x7f\x1c\xad\x79\x5b\x63\xb1\xad\xb1\xd8\xd6\x58\x6c\x6b\x2c\xee\x9c\xc5\xb6\xc6\xe2\x39\xd8\x93\xbe\x07\x5e\xfb\x9a\x81\xdd\x23\x99\x17\xa5\x61\xe4\xc2\x0f\x19\xb4\x48\x14\x0c\x5c\xc7\x1a\x41\xfb\x14\x9e\x44\x8a\x11\x1f\x3b\xc9\x7e\x80\x0d\xe6\xfa\xe1\x7d\xfa\x51\x53\xb7\x27\x98\xbf\x93\xf1\x9c\x37\x2b\xe4\x20\x0b\x0b\xf3\x06\xc6\x8a\x82\x3c\x76\x27\xe5\xf4\x23\x6c\x11\x9a\xcb\x12\x9b\xf2\x25\x6e\xfd\x02\x09\x31\x14\xb6\x71\x2b\x43\xba\x31\x71\xaa\x8a\x94\xf3\x0e\xac\x8d\x82\x1a\xc3\x94\x78\x45\xfe\x7b\xef\xc3\xe7\xbf\xf7\xf7\xbf\xdb\xdb\xfb\xe5\x45\xff\x3f\x7f\xfd\x7c\xef\xc3\x00\xfe\xe3\xb3\xfd\xef\xf6\x7f\xf7\x7f\x7c\xbe\xbf\xbf\xb7\xf7\xcb\x8f\x6f\x7f\xb8\x3a\x3f\xf9\x95\xef\xff\xfe\x8b\x28\xf3\x6b\xfc\xeb\xf7\xbd\x5f\xd8\xc9\xaf\x2b\x0e\xb2\xbf\xff\xdd\x7f\x34\x9e\x72\x6b\x95\xb8\x3b\x85\xb8\x23\x75\xf8\x51\x94\x61\x17\x1d\xee\x68\x2f\x5e\xb8\xd1\xe6\x77\xa3\x3b\xb0\xee\xda\x8d\x5e\x9a\x82\x9a\x17\xc6\xe1\x9a\xc8\x9c\x1b\xab\x1c\x5a\x7d\x90\xc6\x79\x61\xdc\xd4\x8c\x52\x27\x07\x20\xa1\x92\x1a\xec\x11\x1a\x72\xaa\xa2\x3c\x6d\xe9\x35\x3f\xd7\x7b\x35\xf8\x2b\x60\x3f\xf7\x53\x36\xe2\x82\xb9\x38\xd8\x56\x36\xdc\x7f\x6d\x65\xc3\x73\x94\x0d\x9a\x25\xa5\xe2\x66\x76\x24\x85\x61\x1f\x1b\x79\x58\xea\xa2\xe1\xb2\x3e\x20\xc1\x7d\xe6\xaa\x28\xdd\x77\x44\x16\x98\x40\x39\x57\xce\x1a\x52\x70\x55\x29\xc0\xc0\xc4\x2a\x19\x66\xd0\xfa\x03\xbb\x07\x72\x22\xe7\x1f\xe2\xed\x39\x34\x33\x7f\x2b\xf9\x94\x66\xd6\xda\xad\x7e\x71\x0e\x16\x4c\xfc\xa3\x55\xf7\xbc\xa1\xfa\xba\xda\xf0\xac\x6f\x75\xe8\x30\xe7\x03\xff\x4a\xf0\x11\xfb\x68\x9e\xa2\x96\x06\x0a\xd2\xb9\xe2\x53\x9e\xb1\x31\x3b\xd1\x09\xcd\x40\xae\x75\x73\x56\x1c\xde\x32\x3a\x2c\xbc\x92\x99\x26\x37\x13\x06\xdd\x95\xa9\x77\x01\x40\x85\xcb\x98\x72\x41\x72\xbb\x44\x85\xff\xb1\x46\x5f\x82\x15\xff\x05\x55\x76\x81\x83\xcf\x00\x4c\xe4\xa1\x94\x99\x4b\x1d\xce\x66\xd5\xf8\x2e\xf7\x5e\xc8\x7f\x08\x76\xf3\x0f\x3b\x9a\x26\xa3\x8c\x8e\x83\xab\x40\x33\xb3\xe0\xed\xab\x86\xbe\xf5\x05\x20\x2f\xb7\x64\x84\x66\x37\x74\xa6\x2b\xc7\x49\xdc\x07\xfc\x15\x79\xb9\x0f\xec\x4c\x35\x09\x63\xa4\xe4\x8b\x7d\x88\x25\x1e\x1d\x9e\xff\xe3\xf2\xef\x97\xff\x38\x3c\x7e\x7b\x7a\xd6\xee\xa4\xb0\xef\xce\xa8\x68\x34\x46\x42\x0b\x3a\xe4\x19\x6f\x73\x40\x2c\x64\x9b\xc4\x83\xc2\x11\x9c\xa6\x07\xa9\x92\x05\xd2\xc9\xfb\xa8\xaa\x93\xb2\x6e\x05\xc7\x95\xc9\xb0\x3c\xa3\xfa\x80\x63\x45\x85\xa9\x9c\x35\x15\xc9\x55\x29\xac\x61\xfd\xc4\x13\xf3\x69\xda\x5d\x52\xfe\x61\x9a\xb2\xb4\x46\xbd\x67\x97\x04\x78\xe4\x5f\x6e\x56\xd5\x68\x93\xf3\x77\x97\xa7\xff\xcf\x1c\x1b\xce\x8a\x76\x39\x4f\xdd\xd4\x85\x29\x59\x74\xb6\xba\x17\xae\xee\x68\xbb\xbe\x1b\xb1\xbe\xe1\xac\xea\x26\xd2\x7e\x51\x8a\x3a\x8c\x47\x35\x3e\xc9\x65\xca\x06\xe4\x3c\x78\xe9\xeb\xdf\x46\xe5\xbd\x54\x31\x62\x6f\x11\x86\xd3\x2c\x9b\xc5\x0a\x92\x91\x58\x4c\x53\xab\x4c\x8e\xe5\xf0\x88\x66\xba\xa5\x30\x6d\x73\x32\xd9\x43\xf8\xad\x35\x26\x3b\xa1\x66\x18\x8d\xa4\x4c\x48\xe3\xb4\x52\x3b\x4b\x28\xd6\x56\x32\x21\x68\xb9\x46\x69\x51\xb5\xd3\x45\xa3\xa3\xdf\x1f\x4c\x5c\x7b\x5a\x9d\x87\x91\xd1\xcb\x5b\x6a\x36\xaf\xdd\xba\x83\xa9\xb2\x65\xed\xe8\x8a\xd1\x14\x6a\xd2\x0a\x6a\x26\x98\xd5\x90\x53\x7d\xcd\x52\xfc\xc0\xe9\x35\xc1\xcd\x6f\x47\x0c\x8f\xba\xb2\xf3\xf6\x3e\x7d\xd0\x67\x30\xd7\x02\x62\x01\xcd\x40\x37\x48\x17\x5b\xc0\xbe\xd3\x3b\x91\xcd\x2e\xa4\x34\xaf\x43\x2d\x56\x27\x0b\xf8\xb3\xd3\x14\xeb\x6e\x58\x50\xa5\x20\x09\x21\xed\x03\x31\x81\xa5\xe3\x32\xb0\xe3\x6a\xc1\xd6\xcc\xd0\xaa\x14\x87\xfa\x07\x25\xcb\xc6\x27\xc0\x82\xa2\xf5\xc3\xe9\x31\xec\xe3\xd2\x45\xd9\x84\x51\x33\xa8\x3a\x5d\x04\x0c\x0a\x3a\xed\x7b\x17\x27\x8c\x39\xb2\x0a\xe9\x90\xb7\x74\x46\x68\xa6\xa5\x57\x8e\xb9\x58\x6a\x40\x39\xeb\xcc\x7e\x3d\x94\x66\xb2\x60\x96\x59\x76\x5e\xfc\x5d\x2f\x0a\xba\x55\x08\x46\x5c\x2c\xfc\xdc\xd0\x6b\xa6\x49\xa1\x58\xc2\x52\x26\x92\x96\xab\xb6\xee\x50\x13\xac\xfc\x99\x14\x76\x5b\x74\xb2\xf6\xa7\x21\xc6\x08\x8e\xb0\xfa\x4a\x43\xb4\xd2\xd9\x1d\x14\x62\x96\xb0\x29\x4a\xcd\x14\x06\x58\x55\xc9\x70\x21\x7e\x2c\x87\x2c\x63\x06\x8d\x21\xc0\x9d\xa0\x06\x0d\x69\x9e\xd3\x31\x23\xd4\x04\x46\x31\x92\x30\xa1\xad\xb8\x41\xd7\x9b\x21\xa9\x64\x55\x01\x25\xd5\xe4\xfd\xe9\x31\x79\x41\xf6\xec\xb3\xf6\x61\xf9\x47\x94\x67\x10\xce\x34\x54\xcd\xcf\x91\x8f\xfc\x10\x30\x25\xe0\x3d\x22\x15\x6e\xd1\x1e\x11\x92\xe8\x32\x99\xf8\x39\x59\x8b\xcb\x1b\x6c\x2e\x9f\x0f\x9c\xfa\xcf\x90\x55\x5b\x0b\x98\xf7\x9a\xa9\xce\xe4\xcb\xfb\x06\xf2\x25\x56\x21\x2c\xcf\xd5\xa9\x87\x8c\x95\x33\x43\x53\x6a\xa8\x93\x3b\x55\xd5\xf5\x73\x5c\xd2\x75\x4b\x1f\xcd\xde\x70\x51\x7e\xc4\x8c\x95\xee\x8c\xfc\xcb\x13\x18\x96\x24\x9e\x68\xb0\x68\xb4\x28\x32\x8e\xf5\xce\x73\x19\x54\xa7\xb5\xa5\xee\xdd\xa2\x22\xc1\x36\xa7\x59\x26\xad\x78\xb3\x27\x3b\x15\xa9\xcc\x17\x1e\x66\x15\x28\x56\x03\xba\x1b\x90\x67\xc9\x3c\x6b\x77\x47\x64\x6c\xca\x5a\x60\xba\xcc\xe3\xf2\xd9\xd1\xac\x2e\xe6\x17\x14\x86\x27\x19\x1d\xb2\x0c\x4f\x16\x64\x20\xbd\xc8\x40\xeb\xce\x42\x54\x32\xeb\xae\x06\xe3\x42\x66\x0c\xd3\x7a\x3c\x21\xec\xf0\x4f\x82\x0e\x30\x48\x57\x74\x00\x43\xa6\x46\x07\x30\xc9\x9e\x02\x1d\xca\x16\x07\x2d\x99\xa7\x83\x3d\xb5\xeb\x74\x80\xa3\x73\xd3\xe9\xa0\x59\x92\xc8\xbc\x38\x57\xd2\x9a\x5c\x9d\x1d\x2d\x6e\xd8\x2a\x56\x84\x36\xf9\x92\x24\x1c\x10\xe5\xf5\x9b\xa9\x8a\x12\xfa\xa8\x41\x19\xef\xb3\xfa\xfe\x7f\x71\x87\x64\x2b\x7a\xe6\xcf\x21\x3f\x4a\x2d\xac\x64\x7f\xe9\xbe\x78\xe2\x70\x02\x2d\xbc\x64\x9d\x1c\x26\x32\xa1\x19\x40\xee\xb5\xe3\x18\x32\xcf\x35\xf3\x03\x47\x59\x98\x10\x5a\x82\xcf\x7c\xdc\x1f\xd0\xd7\xe0\x13\xe7\xfb\x12\x32\x65\x51\x08\x12\xd3\x47\xaf\x30\x5b\x0f\xee\xf3\x09\xa0\xf6\x54\xf7\xd1\xc0\xb4\xf6\x6b\x23\x1d\x02\xcc\xdb\x00\xe4\x67\x27\xc8\x44\xca\xc5\x18\x3c\x3a\x3d\xa2\x58\x86\xa9\xa3\x6e\x0f\x5f\xa3\xf9\xb5\x0b\x1c\xed\x07\xf5\xec\xec\x1f\x0d\x9a\x10\x97\xc2\x8d\x0c\x4e\x0e\xaf\xdf\x8c\x50\x5a\x72\x4d\x76\xde\x78\x02\xb4\x40\x3e\xdb\xc4\x03\x62\x07\xdf\x30\xac\x26\xfa\xd8\xae\xb9\x48\x5d\x96\x65\x8d\x58\x01\xa3\x16\xb5\x50\xc8\xdf\xe5\x69\x2c\x1a\x5e\x91\x0f\x82\x04\x62\x91\x7e\x63\xf6\xb8\x40\x85\xd5\xbb\x97\xfa\x77\xbb\xfc\xc2\x43\xe6\x87\x79\x2f\x60\xed\xed\x73\xfb\xd6\xec\x5d\xbc\xcf\xbf\xcb\xce\x3a\xd7\xf5\x86\x8b\x54\xde\xe8\xae\x6d\x88\x9f\x71\x58\xaf\x50\x27\x96\xad\x0d\x17\x63\x1d\xdb\x11\x34\xcb\x6a\x6e\xd8\x65\x86\x84\x5f\xe1\x80\x48\xbc\xa8\xc0\xcf\x65\x87\x6f\x8d\x80\x07\x5c\xe3\x5c\xd3\x23\x65\x5f\xc5\x70\x9a\x5d\x16\xcd\xa1\xd9\xc8\x3c\x1b\xfc\xf0\xf6\xf2\xb0\x3e\xb4\x95\x67\x37\x80\x78\x6d\x89\x6d\xbf\x27\x34\xcd\xb9\xd6\xe0\x06\x62\xc3\x89\x94\xd7\x64\xcf\xa7\x6d\x8c\xb9\x99\x94\xc3\x41\x22\xf3\x28\x83\xa3\xaf\xf9\x58\x1f\x38\xa6\xed\xdb\xd9\xef\x13\x2e\xb2\x90\x8d\x02\x66\xa4\x30\xda\xbb\x31\xe0\x21\x49\x98\x05\xac\xad\xc3\xeb\x74\x51\xe6\xc5\x69\x22\x42\x27\x67\xd9\xfa\x01\x67\x16\x97\xe7\xac\x25\x76\xc6\x3d\x4b\x04\xef\xee\x4a\x53\xe2\x32\xaa\xa5\x74\x44\xed\x6d\xed\x44\x72\xda\x41\xc2\x74\x77\xa8\x3c\x7f\xab\xc6\x24\x29\xc3\xea\x09\x06\x59\x27\xf4\xd6\xe4\x26\xf0\xca\xee\x42\x11\x9e\xfb\xe9\x6e\xac\xd1\x42\xd4\x07\xcb\x3c\xac\x3d\x90\x15\x13\xda\x47\x23\xd9\x8a\x24\x90\x61\x5e\x07\x98\x48\x21\x5d\x72\xba\x3d\x05\xa5\x00\x96\x06\x6b\x01\x03\x41\xb0\x26\x4e\xc6\x46\x53\x3d\xaa\xe2\x83\x71\x0c\x09\x8a\x78\x10\x04\xa0\x9a\xc3\x0d\x37\x13\x8f\x70\x5f\x0b\x38\xc1\x4c\x14\xd3\x10\x3d\x10\x84\x29\x25\x95\x4b\x84\xf1\x5e\x5b\x18\x09\x44\x31\x64\xd2\x58\x26\xa1\xf6\xaf\x5d\x1d\x87\x28\x2b\x08\x5c\xc8\x13\xb3\xdc\xc4\x46\x23\x96\x80\xa6\x14\x13\x18\xc5\xee\x5e\x85\xdc\xe7\xb2\xbb\x2d\x83\x39\x08\xdd\x9c\x7f\xb4\x4f\x89\x7f\x15\x07\x43\x1d\x62\xde\xf2\xaf\xf7\x07\x84\x9c\x8a\x90\x39\xd9\xb3\xab\x18\xdf\xe9\x53\x7e\x8c\x7d\xc5\x18\x7f\x19\x5e\x20\xf6\x3b\x59\xf5\x4e\x95\x1d\x70\x7c\x1b\x67\x30\x89\x1d\xc2\x9d\x8a\x03\x70\x0c\xbb\x41\xed\xd2\xfb\x43\xbc\x8d\xa3\xd8\xde\xf2\x58\xce\xe2\xa7\x71\xd2\x93\xb6\x72\xce\x95\xc4\x77\x04\x8a\x7b\x19\x8d\x16\xa9\xdf\x21\xdc\x74\x2e\x53\x84\xc4\x08\x25\xfd\xd0\xcb\x02\x20\x3a\xf8\xbf\xbd\x82\x55\x29\x69\x42\x62\x56\x76\x8c\x95\xe1\x30\x41\x53\x62\x75\xe5\xcc\xdb\xf6\x79\x91\x31\xa8\x9e\x8b\x46\xae\x0a\x03\x23\x14\xdd\x5e\x98\x48\x05\xc4\xeb\x10\x3a\x7a\xe4\x5f\xb0\x29\x43\x02\xa0\x07\x0f\x38\x0f\x3f\x47\x13\x8f\x6b\x0f\xa9\x0d\x95\x6d\x46\x7a\xd7\x01\x49\xf9\x68\xc4\x7c\xa2\xa1\x35\xfd\xa8\xa2\xb9\x15\xf1\x9a\x38\x12\x0c\xd9\x98\x63\x26\x5b\x10\x6c\xbb\xba\xaa\x80\xef\xa1\x30\xe4\x86\xe4\x7c\x3c\x41\x46\x21\x14\x2a\x23\x89\x0f\xa9\x65\x92\xa6\x04\x78\x5b\x2a\x72\x43\x55\x6e\xcf\x0d\x9a\x4c\x20\x3e\x47\x05\x49\x4b\x05\x30\x91\x86\xd1\x74\xd6\xd7\x86\x1a\xab\xea\x32\xe5\x2c\x42\x3f\xff\x2d\x94\xf0\x9d\xd7\x16\x4a\xf8\xf6\x6b\x0b\x25\xbc\x85\x12\xde\x42\x09\xdf\x7d\x6d\xa1\x84\xdd\xb5\xfe\x6a\x5f\xb2\x85\x12\x6e\x78\x3d\x2f\x38\x9b\x2d\x94\xf0\x83\xae\x2d\x94\xf0\xe2\xb5\x85\x12\xbe\xe5\xda\x42\x09\xdf\x72\x6d\xa1\x84\xb7\x50\xc2\x5b\x28\xe1\x2d\x28\xda\xbd\x63\x6d\x26\x28\x1a\xd9\x42\x09\xbb\x6b\x0b\x25\xfc\x2c\xa0\x9f\xc8\x16\x4a\x78\xa5\x6b\x0b\x25\xbc\x85\x12\x6e\x72\x6d\xa1\x84\xe1\xda\xfa\x5e\xb6\x50\xc2\xfe\xda\x42\x09\xe3\xf5\xc7\xd1\x9a\xb7\x50\xc2\x5b\x28\xe1\x2d\x94\xf0\x16\x4a\xf8\xce\x59\x6c\xa1\x84\x9f\x83\x3d\xa9\x4d\xca\x1b\x21\x9f\xad\x02\x54\xe1\x32\x43\xa2\xd2\xd6\x61\x39\x1a\x31\x05\x92\x0b\x9e\xbc\x90\x85\x10\x00\xad\x82\x2c\x73\x79\x06\x00\x8b\xa7\x18\x4d\x5d\xc2\xfb\x2d\x3f\x77\xb5\xb4\x80\x50\x56\x65\x6a\x9e\xbc\x7b\xdd\x0d\x2a\x46\xbb\x1c\x45\x98\xf3\x3b\x91\xb4\xcf\x55\xab\x08\xbe\xac\x00\xc3\xd1\x3d\xc9\xa4\x76\x19\xa6\x40\xac\x64\x42\x85\x60\xde\x78\xe4\x06\x9c\x32\x43\xc6\x04\x91\x05\x13\x28\xbf\x29\xd1\x5c\x8c\x33\x46\xa8\x31\x34\x99\x0c\xec\x93\x84\x27\x76\x95\x0d\xea\x3e\xd1\x46\x31\x9a\xfb\xbc\xd8\x9c\x72\x1c\x8a\xd0\x44\x49\xad\x49\x5e\x66\x86\x17\x61\x30\xa2\x19\x24\xb4\xe3\x41\x15\x88\x01\xe9\x25\x55\x0a\x69\xaf\x7a\x9a\x9b\x96\x8c\x41\x81\xc0\x74\xed\x01\x0e\x6a\x5e\x98\x59\xc8\xa3\x63\x64\xc4\x95\x36\x24\xc9\x38\x9c\xd6\xf0\x44\xac\x1d\x84\xf1\x7a\xfe\xac\x16\x6e\xa6\xda\x4d\x55\xa4\xa0\xb6\x16\x46\x63\x56\x5a\x35\xa0\x1b\x2a\xe5\xda\xa9\xf9\xba\x47\xa8\x87\xbc\x41\x42\xfb\x99\x02\xa9\xfd\xc9\x82\xa3\xbb\x8f\xa2\xe1\x22\x9c\xbc\x2a\x6d\xaf\x62\x74\x48\x31\xf6\xcc\xd9\xab\x65\x53\x57\x0a\x05\xa4\xbb\x2c\x6c\x03\x58\x00\xc1\xa6\x96\x07\x58\xc2\xec\xf9\x4a\x6f\xe1\xfa\x4f\xce\xf4\xd1\xa1\xf8\x96\x69\x4d\xc7\xec\xbc\x61\xd4\xe2\x36\x8b\x0c\x02\x17\xd5\xc2\x00\x2b\x64\x58\x9e\x16\x3e\xa9\xd2\x9c\xea\x6a\x10\xc9\x71\x4e\x41\xf9\xb9\x51\xdc\x18\x06\x8b\x0a\xe0\x48\x10\xf8\x9c\x2f\x40\xdd\x9d\x4b\x96\x7a\xeb\x07\xa9\x7e\x6c\x85\xba\x48\x31\x75\x69\xc8\xc8\x50\x71\x36\x22\x23\x0e\xf9\x50\x90\xa1\xd4\x43\xb8\x0f\x8a\x1e\x05\xad\xad\xbd\x2b\x85\xd7\x65\xfd\xbc\x06\xe4\x67\x37\x31\xa3\x4a\x91\xd0\x08\x04\x10\x4a\xb4\xf8\x88\x8c\x21\xc3\xc9\x69\x8b\x5f\xbd\xf8\xcf\xbf\x90\xe1\xcc\x1e\x69\xa0\x59\x19\x69\x68\x16\x5e\x32\x63\x62\x6c\x69\x85\xdb\xb3\x5e\x64\x14\x28\x00\x28\xe6\x38\xf1\x97\x5f\x5c\x0f\xeb\x67\xec\x41\xca\xa6\x07\x11\xfd\xfa\x99\x1c\x2f\xc3\x85\x6f\x9e\x32\xd9\xd0\x24\x5a\xc2\x66\x32\xe3\xc9\xac\x35\xa3\x79\xdc\x19\x32\x91\x37\xa8\xeb\x2f\xe1\x9e\x2a\x07\xb2\x90\x45\x99\xa1\x07\xfb\x75\x28\xcf\x2b\x35\x5b\xac\xc1\x59\xba\x2f\xc0\xe7\xea\x86\x98\xc7\x8b\xc5\xc4\x36\xff\x48\xe9\x72\xbb\x9d\x57\x30\xc0\xcf\x80\x21\xf4\x9a\x66\xd9\x90\x26\xd7\x57\xf2\x8d\x1c\xeb\x77\xe2\x44\x29\xa9\xea\x73\xc9\xa8\x95\x96\x93\x52\x5c\x23\x72\x75\x28\x11\x96\x63\xab\x5a\x15\xa5\xf1\x89\xc4\xcb\x5e\x18\x0b\x4e\xbd\x10\xf6\x66\x50\x35\x0a\xfb\xc8\x2b\x5b\xc7\x95\x4a\x20\x47\xc6\xe3\xeb\x98\xd9\xbe\x78\xf1\xd5\xd7\xc8\xba\x44\x2a\xf2\xf5\x0b\x48\x7e\xd4\x3d\xdc\xc4\x20\xdb\xec\x41\x91\xd3\x2c\xb3\x66\x43\xcc\x94\x96\xd0\xcb\x98\xf0\x93\xf3\xa0\x69\xcf\x6e\x2b\xab\x52\x57\x57\x7f\x07\x3d\x8a\x1b\xcd\xb2\x51\x0f\xab\x02\x82\x59\xb3\x0b\x07\xc3\xae\x93\x3e\x50\x9a\xb1\x01\x0a\xd0\x54\x66\x65\xce\x8e\xd9\x94\x77\xd1\xbc\xa2\x36\x9a\x37\xf5\x33\xae\xa1\x00\x63\x98\xc9\xe4\x9a\xa4\xee\xcb\x28\x8d\x65\x1e\x42\xb5\x39\x15\x9a\x26\xf4\xb4\x48\xe4\xb9\xf5\xfd\x6b\x29\x3c\x39\x2d\x8a\x90\xa3\xaf\xe8\x4d\x8d\x18\xb0\x27\xa1\xde\xb7\x25\x9e\x42\x6b\x37\x73\x5b\x27\x73\xdf\xbd\x91\x95\x9b\x8d\x87\x68\x9c\xc2\xd2\xde\x47\x5d\xcd\xbe\xb9\x63\xb2\xc6\x10\xd5\x80\x7e\x37\x14\xf0\xdf\x98\x9e\xbd\x50\x95\x14\x0a\x5b\x02\x63\xa0\x02\x60\xd9\x07\x44\x72\x73\x87\x6b\x07\xde\xcd\x76\xf9\x4b\x35\xba\x88\xe0\x55\xce\xa9\x71\x0a\xa1\x77\x5f\x53\x52\x30\xa5\xb9\xb6\xe7\xf2\x4f\xb0\xa1\x8e\x32\xca\xf3\xc8\x05\xb8\x1e\x22\xe0\xe6\x06\xe4\xcb\xf6\x92\xf2\x5c\xa6\x6e\x40\x10\x85\x88\xfa\xb9\x44\xad\xad\x6b\xb5\x1d\x1e\xa8\xeb\x16\x95\x3f\x55\xd4\xac\x4b\x4a\xfb\x49\x10\x95\x78\xd7\x73\x12\x90\xf0\x7e\x4f\x55\x3e\x86\xc9\x77\x24\x06\x40\x30\xba\xc5\xad\x4b\xc2\x9a\xf1\x88\x1b\x25\x52\xe9\x9d\x1d\x38\x20\x18\x52\xb7\x7b\xc2\xfd\x94\xec\xbe\xda\x5d\xab\x90\x44\x12\x29\x59\xd0\x71\xab\x1e\x06\x73\x94\x9a\x1f\x36\x2e\xf4\xb6\x66\x10\x7c\x1f\x60\x87\xe0\x2e\x96\x56\x40\x14\x00\x33\x82\xd1\x51\x4f\x60\x67\x20\x60\x3d\xe4\x0d\x9d\x11\xaa\x64\x29\x52\xe7\x5f\x0a\x0e\xbe\xb7\x73\x0f\x3e\x93\x82\x79\xc7\xf9\x7c\x9d\x38\x78\xf4\xb9\x20\x2f\x07\x2f\x5f\x3c\x97\x93\x0a\xde\x70\xee\xa4\x3a\x0b\x27\x15\xca\xa7\xb5\xbe\xab\x47\x3b\xee\xe8\x7d\xdf\x3a\x17\x4b\x05\x66\xcc\x3d\x58\x2b\x7c\x74\xa3\xb8\x61\x51\x6f\xa3\x3d\x30\x5c\xac\x7d\x18\x55\x45\xef\x77\x88\xe1\xdd\x4d\x19\xba\x2e\x87\x8f\x28\xb7\x9c\x80\x82\xed\xb6\xcc\xc3\xa5\xef\x10\x61\x31\xa1\x76\x76\xc8\x1e\xde\xb9\x8b\x95\x81\xfb\x6b\x65\x2d\x47\xb4\x93\x8f\x45\x0b\x8c\xb9\x1a\xe1\x4e\x3e\x16\x14\x7c\x70\x45\x87\x14\xfc\x9e\x4d\xe8\x94\x41\x45\x24\xcf\xa8\xca\x20\xe6\x78\x89\x73\x27\xc3\xd2\x10\x26\xa6\x5c\x49\x01\x09\x3e\x53\xaa\x38\xa0\x52\x28\x06\x95\xd5\xd6\x16\xfd\x8f\xbd\x9f\x0e\x2f\x20\xa1\x61\xdf\x95\x84\xbb\x59\x96\xda\xc3\x47\xc4\x33\x89\x86\xbb\x77\xf9\xfc\x3c\x2c\x0d\x41\xe6\xfa\x79\xd9\xe7\xe4\xa5\x29\x11\x10\xff\x63\x92\x95\x9a\x4f\xd7\x25\x49\x5c\xa9\xea\x31\x6f\xb4\xce\x73\x65\xb3\x15\xa1\x16\x2a\x60\xc1\xb5\x0e\x47\xcb\x3d\x08\xac\xbb\x3a\x60\x56\xc5\x31\x70\xe7\x7a\x72\xb5\xec\x98\x8b\xe7\x21\xcb\x16\x54\x08\xc0\x6d\x58\xaf\x13\x4a\xc8\x94\x3d\x1c\xf5\xa2\x9e\xde\xe3\x86\xc0\x98\x79\x54\x0e\xa8\x93\x09\x4b\x4b\x80\x57\xe1\x1a\xc1\x01\xad\xf9\x40\x2b\x18\x2b\x01\xfd\x19\x4e\x47\xa1\x36\x58\xf4\xc1\x39\x88\x34\xf7\xbf\x57\xbe\x92\xd8\x7f\xa0\xe7\x46\x04\xa3\xd4\x8e\xd5\x23\x54\xeb\x32\xc7\x2d\x81\xf0\xdb\x23\x6e\x74\xe8\xad\xe7\xb5\x63\xbb\x31\x1e\x58\x9d\xd5\x82\xbe\x97\x2c\x03\xe6\x6a\x41\xe3\xdd\xb3\x68\x1c\x24\xb4\xf6\x7f\x39\x86\x73\x09\x13\x10\x6d\x0b\x49\xa1\x12\xbc\xa4\x23\x0e\xed\x2b\xa8\xa3\xf7\xe5\x92\x5f\xa2\xea\x80\x77\x00\x3c\x03\x1d\xb2\x4c\xcf\x0f\x34\xac\x16\xc5\xc1\xfa\x39\xc2\xb7\xec\x0e\x48\xb5\xe6\x63\x01\x7d\xc3\xec\x68\x0f\xec\x10\xd6\xd8\x66\xea\xa2\xfb\x5f\x63\xa9\x56\xcb\xc2\xca\x69\xd1\x77\x56\xaf\x91\x39\x4f\x1e\x30\x92\x9c\x32\x35\x61\xf4\x81\x06\xdf\x5c\x5c\xcc\x8d\x51\xb5\x8e\xd1\xae\xca\xd1\xed\x1b\xff\x10\xbb\xbf\x64\x02\xd9\xf6\xe8\xa7\xf7\xd9\x4f\x14\x58\x04\x1b\x53\x8e\xf9\x94\x09\x0f\xfc\x77\x94\xd1\xd0\x7c\xcc\x43\x25\x39\xf0\xc1\xd2\xc8\x10\xf9\xb0\xe6\x54\x85\x5e\x06\x81\x52\xe7\x74\x8d\xc7\x89\x6e\x71\xad\xcb\x32\x0f\xd6\xbf\xca\x9d\x10\x7c\xc0\xd6\x1f\xbd\xea\x95\x72\x6f\xa0\xd5\xe0\x71\x48\x02\x21\xb2\xd0\x15\x14\x03\x11\xf7\x3f\xc2\xc5\xb5\x2d\x2f\x2e\x1b\xc6\xed\xb9\x80\xe3\x54\x11\x36\xb3\xca\xeb\x8c\x40\x73\x89\xd3\x51\xfd\x49\xbc\x06\x7d\x09\xd9\xd8\xb0\x87\xab\x43\xe5\x5c\xa6\x97\x05\x4b\x7a\x24\x2c\x65\xdc\xb9\xcd\x39\x6d\x30\xb5\x25\xc2\x6f\xc4\xe3\x48\x29\xa6\x0b\x89\x08\x9c\xf1\x63\xe3\x06\xa1\xdc\xd4\x22\xf6\xd8\x88\x00\x2c\xb4\x0a\x2b\xe1\xdf\x4c\xc9\xa5\x82\x60\xcc\xcd\xe0\xfa\x6b\x90\x02\x4c\x4c\xa8\x48\x50\x00\x1f\x5c\xb3\x42\x1f\x68\x3e\xc6\x4d\xff\x97\xaf\xbf\x06\x09\xe0\x49\x72\x70\x71\x72\x78\xfc\xf6\x64\x90\xa7\x4b\x8c\x38\x8f\xf5\x05\x61\xb1\x1f\xc3\x46\x22\xd3\x97\x83\x97\x5f\x63\xdc\x9e\x6b\x04\x20\x89\xe0\xbf\xb0\x26\x6d\x11\xfb\xeb\x5c\xa6\x81\x6e\x2e\x6f\xeb\x81\xd1\xc8\xb5\xca\xa0\x27\xd3\x77\xb4\x61\x46\x6d\xdb\x2c\xda\x56\x99\xb3\x1d\x66\xcb\x16\x8a\x59\xf5\x86\x4b\xd1\x24\xce\x5c\xb7\xef\xe6\x86\xf2\xce\x7b\xf7\x97\x15\xc4\xfe\x69\x62\x6c\x65\xb3\x46\x79\x9d\xc9\x1b\xc8\x0d\xe1\x52\x71\x33\x1b\x00\x54\x8f\x1c\x91\x33\x36\x65\xaa\xe7\x47\x7d\x63\x6f\x3a\x0f\xf7\xc4\x06\xc4\xb2\x3b\xa2\xae\x38\xb7\x6d\xd4\x1e\x19\xc7\x69\x08\x67\x52\x9c\x87\xd9\x85\x61\xdc\xce\xeb\x43\xc6\xe4\xa7\x50\xce\x3c\x19\x5a\xac\x03\xa2\x1f\xbb\x17\x70\x8d\x92\x7f\xa2\x8a\xcb\x52\x13\xf4\x89\xc7\x98\x83\x18\x47\x0f\x24\x02\xd5\xcc\x79\xb9\xc2\x20\x21\x3d\xde\x3b\xba\x02\x7d\x0e\xc3\x79\x73\xb4\xfc\x48\xe3\xc6\x2e\xfa\xd4\x3f\x4a\xf9\x7c\x9f\x05\xb8\x42\x3c\xcc\x96\x9e\x5f\xfe\x44\xd6\xf1\x44\x61\x18\x3f\x0f\x38\x1b\xac\xc2\x8f\xa3\x4c\xf8\xd8\x67\x95\xc1\xfb\xa3\xee\x1e\x7d\x1a\x98\xad\xc1\x92\x36\xd9\xf1\x4d\x93\x1b\x8b\xf9\xf7\x6b\xc1\x16\x75\x50\xb7\x18\x17\xce\xa7\x55\x57\x5b\x70\x07\xf9\x04\x0e\xc1\x7e\xa2\xb8\xe1\x09\xcd\x76\xe0\x08\xf3\x5f\x59\xdb\xdb\x30\x15\x7f\xab\x18\x31\x37\x12\x9f\x42\x33\x72\xcd\x66\x37\x52\xa5\x5e\xbf\xf0\x4f\xac\xd6\x42\x1b\xff\x48\xce\x9c\x2c\x40\x48\x2e\x95\x33\x45\x86\xcc\xbb\x11\xe6\x6e\x9e\x0d\xc8\xa1\x98\x39\x1f\xac\x88\x2b\x2d\xbc\x1a\x31\x9c\xa1\x8e\x83\x5a\x60\x8d\x49\xdc\x79\xe8\x9f\x46\xb1\x06\xe6\x36\x13\xdb\x2a\x90\x61\x17\x78\xed\xc5\xdb\xd8\x52\xb9\x54\x6f\xd8\x1d\x0a\x13\xd5\xa5\xff\xfa\x93\x48\x0b\xab\x9f\x71\xc1\xb4\xfe\xc1\x2e\x65\x1b\x75\xbb\xce\x1d\x14\xd4\x2a\x37\x36\xc8\xc9\x2a\xaf\x8a\xd9\x2d\x45\x7d\xcf\x77\x4b\xa1\x70\xe7\x80\x1c\xc2\x07\x90\x18\x68\x35\x47\x28\x25\xb0\x83\x59\x8b\x77\xae\xb7\x21\xde\x71\x78\x76\xec\x13\xb8\x50\xe9\xd0\x75\xcc\x46\x54\xf9\xeb\x33\x01\x4d\xd5\xa5\x11\xb1\xdf\x4a\x0a\xad\xaa\x76\xae\x54\xc9\x76\x9a\xa9\x7a\x88\x06\x7a\xf0\xe7\xaf\x5f\x80\xb6\x17\x9e\x07\x62\xff\x81\x59\xd1\x4d\x03\x85\x8d\x42\x84\xf3\xd1\xd1\x8b\x98\x1f\x3c\xc1\xbd\xdd\xe4\x3c\x77\x50\xe0\x04\xcb\x14\x68\xde\xc8\xbe\x6c\x14\x10\x6c\x1e\x0a\xec\x57\xd3\xbd\x7a\x78\x27\x84\x36\x51\xbc\xda\x73\xbb\x70\xf5\x55\xa3\xe1\xaa\x60\xa3\xe5\xea\x39\x51\xd0\x1e\xf1\x76\xdd\xc7\x90\x13\x04\x82\x0b\x5c\x23\x20\x1e\x67\x45\x8b\xfc\xa7\x06\xf2\x06\xd2\x7d\x5b\xab\x8a\xbb\x17\x38\x10\x29\x2a\xdd\x70\x21\x8d\x33\xb8\xb9\x41\xef\x70\x5a\xe1\x21\xe4\xc4\xf7\xc8\x3b\xf1\x1a\x93\x04\x7b\xa8\x28\xd6\xea\xb9\xf1\xa6\x4e\x6b\x25\x0e\xfe\xe4\xde\xbd\x8f\x53\x6e\x22\x14\x1e\x4e\xee\xc8\xf2\x6d\x79\xfa\xef\x5e\xcc\x8d\x55\x63\xbd\x9a\x65\xef\x4e\x48\x5e\x75\x50\x70\xe2\x93\x8c\x95\x2c\x0b\xef\x4e\xae\xb7\x43\xa8\x20\x84\xd1\x0b\x8a\xbd\xba\x84\xac\x0f\x1d\x9c\x37\xc0\xc0\xac\x42\x21\x4f\x49\x82\xe6\xbd\x3f\x75\x31\x15\x1c\x3d\x20\xaa\x14\xf5\x56\x83\x91\x43\x76\x27\x63\x63\x9a\xcc\x76\xea\xcf\x59\xe6\xfe\xe6\x90\xa1\xcc\x73\x84\x5f\xc4\xe7\x55\x89\x9d\x90\xff\x09\xfa\x03\xee\x35\x50\x0d\x42\x3f\x58\x7f\xe4\xfb\xca\x84\x09\x15\x29\xb8\x79\x1a\x7b\x16\xfe\xfc\xf5\x9f\xfb\x6e\xb4\x3e\x4e\x65\xbe\xc6\xcb\xd5\x6a\x2d\x75\x27\x7c\xd5\xc8\x15\xf0\x60\xfe\x0b\xde\xee\x4e\x55\xcf\xda\x12\x5b\x7d\x8a\xeb\x02\xd8\x01\xfd\x21\xe1\xf4\x0f\x4f\xbf\x4b\x3b\x5b\x3e\x48\xe8\x41\x1f\x86\xf8\x24\xe4\xaa\xe3\x4b\xb7\xd9\xad\xf3\x50\xd5\x13\x99\xa5\xb0\xaf\x9c\x93\xc9\x3f\x8a\x50\x63\x14\x1f\x96\xd0\x2d\x47\xa4\x00\x75\x5a\xaf\x33\x71\x5d\x39\x06\xa4\x2a\x34\x88\x8d\x67\x60\xfc\x01\x21\x97\xcc\xb5\x54\x8e\xe6\x01\x62\xd9\x93\x12\x0c\x29\xe0\x45\x68\xde\x87\x36\xdb\x27\x72\x48\x35\x3f\xbd\x47\x4d\xbb\xf6\xd6\x3b\xd9\x1c\x06\xa3\x46\x97\x85\x43\x3d\xa0\x19\xca\xc3\x85\x1e\x5f\x73\x07\x19\xa4\x60\x81\x44\xbc\x94\x79\x88\xd9\x5a\x5a\x68\x04\xe9\x03\x5e\xf6\xfd\x5c\x8d\x84\xfa\xa6\xb1\x73\xc5\xde\xd8\x21\x26\xbc\x40\x13\x9c\x9a\xf0\x73\x08\x7c\xd8\xaf\xe3\x72\x55\xe8\x90\xf3\x12\x6d\x60\x79\x03\x4e\xf0\x1f\x4e\x8f\xc3\x1e\xb1\x77\xbd\xbe\x04\x82\x90\x2f\x06\xae\x5d\x97\x19\xf3\x94\x0c\x31\xd8\x65\xc5\xeb\x9e\x60\x37\x98\x3e\xe7\xfc\xc4\x41\x0d\x9f\xfa\xb4\x32\x1c\x2d\x3c\xdc\x0d\xb9\x4f\xbe\x74\x9d\x97\x98\xf2\x46\xfc\x90\xbb\xf4\x9a\x77\x17\xbb\xde\x3b\x7f\xd3\x57\x37\xfd\x7e\xbf\x6f\xe7\xea\x85\xfa\x92\x9e\xb6\x76\xbf\xe7\x32\xe5\xa3\xd9\x1c\x25\x2c\x9b\x57\x8f\x00\x8e\xa4\x62\xe6\x66\xd7\xa0\xd5\x4e\x3b\x3f\x5e\x9b\x0a\x54\xc7\x9c\x47\xb0\xde\x4d\xcb\x3c\xea\x72\x63\xc9\x90\xce\x2a\xd6\x64\xc8\x26\x74\xca\x25\x14\xa6\x02\x8f\x41\xc2\xe0\x2d\x74\xf5\x3e\x1f\xb7\xe8\x0e\xeb\x08\x6d\x72\xf6\xb1\x90\x88\xa4\x08\x09\xb9\xd0\x24\x62\x3e\x98\x02\x6e\x6e\xbb\x29\x20\xaf\xa0\xc6\xf4\x4e\x7d\x40\x34\x11\x4f\x04\x32\xa4\x76\xc8\x30\x9d\xbd\xb9\x65\xde\x1f\x90\x53\xc7\x19\x60\xfe\x09\xe9\x5a\x4d\x10\x29\x08\x2b\x26\x2c\x67\x8a\x66\xf5\x07\xb9\xc2\xa4\x57\x56\x5a\x2a\xcb\x64\x18\xb0\xc8\x69\x81\xc2\x12\x64\x5f\xca\x95\xef\x35\xe5\x44\x9c\xe5\xd7\x9d\x77\xd0\xf1\xf9\x2d\xd7\xa0\xa9\x38\xd7\x07\xea\x95\x3b\xcb\xce\x23\xff\x5d\xc8\xf2\x7a\x78\xe5\x50\x0b\x87\x70\x9b\xfe\xe4\x6b\xea\x4c\xbe\xee\xde\xae\x2e\x8e\x4c\x4d\x9b\xf4\xd8\xf5\xc9\x8e\x76\x7d\xc9\xb7\x1d\xc9\x57\xe9\x48\xbe\x6e\x16\x6d\xca\x8f\xcd\x92\xfe\x5a\xb4\x20\xdf\xc8\xe6\xe3\xeb\x5e\xbd\x27\x2e\x60\xda\xb6\x1e\x7f\x78\xd3\xf1\x55\x9a\x05\x3e\x7a\xd7\xf1\x67\xc4\x35\x0d\x2b\x36\xda\x15\x3c\xb4\xe8\x39\xbe\xd6\x6e\xe3\x2d\x13\x7f\x9b\x77\x18\x5f\x6b\x6f\xf1\x96\x6f\xdd\xbc\x5d\xec\x5a\x3b\x89\xb7\x7c\xeb\xe6\xdd\xc3\xd7\xda\x37\xbc\xc5\x5b\xb7\xed\x15\xfe\xa0\x2e\xe1\x6c\xce\x79\x12\x3c\xca\x9f\x56\x0c\xb6\x29\x5a\x6b\xd8\xac\xbb\xa5\xe4\xed\xa4\x41\xf7\xb6\x35\x77\x97\xad\xb9\x37\x43\xbe\x6e\x1b\x71\xb7\x6b\xc4\xdd\x46\x72\x46\xee\x62\xf0\xcf\xb4\xd5\xa4\x0f\x03\x32\x04\x38\x9f\x6b\xdd\xb6\x2b\xf4\x28\x67\x54\xb9\xae\x66\x73\x8a\x6f\x0f\x56\xc7\xe5\x78\x2e\x1c\x2e\x98\x07\x94\x53\x35\x23\x3f\x9c\x1e\xa3\xfe\x5b\x53\xc3\x85\xf4\x8f\x0e\x9c\x92\x3a\x80\x20\x2a\x66\xed\xd5\xd6\x66\x35\xd6\x8d\x2b\xac\xdb\x62\xd7\xb5\xb2\xb1\x66\x3a\x31\x59\x5b\x96\xb8\xc4\x51\x20\x46\x44\x68\xe0\x0f\x41\x73\xa6\x0b\x9a\x58\xe9\xe7\xee\x80\x40\x6d\x54\x3f\x31\xb0\x96\x8b\x0b\x82\x96\xa2\xc2\x77\xf6\xf7\xef\xcd\x1f\xc8\x7e\x4b\xee\xbb\x62\x22\xef\x95\xc9\x68\x29\x92\xc9\x13\x59\xf1\x25\xc4\x0b\x3e\x72\x4a\xae\x99\x12\x2c\xab\x7a\x86\xfa\x1a\x13\xd6\xa4\xf6\xbd\x65\xe9\x7c\xbb\xc2\xf9\x16\x45\xef\xcd\x5b\x00\xb5\x2d\x97\x6f\x53\x84\xbc\xa4\x2f\xca\x08\xcf\x26\x3b\xa5\x99\x6b\x97\xd5\x70\xf0\xd6\x95\xa1\xad\x9a\xfa\xd4\x51\x20\x10\xc2\x76\x23\xde\xcd\x35\xea\xef\xce\x4d\xe4\x5b\x52\x87\x82\x3c\x1f\xc1\x7e\xa8\xab\xc8\x2b\x2c\x8b\x30\x18\xbb\x7a\xc1\x0d\x53\xc7\x0c\x7e\x1a\x6e\xde\xb5\xf8\x77\xc6\xb9\xa6\x47\xca\x4e\xdc\x70\x9a\x5d\x16\x4d\xdb\xf3\xd6\xd6\xfd\x87\xb7\x97\x87\xf5\x41\xad\xf6\x7d\x03\x49\xb5\x96\xa8\xf6\xfb\x28\x35\xfc\x86\x0d\x27\x52\x5e\x93\xbd\x28\xe5\x66\x52\x0e\x07\x89\xcc\xa3\xfc\xae\xbe\xe6\x63\x7d\xe0\xf8\xb3\x6f\xe7\xbd\x4f\xb8\x00\x30\xb6\x45\x10\x3b\xff\x90\x24\xcc\x02\xd6\xd0\xe5\x26\xb9\x63\x70\x71\x9a\x20\x64\x30\x15\x62\x1d\xf6\xc1\xe2\x62\x34\xef\x16\x7f\xcf\x82\xf8\x6a\xda\x18\x73\xe8\x56\xaa\xa1\x39\xbf\x16\x92\x4c\xaa\xb6\xff\x1d\xd0\xe1\x6f\xd5\x68\x31\x76\x08\x1f\xd5\x60\x4d\x2b\x3b\x23\x04\xca\x76\xa1\xbd\x82\xfb\xe9\x6e\xec\x74\xae\x97\xa3\xd0\xac\x98\x84\xc2\x31\x11\xc7\xce\x87\x2c\xae\x12\x8b\x0a\x36\xe6\x0b\xc5\x9c\xc0\x8c\xa6\x7a\x54\xf9\x4f\x7c\x16\xd9\x28\xa3\x63\x80\x67\x9f\xab\xba\x00\xe9\x08\x2d\x88\xad\xed\x10\xdd\xec\x4b\xeb\x3c\xf4\x30\x20\x1f\x6a\x4c\xe8\xf6\x81\x34\x97\x9e\x0f\xf1\xff\x43\x3b\x6f\xdf\x4b\xbd\x96\xeb\x0d\x56\x7e\x28\x2e\xd4\x96\x77\x30\x72\x6f\x6d\xf6\x98\xc0\x28\x3a\xf7\xaa\x9e\xcc\x90\x1d\x83\x02\x1f\x7e\x4f\x49\xce\x3f\xda\xa7\xc4\xbf\x8a\xb3\xca\x5d\x2f\xe4\xe5\x5f\xef\x5b\x5b\xa6\x32\x7c\x7a\x76\x15\xe3\x3b\x23\x58\x60\x01\x5f\x9c\x61\x5a\x38\xbe\x40\x1c\x26\x70\x08\xbf\x6d\xf8\xbb\x39\x2e\x47\x08\xd3\x75\xb4\xd5\x21\x5c\xe7\x86\xb3\x0b\xed\xcf\xdf\x36\xe1\x3b\x7b\x4b\x17\x21\xbc\xc5\x43\x76\xf3\xcf\x66\xd2\x26\x7f\x50\x4d\x79\xc2\x0e\x93\x44\x96\xa2\x55\xfa\xe0\x31\xb3\xaf\x40\x0d\x4b\x2f\x6b\x63\xa2\xbf\x39\x85\x6f\xb1\x62\x9a\x66\x9c\x62\x4d\x7d\xfd\x4e\x2c\xa6\xaa\xc6\x01\x7f\xf5\xdc\x0c\x1d\xcb\x60\xbb\xdd\x4f\x93\x90\xba\xf0\xfc\x76\x49\x96\x8b\x6f\xb3\x78\xc2\xcd\x51\xd0\xb9\xaa\x17\xd2\x9d\x57\xcb\x35\x37\x54\x5f\x57\x48\x03\x0c\xca\x4d\xc2\x66\x8a\x3e\x77\x2f\xda\xa7\xf8\xd4\x46\xe8\x03\x0d\xa8\x6b\xac\xdc\xb3\x2f\x7f\xa8\x5f\xff\xd7\xf1\x59\xbb\x94\xdf\x00\xb2\x8e\x75\x0c\x13\x37\x74\xd0\xb5\xe3\xf2\xf1\xb8\x0c\xcd\x3e\xb9\x47\x14\x75\xf8\xb1\xae\x77\x48\xc6\x28\xfa\x34\xc8\x5e\x94\x91\xbd\x3f\xb0\x32\xbd\x0a\xf5\xa2\xa8\x77\xad\x3e\x72\x46\x85\x8e\x4a\x0d\x19\x0c\xed\xd3\x19\xc3\x7c\xf0\x20\x74\xab\xed\xcc\xff\x3d\xef\xb3\xac\xdf\x81\xad\xff\x49\x69\xb4\xfd\x1c\x1f\xee\x05\xe6\x0a\x8f\x57\x6c\xcc\xb5\x51\x33\xdf\x84\x64\x14\x4d\xc2\x79\x65\xc2\x2d\xd7\x6c\x46\xfe\xf6\xe3\xc9\xdf\xff\xf1\xe6\xdd\xd1\xe1\x9b\x7f\xbc\x3d\x3c\xfa\xdb\xe9\xd9\xc9\x87\x0f\x97\x7f\xbf\xbc\x3a\x79\xfb\xe1\xc3\x51\xa9\x14\x13\xc6\x95\x5d\x5e\x32\xf3\xe1\x83\xe3\x54\xfd\xe1\xc3\x55\x52\xf0\xe2\xc3\x87\x73\xef\xc4\x40\x78\xe1\xff\x3a\x3e\x03\xf9\x89\xd5\x3f\x21\xe5\x06\xce\x56\x24\x3a\xcc\x7b\x42\x75\x95\x5e\x57\xab\xab\x68\x00\x49\xd5\xf4\xb8\xd3\x13\xaa\x98\x3b\x9a\xcf\xbc\x27\xab\xd5\x66\xb7\x03\x56\x7d\x01\xbc\x87\x34\x78\xc9\xc8\x90\x99\x1b\xe6\xca\xd5\xe6\x8f\xb9\x38\x8b\xf7\x67\x6c\x8f\x83\xc9\xfa\xf6\x28\x5a\x82\x3d\x8e\xca\x99\x24\x53\xce\x6e\x10\x1b\x01\xdb\xbc\x54\x00\xf8\x50\xbe\x8a\x25\x8c\xf3\xe1\x2e\xa7\x24\x15\x32\x0d\x60\xff\x73\x6e\xdd\x05\x97\x6e\xad\x5c\x02\x91\x4b\x58\x4a\xce\x4f\x8f\xc9\xcb\x01\x2a\x39\xa7\xc7\x08\xa4\xb4\x8c\xac\x24\x71\x68\x3f\xf6\x40\xc5\xd3\x77\x49\xba\x78\xc5\x00\x4d\x84\x51\x03\x0e\x28\x87\xa9\xcc\xe9\x43\xdb\x7a\xdc\x53\x78\x80\x4d\x97\x7e\x2b\x69\x86\x3a\xc0\xb9\x4c\x17\x25\xd3\xce\x37\xfe\xa3\x6f\x07\xdf\x84\x79\x7c\x3b\xf8\x06\xda\x39\x79\xb2\x7d\x3b\xd0\xd3\x64\xf0\x8d\x2b\x84\x25\xee\xa6\xa5\xd9\xa1\x0b\x55\x2d\x4e\x9f\xc5\xdf\xc0\xb3\x29\xe8\xbb\x9f\xa4\x4e\xa1\xc3\xbe\x58\x1d\x77\xc3\x42\x2d\x10\x6a\x6c\x13\xc5\xa8\x6b\xd7\x9e\xb2\x8c\x99\xa8\xbf\xfd\xda\xdb\x31\xdd\xde\x9f\xca\x87\xaa\x6a\xdd\xbb\x62\xe7\x52\xd0\x97\xfe\xf0\x4d\xbe\x62\x83\xe1\xcb\xaa\x01\x6b\x83\x0d\xd0\xb2\x22\xff\x41\x61\x1b\x23\x33\x86\xeb\xd3\x66\xa7\x2c\x2d\x88\xda\xd5\xf1\xe8\x4d\x08\xb1\x8e\xaa\xe3\x2b\x0f\xc5\x65\x39\xe2\x2a\xcc\x1f\x2c\x0d\x6c\x5e\x83\xb1\x49\xfc\x06\xca\x94\x66\xc4\x9e\x5a\x06\x3d\x19\x71\x25\xa0\x51\xd0\x66\xe7\x9b\x6b\x36\xeb\x21\x70\x03\x2a\x21\xdf\x46\x98\x82\xa1\xf4\x55\x16\x76\x40\xa9\xc8\x37\xfe\xbf\xbe\x7d\xa8\xb5\xd6\xc2\x8f\xda\xc6\x8b\x8a\x2f\xd5\x3a\x74\x75\x82\xf5\x0f\x75\x24\x07\xa4\xac\x2b\x8d\x30\x12\xc9\x35\x20\x27\x50\xdf\x88\x1a\xa9\xc3\x55\xcb\xb2\xda\xcd\xda\xf7\x48\xaa\xa1\x00\x80\xff\x25\xaa\x8b\x38\x93\x97\xae\xa4\x0e\x90\x59\x46\x4c\x55\x9f\x80\x80\x39\x93\x27\x1f\x59\x52\x3e\x14\x2d\x05\xaf\x56\xbe\xbf\x6b\xd6\xbe\x6b\xc5\x8f\x2c\xa0\xd6\x20\x6d\xac\x16\x1e\xb2\xe2\xab\xdd\x19\xa5\x66\xdd\x4d\xdb\x6b\x36\xd3\x01\x0c\xec\x1a\x47\x77\xd5\xab\x81\x7f\xfd\x41\x76\xf2\x91\x6b\xa3\xff\x8f\x6f\x99\x91\x0f\xab\x66\x25\x14\x73\xa4\xaa\xd1\xfd\x92\x08\xe8\xa5\x81\x8f\xf9\xd4\x04\xf7\x2f\xd0\x9a\xea\xef\x3c\x25\x22\xa8\x37\x6a\xdf\x69\x57\xbb\xec\x1e\x29\xa0\x44\x29\xc6\x0c\xab\xf2\x52\xf0\xc7\xc8\x9f\x48\x43\xa0\xcb\x89\x55\xf2\xea\xc7\x8c\xfb\xc8\xdd\xc4\x01\x3d\x82\x4f\x69\xc6\xd0\xae\xbf\xe1\x59\x9a\x50\x85\x21\x72\x07\x1c\xa3\x1d\x94\xa3\x43\x4c\xb0\x67\x9c\x93\x64\xd5\x2a\x6b\x17\x8b\xa3\xca\xf0\xa4\xcc\xa8\x22\x76\x3f\x8e\xa5\x7a\x20\xbe\x0c\x5e\xed\x5a\xb7\x04\x16\x6d\xd1\xd1\xb0\x2e\xdf\xe7\x47\x9c\x07\xe4\x73\xda\x8b\x35\x99\xa0\xb6\xa3\xbe\x51\xf6\xea\x50\x90\x72\xe4\x65\x53\x10\x14\x31\xa4\x9b\xa9\x39\xc7\xf9\x18\xfc\xdf\xfb\xd1\xe1\x11\x76\xe6\x80\x7c\x1f\xca\x7c\x7b\xa4\xf2\x19\x43\x31\xa1\x7b\xa6\xdb\x36\x6e\xb9\xaa\x4d\x3d\x92\x0a\xfa\xf0\xec\xa5\x12\x7e\xc3\xa6\x3c\x31\xfb\x03\xf2\xff\x5a\x4d\x11\x9c\xc8\x5e\x9d\x74\xdb\x2c\x14\x50\x56\xc0\x72\x2f\xc8\x1e\xfc\x2c\x56\x25\xf7\x7d\xa0\xc8\x75\x1e\x78\x62\xd9\x28\x2d\x42\xd4\x4b\xc2\xd3\x35\x31\x8a\x9a\xe2\x1c\x6b\x84\x93\x5f\x06\x09\x19\x64\x22\xd7\x6e\x97\xd6\x3c\xb7\x21\xce\xe2\x45\x68\x60\x9c\x7f\x81\x8f\x9e\x28\x36\x86\xfd\x87\xbb\xe7\x13\xee\x3e\x23\x0b\x99\xc9\xf1\xec\xb2\x50\x8c\xa6\x47\x52\x68\xa3\x40\x34\xb4\xc1\xf1\xba\x6d\xcc\xa8\xf5\xc3\x44\xde\x10\xea\xea\x90\xe5\x08\x41\xd5\x64\x39\x9e\x20\xd8\x2d\xfc\xd0\xb7\x49\xf3\x53\x74\x46\xa7\x1e\x90\xcb\x00\x66\x0b\x0c\x1e\xb0\x71\x61\x14\x70\x78\xdc\xd0\x99\xdb\x4c\x74\x08\xdd\x72\xab\x84\x20\x3f\x19\x0c\xfd\xdc\xfa\xfe\x20\x95\x0f\xcf\x8e\x1f\x8a\x20\xbc\x46\x85\xf6\x96\x57\x89\x7a\xe7\x43\x0b\xb5\x40\xdf\xa0\x91\x02\xdd\x68\x2e\x9d\xa6\x8a\x98\xa3\x9e\x32\x9f\x50\x37\x6d\x03\xb2\x93\xd3\x8f\x97\xd7\xec\xa6\xc1\x2f\xfd\x8b\xfe\xc8\x1e\x9e\xcb\xd5\x07\x7b\xf4\xbd\xd0\xd4\x70\x3d\x02\xa8\xf1\x4f\xa8\x8f\x43\xca\x7d\x33\x44\x64\xbc\xea\x95\x2b\xf1\x68\xa1\x5b\xb2\xc7\xd5\xab\x31\x8b\xcb\xbf\xab\xec\x20\x3c\x00\xb1\x04\x20\x80\x29\xdb\x1d\x94\xb8\x06\x03\x46\x56\x71\x68\x8c\x54\x84\x5e\xc3\x7e\xd7\x9a\x09\xe3\x6a\x0e\x42\x75\x6e\xef\x37\x17\x8c\x8d\x53\xd9\xda\xe6\x85\x01\x79\x4e\x3e\x5a\xcd\x43\x37\xcb\x34\xc2\xab\xde\x1f\x64\x6e\x50\x0c\x8f\xf9\x04\xca\xb9\x65\xa8\xe1\x74\x83\xd9\x1b\x7f\xd2\x54\xce\x55\x57\xbb\x0e\x43\xa4\x5d\x97\x21\xb2\x24\xcf\xf8\xd6\xd7\x9f\x03\xfb\x8e\xab\xd5\x9c\x53\x48\xf7\x50\x81\x47\x07\x36\x15\xd5\xc1\xee\x1a\xbf\x66\x41\x9b\xb3\x46\x91\xbd\x09\x7f\xd7\x16\xca\xbf\x45\x97\x22\xd2\x41\xa7\x22\x02\xb2\xec\xba\x81\x04\x8c\x7f\xef\x89\xd5\x78\x90\xf6\x3d\x8b\x48\x73\x83\xba\xba\x6a\x0c\x75\x5d\x99\xd6\xc8\x59\x35\xd3\xba\x12\x76\x95\x61\xdd\xea\xd9\x1d\x34\xf2\x20\x2d\x6d\xdc\xea\xaa\x11\x42\x3e\xc0\xda\xa5\x10\x60\x92\x23\xbf\x3b\x96\xda\xbc\xa7\xa2\x47\xce\xa4\xb1\xff\x44\xe6\xef\xb1\x64\xfa\x4c\x1a\xf8\x64\x23\x48\x89\xaf\xd0\x21\x21\x9d\x71\x86\xb8\x5e\x20\x37\x5d\x88\xd6\x9e\x78\x9e\x60\x4b\x0c\x8b\x53\x41\xa4\xf2\x14\x0b\xd6\x85\x76\x43\xc4\x61\x05\x07\x8e\x74\xab\x71\x62\xc7\x89\xe9\x7c\xc7\x70\x6e\x28\xc8\xfe\xc2\x6f\x00\x24\xb3\xc8\x20\x41\x3f\x2d\x15\x62\x95\x5a\x5d\xd3\xb0\x31\x4f\x48\xce\xd4\x18\x1a\x1f\x36\xc9\xab\x8f\xaf\xf6\xe7\x0a\x5e\x2d\x4f\x97\x78\x32\x2d\x78\x09\x8e\x6c\x50\xb1\x3a\x54\x01\x70\x3c\x3c\xd6\x72\x0a\x96\xd4\xff\x04\x1f\xf4\xff\x92\x82\x72\x05\xd8\xa6\x2e\x76\x1c\x7f\xe7\xa2\x2f\xf1\x30\x76\x84\x05\xdf\x12\x15\x84\x61\x21\x90\x1d\x7d\x5e\xf1\xe8\x91\x9b\x89\xd4\x78\x18\x06\xf7\xc7\xce\x35\x9b\xed\xf4\x16\x58\x6f\xe7\x54\xec\x54\x81\xe1\x1a\xb3\x85\x43\x18\x32\x08\x77\xe0\xbb\x9d\xc7\xd3\x55\x5a\x1d\xb6\x5d\x80\xcc\xcf\x4f\xa8\x21\x5f\x39\x9b\xa7\x7d\x2f\xf7\xb7\x38\x50\x64\x9f\x63\x4c\x70\xac\x58\xd4\xc7\x1d\x14\xf5\x1c\xe3\x9c\xa5\x60\x53\x66\x17\x2b\xe5\xda\x01\xb9\xf9\x14\x83\x7f\x2e\x98\x44\xff\xff\x63\x79\x26\x8d\xb7\xda\xff\xe9\xdd\x5e\xc8\x7f\x1f\x79\x5e\xe6\x88\x98\x64\xac\xa5\x90\xf2\x91\x07\x7c\xf5\x99\x0d\x75\x7b\xa1\x6e\xb6\x3a\x3e\x36\x54\x8d\x21\xc3\xd1\xd9\x0b\x9e\xcd\xc6\x99\x1c\xd2\x8c\xe4\x5c\xd8\xc7\x0c\xc8\x6b\xa9\x08\xfb\x48\xf3\x22\x63\x58\x4e\x46\xbe\xec\xff\x5b\x0a\x46\x5c\x34\xbc\x47\x3c\x2d\x5c\x92\x84\x91\xe4\x25\x72\x6d\x05\xfc\x1e\x52\x1d\x6a\x06\x58\x70\x5b\x68\xf2\xf2\xe0\xe5\xc1\x8b\x57\xe4\x77\x62\x87\x7e\xe9\xfe\xfd\xc2\xfd\xfb\x25\xf9\x9d\xfc\x4e\x08\x39\x27\xa4\xf6\x2f\x81\x7f\xfb\x84\x8f\xe2\x39\xbc\xb4\xd3\x4c\x64\xee\x5e\x18\x3c\xb9\xa1\xea\x33\xf4\x8f\x31\xd2\x0d\x0d\x45\x3f\x89\xcc\x19\xcc\xe1\xe5\xff\xf1\xf7\x40\xc0\xd5\x60\x8b\x1f\x98\xd4\x1e\x4c\x69\x9f\xdc\x80\x6b\x2a\xa7\xd7\x68\x96\x1d\x26\xa6\xa4\x99\x7d\xf8\xde\x17\xfd\x17\xfb\x44\x8a\xfa\xed\x53\x2e\xa1\x35\xba\x9b\xe1\xde\xcb\xfd\xc1\xc2\x94\xbf\x58\x32\xe5\xb9\x6e\x37\xae\xe6\xce\x0e\x7a\x3b\xd7\x78\x86\x39\x14\xb3\x1b\x3a\x0b\x6c\xe3\xcd\xd2\x31\x9f\x06\x6c\xf4\x08\x87\x02\x62\x76\xc0\x05\xdc\x23\x03\xe1\xa0\x33\xc2\xcd\x80\x9c\x9a\xdd\x5d\xdf\x5b\xc9\x6a\xcc\x1e\xc4\xfd\x38\x86\x0b\x04\xc2\xc3\xa2\xbf\x98\xcb\xe9\x6d\xd1\x58\xbf\x13\xe7\xe8\x83\x50\xd8\xdd\xd3\x2b\xff\x46\x07\x4e\xf5\x30\x96\xdf\xc1\x56\xf4\xcb\x11\xd6\xc9\x62\xa7\xa3\x01\xb4\xb1\x72\xb4\x77\x09\x23\xa8\x3a\xbb\xdd\xc3\x75\xb0\x9e\x38\xe4\xdf\x27\x34\x8b\x83\x75\x89\x04\x80\x36\xc5\x7c\xa3\xa4\x38\xbd\x28\xf8\xa5\xc8\xcf\xd5\x9d\x98\x56\x04\xf1\x57\x1c\xe8\x5b\x4c\x67\xdf\x19\x96\xc9\x35\x33\xfe\xdc\x51\x90\x11\x51\x94\x86\x0c\x69\x46\x85\xd5\x60\x16\xfc\x10\x46\xe2\x60\xf8\x4b\x60\x98\x25\xfc\xf2\xa9\xe3\x23\x0b\xbb\xa3\xbd\xd0\xff\x79\x7e\xc8\x28\x22\xeb\x1c\x85\x29\xa3\x99\x4f\xa5\x00\x7c\xf4\x00\x58\x25\x76\x77\xab\x7d\x05\x6b\x83\xc2\xaf\x72\xb0\x5a\xb9\x50\x93\xfb\x64\xcf\xe7\x3e\x12\xc3\xb2\x0c\xb9\xa7\xea\x4b\x66\x37\x59\xdc\xe8\x8c\xc3\x08\x75\x19\xb0\xf4\x87\xf5\xee\x68\x18\xd4\xb7\x92\x5d\xcc\x42\xb5\x7c\x8f\x10\x68\x0d\x38\xe6\x53\x2b\x94\x56\x12\x1a\x28\x18\x27\x2c\x2b\x88\x62\x69\x99\xe0\xe0\x84\xe8\x6b\x76\x63\x75\xaa\xea\x4d\x5d\x4b\x21\xcf\xb2\x3b\x35\xa2\xee\x20\x46\xb4\xa8\x8b\x44\x3e\x02\x86\xf4\x1d\x37\xd9\x94\xa9\x19\x29\xa4\xd6\xdc\xae\x03\xec\x25\xc8\x86\x03\xbd\x2b\x20\xeb\x40\x26\x16\x4c\xcb\x8b\xe1\x1d\x27\x76\x77\xac\xa0\xd6\xb2\xb6\x3d\x3e\xcd\x51\xf7\xa5\x3d\x66\xee\x3e\xea\xce\xe1\x7f\x8b\x47\xde\xe9\x88\x2c\xe1\xc1\x30\x97\x1a\xf3\x3c\xe4\x14\xfc\x02\x0e\xab\x2f\xf7\xa3\xc3\xf0\xcb\x83\x2f\x0e\x5e\xee\xd9\xb9\x7e\xb1\x6f\x67\x5d\x3b\xe6\x5e\x86\x63\x2e\xfc\xd2\xcd\x88\xe9\xda\x41\x67\x0d\x30\x6c\xa0\x2b\x55\xea\x22\x3c\x3e\x8b\xce\xce\x48\x1b\x17\x6f\xe3\xb9\x97\x2f\x3d\xe0\xbb\x8a\x59\x6f\x24\xec\x1c\x38\x6f\xb9\x21\x9f\xe5\x52\xb1\xcf\xa2\xfb\x6f\x3d\xa0\x9a\x9f\x3b\x6d\xfb\xa9\x65\x5c\x1b\x68\xaa\x76\xcd\x66\x0f\xd6\x74\xdb\xb8\xd7\xdb\x3a\xd7\x17\xdf\x02\x09\x92\xd3\xe2\x01\xe3\xb8\xbe\xed\x6d\x52\x78\xdf\x38\xc7\x6c\x68\x01\x0f\x8e\x47\xd4\x8a\x5c\x5f\x53\xac\x95\x0a\xf9\xb4\x43\x96\x49\xc4\x39\x75\xa9\x03\x0f\x48\xd5\x0f\xb0\xf0\xda\x48\x45\xc7\xec\xc0\x3d\xf6\xa9\xb4\x83\x70\x5d\xe0\x6b\x5e\x26\x2c\x67\x74\x20\xa9\x3e\xa5\xd9\xc7\x1f\x40\x0a\xd0\x04\xb2\x01\x81\x90\x35\x38\x87\x28\xcf\xf0\x89\x84\xb2\x1a\x54\xbf\xb7\x71\x9c\xd2\x1b\x7d\x92\x51\x6d\x78\xf2\x7d\x26\x93\xeb\x4b\x23\x55\x07\xda\xc5\xe1\xcf\x97\x0b\xa3\xd6\xd6\x54\x90\xc3\x9f\x2f\xc9\x31\xd7\xd7\x15\xba\x3e\xa2\x6a\xd6\x13\xf0\x68\x00\xc6\x71\xb5\x18\x24\xa7\xd6\xfe\x63\xde\xc6\x13\x01\xd7\xb7\xbb\xbd\xf2\x27\x7a\xa3\x19\x4e\x7f\x68\xa7\x6f\xbf\x66\xcd\x45\xf0\xda\x80\x14\xf0\x75\x4e\x8f\xd7\x10\xf8\x1a\xe9\xa6\x6d\x47\xc8\x02\x33\xbd\xe6\x19\x73\x1d\xc0\x00\x12\xa8\x8e\xf1\x0c\x5c\x33\x93\x25\xb9\xa1\xe8\xb3\x02\x99\x3a\x20\x57\xbc\x78\x45\x4e\x22\xbc\x56\x2c\x48\xa8\x0f\x65\xf5\x8d\x80\x1f\xe2\xb2\x04\x80\xcb\xd0\x75\x65\x45\xb0\xcb\x8a\x21\x27\xa8\x4c\xe9\x57\x64\x87\x7d\x34\x5f\xed\xf4\xc8\xce\xc7\x91\xb6\xff\x08\x33\x02\x74\x65\xd7\xa3\xc1\x2a\x75\x62\xc4\x54\x65\xc0\xe0\x0f\x16\x4b\x07\xbb\x67\x52\x72\xf5\xee\xf8\xdd\x2b\x50\xe0\x53\x49\x6e\x98\xef\x62\xe6\x0b\x61\x9d\x34\x8c\xc8\x00\x15\x1d\x89\xcc\x0b\x25\x73\x1e\xa5\xab\xc2\x26\x6b\xc2\xf3\xa4\x0b\x7f\x29\x24\xa5\xc1\xf2\x77\xc2\x41\x90\xed\xeb\x87\x9c\x03\x86\xbf\x8d\x7f\x4e\x47\x44\xa2\x53\xaa\x9e\x23\xcf\x75\xb8\xc9\x72\x8c\x1b\x05\xdb\x71\x55\x3c\x62\xd5\x6f\xf7\xd5\x41\xca\xa6\x07\x3a\xa5\x2f\x7b\xf0\x18\x64\x00\x07\x7e\x1f\xe6\x44\x35\xd9\x79\xb9\x33\x20\x97\xbe\xaf\x79\x2f\x9e\x63\x75\x9f\xb5\x06\xfc\x80\xe0\x56\x7d\xb1\x43\xf6\x30\x49\x1d\x74\x8a\x8c\xf9\x92\xe5\x80\xb1\x01\x3e\xfc\xfd\x46\x2a\x24\xe9\xc0\x7d\x41\x5a\xbb\x30\x88\x6b\x19\xf6\x4e\x64\x8d\x43\x7b\x73\x55\x55\x6e\x0d\x76\x0c\x74\xdf\x32\x12\x2a\x08\x98\xeb\x07\x8b\xa2\xe2\xc2\x3d\xb1\x22\x24\x17\x4e\x3b\x79\x6b\x17\x1f\xbb\xc0\xc3\x00\x77\x32\xcb\x0e\x54\x1f\xed\x6c\xcc\x99\x44\x3a\xa8\xe6\x26\xe1\x68\xe9\x66\x3d\xde\x0b\xfe\x5b\xc9\xc8\xe9\x71\xe8\xd9\xc8\x94\xe6\xda\x58\xc9\x95\xd6\x74\x04\x8e\x8a\xc3\xde\x61\x4e\xff\x2d\x05\x39\xf9\xfe\xd2\x4d\x65\x7f\x03\x09\xdc\x50\x00\xd2\x7f\x97\x8a\x59\xd5\xa8\xb5\x1e\x76\xe8\x47\x9a\xd7\xbd\xec\xe7\xe4\x98\x1a\x8a\x2a\x18\x4a\x33\x59\x55\x98\xc2\x4e\x18\x42\xe6\x8f\x2f\x1f\x6e\xa8\x45\x93\xf5\xab\x41\x96\x83\xce\x9a\x63\x4a\xd9\x9f\xbf\xbf\x38\x5d\x83\x12\x95\xc0\x29\x3c\x7e\x2b\xd3\x8e\x34\x29\x80\xf7\x38\xc2\x51\x49\x6e\x87\x25\x67\x52\xb0\x1e\x08\x3b\x62\xa5\x9d\xfb\xcf\x9f\x15\x37\x0f\xad\x98\xac\xae\xd6\xc7\xbf\x5f\xb1\x4e\xde\xda\x1e\xfe\x67\x51\x65\x3c\xc0\x38\x80\x54\x71\x8a\xc0\x30\x93\x43\xe2\xa4\xc1\x3a\xdf\xf8\xfd\xc5\x69\x67\x2f\xfc\xfe\xe2\x74\x73\x5f\xb6\x43\xe3\x60\xde\x36\xa8\xf4\xb7\x0a\x7b\x75\x5e\xe9\x5f\x5d\xe3\x1f\x74\xa5\xeb\xaf\x8b\xd2\xd7\x5c\x34\xce\x0a\xab\x8b\x8e\x13\x5f\x1f\xe9\x22\x35\x50\x92\x9d\xbe\x22\x79\x99\x19\x28\x7f\x03\xc6\xb2\x9c\xa6\xed\xe9\xed\x59\x8c\x38\x28\x08\x42\x8e\x19\x86\x17\xd2\x57\x3e\x21\x21\xfc\x62\xf9\x0f\xde\x52\x41\xc7\xf6\x76\x38\x0f\x49\x8e\x7f\x46\x1c\xbd\x87\x0e\x74\x11\xbe\xa2\x53\xca\x33\x3a\xe4\x19\x37\xd0\xfe\x7f\x7f\xe0\x15\x31\x8d\xb5\xb0\x76\xca\x6b\x13\x6a\x9d\xaa\xb0\x71\x7d\x10\x28\x98\x64\xcf\x8e\x7f\x70\x63\x05\xf7\xfe\xa0\xd2\x5e\x01\x8d\x0c\x12\xe5\x51\xc5\xad\xa9\xb6\x1e\xe5\x61\x4e\xb3\x6d\xc7\xae\x4d\xd5\x4a\x58\xe6\xd7\x0d\x21\xa0\x17\xd5\x1e\x3b\xd2\x52\xb5\x07\xbe\x70\xa0\x13\xcf\x5c\xf3\xc1\x0e\x52\x2d\x74\x1f\xd8\x32\x0d\x7f\xdf\x56\xfb\xd9\xee\x97\xfb\xaf\x6a\x81\x3b\xa1\x52\x0c\x22\x84\x43\xcf\xa5\x49\xe3\x0e\xba\x74\xa2\xda\x83\x0b\x81\x76\x65\xf7\x4d\x93\x22\x0a\xbc\x5a\x4b\xd7\xc0\xa9\x9d\x10\x02\x61\x57\x1a\x6f\x9c\x96\xef\x93\xb0\x62\x32\x6a\x5f\x03\x79\xc4\x8a\xc9\xeb\xcb\x7a\x28\xc5\x7e\x46\x5e\x5f\x2e\x91\x7b\x98\x2b\x63\xdf\x5b\x63\x80\x65\x57\x93\x8c\x8f\x98\xe1\x8d\x88\xb0\x66\xc9\x97\x4b\xc1\x8d\x54\x7a\x1d\x35\x1f\xee\xd1\xdd\xe8\x5d\x17\x9e\x10\xe4\xad\x1b\x17\x13\x3e\x13\x99\x65\x2c\x31\xae\xe7\x21\x2c\xab\x7f\xf0\x32\x47\x88\x4b\x05\xd0\xbe\xc7\xaf\x73\x7a\x1c\x20\xab\x1d\x5c\x9c\x1c\x1e\xbf\x3d\x19\xe4\xe9\x9f\x26\xf2\xa6\x6f\x64\xbf\xd4\xac\xcf\x4d\x3b\x5d\x69\x8d\x45\x21\x1d\x38\xa0\xcd\xa4\x9b\x05\xac\x10\x89\xde\xeb\x0a\x33\xcc\x07\x7e\x95\x94\x66\x11\x35\x6c\x54\x66\x19\xae\xa9\x51\x8c\xf5\x62\x77\xe2\x03\x31\xd5\xaa\x6b\xb3\xf4\xd7\xdd\xe5\x7d\x7d\xbb\x3f\x9a\x37\x65\x33\xb4\x3f\xe5\x9b\xaa\xc6\xe4\x0e\xda\x5f\x86\x91\x7d\x42\x9f\x65\x7c\xbb\x12\xd7\x6c\x46\x20\xbb\x7f\x24\x15\x20\x6d\xd6\xb9\x90\x99\x04\xc8\x75\x00\x2d\x15\x9d\xae\xb0\x21\xa4\x6e\xa3\x45\xc0\x8b\x5c\xb0\xd1\xe3\x10\xfa\x82\x8d\xb0\x80\xc2\xe7\x38\x3b\xeb\x82\x96\x66\x82\x99\x90\x88\x7c\x84\xe4\x5c\x4a\x79\x57\x91\xb1\x21\xa4\x6e\x95\x4b\xdf\x45\xbd\x57\x1b\xe0\x7d\xb2\xb0\x5e\xb1\x9b\xd0\x2d\x92\x79\x70\x5c\x41\x4e\xad\x6d\xc9\x6e\x0e\x6e\xa4\xba\xe6\x62\xdc\xbf\xe1\x66\xd2\x47\x4a\xe9\x03\xc0\x61\x3b\xf8\x13\xfc\xe3\xa2\xb5\x87\x69\xea\x32\xcb\x4a\xcd\x46\x65\x86\x39\x5f\x7a\x40\x68\xc1\x7f\x62\x4a\x43\x0a\xe3\x35\x17\x69\x8f\x94\x3c\xfd\xae\xe9\x8a\x91\x2e\x36\x48\xf3\x2e\x62\x77\x9e\x8b\xca\x8b\x1f\x45\x53\xa9\x11\x85\xd7\x92\xa8\xc6\xfa\x34\xcd\xb9\xd8\x14\xce\x6f\xaa\xda\x73\x91\x36\xa3\x60\x9d\x7a\x47\x30\x4e\x5d\xb7\xc7\xb1\x7d\xcc\x38\x64\xd1\x50\xef\xcb\xc0\x2e\x55\x2e\x9f\xa6\x9e\x4d\xb3\x92\x40\xc9\x67\xfa\xb7\xac\x8f\x4f\xe9\x17\x69\x45\xd7\x6d\x6a\xcc\x43\xae\xc7\x4c\x8d\xe9\xd6\xfd\xfd\x09\x12\x5e\x1e\x95\xc7\xc8\x56\xed\x5d\x03\xad\xdb\x6b\xba\x8f\xa0\x7f\x01\x0e\xbc\xf6\xc5\xc9\xa0\x5e\xa1\xec\xf1\xbe\x2d\xec\xcc\x17\x80\x87\x7d\x99\x51\x22\x85\x70\x98\x74\xef\x0a\x26\x2e\x0d\x4d\xae\x5b\xc6\x45\xb7\x3a\xd3\x1f\x4c\x67\xea\x36\x57\xc6\xa7\x41\xa7\x81\x47\xb1\x8a\xca\xa5\x94\x55\x59\xd2\xb8\xb1\x9f\xa0\xd4\x45\x84\xf5\xb7\xb4\x68\xef\x01\xf5\x23\xcd\x29\x4a\xe1\x63\xe7\xf4\x84\xaa\x9a\x42\x16\x65\x86\x90\x6b\x5c\x3b\x3a\x7e\x7a\xc5\xa6\xed\x06\x77\xfa\x72\x77\x39\x23\x95\x0c\xcd\x65\xca\xc8\x90\x9b\x4a\x3a\x6a\x66\xb0\x76\xd7\x01\xd1\x48\x41\x12\x07\x36\x07\x5a\x87\xd5\x30\xdc\x84\x22\x8d\x44\x10\x99\x18\x5f\xf3\x17\xca\x7c\x5f\xbc\x78\xf1\x02\x8b\x2e\xff\xfa\xd7\xbf\x12\xa9\xa0\xe3\x43\xc2\xf3\xc5\x1b\xe1\xae\x3f\xbf\x7c\x39\x20\x7f\x3f\x7c\xfb\x06\x72\xff\x0b\xa3\x11\x07\x1c\x47\xb6\x37\xd4\x7e\xac\x7b\xe4\xff\x5e\xbe\x3b\xf3\x6a\xa3\x9e\xfb\x16\x4c\xed\xf0\x7a\x75\xf4\xc5\x17\x7f\xf9\xea\xab\x01\x39\xe6\x0a\x6a\x9f\x38\x0b\xad\xb9\x82\xb7\x84\x2a\x86\x45\xa2\x00\x11\xe8\xf5\x2a\x1e\x40\xf4\x1d\x7e\x02\xf6\x1e\xc4\x7a\x46\xcb\x81\x19\x4f\x0c\x96\x59\xa1\x20\x0b\x5d\x85\x01\xb8\xd1\x41\xa1\xba\x64\x5d\x98\x5c\x8f\x64\xfc\x9a\x91\x91\x86\x96\x9c\x55\x31\xbd\x6b\x77\xe3\x4a\x4a\x70\xb0\x6a\xad\x34\x33\x4f\x3c\xf7\xb3\x95\x2f\x78\x1e\xc0\xb8\xd6\x70\x0d\x4a\x3d\xaf\xd9\xac\x8f\x1c\x56\x50\x1e\x0a\x46\x20\x39\xae\xd6\x63\x21\x78\x6d\xd2\x48\xae\x78\x8c\xc5\x42\xc9\x7f\xe1\xe2\x43\x0d\x69\x24\x89\xa1\x12\x15\x5b\xd4\x02\x58\x82\x88\x1a\x76\xf8\x3a\x58\xd7\xd4\xcb\x7f\xec\x90\x42\x17\xe1\x96\x33\xae\xed\x23\xae\xd9\x4c\xdf\xf5\xe4\xaa\x57\x8c\xe5\x4f\x8d\x9c\x52\x8a\x85\x5f\x3b\xe4\x7d\x27\x19\x5d\x93\x05\x87\x78\x53\x8d\x81\xe5\xff\xae\x10\xda\xdd\xeb\xa9\x14\x08\x51\x4b\x57\xd6\xcc\x94\x8e\x34\x90\x77\x6e\x9f\x0d\x0d\x00\xe0\x0d\x73\xaa\xae\x99\xef\xcc\x4b\xb3\x01\x39\xb7\x93\x0c\x90\x23\xa1\x31\x32\xd8\xad\x74\x06\x8f\x75\x4a\x1a\x3c\x64\x77\x30\xd8\xc5\x8d\x27\x15\xd1\x86\x2a\xb7\x8b\xec\xe7\xcf\x03\xc5\xea\x2d\x2d\x34\xa2\xaa\x58\xad\x14\x10\x87\x24\x20\xb5\x9a\x49\xd5\x17\x10\x69\xbd\x45\x9e\x22\x7d\x20\x4c\xe3\x01\x36\x11\x75\xea\xca\xc9\x06\x23\xfd\xf6\xde\x08\x2c\xa4\xbc\x85\x52\x81\x57\x2b\xd5\xc2\xc1\xec\x66\xec\x49\xe9\x12\xcb\xdb\x6a\x38\x49\x19\x69\x6b\x73\xcd\x3c\x9f\xaa\xca\x80\x57\x17\x8a\x03\x5e\xed\xd5\x07\xbc\xda\x04\x74\xf1\x5a\xd8\xa1\xe1\xa4\xc2\xc3\x68\x54\x91\x1e\x40\xcf\x8b\x70\xc4\x1b\x89\x1d\x42\x7c\xa7\x1b\x41\xe8\x50\xcb\xac\x34\xf8\xd3\xea\xcb\xf8\x98\x83\x41\x3d\xf8\x12\x9c\x6d\xe1\xb6\xe8\xd0\x83\xe3\x1e\xcf\x89\x36\xe7\x1f\x5e\xad\xc5\x44\x67\x6d\x90\x9f\xb7\x57\xa1\x35\x9d\xbd\xee\xd4\x4d\xae\x93\x2b\x86\xba\x99\x30\x97\x85\x10\xe9\x75\x56\x78\x5a\x91\x00\x4a\xa3\x57\xd1\xb0\xed\x78\xba\x16\x2f\x61\xa2\x79\x7b\xb7\xc0\xe5\x29\xd9\x0b\xed\x46\x43\x3a\xdb\xa9\x30\x4c\x8d\x68\xc2\xf6\x63\x77\x01\x2b\x26\x2c\x67\x8a\x66\x21\x43\xd9\xd7\x29\x4f\xa8\x48\x33\x57\xbc\xcf\x14\x6c\x5c\xf6\xd1\x30\x25\x68\x06\x8f\x48\x15\x9f\x32\xa5\xc9\xde\xf7\xcc\xda\x12\xd8\xa6\x74\xff\x09\xa6\x91\xe2\x8b\xac\xc3\x99\x01\x0f\xee\x26\x01\x14\x86\x5a\xd6\x29\xb1\x5a\x2a\x8f\x59\x64\x97\x55\xc7\x6e\xa0\x81\xdd\x10\x70\x62\x82\xd0\x85\x8e\x40\x18\x8d\xf4\x0d\xf0\x00\xb8\x38\x31\x38\x30\xd5\xae\x21\x1e\x20\xc2\x38\x79\xee\xa0\x42\xd6\x56\x0a\xf0\x49\x8a\x2e\xee\x2a\x99\x18\x39\x03\x52\x4e\x79\xea\xd5\x20\xc8\x66\xa8\x50\xb7\x0a\xaa\xa3\x4a\x7e\xaa\xb5\x74\xfd\x3e\xa3\x35\x42\x73\x14\x94\xa5\x3a\xa6\xb4\x8f\x14\xc7\xf1\x2e\x09\xc8\xac\x8d\x1a\x5a\x90\x4e\x0e\x44\x99\xb2\xf3\x72\x98\x71\x3d\xb9\xec\x34\xb4\x71\xb6\x64\x60\x4c\x0c\x5c\x48\x2e\xb9\x35\xdc\xa1\x99\xd0\xdc\xf5\x1f\x43\x35\x8b\x5b\x2d\x5b\xc2\x32\xf8\x5f\xc7\xbb\x43\x42\xa1\x38\x74\x35\xf3\x5f\x45\xf3\x70\xc8\x1d\xd8\x4e\x27\x65\xef\x45\x51\xfb\x3c\xa1\x59\xa6\xe7\x1b\x49\xfb\x83\x0c\x35\x53\x8f\xe6\x81\x5c\xc1\x2d\xc3\xf8\xd9\x43\xd6\x0c\x4a\xb1\x80\x6c\xba\xf4\xc5\x34\xc9\x25\x56\xfc\x0b\x22\x85\xbf\x09\xba\x02\xf9\x1f\x04\x0a\x21\xde\x18\x32\xdd\x1a\x31\x25\xb7\x31\x9d\xa7\x17\xd3\xe9\x34\x2a\x7c\x19\x5a\x34\x50\x18\xb8\x0f\x85\x4d\xbe\xd1\x2c\x0d\x85\xff\x95\xe1\x38\xb8\x2f\x7c\xbc\xb6\x08\x2e\xce\xef\xd0\x38\x58\xd0\x6e\xfc\xb6\x3f\xcd\x0d\x0a\xaa\x98\xb5\xbc\x41\x30\xf5\x9d\x6d\x9d\x44\x3b\xc9\x99\xc4\x61\x7b\x2f\x8a\xb3\xea\x4c\x87\xe3\x1c\x3f\xdc\xd5\x24\x95\x49\x69\x6d\xae\x8a\xec\x55\xc2\x44\x3b\xb4\xf7\xe7\x05\x3f\x9b\xca\x1b\x71\x43\x55\x7a\x78\xde\xa8\x6a\xb5\xae\x9c\x55\x63\xc5\xaa\xb7\x7f\x04\xb1\x9f\xd3\xa1\x6f\xf8\x1f\xc0\x9f\xb6\x81\xbb\xf9\x21\xee\xf3\xae\xb9\x36\xe0\xab\xc5\xe9\xc8\x36\xf4\xb7\x0d\xfd\x3d\x9b\xd0\x9f\x1d\xa9\xde\x29\xa5\x26\x5e\x9c\x43\xd6\x52\xfc\x59\xc4\x90\x22\x91\x8a\xa7\xe7\x7c\x3d\xec\x9c\xce\x8f\x9b\xb7\xe2\xba\xc8\x4e\xf0\x32\x17\xd4\xb1\xe7\x10\x6f\xda\x80\x78\x11\xd0\xb2\x85\x31\x88\xd7\x6d\xa5\x62\x88\xd4\x8a\x81\xe7\x28\x82\x5d\xc8\xf4\x15\x02\xa7\x42\xe7\x74\xec\xd9\xd1\x73\xb8\xcd\x3d\xe7\xbb\x10\x51\xaf\x70\x6c\xcd\xec\xd5\x9f\x4e\x62\x02\x2d\x19\x80\x74\xc4\x04\x04\x18\x01\xa8\x73\xde\x86\x1b\x48\x67\x1c\x61\xaf\xca\xd0\x69\x3b\xd2\xbc\x02\x8d\xa3\x7a\x46\xd0\xc9\x84\xe5\xd8\x3f\xfc\xb5\x27\x81\x95\x8d\xd6\x78\x30\x0c\x11\xd2\x98\xca\x35\x91\xa3\x5e\x0d\x42\x61\x67\xfa\x72\xa7\x5d\x8c\x81\x74\x17\x8e\x24\x7e\x1f\x9d\xb7\x8e\xed\x90\x79\x82\x9d\xd7\x42\x3a\x76\x0f\x81\xce\x93\x61\xeb\xe2\xb9\x2c\x0b\x38\x3f\x90\xc2\x1b\x43\x9c\x4d\x89\xd5\xf6\x42\xd4\xe0\x09\x28\x7f\xdb\x58\xed\x73\x8c\xd5\x46\x07\xa3\x17\x74\x8e\xb0\x71\xfc\x36\x0e\x09\xf8\x20\xee\x90\x79\xa3\xc6\xd9\x30\x3e\x82\xeb\xc3\xb7\x52\xd5\x53\x93\x76\x07\x83\xdd\x5d\x1f\xd4\x75\x7c\x5f\x9a\x51\xff\x6b\xc2\x44\x22\x53\x64\x16\x3b\xbe\xd2\x06\xd4\xbd\xca\xcb\x16\xcf\x25\xf7\xcf\x8a\xd3\x9b\x60\xec\x2e\x96\xba\xb5\x6c\xf1\x68\x7c\xaf\x1f\x41\x89\xa9\x54\x97\x80\xf9\xe7\x48\x14\x30\x9d\x9d\x0e\xe3\xbf\xd7\x24\xe3\x39\x77\xfd\xc3\xec\x46\x67\xda\x68\xb2\x87\x1f\x0e\x92\xa2\xec\xb9\x1b\x06\x39\xcb\xa5\x9a\xf5\xc2\x4d\xf6\xcb\xda\xaf\xdc\x1d\xfb\xd8\x87\xa2\x54\x8a\x09\x93\xcd\x9e\xb3\x06\xe4\x89\xb8\x21\x0a\x50\x58\xe3\x36\x48\x1e\xd5\x35\x57\x33\x17\x22\xbe\xe0\x2d\x8f\x30\xf6\x03\x58\xab\xee\x85\x90\x04\x7c\xca\xc4\x94\x4c\xa9\x7a\x20\x7a\xfa\xb2\xab\x43\x9d\x27\xe5\x53\xae\xdb\x36\xf7\x23\xb7\x3b\xa1\xa1\x75\x57\x69\x8a\xd2\x38\x89\xee\x77\xa0\x47\xda\x0e\x3b\x6f\x4e\x39\x7c\xb9\xd3\x7a\x4a\x05\x35\x86\x29\xf1\x8a\xfc\xf7\xde\x87\xcf\x7f\xef\xef\x7f\xb7\xb7\xf7\xcb\x8b\xfe\x7f\xfe\xfa\xf9\xde\x87\x01\xfc\xc7\x67\xfb\xdf\xed\xff\xee\xff\xf8\x7c\x7f\x7f\x6f\xef\x97\x1f\xdf\xfe\x70\x75\x7e\xf2\x2b\xdf\xff\xfd\x17\x51\xe6\xd7\xf8\xd7\xef\x7b\xbf\xb0\x93\x5f\x57\x1c\x64\x7f\xff\xbb\xff\x68\x3d\x75\x2a\x66\xef\x5a\x8a\x42\xbc\xfa\x1d\x1e\xc9\xf5\x11\x3b\x61\xbf\xb9\xd6\x0a\x5c\x98\xbe\x54\x7d\x1c\xfa\x15\x31\xaa\x6c\x27\x4c\xaa\xe3\xa5\xeb\xfd\x5f\xa9\x01\x15\xe4\xbc\x57\xea\xd7\xbc\xc1\x21\xe2\x79\xcc\x3b\x28\x0c\x3e\x71\x23\xd5\x2b\x5e\x0c\xcb\x0b\xa9\xa8\x9a\x91\xd4\x79\x33\x67\x4b\x00\x7f\x22\xc4\x9f\xd6\x68\xba\xf0\x46\x29\x57\x6b\xa8\x0d\x6e\x0d\xe0\xc3\x52\x5e\xe6\xdd\x38\xe1\x7f\x06\xe4\x79\x87\x5a\xef\x13\x88\xf0\x01\x3e\x7c\x31\xa4\xc9\x35\xda\x4b\x61\x6d\x50\x4b\x8c\x41\xa4\x77\x5c\xde\x43\xce\xa8\x08\x6e\x7c\xc8\x64\x91\x29\xb3\x0b\xe7\x6f\xc6\xb1\x6b\x2e\x77\x0c\xa7\xbb\x2c\xc1\xaa\x0d\x93\x54\xe4\x2d\xa8\x3b\x6b\x5d\x6b\xd2\x09\x6c\x07\xff\x37\x7b\x63\x75\xbc\x8e\xe0\xe2\x25\x18\x93\x0e\x23\x6b\x04\x8d\xa4\xaa\xf4\xaf\x9a\xda\x00\xeb\x16\xf6\x9c\x0f\xce\xda\xd5\xb3\x73\x42\xc5\x13\xbc\xce\x99\xc6\x5c\x14\x9e\x40\xa3\x23\x30\x3c\x81\xfa\x61\xc5\xae\xa2\x86\x88\xa5\xb6\x4f\x92\xa2\x7e\x4f\xf5\x20\xec\x03\x35\x44\x16\x70\xed\x0d\xe7\xcc\x65\xfb\xcd\xa5\xa7\x4b\xe4\xac\x80\x72\x62\x6f\x5b\xea\x12\x2c\x10\xf7\x14\xa7\x47\xcb\x11\x64\x4b\x44\x0d\x69\x7c\xcf\x95\x05\xbe\x14\x3c\xab\x33\xa6\x6f\xb4\x10\x5e\xbc\x14\x2e\x5b\x70\x81\xcb\x96\x33\x59\xa9\x99\xea\x8f\x4b\x9e\x76\xc7\x5e\x4f\x4e\xa7\x68\xa9\x49\x74\xa5\x3f\x74\xa2\x35\x74\xae\x2b\x84\x7c\xcc\xd6\x67\xe5\xce\x49\x48\xed\xac\x1d\x96\x71\x63\x88\x7a\x9a\x27\x0d\x0d\xbf\xbc\x30\xf0\xb9\x04\x57\xc1\x4f\xe4\x0e\xd1\x64\x96\x38\x50\x25\x5e\xeb\x4d\x83\xc3\xe2\x9e\x80\x8a\xa8\xbe\xfd\x3f\xef\x4f\xf2\x21\xd4\x21\x1b\x61\x16\x13\xfe\x06\xdc\x00\xae\x8e\x2b\x65\x19\x33\x50\x96\xc5\x44\xd5\xf1\x4e\x13\xc5\x72\x39\xb5\xdb\xec\x83\x20\xef\xb5\x0b\x86\xf3\xd1\x2b\x42\xf7\x6b\x85\xc1\xae\xcd\xae\x60\x2c\xc5\xe2\xae\xa8\x71\x9e\x2a\x85\xee\x91\xe1\xbe\x4f\x56\xd5\xd8\xdb\x51\x81\xc7\xcc\xb5\xaf\x02\x27\x95\x62\x96\x00\x00\x0f\xa5\x64\x4e\xb4\xa0\x85\x9e\x48\x03\xfe\x10\x5a\xd0\x84\x9b\x99\x25\xb7\x51\x34\xb9\x86\x16\xd1\x8a\xb9\x27\xf6\x48\xb2\xef\xb2\xd6\x63\x0a\xd6\x4b\xce\xcc\x44\xc9\x72\x3c\x81\x1a\x28\xbc\x2b\xc9\xa8\xf6\x04\x58\xfa\x7b\x67\xa3\x6b\x92\xce\x04\xcd\x79\x12\x5a\x67\x28\x39\xe5\x9a\x4b\x17\xc9\xc2\x71\xed\x1e\x23\xe7\xa1\xc7\x00\x06\xc8\x8e\x32\xca\x73\xb2\xa7\x19\x23\x81\x31\xf0\x9b\x4b\x54\x16\xd1\x59\xa8\x98\xfd\x79\x1c\x3d\x73\x28\x8a\x0e\x2a\xc0\x7e\x52\xc9\xe0\x90\x90\x80\x4a\x00\x6c\xee\x74\xf9\xa3\xf7\xc3\xd2\x2d\x9f\x99\x54\x90\xd0\xe6\xbb\xdf\x30\x91\xca\x28\xf5\xe5\xf0\xfc\x54\xc7\x86\xac\xeb\x19\x88\x23\xc1\x17\x99\x14\xe3\x18\x64\xae\xe2\x52\x2b\xf0\x05\xf4\x7f\x9c\xf2\xb4\xa4\x19\x8a\x7a\x37\x99\xa3\xcb\x53\xfc\x39\x1f\x4f\x4c\xff\x86\x81\x9b\x13\x4f\xc4\x2a\x35\xda\x3f\x94\x2f\xa4\xd4\x72\x0d\x47\x83\x71\xee\x34\x74\x19\x43\x87\x45\x3a\x03\x84\x5a\x97\xbc\x59\xcb\xba\xf1\x48\xed\x38\x44\xa0\x7b\x44\x74\x98\xde\x61\xe8\x06\x68\xb5\x21\xf0\x03\x5b\x2a\x03\xd7\x2e\xce\x0d\x5a\x1b\x56\x7d\x25\xc2\xc7\x26\xea\x2e\x0a\x9a\xef\x07\x81\x1e\x5d\x08\x16\x0f\xa3\xdc\xed\xaa\x6b\xa3\x43\x9a\x86\xa2\x4e\xb7\x0d\x7f\x60\x82\x29\x9e\xcc\xb1\x4e\xf8\xe9\x98\x1a\xd8\x7c\x4c\xd8\x9f\xa5\x83\x26\xa6\xf2\x9a\xf5\xe2\x69\xc5\x8c\x57\x2c\x2f\x32\x6a\xba\xc9\x54\xd9\xf9\x39\xf2\xa6\x47\xb1\x68\xbb\xfb\xa9\x48\xfb\x34\xb3\x7c\x7f\xfe\xd3\x91\xab\x87\xc3\xfd\x5c\xcb\x86\xbb\xaa\x3a\x7f\xa2\x3a\x82\x7a\xd9\xd2\x6d\x0c\x20\x6a\x43\x96\x82\xf8\x73\x4f\x06\x97\xc7\x8d\xc0\x56\xb0\xf6\x8f\xf3\x9f\x8e\x7a\x84\x0f\xd8\xc0\xff\x15\x6e\xf5\xf2\xd7\xc8\x31\xd6\x4b\x84\x3a\x1c\xd8\x35\x30\x95\xd8\x97\x1c\xff\xf6\x9f\xdf\xd8\x49\xda\x6f\xbf\xed\x7f\x13\x75\x0e\xfa\xf6\x9f\x96\x8f\x94\xbd\xa1\xfe\x69\x9c\xae\x0e\x92\xd6\xfe\xf5\xcf\x73\x99\x5e\x16\x2c\x19\xe0\x6b\xe9\x7f\xba\x3e\xea\x4c\x18\xab\xcc\x9f\x4b\x48\x54\xe3\x29\xee\x25\x78\xb6\x62\xff\xf2\xf1\x06\xd7\x80\xd4\x49\xac\x84\x1a\x26\xe0\xc8\xf1\x75\xc9\x42\x1a\xfc\x39\xb6\x2e\x85\xf9\xef\x8d\xe2\x6e\xa2\x46\x4a\x10\x26\x28\xb0\x0e\x05\x61\x1f\xb9\x06\x14\x1a\x7c\x57\x20\x07\x75\xb9\xf0\xfe\x14\xb5\xc3\x5a\x0a\x07\xd4\x21\x68\x67\x6a\xe7\xf6\x99\x90\xe6\xb3\xb0\xfc\x3e\xcf\x11\x8e\x4a\x49\xe8\x54\x02\xd2\x05\x1c\x22\x82\x94\x02\x1c\xe5\x55\x37\xc0\xe1\x8c\xe4\x5c\x1b\x7a\xcd\x06\xe4\xd2\x9e\x92\x71\xc2\x02\x52\x4f\x10\xe8\xe7\xc2\x52\x52\x0a\xc3\x33\xf8\xb6\x1a\xc7\x4e\x39\x3e\x3d\x4f\x47\x44\x97\x09\xb4\xbc\x55\xac\xef\xcf\x63\x77\xd7\x82\x24\xab\xde\xa5\x17\x16\x7b\x42\xd1\x40\x2b\x52\xf8\x29\x36\xd0\x15\x8e\xbd\x16\xb2\xb3\xed\x3c\xa5\x48\xaa\x33\x18\x88\x09\x5d\x94\xed\xb1\x9b\xf9\x7c\x22\xb4\x15\x5d\xfc\x41\xb0\x84\x69\x4d\xd5\x0c\x1b\x8c\xf2\xd0\x07\xd1\x25\xce\x82\x50\xca\xa9\x28\x61\x00\xc5\xb0\x5b\x6d\x99\x00\x75\x28\x19\x2a\x79\xcd\x44\xa8\x48\x08\x02\x2f\xa4\x65\x57\x49\xa8\x90\x0e\x20\x49\x32\xa1\x62\xcc\xaa\xa2\xf3\x9c\xa6\x40\xfb\x1f\x83\x6e\xe7\xdf\xc7\x52\x80\x8e\xac\x8a\xc4\x0d\x90\x62\x68\x0f\xc2\x10\x45\xf9\x20\x88\x77\xc3\xf4\xaa\x30\x87\x7d\x25\x9e\x35\x92\x89\xa4\x1b\xbf\x7a\x7b\x8f\x7a\x1f\xf4\x97\x35\xa6\x80\xe7\xcc\xd0\x94\x1a\xda\x59\x1a\xf8\x5b\x1a\x1a\x69\xba\x1c\x11\x60\x87\x28\x77\xc4\x9d\xe4\x5e\x79\x95\x05\x8f\x61\x08\x40\x1a\x4c\xfc\xea\x63\x0f\x7a\xcb\xd7\x2e\x86\x89\xd9\xdd\xa0\x1a\xba\xf6\xea\x30\xbc\x1f\x0d\x45\x16\x4b\x49\x5a\x82\xa2\x59\x89\xb4\x36\x31\xf6\x4e\x42\x30\x76\xa1\x3b\xa3\xf2\x55\x95\x4a\x90\xd4\x53\xbd\x97\xaa\x81\x78\xd6\x31\x61\x38\xb6\x4a\xf7\xb8\x11\x8e\xf8\xa5\xc0\xad\x3a\xb7\x0c\xb0\x4e\x63\x66\x74\x95\xa4\x89\xa7\x89\x15\x91\xee\x2c\x77\x6e\x0b\x38\x6a\xdc\xd2\x38\xcb\x7f\xb9\x3e\x8a\x0b\xa7\xa5\x3b\x2d\xec\xf9\xb5\xf6\x95\xe9\x2e\x16\x85\x1d\x65\xdf\xca\xb4\x7d\x50\x6b\xae\x35\x6a\x35\x70\x55\xb3\x82\xf5\x4b\x1a\xdc\x4a\xf8\x64\x08\xf1\xeb\x1a\xaa\x06\x1e\x01\x13\x3a\x6d\xee\x9d\xad\xf4\xdf\x7e\x68\x7b\x06\x8f\xeb\xc3\xe3\xfa\x2f\xdb\xfa\xc1\xdb\x27\x41\xfa\xab\x65\x32\x64\x7d\x42\x1d\x04\x3e\xac\x68\xbd\xec\x24\x2e\x31\xdf\x9b\x32\x9c\xbc\x2e\xc5\x23\xa4\xd5\xb8\xc2\x5c\xc6\xad\xbc\x7c\x45\x3e\xab\xe9\x5a\x4e\xa7\x0d\x96\x37\x56\x41\xed\x79\x53\x7c\xe0\x96\xdc\x43\x7c\xd5\x6f\xdf\x9f\x1b\x0c\x94\xbc\xe5\x56\xa9\xaf\xb6\x0a\x8a\xb7\x55\x92\xa1\xa7\x7d\x28\x76\xb5\x6c\xac\x64\x96\xf9\x46\xe8\x68\x8a\xcf\x25\x49\x41\xdf\x1e\x0c\xbb\xf4\x82\xcb\x23\x68\xfa\x82\xdd\x04\x95\x8e\x6a\x44\x2a\xf5\x41\x7f\x70\xcb\xf8\xcc\xb5\x65\xe3\x85\x8a\xb0\x43\x31\xc3\xa9\x1f\x87\xc5\xba\xcd\x00\xeb\xf9\x14\x25\x4b\x78\x98\x0b\xcd\x6e\xe8\x4c\xc3\xfe\xaa\x2c\xc2\xf0\x7c\x87\xdb\x5e\x0d\x7c\xc1\x46\x2d\x9a\xb3\xc7\x57\x67\x69\x01\xdd\x25\x06\x00\x2a\x0b\x17\xcd\xb3\x7d\xab\x61\x1a\xf4\xb3\x9e\xbf\xba\xcb\x2f\x80\x14\x4b\xc8\xaf\xea\x22\x50\x5b\x6f\x3a\x74\x7e\x0a\x03\x7b\x9b\x6d\x0c\x7f\xf8\xb3\x3c\x44\x1c\x87\xcc\xee\xb7\x0a\x4b\x0a\x78\x37\xfe\xed\x92\x04\xb4\x8a\xe9\x7f\x84\xc6\x44\x2e\xb4\xe3\x0b\x8b\xed\x51\x70\x78\x7e\x8a\x4f\x1c\x40\xeb\x59\x2a\x66\x4e\xcb\x32\x13\xae\xd2\x7e\x41\x95\x99\xa1\x73\xa4\x57\x7b\x5a\x28\xaa\xec\x80\x1c\x9d\xc6\x98\xdb\x74\x2e\x8b\xaf\xda\x1a\x01\xf9\xdc\xfa\xf8\xa0\xdc\xad\x2b\xb3\x69\x14\x69\x5b\xe2\xe9\xaf\x7a\x1d\x71\x84\x46\xe6\xbd\x16\x4f\x82\x22\x69\x2c\x88\xbb\x3d\x91\xe7\x32\x61\xf0\x60\x05\x7d\xd9\xf9\x96\x64\x5c\x72\x16\xf4\x33\x30\xf4\xed\xb4\x7a\x84\x8f\xec\x91\x26\x45\xdf\xd5\xb7\x07\xd7\xbb\xd3\xf1\x7c\xca\x28\x1a\xed\x76\xb3\xa2\x43\x35\x7e\x56\x3c\x40\xd8\xdd\x64\x4f\x48\x81\x3b\x1e\xef\xdd\xc7\x8c\xd9\x5b\x3c\xc6\x70\xcb\x80\xfc\x3c\x61\x22\x3e\xee\x62\x5f\x7b\x2f\x1c\xbb\x5c\xa4\x76\xb9\xe1\x2c\x04\xdb\x5f\x97\x49\xc2\x58\xf0\x16\xc5\xbd\xd7\x2b\x89\xe4\xa6\x9c\x53\x93\x4c\x98\x26\x5a\x02\xf8\xa8\x36\x34\xcb\x2a\x2f\x8d\x23\x97\x04\xcd\xc1\x3b\xe8\x23\x85\xa2\x56\x16\xee\x1c\x56\x45\x46\x9d\x57\x64\x54\x8a\x04\x73\xb2\xb8\x99\xf9\x19\xc4\x27\x3c\xfc\x0c\x4c\x53\x8d\xce\x1b\x3e\x42\x6f\x70\x64\x62\x06\x62\x82\x48\x9d\xa1\x10\xad\x9f\xf5\x0e\x76\xcf\xca\xcf\x21\x4d\xae\x6f\xa8\x4a\x35\x54\xbc\x53\xc3\xb1\xa9\x60\xaf\x36\xec\x5e\x34\x07\xfb\xf4\x9a\x6e\xb0\x1f\x0c\x59\x68\x28\x2d\xe7\x1e\x43\x68\x69\x64\x4e\x0d\x4f\xc0\x45\xc3\x47\x91\x6f\x3f\x0f\x7d\x1e\x42\x9c\x16\x65\x39\x9c\x0e\xee\x35\xc0\x5a\x53\x58\xa1\x61\x6e\x24\xe1\xb9\xd5\xb9\x28\x34\x4c\x1e\x85\xfa\x76\x1f\x88\xb8\x6b\xa6\x56\xb1\xfc\x19\xc2\x40\xd1\x5d\xe8\xfc\xb1\x66\xb9\x86\xe1\x43\x9c\x21\x38\xd8\x5d\x21\x77\x6f\x4e\x25\x22\xfe\x57\x96\xab\xed\x6c\x23\x66\xed\xd9\x05\xba\x61\x56\xd7\xd2\x77\xb2\xac\x1e\x2c\x9b\x13\x1f\x0b\xac\xfa\xe5\xda\x3b\x0c\x5c\x1a\xf7\x5e\xaa\x64\x51\x38\xd7\x5f\xbe\xbf\x38\x27\x88\xee\xa9\x29\xd3\x10\xd9\xf6\xa9\xe1\x96\x14\x63\x26\x98\xa2\x06\xe2\x03\x0e\xad\x10\x76\xef\xfc\x43\x20\x6b\x98\x44\x60\xe6\x7b\x87\x59\x31\xa1\xfb\xe4\xbd\x6b\x9a\x1f\xf8\x37\xe4\x9a\xaf\xa4\x91\xa2\x33\xd1\x47\x05\xb6\xaa\xe4\x5d\xc3\x6c\x55\xc9\xad\x2a\xd9\xe0\xda\xaa\x92\xf3\xd7\x56\x95\x8c\xaf\x90\xce\xdc\xad\x1a\x79\x11\xea\x13\xa2\xec\x92\x38\x5f\xab\x2a\x60\x78\x7c\x2f\x5f\x78\xd6\x06\x9d\x30\x5d\xca\x62\x4c\x5d\xeb\x9c\xa7\x77\xdf\x60\x4a\x1c\x7e\x38\x74\x4b\xe5\xb3\xf4\xaa\x0c\x41\xab\x25\x96\x86\x45\x4b\xea\x94\x87\x07\xaf\x61\x0d\xf5\xe5\x00\x3b\x5b\xf7\xc3\xb0\xfd\x2a\x29\xaf\x71\x23\xc0\xf8\xea\x70\x35\x49\xe7\xf0\x24\xf1\xf5\xe4\x72\xf8\xea\x57\x67\xb5\x01\xe4\x51\xea\x03\x48\xf7\x35\x02\xe4\xf1\xeb\x04\x48\xa8\xdb\xea\x7e\xdf\x5f\xf8\x3a\xb2\xb9\x9d\xef\x44\xf7\x5d\x3b\xbf\x86\x53\x16\xc6\xe1\x9a\xc8\x9c\x1b\xc3\x7c\x5e\x45\xd8\xc9\xe0\x0d\x8f\xeb\x68\x9c\xcc\x01\xb3\x1b\x93\x27\xd8\xc7\xd0\x69\x29\xd2\xe7\x40\x2b\xbb\xe1\x1a\x8c\x08\x2a\xac\x09\x88\x70\xb1\x20\x3b\xfa\x2e\xef\xd6\x9b\xb5\x5b\x39\xd4\x7e\xdc\xad\x1c\x8a\xaf\xad\x1c\x22\xd0\xb2\x2a\x83\xa2\x8d\x4e\x95\xc7\x43\x4c\xb8\x20\xbf\x95\x4c\xcd\x88\x9c\xb2\x28\xaf\x13\x9a\x52\x69\x9e\xba\xcc\x48\xe7\xb7\x6b\x6b\x75\x6d\xa8\x5e\x07\x7e\xc5\x93\x8f\x56\x7f\x06\x6c\x81\xce\x25\xfd\xfc\x03\xea\x10\x41\xb8\x0a\x7e\x89\xbd\x68\xb7\x32\x56\x0f\x1c\x06\x78\xf5\x09\xf8\xe2\x0e\xcf\x8e\xbb\x34\x81\xbb\x88\xa4\x93\xee\xa2\xe9\xe4\x36\x46\x5d\x46\x22\x24\x65\xf8\x06\x0e\xb3\x90\xf1\x10\x7c\x70\xe4\x9a\xcd\x7a\x2e\xb1\xc8\x75\x21\xf4\x37\x63\x8e\x5e\xbd\x55\x4a\x3b\x08\xbe\xfa\xd5\xf1\xa9\xd3\xa5\xcf\x0c\xaf\xb6\xad\x31\xea\x63\x79\xe2\x76\x73\x10\x76\x7c\xb0\x76\xd0\x42\x23\xbe\x6a\x4c\xea\x5a\xda\x40\xd2\x3b\x70\x2b\x80\xf2\xfb\x52\xa5\xc0\xa0\x50\x9e\x05\x12\xb6\x1b\xf6\x22\x5d\xbb\x6d\xf0\xf2\xcb\xf8\x48\xc4\x0a\x5b\xb0\x56\x13\x73\xcd\x66\xbb\xda\xa1\x54\x48\xa1\x27\xbc\xf0\xbd\x14\x41\x4e\xba\x5d\x49\x7e\x82\x54\x30\x3f\x04\x4a\xc4\x53\xd1\x23\x67\xd2\xd8\x7f\x4e\x20\xb7\x15\x43\x10\x92\xe9\x33\x69\xe0\x93\x8d\x26\x37\xbe\xda\x23\x11\xdb\xc5\x2f\x38\x44\x1f\x30\x8b\x1b\xea\x44\x7d\xc6\x23\x10\xd5\x25\xb7\x84\x85\xe1\x9a\x9c\x0a\x22\x95\xa7\xaa\xf1\x2d\xa3\xb4\x1b\xc2\x7b\x75\xa3\x60\xd1\x92\x31\xdc\x62\x48\x55\x5b\x8b\x3b\x86\x0b\x71\x27\xee\xbf\x01\xaf\x2f\x04\xea\x42\x9a\x26\xb4\x2d\xa2\x86\x8d\x79\x42\x72\xa6\xc6\x80\x68\x92\x4c\xba\x5e\xe2\xae\xce\x45\xbc\x3a\x3c\x1d\xf1\xea\x94\x0f\x41\x45\x79\x03\x09\xb8\x8f\xa3\xfe\xe0\xd8\x78\x5c\xe7\xb4\xb0\x2c\xf8\x3f\xf6\x54\x06\x2e\xf8\x5f\x68\x8b\xa6\x07\xe4\x90\x68\x2e\xc6\x19\xab\x7d\xe7\x02\x07\xf1\x30\x76\x04\x6b\xb3\xfe\x56\xf2\x29\xcd\x18\x26\xcc\x53\x11\x7a\x99\xc8\xd1\x82\xd2\xd5\x73\xbd\xd1\xac\x5c\x0e\x21\xea\x9d\x6b\x36\xdb\xe9\x2d\xb0\xed\xce\xa9\xd8\xa9\xc0\x91\x6a\x8c\x1a\x94\x0b\x88\x5e\xee\xc0\x77\x3b\x9f\x46\x4f\x7b\x02\xa6\x6b\x67\x3c\xe9\xdc\xcc\x47\x19\xd5\xba\x0b\x9c\x96\xdb\xb1\xc7\x2f\xa3\x27\x55\x75\xd7\xae\xe8\x22\xc1\x74\xe8\xee\x7c\xe4\x50\x63\xd8\x55\x0a\x6c\x07\x74\x9e\xba\x86\xce\x6d\x81\xdc\xe6\xcf\x9c\x30\x6c\x28\x43\xbd\x89\x51\x0a\xaa\x6c\x95\x5b\x28\xfe\x13\xc4\xc3\xe5\x28\xee\x03\xc1\x35\xb8\x9f\xb8\x2f\x4c\x15\xd2\x10\x2e\x92\xac\x4c\xb1\x03\x06\xfc\x14\x9c\x57\xdd\x18\xaa\x9d\x91\xb7\x73\x06\xfe\x29\x0c\xeb\x75\x4e\x9f\x59\xb3\x50\xfb\x33\x9f\x02\x01\x69\x27\x21\x9b\x00\xa9\xbd\x4e\x6a\x8d\x1a\x55\x39\xd4\x5b\x85\x1c\xd5\xf5\xc8\xd7\x7c\xa8\x18\x39\x9a\x50\x21\x58\x16\xe1\xb0\x38\x47\x27\x35\x86\x26\x13\x4c\x7f\xa6\xc4\xee\xe3\x8c\x99\x5d\x8d\x2d\xea\x73\x9a\x4c\xb8\x08\xe0\x05\x22\xe0\x11\x55\xa5\x54\x6b\x68\xae\xd3\xd6\x10\xea\xb0\x2f\xcb\xee\xed\x8d\x59\x2a\x50\xef\xd1\xdc\x3d\x15\xba\xbd\xdb\xe5\x40\x6b\x3c\x71\xa1\x4b\x08\xdc\x7b\x77\x6b\x97\x3c\xb8\xa7\xb9\x18\x31\xa5\x70\x4d\x86\xcc\xfd\x80\xf0\x5a\xdf\xd5\x81\xeb\xf7\x30\x91\x37\x24\x95\xe4\x06\x3a\x90\x4e\xad\x6a\x00\xf9\x37\xda\x2b\x15\xd1\x4c\x21\x23\x2e\x91\x79\xa1\x64\xce\xb5\xaf\xf1\x73\x0c\xb1\x36\xd8\x91\xac\x6c\x8c\xd3\x7a\x1b\xb8\xe6\xeb\x23\x62\xa8\x1a\x33\x63\x07\x27\xa2\xcc\x87\xac\x25\xac\xca\xba\x21\xbc\x3b\xed\x94\x11\x51\xea\x9e\x06\x18\xe4\xc2\x3d\x17\x01\x4f\x20\x19\x6f\x24\x95\x4b\x29\x0c\x5f\x3a\x9c\x76\xcb\x72\x3f\xb9\x73\xb1\x14\x46\xb7\x84\x4d\x6f\xd3\x40\x03\x97\xff\xe7\x9f\xcf\xba\xc1\x3d\x5f\xca\x5b\x37\x52\x65\xe9\x0d\x4f\x31\x51\x43\x93\x3d\xfb\xb8\xfd\x76\xef\xbc\x46\xe0\xf3\xd6\x1b\xf9\xe6\x86\xa7\x8f\x41\x6e\x9f\x19\x6c\xc9\x4d\x80\xde\xae\x57\x3f\x87\xbe\x70\xf0\xd8\x7d\x72\xc2\xb1\x8e\xdc\xfe\x85\x88\xa2\xf9\x90\x8b\x0a\x09\x21\x30\x04\x9c\x7c\x56\x2e\x78\x8b\x5c\x33\x83\x15\xc0\x50\x44\x2b\xcd\x84\x68\x9e\x97\x99\xa1\x82\xc9\x52\x67\xb3\x96\x6c\xfc\x54\x97\x74\x94\xb1\x8f\xb8\x9b\xdb\xeb\x2f\x61\xa8\xba\x1e\x33\x46\xb4\x07\xbf\xc2\x0b\x8a\x4c\x95\xdc\x9c\x1e\x04\xa5\x26\x94\xb1\xb3\x8f\x2c\x71\x75\x4e\x45\x56\x8e\x79\xa3\x92\xd6\x6d\x53\xc0\x46\xbf\x5e\xad\x29\x60\xd5\xf2\xac\xd4\xac\x42\xfa\x6a\xd7\x74\xfb\x69\xf4\xf0\x7b\x54\x55\xf1\x6a\x79\xa3\xbe\x94\x15\x4c\xa4\x80\x1c\x1e\xed\x38\x9c\xee\xda\xa8\xed\x10\xbb\xbb\x3e\x17\x4e\x3e\x1a\x45\xad\x90\xcf\x01\x4e\xc6\xc1\x82\xf3\x11\xa1\xa2\xad\xc0\x7e\x2e\xbd\xa5\xc8\x56\x6f\x7c\xf0\xa5\x3b\xed\x2f\x19\x11\xac\xd6\x5f\xb2\xe3\xee\x92\x78\xfa\xb9\x8d\xae\xeb\x65\x51\x4b\xba\x40\xba\xa7\xc4\xf5\x4b\x6d\xbb\x41\xea\x25\x4d\xe2\xe6\x66\xb5\xc6\x3d\xb9\x6d\x0d\xf9\xb4\x5a\x43\x8e\x00\x69\xa8\x3d\x8c\xef\x6b\x1c\x67\xce\x77\xe6\x3e\x74\x3a\xe7\x2a\xbe\x32\xb7\xa3\xa2\xe3\x15\x7a\xbe\xb8\x81\x5c\xdd\x3e\xd1\x76\x35\xaa\x24\xfd\x52\x88\x66\x42\x7b\xdd\x1d\xf4\xa8\xa1\x9a\x99\x36\x1e\xdd\xc5\x82\x06\xaf\x0f\xe2\xd8\xd8\x78\x12\x0a\x0d\x3d\xdc\x0e\xe9\x7f\xeb\x34\x47\x51\xbb\xd3\xea\x8c\x9e\xd0\x1e\xe9\x97\x85\xd4\x2d\x1c\x23\xb5\xcb\x9b\x50\xd3\xb2\x97\x7a\x8b\x53\xd6\xcd\xf6\xfd\xfb\xd3\xe3\x4e\x68\x66\x07\x9a\xa3\xd9\x20\xa0\xe9\x95\x82\xff\x56\xc6\x36\x30\x20\x0f\x06\x2a\xb9\xfb\xd7\x41\x8a\x71\xc2\x2a\x67\xfc\x31\xd7\xd7\xed\x81\xb8\x7f\x38\x3a\xa9\x0f\x59\xdf\xcc\x3f\x1c\x9d\x10\xf7\xe9\x4a\x3e\xf0\x87\x38\xc1\xdb\xe2\x39\x8f\x13\x56\x85\xc7\x52\xae\xaf\xd7\x00\xe2\xdd\xd6\x3c\x2d\xd2\xb3\x66\xd5\x82\x9b\xec\xcf\xf7\xd8\x9f\x11\x40\xed\x4c\x96\xe4\xc6\xa1\xd2\x39\x03\xee\x8a\x17\xaf\xc8\x89\xd0\xa5\x62\x55\x96\xd3\xbc\x2d\x67\x75\xa8\x95\xcd\x39\x00\xfe\xd3\xaf\x3a\xf3\xff\x77\xcd\x9f\xcf\x25\xa0\x50\x50\x65\xc0\x06\xeb\x08\xc7\x1c\xda\x94\xba\x21\x3d\x11\xee\x61\x9e\xd3\x91\xaf\x53\xe8\x39\x54\xaa\x00\xf6\xed\x6f\xb2\xec\x12\xc1\x54\xc6\x0c\xf2\x3a\x00\xd0\x92\x83\x94\x4d\x0f\x74\x4a\x5f\xf6\xe0\x31\x1e\xcc\xc8\xd4\xe6\x44\x35\xd9\x79\xb9\x33\x20\x97\x3c\xe7\x19\x55\xd9\xac\xd6\x71\xab\xba\xcf\x1e\xa6\x7e\x40\x48\x02\x79\xb1\x43\xf6\xa4\x82\x91\x13\x2a\x48\xc6\x7c\x25\xbf\xdb\xbe\x33\x34\x1f\xf6\x37\x43\x16\x92\x8d\x89\xc6\xa0\x58\xec\x86\xbd\xde\xe3\x71\x5e\x03\x3b\x3d\xae\xce\x33\x2e\xec\x21\x37\x20\xef\xdd\xe9\xe4\x8e\x7d\x64\x01\xd8\xb5\xfe\x8e\xcd\x5a\xa2\x8d\xf1\x59\xb4\xf3\x44\x2c\x3a\x3a\x36\x8d\xd0\x4d\xbd\x1d\x63\x6e\x2e\x58\x21\x3b\x50\xd1\x70\xa0\x39\xcf\x3e\x37\xf6\x03\xa9\x39\x74\x49\xa1\x86\x50\x14\x44\x49\x99\x51\x6b\x91\xa1\x5f\x7f\x40\x8e\x4f\xce\x2f\x4e\x8e\x0e\xaf\x4e\x8e\x5f\x11\x3f\x12\x8f\x75\xfa\x01\xb9\x8a\xf1\x8a\xa3\x92\x2f\x07\x0a\x1b\x9e\xd5\x73\x82\x95\x8a\xaa\xc5\x03\xe0\x37\x52\x41\x4e\x05\x37\x55\xe7\x2a\x4c\xa2\xcf\xa4\x70\x69\xf1\xf6\xd7\x2e\xae\x30\xe6\x98\xbc\x29\xdc\x60\xf6\xeb\xfa\x68\xb0\x43\xb1\xcf\x4b\x98\x4a\x23\xef\xc6\x9a\x75\xbb\x6a\x79\xd6\x61\x65\xfa\x26\x2d\x9d\x6c\xf2\x2b\x0c\xc8\x56\x5d\x79\xf0\x44\x0d\xcd\x06\x3d\xfe\xaa\x54\xb5\x5e\x80\x83\xc1\xee\x80\xd8\xb3\x7a\x77\xb0\xeb\x55\xb9\x6c\xa1\x61\x65\x18\x34\x86\xb9\xae\xf3\xf7\x80\x90\x77\xbe\x8c\x10\x70\x8b\x96\xf7\xbe\x44\xb0\xbe\xa8\xd3\xe1\xdc\x2e\xf1\x2d\x51\xcb\x61\xfc\x50\x87\x8b\x3d\xe6\x53\x26\xf0\xc5\xd6\x27\x98\xfd\x54\x3b\x59\xb5\x8b\xea\xcd\xdf\x5f\xbc\x59\xdf\x4b\xa1\x64\xe9\xe4\x95\x8e\x64\x9e\x23\x62\xf3\x24\x20\x8d\x54\x60\x21\x41\xea\xad\xc5\x38\x47\x9c\xea\x51\xa3\x0d\x3b\x27\xf1\xfd\x50\x73\xc6\x78\xf8\xd8\xd5\xf5\x8a\xca\x1e\x7a\x78\x9b\x2c\x07\x94\xae\x3d\xf4\xa6\x3b\x3e\x0f\xc2\x7b\x1c\x5c\x9c\x1c\x1e\xbf\x3d\x19\xe4\xe9\x13\x14\xbe\x4c\xa4\x85\xe4\xc2\xe8\xa6\x86\x79\xb3\x76\xdb\x6d\xc5\x76\x98\x76\x37\xba\xd9\x89\x1f\x2e\x4e\xf4\xf4\xcf\x88\x90\xef\x53\x66\x28\xcf\x74\xc4\x61\x46\x16\x32\x93\xe3\xe5\x5d\xb7\x1e\xc0\x3a\x7f\x42\xec\xd4\x3e\xed\x5b\x9e\x5c\x9f\xc5\xda\xbc\x55\x6f\x9d\xa2\xbe\x35\x2f\xf4\xd2\x08\xd4\x0a\x96\x20\x74\xd4\x7d\x06\x04\xfb\x84\x26\xc2\x02\x15\xd1\x27\x03\x22\xce\x37\x26\xa8\x90\xfe\xa3\x06\xde\xab\xda\x0e\xeb\x21\x7e\x53\xb3\xc1\x4a\xf3\xa6\x9d\xe2\xeb\x54\xff\x9b\x1b\xa9\x7e\x88\x14\x8a\xf5\x03\xa0\x32\x74\x90\x96\x2a\xd2\xc1\xe2\x33\xc5\x3b\x71\xbd\xcb\x17\xef\xca\x66\xf3\xce\xdc\x4a\x4b\x0f\x3e\x74\xc4\xab\xcb\xb2\x59\xd5\x2e\xc3\xb9\xb4\xe8\x18\x81\x92\x95\x8b\x94\x15\x8a\x4f\x79\xc6\xc6\xd0\x70\x87\x8b\xb1\x6f\x3d\x1e\xe1\xed\x43\xfb\x4b\xb6\x30\x2f\xbb\xd8\xda\xc4\x0d\xe0\x80\xb3\xce\xde\x5d\x41\x13\x27\x48\x85\x69\x6d\x4c\xda\x07\x42\xb3\xeb\x7e\xbf\x0f\xfe\xbb\xbd\x7f\x59\xab\x26\xcd\xf6\xc9\xcf\xcc\x3d\x47\x42\xa3\x29\x05\x9d\xd4\x27\x32\x74\xfa\x81\xb9\x56\x94\x05\x86\xc6\xe4\x38\x77\xd7\x81\xbd\xd3\xaa\xcf\x78\x9c\xd7\xee\xe7\x0c\xc0\x9c\xab\x98\xff\x53\xb4\x80\xd6\x74\x88\x76\x2c\xed\x7d\x9c\x68\xd9\x1e\x09\x71\xfd\xc2\x9d\x0b\x94\xe8\x59\x9e\x71\x71\x5d\xa1\x87\x8f\xa4\xe5\x63\xac\xeb\xe5\xe2\xda\xef\x1a\xc5\x68\x76\xfb\x89\xd1\x84\x47\xd7\x76\x5a\x98\xce\x42\x09\x57\xb3\x02\xf3\xd8\x82\xf0\x72\x49\x56\xb1\xa8\xdf\xd9\x79\xd2\x14\xe3\x3a\xd1\xbc\xbd\x78\x3f\xbd\x3c\xba\x3c\xad\xc9\x76\x41\xf0\xb3\x4f\x19\xb0\xbb\xed\x70\x85\x97\x7c\xd2\x16\x04\xff\xad\x59\x86\x53\x9f\x64\x65\xd3\x5f\x62\x12\xf5\xb9\x54\x86\x66\x6b\x10\x9c\xc9\x84\x16\x87\xa5\x99\x1c\x73\x9d\xc8\x29\xeb\xc8\x0d\x71\x33\xc1\x0e\x64\xbe\xe1\x02\xf7\x4c\x8a\xcf\x20\x47\x7f\x3b\x3c\x27\xb4\xb4\x5c\x67\x5c\x73\x99\xb5\xa5\xa7\x79\x0a\x5c\x62\xc9\xef\x23\xbe\xbf\x7b\xc2\x46\xbd\xfd\x36\x28\xfc\xe8\x41\x61\x90\x8b\xcf\x25\x10\xcc\x05\x37\x9c\x1a\xa9\x3a\x8b\xd6\x1d\x95\xda\xc8\xdc\x6d\x91\x53\x3f\x3c\xe4\x38\x81\xaa\x55\x7b\x62\xbd\x1b\x2b\x18\x8a\x40\xde\x53\x61\xcd\x3a\x9a\xb0\xb9\x3a\x93\x1e\xf4\x6f\xc1\xb1\x79\xb8\xe7\x1b\x57\x6d\x04\xc0\xe4\xd9\xb7\xaf\x6a\xbd\x0d\x17\x5a\xde\x7a\xa7\x63\xd5\x46\x75\x6d\xde\x62\xfe\x5b\x37\xf2\xc9\x39\xf7\x91\x2e\xff\x55\xd2\x0c\xe9\x79\xb6\x4e\x4f\x78\x7d\x1d\x3b\x79\x4d\xcf\x53\x7e\xdd\xcf\x82\xf7\xab\xd4\x88\xab\x8e\x77\x18\x45\x85\xb6\xcc\x50\xf7\x2f\xec\xba\x14\x83\x5d\xb2\x67\x92\x62\x7f\x6d\x94\xe9\xaa\x9a\x13\x5f\xd6\xad\xfd\x9b\x50\xc5\xd9\xee\xbd\xd6\x9e\x37\x00\x7b\xb8\x1b\xe7\x69\x8d\x40\xa8\x92\x91\x37\x5c\x1b\xdf\xc6\x15\x3e\xe0\xda\xf5\xbd\x02\xed\xfb\x9c\x48\x45\x78\xf1\x0f\x9a\xa6\xea\x15\x9e\xf5\xce\x3a\x84\xff\xd6\x01\xa1\x9c\x8a\x90\xb1\xb2\x67\x66\x85\x6b\xaf\x70\x75\x74\x4e\xb0\x3b\xf4\xd7\x7f\x79\x01\x9a\xf8\x97\x5f\xfc\xe5\x45\x4b\x56\x7b\xaa\xd5\x71\xa4\x6b\x2f\x64\xe7\x79\x0a\xcf\xa4\x86\x02\x14\x50\xac\x9e\x80\xd3\xcd\x49\x41\xe4\x7b\xcb\x84\xe1\xcc\xed\x52\x4d\xdd\xd6\x1b\xfc\x81\xea\x0d\x48\x28\x18\x47\x39\xfa\x58\xf2\x19\x45\xf3\xf9\x53\x11\xcd\x0d\xa9\xd9\x94\x73\xeb\x1c\x8b\xd2\x6d\x77\x57\xc7\xb9\x1c\x50\x4f\x79\x7c\x76\xf9\x8f\x37\x87\xdf\x9f\xbc\x81\xf7\x74\xd9\xf0\x96\x15\x9d\x59\xd2\x24\x77\x7b\x75\xd6\x6e\xee\x29\x6a\x4a\xce\x2e\x22\xf6\x67\xaf\x2f\xe7\x5c\x71\xf6\x93\x07\x86\xe9\xdb\xda\x96\x62\xd4\x82\x7a\x4f\x2d\x48\x00\xad\xac\x99\x5a\x4f\x71\x77\xc7\x11\x86\x08\x40\xbd\xe6\xd4\xb0\x3c\x84\xef\xd8\xda\xef\xd0\x90\x37\xc8\xc6\xa9\x71\x77\x07\x93\x2d\xc5\x90\x8a\x9d\x87\x91\x3f\x29\xb5\xdb\xa9\x87\xaa\x2b\xe4\x81\xdd\x4b\x18\xcb\x27\x3c\x58\x11\x86\x79\xd4\xca\x9e\xa8\xf6\x2c\x65\x3a\x34\xbd\x7d\x06\xdc\x5a\x2c\xeb\xf6\xd6\xfe\x74\x58\xda\x44\xce\xb5\x3a\xc6\x20\x4d\x2d\x44\x5f\xab\x5e\xbe\xad\x6b\xa2\xcf\x65\xa4\xce\x55\xa5\x0b\x9a\x74\xda\x8b\xa7\xfa\x08\x3f\x01\xa0\xb7\xa7\x78\xc0\xc0\xc4\xd7\x54\x66\x15\x9e\xdd\xcd\x76\x3c\xf2\xc3\xcd\x83\x81\x3c\x88\x4b\x7c\x97\xe8\x42\x7a\xb0\x97\x18\x35\x64\x23\x59\x88\x6c\xdc\x39\xf4\x73\x43\x07\xc2\x3a\x9d\x07\xc5\x44\x1a\x29\x3a\x2e\x21\x3d\x5f\x32\x68\x5d\x9e\xe1\x1d\x47\x55\xfb\xf5\x8a\x2f\xb0\xc2\x26\x84\xa6\xad\xc1\xe1\x4f\x6c\x29\x7c\x90\xba\x1e\xa2\x7e\x7a\x02\xa8\x48\x4f\x8f\xd7\x20\x7b\x9e\x3e\x0c\xcf\x43\x83\x73\x6b\x4b\x2f\x4d\x3b\xaa\x4b\x3f\x3d\x76\xb6\x80\xaf\x3d\xd7\x6e\xf3\x90\xdb\x77\xcf\x5a\xf4\x24\xa9\xcc\x8d\x54\x5d\xc1\x97\x9d\xd7\x86\x9b\xcb\x57\x74\xdf\x2d\xe0\x49\x3c\x4f\x59\x81\x6f\xf9\xe4\xe5\xc5\x25\x24\x72\xcd\x75\x94\x9c\x97\x10\xa1\x52\xf7\x11\x84\xc8\xd3\x11\x1e\x9d\x6a\x25\x8f\x0b\x1b\xb5\x36\x93\xd6\xef\x8a\x4e\x68\xf4\x93\x1b\xcc\xb9\x36\x2d\x7f\x54\xe2\x96\x06\x61\xe4\x1e\xba\x16\xf1\xaa\xa4\x15\x3f\xcd\xa4\x48\xfd\x40\x31\x2c\xd7\xd8\xca\x2f\xcb\xec\x7a\x4a\x11\x37\x01\x74\xe0\x52\x3d\x82\x7d\xf4\x72\x5a\xb8\x7e\xe3\xa9\xbc\x11\x37\x54\xa5\xe4\xf0\xfc\xf4\xd3\x0b\xd1\xd6\xc5\x8f\xb8\x0b\xda\x60\xd2\xd7\xa8\x08\x28\xf4\x43\x6e\x34\x66\xb3\x43\x3e\xba\x89\x7d\x48\xf6\x00\x0a\x19\x22\x56\x84\x59\x71\xe5\x66\x11\xe9\x48\x82\xc8\xc4\x50\xd7\xd9\x3d\x74\xbd\x7f\xf1\xe2\x05\x86\x14\x5e\xfc\xf5\xaf\x7f\x25\xd0\x75\x31\x65\x09\xcf\x17\x6f\x84\xbb\xfe\xfc\xf2\xe5\x80\xfc\xfd\xf0\xed\x1b\x42\x13\xb0\xc0\x10\x52\x15\x47\x86\xb5\x8b\x7f\xac\x7b\xe4\xff\x5e\xbe\x3b\xab\xda\xbd\xd7\xbf\x05\xd6\xc8\xfd\xeb\x0d\xc8\x71\x94\x7e\x1e\xbb\xfc\xa9\x99\x40\x4a\xbe\x90\x86\xd0\xd1\x08\x98\x13\x45\x32\xd7\x5e\x5c\x78\x5c\x34\x3e\x9e\xf8\x6e\xdd\x96\xad\x32\xc8\x8b\xe7\x76\x8a\x10\x62\xf1\x50\x82\x98\xe6\x0f\x63\x85\xd3\x01\xa6\xd2\x23\x19\xbf\x66\x64\xa4\xa1\x67\x77\xd5\x44\x43\x31\x6d\xed\xa7\x84\x0a\x3b\x3a\x0e\x16\xa6\x6e\x27\xf1\xb4\x73\x17\x5a\x76\x77\xae\x31\xac\x6f\x0c\xe7\xeb\x92\x50\x9e\x58\xb2\x3f\xd5\x5c\x82\xba\xbe\x18\xde\x07\xb9\xc8\x41\xf1\x05\xb1\x49\x68\x26\xc5\x38\x66\xba\x4a\x8f\xf0\x09\x88\xb3\x82\x35\x25\x46\x47\xdd\x54\xba\xe9\x4d\x86\x92\xfb\x2d\x6d\xd9\xdf\xbf\x1e\x5a\x8d\xa0\x10\xe9\x50\x96\xc6\xa7\xbc\xe1\x93\x00\x02\x0b\x30\x12\x91\xe0\xad\x1e\xdc\x59\x63\x9a\xee\x5a\xbd\x75\xd4\x67\xa9\x7e\x10\xd7\x94\xcd\x1e\x61\x34\x99\x90\x6b\x36\xeb\xa3\x88\x2f\x28\xa0\x1f\x00\x9d\x8f\x2d\x75\xb1\xbf\x50\x3d\xa3\x20\x61\xa9\xb5\x03\xdd\x22\xf8\xcc\xc4\x8a\xeb\x03\x7a\x82\x37\x95\xb4\xd3\xa8\x5d\xdf\x22\x11\x39\x0e\x7d\xa3\xc2\x44\x0a\xe3\x9a\x20\x86\x46\x45\x90\x69\x39\x57\x61\x6f\x25\x0a\x4b\xed\xcf\xf4\x5d\x4f\xae\xd2\x31\xed\x91\xe1\x94\x89\x52\x2c\xfc\x1a\x90\xc0\x21\xef\x55\x33\x87\xe7\x43\x7d\x03\xbc\x28\xa5\x73\xc2\x13\xa8\xaa\xb1\xb7\xbb\x7b\x3d\x95\x02\x21\x6a\x08\x00\x9a\x99\xd2\x91\x06\x72\x69\xed\xb3\x99\xd6\x84\xc3\x1b\xe6\x54\x5d\x33\x0f\x66\x4b\xb3\x01\x39\xb7\x93\x0c\x38\xe5\xd8\x37\x6e\x8a\x45\x10\x56\xa6\xc4\xd0\x06\xf6\x21\xbb\x83\xc1\x2e\x9e\x85\x4b\x80\x0e\x5a\xf3\x4b\x97\x2d\xc3\x3a\x6b\x15\x56\xd7\x83\x68\xa1\xb1\x75\x9a\xb5\x0e\xa0\x3d\xa1\x04\xdc\x11\x33\xf1\xda\x02\x6d\x09\x3e\x1d\x5f\x1d\xf7\xac\xea\xb6\xed\x65\x77\x4d\x2f\x5b\x84\xc0\xeb\x57\xd7\xcd\x2e\x3b\x6c\x75\x59\x4f\x38\x76\xf2\xa7\x3a\x41\xba\xea\xbb\xd7\x79\x63\xc5\xbc\x83\xb6\x56\xfe\xba\x0d\xb9\x38\x5f\xc5\xba\x00\x45\xdb\xca\xf2\x27\x65\x4e\x9c\x8e\x40\x86\x2e\x47\x6b\x89\xac\xb4\x70\xa4\x58\x0a\xac\xdf\x8e\xe8\xa2\x57\x3c\xe9\xc8\xb0\x98\xbf\xda\x1b\x1a\xf3\x57\x9b\x64\x96\xf9\x6b\x61\x9f\x87\x33\xb5\x88\x4a\x69\x61\x89\x8c\x84\x1e\x8c\x26\x08\x83\x01\x79\xeb\xce\x5c\x64\x6e\x3a\xd4\x32\x2b\x4d\x80\x55\x58\x72\x20\xc3\xa0\xbe\x63\x23\xc2\x0d\xf9\xdb\xa2\xe3\x19\x14\x13\x3c\xb3\xba\x39\xa9\xf1\xea\x50\xd8\xb4\x4d\x46\xc5\xeb\x0f\x96\x92\x8a\x57\x87\xab\xe0\xf5\xc2\x8e\x57\xe2\xd2\x61\x4a\xfa\x3a\xc0\x9a\xf6\x0a\x69\xa9\x46\xa3\x6a\xec\x15\x51\x6c\x78\xd8\x14\x6d\xb9\xba\xda\x3b\x5e\xdd\xeb\x38\x6f\xe0\xe1\xf9\xe9\xa3\x5b\x99\xd1\xb3\xb6\x76\xe6\x4a\xd7\x12\x87\x2f\x00\x11\x78\x27\xd0\x71\x45\x51\x17\x60\xb3\xf2\xf7\x0f\x60\xae\x2c\xbc\xf8\x6b\x7b\xee\x44\x41\xa9\xb9\x96\x0f\xe8\xc1\xad\x4e\xa8\xa8\x4d\x84\x4f\x97\x01\x69\xf6\xfc\x4d\x9b\x0d\x35\x48\x80\xfa\x2d\xea\x5e\xe6\xaf\xf9\xc4\x52\x47\x44\x72\x09\xbd\xf6\xd1\x7b\x12\xb9\x61\x0a\x99\xbe\xc2\xa6\xcd\x54\x08\x69\xb0\xc7\x7c\x0f\x9b\xf5\xeb\x1e\xba\x57\xac\x92\x19\x25\x5a\xa9\x28\x84\xd9\xb1\x5a\xd9\x19\xf3\x90\xce\x19\x88\x00\x13\x01\xed\xce\xbb\xe1\x24\xf2\x08\xdc\x64\xaf\x4a\x2b\xe9\xb2\xaf\x7a\x3d\xdc\x88\xe3\x7b\x26\xd2\xc9\x84\xe5\x14\x1b\x5c\x78\x02\x59\x79\x7d\xa3\xb8\x31\x0c\xf1\xaf\x99\xca\x35\x91\xa3\x9e\x37\x91\x10\xf5\x64\xfa\x72\xa7\xbb\xfe\xf4\x8f\x60\x2b\x13\xbf\x43\x9b\xc2\x57\xdd\x76\xd5\x7d\xff\x35\x3b\xc2\xee\x4e\x30\x98\x33\xe8\xb8\x23\xe6\x9c\x90\x56\x89\x98\x22\xfd\x37\x9a\x74\x9b\xe7\x66\xe8\x05\x65\x74\xeb\x66\xd8\xba\x19\xba\x18\xf1\xd1\xdc\x0c\xd1\xc1\xed\x85\xa9\x5b\x80\xd8\xf5\x10\xe3\xbf\x7b\xff\x43\x85\xeb\x10\x61\x19\x5b\x96\xf7\x9e\x07\xa9\xea\xfe\xff\xdd\xc1\x60\x77\xd7\xfb\x23\xdc\xfe\x28\xcd\xa8\xff\x35\x61\x22\x91\x29\x32\x95\x1d\x5f\x69\x03\x4a\x6d\x65\x80\xc7\x73\xc9\xfd\xb3\xe2\x18\x02\x8c\xdd\x2d\x4b\x74\x28\xa1\x7c\xce\xc8\xeb\x47\x55\xc1\x2a\xc5\x2b\xc0\x57\x39\x02\x06\x94\x3f\xa7\x81\x55\x39\x2c\x19\xcf\xb9\xc3\xd5\xb3\xe2\x82\x69\xa3\xc9\x1e\x7e\x38\x48\x8a\xb2\xe7\x6e\x18\xe4\x2c\x97\x6a\xd6\x0b\x37\xd9\x2f\x6b\xbf\x72\x77\xec\x83\xd6\x96\x94\x4a\x31\x61\xb2\xd9\x1f\x57\x7f\xf3\x24\xde\x60\xf5\x2d\x70\x45\x9b\x12\x8b\x65\xd7\x5c\xd9\x45\x00\xb6\x07\x47\x5d\xa0\x36\x9c\x43\xae\xd8\xa1\x17\xdc\x47\xf0\x29\x13\x53\x32\xa5\xaa\x71\xb1\xc3\xb2\xeb\x51\x34\xb6\x94\x4f\xb9\x96\x8d\xcb\xc5\x96\x0e\xb9\xe8\xfd\xe2\xae\x11\x80\x2c\x4d\x51\x1a\x77\xba\xf8\xbd\xed\xa1\xe6\xc2\x9e\x9e\x53\x7c\x5f\xee\x74\x38\xb9\x82\x1a\xc3\x94\x78\x45\xfe\x7b\xef\xc3\xe7\xbf\xf7\xf7\xbf\xdb\xdb\xfb\xe5\x45\xff\x3f\x7f\xfd\x7c\xef\xc3\x00\xfe\xe3\xb3\xfd\xef\xf6\x7f\xf7\x7f\x7c\xbe\xbf\xbf\xb7\xf7\xcb\x8f\x6f\x7f\xb8\x3a\x3f\xf9\x95\xef\xff\xfe\x8b\x28\xf3\x6b\xfc\xeb\xf7\xbd\x5f\xd8\xc9\xaf\x2b\x0e\xb2\xbf\xff\xdd\x7f\x74\xf8\x12\x54\xcc\xde\x75\x26\x82\xf1\xea\x3f\x8a\x1a\x51\x1f\xbb\x63\xd6\x25\xe4\x63\xbf\x72\x5e\xf7\xb9\x30\x7d\xa9\xfa\xf8\x90\x57\xc4\xa8\xb2\x2b\xd1\x55\x1d\x7f\x8f\x27\x63\x2a\x25\xa6\x42\x6e\xf4\x86\xcd\x06\x0a\x11\xcc\x1c\x7d\x74\x6f\xb0\x6b\x97\xba\x75\x04\xaf\x72\x3d\x4a\xc2\x91\x43\x86\xf9\x83\x67\x1b\x5d\xba\x8e\xbc\xdb\x54\xa3\x85\x6b\x9b\x6a\xb4\x78\x6d\x53\x8d\x1e\x78\x6d\x53\x8d\x36\xd0\x07\xb8\x4d\x35\xda\xfa\x00\x9f\x88\x0f\x70\x9b\x6a\xb4\xea\xb5\x4d\x35\x6a\x7c\x3d\xcd\x54\x23\xa7\xc0\x57\x79\x46\x1b\x9b\x66\xe4\x1a\xfc\x1f\x26\x89\x2c\x85\xb9\x92\xd7\xac\x65\x54\x76\x25\x03\x73\xe1\x99\x9b\x69\x6d\x76\xa5\x52\x76\xa0\x02\x76\xa7\xfc\xd1\x32\xe5\xd6\xcc\xec\x78\x1b\x1c\xba\x61\xbd\x9d\x69\x8f\x45\x91\xb2\x34\x3c\xcf\x0b\x2b\x63\xd7\x7b\x40\x0e\x89\x62\x09\x2f\xb8\x15\xed\x00\xa6\x03\x9f\xe3\x3e\x09\xfd\x80\xb9\xd1\x2c\x1b\xb9\x9e\xa8\xa2\xaa\x19\x56\x91\x09\xe9\xce\x8a\xa5\x8f\x41\xad\x40\xfa\x36\x96\x44\x4f\x64\x99\xa5\x44\xb1\x7f\x79\x75\xc2\xcd\xe6\x2a\x1e\x21\x76\x84\xc2\xab\x54\x8f\x75\x83\xd3\x82\x3b\xd4\xad\x4d\x12\x70\xec\x63\xc1\x15\x6c\xb6\x4b\x96\x48\x91\x76\xed\xde\x38\x99\x1f\xdf\xaf\xb5\x8b\xe6\xb0\x94\xa4\x25\xde\x00\x85\x90\x34\xe3\x29\x37\xb3\x90\x85\x81\xdb\xde\x2a\xa2\xd8\x85\xd6\x31\x82\xae\x16\x82\xd0\xa2\x50\x92\x26\x13\xa6\xa3\xb7\x41\xb5\xd2\x81\x4d\x84\xfa\xca\xac\x1c\x73\x81\x9a\x25\xfc\xc6\xaa\x21\xd9\x8c\x28\x69\x7c\x42\xd9\x2d\x0f\xbc\x8a\x06\x83\x9f\xa3\x2e\x61\xd4\x0c\xb2\xce\x64\x3c\x04\xce\x8a\x8f\xe2\x3f\x34\x91\x59\xea\x71\x4b\xbf\x7e\x61\x55\xf9\xc4\x71\xb1\x95\xf6\x80\x2a\x69\x24\xc9\xac\x5a\x64\x4f\x80\xdb\x7f\xfc\xc5\x57\x64\x22\x4b\xa5\x07\x31\x84\xc0\x4b\xf8\x0c\x9d\x14\xde\x14\x30\x24\x63\x54\x1b\xf2\xf2\x05\xc9\xb9\x28\xed\x59\xde\x11\xe3\x75\xa5\xbd\x46\x7a\xeb\x5f\xbe\x6a\x39\x5a\x37\x1a\xeb\x62\x06\x8b\xe3\xd6\x02\xfb\xb3\x39\xc5\xd5\xed\x71\x04\xc5\xc0\x1e\x8d\x73\x6a\xac\x3b\x92\xe2\x55\x14\x46\xae\x79\xe7\xff\x56\xca\xe1\xcc\xb4\x87\x81\xf9\x2f\x1c\xa7\x8e\xff\xe2\x3f\x5c\x05\x4b\xb5\x82\x52\x6d\x30\x95\xb5\x77\x8b\x1e\x73\x6d\x1a\xf5\x8a\xae\x70\x63\x1a\xfc\xb8\xed\x61\x3e\xb6\x16\x6f\x27\x45\xeb\x60\x3b\x7b\x5b\xcd\x3b\x95\x93\x84\x69\x10\x45\x1e\x3e\x0d\xfc\xb3\xf8\xd4\x86\x0f\xdd\x2c\xc4\x96\x3b\x11\x59\x3c\xf3\x77\xd0\x19\xb3\x15\xb1\xda\xe8\xf6\x9e\xb1\x3b\xa2\x16\x0e\x56\x97\x11\x9a\x8b\x31\x36\xb2\xcc\xcb\xcc\xf0\x22\xab\x28\x17\x7e\xe0\x0e\xe0\xd8\xe1\x4f\x23\x0f\x33\x45\xe0\x28\x84\x06\x87\xe0\xc8\x5e\x18\x8b\x09\x83\xfd\x18\x95\x3d\xc7\x0b\xaa\x68\x20\x7f\x22\xf3\x9c\xea\x7d\x17\x3b\xa0\x90\xbb\x82\x92\xdd\x1e\xc3\x8a\x66\xe1\xf5\xe3\x5c\x81\x75\x31\xae\x61\x82\x8a\xc6\x41\xbb\xba\xc3\x05\x86\x22\xf2\x26\xa4\xc7\x63\xff\xf4\x39\x8e\x75\x0a\xf1\xf7\x34\xb9\x66\x22\x25\xef\xb5\x27\x5c\x3a\x13\x34\x77\xe0\xea\x85\x92\xd8\xb7\x9b\xa5\x73\xbf\xd7\x3d\xe7\x48\x44\x94\x11\x0f\x02\x85\xfa\xd6\xba\xa8\x58\xea\x8e\xd0\x75\xdf\x6b\xab\x7c\xdd\x2d\xef\x34\x3a\x69\x15\x9f\x26\xcc\xeb\x8e\x76\x02\xeb\x7a\xf9\x69\x63\xc4\x37\xb2\x1c\x87\xc9\x35\xcd\xc4\x5d\x08\x47\x7a\x08\x3e\x02\x8e\x3a\xcd\xac\x88\x9b\x05\x78\x9d\x39\x06\x1b\xce\xd6\xd7\xb2\x5f\x0d\xdb\x03\x34\xed\x5e\x7c\x7f\x5c\x17\x66\x17\x34\x95\x9a\x7c\x9f\xc9\xe4\x9a\x1c\x33\x30\x1a\x1e\xb3\xdd\xbb\x1a\xa6\x4f\xbb\x4d\x63\x4e\xc7\xcd\xf2\x3c\xfa\x24\x97\x82\x1b\xa9\x9a\xc8\xe3\x0d\x02\xdb\xdb\xb6\xda\x5b\x0e\x22\xae\x86\xe9\xb3\x69\xb4\x67\x99\xbc\xa3\x0e\xbb\x13\x46\x14\x88\x18\x18\xd4\x77\xff\x68\x28\x30\xfe\x34\x91\x37\x7d\x23\xfb\xa5\x66\x7d\xde\x38\x4f\xa9\x35\x7d\xae\xd9\x0c\x92\xbe\x3a\xa1\xd0\x8f\x38\x58\xcd\x44\x37\x12\x3c\xe7\xf0\xb9\x55\xe4\x2e\xbe\x3f\xb6\xa7\xf7\x20\x36\x4b\x0e\x98\x49\x0e\x12\x56\x4c\x0e\xdc\x74\x9e\x3c\x59\xbd\x7c\xec\x86\xae\x87\x24\x91\x59\xe6\x70\xbb\xe4\x88\x1c\xb1\x62\x12\x1e\xb1\x19\xb4\x7a\xca\xcd\xd2\x0a\x29\xbb\x69\xac\x14\x89\x08\x3b\xa6\x93\x10\x11\xa3\xab\xe1\xc3\x7a\x41\x6f\x22\x6b\x7f\xc2\x9e\x24\x4d\x7a\xcb\x6d\x04\x79\x37\xa7\x47\xdd\xee\xa5\x1f\x0e\xfc\x3f\x51\xb8\xb9\xde\x92\xce\xe7\x8b\xd6\x44\xf4\xe9\x08\x2d\xcc\x94\xa5\x44\x4e\x99\x52\x3c\x65\x9a\x04\x19\x1d\x3b\x96\x78\xb6\x19\x94\xdf\x76\xc7\x7b\x5a\xf9\x01\x9b\xe3\x53\x88\x84\xb7\x1d\x73\x51\x78\xd3\x34\xe7\x62\x33\xb8\xbc\x21\xbd\x74\x42\x33\x76\xfa\xae\xb5\xe9\x7d\x89\xe3\xd4\xad\x6f\xff\x61\x04\xb2\x7f\x0f\xf0\xfc\x8f\x81\x67\x89\x90\x69\xb3\x68\xd8\x9a\x6d\xe8\x31\x35\xec\xa6\xa1\xe2\xd3\xaf\x44\x7d\xd3\xdf\x83\xe5\xf5\xb4\x6d\xf0\x35\x35\xc8\x88\xf6\x35\xa2\xde\xaf\x4b\x9d\x72\x1c\xd4\x8d\x6b\xd9\x93\x62\xae\xbf\x98\xdf\x9a\x87\xe7\xa7\xe4\x07\x7c\xde\xfa\x3a\x7e\x28\x69\xd0\x92\x39\x96\x39\xe5\x1d\x35\x62\x8f\x1a\x3a\xc5\x2f\x7c\x1e\x1e\x46\xf0\x69\x71\x17\xfa\x11\x1f\x97\x8a\xa5\xc4\x79\x3f\xb6\x6d\x0c\x36\xb8\x8d\x41\xb7\x4a\x71\xa5\x13\x47\x1e\x73\x5f\x19\x53\xe9\xc1\x9e\x8b\x40\x1d\x08\x29\x48\x44\x33\xa1\x39\x64\x1d\x44\x89\x71\xa0\x2c\x43\xfe\x77\x28\x83\x41\xc5\xb9\x47\xde\xc8\x31\x17\x5e\x3a\x49\x97\xec\x32\xa2\x3c\x6b\x47\xce\xad\xa6\xfb\x07\xd3\x74\xb5\xce\x4e\x04\x1d\x66\xcd\x33\x19\xeb\x07\x6f\x46\x21\x4f\x8a\xc1\x98\x07\x29\xd7\xf6\x5f\x72\x79\xf9\x06\x62\xb3\xa5\xf0\x96\x21\x44\x1d\xdd\xb1\x11\xea\x8b\x51\xb8\xac\x4f\x1e\xa0\xcc\xee\xac\x4f\xc5\xa9\x48\xed\xeb\x32\x5d\x4b\x00\x76\x4f\xc1\x2e\x20\xa1\x7a\x0d\xb3\x0f\x87\x8c\x5c\x4d\x78\x72\x7d\x1e\x85\x60\xa5\xb2\x9f\x89\xe8\xa3\x9a\xa2\x31\xff\xdd\xba\x0e\x1c\xf7\x5a\xe7\x5d\xb9\xbd\xae\xa2\x13\xf7\xd2\x91\xcc\x0e\x4e\xa8\xd6\x32\xe1\x55\xcc\x1f\x9c\xc2\xd5\x91\x9c\xc2\x91\xbc\x3e\x32\x80\x96\xf8\x28\xfa\x87\x67\x1c\xa7\xb4\x52\x1d\xeb\x1b\x5c\x78\x6a\xad\xed\xd5\x91\x95\x3b\xeb\xae\x79\x55\xeb\xa7\xe9\xad\xbe\xb9\xf0\xb3\xaf\x07\x75\x8c\xe2\xf5\x79\xd7\xc0\x79\x91\x55\x42\x5f\x4d\xd7\xdf\x63\x2d\xc4\x6a\x5e\xac\xbd\xcc\x0b\x37\x97\x7b\x83\x9f\xb9\x80\x34\x08\x95\x42\x16\x65\x86\x59\xab\xed\xdb\x8a\xfa\x68\x1e\x3e\x67\x0d\x01\xea\x4d\x6b\x46\xf4\xd0\x72\xbe\xe7\xd1\x97\x28\x32\x08\x5e\xfc\xe5\xab\xaf\x9e\x7a\xa7\xa2\x76\x8e\xb3\x75\xb7\x2a\x6a\x15\xea\xda\xa2\x14\x6c\x51\x0a\xee\xba\xd6\x1e\x89\xfd\xf4\x38\x04\x9d\x14\x89\x75\x51\x20\xd6\x16\x69\xa0\x65\x71\x59\x37\x85\x65\xad\xb1\x04\x1e\x15\x41\xa0\xa3\x1a\xab\xf6\x68\x01\x5b\x8c\x80\x3f\x06\x46\x40\x77\xb5\x55\x5d\xe1\x01\xb4\xaf\xa9\x7a\xfe\xb5\xff\xad\xc5\x44\xdb\x0a\xf3\x87\xd7\x95\x77\xd5\xbf\xa2\x2b\x3f\x7b\x67\x8e\x81\x9a\x57\xd7\xd9\xbb\x9e\x33\x30\xf3\xba\x42\x7c\x37\xd2\x0a\x8d\x35\x5a\xbb\xa4\xb5\xb3\x00\xa7\x22\x1b\x9d\xc1\x75\xae\xc1\x91\xde\x5d\xce\x85\xd8\xc3\xc7\x9b\x1f\x59\xdf\x86\x98\xb7\x6d\xd4\xb7\xf1\xc7\x70\xdd\x12\x7f\xd4\x35\x8c\x57\xef\x11\x04\x49\x08\x2a\x98\x1c\xc6\x7d\x54\xaa\xfd\x7f\x78\x7e\x4a\x12\xc5\x00\xd2\x80\x66\x7a\x40\x96\x68\x68\x3e\x52\xe3\x34\x3a\xaf\x99\x51\x63\x58\x5e\x98\xb6\x0c\xb7\x0d\x3f\xfe\xc1\xc2\x8f\x1d\xc7\x0c\x7e\x0a\xc3\x79\x6f\xd1\xa4\xcc\xa9\xe8\x5b\x69\x01\x81\xc8\x5a\x3e\xc7\xdc\xc1\x37\x20\xbe\x06\x0e\xa9\x49\x15\x43\x70\xf3\x52\xf0\xdf\x4a\x56\xf9\x17\x82\x7a\xb1\x01\xa1\x16\x98\x47\xc7\xb4\x43\xd5\x69\x4e\x8a\x24\x72\xa1\x94\xc9\x11\x24\xd0\xd1\x0b\x8c\x48\xff\xaa\xf9\xca\xcc\x84\xa1\x9a\x76\x0e\xe0\x00\xd5\x5d\x75\xfb\x0e\x0d\x3c\x9a\x65\xf2\x06\x9f\x1d\x2b\x1e\x76\xfd\xec\x5c\x1c\x1e\xc7\x90\x91\x9c\x2b\x25\x95\x0b\xf1\xc4\xd3\xc1\xb4\x1c\x6b\x27\x32\x85\x06\x97\x72\x59\x15\x97\xcc\xc4\xac\x62\x24\xa1\x02\x0b\x17\xed\x7f\xfb\xa4\x64\xec\x7f\xe6\xe4\xdd\x90\x4d\xe8\x94\xcb\x52\xe1\xaf\x8d\x24\x3b\xee\x2b\x38\x72\x67\xb2\x0c\x6e\xee\x12\xea\x94\xc2\xdb\xe9\x25\x74\x3a\xab\xbe\x04\x03\x35\x95\xde\x7f\xd8\x67\x1f\xb9\x36\x8b\xef\xe2\x49\xe4\x1b\x24\xac\x83\xf3\xa6\xba\xb0\x07\xec\x4f\x8d\x6b\x4e\xeb\xfc\x16\x8f\x56\x57\x49\xa7\x97\xf0\xd5\x7d\x0a\xa9\x43\x6a\xc1\x52\x71\x5f\x14\xf6\xf4\xd2\x3d\xf1\x2d\x1b\x76\x66\xda\x6a\xc4\x4f\x45\x23\x0e\x09\x12\x19\x4f\x66\xa7\xc7\xdd\xe8\x7c\x21\x31\xc2\x0e\x4a\xbe\xa7\x9a\xa5\xe4\x2d\x15\x74\x8c\xce\x91\xbd\xcb\xf3\xef\xdf\xee\x5b\x26\x01\xe7\xcb\xe9\xf1\xd2\xec\x89\xcb\x78\x66\x67\xeb\x2a\xdf\x26\xf3\x34\xea\x4c\x2b\x78\x20\x95\xd6\x56\xc0\x4e\xc2\xc9\xde\xa6\x65\xd7\x22\xb8\x11\xa6\x43\x78\xa4\x32\x3d\x2f\x5e\xa7\x79\x7a\xfd\x98\xaf\x1b\xf9\xaa\xef\x7a\xa7\xd5\x02\x4d\x2b\x04\x93\xe6\xd6\x5e\x51\xc3\xc6\xb3\x63\x56\x64\x72\x66\x97\xfb\x3c\x72\x9d\xe3\xad\x43\x3c\xea\xd5\x90\x26\x44\x95\x19\xc3\xee\x35\xf3\x10\x61\x82\xb1\xb4\x92\x53\x5c\x68\x43\x01\x20\x0c\xc7\xbf\x73\x46\x2b\x1f\x30\xab\x1e\x25\x7d\x9c\xe7\xbd\x77\xd5\xe1\x14\xed\x86\xba\xf3\x27\xab\x1f\x26\xf0\xf8\xfb\x39\xf4\x21\xc1\xc3\x95\xc3\x84\x75\x06\x87\x3d\x7d\x51\x66\xf6\xe8\xc8\xd2\xb9\x26\xa2\xa0\x5b\xb9\x35\x46\x64\x06\x90\x00\x76\xf6\x3d\x32\x2c\xad\xe2\xc5\x74\xcd\xbf\xbc\x08\x4b\x79\x33\xc1\xb8\xb1\xfd\x11\xa1\x45\x91\x71\xcc\xeb\x95\xca\x05\x7f\x23\x6f\xe3\xe2\x6d\xab\x08\x92\x07\xea\x1f\x0f\xd3\x37\xfa\x64\xca\xd4\x70\x15\x4c\x85\x87\xaa\x12\xb4\xe0\x10\x3b\x59\x59\xf3\xa8\x83\x42\x9e\x9f\xe2\xaf\xbd\xa5\x16\x9b\x66\xfe\x4b\x5c\x41\xb7\x36\x1e\x50\xd0\x75\xa5\x41\x6b\x23\xa0\x02\x1d\x9e\x9f\x22\x0c\x95\x03\x06\xaa\x5c\x16\x56\xb7\xa7\x98\x1c\x58\xa1\x11\xd2\xb1\x1d\xd1\x10\x29\xc2\x43\x99\x28\x73\x86\x60\x42\x55\x3b\x2b\x6b\xf0\x89\x59\x35\x7a\xe5\xf1\xb0\xf6\xc9\xea\xea\xc4\xc3\xc3\xe8\x0f\x0c\x9b\x3f\xf8\xe4\x11\x52\x5c\xb8\xd7\x7c\x7f\xf1\xa6\xd9\x22\x9e\xd5\xc7\x70\xe0\x31\x0c\x70\xf2\x0a\xaa\x0c\xa7\x19\x29\x55\xe6\xc3\x70\x98\xf4\xee\xd2\xd2\x26\x74\x1a\x01\xec\x0c\x08\xf9\x0c\x57\xce\x11\x16\xf7\x27\xb6\x77\xc5\x95\x1f\x95\x59\xd6\x23\x23\x2e\xa8\x15\xbb\xac\x20\x71\x38\xe8\x92\x8b\xc4\x9a\x5f\xd6\xd6\x77\xfd\x5a\x60\x46\xde\x28\x0b\x9b\x14\xa2\x8c\x10\x2d\x65\x59\x0a\xa0\x8b\xf0\x08\xbb\x61\x13\x70\x11\x58\xab\xf1\x28\x2b\xb5\x61\xea\x42\xda\xc3\x20\xca\x6b\x01\x38\x0a\x1a\x7f\xfd\x3d\x17\x29\xa4\x30\x5d\xc0\xc1\x91\x50\x41\x18\x07\xe7\x8b\x1d\x12\xe2\xd4\x96\x77\x2a\x86\xda\xd3\x65\x32\xb1\xaf\xb4\x53\xc8\x54\xef\x58\x31\xb2\x83\x2e\x3a\xbd\xb3\x6f\xff\x9a\x7f\x07\x4c\x53\x89\x7e\x77\x40\x0b\xbe\xb3\xdf\x23\x40\x20\x08\x9c\x49\x33\x79\xba\x7c\xe8\xdf\x15\x6c\xe2\x46\x5c\x78\x11\x8f\x00\x3c\x28\xaa\xee\x5f\x37\x13\x6e\x58\x68\xbe\x8d\x9e\x9d\x80\xaf\x32\x2f\xac\x09\x39\x14\x84\xe5\x85\x01\x6f\x31\xc9\x19\xf5\x21\x64\x36\x65\x6a\x66\x6d\x72\x00\xa2\x78\xf2\x9b\x3f\xf0\x63\x2b\x82\xcf\x75\x36\xaf\x98\x1c\x76\xd8\x02\x71\x77\x3f\xdb\xad\xd9\xf9\x59\x16\x49\xf3\x27\x4b\x4a\x38\x5e\x1b\x91\xf1\x27\xfb\xcb\x3a\x09\xf1\x23\x94\x96\x41\x7e\xbc\x79\xe3\x02\x19\x48\xab\x1f\xb9\x48\x51\x45\x3d\x34\x46\xf1\x61\x69\xd8\x05\xb3\x13\x4e\x30\xe5\xc1\x77\xe1\x73\xd9\xd1\x6e\x25\x96\x92\x1f\xe6\xfe\x14\x49\xbf\xa8\xd8\xae\xaa\x8c\xde\x31\xbc\xd7\xe5\x6f\x1b\xea\xce\x01\x9c\x41\xf0\x56\xa6\xcb\x37\xd5\x5c\x65\x48\x75\xb3\x53\x55\xa2\xce\x96\x7e\x2c\xa7\xc4\xce\x8a\xa5\x9a\xfe\xdd\xcb\x71\x07\xe9\x6f\x9b\x49\xe5\x1b\x00\x09\x1a\x7d\x73\x35\x2b\x98\x43\xda\x26\xa3\x8c\x8e\x2b\x36\x02\x79\x88\xea\xd3\xd1\xe5\x4f\xfe\x15\x34\xe1\xcb\x15\xd9\x7b\x35\xdd\xfb\x74\xdb\x7e\x45\xa5\x5b\xef\xb0\x0f\x59\xfa\xe5\xfd\x0a\x6e\x18\xfc\x76\x6e\x5a\x25\xec\x67\xee\x74\xa9\xdd\x46\xff\x2b\x87\xf0\x45\x23\x4e\xf0\x00\x62\xde\xdc\x84\x4c\x24\xd0\x50\x2e\x7f\xaa\xb1\xc9\x3d\xf3\xbd\x85\x69\xaf\xd9\xec\x46\xaa\xe5\x68\xe0\x8d\xf9\xeb\xce\x27\x62\x77\xfe\x7b\x37\xc8\x5b\x5a\xd8\xd7\xae\xf2\x3c\x51\xe0\xb9\xa8\x23\x5a\x05\x98\xa1\xe5\xb3\xe2\xa4\x1a\x53\xc1\xff\x8d\xc9\xb1\x89\xdd\xc7\x52\xd9\x3f\xf7\x30\x72\x81\x16\x7d\xc6\x12\xb3\xef\xf8\x6f\xa9\xdc\xbb\x87\x41\x69\x9a\x72\xd4\x2b\xce\xef\xe1\xa5\xbb\x89\xc0\xc5\xf5\x63\xd0\xfc\x8e\x8d\x75\x3f\xef\xdf\x1d\xfa\x5c\x41\x36\x97\xea\x8e\xec\xa6\x3b\x7f\x9f\x53\xee\x3a\xba\x6e\x1c\x55\x58\x4e\x79\xd3\xd7\xc2\xab\x05\x5d\x73\x6a\x4a\xc5\xcd\xd2\x03\xe9\xee\x1f\x72\xf1\x63\x39\x64\x2e\xda\xfb\xe0\x9f\x0b\x48\xde\x3b\x3c\x3f\xed\x76\x39\x16\xe1\xa5\xdd\x04\xad\x46\x43\x4a\x41\xf3\x21\x1f\x97\xb2\xd4\xd9\x2c\x76\x57\x52\x08\x56\x5b\x73\x1f\xfd\x35\x62\xd7\x10\x2a\xa4\x98\xe5\xee\x56\x91\x64\x65\xca\x6a\x23\x42\x4c\x6f\x2a\x79\x4a\x68\x69\x64\x4e\x0d\x4f\x48\x22\xf1\xbb\xfa\x48\xa5\x66\x84\xde\xf2\xdb\xa4\xd4\x46\xe6\x24\xa7\x4a\x4f\x68\x96\xdd\xb6\xc6\x1d\x9c\x6a\x77\x01\x68\xf7\xe1\xfd\x6f\xfd\x72\x8a\xb3\x6e\xc8\xdf\xf7\xe0\x85\xaf\xc0\xdf\x76\x72\xad\x06\x98\xde\xce\xa5\x2b\x8c\xe1\x4a\xe2\x97\xc2\xf5\xdc\xb3\x30\xf7\x51\xe7\xae\x9d\x7b\xef\x7b\xdd\x21\x0d\xef\xfc\x2d\xa4\xce\xb2\xf4\x34\xa7\xe3\x15\x14\xc9\x37\xd6\x6e\xa0\x62\xe6\x7f\x86\x28\x92\xba\x47\xa4\x72\x39\x20\xa1\x27\xb7\xfb\x2a\x00\x90\x2a\xf2\x0e\xc2\x6c\x52\xb9\x64\x6a\xc7\xa5\x90\x5a\xcf\xd4\x48\xaa\xdc\xea\x75\x5c\x91\x51\x29\xd0\xb4\x70\xb9\xd7\x60\xac\x38\x2f\x0e\xcd\xb4\x0c\x3b\x10\xe2\x76\xc2\x4f\x82\x50\x4d\x6e\x58\x96\x0d\xc8\x61\x96\x39\x78\xcb\x08\x1a\xa1\x2a\x79\xae\x32\x04\x86\x33\x92\xf2\x31\xd3\x86\xec\x5d\xfe\xed\x70\x1f\x4e\x6d\xf0\x70\xcc\x88\xa1\xbe\x4e\xac\xee\xb9\x81\xf3\x3f\x2d\x41\x4f\x48\xa8\xa1\x99\x1c\x63\x90\x1c\x3c\xb8\x22\x25\x45\x46\x67\x00\x52\x5f\x50\x05\x89\xa2\x09\x7a\x6f\x88\x2a\x05\xc0\xf3\x7e\xd2\x13\xe7\x7e\x51\x70\x17\x82\x6e\x1f\x78\xb2\xe1\x56\xbf\x07\xb5\xf4\x71\x8f\x32\xc5\x8a\x8c\xde\xe2\x6f\xb8\xa3\xec\xd7\xaa\xb9\x60\xc2\x4a\xc1\xc2\x18\x03\x72\x89\xbc\x93\x53\x93\x60\x08\xf3\x9f\x39\x33\x34\xa5\x86\x0e\xac\x2d\xf8\xcf\x7a\x61\x9a\xcc\x52\x3b\xd0\xed\x0b\x7d\xcb\x9c\x51\x5f\x5c\xde\x8c\xbd\xbe\x0b\xad\x52\x1b\x6e\x07\xfd\xdc\xef\xc7\x3b\x1d\x1c\x2d\xe5\x13\xbc\xfe\xc9\x47\x6b\x8a\xdd\x19\x5d\xab\xcd\x75\xfe\x47\x75\xff\x43\x56\x7f\x13\xc7\xad\x39\x03\x5c\xc4\x2b\xd7\xcf\xc7\x7f\x02\xce\xd5\xc3\xb3\xe3\xdb\x1d\x61\xf7\xbb\x0c\xee\x71\x11\xd4\x43\x06\x77\x4c\xcf\xbb\x9e\xdd\x37\xf5\xb8\x81\x2f\x4e\x81\xfa\x3d\x2c\xf5\xa0\x1e\x3c\xc5\xdf\x8c\x0b\x56\xaf\x3c\xc4\xdf\xdd\xee\x1f\x59\x29\x70\xb3\x4a\xb8\xe6\xbe\x42\xaf\x7e\x98\xec\xad\x37\xad\x16\xbd\xb9\xb7\x18\xab\x46\x70\x57\xed\x08\xc5\x95\x40\x79\x28\xd9\xf0\xce\xd3\x40\xec\x55\xa3\x5d\x2b\xfa\x77\xfc\xab\x3e\x60\xa2\x61\x29\x6b\x69\x44\xd7\x6c\xb6\xab\x5d\x2d\x8a\x14\x7a\xc2\x0b\xac\x16\x74\x01\x0a\xb7\xba\xe4\x27\x9a\xf1\x34\x0c\x81\x5c\x7d\x2a\x7a\xe4\x4c\x1a\xfb\xcf\xc9\x47\xae\x0d\x9a\x9f\xc7\x92\xe9\x33\x69\xe0\x93\x4e\x5e\x15\xa7\xf0\x80\x17\x75\x06\x30\xfa\xb8\x61\x5f\x45\x66\xb2\x7f\xa1\x53\x27\xf6\x3c\x51\xb8\x26\xa7\xc2\x6a\x04\xee\x8d\x42\x15\xad\x76\x43\xf8\x42\x11\x21\x45\x1f\xbc\xdf\x4b\xc7\x70\x84\x90\xaa\x46\x87\x3b\x86\x73\x43\x61\x3a\x1f\x7c\xc3\xb5\x17\xe2\xe1\xcc\xa6\xde\xed\xc6\x13\x92\x33\x35\x86\x78\x4e\x72\x4f\x3c\x63\x55\x57\xe4\x4a\x0e\xc8\x7b\xd7\x0a\x44\xe6\x9b\x5b\x1d\x17\x0b\x8b\x14\xdd\x8f\x62\x29\x47\x6f\xc6\xff\x58\xe9\x03\x94\xfa\x5f\x28\xa5\xd6\x03\x72\xe8\x9b\xa5\xc4\xdf\xb9\xb8\x56\x3c\x8c\x1d\x81\x6b\x62\x45\xc9\x94\x66\x0c\x91\xe3\xa9\x08\x55\x50\x72\xb4\x20\xd8\x7b\xae\xa4\xda\xee\xd9\xa0\x32\xed\x5c\xb3\xd9\x4e\x6f\x61\x69\x77\x4e\xc5\x4e\x55\x02\x57\x5b\xcc\x20\x44\x41\xdb\xda\x81\xef\x76\x9a\x9f\x05\x77\x0a\xcb\xd5\xdd\x2b\xf7\xae\x9b\xbe\xe6\xcb\x03\xd3\x4b\x95\x8d\x3d\xbd\x6f\x49\x08\xc1\x60\x45\x72\xa9\xc0\x9d\x69\x3f\x8d\x81\x34\xac\xaa\x7a\xcd\x8b\xa2\xc2\x1d\x29\x8b\xb1\xa2\x29\x23\x63\x45\x8b\xc9\x43\xd5\x12\xd4\x6d\x96\x0d\xff\x64\x14\xdd\x5b\x88\x7f\x87\x45\x57\x23\xbf\x37\x40\xbc\xe1\x0d\x9b\xe5\x46\xd1\xa2\x60\x8a\x50\x25\x4b\x70\xda\xe5\x53\xa6\x06\xfe\x16\x4c\xb9\x08\x7e\xe6\x44\x2a\xc5\x12\xe3\x4d\x74\x97\x15\x8c\x05\xab\x22\x85\x6a\xd4\x07\xab\x7d\x37\x6c\x38\x91\xf2\x1a\xaa\xe6\x80\x1d\x1f\xd1\x0b\xf2\x33\x3e\xeb\xb8\xfa\xcc\x1b\xb4\x9a\xa4\xcc\x50\x9e\x41\xae\xc9\xbb\x37\x6f\x5d\x36\x8a\xd7\x26\xfc\x2c\x97\x27\x76\x74\x60\x86\xd0\xd4\x65\x49\x5d\xb0\x29\x67\x37\x8e\xfe\xb7\xe5\x91\xf4\xc9\x98\x09\x48\x9e\xb8\x23\xc9\xa8\x4f\x34\x4f\xd9\x09\x14\xe3\xde\x3e\x50\x0b\xf7\xfd\x2d\x73\xbe\x4f\x84\xdc\x7d\x8e\xdc\x7b\x86\xac\x70\xd6\x07\x23\xfc\x5c\xaa\x3b\x80\x7f\x56\xab\x0d\x5e\xad\xee\xd7\x65\xa7\xbf\x22\x5f\x7d\xf5\xe5\xad\x37\xe5\xf4\x23\xcf\xcb\xfc\x15\xf9\xcb\x9f\xff\xfc\xe5\x9f\x6f\xbf\x8d\x0b\xbc\xed\xe5\xed\xef\xe7\xf6\xfc\xd1\xc5\xf1\x06\xd0\x3b\x0d\xd9\x7e\x77\x87\x06\x57\x18\x6a\x44\x79\x56\x2a\x97\x92\xba\xa2\xa1\xf2\x3a\xfe\x0d\x84\x75\xaa\x62\x0a\xea\x47\xf4\xc9\x68\x2e\x49\x6d\xc4\x05\xd3\xd0\x1a\xa5\x14\x8a\x25\x72\x2c\xf8\xbf\x59\xea\x3b\xa3\x40\xe2\x09\x00\xac\x7b\x16\x27\x4c\xa4\xd8\x93\xd2\x9e\xbc\x13\x2a\xd2\xec\xae\x84\x84\x15\xde\x34\xde\xc1\xad\x48\x06\xe7\xdf\x83\x08\xf6\xb6\xfa\xc5\x1c\xb9\xa0\xb3\xa6\x0b\x82\xe1\xb9\x8a\x64\x6b\xf5\xa6\x28\x18\x2f\xef\x30\xef\x97\xcc\x71\xc1\xfa\x44\xc3\x19\x3e\xfb\xad\x64\x6a\x06\x85\x23\x95\x79\x11\x25\xaa\x5d\x55\xb8\x02\xfe\x35\x9c\x5e\x87\x48\x2e\x73\x16\x79\xa5\x4a\x55\xe9\x28\x73\xcf\x86\xdf\x30\x0c\xe2\xfb\x70\x16\x39\x24\xa2\xcc\xb2\xdb\x6e\x15\xf2\xae\xc0\x57\x4c\xbb\x7b\x0c\xda\xd5\x2c\xcd\x55\x9d\x13\x4b\x28\xfd\x49\x5d\x14\xf1\x8b\x77\x64\x50\x6c\xb6\xd3\x22\x7e\xe1\x95\x72\x4e\x57\xcf\x37\x5d\x0d\xaf\x66\x05\x67\x06\x5e\x0f\x49\x48\x5d\x11\x65\xe6\x31\xdd\x1b\x78\x3d\x28\x7f\x68\x35\x57\xc7\x92\xa9\x6f\x9c\xc3\xa3\xc1\xcb\xaf\xe2\xfc\x58\xf2\xea\x5b\x17\xc8\x02\xc1\x57\xcd\xc9\x7a\x40\x3e\xd6\x8a\x2b\xb9\x82\x6b\x04\xaf\xad\x83\xe4\x41\x27\xd1\x0a\x82\xf9\x61\xce\x92\x95\x57\x55\x31\x2e\xa6\x12\x51\x9a\x1f\xa4\xc3\x5d\x2c\xfc\x70\x4e\x95\xbb\x01\xc9\xea\x74\xb9\xa0\xfc\xc6\x2a\xad\x35\x68\x49\xa9\xef\x77\xb9\xdf\xfd\x06\x77\xd7\xa6\x74\x62\x83\xd4\xdf\xbc\xcc\xd8\xcf\xdc\x4c\xde\x79\x34\x76\xc7\xd5\xa6\x2c\x32\x78\xd9\xe8\x0b\xcb\x42\x17\x95\x66\x78\x8a\x1d\xbc\x58\x22\xf3\x9c\x89\x14\x53\x99\x72\x7a\xcd\x48\xd5\x08\xd2\xea\x78\xa0\x06\xc3\x70\xec\x63\x41\x45\xa5\x27\x4e\xad\x2c\xbf\x8b\xa3\x56\xe4\xa7\x55\xcf\xda\x95\x8b\x3e\xee\x2e\xf6\x88\xaa\x35\x6a\x45\x1d\x64\xc8\x32\x09\x4e\x1c\xcc\x57\xc5\x5c\x6b\x77\x2b\x88\x64\xf7\xa9\x3b\xf5\x1c\xf2\x23\x13\xe3\x0a\x67\x4a\x67\xd0\xa4\xd5\x49\x60\x29\xd8\x80\x5c\x38\x15\x66\x35\xad\x68\x15\x71\xba\xa2\x28\x5d\xf9\x40\xac\xb0\x19\x1e\x4c\x59\xff\xbb\x98\xb6\x53\xff\xd9\x2a\xd4\xf5\x37\x3f\x67\xfa\x86\x4e\x09\x0f\x23\x6f\x7d\x4b\x57\xa7\x42\xa0\xed\x9c\xf0\x4a\xb0\x05\x30\xb8\xea\xfa\xe4\xe8\xe2\xe4\xf0\xea\xa4\x47\xde\x9f\x1f\xc3\xbf\xc7\x27\x6f\x4e\xec\xbf\x47\xef\xce\xce\x4e\x8e\xae\xac\x1e\xf1\x19\xe2\xc0\x5b\x33\xce\x52\xd7\x9e\x47\xb2\x2e\x2d\xa8\x98\x91\x51\x69\xac\x38\xa8\x1e\x56\x9b\x05\x45\x1f\x00\x4d\x53\x6b\x32\x3e\xb9\x35\x5c\x4e\xf0\x79\xb7\x49\xdc\xec\x02\xa1\xf3\x5d\x31\xd7\xfd\x6a\xd2\xca\x4c\xb2\x72\x55\x44\x6d\xca\x3b\x0d\xcb\x21\x3e\x08\xf2\x5a\x2a\xe2\xfa\x7c\xbd\x22\xbb\x85\x4c\xf5\xae\x2b\x3a\xb1\xff\x3d\xc0\x8f\x0e\x32\x39\xde\x0d\xb5\x28\x8c\x64\x72\x4c\x74\x39\x0c\x35\x42\x70\x9a\xc2\xdd\x9f\xf9\xdb\x6a\xa5\x15\xbd\x50\x28\x14\xfd\x2a\x0c\x5e\xfb\x4d\x7c\x43\x3c\xee\x01\x34\xf9\xaa\xdd\x69\x3f\x98\x1f\xf0\xb3\x83\xe5\x33\xf0\x8a\x13\x57\x73\xbf\xf8\x20\x2c\xbb\xde\xf0\x2c\x4d\xa8\x4a\x17\x78\x16\x0e\x37\x5c\x72\xa0\x1e\xe2\xe6\x62\x8f\xe4\x6a\x70\x07\x9e\x21\xa7\x4c\x65\xb4\xc0\x3c\x75\x00\x2e\x86\x04\x28\x78\xc8\x31\x2b\x18\xd4\x69\xf9\xae\xdd\x4c\x24\x99\x04\x9c\x0e\x3c\x19\x7b\xf5\x57\xc7\x84\x28\x0f\x4a\xe8\x8a\x7d\xaa\x1d\xb2\xb3\xb1\x62\x0e\x92\x9d\x1f\xc4\xbd\x98\x1e\x7d\x2b\xd8\x4b\xa8\x1e\x41\xa3\x31\x68\xbe\x8c\xec\xb8\x2a\xb8\x9d\x1e\xd9\x09\x78\x26\xa9\xd3\x92\x77\x3e\xdb\xa9\x6e\x88\xeb\xa8\x40\x49\x76\x81\xa9\x3e\x3c\x27\xae\xb6\x84\x05\xf6\xe1\xb3\xf0\xe8\x0a\x93\xc6\x1e\x6d\xce\x89\x05\x73\xa8\x0f\x34\xa8\x4d\x64\xe1\xa9\x55\x09\xe0\xbd\x4f\xb4\xd3\x8f\x7e\x6e\xa0\x5c\x1e\x4b\x09\x1d\x71\x54\x54\x71\x33\x20\x97\x35\xe6\x09\xe1\xbf\x18\x34\x87\x2b\x52\x50\x65\x4d\x11\x7f\x67\xbd\x5f\xd8\x67\xf7\x76\x0b\x5b\x81\x09\xa2\xf8\xca\x8a\x5a\xfb\x65\xf8\xc5\x51\x46\xb5\x5e\xe2\x79\x05\x41\x60\x07\x26\x0c\x47\x26\xd4\x07\x9f\x00\x84\x7a\x42\xa7\x77\xc0\x25\xac\x30\x69\x43\xd5\x98\x99\xbb\x23\x23\x54\xcc\xde\xdd\x09\x93\xd6\x5f\x19\x58\xb5\xbf\xda\x6e\xfa\xd8\xaf\x40\xb9\xfa\x5c\x98\xbe\x54\x7d\xfc\xc9\x2b\x62\x54\x79\x5b\x8c\xcb\xf0\x9c\xc9\xd2\x5c\xb2\x44\x8a\xe5\x75\x15\xee\xbe\xce\x42\x3d\x0f\x28\x36\x71\xd1\xc6\x43\xaf\x46\xf8\x8a\x93\xd8\xc9\x5e\xe9\x18\x3e\xc2\x58\x07\x69\x79\xf7\xe6\x6d\x9b\xc5\x26\x50\x66\x7d\xf7\x4a\xfe\xe4\xc4\xbe\x18\x87\x99\xba\x99\xdf\xf9\xb3\xb7\xa5\x79\xf8\x8f\xfe\x3f\xe6\xae\x2c\xb7\x6d\x1e\x08\xbf\xe7\x14\x7c\xfb\xff\x02\x8d\x7b\x86\xc2\x79\xeb\x82\xc2\x4e\x0f\xc0\x48\x74\x2c\xd4\x96\x0c\x52\x8a\xbb\xa0\x77\x2f\x38\x33\xa4\x4c\x99\x9b\x22\xd9\xb1\x1e\x6d\x72\xb8\x88\x43\xcd\xfa\xcd\xd2\x7a\xae\xe2\xad\x69\x33\xe2\xc0\x1c\xc1\xf5\xab\x96\xb7\xdd\xd9\x69\x70\xde\x0d\x5d\x96\x6b\x4c\x6c\x23\x99\x7e\x0d\xfd\x4e\x8d\x7c\xe7\xf8\x04\x88\x73\x0b\xed\x4c\xc8\xe4\x82\x51\x47\xcd\x9f\xad\xe4\x15\x2a\x90\xbc\x68\x3b\xc8\x9d\xe6\x2d\x85\x57\x12\xbc\xce\x9d\x6f\x19\x5e\x95\x31\xa6\x26\x16\x42\xb6\xea\x33\x57\xed\xf7\x43\xc9\x03\x39\x54\x83\xb0\x49\xd5\x02\xc3\xa0\x60\x7d\xac\x45\xa9\x6f\x78\xda\x02\xa4\xc7\x8e\xfa\xea\xed\x90\xe2\x58\x4f\x7e\xcf\x40\xba\xfb\xbd\x1e\xca\x3f\xeb\x55\xa3\xf7\xe4\xa3\xf7\x02\x72\x03\x46\x52\xb3\xd5\x9f\x13\x09\xd4\x58\x2d\x7e\xfa\x34\xee\xe9\x33\xde\x09\x5e\xfb\x83\xf6\x07\x27\x0a\xda\x8d\x3f\x43\x34\x00\x3b\x6e\x2b\x2d\xb2\x62\xae\x99\x62\x46\x84\x2a\xc5\x4e\x04\x52\xce\x26\x06\xb4\xd2\x08\x0f\x34\x40\x56\xb0\xd5\x37\xb7\x8f\x35\xe8\x93\x10\x4e\x29\x1c\xbd\xb0\x4c\xd2\x83\xd5\x9a\x86\xab\x02\xf1\xe5\x69\xd7\x14\x3f\x10\x64\x0c\xf0\x06\xaa\xdf\x42\x9a\xe8\xf7\xca\x56\xf5\xa2\xca\x53\xcf\xa6\x2a\xa6\xd9\x37\x53\x7e\x08\xa8\x68\xda\x7a\x03\x2d\xfd\x46\xf6\x96\xc5\xae\xa6\x1c\xbe\xeb\x04\xd0\x1a\x45\x05\xb2\x06\x1c\xcf\xc1\xb9\xce\x82\x81\x36\x80\x81\x48\x2a\x23\xdf\x53\x8e\xcd\x87\x4f\xe1\x7c\x94\x59\x83\x62\x63\x59\x31\xd8\x02\xb6\xaf\x2e\xa2\x50\x38\xd1\xfc\x99\x5c\xcb\x57\x22\x4f\x86\xe5\x0b\xe9\x76\xca\x39\xd4\x66\x0d\x71\x9c\xdd\xdb\x17\x4c\x46\xe8\x9f\x31\x3e\xbc\x5c\xf0\xd5\x51\x5e\xa6\x7a\x0c\x48\xa6\x0b\x6e\x62\xd5\x0e\x4a\x35\x45\x4f\xfc\xa6\x91\x41\x05\x66\xbe\xc9\xc7\xb3\xaa\x92\x84\xb4\xf4\x19\x8e\x5d\x3b\x4f\x21\xd2\xb7\x97\xed\xf2\x9e\x71\xb6\xad\x54\xdb\x48\x72\xad\x41\xf1\x30\xc9\xa1\x42\xa9\x3f\x06\x6c\x9e\x68\xb8\xa5\x9d\x02\xe3\x87\x83\xe0\xb6\xd8\x10\x7d\x9b\xa0\x5a\x90\x14\x45\x23\x4b\xef\xc4\x8c\x76\xef\x95\xa5\xbc\xc3\xcf\x90\x21\xba\xe3\xaa\x7d\xb4\x73\xd0\x02\x42\xe6\x6d\xec\x8a\x3f\xb4\xc4\x7e\x35\x06\x6e\xa6\xa9\xfb\x3f\x1b\xc6\x6b\xb4\x6a\x4c\x93\xc1\xd3\x42\x46\xbf\x36\x94\xe6\x5e\xb5\xae\xa3\x95\xdc\x4e\x96\x78\x9d\x99\xef\x85\x52\xd1\x74\xa7\x41\x90\x06\xe0\x04\x33\x8b\x13\x4c\xdd\xcd\xc7\x1e\x05\x04\x0c\xc7\x34\xa8\x60\xbf\xc2\x47\x8d\x81\x98\x80\x06\x05\xcb\x56\x93\x5e\xd9\x61\xcb\x55\xee\x62\x2c\x17\xd9\x40\xe3\x6c\x76\xc8\x9c\x8d\x14\x5c\xc5\x12\x36\x07\x7b\xfb\x24\x2b\xb1\x61\x4b\xbe\x17\xbb\x25\x57\x73\x6e\x2e\xdc\x00\x0b\x26\x16\xcf\x0b\xf6\xdf\xea\xc4\xdb\xfa\xb5\x69\xbf\xc4\x0a\x36\x24\x30\x0a\x72\x38\xfa\xa2\xbc\x3c\x59\x49\x48\x73\xee\x44\x9e\x9d\x3c\xc3\x08\x87\xde\x04\x6f\xc6\xb3\x8e\x43\xfc\xe8\x72\x62\x27\xc1\xe2\x57\xbc\x96\x23\x13\x29\x95\x21\x2e\xbc\x65\xfe\x4b\x2c\xc9\x92\x58\x7b\x4d\x26\x67\xab\x7b\x74\x34\x57\x30\xfb\x9f\x06\xd8\x61\x65\xfe\x4a\x69\x15\x6c\x4e\xb1\xe5\x6d\x53\xfe\xe9\x05\x06\xff\x8f\xc8\xe5\xf7\xf1\xaf\xf0\x54\x38\x81\x12\x1c\x2d\xfa\x04\x5c\x33\x00\xe3\xc1\x8c\x4a\xb6\x0e\xb2\x01\xd0\xb9\xd8\x50\x95\x33\x6a\xe3\x9c\x8f\xff\xa1\x8e\x9c\x78\xc1\xaa\x8d\x90\xf0\x21\x58\x2d\x94\x66\x8a\x77\x91\xe1\x33\x15\xaa\x3c\x65\x2a\xad\xe8\x26\x95\x58\x96\x7e\xb5\xa6\x51\xec\x05\xe3\x93\xab\xb3\x65\xe8\xc4\x23\x94\xb5\xb4\xc6\x33\x82\x58\x52\xfc\x1b\x49\xcf\x6f\xc0\x1d\x3e\x03\xe4\x61\xdd\x65\x05\x97\x34\x3a\x86\x0b\x7d\x03\x17\x80\x3e\x8d\x77\x37\x5d\x4f\xae\xfd\x76\x35\xbc\x03\x21\xdc\xd0\x3d\xe1\x73\x2d\xab\xeb\xaa\xf9\xf6\x3c\x89\xe3\x91\x4d\xef\x06\x40\x49\x92\x07\xe8\xb2\x70\x09\xf8\xa4\x4e\xdd\xdb\x9f\xb7\x1c\x58\xa8\xe8\x19\xbb\x10\x3e\x8c\x12\xf2\x45\x94\x8e\xa7\x8e\xb0\xe5\xdd\xdf\x4e\xfc\xb6\x3d\x7d\xda\x76\xf6\xe7\xef\xdd\xbf\x00\x00\x00\xff\xff\x12\xac\x7d\xb1\x7e\x88\x07\x00") +var _operatorsCoreosCom_clusterserviceversionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xfd\x7d\x77\xe3\xb6\xb5\x28\x8c\xff\xdf\x4f\x81\xe5\xe6\x5c\xdb\x27\x92\x3c\xd3\xf6\xf4\xd7\xce\xaf\xcf\xc9\xf2\xb1\x9d\xc4\x4f\x66\x3c\x5a\x63\x27\xb9\x5d\x49\x4e\x0a\x91\x5b\x12\x8e\x49\x80\x05\x40\xd9\xea\xcd\xfd\xee\xcf\xc2\x06\x40\x82\x7a\xb1\x25\x91\x33\x96\x3d\x40\xd7\x6a\xc6\x22\x09\x82\x1b\x1b\xfb\xfd\x85\x16\xec\x07\x90\x8a\x09\xfe\x86\xd0\x82\xc1\xbd\x06\x6e\xfe\x52\x83\xdb\xbf\xa8\x01\x13\x27\xb3\xd7\xbf\xbb\x65\x3c\x7d\x43\xce\x4a\xa5\x45\xfe\x01\x94\x28\x65\x02\xe7\x30\x66\x9c\x69\x26\xf8\xef\x72\xd0\x34\xa5\x9a\xbe\xf9\x1d\x21\x94\x73\xa1\xa9\xf9\x59\x99\x3f\x09\x49\x04\xd7\x52\x64\x19\xc8\xfe\x04\xf8\xe0\xb6\x1c\xc1\xa8\x64\x59\x0a\x12\x27\xf7\xaf\x9e\xbd\x1a\xfc\x65\xf0\xea\x77\x84\x24\x12\xf0\xf1\x1b\x96\x83\xd2\x34\x2f\xde\x10\x5e\x66\xd9\xef\x08\xe1\x34\x87\x37\x24\xc9\x4a\xa5\x41\x2a\x90\x33\x96\x80\x7b\x5e\x0d\x44\x01\x92\x6a\x21\xd5\x20\x11\x12\x84\xf9\x4f\xfe\x3b\x55\x40\x62\x56\x31\x91\xa2\x2c\xde\x90\x95\xf7\xd8\x79\xfd\x62\xa9\x86\x89\x90\xcc\xff\x4d\x48\x9f\x88\x2c\xc7\x7f\x3b\x20\xd8\xd7\x5f\xdb\xd7\x3b\xc8\xe1\xf5\x8c\x29\xfd\xdd\xfa\x7b\xde\x32\xa5\xf1\xbe\x22\x2b\x25\xcd\xd6\x7d\x08\xde\xa2\xa6\x42\xea\xab\x7a\x59\x66\x19\x89\x9a\x85\xff\x76\x37\x32\x3e\x29\x33\x2a\xd7\xcc\xf6\x3b\x42\x54\x22\x0a\x78\x43\x70\xb2\x82\x26\x90\xfe\x8e\x10\xff\x2e\x3b\x79\x9f\xd0\x34\xc5\x8d\xa4\xd9\x50\x32\xae\x41\x9e\x89\xac\xcc\x79\xf5\x72\x73\x4f\x0a\x2a\x91\xac\xd0\xb8\x59\x37\x53\x40\xa8\x11\x31\x26\x7a\x0a\xe4\xec\xfa\x87\xea\x56\x42\xfe\x47\x09\x3e\xa4\x7a\xfa\x86\x0c\xcc\x06\x0c\x52\xa6\x8a\x8c\xce\xcd\x12\x82\xbb\xec\x6e\x9e\xdb\x6b\xc1\xef\x7a\x6e\xd6\xab\xb4\x64\x7c\xf2\xd0\xfb\xdd\x47\x6c\xb6\x84\x59\xb0\x4f\xe1\xeb\x7f\x58\xfa\x7d\xd3\xd7\xfb\xcf\xa7\xe6\xcd\x44\x4f\xa9\x26\x7a\xca\x14\x11\x1c\x88\x84\x22\xa3\x09\xa8\x07\x16\xb4\xe2\x16\xbb\xa2\x0f\xcb\x17\xd6\x2c\x29\x9c\x52\x53\x5d\xaa\x41\x31\xa5\x6a\x19\xc4\xc3\x85\x5f\x57\x4c\x67\x6f\x9c\xbd\xa6\x59\x31\xa5\xaf\xdd\x8f\x2a\x99\x42\x4e\x6b\x1c\x10\x05\xf0\xd3\xe1\xe5\x0f\x7f\xbc\x5e\xb8\x40\x9a\xd0\x59\x89\xfd\x84\x29\x03\x2a\xa4\x20\xc4\x93\x10\xdc\xbb\x79\x01\xe4\x1f\x2b\x9f\xb9\x2e\x20\xf9\xc7\x60\x69\xe5\x62\xf4\x3f\x90\xe8\xe0\x67\x09\xff\x2c\x99\x84\x34\x5c\x91\x01\x90\x27\x4b\x0b\x3f\x1b\xf8\x07\x3f\x15\xd2\x90\x05\x1d\x1c\x79\x3b\x02\xba\xd8\xf8\x7d\xe1\x6b\x0f\x0d\x48\xdc\x37\xa6\x86\x24\x82\x42\x7c\x74\x18\x07\xa9\x83\xa3\xc5\x53\xa6\x0c\x72\x48\x50\xc0\x2d\x91\x44\x14\xe2\xee\x9b\x06\xc4\x00\x00\xa4\x32\x04\xa0\xcc\x52\x43\x3b\x67\x20\x35\x91\x90\x88\x09\x67\xff\xaa\x66\x53\x44\x0b\x7c\x4d\x46\x35\x28\x4d\xf0\xd4\x72\x9a\x91\x19\xcd\x4a\xe8\x11\xca\x53\x92\xd3\x39\x91\x60\xe6\x25\x25\x0f\x66\xc0\x5b\xd4\x80\xbc\x13\x12\x08\xe3\x63\xf1\x86\x4c\xb5\x2e\xd4\x9b\x93\x93\x09\xd3\x9e\xea\x27\x22\xcf\x4b\xce\xf4\xfc\x04\x09\x38\x1b\x95\x86\x70\x9e\xa4\x30\x83\xec\x44\xb1\x49\x9f\xca\x64\xca\x34\x24\xba\x94\x70\x42\x0b\xd6\xc7\xc5\x72\xa4\xfc\x83\x3c\xfd\xbd\x74\x9b\xac\x0e\x17\xc0\xb7\x12\x9d\x89\x27\xb0\x0f\xc2\xda\x90\x57\x8b\x49\xf6\x71\xfb\x2d\x35\x48\xcd\x4f\x06\x2a\x1f\x2e\xae\x6f\x88\x5f\x80\x3b\x97\x08\xe1\xfa\x56\x55\x03\xdb\x00\x8a\xf1\x31\x48\x7b\xe7\x58\x8a\x1c\x67\x01\x9e\x16\x82\x71\x8d\x7f\x24\x19\x03\xae\x89\x2a\x47\x39\xd3\x0a\x71\x0e\x94\x36\xfb\x30\x20\x67\xc8\xf4\xc8\x08\x48\x59\xa4\x54\x43\x3a\x20\x97\x9c\x9c\xd1\x1c\xb2\x33\xaa\xe0\xa3\x83\xda\x40\x54\xf5\x0d\xf8\x36\x07\x76\xc8\xb3\x97\x1f\x58\x3a\x63\x84\x78\x5e\xba\x76\x77\xd6\x9e\x61\x92\x42\x92\x51\x69\x85\x02\xa2\x21\xcb\xc8\xfb\xb7\xef\xc8\x54\xdc\x19\x2c\x66\x5c\x69\x9a\x65\x78\x0a\x1c\x7f\xb6\xe4\x34\xa1\x9c\xe4\x94\xd3\x09\x10\x5a\x14\x8a\x8c\x85\x24\x94\x4c\xd8\x0c\xb8\x3f\x5d\x83\x4d\x17\xbf\x8e\x48\x10\x4b\xdc\x57\x32\x28\x7f\xd5\x2d\x70\xe1\xca\x3a\xb2\x61\xc6\x92\x0c\xf4\x00\xd4\x4e\xeb\x7b\x11\xb3\x39\x29\xb9\xd2\xb2\xc4\xcd\x4e\xc9\x2d\xcc\x1d\x92\xe7\xb4\x20\x4a\x0b\xf3\xe3\x1d\xd3\x53\x42\x43\x04\xa7\x1a\xb1\x78\x04\x44\x81\x26\xa3\x39\x31\x62\x1c\x12\x04\x2d\x44\x86\xd4\x02\x9f\x45\xc2\x20\x41\x4b\x06\x33\x20\x54\x8e\x98\x96\x54\xce\x2b\x6c\x58\x04\xe8\x23\x40\xc5\x8f\x0d\x84\x87\xf5\x20\x21\x0f\xe1\x22\xb1\xe4\xd6\xc9\x2e\x69\x25\x58\x6e\x00\xbd\xe1\xa5\xc3\xb7\x5a\x1c\x55\x0e\xdf\x40\x11\x83\x57\x4e\x3e\xa8\xe4\x5a\x7c\x93\x43\xac\x94\x08\x59\x61\x86\x01\x5b\x88\x84\x23\x30\xe4\x44\x52\x6e\x2e\xac\x44\xee\x1d\xa0\xf5\x10\xda\x98\x21\xee\xf8\x2a\x1c\x0d\xe7\xa6\x52\x36\x04\xa6\x70\x30\x0d\xf9\x9a\x99\x1f\x84\x5d\xf5\xb3\x59\xe0\x8c\xa5\x60\x80\xa8\x29\xb3\xa8\x63\x4e\x2b\x1d\x89\x52\x5b\xd8\xb9\x5b\x52\x32\x63\x94\xd0\xc9\x44\xc2\x04\x11\x78\xed\x6b\x1f\x81\x89\x1d\xeb\x0f\x68\x3d\xfa\x56\x92\x7f\xf0\x0e\x43\x06\x1f\xbc\x81\xaf\x3a\xe6\xe1\x0d\xcb\xc2\x62\x73\x3c\xb6\x87\x76\xd0\xc4\xc0\xc4\x83\x56\xc8\x07\x6f\xde\x64\x6f\xed\x78\x64\x87\xed\x68\xee\xf3\xc2\x42\xdc\xd5\x91\x39\x1f\x35\x69\x36\xe4\x00\x6f\xac\x89\xef\x08\x48\x01\x72\x2c\x64\x6e\x0e\x0a\x27\x94\x24\x56\x7e\xab\x08\x0f\x92\x46\x9e\x3c\x04\x4e\xb2\xe9\xfe\xdb\xb1\x09\x16\xd8\xd1\x27\x05\xd5\xd3\x47\x6e\xdb\x6c\xab\xec\x08\x81\xf6\xe8\xcd\x8f\x50\xb3\xa5\xb9\x6b\x0e\xd3\xf9\xdc\x06\x0c\x9d\x4f\x8a\x3c\x67\x93\x59\x1b\xa8\xf6\x81\xde\xbd\x03\xa5\x0c\xcb\x46\x29\x4d\xd2\x3b\x02\x3c\x11\x86\x58\xfc\xbf\xd7\xef\xaf\xec\xb4\x03\x72\xa9\x09\xcb\x8b\x0c\x72\x23\x88\x91\x77\x54\xaa\x29\xcd\x40\x22\x77\xfa\x9e\xe7\x8d\xbf\x1d\x26\x96\x0a\x52\x43\x8b\x52\xc8\xe8\xdc\x4e\x96\x42\x22\x52\x43\xa3\x85\x24\x85\x11\x70\xf3\xa2\xd4\x40\xa8\xbd\x8a\xef\x65\x7c\xb2\x8a\x48\xb7\x02\x0d\x31\x92\x48\x4e\xf5\x1b\x32\x9a\xeb\xc7\x50\x9f\x90\xfb\x7e\xba\x29\x0d\x08\x17\xf3\x38\x25\xb0\x63\x23\x7a\x10\x4e\xfc\xe8\x57\x1a\x21\x94\x32\x0e\x72\x28\xa4\xde\x84\x68\x19\xe5\x63\x02\xf2\xc1\x3b\x3d\xc8\x18\xd7\x7f\xfc\xc3\x03\x77\xa6\x50\x64\x62\x6e\xf0\xe2\xf1\xb3\xb2\xe1\xf7\x6c\x7c\xae\x37\x9d\x6f\xd3\xb3\xbc\xe1\x7c\xd6\x38\xd5\xc5\x4c\xab\x14\xa8\x9d\x26\xe2\x5d\x7d\x5b\xa5\x04\x3e\x19\xf3\x1b\x5e\x7a\x6b\xc3\x07\x18\x83\x04\x9e\x38\xda\xf4\x5d\x39\x02\xc9\x41\x83\x0a\x04\xe9\x79\xe1\x28\x8d\x91\x05\x17\xd9\xdd\xd3\x70\xb9\x47\xe4\x19\x7f\xdb\x23\x52\x8d\xbf\xed\x31\xd9\xc6\x8e\x6d\xd8\xe6\xe3\x48\x67\xc7\x56\x34\xf6\x71\x04\xdc\x61\xd2\xd9\x6a\x73\x4e\x8b\x79\x8d\x4e\xbc\x07\x12\xde\x75\x63\x19\x0d\xf9\x6e\xcc\x20\x4b\x09\x33\xc2\x9b\x59\x2c\x19\x65\x22\xb9\x75\x76\xcb\x0f\xe7\x44\x09\x2b\xee\x19\x09\xdf\x30\xda\x44\x70\x55\xe6\x40\xd8\x63\x18\x1c\x45\xba\x28\xd2\x45\x91\xee\xb9\x88\x74\xd6\x3f\xb0\x0f\x94\x6a\x61\x21\x6b\x69\x15\xde\x17\xa9\xd5\x43\x23\x52\x2b\x1c\x91\x5a\x3d\x32\x9e\x1d\xb5\xda\x48\x4e\x7b\x74\xae\xc7\x0e\x72\x34\xa6\x46\x63\x6a\x34\xa6\xba\x11\x79\x99\x1b\x91\x97\x45\x5e\x16\x8d\xa9\x0f\x4d\x19\x8d\xa9\x5b\x4e\x14\x8d\xa9\xd1\x98\x1a\x8d\xa9\xd1\x98\xfa\xd8\xc7\x44\x91\x2e\x8a\x74\x51\xa4\xdb\x74\x31\xd1\x98\x1a\x8d\xa9\x0f\x8d\x48\xad\x82\x11\xa9\xd5\x03\xe3\x65\x53\xab\xf6\xc6\xd4\x24\x03\xca\x57\x2b\x55\x0b\xf1\xdf\x78\x1f\x8a\x46\x6c\xcc\x5c\x1e\x84\x7b\x9a\x8c\x60\x4a\x67\x4c\x94\x92\xdc\x4d\x81\xfb\x94\x1d\x32\x01\xad\x0c\x16\x80\x86\x55\x82\xf9\x23\xb4\xe6\x61\xfa\xd2\x27\xc0\xe9\x28\x5b\x39\xf1\x63\xa4\xc4\x3d\xf9\xb0\xf1\x78\x24\x84\xf9\xba\x65\x88\xa1\xaa\xe3\x35\x9d\x6d\xe2\x99\x0f\xd6\xe5\xd8\xad\x0e\x6a\x3e\xfb\x70\xde\x55\x28\x33\xf9\x99\x93\xcb\x6a\x56\x82\x96\x69\x4c\x94\x30\x3c\xc4\xfc\xfa\xfe\x8e\x43\x8a\x49\x6e\x3d\xc2\xb4\xb9\xc1\x1c\x7a\x96\x30\x9d\xcd\xab\x17\x0f\x0e\xb6\xdf\xc4\x3d\x0a\x89\x3e\xfb\x70\xbe\xb9\xf9\xde\x6f\xc0\xa7\xb0\xd4\x47\x3b\x7c\xb4\xc3\x57\x23\x8a\x41\x3b\x4e\x1a\xc5\xa0\x07\xc6\xcb\x16\x83\xf6\xdd\x6e\x1d\xad\xcd\x24\x5a\x9b\x1f\xbe\x2d\x5a\x9b\xa3\xb5\x39\xda\x6f\xd6\x8c\x28\xb8\xe0\x88\x82\xcb\x23\xe3\xd9\x09\x2e\xd1\xda\x1c\xa9\x55\xa4\x56\x91\x5a\x3d\x0f\x6a\xf5\x1c\x43\x77\xa3\xd1\x2f\x1a\xfd\xa2\xd1\x2f\x72\xa3\xc8\x8d\x1e\x19\xcf\x8e\x1b\x45\xa3\xdf\xb6\x13\x45\xa3\xdf\xca\x11\x8d\x7e\x8f\x8c\x68\xf4\x8b\x46\xbf\x35\x23\x0a\x2e\x3b\x4e\x1a\x05\x97\x07\xc6\xcb\x16\x5c\xa2\xd1\x2f\x52\xab\x48\xad\x22\xb5\x7a\x1e\xd4\xaa\xbd\xd1\xef\x91\x93\xf4\xf0\xb3\x0f\x9f\x94\x07\x9f\x65\xc9\x43\x2f\x5c\x07\xd1\x07\x20\xf8\x28\xe1\x7a\x8c\x5c\xf5\xc9\x88\x2a\xf8\xf3\x9f\x96\xea\x96\x87\xb7\xe4\x90\x32\x6a\x5e\xb5\xf2\x8e\xc7\x49\x58\xfd\x8a\xf5\x7b\xb6\xc1\xde\x57\xcb\xd8\x71\x16\x57\x58\xf9\xd1\xa0\x58\xb3\xb5\xe9\xa5\xbd\xf9\x5a\x4b\xaa\x61\x32\x0f\x0a\x79\xa3\x4d\xb6\xe6\x3c\x7c\x4d\x01\xfa\x4a\x69\xbc\x9b\x82\x04\x7c\xc8\x97\x9e\x56\x7e\x52\xa6\xaa\xe8\xe5\x74\x87\xe2\xbe\x8f\x85\x23\xfb\xf7\xac\xb8\xfc\xd8\xa6\xad\xaa\xbe\xbd\x12\x58\x1e\x40\xe7\xd6\x7a\x7d\x5e\xa5\x00\x2f\x42\xac\xa0\xd2\x50\x48\x6f\xe5\x46\xa6\x1d\xdc\xbd\x00\xef\x75\x44\x71\x03\x4e\xfd\x38\x87\xee\x07\x99\xca\xeb\x2c\xeb\x9b\x30\x66\xd7\x03\x63\x08\x32\x67\x4a\xad\x0b\xb8\x6e\x2e\xfd\x31\xb2\xb9\x01\xb9\x5c\x03\x7f\xff\x45\xc1\x72\x2a\xf1\x09\x77\x40\x8e\x68\x42\x64\x99\x19\x61\x8a\xa7\xc4\x95\xbf\x26\x34\x49\x44\xc9\x35\xe1\x00\xa9\xb5\x6c\xac\xc2\xd5\x0d\x88\xed\x06\xf2\xd3\xa6\xd2\x53\xdf\xae\xf3\xd1\xbb\xdc\x37\x9c\xda\x4f\x58\x59\x50\x3d\x1c\x9b\x4b\x5b\xf8\xfa\xc7\xb9\xd6\x36\xac\x70\x63\x46\xd8\xd8\xdf\xa1\xc8\x58\x32\xff\x50\x66\x40\xa6\x22\x4b\x15\x96\xf5\x37\xdc\xbd\x72\x38\x84\x22\x72\x81\x77\xe3\xea\x7b\x64\x54\x6a\x92\x0a\x50\x84\x0b\xed\x0b\x03\x34\x1e\xb7\x2e\xa6\xbb\xa9\x6d\xed\x60\x1e\x22\xb4\x28\x32\x4c\xa5\x10\x46\x68\xb9\x9b\xb2\x64\x6a\xfb\xd5\x14\x34\x81\x55\xb7\x6d\x2e\xbd\x6c\x24\x5e\x93\xad\x44\x6c\xe2\x6d\x56\xa3\xc7\x50\x85\x6c\x29\x6b\x13\x5b\x22\xfe\x1b\x29\xca\x62\xc3\xdb\x97\x2d\x8b\xf6\x69\x43\xe5\xf5\x42\x03\x1b\x7f\xd1\xb9\x8c\xec\xde\xd8\xdb\x2a\x93\xe8\x80\x90\xcb\x31\xc9\xcb\x4c\xb3\x22\xc3\x47\x6c\xb5\x01\x45\xa8\x84\x9a\x6f\xf4\x08\xe5\x73\xef\x81\x72\x6d\x22\x20\x25\x74\x62\x66\xd4\xd8\x1f\xc6\x97\xa4\xe7\x65\x0e\xe6\x34\xa7\xf5\x4b\x50\x9d\xe2\xf3\x7a\x76\x72\xc7\xb2\xcc\xc8\xb3\x34\xcb\xc4\xdd\x6a\xb6\xb4\x6a\x6c\x27\x14\x92\xed\x04\x43\xb2\xbd\x08\x4c\x08\x17\xdc\x9b\x76\xbf\xff\xf0\x76\xb7\x4d\xbc\x6a\xce\xe1\x7a\x81\x80\x36\x20\x2d\xa8\xd4\x8c\x66\xa4\x94\x99\xb2\xfb\x48\x8d\x12\x20\x7d\x33\x95\x29\x45\xcf\x60\x02\xca\x76\xed\x20\xff\x6e\x77\xce\x01\xd6\x9e\x4f\xc1\xb3\x39\xa1\x76\xe7\xc7\x65\x96\xf5\xc8\x98\x71\x6a\xc8\x2e\x14\x3e\x13\xc6\xe8\x4f\xe4\x9a\xf1\x04\xcc\x37\xf5\x2b\xc1\x02\x57\x64\x66\x34\xe7\xbb\x3a\xa4\x69\xcf\xb5\x15\xb1\xda\xb2\x72\xaf\x30\x07\x36\xa1\xa3\x0c\xb0\xaf\x85\x13\x59\x3e\x88\x0c\xcd\xdb\xce\xf0\x9d\xda\x5e\x24\x34\xbc\xfc\x5f\x8c\xa3\x92\x42\x3e\x20\xe3\x30\xca\x0e\x30\x3d\x35\xba\x4f\x51\x64\x73\x43\x28\x0c\xee\xd4\x08\x75\xa4\xca\x64\x6a\x3e\xe9\xa0\x10\xa9\x3a\x30\x64\xe4\x40\x41\x22\x41\xab\x83\x63\xf3\xd7\xe2\x37\xe0\xf7\x85\xcf\x9d\xd0\x82\x1d\x1c\xf7\x08\x02\x08\x1b\x9d\x08\x3d\x7d\xbe\x78\xe8\xbf\xb5\xd1\x5f\xeb\xb1\xd1\xd4\x5a\xc3\x19\x5c\xd7\x0e\x51\xd8\x26\x18\x86\x46\x6b\xc0\x3c\x29\x83\x94\x88\x06\xbe\x3d\xd4\x32\xb1\x26\xe4\x94\x13\xc8\x0b\x3d\x47\x2c\xce\x81\x72\x77\x37\xcc\x40\xce\xf5\xd4\x68\xab\x4c\x3d\xff\xc3\xbf\xa1\x63\xa9\x1e\x2b\x01\xee\x0e\xbc\x07\x6e\x8d\xe4\xb6\xb3\xd2\x22\x70\x0f\xff\xfd\x30\x94\x7a\x8d\xf8\x54\x53\xf3\x67\x0b\x4a\x64\xaf\x3b\x81\xf1\x07\xf3\x64\x13\x84\xf6\x27\x4b\x2d\x2b\xfa\xf1\xf6\xad\xed\xa2\xe4\x60\xf5\x1d\xe3\xa9\xaa\x2a\x19\xa5\x96\x0c\x3a\x78\xaf\x04\x32\xae\xf0\x39\x02\x78\x59\x7c\xdd\x54\xe4\x7c\x64\xfa\x40\xbf\xd9\x07\x95\x04\xbb\x32\x35\xa4\x1c\x43\xa7\x7a\xd6\xe5\x64\x74\x91\x8c\x8e\x20\xb3\x2d\x97\xcc\xd5\x7a\xf9\xe4\xf4\xed\xbb\xaa\x3b\x99\x04\xfa\x88\x3d\xeb\x23\x28\x22\x1b\x38\x4e\x97\x7a\xbc\x2d\x8f\xcd\x65\x4f\x04\xc5\x76\xc6\x60\x72\x0d\xda\x1e\xb3\x9c\x16\xe6\x94\xd9\x39\x56\xda\x32\xdf\x22\xa4\x1f\x3f\x2c\x5b\xc9\xec\x9b\xf7\x64\x5a\xf5\x92\x8d\x8e\xca\x66\x1e\xdf\x6d\xce\xde\x03\x16\x8e\x7a\x34\xc0\xbc\x80\xd0\x4e\xae\x77\x92\x78\x52\xf5\xd7\xb3\x18\xac\x6c\x62\xb4\x4d\x43\x97\xfe\xf7\x7a\x8a\x8e\xb7\x60\x1b\xa5\xc9\xe8\xcd\x19\x24\x5a\x3c\x5c\xf6\xcd\xdf\xac\x21\x2f\xb2\xc7\x4e\x1e\xd9\x5a\xc1\xca\x19\xff\x00\x34\x9d\x5f\x43\x22\x78\xba\x21\x81\x6d\xec\xc7\x3b\xc6\x59\x5e\xe6\x84\x97\xf9\x08\x10\xc4\xca\xce\x85\x84\xc4\x2a\xaf\x94\x70\xb8\xcb\xe6\x8e\x78\xa4\xa4\x10\xa9\xa7\x27\x23\xa3\x6c\xd1\x74\x8e\xfd\xcd\xb0\x40\x2a\x9f\x9b\x49\x98\xae\xb9\x8f\x24\x89\xa4\xca\x88\x45\x3d\x9c\x94\x69\xc3\xb1\x46\x80\xbe\x25\x96\x82\xd9\x63\x3a\xa3\x2c\x33\xa2\xf5\x80\x9c\xc3\x98\x96\x19\xb6\xe9\x23\xaf\xc8\x91\x79\x99\xd7\xa7\x56\x3d\x60\xc4\x5d\x25\x8c\x26\xae\x5c\x8e\x3b\x2e\xe8\x78\x0b\x6b\xf9\x26\xf5\xfb\xfc\xd8\xb4\x8e\x9f\x1f\x05\x2d\xd5\xa6\x6a\x78\x63\x63\x2e\x79\x6a\xce\x43\x28\x89\x06\x24\x9d\x29\x37\xf3\x66\x2c\xfb\xe1\xda\x07\x2b\x56\x2d\xc5\x44\x82\x52\xe7\x40\xd3\x8c\x71\xd8\x1d\xbf\x6e\xa6\x40\x72\x7a\x8f\x38\xa6\x59\x0e\x46\x12\x09\x31\x8c\x86\x5f\xa5\x05\xc9\xe9\x2d\x54\xaf\x27\x23\x18\x63\x1b\x46\xfc\xe0\x60\xf7\x2d\xfe\x8c\x29\xcb\x20\x1d\xe0\x3b\x82\x59\xea\xee\xc5\x16\x71\xcc\xdf\x8c\x97\x60\x9e\x2a\xa4\x40\x65\xd2\x3e\x1a\xf2\x78\xe4\xa1\xd4\xdc\x6c\xe9\xb0\xef\xd8\x37\x5c\x00\xc5\xc5\x7d\x62\x8d\x7c\x12\xa8\xc2\xdb\x2c\x6e\xaa\x52\x8e\x8d\xea\xe8\x35\xce\x60\x41\xae\xd5\x2b\xb9\x12\xda\x35\xfe\xab\x3e\x10\x9f\x76\x8d\x28\x41\x69\x96\xe3\x01\x4b\x4b\xe9\xdb\x62\x22\xcc\xe8\xea\xad\x6f\x1c\x95\x3f\xbf\x7a\xb5\xa1\xfc\xf6\xf1\x91\x5e\x02\x6a\xca\xbb\xe0\xcb\x55\x45\x87\x3c\xf9\x37\x2a\xb0\xd9\x63\xe6\xc4\x60\xec\xef\x09\x12\xfd\x84\x4c\x69\xc6\x27\x25\x53\x53\x32\x02\x7d\x07\xc0\x09\xdc\xdb\x0a\x17\xe4\x5f\x20\x05\x6e\xaa\x01\x6f\xed\x22\x68\x00\xed\xf5\xfe\x40\x6c\xc6\x14\x13\xfc\x5b\xa6\xb4\x90\xf3\xb7\x2c\x67\x8f\x94\x1e\xf5\x63\xb9\xcb\x71\x05\x41\x91\xa5\xd8\x9b\x98\x25\xf4\x1a\xec\x07\x4b\x40\x0b\xa6\x16\x56\x3d\x25\xe6\x9c\x8c\x68\x72\xfb\xd1\x00\xfc\x6a\x5f\x20\xec\xd9\xf5\x0e\x50\x45\x79\xaf\x9a\x00\xc9\x96\x45\xca\x8b\x7b\x0b\x9f\x06\x94\xef\xa6\x42\x01\xde\x60\x8d\x8c\xf8\x98\x77\x0a\x30\x55\x11\x0c\x73\xba\x05\x07\x45\xe8\x78\xdc\xbc\xa3\x3e\xec\x28\x79\xe6\xa5\xd2\x24\xa7\x3a\x99\x5a\x53\x96\x48\x2b\x71\xe2\x50\x39\xb1\x7f\x1b\x28\x6f\x6c\x44\xde\xde\xdc\x4b\xec\x3a\x2f\xee\x8d\x6e\xf9\xa8\x37\xa7\x39\x1a\x20\x5f\x9c\xa6\xa9\x01\x67\xcd\x0d\x71\x72\x5b\x6e\x5b\x04\xdf\xa0\x01\xb8\xfe\x05\x77\xe1\xf4\xea\x7c\x73\x53\xcc\x2e\x0a\xee\xd6\x2a\xee\xa2\xa9\xfb\x81\x8f\xf2\x26\x53\x77\xa5\x69\xef\xb6\xad\xa1\x7b\x84\x92\x5b\x98\xdb\x2e\xd2\x4b\x6d\x79\x25\x64\x4e\x92\x00\xec\x4e\x6b\x6e\x72\x2d\xa5\xb7\x58\xef\xd6\xd8\x63\xc7\x76\xae\x08\x3f\xfa\x66\xa1\x5b\x3e\xe1\x3f\x7a\x8b\xc7\xb6\x47\x70\x3b\x6e\x61\xbe\xdd\x03\x0b\xdb\x6d\x76\xc1\xe9\x3e\x76\xdf\xcd\x0f\x95\xa0\x57\x6d\xf5\x76\x3e\xa2\x70\x6c\x6d\xa2\xf2\xc3\x03\xb1\xd5\xe7\x55\xe8\x17\x5a\x99\xcc\x37\x1e\x2a\x8b\x8c\xe6\x4c\x4f\x59\x81\x8c\xc8\x3b\x03\x7c\x93\xf3\x1f\x68\xc6\xd2\x6a\x0a\x7b\x7e\x2f\x79\xcf\x88\x4f\xe6\x3f\x48\x74\xad\xb8\x76\x2e\x40\x5d\x09\x8d\xbf\x7c\x32\x00\xd9\x65\xb6\x02\x8f\x9d\xc2\x59\xa1\x91\xca\xa0\xe2\x15\xf4\x47\x57\x03\x5f\xd9\xab\x02\x25\x53\xe4\x92\x13\x21\x3d\x1c\xb0\x63\xbd\x9d\xc8\x4e\x81\x7c\x62\x64\x1d\x1c\x68\x9f\x5e\x39\x87\x03\x9f\x90\x0d\xe8\x3d\x30\x9d\x9b\x0a\xe5\x03\x7b\xc5\x76\xc4\xcf\x50\xda\x75\xa2\x2a\xf5\x4e\x6e\x96\x90\x1c\xe4\x04\x3d\x2e\xc9\xc6\x1e\x87\xe6\xa6\x6c\x47\x77\xed\xd8\x9a\xfa\x86\x2f\xdc\x0a\x0b\x90\x35\x59\x13\x50\x1b\xe6\x66\x67\x68\x98\x9c\xfe\x8f\xa1\xe0\xb8\x07\xff\x97\x14\x94\x49\x35\x20\xa7\x44\x31\x3e\xc9\xa0\x71\xcd\x69\x18\xe1\x34\x66\x06\xa6\x88\x21\xb5\x33\x9a\x39\x5d\x8a\x72\x02\xd6\x66\x65\x66\x5f\x64\xa9\x3d\x27\xa9\x18\xca\x53\x39\xba\x0e\x6e\x61\x7e\xd0\x5b\x42\x9a\x83\x4b\x7e\x60\x79\xcb\x12\x9a\x54\x8c\x08\x7d\x64\x07\x78\xed\xa0\x4b\x2e\xbc\x25\xc3\xd9\xd5\x8e\xd6\x7c\xe9\xc6\x18\xe1\x63\x3b\x76\x14\xd6\x1b\x5a\xa2\x8b\x68\xd2\x82\x94\x0a\xac\xb4\x8e\xa7\x8c\x80\x97\x33\x51\xaa\x44\xc5\x94\xc3\x1d\x4a\x8f\x7b\x23\xf8\x19\x4d\x82\xf1\xc9\xf7\x45\x4a\xf5\x46\x41\xa5\x76\x34\x20\x72\xf8\xc1\x4e\x42\x4a\x9c\xc5\xe0\xd6\x98\x4d\x48\x41\x25\xcd\xd5\x80\x0c\x5d\x75\x43\xc4\x34\x36\x0e\x6d\x89\x0e\x76\x37\xf3\x02\xc8\xff\x43\x3e\x84\x6b\x19\x90\x7e\xbf\x4f\x6e\xde\x9f\xbf\x7f\x43\xec\x2f\x56\xca\xd6\x82\x8c\x05\x2a\x41\xa2\x94\xe6\x55\x33\xe0\xa8\xf8\x1b\xf9\x5e\x70\x78\x3f\x36\x27\x84\x6a\x98\x81\x24\x77\x66\xab\x12\x96\x42\x65\xbd\x1a\x1c\x7e\x5c\x3c\xde\x4d\x32\xc9\xe9\xfd\x75\x29\x27\x5b\x6c\x00\x59\xda\x84\xd0\x64\x53\x2b\x93\x88\x7a\x61\x76\xae\x4a\xa6\x90\x96\x19\xa4\x84\x8e\xc4\x0c\x1a\x26\xdb\xe6\x63\xc8\xd2\x4b\xf0\x0f\x1a\x9e\x37\x52\x22\x2b\x75\xa5\xac\x1e\xc1\xfd\x1b\xf2\x1f\xe8\xda\xa6\xa4\x00\x99\x00\xd7\x74\x02\x8b\x66\x00\x7b\xdf\xeb\x57\xff\x76\xec\xf8\x91\x99\xd1\x59\x4f\x5e\x19\x8c\x78\x47\xef\xbf\xe7\xb5\x69\x90\x29\xf2\x6a\x40\x4e\x17\x5e\x86\xcf\x65\x49\x99\xa1\xad\x05\xdd\xf5\xc1\x2b\x47\x73\x22\x45\x89\x0e\x7b\x52\x16\x4d\x6d\xf6\x0f\xff\xf1\x6f\x46\xe9\xa3\x79\x91\xc1\x1b\x5f\x14\xd5\xaa\xcd\x46\x86\xd1\x82\xfc\xf1\xd5\xbf\x59\xea\x69\xce\x67\xad\x15\xd6\x30\xa3\x06\x60\x65\x41\x58\x6e\x43\x31\x21\x9b\xd7\xd5\x55\x65\x13\xfd\x95\xa6\x52\xab\x1e\x41\xaf\x7e\x25\x1c\x6a\xa1\x69\xb6\xa0\xe5\xa3\x16\x0e\x77\x16\x48\xa9\x40\x98\x00\x1a\xaa\xc8\xeb\x3f\xbe\xfa\xb7\x65\x73\xca\x7b\x9e\x00\x3e\x89\x4f\x60\x98\xc5\xc8\x28\xf7\xb7\x2c\xcb\x20\xed\x3d\xba\xfc\x71\x29\xf5\x14\x64\x8f\x00\x57\xde\x58\x65\xd6\xb7\xb0\x36\x9c\x5d\x96\x9c\xa3\x8c\x60\xad\xc3\x68\xd1\x0a\x2c\x5c\xee\x63\x0d\x23\xd4\x24\x17\x4a\xaf\x5e\xf2\xe6\xc7\xcd\x0c\xca\xe7\xef\xc7\xdb\x8a\x03\xfd\x1d\xcc\x10\xcb\x4f\xef\x20\x52\xde\xf7\x6f\xab\x4c\xc9\x3e\xe3\xba\x2f\x64\xdf\x4e\xf3\x86\x68\x59\x3e\xee\x35\xa8\x47\xde\x38\x01\x9f\x80\x0c\x94\xc1\x79\x5b\xda\xd5\x8f\x72\xf2\x77\x3f\xcf\xa9\xb8\xe3\xeb\x29\x07\x12\x4e\x47\x33\x76\x3c\xf5\x4d\x8b\xdb\xc2\xb1\x31\x6f\x37\x77\xff\xff\x96\xb1\x7b\x0b\x72\xe0\xce\x6e\x75\xda\x8d\x5c\x85\x1e\x8f\xde\x06\x6f\xaf\x8e\xad\xe5\x7c\xd6\xe6\x64\x6e\xb0\xaf\x59\x41\xb9\x96\x4e\xf8\x0a\x0a\x64\xd7\x51\x3b\x64\x34\x46\x14\x98\x73\xae\xd6\x1e\xf4\x0c\xa8\xd2\xab\x40\x11\x0f\xfa\xe3\xe3\xe1\x00\xfe\xc5\xd1\x14\x3a\x8d\x84\x84\x20\xaf\x6d\x8c\x67\x16\x51\x0e\x3e\x80\xf5\xf0\xd9\x80\xb3\x86\x10\x75\x50\x1d\x09\xb3\x7f\x4d\xf9\xea\x63\x85\xcd\x78\x23\xe7\x2e\xa2\xb5\x7b\x34\x08\xec\x75\xa6\x53\x47\xbc\x2a\x8f\xa2\x75\x69\xee\x8d\x14\x9d\x83\xa6\x0f\x27\x79\x2c\x8e\x26\xd1\xbe\xd6\x94\xa7\x54\xa6\x6e\x95\x87\x87\xaa\x9a\x72\x40\xde\xa1\x2f\x8d\x8f\xc5\x1b\x32\xd5\xba\x50\x6f\x4e\x4e\x26\x4c\x0f\x6e\xff\xa2\x06\x4c\x9c\x24\x22\xcf\x4b\xce\xf4\xfc\x04\x1d\x68\x6c\x54\x6a\x21\xd5\x49\x0a\x33\xc8\x4e\x14\x9b\xf4\xa9\x4c\xa6\x4c\x43\xa2\x4b\x09\x27\xb4\x60\xfd\x5a\x66\x56\x83\x3c\xfd\xbd\x7f\xd1\x47\x16\x8c\x1b\x67\x08\xad\x4b\x72\x06\xfd\x92\xdf\x72\x71\xc7\xfb\xa8\xc9\xaa\xad\x4e\xd3\x66\x51\x0c\x7e\x2c\xc0\x7b\x9b\xc0\x85\x42\xa4\x1f\x7d\x13\xcc\xc7\xf4\x29\x4f\xfb\xd6\xe9\xf8\x91\xf7\x62\x17\xdb\x6e\xbf\x0e\x0c\xd8\x24\xe2\xdc\x8e\xdd\xb4\x21\x9a\x68\x36\x83\x9d\x9c\xd8\x7e\x34\xb6\xfb\xbd\x0f\x18\x4d\x4b\x69\x77\x3c\xf0\x66\x7b\xdf\x4c\x4e\xe7\x28\xeb\xe0\xbb\x89\xb0\xac\x9c\x8b\x14\x9c\xe5\x73\x86\xaa\xfd\xb5\x61\xe6\x37\x46\x14\x76\x3e\x6e\xb4\xfb\xce\x95\x86\xdc\x12\x27\xfb\x7c\x36\x27\x5a\xce\xad\x63\x5c\xde\x1a\xe5\xd3\x79\xae\x8d\xc4\x7f\x8b\xf7\x29\x25\x12\x86\xa2\x4f\x0d\x57\x2f\x77\x79\x1b\x1e\x25\x85\x50\x0c\xdf\xed\x78\xde\x76\x96\xb9\xdd\xd9\x65\xe0\xa6\xfb\xf3\x9f\xb6\xd9\xba\x31\xb6\x51\xd8\xd2\xca\xde\x8c\xa0\x18\x87\x11\xfe\x6e\x7b\x0e\x95\x57\x5c\x8d\x58\x92\x08\xae\xb4\xa4\x6c\x7d\x0e\xd3\xea\xb1\xa3\x2b\x64\x77\x7f\x03\x41\x0c\x3a\xdd\x09\x28\x64\x39\x06\xcb\x33\x45\x44\x4b\x0f\xea\x10\x30\x36\xc5\xc9\xc7\x12\x1a\xc2\xb5\xa3\x69\x75\x07\x18\x91\x56\x70\xb2\x4f\xc3\x18\xa4\x84\xf4\x1c\xa5\xcf\xeb\xea\xbb\x2e\x27\x5c\x54\x3f\x5f\xdc\x43\x52\x6e\x9a\x09\xbe\x3c\x96\x6c\x79\xde\x20\xe2\xc2\x4e\xec\x22\xcc\xd1\xf5\x17\x9c\xfc\x21\x10\xec\x4e\x10\x51\x54\x33\x35\xb6\xf9\x62\xd5\x46\x40\xe0\xf8\xac\x50\xb8\x72\x0f\x23\x8b\xb3\xa9\x0f\x4c\x23\xb9\x49\xa6\x42\x28\x73\xca\x71\x3f\x71\xde\x19\x13\xd6\xe7\x87\xc9\x2b\x92\xe4\x86\xc6\xf8\x24\x96\x7a\x7a\x6b\xa8\xad\x1f\x63\xca\xaa\xe0\x15\x04\xbd\x97\xca\x4c\x83\x86\x47\xf3\xc7\x04\xa5\x26\xa5\x89\x2a\x73\x33\xe9\x1d\xb0\xc9\x54\xab\x1e\x61\x03\x18\x20\xd6\x00\x4d\xa6\xc1\xb4\x39\x80\x6e\x74\x41\x09\x51\x2d\xb4\x12\x1f\x55\x59\x0d\x2e\x0d\xa7\x57\xf1\x98\xc5\xbd\x5c\x09\xae\x1e\x01\x9d\x0c\x8e\x7b\xa4\x4e\x14\x37\x6b\x1c\xcd\x09\xd3\x60\x68\x36\xea\x22\x52\x94\x13\xfb\x25\xe0\x63\x3a\x71\x5d\x55\xca\x07\x7a\x51\x53\xd4\x19\x0f\xec\xc7\x1d\x98\x7d\xc3\x95\x97\xb9\xd1\x17\x2b\xa2\x8e\x66\x75\xdf\x38\x47\x48\x09\xaa\x10\x56\xdb\x5c\x34\xb8\xff\xff\xab\x87\x8e\xd4\x71\x0d\xcc\x29\x9b\x4c\x3d\x2c\xa9\x63\x04\xcd\x3d\xd8\xfe\xec\x91\x56\xbe\x14\x3b\x76\xf4\xa8\xd8\xd1\xf4\x6d\xfb\x7c\x89\x1a\xab\x82\xfd\xd7\x20\xf3\x0a\x8a\x88\x22\x48\x32\x9c\x9d\xdb\x37\xac\x71\x38\x46\x5e\x91\x23\x44\x32\xa6\x0f\x15\x22\x7c\x5f\x14\xc7\x03\x72\x4a\x78\x59\x9d\xb9\x87\x5e\xc0\x45\x35\xbf\x9b\xc8\xbc\x54\x89\x7a\xae\x1d\xbf\xb8\x15\xb9\xb3\x63\x37\x4f\x79\x38\xfa\x0e\x02\xf0\x78\x59\xc4\x87\x26\xb1\xb0\xde\x71\x82\x76\xa4\xdb\xcf\xe1\xbf\x62\xf7\x39\x96\x02\x2c\xf0\xb8\xd6\x51\x14\x20\xf3\x5e\x28\x3d\x55\x07\xb2\x79\x8a\x2d\x2c\x76\xc5\x0a\xd2\x0d\x66\x90\x8e\xe0\x4a\x5a\x45\xe8\xac\x1e\x8b\x61\x2c\x3e\x8b\xaa\x01\xed\x06\x91\x1f\xcd\xf1\xea\x96\xc1\x4b\xeb\x47\x5b\x4a\x57\x8f\x56\x34\xaf\x1e\x0f\x22\xde\xfe\x05\xf6\xac\x1e\x1d\xa1\xad\x1d\xed\x49\x5b\x3d\xb6\x0f\x0d\x5a\x37\xcf\x0e\x01\x43\xab\x47\x57\x67\xd3\x8e\x1d\x82\x8b\x56\x8f\x25\x11\xf5\xe3\xc4\x1a\xad\x1e\x3b\x1b\x49\x57\x8f\x5d\xe3\x92\x56\x8f\x85\x54\xc5\x8f\x14\xa4\xd4\x6b\x46\x28\x91\x6f\xb4\x3d\xc7\x6f\x5b\xf1\x93\x7a\x74\x0c\xe2\xdd\x22\x9b\x56\x8f\x45\x01\xf0\x99\x44\x39\xad\x98\xea\x1b\x6d\xa6\x79\xbb\xf6\x61\x9b\xa3\xee\xe3\x74\x9c\x42\xd1\x73\xa9\x33\xde\xce\x8c\x11\xd5\x85\x04\x2c\x2b\x80\x61\x5f\xde\x0e\xf3\x69\x02\xab\x56\x8f\xee\x18\xa7\x1d\x1d\xb1\x4f\x3b\x3a\x43\x6e\x14\x78\xbe\xb6\x76\xe1\x27\x94\x75\xac\x65\x3a\xca\x3a\x51\xd6\xd9\x62\x44\x59\x67\xd3\x11\x65\x9d\x75\x23\xca\x3a\x2b\x46\x94\x75\xa2\xac\xd3\x6a\xec\x9f\xac\x63\x2d\x55\x9d\x19\xcc\x7e\xb4\x06\xd7\x45\x0b\x19\x4a\x53\x3e\xa4\xa7\x69\x2a\x33\xbc\xff\xda\x91\xd8\x1b\x34\xaf\xb9\x48\x75\x49\xf9\x04\xc8\xeb\xfe\xeb\x57\x1b\xa6\x03\xae\x1e\x6d\x82\x76\xc2\xb1\x6d\xea\xe0\xe2\x58\xe7\x91\xf8\x68\xde\x25\x77\x52\x2b\x87\x47\x43\xc2\x5c\xe3\x20\xaa\xaa\x5a\xe5\xa0\x09\xd5\x0d\x83\x38\xcb\xa1\x72\x88\x36\x52\x90\xeb\x98\x5e\xc1\x9d\xbf\xc3\x6c\xea\x60\xb7\x15\x24\x40\x6d\x1c\xfb\x08\xaa\x55\x88\x1c\x6c\x82\xa9\x3f\xf4\x66\x09\xe0\x61\x45\x8e\x60\x30\x19\x90\xd4\x26\x6b\x53\xee\x62\xc6\x8e\x7b\xa1\x7b\x3c\x37\xc4\x55\xe2\x7f\xcc\xb2\x9d\x7f\x1c\x66\xc0\x75\x49\xb3\x6c\x4e\x60\xc6\x12\x5d\x7d\x1f\x06\x04\x32\x6d\x9d\x9d\x6d\x5c\x29\x2d\xc4\xc3\xb6\x22\x61\x7f\xe9\x6c\x6d\xe7\xaf\xf6\xa3\xbd\xec\xb6\xb4\x8e\xdd\xe9\xcd\x82\x5c\x62\x21\x34\x58\xab\x56\x69\xf3\x36\xeb\xaf\xc4\x7f\x22\x82\xbf\xff\xb0\xab\x7b\x8c\x74\xc4\x13\x5a\xf3\x81\x45\x05\xaa\xcc\x32\x83\xde\xd6\x63\xb6\x0c\x82\x15\x9e\xac\x15\xd9\x36\xd6\xcd\x9a\x07\x59\x37\x78\xcf\x8d\x28\x44\x26\x26\xf3\x70\x07\x6d\x47\x96\xa0\xbc\x0d\x25\xaa\x1c\x39\x11\xd0\x1c\xa2\xab\x85\x2d\x8f\xbe\x90\xb5\x23\xfa\x42\x96\x46\xb4\x0f\x2c\x8e\x68\x1f\xd8\x62\x44\xfb\xc0\x8a\x11\xed\x03\xcb\x23\xda\x07\xa2\x7d\xa0\xcd\x78\xf9\xf6\x01\x12\x7d\x21\xeb\x46\x94\x75\xea\x11\x65\x9d\xcd\x47\x94\x75\x96\x47\x94\x75\xa2\xac\x13\x65\x9d\x28\xeb\xec\x3a\x5a\x20\x77\x21\xd2\xce\x53\x64\x0a\x91\x3e\x90\x21\x63\xed\xd5\x89\xe8\x67\x22\xa9\x2a\x8b\x98\x47\x9c\xe7\x43\xd1\xdc\x9a\xd0\x7b\xe4\x5f\x82\x83\x4d\x4f\xb0\x25\x6b\x73\x20\x02\x9b\x40\x14\x22\x3d\x52\xc7\x3b\x04\x9e\xc7\x0c\x9b\x98\x61\xf3\x19\x64\xd8\x4c\xa9\x72\x85\x8f\x90\xb4\xae\x4f\xb8\x09\x8e\xff\x0d\xc8\xfc\xb3\xcd\xb7\x31\x08\xe7\x10\x06\x7b\xc4\xd5\x48\x61\x61\x97\x3a\xdf\x2e\xa4\xc3\x26\xc4\x9c\x5e\x66\x5b\xec\xa4\x29\xa4\xa4\x00\xd9\xb7\x48\x26\xc8\x98\xb9\xfa\x5f\x0b\xf8\xeb\x20\xfc\xcc\xf3\x66\x9a\x90\x78\xd6\xc9\x33\xcd\x4f\xe9\xcc\x37\x15\xba\xe8\x1a\x5c\xf1\xd9\xa5\xd2\x74\xa3\x95\xf6\x89\x76\xee\xb4\xef\x5a\xe9\xa5\x5d\x29\x91\xa8\xe4\x5d\x6f\x55\xe6\x78\xfd\x58\x59\x9c\xf6\x9f\x25\xc8\x39\x11\x33\x90\xb5\x62\x54\x75\xe7\xe9\x55\x4d\x66\x12\xea\x0a\x20\x77\x63\xe0\xe9\xc4\x14\xd1\xa5\xa6\xde\xb5\xd7\x90\xec\x59\xf5\xe3\xf5\xa3\x5b\xc5\xa1\x43\xb5\xe1\xb9\xd5\x52\x5e\x3f\x3a\x35\xbf\x91\x8e\x4d\x70\xa4\x43\x33\x1c\xe9\xd6\x14\x47\x3a\x37\xc7\x91\x2e\x4d\x72\xe4\x93\x57\x80\x5e\x3f\x3a\x36\x1f\x91\xce\xad\x74\xe4\x19\xd6\x93\x5e\x3f\x3e\x02\xb8\xbb\xb4\xd8\x91\x58\x9d\xba\xf5\xe8\xda\xa0\x46\xba\x36\xaa\x91\xae\xf1\x70\xa7\x2a\xd8\xeb\x47\xac\x8f\xfd\x11\xe4\xb4\xce\x84\x88\xb6\x35\xb5\x1f\x5b\x68\x07\x38\x59\xf5\xee\xfd\x54\x0a\x90\xe5\xd2\x75\xc3\x58\xf3\xee\xa0\x57\x17\x86\x6a\x86\x8d\x4d\x7d\xdc\x2a\x62\x34\xfe\x9e\x7a\x83\x57\xc9\x83\xe2\x71\xc1\x64\x4b\xad\x63\x6a\xd3\x59\xd5\x3c\xc6\x28\x05\x75\xd3\xa9\xe0\x61\xbc\x77\x60\xc3\x49\x6b\x69\x82\xa7\x8b\x01\xa6\xf5\x13\xa8\x5f\xd8\x76\xb6\x07\xde\x8e\x7d\xa8\xea\x3b\x0e\x06\x61\xe7\x5b\x37\xe3\xd1\xff\xf9\xbf\xc7\x8d\xea\x2d\xf5\x84\x8e\x2a\x57\x67\x67\x04\x9a\xf6\x33\x98\x41\x86\xeb\xf0\x6d\x95\xa7\x02\x2d\xc6\xb6\xec\x69\x60\x90\xba\x5a\xdc\x51\x32\x06\xaa\x4b\x89\x15\x44\x81\xd3\x51\xd6\xfe\xac\x44\x05\x33\x2a\x98\x9b\x8d\xa8\x60\xae\x1d\x51\xc1\x6c\x31\xa2\x82\xb9\xd9\x88\x0a\xe6\xfa\x11\x15\xcc\xa8\x60\xee\x30\xa2\x82\x19\x15\xcc\x5d\xc7\x67\xac\x60\x76\x1b\x38\x1d\xaa\x7b\x2e\x0e\x05\xe5\x47\x4d\x35\x4b\xea\xa0\x6a\x7f\x97\xfd\x57\xb7\x6a\x66\xa8\x42\xae\x56\x32\x43\x45\x74\x49\xd1\x1e\x3c\xa2\x51\x56\x3a\xe7\xd2\x93\x0f\x2a\x9b\x2f\x2d\x36\xbc\x33\x44\x0c\x9c\xce\x9d\x62\xe2\x8d\x0f\x5d\xab\x5b\xbb\x57\x71\x6d\x29\x39\xf2\xde\x7e\x6c\xd5\xc2\x85\x6e\x5e\xe4\x9a\xf5\xeb\x3b\x2a\xff\x3f\x86\xed\x34\x2a\x06\x34\x9c\xd4\x55\x94\x5c\x15\x81\x55\x23\x8f\xa1\x8e\x20\x1b\x6b\xc0\xd6\xb8\x63\xc6\x6d\x2c\xa5\x6f\x2b\x24\xb8\x0f\xcb\xb2\xe4\x14\x09\xa0\x47\x73\x2b\xf9\xe2\x7a\x50\xfc\xad\x61\x17\xc4\x11\x51\x3c\x63\x94\xbb\x74\x5b\xc1\x7d\xdf\x7b\xdb\xcb\xbe\x16\x97\xab\x6e\x2d\xd5\xdb\x07\xe4\x02\x91\x3e\x9c\x98\x29\x84\x0f\xb5\x1d\x56\xba\x31\x51\xec\x57\x69\x88\xbb\xad\x4b\x43\x2c\xc4\xa4\xc4\xca\x10\xb1\x32\x44\xab\xca\x10\x78\xd1\x1e\xee\xce\x4b\x44\x90\x1f\x5d\x03\x26\x09\x08\xaa\xbc\xcc\x34\x2b\xea\x18\x6f\x65\x5f\x95\x59\x45\x62\xec\x62\x4d\x9b\xf8\x6e\xde\x46\x93\xe9\x22\xde\xe3\x7c\x18\x13\xae\x90\x9c\xb8\x78\x4e\x6c\x97\x84\x35\x0d\xbc\xd6\x61\x83\x56\xd9\xf3\x8f\x45\x3c\x47\x82\xad\x6a\xa5\xd9\x76\xf3\x32\x74\x3e\x33\x28\x61\x28\xf6\x03\x0c\x22\x6c\x99\x81\x71\xb1\x6c\x06\xbc\xe6\x12\x47\xea\xf8\xd8\x0b\x43\x9d\x72\xaf\x8f\xc2\x7d\xfe\x16\x70\x89\xff\xdc\x84\xff\xe0\x07\x55\x1c\xa8\x06\x5f\xcd\x7f\x9e\x77\xd0\x65\xfb\xf8\xb9\x2e\x0c\x72\x9d\xc5\xcd\x3d\x79\xcc\xdc\xe7\x54\x5d\x63\x2f\x5d\x18\x7b\xa7\x75\xbc\x0c\xb7\x45\x4c\x49\xdd\x7c\x3c\x87\x94\xd4\x27\x72\x4d\x3c\x9f\xcc\xd4\x67\xeb\x8e\x78\x2e\x99\xa9\xd1\x05\xb1\xd5\x78\xa9\x09\xa3\xcd\xd1\xa1\xcb\x21\xba\x1b\x3a\x96\xa9\x3a\x61\xfe\x1f\xc7\xcd\xd0\x09\xfe\x75\x1a\xbf\x16\x63\xd7\x5e\x78\xec\x5a\x54\xf4\xa2\xa2\xd7\x1c\x51\xd1\x5b\x1a\x51\xd1\xdb\x62\x44\x45\x6f\xfd\x88\x8a\xde\xf2\x88\x8a\x5e\x54\xf4\x36\x18\x51\xd1\x8b\x8a\xde\xa6\xe3\x33\x53\xf4\xba\x2b\x1a\x1f\x63\xc8\xba\x8f\x21\xeb\x86\x10\x76\x40\xfe\x3a\x41\xba\x8e\x62\xc6\x62\xbc\xd8\x7e\xc7\x8b\xb5\x2c\x9d\xc7\x35\xfb\x38\xe5\xf3\xc2\xdd\x5e\x57\x43\x8f\xce\x04\x4b\x49\x51\x6a\x57\x41\x2c\xd6\xd1\xdb\xe7\x3a\x7a\x8d\x1d\x8d\xc5\xf4\x36\x2a\xa6\xb7\x0e\x66\xb1\xa2\xde\x9a\xb1\x3f\x51\x6c\xb1\xa2\xde\xb6\x23\x56\xd4\x5b\x3d\x62\x45\xbd\x07\x46\xac\xa8\x17\x2b\xea\xc5\x82\x07\x2d\x46\x2c\x78\xb0\x62\xc4\x82\x07\xbb\x8f\x58\xf0\x60\xa3\x11\x0b\x1e\xc4\x82\x07\xcd\x11\x9d\x50\xed\x46\x2c\x78\xd0\x72\x44\xc7\x54\x2c\x78\xd0\x6a\xc2\x58\x51\x2f\x46\x25\x6e\x3f\xa2\x82\x19\x15\xcc\xcd\x46\x54\x30\xd7\x8e\xa8\x60\xb6\x18\x51\xc1\xdc\x6c\x44\x05\x73\xfd\x88\x0a\x66\x54\x30\x77\x18\x51\xc1\x8c\x0a\xe6\xae\xe3\x33\x56\x30\x63\x45\xbd\x7d\x8f\x86\x24\xfb\x98\xf2\x14\x2b\xea\xc5\x08\xc9\x9d\xb6\x3b\x56\xd4\x7b\x7c\x7c\xf6\x15\xf5\x1a\xd1\x7a\x4f\x57\x56\x6f\xfb\x65\xc4\xda\x7a\xb1\xb6\x5e\xac\xad\x17\x6b\xeb\xc5\xda\x7a\xb1\xb6\xde\xe6\x63\xff\x9d\x19\x7b\xa7\x7f\xbc\x0c\x07\x46\x2c\xb9\xb0\xf9\x88\x25\x17\xd6\x8e\x58\x72\x21\x96\x5c\x88\xce\x88\x5d\x46\x2c\xb9\xb0\xe5\x88\x8e\x87\x58\x72\x61\xab\x11\x6b\xeb\xc5\x28\xb6\xcd\x47\x54\xf4\xa2\xa2\xd7\x1c\x51\xd1\x5b\x1a\x51\xd1\xdb\x62\x44\x45\x6f\xfd\x88\x8a\xde\xf2\x88\x8a\x5e\x54\xf4\x36\x18\x51\xd1\x8b\x8a\xde\xa6\xe3\x33\x53\xf4\x62\x6d\xbd\x7d\x8e\x26\x8b\xb5\xf5\x56\x8c\x18\x39\xb6\xdf\x91\x63\x3b\xe2\x0a\x2d\xb5\xc8\x45\xc9\xf5\x35\xc8\x19\x4b\xe0\x34\x49\xcc\x5f\x37\xe2\x16\xb6\x8c\x56\x6a\x6a\xa1\x0f\x4c\x4b\x18\x4f\x59\x82\x7a\xe4\xdd\x14\xb0\x34\x9e\x11\x6f\xf1\x3e\x42\xed\x8d\x44\xe3\x9d\x35\x7a\xe1\x3a\x0d\x4d\xc3\x10\x1e\x9c\x7a\x5b\x78\x59\x08\x8d\x84\xc8\x80\xf2\x2d\x9e\x74\xcc\x10\xe4\x96\xa7\xb9\x01\x90\xb7\x8e\x12\xd7\x93\x91\x11\x64\x82\x4f\x5c\xc4\x90\x3b\x01\x03\x72\x56\xdf\x90\x50\x8e\x87\xa7\x94\x12\xb8\xce\xe6\x08\x07\x2c\xd2\x85\x4a\x43\x2e\x66\x90\x22\xc5\xc6\x40\x25\x2b\x46\x52\x4d\x32\xa0\xe6\x5d\x1c\xea\x97\x99\xc3\x43\xc9\x10\xe7\xb7\x93\x8e\xc0\x05\x4f\xed\x04\xc4\xed\x69\xe3\x4e\xd4\x70\xc1\xb0\xe1\xa4\x26\x64\x4b\x09\xaa\x47\xc1\x17\xe2\xd1\x9c\x8b\x92\xdc\x51\x2b\x28\xc9\x92\xe3\x61\xc6\x4f\x37\xa0\xdd\xf2\xe5\x2d\x44\x92\xdd\xad\x0f\x7d\xa4\x6a\x5b\x3e\xd6\xc6\x1a\x40\xe5\x64\x27\x26\xd5\xd8\x9a\xc3\x53\x39\x29\xad\x44\xe8\x50\x19\xb8\x96\x73\x8c\xe8\xb3\x22\x45\x2a\x92\x5b\x83\x86\x39\x9d\xc0\xe1\xa1\x22\x67\xef\xce\x0d\xed\x2b\x95\x21\xd5\xae\x4c\xa0\xa3\x85\x85\x14\x33\x96\x1a\xcc\xfe\x81\x4a\x46\x47\x99\x91\x39\xc7\x20\x81\x1b\x91\xe0\x8b\xa3\x1f\x4e\x3f\xfc\x7a\x75\xfa\xee\xe2\x18\xa5\x4f\xb8\x2f\x28\x37\x47\xa2\x54\x75\x1c\xaa\xc3\x09\xf3\x22\xe0\x33\x26\x05\x37\x8b\x43\x3d\x8d\x92\x99\x9f\x35\xa9\x4e\x82\x04\x25\xb2\x19\xa4\x56\x46\xae\xde\xe6\x59\x0e\xe3\x45\xa9\xbd\xde\x88\xd1\x91\xe6\xf4\xf0\x64\x4a\xf9\xc4\xac\xf3\x5c\x94\x66\xbe\x2f\xbe\xc0\x15\x49\x48\xcb\xc4\x4a\x4d\xd4\xa3\xec\x17\x3d\xcf\x26\x0c\xa1\x57\xb6\xa6\xa3\x4a\x68\xe1\xd7\x1c\x7e\x96\x9a\x73\x4d\xef\xdf\xd8\xf0\xc0\x83\x2f\x82\x4b\x07\xbe\x1e\xa6\x30\xaf\xb0\xcc\xc6\xae\x2a\xc3\x52\x8c\x19\x39\x08\xef\x1e\x90\x0b\xf3\x0e\x48\x43\x00\xda\xe8\x4e\x98\x81\x44\xad\xd3\x81\xaf\x47\x24\x4c\xa8\x4c\x33\x50\x18\xd7\xe8\x09\xb3\xd5\x0c\x1c\xc0\xa0\xd2\x69\xb9\xd0\xab\x28\x09\x79\x27\x30\xc6\x71\x2c\xde\x90\xa9\xd6\x85\x7a\x73\x72\x72\x5b\x8e\x40\x72\xd0\xa0\x06\x4c\x9c\xa4\x22\x51\x27\x9a\xaa\x5b\x75\xc2\xb8\x39\x59\xfd\x94\x6a\xda\x0f\x8e\xf4\x89\x65\xdb\xfd\x44\xe4\x39\xe5\x69\x9f\x3a\xd4\xea\x57\xdb\x7a\xf2\x7b\xc7\x50\xfb\xb4\xba\x8b\xf1\x3e\xed\xab\x29\x64\xd9\xe1\x0e\xc8\xdc\x4e\xe0\x6b\x21\xe8\xb5\x12\xf0\xdc\xb7\xb7\x3f\xbd\x17\xd5\x61\xb5\x30\x18\x90\x2b\xa1\x5d\xf8\xad\x8b\xf4\x46\x22\x8a\xf0\x5d\x7d\x9e\x2f\xae\x6e\x3e\xfc\x7d\xf8\xfe\xf2\xea\x26\x1e\xeb\x78\xac\xe3\xb1\x6e\x71\xac\x81\xcf\x5a\x1f\x69\x2f\x6d\x06\xc7\xa4\xda\x6f\xe4\xd1\x0a\xb4\x3f\x06\xd5\x06\xb4\x96\x0d\xed\x78\x32\xa8\x37\x20\x70\xc1\x67\x3f\xd0\xa6\x69\x9d\xaf\x04\x07\x71\x37\x58\x11\xb9\x92\xbe\xdb\xc4\xde\xb7\x30\x63\xb5\xf5\x5b\xed\x24\x3f\xda\xd1\xde\xa7\x64\x5e\xbd\xbb\x89\xa1\xb1\x7d\x57\x34\xaf\xeb\x6b\xaf\xd8\xb5\x01\x79\xe7\x15\x1e\x72\xf6\xeb\xe5\xf9\xc5\xd5\xcd\xe5\xd7\x97\x17\x1f\x76\xd7\xa0\x3b\xb0\xb5\xa0\x35\xa1\x23\x00\x1c\xee\xc8\x25\x0b\x09\x33\x26\x4a\x95\xcd\x2b\xfb\xc7\x6a\x22\xb0\x78\xfa\x9d\xc3\x77\x5e\x69\xe2\x2b\x1f\x8b\xcc\xb6\x5b\x66\x7b\x0e\x63\x5a\x66\x56\x6f\x3a\x38\x18\xec\xc2\xe5\xec\xe8\x0a\x7d\xbf\x96\xa2\x45\xfd\xe8\x06\x0a\x5f\xdb\xca\xf3\x63\x21\xd7\x1e\xe3\x43\x17\x76\xd0\x60\x3d\x4e\x78\xb4\xb6\x39\x27\x3d\x5a\xef\x58\x4b\xe8\xb4\x74\x2f\x74\xe3\x74\x4f\x04\x1f\xb3\xc9\x3b\x5a\x7c\x07\xf3\x0f\x30\x6e\x67\x20\x6e\xc2\x1b\xed\x8e\xce\x87\x8c\x56\x4a\xc3\xce\xec\xcb\xda\xf9\x67\x3a\xf3\xce\x74\x15\x96\xd1\x3e\x24\xa3\xbb\x08\x8a\x4e\xa2\x27\x96\xaa\xf9\x5b\x0b\xb4\xb3\x25\x77\x15\x5c\xd3\x89\xcb\xbe\x1d\x97\xf7\xa3\xc9\xec\x42\x76\xef\xe8\xac\xde\x54\xed\x48\x04\x4f\xa0\xd0\xea\x44\xcc\x0c\xe7\x82\xbb\x93\x3b\x21\x6f\x8d\x1e\x61\x14\xd7\xbe\xc5\x5a\x75\x82\xde\x82\x93\xdf\x5b\xff\xd7\xcd\xfb\xf3\xf7\x6f\xc8\x69\x9a\xba\xd6\x2c\xa5\x82\x71\x99\xb9\x66\x08\x03\x42\x0b\xf6\x03\x48\xc5\x04\xef\x91\x5b\xc6\xd3\x1e\x29\x59\xfa\xd5\xee\xc4\xd9\x8f\x0e\x77\x41\x14\xd6\xc7\xd9\xf1\x4e\x5c\xa3\x77\x65\xde\xe0\x5d\x15\x11\x31\x5c\x8b\x69\x85\xb8\xe9\xed\xcd\x4e\xc8\xe8\x08\x34\xdb\x1b\xe7\x17\x07\x6e\x61\xb7\x74\xf5\xb0\x26\xac\xd6\xb7\xe9\x10\xb5\x10\xe9\x1b\xa2\xca\xa2\x10\x52\x2b\x92\x83\xa6\x46\xe9\x1d\x18\x0c\xeb\x35\xff\x44\x2f\x55\x8f\xfc\xa3\xfa\x11\x5d\x4d\xea\xa7\xc3\xc3\xbf\x7d\x77\xf1\xf7\xff\x3c\x3c\xfc\xe5\x1f\xe1\x55\x64\x85\x36\xfc\xa7\x79\x8b\x2a\x20\x19\x70\x91\xc2\x15\xbe\x03\xff\x54\x0d\x07\x8b\xbb\xa0\xa9\x2e\xd5\x60\x2a\x94\xbe\x1c\x56\x7f\x16\x22\x5d\xfc\x4b\xb5\x90\x38\xc8\x7e\x32\x06\xdc\xa2\x21\xd5\xd3\x3d\x61\x0f\x35\x2d\xe9\xf8\xa8\xba\x59\xc3\x16\x40\x39\xc5\x7f\x7e\xed\x41\x60\xa4\xa7\x3b\xc9\xb4\x46\xa7\x9b\x4b\x33\x17\xe3\x9e\x39\xb5\xb5\xd8\x39\x7b\x7d\xb0\x57\x0c\xa6\xda\xc1\x8e\x01\x86\x10\x71\xd0\xb2\x07\xb9\x62\xb0\xcb\xce\xe5\xd3\xe1\x25\x99\x59\x08\xef\x0d\x70\x7c\xea\xf0\xd7\x1f\x95\xc6\x55\x2d\xa3\x1c\xa8\x2a\x0d\xf1\x8d\x8d\x06\xaa\x12\x98\x49\xc6\x72\xe6\x82\x0c\x5d\x7b\x29\x45\x8e\xec\x8f\x83\xa4\x28\x7b\xee\x86\x41\x0e\xb9\x90\xf3\xea\x4f\x28\xa6\x90\x1b\x4d\xab\xaf\xb4\x90\x74\x02\xbd\xea\x71\xfb\x58\xf5\x97\x7d\xb0\xf1\x82\xe5\xa7\xad\x2a\x5c\x3b\x49\x1d\x45\x86\xf4\xe5\xd1\x36\x0f\xfa\x3d\x21\x6d\x15\x66\x5c\x7d\x04\x91\xb0\xb2\xc4\x59\x81\xb3\x82\x22\xea\x93\x33\x91\x95\x39\xa8\x5e\x25\x06\x59\x6b\x00\x9f\x19\xcd\x52\xed\x95\xa0\x96\xb2\x19\x53\x5d\xc4\x0f\xaf\x90\xd3\x98\x0b\xc5\x17\xa5\x2e\x4a\xed\x6a\xd9\x04\x6d\xe9\x84\x42\xbb\x45\x55\x70\xa0\x41\xf6\x5f\xb7\x2d\xb8\x45\x48\x41\xb5\x06\xc9\xdf\x90\xff\x3e\xfa\xf9\xcb\xdf\xfa\xc7\x5f\x1d\x1d\xfd\xf4\xaa\xff\xd7\x5f\xbe\x3c\xfa\x79\x80\xff\xf8\xf7\xe3\xaf\x8e\x7f\xf3\x7f\x7c\x79\x7c\x7c\x74\xf4\xd3\x77\xef\xbe\xb9\x19\x5e\xfc\xc2\x8e\x7f\xfb\x89\x97\xf9\xad\xfd\xeb\xb7\xa3\x9f\xe0\xe2\x97\x0d\x27\x39\x3e\xfe\xea\x8b\xd6\x4b\xa7\x7c\xfe\xbe\x25\x01\xb5\xa3\xdf\x59\x29\xa2\xc5\x19\x3b\x0a\xb0\xbe\xef\xd7\x4a\x53\x9f\x71\xdd\x17\xb2\x6f\xa7\x7e\x43\xb4\x2c\xdb\x11\x93\x9a\x29\x75\x7d\xfe\x7d\xef\xb1\x37\x35\x43\xaa\xd8\xf5\xde\x1c\x70\x05\x89\x04\xfd\x29\x2c\x39\xf6\x4d\x5e\x4e\x59\x08\x76\x7c\x69\x7c\xee\x73\x30\xee\x54\xc1\x82\xb8\xaf\xb5\x24\x3a\x96\x22\x1f\x90\xc0\xbd\x31\xc3\x4c\x0f\x77\xdf\x2d\xb4\xb0\x82\xfa\x11\x8d\x41\xd1\x18\xb4\x66\x3c\x6a\x0c\xba\xb6\x78\xb8\xb7\x96\x20\xe0\xb3\x5d\x5d\x18\x2b\x3d\xe8\x5e\xd7\xd1\x82\x14\xa2\x28\x33\xaa\xd7\x78\xc6\x56\xb8\xd3\xdd\x51\xaf\x23\x91\xeb\x48\x1a\xcb\xd0\xf2\xd5\x3e\x4c\x72\x9a\x65\x84\x71\x7b\xf0\x71\x02\xef\x30\x93\x60\x55\x1b\x42\xad\x3f\x7b\x66\x96\x70\xe7\x4a\xd6\x85\xe1\x9e\x8a\x28\x4d\xa5\xc6\xa8\x63\x2c\x69\x67\x59\x89\xf3\x3e\x31\x5e\x17\xb6\xab\x84\xc3\x2a\x09\x64\x65\x5f\xcf\x8c\x2a\xed\x97\x8d\xab\xd1\xf4\x16\xbd\x8d\x09\xa4\xc0\x13\xc0\x8c\xb4\x12\xea\x6f\x1d\x19\xbd\x8d\x5c\xf0\x99\x9d\x83\x92\xb4\xb4\xc1\x20\x96\xfc\xad\x9e\xe3\x65\x05\x20\x18\x44\xbc\xf6\xed\x97\xab\x38\x04\xa4\xfa\x95\x86\x5d\x25\xf6\x55\x56\x56\xf5\x34\x91\x07\xed\x79\x66\xe5\xd9\x6a\x25\x0c\x2d\x31\xcb\xda\xfc\xdc\x64\x92\x2f\xc1\x19\xd8\x9e\x7d\x7e\x76\xac\xb3\x23\xb6\xd9\x0d\xcb\xdc\xc2\x77\xd2\x25\x9b\xec\xc2\x59\x52\x48\x18\xb3\xfb\x8e\xce\xe9\x29\xaf\x2d\x31\x2c\x05\xae\xd9\x98\xd9\x8e\xfd\x85\x84\x02\x78\x5a\x15\x45\xc5\xac\x70\xde\x84\xcd\x5e\x06\xf3\x58\x81\xbb\x5b\x52\x76\xbd\x4a\xd8\x8f\x74\x8c\x44\x3a\xb6\xf3\xf8\x44\x74\xcc\x61\xee\xfe\x10\x31\x8c\x3c\x6f\x1f\xfa\x7e\x1e\xc4\xb1\x23\x16\x6f\x8d\x65\x75\x42\xd7\x09\xce\xa2\x16\xaa\x07\x55\x74\x51\x0b\x1b\xb9\x46\xa6\x6c\x62\xc0\x6a\x2b\x0a\x59\xa1\x89\xe4\x94\xd3\x89\xcd\xea\xd6\xc2\xdb\x69\x8d\x96\x65\x90\x58\xb2\xb4\x21\xdc\xdb\xd7\x30\x4e\x0c\x62\x67\x82\xa6\x78\x51\x8a\x2c\x03\xa9\x48\xc6\x6e\x81\x9c\x43\x91\x89\xb9\x4b\xd2\xe6\x29\xb9\xd6\x54\x1b\x94\xbe\x06\xbd\x9b\xcf\xb7\x15\xba\xe2\x8a\x87\x65\x96\x0d\x45\xc6\x92\x9d\x2c\x2a\xcd\x6d\xbb\xc4\xfd\x2a\xca\x2c\x23\x05\x4e\x39\x20\xef\x39\x52\x8c\xd3\xec\x8e\xce\x55\x8f\x5c\xc1\x0c\x64\x8f\x5c\x8e\xaf\x84\x1e\x5a\xd1\xbb\x19\x6d\x67\x6f\x24\x6c\x4c\xde\x60\x4d\x1b\x4d\x34\x9d\xa0\xe2\xe4\x7d\x80\x3d\x03\xff\x70\x02\x4b\x1c\xee\x98\x5a\xa9\xa9\xb4\x46\x9c\xdf\xe3\x4c\x86\x50\xd9\xbf\x3f\xf9\x36\x65\x6c\x0c\xc9\x3c\xc9\xda\x9f\xab\xd3\x04\xa3\x17\xea\x3c\xf3\x00\xbf\x5d\x99\x76\x97\xda\x89\x2a\x20\xe3\xc4\xd6\x4f\xb7\x85\xe1\x6b\x54\xaf\x56\x64\x55\x5d\xd5\xa9\x86\xb8\x33\xe7\x6c\xcb\x33\x0b\xa1\xf4\xb5\x51\xcf\x3b\xa9\xb2\x7e\x38\xf4\xd3\x11\xac\x25\x9d\x65\x90\x12\x96\xe7\x90\x1a\x15\x3e\x9b\x13\x3a\xd6\x98\x62\xdb\x30\x0f\x24\x12\x2c\xd6\xba\xda\x25\x53\xca\xd3\x0c\x24\x19\x53\x96\x39\x63\x40\xe3\x7e\x0d\x32\x67\x1c\x6d\x02\xd6\x1d\x8b\xf6\x05\xf3\x57\x92\x08\xe9\xeb\xde\x33\xad\xfc\xa5\xfa\x60\x22\x13\x09\x10\x60\xd1\xaf\x4c\x46\x99\x48\x6e\x15\x29\xb9\x66\x99\x5d\x8c\x10\xb7\x24\x11\x79\x91\xe1\xd1\x69\x71\xb2\xaa\x7f\xf6\x2b\x54\xea\x9b\xd9\xd5\xc9\xef\xeb\x4b\xf8\xc3\xae\xdc\xbc\x03\x29\xac\x0b\x19\x0c\xee\x21\xe9\x2c\xbd\xff\xe2\x1e\x92\xa0\x9c\x04\x36\x7a\xc0\x13\x8d\xe9\x9d\xf4\x16\x5e\x50\xfd\xba\x16\x59\x74\xe1\x68\xc0\xef\xcc\xce\xe9\xcb\x5f\xb9\x57\x90\x8c\x71\xa4\x6f\x2e\xb3\x8e\x30\xae\x0c\x67\x6f\x1c\x06\x7b\xf4\x9c\xc4\x4a\x52\x26\xb1\xf8\xc1\xbc\x8a\xa2\xf6\x73\x61\x5d\x01\x21\x34\x39\x3a\x3c\x39\x3c\x5e\x32\x3e\x1e\x1a\x09\x24\x03\x4b\x6b\xad\x25\x32\xa9\x17\xa5\x58\x5e\x64\x73\x5c\xc7\x61\xda\x23\x4c\xfb\x30\x6b\x59\x72\xbf\x2a\x97\xee\xd7\x23\x4a\x10\x2d\xa9\xaf\xa9\x62\x7f\x35\x37\x69\x59\x3a\x2a\x7f\x74\xf8\xdb\x61\x8f\x80\x4e\x8e\xc9\x9d\xe0\x87\x1a\x97\x3f\x20\x37\xc2\xc8\xd1\xf5\x44\x73\x51\x12\x0e\x36\xaa\x1f\xee\x8b\x8c\x25\x4c\x67\x73\xa4\x58\x44\x94\xda\xa6\x0e\x53\xed\xd3\x0c\x2f\xee\x99\x76\xc1\x6a\x86\x64\xbc\x42\x68\x5a\xaa\x45\xa8\x11\x73\x66\x70\x32\x05\x9a\xe9\xa9\x8d\x10\xe1\x82\xf7\xff\x05\x52\x60\x02\x22\x77\x57\x5e\x5c\xad\xbf\x4e\xd4\x06\x43\x44\xbf\x81\xee\xba\x03\x7d\x7b\x73\x33\xfc\x06\xf4\x02\xc9\x30\x6f\xf1\x71\x3b\x68\x0a\x00\x39\x16\x32\xdf\x03\xda\xd1\x8d\xa7\xb2\x4f\x0a\x21\xf7\x81\x84\x4d\x85\x6a\xb5\x97\x64\x69\x3f\x85\xd2\xa8\x0d\x39\x69\x8c\x43\x62\x76\xb0\x19\x40\xe2\x1b\xe8\x5c\x0e\x07\xe4\xef\xa2\x34\x5f\x33\xa2\xa3\x6c\x5e\x15\x60\x50\xa0\xc9\x81\x99\xea\xc0\x90\x27\x83\x0d\xdf\x02\x4d\x8d\x8a\x62\xa8\x07\xd0\xfd\x68\x94\x45\xdc\x79\x70\x6b\xeb\x96\x0f\x94\x4a\x8b\x9c\x4c\xdd\x67\x37\xf3\x2e\xdd\xc9\x18\xe0\xe9\xf1\x49\x4d\x12\x0a\x4b\xe1\xdc\x33\x2f\x8e\x7e\x2d\xd1\x0d\x0b\x77\xf7\xfb\x08\x8b\x57\x25\x21\xd8\x5c\xa7\x28\x9b\x15\xc4\x2d\xb0\x0c\xaa\xc1\x6e\x7e\x92\x70\xec\x71\xc5\xd1\x9d\xb3\x38\x17\x27\x42\x8f\x5e\xfb\x40\xaf\x4e\xeb\x8d\x76\x13\x34\x40\x56\x59\x58\x1d\xce\x58\xeb\x4b\x47\x40\xfc\x38\x05\x2f\x3f\x05\x00\xba\xd9\x7c\xd2\x25\x04\x8a\x0e\xe2\xba\x97\xa3\xba\xb5\x30\x7a\x28\xe6\x5d\x5a\xe2\x8a\x64\x42\x81\x9c\xed\x9a\xc9\x5d\x8f\xee\x3e\x5d\xec\xae\xf1\xfb\xb1\x22\x49\x5a\x12\x5e\xe6\x23\x90\x75\x5a\x8a\xd4\xcb\x00\x09\xc2\x12\xae\xec\xed\xde\x96\xdb\xec\xcb\x68\x9e\xfc\xf3\x7f\xfc\xc7\x1f\xff\x63\x60\xa7\xaf\x42\x14\x38\xb9\x3c\xbd\x3a\xfd\xf5\xfa\x87\x33\xcc\x8c\x6d\x0b\xd5\x8e\xe2\x2f\xbb\x8e\xbe\xec\x34\xf6\xf2\xa3\x46\x5e\x62\xbe\x47\x6b\x2a\xd2\x34\xfc\xe3\x94\x06\x03\x8c\xde\x66\x34\x4e\x27\xfb\x05\x35\xca\x8c\xac\xd9\x34\xa4\x9a\xa3\xb6\x17\x67\x4c\x27\xc5\xb5\x48\x6e\x3b\xd4\x6b\xce\xa1\x90\x90\x58\x3b\xd9\xcd\xd9\xd0\xce\x6e\xf4\xcb\xab\xf7\x37\x75\x9e\x01\x06\xe3\x90\xb7\xde\xbe\xf4\xad\xb3\xa4\x19\x9d\xf4\x16\x0a\x5d\xa9\xee\x23\x9a\xdc\xde\x51\x99\xa2\x65\x8b\x6a\x36\x62\x19\xb3\x25\x7f\x7d\xb7\x49\x2e\x6c\xb4\x9f\xad\x6d\x26\xc6\x8b\x05\x35\x6b\x73\x28\x9a\xac\x6c\x10\xcd\x98\xb2\x0c\x2d\xa8\x25\xd7\x2c\x07\x17\x0e\x94\x14\x95\x49\x2f\xb4\x69\x47\xe5\xcb\x8f\xbd\x55\xbe\x0e\xdf\x7b\x97\xde\xd6\x7a\x58\xdb\xa0\xc4\x3d\x66\x75\x8e\xc5\xd9\x6c\x90\xc8\xea\x3e\x0b\x56\x57\x48\xb8\xd6\xa2\xe8\xc8\x4b\x62\x27\x5b\xe3\x23\x19\xc1\x58\x18\x22\xbc\xd6\xe9\xe1\x9b\x0f\x73\xcc\x0c\xf4\x56\x2d\xd1\x70\x6c\xd8\x70\x4c\x55\x26\x53\x6f\xa0\xe4\xa0\xd4\x09\xba\x43\xca\xc2\x6a\xad\x48\xae\x4b\x09\x3d\xf3\x75\x90\xe3\xea\x7a\x75\x8a\x83\x79\x3d\x70\xfb\x23\xe8\xc4\x5a\x6e\x03\x42\x8e\xf5\x40\xdd\xf2\x17\xdd\x28\x89\xa4\x6a\x0a\x58\x5b\x04\xee\x99\xef\x81\x32\x14\xe9\xe1\x61\xfd\x29\x86\xb1\x4c\x24\x4d\x80\x14\x20\x99\x30\xcc\xa8\xe4\x3a\x15\x77\x9c\x8c\x60\xc2\xb8\xf2\xa0\x30\x73\x7b\x98\xa1\x3f\x86\xa9\xaa\x24\xdc\x80\x7c\x68\x54\x3a\x71\x39\x48\x89\xa8\x8f\xa6\x5b\xf3\xa2\x27\x09\x39\x56\xd0\x8b\xb9\x82\xb0\x8f\x8d\xd5\x1b\x2c\xf9\xa8\xe4\xf8\xe6\x14\x32\x3a\xb7\xa1\xa6\x63\xc6\x69\xc6\xfe\x05\x52\x1d\x77\xe0\x71\x32\x20\xac\xaf\xad\x5d\x07\x16\xe8\xa7\xc9\xb4\x9d\xf3\x37\xba\xa8\x36\x1c\xd1\x45\xd5\x66\x92\xe8\xa2\x8a\x2e\xaa\x47\x46\x74\x51\x45\x17\xd5\xc2\xd8\x5b\x2d\x29\xba\xa8\x76\x1e\xd1\x45\xf5\xf0\x88\x2e\xaa\x0d\x46\x74\x51\x6d\x38\xa2\x8b\x2a\xba\xa8\xa2\x8b\x2a\xba\xa8\x3e\x23\xbb\x9d\x1f\xd1\x45\xb5\x34\x49\x74\x51\x45\x17\xd5\xc6\x63\x6f\x95\xaf\xe8\xa2\xb2\x23\xba\xa8\x9a\xe3\xf3\x62\x75\xde\xc1\x33\x34\xaa\x5e\xfb\x9c\xb6\x21\x3a\x15\x58\xe2\xfc\x44\x61\xaf\xb8\xea\x55\x41\x7b\xb8\xa0\x26\x88\x4f\xc5\x71\x1e\xa1\xda\xcf\xb4\x32\x5f\x6a\x5b\x57\x85\x4f\x32\x54\x27\x85\xb0\xff\x57\x3b\x2a\x02\x0f\x85\x55\x78\x77\xcf\x59\x7b\xb2\x6c\xac\x36\x6e\x89\x4f\xe3\x92\xd8\x13\xff\x4d\x07\x6e\x88\xe8\x82\x78\x71\x2e\x88\x97\xd3\x2c\xd7\x79\xe6\x6f\xa6\x12\xd4\x54\x64\x3b\x23\x7a\x03\xc9\xdf\x31\xce\xf2\x32\x37\x38\xa7\x0c\x3e\xb3\x59\x15\x02\xa0\x2a\x74\xb5\x14\xdb\x5a\x11\xcd\x8d\x2c\x05\xac\x74\x4a\x59\x66\xb6\x11\xf3\x37\xa7\x74\x66\x70\x5d\x95\x49\x02\x80\x7d\xd4\x42\x0d\xe7\x8f\x83\xea\x4d\x55\xdf\x8c\xd7\xed\xe8\x4d\x3b\x26\x6e\x6b\x91\xe2\x2c\x7f\xfc\xc3\x4e\x73\x4c\x64\xd1\x0d\x5d\xfe\xe6\xc3\xf0\x2c\x6c\x8e\xcd\x3d\x59\x66\x7c\x26\xb2\x99\xed\xab\x8f\x37\x19\x61\xcd\xb5\xe0\x67\xf6\xc6\xac\x98\xd2\x40\xbb\x71\x8a\x81\x22\xc0\xe9\x28\x33\x4f\x9a\xe7\x2a\x9e\x3c\xb4\x9c\x17\xa8\x2e\x25\x90\x09\xd5\x4f\x49\xf2\xdb\x2b\x31\xad\x14\x98\x2e\x38\x4e\x5b\x19\xbd\x69\x85\x33\x92\x78\xd3\x0e\x35\x41\xcc\xb0\x05\xf4\x37\x96\xc4\x5b\xd3\xca\xf6\xd2\x71\xfb\xc3\x45\xb0\xc2\x0d\x7e\x78\x67\x00\x3e\x70\xbd\x9e\x3d\x43\x0f\xd5\x20\xdf\x54\x4a\x0b\x52\x64\xb4\x6e\x0b\x85\x3b\xf0\x2d\x72\xa1\xb3\x29\x24\xb7\x1f\x9c\x2f\xf6\x48\x01\x54\xd2\xe9\x84\xe9\x69\x39\x1a\x24\x22\x3f\x31\x44\xc1\xfe\xdf\x28\x13\xa3\x93\x9c\x2a\x0d\xd2\x08\xac\x8e\xc9\xf5\x13\x33\x0b\xe3\x93\x41\x9e\x1e\x0f\xc8\xcf\xdc\xe6\xb7\xd7\x6d\x28\x83\xea\x0e\xe6\xfd\xbe\xd2\xc6\x08\x0c\x7d\x15\x32\xec\x1b\x3e\x9a\xe3\xf2\x06\xed\x5b\xc9\xb7\x60\x4a\x2d\xfd\xe0\x9f\xde\x07\x1e\x29\x17\xe9\xc0\xe4\xf2\xdc\x7c\xdd\x9d\xc5\x7c\x74\xe0\xe3\xde\x23\xff\xf6\xde\x08\xc7\xfb\xe2\xd3\xde\xc3\x62\xd3\x1d\xb8\x60\xbb\xf0\x61\x77\xe7\xbf\xfe\x08\x35\x99\x3f\x8e\xdf\xba\x43\xe3\x5e\x47\xfe\xea\x4f\xe1\xab\xee\xe4\xab\xdb\xfa\xa8\x3f\x9d\x7f\xba\x9b\xcf\xed\x52\x11\x78\xae\x3e\xe9\x0e\x8c\xf4\x5d\x1a\xe8\x3b\x33\xce\x7f\x34\x1f\x74\x7b\xff\xf3\x1e\xf8\x9e\x5b\x03\x99\x71\xa6\x19\xcd\xce\x21\xa3\xf3\x6b\x48\x04\x4f\x77\xe6\x30\x0b\x45\x3a\xab\xf3\xa3\xec\xb4\xce\x52\xd5\x4c\xb5\x98\x52\x57\x8b\xdc\x68\x54\x36\xb5\xc4\x7b\x33\x9c\x40\x81\x7e\x65\xbb\xca\xbd\xf4\x4f\x90\xbd\x31\x89\xd9\xbc\x93\x2e\x37\xf1\x5b\x71\x47\xc4\x58\x03\x27\x47\x8c\xfb\x7d\x3c\x0e\xd4\xc0\xda\x3e\x59\xa1\xb5\xb9\xfa\xfa\x95\xbf\xf9\xe5\x19\x1e\xd1\xc4\xaa\xd4\xc7\xb7\x03\xbb\x17\x3d\x6e\x08\x76\x37\x8e\xcb\xac\x69\x0c\xb6\x06\xe2\x26\xbd\x79\x5d\x57\x53\x7e\x8d\xf3\x56\xa7\x8d\xf2\x94\xb8\x5c\xb4\x97\xb7\x69\xad\x23\x6b\x9a\xa2\x5f\x15\x49\xf3\x98\xdd\xf8\xe6\x6c\x68\xcd\xc6\xd1\x5c\xb2\x2f\xe6\x92\x27\x8a\x4e\xd9\x43\x41\xf7\x99\x46\xa4\x44\x41\x77\x8b\x11\x64\xa7\x7e\x23\x69\x02\xc3\xce\x65\x04\x7f\x9c\x48\x5a\x4a\xea\x08\x60\x25\xf2\xf9\xc3\xc3\x01\x52\x7b\x9a\xaa\x8c\x5e\xcc\x95\x1d\x97\x59\x36\x27\x65\x21\x78\x33\xff\xd9\x7a\xdb\x17\xd3\x69\xd1\x24\xbf\xe2\x2d\xb5\x60\x59\x48\xe1\x78\xa6\x2c\x39\x37\x34\xb8\x6e\x89\x86\x82\x24\x16\x6a\xa6\x8d\xa4\x5d\xc5\x26\x66\xf9\x86\xff\x61\x3e\x6f\x1d\x82\xd8\x98\xd0\x3c\x3d\x16\x32\x61\xa3\x6c\x4e\xa6\x34\xab\xfa\xdf\x50\x72\xcb\xb2\xcc\x4d\x33\x20\xd7\xa0\xad\x4b\xc1\xf2\xce\x4c\xf0\x09\x2e\x8e\x72\xdf\x77\x11\x12\xf3\x6c\x92\x01\xe5\x65\x61\xdf\x67\x38\xf1\x5c\x94\xd2\xbf\x6f\x50\x39\x26\x2a\x0e\xcc\x59\xd6\x0b\xba\xbb\x3d\xb8\xb1\x55\xf4\x4f\xa9\x8c\x00\xf0\xde\x17\xa6\xee\x85\x73\xfa\xda\xe1\x2a\xe8\xed\x53\x48\x31\x63\xa9\xf5\x6e\x78\xb0\x61\x1f\x69\xdb\xbf\xa7\x3a\xcf\x5c\xf0\x3e\x87\x09\x45\x41\xc5\x9d\x22\xbb\x67\x76\x1e\x1b\x43\xc0\x53\xec\xe8\x63\x24\x7c\x51\x34\x12\xea\x67\xcc\xf6\x22\x0e\x20\x47\x8e\xb8\x20\x02\x23\x52\x4b\xce\xb4\xed\x6f\x3f\x2d\x35\x49\xc5\x1d\x3f\x0e\xfc\xae\x64\x04\xfa\x61\xaf\x2b\x3a\x5a\x6f\x56\x02\xa8\xe9\x7e\x5d\x25\xe7\xd8\xef\x7d\x18\xbc\x4c\x39\xd3\xe7\x98\x94\x5c\x41\x4b\xf6\xde\x99\x70\xf4\xe7\x3f\xed\x46\x23\x58\x0e\xa2\xd4\x9f\x44\xfb\xbb\x9b\xb2\x64\x1a\x0a\xb3\x2c\x07\x45\x44\xb9\xa0\x16\xbf\x76\x8f\xad\xde\xa1\xa8\x02\xae\x1a\xbb\x1a\x76\x57\x58\xbf\x16\x0b\x22\xd4\x8d\xaf\x31\x52\xfc\xfc\xea\xfa\xd7\xb7\xa7\xff\x75\xf1\x76\x40\x2e\x68\x32\x0d\xab\x62\x70\x42\x91\x68\x20\xa1\x98\xd2\x19\x10\x4a\x4a\xce\xfe\x59\x3a\x87\xef\x51\xf5\xec\x71\xa7\xd5\xda\x77\xe4\xbe\xd8\x9c\xbf\xb3\x6e\x70\xb6\xd5\xbf\x8d\xcc\x12\x0a\xb0\x7f\xcb\xa2\xf8\x74\x61\x2e\x59\xe5\x00\x45\x2d\x0c\x9d\x9f\xb0\x99\x23\xc3\xae\xfc\x3d\x4d\xab\x58\x31\x83\xe7\x06\x2d\x0c\xab\xa2\x23\x8c\xf1\x9a\x02\xe1\xa0\x0d\x5a\x57\x36\x26\xc1\x55\xa3\x3c\x49\xa9\x40\xf5\xc8\xa8\xc4\xa8\xb4\x42\xb2\x9c\x4a\x96\xcd\xc3\xc9\x0c\xaf\xba\xaa\x5c\xde\xf3\xc5\x25\x9d\xbf\xbf\xb8\xc6\x2c\x81\x42\xda\xc2\x25\x18\x56\x86\xd7\xf1\xb3\x46\x60\x9e\x70\x5d\x84\x07\xe4\x94\xcf\xed\x45\x7b\xc0\x99\x22\x19\x53\x1a\x90\x05\x3b\x19\xd2\x3b\xd3\x0f\x5e\x0d\xf0\x7f\x07\xe6\x2b\xa5\x11\x32\xab\x68\xb9\x64\x29\x7c\xd5\x8a\xa1\x6c\x94\x05\xd0\x74\xdf\xfe\xa2\xfa\xc1\xd5\x41\x42\x06\x88\x41\x3f\x38\x5a\x6d\x35\x82\xd7\xf6\x07\x64\x7c\x92\x85\x58\xb5\x1b\xd9\x6f\xab\x5b\xb6\xd5\x2c\xfb\xf5\x17\x0c\x77\x55\x30\x3b\xe9\x4b\x57\xaf\xa1\xa3\x6e\x4e\x35\xf7\xf3\xea\x94\xa3\x08\x22\x6c\xd0\x7b\x39\xf4\x27\xc0\x49\x37\xf9\x42\x57\xd7\xa2\x8e\x49\xea\x91\x57\xe4\x6f\xe4\x9e\xfc\x0d\xd5\xab\x3f\xb7\xed\x7d\xd5\x56\xf1\xe9\x22\xc4\xc8\x68\xf5\x97\xc3\x8e\x20\xfe\xa3\xa1\x4e\x66\x46\x03\x55\x2d\xc8\x88\x39\x71\x1e\xee\x35\x48\x43\x47\xdd\x4e\x3c\x69\xd7\x30\xb3\xc0\x4f\x88\x66\xd6\xdd\x70\x39\x6e\x86\x35\x6d\x87\x68\xe6\xf1\x6f\x85\xd2\x57\x8e\x0a\x35\x5b\xe0\xd4\xb3\xe5\x54\x27\xd3\x26\x19\x33\x82\x9a\xd2\xf5\x01\x53\x24\x15\x18\x65\x65\x03\x98\xa7\xac\x45\xf0\xc4\xfe\xa0\x71\x3b\x7f\x7a\x63\x3f\x1f\xda\xa9\x05\x03\x0a\x6a\x3e\x4e\xb0\x0a\x6a\x63\x15\x22\x75\x32\x99\x59\x56\x1a\xf0\x8c\x07\x84\x32\x67\xab\xa9\xac\xcc\x88\x4b\xe6\x3c\x25\x94\xdb\x14\x92\x31\x48\x69\x63\xce\x47\x73\x1f\xac\xd7\x7a\xf3\x5a\x9d\xa4\x42\x0a\x2d\x12\xd1\xa2\xb1\x59\xd3\xc7\xed\xa6\x43\x20\xd8\x38\x5f\x6f\x26\xff\xfe\x7c\xd8\x23\x37\x67\x43\xec\xf7\x74\x7d\x76\x33\x6c\x6a\x2a\x07\x37\x67\xc3\x83\x27\x05\x05\xf1\x92\x15\x1a\xa6\x77\x98\xa4\x61\x78\x32\x62\x5b\x3f\xa7\x45\xff\x16\xe6\x3b\xf2\xd4\x2e\xf8\x7a\xbf\xda\xe1\x4e\x3e\xc8\x82\x39\xa7\xc5\xd6\xb3\x49\xa0\x29\xfb\x44\x79\x5c\x3e\x0c\xb6\x7a\xe7\xea\x84\xae\x5c\xcc\x20\xb5\xe2\xb0\x7f\x02\x78\x5a\x08\x66\xe4\xc5\x98\xe5\xb5\xfd\xd3\x31\xcb\x6b\xe3\x11\xb3\xbc\x62\x96\xd7\xf2\xd8\x9b\x40\xd6\x98\xe5\xf5\xb2\xfc\xf6\x31\xcb\xeb\xb3\x77\xfe\xc7\x2c\xaf\xd5\x23\x66\x79\xc5\x2c\xaf\xcd\x46\xcc\xf2\xda\x7e\xec\x5d\xd8\x52\xcc\xf2\xda\x6a\xc4\x2c\xaf\xe5\x11\xb3\xbc\xd6\x8c\x98\xe5\xb5\x66\xc4\x2c\xaf\x98\xe5\x15\xb3\xbc\x62\xf0\xeb\xa3\x73\xed\x67\xf0\x2b\x89\x59\x5e\x6e\xc4\x2c\xaf\x17\x11\xe2\x47\x62\x96\xd7\x46\x23\x66\x79\xc5\x2c\xaf\x5d\x46\xcc\xf2\x7a\x29\xe6\x92\x98\xe5\x15\xb3\xbc\x3e\x1f\x41\x37\x66\x79\xc5\x2c\xaf\x98\xe5\x15\xb3\xbc\x1e\x5c\x45\xcc\xf2\x7a\x09\x2a\xa0\xef\x05\xdc\x3e\x6b\xe9\xf0\x4c\xe4\x45\xa9\x81\x7c\xf0\x53\x56\x52\xa4\x25\x0c\x4c\x85\x12\x41\xfb\x20\xc2\x44\xf0\x31\x9b\x38\xca\x7e\x62\x1b\xf0\xf6\xab\xef\xe9\x07\x4d\x6f\x9f\x61\x04\x61\xc6\x72\xb6\x5b\x2a\x19\x59\xda\x98\xb7\x38\x57\xe0\x97\x31\x27\x29\xa7\xf7\x78\x44\x68\x2e\x4a\xdb\xb4\x38\x71\xfb\x57\x81\xd0\x7a\xaf\xf6\x6e\x67\x48\x37\x2a\x4e\x9d\x13\x37\xec\x22\xac\x84\x6a\x0d\x92\xbf\x21\xff\x7d\xf4\xf3\x97\xbf\xf5\x8f\xbf\x3a\x3a\xfa\xe9\x55\xff\xaf\xbf\x7c\x79\xf4\xf3\x00\xff\xf1\xef\xc7\x5f\x1d\xff\xe6\xff\xf8\xf2\xf8\xf8\xe8\xe8\xa7\xef\xde\x7d\x73\x33\xbc\xf8\x85\x1d\xff\xf6\x13\x2f\xf3\x5b\xfb\xd7\x6f\x47\x3f\xc1\xc5\x2f\x1b\x4e\x72\x7c\xfc\xd5\x17\x3b\x2f\xb9\xb5\x48\xdc\x9d\x40\xdc\x91\x38\xfc\x51\x84\x61\xe7\xd0\xed\xe8\x2c\xba\x60\x94\xa5\xd3\xe8\x18\xd6\x43\xa7\xd1\x53\x53\x14\xf3\xaa\x79\x98\x22\x22\x67\xda\x08\x87\x46\x1e\xa4\x61\x40\x2b\xd3\x0d\xa5\xd4\xd1\x01\x0c\xe9\xa6\xda\xb6\x58\xaf\x82\x41\x83\x20\x16\xe1\x25\x3f\xd7\x83\x9e\xe5\x45\x86\xad\xcd\xf1\x3c\xf7\x7d\x2c\x0b\x32\xd7\x48\x1b\x1e\x1f\x91\x36\xbc\x44\xda\xa0\x20\x29\x25\xd3\xf3\x33\xc1\x35\xdc\xef\x64\x61\x69\x92\x86\xeb\xe6\x84\x2e\x66\xcc\xe5\x71\xbb\x6b\x44\x14\x36\xf2\x7b\x21\xa1\x7e\x2a\xca\x2c\xc5\x74\x8e\x92\xa3\x82\x69\xf3\xf4\x40\x5b\xed\x0f\xf5\x1e\x0c\xe6\x5e\x7c\x89\xd7\xe7\xac\x9a\xf9\xcf\x92\xcd\x68\x66\xb4\xdd\xfa\x89\x21\x6a\x30\xe1\x43\x9b\x9e\x79\x4d\xd5\x6d\x7d\xe0\xa1\x6f\x64\xe8\x6a\xcd\x27\xfe\x93\xf0\x27\xb8\xd7\xcf\x51\x4a\x43\x01\x69\x28\xd9\x8c\x65\x30\x81\x0b\x95\xd0\x0c\xe9\x5a\x37\xbc\xe2\x74\xcd\xec\xb8\xf1\x52\x64\x8a\xdc\x4d\xc1\xd0\x6a\x42\xbd\x09\x00\x73\xec\x26\x94\x71\x92\x9b\x2d\x2a\xfc\xc3\xca\xda\x12\x0c\xf9\x2f\xa8\x34\x1b\x5c\xd9\x0c\x50\x45\x1e\x09\x91\xb9\x9c\x87\x6c\x5e\xcf\xef\xb2\x7f\xb8\xf8\x95\xc3\xdd\xaf\x66\x36\x45\xc6\x19\x9d\x54\xa6\x02\x05\x7a\xc9\xda\x57\x4f\xbd\xf6\x03\x30\xa1\xa0\x04\x42\xb3\x3b\x3a\x57\xb5\xe1\x24\xa8\xfc\xa0\xde\x90\xd7\xc7\x88\xce\x54\x91\x6a\x8e\x94\xfc\xe1\x18\xdd\x7f\x67\xa7\xc3\x5f\xaf\xff\x7e\xfd\xeb\xe9\xf9\xbb\xcb\x2b\x72\x25\x34\x58\xa6\x16\x34\x08\x4c\x2a\x0d\xc3\xac\x12\xdf\x81\x5a\xba\x50\x03\xb4\x5d\x32\x45\xee\x18\x4f\xc5\x9d\xda\xd9\x46\x6b\xd1\xcf\x00\x0f\x28\xdf\x69\x8e\x84\x16\x14\xfb\x1e\xb6\xe0\x30\x4b\x11\x26\xe1\xa4\xc8\xc3\xd3\xf4\x24\x95\xa2\xb0\x40\xf0\x46\xae\x9a\xd5\x36\xd5\xe8\x30\x86\x15\xf7\x77\xdc\x9c\x70\x22\x29\xd7\xb5\xb5\xa7\xde\x33\xd7\x70\x71\xd0\x7a\x3b\x9e\x77\x4e\x13\x4d\xbb\xcb\x67\x3a\x4d\x53\x48\x1b\xe0\x7f\x71\x91\x83\x67\xfe\xe3\xe6\x75\x9d\x0a\x32\x7c\x7f\x7d\xf9\xbf\x17\xf0\x78\x5e\xb4\x0b\x94\xea\x26\x37\x56\x8a\xa2\xb3\xdd\xfd\xe0\x72\x2f\xe3\xfe\xee\xc5\xfe\x56\xdc\xb2\x1b\xf7\xfc\x87\x92\x37\x4b\x19\xd5\xf3\x93\x5c\xa4\x30\x20\xc3\xca\x4f\xd0\xbc\x1a\x94\x38\xa0\x12\x88\xb9\x85\x6b\x46\xb3\x6c\x1e\x8a\x68\x5a\xd8\x3c\xc4\x46\x75\x86\x90\x90\x8f\x69\xa6\x9e\x9a\x1a\xb7\xe1\x8d\x46\x8e\x78\x67\xf4\xe1\x4e\xb6\xa3\x9a\x8d\xa4\xc0\x85\x76\x82\xb5\x59\x25\x56\xbc\x90\x22\x21\x56\xf9\x0e\x82\xb1\x1a\xfc\x4d\x59\x5f\x85\x67\x8d\x4c\x79\x60\x0f\xab\x99\xad\xa1\xba\x54\xb0\x28\xa0\xfb\x5e\xc4\x95\x3a\x6e\x66\x97\x40\x53\xc1\xb3\x39\x46\x5e\xda\x58\x8a\x9c\xaa\x5b\x48\xed\x0f\x4e\x34\xab\x3c\x15\x66\xc6\xea\x55\x37\x66\xdd\xde\x2d\x81\x22\x99\x8d\xf0\x40\x77\x06\xa4\x4f\xbc\xeb\x2d\x0e\xa1\x01\xca\x7b\x9e\xcd\x3f\x08\xa1\xbf\xae\x12\x69\x3b\xc1\x80\x1f\x9d\xb4\xdc\x34\x45\xa3\x38\x49\xf1\xbd\x7d\xdc\x0d\x3c\x54\x61\x0e\xef\x79\xbd\xe3\xcf\xfd\x48\xc9\x92\x9f\xaa\x6f\xa4\x28\x77\x66\x62\x4b\xc2\xe6\x37\x97\xe7\x48\x8a\x4a\xe7\xaa\xe4\x5a\xce\xb1\x78\xc0\x72\xdd\xb7\x4a\x31\xf8\xde\x39\x5b\xc3\x33\x51\xfb\xc5\xc8\x3b\x3a\x27\x34\x53\xc2\xc3\x92\xf1\x95\x5a\xa8\x53\x71\xcd\xe5\x91\xd0\xd3\x25\xdd\xd6\x1c\xa8\xe5\xe7\x7a\x81\xe7\xb2\x2e\x44\xc7\xf8\xd2\xe3\x9a\xde\x82\x22\x85\x84\x04\x52\xe0\xc9\x53\x6f\xfb\x53\x3b\xfc\x10\x75\xae\x04\x37\x07\xb3\x13\xe4\xb9\xac\x3c\xbd\x0e\xa4\x21\xaa\xa0\xcf\xd8\x69\x7f\x14\x3d\xc7\x78\x2c\x4b\x05\xd2\xba\xb9\x65\x09\x76\x27\xbf\x2b\x47\x90\x19\xc8\x1b\x95\xd4\x75\x8b\xb7\xe6\x0c\x96\xd3\x09\x10\xaa\x2b\x4c\xd3\x82\x00\x57\x86\x62\x5a\x03\xa8\x26\xa9\x80\x3a\xff\x9e\x2a\xf2\xfd\xe5\x39\x79\x45\x8e\xcc\xbb\x8e\x11\x7f\xb0\x99\xbc\x16\x36\xc8\x6d\x51\x47\x1d\xfb\x29\x70\x49\x88\xbc\x44\x48\x4b\x24\x7a\x84\x0b\xa2\xca\x64\x1a\x76\xb0\xf7\x6a\xb3\x0b\x84\x44\xd7\xca\x7e\xe2\xfa\xd3\x52\xa8\xef\x15\xc8\xce\x08\xd4\xf7\x3b\x10\xa8\x50\x8c\x32\x38\xd7\x84\x9e\x45\xac\x1c\x34\x4d\xa9\xa6\x8e\x70\xf9\x1b\xf6\x76\x4b\x3f\x6f\xf2\xa5\xe0\x2d\xe3\xe5\xbd\x0d\x3c\xea\xce\xd4\x72\x7d\x81\xd3\x92\xc4\x43\x1d\x77\x9d\x16\x45\xc6\x6c\xbd\x8d\x85\x40\xb8\xcb\x06\xae\xf4\xd6\x88\x89\x48\x27\x68\x96\x09\x43\x1f\x8d\x70\x42\x79\x2a\xf2\xa5\x97\x19\x21\x12\x1a\x15\x53\x07\x24\x62\x5f\x73\xec\x89\x51\x28\x83\x19\xb4\xa8\x2e\xb6\x58\x21\xd6\xcc\x66\x80\xe3\x31\x02\xa7\x27\x19\x1d\x41\x66\x61\x6c\x31\x50\x2d\x63\xe0\x53\x47\xa3\x4a\x91\x75\x97\x3e\xf3\x41\x64\x60\xc3\xbb\x3c\x20\xcc\xf4\xcf\x02\x0e\x38\x49\x57\x70\x40\x6d\xb0\x01\x07\xd4\x6b\x9f\x03\x1c\xca\x16\xac\x9e\x2c\xc2\xc1\xc8\x0d\x4d\x38\x20\xf3\xde\x77\x38\x28\x48\x12\x91\x17\x43\x29\x8c\xda\xd9\x19\x6f\x72\xd3\xd6\x3e\x43\x6b\xd8\x58\x11\x8c\x85\xbc\xa0\x79\x33\x95\x41\x60\x27\xd5\x96\x49\xf8\xe8\xce\xff\x15\xf0\x2c\x24\x3d\x8b\x8c\xcc\xcf\xd2\x70\x2f\x9a\x27\xdd\x85\xe7\xcc\x0e\xba\xc8\x8d\x68\x61\xec\xec\x84\x1b\x89\x84\x66\x58\x3d\xb6\x1d\xca\x91\x45\xb4\x5b\x9c\x38\x08\xe7\x45\x1f\x25\xfe\xe6\x03\x48\xb0\x90\x28\xfe\xe2\x4c\x98\x5c\xa4\x10\xf8\xb2\x6d\x1c\xf2\x8d\x0d\xfb\xc4\xfb\x7c\x24\xb1\x91\x2b\xbc\x5b\x39\x6d\x3c\xad\x85\xab\x81\xf6\xae\xaa\x49\x6b\x16\x08\x3c\x65\x7c\x82\x76\xb5\x1e\x91\x90\xd9\x18\x64\x47\x04\x6e\xad\x06\x79\x88\x47\xc2\x4f\xea\xcf\x83\x7f\x35\xca\x62\x4c\x70\x37\x33\x5a\x8a\xbc\x84\x35\xb6\xe4\x96\x29\x72\xf0\xd6\x03\xa0\x45\x11\xcf\x7d\xe4\x30\x07\xf6\x0b\xab\xdd\xb4\x96\xce\x5b\xc6\x53\x17\xae\xdb\x00\x56\x55\x6e\xdd\xca\xc1\x18\x08\xce\xd2\x90\xb6\xbc\x21\x3f\x73\x52\x01\x8b\xf4\x77\x46\x8f\x0f\x56\x64\xf6\x36\xba\xfe\xc3\x86\xd7\xea\x25\x8b\xd3\x7c\xcf\x71\xef\xcd\x7b\xfb\x46\x73\x5f\xbe\xcf\x7f\xcb\x93\x96\xee\x71\xd4\xaf\x6b\x2d\xe6\x47\x3b\xad\x17\xe9\x13\x83\xd6\x9a\xf1\x89\x0a\x35\x19\x9a\x65\x0d\x63\xf8\x2a\x55\xc6\xef\x70\x55\x5c\x7f\x59\x85\x58\x48\x33\x78\x2e\x6a\x48\x66\xc4\x89\x67\xae\x84\x4c\x72\x45\xcf\xa4\x81\x84\x66\x34\xbb\x2e\x76\x2f\x52\x4a\x96\x0a\xe2\xbd\xbb\x3e\x6d\x4e\x8d\xcc\x1a\x7b\x3f\x98\xbd\x32\xd7\x09\x4d\x73\xa6\x14\x1a\xc2\x60\x34\x15\xe2\x96\x1c\xad\xa8\xc7\x15\xc4\x69\x29\x36\x51\x27\x0e\xe7\xfb\x66\xf5\xc7\x84\xf1\xac\x8a\x8a\x42\x3d\x98\x6b\xe5\x0d\x39\xf8\x92\xa4\x5a\x05\xee\xa1\xab\x5c\xed\x82\x15\x96\x97\x69\x6b\x55\x1b\x2c\x78\x72\x82\xbd\xbc\x3d\x57\x2d\xcb\xae\x3c\xb2\x45\x57\x0e\xb7\x17\x2b\xab\xad\x84\xa3\x95\x1e\x9f\x1c\x48\x4e\xb8\x48\x40\x75\x57\xd0\xe9\xdb\x7a\x4e\x92\x82\xcd\xe2\x01\x8c\x7e\xa2\x6b\x83\xec\xd0\x2e\x7d\x88\xc9\xa0\xee\xd1\xc3\x50\xa2\xbe\xa9\x89\x8b\xd1\x47\xb2\x62\x4a\xfb\x56\x49\x37\x14\x0d\x49\xa0\x17\x21\xa6\x82\x0b\x97\x24\x61\x98\xa8\xe0\x88\xd2\x48\xa2\xac\x37\x0f\xf7\xc4\x91\xe8\x60\xa9\x67\xb5\x97\x38\x74\x04\x62\x32\x99\xad\x1f\x51\xaf\xe1\x8e\xe9\xa9\xef\xf5\xd2\xf0\x1a\xe2\x4a\x24\x28\x74\xc0\x70\x02\x52\x0a\xe9\x02\xb2\xbc\xdd\x1a\x67\x42\x4a\x8e\x11\x5d\x06\x49\xa8\xf9\xeb\x50\x85\x8e\xea\xba\x18\x3c\xc6\x2b\x1a\x6c\x82\xf1\x18\x12\x14\xb4\x42\x00\x5b\xaa\x7d\x54\x97\xbe\x75\x59\x06\x06\xc1\x5c\x31\xf9\x9c\xdd\x9b\xb7\x84\x4f\x85\x2e\x71\x57\x72\x76\xf5\xe5\xe3\x01\x21\x97\xbc\x8a\xe0\xed\x99\x5d\x0c\xef\xf4\xa1\x67\xda\x7c\x62\xd8\x89\x00\x3f\x20\x34\x9c\x19\xe9\x50\x96\x1d\x60\x7c\x1b\x73\x38\x09\x4d\xe2\x9d\x92\x03\x34\x8d\xbb\x49\xcd\xd6\x7b\x19\xa0\x8d\xa9\xdc\xdc\xf2\xb1\xcc\xe5\xcf\xc3\x01\x42\xda\xd2\x39\x57\x4d\xa1\xa3\xf2\xf0\xd7\xc1\x6c\x81\xf4\x5e\x39\xdc\x86\x22\xb5\xd5\x54\xaa\x6a\x10\xd8\xd5\x09\xab\xbb\xb0\x7f\x79\xf9\xac\x96\xf1\xb8\xb0\xd9\x01\x61\x99\x15\x57\x54\x3b\x25\x46\xd4\xce\xbc\x6d\x21\x2f\x32\xc0\x2c\xce\x60\xe6\x3a\x41\x35\xa8\x27\xdf\xab\x16\x52\x97\xa4\x77\xc5\x5d\x7a\xe4\x7f\xf0\x50\x56\x81\xa8\xbe\xee\xc4\xb0\x7a\xdc\x6a\x88\x4c\xf9\xe6\x12\x98\x61\xa9\x85\x37\x5d\x90\x94\x8d\xc7\xe0\x03\x5e\x8d\xe6\x48\x25\xcd\x0d\x89\x57\xc4\x81\x60\x04\x13\x66\x03\x22\x2b\xc2\x76\x68\xc4\x3d\x97\xeb\xd7\xb3\xc4\x90\x69\x92\xb3\xc9\xd4\x22\x0a\xa1\x98\xa1\x4b\xbc\x53\x31\x13\x34\x25\x88\xdb\x42\x92\x3b\x2a\x73\xc3\x37\x68\x32\x45\x0f\x25\xe5\x24\x2d\x25\xd6\x59\xd6\x40\xd3\x79\x5f\x69\xaa\x8d\xa4\x0c\xd2\x29\x94\x7e\xfd\xb1\xa8\xfe\x83\x23\x16\xd5\xdf\x70\xc4\xa2\xfa\xb1\xa8\xfe\xf2\xd8\x9b\xe8\xd0\x58\x54\xff\x65\x95\x49\x8a\x45\xf5\x9f\xde\x9f\x10\x8b\xea\xc7\xa2\xfa\x0f\x8d\x58\x54\xff\x91\x11\x8b\xea\xef\x30\x5e\x00\xe5\x8a\x45\xf5\x77\x18\xb1\xa8\xfe\xea\x11\x8b\xea\x2f\x8f\x58\x54\x7f\xed\x88\x45\xf5\x77\x1e\xb1\xa8\x7e\x2c\xaa\x1f\x6b\x8d\x6e\x37\xd7\x7e\xd6\x1a\x25\xb1\xa8\xbe\x1b\xb1\xa8\xfe\x8b\xa8\xa8\x48\x62\x51\xfd\x8d\x46\x2c\xaa\x1f\x8b\xea\xef\x32\x62\x51\xfd\x97\x62\x2e\x89\x45\xf5\x63\x51\xfd\xcf\x47\xd0\x8d\x45\xf5\x63\x51\xfd\x58\x54\x3f\x16\xd5\x7f\x70\x15\xb1\xa8\xfe\x4b\x50\x01\x95\x4e\xd9\x4e\x35\x40\x37\x29\x57\xe4\xc2\xd0\x83\xea\x00\xa3\x72\x3c\x06\x89\x94\x0b\xdf\xbc\x14\x3e\x55\x57\x66\x5c\x74\xb2\x82\xee\x61\xe5\x23\x97\xb1\xb3\xe6\x71\x57\x8e\x00\x6b\x75\xd6\xb1\xe2\x17\xef\xbf\x5e\x51\x1b\x69\xe7\xb8\xc2\x5d\xa3\xa4\x71\xcd\xef\xf9\x6e\xfe\xf1\x35\x00\x5f\x95\x41\xe6\xe0\x9e\x64\x42\xb9\x18\x77\x04\x56\x32\xa5\x9c\x83\xd7\xf7\x98\x46\x3b\xca\x08\x80\x13\x51\x80\xf3\x4e\x53\xa2\x18\x9f\x64\x40\xa8\xd6\x34\x99\x0e\xcc\x9b\xb8\x07\x76\x1d\x8f\xee\x7e\x51\x5a\x02\xcd\x7d\x64\x7e\x4e\x99\x9d\x8a\xd0\x44\x0a\xa5\x48\x5e\x66\x9a\x15\xd5\x64\x44\x01\xa6\xd4\x58\x46\x55\x01\x03\xe3\xe2\xea\x20\xf6\x5e\xfd\x36\xb7\x2c\x11\x16\xa7\x43\x6d\xb3\x87\x15\xc1\xf3\x42\xcf\xab\x48\x5e\x20\x63\x26\x95\x26\x49\xc6\x90\x5b\xe3\x1b\x6d\xf6\x34\xce\xd7\xf3\xbc\x9a\xbb\x95\x2a\xb7\x54\x9e\xa2\xd8\x5a\x68\x65\xe3\x62\xeb\x09\xdd\x54\x29\x53\x4e\xcc\x57\x3d\x42\x7d\xe5\x34\x0b\x68\xbf\x52\x04\xb5\xe7\x2c\x76\x76\xf7\x53\x30\x5d\x50\x31\xb6\x0e\x1c\xae\x11\x1d\x93\x1c\x3c\x72\xf6\x1a\xf9\x1c\xb5\x40\x81\x71\x7a\x4b\xc7\x00\x37\x80\xc3\xcc\xe0\x00\x24\x60\xf8\x2b\x5d\x83\xf5\x9f\x1c\xe9\x03\xa6\xf8\x0e\x94\xa2\x13\x18\xee\xe8\x68\x58\xa7\x91\xa1\xaf\xa1\xde\x18\x44\x85\xcc\xe6\xd7\x56\xbf\xd4\xf1\x99\x4d\x31\x88\xe4\x76\x4d\x95\xf0\x73\x27\x99\xd6\x80\x9b\x8a\x35\xf6\xd0\x57\xb9\x98\x82\x7f\xb8\x10\xe5\xf9\xce\x4f\x52\x3f\x6c\x88\x3a\x4f\x6d\xcc\xe5\x08\xc8\x48\x32\x18\x93\x31\xc3\x40\x4e\x0c\xad\xec\xd9\x92\x4b\xd4\x5a\x01\x94\x32\xfa\xae\xe0\x5e\x96\xf5\xeb\x1a\x90\x1f\xdd\xc2\xb4\x2c\x79\x42\x83\x6a\xb6\x98\x63\xca\xc6\x64\x82\xa1\x99\x4e\x5a\xfc\xd3\xab\xbf\xfe\x99\x8c\xe6\x86\xa5\xa1\x64\xa5\x85\xa6\x59\xf5\x91\x19\xf0\x89\x81\x95\x3d\x9e\xcd\x2c\xc9\x0a\x02\xd8\xcf\xc3\x2e\xfc\xf5\x1f\x6e\x47\x4d\x1e\x7b\x92\xc2\xec\x24\x80\x5f\x3f\x13\x93\x55\x1d\x52\x76\x0f\xda\xde\x51\x25\x5a\x81\x66\x22\x63\xc9\xbc\x35\xa2\xf9\xda\x5f\x64\x2a\xee\xac\xac\xbf\x02\x7b\xea\x84\xab\x42\x14\x65\x66\x8d\xce\x5f\x57\xf9\xc5\xa5\x82\xe5\x2c\xc0\x95\xe7\x02\xcd\xa4\x6e\x8a\xc5\xca\xe9\x36\x22\xd7\xbf\x52\xb8\xec\x12\x67\xc8\xab\x4a\x80\xa1\x22\xf4\x35\xcd\xb2\x11\x4d\x6e\x6f\xc4\x5b\x31\x51\xef\xf9\x85\x94\x42\x36\xd7\x92\x51\x43\x2d\xa7\x25\xbf\xb5\x3d\x1c\xaa\x22\x09\x62\x62\x44\xab\xa2\xd4\x3e\x95\x61\xd5\x07\xdb\x8c\x79\x4f\x84\xbd\x1a\x54\xcf\x02\xf7\xac\xd6\x75\x5c\xb2\x96\xc5\xc8\x70\x7e\x15\x22\xdb\x1f\x5e\xfd\xe9\x2f\x16\x75\x89\x90\xe4\x2f\xaf\x30\x6a\x5b\xf5\xec\x21\x46\xda\x66\x18\x45\x4e\xb3\xcc\xa8\x0d\x21\x52\x1a\x40\xaf\x42\xc2\x4f\x8e\x83\xba\x3d\xba\x6d\x2c\x4a\xdd\xdc\xfc\x1d\xe5\x28\xa6\x15\x64\xe3\x9e\xcd\x4b\xaa\xd4\x9a\x43\x64\x0c\x87\x8e\xfa\x60\x72\xd8\x1e\x08\x40\x33\x91\x95\x39\x9c\xc3\x8c\x75\xd1\xc6\xa9\x31\x9b\x57\xf5\x33\xa6\x30\x05\x6c\x94\x89\xe4\x96\xa4\xee\x62\x10\x79\xb2\x58\x0b\x7c\x77\x28\xec\x1a\x83\xd3\x22\xf6\x66\xed\xf7\x37\xa2\x6e\x72\x5a\x14\x55\x96\x90\xa4\x77\x0d\x60\xe0\x99\xc4\x82\x05\x2d\x2b\xca\xb4\x36\x33\xb7\x35\x32\xf7\xdd\x17\x19\xba\xb9\xf3\x14\x3b\x47\x9d\xb4\xb7\x51\xd7\xab\xdf\xdd\x30\xd9\x40\x88\x7a\x42\x7f\x1a\x0a\xfc\xb7\xcd\x2b\x59\xca\x8b\xac\x52\xeb\x2a\xc4\xb0\x02\x80\x41\x1f\x24\xc9\xbb\x1b\x5c\x3b\xb0\x6e\xb6\x0b\x39\x6a\xc0\x85\x57\x56\xe5\x9c\x6a\x27\x10\x7a\xf3\x35\x25\x05\x48\xc5\x94\xe1\xcb\x3f\xe0\x81\x3a\xcb\x28\xcb\x03\x13\xe0\xd3\x00\xc1\x1e\x6e\x2c\xa0\xdc\x9e\x52\x0e\x45\xea\x26\x44\x52\x68\x8b\x47\xaf\x10\x6b\x9b\x52\x6d\x87\x0c\xf5\xa9\x49\xe5\x0f\x35\x34\x9b\x94\xd2\xfc\x52\x91\x4a\x7b\xd7\x4b\x22\x90\xf8\x7d\xcf\x95\x3e\x56\x8b\xef\x88\x0c\x20\x61\x74\x9b\xdb\xa4\x84\x0d\xe5\xd1\x1e\x94\x40\xa4\x77\x7a\xe0\x80\x58\x2f\xb8\x39\x13\xee\x51\x72\xf8\xe6\xf0\x49\x89\xa4\x05\x91\x14\x05\x9d\xb4\xea\xe6\xb3\x00\xa9\xc5\x69\xc3\x52\x13\x46\x0d\xc2\xeb\x55\xe1\x35\xbc\x0b\xd2\xba\x92\x0e\xd6\x49\xb2\xde\x51\x0f\x60\xa7\x20\xd8\x8c\xec\x3b\x3a\x27\x54\x8a\x92\xa7\xce\xbe\x54\x19\xf8\xde\x2d\xbc\xf8\x4a\x70\xf0\x86\xf3\xc5\x4a\x15\x68\xd1\x67\x9c\xbc\x1e\xbc\x7e\xf5\x52\x38\x15\x7e\xe1\x02\xa7\xba\xaa\x38\x95\xa5\x4f\x4f\xfa\xad\xbe\xe6\x7d\x47\xdf\xfb\xce\x99\x58\xea\x92\xf6\xcc\x17\xcc\xc6\x9f\xee\x24\xd3\x10\x74\xf9\x3b\x42\xc5\xc5\xe8\x87\x41\x5d\x86\xe3\x55\xbd\x24\x5a\x02\xa9\x5d\x21\x0c\x55\x8e\x3e\x22\xdd\x72\x04\x0a\x8f\xdb\x2a\x0b\x97\x7a\x80\x84\x85\x80\x3a\x38\x20\x47\xf6\xce\x43\x9b\xd2\x7c\xfc\xa4\xa8\xe5\x80\x76\x71\x5f\xb4\xa8\xb2\xb9\x90\x3d\x5f\x50\xb4\xc1\x15\x1d\x42\xf0\xbf\x60\x4a\x67\x80\xa9\xdc\x2c\xa3\x32\x43\x9f\xe3\xb5\x5d\x3b\x19\x95\x9a\x00\x9f\x31\x29\x78\x0e\x5c\x93\x19\x95\x0c\xeb\xe2\x48\xc0\xda\x0e\x46\x17\xfd\xe2\xe8\x87\xd3\x0f\x18\xd0\x70\xec\x8a\x52\xb8\x55\x96\xca\x17\xb0\x09\x57\x12\x4c\xf7\xe8\xf6\xf9\x75\x18\x18\x22\xcd\xf5\xeb\x32\xef\xc9\x4b\x5d\xda\xc6\x2c\xf7\x49\x56\x2a\x36\x7b\x2a\x4a\xe2\x72\xec\xcf\xd9\x4e\xfb\xbc\x90\xef\x5f\x03\x6a\x29\x75\x1f\x4d\xeb\x2b\x12\xf4\x96\x1c\x26\x87\xaa\x4a\xda\x0b\x7d\xe0\xce\xf4\xe4\xaa\x69\xd8\xf0\x39\x5f\x73\x71\x49\x84\xc0\xca\x31\x4f\x6b\x84\x4a\xb9\x3a\xc3\x15\x6e\x07\xd6\x66\x40\x72\x23\x8f\xef\xfc\xea\x3a\x2c\x43\x62\xd5\x25\x91\x0e\xc8\xb0\xfe\xb1\xae\x55\x83\x15\xd4\x2a\x25\x12\xe4\xa4\x2e\x2b\x3e\x01\x0e\x12\x85\x04\x33\x65\xa3\xb1\x2a\x19\x51\x65\x9d\x3c\xe7\x57\xd7\xd6\x66\xbb\x1d\xcc\x76\x16\xb3\x77\x97\x50\x0d\xc7\xb7\x69\x0c\x3b\x08\xb7\xcd\xae\x69\x95\xc1\xca\x00\x06\x95\x52\x3b\x31\xb9\x1c\x12\x9a\xa6\x12\xdd\x3e\x4e\xf4\x09\x6a\x55\x56\xbe\x05\xac\x0b\x43\x15\x84\x6b\x0a\xc0\x8d\x24\xae\x06\x2c\x39\x2f\x8b\x8c\x59\x37\x42\xf8\x40\x5d\xcf\x06\xdb\x7c\x6d\x8f\xb4\x6d\xd4\xbc\x9d\x95\xbc\x16\x54\x48\xec\x5a\x96\xf2\x81\xdd\x93\xa0\x44\x36\xab\x4b\x0a\x2f\xec\x9a\x3b\x11\x68\x12\xaf\x76\xcd\x57\xa1\xdc\x68\xc7\x80\x6b\x69\x8e\xe6\xe2\x6e\x61\x1f\xfb\xac\xc4\xd3\x54\x4d\xc8\x66\x80\xfe\x71\x57\x80\xd3\x15\x72\xab\x8b\x1c\x5b\xdf\xb0\xad\x33\x0d\x54\x7a\x8a\x86\xab\xda\xf1\x24\x92\xa7\x42\x84\x45\x63\xc7\xf9\xd5\xb5\xa5\x84\xf6\xe3\xab\xfe\xb4\xab\x76\xa9\xa6\x6a\x3b\x63\xe0\x93\xd5\x19\x6a\xa3\x79\x2c\xb4\xf7\x73\x0d\xbb\x5b\x05\xb2\xb4\x10\xff\x5a\x25\xdb\xb5\x78\xbb\x02\x2a\x93\xe9\x2e\xf0\x7f\x80\x10\xd8\x49\x49\x2a\x6c\x24\xc0\x58\x48\x54\x89\xfb\x48\xde\x33\x21\x6e\xcb\x62\x13\x8a\xee\xa6\xb1\x2d\xd7\x36\x22\x10\x8d\x27\x3e\x2b\x9a\x9e\x72\xb5\x8b\xbf\xb7\x29\xfb\x80\xb6\x12\x0f\x4e\x54\x27\x50\x88\x45\xbd\xe9\x2c\x2b\x95\x06\xf9\x35\x93\x4a\x1f\xf8\x8a\xd1\x88\xc1\xd6\x26\x72\x18\xde\xf0\x23\xd3\x53\x57\xbc\xf1\xb0\xd7\xbc\x64\xfe\x76\x13\x1f\x1a\x9d\xf6\xf0\x4a\x70\x38\x1c\x2c\x8a\x5d\x15\x29\xaf\xc8\xda\x5a\x9e\xe2\x96\xae\x20\xb3\xf1\xa2\x78\x21\xc0\x95\x1b\x57\xb8\xd2\xbc\xc1\xd3\x3f\x05\x9a\x50\x2c\x12\x87\x77\x4f\xeb\x42\x93\xb6\x72\x94\xad\x94\x29\x9c\xa0\x37\x0f\x41\x14\x14\x93\xd2\x62\xfd\x67\xef\x22\xcf\x6d\x8d\x01\xb6\x00\xa9\xab\x17\xf2\x96\xf1\xdb\x2d\xd1\xaf\x19\x5d\x72\xb1\x34\x5b\xa3\xa2\xb8\xf5\xd1\x32\x6e\x83\xef\x0c\x8b\xa1\x23\x51\x6a\x5f\x93\x44\x05\x8a\x23\xe3\xff\x63\xf7\x02\xed\xed\x85\xad\xd9\xb7\x4a\x47\x54\x3d\x6b\xf4\xf1\x4a\xa0\x9a\x73\x4d\xb1\xba\xe8\xb9\x48\x6e\x41\x92\xcc\x2c\x63\x40\xea\xc0\x97\x46\x3d\x4b\x59\xc2\x96\x51\x17\xbb\x5a\x3a\xa0\x98\x42\x0e\x92\x66\x75\x59\xd7\x16\xa0\x7e\xeb\x08\x67\x35\x6b\x18\x93\x62\xcb\xa2\xb9\x42\x8c\xe6\x1c\x5e\xac\xba\x2b\xa7\x73\x5f\xeb\x96\x71\x0c\x37\xb8\x67\x0a\xcd\xfa\x85\x48\xc3\xc4\xb3\x52\x81\xec\x57\x69\x81\x2e\xf7\x46\x55\x81\x38\x29\x8c\xca\xc9\x84\xf1\x89\xa3\xce\x48\xd3\x83\x82\xdb\x95\xa6\x83\x91\xde\x89\x04\x5b\x72\x16\xa5\x07\x1b\x5f\xc6\xc2\xfb\x73\x91\xda\xdb\x47\x73\xab\x0d\xfa\x9d\xad\x03\xa4\x2f\x39\x11\xd2\x95\x46\xa0\x69\x8a\x6b\x5f\xfe\x42\xbc\xda\xfc\xaa\x5e\x15\xc7\x61\x23\xbb\xab\xa7\x02\xb0\xa8\x72\x64\x84\x9d\x52\x26\xb0\xca\x76\x1a\x14\xf9\xa5\x33\xca\x32\xb4\x53\x08\x4e\x12\x7b\x8a\x5d\xac\x99\x39\xfd\xfc\x10\xa3\xe0\xb0\x5d\x27\xbe\xf3\x62\x19\x03\x5a\x94\xa8\xda\x95\xcf\xec\xc4\x63\x9a\xe5\x85\x4e\xf9\x8a\x6f\xb1\x01\xe3\x1a\xf2\x42\x48\x2a\xe7\x8b\x1e\x53\x43\x13\x0d\xc6\x99\xfd\x5a\xd8\x98\xa1\x48\x91\x6d\xac\xc0\xb3\x99\x6d\x1d\xbc\x02\xd5\x56\xa2\x34\x12\x5d\x2e\x88\xdf\x40\xc3\x1e\x54\x32\x85\xb4\xc4\x60\xf5\x49\x49\xb1\xb5\xb9\x21\x1a\xce\xb6\x3e\x77\x51\x80\x16\xf7\xaa\xf8\xc2\x2a\x2b\x61\x8e\x31\x39\x58\xf6\xd3\xfc\x82\xe5\x43\x6d\x24\xa2\xed\xec\x8c\x5d\x5e\xab\xa0\xc4\x9b\xba\xd9\x04\x7e\x2c\xcc\x58\xa2\xfd\x43\xe3\x75\x78\x9a\xd0\xaa\xa1\xec\x50\xb8\x72\x83\x09\x18\xda\xa7\x55\xfd\x29\x2e\x88\x05\x0b\x8a\xfe\xcc\x0d\x4f\x5a\x8f\xfa\x35\x9e\x3f\x82\xe1\x28\xc6\x37\xb7\xe2\x01\x6a\x51\x41\x69\xd5\xb7\x9b\x35\x2d\xe4\x0d\x38\xdc\xee\xfc\x9c\x6c\x5b\x07\xaa\x85\xbe\xb1\xbb\x33\x71\x27\x27\x60\x1b\xd5\x86\xca\x49\x7b\x35\xf0\xf0\x54\x4e\xca\xdc\x16\x28\x17\x0b\x35\xa2\x5d\x7b\x64\xcb\x56\xd1\x72\x67\x98\xf2\xd9\xbb\xf3\x30\x49\x23\x8c\x3e\xf7\x29\x2e\x46\xd8\x6b\x69\xd1\x5d\x34\xe9\x5e\x1a\xf5\xb3\xb2\x13\xd7\xdc\xc3\xe9\xa9\xce\x66\x59\xbd\xcd\xeb\xe9\x8c\x17\x46\xde\x40\x29\xa9\xb6\x5a\xf2\x64\x4a\xf9\x04\x0d\xfd\xa2\x34\xf3\x7d\xf1\x05\xae\x48\x42\x5a\x26\xae\x37\x86\x8f\xf0\xfe\xc2\xdb\x37\x5d\x91\x22\x6c\xd1\xa7\x12\x5a\xf8\x35\x87\x9f\x65\x85\x91\x37\x84\x0d\x60\x40\x0e\xbe\x08\x2e\x1d\xd8\xb7\x17\x52\x98\x57\xb8\xe0\x70\x5c\x55\xc6\x34\x9e\xbd\x83\xf0\xee\x01\xb9\x30\xef\x40\x9f\x4f\x05\xc0\x20\x7e\x79\x54\x83\xaf\x47\x24\x4c\xa8\x4c\x33\xcc\x29\x1c\x57\x62\x97\xcd\x3c\x72\x00\xc3\x03\x8f\x11\x83\x5c\xe8\x55\xf6\xd7\x0d\x13\x3f\x34\x55\xb7\xea\xc4\x0a\x6b\xfd\x94\x6a\xda\xc7\x7e\x22\x96\x4e\x9d\x58\x03\x42\xdf\x55\x72\xed\x53\x87\x5a\xfd\x6a\x5b\x4f\x7e\xef\x72\xc7\xfa\xb4\xba\x8b\xf1\x3e\xed\x63\x4d\xd5\xdd\xa3\x61\x9f\x20\x70\xa2\x95\x2e\xdf\xa2\xa0\xef\xa2\x00\x5e\x15\x74\x47\x18\x60\x3b\x94\xba\x80\x77\x15\xa3\xe1\x6a\xd6\xae\x3a\xcf\x17\x57\x37\x1f\xfe\x3e\x7c\x7f\x79\x75\x13\x8f\x75\x3c\xd6\xf1\x58\xb7\x38\xd6\xc0\x67\xad\x8f\x74\xa5\xe8\xad\xd2\x7d\x17\xaa\xe8\x05\xa9\xe3\x2f\x28\x0a\xed\x82\xcf\x7e\xa0\x46\xd4\x2c\x24\x28\x94\x4c\x8c\xc4\xba\xca\x5d\xec\x6e\xb0\x8d\xc5\xce\x9e\x7d\x18\xda\x13\x06\x91\x75\x18\x9c\x73\x15\x54\x3c\x58\xb5\x6b\x61\x27\xbf\xb3\x5f\x2f\xcf\x2f\xae\x6e\x2e\xbf\xbe\xbc\xf8\xf0\xa4\x51\x15\x2d\xab\xd8\x35\x99\xf2\x8e\x5c\xb2\x90\x30\x63\xa2\x54\xd9\xbc\x2a\x84\xbb\x9a\x08\x2c\x07\xe6\x71\xa3\x18\xce\xab\x5a\xbf\x2b\x1f\x8b\xcc\xb6\x5b\x66\xdb\x0c\x32\x69\x51\xc0\xa4\x2b\xf4\xfd\x5a\x8a\xbc\x23\x14\xbe\xb6\xc6\x02\x6f\xdb\x5f\x85\x4f\x87\xae\xd6\x41\x83\xf5\x38\xe1\xb1\x2e\xac\x60\x84\xd1\xbc\xd0\x2d\xfa\x1c\x74\x52\xb7\xb4\x9b\x12\x9f\x36\x20\xe3\x1d\x2d\xbe\x83\xf9\x07\x68\x59\x27\x65\xc1\xa7\x92\x41\x62\x18\x1d\xb9\x85\xb9\x75\xb5\x9e\xf9\x97\xb5\xa9\xe7\xb2\x97\x65\x5f\x6f\xa1\x4d\x49\xde\x2e\xeb\xb5\xde\x42\x8b\x08\x4d\x3f\x96\x2a\x97\x9a\x2d\x44\x39\xcd\xec\x69\xbb\xdd\x23\xdd\xd6\x6a\xfd\x08\xf5\x69\x0f\x43\x76\xef\xe8\xac\xde\xba\x8c\x84\x98\x19\xce\x05\x77\x27\x2e\x3a\xad\x6f\x14\xd7\xbe\xc5\x5a\x75\x82\x21\x38\x27\xbf\xc7\xff\x90\x9b\xf7\xe7\xef\xdf\x90\xd3\x34\x75\x51\xd2\xa5\x82\x71\x99\x59\x9b\xbd\x1a\x10\x5a\xb0\x1f\x40\x2a\x6c\x14\x77\xcb\x78\xda\x23\x25\x4b\xbf\x6a\x53\x5d\xca\x8e\x0e\x77\x41\x78\xcf\x54\xb7\x3b\x71\xed\x1c\x8f\x21\xef\xaa\x88\x08\xb1\x29\x90\x88\x9b\xbe\xd0\x8c\x13\x32\x3a\x02\x4d\xdb\x9e\x78\xc4\x6e\x61\xb7\x74\xf5\xb0\x26\xac\xd6\xa9\x53\x55\xe2\x4a\xdf\x10\x55\x62\x45\x1c\x55\x35\xb2\xc3\xd6\xb0\xbd\xe6\x9f\xaa\xa0\x09\xf4\xc8\x3f\xaa\x1f\xb1\xf5\xbc\xfa\xe9\xf0\xf0\x6f\xdf\x5d\xfc\xfd\x3f\x0f\x0f\x7f\xf9\x47\x78\x15\x59\x21\x6a\xcd\x0b\xb7\xa0\x23\x8b\x8b\x14\xae\xf0\x1d\xf8\xa7\x13\xd7\x4e\x93\x44\x94\x5c\xbb\x0b\x98\xbe\x3c\x98\x0a\xa5\x2f\x87\xd5\x9f\x85\x48\x17\xff\x52\xad\x4a\xa6\xed\x25\x63\xc0\x2d\x6a\x91\x86\x63\x47\x77\xec\xa1\xa6\x25\x1d\x1f\x55\x37\x6b\xd5\xa2\x23\x99\x42\x6e\x8b\x36\x7d\xed\x41\x80\xcd\x76\x7d\x9d\x04\x8e\xc9\xe5\x46\x32\x6d\xd6\xcf\x3b\x98\xbd\x6e\xd5\x95\xdc\x8e\x0e\x49\x5b\xb5\x83\x1d\x03\x0c\x21\xe2\xa0\x65\x0f\x72\xc5\x60\xbd\x96\x52\xbb\x9d\x4f\x87\x97\x64\x66\x21\xbc\x37\xc0\xf1\xfe\xb7\xaf\x3f\x2a\x8d\x0b\xbd\x7c\x0d\x0d\xf1\x8d\xed\x4d\xeb\xaf\xbb\x82\x02\xaa\xaa\xf1\x05\x46\xb1\x39\xb2\x3f\x0e\x92\xa2\xec\xb9\x1b\x06\x39\xe4\x42\xce\xab\x3f\x2b\xef\x62\x5f\x69\x21\xe9\x04\x13\x50\xec\xe3\xf6\xb1\xea\x2f\xfb\x60\xe3\x05\xcb\x4f\x5b\x55\x38\x29\xa5\x11\x1a\xb2\xb9\xa7\xc8\x3b\x16\xc6\xa8\xc7\x1e\xd2\x36\x0f\xfa\x3d\x21\x6d\x15\x66\xb4\xed\x40\x6b\x47\x13\x21\xeb\x10\x01\x14\x38\x2b\x28\xa2\x3e\xe9\x12\x6c\x7b\x95\x18\x64\xad\x01\x7c\x66\x34\xcb\x9d\x4b\x84\xd5\xa3\x43\x6a\x96\xb2\x19\x53\xa2\x45\x9a\x4d\x35\xd1\xfa\xdc\x01\x57\xe3\xc3\x46\x48\x55\x66\xb3\xfb\x02\xab\x22\x55\xe7\x75\x81\xec\xbf\x6e\xd3\x18\xc9\x8e\x82\x6a\x0d\x92\xbf\x21\xff\x7d\xf4\xf3\x97\xbf\xf5\x8f\xbf\x3a\x3a\xfa\xe9\x55\xff\xaf\xbf\x7c\x79\xf4\xf3\x00\xff\xf1\xef\xc7\x5f\x1d\xff\xe6\xff\xf8\xf2\xf8\xf8\xe8\xe8\xa7\xef\xde\x7d\x73\x33\xbc\xf8\x85\x1d\xff\xf6\x13\x2f\xf3\x5b\xfb\xd7\x6f\x47\x3f\xc1\xc5\x2f\x1b\x4e\x72\x7c\xfc\xd5\x17\xad\x97\xde\x41\x91\x52\x3b\xba\x2c\x55\xda\x9c\xb1\x13\xf4\xfb\x88\xf5\xf9\xed\xf0\xe8\xd5\xf5\xf9\xf7\x61\xd2\x6f\x6a\x86\x54\xb1\xeb\xbd\x39\xe0\x0a\x12\x09\xfa\x53\x58\x72\xec\x9b\x82\x52\x09\x87\x8a\x54\xaa\xc5\x4b\xe3\x73\x9f\x83\x71\xa7\xea\xac\x87\xfb\x5a\x4b\xa2\x63\x29\x72\x9f\xfe\x8e\xee\x0d\x6c\xb8\xef\xef\xbb\x85\x56\xdd\x5e\xed\x88\xc6\xa0\x68\x0c\x5a\x33\x1e\x35\x06\x5d\x5b\x3c\xdc\x5b\x4b\x10\xf0\xd9\xae\x2e\x8c\x95\x1e\x74\xaf\xeb\x84\xb5\xe2\x36\x73\xa8\x0d\xfc\x51\xaf\x5b\x52\xd6\x91\x34\x96\xa1\xe5\xab\x7d\x98\xe4\x14\x9b\x4f\xdb\x83\x8f\x13\xd4\xf9\x25\x56\xb5\x71\xa5\x0c\x61\x66\x96\x50\xd5\xc2\x6e\x54\xbd\xc4\x10\x4b\x0c\x7a\xfd\xd1\xc6\xa0\xde\xda\xb0\x54\xa3\xa4\x31\x5e\xd7\x0b\xad\x84\xc3\xba\xc8\x34\x55\x4a\x24\x36\x9c\xb6\xca\x76\xc0\x12\x76\x6e\xd9\xb8\x1a\xec\x78\x5f\x48\x48\x20\x05\x9e\x80\x2b\x40\xdd\x68\xbf\x49\x39\xb9\xe0\x33\x5f\x84\x3b\xf5\xb9\x33\xb8\x92\xd5\x73\xbc\xac\x00\x04\x83\x88\xce\x09\x16\xc4\x21\x20\xd5\xaf\xe3\x68\x31\x14\x43\x8c\x6b\x2b\xeb\x6e\x1d\xfa\x5a\x73\xf1\xf6\x3c\xb3\xf2\x6c\xb5\x12\x86\x96\x98\x65\x6d\x7e\x6e\x32\xc9\x97\xe0\x0c\x6c\xcf\x3e\x3f\x3b\xd6\xd9\x11\xdb\xec\x86\x65\x6e\xe1\x3b\xe9\x92\x4d\x76\xe1\x2c\x29\x24\x8c\xd9\x7d\x47\xe7\xf4\x94\xd7\x96\x18\x96\x02\xd7\x6c\xcc\x6c\x2e\x4d\x21\xa1\x00\x6e\xf3\x13\x68\x32\x45\xda\xef\x38\x65\xed\x9c\xde\xc7\x60\x1e\x2b\x70\x77\x4b\xca\xae\x57\x09\xfb\x91\x8e\x91\x48\xc7\x76\x1e\x9f\x88\x8e\x39\xcc\xdd\x1f\x22\x86\x91\xe7\xed\x43\xdf\xcf\x83\x38\x76\xc4\xe2\xad\xb1\xac\xce\x76\x3a\xc1\x59\x76\xb2\x3e\xb7\x42\x06\x7c\xed\xb0\xcc\xb2\x8e\xaa\x70\x1f\x5e\x22\x34\x8a\x32\xcb\x5c\xf2\xf1\x80\xbc\xe7\x78\x1e\x4f\xb1\xdb\x43\x8f\x5c\xc1\x0c\x64\x8f\x5c\x8e\xaf\x84\x1e\x5a\xc1\xb6\x19\xcb\x66\x6f\x24\x6c\x4c\xde\x18\x95\x49\x69\xa2\x6d\xc5\xfd\xa0\x3e\x90\x90\x8d\x09\xea\xd2\x63\x2d\x62\xd0\xd7\x6f\xcb\xef\x7d\x5a\x68\xff\x89\xb6\xa9\x6a\x69\xd2\x81\x6e\xea\x66\xf2\xd1\x71\x18\x11\xe9\x5c\x23\xab\x72\x7b\x9f\x61\xb9\x8d\x42\x28\x7d\x6d\x54\xd8\x6e\xda\xdd\x0c\xfd\x74\xd8\x41\x82\x66\x19\xa4\x8d\x7e\x47\xb6\x4f\x07\x6d\xaa\xd0\x98\x75\x5c\xb5\x8d\x00\x32\xa5\x3c\xcd\x40\x62\xe9\x77\xb5\x58\xdf\x8a\xd5\xbd\x0e\xaa\xee\x14\x3e\x2f\x94\x26\x89\x90\xa9\xeb\x33\xeb\xf2\x33\x71\x31\xd5\xf1\x42\x42\x9b\x53\x4e\x27\x80\x66\x85\xa5\x02\xc2\x58\x56\x5a\x05\x2d\x2e\xa6\x42\xdc\x92\x44\xe4\x45\x86\x07\xa0\xc5\xf9\xa8\x3b\xec\x54\x28\xda\x37\xb3\xab\x93\xa0\xf9\x0e\xfe\xd0\xae\xf7\x4e\x2b\x49\xa5\x0b\x39\x05\xee\x21\xe9\xac\x3b\xdf\xc5\x3d\x24\x41\x7b\x49\xb3\x25\xae\xbf\xa4\x16\x68\xd8\x68\xdf\x35\xb8\xb5\x4d\xbe\x2b\x3b\x78\x8b\x4c\xb3\x70\x2c\x94\x93\xc3\x39\x7d\xf5\x6c\xf7\x0a\x6c\x44\x60\x93\x99\x31\xfb\xcc\x17\xd4\x6e\x1c\x06\x7b\xf4\x96\x6a\xd0\x55\x91\xc6\x7e\x2e\x4c\xb9\x16\x42\x93\xa3\xc3\x93\xc3\xe3\x25\x03\xdd\x42\x09\xe6\x9b\xe0\x49\x86\x35\x07\x0b\x2c\xe0\x07\xc9\x61\xda\x23\x4c\x7b\x62\x6b\x4b\x1f\xe0\xaa\x5c\x4a\x5c\x8f\x28\x41\xb4\xa4\x29\x73\x2a\x10\xfe\x6a\x6e\xd2\xb2\x74\x75\x0f\x8e\x0e\x7f\x3b\xec\x11\xd0\xc9\x31\xb9\x13\xfc\x50\xe3\xf2\xb1\x48\x48\xa9\x82\x89\xe6\xa2\xc4\x5e\x7c\x16\x04\x55\xc5\x0f\x43\xb1\x88\x28\x6d\xe3\x9e\x29\xd5\x3e\x15\xef\xe2\x9e\x69\xdf\xac\x42\x8c\xc9\x2b\xdb\x37\x08\xa8\x33\x11\x66\x6c\x06\x27\x53\xa0\x99\x9e\xda\x28\x0a\x2e\x78\xdf\xb6\x7e\x33\xa4\xc4\x5d\x69\xeb\x50\x68\x67\x6f\x0b\x47\x0b\xdb\xdb\xf2\x82\x5a\x8a\xd6\x86\x88\x7e\xb3\x7b\x3f\x5a\xb2\xd4\xaa\xf9\xe6\x66\xf8\x4d\xa3\x23\x2d\x52\x71\xad\x0b\x1f\xdb\x12\x54\xcf\xd8\x03\xda\xd1\x8d\x37\xaf\x55\x6b\x5a\xd2\x21\x09\x6b\xdb\xa2\x96\x2c\xb7\xde\xde\xae\x37\x2d\xf9\xbb\x28\xb1\xa7\x1e\x1d\x65\x73\x72\x47\xb9\xf6\x79\x78\x07\x66\xaa\x03\x43\x9e\x0c\x36\x7c\x0b\x34\x05\xa9\x90\x7a\x00\xdd\xb9\x4a\x98\x1f\x9d\x79\x99\x82\xb5\x75\xcb\x07\x4a\xa5\x45\x4e\xa6\xee\xb3\x9b\xb9\x89\xee\x64\x0c\xf0\xf4\xf8\xc4\x1f\x09\x85\xa5\x70\xee\x99\x17\x47\xbf\x96\xe8\x86\x85\x7b\xa3\x9a\x7e\x12\x82\x2d\xec\xb9\xc2\xb8\x05\x96\xed\x96\xd8\x11\x2d\xed\x20\x3a\x80\x74\x18\x21\x40\xda\x65\x3a\x2e\x4e\x84\x5e\xaf\xf6\xc1\x50\x9d\x05\x1d\x90\xce\x1c\xeb\x64\x95\x15\xd2\xe1\x8c\x0d\x81\xed\x08\x88\x9d\xba\xb3\x49\xfb\x5c\xca\x70\x3c\x0c\x80\x6e\x36\x9f\x74\x09\x81\xa2\x83\xd8\xe7\xe5\xc8\xe7\xa5\x9e\xe1\x48\x26\x6c\x55\xda\xbd\xe1\x32\x6d\x1b\xa8\x93\xd5\x89\xc4\x92\xf0\xaa\xdf\xad\x7e\x16\x4d\xd4\x49\x77\x31\x8a\x5d\x47\x28\x76\x1a\x9f\xf8\x51\xa3\x13\x31\x27\xa2\x35\x15\x69\x1a\xc7\x71\x4a\x83\x01\x46\x6f\x33\x1a\xa7\x93\xfd\x9c\x75\xc7\xf7\xe4\x68\x9a\x43\xcd\x51\xdb\x8b\x33\xa6\x93\xe2\x5a\x24\xb7\x1d\xea\x35\xe7\x50\x48\x48\xac\x9d\xec\xe6\x6c\x68\x67\x37\xfa\xe5\xd5\xfb\x9b\x3a\x16\x1f\x03\x56\x6a\xc3\xe5\xb7\xce\x92\x66\x74\xd2\x5b\x28\x74\xa5\xba\x8f\x68\x72\x7b\x47\x65\x8a\x96\x2d\xaa\xd9\x88\x65\x4c\xcf\x51\x39\x97\x80\x81\xfe\x5c\xd8\x88\x38\x5b\x0a\x52\xf8\x86\xae\x55\xb7\xf1\xca\x86\x85\x16\x32\x17\x3a\x33\xa6\xcc\xe8\xe3\x55\xd7\x5e\x1b\x32\x93\x14\x95\x49\x2f\xb4\x4c\x47\xe5\xcb\x8f\xbd\x55\xbe\x82\x8e\xb4\xdb\xea\x61\x6d\x03\xf7\xf6\x98\xd5\x39\x16\x27\xab\x86\x6b\x91\xd5\x75\x34\xdf\xfe\xb2\xba\x42\xc2\xb5\x16\x45\x47\x5e\x12\x3b\xd9\x1a\x1f\xc9\x08\xc6\xc2\x10\xe1\xb5\x4e\x8f\xb4\x04\x57\xa5\xf3\x74\x78\x59\x59\xb5\x44\xc3\xb1\x61\x43\x16\x7d\x69\xce\x8c\xcd\x80\x83\x52\x27\xe8\x0e\x29\x0b\xab\xb5\xfa\xde\xba\x3d\xf3\x75\x90\xe3\xea\x7a\x75\x1a\x80\xeb\xec\x8b\x3f\x82\x4e\xac\xe5\x36\x20\xe4\xd8\x34\xcc\x2d\x7f\xd1\x8d\x92\x48\xaa\xa6\xb6\xeb\x2d\xdc\x33\xed\x3a\x37\x0f\x6d\xa5\xe0\xb0\xf9\xee\x44\xd2\x04\x48\x01\x92\x09\xc3\x8c\x4a\xae\x53\x71\xc7\xc9\x08\x26\x8c\x2b\x0f\x0a\x2c\xbe\xe9\x60\x86\xfe\x18\xa6\xaa\xb2\x69\x03\xf2\xa1\x51\x0d\xc4\xe5\xe9\x24\xa2\x3e\x9a\x6e\xcd\x8b\x9e\x24\xe4\x58\x08\x27\xdb\x43\xa6\x82\x70\xd8\x56\xe7\xb1\x25\x1f\x95\x1c\xdf\x9c\x42\x46\xe7\x36\x1c\x13\x3b\x62\xb3\x7f\x81\x54\xc7\x1d\x78\x9c\x6c\x63\x28\x7f\x6d\xed\x3a\xb0\xea\x29\x4d\xa6\xed\x5c\xb8\xd1\x45\xb5\xe1\x88\x2e\xaa\x36\x93\x44\x17\x55\x74\x51\x3d\x32\xa2\x8b\x2a\xba\xa8\x16\xc6\xde\x6a\x49\xd1\x45\xb5\xf3\x88\x2e\xaa\x87\x47\x74\x51\x6d\x30\xa2\x8b\x6a\xc3\x11\x5d\x54\xd1\x45\x15\x5d\x54\xd1\x45\xf5\x19\xd9\xed\xfc\x88\x2e\xaa\xa5\x49\xa2\x8b\x2a\xba\xa8\x36\x1e\x7b\xab\x7c\x45\x17\x95\x1d\xd1\x45\xd5\x1c\x9f\x17\xab\xf3\x0e\x9e\xa1\x51\xf5\xda\xb7\x1b\x46\x85\xd1\xd1\xd8\x17\x99\xf6\xd4\xc6\xfe\xff\x69\x6c\xff\x7b\xe2\x28\xe9\xc0\xde\x1f\x6d\xfd\x2f\xce\xd6\xdf\x8d\x9d\xac\x03\x1b\x59\x6b\x9a\xec\x5c\xe0\x37\x53\x09\x6a\x2a\xb2\x9d\x11\xbd\x81\xe4\xef\x18\x67\x79\x99\x1b\x9c\x53\x06\x9f\xd9\xac\xf2\xb5\xab\xba\x07\x33\xba\xe0\xad\xb9\xce\xdc\xc8\x52\xc0\xb2\x9b\x94\x65\x66\x1b\x31\x51\x72\x4a\x67\x06\xd7\x55\x99\x24\x00\xd8\xd4\x2b\x54\x25\xfe\x38\xa8\xde\x54\x35\x71\x78\xdd\x8e\xde\xb4\xe3\x96\xb6\x30\x26\xce\xf2\xc7\x3f\xec\x34\xc7\x44\x16\xdd\xd0\xe5\x6f\x3e\x0c\xcf\x02\xba\x4c\xb9\x27\xcb\x8c\xcf\x44\x36\xb3\x3d\x6e\xf1\x26\x23\x15\x0d\xea\xee\x98\x9c\xd0\xac\x98\xd2\x40\x8d\x70\x12\xb8\xb2\xed\x98\xcd\x93\xe6\xb9\xaa\x6e\xea\xd0\x86\x52\xec\xdc\x2a\xb6\x1e\x1d\x90\xfc\xf6\xda\x42\x2b\x4d\xa1\x0b\x8e\xd3\x56\x18\x6e\x4a\x32\x46\xe4\x6d\x1a\x7c\x26\x88\x19\xb6\x9a\xfb\xc6\x22\x6f\x6b\x5a\xd9\x5e\x0c\x6d\x7f\xb8\x08\x96\x5b\xc1\x0f\xef\x0c\xc0\x07\xae\x9f\xb8\x67\xe8\xa1\xbe\xe1\x3b\x1c\x69\x41\x8a\x8c\xd6\x3d\x8a\x70\x07\xbe\x45\x2e\x74\x36\x85\xe4\xf6\x83\x73\x7a\x1e\x29\x80\x2a\x62\x65\xc2\xf4\xb4\x1c\x0d\x12\x91\x9f\x18\xa2\x60\xff\x6f\x94\x89\xd1\x49\x4e\x95\x06\x79\x92\x8a\xc4\x31\xb9\x7e\x62\x66\x61\x7c\x32\xc8\xd3\x63\xec\x75\x7b\xd9\xec\x89\x18\x14\x43\x30\xef\x77\xea\x20\x19\x81\xa1\xaf\x02\x55\xfe\xa0\x9c\x9a\x59\xde\xd6\x5d\x6c\xc3\xd1\x9a\x29\xb5\x74\x38\x7f\x7a\x67\x73\xa4\x5c\xa4\x03\xdb\xc6\x73\x73\x2a\x77\x16\x5c\xd1\x81\x33\x79\x8f\x1c\xc9\x7b\x23\x1c\xef\x8b\xf3\x78\x0f\x2b\x1f\x77\xe0\xeb\xec\xc2\x59\xdc\x9d\xa3\xf8\x23\x14\x08\xfe\x38\x0e\xe2\x0e\xad\x68\x1d\x39\x86\x3f\x85\x53\xb8\x93\xaf\x6e\xeb\x0c\xfe\x74\x8e\xe0\x6e\x3e\xb7\x4b\x45\xe0\xb9\x3a\x7f\x3b\xb0\x86\x77\x69\x09\xef\xcc\x0a\xfe\xd1\x9c\xbd\xed\x1d\xbd\x7b\xe0\xe4\x6d\x0d\x64\xc6\x99\x66\x34\x3b\x87\x8c\xce\xaf\x21\x11\x3c\xdd\x99\xc3\x2c\x54\x8c\xac\xce\x8f\xb2\xd3\x3a\x4b\x55\x33\xa7\x61\x4a\x5d\x61\x6c\xa3\x51\xd9\x1c\x0e\xef\xa1\x70\x02\x05\x3a\x17\xec\x2a\x77\x29\x3b\x77\x27\xe4\x6d\x26\x68\xaa\x4e\x0a\x61\xff\xaf\xce\x58\x08\x52\x15\xec\xbb\xda\xe5\x2a\x3c\xb5\x49\xcc\x26\x78\x74\xb9\x89\xdf\x8a\x3b\x22\xc6\x1a\x38\x39\x62\xdc\xef\xe3\x71\xa0\x06\xd6\xf6\xc9\x0a\xad\xcd\xd5\xd7\xaf\xfc\xcd\x2f\xcf\xf0\x88\x26\x56\xa5\x3e\xbe\x1d\xd8\xbd\xe8\x71\x43\xb0\xbb\x71\x5c\x66\x4d\x63\xb0\x35\x10\x37\xe9\xcd\xeb\xba\xb4\xef\x6b\x9c\xb7\x3a\x6d\x94\xa7\xc4\x25\x7d\xbd\xbc\x4d\x6b\x1d\xc2\xd2\x14\xfd\xaa\x90\x95\xc7\xec\xc6\x37\x67\x43\x6b\x36\x8e\xe6\x92\x7d\x31\x97\x3c\x51\x18\xc8\x1e\x0a\xba\xcf\x34\xf4\x23\x0a\xba\x5b\x8c\x20\x0d\xf4\x1b\x49\x13\x18\x76\x2e\x23\xf8\xe3\x44\xd2\x52\x52\x47\x00\x2b\x91\xcf\x1f\x1e\x0e\x90\xda\xd3\x54\xa5\xce\x62\x52\xea\xb8\xcc\xb2\x39\x29\x0b\xc1\x9b\x89\xc6\xd6\xdb\xbe\x98\xb7\x8a\x26\xf9\x15\x6f\xa9\x05\xcb\x42\x0a\xc7\x33\x65\xc9\xb9\xa1\xc1\x75\x7f\x2e\x14\x24\xb1\xae\x31\x6d\x64\xc7\x2a\x36\x31\xcb\x37\xfc\x0f\x13\x67\xeb\x58\xbf\xc6\x84\xe6\xe9\xb1\x90\x09\x1b\x65\x73\x32\xa5\x59\xd5\x8c\x85\x92\x5b\x96\x65\x6e\x9a\x01\xb9\x06\x6d\x5d\x0a\x96\x77\x66\x82\x4f\x70\x71\x94\xfb\x26\x80\x90\x98\x67\x93\x0c\x28\x2f\x0b\xfb\x3e\xc3\x89\xe7\xa2\x94\xfe\x7d\x83\xca\x31\x51\x37\xdd\x67\x59\x2f\x68\x35\xf6\xe0\xc6\x56\xed\x69\x4a\x65\x04\x80\xf7\xbe\x8e\x73\x2f\x9c\x53\xcc\x40\x4a\x96\x3a\x3b\xbf\xfd\xad\x90\x62\xc6\x52\xeb\xdd\xf0\x60\xc3\xa6\xc6\xb6\x99\x4c\x75\x9e\xb9\xe0\x7d\x0e\x13\x8a\x82\x8a\x3b\x45\x76\xcf\xec\x3c\x36\x86\x80\xa7\xd8\x5e\xc6\x48\xf8\xa2\x68\x64\xae\xcf\x98\x6d\x8c\x1b\x40\x8e\x1c\x71\x41\x04\x86\x7e\x96\x9c\x69\xdb\x6c\x7d\x5a\x6a\x92\x8a\x3b\x7e\x1c\xf8\x5d\xc9\x08\xf4\xc3\x5e\x57\x74\xb4\xde\xac\x04\x50\xd3\xfd\xba\x4a\xce\xb1\xdf\xfb\x30\x78\x99\x72\xa6\xcf\x31\x29\xb9\x82\x96\xec\xbd\x33\xe1\xe8\xcf\x7f\xda\x8d\x46\xb0\x1c\x44\xa9\x3f\x89\xf6\x77\x37\x65\xc9\x34\x14\x66\x59\x0e\x8a\x88\x72\x41\x2d\x7e\xed\x1e\x5b\xbd\x43\x51\x05\x5c\x35\x76\x35\xec\xae\xb0\x7e\xb9\x7e\xa5\xcb\x11\x7c\x41\x3f\x66\x0c\xce\x3e\xbf\xba\xfe\xf5\xed\xe9\x7f\x5d\xbc\x75\xe7\x93\x87\x4c\xbf\xe4\xec\x9f\x25\x10\x9a\x0b\x23\x0b\x67\x61\x20\x60\x0f\x35\xfa\xe0\x07\x3c\xc9\xdd\x86\x0c\xee\xc8\x90\xb1\x79\x7c\xfb\xc0\x48\x6c\x41\xff\xf1\xe3\x22\x9f\xba\xa9\x56\x1d\xdc\x62\xe4\xc6\xa0\xa9\x16\x25\x1c\xb4\x39\x79\x56\xa2\xb4\x4d\xd6\x18\x9f\x64\xa1\x30\xb9\x1b\xb9\x6a\xab\x13\xb5\xd5\x88\xfa\xf5\x17\x0c\x77\x55\x8c\x3a\x69\xee\x55\xaf\xa1\xa3\x96\x38\x35\xd5\xf6\x6a\x80\xed\x59\xec\xd5\x00\x2b\x7a\x5c\x0e\x09\x4d\x53\x89\x62\x0a\x9e\xfa\x7c\xa1\x35\x66\x51\xc7\xd2\xf4\xc8\x2b\xf2\x37\x72\x4f\xfe\x86\x6a\xc1\x9f\xdb\x36\x10\x6a\x2b\xb0\x77\x11\x1a\x63\xb4\xd1\xcb\x61\x47\x10\xff\x71\x4a\x35\xce\x68\xa0\xaa\x05\x19\x31\x27\x86\xc2\xbd\x06\x69\xc4\x22\xb7\x13\x4f\xda\x7a\xc9\x2c\xf0\x13\xa2\x99\x35\x93\x5f\x8e\x9b\xe1\x38\xdb\x21\x9a\x79\xdc\xe8\xf7\x57\x8e\x0a\x35\x3b\x9d\xd4\xb3\xe5\x54\x27\xd3\x26\x19\x33\x02\x86\x6a\x30\xa7\x54\x20\x19\xb7\x81\xb7\x53\xd6\xc2\xe9\xbf\x3f\x68\xdc\xce\x0f\xdc\xd8\xcf\x87\x76\x6a\x41\xf1\x47\x3e\xef\x04\x83\xa0\x78\x52\x21\xd2\x01\xb9\xa0\xc9\x14\x97\x95\x06\x3c\xc3\x68\x20\x38\xd9\x94\xce\xcc\xc6\xbb\x67\x6d\x67\x20\x94\x56\x2a\xeb\x28\xe2\x92\x39\x4f\x09\xe5\xb6\x37\xe7\x18\xa4\xb4\xb1\xd2\xa3\xb9\x0f\x32\x6b\xbd\x79\xad\x4e\x52\x21\x85\x16\x89\x68\xd1\x1d\x6a\x31\xff\x02\xa7\x43\x20\xd8\xf8\x54\x6f\xde\xfd\xfe\x7c\xd8\x23\x37\x67\x43\x6c\xeb\x73\x7d\x76\x33\x6c\x4a\xd8\x07\x37\x67\xc3\x83\x27\x05\x05\xf1\x66\x36\x34\xa8\xee\x30\x49\xc3\x60\x92\x31\xa5\xfb\x39\x2d\xfa\xb7\x30\xdf\x91\xa7\x76\xc1\xd7\xfb\xd5\x0e\x77\xf2\x41\x16\xcc\x39\x2d\xb6\x9e\x4d\x02\x4d\x59\x4c\xf4\xd9\x7c\xc4\x44\x9f\x0d\x47\x4c\xf4\x89\x89\x3e\xcb\x63\x6f\x62\x19\x63\xa2\xcf\xcb\x72\xdd\xc6\x44\x9f\xcf\xde\xff\x1b\x13\x7d\x56\x8f\x98\xe8\x13\x13\x7d\x36\x1b\x31\xd1\x67\xfb\xb1\x77\x91\x2b\x31\xd1\x67\xab\x11\x13\x7d\x96\x47\x4c\xf4\x59\x33\x62\xa2\xcf\x9a\x11\x13\x7d\x62\xa2\x4f\x4c\xf4\x89\xf1\x8f\x8f\xce\xb5\x9f\xf1\x8f\x24\x26\xfa\xb8\x11\x13\x7d\x5e\x44\x94\x17\x89\x89\x3e\x1b\x8d\x98\xe8\x13\x13\x7d\x76\x19\x31\xd1\xe7\xa5\x98\x4b\x62\xa2\x4f\x4c\xf4\xf9\x7c\x04\xdd\x98\xe8\x13\x13\x7d\x62\xa2\x4f\x4c\xf4\x79\x70\x15\x31\xd1\xe7\x25\xa8\x80\xbe\xef\x6a\xfb\x2c\x95\x0f\x7e\xa6\xcd\x03\xfb\xc8\xc5\x8a\x5f\xd1\x12\xa2\x0a\x33\x89\xac\xa7\xcc\x24\xd0\x74\x8e\x53\x62\xaf\x87\x40\xc8\x7a\x86\xf1\x81\x19\xcb\xd9\x6e\x89\x41\x64\xe9\xd0\xbc\xc5\xb9\x02\xaf\x8b\x01\x4b\x4e\xef\xf1\x00\xd0\x5c\x94\xb6\xfd\x6b\x22\xf2\xa2\xd4\x4d\x98\xe2\xf6\xec\xd2\xb9\x75\xcc\x26\x8e\xa3\x9e\xd8\x26\xb3\xfd\x6a\xda\x7e\xd0\xd8\xf5\x09\xdb\xb5\xd2\xd4\xc7\xcd\x0d\xbb\x08\x1a\xa1\x5a\x83\xe4\x6f\xc8\x7f\x1f\xfd\xfc\xe5\x6f\xfd\xe3\xaf\x8e\x8e\x7e\x7a\xd5\xff\xeb\x2f\x5f\x1e\xfd\x3c\xc0\x7f\xfc\xfb\xf1\x57\xc7\xbf\xf9\x3f\xbe\x3c\x3e\x3e\x3a\xfa\xe9\xbb\x77\xdf\xdc\x0c\x2f\x7e\x61\xc7\xbf\xfd\xc4\xcb\xfc\xd6\xfe\xf5\xdb\xd1\x4f\x70\xf1\xcb\x86\x93\x1c\x1f\x7f\xf5\xc5\xce\x4b\x6e\x2d\xf0\x76\x27\xee\x76\x24\xec\x7e\x14\x51\xd7\xb9\x6b\x3b\x3a\x8b\x2e\xd4\x64\xe9\x34\x3a\x76\xf4\xd0\x69\xf4\x1a\x37\x0a\x71\xd5\x3c\x4c\x11\x91\x33\xad\x1d\x15\xa5\x61\xb8\x2a\xd3\x0d\x95\xd3\xd1\x01\x6c\x8a\x4d\xb5\x6d\x56\x5d\x85\x7a\x06\x21\x2a\xc2\xcb\x75\xae\x9b\x37\xcb\x8b\x0c\x9b\x44\xe3\x79\xee\xfb\x48\x15\x64\x9d\x91\x36\x3c\x3e\x22\x6d\x78\x89\xb4\x41\x41\x52\x4a\xa6\xe7\x67\x82\x6b\xb8\xdf\xc9\x7e\xb2\xce\x80\x74\xdd\x9c\xda\xc5\x86\x29\x17\xd3\x66\xaf\x11\x51\xd8\x08\xef\xb5\xb9\xd3\x53\x51\x66\x29\x66\x26\x95\x1c\x55\x4a\x9b\xe4\x06\xda\xea\x7b\xa8\xe9\x60\xf8\xf6\xe2\xeb\xbc\x06\x67\xa7\xfe\x67\xc9\x66\x34\x33\xfa\x6d\xfd\xc4\x10\x75\x96\xf0\xa1\x9d\x8c\x58\x4f\x2c\x63\xa1\x78\x33\x94\x6c\xc6\x32\x98\xc0\x85\x4a\x68\x86\x54\xa9\x1b\x4a\x7f\xba\x66\x76\xdc\x22\x29\x32\x45\xee\xa6\x80\x5d\xf8\xa9\x57\xcf\x31\x95\x6c\x42\x19\x27\xb9\x21\xaa\x85\x7f\x58\x59\x3d\xdf\x10\x6f\x23\xf5\x72\x5d\xeb\xf3\xa8\xbe\x8e\x84\xc8\x5c\x3e\x42\x36\xaf\xe7\x67\xd6\xf4\xc6\xc5\xaf\x1c\xee\x7e\x35\xb3\x29\x32\xce\xe8\xa4\x52\xe3\x15\xe8\x25\x4b\x5c\x3d\xf5\xda\x0f\xc0\x60\xff\x12\x08\xcd\xee\xe8\x5c\xd5\x46\x8d\x7a\x0e\xa6\xde\x90\xd7\xc7\x88\x78\x54\x91\x6a\x8e\x94\xfc\xe1\x18\x5d\x73\x67\xa7\xc3\x5f\xaf\xff\x7e\xfd\xeb\xe9\xf9\xbb\xcb\x2b\x72\x25\x34\x58\x96\x14\x34\x4a\x4b\x28\x37\x1a\x82\x5b\x25\xbe\x03\x35\x68\xa1\x06\x68\x57\x64\x8a\xdc\x31\x9e\x8a\x3b\xb5\xb3\xfd\xd4\xa2\x9f\x01\x1e\x50\xbe\xd3\x1c\x09\x2d\x28\xf6\x7f\x6b\xc1\x1f\x96\xa2\x3f\xc2\x49\x91\x03\xa7\xe9\x49\x2a\x45\x61\x81\xe0\x0d\x50\xa1\x92\x74\xbe\x60\x57\xf6\xf1\xa5\xb8\xbf\xe3\xe6\x84\x13\x49\xb9\xae\x2d\x31\xf5\x9e\xb9\xc6\x73\x83\xd6\xdb\xf1\xbc\xf3\x8d\x68\xda\x5d\xae\xd1\x69\x9a\x42\xda\x00\xff\x8b\x8b\xea\x3b\xf3\x1f\x37\xaf\xcb\x31\x90\xe1\xfb\xeb\xcb\xff\xbd\x80\xc7\xf3\xa2\x5d\x10\x53\x37\x29\xa0\x52\x14\x9d\xed\xee\x07\xc8\xc5\x2c\xee\xef\xbe\xec\x6f\xc5\x2d\xbb\x71\x9d\x7f\x28\x79\xc8\xd0\x78\x30\x3f\xc9\x45\x0a\x03\x32\xac\x6c\xf8\xcd\xab\x61\x99\x19\x09\xc4\xdc\xc2\x35\xa3\x59\x36\x0f\x85\x29\x2d\x6c\x8e\x60\xa3\x08\x41\x48\xc8\xc7\x34\x53\x4f\x4d\x8d\xdb\xf0\x46\x23\x47\xbc\x33\xda\x6c\x27\xdb\x51\xcd\x46\x52\xe0\x42\x3b\x61\xd8\xac\x12\x0b\x3b\x48\x91\x10\xab\x3a\x07\x81\x52\x0d\xfe\xa6\xac\x1f\xc1\xb3\x46\xa6\x3c\xb0\x87\xd5\xcc\xd6\x88\x5c\x2a\x50\xab\x59\x63\xad\x4c\x9b\xd9\x25\xd0\x54\xf0\x6c\x8e\x51\x91\x36\xce\x21\xa7\xea\x16\x52\xfb\x83\x13\xcd\x2a\x2f\x82\x99\xb1\x7a\xd5\x8d\x59\xb7\x77\x19\xa0\x48\x66\xa3\x2f\xd0\xd5\x60\x34\xfc\x27\xdd\xf5\x16\x87\xd0\x00\xe5\x3d\xcf\xe6\x1f\x84\xd0\x5f\x57\x49\xae\x9d\x60\xc0\x8f\x4e\x5a\x46\x80\x34\x23\xbd\x28\xbe\xb7\x8f\xbb\x81\x87\x2a\xcc\xaf\x3d\xaf\x77\xfc\xb9\x1f\x29\x59\xf2\x53\xf5\x8d\x14\xe5\xce\x4c\x6c\x49\xd8\xfc\xe6\xf2\x1c\x49\x51\xe9\xdc\x88\x5c\xcb\x79\x21\x98\xb5\x41\xad\x51\x0c\xbe\x77\x8e\xd0\xf0\x4c\xd4\x3e\x2b\xf2\x8e\xce\x09\xcd\x94\xf0\xb0\x64\x7c\x95\xbe\x48\x9c\x32\x6a\x2e\x8f\x84\x9e\x2e\x69\xa1\xe6\x40\x2d\x3f\xd7\x0b\xbc\x8a\x75\x75\x30\xc6\x97\x1e\xd7\xf4\x16\x14\x29\x24\x24\x90\x02\x4f\x9e\x7a\xdb\x9f\xda\x19\x87\xa8\x73\x25\xb8\x39\x98\x9d\x20\xcf\x65\xe5\x85\x75\x20\x0d\x51\x05\xfd\xb9\x4e\xfb\xa3\xe8\xd5\xc5\x63\x59\x2a\x90\xd6\x05\x2d\x4b\xb0\x3b\xf9\x5d\x39\x82\xcc\x40\xde\xa8\xa4\xae\x6b\xb6\x35\x3c\xb0\x9c\x4e\x80\x50\x5d\x61\x9a\x16\x04\xb8\x32\x14\xd3\x9a\x2f\x35\x49\x05\xd4\xb9\xf1\x54\x91\xef\x2f\xcf\xc9\x2b\x72\x64\xde\x75\x8c\xf8\x83\x4d\xb5\xb5\xb0\x01\x68\x8b\x3a\xea\xd8\x4f\x81\x4b\x42\xe4\x25\x42\x5a\x22\xd1\x23\x5c\x10\x55\x26\xd3\xb0\x93\xb7\x57\x9b\x5d\x90\x22\x3a\x46\xf6\x13\xd7\x9f\x96\x42\x7d\xaf\x40\x76\x46\xa0\xbe\xdf\x81\x40\x85\x62\x94\xc1\xb9\x26\xf4\x2c\x62\xe5\xa0\x69\x4a\x35\x75\x84\xab\xea\xac\xbe\xaf\x5b\xfa\x79\x93\x2f\x05\x6f\x19\x2f\xef\xad\x89\xb4\x3b\x53\xcb\xf5\x05\x4e\x8b\x38\x84\x50\xc7\x5d\xa7\x45\x91\xb1\xda\x81\x1c\x04\xa9\x5d\x36\x70\xa5\xb7\x46\x4c\x44\x3a\xe1\xfd\xd0\x46\x38\xa1\x3c\x15\xf9\xd2\xcb\xd0\xe9\x4d\x93\x69\xf8\x82\x88\x7d\xcd\xb1\x27\x46\xa1\x0c\x66\xd0\xa2\x88\xd6\x02\xe6\xbd\x35\xb3\x19\xe0\x78\x8c\xc0\xe9\x49\x46\x47\x90\x59\x18\x5b\x0c\x54\xcb\x18\xf8\xd4\x91\xa2\x52\x64\xdd\xa5\xb6\x7c\x10\x19\xd8\xd0\x2b\x0f\x08\x33\xfd\xb3\x80\x03\x4e\xd2\x15\x1c\x50\x1b\x6c\xc0\x01\xf5\xda\xe7\x00\x87\xb2\x05\xab\x27\x8b\x70\x30\x72\x43\x13\x0e\xc8\xbc\xf7\x1d\x0e\x0a\x92\x44\xe4\xc5\x50\x0a\xa3\x76\x76\xc6\x9b\xdc\xb4\xb5\x9f\xcf\x1a\x36\xd0\x6e\x1f\x6a\xc0\xce\xab\xd7\xbc\x99\xca\x20\xe8\x92\x6a\xcb\x24\x7c\xe4\xe5\xff\x0a\x78\x16\x92\x9e\x45\x46\xe6\x67\x69\x38\x02\xcd\x93\xee\xc2\x73\x66\x07\x5d\xe4\x2d\xb4\x30\x76\x76\xc2\x8d\x44\x42\x33\x2c\x92\xda\x0e\xe5\xc8\x22\xda\x2d\x4e\x1c\x84\xda\xa2\x8f\x12\x7f\xf3\xe1\x1f\x58\x2f\x13\x7f\x71\x26\x4c\x2e\x52\x08\xbc\xce\x36\x46\xf8\xc6\x86\x64\xe2\x7d\x3e\xca\xd7\xc8\x15\x2e\x0a\x04\xd2\xc6\xd3\x5a\xb8\xfa\x64\xef\xaa\xd2\xab\x66\x81\xc0\x53\xc6\x27\x68\x57\xeb\x11\x09\x99\x8d\x0f\x76\x44\xe0\xd6\x6a\x90\x87\x78\x24\xfc\xa4\xfe\x3c\xf8\x57\xa3\x2c\xc6\x04\x77\x33\xa3\xa5\xc8\x4b\x58\x63\x4b\x6e\x99\x22\x07\x6f\x3d\x00\x5a\xd4\xaa\xdc\x47\x0e\x73\x60\xbf\xb0\xda\x4d\x6b\xe9\xbc\x65\x3c\x75\xa1\xb4\x0d\x60\x79\x3d\xd7\xc9\xc1\x18\xa4\xcd\xd2\x90\xb6\xbc\x21\x3f\x73\x52\x01\x8b\xf4\x77\x46\x8f\x0f\x56\x64\xf6\x36\xba\xfe\xc3\x86\xd7\xea\x25\x8b\xd3\x7c\xcf\x71\xef\xcd\x7b\xfb\x46\x73\x5f\xbe\xcf\x7f\xcb\x93\x96\xd5\x71\xd4\xaf\x6b\x2d\xe6\x47\x3b\xad\x17\xe9\x13\x83\xd6\x9a\xf1\x89\x0a\x35\x99\x66\x45\xfc\xd5\xaa\x8c\xdf\xe1\xb1\x14\x36\x05\x73\x59\x85\x58\x48\x01\x78\x2e\x6a\x48\x66\xc4\x89\x67\xae\x84\x4c\x72\x45\xcf\xa4\x81\x84\x66\x34\xbb\x2e\x76\x2f\x20\x4a\x96\x8a\xd5\xbd\xbb\x3e\x6d\x4e\x8d\xcc\x7a\x0a\xd2\xf2\x7e\x73\x9d\xd0\x34\x67\x4a\xa1\x21\x0c\x46\x53\x21\x6e\xc9\xd1\x8a\x5a\x59\x41\x94\x95\x62\x13\x75\xe2\x70\xbe\x6f\x56\x7f\x4c\x18\xcf\xaa\x48\x26\xd4\x83\xb9\x56\xde\x90\x83\x2f\x49\xaa\x55\xe0\x1e\xba\x02\xcd\x2e\x58\x61\x79\x99\xb6\x24\xb3\xc1\x82\x27\x27\xd8\xcb\xdb\x73\xd5\xb2\x24\xca\x23\x5b\x74\xe5\x70\x7b\xb1\xea\xd9\x4a\x38\x5a\xe9\xf1\xc9\x81\xe4\x84\x8b\x04\x54\x77\xc5\x96\xbe\xad\xe7\x24\x29\xd8\x0c\x1b\xc0\xe8\x27\xba\x36\x1c\x0e\xed\xd2\x87\x98\xa8\xe9\x1e\x3d\x0c\x25\xea\x9b\x9a\xb8\x18\x7d\x24\x2b\xa6\xb4\x6f\x95\x74\x43\xd1\x90\x04\x7a\x11\x62\x2a\xb8\x90\x16\x45\x0d\x13\x15\x1c\x51\x1a\x49\x94\xf5\xe6\xe1\x9e\x38\x12\x1d\x2c\xf5\xac\xf6\x12\x87\x8e\x40\x4c\xf4\xb2\xb5\x1d\xea\x35\xdc\x31\x3d\xc5\x2a\xac\xd3\x05\xaf\x21\xae\x44\x82\x42\x07\x0c\x27\x20\xa5\x90\x2e\x20\xcb\xdb\xad\x71\x26\xa4\xe4\x18\xd1\x65\x90\x84\x9a\xbf\x0e\x55\xe8\xa8\xae\x6b\x9e\x63\x8c\xa1\xc1\x26\x18\x8f\x21\x41\x41\x2b\x04\xb0\xa5\xda\x47\x75\x59\x5a\x9f\xc2\xa1\x85\xaf\x99\x9e\xb3\x7b\xf3\x96\xf0\xa9\x85\xce\x2b\x5c\xf0\xfe\xea\xcb\xc7\x03\x42\x2e\x79\x15\x7f\xdb\x33\xbb\x18\xde\xe9\x43\xcf\xb4\xf9\xc4\xb0\xe0\x3e\x7e\x40\x68\x38\x33\xd2\xa1\x2c\x3b\xc0\xf8\x36\xe6\x70\x12\x9a\xc4\x3b\x25\x07\x68\x1a\x77\x93\x9a\xad\xf7\x32\x40\x1b\x53\xb9\xb9\xe5\x63\x99\xcb\x9f\x87\x03\x84\xb4\xa5\x73\xae\xd2\x41\xac\x82\xbe\xd9\x88\x55\xd0\x37\x1c\xb1\x0a\x7a\xac\x82\xbe\x3c\xf6\x26\x64\x30\x56\x41\x7f\x59\x75\x6d\x62\x15\xf4\xa7\x37\x32\xc7\x2a\xe8\xb1\x0a\xfa\x43\x23\x56\x41\x7f\x64\xc4\x2a\xe8\x3b\x8c\x17\x40\xb9\x62\x15\xf4\x1d\x46\xac\x82\xbe\x7a\xc4\x2a\xe8\xcb\x23\x56\x41\x5f\x3b\x62\x15\xf4\x9d\x47\xac\x82\x1e\xab\xa0\xc7\xe2\x90\xdb\xcd\xb5\x9f\xc5\x21\x49\xac\x82\xee\x46\xac\x82\xfe\x22\x4a\xe0\x91\x58\x05\x7d\xa3\x11\xab\xa0\xc7\x2a\xe8\xbb\x8c\x58\x05\xfd\xa5\x98\x4b\x62\x15\xf4\x58\x05\xfd\xf3\x11\x74\x63\x15\xf4\x58\x05\x3d\x56\x41\x8f\x55\xd0\x1f\x5c\x45\xac\x82\xfe\x12\x54\x40\xa5\x53\xb6\x53\x61\xc8\x4d\x6a\xd8\xb8\xd8\xe4\x20\x65\x7c\x54\x8e\xc7\x20\x91\x72\xe1\x9b\x97\xc2\xa7\xea\x72\x7d\x8b\x4e\x56\xd0\x3d\x2c\x87\xe3\xd2\x38\xd6\x3c\xee\x72\xd4\xb1\x80\x63\x1d\x40\x7c\xf1\xfe\xeb\x15\x05\x73\x76\x8e\x2b\xdc\x35\x74\x16\xd7\xfc\x9e\xef\xe6\x1f\x5f\x03\xf0\x55\x69\x45\x0e\xee\x49\x26\x94\x0b\x7c\x46\x60\x25\x53\xca\x39\x78\x7d\x8f\x69\xb4\xa3\x8c\x00\x38\x11\x05\x38\xef\x34\x25\x8a\xf1\x49\x06\x84\x6a\x4d\x93\xe9\xc0\xbc\x89\x7b\x60\xd7\x41\xca\xee\x17\xa5\x25\xd0\xdc\x87\x6b\xe7\x94\xd9\xa9\x08\x4d\xa4\x50\x8a\xe4\x65\xa6\x59\x51\x4d\x46\x14\x60\x9e\x85\x65\x54\x15\x30\x30\x2e\xae\x8e\x6c\xee\xd5\x6f\x73\xcb\x12\x61\xc5\x32\xd4\x36\x7b\x58\xe4\x39\x2f\xf4\x9c\x98\x4f\xce\x5c\xe1\x57\xa9\x34\x49\x32\x86\xdc\x1a\xdf\x68\x53\x6a\x71\xbe\x9e\xe7\xd5\xdc\xad\x54\xb9\xa5\xf2\x14\xc5\xd6\x42\x2b\x82\x81\xc0\xf5\x84\x6e\xaa\x94\x29\x27\xe6\xab\x1e\xa1\xbe\x9c\x96\x05\xb4\x5f\x29\x82\xda\x73\x16\x3b\xbb\xfb\x29\x98\x2e\x28\x23\x6a\x70\xd3\x1a\xb0\x6a\x44\xc7\xc8\x77\x8f\x9c\xbd\x46\x90\x7f\x2d\x50\x60\x9c\xde\xd2\x31\xc0\x0d\xe0\x30\x33\x38\x00\x09\x18\xfe\x4a\xd7\x60\xfd\x27\x47\x7a\x4d\xe5\x04\x74\x15\xcf\xb4\x6b\xb4\x78\x33\x2c\x24\x2c\xf8\x1b\x2a\x22\x35\xc8\x10\x3a\x43\x91\x62\xd2\x4f\x9d\x59\xb5\xaa\xa2\xb0\x5d\xa1\x2b\xa4\xb6\xea\x06\x2f\x18\xd9\x20\xcd\xea\xa5\xaa\xa0\x09\x28\x72\x74\x39\x3c\xeb\x91\xe1\xe5\xb9\x8b\xc4\x14\xe3\x55\x99\xcc\x8e\x86\x59\x0c\x5c\x57\xdb\xb8\xaa\xd1\x16\x4c\x1f\x64\x7f\xba\x77\x0f\x2b\xf9\xea\x67\xee\x02\x4c\x17\x29\x00\x8a\x5c\x55\x7d\x73\xa2\x4a\x14\x91\x9c\x4d\x88\x55\xa9\x19\x0e\xf9\xa0\x4e\x48\xf4\x95\x87\xfc\x13\xd5\x42\x1c\x94\x5c\xde\x85\xf7\x75\x23\x81\x45\x7e\xbd\x94\xdc\x81\xc1\xa0\x2e\xee\x65\xa7\x78\x97\x56\x1a\x52\x20\x8a\xbd\x03\xa5\xe8\x04\x86\x3b\xba\xb7\xd6\xd9\x01\xd0\xc3\x55\x93\x03\x24\x40\x99\x4d\xf5\xad\x7e\xa9\xa3\x82\x9b\xc2\x37\xc9\xed\x9a\x2a\xcc\xba\x93\x4c\x6b\x40\x52\x82\xe5\xfe\x70\xb3\x17\xab\x01\x1c\x2e\xc4\x16\xbf\xf3\x93\xd4\x0f\x1b\x51\x82\xa7\x36\xd2\x77\x04\x64\x24\x19\x8c\xc9\x98\x61\xf8\x30\x06\xf4\xf6\x6c\xf5\x27\x6a\x6d\x4f\x4a\x81\xc4\xf5\x38\x0d\xca\xaf\x6b\x40\x7e\x74\x0b\xd3\xb2\xe4\xb6\xed\x88\x13\xee\x31\xdd\x95\x8d\xc9\x04\x03\x82\x9d\x8e\xf2\xa7\x57\x7f\xfd\x33\x19\xcd\x8d\x20\x85\x08\xa9\x85\xa6\x59\xf5\x91\x19\xf0\x89\x81\x95\x65\x0a\xcd\x84\xcd\x0a\x02\xd8\x18\xc4\x2e\xfc\xf5\x1f\x6e\x47\x4d\xc9\xee\x24\x85\xd9\x49\x00\xbf\x7e\x26\x26\x03\x72\x56\xe5\x47\x96\x45\x8a\x76\xfe\xdd\x8b\x75\x77\x87\x66\x22\x63\xc9\xbc\x35\xa2\xf9\x32\x64\x64\x2a\xee\xac\x86\xb9\x02\x7b\xea\xdc\xaf\x42\x14\x65\x66\x5d\x1d\x5f\x57\xa9\xce\xa5\x82\xe5\x84\xc4\x95\xe7\x02\x8d\xf3\x6e\x8a\x05\x3a\xea\xe2\xc0\xfd\x2b\x85\x4b\x74\x71\xe6\xe3\xaa\x1a\x19\x12\x93\xaf\x69\x96\x8d\x68\x72\x7b\x23\xde\x8a\x89\x7a\xcf\x2f\xa4\x14\xb2\xb9\x96\x8c\x1a\x1e\x3d\x2d\xf9\xad\x6d\x06\x51\xd5\x6b\x10\x13\x23\xd0\x17\xa5\xf6\xe5\xbd\x57\x7d\xb0\x4d\xde\xf7\xac\xdf\x2b\xdf\xf5\x2c\x70\xcf\x6a\x0d\xdb\xe5\x8d\x59\x8c\x0c\xe7\x57\x21\xb2\xfd\xe1\xd5\x9f\xfe\x62\x51\x97\x08\x49\xfe\xf2\x0a\x73\x05\x54\xcf\x1e\x62\xe4\xa8\x46\x3c\xc9\x69\x96\x19\x42\x1e\x22\xa5\x01\xf4\x2a\x24\xfc\xe4\x38\xa8\xdb\xa3\xdb\xc6\x02\xfc\xcd\xcd\xdf\x91\x8b\x30\xad\x20\x1b\xf7\x6c\x8a\x54\xa5\x4c\x1f\xa2\x38\x72\xe8\xa8\x0f\xe6\xa9\xed\x81\xd8\x3d\x13\x59\x99\xc3\x39\xcc\x58\x17\xdd\x9e\x1a\xb3\x79\x03\x53\xc6\x14\xf2\xc1\x51\x26\x92\x5b\x92\xba\x8b\x41\xbc\xd3\x62\x59\xf2\xdd\xa1\xb0\x6b\xe4\x57\x8b\x88\xaf\xb5\xdf\xdf\x88\xf5\xca\x69\x51\x18\x19\x00\x33\x31\x25\xbd\x6b\x00\x03\xcf\x24\xd6\x4e\x68\x59\xdc\xa6\xb5\x73\xa3\xad\x6b\xa3\xef\xbe\xc8\xd0\xcd\x9d\xa7\xd8\x39\xd6\xa9\xbd\x67\xa4\x5e\xfd\xee\xe6\xf0\x06\x42\xd4\x13\xfa\xd3\x50\xe0\xbf\x6d\x36\xd3\x92\x60\x5e\x95\xd5\xac\x10\xc3\x0a\x00\x06\x7d\x90\x24\xef\x6e\xe6\xef\xc0\xa6\xde\x2e\xd0\xad\x01\x17\x5e\xf9\x32\x72\xaa\x9d\x40\xe8\x75\x15\x4a\x0a\x90\x8a\x29\xc3\x97\x7f\xc0\x03\x75\x96\x51\x96\x07\x86\xe7\xa7\x01\x82\x3d\xdc\x58\xcb\xb9\x3d\xa5\x34\x7a\x8a\x9d\x10\x49\xa1\xad\x63\xbd\x42\xac\x6d\x4a\xb5\xd7\xe5\x08\xf1\x07\x6f\xdf\xa6\xa5\x5e\x87\x9c\xf8\xa9\x69\xec\x0f\xf5\x36\x34\x49\xac\xf9\xa5\xa2\xb1\xf6\xae\x97\x44\x59\xf1\xfb\x9e\x2b\x61\xad\x16\xdf\x11\xfd\x40\x8a\xea\x36\xb7\x49\x42\x1b\x5a\xa7\x3d\x61\x81\x2e\xe0\x14\xc8\x01\xb1\x41\x1b\xe6\x4c\xb8\x47\xc9\xe1\x9b\xc3\x27\xa5\xae\x16\x44\x52\x14\x74\xd2\xaa\x23\xd1\x02\xa4\x16\xa7\x0d\xcb\x65\x18\xfd\x29\x20\x25\x85\xbb\xcb\x50\x12\x5f\x0d\x08\x6b\x3d\x59\x67\xbe\x07\xb0\xd3\x2c\xb0\x63\x1c\xb9\xa3\x73\x42\xa5\x28\x79\xea\xcc\xa1\x95\x3d\xfa\xdd\xc2\x8b\xaf\x04\x07\xef\xe7\x59\xac\xb6\x81\x0e\x28\xc6\xc9\xeb\xc1\xeb\x57\x2f\x85\xc5\xe1\x17\x2e\xb0\xb8\xab\x8a\xc5\x59\xfa\xf4\xa4\xdf\xea\xeb\xf6\x77\xf4\xbd\xef\x9c\x6d\xa6\x2e\xcb\xcf\x7c\xd1\x6f\xfc\xe9\x4e\x32\x0d\x41\x9f\xc1\x23\xd4\x78\x8c\x62\x19\xd4\x96\x38\x5e\xd5\x0f\xa3\x25\x90\xda\x15\xf3\x50\xe5\xe8\x23\xd2\x2d\x47\xa0\xf0\xb8\xad\x32\x8d\xa9\x07\x48\x58\x08\xa8\x83\x03\x72\x64\xef\x3c\xb4\x19\xf8\xc7\x4f\x8a\x5a\x0e\x68\x17\xf7\x45\x8b\x4a\xa1\x0b\xc5\x1e\x0a\x8a\xc6\xbb\xa2\x43\x08\xfe\x17\x4c\xe9\x0c\xb0\xf2\x00\xcb\xa8\xcc\xd0\x45\x7e\x6d\xd7\x4e\x46\xa5\x26\xc0\x67\x4c\x0a\x8e\x76\xe2\x19\x95\x0c\x6b\xfb\x48\x18\x83\x04\x6e\x94\xd8\x2f\x8e\x7e\x38\xfd\x80\xf1\x37\xc7\xb6\xef\x8b\x5f\x65\xa9\x7c\x11\x9e\x70\x25\xc1\x74\x8f\x6e\x9f\x5f\x87\x81\x21\xd2\x5c\xbf\x2e\xf3\x9e\xbc\xd4\xa5\x6d\x2e\x73\x9f\x64\xa5\x62\xb3\xa7\xa2\x24\xae\x24\xc4\x39\xdb\x69\x9f\x17\xca\x53\xd4\x80\x5a\xaa\x34\x51\xbb\x09\x1e\x29\xc4\x7d\xa8\xaa\x1c\xd3\x30\x64\xc3\xd9\xac\x48\xce\x26\x53\xed\xa2\x3d\x17\x3c\x07\x81\x0b\x2a\x47\x33\xef\x53\x5a\xaf\x0c\xdb\x3d\xcd\x18\x55\xdb\x8a\x5c\x4b\x89\x8c\x6e\x16\x97\x60\x2f\x7c\x6c\x91\x37\xca\x98\x17\x59\x4b\xe5\xe5\xd0\x79\xd0\x3c\xdc\x18\xff\x1f\x1b\x58\x53\xa9\x25\x36\x50\xc6\x3e\x62\xcd\x8d\x63\x12\x94\x05\xf2\x01\x25\x48\xfc\xb1\x16\x15\x6a\x24\x5c\xf0\xfe\x34\x28\xdb\x54\x88\x74\xcb\x24\xbf\x5d\x15\x8f\x9d\x54\x8e\xd5\x10\x24\x53\x91\xa5\xbe\x8b\xb6\xb5\xe5\x8c\x40\xdf\x01\x70\x72\x39\x44\xf8\x99\x4f\x44\x8f\xd0\x1a\x28\x5a\xb7\x02\x16\x68\x0a\x54\xd9\x06\x3c\xb7\x45\xb0\x16\x5a\x49\x1b\x91\xbe\xfa\xd2\xd6\x67\xfe\xdb\x0a\x66\x3e\x22\x9b\x8e\xc4\x0c\x10\xa4\x69\x2a\x41\xb5\x28\x70\xf4\x04\x7a\x6a\x2b\x52\xca\x76\x6a\xf0\xd3\x74\x8c\x54\x60\xf3\xa6\x25\x14\xdf\xf1\xa8\x22\xe2\x7d\x62\x0a\x76\x39\x3c\x6b\x41\xbd\x0e\xbf\x77\x7e\x11\x33\xd5\xe1\xa1\x22\xac\x48\x6a\x9f\xeb\x80\xd4\xee\xc6\x20\x51\xc2\x4a\x8c\xdb\xf9\xba\x76\x15\x13\x03\xa2\xd6\x92\x48\x13\x6e\xa7\x31\x64\xc5\x25\x49\x3b\x73\x0e\x3a\x1d\x0a\x91\x62\x07\xa6\x1a\x1a\xca\x3f\x11\x02\xc4\x07\x4b\x58\x22\xef\x42\x47\x7a\x55\x10\xf2\x02\x61\x42\xd3\xbb\x0f\x3f\x0c\xa8\xf8\x12\x30\x3f\x19\x2c\x87\x97\xe7\x5d\xa2\x4b\xc1\xd2\xbd\x43\x97\xed\xf5\xcb\x66\x4a\x5c\xb3\x92\x84\x9b\xd0\x1f\xf6\xa1\x48\xd7\x88\x49\x35\xa3\xc1\xfb\xc3\x5e\xc0\x5a\x10\x4a\xac\x7d\x71\xa1\xcb\xfb\x0e\x40\xd9\x9a\x4a\xa0\xa8\x35\x2c\xb3\xec\x1a\x12\x09\xdb\xda\x55\x9b\xfb\x7f\xb9\x30\xd7\x3a\x91\x27\x90\xdf\xb1\x3c\x81\xbb\x99\xd7\x65\x30\x83\xc0\x8e\x3a\xf9\xb0\x28\x33\x8c\x85\xa5\x7c\xee\x01\x8e\xab\x57\x81\x13\x8b\x29\x1f\x56\x63\xc3\xb8\x1a\xbb\xa0\xa0\x7a\x59\xd5\x55\x8a\x2a\x65\x5d\xad\x8c\xa7\x6c\xc6\xd2\x92\x66\xf8\x22\x94\x42\xc3\x0e\xfc\x15\x87\xcc\x7d\x59\x57\xf2\xb5\x90\x04\xee\xa9\xb9\xad\x57\x09\xb1\x54\x21\x3a\xa4\x22\xb9\x05\xd9\xb3\xa2\xd8\x39\xfe\x71\x86\x12\xaf\xad\x7b\xee\xd7\x61\x74\x09\x57\xcc\x74\x97\xa6\xfe\xbe\x6b\xbf\x85\xc3\xef\xed\xe7\xce\x19\x9f\xf4\xf1\x17\xf3\x21\xee\x4d\x7d\xc1\xfb\xb4\x6f\xd0\xf0\x99\x08\x7e\x58\xe8\xfc\x3d\x4a\x56\x1f\x3c\xbe\x78\x15\xc1\x28\x72\xa2\x9c\x4c\x11\x58\x32\xa7\xbe\xe6\x60\x06\x1a\xcb\xc9\x39\x87\xb0\x8d\x02\x72\xcf\xa6\x4e\x4c\x0b\xcb\xeb\x35\x71\xed\x99\x08\x7f\xbb\x5a\xc8\x16\xa2\x99\x03\xb2\xe5\x60\xa4\xb7\xc6\x40\x31\x03\x39\x63\x70\x77\xe2\x58\x67\xff\x8e\xe9\x69\xdf\x42\x44\x9d\x20\x60\x4f\x7e\x6f\xc5\xcb\x9b\xf7\xe7\xef\xb1\x37\xb3\x33\x5b\x96\x0a\xc6\x65\xe6\xba\xdb\x0f\x08\x2d\xd8\x0f\x20\x15\x56\x9f\xbd\x65\x3c\xed\x91\x92\xa5\x5f\x7d\xc2\x88\x19\xc6\x59\x1d\x06\xd8\x8a\x0a\xbe\x75\x54\xce\xa5\x21\xb3\x7f\xd5\x0d\xe8\x5d\x54\xd1\x08\x32\xc1\x27\x41\x12\x35\x8a\x17\x97\x9c\xe9\xa5\x36\xb6\xb6\x24\x24\xaa\xc8\x42\xa6\x18\x6c\xc9\x84\x6c\xd8\x83\xcd\x7c\x58\x28\x2f\x08\xd9\x34\x24\x92\x35\xe6\xc3\x38\x18\x55\x31\x23\x62\x23\x29\x7c\xbe\xa5\xaf\x23\xec\x0b\xf0\xd9\x7a\x90\x53\xca\x53\xfc\x33\x49\x84\x4c\xdd\x7a\x99\xae\xe2\x43\x6d\x34\x91\x0d\x61\x41\xb6\x66\x28\x24\xe5\x8b\x6f\x46\x0d\x54\xe6\x8d\x58\x42\x2f\xf6\x94\x9c\xfd\xb3\x04\x42\x73\x61\x08\xfb\x62\xb5\xfc\x05\x88\xe4\x74\x8e\xbc\x15\x97\xfa\xd6\xc7\xbb\xbb\x24\x45\xd5\x23\x1f\x80\xa6\x2c\xc8\xb3\xee\x91\xb7\xcd\xc4\xeb\x9e\x59\xcb\xb5\xcd\x08\x75\x3f\xd9\xd5\x4b\x50\xa2\x94\x09\x7c\xb0\x4e\xa2\xdc\x07\x24\x2d\x7f\x8c\xd9\x15\x4d\x6f\x81\x5b\xa5\xdc\x80\x06\xfd\x60\xa5\xc4\x3d\x48\xa6\x90\x96\xc8\xa5\x46\x73\x32\x66\xb6\x85\x06\x8a\x0a\x6c\x32\x05\xa5\xbd\x70\x79\x82\x41\x3e\x75\x37\x32\xbf\x00\x44\xdf\x20\x1a\xb8\x36\x63\xe5\x14\x0b\x3c\xe3\x91\xa5\xda\x27\xbc\x58\x9d\x4d\x95\xb9\x3f\xcb\x8b\x90\x56\x03\xf2\xd6\xbc\xca\xe2\x53\xd0\x9a\x80\x2d\x00\x17\x9d\x74\xce\x0e\x47\xc6\x54\x4d\xb1\x71\xc7\xe2\x16\xb8\xaa\xff\x49\x29\x0d\xc1\xb0\xc5\xb8\x29\x36\x5c\xc7\xe6\xbc\xd8\x9b\x7b\x95\xe1\xa6\x65\x82\x83\x59\x6c\x3f\xe0\x77\xcf\x85\x89\xfd\x7f\xec\xfd\x0d\x77\xdb\x36\xd6\x2f\x8a\x7f\x15\x2c\xcf\xac\xbf\xad\x56\x52\x92\xce\xcb\xd3\xc9\xe9\x7f\xba\x5c\xdb\x69\x7d\x9a\x38\x7e\x6c\xa7\xbd\x73\x9b\x3e\x33\x10\x09\x49\x18\x93\x00\x0b\x80\x72\x34\x27\xe7\xbb\xdf\x85\xbd\x01\x10\xa4\x64\xc7\x26\x99\x48\x4e\xc5\x59\x6b\x1a\x4b\x14\x08\x02\x1b\xfb\x7d\xff\xf6\x61\x48\x58\xb7\x0b\x9f\x34\x38\x01\xee\xa4\x15\x58\x1e\xb2\x4a\x95\xa2\x8a\x98\x5a\xae\xf0\xe9\x44\x52\xfb\xf8\x68\xab\xb8\x66\x17\x09\x48\xd5\xac\xbb\xe7\x63\xff\x50\xcd\x4a\x3c\xe8\x8e\x0b\x57\xd0\xdd\xae\x6b\x35\x68\x6d\xa8\x63\x5a\x73\xe6\xe8\xd5\x71\x5c\x26\x15\xd7\x7f\xf8\x22\xb3\x31\xf9\xa9\xab\x93\xba\xe9\xa5\xb6\xdc\xbc\x72\x7d\x57\x5d\x37\x2c\xc7\xc8\x16\xde\xbe\x08\x4f\xf3\x7a\x28\x17\x45\x69\x9c\x18\xac\x2c\x4e\x91\xcc\xa9\x98\x81\x91\x29\x4b\x3b\xde\x1f\xff\x08\x33\x52\x2c\x2d\x13\xd7\xb2\xc4\x93\xec\x1f\xbd\xcb\xd6\xc1\x84\x01\xaf\xd2\x09\x2d\xfc\x9c\xe3\xd7\xd2\x4b\x61\xe8\xbb\xe7\x84\x8f\xd9\x98\xec\xfd\x31\xfa\x6a\x0f\x9f\x5e\x28\x69\x1f\xe1\xca\x33\x60\x56\x19\x37\x90\x26\xb1\x17\xdf\x3d\x26\x27\xf6\x19\x10\xc6\x0a\x0b\x18\x55\x10\x4c\xaa\xe5\x1b\x12\xc5\x66\x54\xa5\x99\x73\xb7\xdc\x44\x65\x27\x61\xc1\xd8\x3b\xae\x8d\x46\x19\x64\x3a\x70\x26\x43\xf5\xb5\xe5\x43\xf6\x64\x8d\x52\x6a\xe8\x28\x3a\xd2\x4f\xd0\x6e\x1b\x39\x2c\xe5\x11\x75\xa4\x55\xb1\xac\x27\x7f\x70\xd5\x9b\x23\x1a\xee\xe2\x56\x23\x07\x54\xe3\xf6\x7a\xce\x63\xf3\xb1\x75\x80\xd4\xae\x9f\xde\x93\x0a\x67\x1f\xd6\x00\xba\xd4\x54\xfa\x52\x60\xa2\x0e\x35\x7a\xdd\x79\x3e\x39\xbb\xba\xf8\xc7\xf9\xeb\xd3\xb3\xab\xdd\xb1\xde\x1d\xeb\xdd\xb1\xee\x70\xac\x99\x58\x74\x3e\xd2\xde\x6e\x5a\x17\xf2\x6d\xe2\x58\x46\xd5\x4b\x9f\x51\x62\xdd\x89\x58\xfc\x44\xad\x1a\x5d\x28\xa6\x41\x33\x81\x78\xd5\x9a\x08\xb8\xbb\x01\x95\xf6\xa3\x47\x9f\x59\xb7\xc1\xbc\xb8\x1e\xf3\x8d\x62\x97\xca\xba\x5d\x8b\x1b\x2c\x1e\xfd\xf3\xf4\xf8\xe4\xec\xea\xf4\xc5\xe9\xc9\xc5\x46\x13\x45\x3a\xe2\x48\xd6\x85\x72\x4b\x29\x59\x28\xb6\xe0\xb2\xd4\xd9\x32\x40\x51\xaf\x67\x02\xab\xb9\x86\x22\x05\x5f\x87\x47\xdb\x5e\xfb\xb3\x9d\xb0\xed\x57\xd8\xd6\xf3\x66\x3a\x40\x08\xf5\x45\xbe\x2f\x94\xcc\x7b\x22\xe1\x4b\xf4\xc2\xf8\x60\xf8\x3a\x7a\xda\x77\x68\x23\x35\xd1\xe3\x94\xc7\x0a\xda\xc4\x2a\xa3\x79\x61\x3a\x74\x1a\xe9\x05\x39\xb8\x1f\x90\x5d\xcc\xd5\x79\x45\x8b\x1f\xd9\xf2\x82\x75\x44\x2a\xaa\xaf\x37\xcb\x58\x62\x05\x1d\xb9\x66\x4b\x4c\xcc\x3c\xf2\x0f\xeb\x82\xa8\xb4\x95\xc0\xcb\xd7\xac\x0b\x28\x76\x9f\x88\xc9\xd7\xac\x43\xd2\xa9\xbf\x56\xb0\x83\xed\x16\x82\x9e\x66\xf7\xb4\xdb\xee\x91\x7e\xd1\x92\x3f\x02\x42\xf4\xe7\x1b\x41\xa9\x5f\x3d\xee\x82\x0f\x04\xf7\xbc\x13\x18\x93\x5f\xd6\x64\x57\x60\x22\x04\xcb\x41\x81\x36\x7d\xd0\xc1\x29\x19\x3d\x2d\x4d\xd7\x56\x85\x04\xb7\xb0\x5f\xbe\xba\x5f\x31\x56\xcc\xf1\x0f\x58\x78\xe9\x73\x0f\x9f\xa0\x43\x7f\x41\xe8\xd8\x3b\xac\xff\x09\x21\xd1\x21\xf9\x57\xf8\x30\xa3\x13\x96\xe9\x5f\xf6\xf7\xbf\xf9\xf1\xe4\x1f\x7f\xdf\xdf\xff\xf5\x5f\xf1\xb7\x20\x0a\x31\x50\x5e\xbf\x05\xb0\x20\x84\x4c\xd9\x19\x3c\x03\xfe\x74\xea\xda\x21\x06\x4f\xdc\x17\x50\xca\x3d\xc6\xac\xa5\xf0\x67\x21\xd3\xe6\x5f\xba\x13\x68\xe1\x56\x0a\x06\xd8\xa2\x0e\x95\x45\x78\xf5\x27\x1e\x2a\x5e\xd2\xf3\x51\x75\xa3\x86\x26\x39\xc9\x9c\xe5\x08\x9b\xf6\xc2\x2f\x01\xf4\x40\xf6\x98\x11\x02\x0a\xed\xad\x66\x5a\x47\xb0\xdc\x5b\x3c\xeb\xd4\x2c\x1e\xaf\x1e\x59\x5b\xd8\xc1\x9e\x17\x0c\x56\xc4\xad\x16\x1e\xe4\x20\x60\x43\xc2\x4c\xe8\xd1\x79\x78\x7e\x4a\x16\xb8\xc2\x5b\xb3\x38\x3e\xb0\xf9\xe2\xa3\xf2\xb8\x10\x3e\x6d\x16\xf4\x3e\xc7\x04\x1c\xff\xbd\x03\x57\xd0\x01\x65\x8f\x59\xc3\xe6\x00\x3f\x1c\x27\x45\x39\x74\x37\x8c\x73\x96\x4b\xb5\x0c\x7f\x86\xa2\xce\x91\x36\x52\xd1\x19\xd4\xd4\xe0\xcf\xf1\x67\xe1\x2f\xfc\x61\xed\x01\xab\xbf\x46\x53\xb8\x8a\xa2\x3a\x8e\xdc\x12\x24\xa4\xba\xb6\x90\xb7\xf9\xa5\xdf\x12\xd6\x96\x74\x85\x7a\xaa\x5f\x75\x82\x0c\x9e\x38\x54\x38\xc3\x2a\x82\x3d\xe9\x8a\x8d\x87\x55\x3e\x1c\x78\x03\xc4\xc2\x5a\x96\xad\x41\xfa\xaa\xab\x47\x6e\x96\xf2\x05\xd7\xb2\x43\xe5\x50\x18\xe8\xf6\xdc\x49\x87\x77\x82\xf9\x5b\xc1\x6d\xf6\xae\x00\x5c\xb2\x70\x5e\x1b\x6c\xff\x59\x97\xd6\x64\x78\x15\xd4\x18\xa6\xc4\x73\xf2\x3f\x07\x6f\xbf\x7c\x3f\x1a\x7c\x7b\x70\xf0\xcb\xd3\xd1\xdf\x7e\xfd\xf2\xe0\xed\x18\xfe\xf1\xc5\xe0\xdb\xc1\x7b\xff\xc7\x97\x83\xc1\xc1\xc1\x2f\x3f\xbe\xfa\xfe\xea\xfc\xe4\x57\x3e\x78\xff\x8b\x28\xf3\x6b\xfc\xeb\xfd\xc1\x2f\xec\xe4\xd7\x7b\x0e\x32\x18\x7c\xfb\xc7\xce\x53\xef\x01\x26\x18\xaf\x3e\xc1\x82\xeb\x23\xf6\x42\x7e\x1f\xb1\x43\x06\x5e\x9e\xbc\xfa\x3e\xff\x17\x9e\x6b\x46\xf9\x3c\x5e\x5c\x6f\xcd\x01\xc7\x84\xd0\x4f\xe1\xc9\xc1\x27\xd5\x6b\x6d\x82\x69\xf1\xb9\xc9\xb9\xdf\x83\x73\x27\xf4\xb6\x84\x7d\xad\x34\xd1\xa9\x92\xb9\xaf\xe8\x87\xf0\x06\xd6\x9e\xb9\xfb\xae\x59\xa7\x7e\xcb\x78\xed\x9c\x41\x3b\x67\xd0\x2d\xd7\x07\x9d\x41\x58\x8e\xb0\xbd\x9e\x20\x26\x16\x6d\x43\x18\x6b\x23\xe8\xde\xd6\x89\x71\xf3\xee\x17\x50\x1b\xfb\xa3\x5e\x35\x85\xad\x32\x69\x50\xa0\xe5\xeb\x63\x98\xe4\x10\xda\xbf\xe3\xc1\x87\x01\x02\x2e\x29\x43\xd3\xc6\xd7\x5f\x2e\xec\x14\x02\x1a\x7d\x0d\x77\x16\xb2\x8a\xb9\x98\x39\x24\x0b\x14\x25\x2e\xfa\xc4\x45\x85\xd8\x1b\x94\xc3\x0a\xe6\x9d\x6a\x2d\x13\xe8\xa7\x84\x00\x7b\x01\xce\xcf\x4d\x1b\x66\x63\xe8\x35\x44\x1b\x13\x96\x32\x91\x30\x07\x01\x5f\x6b\x80\x4b\x05\x39\x11\x0b\x0f\x83\x9f\x96\x98\x0c\x82\xec\x6f\xfd\x18\x9f\x57\x02\x82\x25\x44\x17\x04\x8b\xf2\x10\x80\xeb\x07\x0b\x9b\x42\x2a\x86\x9c\x56\x5e\xd6\x76\x3d\x32\x3b\x4b\xf1\xee\x32\x33\x44\xb6\x3a\x29\x43\x2b\xc2\xb2\x72\x3f\xd7\x85\xe4\xe7\x10\x0c\xec\x2e\x3e\x7f\x77\xa2\xb3\x27\xb1\xd9\x8f\xc8\x7c\x40\xec\xa4\x4f\x31\xd9\x47\xb0\xa4\x50\x6c\xca\xdf\xf5\x74\x4e\x0f\xa3\xca\x44\x9e\x32\x61\xf8\x94\x63\x1b\xe0\x42\xb1\x82\x09\x70\xb5\x42\x71\x86\xe5\xfd\x4e\x52\x56\xc1\xe9\x6d\x4c\xe6\x41\x85\xbb\x5f\x56\x76\xb9\x4e\xd9\xdf\xf1\x31\xb2\xe3\x63\xad\xaf\x4f\xc4\xc7\x1c\xe5\x6e\x0f\x13\x83\xcc\xf3\xee\xa9\xef\xc7\x51\x1e\x3b\x50\x71\xf7\xca\xe1\x06\x1a\x5c\xe0\x8b\x46\x62\xe6\x1a\x96\xaf\x29\x92\xb1\x05\xcb\x9c\xd2\x44\x72\x2a\xe8\x0c\x21\xfc\x8d\x0c\xa0\x3f\x52\x85\x36\x4c\x4d\x44\x1f\x50\xe2\x7d\x65\x17\x7c\xa9\x64\x96\x31\xa5\x49\xc6\xaf\x19\x39\x66\x45\x26\x97\xb9\x4b\x7c\x4d\xc9\xa5\xa1\xc6\x92\xf4\x25\x33\xed\x62\xbe\xdd\xd0\x40\x7c\x31\x7b\x4f\x98\xe9\x58\x1d\x0f\xb5\xe5\xa4\x70\x85\x93\xaf\x05\x70\x8c\x43\xe8\x08\x33\x24\x67\x6c\xc1\xd4\x90\x9c\x4e\xcf\xa4\x39\x47\xd5\xbb\x9e\x6d\x87\x37\x12\x3e\x25\xcf\xad\x51\xa7\x0d\x31\xd8\x95\x23\xaa\x73\x97\xaa\x36\x40\x85\xf7\xd6\x47\x59\xde\x6a\xc9\x39\x8c\x14\x0a\xce\x5b\x85\x31\x3a\x6d\x53\x68\x7b\xd4\x79\x83\x0e\xb1\x8c\xb4\x82\x00\x8e\xe8\x1b\xe1\x19\x3c\x82\x19\x98\x80\x5c\x10\xc5\x74\x21\x85\x66\x75\x78\xc6\x30\x23\x34\x75\xfb\xc5\x7e\x6d\x2d\x39\xbb\xca\xcc\x42\x6a\x03\x95\xb3\xfd\x34\xd3\x3a\xf7\xc3\x41\x21\x32\xcd\x32\x96\xd6\xba\xa9\x61\x17\x20\x5a\x77\x0f\x24\xd0\xd5\x21\x0d\x7d\x41\xb0\x3e\xb9\x56\xda\x5c\xbb\x3f\x74\xe6\xf3\xbd\x6f\x7c\x5b\xe6\xdb\x0a\x9a\xab\x83\x09\x42\x24\x22\x80\x15\xa0\x68\x80\x0f\xd7\x51\x03\x9d\xb9\x94\xd7\x24\x91\x79\x91\xc1\xd1\xe9\x70\xb2\xaa\xfe\x5d\x81\x94\x46\x76\x74\xfd\x24\x6a\xed\x05\x1f\x74\xeb\xec\xd5\x49\x0b\xeb\x43\x07\x63\xef\x58\xd2\x5b\xef\xcf\x93\x77\x2c\x89\x9a\xd7\x02\x94\x55\xe2\x81\x21\xec\x89\xed\xde\x93\xbc\x73\xbc\xa1\x2f\x1f\x7f\x87\x2a\xba\xf8\x6a\xa0\xff\xc1\x98\x1e\x25\xdd\x3d\x02\x1a\x4e\x80\x21\x84\x95\x75\x31\x7a\x46\x20\x46\x3c\x7a\x2b\x90\x81\x21\x8b\xda\x8f\x05\xad\xa5\xa4\x34\xe4\x60\xff\xc9\xfe\x60\xc5\xf9\xd8\x80\xda\xbe\x8a\x7e\xc9\x01\x22\xb2\x00\xbc\x45\x96\xec\xa7\x43\xc2\x8d\x4f\xb3\xc6\xbe\x47\x30\x2b\x57\xee\x37\x24\x5a\x12\xa3\x68\xca\x9d\x1a\x03\x9f\xda\x9b\x8c\x2a\x1d\x97\x3f\xd8\x7f\xbf\xef\x5a\x22\xdd\x48\xb1\x6f\x60\xfa\x63\x72\x85\x70\x33\x61\xa0\xa5\x2c\xa1\xd3\x27\x2e\x41\x91\xf1\x84\x9b\x6c\x09\x1c\x8b\xc8\x12\xdb\x82\x59\x79\xe1\xca\x0c\x4f\xde\x71\xe3\x9b\x92\xc8\x29\x79\x8a\x5d\xc9\x18\x75\xee\xcf\x8c\x2f\xd8\x93\x39\xa3\x99\x99\x63\x86\x88\x90\x62\x84\x8d\x25\x2d\x2b\x71\xdf\x74\x0d\x96\x74\xf3\x25\xc6\x57\x07\xbf\xe2\xea\x84\x3a\x9a\x0d\x96\x89\x7e\xdf\xbe\xdb\x35\x59\x41\xfd\xba\xba\x3a\xff\xbe\xd6\xef\x1a\xb8\xb8\x31\x85\xcf\xdb\x89\x9a\xc2\x6f\x01\xef\xe8\x27\x52\xd9\xa9\xf1\x35\xe9\x91\x85\x75\x6d\x80\x4d\xd6\xa3\xb8\xdd\xbf\xf3\x35\xf9\x87\x2c\x01\x03\x84\x4e\xb2\x65\x00\x60\xd0\xcc\x90\x3d\x3b\xd4\x9e\x65\x4f\x96\x1a\x7e\x60\x34\x45\x7c\x0c\x6d\x18\x6d\xa5\xba\xc5\x57\x6f\x11\xb4\x68\x6e\xfd\xca\x81\x52\x1b\x99\x93\xb9\x7b\xed\x7a\xdd\xa5\x3b\x19\x63\x38\x3d\xbe\xa8\x49\xb1\x02\x39\x9c\xfb\xcd\x67\xc7\xbf\x56\xf8\x06\xae\x7b\xad\xf9\x41\x12\x2f\x5b\xdc\x5b\x87\x0b\x5c\x2c\x84\x9b\xe9\x89\x97\xf6\x90\xf9\x40\x7a\xcc\x7e\x20\xdd\xaa\x38\x9b\x03\x41\x44\xaf\x7b\xa2\x57\x6f\x09\x15\xa4\xb7\xa4\x01\xb2\xce\xc3\xea\x68\x06\xbd\x2f\x3d\x2d\x62\xaf\xa1\x7a\xd2\xbd\x4e\x34\xbe\xee\x5e\x80\x7e\x36\x9f\xf4\xb9\x02\x45\x0f\x79\xdd\xab\x59\xdd\x88\x1e\x05\x75\x97\xc8\x5c\x81\x4d\x68\xa6\x16\x6d\x2b\xb9\xab\xab\xbf\x57\x97\xed\x2d\x7e\x7f\xad\x29\x92\x56\x44\x84\x6e\xda\x1e\x1d\x75\x75\x41\xa2\xb4\x04\xd7\x7c\xdb\xfb\x72\xbd\x38\xa2\x62\xc6\xc8\x33\xfb\xcb\xbf\xfe\xe5\x2f\x7f\xfa\xcb\x18\x87\x0f\x29\x0a\x82\x9c\x1e\x9e\x1d\xfe\xf3\xf2\xa7\x23\xa8\x8c\xed\xba\xaa\x3d\xe5\x5f\xf6\x9d\x7d\xd9\x6b\xee\xe5\x47\xcd\xbc\x84\x7a\x8f\xce\x5c\xa4\xee\xf8\x87\x21\x63\x98\x50\xa7\xfb\x45\xf0\x7a\x56\xd7\xac\x3b\x52\xed\x51\xdb\x8a\x33\x66\x92\xe2\x52\x26\xd7\x3d\xda\x35\xc7\xac\x50\x2c\x41\x3f\xd9\xd5\xd1\x39\x8e\x6e\xed\xcb\xb3\xd7\x57\x55\x9d\x01\x24\xe3\x54\x18\x7a\x3f\x38\x4f\x9a\xb5\x49\xaf\x59\x61\x82\xe9\x3e\xa1\xc9\xf5\x0d\x55\x29\x78\xb6\xa8\xe1\x13\x9e\x71\x83\x90\x7f\x8a\xb9\xf6\x57\x98\xed\x87\xd8\x66\xbe\xbd\x30\xf2\x72\x74\x20\x78\x77\x28\xb8\xac\x30\x89\x66\x4a\x79\x06\x1e\x54\xd7\xd9\x17\xd3\x81\x92\x22\xb8\xf4\x62\x9f\xf6\xce\xf8\xf2\xd7\xd6\x1a\x5f\x51\xe7\xe1\x87\xda\x61\x5d\x93\x12\xb7\x58\xd4\x39\x11\xa7\x6a\x4d\xc0\x77\xa2\xae\x87\xf1\xb6\x57\xd4\x15\x8a\x5d\x1a\xd9\xaa\x93\x00\x59\x8d\x92\xe0\x60\xb7\xc4\x48\x26\x6c\x2a\x2d\x13\xbe\x35\xe8\x91\x96\x70\x08\xa9\x80\xca\x40\xef\xd5\x92\xb5\xc0\x06\xa6\x63\xfa\xb6\xdb\x99\xc3\x4b\x7d\xa2\x63\x90\x54\xdf\x43\x79\x68\xdf\x8e\xe5\x30\xbb\x61\x55\xe2\xe0\x3a\x38\xc3\x87\xcc\x24\xe8\xb9\x8d\x18\x39\x00\x86\xba\xe9\x37\xc3\x28\x89\xa2\x7a\x8e\xdd\x8d\xd9\x3b\xee\xdb\xdc\x9f\xcb\xb4\xd9\x93\x7c\xa6\x68\xc2\x48\xc1\x14\x97\x56\x18\x95\xc2\xa4\xf2\x46\x90\x09\x9b\x71\xa1\xfd\x52\x00\x06\xbb\x5b\x33\x88\xc7\x70\x1d\x20\xe1\xc6\xe4\xa2\x86\x74\xe2\x6a\x90\x12\x59\x1d\x4d\x37\xe7\x66\x24\x09\x24\x16\xac\x13\xb6\xfc\x09\x2b\x1c\x77\x41\xfa\xd0\x94\x0f\x4a\x01\x4f\x4e\x59\x46\x97\x98\x6a\x0a\x9d\xcf\xf9\x7f\x98\xd2\x83\x1e\x22\x4e\xd8\xc7\xcb\x7f\x77\xeb\x3c\xb8\x26\x8a\xd1\x64\xde\x2d\xf8\xbb\x0b\x51\xdd\xf3\xda\x85\xa8\xba\x0c\xb2\x0b\x51\xed\x42\x54\x1f\xb8\x76\x21\xaa\x5d\x88\xaa\x71\x6d\xad\x95\xb4\x0b\x51\xb5\xbe\x76\x21\xaa\xbb\xaf\x5d\x88\xea\x1e\xd7\x2e\x44\x75\xcf\x6b\x17\xa2\xda\x85\xa8\x76\x21\xaa\x5d\x88\xea\x77\xe4\xb7\xf3\xd7\x2e\x44\xb5\x32\xc8\x2e\x44\xb5\x0b\x51\xdd\xfb\xda\x5a\xe3\x6b\x17\xa2\xc2\x6b\x17\xa2\xaa\x5f\xbf\x2f\x51\xe7\x03\x3c\xe7\xd6\xd4\xeb\x5e\xd3\x76\x0e\x41\x05\x9e\xb8\x38\x91\x9c\xd6\xea\xa0\xf0\x51\xe3\xaa\x41\x45\x84\x09\xe2\x4b\x71\x5c\x44\xa8\x8a\x33\xad\xad\x97\xea\xd8\x3e\xae\x90\x69\x15\xa8\x88\x22\x14\x68\xf0\xb6\xaf\x59\xdb\x58\x35\x56\x97\xb0\xc4\xa7\x09\x49\x6c\x49\xfc\xa6\x87\x30\xc4\x2e\x04\xf1\xd9\x85\x20\xfa\x71\xdf\xf5\xe0\xba\xeb\x2c\x2a\x5c\x64\xfe\x6a\xae\x98\x9e\xcb\xac\x35\xa1\xd7\x88\xfc\x15\x17\x3c\x2f\x73\x68\x10\x6b\xe9\x99\x2f\x42\x0a\x40\xe8\x82\xed\x38\x36\x7a\x11\xa3\x4e\xb2\xbe\x83\x2c\xd4\x6f\xce\xe9\x02\xba\xa2\x96\x49\xc2\x58\x1a\xf5\xb6\x07\x0d\xeb\x4f\xe3\xf0\xa4\xd0\x37\xe3\x59\x37\x7e\xd3\x4d\x88\x23\x16\x29\x8c\xf2\xa7\xaf\x5a\x8d\x31\x53\x45\x3f\x7c\xf9\xfb\x8b\xf3\xa3\x88\x2f\x53\xe1\xd9\x32\x17\x0b\x99\xc1\xaa\x52\xbc\xc9\x2a\x6b\x63\xac\xdf\xc7\x76\xeb\x34\x2b\xe6\x34\xb2\x6e\x9c\x61\xa0\x09\x13\x74\x02\xad\x69\xed\xef\x82\x4c\x3e\x47\xc9\xcb\xa8\x29\x15\x23\x33\x6a\x36\xc9\xf2\xbb\x1b\x31\x9d\x0c\x98\x3e\x24\x4e\x57\x1d\xbd\xee\x85\xb3\x9a\x78\xdd\x0f\x35\x03\xca\x40\x00\xfd\x7b\x6b\xe2\x9d\x79\x65\x77\xed\xb8\xfb\xe1\x22\x80\x70\x03\x2f\xde\xdb\x02\xef\x5d\xba\xce\x51\x4e\xa0\xc7\x66\x90\x6f\x2a\x65\x24\x29\x32\x5a\xb5\x85\x82\x1d\xf8\x01\xa4\xd0\xd1\x9c\x25\xd7\x17\x2e\x16\x7b\xa0\x19\x0b\xda\xe9\x8c\x9b\x79\x39\x19\x27\x32\x7f\x62\x99\x02\xfe\xdf\x24\x93\x93\x27\x39\xd5\x86\x29\xab\xb0\x3a\x21\x37\x4a\xec\x28\x5c\xcc\xc6\x79\x3a\x18\x93\xb7\x02\xeb\xdb\xab\x36\x94\x11\xba\x83\x7d\xbe\x47\xda\x98\x30\xcb\x5f\x25\x78\x22\x22\x04\x3b\x3b\xbd\x71\x17\x9c\xe4\xce\x42\xa9\x63\x1c\xfc\xd3\xc7\xc0\x77\x9c\x8b\xf4\xe0\x72\x79\x6c\xb1\xee\xde\x72\x3e\x7a\x88\x71\x6f\x51\x7c\x7b\x6b\x94\xe3\x6d\x89\x69\x6f\x21\xd8\x74\x0f\x21\xd8\x3e\x62\xd8\xfd\xc5\xaf\x3f\x02\x26\xf3\xc7\x89\x5b\xf7\xe8\xdc\xeb\x29\x5e\xfd\x29\x62\xd5\xbd\xbc\x75\xd7\x18\xf5\xa7\x8b\x4f\xf7\xf3\xba\x7d\x1a\x02\x8f\x35\x26\xdd\x83\x93\xbe\x4f\x07\x7d\x6f\xce\xf9\x8f\x16\x83\xee\x1e\x7f\xde\x82\xd8\x73\xe7\x45\xe6\x82\x1b\x4e\xb3\x63\x96\xd1\xe5\x25\x4b\xa4\x48\x5b\x4b\x98\x06\x48\x67\x38\x3f\x1a\x87\x75\x9e\xaa\x7a\xa9\xc5\x9c\x3a\x2c\x72\x6b\x51\x61\x69\x89\x8f\x66\x38\x85\x02\xe2\xca\x38\xcb\xad\x8c\x4f\x90\xad\x71\x89\x61\xdd\x49\x9f\x9b\xf8\x83\xbc\x21\x72\x6a\x98\x20\x07\x5c\xf8\x7d\x1c\x44\x66\x60\xe5\x9f\x0c\x64\x6d\xbf\x7d\xf6\xd4\xdf\xfc\xf9\x39\x1e\xc1\xc5\xaa\xf5\xc7\xf7\x03\xbb\x07\x7d\xd8\x11\xec\x6e\x9c\x96\x59\xdd\x19\x8c\x0e\xe2\x3a\xbf\x79\x56\xa1\x29\x3f\x83\x71\xc3\x69\xa3\x22\x25\xae\x16\xed\xf3\xdb\xb4\xce\x99\x35\x75\xd5\x2f\x64\xd2\x7c\xc8\x6f\x7c\x75\x74\x8e\x6e\xe3\x9d\xbb\x64\x5b\xdc\x25\x1b\xca\x4e\xd9\x42\x45\xf7\x91\x66\xa4\xec\x14\xdd\x07\x5c\x51\x75\xea\xf7\x8a\x26\xec\xbc\x77\x1d\xc1\x1f\x27\x92\x96\x8a\x3a\x06\x18\x54\x3e\x7f\x78\x04\x63\x29\x9e\xa6\x50\xd1\x0b\xb5\xb2\xd3\x32\xcb\x96\xa4\x2c\xa4\xa8\xd7\x3f\x63\xb4\xbd\x59\x4e\x0b\x2e\xf9\x35\x4f\xa9\x14\xcb\x42\x49\x27\x33\x55\x29\x84\xe5\xc1\x55\x4b\x34\x50\x24\x01\xa8\x99\xd6\x8a\x76\x35\x9f\xd9\xe9\x5b\xf9\x07\xf5\xbc\x55\x0a\x62\x6d\x40\xfb\xeb\xa9\x54\x09\x9f\x64\x4b\x32\xa7\x59\xe8\x7f\x43\xc9\x35\xcf\x32\x37\xcc\x98\x5c\x32\x83\x21\x05\x94\x9d\x99\x14\x33\x98\x1c\x15\xbe\xef\x22\x4b\xec\x6f\x93\x8c\x51\x51\x16\xf8\x3c\x2b\x89\x97\xb2\x54\xfe\x79\xe3\x10\x98\x08\x12\x58\xf0\x6c\x18\x75\x77\xbb\x73\x63\x43\xf6\x4f\xa9\xad\x02\xf0\xda\x03\x53\x0f\xe3\x31\x3d\x76\xb8\x8e\x7a\xfb\x14\x4a\x2e\x78\x8a\xd1\x0d\xbf\x6c\xd0\x47\x1a\xfb\xf7\x84\xf3\x2c\xa4\x18\x09\x36\xa3\xa0\xa8\xb8\x53\x84\x7b\x86\xe3\x60\x0e\x81\x48\xa1\xa3\x8f\xd5\xf0\x65\x51\x2b\xa8\x5f\x70\xec\x45\x1c\xad\x1c\x39\x10\x92\x48\xc8\x48\x2d\x05\x37\xd8\xdf\x7e\x5e\x1a\x92\xca\x1b\x31\x88\xe2\xae\x64\xc2\xcc\xdd\x51\x57\x08\xb4\x5e\xad\x5d\xa0\x7a\xf8\x75\x9d\x9e\x83\xef\x7b\xf7\xf2\x72\xed\x5c\x9f\x53\x52\x0a\xcd\x3a\x8a\xf7\xde\x94\xa3\xbf\xfe\xb9\x1d\x8f\xe0\x39\x93\xa5\xf9\x24\xd6\xdf\xcd\x9c\x27\xf3\x58\x99\xe5\x39\xd3\x44\x96\x0d\xb3\xf8\x99\xfb\xd9\xfa\x1d\xda\x99\x80\xeb\xae\xb6\x8e\xdd\x35\xde\xaf\x26\x20\x42\xd5\xf8\x1a\x32\xc5\x8f\xcf\x2e\xff\xf9\xf2\xf0\xbb\x93\x97\x63\x72\x42\x93\x79\x8c\x8a\x21\x08\x05\xa6\x01\x8c\x62\x4e\x17\x8c\x50\x52\x0a\xfe\x5b\xe9\x02\xbe\x07\xe1\xb7\x83\x5e\xd1\xda\x5b\x4a\x5f\x68\xce\xdf\x5b\x37\x38\x6c\xf5\x8f\x99\x59\x52\x33\xe8\xdf\xd2\x54\x9f\x4e\xec\x57\x68\x1c\x80\xaa\x05\xa9\xf3\x33\xbe\x70\x6c\xd8\xc1\xdf\xd3\x34\xe4\x8a\x59\x3a\xb7\x64\x61\x45\x15\x9d\x40\x8e\xd7\x9c\x11\xc1\x8c\x25\xeb\xe0\x63\x92\x42\xd7\xe0\x49\x4a\xcd\xf4\x90\x4c\x4a\xc8\x4a\x2b\x14\xcf\xa9\xe2\xd9\x32\x1e\xcc\xca\xaa\xb3\x10\xf2\x5e\x36\xa7\x74\xfc\xfa\xe4\x12\xaa\x04\x0a\x85\xc0\x25\x90\x56\x06\xdf\xc3\x6b\x4d\x98\xfd\x85\xeb\x22\x3c\x26\x87\x62\x89\x5f\xe2\x01\xe7\x9a\x64\x5c\x1b\x06\x22\xd8\xe9\x90\x3e\x98\xbe\xf7\x74\x0c\xff\xdb\xb3\x6f\xa9\xac\x92\x19\xb2\xe5\x92\x95\xf4\x55\x54\x43\xf9\x24\x8b\x56\xd3\xbd\xfb\x67\xd5\x0f\xae\x4a\x12\xb2\x8b\x18\xf5\x83\xa3\x61\xab\x61\x79\xb1\x3f\x20\x17\xb3\x2c\xa6\xaa\x76\x6c\xbf\xab\x6d\xd9\xd5\xb2\x1c\x55\x6f\x70\xde\xd6\xc0\xec\xa5\x2f\x5d\x35\x87\x9e\xba\x39\x55\xd2\xcf\x9b\x53\x8e\x23\xc8\xb8\x41\xef\xe9\xb9\x3f\x01\x4e\xbb\xc9\x1b\x5d\x5d\x8b\x2a\x27\x69\x48\x9e\x92\x6f\xc8\x3b\xf2\x0d\x98\x57\x7f\xed\xda\xfb\xaa\xab\xe1\xd3\x47\x8a\x91\xb5\xea\x4f\xcf\x7b\x5a\xf1\x9f\x2d\x77\xb2\x23\xda\x55\x35\x92\x4c\xb8\x53\xe7\xd9\x3b\xc3\x94\xe5\xa3\x6e\x27\x36\xda\x35\xcc\x4e\xf0\x13\x92\x19\x86\x1b\x4e\xa7\xf5\xb4\xa6\x87\x11\x9a\xfd\xf9\x0f\x52\x9b\x33\xc7\x85\xea\x2d\x70\xaa\xd1\x72\x6a\x92\x79\x9d\x8d\x59\x45\x4d\x9b\xea\x80\x69\x92\x4a\xc8\xb2\xc2\x04\xe6\x39\xef\x90\x3c\xb1\x3d\x64\xdc\x2d\x9e\x5e\xdb\xcf\xbb\x76\xaa\xe1\x40\x01\xcb\xc7\x29\x56\x11\x36\x56\x21\x53\xa7\x93\xd9\x69\xa5\x91\xcc\xb8\x43\x29\x73\xbe\x9a\xe0\x65\x06\x5a\xb2\xe7\x29\xa1\x02\x4b\x48\xa6\x4c\x29\xcc\x39\x9f\x2c\x7d\xb2\x5e\xe7\xcd\xeb\x74\x92\x0a\x25\x8d\x4c\x64\x87\xc6\x66\xf5\x18\xb7\x1b\x0e\x16\x01\xf3\x7c\xbd\x9b\xfc\xcd\xf1\xf9\x90\x5c\x1d\x9d\x43\xbf\xa7\xcb\xa3\xab\xf3\xba\xa5\xb2\x77\x75\x74\xbe\xb7\xd1\xa5\x20\x5e\xb3\x02\xc7\x74\x8b\x41\x6a\x8e\x27\xab\xb6\x8d\x72\x5a\x8c\xae\xd9\xb2\xa5\x4c\xed\x43\xae\x8f\xc2\x0e\xf7\xf2\x42\xb8\xcc\x39\x2d\x1e\x3c\x9a\x62\x34\xe5\x9f\xa8\x8e\xcb\xa7\xc1\x86\x67\xae\x2f\xe8\xca\xe5\x82\xa5\xa8\x0e\xfb\x5f\x30\x91\x16\x92\x5b\x7d\x71\x57\xe5\xf5\xf0\x5f\xef\xaa\xbc\xee\x7d\xed\xaa\xbc\x76\x55\x5e\xab\xd7\xd6\x24\xb2\xee\xaa\xbc\x3e\xaf\xb8\xfd\xae\xca\xeb\x77\x1f\xfc\xdf\x55\x79\xad\xbf\x76\x55\x5e\xbb\x2a\xaf\xfb\x5d\xbb\x2a\xaf\x87\x5f\x5b\x97\xb6\xb4\xab\xf2\x7a\xd0\xb5\xab\xf2\x5a\xbd\x76\x55\x5e\xb7\x5c\xbb\x2a\xaf\x5b\xae\x5d\x95\xd7\xae\xca\x6b\x57\xe5\xb5\x4b\x7e\xfd\xe0\x58\xdb\x99\xfc\x4a\x76\x55\x5e\xee\xda\x55\x79\x7d\x16\x29\x7e\x64\x57\xe5\x75\xaf\x6b\x57\xe5\xb5\xab\xf2\x6a\x73\xed\xaa\xbc\x3e\x17\x77\xc9\xae\xca\x6b\x57\xe5\xf5\xfb\x51\x74\x77\x55\x5e\xbb\x2a\xaf\x5d\x95\xd7\xae\xca\xeb\xce\x59\xec\xaa\xbc\x3e\x07\x13\xd0\xf7\x02\xee\x5e\xb5\xb4\x7f\x24\xf3\xa2\x34\x8c\x5c\xf8\x21\x83\x16\x89\x8c\x81\xeb\x58\x23\xe8\x9e\x44\x98\x48\x31\xe5\x33\xc7\xd9\x9f\x60\x03\xde\x51\x78\x9f\x51\xd4\xf4\xf6\x11\x66\x10\x66\x3c\xe7\xed\x4a\xc9\xc8\xca\xc6\xbc\x84\xb1\xa2\xb8\x8c\x3d\x49\x39\x7d\x07\x47\x84\xe6\xb2\xc4\xa6\xc5\x89\xdb\xbf\xb0\x84\x18\xbd\xda\xba\x9d\x21\xfd\x98\x38\x55\x4d\xdc\x79\x1f\x69\x25\xd4\x18\xa6\xc4\x73\xf2\x3f\x07\x6f\xbf\x7c\x3f\x1a\x7c\x7b\x70\xf0\xcb\xd3\xd1\xdf\x7e\xfd\xf2\xe0\xed\x18\xfe\xf1\xc5\xe0\xdb\xc1\x7b\xff\xc7\x97\x83\xc1\xc1\xc1\x2f\x3f\xbe\xfa\xfe\xea\xfc\xe4\x57\x3e\x78\xff\x8b\x28\xf3\x6b\xfc\xeb\xfd\xc1\x2f\xec\xe4\xd7\x7b\x0e\x32\x18\x7c\xfb\xc7\xd6\x53\xee\xac\x12\xf7\xa7\x10\xf7\xa4\x0e\x7f\x14\x65\xd8\x05\x74\x7b\x3a\x8b\x2e\x19\x65\xe5\x34\x3a\x81\x75\xd7\x69\xf4\xdc\x14\xd4\xbc\x30\x0e\xd7\x44\xe6\xdc\x58\xe5\xd0\xea\x83\x34\x4e\x68\xe5\xa6\x66\x94\x3a\x3e\x00\x29\xdd\xd4\x60\x8b\xf5\x90\x0c\x1a\x25\xb1\x48\xaf\xf9\xb9\x1e\xf4\x3c\x2f\x32\x68\x6d\x0e\xe7\x79\xe4\x73\x59\x40\xb8\xee\x78\xc3\x87\xaf\x1d\x6f\xf8\x1c\x79\x83\x66\x49\xa9\xb8\x59\x1e\x49\x61\xd8\xbb\x56\x1e\x96\x3a\x6b\xb8\xac\x0f\xe8\x72\xc6\x5c\x1d\xb7\xfb\x8e\xc8\x02\x33\xbf\x1b\x05\xf5\x73\x59\x66\x29\x94\x73\x94\x02\x0c\x4c\xac\xd3\x63\x06\xad\x3f\xb0\x7b\x20\x99\xbb\xf9\x10\x6f\xcf\xa1\x99\xf9\x5b\xc9\x17\x34\xb3\xd6\x6e\xf5\x8b\x73\xb0\x60\xe2\x1f\xdd\xf7\xcc\x1b\xaa\xaf\xab\x03\xcf\x46\x56\x87\x0e\x73\x7e\xe2\x5f\x09\x3e\x62\xef\xcc\x63\xd4\xd2\x40\x41\x3a\x57\x7c\xc1\x33\x36\x63\x27\x3a\xa1\x19\xf0\xb5\x7e\x64\xc5\xe1\x2d\xa3\xc3\xc6\x2b\x99\x69\x72\x33\x67\x96\x57\x13\xea\x5d\x00\x50\x63\x37\xa3\x5c\x90\xdc\x6e\x51\xe1\x7f\xac\xd1\x97\x60\xd9\x7f\x41\x95\xdd\xe0\xe0\x33\x00\x13\x79\x22\x65\xe6\x6a\x1e\xb2\x65\x35\xbe\xab\xfe\x11\xf2\x9f\x82\xdd\xfc\xd3\x8e\xa6\xc9\x34\xa3\xb3\xe0\x2a\xd0\xcc\xac\x78\xfb\xaa\xa1\x6f\x7d\x01\x28\x28\x28\x19\xa1\xd9\x0d\x5d\xea\xca\x71\x12\x21\x3f\xe8\xe7\xe4\xd9\x00\xc8\x99\x6a\x12\xc6\x48\xc9\x57\x03\x08\xff\x1d\x1d\x9e\xff\xf3\xf2\x1f\x97\xff\x3c\x3c\x7e\x75\x7a\x46\xce\xa4\x61\x28\xd4\xa2\x06\x81\x49\xb0\x30\xec\x2c\xe1\x19\x60\xa5\x4b\x3d\x06\xdf\x25\xd7\xe4\x86\x8b\x54\xde\xe8\xd6\x3e\x5a\x24\x3f\xbb\x78\x8c\x8a\x56\x63\x24\xb4\xa0\xd0\xf7\xb0\x83\x84\x59\xc9\x30\x89\x07\x05\x19\x9e\xa6\x4f\x52\x25\x0b\x5c\x04\xef\xe4\xaa\x44\x6d\xdd\x8c\x8e\x73\x58\x61\x7f\xa7\xf5\x01\x67\x8a\x0a\x53\x79\x7b\xaa\x3d\x73\x0d\x17\xc7\x9d\xb7\xe3\x71\xd7\x34\xd1\xb4\xbf\x7a\xa6\xc3\x34\x65\x69\x6d\xf9\x3f\xbb\xcc\xc1\x23\xff\x72\xcb\x0a\xa7\x82\x9c\xbf\xbe\x3c\xfd\x7f\x1a\x74\xbc\x2c\xba\x25\x4a\xf5\x53\x1b\xab\x64\xd1\xdb\xee\x5e\xb8\xda\xcb\xdd\xfe\x6e\xc5\xfe\x06\x69\xd9\x4f\x78\xfe\xa2\x14\x75\x28\xa3\x6a\x7c\x92\xcb\x94\x8d\xc9\x79\x88\x13\xd4\xbf\x8d\x20\x0e\xa8\x62\xc4\xde\x22\x0c\xa7\x59\xb6\x8c\x55\x34\x23\xb1\x0e\xb1\x86\xce\x10\x33\xf2\x29\xcd\xf4\xa6\xb9\x71\x17\xd9\x68\xf5\x88\x57\xd6\x1e\xee\x65\x3b\xc2\x68\x24\x65\x42\x1a\xa7\x58\xdb\x59\x02\xe2\x85\x92\x09\x41\xe3\x3b\x4a\xc6\xaa\xc9\x37\x8d\xb1\x0a\x2f\x1a\xb9\xf6\x8b\x7d\x1e\x46\x46\x47\x75\xa9\x59\x53\x41\xf7\xbd\x88\x83\x39\x6e\x47\x57\x8c\xa6\x52\x64\x4b\xc8\xbc\xc4\x5c\x8a\x9c\xea\x6b\x96\xe2\x07\x4e\x35\x0b\x91\x0a\x3b\x62\x78\xd4\x95\x9d\xb7\x0f\x4b\x80\x4a\x86\x19\x1e\x10\xce\x60\xe9\x86\x77\xbd\xc3\x21\xb4\x8b\xf2\x5a\x64\xcb\x0b\x29\xcd\x8b\x50\x48\xdb\x0b\x05\xfc\xec\xb4\xe5\xba\x2b\x1a\xd4\x49\x0a\xcf\x1d\xc1\x6e\xc0\xa1\x8a\x6b\x78\x8f\xab\x1d\x7f\xec\x47\x4a\x95\xe2\x50\x7f\xaf\x64\xd9\x5a\x88\xad\x28\x9b\xdf\x9f\x1e\x03\x2b\x2a\x5d\xa8\x52\x18\xb5\x04\xf0\x80\x55\xdc\xb7\x60\x18\xbc\x71\xc1\xd6\xf8\x4c\x54\x71\x31\xf2\x8a\x2e\x09\xcd\xb4\xf4\x6b\xc9\xc5\x5a\x2b\xd4\x99\xb8\xf6\xeb\x89\x34\xf3\x15\xdb\xd6\x1e\xa8\xd5\xdf\x0d\xa3\xc8\x65\x05\x44\xc7\xc5\xca\xcf\x0d\xbd\x66\x9a\x14\x8a\x25\x2c\x65\x22\xd9\xf4\xb6\x6f\x3a\xe0\x07\xa4\x73\x26\x85\x3d\x98\xbd\x10\xcf\x69\x88\xf4\xba\x25\x8d\x49\x05\x62\xc6\xce\xfa\xa3\x10\x39\x86\x63\x59\x6a\xa6\x30\xcc\xad\x4a\x86\x3b\xf9\x63\x39\x61\x99\x5d\x79\x6b\x92\xba\x6e\xf1\xe8\xce\xe0\x39\x9d\x31\x42\x4d\xa0\x34\x23\x09\x13\xda\x72\x4c\x74\x80\x1a\x92\x4a\x56\xd5\xdf\x53\x4d\xde\x9c\x1e\x93\xa7\xe4\xc0\x3e\x6b\x00\xf4\x03\xcd\xe4\x8d\xc4\x24\xb7\xa6\x8d\x3a\xf5\x43\xc0\x94\x80\x78\x89\x54\xc8\x24\x86\x44\x48\xa2\xcb\x64\x1e\x77\xb0\xf7\x66\xb3\x4b\x84\x84\xd0\xca\x76\xd2\xfa\x66\x39\xd4\x1b\xcd\x54\x6f\x0c\xea\x4d\x0b\x06\x15\xab\x51\x96\xe6\xea\xab\x87\x84\x95\x33\x43\x53\x6a\xa8\x63\x5c\xfe\x86\xad\xdd\xd2\xdf\x37\xfb\xd2\xec\x25\x17\xe5\x3b\x4c\x3c\xea\xcf\xd5\x72\x79\x02\xc3\x92\xc4\xaf\x3a\xec\x3a\x2d\x8a\x8c\x23\xde\x46\x23\x11\xee\xb4\x46\x2b\xc3\x5b\xd4\x44\xe0\x13\x34\xcb\xa4\xe5\x8f\x56\x39\xa1\x22\x95\xf9\xca\xc3\xac\x12\xc9\x6a\x88\xa9\x63\xb2\xa3\xbe\xfa\xb5\x25\x4e\xa1\x8c\x2d\x58\x07\x74\xb1\x26\x42\xac\x1d\xcd\x2e\x8e\xa7\x08\x18\x9e\x64\x74\xc2\x32\x5c\x63\xa4\x40\xbd\x4a\x81\x9b\xce\x46\x55\x32\xeb\xaf\x7c\xe6\x42\x66\x0c\xd3\xbb\xfc\x42\xd8\xe1\x1f\xc5\x3a\xc0\x20\x7d\xad\x03\x58\x83\xb5\x75\x00\xbb\xf6\x31\xac\x43\xd9\x41\xd4\x93\xe6\x3a\x58\xbd\xa1\xbe\x0e\x20\xbc\xb7\x7d\x1d\x34\x4b\x12\x99\x17\xe7\x4a\x5a\xb3\xb3\x37\xd9\xe4\x86\xad\x62\x86\xe8\xd8\x58\x93\x8c\x05\xb2\xa0\x7e\x33\x55\x51\x62\x27\x35\x28\x24\x7c\x76\xe7\xff\x2f\x92\x59\xc0\x7a\x9a\x82\xcc\x8f\x52\x0b\x2f\xda\x5f\xba\x2f\x1e\xb3\x38\xe8\xa3\x36\xa2\x83\xb3\xb3\x17\x69\x24\x13\x9a\x01\x7a\x6c\x37\x92\x23\x4d\xb2\x6b\x0e\x1c\xa5\xf3\x42\x8c\x12\x3e\xf3\x09\x24\x00\x24\x0a\x9f\x38\x17\xa6\x90\x29\x8b\x62\xd9\x98\x87\x7c\x85\x69\x9f\x70\x9f\xcf\x24\xb6\x7a\x85\x0f\x2b\xa7\xb5\x5f\x1b\xe9\x30\xd0\x5e\x05\x4c\x5a\x3b\x41\x26\x52\x2e\x66\xe0\x57\x1b\x12\xc5\x32\xcc\x41\x76\x4c\xe0\x1a\x2d\xc8\x7d\x38\x12\x7e\x50\x7f\x1e\xfc\xa3\x41\x17\xe3\x52\xb8\x91\xc1\x53\xe4\x35\xac\x29\xb2\x5b\xae\xc9\xde\x4b\xbf\x00\x1d\x40\x3c\xb7\x51\xc2\xec\xe1\x1b\x86\xdd\x44\x4f\xe7\x35\x17\xa9\x4b\xd7\xad\x2d\x56\x80\x5b\x47\x3d\x18\x12\xc1\x79\x1a\xf3\x96\xe7\xe4\xad\x20\x61\xb1\xc8\xa8\x35\x79\x5c\xa0\xca\xec\x7d\x74\xa3\xbb\x1d\xaf\xe1\x21\xcd\x61\xde\x08\xd8\x7b\xfb\xdc\x91\xb5\xdc\x57\xef\xf3\xef\xb2\x51\xe8\x1e\xc7\xfd\xfa\xb6\x62\x7e\xc6\x61\xbd\x4a\x9f\x58\xb2\x36\x5c\xcc\x74\x6c\xc9\xd0\x2c\xab\x39\xc3\xd7\x99\x32\x7e\x87\x03\xb8\xfe\xaa\x09\xd1\x28\x33\x78\x2c\x66\x48\x66\xd5\x89\x47\x6e\x84\xcc\x72\x4d\x8f\x94\x5d\x09\xc3\x69\x76\x59\xb4\x07\x29\x25\x2b\x80\x78\xaf\x2e\x0f\xeb\x43\x83\xb0\x86\xde\x0f\x76\xaf\xec\xf7\x84\xa6\x39\xd7\x1a\x1c\x61\x6c\x32\x97\xf2\x9a\x1c\xac\xc1\xe3\x8a\xf2\xb4\x34\x9f\xe9\x27\x8e\xe6\x47\x76\xf6\x03\xc2\x45\x16\xb2\xa2\xc0\x0e\x16\x46\x7b\x47\x0e\x3c\x24\x09\xb3\x80\x3d\x74\xc8\xd5\x2e\x59\x61\x75\x9a\x88\x55\x6d\xa9\x60\xe3\x0c\x7b\x75\x7b\xce\x3a\xc2\xae\x7c\x60\x8b\xce\x1c\x6d\x37\x91\xd5\xd6\xae\x23\x6a\x8f\x1b\x5f\x24\xa7\x5c\x24\x4c\xf7\x07\xe8\xf4\x43\x35\x26\x49\x19\x56\xf1\x30\xc8\x7e\xa2\xb7\x26\xd9\x81\x5f\x7a\x1f\x8a\x41\xdd\x4f\xf7\x63\x8d\xfa\xaa\x62\x2e\xd6\x1e\xc9\x8a\x39\x1d\xa1\x91\x6e\x39\x1a\xb0\x40\xaf\x42\xcc\xa5\x90\xae\x48\xc2\x0a\x51\x29\x80\xa4\x81\x45\x61\x34\x0f\xf6\xc4\xb1\xe8\x68\xaa\x47\x55\x94\x38\x0e\x04\x42\x31\x19\xe2\x47\x54\x73\xb8\xe1\x66\xee\x7b\xbd\xd4\xa2\x86\x30\x13\xc5\x34\x04\x60\x04\x61\x4a\x49\xe5\x12\xb2\xbc\xdf\x1a\x46\x02\x4e\x0e\x19\x5d\x96\x48\xa8\xfd\x6b\x5f\xc7\x81\xea\x0a\x0c\x1e\xf2\x15\x2d\x35\xb1\xe9\x94\x25\xa0\x68\xc5\x0b\x8c\x5c\xfb\xa0\x82\xbe\x75\x55\x06\x96\xc0\x1c\x98\x7c\xce\xdf\xd9\xa7\xc4\xbf\x8a\x43\xe2\x0e\x72\x76\xfd\xd7\x83\x31\x21\xa7\x22\x64\xf0\x0e\xed\x2e\xc6\x77\xfa\xd4\x33\x63\x5f\x31\xee\x44\x00\x2f\x10\x3b\xce\xac\x76\xa8\xca\x1e\x28\xbe\x8b\x3b\x9c\xc4\x2e\xf1\x5e\xd9\x01\xb8\xc6\xdd\xa0\x76\xeb\xbd\x0e\xd0\xc5\x55\x6e\x6f\xf9\x58\xee\xf2\xc7\x11\x00\x21\x5d\xf9\x9c\x43\x53\xe8\x09\x1e\xfe\x32\x1a\x2d\xd2\xde\x43\xc0\xed\x5c\xa6\x88\xa6\x12\xd0\x20\xa0\xab\x13\xa0\xbb\xf0\xff\x78\xfd\xac\xd2\xf1\x84\xc4\xea\x80\x18\x66\xc5\x81\x6a\xa7\xc4\xaa\xda\x99\xf7\x2d\xe4\x45\xc6\xa0\x8a\x33\x1a\xb9\x2a\x50\x8d\xf0\xe4\x87\x61\x22\x15\x24\xbd\x03\x77\x19\x92\x7f\xc3\xa1\x0c\x89\xa8\x1e\x77\xe2\x3c\xfc\x1c\x2d\x44\xae\x7d\x73\x09\xa8\xb0\x34\xd2\xbb\x2e\x48\xca\xa7\x53\xe6\x13\x5e\xad\xe5\x48\x15\xcd\x2d\x8b\xd7\xc4\x2d\xc1\x84\xcd\x38\x26\x44\x06\xc6\xb6\x6f\xd5\x3d\x57\xeb\x37\x44\x66\xc8\x0d\xc9\xf9\x6c\x8e\x84\x42\x28\x54\xe8\x12\x1f\x54\xcc\x24\x4d\x09\xd0\xb6\x54\xe4\x86\xaa\xdc\xca\x0d\x9a\xcc\x21\x42\x49\x05\x49\x4b\x05\x38\xcb\x86\xd1\x74\x39\xd2\x86\x1a\xab\x29\x33\xe5\x0c\x4a\x3f\xff\x1d\xa8\xfe\x9d\xd7\x0e\x54\xff\x9e\xd7\x0e\x54\x7f\x07\xaa\xbf\x7a\x6d\x4d\x76\xe8\x0e\x54\xff\xf3\x82\x49\xda\x81\xea\x6f\x3e\x9e\xb0\x03\xd5\xdf\x81\xea\xdf\x75\xed\x40\xf5\x3f\x70\xed\x40\xf5\x5b\x5c\x9f\x01\xe7\xda\x81\xea\xb7\xb8\x76\xa0\xfa\xeb\xaf\x1d\xa8\xfe\xea\xb5\x03\xd5\xbf\xf5\xda\x81\xea\xb7\xbe\x76\xa0\xfa\x3b\x50\xfd\x1d\xd6\xe8\xc3\xc6\xda\x4e\xac\x51\xb2\x03\xd5\x77\xd7\x0e\x54\xff\xb3\x40\x54\x24\x3b\x50\xfd\x7b\x5d\x3b\x50\xfd\x1d\xa8\x7e\x9b\x6b\x07\xaa\xff\xb9\xb8\x4b\x76\xa0\xfa\x3b\x50\xfd\xdf\x8f\xa2\xbb\x03\xd5\xdf\x81\xea\xef\x40\xf5\x77\xa0\xfa\x77\xce\x62\x07\xaa\xff\x39\x98\x80\xda\xa4\xbc\x15\x06\xe8\x7d\xe0\x8a\x5c\x1a\x7a\x84\x0e\x30\x29\xa7\x53\xa6\x80\x73\xc1\x93\x57\xd2\xa7\x2a\x64\xc6\x66\x90\x95\x99\x21\x20\x1f\xb9\x8a\x9d\x5b\x7e\xee\xe0\x08\x00\xab\xb3\xca\x15\x3f\x79\xfd\x62\x0d\x36\x52\xeb\xbc\xc2\xb6\x59\xd2\x30\xe7\xd7\xa2\x5d\x7c\xfc\x96\x05\x5f\x57\x41\xe6\xd6\x3d\xc9\xa4\x76\x39\xee\xb0\x58\xc9\x9c\x0a\xc1\xbc\xbd\xc7\x0d\xf8\x51\x26\x8c\x09\x22\x0b\xe6\xa2\xd3\x94\x68\x2e\x66\x19\x23\xd4\x18\x9a\xcc\xc7\xf6\x49\xc2\x2f\x76\x95\x8f\xee\x3e\xd1\x46\x31\x9a\xfb\xcc\xfc\x9c\x72\x1c\x8a\xd0\x44\x49\xad\x49\x5e\x66\x86\x17\x61\x30\xa2\x19\x94\xd4\xa0\xa0\x0a\x8b\x01\x79\x71\x55\x12\xfb\xb0\x7a\x9a\x9b\x96\x8c\xc1\xe9\xc0\xda\x1c\x02\x22\x78\x5e\x98\x65\xc8\xe4\x65\x64\xca\x95\x36\x24\xc9\x38\x48\x6b\x78\x22\x56\x4f\xc3\x78\x43\x2f\xab\x85\x9b\xa9\x76\x53\x15\x29\xa8\xad\x85\xd1\x98\x17\x5b\x0d\xe8\x86\x4a\xb9\x76\x6a\xbe\x1e\x12\xea\x91\xd3\x70\xa1\xfd\x4c\x61\xa9\xbd\x64\xc1\xd1\xdd\x47\xd1\x70\x11\x62\x6c\x95\x38\x5c\x11\x3a\x14\x39\x78\xe2\x1c\xd6\xea\x39\x2a\x85\x02\xf2\xf4\x56\x8e\x01\x6c\x80\x60\x0b\x4b\x03\x2c\x61\x56\xbe\xd2\x5b\xa8\xfe\x93\x13\x7d\x24\x14\x5f\x31\xad\xe9\x8c\x9d\xb7\x0c\x34\xdc\x66\x91\x41\xac\xa1\xda\x18\x20\x85\x0c\xeb\x6b\xc3\x27\x55\x7e\x66\x5d\x0d\x22\x39\xce\x29\x28\x3f\x37\x8a\x1b\xc3\x60\x53\x01\x63\x0f\x62\x95\xcd\x12\xfc\xfd\x46\x96\xe7\x2b\x3f\x48\xf5\x63\xcb\xd4\x45\x8a\x39\x97\x13\x46\x26\x8a\xb3\x29\x99\x72\x48\xe4\x84\xd4\xca\x21\x42\x2e\x51\xf4\x02\x68\x6d\xed\x5d\x29\xbc\x2e\xeb\xe7\x35\x26\x3f\xbb\x89\x19\x55\x8a\x84\x46\x68\xb6\x50\x63\xca\xa7\x64\x06\xa9\x99\x4e\x5b\xfc\xf3\xd3\xbf\xfd\x95\x4c\x96\x56\xa4\x81\x66\x65\xa4\xa1\x59\x78\xc9\x8c\x89\x99\x5d\x2b\x3c\x9e\xf5\x2a\xc9\xb0\x02\xd0\xcf\x03\x27\xfe\xec\xab\xeb\x49\x5d\xc6\x3e\x49\xd9\xe2\x49\xb4\x7e\xa3\x4c\xce\xd6\x75\x48\x69\x9f\xb4\xdd\xd2\x24\x5a\x43\x66\x32\xe3\xc9\xb2\x33\xa1\x79\xec\x2f\x32\x97\x37\xa8\xeb\xaf\xa1\x9e\xaa\xe0\xaa\x90\x45\x99\xa1\xd3\xf9\x45\xa8\x2f\x2e\x35\x5b\xad\x02\x5c\x7b\x2e\xc0\x4d\xea\x86\x68\x22\xa7\x63\x46\xae\x7f\xa4\x74\xd5\x25\xce\x91\x17\x20\xc0\xc0\x10\x7a\x41\xb3\x6c\x42\x93\xeb\x2b\xf9\x52\xce\xf4\x6b\x71\xa2\x94\x54\xf5\xb9\x64\xd4\x72\xcb\x79\x29\xae\xb1\x87\x43\x00\x49\x90\x33\xab\x5a\x15\xa5\xf1\xa5\x0c\xeb\x5e\x18\x2b\xe6\x3d\x13\xf6\x66\x50\x35\x0a\x7b\xc7\x2b\x5b\xc7\x15\x6b\x21\x45\xc6\xe3\xeb\x98\xd8\xbe\x7a\xfa\xe7\xaf\x91\x74\x89\x54\xe4\xeb\xa7\x90\xb5\xad\x87\x78\x88\x81\xb7\x59\x41\x91\xd3\x2c\xb3\x66\x43\x4c\x94\x76\xa1\xd7\x11\xe1\x27\xa7\x41\xd3\x9d\xdc\xee\xad\x4a\x5d\x5d\xfd\x03\xf4\x28\x6e\x34\xcb\xa6\x43\xac\x4b\x0a\x66\xcd\x3e\x08\x86\x7d\xc7\x7d\xa0\x38\x6c\x0b\x14\xa0\x85\xcc\xca\x9c\x1d\xb3\x05\xef\xa3\x8d\x53\x6d\x34\x6f\xea\x67\x5c\x43\x09\xd8\x24\x93\xc9\x35\x49\xdd\x97\x51\xe6\x49\x13\x0b\xbc\xfd\x2a\xb4\xcd\xc1\xe9\x90\x7b\x73\xeb\xfb\xd7\xb2\x6e\x72\x5a\x14\xa1\x4a\x48\xd1\x9b\xda\x62\xc0\x99\x04\xc0\x82\x8e\x88\x32\x9d\xdd\xcc\x5d\x9d\xcc\x23\xf7\x46\x96\x6f\xb6\x1e\xa2\x75\xd6\x49\x77\x1f\x75\x35\xfb\xf6\x8e\xc9\x1a\x41\x54\x03\xfa\xd3\x50\xc0\xbf\xb1\xae\x64\xa5\x2e\x32\x94\xd6\x05\xc2\x40\x05\xc0\x92\x0f\xb0\xe4\xf6\x0e\xd7\x1e\xbc\x9b\xdd\x52\x8e\x6a\xeb\x22\x82\x57\x39\xa7\xc6\x29\x84\xde\x7d\x4d\x49\xc1\x94\xe6\xda\xca\xe5\x9f\xe0\x40\x1d\x65\x94\xe7\x91\x0b\x70\x33\x8b\x80\x87\x1b\x00\x94\xbb\x73\xca\x73\x99\xba\x01\x81\x15\x22\x78\xf4\x1a\xb5\xb6\xae\xd5\xf6\x28\x50\x37\xcd\x2a\x7f\xaa\x56\xb3\xce\x29\xed\x27\x81\x55\xe2\x5d\x9f\x13\x83\x84\xf7\x7b\xac\xfc\x31\x4c\xbe\x27\x36\x00\x8c\xd1\x6d\x6e\x9d\x13\xd6\x8c\x47\x3c\x28\x91\x4a\xef\xec\xc0\x31\xc1\x28\xb8\x3d\x13\xee\xa7\x64\xff\xf9\xfe\x46\x99\x24\x2e\x91\x92\x05\x9d\x75\xea\xe6\xd3\x58\xa9\xe6\xb0\x31\xd4\x84\x35\x83\xe0\xfb\x00\xbc\x06\x77\xb1\xb4\x42\xd2\x01\x9c\x24\x8c\x8e\xfa\x05\x76\x06\x02\x56\x64\xdf\xd0\x25\xa1\x4a\x96\x22\x75\xfe\xa5\xe0\xe0\x7b\xd5\x78\xf0\x99\x14\xcc\x3b\xce\x9b\x48\x15\xe0\xd1\xe7\x82\x3c\x1b\x3f\x7b\xfa\xb9\x48\x2a\x78\xc3\x86\xa4\x3a\x0b\x92\x0a\xf9\xd3\x46\xdf\xd5\x63\xde\xf7\xf4\xbe\xaf\x9c\x8b\xa5\x82\xb4\xe7\x1e\x30\x1b\x3e\xba\x51\xdc\xb0\xa8\xcb\xdf\x01\x18\x2e\xd6\x3e\x8c\x70\x19\x06\xeb\x7a\x49\x74\x5c\xa4\x6e\x40\x18\xba\x9c\x7c\x44\xbe\xe5\x18\x14\x1c\xb7\x75\x1e\x2e\x7d\x07\x0b\x8b\x17\x6a\x6f\x8f\x1c\xe0\x9d\xfb\x58\xd2\x3c\xd8\x28\x69\xb9\x45\x3b\x79\x57\x74\x40\xd9\x6c\x54\xcf\x17\x14\x7c\x70\x45\x8f\x2b\xf8\x1d\x9b\xd3\x05\x83\x52\x6e\x9e\x51\x95\x41\xcc\xf1\x12\xe7\x4e\x26\xa5\x21\x4c\x2c\xb8\x92\x22\x67\xc2\x90\x05\x55\x1c\x70\x71\x14\x03\x6c\x07\x6b\x8b\xfe\xf1\xe0\xa7\xc3\x0b\x48\x68\x18\x38\x50\x0a\x37\xcb\x52\x7b\x00\x9b\x78\x26\xd1\x70\x1f\xdc\x3e\x3f\x0f\xbb\x86\xc0\x73\xfd\xbc\xec\x73\xf2\xd2\x94\xd8\x98\xe5\x5d\x92\x95\x9a\x2f\x36\xc5\x49\x5c\x8d\xfd\x31\x6f\xb5\xcf\x8d\x7a\xff\x6a\xa1\x56\x4a\xf7\xc1\xb5\xbe\xa6\x40\x6f\x25\x60\xb2\xaf\x43\xd1\x5e\x1c\x03\x77\xae\x27\x87\xa6\x81\xe9\x73\x1e\x73\x71\x45\x85\x00\xe4\x98\xcd\x3a\xa1\x84\x4c\xd9\xc3\x71\x77\xea\xe9\x3d\x6e\x08\x8c\x99\x47\x15\x7c\x3a\x99\xb3\xb4\x04\x80\x27\xae\x11\x1e\xd5\x9a\x0f\xb4\xc2\xe1\x13\xd0\x27\xe8\x74\x1a\x40\x0d\xc4\x08\x9c\x83\xb8\xe6\xfe\xf7\xca\x43\x20\xf8\x0f\x74\x63\x44\x30\x4a\xed\x58\x43\x42\xb5\x2e\x73\x3c\x12\xd8\x02\x61\xca\x8d\x0e\x5d\x66\xbd\x76\x6c\x0f\xc6\x03\x0b\xaa\x3a\xac\xef\x25\xcb\x80\xb8\x3a\xac\xf1\xfe\x59\x34\x0e\x2e\xb4\xf6\x7f\x39\x82\x73\x09\x13\x10\x6d\x0b\x79\x9c\x12\xbc\xa4\x53\x0e\x6d\x94\xa8\x5b\xef\xcb\x35\xbf\x44\xd5\x01\xef\x00\x80\x18\x3a\x61\x99\x6e\x0e\x34\xa9\x36\xc5\xe1\x92\xba\x85\xef\xd8\x27\x97\x6a\xcd\x67\x02\x3a\x68\xda\xd1\x1e\xd8\x2b\xb3\xb5\xcd\xd4\x47\x1f\xdc\xd6\x5c\xad\x96\x85\x95\xd3\x62\xe4\xac\x5e\x23\x73\x9e\x3c\x60\x24\xf9\xc0\x29\x37\x6a\xa5\x6b\x35\xb8\xaf\x2f\x57\x3c\x3e\x3a\xf2\x6a\x8c\xc9\xa5\xcc\x5d\x8a\x93\x88\xfa\x78\xf9\x76\xaa\x56\x62\x28\x66\xd7\x02\x12\x8f\x78\x15\x8d\x87\xbe\x37\xbe\x0a\x1a\x9e\x13\x54\x72\x17\xc6\x05\x00\x4a\xd7\xce\x55\x66\x99\xbc\x81\xc4\x62\x1c\xd7\xd3\x36\xa4\xc0\x3c\x27\xa3\x46\x6f\xda\x71\x1d\x36\xf4\xee\xe7\xb8\x7b\x87\x1f\x7e\x0a\xe6\xe7\x00\x20\xdf\xe9\x71\xfc\xe7\xe9\xf9\x91\xff\xb3\x39\x93\x7a\x1b\x86\xdb\xef\x8a\x01\xb1\x6f\xbb\x6b\x8a\x9d\x8c\x3e\xf0\xf5\xd1\x9c\x0a\x1f\xb7\xba\xf5\x79\x4b\x9d\x98\xac\x9a\xce\x9c\x2a\xe6\x00\xe3\x2c\xe3\xd6\x05\x4d\x6e\x9d\x45\x40\x67\xbb\xf3\x86\x3b\x67\xaa\xcb\xc2\x77\xd8\xce\xe0\xc6\x30\x93\x8a\xca\x7e\xf9\xe2\xd7\x7b\x2e\xe6\x87\x7e\xb3\x6e\x69\xef\xfe\x4d\xad\x4f\xdf\xbd\x7e\xb1\xbe\x8b\xd7\xfd\x7e\x1b\x35\xc2\xbb\xd7\xfd\xb7\x35\xe1\xbd\xef\xd3\x7c\xf3\xb6\xfb\xbd\x58\x73\xb7\xef\x71\x3b\xee\xfd\x7d\xd0\x4a\xec\x91\x3c\x05\xd4\xcd\xe9\xf2\x5c\xa6\xf6\x74\x62\x92\xdc\xc3\xa0\x0d\x5a\xf3\xfb\xb6\xbe\xb1\x16\x1e\xad\xf6\x9e\xac\x76\x9e\x81\x86\xb6\x70\x0b\xf2\xa9\x43\x65\x13\x33\x52\xc3\x9a\x2a\x95\x62\x02\xba\xe4\x97\x90\x16\xe9\xbb\xdf\x23\x47\x07\xce\xec\x70\x3d\x11\x9c\x9e\x1c\x06\xc1\xe9\xd2\xe5\x72\x0a\x58\x9f\x11\xb6\xf5\xb4\x84\xec\x47\x90\x13\x88\x5d\x27\x85\x9d\xc7\xf3\x75\x70\x1a\xb2\x60\x22\x6a\x8d\xef\x54\xec\x91\xa5\xc0\x1a\xc0\x06\x6a\x0d\xe3\x3c\xfd\x43\x91\x51\x33\x95\x2a\x1f\x79\x5d\x72\x54\xd3\x28\xc8\x11\xe4\xe1\x68\x6f\x8c\x61\x32\x2c\x62\x70\x8a\x34\x63\x91\xe8\x0f\xaf\x2a\x52\x44\xac\x22\xa5\x50\x2c\x91\x33\xc1\xff\x53\x2d\x04\x08\xc1\xe0\x49\xa2\xda\x8a\x5d\x22\xca\x2c\x7b\x78\xd2\x42\x4b\x8d\x41\x2e\x98\x9a\x33\xfa\x40\xe2\x6d\xe4\xbf\xb8\x31\xaa\x56\xa5\xda\x01\x10\x38\xfd\xd8\x3f\xc4\xea\xd1\x32\x81\x42\x38\x8c\xc7\xfb\x2c\x67\x0a\xd2\xdf\xaa\x85\x94\xcc\xf8\x82\x09\x8f\x50\x7e\x94\xd1\xd0\x6e\xdb\x83\xb2\x3a\x94\xf4\xd2\xc8\x90\xe1\x40\xa8\x89\x70\x92\x21\x21\xca\x05\x57\xe3\x71\xa2\x5b\x5c\xb3\xee\xcc\x37\x46\xbb\xcf\x9d\x90\x64\x80\x9d\x22\x87\xd5\x2b\xe5\xde\x11\x5b\x03\xe2\x24\x09\xa4\xc2\x78\xbb\xc5\xa5\xc0\x7c\xf8\x11\x2e\x7f\xcd\xf2\xa0\x75\xc3\x38\xdd\x3a\x20\xc6\x56\x0b\x9b\x59\xe1\xb1\x44\x8d\xe8\x74\x5a\x7f\x12\xaf\x61\xf4\x43\xa1\x14\xe8\xea\x95\xf1\x78\x2e\x53\xab\xb2\x0d\x49\xd8\xca\xb8\x57\xb9\x0b\xce\xe0\x99\x8c\x0e\x23\x6a\x74\x4a\x31\x5d\x48\x6c\x15\x10\x3f\x76\x18\x39\xcb\xb8\xa9\x65\xe6\x61\xd3\xb7\x70\x34\x10\xcc\xed\x3f\x4c\xc9\xb5\x0a\xff\x8c\x9b\xf1\xf5\xd7\xa0\xed\x33\x31\xa7\x22\x41\x43\xeb\xc9\x35\x2b\xf4\x13\xcd\x67\xa8\xdc\xff\xf5\xeb\xaf\x41\xd3\xf7\x4b\xf2\xe4\xe2\xe4\xf0\xf8\xd5\xc9\x38\x4f\xd7\x38\x6b\x3d\xaa\x30\xa4\xbf\xfc\x18\x14\x66\xb2\x78\x36\x7e\xf6\x35\xe6\xe7\x71\x8d\x58\xc3\x11\xd0\x30\x96\x8b\xaf\xa2\x0c\x5b\xa1\xe3\xd7\xcd\x89\x9e\x07\x66\x1d\x6d\xd4\xd6\x28\xa8\x31\x4c\x89\xe7\xe4\x7f\x0e\xde\x7e\xf9\x7e\x34\xf8\xf6\xe0\xe0\x97\xa7\xa3\xbf\xfd\xfa\xe5\xc1\xdb\x31\xfc\xe3\x8b\xc1\xb7\x83\xf7\xfe\x8f\x2f\x07\x83\x83\x83\x5f\x7e\x7c\xf5\xfd\xd5\xf9\xc9\xaf\x7c\xf0\xfe\x17\x51\xe6\xd7\xf8\xd7\xfb\x83\x5f\xd8\xc9\xaf\xf7\x1c\x64\x30\xf8\xf6\x8f\x0f\x9c\x68\xcb\xca\x99\xae\xd5\x32\x9d\x2a\x64\x7a\xac\x8a\x29\x14\x63\x39\xf0\xdc\x36\xf9\x64\x75\x3f\x6e\x63\x28\x2f\xd5\xdd\x5f\x96\x11\xfb\xa7\x89\x99\xe5\xcd\x1a\xf9\x75\x26\x6f\x20\x07\x94\x4b\xab\xaf\x8d\xc9\x6b\x10\xbe\xe4\x8c\x2d\x98\x1a\xfa\x51\x5f\xda\x9b\xce\xc3\x3d\xb1\xa3\x70\xdd\x1d\x51\x0b\xd3\xdb\x0e\xea\x90\xcc\xe2\x74\xc3\x33\x29\xce\xc3\xec\xc2\x30\xee\xe4\x8d\x1e\x0e\x4c\xd7\x72\x7b\xfd\x32\x74\xd8\x07\x6c\xd3\xe2\x5e\x00\xf8\xeb\x98\xfc\x44\x15\x97\xa5\x76\xba\x54\x8c\x6e\x8e\xf9\x72\x61\x89\xc0\x05\xe3\xa2\x59\x61\x90\x50\x06\xe7\x03\x5a\x61\x7d\x0e\x83\xbc\x39\x5a\x2f\xd2\xb8\xb1\x9b\xbe\xf0\x8f\x52\x3e\xaf\x77\x05\x18\x1d\x85\xd9\x5a\xf9\xe5\x25\xb2\x8e\x27\x0a\xc3\xf8\x79\x80\x6c\xb0\x9a\x24\x8e\x32\xe7\x33\x9f\x3d\x0e\xef\x8f\xb6\x7a\xf4\x69\x20\xb6\x16\x5b\xda\xe6\xc4\xb7\x2d\x62\x28\x9a\xef\xd7\x81\x2c\xea\xf0\xd1\x31\x02\xb5\x2f\x9f\xaa\x8e\xe0\x1e\xd2\x09\x08\xc1\x51\xa2\xb8\xe1\x09\xcd\xf6\x40\x84\xf9\xaf\x92\xac\xb4\x7a\x6e\xfc\xad\x62\xc4\xdc\x48\x7c\x0a\xcd\xc8\x35\x5b\xde\x48\x95\x7a\xfd\xc2\x3f\xb1\xda\x0b\x6d\xfc\x23\xad\x35\x0b\xbc\x00\x7d\x2a\x2a\x67\x8a\x4c\x98\x0f\x17\x34\x6e\x5e\x8e\xc9\xa1\x58\xba\x58\xab\x88\x2b\x2a\x23\x18\x3a\xd0\x71\x50\x0b\xac\x11\x89\x93\x87\xfe\x69\x14\x6b\x5d\x6f\x73\xa5\x5b\x05\x32\x9c\x02\xaf\xbd\x78\x5f\xba\x54\xae\xa4\x0b\x4e\x87\xc2\x82\x34\xe9\xbf\xfe\x24\xdc\xc2\xea\x67\x5c\x30\xad\xbf\xb7\x5b\xd9\x45\xdd\xae\x53\x07\x05\xb5\xca\x8d\x0d\x7c\xb2\xca\x9f\x66\xf6\x48\x61\x40\xdc\x72\x74\x99\x56\x77\x8e\xc9\x21\x7c\x00\x05\x00\x56\x73\x84\x92\x41\x3b\x18\x37\xba\xd9\x4b\x1f\xef\x38\x3c\x3b\xf6\x89\xda\xa8\x74\xe8\x3a\x3a\x3c\xaa\xfc\xf5\x99\x80\xa6\xea\xd2\x85\xd9\x6f\x25\x85\xb6\xc0\x7b\x57\xaa\x64\x7b\xed\x54\x3d\xec\x3b\xf0\xe4\x2f\x5f\x3f\x05\x6d\x2f\x3c\x0f\xd8\xfe\x03\xab\x9f\xda\x26\x04\xb5\x4a\x05\x6a\x66\x41\x5d\xc4\xf4\xe0\x17\xdc\xdb\x4d\x2e\x42\x07\x85\xcc\xb0\x4d\x61\xcd\x5b\xf9\x91\x5b\x25\xfe\xb4\x4f\xf9\x19\x55\xd3\xbd\x7a\x78\xcb\xb6\x2e\xd9\x3a\xb5\xe7\xf6\x11\xd2\xab\x46\xc3\x5d\xd1\xb8\x25\xe1\x39\x91\x1b\x1b\x3b\x7b\xb8\x8f\x21\xf7\x17\x18\x17\x84\x40\x80\x3d\x2e\x8b\x0e\x79\xce\x2d\xf8\x0d\x94\xf5\x74\x56\x15\xf7\x2f\x70\x20\x52\x54\xba\xe1\x4a\xb9\x46\x08\x67\x83\xde\xe1\xb4\xc2\x43\xa8\x7d\x1b\x92\xd7\xe2\x05\x16\x03\x0c\x51\x51\xac\x41\xad\xe0\x4d\xbd\xd6\x44\x3e\xf9\x83\x7b\xf7\x11\x4e\xb9\x0d\x53\x78\xf8\x72\x47\x96\x6f\x47\xe9\xbf\x7f\xd1\x18\xab\x46\x7a\x35\xcb\xde\x49\x48\x5e\xb5\x7a\x73\xec\x93\xcc\x94\x2c\x0b\x1f\x36\xae\xf7\x6d\xab\x9a\x95\x60\xb4\x13\xdb\x1a\x0b\x59\x1f\x3a\x38\x6f\x80\x80\x59\xe5\xf5\x4b\x49\x82\xe6\xbd\x97\xba\x58\xf2\x85\x1e\x10\x55\x8a\x7a\x5b\xf7\x28\xf0\xba\x97\xb1\x19\x4d\x96\x7b\xf5\xe7\xac\x0b\x73\xa3\xc3\x97\xe7\x88\x0f\x8f\xcf\xab\x0a\x38\xa0\xce\x03\xf4\x07\x3c\x6b\xa0\x1a\x94\xda\x4d\xd1\x8b\x7c\x5f\x81\x88\x9e\x39\xd5\xc1\xb3\xf0\x97\xaf\xff\x32\xf2\xbe\x43\x9c\x4a\xb3\x96\xdb\xd5\x64\xaf\x75\x27\xfc\xb9\x95\x2b\xe0\xc1\xf4\x17\xa2\xda\xbd\xaa\x9e\xb5\x2d\xb6\xfa\x14\xd7\x05\x90\x03\xfa\x43\x82\xf4\x0f\x4f\xbf\x4b\x3b\x5b\x3f\x88\xdf\xaf\x6a\x88\x4f\xb2\x5c\xf5\x90\x43\x97\xd3\xda\x6c\x8a\x33\x97\x59\x0a\xe7\xca\x39\x99\xfc\xa3\x08\x35\x46\xf1\x49\x69\x9c\x57\x38\x91\x79\x5e\xaf\x27\x75\xed\x03\xc7\xa4\x2a\x28\x8c\x8d\x67\x20\xfc\x31\x21\x97\x8c\x61\xeb\xcc\x68\x1e\xc0\x96\xfd\x52\x3a\xe7\xb2\x9c\x62\x9f\x73\xb4\xd9\x3e\x91\x43\xaa\xbd\xf4\x76\x91\xc7\x8e\x41\x8a\xbd\xc3\x60\xd4\xc4\x01\x42\xe4\x87\x2b\xdd\x8c\x1b\x82\x0c\x52\xad\xab\x88\xb4\xcb\xbc\xb2\x6b\xa1\x11\x3f\x17\x68\xf9\x47\xec\x7c\x0a\x69\xa5\x10\x26\x45\x57\xec\x8d\x1d\x62\xce\x0b\x34\xc1\xa9\x09\x3f\x87\x04\x07\xfb\x75\x0c\x4b\x01\xad\x3c\x9f\xa1\x0d\x2c\x6f\xc0\x09\xfe\xfd\xe9\x71\x38\x23\xf6\xae\x17\x97\x18\x03\xfb\x6a\xec\x1a\x13\x9b\x19\x4f\xc9\x04\x93\x5a\x2c\x7b\x3d\x10\xec\x06\xd3\xe4\x9d\x9f\x38\xa8\xe1\x0b\x9f\x3e\x8e\xa3\x85\x87\xbb\x21\x07\xe4\x4f\xae\x45\x2c\x53\xde\x88\x9f\x70\x97\x46\xfb\xfa\x62\xdf\x7b\xe7\x6f\x46\xea\x66\x34\x1a\x8d\x5c\xec\x1b\x98\xfa\xb0\xb6\x06\x81\xf7\xe7\x32\xe5\xd3\x65\x63\x25\x2c\x99\x57\x8f\x00\x8a\xa4\x62\xe9\x66\xd7\xbd\x9b\xf1\xc3\xa1\xcb\xbb\x39\x02\xbb\x40\x55\xac\x89\xab\x77\x0d\xc7\xad\x0b\xd5\xa3\x59\xad\x2b\xc4\x77\x39\x45\x22\x85\xca\x82\x5b\x36\xc6\x3b\x8d\x1c\xd5\x38\x1c\x43\x34\xea\xd9\xbb\x42\x22\x4a\x32\x54\xee\x40\x3f\xbb\x66\x34\x06\xfc\xe4\xf6\x54\x41\x02\x62\xed\xd4\x38\xfd\x03\x03\x80\x7e\x11\xc8\x84\xda\x21\xc3\x74\x0e\x1a\x74\x32\x18\x93\x53\x47\x5a\x60\x3f\x0a\xe9\xba\xe2\x11\x29\x08\x2b\xe6\x2c\x67\x8a\x66\xf5\x07\xb9\x0a\xe6\xe7\x96\xdd\x2a\x4b\xa5\x18\xf1\xc8\x69\x81\xdc\x16\x98\x67\xca\x95\xef\xaa\x1b\x45\x22\xf7\x5e\x8b\x0b\x29\xcd\x2b\xae\x41\xd5\x71\xbe\x13\x54\x4c\xf7\xd6\x09\x34\xff\x5d\x95\x0e\xde\x95\x92\x3f\x59\xb8\x8f\xf8\xce\x78\x7d\xf0\x5a\xcb\x41\x2c\xd3\x7a\x68\xf3\xbb\x37\x0e\xe0\xa8\xd6\x63\xb8\xf2\x02\xaf\x69\x6d\xb7\xd2\xd7\xee\x13\x37\xb6\x73\x19\x6b\xd4\xd4\x90\xc4\x3e\x75\x33\xf6\xcd\x71\x2f\x20\x99\x33\x09\xe7\xa4\x23\xd1\x9c\xae\xf6\xd3\xab\x48\x04\xbc\x83\xa1\x51\xa8\x90\x62\x04\xfd\xad\x4a\xed\xe3\xb4\xca\x7b\x88\x6b\x02\xc8\x35\xdd\x44\xb1\x89\x8d\x13\x69\x65\x01\x58\xd5\x49\xe8\x52\xb1\x90\xbd\x99\x4a\x56\xf5\xba\xa2\x9a\xbc\x39\x3d\x26\x4f\xc9\x01\x64\x2e\x87\xea\x75\xc4\xeb\xb0\x96\x6f\x23\xbd\x76\xea\x87\xa8\x5b\x3a\x0e\x2c\x43\x48\xe4\x45\xbe\x11\xa8\x14\x41\x0c\x3b\xd0\xd1\x5b\xda\x37\x6e\x9a\xc6\xdb\xd2\x63\xbb\xfa\x84\x90\x12\xd4\x03\x0f\x7a\xd3\x82\x07\xc5\x8a\x75\x1f\xcd\x37\x37\xbd\x7b\xbf\x77\x0e\x55\xcf\xea\xeb\x81\xa8\x2e\x4f\x60\x40\x04\xca\x78\x67\x9c\x1a\xff\xc0\xce\xee\xab\x80\x48\x0e\x15\x2a\x60\x27\x28\x2a\x52\x99\xaf\x3c\xcd\xee\x26\x18\x6f\xd1\x6e\xee\xc8\xee\xb6\xab\x53\x79\x6b\xb7\xea\x50\xb0\xf1\x7b\x28\x0b\x7e\x09\xbe\x02\xae\x03\x25\xa0\xf3\x00\x12\xe6\x57\xcc\xd6\xce\xa8\x11\x9d\xab\xa4\x94\xcc\x5a\x16\x1a\xd6\xde\xfa\x42\x66\xae\xc0\xc3\xbf\xb6\x1d\x78\x6b\xdf\xda\xb4\x8c\x2a\x34\xd9\xcb\xb2\x68\xbc\x35\xb8\x73\xb6\xf5\xad\xcb\x56\x52\x9a\x34\xdf\x1a\xf2\x7f\x6b\x6f\x0d\x72\x77\x1b\xdf\xba\x9e\xee\xdd\x83\x30\x71\x03\x12\xe9\x92\xce\x5d\x97\x85\x26\x00\x4c\x95\x10\x0a\x4e\xa8\xc7\xc5\x47\xbb\x40\x04\x60\x8a\xd5\xa7\x66\xdd\x32\xa1\xd9\x1c\xbb\xdc\xb7\xdb\x67\xd2\xdc\xeb\xe6\x90\x51\xee\x06\xb5\xb3\x85\xcf\xa2\x0c\x4a\x8a\xe8\x55\xb2\x8a\xdf\x34\x62\x35\xce\x4d\xe7\x7e\xe9\x93\x27\xac\xfc\xad\x12\x3a\xe3\x5f\x1b\xe9\x1a\xef\x7a\x94\x7c\x0a\x13\x64\x98\x9e\x59\x50\x33\x1f\x12\xc5\x32\x04\xbe\x75\xe7\xec\x1a\x4d\xa9\xfd\x5a\x96\xa8\xa7\x58\xff\x68\x50\x58\xa0\xf1\x36\x8c\x0c\x2e\x1f\xaf\x86\x4c\x91\x7f\x71\x4d\xf6\x5e\xfa\x05\xd8\x7b\xcc\x0c\x7a\x0f\xdf\x27\xec\x1d\x7a\xb1\xae\xb9\x48\x1d\x22\x6c\x6d\x69\x42\x46\x32\xea\x86\xde\xc3\xe4\xcf\x3a\x55\x0c\x9c\xbd\x61\x69\xc8\xa8\x35\x31\xb8\xc8\x99\x8f\x9f\x8e\x6e\x51\x32\xbd\x4f\xc5\x3f\xa4\x39\xcc\x1b\x01\x3b\x2d\xa0\x58\x44\xc8\x35\xf7\xf9\x77\x69\xd7\x1d\xb2\x0b\xeb\x5d\xa9\xea\xe9\xc8\x7e\x0f\x03\x0e\xd7\x0c\x8b\x84\x22\x15\xbe\xc2\xea\x74\x76\xa1\x6b\x7e\xdd\x50\xbd\x87\xb0\x3b\x2e\xd3\x76\x45\x3a\x61\x36\x56\x4e\xd5\x92\x7c\x7f\x7a\x8c\x1a\x78\xcd\x10\x10\xd2\x3f\x3a\x50\x4a\xea\xe0\x18\xa9\x58\x6e\x81\xe2\xdc\x0e\x12\xa7\x35\x20\x4e\x57\xa8\xe1\x4e\x66\x22\xd6\xac\x75\xa4\xa9\x4b\x57\xf9\x36\x97\x59\x4a\x68\x20\x30\xe1\xab\xde\x52\xff\x1c\x8c\xb7\x47\xe5\xae\x63\x6b\x7c\xb9\x58\x76\x29\xaa\xc2\x18\x7f\xff\x41\x53\x25\xf0\x67\x7a\xe0\x6a\xbf\xbd\x67\x2a\xa3\xa5\x48\xe6\xbf\x17\x92\x59\xb3\xfa\x21\xd4\x41\xc9\x35\x53\x82\x65\xa4\xa0\x8a\xe6\xcc\x84\xee\x8e\x9a\xb5\xc1\x3a\xea\x08\x95\xd4\x0d\x28\xa9\x03\xc8\x51\xfb\x2e\x8d\x5d\xe1\x91\xba\x80\xce\xac\x69\x5d\x37\x45\xe9\x68\xa7\xb4\x74\x1d\x4d\x5b\x0e\xde\x19\x09\xa4\x53\xdf\xc5\x3a\xea\x17\xb6\x2c\xd8\x8a\x77\xab\xd7\x35\xf7\x60\xdd\xfc\x8c\x03\x56\x00\x0c\x3e\x93\xe1\xa1\xee\x32\xaf\x32\xad\xc2\x9e\xed\xeb\x15\x57\x54\xbd\x47\xc4\x27\xf6\x95\xb7\xe6\xbb\x50\xf6\xf8\xa8\x3c\x5c\xb3\x5c\xd3\x23\xc5\xa0\xc0\x96\x66\x97\x05\x4b\x7a\xd0\xb0\xbf\x7f\x75\x79\x58\x1f\x14\x84\x12\xe4\x66\xdb\x3d\xb1\xdf\x47\x15\x06\x37\x6c\x32\x97\xf2\x9a\x1c\xac\xa9\xf2\x8c\xea\x6b\x34\x9f\xe9\x27\x8e\xbc\x47\x76\xde\x03\xc2\x05\x60\xf7\xae\x62\x1e\xfb\x87\x24\x61\x16\xb0\x57\x2e\xc5\xcd\x89\xe1\xd5\x69\x02\x8f\xc2\x8c\x9a\x4d\x18\x38\xab\x9b\xf1\xf0\x7c\x2f\x7f\x7d\x60\x43\x6e\xab\xf6\x5d\xbb\x6a\xe8\xd0\xd8\xc8\x92\x38\x73\xdb\xaa\xef\x3d\xac\xc3\x0f\xd5\x68\x31\xd4\x1c\x9f\xd6\x50\xf0\x2b\x43\x29\x04\x2b\xf7\xa1\x1b\x97\xfb\xe9\x7e\xac\xd5\xd7\xab\x9a\xa0\x8c\xdd\xd7\x1f\x8a\x38\x83\x62\xc2\xe2\x62\xc3\xa8\xee\xa7\x59\x6f\xe8\xf8\x6d\x34\xd5\xa3\xca\x83\xe4\x93\x11\xa7\x19\x9d\x41\x37\x9f\x46\xf1\x0e\x30\x57\x59\x62\x54\x33\xbe\xd9\x57\x68\xfa\x4e\x15\x00\x94\xad\x91\x8b\xf9\x60\xa6\xab\xf2\x80\x2c\x90\x43\x3b\x6f\xbb\x2c\xe7\x3e\xf7\xd9\x4f\x01\xdc\x14\xa1\x46\x55\x5b\xda\xc1\xfc\x0d\xbe\x60\xb5\x05\x46\xce\x7b\xe0\x61\x7a\x0c\x26\x59\xa1\xbc\x80\xdf\x53\x92\xf3\x77\xf6\x29\xf1\xaf\xe2\xe2\x04\x91\x42\x94\x78\xfd\xd7\x03\x6b\x8c\x55\x96\xdb\xd0\xee\x62\x7c\x67\xd4\x45\x42\xc0\x17\x67\x58\x5d\x80\x2f\x10\x47\x5a\x5c\x43\x88\x2e\xf4\xdd\x1e\xc6\x2d\x84\x4a\x7b\x3a\xea\x10\x32\x75\xc3\xd9\x8d\xf6\xe2\xbb\x4b\x08\xd5\xde\xd2\x47\x18\x75\x55\x46\x7f\x72\xd1\xfe\x29\x79\x98\x66\x6a\xc1\x13\x76\x98\x24\xb2\x14\x9d\xb2\x50\x8f\x99\x7d\x05\x6a\x58\x7a\x59\x1b\x13\x3d\xee\x29\x7c\x8b\x85\xf7\x34\xe3\x14\x21\x98\xea\x77\x62\x4d\x5e\x35\x0e\x78\xec\x1b\x33\x74\x24\xa3\x0d\xa3\xed\x32\x4a\x3b\xae\x50\xd7\xcc\xfa\xd5\x37\x5e\x27\xe1\x1a\x2b\xe8\x9c\xf5\x2b\x59\xf3\xf7\x2b\x59\x30\x54\x5f\x57\xc0\x54\x0c\xaa\x96\xc2\x61\x8a\x3e\x77\x2f\x3a\xa2\xf8\xd4\x56\x60\x55\x2d\x56\xd7\x58\xbe\x67\x5f\xfe\x50\xbf\xf8\xef\xe3\xb3\x6e\x99\xe3\xa1\x27\x0f\x96\xc3\xcc\xdd\xd0\x41\x55\x8f\x51\x08\xe2\x6a\x46\xfb\xe4\x21\x51\xd4\xb5\x1b\x70\xad\xe6\x32\x46\xd1\xa7\x42\x0e\xa2\xc4\xfe\xc1\xd8\xf2\xf4\x2a\x5a\x8e\xac\xde\x75\x86\xcb\x19\x15\x3a\xaa\x58\x65\x30\xb4\xcf\x8a\x0d\xf3\x41\x41\xe8\x76\xdb\x79\x0f\x0e\xbc\xd3\xb5\x7e\x87\x36\xaa\x4c\x0c\x29\x8d\xb6\x9f\xe3\xc3\x3d\xc3\xbc\xc7\xe3\x15\x9b\x71\x6d\xd4\xd2\xf7\xac\x9b\x46\x93\x70\x5e\xa1\x70\xcb\x35\x5b\x92\x1f\x7e\x3c\xf9\xc7\x3f\x5f\xbe\x3e\x3a\x7c\xf9\xcf\x57\x87\x47\x3f\x9c\x9e\x9d\xbc\x7d\x7b\xf9\x8f\xcb\xab\x93\x57\x6f\xdf\x1e\x21\xa0\x8a\xab\xde\xbd\x64\xe6\xed\x5b\x47\xa9\xfa\xed\xdb\xab\xa4\xe0\xc5\xdb\xb7\xe7\xde\x07\x82\xdd\x28\xfe\xfb\xf8\x0c\xf8\x27\x16\x91\x85\xb4\x27\x90\xad\xb8\xe8\x30\xef\x39\xd5\x55\x92\x65\xad\x3c\xa7\x05\x82\x69\x5b\x71\xb7\x16\x3f\xaa\xd3\x61\xb7\x03\x56\x6d\xa4\xbc\x8b\x37\x78\xe9\xc8\x84\x99\x1b\xe6\xaa\x1e\xd7\x02\x94\xd1\xa8\x8e\x3a\xc2\x1c\x5b\xd7\xaa\x06\x95\x33\x49\x16\x9c\xdd\x20\xc4\x06\x76\x05\xac\xfa\x25\x41\x15\x34\x56\xc2\xae\xc2\xa0\x81\x92\x54\xc8\x34\xf4\x86\x6a\xf8\xa5\x57\x7c\xd2\xb5\xaa\x1b\x04\xba\x63\x29\x39\x3f\x3d\x26\xcf\xc6\xa8\xe4\x9c\x1e\x23\xee\xe6\x5a\x58\x2e\x6f\xa9\x5a\x81\x8a\xd2\x77\x4d\xd5\x41\x45\x00\x6d\x98\x51\x0b\x0a\x28\x27\xa9\xcc\xe9\x43\xbb\xc0\x7d\xa0\x7e\x05\x7b\x74\xfe\x56\xd2\x0c\x75\x80\x73\x99\xae\x72\xa6\xbd\x6f\xfc\x47\x7f\x1f\x7f\x13\xe6\xf1\xf7\xf1\x37\xd0\xfd\xd3\x2f\xdb\xdf\xc7\x7a\x91\x8c\xbf\x71\xf5\xd4\xc4\xdd\xb4\x36\x47\x78\xa5\x38\xca\xe9\xb3\xf8\x1b\x78\x36\x05\x7d\xf7\x93\x94\xbb\xf4\xd8\x46\xb5\xe7\xe6\xa9\xa8\x05\x42\xa9\x76\xa2\x18\xc5\x54\x73\x92\xb2\x8c\x55\xb0\x37\x5b\xd0\xbd\xf3\xf6\x76\xa6\x3e\xd6\x56\x6b\xf6\x1a\xfb\xa6\x82\xbe\xf4\xbb\xef\x09\x1b\x1b\x0c\x7f\xaa\x5a\xec\xb7\x38\x00\x1d\x81\x1d\x1e\x14\x36\x32\x32\x63\xb8\x3f\x5d\x4e\xca\xda\xba\xba\x7d\x1d\x8f\xde\x66\x21\x36\x51\xbc\x7e\xe5\x91\x5b\x2d\x45\x5c\x85\xf9\x83\xa5\x81\xbd\x0e\x31\xb8\x8a\xdf\x40\xb5\xdb\x92\x58\xa9\x65\xd0\x93\x11\x17\x94\x1a\x05\x5d\x19\xbf\xb9\x66\xcb\x21\xe2\x7f\xa0\x12\xf2\xf7\x08\x82\x3a\x54\x50\x23\xce\x9c\x54\xe4\x1b\xff\xaf\xbf\x3f\xd4\x5a\xeb\xe0\x47\xed\xe2\x45\xc5\x97\xea\x1c\xf9\x3a\xc1\x2a\x98\x3a\x20\x08\xae\xac\x2b\x90\x31\x12\x97\x6b\x4c\x4e\xa0\x4c\x16\x35\x52\x07\xc3\x9b\x65\xb5\x9b\xb5\x6f\xa9\x59\x03\x93\x00\xff\x4b\x54\x1d\x73\x26\x2f\x5d\x65\x26\x00\xfc\x4c\x99\xaa\x3e\x01\x06\x73\x26\x4f\xde\xb1\xa4\x7c\x28\xe8\x0e\x5e\x9d\x7c\x7f\xd7\xac\x7b\x93\xb3\x1f\x59\x00\x3f\xc2\xb5\xb1\x5a\x78\xa8\x4c\xa8\x4e\x67\x94\x9c\x76\xf7\xda\x5e\xb3\xa5\x0e\x98\x72\xd7\x38\xba\x2b\x82\x0e\xf4\xeb\x05\xd9\xc9\x3b\xae\x8d\xfe\x5f\xbe\xc3\x5a\x3e\xa9\x7a\xdb\x51\xcc\x12\xab\x46\x8f\xf0\x04\xed\x9f\xf0\x98\x4f\xbd\xe0\xfe\x05\x3a\xaf\xfa\x6b\xbf\x12\x11\x62\x20\xb5\xef\xb4\xaf\x5d\x7a\x92\x14\x50\xa8\x16\x43\xcf\x55\x89\x35\xf8\x63\xa4\x4f\x5c\x43\x58\x97\x13\xab\xe4\xd5\xc5\x8c\xfb\xc8\xdd\xc4\x01\x84\x84\x2f\x68\xc6\x84\x83\xed\xcd\xd2\x84\x2a\x0c\xd1\x3b\xfc\x21\xed\x90\xbf\x1d\xf0\x86\x95\x71\x8e\x93\x55\xbb\xac\x5d\x28\x8f\x2a\xc3\x93\x32\xa3\x8a\xd8\xf3\x38\x93\xea\x81\x30\x45\x78\x75\xeb\xf4\x17\x48\xb4\x43\x03\xec\x3a\x7f\x6f\x8e\xd8\xc4\x75\x74\xda\x8b\x35\x99\xa0\xbe\xa6\x7e\x50\x0e\xea\xc8\xe1\x72\xea\x79\x53\x60\x14\x31\x32\xa0\xa9\x39\xc7\xf9\x0c\xfc\xdf\x83\x48\x78\x84\x93\x39\x26\xdf\x85\x6a\xf1\x21\xa9\x7c\xc6\x50\x93\xea\x9e\xe9\x8e\x8d\xdb\xae\xea\x50\x4f\xa5\x82\xb6\x8d\x07\xa9\x84\xdf\xb0\x05\x4f\xcc\x60\x4c\xfe\x5f\xab\x29\x82\x13\xd9\xab\x93\xee\x98\x85\x3a\xdc\x0a\x9f\xf0\x29\x39\x80\x9f\xc5\xaa\xe4\xc0\x07\x8a\x1c\xf0\xe9\x23\xcb\x86\xe9\x10\xe1\x5e\x13\xdd\xae\xb1\x51\xd4\x14\x1b\xa4\x11\x24\xbf\x0c\x1c\x32\xf0\x44\xae\xdd\x29\xad\x79\x6e\x43\x9c\xc5\xb3\xd0\x40\x38\xff\x06\x1f\x3d\x51\x6c\x06\xe7\x0f\x4f\xcf\x27\x3c\x7d\x46\x16\x32\x93\xb3\xe5\x65\xa1\x18\x4d\x8f\xa4\xd0\x46\x01\x6b\xe8\x02\x07\x77\xdb\x98\x51\xa7\xb0\xb9\xbc\x21\xd4\x95\xb3\xcb\x29\x62\xf3\xc9\x72\x36\xc7\xde\x08\xf0\x43\xdf\x55\xd7\x4f\xd1\x19\x9d\x7a\x4c\x2e\x43\xef\x03\x20\xf0\xd0\x4a\x01\x46\x01\x87\xc7\x0d\x5d\xba\xc3\x44\x27\x3c\x65\x3a\xca\x51\xf6\x93\xc1\xd0\xcf\xad\xef\x0f\x5c\xf9\xf0\xec\xf8\xa1\x0d\x27\x36\xa8\xd0\xde\xf2\x2a\x41\x33\xc2\x55\xaf\xd6\x37\x68\xa4\xb0\x6e\x34\x97\x4e\x53\x45\xe8\x5a\xbf\x32\x9f\x50\x37\xed\x82\xd5\x94\xd3\x77\x97\xd7\xec\xa6\xc5\x2f\xfd\x8b\xfe\xc8\x1e\x9e\x0a\x36\x02\x7b\xf4\x8d\xd0\xd4\x70\x3d\x85\xce\x34\x9f\x50\x1f\x87\xa2\x83\x76\x0d\x34\xf0\xaa\xd7\xee\xc4\xa3\xf9\xa2\xf0\x00\xcf\x58\x23\x16\x97\xff\x57\xd9\x41\x28\x00\xb1\x08\x22\xf4\xde\xb0\x27\x28\x71\xfd\xa8\x8c\xac\xe2\xd0\x18\xa9\x28\xf3\x09\x53\xe1\xec\xa3\x33\x80\xab\x06\x12\x6f\xe3\xec\xb7\x67\x8c\xad\x33\xe1\xba\xa6\x95\xc1\xf2\x9c\xbc\xb3\x9a\x87\x6e\x97\xa8\x84\x57\xbd\x9d\x5c\x63\x50\x0c\x8f\xf9\x04\xce\xc6\x36\xd4\xda\xba\x80\xd9\x1b\x7f\xd2\x96\xcf\x55\x57\xb7\x86\x94\xa4\x5b\x53\x4a\xb2\x26\x51\xfa\xd6\xd7\x6f\xf4\x86\x89\x0b\xfe\x9c\x53\x48\x0f\x51\x81\x47\x07\x36\x15\x95\x60\x87\x9b\x41\xa9\x77\xda\x9c\x35\x8a\xec\x4d\xf8\xbb\xae\x9d\x9f\x3a\x34\xb5\x24\x3d\x34\xb6\x24\xc0\xcb\xae\x5b\x70\xc0\xf8\xf7\x7e\xb1\x5a\x0f\xd2\xbd\xc5\x25\x69\x6f\x50\x57\x57\x8d\xa0\xae\x2b\xd3\x1a\x29\xab\x66\x5a\x57\xcc\xae\x32\xac\x3b\x3d\xbb\x87\xbe\x6f\xa4\xa3\x8d\x5b\x5d\xb5\x85\x90\x0f\xb0\x76\x29\x04\x98\xe4\xd4\x9f\x8e\xb5\x36\xef\xa9\x18\x92\x33\x69\xec\x7f\x22\xf3\xf7\x58\x32\x7d\x26\x0d\x7c\xb2\x15\x4b\x89\xaf\xd0\xe3\x42\xfa\xae\x09\xd8\x0f\xc4\xf2\x4d\x17\xa2\xb5\x12\xcf\x2f\xd8\x1a\xc3\xe2\x54\x10\xa9\xfc\x8a\x05\xeb\x42\xbb\x21\xe2\xb0\x82\xc3\xd8\xba\xd5\x38\xb1\xe3\xc4\xeb\x7c\xc7\x70\x6e\x28\xc8\xfe\xc2\x6f\x00\x6b\xb5\xc8\xa0\x40\x20\x2d\x15\x42\xde\x5a\x5d\xd3\xb0\x19\x4f\x48\xce\xd4\x0c\xfa\x64\x27\xf3\x3e\xb6\xaf\x8b\x5c\xc1\xab\xa3\x74\x89\x27\xd3\x81\x96\x40\x64\x83\x8a\xd5\xa3\x0a\x80\xe3\xa1\x58\xcb\x29\x58\x52\xff\x27\xf8\xa0\xff\x2f\x29\x28\x57\x00\x91\xeb\x62\xc7\xf1\x77\x2e\xfa\x12\x0f\x63\x47\x58\xf1\x2d\x51\x41\x18\x56\x32\xd9\xd1\x9b\x8a\xc7\x90\xdc\xcc\xa5\x46\x61\x18\xdc\x1f\x7b\xd7\x6c\xb9\x37\x5c\x21\xbd\xbd\x53\xb1\x57\x05\x86\x6b\xc4\x16\x84\x30\x64\x10\xee\xc1\x77\x7b\x1f\x4f\x57\xe9\x24\x6c\xfb\xe8\x55\xd0\x9c\x50\x4b\xba\x72\x36\x4f\x67\xcd\x7f\xff\x15\x0e\x14\xd9\xe7\x18\x13\x9c\x29\x86\xc5\x98\x60\x4a\x83\xa2\xee\x9a\xd9\x94\x82\x2d\x98\xdd\xac\x94\x6b\x87\x07\xe8\x53\x0c\xfe\xb5\x62\x12\xfd\xff\x8f\xe5\x99\x34\xde\x6a\xff\x97\x77\x7b\x21\xfd\xbd\xe3\x79\x99\x23\x6e\x96\xb1\x96\x42\xca\xa7\x1e\x37\xd8\x67\x36\xd4\xed\x85\xba\xd9\xea\xe8\xd8\x50\x35\x83\x0c\x47\x67\x2f\x78\x32\x9b\x65\x72\x42\x33\x92\x73\x61\x1f\x33\x26\x2f\xa4\x22\xec\x1d\xcd\x8b\x8c\x61\x3d\x1c\xf9\xd3\xe8\x3f\x52\x30\xe2\xa2\xe1\x43\xe2\xd7\xa2\xea\x8a\xf6\x0c\xa9\xb6\xea\x1f\x10\x52\x1d\x6a\x06\x58\x70\x5b\x68\xf2\xec\xc9\xb3\x27\x4f\x9f\x93\xf7\xc4\x0e\xfd\xcc\xfd\xf7\x2b\xf7\xdf\x3f\x91\xf7\xe4\x3d\x21\xe4\x9c\x90\xda\x7f\x09\xfc\x77\x44\xf8\x34\x9e\xc3\x33\x3b\xcd\x44\xe6\xee\x85\xc1\x93\x1b\xca\x56\x43\xbb\x41\x23\xdd\xd0\x50\x33\x94\xc8\x9c\xc1\x1c\x9e\xfd\x2f\x7f\x0f\x04\x5c\x0d\x76\x84\x84\x49\x1d\xc0\x94\x06\xe4\x06\x5c\x53\x39\xbd\x46\xb3\xec\x30\x31\x25\xcd\xec\xc3\x0f\xbe\x1a\x3d\x1d\x10\x29\xea\xb7\x2f\xb8\xb4\x2a\xb0\x9f\xe1\xc1\xb3\xc1\x78\x65\xca\x5f\xad\x99\x72\xa3\x39\xa2\x2b\x1a\xb4\x83\xde\x4e\x35\x9e\x60\x0e\xc5\xf2\x86\x2e\x03\xd9\x78\xb3\x74\xc6\x17\x01\x62\x3f\x82\xf2\x80\x98\x1d\x50\x01\xf7\xe8\x4c\x38\xe8\x92\x70\x33\x26\xa7\x66\x7f\xdf\xb7\xe2\xb4\x1a\xb3\xef\x05\x70\x1c\xa3\x4e\xc2\xc2\xc3\xa6\x3f\x6d\xe4\xf4\xb6\xc0\x38\xeb\xd5\x39\xfa\x20\x30\x7f\xf7\xf4\xca\xbf\xd1\x83\x53\x3d\x8c\xe5\x4f\xb0\x65\xfd\x72\x8a\x85\xbe\xd8\x18\x73\x0c\x5d\x4f\xdd\xda\xbb\x84\x11\x54\x9d\xdd\xe9\xe1\x3a\x58\x4f\x1c\xf2\xef\x93\xa8\xd3\x94\x42\x2f\x1d\x4f\x99\x62\xbe\xaf\x66\x9c\x5e\x14\xfc\x52\xe4\xe7\xea\x4e\x4c\x2b\x82\xf8\x2b\x0e\xf4\x77\x4c\x67\xdf\x9b\x94\xc9\x35\x33\x5e\xee\x28\xc8\x88\x28\x4a\x43\x26\x34\xa3\xc2\x6a\x30\x2b\x7e\x08\x23\x71\x30\xfc\x25\x10\xcc\x1a\x7a\xf9\xd4\xf1\x91\x95\xd3\xd1\x9d\xe9\xff\xdc\x1c\x32\x8a\xc8\x3a\x47\x61\xca\x68\xe6\x53\x29\x00\x66\x3f\x80\x86\x89\xfd\xfd\xea\x5c\xc1\xde\x20\xf3\xab\x1c\xac\x96\x2f\xd4\xf8\x3e\x39\xf0\xb9\x8f\xc4\xb0\x2c\x43\xea\xa9\xda\xd8\xda\x43\x16\xf7\xc5\xe5\x30\x42\x9d\x07\xac\xfd\x61\xbd\x99\x2e\x06\xf5\x2d\x67\x17\xcb\x50\xee\x3f\x84\x3e\xd2\x33\xbe\xb0\x2c\xe9\x5e\x2c\x03\xd9\xe2\x9c\x65\x05\x51\x2c\x2d\x13\x57\x04\x70\xcd\x6e\xac\x3e\x55\xbd\xa5\xeb\x4a\xe5\xc9\x75\xaf\xb6\xa0\x7b\x08\x33\x2e\xea\xec\x90\x4f\x81\x18\x7d\x73\x76\xb6\x60\x6a\x49\x0a\xa9\x35\xb7\x7b\x00\xe7\x08\x33\xe1\x40\xe9\x0a\xc8\x44\x90\x86\x05\xb3\xf2\x3c\x78\xcf\xf1\xdc\x3d\xcb\xa5\xb5\xac\x9d\x8d\x4f\x23\xe7\xfe\x64\x65\xcc\xdd\x72\xee\x1c\xfe\xb7\x2a\xef\x4e\xa7\x64\x0d\x01\x86\xb9\xd4\x28\xe7\x21\x22\xf0\x2b\x90\x54\x7f\x1a\x44\x92\xf0\x4f\x4f\xbe\x7a\xf2\xec\xc0\xce\xf5\xab\x81\x9d\x75\x4d\xc6\x3d\x0b\x32\x2e\xfc\xd2\xcd\x88\xe9\x9a\x94\xb3\xd6\x17\xa4\x3d\x42\x8b\x11\x07\x8c\xe5\x52\xe8\xec\x8c\xb4\x71\xc1\x36\x9e\x7b\xe6\x82\x64\x57\x51\xea\x8d\x84\x63\x03\xc2\x96\x1b\xf2\x45\x2e\x15\xfb\x22\xba\xff\x56\xe9\xd4\x5e\xe8\x74\xed\xbd\x9b\x71\x6d\xa0\x01\xef\x35\x5b\x3e\x58\xcd\xed\xe2\x5b\xef\xea\x59\x5f\x7d\x0b\x5c\x90\x9c\x16\x0f\x18\x07\xc1\x59\x3b\xf5\x39\x79\xe9\xbc\xb2\x6e\x28\xe7\x75\x44\x95\xc8\xf5\xc0\xc7\x42\xa9\x90\x4c\x3b\x61\x99\x44\xa8\x5b\x97\x37\xf0\x80\x3c\xfd\xd0\x5a\x40\x1b\xa9\xe8\x8c\x3d\x71\x8f\x7d\x2c\x2d\x45\x7e\x42\x34\xdc\x9a\x8b\x09\x6b\x19\x1d\x4e\xae\xcf\x67\xf6\xc1\x07\xe0\x02\x34\x81\x54\x40\x58\xc8\x1a\x18\x45\xdc\x9f\xf9\x71\xc4\xb1\x5a\x54\xce\x77\xf1\x9a\xd2\x1b\x7d\x92\x51\x6d\x78\xf2\x5d\x26\x93\xeb\x4b\x23\x55\x0f\xaa\xc5\xe1\xcf\x97\x2b\xa3\xd6\xf6\x54\x90\xc3\x9f\x2f\xc9\x31\xd7\xd7\x55\x87\x06\x84\x35\xad\x67\xdf\xd1\x00\xeb\xe3\x0a\x31\x48\x4e\xad\xf1\xc7\xbc\x81\x27\x02\xb4\x73\x7f\x67\xe5\x0f\xf4\x46\x33\x9c\xfe\xc4\x4e\xdf\x7e\xcd\xda\xb3\xe0\x8d\x81\x30\xe0\xeb\x9c\x1e\x6f\x20\xea\x35\xd5\x6d\x5b\xd7\x90\x15\x62\x8a\x7a\x48\x03\xa0\x51\x1d\xe6\x1b\xa8\x66\x29\x4b\x72\x43\xd1\x61\x05\x3c\x75\x4c\xae\x78\xf1\x9c\x9c\x44\x80\xb9\x58\x8d\x50\x1f\xca\xea\x1b\x01\xbc\xc4\xa5\x08\x00\x95\xad\xf6\x02\x3e\x41\x65\x4a\x3f\x27\x7b\xec\x9d\xf9\xf3\xde\x90\xec\xbd\x9b\x6a\xfb\x1f\x61\xa6\x00\xb0\xed\xfa\x7c\x58\xad\x4e\x4c\x99\xaa\xac\x17\xfc\xc1\x6a\xdd\x60\xff\x44\x4a\xae\x5e\x1f\xbf\x7e\x0e\xda\x7b\x2a\xc9\x0d\xf3\x9d\xf0\x7c\x15\xac\xe3\x86\xd1\x32\x40\x39\x47\x22\xf3\x42\xc9\x9c\x47\xb9\xaa\x70\xc8\xda\xd0\x3c\xe9\xc3\x59\x0a\x19\x69\xb0\xfd\xbd\x50\x10\xa4\xfa\xfa\x21\x1b\xcd\x05\x6e\xa3\x9f\xd3\x29\x91\xe8\x91\xaa\x27\xc8\x73\x1d\x6e\xb2\x14\xe3\x46\xc1\x96\x6e\x15\x8d\x58\xf5\xdb\x7d\xf5\x24\x65\x8b\x27\x3a\xa5\xcf\x86\xf0\x18\x24\x00\xd7\x40\x21\xcc\x89\x6a\xb2\xf7\x6c\x6f\x4c\x2e\x79\xce\x33\xaa\x32\xd7\x6b\xc6\x0d\x51\xdd\x67\xad\x01\x3f\x20\xf8\x54\x9f\xee\x91\x03\xcc\x50\x07\x9d\x22\x63\xbe\x5e\x39\xe0\x73\x80\x03\x7f\xd0\x4a\x85\x24\x3d\xf8\x2e\x48\x67\xff\x05\x71\x6d\xe7\x5e\x8b\xac\x75\x5c\xaf\x51\x52\xe5\xf6\x60\xcf\x40\x07\x37\x23\xa1\x7c\x80\xb9\x9e\xc2\xc8\x2a\x2e\xdc\x13\xab\x85\xe4\xc2\x69\x27\xd0\x32\x1e\xc8\x00\x07\xb8\x93\x58\xf6\xa0\xf4\x68\x6f\x6b\x64\x12\xe9\xa1\x94\x9b\x04\xd1\xd2\xcf\x7e\xbc\x11\xfc\xb7\x92\x91\xd3\xe3\xd0\xf7\x93\x29\xcd\xb5\xb1\x9c\x2b\xad\xe9\x08\x1c\x15\x87\x83\xc3\x9c\xfe\x47\x0a\x72\xf2\xdd\xa5\x9b\xca\x60\x0b\x17\xb8\x25\x03\xa4\xff\x29\x15\xb3\xaa\x51\x67\x3d\xec\xd0\x8f\xd4\xd4\xbd\xec\xe7\xe4\x98\x1a\x8a\x2a\x18\x72\x33\x59\x95\x97\xc2\x49\x98\x40\xda\x8f\xaf\x1d\x6e\xa9\x45\x93\xcd\xab\x41\x96\x82\xce\xda\xe3\x51\xd9\x9f\xbf\xb9\x38\xdd\x80\x12\x95\x80\x14\x9e\xbd\x92\x69\x4f\x9a\x14\x60\x7b\x1c\xe1\xa8\x24\xb7\xc3\x92\x33\x29\xd8\x10\x98\x1d\xb1\xdc\xce\xfd\xf3\x67\xc5\xcd\x43\xcb\x25\xab\xab\xb3\xf8\xf7\x3b\xd6\xcb\x5b\x5b\xe1\x7f\x16\x95\xc5\x03\x86\x03\x70\x15\xa7\x08\x4c\x32\x39\x21\x8e\x1b\x6c\xf2\x8d\xdf\x5c\x9c\xf6\xf6\xc2\x6f\x2e\x4e\xb7\xf7\x65\x7b\x34\x0e\x9a\xb6\x41\xa5\xbf\x55\xc8\xb1\x4d\xa5\xff\xfe\x1a\xff\xb8\x2f\x5d\x7f\x53\x2b\x7d\xcd\x45\xeb\x94\xb0\x3a\xeb\x38\xf1\xc5\x91\x2e\x4c\x03\xf5\xd8\xe9\x73\x92\x97\x99\x81\xda\x37\x20\x2c\x4b\x69\xda\x4a\x6f\x4f\x62\xc4\xe1\x40\x10\x72\xcc\x30\xb6\x90\x3e\xf7\xd9\x08\xe1\x17\xeb\x7f\xf0\x8a\x0a\x3a\xb3\xb7\x83\x3c\x24\x39\xfe\x19\x51\xf4\x01\x7a\xd0\x45\xf8\x8a\x2e\x28\xcf\xe8\x84\x67\xdc\x2c\xad\x1e\x37\x18\x7b\x45\x4c\x63\x21\xac\x9d\xf2\xc6\x98\x5a\xaf\x2a\x6c\x5c\x1c\x04\x0a\x26\x39\xb0\xe3\x3f\xb9\xb1\x8c\x7b\x30\xae\xb4\x57\x80\x22\x83\x2c\x79\x54\x71\x6b\xaa\xad\x87\x78\x68\x68\xb6\xdd\xc8\xb5\xad\x5a\x09\xdb\xfc\xa2\x25\x80\xf5\xaa\xda\x63\x47\x5a\xab\xf6\xc0\x17\x0e\x71\xe2\x33\xd7\x7c\xb0\x89\x58\x07\xdd\x07\x8e\x4c\xcb\xdf\x77\xd5\x7e\x76\xe7\xe5\xc3\x57\xb5\xc1\xbd\xac\x52\x8c\x20\x84\x43\x37\x72\xa4\xf1\x04\x5d\x3a\x56\xed\x91\x85\x40\xbb\xb2\xe7\xa6\x4d\x05\x05\x5e\x9d\xb9\x6b\xa0\xd4\x5e\x16\x02\x31\x57\x5a\x1f\x9c\x8e\xef\x93\xb0\x62\x3e\xed\x5e\x00\x79\xc4\x8a\xf9\x8b\xcb\x7a\x28\xc5\x7e\x46\x5e\x5c\xae\xe1\x7b\x98\x28\x63\xdf\x5b\x63\x80\x65\x5f\x93\x8c\x4f\x99\xe1\xad\x16\x61\xc3\x9c\x2f\x97\x82\x1b\xa9\xf4\x26\x0a\x3e\xdc\xa3\xfb\xd1\xbb\x2e\xfc\x42\x90\x57\x6e\x5c\xcc\xf6\x4c\x64\x96\xb1\xc4\xb8\xb6\x97\xb0\xad\xfe\xc1\xeb\x1c\x21\x2e\x15\x40\xfb\x3e\xd1\xce\xe9\xf1\x04\x49\xed\xc9\xc5\xc9\xe1\xf1\xab\x93\x71\x9e\xfe\x61\x2e\x6f\x46\x46\x8e\x4a\xcd\x46\xdc\x74\xd3\x95\x36\x58\x11\xd2\x83\x03\xda\xcc\xfb\xd9\xc0\x0a\x8e\xe8\x8d\xae\x00\xc3\x7c\xe0\x57\x49\x69\x56\x21\xc3\xa6\x65\x96\xe1\x9e\x1a\xc5\xd8\x30\x76\x27\x3e\x10\x50\xad\xba\xb6\x4b\x7f\xdd\x5f\xdf\x1b\xba\x7f\xd1\xbc\x2d\x87\xa1\xbb\x94\x6f\xab\x1a\x93\x3b\xd6\xfe\x32\x8c\xec\xb3\xf9\x2c\xe1\xdb\x9d\xb8\x66\x4b\x02\xa9\xfd\x53\xa9\x00\x66\xb3\x4e\x85\xcc\x24\xb0\x5c\x4f\xa0\xa7\xa5\xd3\x15\xb6\x64\xa9\xbb\x68\x11\xf0\x22\x17\x6c\xfa\x71\x16\xfa\x82\x4d\xb1\x7a\xc2\x27\x38\x3b\xeb\x82\x96\x66\x8e\x69\x90\x08\x7b\x84\xcb\xb9\x76\xe5\x5d\x39\xc6\x96\x2c\x75\xa7\x44\xfa\x3e\x8a\xbd\xba\x80\xf6\x93\x95\xfd\x8a\xdd\x84\x6e\x93\xcc\x83\xe3\x0a\x72\x61\x6d\x4b\x76\xf3\xe4\x46\xaa\x6b\x2e\x66\xa3\x1b\x6e\xe6\x23\x5c\x29\xfd\x04\x40\xd8\x9e\xfc\x01\xfe\xe3\xa2\xb5\x87\x69\xea\x32\xcb\x4a\xcd\xa6\x65\x86\x39\x5f\x7a\x4c\x68\xc1\x7f\x62\x4a\x43\xfe\xe2\x35\x17\xe9\x90\x94\x3c\xfd\xb6\xed\x8e\x91\x3e\x0e\x48\xfb\x26\x6a\x77\xca\x45\xe5\xd9\x8f\xa2\xa9\xd4\x08\xc1\x6b\x97\xa8\x46\xfa\x34\xcd\xb9\xd8\x16\xca\x6f\xab\xda\x73\x91\xb6\x5b\xc1\xfa\xea\x1d\xc1\x38\x75\xdd\x1e\xc7\xf6\x31\xe3\x90\x45\x43\xbd\x2f\x03\x7b\x6c\xb9\x7c\x9a\x7a\x36\xcd\xbd\x18\x4a\xbe\xd4\xbf\x65\x23\x7c\xca\xa8\x48\xab\x75\xdd\xa5\xc6\x3c\xe4\xfa\x98\xa9\x31\xfd\xba\xbf\x3f\x41\xc2\xcb\x47\xa5\x31\xb2\x53\x7b\x37\xb0\xd6\xdd\x35\xdd\x8f\xa0\x7f\x01\x08\xbc\xf6\x95\xc9\xa0\x5e\x21\xef\xf1\xbe\x2d\xec\x2b\x18\x50\x87\x7d\x8d\x51\x22\x85\x70\x80\x74\xaf\x0b\x26\x2e\x0d\x4d\xae\x3b\xc6\x45\x77\x3a\xd3\xef\x4c\x67\xea\x37\x57\xc6\xa7\x41\xa7\x81\x46\xb1\x84\xca\xa5\x94\x55\x59\xd2\x78\xb0\x1f\x21\xd7\x45\x78\xf5\x57\xb4\xe8\xee\x01\xf5\x23\x35\x14\xa5\xf0\xb1\x73\x7a\x42\x55\x4d\x21\x8b\x32\x43\xbc\x35\xae\xdd\x3a\x7e\x7a\xc5\xa6\xeb\x01\x77\xfa\x72\x7f\x39\x23\x15\x0f\xcd\x65\xca\xc8\x84\x9b\x8a\x3b\x6a\x66\xb0\x70\xd7\xa1\xd0\x48\x41\x12\x87\x34\x07\x5a\x87\xd5\x30\xdc\x84\x22\x8d\x44\x10\x99\x18\x5f\xf0\x17\x6a\x7c\x9f\x3e\x7d\xfa\x14\x2b\x2e\xff\xeb\xbf\xfe\x8b\x48\x05\xed\x1e\x12\x9e\xaf\xde\x08\x77\xfd\xe5\xd9\xb3\x31\xf9\xc7\xe1\xab\x97\x90\xfb\x5f\x18\x8d\x20\xe0\x38\xb2\xbd\xa1\xf6\x63\x3d\x24\xff\xfb\xf2\xf5\x99\x57\x1b\x75\xe3\x5b\x30\xb5\xc3\xeb\xd5\xa1\x17\x9f\xfe\xf5\xcf\x7f\x1e\x93\x63\xae\xa0\xf6\x89\xb3\xd0\xd6\x2b\x78\x4b\xa8\x62\x58\x21\x0a\xf8\x80\x5e\xaf\xe2\x01\x41\xdf\x81\x27\x60\xe3\x43\x2c\x66\xb4\x14\x98\xf1\xc4\x60\x99\x15\x32\xb2\xd0\x54\x19\x50\x1b\x1d\x0e\xaa\x4b\xd6\x85\xc9\x0d\x49\xc6\xaf\x19\x99\x6a\x68\x28\x5a\x55\xd2\xbb\x5e\x37\xae\xa4\x04\x07\xab\xf6\x4a\x33\xf3\xc8\x73\x3f\x3b\xf9\x82\x9b\xe8\xc5\xb5\x66\x6d\x50\xe7\x79\xcd\x96\x23\xa4\xb0\x82\xf2\x50\x30\x02\xc9\x71\xb5\x06\x0b\xc1\x6b\x93\x46\x7c\xc5\x03\x2c\x16\x4a\xfe\x1b\x37\x1f\x0a\x48\x23\x4e\x0c\x65\xa8\xd8\x60\x17\x90\x12\x44\xd4\xad\xc3\x17\xc1\xba\x8e\x5e\xfe\x63\x07\x13\xba\x8a\xb5\x9c\x71\x6d\x1f\x71\xcd\x96\xfa\xae\x27\x57\x8d\x62\x2c\x7d\x6a\xa4\x94\x52\xac\xfc\xda\xc1\xee\x3b\xce\xe8\x3a\x2c\x38\xb8\x9b\x6a\x0c\xac\xfd\x77\x55\xd0\xee\x5e\xbf\x4a\x61\x21\x6a\xe9\xca\x9a\x99\xd2\x2d\x0d\xe4\x9d\xdb\x67\x03\xfa\x3f\xbc\x61\x4e\xd5\x35\xf3\x7d\x85\x69\x36\x26\xe7\x76\x92\x01\x6f\x24\xb4\x75\x06\xbb\x95\x2e\xe1\xb1\x4e\x49\x83\x87\xec\x8f\xc7\xfb\x78\xf0\xa4\x22\xda\x50\xe5\x4e\x91\xfd\xfc\xf3\x80\xb0\x7a\x45\x0b\x8d\x90\x2a\x56\x2b\x05\xb8\x21\x09\x30\xad\x66\x5e\xf5\x14\xc4\xb5\xde\xc1\x4e\x91\x11\x2c\x4c\xeb\x01\xb6\x11\x72\xea\xca\xf1\x06\x23\xfd\xf1\xde\x0a\x20\xa4\xbc\x83\x52\x81\x57\x27\xd5\xc2\x61\xec\x66\xec\x51\xe9\x12\xeb\x7b\x6a\x38\x4e\x19\x69\x6b\x8d\x46\xa0\x8f\x55\x65\xc0\xab\x0f\xc5\x01\xaf\xee\xea\x03\x5e\x5d\x02\xba\x78\xad\x9c\xd0\x20\xa9\x50\x18\x4d\xab\xa5\x07\xc4\xf3\x22\x88\x78\x23\xb1\x3d\x88\x6f\x73\x23\x08\x9d\x68\x99\x95\x06\x7f\x5a\x7d\x19\x8b\x39\x18\xd4\x23\x2f\x81\x6c\x0b\xb7\x45\x42\x0f\xc4\x3d\xca\x89\x2e\xf2\x0f\xaf\xce\x6c\xa2\xb7\x16\xca\x9f\xb7\x57\xa1\xf3\x3a\x7b\xdd\xa9\x9f\x5c\x27\x57\x0c\x75\x33\x67\x2e\x0b\x21\xd2\xeb\x2c\xf3\xb4\x2c\x01\x94\x46\xaf\xa2\x61\xcb\xf2\x74\x23\x5e\xc2\x44\xf3\xee\x6e\x81\xcb\x53\x72\x10\x7a\x8d\x86\x74\xb6\x53\x61\x98\x9a\xd2\x84\x0d\x62\x77\x01\x2b\xe6\x2c\x67\x8a\x66\x21\x43\xd9\xd7\x29\xcf\xa9\x48\x33\x57\xbc\xcf\x14\x1c\x5c\xf6\xce\x30\x25\x68\x06\x8f\x48\x15\x5f\x30\xa5\xc9\xc1\x77\xcc\xda\x12\xd8\xa3\x74\xf0\x08\xd3\x48\xf1\x45\x36\xe1\xcc\x80\x07\xf7\x93\x00\x0a\x43\xad\x6b\x93\x58\x6d\x95\x07\x2c\xb2\xdb\xaa\x63\x37\xd0\xd8\x1e\x08\x90\x98\xc0\x74\xa1\x1d\x10\x46\x23\x7d\xf7\x3b\x40\x2d\x4e\x0c\x0e\x4c\xb5\xeb\x86\x07\x90\x30\x8e\x9f\x3b\xa8\x90\x8d\x95\x02\x7c\x92\xa2\x8b\xbb\x4a\x26\xa6\xce\x80\x94\x0b\x9e\x7a\x35\x08\xb2\x19\x2a\xc8\xad\x82\xea\xa8\x92\x9f\x6a\x2d\x5d\xb3\xcf\x68\x8f\xd0\x1c\x05\x65\xa9\x0e\x28\xed\x23\xc5\x71\xbc\x4b\x02\x2c\x6b\xab\x6e\x16\xa4\x17\x81\x28\x53\x76\x5e\x4e\x32\xae\xe7\x97\xbd\x86\x36\xce\xd6\x0c\x8c\x89\x81\x2b\xc9\x25\xb7\x86\x3b\x34\x13\x9a\xbb\xe6\x63\xa8\x66\x71\xab\x65\x4b\xd8\x06\xff\xeb\xf8\x74\x48\x28\x14\x87\x96\x66\xfe\xab\x68\x1e\x0e\xb9\x03\x7b\xe9\xa4\xec\x8d\x28\x6a\x9f\x27\x34\xcb\x74\xb3\x8b\xb4\x17\x64\xa8\x99\x7a\x34\x0f\xa4\x0a\x6e\x09\xc6\xcf\x1e\xb2\x66\x90\x8b\x05\x58\xd3\xb5\x2f\xa6\x49\x2e\xb1\xe2\x5f\x10\x29\xfc\x4d\xd0\x12\xc8\xff\x20\xac\x10\x82\x8d\x21\xd1\x6d\x10\x50\x72\x17\xd3\x79\x7c\x31\x9d\x5e\xa3\xc2\x97\xa1\x3f\x03\x85\x81\x47\x50\xd8\xe4\xbb\xcc\xd2\x50\xf8\x5f\x19\x8e\xe3\x0f\x85\x8f\x37\x16\xc1\xc5\xf9\x1d\x1a\x87\x09\xda\x8f\xdf\xf6\xa7\xc6\xa0\xa0\x8a\x59\xcb\x1b\x18\xd3\xc8\xd9\xd6\x49\x74\x92\x9c\x49\x1c\x8e\xf7\x2a\x3b\xab\x64\x3a\x88\x73\xfc\x70\x5f\x93\x54\x26\xa5\xb5\xb9\xaa\x65\xaf\x12\x26\xba\x41\xbd\x7f\x5e\xd8\xb3\xa9\xbc\x11\x37\x54\xa5\x87\xe7\xad\xaa\x56\xeb\xca\x59\x35\x56\xac\x7a\xfb\x47\x10\xfb\x39\x9d\xf8\x6e\xff\x01\xfc\x69\x17\xb8\x6b\x0e\xf1\x21\xef\x9a\xeb\x01\x7e\xbf\x38\x1d\xd9\x85\xfe\x76\xa1\xbf\xcf\x26\xf4\x67\x47\xaa\xb7\x49\xa9\xb1\x17\xe7\x90\xb5\x2b\xfe\x59\xc4\x90\x22\x96\x8a\xd2\xb3\x59\x0f\xdb\xd0\xf9\xf1\xf0\x56\x54\x17\xd9\x09\x9e\xe7\x82\x3a\xf6\x39\xc4\x9b\xb6\x20\x5e\x04\x6b\xd9\xc1\x18\xc4\xeb\xb6\x52\x31\x44\x6a\xc5\xc0\x73\x14\xc1\x2e\x64\xfa\x1c\x81\x53\xa1\x6d\x3a\x36\xec\x18\x3a\xd0\xe6\xa1\xf3\x5d\x88\xa8\x51\x38\xf6\x65\xf6\xea\x4f\x2f\x31\x81\x8e\x04\x40\x7a\x22\x02\x02\x84\x00\xab\x73\xde\x85\x1a\x48\x6f\x14\x61\xaf\xca\xd0\xe9\x3a\x52\x53\x81\xc6\x51\x3d\x21\xe8\x64\xce\x72\x6c\x1e\xfe\xc2\x2f\x81\xe5\x8d\xd6\x78\x30\x0c\x11\xd2\x98\xca\x35\x91\xd3\x61\x0d\x42\x61\x6f\xf1\x6c\xaf\x5b\x8c\x81\xf4\x17\x8e\x24\xfe\x1c\x9d\x77\x8e\xed\x90\xe6\x82\x9d\xd7\x42\x3a\xf6\x0c\x81\xce\x93\x61\xdf\xe2\x46\x96\x05\xc8\x0f\x5c\xe1\xad\x59\x9c\x6d\x89\xd5\x0e\x43\xd4\xe0\x11\x28\x7f\xbb\x58\xed\xe7\x18\xab\x8d\x04\xa3\x67\x74\x6e\x61\xe3\xf8\x6d\x1c\x12\xf0\x41\xdc\x09\xf3\x46\x8d\xb3\x61\x7c\x04\xd7\x87\x6f\xa5\xaa\xa7\x26\xed\x8f\xc7\xfb\xfb\x3e\xa8\xeb\xe8\xbe\x34\xd3\xd1\xd7\x84\x89\x44\xa6\x48\x2c\x76\x7c\xa5\x0d\xa8\x7b\x95\x97\x2d\x9e\x4b\xee\x9f\x15\xa7\x37\xc1\xd8\x7d\x6c\x75\x67\xde\xe2\xd1\xf8\x5e\x7c\x04\x25\xa6\x52\x5d\x02\xe6\x9f\x5b\xa2\x80\xe9\xec\x74\x18\xff\xbd\x26\x19\xcf\xb9\x6b\x1e\x66\x0f\x3a\xd3\x46\x93\x03\xfc\x70\x9c\x14\xe5\xd0\xdd\x30\xce\x59\x2e\xd5\x72\x18\x6e\xb2\x5f\xd6\x7e\xe5\xee\x18\x60\x13\x8a\x52\x29\x26\x4c\xb6\xfc\x9c\x35\x20\xbf\x88\x5b\xa2\x00\x85\x3d\xee\x82\xe4\x51\x5d\x8d\x9a\xb9\x10\xf1\x05\x6f\x79\x84\xb1\x1f\xc0\x5a\xf5\x30\x84\x24\xe0\x53\x26\x16\x64\x41\xd5\x03\xd1\xd3\xd7\x5d\x3d\xea\x3c\x29\x5f\x70\xdd\xb5\xb3\x1f\xb9\xdd\x09\x0d\x7d\xbb\x4a\x53\x94\xc6\x71\x74\x7f\x02\x3d\xd2\x76\x38\x79\x0d\xe5\xf0\xd9\x5e\xe7\x29\x15\xd4\x18\xa6\xc4\x73\xf2\x3f\x07\x6f\xbf\x7c\x3f\x1a\x7c\x7b\x70\xf0\xcb\xd3\xd1\xdf\x7e\xfd\xf2\xe0\xed\x18\xfe\xf1\xc5\xe0\xdb\xc1\x7b\xff\xc7\x97\x83\xc1\xc1\xc1\x2f\x3f\xbe\xfa\xfe\xea\xfc\xe4\x57\x3e\x78\xff\x8b\x28\xf3\x6b\xfc\xeb\xfd\xc1\x2f\xec\xe4\xd7\x7b\x0e\x32\x18\x7c\xfb\xc7\xce\x53\xa7\x62\xf9\xba\x23\x2b\xc4\x6b\xd4\xa3\x48\xae\x8f\xd8\x0b\xf9\x35\x5a\x2b\x70\x61\x46\x52\x8d\x70\xe8\xe7\xc4\xa8\xb2\x1b\x33\xa9\xc4\x4b\xdf\xe7\xbf\x52\x03\x2a\xc8\x79\xaf\xd4\x6f\xf8\x80\x43\xc4\xf3\x98\xf7\x50\x18\x7c\xe2\x46\xaa\x57\xbc\x18\x96\x17\x52\x51\xb5\x24\xa9\xf3\x66\x2e\xd7\x00\xfe\x44\x88\x3f\x9d\xd1\x74\xe1\x8d\x52\xae\x36\x50\x1b\xdc\x19\xc0\x87\xa5\xbc\xcc\xfb\x71\xc2\xff\x0c\xc8\xf3\x0e\xb5\xde\x27\x10\xe1\x03\x7c\xf8\x62\x42\x93\x6b\xb4\x97\xc2\xde\xa0\x96\x18\x83\x48\xef\xb9\xbc\x87\x9c\x51\x11\xdc\xf8\x90\xc9\x22\x53\x66\x37\xce\xdf\x8c\x63\xd7\x5c\xee\x18\x4e\x77\x59\x82\x55\x0f\x26\xa9\xc8\x2b\x50\x77\x36\xba\xd7\xa4\x17\xd8\x0e\xfe\x1f\xf6\xd2\xea\x78\x3d\xc1\xc5\x4b\x30\x26\x1d\x46\xd6\x14\xba\x48\x55\xe9\x5f\x35\xb5\x01\xf6\x2d\x9c\x39\x1f\x9c\xb5\xbb\x67\xe7\x84\x8a\x27\x78\x9d\x33\x8d\xb9\x28\x3c\x81\x46\x47\x60\x78\xc2\xea\x87\x1d\xbb\x8a\xba\x21\x96\xda\x3e\x49\x8a\xfa\x3d\xd5\x83\xb0\x0f\xd4\x04\x49\xc0\xf5\x36\x6c\x98\xcb\xf6\x9b\x4b\xbf\x2e\x91\xb3\x02\xca\x89\xbd\x6d\xa9\x4b\xb0\x40\xdc\x53\x9c\x1e\x2d\xa7\x90\x2d\x11\x35\xa4\xf1\x3d\x57\x56\xe8\x52\xf0\xac\x4e\x98\xbe\xd1\x42\x78\xf1\x52\xb8\x6c\xc1\x15\x2a\x5b\x4f\x64\xa5\x66\x6a\x34\x2b\x79\xda\x1f\x79\x3d\x3a\x9d\xa2\xa3\x26\xd1\x97\xfe\xd0\x8b\xd6\xd0\xbb\xae\x10\xf2\x31\x3b\xcb\xca\xbd\x93\x90\xda\x59\x13\x96\x71\x63\x88\x7a\x9a\x27\x0d\x0d\xbf\x3c\x33\xf0\xb9\x04\x57\xc1\x4f\xe4\x84\x68\xb2\x4c\x1c\xa8\x12\xaf\xf5\xa6\xc1\x61\xf1\x4c\x40\x45\xd4\xc8\xfe\x9f\xf7\x27\xf9\x10\xea\x84\x4d\x31\x8b\x09\x7f\x03\x6e\x00\x57\xc7\x95\xb2\x8c\x19\x28\xcb\x62\xa2\x6a\x77\xa7\x89\x62\xb9\x5c\xd8\x63\xf6\x56\x90\x37\xda\x05\xc3\xf9\xf4\x39\xa1\x83\x5a\x61\xb0\xeb\xb1\x2b\x18\x4b\xb1\xb8\x2b\xea\x9a\xa7\x4a\xa1\x87\x64\x32\xf0\xc9\xaa\x1a\x1b\x3b\x2a\xf0\x98\xb9\xf6\x55\xe0\xa4\x52\xcc\x2e\x00\xc0\x43\x29\x99\x13\x2d\x68\xa1\xe7\xd2\x80\x3f\x84\x16\x34\xe1\x66\x49\x8c\xa2\xc9\x35\x34\x87\x56\xcc\x3d\x6e\x48\x92\x81\x4b\x59\x8f\x97\xaf\x5e\x6f\x66\xe6\x4a\x96\xb3\x39\x14\x40\xe1\x5d\x49\x46\xb5\x7f\xfb\xb5\xbf\x77\x06\xba\x26\xe9\x52\xd0\x9c\x27\xa1\x6f\x86\x92\x0b\xae\xb9\x74\x61\x2c\x3f\xee\x79\xe8\x2e\x80\xa1\xb1\xa3\x8c\xf2\x9c\x1c\x68\xc6\x48\x20\x09\xfc\xe6\x12\xd5\x44\x74\x13\xaa\x7a\xa2\x9c\x03\x4f\x74\x08\x01\xf6\x93\x8a\xf5\x86\x3c\x04\x94\xfd\x76\xe6\x6b\x1f\x3a\x08\xdb\xb5\x7e\x4e\x52\x41\x12\x9b\xef\x78\xc3\x44\x2a\xa3\x74\x97\xc3\xf3\x53\x1d\x1b\xaf\xae\x4f\x20\x8e\x04\x5f\x64\x52\xcc\x62\x60\xb9\x8a\x32\x2d\x93\x17\xd0\xf0\x71\xc1\xd3\x92\x66\xc8\xde\xdd\x64\x8e\x2e\x4f\xf1\xe7\x7c\x36\x37\xa3\x1b\x06\xae\x4d\x94\x82\x55\x3a\xb4\x7f\x28\x5f\x49\xa3\xe5\x1a\xc4\x81\x71\x2e\x34\x74\x13\x43\x53\x45\xba\x04\x54\x5a\x97\xb0\x59\xcb\xb4\xf1\xe8\xec\x38\xc4\xba\x15\x87\xe9\x1d\x86\x0e\x80\x56\x03\x02\xdf\xaf\x5d\x62\xa0\xd4\xd5\xb9\x41\x3b\xc3\xaa\x97\x44\xf8\xd8\x44\xed\x44\xad\xb6\xdb\xc6\x70\xdd\xb0\x96\xba\xa8\xc8\xe4\x8a\xe5\x45\x46\x4d\x3f\x79\x23\x7b\x3f\x47\xbe\xed\x28\x32\x6c\x8f\x23\x15\xe9\x88\x66\x96\x22\xcf\x7f\x3a\x72\xd5\x69\x78\xc0\x6a\xb9\x69\x57\x55\x13\x4e\x54\x0e\x50\x4b\x5a\x7b\xb4\x00\xd2\x6c\xc2\x52\x60\x46\xee\xc9\xe0\x80\xb8\x11\xd8\x95\xd5\xfe\x71\xfe\xd3\xd1\x90\xf0\x31\x1b\xfb\xbf\xc2\xad\x9e\x1b\x1a\x39\xc3\xea\x85\x50\x15\x03\xf4\x0c\x53\x89\x3d\xbb\xf1\x6f\xff\xf5\x8d\x9d\xa4\xfd\xf6\xef\xa3\x6f\xa2\x3e\x3e\x7f\xff\x97\x65\xae\xca\xde\x50\xff\x34\x4e\x1e\x07\xbe\x67\xff\xfa\xd7\xb9\x4c\x2f\x0b\x96\x8c\xf1\xb5\xf4\xbf\x5c\x4b\x73\x26\x8c\x55\xad\xcf\x25\xa4\x8d\xf1\x14\xa9\x1c\x9e\xad\xd8\xbf\xbd\xf7\xdf\xf5\x03\x75\x8c\x24\xa1\x86\x09\x10\x00\xbe\x4a\x58\x48\x83\x3f\xc7\x4e\xa2\x30\xff\x83\x69\xdc\xdb\xd3\x48\x09\xc7\x1c\x59\xc9\xa1\x20\xec\x1d\xd7\x80\x09\x83\xef\x0a\xcb\x41\x5d\x66\xba\x97\x69\x76\x58\xbb\xc2\x01\x03\x08\x9a\x8b\xda\xb9\x7d\x21\xa4\xf9\x22\x6c\xbf\xcf\x3a\x04\xc1\x25\x09\x5d\x48\xc0\x9d\x00\xae\x2e\x48\x29\xc0\x6d\x5d\xf5\xe6\x9b\x2c\x49\xce\xb5\xa1\xd7\x6c\x4c\x2e\xad\xcc\x8a\xd3\x07\x70\xf5\x04\x81\xee\x2a\x2c\x25\xa5\x30\x3c\x83\x6f\xab\x71\xec\x94\x63\x59\x76\x3a\x25\xba\x4c\xa0\xfb\xac\x62\x23\x2f\x1d\xdd\x5d\x2b\x3c\xa6\x7a\x97\x61\xd8\xec\x39\x45\x73\xa9\x48\xe1\xa7\xd8\xcb\x56\x38\xf2\x5a\xc9\x95\xb6\xf3\x94\x22\xa9\x24\x22\x2c\x26\x34\x34\xb6\x42\x30\xf3\xd9\x3d\x68\xb9\xb9\x68\x80\x60\x09\xd3\x9a\xaa\x25\xb6\xfb\xe4\xa1\x2b\xa1\x4b\x63\x05\x49\x9d\x53\x51\xc2\x00\x8a\x61\xf3\xd8\x32\x81\xd5\xa1\x64\xa2\xe4\x35\x13\xa1\x3e\xc0\xee\x62\x3d\x49\xba\x4a\x09\x85\xe0\xbc\x24\xc9\x9c\x8a\x19\xab\x4a\xc0\x73\x9a\xc2\xda\xff\x18\x34\x2d\xff\x3e\x76\x05\xe8\xd4\x2a\x2c\xdc\xc0\x52\x4c\xac\x7c\x0a\x31\x8d\xb7\x82\x78\xa7\xc8\xb0\x0a\x3a\xd8\x57\xe2\x59\x2b\x9e\x48\xfa\xf1\x72\x77\xf7\x6f\x8f\x40\xa1\xd8\x60\x42\x76\xce\x0c\x4d\xa9\xa1\xbd\x25\x65\xbf\xa2\xa1\xad\xa5\xcb\xd8\x00\x72\x88\x32\x39\x9c\x8c\xf5\xaa\xa4\x2c\x78\x0c\x0a\x00\xdc\x60\xee\x77\x1f\xdb\xc1\x5b\xba\x76\x11\x45\xcc\xb5\x06\x5d\xcd\x75\x3a\x87\xe1\xfd\x68\xc8\xb2\x58\x4a\xd2\x12\xd4\xbe\x8a\xa5\x75\x89\x78\xf7\x12\x10\xb1\x1b\xdd\xdb\x2a\x5f\x55\x81\xfd\xa4\x9e\x78\xbd\x56\x41\x43\x59\xc7\x84\xe1\xd8\xb5\xdc\xa3\x38\xb8\xc5\x2f\x05\x1e\xd5\xc6\x36\xc0\x3e\xcd\x98\xd1\x55\xca\x24\x4a\x13\xcb\x22\x9d\x2c\x77\x4e\x04\x10\x35\x6e\x6b\x9c\x1d\xbe\x5e\x53\xc4\x8d\xd3\xd2\x49\x0b\x2b\xbf\x36\xbe\x33\xfd\x45\x86\xb0\xbf\xeb\x2b\x99\x76\x0f\x31\x35\x1a\x95\x56\x03\x57\x15\x24\x58\x4d\xa4\xc1\xc9\x83\x4f\x86\x80\xbb\xae\x61\x5c\xa0\x08\x98\xd3\x45\x7b\x5f\x69\xa5\x99\x8e\x42\x13\x32\x78\xdc\x08\x1e\x37\x7a\xd6\xd5\x2b\xdd\x3d\x25\xd1\x5f\x1d\x53\x13\xeb\x13\xea\x21\x0c\x61\x59\xeb\x65\x2f\x51\x82\x66\xa7\xc8\x20\x79\x5d\xc2\x45\x48\x72\x71\x65\xb2\x8c\x5b\x7e\xf9\x9c\x7c\x51\xd3\xb5\x9c\x4e\x1b\xec\x60\xac\x49\x3a\xf0\x86\xf1\xd8\x6d\xb9\x07\xdc\xaa\xdf\x3e\x68\x0c\x06\x4a\xde\x7a\x7b\xd1\xd7\x3e\x05\xc5\xdb\x2a\xc9\xd0\x62\x3e\x94\x9e\x5a\x32\x56\x32\xcb\x7c\x5b\x72\xb4\x8d\x1b\x29\x4b\xd0\x45\x07\x83\x20\xc3\xe0\x80\x08\x9a\xbe\x60\x37\x41\xa5\xa3\x1a\x71\x43\x7d\x08\x1e\x9c\x24\x3e\x8f\x6c\xdd\x78\xa1\x3e\xeb\x50\x2c\x71\xea\xc7\x61\xb3\xbc\x63\x81\xcc\xec\x83\xac\xee\x2f\xe8\x24\xc3\x44\x9b\xb0\xf0\x30\x17\x9a\xdd\xd0\xa5\x86\xf3\x55\xd9\x6a\xe1\xf9\x0e\x45\xbd\x1a\xf8\x82\x4d\x3b\xb4\x4a\x8f\xaf\xde\x82\xf4\xfd\x85\xe9\x01\x23\x85\x8b\xf6\xb9\xb7\xd5\x30\x2d\xba\x4b\x37\xaf\xfe\xa2\xfd\x90\xf0\x08\xd9\x4e\x7d\x84\x4d\xeb\x2d\x80\xce\x4f\x61\x60\x6f\xb3\xcd\xe0\x0f\x2f\xcb\x43\xfc\x6f\xc2\xec\x79\xab\x90\x9d\x80\x76\xe3\xdf\xae\x49\x07\xab\x88\xfe\x47\x68\x13\xe4\x02\x2d\xbe\xcc\xd7\x8a\x82\xc3\xf3\x53\x7c\xe2\x18\x1a\xc1\x52\xb1\x74\x5a\x96\x99\x73\x95\x8e\x0a\xaa\xcc\x12\xdd\x16\xc3\xda\xd3\x42\x89\x63\x0f\xcb\xd1\x6b\xc4\xb7\x4b\x1f\xb1\xf8\xaa\xed\x11\x2c\x9f\xdb\x1f\x1f\x22\xbb\x75\x67\xb6\x6d\x45\xba\x16\x5c\xfa\xab\x5e\xd5\x1b\x61\x83\x79\xaf\xc5\xa3\x58\x91\x34\x66\xc4\xfd\x4a\xe4\x46\x5e\x0a\x0a\x56\xd0\x97\x9d\x6f\x49\xc6\x05\x60\x41\x3f\x03\x43\xdf\x4e\x6b\x48\xf8\xd4\x8a\x34\x29\x46\xae\xda\x3c\x38\xc2\x9d\x8e\xe7\x13\x38\xd1\x68\xb7\x87\x15\x5d\x9d\xf1\xb3\xe2\x01\xc2\xe9\x26\x07\x42\x0a\x3c\xf1\x78\xef\x00\xf3\x57\x6f\xf1\xe5\xc2\x2d\x63\xf2\xf3\x9c\x89\x58\xdc\xc5\xce\xef\x61\x10\xbb\x5c\xa4\x76\xbb\x41\x16\x82\xed\xaf\xcb\x24\x61\x2c\x78\x8b\xe2\x4e\xe8\x15\x47\x72\x53\xce\xa9\x49\xe6\x4c\x13\x2d\x01\x0a\x54\x1b\x9a\x65\x95\x97\xc6\x2d\x97\x04\xcd\xc1\x7b\xcc\x23\x85\xa2\x56\xa4\xed\x1c\x56\x45\x46\x9d\x57\x64\x5a\x8a\x04\x33\xa4\xb8\x59\xfa\x19\xc4\x12\x1e\x7e\x06\xa6\xa9\x46\xe7\x0d\x9f\xa2\x9f\x36\x32\x31\xc3\x62\x02\x4b\x5d\x22\x13\xad\xcb\x7a\x07\x82\x67\xf9\xe7\x84\x26\xd7\x37\x54\xa5\x1a\xea\xcf\xa9\xe1\xd8\xe2\x6f\x58\x1b\xf6\x20\x9a\x83\x7d\x7a\x4d\x37\x18\x04\x43\x16\xda\x3b\xcb\xc6\x63\x08\x2d\x8d\xcc\xa9\xe1\x09\xb8\x68\xf8\x34\xf2\xba\xe7\xa1\xeb\x42\x88\x9a\x22\x2f\x07\xe9\xe0\x5e\x03\xac\x35\x85\xf5\x12\xe6\x46\x12\x9e\x5b\x9d\x8b\x42\xfb\xe2\x69\xa8\x36\xf7\xf1\x81\xbb\x66\x6a\x15\xcb\x9f\x21\x28\x13\xdd\x85\xce\x1f\x6b\x96\x6b\x18\x3e\x44\x00\x82\xeb\xdb\x95\x55\x0f\x1b\x2a\x91\xfb\x8d\xa5\x69\x3b\xd7\x88\x54\x87\x76\x7b\x6e\x98\xd5\xb4\xf4\x9d\x04\xab\xc7\xeb\x66\xc4\x67\x02\x2b\x70\xb9\xf6\xee\x02\x97\x52\x7d\x90\x2a\x59\x14\xce\xf1\x97\x0f\x9a\x33\x82\x38\x9b\x5a\x30\x0d\x31\x66\x9f\xa4\x6d\x97\x61\xc6\x04\x53\xd4\x80\xd7\xde\xe1\x06\xc2\xc9\x6d\x3e\xa2\x76\x60\xc6\xe4\xe0\x30\x2b\xe6\x74\x40\xde\xb8\xe6\xf5\x81\x72\x43\xce\xf7\xbd\x74\x51\x74\x23\x3a\x75\x74\xa7\x44\xde\x39\xcc\x4e\x89\xdc\x29\x91\x2d\xae\x9d\x12\xd9\xbc\x76\x4a\x64\x7c\x85\xb4\xe2\x7e\x15\xc8\x8b\x50\x27\x10\x65\x79\xc4\x79\x53\x55\x21\xc1\x6d\xfe\xbd\xd3\x29\xb9\x60\x89\x5c\x30\x85\x42\xe4\xe4\x5d\x41\x85\x55\x96\x5e\x50\x9e\x59\x11\xe2\x45\x49\xe5\xd1\x80\x1e\x36\x75\x7f\x7a\xe4\x44\x0a\xfb\xe1\x0e\x6b\xee\x26\xe5\x30\x2b\xec\xfd\x2e\x6a\x5f\x28\xb6\xe0\xb2\xd4\x3e\xbb\xab\x34\xc8\x2c\xb4\x71\x0a\xcd\x9c\xcf\x42\xef\xb8\x90\x7b\xa1\x58\x22\x55\x5a\x81\x4f\x69\x43\x4d\xa9\xeb\xd5\xa0\x09\x3a\xb0\xfb\xf3\x5d\x86\x75\xdc\x22\xe9\xd9\xa7\x9c\xc1\xf4\xb8\xde\xcf\xeb\xfe\x4b\x4c\xbb\xc3\x0f\x27\x8e\x0c\x7d\x26\x60\x95\x85\x68\x75\xdf\xd2\xb0\x88\x5c\x1d\x61\x3d\x78\x0f\x6b\xc8\x32\x4f\xb0\x7b\xf6\x28\x0c\x3b\xaa\x12\xff\x5a\x37\x1b\x8c\xaf\x1e\x77\x93\xf4\x0e\x81\x12\x5f\x8f\x2e\x4f\xb0\x7e\xf5\x56\x7f\x40\x3e\x4a\x0d\x02\xe9\xbf\x0e\x81\x7c\xfc\x5a\x04\x12\x6a\xc3\xfa\x3f\xf7\x17\xbe\x56\xad\x71\xf2\x9d\x58\xba\xeb\xe4\xd7\xb0\xd0\xc2\x38\x5c\x13\x99\x73\x63\x98\xcf\x16\x09\x27\x19\x7c\xfc\x71\xad\x8e\xe3\x39\xe0\x4c\xc0\x94\x10\xf6\x2e\x74\x73\x8a\x74\x55\xd0\x38\x6f\xb8\x06\x03\x89\x0a\x6b\xd8\x22\x24\x2d\xf0\x8e\x91\xcb\xed\xf5\xc6\xfa\x8e\x0f\x75\x1f\x77\xc7\x87\xe2\x6b\xc7\x87\x08\xb4\xc5\xca\xa0\x30\xa4\x57\xc5\xf8\x10\xd3\x48\xc8\x6f\x25\x53\x4b\x62\x95\xdb\x2a\x8f\x14\x1a\x5f\x69\x9e\xba\x4c\x4c\xe7\x8d\xec\x6a\x51\x6e\xa9\x5e\x07\xde\xd2\x93\x77\xd6\x36\x00\xfc\x82\xde\x39\x7d\xf3\x01\x75\x18\x22\xdc\x05\xbf\xc5\x35\x8b\x60\xec\x70\xc6\x23\x1b\xc1\x9a\x07\x87\x67\xc7\x7d\x9a\xf7\x7d\xe4\x07\x90\xfe\x72\x04\xc8\x6d\x84\xba\x6e\x89\x70\x29\xc3\x37\x20\xcc\x42\x1e\x47\xf0\x2e\x92\x6b\xb6\x1c\xba\x74\x29\xd7\xe9\xd0\xdf\x8c\x99\x87\xf5\x76\x2c\xdd\x60\xfe\xea\x57\xcf\x52\xa7\x4f\x7f\x20\x5e\x5d\xdb\x6f\xd4\xc7\xf2\x8b\xdb\x8f\x20\xec\x59\xb0\xf6\xd0\xa6\x23\xbe\x6a\x44\xea\xda\xe6\x40\x92\x3d\x50\x2b\x00\xff\xfb\x72\xa8\x40\xa0\x50\x02\x06\x1c\xb6\x1f\xf2\x22\x7d\xbb\xa4\xf0\xf2\xdb\xf8\x91\x16\x2b\x1c\xc1\x5a\xdd\xcd\x35\x5b\xee\x6b\x87\x84\x21\x85\x9e\xf3\xc2\xf7\x6b\x04\x3e\xe9\x4e\x25\xf9\x09\x12\xdc\xfc\x10\xc8\x11\x4f\xc5\x90\x9c\x49\x63\xff\x73\x02\x19\xbb\x18\x58\x91\x4c\x9f\x49\x03\x9f\x6c\xf5\x72\xe3\xab\x7d\xa4\xc5\x76\x71\x19\x0e\x71\x15\xcc\x4d\x87\x5a\x54\x9f\xc7\x09\x8b\xea\x52\x76\xc2\xc6\x70\x4d\x4e\x05\x91\xca\xaf\xaa\xf1\x6d\xa9\xb4\x1b\xc2\x7b\xac\xa3\x10\xd8\x9a\x31\xdc\x66\x48\x55\xdb\x8b\x3b\x86\x0b\xd1\x34\xee\xbf\x01\x8f\x36\x84\x1f\x43\xf2\x29\xb4\x46\xa2\x86\xcd\x78\x42\x72\xa6\x66\x80\x9a\x92\xcc\xfb\xde\xe2\xbe\xe4\x22\x5e\x3d\x4a\x47\xbc\x7a\xa5\x43\x50\x51\x5e\x42\x5a\xf1\xc7\x51\x7f\x70\x6c\x14\xd7\x39\x2d\x2c\x09\xfe\x1f\x2b\x95\x81\x0a\xfe\x2f\xb4\x5e\xd3\x63\x72\x48\x34\x17\xb3\x8c\xd5\xbe\x73\x3e\xcc\x78\x18\x3b\x82\xb5\x59\x7f\x2b\xf9\x82\x66\x0c\xcb\x00\xa8\x08\xfd\x52\xe4\x74\x45\xe9\x1a\xba\xfe\x6b\x96\x2f\x87\xc0\xfb\xde\x35\x5b\xee\x0d\x57\xc8\x76\xef\x54\xec\x55\x00\x4c\x35\x42\x0d\xca\x05\xc4\x64\xf7\xe0\xbb\xbd\x4f\xa3\xa7\x3d\x02\xd3\xb5\x37\x9a\x74\x6e\xe6\xa3\x8c\x6a\xdd\x07\x16\xcc\xed\xf8\xe6\x97\xd1\x93\xaa\xda\x6e\x57\x4a\xd2\xbb\x8f\x1c\x4a\x19\xfb\x4a\xec\xed\x61\x9d\x17\xae\x69\x74\x57\xb0\xb8\xa6\xcc\x09\xc3\x86\x52\xd7\x9b\x18\x09\xa1\xca\xc1\xb9\x65\xc5\x7f\x82\x68\x87\x9c\xc6\xbd\x26\xb8\x06\xf7\x13\xf7\xc5\xaf\x42\x1a\xc2\x45\x92\x95\x2e\xd0\x01\x3f\x05\xe7\x55\x3f\x86\x6a\x6f\xcb\xdb\x3b\x01\xff\x14\x86\xf5\x3a\xa7\xcf\x17\x5a\xa9\x68\x6a\xa6\x76\x40\x32\x4d\xc8\x94\xc0\xd5\xde\xe4\x6a\x4d\x5b\xd5\x6e\xd4\xdb\x91\x1c\xd5\xf5\xc8\x17\x7c\xa2\x18\x39\x9a\x53\x21\x58\x16\x61\xbd\x38\x47\x27\x35\x86\x26\x73\x8c\xc7\x51\x62\xcf\x71\xc6\xcc\xbe\xc6\x36\xf8\x39\x4d\xe6\x5c\x04\x80\x04\x11\x30\x8f\xaa\x02\xb1\x0d\x34\xf0\xe9\x6a\x08\xf5\xd8\xfb\x65\xff\xf6\xe6\x2f\x15\x70\xf8\xb4\x71\x4f\x85\xa0\xef\x4e\x39\xac\x35\x4a\x5c\xe8\x44\x02\xf7\xde\xdd\x3e\x26\x0f\xee\x69\x2e\xa6\x4c\x29\xdc\x93\x09\x73\x3f\x20\xbc\xd6\xdb\x75\xec\x7a\x4a\xcc\xe5\x0d\x49\x25\xb9\x81\x2e\xa7\x0b\xab\x1a\x40\x66\x91\xf6\x4a\x45\x34\x53\xc8\xf3\x4b\x64\x5e\x28\x99\x73\xed\x2b\x17\x1d\x41\x6c\x0c\xda\x24\x2b\x5b\x63\xc1\xde\x06\xe0\xf9\xe2\x88\x18\xaa\x66\xcc\xd8\xc1\x89\x28\xf3\x09\xeb\x08\xdd\xb2\x69\x98\xf0\x5e\xbb\x71\x44\x2b\xf5\x81\x26\x1b\xe4\xc2\x3d\x17\x41\x55\x20\xc5\x70\x2a\x95\x4b\x94\x0c\x5f\x3a\x2c\x78\x4b\x72\x3f\x39\xb9\x58\x0a\xa3\x3b\x42\xb3\x77\x69\xd2\x81\xdb\xff\xf3\xcf\x67\xfd\x60\xab\xaf\xa5\xad\x1b\xa9\xb2\xf4\x86\xa7\x98\x84\xa2\xc9\x81\x7d\xdc\xa0\xdb\x3b\x6f\x10\x5c\xbd\xf3\x41\xbe\xb9\xe1\xe9\xc7\x58\x6e\x9f\xef\x6c\x97\x9b\xc0\x7a\xf3\x94\x09\x63\xb9\xa0\xd2\xe4\x00\x1e\x3b\x20\x27\x1c\xab\xe3\xed\x5f\x88\x5a\x9a\x4f\xb8\xa8\x90\x17\x02\x41\x80\xe4\xb3\x7c\xc1\x5b\xe4\x9a\x19\xac\x6b\x86\xd2\x60\x69\xe6\x44\xf3\xbc\xcc\x0c\x15\x4c\x96\x3a\x5b\x76\x24\xe3\xc7\xba\xa5\xd3\x8c\xbd\xc3\xd3\xdc\x5d\x7f\x09\x43\xd5\xf5\x18\x48\x88\xad\xc0\x4c\x56\x14\x99\x2a\x65\x3b\x7d\x12\x94\x9a\x50\x9c\xcf\xde\xb1\xc4\x55\x6f\x15\x59\x39\xe3\xad\x0a\x75\x77\x8d\x07\x5b\xfd\xfa\x7e\x8d\x07\xab\xb6\x6a\xa5\x66\x15\x9a\x58\xb7\xc6\xde\x8f\xa3\x4f\xe0\x47\x55\x15\xaf\xd6\x37\x03\x4c\x59\xc1\x44\x0a\xe8\xe4\xd1\x89\xc3\xe9\x6e\x6c\xb5\x1d\x2a\x78\xdf\x72\xe1\xe4\x9d\x51\xd4\x32\xf9\xdc\xb2\x73\x0f\x3d\xce\xa7\x84\x8a\xae\x0c\xfb\x73\xe9\x5f\x45\x76\x7a\xe3\x83\x2f\xdd\x6b\x0f\xcb\x68\xc1\x6a\x3d\x2c\x7b\xee\x60\x89\xd2\xcf\x1d\x74\x5d\x2f\xf6\x5a\xd3\x69\xd2\x3d\xa5\x5e\x64\xd2\xad\xe3\xa4\x5e\xd3\x88\xae\x31\xab\x0d\x9e\xc9\x5d\xfb\xc9\xc7\xd5\x7e\x72\x0a\xf8\x49\xdd\xa1\x82\x5f\xe0\x38\x0d\xdf\x99\xfb\xd0\xe9\x9c\xf7\xf1\x95\xb9\x13\x15\x89\x57\xe8\x2b\xe3\x06\x72\x68\x04\x44\xdb\xdd\xa8\x0a\x10\x4a\x21\xda\x31\xed\x4d\x77\xe9\xa3\x86\x6a\x66\xba\x78\x74\x57\x8b\x35\xbc\x3e\x88\x63\x63\x73\x4b\x28\x9f\xf4\x20\x42\x64\xf4\x77\xa7\x39\x8a\xda\x9d\x56\x67\xf4\x0b\xed\xd1\x84\x59\x48\xdd\xc2\x31\x52\xbb\xbd\x09\x35\x1d\xfb\xb5\x77\x90\xb2\x6e\xb6\x6f\xde\x9c\x1e\xf7\xb2\x66\x76\xa0\xc6\x9a\x39\x1a\x04\xbc\x59\xfe\x5b\x19\xdb\xc0\x80\x74\x18\x56\xc9\xdd\xbf\x89\xa5\x98\x25\xac\x72\xc6\x1f\x73\x7d\xdd\x1d\xec\xfb\xfb\xa3\x93\xfa\x90\xf5\xc3\xfc\xfd\xd1\x09\x71\x9f\xde\xcb\x07\xfe\x10\x27\x78\x57\xcc\xe8\x59\xc2\xaa\xf0\x58\xca\xf5\xf5\x06\x80\xc2\xbb\x9a\xa7\x45\x7a\xd6\xae\x12\x72\x9b\xfd\xf9\x1e\x6b\x34\x02\xc1\x5d\xca\x92\xdc\x38\xac\x3d\x67\xc0\x5d\xf1\xe2\x39\x39\x11\xba\x54\xac\xca\x72\x6a\xda\x72\x56\x87\xba\xb7\x39\x07\x70\x86\xfa\x79\x6f\xfe\xff\xbe\xe9\xf3\x73\x09\x28\x14\x54\x19\xb0\xc1\x7a\xc2\x4a\x87\x56\xa8\x6e\x48\xbf\x08\x1f\x20\x9e\xd3\xa9\xaf\x53\x18\x3a\xac\xad\x00\x28\xee\x6f\xb2\xe4\x12\x81\x6f\xc6\x04\xf2\x22\x00\xde\x92\x27\x29\x5b\x3c\xd1\x29\x7d\x36\x84\xc7\xf8\xea\x3a\x53\x9b\x13\xd5\x64\xef\xd9\xde\x98\x5c\xf2\x9c\x67\x54\x65\xcb\x5a\x57\xaf\xea\x3e\x2b\x4c\xfd\x80\x90\x04\xf2\x74\x8f\x1c\x48\x05\x23\x27\x54\x90\x8c\x79\x7c\x02\x77\x7c\x97\x68\x3e\x0c\xb6\x83\x17\x92\xad\x89\xc6\x20\x5b\xec\x87\xbc\xde\xa0\x38\xaf\x41\xb8\x1e\x57\xf2\x8c\x0b\x2b\xe4\xc6\xe4\x8d\x93\x4e\x4e\xec\x23\x09\xc0\xa9\xf5\x77\x6c\xd7\x16\x6d\x8d\xcf\xa2\x9b\x27\x62\xd5\xd1\xb1\x6d\x0b\xdd\xd6\xdb\x31\xe3\xe6\x82\x15\xb2\x07\x15\x0d\x07\x6a\x78\xf6\xb9\xb1\x1f\x48\xcd\xa1\x13\x0b\x35\x84\x22\x23\x4a\xca\x8c\x5a\x8b\x0c\xfd\xfa\x63\x72\x7c\x72\x7e\x71\x72\x74\x78\x75\x72\xfc\x9c\xf8\x91\x78\xac\xd3\x8f\xc9\x55\x8c\xc2\x1c\x95\x7c\x39\xa8\xdb\xf0\xac\xa1\x63\xac\x54\x54\x6d\x24\x00\x95\x92\x0a\x72\x2a\xb8\xa9\xba\x63\x61\x12\x7d\x26\x85\x4b\x8b\xb7\xbf\x76\x71\x85\x19\xc7\xe4\x4d\xe1\x06\xb3\x5f\xd7\x47\x83\x13\x8a\xbd\x64\xc2\x54\x5a\x79\x37\x36\xac\xdb\x55\xdb\xb3\x09\x2b\xd3\x37\x82\xe9\xe5\x90\x5f\x61\x40\xb6\xea\xfc\x83\x12\x35\x34\x34\xf4\xa8\xb2\x52\xd5\xfa\x0d\x8e\xc7\xfb\x63\x62\x65\xf5\xfe\x78\xdf\xab\x72\xd9\x4a\x53\xcc\x30\x68\x0c\xde\x5d\xa7\xef\x31\x21\xaf\x7d\x19\x21\xa0\x31\xad\xef\xaf\x89\x10\x84\x51\x37\xc5\xc6\x29\xf1\xa5\xec\xe5\x24\x7e\xa8\x43\xfb\x9e\xf1\x05\x13\xf8\x62\x9b\x63\xcc\x7e\xaa\xbd\xec\xda\x45\xf5\xe6\x6f\x2e\x5e\x6e\xee\xa5\x90\xb3\xf4\xf2\x4a\x47\x32\xcf\x11\x87\x7a\x1e\x50\x54\x2a\x20\x94\xc0\xf5\x36\x62\x9c\x23\xfa\xf6\xb4\xd5\x81\x6d\x70\x7c\x3f\x54\xc3\x18\x0f\x1f\xbb\xba\x5e\x51\xd9\x43\x0f\x6f\xc5\xe5\xe0\xdf\xb5\x07\x14\x75\xe2\xf3\x49\x78\x8f\x27\x17\x27\x87\xc7\xaf\x4e\xc6\x79\xfa\x08\x99\x2f\x13\x69\x21\xb9\x30\xba\xad\x61\xde\xae\xa5\x77\x57\xb6\x1d\xa6\xdd\x8f\x6e\x76\xe2\x87\x8b\x13\x3d\xfd\x33\x22\x3c\xff\x94\x19\xca\x33\x1d\x51\x98\x91\x85\xcc\xe4\x6c\x7d\x67\xaf\x07\x90\xce\x1f\x10\x11\x76\x44\x47\x96\x26\x37\x67\xb1\xb6\x6f\x07\x5c\x5f\x51\xdf\xfe\xd7\x2e\x64\xb5\x5a\xc1\x12\x84\xae\xbd\x9f\xc1\x82\x7d\x42\x13\x61\x65\x15\xd1\x27\x03\x2c\xce\xb7\x5b\xa8\xfa\x17\x44\x4d\xc2\xef\x6b\x3b\x6c\x66\xf1\xdb\x9a\x0d\x96\x9b\xb7\xed\x46\x5f\x5f\xf5\x1f\xdc\x48\x75\x21\x52\x28\x36\x0a\x30\xd1\xd0\xa5\x5a\xaa\x48\x07\x8b\x65\x8a\x77\xe2\x7a\x97\x2f\xde\x95\x2d\x9b\xce\xdc\x4a\x4b\x0f\x3e\x74\x44\xe2\xcb\xb2\x65\xd5\x04\xc4\xb9\xb4\xe8\x0c\xe1\x9f\x95\x8b\x94\x15\x8a\x2f\x78\xc6\x66\xd0\xe0\x87\x8b\x59\x84\x61\x14\xa3\x1e\xb9\x86\x3f\xf5\xa8\xd1\x2b\xfb\x57\xd4\x64\x0e\x28\xeb\xec\xf5\x15\xf4\x8a\x82\x54\x98\xce\xc6\xa4\x7d\x20\x34\xd4\x1e\x8d\x46\xe0\xbf\x3b\xf8\xb7\xb5\x6a\xd2\x6c\x40\x7e\x66\xee\x39\x12\x9a\x59\x29\xe8\xd6\x3e\x97\xa1\xb3\x10\xcc\xb5\x5a\x59\x20\x68\x4c\x8e\x73\x77\x3d\xb1\x77\x5a\xf5\x19\xc5\x79\xed\x7e\xce\x00\xa2\xba\x8a\xf9\x3f\x46\x0b\x68\x43\x42\xb4\x67\x6e\xef\xe3\x44\xeb\xce\x48\x88\xeb\x17\x4e\x2e\x50\xa2\x97\x79\xc6\xc5\x75\x85\x89\x3e\x95\x96\x8e\xb1\xae\x97\x8b\x6b\x7f\x6a\x14\xa3\xd9\xed\x12\xa3\x0d\x8d\x6e\x4c\x5a\x98\xde\x42\x09\x57\xcb\x02\xf3\xd8\x02\xf3\x72\x49\x56\x31\xab\xdf\xdb\x7b\xd4\x2b\xc6\x75\xa2\x79\x77\xf6\x7e\x7a\x79\x74\x79\x5a\xe3\xed\x82\xe0\x67\x9f\x32\x60\x77\x9b\x70\x85\x97\x7c\xd4\x16\x04\xff\xad\x5d\x86\xd3\x88\x64\x65\xdb\x5f\x62\x12\xf5\xb9\x54\x86\x66\x1b\x60\x9c\xc9\x9c\x16\x87\xa5\x99\x1f\x73\x0d\x50\x85\xfd\xa8\x7f\x37\x73\xec\xab\xe6\xdb\x48\x70\x4f\xa4\xf8\x0c\x72\xf4\xc3\xe1\x39\xa1\xa5\xa5\x3a\xe3\x5a\xe6\x6c\x2c\x3d\xcd\xaf\xc0\x25\x96\xfc\x7e\xc4\xf7\x77\x4f\xd8\xaa\xb7\xdf\x05\x85\x3f\x7a\x50\x18\xf8\xe2\xe7\x12\x08\xe6\x82\x1b\x4e\x8d\x54\xbd\x45\xeb\x8e\x4a\x6d\x64\xee\x8e\xc8\xa9\x1f\x1e\x72\x9c\x40\xd5\xaa\x3d\xb1\xde\xf4\x15\x0c\x45\x58\xde\x53\x61\xcd\x3a\x9a\xb0\x46\x9d\xc9\x10\xba\xd2\xe0\xd8\x3c\xdc\xf3\x8d\xab\x36\x02\xb8\xf5\xec\xef\xcf\x6b\x1d\x1b\x57\xda\xea\x7a\xa7\x63\xd5\xb3\x75\x63\xde\x62\xfe\x5b\x3f\xfc\xc9\x39\xf7\x71\x5d\xfe\xbb\xa4\x19\xae\xe7\xd9\x26\x3d\xe1\xf5\x7d\xec\xe5\x35\x3d\x4d\xf9\x7d\x3f\x0b\xde\xaf\x52\x23\x62\x3c\xde\x61\x14\x15\xda\x12\x43\xdd\xbf\xb0\xef\x52\x0c\xf6\xc9\x81\x49\x8a\xc1\xc6\x56\xa6\xaf\x6a\x4e\x7c\x59\xb7\xf7\x2f\x43\x15\x67\xb7\xf7\xda\x78\xde\x00\x9c\xe1\x7e\x9c\xa7\xb5\x05\x42\x95\x8c\xbc\xe4\xda\xf8\xe6\xb4\xf0\x01\xd7\xae\x9b\x17\x68\xdf\xe7\x44\x2a\xc2\x8b\x7f\xd2\x34\x55\xcf\x51\xd6\x3b\xeb\x10\xfe\xad\x03\xfa\x3a\x15\x21\x63\xe5\xc0\x2c\x0b\xd7\x34\xe2\xea\xe8\x9c\x60\x13\xea\xaf\xff\xfa\x14\x34\xf1\x3f\x7d\xf5\xd7\xa7\x1d\x49\xed\xb1\x56\xc7\x91\xbe\xbd\x90\xbd\xe7\x29\x7c\x26\x35\x14\xa0\x80\x62\xf5\x04\x48\x37\xc7\x05\x91\xee\x2d\x11\x06\x99\xdb\xa7\x9a\xba\xab\x37\xf8\x1d\xd5\x1b\x90\x50\x30\x8e\x7c\xf4\x63\xf1\x67\x64\xcd\xe7\x8f\x85\x35\xb7\x5c\xcd\xb6\x94\x5b\xa7\x58\xe4\x6e\xfb\xfb\x3a\xce\xe5\x80\x7a\xca\xe3\xb3\xcb\x7f\xbe\x3c\xfc\xee\xe4\x25\xbc\xa7\xcb\x86\xb7\xa4\xe8\xcc\x92\x36\xb9\xdb\xf7\x27\xed\xf6\x9e\xa2\xb6\xcb\xd9\x47\xc4\xfe\xec\xc5\x65\xc3\x15\x67\x3f\x79\x60\x98\xbe\xab\x6d\x29\xa6\x1d\x56\xef\xb1\x05\x09\xa0\x41\x37\x53\x9b\x29\xee\xee\x39\xc2\x10\x01\xa8\xd7\x9c\x1a\x96\x86\xf0\x1d\x3b\xfb\x1d\x5a\xd2\x06\xd9\x3a\x35\xee\xee\x60\xb2\x5d\x31\x5c\xc5\xde\xc3\xc8\x9f\x74\xb5\xbb\xa9\x87\xaa\x2f\xe4\x81\xfd\x4b\x18\xcb\x27\x3c\x58\x16\x86\x79\xd4\xca\x4a\x54\x2b\x4b\x99\x0e\xad\x7c\x3f\x03\x6a\x2d\xd6\x75\xb1\xeb\x2e\x1d\xd6\x36\xc7\x73\x0d\x9c\x7d\x13\x9f\x28\x44\x5f\xab\x5e\xbe\xad\x17\xa4\xcf\x65\xa4\xce\x55\xa5\x0b\x9a\xf4\xda\x47\xbc\xfa\x08\x3f\x01\xa0\xb7\xc7\x28\x60\x60\xe2\x1b\x2a\xb3\x0a\xcf\xee\xe7\x38\x1e\xf9\xe1\x9a\x60\x20\x0f\xa2\x12\xdf\xfb\xba\x90\x1e\xec\x25\x46\x0d\xd9\x4a\x12\x22\x5b\x27\x87\x7e\x6e\xe9\x40\xd8\xa4\xf3\xa0\x98\x4b\x23\x45\xcf\x25\xa4\xe7\x6b\x06\xad\xf3\x33\xbc\xe3\xa8\x6a\x2a\x5f\xd1\x05\x56\xd8\x84\xd0\xb4\x35\x38\xbc\xc4\x96\xc2\x07\xa9\xeb\x21\xea\xc7\xc7\x80\x8a\xf4\xf4\x78\x03\xbc\xe7\xf1\xc3\xf0\x3c\x34\x38\xb7\xb1\xf4\xd2\xb4\xa7\xba\xf4\xd3\x63\x67\x0b\xf8\xda\x73\xed\x0e\x0f\xb9\xfd\xf4\x6c\x44\x4f\x92\xca\xdc\x48\xd5\x17\x7c\xd9\x79\x6d\xb8\x46\xbe\xa2\xfb\x6e\x05\x4f\xe2\xf3\xe4\x15\xf8\x96\x8f\x9e\x5f\x5c\x42\x22\x57\xa3\x5b\x66\x93\x43\x84\x4a\xdd\x8f\xc0\x44\x1e\x0f\xf3\xe8\x55\x2b\xf9\xb8\xb0\x51\x1b\x33\x69\xfd\xa9\xe8\x65\x8d\x7e\x72\x83\x39\xd7\xa6\xa5\x8f\x8a\xdd\xd2\xc0\x8c\xdc\x43\x37\xc2\x5e\x95\xb4\xec\xa7\x1d\x17\xa9\x0b\x14\xc3\x72\x8d\xad\xfc\xb2\xcc\xee\xa7\x14\x71\x13\x40\x07\x2e\x35\x24\xd8\x47\x2f\xa7\x85\xeb\xa4\x9e\xca\x1b\x71\x43\x55\x4a\x0e\xcf\x4f\x3f\x3d\x13\xed\x5c\xfc\x88\xa7\xa0\x0b\x26\x7d\x6d\x15\x01\x85\x7e\xc2\x8d\xc6\x6c\x76\xc8\x47\x37\xb1\x0f\xc9\x0a\xa0\x90\x21\x62\x59\x98\x65\x57\x6e\x16\x91\x8e\x24\x88\x4c\x0c\xcd\x7c\x23\x5e\xd7\xcb\xff\xe9\xd3\xa7\x18\x52\x78\xfa\x5f\xff\xf5\x5f\x04\xba\x2e\xa6\x2c\xe1\xf9\xea\x8d\x70\xd7\x5f\x9e\x3d\x1b\x93\x7f\x1c\xbe\x7a\x49\x68\x02\x16\x18\x42\xaa\xe2\xc8\xb0\x77\xf1\x8f\xf5\x90\xfc\xef\xcb\xd7\x67\x55\x2b\xfb\xfa\xb7\x40\x1a\xb9\x7f\xbd\x31\x39\x8e\xd2\xcf\x63\x97\x3f\x35\x73\x48\xc9\x17\xd2\x10\x3a\x9d\x02\x71\x22\x4b\xe6\xda\xb3\x0b\x8f\x8b\xc6\x67\x73\xdf\x89\xdc\x92\x55\x06\x79\xf1\xdc\x4e\x11\x42\x2c\x1e\x4a\x10\xd3\xfc\x61\xac\x20\x1d\x60\x2a\x43\x92\xf1\x6b\x46\xa6\x1a\xfa\x91\x57\x4d\x34\x14\xd3\xd6\x7e\x4a\xa8\xb0\xa3\xe3\x60\x61\xea\x76\x12\x8f\x3b\x77\xa1\x63\xe7\xea\x1a\xc1\xfa\xc6\x70\xbe\x2e\x09\xf9\x89\x5d\xf6\xc7\x9a\x4b\x50\xd7\x17\xc3\xfb\x20\x15\x39\x28\xbe\xc0\x36\x09\xcd\xa4\x98\xc5\x44\x57\xe9\x11\x3e\x01\x71\x59\xb0\xb6\x8b\xd1\x53\x37\x95\x7e\x7a\x93\x21\xe7\x7e\x45\x8b\x6e\xed\x21\xea\xa1\xd5\x08\x0a\x91\x4e\x64\x69\x7c\xca\x1b\x3e\x09\x20\xb0\x00\x23\x11\x17\xbc\xd3\x83\x7b\x6b\x4c\xd3\x5f\xab\xb7\x9e\xfa\x2c\xd5\x05\x71\x4d\xd9\x1c\x12\x46\x93\x39\xb9\x66\xcb\x11\xb2\xf8\x82\x02\xfa\x01\xac\xf3\xb1\x5d\xdd\x5a\x9f\xf5\xaa\xd9\xbe\xb5\x03\xdd\x26\xf8\xcc\xc4\x8a\xea\x03\x7a\x82\x37\x95\xb4\xd3\xa8\x5d\xdf\x22\x11\x39\x0e\x7d\xa3\xc2\x44\x0a\xe3\x9a\x20\x86\x46\x45\x90\x69\xd9\xa8\xb0\xb7\x1c\x85\xa5\xf6\x67\xfa\xae\x27\x57\xe9\x98\x56\x64\x38\x65\xa2\x14\x2b\xbf\x06\x24\x70\xc8\x7b\xd5\xcc\xe1\xf9\x50\xdf\x00\x2f\x4a\xe9\x9c\xf3\x04\xaa\x6a\xec\xed\xee\x5e\xbf\x4a\x61\x21\x6a\x08\x00\x9a\x99\xd2\x2d\x0d\xe4\xd2\xda\x67\x33\xad\x09\x87\x37\xcc\xa9\xba\x66\x1e\xcc\x96\x66\x63\x72\x6e\x27\x19\x70\xca\xb1\x6f\xdc\x02\x8b\x20\x2c\x4f\x89\xa1\x0d\xec\x43\xf6\xc7\xe3\x7d\x94\x85\x6b\x80\x0e\x3a\xd3\x4b\x9f\x2d\xc3\x7a\x6b\x15\x56\xd7\x83\x68\xa1\xb1\x75\x9a\xb5\x0e\xa0\x3d\xa1\x04\xdc\x11\x33\xf7\xda\x02\xed\x08\x3e\x1d\x5f\x3d\xf7\xac\xea\xb7\xed\x65\x7f\x4d\x2f\x3b\x84\xc0\xeb\x57\xdf\xcd\x2e\x7b\x6c\x75\x59\x4f\x38\x76\xfc\xa7\x92\x20\x7d\xf5\xdd\xeb\xbd\xb1\x62\xde\x43\x5b\x2b\x7f\xdd\x86\x5c\x9c\xdf\xc7\xba\x00\x45\xdb\xf2\xf2\x47\x65\x4e\x9c\x4e\x81\x87\xae\x47\x6b\x89\xac\xb4\x20\x52\xec\x0a\x6c\xde\x8e\xe8\xa3\x57\x3c\xe9\xc9\xb0\x68\x5e\xdd\x0d\x8d\xe6\xd5\x25\x99\xa5\x79\xad\x9c\xf3\x20\x53\x8b\xa8\x94\x16\xb6\xc8\x48\xe8\xc1\x68\x02\x33\x18\x93\x57\x4e\xe6\x22\x71\xd3\x89\x96\x59\x69\x02\xac\xc2\x1a\x81\x0c\x83\xfa\x8e\x8d\x08\x37\xe4\x6f\x8b\xc4\x33\x28\x26\x28\xb3\xfa\x91\xd4\x78\xf5\xc8\x6c\xba\x26\xa3\xe2\xf5\x3b\x4b\x49\xc5\xab\xc7\x5d\xf0\x7a\x61\xcf\x3b\x71\xe9\x30\x25\x7d\x1d\x60\x4d\x7b\x85\xb4\x54\xa3\x51\x35\xf6\x8a\x28\x36\x3c\x6c\x8b\xb6\x5c\x5d\xdd\x1d\xaf\xee\x75\x9c\x37\xf0\xf0\xfc\xf4\xa3\x5b\x99\xd1\xb3\x76\x76\xe6\xbd\xae\x35\x0e\x5f\x00\x22\xf0\x4e\xa0\xe3\x6a\x45\x5d\x80\xcd\xf2\xdf\xdf\x81\xb9\xb2\xf2\xe2\x2f\xac\xdc\x89\x82\x52\x8d\x96\x0f\xe8\xc1\xad\x24\x54\xd4\x26\xc2\xa7\xcb\x00\x37\xfb\xfc\x4d\x9b\x2d\x35\x48\x60\xf5\x3b\xd4\xbd\x34\xaf\x66\x62\xa9\x5b\x44\x72\x09\xbd\xf6\xd1\x7b\x12\xb9\x61\x0a\x99\x3e\xc7\xa6\xcd\x54\x08\x69\xb0\xc7\xfc\x10\x9b\xf5\xeb\x21\xba\x57\xac\x92\x19\x25\x5a\xa9\x28\x84\xd9\xb3\x5a\xd9\x1b\xf1\x90\xde\x09\x88\x00\x11\xc1\xda\x9d\xf7\x43\x49\xe4\x23\x50\x93\xbd\x2a\xad\xa4\xcf\xbe\xea\xf5\x70\x23\x8e\xef\x89\x48\x27\x73\x96\x53\x6c\x70\xe1\x17\xc8\xf2\xeb\x1b\xc5\x8d\x61\x88\x7f\xcd\x54\xae\x89\x9c\x0e\xbd\x89\x84\xa8\x27\x8b\x67\x7b\xfd\xf5\xa7\xff\x08\xb6\x32\xf1\x27\xb4\x2d\x7c\xd5\x6d\x57\xdd\xf7\x5f\xb3\x23\xec\xe9\x04\x83\x39\x83\x8e\x3b\xa2\xe1\x84\xb4\x4a\xc4\x02\xd7\x7f\xab\x97\x6e\xfb\xdc\x0c\xc3\xa0\x8c\xee\xdc\x0c\x3b\x37\x43\x1f\x23\x7e\x34\x37\x43\x24\xb8\x3d\x33\x75\x1b\x10\xbb\x1e\x62\xfc\x77\xef\x7f\xa8\x70\x1d\x22\x2c\x63\x4b\xf2\xde\xf3\x20\x55\xdd\xff\xbf\x3f\x1e\xef\xef\x7b\x7f\x84\x3b\x1f\xa5\x99\x8e\xbe\x26\x4c\x24\x32\x45\xa2\xb2\xe3\x2b\x6d\x40\xa9\xad\x0c\xf0\x78\x2e\xb9\x7f\x56\x1c\x43\x80\xb1\xfb\x25\x89\x1e\x39\x94\xcf\x19\x79\xf1\x51\x55\xb0\x4a\xf1\x0a\xf0\x55\x6e\x01\x03\xca\x9f\xd3\xc0\xaa\x1c\x96\x8c\xe7\xdc\xe1\xea\x59\x76\xc1\xb4\xd1\xe4\x00\x3f\x1c\x27\x45\x39\x74\x37\x8c\x73\x96\x4b\xb5\x1c\x86\x9b\xec\x97\xb5\x5f\xb9\x3b\x06\xa0\xb5\x25\xa5\x52\x4c\x98\x6c\xf9\xfb\xd5\xdf\xfc\x12\x6f\xb1\xfa\x16\xa8\xa2\x4b\x89\xc5\xba\xab\x51\x76\x11\x80\xed\xc1\x51\x17\x56\x1b\xe4\x90\x2b\x76\x18\x06\xf7\x11\x7c\xca\xc4\x82\x2c\xa8\x6a\x5d\xec\xb0\xee\xfa\x28\x1a\x5b\xca\x17\x5c\xcb\xd6\xe5\x62\x6b\x87\x5c\xf5\x7e\x71\xd7\x08\x40\x96\xa6\x28\x8d\x93\x2e\xfe\x6c\x7b\xa8\xb9\x70\xa6\x1b\x8a\xef\xb3\xbd\x1e\x27\x57\x50\x63\x98\x12\xcf\xc9\xff\x1c\xbc\xfd\xf2\xfd\x68\xf0\xed\xc1\xc1\x2f\x4f\x47\x7f\xfb\xf5\xcb\x83\xb7\x63\xf8\xc7\x17\x83\x6f\x07\xef\xfd\x1f\x5f\x0e\x06\x07\x07\xbf\xfc\xf8\xea\xfb\xab\xf3\x93\x5f\xf9\xe0\xfd\x2f\xa2\xcc\xaf\xf1\xaf\xf7\x07\xbf\xb0\x93\x5f\xef\x39\xc8\x60\xf0\xed\x1f\x7b\x7c\x09\x2a\x96\xaf\x7b\x63\xc1\x78\x8d\x3e\x8a\x1a\x51\x1f\xbb\x67\xd2\x25\xe4\xdd\xa8\x72\x5e\x8f\xb8\x30\x23\xa9\x46\xf8\x90\xe7\xc4\xa8\xb2\x2f\xd6\x55\x89\xbf\x8f\xc7\x63\x2a\x25\xa6\x42\x6e\xf4\x86\xcd\x16\x32\x11\xcc\x1c\xfd\xe8\xde\x60\xd7\x2e\x75\xe7\x08\xbe\xcf\xf5\x51\x12\x8e\x1c\x32\xcc\xef\x3c\xdb\xe8\xd2\x75\xe4\xdd\xa5\x1a\xad\x5c\xbb\x54\xa3\xd5\x6b\x97\x6a\xf4\xc0\x6b\x97\x6a\xb4\x85\x3e\xc0\x5d\xaa\xd1\xce\x07\xf8\x48\x7c\x80\xbb\x54\xa3\xfb\x5e\xbb\x54\xa3\xd6\xd7\xe3\x4c\x35\x72\x0a\x7c\x95\x67\xb4\xb5\x69\x46\xae\xc1\xff\x61\x92\xc8\x52\x98\x2b\x79\xcd\x3a\x46\x65\xef\x65\x60\xae\x3c\x73\x3b\xad\xcd\xbe\x54\xca\x1e\x54\xc0\xfe\x94\x3f\x5a\xa6\xdc\x9a\x99\x3d\x1f\x83\x43\x37\xac\xb7\x33\xad\x58\x14\x29\x4b\xc3\xf3\x3c\xb3\x32\x76\xbf\xc7\xe4\x90\x28\x96\xf0\x82\x5b\xd6\x0e\x60\x3a\xf0\x39\x9e\x93\xd0\x0f\x98\x1b\xcd\xb2\xa9\xeb\x89\x2a\xaa\x9a\x61\x15\x99\x90\x4e\x56\xac\x7d\x0c\x6a\x05\xd2\xb7\xb1\x24\x7a\x2e\xcb\x2c\x25\x8a\xfd\xdb\xab\x13\x6e\x36\x57\xf1\x08\xb1\x23\x14\x5e\xa5\x7a\xac\x1b\x9c\x16\xdc\xa1\x6e\x6d\x13\x83\x63\xef\x0a\xae\xe0\xb0\x5d\xb2\x44\x8a\xb4\x6f\xf7\xc6\x49\x73\x7c\xbf\xd7\x2e\x9a\xc3\x52\x92\x96\x78\x03\x14\x42\xd2\x8c\xa7\xdc\x2c\x43\x16\x06\x1e\x7b\xab\x88\x62\x17\x5a\x47\x08\xba\xda\x08\x42\x8b\x42\x49\x9a\xcc\x99\x8e\xde\x06\xd5\x4a\x07\x36\x11\xea\x2b\xb3\x72\xc6\x05\x6a\x96\xf0\x1b\xab\x86\x64\x4b\xa2\xa4\xf1\x09\x65\xb7\x3c\xf0\x2a\x1a\x0c\x7e\x8e\xba\x84\x51\x4b\xc8\x3a\x93\xf1\x10\x38\x2b\x3e\x8d\xff\xd0\x44\x66\xa9\xc7\x2d\xfd\xfa\xa9\x55\xe5\x13\x47\xc5\x96\xdb\x03\xaa\xa4\x91\x24\xb3\x6a\x91\x95\x00\xb7\xff\xf8\xab\x3f\x93\xb9\x2c\x95\x1e\xc7\x10\x02\xcf\xe0\x33\x74\x52\x78\x53\xc0\x90\x8c\x51\x6d\xc8\xb3\xa7\x24\xe7\xa2\xb4\xb2\xbc\x27\xc2\xeb\x4b\x7b\x8d\xf4\xd6\xbf\xfe\xb9\xe3\x68\xfd\x68\xac\xab\x19\x2c\x8e\x5a\x0b\xec\xcf\xe6\x14\x57\x77\xc6\x11\x14\x03\x7b\x34\x36\xd4\x58\x27\x92\xe2\x5d\x14\x46\x6e\xf8\xe4\xff\x56\xca\xc9\xd2\x74\x87\x81\xf9\x6f\x1c\xa7\x8e\xff\xe2\x3f\xbc\x0f\x96\x6a\x05\xa5\xda\x62\x2a\x1b\xef\x16\x3d\xe3\xda\xb4\xea\x15\x5d\xe1\xc6\xb4\xf8\x71\x57\x61\x3e\xb3\x16\x6f\x2f\x45\xeb\x60\x3b\x7b\x5b\xcd\x3b\x95\x93\x84\x69\x60\x45\x1e\x3e\x0d\xfc\xb3\xf8\xd4\x96\x0f\xdd\x2e\xc4\x96\x3b\x11\x59\x3c\xf1\xf7\xd0\x19\xb3\xd3\x62\x75\xd1\xed\x3d\x61\xf7\xb4\x5a\x38\x58\x9d\x47\x68\x2e\x66\xd8\xc8\x32\x2f\x33\xc3\x8b\xac\x5a\xb9\xf0\x03\x27\x80\x63\x87\x3f\x8d\x3c\xcc\x14\x81\xa3\x10\x1a\x1c\x82\x23\x07\x61\x2c\x26\x0c\xf6\x63\x54\x56\x8e\x17\x54\xd1\xb0\xfc\x89\xcc\x73\xaa\x07\x2e\x76\x40\x21\x77\x05\x39\xbb\x15\xc3\x8a\x66\xe1\xf5\xe3\x5c\x81\x4d\x11\xae\x61\x82\x8a\xd6\x41\xbb\xba\xc3\x05\x86\x22\xf2\x26\xa4\xc7\x63\xff\xf4\x06\xc5\x3a\x85\xf8\x3b\x9a\x5c\x33\x91\x92\x37\xda\x2f\x5c\xba\x14\x34\x77\xe0\xea\x85\x92\xd8\xb7\x9b\xa5\x8d\xdf\xeb\xa1\x73\x24\x22\xca\x88\x07\x81\x42\x7d\x6b\x53\xab\x58\xea\x9e\xd0\x75\xdf\x68\xab\x7c\xdd\xcd\xef\x34\x3a\x69\x15\x5f\x24\xcc\xeb\x8e\x76\x02\x9b\x7a\xf9\x45\x6b\xc4\x37\xb2\x1e\x87\xc9\x35\xcd\xc4\x53\x08\x22\x3d\x04\x1f\x01\x47\x9d\x66\x96\xc5\x2d\x03\xbc\x4e\x83\xc0\x26\xcb\xcd\xb5\xec\x57\x93\xee\x00\x4d\xfb\x17\xdf\x1d\xd7\x99\xd9\x05\x4d\xa5\x26\xdf\x65\x32\xb9\x26\xc7\x0c\x8c\x86\x8f\xd9\xee\x5d\x4d\xd2\xc7\xdd\xa6\x31\xa7\xb3\x76\x79\x1e\x23\x92\x4b\xc1\x8d\x54\x6d\xf8\xf1\x16\x81\xed\xed\x5a\xed\xad\x07\x11\x57\x93\xf4\xb3\x69\xb4\x67\x89\xbc\xa7\x0e\xbb\x73\x46\x14\xb0\x18\x18\xd4\x77\xff\x68\xc9\x30\xfe\x30\x97\x37\x23\x23\x47\xa5\x66\x23\xde\x3a\x4f\xa9\xf3\xfa\x5c\xb3\x25\x24\x7d\xf5\xb2\x42\x3f\xe2\x60\x35\x13\xdd\x48\xf0\x9c\xc3\xe7\x56\x91\xbb\xf8\xee\xd8\x4a\xef\x71\x6c\x96\x3c\x61\x26\x79\x92\xb0\x62\xfe\xc4\x4d\xe7\xd1\x2f\xab\xe7\x8f\xfd\xac\xeb\x21\x49\x64\x96\x39\xdc\x2e\x39\x25\x47\xac\x98\x87\x47\x6c\xc7\x5a\x3d\xe6\x66\x69\x85\x94\xfd\x34\x56\x8a\x58\x84\x1d\xd3\x71\x88\x88\xd0\xd5\xe4\x61\xbd\xa0\xb7\x91\xb4\x3f\x61\x4f\x92\x36\xbd\xe5\xb6\x62\x79\xb7\xa7\x47\xdd\xfe\xa5\x1f\x0e\xfc\x3f\x51\xb8\xb9\xde\x92\xce\xe7\x8b\xd6\x58\xf4\xe9\x14\x2d\xcc\x94\xa5\x44\x2e\x98\x52\x3c\x65\x9a\x04\x1e\x1d\x3b\x96\x78\xb6\x1d\x2b\xbf\xeb\x8e\xf7\xb8\xf2\x03\xb6\xc7\xa7\x10\x31\x6f\x3b\xe6\x2a\xf3\xa6\x69\xce\xc5\x76\x50\x79\xcb\xf5\xd2\x09\xcd\xd8\xe9\xeb\xce\xa6\xf7\x25\x8e\x53\xb7\xbe\xfd\x87\x11\xc8\xfe\x07\x80\xe7\x7f\x0c\x34\x4b\x84\x4c\xdb\x45\xc3\x36\x6c\x43\xcf\xa8\x61\x37\x2d\x15\x9f\x51\xc5\xea\xdb\xfe\x1e\x2c\xaf\xc7\x6d\x83\x6f\xa8\x41\x46\x74\xae\x11\xf5\x7e\x53\xea\x94\xa3\xa0\x7e\x5c\xcb\x7e\x29\x1a\xfd\xc5\xfc\xd1\x3c\x3c\x3f\x25\xdf\xe3\xf3\x36\xd7\xf1\x43\x49\x83\x96\xcc\xb1\xcc\x29\xef\xa9\x11\x7b\xd4\xd0\x29\x7e\xe1\xf3\xf0\x30\x82\x4f\x8b\xbb\xd0\x4f\xf9\xac\x54\x2c\x25\xce\xfb\xb1\x6b\x63\xb0\xc5\x6d\x0c\xfa\x55\x8a\x2b\x9d\x38\xf2\x98\xfb\xca\x98\x4a\x0f\xf6\x54\x04\xea\x40\x48\x41\x22\x9a\x09\xcd\x21\xeb\x20\x4a\x8c\x03\x65\x19\xf2\xbf\x43\x19\x0c\x2a\xce\x43\xf2\x52\xce\xb8\xf0\xdc\x49\xba\x64\x97\x29\xe5\x59\xb7\xe5\xdc\x69\xba\xbf\x33\x4d\x57\xeb\xec\x44\xd0\x49\xd6\x3e\x93\xb1\x2e\x78\x33\x0a\x79\x52\x0c\xc6\x7c\x92\x72\x6d\xff\x4b\x2e\x2f\x5f\x42\x6c\xb6\x14\xde\x32\x84\xa8\xa3\x13\x1b\xa1\xbe\x18\x99\xcb\xe6\xf8\x01\xf2\xec\xde\xfa\x54\x9c\x8a\xd4\xbe\x2e\xd3\xb5\x04\x60\xf7\x14\xec\x02\x12\xaa\xd7\x30\xfb\x70\xc2\xc8\xd5\x9c\x27\xd7\xe7\x51\x08\x56\x2a\xfb\x99\x88\x3e\xaa\x29\x1a\xcd\xef\x36\x25\x70\xdc\x6b\x9d\xf7\xe5\xf6\xba\x8a\x24\xee\xa5\x5b\x32\x3b\x38\xa1\x5a\xcb\x84\x57\x31\x7f\x70\x0a\x57\x22\x39\x05\x91\xbc\xb9\x65\x00\x2d\xf1\xa3\xe8\x1f\x9e\x70\x9c\xd2\x4a\x75\xac\x6f\x70\xe1\x57\x6b\x63\xaf\x8e\xa4\xdc\x5b\x77\xcd\xab\x5a\x3f\x4d\x6f\xf5\x35\xc2\xcf\xbe\x1e\xd4\x11\x8a\xd7\xe7\x5d\x03\xe7\x55\x52\x09\x7d\x35\x5d\x7f\x8f\x8d\x2c\x56\xfb\x62\xed\x75\x5e\xb8\x46\xee\x0d\x7e\xe6\x02\xd2\xc0\x54\x0a\x59\x94\x19\x66\xad\x76\x6f\x2b\xea\xa3\x79\xf8\x9c\x0d\x04\xa8\xb7\xad\x19\xd1\x43\xcb\xf9\x3e\x8f\xbe\x44\x91\x41\xf0\xf4\xaf\x7f\xfe\xf3\x63\xef\x54\xd4\xcd\x71\xb6\xe9\x56\x45\x9d\x42\x5d\x3b\x94\x82\x1d\x4a\xc1\x5d\xd7\xc6\x23\xb1\x9f\x1e\x87\xa0\x97\x22\xb1\x3e\x0a\xc4\xba\x22\x0d\x74\x2c\x2e\xeb\xa7\xb0\xac\x33\x96\xc0\x47\x45\x10\xe8\xa9\xc6\xaa\x3b\x5a\xc0\x0e\x23\xe0\xf7\x81\x11\xd0\x5f\x6d\x55\x5f\x78\x00\xdd\x6b\xaa\x3e\xff\xda\xff\xce\x6c\xa2\x6b\x85\xf9\xc3\xeb\xca\xfb\xea\x5f\xd1\x97\x9f\xbd\x37\xc7\x40\xcd\xab\xeb\xec\x5d\x4f\x19\x98\x79\x5d\x21\xbe\x1b\x69\x99\xc6\x06\xad\x5d\xd2\xd9\x59\x80\x53\x91\xad\x64\x70\x9d\x6a\x70\xa4\xd7\x97\x8d\x10\x7b\xf8\x78\xfb\x23\xeb\xbb\x10\xf3\xae\x8d\xfa\x2e\xfe\x18\xae\x5b\xe2\x8f\xba\x86\xf1\xea\x3d\x82\xc0\x09\x41\x05\x93\x93\xb8\x8f\x4a\x75\xfe\x0f\xcf\x4f\x49\xa2\x18\x40\x1a\xd0\x4c\x8f\xc9\x1a\x0d\xcd\x47\x6a\x9c\x46\xe7\x35\x33\x6a\x0c\xcb\x0b\xd3\x95\xe0\x76\xe1\xc7\xdf\x59\xf8\xb1\xe7\x98\xc1\x4f\x61\x38\xef\x2d\x9a\x97\x39\x15\x23\xcb\x2d\x20\x10\x59\xcb\xe7\x68\x08\xbe\x31\xf1\x35\x70\xb8\x9a\x54\x31\x04\x37\x2f\x05\xff\xad\x64\x95\x7f\x21\xa8\x17\x5b\x10\x6a\x81\x79\xf4\xbc\x76\xa8\x3a\x35\xb8\x48\x22\x57\x4a\x99\xdc\x82\x84\x75\xf4\x0c\x23\xd2\xbf\x6a\xbe\x32\x33\x67\xa8\xa6\x9d\x03\x38\x40\x75\x57\xdd\xbe\x43\x03\x8f\x66\x99\xbc\xc1\x67\xc7\x8a\x87\xdd\x3f\x3b\x17\x87\xc7\x31\x61\x24\xe7\x4a\x49\xe5\x42\x3c\xf1\x74\x30\x2d\xc7\xda\x89\x4c\xa1\xc1\xa5\x5c\x56\xc5\x25\x33\x31\xa9\x18\x49\xa8\xc0\xc2\x45\xfb\x6f\x9f\x94\x8c\xfd\xcf\x1c\xbf\x9b\xb0\x39\x5d\x70\x59\x2a\xfc\xb5\x91\x64\xcf\x7d\x05\x22\x77\x29\xcb\xe0\xe6\x2e\xa1\x4e\x29\xbc\x9d\x5e\xb3\x4e\x67\xd5\x97\x60\xa0\xa6\xd2\xfb\x0f\x47\xec\x1d\xd7\x66\xf5\x5d\xfc\x12\xf9\x06\x09\x9b\xa0\xbc\x85\x2e\xac\x80\xfd\xa9\x75\xcd\x69\x9d\xde\xe2\xd1\xea\x2a\xe9\xe2\x12\xbe\xfa\x90\x42\xea\x90\x5a\xb0\x54\xdc\x17\x85\x3d\xbe\x74\x4f\x7c\xcb\x96\x9d\x99\x76\x1a\xf1\x63\xd1\x88\x43\x82\x44\xc6\x93\xe5\xe9\x71\x3f\x3a\x5f\x48\x8c\xb0\x83\x92\xef\xa8\x66\x29\x79\x45\x05\x9d\xa1\x73\xe4\xe0\xf2\xfc\xbb\x57\x03\x4b\x24\xe0\x7c\x39\x3d\x5e\x9b\x3d\x71\x19\xcf\xec\x6c\x53\xe5\xdb\xa4\xb9\x46\xbd\x69\x05\x0f\x5c\xa5\x8d\x15\xb0\x93\x20\xd9\xbb\xb4\xec\x5a\x05\x37\xc2\x74\x08\x8f\x54\xa6\x9b\xec\x75\x91\xa7\xd7\x1f\xf3\x75\x23\x5f\xf5\x5d\xef\x74\xbf\x40\xd3\x3d\x82\x49\x8d\xbd\x57\xd4\xb0\xd9\xf2\x98\x15\x99\x5c\xda\xed\x3e\x8f\x5c\xe7\x78\xeb\x04\x45\xbd\x9a\xd0\x84\xa8\x32\x63\xd8\xbd\xa6\x09\x11\x26\x18\x4b\x2b\x3e\xc5\x85\x36\x14\x00\xc2\x70\xfc\x3b\x67\x74\x6f\x01\x73\x5f\x51\x32\xc2\x79\x7e\xf0\xae\x3a\x9c\xa2\x3d\x50\x77\xfe\xe4\xfe\xc2\x04\x1e\xff\x61\x0a\x7d\x48\xf0\xf0\xde\x61\xc2\x3a\x81\xc3\x99\xbe\x28\x33\x2b\x3a\xb2\xb4\xd1\x44\x14\x74\x2b\xb7\xc7\x88\xcc\x00\x1c\xc0\xce\x7e\x48\x26\xa5\x55\xbc\x98\xae\xf9\x97\x57\x61\x29\x6f\xe6\x18\x37\xb6\x3f\x22\xb4\x28\x32\x8e\x79\xbd\x52\xb9\xe0\x6f\xe4\x6d\x5c\xbd\xed\x3e\x8c\xe4\x81\xfa\xc7\xc3\xf4\x8d\x11\x59\x30\x35\xb9\x0f\xa6\xc2\x43\x55\x09\x5a\x70\x88\x9d\xdc\x5b\xf3\xa8\x83\x42\x9e\x9f\xe2\xaf\xbd\xa5\x16\x9b\x66\xfe\x4b\xdc\x41\xb7\x37\x1e\x50\xd0\x75\xa5\x41\x6b\x23\xa0\x02\x1d\x9e\x9f\x22\x0c\x95\x03\x06\xaa\x5c\x16\x56\xb7\xa7\x98\x1c\x58\xa1\x11\xd2\x99\x1d\xd1\x10\x29\xc2\x43\x99\x28\x73\x86\x60\x42\x55\x3b\x2b\x6b\xf0\x89\x65\x35\x7a\xe5\xf1\xb0\xf6\xc9\xfd\xd5\x89\x87\x87\xd1\x1f\x18\x36\x7f\xb0\xe4\x11\x52\x5c\xb8\xd7\x7c\x73\xf1\xb2\xdd\x26\x9e\xd5\xc7\x70\xe0\x31\x0c\x70\xf2\x0a\xaa\x0c\xa7\x19\x29\x55\xe6\xc3\x70\x98\xf4\xee\xd2\xd2\xe6\x74\x11\x01\xec\x8c\x09\xf9\x02\x77\xce\x2d\x2c\x9e\x4f\x6c\xef\x8a\x3b\x3f\x2d\xb3\x6c\x48\xa6\x5c\x50\xcb\x76\x59\x41\xe2\x70\xd0\x25\x17\x89\x35\xbf\xac\xad\xef\xfa\xb5\xc0\x8c\xbc\x51\x16\x0e\x29\x44\x19\x21\x5a\xca\xb2\x14\x40\x17\xe1\x11\xf6\xc0\x26\xe0\x22\xb0\x56\xe3\x51\x56\x6a\xc3\xd4\x85\xb4\xc2\x20\xca\x6b\x01\x38\x0a\x1a\x7f\xfd\x1d\x17\x29\xa4\x30\x5d\x80\xe0\x48\xa8\x20\x8c\x83\xf3\xc5\x0e\x09\x71\x6a\x4b\x3b\x15\x41\x1d\xe8\x32\x99\xdb\x57\xda\x2b\x64\xaa\xf7\x2c\x1b\xd9\x43\x17\x9d\xde\x1b\xd8\xbf\x9a\xef\x80\x69\x2a\xd1\xef\x9e\xd0\x82\xef\x0d\x86\x04\x16\x08\x02\x67\xd2\xcc\x1f\x2f\x1d\xfa\x77\x05\x9b\xb8\x15\x15\x5e\xc4\x23\x00\x0d\x8a\xaa\xfb\xd7\xcd\x9c\x1b\x16\x9a\x6f\xa3\x67\x27\xe0\xab\x34\x99\x35\x21\x87\x82\xb0\xbc\x30\xe0\x2d\x26\x39\xa3\x3e\x84\xcc\x16\x4c\x2d\xad\x4d\x0e\x40\x14\x8f\xfe\xf0\x07\x7a\xec\xb4\xe0\x8d\xce\xe6\x15\x91\xc3\x09\x5b\x59\xdc\xfd\x2f\xf6\x6b\x76\x7e\x96\x45\xdc\xfc\xd1\x2e\x25\x88\xd7\x56\xcb\xf8\x93\xfd\x65\x7d\x09\xf1\x23\xe4\x96\x81\x7f\xbc\x7c\xe9\x02\x19\xb8\x56\x3f\x72\x91\xea\xd0\x6b\xcf\xe5\x40\xbb\xf5\x5e\xbb\xc8\x30\xc3\xc7\xb8\xc0\xab\xea\xeb\x7d\x55\xce\x3b\x86\xf7\x1a\xfb\x6d\x43\xdd\x39\x80\x53\xfb\x5f\xc9\x74\xfd\xd1\x69\xd4\x7f\x54\x37\x3b\x85\x24\xea\x5f\xe9\xc7\x72\xaa\xea\xb2\x58\xab\xcf\xdf\xbd\x1d\x77\x2c\xfd\x6d\x33\xa9\x3c\x00\xc0\x27\xa3\x6f\xae\x96\x05\x73\x78\xda\x64\x9a\xd1\x59\x45\x46\xc0\xf5\x50\x49\x3a\xba\xfc\xc9\xbf\x82\x26\x7c\xbd\xba\xfa\x41\x7d\xf6\x43\x1a\xec\xa8\x5a\xa5\x5b\xef\xb0\x0f\x59\xfb\xe5\x87\xd5\xd8\x30\xf8\xed\xd4\x74\x9f\xe0\x9e\xb9\xd3\x71\x76\xdb\xfa\x5f\x39\x1c\x2f\x1a\x51\x82\x87\x09\xf3\x46\x25\xe4\x1b\x81\x1e\x72\xf9\x53\x8d\x4c\x3e\x30\xdf\x5b\x88\xf6\x9a\x2d\x6f\xa4\x5a\x8f\xf9\xdd\x9a\xbe\xee\x7c\x22\xf6\xe0\xff\xe0\x01\x79\x45\x0b\xfb\xda\x55\x36\x27\x5a\xde\x2e\xb6\x88\xba\x3f\xe6\x61\xf9\xdc\x37\xa9\x66\x54\xf0\xff\x60\x0a\x6c\x62\xcf\xb1\x54\xf6\xcf\x03\x8c\x4f\xa0\xdd\x9e\xb1\xc4\x0c\x1c\xfd\xad\xe5\x7b\x1f\x20\x50\x9a\xa6\x1c\xb5\x87\xf3\x0f\xd0\xd2\xdd\x8b\xc0\xc5\xf5\xc7\x58\xf3\x3b\x0e\xd6\x87\x69\xff\xee\x00\xe7\x3d\x78\x73\xa9\xee\xc8\x61\xba\xf3\xf7\x39\xe5\xae\x6f\xeb\xd6\xad\x0a\xcb\x29\x6f\xfb\x5a\x78\x75\x58\xd7\x9c\x9a\x52\x71\xb3\x56\x20\xdd\xfd\x43\x2e\x7e\x2c\x27\xcc\xc5\x74\x1f\xfc\x73\x01\x29\x7a\x87\xe7\xa7\xfd\x6e\xc7\x2a\x88\xb4\x9b\xa0\xd5\x5b\x48\x29\x68\x3e\xe1\xb3\x52\x96\x3a\x5b\xc6\x4e\x49\x0a\x21\x69\x6b\xd4\xa3\x57\x46\xec\x1b\x42\x85\x14\xcb\xdc\xdd\x2a\x92\xac\x4c\x59\x6d\x44\x88\xdc\x2d\x24\x4f\x09\x2d\x8d\xcc\xa9\xe1\x09\x49\x24\x53\x09\x44\xf9\xe2\x91\x4a\xcd\x08\xbd\xe5\xb7\x49\xa9\x8d\xcc\x49\x4e\x95\x9e\xd3\x2c\xbb\x6d\x8f\x7b\x90\x6a\x77\xc1\x64\x8f\xe0\xfd\x6f\xfd\x72\x81\xb3\x6e\x49\xdf\x1f\x40\x05\xbf\x07\x7d\xdb\xc9\x75\x1a\x60\x71\x3b\x95\xde\x63\x0c\x57\xf8\xbe\x16\x94\xe7\x03\x1b\xf3\xa1\xd5\xb9\xeb\xe4\x7e\xf0\xbd\xee\xe0\x86\x77\xfe\x16\x12\x64\x59\x7a\x9a\xd3\xd9\x3d\x14\xc9\x97\xd6\x3a\xa0\x62\xe9\x7f\x86\x58\x91\x7a\x48\xa4\x72\x99\x1e\xa1\xf3\xb6\xfb\x2a\xc0\x8c\x2a\xf2\x1a\x82\x69\x52\xb9\x94\x69\x47\xa5\x90\x40\xcf\xd4\x54\xaa\xdc\xea\x75\x5c\x91\x69\x29\xc0\x49\xa6\x5d\x86\x35\x98\x24\xce\x57\x43\x33\x2d\xc3\x09\x84\xe8\x9c\xf0\x93\x20\x54\x93\x1b\x96\x65\x63\x72\x98\x65\x0e\xc4\x32\x02\x40\xa8\x0a\x9b\xab\x3c\x80\xc9\x92\xa4\x7c\xc6\xb4\x21\x07\x97\x3f\x1c\x0e\x40\x6a\x83\x1f\x63\x49\x0c\xf5\xd5\x60\x75\xff\x0c\xc8\xff\xb4\x04\x3d\x21\xa1\x86\x66\x72\x86\xa1\x70\xf0\xd3\x8a\x94\x14\x19\x5d\x02\x14\x7d\x41\x15\xa4\x83\x26\xe8\xa3\x21\xaa\x14\x00\xc2\xfb\x49\x25\xce\x87\x59\xc1\x5d\x38\xb9\x23\xa0\xc9\x96\x47\xfd\x03\xd8\xa4\x1f\x57\x94\x29\x56\x64\xf4\x16\xaf\xc2\x1d\xc5\xbd\x56\xcd\x05\x13\x56\x0a\x16\xc6\x18\x93\x4b\xa4\x9d\x9c\x9a\x04\x03\x95\xff\xca\x99\xa1\x29\x35\x74\x6c\x6d\xc1\x7f\xd5\xcb\xcf\x64\x96\xda\x81\x6e\xdf\xe8\x5b\xe6\x8c\xfa\xe2\xfa\x96\xeb\xf5\x53\x68\x95\xda\x70\x3b\xe8\xe7\xfe\x3c\xde\xe9\xc6\xe8\xc8\x9f\xe0\xf5\x4f\xde\x59\x53\xec\xce\x18\x5a\x6d\xae\xcd\x1f\xd5\xbd\x0c\x59\xfd\x4d\x1c\xb5\xe6\x0c\xd0\x0f\xaf\x5c\xd7\x1e\xff\x09\xb8\x50\x0f\xcf\x8e\x6f\x77\x77\x7d\xd8\x65\xf0\x01\x17\x41\x3d\x30\xf0\xff\xb1\x77\x3d\xbd\xad\xdb\x48\xfc\xde\x4f\x41\xf8\x92\x36\x88\xf3\xb0\x68\xdf\x1e\xde\x2d\x70\x52\x20\xd8\xfc\x79\x70\xd2\xf6\xd2\x0b\x63\x31\xb6\x10\x99\xf4\x92\x92\x9d\xb4\xe8\x77\x5f\x70\x66\x48\x89\xb6\x44\x51\xb1\x93\xa6\x8b\xe7\x4b\x02\x89\xa4\xc8\x21\x39\x9c\x7f\xbf\x61\xa4\x7b\xce\xc0\x4c\x6f\x42\xef\x80\x83\xa0\x00\x4a\x0f\x01\x1d\xdc\xa5\x48\x71\x85\x71\xc2\x42\x7c\x21\xd6\xeb\xb6\x8f\x24\xb9\x67\x52\x9c\x32\x7d\x70\xae\xb1\xef\x6c\x67\xa1\x34\x1f\x4d\x2f\xe4\x2a\x20\x38\x61\x1a\x01\x42\x09\x94\x07\x60\x86\x33\x91\x7a\x62\xa7\xfa\xb4\x12\xed\x3b\x6e\xa8\x03\x3a\xea\xa7\x32\x08\x16\x7a\x12\x2f\x47\x86\x10\x27\x4a\x9a\x45\xbe\x42\x4c\x20\xb9\x21\x68\x76\xd9\xaf\xbc\xc8\x33\xdf\x04\xae\xea\x4b\x79\xc2\x6e\x54\x69\xff\x5c\x3c\xe7\xa6\x44\xf5\xf3\x5c\x09\x73\xa3\x4a\x78\x72\x90\xa1\x62\x17\x06\x0c\x94\x14\x60\xb4\x64\xc3\xbe\x6a\xa8\xc9\x6e\x40\x97\xc4\xf6\x1c\x51\x72\xc3\x2e\xa5\x95\x08\x68\x44\x1e\x2b\x6b\xa8\x09\x07\x07\x91\x4a\x8e\xc1\xc6\xdd\xda\x06\x11\x42\xe9\x80\x0e\x91\xe6\xa8\x29\x0c\xda\x83\x37\xb9\x71\x4c\xdc\x9f\xd9\xdc\x99\xdd\xf2\x19\x5b\x0a\x3d\x07\xaf\xcd\xac\xc7\x6b\x91\x6a\x8a\x4c\x32\x40\xf6\xce\x15\xb0\xcc\xab\x4e\xc3\xc5\xce\x24\x35\xca\x23\x5b\x5a\xa2\x35\xe3\x4f\xcb\x7d\x80\x52\x7f\x01\x60\xda\x9c\xb2\x33\x77\x25\x4a\xf3\x1d\x79\xaf\x9a\xcd\xd8\x16\x72\xc3\x2c\x2b\x59\xf3\x42\x60\x7e\x78\x2e\x3d\xd6\x49\x3d\xee\x30\xf6\x13\x02\x4e\xdb\x3d\xeb\x45\xa6\xd1\x93\x78\x19\x9d\xec\x4c\xed\xe8\x52\x8e\x6a\xa0\x5b\x30\x99\x9e\x89\x82\xb4\x35\x82\x77\xa3\xd7\x9f\x05\x51\x66\x99\x6e\x5e\xe9\x9d\x37\xf3\x94\xb7\xbb\x9f\x5b\x85\x8d\xef\xcd\x0f\x96\x84\xe0\xf2\xd5\x6c\xa9\x34\x98\x33\xed\xd3\x66\xba\x0c\x2b\xaa\x3e\xe5\xab\x55\x9d\x5d\xa4\x5a\xcd\x35\xcf\x04\x9b\x6b\xbe\x5a\x0c\x15\x4b\x50\xb6\x69\x6b\xfe\x1f\x23\xe8\x76\x10\x3f\xa2\xd1\x45\xeb\x6d\xc4\xc3\x42\xa9\x27\x40\xa5\xc1\x42\x78\x43\xfb\xc3\x6f\xf8\xad\xf3\xfa\x99\x53\x25\x0d\xcb\x44\xc9\xf3\x02\x62\x39\x6e\xaf\xae\x29\xda\xc3\x9d\xe3\xae\x97\xed\x81\x13\x07\x50\x00\x78\x46\x51\x48\x53\xb1\xce\xc5\x86\xac\x12\x5d\x71\x1a\x63\x36\x17\x12\x82\x13\x22\x41\x3c\x63\x66\xf2\x4c\x5c\x00\xd8\xb5\xbb\xa1\x3d\x0c\xe7\x1d\x7d\xee\xdb\xbc\x71\x0e\xde\xcb\xbd\x13\x4e\x59\xaf\xfe\x7e\x55\x3a\x92\x58\x27\x0d\x7b\x9b\x86\xab\xa5\xe8\xef\x2f\xec\xa7\x9f\x7e\xec\x2c\xb4\xe4\xcf\xf9\xb2\x5a\x7e\x61\xff\xfe\xfc\xf9\xc7\xcf\xdd\xc5\x72\x89\xc5\xfe\xd5\x3d\x3e\xda\x6d\x93\xe9\xf9\x07\xa0\x77\xe6\xa3\xe9\xe2\x4e\xb9\x84\xa6\x1e\x79\x5e\x54\x9a\x42\x3e\x13\x55\x84\x9f\x9b\x75\xc0\xa1\x52\x83\x15\xb8\x6b\xd1\x05\x7b\x51\x10\xd8\x63\x2e\x85\x81\xab\x47\x2a\xa9\xc5\x4c\xcd\x65\xfe\x87\xc8\xdc\xcd\x23\x10\xd8\x01\x09\xcc\xdd\x12\x67\x42\x66\x78\xe7\xa3\x3d\xf3\x16\x5c\x66\x45\xcc\xe1\x9f\x30\xd2\xe6\x0e\xde\x8b\x64\x70\xf2\x0c\x22\xd8\x75\x5d\x63\x8b\x5c\x70\x73\x25\xb9\x9f\xf0\x44\x43\xb2\xed\x35\x52\x64\x8c\x77\x11\xc5\xba\xa5\x8f\x3b\x7a\x1f\xaa\xac\xf0\xec\xbf\x95\xd0\x2f\x00\xcc\xa8\x05\xfb\x46\x20\xd8\x7d\x8d\xdb\x77\xc3\x20\x89\x0a\x33\xa5\x6c\xe9\xc2\xb5\x10\x53\x87\x7b\x6c\x7d\x1b\xea\x08\x74\x9f\x3b\x47\x12\x3b\x63\xb2\x2a\x8a\xae\xa2\x52\xc5\x5c\x4e\x4d\xda\xf5\xa8\x92\x69\x3a\x5e\xaa\x59\xa0\x85\xd2\xef\x6a\x1c\x68\x0e\xfc\x40\xa2\xfc\xc7\x36\x17\x34\x07\x9c\x14\xd3\x99\x1e\xcf\x99\x96\x0f\x26\xc1\x8c\x80\xbf\x21\x01\x9f\x89\x59\x5c\xde\xd2\xb0\x80\xbf\x41\xf1\x39\x69\x46\x86\x96\xae\x7f\x38\x53\xc3\x2b\x06\x9f\x62\x76\x68\x19\xfa\x37\xe3\xc3\x0e\xc1\x53\xa3\xa1\x06\x44\x42\x25\xce\x64\x82\x51\x02\x7f\xdf\x4c\x13\x83\x4e\xa2\x04\xc6\x3c\xcc\x4c\x91\x3c\xab\x5a\xe4\x72\xad\x30\x0b\xf2\x20\x19\x6e\xba\x53\x71\x4b\x94\xdb\x00\x67\x25\x59\xce\x0b\xbf\x4d\x91\xd6\x2a\xb4\xac\x32\xfd\xc6\xee\xf8\x08\xe2\xd8\x8f\x83\xe8\x20\xe1\xc8\xab\x42\xfc\x96\x97\x8b\x5b\x97\xed\x9c\x56\x75\x59\xad\x0a\x18\x6c\xe3\x85\x5d\x42\xd3\x5a\x32\xbc\xc4\x1b\xb2\xc4\x4c\x2d\x97\x42\x66\x18\x44\xb4\xe4\x4f\x82\xd5\x17\x2d\x5a\x19\x0f\xc4\x60\x68\x4e\x3c\xaf\xb8\xac\xe5\xc4\xb5\xe5\xe5\xb1\x15\x95\xb8\x9e\x52\xcf\xda\x64\x50\x45\x1c\x4c\xd1\x40\x43\x04\xa0\x09\xf6\x20\x0a\x05\xd0\x69\x8c\x14\xc5\x58\x66\x2a\x0a\x2c\x99\x9e\xd2\xa9\x47\x99\x15\x85\x9c\xd7\x79\x9c\x4c\x01\x97\xa0\x12\x07\x56\x52\x9c\xb2\x29\x89\x30\x69\x52\x51\x0a\x3b\x4d\x64\xa5\xc9\x07\x62\x9d\xfb\x60\x30\x65\x5d\xbd\x26\x6d\xd7\xee\x59\x0a\x75\x5d\xe1\xff\x67\xfa\xfa\x9b\x08\x86\x91\x37\xdc\xd2\xf5\xa9\xe0\x69\xbb\xc5\xbc\x66\x78\xc5\x2e\x98\xea\xc6\x6c\x32\xbd\x38\xbb\xbf\x38\x61\xbf\x7c\x3d\x87\xbf\xe7\x17\x57\x17\xf6\xef\xe4\xf6\xe6\xe6\x62\x72\x6f\xe5\x88\x63\xcc\xb3\x6e\xd5\x38\x4b\x5d\x7b\x1e\xa9\x90\x5b\x70\xf9\xc2\x1e\xab\xd2\xb2\x83\xfa\x63\x41\x2f\x38\xda\x00\x78\x96\x59\x95\xf1\x1f\x37\x87\xed\x04\xdf\x36\x9b\x34\x2f\x93\xc0\xd4\xf4\x04\x96\xea\x17\x93\x92\x17\x49\x32\xea\x20\xe8\xf2\xe8\x95\x70\x83\xdf\x25\xfb\x59\x69\x46\xf7\x68\x7d\x61\x47\x2b\x95\x99\x23\x02\x75\xd8\xff\x4f\xf1\xd1\xa7\x42\xcd\x8f\x3c\xd6\x43\xb0\x42\xcd\x99\xa9\x1e\x3c\x06\x07\x4e\x53\x28\x7d\xec\x8a\x05\xd0\x85\x13\x0f\xc4\x69\xd4\xf2\x8d\x07\x75\x9a\x05\x9a\xed\x7e\x82\x4b\xb4\x82\x92\xf6\xc1\x76\x83\xc7\x9f\xda\x7b\xe0\x04\xa7\x5c\x6f\xd5\xf8\x5d\xda\xe5\xba\xc9\x8b\x6c\xc6\x75\xb6\xb3\x66\xe1\x70\xc3\x29\x07\xea\x61\x5e\x5a\xbc\x83\xb8\x6e\x9c\x92\x53\xa8\xb5\xd0\x05\x5f\x61\x84\x38\x24\x06\x86\xd0\x23\xf8\xc8\xb9\x58\x09\xc0\x41\xb9\x5b\xb1\x85\x9c\x15\x0a\xf2\x60\xe0\xc9\x78\x12\x0e\x1d\x43\x91\x5c\xd2\x3f\x02\xd3\xd4\x3b\x64\xf4\x61\xd9\x1c\x84\x19\x0f\x5a\xbd\x18\x98\xdc\x99\x4c\xc5\xe3\x36\x50\x69\xf4\x92\xaf\x60\x23\x42\x99\x8d\x4e\xd8\xc8\xe7\x0b\xc9\x48\x4a\x1e\x1d\x8f\xea\x02\x4d\x9c\x12\x08\xc9\xe4\x12\x1a\xc3\x77\x9a\x68\x46\x98\x60\xe7\xb8\xf2\x9f\xae\x73\xbe\xd8\xa3\x8d\x8c\x58\xd0\x87\xb0\xa1\xd3\xa0\x23\x3b\x5f\xad\x21\x76\xbd\x5f\xb4\xdd\x6f\x54\x2f\x01\x8e\x8e\x50\x3d\x22\x8e\x16\x76\x36\x5c\x40\xda\x5d\xb0\x78\xbc\xe3\xad\x99\x94\x26\xd7\x6c\xc5\xb5\x55\x45\x5c\xc9\xf0\x3e\xae\xe3\xde\xdb\xb8\x12\x16\x41\xc3\xbf\x92\x28\xb5\xdf\xf9\x1a\x93\x82\x1b\xd3\x62\x79\x05\x46\x60\x1b\x66\x02\x5b\x66\xdc\x39\x9f\x20\xc9\xf3\x82\xaf\x23\xe9\x08\x12\x3a\x5d\x72\x3d\x17\x65\xdc\x33\xc2\xe5\xcb\x6d\x34\x0d\xd9\x38\x39\x71\xe9\x38\x6d\x37\x3d\x8f\xeb\xa4\x57\xe3\x5c\x96\x63\xa5\xc7\x58\xe5\x0b\x2b\x75\xd5\xe5\xe3\x2a\xf3\xa5\x50\x55\x79\x27\x66\x4a\xb6\x23\x1a\xa8\xdc\xc1\x5c\x3d\x03\x60\x1e\xe4\x6d\x3c\x73\x62\x84\xc3\x7a\x34\x8d\xec\xb5\x8c\xe1\x3c\x8c\x61\x12\x94\xdb\xab\xeb\x7d\x26\x9b\x01\x8c\x39\x3e\x93\xbf\x12\xdb\x97\x73\xdf\x53\xea\x79\xb4\xda\x75\x55\x0e\xaf\x34\xf1\x9e\xab\x78\x69\x22\x46\x3c\xf1\x45\xe7\xf8\x4d\xc9\xcb\x6a\x67\x35\x04\x73\x43\xcc\xf2\x0e\x21\x65\x24\xd3\xdf\x41\xbd\xa6\x91\x6f\x17\xff\x8f\x79\x64\xa1\x9c\x0b\x56\x3c\x65\x54\xd1\xee\xcf\x52\xf3\x1c\x15\x48\x3e\x2b\x2b\xc0\x26\xf3\x92\x02\x1b\x29\x7d\xcd\x77\x6d\xc3\x68\x55\x19\x63\x6a\xe2\x4c\xe8\xd2\x5c\x71\x53\xfe\xb2\xca\x78\x07\x7a\x69\x2b\x60\xd1\x94\xb0\x61\x50\xb0\xde\x48\x91\x59\x0e\x4f\x24\xc0\xf6\xd8\xc6\xb2\xde\x0a\x5b\x1c\xea\xc9\xaf\x37\x90\xad\x3e\xb6\x9f\x6a\xef\xf5\x54\x59\x9a\x9c\xb5\x32\xa0\x30\x54\xa3\xaf\xb7\xf6\x38\xd1\xd0\x1a\x93\xe2\xb9\x4d\xe3\xde\xbf\xc7\x85\xe0\xb2\x3d\x5c\x7e\x6b\x45\x41\xb9\xe1\x6b\x88\x3e\xc0\x36\x8b\xdc\x8a\xac\x88\xf2\x32\xcc\x89\x50\x99\x28\x44\x07\xd8\x6b\xcf\x50\x52\xfa\xc2\x39\x7d\x20\x29\xcc\xe9\x6b\x58\xc7\x1b\xf4\x49\x08\x27\xf0\x44\x2d\x2c\x93\xf4\xe0\xb5\xa6\xed\x51\x81\xf8\xf2\x50\xa8\xd9\x13\x26\xf1\x02\x3c\x7f\xfe\x87\xd0\x2e\xee\x3c\xf7\xb7\x66\xd1\xcd\x4e\x73\x77\xeb\xa4\xa3\x9b\xbb\xde\x07\x5a\xb1\x6d\x5b\x02\xfa\xf6\x95\xae\x2d\x8b\x95\x24\xf4\xdc\xfb\x84\xae\x3a\x45\x05\xe2\xf5\x03\xcf\xc1\xae\xce\x82\xb9\x43\x20\xc7\x20\xa9\x8c\x7c\x49\xe8\x96\x4f\xff\xe9\x46\x82\x1c\x34\x1c\x35\x86\x47\xc1\x12\x40\x3e\x39\x8b\xa6\x9a\x89\x22\x57\x52\x2d\x5f\x3d\x08\x15\x96\x2e\xa4\xfb\x2e\xa7\xb4\x76\xd0\xe0\xc2\x83\x7b\xfb\x3a\x61\x00\xf5\x6f\x88\x0f\x2f\x35\xb9\xe9\x20\x2f\x93\x1c\x92\x84\x32\x4c\x1e\xe2\xd5\x0e\x02\x79\xa2\x27\xfe\x51\xe9\x4e\x05\xe6\x70\x9d\x8f\xe3\x99\x7a\x1b\xb2\xd2\x67\x77\xec\xda\x2e\x78\xc7\x72\x2f\x5f\xe5\x84\x71\xb6\xc8\x4d\xa9\x34\xb9\xd6\xe0\x72\x2e\xcd\xe1\x06\xd0\xf6\x18\xb0\xc3\x44\xc3\x4d\x7c\x17\x18\x5f\xad\x04\xf7\x97\xf9\xd0\xd9\x04\xb7\xf1\x68\x31\x53\x3a\x6b\xed\x98\xd3\xee\x5b\x65\xa9\xd6\xcf\x1f\x00\x9b\x59\x70\x53\xde\xfb\x3e\x58\x01\x21\x91\x1b\x87\xe2\x0f\x0d\xb1\x1e\x8d\x4b\xe7\xa2\x64\xfd\x52\x31\x2e\xd1\xaa\xb1\x9f\x0c\xde\x2f\x64\xd4\x63\x43\x69\xee\x55\xe3\xda\x78\xc9\xad\x31\xc4\xf7\xe9\xf9\x52\x18\x13\x05\x1a\x6d\x05\x69\x40\x1e\x5e\xe6\xf3\xf0\x52\x75\x77\xd8\xa3\x80\x80\xe1\x98\x2e\xeb\xd6\x4b\xf7\x52\x63\x20\x26\xa0\x41\xc1\x6f\xab\xbd\xa6\x6c\xb5\xe0\x26\x75\x30\x7e\x17\xf9\x10\xdf\xe4\xed\x90\xd8\x1b\x2d\xb8\x89\x41\x25\xb7\x68\xfb\xa0\x73\xf1\xc8\x26\x7c\x29\x8a\x09\x37\x87\x24\x2e\x70\x80\x53\x26\x4e\xe7\xa7\xec\x68\xda\xf0\xb6\xde\xa8\xf2\x3a\x76\x21\x42\x4f\x76\x80\x94\x1d\xfd\xa6\x7b\x79\x6f\x25\xa1\x7f\xe7\xee\xb9\x67\xf7\xee\x61\x64\x87\x7e\x88\xbd\x19\xc7\xfb\x76\xed\xc7\x70\x27\x56\x1a\x2c\x7e\xb3\xd7\xee\xc8\x1e\x30\x63\xd7\x2e\xfc\xc8\xfb\xaf\x67\x48\xbe\x89\xbb\x56\x93\xc9\xce\xe8\xee\x03\xcd\x15\xcc\xfe\xcd\x00\x3b\xbc\xf9\x3e\x37\x56\x05\x3b\xa4\xd8\xf2\xf7\x82\xed\x69\x02\x3b\xdf\x47\xe4\xf2\x71\xfc\x14\xde\x17\xc8\x9f\x81\xa3\xc5\xae\x80\xf7\x0c\xc0\x38\x77\x5f\x25\x5b\x07\xd9\x00\x68\x5d\x3c\xd2\x2d\x62\x54\x26\x58\x1f\xdf\xc3\x3d\x6d\x62\x8d\xb7\x22\x02\xe0\x43\x30\x29\x8c\xdd\x14\x3f\x44\x3e\x9f\xa8\x50\xa5\x29\x53\xfd\x8a\x6e\xaf\x12\xcb\xfa\xa7\xd6\x15\x8a\x4d\x30\xfe\x52\x75\xb6\x04\x9d\x78\x80\xb2\xd6\xaf\xf1\x0c\x68\xac\x57\xfc\x1b\xd8\x5e\xbb\x01\x77\xfb\xb7\x95\xd9\xd7\x56\x99\x02\x93\x46\xc7\xf0\xcc\x72\xe0\x19\x64\x77\x46\xde\x4d\xec\x29\xb4\xdf\x4e\xb7\x79\x20\x84\x1b\x86\x2b\xfc\x50\xc3\xaa\xaa\xfc\x70\x34\xef\xcd\xa0\x91\xdc\xde\x07\x48\x07\xd2\xbb\x80\xde\x36\x51\x01\xfe\xfa\x56\xdd\xdf\xbf\xde\x52\x12\x32\x45\xd7\xd8\x1b\x65\x66\x31\x42\xaf\x45\x16\x78\xea\x28\x77\x7b\xf8\xac\xe1\xb7\xad\xdb\x27\xb2\xb3\x3f\xff\xfa\xee\x7f\x01\x00\x00\xff\xff\xef\x60\xf6\xa9\xa9\xc4\x07\x00") func operatorsCoreosCom_clusterserviceversionsYamlBytes() ([]byte, error) { return bindataRead( @@ -125,7 +125,7 @@ func operatorsCoreosCom_clusterserviceversionsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_installplansYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\xdd\x6f\x1b\x37\x12\x7f\xf7\x5f\x31\x70\x1f\xd2\x02\x96\xdc\xe6\x80\xc3\x41\x6f\x39\xf7\x7a\xf0\x5d\x3f\x82\xd8\xcd\x4b\xaf\x0f\xa3\xdd\x91\x96\x35\x97\x64\xf9\x21\x47\x57\xf4\x7f\x3f\x0c\xb9\x9f\xd2\xee\x6a\xe5\x38\x69\x70\xe8\xbe\x24\xde\x1d\x92\xf3\x3d\xbf\x21\x29\x34\xe2\x2d\x59\x27\xb4\x5a\x01\x1a\x41\xef\x3c\x29\xfe\xcb\x2d\x1f\xfe\xe6\x96\x42\x5f\xef\xbe\xba\x78\x10\x2a\x5f\xc1\x4d\x70\x5e\x97\x6f\xc8\xe9\x60\x33\xfa\x9a\x36\x42\x09\x2f\xb4\xba\x28\xc9\x63\x8e\x1e\x57\x17\x00\xa8\x94\xf6\xc8\xaf\x1d\xff\x09\x90\x69\xe5\xad\x96\x92\xec\x62\x4b\x6a\xf9\x10\xd6\xb4\x0e\x42\xe6\x64\xe3\xe4\xf5\xd2\xbb\x2f\x97\x7f\x5d\xbe\xbc\x00\xc8\x2c\xc5\xe1\xf7\xa2\x24\xe7\xb1\x34\x2b\x50\x41\xca\x0b\x00\x85\x25\xad\x40\x28\xe7\x51\x4a\x23\x51\xb9\xa5\x36\x64\xd1\x6b\xeb\x96\x99\xb6\xa4\xf9\x9f\xf2\xc2\x19\xca\x78\xed\xad\xd5\xc1\xac\x60\x90\x26\xcd\x56\xb3\x88\x9e\xb6\xda\x8a\xfa\x6f\x80\x05\x68\x59\xc6\xff\x27\xd1\x6f\xd3\xa2\xaf\x25\xaa\xf8\x56\x0a\xe7\xff\x7d\xf8\xe5\x5b\xe1\x7c\xfc\x6a\x64\xb0\x28\xfb\xac\xc6\x0f\xae\xd0\xd6\x7f\xdf\x2e\xcc\x0b\x09\x93\x3e\x09\xb5\x0d\x12\x6d\x6f\xd4\x05\x80\xcb\xb4\xa1\x15\xc4\x41\x06\x33\xca\x2f\x00\x2a\xa5\x55\x93\x2c\x00\xf3\x3c\x1a\x02\xe5\x6b\x2b\x94\x27\x7b\xa3\x65\x28\x55\xb3\x08\xd3\xe4\xe4\x32\x2b\x8c\x8f\xca\xbe\x2f\x08\x36\xc2\x3a\x0f\x37\x77\x6f\x41\x28\xf0\x05\x45\x99\x40\x6f\x20\x93\xc1\x79\xb2\x77\x64\x77\x22\xa3\xca\x37\xe2\xfa\xcd\x74\x00\xbf\x38\xad\x5e\xa3\x2f\x56\xb0\x64\x75\x2f\xc7\x07\xfd\xf4\xe5\xcf\x9d\x71\xc9\x86\x37\x77\x6f\x3b\xef\xfc\x9e\x25\x74\xde\x0a\xb5\x9d\xe2\x18\x8d\xb1\x7a\x87\x12\x4a\x9d\xd3\x04\x2f\x35\xdd\xd1\xb2\xaf\x8e\x3f\x8c\xac\x3d\x3c\x65\x54\xfe\xd0\x94\xbd\x0f\x69\xca\xb5\xd6\x92\x2a\x6f\xa9\x89\x77\x5f\xa1\x34\x05\x7e\x55\xbd\x74\x59\x41\x25\xb6\x46\xd2\x86\xd4\xab\xd7\xb7\x6f\xff\x72\x77\xf0\x01\xfa\xba\xe8\xb8\x1c\xe4\x1c\x85\xe4\xa2\x01\x2b\xc7\x89\xd1\xc3\x86\x44\x70\x14\x2d\xda\x46\xc0\x11\x9b\x7a\xfd\x0b\x65\xbe\xf3\xda\xd2\xaf\x41\x58\xca\xbb\xab\xb3\x46\xea\x18\x3f\x78\xcd\xda\xe9\xbc\x32\x96\xd7\xf2\x9d\x48\x4a\x4f\x27\xc9\xf4\xde\x1f\x48\xf6\x82\xc5\x4f\x74\x3d\xc9\x2a\x87\xa7\xbc\xd2\x19\x0b\xe5\x0b\xe1\xc0\x92\xb1\xe4\x48\xf9\x56\x68\x55\xc9\xb4\x04\x76\x46\xb2\x8e\xa3\x2e\xc8\x9c\x13\xd1\x8e\xac\x07\x4b\x99\xde\x2a\xf1\xdf\x66\x36\x07\x5e\xa7\x08\x40\x4f\xce\x43\x0c\x21\x85\x12\x76\x28\x03\x5d\x01\xaa\x1c\x4a\xdc\x83\x25\x9e\x17\x82\xea\xcc\x10\x49\xdc\x12\xbe\xd3\x96\x0d\xb0\xd1\x2b\x28\xbc\x37\x6e\x75\x7d\xbd\x15\xbe\x4e\xa1\x99\x2e\xcb\xa0\x84\xdf\x5f\xc7\x6c\x28\xd6\x81\xad\x71\x9d\xd3\x8e\xe4\xb5\x13\xdb\x05\xda\xac\x10\x9e\x32\x1f\x2c\x5d\xa3\x11\x8b\xc8\xac\x8a\x69\x74\x59\xe6\x9f\xd9\x2a\xe9\xba\x17\x07\xea\x1b\xf4\x5f\xa8\xf3\xd6\xa4\xae\x39\x7f\x81\x70\xec\x26\x71\x78\x92\xa5\x55\x29\xbf\x62\xad\xbc\xf9\xc7\xdd\x3d\xd4\x0c\x24\xb5\x27\x0d\xb7\xa4\xae\x55\x36\x2b\x4a\xa8\x0d\xd9\x44\xb9\xb1\xba\x8c\xb3\x90\xca\x8d\x16\xca\xc7\x3f\x32\x29\x48\x79\x70\x61\x5d\x0a\xef\xa2\xcf\x91\xf3\x6c\x87\x25\xdc\xc4\x0a\x02\x6b\x82\x60\x72\xf4\x94\x2f\xe1\x56\xc1\x0d\x96\x24\x6f\xd0\xd1\x07\x57\x35\x6b\xd4\x2d\x58\x7d\xf3\x95\xdd\x2d\x80\xc7\x03\x8e\x62\x0c\xa0\x2e\x51\xa3\xd6\xe9\xc4\xf8\x9d\xa1\xac\x89\x86\x26\xa6\x5f\x19\x23\x45\x96\xdc\xbe\xf1\x0e\x76\xe4\x75\x93\x08\x7a\x59\x69\x92\x9d\xb1\xb0\x87\x54\x5e\x8e\xd3\x66\xff\xd3\xd1\x42\xfc\x69\x56\x19\x81\x89\x9c\x01\x31\x6f\xa4\xa5\x8f\xbf\x1c\xe8\xab\x4e\xed\xec\xd0\xec\x61\xc1\x91\x6d\x0b\x86\xd1\x52\x64\x7b\xd8\x68\xcb\xf9\xa1\xa3\xdb\x25\xdc\x7a\x28\x83\x8b\xfe\xa6\x15\xb1\x66\x2f\x5f\x05\xaf\x4b\xf4\x22\xbb\x04\x6d\xe1\xf2\x3b\x54\x01\xe5\xe5\x72\x80\x85\x51\x87\x68\x79\x1f\x52\xe9\x70\x8d\x68\x9f\x71\xd5\x8d\xcf\x85\xd6\xe2\x7e\xe0\xab\xf0\x54\x0e\x0e\x3b\xc1\xfd\x96\x14\x17\x8d\x81\x8c\xdd\x0e\xe5\x44\xb9\x25\x7b\xf4\x3d\x79\xe3\xf8\xb8\x91\x25\xd3\xb0\x06\xe9\x9c\x35\xde\x79\xf4\xe1\x48\xce\x9e\x8b\x5c\x76\x63\x2a\x92\x77\x12\x58\x55\x40\x37\xda\x96\x29\xa6\x70\xad\x43\x4a\x56\x69\x6a\xf6\x0c\xe7\xc9\xb8\x26\x54\x38\xd8\x32\x5d\x1a\x49\xbe\x5f\x7b\x97\xf0\x1f\x05\xd5\x0a\x9c\x0e\xbd\x45\x21\xe3\x54\x98\xf9\x80\x32\xce\x48\x55\x85\xde\x3b\x4f\xe5\xf2\xf2\x79\x22\x35\x43\x8f\x52\x6f\xef\x52\x36\x18\x20\x30\x05\x3a\x3a\x27\xfe\xbc\x27\x15\x38\x0b\x57\xce\xf8\x2a\xcb\x74\x50\xfe\x0d\x6d\x4e\x87\xe4\xf8\x58\xb0\xb4\x21\x4b\x2a\xab\xea\xbb\x4b\x04\x80\x89\x02\x7c\x81\x9e\x23\x39\xb8\xa4\xe6\x5c\x27\x1c\x9c\x37\x50\xa6\x56\xf8\x78\x54\x0e\x2a\xef\x94\xbc\x30\x89\x55\x86\xc5\x7c\x7d\x5b\xe3\x93\x04\x4b\xa8\x96\xce\x0f\x31\x07\xa7\xa2\x80\x9f\x8d\x20\x99\x47\xfc\x39\x87\x83\x17\xb7\x95\x42\x63\x15\xf7\x1a\x10\x8c\xa0\x8c\x7a\x70\x28\x2a\x8c\x30\xaf\x5e\x72\xc1\xb3\x54\x7d\xbb\x4a\xb5\xba\x82\x01\x2d\x5c\xf2\x28\x14\x20\xe3\x02\x91\xc3\xbf\xee\x7e\xf8\xfe\xfa\x9f\x3a\xf1\xc6\x96\x22\xe7\x92\x27\x97\xa4\xfc\x15\xb8\x90\x15\x80\x8e\x59\x63\xf7\x64\xff\xa7\x65\x89\x4a\x6c\xc8\xf9\x65\x35\x1b\x59\xf7\xd3\xcb\x9f\x97\xf0\x8d\xb6\x40\xef\x90\x83\xe7\x0a\x44\xd2\x5a\x03\x2a\x2a\xd7\x88\xa9\x9c\x85\x69\xc6\xc2\xa3\xf0\x45\x64\xc9\xe8\xbc\x62\xfa\x31\x32\xeb\xf1\x81\xf3\x77\x62\x36\x70\x2f\xf3\x40\x2b\xb8\x4c\xad\x49\xb3\xf4\x6f\x0c\xc3\x7f\xbf\x84\xcf\x1f\x0b\xb2\x04\x97\xfc\xe7\x65\x5a\xb0\xc1\x80\xfc\xae\xb6\x63\xbb\x70\x74\x48\x6f\xc5\x76\x4b\x31\xf2\x19\xd0\x30\x68\xf8\x82\x2b\x84\xd8\x80\xd2\x1d\xe2\x38\x05\xeb\xd3\x50\x26\x36\x82\xf2\x23\x46\x7e\x7a\xf9\xf3\x25\x7c\xde\x97\x0b\x84\xca\xe9\x1d\xbc\x4c\xed\x98\x70\x2c\xe3\x17\x4b\xb8\x8f\x96\xd9\x2b\x8f\xef\x78\xce\xac\xd0\x8e\x14\x68\x25\xf7\xcc\x71\x81\x3b\x02\xa7\x4b\x82\x47\x92\x72\x91\x50\x42\x0e\x8f\xb8\x67\x19\x6a\x55\xb2\x55\x11\x0c\x5a\x7f\x80\x90\xef\x7f\xf8\xfa\x87\x55\x5a\x8d\xcd\xb6\x55\xbc\x04\xa3\xaf\x8d\x60\xfc\xcb\xc0\x37\xa1\xb8\x68\x73\x66\x24\x24\x23\x71\xea\x2b\x50\x6d\xa9\x6e\x1e\x37\x81\xf1\xd4\xf2\x10\x31\xcd\xf6\xf8\x21\xb8\x3a\xec\xec\x11\xb6\x1e\x06\xda\x1f\x08\x0a\x67\x8b\x18\x7b\xc0\x59\x22\x7e\xdf\xf1\xc1\x49\x11\x1f\xc2\x9a\xac\x22\x4f\x51\xca\x5c\x67\x8e\x05\xcc\xc8\x78\x77\xad\x77\x9c\x54\xe9\xf1\xfa\x51\xdb\x07\xa1\xb6\x0b\x76\xb2\x45\xb2\xbc\xbb\x8e\xbb\x1f\xd7\x9f\xc5\x7f\xde\x4b\xa2\xd1\x52\x3d\x2c\x56\x24\xff\x18\xb2\xf1\x3a\xee\xfa\xc9\xa2\xd5\x90\xfa\x9c\x4a\xf0\xe2\x2e\x05\x7c\x76\x38\x9a\xc3\xe5\xb1\x10\x59\x51\x37\xad\x9d\x0c\x57\x62\x9e\x52\x20\xaa\xfd\x07\x77\x63\x56\x60\xb0\xbc\xf6\x7e\x51\xed\xcb\x2d\x50\xe5\xfc\x7f\x27\x9c\xe7\xf7\x4f\xd6\x58\x10\x33\x03\xf8\xc7\xdb\xaf\x3f\x8e\x73\x07\xf1\xc4\x68\x5d\x07\x95\x4b\xfa\x56\xeb\x87\x60\x06\x41\x42\x4f\xa0\xbf\x77\xa9\xeb\xfe\xa3\xea\xd2\x84\x5a\x18\xab\xb7\x96\x6b\x65\xa7\xcb\x05\x13\x64\x4a\xaf\x41\x19\xcc\x1e\x70\x4b\xd5\xa2\xb1\x8c\x70\x6f\x5c\x95\xa3\xaa\x15\x18\x87\x39\x4f\xc0\xfd\xa3\xdc\xa7\xdd\x80\x8a\xcf\x11\x36\xeb\xba\xc8\x3c\x46\x04\x5b\xf1\x7d\x9a\xdf\x93\xc0\x6c\x0a\xdb\xa6\xe7\x00\xe1\xbe\xa1\xcd\x28\xa1\xc8\xd9\xef\x37\x62\xa0\x3d\xa9\x49\x0c\xfa\x62\xf4\xa3\x25\x23\x71\x08\x44\xc3\x0c\x08\x09\x47\x7c\x8e\xd1\x1d\x58\xe3\xe6\x60\x58\x6d\x91\x3a\x61\x54\x5a\xee\x91\xc5\x37\x95\x15\x58\x24\x78\x44\x17\x33\x90\xdc\x51\x1e\x37\x60\xc6\x70\xe8\x0c\x8b\xcc\x93\x16\x66\xc1\xe6\x01\x79\x9f\x00\x9e\xbb\x8c\x4f\xa4\xa3\xf4\x9c\x04\xd2\x03\x3c\xfd\x09\xa7\xff\x84\xd3\x9f\x38\x9c\x3e\x2b\x06\xa6\xa0\xf5\x90\xfb\x7f\xaa\x00\xfb\x2c\xa1\xa7\xc0\xf6\x90\xd0\x9f\x08\xe4\x3e\x5b\xc6\x49\xf8\x3d\x26\xe8\x27\x02\xc2\xcf\x12\x76\x26\x20\x1f\x12\xf9\xff\x19\x96\x9f\xa5\xc3\x09\x88\x3e\xa4\xb7\x4f\x02\xa8\xcf\x16\x30\xd3\x2a\x9d\x82\x4f\xa0\x94\x3e\xd6\x6a\x06\x1c\xee\x03\x33\xd3\x28\x7b\xfb\xb4\x5d\x98\x7c\x0a\x4e\x8d\x41\xf2\xf4\x4c\x00\xf3\xee\x24\x27\x30\xd9\x69\xac\x9c\x9e\x45\xb5\x7d\x7d\x82\x88\xd7\x9c\x20\x99\x87\x00\x01\x24\x3a\x7f\x6f\x51\x39\x51\xdf\xe0\x98\xa6\x3f\xb0\xc8\xb7\xc8\x6d\x87\x28\x9b\x2e\x23\xd9\x07\x7c\x33\x65\x05\x68\xe3\x51\x4d\xb5\x2f\xcf\x98\x46\x69\x5f\x8c\x35\x1d\xed\x33\x33\x4a\xf8\x49\xe7\x00\x2b\xc8\xd1\xd3\x82\x39\x3a\x29\xf6\x8f\xf1\xb0\xf2\xd9\x44\x66\x0c\x6f\xac\x5e\x53\xfe\x87\x49\x55\x92\x73\xb8\x3d\x4f\x9c\x57\x50\x84\x12\x15\x58\xc2\x1c\xd7\x92\xea\x49\x18\x8d\xc5\xd3\x4a\xb5\x85\x9c\x3c\x0a\xe9\x3a\x27\x2c\xad\x7d\x9f\x4d\x58\x4b\xe8\x4e\x55\x09\x38\xbe\x62\x92\x86\xc5\x83\xc2\x9e\x3d\x5e\xb8\x68\xe4\x0f\xc1\xe9\xf0\xc9\xd5\x24\xa7\x77\xcd\x89\x54\x8f\xc9\xab\xfa\x04\xf3\xde\x06\xba\x82\x6f\x50\x3a\xba\x82\x1f\xd5\x83\xd2\x8f\xcf\xc7\x6f\x24\x3c\x4b\xaf\x7b\x13\xb9\x6a\xf8\x7c\x06\x56\xda\xee\x7e\x66\xb2\xbf\x6d\x06\xd4\x3b\x34\x55\x87\xbe\x08\x4a\xfc\x1a\xfa\x8d\x4a\x73\xc8\xf4\xf9\x61\x0b\x73\x73\xf7\x36\x3a\x47\x6a\xb7\x5d\x6a\x64\xea\xd6\xee\xe6\xee\xad\xfb\xe2\x44\x6d\x98\x94\xca\x4c\x36\xaa\x3d\x79\xb8\xa7\x3d\x68\xb5\xa4\xce\x3a\x57\x7f\xda\x6d\x19\x13\xa4\x5c\xc2\xad\x7f\xe1\x98\x07\x91\xa1\x94\x7b\xee\x5a\x44\xc9\x81\xd9\xa0\x9e\x53\x55\x6d\x9a\xf3\x19\x05\xe2\x28\xd8\x68\xb3\xa1\xcc\x8b\x1d\x75\x86\xd7\x8a\x4e\x1b\x4e\x94\x57\x72\xbc\x17\x73\xf5\x56\xce\x4c\xd6\xde\x54\xe4\xb5\xa3\x74\xed\xdf\x6a\xb5\x9a\x34\xf5\x9a\xd1\x69\x14\xc1\x46\x07\x95\x03\xfa\x68\x9e\x27\xf2\xdc\x3f\xc3\xfd\x78\x07\xfe\xd3\xf8\xe9\x79\x36\x1b\x3b\x27\xf0\x0d\xfa\x9a\x02\x5f\x6d\x92\xa3\x77\x94\x85\xce\x1d\xaf\xee\x1d\x8e\xa7\xed\x35\x9e\x76\xd9\x73\xd0\xcc\xac\xf4\x39\xb7\xfe\xce\xc5\x13\xcf\xba\xe8\xc9\x72\x3f\x2b\xd2\xa6\xab\xee\x30\xfe\x7e\x93\x8a\x6e\xdc\xea\xcc\xb0\x24\x99\xa1\xa3\xfc\xb0\x16\x27\x30\x3e\xa7\x00\xcf\x60\xf4\x54\xd1\x9d\x31\xc5\x74\x1d\x3c\xe9\xf6\xb1\x2a\x26\xaa\x75\x7d\x0b\xa2\x69\x37\x7a\xfe\xcd\xf9\x04\x21\x23\x1b\x8b\x4c\xba\x44\x87\xac\xab\xc7\x42\x3f\x39\x33\x4e\x58\xbb\xc7\xfa\x77\x35\x7e\xe3\x05\x23\xb6\x5b\x1c\x61\xbb\xaa\xfe\xb5\xd8\x8e\xf2\xde\x55\x9a\x58\x24\x4b\xdc\xc7\xab\x69\xa5\xd1\xd6\x63\x3a\xe0\x08\x2a\x27\xeb\x3c\xaa\x9c\xc7\x3e\x16\xfb\xa8\x06\xc3\x32\x17\xe8\x40\x78\x07\xa9\x2f\xf6\x95\xc1\xce\xbe\x83\x15\xef\xbb\x9c\x14\xb2\xa3\xec\xd7\x3c\xa0\x81\x08\xbd\xc5\x53\x5d\xed\x19\x66\xd2\x0a\xd3\x8c\x49\x9c\xb8\x58\xf5\xbe\x79\xf6\xce\x93\x39\xcc\xab\x1d\x21\x54\x84\xe3\x3b\x91\xa7\xcb\x48\x64\x40\xa8\xe7\x49\xaa\xa7\x0f\x70\xd2\xc1\xc4\x78\x58\x2d\x9a\x5d\x9a\x51\x82\x89\x8e\xf6\x74\x52\x6f\xd6\x7f\xcf\x44\x37\x7e\xc7\x2d\x3d\x47\xf6\xa8\x7f\x37\x31\x61\x97\xce\x2d\xdb\x78\x8f\xd3\xdb\x0a\x03\xed\x67\x59\x07\xe6\x6e\x1e\xcc\xd9\x3a\x58\xa4\x9f\x4f\x4c\x52\x3c\x08\x75\x7c\xf3\xb3\x4b\xc0\xd0\x69\x92\xa0\xbd\xf2\x37\x93\x2c\x6e\x29\x4e\xd2\x56\xc7\x49\xef\x79\x9a\x95\x7e\x3b\xf2\x71\xb6\xdf\x67\x4e\x54\x1f\xfe\x3c\xcb\x64\xa7\xf7\xc7\x67\x4e\xd4\x9a\xe6\x99\xa7\x9b\xb1\xb3\x3d\x73\xce\xdd\x9c\x2d\xe3\x67\x00\x0d\x47\x21\x5f\xf5\xe9\x13\xd5\xc4\xa0\xf5\x22\x0b\x12\x6d\x1b\xfb\x31\x3d\x1f\xfd\xe2\xe8\x6c\x9e\x9d\x47\xeb\xc7\xf0\xe3\xe1\x76\x42\xa2\xac\x39\x8d\xfb\x51\x8f\x05\xa9\xe6\xd8\x2e\xfd\x80\x0b\xd6\xb4\xe5\xb2\x67\x8c\xdc\xd7\xbf\x0e\x68\xef\x9e\x4b\xe1\x7c\xac\xfc\x6d\x15\x9f\x7b\x89\x61\x54\xed\x63\xe0\xd5\x91\xdd\x51\xbe\x02\x6f\x43\xf3\xca\x6b\xcb\x88\xa6\xf7\x2e\xac\x1b\xfe\x5a\x35\x54\x76\x84\xdf\x7e\xbf\xf8\x5f\x00\x00\x00\xff\xff\xaa\x07\xfe\xc9\xfd\x36\x00\x00") +var _operatorsCoreosCom_installplansYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\x4b\x93\xdb\x36\x12\xbe\xcf\xaf\xe8\x9a\x1c\x9c\x54\x59\x9a\x24\x7b\x49\xe9\xe6\x9d\x6c\xb6\x66\x37\x0f\x97\x67\xe2\x4b\x36\x87\x16\xd9\x12\x91\x01\x01\x04\x0f\xc9\xda\x54\xfe\xfb\x56\x03\x7c\x4a\x24\x45\x8d\x27\x8e\x6b\x2b\xbc\xd8\x43\x36\x80\x7e\xf7\xd7\x00\x84\x46\xbc\x25\xeb\x84\x56\x2b\x40\x23\xe8\x9d\x27\xc5\x7f\xb9\xe5\xe3\x57\x6e\x29\xf4\xcd\xee\x8b\xab\x47\xa1\xf2\x15\xdc\x06\xe7\x75\xf9\x86\x9c\x0e\x36\xa3\xaf\x69\x23\x94\xf0\x42\xab\xab\x92\x3c\xe6\xe8\x71\x75\x05\x80\x4a\x69\x8f\xfc\xda\xf1\x9f\x00\x99\x56\xde\x6a\x29\xc9\x2e\xb6\xa4\x96\x8f\x61\x4d\xeb\x20\x64\x4e\x36\x4e\x5e\x2f\xbd\xfb\x7c\xf9\xd5\xf2\xf3\x2b\x80\xcc\x52\x1c\xfe\x20\x4a\x72\x1e\x4b\xb3\x02\x15\xa4\xbc\x02\x50\x58\xd2\x0a\x84\x72\x1e\xa5\x34\x12\x95\x5b\x6a\x43\x16\xbd\xb6\x6e\x99\x69\x4b\x9a\xff\x29\xaf\x9c\xa1\x8c\xd7\xde\x5a\x1d\xcc\x0a\x06\x69\xd2\x6c\x35\x8b\xe8\x69\xab\xad\xa8\xff\x06\x58\x80\x96\x65\xfc\x7f\x12\xfd\x2e\x2d\xfa\x5a\xa2\x8a\x6f\xa5\x70\xfe\xdf\xc7\x5f\xbe\x15\xce\xc7\xaf\x46\x06\x8b\xb2\xcf\x6a\xfc\xe0\x0a\x6d\xfd\xf7\xed\xc2\xbc\x90\x30\xe9\x93\x50\xdb\x20\xd1\xf6\x46\x5d\x01\xb8\x4c\x1b\x5a\x41\x1c\x64\x30\xa3\xfc\x0a\xa0\x52\x5a\x35\xc9\x02\x30\xcf\xa3\x21\x50\xbe\xb6\x42\x79\xb2\xb7\x5a\x86\x52\x35\x8b\x30\x4d\x4e\x2e\xb3\xc2\xf8\xa8\xec\x87\x82\x60\x23\xac\xf3\x70\x7b\xff\x16\x84\x02\x5f\x50\x94\x09\xf4\x06\x32\x19\x9c\x27\x7b\x4f\x76\x27\x32\xaa\x7c\x23\xae\xdf\x4c\x07\xf0\x8b\xd3\xea\x35\xfa\x62\x05\x4b\x56\xf7\x72\x7c\xd0\x4f\x9f\xff\xdc\x19\x97\x6c\x78\x7b\xff\xb6\xf3\xce\x1f\x58\x42\xe7\xad\x50\xdb\x29\x8e\xd1\x18\xab\x77\x28\xa1\xd4\x39\x4d\xf0\x52\xd3\x9d\x2c\xfb\xea\xf4\xc3\xc8\xda\xc3\x53\x46\xe5\x0f\x4d\xd9\xfb\x90\xa6\x5c\x6b\x2d\xa9\xf2\x96\x9a\x78\xf7\x05\x4a\x53\xe0\x17\xd5\x4b\x97\x15\x54\x62\x6b\x24\x6d\x48\xbd\x7a\x7d\xf7\xf6\x6f\xf7\x47\x1f\xa0\xaf\x8b\x8e\xcb\x41\xce\x51\x48\x2e\x1a\xb0\x72\x9c\x18\x3d\x6c\x48\x04\x47\xd1\xa2\x6d\x04\x9c\xb0\xa9\xd7\xbf\x50\xe6\x3b\xaf\x2d\xfd\x1a\x84\xa5\xbc\xbb\x3a\x6b\xa4\x8e\xf1\xa3\xd7\xac\x9d\xce\x2b\x63\x79\x2d\xdf\x89\xa4\xf4\x74\x92\x4c\xef\xfd\x91\x64\x2f\x58\xfc\x44\xd7\x93\xac\x72\x78\xca\x2b\x9d\xb1\x50\xbe\x10\x0e\x2c\x19\x4b\x8e\x94\x6f\x85\x56\x95\x4c\x4b\x60\x67\x24\xeb\x38\xea\x82\xcc\x39\x11\xed\xc8\x7a\xb0\x94\xe9\xad\x12\xff\x6d\x66\x73\xe0\x75\x8a\x00\xf4\xe4\x3c\xc4\x10\x52\x28\x61\x87\x32\xd0\x4b\x40\x95\x43\x89\x07\xb0\xc4\xf3\x42\x50\x9d\x19\x22\x89\x5b\xc2\x77\xda\xb2\x01\x36\x7a\x05\x85\xf7\xc6\xad\x6e\x6e\xb6\xc2\xd7\x29\x34\xd3\x65\x19\x94\xf0\x87\x9b\x98\x0d\xc5\x3a\xb0\x35\x6e\x72\xda\x91\xbc\x71\x62\xbb\x40\x9b\x15\xc2\x53\xe6\x83\xa5\x1b\x34\x62\x11\x99\x55\x31\x8d\x2e\xcb\xfc\x13\x5b\x25\x5d\xf7\xe2\x48\x7d\x83\xfe\x0b\x75\xde\x9a\xd4\x35\xe7\x2f\x10\x8e\xdd\x24\x0e\x4f\xb2\xb4\x2a\xe5\x57\xac\x95\x37\xff\xb8\x7f\x80\x9a\x81\xa4\xf6\xa4\xe1\x96\xd4\xb5\xca\x66\x45\x09\xb5\x21\x9b\x28\x37\x56\x97\x71\x16\x52\xb9\xd1\x42\xf9\xf8\x47\x26\x05\x29\x0f\x2e\xac\x4b\xe1\x5d\xf4\x39\x72\x9e\xed\xb0\x84\xdb\x58\x41\x60\x4d\x10\x4c\x8e\x9e\xf2\x25\xdc\x29\xb8\xc5\x92\xe4\x2d\x3a\xfa\xc3\x55\xcd\x1a\x75\x0b\x56\xdf\x7c\x65\x77\x0b\xe0\xe9\x80\x93\x18\x03\xa8\x4b\xd4\xa8\x75\x3a\x31\x7e\x6f\x28\x6b\xa2\xa1\x89\xe9\x57\xc6\x48\x91\x25\xb7\x6f\xbc\x83\x1d\x79\xdd\x24\x82\x5e\x56\x9a\x64\x67\x2c\xec\x21\x95\x97\xd3\xb4\xd9\xff\x74\xb2\x10\x7f\x9a\x55\x46\x60\x22\x67\x40\xcc\x1b\x69\xe9\xd3\x2f\x47\xfa\xaa\x53\x3b\x3b\x34\x7b\x58\x70\x64\xdb\x82\x61\xb4\x14\xd9\x01\x36\xda\x72\x7e\xe8\xe8\x76\x09\x77\x1e\xca\xe0\xa2\xbf\x69\x45\xac\xd9\xeb\x57\xc1\xeb\x12\xbd\xc8\xae\x41\x5b\xb8\xfe\x0e\x55\x40\x79\xbd\x1c\x60\x61\xd4\x21\x5a\xde\x87\x54\x3a\x5c\x23\xda\x67\x5c\x75\xe3\x73\xa1\xb5\x78\x18\xf8\x2a\x3c\x95\x83\xc3\xce\x70\xbf\x25\xc5\x45\x63\x20\x63\xb7\x43\x39\x51\x6e\xc9\x9e\x7c\x4f\xde\x38\x3e\x6e\x64\xc9\x34\xac\x41\x3a\x17\x8d\x77\x1e\x7d\x38\x91\xb3\xe7\x22\xd7\xdd\x98\x8a\xe4\x9d\x04\x56\x15\xd0\x8d\xb6\x65\x8a\x29\x5c\xeb\x90\x92\x55\x9a\x9a\x3d\xc3\x79\x32\xae\x09\x15\x0e\xb6\x4c\x97\x46\x92\xef\xd7\xde\x25\xfc\x47\x41\xb5\x02\xa7\x43\x6f\x51\xc8\x38\x15\x66\x3e\xa0\x8c\x33\x52\x55\xa1\x0f\xce\x53\xb9\xbc\x7e\x9e\x48\xcd\xd0\xa3\xd4\xdb\xfb\x94\x0d\x06\x08\x4c\x81\x8e\x2e\x89\x3f\xef\x49\x05\xce\xc2\x95\x33\xbe\xca\x32\x1d\x94\x7f\x43\x9b\xf3\x21\x39\x3e\x16\x2c\x6d\xc8\x92\xca\xaa\xfa\xee\x12\x01\x60\xa2\x00\x5f\xa0\xe7\x48\x0e\x2e\xa9\x39\xd7\x09\x07\xe7\x0d\x94\xa9\x15\x3e\x1e\x95\x83\xca\x3b\x27\x2f\x4c\x62\x95\x61\x31\x5f\xdf\xd5\xf8\x24\xc1\x12\xaa\xa5\xf3\x43\xcc\xc1\xb9\x28\xe0\x67\x23\x48\xe6\x11\x7f\xce\xe1\xe0\xc5\x5d\xa5\xd0\x58\xc5\xbd\x06\x04\x23\x28\xa3\x1e\x1c\x8a\x0a\x23\xcc\xab\x97\x5c\xf0\x2c\x55\xdf\x5e\xa6\x5a\x5d\xc1\x80\x16\x2e\x79\x14\x0a\x90\x71\x81\xc8\xe1\x5f\xf7\x3f\x7c\x7f\xf3\x4f\x9d\x78\x63\x4b\x91\x73\xc9\x93\x4b\x52\xfe\x25\xb8\x90\x15\x80\x8e\x59\x63\xf7\x64\xff\xa7\x65\x89\x4a\x6c\xc8\xf9\x65\x35\x1b\x59\xf7\xd3\x97\x3f\x2f\xe1\x1b\x6d\x81\xde\x21\x07\xcf\x4b\x10\x49\x6b\x0d\xa8\xa8\x5c\x23\xa6\x72\x16\xa6\x19\x0b\x7b\xe1\x8b\xc8\x92\xd1\x79\xc5\xf4\x3e\x32\xeb\xf1\x91\xf3\x77\x62\x36\x70\x2f\xf3\x48\x2b\xb8\x4e\xad\x49\xb3\xf4\x6f\x0c\xc3\x7f\xbf\x86\x4f\xf7\x05\x59\x82\x6b\xfe\xf3\x3a\x2d\xd8\x60\x40\x7e\x57\xdb\xb1\x5d\x38\x3a\xa4\xb7\x62\xbb\xa5\x18\xf9\x0c\x68\x18\x34\x7c\xc6\x15\x42\x6c\x40\xe9\x0e\x71\x9c\x82\xf5\x69\x28\x13\x1b\x41\xf9\x09\x23\x3f\x7d\xf9\xf3\x35\x7c\xda\x97\x0b\x84\xca\xe9\x1d\x7c\x99\xda\x31\xe1\x58\xc6\xcf\x96\xf0\x10\x2d\x73\x50\x1e\xdf\xf1\x9c\x59\xa1\x1d\x29\xd0\x4a\x1e\x98\xe3\x02\x77\x04\x4e\x97\x04\x7b\x92\x72\x91\x50\x42\x0e\x7b\x3c\xb0\x0c\xb5\x2a\xd9\xaa\x08\x06\xad\x3f\x42\xc8\x0f\x3f\x7c\xfd\xc3\x2a\xad\xc6\x66\xdb\x2a\x5e\x82\xd1\xd7\x46\x30\xfe\x65\xe0\x9b\x50\x5c\xb4\x39\x33\x12\x92\x91\x38\xf5\x15\xa8\xb6\x54\x37\x8f\x9b\xc0\x78\x6a\x79\x8c\x98\x66\x7b\xfc\x10\x5c\x1d\x76\xf6\x08\x5b\x8f\x03\xed\x4f\x04\x85\xb3\x45\x8c\x3d\xe0\x2c\x11\xbf\xef\xf8\xe0\xa4\x88\x8f\x61\x4d\x56\x91\xa7\x28\x65\xae\x33\xc7\x02\x66\x64\xbc\xbb\xd1\x3b\x4e\xaa\xb4\xbf\xd9\x6b\xfb\x28\xd4\x76\xc1\x4e\xb6\x48\x96\x77\x37\x71\xf7\xe3\xe6\x93\xf8\xcf\x7b\x49\x34\x5a\xaa\x87\xc5\x8a\xe4\x1f\x42\x36\x5e\xc7\xdd\x3c\x59\xb4\x1a\x52\x5f\x52\x09\x5e\xdc\xa7\x80\xcf\x8e\x47\x73\xb8\xec\x0b\x91\x15\x75\xd3\xda\xc9\x70\x25\xe6\x29\x05\xa2\x3a\xfc\xe1\x6e\xcc\x0a\x0c\x96\xd7\x3e\x2c\xaa\x7d\xb9\x05\xaa\x9c\xff\xef\x84\xf3\xfc\xfe\xc9\x1a\x0b\x62\x66\x00\xff\x78\xf7\xf5\x87\x71\xee\x20\x9e\x18\xad\xeb\xa0\x72\x49\xdf\x6a\xfd\x18\xcc\x20\x48\xe8\x09\xf4\xf7\x2e\x75\xdd\x7f\x54\x5d\x9a\x50\x0b\x63\xf5\xd6\x72\xad\xec\x74\xb9\x60\x82\x4c\xe9\x35\x28\x83\xd9\x23\x6e\xa9\x5a\x34\x96\x11\xee\x8d\xab\x72\x54\xb5\x02\xe3\x30\xe7\x09\xb8\x7f\x94\xfb\xb4\x1b\x50\xf1\x39\xc2\x66\x5d\x17\x99\xc7\x88\x60\x2b\xbe\xcf\xf3\x7b\x16\x98\x4d\x61\xdb\xf4\x1c\x21\xdc\x37\xb4\x19\x25\x14\x39\xfb\xfd\x46\x0c\xb4\x27\x35\x89\x41\x5f\x8c\x7e\xb4\x64\x24\x0e\x81\x68\x98\x01\x21\xe1\x84\xcf\x31\xba\x23\x6b\xdc\x1e\x0d\xab\x2d\x52\x27\x8c\x4a\xcb\x3d\xb2\xf8\xa6\xb2\x02\x8b\x04\x7b\x74\x31\x03\xc9\x1d\xe5\x71\x03\x66\x0c\x87\xce\xb0\xc8\x3c\x69\x61\x16\x6c\x1e\x90\xf7\x09\xe0\xb9\xcb\xf8\x44\x3a\x4a\xcf\x59\x20\x3d\xc0\xd3\x5f\x70\xfa\x2f\x38\xfd\x91\xc3\xe9\x8b\x62\x60\x0a\x5a\x0f\xb9\xff\xc7\x0a\xb0\x2f\x12\x7a\x0a\x6c\x0f\x09\xfd\x91\x40\xee\x8b\x65\x9c\x84\xdf\x63\x82\x7e\x24\x20\xfc\x22\x61\x67\x02\xf2\x21\x91\xff\x9f\x61\xf9\x45\x3a\x9c\x80\xe8\x43\x7a\xfb\x28\x80\xfa\x6c\x01\x33\xad\xd2\x29\xf8\x04\x4a\xe9\x63\xad\x66\xc0\xf1\x3e\x30\x33\x8d\xb2\xb7\x4f\xdb\x85\xc9\xe7\xe0\xd4\x18\x24\x4f\xcf\x04\x30\xef\x4e\x72\x06\x93\x9d\xc7\xca\xe9\x59\x54\xdb\xd7\x67\x88\x78\xcd\x09\x92\x79\x08\x10\x40\xa2\xf3\x0f\x16\x95\x13\xf5\x0d\x8e\x69\xfa\x23\x8b\x7c\x8b\xdc\x76\x88\xb2\xe9\x32\x92\x7d\xc0\x37\x53\x56\x80\x36\x1e\xd5\x54\xfb\xf2\x8c\x69\x94\xf6\xc5\x58\xd3\xd1\x3e\x33\xa3\x84\x9f\x74\x0e\xb0\x82\x1c\x3d\x2d\x98\xa3\xb3\x62\xff\x18\x0f\x2b\x9f\x4d\x64\xc6\xf0\xc6\xea\x35\xe5\x7f\x9a\x54\x25\x39\x87\xdb\xcb\xc4\x79\x05\x45\x28\x51\x81\x25\xcc\x71\x2d\xa9\x9e\x84\xd1\x58\x3c\xad\x54\x5b\xc8\xc9\xa3\x90\xae\x73\xc2\xd2\xda\xf7\xd9\x84\xb5\x84\xee\x5c\x95\x80\xd3\x2b\x26\x69\x58\x3c\x28\xec\xd9\xe3\x85\x8b\x46\xfe\x23\x38\x1d\x3e\xb9\x9a\xe4\xf4\xbe\x39\x91\xea\x31\xf9\xb2\x3e\xc1\x7c\xb0\x81\x5e\xc2\x37\x28\x1d\xbd\x84\x1f\xd5\xa3\xd2\xfb\xe7\xe3\x37\x12\x5e\xa4\xd7\x83\x89\x5c\x35\x7c\x3e\x03\x2b\x6d\x77\x3f\x33\xd9\xdf\x35\x03\xea\x1d\x9a\xaa\x43\x5f\x04\x25\x7e\x0d\xfd\x46\xa5\x39\x64\xfa\xf4\xb8\x85\xb9\xbd\x7f\x1b\x9d\x23\xb5\xdb\x2e\x35\x32\x75\x6b\x77\x7b\xff\xd6\x7d\x76\xa6\x36\x4c\x4a\x65\x26\x1b\xd5\x9e\x3c\xdc\xd3\x1e\xb5\x5a\x52\x67\x9d\xab\x3f\xed\xb6\x8c\x09\x52\x2e\xe1\xce\xbf\x70\xcc\x83\xc8\x50\xca\x03\x77\x2d\xa2\xe4\xc0\x6c\x50\xcf\xb9\xaa\x36\xcd\xf9\x8c\x02\x71\x12\x6c\xb4\xd9\x50\xe6\xc5\x8e\x3a\xc3\x6b\x45\xa7\x0d\x27\xca\x2b\x39\xde\x8b\xb9\x7a\x2b\x67\x26\x6b\x6f\x2a\xf2\xda\x51\xba\xf6\x6f\xb5\x5a\x4d\x9a\x7a\xcd\xe8\x34\x8a\x60\xa3\x83\xca\x01\x7d\x34\xcf\x13\x79\xee\x9f\xe1\x7e\xb8\x03\xff\x69\xfc\xf4\x3c\x9b\x8d\x9d\x13\xf8\x06\x7d\x4d\x81\xaf\x36\xc9\xd1\x3b\xca\x42\xe7\x8e\x57\xf7\x0e\xc7\xd3\xf6\x1a\xcf\xbb\xec\x25\x68\x66\x56\xfa\x9c\x5b\x7f\xe7\xe2\x89\x67\x5d\xf4\x6c\xb9\x9f\x15\x69\xd3\x55\x77\x18\x7f\xbf\x49\x45\x37\x6e\x75\x66\x58\x92\xcc\xd0\x51\x7e\x5c\x8b\x13\x18\x9f\x53\x80\x67\x30\x7a\xae\xe8\xce\x98\x62\xba\x0e\x9e\x75\xfb\x58\x15\x13\xd5\xba\xbe\x05\xd1\xb4\x1b\x3d\xff\xe6\x7c\x82\x90\x91\x8d\x45\x26\x5d\xa2\x43\xd6\xd5\xbe\xd0\x4f\xce\x8c\x13\xd6\xee\xb1\xfe\x5d\x8d\xdf\x78\xc1\x88\xed\x16\x27\xd8\xae\xaa\x7f\x2d\xb6\xa3\xbc\x77\x95\x26\x16\xc9\x12\x0f\xf1\x6a\x5a\x69\xb4\xf5\x98\x0e\x38\x82\xca\xc9\x3a\x8f\x2a\xe7\xb1\xfb\xe2\x10\xd5\x60\x58\xe6\x02\x1d\x08\xef\x20\xf5\xc5\xbe\x32\xd8\xc5\x77\xb0\xe2\x7d\x97\xb3\x42\x76\x94\xfd\x9a\x07\x34\x10\xa1\xb7\x78\xaa\xab\x3d\xc3\x4c\x5a\x61\x9a\x31\x89\x13\x17\xab\xde\x37\xcf\xde\x7b\x32\xc7\x79\xb5\x23\x84\x8a\x70\x7c\x27\xf2\x74\x19\x89\x0c\x08\xf5\x3c\x49\xf5\xfc\x01\x4e\x3a\x98\x18\x0f\xab\x45\xb3\x4b\x33\x4a\x30\xd1\xd1\x9e\x4f\xea\xda\xa4\x9b\xf2\xe7\x62\x7f\xec\x6e\x5e\x7a\x1a\x29\xde\x33\x5d\x8e\xdf\x94\x4b\xcf\x89\x55\xeb\x5f\x5f\x4c\x58\xb7\x73\x57\x37\xde\x06\xf5\xb6\x42\x52\x87\x59\x36\x86\xb9\x5b\x10\x73\x36\x20\x16\xe9\x47\x18\x93\x14\x8f\x42\x9d\xde\x1f\xed\x12\x30\x00\x9b\x24\x68\x2f\x0e\xce\x24\x8b\x1b\x93\x93\xb4\xd5\xa1\xd4\x7b\x9e\x89\xa5\x5f\xa0\x7c\x98\x4d\xfc\x99\x13\xd5\x47\x48\xcf\x32\xd9\xf9\x5d\xf6\x99\x13\xb5\xa6\x79\xe6\xe9\x66\xec\x8f\xcf\x9c\x73\x37\x67\xe3\xf9\x19\xa0\xc7\x49\xc8\x57\xdd\xfe\x44\x4d\x32\x68\xbd\xc8\x82\x44\xdb\xc6\x7e\x4c\xf2\x27\xbf\x5b\xba\x98\x67\xe7\xd1\xfa\x31\x14\x7a\xbc\x29\x91\x28\x6b\x4e\xe3\xae\xd6\xbe\x20\xd5\x1c\xfe\xa5\x9f\x81\xc1\x9a\xb6\x5c\x3c\x8d\x91\x87\xfa\x37\x06\xed\x0d\x76\x29\x9c\x8f\xf8\xa1\xc5\x02\x73\xaf\x42\x8c\xaa\x7d\x0c\x02\x3b\xb2\x3b\xca\x57\xe0\x6d\x68\x5e\x79\x6d\x19\x17\xf5\xde\x85\x75\xc3\x5f\xab\x86\xca\x8e\xf0\xdb\xef\x57\xff\x0b\x00\x00\xff\xff\xae\xb2\xfa\x2c\x43\x37\x00\x00") func operatorsCoreosCom_installplansYamlBytes() ([]byte, error) { return bindataRead( @@ -145,7 +145,7 @@ func operatorsCoreosCom_installplansYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_olmconfigsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x58\xef\x6e\xdb\x46\x12\xff\xee\xa7\x18\xe8\x0e\x88\x9d\x93\xa8\x38\x39\xe4\x5a\x02\x41\x10\x28\xe7\x22\x48\x7c\x0d\x62\x5f\x0e\x38\xcb\x77\x1d\x92\x23\x6a\x1b\x72\x97\xdd\x9d\xb5\xad\x16\x7d\xf7\x62\x76\x49\x8a\x92\x45\xc7\x40\x5b\x7e\x11\xb9\x3b\x3b\x3b\x7f\x7f\x33\x23\x6c\xd4\x67\xb2\x4e\x19\x9d\x02\x36\x8a\xee\x98\xb4\x7c\xb9\xe4\xcb\x37\x2e\x51\x66\x7e\x73\x7a\xf4\x45\xe9\x22\x85\x85\x77\x6c\xea\x4f\xe4\x8c\xb7\x39\xbd\xa5\x95\xd2\x8a\x95\xd1\x47\x35\x31\x16\xc8\x98\x1e\x01\xa0\xd6\x86\x51\x96\x9d\x7c\x02\xe4\x46\xb3\x35\x55\x45\x76\x56\x92\x4e\xbe\xf8\x8c\x32\xaf\xaa\x82\x6c\x60\xde\x5d\x7d\xf3\x2c\x79\x99\x3c\x3f\x02\xc8\x2d\x85\xe3\x97\xaa\x26\xc7\x58\x37\x29\x68\x5f\x55\x47\x00\x1a\x6b\x4a\xc1\x54\x75\x6e\xf4\x4a\x95\x2e\x31\x0d\x59\x64\x63\x5d\x92\x1b\x4b\x46\x7e\xea\x23\xd7\x50\x2e\x37\x97\xd6\xf8\x26\x85\x83\x34\x91\x57\x27\x20\x32\x95\xc6\xaa\xee\x1b\x60\x26\x97\x84\xf7\xa8\xf8\xf7\x1f\xce\x17\xe1\xca\xb0\x56\x29\xc7\xef\x77\xd7\x3f\x28\xc7\x61\xaf\xa9\xbc\xc5\x6a\x28\x64\x58\x76\x4a\x97\xbe\x42\x3b\xd8\x38\x02\x70\xb9\x69\x28\x85\x45\xe5\x1d\x93\x3d\x02\x68\x8d\xd1\xca\x31\x6b\x15\xbe\x39\x6d\xc5\x72\xf9\x9a\x6a\xec\x84\x04\x51\x4d\xbf\xf9\xf8\xee\xf3\x8b\x8b\xbd\x0d\x80\x82\x5c\x6e\x55\xc3\xc1\xb4\xbd\x98\xa0\x1c\x20\xd8\xd6\x81\xf2\xd2\x18\xed\x54\x56\x11\xac\x8c\x85\x28\x98\xb7\x4a\x97\x72\x26\x19\xf0\xe3\x8d\x48\x6a\xb2\x1f\x29\xe7\xc1\xb2\xa5\x9f\xbc\xb2\x54\x0c\xaf\x16\xc1\xbb\x80\x18\x2c\x37\x56\x3c\xc1\x03\x2b\xc7\x67\x10\x7e\x3b\xeb\x7b\x3a\x3c\x11\x45\x23\x1d\x14\x12\x79\xe4\x80\xd7\xd4\x99\x8c\x8a\xd6\x3a\x60\x56\xc0\x6b\xe5\xc0\x52\x63\xc9\x91\x8e\xb1\x28\xcb\xa8\x5b\x05\x12\xb8\x20\x2b\x07\xc1\xad\x8d\xaf\x0a\x51\xfc\x86\x2c\x83\xa5\xdc\x94\x5a\xfd\xdc\x73\x73\xc0\x26\x5c\x53\x21\x93\x63\x50\x9a\xc9\x6a\xac\xe0\x06\x2b\x4f\x53\x40\x5d\x40\x8d\x1b\xb0\x24\x7c\xc1\xeb\x01\x87\x40\xe2\x12\x38\x37\x96\x40\xe9\x95\x49\x61\xcd\xdc\xb8\x74\x3e\x2f\x15\x77\xc9\x95\x9b\xba\xf6\x5a\xf1\x66\x1e\xf2\x44\x65\x5e\x62\x75\x5e\xd0\x0d\x55\x73\xa7\xca\x19\xda\x7c\xad\x98\x72\xf6\x96\xe6\xd8\xa8\x59\x10\x56\x87\x04\x4b\xea\xe2\x2f\x9d\x37\xdd\x93\x3d\xf3\x45\x97\x39\x16\x77\xee\x6c\x85\x98\x7e\xd0\xd6\x12\xdd\x31\x56\xe2\xf1\xa8\xcb\xd6\xa4\xb2\x24\x56\xf9\xf4\xcf\x8b\xcb\x6d\x38\x05\xb3\x47\x0b\x6f\x49\xdd\xd6\xd8\x62\x28\xa5\x57\x64\x23\xe5\xca\x9a\x3a\x70\x21\x5d\x34\x46\x69\x0e\x1f\x79\xa5\x48\x33\x38\x9f\xd5\x8a\x5d\x08\x30\x72\x2c\x7e\x48\x60\x11\xb0\x05\x32\x02\xdf\x14\xc8\x54\x24\xf0\x4e\xc3\x02\x6b\xaa\x16\xe8\xe8\x4f\x37\xb5\x58\xd4\xcd\xc4\x7c\x8f\x37\xf6\x10\x1a\xef\x1f\xb8\x97\x50\x00\x1d\x7c\x8d\x7a\xa7\xcf\xe6\x8b\x86\x72\xf1\x92\x98\x4d\x4e\x85\x1c\x46\x3d\x48\xf7\xce\x35\xc9\x63\x2f\x1f\x4f\x53\x79\x56\x84\x62\x9a\x03\x3b\x7b\x22\x9e\xb5\x84\x01\xfb\x51\xe9\x28\xa3\xe0\xa6\xe4\x61\x07\x33\x28\xb8\xf3\xfd\x87\xf3\x9e\xef\xbe\x98\x5f\x11\xf5\x6b\xe2\x06\xb1\x94\x93\x6b\x16\xa6\x51\x54\x2c\x2e\x3e\x8f\x90\xed\xc9\xff\x76\xff\x94\x98\xd9\x3b\x2a\x04\x0e\x5a\x96\x22\xf9\x13\x07\x93\x48\x04\x8b\x8b\xcf\x93\x4e\x91\xe0\x88\xbe\xee\x80\xd2\x8e\xb1\xaa\xa8\x00\xec\x62\x3c\x00\x7e\xc4\xff\x29\xdc\xae\xc9\x12\xe0\xee\x72\xd1\x33\x90\xbb\x8d\x96\xf4\x42\x86\x35\x3a\xc8\x88\xf4\x80\xa9\xd2\xc1\xe9\x2d\xf5\x77\x52\xf5\x22\x2d\xa3\x2d\x89\x1d\x60\x55\xc5\x72\xd7\x60\x2e\x80\xf4\x9f\x35\x69\xb0\x44\x5a\xd4\x28\xa6\xc1\x05\xb7\xaa\xaa\x04\xfe\xa4\xf6\x52\x10\x72\xa0\x98\x9b\x04\x8d\x08\xf3\xf5\x98\x90\x87\x5c\xb7\x75\x5f\x66\x4c\x45\xa8\x77\xe3\x9c\x91\xfd\x3d\x77\x8c\x44\x7a\xa0\xed\x63\x3d\x7e\xfd\xd9\xd1\x9e\x1b\x5d\xa8\x41\x1f\x73\x88\x29\x5a\x8b\x9b\x03\xbb\x8a\xa9\x1e\x8b\xc8\xa1\x86\x93\x45\x77\xc9\x36\x55\x0a\x62\x54\x55\xd4\x4f\xfc\x8e\x92\xdb\x1c\xeb\x1a\x41\xee\xad\x0d\x00\xc9\xe2\xa8\xae\xd8\xbd\xf9\xf8\x0e\xba\xbe\x2c\x81\xd9\x6c\x06\x97\xb2\xec\xd8\xfa\x9c\xc5\x6e\x52\xb8\x74\x41\x45\xe0\x5a\x28\x1b\xaa\x95\x13\xe6\x62\xc3\xa0\x46\x17\x9d\x2b\x45\x55\x01\x0d\xf2\x1a\x92\x68\xea\x64\x6b\x8a\x04\xe0\x4c\x42\xe1\x0e\xeb\xa6\xa2\x69\x30\x03\x9c\x19\xd3\x7a\x28\x5e\xf8\x4b\x50\x74\x3e\x87\x4f\x7d\x15\x08\x9c\x4d\xe6\xc8\xde\xc4\xde\x30\x14\x64\x58\x19\xf3\xc4\xed\xea\x94\x74\x87\xdf\x6b\x73\xab\x0f\x89\x10\xee\x44\x4b\x29\x2c\x27\x6f\x6e\x50\x55\x12\xc7\xcb\xc9\x14\x96\x93\x8f\xd6\x94\x96\x9c\xb4\x5b\xb2\x20\xe5\x79\x39\x79\x4b\xa5\xc5\x82\x8a\xe5\xa4\x63\xfd\xb7\x06\x39\x5f\x9f\x93\x2d\xe9\x3d\x6d\x5e\x05\x86\x3b\x5b\x17\x6c\xa5\x29\xdc\xbc\xaa\x85\xa6\xdf\x13\x04\xbb\xdc\x34\xf4\xaa\xc6\x66\x67\xf1\x1c\x9b\x1d\x46\xbd\x5b\x1d\x5c\x5d\x4b\x09\xb8\x39\x4d\xb6\xae\xfe\xe1\x47\x67\x74\xba\x9c\x6c\x75\x9a\x9a\x5a\x42\xa6\xe1\xcd\x72\x02\x3b\x12\xa4\xcb\x49\x90\xa1\x5b\xef\x84\x4e\x97\x13\xb9\x4d\x96\xad\x61\x93\xf9\x55\xba\x9c\x64\x1b\x26\x37\x3d\x9d\x5a\x6a\xa6\x92\xf1\xaf\xb6\x37\x2c\x27\x3f\xc0\x52\x77\x42\x1b\x5e\x93\x8d\x9e\x76\xf0\xeb\xe4\x60\xa0\x7e\x05\x79\xc7\x9a\xbf\xed\x33\x83\x0a\x1d\x5f\x5a\xd4\x4e\x75\x0d\xfd\x28\x69\x4d\xce\x61\x39\xbe\x6f\x09\x9d\xd1\xa3\xdb\x31\x4a\x46\xb7\x45\x97\x83\x9b\x5f\xab\x1f\x70\x40\x87\x31\xca\xbd\xdc\xbe\x7f\xb0\x03\x30\xd9\x01\x96\x85\x90\xd1\x7d\x5c\x70\x4f\x2d\x89\x2a\xed\x91\xe4\x7f\x0b\x77\x6c\x00\x75\xf0\x5b\xd2\x26\x77\xec\x5d\x33\x92\x02\xa2\x03\x2b\xaf\x0b\xb2\xd5\x46\xda\xb3\x2d\xd7\x7c\x8d\xba\x94\x5e\x09\xde\xad\x62\x61\x50\x0e\xa4\x8f\xfa\x22\x09\x36\x95\x83\x1a\xbc\xeb\x7a\xba\x20\x57\xcf\x51\x80\x25\x02\x42\xcb\x26\xb4\x85\x79\x4e\x0d\x4b\xd6\x8d\xc1\xfe\x03\x0d\xd1\xf0\x59\x19\x5b\x23\xa7\x20\xcd\xdc\x8c\xc7\xc3\xa3\x0d\x8e\x47\x1a\xbe\xa5\x8e\x0d\xec\xda\xd7\x28\xd5\x0e\x8b\x50\xb4\xfb\x3d\x5d\xa8\x1c\x43\x23\xdb\xe1\x2d\x66\xc6\x47\x04\xdc\xfa\xa1\x35\xb5\x74\xae\x19\x09\x52\x86\x1c\x6d\xd5\xfa\x9d\xca\xd7\x78\xf7\x81\x74\xc9\xeb\x14\x5e\x3c\xff\xc7\xcb\x6f\x46\x08\x23\x68\x52\xf1\x1d\x69\x29\xb5\x07\xe6\xa4\x11\x33\xdc\x3f\x38\xe8\xca\x83\x9e\x49\xd7\x9c\x26\xe5\x96\x26\xb6\x0e\x3b\x71\x79\x8b\x0e\x1c\x31\x64\x28\x2d\x90\x6f\xc4\x2e\x52\x05\x42\x0f\xa2\x73\x9a\x82\x5a\x1d\x66\xa6\x7a\x70\xaf\x36\x70\xfa\x7c\x0a\x59\x6b\xe2\xfb\xb0\x7e\x75\x77\x9d\x1c\x10\x59\x39\xf8\x76\xba\x27\x8f\x34\x44\x3e\x54\x44\x09\x1c\xb8\x55\xbc\x0e\xb3\xac\x14\xb5\x76\x5e\x3b\x50\x26\xa9\x97\xf7\x6b\x8e\x93\x62\x59\x86\x81\xfc\xf0\xd3\x85\xad\xd2\xfc\xf2\xef\xe3\xfe\x55\x5a\xd5\xbe\x4e\xe1\xd9\x08\x49\x84\xb4\x47\x7a\x33\x12\x6f\xbb\x04\x14\xe8\x2a\x2d\xd6\x35\xb2\xca\x41\x15\x32\xa7\xac\x14\xd9\x61\x68\x8b\xd2\xed\x41\xa9\xfb\x3b\x56\x7c\xe2\x5a\x1c\x1a\x04\xfb\x47\x6b\x0a\x9f\xcb\xac\x66\x56\x61\xa4\x50\x2b\x95\x0f\x01\x4a\x06\xa0\x90\x0d\x71\x04\x07\xba\x13\xa3\xf7\xc3\x6e\x9c\x87\x09\xb5\xd2\xa5\x6b\xaf\x94\x49\x4f\x00\x24\x56\xe3\xdb\x35\x85\xd2\x13\x46\xf7\xf6\x8c\x0d\x52\x39\x55\x90\x95\x1e\x19\x4a\x8f\x16\x35\x13\x15\x02\x3f\x92\x82\x2d\xed\x00\xf2\x70\x3b\xf6\x75\xd9\x18\x53\x35\x82\x95\x88\xd8\x8e\x8a\x21\x63\xff\xb8\x54\x3d\x7d\xf6\xfc\x41\x97\xf7\x74\xa3\x44\x0d\x32\x93\xd5\x29\xfc\xef\xea\xcd\xec\xbf\x38\xfb\xf9\xfa\xb8\x7d\x79\x36\xfb\xf6\xff\xd3\xf4\xfa\xe9\xe0\xf3\xfa\xe4\xf5\x5f\x47\x38\x1d\x6e\xa0\x47\xc2\xa7\x2d\x22\x5d\x13\xd9\x79\x74\x1a\x2a\x8c\x59\xc1\xa5\xf5\x34\x85\x33\xac\x1c\x4d\xe1\xdf\x3a\x94\x86\xdf\x69\x34\xd2\xbe\x1e\x97\x4e\xaa\xf2\x44\x6e\x3d\xdc\x7c\xf4\x24\x41\xa4\x87\x69\x5a\x71\x1f\x9a\x40\x1e\x67\xa4\xd0\xbe\xc5\x01\xb5\x43\x9a\xc1\xdf\x0b\x10\x10\x4f\x5a\xd6\xa4\x6d\x7f\x93\xdc\xd4\xf3\xc1\xdf\x0f\xd2\x77\x9f\xa3\xde\xc0\x16\xd6\x62\xb3\xba\x1f\xe9\x8e\x05\x9b\x30\xb7\xc6\xb9\x7e\x6c\x71\x50\xa9\x2f\x04\x7d\x47\x1b\xc1\x32\xa3\x1c\x43\xa3\x6e\x33\xc5\x16\xed\x66\x30\x97\x40\x8e\x3a\xfc\x1b\xe2\x68\xe5\x2b\x38\x76\x44\x90\x68\x53\xd0\x7d\x74\x3d\x89\x18\x8a\x99\xaa\x14\x6f\xc2\x18\x4b\x32\x87\x57\xaa\x9d\x0f\xea\xc6\x58\x46\xcd\x31\xdd\x2c\x95\x74\x07\x8a\xa1\x96\x9e\x93\xc2\xe8\x75\x5c\x68\x77\x7a\xfa\xfc\xc5\x85\xcf\x0a\x53\xa3\xd2\x67\x35\xcf\x4f\x5e\x1f\xff\xe4\xb1\x12\xe4\x29\xfe\x85\x35\x9d\xd5\x7c\xf2\xc7\x95\xc5\xd3\x97\x8f\xc8\xa2\xe3\xab\x98\x2b\xd7\xc7\x57\xb3\xf6\xed\x69\xb7\x74\xf2\xfa\x78\x99\x3c\xb8\x7f\xf2\x54\x74\x18\x64\xe0\xf5\xd5\x6c\x9b\x7e\xc9\xf5\xd3\x93\xd7\x83\xbd\x93\x2e\x19\x63\x9d\x4a\x81\xad\xef\x9a\x16\xc7\xc6\x4a\x93\xb2\xb3\xe6\xb3\xde\xbd\xdb\x20\x6c\x33\x17\x7e\xf9\xf5\xe8\xb7\x00\x00\x00\xff\xff\xc6\x78\xa2\x47\x7d\x17\x00\x00") +var _operatorsCoreosCom_olmconfigsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x58\x6f\x6f\xdb\x46\xd2\x7f\xef\x4f\x31\xd0\xf3\x00\xb1\x73\x12\x15\x27\x87\x5c\x4a\x20\x08\x02\xe5\x5c\x04\x89\xaf\x41\xec\xcb\x01\x67\xf9\xae\x43\x72\x44\x6d\x43\xee\xb2\xbb\xb3\xb6\xd5\xa2\xdf\xfd\x30\xbb\x24\x45\xc9\xa2\x63\xa0\xad\xde\x58\x9a\x9d\x9d\x9d\xbf\xbf\x99\x31\x36\xea\x0b\x59\xa7\x8c\x4e\x01\x1b\x45\x77\x4c\x5a\x7e\xb9\xe4\xeb\x2b\x97\x28\x33\xbf\x39\x3d\xfa\xaa\x74\x91\xc2\xc2\x3b\x36\xf5\x67\x72\xc6\xdb\x9c\xde\xd1\x4a\x69\xc5\xca\xe8\xa3\x9a\x18\x0b\x64\x4c\x8f\x00\x50\x6b\xc3\x28\x64\x27\x3f\x01\x72\xa3\xd9\x9a\xaa\x22\x3b\x2b\x49\x27\x5f\x7d\x46\x99\x57\x55\x41\x36\x08\xef\x9e\xbe\x79\x96\xbc\x4a\x9e\x1d\x01\xe4\x96\xc2\xf5\x4b\x55\x93\x63\xac\x9b\x14\xb4\xaf\xaa\x23\x00\x8d\x35\xa5\x60\xaa\x3a\x37\x7a\xa5\x4a\x97\x98\x86\x2c\xb2\xb1\x2e\xc9\x8d\x25\x23\x7f\xea\x23\xd7\x50\x2e\x2f\x97\xd6\xf8\x26\x85\x83\x3c\x51\x56\xa7\x20\x32\x95\xc6\xaa\xee\x37\xc0\x4c\x1e\x09\xdf\xa3\xe1\x3f\x7c\x3c\x5f\x84\x27\x03\xad\x52\x8e\x3f\xec\xd2\x3f\x2a\xc7\xe1\xac\xa9\xbc\xc5\x6a\xa8\x64\x20\x3b\xa5\x4b\x5f\xa1\x1d\x1c\x1c\x01\xb8\xdc\x34\x94\xc2\xa2\xf2\x8e\xc9\x1e\x01\xb4\xce\x68\xf5\x98\xb5\x06\xdf\x9c\xb6\x6a\xb9\x7c\x4d\x35\x76\x4a\x82\x98\xa6\xdf\x7e\x7a\xff\xe5\xc5\xc5\xde\x01\x40\x41\x2e\xb7\xaa\xe1\xe0\xda\x5e\x4d\x50\x0e\x10\x6c\x1b\x40\xf9\xd2\x18\xed\x54\x56\x11\xac\x8c\x85\xa8\x98\xb7\x4a\x97\x72\x27\x19\xc8\xe3\x8d\x68\x6a\xb2\x9f\x28\xe7\x01\xd9\xd2\xcf\x5e\x59\x2a\x86\x4f\x8b\xe2\x5d\x42\x0c\xc8\x8d\x95\x48\xf0\xc0\xcb\xf1\x33\x48\xbf\x1d\xfa\x9e\x0d\x4f\xc4\xd0\xc8\x07\x85\x64\x1e\x39\xe0\x35\x75\x2e\xa3\xa2\xf5\x0e\x98\x15\xf0\x5a\x39\xb0\xd4\x58\x72\xa4\x63\x2e\x0a\x19\x75\x6b\x40\x02\x17\x64\xe5\x22\xb8\xb5\xf1\x55\x21\x86\xdf\x90\x65\xb0\x94\x9b\x52\xab\x5f\x7a\x69\x0e\xd8\x84\x67\x2a\x64\x72\x0c\x4a\x33\x59\x8d\x15\xdc\x60\xe5\x69\x0a\xa8\x0b\xa8\x71\x03\x96\x44\x2e\x78\x3d\x90\x10\x58\x5c\x02\xe7\xc6\x12\x28\xbd\x32\x29\xac\x99\x1b\x97\xce\xe7\xa5\xe2\xae\xb8\x72\x53\xd7\x5e\x2b\xde\xcc\x43\x9d\xa8\xcc\x4b\xae\xce\x0b\xba\xa1\x6a\xee\x54\x39\x43\x9b\xaf\x15\x53\xce\xde\xd2\x1c\x1b\x35\x0b\xca\xea\x50\x60\x49\x5d\xfc\x5f\x17\x4d\xf7\x64\xcf\x7d\x31\x64\x8e\x25\x9c\x3b\x47\x21\xa7\x1f\xf4\xb5\x64\x77\xcc\x95\x78\x3d\xda\xb2\x75\xa9\x90\xc4\x2b\x9f\xff\x7e\x71\xb9\x4d\xa7\xe0\xf6\xe8\xe1\x2d\xab\xdb\x3a\x5b\x1c\xa5\xf4\x8a\x6c\xe4\x5c\x59\x53\x07\x29\xa4\x8b\xc6\x28\xcd\xe1\x47\x5e\x29\xd2\x0c\xce\x67\xb5\x62\x17\x12\x8c\x1c\x4b\x1c\x12\x58\x04\x6c\x81\x8c\xc0\x37\x05\x32\x15\x09\xbc\xd7\xb0\xc0\x9a\xaa\x05\x3a\xfa\xd3\x5d\x2d\x1e\x75\x33\x71\xdf\xe3\x9d\x3d\x84\xc6\xfb\x17\xee\x15\x14\x40\x07\x5f\xa3\xd1\xe9\xab\xf9\xa2\xa1\x5c\xa2\x24\x6e\x93\x5b\xa1\x86\x51\x0f\xca\xbd\x0b\x4d\xf2\xd8\xc7\xc7\xcb\x54\x3e\x2b\x42\x71\xcd\x81\x93\x3d\x15\xcf\x5a\xc6\x80\xfd\xa8\x74\xd4\x51\x70\x53\xea\xb0\x83\x19\x14\xdc\xf9\xe1\xe3\x79\x2f\x77\x5f\xcd\x6f\xa8\xfa\x2d\x75\x83\x5a\xca\xc9\x33\x0b\xd3\x28\x2a\x16\x17\x5f\x46\xd8\xf6\xf4\x7f\xb7\x7f\x4b\xdc\xec\x1d\x15\x02\x07\xad\x48\xd1\xfc\x89\x83\x49\x64\x82\xc5\xc5\x97\x49\x67\x48\x08\x44\xdf\x77\x40\x69\xc7\x58\x55\x54\x00\x76\x39\x1e\x00\x3f\xe2\xff\x14\x6e\xd7\x64\x09\x70\x97\x5c\xf4\x02\xe4\x6d\xa3\xa5\xbc\x90\x61\x8d\x0e\x32\x22\x3d\x10\xaa\x74\x08\x7a\xcb\xfd\xbd\x74\xbd\xc8\xcb\x68\x4b\x62\x07\x58\x55\xb1\xdd\x35\x98\x0b\x20\xfd\x6b\x4d\x1a\x2c\x91\x16\x33\x8a\x69\x08\xc1\xad\xaa\x2a\x81\x3f\xe9\xbd\x14\x94\x1c\x18\xe6\x26\xc1\x22\xc2\x7c\x3d\xa6\xe4\xa1\xd0\x6d\xc3\x97\x19\x53\x11\xea\xdd\x3c\x67\x64\x7f\x2f\x1c\x23\x99\x1e\x78\xfb\x5c\x8f\xbf\xfe\xec\x6c\xcf\x8d\x2e\xd4\x60\x8e\x39\x24\x14\xad\xc5\xcd\x81\x53\xc5\x54\x8f\x65\xe4\xd0\xc2\xc9\xa2\x7b\x64\x5b\x2a\x05\x31\xaa\x2a\xda\x27\x71\x47\xa9\x6d\x8e\x7d\x8d\x20\xf7\xd6\x06\x80\x64\x09\x54\xd7\xec\xde\x7e\x7a\x0f\xdd\x5c\x96\xc0\x6c\x36\x83\x4b\x21\x3b\xb6\x3e\x67\xf1\x9b\x34\x2e\x5d\x50\x11\xa4\x16\xca\x86\x6e\xe5\x44\xb8\xf8\x30\x98\xd1\x65\xe7\x4a\x51\x55\x40\x83\xbc\x86\x24\xba\x3a\xd9\xba\x22\x01\x38\x93\x54\xb8\xc3\xba\xa9\x68\x1a\xdc\x00\x67\xc6\xb4\x11\x8a\x0f\xfe\x0a\xf3\x39\x7c\xee\x3b\x40\x90\x6a\x32\x47\xf6\x26\xce\x85\xa1\x19\xc3\xca\x98\x27\x6e\xd7\x9e\x44\x2e\x7e\xd0\xe6\x56\x1f\x7a\x3a\xbc\x85\x96\x52\x58\x4e\xde\xde\xa0\xaa\x24\x7f\x97\x93\x29\x2c\x27\x9f\xac\x29\x2d\x39\x19\xb3\x84\x20\x6d\x79\x39\x79\x47\xa5\xc5\x82\x8a\xe5\x44\xc4\xfe\xa5\x41\xce\xd7\xe7\x64\x4b\xfa\x40\x9b\xd7\x41\x58\x4f\xbe\x60\x2b\x43\xe0\xe6\x75\x2d\xe7\x81\x2e\x68\x75\xb9\x69\xe8\x75\x8d\x4d\x4f\x38\xc7\xa6\xbf\xdc\x87\xce\xc1\xd5\xb5\xc0\xfc\xcd\x69\xb2\x0d\xe7\x8f\x3f\x39\xa3\xd3\xe5\x64\xab\xff\xd4\xd4\x92\x16\x0d\x6f\x96\x13\xd8\x79\x35\x5d\x4e\xc2\xbb\x1d\xbd\x53\x32\x5d\x4e\xe4\x25\x21\x5b\xc3\x26\xf3\xab\x74\x39\xc9\x36\x4c\x6e\x7a\x3a\xb5\xd4\x4c\xa5\xaa\x5f\x6f\x5f\x58\x4e\x7e\x84\xa5\x16\x65\x0d\xaf\xc9\xc6\x48\x3a\xf8\x6d\x72\x30\x11\xbf\x81\xac\x63\xc3\xdd\xf6\x33\x83\x0a\x1d\x5f\x5a\xd4\x4e\x75\x03\xfb\x28\x6b\x4d\xce\x61\x39\x7e\x6e\x09\x9d\xd1\xa3\xc7\x31\x1b\x46\x8f\xc5\x96\x83\x87\xdf\xea\x0f\x70\xc0\x86\x31\xce\xbd\xda\xbd\x7f\xb1\x03\x28\x39\x01\x16\x42\xa8\xd8\x3e\x27\xb8\xe7\x96\x42\x94\xf1\x47\xea\xbb\x85\x33\x36\x80\x3a\xc4\x2d\x69\x8b\x37\xce\xa6\x19\x49\x83\xd0\x41\x94\xd7\x05\xd9\x6a\x23\xe3\xd7\x56\x6a\xbe\x46\x5d\xca\x2c\x04\xef\x57\x11\xf8\x95\x03\x99\x93\xbe\x4a\x21\x4d\xe5\xa2\x06\xef\xba\x99\x2d\xe8\xd5\x4b\x14\xe0\x88\x05\xdf\x8a\x09\x63\x5f\x9e\x53\xc3\x52\x5d\x63\xb0\xfe\xc0\xc0\x33\xfc\xac\x8c\xad\x91\x53\x90\x61\x6d\xc6\xe3\xe9\xd1\x26\xc7\x23\x1d\xdf\x72\xc7\x01\x75\xed\x6b\x94\x6e\x86\x45\x68\xca\xfd\x99\x2e\x54\x8e\x61\x50\xed\xf0\x14\x33\xe3\x23\xc2\x6d\xe3\xd0\xba\x5a\x26\xd3\x8c\x04\x09\x43\x7d\xb6\x66\xfd\x4e\xe3\x6b\xbc\xfb\x48\xba\xe4\x75\x0a\x2f\x9e\xff\xed\xe5\xab\x11\xc6\x08\x8c\x54\x7c\x4f\x5a\x5a\xe9\x81\x3d\x68\xc4\x0d\xf7\x2f\x0e\xa6\xee\x60\x67\xd2\x0d\x9f\x49\xb9\xe5\x89\xa3\xc1\x4e\x5e\xde\xa2\x03\x47\x0c\x19\xca\x88\xe3\x1b\xf1\x8b\xa0\x7c\x98\x31\x74\x4e\x53\x50\xab\xc3\xc2\x54\x0f\xe0\xd5\x06\x4e\x9f\x4f\x21\x6b\x5d\x7c\x1f\xbe\xaf\xee\xae\x93\x03\x2a\x2b\x07\xdf\x4d\xf7\xf4\x91\x81\xc7\x87\x8e\x27\x89\x03\xb7\x8a\xd7\x61\x57\x95\xa6\xd5\xee\x63\x07\xda\x20\xf5\xfa\x7e\x2b\x70\xd2\x0c\xcb\xb0\x70\x1f\xfe\x74\x69\xab\x34\xbf\xfc\xeb\x78\x7c\x95\x56\xb5\xaf\x53\x78\x36\xc2\x12\x21\xed\x91\xd1\x8c\xcc\xdb\x29\x00\x05\xba\x4a\x8b\x75\x8d\xac\x72\x50\x85\xec\x21\x2b\x45\x76\x98\xda\x62\x74\x7b\x51\xfa\xfa\x8e\x17\x9f\xb8\x16\x87\x06\xc9\xfe\xc9\x9a\xc2\xe7\xb2\x8b\x99\x55\x58\x19\xd4\x4a\xe5\x43\x80\x92\x05\x27\x54\x43\x5c\xb1\x81\xee\xc4\xe9\xfd\x32\x1b\xf7\x5d\x42\xad\x74\xe9\xda\x27\x65\x93\x13\x00\x89\x5d\xf7\x76\x4d\xa1\xf5\x84\xd5\xbc\xbd\x63\x83\x56\x4e\x15\x64\x65\x06\x86\xd2\xa3\x45\xcd\x44\x85\xc0\x8f\x94\x60\xcb\x3b\x80\x3c\xdc\xae\x75\x5d\x35\xc6\x52\x8d\x60\x25\x2a\xb6\xab\x60\xa8\xd8\x3f\xae\x54\x4f\x9f\x3d\x7f\x30\xe4\x3d\xdf\x28\x53\x83\xcc\x64\x75\x0a\xff\xb9\x7a\x3b\xfb\x37\xce\x7e\xb9\x3e\x6e\xbf\x3c\x9b\x7d\xf7\xdf\x69\x7a\xfd\x74\xf0\xf3\xfa\xe4\xcd\xff\x8f\x48\x3a\x3c\x20\x8f\xa4\x4f\xdb\x44\xba\x21\xb1\x8b\xe8\x34\x74\x18\xb3\x82\x4b\xeb\x69\x0a\x67\x58\x39\x9a\xc2\x3f\x75\x68\x0d\xbf\xd3\x69\xa4\x7d\x3d\xae\x9d\x74\xe5\x89\xbc\x7a\x78\xf8\xe8\x59\x82\x4a\x0f\xf3\xb4\xea\x3e\xb4\x61\x3c\xce\x49\x61\x6c\x8b\x0b\x68\x87\x34\x83\x7f\x1f\x40\x40\x3c\x19\x4b\x93\x76\xbc\x4d\x72\x53\xcf\x07\xff\x5e\x90\xb9\xfa\x1c\xf5\x06\xb6\xb0\x16\x87\xd2\xfd\x4c\x77\x2c\xd8\x84\xb9\x35\xce\xf5\x6b\x89\x83\x4a\x7d\x25\xe8\x27\xd7\x08\x96\x19\xe5\x18\x06\x71\x9b\x29\xb6\x68\x37\x83\xbd\x03\x72\xd4\xe1\xbf\x1d\x8e\x56\xbe\x82\x63\x47\x04\x89\x36\x05\xdd\x47\xd7\x93\x88\xa1\x98\xa9\x4a\xf1\x26\xac\xa9\x24\x7b\x76\xa5\xda\xf9\xbf\x6e\x8c\x65\xd4\x1c\xcb\xcd\x52\x49\x77\xa0\x18\x6a\x99\x37\x29\xac\x56\xc7\x85\x76\xa7\xa7\xcf\x5f\x5c\xf8\xac\x30\x35\x2a\x7d\x56\xf3\xfc\xe4\xcd\xf1\xcf\x1e\x2b\x41\x9e\xe2\x1f\x58\xd3\x59\xcd\x27\x7f\x5c\x5b\x3c\x7d\xf9\x88\x2a\x3a\xbe\x8a\xb5\x72\x7d\x7c\x35\x6b\xbf\x3d\xed\x48\x27\x6f\x8e\x97\xc9\x83\xe7\x27\x4f\xc5\x86\x41\x05\x5e\x5f\xcd\xb6\xe5\x97\x5c\x3f\x3d\x79\x33\x38\x3b\xe9\x8a\x31\xf6\xa9\x14\xd8\xfa\x6e\x68\x71\x6c\xac\x0c\x29\x3b\x34\x9f\xf5\xe1\xdd\x26\x61\x5b\xb9\xf0\xeb\x6f\x47\xff\x0b\x00\x00\xff\xff\x65\x57\xc7\x70\x5d\x17\x00\x00") func operatorsCoreosCom_olmconfigsYamlBytes() ([]byte, error) { return bindataRead( @@ -165,7 +165,7 @@ func operatorsCoreosCom_olmconfigsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_operatorconditionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\x5f\x6f\x1b\xb9\x11\x7f\xf7\xa7\x18\xa8\x05\x62\xa7\xd2\x2a\xf6\x15\xe9\x9d\x80\x20\x08\x72\x4d\x11\x24\xbe\x04\xb1\x7b\x0f\xb5\xdc\x66\x76\x39\x5a\xf1\xb2\x4b\xee\x91\x5c\xd9\xba\xc3\x7d\xf7\x62\xc8\x5d\xed\xca\x5a\xc9\x2e\x92\x06\xd7\x82\x7c\xb1\x44\xce\x0e\x87\xf3\xff\x47\xaf\xb0\x92\x3f\x92\xb1\x52\xab\x19\x60\x25\xe9\xd6\x91\xe2\x6f\x36\xf9\xf4\xad\x4d\xa4\x9e\xae\x4e\x8f\x3e\x49\x25\x66\xf0\xb2\xb6\x4e\x97\x1f\xc8\xea\xda\x64\xf4\x3d\x2d\xa4\x92\x4e\x6a\x75\x54\x92\x43\x81\x0e\x67\x47\x00\xa8\x94\x76\xc8\xd3\x96\xbf\x02\x64\x5a\x39\xa3\x8b\x82\xcc\x24\x27\x95\x7c\xaa\x53\x4a\x6b\x59\x08\x32\x9e\x79\xbb\xf5\xea\x49\xf2\x34\x39\x3b\x02\xc8\x0c\xf9\xc7\x2f\x65\x49\xd6\x61\x59\xcd\x40\xd5\x45\x71\x04\xa0\xb0\xa4\x19\xe8\x8a\x0c\x3a\x6d\x32\xad\x84\xdf\xde\x26\xed\x94\x4d\x32\x6d\x48\xf3\x9f\xf2\xc8\x56\x94\xb1\x04\xb9\xd1\x75\xd5\x3d\xb6\x45\x13\x78\xb6\x82\xa2\xa3\x5c\x1b\xd9\x7e\x07\x98\x80\x2e\x4a\xff\x39\x28\xe0\x5d\xc3\xe3\x65\xbb\xb5\x5f\x2b\xa4\x75\x6f\x86\xd7\xdf\x4a\xeb\x3c\x4d\x55\xd4\x06\x8b\x21\xe1\xfd\xb2\x5d\x6a\xe3\x7e\xe8\x44\xe1\xad\xb3\xad\x4d\xac\x54\x79\x5d\xa0\x19\x60\x71\x04\x60\x33\x5d\xd1\x0c\x3c\x87\x0a\x33\x12\x47\x00\x8d\x66\x1b\x8e\x93\x46\x7b\xab\xd3\x66\x03\x9b\x2d\xa9\xc4\x76\x3b\x60\xb6\xea\xc5\xfb\xd7\x3f\x7e\x73\x71\x67\x01\x40\x90\xcd\x8c\xac\x9c\xb7\xd3\xce\x19\x41\x5a\xc0\xc6\x37\xa0\x75\x0e\xd0\x0b\x70\xeb\x8a\xe0\xe3\x0e\xfd\x47\xb8\x59\xca\x6c\xc9\x8f\xd5\x96\x04\x38\xcd\x47\x5d\xd1\x1a\xa4\x5a\x68\x53\x7a\xe3\xf3\xec\xbb\xb7\xe7\x80\xa9\xae\x1d\xb8\x25\x81\x75\xe8\x3c\x5b\x54\x1b\x15\x24\x3d\x21\x79\xb7\x19\xe8\xf4\x27\xca\x5c\x6f\xda\xd0\xcf\xb5\x34\x24\xfa\xe7\x61\x6d\xb4\x2e\xdb\x9b\xae\x0c\xf3\x75\x3d\xfb\x87\xd1\x0b\x90\xad\xf9\x3b\x8a\x79\xc4\xda\x0b\x74\x20\x38\x36\xc8\x7a\xc1\x1b\x3b\x90\x68\x54\xee\x55\xb3\x94\x16\x0c\x55\x86\x2c\xa9\x10\x2d\xed\xd1\xfc\x01\x12\xb8\x20\xc3\x0f\xb2\x67\xd4\x85\x08\x1a\x32\x0e\x0c\x65\x3a\x57\xf2\x97\x0d\x37\xcb\x9a\xe2\x6d\x0a\x74\x64\x1d\x48\xe5\xc8\x28\x2c\x60\x85\x45\x4d\x63\x40\x25\xa0\xc4\x35\x18\x62\xbe\x50\xab\x1e\x07\x4f\x62\x13\x38\xd7\x86\xbc\xf2\x67\xb0\x74\xae\xb2\xb3\xe9\x34\x97\xae\x0d\xff\x4c\x97\x65\xad\xa4\x5b\x4f\x7d\x24\xcb\xb4\xe6\x28\x9a\x0a\x5a\x51\x31\xb5\x32\x9f\xa0\xc9\x96\xd2\x51\xe6\x6a\x43\x53\xac\xe4\xc4\x0b\xab\x42\x68\x96\xe2\x0f\xa6\xf1\x09\xfb\xe8\x8e\xfa\x82\xc9\xac\x33\x52\xe5\x5b\x4b\x3e\xda\x0e\xea\x9a\xe3\x2d\x38\x5e\x78\x3c\x9c\xa5\x53\x29\x4f\xb1\x56\x3e\xfc\xf5\xe2\x12\x5a\x01\x82\xda\x83\x86\x3b\x52\xdb\x29\x9b\x15\x25\xd5\x82\x4c\xa0\x5c\x18\x5d\x7a\x2e\xa4\x44\xa5\xa5\x0a\x8e\x98\x15\x92\x94\x03\x5b\xa7\xa5\x74\xd6\x3b\x18\x59\xc7\x76\x48\xe0\xa5\xcf\x7e\x90\x12\xd4\x95\x40\x47\x22\x81\xd7\x0a\x5e\x62\x49\xc5\x4b\xb4\xf4\x5f\x57\x35\x6b\xd4\x4e\x58\x7d\x0f\x57\x76\x3f\x79\xef\x3e\xb0\x13\x50\x00\x6d\x62\xdd\x6b\x9d\x9d\x90\xbf\xa8\x28\x03\x2c\x0a\x7d\xc3\x16\xcb\x8a\xda\x3a\x32\x80\xa2\x94\x6a\x4f\xf8\x1f\x8e\xfb\x26\x3b\x8c\xa1\xd2\x8e\x4f\x8f\x45\xb1\x06\xbd\x22\x63\xa4\x60\xcb\x87\x67\x0c\x55\xda\x38\x12\x90\xae\x3d\xa7\xa1\xac\x71\xf0\xa0\xfb\x53\x42\x38\x72\x55\xe8\x75\xc9\x1e\xb4\xbb\xd8\x72\x45\x63\x70\x3d\xb0\x2a\x1d\x95\x83\x8f\x1d\x30\x14\x8f\xe6\x90\x43\xf2\x7c\xc6\x96\x5b\xd6\x1b\x75\x99\x9d\xbd\x10\xa5\xb2\x20\xc8\xa1\x2c\x2c\x2c\xb4\x01\xad\x08\x90\x7d\xc0\x85\x4c\x46\x90\xd5\xc6\xf8\x90\x68\x4d\xe5\xa3\xe7\xc5\xfb\xd7\x9b\x72\x90\xc0\x64\x32\x81\x4b\x9e\xb6\xce\xd4\x99\xe3\xd8\xe5\x54\xa5\x04\x09\xcf\x55\x48\xe3\xf3\x93\x65\xe6\x6c\x6b\x7f\x0c\xc0\xe0\x04\x0b\x49\x85\x80\x0a\xdd\x12\x12\xde\xa5\xe6\xf2\xbd\x29\xff\x00\xaf\xb4\x01\xba\xc5\xb2\x2a\x68\x1c\xea\xce\x2b\xad\x2f\x3c\x61\xb3\xe1\xaf\xfe\xa0\xd3\x29\x7c\xd8\xc4\x7d\x70\x8a\xd4\x92\x59\x85\x7e\xc5\x7b\x19\x2c\xb4\x7e\x64\xb7\xcf\x94\xb4\x0f\xbf\x51\xfa\x46\x0d\x89\xe0\xf7\x44\x43\x33\x98\x8f\x5e\xac\x50\x16\x98\x16\x34\x1f\x8d\x61\x3e\x7a\x6f\x74\x6e\xc8\x72\x01\xe7\x09\x4e\xc8\xf3\xd1\xf7\x94\x1b\x14\x24\xe6\xa3\x96\xf5\x9f\x2a\x74\xd9\xf2\x9c\x4c\x4e\x6f\x68\xfd\xcc\x33\xdc\x5a\xba\x70\x86\x1b\x94\xf5\xb3\x92\x69\x36\x6b\xdc\x7d\x5c\xae\x2b\x7a\x56\x62\xb5\x35\x79\x8e\xd5\x16\xa3\x8d\x59\x2d\x5c\x5d\x73\xd0\xaf\x4e\x93\xce\xd4\x1f\x7f\xb2\x5a\xcd\xe6\xa3\xee\x4c\x63\x5d\xb2\xcb\x54\x6e\x3d\x1f\xc1\x96\x04\xb3\xf9\xc8\xcb\xd0\xce\xb7\x42\xcf\xe6\x23\xde\x8d\xa7\x8d\x76\x3a\xad\x17\xb3\xf9\x28\x5d\x3b\xb2\xe3\xd3\xb1\xa1\x6a\xcc\x2d\xc8\xb3\x6e\x87\xf9\xe8\x23\xcc\x55\x2b\xb4\x76\x4b\x32\xc1\xd2\x16\x7e\x1b\x1d\x88\x8d\xc1\x50\x0d\x63\xb8\xdc\x77\x83\x0b\xbf\xb5\x98\xd3\xde\x75\x43\x68\x9b\x9e\x6b\x68\x39\x98\x7e\xef\x32\x0b\x38\xb8\x78\x28\x93\x84\x51\xa0\x75\x97\x06\x95\x95\x6d\xf7\xbb\x8f\xf2\x4e\xc0\xee\x3e\xc8\xd1\x15\x7a\x02\xeb\xc0\xf1\x84\x0f\xd3\x8d\xb1\xdd\x86\x9a\xa3\x8f\xab\x1c\x07\x75\x38\x1a\xe7\x56\x54\xde\x18\x49\x13\xb1\xa1\x05\x49\x09\x6e\x96\xa4\x3c\xab\x5a\x09\x32\xc5\x9a\x73\x6d\xc7\x35\x5b\xa2\xca\xb9\xe4\xc1\x6b\x4e\x01\xe8\x83\x9c\xcb\xe1\x27\x8e\x9a\x31\x3f\xa8\xa0\xb6\x6d\x69\xf6\x72\x6d\x38\x72\xb6\x08\x51\xde\xb0\xf1\xd5\x3d\xcb\xa8\x72\x1c\x4a\x77\x73\x76\x37\x0e\xa6\xcb\x76\x84\xc2\x32\x03\xae\xc9\x13\xde\x78\x0f\x65\xe3\x1c\x0f\x54\x7c\x43\x1d\xfa\x90\x65\x5d\xa2\x62\xef\x11\x2c\x6f\xb7\xa6\x84\xcc\xd0\xf7\x23\x6d\x12\xed\x6a\x5b\x67\x87\x46\xd5\xdc\x80\xa4\xc4\xe9\xcf\x07\x5e\x73\xac\xcf\x3c\x7c\x89\xb7\x6f\x49\xe5\x6e\x39\x83\x6f\xce\xfe\xf2\xf4\xdb\x3d\x84\x21\x13\x92\xf8\x1b\x29\xae\x93\x03\xed\xee\x1e\x35\xec\x3e\xd8\x6b\xae\xfc\x39\x93\xb6\xc7\x48\xf2\x8e\xc6\x7b\xc8\xb6\x5f\xde\xa0\x05\x4b\x0e\x52\x64\x60\x50\x57\xac\x17\x4e\xed\x52\x59\x87\x2a\xa3\x31\xc8\xc5\x30\x33\xb9\xc9\xd8\xc5\x1a\x4e\xcf\xc6\x90\x36\x2a\xde\xcd\xd5\x57\xb7\xd7\xc9\x80\xc8\xd2\xc2\x77\xe3\x3b\xf2\x70\xb7\x58\xfb\x32\xc7\x8e\x03\x37\xd2\x2d\xb9\x99\xf4\xb5\xaf\x69\xbb\x07\x6a\x1f\x6d\xe4\xbd\xcf\x70\x5c\x01\x73\x32\xf7\xba\xad\x54\xee\xe9\x9f\xf7\xdb\x57\x2a\x59\xd6\xe5\x0c\x9e\xec\x21\x09\x29\xed\x81\xd6\x0c\xc4\x5d\xe9\x47\x4e\x5d\xb9\xc1\x92\x3b\xb3\x0c\xa4\xe0\x86\x6b\x21\xc9\xf4\x5d\x9b\x0f\xdd\x3c\xc8\xc5\x7c\x4b\x8b\x8f\x6c\x93\x87\x7a\xce\xfe\xde\x68\x51\x67\xdc\x72\xeb\x85\xef\x27\xe5\x42\x66\xfd\x04\xc5\x7d\xac\x8f\x86\x80\xa4\x80\x6e\x59\xe9\x1b\xcc\x12\x60\x0d\xa1\x92\x2a\xb7\xcd\x96\xdc\xb0\x73\x02\x09\x25\xf6\x66\x49\xbe\x9e\x78\x04\xd6\x3c\x63\xbc\x54\x56\x0a\x32\x24\x00\x21\xaf\xd1\xa0\x72\x44\x82\xd3\x0f\x87\x60\x43\xdb\x4b\x79\xd8\x75\xef\x6d\x34\x86\x50\x0d\xc9\x8a\x45\x6c\x3a\x7e\x1f\xb1\x5f\x2e\x54\x4f\x9f\x9c\x1d\x34\xf9\x86\x6e\x2f\x51\x85\x8e\xb1\xe0\x0c\xfe\x79\xf5\x62\xf2\x0f\x9c\xfc\x72\x7d\xdc\x7c\x78\x32\xf9\xee\x5f\xe3\xd9\xf5\xe3\xde\xd7\xeb\x93\xe7\x7f\xdc\xc3\x29\x44\xd0\x03\xdd\xa7\x29\x22\x6d\x67\xd8\x5a\x74\xec\x2b\x8c\x5e\xc0\xa5\x61\x54\xfa\x0a\x0b\x4b\x63\xf8\xbb\xf2\xa5\xe1\x33\x95\x46\xaa\x2e\xf7\x4b\xc7\x55\x79\xc4\xbb\x0e\x77\x14\x1b\x12\x2f\xd2\x61\x9a\x46\xdc\x3d\x34\x5e\xd6\x87\x29\xc9\xf7\x64\x7a\xd1\xcf\x34\x3d\x94\x08\x3e\xe3\x71\x1f\x9a\x34\x3d\x6d\x92\xe9\x72\xda\x43\x91\xdc\x4c\x9f\xa3\x5a\x43\x97\xd6\x42\x07\x7a\xd7\xd3\x2d\xc3\x23\xc0\xcc\x68\x6b\x37\x30\xd8\x42\x21\x3f\x11\x6c\xda\xd4\x90\x2c\x53\xca\xd0\x77\xdf\x26\x95\xce\xa0\x59\x77\xd2\x59\xc8\x50\x79\x50\x6b\x69\x51\x17\x70\x6c\x89\x20\x51\x5a\xd0\x6e\x76\x3d\x09\x39\x14\x53\x59\x48\xb7\xe6\x2c\x29\x28\xd3\x6a\x51\xc8\xa6\xe9\x2f\x19\x94\xa1\x72\x21\xdc\x0c\xe5\x74\x0b\xd2\x41\xc9\x8d\x24\x59\x26\x39\x16\xca\x9e\x9e\x9e\x7d\x73\x51\xa7\x42\x97\x28\xd5\xab\xd2\x4d\x4f\x9e\x1f\xff\x5c\x63\xc1\x99\x47\xfc\x80\x25\xbd\x2a\xdd\xc9\x97\x2b\x8b\xa7\x4f\x1f\x10\x45\xc7\x57\x21\x56\xae\x8f\xaf\x26\xcd\xa7\xc7\xed\xd4\xc9\xf3\xe3\x79\x72\x70\xfd\xe4\x31\x9f\xa1\x17\x81\xd7\x57\x93\x2e\xfc\x92\xeb\xc7\x27\xcf\x7b\x6b\x27\xbb\xc1\xc8\x15\x4b\x66\xf4\x22\xcb\x74\xfd\xd5\x30\xe7\x70\xec\xdf\x83\xf6\x43\x0a\x68\xf1\xfe\x36\x6c\x1f\xc0\xfa\xd2\xd9\xa6\x7c\x06\x58\x1f\x3c\xa3\x49\x24\x9c\x60\x9d\x41\x59\x04\xb7\xca\x5c\x8d\x45\xef\x4e\x00\xec\xda\x3a\x2a\xbf\x10\xa4\xef\xdc\x38\xc2\xeb\x08\xaf\x23\xbc\xde\x19\xf7\xc3\xeb\x5d\x30\x1a\x91\x78\x44\xe2\xdd\x88\x48\x3c\x22\xf1\x88\xc4\x1f\x64\xcd\x88\xc4\x23\x12\xdf\x1e\x11\x89\x37\x34\x11\x89\x47\x24\xfe\xb5\x91\x78\xa8\x53\x33\x70\xa6\x6e\x9b\x16\xeb\xb4\xe1\x26\x05\x16\xec\xb2\xed\x64\x9d\x6e\xec\xdb\x79\x61\x13\xba\xf0\xeb\x6f\xdb\xaf\xe3\x9c\xc5\xd7\x71\xe2\xeb\x38\xf1\x75\x9c\xf8\x3a\x4e\x3b\xbe\xf6\xeb\x38\xdb\xd7\x73\xe1\x9d\x99\xad\xeb\x38\xef\xb3\x95\xd1\x2b\x29\xc8\xde\x79\x79\xc7\xf7\xe1\x77\xaa\x4c\x89\xaa\xee\xbf\x90\x43\x5f\xe7\x75\x9c\x78\x77\x17\xef\xee\xe2\xdd\x5d\xbc\xbb\x8b\x77\x77\xf1\xee\x2e\xde\xdd\xc5\xbb\xbb\x6e\xc4\xbb\xbb\x78\x77\xb7\xcf\xe4\xf1\xee\xae\x1d\xf1\xee\x2e\xde\xdd\x0d\x98\xe2\xff\xe3\xee\xae\xef\x41\xf1\x57\x1b\x11\x9a\x46\x68\xfa\x3f\x06\x4d\x23\xde\x8c\x78\x33\xe2\xcd\x81\x11\xf1\x66\xc4\x9b\x11\x6f\x46\xbc\xb9\x33\x22\xde\x6c\x68\x22\xde\x8c\x78\x33\xfe\x6a\xe3\x3f\xfc\xd5\xc6\xbb\xb7\xe7\xbd\x37\x41\xc2\x1b\x22\x3d\xcf\x5a\xe2\x8a\x20\x25\x52\x9b\x36\x22\xfe\x17\x37\x42\xe5\x08\x95\x7f\x0f\x50\x39\xfe\x17\x37\xa2\xea\x88\xaa\xf7\x8c\x88\xaa\x23\xaa\x8e\xa8\x3a\xa2\xea\x88\xaa\x0f\x91\x44\x54\x1d\x51\xf5\xd0\xf8\x1d\xff\x02\xa3\x3f\x77\xdf\x0f\x30\xfe\x1d\x00\x00\xff\xff\xcd\xc3\xfd\xa8\xf2\x56\x00\x00") +var _operatorsCoreosCom_operatorconditionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\xdd\x6f\x1b\xb9\x11\x7f\xf7\x5f\x31\x50\x0b\xc4\x4e\xa5\x55\x9c\x2b\xae\x39\x01\x41\x10\xe4\x9a\x22\x48\x7c\x09\x62\xf7\x1e\x6a\xb9\xcd\xec\x72\x24\xf1\xb2\x4b\xee\x91\x5c\xd9\xba\xc3\xfd\xef\xc5\x90\xfb\x25\x69\xa5\xf8\x90\x34\x68\x0b\xf2\xc5\x12\x3f\x86\xc3\xf9\xfe\xd1\x14\x96\xf2\x47\x32\x56\x6a\x35\x03\x2c\x25\xdd\x39\x52\xfc\xcd\x26\x1f\x9f\xd8\x44\xea\xe9\xfa\xfc\xe4\xa3\x54\x62\x06\x2f\x2a\xeb\x74\xf1\x9e\xac\xae\x4c\x46\xdf\xd3\x42\x2a\xe9\xa4\x56\x27\x05\x39\x14\xe8\x70\x76\x02\x80\x4a\x69\x87\xdc\x6d\xf9\x2b\x40\xa6\x95\x33\x3a\xcf\xc9\x4c\x96\xa4\x92\x8f\x55\x4a\x69\x25\x73\x41\xc6\x13\x6f\xb6\x5e\x3f\x4a\x9e\x24\x8f\x4e\x00\x32\x43\x7e\xf9\x95\x2c\xc8\x3a\x2c\xca\x19\xa8\x2a\xcf\x4f\x00\x14\x16\x34\x03\x5d\x92\x41\xa7\x4d\xa6\x95\xf0\xdb\xdb\xa4\xe9\xb2\x49\xa6\x0d\x69\xfe\x53\x9c\xd8\x92\x32\xe6\x60\x69\x74\x55\x76\xcb\xb6\xe6\x04\x9a\x0d\xa3\xe8\x68\xa9\x8d\x6c\xbe\x03\x4c\x40\xe7\x85\xff\x1c\x04\xf0\xb6\xa6\xf1\xa2\xd9\xda\x8f\xe5\xd2\xba\xd7\xc3\xe3\x6f\xa4\x75\x7e\x4e\x99\x57\x06\xf3\x21\xe6\xfd\xb0\x5d\x69\xe3\x7e\xe8\x58\xe1\xad\xb3\xad\x4d\xac\x54\xcb\x2a\x47\x33\x40\xe2\x04\xc0\x66\xba\xa4\x19\x78\x0a\x25\x66\x24\x4e\x00\x6a\xc9\xd6\x14\x27\xb5\xf4\xd6\xe7\xf5\x06\x36\x5b\x51\x81\xcd\x76\xc0\x64\xd5\xf3\x77\xaf\x7e\xfc\xe6\x72\x67\x00\x40\x90\xcd\x8c\x2c\x9d\xd7\xd3\xde\x19\x41\x5a\xc0\xda\x36\xa0\x31\x0e\xd0\x0b\x70\x9b\x92\xe0\xc3\xde\xfc\x0f\x70\xbb\x92\xd9\x8a\x97\x55\x96\x04\x38\xcd\x47\x5d\xd3\x06\xa4\x5a\x68\x53\x78\xe5\x73\xef\xdb\x37\x17\x80\xa9\xae\x1c\xb8\x15\x81\x75\xe8\x3c\x59\x54\xad\x08\x92\x1e\x93\xbc\xdb\x0c\x74\xfa\x13\x65\xae\xd7\x6d\xe8\xe7\x4a\x1a\x12\xfd\xf3\xb0\x34\x1a\x93\xed\x75\x97\x86\xe9\xba\x9e\xfe\x43\xeb\x39\xc8\x56\xff\x8e\x60\x1e\xb0\xf4\xc2\x3c\x10\xec\x1b\x64\x3d\xe3\xb5\x1e\x48\xd4\x22\xf7\xa2\x59\x49\x0b\x86\x4a\x43\x96\x54\xf0\x96\xe6\x68\xfe\x00\x09\x5c\x92\xe1\x85\x6c\x19\x55\x2e\x82\x84\x8c\x03\x43\x99\x5e\x2a\xf9\x4b\x4b\xcd\xb2\xa4\x78\x9b\x1c\x1d\x59\x07\x52\x39\x32\x0a\x73\x58\x63\x5e\xd1\x18\x50\x09\x28\x70\x03\x86\x98\x2e\x54\xaa\x47\xc1\x4f\xb1\x09\x5c\x68\x43\x5e\xf8\x33\x58\x39\x57\xda\xd9\x74\xba\x94\xae\x71\xff\x4c\x17\x45\xa5\xa4\xdb\x4c\xbd\x27\xcb\xb4\x62\x2f\x9a\x0a\x5a\x53\x3e\xb5\x72\x39\x41\x93\xad\xa4\xa3\xcc\x55\x86\xa6\x58\xca\x89\x67\x56\x05\xd7\x2c\xc4\x1f\x4c\x6d\x13\xf6\xc1\x8e\xf8\x82\xca\xac\x33\x52\x2d\xb7\x86\xbc\xb7\x1d\x95\x35\xfb\x5b\x30\xbc\xb0\x3c\x9c\xa5\x13\x29\x77\xb1\x54\xde\xff\xf5\xf2\x0a\x1a\x06\x82\xd8\x83\x84\xbb\xa9\xb6\x13\x36\x0b\x4a\xaa\x05\x99\x30\x73\x61\x74\xe1\xa9\x90\x12\xa5\x96\x2a\x18\x62\x96\x4b\x52\x0e\x6c\x95\x16\xd2\x59\x6f\x60\x64\x1d\xeb\x21\x81\x17\x3e\xfa\x41\x4a\x50\x95\x02\x1d\x89\x04\x5e\x29\x78\x81\x05\xe5\x2f\xd0\xd2\x7f\x5c\xd4\x2c\x51\x3b\x61\xf1\xdd\x5f\xd8\xfd\xe0\xbd\xbf\x60\xcf\xa1\x00\x9a\xc0\x7a\x50\x3b\x7b\x2e\x7f\x59\x52\x06\x98\xe7\xfa\x96\x35\x96\xe5\x95\x75\x64\x00\x45\x21\xd5\x01\xf7\x3f\xee\xf7\x75\x74\x18\x43\xa9\x1d\x9f\x1e\xf3\x7c\x03\x7a\x4d\xc6\x48\xc1\x9a\x0f\x6b\x0c\x95\xda\x38\x12\x90\x6e\x3c\xa5\xa1\xa8\x71\xf4\xa0\x87\x43\x42\x38\x72\x99\xeb\x4d\xc1\x16\xb4\x3f\xd8\x50\x45\x63\x70\x33\x30\x2a\x1d\x15\x83\xcb\x8e\x28\x8a\x5b\x7d\xc8\x21\x7e\x3e\x63\xcb\x2d\xed\x8d\xba\xc8\xce\x56\x88\x52\x59\x10\xe4\x50\xe6\x16\x16\xda\x80\x56\x04\xc8\x36\xe0\x42\x24\x23\xc8\x2a\x63\xbc\x4b\x34\xaa\xf2\xde\xf3\xfc\xdd\xab\x36\x1d\x24\x30\x99\x4c\xe0\x8a\xbb\xad\x33\x55\xe6\xd8\x77\x39\x54\x29\x41\xc2\x53\x15\xd2\xf8\xf8\x64\x99\x38\xeb\xda\x1f\x03\x30\x18\xc1\x42\x52\x2e\xa0\x44\xb7\x82\x84\x77\xa9\x38\x7d\xb7\xe9\x1f\xe0\xa5\x36\x40\x77\x58\x94\x39\x8d\x43\xde\x79\xa9\xf5\xa5\x9f\x58\x6f\xf8\x2b\x4c\xa7\xf0\xbe\xf5\xf9\x60\x10\xa9\x25\xb3\x0e\xb5\x8a\xb7\x30\x58\x68\xfd\xc0\x6e\x9f\x27\xe1\x85\xaf\x95\xbe\x55\x43\x5b\xfb\xbd\xd0\xd0\x0c\xe6\xa3\xe7\x6b\x94\x39\xa6\x39\xcd\x47\x63\x98\x8f\xde\x19\xbd\x34\x64\x39\x71\x73\x07\x07\xe2\xf9\xe8\x7b\x5a\x1a\x14\x24\xe6\x23\x26\xfb\xa7\x12\x5d\xb6\xba\x20\xb3\xa4\xd7\xb4\x79\xea\x89\xb5\xdd\x97\xce\x70\x41\xb2\x79\x5a\xf0\xb8\xef\xe7\x4a\xe3\x6a\x53\xd2\xd3\x02\xcb\xb6\xe3\x02\xcb\x76\x71\xab\x3a\x0b\xd7\x37\xec\xd8\xeb\xf3\xa4\x53\xe7\x87\x9f\xac\x56\xb3\xf9\xa8\xe3\x7f\xac\x0b\x36\x8b\xd2\x6d\xe6\x23\xd8\xda\x75\x36\x1f\xf9\x7d\x9b\xfe\x86\xc9\xd9\x7c\xc4\x3b\x71\xb7\xd1\x4e\xa7\xd5\x62\x36\x1f\xa5\x1b\x47\x76\x7c\x3e\x36\x54\x8e\xb9\xcc\x78\xda\xed\x30\x1f\x7d\x80\xb9\x62\x66\xb5\x5b\x91\x09\x9a\xb4\xf0\xdb\xe8\x88\xed\x0f\xba\x62\x68\xc3\xe9\xbc\x6b\x9c\xd8\xad\xc5\x25\x1d\x1c\x37\x84\xb6\xae\xa9\x86\x86\x83\x8a\x0f\x0e\x33\x83\x83\x83\xc7\x22\x45\x68\x39\x5a\x77\x65\x50\x59\xd9\x54\xb7\x87\x66\xee\x38\xe4\xfe\x42\xf6\x9e\x90\xf3\xad\x03\xc7\x1d\xde\x0d\x5b\x45\xbb\x76\x36\x7b\x17\x67\x31\x76\xda\x70\x34\x8e\x9d\xa8\xbc\x32\x92\xda\x23\x43\x89\x91\x12\xdc\xae\x48\x79\x52\x95\x12\x64\xf2\x0d\xc7\xd2\x8e\x6a\xb6\x42\xb5\xe4\x94\x06\xaf\xd8\xc5\xd1\x3b\x31\xa7\xbb\x8f\xec\x1d\x63\x5e\xa8\xa0\xb2\x4d\xea\xf5\x7c\xb5\x14\x39\x1a\x04\x2f\xae\xc9\xf8\xec\x9d\x65\x54\x3a\x76\x99\xdd\x98\xdc\xb5\xa3\xe1\xb0\x69\x21\x71\xcc\x80\x73\xee\x84\x37\x3e\x30\xb3\x36\x8e\x7b\x0a\xbe\x9e\x1d\xea\x8c\x55\x55\xa0\x62\xeb\x11\xcc\x6f\x37\xa6\x84\xcc\xd0\xd7\x1b\x4d\x90\xec\x72\x57\xa7\x87\x5a\xd4\x5c\x60\xa4\xc4\xe1\xcd\x3b\x5d\x7d\xac\xcf\x3c\x7c\x81\x77\x6f\x48\x2d\xdd\x6a\x06\xdf\x3c\xfe\xcb\xb7\x4f\x0e\x4c\x0c\xd1\x8e\xc4\xdf\x48\x71\x1e\x1c\x28\x67\x0f\x88\x61\x7f\x61\xaf\x78\xf2\xe7\x4c\x9a\x1a\x22\x59\x76\x73\xbc\x85\x6c\xdb\xe5\x2d\x5a\xb0\xe4\x20\x45\x2e\xfc\xab\x92\xe5\xc2\xa1\x5b\x2a\xeb\x50\x65\x34\x06\xb9\x18\x26\x26\xdb\xa8\x9c\x6f\xe0\xfc\xf1\x18\xd2\x5a\xc4\xfb\x31\xf9\xfa\xee\x26\x19\x60\x59\x5a\xf8\x6e\xbc\xc3\x0f\x57\x83\x95\x4f\x63\x6c\x38\x70\x2b\xdd\x8a\x8b\x45\x9f\xdb\xea\xb2\x7a\x20\xb7\x51\xcb\xef\xa7\x14\xc7\x19\x6e\x49\xe6\x93\x66\x2b\x95\xfb\xf6\xcf\x87\xf5\x2b\x95\x2c\xaa\x62\x06\x8f\x0e\x4c\x09\x21\xed\x9e\xda\x0c\x93\xbb\xd4\x8e\x1c\xba\x96\x06\x0b\xae\xbc\x32\x90\x82\x0b\xaa\x85\x24\xd3\x37\x6d\x3e\x74\xbd\x90\x93\xf5\x96\x14\x1f\xd8\x3a\x0e\xf5\x8c\xfd\x9d\xd1\xa2\xca\xb8\xa4\xd6\x0b\x5f\x2f\xca\x85\xcc\xfa\x01\x8a\xeb\x54\xef\x0d\x01\x29\x01\xdd\xb1\xd0\x5b\x4c\x12\x60\x0b\xa1\x92\x6a\x69\xeb\x2d\xb9\x20\xe7\x00\x12\x52\xe9\xed\x8a\x7c\x3e\xf1\x08\xab\x5e\x63\x3c\x57\x56\x0a\x32\x24\x00\x61\x59\xa1\x41\xe5\x88\x04\x87\x1f\x76\xc1\x7a\x6e\x2f\xe4\x61\x57\x9d\x37\xde\x18\x5c\x35\x04\x2b\x66\xb1\xae\xe8\xbd\xc7\x7e\x39\x57\x3d\x7f\xf4\xf8\xa8\xca\xdb\x79\x07\x27\x95\xe8\x18\xeb\xcd\xe0\x9f\xd7\xcf\x27\xff\xc0\xc9\x2f\x37\xa7\xf5\x87\x47\x93\xef\xfe\x35\x9e\xdd\x3c\xec\x7d\xbd\x39\x7b\xf6\xc7\x03\x94\x82\x07\xdd\xd3\x7c\xea\x24\xd2\x54\x7e\x8d\x46\xc7\x3e\xc3\xe8\x05\x5c\x19\x46\x9d\x2f\x31\xb7\x34\x86\xbf\x2b\x9f\x1a\x3e\x53\x68\xa4\xaa\xe2\x30\x77\x9c\x95\x47\xbc\xeb\x70\x45\xd1\x4e\xf1\x2c\x1d\x9f\x53\xb3\x7b\x60\x8e\xe7\xf5\x7e\x42\xf2\xb5\x98\x5e\xf4\x23\x4d\x0f\x05\x82\x8f\x78\x5c\x6b\x26\x75\xcd\x9a\x64\xba\x98\xf6\x50\x22\x17\xcb\x17\xa8\x36\xd0\x85\xb5\x50\x69\xee\x5a\xba\x65\xf8\x03\x98\x19\x6d\x6d\x0b\x73\x2d\xe4\xf2\x23\x41\x5b\x8e\x86\x60\x99\x52\x86\xbe\xba\x36\xa9\x74\x06\xcd\xa6\xe3\xce\x42\x86\xca\x83\x56\x4b\x8b\x2a\x87\x53\x4b\x04\x89\xd2\x82\xf6\xa3\xeb\x59\x88\xa1\x98\xca\x5c\xba\x0d\x47\x49\x41\x99\x56\x8b\x5c\xd6\x45\x7d\xc1\xa0\x0b\x95\x0b\xee\x66\x68\x49\x77\x20\x1d\x14\x5c\x44\x92\xe5\x29\xa7\x42\xd9\xf3\xf3\xc7\xdf\x5c\x56\xa9\xd0\x05\x4a\xf5\xb2\x70\xd3\xb3\x67\xa7\x3f\x57\x98\x73\xe4\x11\x3f\x60\x41\x2f\x0b\x77\xf6\xe5\xd2\xe2\xf9\xb7\xf7\xf0\xa2\xd3\xeb\xe0\x2b\x37\xa7\xd7\x93\xfa\xd3\xc3\xa6\xeb\xec\xd9\xe9\x3c\x39\x3a\x7e\xf6\x90\xcf\xd0\xf3\xc0\x9b\xeb\x49\xe7\x7e\xc9\xcd\xc3\xb3\x67\xbd\xb1\xb3\x7d\x67\xe4\x8c\x25\x33\x7a\x9e\x65\xba\xfa\x6a\x98\x72\xd8\xf7\x3f\x81\xe6\x43\x08\x68\xf0\xfc\x36\x2c\x1f\xc0\xf2\xd2\xd9\x3a\x7d\x06\xd8\x1e\x2c\xa3\x0e\x24\x1c\x60\x9d\x41\x99\x07\xb3\xca\x5c\x85\x79\x0f\xf3\x83\xdd\x58\x47\xc5\x17\x82\xec\x9d\x19\x47\xf8\x1c\xe1\x73\x84\xcf\x7b\x6d\x32\x00\x36\x23\xd2\x8e\x48\xbb\x6b\x11\x69\x47\xa4\x1d\x91\xf6\xbd\xb4\x19\x91\x76\x44\xda\xdb\x2d\x22\xed\x7a\x4e\x44\xda\x11\x69\x7f\x6d\xa4\x1d\xf2\xd4\x0c\x9c\xa9\x9a\xa2\xc5\x3a\x6d\xb8\x48\x81\x05\x9b\x6c\xd3\x59\xa5\xad\x7e\x3b\x2b\xac\x5d\x17\x7e\xfd\x6d\xfb\x39\xcd\xe3\xf8\x9c\x26\x3e\xa7\x89\xcf\x69\xe2\x73\x9a\xa6\x7d\xed\xe7\x34\xdb\xd7\x6f\xe1\xcd\xcb\xd6\x75\x9b\xb7\xd9\xd2\xe8\xb5\x14\x64\x77\x1e\xdf\xf8\x3a\x7c\x27\xcb\x14\xa8\xaa\xfe\x83\x1a\xfa\x3a\xcf\x69\xe2\xdd\x5c\xbc\x9b\x8b\x77\x73\xf1\x6e\xae\xd7\xe2\xdd\x5c\xdb\xe2\xdd\x5c\xbc\x9b\x8b\x77\x73\xf1\x6e\x2e\xde\xcd\xed\xb6\x78\x37\x17\x5a\xbc\x9b\x8b\x77\x73\x03\xed\x7f\xe3\x6e\xae\x6f\x41\xf1\x57\x15\x11\x7a\x46\xe8\xf9\x5f\x06\x3d\x23\x9e\x8c\x78\x32\xe2\xc9\x81\x16\xf1\x64\xc4\x93\x11\x4f\x46\x3c\xb9\xd7\x22\x9e\xac\xe7\x44\x3c\x19\xf1\x64\xfc\x55\xc5\xef\xfc\x55\xc5\xdb\x37\x17\xbd\x97\x1c\xe1\x85\x47\xcf\xb2\x56\xb8\x26\x48\x89\x54\x5b\x46\xc4\xff\xc2\x46\x28\x1c\xa1\x70\xfc\x2f\x2c\x44\xd4\x1c\x51\x73\x44\xcd\x11\x35\xef\x2a\x2e\xa2\xe6\x88\x9a\xb7\x55\x19\x51\xf3\xef\x17\x5a\x44\xcd\x11\x35\x0f\xa8\xe2\xff\x03\x35\x1f\xfb\x85\x44\xbf\xef\x53\x3f\x90\xf8\x77\x00\x00\x00\xff\xff\x79\xf0\xdc\xa4\x52\x56\x00\x00") func operatorsCoreosCom_operatorconditionsYamlBytes() ([]byte, error) { return bindataRead( @@ -185,7 +185,7 @@ func operatorsCoreosCom_operatorconditionsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_operatorgroupsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5a\xe9\x6f\x1b\x37\x16\xff\xee\xbf\xe2\x41\x5d\x20\x76\x56\x1a\xc5\xee\x22\xdb\x0a\x08\x02\x23\x69\x0a\x6f\x73\x18\xb1\xdb\x0f\x6b\x7b\xb7\xd4\xcc\xd3\x88\x35\x87\x9c\x92\x1c\xdb\x6a\x90\xff\x7d\xf1\x1e\x39\x87\x4e\xcb\x49\xda\xed\x2e\xa4\x2f\xf6\x0c\x8f\x79\xe7\xef\x1d\xa4\x28\xe5\x4f\x68\x9d\x34\x7a\x04\xa2\x94\x78\xe7\x51\xd3\x93\x4b\xae\xbf\x71\x89\x34\xc3\x9b\xc3\xbd\x6b\xa9\xb3\x11\xbc\xa8\x9c\x37\xc5\x7b\x74\xa6\xb2\x29\xbe\xc4\x89\xd4\xd2\x4b\xa3\xf7\x0a\xf4\x22\x13\x5e\x8c\xf6\x00\x84\xd6\xc6\x0b\x7a\xed\xe8\x11\x20\x35\xda\x5b\xa3\x14\xda\x41\x8e\x3a\xb9\xae\xc6\x38\xae\xa4\xca\xd0\xf2\xe6\xf5\xa7\x6f\x9e\x24\x4f\x93\xa3\x3d\x80\xd4\x22\x2f\x3f\x97\x05\x3a\x2f\x8a\x72\x04\xba\x52\x6a\x0f\x40\x8b\x02\x47\x60\x4a\xb4\xc2\x1b\x9b\x5b\x53\x95\x2e\xa9\x1f\x5d\x92\x1a\x8b\x86\xfe\x14\x7b\xae\xc4\x94\xbe\xce\x73\xda\x25\x73\x73\xc2\x7e\x35\x91\xc2\x63\x6e\xac\xac\x9f\x01\x06\x60\x54\xc1\xff\x07\xe6\xdf\xc5\x3d\xbe\xa7\x2d\xf9\xbd\x92\xce\xff\xb0\x3c\xf6\x5a\x3a\xcf\xe3\xa5\xaa\xac\x50\x8b\x04\xf3\x90\x9b\x1a\xeb\xdf\xb6\x9f\xe7\xcf\xe5\x61\x48\xea\xbc\x52\xc2\x2e\xac\xdb\x03\x70\xa9\x29\x71\x04\xbc\xac\x14\x29\x66\x7b\x00\x51\x7c\x71\x9b\x41\x14\xd1\xcd\x61\xdc\xd5\xa5\x53\x2c\x44\xfd\x0d\xa0\x2d\xf5\xf1\xe9\xc9\x4f\x5f\x9f\x2d\x0c\x00\x64\xe8\x52\x2b\x4b\xcf\xca\x98\x63\x08\xa4\x03\x3f\x45\xa8\xb4\xf4\x60\x26\x50\x54\xca\x4b\x8f\x5a\xe8\x74\x06\x13\x63\xe1\xdd\xeb\x37\x50\x08\x2d\x72\xcc\x3a\xa2\x86\x13\x4f\xba\x77\xde\x0a\xa9\xc3\x0e\x52\x3b\x2f\x94\x62\xf5\xd2\x4e\xcd\x64\x90\x1a\xa4\x77\x41\x23\xc4\x1b\x78\x03\x02\x48\x8d\x72\x22\x31\x03\x87\xfc\x69\x2f\x6c\x8e\xbe\x9d\xe6\x92\x0e\x07\x7e\x46\xe2\x31\xe3\x5f\x30\xf5\x9d\xd7\x16\x7f\xad\xa4\xc5\xac\xcb\x2c\x89\xaa\x36\xda\xce\xeb\xd2\x12\x45\xbe\x63\x05\xe1\xd7\x71\x91\xb9\xf7\x0b\x52\x7b\x44\xa2\x0d\xf3\x20\x23\xef\xc0\xc0\x76\x54\x12\xb1\xc1\x62\x67\x4e\xa6\xd2\x81\xc5\xd2\xa2\x43\xed\x1b\x89\x08\x1d\x19\x48\xe0\x0c\x2d\x2d\x24\x5b\xa9\x54\x46\xa2\xbc\x41\xeb\xc1\x62\x6a\x72\x2d\x7f\x6b\x76\x73\x24\x2b\xfa\x8c\x12\x1e\x9d\x07\xa9\x3d\x5a\x2d\x14\xdc\x08\x55\x61\x1f\x84\xce\xa0\x10\x33\xb0\x48\xfb\x42\xa5\x3b\x3b\xf0\x14\x97\xc0\x1b\x63\x49\x3b\x13\x33\x82\xa9\xf7\xa5\x1b\x0d\x87\xb9\xf4\x35\x00\xa4\xa6\x28\x48\xf9\xb3\x21\xfb\xb2\x1c\x57\xa4\xb3\x61\x86\x37\xa8\x86\x4e\xe6\x03\x61\xd3\xa9\xf4\x98\xfa\xca\xe2\x50\x94\x72\xc0\xc4\x6a\x06\x81\xa4\xc8\xbe\xb2\x11\x32\xdc\xa3\x05\xf1\x05\x95\x39\x6f\xa5\xce\xe7\x86\xd8\xe7\x36\xca\x9a\x3c\x8f\x2c\x53\xc4\xe5\x81\x97\x56\xa4\xf4\x8a\xa4\xf2\xfe\xbb\xb3\x73\xa8\x09\x08\x62\x0f\x12\x6e\xa7\xba\x56\xd8\x24\x28\xa9\x27\x68\xc3\xcc\x89\x35\x05\xef\x82\x3a\x2b\x8d\xd4\x9e\x1f\x52\x25\x51\x7b\x70\xd5\xb8\x20\xa3\x25\x03\x43\xe7\x49\x0f\x09\xbc\x60\xfc\x83\x31\x42\x55\x66\xc2\x63\x96\xc0\x89\x86\x17\xa2\x40\xf5\x42\x38\xfc\xdd\x45\x4d\x12\x75\x03\x12\xdf\xf6\xc2\xee\xc2\xf7\xf2\x82\x25\x87\x02\xa8\xe1\x75\xad\x76\xe6\xf0\xe3\xac\xc4\xb4\xc6\x10\x5a\xc9\x98\x21\xf4\x02\xc8\xd4\x2a\x4a\xb6\x25\x62\xbd\xbb\x32\x89\xa8\x30\xf5\xc6\x2e\x8f\x2c\x90\x7a\x16\x27\xc6\x15\x81\xcc\x39\xd2\x1e\xb9\xcd\xb8\xb3\x05\xa5\xf7\x51\xcb\x5a\x10\x3e\x9d\x7e\x77\x47\x36\xd9\x81\xf4\x7b\xa8\x5f\x5c\x14\x3c\x82\x22\x13\xa1\x89\x12\x63\x54\x8d\x28\x6a\x24\x2c\x82\xc9\x9f\x4f\x71\xee\x0d\x08\x8b\x70\xfc\xf6\x25\x66\xab\x98\x6b\x19\x14\xd6\x8a\xd9\x9a\x19\xd2\x63\xb1\x96\xf0\x05\xd2\x8f\x37\x90\x17\x1d\xbb\x1e\xf1\x53\xc1\xb1\xc4\x73\x24\x09\xa0\xd5\x07\x01\xd7\x38\x0b\xf8\x46\xb0\x19\x55\x16\x26\x5b\x64\x34\x64\x65\x5e\xe3\x8c\x27\x45\xb0\x5b\x4b\xdd\x3d\xfa\x0b\xbf\xd5\xd1\x64\xfe\x37\xa0\x4f\x6e\x1c\xaf\x89\x5d\x3b\xe9\x3e\x63\x09\xbf\x6b\x9c\x6d\x1a\x5e\x10\x38\xc9\x21\xba\x61\x90\x3c\xbd\x60\x69\xb1\x67\xd6\xc2\x16\x65\xa9\x24\x32\x9a\x6d\xdc\x7b\x2d\x9c\xcc\xff\x6a\x56\x1f\x40\x68\xa3\xca\x16\xa1\x83\xb2\x1f\xb9\xa0\x58\xb2\xf4\xa9\x2c\x63\x92\x10\x52\x83\x3a\x94\xfd\x24\x94\xec\xa4\x21\x6c\xd5\x27\xba\x0f\x6f\x8d\xa7\x3f\xdf\xdd\x49\x82\x6a\xb2\x87\x97\x06\xdd\x5b\xe3\xf9\xcd\x17\x61\x35\x90\xf0\x00\x46\xc3\x02\x36\x76\x1d\xfc\x8a\x38\xe9\xc6\x33\x4a\xa3\x26\xac\x9f\x46\x28\xd2\x51\x44\x31\xb6\xe6\x88\x33\x8c\xb0\x51\xd8\xa2\xa8\x1c\x07\x20\x6d\xf4\x00\x8b\xd2\xcf\x56\xee\x11\x05\x61\xec\x9c\x1c\x36\x6c\x17\xb7\x3a\xa7\xb8\x18\x46\x42\x06\xa3\x28\x15\x85\xac\x62\xa2\x39\x1a\x53\x2e\x2d\x53\x28\xd0\xe6\x08\x25\x21\xd4\x36\xe2\xdd\x84\x2b\xe1\x77\x0f\xba\x6c\xa9\x2b\x86\xcc\xd7\xe4\x00\x0f\x80\xd8\x30\x3f\xc0\x52\x21\x4a\x52\xd3\x07\x42\x1f\x96\xd4\x47\x28\x85\xa4\x8c\xf7\x98\xb3\x77\x85\x73\x63\x52\xb3\x4c\xbb\xdb\xd0\x0e\xd2\x01\x41\xc9\x8d\x50\x84\x77\x64\xc9\x1a\x50\x05\xf4\xa3\x24\x7b\x01\xd8\xfb\x70\x3b\x35\x2e\x80\xd9\x44\xa2\xe2\xdc\xa7\x77\x8d\xb3\x5e\x7f\x49\xb5\xbd\x13\xdd\x0b\xb8\xb8\xa4\xcc\x06\x44\x8d\x56\x33\xe8\xf1\x58\xef\xd3\x63\xc1\x46\xb0\x14\x59\xc6\xe5\xa1\x50\xa7\x5b\xa0\xd9\x46\xbd\x39\xb4\x37\x32\xc5\xe3\x34\x35\x95\xe6\xc2\x69\x8b\xb8\xbe\xb8\xa4\x06\x3f\x91\x15\x52\xcf\xd5\x16\x3c\x13\x44\x98\x0a\xb7\x53\x99\x4e\xe1\x56\x2a\xc5\x69\x9c\xc3\x8c\xd4\x93\x61\xa9\xcc\xac\x91\xf3\xbe\x3b\x08\x9a\xa5\x7c\xb2\x96\x3d\x57\x6a\xeb\x53\x83\x75\xcc\x51\xfa\x9f\x9e\x5a\x73\x23\x33\xcc\x8e\x4f\x4f\x56\x4a\x69\x9e\x39\x5e\x02\x1e\x95\x72\x5c\x7e\x51\xce\xe9\x4d\xcc\x39\x57\xa6\x30\x65\x67\xff\x4e\x91\xbe\x96\xd8\xb1\x31\x0a\xc5\xf2\x78\x48\x85\x9a\x22\xf4\x7e\x5a\xcf\x17\x16\x44\xb8\xc3\xbb\x52\xc9\x54\xfa\x1a\xbf\xdb\xdc\x8a\xeb\x19\x5e\xc4\xc0\x25\x39\x1b\x70\xe8\xfb\x6d\xae\x26\x1d\xc8\x5c\x1b\xbb\xda\x3e\x37\xe3\xc9\x06\x14\xb9\x07\x3b\xee\x06\xd7\xd5\x18\xad\x46\x8f\x6e\x40\x39\xd6\x20\x2e\xc0\x85\xf4\xd8\x0b\x5f\x2d\x7d\x62\x43\x82\xcc\xf3\x9b\x14\x39\x3c\xad\x4a\x92\xdf\x3f\x3c\x47\x5e\x9f\xaf\x0c\x40\x09\xe7\x7f\x0c\x55\xca\x03\x32\xeb\xd4\xe8\xe0\xd7\xf7\xab\xfe\x45\x33\x75\x31\xc6\xad\xb2\xd0\x76\xe3\x2f\xaa\xd4\x39\x8a\x7a\x0d\x49\x2d\x14\x66\xe8\x85\x54\x41\xe2\x46\x23\x08\x82\x06\x5f\x53\x99\x56\xd6\x72\xb5\xe7\xc9\xb3\xea\xca\xfd\xf8\xf4\x04\x1a\x6d\xc0\x60\x30\x08\x71\xd1\x79\x5b\xa5\x6c\xaf\x54\x85\xeb\x0c\x33\xde\x35\x93\x96\x4b\x6f\x47\x9b\xb7\x72\x88\x99\x57\x80\xf3\x52\xf8\x29\x24\x41\xf9\x49\x47\x14\x00\xaf\x8c\x05\xbc\x13\x45\xa9\xb0\xcf\x62\x80\x57\xc6\x44\x9b\x09\x1f\xfc\xc0\x8c\x0e\x87\xf0\xbe\x4d\x98\x38\x28\x8c\x09\xdb\x42\xbe\xc4\xdd\x05\x98\x18\x43\x92\xee\xf2\x94\xd4\x8b\x7f\xd0\xe6\x56\xaf\x22\x81\xbf\x29\x2c\x8e\xe0\xb2\x77\x7c\x23\xa4\x12\x63\x85\x97\xbd\x3e\x5c\xf6\x4e\xad\xc9\x39\x44\xe9\xfc\x32\xc6\x9c\xcb\xde\x4b\xcc\xad\xc8\x30\xbb\xec\xd5\x5b\xff\x95\xb3\x80\x37\x94\x10\xfc\x80\xb3\x67\xbc\xe1\xdc\xd0\x59\xc8\x1a\x66\xcf\x42\xd2\x50\x8f\x91\x93\x9d\xcf\x4a\x7c\x46\x11\xb3\xfb\xf2\x8d\x28\xe7\x36\xea\x58\xda\xc5\x15\xd5\xb3\x37\x87\x49\xab\xea\x9f\x7f\x71\x46\x8f\x2e\x7b\x2d\x4f\x7d\x53\x90\xc9\x94\x7e\x76\xd9\x83\x39\x0a\x46\x97\x3d\xa6\xa1\x7e\x5f\x13\x3d\xba\xec\xd1\xd7\xe8\xb5\x35\xde\x8c\xab\xc9\xe8\xb2\x37\x9e\x79\x74\xfd\xc3\xbe\xc5\xb2\x4f\x00\xf6\xac\xfd\xc2\x65\xef\x67\xb8\xd4\x35\xd1\xc6\x4f\xd1\x06\x4d\x3b\xf8\xd8\xdb\x80\x3e\x1b\x42\xea\x7d\xb5\x47\xf0\xe8\x73\x2b\xb4\x93\x75\x07\x75\xed\xd4\x02\x9d\x13\xf9\xfa\x71\x8b\xc2\xad\x0c\x0f\x61\x38\x58\xc9\xda\x61\xe2\x65\xe5\xe0\xfd\x85\xcd\x32\x0f\x5b\x16\x94\xcb\x0b\xdb\x72\xc7\x79\xf0\xf4\x82\x3d\xba\xb1\x0b\xdf\xcc\x26\x47\xb5\xa6\x60\xff\x8f\x00\xcc\x29\x19\xeb\x2d\x26\xbd\xb1\x11\x37\x46\xb8\x9d\xa2\x8e\x2d\xd1\x0c\xad\x9a\x51\xe6\xdb\xee\x9a\x4e\x85\xce\x31\x4b\x20\xa4\xdd\x82\xf1\x80\x02\xf4\x35\x39\x18\xa7\x6b\x1a\x2a\x57\x37\xa8\x98\xae\x66\x47\x02\x96\x00\x08\x71\x1b\x46\xce\x34\xc5\xd2\x93\xd7\xdd\x57\xbd\xde\x53\xa3\x4c\x8c\x2d\x84\x1f\x01\x61\xfe\xc0\xaf\x37\x8f\x68\x1c\x5b\x0a\x3e\xce\x0e\xd9\xf1\xb4\x2a\x84\x26\xeb\xc9\x88\xde\x76\x4c\x67\x32\x15\xdc\x95\xab\xf1\x56\x8c\x4d\x15\x10\xb0\xd5\x43\x14\x75\x21\x66\x24\x67\x4a\x13\xc8\x47\x23\x5b\x9f\xc9\x7c\x21\xee\x5e\xa3\xce\xfd\x74\x04\x5f\x1f\xfd\xfd\xe9\x37\x6b\x26\x06\xd0\xc4\xec\x7b\xd4\x14\x9f\x56\x34\x7d\xd7\x88\x61\x79\x61\xb7\x80\x25\x3e\x93\xba\xd3\x96\xe4\xed\x9c\xa6\x02\x6f\x2d\xe8\x56\x70\xc2\x03\x63\x41\xc9\x67\x55\x92\x5c\x28\x0a\x70\xff\x5c\xa7\xd8\x07\x39\x59\xbd\x99\x6c\xc0\x5d\xcd\xe0\xf0\xa8\x0f\xe3\x28\xe2\x65\x58\xbf\xb8\xbb\x4a\x56\x90\x2c\x1d\x7c\xdb\x5f\xa0\x87\x72\xdc\x8a\x23\x22\xa7\x97\xb7\xd2\x4f\xc1\x62\x08\x93\xb1\xf9\xbc\x22\x4c\x62\x43\xef\x7d\x8a\xa3\x60\x99\xe3\xfa\x6e\x48\x6d\xb6\x52\xfb\xa7\x7f\x5b\xaf\x5f\xa9\x65\x51\x15\x23\x78\xb2\x66\x4a\x80\xb4\x2d\xb5\x19\x26\xb7\x59\x82\x20\xe8\xca\xad\x28\x0a\x4e\xbd\x65\x86\xda\x53\xfd\x60\xbb\xa6\xed\xb9\x8e\xe2\x85\x13\x6e\x45\x75\xa4\xf8\xc8\x45\x1c\xea\x18\xfb\xa9\x35\x59\x95\xa2\xe5\xe8\x1c\x2b\x92\xb4\x0b\x50\xb3\x12\x83\x37\x84\xf3\x04\xca\x9a\x31\xf5\x4d\xe7\x3e\x34\xf7\x51\x68\xa9\x73\x17\x3f\x29\x5d\x00\x90\x10\x8d\x6f\xa7\xc8\xa1\x67\xae\x12\x64\xaa\x9c\xcc\xd0\x62\x06\x02\xf2\x4a\x58\xa1\x3d\x62\x46\xf0\x13\xaa\xc1\xd0\x4d\x6f\x21\x4f\xb4\x3d\xec\xda\x1b\x83\xab\x06\xb0\x22\x12\x63\xdf\x3b\xf4\x09\xbe\x98\xab\x1e\x3e\x39\xda\xa8\xf2\x66\xde\xfa\x5e\x9a\xf0\x1e\xad\x1e\xc1\xbf\x2e\x8e\x07\xff\x14\x83\xdf\xae\xf6\xe3\x3f\x4f\x06\xdf\xfe\xbb\x3f\xba\x7a\xdc\x79\xbc\x3a\x78\xfe\x97\x35\x3b\xad\x4e\xeb\xd7\x98\x4f\x0c\x22\x75\x12\x59\x6b\xb4\xcf\x11\xc6\x4c\xe0\xdc\x56\xd8\x87\x57\x42\x39\xec\xc3\x8f\x9a\x43\xc3\x67\x0a\x0d\x75\x55\x6c\x6e\x4b\xf6\xe8\xab\xab\x93\x8f\x66\x0a\x93\xb4\x79\x4e\x24\x77\x53\x67\x60\x3b\x21\x71\xfa\x66\x26\x5d\xa4\xe9\x9c\x95\x00\x23\x1e\xa5\xac\x49\x4c\x7f\x93\xd4\x14\xc3\xce\x59\x0a\xe5\xdd\x6f\x84\x9e\x41\x0b\x6b\x21\x59\x5d\xb4\x74\xe7\x09\x9b\x44\x6a\x8d\x73\xcd\x49\x83\x03\x25\xaf\x11\x9a\x8c\x36\x80\xe5\x18\x53\xc1\x89\xba\x1d\x4b\x6f\x85\x9d\x75\xea\x12\x48\x85\x8e\x3d\x81\x49\xa5\x60\xdf\x21\x42\xa2\x4d\x86\xcb\xe8\x7a\x10\x30\x54\x8c\xa5\x92\x7e\x16\x1a\x08\xa9\xd1\x13\x25\x63\x7d\x50\x94\xc6\x7a\xa1\x7d\xdd\x7c\xc9\xf1\x8e\x4a\x5d\xee\xfb\x84\x22\x79\x3f\xd3\xee\xf0\xf0\xe8\xeb\xb3\x6a\x9c\x99\x42\x48\xfd\xaa\xf0\xc3\x83\xe7\xfb\xbf\x56\x42\x71\xe7\x82\x6a\xea\x57\x85\x3f\xf8\x72\x61\xf1\xf0\xe9\x16\x5e\xb4\x7f\x11\x7c\xe5\x6a\xff\x62\x10\xff\x7b\x5c\xbf\x3a\x78\xbe\x7f\x99\x6c\x1c\x3f\x78\x4c\x3c\x74\x3c\xf0\xea\x62\xd0\xba\x5f\x72\xf5\xf8\xe0\x79\x67\xec\x60\xd9\x19\x3b\x55\xeb\xbd\x05\xe8\xeb\x76\x6e\xc8\x4e\x7c\x7d\xa9\xa0\xf6\xcc\xf9\xd4\x70\xb1\x24\x8d\x5e\x4c\xf1\x38\x6e\xf3\xe0\xee\xce\x36\x49\x97\xde\xbe\x9b\x32\xdf\x47\x09\x8d\xfb\xd5\x47\xe3\x4d\x04\x9a\x63\xea\xcf\xd8\x2f\x81\xa5\x0e\xdf\x7b\x9c\x3c\xb0\xc1\xf7\x1e\x27\x60\x71\x82\x16\x75\x8a\xb5\x60\xe6\xfb\x7a\xf1\xd8\xb7\x69\xfc\xfd\x0e\x67\x78\xeb\x2f\x0a\xac\x64\x81\x92\xfd\x78\x39\xa0\xb6\xc7\xc8\xc3\xda\x03\x89\x7b\x5d\x9a\xe3\xf1\xa9\xf0\xd3\xad\x28\x78\x74\x12\xc5\xc6\xdd\x7b\x3e\x4f\x29\x25\xa6\x38\x77\x17\x81\xf3\x38\x14\x59\x7c\x49\x89\x8f\xc5\x38\xd6\x0f\x19\x47\x3c\xb3\x68\xef\x2a\x50\xd2\x04\x82\x80\x58\x66\xf0\x8f\xb3\x77\x6f\x87\xdf\x9b\x98\x2b\x50\x35\xe3\x82\x6f\x71\xb7\xb9\x0f\xae\x4a\xa7\x20\x1c\x91\x46\xf5\xed\x19\xb7\x25\x0a\xa1\xe5\x04\x9d\x4f\xe2\x6e\x68\xdd\xc5\xd1\x55\x32\xdf\x0e\x91\xf1\x60\xa3\x3e\xd1\x8f\x06\xc0\xbe\x41\xcc\x34\x6b\x39\x69\x65\x92\x4a\x93\x45\xa2\x6f\x99\x58\x2f\xae\x11\x4c\x24\xb6\x42\x0e\x0a\x23\xe8\x91\x99\x74\x3e\xfd\x81\x1c\xeb\x63\x0f\xf6\x6f\xa7\x68\x11\x7a\xf4\xd8\x0b\x1f\x6c\x2e\x60\xd0\xbb\x4e\xc4\x8f\x1f\x0e\xf9\xbd\x95\x79\xce\xe9\x16\xdf\x26\xb8\x41\xed\x0f\x38\xbe\x4d\x40\x9b\xce\x64\x1d\xfb\xd4\x6d\x77\x7a\x91\x90\x8b\xa3\xab\x1e\xec\xcf\xf3\x45\x29\x28\xde\xc1\x51\xd3\x91\x2e\x4d\x76\x50\x57\xad\x33\xed\xc5\x1d\x17\x06\x53\xe3\x50\x87\xce\xbf\x37\x30\x15\x37\x08\xce\x50\xf1\x89\x4a\x0d\x42\x82\x99\xc1\x6d\x68\xd0\xd5\xa2\x0c\x87\x3a\xa5\xb0\x7e\xe1\x7a\xca\xf9\xbb\x97\xef\x46\xe1\x6b\xa4\xb6\x5c\xd7\x55\xee\x44\x6a\xa1\xe2\xe9\x43\x93\x1f\x12\x21\x55\x50\x92\x37\xb1\xb4\xad\x4f\x46\x26\x95\xaf\x2c\x26\x8b\xd7\x15\xb6\xb6\xf8\x55\x77\x45\x56\x1b\x3b\xdf\x19\x59\x74\xb4\xff\xe2\x8d\x8c\xad\x59\xd4\x6b\x4e\x3c\x96\x59\x7c\xdb\xb1\xc1\x8d\x2c\xb6\xd0\x4c\x5c\x66\x26\x75\xc4\x60\x8a\xa5\x77\x43\x73\x43\xd0\x89\xb7\xc3\x5b\x63\xaf\xa5\xce\x07\x64\x64\x83\xa0\x79\x37\xe4\x10\x33\xfc\x8a\xff\x7c\x16\x47\x1c\xa7\xb6\x67\x2b\x5c\x0c\xfb\x03\x78\xe3\xf0\x39\xfc\x64\xd6\xea\xfc\xf2\x21\x91\xe0\xd1\x59\x5d\xfc\x2d\xac\x26\x77\x09\x07\x52\xf1\xc6\x58\x07\xe1\x0a\x91\x05\x08\x14\x7a\xf6\xbb\x9b\x31\x09\x90\x6b\xfc\x74\x36\x88\x57\x3a\x07\x42\x67\x83\x26\xbf\x4e\x67\x9f\x2c\xb1\x4a\x6e\xe9\xc0\x3f\x9e\xbc\xfc\x63\x8c\xbb\x92\x0f\xf2\xd6\xd0\x45\x19\x81\xb7\x55\x9d\xdd\x39\x6f\xac\xc8\x71\xfe\x5d\x35\x6e\x8a\x8f\x96\xe1\x58\x57\xc2\x87\x8f\xfc\xaa\xbd\xc4\x29\x54\x39\x15\x47\xf5\xda\xdd\x55\xce\xdd\x55\xce\xdd\x55\xce\xdd\x55\xce\x8d\xc2\xde\x5d\xe5\xdc\x5d\xe5\xdc\x5d\xe5\xdc\x5d\xe5\xdc\x5d\xe5\xfc\x3c\x56\x77\x57\x39\x77\x57\x39\x77\x57\x39\x9b\xdf\xee\x2a\xe7\x96\xcc\xed\xae\x72\xfe\xd9\xaf\x72\xfe\x7f\x5f\xce\xdc\x1d\x8e\xfd\x6f\x1c\x8e\xed\x8e\xbb\x76\xc7\x5d\xbb\xe3\xae\xdd\x71\xd7\x27\x58\xfc\xee\xb8\x6b\x77\xdc\xb5\x3b\xee\xda\x1d\x77\xfd\x49\x8f\xbb\x26\x42\xb9\xad\xcf\xbb\xfe\x13\x00\x00\xff\xff\xf2\x1a\x66\xa5\x7c\x46\x00\x00") +var _operatorsCoreosCom_operatorgroupsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5a\xe9\x6f\x1b\x37\x94\xff\xee\xbf\xe2\x41\x5d\x20\x76\x56\x1a\xc5\xee\xa2\xdb\x0a\x08\x02\x23\x69\x0a\x6f\x73\x18\xb1\xdb\x0f\x6b\x7b\xb7\xd4\xcc\xd3\x88\x35\x87\x9c\x92\x1c\xdb\x6a\x90\xff\x7d\xf1\x1e\x39\x87\x6e\x39\x49\xbb\xdd\x85\xfc\x25\xd1\xf0\x7a\xe7\xef\x1d\xa4\x28\xe5\xaf\x68\x9d\x34\x7a\x04\xa2\x94\xf8\xe0\x51\xd3\x2f\x97\xdc\x7e\xef\x12\x69\x86\x77\xc7\x07\xb7\x52\x67\x23\x78\x59\x39\x6f\x8a\x0f\xe8\x4c\x65\x53\x7c\x85\x13\xa9\xa5\x97\x46\x1f\x14\xe8\x45\x26\xbc\x18\x1d\x00\x08\xad\x8d\x17\xf4\xd9\xd1\x4f\x80\xd4\x68\x6f\x8d\x52\x68\x07\x39\xea\xe4\xb6\x1a\xe3\xb8\x92\x2a\x43\xcb\x9b\xd7\x47\xdf\x3d\x4b\xbe\x4f\x9e\x1d\x00\xa4\x16\x79\xf9\xa5\x2c\xd0\x79\x51\x94\x23\xd0\x95\x52\x07\x00\x5a\x14\x38\x02\x53\xa2\x15\xde\xd8\xdc\x9a\xaa\x74\x49\xfd\xd3\x25\xa9\xb1\x68\xe8\x9f\xe2\xc0\x95\x98\xd2\xe9\x3c\xa7\x5d\x32\x37\x27\xec\x57\x13\x29\x3c\xe6\xc6\xca\xfa\x37\xc0\x00\x8c\x2a\xf8\xff\x81\xf9\xf7\x71\x8f\x9f\x68\x4b\xfe\xae\xa4\xf3\x3f\x2f\x8f\xbd\x91\xce\xf3\x78\xa9\x2a\x2b\xd4\x22\xc1\x3c\xe4\xa6\xc6\xfa\x77\xed\xf1\x7c\x5c\x1e\x86\xa4\xce\x2b\x25\xec\xc2\xba\x03\x00\x97\x9a\x12\x47\xc0\xcb\x4a\x91\x62\x76\x00\x10\xc5\x17\xb7\x19\x44\x11\xdd\x1d\xc7\x5d\x5d\x3a\xc5\x42\xd4\x67\x00\x6d\xa9\x4f\xcf\xcf\x7e\xfd\xf6\x62\x61\x00\x20\x43\x97\x5a\x59\x7a\x56\xc6\x1c\x43\x20\x1d\xf8\x29\x42\xa5\xa5\x07\x33\x81\xa2\x52\x5e\x7a\xd4\x42\xa7\x33\x98\x18\x0b\xef\xdf\xbc\x85\x42\x68\x91\x63\xd6\x11\x35\x9c\x79\xd2\xbd\xf3\x56\x48\x1d\x76\x90\xda\x79\xa1\x14\xab\x97\x76\x6a\x26\x83\xd4\x20\xbd\x0b\x1a\x21\xde\xc0\x1b\x10\x40\x6a\x94\x13\x89\x19\x38\xe4\xa3\xbd\xb0\x39\xfa\x76\x9a\x4b\x3a\x1c\xf8\x19\x89\xc7\x8c\x7f\xc7\xd4\x77\x3e\x5b\xfc\xa3\x92\x16\xb3\x2e\xb3\x24\xaa\xda\x68\x3b\x9f\x4b\x4b\x14\xf9\x8e\x15\x84\xbf\x8e\x8b\xcc\x7d\x5f\x90\xda\x13\x12\x6d\x98\x07\x19\x79\x07\x06\xb6\xa3\x92\x88\x0d\x16\x3b\x73\x32\x95\x0e\x2c\x96\x16\x1d\x6a\xdf\x48\x44\xe8\xc8\x40\x02\x17\x68\x69\x21\xd9\x4a\xa5\x32\x12\xe5\x1d\x5a\x0f\x16\x53\x93\x6b\xf9\x67\xb3\x9b\x23\x59\xd1\x31\x4a\x78\x74\x1e\xa4\xf6\x68\xb5\x50\x70\x27\x54\x85\x7d\x10\x3a\x83\x42\xcc\xc0\x22\xed\x0b\x95\xee\xec\xc0\x53\x5c\x02\x6f\x8d\x25\xed\x4c\xcc\x08\xa6\xde\x97\x6e\x34\x1c\xe6\xd2\xd7\x00\x90\x9a\xa2\x20\xe5\xcf\x86\xec\xcb\x72\x5c\x91\xce\x86\x19\xde\xa1\x1a\x3a\x99\x0f\x84\x4d\xa7\xd2\x63\xea\x2b\x8b\x43\x51\xca\x01\x13\xab\x19\x04\x92\x22\xfb\xc6\x46\xc8\x70\x4f\x16\xc4\x17\x54\xe6\xbc\x95\x3a\x9f\x1b\x62\x9f\xdb\x28\x6b\xf2\x3c\xb2\x4c\x11\x97\x07\x5e\x5a\x91\xd2\x27\x92\xca\x87\x1f\x2f\x2e\xa1\x26\x20\x88\x3d\x48\xb8\x9d\xea\x5a\x61\x93\xa0\xa4\x9e\xa0\x0d\x33\x27\xd6\x14\xbc\x0b\xea\xac\x34\x52\x7b\xfe\x91\x2a\x89\xda\x83\xab\xc6\x05\x19\x2d\x19\x18\x3a\x4f\x7a\x48\xe0\x25\xe3\x1f\x8c\x11\xaa\x32\x13\x1e\xb3\x04\xce\x34\xbc\x14\x05\xaa\x97\xc2\xe1\x5f\x2e\x6a\x92\xa8\x1b\x90\xf8\x76\x17\x76\x17\xbe\x97\x17\x2c\x39\x14\x40\x0d\xaf\x6b\xb5\x33\x87\x1f\x17\x25\xa6\x35\x86\xd0\x4a\xc6\x0c\xa1\x17\x40\xa6\x56\x51\xb2\x2b\x11\xeb\xdd\x95\x49\x44\x85\xa9\x37\x76\x79\x64\x81\xd4\x8b\x38\x31\xae\x08\x64\xce\x91\xf6\xc4\x6d\xc6\x9d\x1d\x28\xdd\x46\x2d\x6b\x41\xf8\x74\xfa\xe3\x03\xd9\x64\x07\xd2\xb7\x50\xbf\xb8\x28\x78\x04\x45\x26\x42\x13\x25\xc6\xa8\x1a\x51\xd4\x48\x58\x04\x93\xbf\x9c\xe2\xdc\x17\x10\x16\xe1\xf4\xdd\x2b\xcc\x56\x31\xd7\x32\x28\xac\x15\xb3\x35\x33\xa4\xc7\x62\x2d\xe1\x0b\xa4\x9f\x6e\x20\x2f\x3a\x76\x3d\xe2\xa7\x82\x63\x89\xe7\x48\x12\x40\xab\x0f\x02\x6e\x71\x16\xf0\x8d\x60\x33\xaa\x2c\x4c\xb6\xc8\x68\xc8\xca\xbc\xc5\x19\x4f\x8a\x60\xb7\x96\xba\x2d\xfa\x0b\x7f\xab\xa3\xc9\xfc\xdf\x80\x8e\xdc\x38\x5e\x13\xbb\x76\xd2\x36\x63\x09\x7f\xb7\x38\xdb\x34\xbc\x20\x70\x92\x43\x74\xc3\x20\x79\xfa\xc0\xd2\x62\xcf\xac\x85\x2d\xca\x52\x49\x64\x34\xdb\xb8\xf7\x5a\x38\x99\xff\xab\x59\x7d\x04\xa1\x8d\x2a\x5b\x84\x0e\xca\x7e\xe2\x82\x62\xc9\xd2\xa7\xb2\x8c\x49\x42\x48\x0d\xea\x50\xf6\xab\x50\xb2\x93\x86\xb0\x55\x9f\xe9\x3e\xbc\x33\x9e\xfe\xf9\xf1\x41\x12\x54\x93\x3d\xbc\x32\xe8\xde\x19\xcf\x5f\xbe\x0a\xab\x81\x84\x47\x30\x1a\x16\xb0\xb1\xeb\xe0\x57\xc4\x49\x37\x9e\x51\x1a\x35\x61\xfd\x34\x42\x91\x8e\x22\x8a\xb1\x35\x47\x9c\x61\x84\x8d\xc2\x16\x45\xe5\x38\x00\x69\xa3\x07\x58\x94\x7e\xb6\x72\x8f\x28\x08\x63\xe7\xe4\xb0\x61\xbb\xb8\xd5\x25\xc5\xc5\x30\x12\x32\x18\x45\xa9\x28\x64\x15\x13\xcd\xd1\x98\x72\x69\x99\x42\x81\x36\x47\x28\x09\xa1\x76\x11\xef\x26\x5c\x09\x7f\x5b\xd0\x65\x47\x5d\x31\x64\xbe\x21\x07\x78\x04\xc4\x86\xf9\x01\x96\x0a\x51\x92\x9a\x3e\x12\xfa\xb0\xa4\x3e\x41\x29\x24\x65\xbc\xa7\x9c\xbd\x2b\x9c\x1b\x93\x9a\x65\xda\xdd\x86\x76\x90\x0e\x08\x4a\xee\x84\x22\xbc\x23\x4b\xd6\x80\x2a\xa0\x1f\x25\xd9\x0b\xc0\xde\x87\xfb\xa9\x71\x01\xcc\x26\x12\x15\xe7\x3e\xbd\x5b\x9c\xf5\xfa\x4b\xaa\xed\x9d\xe9\x5e\xc0\xc5\x25\x65\x36\x20\x6a\xb4\x9a\x41\x8f\xc7\x7a\x9f\x1f\x0b\x36\x82\xa5\xc8\x32\x2e\x0f\x85\x3a\xdf\x01\xcd\x36\xea\xcd\xa1\xbd\x93\x29\x9e\xa6\xa9\xa9\x34\x17\x4e\x3b\xc4\xf5\xc5\x25\x35\xf8\x89\xac\x90\x7a\xae\xb6\xe0\x99\x20\xc2\x54\xb8\x9f\xca\x74\x0a\xf7\x52\x29\x4e\xe3\x1c\x66\xa4\x9e\x0c\x4b\x65\x66\x8d\x9c\x0f\xdd\x51\xd0\x2c\xe5\x93\xb5\xec\xb9\x52\x5b\x9f\x1a\xac\x63\x8e\xd2\xff\xf4\xdc\x9a\x3b\x99\x61\x76\x7a\x7e\xb6\x52\x4a\xf3\xcc\xf1\x12\xf0\xa8\x94\xe3\xf2\x8b\x72\x4e\x6f\x62\xce\xb9\x32\x85\x29\x3b\xfb\x77\x8a\xf4\xb5\xc4\x8e\x8d\x51\x28\x96\xc7\x43\x2a\xd4\x14\xa1\xdb\x69\xbd\x5c\x58\x10\xe1\x0e\x1f\x4a\x25\x53\xe9\x6b\xfc\x6e\x73\x2b\xae\x67\x78\x11\x03\x97\xe4\x6c\xc0\xa1\xef\xb7\xb9\x9a\x74\x20\x73\x6d\xec\x6a\xfb\xdc\x8c\x27\x1b\x50\x64\x0b\x76\x3c\x0c\x6e\xab\x31\x5a\x8d\x1e\xdd\x80\x72\xac\x41\x5c\x80\x0b\xe9\xb1\x17\xbe\x5a\x3a\x62\x43\x82\xcc\xf3\x9b\x14\x39\xfc\x5a\x95\x24\x7f\x78\x7c\x8e\xbc\x3e\x5f\x19\x80\x12\xce\xff\x12\xaa\x94\x47\x64\xd6\xa9\xd1\xc1\xaf\xb7\xab\xfe\x65\x33\x75\x31\xc6\xad\xb2\xd0\x76\xe3\xaf\xaa\xd4\x39\x8a\x7a\x0d\x49\x2d\x14\x66\xe8\x85\x54\x41\xe2\x46\x23\x08\x82\x06\x5f\x53\x99\x56\xd6\x72\xb5\xe7\xc9\xb3\xea\xca\xfd\xf4\xfc\x0c\x1a\x6d\xc0\x60\x30\x08\x71\xd1\x79\x5b\xa5\x6c\xaf\x54\x85\xeb\x0c\x33\xde\x35\x93\x96\x4b\x6f\x47\x9b\xb7\x72\x88\x99\x57\x80\xf3\x52\xf8\x29\x24\x41\xf9\x49\x47\x14\x00\xaf\x8d\x05\x7c\x10\x45\xa9\xb0\xcf\x62\x80\xd7\xc6\x44\x9b\x09\x07\x7e\x84\xe1\x10\x3e\xb4\xc9\x12\x07\x84\x31\xe1\x5a\xc8\x95\xb8\xb3\x00\x13\x63\x48\xca\x5d\x7e\x12\x5a\xf8\xb3\x36\xf7\x7a\xd5\xd1\x7c\x96\xb0\x38\x82\xeb\xde\xe9\x9d\x90\x4a\x8c\x15\x5e\xf7\xfa\x70\xdd\x3b\xb7\x26\xe7\xd0\xa4\xf3\xeb\x18\x6b\xae\x7b\xaf\x30\xb7\x22\xc3\xec\xba\x47\xdb\xfe\x2b\x47\xfe\xb7\x94\x04\xfc\x8c\xb3\xe7\xbc\x59\xf3\xf9\x22\x64\x09\xb3\xe7\x21\x49\xa0\xef\xe4\x50\x97\xb3\x12\x9f\x53\x74\xac\x3f\xbc\x15\x65\xb3\xb8\x63\x4d\x57\x37\x54\xb3\xde\x1d\x27\xad\x3a\x7f\xfb\xdd\x19\x3d\xba\xee\xb5\xf4\xf7\x4d\x41\x66\x51\xfa\xd9\x75\x0f\xe6\x4e\x1d\x5d\xf7\xf8\xdc\xfa\x7b\x4d\xe4\xe8\xba\x47\x27\xd1\x67\x6b\xbc\x19\x57\x93\xd1\x75\x6f\x3c\xf3\xe8\xfa\xc7\x7d\x8b\x65\x9f\x40\xea\x79\x7b\xc2\x75\xef\x37\xb8\xd6\x44\xac\xf1\x53\xb4\x41\x93\x0e\x3e\xf5\x36\xa0\xcb\x86\x90\xb9\xad\xb6\x08\x1e\x7b\x69\x85\x76\xb2\xee\x90\xae\x9d\x5a\xa0\x73\x22\x5f\x3f\x6e\x51\xb8\x95\xf0\x1f\x86\x83\x35\xac\x1d\x26\x5e\x56\x0e\x6e\x2f\x5c\x96\x79\xd8\xb1\x60\x5c\x5e\xd8\x96\x33\xce\x83\xa7\x0f\xec\xb1\x8d\x4d\xf8\x66\x36\x39\xa2\x35\x05\xfb\x77\x04\x58\x4e\xb9\x58\x6f\x31\xa9\x8d\x8d\xb6\x31\xc2\xfd\x14\x75\x6c\x79\x66\x68\xd5\x8c\x32\xdb\x76\xd7\x74\x2a\x74\x8e\x59\x02\x21\xad\x16\xec\xef\x14\x80\x6f\xc9\x91\x38\x1d\xd3\x50\xb9\xba\x01\xc5\x74\x35\x3b\x12\x70\x04\x87\x8f\xdb\x30\x32\xa6\x29\x96\x9e\xbc\x6b\x5b\x75\xba\xa5\x06\x99\x18\x5b\x08\x3f\x02\xc2\xf4\x81\x5f\x6f\x1e\xd1\x38\x76\x14\x7c\x9c\x1d\xb2\xdf\x69\x55\x08\x4d\xd6\x93\x11\xbd\xed\x98\xce\x64\x2a\xb8\xeb\x56\xe3\xa9\x18\x9b\x2a\x20\x5c\xab\x87\x28\xea\x42\xcc\x48\xce\x94\x06\x90\x7f\x46\xb6\xbe\x90\xf9\x42\x3c\xbc\x41\x9d\xfb\xe9\x08\xbe\x3d\xf9\xf7\xef\xbe\x5f\x33\x31\x00\x23\x66\x3f\xa1\xa6\xf8\xb3\xa2\xa9\xbb\x46\x0c\xcb\x0b\xbb\x05\x2a\xf1\x99\xd4\x9d\xb4\x24\x6f\xe7\x34\x15\x76\x6b\x41\xf7\x82\x13\x1a\x18\x0b\x4a\x2e\xab\x92\xe4\x42\x28\xcf\xfd\x71\x9d\x62\x1f\xe4\x64\xf5\x66\xb2\x01\x70\x35\x83\xe3\x93\x3e\x8c\xa3\x88\x97\xe1\xfb\xea\xe1\x26\x59\x41\xb2\x74\xf0\x43\x7f\x81\x1e\xca\x61\x2b\x8e\x78\x9c\x3e\xde\x4b\x3f\x05\x8b\x21\x0c\xc6\xe6\xf2\x8a\x30\x88\x0d\xbd\xdb\x14\x47\xc1\x30\xc7\xf5\xdd\x8e\xda\x6c\xa5\xf6\xdf\xfd\xdb\x7a\xfd\x4a\x2d\x8b\xaa\x18\xc1\xb3\x35\x53\x02\xa4\xed\xa8\xcd\x30\xb9\xcd\x02\x04\x41\x57\x6e\x45\x51\x70\x6a\x2d\x33\xd4\x9e\xea\x03\xdb\x35\x6d\xcf\x75\x12\x2f\x9c\x70\xab\xa9\x23\xc5\x27\x2e\xe2\x50\xc7\xd8\xcf\xad\xc9\xaa\x14\x2d\x47\xe0\x58\x71\xa4\x5d\x80\x9a\x95\x18\xbc\x21\xdc\x17\x50\x56\x8c\xa9\x6f\x3a\xf3\xa1\x79\x8f\x42\x4b\x9d\xbb\x78\xa4\x74\x01\x40\x42\xd4\xbd\x9f\x22\x87\x9e\xb9\x4a\x8f\xa9\x72\x32\x43\x8b\x19\x08\xc8\x2b\x61\x85\xf6\x88\x19\xc1\x4f\xa8\xf6\x42\xb7\xbc\x85\x3c\xd1\xf6\xa8\x6b\x6f\x0c\xae\x1a\xc0\x8a\x48\x8c\x7d\xed\xd0\x07\xf8\x6a\xae\x7a\xfc\xec\x64\xa3\xca\x9b\x79\xeb\x7b\x65\xc2\x7b\xb4\x7a\x04\xff\x75\x75\x3a\xf8\x4f\x31\xf8\xf3\xe6\x30\xfe\xe7\xd9\xe0\x87\xff\xee\x8f\x6e\x9e\x76\x7e\xde\x1c\xbd\xf8\x97\x35\x3b\xad\x4e\xdb\xd7\x98\x4f\x0c\x22\x75\x92\x58\x6b\xb4\xcf\x11\xc6\x4c\xe0\xd2\x56\xd8\x87\xd7\x42\x39\xec\xc3\x2f\x9a\x43\xc3\x17\x0a\x0d\x75\x55\x6c\x6e\x3b\xf6\xe8\xd4\xd5\xc9\x47\x33\x85\x49\xda\x3c\x27\x92\xbb\xa9\xf2\xdf\x4d\x48\x9c\xb6\x99\x49\x17\x69\x3a\x77\x21\xc0\x88\x47\x69\x69\x12\xd3\xdb\x24\x35\xc5\xb0\x73\x57\x42\x79\xf5\x5b\xa1\x67\xd0\xc2\x5a\x48\x4a\x17\x2d\xdd\x79\xc2\x26\x91\x5a\xe3\x5c\x73\x93\xe0\x40\xc9\x5b\x84\x26\x73\x0d\x60\x39\xc6\x54\x70\x22\x6e\xc7\xd2\x5b\x61\x67\x9d\xba\x03\x52\xa1\x63\xcd\x3f\xa9\x14\x1c\x3a\x44\x48\xb4\xc9\x70\x19\x5d\x8f\x02\x86\x8a\xb1\x54\xd2\xcf\x42\x83\x20\x35\x7a\xa2\x64\xcc\xff\x8b\xd2\x58\x2f\xb4\xaf\x9b\x2b\x39\x3e\x50\x29\xcb\x7d\x9d\x50\x04\x1f\x66\xda\x1d\x1f\x9f\x7c\x7b\x51\x8d\x33\x53\x08\xa9\x5f\x17\x7e\x78\xf4\xe2\xf0\x8f\x4a\x28\xee\x4c\x50\xcd\xfc\xba\xf0\x47\x5f\x2f\x2c\x1e\x7f\xb7\x83\x17\x1d\x5e\x05\x5f\xb9\x39\xbc\x1a\xc4\xff\x3d\xad\x3f\x1d\xbd\x38\xbc\x4e\x36\x8e\x1f\x3d\x25\x1e\x3a\x1e\x78\x73\x35\x68\xdd\x2f\xb9\x79\x7a\xf4\xa2\x33\x76\xb4\xec\x8c\x9d\xaa\x74\x6b\x81\xf9\xa6\x9d\x1b\xb2\x13\x5f\x3f\x1a\xa8\x3d\x73\x3e\x35\x5c\x2c\x39\xa3\x17\x53\x3c\x8e\xdb\x3c\xba\x7b\xb3\x4b\xd2\xa5\x77\xef\x96\xcc\xf7\x49\x42\x63\x7e\xf5\xd5\x77\x13\x81\xe6\x98\xfa\x27\xf6\x43\x60\xa9\x83\xf7\x01\x27\x8f\x6c\xe0\x7d\xc0\x09\x58\x9c\xa0\x45\x9d\x62\x2d\x98\xf9\xbe\x5d\xbc\xd6\x6d\x1a\x7b\x7f\xc1\x1d\xdd\xfa\x87\x00\x2b\x59\xa0\x64\x3f\x5e\xfe\xd7\xf6\x18\x79\x58\x7b\xe1\xb0\xd5\xa5\x39\x1e\x9f\x0b\x3f\xdd\x89\x82\x27\x67\x51\x6c\xdc\x9d\xe7\xfb\x92\x52\x62\x8a\x73\x6f\x0d\x38\x8f\x43\x91\xc5\x8f\x94\xf8\x58\x8c\x63\xfd\x90\x71\xc4\x3b\x89\xf6\x2d\x02\x25\x4d\x20\x08\x88\x65\x06\xff\x71\xf1\xfe\xdd\xf0\x27\x13\x73\x05\xaa\x66\x5c\xf0\x2d\xee\x26\xf7\xc1\x55\xe9\x14\x84\x23\xd2\xa8\xbe\xbd\xe0\xd6\x43\x21\xb4\x9c\xa0\xf3\x49\xdc\x0d\xad\xbb\x3a\xb9\x49\xe6\xdb\x1d\x32\x5e\x5c\xd4\x37\xf6\xd1\x00\xd8\x37\x88\x99\x66\x2d\x27\xad\x4c\x52\x69\xb2\x48\xf4\x3d\x13\xeb\xc5\x2d\x82\x89\xc4\x56\xc8\x41\x61\x04\x3d\x32\x93\xce\xd1\x1f\xc9\xb1\x3e\xf5\xe0\xf0\x7e\x8a\x16\xa1\x47\x3f\x7b\xe1\xc0\xe6\x81\x05\x7d\xeb\x44\xfc\x78\x70\xc8\xef\xad\xcc\x73\x4e\xb7\xf8\xb5\xc0\x1d\x6a\x7f\xc4\xf1\x6d\x02\xda\x74\x26\xeb\xd8\x87\x6e\xbb\xcf\x8b\x84\x5c\x9d\xdc\xf4\xe0\x70\x9e\x2f\x4a\x41\xf1\x01\x4e\x9a\x8e\x73\x69\xb2\xa3\xba\x6a\x9d\x69\x2f\x1e\xb8\x30\x98\x1a\x87\x3a\x74\xf6\xbd\x81\xa9\xb8\x43\x70\x86\x8a\x4f\x54\x6a\x10\x12\xcc\x0c\xee\x43\x03\xae\x16\x65\xb8\xb4\x29\x85\xf5\x0b\xcf\x4f\x2e\xdf\xbf\x7a\x3f\x0a\xa7\x91\xda\x72\x5d\x57\xb9\x13\xa9\x85\x8a\xb7\x0b\x4d\x7e\x48\x84\x54\x41\x49\xde\xc4\xd2\xb6\xbe\xf9\x98\x54\xbe\xb2\x98\x2c\x3e\x47\xd8\xd9\xe2\x57\xbd\x05\x59\x6d\xec\xfc\x26\x64\xd1\xd1\xfe\x17\x5f\x5c\xec\xcc\xa2\x5e\x73\xa3\xb1\xcc\xe2\xbb\x8e\x0d\x6e\x64\xb1\x85\x66\xe2\x32\x33\xa9\x23\x06\x53\x2c\xbd\x1b\x9a\x3b\x82\x4e\xbc\x1f\xde\x1b\x7b\x2b\x75\x3e\x20\x23\x1b\x04\xcd\xbb\x21\x87\x98\xe1\x37\xfc\xcf\x17\x71\xc4\x71\x6a\x77\xb6\xc2\xc3\xaf\xbf\x81\x37\x0e\x9f\xc3\xcf\x66\xad\xce\x2f\x1f\x13\x09\x9e\x5c\xd4\xc5\xdf\xc2\x6a\x72\x97\x70\xe1\x14\x5f\x84\x75\x10\xae\x10\x59\x80\x40\xa1\x67\x7f\xb9\x19\x93\x00\xb9\xc6\x4f\x67\x83\xf8\x64\x73\x20\x74\x36\x68\xf2\xeb\x74\xf6\xd9\x12\xab\xe4\x8e\x0e\xfc\xcb\xd9\xab\xbf\xc7\xb8\x2b\xf9\x28\x6f\x0d\x5d\x94\x11\x78\x5b\xd5\xd9\x9d\xf3\xc6\x8a\x1c\xe7\xbf\x55\xe3\xa6\xf8\x68\x19\x8e\x75\x25\x7c\xfc\xc4\x9f\xda\x47\x9a\x42\x95\x53\x71\x52\xaf\xdd\x3f\xd5\xdc\x3f\xd5\xdc\x3f\xd5\xdc\x3f\xd5\xdc\x28\xec\xfd\x53\xcd\xfd\x53\xcd\xfd\x53\xcd\xfd\x53\xcd\xfd\x53\xcd\x2f\x63\x75\xff\x54\x73\xff\x54\x73\xff\x54\xb3\xf9\xdb\x3f\xd5\xdc\x91\xb9\xfd\x53\xcd\x7f\xfa\x53\xcd\xff\xdf\x8f\x2f\xf7\x97\x63\xff\x37\x2e\xc7\xf6\xd7\x5d\xfb\xeb\xae\xfd\x75\xd7\xfe\xba\xeb\x33\x2c\x7e\x7f\xdd\xb5\xbf\xee\xda\x5f\x77\xed\xaf\xbb\xfe\xa1\xd7\x5d\x13\xa1\xdc\xce\xf7\x5d\xff\x13\x00\x00\xff\xff\xc7\xa0\x23\x13\x5c\x46\x00\x00") func operatorsCoreosCom_operatorgroupsYamlBytes() ([]byte, error) { return bindataRead( @@ -205,7 +205,7 @@ func operatorsCoreosCom_operatorgroupsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_operatorsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x59\x5f\x8f\xdb\xb8\x11\x7f\xdf\x4f\x31\xf0\x3d\xec\x1d\xe0\x3f\xbd\x14\x28\x0a\xbf\x2d\x76\x73\xc5\xb6\xd7\x4d\x90\xdd\xe4\xe5\x70\x0f\x63\x69\x6c\xb1\xa6\x48\x1d\x87\xb2\xd7\x0d\xf2\xdd\x8b\x21\x29\x5b\xb2\xbd\xb6\x9c\x6e\xd2\xf2\xc5\x16\x45\x0e\xe7\xef\x6f\x66\x28\xac\xd4\x27\x72\xac\xac\x99\x02\x56\x8a\x9e\x3d\x19\x79\xe2\xf1\xf2\xaf\x3c\x56\x76\xb2\xfa\xf9\x6a\xa9\x4c\x3e\x85\xdb\x9a\xbd\x2d\x3f\x10\xdb\xda\x65\x74\x47\x73\x65\x94\x57\xd6\x5c\x95\xe4\x31\x47\x8f\xd3\x2b\x00\x34\xc6\x7a\x94\x69\x96\x47\x80\xcc\x1a\xef\xac\xd6\xe4\x46\x0b\x32\xe3\x65\x3d\xa3\x59\xad\x74\x4e\x2e\x10\x6f\x8e\x5e\xfd\x69\xfc\x97\xf1\x9b\x2b\x80\xcc\x51\xd8\xfe\xa4\x4a\x62\x8f\x65\x35\x05\x53\x6b\x7d\x05\x60\xb0\xa4\x29\xd8\x8a\x1c\x7a\xeb\x78\xbc\xfb\x97\x59\x47\x56\x7e\xca\x2b\xae\x28\x93\x83\x17\xce\xd6\x55\x7b\x75\x6b\x4d\x24\xd5\xf0\x87\x9e\x16\xd6\xa9\xe6\x19\x60\x04\x56\x97\xe1\x7f\x94\xfb\x5d\xa2\x11\xa6\xb4\x62\xff\x8f\xce\xf4\xaf\x8a\x7d\x78\x55\xe9\xda\xa1\x6e\x9d\x19\x66\x59\x99\x45\xad\xd1\xed\xe6\xaf\x00\x38\xb3\x15\x4d\xe1\x56\xd7\xec\x49\x26\x92\x1e\x12\x0f\xa3\x24\xeb\xea\xe7\xc4\x12\x67\x05\x95\xd8\x30\x08\x42\xca\xdc\xbc\xbf\xff\xf4\xe7\xc7\xbd\x17\x00\x39\x71\xe6\x54\xe5\x83\x56\x1b\x1e\xc1\x51\xe5\x88\xc9\x78\x06\x84\x2c\x1e\xbb\x65\x68\xdc\xda\xee\x37\xc2\x98\x9d\xfd\x8b\x32\xdf\x9a\xae\x9c\x2c\xf6\x2d\x2d\xc5\xd1\xf2\x9e\xce\xfc\x1e\x1f\xd7\xc2\x6c\x5c\x07\xb9\x38\x0e\x31\xf8\x82\x1a\xb1\x29\x4f\x12\x82\x9d\x83\x2f\x14\xef\xf8\x0d\xbe\x20\xd3\x68\x12\x57\x63\x78\x24\x27\x1b\x81\x0b\x5b\xeb\x5c\x3c\x6c\x45\xce\x83\xa3\xcc\x2e\x8c\xfa\xf7\x96\x1a\x83\xb7\xe1\x18\x8d\x9e\xd8\x83\x32\x9e\x9c\x41\x0d\x2b\xd4\x35\x0d\x01\x4d\x0e\x25\x6e\xc0\x91\xd0\x85\xda\xb4\x28\x84\x25\x3c\x86\x7f\x5a\x47\xa0\xcc\xdc\x4e\xa1\xf0\xbe\xe2\xe9\x64\xb2\x50\xbe\x89\x8d\xcc\x96\x65\x6d\x94\xdf\x4c\x82\x9b\xab\x59\x2d\x76\x9f\xe4\xb4\x22\x3d\x61\xb5\x18\xa1\xcb\x0a\xe5\x29\xf3\xb5\xa3\x09\x56\x6a\x14\x98\x35\x21\x3e\xc6\x65\xfe\x83\x4b\xd1\xc4\xd7\x7b\xea\x8b\x76\x60\xef\x94\x59\x74\x5e\x05\x9f\x3c\xa9\x6b\x71\x4f\x50\x62\xe8\xb8\x3d\xca\xb2\x53\xa9\x4c\x89\x56\x3e\xbc\x7d\x7c\x82\x86\x81\xa8\xf6\xa8\xe1\x96\xb7\xec\x94\x2d\x8a\x52\x66\x4e\x2e\xae\x9c\x3b\x5b\x06\x2a\x64\xf2\xca\x2a\xe3\xc3\x43\xa6\x15\x19\x0f\x5c\xcf\x4a\xe5\xc5\x8a\x7f\xd4\xc4\x5e\xec\x30\x86\xdb\x00\x0d\x30\x23\xa8\xab\x1c\x3d\xe5\x63\xb8\x37\x70\x8b\x25\xe9\x5b\x64\xfa\xe6\xaa\x16\x8d\xf2\x48\xd4\xd7\x5f\xd9\x6d\x64\x3b\xdc\x70\x10\x25\x00\x0d\xfc\xbc\x68\x9d\x26\x22\x1f\x2b\xca\x3a\xa1\x90\x13\x2b\x27\xae\xeb\xd1\x93\x38\x7c\x07\x76\xfa\x1c\xed\xd1\xd7\xdc\xef\xf0\xb0\xb4\x73\xbc\x9d\xb1\x18\xba\x75\x3e\x9a\x1d\x7c\x48\xa4\x88\x41\x33\x5b\x56\xd6\x88\x63\xf4\xe5\xea\x65\xe8\x80\x90\x1c\x1a\x7a\x87\xef\xf6\x78\xbf\xdd\x2e\x4d\xf3\x33\xe2\xad\xf7\x8a\x0c\xe8\x23\x39\xa6\x28\xd0\x11\x70\xeb\xc1\xad\x0c\x71\x5b\xb1\xc5\x31\x9e\x04\x9c\x35\xce\x48\x3f\x92\xa6\xec\xd0\x3c\xe7\x24\x96\xd1\xd9\x7f\x7c\xc9\x9e\xf0\xbf\xb6\x77\xc4\xd8\x0e\x44\xe0\x8f\x9a\xdc\x06\xec\x8a\x9c\x84\x3b\x79\x31\xdc\x4e\x29\x35\x53\x2e\x18\xc8\x61\x67\x47\x2d\xd7\x27\x8c\xd9\x53\x4d\x7d\x44\x95\x51\xa2\xcf\x8a\xb7\xcf\x02\x29\xad\x1c\xd7\x43\xea\xfd\x8d\x49\x70\xc5\x41\xcc\xa8\x00\x6e\x94\x92\x8c\x56\x46\xd4\x7a\x2a\xa8\x33\x03\xe8\x08\x6e\x1e\xee\x28\x3f\xe6\x0f\x5d\x81\xd1\x39\xdc\x9c\x58\xa5\x3c\x95\x27\x85\xd8\x13\xe3\xe6\x04\xab\x09\xa7\x9b\x37\xc9\x8b\x8d\x47\x65\x38\xe5\xa0\x21\x20\x2c\x69\x13\xd3\x95\x64\xc1\x26\x28\xc3\x62\x47\x21\xb9\x05\xdb\x2e\x69\x13\x16\xa5\xdc\x75\x92\xc3\x1e\xb6\x8d\xe3\x74\x30\xec\xc6\x48\x8e\x3f\xbb\xc6\x1e\x07\xb5\xee\xe8\xe3\x54\x71\x2c\x69\x73\x6e\xc9\x9e\x31\x44\x47\x8a\x53\x55\x20\x56\x91\x89\xa0\x49\x99\xda\x1a\x02\xab\x4a\x2b\x0a\x89\xeb\x2c\xfd\x17\xb3\xc7\xe1\x68\xc4\xbf\x90\x69\x7b\xb4\x8c\x5b\xd2\xe6\x9a\xa3\x03\x48\x74\x14\xaa\x92\x58\xdf\xc2\x40\x53\xc1\x7c\x42\xad\xf2\x5d\x51\x1a\x22\xe1\xde\x0c\xe1\xc1\x7a\xf9\x79\xfb\xac\x24\x43\x8b\xdf\xdc\x59\xe2\x07\xeb\xc3\xcc\xab\x8a\x1d\x59\xb9\x50\xe8\xb8\x29\x04\x88\x89\x31\x29\x52\xb5\x4b\x1a\x1e\xc3\xfd\xbc\x83\x6a\xb2\xfa\xde\x80\x75\x8d\x74\xa1\xc8\x8c\x84\x22\x89\xb2\xe6\x50\x83\x18\x6b\x46\x54\x56\x7e\x73\x94\x46\x52\x8a\x75\x1d\x9d\x9c\x20\x97\x48\x3d\x49\x69\x14\xdf\xc4\x22\x56\x63\x46\x39\xe4\x75\x60\x3a\x14\x64\xd2\x6e\xa8\x0c\x4a\x72\x0b\x82\x4a\x10\xae\xaf\xaa\xcf\xe1\x52\x1c\x3d\xd0\xa9\x4d\xf4\x8c\xfd\x02\x04\x87\xec\x73\x21\x6c\xc7\x3d\x11\xde\x4a\xac\xc4\x74\x9f\x05\xc5\x82\xf6\xbe\x40\x85\xca\xf1\x18\x6e\x42\x7b\xa4\xa9\xf3\x4e\x99\xa0\xe7\x36\x19\xa1\xa0\x18\x04\x8a\x56\xa8\x05\x37\xc5\xd3\x0d\x90\x8e\x28\x6a\xe7\x07\xc9\x62\x08\xeb\x42\x6a\x01\x89\xef\xb9\x22\x1d\x4a\xe2\xc1\x92\x36\x83\xe1\x81\xb9\x07\xf7\x66\x10\xf1\xf5\xc0\xc0\x5b\x30\xb6\x46\x6f\x60\x10\xde\x0d\xfe\xbb\xfc\x72\x16\x74\x31\xcf\x43\x63\x8d\xfa\x7d\x4f\x24\x3c\x6b\x4b\x47\xf3\x17\x49\x74\x8c\xf7\x81\xe6\x51\x98\x56\x39\x31\x27\x47\x26\x14\x59\xf6\xc5\x1a\x62\x57\x75\x0c\x13\x8a\x52\x0e\x6b\xe5\x8b\x6e\xed\xf2\x92\x76\xce\x7b\xf8\x19\xbf\xee\x0a\xa1\xb2\xe2\x43\xc3\x76\xf4\xc1\xad\x14\x11\x23\x1b\x6e\x87\x40\xc6\xa9\xac\x68\x98\x95\x22\x37\x16\xd2\x62\xf9\x68\x86\x13\x99\xb4\x97\x41\xfb\xa5\xb3\x97\x3b\xe9\x13\x82\xde\xbc\xbf\x6f\x7a\xe8\xd8\x3a\x53\x23\xe8\x19\x00\xef\x09\xde\x3b\x1d\x5c\xc0\xd4\xed\x76\x53\x3b\x5f\xb5\xfa\xf0\x6d\x8b\x11\x5a\xc6\xc6\x83\xfa\x30\x7c\x1e\x02\x7b\xc1\xdf\x71\x76\x77\xdc\xb6\x99\xc5\x15\x2a\x8d\x33\xdd\xb4\x48\x31\xd9\xa6\x06\x69\xcb\xfc\x75\x74\x1b\x3a\x87\xe5\xbd\xcb\xae\xfe\x85\x97\x94\x55\xd1\x65\x7b\x2c\x94\xf3\xcf\x2c\xeb\x5f\x7d\x49\x27\xc3\xfe\xc9\xa1\x61\xd5\x5c\xd9\xf5\xc9\x3c\x7b\xad\x0d\x7b\xf0\xaa\xa4\xe4\x0d\x8d\x31\xfc\x96\x2c\xe5\xf1\xb6\xc1\x1a\x6a\x62\x33\xa0\xbf\xf5\x05\xbd\x08\x28\xed\x71\x41\xa5\x22\x63\x6e\x5d\x89\x7e\x0a\x39\x7a\x1a\x09\x67\xbd\xd4\xf0\x31\x5c\x6a\xbc\xaa\x0a\xd6\xc8\x62\x8d\x19\xe5\xff\x0f\x42\x96\xc4\x8c\x8b\xcb\xa5\xbb\x81\xa2\x2e\x51\xa2\x0b\xf3\x10\x47\x89\x10\x28\x93\xab\x0c\xc3\x75\x54\x4e\x1e\x95\x66\xc0\x99\xad\x63\xf4\xed\xcc\xff\xea\x16\x76\x84\x7c\x0e\x65\x8f\xc8\x11\x53\xbe\x6c\x15\xe5\x75\x4d\x75\xcd\xc1\x07\xbe\x25\xd7\xc7\xaf\x77\xce\x72\x9d\xae\x7a\xb6\x60\x9b\x18\x1e\x86\x68\xb2\x73\x78\x72\x35\x0d\xe1\x17\xd4\x4c\x43\xf8\x68\x96\xc6\xae\x5f\x9f\xf7\xb0\xf8\x62\x7d\x6f\xaa\xc0\xe1\x96\xe7\x57\x64\x2b\x14\x84\xef\xd1\x17\x17\xa4\xb5\xeb\xfb\x54\x0b\x85\x5a\x3e\x54\x11\x95\xa2\x8c\x3a\x97\xd3\xa0\x0c\x7b\xc2\x3c\x4d\x92\xf1\xca\x51\x7a\x37\x8c\x37\xa7\xa9\x83\xd9\x5d\x5e\x4b\x7d\x09\x28\x65\xa7\xca\xe1\xef\x8f\xef\x1e\x26\x7f\xb3\xa9\x64\xc5\x2c\x23\x4e\xa9\x45\xea\xcc\x21\x70\x9d\x15\x80\xdc\x5c\x17\x3e\x86\xa4\x53\xa2\x51\x73\x62\x3f\x4e\xd4\xc8\xf1\x6f\x6f\x7e\x1f\xc3\x2f\xd6\x01\x3d\x63\x59\x69\x1a\x82\x4a\x6d\x4e\x73\xc5\xdb\x2a\x8f\x82\x30\xdb\xbd\xa1\x12\x0a\x2c\x55\x36\x4f\x4c\xaf\x03\xb3\x1e\x97\x04\x36\x31\x5b\x13\x68\xb5\xa4\x29\x0c\xb8\xa2\xac\x75\xf4\x67\x83\x25\x7d\x19\xc0\x8f\xeb\x82\x1c\xc1\x40\x1e\x07\xf1\xc0\x6d\x09\x29\x73\x2d\xa7\x4c\x07\xc7\x3e\xdc\xa9\xc5\x82\x1c\xc5\x62\x9c\x56\x64\xfc\x4f\xd2\x89\xa9\x39\x18\xdb\x5a\x1c\x48\x88\x3e\x2b\xca\xd4\x5c\x51\x7e\xc0\xc8\x6f\x6f\x7e\x1f\xc0\x8f\x5d\xb9\x04\x75\xe8\x19\xde\xc4\x2e\x43\xb1\xc8\xf8\x53\x6a\xdc\x78\x63\x3c\x3e\x0b\xcd\x4c\x5a\x07\x13\x6b\x7e\x6f\xa1\xc0\x15\x01\xdb\x92\x60\x4d\x5a\x8f\xe2\xbd\x69\x0e\xeb\xd8\x92\x36\xaa\x8c\x2d\x5e\x85\xce\xef\x7d\xaf\x78\x7a\x77\xf7\x6e\x1a\x4f\x13\xb3\x2d\x8c\x1c\x61\xac\x87\xb9\x32\xa8\x53\xdf\xa1\x78\xd7\xa6\x70\x1d\x8d\xe4\x2d\x64\x05\x9a\x80\x95\x41\x1b\xf3\xda\xd7\x8e\xc6\xfb\xf7\xd7\x5f\x15\x03\xc7\x3e\x24\x9c\x72\xff\xf0\x59\x61\xbf\xc8\xfc\x1f\x5e\xda\x7f\x95\xd0\xe1\xbb\xda\x05\x42\x3f\xb4\xfc\xf4\xa4\xd0\xcb\x7a\x46\xce\x90\xa7\x20\x77\x6e\x33\x16\x91\x33\xaa\x3c\x4f\xec\x8a\xdc\x4a\xd1\x7a\xb2\xb6\x6e\xa9\xcc\x62\x24\x8e\x38\x8a\xde\xc1\x93\xf0\x2d\x72\xf2\x43\xf8\x79\x35\x19\xb9\xc2\xec\x62\x41\xc3\xa6\xef\x21\xad\x9c\xc3\x93\x57\x11\xb6\x69\xe4\x2e\xef\x9d\xae\x1f\x23\x70\x64\xfb\x34\x24\xec\xd6\x85\xca\x8a\xe6\x53\x64\x0b\x29\x4b\xcc\x23\x94\xa2\xd9\x7c\x73\xe7\x17\x95\xd6\x4e\xce\xde\x8c\xd2\x67\xf4\x11\x9a\x5c\xfe\xb3\x62\x2f\xf3\xaf\xa2\xc3\x5a\x5d\x04\x04\x1f\xef\xef\xbe\x4f\x48\xd4\xea\x2b\xa2\x3e\x7e\xc6\x9a\x82\x77\x75\x53\xd3\xb2\xb7\x4e\x2a\xd7\xce\x5c\x3d\xdb\xde\x58\xec\x84\x4f\x45\x16\x7c\xfe\x72\xf5\x9f\x00\x00\x00\xff\xff\xb3\x0d\x9b\xb8\x18\x21\x00\x00") +var _operatorsCoreosCom_operatorsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x59\xcd\x72\xe3\x36\x12\xbe\xfb\x29\xba\x94\x83\x93\x2a\xfd\x24\xb3\x97\x94\x6e\x2e\x7b\xb2\xe5\xdd\xac\x67\x6a\xec\x99\x4b\x2a\x87\x16\xd9\x12\xb1\x02\x01\x06\x0d\x4a\xd6\x4e\xcd\xbb\x6f\x35\x00\x4a\xa4\x24\x4b\xd4\xac\x27\x1b\x5c\x24\x82\x40\xa3\x7f\xbf\xee\x06\xb1\x52\x9f\xc8\xb1\xb2\x66\x0a\x58\x29\x7a\xf6\x64\xe4\x89\xc7\xcb\x9f\x79\xac\xec\x64\xf5\xd3\xd5\x52\x99\x7c\x0a\xb7\x35\x7b\x5b\x7e\x20\xb6\xb5\xcb\xe8\x8e\xe6\xca\x28\xaf\xac\xb9\x2a\xc9\x63\x8e\x1e\xa7\x57\x00\x68\x8c\xf5\x28\xd3\x2c\x8f\x00\x99\x35\xde\x59\xad\xc9\x8d\x16\x64\xc6\xcb\x7a\x46\xb3\x5a\xe9\x9c\x5c\x20\xde\x1c\xbd\xfa\x71\xfc\xf3\xf8\xc7\x2b\x80\xcc\x51\xd8\xfe\xa4\x4a\x62\x8f\x65\x35\x05\x53\x6b\x7d\x05\x60\xb0\xa4\x29\xd8\x8a\x1c\x7a\xeb\x78\xbc\xfb\x97\x59\x47\x56\x7e\xca\x2b\xae\x28\x93\x83\x17\xce\xd6\x55\x7b\x75\x6b\x4d\x24\xd5\xf0\x87\x9e\x16\xd6\xa9\xe6\x19\x60\x04\x56\x97\xe1\x7f\x94\xfb\x5d\xa2\x11\xa6\xb4\x62\xff\xcf\xce\xf4\xaf\x8a\x7d\x78\x55\xe9\xda\xa1\x6e\x9d\x19\x66\x59\x99\x45\xad\xd1\xed\xe6\xaf\x00\x38\xb3\x15\x4d\xe1\x56\xd7\xec\x49\x26\x92\x1e\x12\x0f\xa3\x24\xeb\xea\xa7\xc4\x12\x67\x05\x95\xd8\x30\x08\x42\xca\xdc\xbc\xbf\xff\xf4\xb7\xc7\xbd\x17\x00\x39\x71\xe6\x54\xe5\x83\x56\x1b\x1e\xc1\x51\xe5\x88\xc9\x78\x06\x84\x2c\x1e\xbb\x65\x68\xdc\xda\xee\x37\xc2\x98\x9d\xfd\x9b\x32\xdf\x9a\xae\x9c\x2c\xf6\x2d\x2d\xc5\xd1\xf2\x9e\xce\xfc\x1e\x1f\xd7\xc2\x6c\x5c\x07\xb9\x38\x0e\x31\xf8\x82\x1a\xb1\x29\x4f\x12\x82\x9d\x83\x2f\x14\xef\xf8\x0d\xbe\x20\xd3\x68\x12\x57\x63\x78\x24\x27\x1b\x81\x0b\x5b\xeb\x5c\x3c\x6c\x45\xce\x83\xa3\xcc\x2e\x8c\xfa\xcf\x96\x1a\x83\xb7\xe1\x18\x8d\x9e\xd8\x83\x32\x9e\x9c\x41\x0d\x2b\xd4\x35\x0d\x01\x4d\x0e\x25\x6e\xc0\x91\xd0\x85\xda\xb4\x28\x84\x25\x3c\x86\x7f\x59\x47\xa0\xcc\xdc\x4e\xa1\xf0\xbe\xe2\xe9\x64\xb2\x50\xbe\x89\x8d\xcc\x96\x65\x6d\x94\xdf\x4c\x82\x9b\xab\x59\x2d\x76\x9f\xe4\xb4\x22\x3d\x61\xb5\x18\xa1\xcb\x0a\xe5\x29\xf3\xb5\xa3\x09\x56\x6a\x14\x98\x35\x21\x3e\xc6\x65\xfe\x9d\x4b\xd1\xc4\xd7\x7b\xea\x8b\x76\x60\xef\x94\x59\x74\x5e\x05\x9f\x3c\xa9\x6b\x71\x4f\x50\x62\xe8\xb8\x3d\xca\xb2\x53\xa9\x4c\x89\x56\x3e\xbc\x7d\x7c\x82\x86\x81\xa8\xf6\xa8\xe1\x96\xb7\xec\x94\x2d\x8a\x52\x66\x4e\x2e\xae\x9c\x3b\x5b\x06\x2a\x64\xf2\xca\x2a\xe3\xc3\x43\xa6\x15\x19\x0f\x5c\xcf\x4a\xe5\xc5\x8a\x7f\xd4\xc4\x5e\xec\x30\x86\xdb\x00\x0d\x30\x23\xa8\xab\x1c\x3d\xe5\x63\xb8\x37\x70\x8b\x25\xe9\x5b\x64\xfa\xe6\xaa\x16\x8d\xf2\x48\xd4\xd7\x5f\xd9\x6d\x64\x3b\xdc\x70\x10\x25\x00\x0d\xfc\xbc\x68\x9d\x26\x22\x1f\x2b\xca\x3a\xa1\x90\x13\x2b\x27\xae\xeb\xd1\x93\x38\x7c\x07\x76\xfa\x1c\xed\xd1\xd7\xdc\xef\xf0\xb0\xb4\x73\xbc\x9d\xb1\x18\xba\x75\x3e\x9a\x1d\x7c\x48\xa4\x88\x41\x33\x5b\x56\xd6\x88\x63\xf4\xe5\xea\x65\xe8\x80\x90\x1c\x1a\x7a\x87\xef\xf6\x78\xbf\xdd\x2e\x4d\xf3\x33\xe2\xad\xf7\x8a\x0c\xe8\x23\x39\xa6\x28\xd0\x11\x70\xeb\xc1\xad\x0c\x71\x5b\xb1\xc5\x31\x9e\x04\x9c\x35\xce\x48\x3f\x92\xa6\xec\xd0\x3c\xe7\x24\x96\xd1\xd9\x7f\x7c\xc9\x9e\xf0\xbf\xb6\x77\xc4\xd8\x0e\x44\xe0\x8f\x9a\xdc\x06\xec\x8a\x9c\x84\x3b\x79\x31\xdc\x4e\x29\x35\x53\x2e\x18\xc8\x61\x67\x47\x2d\xd7\x27\x8c\xd9\x53\x4d\x7d\x44\x95\x51\xa2\xcf\x8a\xb7\xcf\x02\x29\xad\x1c\xd7\x43\xea\xfd\x8d\x49\x70\xc5\x41\xcc\xa8\x00\x6e\x94\x92\x8c\x56\x46\xd4\x7a\x2a\xa8\x33\x03\xe8\x08\x6e\x1e\xee\x28\x3f\xe6\x0f\x5d\x81\xd1\x39\xdc\x9c\x58\xa5\x3c\x95\x27\x85\xd8\x13\xe3\xe6\x04\xab\x09\xa7\x9b\x37\xc9\x8b\x8d\x47\x65\x38\xe5\xa0\x21\x20\x2c\x69\x13\xd3\x95\x64\xc1\x26\x28\xc3\x62\x47\x21\xb9\x05\xdb\x2e\x69\x13\x16\xa5\xdc\x75\x92\xc3\x1e\xb6\x8d\xe3\x74\x30\xec\xc6\x48\x8e\x3f\xbb\xc6\x1e\x07\xb5\xee\xe8\xe3\x54\x71\x2c\x69\x73\x6e\xc9\x9e\x31\x44\x47\x8a\x53\x55\x20\x56\x91\x89\xa0\x49\x99\xda\x1a\x02\xab\x4a\x2b\x0a\x89\xeb\x2c\xfd\x17\xb3\xc7\xe1\x68\xc4\xbf\x90\x69\x7b\xb4\x8c\x5b\xd2\xe6\x9a\xa3\x03\x48\x74\x14\xaa\x92\x58\xdf\xc2\x40\x53\xc1\x7c\x42\xad\xf2\x5d\x51\x1a\x22\xe1\xde\x0c\xe1\xc1\x7a\xf9\x79\xfb\xac\x24\x43\x8b\xdf\xdc\x59\xe2\x07\xeb\xc3\xcc\xab\x8a\x1d\x59\xb9\x50\xe8\xb8\x29\x04\x88\x89\x31\x29\x52\xb5\x4b\x1a\x1e\xc3\xfd\xbc\x83\x6a\xb2\xfa\xde\x80\x75\x8d\x74\xa1\xc8\x8c\x84\x22\x89\xb2\xe6\x50\x83\x18\x6b\x46\x54\x56\x7e\x73\x94\x46\x52\x8a\x75\x1d\x9d\x9c\x20\x97\x48\x3d\x49\x69\x14\xdf\xc4\x22\x56\x63\x46\x39\xe4\x75\x60\x3a\x14\x64\xd2\x6e\xa8\x0c\x4a\x72\x0b\x82\x4a\x10\xae\xaf\xaa\xcf\xe1\x52\x1c\x3d\xd0\xa9\x4d\xf4\x8c\xfd\x02\x04\x87\xec\x73\x21\x6c\xc7\x3d\x11\xde\x4a\xac\xc4\x74\x9f\x05\xc5\x82\xf6\xbe\x40\x85\xca\xf1\x18\x6e\x42\x7b\xa4\xa9\xf3\x4e\x99\xa0\xe7\x36\x19\xa1\xa0\x18\x04\x8a\x56\xa8\x05\x37\xc5\xd3\x0d\x90\x8e\x28\x6a\xe7\x07\xc9\x62\x08\xeb\x42\x6a\x01\x89\xef\xb9\x22\x1d\x4a\xe2\xc1\x92\x36\x83\xe1\x81\xb9\x07\xf7\x66\x10\xf1\xf5\xc0\xc0\x5b\x30\xb6\x46\x6f\x60\x10\xde\x0d\xfe\xb7\xfc\x72\x16\x74\x31\xcf\x43\x63\x8d\xfa\x7d\x4f\x24\x3c\x6b\x4b\x47\xf3\x17\x49\x74\x8c\xf7\x81\xe6\x51\x98\x56\x39\x31\x27\x47\x26\x14\x59\xf6\xc5\x1a\x62\x57\x75\x0c\x13\x8a\x52\x0e\x6b\xe5\x8b\x6e\xed\xf2\x92\x76\xce\x7b\xf8\x19\xbf\xee\x0a\xa1\xb2\xe2\x43\xc3\x76\xf4\xc1\xad\x14\x11\x23\x1b\x6e\x87\x40\xc6\xa9\xac\x68\x98\x95\x22\x37\x16\xd2\x62\xf9\x68\x86\x13\x99\xb4\x97\x41\xfb\xa5\xb3\x97\x3b\xe9\x13\x82\xde\xbc\xbf\x6f\x7a\xe8\xd8\x3a\x53\x23\xe8\x19\x00\xef\x09\xde\x3b\x1d\x5c\xc0\xd4\xed\x76\x53\x3b\x5f\xb5\xfa\xf0\x6d\x8b\x11\x5a\xc6\xc6\x83\xfa\x30\x7c\x1e\x02\x7b\xc1\xdf\x71\x76\x77\xdc\xb6\x99\xc5\x15\x2a\x8d\x33\xdd\xb4\x48\x31\xd9\xa6\x06\x69\xcb\xfc\x75\x74\x1b\x3a\x87\xe5\xbd\xcb\xae\xfe\x85\x97\x94\x55\xd1\x65\x7b\x2c\x94\xf3\xcf\x2c\xeb\x5f\x7d\x49\x27\xc3\xfe\xc9\xa1\x61\xd5\x5c\xd9\xf5\xc9\x3c\x7b\xad\x0d\x7b\xf0\xaa\xa4\xe4\x0d\x8d\x31\xfc\x96\x2c\xe5\xf1\xb6\xc1\x1a\x6a\x62\x33\xa0\xbf\xf5\x05\xbd\x08\x28\xed\x71\x41\xa5\x22\x63\x6e\x5d\x89\x7e\x0a\x39\x7a\x1a\x09\x67\xbd\xd4\xf0\x31\x5c\x6a\xbc\xaa\x0a\xd6\xc8\x62\x8d\x19\xe5\x7f\x05\x21\x4b\x62\xc6\xc5\xe5\xd2\xdd\x40\x51\x97\x28\xd1\x85\x79\x88\xa3\x44\x08\x94\xc9\x55\x86\xe1\x3a\x2a\x27\x8f\x4a\x33\xe0\xcc\xd6\x31\xfa\x76\xe6\x7f\x75\x0b\x3b\x42\x3e\x87\xb2\x47\xe4\x88\x29\x5f\xb6\x8a\xf2\xba\xa6\xba\xe6\xe0\x03\xdf\x92\xeb\xe3\xd7\x3b\x67\xb9\x4e\x57\x3d\x5b\xb0\x4d\x0c\x0f\x43\x34\xd9\x39\x3c\xb9\x9a\x86\xf0\x0b\x6a\xa6\x21\x7c\x34\x4b\x63\xd7\xaf\xcf\x7b\x58\x7c\xb1\xbe\x37\x55\xe0\x70\xcb\xf3\x2b\xb2\x15\x0a\xc2\xf7\xe8\x8b\x0b\xd2\xda\xf5\x7d\xaa\x85\x42\x2d\x1f\xaa\x88\x4a\x51\x46\x9d\xcb\x69\x50\x86\x3d\x61\x9e\x26\xc9\x78\xe5\x28\xbd\x1b\xc6\x9b\xd3\xd4\xc1\xec\x2e\xaf\xa5\xbe\x04\x94\xb2\x53\xe5\xf0\x8f\xc7\x77\x0f\x93\xbf\xdb\x54\xb2\x62\x96\x11\xa7\xd4\x22\x75\xe6\x10\xb8\xce\x0a\x40\x6e\xae\x0b\x1f\x43\xd2\x29\xd1\xa8\x39\xb1\x1f\x27\x6a\xe4\xf8\xb7\x37\xbf\x8f\xe1\x17\xeb\x80\x9e\xb1\xac\x34\x0d\x41\xa5\x36\xa7\xb9\xe2\x6d\x95\x47\x41\x98\xed\xde\x50\x09\x05\x96\x2a\x9b\x27\xa6\xd7\x81\x59\x8f\x4b\x02\x9b\x98\xad\x09\xb4\x5a\xd2\x14\x06\x5c\x51\xd6\x3a\xfa\xb3\xc1\x92\xbe\x0c\xe0\xfb\x75\x41\x8e\x60\x20\x8f\x83\x78\xe0\xb6\x84\x94\xb9\x96\x53\xa6\x83\x63\x1f\xee\xd4\x62\x41\x8e\x62\x31\x4e\x2b\x32\xfe\x07\xe9\xc4\xd4\x1c\x8c\x6d\x2d\x0e\x24\x44\x9f\x15\x65\x6a\xae\x28\x3f\x60\xe4\xb7\x37\xbf\x0f\xe0\xfb\xae\x5c\x82\x3a\xf4\x0c\x6f\x62\x97\xa1\x58\x64\xfc\x21\x35\x6e\xbc\x31\x1e\x9f\x85\x66\x26\xad\x83\x89\x35\xbf\xb7\x50\xe0\x8a\x80\x6d\x49\xb0\x26\xad\x47\xf1\xde\x34\x87\x75\x6c\x49\x1b\x55\xc6\x16\xaf\x42\xe7\xf7\xbe\x57\x3c\xbd\xbb\x7b\x37\x8d\xa7\x89\xd9\x16\x46\x8e\x30\xd6\xc3\x5c\x19\xd4\xa9\xef\x50\xbc\x6b\x53\xb8\x8e\x46\xf2\x16\xb2\x02\x4d\xc0\xca\xa0\x8d\x79\xed\x6b\x47\xe3\xfd\xfb\xeb\xaf\x8a\x81\x63\x1f\x12\x4e\xb9\x7f\xf8\xac\xb0\x5f\x64\xfe\x1f\x2f\xed\xbf\x4a\xe8\xf0\x5d\xed\x02\xa1\x1f\x5a\x7e\x7a\x52\xe8\x65\x3d\x23\x67\xc8\x53\x90\x3b\xb7\x19\x8b\xc8\x19\x55\x9e\x27\x76\x45\x6e\xa5\x68\x3d\x59\x5b\xb7\x54\x66\x31\x12\x47\x1c\x45\xef\xe0\x49\xf8\x16\x39\xf9\x2e\xfc\xbc\x9a\x8c\x5c\x61\x76\xb1\xa0\x61\xd3\x9f\x21\xad\x9c\xc3\x93\x57\x11\xb6\x69\xe4\x2e\xef\x9d\xae\x1f\x23\x70\x64\xfb\x34\x24\xec\xd6\x85\xca\x8a\xe6\x53\x64\x0b\x29\x4b\xcc\x23\x94\xa2\xd9\x7c\x73\xe7\x17\x95\xd6\x4e\xce\xde\x8c\xd2\x67\xf4\x11\x9a\x5c\xfe\xb3\x62\x2f\xf3\xaf\xa2\xc3\x5a\x5d\x04\x04\x1f\xef\xef\xfe\x9c\x90\xa8\xd5\x57\x44\x7d\xfc\x8c\x35\x05\xef\xea\xa6\xa6\x65\x6f\x9d\x54\xae\x9d\xb9\x7a\xb6\xbd\xb1\xd8\x09\x9f\x8a\x2c\xf8\xfc\xe5\xea\xbf\x01\x00\x00\xff\xff\x7e\x2b\xf8\xdd\x18\x21\x00\x00") func operatorsCoreosCom_operatorsYamlBytes() ([]byte, error) { return bindataRead( @@ -225,7 +225,7 @@ func operatorsCoreosCom_operatorsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_subscriptionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x7d\x6b\x73\xe3\xb8\x95\xe8\xf7\xf9\x15\x28\x27\x55\xb6\xb3\x92\xdc\x9d\x9d\x4d\x72\xbd\xa9\xa4\xdc\xb6\x7b\xa2\x9d\x6e\xb7\xb7\xe5\xee\xa9\xdc\x24\x37\x81\x48\x48\xc2\x98\x04\x38\x00\x28\xb7\xf2\xf8\xef\xb7\x70\x0e\x00\x82\xd4\x8b\x94\xe5\xc7\x4c\xcc\x0f\x33\x6d\x0a\x00\x81\x83\x83\xf3\xc2\x79\xd0\x82\x7f\x66\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x62\x98\xb0\x7f\xe9\xc1\xed\x6f\xf4\x80\xcb\x93\xf9\xeb\xaf\x6e\xb9\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x32\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x57\x39\x33\x34\xa5\x86\x9e\x7e\x45\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\xaa\x3f\x65\x62\x70\x5b\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xf8\xd5\xe0\x97\x5f\x11\x92\x28\x06\xdd\x6f\x78\xce\xb4\xa1\x79\x71\x4a\x44\x99\x65\x5f\x11\x22\x68\xce\x4e\x89\x2e\xc7\x3a\x51\xbc\x80\x4f\x0c\x64\xc1\x14\x35\x52\xe9\x41\x22\x15\x93\xf6\x7f\xf9\x57\xba\x60\x89\xfd\xf8\x54\xc9\xb2\x38\x25\x2b\xdb\xe0\x70\x7e\x8e\xd4\xb0\xa9\x54\xdc\xff\x4d\x48\x9f\xc8\x2c\x87\x7f\xe3\xda\x47\xd1\x57\xe1\x75\xc6\xb5\xf9\x76\xe9\xa7\x77\x5c\x1b\xf8\xb9\xc8\x4a\x45\xb3\xc6\x6c\xe1\x17\x3d\x93\xca\x5c\x55\xdf\xb6\xdf\xd2\xe5\x38\xfe\xb7\x6b\xc8\xc5\xb4\xcc\xa8\xaa\x0f\xf2\x15\x21\x3a\x91\x05\x3b\x25\x30\x46\x41\x13\x96\x7e\x45\x88\x83\xa3\x1b\xb3\x4f\x68\x9a\xc2\xde\xd0\xec\x5a\x71\x61\x98\x3a\x97\x59\x99\x8b\xf0\x4d\xdb\x26\x65\x61\xd4\x53\x72\x33\x63\xa4\xa0\xc9\x2d\x9d\x32\xff\xbd\x31\x4b\x89\x91\xa1\x03\x21\xdf\x6b\x29\xae\xa9\x99\x9d\x92\x81\x05\xf1\xc0\x42\x30\xfa\x19\xf7\xe7\x1a\x07\x89\xde\x9b\x85\x9d\xae\x36\x8a\x8b\xe9\xa6\xcf\x27\xd4\xd0\x4c\x4e\x09\xe2\x17\x99\x48\x45\xcc\x8c\x11\xfb\x29\x3e\xe1\x2c\xf5\xf3\xdb\x30\x23\xec\xba\x34\xa7\x51\xf3\x75\xeb\x29\xcd\xa8\x10\x2c\x23\x72\x42\xca\x22\xa5\x86\x69\x62\x64\x05\x9f\xcd\xe0\x71\x9d\x97\x66\x73\xbe\xf4\x7e\xc5\x74\xb0\xe9\xfc\x35\xcd\x8a\x19\x7d\xed\x5e\xea\x64\xc6\x72\x5a\xed\xa1\x2c\x98\x38\xbb\x1e\x7e\xfe\xcf\x51\xe3\x07\x52\x5f\x4a\x8c\xa2\xe4\x96\xb1\x42\x57\x87\x82\x94\x85\x5d\x93\x5d\x1c\x19\x2f\x88\x51\x34\xb9\xe5\x62\x0a\x4b\x9f\xe2\x7a\xcf\x71\x63\xf4\x60\x69\xca\x72\xfc\x3d\x4b\x4c\xf4\x5a\xb1\x1f\x4a\xae\x58\x1a\x4f\xc5\x42\xd6\x93\x88\xc6\x6b\x0b\xa7\xe8\x55\xa1\xec\xb4\x4c\x74\x0e\xf1\x89\x68\x54\xed\x7d\x63\x99\x87\x16\x16\xd8\x8e\xa4\x96\x3c\xd9\xe9\xcf\x98\x3f\x1c\x2c\x75\x00\xb4\xdb\x69\x66\x5c\x13\xc5\x0a\xc5\x34\x13\x48\xb0\xec\x6b\x2a\xdc\x9a\x06\x64\xc4\x94\xed\x68\x0f\x6c\x99\xa5\x96\x8e\xcd\x99\x32\x44\xb1\x44\x4e\x05\xff\x7b\x18\x0d\x40\x64\x3f\x93\x59\xfc\x30\x04\x8e\x9b\xa0\x19\x99\xd3\xac\x64\x3d\x42\x45\x4a\x72\xba\x20\x8a\xd9\x71\x49\x29\xa2\x11\xa0\x89\x1e\x90\xf7\x52\x31\xc2\xc5\x44\x9e\x92\x99\x31\x85\x3e\x3d\x39\x99\x72\xe3\x29\x70\x22\xf3\xbc\x14\xdc\x2c\x4e\x80\x98\xf2\x71\x69\x37\xee\x24\x65\x73\x96\x9d\x68\x3e\xed\x53\x95\xcc\xb8\x61\x89\x29\x15\x3b\xa1\x05\xef\xc3\x64\x05\x92\xc8\x3c\xfd\x99\x72\x34\x5b\x1f\x36\xc0\xb7\xf2\x1c\x10\x4f\xf5\x36\xc2\xda\x12\x3f\xc2\x35\xa1\xae\x3b\xae\xa5\x02\xa9\x7d\x65\xa1\xf2\xf1\x72\x74\x43\xfc\x04\x10\xec\x08\xe1\xaa\xa9\xae\x80\x6d\x01\xc5\xc5\x84\x29\x6c\x39\x51\x32\x87\x51\x98\x48\x0b\xc9\x85\x81\x3f\x92\x8c\x33\x61\xec\x31\xcc\xb9\xd1\x80\x73\x4c\x1b\xbb\x0f\x03\x72\x0e\x0c\x88\x8c\x99\x3b\xb0\xe9\x80\x0c\x05\x39\xa7\x39\xcb\xce\xa9\x66\x0f\x0e\x6a\x0b\x51\xdd\xb7\xe0\x6b\x0f\xec\x98\x7f\x2e\x77\x58\x3a\x63\x84\x78\x06\xb7\x76\x77\xe2\x03\x3f\x2a\x58\x12\x8e\x03\x15\xe4\xac\x28\x32\x9e\x20\xc6\x9b\x19\x35\x24\xa1\xc2\xc2\x8b\x0b\x6d\x68\x96\x01\x3b\x69\x35\x8b\x75\xa7\x9d\xc0\xd1\x6e\x30\x07\xff\x7a\x89\x42\xd7\x7f\x08\x4c\xad\xd1\x62\x1d\x65\xb0\x8f\xa3\xb3\xcb\x3f\x6c\x00\x39\x41\xc9\x64\xc2\xa7\xab\xba\xad\x85\xe5\x39\x74\x01\x99\x86\x72\xa1\xdd\x10\xa5\x42\x68\x56\x9c\xca\xf2\x2e\x5a\xe3\xdb\x83\xb5\xb3\x5b\x09\xd9\x6d\x6b\xb6\x0f\x13\xf3\xd5\x3f\x34\x16\x70\x29\xe6\x78\x50\xad\xcc\x62\x89\x1c\x13\x73\xae\xa4\xc8\xed\x21\x9a\x53\xc5\xe9\x38\x73\x8c\x8d\x59\xf2\x85\x67\x0c\x97\xc8\xd4\xaa\x23\xb5\xe6\xab\xb8\x1e\xaa\x14\x5d\xac\x69\xc1\x0d\xcb\xd7\xac\x66\xd5\xb4\x3f\x53\x15\x51\x09\x8b\xbc\xab\xa6\x4e\x5c\x03\x3b\x75\x4a\xce\xc3\xc4\xd7\x7e\x66\x0b\xdc\xf1\x59\x8f\xdb\xd5\xb3\x06\xcb\xfd\xb3\x6d\x03\xf1\x01\x4e\xbf\xe1\xf7\x06\x58\xec\x09\x41\x06\xc6\x56\x42\x63\x40\xde\x97\x1a\x76\x8b\x92\xf3\xbf\x0e\x2f\x2e\xaf\x6e\x86\x6f\x87\x97\x1f\xd7\x83\x83\x6c\x3b\x28\xd5\x03\x34\xbe\xc3\x64\x0f\x3f\xfb\x3d\x52\x6c\xc2\x14\x13\x09\xd3\xe4\xe7\x47\x9f\xcf\x3e\xfe\xf5\xea\xec\xfd\xe5\x31\xa1\x8a\x11\xf6\xa5\xa0\x22\x65\x29\x29\xb5\x67\x1a\x85\x62\x73\x2e\x4b\x9d\x2d\x1c\xe5\x4a\xd7\x20\x6d\x13\x5b\x81\xdb\x52\xb1\x20\x9a\xa9\x39\x4f\x56\x83\x48\x0f\xc8\x70\x42\x68\x85\x40\x49\xc0\x70\xcb\xa8\xb2\x39\x4b\x7b\x30\x6c\x98\xb4\xff\x0e\x17\x45\x69\x3c\xc3\xbb\xe3\x59\x06\xa7\x42\xa0\xac\x94\x0e\xc8\x85\x2c\xed\x78\x3f\xff\x39\x2c\x4c\xb1\xb4\x4c\x40\x88\xb6\xc4\x80\x8b\xa9\xfd\xa9\x47\xee\x66\x3c\x99\x11\x9a\x65\xf2\x4e\x03\xa5\x60\x3a\xa1\x85\x5f\x7a\x0c\x1d\xbd\x10\x86\x7e\x39\x25\x7c\xc0\x06\xe4\xe0\xe7\xd1\x4f\x07\xf8\xf5\x42\x49\xfb\x09\x94\x93\x71\x56\x19\x37\x4c\xd1\x8c\x1c\xc4\xad\x07\xe4\xd2\x7e\x83\xa5\xf1\x3e\xc0\x08\x82\xcd\x99\xb2\xab\xf0\xbb\xd0\x23\x8a\x4d\xa9\x4a\x33\xa6\xb5\xc5\xb3\xbb\x19\x33\x33\x86\xa2\x78\x00\x18\xfb\xc2\x2d\xc3\x95\x8a\x08\x69\x06\xe4\x82\x4d\x68\x99\x01\x07\x26\x07\x07\x83\x26\xe3\xdb\x1d\xd5\xde\x2a\x99\x77\x40\xb7\x51\x5d\x73\x58\xb5\xf7\x87\x1a\x47\xae\x91\x35\xcd\x52\xc2\x27\x4e\x82\xe1\xda\x2e\x8a\xb0\xbc\x30\x8b\x36\x87\x66\x0b\x1d\x21\xad\x09\x01\x09\x3c\xe9\x3d\x2d\xbe\x65\x8b\x8f\x6c\xb2\xad\x79\x73\xfd\x2c\x63\x89\x25\x94\xe4\x96\x2d\x40\x9c\x25\xe7\x7e\xc0\xcd\x4b\xe9\xb4\x1c\xd2\x92\x3c\xfa\xa7\x6f\xa7\xb3\xb5\x5d\x7b\x20\xd9\xe7\x96\x2d\xda\x34\x23\xcb\x3a\x9d\x05\x0d\xf0\x3a\x0b\xab\xed\x50\x21\xed\x51\xd6\x3f\xdb\x29\xfa\xca\xc9\x1d\xc6\xa4\xdd\x9d\x53\xb3\x52\x60\xbd\x2d\xc7\x4c\x09\x66\x18\xc8\xac\xa9\x4c\xb4\x15\x57\x13\x56\x18\x7d\x22\xe7\x96\xf2\xb1\xbb\x93\x3b\xa9\xac\x22\xd7\xbf\xe3\x66\xd6\xc7\x5d\xd5\x27\x60\xf4\x38\xf9\x19\xfc\x8f\xdc\x7c\xb8\xf8\x70\x4a\xce\xd2\x94\x48\x38\xe2\xa5\x66\x93\x32\x23\x13\xce\xb2\x54\x0f\x22\xad\xab\x07\xfa\x40\x8f\x94\x3c\xfd\xfd\xe6\xc3\xbd\x23\xc4\x64\x81\xc6\x8a\x1d\xa0\x36\x02\xa1\x6b\x51\xa3\x53\x01\xe9\x2d\x85\xb2\x2a\x82\xdd\xf3\xdc\xb1\x45\xc7\x50\x3a\x2c\x63\x2c\x65\xc6\xa8\xd8\xd2\x03\xc0\xd6\xfd\xcc\x1e\x56\x87\x16\x46\xf0\x08\x50\xc8\xf4\x94\xe8\xb2\x28\xa4\x32\x3a\xa8\x08\x60\x73\xe9\xd5\xff\x04\x79\xb9\x47\xfe\x16\x5e\x66\x74\xcc\x32\xfd\xa7\xc3\xc3\xdf\x7e\x7b\xf9\xc7\xdf\x1d\x1e\xfe\xe5\x6f\xf1\xaf\x91\x85\xae\xde\x04\x6d\x3a\x32\x05\x21\xdc\xfd\xe9\xd8\xe8\x59\x92\xc8\x52\x18\xf7\x83\xa1\xa6\xd4\x83\x99\xd4\x66\x78\x1d\xfe\x2c\x64\xda\xfc\x4b\x6f\xe1\x04\xe4\x61\x89\x0e\x80\xf3\x9a\x9a\xd9\x9e\x49\xcf\x7a\x6b\xc4\xea\xa7\xb6\xdd\xde\x3e\xe1\x76\xd9\x19\x24\xec\x3f\xdf\xfa\xe9\x5a\x0e\x74\xa7\xb8\x31\x4c\x80\xdc\xc1\x54\x6e\x39\x71\xcf\x62\x6e\xc5\x66\xe7\xaf\x0f\x1e\x84\x78\x05\xa8\xed\xb0\x38\x98\xbd\x5b\x19\x22\x73\x20\xb4\x5e\x82\xaa\x74\xa4\xb3\xeb\xa1\xb7\xcc\xec\x7d\x21\xde\xde\xf0\xf6\xde\x67\x32\x58\x2e\xdc\xb2\x82\xa4\x79\x4a\xa4\xc8\x16\xe1\x77\x4d\x32\x0e\xd6\x08\x2b\x80\x06\x8b\xc4\x11\xbe\x1c\x24\x45\xd9\x73\x0d\x06\x39\xcb\xa5\x5a\x84\x3f\x59\x31\x63\xb9\x95\xd8\xfa\xda\x48\x45\xa7\xac\x17\xba\x63\xb7\xf0\x17\x76\xac\x7d\x60\xb9\x37\x8a\xd4\x49\xa9\x2c\xf3\xc8\x16\x9e\x82\xb0\xf4\x69\xcf\xa2\x07\xd3\x9e\x8f\x62\xd8\x8d\xab\x1d\x59\x6e\xd0\x16\x9d\xc1\xd5\xaf\x0a\x64\xc8\xb9\xcc\xca\x9c\xe9\x5e\x60\x4f\x28\xad\x8b\xb9\x95\x26\x97\xcc\x3b\xab\x9f\x8e\xa7\x2f\xe5\x73\xae\xa5\xda\x99\x0f\x72\x67\xf2\x94\xa5\xb1\x9a\xca\x44\xaa\x9c\x9a\xa0\x2e\x7e\x29\xa4\x06\x1d\xc0\xe1\x6c\x83\xa4\xbc\x3e\x68\xf5\xd9\x82\x1a\xc3\x94\x38\x25\xff\xef\xe8\xcf\xff\xf1\xcf\xfe\xf1\xef\x8f\x8e\xfe\xf4\xaa\xff\x7f\xfe\xf2\x1f\x47\x7f\x1e\xc0\x3f\x7e\x71\xfc\xfb\xe3\x7f\xfa\x3f\xfe\xe3\xf8\xf8\xe8\xe8\x4f\xdf\xbe\xff\xe6\xe6\xfa\xf2\x2f\xfc\xf8\x9f\x7f\x12\x65\x7e\x8b\x7f\xfd\xf3\xe8\x4f\xec\xf2\x2f\x2d\x07\x39\x3e\xfe\xfd\xcf\x5b\x4d\x8f\x8a\xc5\x87\x16\x07\x1e\x9f\xbe\xdb\x20\x2e\x0c\x9b\x32\xd5\xb1\x57\xeb\x6d\x25\xe4\x4b\xbf\x12\xda\xfa\x5c\x98\xbe\x54\x7d\xec\x7e\x4a\x8c\x2a\xb7\x1f\x8c\x8a\xa8\xed\x82\xe7\x1f\xfd\x69\x8d\x4c\xb1\x9e\x34\xef\x1d\x91\x35\x4b\x14\x33\xfb\xd2\x60\x70\x34\xcf\x3f\x0a\x99\x1e\x6a\x22\xd6\x98\x09\xd7\x4d\xfb\xdf\x42\xa9\xf1\x22\x05\xc2\xab\xe2\xbc\x13\x25\xf3\x01\x89\xcc\x42\x73\x9a\xf1\xd4\xb7\xbb\x65\x5b\xb4\x5c\xff\xbc\x28\x41\x3f\x2e\x25\x68\x84\xfb\xfb\xe0\x1a\x10\x13\xf3\x4d\x66\x9a\xa6\x4d\xd7\xb6\xad\x9b\xa3\xbd\x00\x65\x24\x29\x64\x51\x66\xd4\xac\x31\xdb\xad\xb0\x4d\x3b\xdc\xd7\xc1\x4c\x68\x37\x1a\xec\xc0\x8e\xca\xe5\xab\x8d\xa1\xe4\x2c\xcb\x08\x17\x78\x12\x60\x00\x6f\xcd\x53\x0c\xe5\x25\x42\xd1\xe0\x3c\xb7\x53\xb8\x9b\xb1\xa6\xa1\x91\x6b\xab\xeb\x28\xc3\xc5\x74\x40\xbe\xb3\xbf\x23\xcd\x72\xa6\x31\x2e\x48\x5e\x66\x86\x17\x19\x23\x81\xdb\xa2\x0d\x2d\x2b\x19\xa1\x5a\xcb\x84\x53\xe3\x66\xec\xee\x0f\xb5\xf1\xd3\x86\xd9\x18\x7a\x0b\xa6\xd0\x84\xa5\x4c\x24\x6c\x40\x3e\xc3\x75\x61\x58\xeb\xd8\x0a\x83\x60\xde\x87\x31\x28\x49\x4b\xbc\xda\x41\x7a\xb0\x7a\x8c\x61\x9e\x97\x06\x0c\xc5\x8f\x65\xc5\xb7\x3b\xee\x2c\x73\x91\x31\x1f\x48\x55\x10\xad\x29\xdc\x3d\xc8\x49\xa5\xba\xeb\xfb\x99\xef\xdb\x11\xde\x60\x6e\xdb\xca\xa9\x96\x28\x6e\x65\x63\xa8\x53\xda\xc7\xb6\x18\xb6\xa3\xb3\x3f\x49\x1a\xdb\x81\xbe\xb6\xa7\xad\x1d\x8c\x4b\x5d\xe9\x69\x5b\x6b\x52\xa1\xd8\x84\x7f\xe9\x80\x8f\x67\xa2\x52\x51\x78\xca\x84\xb1\x8a\x80\x02\x82\xaa\x58\xc1\x04\xe8\xe1\x8c\x26\x33\xa0\x0b\x8e\x8a\x56\x96\xe1\x87\xbc\x31\x42\x29\xa3\xfb\xf1\x1a\xad\x92\x62\x5e\xce\xd6\x4f\xfc\x6c\xb9\x5d\xdf\xff\xc1\x12\x32\x65\xa8\x5b\xac\x57\xae\x1b\xfb\x18\xf5\x70\x7e\x2e\xfe\x2f\xbc\xc0\xf3\x93\xb4\xda\x5b\xb8\x72\x2a\x24\x9c\xb5\x09\x37\x44\x5a\x89\xc0\x7e\x77\x40\x46\x2b\x7a\xe6\xd4\x24\x33\xd7\xe2\xf0\x50\x13\x34\xda\x36\x07\x1a\xa3\x89\x30\x2d\x33\x96\x12\xef\xb0\x81\x83\x76\x44\xa9\x9a\xab\xc2\x09\xd5\x9a\x4f\x45\xbf\x90\x69\xdf\x8e\x76\xb2\x0e\x21\x5a\x1c\xaa\xd8\xd5\x70\xfb\xc1\xda\x8a\x57\xc1\x38\xd1\x6e\x9b\x3e\x06\xfb\x5b\x24\x5b\x24\x32\x2f\x4a\xc3\x22\xe3\x5c\xb0\xeb\x8c\x17\xe8\x59\x14\xc9\x90\x95\x44\x74\x3f\x98\xe6\x54\xd0\x29\xeb\xbb\x8f\xf7\xc3\xc7\xfb\xe1\x5b\xf7\x01\x73\x1b\xaa\x85\x26\xc5\x4d\xe7\xb0\x0e\xbc\x77\x68\xb2\xc4\x97\x63\x67\x3a\xca\xe9\x17\x9e\x97\x39\xa1\xb9\x2c\x05\xc8\x64\xcb\xe0\x84\xcb\x6b\x96\xee\x07\x60\x2b\x00\xa5\xd7\x42\xaa\x25\xb4\x48\x67\xc4\x24\xcf\xd7\xb2\xd5\xca\xa2\xd5\xcd\x92\xd5\xc1\x82\xb5\xb3\xe5\xca\x1b\xa9\xdb\xe3\xe3\x47\x6f\x37\x6f\x60\x24\x17\x5b\x31\xd2\x1f\x70\x70\xed\x08\xe3\x70\x4d\x64\xce\x8d\x09\x2e\x59\x01\xc3\x7a\x84\x9b\x9a\xf5\xd3\x9d\x05\x3e\x41\x1a\xcb\x35\x61\x5f\xac\x36\xc5\xc1\x8a\xee\x6f\x2d\x7a\xc8\x65\xef\xb8\x06\x03\x1a\x15\x84\xe7\x45\xc6\x72\xef\x43\xda\xf7\xba\x99\x73\x32\x78\x39\x1f\x2f\xe7\x63\x55\x27\xdd\x45\x16\x89\xc5\x10\x34\x14\x8c\x59\x56\x89\x23\x16\xb3\x0b\x99\x6a\x27\x2f\x78\x1c\xb2\x67\xe1\xf2\x0b\xd7\xe0\x89\xfb\x91\x81\x65\x60\xc4\x8c\x26\x77\x33\xa9\x19\xf6\xa0\x8a\xb9\x71\x22\xd6\xe8\x2d\x21\x70\x8f\x00\x4e\xa3\x93\x49\xbd\x45\xca\x8a\x4c\x2e\x72\x90\x6c\x87\x26\x96\x67\x82\xe8\xc2\xf2\x22\xa3\x86\x05\xc1\x66\xb3\xb5\xe1\xde\x9c\x0f\xbe\x7e\xf9\xc5\x4a\x00\x51\x1c\x44\x0b\xd8\x36\x3b\xd6\x4d\x53\x0d\x48\x3b\x22\x93\xa3\xcf\xf2\x0d\x48\xf8\xd5\x1b\x80\xe6\xd9\xd5\xc5\x7a\x07\x49\xd2\xca\xbc\x42\xb6\x9b\x58\x96\x96\x71\xb6\x61\xaa\x0d\xe9\x15\x7d\x7e\xbd\x07\x2b\x7a\xa0\xf7\xd0\x78\xd5\x73\xee\x73\x21\x3a\x00\x1b\x2b\x96\x61\xe8\x83\x33\x34\xdb\x46\xce\x73\x7d\x3f\x1a\x59\x5b\xbb\x7b\x1b\x9b\x7b\x3f\x4c\x7e\x4f\x4a\x60\x2b\xa3\x7c\x6d\x33\x40\xc9\x8e\x8f\x2a\xb8\x1c\x59\x48\xa2\x7d\xde\x6d\x04\x2d\x8a\x0c\xee\xeb\x64\x5b\xdf\xac\x96\xea\x18\x2e\xbf\xe3\xa4\xc3\x96\xc7\x0e\xb7\x76\xe6\x87\x1a\x11\xc0\x9e\x8e\x19\x2f\x9c\x37\x23\x5a\xeb\x7c\xfc\xc2\x67\xb0\xa3\x56\x31\x25\xf6\x24\x0c\x45\x8f\x5c\x49\x63\xff\x77\x89\x36\x51\x8b\x37\x17\x92\xe9\x2b\x69\xe0\xcd\x5e\x97\x8d\x53\xe9\xb8\x68\xec\x04\x07\x44\xe0\x99\x04\x83\x74\x14\xd0\x80\xbe\xa2\x40\x0a\x3d\x80\xb8\x26\x43\x41\xa4\xf2\xab\x0b\x56\x5d\xed\x86\xf0\x9a\xa1\x90\xa2\x8f\x6e\x84\xab\xc6\xb8\x0c\x3e\x94\x31\x4c\x36\x0c\xe7\x86\xba\xb1\x14\x18\x7f\xc1\x10\x96\x8c\x26\x2c\x25\x69\x09\x93\x86\x70\x0c\x6a\xd8\x94\x27\x24\x67\x6a\xca\x2c\xd3\x4e\x66\x6d\x41\xbd\x8d\x2e\xe1\xd3\x82\x3a\xc5\x83\x6e\xd9\x3f\x20\xc1\xef\x80\x4b\x74\x23\xdb\xd8\x07\xc9\x5b\x4e\x0b\xbb\x75\xff\xb0\x54\x0c\xa0\xf7\x2f\x52\x50\xae\xf4\x80\x9c\x79\xd7\xdb\xf8\x37\x67\x03\x8b\x87\xb1\x23\x58\xa9\xef\x87\x92\xcf\x69\x66\xe9\x26\x0a\x78\x0c\xc5\x3b\x3b\x7a\x93\x59\xf4\x1c\x2f\xb5\xe7\x1b\xfd\x5d\xb8\x26\x07\xb7\x6c\x71\xd0\x5b\xda\xee\x83\xa1\x38\x40\xfa\xba\xb4\xc1\x81\x18\x83\x47\xc9\x01\xfc\x76\x70\x3f\xfe\xf2\x00\xc2\xdf\xd6\xbd\x34\x32\x63\x2a\x0e\xfd\xdc\xb2\x87\x37\x55\x7b\x58\x5a\x75\xbd\x1b\x8d\xf4\x38\xb7\x14\x37\x5e\x6c\xb1\x67\xab\x9a\x17\xa0\x96\x31\x34\x99\xa1\x17\xb7\x9b\x17\xc4\xd1\x2c\x88\xdd\x33\x83\x74\x1d\x10\xc3\x71\x48\xa3\xe0\xd2\xe7\xb7\x01\xdb\x7a\x0c\xe4\xa7\xdf\x45\xfe\xed\xd0\xde\xfe\x11\x30\xe4\xb7\xfe\x5f\xbf\xbb\x67\xdc\x42\x3b\xc6\x86\x53\xea\x20\x60\x5c\x42\x07\xc2\x45\x0a\x17\x4c\x6e\xa9\x00\x01\x1c\xcb\xc2\x07\x96\x35\x20\x97\x96\x50\x91\x9c\x51\xa1\xbd\x99\x0b\x6e\xa2\xaa\xc6\xda\x5d\x99\x45\x7a\x95\x33\x29\x54\x27\x83\x91\x2b\x39\x72\xb6\xaf\x1e\xb9\x06\x5b\x6a\xf5\x06\x4e\xd2\x95\xbc\xfc\xc2\x92\xd2\xac\xbd\xcb\x8a\xe1\xb6\x95\x8b\x6c\x65\xf4\x35\x80\x7c\x5b\x31\x79\x5c\x59\x8d\xc9\x57\x18\x1c\xb3\xf9\x8d\x90\xb9\x65\x8b\x8a\xd9\x38\x11\x02\x48\x7e\xaf\xc2\x12\xcf\x0a\x90\x77\xfc\xb7\x37\x65\xe5\x63\x2e\xf0\x63\x38\xb4\xdf\x0a\x18\xdd\x03\xd4\x4a\x76\x59\x86\x9f\xd9\x07\xb8\xda\xc9\x19\x35\x98\x7d\xe8\x20\x63\x04\x2a\xb9\x5a\xba\x88\x44\x8a\xcb\x1f\x4a\x9a\xd5\x83\x10\xdc\x2b\xd7\x68\x89\xaa\xdf\xf1\x2c\x4d\xa8\x72\x5e\x5e\x18\xa6\xa9\x25\xee\x1e\x05\x42\x90\x50\x11\x4e\x7b\xb5\x47\x1a\xaf\x2a\x0b\xaa\x0c\x4f\xca\x8c\x2a\x1f\x39\xde\x2a\x50\x60\x2b\x44\x2b\xa4\x19\xb1\x44\x8a\xb4\x8b\x02\x70\xd3\xec\xdb\xbc\x6b\x2d\x98\xe2\x12\xbd\x8b\x79\xce\x9a\x48\x7a\x54\xb7\x69\xcb\x89\x3f\xd5\xe1\x88\xd5\x2c\x1f\x10\x9b\xe9\x19\x1e\x9f\x0a\xa9\x58\x7a\x1c\x91\xc7\x70\x2a\x06\xe4\xcd\xc2\x9b\x59\xc0\xe4\xe2\xa2\x2b\x34\x33\x3e\x10\xc6\xa3\xac\x03\x76\x75\xa0\x26\x52\x41\x70\xca\x51\x2a\x31\x22\x63\xce\x13\x73\x3c\x20\xff\x97\x29\x09\x1b\x2f\xd8\x94\x1a\x3e\x0f\xdc\x34\x28\xae\x8a\x51\x77\x83\xff\x8a\x1c\x41\x37\xc2\xf3\x9c\xa5\x9c\x1a\x96\x2d\x8e\x51\x8f\x65\x44\x2f\xb4\x61\x79\x9b\xad\x6b\x63\x34\x40\x5f\x3b\x68\xfb\xab\xaf\x37\xb4\xec\x1a\x43\xf5\xd9\x47\xa5\x54\x90\x41\x1f\x82\xc6\x16\x06\x1e\x24\x37\x88\x9b\xb1\x0f\x82\x0b\x6c\xf6\x92\x65\xbc\xc1\xdf\x5b\x3c\xa0\x44\x31\xc8\x40\xe0\x30\xf7\x9e\x38\x8e\xde\x94\xef\x65\x29\xd6\x9b\x04\x6b\x0b\x7f\xe7\x94\xf0\xcf\x51\xc7\xb5\x51\x8a\x8f\x22\x26\x44\x33\x89\x4c\x94\x94\x80\x5d\x12\xd8\xb9\x25\x0f\xd8\xaa\xf2\x44\xd9\x3a\xc9\xbd\x46\x24\xc2\x5c\xb6\x78\xbd\xef\x25\x6e\x31\x7c\xa8\x03\x2e\x83\x83\xb8\x03\x4c\x23\x6e\xcf\x38\x72\x00\xf8\x89\x10\xac\x10\x14\xbe\xc5\x52\xef\xc5\x66\xa9\x81\xeb\x4a\x0e\x4f\x0f\xf7\x42\x7c\x71\x39\x4a\x16\x74\x0a\xe7\xa9\xc3\xaa\x9a\x5d\x49\xca\x0c\x53\x39\x04\x5c\xcf\xe4\x1d\xfe\x8e\x6c\xab\x70\xad\x58\x5a\xc5\xb6\xcf\xa4\x06\xae\x54\x0f\x62\x84\xf3\x0b\x17\xa3\x77\x74\x41\xa8\x92\xa5\x48\x9d\xd4\x14\x08\xe8\xfb\xc6\x87\xaf\xa4\x00\x4a\x51\x6a\x0b\xab\x9b\x1a\x95\x1e\x33\x43\xed\xb1\x79\x3d\x78\xfd\x6a\x2f\x00\xeb\x18\xb7\x0a\xb3\x69\x58\x0a\xfd\x5d\xb9\x3f\x33\x7b\x99\x97\x62\x34\xfd\x20\xb2\x2e\xb2\xdc\x7b\x44\x2f\xe8\xda\x07\x25\x8c\x4f\xc0\x76\xdb\xc3\x57\x77\x8a\x1b\x16\x91\xc7\xa3\x09\xcd\x34\xb3\xaa\x7b\x29\x82\x08\x7b\x5c\x17\x41\xa0\x49\x9b\x05\x6d\xf7\x07\xd1\xe5\xf8\x9e\xe7\xcc\x1d\x28\x40\xb9\xea\x98\x05\x84\x3b\xd4\x1b\x8e\x5c\x3d\xb8\x93\x1c\x61\x4b\x2b\xb1\x49\x69\x8e\xf7\xe3\x24\x82\x0b\xb4\x9a\x75\x17\x95\xc4\xc7\x0d\x17\x7b\x5c\xed\x1b\x36\xa3\x73\xa6\x89\xe6\x39\xcf\xa8\xca\x20\x56\x70\x84\xf3\x23\xe3\xd2\xac\x8e\x40\xef\x16\xdd\x1c\xcf\x24\x1a\x6e\x2b\xa8\xfd\x3c\x2c\x9c\x80\x46\xf8\x79\xd9\xef\xe4\xa5\x29\x69\x96\x2d\x08\xfb\x92\x64\xa5\xe6\xf3\xfb\x9e\x26\x17\xfd\xb0\x03\xab\x6e\x72\xe9\x42\xa6\xa3\x82\x25\x8f\xc9\xa3\xeb\x1a\x86\x25\x55\xa9\xdf\x74\xe0\xc9\xa8\xec\x83\xe6\xbe\x00\xcf\xa7\x24\x61\x5a\x7b\x9f\xca\x45\xec\xe7\x19\xd6\xf0\x63\x49\x28\x40\xef\xf4\x65\x46\xb5\xe1\xc9\x9b\x4c\x26\xb7\x23\x23\x55\xa7\x98\xfd\xb3\xef\x46\x4b\xfd\x1b\x69\x18\xce\xbe\x1b\x91\x0b\xae\x6f\xe3\xc4\x2e\x78\x69\x1a\x9b\x4b\x28\xb9\x2d\xc7\x2c\x63\xe6\xf0\x50\x23\x97\xcb\x69\x32\xe3\x82\x79\x06\x27\x42\x48\x8a\x53\xf8\x2c\x94\xbb\xde\x99\xba\xc0\xa7\x13\x87\xaf\x3f\xa3\x77\x9a\xe1\xf4\xc7\x76\xfa\xf6\x67\xd6\x26\x22\x7d\xaf\xf7\x14\x38\x99\xe1\xc5\x9e\xee\x20\x26\xfa\xc6\xce\xb1\x9b\x71\xfb\xf0\x2d\xcf\x18\xea\x38\xb0\x44\xef\x95\xe6\xce\x01\xec\xd8\x42\x96\xe4\x8e\xa2\x56\x0c\x34\x70\x40\x6e\x78\x71\x4a\x2e\x85\x2e\x15\xab\xec\x19\x93\xc6\x50\x5c\x57\x91\x65\x5e\x9d\x82\x1d\x46\x95\xc3\x52\x3a\xa7\x5d\x91\xcb\x2f\x34\x2f\x32\xa6\x4f\xc9\x01\xfb\x62\xbe\x3e\xe8\x91\x83\x2f\x13\x6d\xff\x27\xcc\x44\x1f\x0c\xc8\x30\x0f\xf7\xec\x90\xfa\x47\x31\xef\xfa\x84\x1d\x2c\x33\x8e\xf8\xec\x83\x20\x88\x73\xa3\xb3\xd2\x5a\x2a\xc9\x1d\x66\xa0\xb0\x24\x9e\x29\x25\x55\xf0\x3c\x8f\xc0\x00\xdc\x25\x91\x79\xa1\x64\xce\x23\xc3\x1e\x20\xf8\x5e\xfd\xeb\xc0\xdc\xb0\x5d\x24\x5d\xde\x7f\xcc\xe9\xe6\x3a\x93\x3a\x73\x5c\xb7\xfb\xc3\x89\xf7\x98\x40\x55\xd1\xe9\xee\xa0\x7f\xba\x46\x76\xbf\xdd\x28\x96\x5a\xc5\x3b\xfc\x36\x44\xcd\x91\x93\x94\xcd\x4f\x74\x4a\x5f\xf7\xe0\x33\xda\x79\xfb\x99\xda\x9c\xa8\x26\x07\xaf\x0f\x06\x64\xe4\xb9\x6d\x2f\x9e\x63\xd5\x6e\x22\x55\x18\x10\x8c\xe9\xaf\x0e\xc8\x91\x54\x30\x72\x42\x05\xc9\x18\x9d\x3b\x03\x32\x9e\xa9\x05\xea\xb4\xc7\xad\xa3\x1e\xdb\x06\x80\x45\x5a\xfe\x7f\xfe\x72\x4b\xeb\x76\x92\xe8\xf2\xbe\x79\xcf\xc8\x03\x2b\x82\x1e\x80\x30\x29\x2d\x8d\xb5\x54\xd3\xb2\x55\x48\xab\xe5\xc6\xae\x16\xcc\xc5\x92\xa6\x8c\x03\x6c\xdc\xd4\x03\x90\x53\x0f\x9e\x80\xea\x92\x8e\xf1\xf5\x9e\xa4\x76\x85\xe6\x27\xc1\x7f\x28\x19\x19\x5e\x84\xc8\x7a\xa6\x34\xd7\xc6\x9e\xee\xb4\xc6\xc3\x38\x32\xb6\xa3\xb3\x9c\xfe\x5d\x0a\x72\xf9\x66\xe4\x3e\x7a\xfc\xa4\xe0\xd9\x4a\x24\xe8\xdf\x4b\xc5\x2c\x3b\xee\xe2\x30\xe0\xfb\x34\x39\xbb\x7d\x4f\x2e\xa8\xa1\xc8\xe0\x9d\xcb\x95\xa8\x28\xbc\xc5\xc2\x31\x17\xa9\xfb\x29\xe2\xdc\x8f\xcd\x64\xed\xee\x5d\x6d\x92\x97\xe2\x86\x9f\x3e\x0e\xf7\xc4\x8c\x13\xa0\xf1\xd3\xf7\x32\xed\xcc\x91\xff\x60\x01\x78\x8e\xfd\x49\x6e\x07\x20\x56\x67\xef\xc1\x71\x26\xf6\x3c\xbb\x7f\x7e\x67\x35\xce\xd6\xc4\xab\x15\x1b\xf1\xd0\xea\x38\xe7\x9b\x48\x4f\x07\xda\x61\x51\x03\xce\x8d\x63\x28\xe3\x4c\x8e\x89\xc3\xf7\x7d\xcf\xf7\xd3\xc7\xe1\x0e\xd3\xfd\xf4\x71\xf8\xb8\x53\xdd\x49\x3c\x6b\x4a\x67\x15\x0f\xae\xc2\x31\x9a\x62\x57\x7b\x99\x6b\xb0\x2f\x69\x6b\x9f\x70\x5a\x95\x55\x72\x0b\x94\x0e\x2f\xbf\x14\xe8\x7c\xe6\x8c\xfc\xa3\x19\x85\x38\xe6\x10\x5d\x07\x9b\x6a\x77\x59\x5b\xca\xee\xb7\xd7\x6a\x74\x40\x9f\xc8\x05\xc3\x2b\xcb\xf4\xd4\x3b\x02\x84\x1e\xab\x3b\xbc\x07\xb7\xcb\xf4\x14\xe9\x2a\x41\x2f\xcc\x34\xc2\xa6\x23\x34\x11\x89\xf0\x13\x9d\x53\x9e\xd1\x31\xcf\xb8\x59\x58\x0e\x7d\x3c\xa8\xb9\x96\x6a\x98\xf2\x5e\x0f\xf3\x8e\xa2\xc5\x92\x81\x8a\x1c\xd9\x91\x4e\xc0\xc0\x75\x3c\xa8\xa4\x8a\x19\x53\x2e\x08\x11\x45\x8f\x9a\xc8\xa1\x99\x01\x6c\x6b\x48\x1c\x6d\x51\x65\x3b\xbb\x07\xc0\xdb\xf3\xd1\x95\xa1\xd9\x3e\x2b\x19\x1a\xfc\x30\x72\x39\xe1\x9e\x33\x4f\xc3\x78\xa9\x56\x5c\x0d\xd0\x6a\x6b\xcb\xf6\x7c\xed\xa7\x8d\x53\x24\x04\xa3\xed\xc0\x04\xed\x54\x85\x63\x82\x3e\xbe\xbe\xe6\x46\x89\x58\x36\x72\xa4\xc4\xa5\x4b\x42\xbe\x69\x71\xeb\xdb\x16\xa9\x02\xba\x24\x58\xf0\x3b\xdf\x35\xe4\x6a\x06\x6e\x15\xdb\x91\xab\xf5\x6c\x12\x56\xcc\x26\x5d\xee\xa9\xcf\x59\x31\x7b\x3b\xaa\x9b\xe7\xec\x3b\xf2\x76\xb4\xe2\x5c\x02\x90\x61\xb5\x1a\x8d\x76\x87\x9a\x64\x7c\xc2\x0c\xdf\xb2\x84\x07\x38\x99\xb9\x14\xdc\x48\xb5\x3e\x2e\x99\x74\x3a\x6d\x7e\xb8\xae\xfc\xb0\xca\xe4\xf1\xde\x8d\x80\x0e\x70\x89\xcc\x32\x96\xf8\x3c\xd6\x00\x52\xff\x89\x55\xca\x0b\x73\x3a\x7b\xc8\xf2\x8f\x8a\xca\x09\x6e\xe8\xc9\xc7\xcb\xb3\x8b\xf7\x97\x83\x3c\xfd\xd9\x4c\xde\xf5\x8d\xec\x97\x9a\xf5\x79\x8b\x54\x21\x4f\xe7\x46\x88\x4f\xd1\x2a\x73\x55\x1d\xa4\x1f\x7c\x00\x23\xf9\xa4\xd1\x6d\x00\x4c\x39\xfe\x52\x48\x4a\xd3\x23\x8a\xba\x20\x45\xea\x2c\x41\x65\x96\x21\x94\x8d\x62\xac\x17\xab\xd4\x1b\x63\x33\x3a\x2f\x68\x57\x23\x42\xb5\xa8\x87\x25\xd0\x8f\x8f\x5c\x5d\x68\xfd\x76\x21\x62\x13\xe4\x46\x61\x0c\xef\x7f\x01\x57\x4d\x46\x82\x7f\x16\xf8\xdb\x4e\xa4\xb2\x58\xa3\xea\x18\xc0\x4c\x02\x8b\x3d\x29\x35\x53\x03\xc7\x31\x1e\x1d\x50\x1d\x92\xf5\xec\x90\x23\xad\x09\xa6\x8f\x6c\x82\x0e\xc9\x3e\x67\xae\x93\xa2\x68\x69\x66\x4c\x18\x9f\x72\xdc\x01\x63\x25\xdc\x9c\x87\xf3\xa3\x03\xaa\x65\x7a\xa0\x6e\xc9\x7c\x5e\x12\xe0\x74\x41\x43\x7b\x50\xee\x45\xb7\x43\x74\x94\xa2\xa9\x04\x17\x08\xcc\xe9\x56\x43\x30\x9a\xe6\x5c\x3c\xc3\x83\x98\x70\x91\x6e\x5b\x7f\x23\x71\x1d\xf4\xa8\xcb\x51\x38\x8a\xb7\x9e\x87\x9b\x38\xea\xf5\x1a\x0c\x21\x77\x77\x72\xf5\x1b\xb9\x56\x87\x2e\x5f\xe8\x1f\xb2\x3e\x7e\xa5\x5f\xa4\x15\x54\x5e\xae\xd7\xf6\x6f\xc0\x79\x84\x4b\xb3\x3d\xed\x2f\xf9\xf7\x13\x68\xee\x0d\xa9\x2e\x32\xcc\xbd\x78\x33\x54\x4d\xd1\x3e\x68\x0b\x33\x82\x61\xf9\x15\xa7\xbb\x5a\x10\x14\x54\xd1\x9c\x19\xa6\xd0\x75\xcc\x39\xa3\x09\xe7\xd5\xff\xa1\x60\x62\x64\x68\x72\xbb\xef\x14\xa2\x2f\xfc\xf4\xe1\xf8\xe9\xae\xb7\x65\xde\x49\x26\x0d\x98\xe0\x12\x0a\x2d\xe2\x9b\x59\x2e\x1c\xb3\x79\x26\x74\x25\xe4\xf1\xea\x62\x89\x08\x79\x9c\xea\x4c\xb4\xca\xeb\x85\xc6\x07\x70\x11\x0b\x89\xe9\xc0\xf5\x1d\xa1\xb0\x1f\xa6\xd7\xfe\x10\x38\x39\x66\x97\x7b\xa7\x8a\x1e\xe4\x32\x65\x64\xcc\x4d\x75\xd2\x35\x33\xa4\x60\x2a\xe7\x2e\x00\x5a\x0a\xac\xc1\xc7\x52\xe4\x5e\x96\x53\xb9\x4f\x47\x9c\x4d\x10\x99\x18\x5f\xe4\x8a\x8c\x99\xb9\x63\x4c\x90\x57\xaf\x5e\xbd\x02\x79\xe3\xd5\xaf\x7f\xfd\x6b\x02\x19\x17\x52\x96\xf0\x7c\xb9\x21\xb4\xfa\xaf\xd7\xaf\x07\xe4\x8f\x67\xef\xdf\x81\xff\x55\x61\x34\x19\x4b\x33\x73\x23\xdb\x06\xb5\xce\xba\x47\xfe\x67\xf4\xe1\xca\x8b\x09\xba\xf1\x2b\xa8\x14\x61\x79\x75\x67\xba\x57\xbf\xfa\xfa\xeb\x01\xb9\xe0\x0a\x22\x6f\x39\xc4\x0a\x04\x77\xc1\xc2\xbb\xd0\x09\x69\x96\x63\xdd\x1d\x9b\x70\xee\xb4\x39\x9f\xce\x0c\x56\x4b\x02\x4c\xc9\x78\x62\x30\xfb\x1e\x1e\x76\xcc\x85\xa4\x5d\x28\x89\x0b\x8c\x72\x8e\x23\x30\xb9\x1e\xc9\xf8\x2d\x23\x13\xfd\x8d\x92\x65\x51\x05\x04\x2a\xa6\xad\x8c\xea\x6a\x31\xe1\x60\xd5\x5e\x69\x66\x9e\xd4\x93\xa1\xa5\xa5\xa6\x86\x74\xc3\x9a\x00\xd2\x0b\xf9\xc7\xfa\x88\x09\x05\xe5\xc1\xb9\x0e\xae\x9b\x6b\xd9\xef\x83\x16\x99\x46\xe7\xd4\xc7\x77\x14\x4a\x7e\x8f\x9b\xc4\x85\x8f\x14\x72\x32\xaf\x76\x32\x97\x0b\xcc\x04\x9b\x2d\xaf\x47\xae\x5b\xbe\xe7\xa2\xe2\xa3\x18\xa3\xe1\x24\x0e\x46\x83\xd0\x6d\xae\xed\x27\x6a\xc9\x21\x57\x7c\x39\x2e\x4f\x68\x66\x1a\x77\xb4\x14\x4b\xbd\x5d\xad\x11\x47\x69\x5c\x05\x1a\x17\xe6\x55\x8d\x81\xee\xaa\x2e\x48\x26\xaa\x6b\x54\x4b\xd8\x56\x73\x92\xd1\xcc\x94\x0e\x34\xe0\xab\x64\xbf\xcd\xb4\x76\xb1\x36\x39\x55\xb7\x56\xec\x77\xe7\x7f\x00\x9e\xc1\x3a\xc4\xf9\x60\xd0\xd5\x9c\x85\x22\x75\xb1\x67\xbd\xfd\xc8\xe1\x60\x70\x88\x07\x44\x2a\xcc\x77\x89\xd8\x6e\xdf\x3f\x51\x4c\x71\xdd\x73\x9b\x16\x51\x09\x3a\x57\xda\x83\xd6\x3c\x82\xa9\x83\x54\x9b\x2c\xb7\x9d\xc4\x97\x6e\xf9\x82\xdb\x66\x0c\xc6\x96\x45\x9b\xb2\x05\x5d\x25\xa8\x0e\x09\x86\xd7\xd7\x4d\x71\x47\xa0\x5d\xce\xe0\xce\x39\x70\x09\x7a\x45\xec\x32\xc7\xae\x4c\xce\x05\xb1\xd5\x2a\x66\x3d\x7f\xae\x36\x9c\x60\xf8\x47\x9d\x56\x39\x5a\x10\x49\x08\x55\x75\xaa\x2a\x16\xe4\x59\x33\xaf\x18\x5d\xba\x65\x63\xef\xc2\xc8\xf0\x69\x77\x49\x80\xcf\xd2\x39\x08\x34\xb3\xa8\x55\xbb\xc8\xd0\x00\x00\x72\xa3\x3f\x2c\x03\xf2\xde\xd1\x54\x44\x2e\x3a\xd6\x32\x2b\x0d\x76\xad\x7e\x8c\x09\x2e\x0c\xea\x53\x0e\x00\x95\x0d\xcd\x22\xf2\x6b\xaa\x7a\x5f\xed\x28\x31\x3e\x1d\x0e\xe3\x4b\xea\xcb\x27\x4b\x2b\x5b\x65\xec\xd6\x0f\x96\x62\x36\xd1\xbc\x8b\xaa\x34\x1a\x92\xa3\xaa\x54\x86\xbf\xe6\x1e\x0a\xc3\xd4\x84\x26\xec\x38\x56\xa1\x42\x49\x92\xe0\x59\xe3\x63\x03\x66\x54\xa4\x19\x8a\xd6\x09\x53\x80\xf2\xec\x8b\x2b\x96\x6b\x3f\x91\x2a\x0e\x45\x60\x8f\xde\x30\x2b\x0f\x32\x6a\x4a\xc5\x5a\x45\x18\xed\xd7\xad\x10\xa6\xb1\x2f\xa5\x0d\x06\xeb\xea\x52\x01\x9d\xbc\x84\x2a\xa2\x63\x55\x81\x09\xa1\x8a\x20\xd5\xb1\x5a\x3a\xb0\xa8\x04\xf4\x18\x48\xc5\x42\x96\xca\xd9\xbd\x7d\x6e\xd1\x44\x2a\xab\x08\xe1\xc0\x54\x13\xc5\xa6\x56\x5a\x55\x20\xd6\x62\x8b\xac\xb4\x2f\xf6\xea\xfc\xb5\x67\x27\xb9\x4d\x2e\x6e\x13\x27\x3e\xcb\x39\x4f\x3d\x8b\x84\xbb\xa5\xaa\xc4\x5f\x41\x75\x14\x77\x12\xa5\x63\x8f\x20\x8c\xc2\x38\x30\xd2\x10\xd1\x59\xf3\x9f\x8e\xad\xbb\x12\x12\x3d\xb4\xa8\xa5\xd0\x85\x08\xcb\x94\x5d\x97\xe3\x8c\xeb\xd9\x68\x47\x53\xe0\xd5\x8a\x21\xd0\x61\x60\xe9\xa2\x6e\xad\x79\x50\x33\xa1\x39\xb0\x3c\x4b\xc6\x2d\xb3\x85\xda\xc1\x12\x80\xe8\x7b\xc7\x98\x29\x21\x30\x22\x63\x2e\x9c\xdf\xfe\x14\xcd\xc3\x45\x68\x61\x02\x8f\x94\x7d\x12\x45\xed\x7d\x42\xb3\x4c\x37\xa3\x57\x3d\xa1\x45\x99\xc3\x47\x6d\xe1\x9e\x72\xbb\xdd\xa1\x4c\x48\x23\x15\xe4\xda\x85\x69\x92\x4b\x8c\x70\x11\x44\x0a\xdf\x08\xf2\x90\xf8\x0e\x51\x54\x1f\xc4\xee\x02\xca\xec\xb9\x8e\xe2\x8b\x0d\xf4\xe1\x6c\xa0\x3b\xde\x34\x54\x95\x94\x68\x14\x11\x5c\x2f\xf5\xec\x49\xa9\x27\xb9\x5b\xae\x24\xf6\x7a\x2b\x80\xdf\x3c\x33\x58\x9e\xbc\x73\xce\xb3\xcf\x8d\xee\xc0\xa6\xad\xde\x01\x87\xb7\xef\x34\x8b\x24\xc2\x4c\xa7\x10\x84\x23\xb0\x7c\xe4\x2b\x9e\x03\xec\x06\x5f\x1e\x6a\x92\xca\xa4\x0c\xb9\x51\x01\x68\xd5\x05\x58\x9b\x0c\x82\xa4\xeb\x71\xea\x9e\xd6\x2a\xfe\xc8\x56\xac\x4a\xe5\x9d\xb8\xa3\x2a\x3d\xbb\xde\xe2\x97\x5e\x67\xe7\x55\xaf\x58\x50\xf2\x83\x41\x25\x3c\x3a\x96\xa5\xa9\xd2\x67\xfe\xb4\x4d\xcf\x46\x5a\x8a\xd0\xd2\xd2\x4c\x5e\x8c\xd7\x2f\xc6\xeb\xe6\xf3\xe0\xc6\x6b\xdb\xa7\x9e\x0b\xb6\x76\x5c\x7d\x8a\x01\x9e\xb5\x75\xa5\x7d\x48\x2b\x68\x44\x60\x90\xba\x37\xfd\xe0\x1b\x72\x1b\x1e\x91\x6a\x6f\x23\x59\xcf\x53\x20\x60\xd5\x4f\x6f\x31\x7d\x20\x3b\x68\xfb\x5a\xbd\xf8\xac\x73\xc1\xdd\x54\xbb\x17\xa4\x86\xa8\xd8\x6e\xcf\x65\x42\xee\x39\xbd\x4b\xa4\x55\x19\x3b\x4c\xc4\xdc\xa1\x54\x27\x3e\x1d\x81\x4f\x3a\x6f\x00\xe9\x58\x48\x17\x9f\xae\xbb\x41\x76\x28\xaa\x8b\xcf\x13\x97\xd6\xc5\xa7\xb3\x89\x9b\x74\x2f\xb3\xbb\x62\xb9\x0f\x5b\x6c\x77\xc7\xa5\x3d\xbe\xf5\xbe\x57\x95\x78\x7b\xfe\x6c\xfd\xc5\x7a\xbf\xf4\x3c\xa2\xf5\x3e\x22\xdc\x9e\x18\x38\x00\xc4\x16\xfd\xd8\xdc\xe6\xcd\xfa\x63\xe6\xc5\xca\x41\x95\x81\xcc\xa2\x9c\x37\xe8\x4b\x55\xbf\x36\x3d\x1c\x0c\x0e\x0f\xbd\x99\xdf\xe1\x67\x69\x26\xfd\xdf\x10\x26\x12\x99\xe2\xa6\xda\xf1\x95\x36\xc0\xf4\x2b\xed\x3c\x9e\x4b\xee\xbf\x15\x5f\xbd\xc2\xd8\xdd\xb6\xa4\xc3\x09\xee\x5e\x3a\x7b\x15\xa4\x1f\xa3\x80\x76\x5c\x26\xbb\x5e\x15\x1b\x5b\xdc\xa7\x14\x76\x0c\xbc\x07\xe7\xaf\xad\x8b\x63\xe3\xb3\x0b\x7b\xdd\xa1\x50\x36\x3e\x8f\x5c\x2e\x1b\x9f\x9d\x38\x6a\xa7\xd2\xd9\x2b\x16\xf7\x78\x05\xb4\xf1\x79\xa6\xc5\x54\xea\x4f\xa7\x62\xda\xf8\xec\x56\x52\xbb\xde\xb7\xe3\xd6\xef\xa5\xbc\x36\x3e\xdd\x8a\x6c\xe3\xb3\xef\x52\xdb\xf8\xb4\x84\x04\xd8\xc0\x2f\x78\xa7\xe0\x81\x4b\xd7\xa7\xee\xf9\x68\x58\x5e\x48\x45\xd5\x82\xa4\xce\xd6\xb0\x58\x11\x80\x19\x45\x60\xde\x3b\x2b\x0a\xcc\x3d\xe5\x6a\x4f\xf1\x03\x1d\x82\x2f\x59\xca\xcb\xb5\x25\x8b\xd7\x81\xed\x3b\xc8\x86\xe5\x32\x69\xf9\xcb\x4d\x1c\x2a\xa4\x12\xa4\xc9\xad\xab\x91\xe3\x61\x88\x9c\x3e\x4e\xb9\x73\xd0\xc8\x7c\x0c\xc6\x30\xb8\xe9\x73\xb5\x00\x7d\x63\x1c\xbb\x66\xb8\xc2\x2b\x0f\x77\xf7\x7f\xe4\x1a\x1e\x5b\xf9\xe3\x3d\x30\xbd\x47\xda\x13\xd2\x31\xc8\x8c\xff\x9d\x41\x81\xad\xce\x29\xac\x24\x88\xdd\xa1\xf0\x57\x26\x93\xe8\x62\xb9\xc6\x7e\x00\xea\x01\xb3\xbd\x61\xde\xc2\xde\x7e\x1d\x85\x07\xb0\xe8\x64\x1a\xef\xea\x78\x02\xb9\x1b\x41\x44\x07\xd8\x05\x78\xdf\x44\x65\xf0\x4a\x6d\xbf\x04\xa9\xd5\xa3\x36\xd5\x87\xee\x7c\x0a\x49\x13\x55\x2a\xab\x2b\x16\xf6\x97\x91\x87\x40\xa4\x94\x41\x78\x82\x97\xc2\x75\x09\x32\xa0\xfb\x8a\x93\x85\xe4\x04\xee\xa3\xaa\xba\x5f\x21\x7b\xe1\x12\x56\x09\x9e\xd5\xd1\xca\xa7\x6e\x0b\x0b\x2f\x85\xf3\x22\x58\xc2\x91\xd5\x28\x52\x6a\xa6\xfa\xd3\x92\xa7\xbb\x20\xc7\x33\xe6\x6e\xad\x79\x5a\x77\x4e\xd6\x91\x7f\xdd\x83\x6b\x05\x2f\x8b\x0e\x74\xff\xe0\x32\xb8\x66\xd4\x08\x7f\x9c\x12\xae\xee\xa6\x41\xbd\x27\x40\x38\x72\xfe\xbe\xe7\x26\xe8\xad\x8e\x21\x24\x8b\xc4\x85\xc9\xf2\x5a\x3e\x47\x1c\x16\x31\x0f\xbc\x52\xfb\xf6\x3f\x5e\xbf\xf5\xc6\xfa\x31\x9b\xc8\xaa\x04\x08\xaa\x3b\xce\x97\x36\x65\x19\x83\x3a\xe9\xbe\x06\xbb\x6d\x00\xd7\xbc\xb9\x9c\x5b\x64\xfe\xb3\x20\x9f\x7c\x52\x7a\x3e\x39\x25\xf4\xb8\x16\xaa\xe0\xca\xaa\x08\xc6\x52\x74\xb0\xcd\xaa\xef\xa8\x52\xe8\x1e\x19\x1f\x7b\x67\x13\x38\x71\xc2\xca\x7c\x99\x17\x67\x51\x69\x56\xcc\x02\x00\x02\x7e\x95\xcc\x89\x16\xb4\xd0\x33\x09\xd5\xf5\x13\x5a\xd0\x84\x9b\x85\x05\xb7\x51\x34\xb9\x85\x32\x3c\x8a\xb9\x2f\xf6\x48\x72\xec\xfc\xb5\x62\x08\xd6\xdd\x7e\xcd\x4c\xc9\x72\x3a\x03\x4f\x56\x6c\x95\x64\x54\x7b\x00\xac\xec\xef\xb4\x19\x4d\xd2\x85\xa0\x39\x4f\x42\xd2\x3c\x25\xe7\x5c\x73\xe9\xac\xb9\x38\xae\xc5\x7a\x72\x1d\xf2\x9e\xa1\x91\xf8\x3c\xa3\x3c\x27\x47\x9a\x31\x12\x10\x03\x7f\x71\xd5\xda\xd1\x78\xa1\x98\xed\x1e\x5b\x90\x65\x48\xde\x2d\x5c\xc6\x81\x8a\xd2\x85\x2b\x2a\x64\x94\x70\xdc\xd2\xd5\x9f\x3e\x0e\x5b\xb7\x7a\x66\x52\xc1\xc5\xbc\xcf\x5a\xc9\x44\x2a\xa3\xeb\xc9\xb3\xeb\xa1\x8e\xd5\x0e\xc4\x33\x97\xdb\x0d\x7e\xc8\xa4\x98\xc6\x21\xfb\x15\x96\x5a\xb2\x2a\xa0\x96\xc9\x9c\xa7\x25\xcd\x90\xa0\xba\xc9\x9c\x8f\x86\xd8\x9d\x4f\x67\xa6\x7f\xc7\xc0\xec\x82\x7c\xa7\x72\x6d\xf2\x1f\xe5\x4b\x6e\x39\x5c\x03\x01\x36\xce\x6c\x80\x26\x2c\x3b\xb5\x3b\xba\x80\xfc\x2e\xce\x85\xa4\x76\x33\xea\x73\x6b\xe1\x10\x01\xee\x11\xd0\x61\x7a\x67\xa1\x36\x85\x95\x18\xc0\x2e\x65\xa1\x0c\x58\xbb\x3c\x37\x0b\xf8\x28\xd7\x5d\x78\xed\xca\x90\x51\xbb\x47\x20\xc5\xfd\x59\xa0\x85\x09\xae\x3b\xc6\x91\xef\x15\x0c\x81\x76\x6c\xcc\x70\x04\x8e\xf5\xee\x18\x7e\xc3\x04\x53\x3c\x69\xa0\x4e\xe8\x3a\xa5\x06\x0e\x1f\x13\xb6\x5b\x3a\xd8\xac\x1a\x3d\x80\x8c\x37\xaf\x50\xe9\xc6\x55\x23\xec\x28\x7d\x1c\x7c\x17\x59\xe1\xa2\x7b\x13\x7b\x4a\xa9\x48\xfb\x34\xb3\xf8\x79\xfd\xf9\xdc\xf9\x45\xe3\xb9\xab\xf9\x05\xf8\xc2\x42\x5c\x84\x4c\xd4\x56\x4a\x59\x79\xdc\x20\x00\x7e\xcc\x52\x20\x53\x71\x0d\xc6\x3b\xab\x70\x3b\x14\xb9\xfe\x7c\xde\x23\x7c\xc0\x06\xfe\xaf\xd0\xd4\xd3\x49\x23\xa7\xe8\x55\x18\x3c\x45\x01\xbb\x61\x2a\xb1\x6d\x2b\xee\xfb\xb7\xdf\xda\x49\xda\x5f\x7f\xd7\xff\x6d\x94\xdb\xf3\x77\x7f\xb3\xfb\xad\x6c\x83\xfa\xdb\xd8\x35\x2d\x24\xb2\xff\xdb\xb5\x4b\xf4\xec\xd2\x40\xff\xcd\xd5\xb7\x62\xc2\x58\xc1\xf4\x5a\xc2\xa5\x3f\x4f\x11\xe7\xe1\xdb\x8a\x7d\xef\xed\x94\x00\xa6\x60\x23\x4a\xa8\x61\x02\x58\x83\x8f\xe1\x10\xd2\x60\x77\x57\xca\xd5\xce\xff\x08\x2c\x0c\x18\x6e\xd6\x23\x46\x4a\x38\xf4\x48\x58\xce\x04\x61\xbe\xfc\x25\xae\x15\xc0\x41\x9d\xdf\x9b\xe7\x76\x76\x58\x0b\xe1\x10\x91\x6b\xe7\x01\x73\xfb\x85\x90\xe6\x17\x61\xfb\x1b\x85\xb9\xe9\x5c\x72\x9f\xd3\xdb\x9e\x47\x81\x45\x12\x43\x96\xe9\xf1\x82\xe4\x5c\x1b\x7a\xcb\x06\x64\x64\xb9\x59\x7c\xb9\x86\xd0\x13\x04\x72\x41\xb2\x94\x94\xc2\xf0\x0c\x7e\xad\xc6\xb1\x53\x8e\xb9\xdc\x70\x42\x74\x09\x15\xc3\x0b\xc5\xfa\x9e\x6f\xba\x56\x4b\x14\xa7\x5a\x4b\x2f\x6c\xf6\x8c\xa2\xb2\x51\xa4\xd0\x15\xe0\x41\x85\x43\xaf\x25\x6f\x30\x3b\x4f\x29\x92\x8a\x57\x02\x30\xf5\x80\x5c\x01\x7b\xcc\xfc\x0d\x33\xea\x3d\xce\x1e\x2a\x58\xc2\xb4\xa6\x6a\xd1\x83\x5c\xe9\x3c\xe4\xd7\x76\x0e\x40\x40\x3c\x72\x2a\x30\x53\xb9\x62\x89\x14\xda\xa8\x32\x31\x58\xba\x6e\xac\xe4\x2d\x13\xc1\xfb\x30\x10\xa6\xe0\x06\x56\xb9\xe3\xc0\xf5\x99\x24\xc9\x8c\x8a\x69\x54\xfa\x25\xa7\x29\xc0\xfe\xdb\x20\x57\xf9\xf5\x58\x08\xd0\x89\x15\x65\xb8\x01\x50\x8c\x2d\xc3\x0a\x56\xdd\x3f\x0b\xe2\x15\xf7\x5e\x65\x76\xb5\x4b\xe2\xd9\x16\xda\xd5\x89\x7e\x91\x8e\x36\xc2\x3e\x48\x09\x7b\x76\x23\xcb\x99\xa1\x29\x35\x74\x07\x57\xb2\xf7\x55\xbd\x3a\x5f\xb2\x1e\x6b\x86\x86\x7b\x4e\xc7\xed\xbc\x80\x27\x0b\x1e\x87\x4b\xc1\x49\x9c\x79\xc8\x43\xfc\xb5\xb1\x38\xe5\xee\x1d\xd0\x43\x0c\xc4\x27\x5f\x10\xcc\x0e\xef\x47\x43\x72\x51\x55\x3b\xac\xc8\x49\xbb\x5b\xad\x8e\x06\x5d\x0b\xfa\x1d\x60\x74\x53\x5d\xbd\x25\x75\x77\xb1\x95\x82\x0e\x72\x09\x26\x0c\x57\x2c\x8e\x4e\x73\xa0\x2b\x05\x22\x79\x03\x88\x00\xe5\x29\x33\xba\x72\x78\x41\x3a\x6c\x89\x8b\xe3\x77\x4e\xfd\x05\x22\xed\x00\xeb\x34\xc8\xd5\x12\x17\x82\x5d\x4b\x47\x67\x2d\xe5\x7f\x10\xb8\xee\x62\xc3\xc6\x0c\xfd\xef\x65\xda\xc5\xec\xdd\x48\x6c\x5f\x0d\x51\x79\x81\xa2\x3f\xaf\x06\x33\x02\x7e\x03\x2e\xbf\x74\x2d\xc6\x0e\x89\xdc\x8c\xce\x77\xb7\x79\x55\x92\x58\x3f\x24\x05\x86\xcf\xf5\xe1\x73\xfd\xd7\xed\x6d\x83\x5d\x1c\x4a\xfc\xd3\xda\xb1\xa4\xfe\x91\x4e\x86\x58\x4b\x52\x46\x1d\xad\xa7\xcd\x8c\xe5\x81\xda\xbb\xeb\xc8\x70\x05\xec\x42\x26\x18\xb7\x74\xe2\x94\xfc\xa2\xc6\xdf\x9d\x1c\x15\xb4\x32\xf4\xf4\x3d\xf2\x6a\xda\xc0\x6d\x82\x0f\x48\xaf\x37\x3f\x6e\x0c\x06\x82\xc5\x6a\x8d\xc5\x7b\x14\x07\x61\xcf\x0a\x66\x0a\xec\x72\x3e\x90\xc1\x22\x96\x92\x59\xc6\x14\x2c\xc1\xa9\x69\x8d\xeb\x78\xc8\x25\x8a\xc6\xe1\x5e\x50\x87\x83\x74\x29\xd8\x5d\x10\x23\xa8\xc6\xac\x2d\xfe\xea\x8c\xb9\x2a\x74\x6b\xc7\x0b\x5e\xcf\x67\x62\x81\x53\xbf\x08\xdb\xb2\x4e\x38\xef\xc5\x15\xdd\x60\x2e\x34\xbb\xa3\x0b\x0d\x18\x5f\x69\x0b\xe1\xfb\x2e\x43\x5a\x35\xf0\x47\x36\xc1\xde\xad\xaf\xd6\x76\xba\x5c\xdb\xe5\x7a\x0d\xe2\x2e\xb9\x68\xe3\xcb\x54\x75\xd8\x58\x85\xa3\xf9\xec\x72\x1f\x07\x0e\x2f\x70\x0f\xdf\xed\x72\xa5\x9e\xf2\xf4\x7a\x08\x43\x78\x69\x7c\x0a\x7f\x78\x5e\x13\x6e\x1f\xc6\xcc\x62\x75\x15\x51\x0d\x18\x12\xf7\x5d\xe1\x92\x50\xa1\xd6\xb7\x90\x16\xd5\x19\xa0\x43\xd9\x2e\xc5\xc0\xa5\x04\xbe\x38\x80\xb4\xff\x54\x2c\x1c\x0f\x37\x33\xae\xd2\x7e\x41\x95\x59\xa0\x7a\xda\xab\x7d\x2d\xb8\xe7\x77\x5a\xf8\x8e\xf7\x42\xed\x32\x0e\xaf\x85\x30\x2c\xde\x97\xde\x73\x86\xff\xb5\x70\x7d\x8c\xf5\xb4\x0f\x00\x58\xb9\x9e\xab\x28\x1e\xde\xeb\x82\x4f\xb6\x9e\x34\x26\x1f\xbb\x72\x8c\xc6\xad\x2d\x12\xfe\xb8\xf2\x93\x8c\x1d\xa8\x03\x47\x07\xe5\xc7\x4e\xa0\x67\x75\x4e\x5a\x95\xea\x8e\xcc\x86\x4e\x2a\xf0\xee\x37\xae\x50\x90\x58\x38\x63\x50\xfc\xad\x78\x80\x70\x2e\xc8\x91\x90\x02\xcf\x0a\xb6\x3d\x46\xef\xa3\x35\xd6\x2e\x68\xe2\x2a\xbc\xd5\x0b\x6c\x46\x67\xd3\xb3\x05\x2e\x52\xbb\x59\x40\xab\x41\x1f\xd2\x65\x92\x30\x16\x34\xe8\xb8\xde\x4b\x75\x96\xdd\x94\x7d\xa5\x48\x2d\x21\x95\x8b\x36\x34\xcb\x2a\xcd\xd5\x81\x4b\x02\x67\xf3\xc6\xc5\x88\xe1\xd5\x42\x73\x9c\x12\x0f\x35\xc8\xd1\x63\xa6\x14\x09\xde\xfe\x73\xb3\xf0\x33\x88\x39\x10\x74\x03\x95\x41\xa3\x42\xcb\x27\x68\xc9\x8a\x44\xff\x00\x4c\x20\x46\xae\x02\x7a\x9d\x17\xb9\xb4\x0d\x96\xf2\x8c\x69\x72\x7b\x47\x55\x0a\x95\x70\x0b\x6a\x38\x26\xe2\xee\xd5\x86\x3d\x8a\xe6\x00\x75\xe8\x63\xe4\x3b\x0e\x0a\x06\x94\xd7\x90\x8d\xcf\x10\x5a\x1a\x99\x53\xc3\x13\x50\x5b\xf9\x24\xb2\x4b\xe6\x21\x6f\x61\xa3\x6a\x1f\xd0\xd5\x50\xff\xfd\x06\xef\x7a\x14\x23\xe6\x4e\x12\x9e\x5b\x99\x80\x42\x01\x8a\x49\x88\x31\xf2\x46\xd4\x4d\x33\xb5\x82\xcf\x77\x60\xc2\x8e\x5a\xa1\x42\x6c\xd5\x25\x0d\xc3\x07\x1b\x69\x30\x0e\xba\x20\x9d\x5e\x83\x65\x13\xdf\xcb\x62\xb5\x9d\x6d\x84\xac\x3d\xbb\x41\x77\xcc\xca\x02\x7a\x23\xca\xea\xc1\xaa\x39\x61\x51\x58\x4d\x52\xae\x1b\x95\x9d\x8f\x52\x25\x8b\xc2\x99\x43\xf2\xe3\xe5\x39\xc1\xcd\x84\x9a\x33\x1d\x95\x2f\x46\x4b\xf8\x94\x89\x50\x7f\xdb\x65\xbb\x80\xd3\xdb\xfc\x08\x78\x76\x91\x28\xf9\xd9\xd1\x59\x56\xcc\xe8\x31\xf9\xe4\x0a\xf5\x04\xfc\x0d\x7e\x7b\xad\x24\x26\x34\xb0\x78\x8b\xe6\x8b\xa8\xd3\xf2\x79\x11\x75\x5e\x44\x9d\x7f\x6f\x51\x27\x38\x8c\xed\x2a\xe6\x7c\x0c\x5e\x92\x8d\xb2\xde\xde\xe3\xa0\x72\xa3\x7c\x78\xbb\x45\xf8\xd6\x03\x53\xc0\xdd\xa8\x0d\xba\x4e\xdc\x03\x73\x0e\xdf\xa1\xf3\x45\x55\xe1\xd9\x44\xfe\x20\x95\x2f\x8a\x95\x36\x4a\xc3\x22\xd0\x3b\x26\xd4\x19\xd6\xb5\xd8\xd2\x13\xac\x2a\xd2\x0f\xc3\xf6\x2b\xf7\x8f\x16\xa9\xc5\xe3\x67\x27\xa8\x93\x7b\x84\x51\xc6\xcf\x33\xf6\x00\x69\x2c\xb6\xbb\x8f\x23\xb9\xa7\x9f\x23\xb9\x8f\xaf\x23\xd9\xa7\xbf\x23\x09\x5e\xd3\xf7\x39\x31\x1f\xbd\xbf\x76\xe3\xcc\x38\xe2\xb4\xe9\xcc\xd4\xa2\xf5\xc3\x38\x5c\xfb\x8a\x75\xee\xb6\x2f\x9c\x01\xb0\x97\xc5\x5e\xb7\xee\xb4\x82\xe2\x83\x57\x7a\xec\x4b\xc8\x8d\x1b\xf1\xfa\xaa\x7c\xb3\x91\x70\xfd\x9f\x17\x98\x66\x07\x4e\x5d\xdf\xf9\x46\x79\xc5\xe2\xe5\x04\xbf\x9c\xe0\xb6\xfd\x9f\xf2\x04\xa3\x5f\x71\x17\xb7\xf7\xba\x5c\x8d\x97\x78\xe4\x87\x92\xa9\x05\x91\x73\x16\xf9\xd3\x40\x12\x60\xcd\x53\xe7\x91\xe2\x6c\x0e\xed\x65\xd9\x47\xe4\xf9\x60\xd1\xb8\xfc\x62\x25\x23\x88\x10\xbb\x07\x2d\x6b\x0e\x55\x0f\x02\x46\x68\x79\xa0\x7b\xe2\x65\xa9\x88\x1e\xb8\xec\x60\xd5\x1b\xd0\xf7\xcf\xae\x2e\x76\x53\x00\xba\xdd\xef\x90\x5d\xee\x78\x96\x16\x7f\xb6\x61\x81\x08\x88\xf0\x4b\xbd\xfe\x51\xd0\xd2\xc9\x2d\x5b\xf4\xdc\x95\xb0\xcb\x6b\xee\x1b\xa3\x67\x43\x3d\x19\x67\xdb\x24\x10\xab\x00\xb4\x03\x55\xdc\x4d\xab\xc6\xa7\x7d\xfa\xc6\x7a\x2f\x0f\x84\xae\xc4\x77\x67\xb2\xdd\x29\xcd\x63\xfc\xd4\x50\xc1\xa5\x26\x05\xc7\x39\xc0\x09\x48\x69\xe7\x9d\x8a\x03\x1a\x80\x23\x35\x50\x8b\xae\x9b\x48\x76\x57\x0d\xf1\xf1\x80\xbd\xf7\x52\x03\x9a\xd6\xbc\x62\x6f\xd9\xe2\x50\xbb\x78\x3c\x29\xf4\x8c\x17\x3e\x8b\x3a\x50\x02\x87\xb9\xe4\x33\x5c\x95\xfb\x21\xf0\xcc\x0f\x45\x8f\x5c\x49\x63\xff\x77\x09\x5e\x33\x68\xc8\x93\x4c\x5f\x49\x03\x6f\x1e\x1d\x58\x38\xdd\x7b\x83\xca\xd9\xf0\x38\x58\xe0\xd0\xbb\x0b\x62\x21\xbc\x37\x06\x80\xc4\x5d\x40\x06\xb0\x72\x4d\x86\x82\x48\xe5\x61\x62\x7c\xda\x5d\xed\x86\xf0\x36\x97\xc8\x60\xba\x62\x0c\x07\x4a\xa9\x6a\x90\xdc\x30\x5c\xb0\xbd\x72\xff\x0b\xd8\x64\xc0\x58\x1d\x5c\x48\x20\x79\x2c\x35\x6c\xca\x13\x92\x33\x35\x85\xc8\xcb\x64\xb6\xfb\x06\x75\xa7\xdb\xf8\xec\x44\xbd\xe3\x0f\x77\xc6\x0c\x60\x75\xef\xc0\x89\xe7\xbe\x0c\x13\x47\x41\x16\x91\xd3\xc2\x22\xc5\x3f\x2c\x27\x80\x7d\xf9\x17\x24\x7b\xd6\x03\x72\xe6\x2b\x70\xc6\xbf\x39\x43\x5b\x3c\x8c\x1d\xc1\xca\xf1\x3f\x94\x7c\x4e\x33\x86\xae\x6d\x54\x84\xbc\x98\x72\xb2\xc4\xa6\x7b\x2e\xe3\xb3\xa5\x52\xe1\xe2\xe4\xe0\x96\x2d\x0e\x7a\x4b\x88\x74\x30\x14\x07\x55\xf8\x73\x0d\x75\x02\x43\x03\x9b\xfa\x01\xfc\x76\xb0\x6f\xce\xfe\x44\xe2\xfc\x0e\x58\xe2\x8c\x40\xe7\x19\xd5\xba\x5b\xe4\xe8\xfa\xfc\x63\xa3\x68\xcc\x2a\x82\xc7\x39\x2c\x26\xe8\x10\xb5\x3f\x5b\x15\xf8\xd1\x77\x77\xae\xe9\x04\xa5\xb9\x2b\x1f\xd2\x3e\xf5\x41\x93\xaa\x86\x01\x42\xa0\xc4\x5d\x1c\x6b\x56\xdd\x49\xae\x81\xd7\x67\xb8\xf5\x90\x93\x38\x5f\x22\xd7\xa0\xe2\x72\x1f\x3a\x21\xa4\x21\x5c\x24\x59\x99\x62\x9e\x47\xe8\x0a\x0a\x72\x57\x91\x7e\x07\xe0\xdc\x03\x79\x3e\x87\x01\xbc\x3c\xe2\x6f\x3f\x97\x7c\x56\x9b\xd7\x54\x70\x35\x18\x6e\x7c\x10\x56\xfb\x5e\xeb\x64\x8b\x87\x60\x3d\x9d\xe5\x79\x5d\xc6\x78\xcb\xc7\x8a\x91\xf3\x19\x15\x82\x65\x51\xbc\xa8\x33\x64\x84\x12\x4e\x20\x78\xb8\xc2\x4d\x87\xf5\xca\x4d\x9e\x8e\x89\x10\x9d\xbc\xf7\xea\xb5\x3f\xee\x42\x4a\x7b\xab\x84\xed\xb2\x1a\xce\xe4\x1d\x49\x25\xb9\x83\x5c\xfe\x73\xcb\x8e\xe0\x26\x52\x7b\x46\x16\xcd\x14\x7c\x03\x12\x99\x17\x4a\xe6\x5c\x7b\x0f\x70\xb7\x71\x7b\x0d\xb0\xcc\xca\x16\x79\x73\xd6\x25\x5c\x79\x7b\x4e\x0c\x55\x53\x66\xec\x30\x44\x94\xf9\x98\xb5\x0e\xff\x7c\x88\x84\x5d\xcf\xbd\x42\xd4\x7e\x8b\x3c\x21\xe8\xbf\xfb\xee\xaa\x73\x29\xd8\x55\x3b\x78\x27\x55\x96\xde\xf1\x14\x2f\xbd\x34\x39\xb2\x03\x1f\x3f\xff\xba\xad\x77\x77\x3c\xbd\x1f\x00\xbc\x67\x8f\x05\x00\x01\x08\xb8\xca\x45\x1c\x72\x4a\xc3\x07\x8e\xc9\x25\xc7\xd8\x18\xfb\x17\x66\x6d\xc9\xc7\x5c\x54\x51\x58\x61\x33\x80\xae\xda\xf3\xe0\xb5\x09\xcd\x0c\x46\x35\x40\x60\x80\x34\x33\xa2\x79\x5e\x66\x86\x0a\x26\x4b\x9d\x2d\x5a\xa3\xc5\xd3\x00\x79\x92\xb1\x2f\x88\xc5\x5d\xf8\x55\xe8\x54\xe7\x5b\x53\x8c\xfd\xf2\x30\x5f\x62\x5c\x95\xbb\x50\x7a\x12\x98\x58\x08\x96\x61\x5f\x58\xe2\x3c\x5b\x8b\xac\x9c\xf2\x2d\xce\xfb\xff\x66\x29\xbe\xab\x24\xca\xa5\x66\x55\x64\x7b\xdb\x22\x26\x4f\x97\x91\xfb\x41\x99\xf5\xcd\xea\xb4\xdb\x29\x2b\x98\x48\x21\x23\x58\x84\xab\x38\xdd\xbd\xc2\xca\x65\xd7\xda\x9d\x42\x5d\x7e\x31\x8a\x5a\x72\x93\x43\x50\xa5\x4b\xd6\xc5\x27\x84\x8a\xf6\xa4\xe3\x79\x64\xc1\x25\xff\x76\x3c\xfa\xc1\x8b\x24\xdf\x2f\xf7\x3a\x52\x51\x87\xf6\xba\xee\xb0\xba\x22\x47\xba\xfb\x4a\xec\x59\x7a\xdf\x5c\xe9\x7a\x45\x7a\xe8\xc6\xac\x5e\x8a\x47\xfe\x28\x12\xa7\x4f\x20\x26\xb5\x4b\x3a\xa1\xb7\xd8\xa3\xa1\xd9\xba\x97\xcd\x62\xc4\x1b\x34\x59\x87\xb7\x11\x49\x87\xdc\x9d\x6e\x20\x17\x57\x43\xb4\x85\x65\xe5\xc2\x55\x0a\xb1\x8d\x58\x3d\x44\x3e\x6c\x6a\xa8\x66\xa6\x9d\x55\x63\xd9\x2d\xcd\x73\x7a\x1c\x05\x13\xb0\x83\x43\xb4\x0f\xcc\x24\xfd\xdf\x39\x99\x40\xd4\x5a\x5a\x69\xc0\x03\xc4\x67\x1c\x62\xe1\x9a\x16\xc7\x48\xed\x36\x24\xd4\xb4\xae\x16\xd3\x8a\xde\xbb\x19\x7c\xfa\xd4\xb9\xa4\xa8\xed\xd2\x58\xf1\x20\xe4\x1b\x28\x05\xff\xa1\x8c\x25\x75\xc8\xcd\x10\xd6\xe8\xda\xef\x6b\x21\xd3\x84\x55\x26\xa2\x0b\xae\x6f\xbb\x24\xcd\xfa\xe6\xfc\xb2\xde\xb9\x8e\xf0\xdf\x9c\x5f\x12\xf7\xb6\x95\x15\xa7\x8b\x19\xe7\xbe\x39\x9d\xa6\x09\xab\x4c\xa3\x29\xd7\xb7\x8f\x5e\xb0\xbb\x48\xaf\xb6\xf9\x19\x3f\xb6\x95\xc9\xe7\x15\x89\x92\xdf\x2c\x64\x49\xee\x5c\x24\xbd\x13\x6a\x6f\x78\x71\x4a\x2e\x85\x2e\x15\xab\x6e\x3f\x9b\xf2\xad\xe5\xa4\xcf\xa9\xb0\xf7\xbd\x70\xe3\x39\x9b\xb9\x0a\xaa\x0c\x48\xb6\x9d\xf3\x88\x41\xaa\x7c\xd7\xd9\x2f\x61\xcb\xd6\x0f\x27\xde\x07\xad\xe7\xa2\x84\x43\xb2\x2d\xdf\xc8\x6e\x76\x94\x18\x23\xde\xde\xb7\x21\x35\x0d\x39\x49\xd9\xfc\x44\xa7\xf4\x75\x0f\x3e\xe3\x43\x59\x4d\x6d\x4e\x54\x93\x83\xd7\x07\x03\x32\xe2\x39\xcf\xa8\xca\x16\xb5\xdc\xc0\x55\x3b\xcb\x02\xfc\x80\x70\x99\xf5\xea\x80\x1c\x49\x05\x23\x27\x54\x90\x8c\xf9\x38\x19\x77\xa0\x16\x28\x02\x1e\x3f\x36\x15\x21\x0f\x6a\x23\x44\x82\xd2\x15\x0d\x3e\x21\xbb\xa9\xa5\x41\xb9\xa8\x28\x36\x17\x96\x8c\x0f\xc8\xa7\x55\xa5\xaf\xe1\x6c\xf8\x16\x4f\x05\xca\x07\xd5\xcd\xee\x59\x37\x7f\x49\xa1\x7b\x3a\x30\x6d\xd7\xea\xa6\xdc\x7c\x64\x85\xec\x24\x00\x60\x97\x86\x25\x8c\x1b\xfb\x42\x6a\x0e\xf9\x32\xa9\x81\xea\xb3\xca\xf0\xa4\xcc\xa8\x95\x89\xd1\x0e\x36\x20\x17\x97\xd7\x1f\x2f\xcf\xcf\x6e\x2e\x2f\x4e\x89\x1f\x89\xc7\xd2\xda\x80\xdc\xc4\x59\x84\x22\x97\x57\x97\xaa\x25\x7c\xab\xe7\x88\x0f\x15\x55\x1a\x42\xc8\x0d\x41\x05\x19\x0a\x6e\xaa\x2c\xbd\xe8\xa4\x95\x49\xe1\xdc\xae\x6c\x6f\x67\x87\x9b\x72\x74\x9d\x10\x6e\x30\xfb\x73\x7d\x34\x38\x1d\x98\xf1\x33\x4c\x65\x8b\x16\xf7\x00\x92\x43\x05\xdc\x7d\xc9\xee\x3e\x31\x67\xc7\xe3\x71\x83\x06\xf6\x2a\x37\x2a\x52\xfc\x90\x0e\xdc\x67\x45\x59\x51\x28\x99\x58\x5e\x72\x38\x38\xf4\x82\x42\xb6\x94\xfa\x3d\x0c\x1a\x27\x7e\xaa\xe3\xd6\x80\x90\x0f\xde\x85\x19\xa2\x56\x57\x67\x91\xc7\x54\x02\x51\x2e\xf2\x06\x86\xfa\xd2\x00\xe5\x38\xfe\xa8\xcb\x14\x35\xe5\x73\x26\x70\x61\xfb\x25\x48\xfe\xf3\x1d\x61\xfe\xb1\x9a\xf7\xa7\x8f\xef\xf6\x3b\x25\x3c\x67\x1d\x27\x74\x2e\xf3\x1c\xf3\x07\xcd\x42\xf4\x59\x15\x40\x16\x4e\xfb\xde\x14\x16\xcc\x84\x34\xd9\x82\xd4\x0d\x3a\xe5\x3b\x35\x14\x94\xf0\xda\x79\xe3\x8b\x4a\x4e\xed\x9e\xe6\xd7\x25\xdd\xd2\x3e\xa5\x86\x23\xd9\x27\x61\xc6\x27\x1f\x2f\xcf\x2e\xde\x5f\x0e\xf2\xf4\xd1\x49\x06\x13\x69\x21\xb9\x30\x7a\xbb\x5a\xb2\xad\xa8\x49\x7b\xb2\x12\x3e\xda\x95\xeb\x5e\xfa\x8e\xb1\x8b\x83\x1f\x2d\xca\x55\x96\x32\x43\x79\xa6\xa3\x7d\x34\xb2\x90\x99\x9c\xae\xce\xf9\xdb\x61\x83\x7e\x86\x99\x47\xfa\xb4\x6f\x77\x7e\xbf\xf2\x7a\x9b\x52\x0d\x75\x78\xf8\xd2\x0c\x90\x63\x30\xac\x35\xc8\xc1\x50\x51\xe1\x99\x2e\xf7\x41\x04\xaf\x25\x18\xa0\x36\x08\x87\xd8\xa7\x71\xab\xf2\xa2\x45\x65\x52\xda\x4a\x64\x0f\x0d\xba\xed\xc2\x98\xa5\x41\xdb\x6b\xe1\xd4\x61\xf6\x07\xd7\xa7\x4e\xe4\x0a\xc5\xfa\x21\x91\x0f\x54\xef\x90\x2a\xe2\xae\x31\xcd\xf3\x86\x17\x6f\xa6\xc1\x56\xd9\xa2\x69\x80\xa9\x64\x9f\x60\xb5\xc2\x38\xf4\x2c\x5b\x54\xa9\x01\x9d\x2a\x4c\xa7\x98\xa0\x47\x39\xfb\x6d\xa1\xf8\x9c\x67\x6c\x0a\x49\x40\xb9\x98\x46\xb5\x14\x7d\xc4\x3a\x24\x87\x67\x4b\xf3\xb2\x5b\xa5\x4d\x9c\xfa\x19\xf0\xe2\xea\xc3\x0d\x24\x96\x85\x4b\xc1\x7b\x0b\xd8\xf6\x83\x50\x68\xa4\xdf\xef\x83\xde\x7f\xf4\xbd\x95\x15\xd3\xec\x98\x7c\xc7\xdc\x77\x24\x24\xbf\x55\x50\x6d\x66\x26\x43\xf6\x51\x98\x6b\x05\x59\x40\x47\xbc\x34\x77\xad\x4e\x6c\x4b\x2b\x18\x21\xbb\xa9\xb5\x87\xe2\x9a\x98\xce\x0f\xef\x7b\x1e\x5f\xae\xdc\x23\xe9\xdf\x99\xca\x79\xab\xe8\x2a\xfc\x0c\x37\x32\x85\xa3\x87\x94\xe8\x45\x9e\x71\x71\x5b\x65\x8c\x9a\x48\x8b\x43\xe8\xa3\xcf\xc5\xad\xc7\x58\xc5\x68\xb6\x9e\x52\xee\x82\x1f\x7b\xa5\x92\x66\x07\xe3\xdd\xcd\xa2\xc0\xbb\xf0\x70\xec\xdd\x55\x6f\x4c\xe2\x0e\x0e\x9e\xdd\x7a\xb9\xee\x56\x69\xfd\x70\x38\x3a\x1f\xd5\xaa\x84\x5a\x9d\x0e\xde\x3d\xa6\x71\x79\x1d\x4b\x80\xe5\x3c\xa1\x64\xc7\x7f\xd8\x76\x53\xdb\x27\x59\xb9\xbd\x0d\xba\xf9\x5c\x4b\x65\x68\xb6\x27\x22\x90\xcc\x68\x71\x56\x9a\xd9\x05\xd7\x89\x9c\xb3\xce\xaa\xce\xdd\x0c\xb3\xf6\xfa\x84\x71\xdc\x6f\x3a\x8e\x46\xce\xff\x70\x76\x4d\x68\x69\x77\xd1\xb8\xb4\x92\x7b\xbd\xe2\xf6\xf3\x1f\xa1\x43\xfd\x5e\x66\xef\xc6\x7a\xf0\xb9\xbf\x5c\x08\xec\xf1\x42\x00\xce\xf8\x73\xbe\x04\xe0\x82\x1b\x4e\x8d\x6c\x59\xcb\xaa\xae\xbf\x97\xda\xc8\xdc\xa1\xe7\xd0\x0f\x04\xb7\xb2\xc0\x70\x6b\x63\xd7\x73\xf4\x83\xa0\x0d\xc0\x19\x0a\x2b\x16\xd3\x84\x35\x3c\x00\x7b\x90\xb9\x11\xc7\xe6\xa1\xcd\x6f\x9d\x67\x26\xa4\x7c\xca\x7e\x77\x5a\xcb\xa4\xbd\x54\x08\xc1\x1b\x15\xaa\xe4\xfa\x7b\xb5\xc4\xf0\x1f\xba\x9e\x6c\x67\xf6\xc2\x55\xfd\x6f\x49\x33\x84\xc6\xd5\xbe\x6d\x44\x75\xc8\x76\x9c\xa4\xdf\x4f\x0f\xf3\xab\xa0\x35\x97\x1a\xb3\x45\x61\x0b\xa3\xa8\xd0\x76\x23\xea\xba\xd1\xa1\xbb\xda\x39\x24\x47\x26\x29\x5a\x97\x6b\x7f\x20\xcf\x6c\x9c\xaa\x83\xfb\xbb\xe0\x91\xdd\x76\x56\x0f\x72\xdb\x02\xb8\xdb\xd5\xb4\x51\x5b\x08\x32\x5b\xf2\x8e\x6b\xe3\xd3\xe2\xc3\x0b\xae\x5d\x4e\x57\x90\x74\xae\xad\xea\xc4\x8b\xbf\xd2\x34\x55\xa7\xc8\x49\x7c\x49\x5d\x05\xf2\x8e\xcf\xbb\x44\x45\xb8\x8f\x3b\x32\x8b\xc2\xa5\x66\xbb\x39\xbf\x26\x58\x15\xe3\x37\xbf\xc2\x72\x9e\xff\xf9\xcb\x5f\xbd\x6a\xbd\xa1\x4f\xe7\xfe\xbc\xa3\xe5\x60\xef\x37\x36\xcf\xc2\x6b\x0e\xc4\x05\xf4\x97\x03\x7a\xe8\xce\x2e\xe2\x91\xdd\xd4\x40\xa5\x77\x13\x2a\x5e\x3c\xcc\x9e\xd4\xc3\x8c\x84\xa0\x07\xa4\x09\xf7\xa7\x2a\x48\x50\xae\x9f\x1f\x41\xd9\x0a\x8b\xed\x58\x53\xc7\x16\x3c\xbf\x56\xbf\x8b\x6e\x9f\xc0\xe7\xfa\xe2\x6a\xf4\xd7\x77\x67\x6f\x2e\xdf\xc1\x2c\x9d\x5f\x95\x45\x03\x2e\x76\xf6\x23\x6a\x8f\x56\x6d\x34\xc1\xed\xc0\xe8\x76\xcf\x71\xf5\x76\xd4\x50\x94\xed\x9b\x8e\x97\x1b\xf7\x95\x96\xc5\xa4\xd5\xda\x1f\xd7\x74\x05\x65\x23\x98\xda\x5f\x88\xc3\xce\x16\xae\x28\x25\x53\x4d\x19\xb2\x3b\x85\x33\xbc\xb7\xbe\xb2\x75\x07\xc8\x33\x30\xe2\xdb\xf5\x22\x0c\xf6\x6e\xbe\x7f\x20\x58\xb5\x65\xf1\xaa\x7b\xec\xcb\xe1\x08\x7a\xf9\x4b\x1e\x7b\x48\xd1\x23\x47\x59\x7a\x6d\x29\x35\xd3\x21\xc9\xfd\x33\xc5\x94\x62\x55\x46\xdc\x2e\xd4\x6b\x65\x4a\xdd\x5a\x3d\xa8\xda\xc5\x46\x2d\x62\x60\x5d\x0e\x69\x7f\xb7\x4f\x9d\x7a\xa9\x0b\x9a\xec\x35\xf3\x63\xf5\x0a\xdf\x40\x48\xf5\xe3\x13\x40\xf8\xec\x1e\x1d\x4a\xc3\x78\x5d\x11\xf9\xdc\x77\x6c\x06\x72\x75\xda\x21\x5f\x4f\xa1\x90\x3e\x48\x2e\x8e\xf8\x7a\xe2\xed\x23\x8f\x42\x3d\xbf\xdb\x51\x75\xd9\xb7\xda\x52\xcc\xa4\x91\x62\x67\x27\xf1\xeb\x15\xdd\xeb\xe7\x18\x5b\x9c\x57\x45\x42\xa2\x0a\x7d\xe0\x61\x18\x0c\xfa\x56\x8c\xf3\x5c\x42\x0a\x6f\xda\xaf\x1b\xf6\x1f\x5d\xf2\x48\x87\x17\x7b\x3a\x73\x3f\xa6\xe0\xc3\xae\x26\xd8\xbd\xba\x50\xa4\x9d\x23\x2e\x86\x17\x4e\xee\xf2\x51\x15\xda\xa1\x1d\x59\x8f\x77\x7b\xe3\x8b\x52\x99\x3b\xa9\xba\x87\x1a\x5f\xd7\x3a\x36\x6e\xf5\xdd\x6f\x4b\xd1\x44\xcf\xf1\x8c\xe0\x1c\x9f\xf8\x9c\x8c\xe0\xc2\xb4\x91\x2b\xba\x79\x32\x82\x17\xfb\x03\x1c\x9e\xa7\x3d\x34\x3b\x72\xa1\x87\x0d\x49\xdd\xab\xe0\xed\xb1\xac\xe3\x0a\x3f\xbb\x6e\xce\x40\x60\xf7\xa6\x22\x12\x34\x1c\x42\x37\xfc\xde\x88\x82\x92\x58\xb7\xaf\x03\x3d\x18\x1a\x96\x63\x81\x5f\x9a\x65\x16\x96\x52\xc4\x69\x83\x5d\xd8\x69\x8f\x60\xe6\xdd\x9c\x16\xbe\x5a\xb2\xbc\x13\x77\x54\xa5\xe4\xec\x7a\xb8\x9f\xa3\xdf\xc1\xb5\x18\xf1\xa7\x5d\x26\xa8\x7a\x59\x45\x99\x32\x32\xe6\x46\x57\x05\xcf\x98\x89\xb5\x41\x4b\xde\xc2\x1d\x91\x3d\xa4\xf6\x40\xba\xef\x45\xdc\x4f\x10\x99\x18\x9a\x35\x0a\xd0\xbf\x7a\xf5\x0a\x8d\x57\xaf\x7e\xfd\xeb\x5f\x63\x11\x9a\x94\x25\x3c\x5f\x6e\x08\xad\xfe\xeb\xf5\xeb\x01\xf9\xe3\xd9\xfb\x77\x50\x10\xaf\x30\x1a\xd3\x5d\xe0\xc8\x58\x92\x3b\xea\xac\x7b\xe4\x7f\x46\x1f\xae\xaa\x52\x1a\xf5\x5f\x5d\x35\x63\xb7\xbc\x01\xb9\x88\x5c\x80\x62\xf3\x14\x35\x33\x57\xfb\xc5\x10\x3a\x99\x60\x99\xc7\xb1\xaf\x32\x8a\x47\xca\x47\x36\x43\x49\x66\xac\xd1\x60\xb7\x3f\x03\xdf\x24\xab\x48\xa3\x31\xcf\x07\xd7\xa3\xab\x15\x8c\x15\xe8\x1f\x4c\xa5\x87\x45\xbd\x27\x1a\x2a\x35\x54\xa9\xe0\x14\xd3\x56\xa6\x74\xa5\xe7\x70\xb0\x30\x75\x3b\x89\xa7\xbc\x83\x69\x5d\x41\xa0\x86\x58\x3e\x71\x6d\x55\x1d\xfc\x7b\xbc\x56\xdc\xe6\x1c\xfb\x40\x77\x22\x75\x9e\x1f\x66\x83\x7b\xe5\x42\xd6\x03\xb9\x20\x34\x93\x50\xe5\x28\x6c\x6d\xc5\x8f\xa2\x2a\xe3\xdb\x97\xd2\x39\xf3\x5e\xd7\xec\xab\x48\x85\xde\xd3\xd6\x35\x4e\xea\x26\xed\x28\xb4\x9f\x8e\x65\x69\xfc\x15\x30\x8e\x89\xe5\xfd\xb0\xc6\x74\x87\xcc\x81\x3b\x24\x1b\xdc\x25\xe9\x6c\xe7\xbc\x95\x75\x32\x5f\x13\x02\x7a\x84\xd1\x64\x46\x6e\xd9\xa2\x8f\x84\xa9\xa0\x10\x8d\x12\xaa\x48\xb9\xdc\x8e\xf5\xfb\x92\x84\xa5\x56\xb2\x75\xc0\xf2\x37\xea\x15\x16\x85\x68\x16\x2f\x3e\x6a\x27\xe9\xb8\x9c\x91\x22\x52\xe0\x7d\x62\xe2\xa8\x0e\x6b\x48\x12\x89\x45\x98\xeb\x51\x17\xf6\x7c\xb1\xd4\x76\xd3\x9b\xbe\x5c\xb9\x11\x58\x42\xe7\x58\x55\x29\x96\x7a\xbb\xa2\xc3\x4e\x6c\x83\x0f\x52\x9f\x8a\x37\x72\x45\x80\xd2\x66\xae\x9c\x8d\x6b\xeb\xa1\x14\x00\x51\x8b\x0a\xd1\xcc\x94\x0e\x34\x58\x37\xa9\x14\x19\xd3\x9a\x70\x58\x61\x4e\xd5\x2d\xf3\x49\x49\x68\x36\x20\xd7\x76\x92\x21\xf3\x11\xe6\xc0\x9d\xa3\x1b\x99\x3d\xa3\x71\xb8\x8b\xfd\xc8\xe1\x60\x70\x88\x14\x7c\x45\xf0\x4b\x07\xcc\xd8\x2d\x81\xea\x0e\x89\x53\x1b\x25\x8d\x0b\x8d\x69\x60\xad\xd4\x06\x69\x8e\x25\x44\x71\x99\x99\xe7\x50\xb4\x75\xfa\x9d\xe5\xe5\xec\x90\xed\x73\xd7\x24\xd5\xbb\xa4\xa8\x6e\x75\x9d\x50\x7f\x76\x4f\x4d\xbd\x53\x62\xea\xa5\xda\xca\x6e\x8b\xdc\x31\xeb\x9e\xa9\xf7\x1e\x89\x94\xf3\x4e\x49\x3e\xfd\xb3\x2e\x27\x4c\xde\x46\xea\x73\xd5\xca\x32\xf6\xa3\x12\xf3\x86\x93\x55\xb5\xb6\x7c\xb8\x5b\x25\x27\x07\xa2\x69\x21\xf0\xf4\xf2\x5d\xb7\xea\x1c\xa4\xb3\xc0\xd7\x7c\xba\x08\x80\xcd\xa7\xdd\xa5\x5c\xf3\x59\x3a\x4d\x81\xba\x17\x91\x4b\x3a\x80\xd2\x48\xc8\xc4\x6c\xc2\x91\x1b\x40\xf9\x77\xc7\xa3\xa8\x95\x55\xb4\xcc\x4a\x13\xc2\x72\x56\xb0\x06\x18\xd4\xe7\x6d\xc6\x60\x48\xdf\x2c\x62\x14\xc0\x22\x91\xfe\x76\xe5\x19\xf8\xec\x74\xa4\xbb\x56\x18\xfb\xc9\x3a\x6e\xdc\x03\x86\x5e\x66\xd8\x19\x8e\x23\x97\x0d\xc1\x7b\x10\xd7\x64\x18\x70\xde\x30\x1a\x05\x24\x2f\x8e\xb8\x4a\x3d\x9d\x57\xd6\xce\xb0\xe2\xa6\xe8\xac\x08\x67\xd7\xc3\x3d\x4a\xf4\xd1\xa8\x3f\x69\x99\x1e\x4c\x37\xb5\xba\x29\x17\xd5\xca\x9d\x81\xd7\x52\x98\x67\x2f\x1a\x2e\x4d\xfb\xad\xa5\x8b\x91\x59\xb5\x91\x94\xcd\x95\x70\x0f\x14\x34\x4a\xe4\xe6\x2f\xf8\xe0\xbc\x3e\x77\x31\xf2\x11\x45\x42\x80\x47\xa7\x02\xd0\xfe\x59\x2e\x41\x06\x8b\x25\x23\xa8\x4d\x82\x3a\x5e\xa4\x2c\x16\x32\x3d\x75\xa5\x72\x85\x90\x58\xf5\x4b\xf7\xb0\xb8\x89\xee\xa1\x12\x68\x05\x85\xe8\x5a\x56\x45\x06\xf0\x9d\x45\x83\x9d\xca\xd4\xdc\xa7\x50\x8d\xdd\x40\x58\xf9\x75\xd7\x5d\x24\xf7\xac\x3b\x43\x22\x2e\xb4\x5b\x25\x8b\xba\xb1\x1a\x47\x0a\x75\xac\x93\x19\xcb\x29\x26\x85\xf3\xcb\xb3\x54\xe6\x4e\x71\x63\x18\x66\xf5\x61\x2a\xd7\x44\x4e\x7a\xb5\x0a\x71\x07\xf3\xd7\x07\xbb\xd4\xf3\xb8\x67\xc9\x15\x52\xed\xc2\x1e\x80\x71\x5d\x93\xce\x2c\x5e\x83\xba\x90\x41\x26\x47\xd1\x30\x32\x58\x06\x33\x47\xe8\x3d\xfa\xc2\x9f\x52\x45\xea\x05\x21\xe1\x45\x45\x7a\x51\x91\xf6\xa2\x22\x45\x8c\xc5\x13\x1c\x07\xa8\x58\x6d\x8a\x33\x4a\x79\xdd\xa9\x8a\xea\x89\xb2\xc4\x58\xd4\xf4\x5a\x93\x54\x75\x2b\x9a\x55\x7d\x0e\xbd\x2e\xe5\xf0\xb8\x34\x93\xfe\x6f\x08\x13\x89\x4c\x71\xf3\xed\xf8\x4a\x1b\x10\x6d\x2a\xf5\x23\x9e\x4b\xee\xbf\x15\x5b\xe2\x60\xec\x5d\xb7\x6e\x27\x3a\xe0\xef\xea\xde\xee\x89\xc1\x57\x6c\x3d\x04\xc1\xba\xe5\x87\x18\x79\xc7\xdf\xab\x5b\x42\xac\x05\x0c\xc8\xed\xcb\x9c\x92\x23\x7c\x39\x48\x8a\xb2\xe7\x1a\x0c\x72\x96\x4b\xb5\xe8\x85\x46\xf6\xc7\x5a\x2f\xd7\xe2\x18\x64\x82\xa4\x54\x56\xd9\xcb\x16\x3f\x56\xe9\xc0\x03\xe8\x91\x85\x83\xb0\x4f\xdd\xaa\xc1\xc4\x4f\xc3\xfd\x2e\x24\xba\x02\x55\xbe\xaa\x8e\x33\x09\xc9\xf7\x74\x2f\xa8\xa8\xf0\x96\x89\x39\x99\x53\xd5\xa1\x74\x75\xfc\xdc\x53\x1e\x48\xf9\x9c\xeb\xdd\x0a\xd6\xad\xd4\x9a\xb9\x4b\xeb\x25\x4b\x53\x94\xc6\x51\x4a\x7f\x2a\x7c\xa8\x77\x38\x0d\x0d\xa1\xe8\xf5\xc1\x4e\xd3\xf8\xd1\x14\x85\xc5\x67\xc7\xd2\xb0\xf8\xdc\xb7\x40\x6c\x7d\x94\x9d\xd1\x66\xaf\xe5\x9e\xfd\xe3\xd1\x62\x1f\xe7\xb0\x62\x91\x55\x7e\x02\x2f\x9c\x3e\xd2\x41\x43\x7f\x90\x3d\xda\x6a\x5c\x22\xf4\x9f\xb2\x99\x66\x4f\x57\xaf\x2e\x52\xef\xdf\xfc\xde\x75\xe4\x72\xe2\xbf\x5c\xba\xb6\x42\xbe\x97\x4b\xd7\x97\x4b\xd7\xb6\xcf\xcb\xa5\xeb\x8b\x45\xa1\xfe\xfc\xa8\x2d\x0a\x2f\x97\xae\x2f\x97\xae\xf7\x83\xe1\x83\x5c\xba\x3a\x31\xae\xba\x71\x7d\xd4\x0b\x57\x57\xd6\xe5\x2c\x49\x64\x29\xcc\x8d\xbc\x65\xad\x6f\x10\x5a\x09\xf3\x4b\xa3\x3f\x9e\x64\xdf\x5d\xb0\xe8\x24\x1e\xec\x22\x18\xd0\x32\xe5\x56\x78\xdf\x19\x81\xce\xdc\x00\x5e\x4e\xb7\xa4\x58\xa4\x2c\x0d\x23\xfb\x43\x6a\x2c\xac\x07\xe4\x8c\x28\x96\xf0\x82\xbb\xea\xdd\x14\xdf\x23\x86\x85\x2c\xfb\xdc\x68\x96\x4d\x5c\xb6\x73\x11\x17\x85\xa9\x44\x70\x47\xe1\x56\x7e\x06\x79\x8e\xf4\x49\xb2\x7d\x85\x1c\xc5\xbe\xf7\xcc\xca\xcd\xe6\x26\x1e\x21\x36\x8a\xc0\x52\x6a\xb5\x68\xe0\x63\x05\x77\x11\xc8\x0f\x7d\xb0\xd9\x97\x82\x2b\x40\xde\x11\x4b\xa4\x68\x53\x11\x73\xcd\x06\x5d\x36\x47\xf2\x3b\xe5\x2c\x9a\x58\x00\x3f\xd4\xbd\x9c\xd3\x8c\xa7\xdc\x2c\xc2\x5d\x9b\xab\xb2\x44\xf1\xc4\x84\x6d\xd4\x15\x18\x09\x2d\x0a\x25\x69\x32\x63\x3a\x9a\x37\x8a\x1c\x2e\x10\x2b\x78\x9d\x63\x25\x30\x90\x3a\xa0\x8f\x65\x7d\xd9\x82\x28\x69\xfc\x75\xf9\x9a\x0f\xde\x44\x83\x41\x77\xe4\x5f\x46\x2d\xe0\x4e\x5d\xc6\x43\xe0\xac\xf8\x24\xfe\x43\x13\x99\xa5\x3e\xbf\xc7\x6f\x5e\x59\x31\x2f\x71\x38\x68\xa9\x1c\x64\x80\x30\x92\x64\x96\x15\x5b\xca\xb7\xbe\xf3\x2f\xbf\x26\x33\x59\x2a\x3d\x88\x83\x84\x5e\xc3\x3b\x54\xd1\xbc\x98\x68\x48\xc6\xa8\x36\xe4\xf5\x2b\x92\x73\x51\x5a\x0e\xd4\x19\x6d\xba\x4b\x36\x91\x4c\xf3\xab\xaf\x5b\xf7\xeb\x2a\xcd\x2c\xdf\x48\x3a\xac\x2a\x30\x13\xaf\x13\x6a\xdc\x49\xc2\xe0\x32\xcc\x63\xdd\x10\x71\x1c\xd1\x8d\xa1\x2d\x8c\x7c\x80\xf3\xf5\x43\x29\xc7\x0b\xd3\x25\x10\xf1\x7f\xb1\x47\x3d\x02\xd1\xbf\x6c\x93\x5d\xa4\x4a\x2e\xb2\xf1\xa3\x0f\x52\x2b\x61\xca\xb5\xd9\x52\x29\xa1\x8a\x51\xdc\xd8\xac\x3d\x5b\x99\x5a\x79\xbf\x63\x58\x0a\xe8\x08\x5e\xd6\xf5\xe6\xa1\x24\x61\x58\xd3\xf0\xa2\xaa\xb4\x23\x24\x8e\xbf\x75\xf8\x27\x4e\xb6\xe5\x11\x64\x0f\x39\xba\x5b\x2e\xb5\x9d\x74\xe5\x51\xa2\xf3\x5a\xb1\x5b\xfd\x14\x68\x2e\xa6\x98\x52\x3b\x2f\x33\xc3\x8b\xac\x5a\x77\xe8\xe0\x08\x79\x6c\x36\xa3\x91\xa5\x87\x62\x70\x2e\xa6\x62\x02\x13\xe3\x51\x18\x8b\x09\x83\x99\xa1\x95\xe5\x07\x05\x55\x34\x00\x0f\xea\xa6\xea\x63\x67\x81\xa3\x70\x0f\x88\x94\xc7\x92\x73\x45\xb3\xb0\xd0\xf8\xee\x67\x9f\x48\x63\x98\xa0\xa2\x85\x81\xb9\xae\xea\x41\x27\x22\xef\x82\x0b\x18\x56\xd8\x68\x60\x8b\x13\x6a\xde\xd0\xe4\x96\x89\x14\xcb\x0f\xc1\xb2\xd3\x85\xa0\xb9\x4b\x45\x15\xd5\x54\x6e\xf4\xd7\x3d\x67\x6a\xc0\x48\x39\x1f\xaa\x8b\x5c\x77\x9f\x30\x28\x75\xe7\x5c\x2f\x9f\x34\xd6\x32\xde\x74\xce\x35\x1a\x61\x14\x9f\x27\xcc\xf3\x7f\xfb\xa9\x7d\x4e\x7d\xde\x22\x1e\x7d\x69\xf2\xce\x55\x91\x47\xf8\x0b\xe4\x3e\x18\xbf\x21\xeb\x14\xcd\xec\xd1\x5e\x84\xf0\xcc\xc6\xe6\x8e\x17\xfb\x2d\xa8\xa2\xc6\x5d\xc2\x68\x0f\x3f\xbe\xb9\xa8\x1f\xe2\x8f\x34\x95\x9a\xbc\xc9\x64\x72\x4b\x2e\x18\x08\x5d\x0f\x59\x10\x44\x8d\xd3\xa7\x4c\x18\x9d\xd3\xe9\xb6\xdb\xb1\x3e\xc9\xa5\xe0\x46\xaa\xcd\xf4\xe2\xa5\x3e\xe1\x93\xa4\x23\x56\xe3\xf4\x59\x27\x23\xb6\x08\xb6\x4b\x35\x42\x05\xc7\x10\xba\xfb\x5c\x7e\x3b\x1e\xaa\x9f\xcd\xe4\x5d\xdf\xc8\x7e\xa9\x59\x9f\xb7\xb8\x6f\xed\xb0\xba\x5b\xb6\x80\x4b\xe6\x8e\xeb\xfb\x16\xbb\xd5\x94\x03\x23\xc1\xa6\x04\xef\x2d\x8b\xfe\xf8\xe6\xc2\xf2\x86\x41\x2c\xec\x9d\x30\x93\x9c\x24\xac\x98\x9d\xb8\x0f\x3f\x4b\xa0\x78\x6a\xd1\x15\x2a\x67\x24\x91\x59\xe6\xe2\x9d\xe5\x84\x9c\xb3\x62\x16\x06\x7b\xec\x95\x3e\x5d\xaa\xdb\x42\xca\xae\x29\x3f\xa3\x03\x63\x7b\xbb\xf3\x12\x21\x8e\x1a\x77\xab\x63\xf0\x58\xa8\xf2\xac\x2b\x31\x3e\x20\x70\x1e\xb8\xaa\x7e\xad\x96\x7e\xec\x7a\x59\x4f\x07\xec\x7d\x38\x6a\xe4\x66\x38\x41\x49\x3a\x65\x29\x91\x73\xa6\x14\x4f\x99\x26\x81\xde\xc4\xaa\x27\xcf\x1e\x1b\x6e\x2f\x99\x89\x9f\x3c\x33\xf1\x0e\x3a\x4e\x44\x9e\x6c\xef\x65\xf2\x44\xd3\x9c\x8b\x67\x47\xa0\x74\x42\x33\x36\xfc\xd0\x41\x99\x18\x61\x8f\xba\x3e\xe1\x5f\x46\x09\xc5\xb6\xa4\xe9\xfa\x36\xe0\x0b\x11\x32\xdd\x66\x1f\x7d\x00\xad\x60\x4a\x0d\xbb\xdb\xca\xfe\xfa\x15\x81\xda\xde\x12\xe4\xce\xa7\xd4\x1f\x9e\x28\x35\x5e\x84\xe5\x98\xf7\x6b\x9f\xec\xd3\xed\x53\x57\xa3\x8b\x5f\x48\x23\x93\xac\x47\xd4\xb3\xeb\x21\xf9\x06\x47\xde\x6f\xa6\x3e\x25\x0d\x4a\x77\x17\x32\xa7\xbc\x73\xa1\x8d\x59\xbd\x30\xb5\x9f\xee\x75\x18\x96\xe0\xb8\x71\x8d\x90\x09\x9f\x96\x56\x03\x73\x5a\xd3\x4b\x12\xb5\x47\x11\x40\x2a\xf9\x23\xb2\x04\x79\x8f\xc3\x4a\xe6\xf0\x3b\x08\x4c\x21\x5c\x4d\x12\xcd\x84\xe6\x70\x4f\x12\x5d\x56\xbb\x72\x6f\x58\x5f\x10\xdd\x0b\x51\x48\xe9\x91\x77\x72\xca\x85\x3f\x95\xd2\x5d\xa3\x4d\x28\xcf\xda\x02\xe3\x45\xaa\x78\x72\xa9\x42\xeb\xec\x52\xd0\x71\xd6\xc6\x0b\xa0\x4e\xd6\x33\x0a\xf7\x9c\x0c\x7a\x9f\xa4\x5c\xdb\xff\x93\xd1\xe8\x1d\xd8\xc4\x4b\xe1\x65\x5d\xb0\x17\x3b\xb2\x16\x3c\xfd\xf1\x00\xee\xf7\xcc\x20\xa5\xd9\x21\xc7\xdd\x50\xa4\x76\xb2\x4c\xd7\xdc\x4e\xdc\x78\x98\xe9\x2f\x78\xce\xe2\xcd\xfd\x98\x91\x9b\x19\x4f\x6e\xaf\x23\xd3\xb7\x54\xf6\x9d\x88\x5e\xd5\x98\x50\xf3\xb7\x7d\x12\x44\x37\xd5\xeb\xee\x0a\xec\x4d\x44\xcf\x47\x6e\xc1\x76\x18\x42\xb5\x96\x09\xaf\xee\x39\xc0\x5c\x52\x11\xfc\x14\x08\xfe\x7e\x17\x01\x3c\xfd\x9e\xbc\xc9\x6f\x9a\xaf\x7a\xaa\x63\x5e\xc4\x85\x5f\xeb\x5e\x27\x8e\xa8\xb1\x43\x96\xee\x9b\x5a\x5e\x6e\x2f\x9b\x36\x8c\xf6\xde\x8b\xdb\x6d\x92\x97\x92\x7c\x95\xc5\xa5\x6d\x0a\xf9\xb9\x5d\x5e\xbe\xbd\x2d\xb5\x4d\x20\xc3\x2a\x6d\xb8\x71\x53\x87\xef\x9c\x19\x1f\x0e\x53\x21\x8b\x32\x43\x5f\x89\xfb\x27\x17\xf7\xd6\x59\xfc\xce\x9e\xcc\xfa\x8f\x91\x68\xb3\xab\x23\xf0\x4f\x23\xe7\x66\x24\x92\xbd\xfa\xd5\xd7\x5f\xff\xd8\xb3\x70\xb6\x55\x81\x1f\x22\x0d\x67\x4b\x93\xe8\x4b\xa4\xcd\x4b\xa4\x4d\x8c\x8a\x0f\x99\x46\x75\xcf\xb1\x34\x1d\x5d\x5c\xbb\xb9\xb7\xb6\x8f\x96\x69\xed\x04\xdb\xd5\x01\xb6\x43\x3c\xcc\x9e\xa2\x60\x3a\xfb\x82\x76\x89\x78\x79\x89\x73\xf9\xa9\xc5\xb9\xec\xe2\x03\xda\x3d\xa6\xa5\x8b\xef\xe7\x4f\x29\x7e\xa5\xc3\x61\x6c\x1f\x67\xd1\x3d\xba\xa2\x7b\x3e\xbb\xee\x96\xad\x5d\x4a\x1a\xc5\xf6\x19\xa7\x45\x54\x15\x04\x7d\xe1\x41\xcc\x8f\x65\xa4\x3d\x58\x8f\xa2\x43\x90\x0e\x0a\x14\x0e\x2f\xbb\xd4\x12\x74\x3a\xf9\x87\x51\xe3\x6a\x23\xbc\x7e\x9a\x1b\x8d\x9f\xe6\x95\xc1\x4b\x61\x90\xe7\x6d\xd3\xd6\xb5\xdc\x22\xde\x92\x00\x67\x1d\x18\xb1\x1c\xc7\x39\x0d\xab\x33\x72\x76\x3d\xb4\xea\x32\x84\xcf\xd0\x4c\x0f\xc8\x0a\x3e\xed\xed\x92\x8e\xaf\x7b\xfe\x4c\x8d\x61\x79\x61\xda\x6f\xf6\x8b\x49\xfb\xc9\x4d\xda\x3b\xdb\xe3\x3e\x87\x8e\xa1\x02\x64\x99\x53\xd1\xb7\x27\x0a\x8c\xdb\xb5\x5b\xb0\x06\x09\x1e\x10\xef\x95\x8b\xb0\xa0\x8a\x61\xd2\xa7\x7a\xc5\x5b\x1a\xd5\x3f\x7c\x18\x23\x24\x8c\xbd\xf3\xca\x91\x81\x36\x4e\x5a\x22\x97\xdc\x3e\xdd\x72\x02\x14\xfc\xa1\x8a\xb8\x70\x4d\x6f\x36\x33\x86\xcc\xfa\x1a\x02\x51\xaa\x56\x75\x49\x18\x45\x61\x9a\x65\xf2\x0e\xbf\x1d\x33\x30\x0b\x7d\x3b\x17\x17\x61\x35\x66\x24\xe7\x56\xa9\x76\xc6\xcf\x78\x3a\x78\x15\x69\x25\x6a\xa6\x50\x60\x55\xee\x36\x6b\xc4\x4c\xbc\xd1\x56\x21\x15\xe8\x08\x6d\xff\xed\x1d\x6f\x30\x2b\xae\xa3\x09\x63\x36\xa3\x73\x2e\x4b\x85\xbd\x8d\x24\x07\xee\x27\x60\x09\x0b\x59\x06\xd3\x14\x56\x49\x0c\xab\xd3\x2b\xe0\x74\x55\xfd\x08\xa2\x7c\x2a\xbd\x2d\xa1\xcf\xbe\x70\x6d\x96\xd7\xe2\x41\xe4\x93\xb6\xed\x0b\x6f\xe6\xba\xb0\x6c\xa1\x73\x45\xb4\xcf\x71\xbf\xba\x60\x32\x1f\xc1\x4f\x3f\xa2\x7a\x68\x5b\x73\x91\xbe\xc8\x3a\xfb\x96\x75\xc2\x75\x55\xc6\x93\x45\xe7\x4a\x61\xd5\x35\x95\xed\x4e\xde\x50\xcd\x52\xf2\x9e\x0a\x3a\x45\xb5\xec\x68\x74\xfd\xe6\xfd\xb1\xdd\x36\x50\xfb\x86\x17\x2b\xef\xb2\x46\xf1\x1c\xae\xf6\x19\x06\xb1\xb4\xc2\x1d\x38\x51\xc7\x35\xee\x35\x8c\x83\x04\x6e\xd2\x2e\x41\xec\x72\xe8\x65\xb3\xc6\x63\x83\x28\xcc\xf3\xf4\x9e\x55\x1d\xb9\xd0\x86\x66\xd9\x75\x46\xc5\x59\x51\x28\x39\x5f\xad\x09\xd7\x03\xc3\x5d\x43\xcf\xda\xd1\xf7\xc1\xbf\x2c\x10\xd0\x70\xd7\x2b\xc8\xb0\x1a\x7f\x40\x86\x26\x28\xc4\x52\x00\x1b\x3c\x38\x2b\x8d\xcc\xa9\xe1\xc9\x81\xd5\x9b\x0f\xde\x53\x51\xd2\x6c\xa5\x87\xd1\xc6\x65\xac\x13\xeb\x36\x76\x5a\x9f\x1c\xad\x45\xb7\x8d\xf2\xc1\xe6\xfe\x86\x2a\x4b\x5b\xce\x47\x9f\x3b\xf5\xd5\x86\x9a\x72\x89\x72\x6e\xa0\xe6\xeb\xe9\x77\x9f\x64\x54\x9b\x4f\x45\x6a\x4f\x72\xe3\xd7\x4d\x44\x3a\xa1\x86\x66\x72\xfa\x07\x46\xb3\xd5\xf8\x5c\xc3\x93\xf3\xb8\xb5\x37\xfe\x20\xca\x8c\xca\x71\x68\x78\xa8\x89\x15\x8a\x7d\xbc\xb6\x62\x19\x9b\x53\x61\x7c\x77\xac\x94\xad\x0f\xdd\xfa\x01\x8b\x78\x65\xf0\x4c\x99\x61\x2a\xe7\xa2\x3e\xe6\x08\xda\x9e\x4b\x91\x72\x34\xf5\x81\x31\x0b\x7b\xd4\xc7\x5d\x8f\x6a\xeb\xcc\xf9\x1b\x0c\xf8\x75\xca\x13\xcd\xa7\x0e\x0a\x6c\x36\x76\x32\xe1\x0c\x5f\xc2\xcd\x75\x6d\x6e\x4b\x90\x22\xb7\xc2\x0a\x73\x90\xf3\x62\x35\x91\xda\xca\xdb\xb7\xf1\xf4\xbe\xdf\x63\x9c\xc2\x7a\xbf\xc8\xbe\x9b\xf7\x3a\x43\xff\x26\x14\xc3\x67\xbb\x34\xd0\x9c\xca\x7a\x0a\xba\x0a\xef\x42\x37\x0c\xee\x6b\x54\x57\xaf\x35\x5a\x4f\xf1\x5b\x09\x4b\xed\xe4\x9a\xb6\x79\xd3\xeb\xb4\xb6\xca\xf2\xbd\xa4\x7e\xb6\x90\xf2\xb6\xb2\xa8\x96\xe9\xcb\xeb\xca\xf0\xd0\x39\xc5\x29\xa7\x3e\x50\x52\x70\x86\x89\x3a\xa8\x70\xc0\x02\xce\xc2\x68\xea\x5e\x5a\x0e\x66\xd5\x38\xf8\xad\xe7\xee\x9a\xd1\xb0\xeb\x7c\x17\xbc\x71\x98\x62\xa2\x0a\xb8\x2c\x38\xf9\x46\xba\x8b\x52\x17\x50\x6a\x69\x00\xf0\xed\x1e\xd1\x65\x32\x23\x54\xdb\xa9\x59\x84\xb6\x27\x9e\x0d\x72\x2a\xf8\x84\x69\x33\x08\x79\x68\xf5\x9f\x7e\xf9\x97\x01\x79\x2b\x15\x71\x7e\xd8\x3d\x9f\x01\xc2\xcd\xb3\xc2\x0b\xae\x71\x31\xa1\x6f\xa5\x69\x16\x32\x75\x93\xbe\x83\xc9\x1a\x7a\x6b\x79\x18\x4e\xb6\x64\x70\x5d\x70\x4a\x0e\xac\x90\x17\x7d\xfa\x1f\x96\x2d\xfd\xeb\x80\x1c\xdd\x01\xd3\x3e\xb0\x7f\x1e\xe0\x07\x83\x2f\x61\xac\x08\x57\x1f\xc6\x30\x3f\xc5\xa7\x53\xa6\x50\xe5\x23\x10\x0e\x77\xec\x32\x58\x08\x19\x35\xf6\x37\xbf\x95\x8a\xd8\x9c\xc8\x9f\x7e\xf9\x97\x03\x72\x54\x5f\x17\xe1\x22\x65\x5f\xc8\x2f\xd1\xf4\xcb\xb5\x5d\xe3\xb1\xbb\x40\xd1\x0b\x61\xe8\x17\x3b\x66\x32\x93\x9a\x09\x54\xbf\x8d\x24\x33\x3a\x67\x44\x4b\xab\xb5\xb2\x2c\xeb\x3b\xb3\x36\xb9\xa3\x90\x55\xc4\x83\x12\x82\xc0\x49\x41\x95\xa9\xa1\xc4\xc0\x59\x35\xe0\x6b\x76\xdb\xa6\xc2\x5f\xff\x4e\xb8\x70\x77\x46\xee\xb6\xca\xee\x39\x84\x34\xe2\x26\x19\x49\x92\x19\x15\xd3\x10\x47\x3d\x29\x4d\xa9\xd8\x96\xeb\x96\x96\x67\xe0\x96\x8b\x4e\xe1\xb6\xdf\x72\xd1\xbc\xb9\x5f\x6d\x0b\x9a\x72\xe3\x9d\xfe\x9d\x23\x9f\x59\x9c\xd8\x5d\x50\x7c\x5c\x1a\xa9\xf4\x49\xca\xe6\x2c\x3b\xd1\x7c\xda\xa7\x2a\x99\x71\xc3\x12\xbb\xac\x13\x5a\xf0\x7e\x22\x85\xdd\x71\xc8\x20\x90\xa7\x3f\x83\x22\x98\x7d\x3b\xd5\x2d\x79\x8d\x5b\x2e\x7a\xbb\x21\xec\x49\x0d\x60\x7b\x5b\x63\x0b\x1b\xce\xf2\x42\xd1\x9e\xf2\x08\xab\x05\xe3\xc5\xc9\x5e\x16\xeb\xd3\xf2\x76\xe7\x31\x87\x2e\xd3\x74\xd2\x1c\xc3\x1e\x3b\xf4\xd2\x80\x53\x59\xa3\x94\x39\x4d\x91\x94\x52\xb1\x78\x70\xe4\xb7\x20\x85\x84\xec\xc9\xa2\x9f\x60\x7d\xfb\x3e\x15\xa9\xfd\x37\xc6\xa3\x24\x8b\xbd\xc0\xb0\xe4\x9d\x08\xc1\xa7\xe1\xc5\xe3\x1c\x89\x92\xef\xe1\xd4\x3b\x79\xad\xa5\x10\x85\xa2\x2a\xb8\xec\x18\x55\x32\xcf\x34\xeb\x02\x2a\xd7\x7e\xd4\xff\x76\x77\x26\x21\x33\xd7\x36\x91\x6a\xf3\x4d\x47\x24\x3b\xb6\x9c\xef\xbb\xaa\x47\xb3\x26\xbe\x1d\xcc\xa5\x81\xf2\xd1\xf3\xb5\x65\x78\x05\x05\x18\xcc\xfa\x3b\xda\x56\x38\xe4\xef\xe8\xed\x44\xfa\x2b\xf3\x03\x25\x41\x29\xd9\xae\x40\x55\xfa\x4b\xad\xd2\x16\x2e\xca\x30\x6d\x08\x9d\x53\x9e\x81\x45\x5d\x8e\x35\x53\x73\x2c\x79\xe4\xd2\xe2\xd1\xa6\x9e\xe5\xaa\x1a\xa0\x18\xf5\x48\x9a\x8f\x5f\xc3\xf2\xae\x6c\x5a\x00\x68\x43\x8d\xd9\xaf\x9d\xf5\x5e\xf4\x1e\x54\x2f\xd7\xfe\x6c\xbf\xb0\xa3\x1a\x63\xf1\xef\x0f\x8c\x2a\x33\x66\xd4\xdc\xf0\x4d\x7c\x77\x09\xa5\x6b\xfd\xbc\xc1\xa5\x42\xe8\x3b\x46\xa6\xd2\x58\x11\xab\x04\xdc\x47\x99\x14\x13\xd0\x04\x44\x7b\x68\x8c\xae\x56\x79\xa3\x28\xc4\xbd\x48\xd1\x71\x99\xf5\x8e\xcb\xeb\x74\xd2\xb1\xc3\x24\x83\xad\x31\x05\x84\x14\xcc\xed\x1d\xde\x40\x00\x05\x7a\x9c\x25\xe7\x4c\xeb\x8d\xa9\x21\xea\x2e\x7c\xd8\x1a\x8f\x72\xe3\x3a\x2c\xf7\xbf\x61\xfc\x84\x15\xa0\x53\x66\x28\xcf\xfc\x51\x46\x50\x04\x28\x6d\xa3\xae\x1b\x17\xa8\x18\xd5\x9b\x04\x84\x66\x46\x2c\x2d\x05\x4e\x5a\x0a\xd6\xbf\x93\x2a\x25\xe7\x34\x67\xd9\x39\xd5\xcc\x8d\x15\x87\xab\xe1\x1e\x1d\xea\xbd\x4e\x79\xb5\xed\x6b\xcd\x94\xd1\xf8\xe3\x91\xc8\xe1\x46\xa5\x62\xe1\x04\x7b\xde\x04\x79\xa3\x4a\xd6\x23\x6f\x2d\xf7\xea\x91\x4f\xe2\x56\xc8\xbb\xfb\xcd\xd5\x6c\xbc\xb9\xa8\xbb\x59\xb9\xcc\x2d\x90\x22\xcf\x25\x84\xa9\x19\x7c\xc2\x74\x77\x9c\x91\x23\xf8\x6b\x4c\x8d\x75\x66\x13\x9a\xfa\x19\xd9\x7f\x2e\x99\xa0\xac\xa2\xa8\xe4\x54\x31\x8d\x39\x57\x56\x26\xf4\x6b\x6b\x72\xfe\x86\x09\x17\xf1\xb6\x75\x7a\xc3\x55\xbd\xfc\x4c\x3d\x5f\x9b\x56\xbf\xb8\xfd\x76\x1f\x2b\xb2\x95\xa2\xc6\x66\x2f\xbc\x68\xa2\x6b\x8c\x4f\xeb\x66\xb8\xda\xe8\x14\x71\xbd\xa8\x2d\x0a\x25\x9b\xac\xa3\x7e\x75\xe7\xa3\xcf\xeb\x81\xbd\x96\xf7\x6d\xe3\x4f\xdb\xcd\x52\xf7\x35\x48\x6d\x3d\x33\x5b\x8d\x50\x2f\xe6\xa7\x17\xf3\xd3\x8f\xc9\xfc\xb4\x15\xe3\x37\x99\x9c\x7e\x1c\xc6\xa6\xad\x4b\xdc\x64\x60\x7a\x96\xa6\xa5\x56\x2b\xda\x68\x4e\x7a\xb6\x86\xa4\xad\x4b\x6b\x69\x3c\xfa\xf7\x31\x1b\x6d\x85\xd8\x06\x53\xd1\x33\x34\x12\xb5\x11\xc8\x58\xda\x46\x4c\x1c\x46\x8d\x63\x41\xb1\x2a\x98\x18\x86\xf3\x2e\x35\xb1\x38\xb3\xab\xb4\x68\x05\xb8\xad\x73\x3b\x74\x93\x6b\x2f\x7b\x39\x81\xd1\x95\x13\x5c\x9a\x2c\xb9\xb8\xbc\xfe\x78\x79\x7e\x76\x73\x79\xd1\x94\xef\x56\x41\x7a\x8b\x24\xb6\xd9\x06\xd1\x8f\x24\xb1\x35\x0d\x2c\x41\x5e\xf3\x93\xc5\x81\x35\x3f\x95\x25\x5f\xd5\xeb\xfe\x72\xe1\xbd\xb8\xdc\xbd\xf8\xc7\xf6\xd3\xd9\xf6\x78\xda\xd3\x09\xd8\x82\x1e\x63\x56\xee\x99\xc9\x2c\xd5\xde\xd7\x74\x78\x11\xa2\x97\xb8\x48\xb2\x32\xb5\xc2\xc5\xa7\x4f\xc3\x0b\x3d\x20\xe4\x0d\x4b\x68\xa9\xc1\x0a\x93\x4a\x71\x68\xc8\x87\xab\x77\x7f\x04\x1f\x6a\x68\xd1\x0b\xc9\x3e\x20\x83\x2c\xa7\x98\x04\xd7\x60\x16\x32\xf2\x86\xa1\xa0\x02\x5f\x4e\x68\x61\xa9\x98\xc6\x2a\x0b\x06\x64\x91\x19\xcb\x0a\x4b\x31\x6f\x19\xa9\x72\x7f\xda\x81\xab\x1a\xe6\xde\xe5\x71\xca\x0c\x46\x3a\x6d\xf2\x6a\xdc\x08\xb5\x2d\x16\xd7\x7b\xd8\x5a\x6b\xea\xa3\xd3\xc6\xef\xa8\x76\x16\xab\x95\xb3\xdd\xb2\xbf\xdb\xed\x33\xeb\x4d\x1c\x6b\x8c\x1b\x48\x9e\xe1\xaf\xa5\x39\xdb\xc9\x56\x76\x0c\x74\x22\xe1\xa6\xb5\x35\x75\xbd\x1b\xd0\xea\x9c\xf5\x4b\xb6\x0c\xd6\x04\x72\xed\xc3\xc1\x8b\x3a\x9a\x72\xbb\xb9\x40\xc1\x8b\xb4\x56\x5d\xd2\x79\xdb\xd5\xdf\x95\xe3\x50\x5f\xb4\x9a\xaf\xb3\xc8\x90\x7f\xfc\xeb\xab\xff\x1f\x00\x00\xff\xff\x19\x53\xdb\x44\x5f\xac\x01\x00") +var _operatorsCoreosCom_subscriptionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x7d\x6b\x73\xe3\xb8\x95\xe8\xf7\xf9\x15\x28\x27\x55\xb6\xb3\x92\xdc\x9d\x9d\x4d\x72\xbd\xa9\xa4\xdc\xb6\x3b\xd1\x4e\xb7\xdb\xdb\x72\xf7\x54\x6e\x92\x9b\x40\x24\x24\x61\x4c\x02\x1c\x00\x94\x5b\x79\xfc\xf7\x5b\x38\x07\x00\x41\xea\x45\xca\xf2\x63\x66\xcc\x0f\x33\x6d\x0a\x00\x81\x83\x83\xf3\xc2\x79\xd0\x82\x7f\x66\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x62\x98\xb0\x7f\xe9\xc1\xed\x6f\xf4\x80\xcb\x93\xf9\xeb\xaf\x6e\xb9\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x32\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x57\x39\x33\x34\xa5\x86\x9e\x7e\x45\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\xaa\x3f\x65\x62\x70\x5b\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xf8\xcd\xe0\xd5\x57\x84\x24\x8a\x41\xf7\x1b\x9e\x33\x6d\x68\x5e\x9c\x12\x51\x66\xd9\x57\x84\x08\x9a\xb3\x53\xa2\xcb\xb1\x4e\x14\x2f\xe0\x13\x03\x59\x30\x45\x8d\x54\x7a\x90\x48\xc5\xa4\xfd\x5f\xfe\x95\x2e\x58\x62\x3f\x3e\x55\xb2\x2c\x4e\xc9\xca\x36\x38\x9c\x9f\x23\x35\x6c\x2a\x15\xf7\x7f\x13\xd2\x27\x32\xcb\xe1\xdf\xb8\xf6\x51\xf4\x55\x78\x9d\x71\x6d\xbe\x59\xfa\xe9\x1d\xd7\x06\x7e\x2e\xb2\x52\xd1\xac\x31\x5b\xf8\x45\xcf\xa4\x32\x57\xd5\xb7\xed\xb7\x74\x39\x8e\xff\xed\x1a\x72\x31\x2d\x33\xaa\xea\x83\x7c\x45\x88\x4e\x64\xc1\x4e\x09\x8c\x51\xd0\x84\xa5\x5f\x11\xe2\xe0\xe8\xc6\xec\x13\x9a\xa6\xb0\x37\x34\xbb\x56\x5c\x18\xa6\xce\x65\x56\xe6\x22\x7c\xd3\xb6\x49\x59\x18\xf5\x94\xdc\xcc\x18\x29\x68\x72\x4b\xa7\xcc\x7f\x6f\xcc\x52\x62\x64\xe8\x40\xc8\x77\x5a\x8a\x6b\x6a\x66\xa7\x64\x60\x41\x3c\xb0\x10\x8c\x7e\xc6\xfd\xb9\xc6\x41\xa2\xf7\x66\x61\xa7\xab\x8d\xe2\x62\xba\xe9\xf3\x09\x35\x34\x93\x53\x82\xf8\x45\x26\x52\x11\x33\x63\xc4\x7e\x8a\x4f\x38\x4b\xfd\xfc\x36\xcc\x08\xbb\x2e\xcd\x69\xd4\x7c\xdd\x7a\x4a\x33\x2a\x04\xcb\x88\x9c\x90\xb2\x48\xa9\x61\x9a\x18\x59\xc1\x67\x33\x78\x5c\xe7\xa5\xd9\x9c\x2f\xbd\x5f\x31\x1d\x6c\x3a\x7f\x4d\xb3\x62\x46\x5f\xbb\x97\x3a\x99\xb1\x9c\x56\x7b\x28\x0b\x26\xce\xae\x87\x9f\xff\x73\xd4\xf8\x81\xd4\x97\x12\xa3\x28\xb9\x65\xac\xd0\xd5\xa1\x20\x65\x61\xd7\x64\x17\x47\xc6\x0b\x62\x14\x4d\x6e\xb9\x98\xc2\xd2\xa7\xb8\xde\x73\xdc\x18\x3d\x58\x9a\xb2\x1c\x7f\xc7\x12\x13\xbd\x56\xec\xfb\x92\x2b\x96\xc6\x53\xb1\x90\xf5\x24\xa2\xf1\xda\xc2\x29\x7a\x55\x28\x3b\x2d\x13\x9d\x43\x7c\x22\x1a\x55\x7b\xdf\x58\xe6\xa1\x85\x05\xb6\x23\xa9\x25\x4f\x76\xfa\x33\xe6\x0f\x07\x4b\x1d\x00\xed\x76\x9a\x19\xd7\x44\xb1\x42\x31\xcd\x04\x12\x2c\xfb\x9a\x0a\xb7\xa6\x01\x19\x31\x65\x3b\xda\x03\x5b\x66\xa9\xa5\x63\x73\xa6\x0c\x51\x2c\x91\x53\xc1\xff\x11\x46\x03\x10\xd9\xcf\x64\x16\x3f\x0c\x81\xe3\x26\x68\x46\xe6\x34\x2b\x59\x8f\x50\x91\x92\x9c\x2e\x88\x62\x76\x5c\x52\x8a\x68\x04\x68\xa2\x07\xe4\xbd\x54\x8c\x70\x31\x91\xa7\x64\x66\x4c\xa1\x4f\x4f\x4e\xa6\xdc\x78\x0a\x9c\xc8\x3c\x2f\x05\x37\x8b\x13\x20\xa6\x7c\x5c\xda\x8d\x3b\x49\xd9\x9c\x65\x27\x9a\x4f\xfb\x54\x25\x33\x6e\x58\x62\x4a\xc5\x4e\x68\xc1\xfb\x30\x59\x81\x24\x32\x4f\x7f\xa6\x1c\xcd\xd6\x87\x0d\xf0\xad\x3c\x07\xc4\x53\xbd\x8d\xb0\xb6\xc4\x8f\x70\x4d\xa8\xeb\x8e\x6b\xa9\x40\x6a\x5f\x59\xa8\x7c\xbc\x1c\xdd\x10\x3f\x01\x04\x3b\x42\xb8\x6a\xaa\x2b\x60\x5b\x40\x71\x31\x61\x0a\x5b\x4e\x94\xcc\x61\x14\x26\xd2\x42\x72\x61\xe0\x8f\x24\xe3\x4c\x18\x7b\x0c\x73\x6e\x34\xe0\x1c\xd3\xc6\xee\xc3\x80\x9c\x03\x03\x22\x63\xe6\x0e\x6c\x3a\x20\x43\x41\xce\x69\xce\xb2\x73\xaa\xd9\x83\x83\xda\x42\x54\xf7\x2d\xf8\xda\x03\x3b\xe6\x9f\xcb\x1d\x96\xce\x18\x21\x9e\xc1\xad\xdd\x9d\xf8\xc0\x8f\x0a\x96\x84\xe3\x40\x05\x39\x2b\x8a\x8c\x27\x88\xf1\x66\x46\x0d\x49\xa8\xb0\xf0\xe2\x42\x1b\x9a\x65\xc0\x4e\x5a\xcd\x62\xdd\x69\x27\x70\xb4\x1b\xcc\xc1\xbf\x5e\xa2\xd0\xf5\x1f\x02\x53\x6b\xb4\x58\x47\x19\xec\xe3\xe8\xec\xf2\x0f\x1b\x40\x4e\x50\x32\x99\xf0\xe9\xaa\x6e\x6b\x61\x79\x0e\x5d\x40\xa6\xa1\x5c\x68\x37\x44\xa9\x10\x9a\x15\xa7\xb2\xbc\x8b\xd6\xf8\xf6\x60\xed\xec\x56\x42\x76\xdb\x9a\xed\xc3\xc4\x7c\xf5\x0f\x8d\x05\x5c\x8a\x39\x1e\x54\x2b\xb3\x58\x22\xc7\xc4\x9c\x2b\x29\x72\x7b\x88\xe6\x54\x71\x3a\xce\x1c\x63\x63\x96\x7c\xe1\x19\xc3\x25\x32\xb5\xea\x48\xad\xf9\x2a\xae\x87\x2a\x45\x17\x6b\x5a\x70\xc3\xf2\x35\xab\x59\x35\xed\xcf\x54\x45\x54\xc2\x22\xef\xaa\xa9\x13\xd7\xc0\x4e\x9d\x92\xf3\x30\xf1\xb5\x9f\xd9\x02\x77\x7c\xd6\xe3\x76\xf5\xac\xc1\x72\xff\x6c\xdb\x40\x7c\x80\xd3\x6f\xf8\xbd\x01\x16\x7b\x42\x90\x81\xb1\x95\xd0\x18\x90\xf7\xa5\x86\xdd\xa2\xe4\xfc\x6f\xc3\x8b\xcb\xab\x9b\xe1\xdb\xe1\xe5\xc7\xf5\xe0\x20\xdb\x0e\x4a\xf5\x00\x8d\xef\x30\xd9\xc3\xcf\x7e\x8f\x14\x9b\x30\xc5\x44\xc2\x34\xf9\xf9\xd1\xe7\xb3\x8f\x7f\xbb\x3a\x7b\x7f\x79\x4c\xa8\x62\x84\x7d\x29\xa8\x48\x59\x4a\x4a\xed\x99\x46\xa1\xd8\x9c\xcb\x52\x67\x0b\x47\xb9\xd2\x35\x48\xdb\xc4\x56\xe0\xb6\x54\x2c\x88\x66\x6a\xce\x93\xd5\x20\xd2\x03\x32\x9c\x10\x5a\x21\x50\x12\x30\xdc\x32\xaa\x6c\xce\xd2\x1e\x0c\x1b\x26\xed\xbf\xc3\x45\x51\x1a\xcf\xf0\xee\x78\x96\xc1\xa9\x10\x28\x2b\xa5\x03\x72\x21\x4b\x3b\xde\xcf\x7f\x0e\x0b\x53\x2c\x2d\x13\x10\xa2\x2d\x31\xe0\x62\x6a\x7f\xea\x91\xbb\x19\x4f\x66\x84\x66\x99\xbc\xd3\x40\x29\x98\x4e\x68\xe1\x97\x1e\x43\x47\x2f\x84\xa1\x5f\x4e\x09\x1f\xb0\x01\x39\xf8\x79\xf4\xd3\x01\x7e\xbd\x50\xd2\x7e\x02\xe5\x64\x9c\x55\xc6\x0d\x53\x34\x23\x07\x71\xeb\x01\xb9\xb4\xdf\x60\x69\xbc\x0f\x30\x82\x60\x73\xa6\xec\x2a\xfc\x2e\xf4\x88\x62\x53\xaa\xd2\x8c\x69\x6d\xf1\xec\x6e\xc6\xcc\x8c\xa1\x28\x1e\x00\xc6\xbe\x70\xcb\x70\xa5\x22\x42\x9a\x01\xb9\x60\x13\x5a\x66\xc0\x81\xc9\xc1\xc1\xa0\xc9\xf8\x76\x47\xb5\xb7\x4a\xe6\x1d\xd0\x6d\x54\xd7\x1c\x56\xed\xfd\xa1\xc6\x91\x6b\x64\x4d\xb3\x94\xf0\x89\x93\x60\xb8\xb6\x8b\x22\x2c\x2f\xcc\xa2\xcd\xa1\xd9\x42\x47\x48\x6b\x42\x40\x02\x4f\x7a\x4f\x8b\x6f\xd8\xe2\x23\x9b\x6c\x6b\xde\x5c\x3f\xcb\x58\x62\x09\x25\xb9\x65\x0b\x10\x67\xc9\xb9\x1f\x70\xf3\x52\x3a\x2d\x87\xb4\x24\x8f\xfe\xe9\xdb\xe9\x6c\x6d\xd7\x1e\x48\xf6\xb9\x65\x8b\x36\xcd\xc8\xb2\x4e\x67\x41\x03\xbc\xce\xc2\x6a\x3b\x54\x48\x7b\x94\xf5\xcf\x76\x8a\xbe\x72\x72\x87\x31\x69\x77\xe7\xd4\xac\x14\x58\x6f\xcb\x31\x53\x82\x19\x06\x32\x6b\x2a\x13\x6d\xc5\xd5\x84\x15\x46\x9f\xc8\xb9\xa5\x7c\xec\xee\xe4\x4e\x2a\xab\xc8\xf5\xef\xb8\x99\xf5\x71\x57\xf5\x09\x18\x3d\x4e\x7e\x06\xff\x23\x37\x1f\x2e\x3e\x9c\x92\xb3\x34\x25\x12\x8e\x78\xa9\xd9\xa4\xcc\xc8\x84\xb3\x2c\xd5\x83\x48\xeb\xea\x81\x3e\xd0\x23\x25\x4f\x7f\xbf\xf9\x70\xef\x08\x31\x59\xa0\xb1\x62\x07\xa8\x8d\x40\xe8\x5a\xd4\xe8\x54\x40\x7a\x4b\xa1\xac\x8a\x60\xf7\x3c\x77\x6c\xd1\x31\x94\x0e\xcb\x18\x4b\x99\x31\x2a\xb6\xf4\x00\xb0\x75\x3f\xb3\x87\xd5\xa1\x85\x11\x3c\x02\x14\x32\x3d\x25\xba\x2c\x0a\xa9\x8c\x0e\x2a\x02\xd8\x5c\x7a\xf5\x3f\x41\x5e\xee\x91\xbf\x87\x97\x19\x1d\xb3\x4c\xff\xf9\xf0\xf0\xb7\xdf\x5c\xfe\xe9\x77\x87\x87\x7f\xfd\x7b\xfc\x6b\x64\xa1\xab\x37\x41\x9b\x8e\x4c\x41\x08\x77\x7f\x3a\x36\x7a\x96\x24\xb2\x14\xc6\xfd\x60\xa8\x29\xf5\x60\x26\xb5\x19\x5e\x87\x3f\x0b\x99\x36\xff\xd2\x5b\x38\x01\x79\x58\xa2\x03\xe0\xbc\xa6\x66\xb6\x67\xd2\xb3\xde\x1a\xb1\xfa\xa9\x6d\xb7\xb7\x4f\xb8\x5d\x76\x06\x09\xfb\xcf\xb7\x7e\xba\x96\x03\xdd\x29\x6e\x0c\x13\x20\x77\x30\x95\x5b\x4e\xdc\xb3\x98\x5b\xb1\xd9\xf9\xeb\x83\x07\x21\x5e\x01\x6a\x3b\x2c\x0e\x66\xef\x56\x86\xc8\x1c\x08\xad\x97\xa0\x2a\x1d\xe9\xec\x7a\xe8\x2d\x33\x7b\x5f\x88\xb7\x37\xbc\xbd\xf7\x99\x0c\x96\x0b\xb7\xac\x20\x69\x9e\x12\x29\xb2\x45\xf8\x5d\x93\x8c\x83\x35\xc2\x0a\xa0\xc1\x22\x71\x84\x2f\x07\x49\x51\xf6\x5c\x83\x41\xce\x72\xa9\x16\xe1\x4f\x56\xcc\x58\x6e\x25\xb6\xbe\x36\x52\xd1\x29\xeb\x85\xee\xd8\x2d\xfc\x85\x1d\x6b\x1f\x58\xee\x8d\x22\x75\x52\x2a\xcb\x3c\xb2\x85\xa7\x20\x2c\x7d\xda\xb3\xe8\xc1\xb4\xe7\xa3\x18\x76\xe3\x6a\x47\x96\x1b\xb4\x45\x67\x70\xf5\xab\x02\x19\x72\x2e\xb3\x32\x67\xba\x17\xd8\x13\x4a\xeb\x62\x6e\xa5\xc9\x25\xf3\xce\xea\xa7\xe3\xe9\x4b\xf9\x9c\x6b\xa9\x76\xe6\x83\xdc\x99\x3c\x65\x69\xac\xa6\x32\x91\x2a\xa7\x26\xa8\x8b\x5f\x0a\xa9\x41\x07\x70\x38\xdb\x20\x29\xaf\x0f\x5a\x7d\xb6\xa0\xc6\x30\x25\x4e\xc9\xff\x3b\xfa\xcb\x7f\xfc\xab\x7f\xfc\xfb\xa3\xa3\x3f\xbf\xea\xff\x9f\xbf\xfe\xc7\xd1\x5f\x06\xf0\x8f\x5f\x1c\xff\xfe\xf8\x5f\xfe\x8f\xff\x38\x3e\x3e\x3a\xfa\xf3\x37\xef\xff\x70\x73\x7d\xf9\x57\x7e\xfc\xaf\x3f\x8b\x32\xbf\xc5\xbf\xfe\x75\xf4\x67\x76\xf9\xd7\x96\x83\x1c\x1f\xff\xfe\xe7\xad\xa6\x47\xc5\xe2\x43\x8b\x03\x8f\x4f\xdf\x6d\x10\x17\x86\x4d\x99\xea\xd8\xab\xf5\xb6\x12\xf2\xa5\x5f\x09\x6d\x7d\x2e\x4c\x5f\xaa\x3e\x76\x3f\x25\x46\x95\xdb\x0f\x46\x45\xd4\x76\xc1\xf3\x8f\xfe\xb4\x46\xa6\x58\x4f\x9a\xf7\x8e\xc8\x9a\x25\x8a\x99\x7d\x69\x30\x38\x9a\xe7\x1f\x85\x4c\x0f\x35\x11\x6b\xcc\x84\xeb\xa6\xfd\x93\x50\x6a\xbc\x48\x81\xf0\xaa\x38\xef\x44\xc9\x7c\x40\x22\xb3\xd0\x9c\x66\x3c\xf5\xed\x6e\xd9\x16\x2d\xd7\x3f\x2f\x4a\xd0\x0f\x4b\x09\x1a\xe1\xfe\x3e\xb8\x06\xc4\xc4\x7c\x93\x99\xa6\x69\xd3\xb5\x6d\xeb\xe6\x68\x2f\x40\x19\x49\x0a\x59\x94\x19\x35\x6b\xcc\x76\x2b\x6c\xd3\x0e\xf7\x75\x30\x13\xda\x8d\x06\x3b\xb0\xa3\x72\xf9\x6a\x63\x28\x39\xcb\x32\xc2\x05\x9e\x04\x18\xc0\x5b\xf3\x14\x43\x79\x89\x50\x34\x38\xcf\xed\x14\xee\x66\xac\x69\x68\xe4\xda\xea\x3a\xca\x70\x31\x1d\x90\x6f\xed\xef\x48\xb3\x9c\x69\x8c\x0b\x92\x97\x99\xe1\x45\xc6\x48\xe0\xb6\x68\x43\xcb\x4a\x46\xa8\xd6\x32\xe1\xd4\xb8\x19\xbb\xfb\x43\x6d\xfc\xb4\x61\x36\x86\xde\x82\x29\x34\x61\x29\x13\x09\x1b\x90\xcf\x70\x5d\x18\xd6\x3a\xb6\xc2\x20\x98\xf7\x61\x0c\x4a\xd2\x12\xaf\x76\x90\x1e\xac\x1e\x63\x98\xe7\xa5\x01\x43\xf1\x63\x59\xf1\xed\x8e\x3b\xcb\x5c\x64\xcc\x07\x52\x15\x44\x6b\x0a\x77\x0f\x72\x52\xa9\xee\xfa\x7e\xe6\xfb\x76\x84\x37\x98\xdb\xb6\x72\xaa\x25\x8a\x5b\xd9\x18\xea\x94\xf6\xb1\x2d\x86\xed\xe8\xec\x8f\x92\xc6\x76\xa0\xaf\xed\x69\x6b\x07\xe3\x52\x57\x7a\xda\xd6\x9a\x54\x28\x36\xe1\x5f\x3a\xe0\xe3\x99\xa8\x54\x14\x9e\x32\x61\xac\x22\xa0\x80\xa0\x2a\x56\x30\x01\x7a\x38\xa3\xc9\x0c\xe8\x82\xa3\xa2\x95\x65\xf8\x21\x6f\x8c\x50\xca\xe8\x7e\xbc\x46\xab\xa4\x98\x97\xb3\xf5\x23\x3f\x5b\x6e\xd7\xf7\x7f\xb0\x84\x4c\x19\xea\x16\xeb\x95\xeb\xc6\x3e\x46\x3d\x9c\x9f\x8b\xff\x0b\x2f\xf0\xfc\x24\xad\xf6\x16\xae\x9c\x0a\x09\x67\x6d\xc2\x0d\x91\x56\x22\xb0\xdf\x1d\x90\xd1\x8a\x9e\x39\x35\xc9\xcc\xb5\x38\x3c\xd4\x04\x8d\xb6\xcd\x81\xc6\x68\x22\x4c\xcb\x8c\xa5\xc4\x3b\x6c\xe0\xa0\x1d\x51\xaa\xe6\xaa\x70\x42\xb5\xe6\x53\xd1\x2f\x64\xda\xb7\xa3\x9d\xac\x43\x88\x16\x87\x2a\x76\x35\xdc\x7e\xb0\xb6\xe2\x55\x30\x4e\xb4\xdb\xa6\x8f\xc1\xfe\x16\xc9\x16\x89\xcc\x8b\xd2\xb0\xc8\x38\x17\xec\x3a\xe3\x05\x7a\x16\x45\x32\x64\x25\x11\xdd\x0f\xa6\x39\x15\x74\xca\xfa\xee\xe3\xfd\xf0\xf1\x7e\xf8\xd6\x7d\xc0\xdc\x86\x6a\xa1\x49\x71\xd3\x39\xac\x03\xef\x1d\x9a\x2c\xf1\xe5\xd8\x99\x8e\x72\xfa\x85\xe7\x65\x4e\x68\x2e\x4b\x01\x32\xd9\x32\x38\xe1\xf2\x9a\xa5\xfb\x01\xd8\x0a\x40\xe9\xb5\x90\x6a\x09\x2d\xd2\x19\x31\xc9\xf3\xb5\x6c\xb5\xb2\x68\x75\xb3\x64\x75\xb0\x60\xed\x6c\xb9\xf2\x46\xea\xf6\xf8\xf8\xd1\xdb\xcd\x1b\x18\xc9\xc5\x56\x8c\xf4\x07\x1c\x5c\x3b\xc2\x38\x5c\x13\x99\x73\x63\x82\x4b\x56\xc0\xb0\x1e\xe1\xa6\x66\xfd\x74\x67\x81\x4f\x90\xc6\x72\x4d\xd8\x17\xab\x4d\x71\xb0\xa2\xfb\x5b\x8b\x1e\x72\xd9\x3b\xae\xc1\x80\x46\x05\xe1\x79\x91\xb1\xdc\xfb\x90\xf6\xbd\x6e\xe6\x9c\x0c\x5e\xce\xc7\xcb\xf9\x58\xd5\x49\x77\x91\x45\x62\x31\x04\x0d\x05\x63\x96\x55\xe2\x88\xc5\xec\x42\xa6\xda\xc9\x0b\x1e\x87\xec\x59\xb8\xfc\xc2\x35\x78\xe2\x7e\x64\x60\x19\x18\x31\xa3\xc9\xdd\x4c\x6a\x86\x3d\xa8\x62\x6e\x9c\x88\x35\x7a\x4b\x08\xdc\x23\x80\xd3\xe8\x64\x52\x6f\x91\xb2\x22\x93\x8b\x1c\x24\xdb\xa1\x89\xe5\x99\x20\xba\xb0\xbc\xc8\xa8\x61\x41\xb0\xd9\x6c\x6d\xb8\x37\xe7\x83\xaf\x5f\x7e\xb1\x12\x40\x14\x07\xd1\x02\xb6\xcd\x8e\x75\xd3\x54\x03\xd2\x8e\xc8\xe4\xe8\xb3\x7c\x03\x12\x7e\xf5\x06\xa0\x79\x76\x75\xb1\xde\x41\x92\xb4\x32\xaf\x90\xed\x26\x96\xa5\x65\x9c\x6d\x98\x6a\x43\x7a\x45\x9f\x5f\xef\xc1\x8a\x1e\xe8\x3d\x34\x5e\xf5\x9c\xfb\x5c\x88\x0e\xc0\xc6\x8a\x65\x18\xfa\xe0\x0c\xcd\xb6\x91\xf3\x5c\xdf\x8f\x46\xd6\xd6\xee\xde\xc6\xe6\xde\x0f\x93\xdf\x93\x12\xd8\xca\x28\x5f\xdb\x0c\x50\xb2\xe3\xa3\x0a\x2e\x47\x16\x92\x68\x9f\x77\x1b\x41\x8b\x22\x83\xfb\x3a\xd9\xd6\x37\xab\xa5\x3a\x86\xcb\xef\x38\xe9\xb0\xe5\xb1\xc3\xad\x9d\xf9\xa1\x46\x04\xb0\xa7\x63\xc6\x0b\xe7\xcd\x88\xd6\x3a\x1f\xbf\xf0\x19\xec\xa8\x55\x4c\x89\x3d\x09\x43\xd1\x23\x57\xd2\xd8\xff\x5d\xa2\x4d\xd4\xe2\xcd\x85\x64\xfa\x4a\x1a\x78\xb3\xd7\x65\xe3\x54\x3a\x2e\x1a\x3b\xc1\x01\x11\x78\x26\xc1\x20\x1d\x05\x34\xa0\xaf\x28\x90\x42\x0f\x20\xae\xc9\x50\x10\xa9\xfc\xea\x82\x55\x57\xbb\x21\xbc\x66\x28\xa4\xe8\xa3\x1b\xe1\xaa\x31\x2e\x83\x0f\x65\x0c\x93\x0d\xc3\xb9\xa1\x6e\x2c\x05\xc6\x5f\x30\x84\x25\xa3\x09\x4b\x49\x5a\xc2\xa4\x21\x1c\x83\x1a\x36\xe5\x09\xc9\x99\x9a\x32\xcb\xb4\x93\x59\x5b\x50\x6f\xa3\x4b\xf8\xb4\xa0\x4e\xf1\xa0\x5b\xf6\x0f\x48\xf0\x3b\xe0\x12\xdd\xc8\x36\xf6\x41\xf2\x96\xd3\xc2\x6e\xdd\x3f\x2d\x15\x03\xe8\xfd\x9b\x14\x94\x2b\x3d\x20\x67\xde\xf5\x36\xfe\xcd\xd9\xc0\xe2\x61\xec\x08\x56\xea\xfb\xbe\xe4\x73\x9a\x59\xba\x89\x02\x1e\x43\xf1\xce\x8e\xde\x64\x16\x3d\xc7\x4b\xed\xf9\x46\x7f\x17\xae\xc9\xc1\x2d\x5b\x1c\xf4\x96\xb6\xfb\x60\x28\x0e\x90\xbe\x2e\x6d\x70\x20\xc6\xe0\x51\x72\x00\xbf\x1d\xdc\x8f\xbf\x3c\x80\xf0\xb7\x75\x2f\x8d\xcc\x98\x8a\x43\x3f\xb7\xec\xe1\x4d\xd5\x1e\x96\x56\x5d\xef\x46\x23\x3d\xce\x2d\xc5\x8d\x17\x5b\xec\xd9\xaa\xe6\x05\xa8\x65\x0c\x4d\x66\xe8\xc5\xed\xe6\x05\x71\x34\x0b\x62\xf7\xcc\x20\x5d\x07\xc4\x70\x1c\xd2\x28\xb8\xf4\xf9\x6d\xc0\xb6\x1e\x03\xf9\xe9\x77\x91\x7f\x3b\xb4\xb7\x7f\x04\x0c\xf9\xad\xff\xd7\xef\xee\x19\xb7\xd0\x8e\xb1\xe1\x94\x3a\x08\x18\x97\xd0\x81\x70\x91\xc2\x05\x93\x5b\x2a\x40\x00\xc7\xb2\xf0\x81\x65\x0d\xc8\xa5\x25\x54\x24\x67\x54\x68\x6f\xe6\x82\x9b\xa8\xaa\xb1\x76\x57\x66\x91\x5e\xe5\x4c\x0a\xd5\xc9\x60\xe4\x4a\x8e\x9c\xed\xab\x47\xae\xc1\x96\x5a\xbd\x81\x93\x74\x25\x2f\xbf\xb0\xa4\x34\x6b\xef\xb2\x62\xb8\x6d\xe5\x22\x5b\x19\x7d\x0d\x20\xdf\x54\x4c\x1e\x57\x56\x63\xf2\x15\x06\xc7\x6c\x7e\x23\x64\x6e\xd9\xa2\x62\x36\x4e\x84\x00\x92\xdf\xab\xb0\xc4\xb3\x02\xe4\x1d\xff\xed\x4d\x59\xf9\x98\x0b\xfc\x18\x0e\xed\xb7\x02\x46\xf7\x00\xb5\x92\x5d\x96\xe1\x67\xf6\x01\xae\x76\x72\x46\x0d\x66\x1f\x3a\xc8\x18\x81\x4a\xae\x96\x2e\x22\x91\xe2\xf2\xfb\x92\x66\xf5\x20\x04\xf7\xca\x35\x5a\xa2\xea\x77\x3c\x4b\x13\xaa\x9c\x97\x17\x86\x69\x6a\x89\xbb\x47\x81\x10\x24\x54\x84\xd3\x5e\xed\x91\xc6\xab\xca\x82\x2a\xc3\x93\x32\xa3\xca\x47\x8e\xb7\x0a\x14\xd8\x0a\xd1\x0a\x69\x46\x2c\x91\x22\xed\xa2\x00\xdc\x34\xfb\x36\xef\x5a\x0b\xa6\xb8\x44\xef\x62\x9e\xb3\x26\x92\x1e\xd5\x6d\xda\x72\xe2\x4f\x75\x38\x62\x35\xcb\x07\xc4\x66\x7a\x86\xc7\xa7\x42\x2a\x96\x1e\x47\xe4\x31\x9c\x8a\x01\x79\xb3\xf0\x66\x16\x30\xb9\xb8\xe8\x0a\xcd\x8c\x0f\x84\xf1\x28\xeb\x80\x5d\x1d\xa8\x89\x54\x10\x9c\x72\x94\x4a\x8c\xc8\x98\xf3\xc4\x1c\x0f\xc8\xff\x65\x4a\xc2\xc6\x0b\x36\xa5\x86\xcf\x03\x37\x0d\x8a\xab\x62\xd4\xdd\xe0\xbf\x22\x47\xd0\x8d\xf0\x3c\x67\x29\xa7\x86\x65\x8b\x63\xd4\x63\x19\xd1\x0b\x6d\x58\xde\x66\xeb\xda\x18\x0d\xd0\xd7\x0e\xda\xfe\xea\xeb\x0d\x2d\xbb\xc6\x50\x7d\xf6\x51\x29\x15\x64\xd0\x87\xa0\xb1\x85\x81\x07\xc9\x0d\xe2\x66\xec\x83\xe0\x02\x9b\xbd\x64\x19\x6f\xf0\x77\x16\x0f\x28\x51\x0c\x32\x10\x38\xcc\xbd\x27\x8e\xa3\x37\xe5\x7b\x59\x8a\xf5\x26\xc1\xda\xc2\xdf\x39\x25\xfc\x73\xd4\x71\x6d\x94\xe2\xa3\x88\x09\xd1\x4c\x22\x13\x25\x25\x60\x97\x04\x76\x6e\xc9\x03\xb6\xaa\x3c\x51\xb6\x4e\x72\xaf\x11\x89\x30\x97\x2d\x5e\xef\x7b\x89\x5b\x0c\x1f\xea\x80\xcb\xe0\x20\xee\x00\xd3\x88\xdb\x33\x8e\x1c\x00\x7e\x22\x04\x2b\x04\x85\x6f\xb1\xd4\x7b\xb1\x59\x6a\xe0\xba\x92\xc3\xd3\xc3\xbd\x10\x5f\x5c\x8e\x92\x05\x9d\xc2\x79\xea\xb0\xaa\x66\x57\x92\x32\xc3\x54\x0e\x01\xd7\x33\x79\x87\xbf\x23\xdb\x2a\x5c\x2b\x96\x56\xb1\xed\x33\xa9\x81\x2b\xd5\x83\x18\xe1\xfc\xc2\xc5\xe8\x1d\x5d\x10\xaa\x64\x29\x52\x27\x35\x05\x02\xfa\xbe\xf1\xe1\x2b\x29\x80\x52\x94\xda\xc2\xea\xa6\x46\xa5\xc7\xcc\x50\x7b\x6c\x5e\x0f\x5e\xbf\xda\x0b\xc0\x3a\xc6\xad\xc2\x6c\x1a\x96\x42\x7f\x57\xee\xcf\xcc\x5e\xe6\xa5\x18\x4d\x3f\x88\xac\x8b\x2c\xf7\x1e\xd1\x0b\xba\xf6\x41\x09\xe3\x13\xb0\xdd\xf6\xf0\xd5\x9d\xe2\x86\x45\xe4\xf1\x68\x42\x33\xcd\xac\xea\x5e\x8a\x20\xc2\x1e\xd7\x45\x10\x68\xd2\x66\x41\xdb\xfd\x41\x74\x39\xbe\xe7\x39\x73\x07\x0a\x50\xae\x3a\x66\x01\xe1\x0e\xf5\x86\x23\x57\x0f\xee\x24\x47\xd8\xd2\x4a\x6c\x52\x9a\xe3\xfd\x38\x89\xe0\x02\xad\x66\xdd\x45\x25\xf1\x71\xc3\xc5\x1e\x57\xfb\x86\xcd\xe8\x9c\x69\xa2\x79\xce\x33\xaa\x32\x88\x15\x1c\xe1\xfc\xc8\xb8\x34\xab\x23\xd0\xbb\x45\x37\xc7\x33\x89\x86\xdb\x0a\x6a\x3f\x0f\x0b\x27\xa0\x11\x7e\x5e\xf6\x3b\x79\x69\x4a\x9a\x65\x0b\xc2\xbe\x24\x59\xa9\xf9\xfc\xbe\xa7\xc9\x45\x3f\xec\xc0\xaa\x9b\x5c\xba\x90\xe9\xa8\x60\xc9\x63\xf2\xe8\xba\x86\x61\x49\x55\xea\x37\x1d\x78\x32\x2a\xfb\xa0\xb9\x2f\xc0\xf3\x29\x49\x98\xd6\xde\xa7\x72\x11\xfb\x79\x86\x35\xfc\x50\x12\x0a\xd0\x3b\x7d\x99\x51\x6d\x78\xf2\x26\x93\xc9\xed\xc8\x48\xd5\x29\x66\xff\xec\xdb\xd1\x52\xff\x46\x1a\x86\xb3\x6f\x47\xe4\x82\xeb\xdb\x38\xb1\x0b\x5e\x9a\xc6\xe6\x12\x4a\x6e\xcb\x31\xcb\x98\x39\x3c\xd4\xc8\xe5\x72\x9a\xcc\xb8\x60\x9e\xc1\x89\x10\x92\xe2\x14\x3e\x0b\xe5\xae\x77\xa6\x2e\xf0\xe9\xc4\xe1\xeb\xcf\xe8\x9d\x66\x38\xfd\xb1\x9d\xbe\xfd\x99\xb5\x89\x48\xdf\xeb\x3d\x05\x4e\x66\x78\xb1\xa7\x3b\x88\x89\xbe\xb1\x73\xec\x66\xdc\x3e\x7c\xcb\x33\x86\x3a\x0e\x2c\xd1\x7b\xa5\xb9\x73\x00\x3b\xb6\x90\x25\xb9\xa3\xa8\x15\x03\x0d\x1c\x90\x1b\x5e\x9c\x92\x4b\xa1\x4b\xc5\x2a\x7b\xc6\xa4\x31\x14\xd7\x55\x64\x99\x57\xa7\x60\x87\x51\xe5\xb0\x94\xce\x69\x57\xe4\xf2\x0b\xcd\x8b\x8c\xe9\x53\x72\xc0\xbe\x98\xaf\x0f\x7a\xe4\xe0\xcb\x44\xdb\xff\x09\x33\xd1\x07\x03\x32\xcc\xc3\x3d\x3b\xa4\xfe\x51\xcc\xbb\x3e\x61\x07\xcb\x8c\x23\x3e\xfb\x20\x08\xe2\xdc\xe8\xac\xb4\x96\x4a\x72\x87\x19\x28\x2c\x89\x67\x4a\x49\x15\x3c\xcf\x23\x30\x00\x77\x49\x64\x5e\x28\x99\xf3\xc8\xb0\x07\x08\xbe\x57\xff\x3a\x30\x37\x6c\x17\x49\x97\xf7\x1f\x73\xba\xb9\xce\xa4\xce\x1c\xd7\xed\xfe\x70\xe2\x3d\x26\x50\x55\x74\xba\x3b\xe8\x9f\xae\x91\xdd\x6f\x37\x8a\xa5\x56\xf1\x0e\xbf\x0d\x51\x73\xe4\x24\x65\xf3\x13\x9d\xd2\xd7\x3d\xf8\x8c\x76\xde\x7e\xa6\x36\x27\xaa\xc9\xc1\xeb\x83\x01\x19\x79\x6e\xdb\x8b\xe7\x58\xb5\x9b\x48\x15\x06\x04\x63\xfa\xab\x03\x72\x24\x15\x8c\x9c\x50\x41\x32\x46\xe7\xce\x80\x8c\x67\x6a\x81\x3a\xed\x71\xeb\xa8\xc7\xb6\x01\x60\x91\x96\xff\x9f\xbf\xdc\xd2\xba\x9d\x24\xba\xbc\x6f\xde\x33\xf2\xc0\x8a\xa0\x07\x20\x4c\x4a\x4b\x63\x2d\xd5\xb4\x6c\x15\xd2\x6a\xb9\xb1\xab\x05\x73\xb1\xa4\x29\xe3\x00\x1b\x37\xf5\x00\xe4\xd4\x83\x27\xa0\xba\xa4\x63\x7c\xbd\x27\xa9\x5d\xa1\xf9\x49\xf0\xef\x4b\x46\x86\x17\x21\xb2\x9e\x29\xcd\xb5\xb1\xa7\x3b\xad\xf1\x30\x8e\x8c\xed\xe8\x2c\xa7\xff\x90\x82\x5c\xbe\x19\xb9\x8f\x1e\x3f\x29\x78\xb6\x12\x09\xfa\x8f\x52\x31\xcb\x8e\xbb\x38\x0c\xf8\x3e\x4d\xce\x6e\xdf\x93\x0b\x6a\x28\x32\x78\xe7\x72\x25\x2a\x0a\x6f\xb1\x70\xcc\x45\xea\x7e\x8a\x38\xf7\x63\x33\x59\xbb\x7b\x57\x9b\xe4\xa5\xb8\xe1\xa7\x8f\xc3\x3d\x31\xe3\x04\x68\xfc\xf4\xbd\x4c\x3b\x73\xe4\x3f\x5a\x00\x9e\x63\x7f\x92\xdb\x01\x88\xd5\xd9\x7b\x70\x9c\x89\x3d\xcf\xee\x9f\xdf\x5a\x8d\xb3\x35\xf1\x6a\xc5\x46\x3c\xb4\x3a\xce\xf9\x26\xd2\xd3\x81\x76\x58\xd4\x80\x73\xe3\x18\xca\x38\x93\x63\xe2\xf0\x7d\xdf\xf3\xfd\xf4\x71\xb8\xc3\x74\x3f\x7d\x1c\x3e\xee\x54\x77\x12\xcf\x9a\xd2\x59\xc5\x83\xab\x70\x8c\xa6\xd8\xd5\x5e\xe6\x1a\xec\x4b\xda\xda\x27\x9c\x56\x65\x95\xdc\x02\xa5\xc3\xcb\x2f\x05\x3a\x9f\x39\x23\xff\x68\x46\x21\x8e\x39\x44\xd7\xc1\xa6\xda\x5d\xd6\x96\xb2\xfb\xed\xb5\x1a\x1d\xd0\x27\x72\xc1\xf0\xca\x32\x3d\xf5\x8e\x00\xa1\xc7\xea\x0e\xef\xc1\xed\x32\x3d\x45\xba\x4a\xd0\x0b\x33\x8d\xb0\xe9\x08\x4d\x44\x22\xfc\x44\xe7\x94\x67\x74\xcc\x33\x6e\x16\x96\x43\x1f\x0f\x6a\xae\xa5\x1a\xa6\xbc\xd7\xc3\xbc\xa3\x68\xb1\x64\xa0\x22\x47\x76\xa4\x13\x30\x70\x1d\x0f\x2a\xa9\x62\xc6\x94\x0b\x42\x44\xd1\xa3\x26\x72\x68\x66\x00\xdb\x1a\x12\x47\x5b\x54\xd9\xce\xee\x01\xf0\xf6\x7c\x74\x65\x68\xb6\xcf\x4a\x86\x06\x3f\x8c\x5c\x4e\xb8\xe7\xcc\xd3\x30\x5e\xaa\x15\x57\x03\xb4\xda\xda\xb2\x3d\x5f\xfb\x71\xe3\x14\x09\xc1\x68\x3b\x30\x41\x3b\x55\xe1\x98\xa0\x8f\xaf\xaf\xb9\x51\x22\x96\x8d\x1c\x29\x71\xe9\x92\x90\x6f\x5a\xdc\xfa\xa6\x45\xaa\x80\x2e\x09\x16\xfc\xce\x77\x0d\xb9\x9a\x81\x5b\xc5\x76\xe4\x6a\x3d\x9b\x84\x15\xb3\x49\x97\x7b\xea\x73\x56\xcc\xde\x8e\xea\xe6\x39\xfb\x8e\xbc\x1d\xad\x38\x97\x00\x64\x58\xad\x46\xa3\xdd\xa1\x26\x19\x9f\x30\xc3\xb7\x2c\xe1\x01\x4e\x66\x2e\x05\x37\x52\xad\x8f\x4b\x26\x9d\x4e\x9b\x1f\xae\x2b\x3f\xac\x32\x79\xbc\x77\x23\xa0\x03\x5c\x22\xb3\x8c\x25\x3e\x8f\x35\x80\xd4\x7f\x62\x95\xf2\xc2\x9c\xce\x1e\xb2\xfc\xa3\xa2\x72\x82\x1b\x7a\xf2\xf1\xf2\xec\xe2\xfd\xe5\x20\x4f\x7f\x36\x93\x77\x7d\x23\xfb\xa5\x66\x7d\xde\x22\x55\xc8\xd3\xb9\x11\xe2\x53\xb4\xca\x5c\x55\x07\xe9\x07\x1f\xc0\x48\x3e\x69\x74\x1b\x00\x53\x8e\xbf\x14\x92\xd2\xf4\x88\xa2\x2e\x48\x91\x3a\x4b\x50\x99\x65\x08\x65\xa3\x18\xeb\xc5\x2a\xf5\xc6\xd8\x8c\xce\x0b\xda\xd5\x88\x50\x2d\xea\x61\x09\xf4\xe3\x23\x57\x17\x5a\xbf\x5d\x88\xd8\x04\xb9\x51\x18\xc3\xfb\x5f\xc0\x55\x93\x91\xe0\x9f\x05\xfe\xb6\x13\xa9\x2c\xd6\xa8\x3a\x06\x30\x93\xc0\x62\x4f\x4a\xcd\xd4\xc0\x71\x8c\x47\x07\x54\x87\x64\x3d\x3b\xe4\x48\x6b\x82\xe9\x23\x9b\xa0\x43\xb2\xcf\x99\xeb\xa4\x28\x5a\x9a\x19\x13\xc6\xa7\x1c\x77\xc0\x58\x09\x37\xe7\xe1\xfc\xe8\x80\x6a\x99\x1e\xa8\x5b\x32\x9f\x97\x04\x38\x5d\xd0\xd0\x1e\x94\x7b\xd1\xed\x10\x1d\xa5\x68\x2a\xc1\x05\x02\x73\xba\xd5\x10\x8c\xa6\x39\x17\xcf\xf0\x20\x26\x5c\xa4\xdb\xd6\xdf\x48\x5c\x07\x3d\xea\x72\x14\x8e\xe2\xad\xe7\xe1\x26\x8e\x7a\xbd\x06\x43\xc8\xdd\x9d\x5c\xfd\x46\xae\xd5\xa1\xcb\x17\xfa\xfb\xac\x8f\x5f\xe9\x17\x69\x05\x95\x97\xeb\xb5\xfd\x1b\x70\x1e\xe1\xd2\x6c\x4f\xfb\x4b\x7e\x7a\x02\xcd\xbd\x21\xd5\x45\x86\xb9\x17\x6f\x86\xaa\x29\xda\x07\x6d\x61\x46\x30\x2c\xbf\xe2\x74\x57\x0b\x82\x82\x2a\x9a\x33\xc3\x14\xba\x8e\x39\x67\x34\xe1\xbc\xfa\x3f\x14\x4c\x8c\x0c\x4d\x6e\xf7\x9d\x42\xf4\x85\x9f\x3e\x1c\x3f\xdd\xf5\xb6\xcc\x3b\xc9\xa4\x01\x13\x5c\x42\xa1\x45\x7c\x33\xcb\x85\x63\x36\xcf\x84\xae\x84\x3c\x5e\x5d\x2c\x11\x21\x8f\x53\x9d\x89\x56\x79\xbd\xd0\xf8\x00\x2e\x62\x21\x31\x1d\xb8\xbe\x23\x14\xf6\xc3\xf4\xda\x1f\x02\x27\xc7\xec\x72\xef\x54\xd1\x83\x5c\xa6\x8c\x8c\xb9\xa9\x4e\xba\x66\x86\x14\x4c\xe5\xdc\x05\x40\x4b\x81\x35\xf8\x58\x8a\xdc\xcb\x72\x2a\xf7\xe9\x88\xb3\x09\x22\x13\xe3\x8b\x5c\x91\x31\x33\x77\x8c\x09\xf2\xea\xd5\xab\x57\x20\x6f\xbc\xfa\xf5\xaf\x7f\x4d\x20\xe3\x42\xca\x12\x9e\x2f\x37\x84\x56\xff\xf5\xfa\xf5\x80\xfc\xe9\xec\xfd\x3b\xf0\xbf\x2a\x8c\x26\x63\x69\x66\x6e\x64\xdb\xa0\xd6\x59\xf7\xc8\xff\x8c\x3e\x5c\x79\x31\x41\x37\x7e\x05\x95\x22\x2c\xaf\xee\x4c\xf7\xea\x57\x5f\x7f\x3d\x20\x17\x5c\x41\xe4\x2d\x87\x58\x81\xe0\x2e\x58\x78\x17\x3a\x21\xcd\x72\xac\xbb\x63\x13\xce\x9d\x36\xe7\xd3\x99\xc1\x6a\x49\x80\x29\x19\x4f\x0c\x66\xdf\xc3\xc3\x8e\xb9\x90\xb4\x0b\x25\x71\x81\x51\xce\x71\x04\x26\xd7\x23\x19\xbf\x65\x64\xa2\xff\xa0\x64\x59\x54\x01\x81\x8a\x69\x2b\xa3\xba\x5a\x4c\x38\x58\xb5\x57\x9a\x99\x27\xf5\x64\x68\x69\xa9\xa9\x21\xdd\xb0\x26\x80\xf4\x42\xfe\xb1\x3e\x62\x42\x41\x79\x70\xae\x83\xeb\xe6\x5a\xf6\xfb\xa0\x45\xa6\xd1\x39\xf5\xf1\x1d\x85\x92\xdf\xe1\x26\x71\xe1\x23\x85\x9c\xcc\xab\x9d\xcc\xe5\x02\x33\xc1\x66\xcb\xeb\x91\xeb\x96\xef\xb9\xa8\xf8\x28\xc6\x68\x38\x89\x83\xd1\x20\x74\x9b\x6b\xfb\x89\x5a\x72\xc8\x15\x5f\x8e\xcb\x13\x9a\x99\xc6\x1d\x2d\xc5\x52\x6f\x57\x6b\xc4\x51\x1a\x57\x81\xc6\x85\x79\x55\x63\xa0\xbb\xaa\x0b\x92\x89\xea\x1a\xd5\x12\xb6\xd5\x9c\x64\x34\x33\xa5\x03\x0d\xf8\x2a\xd9\x6f\x33\xad\x5d\xac\x4d\x4e\xd5\xad\x15\xfb\xdd\xf9\x1f\x80\x67\xb0\x0e\x71\x3e\x18\x74\x35\x67\xa1\x48\x5d\xec\x59\x6f\x3f\x72\x38\x18\x1c\xe2\x01\x91\x0a\xf3\x5d\x22\xb6\xdb\xf7\x4f\x14\x53\x5c\xf7\xdc\xa6\x45\x54\x82\xce\x95\xf6\xa0\x35\x8f\x60\xea\x20\xd5\x26\xcb\x6d\x27\xf1\xa5\x5b\xbe\xe0\xb6\x19\x83\xb1\x65\xd1\xa6\x6c\x41\x57\x09\xaa\x43\x82\xe1\xf5\x75\x53\xdc\x11\x68\x97\x33\xb8\x73\x0e\x5c\x82\x5e\x11\xbb\xcc\xb1\x2b\x93\x73\x41\x6c\xb5\x8a\x59\xcf\x9f\xab\x0d\x27\x18\xfe\x51\xa7\x55\x8e\x16\x44\x12\x42\x55\x9d\xaa\x8a\x05\x79\xd6\xcc\x2b\x46\x97\x6e\xd9\xd8\xbb\x30\x32\x7c\xda\x5d\x12\xe0\xb3\x74\x0e\x02\xcd\x2c\x6a\xd5\x2e\x32\x34\x00\x80\xdc\xe8\x0f\xcb\x80\xbc\x77\x34\x15\x91\x8b\x8e\xb5\xcc\x4a\x83\x5d\xab\x1f\x63\x82\x0b\x83\xfa\x94\x03\x40\x65\x43\xb3\x88\xfc\x9a\xaa\xde\x57\x3b\x4a\x8c\x4f\x87\xc3\xf8\x92\xfa\xf2\xc9\xd2\xca\x56\x19\xbb\xf5\x83\xa5\x98\x4d\x34\xef\xa2\x2a\x8d\x86\xe4\xa8\x2a\x95\xe1\xaf\xb9\x87\xc2\x30\x35\xa1\x09\x3b\x8e\x55\xa8\x50\x92\x24\x78\xd6\xf8\xd8\x80\x19\x15\x69\x86\xa2\x75\xc2\x14\xa0\x3c\xfb\xe2\x8a\xe5\xda\x4f\xa4\x8a\x43\x11\xd8\xa3\x37\xcc\xca\x83\x8c\x9a\x52\xb1\x56\x11\x46\xfb\x75\x2b\x84\x69\xec\x4b\x69\x83\xc1\xba\xba\x54\x40\x27\x2f\xa1\x8a\xe8\x58\x55\x60\x42\xa8\x22\x48\x75\xac\x96\x0e\x2c\x2a\x01\x3d\x06\x52\xb1\x90\xa5\x72\x76\x6f\x9f\x5b\x34\x91\xca\x2a\x42\x38\x30\xd5\x44\xb1\xa9\x95\x56\x15\x88\xb5\xd8\x22\x2b\xed\x8b\xbd\x3a\x7f\xed\xd9\x49\x6e\x93\x8b\xdb\xc4\x89\xcf\x72\xce\x53\xcf\x22\xe1\x6e\xa9\x2a\xf1\x57\x50\x1d\xc5\x9d\x44\xe9\xd8\x23\x08\xa3\x30\x0e\x8c\x34\x44\x74\xd6\xfc\xa7\x63\xeb\xae\x84\x44\x0f\x2d\x6a\x29\x74\x21\xc2\x32\x65\xd7\xe5\x38\xe3\x7a\x36\xda\xd1\x14\x78\xb5\x62\x08\x74\x18\x58\xba\xa8\x5b\x6b\x1e\xd4\x4c\x68\x0e\x2c\xcf\x92\x71\xcb\x6c\xa1\x76\xb0\x04\x20\xfa\xde\x31\x66\x4a\x08\x8c\xc8\x98\x0b\xe7\xb7\x3f\x45\xf3\x70\x11\x5a\x98\xc0\x23\x65\x9f\x44\x51\x7b\x9f\xd0\x2c\xd3\xcd\xe8\x55\x4f\x68\x51\xe6\xf0\x51\x5b\xb8\xa7\xdc\x6e\x77\x28\x13\xd2\x48\x05\xb9\x76\x61\x9a\xe4\x12\x23\x5c\x04\x91\xc2\x37\x82\x3c\x24\xbe\x43\x14\xd5\x07\xb1\xbb\x80\x32\x7b\xae\xa3\xf8\x62\x03\x7d\x38\x1b\xe8\x8e\x37\x0d\x55\x25\x25\x1a\x45\x04\xd7\x4b\x3d\x7b\x52\xea\x49\xee\x96\x2b\x89\xbd\xde\x0a\xe0\x37\xcf\x0c\x96\x27\xef\x9c\xf3\xec\x73\xa3\x3b\xb0\x69\xab\x77\xc0\xe1\xed\x3b\xcd\x22\x89\x30\xd3\x29\x04\xe1\x08\x2c\x1f\xf9\x8a\xe7\x00\xbb\xc1\x97\x87\x9a\xa4\x32\x29\x43\x6e\x54\x00\x5a\x75\x01\xd6\x26\x83\x20\xe9\x7a\x9c\xba\xa7\xb5\x8a\x3f\xb2\x15\xab\x52\x79\x27\xee\xa8\x4a\xcf\xae\xb7\xf8\xa5\xd7\xd9\x79\xd5\x2b\x16\x94\xfc\x60\x50\x09\x8f\x8e\x65\x69\xaa\xf4\x99\x3f\x6e\xd3\xb3\x91\x96\x22\xb4\xb4\x34\x93\x17\xe3\xf5\x8b\xf1\xba\xf9\x3c\xb8\xf1\xda\xf6\xa9\xe7\x82\xad\x1d\x57\x9f\x62\x80\x67\x6d\x5d\x69\x1f\xd2\x0a\x1a\x11\x18\xa4\xee\x4d\x3f\xf8\x86\xdc\x86\x47\xa4\xda\xdb\x48\xd6\xf3\x14\x08\x58\xf5\xd3\x5b\x4c\x1f\xc8\x0e\xda\xbe\x56\x2f\x3e\xeb\x5c\x70\x37\xd5\xee\x05\xa9\x21\x2a\xb6\xdb\x73\x99\x90\x7b\x4e\xef\x12\x69\x55\xc6\x0e\x13\x31\x77\x28\xd5\x89\x4f\x47\xe0\x93\xce\x1b\x40\x3a\x16\xd2\xc5\xa7\xeb\x6e\x90\x1d\x8a\xea\xe2\xf3\xc4\xa5\x75\xf1\xe9\x6c\xe2\x26\xdd\xcb\xec\xae\x58\xee\xc3\x16\xdb\xdd\x71\x69\x8f\x6f\xbd\xef\x55\x25\xde\x9e\x3f\x5b\x7f\xb1\xde\x2f\x3d\x8f\x68\xbd\x8f\x08\xb7\x27\x06\x0e\x00\xb1\x45\x3f\x36\xb7\x79\xb3\xfe\x98\x79\xb1\x72\x50\x65\x20\xb3\x28\xe7\x0d\xfa\x52\xd5\xaf\x4d\x0f\x07\x83\xc3\x43\x6f\xe6\x77\xf8\x59\x9a\x49\xff\x37\x84\x89\x44\xa6\xb8\xa9\x76\x7c\xa5\x0d\x30\xfd\x4a\x3b\x8f\xe7\x92\xfb\x6f\xc5\x57\xaf\x30\x76\xb7\x2d\xe9\x70\x82\xbb\x97\xce\x5e\x05\xe9\xc7\x28\xa0\x1d\x97\xc9\xae\x57\xc5\xc6\x16\xf7\x29\x85\x1d\x03\xef\xc1\xf9\x6b\xeb\xe2\xd8\xf8\xec\xc2\x5e\x77\x28\x94\x8d\xcf\x23\x97\xcb\xc6\x67\x27\x8e\xda\xa9\x74\xf6\x8a\xc5\x3d\x5e\x01\x6d\x7c\x9e\x69\x31\x95\xfa\xd3\xa9\x98\x36\x3e\xbb\x95\xd4\xae\xf7\xed\xb8\xf5\x7b\x29\xaf\x8d\x4f\xb7\x22\xdb\xf8\xec\xbb\xd4\x36\x3e\x2d\x21\x01\x36\xf0\x0b\xde\x29\x78\xe0\xd2\xf5\xa9\x7b\x3e\x1a\x96\x17\x52\x51\xb5\x20\xa9\xb3\x35\x2c\x56\x04\x60\x46\x11\x98\xf7\xce\x8a\x02\x73\x4f\xb9\xda\x53\xfc\x40\x87\xe0\x4b\x96\xf2\x72\x6d\xc9\xe2\x75\x60\xfb\x16\xb2\x61\xb9\x4c\x5a\xfe\x72\x13\x87\x0a\xa9\x04\x69\x72\xeb\x6a\xe4\x78\x18\x22\xa7\x8f\x53\xee\x1c\x34\x32\x1f\x83\x31\x0c\x6e\xfa\x5c\x2d\x40\xdf\x18\xc7\xae\x19\xae\xf0\xca\xc3\xdd\xfd\x1f\xb9\x86\xc7\x56\xfe\x78\x0f\x4c\xef\x91\xf6\x84\x74\x0c\x32\xe3\xff\x60\x50\x60\xab\x73\x0a\x2b\x09\x62\x77\x28\xfc\x95\xc9\x24\xba\x58\xae\xb1\x1f\x80\x7a\xc0\x6c\x6f\x98\xb7\xb0\xb7\x5f\x47\xe1\x01\x2c\x3a\x99\xc6\xbb\x3a\x9e\x40\xee\x46\x10\xd1\x01\x76\x01\xde\x37\x51\x19\xbc\x52\xdb\x2f\x41\x6a\xf5\xa8\x4d\xf5\xa1\x3b\x9f\x42\xd2\x44\x95\xca\xea\x8a\x85\xfd\x65\xe4\x21\x10\x29\x65\x10\x9e\xe0\xa5\x70\x5d\x82\x0c\xe8\xbe\xe2\x64\x21\x39\x81\xfb\xa8\xaa\xee\x57\xc8\x5e\xb8\x84\x55\x82\x67\x75\xb4\xf2\xa9\xdb\xc2\xc2\x4b\xe1\xbc\x08\x96\x70\x64\x35\x8a\x94\x9a\xa9\xfe\xb4\xe4\xe9\x2e\xc8\xf1\x8c\xb9\x5b\x6b\x9e\xd6\x9d\x93\x75\xe4\x5f\xf7\xe0\x5a\xc1\xcb\xa2\x03\xdd\x3f\xb8\x0c\xae\x19\x35\xc2\x1f\xa7\x84\xab\xbb\x69\x50\xef\x09\x10\x8e\x9c\xbf\xef\xb9\x09\x7a\xab\x63\x08\xc9\x22\x71\x61\xb2\xbc\x96\xcf\x11\x87\x45\xcc\x03\xaf\xd4\xbe\xfd\x8f\xd7\x6f\xbd\xb1\x7e\xcc\x26\xb2\x2a\x01\x82\xea\x8e\xf3\xa5\x4d\x59\xc6\xa0\x4e\xba\xaf\xc1\x6e\x1b\xc0\x35\x6f\x2e\xe7\x16\x99\xff\x22\xc8\x27\x9f\x94\x9e\x4f\x4e\x09\x3d\xae\x85\x2a\xb8\xb2\x2a\x82\xb1\x14\x1d\x6c\xb3\xea\x3b\xaa\x14\xba\x47\xc6\xc7\xde\xd9\x04\x4e\x9c\xb0\x32\x5f\xe6\xc5\x59\x54\x9a\x15\xb3\x00\x80\x80\x5f\x25\x73\xa2\x05\x2d\xf4\x4c\x42\x75\xfd\x84\x16\x34\xe1\x66\x41\x8c\xa2\xc9\x2d\xd4\xe0\x51\xcc\x7d\xae\x47\x92\x63\xe7\xac\x15\x83\xaf\xee\xf3\x6b\x66\x4a\x96\xd3\x19\xb8\xb1\x62\xab\x24\xa3\xda\xaf\x7e\x65\x7f\xa7\xca\x68\x92\x2e\x04\xcd\x79\x12\x32\xe6\x29\x39\xe7\x9a\x4b\x67\xca\xf5\xe3\x5e\x87\x8c\x67\x68\x1e\x3e\xcf\x28\xcf\xc9\x91\x66\x8c\x04\x94\xc0\x5f\x5c\x9d\x76\x34\x5b\xa8\xfa\x85\xbf\x0c\x39\xbb\x85\x4b\x34\x50\x11\xb8\x70\x33\x85\xfc\xd1\xce\x7c\xe5\x47\x8f\xc3\x76\xad\x9e\x93\x54\x70\x19\xef\x33\x55\x32\x91\xca\xe8\x4a\xf2\xec\x7a\xa8\x63\x55\x03\x71\xcb\xe5\x73\x83\x1f\x32\x29\xa6\x71\x98\x7e\x85\x99\x96\x94\x0a\xa8\x5f\x32\xe7\x69\x49\x33\x24\xa2\x6e\x32\xe7\xa3\x21\x76\xe7\xd3\x99\xe9\xdf\x31\x30\xb5\x20\xaf\xa9\xdc\x99\xfc\x47\xf9\x92\x2b\x0e\xd7\x40\x74\x8d\x33\x15\xa0\xd9\xca\x4e\xed\x8e\x2e\x20\xa7\x8b\x73\x1b\xa9\xdd\x86\xfa\x7c\x5a\x38\xc4\x2a\x88\xc3\xf4\xce\x42\x3d\x0a\x2b\x25\x80\x2d\xca\x82\x18\x30\x75\x79\x6e\x16\xf0\x51\x7e\xbb\xf0\xda\x95\x1e\xa3\x76\x83\xac\xe4\xb6\x59\x51\x79\x00\x89\x6b\x5e\x6d\xf2\x8d\xab\x0d\xd8\x51\x16\x38\xf8\x36\xb2\x89\x45\xb7\x18\xf6\xd8\x50\x91\xf6\x69\x66\x31\xe7\xfa\xf3\xb9\xf3\x52\xc6\x83\x50\xbb\xa5\xf7\x65\x7e\xb8\x08\x79\xa1\xad\xcc\xb0\xf2\x08\x40\x38\xfa\x98\xa5\x40\x34\xe2\x8a\x88\x77\x56\xfd\x75\x9b\x77\xfd\xf9\xbc\x47\xf8\x80\x0d\xfc\x5f\xa1\xa9\xa7\x5a\x46\x4e\xd1\xc7\x2f\xf8\x6d\x02\xde\xc1\x54\x62\x4b\x53\xdc\xf7\xef\xbf\xb5\x93\xb4\xbf\xfe\xae\xff\xdb\x28\xd3\xe6\xef\xfe\x6e\x89\xa0\xb2\x0d\xea\x6f\x63\x47\xb1\x90\x56\xfe\xef\xd7\x2e\xed\xb2\x4b\xca\xfc\x77\x57\x6d\x8a\x09\x63\xc5\xc4\x6b\x09\x57\xf0\x3c\x45\x6c\x84\x6f\x2b\xf6\x9d\xb7\x1a\x02\x98\x82\xc5\x26\xa1\x86\x09\x20\xd4\x3e\xa2\x42\x48\x83\xdd\x5d\x61\x55\x3b\xff\x23\xd0\xf7\x31\xf8\xab\x47\x8c\x94\x70\x1c\xf1\xc8\x9f\x09\xc2\x7c\x31\x4a\x5c\x2b\x80\x83\x3a\x2f\x34\xcf\x7b\xec\xb0\x16\xc2\x21\x3e\xd6\xce\x03\xe6\xf6\x0b\x21\xcd\x2f\xc2\xf6\x37\xca\x64\xd3\xb9\xe4\x3e\xc3\xb6\x3d\x29\x02\x4b\x16\x86\x9c\xcf\xe3\x05\xc9\xb9\x36\xf4\x96\x0d\xc8\xc8\xf2\x96\xf8\xaa\x0b\xa1\x27\x08\x64\x66\x64\x29\x29\x85\xe1\x19\xfc\x5a\x8d\x63\xa7\x1c\xf3\x9c\xe1\x84\xe8\x12\xea\x77\x17\x8a\xf5\x3d\x17\x73\xad\x96\x68\x41\xb5\x96\x5e\xd8\xec\x19\x45\xd1\xbf\x48\xa1\x2b\xc0\x83\x0a\x87\x5e\x4b\xbe\x59\x76\x9e\x52\x24\x15\xe7\x02\x60\xea\x01\xb9\x02\x66\x95\xf9\xfb\x5e\xd4\x42\x9c\x75\x52\xb0\x84\x69\x4d\xd5\xa2\x07\x99\xcb\x79\xc8\x76\xed\xdc\x71\x80\xa3\xe6\x54\x60\xde\x70\xc5\x12\x29\xb4\x51\x65\x62\xb0\x90\xdc\x58\xc9\x5b\x26\x82\x2f\xa0\xdd\xc5\xba\x53\x56\xe5\x1c\x03\x97\x59\x92\x24\x33\x2a\xa6\x51\x21\x96\x9c\xa6\x00\xfb\x6f\x82\x94\xe3\xd7\x63\x21\x40\x27\x56\xb0\xe0\x06\x40\x31\xb6\x7c\x24\xd8\x58\xff\x22\x88\x57\xa3\x7b\x95\x11\xd4\x2e\x89\x67\x5b\x68\x57\x27\xfa\x45\x3a\x5a\xec\xfa\xc0\xb6\xf7\xec\xd4\x95\x33\x43\x53\x6a\xe8\x0e\x8e\x5d\xef\xab\xea\x71\xbe\x80\x3c\x56\xf0\x0c\xb7\x8e\x8e\x0f\x79\x71\x4b\x16\x3c\x0e\x5e\x82\x93\x38\xf3\x90\x87\x68\x68\x63\x71\xca\xdd\x02\xa0\xbf\x16\xc8\x33\xbe\x3c\x97\x1d\xde\x8f\x86\xe4\xa2\xaa\x3d\x58\x91\x93\x76\x77\x4c\x1d\xcd\xab\x16\xf4\x3b\xc0\xe8\xa6\xba\x08\x4b\xea\xce\x5b\x2b\x45\x10\xe4\x12\x4c\x18\xae\x58\x1c\x2b\xe6\x40\x57\x0a\x44\xf2\x06\x10\x01\xca\x53\x66\x74\xe5\x7e\x82\x74\xd8\x12\x17\xc7\xef\x9c\x32\x0a\x44\xda\x01\xd6\xe9\x73\xab\x65\x21\x04\xbb\x96\x8e\xce\x5a\xca\xff\x20\x70\xdd\xc5\xa2\x8c\xf9\xf2\xdf\xcb\xb4\x8b\x11\xba\x91\x66\xbe\x1a\xa2\xf2\xc9\x44\xef\x5a\x0d\x4a\x3d\x7e\x03\xae\xa2\x74\x2d\xe2\x0d\x89\xdc\x8c\xce\x77\xb7\x40\x55\x32\x52\x3f\xa4\xe8\x85\xcf\xf5\xe1\x73\xfd\xd7\xed\x2d\x75\x5d\xdc\x3b\xfc\xd3\xda\xcd\xa3\xfe\x91\x4e\x66\x51\x4b\x52\x46\x1d\x6d\x99\xcd\xfc\xe1\x81\xda\xbb\xcb\xc1\x70\x21\xeb\x02\x18\x18\xb7\x74\xe2\x94\xfc\xa2\xc6\xdf\x9d\x1c\x15\x74\x24\xf4\xbb\x3d\xf2\x4a\xd3\xc0\x6d\x82\x0f\x0f\xaf\x37\x3f\x6e\x0c\x06\x82\xc5\x6a\x5d\xc2\xfb\xf7\x06\x61\xcf\x0a\x66\x0a\xac\x64\x3e\xac\xc0\x22\x96\x92\x59\xc6\x14\x2c\xc1\xe9\x4d\x8d\xcb\x71\xc8\xec\x89\xa6\xda\x5e\x50\x4e\x83\x74\x29\xd8\x5d\x10\x23\xa8\xc6\x1c\x2a\xfe\x22\x8b\xb9\x9a\x70\x6b\xc7\x0b\x3e\xc8\x67\x62\x81\x53\xbf\x08\xdb\xe2\x95\x4e\x32\xb5\x1f\xb2\xf2\xa6\xa0\xe3\x0c\x2f\x85\x03\xe0\x61\x2e\x34\xbb\xa3\x0b\x0d\x18\x5f\xc9\xf1\xe1\xfb\x2e\x5f\x59\x35\xf0\x47\x36\xc1\xde\xad\x2f\xba\x76\xba\xea\xda\xe5\xb2\x0b\xa2\x20\xb9\x68\xe3\x59\x54\x75\xd8\x58\x13\xa3\xf9\xec\x72\x3b\x06\xee\x27\x70\x2b\xde\xed\xaa\xa3\x9e\x80\xf4\x7a\x08\x43\x78\x69\x7c\x0a\x7f\x78\x5e\x13\xee\x02\xc6\xcc\x62\x75\x15\xdf\x0c\x18\x12\xf7\x5d\xe1\x20\x50\xa1\xd6\x37\x90\xa4\xd4\x99\x83\x43\x11\x2d\xc5\xc0\xc1\x03\xbe\x38\x80\x24\xfc\x54\x2c\x1c\x0f\x37\x33\xae\xd2\x7e\x41\x95\x59\xa0\xe2\xd8\xab\x7d\x2d\x38\xcb\x77\x5a\xf8\x8e\xb7\x34\xed\xf2\xff\xae\x85\x30\x2c\xde\x17\xc2\x73\x66\xf8\xb5\x70\x7d\x8c\xf5\xb4\x77\xc7\x5f\xb9\x9e\xab\x28\x3a\xdd\xeb\x82\x4f\xb6\x9e\x34\x26\x1f\xbb\x72\x8c\xc6\x1d\x2a\x12\xfe\xb8\x0e\x93\x8c\xdd\x99\x03\x47\x07\xe5\xc7\x4e\xa0\x67\x75\x4e\x5a\x15\xce\x8e\x8c\x78\x4e\x2a\xf0\xce\x30\xae\x6c\x8f\x58\x38\x33\x4d\xfc\xad\x78\x80\x70\x2e\xc8\x91\x90\x02\xcf\x0a\xb6\x3d\x46\x5f\xa0\x35\x76\x28\x68\xe2\xea\xad\xd5\xcb\x5d\x46\x67\xd3\xb3\x05\x2e\x52\xbb\x59\x40\xab\x41\x1f\xd2\x65\x92\x30\x16\x34\xe8\xb8\xfa\x4a\x75\x96\xdd\x94\x7d\xdd\x46\x2d\x21\xb1\x8a\x36\x34\xcb\x2a\xcd\xd5\x81\x4b\x02\x67\xf3\xd6\xbe\x88\xe1\xd5\x02\x65\x9c\x12\x0f\x15\xc1\x5d\x96\x4a\x91\xe0\x5d\x3c\x37\x0b\x3f\x83\x98\x03\x41\x37\x50\x19\x34\x2a\xb4\x7c\x82\x36\xa6\x48\xf4\x0f\xc0\x04\x62\xe4\xea\x91\xd7\x79\x91\x4b\xa2\x60\x29\xcf\x98\x26\xb7\x77\x54\xa5\x50\x97\xb6\xa0\x86\x63\x5a\xec\x5e\x6d\xd8\xa3\x68\x0e\x50\x15\x3e\x46\xbe\xe3\xa0\x60\x40\xb1\x0b\xd9\xf8\x0c\xa1\xa5\x91\x39\x35\x3c\x01\xb5\x95\x4f\x22\x8b\x61\x1e\xb2\x08\x36\x6a\xe8\x01\x5d\x0d\xd5\xd8\x6f\xf0\xe6\x45\x31\x62\xee\x24\xe1\xb9\x95\x09\x28\x94\x83\x98\x84\x88\x1f\x6f\xdb\xdc\x34\x53\x2b\xf8\x7c\x0b\x06\xe5\xa8\x15\x2a\xc4\x56\x5d\xd2\x30\x7c\xb0\x5e\x06\xb3\x9d\x0b\x99\xe9\x35\x58\xb6\xeb\x63\x71\xda\xce\x35\x42\xd5\x9e\xdd\x9e\x3b\x66\x25\x01\xbd\x11\x61\xf5\x60\xd5\x8c\xb0\x40\xab\x26\x29\xd7\x8d\x2a\xcb\x47\xa9\x92\x45\xe1\x8c\x21\xf9\x71\x73\x46\x70\x47\xa0\xe6\x4c\x47\x85\x84\xd1\x2c\x3d\x65\x22\x54\xc2\x76\x79\x27\xe0\xe4\x36\x3f\x51\x3b\x30\x03\x72\x74\x96\x15\x33\x7a\x4c\x3e\xb9\x82\x39\x01\x73\x83\xff\x5c\x2b\x59\x09\x4d\x2b\x4e\x5c\x7a\x11\x72\xda\x3e\x2f\x42\xce\x8b\x90\xf3\xd3\x16\x72\x82\xe3\xd6\xae\x02\xce\xc7\xe0\xad\xd8\x28\xaf\xed\x6f\xfe\x2b\x77\xc6\x75\x16\x8b\xe1\x84\x7c\x64\x89\x9c\x33\x85\x44\x0e\xca\x58\x5a\x66\xfe\x96\xf2\xcc\x92\x38\x4f\xea\x2a\x8d\x10\xb2\x99\xd6\xed\x70\x91\x12\x1e\xa0\xe9\xd0\x3c\x77\x93\x72\x31\x7b\xb6\xbd\xbb\x11\x2b\x14\x9b\x73\x59\x6a\xef\x9f\x50\x1a\x3c\x66\xda\x38\x86\x3b\xe3\xd3\x90\xe5\x3a\xdc\x6b\x2a\x96\x48\x95\x56\xc1\xe1\xda\x50\x53\xea\x7a\xc4\x43\x82\xa6\xb3\xfd\x59\x63\x02\x1c\x1f\x98\xba\xef\x46\x49\xd1\x3d\xe3\x1e\xa7\xe2\xf0\x1d\x3a\x78\x54\x55\xa4\x4d\xe4\x73\x52\xf9\xbb\x58\x19\xaa\x34\x2c\x42\x2b\x87\x00\x9d\x61\x5d\x8b\x5f\x3d\xc1\xca\x25\xfd\x30\x6c\xbf\x72\x31\x69\x91\xbe\x3c\x7e\x76\x82\x3a\xb9\x47\xa8\x66\xfc\x3c\x63\x2f\x93\xc6\x62\xbb\xfb\x51\x92\x7b\xfa\x52\x92\xfb\xf8\x53\x92\x7d\xfa\x54\x92\xe0\x99\x7d\x9f\x13\xf3\xd1\xfb\x84\x37\xce\x8c\x23\xbc\x9b\xce\x4c\x2d\x23\x40\x18\x87\x6b\x5f\x15\xcf\xdd\x61\x86\x33\x00\x56\xc0\xd8\xb3\xd7\x9d\x56\x50\xe7\xf0\xa2\x92\x7d\x09\xf9\x77\x23\x39\xa6\x2a\x11\x6d\x24\xb8\x1b\xe4\x05\xa6\xf2\x81\x53\xd7\x77\xfe\x57\x5e\x5d\x7a\x39\xc1\x2f\x27\xb8\x6d\xff\xa7\x3c\xc1\xe8\xbb\xdc\xc5\xb5\xbe\xae\x33\xe0\xd5\x24\xf9\xbe\x64\x6a\x41\xac\xe0\x53\xf9\xef\x40\xa2\x61\xcd\x53\xe7\x01\xe3\x2c\x29\xed\xe5\xf4\x47\xe4\xf9\x60\xa7\xb9\xfc\x62\xa5\x3e\x88\x42\xbb\x07\x2d\x6b\x0e\x55\x0f\x34\x46\x68\x79\xa0\xd7\xa4\xba\x81\xcb\x40\x16\xc9\x79\x56\xc4\x3b\xbb\xba\xd8\x4d\xb9\xe9\x76\x6b\x45\x76\xb9\xb9\x5a\x5a\xfc\xd9\x86\x05\x22\x20\xc2\x2f\xf5\x1a\x4b\xc1\xfe\x40\x6e\xd9\xa2\xe7\x2e\xba\x5d\xee\x74\xdf\x18\xfd\x35\xea\x09\x3f\xdb\x26\x9a\x58\x05\xa0\x1d\xa8\xe2\x6e\x16\x03\x7c\xda\xa7\x88\xac\xf7\xf2\x40\xe8\x4a\x7c\x77\x26\xdb\x9d\x52\x49\xc6\x4f\x0d\x15\x5c\xfa\x53\x70\xd4\x03\x9c\x80\xb4\x79\xde\x71\x39\xa0\x01\x38\x6b\x03\xb5\xe8\xba\x89\x64\x77\xb5\x17\x1f\x0f\xd8\x7b\x2f\x35\xa0\x69\xcd\xf3\xf6\x96\x2d\x0e\xb5\x8b\xf9\x93\x42\xcf\x78\xe1\x33\xb5\x03\x25\x70\x98\x4b\x3e\x83\x03\x80\x1f\x02\xcf\xfc\x50\xf4\xc8\x95\x34\xf6\x7f\x97\xe0\x0b\x84\xe6\x49\xc9\xf4\x95\x34\xf0\xe6\xd1\x81\x85\xd3\xbd\x37\xa8\x9c\x6d\x92\x83\x6d\x11\x7d\xd6\x20\xde\xc2\xfb\x98\x00\x48\xdc\xb5\x6a\x00\x2b\xd7\x64\x28\x88\x54\x1e\x26\xc6\xa7\xf6\xd5\x6e\x08\x6f\x4f\x8a\xcc\xc0\x2b\xc6\x70\xa0\x94\xaa\x06\xc9\x0d\xc3\x05\x8b\x32\xf7\xbf\x80\xbd\x09\x4c\xf0\xc1\x31\x06\x12\xd4\x52\xc3\xa6\x3c\x21\x39\x53\x53\x88\xee\x4c\x66\xbb\x6f\x50\x77\xba\x8d\xcf\x4e\xd4\x3b\xfe\x70\x67\xcc\x00\x56\xf7\x0e\x5c\x93\xee\xcb\x30\x71\x14\x64\x11\x39\x2d\x2c\x52\xfc\xd3\x72\x02\xd8\x97\x7f\x43\x42\x69\x3d\x20\x67\xbe\xca\x67\xfc\x9b\xb3\x5c\xc4\xc3\xd8\x11\xac\x1c\xff\x7d\xc9\xe7\x34\x63\xe8\xb0\x47\x45\xc8\xbd\x29\x27\x4b\x6c\xba\xe7\xb2\x4a\x5b\x2a\x15\xae\x83\x0e\x6e\xd9\xe2\xa0\xb7\x84\x48\x07\x43\x71\x50\x85\x58\xd7\x50\x27\x30\x34\xb8\x29\x38\x80\xdf\x0e\xf6\xcd\xd9\x9f\x48\x9c\xdf\x01\x4b\x9c\x11\xe8\x3c\xa3\x5a\x77\x8b\x4e\x5d\x9f\xe3\x6c\x14\x8d\x59\x45\x09\x39\x37\xcc\xbd\xdb\xaa\xc0\x5d\xbf\xbb\xcb\x50\x27\x28\xcd\x5d\x89\x92\xf6\xe9\x15\x9a\x54\x35\x0c\x10\x82\x31\xee\xe2\x78\xb6\xea\xa6\x75\x0d\xbc\x3e\x83\xcd\x50\x4e\xe2\x9c\x8c\x5c\x83\x8a\xcb\x7d\x78\x86\x90\x86\x70\x91\x64\xa5\x33\x17\x42\x57\x50\x90\xbb\x8a\xf4\x3b\x00\xe7\x1e\xc8\xf3\x39\x0c\xe0\xe5\x11\x7f\xa7\xbb\xe4\x89\xdb\xbc\x7e\x83\x0b\xcf\x70\x9b\x85\xb0\xda\xf7\x5a\x27\x5b\xfc\x1e\xeb\x29\x33\xcf\xeb\x32\xc6\x5b\x3e\x56\x8c\x9c\xcf\xa8\x10\x2c\x8b\x62\x52\x9d\x21\x23\x94\x89\x02\xc1\xc3\x15\x87\x3a\xac\x57\x87\xf2\x74\x4c\x84\x08\xe8\xbd\x57\xc8\xfd\x61\x17\x6b\xda\x5b\xb5\x6d\x97\x39\x71\x26\xef\x48\x2a\xc9\x1d\xd4\x0b\x98\x5b\x76\x04\x77\xac\xda\x33\xb2\x68\xa6\xe0\xf1\x90\xc8\xbc\x50\x32\xe7\xda\xfb\xb5\xbb\x8d\xdb\x6b\x10\x67\x56\xb6\xc8\xcd\xb3\x2e\xa9\xcb\xdb\x73\x62\xa8\x9a\x32\x63\x87\x21\xa2\xcc\xc7\xac\x75\x88\xe9\x43\x24\x05\x7b\xee\x55\xa8\xf6\x5b\x48\x0a\x41\xff\xed\xb7\x57\x9d\xcb\xcd\xae\xda\xc1\x3b\xa9\xb2\xf4\x8e\xa7\x78\xa1\xa7\xc9\x91\x1d\xf8\xf8\xf9\xd7\x86\xbd\xbb\xe3\xe9\xfd\x00\xe0\xfd\x95\x2c\x00\x08\x40\xc0\x55\x47\xe2\x90\xb7\x1a\x3e\x70\x4c\x2e\x39\x46\xfc\xd8\xbf\x30\x33\x4c\x3e\xe6\xa2\x8a\xfa\x0a\x9b\x01\x74\xd5\x9e\x07\xaf\x4d\x68\x66\x30\x56\x03\xc2\x1d\xa4\x99\x11\xcd\xf3\x32\x33\x54\x30\x59\xea\x6c\xd1\x1a\x2d\x9e\x06\xc8\x93\x8c\x7d\x41\x2c\xee\xc2\xaf\x42\xa7\x3a\xdf\x02\x17\x93\x2a\xb4\x71\x89\x71\x55\x4e\x50\xe9\x49\x60\x62\x21\x04\x88\x7d\x61\x89\xf3\xd7\x2d\xb2\x72\xca\xb7\x84\x24\xfc\xc4\xd2\x88\x57\x89\x9a\x4b\xcd\xaa\xe8\xf9\xb6\x85\x52\x9e\x2e\xeb\xf7\x83\x32\xeb\x9b\xd5\xa9\xbd\x53\x56\x30\x91\x42\xd6\xb1\x08\x57\x71\xba\x7b\x85\x95\xcb\xe0\xb5\x3b\x85\xba\xfc\x62\x14\xb5\xe4\x26\xb7\x84\xc5\x27\x04\xe3\x13\x42\x45\x7b\xd2\xf1\x3c\x32\xed\x92\x9f\x1c\x8f\x7e\xf0\x42\xcc\xf7\xcb\xef\x8e\x54\xd4\xa1\xbd\xae\xbb\xe1\xae\xc8\xc3\xee\xbe\x52\x77\xff\xbb\x5f\x3e\x76\xbd\x22\x05\x75\x63\x56\x2f\x05\x2a\x7f\x10\xc9\xd9\x27\x10\x69\xdb\x25\x65\xd1\x5b\xec\xd1\xd0\x6c\xdd\xcb\x66\xc1\xe3\x0d\x9a\xac\xc3\xdb\x88\xa4\x43\x7e\x50\x37\x90\x8b\x16\x22\xda\xc2\xb2\x72\x4f\x2b\x85\xd8\x46\xac\x1e\x22\xe7\x36\x35\x54\x33\xd3\xce\xaa\xb1\xec\x72\xe7\x39\x3d\x8e\x82\x49\xde\xc1\xcd\xdb\x87\x9b\x92\xfe\xef\x9c\x4c\x20\x6a\x2d\xad\x34\xe0\x01\xe2\xb3\x1a\xb1\x70\x4d\x8b\x63\xa4\x76\x1b\x12\x6a\x5a\x57\xa4\x69\x45\xef\xdd\x0c\x3e\x7d\xea\x5c\xb6\xd4\x76\x69\xac\xd8\xed\x34\xe4\xbd\xe1\xdf\x97\xb1\xa4\x0e\xb9\x20\xc2\x1a\x5d\xfb\x7d\x2d\x64\x9a\xb0\xca\x44\x74\xc1\xf5\x6d\x97\xc4\x5c\x7f\x38\xbf\xac\x77\xae\x23\xfc\x1f\xce\x2f\x89\x7b\xdb\xca\x8a\xd3\xc5\x8c\x73\xdf\xbc\x51\xd3\x84\x55\xa6\xd1\x94\xeb\xdb\x47\x2f\x0a\x5e\xa4\x57\xdb\x7c\xa8\x1f\xdb\xca\xe4\xf3\x98\x44\x09\x76\x16\xb2\x24\x77\x2e\x3f\x80\x13\x6a\x6f\x78\x71\x4a\x2e\x85\x2e\x15\xab\x6e\x3f\x9b\xf2\xad\xe5\xa4\xcf\xa9\x78\xf8\xbd\x70\xe3\x39\x9b\xb9\x0a\xaa\x0c\x48\xb6\x9d\x73\x95\x41\x3a\x7e\xd7\xd9\x2f\x61\xcb\xd6\x0f\x27\xde\x07\xad\xe7\x62\x9f\x43\x42\x2f\xdf\xc8\x6e\x76\x94\xee\x23\xde\xde\xb7\x21\x15\x0e\x39\x49\xd9\xfc\x44\xa7\xf4\x75\x0f\x3e\xe3\x7d\x83\x4d\x6d\x4e\x54\x93\x83\xd7\x07\x03\x32\xe2\x39\xcf\xa8\xca\x16\xb5\xfc\xc3\x55\x3b\xcb\x02\xfc\x80\x70\x99\xf5\xea\x80\x1c\x49\x05\x23\x27\x54\x90\x8c\xf9\xe8\x1f\x77\xa0\x16\x28\x02\x1e\x3f\x36\x15\x21\x0f\x6a\x23\x44\x82\xd2\x15\x0d\x3e\x21\xbb\xa9\x25\x77\xb9\xa8\x28\x36\x17\x96\x8c\x0f\xc8\xa7\x55\xe5\xb5\xe1\x6c\xf8\x16\x4f\x05\xca\x07\xd5\xcd\xee\x59\x9b\x7f\x49\xa1\x7b\x3a\x30\x6d\xd7\xea\xa6\xdc\x7c\x64\x85\xec\x24\x00\x60\x97\x86\x25\x8c\x1b\xfb\x42\x6a\x0e\x39\x39\xa9\x81\x0a\xb7\xca\xf0\xa4\xcc\xa8\x95\x89\xd1\x0e\x36\x20\x17\x97\xd7\x1f\x2f\xcf\xcf\x6e\x2e\x2f\x4e\x89\x1f\x89\xc7\xd2\xda\x80\xdc\xc4\xb9\x91\x22\x97\x57\x97\x80\x26\x7c\xab\xe7\x88\x0f\x15\x55\xaa\x43\xc8\x78\x41\x05\x19\x0a\x6e\xaa\x4c\xc0\xe8\xa4\x95\x49\xe1\xdc\xae\x6c\x6f\x67\x87\x9b\x72\x74\x9d\x10\x6e\x30\xfb\x73\x7d\x34\x38\x1d\x98\x55\x34\x4c\x65\x8b\x16\xf7\x00\x92\x43\x05\xdc\x7d\xc9\xee\x3e\xf9\x67\xc7\xe3\x71\x83\x06\xf6\x2a\xff\x2a\x52\xfc\x90\x72\xdc\xe7\x7a\x59\x51\x8c\x99\x58\x5e\x72\x38\x38\xf4\x82\x42\xb6\x94\x5e\x3e\x0c\x1a\xa7\xb3\xaa\xe3\xd6\x80\x90\x0f\xde\x85\x19\x62\x71\x57\x67\xaa\xc7\x04\x09\x51\xbe\xf3\x06\x86\xfa\x40\x91\x72\x1c\x7f\xd4\xe5\xbf\x9a\xf2\x39\x13\xb8\xb0\xfd\x12\x24\xff\xf9\x8e\x30\xff\x58\xcd\xfb\xd3\xc7\x77\xfb\x9d\x12\x9e\xb3\x8e\x13\x3a\x97\x79\x8e\x59\x91\x66\x21\xb2\xae\x0a\x8e\x0b\xa7\x7d\x6f\x0a\x0b\xe6\x77\x9a\x6c\x41\xea\x06\x9d\xf2\x9d\x1a\x0a\x4a\x78\xed\xbc\xf1\x45\x25\xa7\x76\x4f\x25\xec\x52\x89\x69\x9f\x28\xc4\x91\xec\x93\x30\xe3\x93\x8f\x97\x67\x17\xef\x2f\x07\x79\xfa\xe8\x24\x83\x89\xb4\x90\x5c\x18\xbd\x5d\x2d\xd9\x56\x38\xa5\x3d\x59\x09\x1f\xed\xca\x75\x2f\x7d\xc7\xd8\xc5\xc1\x8f\x16\x65\x60\x4b\x99\xa1\x3c\xd3\xd1\x3e\x1a\x59\xc8\x4c\x4e\x57\xe7\x15\xee\xb0\x41\x3f\xc3\x7c\x2a\x7d\xda\xb7\x3b\xbf\x5f\x79\xbd\x4d\x39\x88\x3a\x3c\x7c\xf9\x07\x0b\x86\x6a\xad\x41\x0e\x86\xaa\x0d\xcf\x74\xb9\x0f\x22\x78\x2d\xc1\x00\xb5\x41\x38\xc4\x3e\x39\x5d\x95\xed\x2d\x2a\xc5\xd2\x56\x22\x7b\x68\xd0\x6d\x17\xc6\x2c\x0d\xda\x5e\x6f\xa7\x0e\xb3\x3f\xba\x3e\x75\x22\x57\x28\xd6\x0f\xe9\x89\xa0\x42\x88\x54\x11\x77\x8d\x69\x9e\x37\xbc\x78\x33\x0d\xb6\xca\x16\x4d\x03\x4c\x25\xfb\x04\xab\x15\x46\xd8\x67\xd9\xa2\x4a\x78\xe8\x54\x61\x3a\xc5\xb4\x43\xca\xd9\x6f\x0b\xc5\xe7\x3c\x63\x53\x48\x3a\xca\xc5\x34\x8a\xfd\x8c\xa3\x45\x5d\x12\xd2\xba\x35\xf4\xbd\xfd\x2b\x4a\x2f\x0d\x78\x71\xf5\xe1\x06\xf2\xd7\xc2\xa5\xe0\xbd\x05\x6c\xfb\x41\x28\x66\xd2\xef\xf7\x41\xef\x3f\xfa\xce\xca\x8a\x69\x76\x4c\xbe\x65\xee\x3b\x12\x12\xec\x2a\xa8\x68\x33\x93\x21\xdb\x29\xcc\xb5\x82\x2c\xa0\x23\x5e\x9a\xbb\x56\x27\xb6\xa5\x15\x8c\x90\xdd\xd4\xda\x43\x01\x4f\x4c\x52\x88\xf7\x3d\x8f\x2f\x57\xee\x91\xf4\xef\x4c\xe5\xbc\x55\x74\x15\x7e\x86\x1b\x99\xc2\xd1\x43\x4a\xf4\x22\xcf\xb8\xb8\xad\xf2\x60\x4d\xa4\xc5\x21\xf4\xd1\xe7\xe2\xd6\x63\xac\x62\x34\x5b\x4f\x29\x77\xc1\x8f\xbd\x52\x49\xb3\x83\xf1\xee\x66\x51\xe0\x5d\x78\x38\xf6\xee\xaa\x37\x26\x71\x07\x07\xcf\x6e\xbd\x5c\x77\xab\xe6\x7e\x38\x1c\x9d\x8f\x6a\x95\x48\xad\x4e\x07\xef\x1e\xd3\xb8\xbc\x8e\x25\xc0\x72\x9e\x50\xb2\xe3\xdf\x6f\xbb\xa9\xed\x93\xac\xdc\xde\x06\xdd\x7c\xae\xa5\x32\x34\xdb\x13\x11\x48\x66\xb4\x38\x2b\xcd\xec\x82\x6b\x48\x20\xd0\x55\x08\xb8\x9b\x61\x2e\x62\x9f\x06\x8f\xfb\x4d\xc7\xd1\xc8\xf9\x1f\xcf\xae\x09\x2d\xed\x2e\x1a\x97\x2c\x73\xaf\x57\xdc\x7e\xfe\x23\x74\xa8\xdf\xcb\xec\xdd\x58\x0f\x3e\xf7\x97\x0b\x81\x3d\x5e\x08\xc0\x19\x7f\xce\x97\x00\x5c\x70\xc3\xa9\x91\x2d\xeb\x65\xd5\xf5\xf7\x52\x1b\x99\x3b\xf4\x1c\xfa\x81\xe0\x56\x16\x18\x6e\x6d\xec\x7a\x29\x00\x10\xb4\x01\x38\x43\x61\xc5\x62\x9a\xb0\x86\x07\x60\x0f\xf2\x51\xe2\xd8\x3c\xb4\xf9\xad\xf3\xcc\x84\x44\x56\xd9\xef\x4e\x6b\xf9\xc1\x97\x8a\x2d\x78\xa3\x42\x95\xc9\x7f\xaf\x96\x18\xfe\x7d\xd7\x93\xed\xcc\x5e\xb8\xaa\xff\x2d\x69\x86\xd0\xb8\xda\xb7\x8d\xa8\x0e\xd9\x8e\x93\xf4\xfb\xe9\x61\x7e\x15\xb4\xe6\x52\x63\x1e\x2c\x6c\x61\x14\x15\xda\x6e\x44\x5d\x37\x3a\x74\x57\x3b\x87\xe4\xc8\x24\x45\xeb\x92\xf0\x0f\xe4\x99\x8d\x53\x75\x70\x7f\x17\x3c\xb2\xdb\xce\xea\x41\x6e\x5b\x00\x77\xbb\x9a\x36\x6a\x0b\x41\x66\x4b\xde\x71\x6d\x7c\xb2\x7f\x78\xc1\xb5\xcb\x54\x0b\x92\xce\xb5\x55\x9d\x78\xf1\x37\x9a\xa6\xea\x14\x39\x89\x2f\xdb\xab\x40\xde\xf1\x39\xa5\xa8\x08\xf7\x71\x47\x66\x51\xb8\x84\x73\x37\xe7\xd7\x04\x8b\x6f\xfc\xe6\x57\x58\x32\xf4\x3f\x7f\xf9\xab\x57\xad\x37\xf4\xe9\xdc\x9f\x77\xb4\x1c\xec\xfd\xc6\xe6\x59\x78\xcd\x81\xb8\x80\xfe\x72\x40\x0f\xdd\xd9\x45\x3c\xb2\x9b\x1a\xa8\xf4\x6e\x42\xc5\x8b\x87\xd9\x93\x7a\x98\x91\x10\xf4\x80\x34\xe1\xfe\x54\x05\x09\xca\xf5\xf3\x23\x28\x5b\x61\xb1\x1d\x6b\xea\xd8\x82\xe7\xd7\xea\x77\xd1\xed\x13\xf8\x5c\x5f\x5c\x8d\xfe\xf6\xee\xec\xcd\xe5\x3b\x98\xa5\xf3\xab\xb2\x68\xc0\xc5\xce\x7e\x44\xed\xd1\xaa\x8d\x26\xb8\x1d\x18\xdd\xee\x39\xae\xde\x8e\x1a\x8a\xb2\x7d\xd3\xf1\x72\xe3\xbe\xd2\xb2\x98\xb4\x5a\xfb\xe3\x9a\xae\xa0\x18\x06\x53\xfb\x0b\x71\xd8\xd9\xc2\x15\xa5\x64\xaa\x29\x43\x76\xa7\x70\x86\xf7\xd6\x57\xb6\xee\x00\x79\x06\x46\x7c\xbb\x5e\x84\xc1\xde\xcd\xf7\x0f\x04\xab\xb6\x2c\x5e\x75\x8f\x7d\x39\x1c\x41\x2f\x7f\xc9\x63\x0f\x29\x7a\xe4\x28\x4b\xaf\x2d\xa5\x66\x3a\xa4\xee\x7f\xa6\x98\x52\xac\xca\xf4\xdb\x85\x7a\xad\x4c\x15\x5c\xab\x72\x55\xbb\xd8\xa8\x45\x0c\xac\xcb\x8c\xed\xef\xf6\xa9\x53\x2f\x75\x41\x93\xbd\xd6\xe1\xa8\x5e\xe1\x1b\x08\xa9\x7e\x7c\x02\x08\x9f\xdd\xa3\x43\x69\x18\xaf\x2b\x22\x9f\xfb\x8e\xcd\x40\xae\x4e\x3b\xe4\xab\x44\x14\xd2\x07\xc9\xc5\x11\x5f\x4f\xbc\x7d\xe4\x51\xa8\xe7\xb7\x3b\xaa\x2e\xfb\x56\x5b\x8a\x99\x34\x52\xec\xec\x24\x7e\xbd\xa2\x7b\xfd\x1c\x63\x8b\xf3\xaa\xf4\x49\x54\x11\x10\x3c\x0c\x83\x41\xdf\x8a\x71\x9e\x4b\x48\xe1\x4d\xfb\x75\xc3\xfe\xa3\x4b\x1e\xe9\xf0\x62\x4f\x67\xee\x87\x14\x7c\xd8\xd5\x04\xbb\x57\x17\x8a\xb4\x73\xc4\xc5\xf0\xc2\xc9\x5d\x3e\xaa\x42\x3b\xb4\x23\xeb\xf1\x6e\x6f\x7c\x51\x2a\x73\x27\x55\xf7\x50\xe3\xeb\x5a\xc7\xc6\xad\xbe\xfb\x6d\x29\x9a\xe8\x39\x9e\x11\x9c\xe3\x13\x9f\x93\x11\x5c\x98\x36\xf2\x60\x37\x4f\x46\xf0\x62\x7f\x80\xc3\xf3\xb4\x87\x66\x47\x2e\xf4\xb0\x21\xa9\x7b\x15\xbc\x3d\x96\x75\x5c\xe1\x67\xd7\xcd\x19\x08\xec\xde\x54\x44\x82\x86\x43\xe8\x86\xdf\x1b\x51\x50\x12\xab\x11\x76\xa0\x07\x43\xc3\x72\x2c\x28\x4c\xb3\xcc\xc2\x52\x8a\x38\x6d\xb0\x0b\x3b\xed\x11\xcc\xbc\x9b\xd3\xc2\x17\x65\x96\x77\xe2\x8e\xaa\x94\x9c\x5d\x0f\xf7\x73\xf4\x3b\xb8\x16\x23\xfe\xb4\xcb\x04\x55\x2f\x16\x29\x53\x46\xc6\xdc\xe8\xaa\x8c\x1b\x33\xb1\x36\x68\xc9\x5b\xb8\x23\xb2\x87\xd4\x1e\x48\xf7\xbd\x88\xfb\x09\x22\x13\x43\xb3\x46\x91\xfb\x57\xaf\x5e\xa1\xf1\xea\xd5\xaf\x7f\xfd\x6b\x2c\xad\x93\xb2\x84\xe7\xcb\x0d\xa1\xd5\x7f\xbd\x7e\x3d\x20\x7f\x3a\x7b\xff\x0e\xca\xfc\x15\x46\x63\xba\x0b\x1c\x19\xcb\x7e\x47\x9d\x75\x8f\xfc\xcf\xe8\xc3\x55\x55\x26\xa4\xfe\xab\xab\x9e\xec\x96\x37\x20\x17\x91\x0b\x50\x6c\x9e\xa2\x66\xe6\x2a\xda\x18\x42\x27\x13\x2c\x5e\x39\xf6\xb5\x53\xf1\x48\xf9\xc8\x66\x28\x01\x8d\xf5\x27\xec\xf6\x67\xe0\x9b\x64\x15\x69\x34\xe6\xf9\xe0\x7a\x74\xb5\x82\xb1\x02\xfd\x83\xa9\xf4\xb0\x70\xf8\x44\x43\x15\x8a\x2a\x15\x9c\x62\xda\xca\x94\xae\xa0\x1e\x0e\x16\xa6\x6e\x27\xf1\x94\x77\x30\xad\xab\x23\xd4\x10\xcb\x27\xae\xad\x8a\x90\x7f\x87\xd7\x8a\xdb\x9c\x63\x1f\xe8\x4e\xa4\xce\xf3\xc3\x6c\x70\xaf\x5c\xc8\x7a\x20\x17\x84\x66\x12\x6a\x37\x85\xad\xad\xf8\x51\x54\xd2\x7c\xfb\x52\x3a\x67\xde\xeb\x9a\x7d\x15\xa9\xd0\x7b\xda\xba\x7e\x4b\xdd\xa4\x1d\x85\xf6\xd3\xb1\x2c\x8d\xbf\x02\xc6\x31\xb1\x68\x21\x56\xce\xee\x90\x39\x70\x87\x64\x83\xbb\x24\x9d\xed\x9c\xb7\xb2\x4e\xe6\x6b\x42\x40\x8f\x30\x9a\xcc\xc8\x2d\x5b\xf4\x91\x30\x15\x14\xa2\x51\x42\x6d\xac\x7a\x65\x8b\xaa\x38\x89\x95\x6c\x1d\xb0\xfc\x8d\x7a\x85\x45\x21\x9a\xc5\x8b\x8f\xda\x49\x3a\x2e\x67\xa4\x88\x14\x78\x9f\x98\x38\xaa\x2e\x1b\x92\x44\x62\x69\xe9\x7a\xd4\x85\x3d\x5f\x2c\xb5\xdd\xf4\xa6\x2f\x57\x6e\x04\x96\xd0\x39\x56\x55\x8a\xa5\xde\xae\x94\xb2\x13\xdb\xe0\x83\xd4\xa7\xe2\x8d\x5c\x11\xa0\x60\x9b\x2b\xd5\xe3\xda\x7a\x28\x05\x40\xd4\xa2\x42\x34\x33\xa5\x03\x0d\x56\x84\x2a\x45\xc6\xb4\x26\x1c\x56\x98\x53\x75\xcb\x7c\x52\x12\x9a\x0d\xc8\xb5\x9d\x64\xc8\x7c\x84\x39\x70\xe7\xe8\x46\x66\xcf\x68\x1c\xee\x62\x3f\x72\x38\x18\x1c\x22\x05\x5f\x11\xfc\xd2\x01\x33\x76\x4b\xa0\xba\x43\xe2\xd4\x46\xa1\xe6\x42\x63\x1a\x58\x2b\xb5\x41\x9a\x63\x09\x51\x5c\x66\xe6\x39\x14\x6d\x9d\x7e\x67\x79\x39\x3b\x64\xfb\xdc\x35\x49\xf5\x2e\x29\xaa\x5b\x5d\x27\xd4\x9f\xdd\x53\x53\xef\x94\x98\x7a\xa9\x62\xb4\xdb\x22\x77\xcc\xba\x67\xea\xbd\x47\x22\xe5\xbc\x53\x92\x4f\xff\xac\xcb\x09\x93\xb7\x91\xfa\x5c\x25\xb6\x8c\xfd\xa0\xc4\xbc\xe1\x64\x55\x1d\x31\x1f\xee\x56\xc9\xc9\x81\x68\x5a\x08\x3c\xbd\x7c\xd7\xad\x3a\x07\xe9\x2c\xf0\x35\x9f\x2e\x02\x60\xf3\x69\x77\x29\xd7\x7c\x96\x4e\x53\xa0\xee\x45\xe4\x92\x0e\xa0\x34\x12\x32\x31\x9b\x70\xe4\x06\x50\xd4\xde\xf1\x28\x6a\x65\x15\x2d\xb3\xd2\x84\xb0\x9c\x15\xac\x01\x06\xf5\x79\x9b\x31\x18\xd2\x37\x8b\x18\x05\x96\xae\x02\xfa\xdb\x95\x67\xe0\xb3\xd3\x91\xee\x5a\x3d\xed\x47\xeb\xb8\x71\x0f\x18\x7a\x99\x61\x67\x38\x8e\x5c\x36\x04\xef\x41\x5c\x93\x61\xc0\x79\xc3\x68\x14\x90\xbc\x38\xe2\x2a\xf5\x74\x5e\x59\x3b\xc3\x8a\x9b\xa2\xb3\x22\x9c\x5d\x0f\xf7\x28\xd1\x47\xa3\xfe\xa8\x65\x7a\x30\xdd\xd4\xea\xa6\x5c\x54\x2b\x77\x06\x5e\x4b\x61\x9e\xbd\x68\xb8\x34\xed\xb7\x96\x2e\x46\x66\xd5\x46\x52\x36\x57\x98\x3e\x50\xd0\x28\x91\x9b\xbf\xe0\x83\xf3\xfa\xdc\xc5\xc8\x47\x14\x09\x01\x1e\x9d\xca\x5a\xfb\x67\xb9\x04\x19\x2c\x96\x8c\xa0\x36\x09\xea\x78\x91\xb2\x58\xc8\xf4\xd4\x15\x00\x16\x42\x62\xd5\x2f\xdd\xc3\xe2\x26\xba\x87\x4a\xa0\x15\x14\xa2\x6b\x59\x15\x19\xc0\x77\x16\x0d\x76\x2a\x53\x73\x9f\x42\x35\x76\x03\x61\xe5\xd7\x5d\x77\x91\xdc\xb3\xee\x0c\x89\xb8\xd0\x6e\x95\x2c\xea\xc6\x6a\x1c\x29\x54\xe7\x4e\x66\x2c\xa7\x98\x14\xce\x2f\xcf\x52\x99\x3b\xc5\x8d\x61\x98\xd5\x87\xa9\x5c\x13\x39\xe9\xd5\x2a\xc4\x1d\xcc\x5f\x1f\xec\x52\xcf\xe3\x9e\x25\x57\x48\xb5\x0b\x7b\x00\xc6\x75\x4d\x3a\xb3\x78\x0d\xea\x42\x06\x99\x1c\x45\xc3\xc8\x60\x19\xcc\x1c\xa1\xf7\xe8\x0b\x7f\x4a\x15\xa9\x17\x84\x84\x17\x15\xe9\x45\x45\xda\x8b\x8a\x14\x31\x16\x4f\x70\x1c\xa0\x62\xb5\x29\xce\x28\xe5\x75\xa7\x2a\xaa\x27\xca\x12\x63\x51\xd3\x6b\x4d\x52\xd5\xad\x68\x56\xf5\x39\xf4\xba\x94\xc3\xe3\xd2\x4c\xfa\xbf\x21\x4c\x24\x32\xc5\xcd\xb7\xe3\x2b\x6d\x40\xb4\xa9\xd4\x8f\x78\x2e\xb9\xff\x56\x6c\x89\x83\xb1\x77\xdd\xba\x9d\xe8\x80\xbf\xab\x7b\xbb\x27\x06\x5f\xb1\xf5\x10\x04\xeb\x0b\x1c\xfb\x18\x79\xc7\xdf\xab\x5b\x42\xac\x05\x0c\xc8\xed\xcb\x9c\x92\x23\x7c\x39\x48\x8a\xb2\xe7\x1a\x0c\x72\x96\x4b\xb5\xe8\x85\x46\xf6\xc7\x5a\x2f\xd7\xe2\x18\x64\x82\xa4\x54\x56\xd9\xcb\x16\x3f\x54\xe9\xc0\x03\xe8\x91\x85\x83\xb0\x4f\xdd\xaa\xc1\xc4\x4f\xc3\xfd\x2e\x24\xba\x02\x55\xbe\xaa\x8e\x33\x09\xc9\xf7\x74\x2f\xa8\xa8\xf0\x96\x89\x39\x99\x53\xd5\xa1\x74\x75\xfc\xdc\x53\x1e\x48\xf9\x9c\xeb\xdd\x0a\xd6\xad\xd4\x9a\xb9\x4b\xeb\x25\x4b\x53\x94\xc6\x51\x4a\x7f\x2a\x7c\xa8\x77\x38\x0d\x0d\xa1\xe8\xf5\xc1\x4e\xd3\xf8\xc1\x14\x85\xc5\x67\xc7\xd2\xb0\xf8\xdc\xb7\x40\x6c\x7d\x94\x9d\xd1\x66\xaf\xe5\x9e\xfd\xe3\xd1\x62\x1f\xe7\xb0\x62\x91\x55\x7e\x02\x2f\x9c\x3e\xd2\x41\x43\x7f\x90\x3d\xda\x6a\x5c\x22\xf4\x1f\xb3\x99\x66\x4f\x57\xaf\x2e\x52\xef\x27\x7e\xef\x3a\x72\x39\xf1\x5f\x2e\x5d\x5b\x21\xdf\xcb\xa5\xeb\xcb\xa5\x6b\xdb\xe7\xe5\xd2\xf5\xc5\xa2\x50\x7f\x7e\xd0\x16\x85\x97\x4b\xd7\x97\x4b\xd7\xfb\xc1\xf0\x41\x2e\x5d\x9d\x18\x57\xdd\xb8\x3e\xea\x85\xab\x2b\xeb\x72\x96\x24\xb2\x14\xe6\x46\xde\xb2\xd6\x37\x08\xad\x84\xf9\xa5\xd1\x1f\x4f\xb2\xef\x2e\x58\x74\x12\x0f\x76\x11\x0c\x68\x99\x72\x2b\xbc\xef\x8c\x40\x67\x6e\x00\x2f\xa7\x5b\x52\x2c\x52\x96\x86\x91\xfd\x21\x35\x16\xd6\x03\x72\x46\x14\x4b\x78\xc1\x5d\xf5\x6e\x8a\xef\x11\xc3\x42\x96\x7d\x6e\x34\xcb\x26\x2e\xdb\xb9\x88\x8b\xc2\x54\x22\xb8\xa3\x70\x2b\x3f\x83\x3c\x47\xfa\x24\xd9\xbe\x42\x8e\x62\xdf\x79\x66\xe5\x66\x73\x13\x8f\x10\x1b\x45\x60\x29\xb5\x5a\x34\xf0\xb1\x82\xbb\x08\xe4\x87\x3e\xd8\xec\x4b\xc1\x15\x20\xef\x88\x25\x52\xb4\xa9\x88\xb9\x66\x83\x2e\x9b\x23\xf9\x9d\x72\x16\x4d\x2c\x80\x1f\xea\x5e\xce\x69\xc6\x53\x6e\x16\xe1\xae\xcd\x55\x59\xa2\x78\x62\xc2\x36\xea\x0a\x8c\x84\x16\x85\x92\x34\x99\x31\x1d\xcd\x1b\x45\x0e\x17\x88\x15\xbc\xce\xb1\x12\x18\x48\x1d\xd0\xc7\xb2\xbe\x6c\x41\x94\x34\xfe\xba\x7c\xcd\x07\x6f\xa2\xc1\xa0\x3b\xf2\x2f\xa3\x16\x70\xa7\x2e\xe3\x21\x70\x56\x7c\x12\xff\xa1\x89\xcc\x52\x9f\xdf\xe3\x37\xaf\xac\x98\x97\x38\x1c\xb4\x54\x0e\x32\x40\x18\x49\x32\xcb\x8a\x2d\xe5\x5b\xdf\xf9\x97\x5f\x93\x99\x2c\x95\x1e\xc4\x41\x42\xaf\xe1\x1d\xaa\x68\x5e\x4c\x34\x24\x63\x54\x1b\xf2\xfa\x15\xc9\xb9\x28\x2d\x07\xea\x8c\x36\xdd\x25\x9b\x48\xa6\xf9\xd5\xd7\xad\xfb\x75\x95\x66\x96\x6f\x24\x1d\x56\x15\x98\x89\xd7\x09\x35\xee\x24\x61\x70\x19\xe6\xb1\x6e\x88\x38\x8e\xe8\xc6\xd0\x16\x46\x3e\xc0\xf9\xfa\xbe\x94\xe3\x85\xe9\x12\x88\xf8\xbf\xd8\xa3\x1e\x81\xe8\x5f\xb6\xc9\x2e\x52\x25\x17\xd9\xf8\xd1\x07\xa9\x95\x30\xe5\xda\x6c\xa9\x94\x50\xc5\x28\x6e\x6c\xd6\x9e\xad\x4c\xad\xbc\xdf\x31\x2c\x05\x74\x04\x2f\xeb\x7a\xf3\x50\x92\x30\xac\x69\x78\x51\x55\xda\x11\x12\xc7\xdf\x3a\xfc\x13\x27\xdb\xf2\x08\xb2\x87\x1c\xdd\x2d\x97\xda\x4e\xba\xf2\x28\xd1\x79\xad\xd8\xad\x7e\x0a\x34\x17\x53\x4c\xa9\x9d\x97\x99\xe1\x45\x56\xad\x3b\x74\x70\x84\x3c\x36\x9b\xd1\xc8\xd2\x43\x31\x38\x17\x53\x31\x81\x89\xf1\x28\x8c\xc5\x84\xc1\xcc\xd0\xca\xf2\x83\x82\x2a\x1a\x80\x07\x75\x53\xf5\xb1\xb3\xc0\x51\xb8\x07\x44\xca\x63\xc9\xb9\xa2\x59\x58\x68\x7c\xf7\xb3\x4f\xa4\x31\x4c\x50\xd1\xc2\xc0\x5c\x57\xf5\xa0\x13\x91\x77\xc1\x05\x0c\x2b\x6c\x34\xb0\xc5\x09\x35\x6f\x68\x72\xcb\x44\x8a\xe5\x87\x60\xd9\xe9\x42\xd0\xdc\xa5\xa2\x8a\x6a\x2a\x37\xfa\xeb\x9e\x33\x35\x60\xa4\x9c\x0f\xd5\x45\xae\xbb\x4f\x18\x94\xba\x73\xae\x97\x4f\x1a\x6b\x19\x6f\x3a\xe7\x1a\x8d\x30\x8a\xcf\x13\xe6\xf9\xbf\xfd\xd4\x3e\xa7\x3e\x6f\x11\x8f\xbe\x34\x79\xe7\xaa\xc8\x23\xfc\x05\x72\x1f\x8c\xdf\x90\x75\x8a\x66\xf6\x68\x2f\x42\x78\x66\x63\x73\xc7\x8b\xfd\x16\x54\x51\xe3\x2e\x61\xb4\x87\x1f\xdf\x5c\xd4\x0f\xf1\x47\x9a\x4a\x4d\xde\x64\x32\xb9\x25\x17\x0c\x84\xae\x87\x2c\x08\xa2\xc6\xe9\x53\x26\x8c\xce\xe9\x74\xdb\xed\x58\x9f\xe4\x52\x70\x23\xd5\x66\x7a\xf1\x52\x9f\xf0\x49\xd2\x11\xab\x71\xfa\xac\x93\x11\x5b\x04\xdb\xa5\x1a\xa1\x82\x63\x08\xdd\x7d\x2e\xbf\x1d\x0f\xd5\xcf\x66\xf2\xae\x6f\x64\xbf\xd4\xac\xcf\x5b\xdc\xb7\x76\x58\xdd\x2d\x5b\xc0\x25\x73\xc7\xf5\x7d\x83\xdd\x6a\xca\x81\x91\x60\x53\x82\xf7\x96\x45\x7f\x7c\x73\x61\x79\xc3\x20\x16\xf6\x4e\x98\x49\x4e\x12\x56\xcc\x4e\xdc\x87\x9f\x25\x50\x3c\xb5\xe8\x0a\x95\x33\x92\xc8\x2c\x73\xf1\xce\x72\x42\xce\x59\x31\x0b\x83\x3d\xf6\x4a\x9f\x2e\xd5\x6d\x21\x65\xd7\x94\x9f\xd1\x81\xb1\xbd\xdd\x79\x89\x10\x47\x8d\xbb\xd5\x31\x78\x2c\x54\x79\xd6\x95\x18\x1f\x10\x38\x0f\x5c\x55\xbf\x56\x4b\x3f\x76\xbd\xac\xa7\x03\xf6\x3e\x1c\x35\x72\x33\x9c\xa0\x24\x9d\xb2\x94\xc8\x39\x53\x8a\xa7\x4c\x93\x40\x6f\x62\xd5\x93\x67\x8f\x0d\xb7\x97\xcc\xc4\x4f\x9e\x99\x78\x07\x1d\x27\x22\x4f\xb6\xf7\x32\x79\xa2\x69\xce\xc5\xb3\x23\x50\x3a\xa1\x19\x1b\x7e\xe8\xa0\x4c\x8c\xb0\x47\x5d\x9f\xf0\x2f\xa3\x84\x62\x5b\xd2\x74\x7d\x13\xf0\x85\x08\x99\x6e\xb3\x8f\x3e\x80\x56\x30\xa5\x86\xdd\x6d\x65\x7f\xfd\x8a\x40\x6d\x6f\x09\x72\xe7\x53\xea\x0f\x4f\x94\x1a\x2f\xc2\x72\xcc\xfb\xb5\x4f\xf6\xe9\xf6\xa9\xab\xd1\xc5\x2f\xa4\x91\x49\xd6\x23\xea\xd9\xf5\x90\xfc\x01\x47\xde\x6f\xa6\x3e\x25\x0d\x4a\x77\x17\x32\xa7\xbc\x73\xa1\x8d\x59\xbd\x30\xb5\x9f\xee\x75\x18\x96\xe0\xb8\x71\x8d\x90\x09\x9f\x96\x56\x03\x73\x5a\xd3\x4b\x12\xb5\x47\x11\x40\x2a\xf9\x23\xb2\x04\x79\x8f\xc3\x4a\xe6\xf0\x3b\x08\x4c\x21\x5c\x4d\x12\xcd\x84\xe6\x70\x4f\x12\x5d\x56\xbb\x72\x6f\x58\x5f\x10\xdd\x0b\x51\x48\xe9\x91\x77\x72\xca\x85\x3f\x95\xd2\x5d\xa3\x4d\x28\xcf\xda\x02\xe3\x45\xaa\x78\x72\xa9\x42\xeb\xec\x52\xd0\x71\xd6\xc6\x0b\xa0\x4e\xd6\x33\x0a\xf7\x9c\x0c\x7a\x9f\xa4\x5c\xdb\xff\x93\xd1\xe8\x1d\xd8\xc4\x4b\xe1\x65\x5d\xb0\x17\x3b\xb2\x16\x3c\xfd\xf1\x00\xee\xf7\xcc\x20\xa5\xd9\x21\xc7\xdd\x50\xa4\x76\xb2\x4c\xd7\xdc\x4e\xdc\x78\x98\xe9\x2f\x78\xce\xe2\xcd\xfd\x98\x91\x9b\x19\x4f\x6e\xaf\x23\xd3\xb7\x54\xf6\x9d\x88\x5e\xd5\x98\x50\xf3\xb7\x7d\x12\x44\x37\xd5\xeb\xee\x0a\xec\x4d\x44\xcf\x47\x6e\xc1\x76\x18\x42\xb5\x96\x09\xaf\xee\x39\xc0\x5c\x52\x11\xfc\x14\x08\xfe\x7e\x17\x01\x3c\xfd\x9e\xbc\xc9\x6f\x9a\xaf\x7a\xaa\x63\x5e\xc4\x85\x5f\xeb\x5e\x27\x8e\xa8\xb1\x43\x96\xee\x9b\x5a\x5e\x6e\x2f\x9b\x36\x8c\xf6\xde\x8b\xdb\x6d\x92\x97\x92\x7c\x95\xc5\xa5\x6d\x0a\xf9\xb9\x5d\x5e\xbe\xbd\x2d\xb5\x4d\x20\xc3\x2a\x6d\xb8\x71\x53\x87\xef\x9c\x19\x1f\x0e\x53\x21\x8b\x32\x43\x5f\x89\xfb\x27\x17\xf7\xd6\x59\xfc\xce\x9e\xcc\xfa\x8f\x91\x68\xb3\xab\x23\xf0\x8f\x23\xe7\x66\x24\x92\xbd\xfa\xd5\xd7\x5f\xff\xd0\xb3\x70\xb6\x55\x81\x1f\x22\x0d\x67\x4b\x93\xe8\x4b\xa4\xcd\x4b\xa4\x4d\x8c\x8a\x0f\x99\x46\x75\xcf\xb1\x34\x1d\x5d\x5c\xbb\xb9\xb7\xb6\x8f\x96\x69\xed\x04\xdb\xd5\x01\xb6\x43\x3c\xcc\x9e\xa2\x60\x3a\xfb\x82\x76\x89\x78\x79\x89\x73\xf9\xb1\xc5\xb9\xec\xe2\x03\xda\x3d\xa6\xa5\x8b\xef\xe7\x8f\x29\x7e\xa5\xc3\x61\x6c\x1f\x67\xd1\x3d\xba\xa2\x7b\x3e\xbb\xee\x96\xad\x5d\x4a\x1a\xc5\xf6\x19\xa7\x45\x54\x15\x04\x7d\xe1\x41\xcc\x8f\x65\xa4\x3d\x58\x8f\xa2\x43\x90\x0e\x0a\x14\x0e\x2f\xbb\xd4\x12\x74\x3a\xf9\x87\x51\xe3\x6a\x23\xbc\x7e\x9a\x1b\x8d\x1f\xe7\x95\xc1\x4b\x61\x90\xe7\x6d\xd3\xd6\xb5\xdc\x22\xde\x92\x00\x67\x1d\x18\xb1\x1c\xc7\x39\x0d\xab\x33\x72\x76\x3d\xb4\xea\x32\x84\xcf\xd0\x4c\x0f\xc8\x0a\x3e\xed\xed\x92\x8e\xaf\x7b\xfe\x4c\x8d\x61\x79\x61\xda\x6f\xf6\x8b\x49\xfb\xc9\x4d\xda\x3b\xdb\xe3\x3e\x87\x8e\xa1\x02\x64\x99\x53\xd1\xb7\x27\x0a\x8c\xdb\xb5\x5b\xb0\x06\x09\x1e\x10\xef\x95\x8b\xb0\xa0\x8a\x61\xd2\xa7\x7a\xc5\x5b\x1a\xd5\x3f\x7c\x18\x23\x24\x8c\xbd\xf3\xca\x91\x81\x36\x4e\x5a\x22\x97\xdc\x3e\xdd\x72\x02\x14\xfc\xa1\x8a\xb8\x70\x4d\x6f\x36\x33\x86\xcc\xfa\x1a\x02\x51\xaa\x56\x75\x49\x18\x45\x61\x9a\x65\xf2\x0e\xbf\x1d\x33\x30\x0b\x7d\x3b\x17\x17\x61\x35\x66\x24\xe7\x56\xa9\x76\xc6\xcf\x78\x3a\x78\x15\x69\x25\x6a\xa6\x50\x60\x55\xee\x36\x6b\xc4\x4c\xbc\xd1\x56\x21\x15\xe8\x08\x6d\xff\xed\x1d\x6f\x30\x2b\xae\xa3\x09\x63\x36\xa3\x73\x2e\x4b\x85\xbd\x8d\x24\x07\xee\x27\x60\x09\x0b\x59\x06\xd3\x14\x56\x49\x0c\xab\xd3\x2b\xe0\x74\x55\xfd\x08\xa2\x7c\x2a\xbd\x2d\xa1\xcf\xbe\x70\x6d\x96\xd7\xe2\x41\xe4\x93\xb6\xed\x0b\x6f\xe6\xba\xb0\x6c\xa1\x73\x45\xb4\xcf\x71\xbf\xba\x60\x32\x1f\xc1\x4f\x3f\xa0\x7a\x68\x5b\x73\x91\xbe\xc8\x3a\xfb\x96\x75\xc2\x75\x55\xc6\x93\x45\xe7\x4a\x61\xd5\x35\x95\xed\x4e\xde\x50\xcd\x52\xf2\x9e\x0a\x3a\x45\xb5\xec\x68\x74\xfd\xe6\xfd\xb1\xdd\x36\x50\xfb\x86\x17\x2b\xef\xb2\x46\xf1\x1c\xae\xf6\x19\x06\xb1\xb4\xc2\x1d\x38\x51\xc7\x35\xee\x35\x8c\x83\x04\x6e\xd2\x2e\x41\xec\x72\xe8\x65\xb3\xc6\x63\x83\x28\xcc\xf3\xf4\x9e\x55\x1d\xb9\xd0\x86\x66\xd9\x75\x46\xc5\x59\x51\x28\x39\x5f\xad\x09\xd7\x03\xc3\x5d\x43\xcf\xda\xd1\xf7\xc1\xbf\x2c\x10\xd0\x70\xd7\x2b\xc8\xb0\x1a\x7f\x40\x86\x26\x28\xc4\x52\x00\x1b\x3c\x38\x2b\x8d\xcc\xa9\xe1\xc9\x81\xd5\x9b\x0f\xde\x53\x51\xd2\x6c\xa5\x87\xd1\xc6\x65\xac\x13\xeb\x36\x76\x5a\x9f\x1c\xad\x45\xb7\x8d\xf2\xc1\xe6\xfe\x86\x2a\x4b\x5b\xce\x47\x9f\x3b\xf5\xd5\x86\x9a\x72\x89\x72\x6e\xa0\xe6\xeb\xe9\x77\x9f\x64\x54\x9b\x4f\x45\x6a\x4f\x72\xe3\xd7\x4d\x44\x3a\xa1\x86\x66\x72\xfa\x47\x46\xb3\xd5\xf8\x5c\xc3\x93\xf3\xb8\xb5\x37\xfe\x20\xca\x8c\xca\x71\x68\x78\xa8\x89\x15\x8a\x7d\xbc\xb6\x62\x19\x9b\x53\x61\x7c\x77\xac\x94\xad\x0f\xdd\xfa\x01\x8b\x78\x65\xf0\x4c\x99\x61\x2a\xe7\xa2\x3e\xe6\x08\xda\x9e\x4b\x91\x72\x34\xf5\x81\x31\x0b\x7b\xd4\xc7\x5d\x8f\x6a\xeb\xcc\xf9\x1b\x0c\xf8\x75\xca\x13\xcd\xa7\x0e\x0a\x6c\x36\x76\x32\xe1\x0c\x5f\xc2\xcd\x75\x6d\x6e\x4b\x90\x22\xb7\xc2\x0a\x73\x90\xf3\x62\x35\x91\xda\xca\xdb\xb7\xf1\xf4\xbe\xdf\x63\x9c\xc2\x7a\xbf\xc8\xbe\x9b\xf7\x3a\x43\xff\x26\x14\xc3\x67\xbb\x34\xd0\x9c\xca\x7a\x0a\xba\x0a\xef\x42\x37\x0c\xee\x6b\x54\x57\xaf\x35\x5a\x4f\xf1\x5b\x09\x4b\xed\xe4\x9a\xb6\x79\xd3\xeb\xb4\xb6\xca\xf2\xbd\xa4\x7e\xb6\x90\xf2\xb6\xb2\xa8\x96\xe9\xcb\xeb\xca\xf0\xd0\x39\xc5\x29\xa7\x3e\x50\x52\x70\x86\x89\x3a\xa8\x70\xc0\x02\xce\xc2\x68\xea\x5e\x5a\x0e\x66\xd5\x38\xf8\xad\xe7\xee\x9a\xd1\xb0\xeb\x7c\x17\xbc\x71\x98\x62\xa2\x0a\xb8\x2c\x38\xf9\x83\x74\x17\xa5\x2e\xa0\xd4\xd2\x00\xe0\xdb\x3d\xa2\xcb\x64\x46\xa8\xb6\x53\xb3\x08\x6d\x4f\x3c\x1b\xe4\x54\xf0\x09\xd3\x66\x10\xf2\xd0\xea\x3f\xff\xf2\xaf\x03\xf2\x56\x2a\xe2\xfc\xb0\x7b\x3e\x03\x84\x9b\x67\x85\x17\x5c\xe3\x62\x42\xdf\x4a\xd3\x2c\x64\xea\x26\x7d\x07\x93\x35\xf4\xd6\xf2\x30\x9c\x6c\xc9\xe0\xba\xe0\x94\x1c\x58\x21\x2f\xfa\xf4\x3f\x2d\x5b\xfa\xf7\x01\x39\xba\x03\xa6\x7d\x60\xff\x3c\xc0\x0f\x06\x5f\xc2\x58\x11\xae\x3e\x8c\x61\x7e\x8a\x4f\xa7\x4c\xa1\xca\x47\x20\x1c\xee\xd8\x65\xb0\x10\x32\x6a\xec\x6f\x7e\x2b\x15\xb1\x39\x91\x3f\xff\xf2\xaf\x07\xe4\xa8\xbe\x2e\xc2\x45\xca\xbe\x90\x5f\xa2\xe9\x97\x6b\xbb\xc6\x63\x77\x81\xa2\x17\xc2\xd0\x2f\x76\xcc\x64\x26\x35\x13\xa8\x7e\x1b\x49\x66\x74\xce\x88\x96\x56\x6b\x65\x59\xd6\x77\x66\x6d\x72\x47\x21\xab\x88\x07\x25\x04\x81\x93\x82\x2a\x53\x43\x89\x81\xb3\x6a\xc0\xd7\xec\xb6\x4d\x85\xbf\xfe\x9d\x70\xe1\xee\x8c\xdc\x6d\x95\xdd\x73\x08\x69\xc4\x4d\x32\x92\x24\x33\x2a\xa6\x21\x8e\x7a\x52\x9a\x52\xb1\x2d\xd7\x2d\x2d\xcf\xc0\x2d\x17\x9d\xc2\x6d\xbf\xe1\xa2\x79\x73\xbf\xda\x16\x34\xe5\xc6\x3b\xfd\x3b\x47\x3e\xb3\x38\xb1\xbb\xa0\xf8\xb8\x34\x52\xe9\x93\x94\xcd\x59\x76\xa2\xf9\xb4\x4f\x55\x32\xe3\x86\x25\x76\x59\x27\xb4\xe0\xfd\x44\x0a\xbb\xe3\x90\x41\x20\x4f\x7f\x06\x45\x30\xfb\x76\xaa\x5b\xf2\x1a\xb7\x5c\xf4\x76\x43\xd8\x93\x1a\xc0\xf6\xb6\xc6\x16\x36\x9c\xe5\x85\xa2\x3d\xe5\x11\x56\x0b\xc6\x8b\x93\xbd\x2c\xd6\xa7\xe5\xed\xce\x63\x0e\x5d\xa6\xe9\xa4\x39\x86\x3d\x76\xe8\xa5\x01\xa7\xb2\x46\x29\x73\x9a\x22\x29\xa5\x62\xf1\xe0\xc8\x6f\x41\x0a\x09\xd9\x93\x45\x3f\xc1\xfa\xf6\x7d\x2a\x52\xfb\x6f\x8c\x47\x49\x16\x7b\x81\x61\xc9\x3b\x11\x82\x4f\xc3\x8b\xc7\x39\x12\x25\xdf\xc3\xa9\x77\xf2\x5a\x4b\x21\x0a\x45\x55\x70\xd9\x31\xaa\x64\x9e\x69\xd6\x05\x54\xae\xfd\xa8\xff\xed\xee\x4c\x42\x66\xae\x6d\x22\xd5\xe6\x9b\x8e\x48\x76\x6c\x39\xdf\x77\x55\x8f\x66\x4d\x7c\x3b\x98\x4b\x03\xe5\xa3\xe7\x6b\xcb\xf0\x0a\x0a\x30\x98\xf5\x77\xb4\xad\x70\xc8\xdf\xd1\xdb\x89\xf4\x57\xe6\x07\x4a\x82\x52\xb2\x5d\x81\xaa\xf4\x97\x5a\xa5\x2d\x5c\x94\x61\xda\x10\x3a\xa7\x3c\x03\x8b\xba\x1c\x6b\xa6\xe6\x58\xf2\xc8\xa5\xc5\xa3\x4d\x3d\xcb\x55\x35\x40\x31\xea\x91\x34\x1f\xbf\x86\xe5\x5d\xd9\xb4\x00\xd0\x86\x1a\xb3\x5f\x3b\xeb\xbd\xe8\x3d\xa8\x5e\xae\xfd\xd9\x7e\x61\x47\x35\xc6\xe2\xdf\x1f\x19\x55\x66\xcc\xa8\xb9\xe1\x9b\xf8\xee\x12\x4a\xd7\xfa\x79\x83\x4b\x85\xd0\x77\x8c\x4c\xa5\xb1\x22\x56\x09\xb8\x8f\x32\x29\x26\xa0\x09\x88\xf6\xd0\x18\x5d\xad\xf2\x46\x51\x88\x7b\x91\xa2\xe3\x32\xeb\x1d\x97\xd7\xe9\xa4\x63\x87\x49\x06\x5b\x63\x0a\x08\x29\x98\xdb\x3b\xbc\x81\x00\x0a\xf4\x38\x4b\xce\x99\xd6\x1b\x53\x43\xd4\x5d\xf8\xb0\x35\x1e\xe5\xc6\x75\x58\xee\x7f\xc3\xf8\x09\x2b\x40\xa7\xcc\x50\x9e\xf9\xa3\x8c\xa0\x08\x50\xda\x46\x5d\x37\x2e\x50\x31\xaa\x37\x09\x08\xcd\x8c\x58\x5a\x0a\x9c\xb4\x14\xac\x7f\x27\x55\x4a\xce\x69\xce\xb2\x73\xaa\x99\x1b\x2b\x0e\x57\xc3\x3d\x3a\xd4\x7b\x9d\xf2\x6a\xdb\xd7\x9a\x29\xa3\xf1\xc7\x23\x91\xc3\x8d\x4a\xc5\xc2\x09\xf6\xbc\x09\xf2\x46\x95\xac\x47\xde\x5a\xee\xd5\x23\x9f\xc4\xad\x90\x77\xf7\x9b\xab\xd9\x78\x73\x51\x77\xb3\x72\x99\x5b\x20\x45\x9e\x4b\x08\x53\x33\xf8\x84\xe9\xee\x38\x23\x47\xf0\xd7\x98\x1a\xeb\xcc\x26\x34\xf5\x33\xb2\xff\x5c\x32\x41\x59\x45\x51\xc9\xa9\x62\x1a\x73\xae\xac\x4c\xe8\xd7\xd6\xe4\xfc\x07\x26\x5c\xc4\xdb\xd6\xe9\x0d\x57\xf5\xf2\x33\xf5\x7c\x6d\x5a\xfd\xe2\xf6\xdb\x7d\xac\xc8\x56\x8a\x1a\x9b\xbd\xf0\xa2\x89\xae\x31\x3e\xad\x9b\xe1\x6a\xa3\x53\xc4\xf5\xa2\xb6\x28\x94\x6c\xb2\x8e\xfa\xd5\x9d\x8f\x3e\xaf\x07\xf6\x5a\xde\xb7\x8d\x3f\x6d\x37\x4b\xdd\xd7\x20\xb5\xf5\xcc\x6c\x35\x42\xbd\x98\x9f\x5e\xcc\x4f\x3f\x24\xf3\xd3\x56\x8c\xdf\x64\x72\xfa\x61\x18\x9b\xb6\x2e\x71\x93\x81\xe9\x59\x9a\x96\x5a\xad\x68\xa3\x39\xe9\xd9\x1a\x92\xb6\x2e\xad\xa5\xf1\xe8\xa7\x63\x36\xda\x0a\xb1\x0d\xa6\xa2\x67\x68\x24\x6a\x23\x90\xb1\xb4\x8d\x98\x38\x8c\x1a\xc7\x82\x62\x55\x30\x31\x0c\xe7\x5d\x6a\x62\x71\x66\x57\x69\xd1\x0a\x70\x5b\xe7\x76\xe8\x26\xd7\x5e\xf6\x72\x02\xa3\x2b\x27\xb8\x34\x59\x72\x71\x79\xfd\xf1\xf2\xfc\xec\xe6\xf2\xa2\x29\xdf\xad\x82\xf4\x16\x49\x6c\xb3\x0d\xa2\x1f\x49\x62\x6b\x1a\x58\x82\xbc\xe6\x27\x8b\x03\x6b\x7e\x2a\x4b\xbe\xaa\xd7\xfd\xe5\xc2\x7b\x71\xb9\x7b\xf1\x8f\xed\xa7\xb3\xed\xf1\xb4\xa7\x13\xb0\x05\x3d\xc6\xac\xdc\x33\x93\x59\xaa\xbd\xaf\xe9\xf0\x22\x44\x2f\x71\x91\x64\x65\x6a\x85\x8b\x4f\x9f\x86\x17\x7a\x40\xc8\x1b\x96\xd0\x52\x83\x15\x26\x95\xe2\xd0\x90\x0f\x57\xef\xfe\x04\x3e\xd4\xd0\xa2\x17\x92\x7d\x40\x06\x59\x4e\x31\x09\xae\xc1\x2c\x64\xe4\x0d\x43\x41\x05\xbe\x9c\xd0\xc2\x52\x31\x8d\x55\x16\x0c\xc8\x22\x33\x96\x15\x96\x62\xde\x32\x52\xe5\xfe\xb4\x03\x57\x35\xcc\xbd\xcb\xe3\x94\x19\x8c\x74\xda\xe4\xd5\xb8\x11\x6a\x5b\x2c\xae\xf7\xb0\xb5\xd6\xd4\x47\xa7\x8d\xdf\x51\xed\x2c\x56\x2b\x67\xbb\x65\x7f\xb7\xdb\x67\xd6\x9b\x38\xd6\x18\x37\x90\x3c\xc3\x5f\x4b\x73\xb6\x93\xad\xec\x18\xe8\x44\xc2\x4d\x6b\x6b\xea\x7a\x37\xa0\xd5\x39\xeb\x97\x6c\x19\xac\x09\xe4\xda\x87\x83\x17\x75\x34\xe5\x76\x73\x81\x82\x17\x69\xad\xba\xa4\xf3\xb6\xab\xbf\x2b\xc7\xa1\xbe\x68\x35\x5f\x67\x91\x21\xff\xfc\xf7\x57\xff\x3f\x00\x00\xff\xff\x20\x70\xf2\xef\xc3\xac\x01\x00") func operatorsCoreosCom_subscriptionsYamlBytes() ([]byte, error) { return bindataRead( diff --git a/staging/api/go.mod b/staging/api/go.mod index d78ff4fecd..914c092974 100644 --- a/staging/api/go.mod +++ b/staging/api/go.mod @@ -1,6 +1,6 @@ module github.com/operator-framework/api -go 1.16 +go 1.17 require ( github.com/blang/semver v3.5.1+incompatible @@ -8,15 +8,87 @@ require ( github.com/ghodss/yaml v1.0.0 github.com/go-bindata/go-bindata/v3 v3.1.3 github.com/google/cel-go v0.9.0 - github.com/mikefarah/yq/v3 v3.0.0-20201202084205-8846255d1c37 + github.com/google/go-cmp v0.5.6 // indirect github.com/sirupsen/logrus v1.8.1 github.com/spf13/cobra v1.2.1 github.com/stretchr/testify v1.7.0 google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2 - k8s.io/api v0.22.1 - k8s.io/apiextensions-apiserver v0.22.1 - k8s.io/apimachinery v0.22.1 - k8s.io/client-go v0.22.1 - sigs.k8s.io/controller-runtime v0.10.0 - sigs.k8s.io/controller-tools v0.6.2 + k8s.io/api v0.23.0 + k8s.io/apiextensions-apiserver v0.23.0 + k8s.io/apimachinery v0.23.0 + k8s.io/client-go v0.23.0 + sigs.k8s.io/controller-runtime v0.11.0 +) + +require ( + github.com/PuerkitoBio/purell v1.1.1 // indirect + github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect + github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e // indirect + github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/cespare/xxhash/v2 v2.1.1 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/felixge/httpsnoop v1.0.1 // indirect + github.com/go-logr/logr v1.2.0 // indirect + github.com/go-openapi/jsonpointer v0.19.5 // indirect + github.com/go-openapi/jsonreference v0.19.5 // indirect + github.com/go-openapi/swag v0.19.14 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/golang/protobuf v1.5.2 // indirect + github.com/google/gofuzz v1.1.0 // indirect + github.com/googleapis/gnostic v0.5.5 // indirect + github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect + github.com/imdario/mergo v0.3.12 // indirect + github.com/inconshreveable/mousetrap v1.0.0 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/kisielk/errcheck v1.5.0 // indirect + github.com/mailru/easyjson v0.7.6 // indirect + github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect + github.com/mitchellh/mapstructure v1.4.1 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/prometheus/client_golang v1.11.0 // indirect + github.com/prometheus/client_model v0.2.0 // indirect + github.com/prometheus/common v0.28.0 // indirect + github.com/prometheus/procfs v0.6.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/stoewer/go-strcase v1.2.0 // indirect + go.opentelemetry.io/contrib v0.20.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.20.0 // indirect + go.opentelemetry.io/otel v0.20.0 // indirect + go.opentelemetry.io/otel/exporters/otlp v0.20.0 // indirect + go.opentelemetry.io/otel/metric v0.20.0 // indirect + go.opentelemetry.io/otel/sdk v0.20.0 // indirect + go.opentelemetry.io/otel/sdk/export/metric v0.20.0 // indirect + go.opentelemetry.io/otel/sdk/metric v0.20.0 // indirect + go.opentelemetry.io/otel/trace v0.20.0 // indirect + go.opentelemetry.io/proto/otlp v0.7.0 // indirect + golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 // indirect + golang.org/x/mod v0.4.2 // indirect + golang.org/x/net v0.0.0-20210825183410-e898025ed96a // indirect + golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f // indirect + golang.org/x/sys v0.0.0-20211029165221-6e7872819dc8 // indirect + golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect + golang.org/x/text v0.3.7 // indirect + golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect + golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff // indirect + golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect + google.golang.org/appengine v1.6.7 // indirect + google.golang.org/grpc v1.40.0 // indirect + google.golang.org/protobuf v1.27.1 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect + gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect + k8s.io/apiserver v0.23.0 // indirect + k8s.io/component-base v0.23.0 // indirect + k8s.io/klog/v2 v2.30.0 // indirect + k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65 // indirect + k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b // indirect + sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.25 // indirect + sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6 // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.2.0 // indirect + sigs.k8s.io/yaml v1.3.0 // indirect ) diff --git a/staging/api/go.sum b/staging/api/go.sum index a0e005cfc0..a456becd20 100644 --- a/staging/api/go.sum +++ b/staging/api/go.sum @@ -37,17 +37,13 @@ cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohl cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= -github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8= github.com/Azure/go-ansiterm v0.0.0-20210608223527-2377c96fe795/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8= github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= github.com/Azure/go-autorest v14.2.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24= -github.com/Azure/go-autorest/autorest v0.11.12/go.mod h1:eipySxLmqSyC5s5k1CLupqet0PSENBEDP93LQ9a8QYw= github.com/Azure/go-autorest/autorest v0.11.18/go.mod h1:dSiJPy22c3u0OtOKDNttNgqpNFY/GeWa7GH/Pz56QRA= -github.com/Azure/go-autorest/autorest/adal v0.9.5/go.mod h1:B7KF7jKIeC9Mct5spmyCB/A8CG/sEz1vwIRGv/bbw7A= github.com/Azure/go-autorest/autorest/adal v0.9.13/go.mod h1:W/MM4U6nLxnIskrw4UwWzlHfGjwUS50aOsc/I3yuU8M= github.com/Azure/go-autorest/autorest/date v0.3.0/go.mod h1:BI0uouVdmngYNUzGWeSYnokU+TrmwEsOqdt8Y6sso74= github.com/Azure/go-autorest/autorest/mocks v0.4.1/go.mod h1:LTp+uSrOhSkaKrUy935gNZuuIPPVsHlr9DSOxSayd+k= -github.com/Azure/go-autorest/logger v0.2.0/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZmbF5NWuPV8+WeEW8= github.com/Azure/go-autorest/logger v0.2.1/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZmbF5NWuPV8+WeEW8= github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= @@ -68,7 +64,6 @@ github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kd github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e h1:GCzyKMDDjSGnlpl3clrdAK7I1AaVoaiKDOYkUzChZzg= github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e/go.mod h1:F7bn7fEU90QkQ3tnmaTx3LTKLEDqnwWODIYppRQ5hnY= github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= -github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a h1:idn718Q4B6AGu/h5Sxe66HYVdqdGu2l9Iebqhi/AEoA= @@ -102,23 +97,17 @@ github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGX github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8= github.com/cockroachdb/datadriven v0.0.0-20200714090401-bf6692d28da5/go.mod h1:h6jFvWxBdQXxjopDMZyH2UVceIRfR84bdzbkoKrsWNo= github.com/cockroachdb/errors v1.2.4/go.mod h1:rQD95gz6FARkaKkQXUksEje/d9a6wBJoCr5oaCLELYA= github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk= -github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/go-oidc v2.1.0+incompatible/go.mod h1:CgnwVTmzoESiwO9qyAFEMiHoZ1nMCKZlZ9V6mm3/LKc= -github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= -github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= -github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= -github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/creack/pty v1.1.11/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -127,7 +116,6 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ= github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no= github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= -github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc= github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs= @@ -141,19 +129,17 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.m github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/evanphx/json-patch v0.5.2/go.mod h1:ZWS5hhDbVDyob71nXKNL0+PWn6ToqBHMikGIFbs31qQ= -github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= -github.com/evanphx/json-patch v4.11.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= +github.com/evanphx/json-patch v4.12.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= -github.com/fatih/color v1.12.0 h1:mRhaKNwANqRgUBGKmnI5ZxEk7QXmjQeCcuYFMX2bfcc= -github.com/fatih/color v1.12.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= github.com/felixge/httpsnoop v1.0.1 h1:lvB5Jl89CsZtGIWuTcDM1E/vkVs49/Ml7JJe07l8SPQ= github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/form3tech-oss/jwt-go v3.2.2+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k= github.com/form3tech-oss/jwt-go v3.2.3+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWpgI= +github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU= +github.com/getkin/kin-openapi v0.76.0/go.mod h1:660oXbgy5JFMKreazJaQTw7o+X00qeSyhcnluiMv+Xg= github.com/getsentry/raven-go v0.2.0/go.mod h1:KungGk8q33+aIAZUIVWZDr2OfAEBsO49PX4NzFV5kcQ= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= @@ -170,31 +156,20 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas= github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= -github.com/go-logr/logr v0.4.0 h1:K7/B1jt6fIBQVd4Owv2MqGQClcgf0R266+7C/QjRcLc= -github.com/go-logr/logr v0.4.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= -github.com/go-logr/zapr v0.4.0/go.mod h1:tabnROwaDl0UNxkVeFRbY8bwB37GwRv0P8lg6aAiEnk= -github.com/go-openapi/jsonpointer v0.19.2/go.mod h1:3akKfEdA7DF1sugOqz1dVQHBcuDBPKZGEoHC/NkiQRg= +github.com/go-logr/logr v1.2.0 h1:QK40JKJyMdUDz+h+xvCsru/bJhvG0UxvePV0ufL/AcE= +github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/zapr v1.2.0/go.mod h1:Qa4Bsj2Vb+FAVeAKsLD8RLQ+YRJB8YDmOAKxaBQf7Ro= github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= github.com/go-openapi/jsonpointer v0.19.5 h1:gZr+CIYByUqjcgeLXnQu2gHYQC9o73G2XUeOFYEICuY= github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= -github.com/go-openapi/jsonreference v0.19.2/go.mod h1:jMjeRr2HHw6nAVajTXJ4eiUwohSTlpa0o73RUL1owJc= github.com/go-openapi/jsonreference v0.19.3/go.mod h1:rjx6GuL8TTa9VaixXglHmQmIL98+wF9xc8zWvFonSJ8= github.com/go-openapi/jsonreference v0.19.5 h1:1WJP/wi4OjB4iV8KVbH73rQaoialJrqv8gitZLxGLtM= github.com/go-openapi/jsonreference v0.19.5/go.mod h1:RdybgQwPxbL4UEjuAruzK1x3nE69AqPYEJeo/TWfEeg= -github.com/go-openapi/spec v0.19.3/go.mod h1:FpwSN1ksY1eteniUU7X0N/BgJ7a4WvBFVA8Lj9mJglo= -github.com/go-openapi/spec v0.19.5/go.mod h1:Hm2Jr4jv8G1ciIAo+frC/Ft+rR2kQDh8JHKHb3gWUSk= -github.com/go-openapi/swag v0.19.2/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= github.com/go-openapi/swag v0.19.14 h1:gm3vOOXfiuw5i9p5N9xJvfjvuofpyvLA9Wr6QfK5Fng= github.com/go-openapi/swag v0.19.14/go.mod h1:QYRuS/SOXUCsnplDa677K7+DxSOj6IPNl/eQntq43wQ= -github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= -github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= -github.com/gobuffalo/flect v0.2.3 h1:f/ZukRnSNA/DUpSNDadko7Qc0PhGvsew35p/2tu+CRY= -github.com/gobuffalo/flect v0.2.3/go.mod h1:vmkQwuZYhN5Pc4ljYQZzP+1sq+NEkK+lh20jmEmX3jc= -github.com/goccy/go-yaml v1.8.1 h1:JuZRFlqLM5cWF6A+waL8AKVuCcqvKOuhJtUQI+L3ez0= -github.com/goccy/go-yaml v1.8.1/go.mod h1:wS4gNoLalDSJxo/SpngzPQ2BN4uuZVLCmbM4S3vd4+Y= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= @@ -203,7 +178,6 @@ github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= -github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -273,27 +247,21 @@ github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLe github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= -github.com/googleapis/gnostic v0.4.1/go.mod h1:LRhVm6pbyptWbWbuZ38d1eyptfvIytN3ir6b65WBswg= github.com/googleapis/gnostic v0.5.1/go.mod h1:6U4PtQXGIEt/Z3h5MAT7FNofLnw9vXk2cUuW7uA/OeU= github.com/googleapis/gnostic v0.5.5 h1:9fHAtK0uDfpveeqqo1hkEZJcFvYXAiCN3UutL8F9xHw= github.com/googleapis/gnostic v0.5.5/go.mod h1:7+EbHbldMins07ALC74bsA81Ovc97DwqyJO1AENw9kA= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= -github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= -github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= +github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA= github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= -github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= -github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= @@ -331,10 +299,10 @@ github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8Hm github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= -github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/json-iterator/go v1.1.11 h1:uVUAXhF2To8cbw/3xN3pxj6kk7TYKs98NIrTqPlMWAQ= github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= @@ -352,40 +320,21 @@ github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFB github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= -github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= -github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs= github.com/mailru/easyjson v0.7.6 h1:8yTIVnZgCoiM1TgqoeTl+LfU5Jg6/xL3QhGQnimLYnA= github.com/mailru/easyjson v0.7.6/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= -github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= -github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8= -github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= -github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= -github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84= -github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= -github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY= -github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= -github.com/mikefarah/yq/v3 v3.0.0-20201202084205-8846255d1c37 h1:lPmsut5Sk7eK2BmDXuvNEvMbT7MkAJBu64Yxr7iJ6nk= -github.com/mikefarah/yq/v3 v3.0.0-20201202084205-8846255d1c37/go.mod h1:dYWq+UWoFCDY1TndvFUQuhBbIYmZpjreC8adEAx93zE= github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= @@ -397,14 +346,14 @@ github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag= github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/moby/spdystream v0.2.0/go.mod h1:f7i0iNDQJ059oMTcWxx8MA/zKFIuD/lY+0GqbN2Wy8c= -github.com/moby/term v0.0.0-20201216013528-df9cb8a40635/go.mod h1:FBS0z0QWA44HXygs7VXDUOGoN/1TV3RuWkLO04am3wc= github.com/moby/term v0.0.0-20210610120745-9d4ed1856297/go.mod h1:vgPCkQMyxTZ7IDy8SXRufE172gr8+K/JE/7hHFxHW3A= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= @@ -416,21 +365,18 @@ github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= -github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= -github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= +github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= +github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= -github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= -github.com/onsi/gomega v1.14.0/go.mod h1:cIuvLEne0aoVhAgh/O6ac0Op8WWw9H6eYCriF+tEHG0= -github.com/onsi/gomega v1.15.0 h1:WjP/FQ/sk43MRmnEcT+MlDw2TFvkrXlprrPST/IudjU= -github.com/onsi/gomega v1.15.0/go.mod h1:cIuvLEne0aoVhAgh/O6ac0Op8WWw9H6eYCriF+tEHG0= +github.com/onsi/gomega v1.17.0 h1:9Luw4uT5HTjHTN8+aNcSThgH1vdXnmdJ8xIfZ4wyTRE= +github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= @@ -438,7 +384,6 @@ github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCko github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= @@ -460,13 +405,13 @@ github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7q github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= -github.com/prometheus/common v0.26.0 h1:iMAkS2TDoNWnKM+Kopnx/8tnEStIfpYA0ur0xQzzhMQ= github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= +github.com/prometheus/common v0.28.0 h1:vGVfV9KrDTvWt5boZO0I19g2E3CsWfpPPKZM9dt3mEw= +github.com/prometheus/common v0.28.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= -github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= github.com/prometheus/procfs v0.6.0 h1:mxy4L2jP6qMonqmq+aTtOx1ifVWUgG/TAmntgbh3xv4= github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= @@ -494,27 +439,20 @@ github.com/spf13/afero v1.6.0 h1:xoax2sJ2DT8S8xA2paPFjDCScCNeWsg75VG0DLRreiY= github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= -github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= -github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE= -github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI= github.com/spf13/cobra v1.1.3/go.mod h1:pGADOWyqRD/YMrPZigI/zbliZ2wVD/23d+is3pSWzOo= github.com/spf13/cobra v1.2.1 h1:+KmjbUw1hriSNMF55oPrkZcb27aECyrj8V2ytv7kWDw= github.com/spf13/cobra v1.2.1/go.mod h1:ExllRjgxM/piMAM+3tAZvg8fsklGAf3tPfi+i8t68Nk= github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= -github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= -github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE= github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns= github.com/stoewer/go-strcase v1.2.0 h1:Z2iHWqGXH00XYgqDmNgQbIBxf3wrNq0F3feEy0ainaU= github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= @@ -523,23 +461,17 @@ github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= -github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tmc/grpc-websocket-proxy v0.0.0-20201229170055-e5319fda7802/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= -github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= -github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= -github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= -go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= -go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4= -go.etcd.io/etcd v0.5.0-alpha.5.0.20200910180754-dd1b699fc489/go.mod h1:yVHk9ub3CSBatqGNg7GRmsnfLWtoW60w4eDYfh7vHDg= go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ= @@ -577,26 +509,27 @@ go.opentelemetry.io/otel/trace v0.20.0 h1:1DL6EXUdcg95gukhuRRvLDO/4X5THh/5dIV52l go.opentelemetry.io/otel/trace v0.20.0/go.mod h1:6GjCW8zgDjwGHGa6GkyeB8+/5vjT16gUEi0Nf1iBdgw= go.opentelemetry.io/proto/otlp v0.7.0 h1:rwOQPCuKAKmwGKq2aVNnYIibI6wnV7EvzgfTCzcdGg8= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= -go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/goleak v1.1.12/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= go.uber.org/zap v1.19.0/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= +go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= +golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -630,7 +563,6 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.1-0.20200828183125-ce943fd02449/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo= @@ -648,13 +580,11 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -677,12 +607,12 @@ golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210224082022-3d97a244fca7/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= -golang.org/x/net v0.0.0-20210520170846-37e1c6afe023/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210825183410-e898025ed96a h1:bRuuGXV8wwSdGTB+CtJf+FjgO1APK1CoO39T4BN/XBw= golang.org/x/net v0.0.0-20210825183410-e898025ed96a/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -696,8 +626,10 @@ golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602 h1:0Ja1LBD+yisY6RWM/BH7TJVXWsSjs2VwBSmvSX4HdBc= golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f h1:Qmd2pbz05z7z6lm0DrgQVVPuBm92jqujBKMHMOlOQEw= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -717,29 +649,23 @@ golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190616124812-15dcb6c0061f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -772,17 +698,18 @@ golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210817190340-bfb29a6856f2/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e h1:XMgFehsDnnLGtjvjOfqWSUzt0alpTR1RSEuznObga2c= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= +golang.org/x/sys v0.0.0-20211029165221-6e7872819dc8 h1:M69LAlWZCshgp0QSzyDcSsSIejIEeuaCVpmwcKwyLMk= +golang.org/x/sys v0.0.0-20211029165221-6e7872819dc8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE= -golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE= +golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -793,7 +720,6 @@ golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -813,7 +739,6 @@ golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBn golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190614205625-5aca471b1d59/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190624222133-a101b041ded4/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= @@ -858,8 +783,9 @@ golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.5 h1:ouewzE6p+/VEB31YYnTbEJdi8pFqKp4P4n85vwo3DHA= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff h1:VX/uD7MK0AHXGiScH3fsieUQUcpmRERPDYtqZdJnA+Q= +golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff/go.mod h1:YD9qOF0M9xpSpdWTBbzEl5e/RnCefISl8E5Noe10jFM= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -931,7 +857,6 @@ google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20201019141844-1ed22bb0c154/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201102152239-715cce707fb0/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20201110150050-8816d57aaa9a/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= @@ -945,7 +870,6 @@ google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2 h1:NHN4wOCScVzKhPe google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= -google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= @@ -987,18 +911,13 @@ gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= -gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE= -gopkg.in/go-playground/validator.v9 v9.30.0/go.mod h1:+c9/zcJMFNgbLvly1L1V+PpxWdVbfP1avr/N00E2vyQ= gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= -gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473 h1:6D+BvnJ/j6e222UW8s2qTSe3wGBtvo0MbVQG/c5k8RE= -gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473/go.mod h1:N1eN2tsCx0Ydtgjl4cqmbRCsY4/+z4cYDeqwZTk6zog= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= gopkg.in/square/go-jose.v2 v2.2.2/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= @@ -1026,53 +945,42 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -k8s.io/api v0.21.3/go.mod h1:hUgeYHUbBp23Ue4qdX9tR8/ANi/g3ehylAqDn9NWVOg= -k8s.io/api v0.22.1 h1:ISu3tD/jRhYfSW8jI/Q1e+lRxkR7w9UwQEZ7FgslrwY= -k8s.io/api v0.22.1/go.mod h1:bh13rkTp3F1XEaLGykbyRD2QaTTzPm0e/BMd8ptFONY= -k8s.io/apiextensions-apiserver v0.21.3/go.mod h1:kl6dap3Gd45+21Jnh6utCx8Z2xxLm8LGDkprcd+KbsE= -k8s.io/apiextensions-apiserver v0.22.1 h1:YSJYzlFNFSfUle+yeEXX0lSQyLEoxoPJySRupepb0gE= -k8s.io/apiextensions-apiserver v0.22.1/go.mod h1:HeGmorjtRmRLE+Q8dJu6AYRoZccvCMsghwS8XTUYb2c= -k8s.io/apimachinery v0.21.3/go.mod h1:H/IM+5vH9kZRNJ4l3x/fXP/5bOPJaVP/guptnZPeCFI= -k8s.io/apimachinery v0.22.1 h1:DTARnyzmdHMz7bFWFDDm22AM4pLWTQECMpRTFu2d2OM= -k8s.io/apimachinery v0.22.1/go.mod h1:O3oNtNadZdeOMxHFVxOreoznohCpy0z6mocxbZr7oJ0= -k8s.io/apiserver v0.21.3/go.mod h1:eDPWlZG6/cCCMj/JBcEpDoK+I+6i3r9GsChYBHSbAzU= -k8s.io/apiserver v0.22.1 h1:Ul9Iv8OMB2s45h2tl5XWPpAZo1VPIJ/6N+MESeed7L8= -k8s.io/apiserver v0.22.1/go.mod h1:2mcM6dzSt+XndzVQJX21Gx0/Klo7Aen7i0Ai6tIa400= -k8s.io/client-go v0.21.3/go.mod h1:+VPhCgTsaFmGILxR/7E1N0S+ryO010QBeNCv5JwRGYU= -k8s.io/client-go v0.22.1 h1:jW0ZSHi8wW260FvcXHkIa0NLxFBQszTlhiAVsU5mopw= -k8s.io/client-go v0.22.1/go.mod h1:BquC5A4UOo4qVDUtoc04/+Nxp1MeHcVc1HJm1KmG8kk= -k8s.io/code-generator v0.21.3/go.mod h1:K3y0Bv9Cz2cOW2vXUrNZlFbflhuPvuadW6JdnN6gGKo= -k8s.io/code-generator v0.22.1/go.mod h1:eV77Y09IopzeXOJzndrDyCI88UBok2h6WxAlBwpxa+o= -k8s.io/component-base v0.21.3/go.mod h1:kkuhtfEHeZM6LkX0saqSK8PbdO7A0HigUngmhhrwfGQ= -k8s.io/component-base v0.22.1 h1:SFqIXsEN3v3Kkr1bS6rstrs1wd45StJqbtgbQ4nRQdo= -k8s.io/component-base v0.22.1/go.mod h1:0D+Bl8rrnsPN9v0dyYvkqFfBeAd4u7n77ze+p8CMiPo= -k8s.io/gengo v0.0.0-20200413195148-3a45101e95ac/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= -k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E= +k8s.io/api v0.23.0 h1:WrL1gb73VSC8obi8cuYETJGXEoFNEh3LU0Pt+Sokgro= +k8s.io/api v0.23.0/go.mod h1:8wmDdLBHBNxtOIytwLstXt5E9PddnZb0GaMcqsvDBpg= +k8s.io/apiextensions-apiserver v0.23.0 h1:uii8BYmHYiT2ZTAJxmvc3X8UhNYMxl2A0z0Xq3Pm+WY= +k8s.io/apiextensions-apiserver v0.23.0/go.mod h1:xIFAEEDlAZgpVBl/1VSjGDmLoXAWRG40+GsWhKhAxY4= +k8s.io/apimachinery v0.23.0 h1:mIfWRMjBuMdolAWJ3Fd+aPTMv3X9z+waiARMpvvb0HQ= +k8s.io/apimachinery v0.23.0/go.mod h1:fFCTTBKvKcwTPFzjlcxp91uPFZr+JA0FubU4fLzzFYc= +k8s.io/apiserver v0.23.0 h1:Ds/QveXWi9aJ8ISB0CJa4zBNc5njxAs5u3rmMIexqCY= +k8s.io/apiserver v0.23.0/go.mod h1:Cec35u/9zAepDPPFyT+UMrgqOCjgJ5qtfVJDxjZYmt4= +k8s.io/client-go v0.23.0 h1:vcsOqyPq7XV3QmQRCBH/t9BICJM9Q1M18qahjv+rebY= +k8s.io/client-go v0.23.0/go.mod h1:hrDnpnK1mSr65lHHcUuIZIXDgEbzc7/683c6hyG4jTA= +k8s.io/code-generator v0.23.0/go.mod h1:vQvOhDXhuzqiVfM/YHp+dmg10WDZCchJVObc9MvowsE= +k8s.io/component-base v0.23.0 h1:UAnyzjvVZ2ZR1lF35YwtNY6VMN94WtOnArcXBu34es8= +k8s.io/component-base v0.23.0/go.mod h1:DHH5uiFvLC1edCpvcTDV++NKULdYYU6pR9Tt3HIKMKI= +k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E= k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE= k8s.io/klog/v2 v2.2.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y= -k8s.io/klog/v2 v2.8.0/go.mod h1:hy9LJ/NvuK+iVyP4Ehqva4HxZG/oXyIS3n3Jmire4Ec= -k8s.io/klog/v2 v2.9.0 h1:D7HV+n1V57XeZ0m6tdRkfknthUaM06VFbWldOFh8kzM= -k8s.io/klog/v2 v2.9.0/go.mod h1:hy9LJ/NvuK+iVyP4Ehqva4HxZG/oXyIS3n3Jmire4Ec= -k8s.io/kube-openapi v0.0.0-20210305001622-591a79e4bda7/go.mod h1:wXW5VT87nVfh/iLV8FpR2uDvrFyomxbtb1KivDbvPTE= -k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e h1:KLHHjkdQFomZy8+06csTWZ0m1343QqxZhR2LJ1OxCYM= -k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e/go.mod h1:vHXdDvt9+2spS2Rx9ql3I8tycm3H9FDfdUoIuKCefvw= -k8s.io/utils v0.0.0-20201110183641-67b214c5f920/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= -k8s.io/utils v0.0.0-20210707171843-4b05e18ac7d9/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= -k8s.io/utils v0.0.0-20210802155522-efc7438f0176 h1:Mx0aa+SUAcNRQbs5jUzV8lkDlGFU8laZsY9jrcVX5SY= +k8s.io/klog/v2 v2.30.0 h1:bUO6drIvCIsvZ/XFgfxoGFQU/a4Qkh0iAlvUR7vlHJw= +k8s.io/klog/v2 v2.30.0/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= +k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65 h1:E3J9oCLlaobFUqsjG9DfKbP2BmgwBL2p7pn0A3dG9W4= +k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65/go.mod h1:sX9MT8g7NVZM5lVL/j8QyCCJe8YSMW30QvGZWaCIDIk= k8s.io/utils v0.0.0-20210802155522-efc7438f0176/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= +k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b h1:wxEMGetGMur3J1xuGLQY7GEQYg9bZxKn3tKo5k/eYcs= +k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= -sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.19/go.mod h1:LEScyzhFmoF5pso/YSeBstl57mOzx9xlU9n85RGrDQg= -sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.22 h1:fmRfl9WJ4ApJn7LxNuED4m0t18qivVQOxP6aAYG9J6c= -sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.22/go.mod h1:LEScyzhFmoF5pso/YSeBstl57mOzx9xlU9n85RGrDQg= -sigs.k8s.io/controller-runtime v0.10.0 h1:HgyZmMpjUOrtkaFtCnfxsR1bGRuFoAczSNbn2MoKj5U= -sigs.k8s.io/controller-runtime v0.10.0/go.mod h1:GCdh6kqV6IY4LK0JLwX0Zm6g233RtVGdb/f0+KSfprg= -sigs.k8s.io/controller-tools v0.6.2 h1:+Y8L0UsAugDipGRw8lrkPoAi6XqlQVZuf1DQHME3PgU= -sigs.k8s.io/controller-tools v0.6.2/go.mod h1:oaeGpjXn6+ZSEIQkUe/+3I40PNiDYp9aeawbt3xTgJ8= +sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.25 h1:DEQ12ZRxJjsglk5JIi5bLgpKaHihGervKmg5uryaEHw= +sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.25/go.mod h1:Mlj9PNLmG9bZ6BHFwFKDo5afkpWyUISkb9Me0GnK66I= +sigs.k8s.io/controller-runtime v0.11.0 h1:DqO+c8mywcZLFJWILq4iktoECTyn30Bkj0CwgqMpZWQ= +sigs.k8s.io/controller-runtime v0.11.0/go.mod h1:KKwLiTooNGu+JmLZGn9Sl3Gjmfj66eMbCQznLP5zcqA= +sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6 h1:fD1pz4yfdADVNfFmcP2aBEtudwUQ1AlLnRBALr33v3s= +sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6/go.mod h1:p4QtZmO4uMYipTQNzagwnNoseA6OxSUutVw05NhYDRs= sigs.k8s.io/structured-merge-diff/v4 v4.0.2/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw= -sigs.k8s.io/structured-merge-diff/v4 v4.1.2 h1:Hr/htKFmJEbtMgS/UD0N+gtgctAqz81t3nu+sPzynno= sigs.k8s.io/structured-merge-diff/v4 v4.1.2/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4= -sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= -sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q= +sigs.k8s.io/structured-merge-diff/v4 v4.2.0 h1:kDvPBbnPk+qYmkHmSo8vKGp438IASWofnbbUKDE/bv0= +sigs.k8s.io/structured-merge-diff/v4 v4.2.0/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4= sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc= +sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= +sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= diff --git a/staging/api/pkg/apis/scorecard/v1alpha3/zz_generated.deepcopy.go b/staging/api/pkg/apis/scorecard/v1alpha3/zz_generated.deepcopy.go index 3f60a88ba3..ee3c5503c5 100644 --- a/staging/api/pkg/apis/scorecard/v1alpha3/zz_generated.deepcopy.go +++ b/staging/api/pkg/apis/scorecard/v1alpha3/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/staging/api/pkg/encoding/encoding.go b/staging/api/pkg/encoding/encoding.go new file mode 100644 index 0000000000..79cee4f0c7 --- /dev/null +++ b/staging/api/pkg/encoding/encoding.go @@ -0,0 +1,50 @@ +package encoding + +import ( + "bytes" + "compress/gzip" + "encoding/base64" + "io" +) + +// GzipBase64Encode applies gzip compression to the given bytes, followed by base64 encoding. +func GzipBase64Encode(data []byte) ([]byte, error) { + buf := &bytes.Buffer{} + + bWriter := base64.NewEncoder(base64.StdEncoding, buf) + zWriter := gzip.NewWriter(bWriter) + _, err := zWriter.Write(data) + if err != nil { + zWriter.Close() + bWriter.Close() + return nil, err + } + + // Ensure all gzipped bytes are flushed to the underlying base64 encoder + err = zWriter.Close() + if err != nil { + return nil, err + } + + // Ensure all base64d bytes are flushed to the underlying buffer + err = bWriter.Close() + if err != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +// GzipBase64Decode applies base64 decoding to the given bytes, followed by gzip decompression. +func GzipBase64Decode(data []byte) ([]byte, error) { + bBuffer := bytes.NewReader(data) + + bReader := base64.NewDecoder(base64.StdEncoding, bBuffer) + zReader, err := gzip.NewReader(bReader) + if err != nil { + return nil, err + } + defer zReader.Close() + + return io.ReadAll(zReader) +} diff --git a/staging/api/pkg/encoding/encoding_test.go b/staging/api/pkg/encoding/encoding_test.go new file mode 100644 index 0000000000..291e8a6f5b --- /dev/null +++ b/staging/api/pkg/encoding/encoding_test.go @@ -0,0 +1,43 @@ +package encoding + +import ( + "os" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestGzipBase64EncodeDecode(t *testing.T) { + tests := []struct { + name string + source string + }{ + { + name: "Encode-Decode-CSV", + source: "testdata/etcdoperator.v0.9.4.clusterserviceversion.yaml", + }, + { + name: "Encode-Decode-CRD", + source: "testdata/etcdclusters.etcd.database.coreos.com.crd.yaml", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + data, err := os.ReadFile(tt.source) + require.NoError(t, err, "unable to load from file %s", tt.source) + + encoded, err := GzipBase64Encode(data) + require.NoError(t, err, "unexpected error while encoding data") + + require.Lessf(t, len(encoded), len(data), + "encoded data (%d bytes) isn't lesser than original data (%d bytes)", + len(encoded), len(data)) + + decoded, err := GzipBase64Decode(encoded) + require.NoError(t, err, "unexpected error while decoding data") + + require.Equal(t, data, decoded, "decoded data doesn't match original data") + }) + } +} diff --git a/staging/api/pkg/encoding/testdata/etcdclusters.etcd.database.coreos.com.crd.yaml b/staging/api/pkg/encoding/testdata/etcdclusters.etcd.database.coreos.com.crd.yaml new file mode 100644 index 0000000000..3d4f4a1007 --- /dev/null +++ b/staging/api/pkg/encoding/testdata/etcdclusters.etcd.database.coreos.com.crd.yaml @@ -0,0 +1,16 @@ +apiVersion: apiextensions.k8s.io/v1beta1 +kind: CustomResourceDefinition +metadata: + name: etcdclusters.etcd.database.coreos.com +spec: + group: etcd.database.coreos.com + names: + kind: EtcdCluster + listKind: EtcdClusterList + plural: etcdclusters + shortNames: + - etcdclus + - etcd + singular: etcdcluster + scope: Namespaced + version: v1beta2 \ No newline at end of file diff --git a/staging/api/pkg/encoding/testdata/etcdoperator.v0.9.4.clusterserviceversion.yaml b/staging/api/pkg/encoding/testdata/etcdoperator.v0.9.4.clusterserviceversion.yaml new file mode 100644 index 0000000000..f719e5738e --- /dev/null +++ b/staging/api/pkg/encoding/testdata/etcdoperator.v0.9.4.clusterserviceversion.yaml @@ -0,0 +1,309 @@ +apiVersion: operators.coreos.com/v1alpha1 +kind: ClusterServiceVersion +metadata: + annotations: + alm-examples: "[\n {\n \"apiVersion\": \"etcd.database.coreos.com/v1beta2\"\ + ,\n \"kind\": \"EtcdCluster\",\n \"metadata\": {\n \"name\": \"example\"\ + \n },\n \"spec\": {\n \"size\": 3,\n \"version\": \"3.2.13\"\ + \n }\n },\n {\n \"apiVersion\": \"etcd.database.coreos.com/v1beta2\"\ + ,\n \"kind\": \"EtcdRestore\",\n \"metadata\": {\n \"name\": \"example-etcd-cluster-restore\"\ + \n },\n \"spec\": {\n \"etcdCluster\": {\n \"name\": \"example-etcd-cluster\"\ + \n },\n \"backupStorageType\": \"S3\",\n \"s3\": {\n \"\ + path\": \"\",\n \"awsSecret\": \"\"\n \ + \ }\n }\n },\n {\n \"apiVersion\": \"etcd.database.coreos.com/v1beta2\"\ + ,\n \"kind\": \"EtcdBackup\",\n \"metadata\": {\n \"name\": \"example-etcd-cluster-backup\"\ + \n },\n \"spec\": {\n \"etcdEndpoints\": [\"\"\ + ],\n \"storageType\":\"S3\",\n \"s3\": {\n \"path\": \"\"\ + ,\n \"awsSecret\": \"\"\n }\n }\n }\n]\n" + capabilities: Full Lifecycle + categories: Database + containerImage: quay.io/coreos/etcd-operator@sha256:66a37fd61a06a43969854ee6d3e21087a98b93838e284a6086b13917f96b0d9b + createdAt: 2019-02-28 01:03:00 + description: Create and maintain highly-available etcd clusters on Kubernetes + repository: https://github.com/coreos/etcd-operator + tectonic-visibility: ocs + name: etcdoperator.v0.9.4 + namespace: placeholder +spec: + customresourcedefinitions: + owned: + - description: Represents a cluster of etcd nodes. + displayName: etcd Cluster + kind: EtcdCluster + name: etcdclusters.etcd.database.coreos.com + resources: + - kind: Service + version: v1 + - kind: Pod + version: v1 + specDescriptors: + - description: The desired number of member Pods for the etcd cluster. + displayName: Size + path: size + x-descriptors: + - urn:alm:descriptor:com.tectonic.ui:podCount + - description: Limits describes the minimum/maximum amount of compute resources + required/allowed + displayName: Resource Requirements + path: pod.resources + x-descriptors: + - urn:alm:descriptor:com.tectonic.ui:resourceRequirements + statusDescriptors: + - description: The status of each of the member Pods for the etcd cluster. + displayName: Member Status + path: members + x-descriptors: + - urn:alm:descriptor:com.tectonic.ui:podStatuses + - description: The service at which the running etcd cluster can be accessed. + displayName: Service + path: serviceName + x-descriptors: + - urn:alm:descriptor:io.kubernetes:Service + - description: The current size of the etcd cluster. + displayName: Cluster Size + path: size + - description: The current version of the etcd cluster. + displayName: Current Version + path: currentVersion + - description: The target version of the etcd cluster, after upgrading. + displayName: Target Version + path: targetVersion + - description: The current status of the etcd cluster. + displayName: Status + path: phase + x-descriptors: + - urn:alm:descriptor:io.kubernetes.phase + - description: Explanation for the current status of the cluster. + displayName: Status Details + path: reason + x-descriptors: + - urn:alm:descriptor:io.kubernetes.phase:reason + version: v1beta2 + - description: Represents the intent to backup an etcd cluster. + displayName: etcd Backup + kind: EtcdBackup + name: etcdbackups.etcd.database.coreos.com + specDescriptors: + - description: Specifies the endpoints of an etcd cluster. + displayName: etcd Endpoint(s) + path: etcdEndpoints + x-descriptors: + - urn:alm:descriptor:etcd:endpoint + - description: The full AWS S3 path where the backup is saved. + displayName: S3 Path + path: s3.path + x-descriptors: + - urn:alm:descriptor:aws:s3:path + - description: The name of the secret object that stores the AWS credential + and config files. + displayName: AWS Secret + path: s3.awsSecret + x-descriptors: + - urn:alm:descriptor:io.kubernetes:Secret + statusDescriptors: + - description: Indicates if the backup was successful. + displayName: Succeeded + path: succeeded + x-descriptors: + - urn:alm:descriptor:text + - description: Indicates the reason for any backup related failures. + displayName: Reason + path: reason + x-descriptors: + - urn:alm:descriptor:io.kubernetes.phase:reason + version: v1beta2 + - description: Represents the intent to restore an etcd cluster from a backup. + displayName: etcd Restore + kind: EtcdRestore + name: etcdrestores.etcd.database.coreos.com + specDescriptors: + - description: References the EtcdCluster which should be restored, + displayName: etcd Cluster + path: etcdCluster.name + x-descriptors: + - urn:alm:descriptor:io.kubernetes:EtcdCluster + - urn:alm:descriptor:text + - description: The full AWS S3 path where the backup is saved. + displayName: S3 Path + path: s3.path + x-descriptors: + - urn:alm:descriptor:aws:s3:path + - description: The name of the secret object that stores the AWS credential + and config files. + displayName: AWS Secret + path: s3.awsSecret + x-descriptors: + - urn:alm:descriptor:io.kubernetes:Secret + statusDescriptors: + - description: Indicates if the restore was successful. + displayName: Succeeded + path: succeeded + x-descriptors: + - urn:alm:descriptor:text + - description: Indicates the reason for any restore related failures. + displayName: Reason + path: reason + x-descriptors: + - urn:alm:descriptor:io.kubernetes.phase:reason + version: v1beta2 + description: "The etcd Operater creates and maintains highly-available etcd clusters\ + \ on Kubernetes, allowing engineers to easily deploy and manage etcd clusters\ + \ for their applications.\n\netcd is a distributed key value store that provides\ + \ a reliable way to store data across a cluster of machines. It\xE2\u20AC\u2122\ + s open-source and available on GitHub. etcd gracefully handles leader elections\ + \ during network partitions and will tolerate machine failure, including the leader.\n\ + \n\n### Reading and writing to etcd\n\nCommunicate with etcd though its command\ + \ line utility `etcdctl` via port forwarding:\n\n $ kubectl --namespace default\ + \ port-forward service/example-client 2379:2379\n $ etcdctl --endpoints http://127.0.0.1:2379\ + \ get /\n\nOr directly to the API using the automatically generated Kubernetes\ + \ Service:\n\n $ etcdctl --endpoints http://example-client.default.svc:2379\ + \ get /\n\nBe sure to secure your etcd cluster (see Common Configurations) before\ + \ exposing it outside of the namespace or cluster.\n\n\n### Supported Features\n\ + \n* **High availability** - Multiple instances of etcd are networked together\ + \ and secured. Individual failures or networking issues are transparently handled\ + \ to keep your cluster up and running.\n\n* **Automated updates** - Rolling out\ + \ a new etcd version works like all Kubernetes rolling updates. Simply declare\ + \ the desired version, and the etcd service starts a safe rolling update to the\ + \ new version automatically.\n\n* **Backups included** - Create etcd backups and\ + \ restore them through the etcd Operator.\n\n### Common Configurations\n\n* **Configure\ + \ TLS** - Specify [static TLS certs](https://github.com/coreos/etcd-operator/blob/master/doc/user/cluster_tls.md)\ + \ as Kubernetes secrets.\n\n* **Set Node Selector and Affinity** - [Spread your\ + \ etcd Pods](https://github.com/coreos/etcd-operator/blob/master/doc/user/spec_examples.md#three-member-cluster-with-node-selector-and-anti-affinity-across-nodes)\ + \ across Nodes and availability zones.\n\n* **Set Resource Limits** - [Set the\ + \ Kubernetes limit and request](https://github.com/coreos/etcd-operator/blob/master/doc/user/spec_examples.md#three-member-cluster-with-resource-requirement)\ + \ values for your etcd Pods.\n\n* **Customize Storage** - [Set a custom StorageClass](https://github.com/coreos/etcd-operator/blob/master/doc/user/spec_examples.md#custom-persistentvolumeclaim-definition)\ + \ that you would like to use.\n" + displayName: etcd + icon: + - base64data: iVBORw0KGgoAAAANSUhEUgAAAOEAAADZCAYAAADWmle6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAEKlJREFUeNrsndt1GzkShmEev4sTgeiHfRYdgVqbgOgITEVgOgLTEQydwIiKwFQCayoCU6+7DyYjsBiBFyVVz7RkXvqCSxXw/+f04XjGQ6IL+FBVuL769euXgZ7r39f/G9iP0X+u/jWDNZzZdGI/Ftama1jjuV4BwmcNpbAf1Fgu+V/9YRvNAyzT2a59+/GT/3hnn5m16wKWedJrmOCxkYztx9Q+py/+E0GJxtJdReWfz+mxNt+QzS2Mc0AI+HbBBwj9QViKbH5t64DsP2fvmGXUkWU4WgO+Uve2YQzBUGd7r+zH2ZG/tiUQc4QxKwgbwFfVGwwmdLL5wH78aPC/ZBem9jJpCAX3xtcNASSNgJLzUPSQyjB1zQNl8IQJ9MIU4lx2+Jo72ysXYKl1HSzN02BMa/vbZ5xyNJIshJzwf3L0dQhJw4Sih/SFw9Tk8sVeghVPoefaIYCkMZCKbrcP9lnZuk0uPUjGE/KE8JQry7W2tgfuC3vXgvNV+qSQbyFtAtyWk7zWiYevvuUQ9QEQCvJ+5mmu6dTjz1zFHLFj8Eb87MtxaZh/IQFIHom+9vgTWwZxAQjT9X4vtbEVPojwjiV471s00mhAckpwGuCn1HtFtRDaSh6y9zsL+LNBvCG/24ThcxHObdlWc1v+VQJe8LcO0jwtuF8BwnAAUgP9M8JPU2Me+Oh12auPGT6fHuTePE3bLDy+x9pTLnhMn+07TQGh//Bz1iI0c6kvtqInjvPZcYR3KsPVmUsPYt9nFig9SCY8VQNhpPBzn952bbgcsk2EvM89wzh3UEffBbyPqvBUBYQ8ODGPFOLsa7RF096WJ69L+E4EmnpjWu5o4ChlKaRTKT39RMMaVPEQRsz/nIWlDN80chjdJlSd1l0pJCAMVZsniobQVuxceMM9OFoaMd9zqZtjMEYYDW38Drb8Y0DYPLShxn0pvIFuOSxd7YCPet9zk452wsh54FJoeN05hcgSQoG5RR0Qh9Q4E4VvL4wcZq8UACgaRFEQKgSwWrkr5WFnGxiHSutqJGlXjBgIOayhwYBTA0ER0oisIVSUV0AAMT0IASCUO4hRIQSAEECMCCEPwqyQA0JCQBzEGjWNAqHiUVAoXUWbvggOIQCEAOJzxTjoaQ4AIaE64/aZridUsBYUgkhB15oGg1DBIl8IqirYwV6hPSGBSFteMCUBSVXwfYixBmamRubeMyjzMJQBDDowE3OesDD+zwqFoDqiEwXoXJpljB+PvWJGy75BKF1FPxhKygJuqUdYQGlLxNEXkrYyjQ0GbaAwEnUIlLRNvVjQDYUAsJB0HKLE4y0AIpQNgCIhBIhQTgCKhZBBpAN/v6LtQI50JfUgYOnnjmLUFHKhjxbAmdTCaTiBm3ovLPqG2urWAij6im0Nd9aTN9ygLUEt9LgSRnohxUPIKxlGaE+/6Y7znFf0yX+GnkvFFWmarkab2o9PmTeq8sbd2a7DaysXz7i64VeznN4jCQhN9gdDbRiuWrfrsq0mHIrlaq+hlotCtd3Um9u0BYWY8y5D67wccJoZjFca7iUs9VqZcfsZwTd1sbWGG+OcYaTnPAP7rTQVVlM4Sg3oGvB1tmNh0t/HKXZ1jFoIMwCQjtqbhNxUmkGYqgZEDZP11HN/S3gAYRozf0l8C5kKEKUvW0t1IfeWG/5MwgheZTT1E0AEhDkAePQO+Ig2H3DncAkQM4cwUQCD530dU4B5Yvmi2LlDqXfWrxMCcMth51RToRMNUXFnfc2KJ0+Ryl0VNOUwlhh6NoxK5gnViTgQpUG4SqSyt5z3zRJpuKmt3Q1614QaCBPaN6je+2XiFcWAKOXcUfIYKRyL/1lb7pe5VxSxxjQ6hImshqGRt5GWZVKO6q2wHwujfwDtIvaIdexj8Cm8+a68EqMfox6x/voMouZF4dHnEGNeCDMwT6vdNfekH1MafMk4PI06YtqLVGl95aEM9Z5vAeCTOA++YLtoVJRrsqNCaJ6WRmkdYaNec5BT/lcTRMqrhmwfjbpkj55+OKp8IEbU/JLgPJE6Wa3TTe9sHS+ShVD5QIyqIxMEwKh12olC6mHIed5ewEop80CNlfIOADYOT2nd6ZXCop+Ebqchc0JqxKcKASxChycJgUh1rnHA5ow9eTrhqNI7JWiAYYwBGGdpyNLoGw0Pkh96h1BpHihyywtATDM/7Hk2fN9EnH8BgKJCU4ooBkbXFMZJiPbrOyecGl3zgQDQL4hk10IZiOe+5w99Q/gBAEIJgPhJM4QAEEoFREAIAAEiIASAkD8Qt4AQAEIAERAGFlX4CACKAXGVM4ivMwWwCLFAlyeoaa70QePKm5Dlp+/n+ye/5dYgva6YsUaVeMa+tzNFeJtWwc+udbJ0Fg399kLielQJ5Ze61c2+7ytA6EZetiPxZC6tj22yJCv6jUwOyj/zcbqAxOMyAKEbfeHtNa7DtYXptjsk2kJxR+eIeim/tHNofUKYy8DMrQcAKWz6brpvzyIAlpwPhQ49l6b7skJf5Z+YTOYQc4FwLDxvoTDwaygQK+U/kVr+ytSFBG01Q3gnJJR4cNiAhx4HDub8/b5DULXlj6SVZghFiE+LdvE9vo/o8Lp1RmH5hzm0T6wdbZ6n+D6i44zDRc3ln6CpAEJfXiRU45oqLz8gFAThWsh7ughrRibc0QynHgZpNJa/ENJ+loCwu/qOGnFIjYR/n7TfgycULhcQhu6VC+HfF+L3BoAQ4WiZTw1M+FPCnA2gKC6/FAhXgDC+ojQGh3NuWsvfF1L/D5ohlCKtl1j2ldu9a/nPAKFwN56Bst10zCG0CPleXN/zXPgHQZXaZaBgrbzyY5V/mUA+6F0hwtGN9rwu5DVZPuwWqfxdFz1LWbJ2lwKEa+0Qsm4Dl3fp+Pu0lV97PgwIPfSsS+UQhj5Oo+vvFULazRIQyvGEcxPuNLCth2MvFsrKn8UOilAQShkh7TTczYNMoS6OdP47msrPi82lXKGWhCdMZYS0bFy+vcnGAjP1CIfvgbKNA9glecEH9RD6Ol4wRuWyN/G9MHnksS6o/GPf5XcwNSUlHzQhDuAKtWJmkwKElU7lylP5rgIcsquh/FI8YZCDpkJBuE4FQm7Icw8N+SrUGaQKyi8FwiDt1ve5o+Vu7qYHy/psgK8cvh+FTYuO77bhEC7GuaPiys/L1X4IgXDL+e3M5+ovLxBy5VLuIebw1oqcHoPfoaMJUsHays878r8KbDc3xtPx/84gZPBG/JwaufrsY/SRG/OY3//8QMNdsvdZCFtbW6f8pFuf5bflILAlX7O+4fdfugKyFYS8T2zAsXthdG0VurPGKwI06oF5vkBgHWkNp6ry29+lsPZMU3vijnXFNmoclr+6+Ou/FIb8yb30sS8YGjmTqCLyQsi5N/6ZwKs0Yenj68pfPjF6N782Dp2FzV9CTyoSeY8mLK16qGxIkLI8oa1n8tz9juP40DlK0epxYEbojbq+9QfurBeVIlCO9D2396bxiV4lkYQ3hOAFw2pbhqMGISkkQOMcQ9EqhDmGZZdo92JC0YHRNTfoSg+5e0IT+opqCKHoIU+4ztQIgBD1EFNrQAgIpYSil9lDmPHqkROPt+JC6AgPquSuumJmg0YARVCuneDfvPVeJokZ6pIXDkNxQtGzTF9/BQjRG0tQznfb74RwCQghpALBtIQnfK4zhxdyQvVCUeknMIT3hLyY+T5jo0yABqKPQNpUNw/09tGZod5jgCaYFxyYvJcNPkv9eof+I3pnCFEHIETjSM8L9tHZHYCQT9PaZGycU6yg8S4akDnJ+P03L0+t23XGzCLzRgII/Wqa+fv/xlfvmKvMUOcOrlCDdoei1MGdZm6G5VEIfRzzjd4aQs69n699Rx7ewhvCGzr2gmTPs8zNsJOrXt24FbkhhOjCfT4ICA/rPbyhUy94Dks0gJCX1NzCZui9YUd3oei+c257TalFbgg19ILHrlrL2gvWgXAL26EX76gZTNASQnad8Ibwhl284NhgXpB0c+jKhWO3Ms1hP9ihJYB9eMF6qd1BCPk0qA1s+LimFIu7m4nsdQIzPK4VbQ8hYvrnuSH2G9b2ggP78QmWqBdF9Vx8SSY6QYdUW7BTA1schZATyhvY8lHvcRbNUS9YGFy2U+qmzh2YPVc0I7yAOFyHfRpyUwtCSzOdPXMHmz7qDIM0e0V2wZTEk+6Ym6N63eBLp/b5Bts+2cKCSJ/LuoZO3ANSiE5hKAZjnvNSS4931jcw9jpwT0feV/qSJ1pVtCyfHKDkvK8Ejx7pUxGh2xFNSwx8QTi2H9ceC0/nni64MS/5N5dG39pDqvRV+WgGk71c9VFXF9b+xYvOw/d61iv7m3MvEHryhvecwC52jSSx4VIIgwnMNT/UsTxIgpPt3K/ARj15CptwL3Zd/ceDSATj2DGQjbxgWwhdeMMte7zpy5On9vymRm/YxBYljGVjKWF9VJf7I1+sex3wY8w/V1QPTborW/72gkdsRDaZMJBdbdHIC7aCkAu9atlLbtnrzerMnyToDaGwelOnk3/hHSem/ZK7e/t7jeeR20LYBgqa8J80gS8jbwi5F02Uj1u2NYJxap8PLkJfLxA2hIJyvnHX/AfeEPLpBfe0uSFHbnXaea3Qd5d6HcpYZ8L6M7lnFwMQ3MNg+RxUR1+6AshtbsVgfXTEg1sIGax9UND2p7f270wdG3eK9gXVGHdw2k5sOyZv+Nbs39Z308XR9DqWb2J+PwKDhuKHPobfuXf7gnYGHdCs7bhDDadD4entDug7LWNsnRNW4mYqwJ9dk+GGSTPBiA2j0G8RWNM5upZtcG4/3vMfP7KnbK2egx6CCnDPhRn7NgD3cghLIad5WcM2SO38iqHvvMOosyeMpQ5zlVCaaj06GVs9xUbHdiKoqrHWgquFEFMWUEWfXUxJAML23hAHFOctmjZQffKD2pywkhtSGHKNtpitLroscAeE7kCkSsC60vxEl6yMtL9EL5HKGCMszU5bk8gdkklAyEn5FO0yK419rIxBOIqwFMooDE0tHEVYijAUECIshRCGIhxFWIowFJ5QkEYIS5PTJrUwNGlPyN6QQPyKtpuM1E/K5+YJDV/MiA3AaehzqgAm7QnZG9IGYKo8bHnSK7VblLL3hOwNHziPuEGOqE5brrdR6i+atCfckyeWD47HkAkepRGLY/e8A8J0gCwYSNypF08bBm+e6zVz2UL4AshhBUjML/rXLefqC82bcQFhGC9JDwZ1uuu+At0S5gCETYHsV4DUeD9fDN2Zfy5OXaW2zAwQygCzBLJ8cvaW5OXKC1FxfTggFAHmoAJnSiOw2wps9KwRWgJCLaEswaj5NqkLwAYIU4BxqTSXbHXpJdRMPZgAOiAMqABCNGYIEEJutEK5IUAIwYMDQgiCACEEAcJs1Vda7gGqDhCmoiEghAAhBAHCrKXVo2C1DCBMRlp37uMIEECoX7xrX3P5C9QiINSuIcoPAUI0YkAICLNWgfJDh4T9hH7zqYH9+JHAq7zBqWjwhPAicTVCVQJCNF50JghHocahKK0X/ZnQKyEkhSdUpzG8OgQI42qC94EQjsYLRSmH+pbgq73L6bYkeEJ4DYTYmeg1TOBFc/usTTp3V9DdEuXJ2xDCUbXhaXk0/kAYmBvuMB4qkC35E5e5AMKkwSQgyxufyuPy6fMMgAFCSI73LFXU/N8AmEL9X4ABACNSKMHAgb34AAAAAElFTkSuQmCC + mediatype: image/png + install: + spec: + deployments: + - name: etcd-operator + spec: + replicas: 1 + selector: + matchLabels: + name: etcd-operator-alm-owned + template: + metadata: + labels: + name: etcd-operator-alm-owned + name: etcd-operator-alm-owned + spec: + containers: + - command: + - etcd-operator + - --create-crd=false + env: + - name: MY_POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: MY_POD_NAME + valueFrom: + fieldRef: + fieldPath: metadata.name + image: quay.io/coreos/etcd-operator@sha256:66a37fd61a06a43969854ee6d3e21087a98b93838e284a6086b13917f96b0d9b + name: etcd-operator + - command: + - etcd-backup-operator + - --create-crd=false + env: + - name: MY_POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: MY_POD_NAME + valueFrom: + fieldRef: + fieldPath: metadata.name + image: quay.io/coreos/etcd-operator@sha256:66a37fd61a06a43969854ee6d3e21087a98b93838e284a6086b13917f96b0d9b + name: etcd-backup-operator + - command: + - etcd-restore-operator + - --create-crd=false + env: + - name: MY_POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: MY_POD_NAME + valueFrom: + fieldRef: + fieldPath: metadata.name + image: quay.io/coreos/etcd-operator@sha256:66a37fd61a06a43969854ee6d3e21087a98b93838e284a6086b13917f96b0d9b + name: etcd-restore-operator + serviceAccountName: etcd-operator + permissions: + - rules: + - apiGroups: + - etcd.database.coreos.com + resources: + - etcdclusters + - etcdbackups + - etcdrestores + verbs: + - '*' + - apiGroups: + - '' + resources: + - pods + - services + - endpoints + - persistentvolumeclaims + - events + verbs: + - '*' + - apiGroups: + - apps + resources: + - deployments + verbs: + - '*' + - apiGroups: + - '' + resources: + - secrets + verbs: + - get + serviceAccountName: etcd-operator + strategy: deployment + installModes: + - supported: true + type: OwnNamespace + - supported: true + type: SingleNamespace + - supported: false + type: MultiNamespace + - supported: false + type: AllNamespaces + keywords: + - etcd + - key value + - database + - coreos + - open source + labels: + alm-owner-etcd: etcdoperator + operated-by: etcdoperator + links: + - name: Blog + url: https://coreos.com/etcd + - name: Documentation + url: https://coreos.com/operators/etcd/docs/latest/ + - name: etcd Operator Source Code + url: https://github.com/coreos/etcd-operator + maintainers: + - email: etcd-dev@googlegroups.com + name: etcd Community + maturity: alpha + provider: + name: CNCF + replaces: etcdoperator.v0.9.2 + selector: + matchLabels: + alm-owner-etcd: etcdoperator + operated-by: etcdoperator + version: 0.9.4 \ No newline at end of file diff --git a/staging/api/pkg/manifests/bundle.go b/staging/api/pkg/manifests/bundle.go index e26a9b34e2..9be294a352 100644 --- a/staging/api/pkg/manifests/bundle.go +++ b/staging/api/pkg/manifests/bundle.go @@ -19,6 +19,10 @@ type Bundle struct { V1beta1CRDs []*apiextensionsv1beta1.CustomResourceDefinition V1CRDs []*apiextensionsv1.CustomResourceDefinition Dependencies []*Dependency + // CompressedSize stores the gzip size of the bundle + CompressedSize int64 + // Size stores the size of the bundle + Size int64 } func (b *Bundle) ObjectsToValidate() []interface{} { diff --git a/staging/api/pkg/manifests/bundleloader.go b/staging/api/pkg/manifests/bundleloader.go index ec90c0cd41..6a8d7e4cf4 100644 --- a/staging/api/pkg/manifests/bundleloader.go +++ b/staging/api/pkg/manifests/bundleloader.go @@ -13,6 +13,7 @@ import ( utilerrors "k8s.io/apimachinery/pkg/util/errors" "k8s.io/apimachinery/pkg/util/yaml" + "github.com/operator-framework/api/pkg/encoding" operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" ) @@ -35,6 +36,8 @@ func (b *bundleLoader) LoadBundle() error { errs = append(errs, err) } + errs = append(errs, b.calculateCompressedBundleSize()) + if !b.foundCSV { errs = append(errs, fmt.Errorf("unable to find a csv in bundle directory %s", b.dir)) } else if b.bundle == nil { @@ -44,6 +47,39 @@ func (b *bundleLoader) LoadBundle() error { return utilerrors.NewAggregate(errs) } +// Compress the bundle to check its size +func (b *bundleLoader) calculateCompressedBundleSize() error { + if b.bundle == nil { + return nil + } + err := filepath.Walk(b.dir, + func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if info.IsDir() { + return nil + } + data, err := os.ReadFile(path) + if err == nil { + // Sum the bundle amount + b.bundle.Size += info.Size() + + // Sum the compressed amount + contentGzip, err := encoding.GzipBase64Encode(data) + if err != nil { + return err + } + b.bundle.CompressedSize += int64(len(contentGzip)) + } + return err + }) + if err != nil { + return err + } + return nil +} + // collectWalkErrs calls the given walk func and appends any non-nil, non skip dir error returned to the given errors slice. func collectWalkErrs(walk filepath.WalkFunc, errs *[]error) filepath.WalkFunc { return func(path string, f os.FileInfo, err error) (walkErr error) { diff --git a/staging/api/pkg/operators/v1/zz_generated.deepcopy.go b/staging/api/pkg/operators/v1/zz_generated.deepcopy.go index 26afb9d030..89a3007bc1 100644 --- a/staging/api/pkg/operators/v1/zz_generated.deepcopy.go +++ b/staging/api/pkg/operators/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/staging/api/pkg/operators/v1alpha1/catalogsource_types.go b/staging/api/pkg/operators/v1alpha1/catalogsource_types.go index e94618f9c7..726f8e1aa1 100644 --- a/staging/api/pkg/operators/v1alpha1/catalogsource_types.go +++ b/staging/api/pkg/operators/v1alpha1/catalogsource_types.go @@ -1,6 +1,7 @@ package v1alpha1 import ( + "encoding/json" "fmt" "github.com/sirupsen/logrus" corev1 "k8s.io/api/core/v1" @@ -10,8 +11,9 @@ import ( ) const ( - CatalogSourceCRDAPIVersion = GroupName + "/" + GroupVersion - CatalogSourceKind = "CatalogSource" + CatalogSourceCRDAPIVersion = GroupName + "/" + GroupVersion + CatalogSourceKind = "CatalogSource" + DefaultRegistryPollDuration = 15 * time.Minute ) // SourceType indicates the type of backing store for a CatalogSource @@ -36,6 +38,8 @@ const ( CatalogSourceConfigMapError ConditionReason = "ConfigMapError" // CatalogSourceRegistryServerError denotes when there is an issue querying the specified registry server. CatalogSourceRegistryServerError ConditionReason = "RegistryServerError" + // CatalogSourceIntervalInvalidError denotes if the registry polling interval is invalid. + CatalogSourceIntervalInvalidError ConditionReason = "InvalidIntervalError" ) type CatalogSourceSpec struct { @@ -119,7 +123,32 @@ type RegistryPoll struct { // Interval is used to determine the time interval between checks of the latest catalog source version. // The catalog operator polls to see if a new version of the catalog source is available. // If available, the latest image is pulled and gRPC traffic is directed to the latest catalog source. - Interval *metav1.Duration `json:"interval,omitempty"` + RawInterval string `json:"interval,omitempty"` + Interval *metav1.Duration `json:"-"` + ParsingError string `json:"-"` +} + +// UnmarshalJSON implements the encoding/json.Unmarshaler interface. +func (u *UpdateStrategy) UnmarshalJSON(data []byte) (err error) { + type alias struct { + *RegistryPoll `json:"registryPoll,omitempty"` + } + us := alias{} + if err = json.Unmarshal(data, &us); err != nil { + return err + } + registryPoll := &RegistryPoll{ + RawInterval: us.RegistryPoll.RawInterval, + } + duration, err := time.ParseDuration(registryPoll.RawInterval) + if err != nil { + registryPoll.ParsingError = fmt.Sprintf("error parsing spec.updateStrategy.registryPoll.interval. Using the default value of %s instead. Error: %s", DefaultRegistryPollDuration, err) + registryPoll.Interval = &metav1.Duration{Duration: DefaultRegistryPollDuration} + } else { + registryPoll.Interval = &metav1.Duration{Duration: duration} + } + u.RegistryPoll = registryPoll + return nil } type RegistryServiceStatus struct { diff --git a/staging/api/pkg/operators/v1alpha1/installplan_types.go b/staging/api/pkg/operators/v1alpha1/installplan_types.go index 6b56a5d727..5210436d98 100644 --- a/staging/api/pkg/operators/v1alpha1/installplan_types.go +++ b/staging/api/pkg/operators/v1alpha1/installplan_types.go @@ -71,6 +71,7 @@ const ( StepStatusNotPresent StepStatus = "NotPresent" StepStatusPresent StepStatus = "Present" StepStatusCreated StepStatus = "Created" + StepStatusNotCreated StepStatus = "NotCreated" StepStatusWaitingForAPI StepStatus = "WaitingForApi" StepStatusUnsupportedResource StepStatus = "UnsupportedResource" ) @@ -227,6 +228,7 @@ func ConditionMet(cond InstallPlanConditionType, now *metav1.Time) InstallPlanCo type Step struct { Resolving string `json:"resolving"` Resource StepResource `json:"resource"` + Optional bool `json:"optional,omitempty"` Status StepStatus `json:"status"` } diff --git a/staging/api/pkg/operators/v1alpha1/types_test.go b/staging/api/pkg/operators/v1alpha1/types_test.go index 93df990926..966ae1f182 100644 --- a/staging/api/pkg/operators/v1alpha1/types_test.go +++ b/staging/api/pkg/operators/v1alpha1/types_test.go @@ -1,6 +1,8 @@ package v1alpha1 import ( + "encoding/json" + "fmt" "sort" "testing" "time" @@ -208,3 +210,72 @@ func TestCatalogSource_Poll(t *testing.T) { require.Equal(t, tt.result, table[i].catsrc.Poll(), table[i].description) } } + +func TestUpdateStrategyUnmarshal(t *testing.T) { + type TestStruct struct { + UpdateStrategy UpdateStrategy `json:"updateStrategy,omitempty"` + } + validDuration, err := time.ParseDuration("45m") + if err != nil { + panic(fmt.Errorf("error parsing duration: %s", err)) + } + defaultDuration, err := time.ParseDuration("15m") + if err != nil { + panic(fmt.Errorf("error parsing duration: %s", err)) + } + tests := []struct { + name string + in []byte + out TestStruct + err error + }{ + { + name: "valid", + in: []byte(`{"UpdateStrategy": {"registryPoll":{"interval":"45m"}}}`), + out: TestStruct{ + UpdateStrategy{ + &RegistryPoll{ + RawInterval: "45m", + Interval: &metav1.Duration{Duration: validDuration}, + ParsingError: "", + }, + }, + }, + }, + { + name: "invalid", + in: []byte(`{"UpdateStrategy": {"registryPoll":{"interval":"19mError Code"}}}`), + out: TestStruct{ + UpdateStrategy{ + &RegistryPoll{ + RawInterval: "19mError Code", + Interval: &metav1.Duration{Duration: defaultDuration}, + ParsingError: "error parsing spec.updateStrategy.registryPoll.interval. Using the default value of 15m0s instead. Error: time: unknown unit \"mError Code\" in duration \"19mError Code\"", + }, + }, + }, + }, + { + name: "empty", + in: []byte(`{"UpdateStrategy": {"registryPoll":{"interval":""}}}`), + out: TestStruct{ + UpdateStrategy{ + &RegistryPoll{ + Interval: &metav1.Duration{Duration: defaultDuration}, + ParsingError: "error parsing spec.updateStrategy.registryPoll.interval. Using the default value of 15m0s instead. Error: time: invalid duration \"\"", + }, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := TestStruct{} + err := json.Unmarshal(tt.in, &s) + require.Equal(t, tt.out.UpdateStrategy.RawInterval, s.UpdateStrategy.RawInterval) + require.Equal(t, tt.out.UpdateStrategy.Interval, s.UpdateStrategy.Interval) + require.Equal(t, tt.out.UpdateStrategy.ParsingError, s.UpdateStrategy.ParsingError) + require.Equal(t, tt.err, err) + }) + } +} diff --git a/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go b/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go index 080b350ee7..c094738eed 100644 --- a/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go +++ b/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/staging/api/pkg/operators/v1alpha2/zz_generated.deepcopy.go b/staging/api/pkg/operators/v1alpha2/zz_generated.deepcopy.go index 807a963162..3d81e86ed4 100644 --- a/staging/api/pkg/operators/v1alpha2/zz_generated.deepcopy.go +++ b/staging/api/pkg/operators/v1alpha2/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/staging/api/pkg/operators/v2/zz_generated.deepcopy.go b/staging/api/pkg/operators/v2/zz_generated.deepcopy.go index 06fbb625a1..8f7498c356 100644 --- a/staging/api/pkg/operators/v2/zz_generated.deepcopy.go +++ b/staging/api/pkg/operators/v2/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/staging/api/pkg/validation/errors/error.go b/staging/api/pkg/validation/errors/error.go index 4ff55c0dd5..9b4391658b 100644 --- a/staging/api/pkg/validation/errors/error.go +++ b/staging/api/pkg/validation/errors/error.go @@ -101,6 +101,7 @@ const ( ErrorInvalidBundle ErrorType = "BundleNotValid" ErrorInvalidPackageManifest ErrorType = "PackageManifestNotValid" ErrorObjectFailedValidation ErrorType = "ObjectFailedValidation" + ErrorPropertiesAnnotationUsed ErrorType = "PropertiesAnnotationUsed" ) func NewError(t ErrorType, detail, field string, v interface{}) Error { @@ -116,7 +117,7 @@ func ErrInvalidBundle(detail string, value interface{}) Error { } func WarnInvalidBundle(detail string, value interface{}) Error { - return invalidBundle(LevelError, detail, value) + return invalidBundle(LevelWarn, detail, value) } func invalidBundle(lvl Level, detail string, value interface{}) Error { @@ -243,3 +244,7 @@ func invalidObject(lvl Level, detail string, value interface{}) Error { func WarnInvalidObject(detail string, value interface{}) Error { return failedValidation(LevelWarn, detail, value) } + +func WarnPropertiesAnnotationUsed(detail string) Error { + return Error{ErrorPropertiesAnnotationUsed, LevelWarn, "", "", detail} +} diff --git a/staging/api/pkg/validation/internal/annotations.go b/staging/api/pkg/validation/internal/annotations.go index 95ee22a2cf..2ab63aa9fb 100644 --- a/staging/api/pkg/validation/internal/annotations.go +++ b/staging/api/pkg/validation/internal/annotations.go @@ -9,6 +9,8 @@ import ( "github.com/operator-framework/api/pkg/validation/errors" ) +const olmpropertiesAnnotation = "olm.properties" + // CaseSensitiveAnnotationKeySet is a set of annotation keys that are case sensitive // and can be used for validation purposes. The key is always lowercase and the value // contains the expected case sensitive string. This may not be an exhaustive list. @@ -24,8 +26,9 @@ var CaseSensitiveAnnotationKeySet = map[string]string{ /* ValidateAnnotationNames will check annotation keys to ensure they are using proper case. Uses CaseSensitiveAnnotationKeySet as a source for keys -which are known to be case sensitive. This function can be used anywhere -annotations need to be checked for case sensitivity. +which are known to be case sensitive. It also checks to see if the olm.properties +annotation is defined in order to add a warning if present. This function can be +used anywhere annotations need to be checked for case sensitivity. Arguments @@ -48,6 +51,16 @@ func ValidateAnnotationNames(annotations map[string]string, value interface{}) ( errs = append(errs, errors.ErrFailedValidation(fmt.Sprintf("provided annotation %s uses wrong case and should be %s instead", annotationKey, knownCaseSensitiveKey), value)) } } + + if annotationKey == olmpropertiesAnnotation { + errs = append( + errs, + errors.WarnPropertiesAnnotationUsed( + fmt.Sprintf( + "found %s annotation, please define these properties in metadata/properties.yaml instead", + annotationKey, + ))) + } } return errs } diff --git a/staging/api/pkg/validation/internal/bundle.go b/staging/api/pkg/validation/internal/bundle.go index d109deab72..9bb90a04d3 100644 --- a/staging/api/pkg/validation/internal/bundle.go +++ b/staging/api/pkg/validation/internal/bundle.go @@ -15,6 +15,12 @@ import ( var BundleValidator interfaces.Validator = interfaces.ValidatorFunc(validateBundles) +// max_bundle_size is the maximum size of a bundle in bytes. +// This ensures the bundle can be staged in a single ConfigMap by OLM during installation. +// The value is derived from the standard upper bound for k8s resources (~1MB). +// We will use this value to check the bundle compressed is < ~1MB +const max_bundle_size = int64(1 << (10 * 2)) + func validateBundles(objs ...interface{}) (results []errors.ManifestResult) { for _, obj := range objs { switch v := obj.(type) { @@ -32,6 +38,10 @@ func validateBundle(bundle *manifests.Bundle) (result errors.ManifestResult) { if saErrors != nil { result.Add(saErrors...) } + sizeErrors := validateBundleSize(bundle) + if sizeErrors != nil { + result.Add(sizeErrors...) + } return result } @@ -99,7 +109,7 @@ func validateOwnedCRDs(bundle *manifests.Bundle, csv *operatorsv1alpha1.ClusterS // All CRDs present in a CSV must be present in the bundle. for key := range keySet { - result.Add(errors.WarnInvalidBundle(fmt.Sprintf("CRD %q is present in bundle %q but not defined in CSV", key, bundle.Name), key)) + result.Add(errors.ErrInvalidBundle(fmt.Sprintf("CRD %q is present in bundle %q but not defined in CSV", key, bundle.Name), key)) } return result @@ -117,6 +127,62 @@ func getOwnedCustomResourceDefintionKeys(csv *operatorsv1alpha1.ClusterServiceVe return keys } +// validateBundleSize will check the bundle size according to its limits +// note that this check will raise an error if the size is bigger than the max allowed +// and warnings when: +// - we are unable to check the bundle size because we are running a check without load the bundle +// - we could identify that the bundle size is close to the limit (bigger than 85%) +func validateBundleSize(bundle *manifests.Bundle) []errors.Error { + warnPercent := 0.85 + warnSize := float64(max_bundle_size) * warnPercent + var errs []errors.Error + + if bundle.CompressedSize == 0 { + errs = append(errs, errors.WarnFailedValidation("unable to check the bundle compressed size", bundle.Name)) + return errs + } + + if bundle.Size == 0 { + errs = append(errs, errors.WarnFailedValidation("unable to check the bundle size", bundle.Name)) + return errs + } + + // From OPM (https://github.com/operator-framework/operator-registry) 1.17.5 + // and OLM (https://github.com/operator-framework/operator-lifecycle-manager) : v0.19.0 + // the total size checked is compressed + if bundle.CompressedSize > max_bundle_size { + errs = append(errs, errors.ErrInvalidBundle( + fmt.Sprintf("maximum bundle compressed size with gzip size exceeded: size=~%s , max=%s. Bundle uncompressed size is %s", + formatBytesInUnit(bundle.CompressedSize), + formatBytesInUnit(max_bundle_size), + formatBytesInUnit(bundle.Size)), + bundle.Name)) + } else if float64(bundle.CompressedSize) > warnSize { + errs = append(errs, errors.WarnInvalidBundle( + fmt.Sprintf("nearing maximum bundle compressed size with gzip: size=~%s , max=%s. Bundle uncompressed size is %s", + formatBytesInUnit(bundle.CompressedSize), + formatBytesInUnit(max_bundle_size), + formatBytesInUnit(bundle.Size)), + bundle.Name)) + } + + return errs +} + +func formatBytesInUnit(b int64) string { + const unit = 1000 + if b < unit { + return fmt.Sprintf("%d B", b) + } + div, exp := int64(unit), 0 + for n := b / unit; n >= unit; n /= unit { + div *= unit + exp++ + } + return fmt.Sprintf("%.1f %cB", + float64(b)/float64(div), "kMGTPE"[exp]) +} + // getBundleCRDKeys returns a set of definition keys for all CRDs in bundle. func getBundleCRDKeys(bundle *manifests.Bundle) (keys []schema.GroupVersionKind) { // Collect all v1 and v1beta1 CRD keys, skipping group which CSVs do not support. diff --git a/staging/api/pkg/validation/internal/bundle_test.go b/staging/api/pkg/validation/internal/bundle_test.go index 6469247e2e..4bb9ad5973 100644 --- a/staging/api/pkg/validation/internal/bundle_test.go +++ b/staging/api/pkg/validation/internal/bundle_test.go @@ -1,13 +1,15 @@ package internal import ( + "fmt" "testing" - "github.com/operator-framework/api/pkg/manifests" - "github.com/operator-framework/api/pkg/operators/v1alpha1" + "github.com/stretchr/testify/require" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" - "github.com/stretchr/testify/require" + "github.com/operator-framework/api/pkg/manifests" + "github.com/operator-framework/api/pkg/operators/v1alpha1" + "github.com/operator-framework/api/pkg/validation/errors" ) func TestValidateBundle(t *testing.T) { @@ -160,3 +162,143 @@ func TestValidateServiceAccount(t *testing.T) { }) } } + +func TestBundleSize(t *testing.T) { + type args struct { + sizeCompressed int64 + size int64 + } + tests := []struct { + name string + args args + wantError bool + wantWarning bool + errStrings []string + warnStrings []string + }{ + { + name: "should pass when the size is not bigger or closer of the limit", + args: args{ + sizeCompressed: max_bundle_size / 2, + size: max_bundle_size / 2, + }, + }, + { + name: "should warn when the size is closer of the limit", + args: args{ + sizeCompressed: max_bundle_size - 100000, + size: (max_bundle_size - 100000) * 10, + }, + wantWarning: true, + warnStrings: []string{ + "Warning: Value : nearing maximum bundle compressed size with gzip: size=~948.6 kB , max=1.0 MB. Bundle uncompressed size is 9.5 MB", + }, + }, + { + name: "should warn when is not possible to check the size compressed", + args: args{ + size: max_bundle_size * 1024, + }, + wantWarning: true, + warnStrings: []string{"Warning: Value : unable to check the bundle compressed size"}, + }, + { + name: "should warn when is not possible to check the size", + args: args{ + sizeCompressed: max_bundle_size / 2, + }, + wantWarning: true, + warnStrings: []string{"Warning: Value : unable to check the bundle size"}, + }, + { + name: "should raise an error when the size is bigger than the limit", + args: args{ + sizeCompressed: 2 * max_bundle_size, + size: (2 * max_bundle_size) * 10, + }, + wantError: true, + errStrings: []string{ + "Error: Value : maximum bundle compressed size with gzip size exceeded: size=~2.1 MB , max=1.0 MB. Bundle uncompressed size is 21.0 MB", + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + bundle := &manifests.Bundle{ + CompressedSize: tt.args.sizeCompressed, + Size: tt.args.size, + } + result := validateBundleSize(bundle) + + var warns, errs []errors.Error + for _, r := range result { + if r.Level == errors.LevelWarn { + warns = append(warns, r) + } else if r.Level == errors.LevelError { + errs = append(errs, r) + } + } + require.Equal(t, tt.wantWarning, len(warns) > 0) + if tt.wantWarning { + require.Equal(t, len(tt.warnStrings), len(warns)) + for _, w := range warns { + wString := w.Error() + require.Contains(t, tt.warnStrings, wString) + } + } + + require.Equal(t, tt.wantError, len(errs) > 0) + if tt.wantError { + require.Equal(t, len(tt.errStrings), len(errs)) + for _, err := range errs { + errString := err.Error() + require.Contains(t, tt.errStrings, errString) + } + } + }) + } +} + +func Test_EnsureGetBundleSizeValue(t *testing.T) { + type args struct { + annotations map[string]string + bundleDir string + imageIndexPath string + } + tests := []struct { + name string + args args + wantWarning bool + warnStrings []string + }{ + { + name: "should calculate the bundle size and not raise warnings when a valid bundle is informed", + args: args{ + bundleDir: "./testdata/valid_bundle", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + // Validate the bundle object + bundle, err := manifests.GetBundleFromDir(tt.args.bundleDir) + require.NoError(t, err) + + // Should have the values calculated + require.Greater(t, bundle.Size, int64(0), fmt.Sprintf("the bundle size is %d when should be > 0", bundle.Size)) + require.Greater(t, bundle.CompressedSize, int64(0), fmt.Sprintf("the bundle compressed size is %d when should be > 0", bundle.CompressedSize)) + + results := validateBundle(bundle) + require.Equal(t, tt.wantWarning, len(results.Warnings) > 0) + if tt.wantWarning { + require.Equal(t, len(tt.warnStrings), len(results.Warnings)) + for _, w := range results.Warnings { + wString := w.Error() + require.Contains(t, tt.warnStrings, wString) + } + } + }) + } +} diff --git a/staging/api/pkg/validation/internal/community.go b/staging/api/pkg/validation/internal/community.go index 178729b7f7..dfc7c4aabe 100644 --- a/staging/api/pkg/validation/internal/community.go +++ b/staging/api/pkg/validation/internal/community.go @@ -3,11 +3,12 @@ package internal import ( "encoding/json" "fmt" - "github.com/blang/semver" "io/ioutil" "os" "strings" + "github.com/blang/semver" + "github.com/operator-framework/api/pkg/manifests" "github.com/operator-framework/api/pkg/validation/errors" interfaces "github.com/operator-framework/api/pkg/validation/interfaces" diff --git a/staging/api/pkg/validation/internal/crd.go b/staging/api/pkg/validation/internal/crd.go index 79dae726e1..9a38f7b863 100644 --- a/staging/api/pkg/validation/internal/crd.go +++ b/staging/api/pkg/validation/internal/crd.go @@ -12,7 +12,6 @@ import ( "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation" "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/runtime/schema" ) var scheme = runtime.NewScheme() @@ -44,8 +43,7 @@ func validateV1Beta1CRD(crd *v1beta1.CustomResourceDefinition) (result errors.Ma return result } - gv := crd.GetObjectKind().GroupVersionKind().GroupVersion() - result = validateInternalCRD(internalCRD, gv) + result = validateInternalCRD(internalCRD) return result } @@ -58,13 +56,12 @@ func validateV1CRD(crd *v1.CustomResourceDefinition) (result errors.ManifestResu return result } - gv := crd.GetObjectKind().GroupVersionKind().GroupVersion() - result = validateInternalCRD(internalCRD, gv) + result = validateInternalCRD(internalCRD) return result } -func validateInternalCRD(crd *apiextensions.CustomResourceDefinition, gv schema.GroupVersion) (result errors.ManifestResult) { - errList := validation.ValidateCustomResourceDefinition(crd, gv) +func validateInternalCRD(crd *apiextensions.CustomResourceDefinition) (result errors.ManifestResult) { + errList := validation.ValidateCustomResourceDefinition(crd) for _, err := range errList { if !strings.Contains(err.Field, "openAPIV3Schema") && !strings.Contains(err.Field, "status") { result.Add(errors.NewError(errors.ErrorType(err.Type), err.Error(), err.Field, err.BadValue)) diff --git a/staging/api/pkg/validation/internal/csv.go b/staging/api/pkg/validation/internal/csv.go index ea7145d078..b5b7683c0c 100644 --- a/staging/api/pkg/validation/internal/csv.go +++ b/staging/api/pkg/validation/internal/csv.go @@ -1,6 +1,7 @@ package internal import ( + "encoding/json" "fmt" "io" "reflect" @@ -97,6 +98,12 @@ func validateExamplesAnnotations(csv *v1alpha1.ClusterServiceVersion) (errs []er } else { examplesString = olmExamples } + + if err := validateJSON(examplesString); err != nil { + errs = append(errs, errors.ErrInvalidParse("invalid example", err)) + return errs + } + us := []unstructured.Unstructured{} dec := yaml.NewYAMLOrJSONDecoder(strings.NewReader(examplesString), 8) if err := dec.Decode(&us); err != nil && err != io.EOF { @@ -115,6 +122,31 @@ func validateExamplesAnnotations(csv *v1alpha1.ClusterServiceVersion) (errs []er return errs } +func validateJSON(value string) error { + var js json.RawMessage + + if len(value) == 0 { + return nil + } + + byteValue := []byte(value) + if err := json.Unmarshal(byteValue, &js); err != nil { + switch t := err.(type) { + case *json.SyntaxError: + jsn := string(byteValue[0:t.Offset]) + jsn += "<--(see the invalid character)" + return fmt.Errorf("invalid character at %v\n %s", t.Offset, jsn) + case *json.UnmarshalTypeError: + jsn := string(byteValue[0:t.Offset]) + jsn += "<--(see the invalid type)" + return fmt.Errorf("invalid value at %v\n %s", t.Offset, jsn) + default: + return err + } + } + return nil +} + func getProvidedAPIs(csv *v1alpha1.ClusterServiceVersion) (provided map[schema.GroupVersionKind]struct{}, errs []errors.Error) { provided = map[schema.GroupVersionKind]struct{}{} for _, owned := range csv.Spec.CustomResourceDefinitions.Owned { diff --git a/staging/api/pkg/validation/internal/csv_test.go b/staging/api/pkg/validation/internal/csv_test.go index 1c94a4f5e9..44f1ae8700 100644 --- a/staging/api/pkg/validation/internal/csv_test.go +++ b/staging/api/pkg/validation/internal/csv_test.go @@ -1,14 +1,15 @@ package internal import ( + "fmt" "io/ioutil" "path/filepath" "testing" + "github.com/ghodss/yaml" operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" "github.com/operator-framework/api/pkg/validation/errors" - - "github.com/ghodss/yaml" + "k8s.io/apimachinery/pkg/runtime/schema" ) func TestValidateCSV(t *testing.T) { @@ -71,7 +72,43 @@ func TestValidateCSV(t *testing.T) { }, filepath.Join("testdata", "badName.csv.yaml"), }, + { + validatorFuncTest{ + description: "should fail when alm-examples is pretty format and is invalid", + wantErr: true, + errors: []errors.Error{ + errors.ErrInvalidParse("invalid example", "invalid character at 176\n [{\"apiVersion\":\"local.storage.openshift.io/v1\",\"kind\":\"LocalVolume\",\"metadata\":{\"name\":\"example\"},\"spec\":{\"storageClassDevices\":[{\"devicePaths\":[\"/dev/disk/by-id/ata-crucial\",]<--(see the invalid character)"), + }, + }, + filepath.Join("testdata", "invalid.alm-examples.csv.yaml"), + }, + { + validatorFuncTest{ + description: "should not fail when alm-examples is not informed", + wantWarn: true, + errors: []errors.Error{ + errors.WarnInvalidOperation("provided API should have an example annotation", schema.GroupVersionKind{Group: "etcd.database.coreos.com", Version: "v1beta2", Kind: "EtcdCluster"}), + }, + }, + filepath.Join("testdata", "correct.csv.empty.example.yaml"), + }, + { + validatorFuncTest{ + description: "should warn when olm.properties are defined in the annotations", + wantWarn: true, + errors: []errors.Error{ + errors.WarnPropertiesAnnotationUsed( + fmt.Sprintf( + "found %s annotation, please define these properties in metadata/properties.yaml instead", + olmpropertiesAnnotation, + ), + ), + }, + }, + filepath.Join("testdata", "correct.csv.olm.properties.annotation.yaml"), + }, } + for _, c := range cases { b, err := ioutil.ReadFile(c.csvPath) if err != nil { diff --git a/staging/api/pkg/validation/internal/good_practices.go b/staging/api/pkg/validation/internal/good_practices.go index 5f22c86fdf..4d294ea6bb 100644 --- a/staging/api/pkg/validation/internal/good_practices.go +++ b/staging/api/pkg/validation/internal/good_practices.go @@ -65,10 +65,10 @@ func validateResourceRequests(csv *operatorsv1alpha1.ClusterServiceVersion) (err for _, dSpec := range deploymentSpec { for _, c := range dSpec.Spec.Template.Spec.Containers { if c.Resources.Requests == nil || !(len(c.Resources.Requests.Cpu().String()) != 0 && len(c.Resources.Requests.Memory().String()) != 0) { - msg := fmt.Errorf("unable to find the resource requests for the container %s. It is recommended "+ + msg := fmt.Errorf("unable to find the resource requests for the container: (%s). It is recommended "+ "to ensure the resource request for CPU and Memory. Be aware that for some clusters configurations "+ "it is required to specify requests or limits for those values. Otherwise, the system or quota may "+ - "reject Pod creation. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", c.Name) + "reject Pod creation. More info: https://master.sdk.operatorframework.io/docs/best-practices/managing-resources/", c.Name) warns = append(warns, msg) } } diff --git a/staging/api/pkg/validation/internal/good_practices_test.go b/staging/api/pkg/validation/internal/good_practices_test.go index ed8a5adf4a..5d2424f05f 100644 --- a/staging/api/pkg/validation/internal/good_practices_test.go +++ b/staging/api/pkg/validation/internal/good_practices_test.go @@ -32,8 +32,8 @@ func Test_ValidateGoodPractices(t *testing.T) { { name: "should raise an waring when the resource request is NOT set for any of the containers defined in the bundle", wantWarning: true, - warnStrings: []string{"Warning: Value memcached-operator.v0.0.1: unable to find the resource requests for the container kube-rbac-proxy. It is recommended to ensure the resource request for CPU and Memory. Be aware that for some clusters configurations it is required to specify requests or limits for those values. Otherwise, the system or quota may reject Pod creation. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", - "Warning: Value memcached-operator.v0.0.1: unable to find the resource requests for the container manager. It is recommended to ensure the resource request for CPU and Memory. Be aware that for some clusters configurations it is required to specify requests or limits for those values. Otherwise, the system or quota may reject Pod creation. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/"}, + warnStrings: []string{"Warning: Value memcached-operator.v0.0.1: unable to find the resource requests for the container: (kube-rbac-proxy). It is recommended to ensure the resource request for CPU and Memory. Be aware that for some clusters configurations it is required to specify requests or limits for those values. Otherwise, the system or quota may reject Pod creation. More info: https://master.sdk.operatorframework.io/docs/best-practices/managing-resources/", + "Warning: Value memcached-operator.v0.0.1: unable to find the resource requests for the container: (manager). It is recommended to ensure the resource request for CPU and Memory. Be aware that for some clusters configurations it is required to specify requests or limits for those values. Otherwise, the system or quota may reject Pod creation. More info: https://master.sdk.operatorframework.io/docs/best-practices/managing-resources/"}, args: args{ bundleDir: "./testdata/valid_bundle_v1", }, diff --git a/staging/api/pkg/validation/internal/operatorhub.go b/staging/api/pkg/validation/internal/operatorhub.go index f265b0c134..48456b3088 100644 --- a/staging/api/pkg/validation/internal/operatorhub.go +++ b/staging/api/pkg/validation/internal/operatorhub.go @@ -11,7 +11,7 @@ import ( "regexp" "strings" - semver "github.com/blang/semver/v4" + "github.com/blang/semver/v4" "github.com/operator-framework/api/pkg/manifests" "github.com/operator-framework/api/pkg/operators/v1alpha1" "github.com/operator-framework/api/pkg/validation/errors" @@ -158,6 +158,10 @@ var validCategories = map[string]struct{}{ "Streaming & Messaging": {}, } +const minKubeVersionWarnMessage = "csv.Spec.minKubeVersion is not informed. It is recommended you provide this information. " + + "Otherwise, it would mean that your operator project can be distributed and installed in any cluster version " + + "available, which is not necessarily the case for all projects." + func validateOperatorHub(objs ...interface{}) (results []errors.ManifestResult) { // Obtain the k8s version if informed via the objects an optional diff --git a/staging/api/pkg/validation/internal/removed_apis.go b/staging/api/pkg/validation/internal/removed_apis.go index 9377b50b00..44dee85d06 100644 --- a/staging/api/pkg/validation/internal/removed_apis.go +++ b/staging/api/pkg/validation/internal/removed_apis.go @@ -3,30 +3,48 @@ package internal import ( "fmt" "github.com/blang/semver" - "github.com/operator-framework/api/pkg/manifests" - "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" - "github.com/operator-framework/api/pkg/validation/errors" interfaces "github.com/operator-framework/api/pkg/validation/interfaces" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "sort" ) // k8sVersionKey defines the key which can be used by its consumers // to inform what is the K8S version that should be used to do the tests against. const k8sVersionKey = "k8s-version" -const minKubeVersionWarnMessage = "csv.Spec.minKubeVersion is not informed. It is recommended you provide this information. " + - "Otherwise, it would mean that your operator project can be distributed and installed in any cluster version " + - "available, which is not necessarily the case for all projects." - -// K8s version where the apis v1betav1 is no longer supported -const k8sVerV1betav1Unsupported = "1.22.0" +// DeprecateMessage defines the content of the message that will be raised as an error or warning +// when the removed apis are found +const DeprecateMessage = "this bundle is using APIs which were deprecated and removed in v%v.%v. " + + "More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v%v-%v. " + + "Migrate the API(s) for %s" -// K8s version where the apis v1betav1 was deprecated -const k8sVerV1betav1Deprecated = "1.16.0" +// K8sVersionsSupportedByValidator defines the k8s versions which this validator is implemented to +// perform the checks +var K8sVersionsSupportedByValidator = []string{"1.22.0", "1.25.0", "1.26.0"} -// AlphaDeprecatedAPIsValidator validates if the bundles is using versions API version which are deprecate or -// removed in specific Kubernetes versions informed via optional key value `k8s-version`. +// AlphaDeprecatedAPIsValidator implements Validator to validate bundle objects +// for API deprecation requirements. +// +// Note that this validator looks at the manifests. If any removed APIs for the mapped k8s versions are found, +// it raises a warning. +// +// This validator only raises an error when the deprecated API found is removed in the specified k8s +// version informed via the optional key `k8s-version`. +// +// The K8s versions supported and checks are: +// +// - 1.22 : https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-22 +// +// - 1.25 : https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-25 +// +// - 1.26 : https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-26 +// +// IMPORTANT: Note that in the case scenarios of 1.25 and 1.26 it is very unlikely the OperatorAuthors +// add manifests on the bundle using these APIs. On top of that some Kinds such as the CronJob +// are not currently a valid/supported by OLM and never would to be added to bundle. +// See: https://github.com/operator-framework/operator-registry/blob/v1.19.5/pkg/lib/bundle/supported_resources.go#L3-L23 var AlphaDeprecatedAPIsValidator interfaces.Validator = interfaces.ValidatorFunc(validateDeprecatedAPIsValidator) func validateDeprecatedAPIsValidator(objs ...interface{}) (results []errors.ManifestResult) { @@ -54,13 +72,14 @@ func validateDeprecatedAPIsValidator(objs ...interface{}) (results []errors.Mani } func validateDeprecatedAPIs(bundle *manifests.Bundle, k8sVersion string) errors.ManifestResult { - result := errors.ManifestResult{Name: bundle.Name} - + result := errors.ManifestResult{} if bundle == nil { result.Add(errors.ErrInvalidBundle("Bundle is nil", nil)) return result } + result.Name = bundle.Name + if bundle.CSV == nil { result.Add(errors.ErrInvalidBundle("Bundle csv is nil", bundle.Name)) return result @@ -78,34 +97,22 @@ func validateDeprecatedAPIs(bundle *manifests.Bundle, k8sVersion string) errors. } // validateDeprecatedAPIS will check if the operator bundle is using a deprecated or no longer supported k8s api -// Note if the k8s was informed via "k8s=1.22" it will be used. Otherwise, we will use the minKubeVersion in -// the CSV to do the checks. So, the criteria is >=minKubeVersion. By last, if the minKubeVersion is not provided +// Note if the k8s version was informed via "k8s-version" optional key it will be used. Otherwise, we will use the minKubeVersion in +// the CSV to do the checks. So, the criteria is >=minKubeVersion. Lastly, if the minKubeVersion is not provided // then, we should consider the operator bundle is intend to work well in any Kubernetes version. // Then, it means that: -//--optional-values="k8s-version=value" flag with a value => 1.16 <= 1.22 the validator will return result as warning. -//--optional-values="k8s-version=value" flag with a value => 1.22 the validator will return result as error. -//minKubeVersion >= 1.22 return the error result. -//minKubeVersion empty returns a warning since it would mean the same of allow install in any supported version +// - --optional-values="k8s-version=value" flag with a value <= unsupportedAPIVersion the validator will return result as warning. +// - --optional-values="k8s-version=value" flag with a value => unsupportedAPIVersion the validator will return result as error. +// - minKubeVersion >= unsupportedAPIVersion return the error result. +// - minKubeVersion empty returns a warning since it would mean the same of allow in any supported version func validateDeprecatedAPIS(bundle *manifests.Bundle, versionProvided string) (errs, warns []error) { - - // semver of the K8s version where the apis v1betav1 is no longer supported to allow us compare - semVerK8sVerV1betav1Unsupported := semver.MustParse(k8sVerV1betav1Unsupported) - // semver of the K8s version where the apis v1betav1 is deprecated to allow us compare - semVerk8sVerV1betav1Deprecated := semver.MustParse(k8sVerV1betav1Deprecated) // isVersionProvided defines if the k8s version to test against was or not informed isVersionProvided := len(versionProvided) > 0 + // semVerVersionProvided -- converts the k8s version informed in semver + semVerVersionProvided, _ := semver.ParseTolerant(versionProvided) - // Transform the key/option versionProvided in semver Version to compare - var semVerVersionProvided semver.Version - if isVersionProvided { - var err error - semVerVersionProvided, err = semver.ParseTolerant(versionProvided) - if err != nil { - errs = append(errs, fmt.Errorf("invalid value informed via the k8s key option : %s", versionProvided)) - } else { - // we might want to return it as info instead of warning in the future. - warns = append(warns, fmt.Errorf("checking APIs against Kubernetes version : %s", versionProvided)) - } + if err := verifyK8sVersionInformed(versionProvided); err != nil && isVersionProvided { + errs = append(errs, err) } // Transform the spec minKubeVersion in semver Version to compare @@ -118,39 +125,86 @@ func validateDeprecatedAPIS(bundle *manifests.Bundle, versionProvided string) (e } } - // if the k8s value was informed and it is >=1.16 we should check - // if the k8s value was not informed we also should check since the - // check should occurs with any minKubeVersion value: - // - if minKubeVersion empty then means that the project can be installed in any version - // - if minKubeVersion any version defined it means that we are considering install - // in any upper version from that where the check is always applied - if !isVersionProvided || semVerVersionProvided.GE(semVerk8sVerV1betav1Deprecated) { - deprecatedAPIs := getRemovedAPIsOn1_22From(bundle) - if len(deprecatedAPIs) > 0 { - deprecatedAPIsMessage := generateMessageWithDeprecatedAPIs(deprecatedAPIs) - // isUnsupported is true only if the key/value OR minKubeVersion were informed and are >= 1.22 - isUnsupported := semVerVersionProvided.GE(semVerK8sVerV1betav1Unsupported) || - semverMinKube.GE(semVerK8sVerV1betav1Unsupported) - // We only raise an error when the version >= 1.22 was informed via + // Check the bundle with all k8s versions implemented + for _, v := range K8sVersionsSupportedByValidator { + k8sVersionToCheck := semver.MustParse(v) + errs, warns = checkRemovedAPIsForVersion(bundle, + k8sVersionToCheck, + semVerVersionProvided, + semverMinKube, + errs, + warns) + } + + return errs, warns +} + +// checkRemovedAPIsForVersion will check if the bundle is using the removed APIs +// for the version informed (k8sVersionToCheck) +func checkRemovedAPIsForVersion( + bundle *manifests.Bundle, + k8sVersionToCheck, semVerVersionProvided, semverMinKube semver.Version, + errs []error, warns []error) ([]error, []error) { + + found := map[string][]string{} + switch k8sVersionToCheck.String() { + case "1.22.0": + found = getRemovedAPIsOn1_22From(bundle) + case "1.25.0": + found = getRemovedAPIsOn1_25From(bundle) + case "1.26.0": + found = getRemovedAPIsOn1_26From(bundle) + default: + panic(fmt.Errorf("invalid internal call to check the removed apis with the version (%s) which is not supported", k8sVersionToCheck.String())) + } + + if len(found) > 0 { + deprecatedAPIsMessage := generateMessageWithDeprecatedAPIs(found) + msg := fmt.Errorf(DeprecateMessage, + k8sVersionToCheck.Major, k8sVersionToCheck.Minor, + k8sVersionToCheck.Major, k8sVersionToCheck.Minor, + deprecatedAPIsMessage) + if isK8sVersionInformedEQ(semVerVersionProvided, k8sVersionToCheck, semverMinKube) { + // We only raise an error when the version >= 1.26 was informed via // the k8s key/value option or is specifically defined in the CSV - msg := fmt.Errorf("this bundle is using APIs which were deprecated and removed in v1.22. More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-22. Migrate the API(s) for %s", deprecatedAPIsMessage) - if isUnsupported { - errs = append(errs, msg) - } else { - warns = append(warns, msg) - } + errs = append(errs, msg) + } else { + warns = append(warns, msg) } } - return errs, warns } +// isK8sVersionInformedEQ returns true only if the key/value OR minKubeVersion were informed and are >= semVerAPIUnsupported +func isK8sVersionInformedEQ(semVerVersionProvided semver.Version, semVerAPIUnsupported semver.Version, semverMinKube semver.Version) bool { + return semVerVersionProvided.GE(semVerAPIUnsupported) || semverMinKube.GE(semVerAPIUnsupported) +} + +func verifyK8sVersionInformed(versionProvided string) error { + if _, err := semver.ParseTolerant(versionProvided); err != nil { + return fmt.Errorf("invalid value informed via the k8s key option : %s", versionProvided) + } + return nil +} + // generateMessageWithDeprecatedAPIs will return a list with the kind and the name // of the resource which were found and required to be upgraded func generateMessageWithDeprecatedAPIs(deprecatedAPIs map[string][]string) string { msg := "" count := 0 - for k, v := range deprecatedAPIs { + + keys := make([]string, 0, len(deprecatedAPIs)) + for k := range deprecatedAPIs { + keys = append(keys, k) + } + sort.Strings(keys) + + deprecatedAPIsSorted := make(map[string][]string) + for _, key := range keys { + deprecatedAPIsSorted[key] = deprecatedAPIs[key] + } + + for k, v := range deprecatedAPIsSorted { if count == len(deprecatedAPIs)-1 { msg = msg + fmt.Sprintf("%s: (%+q)", k, v) } else { @@ -160,9 +214,6 @@ func generateMessageWithDeprecatedAPIs(deprecatedAPIs map[string][]string) strin return msg } -// todo: we need to improve this code since we ought to map the kinds, apis and ocp/k8s versions -// where them are no longer supported ( removed ) instead of have this fixed in this way. - // getRemovedAPIsOn1_22From return the list of resources which were deprecated // and are no longer be supported in 1.22. More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-22 func getRemovedAPIsOn1_22From(bundle *manifests.Bundle) map[string][]string { @@ -228,3 +279,69 @@ func getRemovedAPIsOn1_22From(bundle *manifests.Bundle) map[string][]string { } return deprecatedAPIs } + +// getRemovedAPIsOn1_25From return the list of resources which were deprecated +// and are no longer be supported in 1.25. More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-25 +// +// IMPORTANT: Note that in the case scenarios of 1.25 and 1.26 it is very unlikely the OperatorAuthors +// add manifests on the bundle using these APIs. On top of that some Kinds such as the CronJob +// are not currently a valid/supported by OLM and never would to be added to bundle. +// See: https://github.com/operator-framework/operator-registry/blob/v1.19.5/pkg/lib/bundle/supported_resources.go#L3-L23 +func getRemovedAPIsOn1_25From(bundle *manifests.Bundle) map[string][]string { + deprecatedAPIs := make(map[string][]string) + for _, obj := range bundle.Objects { + switch u := obj.GetObjectKind().(type) { + case *unstructured.Unstructured: + switch u.GetAPIVersion() { + case "batch/v1beta1": + if u.GetKind() == "CronJob" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "discovery.k8s.io/v1beta1": + if u.GetKind() == "EndpointSlice" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "events.k8s.io/v1beta1": + if u.GetKind() == "Event" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "autoscaling/v2beta1": + if u.GetKind() == "HorizontalPodAutoscaler" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "policy/v1beta1": + if u.GetKind() == "PodDisruptionBudget" || u.GetKind() == "PodSecurityPolicy" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "node.k8s.io/v1beta1": + if u.GetKind() == "RuntimeClass" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + } + } + } + return deprecatedAPIs +} + +// getRemovedAPIsOn1_26From return the list of resources which were deprecated +// and are no longer be supported in 1.26. More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-26 +// +// IMPORTANT: Note that in the case scenarios of 1.25 and 1.26 it is very unlikely the OperatorAuthors +// add manifests on the bundle using these APIs. On top of that some Kinds such as the CronJob +// are not currently a valid/supported by OLM and never would to be added to bundle. +// See: https://github.com/operator-framework/operator-registry/blob/v1.19.5/pkg/lib/bundle/supported_resources.go#L3-L23 +func getRemovedAPIsOn1_26From(bundle *manifests.Bundle) map[string][]string { + deprecatedAPIs := make(map[string][]string) + for _, obj := range bundle.Objects { + switch u := obj.GetObjectKind().(type) { + case *unstructured.Unstructured: + switch u.GetAPIVersion() { + case "autoscaling/v2beta2": + if u.GetKind() == "HorizontalPodAutoscaler" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + } + } + } + return deprecatedAPIs +} diff --git a/staging/api/pkg/validation/internal/removed_apis_test.go b/staging/api/pkg/validation/internal/removed_apis_test.go index 440b34a69c..1b1aabdabb 100644 --- a/staging/api/pkg/validation/internal/removed_apis_test.go +++ b/staging/api/pkg/validation/internal/removed_apis_test.go @@ -7,8 +7,7 @@ import ( "testing" ) -func Test_getDeprecatedAPIs(t *testing.T) { - +func Test_GetRemovedAPIsOn1_22From(t *testing.T) { // Mock the expected result for ./testdata/valid_bundle_v1beta1 crdMock := make(map[string][]string) crdMock["CRD"] = []string{"etcdbackups.etcd.database.coreos.com", "etcdclusters.etcd.database.coreos.com", "etcdrestores.etcd.database.coreos.com"} @@ -64,6 +63,89 @@ func Test_getDeprecatedAPIs(t *testing.T) { } } +func Test_GetRemovedAPIsOn1_25From(t *testing.T) { + mock := make(map[string][]string) + mock["HorizontalPodAutoscaler"] = []string{"memcached-operator-hpa"} + mock["PodDisruptionBudget"] = []string{"memcached-operator-policy-manager"} + + type args struct { + bundleDir string + } + tests := []struct { + name string + args args + want map[string][]string + }{ + { + name: "should return an empty map when no deprecated apis are found", + args: args{ + bundleDir: "./testdata/valid_bundle_v1", + }, + want: map[string][]string{}, + }, + { + name: "should fail return the removed APIs in 1.25", + args: args{ + bundleDir: "./testdata/removed_api_1_25", + }, + want: mock, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + // Validate the bundle object + bundle, err := manifests.GetBundleFromDir(tt.args.bundleDir) + require.NoError(t, err) + + if got := getRemovedAPIsOn1_25From(bundle); !reflect.DeepEqual(got, tt.want) { + t.Errorf("getRemovedAPIsOn1_25From() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_GetRemovedAPIsOn1_26From(t *testing.T) { + mock := make(map[string][]string) + mock["HorizontalPodAutoscaler"] = []string{"memcached-operator-hpa"} + + type args struct { + bundleDir string + } + tests := []struct { + name string + args args + want map[string][]string + }{ + { + name: "should return an empty map when no deprecated apis are found", + args: args{ + bundleDir: "./testdata/valid_bundle_v1", + }, + want: map[string][]string{}, + }, + { + name: "should fail return the removed APIs in 1.26", + args: args{ + bundleDir: "./testdata/removed_api_1_26", + }, + want: mock, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + // Validate the bundle object + bundle, err := manifests.GetBundleFromDir(tt.args.bundleDir) + require.NoError(t, err) + + if got := getRemovedAPIsOn1_26From(bundle); !reflect.DeepEqual(got, tt.want) { + t.Errorf("getRemovedAPIsOn1_26From() = %v, want %v", got, tt.want) + } + }) + } +} + func TestValidateDeprecatedAPIS(t *testing.T) { type args struct { minKubeVersion string @@ -78,16 +160,6 @@ func TestValidateDeprecatedAPIS(t *testing.T) { errStrings []string warnStrings []string }{ - { - name: "should not return error or warning when the k8sVersion is <= 1.15", - args: args{ - k8sVersion: "1.15", - minKubeVersion: "", - directory: "./testdata/valid_bundle_v1beta1", - }, - wantWarning: true, - warnStrings: []string{"checking APIs against Kubernetes version : 1.15"}, - }, { name: "should return a warning when has the CRD v1beta1 and minKubeVersion is informed", args: args{ @@ -101,16 +173,6 @@ func TestValidateDeprecatedAPIS(t *testing.T) { "Migrate the API(s) for CRD: ([\"etcdbackups.etcd.database.coreos.com\" " + "\"etcdclusters.etcd.database.coreos.com\" \"etcdrestores.etcd.database.coreos.com\"])"}, }, - { - name: "should not return a warning or error when has minKubeVersion but the k8sVersion informed is <= 1.15", - args: args{ - k8sVersion: "1.15", - minKubeVersion: "1.11.3", - directory: "./testdata/valid_bundle_v1beta1", - }, - wantWarning: true, - warnStrings: []string{"checking APIs against Kubernetes version : 1.15"}, - }, { name: "should return an error when the k8sVersion is >= 1.22 and has the deprecated API", args: args{ @@ -123,8 +185,56 @@ func TestValidateDeprecatedAPIS(t *testing.T) { "More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-22. " + "Migrate the API(s) for CRD: ([\"etcdbackups.etcd.database.coreos.com\"" + " \"etcdclusters.etcd.database.coreos.com\" \"etcdrestores.etcd.database.coreos.com\"])"}, + }, + { + name: "should return an error when the k8sVersion is >= 1.25 and found removed APIs on 1.25", + args: args{ + k8sVersion: "1.25", + minKubeVersion: "", + directory: "./testdata/removed_api_1_25", + }, + wantError: true, + errStrings: []string{"this bundle is using APIs which were deprecated and removed in v1.25. " + + "More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-25. " + + "Migrate the API(s) for HorizontalPodAutoscaler: ([\"memcached-operator-hpa\"])," + + "PodDisruptionBudget: ([\"memcached-operator-policy-manager\"]),"}, + }, + { + name: "should return a warning if the k8sVersion is empty and found removed APIs on 1.25", + args: args{ + k8sVersion: "", + minKubeVersion: "", + directory: "./testdata/removed_api_1_25", + }, + wantWarning: true, + warnStrings: []string{"this bundle is using APIs which were deprecated and removed in v1.25. " + + "More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-25. " + + "Migrate the API(s) for HorizontalPodAutoscaler: ([\"memcached-operator-hpa\"])," + + "PodDisruptionBudget: ([\"memcached-operator-policy-manager\"]),"}, + }, + { + name: "should return an error when the k8sVersion is >= 1.26 and found removed APIs on 1.26", + args: args{ + k8sVersion: "1.26", + minKubeVersion: "", + directory: "./testdata/removed_api_1_26", + }, + wantError: true, + errStrings: []string{"this bundle is using APIs which were deprecated and removed in v1.26. " + + "More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-26. " + + "Migrate the API(s) for HorizontalPodAutoscaler: ([\"memcached-operator-hpa\"])"}, + }, + { + name: "should return a warning when the k8sVersion is empty and found removed APIs on 1.26", + args: args{ + k8sVersion: "", + minKubeVersion: "", + directory: "./testdata/removed_api_1_26", + }, wantWarning: true, - warnStrings: []string{"checking APIs against Kubernetes version : 1.22"}, + warnStrings: []string{"this bundle is using APIs which were deprecated and removed in v1.26. " + + "More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-26. " + + "Migrate the API(s) for HorizontalPodAutoscaler: ([\"memcached-operator-hpa\"])"}, }, { name: "should return an error when the k8sVersion informed is invalid", @@ -133,8 +243,13 @@ func TestValidateDeprecatedAPIS(t *testing.T) { minKubeVersion: "", directory: "./testdata/valid_bundle_v1beta1", }, - wantError: true, - errStrings: []string{"invalid value informed via the k8s key option : invalid"}, + wantError: true, + errStrings: []string{"invalid value informed via the k8s key option : invalid"}, + wantWarning: true, + warnStrings: []string{"this bundle is using APIs which were deprecated and removed in v1.22. " + + "More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-22. " + + "Migrate the API(s) for CRD: ([\"etcdbackups.etcd.database.coreos.com\"" + + " \"etcdclusters.etcd.database.coreos.com\" \"etcdrestores.etcd.database.coreos.com\"])"}, }, { name: "should return an error when the csv.spec.minKubeVersion informed is invalid", diff --git a/staging/api/pkg/validation/internal/testdata/correct.csv.empty.example.yaml b/staging/api/pkg/validation/internal/testdata/correct.csv.empty.example.yaml new file mode 100644 index 0000000000..2aa19870d8 --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/correct.csv.empty.example.yaml @@ -0,0 +1,61 @@ +#! validate-crd: deploy/chart/templates/0000_30_02-clusterserviceversion.crd.yaml +#! parse-kind: ClusterServiceVersion +apiVersion: operators.coreos.com/v1alpha1 +kind: ClusterServiceVersion +metadata: + name: etcdoperator.v0.9.0 + namespace: placeholder + annotations: + "alm-examples": "" +spec: + version: 0.9.0 + installModes: + - type: AllNamespaces + supported: true + install: + strategy: deployment + spec: + permissions: + - serviceAccountName: etcd-operator + rules: + - apiGroups: + - etcd.database.coreos.com + resources: + - etcdclusters + - etcdbackups + - etcdrestores + verbs: + - "*" + deployments: + - name: etcd-operator + spec: + replicas: 1 + template: + metadata: + name: etcd-operator-alm-owned + labels: + name: etcd-operator-alm-owned + spec: + serviceAccountName: etcd-operator + containers: + - name: etcd-operator + command: + - etcd-operator + - --create-crd=false + image: quay.io/coreos/etcd-operator@sha256:db563baa8194fcfe39d1df744ed70024b0f1f9e9b55b5923c2f3a413c44dc6b8 + env: + - name: MY_POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: MY_POD_NAME + valueFrom: + fieldRef: + fieldPath: metadata.name + customresourcedefinitions: + owned: + - name: etcdclusters.etcd.database.coreos.com + version: v1beta2 + kind: EtcdCluster + + diff --git a/staging/api/pkg/validation/internal/testdata/correct.csv.olm.properties.annotation.yaml b/staging/api/pkg/validation/internal/testdata/correct.csv.olm.properties.annotation.yaml new file mode 100644 index 0000000000..6794c5121e --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/correct.csv.olm.properties.annotation.yaml @@ -0,0 +1,60 @@ +#! validate-crd: deploy/chart/templates/0000_30_02-clusterserviceversion.crd.yaml +#! parse-kind: ClusterServiceVersion +apiVersion: operators.coreos.com/v1alpha1 +kind: ClusterServiceVersion +metadata: + name: etcdoperator.v0.9.0 + namespace: placeholder + annotations: + alm-examples: '[{"apiVersion":"etcd.database.coreos.com/v1beta2","kind":"EtcdCluster","metadata":{"name":"example","namespace":"default"},"spec":{"size":3,"version":"3.2.13"}},{"apiVersion":"etcd.database.coreos.com/v1beta2","kind":"EtcdRestore","metadata":{"name":"example-etcd-cluster"},"spec":{"etcdCluster":{"name":"example-etcd-cluster"},"backupStorageType":"S3","s3":{"path":"","awsSecret":""}}},{"apiVersion":"etcd.database.coreos.com/v1beta2","kind":"EtcdBackup","metadata":{"name":"example-etcd-cluster-backup"},"spec":{"etcdEndpoints":[""],"storageType":"S3","s3":{"path":"","awsSecret":""}}}]' + olm.properties: '[{"type": "foo", "value": "bar"}]' +spec: + version: 0.9.0 + installModes: + - type: AllNamespaces + supported: true + install: + strategy: deployment + spec: + permissions: + - serviceAccountName: etcd-operator + rules: + - apiGroups: + - etcd.database.coreos.com + resources: + - etcdclusters + - etcdbackups + - etcdrestores + verbs: + - "*" + deployments: + - name: etcd-operator + spec: + replicas: 1 + template: + metadata: + name: etcd-operator-alm-owned + labels: + name: etcd-operator-alm-owned + spec: + serviceAccountName: etcd-operator + containers: + - name: etcd-operator + command: + - etcd-operator + - --create-crd=false + image: quay.io/coreos/etcd-operator@sha256:db563baa8194fcfe39d1df744ed70024b0f1f9e9b55b5923c2f3a413c44dc6b8 + env: + - name: MY_POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: MY_POD_NAME + valueFrom: + fieldRef: + fieldPath: metadata.name + customresourcedefinitions: + owned: + - name: etcdclusters.etcd.database.coreos.com + version: v1beta2 + kind: EtcdCluster \ No newline at end of file diff --git a/staging/api/pkg/validation/internal/testdata/invalid.alm-examples.csv.yaml b/staging/api/pkg/validation/internal/testdata/invalid.alm-examples.csv.yaml new file mode 100644 index 0000000000..1d6bfc13bd --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/invalid.alm-examples.csv.yaml @@ -0,0 +1,34 @@ +apiVersion: operators.coreos.com/v1alpha1 +kind: ClusterServiceVersion +metadata: + annotations: + alm-examples: '[{"apiVersion":"local.storage.openshift.io/v1","kind":"LocalVolume","metadata":{"name":"example"},"spec":{"storageClassDevices":[{"devicePaths":["/dev/disk/by-id/ata-crucial",],"fsType": "ext4", "storageClassName": "foobar", "volumeMode": "Filesystem" } ] } }, { "apiVersion": "local.storage.openshift.io/v1alpha1", "kind": "LocalVolumeSet", "metadata": { "name": "example-localvolumeset" }, "spec": { "deviceInclusionSpec": { "deviceMechanicalProperties": [ "Rotational", "NonRotational" ], "deviceTypes": [ "RawDisk" ], "maxSize": "100G", "minSize": "10G" }, "maxDeviceCount": 10, "nodeSelector": { "nodeSelectorTerms": [ { "matchExpressions": [ { "key": "kubernetes.io/hostname", "operator": "In", "values": [ "worker-0", "worker-1" ] } ] } ] }, "storageClassName": "example-storageclass", "volumeMode": "Block" } }, { "apiVersion": "local.storage.openshift.io/v1alpha1", "kind": "LocalVolumeDiscovery", "metadata": { "name": "auto-discover-devices" }, "spec": { "nodeSelector": { "nodeSelectorTerms": [ { "matchExpressions": [ { "key":"kubernetes.io/hostname","operator":"In","values":["worker-0","worker-1"]}]}]}}}]' + capabilities: Basic Install + name: test-operator.v0.0.1 + namespace: placeholder +spec: + displayName: test-operator + install: + strategy: deployment + installModes: + - supported: true + type: OwnNamespace + - supported: true + type: SingleNamespace + - supported: false + type: MultiNamespace + - supported: true + type: AllNamespaces + keywords: + - test-operator + links: + - name: Test Operator + url: https://test-operator.domain + maintainers: + - email: your@email.com + name: Maintainer Name + maturity: alpha + provider: + name: Provider Name + url: https://your.domain + version: 0.0.1 diff --git a/staging/api/pkg/validation/internal/testdata/removed_api_1_25/cache.example.com_memcacheds.yaml b/staging/api/pkg/validation/internal/testdata/removed_api_1_25/cache.example.com_memcacheds.yaml new file mode 100644 index 0000000000..a8ea3eb8d3 --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/removed_api_1_25/cache.example.com_memcacheds.yaml @@ -0,0 +1,66 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.4.1 + creationTimestamp: null + name: memcacheds.cache.example.com +spec: + group: cache.example.com + names: + kind: Memcached + listKind: MemcachedList + plural: memcacheds + singular: memcached + scope: Namespaced + versions: + - name: v1alpha1 + schema: + openAPIV3Schema: + description: Memcached is the Schema for the memcacheds API + properties: + apiVersion: + description: 'APIVersion defines the versioned schema of this representation + of an object. Servers should convert recognized schemas to the latest + internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources' + type: string + kind: + description: 'Kind is a string value representing the REST resource this + object represents. Servers may infer this from the endpoint the client + submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds' + type: string + metadata: + type: object + spec: + description: MemcachedSpec defines the desired state of Memcached + properties: + foo: + description: Foo is an example field of Memcached. Edit memcached_types.go + to remove/update + type: string + size: + description: Size defines the number of Memcached instances + format: int32 + type: integer + type: object + status: + description: MemcachedStatus defines the observed state of Memcached + properties: + nodes: + description: Nodes store the name of the pods which are running Memcached + instances + items: + type: string + type: array + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: [] + storedVersions: [] diff --git a/staging/api/pkg/validation/internal/testdata/removed_api_1_25/horizontal-pod.yaml b/staging/api/pkg/validation/internal/testdata/removed_api_1_25/horizontal-pod.yaml new file mode 100644 index 0000000000..69f77b5f49 --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/removed_api_1_25/horizontal-pod.yaml @@ -0,0 +1,18 @@ +apiVersion: autoscaling/v2beta1 +kind: HorizontalPodAutoscaler +metadata: + name: memcached-operator-hpa +spec: + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: memcached-operator-controller-manager + minReplicas: 1 + maxReplicas: 10 + metrics: + - type: Resource + resource: + name: cpu + target: + type: Utilization + averageUtilization: 50 \ No newline at end of file diff --git a/staging/api/pkg/validation/internal/testdata/removed_api_1_25/memcached-operator.clusterserviceversion.yaml b/staging/api/pkg/validation/internal/testdata/removed_api_1_25/memcached-operator.clusterserviceversion.yaml new file mode 100644 index 0000000000..bddc807691 --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/removed_api_1_25/memcached-operator.clusterserviceversion.yaml @@ -0,0 +1,252 @@ +apiVersion: operators.coreos.com/v1alpha1 +kind: ClusterServiceVersion +metadata: + annotations: + alm-examples: |- + [ + { + "apiVersion": "cache.example.com/v1alpha1", + "kind": "Memcached", + "metadata": { + "name": "memcached-sample" + }, + "spec": { + "size": 1 + } + } + ] + capabilities: Basic Install + name: memcached-operator.v0.0.1 + namespace: placeholder +spec: + apiservicedefinitions: {} + customresourcedefinitions: + owned: + - description: Memcached is the Schema for the memcacheds API + displayName: Memcached + kind: Memcached + name: memcacheds.cache.example.com + version: v1alpha1 + description: Memcached Operator description. TODO. + displayName: Memcached Operator + icon: + - base64data: "" + mediatype: "" + install: + spec: + clusterPermissions: + - rules: + - apiGroups: + - apps + resources: + - deployments + verbs: + - create + - delete + - get + - list + - patch + - update + - watch + - apiGroups: + - cache.example.com + resources: + - memcacheds + verbs: + - create + - delete + - get + - list + - patch + - update + - watch + - apiGroups: + - cache.example.com + resources: + - memcacheds/finalizers + verbs: + - update + - apiGroups: + - cache.example.com + resources: + - memcacheds/status + verbs: + - get + - patch + - update + - apiGroups: + - "" + resources: + - pods + verbs: + - get + - list + - watch + - apiGroups: + - authentication.k8s.io + resources: + - tokenreviews + verbs: + - create + - apiGroups: + - authorization.k8s.io + resources: + - subjectaccessreviews + verbs: + - create + serviceAccountName: memcached-operator-controller-manager + deployments: + - name: memcached-operator-controller-manager + spec: + replicas: 1 + selector: + matchLabels: + control-plane: controller-manager + strategy: {} + template: + metadata: + labels: + control-plane: controller-manager + spec: + containers: + - args: + - --secure-listen-address=0.0.0.0:8443 + - --upstream=http://127.0.0.1:8080/ + - --logtostderr=true + - --v=10 + image: gcr.io/kubebuilder/kube-rbac-proxy:v0.8.0 + name: kube-rbac-proxy + ports: + - containerPort: 8443 + name: https + resources: {} + - args: + - --health-probe-bind-address=:8081 + - --metrics-bind-address=127.0.0.1:8080 + - --leader-elect + command: + - /manager + image: quay.io/example/memcached-operator:v0.0.1 + livenessProbe: + httpGet: + path: /healthz + port: 8081 + initialDelaySeconds: 15 + periodSeconds: 20 + name: manager + ports: + - containerPort: 9443 + name: webhook-server + protocol: TCP + readinessProbe: + httpGet: + path: /readyz + port: 8081 + initialDelaySeconds: 5 + periodSeconds: 10 + securityContext: + allowPrivilegeEscalation: false + securityContext: + runAsNonRoot: true + serviceAccountName: memcached-operator-controller-manager + terminationGracePeriodSeconds: 10 + permissions: + - rules: + - apiGroups: + - "" + resources: + - configmaps + verbs: + - get + - list + - watch + - create + - update + - patch + - delete + - apiGroups: + - coordination.k8s.io + resources: + - leases + verbs: + - get + - list + - watch + - create + - update + - patch + - delete + - apiGroups: + - "" + resources: + - events + verbs: + - create + - patch + serviceAccountName: memcached-operator-controller-manager + strategy: deployment + installModes: + - supported: false + type: OwnNamespace + - supported: false + type: SingleNamespace + - supported: false + type: MultiNamespace + - supported: true + type: AllNamespaces + keywords: + - memcached-operator + links: + - name: Memcached Operator + url: https://memcached-operator.domain + maintainers: + - email: your@email.com + name: Maintainer Name + maturity: alpha + provider: + name: Provider Name + url: https://your.domain + version: 0.0.1 + webhookdefinitions: + - admissionReviewVersions: + - v1 + - v1beta1 + containerPort: 443 + deploymentName: memcached-operator-controller-manager + failurePolicy: Fail + generateName: vmemcached.kb.io + rules: + - apiGroups: + - cache.example.com + apiVersions: + - v1alpha1 + operations: + - CREATE + - UPDATE + resources: + - memcacheds + sideEffects: None + targetPort: 9443 + type: ValidatingAdmissionWebhook + webhookPath: /validate-cache-example-com-v1alpha1-memcached + - admissionReviewVersions: + - v1 + - v1beta1 + containerPort: 443 + deploymentName: memcached-operator-controller-manager + failurePolicy: Fail + generateName: mmemcached.kb.io + rules: + - apiGroups: + - cache.example.com + apiVersions: + - v1alpha1 + operations: + - CREATE + - UPDATE + resources: + - memcacheds + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate-cache-example-com-v1alpha1-memcached diff --git a/staging/api/pkg/validation/internal/testdata/removed_api_1_25/policy.yaml b/staging/api/pkg/validation/internal/testdata/removed_api_1_25/policy.yaml new file mode 100644 index 0000000000..15714a60c3 --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/removed_api_1_25/policy.yaml @@ -0,0 +1,9 @@ +apiVersion: policy/v1beta1 +kind: PodDisruptionBudget +metadata: + name: memcached-operator-policy-manager +spec: + minAvailable: 2 + selector: + matchLabels: + app: memcached-operator \ No newline at end of file diff --git a/staging/api/pkg/validation/internal/testdata/removed_api_1_26/cache.example.com_memcacheds.yaml b/staging/api/pkg/validation/internal/testdata/removed_api_1_26/cache.example.com_memcacheds.yaml new file mode 100644 index 0000000000..a8ea3eb8d3 --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/removed_api_1_26/cache.example.com_memcacheds.yaml @@ -0,0 +1,66 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.4.1 + creationTimestamp: null + name: memcacheds.cache.example.com +spec: + group: cache.example.com + names: + kind: Memcached + listKind: MemcachedList + plural: memcacheds + singular: memcached + scope: Namespaced + versions: + - name: v1alpha1 + schema: + openAPIV3Schema: + description: Memcached is the Schema for the memcacheds API + properties: + apiVersion: + description: 'APIVersion defines the versioned schema of this representation + of an object. Servers should convert recognized schemas to the latest + internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources' + type: string + kind: + description: 'Kind is a string value representing the REST resource this + object represents. Servers may infer this from the endpoint the client + submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds' + type: string + metadata: + type: object + spec: + description: MemcachedSpec defines the desired state of Memcached + properties: + foo: + description: Foo is an example field of Memcached. Edit memcached_types.go + to remove/update + type: string + size: + description: Size defines the number of Memcached instances + format: int32 + type: integer + type: object + status: + description: MemcachedStatus defines the observed state of Memcached + properties: + nodes: + description: Nodes store the name of the pods which are running Memcached + instances + items: + type: string + type: array + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: [] + storedVersions: [] diff --git a/staging/api/pkg/validation/internal/testdata/removed_api_1_26/horizontal-pod.yaml b/staging/api/pkg/validation/internal/testdata/removed_api_1_26/horizontal-pod.yaml new file mode 100644 index 0000000000..33d6e16fa1 --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/removed_api_1_26/horizontal-pod.yaml @@ -0,0 +1,18 @@ +apiVersion: autoscaling/v2beta2 +kind: HorizontalPodAutoscaler +metadata: + name: memcached-operator-hpa +spec: + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: memcached-operator-controller-manager + minReplicas: 1 + maxReplicas: 10 + metrics: + - type: Resource + resource: + name: cpu + target: + type: Utilization + averageUtilization: 50 \ No newline at end of file diff --git a/staging/api/pkg/validation/internal/testdata/removed_api_1_26/memcached-operator.clusterserviceversion.yaml b/staging/api/pkg/validation/internal/testdata/removed_api_1_26/memcached-operator.clusterserviceversion.yaml new file mode 100644 index 0000000000..bddc807691 --- /dev/null +++ b/staging/api/pkg/validation/internal/testdata/removed_api_1_26/memcached-operator.clusterserviceversion.yaml @@ -0,0 +1,252 @@ +apiVersion: operators.coreos.com/v1alpha1 +kind: ClusterServiceVersion +metadata: + annotations: + alm-examples: |- + [ + { + "apiVersion": "cache.example.com/v1alpha1", + "kind": "Memcached", + "metadata": { + "name": "memcached-sample" + }, + "spec": { + "size": 1 + } + } + ] + capabilities: Basic Install + name: memcached-operator.v0.0.1 + namespace: placeholder +spec: + apiservicedefinitions: {} + customresourcedefinitions: + owned: + - description: Memcached is the Schema for the memcacheds API + displayName: Memcached + kind: Memcached + name: memcacheds.cache.example.com + version: v1alpha1 + description: Memcached Operator description. TODO. + displayName: Memcached Operator + icon: + - base64data: "" + mediatype: "" + install: + spec: + clusterPermissions: + - rules: + - apiGroups: + - apps + resources: + - deployments + verbs: + - create + - delete + - get + - list + - patch + - update + - watch + - apiGroups: + - cache.example.com + resources: + - memcacheds + verbs: + - create + - delete + - get + - list + - patch + - update + - watch + - apiGroups: + - cache.example.com + resources: + - memcacheds/finalizers + verbs: + - update + - apiGroups: + - cache.example.com + resources: + - memcacheds/status + verbs: + - get + - patch + - update + - apiGroups: + - "" + resources: + - pods + verbs: + - get + - list + - watch + - apiGroups: + - authentication.k8s.io + resources: + - tokenreviews + verbs: + - create + - apiGroups: + - authorization.k8s.io + resources: + - subjectaccessreviews + verbs: + - create + serviceAccountName: memcached-operator-controller-manager + deployments: + - name: memcached-operator-controller-manager + spec: + replicas: 1 + selector: + matchLabels: + control-plane: controller-manager + strategy: {} + template: + metadata: + labels: + control-plane: controller-manager + spec: + containers: + - args: + - --secure-listen-address=0.0.0.0:8443 + - --upstream=http://127.0.0.1:8080/ + - --logtostderr=true + - --v=10 + image: gcr.io/kubebuilder/kube-rbac-proxy:v0.8.0 + name: kube-rbac-proxy + ports: + - containerPort: 8443 + name: https + resources: {} + - args: + - --health-probe-bind-address=:8081 + - --metrics-bind-address=127.0.0.1:8080 + - --leader-elect + command: + - /manager + image: quay.io/example/memcached-operator:v0.0.1 + livenessProbe: + httpGet: + path: /healthz + port: 8081 + initialDelaySeconds: 15 + periodSeconds: 20 + name: manager + ports: + - containerPort: 9443 + name: webhook-server + protocol: TCP + readinessProbe: + httpGet: + path: /readyz + port: 8081 + initialDelaySeconds: 5 + periodSeconds: 10 + securityContext: + allowPrivilegeEscalation: false + securityContext: + runAsNonRoot: true + serviceAccountName: memcached-operator-controller-manager + terminationGracePeriodSeconds: 10 + permissions: + - rules: + - apiGroups: + - "" + resources: + - configmaps + verbs: + - get + - list + - watch + - create + - update + - patch + - delete + - apiGroups: + - coordination.k8s.io + resources: + - leases + verbs: + - get + - list + - watch + - create + - update + - patch + - delete + - apiGroups: + - "" + resources: + - events + verbs: + - create + - patch + serviceAccountName: memcached-operator-controller-manager + strategy: deployment + installModes: + - supported: false + type: OwnNamespace + - supported: false + type: SingleNamespace + - supported: false + type: MultiNamespace + - supported: true + type: AllNamespaces + keywords: + - memcached-operator + links: + - name: Memcached Operator + url: https://memcached-operator.domain + maintainers: + - email: your@email.com + name: Maintainer Name + maturity: alpha + provider: + name: Provider Name + url: https://your.domain + version: 0.0.1 + webhookdefinitions: + - admissionReviewVersions: + - v1 + - v1beta1 + containerPort: 443 + deploymentName: memcached-operator-controller-manager + failurePolicy: Fail + generateName: vmemcached.kb.io + rules: + - apiGroups: + - cache.example.com + apiVersions: + - v1alpha1 + operations: + - CREATE + - UPDATE + resources: + - memcacheds + sideEffects: None + targetPort: 9443 + type: ValidatingAdmissionWebhook + webhookPath: /validate-cache-example-com-v1alpha1-memcached + - admissionReviewVersions: + - v1 + - v1beta1 + containerPort: 443 + deploymentName: memcached-operator-controller-manager + failurePolicy: Fail + generateName: mmemcached.kb.io + rules: + - apiGroups: + - cache.example.com + apiVersions: + - v1alpha1 + operations: + - CREATE + - UPDATE + resources: + - memcacheds + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate-cache-example-com-v1alpha1-memcached diff --git a/staging/api/pkg/validation/validation.go b/staging/api/pkg/validation/validation.go index d84a5ace77..1d87737fa2 100644 --- a/staging/api/pkg/validation/validation.go +++ b/staging/api/pkg/validation/validation.go @@ -48,6 +48,12 @@ var CommunityOperatorValidator = internal.CommunityOperatorValidator // AlphaDeprecatedAPIsValidator implements Validator to validate bundle objects // for API deprecation requirements. +// +// Note that this validator looks at the manifests. If any removed APIs for the mapped k8s versions are found, +// it raises a warning. +// +// This validator only raises an error when the deprecated API found is removed in the specified k8s +// version informed via the optional key `k8s-version`. var AlphaDeprecatedAPIsValidator = internal.AlphaDeprecatedAPIsValidator // GoodPracticesValidator implements Validator to validate the criteria defined as good practices diff --git a/staging/api/tools.go b/staging/api/tools.go index 3837fcb168..a3fba99c66 100644 --- a/staging/api/tools.go +++ b/staging/api/tools.go @@ -3,10 +3,6 @@ package tools import ( - // Generate deepcopy and conversion. - _ "sigs.k8s.io/controller-tools/cmd/controller-gen" - // Manipulate YAML. - _ "github.com/mikefarah/yq/v3" // Generate embedded files. _ "github.com/go-bindata/go-bindata/v3/go-bindata" ) diff --git a/staging/operator-lifecycle-manager/.github/ISSUE_TEMPLATE/flaky-test.md b/staging/operator-lifecycle-manager/.github/ISSUE_TEMPLATE/flaky-test.md new file mode 100644 index 0000000000..957741b3c6 --- /dev/null +++ b/staging/operator-lifecycle-manager/.github/ISSUE_TEMPLATE/flaky-test.md @@ -0,0 +1,23 @@ +--- +name: Flaky Test Report +about: If an unrelated test is failing for mysterious reasons +title: '' +labels: 'kind/flake' +assignees: '' + +--- + +## Flaky Test Report + + + +**Failure Log Link** +[Failure Log](put link here) +You can get the link by clicking on the line number in the job logs and copying the url from your browser. + +**Relevant Failure Log** + + diff --git a/staging/operator-lifecycle-manager/.github/PULL_REQUEST_TEMPLATE.md b/staging/operator-lifecycle-manager/.github/PULL_REQUEST_TEMPLATE.md index 5e3a619e36..50bae711f2 100644 --- a/staging/operator-lifecycle-manager/.github/PULL_REQUEST_TEMPLATE.md +++ b/staging/operator-lifecycle-manager/.github/PULL_REQUEST_TEMPLATE.md @@ -17,6 +17,8 @@ Note: Make sure your branch is rebased to the latest upstream master. - [ ] Sufficient end-to-end test coverage - [ ] Docs updated or added to `/doc` - [ ] Commit messages sensible and descriptive +- [ ] Tests marked as `[FLAKE]` are truly flaky +- [ ] Tests that remove the `[FLAKE]` tag are no longer flaky ..2021_12_15_02_01_11.729011450 + // |--> catalog.json + // |--> .indexignore + // |--> ..data -> ..2021_12_15_02_01_11.729011450 + // |--> catalog.json -> ..data/catalog.json + // |--> .indexignore -> ..data/.indexignore + // Adding '**/..*' to the .indexignore ensures the + // '..2021_12_15_02_01_11.729011450' and ' ..data' directories are ignored. + // Otherwise, opm will pick up on both catalog.json files and fail with a conflicts (duplicate packages) + ".indexignore": "**/\\.\\.*\n", + }, + } +} + +func (c *magicCatalog) makeCatalogSource() *operatorsv1alpha1.CatalogSource { + return &operatorsv1alpha1.CatalogSource{ + ObjectMeta: metav1.ObjectMeta{ + Name: c.name, + Namespace: c.namespace, + }, + Spec: operatorsv1alpha1.CatalogSourceSpec{ + SourceType: operatorsv1alpha1.SourceTypeGrpc, + Address: fmt.Sprintf("%s.%s.svc:50051", c.serviceName, c.namespace), + }, + } +} + +func (c *magicCatalog) makeCatalogSourcePod() *corev1.Pod { + + const ( + image = "quay.io/operator-framework/upstream-opm-builder" + readinessDelay int32 = 5 + livenessDelay int32 = 10 + volumeMountName string = "fbc-catalog" + ) + + readOnlyRootFilesystem := false + + return &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: c.podName, + Namespace: c.namespace, + Labels: c.makeCatalogSourcePodLabels(), + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "catalog", + Image: image, + Command: []string{"opm", "serve", catalogMountPath}, + Ports: []corev1.ContainerPort{ + { + Name: "grpc", + ContainerPort: 50051, + }, + }, + ReadinessProbe: &corev1.Probe{ + ProbeHandler: corev1.ProbeHandler{ + Exec: &corev1.ExecAction{ + Command: []string{"grpc_health_probe", "-addr=:50051"}, + }, + }, + InitialDelaySeconds: readinessDelay, + TimeoutSeconds: 5, + }, + LivenessProbe: &corev1.Probe{ + ProbeHandler: corev1.ProbeHandler{ + Exec: &corev1.ExecAction{ + Command: []string{"grpc_health_probe", "-addr=:50051"}, + }, + }, + InitialDelaySeconds: livenessDelay, + TimeoutSeconds: 5, + }, + Resources: corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("10m"), + corev1.ResourceMemory: resource.MustParse("50Mi"), + }, + }, + SecurityContext: &corev1.SecurityContext{ + ReadOnlyRootFilesystem: &readOnlyRootFilesystem, + }, + ImagePullPolicy: corev1.PullAlways, + TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError, + VolumeMounts: []corev1.VolumeMount{ + { + Name: volumeMountName, + MountPath: catalogMountPath, + ReadOnly: true, + }, + }, + }, + }, + Volumes: []corev1.Volume{ + { + Name: volumeMountName, + VolumeSource: corev1.VolumeSource{ + ConfigMap: &corev1.ConfigMapVolumeSource{ + LocalObjectReference: corev1.LocalObjectReference{ + Name: c.configMapName, + }, + }, + }, + }, + }, + }, + } +} + +func (c *magicCatalog) makeCatalogSourcePodLabels() map[string]string { + return map[string]string{ + olmCatalogLabel: c.name, + } +} diff --git a/staging/operator-lifecycle-manager/test/e2e/magic_catalog_test.go b/staging/operator-lifecycle-manager/test/e2e/magic_catalog_test.go new file mode 100644 index 0000000000..57b2d52e84 --- /dev/null +++ b/staging/operator-lifecycle-manager/test/e2e/magic_catalog_test.go @@ -0,0 +1,40 @@ +package e2e + +import ( + "context" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/operator-framework/operator-lifecycle-manager/test/e2e/ctx" + corev1 "k8s.io/api/core/v1" +) + +var _ = Describe("MagicCatalog", func() { + var ( + generatedNamespace corev1.Namespace + ) + + BeforeEach(func() { + generatedNamespace = SetupGeneratedTestNamespace(genName("magic-catalog-e2e-")) + }) + + AfterEach(func() { + TeardownNamespace(generatedNamespace.GetName()) + }) + + It("Deploys and Undeploys a File-based Catalog", func() { + // create dependencies + const catalogName = "test" + namespace := generatedNamespace.GetName() + kubeClient := ctx.Ctx().Client() + provider, err := NewFileBasedFiledBasedCatalogProvider("../test/e2e/testdata/fbc_catalog.json") + Expect(err).To(BeNil()) + + // create and deploy and undeploy the magic catalog + magicCatalog := NewMagicCatalog(kubeClient, namespace, catalogName, provider) + + // deployment blocks until the catalog source has reached a READY status + Expect(magicCatalog.DeployCatalog(context.TODO())).To(BeNil()) + Expect(magicCatalog.UndeployCatalog(context.TODO())).To(BeNil()) + }) +}) diff --git a/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go index 969779cee3..8954dacf0c 100644 --- a/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go @@ -292,7 +292,6 @@ var _ = Describe("Operator Group", func() { stopCh := make(chan struct{}) defer func() { stopCh <- struct{}{} - return }() for _, informer := range []cache.SharedIndexInformer{roleInformer.Informer(), roleBindingInformer.Informer(), clusterRoleInformer.Informer(), clusterRoleBindingInformer.Informer()} { @@ -1420,7 +1419,7 @@ var _ = Describe("Operator Group", func() { aCSV := newCSV(csvName, opGroupNamespace, "", semver.MustParse("0.0.0"), []apiextensions.CustomResourceDefinition{mainCRD}, nil, &namedStrategy) // Use the It spec name as label after stripping whitespaces - aCSV.Labels = map[string]string{"label": strings.Replace(CurrentGinkgoTestDescription().TestText, " ", "", -1)} + aCSV.Labels = map[string]string{"label": K8sSafeCurrentTestDescription()} createdCSV, err := crc.OperatorsV1alpha1().ClusterServiceVersions(opGroupNamespace).Create(context.TODO(), &aCSV, metav1.CreateOptions{}) require.NoError(GinkgoT(), err) @@ -1499,7 +1498,7 @@ var _ = Describe("Operator Group", func() { }) require.NoError(GinkgoT(), err) - csvList, err := crc.OperatorsV1alpha1().ClusterServiceVersions(corev1.NamespaceAll).List(context.TODO(), metav1.ListOptions{LabelSelector: fmt.Sprintf("label=%s", strings.Replace(CurrentGinkgoTestDescription().TestText, " ", "", -1))}) + csvList, err := crc.OperatorsV1alpha1().ClusterServiceVersions(corev1.NamespaceAll).List(context.TODO(), metav1.ListOptions{LabelSelector: fmt.Sprintf("label=%s", K8sSafeCurrentTestDescription())}) require.NoError(GinkgoT(), err) GinkgoT().Logf("Found CSV count of %v", len(csvList.Items)) GinkgoT().Logf("Create other namespace %s", otherNamespaceName) @@ -1796,7 +1795,8 @@ var _ = Describe("Operator Group", func() { // Versions of OLM at 0.14.1 and older had a bug that would place the wrong namespace annotation on copied CSVs, // preventing them from being GCd. This ensures that any leftover CSVs in that state are properly cleared up. - It("cleanup csvs with bad owner operator groups", func() { + // issue: https://github.com/operator-framework/operator-lifecycle-manager/issues/2644 + It("[FLAKE] cleanup csvs with bad owner operator groups", func() { c := newKubeClient() crc := newCRClient() @@ -1900,7 +1900,7 @@ var _ = Describe("Operator Group", func() { aCSV := newCSV(csvName, opGroupNamespace, "", semver.MustParse("0.0.0"), []apiextensions.CustomResourceDefinition{mainCRD}, nil, &namedStrategy) // Use the It spec name as label after stripping whitespaces - aCSV.Labels = map[string]string{"label": strings.Replace(CurrentGinkgoTestDescription().TestText, " ", "", -1)} + aCSV.Labels = map[string]string{"label": K8sSafeCurrentTestDescription()} createdCSV, err := crc.OperatorsV1alpha1().ClusterServiceVersions(opGroupNamespace).Create(context.TODO(), &aCSV, metav1.CreateOptions{}) require.NoError(GinkgoT(), err) @@ -1979,7 +1979,7 @@ var _ = Describe("Operator Group", func() { }) require.NoError(GinkgoT(), err) - csvList, err := crc.OperatorsV1alpha1().ClusterServiceVersions(corev1.NamespaceAll).List(context.TODO(), metav1.ListOptions{LabelSelector: fmt.Sprintf("label=%s", strings.Replace(CurrentGinkgoTestDescription().TestText, " ", "", -1))}) + csvList, err := crc.OperatorsV1alpha1().ClusterServiceVersions(corev1.NamespaceAll).List(context.TODO(), metav1.ListOptions{LabelSelector: fmt.Sprintf("label=%s", K8sSafeCurrentTestDescription())}) require.NoError(GinkgoT(), err) GinkgoT().Logf("Found CSV count of %v", len(csvList.Items)) GinkgoT().Logf("Create other namespace %s", otherNamespaceName) @@ -2289,7 +2289,8 @@ var _ = Describe("Operator Group", func() { Expect(err).ToNot(HaveOccurred()) }) - It("OLM applies labels to Namespaces that are associated with an OperatorGroup", func() { + // issue: https://github.com/operator-framework/operator-lifecycle-manager/issues/2637 + It("[FLAKE] OLM applies labels to Namespaces that are associated with an OperatorGroup", func() { ogLabel, err := getOGLabelKey(operatorGroup) Expect(err).ToNot(HaveOccurred()) @@ -2438,7 +2439,6 @@ func updateOperatorGroupSpecFunc(t GinkgoTInterface, crc versioned.Interface, na } func pollForNamespaceListCount(c operatorclient.ClientInterface, listOptions metav1.ListOptions, expectedLength int) (list *corev1.NamespaceList, err error) { - Eventually(func() (bool, error) { list, err = c.KubernetesInterface().CoreV1().Namespaces().List(context.TODO(), listOptions) if err != nil { diff --git a/staging/operator-lifecycle-manager/test/e2e/operator_test.go b/staging/operator-lifecycle-manager/test/e2e/operator_test.go index 341bcd97a4..faa5acac66 100644 --- a/staging/operator-lifecycle-manager/test/e2e/operator_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/operator_test.go @@ -70,7 +70,8 @@ var _ = Describe("Operator API", func() { // 14. Ensure the reference to ns-a is eventually removed from o's status.components.refs field // 15. Delete o // 16. Ensure o is not re-created - It("should surface components in its status", func() { + // issue: https://github.com/operator-framework/operator-lifecycle-manager/issues/2628 + It("[FLAKE] should surface components in its status", func() { o := &operatorsv1.Operator{} o.SetName(genName("o-")) @@ -454,7 +455,7 @@ func (matcher *copiedCSVRefMatcher) Match(actual interface{}) (success bool, err func (matcher *copiedCSVRefMatcher) FailureMessage(actual interface{}) (message string) { operator, ok := actual.(*operatorsv1.Operator) if !ok { - return fmt.Sprintf("copiedCSVRefMatcher matcher expects an *Operator") + return "copiedCSVRefMatcher matcher expects an *Operator" } return fmt.Sprintf("Expected\n\t%#v\nto contain copied CSVs in components\n\t%#v\n", operator, operator.Status.Components) } @@ -462,7 +463,7 @@ func (matcher *copiedCSVRefMatcher) FailureMessage(actual interface{}) (message func (matcher *copiedCSVRefMatcher) NegatedFailureMessage(actual interface{}) (message string) { operator, ok := actual.(*operatorsv1.Operator) if !ok { - return fmt.Sprintf("copiedCSVRefMatcher matcher expects an *Operator") + return "copiedCSVRefMatcher matcher expects an *Operator" } return fmt.Sprintf("Expected\n\t%#v\nto not contain copied CSVs in components\n\t%#v\n", operator, operator.Status.Components) } diff --git a/staging/operator-lifecycle-manager/test/e2e/packagemanifest_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/packagemanifest_e2e_test.go index 153a608612..1e7dcb13fb 100644 --- a/staging/operator-lifecycle-manager/test/e2e/packagemanifest_e2e_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/packagemanifest_e2e_test.go @@ -100,7 +100,7 @@ var _ = Describe("Package Manifest API lists available Operators from Catalog So csvAlpha = *csv.DeepCopy() csvAlpha.SetName(packageAlpha) - csvAlpha.Spec.Version = opver.OperatorVersion{semver.MustParse("0.1.1")} + csvAlpha.Spec.Version = opver.OperatorVersion{Version: semver.MustParse("0.1.1")} csvAlpha.Spec.Replaces = csv.GetName() csvAlpha.Spec.Icon = []v1alpha1.Icon{ { diff --git a/staging/operator-lifecycle-manager/test/e2e/split/integration_test.sh b/staging/operator-lifecycle-manager/test/e2e/split/integration_test.sh new file mode 100755 index 0000000000..c3b7115539 --- /dev/null +++ b/staging/operator-lifecycle-manager/test/e2e/split/integration_test.sh @@ -0,0 +1,14 @@ +#!/usr/bin/env bash + +function get_total_specs() { + go run github.com/onsi/ginkgo/ginkgo -noColor -dryRun -v -seed 1 "$@" ./test/e2e | grep -Po "Ran \K([0-9]+)(?= of .+ Specs in .+ seconds)" +} + +unfocused_specs=$(get_total_specs) +regexp=$(go run ./test/e2e/split/... -chunks 1 -print-chunk 0 ./test/e2e) +focused_specs=$(get_total_specs -focus "$regexp") + +if ! [ $unfocused_specs -eq $focused_specs ]; then + echo "expected number of unfocused specs $unfocused_specs to equal focus specs $focused_specs" + exit 1 +fi diff --git a/staging/operator-lifecycle-manager/test/e2e/split/main.go b/staging/operator-lifecycle-manager/test/e2e/split/main.go new file mode 100644 index 0000000000..30745d0cab --- /dev/null +++ b/staging/operator-lifecycle-manager/test/e2e/split/main.go @@ -0,0 +1,234 @@ +package main + +import ( + "flag" + "fmt" + "io" + "io/ioutil" + "log" + "math" + "os" + "path/filepath" + "regexp" + "sort" + "strings" + + "github.com/sirupsen/logrus" +) + +type options struct { + numChunks int + printChunk int + printDebug bool + writer io.Writer + logLevel string +} + +func main() { + opts := options{ + writer: os.Stdout, + } + flag.IntVar(&opts.numChunks, "chunks", 1, "Number of chunks to create focus regexps for") + flag.IntVar(&opts.printChunk, "print-chunk", 0, "Chunk to print a regexp for") + flag.BoolVar(&opts.printDebug, "print-debug", false, "Print all spec prefixes in non-regexp format. Use for debugging") + flag.StringVar(&opts.logLevel, "log-level", logrus.ErrorLevel.String(), "Configure the logging level") + flag.Parse() + + if opts.printChunk >= opts.numChunks { + exitIfErr(fmt.Errorf("the chunk to print (%d) must be a smaller number than the number of chunks (%d)", opts.printChunk, opts.numChunks)) + } + + dir := flag.Arg(0) + if dir == "" { + exitIfErr(fmt.Errorf("test directory required as the argument")) + } + + // Clean dir. + var err error + dir, err = filepath.Abs(dir) + exitIfErr(err) + wd, err := os.Getwd() + exitIfErr(err) + dir, err = filepath.Rel(wd, dir) + exitIfErr(err) + + exitIfErr(opts.run(dir)) +} + +func exitIfErr(err error) { + if err != nil { + log.Fatal(err) + } +} + +func (opts options) run(dir string) error { + level, err := logrus.ParseLevel(opts.logLevel) + if err != nil { + return fmt.Errorf("failed to parse the %s log level: %v", opts.logLevel, err) + } + logger := logrus.New() + logger.SetLevel(level) + + describes, err := findDescribes(logger, dir) + if err != nil { + return err + } + + // Find minimal prefixes for all spec strings so no spec runs are duplicated across chunks. + prefixes := findMinimalWordPrefixes(describes) + sort.Strings(prefixes) + + var out string + if opts.printDebug { + out = strings.Join(prefixes, "\n") + } else { + out, err = createChunkRegexp(opts.numChunks, opts.printChunk, prefixes) + if err != nil { + return err + } + } + + fmt.Fprint(opts.writer, out) + return nil +} + +// TODO: this is hacky because top-level tests may be defined elsewise. +// A better strategy would be to use the output of `ginkgo -noColor -dryRun` +// like https://github.com/operator-framework/operator-lifecycle-manager/pull/1476 does. +var topDescribeRE = regexp.MustCompile(`var _ = Describe\("(.+)", func\(.*`) + +func findDescribes(logger logrus.FieldLogger, dir string) ([]string, error) { + // Find all Ginkgo specs in dir's test files. + // These can be grouped independently. + describeTable := make(map[string]struct{}) + matches, err := filepath.Glob(filepath.Join(dir, "*_test.go")) + if err != nil { + return nil, err + } + for _, match := range matches { + b, err := ioutil.ReadFile(match) + if err != nil { + return nil, err + } + specNames := topDescribeRE.FindAllSubmatch(b, -1) + if len(specNames) == 0 { + logger.Warnf("%s: found no top level describes, skipping", match) + continue + } + for _, possibleNames := range specNames { + if len(possibleNames) != 2 { + logger.Debugf("%s: expected to find 2 submatch, found %d:", match, len(possibleNames)) + for _, name := range possibleNames { + logger.Debugf("\t%s\n", string(name)) + } + continue + } + describe := strings.TrimSpace(string(possibleNames[1])) + describeTable[describe] = struct{}{} + } + } + + describes := make([]string, len(describeTable)) + i := 0 + for describeKey := range describeTable { + describes[i] = describeKey + i++ + } + return describes, nil +} + +func createChunkRegexp(numChunks, printChunk int, specs []string) (string, error) { + numSpecs := len(specs) + if numSpecs < numChunks { + return "", fmt.Errorf("have more desired chunks (%d) than specs (%d)", numChunks, numSpecs) + } + + // Create chunks of size ceil(number of specs/number of chunks) in alphanumeric order. + // This is deterministic on inputs. + chunks := make([][]string, numChunks) + interval := int(math.Ceil(float64(numSpecs) / float64(numChunks))) + currIdx := 0 + for chunkIdx := 0; chunkIdx < numChunks; chunkIdx++ { + nextIdx := int(math.Min(float64(currIdx+interval), float64(numSpecs))) + chunks[chunkIdx] = specs[currIdx:nextIdx] + currIdx = nextIdx + } + + chunk := chunks[printChunk] + if len(chunk) == 0 { + // This is a panic because the caller may skip this error, resulting in missed test specs. + panic(fmt.Sprintf("bug: chunk %d has no elements", printChunk)) + } + + // Write out the regexp to focus chunk specs via `ginkgo -focus `. + var reStr string + if len(chunk) == 1 { + reStr = fmt.Sprintf("%s .*", chunk[0]) + } else { + sb := strings.Builder{} + sb.WriteString(chunk[0]) + for _, test := range chunk[1:] { + sb.WriteString("|") + sb.WriteString(test) + } + reStr = fmt.Sprintf("(%s) .*", sb.String()) + } + + return reStr, nil +} + +func findMinimalWordPrefixes(specs []string) (prefixes []string) { + // Create a word trie of all spec strings. + t := make(wordTrie) + for _, spec := range specs { + t.push(spec) + } + + // Now find the first branch point for each path in the trie by DFS. + for word, node := range t { + var prefixElements []string + next: + if word != "" { + prefixElements = append(prefixElements, word) + } + if len(node.children) == 1 { + for nextWord, nextNode := range node.children { + word, node = nextWord, nextNode + } + goto next + } + // TODO: this might need to be joined by "\s+" + // in case multiple spaces were used in the spec name. + prefixes = append(prefixes, strings.Join(prefixElements, " ")) + } + + return prefixes +} + +// wordTrie is a trie of word nodes, instead of individual characters. +type wordTrie map[string]*wordTrieNode + +type wordTrieNode struct { + word string + children map[string]*wordTrieNode +} + +// push creates s branch of the trie from each word in s. +func (t wordTrie) push(s string) { + split := strings.Split(s, " ") + + curr := &wordTrieNode{word: "", children: t} + for _, sp := range split { + if sp = strings.TrimSpace(sp); sp == "" { + continue + } + next, hasNext := curr.children[sp] + if !hasNext { + next = &wordTrieNode{word: sp, children: make(map[string]*wordTrieNode)} + curr.children[sp] = next + } + curr = next + } + // Add termination node so "foo" and "foo bar" have a branching point of "foo". + curr.children[""] = &wordTrieNode{} +} diff --git a/staging/operator-lifecycle-manager/test/e2e/split/main_test.go b/staging/operator-lifecycle-manager/test/e2e/split/main_test.go new file mode 100644 index 0000000000..ec2a5410fa --- /dev/null +++ b/staging/operator-lifecycle-manager/test/e2e/split/main_test.go @@ -0,0 +1,141 @@ +package main + +import ( + "os" + "os/exec" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestMain(t *testing.T) { + // This test makes sure that every spec gets run. + + cmd := exec.Command("./test/e2e/split/integration_test.sh") + cmd.Dir = "../../../" + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + err := cmd.Run() + require.NoError(t, err) +} + +func TestCreateChunkRegexp(t *testing.T) { + type spec struct { + name string + numChunks int + printChunk int + specs []string + expRE string + expError string + } + + cases := []spec{ + { + name: "singlePrefix1", + numChunks: 1, printChunk: 0, + specs: []string{"foo"}, + expRE: "foo .*", + }, + { + name: "multiplePrefixes1", + numChunks: 1, printChunk: 0, + specs: []string{"bar foo", "baz", "foo"}, + expRE: "(bar foo|baz|foo) .*", + }, + { + name: "multiplePrefixes2", + numChunks: 3, printChunk: 0, + specs: []string{"bar foo", "baz", "foo"}, + expRE: "bar foo .*", + }, + { + name: "multiplePrefixes3", + numChunks: 3, printChunk: 2, + specs: []string{"bar foo", "baz", "foo"}, + expRE: "foo .*", + }, + { + name: "empty", + numChunks: 1, printChunk: 0, + specs: nil, + expError: "have more desired chunks (1) than specs (0)", + }, + { + name: "singleSpecTooManyChunks", + numChunks: 2, printChunk: 1, + specs: []string{"foo"}, + expError: "have more desired chunks (2) than specs (1)", + }, + { + name: "multipleSpecTooManyChunks", + numChunks: 3, printChunk: 1, + specs: []string{"foo", "bar"}, + expError: "have more desired chunks (3) than specs (2)", + }, + } + + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + re, err := createChunkRegexp(c.numChunks, c.printChunk, c.specs) + if c.expError != "" { + require.EqualError(t, err, c.expError) + } else { + require.NoError(t, err) + require.Equal(t, c.expRE, re) + } + }) + } +} + +func TestFindMinimalWordPrefixes(t *testing.T) { + type spec struct { + name string + specs []string + expPrefixes []string + } + + cases := []spec{ + { + name: "empty", + specs: nil, + expPrefixes: nil, + }, + { + name: "singleSpec", + specs: []string{"foo"}, + expPrefixes: []string{"foo"}, + }, + { + name: "twoSpecsSingleWordPrefix", + specs: []string{"foo", "foo bar"}, + expPrefixes: []string{"foo"}, + }, + { + name: "twoMultiWordSpecsSingleWordPrefix", + specs: []string{"foo bar", "foo baz"}, + expPrefixes: []string{"foo"}, + }, + { + name: "twoMultiWordSpecsLongPrefix", + specs: []string{"foo bar", "foo bar baz"}, + expPrefixes: []string{"foo bar"}, + }, + { + name: "threeSpecsSingleWordPrefix", + specs: []string{"foo", "foo bar", "foo baz"}, + expPrefixes: []string{"foo"}, + }, + { + name: "multiplePrefixes", + specs: []string{"foo", "foo bar", "foo bar baz", "bar foo", "baz buf", "baz bar foo"}, + expPrefixes: []string{"foo", "bar foo", "baz"}, + }, + } + + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + prefixes := findMinimalWordPrefixes(c.specs) + require.ElementsMatch(t, c.expPrefixes, prefixes) + }) + } +} diff --git a/staging/operator-lifecycle-manager/test/e2e/subscription_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/subscription_e2e_test.go index 3d4f16f58f..3563a88eb6 100644 --- a/staging/operator-lifecycle-manager/test/e2e/subscription_e2e_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/subscription_e2e_test.go @@ -95,6 +95,8 @@ var _ = Describe("Subscription", func() { } _, teardown = createInternalCatalogSource(ctx.Ctx().KubeClient(), ctx.Ctx().OperatorClient(), "test-catalog", generatedNamespace.GetName(), packages, crds, csvs) + _, err := fetchCatalogSourceOnStatus(ctx.Ctx().OperatorClient(), "test-catalog", generatedNamespace.GetName(), catalogSourceRegistryPodSynced) + Expect(err).NotTo(HaveOccurred()) createSubscriptionForCatalog(ctx.Ctx().OperatorClient(), generatedNamespace.GetName(), "test-subscription", "test-catalog", "root", "channel-root", "", operatorsv1alpha1.ApprovalAutomatic) }) @@ -506,7 +508,8 @@ var _ = Describe("Subscription", func() { require.Len(GinkgoT(), ips.Items, 2) }) - It("updates multiple intermediates", func() { + // issue: https://github.com/operator-framework/operator-lifecycle-manager/issues/2635 + It("[FLAKE] updates multiple intermediates", func() { crd := newCRD("ins") @@ -1113,7 +1116,25 @@ var _ = Describe("Subscription", func() { // Wait for sub to have status condition SubscriptionInstallPlanPending true and reason Installing sub, err = fetchSubscription(crc, generatedNamespace.GetName(), subName, func(s *operatorsv1alpha1.Subscription) bool { cond := s.Status.GetCondition(operatorsv1alpha1.SubscriptionInstallPlanPending) - return cond.Status == corev1.ConditionTrue && cond.Reason == string(operatorsv1alpha1.InstallPlanPhaseInstalling) + isConditionPresent := cond.Status == corev1.ConditionTrue && cond.Reason == string(operatorsv1alpha1.InstallPlanPhaseInstalling) + + if isConditionPresent { + return true + } + + // Sometimes the transition from installing to complete can be so quick that the test does not capture + // the condition in the subscription before it is removed. To mitigate this, we check if the installplan + // has transitioned to complete and exit out the fetch subscription loop if so. + // This is a mitigation. We should probably fix this test appropriately. + // issue: https://github.com/operator-framework/operator-lifecycle-manager/issues/2667 + ip, err := crc.OperatorsV1alpha1().InstallPlans(generatedNamespace.GetName()).Get(context.TODO(), plan.Name, metav1.GetOptions{}) + if err != nil { + // retry on failure + return false + } + isInstallPlanComplete := ip.Status.Phase == operatorsv1alpha1.InstallPlanPhaseComplete + + return isInstallPlanComplete }) Expect(err).ToNot(HaveOccurred()) @@ -1313,14 +1334,18 @@ var _ = Describe("Subscription", func() { require.NoError(GinkgoT(), err) require.NotNil(GinkgoT(), subscription) - csv, err := fetchCSV(crClient, subscription.Status.CurrentCSV, generatedNamespace.GetName(), buildCSVConditionChecker(operatorsv1alpha1.CSVPhaseSucceeded)) - require.NoError(GinkgoT(), err) - proxyEnv := proxyEnvVarFunc(GinkgoT(), config) expected := podEnv expected = append(expected, proxyEnv...) - checkDeploymentWithPodConfiguration(GinkgoT(), kubeClient, csv, podConfig.Env, podConfig.Volumes, podConfig.VolumeMounts, podConfig.Tolerations, podConfig.Resources) + Eventually(func() error { + csv, err := fetchCSV(crClient, subscription.Status.CurrentCSV, generatedNamespace.GetName(), buildCSVConditionChecker(operatorsv1alpha1.CSVPhaseSucceeded)) + if err != nil { + return err + } + + return checkDeploymentWithPodConfiguration(kubeClient, csv, podConfig.Env, podConfig.Volumes, podConfig.VolumeMounts, podConfig.Tolerations, podConfig.Resources) + }).Should(Succeed()) }) It("creation with nodeSelector config", func() { @@ -2353,7 +2378,7 @@ var ( }, Spec: operatorsv1alpha1.ClusterServiceVersionSpec{ Replaces: "", - Version: version.OperatorVersion{semver.MustParse("0.1.0")}, + Version: version.OperatorVersion{Version: semver.MustParse("0.1.0")}, MinKubeVersion: "0.0.0", InstallModes: []operatorsv1alpha1.InstallMode{ { @@ -2383,7 +2408,7 @@ var ( }, Spec: operatorsv1alpha1.ClusterServiceVersionSpec{ Replaces: outdated, - Version: version.OperatorVersion{semver.MustParse("0.2.0")}, + Version: version.OperatorVersion{Version: semver.MustParse("0.2.0")}, MinKubeVersion: "0.0.0", InstallModes: []operatorsv1alpha1.InstallMode{ { @@ -2413,7 +2438,7 @@ var ( }, Spec: operatorsv1alpha1.ClusterServiceVersionSpec{ Replaces: stable, - Version: version.OperatorVersion{semver.MustParse("0.1.1")}, + Version: version.OperatorVersion{Version: semver.MustParse("0.1.1")}, InstallModes: []operatorsv1alpha1.InstallMode{ { Type: operatorsv1alpha1.InstallModeTypeOwnNamespace, @@ -2442,7 +2467,7 @@ var ( }, Spec: operatorsv1alpha1.ClusterServiceVersionSpec{ Replaces: beta, - Version: version.OperatorVersion{semver.MustParse("0.3.0")}, + Version: version.OperatorVersion{Version: semver.MustParse("0.3.0")}, InstallModes: []operatorsv1alpha1.InstallMode{ { Type: operatorsv1alpha1.InstallModeTypeOwnNamespace, @@ -2534,7 +2559,6 @@ func init() { } func initCatalog(t GinkgoTInterface, namespace string, c operatorclient.ClientInterface, crc versioned.Interface) error { - dummyCatalogConfigMap.SetNamespace(namespace) if _, err := c.KubernetesInterface().CoreV1().ConfigMaps(namespace).Create(context.Background(), dummyCatalogConfigMap, metav1.CreateOptions{}); err != nil { if k8serrors.IsAlreadyExists(err) { @@ -2638,9 +2662,7 @@ func fetchSubscription(crc versioned.Interface, namespace, name string, checker func buildSubscriptionCleanupFunc(crc versioned.Interface, subscription *operatorsv1alpha1.Subscription) cleanupFunc { return func() { - if installPlanRef := subscription.Status.InstallPlanRef; installPlanRef != nil { - installPlan, err := crc.OperatorsV1alpha1().InstallPlans(subscription.GetNamespace()).Get(context.Background(), installPlanRef.Name, metav1.GetOptions{}) if err == nil { buildInstallPlanCleanupFunc(crc, subscription.GetNamespace(), installPlan)() @@ -2746,14 +2768,14 @@ func checkDeploymentHasPodConfigNodeSelector(t GinkgoTInterface, client operator return nil } -func checkDeploymentWithPodConfiguration(t GinkgoTInterface, client operatorclient.ClientInterface, csv *operatorsv1alpha1.ClusterServiceVersion, envVar []corev1.EnvVar, volumes []corev1.Volume, volumeMounts []corev1.VolumeMount, tolerations []corev1.Toleration, resources *corev1.ResourceRequirements) { +func checkDeploymentWithPodConfiguration(client operatorclient.ClientInterface, csv *operatorsv1alpha1.ClusterServiceVersion, envVar []corev1.EnvVar, volumes []corev1.Volume, volumeMounts []corev1.VolumeMount, tolerations []corev1.Toleration, resources *corev1.ResourceRequirements) error { resolver := install.StrategyResolver{} strategy, err := resolver.UnmarshalStrategy(csv.Spec.InstallStrategy) - require.NoError(t, err) + Expect(err).NotTo(HaveOccurred()) strategyDetailsDeployment, ok := strategy.(*operatorsv1alpha1.StrategyDetailsDeployment) - require.Truef(t, ok, "could not cast install strategy as type %T", strategyDetailsDeployment) + Expect(ok).To(BeTrue(), "could not cast install strategy as type %T", strategyDetailsDeployment) findEnvVar := func(envVar []corev1.EnvVar, name string) (foundEnvVar *corev1.EnvVar, found bool) { for i := range envVar { @@ -2816,48 +2838,58 @@ func checkDeploymentWithPodConfiguration(t GinkgoTInterface, client operatorclie return } - check := func(container *corev1.Container) { + check := func(container *corev1.Container) error { for _, e := range envVar { existing, found := findEnvVar(container.Env, e.Name) - require.Truef(t, found, "env variable name=%s not injected", e.Name) - require.NotNil(t, existing) - require.Equalf(t, e.Value, existing.Value, "env variable value does not match %s=%s", e.Name, e.Value) + if !found || existing == nil { + return fmt.Errorf("env variable name=%s not injected", e.Name) + } + Expect(e.Value).Should(Equal(existing.Value), "env variable value does not match %s=%s", e.Name, e.Value) } for _, v := range volumeMounts { existing, found := findVolumeMount(container.VolumeMounts, v.Name) - require.Truef(t, found, "VolumeMount name=%s not injected", v.Name) - require.NotNil(t, existing) - require.Equalf(t, v.MountPath, existing.MountPath, "VolumeMount MountPath does not match %s=%s", v.Name, v.MountPath) + if !found || existing == nil { + return fmt.Errorf("VolumeMount name=%s not injected", v.Name) + } + Expect(v.MountPath).Should(Equal(existing.MountPath), "VolumeMount MountPath does not match %s=%s", v.Name, v.MountPath) } existing, found := findResources(&container.Resources, resources) - require.Truef(t, found, "Resources not injected. Resource=%v", resources) - require.NotNil(t, existing) - require.Equalf(t, existing, resources, "Resource=%v does not match expected Resource=%v", existing, resources) + if !found || existing == nil { + return fmt.Errorf("Resources not injected. Resource=%v", resources) + } + Expect(existing).Should(Equal(resources), "Resource=%v does not match expected Resource=%v", existing, resources) + return nil } for _, deploymentSpec := range strategyDetailsDeployment.DeploymentSpecs { deployment, err := client.KubernetesInterface().AppsV1().Deployments(csv.GetNamespace()).Get(context.Background(), deploymentSpec.Name, metav1.GetOptions{}) - require.NoError(t, err) + Expect(err).NotTo(HaveOccurred()) for _, v := range volumes { existing, found := findVolume(deployment.Spec.Template.Spec.Volumes, v.Name) - require.Truef(t, found, "Volume name=%s not injected", v.Name) - require.NotNil(t, existing) - require.Equalf(t, v.ConfigMap.LocalObjectReference.Name, existing.ConfigMap.LocalObjectReference.Name, "volume ConfigMap Names does not match %s=%s", v.Name, v.ConfigMap.LocalObjectReference.Name) + if !found || existing == nil { + return fmt.Errorf("Volume name=%s not injected", v.Name) + } + Expect(v.ConfigMap.LocalObjectReference.Name).Should(Equal(existing.ConfigMap.LocalObjectReference.Name), "volume ConfigMap Names does not match %s=%s", v.Name, v.ConfigMap.LocalObjectReference.Name) } for _, toleration := range tolerations { existing, found := findTolerations(deployment.Spec.Template.Spec.Tolerations, toleration) - require.Truef(t, found, "Toleration not injected. Toleration=%v", toleration) - require.NotNil(t, existing) - require.Equalf(t, *existing, toleration, "Toleration=%v does not match expected Toleration=%v", existing, toleration) + if !found || existing == nil { + return fmt.Errorf("Toleration not injected. Toleration=%v", toleration) + } + Expect(*existing).Should(Equal(toleration), "Toleration=%v does not match expected Toleration=%v", existing, toleration) } for i := range deployment.Spec.Template.Spec.Containers { - check(&deployment.Spec.Template.Spec.Containers[i]) + err = check(&deployment.Spec.Template.Spec.Containers[i]) + if err != nil { + return err + } } } + return nil } func updateInternalCatalog(t GinkgoTInterface, c operatorclient.ClientInterface, crc versioned.Interface, catalogSourceName, namespace string, crds []apiextensions.CustomResourceDefinition, csvs []operatorsv1alpha1.ClusterServiceVersion, packages []registry.PackageManifest) { @@ -2897,7 +2929,7 @@ func updateInternalCatalog(t GinkgoTInterface, c operatorclient.ClientInterface, before := fetchedInitialCatalog.Status.ConfigMapResource after := catalog.Status.ConfigMapResource if after != nil && after.LastUpdateTime.After(before.LastUpdateTime.Time) && after.ResourceVersion != before.ResourceVersion && - catalog.Status.GRPCConnectionState.LastConnectTime.After(after.LastUpdateTime.Time) && catalog.Status.GRPCConnectionState.LastObservedState == "READY" { + catalog.Status.GRPCConnectionState.LastConnectTime.After(after.LastUpdateTime.Time) && (catalog.Status.GRPCConnectionState.LastObservedState == "READY" || catalog.Status.GRPCConnectionState.LastObservedState == "IDLE") { fmt.Println("catalog updated") return true } diff --git a/staging/operator-lifecycle-manager/test/e2e/testdata/fbc_catalog.json b/staging/operator-lifecycle-manager/test/e2e/testdata/fbc_catalog.json new file mode 100644 index 0000000000..c6c7ee6815 --- /dev/null +++ b/staging/operator-lifecycle-manager/test/e2e/testdata/fbc_catalog.json @@ -0,0 +1,38 @@ +{ + "schema": "olm.package", + "name": "packageA", + "defaultChannel": "stable" +} +{ + "schema": "olm.channel", + "name": "stable", + "package": "packageA", + "entries": [ + { + "name": "packageA.v1.0.0" + } + ] +} +{ + "schema": "olm.bundle", + "name": "packageA.v1.0.0", + "package": "packageA", + "image": "packageA:v1.0.0", + "properties": [ + { + "type": "olm.gvk", + "value": { + "group": "example.com", + "kind": "TestA", + "version": "v1alpha1" + } + }, + { + "type": "olm.package", + "value": { + "packageName": "packageA", + "version": "1.0.0" + } + } + ] +} \ No newline at end of file diff --git a/staging/operator-lifecycle-manager/test/e2e/util_test.go b/staging/operator-lifecycle-manager/test/e2e/util.go similarity index 89% rename from staging/operator-lifecycle-manager/test/e2e/util_test.go rename to staging/operator-lifecycle-manager/test/e2e/util.go index 88f7a03788..fb46cdde5c 100644 --- a/staging/operator-lifecycle-manager/test/e2e/util_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/util.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "fmt" + "regexp" "strings" "time" @@ -57,7 +58,8 @@ const ( ) var ( - genName = names.SimpleNameGenerator.GenerateName + genName = names.SimpleNameGenerator.GenerateName + nonAlphaNumericRegexp = regexp.MustCompile(`[^a-zA-Z0-9]`) ) // newKubeClient configures a client to talk to the cluster defined by KUBECONFIG @@ -77,6 +79,15 @@ func newPMClient() pmversioned.Interface { return ctx.Ctx().PackageClient() } +type cleanupFunc func() + +// waitFor wraps wait.Pool with default polling parameters +func waitFor(fn func() (bool, error)) error { + return wait.Poll(pollInterval, pollDuration, func() (bool, error) { + return fn() + }) +} + // awaitPods waits for a set of pods to exist in the cluster func awaitPods(t GinkgoTInterface, c operatorclient.ClientInterface, namespace, selector string, checkPods podsCheckFunc) (*corev1.PodList, error) { var fetchedPodList *corev1.PodList @@ -198,8 +209,7 @@ func awaitPod(t GinkgoTInterface, c operatorclient.ClientInterface, namespace, n } func awaitAnnotations(t GinkgoTInterface, query func() (metav1.ObjectMeta, error), expected map[string]string) error { - var err error - err = wait.Poll(pollInterval, pollDuration, func() (bool, error) { + err := wait.Poll(pollInterval, pollDuration, func() (bool, error) { t.Logf("Waiting for annotations to match %v", expected) obj, err := query() if err != nil && !apierrors.IsNotFound(err) { @@ -227,8 +237,7 @@ func awaitAnnotations(t GinkgoTInterface, query func() (metav1.ObjectMeta, error type checkResourceFunc func() error func waitForDelete(checkResource checkResourceFunc) error { - var err error - err = wait.Poll(pollInterval, pollDuration, func() (bool, error) { + err := wait.Poll(pollInterval, pollDuration, func() (bool, error) { err := checkResource() if apierrors.IsNotFound(err) { return true, nil @@ -243,8 +252,7 @@ func waitForDelete(checkResource checkResourceFunc) error { } func waitForEmptyList(checkList func() (int, error)) error { - var err error - err = wait.Poll(pollInterval, pollDuration, func() (bool, error) { + err := wait.Poll(pollInterval, pollDuration, func() (bool, error) { count, err := checkList() if err != nil { return false, err @@ -303,7 +311,7 @@ func registryPodHealthy(address string) bool { func catalogSourceRegistryPodSynced(catalog *operatorsv1alpha1.CatalogSource) bool { registry := catalog.Status.RegistryServiceStatus connState := catalog.Status.GRPCConnectionState - if registry != nil && connState != nil && !connState.LastConnectTime.IsZero() && connState.LastObservedState == "READY" { + if registry != nil && connState != nil && !connState.LastConnectTime.IsZero() && (connState.LastObservedState == "READY" || connState.LastObservedState == "IDLE") { fmt.Printf("catalog %s pod with address %s\n", catalog.GetName(), registry.Address()) return registryPodHealthy(registry.Address()) } @@ -385,6 +393,7 @@ func TearDown(namespace string) { var ( clientCtx = context.Background() client = ctx.Ctx().Client() + dynamic = ctx.Ctx().DynamicClient() inNamespace = k8scontrollerclient.InNamespace(namespace) logf = ctx.Ctx().Logf ) @@ -397,14 +406,13 @@ func TearDown(namespace string) { return client.DeleteAllOf(clientCtx, &operatorsv1alpha1.Subscription{}, inNamespace) }).Should(Succeed(), "failed to delete test subscriptions") - Eventually(func() (remaining []operatorsv1alpha1.Subscription, err error) { - list := &operatorsv1alpha1.SubscriptionList{} - err = client.List(clientCtx, list, inNamespace) - if list != nil { - remaining = list.Items + var subscriptiongvr = schema.GroupVersionResource{Group: "operators.coreos.com", Version: "v1alpha1", Resource: "subscriptions"} + Eventually(func() ([]unstructured.Unstructured, error) { + list, err := dynamic.Resource(subscriptiongvr).Namespace(namespace).List(context.Background(), metav1.ListOptions{}) + if err != nil { + return nil, err } - - return + return list.Items, nil }).Should(BeEmpty(), "failed to await deletion of test subscriptions") logf("deleting test installplans...") @@ -499,6 +507,18 @@ func buildCatalogSourceCleanupFunc(crc versioned.Interface, namespace string, ca ctx.Ctx().Logf("Deleting catalog source %s...", catalogSource.GetName()) err := crc.OperatorsV1alpha1().CatalogSources(namespace).Delete(context.Background(), catalogSource.GetName(), metav1.DeleteOptions{}) Expect(err).ToNot(HaveOccurred()) + + Eventually(func() (bool, error) { + fetched, err := newKubeClient().KubernetesInterface().CoreV1().Pods(catalogSource.GetNamespace()).List(context.Background(), metav1.ListOptions{LabelSelector: "olm.catalogSource=" + catalogSource.GetName()}) + if err != nil { + return false, err + } + if len(fetched.Items) == 0 { + return true, nil + } + ctx.Ctx().Logf("waiting for the catalog source %s pod to be deleted...", fetched.Items[0].GetName()) + return false, nil + }).Should(BeTrue()) } } @@ -518,7 +538,6 @@ func buildServiceAccountCleanupFunc(t GinkgoTInterface, c operatorclient.ClientI } func createInvalidGRPCCatalogSource(crc versioned.Interface, name, namespace string) (*operatorsv1alpha1.CatalogSource, cleanupFunc) { - catalogSource := &operatorsv1alpha1.CatalogSource{ TypeMeta: metav1.TypeMeta{ Kind: operatorsv1alpha1.CatalogSourceKind, @@ -541,7 +560,15 @@ func createInvalidGRPCCatalogSource(crc versioned.Interface, name, namespace str return catalogSource, buildCatalogSourceCleanupFunc(crc, namespace, catalogSource) } -func createInternalCatalogSource(c operatorclient.ClientInterface, crc versioned.Interface, name, namespace string, manifests []registry.PackageManifest, crds []apiextensions.CustomResourceDefinition, csvs []operatorsv1alpha1.ClusterServiceVersion) (*operatorsv1alpha1.CatalogSource, cleanupFunc) { +func createInternalCatalogSource( + c operatorclient.ClientInterface, + crc versioned.Interface, + name, + namespace string, + manifests []registry.PackageManifest, + crds []apiextensions.CustomResourceDefinition, + csvs []operatorsv1alpha1.ClusterServiceVersion, +) (*operatorsv1alpha1.CatalogSource, cleanupFunc) { configMap, configMapCleanup := createConfigMapForCatalogData(c, name, namespace, manifests, crds, csvs) // Create an internal CatalogSource custom resource pointing to the ConfigMap @@ -574,10 +601,15 @@ func createInternalCatalogSource(c operatorclient.ClientInterface, crc versioned return catalogSource, cleanupInternalCatalogSource } -func createInternalCatalogSourceWithPriority(c operatorclient.ClientInterface, crc versioned.Interface, name, - namespace string, manifests []registry.PackageManifest, crds []apiextensions.CustomResourceDefinition, - csvs []operatorsv1alpha1.ClusterServiceVersion, priority int) (*operatorsv1alpha1.CatalogSource, cleanupFunc) { - +func createInternalCatalogSourceWithPriority(c operatorclient.ClientInterface, + crc versioned.Interface, + name, + namespace string, + manifests []registry.PackageManifest, + crds []apiextensions.CustomResourceDefinition, + csvs []operatorsv1alpha1.ClusterServiceVersion, + priority int, +) (*operatorsv1alpha1.CatalogSource, cleanupFunc) { configMap, configMapCleanup := createConfigMapForCatalogData(c, name, namespace, manifests, crds, csvs) // Create an internal CatalogSource custom resource pointing to the ConfigMap catalogSource := &operatorsv1alpha1.CatalogSource{ @@ -611,7 +643,16 @@ func createInternalCatalogSourceWithPriority(c operatorclient.ClientInterface, c return catalogSource, cleanupInternalCatalogSource } -func createV1CRDInternalCatalogSource(t GinkgoTInterface, c operatorclient.ClientInterface, crc versioned.Interface, name, namespace string, manifests []registry.PackageManifest, crds []apiextensionsv1.CustomResourceDefinition, csvs []operatorsv1alpha1.ClusterServiceVersion) (*operatorsv1alpha1.CatalogSource, cleanupFunc) { +func createV1CRDInternalCatalogSource( + t GinkgoTInterface, + c operatorclient.ClientInterface, + crc versioned.Interface, + name, + namespace string, + manifests []registry.PackageManifest, + crds []apiextensionsv1.CustomResourceDefinition, + csvs []operatorsv1alpha1.ClusterServiceVersion, +) (*operatorsv1alpha1.CatalogSource, cleanupFunc) { configMap, configMapCleanup := createV1CRDConfigMapForCatalogData(t, c, name, namespace, manifests, crds, csvs) // Create an internal CatalogSource custom resource pointing to the ConfigMap @@ -645,7 +686,14 @@ func createV1CRDInternalCatalogSource(t GinkgoTInterface, c operatorclient.Clien return catalogSource, cleanupInternalCatalogSource } -func createConfigMapForCatalogData(c operatorclient.ClientInterface, name, namespace string, manifests []registry.PackageManifest, crds []apiextensions.CustomResourceDefinition, csvs []operatorsv1alpha1.ClusterServiceVersion) (*corev1.ConfigMap, cleanupFunc) { +func createConfigMapForCatalogData( + c operatorclient.ClientInterface, + name, + namespace string, + manifests []registry.PackageManifest, + crds []apiextensions.CustomResourceDefinition, + csvs []operatorsv1alpha1.ClusterServiceVersion, +) (*corev1.ConfigMap, cleanupFunc) { // Create a config map containing the PackageManifests and CSVs configMapName := fmt.Sprintf("%s-configmap", name) catalogConfigMap := &corev1.ConfigMap{ @@ -692,7 +740,15 @@ func createConfigMapForCatalogData(c operatorclient.ClientInterface, name, names return createdConfigMap, buildConfigMapCleanupFunc(c, namespace, createdConfigMap) } -func createV1CRDConfigMapForCatalogData(t GinkgoTInterface, c operatorclient.ClientInterface, name, namespace string, manifests []registry.PackageManifest, crds []apiextensionsv1.CustomResourceDefinition, csvs []operatorsv1alpha1.ClusterServiceVersion) (*corev1.ConfigMap, cleanupFunc) { +func createV1CRDConfigMapForCatalogData( + t GinkgoTInterface, + c operatorclient.ClientInterface, + name, + namespace string, + manifests []registry.PackageManifest, + crds []apiextensionsv1.CustomResourceDefinition, + csvs []operatorsv1alpha1.ClusterServiceVersion, +) (*corev1.ConfigMap, cleanupFunc) { // Create a config map containing the PackageManifests and CSVs configMapName := fmt.Sprintf("%s-configmap", name) catalogConfigMap := &corev1.ConfigMap{ @@ -909,7 +965,7 @@ func HaveMessage(goal string) gtypes.GomegaMatcher { }, ContainSubstring(goal)) } -func SetupGeneratedTestNamespace(name string) corev1.Namespace { +func SetupGeneratedTestNamespaceWithOperatorGroup(name string, og operatorsv1.OperatorGroup) corev1.Namespace { ns := corev1.Namespace{ ObjectMeta: metav1.ObjectMeta{ Name: name, @@ -919,15 +975,6 @@ func SetupGeneratedTestNamespace(name string) corev1.Namespace { return ctx.Ctx().Client().Create(context.Background(), &ns) }).Should(Succeed()) - og := operatorsv1.OperatorGroup{ - ObjectMeta: metav1.ObjectMeta{ - Name: fmt.Sprintf("%s-operatorgroup", ns.GetName()), - Namespace: ns.GetName(), - }, - Spec: operatorsv1.OperatorGroupSpec{ - TargetNamespaces: []string{ns.GetName()}, - }, - } Eventually(func() error { return ctx.Ctx().Client().Create(context.Background(), &og) }).Should(Succeed()) @@ -937,6 +984,20 @@ func SetupGeneratedTestNamespace(name string) corev1.Namespace { return ns } +func SetupGeneratedTestNamespace(name string) corev1.Namespace { + og := operatorsv1.OperatorGroup{ + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("%s-operatorgroup", name), + Namespace: name, + }, + Spec: operatorsv1.OperatorGroupSpec{ + TargetNamespaces: []string{name}, + }, + } + + return SetupGeneratedTestNamespaceWithOperatorGroup(name, og) +} + func TeardownNamespace(ns string) { log := ctx.Ctx().Logf @@ -971,3 +1032,7 @@ func inKind(client operatorclient.ClientInterface) (bool, error) { } return false, nil } + +func K8sSafeCurrentTestDescription() string { + return nonAlphaNumericRegexp.ReplaceAllString(CurrentGinkgoTestDescription().TestText, "") +} diff --git a/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go index d746117af7..125dd1a79a 100644 --- a/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go @@ -171,11 +171,7 @@ var _ = Describe("CSVs with a Webhook", func() { // Current Webhook should exist _, err = getWebhookWithGenerateName(c, changedGenerateName) - if err != nil { - return false - } - - return true + return err == nil }, time.Minute, 5*time.Second).Should(BeTrue()) }) It("Reuses existing valid certs", func() { @@ -212,10 +208,7 @@ var _ = Describe("CSVs with a Webhook", func() { fetchedCSV.Status.Phase = operatorsv1alpha1.CSVPhasePending _, err = crc.OperatorsV1alpha1().ClusterServiceVersions(namespace.GetName()).UpdateStatus(context.TODO(), fetchedCSV, metav1.UpdateOptions{}) - if err != nil { - return false - } - return true + return err == nil }).Should(BeTrue(), "Unable to set CSV phase to Pending") // Wait for webhook-operator to succeed @@ -259,7 +252,7 @@ var _ = Describe("CSVs with a Webhook", func() { AdmissionReviewVersions: []string{"v1beta1", "v1"}, SideEffects: &sideEffect, Rules: []admissionregistrationv1.RuleWithOperations{ - admissionregistrationv1.RuleWithOperations{ + { Operations: []admissionregistrationv1.OperationType{}, Rule: admissionregistrationv1.Rule{ APIGroups: []string{"*"}, @@ -278,7 +271,7 @@ var _ = Describe("CSVs with a Webhook", func() { failedCSV, err := fetchCSV(crc, csv.Name, namespace.Name, csvFailedChecker) Expect(err).Should(BeNil()) - Expect(failedCSV.Status.Message).Should(Equal("Webhook rules cannot include all groups")) + Expect(failedCSV.Status.Message).Should(Equal("webhook rules cannot include all groups")) }) It("Fails if the webhook intercepts OLM resources", func() { sideEffect := admissionregistrationv1.SideEffectClassNone @@ -290,7 +283,7 @@ var _ = Describe("CSVs with a Webhook", func() { AdmissionReviewVersions: []string{"v1beta1", "v1"}, SideEffects: &sideEffect, Rules: []admissionregistrationv1.RuleWithOperations{ - admissionregistrationv1.RuleWithOperations{ + { Operations: []admissionregistrationv1.OperationType{}, Rule: admissionregistrationv1.Rule{ APIGroups: []string{"operators.coreos.com"}, @@ -309,7 +302,7 @@ var _ = Describe("CSVs with a Webhook", func() { failedCSV, err := fetchCSV(crc, csv.Name, namespace.Name, csvFailedChecker) Expect(err).Should(BeNil()) - Expect(failedCSV.Status.Message).Should(Equal("Webhook rules cannot include the OLM group")) + Expect(failedCSV.Status.Message).Should(Equal("webhook rules cannot include the OLM group")) }) It("Fails if webhook intercepts Admission Webhook resources", func() { sideEffect := admissionregistrationv1.SideEffectClassNone @@ -321,7 +314,7 @@ var _ = Describe("CSVs with a Webhook", func() { AdmissionReviewVersions: []string{"v1beta1", "v1"}, SideEffects: &sideEffect, Rules: []admissionregistrationv1.RuleWithOperations{ - admissionregistrationv1.RuleWithOperations{ + { Operations: []admissionregistrationv1.OperationType{}, Rule: admissionregistrationv1.Rule{ APIGroups: []string{"admissionregistration.k8s.io"}, @@ -340,7 +333,7 @@ var _ = Describe("CSVs with a Webhook", func() { failedCSV, err := fetchCSV(crc, csv.Name, namespace.Name, csvFailedChecker) Expect(err).Should(BeNil()) - Expect(failedCSV.Status.Message).Should(Equal("Webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources")) + Expect(failedCSV.Status.Message).Should(Equal("webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources")) }) It("Succeeds if the webhook intercepts non Admission Webhook resources in admissionregistration group", func() { sideEffect := admissionregistrationv1.SideEffectClassNone @@ -352,7 +345,7 @@ var _ = Describe("CSVs with a Webhook", func() { AdmissionReviewVersions: []string{"v1beta1", "v1"}, SideEffects: &sideEffect, Rules: []admissionregistrationv1.RuleWithOperations{ - admissionregistrationv1.RuleWithOperations{ + { Operations: []admissionregistrationv1.OperationType{ admissionregistrationv1.OperationAll, }, @@ -384,7 +377,7 @@ var _ = Describe("CSVs with a Webhook", func() { AdmissionReviewVersions: []string{"v1beta1", "v1"}, SideEffects: &sideEffect, Rules: []admissionregistrationv1.RuleWithOperations{ - admissionregistrationv1.RuleWithOperations{ + { Operations: []admissionregistrationv1.OperationType{ admissionregistrationv1.OperationAll, }, @@ -441,7 +434,8 @@ var _ = Describe("CSVs with a Webhook", func() { return false, nil }).Should(BeTrue()) }) - It("Is updated when the CAs expire", func() { + // issue: https://github.com/operator-framework/operator-lifecycle-manager/issues/2629 + It("[FLAKE] Is updated when the CAs expire", func() { sideEffect := admissionregistrationv1.SideEffectClassNone webhook := operatorsv1alpha1.WebhookDescription{ GenerateName: webhookName, diff --git a/staging/operator-lifecycle-manager/util/cpb/main.go b/staging/operator-lifecycle-manager/util/cpb/main.go index f0bfbbe80a..ae9912bf97 100644 --- a/staging/operator-lifecycle-manager/util/cpb/main.go +++ b/staging/operator-lifecycle-manager/util/cpb/main.go @@ -84,6 +84,13 @@ func getMetadata() (m *metadata, err error) { manifestDir: "/manifests", } + // Exclude device filesystems and pseudo filesystems from filesystems looking for metadata + excludeDir := []string{ + "/dev", + "/proc", + "/sys", + } + // Traverse the filesystem looking for metadata err = filepath.Walk(".", func(path string, info os.FileInfo, err error) error { if err != nil { @@ -91,7 +98,18 @@ func getMetadata() (m *metadata, err error) { return nil } if info.IsDir() { - fmt.Printf("skipping a dir without errors: %+v \n", info.Name()) + absPath, err := filepath.Abs(path) + if err != nil { + fmt.Printf("couldn't get the absolute path %q: %v\n", path, err) + return nil + } + for _, v := range excludeDir { + if v == absPath { + fmt.Printf("skipping all files in the dir: %+v \n", absPath) + return filepath.SkipDir + } + } + fmt.Printf("skipping a dir without errors: %+v \n", absPath) return nil } if info.Name() != bundle.AnnotationsFile { diff --git a/staging/operator-registry/.github/workflows/build.yaml b/staging/operator-registry/.github/workflows/build.yaml index c6328b4516..4bf2ee35dd 100644 --- a/staging/operator-registry/.github/workflows/build.yaml +++ b/staging/operator-registry/.github/workflows/build.yaml @@ -15,5 +15,5 @@ jobs: - uses: actions/checkout@v2 - uses: actions/setup-go@v2 with: - go-version: '~1.16' + go-version: '~1.17' - run: make build diff --git a/staging/operator-registry/.github/workflows/go-apidiff.yaml b/staging/operator-registry/.github/workflows/go-apidiff.yaml index 37a64fe0d9..15dac64a52 100644 --- a/staging/operator-registry/.github/workflows/go-apidiff.yaml +++ b/staging/operator-registry/.github/workflows/go-apidiff.yaml @@ -17,7 +17,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v2 with: - go-version: '~1.16' + go-version: '~1.17' id: go - name: Check out code into the Go module directory uses: actions/checkout@v2 diff --git a/staging/operator-registry/.github/workflows/goreleaser.yaml b/staging/operator-registry/.github/workflows/goreleaser.yaml index 974baaf82b..b1e4592add 100644 --- a/staging/operator-registry/.github/workflows/goreleaser.yaml +++ b/staging/operator-registry/.github/workflows/goreleaser.yaml @@ -10,62 +10,107 @@ defaults: run: shell: bash jobs: - goreleaser: + release: + needs: + - build-windows + - build-darwin + - build-linux + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/download-artifact@v2 + + - run: | + for dist in dist-*; do + tar -C "${dist}" -xf "${dist}/${dist}.tar" + done + + - name: Create assets + run: | + set -xe + mkdir -p assets + cat dist-*/dist/checksums.txt > assets/checksums.txt + for asset in dist-*/dist/*_*/*; do + base=$(basename "${asset}") + variant=$(basename $(dirname "${asset}") | cut -d_ -f1) + cp "${asset}" "assets/${variant}-${base}" + done + find assets -ls + cat assets/checksums.txt + + - name: Upload Release Assets + if: github.ref_type == 'tag' + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: gh release create "${{ github.ref_name }}" --generate-notes ./assets/* + + build-windows: + runs-on: windows-latest steps: - uses: actions/checkout@v2 with: - # GoReleaser requires fetch-depth: 0 for - # changelog generation to work correctly. + # GoReleaser requires fetch-depth: 0 to correctly + # run git describe fetch-depth: 0 - - uses: actions/setup-go@v2 with: - go-version: '~1.16' + go-version: '~1.17' - - name: "Download osxcross cross-compiler for macOS builds" - run: | - git clone https://github.com/tpoechtrager/osxcross /tmp/osxcross - cd /tmp/osxcross - wget -P tarballs '' - echo "/tmp/osxcross/target/bin" >> $GITHUB_PATH - - - name: "Cache the osxcross + tarball build output" - id: cache-osxcross - uses: actions/cache@v2 + - name: "Run GoReleaser" + run: make release + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + RELEASE_ARGS: release --rm-dist -f release/goreleaser.windows.yaml --skip-validate ${{ github.event_name == 'pull_request' && '--snapshot' || '' }} + + - run: tar -cvf dist-windows.tar dist + - uses: actions/upload-artifact@v2 with: - path: /tmp/osxcross/target - key: ${{ runner.os }}-osxcross-${{ hashFiles('/tmp/osxcross/**/*') }} - restore-keys: | - ${{ runner.os }}-osxcross- + name: dist-windows + path: dist-windows.tar - - name: "Build osxcross" - if: steps.cache-osxcross.outputs.cache-hit != 'true' - run: | - cd /tmp/osxcross - sudo ./tools/get_dependencies.sh - UNATTENDED=1 ./build.sh + build-darwin: + runs-on: macos-latest + steps: + - uses: actions/checkout@v2 + with: + # GoReleaser requires fetch-depth: 0 to correctly + # run git describe + fetch-depth: 0 - - name: "Install linux cross-compilers" - run: | - sudo apt-get update - sudo apt-get install -y gcc-aarch64-linux-gnu gcc-s390x-linux-gnu gcc-powerpc64le-linux-gnu gcc-mingw-w64-x86-64 + - uses: actions/setup-go@v2 + with: + go-version: '~1.17' - - name: "Install yq" - run: | - sudo wget https://github.com/mikefarah/yq/releases/download/v4.10.0/yq_linux_amd64 -O /usr/local/bin/yq - sudo chmod +x /usr/local/bin/yq + - name: "Run GoReleaser" + run: make release + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + RELEASE_ARGS: release --rm-dist -f release/goreleaser.darwin.yaml --skip-validate ${{ github.event_name == 'pull_request' && '--snapshot' || '' }} - - name: "Disable image pushes for pull requests" - if: github.event_name == 'pull_request' - run: | - yq eval '.dockers[].skip_push=true' -i .goreleaser.yaml - yq eval '.docker_manifests[].skip_push=true' -i .goreleaser.yaml + - run: gtar -cvf dist-darwin.tar dist + - uses: actions/upload-artifact@v2 + with: + name: dist-darwin + path: dist-darwin.tar - - name: "Disable the Github release upload for non-tag builds" - if: startsWith(github.ref, 'refs/tags') != true + build-linux: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + with: + # GoReleaser requires fetch-depth: 0 to correctly + # run git describe + fetch-depth: 0 + + - uses: actions/setup-go@v2 + with: + go-version: '~1.17' + + - name: "Install linux cross-compilers" run: | - yq eval '.release.disable=true' -i .goreleaser.yaml + sudo apt-get update + sudo apt-get install -y gcc-aarch64-linux-gnu gcc-s390x-linux-gnu gcc-powerpc64le-linux-gnu - name: "Set the image tag" run: | @@ -97,4 +142,10 @@ jobs: run: make release env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - RELEASE_ARGS: release --rm-dist ${{ !startsWith(github.ref, 'refs/tags') && '--skip-validate' || '' }} + RELEASE_ARGS: release --rm-dist -f release/goreleaser.linux.yaml --skip-validate ${{ github.event_name == 'pull_request' && '--snapshot' || '' }} + + - run: tar -cvf dist-linux.tar dist + - uses: actions/upload-artifact@v2 + with: + name: dist-linux + path: dist-linux.tar diff --git a/staging/operator-registry/.github/workflows/sanity.yaml b/staging/operator-registry/.github/workflows/sanity.yaml index 39c61419fb..5c43e7391a 100644 --- a/staging/operator-registry/.github/workflows/sanity.yaml +++ b/staging/operator-registry/.github/workflows/sanity.yaml @@ -16,7 +16,7 @@ jobs: - uses: actions/checkout@v2 - uses: actions/setup-go@v2 with: - go-version: '~1.16' + go-version: '~1.17' - name: Install goimports run: go install golang.org/x/tools/cmd/goimports@latest - name: Run sanity checks diff --git a/staging/operator-registry/.github/workflows/test.yml b/staging/operator-registry/.github/workflows/test.yml index 1890895861..640eedd9b4 100644 --- a/staging/operator-registry/.github/workflows/test.yml +++ b/staging/operator-registry/.github/workflows/test.yml @@ -14,7 +14,7 @@ jobs: - uses: actions/checkout@v2 - uses: actions/setup-go@v2 with: - go-version: '~1.16' + go-version: '~1.17' - name: Install podman run: | . /etc/os-release diff --git a/staging/operator-registry/.github/workflows/unit.yaml b/staging/operator-registry/.github/workflows/unit.yaml index 0f97ca0d6b..44a5bc6106 100644 --- a/staging/operator-registry/.github/workflows/unit.yaml +++ b/staging/operator-registry/.github/workflows/unit.yaml @@ -16,7 +16,7 @@ jobs: - uses: actions/checkout@v2 - uses: actions/setup-go@v2 with: - go-version: '~1.16' + go-version: '~1.17' - run: make unit - run: sed -i'' "s:^github.com/$GITHUB_REPOSITORY/::" coverage.out - run: .github/workflows/codecov.sh -Z -f coverage.out diff --git a/staging/operator-registry/.gitignore b/staging/operator-registry/.gitignore index fe176ef932..6862915385 100644 --- a/staging/operator-registry/.gitignore +++ b/staging/operator-registry/.gitignore @@ -179,7 +179,6 @@ tags *.userprefs # Build results -[Dd]ebug/ [Dd]ebugPublic/ x64/ x86/ diff --git a/staging/operator-registry/Dockerfile b/staging/operator-registry/Dockerfile index 02a32b433e..afb7fb98ee 100644 --- a/staging/operator-registry/Dockerfile +++ b/staging/operator-registry/Dockerfile @@ -1,4 +1,4 @@ -FROM registry.ci.openshift.org/ocp/builder:rhel-8-golang-1.16-openshift-4.8 AS builder +FROM registry.ci.openshift.org/ocp/builder:rhel-8-golang-1.17-openshift-4.8 AS builder ENV GOPATH /go ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH diff --git a/staging/operator-registry/Makefile b/staging/operator-registry/Makefile index 41c1674e52..996613beec 100644 --- a/staging/operator-registry/Makefile +++ b/staging/operator-registry/Makefile @@ -116,7 +116,7 @@ clean: .PHONY: e2e e2e: - $(GO) run github.com/onsi/ginkgo/ginkgo --v --randomizeAllSpecs --randomizeSuites --race $(if $(TEST),-focus '$(TEST)') $(TAGS) ./test/e2e -- $(if $(SKIPTLS),-skip-tls true) + $(GO) run github.com/onsi/ginkgo/ginkgo --v --randomizeAllSpecs --randomizeSuites --race $(if $(TEST),-focus '$(TEST)') $(TAGS) ./test/e2e -- $(if $(SKIPTLS),-skip-tls-verify true) $(if $(USEHTTP),-use-http true) .PHONY: release @@ -137,9 +137,9 @@ export LATEST_IMAGE_OR_EMPTY ?= $(shell \ echo $(OPM_VERSION) | grep -Eq '^v[0-9]+\.[0-9]+\.[0-9]+$$' \ && [ "$(shell echo -e "$(OPM_VERSION)\n$(LATEST_TAG)" | sort -rV | head -n1)" == "$(OPM_VERSION)" ] \ && echo "$(OPM_IMAGE_REPO):latest" || echo "") -release: RELEASE_ARGS ?= release --rm-dist --snapshot +release: RELEASE_ARGS ?= release --rm-dist --snapshot -f release/goreleaser.$(shell go env GOOS).yaml release: - ./scripts/fetch goreleaser 0.177.0 && ./bin/goreleaser $(RELEASE_ARGS) + ./scripts/fetch goreleaser 1.4.1 && ./bin/goreleaser $(RELEASE_ARGS) # tagged-or-empty returns $(OPM_IMAGE_REPO):$(1) when HEAD is assigned a non-prerelease semver tag, # otherwise the empty string. An empty string causes goreleaser to skip building diff --git a/staging/operator-registry/OWNERS b/staging/operator-registry/OWNERS index 492072e227..c1c32e681c 100644 --- a/staging/operator-registry/OWNERS +++ b/staging/operator-registry/OWNERS @@ -19,7 +19,6 @@ reviewers: - benluddy - hasbro17 - ankitathomas - - estroz - joelanford - jmrodri - timflannagan diff --git a/staging/operator-registry/alpha/action/render_test.go b/staging/operator-registry/alpha/action/render_test.go index b355233ece..e36872a89d 100644 --- a/staging/operator-registry/alpha/action/render_test.go +++ b/staging/operator-registry/alpha/action/render_test.go @@ -3,6 +3,7 @@ package action_test import ( "context" "embed" + "encoding/json" "errors" "io/fs" "os" @@ -265,13 +266,20 @@ func TestRender(t *testing.T) { Schema: "olm.package", Name: "foo", DefaultChannel: "beta", + Properties: []property.Property{ + {Type: "owner", Value: json.RawMessage("{\"group\":\"abc.com\",\"name\":\"admin\"}")}, + }, }, }, Channels: []declcfg.Channel{ {Schema: "olm.channel", Package: "foo", Name: "beta", Entries: []declcfg.ChannelEntry{ {Name: "foo.v0.1.0", SkipRange: "<0.1.0"}, {Name: "foo.v0.2.0", Replaces: "foo.v0.1.0", SkipRange: "<0.2.0", Skips: []string{"foo.v0.1.1", "foo.v0.1.2"}}, - }}, + }, + Properties: []property.Property{ + {Type: "user", Value: json.RawMessage("{\"group\":\"xyz.com\",\"name\":\"account\"}")}, + }, + }, {Schema: "olm.channel", Package: "foo", Name: "stable", Entries: []declcfg.ChannelEntry{ {Name: "foo.v0.2.0", Replaces: "foo.v0.1.0", SkipRange: "<0.2.0", Skips: []string{"foo.v0.1.1", "foo.v0.1.2"}}, }}, @@ -356,13 +364,20 @@ func TestRender(t *testing.T) { Schema: "olm.package", Name: "foo", DefaultChannel: "beta", + Properties: []property.Property{ + {Type: "owner", Value: json.RawMessage("{\"group\":\"abc.com\",\"name\":\"admin\"}")}, + }, }, }, Channels: []declcfg.Channel{ {Schema: "olm.channel", Package: "foo", Name: "beta", Entries: []declcfg.ChannelEntry{ {Name: "foo.v0.1.0", SkipRange: "<0.1.0"}, {Name: "foo.v0.2.0", Replaces: "foo.v0.1.0", SkipRange: "<0.2.0", Skips: []string{"foo.v0.1.1", "foo.v0.1.2"}}, - }}, + }, + Properties: []property.Property{ + {Type: "user", Value: json.RawMessage("{\"group\":\"xyz.com\",\"name\":\"account\"}")}, + }, + }, {Schema: "olm.channel", Package: "foo", Name: "stable", Entries: []declcfg.ChannelEntry{ {Name: "foo.v0.2.0", Replaces: "foo.v0.1.0", SkipRange: "<0.2.0", Skips: []string{"foo.v0.1.1", "foo.v0.1.2"}}, }}, diff --git a/staging/operator-registry/alpha/action/testdata/foo-index-v0.2.0-declcfg/foo/index.yaml b/staging/operator-registry/alpha/action/testdata/foo-index-v0.2.0-declcfg/foo/index.yaml index 7a126ee502..933b108d2a 100644 --- a/staging/operator-registry/alpha/action/testdata/foo-index-v0.2.0-declcfg/foo/index.yaml +++ b/staging/operator-registry/alpha/action/testdata/foo-index-v0.2.0-declcfg/foo/index.yaml @@ -2,6 +2,11 @@ schema: olm.package name: foo defaultChannel: beta +properties: + - type: owner + value: + group: abc.com + name: admin --- schema: olm.channel package: foo @@ -15,6 +20,11 @@ entries: skips: - foo.v0.1.1 - foo.v0.1.2 +properties: + - type: user + value: + group: xyz.com + name: account --- schema: olm.channel package: foo diff --git a/staging/operator-registry/alpha/declcfg/declcfg.go b/staging/operator-registry/alpha/declcfg/declcfg.go index 688d5982a6..7579c97e31 100644 --- a/staging/operator-registry/alpha/declcfg/declcfg.go +++ b/staging/operator-registry/alpha/declcfg/declcfg.go @@ -20,11 +20,12 @@ type DeclarativeConfig struct { } type Package struct { - Schema string `json:"schema"` - Name string `json:"name"` - DefaultChannel string `json:"defaultChannel"` - Icon *Icon `json:"icon,omitempty"` - Description string `json:"description,omitempty"` + Schema string `json:"schema"` + Name string `json:"name"` + DefaultChannel string `json:"defaultChannel"` + Icon *Icon `json:"icon,omitempty"` + Description string `json:"description,omitempty"` + Properties []property.Property `json:"properties,omitempty" hash:"set"` } type Icon struct { @@ -33,10 +34,11 @@ type Icon struct { } type Channel struct { - Schema string `json:"schema"` - Name string `json:"name"` - Package string `json:"package"` - Entries []ChannelEntry `json:"entries"` + Schema string `json:"schema"` + Name string `json:"name"` + Package string `json:"package"` + Entries []ChannelEntry `json:"entries"` + Properties []property.Property `json:"properties,omitempty" hash:"set"` } type ChannelEntry struct { diff --git a/staging/operator-registry/alpha/declcfg/declcfg_to_model_test.go b/staging/operator-registry/alpha/declcfg/declcfg_to_model_test.go index 34c7bc020a..b633c7cc38 100644 --- a/staging/operator-registry/alpha/declcfg/declcfg_to_model_test.go +++ b/staging/operator-registry/alpha/declcfg/declcfg_to_model_test.go @@ -248,6 +248,38 @@ func TestConvertToModel(t *testing.T) { Bundles: []Bundle{newTestBundle("foo", "0.1.0")}, }, }, + { + name: "Success/ValidModelWithChannelProperties", + assertion: require.NoError, + cfg: DeclarativeConfig{ + Packages: []Package{newTestPackage("foo", "alpha", svgSmallCircle)}, + Channels: []Channel{ + addChannelProperties( + newTestChannel("foo", "alpha", ChannelEntry{Name: "foo.v0.1.0"}), + []property.Property{ + {Type: "user", Value: json.RawMessage("{\"group\":\"xyz.com\",\"name\":\"account\"}")}, + }, + ), + }, + Bundles: []Bundle{newTestBundle("foo", "0.1.0")}, + }, + }, + { + name: "Success/ValidModelWithPackageProperties", + assertion: require.NoError, + cfg: DeclarativeConfig{ + Packages: []Package{ + addPackageProperties( + newTestPackage("foo", "alpha", svgSmallCircle), + []property.Property{ + {Type: "owner", Value: json.RawMessage("{\"group\":\"abc.com\",\"name\":\"admin\"}")}, + }, + ), + }, + Channels: []Channel{newTestChannel("foo", "alpha", ChannelEntry{Name: "foo.v0.1.0"})}, + Bundles: []Bundle{newTestBundle("foo", "0.1.0")}, + }, + }, } for _, s := range specs { diff --git a/staging/operator-registry/alpha/declcfg/diff.go b/staging/operator-registry/alpha/declcfg/diff.go index 034aa02400..351eb95e58 100644 --- a/staging/operator-registry/alpha/declcfg/diff.go +++ b/staging/operator-registry/alpha/declcfg/diff.go @@ -101,7 +101,10 @@ func (g *DiffGenerator) Run(oldModel, newModel model.Model) (model.Model, error) if len(ch.Bundles) == 0 { delete(outputPkg.Channels, ch.Name) } - + } + if len(outputPkg.Channels) == 0 { + // Remove empty packages. + delete(outputModel, outputPkg.Name) } } } diff --git a/staging/operator-registry/alpha/declcfg/diff_test.go b/staging/operator-registry/alpha/declcfg/diff_test.go index 18f7dc657b..d36e2aadd5 100644 --- a/staging/operator-registry/alpha/declcfg/diff_test.go +++ b/staging/operator-registry/alpha/declcfg/diff_test.go @@ -1271,6 +1271,66 @@ func TestDiffHeadsOnly(t *testing.T) { g: &DiffGenerator{}, expCfg: DeclarativeConfig{}, }, + { + name: "NoDiff/EmptyBundleWithInclude", + newCfg: DeclarativeConfig{ + Packages: []Package{ + {Schema: schemaPackage, Name: "etcd", DefaultChannel: "stable"}, + }, + Channels: []Channel{ + {Schema: schemaChannel, Name: "stable", Package: "etcd", Entries: []ChannelEntry{ + {Name: "etcd.v0.9.0"}, + {Name: "etcd.v0.9.1", Replaces: "etcd.v0.9.0"}, + }}, + {Schema: schemaChannel, Name: "clusterwide", Package: "etcd", Entries: []ChannelEntry{ + {Name: "etcd.v0.9.1-clusterwide"}, + }}, + }, + Bundles: []Bundle{ + { + Schema: schemaBundle, + Name: "etcd.v0.9.0", + Package: "etcd", + Image: "reg/etcd:latest", + Properties: []property.Property{ + property.MustBuildPackage("etcd", "0.9.1"), + }, + }, + { + Schema: schemaBundle, + Name: "etcd.v0.9.1", + Package: "etcd", + Image: "reg/etcd:latest", + Properties: []property.Property{ + property.MustBuildPackage("etcd", "0.9.1"), + }, + }, + { + Schema: schemaBundle, + Name: "etcd.v0.9.1-clusterwide", + Package: "etcd", + Image: "reg/etcd:latest", + Properties: []property.Property{ + property.MustBuildPackage("etcd", "0.9.1-clusterwide"), + }, + }, + }, + }, + g: &DiffGenerator{ + IncludeAdditively: false, + Includer: DiffIncluder{ + Packages: []DiffIncludePackage{ + { + Name: "etcd", + AllChannels: DiffIncludeChannel{ + Versions: []semver.Version{{Major: 0, Minor: 9, Patch: 2}}, + }, + }, + }, + }, + }, + expCfg: DeclarativeConfig{}, + }, { name: "HasDiff/OneBundle", newCfg: DeclarativeConfig{ diff --git a/staging/operator-registry/alpha/declcfg/helpers_test.go b/staging/operator-registry/alpha/declcfg/helpers_test.go index 86111c770a..cb1a10e2e6 100644 --- a/staging/operator-registry/alpha/declcfg/helpers_test.go +++ b/staging/operator-registry/alpha/declcfg/helpers_test.go @@ -159,6 +159,11 @@ func newTestPackage(packageName, defaultChannel, svgData string) Package { return p } +func addPackageProperties(in Package, p []property.Property) Package { + in.Properties = p + return in +} + func newTestChannel(packageName, channelName string, entries ...ChannelEntry) Channel { return Channel{ Schema: schemaChannel, @@ -168,6 +173,11 @@ func newTestChannel(packageName, channelName string, entries ...ChannelEntry) Ch } } +func addChannelProperties(in Channel, p []property.Property) Channel { + in.Properties = p + return in +} + func buildTestModel() model.Model { return model.Model{ "anakin": buildAnakinPkgModel(), diff --git a/staging/operator-registry/cmd/opm/alpha/bundle/extract.go b/staging/operator-registry/cmd/opm/alpha/bundle/extract.go index d07273b3c4..3952a52b8c 100644 --- a/staging/operator-registry/cmd/opm/alpha/bundle/extract.go +++ b/staging/operator-registry/cmd/opm/alpha/bundle/extract.go @@ -12,7 +12,7 @@ import ( var extractCmd = &cobra.Command{ Use: "extract", Short: "Extracts the data in a bundle directory via ConfigMap", - Long: "Extract takes as input a directory containing manifests and writes the per file contents to a ConfipMap", + Long: "Extract takes as input a directory containing manifests and writes the per file contents to a ConfigMap", PreRunE: func(cmd *cobra.Command, _ []string) error { if debug, _ := cmd.Flags().GetBool("debug"); debug { diff --git a/staging/operator-registry/cmd/opm/alpha/bundle/unpack.go b/staging/operator-registry/cmd/opm/alpha/bundle/unpack.go index 67f3b311a5..59ccab3799 100644 --- a/staging/operator-registry/cmd/opm/alpha/bundle/unpack.go +++ b/staging/operator-registry/cmd/opm/alpha/bundle/unpack.go @@ -12,6 +12,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/image" "github.com/operator-framework/operator-registry/pkg/image/containerdregistry" "github.com/operator-framework/operator-registry/pkg/lib/bundle" @@ -28,11 +29,16 @@ func newBundleUnpackCmd() *cobra.Command { RunE: unpackBundle, } unpack.Flags().BoolP("debug", "d", false, "enable debug log output") - unpack.Flags().BoolP("skip-tls", "s", false, "disable TLS verification") + unpack.Flags().BoolP("skip-tls", "s", false, "use plain HTTP") + unpack.Flags().Bool("skip-tls-verify", false, "disable TLS verification") + unpack.Flags().Bool("use-http", false, "use plain HTTP") unpack.Flags().BoolP("skip-validation", "v", false, "disable bundle validation") unpack.Flags().StringP("root-ca", "c", "", "file path of a root CA to use when communicating with image registries") unpack.Flags().StringP("out", "o", "./", "directory in which to unpack operator bundle content") + if err := unpack.Flags().MarkDeprecated("skip-tls", "use --use-http and --skip-tls-verify instead"); err != nil { + logrus.Panic(err.Error()) + } return unpack } @@ -71,13 +77,14 @@ func unpackBundle(cmd *cobra.Command, args []string) error { var ( registryOpts []containerdregistry.RegistryOption - skipTLS bool ) - skipTLS, err = cmd.Flags().GetBool("skip-tls") + + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } - registryOpts = append(registryOpts, containerdregistry.SkipTLS(skipTLS)) + + registryOpts = append(registryOpts, containerdregistry.SkipTLSVerify(skipTLSVerify), containerdregistry.WithPlainHTTP(useHTTP)) var skipValidation bool skipValidation, err = cmd.Flags().GetBool("skip-validation") diff --git a/staging/operator-registry/cmd/opm/alpha/cmd.go b/staging/operator-registry/cmd/opm/alpha/cmd.go index 7afed8b098..da67833a4a 100644 --- a/staging/operator-registry/cmd/opm/alpha/cmd.go +++ b/staging/operator-registry/cmd/opm/alpha/cmd.go @@ -5,7 +5,6 @@ import ( "github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle" "github.com/operator-framework/operator-registry/cmd/opm/alpha/diff" - "github.com/operator-framework/operator-registry/cmd/opm/alpha/generate" "github.com/operator-framework/operator-registry/cmd/opm/alpha/list" ) @@ -20,7 +19,6 @@ func NewCmd() *cobra.Command { runCmd.AddCommand( bundle.NewCmd(), list.NewCmd(), - generate.NewCmd(), diff.NewCmd(), ) return runCmd diff --git a/staging/operator-registry/cmd/opm/alpha/diff/cmd.go b/staging/operator-registry/cmd/opm/alpha/diff/cmd.go index 752e4d343a..54ed5aa54d 100644 --- a/staging/operator-registry/cmd/opm/alpha/diff/cmd.go +++ b/staging/operator-registry/cmd/opm/alpha/diff/cmd.go @@ -14,6 +14,7 @@ import ( "github.com/operator-framework/operator-registry/alpha/action" "github.com/operator-framework/operator-registry/alpha/declcfg" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" containerd "github.com/operator-framework/operator-registry/pkg/image/containerdregistry" "github.com/operator-framework/operator-registry/pkg/lib/certs" ) @@ -154,15 +155,21 @@ func (a *diff) addFunc(cmd *cobra.Command, args []string) error { return fmt.Errorf("invalid --output value: %q", a.output) } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { - logrus.Panic(err) + return err } + rootCAs, err := certs.RootCAs(a.caFile) if err != nil { a.logger.Fatalf("error getting root CAs: %v", err) } - reg, err := containerd.NewRegistry(containerd.SkipTLS(skipTLS), containerd.WithLog(a.logger), containerd.WithRootCAs(rootCAs)) + reg, err := containerd.NewRegistry( + containerd.SkipTLSVerify(skipTLSVerify), + containerd.WithLog(a.logger), + containerd.WithRootCAs(rootCAs), + containerd.WithPlainHTTP(useHTTP), + ) if err != nil { a.logger.Fatalf("error creating containerd registry: %v", err) } diff --git a/staging/operator-registry/cmd/opm/alpha/generate/cmd.go b/staging/operator-registry/cmd/opm/generate/cmd.go similarity index 100% rename from staging/operator-registry/cmd/opm/alpha/generate/cmd.go rename to staging/operator-registry/cmd/opm/generate/cmd.go diff --git a/staging/operator-registry/cmd/opm/index/add.go b/staging/operator-registry/cmd/opm/index/add.go index ea218d6e04..0cb7c48016 100644 --- a/staging/operator-registry/cmd/opm/index/add.go +++ b/staging/operator-registry/cmd/opm/index/add.go @@ -7,6 +7,7 @@ import ( "github.com/spf13/cobra" "k8s.io/kubectl/pkg/util/templates" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/registry" @@ -126,7 +127,7 @@ func runIndexAddCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -174,7 +175,8 @@ func runIndexAddCmdFunc(cmd *cobra.Command, _ []string) error { Bundles: bundles, Permissive: permissive, Mode: modeEnum, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, Overwrite: overwrite, EnableAlpha: enableAlpha, } diff --git a/staging/operator-registry/cmd/opm/index/cmd.go b/staging/operator-registry/cmd/opm/index/cmd.go index b7cdd14d15..3e3aeb4993 100644 --- a/staging/operator-registry/cmd/opm/index/cmd.go +++ b/staging/operator-registry/cmd/opm/index/cmd.go @@ -33,6 +33,12 @@ func AddCommand(parent *cobra.Command) { parent.AddCommand(cmd) parent.PersistentFlags().Bool("skip-tls", false, "skip TLS certificate verification for container image registries while pulling bundles or index") + parent.PersistentFlags().Bool("skip-tls-verify", false, "skip TLS certificate verification for container image registries while pulling bundles") + parent.PersistentFlags().Bool("use-http", false, "use plain HTTP for container image registries while pulling bundles") + if err := parent.PersistentFlags().MarkDeprecated("skip-tls", "use --use-http and --skip-tls-verify instead"); err != nil { + logrus.Panic(err.Error()) + } + cmd.AddCommand(newIndexDeleteCmd()) addIndexAddCmd(cmd) cmd.AddCommand(newIndexExportCmd()) diff --git a/staging/operator-registry/cmd/opm/index/delete.go b/staging/operator-registry/cmd/opm/index/delete.go index c9472b8ed2..f7970676af 100644 --- a/staging/operator-registry/cmd/opm/index/delete.go +++ b/staging/operator-registry/cmd/opm/index/delete.go @@ -4,6 +4,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -95,7 +96,7 @@ func runIndexDeleteCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -117,7 +118,8 @@ func runIndexDeleteCmdFunc(cmd *cobra.Command, _ []string) error { Operators: operators, Tag: tag, Permissive: permissive, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, } err = indexDeleter.DeleteFromIndex(request) diff --git a/staging/operator-registry/cmd/opm/index/deprecatetruncate.go b/staging/operator-registry/cmd/opm/index/deprecatetruncate.go index 9324d35b8e..33206e3235 100644 --- a/staging/operator-registry/cmd/opm/index/deprecatetruncate.go +++ b/staging/operator-registry/cmd/opm/index/deprecatetruncate.go @@ -5,6 +5,7 @@ import ( "github.com/spf13/cobra" "k8s.io/kubectl/pkg/util/templates" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -110,7 +111,7 @@ func runIndexDeprecateTruncateCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -137,7 +138,8 @@ func runIndexDeprecateTruncateCmdFunc(cmd *cobra.Command, _ []string) error { Tag: tag, Bundles: bundles, Permissive: permissive, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, AllowPackageRemoval: allowPackageRemoval, } diff --git a/staging/operator-registry/cmd/opm/index/export.go b/staging/operator-registry/cmd/opm/index/export.go index f4e32672e7..2541cbba69 100644 --- a/staging/operator-registry/cmd/opm/index/export.go +++ b/staging/operator-registry/cmd/opm/index/export.go @@ -7,6 +7,7 @@ import ( "github.com/spf13/cobra" "k8s.io/kubectl/pkg/util/templates" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -100,7 +101,7 @@ func runIndexExportCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -116,7 +117,8 @@ func runIndexExportCmdFunc(cmd *cobra.Command, _ []string) error { Packages: packages, DownloadPath: downloadPath, ContainerTool: containertools.NewContainerTool(containerTool, containertools.NoneTool), - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, } err = indexExporter.ExportFromIndex(request) diff --git a/staging/operator-registry/cmd/opm/index/prune.go b/staging/operator-registry/cmd/opm/index/prune.go index c80ebf6198..ec57174bb8 100644 --- a/staging/operator-registry/cmd/opm/index/prune.go +++ b/staging/operator-registry/cmd/opm/index/prune.go @@ -6,6 +6,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -99,7 +100,7 @@ func runIndexPruneCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -118,7 +119,8 @@ func runIndexPruneCmdFunc(cmd *cobra.Command, _ []string) error { Packages: packages, Tag: tag, Permissive: permissive, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, } err = indexPruner.PruneFromIndex(request) diff --git a/staging/operator-registry/cmd/opm/index/prunestranded.go b/staging/operator-registry/cmd/opm/index/prunestranded.go index 03e739cff5..4ba306919f 100644 --- a/staging/operator-registry/cmd/opm/index/prunestranded.go +++ b/staging/operator-registry/cmd/opm/index/prunestranded.go @@ -6,6 +6,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -84,7 +85,7 @@ func runIndexPruneStrandedCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -101,7 +102,8 @@ func runIndexPruneStrandedCmdFunc(cmd *cobra.Command, _ []string) error { BinarySourceImage: binaryImage, OutDockerfile: outDockerfile, Tag: tag, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, } err = indexPruner.PruneStrandedFromIndex(request) diff --git a/staging/operator-registry/cmd/opm/internal/util/util.go b/staging/operator-registry/cmd/opm/internal/util/util.go new file mode 100644 index 0000000000..7d83cf66a8 --- /dev/null +++ b/staging/operator-registry/cmd/opm/internal/util/util.go @@ -0,0 +1,39 @@ +package util + +import ( + "errors" + + "github.com/spf13/cobra" +) + +// GetTLSOptions validates and returns TLS options set by opm flags +func GetTLSOptions(cmd *cobra.Command) (bool, bool, error) { + skipTLS, err := cmd.Flags().GetBool("skip-tls") + if err != nil { + return false, false, err + } + skipTLSVerify, err := cmd.Flags().GetBool("skip-tls-verify") + if err != nil { + return false, false, err + } + useHTTP, err := cmd.Flags().GetBool("use-http") + if err != nil { + return false, false, err + } + + switch { + case cmd.Flags().Changed("skip-tls") && cmd.Flags().Changed("use-http"): + return false, false, errors.New("invalid flag combination: cannot use --use-http with --skip-tls") + case cmd.Flags().Changed("skip-tls") && cmd.Flags().Changed("skip-tls-verify"): + return false, false, errors.New("invalid flag combination: cannot use --skip-tls-verify with --skip-tls") + case skipTLSVerify && useHTTP: + return false, false, errors.New("invalid flag combination: --use-http and --skip-tls-verify cannot both be true") + default: + // return use HTTP true if just skipTLS + // is set for functional parity with existing + if skipTLS { + return false, true, nil + } + return skipTLSVerify, useHTTP, nil + } +} diff --git a/staging/operator-registry/cmd/opm/registry/add.go b/staging/operator-registry/cmd/opm/registry/add.go index ceb3fcd1ad..dd7237e37d 100644 --- a/staging/operator-registry/cmd/opm/registry/add.go +++ b/staging/operator-registry/cmd/opm/registry/add.go @@ -7,6 +7,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/registry" reg "github.com/operator-framework/operator-registry/pkg/registry" @@ -36,7 +37,9 @@ func newRegistryAddCmd() *cobra.Command { rootCmd.Flags().StringP("database", "d", "bundles.db", "relative path to database file") rootCmd.Flags().StringSliceP("bundle-images", "b", []string{}, "comma separated list of links to bundle image") rootCmd.Flags().Bool("permissive", false, "allow registry load errors") - rootCmd.Flags().Bool("skip-tls", false, "skip TLS certificate verification for container image registries while pulling bundles") + rootCmd.Flags().Bool("skip-tls", false, "use Plain HTTP for container image registries while pulling bundles") + rootCmd.Flags().Bool("skip-tls-verify", false, "skip TLS certificate verification for container image registries while pulling bundles") + rootCmd.Flags().Bool("use-http", false, "use plain HTTP for container image registries while pulling bundles") rootCmd.Flags().String("ca-file", "", "the root certificates to use when --container-tool=none; see docker/podman docs for certificate loading instructions") rootCmd.Flags().StringP("mode", "", "replaces", "graph update mode that defines how channel graphs are updated. One of: [replaces, semver, semver-skippatch]") rootCmd.Flags().StringP("container-tool", "c", "none", "tool to interact with container images (save, build, etc.). One of: [none, docker, podman]") @@ -48,6 +51,9 @@ func newRegistryAddCmd() *cobra.Command { if err := rootCmd.Flags().MarkHidden("enable-alpha"); err != nil { logrus.Panic(err.Error()) } + if err := rootCmd.Flags().MarkDeprecated("skip-tls", "use --use-http and --skip-tls-verify instead"); err != nil { + logrus.Panic(err.Error()) + } return rootCmd } @@ -56,10 +62,6 @@ func addFunc(cmd *cobra.Command, _ []string) error { if err != nil { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") - if err != nil { - return err - } caFile, err := cmd.Flags().GetString("ca-file") if err != nil { return err @@ -95,9 +97,14 @@ func addFunc(cmd *cobra.Command, _ []string) error { return err } + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) + if err != nil { + return err + } + if caFile != "" { - if skipTLS { - return errors.New("--skip-tls must be false when --ca-file is set") + if skipTLSVerify { + return errors.New("--skip-tls-verify must be false when --ca-file is set") } if containerTool != containertools.NoneTool { return fmt.Errorf("--ca-file cannot be set with --container-tool=%[1]s; "+ @@ -107,7 +114,8 @@ func addFunc(cmd *cobra.Command, _ []string) error { request := registry.AddToRegistryRequest{ Permissive: permissive, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, CaFile: caFile, InputDatabase: fromFilename, Bundles: bundleImages, @@ -119,8 +127,12 @@ func addFunc(cmd *cobra.Command, _ []string) error { logger := logrus.WithFields(logrus.Fields{"bundles": bundleImages}) - if skipTLS { - logger.Warn("--skip-tls flag is set: this mode is insecure and meant for development purposes only.") + if skipTLSVerify { + logger.Warn("--skip-tls-verify flag is set: this mode is insecure and meant for development purposes only.") + } + + if useHTTP { + logger.Warn("--use-http flag is set: this mode is insecure and meant for development purposes only.") } logger.Info("adding to the registry") diff --git a/staging/operator-registry/cmd/opm/render/cmd.go b/staging/operator-registry/cmd/opm/render/cmd.go index 913eb21a08..228deab5a8 100644 --- a/staging/operator-registry/cmd/opm/render/cmd.go +++ b/staging/operator-registry/cmd/opm/render/cmd.go @@ -11,6 +11,8 @@ import ( "github.com/operator-framework/operator-registry/alpha/action" "github.com/operator-framework/operator-registry/alpha/declcfg" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" + containerd "github.com/operator-framework/operator-registry/pkg/image/containerdregistry" "github.com/operator-framework/operator-registry/pkg/sqlite" ) @@ -44,6 +46,29 @@ func NewCmd() *cobra.Command { // returned from render.Run and logged as fatal errors. logrus.SetOutput(ioutil.Discard) + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) + if err != nil { + log.Fatal(err) + } + + cacheDir, err := os.MkdirTemp("", "render-registry-") + if err != nil { + log.Fatal(err) + } + + reg, err := containerd.NewRegistry( + containerd.WithCacheDir(cacheDir), + containerd.SkipTLSVerify(skipTLSVerify), + containerd.WithPlainHTTP(useHTTP), + containerd.WithLog(nullLogger()), + ) + if err != nil { + log.Fatalf("creating containerd registry: %v", err) + } + defer reg.Destroy() + + render.Registry = reg + cfg, err := render.Run(cmd.Context()) if err != nil { log.Fatal(err) @@ -55,5 +80,13 @@ func NewCmd() *cobra.Command { }, } cmd.Flags().StringVarP(&output, "output", "o", "json", "Output format (json|yaml)") + cmd.Flags().Bool("skip-tls-verify", false, "disable TLS verification") + cmd.Flags().Bool("use-http", false, "use plain HTTP") return cmd } + +func nullLogger() *logrus.Entry { + logger := logrus.New() + logger.SetOutput(ioutil.Discard) + return logrus.NewEntry(logger) +} diff --git a/staging/operator-registry/cmd/opm/root/cmd.go b/staging/operator-registry/cmd/opm/root/cmd.go index 1b00fecc01..8798aaf795 100644 --- a/staging/operator-registry/cmd/opm/root/cmd.go +++ b/staging/operator-registry/cmd/opm/root/cmd.go @@ -5,6 +5,7 @@ import ( "github.com/spf13/cobra" "github.com/operator-framework/operator-registry/cmd/opm/alpha" + "github.com/operator-framework/operator-registry/cmd/opm/generate" "github.com/operator-framework/operator-registry/cmd/opm/index" initcmd "github.com/operator-framework/operator-registry/cmd/opm/init" "github.com/operator-framework/operator-registry/cmd/opm/migrate" @@ -29,7 +30,7 @@ func NewCmd() *cobra.Command { Args: cobra.NoArgs, } - cmd.AddCommand(registry.NewOpmRegistryCmd(), alpha.NewCmd(), initcmd.NewCmd(), migrate.NewCmd(), serve.NewCmd(), render.NewCmd(), validate.NewCmd()) + cmd.AddCommand(registry.NewOpmRegistryCmd(), alpha.NewCmd(), initcmd.NewCmd(), migrate.NewCmd(), serve.NewCmd(), render.NewCmd(), validate.NewCmd(), generate.NewCmd()) index.AddCommand(cmd) version.AddCommand(cmd) diff --git a/staging/operator-registry/codegen.Dockerfile b/staging/operator-registry/codegen.Dockerfile index 141433350f..bcb18ef225 100644 --- a/staging/operator-registry/codegen.Dockerfile +++ b/staging/operator-registry/codegen.Dockerfile @@ -1,4 +1,4 @@ -FROM golang:1.16-alpine +FROM golang:1.17-alpine RUN apk update && \ apk add make git protobuf diff --git a/staging/operator-registry/docs/contributors/e2e_tests.md b/staging/operator-registry/docs/contributors/e2e_tests.md index a0eb50eedc..6d716128b1 100644 --- a/staging/operator-registry/docs/contributors/e2e_tests.md +++ b/staging/operator-registry/docs/contributors/e2e_tests.md @@ -19,13 +19,13 @@ running even after the test suite has completed. 1. Start the e2e tests: ```bash - DOCKER_REGISTRY_HOST=localhost:5000 GOENV='GOOS=linux' make build e2e SKIPTLS="true" CLUSTER=kind + DOCKER_REGISTRY_HOST=localhost:5000 GOENV='GOOS=linux' make build e2e USEHTTP="true" CLUSTER=kind ``` 1. Run a specific BDD test using the `TEST` argument to make. Note that this argument uses regular expressions. ```bash - DOCKER_REGISTRY_HOST=localhost:5000 GOENV='GOOS=linux' make build e2e TEST='builds and manipulates bundle and index images' SKIPTLS="true" CLUSTER=kind + DOCKER_REGISTRY_HOST=localhost:5000 GOENV='GOOS=linux' make build e2e TEST='builds and manipulates bundle and index images' USEHTTP="true" CLUSTER=kind ``` 1. If you want a quick way to ensure that your TEST regex argument will work, you can bypass the diff --git a/staging/operator-registry/go.mod b/staging/operator-registry/go.mod index b1e82f13d5..870c446f2d 100644 --- a/staging/operator-registry/go.mod +++ b/staging/operator-registry/go.mod @@ -1,35 +1,24 @@ module github.com/operator-framework/operator-registry -go 1.16 +go 1.17 require ( - github.com/Microsoft/hcsshim v0.8.9 // indirect + github.com/adrg/xdg v0.4.0 github.com/blang/semver/v4 v4.0.0 - github.com/bugsnag/bugsnag-go v1.5.3 // indirect - github.com/bugsnag/panicwrap v1.2.0 // indirect github.com/containerd/containerd v1.4.11 - github.com/containerd/continuity v0.0.0-20200413184840-d3ef23f19fbb // indirect - github.com/containerd/ttrpc v1.0.1 // indirect - github.com/docker/cli v0.0.0-20200130152716-5d0cf8839492 + github.com/docker/cli v20.10.12+incompatible github.com/docker/distribution v2.7.1+incompatible github.com/docker/docker v1.4.2-0.20200203170920-46ec8731fbce - github.com/docker/docker-credential-helpers v0.6.3 // indirect - github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c // indirect - github.com/docker/go-metrics v0.0.1 // indirect - github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect - github.com/garyburd/redigo v1.6.0 // indirect github.com/ghodss/yaml v1.0.0 - github.com/gofrs/uuid v3.3.0+incompatible // indirect github.com/golang-migrate/migrate/v4 v4.6.2 github.com/golang/mock v1.5.0 github.com/golang/protobuf v1.5.2 github.com/google/go-cmp v0.5.6 - github.com/gorilla/handlers v1.4.2 // indirect github.com/grpc-ecosystem/grpc-health-probe v0.3.2 github.com/h2non/filetype v1.1.1 github.com/h2non/go-is-svg v0.0.0-20160927212452-35e8c4b0612c github.com/joelanford/ignore v0.0.0-20210607151042-0d25dc18b62d - github.com/mattn/go-sqlite3 v1.10.0 + github.com/mattn/go-sqlite3 v1.14.10 github.com/maxbrunsfeld/counterfeiter/v6 v6.2.2 github.com/mitchellh/hashstructure/v2 v2.0.2 github.com/onsi/ginkgo v1.16.4 @@ -43,9 +32,6 @@ require ( github.com/sirupsen/logrus v1.8.1 github.com/spf13/cobra v1.2.1 github.com/stretchr/testify v1.7.0 - github.com/yvasiyarov/go-metrics v0.0.0-20150112132944-c25f46c4b940 // indirect - github.com/yvasiyarov/gorelic v0.0.7 // indirect - github.com/yvasiyarov/newrelic_platform_go v0.0.0-20160601141957-9c099fbc30e9 // indirect go.etcd.io/bbolt v1.3.6 golang.org/x/mod v0.4.2 golang.org/x/net v0.0.0-20210825183410-e898025ed96a @@ -64,5 +50,118 @@ require ( sigs.k8s.io/yaml v1.2.0 ) +require ( + github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect + github.com/BurntSushi/toml v0.3.1 // indirect + github.com/MakeNowJust/heredoc v0.0.0-20170808103936-bb23615498cd // indirect + github.com/Microsoft/go-winio v0.4.16 // indirect + github.com/Microsoft/hcsshim v0.8.9 // indirect + github.com/PuerkitoBio/purell v1.1.1 // indirect + github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect + github.com/Shopify/logrus-bugsnag v0.0.0-20171204204709-577dee27f20d // indirect + github.com/alessio/shellescape v1.4.1 // indirect + github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e // indirect + github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/blang/semver v3.5.1+incompatible // indirect + github.com/bshuster-repo/logrus-logstash-hook v0.4.1 // indirect + github.com/bugsnag/bugsnag-go v1.5.3 // indirect + github.com/bugsnag/panicwrap v1.2.0 // indirect + github.com/cespare/xxhash/v2 v2.1.1 // indirect + github.com/containerd/cgroups v0.0.0-20190919134610-bf292b21730f // indirect + github.com/containerd/continuity v0.0.0-20200413184840-d3ef23f19fbb // indirect + github.com/containerd/ttrpc v1.0.1 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/docker/docker-credential-helpers v0.6.3 // indirect + github.com/docker/go-connections v0.4.0 // indirect + github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c // indirect + github.com/docker/go-metrics v0.0.1 // indirect + github.com/docker/go-units v0.4.0 // indirect + github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect + github.com/evanphx/json-patch v4.11.0+incompatible // indirect + github.com/evanphx/json-patch/v5 v5.2.0 // indirect + github.com/felixge/httpsnoop v1.0.1 // indirect + github.com/fsnotify/fsnotify v1.4.9 // indirect + github.com/garyburd/redigo v1.6.0 // indirect + github.com/go-git/gcfg v1.5.0 // indirect + github.com/go-git/go-billy/v5 v5.1.0 // indirect + github.com/go-git/go-git/v5 v5.3.0 // indirect + github.com/go-logr/logr v0.4.0 // indirect + github.com/go-openapi/jsonpointer v0.19.5 // indirect + github.com/go-openapi/jsonreference v0.19.5 // indirect + github.com/go-openapi/swag v0.19.14 // indirect + github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 // indirect + github.com/gofrs/uuid v3.3.0+incompatible // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/google/cel-go v0.9.0 // indirect + github.com/google/gofuzz v1.1.0 // indirect + github.com/googleapis/gnostic v0.5.5 // indirect + github.com/gorilla/handlers v1.4.2 // indirect + github.com/gorilla/mux v1.7.2 // indirect + github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect + github.com/imdario/mergo v0.3.12 // indirect + github.com/inconshreveable/mousetrap v1.0.0 // indirect + github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/json-iterator/go v1.1.11 // indirect + github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0 // indirect + github.com/mailru/easyjson v0.7.6 // indirect + github.com/mattn/go-isatty v0.0.12 // indirect + github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect + github.com/mitchellh/go-wordwrap v1.0.0 // indirect + github.com/mitchellh/mapstructure v1.4.1 // indirect + github.com/moby/spdystream v0.2.0 // indirect + github.com/moby/term v0.0.0-20210610120745-9d4ed1856297 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.1 // indirect + github.com/morikuni/aec v0.0.0-20170113033406-39771216ff4c // indirect + github.com/nxadm/tail v1.4.8 // indirect + github.com/pelletier/go-toml v1.9.3 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/prometheus/client_golang v1.11.0 // indirect + github.com/prometheus/client_model v0.2.0 // indirect + github.com/prometheus/common v0.26.0 // indirect + github.com/prometheus/procfs v0.6.0 // indirect + github.com/russross/blackfriday v1.5.2 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/stoewer/go-strcase v1.2.0 // indirect + github.com/yvasiyarov/go-metrics v0.0.0-20150112132944-c25f46c4b940 // indirect + github.com/yvasiyarov/gorelic v0.0.7 // indirect + github.com/yvasiyarov/newrelic_platform_go v0.0.0-20160601141957-9c099fbc30e9 // indirect + go.opencensus.io v0.23.0 // indirect + go.opentelemetry.io/contrib v0.20.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.20.0 // indirect + go.opentelemetry.io/otel v0.20.0 // indirect + go.opentelemetry.io/otel/exporters/otlp v0.20.0 // indirect + go.opentelemetry.io/otel/metric v0.20.0 // indirect + go.opentelemetry.io/otel/sdk v0.20.0 // indirect + go.opentelemetry.io/otel/sdk/export/metric v0.20.0 // indirect + go.opentelemetry.io/otel/sdk/metric v0.20.0 // indirect + go.opentelemetry.io/otel/trace v0.20.0 // indirect + go.opentelemetry.io/proto/otlp v0.7.0 // indirect + golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2 // indirect + golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602 // indirect + golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 // indirect + golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d // indirect + golang.org/x/text v0.3.7 // indirect + golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect + golang.org/x/tools v0.1.5 // indirect + golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect + google.golang.org/appengine v1.6.7 // indirect + google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect + gopkg.in/warnings.v0 v0.1.2 // indirect + gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect + k8s.io/apiserver v0.22.1 // indirect + k8s.io/component-base v0.22.1 // indirect + k8s.io/klog/v2 v2.9.0 // indirect + k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e // indirect + k8s.io/utils v0.0.0-20210802155522-efc7438f0176 // indirect + sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.22 // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.1.2 // indirect +) + // latest tag resolves to a very old version. this is only used for spinning up local test registries replace github.com/docker/distribution => github.com/docker/distribution v0.0.0-20191216044856-a8371794149d diff --git a/staging/operator-registry/go.sum b/staging/operator-registry/go.sum index 10900d0923..f52c14730f 100644 --- a/staging/operator-registry/go.sum +++ b/staging/operator-registry/go.sum @@ -79,6 +79,8 @@ github.com/Shopify/logrus-bugsnag v0.0.0-20171204204709-577dee27f20d h1:UrqY+r/O github.com/Shopify/logrus-bugsnag v0.0.0-20171204204709-577dee27f20d/go.mod h1:HI8ITrYtUY+O+ZhtlqUnD8+KwNPOyugEhfP9fdUIaEQ= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= +github.com/adrg/xdg v0.4.0 h1:RzRqFcjH4nE5C6oTAxhBtoE2IRyjBSa62SCbyPidvls= +github.com/adrg/xdg v0.4.0/go.mod h1:N6ag73EX4wyxeaoeHctc1mas01KZgsj5tYiAIwqJE/E= github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7/go.mod h1:6zEj6s6u/ghQa61ZWa/C2Aw3RkjiTBOix7dkqa1VLIs= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= @@ -89,6 +91,7 @@ github.com/alessio/shellescape v1.4.1 h1:V7yhSDDn8LP4lc4jS8pFkt0zCnzVJlG5JXy9BVK github.com/alessio/shellescape v1.4.1/go.mod h1:PZAiSCk0LJaZkiCSkPv8qIobYglO3FPpyFjDCtHLS30= github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e h1:GCzyKMDDjSGnlpl3clrdAK7I1AaVoaiKDOYkUzChZzg= github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e/go.mod h1:F7bn7fEU90QkQ3tnmaTx3LTKLEDqnwWODIYppRQ5hnY= github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= @@ -204,8 +207,8 @@ github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZm github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no= github.com/dhui/dktest v0.3.0/go.mod h1:cyzIUfGsBEbZ6BT7tnXqAShHSXCZhSNmFl70sZ7c1yc= github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E= -github.com/docker/cli v0.0.0-20200130152716-5d0cf8839492 h1:FwssHbCDJD025h+BchanCwE1Q8fyMgqDr2mOQAWOLGw= -github.com/docker/cli v0.0.0-20200130152716-5d0cf8839492/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= +github.com/docker/cli v20.10.12+incompatible h1:lZlz0uzG+GH+c0plStMUdF/qk3ppmgnswpR5EbqzVGA= +github.com/docker/cli v20.10.12+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= github.com/docker/distribution v0.0.0-20191216044856-a8371794149d h1:jC8tT/S0OGx2cswpeUTn4gOIea8P08lD3VFQT0cOZ50= github.com/docker/distribution v0.0.0-20191216044856-a8371794149d/go.mod h1:0+TTO4EOBfRPhZXAeF1Vu+W3hHZ8eLp8PgKVZlcvtFY= github.com/docker/docker v0.7.3-0.20190103212154-2b7e084dc98b/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= @@ -381,6 +384,7 @@ github.com/golangplus/testing v0.0.0-20180327235837-af21d9c3145e/go.mod h1:0AA// github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.1/go.mod h1:xXMiIv4Fb/0kKde4SpL7qlzvu5cMJDRkFDxJfI9uaxA= +github.com/google/cel-go v0.9.0 h1:u1hg7lcZ/XWw2d3aV1jFS30ijQQ6q0/h1C2ZBeBD1gY= github.com/google/cel-go v0.9.0/go.mod h1:U7ayypeSkw23szu4GaQTPJGx66c20mx8JklMSxrmI1w= github.com/google/cel-spec v0.6.0/go.mod h1:Nwjgxy5CbjlPrtCWjeDjUyKMl8w41YBYGjsyDdqk0xA= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= @@ -560,8 +564,9 @@ github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHX github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/go-sqlite3 v1.10.0 h1:jbhqpg7tQe4SupckyijYiy0mJJ/pRyHvXf7JdWK860o= github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/mattn/go-sqlite3 v1.14.10 h1:MLn+5bFRlWMGoSRmJour3CL1w/qL96mvipqpwQW/Sfk= +github.com/mattn/go-sqlite3 v1.14.10/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= @@ -763,6 +768,7 @@ github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE= github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns= +github.com/stoewer/go-strcase v1.2.0 h1:Z2iHWqGXH00XYgqDmNgQbIBxf3wrNq0F3feEy0ainaU= github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -1082,8 +1088,9 @@ golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210817190340-bfb29a6856f2/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e h1:XMgFehsDnnLGtjvjOfqWSUzt0alpTR1RSEuznObga2c= golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 h1:2B5p2L5IfGiD7+b9BOoRMC6DgObAVZV+Fsp050NqXik= +golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE= diff --git a/staging/operator-registry/pkg/containertools/runner.go b/staging/operator-registry/pkg/containertools/runner.go index f178d8c5d6..660c92c6a6 100644 --- a/staging/operator-registry/pkg/containertools/runner.go +++ b/staging/operator-registry/pkg/containertools/runner.go @@ -130,10 +130,13 @@ func (r *ContainerCommandRunner) Unpack(image, src, dst string) error { r.logger.Infof("running %s create", r.containerTool) r.logger.Debugf("%s", command.Args) - out, err := command.CombinedOutput() + out, err := command.Output() if err != nil { - r.logger.Errorf(string(out)) - return fmt.Errorf("error creating container %s: %v", string(out), err) + msg := err.Error() + if exitErr, ok := err.(*exec.ExitError); ok { + msg = fmt.Sprintf("%s: %s", err, exitErr.Stderr) + } + return fmt.Errorf("error creating container %s: %s", string(out), msg) } id := strings.TrimSuffix(string(out), "\n") diff --git a/staging/operator-registry/pkg/image/buildahregistry/_options.go b/staging/operator-registry/pkg/image/buildahregistry/_options.go index c0e61fc15b..545db35af0 100644 --- a/staging/operator-registry/pkg/image/buildahregistry/_options.go +++ b/staging/operator-registry/pkg/image/buildahregistry/_options.go @@ -1,4 +1,6 @@ +//go:build ignore // +build ignore + package buildahregistry import ( diff --git a/staging/operator-registry/pkg/image/buildahregistry/_registry.go b/staging/operator-registry/pkg/image/buildahregistry/_registry.go index 9aa2750a7a..b6677715f1 100644 --- a/staging/operator-registry/pkg/image/buildahregistry/_registry.go +++ b/staging/operator-registry/pkg/image/buildahregistry/_registry.go @@ -1,4 +1,6 @@ +//go:build ignore // +build ignore + package buildahregistry import ( diff --git a/staging/operator-registry/pkg/image/containerdregistry/options.go b/staging/operator-registry/pkg/image/containerdregistry/options.go index de0be2f70d..569395feb1 100644 --- a/staging/operator-registry/pkg/image/containerdregistry/options.go +++ b/staging/operator-registry/pkg/image/containerdregistry/options.go @@ -21,7 +21,8 @@ type RegistryConfig struct { DBPath string CacheDir string PreserveCache bool - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool Roots *x509.CertPool } @@ -90,7 +91,7 @@ func NewRegistry(options ...RegistryOption) (registry *Registry, err error) { } var resolver remotes.Resolver - resolver, err = NewResolver(config.ResolverConfigDir, config.SkipTLS, config.Roots) + resolver, err = NewResolver(config.ResolverConfigDir, config.SkipTLSVerify, config.PlainHTTP, config.Roots) if err != nil { return } @@ -140,8 +141,14 @@ func PreserveCache(preserve bool) RegistryOption { } } -func SkipTLS(skip bool) RegistryOption { +func SkipTLSVerify(skip bool) RegistryOption { return func(config *RegistryConfig) { - config.SkipTLS = skip + config.SkipTLSVerify = skip + } +} + +func WithPlainHTTP(insecure bool) RegistryOption { + return func(config *RegistryConfig) { + config.PlainHTTP = insecure } } diff --git a/staging/operator-registry/pkg/image/containerdregistry/resolver.go b/staging/operator-registry/pkg/image/containerdregistry/resolver.go index 9ac771dde9..1f0698d2c7 100644 --- a/staging/operator-registry/pkg/image/containerdregistry/resolver.go +++ b/staging/operator-registry/pkg/image/containerdregistry/resolver.go @@ -5,8 +5,12 @@ import ( "crypto/x509" "net" "net/http" + "os" + "path/filepath" + "sync" "time" + "github.com/adrg/xdg" "github.com/containerd/containerd/remotes" "github.com/containerd/containerd/remotes/docker" "github.com/docker/cli/cli/config" @@ -15,7 +19,7 @@ import ( "github.com/docker/docker/registry" ) -func NewResolver(configDir string, insecure bool, roots *x509.CertPool) (remotes.Resolver, error) { +func NewResolver(configDir string, skipTlSVerify, plainHTTP bool, roots *x509.CertPool) (remotes.Resolver, error) { transport := &http.Transport{ Proxy: http.ProxyFromEnvironment, DialContext: (&net.Dialer{ @@ -32,9 +36,9 @@ func NewResolver(configDir string, insecure bool, roots *x509.CertPool) (remotes }, } - if insecure { + if plainHTTP || skipTlSVerify { transport.TLSClientConfig = &tls.Config{ - InsecureSkipVerify: insecure, + InsecureSkipVerify: true, } } headers := http.Header{} @@ -55,7 +59,7 @@ func NewResolver(configDir string, insecure bool, roots *x509.CertPool) (remotes )), docker.WithClient(client), } - if insecure { + if plainHTTP { regopts = append(regopts, docker.WithPlainHTTP(docker.MatchAllHosts)) } @@ -85,14 +89,39 @@ func credential(cfg *configfile.ConfigFile) func(string) (string, string, error) } } +// protects against a data race inside the docker CLI +// TODO: upstream issue for 20.10.x is tracked here https://github.com/docker/cli/pull/3410 +// newer versions already contain the fix +var configMutex sync.Mutex + func loadConfig(dir string) (*configfile.ConfigFile, error) { + configMutex.Lock() + defer configMutex.Unlock() + if dir == "" { dir = config.Dir() } - cfg, err := config.Load(dir) - if err != nil { - return nil, err + dockerConfigJSON := filepath.Join(dir, config.ConfigFileName) + cfg := configfile.New(dockerConfigJSON) + + switch _, err := os.Stat(dockerConfigJSON); { + case err == nil: + cfg, err = config.Load(dir) + if err != nil { + return cfg, err + } + case os.IsNotExist(err): + podmanConfig := filepath.Join(xdg.RuntimeDir, "containers/auth.json") + if file, err := os.Open(podmanConfig); err == nil { + defer file.Close() + cfg, err = config.LoadFromReader(file) + if err != nil { + return cfg, err + } + } else if !os.IsNotExist(err) { + return cfg, err + } } if !cfg.ContainsAuth() { diff --git a/staging/operator-registry/pkg/lib/bundle/exporter.go b/staging/operator-registry/pkg/lib/bundle/exporter.go index 53469f8682..be9f363120 100644 --- a/staging/operator-registry/pkg/lib/bundle/exporter.go +++ b/staging/operator-registry/pkg/lib/bundle/exporter.go @@ -30,7 +30,7 @@ func NewExporterForBundle(image, directory string, containerTool containertools. } } -func (i *BundleExporter) Export(skipTLS bool) error { +func (i *BundleExporter) Export(skipTLSVerify, plainHTTP bool) error { log := logrus.WithField("img", i.image) @@ -44,11 +44,16 @@ func (i *BundleExporter) Export(skipTLS bool) error { var rerr error switch i.containerTool { case containertools.NoneTool: - reg, rerr = containerdregistry.NewRegistry(containerdregistry.SkipTLS(skipTLS), containerdregistry.WithLog(log), containerdregistry.WithCacheDir(filepath.Join(tmpDir, "cacheDir"))) + reg, rerr = containerdregistry.NewRegistry( + containerdregistry.SkipTLSVerify(skipTLSVerify), + containerdregistry.WithPlainHTTP(plainHTTP), + containerdregistry.WithLog(log), + containerdregistry.WithCacheDir(filepath.Join(tmpDir, "cacheDir")), + ) case containertools.PodmanTool: fallthrough case containertools.DockerTool: - reg, rerr = execregistry.NewRegistry(i.containerTool, log, containertools.SkipTLS(skipTLS)) + reg, rerr = execregistry.NewRegistry(i.containerTool, log, containertools.SkipTLS(plainHTTP)) } if rerr != nil { return rerr diff --git a/staging/operator-registry/pkg/lib/bundle/exporter_test.go b/staging/operator-registry/pkg/lib/bundle/exporter_test.go index 7a3df6336d..6a94774979 100644 --- a/staging/operator-registry/pkg/lib/bundle/exporter_test.go +++ b/staging/operator-registry/pkg/lib/bundle/exporter_test.go @@ -9,10 +9,13 @@ import ( func TestExportForBundleWithBadImage(t *testing.T) { exporter := NewExporterForBundle("foo", "", containertools.DockerTool) - err := exporter.Export(true) + err := exporter.Export(true, false) + assert.Error(t, err) + + err = exporter.Export(false, true) assert.Error(t, err) exporter = NewExporterForBundle("foo", "", containertools.NoneTool) - err = exporter.Export(true) + err = exporter.Export(true, false) assert.Error(t, err) } diff --git a/staging/operator-registry/pkg/lib/bundle/validate.go b/staging/operator-registry/pkg/lib/bundle/validate.go index d7a96d11ca..fb8ca0368d 100644 --- a/staging/operator-registry/pkg/lib/bundle/validate.go +++ b/staging/operator-registry/pkg/lib/bundle/validate.go @@ -237,6 +237,8 @@ func validateDependencies(dependenciesFile *registry.DependenciesFile) []error { errs = dp.Validate() case registry.LabelDependency: errs = dp.Validate() + case registry.CelConstraint: + errs = dp.Validate() default: errs = append(errs, fmt.Errorf("unsupported dependency type %s", d.GetType())) } diff --git a/staging/operator-registry/pkg/lib/indexer/indexer.go b/staging/operator-registry/pkg/lib/indexer/indexer.go index 54eae4db1a..09b7340fab 100644 --- a/staging/operator-registry/pkg/lib/indexer/indexer.go +++ b/staging/operator-registry/pkg/lib/indexer/indexer.go @@ -63,7 +63,8 @@ type AddToIndexRequest struct { Tag string Mode pregistry.Mode CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool Overwrite bool EnableAlpha bool } @@ -76,7 +77,7 @@ func (i ImageIndexer) AddToIndex(request AddToIndexRequest) error { return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -87,7 +88,8 @@ func (i ImageIndexer) AddToIndex(request AddToIndexRequest) error { InputDatabase: databasePath, Permissive: request.Permissive, Mode: request.Mode, - SkipTLS: request.SkipTLS, + SkipTLSVerify: request.SkipTLSVerify, + PlainHTTP: request.PlainHTTP, ContainerTool: i.PullTool, Overwrite: request.Overwrite, EnableAlpha: request.EnableAlpha, @@ -129,7 +131,8 @@ type DeleteFromIndexRequest struct { OutDockerfile string Tag string Operators []string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool CaFile string } @@ -142,7 +145,7 @@ func (i ImageIndexer) DeleteFromIndex(request DeleteFromIndexRequest) error { return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -188,7 +191,8 @@ type PruneStrandedFromIndexRequest struct { OutDockerfile string Tag string CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool } // PruneStrandedFromIndex is an aggregate API used to generate a registry index image @@ -200,7 +204,7 @@ func (i ImageIndexer) PruneStrandedFromIndex(request PruneStrandedFromIndexReque return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -245,7 +249,8 @@ type PruneFromIndexRequest struct { Tag string Packages []string CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool } func (i ImageIndexer) PruneFromIndex(request PruneFromIndexRequest) error { @@ -255,7 +260,7 @@ func (i ImageIndexer) PruneFromIndex(request PruneFromIndexRequest) error { return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -294,14 +299,14 @@ func (i ImageIndexer) PruneFromIndex(request PruneFromIndexRequest) error { } // ExtractDatabase sets a temp directory for unpacking an image -func (i ImageIndexer) ExtractDatabase(buildDir, fromIndex, caFile string, skipTLS bool) (string, error) { +func (i ImageIndexer) ExtractDatabase(buildDir, fromIndex, caFile string, skipTLSVerify, plainHTTP bool) (string, error) { tmpDir, err := ioutil.TempDir("./", tmpDirPrefix) if err != nil { return "", err } defer os.RemoveAll(tmpDir) - databaseFile, err := i.getDatabaseFile(tmpDir, fromIndex, caFile, skipTLS) + databaseFile, err := i.getDatabaseFile(tmpDir, fromIndex, caFile, skipTLSVerify, plainHTTP) if err != nil { return "", err } @@ -309,7 +314,7 @@ func (i ImageIndexer) ExtractDatabase(buildDir, fromIndex, caFile string, skipTL return copyDatabaseTo(databaseFile, filepath.Join(buildDir, defaultDatabaseFolder)) } -func (i ImageIndexer) getDatabaseFile(workingDir, fromIndex, caFile string, skipTLS bool) (string, error) { +func (i ImageIndexer) getDatabaseFile(workingDir, fromIndex, caFile string, skipTLSVerify, plainHTTP bool) (string, error) { if fromIndex == "" { return path.Join(workingDir, defaultDatabaseFile), nil } @@ -325,11 +330,15 @@ func (i ImageIndexer) getDatabaseFile(workingDir, fromIndex, caFile string, skip if err != nil { return "", fmt.Errorf("failed to get RootCAs: %v", err) } - reg, rerr = containerdregistry.NewRegistry(containerdregistry.SkipTLS(skipTLS), containerdregistry.WithLog(i.Logger), containerdregistry.WithRootCAs(rootCAs)) + reg, rerr = containerdregistry.NewRegistry( + containerdregistry.SkipTLSVerify(skipTLSVerify), + containerdregistry.WithPlainHTTP(plainHTTP), + containerdregistry.WithLog(i.Logger), + containerdregistry.WithRootCAs(rootCAs)) case containertools.PodmanTool: fallthrough case containertools.DockerTool: - reg, rerr = execregistry.NewRegistry(i.PullTool, i.Logger, containertools.SkipTLS(skipTLS)) + reg, rerr = execregistry.NewRegistry(i.PullTool, i.Logger, containertools.SkipTLS(plainHTTP)) } if rerr != nil { return "", rerr @@ -481,7 +490,8 @@ type ExportFromIndexRequest struct { DownloadPath string ContainerTool containertools.ContainerTool CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool } // ExportFromIndex is an aggregate API used to specify operators from @@ -495,7 +505,7 @@ func (i ImageIndexer) ExportFromIndex(request ExportFromIndexRequest) error { defer os.RemoveAll(workingDir) // extract the index database to the file - databaseFile, err := i.getDatabaseFile(workingDir, request.Index, request.CaFile, request.SkipTLS) + databaseFile, err := i.getDatabaseFile(workingDir, request.Index, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -549,7 +559,7 @@ func (i ImageIndexer) ExportFromIndex(request ExportFromIndexRequest) error { bundleDir.bundleVersion = strconv.Itoa(rand.Intn(10000)) } exporter := bundle.NewExporterForBundle(bundleImage, filepath.Join(request.DownloadPath, bundleDir.pkgName, bundleDir.bundleVersion), request.ContainerTool) - if err := exporter.Export(request.SkipTLS); err != nil { + if err := exporter.Export(request.SkipTLSVerify, request.PlainHTTP); err != nil { err = fmt.Errorf("exporting bundle image:%s failed with %s", bundleImage, err) mu.Lock() errs = append(errs, err) @@ -651,7 +661,8 @@ type DeprecateFromIndexRequest struct { Bundles []string Tag string CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool AllowPackageRemoval bool } @@ -664,7 +675,7 @@ func (i ImageIndexer) DeprecateFromIndex(request DeprecateFromIndexRequest) erro return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } diff --git a/staging/operator-registry/pkg/lib/registry/registry.go b/staging/operator-registry/pkg/lib/registry/registry.go index 9ed73940e1..5f73196308 100644 --- a/staging/operator-registry/pkg/lib/registry/registry.go +++ b/staging/operator-registry/pkg/lib/registry/registry.go @@ -24,7 +24,8 @@ type RegistryUpdater struct { type AddToRegistryRequest struct { Permissive bool - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool CaFile string InputDatabase string Bundles []string @@ -66,11 +67,15 @@ func (r RegistryUpdater) AddToRegistry(request AddToRegistryRequest) error { if err != nil { return fmt.Errorf("failed to get RootCAs: %v", err) } - reg, rerr = containerdregistry.NewRegistry(containerdregistry.SkipTLS(request.SkipTLS), containerdregistry.WithRootCAs(rootCAs)) + reg, rerr = containerdregistry.NewRegistry( + containerdregistry.SkipTLSVerify(request.SkipTLSVerify), + containerdregistry.WithPlainHTTP(request.PlainHTTP), + containerdregistry.WithRootCAs(rootCAs), + ) case containertools.PodmanTool: fallthrough case containertools.DockerTool: - reg, rerr = execregistry.NewRegistry(request.ContainerTool, r.Logger, containertools.SkipTLS(request.SkipTLS)) + reg, rerr = execregistry.NewRegistry(request.ContainerTool, r.Logger, containertools.SkipTLS(request.PlainHTTP)) } if rerr != nil { return rerr diff --git a/staging/operator-registry/pkg/registry/types.go b/staging/operator-registry/pkg/registry/types.go index d7d2585520..cc44e55978 100644 --- a/staging/operator-registry/pkg/registry/types.go +++ b/staging/operator-registry/pkg/registry/types.go @@ -8,6 +8,7 @@ import ( "strings" "github.com/blang/semver/v4" + "github.com/operator-framework/api/pkg/constraints" ) var ( @@ -55,6 +56,7 @@ const ( DeprecatedType = "olm.deprecated" LabelType = "olm.label" PropertyKey = "olm.properties" + ConstraintType = "olm.constraint" ) // APIKey stores GroupVersionKind for use as map keys @@ -220,6 +222,16 @@ type LabelDependency struct { Label string `json:"label" yaml:"label"` } +type CelConstraint struct { + // Constraint failure message that surfaces in resolution + // This field is optional + FailureMessage string `json:"failureMessage" yaml:"failureMessage"` + + // The cel struct that contraints CEL expression + // This field is required + Cel *constraints.Cel `json:"cel" yaml:"cel"` +} + type GVKProperty struct { // The group of GVK based property Group string `json:"group" yaml:"group"` @@ -289,6 +301,25 @@ func (pd *PackageDependency) Validate() []error { return errs } +// Validate will validate constraint type and return error(s) +func (cc *CelConstraint) Validate() []error { + errs := []error{} + if cc.Cel == nil { + errs = append(errs, fmt.Errorf("The CEL field is missing")) + } else { + if cc.Cel.Rule == "" { + errs = append(errs, fmt.Errorf("The CEL expression is missing")) + return errs + } + validator := constraints.NewCelEnvironment() + _, err := validator.Validate(cc.Cel.Rule) + if err != nil { + errs = append(errs, fmt.Errorf("Invalid CEL expression: %s", err.Error())) + } + } + return errs +} + // GetDependencies returns the list of dependency func (d *DependenciesFile) GetDependencies() []*Dependency { var dependencies []*Dependency @@ -329,6 +360,13 @@ func (e *Dependency) GetTypeValue() interface{} { return nil } return dep + case ConstraintType: + dep := CelConstraint{} + err := json.Unmarshal([]byte(e.GetValue()), &dep) + if err != nil { + return nil + } + return dep } return nil } diff --git a/staging/operator-registry/pkg/registry/types_test.go b/staging/operator-registry/pkg/registry/types_test.go new file mode 100644 index 0000000000..c74275dde3 --- /dev/null +++ b/staging/operator-registry/pkg/registry/types_test.go @@ -0,0 +1,65 @@ +package registry + +import ( + "encoding/json" + "fmt" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestCelConstraintValidation(t *testing.T) { + tests := []struct { + name string + constraint string + errs []error + }{ + { + name: "ValidCelConstraint", + constraint: `{"cel":{"rule":"properties.exists(p, p.type == 'olm.test' && (semver_compare(p.value, '1.0.0') == 0))"}}`, + }, + { + name: "InvalidCelConstraint/MissingCel", + constraint: `{}`, + errs: []error{ + fmt.Errorf("The CEL field is missing"), + }, + }, + { + name: "InvalidCelConstraint/MissingRule", + constraint: `{"cel":{"rule":""}}`, + errs: []error{ + fmt.Errorf("The CEL expression is missing"), + }, + }, + { + name: "InvalidCelConstraint/NotExistedFunc", + constraint: `{"cel":{"rule":"properties.exists(p, p.type == 'olm.test' && (doesnt_exist(p.value, '1.0.0') == 0))"}}`, + errs: []error{ + fmt.Errorf("Invalid CEL expression"), + }, + }, + { + name: "InvalidCelExpression/NonBoolReturn", + constraint: `{"cel":{"rule":"1"}}`, + errs: []error{ + fmt.Errorf("Invalid CEL expression"), + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var dep CelConstraint + err := json.Unmarshal([]byte(tt.constraint), &dep) + assert.NoError(t, err) + errs := dep.Validate() + if len(tt.errs) > 0 { + assert.Error(t, errs[0]) + assert.Contains(t, errs[0].Error(), tt.errs[0].Error()) + } else { + assert.Equal(t, len(errs), 0) + } + }) + } +} diff --git a/staging/operator-registry/pkg/sqlite/load.go b/staging/operator-registry/pkg/sqlite/load.go index 47540b1811..197b5861ed 100644 --- a/staging/operator-registry/pkg/sqlite/load.go +++ b/staging/operator-registry/pkg/sqlite/load.go @@ -957,6 +957,9 @@ func (s *sqlLoader) RemovePackage(packageName string) error { if err != nil { return err } + if len(csvNames) == 0 { + return fmt.Errorf("no package found for packagename %s", packageName) + } for _, csvName := range csvNames { if err := s.rmBundle(tx, csvName); err != nil { return err diff --git a/staging/operator-registry/pkg/sqlite/remove_test.go b/staging/operator-registry/pkg/sqlite/remove_test.go index 2d60c77598..18b22924f6 100644 --- a/staging/operator-registry/pkg/sqlite/remove_test.go +++ b/staging/operator-registry/pkg/sqlite/remove_test.go @@ -76,6 +76,10 @@ func TestRemover(t *testing.T) { _, err = query.GetPackage(context.TODO(), "prometheus") require.EqualError(t, err, "package prometheus not found") + // delete prometheus again + err = store.RemovePackage("prometheus") + require.EqualError(t, err, "no package found for packagename prometheus") + // no apis after all packages are removed rows, err = db.QueryContext(context.TODO(), "select * from api") require.NoError(t, err) diff --git a/staging/operator-registry/registry.Dockerfile b/staging/operator-registry/registry.Dockerfile index 6d36bbf3e5..0a5f26cd5c 100644 --- a/staging/operator-registry/registry.Dockerfile +++ b/staging/operator-registry/registry.Dockerfile @@ -1,4 +1,4 @@ -FROM golang:1.16-alpine as builder +FROM golang:1.17-alpine as builder RUN apk update && apk add sqlite build-base git mercurial bash WORKDIR /build diff --git a/staging/operator-registry/release/goreleaser.darwin.yaml b/staging/operator-registry/release/goreleaser.darwin.yaml new file mode 100644 index 0000000000..b600710406 --- /dev/null +++ b/staging/operator-registry/release/goreleaser.darwin.yaml @@ -0,0 +1,49 @@ +builds: + - id: darwin-amd64 + main: ./cmd/opm + binary: opm + goos: + - darwin + goarch: + - amd64 + env: + - CGO_ENABLED=1 + mod_timestamp: "{{ .CommitTimestamp }}" + flags: &build-flags + - -tags=json1 + asmflags: &build-asmflags + - all=-trimpath={{ .Env.PWD }} + gcflags: &build-gcflags + - all=-trimpath={{ .Env.PWD }} + ldflags: &build-ldflags + - -s -w + - -X {{ .Env.PKG }}/cmd/opm/version.gitCommit={{ .Env.GIT_COMMIT }} + - -X {{ .Env.PKG }}/cmd/opm/version.opmVersion={{ .Env.OPM_VERSION }} + - -X {{ .Env.PKG }}/cmd/opm/version.buildDate={{ .Env.BUILD_DATE }} + - id: darwin-arm64 + main: ./cmd/opm + binary: opm + goos: + - darwin + goarch: + - arm64 + env: + - CGO_ENABLED=1 + mod_timestamp: "{{ .CommitTimestamp }}" + flags: *build-flags + asmflags: *build-asmflags + gcflags: *build-gcflags + ldflags: *build-ldflags +archives: + - id: opm + builds: + - darwin-amd64 + - darwin-arm64 + format: binary + name_template: "{{ .Os }}-{{ .Arch }}-{{ .Binary }}" +checksum: + name_template: 'checksums.txt' +snapshot: + name_template: "{{ .Env.OPM_VERSION }}" +release: + disable: true diff --git a/staging/operator-registry/.goreleaser.yaml b/staging/operator-registry/release/goreleaser.linux.yaml similarity index 81% rename from staging/operator-registry/.goreleaser.yaml rename to staging/operator-registry/release/goreleaser.linux.yaml index a50dfba12e..2f69f8dd57 100644 --- a/staging/operator-registry/.goreleaser.yaml +++ b/staging/operator-registry/release/goreleaser.linux.yaml @@ -67,49 +67,6 @@ builds: asmflags: *build-asmflags gcflags: *build-gcflags ldflags: *build-ldflags - - id: windows-amd64 - main: ./cmd/opm - binary: opm - goos: - - windows - goarch: - - amd64 - env: - - CC=x86_64-w64-mingw32-gcc-posix - - CGO_ENABLED=1 - mod_timestamp: "{{ .CommitTimestamp }}" - flags: *build-flags - asmflags: *build-asmflags - gcflags: *build-gcflags - ldflags: *build-ldflags - - id: darwin-amd64 - main: ./cmd/opm - binary: opm - goos: - - darwin - goarch: - - amd64 - env: - - CC=o64-clang - mod_timestamp: "{{ .CommitTimestamp }}" - flags: *build-flags - asmflags: *build-asmflags - gcflags: *build-gcflags - ldflags: *build-ldflags - - id: darwin-arm64 - main: ./cmd/opm - binary: opm - goos: - - darwin - goarch: - - arm64 - env: - - CC=oa64e-clang - mod_timestamp: "{{ .CommitTimestamp }}" - flags: *build-flags - asmflags: *build-asmflags - gcflags: *build-gcflags - ldflags: *build-ldflags archives: - id: opm builds: @@ -117,11 +74,8 @@ archives: - linux-arm64 - linux-ppc64le - linux-s390x - - windows-amd64 - - darwin-amd64 - - darwin-arm64 - name_template: "{{ .Binary }}_{{ .Env.OPM_VERSION }}_{{ .Os }}_{{ .Arch }}" format: binary + name_template: "{{ .Os }}-{{ .Arch }}-{{ .Binary }}" dockers: - image_templates: - "{{ .Env.OPM_IMAGE_REPO }}:{{ .Env.IMAGE_TAG }}-amd64" @@ -197,5 +151,4 @@ checksum: snapshot: name_template: "{{ .Env.OPM_VERSION }}" release: - name_template: "{{ .Env.OPM_VERSION }}" - draft: true + disable: true diff --git a/staging/operator-registry/release/goreleaser.opm.Dockerfile b/staging/operator-registry/release/goreleaser.opm.Dockerfile index 51637d34b6..50e90df28e 100644 --- a/staging/operator-registry/release/goreleaser.opm.Dockerfile +++ b/staging/operator-registry/release/goreleaser.opm.Dockerfile @@ -2,15 +2,9 @@ # build opm images. See the configurations in .goreleaser.yaml # and .github/workflows/release.yaml. -FROM alpine as grpc_health_probe -ARG TARGETARCH -RUN apk update && \ - apk add curl && \ - curl --silent --show-error --location --output /grpc_health_probe \ - https://github.com/grpc-ecosystem/grpc-health-probe/releases/download/v0.4.5/grpc_health_probe-linux-$TARGETARCH && \ - chmod 755 /grpc_health_probe +FROM ghcr.io/grpc-ecosystem/grpc-health-probe:v0.4.6 as grpc_health_probe FROM gcr.io/distroless/static:debug -COPY --from=grpc_health_probe /grpc_health_probe /bin/grpc_health_probe +COPY --from=grpc_health_probe /ko-app/grpc-health-probe /bin/grpc_health_probe COPY ["nsswitch.conf", "/etc/nsswitch.conf"] COPY opm /bin/opm ENTRYPOINT ["/bin/opm"] diff --git a/staging/operator-registry/release/goreleaser.windows.yaml b/staging/operator-registry/release/goreleaser.windows.yaml new file mode 100644 index 0000000000..4232f5eeac --- /dev/null +++ b/staging/operator-registry/release/goreleaser.windows.yaml @@ -0,0 +1,35 @@ +builds: + - id: windows-amd64 + main: ./cmd/opm + binary: opm + goos: + - windows + goarch: + - amd64 + env: + - CGO_ENABLED=1 + mod_timestamp: "{{ .CommitTimestamp }}" + flags: &build-flags + - -tags=json1,netgo,osusergo + asmflags: &build-asmflags + - all=-trimpath={{ .Env.PWD }} + gcflags: &build-gcflags + - all=-trimpath={{ .Env.PWD }} + ldflags: &build-ldflags + - -s -w + - -extldflags=-static + - -X {{ .Env.PKG }}/cmd/opm/version.gitCommit={{ .Env.GIT_COMMIT }} + - -X {{ .Env.PKG }}/cmd/opm/version.opmVersion={{ .Env.OPM_VERSION }} + - -X {{ .Env.PKG }}/cmd/opm/version.buildDate={{ .Env.BUILD_DATE }} +archives: + - id: opm + builds: + - windows-amd64 + format: binary + name_template: "{{ .Os }}-{{ .Arch }}-{{ .Binary }}" +checksum: + name_template: 'checksums.txt' +snapshot: + name_template: "{{ .Env.OPM_VERSION }}" +release: + disable: true diff --git a/staging/operator-registry/scripts/fetch b/staging/operator-registry/scripts/fetch index ac383f67d2..3a5b8dabae 100755 --- a/staging/operator-registry/scripts/fetch +++ b/staging/operator-registry/scripts/fetch @@ -15,7 +15,7 @@ fetch() { ;; "goreleaser") ver_cmd="${ROOT}/bin/goreleaser --version 2>/dev/null | grep 'goreleaser version' | cut -d' ' -f3" - fetch_cmd="curl -sSfL https://install.goreleaser.com/github.com/goreleaser/goreleaser.sh | sh -s -- -b \"${ROOT}/bin\" -d \"v${ver}\"" + fetch_cmd="GOBIN=${ROOT}/bin go install github.com/goreleaser/goreleaser@v${ver}" ;; *) echo "unknown tool $tool" diff --git a/staging/operator-registry/test/e2e/ctx/provisioner_kind.go b/staging/operator-registry/test/e2e/ctx/provisioner_kind.go index 3145e9cee3..c50c69d2d5 100644 --- a/staging/operator-registry/test/e2e/ctx/provisioner_kind.go +++ b/staging/operator-registry/test/e2e/ctx/provisioner_kind.go @@ -1,3 +1,4 @@ +//go:build kind // +build kind package ctx diff --git a/staging/operator-registry/test/e2e/ctx/provisioner_kubeconfig.go b/staging/operator-registry/test/e2e/ctx/provisioner_kubeconfig.go index fa3a6eec3a..1ce1980d71 100644 --- a/staging/operator-registry/test/e2e/ctx/provisioner_kubeconfig.go +++ b/staging/operator-registry/test/e2e/ctx/provisioner_kubeconfig.go @@ -1,3 +1,4 @@ +//go:build !kind // +build !kind package ctx diff --git a/staging/operator-registry/test/e2e/e2e_suite_test.go b/staging/operator-registry/test/e2e/e2e_suite_test.go index d8736d868f..3f4852e854 100644 --- a/staging/operator-registry/test/e2e/e2e_suite_test.go +++ b/staging/operator-registry/test/e2e/e2e_suite_test.go @@ -27,7 +27,8 @@ var ( // opm command under test. opm *cobra.Command - skipTLSForRegistry = flag.Bool("skip-tls", false, "skip TLS certificate verification for container image registries while pulling bundles or index") + skipTLSForRegistry = flag.Bool("skip-tls-verify", false, "skip TLS certificate verification for container image registries while pulling bundles or index") + useHTTPforRegistry = flag.Bool("use-http", false, "use HTTP for container image registries while pulling bundles or index") ) func TestE2E(t *testing.T) { diff --git a/staging/operator-registry/test/e2e/opm_test.go b/staging/operator-registry/test/e2e/opm_test.go index f0598a0eb0..600d16c55c 100644 --- a/staging/operator-registry/test/e2e/opm_test.go +++ b/staging/operator-registry/test/e2e/opm_test.go @@ -108,7 +108,8 @@ func buildIndexWith(containerTool, fromIndexImage, toIndexImage string, bundleIm Bundles: bundleImages, Permissive: false, Overwrite: overwriteLatest, - SkipTLS: *skipTLSForRegistry, + SkipTLSVerify: *skipTLSForRegistry, + PlainHTTP: *useHTTPforRegistry, } return indexAdder.AddToIndex(request) @@ -169,7 +170,8 @@ func exportPackageWith(containerTool string) error { Packages: packages, DownloadPath: "downloaded", ContainerTool: containertools.NewContainerTool(containerTool, containertools.NoneTool), - SkipTLS: *skipTLSForRegistry, + SkipTLSVerify: *skipTLSForRegistry, + PlainHTTP: *useHTTPforRegistry, } return indexExporter.ExportFromIndex(request) @@ -185,7 +187,8 @@ func exportIndexImageWith(containerTool string) error { Packages: []string{}, DownloadPath: "downloaded", ContainerTool: containertools.NewContainerTool(containerTool, containertools.NoneTool), - SkipTLS: *skipTLSForRegistry, + SkipTLSVerify: *skipTLSForRegistry, + PlainHTTP: *useHTTPforRegistry, } return indexExporter.ExportFromIndex(request) @@ -426,7 +429,7 @@ var _ = Describe("opm", func() { PullTool: tool, Logger: logger, } - dbFile, err := imageIndexer.ExtractDatabase(".", publishedIndex, "", true) + dbFile, err := imageIndexer.ExtractDatabase(".", publishedIndex, "", *skipTLSForRegistry, *useHTTPforRegistry) Expect(err).NotTo(HaveOccurred(), "error extracting registry db") db, err := sql.Open("sqlite3", fmt.Sprintf("file:%s", dbFile)) @@ -460,7 +463,8 @@ var _ = Describe("opm", func() { request := lregistry.AddToRegistryRequest{ Permissive: false, - SkipTLS: *skipTLSForRegistry, + SkipTLSVerify: *skipTLSForRegistry, + PlainHTTP: *useHTTPforRegistry, InputDatabase: dbFile, Bundles: []string{ch.Head.BundlePath}, Mode: registry.ReplacesMode, diff --git a/staging/operator-registry/tools.go b/staging/operator-registry/tools.go index 9f6bea3e40..242800e30c 100644 --- a/staging/operator-registry/tools.go +++ b/staging/operator-registry/tools.go @@ -1,3 +1,4 @@ +//go:build tools // +build tools package tools diff --git a/staging/operator-registry/upstream-builder.Dockerfile b/staging/operator-registry/upstream-builder.Dockerfile index 45e4179828..d5f3a94d2c 100644 --- a/staging/operator-registry/upstream-builder.Dockerfile +++ b/staging/operator-registry/upstream-builder.Dockerfile @@ -1,4 +1,4 @@ -FROM golang:1.16-alpine as builder +FROM golang:1.17-alpine as builder RUN apk update && apk add sqlite build-base git mercurial bash WORKDIR /build diff --git a/staging/operator-registry/upstream-opm-builder.Dockerfile b/staging/operator-registry/upstream-opm-builder.Dockerfile index ba8ca75b6a..be87fb2140 100644 --- a/staging/operator-registry/upstream-opm-builder.Dockerfile +++ b/staging/operator-registry/upstream-opm-builder.Dockerfile @@ -3,7 +3,7 @@ ## GoReleaser to build and push multi-arch images for opm ## -FROM quay.io/operator-framework/golang:1.16-alpine AS builder +FROM quay.io/operator-framework/golang:1.17-alpine AS builder RUN apk update && apk add sqlite build-base git mercurial bash WORKDIR /build diff --git a/values.yaml b/values.yaml index 15da97f70b..701fe3683f 100644 --- a/values.yaml +++ b/values.yaml @@ -38,7 +38,7 @@ olm: memory: 160Mi catalog: replicaCount: 1 - opmImageArgs: -opmImage=quay.io/operator-framework/configmap-operator-registry:latest + opmImageArgs: --opmImage=quay.io/operator-framework/configmap-operator-registry:latest image: ref: quay.io/operator-framework/olm@sha256:de396b540b82219812061d0d753440d5655250c621c753ed1dc67d6154741607 pullPolicy: IfNotPresent diff --git a/vendor/github.com/adrg/xdg/CODE_OF_CONDUCT.md b/vendor/github.com/adrg/xdg/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000..75349e53ee --- /dev/null +++ b/vendor/github.com/adrg/xdg/CODE_OF_CONDUCT.md @@ -0,0 +1,77 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, +body size, disability, ethnicity, sex characteristics, gender identity and +expression, level of experience, education, socio-economic status, nationality, +personal appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behaviour that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behaviour by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behaviour and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behaviour. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviour that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behaviour may be +reported by contacting the project team at adrg@epistack.com. All complaints +will be reviewed and investigated and will result in a response that is deemed +necessary and appropriate to the circumstances. The project team is obligated to +maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 1.4, available at +https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq diff --git a/vendor/github.com/adrg/xdg/CONTRIBUTING.md b/vendor/github.com/adrg/xdg/CONTRIBUTING.md new file mode 100644 index 0000000000..006f146b38 --- /dev/null +++ b/vendor/github.com/adrg/xdg/CONTRIBUTING.md @@ -0,0 +1,135 @@ +# Contributing to this project + +Contributions in the form of pull requests, issues or just general feedback, +are always welcome. Please take a moment to review this document in order to +make the contribution process easy and effective for everyone involved. + +Following these guidelines helps to communicate that you respect the time of +the developers managing and developing this open source project. In return, +they should reciprocate that respect in addressing your issue or assessing +patches and features. + +## Using the issue tracker + +The issue tracker is the preferred channel for [bug reports](#bugs), +[features requests](#features) and [submitting pull +requests](#pull-requests), but please respect the following restrictions: + +* Please **do not** use the issue tracker for personal support requests (use + [Stack Overflow](http://stackoverflow.com) or IRC). +* Please **do not** derail or troll issues. Keep the discussion on topic and + respect the opinions of others. + + +## Bug reports + +A bug is a _demonstrable problem_ that is caused by the code in the repository. +Good bug reports are extremely helpful - thank you! + +Guidelines for bug reports: + +1. **Use the GitHub issue search** — check if the issue has already been + reported. +2. **Check if the issue has been fixed** — try to reproduce it using the + latest `master` or development branch in the repository. +3. **Isolate the problem** — create a reduced test case. + +A good bug report shouldn't leave others needing to chase you up for more +information. Please try to be as detailed as possible in your report. What is +your environment? What steps will reproduce the issue? What browser(s) and OS +experience the problem? What would you expect to be the outcome? All these +details will help people to fix any potential bugs. + +Example: + +> Short and descriptive example bug report title +> +> A summary of the issue and the browser/OS environment in which it occurs. If +> suitable, include the steps required to reproduce the bug. +> +> 1. This is the first step +> 2. This is the second step +> 3. Further steps, etc. +> +> `` - a link to the reduced test case +> +> Any other information you want to share that is relevant to the issue being +> reported. This might include the lines of code that you have identified as +> causing the bug, and potential solutions (and your opinions on their +> merits). + + + +## Feature requests + +Feature requests are welcome. But take a moment to find out whether your idea +fits with the scope and aims of the project. It's up to *you* to make a strong +case to convince the project's developers of the merits of this feature. Please +provide as much detail and context as possible. + + + +## Pull requests + +Good pull requests - patches, improvements, new features - are a fantastic +help. They should remain focused in scope and avoid containing unrelated +commits. + +**Please ask first** before embarking on any significant pull request (e.g. +implementing features, refactoring code, porting to a different language), +otherwise you risk spending a lot of time working on something that the +project's developers might not want to merge into the project. + +Please adhere to the coding conventions used throughout a project (indentation, +accurate comments, etc.) and any other requirements (such as test coverage). + +Follow this process if you'd like your work considered for inclusion in the +project: + +1. [Fork](http://help.github.com/fork-a-repo/) the project, clone your fork, + and configure the remotes: + + ```bash + # Clone your fork of the repo into the current directory + git clone https://github.com// + # Navigate to the newly cloned directory + cd + # Assign the original repo to a remote called "upstream" + git remote add upstream https://github.com// + ``` + +2. If you cloned a while ago, get the latest changes from upstream: + + ```bash + git checkout + git pull upstream + ``` + +3. Create a new topic branch (off the main project development branch) to + contain your feature, change, or fix: + + ```bash + git checkout -b + ``` + +4. Commit your changes in logical chunks and use descriptive commit messages. + Use [interactive rebase](https://help.github.com/articles/interactive-rebase) + to tidy up your commits before making them public. + +5. Locally merge (or rebase) the upstream development branch into your topic branch: + + ```bash + git pull [--rebase] upstream + ``` + +6. Push your topic branch up to your fork: + + ```bash + git push origin + ``` + +7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/) + with a clear title and description. + +**IMPORTANT**: By submitting a patch, you agree to allow the project owner to +license your work under the same license as that used by the project. diff --git a/vendor/github.com/adrg/xdg/LICENSE b/vendor/github.com/adrg/xdg/LICENSE new file mode 100644 index 0000000000..7307e1b7c8 --- /dev/null +++ b/vendor/github.com/adrg/xdg/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Adrian-George Bostan + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/vendor/github.com/adrg/xdg/README.md b/vendor/github.com/adrg/xdg/README.md new file mode 100644 index 0000000000..b55403c27c --- /dev/null +++ b/vendor/github.com/adrg/xdg/README.md @@ -0,0 +1,280 @@ +

+
+ xdg logo +
+

+ +

Go implementation of the XDG Base Directory Specification and XDG user directories.

+ +

+ + Build status + + + Code coverage + + + pkg.go.dev documentation + + + MIT license + +
+ + Go report card + + + Awesome Go + + + GitHub contributors + + + GitHub open issues + + + Buy me a coffee + +

+ +Provides an implementation of the [XDG Base Directory Specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html). +The specification defines a set of standard paths for storing application files, +including data and configuration files. For portability and flexibility reasons, +applications should use the XDG defined locations instead of hardcoding paths. +The package also includes the locations of well known [user directories](https://wiki.archlinux.org/index.php/XDG_user_directories), as well as +other common directories such as fonts and applications. + +The current implementation supports **most flavors of Unix**, **Windows**, **macOS** and **Plan 9**. +On Windows, where XDG environment variables are not usually set, the package uses [Known Folders](https://docs.microsoft.com/en-us/windows/win32/shell/known-folders) +as defaults. Therefore, appropriate locations are used for common [folders](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid) which may have been redirected. + +See usage [examples](#usage) below. Full documentation can be found at https://pkg.go.dev/github.com/adrg/xdg. + +## Installation + go get github.com/adrg/xdg + +## Default locations + +The package defines sensible defaults for XDG variables which are empty or not +present in the environment. + +- On Unix-like operating systems, XDG environment variables are tipically defined. +Appropriate default locations are used for the environment variables which are not set. +- On Windows, XDG environment variables are usually not set. If that is the case, +the package relies on the appropriate [Known Folders](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid). +Sensible fallback locations are used for the folders which are not set. + +### XDG Base Directory + +
+ Unix-like operating systems +
+ +| |

Unix

|

macOS

|

Plan 9

| +| :------------------------------------------------------------: | :-----------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------: | +| XDG_DATA_HOME | ~/.local/share | ~/Library/Application Support | $home/lib | +| XDG_DATA_DIRS | /usr/local/share
/usr/share | /Library/Application Support | /lib | +| XDG_CONFIG_HOME | ~/.config | ~/Library/Application Support | $home/lib | +| XDG_CONFIG_DIRS | /etc/xdg | ~/Library/Preferences
/Library/Application Support
/Library/Preferences | /lib | +| XDG_STATE_HOME | ~/.local/state | ~/Library/Application Support | $home/lib/state | +| XDG_CACHE_HOME | ~/.cache | ~/Library/Caches | $home/lib/cache | +| XDG_RUNTIME_DIR | /run/user/UID | ~/Library/Application Support | /tmp | + +
+ +
+ Microsoft Windows +
+ +| |

Known Folder(s)

|

Fallback(s)

| +| :------------------------------------------------------------: | :---------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------: | +| XDG_DATA_HOME | LocalAppData | %LOCALAPPDATA% | +| XDG_DATA_DIRS | RoamingAppData
ProgramData | %APPADATA%
%ProgramData% | +| XDG_CONFIG_HOME | LocalAppData | %LOCALAPPDATA% | +| XDG_CONFIG_DIRS | ProgramData
RoamingAppData | %ProgramData%
%APPDATA% | +| XDG_STATE_HOME | LocalAppData | %LOCALAPPDATA% | +| XDG_CACHE_HOME | LocalAppData\cache | %LOCALAPPDATA%\cache | +| XDG_RUNTIME_DIR | LocalAppData | %LOCALAPPDATA% | + +
+ +### XDG user directories + +
+ Unix-like operating systems +
+ +| |

Unix

|

macOS

|

Plan 9

| +| :--------------------------------------------------------------: | :-------------------------------------------------------------------------: | :---------------------------------------------------------------------------: | :---------------------------------------------------------------------------: | +| XDG_DESKTOP_DIR | ~/Desktop | ~/Desktop | $home/desktop | +| XDG_DOWNLOAD_DIR | ~/Downloads | ~/Downloads | $home/downloads | +| XDG_DOCUMENTS_DIR | ~/Documents | ~/Documents | $home/documents | +| XDG_MUSIC_DIR | ~/Music | ~/Music | $home/music | +| XDG_PICTURES_DIR | ~/Pictures | ~/Pictures | $home/pictures | +| XDG_VIDEOS_DIR | ~/Videos | ~/Movies | $home/videos | +| XDG_TEMPLATES_DIR | ~/Templates | ~/Templates | $home/templates | +| XDG_PUBLICSHARE_DIR | ~/Public | ~/Public | $home/public | + +
+ +
+ Microsoft Windows +
+ +| |

Known Folder(s)

|

Fallback(s)

| +| :--------------------------------------------------------------: | :-----------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | +| XDG_DESKTOP_DIR | Desktop | %USERPROFILE%\Desktop | +| XDG_DOWNLOAD_DIR | Downloads | %USERPROFILE%\Downloads | +| XDG_DOCUMENTS_DIR | Documents | %USERPROFILE%\Documents | +| XDG_MUSIC_DIR | Music | %USERPROFILE%\Music | +| XDG_PICTURES_DIR | Pictures | %USERPROFILE%\Pictures | +| XDG_VIDEOS_DIR | Videos | %USERPROFILE%\Videos | +| XDG_TEMPLATES_DIR | Templates | %APPDATA%\Microsoft\Windows\Templates | +| XDG_PUBLICSHARE_DIR | Public | %PUBLIC% | + +
+ +### Other directories + +
+ Unix-like operating systems +
+ +| |

Unix

|

macOS

|

Plan 9

| +| :-----------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------: | +| Home | $HOME | $HOME | $home | +| Applications | $XDG_DATA_HOME/applications
~/.local/share/applications
/usr/local/share/applications
/usr/share/applications
$XDG_DATA_DIRS/applications | /Applications | $home/bin
/bin | +| Fonts | $XDG_DATA_HOME/fonts
~/.fonts
~/.local/share/fonts
/usr/local/share/fonts
/usr/share/fonts
$XDG_DATA_DIRS/fonts | ~/Library/Fonts
/Library/Fonts
/System/Library/Fonts
/Network/Library/Fonts | $home/lib/font
/lib/font | + +
+ +
+ Microsoft Windows +
+ +| |

Known Folder(s)

|

Fallback(s)

| +| :-----------------------------------------------------------: | :--------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------: | +| Home | Profile | %USERPROFILE% | +| Applications | Programs
CommonPrograms | %APPDATA%\Microsoft\Windows\Start Menu\Programs
%ProgramData%\Microsoft\Windows\Start Menu\Programs | +| Fonts | Fonts
- | %SystemRoot%\Fonts
%LOCALAPPDATA%\Microsoft\Windows\Fonts | + +
+ +## Usage + +#### XDG Base Directory + +```go +package main + +import ( + "log" + + "github.com/adrg/xdg" +) + +func main() { + // XDG Base Directory paths. + log.Println("Home data directory:", xdg.DataHome) + log.Println("Data directories:", xdg.DataDirs) + log.Println("Home config directory:", xdg.ConfigHome) + log.Println("Config directories:", xdg.ConfigDirs) + log.Println("Home state directory:", xdg.StateHome) + log.Println("Cache directory:", xdg.CacheHome) + log.Println("Runtime directory:", xdg.RuntimeDir) + + // Other common directories. + log.Println("Home directory:", xdg.Home) + log.Println("Application directories:", xdg.ApplicationDirs) + log.Println("Font directories:", xdg.FontDirs) + + // Obtain a suitable location for application config files. + // ConfigFile takes one parameter which must contain the name of the file, + // but it can also contain a set of parent directories. If the directories + // don't exist, they will be created relative to the base config directory. + configFilePath, err := xdg.ConfigFile("appname/config.yaml") + if err != nil { + log.Fatal(err) + } + log.Println("Save the config file at:", configFilePath) + + // For other types of application files use: + // xdg.DataFile() + // xdg.StateFile() + // xdg.CacheFile() + // xdg.RuntimeFile() + + // Finding application config files. + // SearchConfigFile takes one parameter which must contain the name of + // the file, but it can also contain a set of parent directories relative + // to the config search paths (xdg.ConfigHome and xdg.ConfigDirs). + configFilePath, err = xdg.SearchConfigFile("appname/config.yaml") + if err != nil { + log.Fatal(err) + } + log.Println("Config file was found at:", configFilePath) + + // For other types of application files use: + // xdg.SearchDataFile() + // xdg.SearchStateFile() + // xdg.SearchCacheFile() + // xdg.SearchRuntimeFile() +} +``` + +#### XDG user directories + +```go +package main + +import ( + "log" + + "github.com/adrg/xdg" +) + +func main() { + // XDG user directories. + log.Println("Desktop directory:", xdg.UserDirs.Desktop) + log.Println("Download directory:", xdg.UserDirs.Download) + log.Println("Documents directory:", xdg.UserDirs.Documents) + log.Println("Music directory:", xdg.UserDirs.Music) + log.Println("Pictures directory:", xdg.UserDirs.Pictures) + log.Println("Videos directory:", xdg.UserDirs.Videos) + log.Println("Templates directory:", xdg.UserDirs.Templates) + log.Println("Public directory:", xdg.UserDirs.PublicShare) +} +``` + +## Stargazers over time + +[![Stargazers over time](https://starchart.cc/adrg/xdg.svg)](https://starchart.cc/adrg/xdg) + +## Contributing + +Contributions in the form of pull requests, issues or just general feedback, +are always welcome. +See [CONTRIBUTING.MD](CONTRIBUTING.md). + +**Contributors**: +[adrg](https://github.com/adrg), +[wichert](https://github.com/wichert), +[bouncepaw](https://github.com/bouncepaw), +[gabriel-vasile](https://github.com/gabriel-vasile), +[KalleDK](https://github.com/KalleDK), +[nvkv](https://github.com/nvkv), +[djdv](https://github.com/djdv). + +## References + +For more information see: +* [XDG Base Directory Specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html) +* [XDG user directories](https://wiki.archlinux.org/index.php/XDG_user_directories) +* [Windows Known Folders](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid) + +## License + +Copyright (c) 2014 Adrian-George Bostan. + +This project is licensed under the [MIT license](https://opensource.org/licenses/MIT). +See [LICENSE](LICENSE) for more details. diff --git a/vendor/github.com/adrg/xdg/base_dirs.go b/vendor/github.com/adrg/xdg/base_dirs.go new file mode 100644 index 0000000000..a8a3fd55cc --- /dev/null +++ b/vendor/github.com/adrg/xdg/base_dirs.go @@ -0,0 +1,68 @@ +package xdg + +import "github.com/adrg/xdg/internal/pathutil" + +// XDG Base Directory environment variables. +const ( + envDataHome = "XDG_DATA_HOME" + envDataDirs = "XDG_DATA_DIRS" + envConfigHome = "XDG_CONFIG_HOME" + envConfigDirs = "XDG_CONFIG_DIRS" + envStateHome = "XDG_STATE_HOME" + envCacheHome = "XDG_CACHE_HOME" + envRuntimeDir = "XDG_RUNTIME_DIR" +) + +type baseDirectories struct { + dataHome string + data []string + configHome string + config []string + stateHome string + cacheHome string + runtime string + + // Non-standard directories. + fonts []string + applications []string +} + +func (bd baseDirectories) dataFile(relPath string) (string, error) { + return pathutil.Create(relPath, append([]string{bd.dataHome}, bd.data...)) +} + +func (bd baseDirectories) configFile(relPath string) (string, error) { + return pathutil.Create(relPath, append([]string{bd.configHome}, bd.config...)) +} + +func (bd baseDirectories) stateFile(relPath string) (string, error) { + return pathutil.Create(relPath, []string{bd.stateHome}) +} + +func (bd baseDirectories) cacheFile(relPath string) (string, error) { + return pathutil.Create(relPath, []string{bd.cacheHome}) +} + +func (bd baseDirectories) runtimeFile(relPath string) (string, error) { + return pathutil.Create(relPath, []string{bd.runtime}) +} + +func (bd baseDirectories) searchDataFile(relPath string) (string, error) { + return pathutil.Search(relPath, append([]string{bd.dataHome}, bd.data...)) +} + +func (bd baseDirectories) searchConfigFile(relPath string) (string, error) { + return pathutil.Search(relPath, append([]string{bd.configHome}, bd.config...)) +} + +func (bd baseDirectories) searchStateFile(relPath string) (string, error) { + return pathutil.Search(relPath, []string{bd.stateHome}) +} + +func (bd baseDirectories) searchCacheFile(relPath string) (string, error) { + return pathutil.Search(relPath, []string{bd.cacheHome}) +} + +func (bd baseDirectories) searchRuntimeFile(relPath string) (string, error) { + return pathutil.Search(relPath, []string{bd.runtime}) +} diff --git a/vendor/github.com/adrg/xdg/codecov.yml b/vendor/github.com/adrg/xdg/codecov.yml new file mode 100644 index 0000000000..54ee338fd7 --- /dev/null +++ b/vendor/github.com/adrg/xdg/codecov.yml @@ -0,0 +1,11 @@ +coverage: + status: + project: + default: + target: 90% + threshold: 1% + patch: + default: + target: 100% +ignore: + - "paths_plan9.go" diff --git a/vendor/github.com/adrg/xdg/doc.go b/vendor/github.com/adrg/xdg/doc.go new file mode 100644 index 0000000000..7747b183e4 --- /dev/null +++ b/vendor/github.com/adrg/xdg/doc.go @@ -0,0 +1,99 @@ +/* +Package xdg provides an implementation of the XDG Base Directory Specification. +The specification defines a set of standard paths for storing application files +including data and configuration files. For portability and flexibility reasons, +applications should use the XDG defined locations instead of hardcoding paths. +The package also includes the locations of well known user directories. + +The current implementation supports most flavors of Unix, Windows, Mac OS and Plan 9. + + For more information regarding the XDG Base Directory Specification see: + https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html + + For more information regarding the XDG user directories see: + https://wiki.archlinux.org/index.php/XDG_user_directories + + For more information regarding the Windows Known Folders see: + https://docs.microsoft.com/en-us/windows/win32/shell/known-folders + +Usage + +XDG Base Directory + package main + + import ( + "log" + + "github.com/adrg/xdg" + ) + + func main() { + // XDG Base Directory paths. + log.Println("Home data directory:", xdg.DataHome) + log.Println("Data directories:", xdg.DataDirs) + log.Println("Home config directory:", xdg.ConfigHome) + log.Println("Config directories:", xdg.ConfigDirs) + log.Println("Home state directory:", xdg.StateHome) + log.Println("Cache directory:", xdg.CacheHome) + log.Println("Runtime directory:", xdg.RuntimeDir) + + // Other common directories. + log.Println("Home directory:", xdg.Home) + log.Println("Application directories:", xdg.ApplicationDirs) + log.Println("Font directories:", xdg.FontDirs) + + // Obtain a suitable location for application config files. + // ConfigFile takes one parameter which must contain the name of the file, + // but it can also contain a set of parent directories. If the directories + // don't exist, they will be created relative to the base config directory. + configFilePath, err := xdg.ConfigFile("appname/config.yaml") + if err != nil { + log.Fatal(err) + } + log.Println("Save the config file at:", configFilePath) + + // For other types of application files use: + // xdg.DataFile() + // xdg.StateFile() + // xdg.CacheFile() + // xdg.RuntimeFile() + + // Finding application config files. + // SearchConfigFile takes one parameter which must contain the name of + // the file, but it can also contain a set of parent directories relative + // to the config search paths (xdg.ConfigHome and xdg.ConfigDirs). + configFilePath, err = xdg.SearchConfigFile("appname/config.yaml") + if err != nil { + log.Fatal(err) + } + log.Println("Config file was found at:", configFilePath) + + // For other types of application files use: + // xdg.SearchDataFile() + // xdg.SearchStateFile() + // xdg.SearchCacheFile() + // xdg.SearchRuntimeFile() + } + +XDG user directories + package main + + import ( + "log" + + "github.com/adrg/xdg" + ) + + func main() { + // XDG user directories. + log.Println("Desktop directory:", xdg.UserDirs.Desktop) + log.Println("Download directory:", xdg.UserDirs.Download) + log.Println("Documents directory:", xdg.UserDirs.Documents) + log.Println("Music directory:", xdg.UserDirs.Music) + log.Println("Pictures directory:", xdg.UserDirs.Pictures) + log.Println("Videos directory:", xdg.UserDirs.Videos) + log.Println("Templates directory:", xdg.UserDirs.Templates) + log.Println("Public directory:", xdg.UserDirs.PublicShare) + } +*/ +package xdg diff --git a/vendor/github.com/adrg/xdg/go.mod b/vendor/github.com/adrg/xdg/go.mod new file mode 100644 index 0000000000..34f07e087b --- /dev/null +++ b/vendor/github.com/adrg/xdg/go.mod @@ -0,0 +1,8 @@ +module github.com/adrg/xdg + +go 1.14 + +require ( + github.com/stretchr/testify v1.7.0 + golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 +) diff --git a/vendor/github.com/adrg/xdg/go.sum b/vendor/github.com/adrg/xdg/go.sum new file mode 100644 index 0000000000..f6e94d193e --- /dev/null +++ b/vendor/github.com/adrg/xdg/go.sum @@ -0,0 +1,13 @@ +github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 h1:2B5p2L5IfGiD7+b9BOoRMC6DgObAVZV+Fsp050NqXik= +golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/vendor/github.com/adrg/xdg/internal/pathutil/pathutil.go b/vendor/github.com/adrg/xdg/internal/pathutil/pathutil.go new file mode 100644 index 0000000000..7422342b3c --- /dev/null +++ b/vendor/github.com/adrg/xdg/internal/pathutil/pathutil.go @@ -0,0 +1,78 @@ +package pathutil + +import ( + "fmt" + "os" + "path/filepath" + "strings" +) + +// Unique eliminates the duplicate paths from the provided slice and returns +// the result. The items in the output slice are in the order in which they +// occur in the input slice. If a `home` location is provided, the paths are +// expanded using the `ExpandHome` function. +func Unique(paths []string, home string) []string { + var ( + uniq []string + registry = map[string]struct{}{} + ) + + for _, p := range paths { + p = ExpandHome(p, home) + if p != "" && filepath.IsAbs(p) { + if _, ok := registry[p]; ok { + continue + } + + registry[p] = struct{}{} + uniq = append(uniq, p) + } + } + + return uniq +} + +// Create returns a suitable location relative to which the file with the +// specified `name` can be written. The first path from the provided `paths` +// slice which is successfully created (or already exists) is used as a base +// path for the file. The `name` parameter should contain the name of the file +// which is going to be written in the location returned by this function, but +// it can also contain a set of parent directories, which will be created +// relative to the selected parent path. +func Create(name string, paths []string) (string, error) { + var searchedPaths []string + for _, p := range paths { + p = filepath.Join(p, name) + + dir := filepath.Dir(p) + if Exists(dir) { + return p, nil + } + if err := os.MkdirAll(dir, os.ModeDir|0700); err == nil { + return p, nil + } + + searchedPaths = append(searchedPaths, dir) + } + + return "", fmt.Errorf("could not create any of the following paths: %s", + strings.Join(searchedPaths, ", ")) +} + +// Search searches for the file with the specified `name` in the provided +// slice of `paths`. The `name` parameter must contain the name of the file, +// but it can also contain a set of parent directories. +func Search(name string, paths []string) (string, error) { + var searchedPaths []string + for _, p := range paths { + p = filepath.Join(p, name) + if Exists(p) { + return p, nil + } + + searchedPaths = append(searchedPaths, filepath.Dir(p)) + } + + return "", fmt.Errorf("could not locate `%s` in any of the following paths: %s", + filepath.Base(name), strings.Join(searchedPaths, ", ")) +} diff --git a/vendor/github.com/adrg/xdg/internal/pathutil/pathutil_plan9.go b/vendor/github.com/adrg/xdg/internal/pathutil/pathutil_plan9.go new file mode 100644 index 0000000000..8ee4e8d2fb --- /dev/null +++ b/vendor/github.com/adrg/xdg/internal/pathutil/pathutil_plan9.go @@ -0,0 +1,29 @@ +package pathutil + +import ( + "os" + "path/filepath" + "strings" +) + +// Exists returns true if the specified path exists. +func Exists(path string) bool { + _, err := os.Stat(path) + return err == nil || os.IsExist(err) +} + +// ExpandHome substitutes `~` and `$home` at the start of the specified +// `path` using the provided `home` location. +func ExpandHome(path, home string) string { + if path == "" || home == "" { + return path + } + if path[0] == '~' { + return filepath.Join(home, path[1:]) + } + if strings.HasPrefix(path, "$home") { + return filepath.Join(home, path[5:]) + } + + return path +} diff --git a/vendor/github.com/adrg/xdg/internal/pathutil/pathutil_unix.go b/vendor/github.com/adrg/xdg/internal/pathutil/pathutil_unix.go new file mode 100644 index 0000000000..a014c66ef6 --- /dev/null +++ b/vendor/github.com/adrg/xdg/internal/pathutil/pathutil_unix.go @@ -0,0 +1,32 @@ +//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || nacl || linux || netbsd || openbsd || solaris +// +build aix darwin dragonfly freebsd js,wasm nacl linux netbsd openbsd solaris + +package pathutil + +import ( + "os" + "path/filepath" + "strings" +) + +// Exists returns true if the specified path exists. +func Exists(path string) bool { + _, err := os.Stat(path) + return err == nil || os.IsExist(err) +} + +// ExpandHome substitutes `~` and `$HOME` at the start of the specified +// `path` using the provided `home` location. +func ExpandHome(path, home string) string { + if path == "" || home == "" { + return path + } + if path[0] == '~' { + return filepath.Join(home, path[1:]) + } + if strings.HasPrefix(path, "$HOME") { + return filepath.Join(home, path[5:]) + } + + return path +} diff --git a/vendor/github.com/adrg/xdg/internal/pathutil/pathutil_windows.go b/vendor/github.com/adrg/xdg/internal/pathutil/pathutil_windows.go new file mode 100644 index 0000000000..44080e3ab6 --- /dev/null +++ b/vendor/github.com/adrg/xdg/internal/pathutil/pathutil_windows.go @@ -0,0 +1,64 @@ +package pathutil + +import ( + "os" + "path/filepath" + "strings" + + "golang.org/x/sys/windows" +) + +// Exists returns true if the specified path exists. +func Exists(path string) bool { + fi, err := os.Lstat(path) + if fi != nil && fi.Mode()&os.ModeSymlink != 0 { + _, err = filepath.EvalSymlinks(path) + } + + return err == nil || os.IsExist(err) +} + +// ExpandHome substitutes `%USERPROFILE%` at the start of the specified +// `path` using the provided `home` location. +func ExpandHome(path, home string) string { + if path == "" || home == "" { + return path + } + if strings.HasPrefix(path, `%USERPROFILE%`) { + return filepath.Join(home, path[13:]) + } + + return path +} + +// KnownFolder returns the location of the folder with the specified ID. +// If that fails, the folder location is determined by reading the provided +// environment variables (the first non-empty read value is returned). +// If that fails as well, the first non-empty fallback is returned. +// If all of the above fails, the function returns an empty string. +func KnownFolder(id *windows.KNOWNFOLDERID, envVars []string, fallbacks []string) string { + if id != nil { + flags := []uint32{windows.KF_FLAG_DEFAULT, windows.KF_FLAG_DEFAULT_PATH} + for _, flag := range flags { + p, _ := windows.KnownFolderPath(id, flag|windows.KF_FLAG_DONT_VERIFY) + if p != "" { + return p + } + } + } + + for _, envVar := range envVars { + p := os.Getenv(envVar) + if p != "" { + return p + } + } + + for _, fallback := range fallbacks { + if fallback != "" { + return fallback + } + } + + return "" +} diff --git a/vendor/github.com/adrg/xdg/paths_darwin.go b/vendor/github.com/adrg/xdg/paths_darwin.go new file mode 100644 index 0000000000..bfe9ad9bc4 --- /dev/null +++ b/vendor/github.com/adrg/xdg/paths_darwin.go @@ -0,0 +1,60 @@ +package xdg + +import ( + "os" + "path/filepath" +) + +func homeDir() string { + if home := os.Getenv("HOME"); home != "" { + return home + } + + return "/" +} + +func initDirs(home string) { + initBaseDirs(home) + initUserDirs(home) +} + +func initBaseDirs(home string) { + homeAppSupport := filepath.Join(home, "Library", "Application Support") + rootAppSupport := "/Library/Application Support" + + // Initialize standard directories. + baseDirs.dataHome = xdgPath(envDataHome, homeAppSupport) + baseDirs.data = xdgPaths(envDataDirs, rootAppSupport) + baseDirs.configHome = xdgPath(envConfigHome, homeAppSupport) + baseDirs.config = xdgPaths(envConfigDirs, + filepath.Join(home, "Library", "Preferences"), + rootAppSupport, + "/Library/Preferences", + ) + baseDirs.stateHome = xdgPath(envStateHome, homeAppSupport) + baseDirs.cacheHome = xdgPath(envCacheHome, filepath.Join(home, "Library", "Caches")) + baseDirs.runtime = xdgPath(envRuntimeDir, homeAppSupport) + + // Initialize non-standard directories. + baseDirs.applications = []string{ + "/Applications", + } + + baseDirs.fonts = []string{ + filepath.Join(home, "Library/Fonts"), + "/Library/Fonts", + "/System/Library/Fonts", + "/Network/Library/Fonts", + } +} + +func initUserDirs(home string) { + UserDirs.Desktop = xdgPath(envDesktopDir, filepath.Join(home, "Desktop")) + UserDirs.Download = xdgPath(envDownloadDir, filepath.Join(home, "Downloads")) + UserDirs.Documents = xdgPath(envDocumentsDir, filepath.Join(home, "Documents")) + UserDirs.Music = xdgPath(envMusicDir, filepath.Join(home, "Music")) + UserDirs.Pictures = xdgPath(envPicturesDir, filepath.Join(home, "Pictures")) + UserDirs.Videos = xdgPath(envVideosDir, filepath.Join(home, "Movies")) + UserDirs.Templates = xdgPath(envTemplatesDir, filepath.Join(home, "Templates")) + UserDirs.PublicShare = xdgPath(envPublicShareDir, filepath.Join(home, "Public")) +} diff --git a/vendor/github.com/adrg/xdg/paths_plan9.go b/vendor/github.com/adrg/xdg/paths_plan9.go new file mode 100644 index 0000000000..2882f688b3 --- /dev/null +++ b/vendor/github.com/adrg/xdg/paths_plan9.go @@ -0,0 +1,55 @@ +package xdg + +import ( + "os" + "path/filepath" +) + +func homeDir() string { + if home := os.Getenv("home"); home != "" { + return home + } + + return "/" +} + +func initDirs(home string) { + initBaseDirs(home) + initUserDirs(home) +} + +func initBaseDirs(home string) { + homeLibDir := filepath.Join(home, "lib") + rootLibDir := "/lib" + + // Initialize standard directories. + baseDirs.dataHome = xdgPath(envDataHome, homeLibDir) + baseDirs.data = xdgPaths(envDataDirs, rootLibDir) + baseDirs.configHome = xdgPath(envConfigHome, homeLibDir) + baseDirs.config = xdgPaths(envConfigDirs, rootLibDir) + baseDirs.stateHome = xdgPath(envStateHome, filepath.Join(homeLibDir, "state")) + baseDirs.cacheHome = xdgPath(envCacheHome, filepath.Join(homeLibDir, "cache")) + baseDirs.runtime = xdgPath(envRuntimeDir, "/tmp") + + // Initialize non-standard directories. + baseDirs.applications = []string{ + filepath.Join(home, "bin"), + "/bin", + } + + baseDirs.fonts = []string{ + filepath.Join(homeLibDir, "font"), + "/lib/font", + } +} + +func initUserDirs(home string) { + UserDirs.Desktop = xdgPath(envDesktopDir, filepath.Join(home, "desktop")) + UserDirs.Download = xdgPath(envDownloadDir, filepath.Join(home, "downloads")) + UserDirs.Documents = xdgPath(envDocumentsDir, filepath.Join(home, "documents")) + UserDirs.Music = xdgPath(envMusicDir, filepath.Join(home, "music")) + UserDirs.Pictures = xdgPath(envPicturesDir, filepath.Join(home, "pictures")) + UserDirs.Videos = xdgPath(envVideosDir, filepath.Join(home, "videos")) + UserDirs.Templates = xdgPath(envTemplatesDir, filepath.Join(home, "templates")) + UserDirs.PublicShare = xdgPath(envPublicShareDir, filepath.Join(home, "public")) +} diff --git a/vendor/github.com/adrg/xdg/paths_unix.go b/vendor/github.com/adrg/xdg/paths_unix.go new file mode 100644 index 0000000000..ad571dfc81 --- /dev/null +++ b/vendor/github.com/adrg/xdg/paths_unix.go @@ -0,0 +1,71 @@ +//go:build aix || dragonfly || freebsd || (js && wasm) || nacl || linux || netbsd || openbsd || solaris +// +build aix dragonfly freebsd js,wasm nacl linux netbsd openbsd solaris + +package xdg + +import ( + "os" + "path/filepath" + "strconv" + + "github.com/adrg/xdg/internal/pathutil" +) + +func homeDir() string { + if home := os.Getenv("HOME"); home != "" { + return home + } + + return "/" +} + +func initDirs(home string) { + initBaseDirs(home) + initUserDirs(home) +} + +func initBaseDirs(home string) { + // Initialize standard directories. + baseDirs.dataHome = xdgPath(envDataHome, filepath.Join(home, ".local", "share")) + baseDirs.data = xdgPaths(envDataDirs, "/usr/local/share", "/usr/share") + baseDirs.configHome = xdgPath(envConfigHome, filepath.Join(home, ".config")) + baseDirs.config = xdgPaths(envConfigDirs, "/etc/xdg") + baseDirs.stateHome = xdgPath(envStateHome, filepath.Join(home, ".local", "state")) + baseDirs.cacheHome = xdgPath(envCacheHome, filepath.Join(home, ".cache")) + baseDirs.runtime = xdgPath(envRuntimeDir, filepath.Join("/run/user", strconv.Itoa(os.Getuid()))) + + // Initialize non-standard directories. + appDirs := []string{ + filepath.Join(baseDirs.dataHome, "applications"), + filepath.Join(home, ".local/share/applications"), + "/usr/local/share/applications", + "/usr/share/applications", + } + + fontDirs := []string{ + filepath.Join(baseDirs.dataHome, "fonts"), + filepath.Join(home, ".fonts"), + filepath.Join(home, ".local/share/fonts"), + "/usr/local/share/fonts", + "/usr/share/fonts", + } + + for _, dir := range baseDirs.data { + appDirs = append(appDirs, filepath.Join(dir, "applications")) + fontDirs = append(fontDirs, filepath.Join(dir, "fonts")) + } + + baseDirs.applications = pathutil.Unique(appDirs, Home) + baseDirs.fonts = pathutil.Unique(fontDirs, Home) +} + +func initUserDirs(home string) { + UserDirs.Desktop = xdgPath(envDesktopDir, filepath.Join(home, "Desktop")) + UserDirs.Download = xdgPath(envDownloadDir, filepath.Join(home, "Downloads")) + UserDirs.Documents = xdgPath(envDocumentsDir, filepath.Join(home, "Documents")) + UserDirs.Music = xdgPath(envMusicDir, filepath.Join(home, "Music")) + UserDirs.Pictures = xdgPath(envPicturesDir, filepath.Join(home, "Pictures")) + UserDirs.Videos = xdgPath(envVideosDir, filepath.Join(home, "Videos")) + UserDirs.Templates = xdgPath(envTemplatesDir, filepath.Join(home, "Templates")) + UserDirs.PublicShare = xdgPath(envPublicShareDir, filepath.Join(home, "Public")) +} diff --git a/vendor/github.com/adrg/xdg/paths_windows.go b/vendor/github.com/adrg/xdg/paths_windows.go new file mode 100644 index 0000000000..722d3e7856 --- /dev/null +++ b/vendor/github.com/adrg/xdg/paths_windows.go @@ -0,0 +1,168 @@ +package xdg + +import ( + "path/filepath" + + "github.com/adrg/xdg/internal/pathutil" + "golang.org/x/sys/windows" +) + +func homeDir() string { + return pathutil.KnownFolder( + windows.FOLDERID_Profile, + []string{"USERPROFILE"}, + nil, + ) +} + +func initDirs(home string) { + kf := initKnownFolders(home) + initBaseDirs(home, kf) + initUserDirs(home, kf) +} + +func initBaseDirs(home string, kf *knownFolders) { + // Initialize standard directories. + baseDirs.dataHome = xdgPath(envDataHome, kf.localAppData) + baseDirs.data = xdgPaths(envDataDirs, kf.roamingAppData, kf.programData) + baseDirs.configHome = xdgPath(envConfigHome, kf.localAppData) + baseDirs.config = xdgPaths(envConfigDirs, kf.programData, kf.roamingAppData) + baseDirs.stateHome = xdgPath(envStateHome, kf.localAppData) + baseDirs.cacheHome = xdgPath(envCacheHome, filepath.Join(kf.localAppData, "cache")) + baseDirs.runtime = xdgPath(envRuntimeDir, kf.localAppData) + + // Initialize non-standard directories. + baseDirs.applications = []string{ + kf.programs, + kf.commonPrograms, + } + baseDirs.fonts = []string{ + kf.fonts, + filepath.Join(kf.localAppData, "Microsoft", "Windows", "Fonts"), + } +} + +func initUserDirs(home string, kf *knownFolders) { + UserDirs.Desktop = xdgPath(envDesktopDir, kf.desktop) + UserDirs.Download = xdgPath(envDownloadDir, kf.downloads) + UserDirs.Documents = xdgPath(envDocumentsDir, kf.documents) + UserDirs.Music = xdgPath(envMusicDir, kf.music) + UserDirs.Pictures = xdgPath(envPicturesDir, kf.pictures) + UserDirs.Videos = xdgPath(envVideosDir, kf.videos) + UserDirs.Templates = xdgPath(envTemplatesDir, kf.templates) + UserDirs.PublicShare = xdgPath(envPublicShareDir, kf.public) +} + +type knownFolders struct { + systemDrive string + systemRoot string + programData string + userProfile string + userProfiles string + roamingAppData string + localAppData string + desktop string + downloads string + documents string + music string + pictures string + videos string + templates string + public string + fonts string + programs string + commonPrograms string +} + +func initKnownFolders(home string) *knownFolders { + kf := &knownFolders{ + userProfile: home, + } + kf.systemDrive = filepath.VolumeName(pathutil.KnownFolder( + windows.FOLDERID_Windows, + []string{"SystemDrive", "SystemRoot", "windir"}, + []string{home, `C:`}, + )) + string(filepath.Separator) + kf.systemRoot = pathutil.KnownFolder( + windows.FOLDERID_Windows, + []string{"SystemRoot", "windir"}, + []string{filepath.Join(kf.systemDrive, "Windows")}, + ) + kf.programData = pathutil.KnownFolder( + windows.FOLDERID_ProgramData, + []string{"ProgramData", "ALLUSERSPROFILE"}, + []string{filepath.Join(kf.systemDrive, "ProgramData")}, + ) + kf.userProfiles = pathutil.KnownFolder( + windows.FOLDERID_UserProfiles, + nil, + []string{filepath.Join(kf.systemDrive, "Users")}, + ) + kf.roamingAppData = pathutil.KnownFolder( + windows.FOLDERID_RoamingAppData, + []string{"APPDATA"}, + []string{filepath.Join(home, "AppData", "Roaming")}, + ) + kf.localAppData = pathutil.KnownFolder( + windows.FOLDERID_LocalAppData, + []string{"LOCALAPPDATA"}, + []string{filepath.Join(home, "AppData", "Local")}, + ) + kf.desktop = pathutil.KnownFolder( + windows.FOLDERID_Desktop, + nil, + []string{filepath.Join(home, "Desktop")}, + ) + kf.downloads = pathutil.KnownFolder( + windows.FOLDERID_Downloads, + nil, + []string{filepath.Join(home, "Downloads")}, + ) + kf.documents = pathutil.KnownFolder( + windows.FOLDERID_Documents, + nil, + []string{filepath.Join(home, "Documents")}, + ) + kf.music = pathutil.KnownFolder( + windows.FOLDERID_Music, + nil, + []string{filepath.Join(home, "Music")}, + ) + kf.pictures = pathutil.KnownFolder( + windows.FOLDERID_Pictures, + nil, + []string{filepath.Join(home, "Pictures")}, + ) + kf.videos = pathutil.KnownFolder( + windows.FOLDERID_Videos, + nil, + []string{filepath.Join(home, "Videos")}, + ) + kf.templates = pathutil.KnownFolder( + windows.FOLDERID_Templates, + nil, + []string{filepath.Join(kf.roamingAppData, "Microsoft", "Windows", "Templates")}, + ) + kf.public = pathutil.KnownFolder( + windows.FOLDERID_Public, + []string{"PUBLIC"}, + []string{filepath.Join(kf.userProfiles, "Public")}, + ) + kf.fonts = pathutil.KnownFolder( + windows.FOLDERID_Fonts, + nil, + []string{filepath.Join(kf.systemRoot, "Fonts")}, + ) + kf.programs = pathutil.KnownFolder( + windows.FOLDERID_Programs, + nil, + []string{filepath.Join(kf.roamingAppData, "Microsoft", "Windows", "Start Menu", "Programs")}, + ) + kf.commonPrograms = pathutil.KnownFolder( + windows.FOLDERID_CommonPrograms, + nil, + []string{filepath.Join(kf.programData, "Microsoft", "Windows", "Start Menu", "Programs")}, + ) + + return kf +} diff --git a/vendor/github.com/adrg/xdg/user_dirs.go b/vendor/github.com/adrg/xdg/user_dirs.go new file mode 100644 index 0000000000..72088748d0 --- /dev/null +++ b/vendor/github.com/adrg/xdg/user_dirs.go @@ -0,0 +1,40 @@ +package xdg + +// XDG user directories environment variables. +const ( + envDesktopDir = "XDG_DESKTOP_DIR" + envDownloadDir = "XDG_DOWNLOAD_DIR" + envDocumentsDir = "XDG_DOCUMENTS_DIR" + envMusicDir = "XDG_MUSIC_DIR" + envPicturesDir = "XDG_PICTURES_DIR" + envVideosDir = "XDG_VIDEOS_DIR" + envTemplatesDir = "XDG_TEMPLATES_DIR" + envPublicShareDir = "XDG_PUBLICSHARE_DIR" +) + +// UserDirectories defines the locations of well known user directories. +type UserDirectories struct { + // Desktop defines the location of the user's desktop directory. + Desktop string + + // Download defines a suitable location for user downloaded files. + Download string + + // Documents defines a suitable location for user document files. + Documents string + + // Music defines a suitable location for user audio files. + Music string + + // Pictures defines a suitable location for user image files. + Pictures string + + // VideosDir defines a suitable location for user video files. + Videos string + + // Templates defines a suitable location for user template files. + Templates string + + // PublicShare defines a suitable location for user shared files. + PublicShare string +} diff --git a/vendor/github.com/adrg/xdg/xdg.go b/vendor/github.com/adrg/xdg/xdg.go new file mode 100644 index 0000000000..3d33ca6e55 --- /dev/null +++ b/vendor/github.com/adrg/xdg/xdg.go @@ -0,0 +1,218 @@ +package xdg + +import ( + "os" + "path/filepath" + + "github.com/adrg/xdg/internal/pathutil" +) + +var ( + // Home contains the path of the user's home directory. + Home string + + // DataHome defines the base directory relative to which user-specific + // data files should be stored. This directory is defined by the + // $XDG_DATA_HOME environment variable. If the variable is not set, + // a default equal to $HOME/.local/share should be used. + DataHome string + + // DataDirs defines the preference-ordered set of base directories to + // search for data files in addition to the DataHome base directory. + // This set of directories is defined by the $XDG_DATA_DIRS environment + // variable. If the variable is not set, the default directories + // to be used are /usr/local/share and /usr/share, in that order. The + // DataHome directory is considered more important than any of the + // directories defined by DataDirs. Therefore, user data files should be + // written relative to the DataHome directory, if possible. + DataDirs []string + + // ConfigHome defines the base directory relative to which user-specific + // configuration files should be written. This directory is defined by + // the $XDG_CONFIG_HOME environment variable. If the variable is not + // not set, a default equal to $HOME/.config should be used. + ConfigHome string + + // ConfigDirs defines the preference-ordered set of base directories to + // search for configuration files in addition to the ConfigHome base + // directory. This set of directories is defined by the $XDG_CONFIG_DIRS + // environment variable. If the variable is not set, a default equal + // to /etc/xdg should be used. The ConfigHome directory is considered + // more important than any of the directories defined by ConfigDirs. + // Therefore, user config files should be written relative to the + // ConfigHome directory, if possible. + ConfigDirs []string + + // StateHome defines the base directory relative to which user-specific + // state files should be stored. This directory is defined by the + // $XDG_STATE_HOME environment variable. If the variable is not set, + // a default equal to ~/.local/state should be used. + StateHome string + + // CacheHome defines the base directory relative to which user-specific + // non-essential (cached) data should be written. This directory is + // defined by the $XDG_CACHE_HOME environment variable. If the variable + // is not set, a default equal to $HOME/.cache should be used. + CacheHome string + + // RuntimeDir defines the base directory relative to which user-specific + // non-essential runtime files and other file objects (such as sockets, + // named pipes, etc.) should be stored. This directory is defined by the + // $XDG_RUNTIME_DIR environment variable. If the variable is not set, + // applications should fall back to a replacement directory with similar + // capabilities. Applications should use this directory for communication + // and synchronization purposes and should not place larger files in it, + // since it might reside in runtime memory and cannot necessarily be + // swapped out to disk. + RuntimeDir string + + // UserDirs defines the locations of well known user directories. + UserDirs UserDirectories + + // FontDirs defines the common locations where font files are stored. + FontDirs []string + + // ApplicationDirs defines the common locations of applications. + ApplicationDirs []string + + // baseDirs defines the locations of base directories. + baseDirs baseDirectories +) + +func init() { + Reload() +} + +// Reload refreshes base and user directories by reading the environment. +// Defaults are applied for XDG variables which are empty or not present +// in the environment. +func Reload() { + // Initialize home directory. + Home = homeDir() + + // Initialize base and user directories. + initDirs(Home) + + // Set standard directories. + DataHome = baseDirs.dataHome + DataDirs = baseDirs.data + ConfigHome = baseDirs.configHome + ConfigDirs = baseDirs.config + StateHome = baseDirs.stateHome + CacheHome = baseDirs.cacheHome + RuntimeDir = baseDirs.runtime + + // Set non-standard directories. + FontDirs = baseDirs.fonts + ApplicationDirs = baseDirs.applications +} + +// DataFile returns a suitable location for the specified data file. +// The relPath parameter must contain the name of the data file, and +// optionally, a set of parent directories (e.g. appname/app.data). +// If the specified directories do not exist, they will be created relative +// to the base data directory. On failure, an error containing the +// attempted paths is returned. +func DataFile(relPath string) (string, error) { + return baseDirs.dataFile(relPath) +} + +// ConfigFile returns a suitable location for the specified config file. +// The relPath parameter must contain the name of the config file, and +// optionally, a set of parent directories (e.g. appname/app.yaml). +// If the specified directories do not exist, they will be created relative +// to the base config directory. On failure, an error containing the +// attempted paths is returned. +func ConfigFile(relPath string) (string, error) { + return baseDirs.configFile(relPath) +} + +// StateFile returns a suitable location for the specified state file. State +// files are usually volatile data files, not suitable to be stored relative +// to the $XDG_DATA_HOME directory. +// The relPath parameter must contain the name of the state file, and +// optionally, a set of parent directories (e.g. appname/app.state). +// If the specified directories do not exist, they will be created relative +// to the base state directory. On failure, an error containing the +// attempted paths is returned. +func StateFile(relPath string) (string, error) { + return baseDirs.stateFile(relPath) +} + +// CacheFile returns a suitable location for the specified cache file. +// The relPath parameter must contain the name of the cache file, and +// optionally, a set of parent directories (e.g. appname/app.cache). +// If the specified directories do not exist, they will be created relative +// to the base cache directory. On failure, an error containing the +// attempted paths is returned. +func CacheFile(relPath string) (string, error) { + return baseDirs.cacheFile(relPath) +} + +// RuntimeFile returns a suitable location for the specified runtime file. +// The relPath parameter must contain the name of the runtime file, and +// optionally, a set of parent directories (e.g. appname/app.pid). +// If the specified directories do not exist, they will be created relative +// to the base runtime directory. On failure, an error containing the +// attempted paths is returned. +func RuntimeFile(relPath string) (string, error) { + return baseDirs.runtimeFile(relPath) +} + +// SearchDataFile searches for specified file in the data search paths. +// The relPath parameter must contain the name of the data file, and +// optionally, a set of parent directories (e.g. appname/app.data). If the +// file cannot be found, an error specifying the searched paths is returned. +func SearchDataFile(relPath string) (string, error) { + return baseDirs.searchDataFile(relPath) +} + +// SearchConfigFile searches for the specified file in config search paths. +// The relPath parameter must contain the name of the config file, and +// optionally, a set of parent directories (e.g. appname/app.yaml). If the +// file cannot be found, an error specifying the searched paths is returned. +func SearchConfigFile(relPath string) (string, error) { + return baseDirs.searchConfigFile(relPath) +} + +// SearchStateFile searches for the specified file in the state search path. +// The relPath parameter must contain the name of the state file, and +// optionally, a set of parent directories (e.g. appname/app.state). If the +// file cannot be found, an error specifying the searched path is returned. +func SearchStateFile(relPath string) (string, error) { + return baseDirs.searchStateFile(relPath) +} + +// SearchCacheFile searches for the specified file in the cache search path. +// The relPath parameter must contain the name of the cache file, and +// optionally, a set of parent directories (e.g. appname/app.cache). If the +// file cannot be found, an error specifying the searched path is returned. +func SearchCacheFile(relPath string) (string, error) { + return baseDirs.searchCacheFile(relPath) +} + +// SearchRuntimeFile searches for the specified file in the runtime search path. +// The relPath parameter must contain the name of the runtime file, and +// optionally, a set of parent directories (e.g. appname/app.pid). If the +// file cannot be found, an error specifying the searched path is returned. +func SearchRuntimeFile(relPath string) (string, error) { + return baseDirs.searchRuntimeFile(relPath) +} + +func xdgPath(name, defaultPath string) string { + dir := pathutil.ExpandHome(os.Getenv(name), Home) + if dir != "" && filepath.IsAbs(dir) { + return dir + } + + return defaultPath +} + +func xdgPaths(name string, defaultPaths ...string) []string { + dirs := pathutil.Unique(filepath.SplitList(os.Getenv(name)), Home) + if len(dirs) != 0 { + return dirs + } + + return pathutil.Unique(defaultPaths, Home) +} diff --git a/vendor/github.com/chai2010/gettext-go/LICENSE b/vendor/github.com/chai2010/gettext-go/LICENSE new file mode 100644 index 0000000000..8f39408250 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/LICENSE @@ -0,0 +1,27 @@ +Copyright 2013 ChaiShushan . All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/chai2010/gettext-go/gettext/caller.go b/vendor/github.com/chai2010/gettext-go/gettext/caller.go new file mode 100644 index 0000000000..e24aab3756 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/caller.go @@ -0,0 +1,39 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gettext + +import ( + "regexp" + "runtime" +) + +var ( + reInit = regexp.MustCompile(`init·\d+$`) // main.init·1 + reClosure = regexp.MustCompile(`func·\d+$`) // main.func·001 +) + +// caller types: +// runtime.goexit +// runtime.main +// main.init +// main.main +// main.init·1 -> main.init +// main.func·001 -> main.func +// code.google.com/p/gettext-go/gettext.TestCallerName +// ... +func callerName(skip int) string { + pc, _, _, ok := runtime.Caller(skip) + if !ok { + return "" + } + name := runtime.FuncForPC(pc).Name() + if reInit.MatchString(name) { + return reInit.ReplaceAllString(name, "init") + } + if reClosure.MatchString(name) { + return reClosure.ReplaceAllString(name, "func") + } + return name +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/doc.go b/vendor/github.com/chai2010/gettext-go/gettext/doc.go new file mode 100644 index 0000000000..422bf2c6d7 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/doc.go @@ -0,0 +1,66 @@ +// Copyright 2013 . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package gettext implements a basic GNU's gettext library. + +Example: + import ( + "github.com/chai2010/gettext-go/gettext" + ) + + func main() { + gettext.SetLocale("zh_CN") + gettext.Textdomain("hello") + + // gettext.BindTextdomain("hello", "local", nil) // from local dir + // gettext.BindTextdomain("hello", "local.zip", nil) // from local zip file + // gettext.BindTextdomain("hello", "local.zip", zipData) // from embedded zip data + + gettext.BindTextdomain("hello", "local", nil) + + // translate source text + fmt.Println(gettext.Gettext("Hello, world!")) + // Output: 你好, 世界! + + // translate resource + fmt.Println(string(gettext.Getdata("poems.txt"))) + // Output: ... + } + +Translate directory struct("../examples/local.zip"): + + Root: "path" or "file.zip/zipBaseName" + +-default # local: $(LC_MESSAGES) or $(LANG) or "default" + | +-LC_MESSAGES # just for `gettext.Gettext` + | | +-hello.mo # $(Root)/$(local)/LC_MESSAGES/$(domain).mo + | | \-hello.po # $(Root)/$(local)/LC_MESSAGES/$(domain).mo + | | + | \-LC_RESOURCE # just for `gettext.Getdata` + | +-hello # domain map a dir in resource translate + | +-favicon.ico # $(Root)/$(local)/LC_RESOURCE/$(domain)/$(filename) + | \-poems.txt + | + \-zh_CN # simple chinese translate + +-LC_MESSAGES + | +-hello.mo # try "$(domain).mo" first + | \-hello.po # try "$(domain).po" second + | + \-LC_RESOURCE + +-hello + +-favicon.ico # try "$(local)/$(domain)/file" first + \-poems.txt # try "default/$(domain)/file" second + +See: + http://en.wikipedia.org/wiki/Gettext + http://www.gnu.org/software/gettext/manual/html_node + http://www.gnu.org/software/gettext/manual/html_node/Header-Entry.html + http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html + http://www.gnu.org/software/gettext/manual/html_node/MO-Files.html + http://www.poedit.net/ + +Please report bugs to . +Thanks! +*/ +package gettext diff --git a/vendor/github.com/chai2010/gettext-go/gettext/domain.go b/vendor/github.com/chai2010/gettext-go/gettext/domain.go new file mode 100644 index 0000000000..f860b27b6b --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/domain.go @@ -0,0 +1,119 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gettext + +import ( + "sync" +) + +type domainManager struct { + mutex sync.Mutex + locale string + domain string + domainMap map[string]*fileSystem + trTextMap map[string]*translator +} + +func newDomainManager() *domainManager { + return &domainManager{ + locale: DefaultLocale, + domainMap: make(map[string]*fileSystem), + trTextMap: make(map[string]*translator), + } +} + +func (p *domainManager) makeTrMapKey(domain, locale string) string { + return domain + "_$$$_" + locale +} + +func (p *domainManager) Bind(domain, path string, data []byte) (domains, paths []string) { + p.mutex.Lock() + defer p.mutex.Unlock() + + switch { + case domain != "" && path != "": // bind new domain + p.bindDomainTranslators(domain, path, data) + case domain != "" && path == "": // delete domain + p.deleteDomain(domain) + } + + // return all bind domain + for k, fs := range p.domainMap { + domains = append(domains, k) + paths = append(paths, fs.FsName) + } + return +} + +func (p *domainManager) SetLocale(locale string) string { + p.mutex.Lock() + defer p.mutex.Unlock() + if locale != "" { + p.locale = locale + } + return p.locale +} + +func (p *domainManager) SetDomain(domain string) string { + p.mutex.Lock() + defer p.mutex.Unlock() + if domain != "" { + p.domain = domain + } + return p.domain +} + +func (p *domainManager) Getdata(name string) []byte { + return p.getdata(p.domain, name) +} + +func (p *domainManager) DGetdata(domain, name string) []byte { + return p.getdata(domain, name) +} + +func (p *domainManager) PNGettext(msgctxt, msgid, msgidPlural string, n int) string { + p.mutex.Lock() + defer p.mutex.Unlock() + return p.gettext(p.domain, msgctxt, msgid, msgidPlural, n) +} + +func (p *domainManager) DPNGettext(domain, msgctxt, msgid, msgidPlural string, n int) string { + p.mutex.Lock() + defer p.mutex.Unlock() + return p.gettext(domain, msgctxt, msgid, msgidPlural, n) +} + +func (p *domainManager) gettext(domain, msgctxt, msgid, msgidPlural string, n int) string { + if p.locale == "" || p.domain == "" { + return msgid + } + if _, ok := p.domainMap[domain]; !ok { + return msgid + } + if f, ok := p.trTextMap[p.makeTrMapKey(domain, p.locale)]; ok { + return f.PNGettext(msgctxt, msgid, msgidPlural, n) + } + return msgid +} + +func (p *domainManager) getdata(domain, name string) []byte { + if p.locale == "" || p.domain == "" { + return nil + } + if _, ok := p.domainMap[domain]; !ok { + return nil + } + if fs, ok := p.domainMap[domain]; ok { + if data, err := fs.LoadResourceFile(domain, p.locale, name); err == nil { + return data + } + if p.locale != "default" { + if data, err := fs.LoadResourceFile(domain, "default", name); err == nil { + return data + } + } + } + return nil +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/domain_helper.go b/vendor/github.com/chai2010/gettext-go/gettext/domain_helper.go new file mode 100644 index 0000000000..8dce58e655 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/domain_helper.go @@ -0,0 +1,50 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gettext + +import ( + "fmt" + "strings" +) + +func (p *domainManager) bindDomainTranslators(domain, path string, data []byte) { + if _, ok := p.domainMap[domain]; ok { + p.deleteDomain(domain) // delete old domain + } + fs := newFileSystem(path, data) + for locale, _ := range fs.LocaleMap { + trMapKey := p.makeTrMapKey(domain, locale) + if data, err := fs.LoadMessagesFile(domain, locale, ".mo"); err == nil { + p.trTextMap[trMapKey], _ = newMoTranslator( + fmt.Sprintf("%s_%s.mo", domain, locale), + data, + ) + continue + } + if data, err := fs.LoadMessagesFile(domain, locale, ".po"); err == nil { + p.trTextMap[trMapKey], _ = newPoTranslator( + fmt.Sprintf("%s_%s.po", domain, locale), + data, + ) + continue + } + p.trTextMap[p.makeTrMapKey(domain, locale)] = nilTranslator + } + p.domainMap[domain] = fs +} + +func (p *domainManager) deleteDomain(domain string) { + if _, ok := p.domainMap[domain]; !ok { + return + } + // delete all mo files + trMapKeyPrefix := p.makeTrMapKey(domain, "") + for k, _ := range p.trTextMap { + if strings.HasPrefix(k, trMapKeyPrefix) { + delete(p.trTextMap, k) + } + } + delete(p.domainMap, domain) +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/fs.go b/vendor/github.com/chai2010/gettext-go/gettext/fs.go new file mode 100644 index 0000000000..1c2e23c1d0 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/fs.go @@ -0,0 +1,187 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gettext + +import ( + "archive/zip" + "bytes" + "fmt" + "io/ioutil" + "log" + "os" + "strings" +) + +type fileSystem struct { + FsName string + FsRoot string + FsZipData []byte + LocaleMap map[string]bool +} + +func newFileSystem(path string, data []byte) *fileSystem { + fs := &fileSystem{ + FsName: path, + FsZipData: data, + } + if err := fs.init(); err != nil { + log.Printf("gettext-go: invalid domain, err = %v", err) + } + return fs +} + +func (p *fileSystem) init() error { + zipName := func(name string) string { + if x := strings.LastIndexAny(name, `\/`); x != -1 { + name = name[x+1:] + } + name = strings.TrimSuffix(name, ".zip") + return name + } + + // zip data + if len(p.FsZipData) != 0 { + p.FsRoot = zipName(p.FsName) + p.LocaleMap = p.lsZip(p.FsZipData) + return nil + } + + // local dir or zip file + fi, err := os.Stat(p.FsName) + if err != nil { + return err + } + + // local dir + if fi.IsDir() { + p.FsRoot = p.FsName + p.LocaleMap = p.lsDir(p.FsName) + return nil + } + + // local zip file + p.FsZipData, err = ioutil.ReadFile(p.FsName) + if err != nil { + return err + } + p.FsRoot = zipName(p.FsName) + p.LocaleMap = p.lsZip(p.FsZipData) + return nil +} + +func (p *fileSystem) LoadMessagesFile(domain, local, ext string) ([]byte, error) { + if len(p.FsZipData) == 0 { + trName := p.makeMessagesFileName(domain, local, ext) + rcData, err := ioutil.ReadFile(trName) + if err != nil { + return nil, err + } + return rcData, nil + } else { + r, err := zip.NewReader(bytes.NewReader(p.FsZipData), int64(len(p.FsZipData))) + if err != nil { + return nil, err + } + + trName := p.makeMessagesFileName(domain, local, ext) + for _, f := range r.File { + if f.Name != trName { + continue + } + rc, err := f.Open() + if err != nil { + return nil, err + } + rcData, err := ioutil.ReadAll(rc) + rc.Close() + return rcData, err + } + return nil, fmt.Errorf("not found") + } +} + +func (p *fileSystem) LoadResourceFile(domain, local, name string) ([]byte, error) { + if len(p.FsZipData) == 0 { + rcName := p.makeResourceFileName(domain, local, name) + rcData, err := ioutil.ReadFile(rcName) + if err != nil { + return nil, err + } + return rcData, nil + } else { + r, err := zip.NewReader(bytes.NewReader(p.FsZipData), int64(len(p.FsZipData))) + if err != nil { + return nil, err + } + + rcName := p.makeResourceFileName(domain, local, name) + for _, f := range r.File { + if f.Name != rcName { + continue + } + rc, err := f.Open() + if err != nil { + return nil, err + } + rcData, err := ioutil.ReadAll(rc) + rc.Close() + return rcData, err + } + return nil, fmt.Errorf("not found") + } +} + +func (p *fileSystem) makeMessagesFileName(domain, local, ext string) string { + return fmt.Sprintf("%s/%s/LC_MESSAGES/%s%s", p.FsRoot, local, domain, ext) +} + +func (p *fileSystem) makeResourceFileName(domain, local, name string) string { + return fmt.Sprintf("%s/%s/LC_RESOURCE/%s/%s", p.FsRoot, local, domain, name) +} + +func (p *fileSystem) lsZip(data []byte) map[string]bool { + r, err := zip.NewReader(bytes.NewReader(data), int64(len(data))) + if err != nil { + return nil + } + ssMap := make(map[string]bool) + for _, f := range r.File { + if x := strings.Index(f.Name, "LC_MESSAGES"); x != -1 { + s := strings.TrimRight(f.Name[:x], `\/`) + if x = strings.LastIndexAny(s, `\/`); x != -1 { + s = s[x+1:] + } + if s != "" { + ssMap[s] = true + } + continue + } + if x := strings.Index(f.Name, "LC_RESOURCE"); x != -1 { + s := strings.TrimRight(f.Name[:x], `\/`) + if x = strings.LastIndexAny(s, `\/`); x != -1 { + s = s[x+1:] + } + if s != "" { + ssMap[s] = true + } + continue + } + } + return ssMap +} + +func (p *fileSystem) lsDir(path string) map[string]bool { + list, err := ioutil.ReadDir(path) + if err != nil { + return nil + } + ssMap := make(map[string]bool) + for _, dir := range list { + if dir.IsDir() { + ssMap[dir.Name()] = true + } + } + return ssMap +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/gettext.go b/vendor/github.com/chai2010/gettext-go/gettext/gettext.go new file mode 100644 index 0000000000..ca14065b22 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/gettext.go @@ -0,0 +1,184 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gettext + +var ( + defaultManager = newDomainManager() +) + +var ( + DefaultLocale = getDefaultLocale() // use $(LC_MESSAGES) or $(LANG) or "default" +) + +// SetLocale sets and queries the program's current locale. +// +// If the locale is not empty string, set the new local. +// +// If the locale is empty string, don't change anything. +// +// Returns is the current locale. +// +// Examples: +// SetLocale("") // get locale: return DefaultLocale +// SetLocale("zh_CN") // set locale: return zh_CN +// SetLocale("") // get locale: return zh_CN +func SetLocale(locale string) string { + return defaultManager.SetLocale(locale) +} + +// BindTextdomain sets and queries program's domains. +// +// If the domain and path are all not empty string, bind the new domain. +// If the domain already exists, return error. +// +// If the domain is not empty string, but the path is the empty string, +// delete the domain. +// If the domain don't exists, return error. +// +// If the domain and the path are all empty string, don't change anything. +// +// Returns is the all bind domains. +// +// Examples: +// BindTextdomain("poedit", "local", nil) // bind "poedit" domain +// BindTextdomain("", "", nil) // return all domains +// BindTextdomain("poedit", "", nil) // delete "poedit" domain +// BindTextdomain("", "", nil) // return all domains +// +// Use zip file: +// BindTextdomain("poedit", "local.zip", nil) // bind "poedit" domain +// BindTextdomain("poedit", "local.zip", zipData) // bind "poedit" domain +// +func BindTextdomain(domain, path string, zipData []byte) (domains, paths []string) { + return defaultManager.Bind(domain, path, zipData) +} + +// Textdomain sets and retrieves the current message domain. +// +// If the domain is not empty string, set the new domains. +// +// If the domain is empty string, don't change anything. +// +// Returns is the all used domains. +// +// Examples: +// Textdomain("poedit") // set domain: poedit +// Textdomain("") // get domain: return poedit +func Textdomain(domain string) string { + return defaultManager.SetDomain(domain) +} + +// Gettext attempt to translate a text string into the user's native language, +// by looking up the translation in a message catalog. +// +// It use the caller's function name as the msgctxt. +// +// Examples: +// func Foo() { +// msg := gettext.Gettext("Hello") // msgctxt is "some/package/name.Foo" +// } +func Gettext(msgid string) string { + return PGettext(callerName(2), msgid) +} + +// Getdata attempt to translate a resource file into the user's native language, +// by looking up the translation in a message catalog. +// +// Examples: +// func Foo() { +// Textdomain("hello") +// BindTextdomain("hello", "local.zip", nilOrZipData) +// poems := gettext.Getdata("poems.txt") +// } +func Getdata(name string) []byte { + return defaultManager.Getdata(name) +} + +// NGettext attempt to translate a text string into the user's native language, +// by looking up the appropriate plural form of the translation in a message +// catalog. +// +// It use the caller's function name as the msgctxt. +// +// Examples: +// func Foo() { +// msg := gettext.NGettext("%d people", "%d peoples", 2) +// } +func NGettext(msgid, msgidPlural string, n int) string { + return PNGettext(callerName(2), msgid, msgidPlural, n) +} + +// PGettext attempt to translate a text string into the user's native language, +// by looking up the translation in a message catalog. +// +// Examples: +// func Foo() { +// msg := gettext.PGettext("gettext-go.example", "Hello") // msgctxt is "gettext-go.example" +// } +func PGettext(msgctxt, msgid string) string { + return PNGettext(msgctxt, msgid, "", 0) +} + +// PNGettext attempt to translate a text string into the user's native language, +// by looking up the appropriate plural form of the translation in a message +// catalog. +// +// Examples: +// func Foo() { +// msg := gettext.PNGettext("gettext-go.example", "%d people", "%d peoples", 2) +// } +func PNGettext(msgctxt, msgid, msgidPlural string, n int) string { + return defaultManager.PNGettext(msgctxt, msgid, msgidPlural, n) +} + +// DGettext like Gettext(), but looking up the message in the specified domain. +// +// Examples: +// func Foo() { +// msg := gettext.DGettext("poedit", "Hello") +// } +func DGettext(domain, msgid string) string { + return DPGettext(domain, callerName(2), msgid) +} + +// DNGettext like NGettext(), but looking up the message in the specified domain. +// +// Examples: +// func Foo() { +// msg := gettext.PNGettext("poedit", "gettext-go.example", "%d people", "%d peoples", 2) +// } +func DNGettext(domain, msgid, msgidPlural string, n int) string { + return DPNGettext(domain, callerName(2), msgid, msgidPlural, n) +} + +// DPGettext like PGettext(), but looking up the message in the specified domain. +// +// Examples: +// func Foo() { +// msg := gettext.DPGettext("poedit", "gettext-go.example", "Hello") +// } +func DPGettext(domain, msgctxt, msgid string) string { + return DPNGettext(domain, msgctxt, msgid, "", 0) +} + +// DPNGettext like PNGettext(), but looking up the message in the specified domain. +// +// Examples: +// func Foo() { +// msg := gettext.DPNGettext("poedit", "gettext-go.example", "%d people", "%d peoples", 2) +// } +func DPNGettext(domain, msgctxt, msgid, msgidPlural string, n int) string { + return defaultManager.DPNGettext(domain, msgctxt, msgid, msgidPlural, n) +} + +// DGetdata like Getdata(), but looking up the resource in the specified domain. +// +// Examples: +// func Foo() { +// msg := gettext.DGetdata("hello", "poems.txt") +// } +func DGetdata(domain, name string) []byte { + return defaultManager.DGetdata(domain, name) +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/local.go b/vendor/github.com/chai2010/gettext-go/gettext/local.go new file mode 100644 index 0000000000..179a392fe2 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/local.go @@ -0,0 +1,34 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gettext + +import ( + "os" + "strings" +) + +func getDefaultLocale() string { + if v := os.Getenv("LC_MESSAGES"); v != "" { + return simplifiedLocale(v) + } + if v := os.Getenv("LANG"); v != "" { + return simplifiedLocale(v) + } + return "default" +} + +func simplifiedLocale(lang string) string { + // en_US/en_US.UTF-8/zh_CN/zh_TW/el_GR@euro/... + if idx := strings.Index(lang, ":"); idx != -1 { + lang = lang[:idx] + } + if idx := strings.Index(lang, "@"); idx != -1 { + lang = lang[:idx] + } + if idx := strings.Index(lang, "."); idx != -1 { + lang = lang[:idx] + } + return strings.TrimSpace(lang) +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/mo/doc.go b/vendor/github.com/chai2010/gettext-go/gettext/mo/doc.go new file mode 100644 index 0000000000..9677680631 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/mo/doc.go @@ -0,0 +1,74 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package mo provides support for reading and writing GNU MO file. + +Examples: + import ( + "github.com/chai2010/gettext-go/gettext/mo" + ) + + func main() { + moFile, err := mo.Load("test.mo") + if err != nil { + log.Fatal(err) + } + fmt.Printf("%v", moFile) + } + +GNU MO file struct: + + byte + +------------------------------------------+ + 0 | magic number = 0x950412de | + | | + 4 | file format revision = 0 | + | | + 8 | number of strings | == N + | | + 12 | offset of table with original strings | == O + | | + 16 | offset of table with translation strings | == T + | | + 20 | size of hashing table | == S + | | + 24 | offset of hashing table | == H + | | + . . + . (possibly more entries later) . + . . + | | + O | length & offset 0th string ----------------. + O + 8 | length & offset 1st string ------------------. + ... ... | | + O + ((N-1)*8)| length & offset (N-1)th string | | | + | | | | + T | length & offset 0th translation ---------------. + T + 8 | length & offset 1st translation -----------------. + ... ... | | | | + T + ((N-1)*8)| length & offset (N-1)th translation | | | | | + | | | | | | + H | start hash table | | | | | + ... ... | | | | + H + S * 4 | end hash table | | | | | + | | | | | | + | NUL terminated 0th string <----------------' | | | + | | | | | + | NUL terminated 1st string <------------------' | | + | | | | + ... ... | | + | | | | + | NUL terminated 0th translation <---------------' | + | | | + | NUL terminated 1st translation <-----------------' + | | + ... ... + | | + +------------------------------------------+ + +The GNU MO file specification is at +http://www.gnu.org/software/gettext/manual/html_node/MO-Files.html. +*/ +package mo diff --git a/vendor/github.com/chai2010/gettext-go/gettext/mo/encoder.go b/vendor/github.com/chai2010/gettext-go/gettext/mo/encoder.go new file mode 100644 index 0000000000..9b1c240b4f --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/mo/encoder.go @@ -0,0 +1,124 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mo + +import ( + "bytes" + "encoding/binary" + "sort" + "strings" +) + +type moHeader struct { + MagicNumber uint32 + MajorVersion uint16 + MinorVersion uint16 + MsgIdCount uint32 + MsgIdOffset uint32 + MsgStrOffset uint32 + HashSize uint32 + HashOffset uint32 +} + +type moStrPos struct { + Size uint32 // must keep fields order + Addr uint32 +} + +func encodeFile(f *File) []byte { + hdr := &moHeader{ + MagicNumber: MoMagicLittleEndian, + } + data := encodeData(hdr, f) + data = append(encodeHeader(hdr), data...) + return data +} + +// encode data and init moHeader +func encodeData(hdr *moHeader, f *File) []byte { + msgList := []Message{f.MimeHeader.toMessage()} + for _, v := range f.Messages { + if len(v.MsgId) == 0 { + continue + } + if len(v.MsgStr) == 0 && len(v.MsgStrPlural) == 0 { + continue + } + msgList = append(msgList, v) + } + sort.Sort(byMessages(msgList)) + + var buf bytes.Buffer + var msgIdPosList = make([]moStrPos, len(msgList)) + var msgStrPosList = make([]moStrPos, len(msgList)) + for i, v := range msgList { + // write msgid + msgId := encodeMsgId(v) + msgIdPosList[i].Addr = uint32(buf.Len() + MoHeaderSize) + msgIdPosList[i].Size = uint32(len(msgId)) + buf.WriteString(msgId) + // write msgstr + msgStr := encodeMsgStr(v) + msgStrPosList[i].Addr = uint32(buf.Len() + MoHeaderSize) + msgStrPosList[i].Size = uint32(len(msgStr)) + buf.WriteString(msgStr) + } + + hdr.MsgIdOffset = uint32(buf.Len() + MoHeaderSize) + binary.Write(&buf, binary.LittleEndian, msgIdPosList) + hdr.MsgStrOffset = uint32(buf.Len() + MoHeaderSize) + binary.Write(&buf, binary.LittleEndian, msgStrPosList) + + hdr.MsgIdCount = uint32(len(msgList)) + return buf.Bytes() +} + +// must called after encodeData +func encodeHeader(hdr *moHeader) []byte { + var buf bytes.Buffer + binary.Write(&buf, binary.LittleEndian, hdr) + return buf.Bytes() +} + +func encodeMsgId(v Message) string { + if v.MsgContext != "" && v.MsgIdPlural != "" { + return v.MsgContext + EotSeparator + v.MsgId + NulSeparator + v.MsgIdPlural + } + if v.MsgContext != "" && v.MsgIdPlural == "" { + return v.MsgContext + EotSeparator + v.MsgId + } + if v.MsgContext == "" && v.MsgIdPlural != "" { + return v.MsgId + NulSeparator + v.MsgIdPlural + } + return v.MsgId +} + +func encodeMsgStr(v Message) string { + if v.MsgIdPlural != "" { + return strings.Join(v.MsgStrPlural, NulSeparator) + } + return v.MsgStr +} + +type byMessages []Message + +func (d byMessages) Len() int { + return len(d) +} +func (d byMessages) Less(i, j int) bool { + if a, b := d[i].MsgContext, d[j].MsgContext; a != b { + return a < b + } + if a, b := d[i].MsgId, d[j].MsgId; a != b { + return a < b + } + if a, b := d[i].MsgIdPlural, d[j].MsgIdPlural; a != b { + return a < b + } + return false +} +func (d byMessages) Swap(i, j int) { + d[i], d[j] = d[j], d[i] +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/mo/file.go b/vendor/github.com/chai2010/gettext-go/gettext/mo/file.go new file mode 100644 index 0000000000..b49a77b42a --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/mo/file.go @@ -0,0 +1,193 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mo + +import ( + "bytes" + "encoding/binary" + "fmt" + "io/ioutil" + "strings" +) + +const ( + MoHeaderSize = 28 + MoMagicLittleEndian = 0x950412de + MoMagicBigEndian = 0xde120495 + + EotSeparator = "\x04" // msgctxt and msgid separator + NulSeparator = "\x00" // msgid and msgstr separator +) + +// File represents an MO File. +// +// See http://www.gnu.org/software/gettext/manual/html_node/MO-Files.html +type File struct { + MagicNumber uint32 + MajorVersion uint16 + MinorVersion uint16 + MsgIdCount uint32 + MsgIdOffset uint32 + MsgStrOffset uint32 + HashSize uint32 + HashOffset uint32 + MimeHeader Header + Messages []Message +} + +// Load loads a named mo file. +func Load(name string) (*File, error) { + data, err := ioutil.ReadFile(name) + if err != nil { + return nil, err + } + return LoadData(data) +} + +// LoadData loads mo file format data. +func LoadData(data []byte) (*File, error) { + r := bytes.NewReader(data) + + var magicNumber uint32 + if err := binary.Read(r, binary.LittleEndian, &magicNumber); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + var bo binary.ByteOrder + switch magicNumber { + case MoMagicLittleEndian: + bo = binary.LittleEndian + case MoMagicBigEndian: + bo = binary.BigEndian + default: + return nil, fmt.Errorf("gettext: %v", "invalid magic number") + } + + var header struct { + MajorVersion uint16 + MinorVersion uint16 + MsgIdCount uint32 + MsgIdOffset uint32 + MsgStrOffset uint32 + HashSize uint32 + HashOffset uint32 + } + if err := binary.Read(r, bo, &header); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + if v := header.MajorVersion; v != 0 && v != 1 { + return nil, fmt.Errorf("gettext: %v", "invalid version number") + } + if v := header.MinorVersion; v != 0 && v != 1 { + return nil, fmt.Errorf("gettext: %v", "invalid version number") + } + + msgIdStart := make([]uint32, header.MsgIdCount) + msgIdLen := make([]uint32, header.MsgIdCount) + if _, err := r.Seek(int64(header.MsgIdOffset), 0); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + for i := 0; i < int(header.MsgIdCount); i++ { + if err := binary.Read(r, bo, &msgIdLen[i]); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + if err := binary.Read(r, bo, &msgIdStart[i]); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + } + + msgStrStart := make([]int32, header.MsgIdCount) + msgStrLen := make([]int32, header.MsgIdCount) + if _, err := r.Seek(int64(header.MsgStrOffset), 0); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + for i := 0; i < int(header.MsgIdCount); i++ { + if err := binary.Read(r, bo, &msgStrLen[i]); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + if err := binary.Read(r, bo, &msgStrStart[i]); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + } + + file := &File{ + MagicNumber: magicNumber, + MajorVersion: header.MajorVersion, + MinorVersion: header.MinorVersion, + MsgIdCount: header.MsgIdCount, + MsgIdOffset: header.MsgIdOffset, + MsgStrOffset: header.MsgStrOffset, + HashSize: header.HashSize, + HashOffset: header.HashOffset, + } + for i := 0; i < int(header.MsgIdCount); i++ { + if _, err := r.Seek(int64(msgIdStart[i]), 0); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + msgIdData := make([]byte, msgIdLen[i]) + if _, err := r.Read(msgIdData); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + + if _, err := r.Seek(int64(msgStrStart[i]), 0); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + msgStrData := make([]byte, msgStrLen[i]) + if _, err := r.Read(msgStrData); err != nil { + return nil, fmt.Errorf("gettext: %v", err) + } + + if len(msgIdData) == 0 { + var msg = Message{ + MsgId: string(msgIdData), + MsgStr: string(msgStrData), + } + file.MimeHeader.fromMessage(&msg) + } else { + var msg = Message{ + MsgId: string(msgIdData), + MsgStr: string(msgStrData), + } + // Is this a context message? + if idx := strings.Index(msg.MsgId, EotSeparator); idx != -1 { + msg.MsgContext, msg.MsgId = msg.MsgId[:idx], msg.MsgId[idx+1:] + } + // Is this a plural message? + if idx := strings.Index(msg.MsgId, NulSeparator); idx != -1 { + msg.MsgId, msg.MsgIdPlural = msg.MsgId[:idx], msg.MsgId[idx+1:] + msg.MsgStrPlural = strings.Split(msg.MsgStr, NulSeparator) + msg.MsgStr = "" + } + file.Messages = append(file.Messages, msg) + } + } + + return file, nil +} + +// Save saves a mo file. +func (f *File) Save(name string) error { + return ioutil.WriteFile(name, f.Data(), 0666) +} + +// Save returns a mo file format data. +func (f *File) Data() []byte { + return encodeFile(f) +} + +// String returns the po format file string. +func (f *File) String() string { + var buf bytes.Buffer + fmt.Fprintf(&buf, "# version: %d.%d\n", f.MajorVersion, f.MinorVersion) + fmt.Fprintf(&buf, "%s\n", f.MimeHeader.String()) + fmt.Fprintf(&buf, "\n") + + for k, v := range f.Messages { + fmt.Fprintf(&buf, `msgid "%v"`+"\n", k) + fmt.Fprintf(&buf, `msgstr "%s"`+"\n", v.MsgStr) + fmt.Fprintf(&buf, "\n") + } + + return buf.String() +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/mo/header.go b/vendor/github.com/chai2010/gettext-go/gettext/mo/header.go new file mode 100644 index 0000000000..d8c7a5e3a3 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/mo/header.go @@ -0,0 +1,109 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mo + +import ( + "bytes" + "fmt" + "strings" +) + +// Header is the initial comments "SOME DESCRIPTIVE TITLE", "YEAR" +// and "FIRST AUTHOR , YEAR" ought to be replaced by sensible information. +// +// See http://www.gnu.org/software/gettext/manual/html_node/Header-Entry.html#Header-Entry +type Header struct { + ProjectIdVersion string // Project-Id-Version: PACKAGE VERSION + ReportMsgidBugsTo string // Report-Msgid-Bugs-To: FIRST AUTHOR + POTCreationDate string // POT-Creation-Date: YEAR-MO-DA HO:MI+ZONE + PORevisionDate string // PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE + LastTranslator string // Last-Translator: FIRST AUTHOR + LanguageTeam string // Language-Team: golang-china + Language string // Language: zh_CN + MimeVersion string // MIME-Version: 1.0 + ContentType string // Content-Type: text/plain; charset=UTF-8 + ContentTransferEncoding string // Content-Transfer-Encoding: 8bit + PluralForms string // Plural-Forms: nplurals=2; plural=n == 1 ? 0 : 1; + XGenerator string // X-Generator: Poedit 1.5.5 + UnknowFields map[string]string +} + +func (p *Header) fromMessage(msg *Message) { + if msg.MsgId != "" || msg.MsgStr == "" { + return + } + lines := strings.Split(msg.MsgStr, "\n") + for i := 0; i < len(lines); i++ { + idx := strings.Index(lines[i], ":") + if idx < 0 { + continue + } + key := strings.TrimSpace(lines[i][:idx]) + val := strings.TrimSpace(lines[i][idx+1:]) + switch strings.ToUpper(key) { + case strings.ToUpper("Project-Id-Version"): + p.ProjectIdVersion = val + case strings.ToUpper("Report-Msgid-Bugs-To"): + p.ReportMsgidBugsTo = val + case strings.ToUpper("POT-Creation-Date"): + p.POTCreationDate = val + case strings.ToUpper("PO-Revision-Date"): + p.PORevisionDate = val + case strings.ToUpper("Last-Translator"): + p.LastTranslator = val + case strings.ToUpper("Language-Team"): + p.LanguageTeam = val + case strings.ToUpper("Language"): + p.Language = val + case strings.ToUpper("MIME-Version"): + p.MimeVersion = val + case strings.ToUpper("Content-Type"): + p.ContentType = val + case strings.ToUpper("Content-Transfer-Encoding"): + p.ContentTransferEncoding = val + case strings.ToUpper("Plural-Forms"): + p.PluralForms = val + case strings.ToUpper("X-Generator"): + p.XGenerator = val + default: + if p.UnknowFields == nil { + p.UnknowFields = make(map[string]string) + } + p.UnknowFields[key] = val + } + } +} + +func (p *Header) toMessage() Message { + return Message{ + MsgStr: p.String(), + } +} + +// String returns the po format header string. +func (p Header) String() string { + var buf bytes.Buffer + fmt.Fprintf(&buf, `msgid ""`+"\n") + fmt.Fprintf(&buf, `msgstr ""`+"\n") + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Project-Id-Version", p.ProjectIdVersion) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Report-Msgid-Bugs-To", p.ReportMsgidBugsTo) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "POT-Creation-Date", p.POTCreationDate) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "PO-Revision-Date", p.PORevisionDate) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Last-Translator", p.LastTranslator) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Language-Team", p.LanguageTeam) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Language", p.Language) + if p.MimeVersion != "" { + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "MIME-Version", p.MimeVersion) + } + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Content-Type", p.ContentType) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Content-Transfer-Encoding", p.ContentTransferEncoding) + if p.XGenerator != "" { + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "X-Generator", p.XGenerator) + } + for k, v := range p.UnknowFields { + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", k, v) + } + return buf.String() +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/mo/message.go b/vendor/github.com/chai2010/gettext-go/gettext/mo/message.go new file mode 100644 index 0000000000..91ad79bece --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/mo/message.go @@ -0,0 +1,39 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mo + +import ( + "bytes" + "fmt" +) + +// A MO file is made up of many entries, +// each entry holding the relation between an original untranslated string +// and its corresponding translation. +// +// See http://www.gnu.org/software/gettext/manual/html_node/MO-Files.html +type Message struct { + MsgContext string // msgctxt context + MsgId string // msgid untranslated-string + MsgIdPlural string // msgid_plural untranslated-string-plural + MsgStr string // msgstr translated-string + MsgStrPlural []string // msgstr[0] translated-string-case-0 +} + +// String returns the po format entry string. +func (p Message) String() string { + var buf bytes.Buffer + fmt.Fprintf(&buf, "msgid %s", encodePoString(p.MsgId)) + if p.MsgIdPlural != "" { + fmt.Fprintf(&buf, "msgid_plural %s", encodePoString(p.MsgIdPlural)) + } + if p.MsgStr != "" { + fmt.Fprintf(&buf, "msgstr %s", encodePoString(p.MsgStr)) + } + for i := 0; i < len(p.MsgStrPlural); i++ { + fmt.Fprintf(&buf, "msgstr[%d] %s", i, encodePoString(p.MsgStrPlural[i])) + } + return buf.String() +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/mo/util.go b/vendor/github.com/chai2010/gettext-go/gettext/mo/util.go new file mode 100644 index 0000000000..3804511053 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/mo/util.go @@ -0,0 +1,110 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mo + +import ( + "bytes" + "strings" +) + +func decodePoString(text string) string { + lines := strings.Split(text, "\n") + for i := 0; i < len(lines); i++ { + left := strings.Index(lines[i], `"`) + right := strings.LastIndex(lines[i], `"`) + if left < 0 || right < 0 || left == right { + lines[i] = "" + continue + } + line := lines[i][left+1 : right] + data := make([]byte, 0, len(line)) + for i := 0; i < len(line); i++ { + if line[i] != '\\' { + data = append(data, line[i]) + continue + } + if i+1 >= len(line) { + break + } + switch line[i+1] { + case 'n': // \\n -> \n + data = append(data, '\n') + i++ + case 't': // \\t -> \n + data = append(data, '\t') + i++ + case '\\': // \\\ -> ? + data = append(data, '\\') + i++ + } + } + lines[i] = string(data) + } + return strings.Join(lines, "") +} + +func encodePoString(text string) string { + var buf bytes.Buffer + lines := strings.Split(text, "\n") + for i := 0; i < len(lines); i++ { + if lines[i] == "" { + if i != len(lines)-1 { + buf.WriteString(`"\n"` + "\n") + } + continue + } + buf.WriteRune('"') + for _, r := range lines[i] { + switch r { + case '\\': + buf.WriteString(`\\`) + case '"': + buf.WriteString(`\"`) + case '\n': + buf.WriteString(`\n`) + case '\t': + buf.WriteString(`\t`) + default: + buf.WriteRune(r) + } + } + buf.WriteString(`\n"` + "\n") + } + return buf.String() +} + +func encodeCommentPoString(text string) string { + var buf bytes.Buffer + lines := strings.Split(text, "\n") + if len(lines) > 1 { + buf.WriteString(`""` + "\n") + } + for i := 0; i < len(lines); i++ { + if len(lines) > 0 { + buf.WriteString("#| ") + } + buf.WriteRune('"') + for _, r := range lines[i] { + switch r { + case '\\': + buf.WriteString(`\\`) + case '"': + buf.WriteString(`\"`) + case '\n': + buf.WriteString(`\n`) + case '\t': + buf.WriteString(`\t`) + default: + buf.WriteRune(r) + } + } + if i < len(lines)-1 { + buf.WriteString(`\n"` + "\n") + } else { + buf.WriteString(`"`) + } + } + return buf.String() +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/plural/doc.go b/vendor/github.com/chai2010/gettext-go/gettext/plural/doc.go new file mode 100644 index 0000000000..5641e2c3e7 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/plural/doc.go @@ -0,0 +1,36 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package plural provides standard plural formulas. + +Examples: + import ( + "code.google.com/p/gettext-go/gettext/plural" + ) + + func main() { + enFormula := plural.Formula("en_US") + xxFormula := plural.Formula("zh_CN") + + fmt.Printf("%s: %d\n", "en", enFormula(0)) + fmt.Printf("%s: %d\n", "en", enFormula(1)) + fmt.Printf("%s: %d\n", "en", enFormula(2)) + fmt.Printf("%s: %d\n", "??", xxFormula(0)) + fmt.Printf("%s: %d\n", "??", xxFormula(1)) + fmt.Printf("%s: %d\n", "??", xxFormula(2)) + fmt.Printf("%s: %d\n", "??", xxFormula(9)) + // Output: + // en: 0 + // en: 0 + // en: 1 + // ??: 0 + // ??: 0 + // ??: 1 + // ??: 8 + } + +See http://www.gnu.org/software/gettext/manual/html_node/Plural-forms.html +*/ +package plural diff --git a/vendor/github.com/chai2010/gettext-go/gettext/plural/formula.go b/vendor/github.com/chai2010/gettext-go/gettext/plural/formula.go new file mode 100644 index 0000000000..679a1cd50d --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/plural/formula.go @@ -0,0 +1,181 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plural + +import ( + "strings" +) + +// Formula provides the language's standard plural formula. +func Formula(lang string) func(n int) int { + if idx := index(lang); idx != -1 { + return formulaTable[fmtForms(FormsTable[idx].Value)] + } + if idx := index("??"); idx != -1 { + return formulaTable[fmtForms(FormsTable[idx].Value)] + } + return func(n int) int { + return n + } +} + +func index(lang string) int { + for i := 0; i < len(FormsTable); i++ { + if strings.HasPrefix(lang, FormsTable[i].Lang) { + return i + } + } + return -1 +} + +func fmtForms(forms string) string { + forms = strings.TrimSpace(forms) + forms = strings.Replace(forms, " ", "", -1) + return forms +} + +var formulaTable = map[string]func(n int) int{ + fmtForms("nplurals=n; plural=n-1;"): func(n int) int { + if n > 0 { + return n - 1 + } + return 0 + }, + fmtForms("nplurals=1; plural=0;"): func(n int) int { + return 0 + }, + fmtForms("nplurals=2; plural=(n != 1);"): func(n int) int { + if n <= 1 { + return 0 + } + return 1 + }, + fmtForms("nplurals=2; plural=(n > 1);"): func(n int) int { + if n <= 1 { + return 0 + } + return 1 + }, + fmtForms("nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2);"): func(n int) int { + if n%10 == 1 && n%100 != 11 { + return 0 + } + if n != 0 { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=n==1 ? 0 : n==2 ? 1 : 2;"): func(n int) int { + if n == 1 { + return 0 + } + if n == 2 { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=n==1 ? 0 : (n==0 || (n%100 > 0 && n%100 < 20)) ? 1 : 2;"): func(n int) int { + if n == 1 { + return 0 + } + if n == 0 || (n%100 > 0 && n%100 < 20) { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2);"): func(n int) int { + if n%10 == 1 && n%100 != 11 { + return 0 + } + if n%10 >= 2 && (n%100 < 10 || n%100 >= 20) { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"): func(n int) int { + if n%10 == 1 && n%100 != 11 { + return 0 + } + if n%10 >= 2 && n%10 <= 4 && (n%100 < 10 || n%100 >= 20) { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"): func(n int) int { + if n%10 == 1 && n%100 != 11 { + return 0 + } + if n%10 >= 2 && n%10 <= 4 && (n%100 < 10 || n%100 >= 20) { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"): func(n int) int { + if n%10 == 1 && n%100 != 11 { + return 0 + } + if n%10 >= 2 && n%10 <= 4 && (n%100 < 10 || n%100 >= 20) { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"): func(n int) int { + if n%10 == 1 && n%100 != 11 { + return 0 + } + if n%10 >= 2 && n%10 <= 4 && (n%100 < 10 || n%100 >= 20) { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"): func(n int) int { + if n%10 == 1 && n%100 != 11 { + return 0 + } + if n%10 >= 2 && n%10 <= 4 && (n%100 < 10 || n%100 >= 20) { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;"): func(n int) int { + if n == 1 { + return 0 + } + if n >= 2 && n <= 4 { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;"): func(n int) int { + if n == 1 { + return 0 + } + if n >= 2 && n <= 4 { + return 1 + } + return 2 + }, + fmtForms("nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"): func(n int) int { + if n == 1 { + return 0 + } + if n%10 >= 2 && n%10 <= 4 && (n%100 < 10 || n%100 >= 20) { + return 1 + } + return 2 + }, + fmtForms("nplurals=4; plural=(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3);"): func(n int) int { + if n%100 == 1 { + return 0 + } + if n%100 == 2 { + return 1 + } + if n%100 == 3 || n%100 == 4 { + return 2 + } + return 3 + }, +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/plural/table.go b/vendor/github.com/chai2010/gettext-go/gettext/plural/table.go new file mode 100644 index 0000000000..cdc50d2110 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/plural/table.go @@ -0,0 +1,55 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plural + +// FormsTable are standard hard-coded plural rules. +// The application developers and the translators need to understand them. +// +// See GNU's gettext library source code: gettext/gettext-tools/src/plural-table.c +var FormsTable = []struct { + Lang string + Language string + Value string +}{ + {"??", "Unknown", "nplurals=1; plural=0;"}, + {"ja", "Japanese", "nplurals=1; plural=0;"}, + {"vi", "Vietnamese", "nplurals=1; plural=0;"}, + {"ko", "Korean", "nplurals=1; plural=0;"}, + {"en", "English", "nplurals=2; plural=(n != 1);"}, + {"de", "German", "nplurals=2; plural=(n != 1);"}, + {"nl", "Dutch", "nplurals=2; plural=(n != 1);"}, + {"sv", "Swedish", "nplurals=2; plural=(n != 1);"}, + {"da", "Danish", "nplurals=2; plural=(n != 1);"}, + {"no", "Norwegian", "nplurals=2; plural=(n != 1);"}, + {"nb", "Norwegian Bokmal", "nplurals=2; plural=(n != 1);"}, + {"nn", "Norwegian Nynorsk", "nplurals=2; plural=(n != 1);"}, + {"fo", "Faroese", "nplurals=2; plural=(n != 1);"}, + {"es", "Spanish", "nplurals=2; plural=(n != 1);"}, + {"pt", "Portuguese", "nplurals=2; plural=(n != 1);"}, + {"it", "Italian", "nplurals=2; plural=(n != 1);"}, + {"bg", "Bulgarian", "nplurals=2; plural=(n != 1);"}, + {"el", "Greek", "nplurals=2; plural=(n != 1);"}, + {"fi", "Finnish", "nplurals=2; plural=(n != 1);"}, + {"et", "Estonian", "nplurals=2; plural=(n != 1);"}, + {"he", "Hebrew", "nplurals=2; plural=(n != 1);"}, + {"eo", "Esperanto", "nplurals=2; plural=(n != 1);"}, + {"hu", "Hungarian", "nplurals=2; plural=(n != 1);"}, + {"tr", "Turkish", "nplurals=2; plural=(n != 1);"}, + {"pt_BR", "Brazilian", "nplurals=2; plural=(n > 1);"}, + {"fr", "French", "nplurals=2; plural=(n > 1);"}, + {"lv", "Latvian", "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2);"}, + {"ga", "Irish", "nplurals=3; plural=n==1 ? 0 : n==2 ? 1 : 2;"}, + {"ro", "Romanian", "nplurals=3; plural=n==1 ? 0 : (n==0 || (n%100 > 0 && n%100 < 20)) ? 1 : 2;"}, + {"lt", "Lithuanian", "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2);"}, + {"ru", "Russian", "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"}, + {"uk", "Ukrainian", "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"}, + {"be", "Belarusian", "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"}, + {"sr", "Serbian", "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"}, + {"hr", "Croatian", "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"}, + {"cs", "Czech", "nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;"}, + {"sk", "Slovak", "nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;"}, + {"pl", "Polish", "nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"}, + {"sl", "Slovenian", "nplurals=4; plural=(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3);"}, +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/po/comment.go b/vendor/github.com/chai2010/gettext-go/gettext/po/comment.go new file mode 100644 index 0000000000..d4abe7c106 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/po/comment.go @@ -0,0 +1,270 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package po + +import ( + "bytes" + "fmt" + "io" + "strconv" + "strings" +) + +// Comment represents every message's comments. +type Comment struct { + StartLine int // comment start line + TranslatorComment string // # translator-comments // TrimSpace + ExtractedComment string // #. extracted-comments + ReferenceFile []string // #: src/msgcmp.c:338 src/po-lex.c:699 + ReferenceLine []int // #: src/msgcmp.c:338 src/po-lex.c:699 + Flags []string // #, fuzzy,c-format,range:0..10 + PrevMsgContext string // #| msgctxt previous-context + PrevMsgId string // #| msgid previous-untranslated-string +} + +func (p *Comment) less(q *Comment) bool { + if p.StartLine != 0 || q.StartLine != 0 { + return p.StartLine < q.StartLine + } + if a, b := len(p.ReferenceFile), len(q.ReferenceFile); a != b { + return a < b + } + for i := 0; i < len(p.ReferenceFile); i++ { + if a, b := p.ReferenceFile[i], q.ReferenceFile[i]; a != b { + return a < b + } + if a, b := p.ReferenceLine[i], q.ReferenceLine[i]; a != b { + return a < b + } + } + return false +} + +func (p *Comment) readPoComment(r *lineReader) (err error) { + *p = Comment{} + if err = r.skipBlankLine(); err != nil { + return err + } + defer func(oldPos int) { + newPos := r.currentPos() + if newPos != oldPos && err == io.EOF { + err = nil + } + }(r.currentPos()) + + p.StartLine = r.currentPos() + 1 + for { + var s string + if s, _, err = r.currentLine(); err != nil { + return + } + if len(s) == 0 || s[0] != '#' { + return + } + + if err = p.readTranslatorComment(r); err != nil { + return + } + if err = p.readExtractedComment(r); err != nil { + return + } + if err = p.readReferenceComment(r); err != nil { + return + } + if err = p.readFlagsComment(r); err != nil { + return + } + if err = p.readPrevMsgContext(r); err != nil { + return + } + if err = p.readPrevMsgId(r); err != nil { + return + } + } +} + +func (p *Comment) readTranslatorComment(r *lineReader) (err error) { + const prefix = "# " // .,:| + for { + var s string + if s, _, err = r.readLine(); err != nil { + return err + } + if len(s) < 1 || s[0] != '#' { + r.unreadLine() + return nil + } + if len(s) >= 2 { + switch s[1] { + case '.', ',', ':', '|': + r.unreadLine() + return nil + } + } + if p.TranslatorComment != "" { + p.TranslatorComment += "\n" + } + p.TranslatorComment += strings.TrimSpace(s[1:]) + } +} + +func (p *Comment) readExtractedComment(r *lineReader) (err error) { + const prefix = "#." + for { + var s string + if s, _, err = r.readLine(); err != nil { + return err + } + if len(s) < len(prefix) || s[:len(prefix)] != prefix { + r.unreadLine() + return nil + } + if p.ExtractedComment != "" { + p.ExtractedComment += "\n" + } + p.ExtractedComment += strings.TrimSpace(s[len(prefix):]) + } +} + +func (p *Comment) readReferenceComment(r *lineReader) (err error) { + const prefix = "#:" + for { + var s string + if s, _, err = r.readLine(); err != nil { + return err + } + if len(s) < len(prefix) || s[:len(prefix)] != prefix { + r.unreadLine() + return nil + } + ss := strings.Split(strings.TrimSpace(s[len(prefix):]), " ") + for i := 0; i < len(ss); i++ { + idx := strings.Index(ss[i], ":") + if idx <= 0 { + continue + } + name := strings.TrimSpace(ss[i][:idx]) + line, _ := strconv.Atoi(strings.TrimSpace(ss[i][idx+1:])) + p.ReferenceFile = append(p.ReferenceFile, name) + p.ReferenceLine = append(p.ReferenceLine, line) + } + } +} + +func (p *Comment) readFlagsComment(r *lineReader) (err error) { + const prefix = "#," + for { + var s string + if s, _, err = r.readLine(); err != nil { + return err + } + if len(s) < len(prefix) || s[:len(prefix)] != prefix { + r.unreadLine() + return nil + } + ss := strings.Split(strings.TrimSpace(s[len(prefix):]), ",") + for i := 0; i < len(ss); i++ { + p.Flags = append(p.Flags, strings.TrimSpace(ss[i])) + } + } +} + +func (p *Comment) readPrevMsgContext(r *lineReader) (err error) { + var s string + if s, _, err = r.currentLine(); err != nil { + return + } + if !rePrevMsgContextComments.MatchString(s) { + return + } + p.PrevMsgContext, err = p.readString(r) + return +} + +func (p *Comment) readPrevMsgId(r *lineReader) (err error) { + var s string + if s, _, err = r.currentLine(); err != nil { + return + } + if !rePrevMsgIdComments.MatchString(s) { + return + } + p.PrevMsgId, err = p.readString(r) + return +} + +func (p *Comment) readString(r *lineReader) (msg string, err error) { + var s string + if s, _, err = r.readLine(); err != nil { + return + } + msg += decodePoString(s) + for { + if s, _, err = r.readLine(); err != nil { + return + } + if !reStringLineComments.MatchString(s) { + r.unreadLine() + break + } + msg += decodePoString(s) + } + return +} + +// GetFuzzy gets the fuzzy flag. +func (p *Comment) GetFuzzy() bool { + for _, s := range p.Flags { + if s == "fuzzy" { + return true + } + } + return false +} + +// SetFuzzy sets the fuzzy flag. +func (p *Comment) SetFuzzy(fuzzy bool) { + // +} + +// String returns the po format comment string. +func (p Comment) String() string { + var buf bytes.Buffer + if p.TranslatorComment != "" { + ss := strings.Split(p.TranslatorComment, "\n") + for i := 0; i < len(ss); i++ { + fmt.Fprintf(&buf, "# %s\n", ss[i]) + } + } + if p.ExtractedComment != "" { + ss := strings.Split(p.ExtractedComment, "\n") + for i := 0; i < len(ss); i++ { + fmt.Fprintf(&buf, "#. %s\n", ss[i]) + } + } + if a, b := len(p.ReferenceFile), len(p.ReferenceLine); a != 0 && a == b { + fmt.Fprintf(&buf, "#:") + for i := 0; i < len(p.ReferenceFile); i++ { + fmt.Fprintf(&buf, " %s:%d", p.ReferenceFile[i], p.ReferenceLine[i]) + } + fmt.Fprintf(&buf, "\n") + } + if len(p.Flags) != 0 { + fmt.Fprintf(&buf, "#, %s", p.Flags[0]) + for i := 1; i < len(p.Flags); i++ { + fmt.Fprintf(&buf, ", %s", p.Flags[i]) + } + fmt.Fprintf(&buf, "\n") + } + if p.PrevMsgContext != "" { + s := encodeCommentPoString(p.PrevMsgContext) + fmt.Fprintf(&buf, "#| msgctxt %s\n", s) + } + if p.PrevMsgId != "" { + s := encodeCommentPoString(p.PrevMsgId) + fmt.Fprintf(&buf, "#| msgid %s\n", s) + } + return buf.String() +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/po/doc.go b/vendor/github.com/chai2010/gettext-go/gettext/po/doc.go new file mode 100644 index 0000000000..12bac8f2a2 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/po/doc.go @@ -0,0 +1,24 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package po provides support for reading and writing GNU PO file. + +Examples: + import ( + "github.com/chai2010/gettext-go/gettext/po" + ) + + func main() { + poFile, err := po.Load("test.po") + if err != nil { + log.Fatal(err) + } + fmt.Printf("%v", poFile) + } + +The GNU PO file specification is at +http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html. +*/ +package po diff --git a/vendor/github.com/chai2010/gettext-go/gettext/po/file.go b/vendor/github.com/chai2010/gettext-go/gettext/po/file.go new file mode 100644 index 0000000000..a9b7abf949 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/po/file.go @@ -0,0 +1,75 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package po + +import ( + "bytes" + "fmt" + "io" + "io/ioutil" + "sort" +) + +// File represents an PO File. +// +// See http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html +type File struct { + MimeHeader Header + Messages []Message +} + +// Load loads a named po file. +func Load(name string) (*File, error) { + data, err := ioutil.ReadFile(name) + if err != nil { + return nil, err + } + return LoadData(data) +} + +// LoadData loads po file format data. +func LoadData(data []byte) (*File, error) { + r := newLineReader(string(data)) + var file File + for { + var msg Message + if err := msg.readPoEntry(r); err != nil { + if err == io.EOF { + return &file, nil + } + return nil, err + } + if msg.MsgId == "" { + file.MimeHeader.parseHeader(&msg) + continue + } + file.Messages = append(file.Messages, msg) + } +} + +// Save saves a po file. +func (f *File) Save(name string) error { + return ioutil.WriteFile(name, []byte(f.String()), 0666) +} + +// Save returns a po file format data. +func (f *File) Data() []byte { + // sort the massge as ReferenceFile/ReferenceLine field + var messages []Message + messages = append(messages, f.Messages...) + sort.Sort(byMessages(messages)) + + var buf bytes.Buffer + fmt.Fprintf(&buf, "%s\n", f.MimeHeader.String()) + for i := 0; i < len(messages); i++ { + fmt.Fprintf(&buf, "%s\n", messages[i].String()) + } + return buf.Bytes() +} + +// String returns the po format file string. +func (f *File) String() string { + return string(f.Data()) +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/po/header.go b/vendor/github.com/chai2010/gettext-go/gettext/po/header.go new file mode 100644 index 0000000000..a9b5b6671b --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/po/header.go @@ -0,0 +1,106 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package po + +import ( + "bytes" + "fmt" + "strings" +) + +// Header is the initial comments "SOME DESCRIPTIVE TITLE", "YEAR" +// and "FIRST AUTHOR , YEAR" ought to be replaced by sensible information. +// +// See http://www.gnu.org/software/gettext/manual/html_node/Header-Entry.html#Header-Entry +type Header struct { + Comment // Header Comments + ProjectIdVersion string // Project-Id-Version: PACKAGE VERSION + ReportMsgidBugsTo string // Report-Msgid-Bugs-To: FIRST AUTHOR + POTCreationDate string // POT-Creation-Date: YEAR-MO-DA HO:MI+ZONE + PORevisionDate string // PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE + LastTranslator string // Last-Translator: FIRST AUTHOR + LanguageTeam string // Language-Team: golang-china + Language string // Language: zh_CN + MimeVersion string // MIME-Version: 1.0 + ContentType string // Content-Type: text/plain; charset=UTF-8 + ContentTransferEncoding string // Content-Transfer-Encoding: 8bit + PluralForms string // Plural-Forms: nplurals=2; plural=n == 1 ? 0 : 1; + XGenerator string // X-Generator: Poedit 1.5.5 + UnknowFields map[string]string +} + +func (p *Header) parseHeader(msg *Message) { + if msg.MsgId != "" || msg.MsgStr == "" { + return + } + lines := strings.Split(msg.MsgStr, "\n") + for i := 0; i < len(lines); i++ { + idx := strings.Index(lines[i], ":") + if idx < 0 { + continue + } + key := strings.TrimSpace(lines[i][:idx]) + val := strings.TrimSpace(lines[i][idx+1:]) + switch strings.ToUpper(key) { + case strings.ToUpper("Project-Id-Version"): + p.ProjectIdVersion = val + case strings.ToUpper("Report-Msgid-Bugs-To"): + p.ReportMsgidBugsTo = val + case strings.ToUpper("POT-Creation-Date"): + p.POTCreationDate = val + case strings.ToUpper("PO-Revision-Date"): + p.PORevisionDate = val + case strings.ToUpper("Last-Translator"): + p.LastTranslator = val + case strings.ToUpper("Language-Team"): + p.LanguageTeam = val + case strings.ToUpper("Language"): + p.Language = val + case strings.ToUpper("MIME-Version"): + p.MimeVersion = val + case strings.ToUpper("Content-Type"): + p.ContentType = val + case strings.ToUpper("Content-Transfer-Encoding"): + p.ContentTransferEncoding = val + case strings.ToUpper("Plural-Forms"): + p.PluralForms = val + case strings.ToUpper("X-Generator"): + p.XGenerator = val + default: + if p.UnknowFields == nil { + p.UnknowFields = make(map[string]string) + } + p.UnknowFields[key] = val + } + } + p.Comment = msg.Comment +} + +// String returns the po format header string. +func (p Header) String() string { + var buf bytes.Buffer + fmt.Fprintf(&buf, "%s", p.Comment.String()) + fmt.Fprintf(&buf, `msgid ""`+"\n") + fmt.Fprintf(&buf, `msgstr ""`+"\n") + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Project-Id-Version", p.ProjectIdVersion) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Report-Msgid-Bugs-To", p.ReportMsgidBugsTo) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "POT-Creation-Date", p.POTCreationDate) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "PO-Revision-Date", p.PORevisionDate) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Last-Translator", p.LastTranslator) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Language-Team", p.LanguageTeam) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Language", p.Language) + if p.MimeVersion != "" { + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "MIME-Version", p.MimeVersion) + } + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Content-Type", p.ContentType) + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "Content-Transfer-Encoding", p.ContentTransferEncoding) + if p.XGenerator != "" { + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", "X-Generator", p.XGenerator) + } + for k, v := range p.UnknowFields { + fmt.Fprintf(&buf, `"%s: %s\n"`+"\n", k, v) + } + return buf.String() +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/po/line_reader.go b/vendor/github.com/chai2010/gettext-go/gettext/po/line_reader.go new file mode 100644 index 0000000000..8597273a2b --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/po/line_reader.go @@ -0,0 +1,62 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package po + +import ( + "io" + "strings" +) + +type lineReader struct { + lines []string + pos int +} + +func newLineReader(data string) *lineReader { + data = strings.Replace(data, "\r", "", -1) + lines := strings.Split(data, "\n") + return &lineReader{lines: lines} +} + +func (r *lineReader) skipBlankLine() error { + for ; r.pos < len(r.lines); r.pos++ { + if strings.TrimSpace(r.lines[r.pos]) != "" { + break + } + } + if r.pos >= len(r.lines) { + return io.EOF + } + return nil +} + +func (r *lineReader) currentPos() int { + return r.pos +} + +func (r *lineReader) currentLine() (s string, pos int, err error) { + if r.pos >= len(r.lines) { + err = io.EOF + return + } + s, pos = r.lines[r.pos], r.pos + return +} + +func (r *lineReader) readLine() (s string, pos int, err error) { + if r.pos >= len(r.lines) { + err = io.EOF + return + } + s, pos = r.lines[r.pos], r.pos + r.pos++ + return +} + +func (r *lineReader) unreadLine() { + if r.pos >= 0 { + r.pos-- + } +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/po/message.go b/vendor/github.com/chai2010/gettext-go/gettext/po/message.go new file mode 100644 index 0000000000..a2cf2512c7 --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/po/message.go @@ -0,0 +1,189 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package po + +import ( + "bytes" + "fmt" + "io" + "strconv" + "strings" +) + +// A PO file is made up of many entries, +// each entry holding the relation between an original untranslated string +// and its corresponding translation. +// +// See http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html +type Message struct { + Comment // Coments + MsgContext string // msgctxt context + MsgId string // msgid untranslated-string + MsgIdPlural string // msgid_plural untranslated-string-plural + MsgStr string // msgstr translated-string + MsgStrPlural []string // msgstr[0] translated-string-case-0 +} + +type byMessages []Message + +func (d byMessages) Len() int { + return len(d) +} +func (d byMessages) Less(i, j int) bool { + if d[i].Comment.less(&d[j].Comment) { + return true + } + if a, b := d[i].MsgContext, d[j].MsgContext; a != b { + return a < b + } + if a, b := d[i].MsgId, d[j].MsgId; a != b { + return a < b + } + if a, b := d[i].MsgIdPlural, d[j].MsgIdPlural; a != b { + return a < b + } + return false +} +func (d byMessages) Swap(i, j int) { + d[i], d[j] = d[j], d[i] +} + +func (p *Message) readPoEntry(r *lineReader) (err error) { + *p = Message{} + if err = r.skipBlankLine(); err != nil { + return + } + defer func(oldPos int) { + newPos := r.currentPos() + if newPos != oldPos && err == io.EOF { + err = nil + } + }(r.currentPos()) + + if err = p.Comment.readPoComment(r); err != nil { + return + } + for { + var s string + if s, _, err = r.currentLine(); err != nil { + return + } + + if p.isInvalidLine(s) { + err = fmt.Errorf("gettext: line %d, %v", r.currentPos(), "invalid line") + return + } + if reComment.MatchString(s) || reBlankLine.MatchString(s) { + return + } + + if err = p.readMsgContext(r); err != nil { + return + } + if err = p.readMsgId(r); err != nil { + return + } + if err = p.readMsgIdPlural(r); err != nil { + return + } + if err = p.readMsgStrOrPlural(r); err != nil { + return + } + } +} + +func (p *Message) readMsgContext(r *lineReader) (err error) { + var s string + if s, _, err = r.currentLine(); err != nil { + return + } + if !reMsgContext.MatchString(s) { + return + } + p.MsgContext, err = p.readString(r) + return +} + +func (p *Message) readMsgId(r *lineReader) (err error) { + var s string + if s, _, err = r.currentLine(); err != nil { + return + } + if !reMsgId.MatchString(s) { + return + } + p.MsgId, err = p.readString(r) + return +} + +func (p *Message) readMsgIdPlural(r *lineReader) (err error) { + var s string + if s, _, err = r.currentLine(); err != nil { + return + } + if !reMsgIdPlural.MatchString(s) { + return + } + p.MsgIdPlural, err = p.readString(r) + return nil +} + +func (p *Message) readMsgStrOrPlural(r *lineReader) (err error) { + var s string + if s, _, err = r.currentLine(); err != nil { + return + } + if !reMsgStr.MatchString(s) && !reMsgStrPlural.MatchString(s) { + return + } + if reMsgStrPlural.MatchString(s) { + left, right := strings.Index(s, `[`), strings.LastIndex(s, `]`) + idx, _ := strconv.Atoi(s[left+1 : right]) + s, err = p.readString(r) + if n := len(p.MsgStrPlural); (idx + 1) > n { + p.MsgStrPlural = append(p.MsgStrPlural, make([]string, (idx+1)-n)...) + } + p.MsgStrPlural[idx] = s + } else { + p.MsgStr, err = p.readString(r) + } + return nil +} + +func (p *Message) readString(r *lineReader) (msg string, err error) { + var s string + if s, _, err = r.readLine(); err != nil { + return + } + msg += decodePoString(s) + for { + if s, _, err = r.readLine(); err != nil { + return + } + if !reStringLine.MatchString(s) { + r.unreadLine() + break + } + msg += decodePoString(s) + } + return +} + +// String returns the po format entry string. +func (p Message) String() string { + var buf bytes.Buffer + fmt.Fprintf(&buf, "%s", p.Comment.String()) + fmt.Fprintf(&buf, "msgid %s", encodePoString(p.MsgId)) + if p.MsgIdPlural != "" { + fmt.Fprintf(&buf, "msgid_plural %s", encodePoString(p.MsgIdPlural)) + } + if p.MsgStr != "" { + fmt.Fprintf(&buf, "msgstr %s", encodePoString(p.MsgStr)) + } + for i := 0; i < len(p.MsgStrPlural); i++ { + fmt.Fprintf(&buf, "msgstr[%d] %s", i, encodePoString(p.MsgStrPlural[i])) + } + return buf.String() +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/po/re.go b/vendor/github.com/chai2010/gettext-go/gettext/po/re.go new file mode 100644 index 0000000000..67c240a57b --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/po/re.go @@ -0,0 +1,58 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package po + +import ( + "regexp" +) + +var ( + reComment = regexp.MustCompile(`^#`) // # + reExtractedComments = regexp.MustCompile(`^#\.`) // #. + reReferenceComments = regexp.MustCompile(`^#:`) // #: + reFlagsComments = regexp.MustCompile(`^#,`) // #, fuzzy,c-format + rePrevMsgContextComments = regexp.MustCompile(`^#\|\s+msgctxt`) // #| msgctxt + rePrevMsgIdComments = regexp.MustCompile(`^#\|\s+msgid`) // #| msgid + reStringLineComments = regexp.MustCompile(`^#\|\s+".*"\s*$`) // #| "message" + + reMsgContext = regexp.MustCompile(`^msgctxt\s+".*"\s*$`) // msgctxt + reMsgId = regexp.MustCompile(`^msgid\s+".*"\s*$`) // msgid + reMsgIdPlural = regexp.MustCompile(`^msgid_plural\s+".*"\s*$`) // msgid_plural + reMsgStr = regexp.MustCompile(`^msgstr\s*".*"\s*$`) // msgstr + reMsgStrPlural = regexp.MustCompile(`^msgstr\s*(\[\d+\])\s*".*"\s*$`) // msgstr[0] + reStringLine = regexp.MustCompile(`^\s*".*"\s*$`) // "message" + reBlankLine = regexp.MustCompile(`^\s*$`) // +) + +func (p *Message) isInvalidLine(s string) bool { + if reComment.MatchString(s) { + return false + } + if reBlankLine.MatchString(s) { + return false + } + + if reMsgContext.MatchString(s) { + return false + } + if reMsgId.MatchString(s) { + return false + } + if reMsgIdPlural.MatchString(s) { + return false + } + if reMsgStr.MatchString(s) { + return false + } + if reMsgStrPlural.MatchString(s) { + return false + } + + if reStringLine.MatchString(s) { + return false + } + + return true +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/po/util.go b/vendor/github.com/chai2010/gettext-go/gettext/po/util.go new file mode 100644 index 0000000000..52544832cf --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/po/util.go @@ -0,0 +1,110 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package po + +import ( + "bytes" + "strings" +) + +func decodePoString(text string) string { + lines := strings.Split(text, "\n") + for i := 0; i < len(lines); i++ { + left := strings.Index(lines[i], `"`) + right := strings.LastIndex(lines[i], `"`) + if left < 0 || right < 0 || left == right { + lines[i] = "" + continue + } + line := lines[i][left+1 : right] + data := make([]byte, 0, len(line)) + for i := 0; i < len(line); i++ { + if line[i] != '\\' { + data = append(data, line[i]) + continue + } + if i+1 >= len(line) { + break + } + switch line[i+1] { + case 'n': // \\n -> \n + data = append(data, '\n') + i++ + case 't': // \\t -> \n + data = append(data, '\t') + i++ + case '\\': // \\\ -> ? + data = append(data, '\\') + i++ + } + } + lines[i] = string(data) + } + return strings.Join(lines, "") +} + +func encodePoString(text string) string { + var buf bytes.Buffer + lines := strings.Split(text, "\n") + for i := 0; i < len(lines); i++ { + if lines[i] == "" { + if i != len(lines)-1 { + buf.WriteString(`"\n"` + "\n") + } + continue + } + buf.WriteRune('"') + for _, r := range lines[i] { + switch r { + case '\\': + buf.WriteString(`\\`) + case '"': + buf.WriteString(`\"`) + case '\n': + buf.WriteString(`\n`) + case '\t': + buf.WriteString(`\t`) + default: + buf.WriteRune(r) + } + } + buf.WriteString(`\n"` + "\n") + } + return buf.String() +} + +func encodeCommentPoString(text string) string { + var buf bytes.Buffer + lines := strings.Split(text, "\n") + if len(lines) > 1 { + buf.WriteString(`""` + "\n") + } + for i := 0; i < len(lines); i++ { + if len(lines) > 0 { + buf.WriteString("#| ") + } + buf.WriteRune('"') + for _, r := range lines[i] { + switch r { + case '\\': + buf.WriteString(`\\`) + case '"': + buf.WriteString(`\"`) + case '\n': + buf.WriteString(`\n`) + case '\t': + buf.WriteString(`\t`) + default: + buf.WriteRune(r) + } + } + if i < len(lines)-1 { + buf.WriteString(`\n"` + "\n") + } else { + buf.WriteString(`"`) + } + } + return buf.String() +} diff --git a/vendor/github.com/chai2010/gettext-go/gettext/tr.go b/vendor/github.com/chai2010/gettext-go/gettext/tr.go new file mode 100644 index 0000000000..fedfbc301d --- /dev/null +++ b/vendor/github.com/chai2010/gettext-go/gettext/tr.go @@ -0,0 +1,128 @@ +// Copyright 2013 ChaiShushan . All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package gettext + +import ( + "github.com/chai2010/gettext-go/gettext/mo" + "github.com/chai2010/gettext-go/gettext/plural" + "github.com/chai2010/gettext-go/gettext/po" +) + +var nilTranslator = &translator{ + MessageMap: make(map[string]mo.Message), + PluralFormula: plural.Formula("??"), +} + +type translator struct { + MessageMap map[string]mo.Message + PluralFormula func(n int) int +} + +func newMoTranslator(name string, data []byte) (*translator, error) { + var ( + f *mo.File + err error + ) + if len(data) != 0 { + f, err = mo.LoadData(data) + } else { + f, err = mo.Load(name) + } + if err != nil { + return nil, err + } + var tr = &translator{ + MessageMap: make(map[string]mo.Message), + } + for _, v := range f.Messages { + tr.MessageMap[tr.makeMapKey(v.MsgContext, v.MsgId)] = v + } + if lang := f.MimeHeader.Language; lang != "" { + tr.PluralFormula = plural.Formula(lang) + } else { + tr.PluralFormula = plural.Formula("??") + } + return tr, nil +} + +func newPoTranslator(name string, data []byte) (*translator, error) { + var ( + f *po.File + err error + ) + if len(data) != 0 { + f, err = po.LoadData(data) + } else { + f, err = po.Load(name) + } + if err != nil { + return nil, err + } + var tr = &translator{ + MessageMap: make(map[string]mo.Message), + } + for _, v := range f.Messages { + tr.MessageMap[tr.makeMapKey(v.MsgContext, v.MsgId)] = mo.Message{ + MsgContext: v.MsgContext, + MsgId: v.MsgId, + MsgIdPlural: v.MsgIdPlural, + MsgStr: v.MsgStr, + MsgStrPlural: v.MsgStrPlural, + } + } + if lang := f.MimeHeader.Language; lang != "" { + tr.PluralFormula = plural.Formula(lang) + } else { + tr.PluralFormula = plural.Formula("??") + } + return tr, nil +} + +func (p *translator) PGettext(msgctxt, msgid string) string { + return p.PNGettext(msgctxt, msgid, "", 0) +} + +func (p *translator) PNGettext(msgctxt, msgid, msgidPlural string, n int) string { + n = p.PluralFormula(n) + if ss := p.findMsgStrPlural(msgctxt, msgid, msgidPlural); len(ss) != 0 { + if n >= len(ss) { + n = len(ss) - 1 + } + if ss[n] != "" { + return ss[n] + } + } + if msgidPlural != "" && n > 0 { + return msgidPlural + } + return msgid +} + +func (p *translator) findMsgStrPlural(msgctxt, msgid, msgidPlural string) []string { + key := p.makeMapKey(msgctxt, msgid) + if v, ok := p.MessageMap[key]; ok { + if len(v.MsgIdPlural) != 0 { + if len(v.MsgStrPlural) != 0 { + return v.MsgStrPlural + } else { + return nil + } + } else { + if len(v.MsgStr) != 0 { + return []string{v.MsgStr} + } else { + return nil + } + } + } + return nil +} + +func (p *translator) makeMapKey(msgctxt, msgid string) string { + if msgctxt != "" { + return msgctxt + mo.EotSeparator + msgid + } + return msgid +} diff --git a/vendor/github.com/docker/cli/cli/config/config.go b/vendor/github.com/docker/cli/cli/config/config.go index 98147e270a..93275f3d98 100644 --- a/vendor/github.com/docker/cli/cli/config/config.go +++ b/vendor/github.com/docker/cli/cli/config/config.go @@ -24,12 +24,12 @@ const ( ) var ( - initConfigDir sync.Once + initConfigDir = new(sync.Once) configDir string homeDir string ) -// resetHomeDir is used in testing to resets the "homeDir" package variable to +// resetHomeDir is used in testing to reset the "homeDir" package variable to // force re-lookup of the home directory between tests. func resetHomeDir() { homeDir = "" @@ -42,6 +42,13 @@ func getHomeDir() string { return homeDir } +// resetConfigDir is used in testing to reset the "configDir" package variable +// and its sync.Once to force re-lookup between tests. +func resetConfigDir() { + configDir = "" + initConfigDir = new(sync.Once) +} + func setConfigDir() { if configDir != "" { return @@ -97,10 +104,15 @@ func LoadFromReader(configData io.Reader) (*configfile.ConfigFile, error) { return &configFile, err } +// TODO remove this temporary hack, which is used to warn about the deprecated ~/.dockercfg file +var printLegacyFileWarning bool + // Load reads the configuration files in the given directory, and sets up // the auth config information and returns values. // FIXME: use the internal golang config parser func Load(configDir string) (*configfile.ConfigFile, error) { + printLegacyFileWarning = false + if configDir == "" { configDir = Dir() } @@ -125,6 +137,7 @@ func Load(configDir string) (*configfile.ConfigFile, error) { // Can't find latest config file so check for the old one filename = filepath.Join(getHomeDir(), oldConfigfile) if file, err := os.Open(filename); err == nil { + printLegacyFileWarning = true defer file.Close() if err := configFile.LegacyLoadFromReader(file); err != nil { return configFile, errors.Wrap(err, filename) @@ -140,6 +153,9 @@ func LoadDefaultConfigFile(stderr io.Writer) *configfile.ConfigFile { if err != nil { fmt.Fprintf(stderr, "WARNING: Error loading config file: %v\n", err) } + if printLegacyFileWarning { + _, _ = fmt.Fprintln(stderr, "WARNING: Support for the legacy ~/.dockercfg configuration file and file-format is deprecated and will be removed in an upcoming release") + } if !configFile.ContainsAuth() { configFile.CredentialsStore = credentials.DetectDefaultStore(configFile.CredentialsStore) } diff --git a/vendor/github.com/evanphx/json-patch/.gitignore b/vendor/github.com/evanphx/json-patch/.gitignore new file mode 100644 index 0000000000..b7ed7f956d --- /dev/null +++ b/vendor/github.com/evanphx/json-patch/.gitignore @@ -0,0 +1,6 @@ +# editor and IDE paraphernalia +.idea +.vscode + +# macOS paraphernalia +.DS_Store diff --git a/vendor/github.com/evanphx/json-patch/patch.go b/vendor/github.com/evanphx/json-patch/patch.go index 1829854907..dc2b7e51e6 100644 --- a/vendor/github.com/evanphx/json-patch/patch.go +++ b/vendor/github.com/evanphx/json-patch/patch.go @@ -412,6 +412,17 @@ func (d *partialArray) set(key string, val *lazyNode) error { if err != nil { return err } + + if idx < 0 { + if !SupportNegativeIndices { + return errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx) + } + if idx < -len(*d) { + return errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx) + } + idx += len(*d) + } + (*d)[idx] = val return nil } @@ -462,6 +473,16 @@ func (d *partialArray) get(key string) (*lazyNode, error) { return nil, err } + if idx < 0 { + if !SupportNegativeIndices { + return nil, errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx) + } + if idx < -len(*d) { + return nil, errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx) + } + idx += len(*d) + } + if idx >= len(*d) { return nil, errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx) } @@ -547,6 +568,29 @@ func (p Patch) replace(doc *container, op Operation) error { return errors.Wrapf(err, "replace operation failed to decode path") } + if path == "" { + val := op.value() + + if val.which == eRaw { + if !val.tryDoc() { + if !val.tryAry() { + return errors.Wrapf(err, "replace operation value must be object or array") + } + } + } + + switch val.which { + case eAry: + *doc = &val.ary + case eDoc: + *doc = &val.doc + case eRaw: + return errors.Wrapf(err, "replace operation hit impossible case") + } + + return nil + } + con, key := findObject(doc, path) if con == nil { @@ -613,6 +657,25 @@ func (p Patch) test(doc *container, op Operation) error { return errors.Wrapf(err, "test operation failed to decode path") } + if path == "" { + var self lazyNode + + switch sv := (*doc).(type) { + case *partialDoc: + self.doc = *sv + self.which = eDoc + case *partialArray: + self.ary = *sv + self.which = eAry + } + + if self.equal(op.value()) { + return nil + } + + return errors.Wrapf(ErrTestFailed, "testing value %s failed", path) + } + con, key := findObject(doc, path) if con == nil { diff --git a/vendor/github.com/fsnotify/fsnotify/.mailmap b/vendor/github.com/fsnotify/fsnotify/.mailmap new file mode 100644 index 0000000000..a04f2907fe --- /dev/null +++ b/vendor/github.com/fsnotify/fsnotify/.mailmap @@ -0,0 +1,2 @@ +Chris Howey +Nathan Youngman <4566+nathany@users.noreply.github.com> diff --git a/vendor/github.com/fsnotify/fsnotify/.travis.yml b/vendor/github.com/fsnotify/fsnotify/.travis.yml deleted file mode 100644 index a9c30165cd..0000000000 --- a/vendor/github.com/fsnotify/fsnotify/.travis.yml +++ /dev/null @@ -1,36 +0,0 @@ -sudo: false -language: go - -go: - - "stable" - - "1.11.x" - - "1.10.x" - - "1.9.x" - -matrix: - include: - - go: "stable" - env: GOLINT=true - allow_failures: - - go: tip - fast_finish: true - - -before_install: - - if [ ! -z "${GOLINT}" ]; then go get -u golang.org/x/lint/golint; fi - -script: - - go test --race ./... - -after_script: - - test -z "$(gofmt -s -l -w . | tee /dev/stderr)" - - if [ ! -z "${GOLINT}" ]; then echo running golint; golint --set_exit_status ./...; else echo skipping golint; fi - - go vet ./... - -os: - - linux - - osx - - windows - -notifications: - email: false diff --git a/vendor/github.com/fsnotify/fsnotify/AUTHORS b/vendor/github.com/fsnotify/fsnotify/AUTHORS index 5ab5d41c54..6cbabe5ef5 100644 --- a/vendor/github.com/fsnotify/fsnotify/AUTHORS +++ b/vendor/github.com/fsnotify/fsnotify/AUTHORS @@ -4,35 +4,44 @@ # You can update this list using the following command: # -# $ git shortlog -se | awk '{print $2 " " $3 " " $4}' +# $ (head -n10 AUTHORS && git shortlog -se | sed -E 's/^\s+[0-9]+\t//') | tee AUTHORS # Please keep the list sorted. Aaron L Adrien Bustany +Alexey Kazakov Amit Krishnan Anmol Sethi Bjørn Erik Pedersen +Brian Goff Bruno Bigras Caleb Spare Case Nelson -Chris Howey +Chris Howey Christoffer Buchholz Daniel Wagner-Hall Dave Cheney +Eric Lin Evan Phoenix Francisco Souza +Gautam Dey Hari haran -John C Barstow +Ichinose Shogo +Johannes Ebke +John C Barstow Kelvin Fo Ken-ichirou MATSUZAWA Matt Layher +Matthias Stone Nathan Youngman Nickolai Zeldovich +Oliver Bristow Patrick Paul Hammond Pawel Knap Pieter Droogendijk +Pratik Shinde Pursuit92 Riku Voipio Rob Figueiredo @@ -41,6 +50,7 @@ Slawek Ligus Soge Zhang Tiffany Jernigan Tilak Sharma +Tobias Klauser Tom Payne Travis Cline Tudor Golubenco diff --git a/vendor/github.com/fsnotify/fsnotify/CHANGELOG.md b/vendor/github.com/fsnotify/fsnotify/CHANGELOG.md index be4d7ea2c1..a438fe4b4a 100644 --- a/vendor/github.com/fsnotify/fsnotify/CHANGELOG.md +++ b/vendor/github.com/fsnotify/fsnotify/CHANGELOG.md @@ -1,6 +1,28 @@ # Changelog -## v1.4.7 / 2018-01-09 +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +## [1.5.1] - 2021-08-24 + +* Revert Add AddRaw to not follow symlinks + +## [1.5.0] - 2021-08-20 + +* Go: Increase minimum required version to Go 1.12 [#381](https://github.com/fsnotify/fsnotify/pull/381) +* Feature: Add AddRaw method which does not follow symlinks when adding a watch [#289](https://github.com/fsnotify/fsnotify/pull/298) +* Windows: Follow symlinks by default like on all other systems [#289](https://github.com/fsnotify/fsnotify/pull/289) +* CI: Use GitHub Actions for CI and cover go 1.12-1.17 + [#378](https://github.com/fsnotify/fsnotify/pull/378) + [#381](https://github.com/fsnotify/fsnotify/pull/381) + [#385](https://github.com/fsnotify/fsnotify/pull/385) +* Go 1.14+: Fix unsafe pointer conversion [#325](https://github.com/fsnotify/fsnotify/pull/325) + +## [1.4.7] - 2018-01-09 * BSD/macOS: Fix possible deadlock on closing the watcher on kqueue (thanks @nhooyr and @glycerine) * Tests: Fix missing verb on format string (thanks @rchiossi) @@ -10,62 +32,62 @@ * Linux: Properly handle inotify's IN_Q_OVERFLOW event (thanks @zeldovich) * Docs: replace references to OS X with macOS -## v1.4.2 / 2016-10-10 +## [1.4.2] - 2016-10-10 * Linux: use InotifyInit1 with IN_CLOEXEC to stop leaking a file descriptor to a child process when using fork/exec [#178](https://github.com/fsnotify/fsnotify/pull/178) (thanks @pattyshack) -## v1.4.1 / 2016-10-04 +## [1.4.1] - 2016-10-04 * Fix flaky inotify stress test on Linux [#177](https://github.com/fsnotify/fsnotify/pull/177) (thanks @pattyshack) -## v1.4.0 / 2016-10-01 +## [1.4.0] - 2016-10-01 * add a String() method to Event.Op [#165](https://github.com/fsnotify/fsnotify/pull/165) (thanks @oozie) -## v1.3.1 / 2016-06-28 +## [1.3.1] - 2016-06-28 * Windows: fix for double backslash when watching the root of a drive [#151](https://github.com/fsnotify/fsnotify/issues/151) (thanks @brunoqc) -## v1.3.0 / 2016-04-19 +## [1.3.0] - 2016-04-19 * Support linux/arm64 by [patching](https://go-review.googlesource.com/#/c/21971/) x/sys/unix and switching to to it from syscall (thanks @suihkulokki) [#135](https://github.com/fsnotify/fsnotify/pull/135) -## v1.2.10 / 2016-03-02 +## [1.2.10] - 2016-03-02 * Fix golint errors in windows.go [#121](https://github.com/fsnotify/fsnotify/pull/121) (thanks @tiffanyfj) -## v1.2.9 / 2016-01-13 +## [1.2.9] - 2016-01-13 kqueue: Fix logic for CREATE after REMOVE [#111](https://github.com/fsnotify/fsnotify/pull/111) (thanks @bep) -## v1.2.8 / 2015-12-17 +## [1.2.8] - 2015-12-17 * kqueue: fix race condition in Close [#105](https://github.com/fsnotify/fsnotify/pull/105) (thanks @djui for reporting the issue and @ppknap for writing a failing test) * inotify: fix race in test * enable race detection for continuous integration (Linux, Mac, Windows) -## v1.2.5 / 2015-10-17 +## [1.2.5] - 2015-10-17 * inotify: use epoll_create1 for arm64 support (requires Linux 2.6.27 or later) [#100](https://github.com/fsnotify/fsnotify/pull/100) (thanks @suihkulokki) * inotify: fix path leaks [#73](https://github.com/fsnotify/fsnotify/pull/73) (thanks @chamaken) * kqueue: watch for rename events on subdirectories [#83](https://github.com/fsnotify/fsnotify/pull/83) (thanks @guotie) * kqueue: avoid infinite loops from symlinks cycles [#101](https://github.com/fsnotify/fsnotify/pull/101) (thanks @illicitonion) -## v1.2.1 / 2015-10-14 +## [1.2.1] - 2015-10-14 * kqueue: don't watch named pipes [#98](https://github.com/fsnotify/fsnotify/pull/98) (thanks @evanphx) -## v1.2.0 / 2015-02-08 +## [1.2.0] - 2015-02-08 * inotify: use epoll to wake up readEvents [#66](https://github.com/fsnotify/fsnotify/pull/66) (thanks @PieterD) * inotify: closing watcher should now always shut down goroutine [#63](https://github.com/fsnotify/fsnotify/pull/63) (thanks @PieterD) * kqueue: close kqueue after removing watches, fixes [#59](https://github.com/fsnotify/fsnotify/issues/59) -## v1.1.1 / 2015-02-05 +## [1.1.1] - 2015-02-05 * inotify: Retry read on EINTR [#61](https://github.com/fsnotify/fsnotify/issues/61) (thanks @PieterD) -## v1.1.0 / 2014-12-12 +## [1.1.0] - 2014-12-12 * kqueue: rework internals [#43](https://github.com/fsnotify/fsnotify/pull/43) * add low-level functions @@ -77,22 +99,22 @@ kqueue: Fix logic for CREATE after REMOVE [#111](https://github.com/fsnotify/fsn * kqueue: fix regression in rework causing subdirectories to be watched [#48](https://github.com/fsnotify/fsnotify/issues/48) * kqueue: cleanup internal watch before sending remove event [#51](https://github.com/fsnotify/fsnotify/issues/51) -## v1.0.4 / 2014-09-07 +## [1.0.4] - 2014-09-07 * kqueue: add dragonfly to the build tags. * Rename source code files, rearrange code so exported APIs are at the top. * Add done channel to example code. [#37](https://github.com/fsnotify/fsnotify/pull/37) (thanks @chenyukang) -## v1.0.3 / 2014-08-19 +## [1.0.3] - 2014-08-19 * [Fix] Windows MOVED_TO now translates to Create like on BSD and Linux. [#36](https://github.com/fsnotify/fsnotify/issues/36) -## v1.0.2 / 2014-08-17 +## [1.0.2] - 2014-08-17 * [Fix] Missing create events on macOS. [#14](https://github.com/fsnotify/fsnotify/issues/14) (thanks @zhsso) * [Fix] Make ./path and path equivalent. (thanks @zhsso) -## v1.0.0 / 2014-08-15 +## [1.0.0] - 2014-08-15 * [API] Remove AddWatch on Windows, use Add. * Improve documentation for exported identifiers. [#30](https://github.com/fsnotify/fsnotify/issues/30) @@ -146,51 +168,51 @@ kqueue: Fix logic for CREATE after REMOVE [#111](https://github.com/fsnotify/fsn * no tests for the current implementation * not fully implemented on Windows [#93](https://github.com/howeyc/fsnotify/issues/93#issuecomment-39285195) -## v0.9.3 / 2014-12-31 +## [0.9.3] - 2014-12-31 * kqueue: cleanup internal watch before sending remove event [#51](https://github.com/fsnotify/fsnotify/issues/51) -## v0.9.2 / 2014-08-17 +## [0.9.2] - 2014-08-17 * [Backport] Fix missing create events on macOS. [#14](https://github.com/fsnotify/fsnotify/issues/14) (thanks @zhsso) -## v0.9.1 / 2014-06-12 +## [0.9.1] - 2014-06-12 * Fix data race on kevent buffer (thanks @tilaks) [#98](https://github.com/howeyc/fsnotify/pull/98) -## v0.9.0 / 2014-01-17 +## [0.9.0] - 2014-01-17 * IsAttrib() for events that only concern a file's metadata [#79][] (thanks @abustany) * [Fix] kqueue: fix deadlock [#77][] (thanks @cespare) * [NOTICE] Development has moved to `code.google.com/p/go.exp/fsnotify` in preparation for inclusion in the Go standard library. -## v0.8.12 / 2013-11-13 +## [0.8.12] - 2013-11-13 * [API] Remove FD_SET and friends from Linux adapter -## v0.8.11 / 2013-11-02 +## [0.8.11] - 2013-11-02 * [Doc] Add Changelog [#72][] (thanks @nathany) * [Doc] Spotlight and double modify events on macOS [#62][] (reported by @paulhammond) -## v0.8.10 / 2013-10-19 +## [0.8.10] - 2013-10-19 * [Fix] kqueue: remove file watches when parent directory is removed [#71][] (reported by @mdwhatcott) * [Fix] kqueue: race between Close and readEvents [#70][] (reported by @bernerdschaefer) * [Doc] specify OS-specific limits in README (thanks @debrando) -## v0.8.9 / 2013-09-08 +## [0.8.9] - 2013-09-08 * [Doc] Contributing (thanks @nathany) * [Doc] update package path in example code [#63][] (thanks @paulhammond) * [Doc] GoCI badge in README (Linux only) [#60][] * [Doc] Cross-platform testing with Vagrant [#59][] (thanks @nathany) -## v0.8.8 / 2013-06-17 +## [0.8.8] - 2013-06-17 * [Fix] Windows: handle `ERROR_MORE_DATA` on Windows [#49][] (thanks @jbowtie) -## v0.8.7 / 2013-06-03 +## [0.8.7] - 2013-06-03 * [API] Make syscall flags internal * [Fix] inotify: ignore event changes @@ -198,74 +220,74 @@ kqueue: Fix logic for CREATE after REMOVE [#111](https://github.com/fsnotify/fsn * [Fix] tests on Windows * lower case error messages -## v0.8.6 / 2013-05-23 +## [0.8.6] - 2013-05-23 * kqueue: Use EVT_ONLY flag on Darwin * [Doc] Update README with full example -## v0.8.5 / 2013-05-09 +## [0.8.5] - 2013-05-09 * [Fix] inotify: allow monitoring of "broken" symlinks (thanks @tsg) -## v0.8.4 / 2013-04-07 +## [0.8.4] - 2013-04-07 * [Fix] kqueue: watch all file events [#40][] (thanks @ChrisBuchholz) -## v0.8.3 / 2013-03-13 +## [0.8.3] - 2013-03-13 * [Fix] inoitfy/kqueue memory leak [#36][] (reported by @nbkolchin) * [Fix] kqueue: use fsnFlags for watching a directory [#33][] (reported by @nbkolchin) -## v0.8.2 / 2013-02-07 +## [0.8.2] - 2013-02-07 * [Doc] add Authors * [Fix] fix data races for map access [#29][] (thanks @fsouza) -## v0.8.1 / 2013-01-09 +## [0.8.1] - 2013-01-09 * [Fix] Windows path separators * [Doc] BSD License -## v0.8.0 / 2012-11-09 +## [0.8.0] - 2012-11-09 * kqueue: directory watching improvements (thanks @vmirage) * inotify: add `IN_MOVED_TO` [#25][] (requested by @cpisto) * [Fix] kqueue: deleting watched directory [#24][] (reported by @jakerr) -## v0.7.4 / 2012-10-09 +## [0.7.4] - 2012-10-09 * [Fix] inotify: fixes from https://codereview.appspot.com/5418045/ (ugorji) * [Fix] kqueue: preserve watch flags when watching for delete [#21][] (reported by @robfig) * [Fix] kqueue: watch the directory even if it isn't a new watch (thanks @robfig) * [Fix] kqueue: modify after recreation of file -## v0.7.3 / 2012-09-27 +## [0.7.3] - 2012-09-27 * [Fix] kqueue: watch with an existing folder inside the watched folder (thanks @vmirage) * [Fix] kqueue: no longer get duplicate CREATE events -## v0.7.2 / 2012-09-01 +## [0.7.2] - 2012-09-01 * kqueue: events for created directories -## v0.7.1 / 2012-07-14 +## [0.7.1] - 2012-07-14 * [Fix] for renaming files -## v0.7.0 / 2012-07-02 +## [0.7.0] - 2012-07-02 * [Feature] FSNotify flags * [Fix] inotify: Added file name back to event path -## v0.6.0 / 2012-06-06 +## [0.6.0] - 2012-06-06 * kqueue: watch files after directory created (thanks @tmc) -## v0.5.1 / 2012-05-22 +## [0.5.1] - 2012-05-22 * [Fix] inotify: remove all watches before Close() -## v0.5.0 / 2012-05-03 +## [0.5.0] - 2012-05-03 * [API] kqueue: return errors during watch instead of sending over channel * kqueue: match symlink behavior on Linux @@ -273,22 +295,22 @@ kqueue: Fix logic for CREATE after REMOVE [#111](https://github.com/fsnotify/fsn * [Fix] kqueue: handle EINTR (reported by @robfig) * [Doc] Godoc example [#1][] (thanks @davecheney) -## v0.4.0 / 2012-03-30 +## [0.4.0] - 2012-03-30 * Go 1 released: build with go tool * [Feature] Windows support using winfsnotify * Windows does not have attribute change notifications * Roll attribute notifications into IsModify -## v0.3.0 / 2012-02-19 +## [0.3.0] - 2012-02-19 * kqueue: add files when watch directory -## v0.2.0 / 2011-12-30 +## [0.2.0] - 2011-12-30 * update to latest Go weekly code -## v0.1.0 / 2011-10-19 +## [0.1.0] - 2011-10-19 * kqueue: add watch on file creation to match inotify * kqueue: create file event diff --git a/vendor/github.com/fsnotify/fsnotify/README.md b/vendor/github.com/fsnotify/fsnotify/README.md index b2629e5229..df57b1b282 100644 --- a/vendor/github.com/fsnotify/fsnotify/README.md +++ b/vendor/github.com/fsnotify/fsnotify/README.md @@ -12,9 +12,9 @@ Cross platform: Windows, Linux, BSD and macOS. | Adapter | OS | Status | | --------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | -| inotify | Linux 2.6.27 or later, Android\* | Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify) | -| kqueue | BSD, macOS, iOS\* | Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify) | -| ReadDirectoryChangesW | Windows | Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify) | +| inotify | Linux 2.6.27 or later, Android\* | Supported | +| kqueue | BSD, macOS, iOS\* | Supported | +| ReadDirectoryChangesW | Windows | Supported | | FSEvents | macOS | [Planned](https://github.com/fsnotify/fsnotify/issues/11) | | FEN | Solaris 11 | [In Progress](https://github.com/fsnotify/fsnotify/issues/12) | | fanotify | Linux 2.6.37+ | [Planned](https://github.com/fsnotify/fsnotify/issues/114) | diff --git a/vendor/github.com/fsnotify/fsnotify/fen.go b/vendor/github.com/fsnotify/fsnotify/fen.go index ced39cb881..b3ac3d8f55 100644 --- a/vendor/github.com/fsnotify/fsnotify/fen.go +++ b/vendor/github.com/fsnotify/fsnotify/fen.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build solaris // +build solaris package fsnotify diff --git a/vendor/github.com/fsnotify/fsnotify/fsnotify.go b/vendor/github.com/fsnotify/fsnotify/fsnotify.go index 89cab046d1..0f4ee52e8a 100644 --- a/vendor/github.com/fsnotify/fsnotify/fsnotify.go +++ b/vendor/github.com/fsnotify/fsnotify/fsnotify.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 // +build !plan9 // Package fsnotify provides a platform-independent interface for file system notifications. diff --git a/vendor/github.com/fsnotify/fsnotify/go.mod b/vendor/github.com/fsnotify/fsnotify/go.mod index ff11e13f22..54089e48b7 100644 --- a/vendor/github.com/fsnotify/fsnotify/go.mod +++ b/vendor/github.com/fsnotify/fsnotify/go.mod @@ -2,4 +2,6 @@ module github.com/fsnotify/fsnotify go 1.13 -require golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9 +require golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c + +retract v1.5.0 diff --git a/vendor/github.com/fsnotify/fsnotify/go.sum b/vendor/github.com/fsnotify/fsnotify/go.sum index f60af9855d..0f478630ca 100644 --- a/vendor/github.com/fsnotify/fsnotify/go.sum +++ b/vendor/github.com/fsnotify/fsnotify/go.sum @@ -1,2 +1,2 @@ -golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9 h1:L2auWcuQIvxz9xSEqzESnV/QN/gNRXNApHi3fYwl2w0= -golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= diff --git a/vendor/github.com/fsnotify/fsnotify/inotify.go b/vendor/github.com/fsnotify/fsnotify/inotify.go index d9fd1b88a0..eb87699b5b 100644 --- a/vendor/github.com/fsnotify/fsnotify/inotify.go +++ b/vendor/github.com/fsnotify/fsnotify/inotify.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build linux // +build linux package fsnotify @@ -272,7 +273,7 @@ func (w *Watcher) readEvents() { if nameLen > 0 { // Point "bytes" at the first byte of the filename - bytes := (*[unix.PathMax]byte)(unsafe.Pointer(&buf[offset+unix.SizeofInotifyEvent])) + bytes := (*[unix.PathMax]byte)(unsafe.Pointer(&buf[offset+unix.SizeofInotifyEvent]))[:nameLen:nameLen] // The filename is padded with NULL bytes. TrimRight() gets rid of those. name += "/" + strings.TrimRight(string(bytes[0:nameLen]), "\000") } diff --git a/vendor/github.com/fsnotify/fsnotify/inotify_poller.go b/vendor/github.com/fsnotify/fsnotify/inotify_poller.go index b33f2b4d4b..e9ff9439f7 100644 --- a/vendor/github.com/fsnotify/fsnotify/inotify_poller.go +++ b/vendor/github.com/fsnotify/fsnotify/inotify_poller.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build linux // +build linux package fsnotify diff --git a/vendor/github.com/fsnotify/fsnotify/kqueue.go b/vendor/github.com/fsnotify/fsnotify/kqueue.go index 86e76a3d67..368f5b790d 100644 --- a/vendor/github.com/fsnotify/fsnotify/kqueue.go +++ b/vendor/github.com/fsnotify/fsnotify/kqueue.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build freebsd || openbsd || netbsd || dragonfly || darwin // +build freebsd openbsd netbsd dragonfly darwin package fsnotify diff --git a/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go b/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go index 2306c4620b..36cc3845b6 100644 --- a/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go +++ b/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build freebsd || openbsd || netbsd || dragonfly // +build freebsd openbsd netbsd dragonfly package fsnotify diff --git a/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go b/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go index 870c4d6d18..98cd8476ff 100644 --- a/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go +++ b/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build darwin // +build darwin package fsnotify diff --git a/vendor/github.com/fsnotify/fsnotify/windows.go b/vendor/github.com/fsnotify/fsnotify/windows.go index 09436f31d8..c02b75f7c3 100644 --- a/vendor/github.com/fsnotify/fsnotify/windows.go +++ b/vendor/github.com/fsnotify/fsnotify/windows.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows // +build windows package fsnotify diff --git a/vendor/github.com/go-logr/logr/.golangci.yaml b/vendor/github.com/go-logr/logr/.golangci.yaml new file mode 100644 index 0000000000..94ff801df1 --- /dev/null +++ b/vendor/github.com/go-logr/logr/.golangci.yaml @@ -0,0 +1,29 @@ +run: + timeout: 1m + tests: true + +linters: + disable-all: true + enable: + - asciicheck + - deadcode + - errcheck + - forcetypeassert + - gocritic + - gofmt + - goimports + - gosimple + - govet + - ineffassign + - misspell + - revive + - staticcheck + - structcheck + - typecheck + - unused + - varcheck + +issues: + exclude-use-default: false + max-issues-per-linter: 0 + max-same-issues: 10 diff --git a/vendor/github.com/go-logr/logr/CHANGELOG.md b/vendor/github.com/go-logr/logr/CHANGELOG.md new file mode 100644 index 0000000000..c356960046 --- /dev/null +++ b/vendor/github.com/go-logr/logr/CHANGELOG.md @@ -0,0 +1,6 @@ +# CHANGELOG + +## v1.0.0-rc1 + +This is the first logged release. Major changes (including breaking changes) +have occurred since earlier tags. diff --git a/vendor/github.com/go-logr/logr/CONTRIBUTING.md b/vendor/github.com/go-logr/logr/CONTRIBUTING.md new file mode 100644 index 0000000000..5d37e294c5 --- /dev/null +++ b/vendor/github.com/go-logr/logr/CONTRIBUTING.md @@ -0,0 +1,17 @@ +# Contributing + +Logr is open to pull-requests, provided they fit within the intended scope of +the project. Specifically, this library aims to be VERY small and minimalist, +with no external dependencies. + +## Compatibility + +This project intends to follow [semantic versioning](http://semver.org) and +is very strict about compatibility. Any proposed changes MUST follow those +rules. + +## Performance + +As a logging library, logr must be as light-weight as possible. Any proposed +code change must include results of running the [benchmark](./benchmark) +before and after the change. diff --git a/vendor/github.com/go-logr/logr/README.md b/vendor/github.com/go-logr/logr/README.md index e9b5520a1c..ad825f5f0a 100644 --- a/vendor/github.com/go-logr/logr/README.md +++ b/vendor/github.com/go-logr/logr/README.md @@ -1,112 +1,182 @@ -# A more minimal logging API for Go +# A minimal logging API for Go -Before you consider this package, please read [this blog post by the -inimitable Dave Cheney][warning-makes-no-sense]. I really appreciate what -he has to say, and it largely aligns with my own experiences. Too many -choices of levels means inconsistent logs. +[![Go Reference](https://pkg.go.dev/badge/github.com/go-logr/logr.svg)](https://pkg.go.dev/github.com/go-logr/logr) + +logr offers an(other) opinion on how Go programs and libraries can do logging +without becoming coupled to a particular logging implementation. This is not +an implementation of logging - it is an API. In fact it is two APIs with two +different sets of users. + +The `Logger` type is intended for application and library authors. It provides +a relatively small API which can be used everywhere you want to emit logs. It +defers the actual act of writing logs (to files, to stdout, or whatever) to the +`LogSink` interface. + +The `LogSink` interface is intended for logging library implementers. It is a +pure interface which can be implemented by logging frameworks to provide the actual logging +functionality. + +This decoupling allows application and library developers to write code in +terms of `logr.Logger` (which has very low dependency fan-out) while the +implementation of logging is managed "up stack" (e.g. in or near `main()`.) +Application developers can then switch out implementations as necessary. + +Many people assert that libraries should not be logging, and as such efforts +like this are pointless. Those people are welcome to convince the authors of +the tens-of-thousands of libraries that *DO* write logs that they are all +wrong. In the meantime, logr takes a more practical approach. + +## Typical usage + +Somewhere, early in an application's life, it will make a decision about which +logging library (implementation) it actually wants to use. Something like: + +``` + func main() { + // ... other setup code ... + + // Create the "root" logger. We have chosen the "logimpl" implementation, + // which takes some initial parameters and returns a logr.Logger. + logger := logimpl.New(param1, param2) + + // ... other setup code ... +``` + +Most apps will call into other libraries, create structures to govern the flow, +etc. The `logr.Logger` object can be passed to these other libraries, stored +in structs, or even used as a package-global variable, if needed. For example: + +``` + app := createTheAppObject(logger) + app.Run() +``` + +Outside of this early setup, no other packages need to know about the choice of +implementation. They write logs in terms of the `logr.Logger` that they +received: -This package offers a purely abstract interface, based on these ideas but with -a few twists. Code can depend on just this interface and have the actual -logging implementation be injected from callers. Ideally only `main()` knows -what logging implementation is being used. +``` + type appObject struct { + // ... other fields ... + logger logr.Logger + // ... other fields ... + } -# Differences from Dave's ideas + func (app *appObject) Run() { + app.logger.Info("starting up", "timestamp", time.Now()) + + // ... app code ... +``` + +## Background + +If the Go standard library had defined an interface for logging, this project +probably would not be needed. Alas, here we are. + +### Inspiration + +Before you consider this package, please read [this blog post by the +inimitable Dave Cheney][warning-makes-no-sense]. We really appreciate what +he has to say, and it largely aligns with our own experiences. + +### Differences from Dave's ideas The main differences are: -1) Dave basically proposes doing away with the notion of a logging API in favor -of `fmt.Printf()`. I disagree, especially when you consider things like output -locations, timestamps, file and line decorations, and structured logging. I -restrict the API to just 2 types of logs: info and error. +1. Dave basically proposes doing away with the notion of a logging API in favor +of `fmt.Printf()`. We disagree, especially when you consider things like output +locations, timestamps, file and line decorations, and structured logging. This +package restricts the logging API to just 2 types of logs: info and error. Info logs are things you want to tell the user which are not errors. Error logs are, well, errors. If your code receives an `error` from a subordinate function call and is logging that `error` *and not returning it*, use error logs. -2) Verbosity-levels on info logs. This gives developers a chance to indicate +2. Verbosity-levels on info logs. This gives developers a chance to indicate arbitrary grades of importance for info logs, without assigning names with -semantic meaning such as "warning", "trace", and "debug". Superficially this +semantic meaning such as "warning", "trace", and "debug." Superficially this may feel very similar, but the primary difference is the lack of semantics. Because verbosity is a numerical value, it's safe to assume that an app running with higher verbosity means more (and less important) logs will be generated. -This is a BETA grade API. +## Implementations (non-exhaustive) There are implementations for the following logging libraries: +- **a function** (can bridge to non-structured libraries): [funcr](https://github.com/go-logr/logr/tree/master/funcr) - **github.com/google/glog**: [glogr](https://github.com/go-logr/glogr) -- **k8s.io/klog**: [klogr](https://git.k8s.io/klog/klogr) +- **k8s.io/klog** (for Kubernetes): [klogr](https://git.k8s.io/klog/klogr) - **go.uber.org/zap**: [zapr](https://github.com/go-logr/zapr) -- **log** (the Go standard library logger): - [stdr](https://github.com/go-logr/stdr) +- **log** (the Go standard library logger): [stdr](https://github.com/go-logr/stdr) - **github.com/sirupsen/logrus**: [logrusr](https://github.com/bombsimon/logrusr) - **github.com/wojas/genericr**: [genericr](https://github.com/wojas/genericr) (makes it easy to implement your own backend) - **logfmt** (Heroku style [logging](https://www.brandur.org/logfmt)): [logfmtr](https://github.com/iand/logfmtr) +- **github.com/rs/zerolog**: [zerologr](https://github.com/go-logr/zerologr) -# FAQ +## FAQ -## Conceptual +### Conceptual -## Why structured logging? +#### Why structured logging? -- **Structured logs are more easily queriable**: Since you've got +- **Structured logs are more easily queryable**: Since you've got key-value pairs, it's much easier to query your structured logs for particular values by filtering on the contents of a particular key -- think searching request logs for error codes, Kubernetes reconcilers for - the name and namespace of the reconciled object, etc + the name and namespace of the reconciled object, etc. -- **Structured logging makes it easier to have cross-referencable logs**: +- **Structured logging makes it easier to have cross-referenceable logs**: Similarly to searchability, if you maintain conventions around your keys, it becomes easy to gather all log lines related to a particular concept. - + - **Structured logs allow better dimensions of filtering**: if you have structure to your logs, you've got more precise control over how much information is logged -- you might choose in a particular configuration to log certain keys but not others, only log lines where a certain key - matches a certain value, etc, instead of just having v-levels and names + matches a certain value, etc., instead of just having v-levels and names to key off of. - **Structured logs better represent structured data**: sometimes, the data that you want to log is inherently structured (think tuple-link - objects). Structured logs allow you to preserve that structure when + objects.) Structured logs allow you to preserve that structure when outputting. -## Why V-levels? +#### Why V-levels? **V-levels give operators an easy way to control the chattiness of log operations**. V-levels provide a way for a given package to distinguish the relative importance or verbosity of a given log message. Then, if a particular logger or package is logging too many messages, the user -of the package can simply change the v-levels for that library. +of the package can simply change the v-levels for that library. -## Why not more named levels, like Warning? +#### Why not named levels, like Info/Warning/Error? Read [Dave Cheney's post][warning-makes-no-sense]. Then read [Differences from Dave's ideas](#differences-from-daves-ideas). -## Why not allow format strings, too? +#### Why not allow format strings, too? **Format strings negate many of the benefits of structured logs**: - They're not easily searchable without resorting to fuzzy searching, - regular expressions, etc + regular expressions, etc. - They don't store structured data well, since contents are flattened into - a string + a string. -- They're not cross-referencable +- They're not cross-referenceable. -- They don't compress easily, since the message is not constant +- They don't compress easily, since the message is not constant. -(unless you turn positional parameters into key-value pairs with numerical +(Unless you turn positional parameters into key-value pairs with numerical keys, at which point you've gotten key-value logging with meaningless -keys) +keys.) -## Practical +### Practical -## Why key-value pairs, and not a map? +#### Why key-value pairs, and not a map? Key-value pairs are *much* easier to optimize, especially around allocations. Zap (a structured logger that inspired logr's interface) has @@ -117,26 +187,26 @@ While the interface ends up being a little less obvious, you get potentially better performance, plus avoid making users type `map[string]string{}` every time they want to log. -## What if my V-levels differ between libraries? +#### What if my V-levels differ between libraries? That's fine. Control your V-levels on a per-logger basis, and use the -`WithName` function to pass different loggers to different libraries. +`WithName` method to pass different loggers to different libraries. Generally, you should take care to ensure that you have relatively consistent V-levels within a given logger, however, as this makes deciding on what verbosity of logs to request easier. -## But I *really* want to use a format string! +#### But I really want to use a format string! That's not actually a question. Assuming your question is "how do I convert my mental model of logging with format strings to logging with constant messages": -1. figure out what the error actually is, as you'd write in a TL;DR style, - and use that as a message +1. Figure out what the error actually is, as you'd write in a TL;DR style, + and use that as a message. 2. For every place you'd write a format specifier, look to the word before - it, and add that as a key value pair + it, and add that as a key value pair. For instance, consider the following examples (all taken from spots in the Kubernetes codebase): @@ -150,34 +220,59 @@ Kubernetes codebase): response when requesting url", "attempt", retries, "after seconds", seconds, "url", url)` -If you *really* must use a format string, place it as a key value, and -call `fmt.Sprintf` yourself -- for instance, `log.Printf("unable to +If you *really* must use a format string, use it in a key's value, and +call `fmt.Sprintf` yourself. For instance: `log.Printf("unable to reflect over type %T")` becomes `logger.Info("unable to reflect over type", "type", fmt.Sprintf("%T"))`. In general though, the cases where this is necessary should be few and far between. -## How do I choose my V-levels? +#### How do I choose my V-levels? This is basically the only hard constraint: increase V-levels to denote more verbose or more debug-y logs. Otherwise, you can start out with `0` as "you always want to see this", `1` as "common logging that you might *possibly* want to turn off", and -`10` as "I would like to performance-test your log collection stack". +`10` as "I would like to performance-test your log collection stack." Then gradually choose levels in between as you need them, working your way down from 10 (for debug and trace style logs) and up from 1 (for chattier -info-type logs). +info-type logs.) + +#### How do I choose my keys? -## How do I choose my keys +Keys are fairly flexible, and can hold more or less any string +value. For best compatibility with implementations and consistency +with existing code in other projects, there are a few conventions you +should consider. -- make your keys human-readable -- constant keys are generally a good idea -- be consistent across your codebase -- keys should naturally match parts of the message string +- Make your keys human-readable. +- Constant keys are generally a good idea. +- Be consistent across your codebase. +- Keys should naturally match parts of the message string. +- Use lower case for simple keys and + [lowerCamelCase](https://en.wiktionary.org/wiki/lowerCamelCase) for + more complex ones. Kubernetes is one example of a project that has + [adopted that + convention](https://github.com/kubernetes/community/blob/HEAD/contributors/devel/sig-instrumentation/migration-to-structured-logging.md#name-arguments). While key names are mostly unrestricted (and spaces are acceptable), it's generally a good idea to stick to printable ascii characters, or at least match the general character set of your log lines. +#### Why should keys be constant values? + +The point of structured logging is to make later log processing easier. Your +keys are, effectively, the schema of each log message. If you use different +keys across instances of the same log line, you will make your structured logs +much harder to use. `Sprintf()` is for values, not for keys! + +#### Why is this not a pure interface? + +The Logger type is implemented as a struct in order to allow the Go compiler to +optimize things like high-V `Info` logs that are not triggered. Not all of +these implementations are implemented yet, but this structure was suggested as +a way to ensure they *can* be implemented. All of the real work is behind the +`LogSink` interface. + [warning-makes-no-sense]: http://dave.cheney.net/2015/11/05/lets-talk-about-logging diff --git a/vendor/github.com/go-logr/logr/discard.go b/vendor/github.com/go-logr/logr/discard.go index 2bafb13d15..9d92a38f1d 100644 --- a/vendor/github.com/go-logr/logr/discard.go +++ b/vendor/github.com/go-logr/logr/discard.go @@ -16,36 +16,39 @@ limitations under the License. package logr -// Discard returns a valid Logger that discards all messages logged to it. -// It can be used whenever the caller is not interested in the logs. +// Discard returns a Logger that discards all messages logged to it. It can be +// used whenever the caller is not interested in the logs. Logger instances +// produced by this function always compare as equal. func Discard() Logger { - return DiscardLogger{} + return Logger{ + level: 0, + sink: discardLogSink{}, + } } -// DiscardLogger is a Logger that discards all messages. -type DiscardLogger struct{} +// discardLogSink is a LogSink that discards all messages. +type discardLogSink struct{} -func (l DiscardLogger) Enabled() bool { - return false +// Verify that it actually implements the interface +var _ LogSink = discardLogSink{} + +func (l discardLogSink) Init(RuntimeInfo) { } -func (l DiscardLogger) Info(msg string, keysAndValues ...interface{}) { +func (l discardLogSink) Enabled(int) bool { + return false } -func (l DiscardLogger) Error(err error, msg string, keysAndValues ...interface{}) { +func (l discardLogSink) Info(int, string, ...interface{}) { } -func (l DiscardLogger) V(level int) Logger { - return l +func (l discardLogSink) Error(error, string, ...interface{}) { } -func (l DiscardLogger) WithValues(keysAndValues ...interface{}) Logger { +func (l discardLogSink) WithValues(...interface{}) LogSink { return l } -func (l DiscardLogger) WithName(name string) Logger { +func (l discardLogSink) WithName(string) LogSink { return l } - -// Verify that it actually implements the interface -var _ Logger = DiscardLogger{} diff --git a/vendor/github.com/go-logr/logr/go.mod b/vendor/github.com/go-logr/logr/go.mod index 591884e91f..7baec9b570 100644 --- a/vendor/github.com/go-logr/logr/go.mod +++ b/vendor/github.com/go-logr/logr/go.mod @@ -1,3 +1,3 @@ module github.com/go-logr/logr -go 1.14 +go 1.16 diff --git a/vendor/github.com/go-logr/logr/logr.go b/vendor/github.com/go-logr/logr/logr.go index 842428bd3a..44cd398c9f 100644 --- a/vendor/github.com/go-logr/logr/logr.go +++ b/vendor/github.com/go-logr/logr/logr.go @@ -16,83 +16,101 @@ limitations under the License. // This design derives from Dave Cheney's blog: // http://dave.cheney.net/2015/11/05/lets-talk-about-logging -// -// This is a BETA grade API. Until there is a significant 2nd implementation, -// I don't really know how it will change. -// Package logr defines abstract interfaces for logging. Packages can depend on -// these interfaces and callers can implement logging in whatever way is -// appropriate. +// Package logr defines a general-purpose logging API and abstract interfaces +// to back that API. Packages in the Go ecosystem can depend on this package, +// while callers can implement logging with whatever backend is appropriate. // // Usage // -// Logging is done using a Logger. Loggers can have name prefixes and named -// values attached, so that all log messages logged with that Logger have some -// base context associated. +// Logging is done using a Logger instance. Logger is a concrete type with +// methods, which defers the actual logging to a LogSink interface. The main +// methods of Logger are Info() and Error(). Arguments to Info() and Error() +// are key/value pairs rather than printf-style formatted strings, emphasizing +// "structured logging". // -// The term "key" is used to refer to the name associated with a particular -// value, to disambiguate it from the general Logger name. +// With Go's standard log package, we might write: +// log.Printf("setting target value %s", targetValue) // -// For instance, suppose we're trying to reconcile the state of an object, and -// we want to log that we've made some decision. +// With logr's structured logging, we'd write: +// logger.Info("setting target", "value", targetValue) // -// With the traditional log package, we might write: -// log.Printf("decided to set field foo to value %q for object %s/%s", -// targetValue, object.Namespace, object.Name) +// Errors are much the same. Instead of: +// log.Printf("failed to open the pod bay door for user %s: %v", user, err) // -// With logr's structured logging, we'd write: -// // elsewhere in the file, set up the logger to log with the prefix of -// // "reconcilers", and the named value target-type=Foo, for extra context. -// log := mainLogger.WithName("reconcilers").WithValues("target-type", "Foo") +// We'd write: +// logger.Error(err, "failed to open the pod bay door", "user", user) // -// // later on... -// log.Info("setting foo on object", "value", targetValue, "object", object) +// Info() and Error() are very similar, but they are separate methods so that +// LogSink implementations can choose to do things like attach additional +// information (such as stack traces) on calls to Error(). +// +// Verbosity +// +// Often we want to log information only when the application in "verbose +// mode". To write log lines that are more verbose, Logger has a V() method. +// The higher the V-level of a log line, the less critical it is considered. +// Log-lines with V-levels that are not enabled (as per the LogSink) will not +// be written. Level V(0) is the default, and logger.V(0).Info() has the same +// meaning as logger.Info(). Negative V-levels have the same meaning as V(0). +// +// Where we might have written: +// if flVerbose >= 2 { +// log.Printf("an unusual thing happened") +// } +// +// We can write: +// logger.V(2).Info("an unusual thing happened") +// +// Logger Names +// +// Logger instances can have name strings so that all messages logged through +// that instance have additional context. For example, you might want to add +// a subsystem name: // -// Depending on our logging implementation, we could then make logging decisions -// based on field values (like only logging such events for objects in a certain -// namespace), or copy the structured information into a structured log store. +// logger.WithName("compactor").Info("started", "time", time.Now()) // -// For logging errors, Logger has a method called Error. Suppose we wanted to -// log an error while reconciling. With the traditional log package, we might -// write: -// log.Errorf("unable to reconcile object %s/%s: %v", object.Namespace, object.Name, err) +// The WithName() method returns a new Logger, which can be passed to +// constructors or other functions for further use. Repeated use of WithName() +// will accumulate name "segments". These name segments will be joined in some +// way by the LogSink implementation. It is strongly recommended that name +// segments contain simple identifiers (letters, digits, and hyphen), and do +// not contain characters that could muddle the log output or confuse the +// joining operation (e.g. whitespace, commas, periods, slashes, brackets, +// quotes, etc). // -// With logr, we'd instead write: -// // assuming the above setup for log -// log.Error(err, "unable to reconcile object", "object", object) +// Saved Values // -// This functions similarly to: -// log.Info("unable to reconcile object", "error", err, "object", object) +// Logger instances can store any number of key/value pairs, which will be +// logged alongside all messages logged through that instance. For example, +// you might want to create a Logger instance per managed object: // -// However, it ensures that a standard key for the error value ("error") is used -// across all error logging. Furthermore, certain implementations may choose to -// attach additional information (such as stack traces) on calls to Error, so -// it's preferred to use Error to log errors. +// With the standard log package, we might write: +// log.Printf("decided to set field foo to value %q for object %s/%s", +// targetValue, object.Namespace, object.Name) // -// Parts of a log line +// With logr we'd write: +// // Elsewhere: set up the logger to log the object name. +// obj.logger = mainLogger.WithValues( +// "name", obj.name, "namespace", obj.namespace) // -// Each log message from a Logger has four types of context: -// logger name, log verbosity, log message, and the named values. +// // later on... +// obj.logger.Info("setting foo", "value", targetValue) // -// The Logger name consists of a series of name "segments" added by successive -// calls to WithName. These name segments will be joined in some way by the -// underlying implementation. It is strongly recommended that name segments -// contain simple identifiers (letters, digits, and hyphen), and do not contain -// characters that could muddle the log output or confuse the joining operation -// (e.g. whitespace, commas, periods, slashes, brackets, quotes, etc). +// Best Practices // -// Log verbosity represents how little a log matters. Level zero, the default, -// matters most. Increasing levels matter less and less. Try to avoid lots of -// different verbosity levels, and instead provide useful keys, logger names, -// and log messages for users to filter on. It's illegal to pass a log level -// below zero. +// Logger has very few hard rules, with the goal that LogSink implementations +// might have a lot of freedom to differentiate. There are, however, some +// things to consider. // // The log message consists of a constant message attached to the log line. // This should generally be a simple description of what's occurring, and should -// never be a format string. +// never be a format string. Variable information can then be attached using +// named values. // -// Variable information can then be attached using named values (key/value -// pairs). Keys are arbitrary strings, while values may be any Go value. +// Keys are arbitrary strings, but should generally be constant values. Values +// may be any Go value, but how the value is formatted is determined by the +// LogSink implementation. // // Key Naming Conventions // @@ -102,6 +120,7 @@ limitations under the License. // * be constant (not dependent on input data) // * contain only printable characters // * not contain whitespace or punctuation +// * use lower case for simple keys and lowerCamelCase for more complex ones // // These guidelines help ensure that log data is processed properly regardless // of the log implementation. For example, log implementations will try to @@ -110,21 +129,22 @@ limitations under the License. // While users are generally free to use key names of their choice, it's // generally best to avoid using the following keys, as they're frequently used // by implementations: -// -// * `"caller"`: the calling information (file/line) of a particular log line. -// * `"error"`: the underlying error value in the `Error` method. -// * `"level"`: the log level. -// * `"logger"`: the name of the associated logger. -// * `"msg"`: the log message. -// * `"stacktrace"`: the stack trace associated with a particular log line or -// error (often from the `Error` message). -// * `"ts"`: the timestamp for a log line. +// * "caller": the calling information (file/line) of a particular log line +// * "error": the underlying error value in the `Error` method +// * "level": the log level +// * "logger": the name of the associated logger +// * "msg": the log message +// * "stacktrace": the stack trace associated with a particular log line or +// error (often from the `Error` message) +// * "ts": the timestamp for a log line // // Implementations are encouraged to make use of these keys to represent the // above concepts, when necessary (for example, in a pure-JSON output form, it // would be necessary to represent at least message and timestamp as ordinary // named values). // +// Break Glass +// // Implementations may choose to give callers access to the underlying // logging implementation. The recommended pattern for this is: // // Underlier exposes access to the underlying logging implementation. @@ -134,81 +154,220 @@ limitations under the License. // type Underlier interface { // GetUnderlying() // } +// +// Logger grants access to the sink to enable type assertions like this: +// func DoSomethingWithImpl(log logr.Logger) { +// if underlier, ok := log.GetSink()(impl.Underlier) { +// implLogger := underlier.GetUnderlying() +// ... +// } +// } +// +// Custom `With*` functions can be implemented by copying the complete +// Logger struct and replacing the sink in the copy: +// // WithFooBar changes the foobar parameter in the log sink and returns a +// // new logger with that modified sink. It does nothing for loggers where +// // the sink doesn't support that parameter. +// func WithFoobar(log logr.Logger, foobar int) logr.Logger { +// if foobarLogSink, ok := log.GetSink()(FoobarSink); ok { +// log = log.WithSink(foobarLogSink.WithFooBar(foobar)) +// } +// return log +// } +// +// Don't use New to construct a new Logger with a LogSink retrieved from an +// existing Logger. Source code attribution might not work correctly and +// unexported fields in Logger get lost. +// +// Beware that the same LogSink instance may be shared by different logger +// instances. Calling functions that modify the LogSink will affect all of +// those. package logr import ( "context" ) -// TODO: consider adding back in format strings if they're really needed -// TODO: consider other bits of zap/zapcore functionality like ObjectMarshaller (for arbitrary objects) -// TODO: consider other bits of glog functionality like Flush, OutputStats +// New returns a new Logger instance. This is primarily used by libraries +// implementing LogSink, rather than end users. +func New(sink LogSink) Logger { + logger := Logger{} + logger.setSink(sink) + sink.Init(runtimeInfo) + return logger +} -// Logger represents the ability to log messages, both errors and not. -type Logger interface { - // Enabled tests whether this Logger is enabled. For example, commandline - // flags might be used to set the logging verbosity and disable some info - // logs. - Enabled() bool +// setSink stores the sink and updates any related fields. It mutates the +// logger and thus is only safe to use for loggers that are not currently being +// used concurrently. +func (l *Logger) setSink(sink LogSink) { + l.sink = sink +} - // Info logs a non-error message with the given key/value pairs as context. - // - // The msg argument should be used to add some constant description to - // the log line. The key/value pairs can then be used to add additional - // variable information. The key/value pairs should alternate string - // keys and arbitrary values. - Info(msg string, keysAndValues ...interface{}) - - // Error logs an error, with the given message and key/value pairs as context. - // It functions similarly to calling Info with the "error" named value, but may - // have unique behavior, and should be preferred for logging errors (see the - // package documentations for more information). - // - // The msg field should be used to add context to any underlying error, - // while the err field should be used to attach the actual error that - // triggered this log line, if present. - Error(err error, msg string, keysAndValues ...interface{}) +// GetSink returns the stored sink. +func (l Logger) GetSink() LogSink { + return l.sink +} + +// WithSink returns a copy of the logger with the new sink. +func (l Logger) WithSink(sink LogSink) Logger { + l.setSink(sink) + return l +} + +// Logger is an interface to an abstract logging implementation. This is a +// concrete type for performance reasons, but all the real work is passed on to +// a LogSink. Implementations of LogSink should provide their own constructors +// that return Logger, not LogSink. +// +// The underlying sink can be accessed through GetSink and be modified through +// WithSink. This enables the implementation of custom extensions (see "Break +// Glass" in the package documentation). Normally the sink should be used only +// indirectly. +type Logger struct { + sink LogSink + level int +} + +// Enabled tests whether this Logger is enabled. For example, commandline +// flags might be used to set the logging verbosity and disable some info logs. +func (l Logger) Enabled() bool { + return l.sink.Enabled(l.level) +} + +// Info logs a non-error message with the given key/value pairs as context. +// +// The msg argument should be used to add some constant description to the log +// line. The key/value pairs can then be used to add additional variable +// information. The key/value pairs must alternate string keys and arbitrary +// values. +func (l Logger) Info(msg string, keysAndValues ...interface{}) { + if l.Enabled() { + if withHelper, ok := l.sink.(CallStackHelperLogSink); ok { + withHelper.GetCallStackHelper()() + } + l.sink.Info(l.level, msg, keysAndValues...) + } +} + +// Error logs an error, with the given message and key/value pairs as context. +// It functions similarly to Info, but may have unique behavior, and should be +// preferred for logging errors (see the package documentations for more +// information). +// +// The msg argument should be used to add context to any underlying error, +// while the err argument should be used to attach the actual error that +// triggered this log line, if present. +func (l Logger) Error(err error, msg string, keysAndValues ...interface{}) { + if withHelper, ok := l.sink.(CallStackHelperLogSink); ok { + withHelper.GetCallStackHelper()() + } + l.sink.Error(err, msg, keysAndValues...) +} + +// V returns a new Logger instance for a specific verbosity level, relative to +// this Logger. In other words, V-levels are additive. A higher verbosity +// level means a log message is less important. Negative V-levels are treated +// as 0. +func (l Logger) V(level int) Logger { + if level < 0 { + level = 0 + } + l.level += level + return l +} + +// WithValues returns a new Logger instance with additional key/value pairs. +// See Info for documentation on how key/value pairs work. +func (l Logger) WithValues(keysAndValues ...interface{}) Logger { + l.setSink(l.sink.WithValues(keysAndValues...)) + return l +} - // V returns an Logger value for a specific verbosity level, relative to - // this Logger. In other words, V values are additive. V higher verbosity - // level means a log message is less important. It's illegal to pass a log - // level less than zero. - V(level int) Logger - - // WithValues adds some key-value pairs of context to a logger. - // See Info for documentation on how key/value pairs work. - WithValues(keysAndValues ...interface{}) Logger - - // WithName adds a new element to the logger's name. - // Successive calls with WithName continue to append - // suffixes to the logger's name. It's strongly recommended - // that name segments contain only letters, digits, and hyphens - // (see the package documentation for more information). - WithName(name string) Logger +// WithName returns a new Logger instance with the specified name element added +// to the Logger's name. Successive calls with WithName append additional +// suffixes to the Logger's name. It's strongly recommended that name segments +// contain only letters, digits, and hyphens (see the package documentation for +// more information). +func (l Logger) WithName(name string) Logger { + l.setSink(l.sink.WithName(name)) + return l } -// InfoLogger provides compatibility with code that relies on the v0.1.0 -// interface. +// WithCallDepth returns a Logger instance that offsets the call stack by the +// specified number of frames when logging call site information, if possible. +// This is useful for users who have helper functions between the "real" call +// site and the actual calls to Logger methods. If depth is 0 the attribution +// should be to the direct caller of this function. If depth is 1 the +// attribution should skip 1 call frame, and so on. Successive calls to this +// are additive. +// +// If the underlying log implementation supports a WithCallDepth(int) method, +// it will be called and the result returned. If the implementation does not +// support CallDepthLogSink, the original Logger will be returned. +// +// To skip one level, WithCallStackHelper() should be used instead of +// WithCallDepth(1) because it works with implementions that support the +// CallDepthLogSink and/or CallStackHelperLogSink interfaces. +func (l Logger) WithCallDepth(depth int) Logger { + if withCallDepth, ok := l.sink.(CallDepthLogSink); ok { + l.setSink(withCallDepth.WithCallDepth(depth)) + } + return l +} + +// WithCallStackHelper returns a new Logger instance that skips the direct +// caller when logging call site information, if possible. This is useful for +// users who have helper functions between the "real" call site and the actual +// calls to Logger methods and want to support loggers which depend on marking +// each individual helper function, like loggers based on testing.T. +// +// In addition to using that new logger instance, callers also must call the +// returned function. // -// Deprecated: InfoLogger is an artifact of early versions of this API. New -// users should never use it and existing users should use Logger instead. This -// will be removed in a future release. -type InfoLogger = Logger +// If the underlying log implementation supports a WithCallDepth(int) method, +// WithCallDepth(1) will be called to produce a new logger. If it supports a +// WithCallStackHelper() method, that will be also called. If the +// implementation does not support either of these, the original Logger will be +// returned. +func (l Logger) WithCallStackHelper() (func(), Logger) { + var helper func() + if withCallDepth, ok := l.sink.(CallDepthLogSink); ok { + l.setSink(withCallDepth.WithCallDepth(1)) + } + if withHelper, ok := l.sink.(CallStackHelperLogSink); ok { + helper = withHelper.GetCallStackHelper() + } else { + helper = func() {} + } + return helper, l +} +// contextKey is how we find Loggers in a context.Context. type contextKey struct{} -// FromContext returns a Logger constructed from ctx or nil if no -// logger details are found. -func FromContext(ctx context.Context) Logger { +// FromContext returns a Logger from ctx or an error if no Logger is found. +func FromContext(ctx context.Context) (Logger, error) { if v, ok := ctx.Value(contextKey{}).(Logger); ok { - return v + return v, nil } - return nil + return Logger{}, notFoundError{} } -// FromContextOrDiscard returns a Logger constructed from ctx or a Logger -// that discards all messages if no logger details are found. +// notFoundError exists to carry an IsNotFound method. +type notFoundError struct{} + +func (notFoundError) Error() string { + return "no logr.Logger was present" +} + +func (notFoundError) IsNotFound() bool { + return true +} + +// FromContextOrDiscard returns a Logger from ctx. If no Logger is found, this +// returns a Logger that discards all log messages. func FromContextOrDiscard(ctx context.Context) Logger { if v, ok := ctx.Value(contextKey{}).(Logger); ok { return v @@ -217,12 +376,59 @@ func FromContextOrDiscard(ctx context.Context) Logger { return Discard() } -// NewContext returns a new context derived from ctx that embeds the Logger. -func NewContext(ctx context.Context, l Logger) context.Context { - return context.WithValue(ctx, contextKey{}, l) +// NewContext returns a new Context, derived from ctx, which carries the +// provided Logger. +func NewContext(ctx context.Context, logger Logger) context.Context { + return context.WithValue(ctx, contextKey{}, logger) } -// CallDepthLogger represents a Logger that knows how to climb the call stack +// RuntimeInfo holds information that the logr "core" library knows which +// LogSinks might want to know. +type RuntimeInfo struct { + // CallDepth is the number of call frames the logr library adds between the + // end-user and the LogSink. LogSink implementations which choose to print + // the original logging site (e.g. file & line) should climb this many + // additional frames to find it. + CallDepth int +} + +// runtimeInfo is a static global. It must not be changed at run time. +var runtimeInfo = RuntimeInfo{ + CallDepth: 1, +} + +// LogSink represents a logging implementation. End-users will generally not +// interact with this type. +type LogSink interface { + // Init receives optional information about the logr library for LogSink + // implementations that need it. + Init(info RuntimeInfo) + + // Enabled tests whether this LogSink is enabled at the specified V-level. + // For example, commandline flags might be used to set the logging + // verbosity and disable some info logs. + Enabled(level int) bool + + // Info logs a non-error message with the given key/value pairs as context. + // The level argument is provided for optional logging. This method will + // only be called when Enabled(level) is true. See Logger.Info for more + // details. + Info(level int, msg string, keysAndValues ...interface{}) + + // Error logs an error, with the given message and key/value pairs as + // context. See Logger.Error for more details. + Error(err error, msg string, keysAndValues ...interface{}) + + // WithValues returns a new LogSink with additional key/value pairs. See + // Logger.WithValues for more details. + WithValues(keysAndValues ...interface{}) LogSink + + // WithName returns a new LogSink with the specified name appended. See + // Logger.WithName for more details. + WithName(name string) LogSink +} + +// CallDepthLogSink represents a Logger that knows how to climb the call stack // to identify the original call site and can offset the depth by a specified // number of frames. This is useful for users who have helper functions // between the "real" call site and the actual calls to Logger methods. @@ -232,35 +438,59 @@ func NewContext(ctx context.Context, l Logger) context.Context { // // This is an optional interface and implementations are not required to // support it. -type CallDepthLogger interface { - Logger - - // WithCallDepth returns a Logger that will offset the call stack by the - // specified number of frames when logging call site information. If depth - // is 0 the attribution should be to the direct caller of this method. If - // depth is 1 the attribution should skip 1 call frame, and so on. +type CallDepthLogSink interface { + // WithCallDepth returns a LogSink that will offset the call + // stack by the specified number of frames when logging call + // site information. + // + // If depth is 0, the LogSink should skip exactly the number + // of call frames defined in RuntimeInfo.CallDepth when Info + // or Error are called, i.e. the attribution should be to the + // direct caller of Logger.Info or Logger.Error. + // + // If depth is 1 the attribution should skip 1 call frame, and so on. // Successive calls to this are additive. - WithCallDepth(depth int) Logger + WithCallDepth(depth int) LogSink } -// WithCallDepth returns a Logger that will offset the call stack by the -// specified number of frames when logging call site information, if possible. -// This is useful for users who have helper functions between the "real" call -// site and the actual calls to Logger methods. If depth is 0 the attribution -// should be to the direct caller of this function. If depth is 1 the -// attribution should skip 1 call frame, and so on. Successive calls to this -// are additive. +// CallStackHelperLogSink represents a Logger that knows how to climb +// the call stack to identify the original call site and can skip +// intermediate helper functions if they mark themselves as +// helper. Go's testing package uses that approach. // -// If the underlying log implementation supports the CallDepthLogger interface, -// the WithCallDepth method will be called and the result returned. If the -// implementation does not support CallDepthLogger, the original Logger will be -// returned. +// This is useful for users who have helper functions between the +// "real" call site and the actual calls to Logger methods. +// Implementations that log information about the call site (such as +// file, function, or line) would otherwise log information about the +// intermediate helper functions. // -// Callers which care about whether this was supported or not should test for -// CallDepthLogger support themselves. -func WithCallDepth(logger Logger, depth int) Logger { - if decorator, ok := logger.(CallDepthLogger); ok { - return decorator.WithCallDepth(depth) - } - return logger +// This is an optional interface and implementations are not required +// to support it. Implementations that choose to support this must not +// simply implement it as WithCallDepth(1), because +// Logger.WithCallStackHelper will call both methods if they are +// present. This should only be implemented for LogSinks that actually +// need it, as with testing.T. +type CallStackHelperLogSink interface { + // GetCallStackHelper returns a function that must be called + // to mark the direct caller as helper function when logging + // call site information. + GetCallStackHelper() func() +} + +// Marshaler is an optional interface that logged values may choose to +// implement. Loggers with structured output, such as JSON, should +// log the object return by the MarshalLog method instead of the +// original value. +type Marshaler interface { + // MarshalLog can be used to: + // - ensure that structs are not logged as strings when the original + // value has a String method: return a different type without a + // String method + // - select which fields of a complex type should get logged: + // return a simpler struct with fewer fields + // - log unexported fields: return a different struct + // with exported fields + // + // It may return any value of any type. + MarshalLog() interface{} } diff --git a/vendor/github.com/go-logr/zapr/.gitignore b/vendor/github.com/go-logr/zapr/.gitignore index 5ba77727f1..b72f9be204 100644 --- a/vendor/github.com/go-logr/zapr/.gitignore +++ b/vendor/github.com/go-logr/zapr/.gitignore @@ -1,3 +1,2 @@ *~ *.swp -/vendor diff --git a/vendor/github.com/go-logr/zapr/Gopkg.lock b/vendor/github.com/go-logr/zapr/Gopkg.lock deleted file mode 100644 index 8da0a8f76c..0000000000 --- a/vendor/github.com/go-logr/zapr/Gopkg.lock +++ /dev/null @@ -1,52 +0,0 @@ -# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. - - -[[projects]] - digest = "1:edd2fa4578eb086265db78a9201d15e76b298dfd0d5c379da83e9c61712cf6df" - name = "github.com/go-logr/logr" - packages = ["."] - pruneopts = "UT" - revision = "9fb12b3b21c5415d16ac18dc5cd42c1cfdd40c4e" - version = "v0.1.0" - -[[projects]] - digest = "1:3c1a69cdae3501bf75e76d0d86dc6f2b0a7421bc205c0cb7b96b19eed464a34d" - name = "go.uber.org/atomic" - packages = ["."] - pruneopts = "UT" - revision = "1ea20fb1cbb1cc08cbd0d913a96dead89aa18289" - version = "v1.3.2" - -[[projects]] - digest = "1:60bf2a5e347af463c42ed31a493d817f8a72f102543060ed992754e689805d1a" - name = "go.uber.org/multierr" - packages = ["."] - pruneopts = "UT" - revision = "3c4937480c32f4c13a875a1829af76c98ca3d40a" - version = "v1.1.0" - -[[projects]] - digest = "1:9580b1b079114140ade8cec957685344d14f00119e0241f6b369633cb346eeb3" - name = "go.uber.org/zap" - packages = [ - ".", - "buffer", - "internal/bufferpool", - "internal/color", - "internal/exit", - "zapcore", - ] - pruneopts = "UT" - revision = "eeedf312bc6c57391d84767a4cd413f02a917974" - version = "v1.8.0" - -[solve-meta] - analyzer-name = "dep" - analyzer-version = 1 - input-imports = [ - "github.com/go-logr/logr", - "go.uber.org/zap", - "go.uber.org/zap/zapcore", - ] - solver-name = "gps-cdcl" - solver-version = 1 diff --git a/vendor/github.com/go-logr/zapr/Gopkg.toml b/vendor/github.com/go-logr/zapr/Gopkg.toml deleted file mode 100644 index ae475d72e0..0000000000 --- a/vendor/github.com/go-logr/zapr/Gopkg.toml +++ /dev/null @@ -1,38 +0,0 @@ -# Gopkg.toml example -# -# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md -# for detailed Gopkg.toml documentation. -# -# required = ["github.com/user/thing/cmd/thing"] -# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] -# -# [[constraint]] -# name = "github.com/user/project" -# version = "1.0.0" -# -# [[constraint]] -# name = "github.com/user/project2" -# branch = "dev" -# source = "github.com/myfork/project2" -# -# [[override]] -# name = "github.com/x/y" -# version = "2.4.0" -# -# [prune] -# non-go = false -# go-tests = true -# unused-packages = true - - -[[constraint]] - name = "github.com/go-logr/logr" - version = "0.1.0" - -[[constraint]] - name = "go.uber.org/zap" - version = "1.8.0" - -[prune] - go-tests = true - unused-packages = true diff --git a/vendor/github.com/go-logr/zapr/README.md b/vendor/github.com/go-logr/zapr/README.md index 548470ee14..78f5f7653f 100644 --- a/vendor/github.com/go-logr/zapr/README.md +++ b/vendor/github.com/go-logr/zapr/README.md @@ -29,17 +29,42 @@ func main() { } ``` +Increasing Verbosity +-------------------- + +Zap uses semantically named levels for logging (`DebugLevel`, `InfoLevel`, +`WarningLevel`, ...). Logr uses arbitrary numeric levels. By default logr's +`V(0)` is zap's `InfoLevel` and `V(1)` is zap's `DebugLevel` (which is +numerically -1). Zap does not have named levels that are more verbose than +`DebugLevel`, but it's possible to fake it. + +As of zap v1.19.0 you can do something like the following in your setup code: + +```go + zc := zap.NewProductionConfig() + zc.Level = zap.NewAtomicLevelAt(zapcore.Level(-2)) + z, err := zc.Build() + if err != nil { + // ... + } + log := zapr.NewLogger(z) +``` + +Zap's levels get more verbose as the number gets smaller and more important and +the number gets larger (`DebugLevel` is -1, `InfoLevel` is 0, `WarnLevel` is 1, +and so on). + +The `-2` in the above snippet means that `log.V(2).Info()` calls will be active. +`-3` would enable `log.V(3).Info()`, etc. Note that zap's levels are `int8` +which means the most verbose level you can give it is -128. The zapr +implementation will cap `V()` levels greater than 127 to 127, so setting the +zap level to -128 really means "activate all logs". + Implementation Details ---------------------- For the most part, concepts in Zap correspond directly with those in logr. -Unlike Zap, all fields *must* be in the form of suggared fields -- +Unlike Zap, all fields *must* be in the form of sugared fields -- it's illegal to pass a strongly-typed Zap field in a key position to any of the logging methods (`Log`, `Error`). - -Levels in logr correspond to custom debug levels in Zap. Any given level -in logr is represents by its inverse in Zap (`zapLevel = -1*logrLevel`). - -For example `V(2)` is equivalent to log level -2 in Zap, while `V(1)` is -equivalent to Zap's `DebugLevel`. diff --git a/vendor/github.com/go-logr/zapr/go.mod b/vendor/github.com/go-logr/zapr/go.mod new file mode 100644 index 0000000000..71c4aea096 --- /dev/null +++ b/vendor/github.com/go-logr/zapr/go.mod @@ -0,0 +1,10 @@ +module github.com/go-logr/zapr + +go 1.16 + +require ( + github.com/go-logr/logr v1.2.0 + github.com/pkg/errors v0.9.1 // indirect + github.com/stretchr/testify v1.7.0 + go.uber.org/zap v1.19.0 +) diff --git a/vendor/github.com/go-logr/zapr/go.sum b/vendor/github.com/go-logr/zapr/go.sum new file mode 100644 index 0000000000..98fe663e73 --- /dev/null +++ b/vendor/github.com/go-logr/zapr/go.sum @@ -0,0 +1,51 @@ +github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8= +github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/go-logr/logr v1.2.0 h1:QK40JKJyMdUDz+h+xvCsru/bJhvG0UxvePV0ufL/AcE= +github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= +go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/goleak v1.1.10 h1:z+mqJhf6ss6BSfSM671tgKyZBFPTTJM+HLxnhPC3wu0= +go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4= +go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/zap v1.19.0 h1:mZQZefskPPCMIBCSEH0v2/iUqqLrYtaeqwD6FUGUnFE= +go.uber.org/zap v1.19.0/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20191108193012-7d206e10da11 h1:Yq9t9jnGoR+dBuitxdo9l6Q7xh/zOyNnYUtDKaQ3x0E= +golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/vendor/github.com/go-logr/zapr/zapr.go b/vendor/github.com/go-logr/zapr/zapr.go index 0969a4a475..5f99ca117e 100644 --- a/vendor/github.com/go-logr/zapr/zapr.go +++ b/vendor/github.com/go-logr/zapr/zapr.go @@ -28,7 +28,7 @@ limitations under the License. // See the License for the specific language governing permissions and // limitations under the License. -// package zapr defines an implementation of the github.com/go-logr/logr +// Package zapr defines an implementation of the github.com/go-logr/logr // interfaces built on top of Zap (go.uber.org/zap). // // Usage @@ -69,35 +69,81 @@ import ( type zapLogger struct { // NB: this looks very similar to zap.SugaredLogger, but // deals with our desire to have multiple verbosity levels. - l *zap.Logger - lvl zapcore.Level + l *zap.Logger + + // numericLevelKey controls whether the numeric logr level is + // added to each Info log message and with which key. + numericLevelKey string + + // errorKey is the field name used for the error in + // Logger.Error calls. + errorKey string + + // allowZapFields enables logging of strongly-typed Zap + // fields. It is off by default because it breaks + // implementation agnosticism. + allowZapFields bool + + // panicMessages enables log messages for invalid log calls + // that explain why a call was invalid (for example, + // non-string key). This is enabled by default. + panicMessages bool } +const ( + // noLevel tells handleFields to not inject a numeric log level field. + noLevel = -1 +) + // handleFields converts a bunch of arbitrary key-value pairs into Zap fields. It takes // additional pre-converted Zap fields, for use with automatically attached fields, like // `error`. -func handleFields(l *zap.Logger, args []interface{}, additional ...zap.Field) []zap.Field { +func (zl *zapLogger) handleFields(lvl int, args []interface{}, additional ...zap.Field) []zap.Field { + injectNumericLevel := zl.numericLevelKey != "" && lvl != noLevel + // a slightly modified version of zap.SugaredLogger.sweetenFields if len(args) == 0 { - // fast-return if we have no suggared fields. - return additional + // fast-return if we have no suggared fields and no "v" field. + if !injectNumericLevel { + return additional + } + // Slightly slower fast path when we need to inject "v". + return append(additional, zap.Int(zl.numericLevelKey, lvl)) } // unlike Zap, we can be pretty sure users aren't passing structured // fields (since logr has no concept of that), so guess that we need a // little less space. - fields := make([]zap.Field, 0, len(args)/2+len(additional)) + numFields := len(args)/2 + len(additional) + if injectNumericLevel { + numFields++ + } + fields := make([]zap.Field, 0, numFields) + if injectNumericLevel { + fields = append(fields, zap.Int(zl.numericLevelKey, lvl)) + } for i := 0; i < len(args); { - // check just in case for strongly-typed Zap fields, which is illegal (since - // it breaks implementation agnosticism), so we can give a better error message. - if _, ok := args[i].(zap.Field); ok { - l.DPanic("strongly-typed Zap Field passed to logr", zap.Any("zap field", args[i])) + // Check just in case for strongly-typed Zap fields, + // which might be illegal (since it breaks + // implementation agnosticism). If disabled, we can + // give a better error message. + if field, ok := args[i].(zap.Field); ok { + if zl.allowZapFields { + fields = append(fields, field) + i++ + continue + } + if zl.panicMessages { + zl.l.WithOptions(zap.AddCallerSkip(1)).DPanic("strongly-typed Zap Field passed to logr", zapIt("zap field", args[i])) + } break } // make sure this isn't a mismatched key if i == len(args)-1 { - l.DPanic("odd number of arguments passed as key-value pairs for logging", zap.Any("ignored key", args[i])) + if zl.panicMessages { + zl.l.WithOptions(zap.AddCallerSkip(1)).DPanic("odd number of arguments passed as key-value pairs for logging", zapIt("ignored key", args[i])) + } break } @@ -107,52 +153,74 @@ func handleFields(l *zap.Logger, args []interface{}, additional ...zap.Field) [] keyStr, isString := key.(string) if !isString { // if the key isn't a string, DPanic and stop logging - l.DPanic("non-string key argument passed to logging, ignoring all later arguments", zap.Any("invalid key", key)) + if zl.panicMessages { + zl.l.WithOptions(zap.AddCallerSkip(1)).DPanic("non-string key argument passed to logging, ignoring all later arguments", zapIt("invalid key", key)) + } break } - fields = append(fields, zap.Any(keyStr, val)) + fields = append(fields, zapIt(keyStr, val)) i += 2 } return append(fields, additional...) } -func (zl *zapLogger) Enabled() bool { - return zl.l.Core().Enabled(zl.lvl) +func zapIt(field string, val interface{}) zap.Field { + // Handle types that implement logr.Marshaler: log the replacement + // object instead of the original one. + if marshaler, ok := val.(logr.Marshaler); ok { + val = marshaler.MarshalLog() + } + return zap.Any(field, val) +} + +func (zl *zapLogger) Init(ri logr.RuntimeInfo) { + zl.l = zl.l.WithOptions(zap.AddCallerSkip(ri.CallDepth)) } -func (zl *zapLogger) Info(msg string, keysAndVals ...interface{}) { - if checkedEntry := zl.l.Check(zl.lvl, msg); checkedEntry != nil { - checkedEntry.Write(handleFields(zl.l, keysAndVals)...) +// Zap levels are int8 - make sure we stay in bounds. logr itself should +// ensure we never get negative values. +func toZapLevel(lvl int) zapcore.Level { + if lvl > 127 { + lvl = 127 } + // zap levels are inverted. + return 0 - zapcore.Level(lvl) } -func (zl *zapLogger) Error(err error, msg string, keysAndVals ...interface{}) { - if checkedEntry := zl.l.Check(zap.ErrorLevel, msg); checkedEntry != nil { - checkedEntry.Write(handleFields(zl.l, keysAndVals, zap.Error(err))...) +func (zl zapLogger) Enabled(lvl int) bool { + return zl.l.Core().Enabled(toZapLevel(lvl)) +} + +func (zl *zapLogger) Info(lvl int, msg string, keysAndVals ...interface{}) { + if checkedEntry := zl.l.Check(toZapLevel(lvl), msg); checkedEntry != nil { + checkedEntry.Write(zl.handleFields(lvl, keysAndVals)...) } } -func (zl *zapLogger) V(level int) logr.Logger { - return &zapLogger{ - lvl: zl.lvl - zapcore.Level(level), - l: zl.l, +func (zl *zapLogger) Error(err error, msg string, keysAndVals ...interface{}) { + if checkedEntry := zl.l.Check(zap.ErrorLevel, msg); checkedEntry != nil { + checkedEntry.Write(zl.handleFields(noLevel, keysAndVals, zap.NamedError(zl.errorKey, err))...) } } -func (zl *zapLogger) WithValues(keysAndValues ...interface{}) logr.Logger { - newLogger := zl.l.With(handleFields(zl.l, keysAndValues)...) - return newLoggerWithExtraSkip(newLogger, 0) +func (zl *zapLogger) WithValues(keysAndValues ...interface{}) logr.LogSink { + newLogger := *zl + newLogger.l = zl.l.With(zl.handleFields(noLevel, keysAndValues)...) + return &newLogger } -func (zl *zapLogger) WithName(name string) logr.Logger { - newLogger := zl.l.Named(name) - return newLoggerWithExtraSkip(newLogger, 0) +func (zl *zapLogger) WithName(name string) logr.LogSink { + newLogger := *zl + newLogger.l = zl.l.Named(name) + return &newLogger } -func (zl *zapLogger) WithCallDepth(depth int) logr.Logger { - return newLoggerWithExtraSkip(zl.l, depth) +func (zl *zapLogger) WithCallDepth(depth int) logr.LogSink { + newLogger := *zl + newLogger.l = zl.l.WithOptions(zap.AddCallerSkip(depth)) + return &newLogger } // Underlier exposes access to the underlying logging implementation. Since @@ -167,20 +235,70 @@ func (zl *zapLogger) GetUnderlying() *zap.Logger { return zl.l } -// newLoggerWithExtraSkip allows creation of loggers with variable levels of callstack skipping -func newLoggerWithExtraSkip(l *zap.Logger, callerSkip int) logr.Logger { - log := l.WithOptions(zap.AddCallerSkip(callerSkip)) - return &zapLogger{ - l: log, - lvl: zap.InfoLevel, - } -} - // NewLogger creates a new logr.Logger using the given Zap Logger to log. func NewLogger(l *zap.Logger) logr.Logger { + return NewLoggerWithOptions(l) +} + +// NewLoggerWithOptions creates a new logr.Logger using the given Zap Logger to +// log and applies additional options. +func NewLoggerWithOptions(l *zap.Logger, opts ...Option) logr.Logger { // creates a new logger skipping one level of callstack - return newLoggerWithExtraSkip(l, 1) + log := l.WithOptions(zap.AddCallerSkip(1)) + zl := &zapLogger{ + l: log, + } + zl.errorKey = "error" + zl.panicMessages = true + for _, option := range opts { + option(zl) + } + return logr.New(zl) +} + +// Option is one additional parameter for NewLoggerWithOptions. +type Option func(*zapLogger) + +// LogInfoLevel controls whether a numeric log level is added to +// Info log message. The empty string disables this, a non-empty +// string is the key for the additional field. Errors and +// internal panic messages do not have a log level and thus +// are always logged without this extra field. +func LogInfoLevel(key string) Option { + return func(zl *zapLogger) { + zl.numericLevelKey = key + } +} + +// ErrorKey replaces the default "error" field name used for the error +// in Logger.Error calls. +func ErrorKey(key string) Option { + return func(zl *zapLogger) { + zl.errorKey = key + } +} + +// AllowZapFields controls whether strongly-typed Zap fields may +// be passed instead of a key/value pair. This is disabled by +// default because it breaks implementation agnosticism. +func AllowZapFields(allowed bool) Option { + return func(zl *zapLogger) { + zl.allowZapFields = allowed + } +} + +// DPanicOnBugs controls whether extra log messages are emitted for +// invalid log calls with zap's DPanic method. Depending on the +// configuration of the zap logger, the program then panics after +// emitting the log message which is useful in development because +// such invalid log calls are bugs in the program. The log messages +// explain why a call was invalid (for example, non-string +// key). Emitting them is enabled by default. +func DPanicOnBugs(enabled bool) Option { + return func(zl *zapLogger) { + zl.panicMessages = enabled + } } -var _ logr.Logger = &zapLogger{} -var _ logr.CallDepthLogger = &zapLogger{} +var _ logr.LogSink = &zapLogger{} +var _ logr.CallDepthLogSink = &zapLogger{} diff --git a/vendor/github.com/google/cel-go/ext/BUILD.bazel b/vendor/github.com/google/cel-go/ext/BUILD.bazel new file mode 100644 index 0000000000..2b98ad3b7e --- /dev/null +++ b/vendor/github.com/google/cel-go/ext/BUILD.bazel @@ -0,0 +1,39 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") + +package( + licenses = ["notice"], # Apache 2.0 +) + +go_library( + name = "go_default_library", + srcs = [ + "encoders.go", + "guards.go", + "strings.go", + ], + importpath = "github.com/google/cel-go/ext", + visibility = ["//visibility:public"], + deps = [ + "//cel:go_default_library", + "//checker/decls:go_default_library", + "//common/types:go_default_library", + "//common/types/ref:go_default_library", + "//interpreter/functions:go_default_library", + "@org_golang_google_genproto//googleapis/api/expr/v1alpha1:go_default_library", + ], +) + +go_test( + name = "go_default_test", + size = "small", + srcs = [ + "encoders_test.go", + "strings_test.go", + ], + embed = [ + ":go_default_library", + ], + deps = [ + "//cel:go_default_library", + ], +) diff --git a/vendor/github.com/google/cel-go/ext/README.md b/vendor/github.com/google/cel-go/ext/README.md new file mode 100644 index 0000000000..5ddcc41510 --- /dev/null +++ b/vendor/github.com/google/cel-go/ext/README.md @@ -0,0 +1,194 @@ +# Extensions + +CEL extensions are a related set of constants, functions, macros, or other +features which may not be covered by the core CEL spec. + +## Encoders + +Encoding utilies for marshalling data into standardized representations. + +### Base64.Decode + +Decodes base64-encoded string to bytes. + +This function will return an error if the string input is not +base64-encoded. + + base64.decode() -> + +Examples: + + base64.decode('aGVsbG8=') // return b'hello' + base64.decode('aGVsbG8') // error + +### Base64.Encode + +Encodes bytes to a base64-encoded string. + + base64.encode() -> + +Example: + + base64.encode(b'hello') // return 'aGVsbG8=' + +## Strings + +Extended functions for string manipulation. As a general note, all indices are +zero-based. + +### CharAt + +Returns the character at the given position. If the position is negative, or +greater than the length of the string, the function will produce an error: + + .charAt() -> + +Examples: + + 'hello'.charAt(4) // return 'o' + 'hello'.charAt(5) // return '' + 'hello'.charAt(-1) // error + +### IndexOf + +Returns the integer index of the first occurrence of the search string. If the +search string is not found the function returns -1. + +The function also accepts an optional position from which to begin the +substring search. If the substring is the empty string, the index where the +search starts is returned (zero or custom). + + .indexOf() -> + .indexOf(, ) -> + +Examples: + + 'hello mellow'.indexOf('') // returns 0 + 'hello mellow'.indexOf('ello') // returns 1 + 'hello mellow'.indexOf('jello') // returns -1 + 'hello mellow'.indexOf('', 2) // returns 2 + 'hello mellow'.indexOf('ello', 2) // returns 7 + 'hello mellow'.indexOf('ello', 20) // error + +### LastIndexOf + +Returns the integer index of the last occurrence of the search string. If the +search string is not found the function returns -1. + +The function also accepts an optional position which represents the last index +to be considered as the beginning of the substring match. If the substring is +the empty string, the index where the search starts is returned (string length +or custom). + + .lastIndexOf() -> + .lastIndexOf(, ) -> + +Examples: + + 'hello mellow'.lastIndexOf('') // returns 12 + 'hello mellow'.lastIndexOf('ello') // returns 7 + 'hello mellow'.lastIndexOf('jello') // returns -1 + 'hello mellow'.lastIndexOf('ello', 6) // returns 1 + 'hello mellow'.lastIndexOf('ello', -1) // error + +### LowerAscii + +Returns a new string where all ASCII characters are lower-cased. + +This function does not perform Unicode case-mapping for characters outside the +ASCII range. + + .lowerAscii() -> + +Examples: + + 'TacoCat'.lowerAscii() // returns 'tacocat' + 'TacoCÆt Xii'.lowerAscii() // returns 'tacocÆt xii' + +### Replace + +Returns a new string based on the target, which replaces the occurrences of a +search string with a replacement string if present. The function accepts an +optional limit on the number of substring replacements to be made. + +When the replacement limit is 0, the result is the original string. When the +limit is a negative number, the function behaves the same as replace all. + + .replace(, ) -> + .replace(, , ) -> + +Examples: + + 'hello hello'.replace('he', 'we') // returns 'wello wello' + 'hello hello'.replace('he', 'we', -1) // returns 'wello wello' + 'hello hello'.replace('he', 'we', 1) // returns 'wello hello' + 'hello hello'.replace('he', 'we', 0) // returns 'hello hello' + +### Split + +Returns a list of strings split from the input by the given separator. The +function accepts an optional argument specifying a limit on the number of +substrings produced by the split. + +When the split limit is 0, the result is an empty list. When the limit is 1, +the result is the target string to split. When the limit is a negative +number, the function behaves the same as split all. + + .split() -> > + .split(, ) -> > + +Examples: + + 'hello hello hello'.split(' ') // returns ['hello', 'hello', 'hello'] + 'hello hello hello'.split(' ', 0) // returns [] + 'hello hello hello'.split(' ', 1) // returns ['hello hello hello'] + 'hello hello hello'.split(' ', 2) // returns ['hello', 'hello hello'] + 'hello hello hello'.split(' ', -1) // returns ['hello', 'hello', 'hello'] + +### Substring + +Returns the substring given a numeric range corresponding to character +positions. Optionally may omit the trailing range for a substring from a given +character position until the end of a string. + +Character offsets are 0-based with an inclusive start range and exclusive end +range. It is an error to specify an end range that is lower than the start +range, or for either the start or end index to be negative or exceed the string +length. + + .substring() -> + .substring(, ) -> + +Examples: + + 'tacocat'.substring(4) // returns 'cat' + 'tacocat'.substring(0, 4) // returns 'taco' + 'tacocat'.substring(-1) // error + 'tacocat'.substring(2, 1) // error + +### Trim + +Returns a new string which removes the leading and trailing whitespace in the +target string. The trim function uses the Unicode definition of whitespace +which does not include the zero-width spaces. See: +https://en.wikipedia.org/wiki/Whitespace_character#Unicode + + .trim() -> + +Examples: + + ' \ttrim\n '.trim() // returns 'trim' + +### UpperAscii + +Returns a new string where all ASCII characters are upper-cased. + +This function does not perform Unicode case-mapping for characters outside the +ASCII range. + + .upperAscii() -> + +Examples: + + 'TacoCat'.upperAscii() // returns 'TACOCAT' + 'TacoCÆt Xii'.upperAscii() // returns 'TACOCÆT XII' diff --git a/vendor/github.com/google/cel-go/ext/encoders.go b/vendor/github.com/google/cel-go/ext/encoders.go new file mode 100644 index 0000000000..7c7002d534 --- /dev/null +++ b/vendor/github.com/google/cel-go/ext/encoders.go @@ -0,0 +1,104 @@ +// Copyright 2020 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package ext + +import ( + "encoding/base64" + + "github.com/google/cel-go/cel" + "github.com/google/cel-go/checker/decls" + "github.com/google/cel-go/interpreter/functions" + + exprpb "google.golang.org/genproto/googleapis/api/expr/v1alpha1" +) + +// Encoders returns a cel.EnvOption to configure extended functions for string, byte, and object +// encodings. +// +// Base64.Decode +// +// Decodes base64-encoded string to bytes. +// +// This function will return an error if the string input is not base64-encoded. +// +// base64.decode() -> +// +// Examples: +// +// base64.decode('aGVsbG8=') // return b'hello' +// base64.decode('aGVsbG8') // error +// +// Base64.Encode +// +// Encodes bytes to a base64-encoded string. +// +// base64.encode() -> +// +// Examples: +// +// base64.encode(b'hello') // return b'aGVsbG8=' +func Encoders() cel.EnvOption { + return cel.Lib(encoderLib{}) +} + +type encoderLib struct{} + +func (encoderLib) CompileOptions() []cel.EnvOption { + return []cel.EnvOption{ + cel.Declarations( + decls.NewFunction("base64.decode", + decls.NewOverload("base64_decode_string", + []*exprpb.Type{decls.String}, + decls.Bytes)), + decls.NewFunction("base64.encode", + decls.NewOverload("base64_encode_bytes", + []*exprpb.Type{decls.Bytes}, + decls.String)), + ), + } +} + +func (encoderLib) ProgramOptions() []cel.ProgramOption { + wrappedBase64EncodeBytes := callInBytesOutString(base64EncodeBytes) + wrappedBase64DecodeString := callInStrOutBytes(base64DecodeString) + return []cel.ProgramOption{ + cel.Functions( + &functions.Overload{ + Operator: "base64.decode", + Unary: wrappedBase64DecodeString, + }, + &functions.Overload{ + Operator: "base64_decode_string", + Unary: wrappedBase64DecodeString, + }, + &functions.Overload{ + Operator: "base64.encode", + Unary: wrappedBase64EncodeBytes, + }, + &functions.Overload{ + Operator: "base64_encode_bytes", + Unary: wrappedBase64EncodeBytes, + }, + ), + } +} + +func base64DecodeString(str string) ([]byte, error) { + return base64.StdEncoding.DecodeString(str) +} + +func base64EncodeBytes(bytes []byte) (string, error) { + return base64.StdEncoding.EncodeToString(bytes), nil +} diff --git a/vendor/github.com/google/cel-go/ext/guards.go b/vendor/github.com/google/cel-go/ext/guards.go new file mode 100644 index 0000000000..809c0e1b09 --- /dev/null +++ b/vendor/github.com/google/cel-go/ext/guards.go @@ -0,0 +1,248 @@ +// Copyright 2020 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package ext + +import ( + "github.com/google/cel-go/common/types" + "github.com/google/cel-go/common/types/ref" + "github.com/google/cel-go/interpreter/functions" +) + +// function invocation guards for common call signatures within extension functions. + +func callInBytesOutString(fn func([]byte) (string, error)) functions.UnaryOp { + return func(val ref.Val) ref.Val { + vVal, ok := val.(types.Bytes) + if !ok { + return types.MaybeNoSuchOverloadErr(val) + } + str, err := fn([]byte(vVal)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.String(str) + } +} + +func callInStrOutBytes(fn func(string) ([]byte, error)) functions.UnaryOp { + return func(val ref.Val) ref.Val { + vVal, ok := val.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(val) + } + byt, err := fn(string(vVal)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.Bytes(byt) + } +} + +func callInStrOutStr(fn func(string) (string, error)) functions.UnaryOp { + return func(val ref.Val) ref.Val { + vVal, ok := val.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(val) + } + str, err := fn(string(vVal)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.String(str) + } +} + +func callInStrIntOutStr(fn func(string, int64) (string, error)) functions.BinaryOp { + return func(val, arg ref.Val) ref.Val { + vVal, ok := val.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(val) + } + argVal, ok := arg.(types.Int) + if !ok { + return types.MaybeNoSuchOverloadErr(arg) + } + out, err := fn(string(vVal), int64(argVal)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.String(out) + } +} + +func callInStrStrOutInt(fn func(string, string) (int64, error)) functions.BinaryOp { + return func(val, arg ref.Val) ref.Val { + vVal, ok := val.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(val) + } + argVal, ok := arg.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(arg) + } + out, err := fn(string(vVal), string(argVal)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.Int(out) + } +} + +func callInStrStrOutListStr(fn func(string, string) ([]string, error)) functions.BinaryOp { + return func(val, arg ref.Val) ref.Val { + vVal, ok := val.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(val) + } + argVal, ok := arg.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(arg) + } + out, err := fn(string(vVal), string(argVal)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.DefaultTypeAdapter.NativeToValue(out) + } +} + +func callInStrIntIntOutStr(fn func(string, int64, int64) (string, error)) functions.FunctionOp { + return func(args ...ref.Val) ref.Val { + if len(args) != 3 { + return types.NoSuchOverloadErr() + } + vVal, ok := args[0].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[0]) + } + arg1Val, ok := args[1].(types.Int) + if !ok { + return types.MaybeNoSuchOverloadErr(args[1]) + } + arg2Val, ok := args[2].(types.Int) + if !ok { + return types.MaybeNoSuchOverloadErr(args[2]) + } + out, err := fn(string(vVal), int64(arg1Val), int64(arg2Val)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.String(out) + } +} + +func callInStrStrStrOutStr(fn func(string, string, string) (string, error)) functions.FunctionOp { + return func(args ...ref.Val) ref.Val { + if len(args) != 3 { + return types.NoSuchOverloadErr() + } + vVal, ok := args[0].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[0]) + } + arg1Val, ok := args[1].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[1]) + } + arg2Val, ok := args[2].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[2]) + } + out, err := fn(string(vVal), string(arg1Val), string(arg2Val)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.String(out) + } +} + +func callInStrStrIntOutInt(fn func(string, string, int64) (int64, error)) functions.FunctionOp { + return func(args ...ref.Val) ref.Val { + if len(args) != 3 { + return types.NoSuchOverloadErr() + } + vVal, ok := args[0].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[0]) + } + arg1Val, ok := args[1].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[1]) + } + arg2Val, ok := args[2].(types.Int) + if !ok { + return types.MaybeNoSuchOverloadErr(args[2]) + } + out, err := fn(string(vVal), string(arg1Val), int64(arg2Val)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.Int(out) + } +} + +func callInStrStrIntOutListStr(fn func(string, string, int64) ([]string, error)) functions.FunctionOp { + return func(args ...ref.Val) ref.Val { + if len(args) != 3 { + return types.NoSuchOverloadErr() + } + vVal, ok := args[0].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[0]) + } + arg1Val, ok := args[1].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[1]) + } + arg2Val, ok := args[2].(types.Int) + if !ok { + return types.MaybeNoSuchOverloadErr(args[2]) + } + out, err := fn(string(vVal), string(arg1Val), int64(arg2Val)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.DefaultTypeAdapter.NativeToValue(out) + } +} + +func callInStrStrStrIntOutStr(fn func(string, string, string, int64) (string, error)) functions.FunctionOp { + return func(args ...ref.Val) ref.Val { + if len(args) != 4 { + return types.NoSuchOverloadErr() + } + vVal, ok := args[0].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[0]) + } + arg1Val, ok := args[1].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[1]) + } + arg2Val, ok := args[2].(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(args[2]) + } + arg3Val, ok := args[3].(types.Int) + if !ok { + return types.MaybeNoSuchOverloadErr(args[3]) + } + out, err := fn(string(vVal), string(arg1Val), string(arg2Val), int64(arg3Val)) + if err != nil { + return types.NewErr(err.Error()) + } + return types.String(out) + } +} diff --git a/vendor/github.com/google/cel-go/ext/strings.go b/vendor/github.com/google/cel-go/ext/strings.go new file mode 100644 index 0000000000..28ab10803a --- /dev/null +++ b/vendor/github.com/google/cel-go/ext/strings.go @@ -0,0 +1,503 @@ +// Copyright 2020 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package ext contains CEL extension libraries where each library defines a related set of +// constants, functions, macros, or other configuration settings which may not be covered by +// the core CEL spec. +package ext + +import ( + "fmt" + "strings" + "unicode" + + "github.com/google/cel-go/cel" + "github.com/google/cel-go/checker/decls" + "github.com/google/cel-go/common/types" + "github.com/google/cel-go/common/types/ref" + "github.com/google/cel-go/interpreter/functions" + + exprpb "google.golang.org/genproto/googleapis/api/expr/v1alpha1" +) + +// Strings returns a cel.EnvOption to configure extended functions for string manipulation. +// As a general note, all indices are zero-based. +// +// CharAt +// +// Returns the character at the given position. If the position is negative, or greater than +// the length of the string, the function will produce an error: +// +// .charAt() -> +// +// Examples: +// +// 'hello'.charAt(4) // return 'o' +// 'hello'.charAt(5) // return '' +// 'hello'.charAt(-1) // error +// +// IndexOf +// +// Returns the integer index of the first occurrence of the search string. If the search string is +// not found the function returns -1. +// +// The function also accepts an optional position from which to begin the substring search. If the +// substring is the empty string, the index where the search starts is returned (zero or custom). +// +// .indexOf() -> +// .indexOf(, ) -> +// +// Examples: +// +// 'hello mellow'.indexOf('') // returns 0 +// 'hello mellow'.indexOf('ello') // returns 1 +// 'hello mellow'.indexOf('jello') // returns -1 +// 'hello mellow'.indexOf('', 2) // returns 2 +// 'hello mellow'.indexOf('ello', 2) // returns 7 +// 'hello mellow'.indexOf('ello', 20) // error +// +// LastIndexOf +// +// Returns the integer index at the start of the last occurrence of the search string. If the +// search string is not found the function returns -1. +// +// The function also accepts an optional position which represents the last index to be +// considered as the beginning of the substring match. If the substring is the empty string, +// the index where the search starts is returned (string length or custom). +// +// .lastIndexOf() -> +// .lastIndexOf(, ) -> +// +// Examples: +// +// 'hello mellow'.lastIndexOf('') // returns 12 +// 'hello mellow'.lastIndexOf('ello') // returns 7 +// 'hello mellow'.lastIndexOf('jello') // returns -1 +// 'hello mellow'.lastIndexOf('ello', 6) // returns 1 +// 'hello mellow'.lastIndexOf('ello', -1) // error +// +// LowerAscii +// +// Returns a new string where all ASCII characters are lower-cased. +// +// This function does not perform Unicode case-mapping for characters outside the ASCII range. +// +// .lowerAscii() -> +// +// Examples: +// +// 'TacoCat'.lowerAscii() // returns 'tacocat' +// 'TacoCÆt Xii'.lowerAscii() // returns 'tacocÆt xii' +// +// Replace +// +// Returns a new string based on the target, which replaces the occurrences of a search string +// with a replacement string if present. The function accepts an optional limit on the number of +// substring replacements to be made. +// +// When the replacement limit is 0, the result is the original string. When the limit is a negative +// number, the function behaves the same as replace all. +// +// .replace(, ) -> +// .replace(, , ) -> +// +// Examples: +// +// 'hello hello'.replace('he', 'we') // returns 'wello wello' +// 'hello hello'.replace('he', 'we', -1) // returns 'wello wello' +// 'hello hello'.replace('he', 'we', 1) // returns 'wello hello' +// 'hello hello'.replace('he', 'we', 0) // returns 'hello hello' +// +// Split +// +// Returns a list of strings split from the input by the given separator. The function accepts +// an optional argument specifying a limit on the number of substrings produced by the split. +// +// When the split limit is 0, the result is an empty list. When the limit is 1, the result is the +// target string to split. When the limit is a negative number, the function behaves the same as +// split all. +// +// .split() -> > +// .split(, ) -> > +// +// Examples: +// +// 'hello hello hello'.split(' ') // returns ['hello', 'hello', 'hello'] +// 'hello hello hello'.split(' ', 0) // returns [] +// 'hello hello hello'.split(' ', 1) // returns ['hello hello hello'] +// 'hello hello hello'.split(' ', 2) // returns ['hello', 'hello hello'] +// 'hello hello hello'.split(' ', -1) // returns ['hello', 'hello', 'hello'] +// +// Substring +// +// Returns the substring given a numeric range corresponding to character positions. Optionally +// may omit the trailing range for a substring from a given character position until the end of +// a string. +// +// Character offsets are 0-based with an inclusive start range and exclusive end range. It is an +// error to specify an end range that is lower than the start range, or for either the start or end +// index to be negative or exceed the string length. +// +// .substring() -> +// .substring(, ) -> +// +// Examples: +// +// 'tacocat'.substring(4) // returns 'cat' +// 'tacocat'.substring(0, 4) // returns 'taco' +// 'tacocat'.substring(-1) // error +// 'tacocat'.substring(2, 1) // error +// +// Trim +// +// Returns a new string which removes the leading and trailing whitespace in the target string. +// The trim function uses the Unicode definition of whitespace which does not include the +// zero-width spaces. See: https://en.wikipedia.org/wiki/Whitespace_character#Unicode +// +// .trim() -> +// +// Examples: +// +// ' \ttrim\n '.trim() // returns 'trim' +// +// UpperAscii +// +// Returns a new string where all ASCII characters are upper-cased. +// +// This function does not perform Unicode case-mapping for characters outside the ASCII range. +// +// .upperAscii() -> +// +// Examples: +// +// 'TacoCat'.upperAscii() // returns 'TACOCAT' +// 'TacoCÆt Xii'.upperAscii() // returns 'TACOCÆT XII' +func Strings() cel.EnvOption { + return cel.Lib(stringLib{}) +} + +type stringLib struct{} + +func (stringLib) CompileOptions() []cel.EnvOption { + return []cel.EnvOption{ + cel.Declarations( + decls.NewFunction("charAt", + decls.NewInstanceOverload("string_char_at_int", + []*exprpb.Type{decls.String, decls.Int}, + decls.String)), + decls.NewFunction("indexOf", + decls.NewInstanceOverload("string_index_of_string", + []*exprpb.Type{decls.String, decls.String}, + decls.Int), + decls.NewInstanceOverload("string_index_of_string_int", + []*exprpb.Type{decls.String, decls.String, decls.Int}, + decls.Int)), + decls.NewFunction("lastIndexOf", + decls.NewInstanceOverload("string_last_index_of_string", + []*exprpb.Type{decls.String, decls.String}, + decls.Int), + decls.NewInstanceOverload("string_last_index_of_string_int", + []*exprpb.Type{decls.String, decls.String, decls.Int}, + decls.Int)), + decls.NewFunction("lowerAscii", + decls.NewInstanceOverload("string_lower_ascii", + []*exprpb.Type{decls.String}, + decls.String)), + decls.NewFunction("replace", + decls.NewInstanceOverload("string_replace_string_string", + []*exprpb.Type{decls.String, decls.String, decls.String}, + decls.String), + decls.NewInstanceOverload("string_replace_string_string_int", + []*exprpb.Type{decls.String, decls.String, decls.String, decls.Int}, + decls.String)), + decls.NewFunction("split", + decls.NewInstanceOverload("string_split_string", + []*exprpb.Type{decls.String, decls.String}, + decls.NewListType(decls.String)), + decls.NewInstanceOverload("string_split_string_int", + []*exprpb.Type{decls.String, decls.String, decls.Int}, + decls.NewListType(decls.String))), + decls.NewFunction("substring", + decls.NewInstanceOverload("string_substring_int", + []*exprpb.Type{decls.String, decls.Int}, + decls.String), + decls.NewInstanceOverload("string_substring_int_int", + []*exprpb.Type{decls.String, decls.Int, decls.Int}, + decls.String)), + decls.NewFunction("trim", + decls.NewInstanceOverload("string_trim", + []*exprpb.Type{decls.String}, + decls.String)), + decls.NewFunction("upperAscii", + decls.NewInstanceOverload("string_upper_ascii", + []*exprpb.Type{decls.String}, + decls.String)), + ), + } +} + +func (stringLib) ProgramOptions() []cel.ProgramOption { + wrappedReplace := callInStrStrStrOutStr(replace) + wrappedReplaceN := callInStrStrStrIntOutStr(replaceN) + return []cel.ProgramOption{ + cel.Functions( + &functions.Overload{ + Operator: "charAt", + Binary: callInStrIntOutStr(charAt), + }, + &functions.Overload{ + Operator: "string_char_at_int", + Binary: callInStrIntOutStr(charAt), + }, + &functions.Overload{ + Operator: "indexOf", + Binary: callInStrStrOutInt(indexOf), + Function: callInStrStrIntOutInt(indexOfOffset), + }, + &functions.Overload{ + Operator: "string_index_of_string", + Binary: callInStrStrOutInt(indexOf), + }, + &functions.Overload{ + Operator: "string_index_of_string_int", + Function: callInStrStrIntOutInt(indexOfOffset), + }, + &functions.Overload{ + Operator: "lastIndexOf", + Binary: callInStrStrOutInt(lastIndexOf), + Function: callInStrStrIntOutInt(lastIndexOfOffset), + }, + &functions.Overload{ + Operator: "string_last_index_of_string", + Binary: callInStrStrOutInt(lastIndexOf), + }, + &functions.Overload{ + Operator: "string_last_index_of_string_int", + Function: callInStrStrIntOutInt(lastIndexOfOffset), + }, + &functions.Overload{ + Operator: "lowerAscii", + Unary: callInStrOutStr(lowerASCII), + }, + &functions.Overload{ + Operator: "string_lower_ascii", + Unary: callInStrOutStr(lowerASCII), + }, + &functions.Overload{ + Operator: "replace", + Function: func(values ...ref.Val) ref.Val { + if len(values) == 3 { + return wrappedReplace(values...) + } + if len(values) == 4 { + return wrappedReplaceN(values...) + } + return types.NoSuchOverloadErr() + }, + }, + &functions.Overload{ + Operator: "string_replace_string_string", + Function: wrappedReplace, + }, + &functions.Overload{ + Operator: "string_replace_string_string_int", + Function: wrappedReplaceN, + }, + &functions.Overload{ + Operator: "split", + Binary: callInStrStrOutListStr(split), + Function: callInStrStrIntOutListStr(splitN), + }, + &functions.Overload{ + Operator: "string_split_string", + Binary: callInStrStrOutListStr(split), + }, + &functions.Overload{ + Operator: "string_split_string_int", + Function: callInStrStrIntOutListStr(splitN), + }, + &functions.Overload{ + Operator: "substring", + Binary: callInStrIntOutStr(substr), + Function: callInStrIntIntOutStr(substrRange), + }, + &functions.Overload{ + Operator: "string_substring_int", + Binary: callInStrIntOutStr(substr), + }, + &functions.Overload{ + Operator: "string_substring_int_int", + Function: callInStrIntIntOutStr(substrRange), + }, + &functions.Overload{ + Operator: "trim", + Unary: callInStrOutStr(trimSpace), + }, + &functions.Overload{ + Operator: "string_trim", + Unary: callInStrOutStr(trimSpace), + }, + &functions.Overload{ + Operator: "upperAscii", + Unary: callInStrOutStr(upperASCII), + }, + &functions.Overload{ + Operator: "string_upper_ascii", + Unary: callInStrOutStr(upperASCII), + }, + ), + } +} + +func charAt(str string, ind int64) (string, error) { + i := int(ind) + runes := []rune(str) + if i < 0 || i > len(runes) { + return "", fmt.Errorf("index out of range: %d", ind) + } + if i == len(runes) { + return "", nil + } + return string(runes[i]), nil +} + +func indexOf(str, substr string) (int64, error) { + return indexOfOffset(str, substr, int64(0)) +} + +func indexOfOffset(str, substr string, offset int64) (int64, error) { + if substr == "" { + return offset, nil + } + off := int(offset) + runes := []rune(str) + subrunes := []rune(substr) + if off < 0 || off >= len(runes) { + return -1, fmt.Errorf("index out of range: %d", off) + } + for i := off; i < len(runes)-(len(subrunes)-1); i++ { + found := true + for j := 0; j < len(subrunes); j++ { + if runes[i+j] != subrunes[j] { + found = false + break + } + } + if found { + return int64(i), nil + } + } + return -1, nil +} + +func lastIndexOf(str, substr string) (int64, error) { + runes := []rune(str) + if substr == "" { + return int64(len(runes)), nil + } + return lastIndexOfOffset(str, substr, int64(len(runes)-1)) +} + +func lastIndexOfOffset(str, substr string, offset int64) (int64, error) { + if substr == "" { + return offset, nil + } + off := int(offset) + runes := []rune(str) + subrunes := []rune(substr) + if off < 0 || off >= len(runes) { + return -1, fmt.Errorf("index out of range: %d", off) + } + if off > len(runes)-len(subrunes) { + off = len(runes) - len(subrunes) + } + for i := off; i >= 0; i-- { + found := true + for j := 0; j < len(subrunes); j++ { + if runes[i+j] != subrunes[j] { + found = false + break + } + } + if found { + return int64(i), nil + } + } + return -1, nil +} + +func lowerASCII(str string) (string, error) { + runes := []rune(str) + for i, r := range runes { + if r <= unicode.MaxASCII { + r = unicode.ToLower(r) + runes[i] = r + } + } + return string(runes), nil +} + +func replace(str, old, new string) (string, error) { + return strings.ReplaceAll(str, old, new), nil +} + +func replaceN(str, old, new string, n int64) (string, error) { + return strings.Replace(str, old, new, int(n)), nil +} + +func split(str, sep string) ([]string, error) { + return strings.Split(str, sep), nil +} + +func splitN(str, sep string, n int64) ([]string, error) { + return strings.SplitN(str, sep, int(n)), nil +} + +func substr(str string, start int64) (string, error) { + runes := []rune(str) + if int(start) < 0 || int(start) > len(runes) { + return "", fmt.Errorf("index out of range: %d", start) + } + return string(runes[start:]), nil +} + +func substrRange(str string, start, end int64) (string, error) { + runes := []rune(str) + l := len(runes) + if start > end { + return "", fmt.Errorf("invalid substring range. start: %d, end: %d", start, end) + } + if int(start) < 0 || int(start) > l { + return "", fmt.Errorf("index out of range: %d", start) + } + if int(end) < 0 || int(end) > l { + return "", fmt.Errorf("index out of range: %d", end) + } + return string(runes[int(start):int(end)]), nil +} + +func trimSpace(str string) (string, error) { + return strings.TrimSpace(str), nil +} + +func upperASCII(str string) (string, error) { + runes := []rune(str) + for i, r := range runes { + if r <= unicode.MaxASCII { + r = unicode.ToUpper(r) + runes[i] = r + } + } + return string(runes), nil +} diff --git a/vendor/github.com/gorilla/mux/README.md b/vendor/github.com/gorilla/mux/README.md index 92e422eed7..35eea9f106 100644 --- a/vendor/github.com/gorilla/mux/README.md +++ b/vendor/github.com/gorilla/mux/README.md @@ -1,11 +1,10 @@ # gorilla/mux [![GoDoc](https://godoc.org/github.com/gorilla/mux?status.svg)](https://godoc.org/github.com/gorilla/mux) -[![Build Status](https://travis-ci.org/gorilla/mux.svg?branch=master)](https://travis-ci.org/gorilla/mux) [![CircleCI](https://circleci.com/gh/gorilla/mux.svg?style=svg)](https://circleci.com/gh/gorilla/mux) [![Sourcegraph](https://sourcegraph.com/github.com/gorilla/mux/-/badge.svg)](https://sourcegraph.com/github.com/gorilla/mux?badge) -![Gorilla Logo](http://www.gorillatoolkit.org/static/images/gorilla-icon-64.png) +![Gorilla Logo](https://cloud-cdn.questionable.services/gorilla-icon-64.png) https://www.gorillatoolkit.org/pkg/mux @@ -26,6 +25,7 @@ The name mux stands for "HTTP request multiplexer". Like the standard `http.Serv * [Examples](#examples) * [Matching Routes](#matching-routes) * [Static Files](#static-files) +* [Serving Single Page Applications](#serving-single-page-applications) (e.g. React, Vue, Ember.js, etc.) * [Registered URLs](#registered-urls) * [Walking Routes](#walking-routes) * [Graceful Shutdown](#graceful-shutdown) @@ -212,6 +212,93 @@ func main() { } ``` +### Serving Single Page Applications + +Most of the time it makes sense to serve your SPA on a separate web server from your API, +but sometimes it's desirable to serve them both from one place. It's possible to write a simple +handler for serving your SPA (for use with React Router's [BrowserRouter](https://reacttraining.com/react-router/web/api/BrowserRouter) for example), and leverage +mux's powerful routing for your API endpoints. + +```go +package main + +import ( + "encoding/json" + "log" + "net/http" + "os" + "path/filepath" + "time" + + "github.com/gorilla/mux" +) + +// spaHandler implements the http.Handler interface, so we can use it +// to respond to HTTP requests. The path to the static directory and +// path to the index file within that static directory are used to +// serve the SPA in the given static directory. +type spaHandler struct { + staticPath string + indexPath string +} + +// ServeHTTP inspects the URL path to locate a file within the static dir +// on the SPA handler. If a file is found, it will be served. If not, the +// file located at the index path on the SPA handler will be served. This +// is suitable behavior for serving an SPA (single page application). +func (h spaHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // get the absolute path to prevent directory traversal + path, err := filepath.Abs(r.URL.Path) + if err != nil { + // if we failed to get the absolute path respond with a 400 bad request + // and stop + http.Error(w, err.Error(), http.StatusBadRequest) + return + } + + // prepend the path with the path to the static directory + path = filepath.Join(h.staticPath, path) + + // check whether a file exists at the given path + _, err = os.Stat(path) + if os.IsNotExist(err) { + // file does not exist, serve index.html + http.ServeFile(w, r, filepath.Join(h.staticPath, h.indexPath)) + return + } else if err != nil { + // if we got an error (that wasn't that the file doesn't exist) stating the + // file, return a 500 internal server error and stop + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + // otherwise, use http.FileServer to serve the static dir + http.FileServer(http.Dir(h.staticPath)).ServeHTTP(w, r) +} + +func main() { + router := mux.NewRouter() + + router.HandleFunc("/api/health", func(w http.ResponseWriter, r *http.Request) { + // an example API handler + json.NewEncoder(w).Encode(map[string]bool{"ok": true}) + }) + + spa := spaHandler{staticPath: "build", indexPath: "index.html"} + router.PathPrefix("/").Handler(spa) + + srv := &http.Server{ + Handler: router, + Addr: "127.0.0.1:8000", + // Good practice: enforce timeouts for servers you create! + WriteTimeout: 15 * time.Second, + ReadTimeout: 15 * time.Second, + } + + log.Fatal(srv.ListenAndServe()) +} +``` + ### Registered URLs Now let's see how to build registered URLs. diff --git a/vendor/github.com/gorilla/mux/context.go b/vendor/github.com/gorilla/mux/context.go deleted file mode 100644 index 665940a268..0000000000 --- a/vendor/github.com/gorilla/mux/context.go +++ /dev/null @@ -1,18 +0,0 @@ -package mux - -import ( - "context" - "net/http" -) - -func contextGet(r *http.Request, key interface{}) interface{} { - return r.Context().Value(key) -} - -func contextSet(r *http.Request, key, val interface{}) *http.Request { - if val == nil { - return r - } - - return r.WithContext(context.WithValue(r.Context(), key, val)) -} diff --git a/vendor/github.com/gorilla/mux/go.mod b/vendor/github.com/gorilla/mux/go.mod index cfc8ede581..df170a3994 100644 --- a/vendor/github.com/gorilla/mux/go.mod +++ b/vendor/github.com/gorilla/mux/go.mod @@ -1 +1,3 @@ module github.com/gorilla/mux + +go 1.12 diff --git a/vendor/github.com/gorilla/mux/middleware.go b/vendor/github.com/gorilla/mux/middleware.go index cf2b26dc03..cb51c565eb 100644 --- a/vendor/github.com/gorilla/mux/middleware.go +++ b/vendor/github.com/gorilla/mux/middleware.go @@ -58,22 +58,17 @@ func CORSMethodMiddleware(r *Router) MiddlewareFunc { func getAllMethodsForRoute(r *Router, req *http.Request) ([]string, error) { var allMethods []string - err := r.Walk(func(route *Route, _ *Router, _ []*Route) error { - for _, m := range route.matchers { - if _, ok := m.(*routeRegexp); ok { - if m.Match(req, &RouteMatch{}) { - methods, err := route.GetMethods() - if err != nil { - return err - } - - allMethods = append(allMethods, methods...) - } - break + for _, route := range r.routes { + var match RouteMatch + if route.Match(req, &match) || match.MatchErr == ErrMethodMismatch { + methods, err := route.GetMethods() + if err != nil { + return nil, err } + + allMethods = append(allMethods, methods...) } - return nil - }) + } - return allMethods, err + return allMethods, nil } diff --git a/vendor/github.com/gorilla/mux/mux.go b/vendor/github.com/gorilla/mux/mux.go index a2cd193e48..782a34b22a 100644 --- a/vendor/github.com/gorilla/mux/mux.go +++ b/vendor/github.com/gorilla/mux/mux.go @@ -5,6 +5,7 @@ package mux import ( + "context" "errors" "fmt" "net/http" @@ -58,8 +59,7 @@ type Router struct { // If true, do not clear the request context after handling the request. // - // Deprecated: No effect when go1.7+ is used, since the context is stored - // on the request itself. + // Deprecated: No effect, since the context is stored on the request itself. KeepContext bool // Slice of middlewares to be called after a match is found @@ -111,10 +111,8 @@ func copyRouteConf(r routeConf) routeConf { c.regexp.queries = append(c.regexp.queries, copyRouteRegexp(q)) } - c.matchers = make([]matcher, 0, len(r.matchers)) - for _, m := range r.matchers { - c.matchers = append(c.matchers, m) - } + c.matchers = make([]matcher, len(r.matchers)) + copy(c.matchers, r.matchers) return c } @@ -197,8 +195,8 @@ func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) { var handler http.Handler if r.Match(req, &match) { handler = match.Handler - req = setVars(req, match.Vars) - req = setCurrentRoute(req, match.Route) + req = requestWithVars(req, match.Vars) + req = requestWithRoute(req, match.Route) } if handler == nil && match.MatchErr == ErrMethodMismatch { @@ -428,7 +426,7 @@ const ( // Vars returns the route variables for the current request, if any. func Vars(r *http.Request) map[string]string { - if rv := contextGet(r, varsKey); rv != nil { + if rv := r.Context().Value(varsKey); rv != nil { return rv.(map[string]string) } return nil @@ -437,21 +435,22 @@ func Vars(r *http.Request) map[string]string { // CurrentRoute returns the matched route for the current request, if any. // This only works when called inside the handler of the matched route // because the matched route is stored in the request context which is cleared -// after the handler returns, unless the KeepContext option is set on the -// Router. +// after the handler returns. func CurrentRoute(r *http.Request) *Route { - if rv := contextGet(r, routeKey); rv != nil { + if rv := r.Context().Value(routeKey); rv != nil { return rv.(*Route) } return nil } -func setVars(r *http.Request, val interface{}) *http.Request { - return contextSet(r, varsKey, val) +func requestWithVars(r *http.Request, vars map[string]string) *http.Request { + ctx := context.WithValue(r.Context(), varsKey, vars) + return r.WithContext(ctx) } -func setCurrentRoute(r *http.Request, val interface{}) *http.Request { - return contextSet(r, routeKey, val) +func requestWithRoute(r *http.Request, route *Route) *http.Request { + ctx := context.WithValue(r.Context(), routeKey, route) + return r.WithContext(ctx) } // ---------------------------------------------------------------------------- diff --git a/vendor/github.com/gorilla/mux/regexp.go b/vendor/github.com/gorilla/mux/regexp.go index ac1abcd473..0144842bb2 100644 --- a/vendor/github.com/gorilla/mux/regexp.go +++ b/vendor/github.com/gorilla/mux/regexp.go @@ -181,21 +181,21 @@ func (r *routeRegexp) Match(req *http.Request, match *RouteMatch) bool { } } return r.regexp.MatchString(host) - } else { - if r.regexpType == regexpTypeQuery { - return r.matchQueryString(req) - } - path := req.URL.Path - if r.options.useEncodedPath { - path = req.URL.EscapedPath() - } - return r.regexp.MatchString(path) } + + if r.regexpType == regexpTypeQuery { + return r.matchQueryString(req) + } + path := req.URL.Path + if r.options.useEncodedPath { + path = req.URL.EscapedPath() + } + return r.regexp.MatchString(path) } // url builds a URL part using the given values. func (r *routeRegexp) url(values map[string]string) (string, error) { - urlValues := make([]interface{}, len(r.varsN)) + urlValues := make([]interface{}, len(r.varsN), len(r.varsN)) for k, v := range r.varsN { value, ok := values[v] if !ok { @@ -230,14 +230,51 @@ func (r *routeRegexp) getURLQuery(req *http.Request) string { return "" } templateKey := strings.SplitN(r.template, "=", 2)[0] - for key, vals := range req.URL.Query() { - if key == templateKey && len(vals) > 0 { - return key + "=" + vals[0] - } + val, ok := findFirstQueryKey(req.URL.RawQuery, templateKey) + if ok { + return templateKey + "=" + val } return "" } +// findFirstQueryKey returns the same result as (*url.URL).Query()[key][0]. +// If key was not found, empty string and false is returned. +func findFirstQueryKey(rawQuery, key string) (value string, ok bool) { + query := []byte(rawQuery) + for len(query) > 0 { + foundKey := query + if i := bytes.IndexAny(foundKey, "&;"); i >= 0 { + foundKey, query = foundKey[:i], foundKey[i+1:] + } else { + query = query[:0] + } + if len(foundKey) == 0 { + continue + } + var value []byte + if i := bytes.IndexByte(foundKey, '='); i >= 0 { + foundKey, value = foundKey[:i], foundKey[i+1:] + } + if len(foundKey) < len(key) { + // Cannot possibly be key. + continue + } + keyString, err := url.QueryUnescape(string(foundKey)) + if err != nil { + continue + } + if keyString != key { + continue + } + valueString, err := url.QueryUnescape(string(value)) + if err != nil { + continue + } + return valueString, true + } + return "", false +} + func (r *routeRegexp) matchQueryString(req *http.Request) bool { return r.regexp.MatchString(r.getURLQuery(req)) } @@ -288,6 +325,12 @@ func (v routeRegexpGroup) setMatch(req *http.Request, m *RouteMatch, r *Route) { // Store host variables. if v.host != nil { host := getHost(req) + if v.host.wildcardHostPort { + // Don't be strict on the port match + if i := strings.Index(host, ":"); i != -1 { + host = host[:i] + } + } matches := v.host.regexp.FindStringSubmatchIndex(host) if len(matches) > 0 { extractVars(host, matches, v.host.varsN, m.Vars) diff --git a/vendor/github.com/gorilla/mux/route.go b/vendor/github.com/gorilla/mux/route.go index 8479c68c1d..750afe570d 100644 --- a/vendor/github.com/gorilla/mux/route.go +++ b/vendor/github.com/gorilla/mux/route.go @@ -74,7 +74,7 @@ func (r *Route) Match(req *http.Request, match *RouteMatch) bool { return false } - if match.MatchErr == ErrMethodMismatch { + if match.MatchErr == ErrMethodMismatch && r.handler != nil { // We found a route which matches request method, clear MatchErr match.MatchErr = nil // Then override the mis-matched handler @@ -412,11 +412,30 @@ func (r *Route) Queries(pairs ...string) *Route { type schemeMatcher []string func (m schemeMatcher) Match(r *http.Request, match *RouteMatch) bool { - return matchInArray(m, r.URL.Scheme) + scheme := r.URL.Scheme + // https://golang.org/pkg/net/http/#Request + // "For [most] server requests, fields other than Path and RawQuery will be + // empty." + // Since we're an http muxer, the scheme is either going to be http or https + // though, so we can just set it based on the tls termination state. + if scheme == "" { + if r.TLS == nil { + scheme = "http" + } else { + scheme = "https" + } + } + return matchInArray(m, scheme) } // Schemes adds a matcher for URL schemes. // It accepts a sequence of schemes to be matched, e.g.: "http", "https". +// If the request's URL has a scheme set, it will be matched against. +// Generally, the URL scheme will only be set if a previous handler set it, +// such as the ProxyHeaders handler from gorilla/handlers. +// If unset, the scheme will be determined based on the request's TLS +// termination state. +// The first argument to Schemes will be used when constructing a route URL. func (r *Route) Schemes(schemes ...string) *Route { for k, v := range schemes { schemes[k] = strings.ToLower(v) @@ -493,8 +512,8 @@ func (r *Route) Subrouter() *Router { // This also works for host variables: // // r := mux.NewRouter() -// r.Host("{subdomain}.domain.com"). -// HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler). +// r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler). +// Host("{subdomain}.domain.com"). // Name("article") // // // url.String() will be "http://news.domain.com/articles/technology/42" @@ -502,6 +521,13 @@ func (r *Route) Subrouter() *Router { // "category", "technology", // "id", "42") // +// The scheme of the resulting url will be the first argument that was passed to Schemes: +// +// // url.String() will be "https://example.com" +// r := mux.NewRouter() +// url, err := r.Host("example.com") +// .Schemes("https", "http").URL() +// // All variables defined in the route are required, and their values must // conform to the corresponding patterns. func (r *Route) URL(pairs ...string) (*url.URL, error) { @@ -635,7 +661,7 @@ func (r *Route) GetQueriesRegexp() ([]string, error) { if r.regexp.queries == nil { return nil, errors.New("mux: route doesn't have queries") } - var queries []string + queries := make([]string, 0, len(r.regexp.queries)) for _, query := range r.regexp.queries { queries = append(queries, query.regexp.String()) } @@ -654,7 +680,7 @@ func (r *Route) GetQueriesTemplates() ([]string, error) { if r.regexp.queries == nil { return nil, errors.New("mux: route doesn't have queries") } - var queries []string + queries := make([]string, 0, len(r.regexp.queries)) for _, query := range r.regexp.queries { queries = append(queries, query.template) } diff --git a/vendor/github.com/gorilla/mux/test_helpers.go b/vendor/github.com/gorilla/mux/test_helpers.go index 32ecffde48..5f5c496de0 100644 --- a/vendor/github.com/gorilla/mux/test_helpers.go +++ b/vendor/github.com/gorilla/mux/test_helpers.go @@ -15,5 +15,5 @@ import "net/http" // can be set by making a route that captures the required variables, // starting a server and sending the request to that server. func SetURLVars(r *http.Request, val map[string]string) *http.Request { - return setVars(r, val) + return requestWithVars(r, val) } diff --git a/vendor/github.com/json-iterator/go/README.md b/vendor/github.com/json-iterator/go/README.md index 52b111d5f3..c589addf98 100644 --- a/vendor/github.com/json-iterator/go/README.md +++ b/vendor/github.com/json-iterator/go/README.md @@ -8,8 +8,6 @@ A high-performance 100% compatible drop-in replacement of "encoding/json" -You can also use thrift like JSON using [thrift-iterator](https://github.com/thrift-iterator/go) - # Benchmark ![benchmark](http://jsoniter.com/benchmarks/go-benchmark.png) diff --git a/vendor/github.com/json-iterator/go/go.mod b/vendor/github.com/json-iterator/go/go.mod index e05c42ff58..e817cccbf6 100644 --- a/vendor/github.com/json-iterator/go/go.mod +++ b/vendor/github.com/json-iterator/go/go.mod @@ -6,6 +6,6 @@ require ( github.com/davecgh/go-spew v1.1.1 github.com/google/gofuzz v1.0.0 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 - github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 + github.com/modern-go/reflect2 v1.0.2 github.com/stretchr/testify v1.3.0 ) diff --git a/vendor/github.com/json-iterator/go/go.sum b/vendor/github.com/json-iterator/go/go.sum index be00a6df96..4b7bb8a295 100644 --- a/vendor/github.com/json-iterator/go/go.sum +++ b/vendor/github.com/json-iterator/go/go.sum @@ -5,11 +5,10 @@ github.com/google/gofuzz v1.0.0 h1:A8PeW59pxE9IoFRqBp37U+mSNaQoZ46F1f0f863XSXw= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg= -github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= diff --git a/vendor/github.com/mattn/go-sqlite3/README.md b/vendor/github.com/mattn/go-sqlite3/README.md index 746621f9fd..e455133fc9 100644 --- a/vendor/github.com/mattn/go-sqlite3/README.md +++ b/vendor/github.com/mattn/go-sqlite3/README.md @@ -7,17 +7,17 @@ go-sqlite3 [![codecov](https://codecov.io/gh/mattn/go-sqlite3/branch/master/graph/badge.svg)](https://codecov.io/gh/mattn/go-sqlite3) [![Go Report Card](https://goreportcard.com/badge/github.com/mattn/go-sqlite3)](https://goreportcard.com/report/github.com/mattn/go-sqlite3) -Latest stable version is v1.14 or later not v2. +Latest stable version is v1.14 or later, not v2. ~~**NOTE:** The increase to v2 was an accident. There were no major changes or features.~~ # Description -sqlite3 driver conforming to the built-in database/sql interface +A sqlite3 driver that conforms to the built-in database/sql interface. -Supported Golang version: See [.github/workflows/go.yaml](./.github/workflows/go.yaml) +Supported Golang version: See [.github/workflows/go.yaml](./.github/workflows/go.yaml). -[This package follows the official Golang Release Policy.](https://golang.org/doc/devel/release.html#policy) +This package follows the official [Golang Release Policy](https://golang.org/doc/devel/release.html#policy). ### Overview @@ -64,7 +64,7 @@ Supported Golang version: See [.github/workflows/go.yaml](./.github/workflows/go # Installation -This package can be installed with the go get command: +This package can be installed with the `go get` command: go get github.com/mattn/go-sqlite3 @@ -72,28 +72,28 @@ _go-sqlite3_ is *cgo* package. If you want to build your app using go-sqlite3, you need gcc. However, after you have built and installed _go-sqlite3_ with `go install github.com/mattn/go-sqlite3` (which requires gcc), you can build your app without relying on gcc in future. -***Important: because this is a `CGO` enabled package you are required to set the environment variable `CGO_ENABLED=1` and have a `gcc` compile present within your path.*** +***Important: because this is a `CGO` enabled package, you are required to set the environment variable `CGO_ENABLED=1` and have a `gcc` compile present within your path.*** # API Reference -API documentation can be found here: http://godoc.org/github.com/mattn/go-sqlite3 +API documentation can be found [here](http://godoc.org/github.com/mattn/go-sqlite3). -Examples can be found under the [examples](./_example) directory +Examples can be found under the [examples](./_example) directory. # Connection String When creating a new SQLite database or connection to an existing one, with the file name additional options can be given. -This is also known as a DSN string. (Data Source Name). +This is also known as a DSN (Data Source Name) string. Options are append after the filename of the SQLite database. -The database filename and options are seperated by an `?` (Question Mark). +The database filename and options are separated by an `?` (Question Mark). Options should be URL-encoded (see [url.QueryEscape](https://golang.org/pkg/net/url/#QueryEscape)). This also applies when using an in-memory database instead of a file. Options can be given using the following format: `KEYWORD=VALUE` and multiple options can be combined with the `&` ampersand. -This library supports dsn options of SQLite itself and provides additional options. +This library supports DSN options of SQLite itself and provides additional options. Boolean values can be one of: * `0` `no` `false` `off` @@ -138,19 +138,18 @@ file:test.db?cache=shared&mode=memory This package allows additional configuration of features available within SQLite3 to be enabled or disabled by golang build constraints also known as build `tags`. -[Click here for more information about build tags / constraints.](https://golang.org/pkg/go/build/#hdr-Build_Constraints) +Click [here](https://golang.org/pkg/go/build/#hdr-Build_Constraints) for more information about build tags / constraints. ### Usage -If you wish to build this library with additional extensions / features. -Use the following command. +If you wish to build this library with additional extensions / features, use the following command: ```bash go build --tags "" ``` -For available features see the extension list. -When using multiple build tags, all the different tags should be space delimted. +For available features, see the extension list. +When using multiple build tags, all the different tags should be space delimited. Example: @@ -181,9 +180,9 @@ go build --tags "icu json1 fts5 secure_delete" # Compilation -This package requires `CGO_ENABLED=1` ennvironment variable if not set by default, and the presence of the `gcc` compiler. +This package requires the `CGO_ENABLED=1` ennvironment variable if not set by default, and the presence of the `gcc` compiler. -If you need to add additional CFLAGS or LDFLAGS to the build command, and do not want to modify this package. Then this can be achieved by using the `CGO_CFLAGS` and `CGO_LDFLAGS` environment variables. +If you need to add additional CFLAGS or LDFLAGS to the build command, and do not want to modify this package, then this can be achieved by using the `CGO_CFLAGS` and `CGO_LDFLAGS` environment variables. ## Android @@ -198,7 +197,7 @@ For more information see [#201](https://github.com/mattn/go-sqlite3/issues/201) # ARM -To compile for `ARM` use the following environment. +To compile for `ARM` use the following environment: ```bash env CC=arm-linux-gnueabihf-gcc CXX=arm-linux-gnueabihf-g++ \ @@ -234,7 +233,7 @@ Please work only with compiled final binaries. ## Linux -To compile this package on Linux you must install the development tools for your linux distribution. +To compile this package on Linux, you must install the development tools for your linux distribution. To compile under linux use the build tag `linux`. @@ -250,7 +249,7 @@ go build --tags "libsqlite3 linux" ### Alpine -When building in an `alpine` container run the following command before building. +When building in an `alpine` container run the following command before building: ``` apk add --update gcc musl-dev @@ -270,29 +269,29 @@ sudo apt-get install build-essential ## Mac OSX -OSX should have all the tools present to compile this package, if not install XCode this will add all the developers tools. +OSX should have all the tools present to compile this package. If not, install XCode to add all the developers tools. -Required dependency +Required dependency: ```bash brew install sqlite3 ``` -For OSX there is an additional package install which is required if you wish to build the `icu` extension. +For OSX, there is an additional package to install which is required if you wish to build the `icu` extension. -This additional package can be installed with `homebrew`. +This additional package can be installed with `homebrew`: ```bash brew upgrade icu4c ``` -To compile for Mac OSX. +To compile for Mac OSX: ```bash go build --tags "darwin" ``` -If you wish to link directly to libsqlite3 then you can use the `libsqlite3` build tag. +If you wish to link directly to libsqlite3, use the `libsqlite3` build tag: ``` go build --tags "libsqlite3 darwin" @@ -304,14 +303,14 @@ Additional information: ## Windows -To compile this package on Windows OS you must have the `gcc` compiler installed. +To compile this package on Windows, you must have the `gcc` compiler installed. 1) Install a Windows `gcc` toolchain. -2) Add the `bin` folders to the Windows path if the installer did not do this by default. -3) Open a terminal for the TDM-GCC toolchain, can be found in the Windows Start menu. +2) Add the `bin` folder to the Windows path, if the installer did not do this by default. +3) Open a terminal for the TDM-GCC toolchain, which can be found in the Windows Start menu. 4) Navigate to your project folder and run the `go build ...` command for this package. -For example the TDM-GCC Toolchain can be found [here](https://sourceforge.net/projects/tdm-gcc/). +For example the TDM-GCC Toolchain can be found [here](https://jmeubank.github.io/tdm-gcc/). ## Errors @@ -349,28 +348,28 @@ This package supports the SQLite User Authentication module. ## Compile -To use the User authentication module the package has to be compiled with the tag `sqlite_userauth`. See [Features](#features). +To use the User authentication module, the package has to be compiled with the tag `sqlite_userauth`. See [Features](#features). ## Usage ### Create protected database -To create a database protected by user authentication provide the following argument to the connection string `_auth`. +To create a database protected by user authentication, provide the following argument to the connection string `_auth`. This will enable user authentication within the database. This option however requires two additional arguments: - `_auth_user` - `_auth_pass` -When `_auth` is present on the connection string user authentication will be enabled and the provided user will be created +When `_auth` is present in the connection string user authentication will be enabled and the provided user will be created as an `admin` user. After initial creation, the parameter `_auth` has no effect anymore and can be omitted from the connection string. -Example connection string: +Example connection strings: -Create an user authentication database with user `admin` and password `admin`. +Create an user authentication database with user `admin` and password `admin`: `file:test.s3db?_auth&_auth_user=admin&_auth_pass=admin` -Create an user authentication database with user `admin` and password `admin` and use `SHA1` for the password encoding. +Create an user authentication database with user `admin` and password `admin` and use `SHA1` for the password encoding: `file:test.s3db?_auth&_auth_user=admin&_auth_pass=admin&_auth_crypt=sha1` @@ -396,11 +395,11 @@ salt this can be configured with `_auth_salt`. ### Restrictions -Operations on the database regarding to user management can only be preformed by an administrator user. +Operations on the database regarding user management can only be preformed by an administrator user. ### Support -The user authentication supports two kinds of users +The user authentication supports two kinds of users: - administrators - regular users @@ -411,7 +410,7 @@ User management can be done by directly using the `*SQLiteConn` or by SQL. #### SQL -The following sql functions are available for user management. +The following sql functions are available for user management: | Function | Arguments | Description | |----------|-----------|-------------| @@ -420,7 +419,7 @@ The following sql functions are available for user management. | `auth_user_change` | username `string`, password `string`, admin `int` | Function to modify an user. Users can change their own password, but only an administrator can change the administrator flag. | | `authUserDelete` | username `string` | Delete an user from the database. Can only be used by an administrator. The current logged in administrator cannot be deleted. This is to make sure their is always an administrator remaining. | -These functions will return an integer. +These functions will return an integer: - 0 (SQLITE_OK) - 23 (SQLITE_AUTH) Failed to perform due to authentication or insufficient privileges @@ -441,7 +440,7 @@ SELECT user_delete('user'); #### *SQLiteConn -The following functions are available for User authentication from the `*SQLiteConn`. +The following functions are available for User authentication from the `*SQLiteConn`: | Function | Description | |----------|-------------| @@ -452,16 +451,16 @@ The following functions are available for User authentication from the `*SQLiteC ### Attached database -When using attached databases. SQLite will use the authentication from the `main` database for the attached database(s). +When using attached databases, SQLite will use the authentication from the `main` database for the attached database(s). # Extensions -If you want your own extension to be listed here or you want to add a reference to an extension; please submit an Issue for this. +If you want your own extension to be listed here, or you want to add a reference to an extension; please submit an Issue for this. ## Spatialite Spatialite is available as an extension to SQLite, and can be used in combination with this repository. -For an example see [shaxbee/go-spatialite](https://github.com/shaxbee/go-spatialite). +For an example, see [shaxbee/go-spatialite](https://github.com/shaxbee/go-spatialite). ## extension-functions.c from SQLite3 Contrib @@ -471,7 +470,7 @@ extension-functions.c is available as an extension to SQLite, and provides the f - String: replicate, charindex, leftstr, rightstr, ltrim, rtrim, trim, replace, reverse, proper, padl, padr, padc, strfilter. - Aggregate: stdev, variance, mode, median, lower_quartile, upper_quartile -For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/dinedal/go-sqlite3-extension-functions). +For an example, see [dinedal/go-sqlite3-extension-functions](https://github.com/dinedal/go-sqlite3-extension-functions). # FAQ @@ -491,7 +490,7 @@ For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/d - Can I use this in multiple routines concurrently? - Yes for readonly. But, No for writable. See [#50](https://github.com/mattn/go-sqlite3/issues/50), [#51](https://github.com/mattn/go-sqlite3/issues/51), [#209](https://github.com/mattn/go-sqlite3/issues/209), [#274](https://github.com/mattn/go-sqlite3/issues/274). + Yes for readonly. But not for writable. See [#50](https://github.com/mattn/go-sqlite3/issues/50), [#51](https://github.com/mattn/go-sqlite3/issues/51), [#209](https://github.com/mattn/go-sqlite3/issues/209), [#274](https://github.com/mattn/go-sqlite3/issues/274). - Why I'm getting `no such table` error? @@ -505,7 +504,7 @@ For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/d Note that if the last database connection in the pool closes, the in-memory database is deleted. Make sure the [max idle connection limit](https://golang.org/pkg/database/sql/#DB.SetMaxIdleConns) is > 0, and the [connection lifetime](https://golang.org/pkg/database/sql/#DB.SetConnMaxLifetime) is infinite. - For more information see + For more information see: * [#204](https://github.com/mattn/go-sqlite3/issues/204) * [#511](https://github.com/mattn/go-sqlite3/issues/511) * https://www.sqlite.org/sharedcache.html#shared_cache_and_in_memory_databases @@ -515,20 +514,20 @@ For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/d OS X limits OS-wide to not have more than 1000 files open simultaneously by default. - For more information see [#289](https://github.com/mattn/go-sqlite3/issues/289) + For more information, see [#289](https://github.com/mattn/go-sqlite3/issues/289) - Trying to execute a `.` (dot) command throws an error. Error: `Error: near ".": syntax error` - Dot command are part of SQLite3 CLI not of this library. + Dot command are part of SQLite3 CLI, not of this library. You need to implement the feature or call the sqlite3 cli. - More information see [#305](https://github.com/mattn/go-sqlite3/issues/305) + More information see [#305](https://github.com/mattn/go-sqlite3/issues/305). - Error: `database is locked` - When you get a database is locked. Please use the following options. + When you get a database is locked, please use the following options. Add to DSN: `cache=shared` @@ -537,24 +536,24 @@ For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/d db, err := sql.Open("sqlite3", "file:locked.sqlite?cache=shared") ``` - Second please set the database connections of the SQL package to 1. + Next, please set the database connections of the SQL package to 1: ```go db.SetMaxOpenConns(1) ``` - More information see [#209](https://github.com/mattn/go-sqlite3/issues/209) + For more information, see [#209](https://github.com/mattn/go-sqlite3/issues/209). ## Contributors ### Code Contributors -This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)]. +This project exists thanks to all the people who [[contribute](CONTRIBUTING.md)]. ### Financial Contributors -Become a financial contributor and help us sustain our community. [[Contribute](https://opencollective.com/mattn-go-sqlite3/contribute)] +Become a financial contributor and help us sustain our community. [[Contribute here](https://opencollective.com/mattn-go-sqlite3/contribute)]. #### Individuals diff --git a/vendor/github.com/mattn/go-sqlite3/backup.go b/vendor/github.com/mattn/go-sqlite3/backup.go index e222cc8880..ecbb469746 100644 --- a/vendor/github.com/mattn/go-sqlite3/backup.go +++ b/vendor/github.com/mattn/go-sqlite3/backup.go @@ -7,7 +7,7 @@ package sqlite3 /* #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif diff --git a/vendor/github.com/mattn/go-sqlite3/callback.go b/vendor/github.com/mattn/go-sqlite3/callback.go index c3ce75207d..b020fe37c0 100644 --- a/vendor/github.com/mattn/go-sqlite3/callback.go +++ b/vendor/github.com/mattn/go-sqlite3/callback.go @@ -12,7 +12,7 @@ package sqlite3 /* #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif diff --git a/vendor/github.com/mattn/go-sqlite3/error.go b/vendor/github.com/mattn/go-sqlite3/error.go index 696281c733..58ab252e63 100644 --- a/vendor/github.com/mattn/go-sqlite3/error.go +++ b/vendor/github.com/mattn/go-sqlite3/error.go @@ -7,7 +7,7 @@ package sqlite3 /* #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.c b/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.c index c1a4d8f92c..bb9dc50ec7 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.c +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.c @@ -1,7 +1,7 @@ #ifndef USE_LIBSQLITE3 /****************************************************************************** ** This file is an amalgamation of many separate C source files from SQLite -** version 3.34.0. By combining all the individual C code files into this +** version 3.37.0. By combining all the individual C code files into this ** single large file, the entire code can be compiled as a single translation ** unit. This allows many compilers to do optimizations that would not be ** possible if the files were compiled separately. Performance improvements @@ -23,771 +23,6 @@ #ifndef SQLITE_PRIVATE # define SQLITE_PRIVATE static #endif -/************** Begin file ctime.c *******************************************/ -/* -** 2010 February 23 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** -** This file implements routines used to report what compile-time options -** SQLite was built with. -*/ - -#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS /* IMP: R-16824-07538 */ - -/* -** Include the configuration header output by 'configure' if we're using the -** autoconf-based build -*/ -#if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H) -#include "config.h" -#define SQLITECONFIG_H 1 -#endif - -/* These macros are provided to "stringify" the value of the define -** for those options in which the value is meaningful. */ -#define CTIMEOPT_VAL_(opt) #opt -#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) - -/* Like CTIMEOPT_VAL, but especially for SQLITE_DEFAULT_LOOKASIDE. This -** option requires a separate macro because legal values contain a single -** comma. e.g. (-DSQLITE_DEFAULT_LOOKASIDE="100,100") */ -#define CTIMEOPT_VAL2_(opt1,opt2) #opt1 "," #opt2 -#define CTIMEOPT_VAL2(opt) CTIMEOPT_VAL2_(opt) - -/* -** An array of names of all compile-time options. This array should -** be sorted A-Z. -** -** This array looks large, but in a typical installation actually uses -** only a handful of compile-time options, so most times this array is usually -** rather short and uses little memory space. -*/ -static const char * const sqlite3azCompileOpt[] = { - -/* -** BEGIN CODE GENERATED BY tool/mkctime.tcl -*/ -#if SQLITE_32BIT_ROWID - "32BIT_ROWID", -#endif -#if SQLITE_4_BYTE_ALIGNED_MALLOC - "4_BYTE_ALIGNED_MALLOC", -#endif -#if SQLITE_64BIT_STATS - "64BIT_STATS", -#endif -#if SQLITE_ALLOW_COVERING_INDEX_SCAN - "ALLOW_COVERING_INDEX_SCAN", -#endif -#if SQLITE_ALLOW_URI_AUTHORITY - "ALLOW_URI_AUTHORITY", -#endif -#ifdef SQLITE_BITMASK_TYPE - "BITMASK_TYPE=" CTIMEOPT_VAL(SQLITE_BITMASK_TYPE), -#endif -#if SQLITE_BUG_COMPATIBLE_20160819 - "BUG_COMPATIBLE_20160819", -#endif -#if SQLITE_CASE_SENSITIVE_LIKE - "CASE_SENSITIVE_LIKE", -#endif -#if SQLITE_CHECK_PAGES - "CHECK_PAGES", -#endif -#if defined(__clang__) && defined(__clang_major__) - "COMPILER=clang-" CTIMEOPT_VAL(__clang_major__) "." - CTIMEOPT_VAL(__clang_minor__) "." - CTIMEOPT_VAL(__clang_patchlevel__), -#elif defined(_MSC_VER) - "COMPILER=msvc-" CTIMEOPT_VAL(_MSC_VER), -#elif defined(__GNUC__) && defined(__VERSION__) - "COMPILER=gcc-" __VERSION__, -#endif -#if SQLITE_COVERAGE_TEST - "COVERAGE_TEST", -#endif -#if SQLITE_DEBUG - "DEBUG", -#endif -#if SQLITE_DEFAULT_AUTOMATIC_INDEX - "DEFAULT_AUTOMATIC_INDEX", -#endif -#if SQLITE_DEFAULT_AUTOVACUUM - "DEFAULT_AUTOVACUUM", -#endif -#ifdef SQLITE_DEFAULT_CACHE_SIZE - "DEFAULT_CACHE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_CACHE_SIZE), -#endif -#if SQLITE_DEFAULT_CKPTFULLFSYNC - "DEFAULT_CKPTFULLFSYNC", -#endif -#ifdef SQLITE_DEFAULT_FILE_FORMAT - "DEFAULT_FILE_FORMAT=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_FORMAT), -#endif -#ifdef SQLITE_DEFAULT_FILE_PERMISSIONS - "DEFAULT_FILE_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_PERMISSIONS), -#endif -#if SQLITE_DEFAULT_FOREIGN_KEYS - "DEFAULT_FOREIGN_KEYS", -#endif -#ifdef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT - "DEFAULT_JOURNAL_SIZE_LIMIT=" CTIMEOPT_VAL(SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT), -#endif -#ifdef SQLITE_DEFAULT_LOCKING_MODE - "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE), -#endif -#ifdef SQLITE_DEFAULT_LOOKASIDE - "DEFAULT_LOOKASIDE=" CTIMEOPT_VAL2(SQLITE_DEFAULT_LOOKASIDE), -#endif -#if SQLITE_DEFAULT_MEMSTATUS - "DEFAULT_MEMSTATUS", -#endif -#ifdef SQLITE_DEFAULT_MMAP_SIZE - "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE), -#endif -#ifdef SQLITE_DEFAULT_PAGE_SIZE - "DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_PAGE_SIZE), -#endif -#ifdef SQLITE_DEFAULT_PCACHE_INITSZ - "DEFAULT_PCACHE_INITSZ=" CTIMEOPT_VAL(SQLITE_DEFAULT_PCACHE_INITSZ), -#endif -#ifdef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS - "DEFAULT_PROXYDIR_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_PROXYDIR_PERMISSIONS), -#endif -#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS - "DEFAULT_RECURSIVE_TRIGGERS", -#endif -#ifdef SQLITE_DEFAULT_ROWEST - "DEFAULT_ROWEST=" CTIMEOPT_VAL(SQLITE_DEFAULT_ROWEST), -#endif -#ifdef SQLITE_DEFAULT_SECTOR_SIZE - "DEFAULT_SECTOR_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_SECTOR_SIZE), -#endif -#ifdef SQLITE_DEFAULT_SYNCHRONOUS - "DEFAULT_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_SYNCHRONOUS), -#endif -#ifdef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT - "DEFAULT_WAL_AUTOCHECKPOINT=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_AUTOCHECKPOINT), -#endif -#ifdef SQLITE_DEFAULT_WAL_SYNCHRONOUS - "DEFAULT_WAL_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_SYNCHRONOUS), -#endif -#ifdef SQLITE_DEFAULT_WORKER_THREADS - "DEFAULT_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WORKER_THREADS), -#endif -#if SQLITE_DIRECT_OVERFLOW_READ - "DIRECT_OVERFLOW_READ", -#endif -#if SQLITE_DISABLE_DIRSYNC - "DISABLE_DIRSYNC", -#endif -#if SQLITE_DISABLE_FTS3_UNICODE - "DISABLE_FTS3_UNICODE", -#endif -#if SQLITE_DISABLE_FTS4_DEFERRED - "DISABLE_FTS4_DEFERRED", -#endif -#if SQLITE_DISABLE_INTRINSIC - "DISABLE_INTRINSIC", -#endif -#if SQLITE_DISABLE_LFS - "DISABLE_LFS", -#endif -#if SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS - "DISABLE_PAGECACHE_OVERFLOW_STATS", -#endif -#if SQLITE_DISABLE_SKIPAHEAD_DISTINCT - "DISABLE_SKIPAHEAD_DISTINCT", -#endif -#ifdef SQLITE_ENABLE_8_3_NAMES - "ENABLE_8_3_NAMES=" CTIMEOPT_VAL(SQLITE_ENABLE_8_3_NAMES), -#endif -#if SQLITE_ENABLE_API_ARMOR - "ENABLE_API_ARMOR", -#endif -#if SQLITE_ENABLE_ATOMIC_WRITE - "ENABLE_ATOMIC_WRITE", -#endif -#if SQLITE_ENABLE_BATCH_ATOMIC_WRITE - "ENABLE_BATCH_ATOMIC_WRITE", -#endif -#if SQLITE_ENABLE_BYTECODE_VTAB - "ENABLE_BYTECODE_VTAB", -#endif -#if SQLITE_ENABLE_CEROD - "ENABLE_CEROD=" CTIMEOPT_VAL(SQLITE_ENABLE_CEROD), -#endif -#if SQLITE_ENABLE_COLUMN_METADATA - "ENABLE_COLUMN_METADATA", -#endif -#if SQLITE_ENABLE_COLUMN_USED_MASK - "ENABLE_COLUMN_USED_MASK", -#endif -#if SQLITE_ENABLE_COSTMULT - "ENABLE_COSTMULT", -#endif -#if SQLITE_ENABLE_CURSOR_HINTS - "ENABLE_CURSOR_HINTS", -#endif -#if SQLITE_ENABLE_DBSTAT_VTAB - "ENABLE_DBSTAT_VTAB", -#endif -#if SQLITE_ENABLE_EXPENSIVE_ASSERT - "ENABLE_EXPENSIVE_ASSERT", -#endif -#if SQLITE_ENABLE_FTS1 - "ENABLE_FTS1", -#endif -#if SQLITE_ENABLE_FTS2 - "ENABLE_FTS2", -#endif -#if SQLITE_ENABLE_FTS3 - "ENABLE_FTS3", -#endif -#if SQLITE_ENABLE_FTS3_PARENTHESIS - "ENABLE_FTS3_PARENTHESIS", -#endif -#if SQLITE_ENABLE_FTS3_TOKENIZER - "ENABLE_FTS3_TOKENIZER", -#endif -#if SQLITE_ENABLE_FTS4 - "ENABLE_FTS4", -#endif -#if SQLITE_ENABLE_FTS5 - "ENABLE_FTS5", -#endif -#if SQLITE_ENABLE_GEOPOLY - "ENABLE_GEOPOLY", -#endif -#if SQLITE_ENABLE_HIDDEN_COLUMNS - "ENABLE_HIDDEN_COLUMNS", -#endif -#if SQLITE_ENABLE_ICU - "ENABLE_ICU", -#endif -#if SQLITE_ENABLE_IOTRACE - "ENABLE_IOTRACE", -#endif -#if SQLITE_ENABLE_JSON1 - "ENABLE_JSON1", -#endif -#if SQLITE_ENABLE_LOAD_EXTENSION - "ENABLE_LOAD_EXTENSION", -#endif -#ifdef SQLITE_ENABLE_LOCKING_STYLE - "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE), -#endif -#if SQLITE_ENABLE_MEMORY_MANAGEMENT - "ENABLE_MEMORY_MANAGEMENT", -#endif -#if SQLITE_ENABLE_MEMSYS3 - "ENABLE_MEMSYS3", -#endif -#if SQLITE_ENABLE_MEMSYS5 - "ENABLE_MEMSYS5", -#endif -#if SQLITE_ENABLE_MULTIPLEX - "ENABLE_MULTIPLEX", -#endif -#if SQLITE_ENABLE_NORMALIZE - "ENABLE_NORMALIZE", -#endif -#if SQLITE_ENABLE_NULL_TRIM - "ENABLE_NULL_TRIM", -#endif -#if SQLITE_ENABLE_OVERSIZE_CELL_CHECK - "ENABLE_OVERSIZE_CELL_CHECK", -#endif -#if SQLITE_ENABLE_PREUPDATE_HOOK - "ENABLE_PREUPDATE_HOOK", -#endif -#if SQLITE_ENABLE_QPSG - "ENABLE_QPSG", -#endif -#if SQLITE_ENABLE_RBU - "ENABLE_RBU", -#endif -#if SQLITE_ENABLE_RTREE - "ENABLE_RTREE", -#endif -#if SQLITE_ENABLE_SELECTTRACE - "ENABLE_SELECTTRACE", -#endif -#if SQLITE_ENABLE_SESSION - "ENABLE_SESSION", -#endif -#if SQLITE_ENABLE_SNAPSHOT - "ENABLE_SNAPSHOT", -#endif -#if SQLITE_ENABLE_SORTER_REFERENCES - "ENABLE_SORTER_REFERENCES", -#endif -#if SQLITE_ENABLE_SQLLOG - "ENABLE_SQLLOG", -#endif -#if defined(SQLITE_ENABLE_STAT4) - "ENABLE_STAT4", -#endif -#if SQLITE_ENABLE_STMTVTAB - "ENABLE_STMTVTAB", -#endif -#if SQLITE_ENABLE_STMT_SCANSTATUS - "ENABLE_STMT_SCANSTATUS", -#endif -#if SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION - "ENABLE_UNKNOWN_SQL_FUNCTION", -#endif -#if SQLITE_ENABLE_UNLOCK_NOTIFY - "ENABLE_UNLOCK_NOTIFY", -#endif -#if SQLITE_ENABLE_UPDATE_DELETE_LIMIT - "ENABLE_UPDATE_DELETE_LIMIT", -#endif -#if SQLITE_ENABLE_URI_00_ERROR - "ENABLE_URI_00_ERROR", -#endif -#if SQLITE_ENABLE_VFSTRACE - "ENABLE_VFSTRACE", -#endif -#if SQLITE_ENABLE_WHERETRACE - "ENABLE_WHERETRACE", -#endif -#if SQLITE_ENABLE_ZIPVFS - "ENABLE_ZIPVFS", -#endif -#if SQLITE_EXPLAIN_ESTIMATED_ROWS - "EXPLAIN_ESTIMATED_ROWS", -#endif -#if SQLITE_EXTRA_IFNULLROW - "EXTRA_IFNULLROW", -#endif -#ifdef SQLITE_EXTRA_INIT - "EXTRA_INIT=" CTIMEOPT_VAL(SQLITE_EXTRA_INIT), -#endif -#ifdef SQLITE_EXTRA_SHUTDOWN - "EXTRA_SHUTDOWN=" CTIMEOPT_VAL(SQLITE_EXTRA_SHUTDOWN), -#endif -#ifdef SQLITE_FTS3_MAX_EXPR_DEPTH - "FTS3_MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_FTS3_MAX_EXPR_DEPTH), -#endif -#if SQLITE_FTS5_ENABLE_TEST_MI - "FTS5_ENABLE_TEST_MI", -#endif -#if SQLITE_FTS5_NO_WITHOUT_ROWID - "FTS5_NO_WITHOUT_ROWID", -#endif -#if HAVE_ISNAN || SQLITE_HAVE_ISNAN - "HAVE_ISNAN", -#endif -#if SQLITE_HOMEGROWN_RECURSIVE_MUTEX - "HOMEGROWN_RECURSIVE_MUTEX", -#endif -#if SQLITE_IGNORE_AFP_LOCK_ERRORS - "IGNORE_AFP_LOCK_ERRORS", -#endif -#if SQLITE_IGNORE_FLOCK_LOCK_ERRORS - "IGNORE_FLOCK_LOCK_ERRORS", -#endif -#if SQLITE_INLINE_MEMCPY - "INLINE_MEMCPY", -#endif -#if SQLITE_INT64_TYPE - "INT64_TYPE", -#endif -#ifdef SQLITE_INTEGRITY_CHECK_ERROR_MAX - "INTEGRITY_CHECK_ERROR_MAX=" CTIMEOPT_VAL(SQLITE_INTEGRITY_CHECK_ERROR_MAX), -#endif -#if SQLITE_LIKE_DOESNT_MATCH_BLOBS - "LIKE_DOESNT_MATCH_BLOBS", -#endif -#if SQLITE_LOCK_TRACE - "LOCK_TRACE", -#endif -#if SQLITE_LOG_CACHE_SPILL - "LOG_CACHE_SPILL", -#endif -#ifdef SQLITE_MALLOC_SOFT_LIMIT - "MALLOC_SOFT_LIMIT=" CTIMEOPT_VAL(SQLITE_MALLOC_SOFT_LIMIT), -#endif -#ifdef SQLITE_MAX_ATTACHED - "MAX_ATTACHED=" CTIMEOPT_VAL(SQLITE_MAX_ATTACHED), -#endif -#ifdef SQLITE_MAX_COLUMN - "MAX_COLUMN=" CTIMEOPT_VAL(SQLITE_MAX_COLUMN), -#endif -#ifdef SQLITE_MAX_COMPOUND_SELECT - "MAX_COMPOUND_SELECT=" CTIMEOPT_VAL(SQLITE_MAX_COMPOUND_SELECT), -#endif -#ifdef SQLITE_MAX_DEFAULT_PAGE_SIZE - "MAX_DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_DEFAULT_PAGE_SIZE), -#endif -#ifdef SQLITE_MAX_EXPR_DEPTH - "MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_EXPR_DEPTH), -#endif -#ifdef SQLITE_MAX_FUNCTION_ARG - "MAX_FUNCTION_ARG=" CTIMEOPT_VAL(SQLITE_MAX_FUNCTION_ARG), -#endif -#ifdef SQLITE_MAX_LENGTH - "MAX_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LENGTH), -#endif -#ifdef SQLITE_MAX_LIKE_PATTERN_LENGTH - "MAX_LIKE_PATTERN_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LIKE_PATTERN_LENGTH), -#endif -#ifdef SQLITE_MAX_MEMORY - "MAX_MEMORY=" CTIMEOPT_VAL(SQLITE_MAX_MEMORY), -#endif -#ifdef SQLITE_MAX_MMAP_SIZE - "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE), -#endif -#ifdef SQLITE_MAX_MMAP_SIZE_ - "MAX_MMAP_SIZE_=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE_), -#endif -#ifdef SQLITE_MAX_PAGE_COUNT - "MAX_PAGE_COUNT=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_COUNT), -#endif -#ifdef SQLITE_MAX_PAGE_SIZE - "MAX_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_SIZE), -#endif -#ifdef SQLITE_MAX_SCHEMA_RETRY - "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY), -#endif -#ifdef SQLITE_MAX_SQL_LENGTH - "MAX_SQL_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_SQL_LENGTH), -#endif -#ifdef SQLITE_MAX_TRIGGER_DEPTH - "MAX_TRIGGER_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_TRIGGER_DEPTH), -#endif -#ifdef SQLITE_MAX_VARIABLE_NUMBER - "MAX_VARIABLE_NUMBER=" CTIMEOPT_VAL(SQLITE_MAX_VARIABLE_NUMBER), -#endif -#ifdef SQLITE_MAX_VDBE_OP - "MAX_VDBE_OP=" CTIMEOPT_VAL(SQLITE_MAX_VDBE_OP), -#endif -#ifdef SQLITE_MAX_WORKER_THREADS - "MAX_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_MAX_WORKER_THREADS), -#endif -#if SQLITE_MEMDEBUG - "MEMDEBUG", -#endif -#if SQLITE_MIXED_ENDIAN_64BIT_FLOAT - "MIXED_ENDIAN_64BIT_FLOAT", -#endif -#if SQLITE_MMAP_READWRITE - "MMAP_READWRITE", -#endif -#if SQLITE_MUTEX_NOOP - "MUTEX_NOOP", -#endif -#if SQLITE_MUTEX_NREF - "MUTEX_NREF", -#endif -#if SQLITE_MUTEX_OMIT - "MUTEX_OMIT", -#endif -#if SQLITE_MUTEX_PTHREADS - "MUTEX_PTHREADS", -#endif -#if SQLITE_MUTEX_W32 - "MUTEX_W32", -#endif -#if SQLITE_NEED_ERR_NAME - "NEED_ERR_NAME", -#endif -#if SQLITE_NOINLINE - "NOINLINE", -#endif -#if SQLITE_NO_SYNC - "NO_SYNC", -#endif -#if SQLITE_OMIT_ALTERTABLE - "OMIT_ALTERTABLE", -#endif -#if SQLITE_OMIT_ANALYZE - "OMIT_ANALYZE", -#endif -#if SQLITE_OMIT_ATTACH - "OMIT_ATTACH", -#endif -#if SQLITE_OMIT_AUTHORIZATION - "OMIT_AUTHORIZATION", -#endif -#if SQLITE_OMIT_AUTOINCREMENT - "OMIT_AUTOINCREMENT", -#endif -#if SQLITE_OMIT_AUTOINIT - "OMIT_AUTOINIT", -#endif -#if SQLITE_OMIT_AUTOMATIC_INDEX - "OMIT_AUTOMATIC_INDEX", -#endif -#if SQLITE_OMIT_AUTORESET - "OMIT_AUTORESET", -#endif -#if SQLITE_OMIT_AUTOVACUUM - "OMIT_AUTOVACUUM", -#endif -#if SQLITE_OMIT_BETWEEN_OPTIMIZATION - "OMIT_BETWEEN_OPTIMIZATION", -#endif -#if SQLITE_OMIT_BLOB_LITERAL - "OMIT_BLOB_LITERAL", -#endif -#if SQLITE_OMIT_CAST - "OMIT_CAST", -#endif -#if SQLITE_OMIT_CHECK - "OMIT_CHECK", -#endif -#if SQLITE_OMIT_COMPLETE - "OMIT_COMPLETE", -#endif -#if SQLITE_OMIT_COMPOUND_SELECT - "OMIT_COMPOUND_SELECT", -#endif -#if SQLITE_OMIT_CONFLICT_CLAUSE - "OMIT_CONFLICT_CLAUSE", -#endif -#if SQLITE_OMIT_CTE - "OMIT_CTE", -#endif -#if SQLITE_OMIT_DATETIME_FUNCS - "OMIT_DATETIME_FUNCS", -#endif -#if SQLITE_OMIT_DECLTYPE - "OMIT_DECLTYPE", -#endif -#if SQLITE_OMIT_DEPRECATED - "OMIT_DEPRECATED", -#endif -#if SQLITE_OMIT_DISKIO - "OMIT_DISKIO", -#endif -#if SQLITE_OMIT_EXPLAIN - "OMIT_EXPLAIN", -#endif -#if SQLITE_OMIT_FLAG_PRAGMAS - "OMIT_FLAG_PRAGMAS", -#endif -#if SQLITE_OMIT_FLOATING_POINT - "OMIT_FLOATING_POINT", -#endif -#if SQLITE_OMIT_FOREIGN_KEY - "OMIT_FOREIGN_KEY", -#endif -#if SQLITE_OMIT_GET_TABLE - "OMIT_GET_TABLE", -#endif -#if SQLITE_OMIT_HEX_INTEGER - "OMIT_HEX_INTEGER", -#endif -#if SQLITE_OMIT_INCRBLOB - "OMIT_INCRBLOB", -#endif -#if SQLITE_OMIT_INTEGRITY_CHECK - "OMIT_INTEGRITY_CHECK", -#endif -#if SQLITE_OMIT_LIKE_OPTIMIZATION - "OMIT_LIKE_OPTIMIZATION", -#endif -#if SQLITE_OMIT_LOAD_EXTENSION - "OMIT_LOAD_EXTENSION", -#endif -#if SQLITE_OMIT_LOCALTIME - "OMIT_LOCALTIME", -#endif -#if SQLITE_OMIT_LOOKASIDE - "OMIT_LOOKASIDE", -#endif -#if SQLITE_OMIT_MEMORYDB - "OMIT_MEMORYDB", -#endif -#if SQLITE_OMIT_OR_OPTIMIZATION - "OMIT_OR_OPTIMIZATION", -#endif -#if SQLITE_OMIT_PAGER_PRAGMAS - "OMIT_PAGER_PRAGMAS", -#endif -#if SQLITE_OMIT_PARSER_TRACE - "OMIT_PARSER_TRACE", -#endif -#if SQLITE_OMIT_POPEN - "OMIT_POPEN", -#endif -#if SQLITE_OMIT_PRAGMA - "OMIT_PRAGMA", -#endif -#if SQLITE_OMIT_PROGRESS_CALLBACK - "OMIT_PROGRESS_CALLBACK", -#endif -#if SQLITE_OMIT_QUICKBALANCE - "OMIT_QUICKBALANCE", -#endif -#if SQLITE_OMIT_REINDEX - "OMIT_REINDEX", -#endif -#if SQLITE_OMIT_SCHEMA_PRAGMAS - "OMIT_SCHEMA_PRAGMAS", -#endif -#if SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS - "OMIT_SCHEMA_VERSION_PRAGMAS", -#endif -#if SQLITE_OMIT_SHARED_CACHE - "OMIT_SHARED_CACHE", -#endif -#if SQLITE_OMIT_SHUTDOWN_DIRECTORIES - "OMIT_SHUTDOWN_DIRECTORIES", -#endif -#if SQLITE_OMIT_SUBQUERY - "OMIT_SUBQUERY", -#endif -#if SQLITE_OMIT_TCL_VARIABLE - "OMIT_TCL_VARIABLE", -#endif -#if SQLITE_OMIT_TEMPDB - "OMIT_TEMPDB", -#endif -#if SQLITE_OMIT_TEST_CONTROL - "OMIT_TEST_CONTROL", -#endif -#if SQLITE_OMIT_TRACE - "OMIT_TRACE", -#endif -#if SQLITE_OMIT_TRIGGER - "OMIT_TRIGGER", -#endif -#if SQLITE_OMIT_TRUNCATE_OPTIMIZATION - "OMIT_TRUNCATE_OPTIMIZATION", -#endif -#if SQLITE_OMIT_UTF16 - "OMIT_UTF16", -#endif -#if SQLITE_OMIT_VACUUM - "OMIT_VACUUM", -#endif -#if SQLITE_OMIT_VIEW - "OMIT_VIEW", -#endif -#if SQLITE_OMIT_VIRTUALTABLE - "OMIT_VIRTUALTABLE", -#endif -#if SQLITE_OMIT_WAL - "OMIT_WAL", -#endif -#if SQLITE_OMIT_WSD - "OMIT_WSD", -#endif -#if SQLITE_OMIT_XFER_OPT - "OMIT_XFER_OPT", -#endif -#if SQLITE_PCACHE_SEPARATE_HEADER - "PCACHE_SEPARATE_HEADER", -#endif -#if SQLITE_PERFORMANCE_TRACE - "PERFORMANCE_TRACE", -#endif -#if SQLITE_POWERSAFE_OVERWRITE - "POWERSAFE_OVERWRITE", -#endif -#if SQLITE_PREFER_PROXY_LOCKING - "PREFER_PROXY_LOCKING", -#endif -#if SQLITE_PROXY_DEBUG - "PROXY_DEBUG", -#endif -#if SQLITE_REVERSE_UNORDERED_SELECTS - "REVERSE_UNORDERED_SELECTS", -#endif -#if SQLITE_RTREE_INT_ONLY - "RTREE_INT_ONLY", -#endif -#if SQLITE_SECURE_DELETE - "SECURE_DELETE", -#endif -#if SQLITE_SMALL_STACK - "SMALL_STACK", -#endif -#ifdef SQLITE_SORTER_PMASZ - "SORTER_PMASZ=" CTIMEOPT_VAL(SQLITE_SORTER_PMASZ), -#endif -#if SQLITE_SOUNDEX - "SOUNDEX", -#endif -#ifdef SQLITE_STAT4_SAMPLES - "STAT4_SAMPLES=" CTIMEOPT_VAL(SQLITE_STAT4_SAMPLES), -#endif -#ifdef SQLITE_STMTJRNL_SPILL - "STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL), -#endif -#if SQLITE_SUBSTR_COMPATIBILITY - "SUBSTR_COMPATIBILITY", -#endif -#if SQLITE_SYSTEM_MALLOC - "SYSTEM_MALLOC", -#endif -#if SQLITE_TCL - "TCL", -#endif -#ifdef SQLITE_TEMP_STORE - "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE), -#endif -#if SQLITE_TEST - "TEST", -#endif -#if defined(SQLITE_THREADSAFE) - "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE), -#elif defined(THREADSAFE) - "THREADSAFE=" CTIMEOPT_VAL(THREADSAFE), -#else - "THREADSAFE=1", -#endif -#if SQLITE_UNLINK_AFTER_CLOSE - "UNLINK_AFTER_CLOSE", -#endif -#if SQLITE_UNTESTABLE - "UNTESTABLE", -#endif -#if SQLITE_USER_AUTHENTICATION - "USER_AUTHENTICATION", -#endif -#if SQLITE_USE_ALLOCA - "USE_ALLOCA", -#endif -#if SQLITE_USE_FCNTL_TRACE - "USE_FCNTL_TRACE", -#endif -#if SQLITE_USE_URI - "USE_URI", -#endif -#if SQLITE_VDBE_COVERAGE - "VDBE_COVERAGE", -#endif -#if SQLITE_WIN32_MALLOC - "WIN32_MALLOC", -#endif -#if SQLITE_ZERO_MALLOC - "ZERO_MALLOC", -#endif -/* -** END CODE GENERATED BY tool/mkctime.tcl -*/ -}; - -SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt){ - *pnOpt = sizeof(sqlite3azCompileOpt) / sizeof(sqlite3azCompileOpt[0]); - return (const char**)sqlite3azCompileOpt; -} - -#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ - -/************** End of ctime.c ***********************************************/ /************** Begin file sqliteInt.h ***************************************/ /* ** 2001 September 15 @@ -991,6 +226,18 @@ SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt){ # define MSVC_VERSION 0 #endif +/* +** Some C99 functions in "math.h" are only present for MSVC when its version +** is associated with Visual Studio 2013 or higher. +*/ +#ifndef SQLITE_HAVE_C99_MATH_FUNCS +# if MSVC_VERSION==0 || MSVC_VERSION>=1800 +# define SQLITE_HAVE_C99_MATH_FUNCS (1) +# else +# define SQLITE_HAVE_C99_MATH_FUNCS (0) +# endif +#endif + /* Needed for various definitions... */ #if defined(__GNUC__) && !defined(_GNU_SOURCE) # define _GNU_SOURCE @@ -1041,6 +288,17 @@ SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt){ # define _USE_32BIT_TIME_T #endif +/* Optionally #include a user-defined header, whereby compilation options +** may be set prior to where they take effect, but after platform setup. +** If SQLITE_CUSTOM_INCLUDE=? is defined, its value names the #include +** file. +*/ +#ifdef SQLITE_CUSTOM_INCLUDE +# define INC_STRINGIFY_(f) #f +# define INC_STRINGIFY(f) INC_STRINGIFY_(f) +# include INC_STRINGIFY(SQLITE_CUSTOM_INCLUDE) +#endif + /* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear ** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for ** MinGW. @@ -1092,7 +350,30 @@ extern "C" { /* -** Provide the ability to override linkage features of the interface. +** Facilitate override of interface linkage and calling conventions. +** Be aware that these macros may not be used within this particular +** translation of the amalgamation and its associated header file. +** +** The SQLITE_EXTERN and SQLITE_API macros are used to instruct the +** compiler that the target identifier should have external linkage. +** +** The SQLITE_CDECL macro is used to set the calling convention for +** public functions that accept a variable number of arguments. +** +** The SQLITE_APICALL macro is used to set the calling convention for +** public functions that accept a fixed number of arguments. +** +** The SQLITE_STDCALL macro is no longer used and is now deprecated. +** +** The SQLITE_CALLBACK macro is used to set the calling convention for +** function pointers. +** +** The SQLITE_SYSAPI macro is used to set the calling convention for +** functions provided by the operating system. +** +** Currently, the SQLITE_CDECL, SQLITE_APICALL, SQLITE_CALLBACK, and +** SQLITE_SYSAPI macros are used only when building for environments +** that require non-default calling conventions. */ #ifndef SQLITE_EXTERN # define SQLITE_EXTERN extern @@ -1172,9 +453,9 @@ extern "C" { ** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite_version()] and [sqlite_source_id()]. */ -#define SQLITE_VERSION "3.34.0" -#define SQLITE_VERSION_NUMBER 3034000 -#define SQLITE_SOURCE_ID "2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089fed5b" +#define SQLITE_VERSION "3.37.0" +#define SQLITE_VERSION_NUMBER 3037000 +#define SQLITE_SOURCE_ID "2021-11-27 14:13:22 bd41822c7424d393a30e92ff6cb254d25c26769889c1499a18a0b9339f5d6c8a" /* ** CAPI3REF: Run-Time Library Version Numbers @@ -1586,6 +867,7 @@ SQLITE_API int sqlite3_exec( #define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) #define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8)) #define SQLITE_CONSTRAINT_PINNED (SQLITE_CONSTRAINT |(11<<8)) +#define SQLITE_CONSTRAINT_DATATYPE (SQLITE_CONSTRAINT |(12<<8)) #define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8)) #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8)) #define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8)) @@ -1599,6 +881,19 @@ SQLITE_API int sqlite3_exec( ** These bit values are intended for use in the ** 3rd parameter to the [sqlite3_open_v2()] interface and ** in the 4th parameter to the [sqlite3_vfs.xOpen] method. +** +** Only those flags marked as "Ok for sqlite3_open_v2()" may be +** used as the third argument to the [sqlite3_open_v2()] interface. +** The other flags have historically been ignored by sqlite3_open_v2(), +** though future versions of SQLite might change so that an error is +** raised if any of the disallowed bits are passed into sqlite3_open_v2(). +** Applications should not depend on the historical behavior. +** +** Note in particular that passing the SQLITE_OPEN_EXCLUSIVE flag into +** [sqlite3_open_v2()] does *not* cause the underlying database file +** to be opened using O_EXCL. Passing SQLITE_OPEN_EXCLUSIVE into +** [sqlite3_open_v2()] has historically be a no-op and might become an +** error in future versions of SQLite. */ #define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ #define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ @@ -1621,6 +916,7 @@ SQLITE_API int sqlite3_exec( #define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ #define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ #define SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_EXRESCODE 0x02000000 /* Extended result codes */ /* Reserved: 0x00F00000 */ /* Legacy compatibility: */ @@ -2177,6 +1473,23 @@ struct sqlite3_io_methods { ** file to the database file, but before the *-shm file is updated to ** record the fact that the pages have been checkpointed. ** +** +**
  • [[SQLITE_FCNTL_EXTERNAL_READER]] +** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect +** whether or not there is a database client in another process with a wal-mode +** transaction open on the database or not. It is only available on unix.The +** (void*) argument passed with this file-control should be a pointer to a +** value of type (int). The integer value is set to 1 if the database is a wal +** mode database and there exists at least one client in another process that +** currently has an SQL transaction open on the database. It is set to 0 if +** the database is not a wal-mode db, or if there is no such connection in any +** other process. This opcode cannot be used to detect transactions opened +** by clients within the current process, only within other processes. +** +** +**
  • [[SQLITE_FCNTL_CKSM_FILE]] +** Used by the cksmvfs VFS module only. +** */ #define SQLITE_FCNTL_LOCKSTATE 1 #define SQLITE_FCNTL_GET_LOCKPROXYFILE 2 @@ -2216,6 +1529,8 @@ struct sqlite3_io_methods { #define SQLITE_FCNTL_CKPT_DONE 37 #define SQLITE_FCNTL_RESERVE_BYTES 38 #define SQLITE_FCNTL_CKPT_START 39 +#define SQLITE_FCNTL_EXTERNAL_READER 40 +#define SQLITE_FCNTL_CKSM_FILE 41 /* deprecated names */ #define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE @@ -3164,7 +2479,13 @@ struct sqlite3_mem_methods { ** The second parameter is a pointer to an integer into which ** is written 0 or 1 to indicate whether triggers are disabled or enabled ** following this call. The second parameter may be a NULL pointer, in -** which case the trigger setting is not reported back. +** which case the trigger setting is not reported back. +** +**

    Originally this option disabled all triggers. ^(However, since +** SQLite version 3.35.0, TEMP triggers are still allowed even if +** this option is off. So, in other words, this option now only disables +** triggers in the main database schema or in the schemas of ATTACH-ed +** databases.)^ ** ** [[SQLITE_DBCONFIG_ENABLE_VIEW]] **

    SQLITE_DBCONFIG_ENABLE_VIEW
    @@ -3175,7 +2496,13 @@ struct sqlite3_mem_methods { ** The second parameter is a pointer to an integer into which ** is written 0 or 1 to indicate whether views are disabled or enabled ** following this call. The second parameter may be a NULL pointer, in -** which case the view setting is not reported back. +** which case the view setting is not reported back. +** +**

    Originally this option disabled all views. ^(However, since +** SQLite version 3.35.0, TEMP views are still allowed even if +** this option is off. So, in other words, this option now only disables +** views in the main database schema or in the schemas of ATTACH-ed +** databases.)^ ** ** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]] **

    SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER
    @@ -3482,11 +2809,14 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64); ** CAPI3REF: Count The Number Of Rows Modified ** METHOD: sqlite3 ** -** ^This function returns the number of rows modified, inserted or +** ^These functions return the number of rows modified, inserted or ** deleted by the most recently completed INSERT, UPDATE or DELETE ** statement on the database connection specified by the only parameter. -** ^Executing any other type of SQL statement does not modify the value -** returned by this function. +** The two functions are identical except for the type of the return value +** and that if the number of rows modified by the most recent INSERT, UPDATE +** or DELETE is greater than the maximum value supported by type "int", then +** the return value of sqlite3_changes() is undefined. ^Executing any other +** type of SQL statement does not modify the value returned by these functions. ** ** ^Only changes made directly by the INSERT, UPDATE or DELETE statement are ** considered - auxiliary changes caused by [CREATE TRIGGER | triggers], @@ -3535,16 +2865,21 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64); ** */ SQLITE_API int sqlite3_changes(sqlite3*); +SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*); /* ** CAPI3REF: Total Number Of Rows Modified ** METHOD: sqlite3 ** -** ^This function returns the total number of rows inserted, modified or +** ^These functions return the total number of rows inserted, modified or ** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed ** since the database connection was opened, including those executed as -** part of trigger programs. ^Executing any other type of SQL statement -** does not affect the value returned by sqlite3_total_changes(). +** part of trigger programs. The two functions are identical except for the +** type of the return value and that if the number of rows modified by the +** connection exceeds the maximum value supported by type "int", then +** the return value of sqlite3_total_changes() is undefined. ^Executing +** any other type of SQL statement does not affect the value returned by +** sqlite3_total_changes(). ** ** ^Changes made as part of [foreign key actions] are included in the ** count, but those made as part of REPLACE constraint resolution are @@ -3572,6 +2907,7 @@ SQLITE_API int sqlite3_changes(sqlite3*); ** */ SQLITE_API int sqlite3_total_changes(sqlite3*); +SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*); /* ** CAPI3REF: Interrupt A Long-Running Query @@ -4401,6 +3737,14 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); ** the default shared cache setting provided by ** [sqlite3_enable_shared_cache()].)^ ** +** [[OPEN_EXRESCODE]] ^(
    [SQLITE_OPEN_EXRESCODE]
    +**
    The database connection comes up in "extended result code mode". +** In other words, the database behaves has if +** [sqlite3_extended_result_codes(db,1)] where called on the database +** connection as soon as the connection is created. In addition to setting +** the extended result code mode, this flag also causes [sqlite3_open_v2()] +** to return an extended result code.
    +** ** [[OPEN_NOFOLLOW]] ^(
    [SQLITE_OPEN_NOFOLLOW]
    **
    The database filename is not allowed to be a symbolic link
    ** )^ @@ -4408,7 +3752,15 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); ** If the 3rd parameter to sqlite3_open_v2() is not one of the ** required combinations shown above optionally combined with other ** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits] -** then the behavior is undefined. +** then the behavior is undefined. Historic versions of SQLite +** have silently ignored surplus bits in the flags parameter to +** sqlite3_open_v2(), however that behavior might not be carried through +** into future versions of SQLite and so applications should not rely +** upon it. Note in particular that the SQLITE_OPEN_EXCLUSIVE flag is a no-op +** for sqlite3_open_v2(). The SQLITE_OPEN_EXCLUSIVE does *not* cause +** the open to fail if the database already exists. The SQLITE_OPEN_EXCLUSIVE +** flag is intended for use by the [sqlite3_vfs|VFS interface] only, and not +** by sqlite3_open_v2(). ** ** ^The fourth parameter to sqlite3_open_v2() is the name of the ** [sqlite3_vfs] object that defines the operating system interface that @@ -4548,6 +3900,7 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); ** that uses dot-files in place of posix advisory locking. ** file:data.db?mode=readonly ** An error. "readonly" is not a valid option for the "mode" parameter. +** Use "ro" instead: "file:data.db?mode=ro". ** ** ** ^URI hexadecimal escape sequences (%HH) are supported within the path and @@ -4746,7 +4099,7 @@ SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*); ** If the Y parameter to sqlite3_free_filename(Y) is anything other ** than a NULL pointer or a pointer previously acquired from ** sqlite3_create_filename(), then bad things such as heap -** corruption or segfaults may occur. The value Y should be +** corruption or segfaults may occur. The value Y should not be ** used again after sqlite3_free_filename(Y) has been called. This means ** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y, ** then the corresponding [sqlite3_module.xClose() method should also be @@ -5175,12 +4528,17 @@ SQLITE_API int sqlite3_prepare16_v3( ** are managed by SQLite and are automatically freed when the prepared ** statement is finalized. ** ^The string returned by sqlite3_expanded_sql(P), on the other hand, -** is obtained from [sqlite3_malloc()] and must be free by the application +** is obtained from [sqlite3_malloc()] and must be freed by the application ** by passing it to [sqlite3_free()]. +** +** ^The sqlite3_normalized_sql() interface is only available if +** the [SQLITE_ENABLE_NORMALIZE] compile-time option is defined. */ SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt); +#ifdef SQLITE_ENABLE_NORMALIZE SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); +#endif /* ** CAPI3REF: Determine If An SQL Statement Writes The Database @@ -5215,6 +4573,15 @@ SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); ** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and ** [BEGIN|BEGIN EXCLUSIVE] commands do touch the database and so ** sqlite3_stmt_readonly() returns false for those commands. +** +** ^This routine returns false if there is any possibility that the +** statement might change the database file. ^A false return does +** not guarantee that the statement will change the database file. +** ^For example, an UPDATE statement might have a WHERE clause that +** makes it a no-op, but the sqlite3_stmt_readonly() result would still +** be false. ^Similarly, a CREATE TABLE IF NOT EXISTS statement is a +** read-only no-op if the table already exists, but +** sqlite3_stmt_readonly() still returns false for such a statement. */ SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt); @@ -5384,18 +4751,22 @@ typedef struct sqlite3_context sqlite3_context; ** contain embedded NULs. The result of expressions involving strings ** with embedded NULs is undefined. ** -** ^The fifth argument to the BLOB and string binding interfaces -** is a destructor used to dispose of the BLOB or -** string after SQLite has finished with it. ^The destructor is called -** to dispose of the BLOB or string even if the call to the bind API fails, -** except the destructor is not called if the third parameter is a NULL -** pointer or the fourth parameter is negative. -** ^If the fifth argument is -** the special value [SQLITE_STATIC], then SQLite assumes that the -** information is in static, unmanaged space and does not need to be freed. -** ^If the fifth argument has the value [SQLITE_TRANSIENT], then -** SQLite makes its own private copy of the data immediately, before -** the sqlite3_bind_*() routine returns. +** ^The fifth argument to the BLOB and string binding interfaces controls +** or indicates the lifetime of the object referenced by the third parameter. +** These three options exist: +** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished +** with it may be passed. ^It is called to dispose of the BLOB or string even +** if the call to the bind API fails, except the destructor is not called if +** the third parameter is a NULL pointer or the fourth parameter is negative. +** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that +** the application remains responsible for disposing of the object. ^In this +** case, the object and the provided pointer to it must remain valid until +** either the prepared statement is finalized or the same SQL parameter is +** bound to something else, whichever occurs sooner. +** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the +** object is to be copied prior to the return from sqlite3_bind_*(). ^The +** object and pointer to it must remain valid until then. ^SQLite will then +** manage the lifetime of its private copy. ** ** ^The sixth argument to sqlite3_bind_text64() must be one of ** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE] @@ -6137,7 +5508,6 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); ** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions, ** index expressions, or the WHERE clause of partial indexes. ** -** ** For best security, the [SQLITE_DIRECTONLY] flag is recommended for ** all application-defined SQL functions that do not need to be ** used inside of triggers, view, CHECK constraints, or other elements of @@ -6147,7 +5517,6 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); ** a database file to include invocations of the function with parameters ** chosen by the attacker, which the application will then execute when ** the database file is opened and read. -** ** ** ^(The fifth parameter is an arbitrary pointer. The implementation of the ** function can gain access to this pointer using [sqlite3_user_data()].)^ @@ -7353,6 +6722,72 @@ SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); +/* +** CAPI3REF: Autovacuum Compaction Amount Callback +** METHOD: sqlite3 +** +** ^The sqlite3_autovacuum_pages(D,C,P,X) interface registers a callback +** function C that is invoked prior to each autovacuum of the database +** file. ^The callback is passed a copy of the generic data pointer (P), +** the schema-name of the attached database that is being autovacuumed, +** the the size of the database file in pages, the number of free pages, +** and the number of bytes per page, respectively. The callback should +** return the number of free pages that should be removed by the +** autovacuum. ^If the callback returns zero, then no autovacuum happens. +** ^If the value returned is greater than or equal to the number of +** free pages, then a complete autovacuum happens. +** +**

    ^If there are multiple ATTACH-ed database files that are being +** modified as part of a transaction commit, then the autovacuum pages +** callback is invoked separately for each file. +** +**

    The callback is not reentrant. The callback function should +** not attempt to invoke any other SQLite interface. If it does, bad +** things may happen, including segmentation faults and corrupt database +** files. The callback function should be a simple function that +** does some arithmetic on its input parameters and returns a result. +** +** ^The X parameter to sqlite3_autovacuum_pages(D,C,P,X) is an optional +** destructor for the P parameter. ^If X is not NULL, then X(P) is +** invoked whenever the database connection closes or when the callback +** is overwritten by another invocation of sqlite3_autovacuum_pages(). +** +**

    ^There is only one autovacuum pages callback per database connection. +** ^Each call to the sqlite3_autovacuum_pages() interface overrides all +** previous invocations for that database connection. ^If the callback +** argument (C) to sqlite3_autovacuum_pages(D,C,P,X) is a NULL pointer, +** then the autovacuum steps callback is cancelled. The return value +** from sqlite3_autovacuum_pages() is normally SQLITE_OK, but might +** be some other error code if something goes wrong. The current +** implementation will only return SQLITE_OK or SQLITE_MISUSE, but other +** return codes might be added in future releases. +** +**

    If no autovacuum pages callback is specified (the usual case) or +** a NULL pointer is provided for the callback, +** then the default behavior is to vacuum all free pages. So, in other +** words, the default behavior is the same as if the callback function +** were something like this: +** +** 

    +**     unsigned int demonstration_autovac_pages_callback(
+**       void *pClientData,
+**       const char *zSchema,
+**       unsigned int nDbPage,
+**       unsigned int nFreePage,
+**       unsigned int nBytePerPage
+**     ){
+**       return nFreePage;
+**     }
+**
    +*/ +SQLITE_API int sqlite3_autovacuum_pages( + sqlite3 *db, + unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), + void*, + void(*)(void*) +); + + /* ** CAPI3REF: Data Change Notification Callbacks ** METHOD: sqlite3 @@ -8814,7 +8249,9 @@ SQLITE_API int sqlite3_test_control(int op, ...); #define SQLITE_TESTCTRL_PRNG_SEED 28 #define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29 #define SQLITE_TESTCTRL_SEEK_COUNT 30 -#define SQLITE_TESTCTRL_LAST 30 /* Largest TESTCTRL */ +#define SQLITE_TESTCTRL_TRACEFLAGS 31 +#define SQLITE_TESTCTRL_TUNE 32 +#define SQLITE_TESTCTRL_LAST 32 /* Largest TESTCTRL */ /* ** CAPI3REF: SQL Keyword Checking @@ -10014,8 +9451,9 @@ SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...); ** ** A single database handle may have at most a single write-ahead log callback ** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any -** previously registered write-ahead log callback. ^Note that the -** [sqlite3_wal_autocheckpoint()] interface and the +** previously registered write-ahead log callback. ^The return value is +** a copy of the third parameter from the previous call, if any, or 0. +** ^Note that the [sqlite3_wal_autocheckpoint()] interface and the ** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will ** overwrite any prior [sqlite3_wal_hook()] settings. */ @@ -10566,6 +10004,15 @@ SQLITE_API int sqlite3_db_cacheflush(sqlite3*); ** triggers; or 2 for changes resulting from triggers called by top-level ** triggers; and so forth. ** +** When the [sqlite3_blob_write()] API is used to update a blob column, +** the pre-update hook is invoked with SQLITE_DELETE. This is because the +** in this case the new values are not available. In this case, when a +** callback made with op==SQLITE_DELETE is actuall a write using the +** sqlite3_blob_write() API, the [sqlite3_preupdate_blobwrite()] returns +** the index of the column being written. In other cases, where the +** pre-update hook is being invoked for some other reason, including a +** regular DELETE, sqlite3_preupdate_blobwrite() returns -1. +** ** See also: [sqlite3_update_hook()] */ #if defined(SQLITE_ENABLE_PREUPDATE_HOOK) @@ -10586,6 +10033,7 @@ SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **); SQLITE_API int sqlite3_preupdate_count(sqlite3 *); SQLITE_API int sqlite3_preupdate_depth(sqlite3 *); SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **); +SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *); #endif /* @@ -10824,8 +10272,8 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const c ** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory ** allocation error occurs. ** -** This interface is only available if SQLite is compiled with the -** [SQLITE_ENABLE_DESERIALIZE] option. +** This interface is omitted if SQLite is compiled with the +** [SQLITE_OMIT_DESERIALIZE] option. */ SQLITE_API unsigned char *sqlite3_serialize( sqlite3 *db, /* The database connection */ @@ -10872,12 +10320,16 @@ SQLITE_API unsigned char *sqlite3_serialize( ** database is currently in a read transaction or is involved in a backup ** operation. ** +** It is not possible to deserialized into the TEMP database. If the +** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the +** function returns SQLITE_ERROR. +** ** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the ** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then ** [sqlite3_free()] is invoked on argument P prior to returning. ** -** This interface is only available if SQLite is compiled with the -** [SQLITE_ENABLE_DESERIALIZE] option. +** This interface is omitted if SQLite is compiled with the +** [SQLITE_OMIT_DESERIALIZE] option. */ SQLITE_API int sqlite3_deserialize( sqlite3 *db, /* The database connection */ @@ -11126,6 +10578,38 @@ SQLITE_API int sqlite3session_create( */ SQLITE_API void sqlite3session_delete(sqlite3_session *pSession); +/* +** CAPIREF: Conigure a Session Object +** METHOD: sqlite3_session +** +** This method is used to configure a session object after it has been +** created. At present the only valid value for the second parameter is +** [SQLITE_SESSION_OBJCONFIG_SIZE]. +** +** Arguments for sqlite3session_object_config() +** +** The following values may passed as the the 4th parameter to +** sqlite3session_object_config(). +** +**
    SQLITE_SESSION_OBJCONFIG_SIZE
    +** This option is used to set, clear or query the flag that enables +** the [sqlite3session_changeset_size()] API. Because it imposes some +** computational overhead, this API is disabled by default. Argument +** pArg must point to a value of type (int). If the value is initially +** 0, then the sqlite3session_changeset_size() API is disabled. If it +** is greater than 0, then the same API is enabled. Or, if the initial +** value is less than zero, no change is made. In all cases the (int) +** variable is set to 1 if the sqlite3session_changeset_size() API is +** enabled following the current call, or 0 otherwise. +** +** It is an error (SQLITE_MISUSE) to attempt to modify this setting after +** the first table has been attached to the session object. +*/ +SQLITE_API int sqlite3session_object_config(sqlite3_session*, int op, void *pArg); + +/* +*/ +#define SQLITE_SESSION_OBJCONFIG_SIZE 1 /* ** CAPI3REF: Enable Or Disable A Session Object @@ -11370,6 +10854,22 @@ SQLITE_API int sqlite3session_changeset( void **ppChangeset /* OUT: Buffer containing changeset */ ); +/* +** CAPI3REF: Return An Upper-limit For The Size Of The Changeset +** METHOD: sqlite3_session +** +** By default, this function always returns 0. For it to return +** a useful result, the sqlite3_session object must have been configured +** to enable this API using sqlite3session_object_config() with the +** SQLITE_SESSION_OBJCONFIG_SIZE verb. +** +** When enabled, this function returns an upper limit, in bytes, for the size +** of the changeset that might be produced if sqlite3session_changeset() were +** called. The final changeset size might be equal to or smaller than the +** size in bytes returned by this function. +*/ +SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession); + /* ** CAPI3REF: Load The Difference Between Tables Into A Session ** METHOD: sqlite3_session @@ -11487,6 +10987,14 @@ SQLITE_API int sqlite3session_patchset( */ SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession); +/* +** CAPI3REF: Query for the amount of heap memory used by a session object. +** +** This API returns the total amount of heap memory in bytes currently +** used by the session object passed as the only argument. +*/ +SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession); + /* ** CAPI3REF: Create An Iterator To Traverse A Changeset ** CONSTRUCTOR: sqlite3_changeset_iter @@ -11589,18 +11097,23 @@ SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter); ** call to [sqlite3changeset_next()] must have returned [SQLITE_ROW]. If this ** is not the case, this function returns [SQLITE_MISUSE]. ** -** If argument pzTab is not NULL, then *pzTab is set to point to a -** nul-terminated utf-8 encoded string containing the name of the table -** affected by the current change. The buffer remains valid until either -** sqlite3changeset_next() is called on the iterator or until the -** conflict-handler function returns. If pnCol is not NULL, then *pnCol is -** set to the number of columns in the table affected by the change. If -** pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change +** Arguments pOp, pnCol and pzTab may not be NULL. Upon return, three +** outputs are set through these pointers: +** +** *pOp is set to one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], +** depending on the type of change that the iterator currently points to; +** +** *pnCol is set to the number of columns in the table affected by the change; and +** +** *pzTab is set to point to a nul-terminated utf-8 encoded string containing +** the name of the table affected by the current change. The buffer remains +** valid until either sqlite3changeset_next() is called on the iterator +** or until the conflict-handler function returns. +** +** If pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change ** is an indirect change, or false (0) otherwise. See the documentation for ** [sqlite3session_indirect()] for a description of direct and indirect -** changes. Finally, if pOp is not NULL, then *pOp is set to one of -** [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], depending on the -** type of change that the iterator currently points to. +** changes. ** ** If no error occurs, SQLITE_OK is returned. If an error does occur, an ** SQLite error code is returned. The values of the output variables may not @@ -13293,7 +12806,7 @@ struct fts5_api { ** autoconf-based build */ #if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H) -/* #include "config.h" */ +#include "config.h" #define SQLITECONFIG_H 1 #endif @@ -13530,9 +13043,11 @@ struct fts5_api { # define __has_extension(x) 0 /* compatibility with non-clang compilers */ #endif #if GCC_VERSION>=4007000 || __has_extension(c_atomic) +# define SQLITE_ATOMIC_INTRINSICS 1 # define AtomicLoad(PTR) __atomic_load_n((PTR),__ATOMIC_RELAXED) # define AtomicStore(PTR,VAL) __atomic_store_n((PTR),(VAL),__ATOMIC_RELAXED) #else +# define SQLITE_ATOMIC_INTRINSICS 0 # define AtomicLoad(PTR) (*(PTR)) # define AtomicStore(PTR,VAL) (*(PTR) = (VAL)) #endif @@ -13737,11 +13252,12 @@ struct fts5_api { ** is significant and used at least once. On switch statements ** where multiple cases go to the same block of code, testcase() ** can insure that all cases are evaluated. -** */ -#ifdef SQLITE_COVERAGE_TEST -SQLITE_PRIVATE void sqlite3Coverage(int); -# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); } +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG) +# ifndef SQLITE_AMALGAMATION + extern unsigned int sqlite3CoverageCounter; +# endif +# define testcase(X) if( X ){ sqlite3CoverageCounter += (unsigned)__LINE__; } #else # define testcase(X) #endif @@ -13771,6 +13287,14 @@ SQLITE_PRIVATE void sqlite3Coverage(int); # define VVA_ONLY(X) #endif +/* +** Disable ALWAYS() and NEVER() (make them pass-throughs) for coverage +** and mutation testing +*/ +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) +# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1 +#endif + /* ** The ALWAYS and NEVER macros surround boolean expressions which ** are intended to always be true or false, respectively. Such @@ -13786,7 +13310,7 @@ SQLITE_PRIVATE void sqlite3Coverage(int); ** be true and false so that the unreachable code they specify will ** not be counted as untested code. */ -#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) +#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS) # define ALWAYS(X) (1) # define NEVER(X) (0) #elif !defined(NDEBUG) @@ -13797,26 +13321,6 @@ SQLITE_PRIVATE void sqlite3Coverage(int); # define NEVER(X) (X) #endif -/* -** The harmless(X) macro indicates that expression X is usually false -** but can be true without causing any problems, but we don't know of -** any way to cause X to be true. -** -** In debugging and testing builds, this macro will abort if X is ever -** true. In this way, developers are alerted to a possible test case -** that causes X to be true. If a harmless macro ever fails, that is -** an opportunity to change the macro into a testcase() and add a new -** test case to the test suite. -** -** For normal production builds, harmless(X) is a no-op, since it does -** not matter whether expression X is true or false. -*/ -#ifdef SQLITE_DEBUG -# define harmless(X) assert(!(X)); -#else -# define harmless(X) -#endif - /* ** Some conditionals are optimizations only. In other words, if the ** conditionals are replaced with a constant 1 (true) or 0 (false) then @@ -13880,6 +13384,13 @@ SQLITE_PRIVATE void sqlite3Coverage(int); # undef SQLITE_ENABLE_EXPLAIN_COMMENTS #endif +/* +** SQLITE_OMIT_VIRTUALTABLE implies SQLITE_OMIT_ALTERTABLE +*/ +#if defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_ALTERTABLE) +# define SQLITE_OMIT_ALTERTABLE +#endif + /* ** Return true (non-zero) if the input is an integer that is too large ** to fit in 32-bits. This macro is used inside of various testcase() @@ -13992,7 +13503,7 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*); /* ** Number of entries in a hash table */ -/* #define sqliteHashCount(H) ((H)->count) // NOT USED */ +#define sqliteHashCount(H) ((H)->count) #endif /* SQLITE_HASH_H */ @@ -14024,8 +13535,8 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*); #define TK_LP 22 #define TK_RP 23 #define TK_AS 24 -#define TK_WITHOUT 25 -#define TK_COMMA 26 +#define TK_COMMA 25 +#define TK_WITHOUT 26 #define TK_ABORT 27 #define TK_ACTION 28 #define TK_AFTER 29 @@ -14096,90 +13607,93 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*); #define TK_TIES 94 #define TK_GENERATED 95 #define TK_ALWAYS 96 -#define TK_REINDEX 97 -#define TK_RENAME 98 -#define TK_CTIME_KW 99 -#define TK_ANY 100 -#define TK_BITAND 101 -#define TK_BITOR 102 -#define TK_LSHIFT 103 -#define TK_RSHIFT 104 -#define TK_PLUS 105 -#define TK_MINUS 106 -#define TK_STAR 107 -#define TK_SLASH 108 -#define TK_REM 109 -#define TK_CONCAT 110 -#define TK_COLLATE 111 -#define TK_BITNOT 112 -#define TK_ON 113 -#define TK_INDEXED 114 -#define TK_STRING 115 -#define TK_JOIN_KW 116 -#define TK_CONSTRAINT 117 -#define TK_DEFAULT 118 -#define TK_NULL 119 -#define TK_PRIMARY 120 -#define TK_UNIQUE 121 -#define TK_CHECK 122 -#define TK_REFERENCES 123 -#define TK_AUTOINCR 124 -#define TK_INSERT 125 -#define TK_DELETE 126 -#define TK_UPDATE 127 -#define TK_SET 128 -#define TK_DEFERRABLE 129 -#define TK_FOREIGN 130 -#define TK_DROP 131 -#define TK_UNION 132 -#define TK_ALL 133 -#define TK_EXCEPT 134 -#define TK_INTERSECT 135 -#define TK_SELECT 136 -#define TK_VALUES 137 -#define TK_DISTINCT 138 -#define TK_DOT 139 -#define TK_FROM 140 -#define TK_JOIN 141 -#define TK_USING 142 -#define TK_ORDER 143 -#define TK_GROUP 144 -#define TK_HAVING 145 -#define TK_LIMIT 146 -#define TK_WHERE 147 -#define TK_INTO 148 -#define TK_NOTHING 149 -#define TK_FLOAT 150 -#define TK_BLOB 151 -#define TK_INTEGER 152 -#define TK_VARIABLE 153 -#define TK_CASE 154 -#define TK_WHEN 155 -#define TK_THEN 156 -#define TK_ELSE 157 -#define TK_INDEX 158 -#define TK_ALTER 159 -#define TK_ADD 160 -#define TK_WINDOW 161 -#define TK_OVER 162 -#define TK_FILTER 163 -#define TK_COLUMN 164 -#define TK_AGG_FUNCTION 165 -#define TK_AGG_COLUMN 166 -#define TK_TRUEFALSE 167 -#define TK_ISNOT 168 -#define TK_FUNCTION 169 -#define TK_UMINUS 170 -#define TK_UPLUS 171 -#define TK_TRUTH 172 -#define TK_REGISTER 173 -#define TK_VECTOR 174 -#define TK_SELECT_COLUMN 175 -#define TK_IF_NULL_ROW 176 -#define TK_ASTERISK 177 -#define TK_SPAN 178 -#define TK_SPACE 179 -#define TK_ILLEGAL 180 +#define TK_MATERIALIZED 97 +#define TK_REINDEX 98 +#define TK_RENAME 99 +#define TK_CTIME_KW 100 +#define TK_ANY 101 +#define TK_BITAND 102 +#define TK_BITOR 103 +#define TK_LSHIFT 104 +#define TK_RSHIFT 105 +#define TK_PLUS 106 +#define TK_MINUS 107 +#define TK_STAR 108 +#define TK_SLASH 109 +#define TK_REM 110 +#define TK_CONCAT 111 +#define TK_COLLATE 112 +#define TK_BITNOT 113 +#define TK_ON 114 +#define TK_INDEXED 115 +#define TK_STRING 116 +#define TK_JOIN_KW 117 +#define TK_CONSTRAINT 118 +#define TK_DEFAULT 119 +#define TK_NULL 120 +#define TK_PRIMARY 121 +#define TK_UNIQUE 122 +#define TK_CHECK 123 +#define TK_REFERENCES 124 +#define TK_AUTOINCR 125 +#define TK_INSERT 126 +#define TK_DELETE 127 +#define TK_UPDATE 128 +#define TK_SET 129 +#define TK_DEFERRABLE 130 +#define TK_FOREIGN 131 +#define TK_DROP 132 +#define TK_UNION 133 +#define TK_ALL 134 +#define TK_EXCEPT 135 +#define TK_INTERSECT 136 +#define TK_SELECT 137 +#define TK_VALUES 138 +#define TK_DISTINCT 139 +#define TK_DOT 140 +#define TK_FROM 141 +#define TK_JOIN 142 +#define TK_USING 143 +#define TK_ORDER 144 +#define TK_GROUP 145 +#define TK_HAVING 146 +#define TK_LIMIT 147 +#define TK_WHERE 148 +#define TK_RETURNING 149 +#define TK_INTO 150 +#define TK_NOTHING 151 +#define TK_FLOAT 152 +#define TK_BLOB 153 +#define TK_INTEGER 154 +#define TK_VARIABLE 155 +#define TK_CASE 156 +#define TK_WHEN 157 +#define TK_THEN 158 +#define TK_ELSE 159 +#define TK_INDEX 160 +#define TK_ALTER 161 +#define TK_ADD 162 +#define TK_WINDOW 163 +#define TK_OVER 164 +#define TK_FILTER 165 +#define TK_COLUMN 166 +#define TK_AGG_FUNCTION 167 +#define TK_AGG_COLUMN 168 +#define TK_TRUEFALSE 169 +#define TK_ISNOT 170 +#define TK_FUNCTION 171 +#define TK_UMINUS 172 +#define TK_UPLUS 173 +#define TK_TRUTH 174 +#define TK_REGISTER 175 +#define TK_VECTOR 176 +#define TK_SELECT_COLUMN 177 +#define TK_IF_NULL_ROW 178 +#define TK_ASTERISK 179 +#define TK_SPAN 180 +#define TK_ERROR 181 +#define TK_SPACE 182 +#define TK_ILLEGAL 183 /************** End of parse.h ***********************************************/ /************** Continuing where we left off in sqliteInt.h ******************/ @@ -14285,7 +13799,7 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*); ** number of pages. A negative number N translations means that a buffer ** of -1024*N bytes is allocated and used for as many pages as it will hold. ** -** The default value of "20" was choosen to minimize the run-time of the +** The default value of "20" was chosen to minimize the run-time of the ** speedtest1 test program with options: --shrink-memory --reprepare */ #ifndef SQLITE_DEFAULT_PCACHE_INITSZ @@ -14447,6 +13961,7 @@ typedef INT16_TYPE LogEst; # define SQLITE_PTRSIZE __SIZEOF_POINTER__ # elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \ defined(_M_ARM) || defined(__arm__) || defined(__x86) || \ + (defined(__APPLE__) && defined(__POWERPC__)) || \ (defined(__TOS_AIX__) && !defined(__64BIT__)) # define SQLITE_PTRSIZE 4 # else @@ -14595,15 +14110,14 @@ typedef INT16_TYPE LogEst; ** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not ** the Select query generator tracing logic is turned on. */ -#if defined(SQLITE_ENABLE_SELECTTRACE) -# define SELECTTRACE_ENABLED 1 -#else -# define SELECTTRACE_ENABLED 0 +#if !defined(SQLITE_AMALGAMATION) +SQLITE_PRIVATE u32 sqlite3SelectTrace; #endif -#if defined(SQLITE_ENABLE_SELECTTRACE) +#if defined(SQLITE_DEBUG) \ + && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_SELECTTRACE)) # define SELECTTRACE_ENABLED 1 # define SELECTTRACE(K,P,S,X) \ - if(sqlite3_unsupported_selecttrace&(K)) \ + if(sqlite3SelectTrace&(K)) \ sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\ sqlite3DebugPrintf X #else @@ -14611,6 +14125,19 @@ typedef INT16_TYPE LogEst; # define SELECTTRACE_ENABLED 0 #endif +/* +** Macros for "wheretrace" +*/ +SQLITE_PRIVATE u32 sqlite3WhereTrace; +#if defined(SQLITE_DEBUG) \ + && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE)) +# define WHERETRACE(K,X) if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X +# define WHERETRACE_ENABLED 1 +#else +# define WHERETRACE(K,X) +#endif + + /* ** An instance of the following structure is used to store the busy-handler ** callback for a given sqlite handle. @@ -14629,11 +14156,25 @@ struct BusyHandler { /* ** Name of table that holds the database schema. +** +** The PREFERRED names are used whereever possible. But LEGACY is also +** used for backwards compatibility. +** +** 1. Queries can use either the PREFERRED or the LEGACY names +** 2. The sqlite3_set_authorizer() callback uses the LEGACY name +** 3. The PRAGMA table_list statement uses the PREFERRED name +** +** The LEGACY names are stored in the internal symbol hash table +** in support of (2). Names are translated using sqlite3PreferredTableName() +** for (3). The sqlite3FindTable() function takes care of translating +** names for (1). +** +** Note that "sqlite_temp_schema" can also be called "temp.sqlite_schema". */ -#define DFLT_SCHEMA_TABLE "sqlite_master" -#define DFLT_TEMP_SCHEMA_TABLE "sqlite_temp_master" -#define ALT_SCHEMA_TABLE "sqlite_schema" -#define ALT_TEMP_SCHEMA_TABLE "sqlite_temp_schema" +#define LEGACY_SCHEMA_TABLE "sqlite_master" +#define LEGACY_TEMP_SCHEMA_TABLE "sqlite_temp_master" +#define PREFERRED_SCHEMA_TABLE "sqlite_schema" +#define PREFERRED_TEMP_SCHEMA_TABLE "sqlite_temp_schema" /* @@ -14645,7 +14186,7 @@ struct BusyHandler { ** The name of the schema table. The name is different for TEMP. */ #define SCHEMA_TABLE(x) \ - ((!OMIT_TEMPDB)&&(x==1)?DFLT_TEMP_SCHEMA_TABLE:DFLT_SCHEMA_TABLE) + ((!OMIT_TEMPDB)&&(x==1)?LEGACY_TEMP_SCHEMA_TABLE:LEGACY_SCHEMA_TABLE) /* ** A convenience macro that returns the number of elements in @@ -14722,7 +14263,10 @@ typedef struct AutoincInfo AutoincInfo; typedef struct Bitvec Bitvec; typedef struct CollSeq CollSeq; typedef struct Column Column; +typedef struct Cte Cte; +typedef struct CteUse CteUse; typedef struct Db Db; +typedef struct DbFixer DbFixer; typedef struct Schema Schema; typedef struct Expr Expr; typedef struct ExprList ExprList; @@ -14740,14 +14284,17 @@ typedef struct LookasideSlot LookasideSlot; typedef struct Module Module; typedef struct NameContext NameContext; typedef struct Parse Parse; +typedef struct ParseCleanup ParseCleanup; typedef struct PreUpdate PreUpdate; typedef struct PrintfArguments PrintfArguments; typedef struct RenameToken RenameToken; +typedef struct Returning Returning; typedef struct RowSet RowSet; typedef struct Savepoint Savepoint; typedef struct Select Select; typedef struct SQLiteThread SQLiteThread; typedef struct SelectDest SelectDest; +typedef struct SrcItem SrcItem; typedef struct SrcList SrcList; typedef struct sqlite3_str StrAccum; /* Internal alias for sqlite3_str */ typedef struct Table Table; @@ -15180,7 +14727,7 @@ SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *); #define BTREE_BLOBKEY 2 /* Table has keys only - no data */ SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*); -SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, int*); +SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, i64*); SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor*); SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree*, int, int); @@ -15304,13 +14851,17 @@ SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor*, int, ...); #endif SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*); -SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( +SQLITE_PRIVATE int sqlite3BtreeTableMoveto( BtCursor*, - UnpackedRecord *pUnKey, i64 intKey, int bias, int *pRes ); +SQLITE_PRIVATE int sqlite3BtreeIndexMoveto( + BtCursor*, + UnpackedRecord *pUnKey, + int *pRes +); SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*); SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor*, int*); SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags); @@ -15319,6 +14870,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags); #define BTREE_SAVEPOSITION 0x02 /* Leave cursor pointing at NEXT or PREV */ #define BTREE_AUXDELETE 0x04 /* not the primary delete operation */ #define BTREE_APPEND 0x08 /* Insert is likely an append */ +#define BTREE_PREFORMAT 0x80 /* Inserted data is a preformated cell */ /* An instance of the BtreePayload object describes the content of a single ** entry in either an index or table btree. @@ -15418,6 +14970,8 @@ SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*); SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree*, int, int *, int *); #endif +SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor*, BtCursor*, i64); + /* ** If we are not using shared cache, then there is no need to ** use mutexes to access the BtShared structures. So make the @@ -15658,35 +15212,35 @@ typedef struct VdbeOpList VdbeOpList; #define OP_If 18 /* jump */ #define OP_Not 19 /* same as TK_NOT, synopsis: r[P2]= !r[P1] */ #define OP_IfNot 20 /* jump */ -#define OP_IfNullRow 21 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */ -#define OP_SeekLT 22 /* jump, synopsis: key=r[P3@P4] */ -#define OP_SeekLE 23 /* jump, synopsis: key=r[P3@P4] */ -#define OP_SeekGE 24 /* jump, synopsis: key=r[P3@P4] */ -#define OP_SeekGT 25 /* jump, synopsis: key=r[P3@P4] */ -#define OP_IfNotOpen 26 /* jump, synopsis: if( !csr[P1] ) goto P2 */ -#define OP_IfNoHope 27 /* jump, synopsis: key=r[P3@P4] */ -#define OP_NoConflict 28 /* jump, synopsis: key=r[P3@P4] */ -#define OP_NotFound 29 /* jump, synopsis: key=r[P3@P4] */ -#define OP_Found 30 /* jump, synopsis: key=r[P3@P4] */ -#define OP_SeekRowid 31 /* jump, synopsis: intkey=r[P3] */ -#define OP_NotExists 32 /* jump, synopsis: intkey=r[P3] */ -#define OP_Last 33 /* jump */ -#define OP_IfSmaller 34 /* jump */ -#define OP_SorterSort 35 /* jump */ -#define OP_Sort 36 /* jump */ -#define OP_Rewind 37 /* jump */ -#define OP_IdxLE 38 /* jump, synopsis: key=r[P3@P4] */ -#define OP_IdxGT 39 /* jump, synopsis: key=r[P3@P4] */ -#define OP_IdxLT 40 /* jump, synopsis: key=r[P3@P4] */ -#define OP_IdxGE 41 /* jump, synopsis: key=r[P3@P4] */ -#define OP_RowSetRead 42 /* jump, synopsis: r[P3]=rowset(P1) */ +#define OP_IsNullOrType 21 /* jump, synopsis: if typeof(r[P1]) IN (P3,5) goto P2 */ +#define OP_IfNullRow 22 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */ +#define OP_SeekLT 23 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekLE 24 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekGE 25 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekGT 26 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IfNotOpen 27 /* jump, synopsis: if( !csr[P1] ) goto P2 */ +#define OP_IfNoHope 28 /* jump, synopsis: key=r[P3@P4] */ +#define OP_NoConflict 29 /* jump, synopsis: key=r[P3@P4] */ +#define OP_NotFound 30 /* jump, synopsis: key=r[P3@P4] */ +#define OP_Found 31 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekRowid 32 /* jump, synopsis: intkey=r[P3] */ +#define OP_NotExists 33 /* jump, synopsis: intkey=r[P3] */ +#define OP_Last 34 /* jump */ +#define OP_IfSmaller 35 /* jump */ +#define OP_SorterSort 36 /* jump */ +#define OP_Sort 37 /* jump */ +#define OP_Rewind 38 /* jump */ +#define OP_IdxLE 39 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IdxGT 40 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IdxLT 41 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IdxGE 42 /* jump, synopsis: key=r[P3@P4] */ #define OP_Or 43 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */ #define OP_And 44 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */ -#define OP_RowSetTest 45 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */ -#define OP_Program 46 /* jump */ -#define OP_FkIfZero 47 /* jump, synopsis: if fkctr[P1]==0 goto P2 */ -#define OP_IfPos 48 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */ -#define OP_IfNotZero 49 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */ +#define OP_RowSetRead 45 /* jump, synopsis: r[P3]=rowset(P1) */ +#define OP_RowSetTest 46 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */ +#define OP_Program 47 /* jump */ +#define OP_FkIfZero 48 /* jump, synopsis: if fkctr[P1]==0 goto P2 */ +#define OP_IfPos 49 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */ #define OP_IsNull 50 /* jump, same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */ #define OP_NotNull 51 /* jump, same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */ #define OP_Ne 52 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */ @@ -15695,125 +15249,130 @@ typedef struct VdbeOpList VdbeOpList; #define OP_Le 55 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */ #define OP_Lt 56 /* jump, same as TK_LT, synopsis: IF r[P3]=r[P1] */ -#define OP_ElseNotEq 58 /* jump, same as TK_ESCAPE */ -#define OP_DecrJumpZero 59 /* jump, synopsis: if (--r[P1])==0 goto P2 */ -#define OP_IncrVacuum 60 /* jump */ -#define OP_VNext 61 /* jump */ -#define OP_Init 62 /* jump, synopsis: Start at P2 */ -#define OP_PureFunc 63 /* synopsis: r[P3]=func(r[P2@NP]) */ -#define OP_Function 64 /* synopsis: r[P3]=func(r[P2@NP]) */ -#define OP_Return 65 -#define OP_EndCoroutine 66 -#define OP_HaltIfNull 67 /* synopsis: if r[P3]=null halt */ -#define OP_Halt 68 -#define OP_Integer 69 /* synopsis: r[P2]=P1 */ -#define OP_Int64 70 /* synopsis: r[P2]=P4 */ -#define OP_String 71 /* synopsis: r[P2]='P4' (len=P1) */ -#define OP_Null 72 /* synopsis: r[P2..P3]=NULL */ -#define OP_SoftNull 73 /* synopsis: r[P1]=NULL */ -#define OP_Blob 74 /* synopsis: r[P2]=P4 (len=P1) */ -#define OP_Variable 75 /* synopsis: r[P2]=parameter(P1,P4) */ -#define OP_Move 76 /* synopsis: r[P2@P3]=r[P1@P3] */ -#define OP_Copy 77 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */ -#define OP_SCopy 78 /* synopsis: r[P2]=r[P1] */ -#define OP_IntCopy 79 /* synopsis: r[P2]=r[P1] */ -#define OP_ResultRow 80 /* synopsis: output=r[P1@P2] */ -#define OP_CollSeq 81 -#define OP_AddImm 82 /* synopsis: r[P1]=r[P1]+P2 */ -#define OP_RealAffinity 83 -#define OP_Cast 84 /* synopsis: affinity(r[P1]) */ -#define OP_Permutation 85 -#define OP_Compare 86 /* synopsis: r[P1@P3] <-> r[P2@P3] */ -#define OP_IsTrue 87 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */ -#define OP_Offset 88 /* synopsis: r[P3] = sqlite_offset(P1) */ -#define OP_Column 89 /* synopsis: r[P3]=PX */ -#define OP_Affinity 90 /* synopsis: affinity(r[P1@P2]) */ -#define OP_MakeRecord 91 /* synopsis: r[P3]=mkrec(r[P1@P2]) */ -#define OP_Count 92 /* synopsis: r[P2]=count() */ -#define OP_ReadCookie 93 -#define OP_SetCookie 94 -#define OP_ReopenIdx 95 /* synopsis: root=P2 iDb=P3 */ -#define OP_OpenRead 96 /* synopsis: root=P2 iDb=P3 */ -#define OP_OpenWrite 97 /* synopsis: root=P2 iDb=P3 */ -#define OP_OpenDup 98 -#define OP_OpenAutoindex 99 /* synopsis: nColumn=P2 */ -#define OP_OpenEphemeral 100 /* synopsis: nColumn=P2 */ -#define OP_BitAnd 101 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */ -#define OP_BitOr 102 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */ -#define OP_ShiftLeft 103 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<>r[P1] */ -#define OP_Add 105 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */ -#define OP_Subtract 106 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */ -#define OP_Multiply 107 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */ -#define OP_Divide 108 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */ -#define OP_Remainder 109 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */ -#define OP_Concat 110 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */ -#define OP_SorterOpen 111 -#define OP_BitNot 112 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */ -#define OP_SequenceTest 113 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */ -#define OP_OpenPseudo 114 /* synopsis: P3 columns in r[P2] */ -#define OP_String8 115 /* same as TK_STRING, synopsis: r[P2]='P4' */ -#define OP_Close 116 -#define OP_ColumnsUsed 117 -#define OP_SeekScan 118 /* synopsis: Scan-ahead up to P1 rows */ -#define OP_SeekHit 119 /* synopsis: set P2<=seekHit<=P3 */ -#define OP_Sequence 120 /* synopsis: r[P2]=cursor[P1].ctr++ */ -#define OP_NewRowid 121 /* synopsis: r[P2]=rowid */ -#define OP_Insert 122 /* synopsis: intkey=r[P3] data=r[P2] */ -#define OP_Delete 123 -#define OP_ResetCount 124 -#define OP_SorterCompare 125 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */ -#define OP_SorterData 126 /* synopsis: r[P2]=data */ -#define OP_RowData 127 /* synopsis: r[P2]=data */ -#define OP_Rowid 128 /* synopsis: r[P2]=rowid */ -#define OP_NullRow 129 -#define OP_SeekEnd 130 -#define OP_IdxInsert 131 /* synopsis: key=r[P2] */ -#define OP_SorterInsert 132 /* synopsis: key=r[P2] */ -#define OP_IdxDelete 133 /* synopsis: key=r[P2@P3] */ -#define OP_DeferredSeek 134 /* synopsis: Move P3 to P1.rowid if needed */ -#define OP_IdxRowid 135 /* synopsis: r[P2]=rowid */ -#define OP_FinishSeek 136 -#define OP_Destroy 137 -#define OP_Clear 138 -#define OP_ResetSorter 139 -#define OP_CreateBtree 140 /* synopsis: r[P2]=root iDb=P1 flags=P3 */ -#define OP_SqlExec 141 -#define OP_ParseSchema 142 -#define OP_LoadAnalysis 143 -#define OP_DropTable 144 -#define OP_DropIndex 145 -#define OP_DropTrigger 146 -#define OP_IntegrityCk 147 -#define OP_RowSetAdd 148 /* synopsis: rowset(P1)=r[P2] */ -#define OP_Param 149 -#define OP_Real 150 /* same as TK_FLOAT, synopsis: r[P2]=P4 */ -#define OP_FkCounter 151 /* synopsis: fkctr[P1]+=P2 */ -#define OP_MemMax 152 /* synopsis: r[P1]=max(r[P1],r[P2]) */ -#define OP_OffsetLimit 153 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */ -#define OP_AggInverse 154 /* synopsis: accum=r[P3] inverse(r[P2@P5]) */ -#define OP_AggStep 155 /* synopsis: accum=r[P3] step(r[P2@P5]) */ -#define OP_AggStep1 156 /* synopsis: accum=r[P3] step(r[P2@P5]) */ -#define OP_AggValue 157 /* synopsis: r[P3]=value N=P2 */ -#define OP_AggFinal 158 /* synopsis: accum=r[P1] N=P2 */ -#define OP_Expire 159 -#define OP_CursorLock 160 -#define OP_CursorUnlock 161 -#define OP_TableLock 162 /* synopsis: iDb=P1 root=P2 write=P3 */ -#define OP_VBegin 163 -#define OP_VCreate 164 -#define OP_VDestroy 165 -#define OP_VOpen 166 -#define OP_VColumn 167 /* synopsis: r[P3]=vcolumn(P2) */ -#define OP_VRename 168 -#define OP_Pagecount 169 -#define OP_MaxPgcnt 170 -#define OP_Trace 171 -#define OP_CursorHint 172 -#define OP_ReleaseReg 173 /* synopsis: release r[P1@P2] mask P3 */ -#define OP_Noop 174 -#define OP_Explain 175 -#define OP_Abortable 176 +#define OP_ElseEq 58 /* jump, same as TK_ESCAPE */ +#define OP_IfNotZero 59 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */ +#define OP_DecrJumpZero 60 /* jump, synopsis: if (--r[P1])==0 goto P2 */ +#define OP_IncrVacuum 61 /* jump */ +#define OP_VNext 62 /* jump */ +#define OP_Init 63 /* jump, synopsis: Start at P2 */ +#define OP_PureFunc 64 /* synopsis: r[P3]=func(r[P2@NP]) */ +#define OP_Function 65 /* synopsis: r[P3]=func(r[P2@NP]) */ +#define OP_Return 66 +#define OP_EndCoroutine 67 +#define OP_HaltIfNull 68 /* synopsis: if r[P3]=null halt */ +#define OP_Halt 69 +#define OP_Integer 70 /* synopsis: r[P2]=P1 */ +#define OP_Int64 71 /* synopsis: r[P2]=P4 */ +#define OP_String 72 /* synopsis: r[P2]='P4' (len=P1) */ +#define OP_Null 73 /* synopsis: r[P2..P3]=NULL */ +#define OP_SoftNull 74 /* synopsis: r[P1]=NULL */ +#define OP_Blob 75 /* synopsis: r[P2]=P4 (len=P1) */ +#define OP_Variable 76 /* synopsis: r[P2]=parameter(P1,P4) */ +#define OP_Move 77 /* synopsis: r[P2@P3]=r[P1@P3] */ +#define OP_Copy 78 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */ +#define OP_SCopy 79 /* synopsis: r[P2]=r[P1] */ +#define OP_IntCopy 80 /* synopsis: r[P2]=r[P1] */ +#define OP_ChngCntRow 81 /* synopsis: output=r[P1] */ +#define OP_ResultRow 82 /* synopsis: output=r[P1@P2] */ +#define OP_CollSeq 83 +#define OP_AddImm 84 /* synopsis: r[P1]=r[P1]+P2 */ +#define OP_RealAffinity 85 +#define OP_Cast 86 /* synopsis: affinity(r[P1]) */ +#define OP_Permutation 87 +#define OP_Compare 88 /* synopsis: r[P1@P3] <-> r[P2@P3] */ +#define OP_IsTrue 89 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */ +#define OP_ZeroOrNull 90 /* synopsis: r[P2] = 0 OR NULL */ +#define OP_Offset 91 /* synopsis: r[P3] = sqlite_offset(P1) */ +#define OP_Column 92 /* synopsis: r[P3]=PX */ +#define OP_TypeCheck 93 /* synopsis: typecheck(r[P1@P2]) */ +#define OP_Affinity 94 /* synopsis: affinity(r[P1@P2]) */ +#define OP_MakeRecord 95 /* synopsis: r[P3]=mkrec(r[P1@P2]) */ +#define OP_Count 96 /* synopsis: r[P2]=count() */ +#define OP_ReadCookie 97 +#define OP_SetCookie 98 +#define OP_ReopenIdx 99 /* synopsis: root=P2 iDb=P3 */ +#define OP_OpenRead 100 /* synopsis: root=P2 iDb=P3 */ +#define OP_OpenWrite 101 /* synopsis: root=P2 iDb=P3 */ +#define OP_BitAnd 102 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */ +#define OP_BitOr 103 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */ +#define OP_ShiftLeft 104 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<>r[P1] */ +#define OP_Add 106 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */ +#define OP_Subtract 107 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */ +#define OP_Multiply 108 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */ +#define OP_Divide 109 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */ +#define OP_Remainder 110 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */ +#define OP_Concat 111 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */ +#define OP_OpenDup 112 +#define OP_BitNot 113 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */ +#define OP_OpenAutoindex 114 /* synopsis: nColumn=P2 */ +#define OP_OpenEphemeral 115 /* synopsis: nColumn=P2 */ +#define OP_String8 116 /* same as TK_STRING, synopsis: r[P2]='P4' */ +#define OP_SorterOpen 117 +#define OP_SequenceTest 118 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */ +#define OP_OpenPseudo 119 /* synopsis: P3 columns in r[P2] */ +#define OP_Close 120 +#define OP_ColumnsUsed 121 +#define OP_SeekScan 122 /* synopsis: Scan-ahead up to P1 rows */ +#define OP_SeekHit 123 /* synopsis: set P2<=seekHit<=P3 */ +#define OP_Sequence 124 /* synopsis: r[P2]=cursor[P1].ctr++ */ +#define OP_NewRowid 125 /* synopsis: r[P2]=rowid */ +#define OP_Insert 126 /* synopsis: intkey=r[P3] data=r[P2] */ +#define OP_RowCell 127 +#define OP_Delete 128 +#define OP_ResetCount 129 +#define OP_SorterCompare 130 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */ +#define OP_SorterData 131 /* synopsis: r[P2]=data */ +#define OP_RowData 132 /* synopsis: r[P2]=data */ +#define OP_Rowid 133 /* synopsis: r[P2]=rowid */ +#define OP_NullRow 134 +#define OP_SeekEnd 135 +#define OP_IdxInsert 136 /* synopsis: key=r[P2] */ +#define OP_SorterInsert 137 /* synopsis: key=r[P2] */ +#define OP_IdxDelete 138 /* synopsis: key=r[P2@P3] */ +#define OP_DeferredSeek 139 /* synopsis: Move P3 to P1.rowid if needed */ +#define OP_IdxRowid 140 /* synopsis: r[P2]=rowid */ +#define OP_FinishSeek 141 +#define OP_Destroy 142 +#define OP_Clear 143 +#define OP_ResetSorter 144 +#define OP_CreateBtree 145 /* synopsis: r[P2]=root iDb=P1 flags=P3 */ +#define OP_SqlExec 146 +#define OP_ParseSchema 147 +#define OP_LoadAnalysis 148 +#define OP_DropTable 149 +#define OP_DropIndex 150 +#define OP_DropTrigger 151 +#define OP_Real 152 /* same as TK_FLOAT, synopsis: r[P2]=P4 */ +#define OP_IntegrityCk 153 +#define OP_RowSetAdd 154 /* synopsis: rowset(P1)=r[P2] */ +#define OP_Param 155 +#define OP_FkCounter 156 /* synopsis: fkctr[P1]+=P2 */ +#define OP_MemMax 157 /* synopsis: r[P1]=max(r[P1],r[P2]) */ +#define OP_OffsetLimit 158 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */ +#define OP_AggInverse 159 /* synopsis: accum=r[P3] inverse(r[P2@P5]) */ +#define OP_AggStep 160 /* synopsis: accum=r[P3] step(r[P2@P5]) */ +#define OP_AggStep1 161 /* synopsis: accum=r[P3] step(r[P2@P5]) */ +#define OP_AggValue 162 /* synopsis: r[P3]=value N=P2 */ +#define OP_AggFinal 163 /* synopsis: accum=r[P1] N=P2 */ +#define OP_Expire 164 +#define OP_CursorLock 165 +#define OP_CursorUnlock 166 +#define OP_TableLock 167 /* synopsis: iDb=P1 root=P2 write=P3 */ +#define OP_VBegin 168 +#define OP_VCreate 169 +#define OP_VDestroy 170 +#define OP_VOpen 171 +#define OP_VColumn 172 /* synopsis: r[P3]=vcolumn(P2) */ +#define OP_VRename 173 +#define OP_Pagecount 174 +#define OP_MaxPgcnt 175 +#define OP_Trace 176 +#define OP_CursorHint 177 +#define OP_ReleaseReg 178 /* synopsis: release r[P1@P2] mask P3 */ +#define OP_Noop 179 +#define OP_Explain 180 +#define OP_Abortable 181 /* Properties such as "out2" or "jump" that are specified in ** comments following the "case" for each opcode in the vdbe.c @@ -15828,35 +15387,35 @@ typedef struct VdbeOpList VdbeOpList; #define OPFLG_INITIALIZER {\ /* 0 */ 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x10,\ /* 8 */ 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03,\ -/* 16 */ 0x01, 0x01, 0x03, 0x12, 0x03, 0x01, 0x09, 0x09,\ -/* 24 */ 0x09, 0x09, 0x01, 0x09, 0x09, 0x09, 0x09, 0x09,\ -/* 32 */ 0x09, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,\ -/* 40 */ 0x01, 0x01, 0x23, 0x26, 0x26, 0x0b, 0x01, 0x01,\ -/* 48 */ 0x03, 0x03, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\ -/* 56 */ 0x0b, 0x0b, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00,\ -/* 64 */ 0x00, 0x02, 0x02, 0x08, 0x00, 0x10, 0x10, 0x10,\ -/* 72 */ 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,\ -/* 80 */ 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00, 0x12,\ -/* 88 */ 0x20, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\ -/* 96 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x26, 0x26,\ -/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00,\ -/* 112 */ 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,\ -/* 120 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ -/* 128 */ 0x10, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x10,\ -/* 136 */ 0x00, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\ -/* 144 */ 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x10, 0x00,\ -/* 152 */ 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 16 */ 0x01, 0x01, 0x03, 0x12, 0x03, 0x03, 0x01, 0x09,\ +/* 24 */ 0x09, 0x09, 0x09, 0x01, 0x09, 0x09, 0x09, 0x09,\ +/* 32 */ 0x09, 0x09, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,\ +/* 40 */ 0x01, 0x01, 0x01, 0x26, 0x26, 0x23, 0x0b, 0x01,\ +/* 48 */ 0x01, 0x03, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\ +/* 56 */ 0x0b, 0x0b, 0x01, 0x03, 0x03, 0x01, 0x01, 0x01,\ +/* 64 */ 0x00, 0x00, 0x02, 0x02, 0x08, 0x00, 0x10, 0x10,\ +/* 72 */ 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10,\ +/* 80 */ 0x10, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x00,\ +/* 88 */ 0x00, 0x12, 0x1e, 0x20, 0x00, 0x00, 0x00, 0x00,\ +/* 96 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x26, 0x26,\ +/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,\ +/* 112 */ 0x00, 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\ +/* 120 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\ +/* 128 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,\ +/* 136 */ 0x04, 0x04, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00,\ +/* 144 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 152 */ 0x10, 0x00, 0x06, 0x10, 0x00, 0x04, 0x1a, 0x00,\ /* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ -/* 168 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,\ -/* 176 */ 0x00,} +/* 168 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10,\ +/* 176 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,} -/* The sqlite3P2Values() routine is able to run faster if it knows +/* The resolve3P2Values() routine is able to run faster if it knows ** the value of the largest JUMP opcode. The smaller the maximum ** JUMP opcode the better, so the mkopcodeh.tcl script that ** generated this include file strives to group all JUMP opcodes ** together near the beginning of the list. */ -#define SQLITE_MX_JUMP_OPCODE 62 /* Maximum JUMP opcode */ +#define SQLITE_MX_JUMP_OPCODE 63 /* Maximum JUMP opcode */ /************** End of opcodes.h *********************************************/ /************** Continuing where we left off in vdbe.h ***********************/ @@ -15916,7 +15475,7 @@ SQLITE_PRIVATE void sqlite3ExplainBreakpoint(const char*,const char*); #else # define sqlite3ExplainBreakpoint(A,B) /*no-op*/ #endif -SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*); +SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*, int, char*, u16); SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe*, int addr, u8); SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1); SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2); @@ -16383,6 +15942,12 @@ SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache); # define SET_FULLSYNC(x,y) #endif +/* Maximum pathname length. Note: FILENAME_MAX defined by stdio.h +*/ +#ifndef SQLITE_MAX_PATHLEN +# define SQLITE_MAX_PATHLEN FILENAME_MAX +#endif + /* ** The default size of a disk sector */ @@ -16888,6 +16453,11 @@ SQLITE_PRIVATE void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**); #endif /* SQLITE_OMIT_DEPRECATED */ #define SQLITE_TRACE_NONLEGACY_MASK 0x0f /* Normal flags */ +/* +** Maximum number of sqlite3.aDb[] entries. This is the number of attached +** databases plus 2 for "main" and "temp". +*/ +#define SQLITE_MAX_DB (SQLITE_MAX_ATTACHED+2) /* ** Each database connection is an instance of the following structure. @@ -16908,7 +16478,7 @@ struct sqlite3 { int errCode; /* Most recent error code (SQLITE_*) */ int errMask; /* & result codes with this before returning */ int iSysErrno; /* Errno value from last system error */ - u16 dbOptFlags; /* Flags to enable/disable optimizations */ + u32 dbOptFlags; /* Flags to enable/disable optimizations */ u8 enc; /* Text encoding */ u8 autoCommit; /* The auto-commit flag. */ u8 temp_store; /* 1: file 2: memory 0: default */ @@ -16922,10 +16492,10 @@ struct sqlite3 { u8 mTrace; /* zero or more SQLITE_TRACE flags */ u8 noSharedCache; /* True if no shared-cache backends */ u8 nSqlExec; /* Number of pending OP_SqlExec opcodes */ + u8 eOpenState; /* Current condition of the connection */ int nextPagesize; /* Pagesize after VACUUM if >0 */ - u32 magic; /* Magic number for detect library misuse */ - int nChange; /* Value returned by sqlite3_changes() */ - int nTotalChange; /* Value returned by sqlite3_total_changes() */ + i64 nChange; /* Value returned by sqlite3_changes() */ + i64 nTotalChange; /* Value returned by sqlite3_total_changes() */ int aLimit[SQLITE_N_LIMIT]; /* Limits */ int nMaxSorterMmap; /* Maximum size of regions mapped by sorter */ struct sqlite3InitInfo { /* Information used during initialization */ @@ -16935,7 +16505,7 @@ struct sqlite3 { unsigned orphanTrigger : 1; /* Last statement is orphaned TEMP trigger */ unsigned imposterTable : 1; /* Building an imposter table */ unsigned reopenMemdb : 1; /* ATTACH is really a reopen using MemDB */ - char **azInit; /* "type", "name", and "tbl_name" columns */ + const char **azInit; /* "type", "name", and "tbl_name" columns */ } init; int nVdbeActive; /* Number of VDBEs currently running */ int nVdbeRead; /* Number of active VDBEs that read or write */ @@ -16945,10 +16515,10 @@ struct sqlite3 { int nExtension; /* Number of loaded extensions */ void **aExtension; /* Array of shared library handles */ union { - void (*xLegacy)(void*,const char*); /* Legacy trace function */ - int (*xV2)(u32,void*,void*,void*); /* V2 Trace function */ + void (*xLegacy)(void*,const char*); /* mTrace==SQLITE_TRACE_LEGACY */ + int (*xV2)(u32,void*,void*,void*); /* All other mTrace values */ } trace; - void *pTraceArg; /* Argument to the trace function */ + void *pTraceArg; /* Argument to the trace function */ #ifndef SQLITE_OMIT_DEPRECATED void (*xProfile)(void*,const char*,u64); /* Profiling function */ void *pProfileArg; /* Argument to profile function */ @@ -16959,6 +16529,9 @@ struct sqlite3 { void (*xRollbackCallback)(void*); /* Invoked at every commit. */ void *pUpdateArg; void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); + void *pAutovacPagesArg; /* Client argument to autovac_pages */ + void (*xAutovacDestr)(void*); /* Destructor for pAutovacPAgesArg */ + unsigned int (*xAutovacPages)(void*,const char*,u32,u32,u32); Parse *pParse; /* Current parse */ #ifdef SQLITE_ENABLE_PREUPDATE_HOOK void *pPreUpdateArg; /* First argument to xPreUpdateCallback */ @@ -17088,6 +16661,7 @@ struct sqlite3 { #define SQLITE_CountRows HI(0x00001) /* Count rows changed by INSERT, */ /* DELETE, or UPDATE and return */ /* the count using a callback. */ +#define SQLITE_CorruptRdOnly HI(0x00002) /* Prohibit writes due to error */ /* Flags used only if debugging */ #ifdef SQLITE_DEBUG @@ -17115,24 +16689,28 @@ struct sqlite3 { ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to ** selectively disable various optimizations. */ -#define SQLITE_QueryFlattener 0x0001 /* Query flattening */ -#define SQLITE_WindowFunc 0x0002 /* Use xInverse for window functions */ -#define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */ -#define SQLITE_FactorOutConst 0x0008 /* Constant factoring */ -#define SQLITE_DistinctOpt 0x0010 /* DISTINCT using indexes */ -#define SQLITE_CoverIdxScan 0x0020 /* Covering index scans */ -#define SQLITE_OrderByIdxJoin 0x0040 /* ORDER BY of joins via index */ -#define SQLITE_Transitive 0x0080 /* Transitive constraints */ -#define SQLITE_OmitNoopJoin 0x0100 /* Omit unused tables in joins */ -#define SQLITE_CountOfView 0x0200 /* The count-of-view optimization */ -#define SQLITE_CursorHints 0x0400 /* Add OP_CursorHint opcodes */ -#define SQLITE_Stat4 0x0800 /* Use STAT4 data */ - /* TH3 expects the Stat4 ^^^^^^ value to be 0x0800. Don't change it */ -#define SQLITE_PushDown 0x1000 /* The push-down optimization */ -#define SQLITE_SimplifyJoin 0x2000 /* Convert LEFT JOIN to JOIN */ -#define SQLITE_SkipScan 0x4000 /* Skip-scans */ -#define SQLITE_PropagateConst 0x8000 /* The constant propagation opt */ -#define SQLITE_AllOpts 0xffff /* All optimizations */ +#define SQLITE_QueryFlattener 0x00000001 /* Query flattening */ +#define SQLITE_WindowFunc 0x00000002 /* Use xInverse for window functions */ +#define SQLITE_GroupByOrder 0x00000004 /* GROUPBY cover of ORDERBY */ +#define SQLITE_FactorOutConst 0x00000008 /* Constant factoring */ +#define SQLITE_DistinctOpt 0x00000010 /* DISTINCT using indexes */ +#define SQLITE_CoverIdxScan 0x00000020 /* Covering index scans */ +#define SQLITE_OrderByIdxJoin 0x00000040 /* ORDER BY of joins via index */ +#define SQLITE_Transitive 0x00000080 /* Transitive constraints */ +#define SQLITE_OmitNoopJoin 0x00000100 /* Omit unused tables in joins */ +#define SQLITE_CountOfView 0x00000200 /* The count-of-view optimization */ +#define SQLITE_CursorHints 0x00000400 /* Add OP_CursorHint opcodes */ +#define SQLITE_Stat4 0x00000800 /* Use STAT4 data */ + /* TH3 expects this value ^^^^^^^^^^ to be 0x0000800. Don't change it */ +#define SQLITE_PushDown 0x00001000 /* The push-down optimization */ +#define SQLITE_SimplifyJoin 0x00002000 /* Convert LEFT JOIN to JOIN */ +#define SQLITE_SkipScan 0x00004000 /* Skip-scans */ +#define SQLITE_PropagateConst 0x00008000 /* The constant propagation opt */ +#define SQLITE_MinMaxOpt 0x00010000 /* The min/max optimization */ +#define SQLITE_SeekScan 0x00020000 /* The OP_SeekScan optimization */ +#define SQLITE_OmitOrderBy 0x00040000 /* Omit pointless ORDER BY */ + /* TH3 expects this value ^^^^^^^^^^ to be 0x40000. Coordinate any change */ +#define SQLITE_AllOpts 0xffffffff /* All optimizations */ /* ** Macros for testing whether or not optimizations are enabled or disabled. @@ -17146,17 +16724,16 @@ struct sqlite3 { */ #define ConstFactorOk(P) ((P)->okConstFactor) -/* -** Possible values for the sqlite.magic field. -** The numbers are obtained at random and have no special meaning, other -** than being distinct from one another. +/* Possible values for the sqlite3.eOpenState field. +** The numbers are randomly selected such that a minimum of three bits must +** change to convert any number to another or to zero */ -#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ -#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ -#define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */ -#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ -#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ -#define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */ +#define SQLITE_STATE_OPEN 0x76 /* Database is open */ +#define SQLITE_STATE_CLOSED 0xce /* Database is closed */ +#define SQLITE_STATE_SICK 0xba /* Error and awaiting close */ +#define SQLITE_STATE_BUSY 0x6d /* Database currently in use */ +#define SQLITE_STATE_ERROR 0xd5 /* An SQLITE_MISUSE error occurred */ +#define SQLITE_STATE_ZOMBIE 0xa7 /* Close with last statement close */ /* ** Each SQL function is defined by an instance of the following @@ -17181,7 +16758,7 @@ struct FuncDef { union { FuncDef *pHash; /* Next with a different name but the same hash */ FuncDestructor *pDestructor; /* Reference counted destructor function */ - } u; + } u; /* pHash if SQLITE_FUNC_BUILTIN, pDestructor otherwise */ }; /* @@ -17211,12 +16788,13 @@ struct FuncDestructor { ** are assert() statements in the code to verify this. ** ** Value constraints (enforced via assert()): -** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg -** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG -** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG -** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API -** SQLITE_FUNC_DIRECT == SQLITE_DIRECTONLY from the API -** SQLITE_FUNC_UNSAFE == SQLITE_INNOCUOUS +** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg +** SQLITE_FUNC_ANYORDER == NC_OrderAgg == SF_OrderByReqd +** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG +** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG +** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API +** SQLITE_FUNC_DIRECT == SQLITE_DIRECTONLY from the API +** SQLITE_FUNC_UNSAFE == SQLITE_INNOCUOUS ** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API */ #define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */ @@ -17241,6 +16819,8 @@ struct FuncDestructor { #define SQLITE_FUNC_SUBTYPE 0x00100000 /* Result likely to have sub-type */ #define SQLITE_FUNC_UNSAFE 0x00200000 /* Function has side effects */ #define SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */ +#define SQLITE_FUNC_BUILTIN 0x00800000 /* This is a built-in function */ +#define SQLITE_FUNC_ANYORDER 0x08000000 /* count/min/max aggregate */ /* Identifier numbers for each in-line function */ #define INLINEFUNC_coalesce 0 @@ -17288,6 +16868,9 @@ struct FuncDestructor { ** a single query. The iArg is ignored. The user-data is always set ** to a NULL pointer. The bNC parameter is not used. ** +** MFUNCTION(zName, nArg, xPtr, xFunc) +** For math-library functions. xPtr is an arbitrary pointer. +** ** PURE_DATE(zName, nArg, iArg, bNC, xFunc) ** Used for "pure" date/time functions, this macro is like DFUNCTION ** except that it does set the SQLITE_FUNC_CONSTANT flags. iArg is @@ -17315,41 +16898,51 @@ struct FuncDestructor { ** parameter. */ #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ - {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \ - {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \ - {nArg, SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \ SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define MFUNCTION(zName, nArg, xPtr, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \ + xPtr, 0, xFunc, 0, 0, 0, #zName, {0} } #define INLINE_FUNC(zName, nArg, iArg, mFlags) \ - {nArg, SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \ SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} } #define TEST_FUNC(zName, nArg, iArg, mFlags) \ - {nArg, SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \ SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \ SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} } #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \ - {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \ 0, 0, xFunc, 0, 0, 0, #zName, {0} } #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \ - {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \ (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} } #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ - {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\ SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ - {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ pArg, 0, xFunc, 0, 0, 0, #zName, } #define LIKEFUNC(zName, nArg, arg, flags) \ - {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \ (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} } #define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \ - {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \ SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}} #define INTERNAL_FUNCTION(zName, nArg, xFunc) \ - {nArg, SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \ 0, 0, xFunc, 0, 0, 0, #zName, {0} } @@ -17405,19 +16998,48 @@ struct Module { ** or equal to the table column index. It is ** equal if and only if there are no VIRTUAL ** columns to the left. +** +** Notes on zCnName: +** The zCnName field stores the name of the column, the datatype of the +** column, and the collating sequence for the column, in that order, all in +** a single allocation. Each string is 0x00 terminated. The datatype +** is only included if the COLFLAG_HASTYPE bit of colFlags is set and the +** collating sequence name is only included if the COLFLAG_HASCOLL bit is +** set. */ struct Column { - char *zName; /* Name of this column, \000, then the type */ - Expr *pDflt; /* Default value or GENERATED ALWAYS AS value */ - char *zColl; /* Collating sequence. If NULL, use the default */ - u8 notNull; /* An OE_ code for handling a NOT NULL constraint */ - char affinity; /* One of the SQLITE_AFF_... values */ - u8 szEst; /* Estimated size of value in this column. sizeof(INT)==1 */ - u8 hName; /* Column name hash for faster lookup */ - u16 colFlags; /* Boolean properties. See COLFLAG_ defines below */ + char *zCnName; /* Name of this column */ + unsigned notNull :4; /* An OE_ code for handling a NOT NULL constraint */ + unsigned eCType :4; /* One of the standard types */ + char affinity; /* One of the SQLITE_AFF_... values */ + u8 szEst; /* Est size of value in this column. sizeof(INT)==1 */ + u8 hName; /* Column name hash for faster lookup */ + u16 iDflt; /* 1-based index of DEFAULT. 0 means "none" */ + u16 colFlags; /* Boolean properties. See COLFLAG_ defines below */ }; -/* Allowed values for Column.colFlags: +/* Allowed values for Column.eCType. +** +** Values must match entries in the global constant arrays +** sqlite3StdTypeLen[] and sqlite3StdType[]. Each value is one more +** than the offset into these arrays for the corresponding name. +** Adjust the SQLITE_N_STDTYPE value if adding or removing entries. +*/ +#define COLTYPE_CUSTOM 0 /* Type appended to zName */ +#define COLTYPE_ANY 1 +#define COLTYPE_BLOB 2 +#define COLTYPE_INT 3 +#define COLTYPE_INTEGER 4 +#define COLTYPE_REAL 5 +#define COLTYPE_TEXT 6 +#define SQLITE_N_STDTYPE 6 /* Number of standard types */ + +/* Allowed values for Column.colFlags. +** +** Constraints: +** TF_HasVirtual == COLFLAG_VIRTUAL +** TF_HasStored == COLFLAG_STORED +** TF_HasHidden == COLFLAG_HIDDEN */ #define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */ #define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */ @@ -17428,6 +17050,7 @@ struct Column { #define COLFLAG_STORED 0x0040 /* GENERATED ALWAYS AS ... STORED */ #define COLFLAG_NOTAVAIL 0x0080 /* STORED column not yet calculated */ #define COLFLAG_BUSY 0x0100 /* Blocks recursion on GENERATED columns */ +#define COLFLAG_HASCOLL 0x0200 /* Has collating sequence name in zCnName */ #define COLFLAG_GENERATED 0x0060 /* Combo: _STORED, _VIRTUAL */ #define COLFLAG_NOINSERT 0x0062 /* Combo: _HIDDEN, _STORED, _VIRTUAL */ @@ -17493,9 +17116,7 @@ struct CollSeq { ** operator is NULL. It is added to certain comparison operators to ** prove that the operands are always NOT NULL. */ -#define SQLITE_KEEPNULL 0x08 /* Used by vector == or <> */ #define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */ -#define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */ #define SQLITE_NULLEQ 0x80 /* NULL=NULL */ #define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */ @@ -17559,15 +17180,13 @@ struct VTable { #define SQLITE_VTABRISK_High 2 /* -** The schema for each SQL table and view is represented in memory -** by an instance of the following structure. +** The schema for each SQL table, virtual table, and view is represented +** in memory by an instance of the following structure. */ struct Table { char *zName; /* Name of the table or view */ Column *aCol; /* Information about each column */ Index *pIndex; /* List of SQL indexes on this table. */ - Select *pSelect; /* NULL for tables. Points to definition if a view. */ - FKey *pFKey; /* Linked list of all foreign keys in this table */ char *zColAff; /* String defining the affinity of each column */ ExprList *pCheck; /* All CHECK constraints */ /* ... also used as column name list in a VIEW */ @@ -17583,17 +17202,25 @@ struct Table { LogEst costMult; /* Cost multiplier for using this table */ #endif u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ -#ifndef SQLITE_OMIT_ALTERTABLE - int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ -#endif -#ifndef SQLITE_OMIT_VIRTUALTABLE - int nModuleArg; /* Number of arguments to the module */ - char **azModuleArg; /* 0: module 1: schema 2: vtab name 3...: args */ - VTable *pVTable; /* List of VTable objects. */ -#endif - Trigger *pTrigger; /* List of triggers stored in pSchema */ + u8 eTabType; /* 0: normal, 1: virtual, 2: view */ + union { + struct { /* Used by ordinary tables: */ + int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ + FKey *pFKey; /* Linked list of all foreign keys in this table */ + ExprList *pDfltList; /* DEFAULT clauses on various columns. + ** Or the AS clause for generated columns. */ + } tab; + struct { /* Used by views: */ + Select *pSelect; /* View definition */ + } view; + struct { /* Used by virtual tables only: */ + int nArg; /* Number of arguments to the module */ + char **azArg; /* 0: module 1: schema 2: vtab name 3...: args */ + VTable *p; /* List of VTable objects. */ + } vtab; + } u; + Trigger *pTrigger; /* List of triggers on this object */ Schema *pSchema; /* Schema that contains this table */ - Table *pNextZombie; /* Next on the Parse.pZombieTab list */ }; /* @@ -17607,25 +17234,39 @@ struct Table { ** ** Constraints: ** -** TF_HasVirtual == COLFLAG_Virtual -** TF_HasStored == COLFLAG_Stored -*/ -#define TF_Readonly 0x0001 /* Read-only system table */ -#define TF_Ephemeral 0x0002 /* An ephemeral table */ -#define TF_HasPrimaryKey 0x0004 /* Table has a primary key */ -#define TF_Autoincrement 0x0008 /* Integer primary key is autoincrement */ -#define TF_HasStat1 0x0010 /* nRowLogEst set from sqlite_stat1 */ -#define TF_HasVirtual 0x0020 /* Has one or more VIRTUAL columns */ -#define TF_HasStored 0x0040 /* Has one or more STORED columns */ -#define TF_HasGenerated 0x0060 /* Combo: HasVirtual + HasStored */ -#define TF_WithoutRowid 0x0080 /* No rowid. PRIMARY KEY is the key */ -#define TF_StatsUsed 0x0100 /* Query planner decisions affected by +** TF_HasVirtual == COLFLAG_VIRTUAL +** TF_HasStored == COLFLAG_STORED +** TF_HasHidden == COLFLAG_HIDDEN +*/ +#define TF_Readonly 0x00000001 /* Read-only system table */ +#define TF_HasHidden 0x00000002 /* Has one or more hidden columns */ +#define TF_HasPrimaryKey 0x00000004 /* Table has a primary key */ +#define TF_Autoincrement 0x00000008 /* Integer primary key is autoincrement */ +#define TF_HasStat1 0x00000010 /* nRowLogEst set from sqlite_stat1 */ +#define TF_HasVirtual 0x00000020 /* Has one or more VIRTUAL columns */ +#define TF_HasStored 0x00000040 /* Has one or more STORED columns */ +#define TF_HasGenerated 0x00000060 /* Combo: HasVirtual + HasStored */ +#define TF_WithoutRowid 0x00000080 /* No rowid. PRIMARY KEY is the key */ +#define TF_StatsUsed 0x00000100 /* Query planner decisions affected by ** Index.aiRowLogEst[] values */ -#define TF_NoVisibleRowid 0x0200 /* No user-visible "rowid" column */ -#define TF_OOOHidden 0x0400 /* Out-of-Order hidden columns */ -#define TF_HasNotNull 0x0800 /* Contains NOT NULL constraints */ -#define TF_Shadow 0x1000 /* True for a shadow table */ -#define TF_HasStat4 0x2000 /* STAT4 info available for this table */ +#define TF_NoVisibleRowid 0x00000200 /* No user-visible "rowid" column */ +#define TF_OOOHidden 0x00000400 /* Out-of-Order hidden columns */ +#define TF_HasNotNull 0x00000800 /* Contains NOT NULL constraints */ +#define TF_Shadow 0x00001000 /* True for a shadow table */ +#define TF_HasStat4 0x00002000 /* STAT4 info available for this table */ +#define TF_Ephemeral 0x00004000 /* An ephemeral table */ +#define TF_Eponymous 0x00008000 /* An eponymous virtual table */ +#define TF_Strict 0x00010000 /* STRICT mode */ + +/* +** Allowed values for Table.eTabType +*/ +#define TABTYP_NORM 0 /* Ordinary table */ +#define TABTYP_VTAB 1 /* Virtual table */ +#define TABTYP_VIEW 2 /* A view */ + +#define IsView(X) ((X)->eTabType==TABTYP_VIEW) +#define IsOrdinaryTable(X) ((X)->eTabType==TABTYP_NORM) /* ** Test to see whether or not a table is a virtual table. This is @@ -17633,9 +17274,9 @@ struct Table { ** table support is omitted from the build. */ #ifndef SQLITE_OMIT_VIRTUALTABLE -# define IsVirtual(X) ((X)->nModuleArg) +# define IsVirtual(X) ((X)->eTabType==TABTYP_VTAB) # define ExprIsVtab(X) \ - ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->nModuleArg) + ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->eTabType==TABTYP_VTAB) #else # define IsVirtual(X) 0 # define ExprIsVtab(X) 0 @@ -17722,16 +17363,22 @@ struct FKey { ** is returned. REPLACE means that preexisting database rows that caused ** a UNIQUE constraint violation are removed so that the new insert or ** update can proceed. Processing continues and no error is reported. +** UPDATE applies to insert operations only and means that the insert +** is omitted and the DO UPDATE clause of an upsert is run instead. ** -** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. +** RESTRICT, SETNULL, SETDFLT, and CASCADE actions apply only to foreign keys. ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the ** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign -** key is set to NULL. CASCADE means that a DELETE or UPDATE of the +** key is set to NULL. SETDFLT means that the foreign key is set +** to its default value. CASCADE means that a DELETE or UPDATE of the ** referenced table row is propagated into the row that holds the ** foreign key. ** +** The OE_Default value is a place holder that means to use whatever +** conflict resolution algorthm is required from context. +** ** The following symbolic values are used to record which type -** of action to take. +** of conflict resolution action to take. */ #define OE_None 0 /* There is no constraint to check */ #define OE_Rollback 1 /* Fail the operation and rollback the transaction */ @@ -17985,10 +17632,10 @@ struct AggInfo { FuncDef *pFunc; /* The aggregate function implementation */ int iMem; /* Memory location that acts as accumulator */ int iDistinct; /* Ephemeral table used to enforce DISTINCT */ + int iDistAddr; /* Address of OP_OpenEphemeral */ } *aFunc; int nFunc; /* Number of entries in aFunc[] */ u32 selId; /* Select to which this AggInfo belongs */ - AggInfo *pNext; /* Next in list of them all */ }; /* @@ -18018,10 +17665,10 @@ typedef int ynVar; ** tree. ** ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, -** or TK_STRING), then Expr.token contains the text of the SQL literal. If -** the expression is a variable (TK_VARIABLE), then Expr.token contains the +** or TK_STRING), then Expr.u.zToken contains the text of the SQL literal. If +** the expression is a variable (TK_VARIABLE), then Expr.u.zToken contains the ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION), -** then Expr.token contains the name of the function. +** then Expr.u.zToken contains the name of the function. ** ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a ** binary operator. Either or both may be NULL. @@ -18061,7 +17708,7 @@ typedef int ynVar; ** help reduce memory requirements, sometimes an Expr object will be ** truncated. And to reduce the number of memory allocations, sometimes ** two or more Expr objects will be stored in a single memory allocation, -** together with Expr.zToken strings. +** together with Expr.u.zToken strings. ** ** If the EP_Reduced and EP_TokenOnly flags are set when ** an Expr object is truncated. When EP_Reduced is set, then all @@ -18117,7 +17764,7 @@ struct Expr { ** TK_VARIABLE: variable number (always >= 1). ** TK_SELECT_COLUMN: column of the result vector */ i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */ - i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */ + int iRightJoinTable; /* If EP_FromJoin, the right table of the join */ AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */ union { Table *pTab; /* TK_COLUMN: Table containing column. Can be NULL @@ -18130,8 +17777,7 @@ struct Expr { } y; }; -/* -** The following are the meanings of bits in the Expr.flags field. +/* The following are the meanings of bits in the Expr.flags field. ** Value restrictions: ** ** EP_Agg == NC_HasAgg == SF_HasAgg @@ -18159,7 +17805,7 @@ struct Expr { #define EP_ConstFunc 0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */ #define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */ #define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */ -#define EP_Alias 0x400000 /* Is an alias for a result set column */ + /* 0x400000 // Available */ #define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */ #define EP_WinFunc 0x1000000 /* TK_FUNCTION with Expr.y.pWin set */ #define EP_Subrtn 0x2000000 /* Uses Expr.y.sub. TK_IN, _SELECT, or _EXISTS */ @@ -18170,14 +17816,12 @@ struct Expr { #define EP_FromDDL 0x40000000 /* Originates from sqlite_schema */ /* 0x80000000 // Available */ -/* -** The EP_Propagate mask is a set of properties that automatically propagate +/* The EP_Propagate mask is a set of properties that automatically propagate ** upwards into parent nodes. */ #define EP_Propagate (EP_Collate|EP_Subquery|EP_HasFunc) -/* -** These macros can be used to test, set, or clear bits in the +/* Macros can be used to test, set, or clear bits in the ** Expr.flags field. */ #define ExprHasProperty(E,P) (((E)->flags&(P))!=0) @@ -18187,6 +17831,16 @@ struct Expr { #define ExprAlwaysTrue(E) (((E)->flags&(EP_FromJoin|EP_IsTrue))==EP_IsTrue) #define ExprAlwaysFalse(E) (((E)->flags&(EP_FromJoin|EP_IsFalse))==EP_IsFalse) +/* Macros used to ensure that the correct members of unions are accessed +** in Expr. +*/ +#define ExprUseUToken(E) (((E)->flags&EP_IntValue)==0) +#define ExprUseUValue(E) (((E)->flags&EP_IntValue)!=0) +#define ExprUseXList(E) (((E)->flags&EP_xIsSelect)==0) +#define ExprUseXSelect(E) (((E)->flags&EP_xIsSelect)!=0) +#define ExprUseYTab(E) (((E)->flags&(EP_WinFunc|EP_Subrtn))==0) +#define ExprUseYWin(E) (((E)->flags&EP_WinFunc)!=0) +#define ExprUseYSub(E) (((E)->flags&EP_Subrtn)!=0) /* Flags for use with Expr.vvaFlags */ @@ -18258,6 +17912,7 @@ struct Expr { */ struct ExprList { int nExpr; /* Number of expressions on the list */ + int nAlloc; /* Number of a[] slots allocated */ struct ExprList_item { /* For each expression in the list */ Expr *pExpr; /* The parse tree for this expression */ char *zEName; /* Token associated with this expression */ @@ -18268,11 +17923,12 @@ struct ExprList { unsigned bSorterRef :1; /* Defer evaluation until after sorting */ unsigned bNulls: 1; /* True if explicit "NULLS FIRST/LAST" */ union { - struct { + struct { /* Used by any ExprList other than Parse.pConsExpr */ u16 iOrderByCol; /* For ORDER BY, column number in result set */ u16 iAlias; /* Index into Parse.aAlias[] for zName */ } x; - int iConstExprReg; /* Register in which Expr value is cached */ + int iConstExprReg; /* Register in which Expr value is cached. Used only + ** by Parse.pConstExpr */ } u; } a[1]; /* One slot for each expression in the list */ }; @@ -18307,6 +17963,53 @@ struct IdList { int nId; /* Number of identifiers on the list */ }; +/* +** The SrcItem object represents a single term in the FROM clause of a query. +** The SrcList object is mostly an array of SrcItems. +** +** Union member validity: +** +** u1.zIndexedBy fg.isIndexedBy && !fg.isTabFunc +** u1.pFuncArg fg.isTabFunc && !fg.isIndexedBy +** u2.pIBIndex fg.isIndexedBy && !fg.isCte +** u2.pCteUse fg.isCte && !fg.isIndexedBy +*/ +struct SrcItem { + Schema *pSchema; /* Schema to which this item is fixed */ + char *zDatabase; /* Name of database holding this table */ + char *zName; /* Name of the table */ + char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ + Table *pTab; /* An SQL table corresponding to zName */ + Select *pSelect; /* A SELECT statement used in place of a table name */ + int addrFillSub; /* Address of subroutine to manifest a subquery */ + int regReturn; /* Register holding return address of addrFillSub */ + int regResult; /* Registers holding results of a co-routine */ + struct { + u8 jointype; /* Type of join between this table and the previous */ + unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */ + unsigned isIndexedBy :1; /* True if there is an INDEXED BY clause */ + unsigned isTabFunc :1; /* True if table-valued-function syntax */ + unsigned isCorrelated :1; /* True if sub-query is correlated */ + unsigned viaCoroutine :1; /* Implemented as a co-routine */ + unsigned isRecursive :1; /* True for recursive reference in WITH */ + unsigned fromDDL :1; /* Comes from sqlite_schema */ + unsigned isCte :1; /* This is a CTE */ + unsigned notCte :1; /* This item may not match a CTE */ + } fg; + int iCursor; /* The VDBE cursor number used to access this table */ + Expr *pOn; /* The ON clause of a join */ + IdList *pUsing; /* The USING clause of a join */ + Bitmask colUsed; /* Bit N (1<" clause */ + ExprList *pFuncArg; /* Arguments to table-valued-function */ + } u1; + union { + Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */ + CteUse *pCteUse; /* CTE Usage info info fg.isCte is true */ + } u2; +}; + /* ** The following structure describes the FROM clause of a SELECT statement. ** Each table or subquery in the FROM clause is a separate element of @@ -18329,36 +18032,7 @@ struct IdList { struct SrcList { int nSrc; /* Number of tables or subqueries in the FROM clause */ u32 nAlloc; /* Number of entries allocated in a[] below */ - struct SrcList_item { - Schema *pSchema; /* Schema to which this item is fixed */ - char *zDatabase; /* Name of database holding this table */ - char *zName; /* Name of the table */ - char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ - Table *pTab; /* An SQL table corresponding to zName */ - Select *pSelect; /* A SELECT statement used in place of a table name */ - int addrFillSub; /* Address of subroutine to manifest a subquery */ - int regReturn; /* Register holding return address of addrFillSub */ - int regResult; /* Registers holding results of a co-routine */ - struct { - u8 jointype; /* Type of join between this table and the previous */ - unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */ - unsigned isIndexedBy :1; /* True if there is an INDEXED BY clause */ - unsigned isTabFunc :1; /* True if table-valued-function syntax */ - unsigned isCorrelated :1; /* True if sub-query is correlated */ - unsigned viaCoroutine :1; /* Implemented as a co-routine */ - unsigned isRecursive :1; /* True for recursive reference in WITH */ - unsigned fromDDL :1; /* Comes from sqlite_schema */ - } fg; - int iCursor; /* The VDBE cursor number used to access this table */ - Expr *pOn; /* The ON clause of a join */ - IdList *pUsing; /* The USING clause of a join */ - Bitmask colUsed; /* Bit N (1<" clause */ - ExprList *pFuncArg; /* Arguments to table-valued-function */ - } u1; - Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */ - } a[1]; /* One entry for each identifier on the list */ + SrcItem a[1]; /* One entry for each identifier on the list */ }; /* @@ -18392,7 +18066,7 @@ struct SrcList { #define WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */ #define WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */ #define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */ - /* 0x0400 not currently used */ +#define WHERE_AGG_DISTINCT 0x0400 /* Query is "SELECT agg(DISTINCT ...)" */ #define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */ /* 0x1000 not currently used */ /* 0x2000 not currently used */ @@ -18434,10 +18108,11 @@ struct NameContext { ExprList *pEList; /* Optional list of result-set columns */ AggInfo *pAggInfo; /* Information about aggregates at this level */ Upsert *pUpsert; /* ON CONFLICT clause information from an upsert */ + int iBaseReg; /* For TK_REGISTER when parsing RETURNING */ } uNC; NameContext *pNext; /* Next outer name context. NULL for outermost */ int nRef; /* Number of names resolved by this context */ - int nErr; /* Number of errors encountered while resolving names */ + int nNcErr; /* Number of errors encountered while resolving names */ int ncFlags; /* Zero or more NC_* flags defined below */ Select *pWinSelect; /* SELECT statement for any window functions */ }; @@ -18446,29 +18121,33 @@ struct NameContext { ** Allowed values for the NameContext, ncFlags field. ** ** Value constraints (all checked via assert()): -** NC_HasAgg == SF_HasAgg == EP_Agg -** NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX +** NC_HasAgg == SF_HasAgg == EP_Agg +** NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX +** NC_OrderAgg == SF_OrderByReqd == SQLITE_FUNC_ANYORDER ** NC_HasWin == EP_Win ** */ -#define NC_AllowAgg 0x00001 /* Aggregate functions are allowed here */ -#define NC_PartIdx 0x00002 /* True if resolving a partial index WHERE */ -#define NC_IsCheck 0x00004 /* True if resolving a CHECK constraint */ -#define NC_GenCol 0x00008 /* True for a GENERATED ALWAYS AS clause */ -#define NC_HasAgg 0x00010 /* One or more aggregate functions seen */ -#define NC_IdxExpr 0x00020 /* True if resolving columns of CREATE INDEX */ -#define NC_SelfRef 0x0002e /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */ -#define NC_VarSelect 0x00040 /* A correlated subquery has been seen */ -#define NC_UEList 0x00080 /* True if uNC.pEList is used */ -#define NC_UAggInfo 0x00100 /* True if uNC.pAggInfo is used */ -#define NC_UUpsert 0x00200 /* True if uNC.pUpsert is used */ -#define NC_MinMaxAgg 0x01000 /* min/max aggregates seen. See note above */ -#define NC_Complex 0x02000 /* True if a function or subquery seen */ -#define NC_AllowWin 0x04000 /* Window functions are allowed here */ -#define NC_HasWin 0x08000 /* One or more window functions seen */ -#define NC_IsDDL 0x10000 /* Resolving names in a CREATE statement */ -#define NC_InAggFunc 0x20000 /* True if analyzing arguments to an agg func */ -#define NC_FromDDL 0x40000 /* SQL text comes from sqlite_schema */ +#define NC_AllowAgg 0x000001 /* Aggregate functions are allowed here */ +#define NC_PartIdx 0x000002 /* True if resolving a partial index WHERE */ +#define NC_IsCheck 0x000004 /* True if resolving a CHECK constraint */ +#define NC_GenCol 0x000008 /* True for a GENERATED ALWAYS AS clause */ +#define NC_HasAgg 0x000010 /* One or more aggregate functions seen */ +#define NC_IdxExpr 0x000020 /* True if resolving columns of CREATE INDEX */ +#define NC_SelfRef 0x00002e /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */ +#define NC_VarSelect 0x000040 /* A correlated subquery has been seen */ +#define NC_UEList 0x000080 /* True if uNC.pEList is used */ +#define NC_UAggInfo 0x000100 /* True if uNC.pAggInfo is used */ +#define NC_UUpsert 0x000200 /* True if uNC.pUpsert is used */ +#define NC_UBaseReg 0x000400 /* True if uNC.iBaseReg is used */ +#define NC_MinMaxAgg 0x001000 /* min/max aggregates seen. See note above */ +#define NC_Complex 0x002000 /* True if a function or subquery seen */ +#define NC_AllowWin 0x004000 /* Window functions are allowed here */ +#define NC_HasWin 0x008000 /* One or more window functions seen */ +#define NC_IsDDL 0x010000 /* Resolving names in a CREATE statement */ +#define NC_InAggFunc 0x020000 /* True if analyzing arguments to an agg func */ +#define NC_FromDDL 0x040000 /* SQL text comes from sqlite_schema */ +#define NC_NoSelect 0x080000 /* Do not descend into sub-selects */ +#define NC_OrderAgg 0x8000000 /* Has an aggregate other than count/min/max */ /* ** An instance of the following object describes a single ON CONFLICT @@ -18485,15 +18164,21 @@ struct NameContext { ** WHERE clause is omitted. */ struct Upsert { - ExprList *pUpsertTarget; /* Optional description of conflicting index */ + ExprList *pUpsertTarget; /* Optional description of conflict target */ Expr *pUpsertTargetWhere; /* WHERE clause for partial index targets */ ExprList *pUpsertSet; /* The SET clause from an ON CONFLICT UPDATE */ Expr *pUpsertWhere; /* WHERE clause for the ON CONFLICT UPDATE */ - /* The fields above comprise the parse tree for the upsert clause. - ** The fields below are used to transfer information from the INSERT - ** processing down into the UPDATE processing while generating code. - ** Upsert owns the memory allocated above, but not the memory below. */ - Index *pUpsertIdx; /* Constraint that pUpsertTarget identifies */ + Upsert *pNextUpsert; /* Next ON CONFLICT clause in the list */ + u8 isDoUpdate; /* True for DO UPDATE. False for DO NOTHING */ + /* Above this point is the parse tree for the ON CONFLICT clauses. + ** The next group of fields stores intermediate data. */ + void *pToFree; /* Free memory when deleting the Upsert object */ + /* All fields above are owned by the Upsert object and must be freed + ** when the Upsert is destroyed. The fields below are used to transfer + ** information from the INSERT processing down into the UPDATE processing + ** while generating code. The fields below are owned by the INSERT + ** statement and will be freed by INSERT processing. */ + Index *pUpsertIdx; /* UNIQUE constraint specified by pUpsertTarget */ SrcList *pUpsertSrc; /* Table to be updated */ int regData; /* First register holding array of VALUES */ int iDataCur; /* Index of the data cursor */ @@ -18545,9 +18230,10 @@ struct Select { ** "Select Flag". ** ** Value constraints (all checked via assert()) -** SF_HasAgg == NC_HasAgg -** SF_MinMaxAgg == NC_MinMaxAgg == SQLITE_FUNC_MINMAX -** SF_FixedLimit == WHERE_USE_LIMIT +** SF_HasAgg == NC_HasAgg +** SF_MinMaxAgg == NC_MinMaxAgg == SQLITE_FUNC_MINMAX +** SF_OrderByReqd == NC_OrderAgg == SQLITE_FUNC_ANYORDER +** SF_FixedLimit == WHERE_USE_LIMIT */ #define SF_Distinct 0x0000001 /* Output should be DISTINCT */ #define SF_All 0x0000002 /* Includes the ALL keyword */ @@ -18572,7 +18258,11 @@ struct Select { #define SF_WinRewrite 0x0100000 /* Window function rewrite accomplished */ #define SF_View 0x0200000 /* SELECT statement is a view */ #define SF_NoopOrderBy 0x0400000 /* ORDER BY is ignored for this query */ -#define SF_UpdateFrom 0x0800000 /* Statement is an UPDATE...FROM */ +#define SF_UFSrcCheck 0x0800000 /* Check pSrc as required by UPDATE...FROM */ +#define SF_PushDown 0x1000000 /* SELECT has be modified by push-down opt */ +#define SF_MultiPart 0x2000000 /* Has multiple incompatible PARTITIONs */ +#define SF_CopyCte 0x4000000 /* SELECT statement is a copy of a CTE */ +#define SF_OrderByReqd 0x8000000 /* The ORDER BY clause may not be omitted */ /* ** The results of a SELECT can be distributed in several ways, as defined @@ -18743,6 +18433,17 @@ struct TriggerPrg { # define DbMaskNonZero(M) (M)!=0 #endif +/* +** An instance of the ParseCleanup object specifies an operation that +** should be performed after parsing to deallocation resources obtained +** during the parse and which are no longer needed. +*/ +struct ParseCleanup { + ParseCleanup *pNext; /* Next cleanup task */ + void *pPtr; /* Pointer to object to deallocate */ + void (*xCleanup)(sqlite3*,void*); /* Deallocation routine */ +}; + /* ** An SQL parser context. A copy of this structure is passed through ** the parser and down into all the parser action routine in order to @@ -18774,6 +18475,9 @@ struct Parse { u8 okConstFactor; /* OK to factor out constants */ u8 disableLookaside; /* Number of times lookaside has been disabled */ u8 disableVtab; /* Disable all virtual tables for this parse */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) + u8 earlyCleanup; /* OOM inside sqlite3ParserAddCleanup() */ +#endif int nRangeReg; /* Size of the temporary register block */ int iRangeReg; /* First register in temporary register block */ int nErr; /* Number of errors seen */ @@ -18800,13 +18504,15 @@ struct Parse { AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */ Parse *pToplevel; /* Parse structure for main program (or NULL) */ Table *pTriggerTab; /* Table triggers are being coded for */ - Parse *pParentParse; /* Parent parser if this parser is nested */ - AggInfo *pAggList; /* List of all AggInfo objects */ - int addrCrTab; /* Address of OP_CreateBtree opcode on CREATE TABLE */ + union { + int addrCrTab; /* Address of OP_CreateBtree on CREATE TABLE */ + Returning *pReturning; /* The RETURNING clause */ + } u1; u32 nQueryLoop; /* Est number of iterations of a query (10*log2(N)) */ u32 oldmask; /* Mask of old.* columns referenced */ u32 newmask; /* Mask of new.* columns referenced */ u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */ + u8 bReturning; /* Coding a RETURNING trigger */ u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */ u8 disableTriggers; /* True to disable triggers */ @@ -18852,15 +18558,16 @@ struct Parse { Token sArg; /* Complete text of a module argument */ Table **apVtabLock; /* Pointer to virtual tables needing locking */ #endif - Table *pZombieTab; /* List of Table objects to delete after code gen */ TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */ With *pWith; /* Current WITH clause, or NULL */ - With *pWithToFree; /* Free this WITH object at the end of the parse */ + ParseCleanup *pCleanup; /* List of cleanup operations to run after parse */ #ifndef SQLITE_OMIT_ALTERTABLE RenameToken *pRename; /* Tokens subject to renaming by ALTER TABLE */ #endif }; +/* Allowed values for Parse.eParseMode +*/ #define PARSE_MODE_NORMAL 0 #define PARSE_MODE_DECLARE_VTAB 1 #define PARSE_MODE_RENAME 2 @@ -18935,6 +18642,7 @@ struct AuthContext { #define OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */ #define OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */ #define OPFLAG_NOCHNG_MAGIC 0x6d /* OP_MakeRecord: serialtype 10 is ok */ +#define OPFLAG_PREFORMAT 0x80 /* OP_Insert uses preformatted cell */ /* * Each trigger present in the database schema is stored as an instance of @@ -18956,6 +18664,7 @@ struct Trigger { char *table; /* The table or view to which the trigger applies */ u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */ u8 tr_tm; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */ + u8 bReturning; /* This trigger implements a RETURNING clause */ Expr *pWhen; /* The WHEN clause of the expression (may be NULL) */ IdList *pColumns; /* If this is an UPDATE OF trigger, the is stored here */ @@ -19014,14 +18723,15 @@ struct Trigger { * */ struct TriggerStep { - u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */ + u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT, + ** or TK_RETURNING */ u8 orconf; /* OE_Rollback etc. */ Trigger *pTrig; /* The trigger that this step is a part of */ Select *pSelect; /* SELECT statement or RHS of INSERT INTO SELECT ... */ char *zTarget; /* Target table for DELETE, UPDATE, INSERT */ SrcList *pFrom; /* FROM clause for UPDATE statement (if any) */ Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */ - ExprList *pExprList; /* SET clause for UPDATE */ + ExprList *pExprList; /* SET clause for UPDATE, or RETURNING clause */ IdList *pIdList; /* Column names for INSERT */ Upsert *pUpsert; /* Upsert clauses on an INSERT */ char *zSpan; /* Original SQL text of this command */ @@ -19030,18 +18740,16 @@ struct TriggerStep { }; /* -** The following structure contains information used by the sqliteFix... -** routines as they walk the parse tree to make database references -** explicit. +** Information about a RETURNING clause */ -typedef struct DbFixer DbFixer; -struct DbFixer { - Parse *pParse; /* The parsing context. Error messages written here */ - Schema *pSchema; /* Fix items to this schema */ - u8 bTemp; /* True for TEMP schema entries */ - const char *zDb; /* Make sure all objects are contained in this database */ - const char *zType; /* Type of the container - used for error messages */ - const Token *pName; /* Name of the container - used for error messages */ +struct Returning { + Parse *pParse; /* The parse that includes the RETURNING clause */ + ExprList *pReturnEL; /* List of expressions to return */ + Trigger retTrig; /* The transient trigger that implements RETURNING */ + TriggerStep retTStep; /* The trigger step */ + int iRetCur; /* Transient table holding RETURNING results */ + int nRetCol; /* Number of in pReturnEL after expansion */ + int iRetReg; /* Register array for holding a row of RETURNING */ }; /* @@ -19081,7 +18789,26 @@ typedef struct { /* ** Allowed values for mInitFlags */ -#define INITFLAG_AlterTable 0x0001 /* This is a reparse after ALTER TABLE */ +#define INITFLAG_AlterMask 0x0003 /* Types of ALTER */ +#define INITFLAG_AlterRename 0x0001 /* Reparse after a RENAME */ +#define INITFLAG_AlterDrop 0x0002 /* Reparse after a DROP COLUMN */ +#define INITFLAG_AlterAdd 0x0003 /* Reparse after an ADD COLUMN */ + +/* Tuning parameters are set using SQLITE_TESTCTRL_TUNE and are controlled +** on debug-builds of the CLI using ".testctrl tune ID VALUE". Tuning +** parameters are for temporary use during development, to help find +** optimial values for parameters in the query planner. The should not +** be used on trunk check-ins. They are a temporary mechanism available +** for transient development builds only. +** +** Tuning parameters are numbered starting with 1. +*/ +#define SQLITE_NTUNE 6 /* Should be zero for all trunk check-ins */ +#ifdef SQLITE_DEBUG +# define Tuning(X) (sqlite3Config.aTune[(X)-1]) +#else +# define Tuning(X) 0 +#endif /* ** Structure containing global configuration data for the SQLite library. @@ -19137,7 +18864,7 @@ struct Sqlite3Config { void (*xVdbeBranch)(void*,unsigned iSrcLine,u8 eThis,u8 eMx); /* Callback */ void *pVdbeBranchArg; /* 1st argument */ #endif -#ifdef SQLITE_ENABLE_DESERIALIZE +#ifndef SQLITE_OMIT_DESERIALIZE sqlite3_int64 mxMemdbSize; /* Default max memdb size */ #endif #ifndef SQLITE_UNTESTABLE @@ -19147,6 +18874,10 @@ struct Sqlite3Config { int iOnceResetThreshold; /* When to reset OP_Once counters */ u32 szSorterRef; /* Min size in bytes to use sorter-refs */ unsigned int iPrngSeed; /* Alternative fixed seed for the PRNG */ + /* vvvv--- must be last ---vvv */ +#ifdef SQLITE_DEBUG + sqlite3_int64 aTune[SQLITE_NTUNE]; /* Tuning parameters */ +#endif }; /* @@ -19182,8 +18913,8 @@ struct Walker { int n; /* A counter */ int iCur; /* A cursor number */ SrcList *pSrcList; /* FROM clause */ - struct SrcCount *pSrcCount; /* Counting column references */ struct CCurHint *pCCurHint; /* Used by codeCursorHint() */ + struct RefSrcList *pRefSrcList; /* sqlite3ReferencesSrcList() */ int *aiCol; /* array of column indexes */ struct IdxCover *pIdxCover; /* Check for index coverage */ struct IdxExprTrans *pIdxTrans; /* Convert idxed expr to column */ @@ -19193,10 +18924,26 @@ struct Walker { struct WhereConst *pConst; /* WHERE clause constants */ struct RenameCtx *pRename; /* RENAME COLUMN context */ struct Table *pTab; /* Table of generated column */ - struct SrcList_item *pSrcItem; /* A single FROM clause item */ + SrcItem *pSrcItem; /* A single FROM clause item */ + DbFixer *pFix; } u; }; +/* +** The following structure contains information used by the sqliteFix... +** routines as they walk the parse tree to make database references +** explicit. +*/ +struct DbFixer { + Parse *pParse; /* The parsing context. Error messages written here */ + Walker w; /* Walker object */ + Schema *pSchema; /* Fix items to this schema */ + u8 bTemp; /* True for TEMP schema entries */ + const char *zDb; /* Make sure all objects are contained in this database */ + const char *zType; /* Type of the container - used for error messages */ + const Token *pName; /* Name of the container - used for error messages */ +}; + /* Forward declarations */ SQLITE_PRIVATE int sqlite3WalkExpr(Walker*, Expr*); SQLITE_PRIVATE int sqlite3WalkExprList(Walker*, ExprList*); @@ -19208,11 +18955,18 @@ SQLITE_PRIVATE int sqlite3SelectWalkNoop(Walker*, Select*); SQLITE_PRIVATE int sqlite3SelectWalkFail(Walker*, Select*); SQLITE_PRIVATE int sqlite3WalkerDepthIncrease(Walker*,Select*); SQLITE_PRIVATE void sqlite3WalkerDepthDecrease(Walker*,Select*); +SQLITE_PRIVATE void sqlite3WalkWinDefnDummyCallback(Walker*,Select*); #ifdef SQLITE_DEBUG SQLITE_PRIVATE void sqlite3SelectWalkAssert2(Walker*, Select*); #endif +#ifndef SQLITE_OMIT_CTE +SQLITE_PRIVATE void sqlite3SelectPopWith(Walker*, Select*); +#else +# define sqlite3SelectPopWith 0 +#endif + /* ** Return code from the parse-tree walking primitives and their ** callbacks. @@ -19222,20 +18976,56 @@ SQLITE_PRIVATE void sqlite3SelectWalkAssert2(Walker*, Select*); #define WRC_Abort 2 /* Abandon the tree walk */ /* -** An instance of this structure represents a set of one or more CTEs -** (common table expressions) created by a single WITH clause. +** A single common table expression +*/ +struct Cte { + char *zName; /* Name of this CTE */ + ExprList *pCols; /* List of explicit column names, or NULL */ + Select *pSelect; /* The definition of this CTE */ + const char *zCteErr; /* Error message for circular references */ + CteUse *pUse; /* Usage information for this CTE */ + u8 eM10d; /* The MATERIALIZED flag */ +}; + +/* +** Allowed values for the materialized flag (eM10d): +*/ +#define M10d_Yes 0 /* AS MATERIALIZED */ +#define M10d_Any 1 /* Not specified. Query planner's choice */ +#define M10d_No 2 /* AS NOT MATERIALIZED */ + +/* +** An instance of the With object represents a WITH clause containing +** one or more CTEs (common table expressions). */ struct With { - int nCte; /* Number of CTEs in the WITH clause */ - With *pOuter; /* Containing WITH clause, or NULL */ - struct Cte { /* For each CTE in the WITH clause.... */ - char *zName; /* Name of this CTE */ - ExprList *pCols; /* List of explicit column names, or NULL */ - Select *pSelect; /* The definition of this CTE */ - const char *zCteErr; /* Error message for circular references */ - } a[1]; + int nCte; /* Number of CTEs in the WITH clause */ + int bView; /* Belongs to the outermost Select of a view */ + With *pOuter; /* Containing WITH clause, or NULL */ + Cte a[1]; /* For each CTE in the WITH clause.... */ }; +/* +** The Cte object is not guaranteed to persist for the entire duration +** of code generation. (The query flattener or other parser tree +** edits might delete it.) The following object records information +** about each Common Table Expression that must be preserved for the +** duration of the parse. +** +** The CteUse objects are freed using sqlite3ParserAddCleanup() rather +** than sqlite3SelectDelete(), which is what enables them to persist +** until the end of code generation. +*/ +struct CteUse { + int nUse; /* Number of users of this CTE */ + int addrM9e; /* Start of subroutine to compute materialization */ + int regRtn; /* Return address register for addrM9e subroutine */ + int iCur; /* Ephemeral table holding the materialization */ + LogEst nRowEst; /* Estimated number of rows in the table */ + u8 eM10d; /* The MATERIALIZED flag */ +}; + + #ifdef SQLITE_DEBUG /* ** An instance of the TreeView object is used for printing the content of @@ -19309,11 +19099,10 @@ SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p); SQLITE_PRIVATE Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8); SQLITE_PRIVATE void sqlite3WindowAttach(Parse*, Expr*, Window*); SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin); -SQLITE_PRIVATE int sqlite3WindowCompare(Parse*, Window*, Window*, int); +SQLITE_PRIVATE int sqlite3WindowCompare(const Parse*, const Window*, const Window*, int); SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse*, Select*); SQLITE_PRIVATE void sqlite3WindowCodeStep(Parse*, Select*, WhereInfo*, int, int); SQLITE_PRIVATE int sqlite3WindowRewrite(Parse*, Select*); -SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse*, struct SrcList_item*); SQLITE_PRIVATE void sqlite3WindowUpdate(Parse*, Window*, Window*, FuncDef*); SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p); SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p); @@ -19442,8 +19231,8 @@ SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *, void *, u64); SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *, void *, u64); SQLITE_PRIVATE void sqlite3DbFree(sqlite3*, void*); SQLITE_PRIVATE void sqlite3DbFreeNN(sqlite3*, void*); -SQLITE_PRIVATE int sqlite3MallocSize(void*); -SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, void*); +SQLITE_PRIVATE int sqlite3MallocSize(const void*); +SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, const void*); SQLITE_PRIVATE void *sqlite3PageMalloc(int); SQLITE_PRIVATE void sqlite3PageFree(void*); SQLITE_PRIVATE void sqlite3MemSetDefault(void); @@ -19559,6 +19348,7 @@ SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...); SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3*,int); SQLITE_PRIVATE void sqlite3Dequote(char*); SQLITE_PRIVATE void sqlite3DequoteExpr(Expr*); +SQLITE_PRIVATE void sqlite3DequoteToken(Token*); SQLITE_PRIVATE void sqlite3TokenInit(Token*,char*); SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int); SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*, char **); @@ -19578,15 +19368,17 @@ SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*); SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse*, Expr*, Select*); SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse*,Expr*, Expr*); SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr*); -SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*, int); -SQLITE_PRIVATE void sqlite3ExprFunctionUsable(Parse*,Expr*,FuncDef*); +SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, const Token*, int); +SQLITE_PRIVATE void sqlite3ExprFunctionUsable(Parse*,const Expr*,const FuncDef*); SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*, u32); SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*); +SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse*, Expr*); SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse*, Expr*); SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*); SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector(Parse*,ExprList*,IdList*,Expr*); +SQLITE_PRIVATE Select *sqlite3ExprListToValues(Parse*, int, ExprList*); SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList*,int,int); -SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int); +SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,const Token*,int); SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,const char*,const char*); SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*); SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList*); @@ -19602,7 +19394,12 @@ SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3*); SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3*,int); SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3*); SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*); +SQLITE_PRIVATE void sqlite3ColumnSetExpr(Parse*,Table*,Column*,Expr*); +SQLITE_PRIVATE Expr *sqlite3ColumnExpr(Table*,Column*); +SQLITE_PRIVATE void sqlite3ColumnSetColl(sqlite3*,Column*,const char*zColl); +SQLITE_PRIVATE const char *sqlite3ColumnColl(Column*); SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3*,Table*); +SQLITE_PRIVATE void sqlite3GenerateColumnNames(Parse *pParse, Select *pSelect); SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**); SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(Parse*,Table*,Select*,char); SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*,char); @@ -19622,14 +19419,15 @@ SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table*, Column*); #else # define sqlite3ColumnPropertiesFromName(T,C) /* no-op */ #endif -SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token*,Token*); +SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token,Token); SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int); SQLITE_PRIVATE void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int); SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*, const char*, const char*); SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,Expr*,const char*,const char*); SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*); SQLITE_PRIVATE void sqlite3AddGenerated(Parse*,Expr*,Token*); -SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,u8,Select*); +SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,u32,Select*); +SQLITE_PRIVATE void sqlite3AddReturning(Parse*,ExprList*); SQLITE_PRIVATE int sqlite3ParseUri(const char*,const char*,unsigned int*, sqlite3_vfs**,char**,char **); #define sqlite3CodecQueryParameters(A,B,C) 0 @@ -19695,7 +19493,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, T Token*, Select*, Expr*, IdList*); SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *); SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*); -SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *, struct SrcList_item *); +SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *, SrcItem *); SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList*); SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*); SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*); @@ -19723,6 +19521,7 @@ SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount(WhereInfo*); SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo*); SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo*); SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo*); +SQLITE_PRIVATE void sqlite3WhereMinMaxOptEarlyOut(Vdbe*,WhereInfo*); SQLITE_PRIVATE int sqlite3WhereIsSorted(WhereInfo*); SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo*); SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo*); @@ -19737,7 +19536,7 @@ SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int); SQLITE_PRIVATE void sqlite3ExprCode(Parse*, Expr*, int); #ifndef SQLITE_OMIT_GENERATED_COLUMNS -SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(Parse*, Column*, int); +SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(Parse*, Table*, Column*, int); #endif SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, Expr*, int); SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse*, Expr*, int); @@ -19756,23 +19555,24 @@ SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3*,const char*, const char*); #define LOCATE_VIEW 0x01 #define LOCATE_NOERR 0x02 SQLITE_PRIVATE Table *sqlite3LocateTable(Parse*,u32 flags,const char*, const char*); -SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,u32 flags,struct SrcList_item *); +SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char*); +SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,u32 flags,SrcItem *); SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3*,const char*, const char*); SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*); SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*); SQLITE_PRIVATE void sqlite3Vacuum(Parse*,Token*,Expr*); SQLITE_PRIVATE int sqlite3RunVacuum(char**, sqlite3*, int, sqlite3_value*); -SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, Token*); -SQLITE_PRIVATE int sqlite3ExprCompare(Parse*,Expr*, Expr*, int); -SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr*, Expr*, int); -SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList*, ExprList*, int); -SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Parse*,Expr*, Expr*, int); +SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, const Token*); +SQLITE_PRIVATE int sqlite3ExprCompare(const Parse*,const Expr*,const Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr*,Expr*,int); +SQLITE_PRIVATE int sqlite3ExprListCompare(const ExprList*,const ExprList*, int); +SQLITE_PRIVATE int sqlite3ExprImpliesExpr(const Parse*,const Expr*,const Expr*, int); SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr*,int); SQLITE_PRIVATE void sqlite3AggInfoPersistWalkerInit(Walker*,Parse*); SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*); SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*); SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(Expr*, int iCur, Index *pIdx); -SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr*, SrcList*); +SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse*, Expr*, SrcList*); SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*); #ifndef SQLITE_UNTESTABLE SQLITE_PRIVATE void sqlite3PrngSaveState(void); @@ -19797,7 +19597,7 @@ SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr*,int); #ifdef SQLITE_ENABLE_CURSOR_HINTS SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr*); #endif -SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr*, int*); +SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr*, int*); SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*); SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char); SQLITE_PRIVATE int sqlite3IsRowid(const char*); @@ -19822,11 +19622,11 @@ SQLITE_PRIVATE void sqlite3MayAbort(Parse*); SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, int, char*, i8, u8); SQLITE_PRIVATE void sqlite3UniqueConstraint(Parse*, int, Index*); SQLITE_PRIVATE void sqlite3RowidConstraint(Parse*, int, Table*); -SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,Expr*,int); -SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,ExprList*,int); -SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,SrcList*,int); -SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,IdList*); -SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,Select*,int); +SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,const Expr*,int); +SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,const ExprList*,int); +SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,const SrcList*,int); +SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,const IdList*); +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,const Select*,int); SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch(int,const char*); SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(FuncDef*,int); SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,u8,u8); @@ -19836,6 +19636,7 @@ SQLITE_PRIVATE void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3*); SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3*); SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3*); SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int); +SQLITE_PRIVATE With *sqlite3WithDup(sqlite3 *db, With *p); #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) SQLITE_PRIVATE void sqlite3MaterializeView(Parse*, Table*, Expr*, ExprList*,Expr*,int); @@ -19884,6 +19685,7 @@ SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc(Parse*, TriggerStep*); #endif SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*); +SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol); SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr*,int); SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int); SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int); @@ -19906,7 +19708,6 @@ SQLITE_PRIVATE void sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Tok SQLITE_PRIVATE int sqlite3FixSrcList(DbFixer*, SrcList*); SQLITE_PRIVATE int sqlite3FixSelect(DbFixer*, Select*); SQLITE_PRIVATE int sqlite3FixExpr(DbFixer*, Expr*); -SQLITE_PRIVATE int sqlite3FixExprList(DbFixer*, ExprList*); SQLITE_PRIVATE int sqlite3FixTriggerStep(DbFixer*, TriggerStep*); SQLITE_PRIVATE int sqlite3RealSameAsInt(double,sqlite3_int64); SQLITE_PRIVATE void sqlite3Int64ToText(i64,char*); @@ -19963,12 +19764,13 @@ SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3*, Index*); SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe*, Table*, int); SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2); SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity); -SQLITE_PRIVATE char sqlite3TableColumnAffinity(Table*,int); +SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table*,int); SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr); SQLITE_PRIVATE int sqlite3Atoi64(const char*, i64*, int, u8); SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char*, i64*); SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...); SQLITE_PRIVATE void sqlite3Error(sqlite3*,int); +SQLITE_PRIVATE void sqlite3ErrorClear(sqlite3*); SQLITE_PRIVATE void sqlite3SystemError(sqlite3*,int); SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n); SQLITE_PRIVATE u8 sqlite3HexToInt(int h); @@ -19978,7 +19780,7 @@ SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **); SQLITE_PRIVATE const char *sqlite3ErrName(int); #endif -#ifdef SQLITE_ENABLE_DESERIALIZE +#ifndef SQLITE_OMIT_DESERIALIZE SQLITE_PRIVATE int sqlite3MemdbInit(void); #endif @@ -19991,14 +19793,14 @@ SQLITE_PRIVATE void sqlite3SetTextEncoding(sqlite3 *db, u8); SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr); SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr); SQLITE_PRIVATE int sqlite3ExprCollSeqMatch(Parse*,const Expr*,const Expr*); -SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*, const Token*, int); -SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse*,Expr*,const char*); +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(const Parse *pParse, Expr*, const Token*, int); +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(const Parse*,Expr*,const char*); SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr*); SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr*); SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *, CollSeq *); SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3*); SQLITE_PRIVATE int sqlite3CheckObjectName(Parse*, const char*,const char*,const char*); -SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, int); +SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, i64); SQLITE_PRIVATE int sqlite3AddInt64(i64*,i64); SQLITE_PRIVATE int sqlite3SubInt64(i64*,i64); SQLITE_PRIVATE int sqlite3MulInt64(i64*,i64); @@ -20023,16 +19825,22 @@ SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *); #ifndef SQLITE_OMIT_UTF16 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8); #endif -SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **); +SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, const Expr *, u8, u8, sqlite3_value **); SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8); #ifndef SQLITE_AMALGAMATION SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[]; SQLITE_PRIVATE const char sqlite3StrBINARY[]; +SQLITE_PRIVATE const unsigned char sqlite3StdTypeLen[]; +SQLITE_PRIVATE const char sqlite3StdTypeAffinity[]; +SQLITE_PRIVATE const char sqlite3StdTypeMap[]; +SQLITE_PRIVATE const char *sqlite3StdType[]; SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[]; +SQLITE_PRIVATE const unsigned char *sqlite3aLTb; +SQLITE_PRIVATE const unsigned char *sqlite3aEQb; +SQLITE_PRIVATE const unsigned char *sqlite3aGTb; SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[]; SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config; SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions; -SQLITE_API extern u32 sqlite3_unsupported_selecttrace; #ifndef SQLITE_OMIT_WSD SQLITE_PRIVATE int sqlite3PendingByte; #endif @@ -20051,6 +19859,7 @@ SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*, int); SQLITE_PRIVATE void sqlite3CodeRhsOfIN(Parse*, Expr*, int); SQLITE_PRIVATE int sqlite3CodeSubselect(Parse*, Expr*); SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*); +SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse*, SrcItem*); SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p); SQLITE_PRIVATE int sqlite3MatchEName( const struct ExprList_item*, @@ -20068,8 +19877,9 @@ SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int); SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *); SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *); -SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse*, void*, Token*); -SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse*, void *pTo, void *pFrom); +SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse*, SrcList*, const Token*); +SQLITE_PRIVATE const void *sqlite3RenameTokenMap(Parse*, const void*, const Token*); +SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse*, const void *pTo, const void *pFrom); SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse*, Expr*); SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse*, ExprList*); SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*); @@ -20091,6 +19901,7 @@ SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo*); SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo*); SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*); SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(Parse*, ExprList*, int, int); +SQLITE_PRIVATE const char *sqlite3SelectOpName(int); SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse*, ExprList*); #ifdef SQLITE_DEBUG @@ -20112,6 +19923,8 @@ SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *); SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int); SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*); +SQLITE_PRIVATE void sqlite3StrAccumSetError(StrAccum*, u8); +SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context*,StrAccum*); SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int); SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int); @@ -20164,7 +19977,7 @@ SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char*); #endif #ifdef SQLITE_OMIT_VIRTUALTABLE -# define sqlite3VtabClear(Y) +# define sqlite3VtabClear(D,T) # define sqlite3VtabSync(X,Y) SQLITE_OK # define sqlite3VtabRollback(X) # define sqlite3VtabCommit(X) @@ -20201,9 +20014,11 @@ SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables(sqlite3 *db); #ifndef SQLITE_OMIT_VIRTUALTABLE SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName); SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3*,Table*,const char*); +SQLITE_PRIVATE void sqlite3MarkAllShadowTablesOf(sqlite3*, Table*); #else # define sqlite3ShadowTableName(A,B) 0 # define sqlite3IsShadowTableOf(A,B,C) 0 +# define sqlite3MarkAllShadowTablesOf(A,B) #endif SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse*,Module*); SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3*,Module*); @@ -20221,6 +20036,7 @@ SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*); SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int); SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *); SQLITE_PRIVATE void sqlite3ParserReset(Parse*); +SQLITE_PRIVATE void *sqlite3ParserAddCleanup(Parse*,void(*)(sqlite3*,void*),void*); #ifdef SQLITE_ENABLE_NORMALIZE SQLITE_PRIVATE char *sqlite3Normalize(Vdbe*, const char*); #endif @@ -20235,23 +20051,32 @@ SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3*, int, int, int*, int*); SQLITE_PRIVATE int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int); #endif #ifndef SQLITE_OMIT_CTE -SQLITE_PRIVATE With *sqlite3WithAdd(Parse*,With*,Token*,ExprList*,Select*); +SQLITE_PRIVATE Cte *sqlite3CteNew(Parse*,Token*,ExprList*,Select*,u8); +SQLITE_PRIVATE void sqlite3CteDelete(sqlite3*,Cte*); +SQLITE_PRIVATE With *sqlite3WithAdd(Parse*,With*,Cte*); SQLITE_PRIVATE void sqlite3WithDelete(sqlite3*,With*); -SQLITE_PRIVATE void sqlite3WithPush(Parse*, With*, u8); +SQLITE_PRIVATE With *sqlite3WithPush(Parse*, With*, u8); #else -#define sqlite3WithPush(x,y,z) -#define sqlite3WithDelete(x,y) +# define sqlite3CteNew(P,T,E,S) ((void*)0) +# define sqlite3CteDelete(D,C) +# define sqlite3CteWithAdd(P,W,C) ((void*)0) +# define sqlite3WithDelete(x,y) +# define sqlite3WithPush(x,y,z) ((void*)0) #endif #ifndef SQLITE_OMIT_UPSERT -SQLITE_PRIVATE Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*); +SQLITE_PRIVATE Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*,Upsert*); SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3*,Upsert*); SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3*,Upsert*); SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*); SQLITE_PRIVATE void sqlite3UpsertDoUpdate(Parse*,Upsert*,Table*,Index*,int); +SQLITE_PRIVATE Upsert *sqlite3UpsertOfIndex(Upsert*,Index*); +SQLITE_PRIVATE int sqlite3UpsertNextIsIPK(Upsert*); #else -#define sqlite3UpsertNew(v,w,x,y,z) ((Upsert*)0) +#define sqlite3UpsertNew(u,v,w,x,y,z) ((Upsert*)0) #define sqlite3UpsertDelete(x,y) -#define sqlite3UpsertDup(x,y) ((Upsert*)0) +#define sqlite3UpsertDup(x,y) ((Upsert*)0) +#define sqlite3UpsertOfIndex(x,y) ((Upsert*)0) +#define sqlite3UpsertNextIsIPK(x) 0 #endif @@ -20333,7 +20158,7 @@ SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *); SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p); #if SQLITE_MAX_EXPR_DEPTH>0 -SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *); +SQLITE_PRIVATE int sqlite3SelectExprHeight(const Select *); SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse*, int); #else #define sqlite3SelectExprHeight(x) 0 @@ -20404,8 +20229,8 @@ SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...); */ #ifdef SQLITE_MEMDEBUG SQLITE_PRIVATE void sqlite3MemdebugSetType(void*,u8); -SQLITE_PRIVATE int sqlite3MemdebugHasType(void*,u8); -SQLITE_PRIVATE int sqlite3MemdebugNoType(void*,u8); +SQLITE_PRIVATE int sqlite3MemdebugHasType(const void*,u8); +SQLITE_PRIVATE int sqlite3MemdebugNoType(const void*,u8); #else # define sqlite3MemdebugSetType(X,Y) /* no-op */ # define sqlite3MemdebugHasType(X,Y) 1 @@ -20430,10 +20255,10 @@ SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3*); SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3*); #endif -SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr); -SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr); +SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr); +SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr); SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr*, int); -SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(Parse*,Expr*,int); +SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(Parse*,Expr*,int,int); SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse*, Expr*); #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS @@ -20443,6 +20268,990 @@ SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt); #endif /* SQLITEINT_H */ /************** End of sqliteInt.h *******************************************/ +/************** Begin file os_common.h ***************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ +#ifndef _OS_COMMON_H_ +#define _OS_COMMON_H_ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE + +/* +** hwtime.h contains inline assembler code for implementing +** high-performance timing routines. +*/ +/************** Include hwtime.h in the middle of os_common.h ****************/ +/************** Begin file hwtime.h ******************************************/ +/* +** 2008 May 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains inline asm code for retrieving "high-performance" +** counters for x86 and x86_64 class CPUs. +*/ +#ifndef SQLITE_HWTIME_H +#define SQLITE_HWTIME_H + +/* +** The following routine only works on pentium-class (or newer) processors. +** It uses the RDTSC opcode to read the cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +#if !defined(__STRICT_ANSI__) && \ + (defined(__GNUC__) || defined(_MSC_VER)) && \ + (defined(i386) || defined(__i386__) || defined(_M_IX86)) + + #if defined(__GNUC__) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned int lo, hi; + __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); + return (sqlite_uint64)hi << 32 | lo; + } + + #elif defined(_MSC_VER) + + __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ + __asm { + rdtsc + ret ; return value at EDX:EAX + } + } + + #endif + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long val; + __asm__ __volatile__ ("rdtsc" : "=A" (val)); + return val; + } + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long long retval; + unsigned long junk; + __asm__ __volatile__ ("\n\ + 1: mftbu %1\n\ + mftb %L0\n\ + mftbu %0\n\ + cmpw %0,%1\n\ + bne 1b" + : "=r" (retval), "=r" (junk)); + return retval; + } + +#else + + /* + ** asm() is needed for hardware timing support. Without asm(), + ** disable the sqlite3Hwtime() routine. + ** + ** sqlite3Hwtime() is only used for some obscure debugging + ** and analysis configurations, not in any deliverable, so this + ** should not be a great loss. + */ +SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } + +#endif + +#endif /* !defined(SQLITE_HWTIME_H) */ + +/************** End of hwtime.h **********************************************/ +/************** Continuing where we left off in os_common.h ******************/ + +static sqlite_uint64 g_start; +static sqlite_uint64 g_elapsed; +#define TIMER_START g_start=sqlite3Hwtime() +#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start +#define TIMER_ELAPSED g_elapsed +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED ((sqlite_uint64)0) +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_io_error_hit; +SQLITE_API extern int sqlite3_io_error_hardhit; +SQLITE_API extern int sqlite3_io_error_pending; +SQLITE_API extern int sqlite3_io_error_persist; +SQLITE_API extern int sqlite3_io_error_benign; +SQLITE_API extern int sqlite3_diskfull_pending; +SQLITE_API extern int sqlite3_diskfull; +#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) +#define SimulateIOError(CODE) \ + if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ + || sqlite3_io_error_pending-- == 1 ) \ + { local_ioerr(); CODE; } +static void local_ioerr(){ + IOTRACE(("IOERR\n")); + sqlite3_io_error_hit++; + if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; +} +#define SimulateDiskfullError(CODE) \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + sqlite3_io_error_hit = 1; \ + CODE; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOErrorBenign(X) +#define SimulateIOError(A) +#define SimulateDiskfullError(A) +#endif /* defined(SQLITE_TEST) */ + +/* +** When testing, keep a count of the number of open files. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_open_file_count; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif /* defined(SQLITE_TEST) */ + +#endif /* !defined(_OS_COMMON_H_) */ + +/************** End of os_common.h *******************************************/ +/************** Begin file ctime.c *******************************************/ +/* +** 2010 February 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file implements routines used to report what compile-time options +** SQLite was built with. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS /* IMP: R-16824-07538 */ + +/* +** Include the configuration header output by 'configure' if we're using the +** autoconf-based build +*/ +#if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H) +/* #include "config.h" */ +#define SQLITECONFIG_H 1 +#endif + +/* These macros are provided to "stringify" the value of the define +** for those options in which the value is meaningful. */ +#define CTIMEOPT_VAL_(opt) #opt +#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) + +/* Like CTIMEOPT_VAL, but especially for SQLITE_DEFAULT_LOOKASIDE. This +** option requires a separate macro because legal values contain a single +** comma. e.g. (-DSQLITE_DEFAULT_LOOKASIDE="100,100") */ +#define CTIMEOPT_VAL2_(opt1,opt2) #opt1 "," #opt2 +#define CTIMEOPT_VAL2(opt) CTIMEOPT_VAL2_(opt) +/* #include "sqliteInt.h" */ + +/* +** An array of names of all compile-time options. This array should +** be sorted A-Z. +** +** This array looks large, but in a typical installation actually uses +** only a handful of compile-time options, so most times this array is usually +** rather short and uses little memory space. +*/ +static const char * const sqlite3azCompileOpt[] = { + +/* +** BEGIN CODE GENERATED BY tool/mkctime.tcl +*/ +#ifdef SQLITE_32BIT_ROWID + "32BIT_ROWID", +#endif +#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC + "4_BYTE_ALIGNED_MALLOC", +#endif +#ifdef SQLITE_64BIT_STATS + "64BIT_STATS", +#endif +#ifdef SQLITE_ALLOW_COVERING_INDEX_SCAN +# if SQLITE_ALLOW_COVERING_INDEX_SCAN != 1 + "ALLOW_COVERING_INDEX_SCAN=" CTIMEOPT_VAL(SQLITE_ALLOW_COVERING_INDEX_SCAN), +# endif +#endif +#ifdef SQLITE_ALLOW_URI_AUTHORITY + "ALLOW_URI_AUTHORITY", +#endif +#ifdef SQLITE_ATOMIC_INTRINSICS + "ATOMIC_INTRINSICS=" CTIMEOPT_VAL(SQLITE_ATOMIC_INTRINSICS), +#endif +#ifdef SQLITE_BITMASK_TYPE + "BITMASK_TYPE=" CTIMEOPT_VAL(SQLITE_BITMASK_TYPE), +#endif +#ifdef SQLITE_BUG_COMPATIBLE_20160819 + "BUG_COMPATIBLE_20160819", +#endif +#ifdef SQLITE_CASE_SENSITIVE_LIKE + "CASE_SENSITIVE_LIKE", +#endif +#ifdef SQLITE_CHECK_PAGES + "CHECK_PAGES", +#endif +#if defined(__clang__) && defined(__clang_major__) + "COMPILER=clang-" CTIMEOPT_VAL(__clang_major__) "." + CTIMEOPT_VAL(__clang_minor__) "." + CTIMEOPT_VAL(__clang_patchlevel__), +#elif defined(_MSC_VER) + "COMPILER=msvc-" CTIMEOPT_VAL(_MSC_VER), +#elif defined(__GNUC__) && defined(__VERSION__) + "COMPILER=gcc-" __VERSION__, +#endif +#ifdef SQLITE_COVERAGE_TEST + "COVERAGE_TEST", +#endif +#ifdef SQLITE_DEBUG + "DEBUG", +#endif +#ifdef SQLITE_DEFAULT_AUTOMATIC_INDEX + "DEFAULT_AUTOMATIC_INDEX", +#endif +#ifdef SQLITE_DEFAULT_AUTOVACUUM + "DEFAULT_AUTOVACUUM", +#endif +#ifdef SQLITE_DEFAULT_CACHE_SIZE + "DEFAULT_CACHE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_CACHE_SIZE), +#endif +#ifdef SQLITE_DEFAULT_CKPTFULLFSYNC + "DEFAULT_CKPTFULLFSYNC", +#endif +#ifdef SQLITE_DEFAULT_FILE_FORMAT + "DEFAULT_FILE_FORMAT=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_FORMAT), +#endif +#ifdef SQLITE_DEFAULT_FILE_PERMISSIONS + "DEFAULT_FILE_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_PERMISSIONS), +#endif +#ifdef SQLITE_DEFAULT_FOREIGN_KEYS + "DEFAULT_FOREIGN_KEYS", +#endif +#ifdef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT + "DEFAULT_JOURNAL_SIZE_LIMIT=" CTIMEOPT_VAL(SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT), +#endif +#ifdef SQLITE_DEFAULT_LOCKING_MODE + "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE), +#endif +#ifdef SQLITE_DEFAULT_LOOKASIDE + "DEFAULT_LOOKASIDE=" CTIMEOPT_VAL2(SQLITE_DEFAULT_LOOKASIDE), +#endif +#ifdef SQLITE_DEFAULT_MEMSTATUS +# if SQLITE_DEFAULT_MEMSTATUS != 1 + "DEFAULT_MEMSTATUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_MEMSTATUS), +# endif +#endif +#ifdef SQLITE_DEFAULT_MMAP_SIZE + "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE), +#endif +#ifdef SQLITE_DEFAULT_PAGE_SIZE + "DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_PAGE_SIZE), +#endif +#ifdef SQLITE_DEFAULT_PCACHE_INITSZ + "DEFAULT_PCACHE_INITSZ=" CTIMEOPT_VAL(SQLITE_DEFAULT_PCACHE_INITSZ), +#endif +#ifdef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS + "DEFAULT_PROXYDIR_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_PROXYDIR_PERMISSIONS), +#endif +#ifdef SQLITE_DEFAULT_RECURSIVE_TRIGGERS + "DEFAULT_RECURSIVE_TRIGGERS", +#endif +#ifdef SQLITE_DEFAULT_ROWEST + "DEFAULT_ROWEST=" CTIMEOPT_VAL(SQLITE_DEFAULT_ROWEST), +#endif +#ifdef SQLITE_DEFAULT_SECTOR_SIZE + "DEFAULT_SECTOR_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_SECTOR_SIZE), +#endif +#ifdef SQLITE_DEFAULT_SYNCHRONOUS + "DEFAULT_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_SYNCHRONOUS), +#endif +#ifdef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT + "DEFAULT_WAL_AUTOCHECKPOINT=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_AUTOCHECKPOINT), +#endif +#ifdef SQLITE_DEFAULT_WAL_SYNCHRONOUS + "DEFAULT_WAL_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_SYNCHRONOUS), +#endif +#ifdef SQLITE_DEFAULT_WORKER_THREADS + "DEFAULT_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WORKER_THREADS), +#endif +#ifdef SQLITE_DIRECT_OVERFLOW_READ + "DIRECT_OVERFLOW_READ", +#endif +#ifdef SQLITE_DISABLE_DIRSYNC + "DISABLE_DIRSYNC", +#endif +#ifdef SQLITE_DISABLE_FTS3_UNICODE + "DISABLE_FTS3_UNICODE", +#endif +#ifdef SQLITE_DISABLE_FTS4_DEFERRED + "DISABLE_FTS4_DEFERRED", +#endif +#ifdef SQLITE_DISABLE_INTRINSIC + "DISABLE_INTRINSIC", +#endif +#ifdef SQLITE_DISABLE_LFS + "DISABLE_LFS", +#endif +#ifdef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS + "DISABLE_PAGECACHE_OVERFLOW_STATS", +#endif +#ifdef SQLITE_DISABLE_SKIPAHEAD_DISTINCT + "DISABLE_SKIPAHEAD_DISTINCT", +#endif +#ifdef SQLITE_ENABLE_8_3_NAMES + "ENABLE_8_3_NAMES=" CTIMEOPT_VAL(SQLITE_ENABLE_8_3_NAMES), +#endif +#ifdef SQLITE_ENABLE_API_ARMOR + "ENABLE_API_ARMOR", +#endif +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + "ENABLE_ATOMIC_WRITE", +#endif +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + "ENABLE_BATCH_ATOMIC_WRITE", +#endif +#ifdef SQLITE_ENABLE_BYTECODE_VTAB + "ENABLE_BYTECODE_VTAB", +#endif +#ifdef SQLITE_ENABLE_CEROD + "ENABLE_CEROD=" CTIMEOPT_VAL(SQLITE_ENABLE_CEROD), +#endif +#ifdef SQLITE_ENABLE_COLUMN_METADATA + "ENABLE_COLUMN_METADATA", +#endif +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + "ENABLE_COLUMN_USED_MASK", +#endif +#ifdef SQLITE_ENABLE_COSTMULT + "ENABLE_COSTMULT", +#endif +#ifdef SQLITE_ENABLE_CURSOR_HINTS + "ENABLE_CURSOR_HINTS", +#endif +#ifdef SQLITE_ENABLE_DBPAGE_VTAB + "ENABLE_DBPAGE_VTAB", +#endif +#ifdef SQLITE_ENABLE_DBSTAT_VTAB + "ENABLE_DBSTAT_VTAB", +#endif +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + "ENABLE_EXPENSIVE_ASSERT", +#endif +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + "ENABLE_EXPLAIN_COMMENTS", +#endif +#ifdef SQLITE_ENABLE_FTS3 + "ENABLE_FTS3", +#endif +#ifdef SQLITE_ENABLE_FTS3_PARENTHESIS + "ENABLE_FTS3_PARENTHESIS", +#endif +#ifdef SQLITE_ENABLE_FTS3_TOKENIZER + "ENABLE_FTS3_TOKENIZER", +#endif +#ifdef SQLITE_ENABLE_FTS4 + "ENABLE_FTS4", +#endif +#ifdef SQLITE_ENABLE_FTS5 + "ENABLE_FTS5", +#endif +#ifdef SQLITE_ENABLE_GEOPOLY + "ENABLE_GEOPOLY", +#endif +#ifdef SQLITE_ENABLE_HIDDEN_COLUMNS + "ENABLE_HIDDEN_COLUMNS", +#endif +#ifdef SQLITE_ENABLE_ICU + "ENABLE_ICU", +#endif +#ifdef SQLITE_ENABLE_IOTRACE + "ENABLE_IOTRACE", +#endif +#ifdef SQLITE_ENABLE_JSON1 + "ENABLE_JSON1", +#endif +#ifdef SQLITE_ENABLE_LOAD_EXTENSION + "ENABLE_LOAD_EXTENSION", +#endif +#ifdef SQLITE_ENABLE_LOCKING_STYLE + "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE), +#endif +#ifdef SQLITE_ENABLE_MATH_FUNCTIONS + "ENABLE_MATH_FUNCTIONS", +#endif +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + "ENABLE_MEMORY_MANAGEMENT", +#endif +#ifdef SQLITE_ENABLE_MEMSYS3 + "ENABLE_MEMSYS3", +#endif +#ifdef SQLITE_ENABLE_MEMSYS5 + "ENABLE_MEMSYS5", +#endif +#ifdef SQLITE_ENABLE_MULTIPLEX + "ENABLE_MULTIPLEX", +#endif +#ifdef SQLITE_ENABLE_NORMALIZE + "ENABLE_NORMALIZE", +#endif +#ifdef SQLITE_ENABLE_NULL_TRIM + "ENABLE_NULL_TRIM", +#endif +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + "ENABLE_OFFSET_SQL_FUNC", +#endif +#ifdef SQLITE_ENABLE_OVERSIZE_CELL_CHECK + "ENABLE_OVERSIZE_CELL_CHECK", +#endif +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + "ENABLE_PREUPDATE_HOOK", +#endif +#ifdef SQLITE_ENABLE_QPSG + "ENABLE_QPSG", +#endif +#ifdef SQLITE_ENABLE_RBU + "ENABLE_RBU", +#endif +#ifdef SQLITE_ENABLE_RTREE + "ENABLE_RTREE", +#endif +#ifdef SQLITE_ENABLE_SELECTTRACE + "ENABLE_SELECTTRACE", +#endif +#ifdef SQLITE_ENABLE_SESSION + "ENABLE_SESSION", +#endif +#ifdef SQLITE_ENABLE_SNAPSHOT + "ENABLE_SNAPSHOT", +#endif +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + "ENABLE_SORTER_REFERENCES", +#endif +#ifdef SQLITE_ENABLE_SQLLOG + "ENABLE_SQLLOG", +#endif +#ifdef SQLITE_ENABLE_STAT4 + "ENABLE_STAT4", +#endif +#ifdef SQLITE_ENABLE_STMTVTAB + "ENABLE_STMTVTAB", +#endif +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + "ENABLE_STMT_SCANSTATUS", +#endif +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + "ENABLE_UNKNOWN_SQL_FUNCTION", +#endif +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + "ENABLE_UNLOCK_NOTIFY", +#endif +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + "ENABLE_UPDATE_DELETE_LIMIT", +#endif +#ifdef SQLITE_ENABLE_URI_00_ERROR + "ENABLE_URI_00_ERROR", +#endif +#ifdef SQLITE_ENABLE_VFSTRACE + "ENABLE_VFSTRACE", +#endif +#ifdef SQLITE_ENABLE_WHERETRACE + "ENABLE_WHERETRACE", +#endif +#ifdef SQLITE_ENABLE_ZIPVFS + "ENABLE_ZIPVFS", +#endif +#ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS + "EXPLAIN_ESTIMATED_ROWS", +#endif +#ifdef SQLITE_EXTRA_IFNULLROW + "EXTRA_IFNULLROW", +#endif +#ifdef SQLITE_EXTRA_INIT + "EXTRA_INIT=" CTIMEOPT_VAL(SQLITE_EXTRA_INIT), +#endif +#ifdef SQLITE_EXTRA_SHUTDOWN + "EXTRA_SHUTDOWN=" CTIMEOPT_VAL(SQLITE_EXTRA_SHUTDOWN), +#endif +#ifdef SQLITE_FTS3_MAX_EXPR_DEPTH + "FTS3_MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_FTS3_MAX_EXPR_DEPTH), +#endif +#ifdef SQLITE_FTS5_ENABLE_TEST_MI + "FTS5_ENABLE_TEST_MI", +#endif +#ifdef SQLITE_FTS5_NO_WITHOUT_ROWID + "FTS5_NO_WITHOUT_ROWID", +#endif +#if HAVE_ISNAN || SQLITE_HAVE_ISNAN + "HAVE_ISNAN", +#endif +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX +# if SQLITE_HOMEGROWN_RECURSIVE_MUTEX != 1 + "HOMEGROWN_RECURSIVE_MUTEX=" CTIMEOPT_VAL(SQLITE_HOMEGROWN_RECURSIVE_MUTEX), +# endif +#endif +#ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS + "IGNORE_AFP_LOCK_ERRORS", +#endif +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + "IGNORE_FLOCK_LOCK_ERRORS", +#endif +#ifdef SQLITE_INLINE_MEMCPY + "INLINE_MEMCPY", +#endif +#ifdef SQLITE_INT64_TYPE + "INT64_TYPE", +#endif +#ifdef SQLITE_INTEGRITY_CHECK_ERROR_MAX + "INTEGRITY_CHECK_ERROR_MAX=" CTIMEOPT_VAL(SQLITE_INTEGRITY_CHECK_ERROR_MAX), +#endif +#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS + "LIKE_DOESNT_MATCH_BLOBS", +#endif +#ifdef SQLITE_LOCK_TRACE + "LOCK_TRACE", +#endif +#ifdef SQLITE_LOG_CACHE_SPILL + "LOG_CACHE_SPILL", +#endif +#ifdef SQLITE_MALLOC_SOFT_LIMIT + "MALLOC_SOFT_LIMIT=" CTIMEOPT_VAL(SQLITE_MALLOC_SOFT_LIMIT), +#endif +#ifdef SQLITE_MAX_ATTACHED + "MAX_ATTACHED=" CTIMEOPT_VAL(SQLITE_MAX_ATTACHED), +#endif +#ifdef SQLITE_MAX_COLUMN + "MAX_COLUMN=" CTIMEOPT_VAL(SQLITE_MAX_COLUMN), +#endif +#ifdef SQLITE_MAX_COMPOUND_SELECT + "MAX_COMPOUND_SELECT=" CTIMEOPT_VAL(SQLITE_MAX_COMPOUND_SELECT), +#endif +#ifdef SQLITE_MAX_DEFAULT_PAGE_SIZE + "MAX_DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_DEFAULT_PAGE_SIZE), +#endif +#ifdef SQLITE_MAX_EXPR_DEPTH + "MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_EXPR_DEPTH), +#endif +#ifdef SQLITE_MAX_FUNCTION_ARG + "MAX_FUNCTION_ARG=" CTIMEOPT_VAL(SQLITE_MAX_FUNCTION_ARG), +#endif +#ifdef SQLITE_MAX_LENGTH + "MAX_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LENGTH), +#endif +#ifdef SQLITE_MAX_LIKE_PATTERN_LENGTH + "MAX_LIKE_PATTERN_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LIKE_PATTERN_LENGTH), +#endif +#ifdef SQLITE_MAX_MEMORY + "MAX_MEMORY=" CTIMEOPT_VAL(SQLITE_MAX_MEMORY), +#endif +#ifdef SQLITE_MAX_MMAP_SIZE + "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE), +#endif +#ifdef SQLITE_MAX_MMAP_SIZE_ + "MAX_MMAP_SIZE_=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE_), +#endif +#ifdef SQLITE_MAX_PAGE_COUNT + "MAX_PAGE_COUNT=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_COUNT), +#endif +#ifdef SQLITE_MAX_PAGE_SIZE + "MAX_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_SIZE), +#endif +#ifdef SQLITE_MAX_SCHEMA_RETRY + "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY), +#endif +#ifdef SQLITE_MAX_SQL_LENGTH + "MAX_SQL_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_SQL_LENGTH), +#endif +#ifdef SQLITE_MAX_TRIGGER_DEPTH + "MAX_TRIGGER_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_TRIGGER_DEPTH), +#endif +#ifdef SQLITE_MAX_VARIABLE_NUMBER + "MAX_VARIABLE_NUMBER=" CTIMEOPT_VAL(SQLITE_MAX_VARIABLE_NUMBER), +#endif +#ifdef SQLITE_MAX_VDBE_OP + "MAX_VDBE_OP=" CTIMEOPT_VAL(SQLITE_MAX_VDBE_OP), +#endif +#ifdef SQLITE_MAX_WORKER_THREADS + "MAX_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_MAX_WORKER_THREADS), +#endif +#ifdef SQLITE_MEMDEBUG + "MEMDEBUG", +#endif +#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT + "MIXED_ENDIAN_64BIT_FLOAT", +#endif +#ifdef SQLITE_MMAP_READWRITE + "MMAP_READWRITE", +#endif +#ifdef SQLITE_MUTEX_NOOP + "MUTEX_NOOP", +#endif +#ifdef SQLITE_MUTEX_OMIT + "MUTEX_OMIT", +#endif +#ifdef SQLITE_MUTEX_PTHREADS + "MUTEX_PTHREADS", +#endif +#ifdef SQLITE_MUTEX_W32 + "MUTEX_W32", +#endif +#ifdef SQLITE_NEED_ERR_NAME + "NEED_ERR_NAME", +#endif +#ifdef SQLITE_NO_SYNC + "NO_SYNC", +#endif +#ifdef SQLITE_OMIT_ALTERTABLE + "OMIT_ALTERTABLE", +#endif +#ifdef SQLITE_OMIT_ANALYZE + "OMIT_ANALYZE", +#endif +#ifdef SQLITE_OMIT_ATTACH + "OMIT_ATTACH", +#endif +#ifdef SQLITE_OMIT_AUTHORIZATION + "OMIT_AUTHORIZATION", +#endif +#ifdef SQLITE_OMIT_AUTOINCREMENT + "OMIT_AUTOINCREMENT", +#endif +#ifdef SQLITE_OMIT_AUTOINIT + "OMIT_AUTOINIT", +#endif +#ifdef SQLITE_OMIT_AUTOMATIC_INDEX + "OMIT_AUTOMATIC_INDEX", +#endif +#ifdef SQLITE_OMIT_AUTORESET + "OMIT_AUTORESET", +#endif +#ifdef SQLITE_OMIT_AUTOVACUUM + "OMIT_AUTOVACUUM", +#endif +#ifdef SQLITE_OMIT_BETWEEN_OPTIMIZATION + "OMIT_BETWEEN_OPTIMIZATION", +#endif +#ifdef SQLITE_OMIT_BLOB_LITERAL + "OMIT_BLOB_LITERAL", +#endif +#ifdef SQLITE_OMIT_CAST + "OMIT_CAST", +#endif +#ifdef SQLITE_OMIT_CHECK + "OMIT_CHECK", +#endif +#ifdef SQLITE_OMIT_COMPLETE + "OMIT_COMPLETE", +#endif +#ifdef SQLITE_OMIT_COMPOUND_SELECT + "OMIT_COMPOUND_SELECT", +#endif +#ifdef SQLITE_OMIT_CONFLICT_CLAUSE + "OMIT_CONFLICT_CLAUSE", +#endif +#ifdef SQLITE_OMIT_CTE + "OMIT_CTE", +#endif +#if defined(SQLITE_OMIT_DATETIME_FUNCS) || defined(SQLITE_OMIT_FLOATING_POINT) + "OMIT_DATETIME_FUNCS", +#endif +#ifdef SQLITE_OMIT_DECLTYPE + "OMIT_DECLTYPE", +#endif +#ifdef SQLITE_OMIT_DEPRECATED + "OMIT_DEPRECATED", +#endif +#ifdef SQLITE_OMIT_DESERIALIZE + "OMIT_DESERIALIZE", +#endif +#ifdef SQLITE_OMIT_DISKIO + "OMIT_DISKIO", +#endif +#ifdef SQLITE_OMIT_EXPLAIN + "OMIT_EXPLAIN", +#endif +#ifdef SQLITE_OMIT_FLAG_PRAGMAS + "OMIT_FLAG_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_FLOATING_POINT + "OMIT_FLOATING_POINT", +#endif +#ifdef SQLITE_OMIT_FOREIGN_KEY + "OMIT_FOREIGN_KEY", +#endif +#ifdef SQLITE_OMIT_GET_TABLE + "OMIT_GET_TABLE", +#endif +#ifdef SQLITE_OMIT_HEX_INTEGER + "OMIT_HEX_INTEGER", +#endif +#ifdef SQLITE_OMIT_INCRBLOB + "OMIT_INCRBLOB", +#endif +#ifdef SQLITE_OMIT_INTEGRITY_CHECK + "OMIT_INTEGRITY_CHECK", +#endif +#ifdef SQLITE_OMIT_INTROSPECTION_PRAGMAS + "OMIT_INTROSPECTION_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_LIKE_OPTIMIZATION + "OMIT_LIKE_OPTIMIZATION", +#endif +#ifdef SQLITE_OMIT_LOAD_EXTENSION + "OMIT_LOAD_EXTENSION", +#endif +#ifdef SQLITE_OMIT_LOCALTIME + "OMIT_LOCALTIME", +#endif +#ifdef SQLITE_OMIT_LOOKASIDE + "OMIT_LOOKASIDE", +#endif +#ifdef SQLITE_OMIT_MEMORYDB + "OMIT_MEMORYDB", +#endif +#ifdef SQLITE_OMIT_OR_OPTIMIZATION + "OMIT_OR_OPTIMIZATION", +#endif +#ifdef SQLITE_OMIT_PAGER_PRAGMAS + "OMIT_PAGER_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_PARSER_TRACE + "OMIT_PARSER_TRACE", +#endif +#ifdef SQLITE_OMIT_POPEN + "OMIT_POPEN", +#endif +#ifdef SQLITE_OMIT_PRAGMA + "OMIT_PRAGMA", +#endif +#ifdef SQLITE_OMIT_PROGRESS_CALLBACK + "OMIT_PROGRESS_CALLBACK", +#endif +#ifdef SQLITE_OMIT_QUICKBALANCE + "OMIT_QUICKBALANCE", +#endif +#ifdef SQLITE_OMIT_REINDEX + "OMIT_REINDEX", +#endif +#ifdef SQLITE_OMIT_SCHEMA_PRAGMAS + "OMIT_SCHEMA_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS + "OMIT_SCHEMA_VERSION_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_SHARED_CACHE + "OMIT_SHARED_CACHE", +#endif +#ifdef SQLITE_OMIT_SHUTDOWN_DIRECTORIES + "OMIT_SHUTDOWN_DIRECTORIES", +#endif +#ifdef SQLITE_OMIT_SUBQUERY + "OMIT_SUBQUERY", +#endif +#ifdef SQLITE_OMIT_TCL_VARIABLE + "OMIT_TCL_VARIABLE", +#endif +#ifdef SQLITE_OMIT_TEMPDB + "OMIT_TEMPDB", +#endif +#ifdef SQLITE_OMIT_TEST_CONTROL + "OMIT_TEST_CONTROL", +#endif +#ifdef SQLITE_OMIT_TRACE +# if SQLITE_OMIT_TRACE != 1 + "OMIT_TRACE=" CTIMEOPT_VAL(SQLITE_OMIT_TRACE), +# endif +#endif +#ifdef SQLITE_OMIT_TRIGGER + "OMIT_TRIGGER", +#endif +#ifdef SQLITE_OMIT_TRUNCATE_OPTIMIZATION + "OMIT_TRUNCATE_OPTIMIZATION", +#endif +#ifdef SQLITE_OMIT_UTF16 + "OMIT_UTF16", +#endif +#ifdef SQLITE_OMIT_VACUUM + "OMIT_VACUUM", +#endif +#ifdef SQLITE_OMIT_VIEW + "OMIT_VIEW", +#endif +#ifdef SQLITE_OMIT_VIRTUALTABLE + "OMIT_VIRTUALTABLE", +#endif +#ifdef SQLITE_OMIT_WAL + "OMIT_WAL", +#endif +#ifdef SQLITE_OMIT_WSD + "OMIT_WSD", +#endif +#ifdef SQLITE_OMIT_XFER_OPT + "OMIT_XFER_OPT", +#endif +#ifdef SQLITE_PCACHE_SEPARATE_HEADER + "PCACHE_SEPARATE_HEADER", +#endif +#ifdef SQLITE_PERFORMANCE_TRACE + "PERFORMANCE_TRACE", +#endif +#ifdef SQLITE_POWERSAFE_OVERWRITE +# if SQLITE_POWERSAFE_OVERWRITE != 1 + "POWERSAFE_OVERWRITE=" CTIMEOPT_VAL(SQLITE_POWERSAFE_OVERWRITE), +# endif +#endif +#ifdef SQLITE_PREFER_PROXY_LOCKING + "PREFER_PROXY_LOCKING", +#endif +#ifdef SQLITE_PROXY_DEBUG + "PROXY_DEBUG", +#endif +#ifdef SQLITE_REVERSE_UNORDERED_SELECTS + "REVERSE_UNORDERED_SELECTS", +#endif +#ifdef SQLITE_RTREE_INT_ONLY + "RTREE_INT_ONLY", +#endif +#ifdef SQLITE_SECURE_DELETE + "SECURE_DELETE", +#endif +#ifdef SQLITE_SMALL_STACK + "SMALL_STACK", +#endif +#ifdef SQLITE_SORTER_PMASZ + "SORTER_PMASZ=" CTIMEOPT_VAL(SQLITE_SORTER_PMASZ), +#endif +#ifdef SQLITE_SOUNDEX + "SOUNDEX", +#endif +#ifdef SQLITE_STAT4_SAMPLES + "STAT4_SAMPLES=" CTIMEOPT_VAL(SQLITE_STAT4_SAMPLES), +#endif +#ifdef SQLITE_STMTJRNL_SPILL + "STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL), +#endif +#ifdef SQLITE_SUBSTR_COMPATIBILITY + "SUBSTR_COMPATIBILITY", +#endif +#if (!defined(SQLITE_WIN32_MALLOC) \ + && !defined(SQLITE_ZERO_MALLOC) \ + && !defined(SQLITE_MEMDEBUG) \ + ) || defined(SQLITE_SYSTEM_MALLOC) + "SYSTEM_MALLOC", +#endif +#ifdef SQLITE_TCL + "TCL", +#endif +#ifdef SQLITE_TEMP_STORE + "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE), +#endif +#ifdef SQLITE_TEST + "TEST", +#endif +#if defined(SQLITE_THREADSAFE) + "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE), +#elif defined(THREADSAFE) + "THREADSAFE=" CTIMEOPT_VAL(THREADSAFE), +#else + "THREADSAFE=1", +#endif +#ifdef SQLITE_UNLINK_AFTER_CLOSE + "UNLINK_AFTER_CLOSE", +#endif +#ifdef SQLITE_UNTESTABLE + "UNTESTABLE", +#endif +#ifdef SQLITE_USER_AUTHENTICATION + "USER_AUTHENTICATION", +#endif +#ifdef SQLITE_USE_ALLOCA + "USE_ALLOCA", +#endif +#ifdef SQLITE_USE_FCNTL_TRACE + "USE_FCNTL_TRACE", +#endif +#ifdef SQLITE_USE_URI + "USE_URI", +#endif +#ifdef SQLITE_VDBE_COVERAGE + "VDBE_COVERAGE", +#endif +#ifdef SQLITE_WIN32_MALLOC + "WIN32_MALLOC", +#endif +#ifdef SQLITE_ZERO_MALLOC + "ZERO_MALLOC", +#endif +/* +** END CODE GENERATED BY tool/mkctime.tcl +*/ +}; + +SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt){ + *pnOpt = sizeof(sqlite3azCompileOpt) / sizeof(sqlite3azCompileOpt[0]); + return (const char**)sqlite3azCompileOpt; +} + +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +/************** End of ctime.c ***********************************************/ /************** Begin file global.c ******************************************/ /* ** 2008 June 13 @@ -20483,7 +21292,7 @@ SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = { 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233, 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251, - 252,253,254,255 + 252,253,254,255, #endif #ifdef SQLITE_EBCDIC 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */ @@ -20503,7 +21312,35 @@ SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = { 224,225,162,163,164,165,166,167,168,169,234,235,236,237,238,239, /* Ex */ 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, /* Fx */ #endif +/* All of the upper-to-lower conversion data is above. The following +** 18 integers are completely unrelated. They are appended to the +** sqlite3UpperToLower[] array to avoid UBSAN warnings. Here's what is +** going on: +** +** The SQL comparison operators (<>, =, >, <=, <, and >=) are implemented +** by invoking sqlite3MemCompare(A,B) which compares values A and B and +** returns negative, zero, or positive if A is less then, equal to, or +** greater than B, respectively. Then the true false results is found by +** consulting sqlite3aLTb[opcode], sqlite3aEQb[opcode], or +** sqlite3aGTb[opcode] depending on whether the result of compare(A,B) +** is negative, zero, or positive, where opcode is the specific opcode. +** The only works because the comparison opcodes are consecutive and in +** this order: NE EQ GT LE LT GE. Various assert()s throughout the code +** ensure that is the case. +** +** These elements must be appended to another array. Otherwise the +** index (here shown as [256-OP_Ne]) would be out-of-bounds and thus +** be undefined behavior. That's goofy, but the C-standards people thought +** it was a good idea, so here we are. +*/ +/* NE EQ GT LE LT GE */ + 1, 0, 0, 1, 1, 0, /* aLTb[]: Use when compare(A,B) less than zero */ + 0, 1, 0, 1, 0, 1, /* aEQb[]: Use when compare(A,B) equals zero */ + 1, 0, 1, 0, 0, 1 /* aGTb[]: Use when compare(A,B) greater than zero*/ }; +SQLITE_PRIVATE const unsigned char *sqlite3aLTb = &sqlite3UpperToLower[256-OP_Ne]; +SQLITE_PRIVATE const unsigned char *sqlite3aEQb = &sqlite3UpperToLower[256+6-OP_Ne]; +SQLITE_PRIVATE const unsigned char *sqlite3aGTb = &sqlite3UpperToLower[256+12-OP_Ne]; /* ** The following 256 byte lookup table is used to support SQLites built-in @@ -20697,7 +21534,7 @@ SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = { 0, /* xVdbeBranch */ 0, /* pVbeBranchArg */ #endif -#ifdef SQLITE_ENABLE_DESERIALIZE +#ifndef SQLITE_OMIT_DESERIALIZE SQLITE_MEMDB_DEFAULT_MAXSIZE, /* mxMemdbSize */ #endif #ifndef SQLITE_UNTESTABLE @@ -20716,6 +21553,18 @@ SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = { */ SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions; +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG) +/* +** Counter used for coverage testing. Does not come into play for +** release builds. +** +** Access to this global variable is not mutex protected. This might +** result in TSAN warnings. But as the variable does not exist in +** release builds, that should not be a concern. +*/ +SQLITE_PRIVATE unsigned int sqlite3CoverageCounter; +#endif /* SQLITE_COVERAGE_TEST || SQLITE_DEBUG */ + #ifdef VDBE_PROFILE /* ** The following performance counter can be used in place of @@ -20747,9 +21596,10 @@ SQLITE_PRIVATE int sqlite3PendingByte = 0x40000000; #endif /* -** Flags for select tracing and the ".selecttrace" macro of the CLI +** Tracing flags set by SQLITE_TESTCTRL_TRACEFLAGS. */ -SQLITE_API u32 sqlite3_unsupported_selecttrace = 0; +SQLITE_PRIVATE u32 sqlite3SelectTrace = 0; +SQLITE_PRIVATE u32 sqlite3WhereTrace = 0; /* #include "opcodes.h" */ /* @@ -20765,6 +21615,48 @@ SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER; */ SQLITE_PRIVATE const char sqlite3StrBINARY[] = "BINARY"; +/* +** Standard typenames. These names must match the COLTYPE_* definitions. +** Adjust the SQLITE_N_STDTYPE value if adding or removing entries. +** +** sqlite3StdType[] The actual names of the datatypes. +** +** sqlite3StdTypeLen[] The length (in bytes) of each entry +** in sqlite3StdType[]. +** +** sqlite3StdTypeAffinity[] The affinity associated with each entry +** in sqlite3StdType[]. +** +** sqlite3StdTypeMap[] The type value (as returned from +** sqlite3_column_type() or sqlite3_value_type()) +** for each entry in sqlite3StdType[]. +*/ +SQLITE_PRIVATE const unsigned char sqlite3StdTypeLen[] = { 3, 4, 3, 7, 4, 4 }; +SQLITE_PRIVATE const char sqlite3StdTypeAffinity[] = { + SQLITE_AFF_NUMERIC, + SQLITE_AFF_BLOB, + SQLITE_AFF_INTEGER, + SQLITE_AFF_INTEGER, + SQLITE_AFF_REAL, + SQLITE_AFF_TEXT +}; +SQLITE_PRIVATE const char sqlite3StdTypeMap[] = { + 0, + SQLITE_BLOB, + SQLITE_INTEGER, + SQLITE_INTEGER, + SQLITE_FLOAT, + SQLITE_TEXT +}; +SQLITE_PRIVATE const char *sqlite3StdType[] = { + "ANY", + "BLOB", + "INT", + "INTEGER", + "REAL", + "TEXT" +}; + /************** End of global.c **********************************************/ /************** Begin file status.c ******************************************/ /* @@ -20873,6 +21765,7 @@ struct VdbeCursor { Bool isEphemeral:1; /* True for an ephemeral table */ Bool useRandomRowid:1; /* Generate new record numbers semi-randomly */ Bool isOrdered:1; /* True if the table is not BTREE_UNORDERED */ + Bool hasBeenDuped:1; /* This cursor was source or target of OP_OpenDup */ u16 seekHit; /* See the OP_SeekHit and OP_IfNoHope opcodes */ Btree *pBtx; /* Separate file holding temporary table */ i64 seqCount; /* Sequence counter */ @@ -20966,8 +21859,8 @@ struct VdbeFrame { int nMem; /* Number of entries in aMem */ int nChildMem; /* Number of memory cells for child frame */ int nChildCsr; /* Number of cursors for child frame */ - int nChange; /* Statement changes (Vdbe.nChange) */ - int nDbChange; /* Value of db->nChange */ + i64 nChange; /* Statement changes (Vdbe.nChange) */ + i64 nDbChange; /* Value of db->nChange */ }; /* Magic number for sanity checking on VdbeFrame objects */ @@ -21168,13 +22061,13 @@ struct Vdbe { Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */ Parse *pParse; /* Parsing context used to create this Vdbe */ ynVar nVar; /* Number of entries in aVar[] */ - u32 magic; /* Magic number for sanity checking */ + u32 iVdbeMagic; /* Magic number defining state of the SQL statement */ int nMem; /* Number of memory locations currently allocated */ int nCursor; /* Number of slots in apCsr[] */ u32 cacheCtr; /* VdbeCursor row cache generation counter */ int pc; /* The program counter */ int rc; /* Value to return */ - int nChange; /* Number of db changes made since last reset */ + i64 nChange; /* Number of db changes made since last reset */ int iStatement; /* Statement number (or 0 if has no opened stmt) */ i64 iCurrentTime; /* Value of julianday('now') for this statement */ i64 nFkConstraint; /* Number of imm. FK constraints this VM */ @@ -21258,6 +22151,7 @@ struct PreUpdate { UnpackedRecord *pUnpacked; /* Unpacked version of aRecord[] */ UnpackedRecord *pNewUnpacked; /* Unpacked version of new.* record */ int iNewReg; /* Register for new.* values */ + int iBlobWrite; /* Value returned by preupdate_blobwrite() */ i64 iKey1; /* First key value passed to hook */ i64 iKey2; /* Second key value passed to hook */ Mem *aNew; /* Array of new.* values */ @@ -21301,7 +22195,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*); SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int); SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*); SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*); -SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*)); +SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, i64, u8, void(*)(void*)); SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64); #ifdef SQLITE_OMIT_FLOATING_POINT # define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64 @@ -21311,13 +22205,18 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double); SQLITE_PRIVATE void sqlite3VdbeMemSetPointer(Mem*, void*, const char*, void(*)(void*)); SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem*,sqlite3*,u16); SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*); +#ifndef SQLITE_OMIT_INCRBLOB SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int); +#else +SQLITE_PRIVATE int sqlite3VdbeMemSetZeroBlob(Mem*,int); +#endif #ifdef SQLITE_DEBUG SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem*); #endif SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem*); SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*); SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, u8, u8); +SQLITE_PRIVATE int sqlite3IntFloatCompare(i64,double); SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*); SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*); SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*); @@ -21346,7 +22245,8 @@ SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void*); /* Destructor on Mem */ SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*); /* Actually deletes the Frame */ SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *); #ifdef SQLITE_ENABLE_PREUPDATE_HOOK -SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(Vdbe*,VdbeCursor*,int,const char*,Table*,i64,int); +SQLITE_PRIVATE void sqlite3VdbePreUpdateHook( + Vdbe*,VdbeCursor*,int,const char*,Table*,i64,int,int); #endif SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p); @@ -22673,6 +23573,7 @@ static int isDate( int eType; memset(p, 0, sizeof(*p)); if( argc==0 ){ + if( !sqlite3NotPureFunc(context) ) return 1; return setDateTimeToCurrent(context, p); } if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT @@ -22800,131 +23701,100 @@ static void strftimeFunc( sqlite3_value **argv ){ DateTime x; - u64 n; size_t i,j; - char *z; sqlite3 *db; const char *zFmt; - char zBuf[100]; + sqlite3_str sRes; + + if( argc==0 ) return; zFmt = (const char*)sqlite3_value_text(argv[0]); if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return; db = sqlite3_context_db_handle(context); - for(i=0, n=1; zFmt[i]; i++, n++){ - if( zFmt[i]=='%' ){ - switch( zFmt[i+1] ){ - case 'd': - case 'H': - case 'm': - case 'M': - case 'S': - case 'W': - n++; - /* fall thru */ - case 'w': - case '%': - break; - case 'f': - n += 8; - break; - case 'j': - n += 3; - break; - case 'Y': - n += 8; - break; - case 's': - case 'J': - n += 50; - break; - default: - return; /* ERROR. return a NULL */ - } - i++; - } - } - testcase( n==sizeof(zBuf)-1 ); - testcase( n==sizeof(zBuf) ); - testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH]+1 ); - testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ); - if( n(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ){ - sqlite3_result_error_toobig(context); - return; - }else{ - z = sqlite3DbMallocRawNN(db, (int)n); - if( z==0 ){ - sqlite3_result_error_nomem(context); - return; - } - } + sqlite3StrAccumInit(&sRes, 0, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); + computeJD(&x); computeYMD_HMS(&x); for(i=j=0; zFmt[i]; i++){ - if( zFmt[i]!='%' ){ - z[j++] = zFmt[i]; - }else{ - i++; - switch( zFmt[i] ){ - case 'd': sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break; - case 'f': { - double s = x.s; - if( s>59.999 ) s = 59.999; - sqlite3_snprintf(7, &z[j],"%06.3f", s); - j += sqlite3Strlen30(&z[j]); - break; - } - case 'H': sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break; - case 'W': /* Fall thru */ - case 'j': { - int nDay; /* Number of days since 1st day of year */ - DateTime y = x; - y.validJD = 0; - y.M = 1; - y.D = 1; - computeJD(&y); - nDay = (int)((x.iJD-y.iJD+43200000)/86400000); - if( zFmt[i]=='W' ){ - int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */ - wd = (int)(((x.iJD+43200000)/86400000)%7); - sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7); - j += 2; - }else{ - sqlite3_snprintf(4, &z[j],"%03d",nDay+1); - j += 3; - } - break; - } - case 'J': { - sqlite3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0); - j+=sqlite3Strlen30(&z[j]); - break; - } - case 'm': sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break; - case 'M': sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break; - case 's': { - i64 iS = (i64)(x.iJD/1000 - 21086676*(i64)10000); - sqlite3Int64ToText(iS, &z[j]); - j += sqlite3Strlen30(&z[j]); - break; - } - case 'S': sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break; - case 'w': { - z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) + '0'; - break; - } - case 'Y': { - sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]); - break; + if( zFmt[i]!='%' ) continue; + if( j59.999 ) s = 59.999; + sqlite3_str_appendf(&sRes, "%06.3f", s); + break; + } + case 'H': { + sqlite3_str_appendf(&sRes, "%02d", x.h); + break; + } + case 'W': /* Fall thru */ + case 'j': { + int nDay; /* Number of days since 1st day of year */ + DateTime y = x; + y.validJD = 0; + y.M = 1; + y.D = 1; + computeJD(&y); + nDay = (int)((x.iJD-y.iJD+43200000)/86400000); + if( zFmt[i]=='W' ){ + int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */ + wd = (int)(((x.iJD+43200000)/86400000)%7); + sqlite3_str_appendf(&sRes,"%02d",(nDay+7-wd)/7); + }else{ + sqlite3_str_appendf(&sRes,"%03d",nDay+1); } - default: z[j++] = '%'; break; + break; + } + case 'J': { + sqlite3_str_appendf(&sRes,"%.16g",x.iJD/86400000.0); + break; + } + case 'm': { + sqlite3_str_appendf(&sRes,"%02d",x.M); + break; + } + case 'M': { + sqlite3_str_appendf(&sRes,"%02d",x.m); + break; + } + case 's': { + i64 iS = (i64)(x.iJD/1000 - 21086676*(i64)10000); + sqlite3_str_appendf(&sRes,"%lld",iS); + break; + } + case 'S': { + sqlite3_str_appendf(&sRes,"%02d",(int)x.s); + break; + } + case 'w': { + sqlite3_str_appendchar(&sRes, 1, + (char)(((x.iJD+129600000)/86400000) % 7) + '0'); + break; + } + case 'Y': { + sqlite3_str_appendf(&sRes,"%04d",x.Y); + break; + } + case '%': { + sqlite3_str_appendchar(&sRes, 1, '%'); + break; + } + default: { + sqlite3_str_reset(&sRes); + return; } } } - z[j] = 0; - sqlite3_result_text(context, z, -1, - z==zBuf ? SQLITE_TRANSIENT : SQLITE_DYNAMIC); + if( jpMethods==0) ) return 0; return id->pMethods->xDeviceCharacteristics(id); } #ifndef SQLITE_OMIT_WAL @@ -23266,7 +24144,7 @@ SQLITE_PRIVATE int sqlite3OsOpen( SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ DO_OS_MALLOC_TEST(0); assert( dirSync==0 || dirSync==1 ); - return pVfs->xDelete(pVfs, zPath, dirSync); + return pVfs->xDelete!=0 ? pVfs->xDelete(pVfs, zPath, dirSync) : SQLITE_OK; } SQLITE_PRIVATE int sqlite3OsAccess( sqlite3_vfs *pVfs, @@ -23289,6 +24167,8 @@ SQLITE_PRIVATE int sqlite3OsFullPathname( } #ifndef SQLITE_OMIT_LOAD_EXTENSION SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){ + assert( zPath!=0 ); + assert( strlen(zPath)<=SQLITE_MAX_PATHLEN ); /* tag-20210611-1 */ return pVfs->xDlOpen(pVfs, zPath); } SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ @@ -23350,12 +24230,15 @@ SQLITE_PRIVATE int sqlite3OsOpenMalloc( rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); if( rc!=SQLITE_OK ){ sqlite3_free(pFile); + *ppFile = 0; }else{ *ppFile = pFile; } }else{ + *ppFile = 0; rc = SQLITE_NOMEM_BKPT; } + assert( *ppFile!=0 || rc!=SQLITE_OK ); return rc; } SQLITE_PRIVATE void sqlite3OsCloseFree(sqlite3_file *pFile){ @@ -24073,7 +24956,7 @@ static void adjustStats(int iSize, int increment){ ** This routine checks the guards at either end of the allocation and ** if they are incorrect it asserts. */ -static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){ +static struct MemBlockHdr *sqlite3MemsysGetHeader(const void *pAllocation){ struct MemBlockHdr *p; int *pInt; u8 *pU8; @@ -24320,7 +25203,7 @@ SQLITE_PRIVATE void sqlite3MemdebugSetType(void *p, u8 eType){ ** ** assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); */ -SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){ +SQLITE_PRIVATE int sqlite3MemdebugHasType(const void *p, u8 eType){ int rc = 1; if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ struct MemBlockHdr *pHdr; @@ -24342,7 +25225,7 @@ SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){ ** ** assert( sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); */ -SQLITE_PRIVATE int sqlite3MemdebugNoType(void *p, u8 eType){ +SQLITE_PRIVATE int sqlite3MemdebugNoType(const void *p, u8 eType){ int rc = 1; if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ struct MemBlockHdr *pHdr; @@ -26720,205 +27603,7 @@ SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ /* ** Include code that is common to all os_*.c files */ -/************** Include os_common.h in the middle of mutex_w32.c *************/ -/************** Begin file os_common.h ***************************************/ -/* -** 2004 May 22 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -****************************************************************************** -** -** This file contains macros and a little bit of code that is common to -** all of the platform-specific files (os_*.c) and is #included into those -** files. -** -** This file should be #included by the os_*.c files only. It is not a -** general purpose header file. -*/ -#ifndef _OS_COMMON_H_ -#define _OS_COMMON_H_ - -/* -** At least two bugs have slipped in because we changed the MEMORY_DEBUG -** macro to SQLITE_DEBUG and some older makefiles have not yet made the -** switch. The following code should catch this problem at compile-time. -*/ -#ifdef MEMORY_DEBUG -# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." -#endif - -/* -** Macros for performance tracing. Normally turned off. Only works -** on i486 hardware. -*/ -#ifdef SQLITE_PERFORMANCE_TRACE - -/* -** hwtime.h contains inline assembler code for implementing -** high-performance timing routines. -*/ -/************** Include hwtime.h in the middle of os_common.h ****************/ -/************** Begin file hwtime.h ******************************************/ -/* -** 2008 May 27 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -****************************************************************************** -** -** This file contains inline asm code for retrieving "high-performance" -** counters for x86 and x86_64 class CPUs. -*/ -#ifndef SQLITE_HWTIME_H -#define SQLITE_HWTIME_H - -/* -** The following routine only works on pentium-class (or newer) processors. -** It uses the RDTSC opcode to read the cycle count value out of the -** processor and returns that value. This can be used for high-res -** profiling. -*/ -#if !defined(__STRICT_ANSI__) && \ - (defined(__GNUC__) || defined(_MSC_VER)) && \ - (defined(i386) || defined(__i386__) || defined(_M_IX86)) - - #if defined(__GNUC__) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned int lo, hi; - __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); - return (sqlite_uint64)hi << 32 | lo; - } - - #elif defined(_MSC_VER) - - __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ - __asm { - rdtsc - ret ; return value at EDX:EAX - } - } - - #endif - -#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__)) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned long val; - __asm__ __volatile__ ("rdtsc" : "=A" (val)); - return val; - } - -#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__)) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned long long retval; - unsigned long junk; - __asm__ __volatile__ ("\n\ - 1: mftbu %1\n\ - mftb %L0\n\ - mftbu %0\n\ - cmpw %0,%1\n\ - bne 1b" - : "=r" (retval), "=r" (junk)); - return retval; - } - -#else - - /* - ** asm() is needed for hardware timing support. Without asm(), - ** disable the sqlite3Hwtime() routine. - ** - ** sqlite3Hwtime() is only used for some obscure debugging - ** and analysis configurations, not in any deliverable, so this - ** should not be a great loss. - */ -SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } - -#endif - -#endif /* !defined(SQLITE_HWTIME_H) */ - -/************** End of hwtime.h **********************************************/ -/************** Continuing where we left off in os_common.h ******************/ - -static sqlite_uint64 g_start; -static sqlite_uint64 g_elapsed; -#define TIMER_START g_start=sqlite3Hwtime() -#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start -#define TIMER_ELAPSED g_elapsed -#else -#define TIMER_START -#define TIMER_END -#define TIMER_ELAPSED ((sqlite_uint64)0) -#endif - -/* -** If we compile with the SQLITE_TEST macro set, then the following block -** of code will give us the ability to simulate a disk I/O error. This -** is used for testing the I/O recovery logic. -*/ -#if defined(SQLITE_TEST) -SQLITE_API extern int sqlite3_io_error_hit; -SQLITE_API extern int sqlite3_io_error_hardhit; -SQLITE_API extern int sqlite3_io_error_pending; -SQLITE_API extern int sqlite3_io_error_persist; -SQLITE_API extern int sqlite3_io_error_benign; -SQLITE_API extern int sqlite3_diskfull_pending; -SQLITE_API extern int sqlite3_diskfull; -#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) -#define SimulateIOError(CODE) \ - if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ - || sqlite3_io_error_pending-- == 1 ) \ - { local_ioerr(); CODE; } -static void local_ioerr(){ - IOTRACE(("IOERR\n")); - sqlite3_io_error_hit++; - if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; -} -#define SimulateDiskfullError(CODE) \ - if( sqlite3_diskfull_pending ){ \ - if( sqlite3_diskfull_pending == 1 ){ \ - local_ioerr(); \ - sqlite3_diskfull = 1; \ - sqlite3_io_error_hit = 1; \ - CODE; \ - }else{ \ - sqlite3_diskfull_pending--; \ - } \ - } -#else -#define SimulateIOErrorBenign(X) -#define SimulateIOError(A) -#define SimulateDiskfullError(A) -#endif /* defined(SQLITE_TEST) */ - -/* -** When testing, keep a count of the number of open files. -*/ -#if defined(SQLITE_TEST) -SQLITE_API extern int sqlite3_open_file_count; -#define OpenCounter(X) sqlite3_open_file_count+=(X) -#else -#define OpenCounter(X) -#endif /* defined(SQLITE_TEST) */ - -#endif /* !defined(_OS_COMMON_H_) */ - -/************** End of os_common.h *******************************************/ -/************** Continuing where we left off in mutex_w32.c ******************/ +/* #include "os_common.h" */ /* ** Include the header file for the Windows VFS. @@ -27556,7 +28241,6 @@ SQLITE_PRIVATE int sqlite3MallocInit(void){ if( sqlite3GlobalConfig.m.xMalloc==0 ){ sqlite3MemSetDefault(); } - memset(&mem0, 0, sizeof(mem0)); mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512 || sqlite3GlobalConfig.nPage<=0 ){ @@ -27712,7 +28396,7 @@ SQLITE_API void *sqlite3_malloc64(sqlite3_uint64 n){ ** TRUE if p is a lookaside memory allocation from db */ #ifndef SQLITE_OMIT_LOOKASIDE -static int isLookaside(sqlite3 *db, void *p){ +static int isLookaside(sqlite3 *db, const void *p){ return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pEnd); } #else @@ -27723,18 +28407,18 @@ static int isLookaside(sqlite3 *db, void *p){ ** Return the size of a memory allocation previously obtained from ** sqlite3Malloc() or sqlite3_malloc(). */ -SQLITE_PRIVATE int sqlite3MallocSize(void *p){ +SQLITE_PRIVATE int sqlite3MallocSize(const void *p){ assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); - return sqlite3GlobalConfig.m.xSize(p); + return sqlite3GlobalConfig.m.xSize((void*)p); } -static int lookasideMallocSize(sqlite3 *db, void *p){ +static int lookasideMallocSize(sqlite3 *db, const void *p){ #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE return plookaside.pMiddle ? db->lookaside.szTrue : LOOKASIDE_SMALL; #else return db->lookaside.szTrue; #endif } -SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){ +SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, const void *p){ assert( p!=0 ); #ifdef SQLITE_DEBUG if( db==0 || !isLookaside(db,p) ){ @@ -27761,7 +28445,7 @@ SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){ } } } - return sqlite3GlobalConfig.m.xSize(p); + return sqlite3GlobalConfig.m.xSize((void*)p); } SQLITE_API sqlite3_uint64 sqlite3_msize(void *p){ assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); @@ -28255,7 +28939,7 @@ SQLITE_PRIVATE int sqlite3ApiExit(sqlite3* db, int rc){ #define etSQLESCAPE2 10 /* Strings with '\'' doubled and enclosed in '', NULL pointers replaced by SQL NULL. %Q */ #define etTOKEN 11 /* a pointer to a Token structure */ -#define etSRCLIST 12 /* a pointer to a SrcList */ +#define etSRCITEM 12 /* a pointer to a SrcItem */ #define etPOINTER 13 /* The %p conversion */ #define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */ #define etORDINAL 15 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */ @@ -28321,10 +29005,16 @@ static const et_info fmtinfo[] = { /* All the rest are undocumented and are for internal use only */ { 'T', 0, 0, etTOKEN, 0, 0 }, - { 'S', 0, 0, etSRCLIST, 0, 0 }, + { 'S', 0, 0, etSRCITEM, 0, 0 }, { 'r', 10, 1, etORDINAL, 0, 0 }, }; +/* Notes: +** +** %S Takes a pointer to SrcItem. Shows name or database.name +** %!S Like %S but prefer the zName over the zAlias +*/ + /* Floating point constants used for rounding */ static const double arRound[] = { 5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05, @@ -28365,7 +29055,7 @@ static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){ /* ** Set the StrAccum object to an error mode. */ -static void setStrAccumError(StrAccum *p, u8 eError){ +SQLITE_PRIVATE void sqlite3StrAccumSetError(StrAccum *p, u8 eError){ assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG ); p->accError = eError; if( p->mxAlloc ) sqlite3_str_reset(p); @@ -28401,12 +29091,12 @@ static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){ char *z; if( pAccum->accError ) return 0; if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){ - setStrAccumError(pAccum, SQLITE_TOOBIG); + sqlite3StrAccumSetError(pAccum, SQLITE_TOOBIG); return 0; } z = sqlite3DbMallocRaw(pAccum->db, n); if( z==0 ){ - setStrAccumError(pAccum, SQLITE_NOMEM); + sqlite3StrAccumSetError(pAccum, SQLITE_NOMEM); } return z; } @@ -29079,21 +29769,24 @@ SQLITE_API void sqlite3_str_vappendf( length = width = 0; break; } - case etSRCLIST: { - SrcList *pSrc; - int k; - struct SrcList_item *pItem; + case etSRCITEM: { + SrcItem *pItem; if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; - pSrc = va_arg(ap, SrcList*); - k = va_arg(ap, int); - pItem = &pSrc->a[k]; + pItem = va_arg(ap, SrcItem*); assert( bArgList==0 ); - assert( k>=0 && knSrc ); - if( pItem->zDatabase ){ - sqlite3_str_appendall(pAccum, pItem->zDatabase); - sqlite3_str_append(pAccum, ".", 1); + if( pItem->zAlias && !flag_altform2 ){ + sqlite3_str_appendall(pAccum, pItem->zAlias); + }else if( pItem->zName ){ + if( pItem->zDatabase ){ + sqlite3_str_appendall(pAccum, pItem->zDatabase); + sqlite3_str_append(pAccum, ".", 1); + } + sqlite3_str_appendall(pAccum, pItem->zName); + }else if( pItem->zAlias ){ + sqlite3_str_appendall(pAccum, pItem->zAlias); + }else if( ALWAYS(pItem->pSelect) ){ + sqlite3_str_appendf(pAccum, "SUBQUERY %u", pItem->pSelect->selId); } - sqlite3_str_appendall(pAccum, pItem->zName); length = width = 0; break; } @@ -29142,12 +29835,12 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){ return 0; } if( p->mxAlloc==0 ){ - setStrAccumError(p, SQLITE_TOOBIG); + sqlite3StrAccumSetError(p, SQLITE_TOOBIG); return p->nAlloc - p->nChar - 1; }else{ char *zOld = isMalloced(p) ? p->zText : 0; i64 szNew = p->nChar; - szNew += N + 1; + szNew += (sqlite3_int64)N + 1; if( szNew+p->nChar<=p->mxAlloc ){ /* Force exponential buffer size growth as long as it does not overflow, ** to avoid having to call this routine too often */ @@ -29155,7 +29848,7 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){ } if( szNew > p->mxAlloc ){ sqlite3_str_reset(p); - setStrAccumError(p, SQLITE_TOOBIG); + sqlite3StrAccumSetError(p, SQLITE_TOOBIG); return 0; }else{ p->nAlloc = (int)szNew; @@ -29173,7 +29866,7 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){ p->printfFlags |= SQLITE_PRINTF_MALLOCED; }else{ sqlite3_str_reset(p); - setStrAccumError(p, SQLITE_NOMEM); + sqlite3StrAccumSetError(p, SQLITE_NOMEM); return 0; } } @@ -29246,7 +29939,7 @@ static SQLITE_NOINLINE char *strAccumFinishRealloc(StrAccum *p){ memcpy(zText, p->zText, p->nChar+1); p->printfFlags |= SQLITE_PRINTF_MALLOCED; }else{ - setStrAccumError(p, SQLITE_NOMEM); + sqlite3StrAccumSetError(p, SQLITE_NOMEM); } p->zText = zText; return zText; @@ -29261,6 +29954,22 @@ SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){ return p->zText; } +/* +** Use the content of the StrAccum passed as the second argument +** as the result of an SQL function. +*/ +SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context *pCtx, StrAccum *p){ + if( p->accError ){ + sqlite3_result_error_code(pCtx, p->accError); + sqlite3_str_reset(p); + }else if( isMalloced(p) ){ + sqlite3_result_text(pCtx, p->zText, p->nChar, SQLITE_DYNAMIC); + }else{ + sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC); + sqlite3_str_reset(p); + } +} + /* ** This singleton is an sqlite3_str object that is returned if ** sqlite3_malloc() fails to provide space for a real one. This @@ -29650,7 +30359,10 @@ SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 m } sqlite3_str_appendf(&x, ")"); } - sqlite3_str_appendf(&x, " AS"); + if( pCte->pUse ){ + sqlite3_str_appendf(&x, " (pUse=0x%p, nUse=%d)", pCte->pUse, + pCte->pUse->nUse); + } sqlite3StrAccumFinish(&x); sqlite3TreeViewItem(pView, zLine, inCte-1); sqlite3TreeViewSelect(pView, pCte->pSelect, 0); @@ -29666,29 +30378,27 @@ SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 m SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){ int i; for(i=0; inSrc; i++){ - const struct SrcList_item *pItem = &pSrc->a[i]; + const SrcItem *pItem = &pSrc->a[i]; StrAccum x; char zLine[100]; sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0); - sqlite3_str_appendf(&x, "{%d:*}", pItem->iCursor); - if( pItem->zDatabase ){ - sqlite3_str_appendf(&x, " %s.%s", pItem->zDatabase, pItem->zName); - }else if( pItem->zName ){ - sqlite3_str_appendf(&x, " %s", pItem->zName); - } + x.printfFlags |= SQLITE_PRINTF_INTERNAL; + sqlite3_str_appendf(&x, "{%d:*} %!S", pItem->iCursor, pItem); if( pItem->pTab ){ sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx", pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed); } - if( pItem->zAlias ){ - sqlite3_str_appendf(&x, " (AS %s)", pItem->zAlias); - } if( pItem->fg.jointype & JT_LEFT ){ sqlite3_str_appendf(&x, " LEFT-JOIN"); + }else if( pItem->fg.jointype & JT_CROSS ){ + sqlite3_str_appendf(&x, " CROSS-JOIN"); } if( pItem->fg.fromDDL ){ sqlite3_str_appendf(&x, " DDL"); } + if( pItem->fg.isCte ){ + sqlite3_str_appendf(&x, " CteUse=0x%p", pItem->u2.pCteUse); + } sqlite3StrAccumFinish(&x); sqlite3TreeViewItem(pView, zLine, inSrc-1); if( pItem->pSelect ){ @@ -29980,6 +30690,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m sqlite3TreeViewLine(pView, "COLUMN(%d)%s%s", pExpr->iColumn, zFlgs, zOp2); }else{ + assert( ExprUseYTab(pExpr) ); sqlite3TreeViewLine(pView, "{%d:%d} pTab=%p%s", pExpr->iTable, pExpr->iColumn, pExpr->y.pTab, zFlgs); @@ -29999,11 +30710,13 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m } #ifndef SQLITE_OMIT_FLOATING_POINT case TK_FLOAT: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); break; } #endif case TK_STRING: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken); break; } @@ -30012,17 +30725,19 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m break; } case TK_TRUEFALSE: { - sqlite3TreeViewLine(pView, - sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE"); + sqlite3TreeViewLine(pView,"%s%s", + sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs); break; } #ifndef SQLITE_OMIT_BLOB_LITERAL case TK_BLOB: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); break; } #endif case TK_VARIABLE: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3TreeViewLine(pView,"VARIABLE(%s,%d)", pExpr->u.zToken, pExpr->iColumn); break; @@ -30032,12 +30747,14 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m break; } case TK_ID: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken); break; } #ifndef SQLITE_OMIT_CAST case TK_CAST: { /* Expressions of the form: CAST(pLeft AS token) */ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken); sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); break; @@ -30087,6 +30804,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m } case TK_SPAN: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken); sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); break; @@ -30098,6 +30816,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m ** up in the treeview output as "SOFT-COLLATE". Explicit COLLATE ** operators that appear in the original SQL always have the ** EP_Collate bit set and appear in treeview output as just "COLLATE" */ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3TreeViewLine(pView, "%sCOLLATE %Q%s", !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "", pExpr->u.zToken, zFlgs); @@ -30113,6 +30832,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m pFarg = 0; pWin = 0; }else{ + assert( ExprUseXList(pExpr) ); pFarg = pExpr->x.pList; #ifndef SQLITE_OMIT_WINDOWFUNC pWin = ExprHasProperty(pExpr, EP_WinFunc) ? pExpr->y.pWin : 0; @@ -30120,6 +30840,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m pWin = 0; #endif } + assert( !ExprHasProperty(pExpr, EP_IntValue) ); if( pExpr->op==TK_AGG_FUNCTION ){ sqlite3TreeViewLine(pView, "AGG_FUNCTION%d %Q%s agg=%d[%d]/%p", pExpr->op2, pExpr->u.zToken, zFlgs, @@ -30151,11 +30872,13 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m } #ifndef SQLITE_OMIT_SUBQUERY case TK_EXISTS: { + assert( ExprUseXSelect(pExpr) ); sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags); sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); break; } case TK_SELECT: { + assert( ExprUseXSelect(pExpr) ); sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags); sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); break; @@ -30163,7 +30886,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m case TK_IN: { sqlite3TreeViewLine(pView, "IN flags=0x%x", pExpr->flags); sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( ExprUseXSelect(pExpr) ){ sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); }else{ sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); @@ -30184,9 +30907,12 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m ** Z is stored in pExpr->pList->a[1].pExpr. */ case TK_BETWEEN: { - Expr *pX = pExpr->pLeft; - Expr *pY = pExpr->x.pList->a[0].pExpr; - Expr *pZ = pExpr->x.pList->a[1].pExpr; + const Expr *pX, *pY, *pZ; + pX = pExpr->pLeft; + assert( ExprUseXList(pExpr) ); + assert( pExpr->x.pList->nExpr==2 ); + pY = pExpr->x.pList->a[0].pExpr; + pZ = pExpr->x.pList->a[1].pExpr; sqlite3TreeViewLine(pView, "BETWEEN"); sqlite3TreeViewExpr(pView, pX, 1); sqlite3TreeViewExpr(pView, pY, 1); @@ -30208,6 +30934,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m case TK_CASE: { sqlite3TreeViewLine(pView, "CASE"); sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + assert( ExprUseXList(pExpr) ); sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); break; } @@ -30220,6 +30947,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m case OE_Fail: zType = "fail"; break; case OE_Ignore: zType = "ignore"; break; } + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken); break; } @@ -30232,12 +30960,16 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m } case TK_VECTOR: { char *z = sqlite3_mprintf("VECTOR%s",zFlgs); + assert( ExprUseXList(pExpr) ); sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z); sqlite3_free(z); break; } case TK_SELECT_COLUMN: { - sqlite3TreeViewLine(pView, "SELECT-COLUMN %d", pExpr->iColumn); + sqlite3TreeViewLine(pView, "SELECT-COLUMN %d of [0..%d]%s", + pExpr->iColumn, pExpr->iTable-1, + pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : ""); + assert( ExprUseXSelect(pExpr->pLeft) ); sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0); break; } @@ -30246,6 +30978,23 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); break; } + case TK_ERROR: { + Expr tmp; + sqlite3TreeViewLine(pView, "ERROR"); + tmp = *pExpr; + tmp.op = pExpr->op2; + sqlite3TreeViewExpr(pView, &tmp, 0); + break; + } + case TK_ROW: { + if( pExpr->iColumn<=0 ){ + sqlite3TreeViewLine(pView, "First FROM table rowid"); + }else{ + sqlite3TreeViewLine(pView, "First FROM table column %d", + pExpr->iColumn-1); + } + break; + } default: { sqlite3TreeViewLine(pView, "op=%d", pExpr->op); break; @@ -30395,11 +31144,16 @@ SQLITE_API void sqlite3_randomness(int N, void *pBuf){ ** number generator) not as an encryption device. */ if( !wsdPrng.isInit ){ + sqlite3_vfs *pVfs = sqlite3_vfs_find(0); int i; char k[256]; wsdPrng.j = 0; wsdPrng.i = 0; - sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k); + if( NEVER(pVfs==0) ){ + memset(k, 0, sizeof(k)); + }else{ + sqlite3OsRandomness(pVfs, 256, k); + } for(i=0; i<256; i++){ wsdPrng.s[i] = (u8)i; } @@ -31292,16 +32046,6 @@ SQLITE_PRIVATE void sqlite3UtfSelfTest(void){ #include #endif -/* -** Routine needed to support the testcase() macro. -*/ -#ifdef SQLITE_COVERAGE_TEST -SQLITE_PRIVATE void sqlite3Coverage(int x){ - static unsigned dummy = 0; - dummy += (unsigned)x; -} -#endif - /* ** Calls to sqlite3FaultSim() are used to simulate a failure during testing, ** or to bypass normal error detection during testing in order to let @@ -31331,11 +32075,21 @@ SQLITE_PRIVATE int sqlite3FaultSim(int iTest){ #ifndef SQLITE_OMIT_FLOATING_POINT /* ** Return true if the floating point value is Not a Number (NaN). +** +** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN. +** Otherwise, we have our own implementation that works on most systems. */ SQLITE_PRIVATE int sqlite3IsNaN(double x){ + int rc; /* The value return */ +#if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN u64 y; memcpy(&y,&x,sizeof(y)); - return IsNaN(y); + rc = IsNaN(y); +#else + rc = isnan(x); +#endif /* HAVE_ISNAN */ + testcase( rc ); + return rc; } #endif /* SQLITE_OMIT_FLOATING_POINT */ @@ -31360,8 +32114,14 @@ SQLITE_PRIVATE int sqlite3Strlen30(const char *z){ ** the column name if and only if the COLFLAG_HASTYPE flag is set. */ SQLITE_PRIVATE char *sqlite3ColumnType(Column *pCol, char *zDflt){ - if( (pCol->colFlags & COLFLAG_HASTYPE)==0 ) return zDflt; - return pCol->zName + strlen(pCol->zName) + 1; + if( pCol->colFlags & COLFLAG_HASTYPE ){ + return pCol->zCnName + strlen(pCol->zCnName) + 1; + }else if( pCol->eCType ){ + assert( pCol->eCType<=SQLITE_N_STDTYPE ); + return (char*)sqlite3StdType[pCol->eCType-1]; + }else{ + return zDflt; + } } /* @@ -31385,6 +32145,16 @@ SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code){ if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code); } +/* +** The equivalent of sqlite3Error(db, SQLITE_OK). Clear the error state +** and error message. +*/ +SQLITE_PRIVATE void sqlite3ErrorClear(sqlite3 *db){ + assert( db!=0 ); + db->errCode = SQLITE_OK; + if( db->pErr ) sqlite3ValueSetNull(db->pErr); +} + /* ** Load the sqlite3.iSysErrno field if that is an appropriate thing ** to do based on the SQLite error code in rc. @@ -31522,11 +32292,34 @@ SQLITE_PRIVATE void sqlite3Dequote(char *z){ z[j] = 0; } SQLITE_PRIVATE void sqlite3DequoteExpr(Expr *p){ + assert( !ExprHasProperty(p, EP_IntValue) ); assert( sqlite3Isquote(p->u.zToken[0]) ); p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted; sqlite3Dequote(p->u.zToken); } +/* +** If the input token p is quoted, try to adjust the token to remove +** the quotes. This is not always possible: +** +** "abc" -> abc +** "ab""cd" -> (not possible because of the interior "") +** +** Remove the quotes if possible. This is a optimization. The overall +** system should still return the correct answer even if this routine +** is always a no-op. +*/ +SQLITE_PRIVATE void sqlite3DequoteToken(Token *p){ + unsigned int i; + if( p->n<2 ) return; + if( !sqlite3Isquote(p->z[0]) ) return; + for(i=1; in-1; i++){ + if( sqlite3Isquote(p->z[i]) ) return; + } + p->n -= 2; + p->z++; +} + /* ** Generate a Token object from a string */ @@ -32632,13 +33425,13 @@ static void logBadConnection(const char *zType){ ** used as an argument to sqlite3_errmsg() or sqlite3_close(). */ SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3 *db){ - u32 magic; + u8 eOpenState; if( db==0 ){ logBadConnection("NULL"); return 0; } - magic = db->magic; - if( magic!=SQLITE_MAGIC_OPEN ){ + eOpenState = db->eOpenState; + if( eOpenState!=SQLITE_STATE_OPEN ){ if( sqlite3SafetyCheckSickOrOk(db) ){ testcase( sqlite3GlobalConfig.xLog!=0 ); logBadConnection("unopened"); @@ -32649,11 +33442,11 @@ SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3 *db){ } } SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3 *db){ - u32 magic; - magic = db->magic; - if( magic!=SQLITE_MAGIC_SICK && - magic!=SQLITE_MAGIC_OPEN && - magic!=SQLITE_MAGIC_BUSY ){ + u8 eOpenState; + eOpenState = db->eOpenState; + if( eOpenState!=SQLITE_STATE_SICK && + eOpenState!=SQLITE_STATE_OPEN && + eOpenState!=SQLITE_STATE_BUSY ){ testcase( sqlite3GlobalConfig.xLog!=0 ); logBadConnection("invalid"); return 0; @@ -33272,35 +34065,35 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){ /* 18 */ "If" OpHelp(""), /* 19 */ "Not" OpHelp("r[P2]= !r[P1]"), /* 20 */ "IfNot" OpHelp(""), - /* 21 */ "IfNullRow" OpHelp("if P1.nullRow then r[P3]=NULL, goto P2"), - /* 22 */ "SeekLT" OpHelp("key=r[P3@P4]"), - /* 23 */ "SeekLE" OpHelp("key=r[P3@P4]"), - /* 24 */ "SeekGE" OpHelp("key=r[P3@P4]"), - /* 25 */ "SeekGT" OpHelp("key=r[P3@P4]"), - /* 26 */ "IfNotOpen" OpHelp("if( !csr[P1] ) goto P2"), - /* 27 */ "IfNoHope" OpHelp("key=r[P3@P4]"), - /* 28 */ "NoConflict" OpHelp("key=r[P3@P4]"), - /* 29 */ "NotFound" OpHelp("key=r[P3@P4]"), - /* 30 */ "Found" OpHelp("key=r[P3@P4]"), - /* 31 */ "SeekRowid" OpHelp("intkey=r[P3]"), - /* 32 */ "NotExists" OpHelp("intkey=r[P3]"), - /* 33 */ "Last" OpHelp(""), - /* 34 */ "IfSmaller" OpHelp(""), - /* 35 */ "SorterSort" OpHelp(""), - /* 36 */ "Sort" OpHelp(""), - /* 37 */ "Rewind" OpHelp(""), - /* 38 */ "IdxLE" OpHelp("key=r[P3@P4]"), - /* 39 */ "IdxGT" OpHelp("key=r[P3@P4]"), - /* 40 */ "IdxLT" OpHelp("key=r[P3@P4]"), - /* 41 */ "IdxGE" OpHelp("key=r[P3@P4]"), - /* 42 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"), + /* 21 */ "IsNullOrType" OpHelp("if typeof(r[P1]) IN (P3,5) goto P2"), + /* 22 */ "IfNullRow" OpHelp("if P1.nullRow then r[P3]=NULL, goto P2"), + /* 23 */ "SeekLT" OpHelp("key=r[P3@P4]"), + /* 24 */ "SeekLE" OpHelp("key=r[P3@P4]"), + /* 25 */ "SeekGE" OpHelp("key=r[P3@P4]"), + /* 26 */ "SeekGT" OpHelp("key=r[P3@P4]"), + /* 27 */ "IfNotOpen" OpHelp("if( !csr[P1] ) goto P2"), + /* 28 */ "IfNoHope" OpHelp("key=r[P3@P4]"), + /* 29 */ "NoConflict" OpHelp("key=r[P3@P4]"), + /* 30 */ "NotFound" OpHelp("key=r[P3@P4]"), + /* 31 */ "Found" OpHelp("key=r[P3@P4]"), + /* 32 */ "SeekRowid" OpHelp("intkey=r[P3]"), + /* 33 */ "NotExists" OpHelp("intkey=r[P3]"), + /* 34 */ "Last" OpHelp(""), + /* 35 */ "IfSmaller" OpHelp(""), + /* 36 */ "SorterSort" OpHelp(""), + /* 37 */ "Sort" OpHelp(""), + /* 38 */ "Rewind" OpHelp(""), + /* 39 */ "IdxLE" OpHelp("key=r[P3@P4]"), + /* 40 */ "IdxGT" OpHelp("key=r[P3@P4]"), + /* 41 */ "IdxLT" OpHelp("key=r[P3@P4]"), + /* 42 */ "IdxGE" OpHelp("key=r[P3@P4]"), /* 43 */ "Or" OpHelp("r[P3]=(r[P1] || r[P2])"), /* 44 */ "And" OpHelp("r[P3]=(r[P1] && r[P2])"), - /* 45 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"), - /* 46 */ "Program" OpHelp(""), - /* 47 */ "FkIfZero" OpHelp("if fkctr[P1]==0 goto P2"), - /* 48 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"), - /* 49 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]--, goto P2"), + /* 45 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"), + /* 46 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"), + /* 47 */ "Program" OpHelp(""), + /* 48 */ "FkIfZero" OpHelp("if fkctr[P1]==0 goto P2"), + /* 49 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"), /* 50 */ "IsNull" OpHelp("if r[P1]==NULL goto P2"), /* 51 */ "NotNull" OpHelp("if r[P1]!=NULL goto P2"), /* 52 */ "Ne" OpHelp("IF r[P3]!=r[P1]"), @@ -33309,125 +34102,130 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){ /* 55 */ "Le" OpHelp("IF r[P3]<=r[P1]"), /* 56 */ "Lt" OpHelp("IF r[P3]=r[P1]"), - /* 58 */ "ElseNotEq" OpHelp(""), - /* 59 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"), - /* 60 */ "IncrVacuum" OpHelp(""), - /* 61 */ "VNext" OpHelp(""), - /* 62 */ "Init" OpHelp("Start at P2"), - /* 63 */ "PureFunc" OpHelp("r[P3]=func(r[P2@NP])"), - /* 64 */ "Function" OpHelp("r[P3]=func(r[P2@NP])"), - /* 65 */ "Return" OpHelp(""), - /* 66 */ "EndCoroutine" OpHelp(""), - /* 67 */ "HaltIfNull" OpHelp("if r[P3]=null halt"), - /* 68 */ "Halt" OpHelp(""), - /* 69 */ "Integer" OpHelp("r[P2]=P1"), - /* 70 */ "Int64" OpHelp("r[P2]=P4"), - /* 71 */ "String" OpHelp("r[P2]='P4' (len=P1)"), - /* 72 */ "Null" OpHelp("r[P2..P3]=NULL"), - /* 73 */ "SoftNull" OpHelp("r[P1]=NULL"), - /* 74 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"), - /* 75 */ "Variable" OpHelp("r[P2]=parameter(P1,P4)"), - /* 76 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"), - /* 77 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"), - /* 78 */ "SCopy" OpHelp("r[P2]=r[P1]"), - /* 79 */ "IntCopy" OpHelp("r[P2]=r[P1]"), - /* 80 */ "ResultRow" OpHelp("output=r[P1@P2]"), - /* 81 */ "CollSeq" OpHelp(""), - /* 82 */ "AddImm" OpHelp("r[P1]=r[P1]+P2"), - /* 83 */ "RealAffinity" OpHelp(""), - /* 84 */ "Cast" OpHelp("affinity(r[P1])"), - /* 85 */ "Permutation" OpHelp(""), - /* 86 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"), - /* 87 */ "IsTrue" OpHelp("r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4"), - /* 88 */ "Offset" OpHelp("r[P3] = sqlite_offset(P1)"), - /* 89 */ "Column" OpHelp("r[P3]=PX"), - /* 90 */ "Affinity" OpHelp("affinity(r[P1@P2])"), - /* 91 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"), - /* 92 */ "Count" OpHelp("r[P2]=count()"), - /* 93 */ "ReadCookie" OpHelp(""), - /* 94 */ "SetCookie" OpHelp(""), - /* 95 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"), - /* 96 */ "OpenRead" OpHelp("root=P2 iDb=P3"), - /* 97 */ "OpenWrite" OpHelp("root=P2 iDb=P3"), - /* 98 */ "OpenDup" OpHelp(""), - /* 99 */ "OpenAutoindex" OpHelp("nColumn=P2"), - /* 100 */ "OpenEphemeral" OpHelp("nColumn=P2"), - /* 101 */ "BitAnd" OpHelp("r[P3]=r[P1]&r[P2]"), - /* 102 */ "BitOr" OpHelp("r[P3]=r[P1]|r[P2]"), - /* 103 */ "ShiftLeft" OpHelp("r[P3]=r[P2]<>r[P1]"), - /* 105 */ "Add" OpHelp("r[P3]=r[P1]+r[P2]"), - /* 106 */ "Subtract" OpHelp("r[P3]=r[P2]-r[P1]"), - /* 107 */ "Multiply" OpHelp("r[P3]=r[P1]*r[P2]"), - /* 108 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"), - /* 109 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"), - /* 110 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"), - /* 111 */ "SorterOpen" OpHelp(""), - /* 112 */ "BitNot" OpHelp("r[P2]= ~r[P1]"), - /* 113 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"), - /* 114 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"), - /* 115 */ "String8" OpHelp("r[P2]='P4'"), - /* 116 */ "Close" OpHelp(""), - /* 117 */ "ColumnsUsed" OpHelp(""), - /* 118 */ "SeekScan" OpHelp("Scan-ahead up to P1 rows"), - /* 119 */ "SeekHit" OpHelp("set P2<=seekHit<=P3"), - /* 120 */ "Sequence" OpHelp("r[P2]=cursor[P1].ctr++"), - /* 121 */ "NewRowid" OpHelp("r[P2]=rowid"), - /* 122 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"), - /* 123 */ "Delete" OpHelp(""), - /* 124 */ "ResetCount" OpHelp(""), - /* 125 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"), - /* 126 */ "SorterData" OpHelp("r[P2]=data"), - /* 127 */ "RowData" OpHelp("r[P2]=data"), - /* 128 */ "Rowid" OpHelp("r[P2]=rowid"), - /* 129 */ "NullRow" OpHelp(""), - /* 130 */ "SeekEnd" OpHelp(""), - /* 131 */ "IdxInsert" OpHelp("key=r[P2]"), - /* 132 */ "SorterInsert" OpHelp("key=r[P2]"), - /* 133 */ "IdxDelete" OpHelp("key=r[P2@P3]"), - /* 134 */ "DeferredSeek" OpHelp("Move P3 to P1.rowid if needed"), - /* 135 */ "IdxRowid" OpHelp("r[P2]=rowid"), - /* 136 */ "FinishSeek" OpHelp(""), - /* 137 */ "Destroy" OpHelp(""), - /* 138 */ "Clear" OpHelp(""), - /* 139 */ "ResetSorter" OpHelp(""), - /* 140 */ "CreateBtree" OpHelp("r[P2]=root iDb=P1 flags=P3"), - /* 141 */ "SqlExec" OpHelp(""), - /* 142 */ "ParseSchema" OpHelp(""), - /* 143 */ "LoadAnalysis" OpHelp(""), - /* 144 */ "DropTable" OpHelp(""), - /* 145 */ "DropIndex" OpHelp(""), - /* 146 */ "DropTrigger" OpHelp(""), - /* 147 */ "IntegrityCk" OpHelp(""), - /* 148 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"), - /* 149 */ "Param" OpHelp(""), - /* 150 */ "Real" OpHelp("r[P2]=P4"), - /* 151 */ "FkCounter" OpHelp("fkctr[P1]+=P2"), - /* 152 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"), - /* 153 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"), - /* 154 */ "AggInverse" OpHelp("accum=r[P3] inverse(r[P2@P5])"), - /* 155 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"), - /* 156 */ "AggStep1" OpHelp("accum=r[P3] step(r[P2@P5])"), - /* 157 */ "AggValue" OpHelp("r[P3]=value N=P2"), - /* 158 */ "AggFinal" OpHelp("accum=r[P1] N=P2"), - /* 159 */ "Expire" OpHelp(""), - /* 160 */ "CursorLock" OpHelp(""), - /* 161 */ "CursorUnlock" OpHelp(""), - /* 162 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"), - /* 163 */ "VBegin" OpHelp(""), - /* 164 */ "VCreate" OpHelp(""), - /* 165 */ "VDestroy" OpHelp(""), - /* 166 */ "VOpen" OpHelp(""), - /* 167 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"), - /* 168 */ "VRename" OpHelp(""), - /* 169 */ "Pagecount" OpHelp(""), - /* 170 */ "MaxPgcnt" OpHelp(""), - /* 171 */ "Trace" OpHelp(""), - /* 172 */ "CursorHint" OpHelp(""), - /* 173 */ "ReleaseReg" OpHelp("release r[P1@P2] mask P3"), - /* 174 */ "Noop" OpHelp(""), - /* 175 */ "Explain" OpHelp(""), - /* 176 */ "Abortable" OpHelp(""), + /* 58 */ "ElseEq" OpHelp(""), + /* 59 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]--, goto P2"), + /* 60 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"), + /* 61 */ "IncrVacuum" OpHelp(""), + /* 62 */ "VNext" OpHelp(""), + /* 63 */ "Init" OpHelp("Start at P2"), + /* 64 */ "PureFunc" OpHelp("r[P3]=func(r[P2@NP])"), + /* 65 */ "Function" OpHelp("r[P3]=func(r[P2@NP])"), + /* 66 */ "Return" OpHelp(""), + /* 67 */ "EndCoroutine" OpHelp(""), + /* 68 */ "HaltIfNull" OpHelp("if r[P3]=null halt"), + /* 69 */ "Halt" OpHelp(""), + /* 70 */ "Integer" OpHelp("r[P2]=P1"), + /* 71 */ "Int64" OpHelp("r[P2]=P4"), + /* 72 */ "String" OpHelp("r[P2]='P4' (len=P1)"), + /* 73 */ "Null" OpHelp("r[P2..P3]=NULL"), + /* 74 */ "SoftNull" OpHelp("r[P1]=NULL"), + /* 75 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"), + /* 76 */ "Variable" OpHelp("r[P2]=parameter(P1,P4)"), + /* 77 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"), + /* 78 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"), + /* 79 */ "SCopy" OpHelp("r[P2]=r[P1]"), + /* 80 */ "IntCopy" OpHelp("r[P2]=r[P1]"), + /* 81 */ "ChngCntRow" OpHelp("output=r[P1]"), + /* 82 */ "ResultRow" OpHelp("output=r[P1@P2]"), + /* 83 */ "CollSeq" OpHelp(""), + /* 84 */ "AddImm" OpHelp("r[P1]=r[P1]+P2"), + /* 85 */ "RealAffinity" OpHelp(""), + /* 86 */ "Cast" OpHelp("affinity(r[P1])"), + /* 87 */ "Permutation" OpHelp(""), + /* 88 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"), + /* 89 */ "IsTrue" OpHelp("r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4"), + /* 90 */ "ZeroOrNull" OpHelp("r[P2] = 0 OR NULL"), + /* 91 */ "Offset" OpHelp("r[P3] = sqlite_offset(P1)"), + /* 92 */ "Column" OpHelp("r[P3]=PX"), + /* 93 */ "TypeCheck" OpHelp("typecheck(r[P1@P2])"), + /* 94 */ "Affinity" OpHelp("affinity(r[P1@P2])"), + /* 95 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"), + /* 96 */ "Count" OpHelp("r[P2]=count()"), + /* 97 */ "ReadCookie" OpHelp(""), + /* 98 */ "SetCookie" OpHelp(""), + /* 99 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"), + /* 100 */ "OpenRead" OpHelp("root=P2 iDb=P3"), + /* 101 */ "OpenWrite" OpHelp("root=P2 iDb=P3"), + /* 102 */ "BitAnd" OpHelp("r[P3]=r[P1]&r[P2]"), + /* 103 */ "BitOr" OpHelp("r[P3]=r[P1]|r[P2]"), + /* 104 */ "ShiftLeft" OpHelp("r[P3]=r[P2]<>r[P1]"), + /* 106 */ "Add" OpHelp("r[P3]=r[P1]+r[P2]"), + /* 107 */ "Subtract" OpHelp("r[P3]=r[P2]-r[P1]"), + /* 108 */ "Multiply" OpHelp("r[P3]=r[P1]*r[P2]"), + /* 109 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"), + /* 110 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"), + /* 111 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"), + /* 112 */ "OpenDup" OpHelp(""), + /* 113 */ "BitNot" OpHelp("r[P2]= ~r[P1]"), + /* 114 */ "OpenAutoindex" OpHelp("nColumn=P2"), + /* 115 */ "OpenEphemeral" OpHelp("nColumn=P2"), + /* 116 */ "String8" OpHelp("r[P2]='P4'"), + /* 117 */ "SorterOpen" OpHelp(""), + /* 118 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"), + /* 119 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"), + /* 120 */ "Close" OpHelp(""), + /* 121 */ "ColumnsUsed" OpHelp(""), + /* 122 */ "SeekScan" OpHelp("Scan-ahead up to P1 rows"), + /* 123 */ "SeekHit" OpHelp("set P2<=seekHit<=P3"), + /* 124 */ "Sequence" OpHelp("r[P2]=cursor[P1].ctr++"), + /* 125 */ "NewRowid" OpHelp("r[P2]=rowid"), + /* 126 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"), + /* 127 */ "RowCell" OpHelp(""), + /* 128 */ "Delete" OpHelp(""), + /* 129 */ "ResetCount" OpHelp(""), + /* 130 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"), + /* 131 */ "SorterData" OpHelp("r[P2]=data"), + /* 132 */ "RowData" OpHelp("r[P2]=data"), + /* 133 */ "Rowid" OpHelp("r[P2]=rowid"), + /* 134 */ "NullRow" OpHelp(""), + /* 135 */ "SeekEnd" OpHelp(""), + /* 136 */ "IdxInsert" OpHelp("key=r[P2]"), + /* 137 */ "SorterInsert" OpHelp("key=r[P2]"), + /* 138 */ "IdxDelete" OpHelp("key=r[P2@P3]"), + /* 139 */ "DeferredSeek" OpHelp("Move P3 to P1.rowid if needed"), + /* 140 */ "IdxRowid" OpHelp("r[P2]=rowid"), + /* 141 */ "FinishSeek" OpHelp(""), + /* 142 */ "Destroy" OpHelp(""), + /* 143 */ "Clear" OpHelp(""), + /* 144 */ "ResetSorter" OpHelp(""), + /* 145 */ "CreateBtree" OpHelp("r[P2]=root iDb=P1 flags=P3"), + /* 146 */ "SqlExec" OpHelp(""), + /* 147 */ "ParseSchema" OpHelp(""), + /* 148 */ "LoadAnalysis" OpHelp(""), + /* 149 */ "DropTable" OpHelp(""), + /* 150 */ "DropIndex" OpHelp(""), + /* 151 */ "DropTrigger" OpHelp(""), + /* 152 */ "Real" OpHelp("r[P2]=P4"), + /* 153 */ "IntegrityCk" OpHelp(""), + /* 154 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"), + /* 155 */ "Param" OpHelp(""), + /* 156 */ "FkCounter" OpHelp("fkctr[P1]+=P2"), + /* 157 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"), + /* 158 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"), + /* 159 */ "AggInverse" OpHelp("accum=r[P3] inverse(r[P2@P5])"), + /* 160 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"), + /* 161 */ "AggStep1" OpHelp("accum=r[P3] step(r[P2@P5])"), + /* 162 */ "AggValue" OpHelp("r[P3]=value N=P2"), + /* 163 */ "AggFinal" OpHelp("accum=r[P1] N=P2"), + /* 164 */ "Expire" OpHelp(""), + /* 165 */ "CursorLock" OpHelp(""), + /* 166 */ "CursorUnlock" OpHelp(""), + /* 167 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"), + /* 168 */ "VBegin" OpHelp(""), + /* 169 */ "VCreate" OpHelp(""), + /* 170 */ "VDestroy" OpHelp(""), + /* 171 */ "VOpen" OpHelp(""), + /* 172 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"), + /* 173 */ "VRename" OpHelp(""), + /* 174 */ "Pagecount" OpHelp(""), + /* 175 */ "MaxPgcnt" OpHelp(""), + /* 176 */ "Trace" OpHelp(""), + /* 177 */ "CursorHint" OpHelp(""), + /* 178 */ "ReleaseReg" OpHelp("release r[P1@P2] mask P3"), + /* 179 */ "Noop" OpHelp(""), + /* 180 */ "Explain" OpHelp(""), + /* 181 */ "Abortable" OpHelp(""), }; return azName[i]; } @@ -33734,205 +34532,7 @@ static pid_t randomnessPid = 0; /* ** Include code that is common to all os_*.c files */ -/************** Include os_common.h in the middle of os_unix.c ***************/ -/************** Begin file os_common.h ***************************************/ -/* -** 2004 May 22 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -****************************************************************************** -** -** This file contains macros and a little bit of code that is common to -** all of the platform-specific files (os_*.c) and is #included into those -** files. -** -** This file should be #included by the os_*.c files only. It is not a -** general purpose header file. -*/ -#ifndef _OS_COMMON_H_ -#define _OS_COMMON_H_ - -/* -** At least two bugs have slipped in because we changed the MEMORY_DEBUG -** macro to SQLITE_DEBUG and some older makefiles have not yet made the -** switch. The following code should catch this problem at compile-time. -*/ -#ifdef MEMORY_DEBUG -# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." -#endif - -/* -** Macros for performance tracing. Normally turned off. Only works -** on i486 hardware. -*/ -#ifdef SQLITE_PERFORMANCE_TRACE - -/* -** hwtime.h contains inline assembler code for implementing -** high-performance timing routines. -*/ -/************** Include hwtime.h in the middle of os_common.h ****************/ -/************** Begin file hwtime.h ******************************************/ -/* -** 2008 May 27 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -****************************************************************************** -** -** This file contains inline asm code for retrieving "high-performance" -** counters for x86 and x86_64 class CPUs. -*/ -#ifndef SQLITE_HWTIME_H -#define SQLITE_HWTIME_H - -/* -** The following routine only works on pentium-class (or newer) processors. -** It uses the RDTSC opcode to read the cycle count value out of the -** processor and returns that value. This can be used for high-res -** profiling. -*/ -#if !defined(__STRICT_ANSI__) && \ - (defined(__GNUC__) || defined(_MSC_VER)) && \ - (defined(i386) || defined(__i386__) || defined(_M_IX86)) - - #if defined(__GNUC__) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned int lo, hi; - __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); - return (sqlite_uint64)hi << 32 | lo; - } - - #elif defined(_MSC_VER) - - __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ - __asm { - rdtsc - ret ; return value at EDX:EAX - } - } - - #endif - -#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__)) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned long val; - __asm__ __volatile__ ("rdtsc" : "=A" (val)); - return val; - } - -#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__)) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned long long retval; - unsigned long junk; - __asm__ __volatile__ ("\n\ - 1: mftbu %1\n\ - mftb %L0\n\ - mftbu %0\n\ - cmpw %0,%1\n\ - bne 1b" - : "=r" (retval), "=r" (junk)); - return retval; - } - -#else - - /* - ** asm() is needed for hardware timing support. Without asm(), - ** disable the sqlite3Hwtime() routine. - ** - ** sqlite3Hwtime() is only used for some obscure debugging - ** and analysis configurations, not in any deliverable, so this - ** should not be a great loss. - */ -SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } - -#endif - -#endif /* !defined(SQLITE_HWTIME_H) */ - -/************** End of hwtime.h **********************************************/ -/************** Continuing where we left off in os_common.h ******************/ - -static sqlite_uint64 g_start; -static sqlite_uint64 g_elapsed; -#define TIMER_START g_start=sqlite3Hwtime() -#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start -#define TIMER_ELAPSED g_elapsed -#else -#define TIMER_START -#define TIMER_END -#define TIMER_ELAPSED ((sqlite_uint64)0) -#endif - -/* -** If we compile with the SQLITE_TEST macro set, then the following block -** of code will give us the ability to simulate a disk I/O error. This -** is used for testing the I/O recovery logic. -*/ -#if defined(SQLITE_TEST) -SQLITE_API extern int sqlite3_io_error_hit; -SQLITE_API extern int sqlite3_io_error_hardhit; -SQLITE_API extern int sqlite3_io_error_pending; -SQLITE_API extern int sqlite3_io_error_persist; -SQLITE_API extern int sqlite3_io_error_benign; -SQLITE_API extern int sqlite3_diskfull_pending; -SQLITE_API extern int sqlite3_diskfull; -#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) -#define SimulateIOError(CODE) \ - if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ - || sqlite3_io_error_pending-- == 1 ) \ - { local_ioerr(); CODE; } -static void local_ioerr(){ - IOTRACE(("IOERR\n")); - sqlite3_io_error_hit++; - if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; -} -#define SimulateDiskfullError(CODE) \ - if( sqlite3_diskfull_pending ){ \ - if( sqlite3_diskfull_pending == 1 ){ \ - local_ioerr(); \ - sqlite3_diskfull = 1; \ - sqlite3_io_error_hit = 1; \ - CODE; \ - }else{ \ - sqlite3_diskfull_pending--; \ - } \ - } -#else -#define SimulateIOErrorBenign(X) -#define SimulateIOError(A) -#define SimulateDiskfullError(A) -#endif /* defined(SQLITE_TEST) */ - -/* -** When testing, keep a count of the number of open files. -*/ -#if defined(SQLITE_TEST) -SQLITE_API extern int sqlite3_open_file_count; -#define OpenCounter(X) sqlite3_open_file_count+=(X) -#else -#define OpenCounter(X) -#endif /* defined(SQLITE_TEST) */ - -#endif /* !defined(_OS_COMMON_H_) */ - -/************** End of os_common.h *******************************************/ -/************** Continuing where we left off in os_unix.c ********************/ +/* #include "os_common.h" */ /* ** Define various macros that are missing from some systems. @@ -37586,6 +38186,9 @@ static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){ /* Forward declaration */ static int unixGetTempname(int nBuf, char *zBuf); +#ifndef SQLITE_OMIT_WAL + static int unixFcntlExternalReader(unixFile*, int*); +#endif /* ** Information and control of an open file handle. @@ -37702,6 +38305,15 @@ static int unixFileControl(sqlite3_file *id, int op, void *pArg){ return proxyFileControl(id,op,pArg); } #endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */ + + case SQLITE_FCNTL_EXTERNAL_READER: { +#ifndef SQLITE_OMIT_WAL + return unixFcntlExternalReader((unixFile*)id, (int*)pArg); +#else + *(int*)pArg = 0; + return SQLITE_OK; +#endif + } } return SQLITE_NOTFOUND; } @@ -37947,6 +38559,40 @@ struct unixShm { #define UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */ #define UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */ +/* +** Use F_GETLK to check whether or not there are any readers with open +** wal-mode transactions in other processes on database file pFile. If +** no error occurs, return SQLITE_OK and set (*piOut) to 1 if there are +** such transactions, or 0 otherwise. If an error occurs, return an +** SQLite error code. The final value of *piOut is undefined in this +** case. +*/ +static int unixFcntlExternalReader(unixFile *pFile, int *piOut){ + int rc = SQLITE_OK; + *piOut = 0; + if( pFile->pShm){ + unixShmNode *pShmNode = pFile->pShm->pShmNode; + struct flock f; + + memset(&f, 0, sizeof(f)); + f.l_type = F_WRLCK; + f.l_whence = SEEK_SET; + f.l_start = UNIX_SHM_BASE + 3; + f.l_len = SQLITE_SHM_NLOCK - 3; + + sqlite3_mutex_enter(pShmNode->pShmMutex); + if( osFcntl(pShmNode->hShm, F_GETLK, &f)<0 ){ + rc = SQLITE_IOERR_LOCK; + }else{ + *piOut = (f.l_type!=F_UNLCK); + } + sqlite3_mutex_leave(pShmNode->pShmMutex); + } + + return rc; +} + + /* ** Apply posix advisory locks for all bytes from ofst through ofst+n-1. ** @@ -39387,25 +40033,35 @@ static int fillInUnixFile( return rc; } +/* +** Directories to consider for temp files. +*/ +static const char *azTempDirs[] = { + 0, + 0, + "/var/tmp", + "/usr/tmp", + "/tmp", + "." +}; + +/* +** Initialize first two members of azTempDirs[] array. +*/ +static void unixTempFileInit(void){ + azTempDirs[0] = getenv("SQLITE_TMPDIR"); + azTempDirs[1] = getenv("TMPDIR"); +} + /* ** Return the name of a directory in which to put temporary files. ** If no suitable temporary file directory can be found, return NULL. */ static const char *unixTempFileDir(void){ - static const char *azDirs[] = { - 0, - 0, - "/var/tmp", - "/usr/tmp", - "/tmp", - "." - }; unsigned int i = 0; struct stat buf; const char *zDir = sqlite3_temp_directory; - if( !azDirs[0] ) azDirs[0] = getenv("SQLITE_TMPDIR"); - if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR"); while(1){ if( zDir!=0 && osStat(zDir, &buf)==0 @@ -39414,8 +40070,8 @@ static const char *unixTempFileDir(void){ ){ return zDir; } - if( i>=sizeof(azDirs)/sizeof(azDirs[0]) ) break; - zDir = azDirs[i++]; + if( i>=sizeof(azTempDirs)/sizeof(azTempDirs[0]) ) break; + zDir = azTempDirs[i++]; } return 0; } @@ -39721,6 +40377,11 @@ static int unixOpen( } memset(p, 0, sizeof(unixFile)); +#ifdef SQLITE_ASSERT_NO_FILES + /* Applications that never read or write a persistent disk files */ + assert( zName==0 ); +#endif + if( eType==SQLITE_OPEN_MAIN_DB ){ UnixUnusedFd *pUnused; pUnused = findReusableFd(zName, flags); @@ -39996,7 +40657,8 @@ static int unixBackupDir(const char *z, int *pJ){ int j = *pJ; int i; if( j<=0 ) return 0; - for(i=j-1; ALWAYS(i>0) && z[i-1]!='/'; i--){} + for(i=j-1; i>0 && z[i-1]!='/'; i--){} + if( i==0 ) return 0; if( z[i]=='.' && i==j-2 && z[i+1]=='.' ) return 0; *pJ = i-1; return 1; @@ -41662,6 +42324,28 @@ SQLITE_API int sqlite3_os_init(void){ sqlite3_vfs_register(&aVfs[i], i==0); } unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); + +#ifndef SQLITE_OMIT_WAL + /* Validate lock assumptions */ + assert( SQLITE_SHM_NLOCK==8 ); /* Number of available locks */ + assert( UNIX_SHM_BASE==120 ); /* Start of locking area */ + /* Locks: + ** WRITE UNIX_SHM_BASE 120 + ** CKPT UNIX_SHM_BASE+1 121 + ** RECOVER UNIX_SHM_BASE+2 122 + ** READ-0 UNIX_SHM_BASE+3 123 + ** READ-1 UNIX_SHM_BASE+4 124 + ** READ-2 UNIX_SHM_BASE+5 125 + ** READ-3 UNIX_SHM_BASE+6 126 + ** READ-4 UNIX_SHM_BASE+7 127 + ** DMS UNIX_SHM_BASE+8 128 + */ + assert( UNIX_SHM_DMS==128 ); /* Byte offset of the deadman-switch */ +#endif + + /* Initialize temp file dir array. */ + unixTempFileInit(); + return SQLITE_OK; } @@ -41701,205 +42385,7 @@ SQLITE_API int sqlite3_os_end(void){ /* ** Include code that is common to all os_*.c files */ -/************** Include os_common.h in the middle of os_win.c ****************/ -/************** Begin file os_common.h ***************************************/ -/* -** 2004 May 22 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -****************************************************************************** -** -** This file contains macros and a little bit of code that is common to -** all of the platform-specific files (os_*.c) and is #included into those -** files. -** -** This file should be #included by the os_*.c files only. It is not a -** general purpose header file. -*/ -#ifndef _OS_COMMON_H_ -#define _OS_COMMON_H_ - -/* -** At least two bugs have slipped in because we changed the MEMORY_DEBUG -** macro to SQLITE_DEBUG and some older makefiles have not yet made the -** switch. The following code should catch this problem at compile-time. -*/ -#ifdef MEMORY_DEBUG -# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." -#endif - -/* -** Macros for performance tracing. Normally turned off. Only works -** on i486 hardware. -*/ -#ifdef SQLITE_PERFORMANCE_TRACE - -/* -** hwtime.h contains inline assembler code for implementing -** high-performance timing routines. -*/ -/************** Include hwtime.h in the middle of os_common.h ****************/ -/************** Begin file hwtime.h ******************************************/ -/* -** 2008 May 27 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -****************************************************************************** -** -** This file contains inline asm code for retrieving "high-performance" -** counters for x86 and x86_64 class CPUs. -*/ -#ifndef SQLITE_HWTIME_H -#define SQLITE_HWTIME_H - -/* -** The following routine only works on pentium-class (or newer) processors. -** It uses the RDTSC opcode to read the cycle count value out of the -** processor and returns that value. This can be used for high-res -** profiling. -*/ -#if !defined(__STRICT_ANSI__) && \ - (defined(__GNUC__) || defined(_MSC_VER)) && \ - (defined(i386) || defined(__i386__) || defined(_M_IX86)) - - #if defined(__GNUC__) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned int lo, hi; - __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); - return (sqlite_uint64)hi << 32 | lo; - } - - #elif defined(_MSC_VER) - - __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ - __asm { - rdtsc - ret ; return value at EDX:EAX - } - } - - #endif - -#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__)) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned long val; - __asm__ __volatile__ ("rdtsc" : "=A" (val)); - return val; - } - -#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__)) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned long long retval; - unsigned long junk; - __asm__ __volatile__ ("\n\ - 1: mftbu %1\n\ - mftb %L0\n\ - mftbu %0\n\ - cmpw %0,%1\n\ - bne 1b" - : "=r" (retval), "=r" (junk)); - return retval; - } - -#else - - /* - ** asm() is needed for hardware timing support. Without asm(), - ** disable the sqlite3Hwtime() routine. - ** - ** sqlite3Hwtime() is only used for some obscure debugging - ** and analysis configurations, not in any deliverable, so this - ** should not be a great loss. - */ -SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } - -#endif - -#endif /* !defined(SQLITE_HWTIME_H) */ - -/************** End of hwtime.h **********************************************/ -/************** Continuing where we left off in os_common.h ******************/ - -static sqlite_uint64 g_start; -static sqlite_uint64 g_elapsed; -#define TIMER_START g_start=sqlite3Hwtime() -#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start -#define TIMER_ELAPSED g_elapsed -#else -#define TIMER_START -#define TIMER_END -#define TIMER_ELAPSED ((sqlite_uint64)0) -#endif - -/* -** If we compile with the SQLITE_TEST macro set, then the following block -** of code will give us the ability to simulate a disk I/O error. This -** is used for testing the I/O recovery logic. -*/ -#if defined(SQLITE_TEST) -SQLITE_API extern int sqlite3_io_error_hit; -SQLITE_API extern int sqlite3_io_error_hardhit; -SQLITE_API extern int sqlite3_io_error_pending; -SQLITE_API extern int sqlite3_io_error_persist; -SQLITE_API extern int sqlite3_io_error_benign; -SQLITE_API extern int sqlite3_diskfull_pending; -SQLITE_API extern int sqlite3_diskfull; -#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) -#define SimulateIOError(CODE) \ - if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ - || sqlite3_io_error_pending-- == 1 ) \ - { local_ioerr(); CODE; } -static void local_ioerr(){ - IOTRACE(("IOERR\n")); - sqlite3_io_error_hit++; - if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; -} -#define SimulateDiskfullError(CODE) \ - if( sqlite3_diskfull_pending ){ \ - if( sqlite3_diskfull_pending == 1 ){ \ - local_ioerr(); \ - sqlite3_diskfull = 1; \ - sqlite3_io_error_hit = 1; \ - CODE; \ - }else{ \ - sqlite3_diskfull_pending--; \ - } \ - } -#else -#define SimulateIOErrorBenign(X) -#define SimulateIOError(A) -#define SimulateDiskfullError(A) -#endif /* defined(SQLITE_TEST) */ - -/* -** When testing, keep a count of the number of open files. -*/ -#if defined(SQLITE_TEST) -SQLITE_API extern int sqlite3_open_file_count; -#define OpenCounter(X) sqlite3_open_file_count+=(X) -#else -#define OpenCounter(X) -#endif /* defined(SQLITE_TEST) */ - -#endif /* !defined(_OS_COMMON_H_) */ - -/************** End of os_common.h *******************************************/ -/************** Continuing where we left off in os_win.c *********************/ +/* #include "os_common.h" */ /* ** Include the header file for the Windows VFS. @@ -48055,31 +48541,88 @@ SQLITE_API int sqlite3_os_end(void){ ** sqlite3_deserialize(). */ /* #include "sqliteInt.h" */ -#ifdef SQLITE_ENABLE_DESERIALIZE +#ifndef SQLITE_OMIT_DESERIALIZE /* ** Forward declaration of objects used by this utility */ typedef struct sqlite3_vfs MemVfs; typedef struct MemFile MemFile; +typedef struct MemStore MemStore; /* Access to a lower-level VFS that (might) implement dynamic loading, ** access to randomness, etc. */ #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData)) -/* An open file */ -struct MemFile { - sqlite3_file base; /* IO methods */ +/* Storage for a memdb file. +** +** An memdb object can be shared or separate. Shared memdb objects can be +** used by more than one database connection. Mutexes are used by shared +** memdb objects to coordinate access. Separate memdb objects are only +** connected to a single database connection and do not require additional +** mutexes. +** +** Shared memdb objects have .zFName!=0 and .pMutex!=0. They are created +** using "file:/name?vfs=memdb". The first character of the name must be +** "/" or else the object will be a separate memdb object. All shared +** memdb objects are stored in memdb_g.apMemStore[] in an arbitrary order. +** +** Separate memdb objects are created using a name that does not begin +** with "/" or using sqlite3_deserialize(). +** +** Access rules for shared MemStore objects: +** +** * .zFName is initialized when the object is created and afterwards +** is unchanged until the object is destroyed. So it can be accessed +** at any time as long as we know the object is not being destroyed, +** which means while either the SQLITE_MUTEX_STATIC_VFS1 or +** .pMutex is held or the object is not part of memdb_g.apMemStore[]. +** +** * Can .pMutex can only be changed while holding the +** SQLITE_MUTEX_STATIC_VFS1 mutex or while the object is not part +** of memdb_g.apMemStore[]. +** +** * Other fields can only be changed while holding the .pMutex mutex +** or when the .nRef is less than zero and the object is not part of +** memdb_g.apMemStore[]. +** +** * The .aData pointer has the added requirement that it can can only +** be changed (for resizing) when nMmap is zero. +** +*/ +struct MemStore { sqlite3_int64 sz; /* Size of the file */ sqlite3_int64 szAlloc; /* Space allocated to aData */ sqlite3_int64 szMax; /* Maximum allowed size of the file */ unsigned char *aData; /* content of the file */ + sqlite3_mutex *pMutex; /* Used by shared stores only */ int nMmap; /* Number of memory mapped pages */ unsigned mFlags; /* Flags */ + int nRdLock; /* Number of readers */ + int nWrLock; /* Number of writers. (Always 0 or 1) */ + int nRef; /* Number of users of this MemStore */ + char *zFName; /* The filename for shared stores */ +}; + +/* An open file */ +struct MemFile { + sqlite3_file base; /* IO methods */ + MemStore *pStore; /* The storage */ int eLock; /* Most recent lock against this file */ }; +/* +** File-scope variables for holding the memdb files that are accessible +** to multiple database connections in separate threads. +** +** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object. +*/ +static struct MemFS { + int nMemStore; /* Number of shared MemStore objects */ + MemStore **apMemStore; /* Array of all shared MemStore objects */ +} memdb_g; + /* ** Methods for MemFile */ @@ -48133,7 +48676,10 @@ static sqlite3_vfs memdb_vfs = { memdbSleep, /* xSleep */ 0, /* memdbCurrentTime, */ /* xCurrentTime */ memdbGetLastError, /* xGetLastError */ - memdbCurrentTimeInt64 /* xCurrentTimeInt64 */ + memdbCurrentTimeInt64, /* xCurrentTimeInt64 */ + 0, /* xSetSystemCall */ + 0, /* xGetSystemCall */ + 0, /* xNextSystemCall */ }; static const sqlite3_io_methods memdb_io_methods = { @@ -48158,19 +48704,67 @@ static const sqlite3_io_methods memdb_io_methods = { memdbUnfetch /* xUnfetch */ }; +/* +** Enter/leave the mutex on a MemStore +*/ +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0 +static void memdbEnter(MemStore *p){ + UNUSED_PARAMETER(p); +} +static void memdbLeave(MemStore *p){ + UNUSED_PARAMETER(p); +} +#else +static void memdbEnter(MemStore *p){ + sqlite3_mutex_enter(p->pMutex); +} +static void memdbLeave(MemStore *p){ + sqlite3_mutex_leave(p->pMutex); +} +#endif + /* ** Close an memdb-file. -** -** The pData pointer is owned by the application, so there is nothing -** to free. Unless the SQLITE_DESERIALIZE_FREEONCLOSE flag is set, -** in which case we own the pData pointer and need to free it. +** Free the underlying MemStore object when its refcount drops to zero +** or less. */ static int memdbClose(sqlite3_file *pFile){ - MemFile *p = (MemFile *)pFile; - if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ){ - sqlite3_free(p->aData); + MemStore *p = ((MemFile*)pFile)->pStore; + if( p->zFName ){ + int i; +#ifndef SQLITE_MUTEX_OMIT + sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); +#endif + sqlite3_mutex_enter(pVfsMutex); + for(i=0; ALWAYS(inRef==1 ){ + memdb_g.apMemStore[i] = memdb_g.apMemStore[--memdb_g.nMemStore]; + if( memdb_g.nMemStore==0 ){ + sqlite3_free(memdb_g.apMemStore); + memdb_g.apMemStore = 0; + } + } + break; + } + } + sqlite3_mutex_leave(pVfsMutex); + }else{ + memdbEnter(p); + } + p->nRef--; + if( p->nRef<=0 ){ + if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ){ + sqlite3_free(p->aData); + } + memdbLeave(p); + sqlite3_mutex_free(p->pMutex); + sqlite3_free(p); + }else{ + memdbLeave(p); } return SQLITE_OK; } @@ -48184,22 +48778,25 @@ static int memdbRead( int iAmt, sqlite_int64 iOfst ){ - MemFile *p = (MemFile *)pFile; + MemStore *p = ((MemFile*)pFile)->pStore; + memdbEnter(p); if( iOfst+iAmt>p->sz ){ memset(zBuf, 0, iAmt); if( iOfstsz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst); + memdbLeave(p); return SQLITE_IOERR_SHORT_READ; } memcpy(zBuf, p->aData+iOfst, iAmt); + memdbLeave(p); return SQLITE_OK; } /* ** Try to enlarge the memory allocation to hold at least sz bytes */ -static int memdbEnlarge(MemFile *p, sqlite3_int64 newSz){ +static int memdbEnlarge(MemStore *p, sqlite3_int64 newSz){ unsigned char *pNew; - if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || p->nMmap>0 ){ + if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || NEVER(p->nMmap>0) ){ return SQLITE_FULL; } if( newSz>p->szMax ){ @@ -48208,7 +48805,7 @@ static int memdbEnlarge(MemFile *p, sqlite3_int64 newSz){ newSz *= 2; if( newSz>p->szMax ) newSz = p->szMax; pNew = sqlite3Realloc(p->aData, newSz); - if( pNew==0 ) return SQLITE_NOMEM; + if( pNew==0 ) return SQLITE_IOERR_NOMEM; p->aData = pNew; p->szAlloc = newSz; return SQLITE_OK; @@ -48223,19 +48820,27 @@ static int memdbWrite( int iAmt, sqlite_int64 iOfst ){ - MemFile *p = (MemFile *)pFile; - if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ) return SQLITE_READONLY; + MemStore *p = ((MemFile*)pFile)->pStore; + memdbEnter(p); + if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ){ + /* Can't happen: memdbLock() will return SQLITE_READONLY before + ** reaching this point */ + memdbLeave(p); + return SQLITE_IOERR_WRITE; + } if( iOfst+iAmt>p->sz ){ int rc; if( iOfst+iAmt>p->szAlloc && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK ){ + memdbLeave(p); return rc; } if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz); p->sz = iOfst+iAmt; } memcpy(p->aData+iOfst, z, iAmt); + memdbLeave(p); return SQLITE_OK; } @@ -48247,16 +48852,25 @@ static int memdbWrite( ** the size of a file, never to increase the size. */ static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){ - MemFile *p = (MemFile *)pFile; - if( NEVER(size>p->sz) ) return SQLITE_FULL; - p->sz = size; - return SQLITE_OK; + MemStore *p = ((MemFile*)pFile)->pStore; + int rc = SQLITE_OK; + memdbEnter(p); + if( size>p->sz ){ + /* This can only happen with a corrupt wal mode db */ + rc = SQLITE_CORRUPT; + }else{ + p->sz = size; + } + memdbLeave(p); + return rc; } /* ** Sync an memdb-file. */ static int memdbSync(sqlite3_file *pFile, int flags){ + UNUSED_PARAMETER(pFile); + UNUSED_PARAMETER(flags); return SQLITE_OK; } @@ -48264,8 +48878,10 @@ static int memdbSync(sqlite3_file *pFile, int flags){ ** Return the current file-size of an memdb-file. */ static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ - MemFile *p = (MemFile *)pFile; + MemStore *p = ((MemFile*)pFile)->pStore; + memdbEnter(p); *pSize = p->sz; + memdbLeave(p); return SQLITE_OK; } @@ -48273,19 +48889,48 @@ static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ ** Lock an memdb-file. */ static int memdbLock(sqlite3_file *pFile, int eLock){ - MemFile *p = (MemFile *)pFile; - if( eLock>SQLITE_LOCK_SHARED - && (p->mFlags & SQLITE_DESERIALIZE_READONLY)!=0 - ){ - return SQLITE_READONLY; + MemFile *pThis = (MemFile*)pFile; + MemStore *p = pThis->pStore; + int rc = SQLITE_OK; + if( eLock==pThis->eLock ) return SQLITE_OK; + memdbEnter(p); + if( eLock>SQLITE_LOCK_SHARED ){ + if( p->mFlags & SQLITE_DESERIALIZE_READONLY ){ + rc = SQLITE_READONLY; + }else if( pThis->eLock<=SQLITE_LOCK_SHARED ){ + if( p->nWrLock ){ + rc = SQLITE_BUSY; + }else{ + p->nWrLock = 1; + } + } + }else if( eLock==SQLITE_LOCK_SHARED ){ + if( pThis->eLock > SQLITE_LOCK_SHARED ){ + assert( p->nWrLock==1 ); + p->nWrLock = 0; + }else if( p->nWrLock ){ + rc = SQLITE_BUSY; + }else{ + p->nRdLock++; + } + }else{ + assert( eLock==SQLITE_LOCK_NONE ); + if( pThis->eLock>SQLITE_LOCK_SHARED ){ + assert( p->nWrLock==1 ); + p->nWrLock = 0; + } + assert( p->nRdLock>0 ); + p->nRdLock--; } - p->eLock = eLock; - return SQLITE_OK; + if( rc==SQLITE_OK ) pThis->eLock = eLock; + memdbLeave(p); + return rc; } -#if 0 /* Never used because memdbAccess() always returns false */ +#if 0 /* -** Check if another file-handle holds a RESERVED lock on an memdb-file. +** This interface is only used for crash recovery, which does not +** occur on an in-memory database. */ static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){ *pResOut = 0; @@ -48293,12 +48938,14 @@ static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){ } #endif + /* ** File control method. For custom operations on an memdb-file. */ static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){ - MemFile *p = (MemFile *)pFile; + MemStore *p = ((MemFile*)pFile)->pStore; int rc = SQLITE_NOTFOUND; + memdbEnter(p); if( op==SQLITE_FCNTL_VFSNAME ){ *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz); rc = SQLITE_OK; @@ -48316,6 +48963,7 @@ static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){ *(sqlite3_int64*)pArg = iLimit; rc = SQLITE_OK; } + memdbLeave(p); return rc; } @@ -48332,6 +48980,7 @@ static int memdbSectorSize(sqlite3_file *pFile){ ** Return the device characteristic flags supported by an memdb-file. */ static int memdbDeviceCharacteristics(sqlite3_file *pFile){ + UNUSED_PARAMETER(pFile); return SQLITE_IOCAP_ATOMIC | SQLITE_IOCAP_POWERSAFE_OVERWRITE | SQLITE_IOCAP_SAFE_APPEND | @@ -48345,20 +48994,26 @@ static int memdbFetch( int iAmt, void **pp ){ - MemFile *p = (MemFile *)pFile; - if( iOfst+iAmt>p->sz ){ + MemStore *p = ((MemFile*)pFile)->pStore; + memdbEnter(p); + if( iOfst+iAmt>p->sz || (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)!=0 ){ *pp = 0; }else{ p->nMmap++; *pp = (void*)(p->aData + iOfst); } + memdbLeave(p); return SQLITE_OK; } /* Release a memory-mapped page */ static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ - MemFile *p = (MemFile *)pFile; + MemStore *p = ((MemFile*)pFile)->pStore; + UNUSED_PARAMETER(iOfst); + UNUSED_PARAMETER(pPage); + memdbEnter(p); p->nMmap--; + memdbLeave(p); return SQLITE_OK; } @@ -48368,20 +49023,79 @@ static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ static int memdbOpen( sqlite3_vfs *pVfs, const char *zName, - sqlite3_file *pFile, + sqlite3_file *pFd, int flags, int *pOutFlags ){ - MemFile *p = (MemFile*)pFile; - if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){ - return ORIGVFS(pVfs)->xOpen(ORIGVFS(pVfs), zName, pFile, flags, pOutFlags); + MemFile *pFile = (MemFile*)pFd; + MemStore *p = 0; + int szName; + UNUSED_PARAMETER(pVfs); + + memset(pFile, 0, sizeof(*pFile)); + szName = sqlite3Strlen30(zName); + if( szName>1 && zName[0]=='/' ){ + int i; +#ifndef SQLITE_MUTEX_OMIT + sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); +#endif + sqlite3_mutex_enter(pVfsMutex); + for(i=0; izFName,zName)==0 ){ + p = memdb_g.apMemStore[i]; + break; + } + } + if( p==0 ){ + MemStore **apNew; + p = sqlite3Malloc( sizeof(*p) + szName + 3 ); + if( p==0 ){ + sqlite3_mutex_leave(pVfsMutex); + return SQLITE_NOMEM; + } + apNew = sqlite3Realloc(memdb_g.apMemStore, + sizeof(apNew[0])*(memdb_g.nMemStore+1) ); + if( apNew==0 ){ + sqlite3_free(p); + sqlite3_mutex_leave(pVfsMutex); + return SQLITE_NOMEM; + } + apNew[memdb_g.nMemStore++] = p; + memdb_g.apMemStore = apNew; + memset(p, 0, sizeof(*p)); + p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE|SQLITE_DESERIALIZE_FREEONCLOSE; + p->szMax = sqlite3GlobalConfig.mxMemdbSize; + p->zFName = (char*)&p[1]; + memcpy(p->zFName, zName, szName+1); + p->pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( p->pMutex==0 ){ + memdb_g.nMemStore--; + sqlite3_free(p); + sqlite3_mutex_leave(pVfsMutex); + return SQLITE_NOMEM; + } + p->nRef = 1; + memdbEnter(p); + }else{ + memdbEnter(p); + p->nRef++; + } + sqlite3_mutex_leave(pVfsMutex); + }else{ + p = sqlite3Malloc( sizeof(*p) ); + if( p==0 ){ + return SQLITE_NOMEM; + } + memset(p, 0, sizeof(*p)); + p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE; + p->szMax = sqlite3GlobalConfig.mxMemdbSize; } - memset(p, 0, sizeof(*p)); - p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE; - assert( pOutFlags!=0 ); /* True because flags==SQLITE_OPEN_MAIN_DB */ - *pOutFlags = flags | SQLITE_OPEN_MEMORY; - pFile->pMethods = &memdb_io_methods; - p->szMax = sqlite3GlobalConfig.mxMemdbSize; + pFile->pStore = p; + if( pOutFlags!=0 ){ + *pOutFlags = flags | SQLITE_OPEN_MEMORY; + } + pFd->pMethods = &memdb_io_methods; + memdbLeave(p); return SQLITE_OK; } @@ -48409,6 +49123,9 @@ static int memdbAccess( int flags, int *pResOut ){ + UNUSED_PARAMETER(pVfs); + UNUSED_PARAMETER(zPath); + UNUSED_PARAMETER(flags); *pResOut = 0; return SQLITE_OK; } @@ -48424,6 +49141,7 @@ static int memdbFullPathname( int nOut, char *zOut ){ + UNUSED_PARAMETER(pVfs); sqlite3_snprintf(nOut, zOut, "%s", zPath); return SQLITE_OK; } @@ -48496,9 +49214,14 @@ static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){ */ static MemFile *memdbFromDbSchema(sqlite3 *db, const char *zSchema){ MemFile *p = 0; + MemStore *pStore; int rc = sqlite3_file_control(db, zSchema, SQLITE_FCNTL_FILE_POINTER, &p); if( rc ) return 0; if( p->base.pMethods!=&memdb_io_methods ) return 0; + pStore = p->pStore; + memdbEnter(pStore); + if( pStore->zFName!=0 ) p = 0; + memdbLeave(pStore); return p; } @@ -48534,12 +49257,14 @@ SQLITE_API unsigned char *sqlite3_serialize( if( piSize ) *piSize = -1; if( iDb<0 ) return 0; if( p ){ - if( piSize ) *piSize = p->sz; + MemStore *pStore = p->pStore; + assert( pStore->pMutex==0 ); + if( piSize ) *piSize = pStore->sz; if( mFlags & SQLITE_SERIALIZE_NOCOPY ){ - pOut = p->aData; + pOut = pStore->aData; }else{ - pOut = sqlite3_malloc64( p->sz ); - if( pOut ) memcpy(pOut, p->aData, p->sz); + pOut = sqlite3_malloc64( pStore->sz ); + if( pOut ) memcpy(pOut, pStore->aData, pStore->sz); } return pOut; } @@ -48609,7 +49334,8 @@ SQLITE_API int sqlite3_deserialize( sqlite3_mutex_enter(db->mutex); if( zSchema==0 ) zSchema = db->aDb[0].zDbSName; iDb = sqlite3FindDbName(db, zSchema); - if( iDb<0 ){ + testcase( iDb==1 ); + if( iDb<2 && iDb!=0 ){ rc = SQLITE_ERROR; goto end_deserialize; } @@ -48633,15 +49359,16 @@ SQLITE_API int sqlite3_deserialize( if( p==0 ){ rc = SQLITE_ERROR; }else{ - p->aData = pData; + MemStore *pStore = p->pStore; + pStore->aData = pData; pData = 0; - p->sz = szDb; - p->szAlloc = szBuf; - p->szMax = szBuf; - if( p->szMaxszMax = sqlite3GlobalConfig.mxMemdbSize; + pStore->sz = szDb; + pStore->szAlloc = szBuf; + pStore->szMax = szBuf; + if( pStore->szMaxszMax = sqlite3GlobalConfig.mxMemdbSize; } - p->mFlags = mFlags; + pStore->mFlags = mFlags; rc = SQLITE_OK; } @@ -48660,7 +49387,9 @@ SQLITE_API int sqlite3_deserialize( */ SQLITE_PRIVATE int sqlite3MemdbInit(void){ sqlite3_vfs *pLower = sqlite3_vfs_find(0); - int sz = pLower->szOsFile; + unsigned int sz; + if( NEVER(pLower==0) ) return SQLITE_ERROR; + sz = pLower->szOsFile; memdb_vfs.pAppData = pLower; /* The following conditional can only be true when compiled for ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0. We always leave @@ -48670,7 +49399,7 @@ SQLITE_PRIVATE int sqlite3MemdbInit(void){ memdb_vfs.szOsFile = sz; return sqlite3_vfs_register(&memdb_vfs, 0); } -#endif /* SQLITE_ENABLE_DESERIALIZE */ +#endif /* SQLITE_OMIT_DESERIALIZE */ /************** End of memdb.c ***********************************************/ /************** Begin file bitvec.c ******************************************/ @@ -49029,7 +49758,7 @@ SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int sz, int *aOp){ sqlite3BitvecClear(0, 1, pTmpSpace); /* Run the program */ - pc = 0; + pc = i = 0; while( (op = aOp[pc])!=0 ){ switch( op ){ case 1: @@ -49333,11 +50062,14 @@ static int numberOfCachePages(PCache *p){ ** suggested cache size is set to N. */ return p->szCache; }else{ + i64 n; /* IMPLEMANTATION-OF: R-59858-46238 If the argument N is negative, then the ** number of cache pages is adjusted to be a number of pages that would ** use approximately abs(N*1024) bytes of memory based on the current ** page size. */ - return (int)((-1024*(i64)p->szCache)/(p->szPage+p->szExtra)); + n = ((-1024*(i64)p->szCache)/(p->szPage+p->szExtra)); + if( n>1000000000 ) n = 1000000000; + return (int)n; } } @@ -50436,6 +51168,7 @@ static PgHdr1 *pcache1AllocPage(PCache1 *pCache, int benignMalloc){ p->page.pExtra = &p[1]; p->isBulkLocal = 0; p->isAnchor = 0; + p->pLruPrev = 0; /* Initializing this saves a valgrind error */ } (*pCache->pnPurgeable)++; return p; @@ -50791,12 +51524,18 @@ static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){ */ static void pcache1Cachesize(sqlite3_pcache *p, int nMax){ PCache1 *pCache = (PCache1 *)p; + u32 n; + assert( nMax>=0 ); if( pCache->bPurgeable ){ PGroup *pGroup = pCache->pGroup; pcache1EnterMutex(pGroup); - pGroup->nMaxPage += (nMax - pCache->nMax); + n = (u32)nMax; + if( n > 0x7fff0000 - pGroup->nMaxPage + pCache->nMax ){ + n = 0x7fff0000 - pGroup->nMaxPage + pCache->nMax; + } + pGroup->nMaxPage += (n - pCache->nMax); pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; - pCache->nMax = nMax; + pCache->nMax = n; pCache->n90pct = pCache->nMax*9/10; pcache1EnforceMaxPage(pCache); pcache1LeaveMutex(pGroup); @@ -50812,7 +51551,7 @@ static void pcache1Shrink(sqlite3_pcache *p){ PCache1 *pCache = (PCache1*)p; if( pCache->bPurgeable ){ PGroup *pGroup = pCache->pGroup; - int savedMaxPage; + unsigned int savedMaxPage; pcache1EnterMutex(pGroup); savedMaxPage = pGroup->nMaxPage; pGroup->nMaxPage = 0; @@ -52354,6 +53093,7 @@ struct PagerSavepoint { Bitvec *pInSavepoint; /* Set of pages in this savepoint */ Pgno nOrig; /* Original number of pages in file */ Pgno iSubRec; /* Index of first record in sub-journal */ + int bTruncateOnRelease; /* If stmt journal may be truncated on RELEASE */ #ifndef SQLITE_OMIT_WAL u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */ #endif @@ -52548,6 +53288,7 @@ struct Pager { u8 noLock; /* Do not lock (except in WAL mode) */ u8 readOnly; /* True for a read-only database */ u8 memDb; /* True to inhibit all file I/O */ + u8 memVfs; /* VFS-implemented memory database */ /************************************************************************** ** The following block contains those class members that change during @@ -52597,8 +53338,8 @@ struct Pager { i16 nReserve; /* Number of unused bytes at end of each page */ u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */ u32 sectorSize; /* Assumed sector size during rollback */ - int pageSize; /* Number of bytes in a page */ Pgno mxPgno; /* Maximum allowed size of the database */ + i64 pageSize; /* Number of bytes in a page */ i64 journalSizeLimit; /* Size limit for persistent journal files */ char *zFilename; /* Name of the database file */ char *zJournal; /* Name of the journal file */ @@ -52989,6 +53730,9 @@ static int subjRequiresPage(PgHdr *pPg){ for(i=0; inSavepoint; i++){ p = &pPager->aSavepoint[i]; if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){ + for(i=i+1; inSavepoint; i++){ + pPager->aSavepoint[i].bTruncateOnRelease = 0; + } return 1; } } @@ -54939,6 +55683,7 @@ static int readDbPage(PgHdr *pPg){ */ static void pager_write_changecounter(PgHdr *pPg){ u32 change_counter; + if( NEVER(pPg==0) ) return; /* Increment the value just read and write it back to byte 24. */ change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1; @@ -55851,7 +56596,8 @@ static void assertTruncateConstraint(Pager *pPager){ ** then continue writing to the database. */ SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){ - assert( pPager->dbSize>=nPage ); + assert( pPager->dbSize>=nPage || CORRUPT_DB ); + testcase( pPager->dbSizeeState>=PAGER_WRITER_CACHEMOD ); pPager->dbSize = nPage; @@ -56579,7 +57325,7 @@ SQLITE_PRIVATE int sqlite3PagerOpen( int rc = SQLITE_OK; /* Return code */ int tempFile = 0; /* True for temp files (incl. in-memory files) */ int memDb = 0; /* True if this is an in-memory file */ -#ifdef SQLITE_ENABLE_DESERIALIZE +#ifndef SQLITE_OMIT_DESERIALIZE int memJM = 0; /* Memory journal mode */ #else # define memJM 0 @@ -56772,6 +57518,7 @@ SQLITE_PRIVATE int sqlite3PagerOpen( pPager->zWal = 0; } #endif + (void)pPtr; /* Suppress warning about unused pPtr value */ if( nPathname ) sqlite3DbFree(0, zPathname); pPager->pVfs = pVfs; @@ -56783,8 +57530,8 @@ SQLITE_PRIVATE int sqlite3PagerOpen( int fout = 0; /* VFS flags returned by xOpen() */ rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout); assert( !memDb ); -#ifdef SQLITE_ENABLE_DESERIALIZE - memJM = (fout&SQLITE_OPEN_MEMORY)!=0; +#ifndef SQLITE_OMIT_DESERIALIZE + pPager->memVfs = memJM = (fout&SQLITE_OPEN_MEMORY)!=0; #endif readOnly = (fout&SQLITE_OPEN_READONLY)!=0; @@ -57751,7 +58498,7 @@ SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory assert( pPager->eState>=PAGER_READER && pPager->eStatesubjInMemory = (u8)subjInMemory; - if( ALWAYS(pPager->eState==PAGER_READER) ){ + if( pPager->eState==PAGER_READER ){ assert( pPager->pInJournal==0 ); if( pagerUseWal(pPager) ){ @@ -58651,8 +59398,8 @@ SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){ ** used by the pager and its associated cache. */ SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){ - int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr) - + 5*sizeof(void*); + int perPageSize = pPager->pageSize + pPager->nExtra + + (int)(sizeof(PgHdr) + 5*sizeof(void*)); return perPageSize*sqlite3PcachePagecount(pPager->pPCache) + sqlite3MallocSize(pPager) + pPager->pageSize; @@ -58721,7 +59468,7 @@ SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, i ** Return true if this is an in-memory or temp-file backed pager. */ SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){ - return pPager->tempFile; + return pPager->tempFile || pPager->memVfs; } /* @@ -58767,6 +59514,7 @@ static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){ } aNew[ii].iSubRec = pPager->nSubRec; aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize); + aNew[ii].bTruncateOnRelease = 1; if( !aNew[ii].pInSavepoint ){ return SQLITE_NOMEM_BKPT; } @@ -58845,16 +59593,18 @@ SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){ } pPager->nSavepoint = nNew; - /* If this is a release of the outermost savepoint, truncate - ** the sub-journal to zero bytes in size. */ + /* Truncate the sub-journal so that it only includes the parts + ** that are still in use. */ if( op==SAVEPOINT_RELEASE ){ - if( nNew==0 && isOpen(pPager->sjfd) ){ + PagerSavepoint *pRel = &pPager->aSavepoint[nNew]; + if( pRel->bTruncateOnRelease && isOpen(pPager->sjfd) ){ /* Only truncate if it is an in-memory sub-journal. */ if( sqlite3JournalIsInMemory(pPager->sjfd) ){ - rc = sqlite3OsTruncate(pPager->sjfd, 0); + i64 sz = (pPager->pageSize+4)*(i64)pRel->iSubRec; + rc = sqlite3OsTruncate(pPager->sjfd, sz); assert( rc==SQLITE_OK ); } - pPager->nSubRec = 0; + pPager->nSubRec = pRel->iSubRec; } } /* Else this is a rollback operation, playback the specified savepoint. @@ -59038,7 +59788,7 @@ SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, i pPgOld = sqlite3PagerLookup(pPager, pgno); assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB ); if( pPgOld ){ - if( pPgOld->nRef>1 ){ + if( NEVER(pPgOld->nRef>1) ){ sqlite3PagerUnrefNotNull(pPgOld); return SQLITE_CORRUPT_BKPT; } @@ -59784,7 +60534,10 @@ SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager){ ** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and ** HASHTABLE_NPAGE are selected so that together the wal-index header and ** first index block are the same size as all other index blocks in the -** wal-index. +** wal-index. The values are: +** +** HASHTABLE_NPAGE 4096 +** HASHTABLE_NPAGE_ONE 4062 ** ** Each index block contains two sections, a page-mapping that contains the ** database page number associated with each wal frame, and a hash-table @@ -60020,6 +60773,70 @@ struct WalCkptInfo { }; #define READMARK_NOT_USED 0xffffffff +/* +** This is a schematic view of the complete 136-byte header of the +** wal-index file (also known as the -shm file): +** +** +-----------------------------+ +** 0: | iVersion | \ +** +-----------------------------+ | +** 4: | (unused padding) | | +** +-----------------------------+ | +** 8: | iChange | | +** +-------+-------+-------------+ | +** 12: | bInit | bBig | szPage | | +** +-------+-------+-------------+ | +** 16: | mxFrame | | First copy of the +** +-----------------------------+ | WalIndexHdr object +** 20: | nPage | | +** +-----------------------------+ | +** 24: | aFrameCksum | | +** | | | +** +-----------------------------+ | +** 32: | aSalt | | +** | | | +** +-----------------------------+ | +** 40: | aCksum | | +** | | / +** +-----------------------------+ +** 48: | iVersion | \ +** +-----------------------------+ | +** 52: | (unused padding) | | +** +-----------------------------+ | +** 56: | iChange | | +** +-------+-------+-------------+ | +** 60: | bInit | bBig | szPage | | +** +-------+-------+-------------+ | Second copy of the +** 64: | mxFrame | | WalIndexHdr +** +-----------------------------+ | +** 68: | nPage | | +** +-----------------------------+ | +** 72: | aFrameCksum | | +** | | | +** +-----------------------------+ | +** 80: | aSalt | | +** | | | +** +-----------------------------+ | +** 88: | aCksum | | +** | | / +** +-----------------------------+ +** 96: | nBackfill | +** +-----------------------------+ +** 100: | 5 read marks | +** | | +** | | +** | | +** | | +** +-------+-------+------+------+ +** 120: | Write | Ckpt | Rcvr | Rd0 | \ +** +-------+-------+------+------+ ) 8 lock bytes +** | Read1 | Read2 | Rd3 | Rd4 | / +** +-------+-------+------+------+ +** 128: | nBackfillAttempted | +** +-----------------------------+ +** 132: | (unused padding) | +** +-----------------------------+ +*/ /* A block of WALINDEX_LOCK_RESERVED bytes beginning at ** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems @@ -60176,9 +60993,13 @@ struct WalIterator { ** so. It is safe to enlarge the wal-index if pWal->writeLock is true ** or pWal->exclusiveMode==WAL_HEAPMEMORY_MODE. ** -** If this call is successful, *ppPage is set to point to the wal-index -** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs, -** then an SQLite error code is returned and *ppPage is set to 0. +** Three possible result scenarios: +** +** (1) rc==SQLITE_OK and *ppPage==Requested-Wal-Index-Page +** (2) rc>=SQLITE_ERROR and *ppPage==NULL +** (3) rc==SQLITE_OK and *ppPage==NULL // only if iPage==0 +** +** Scenario (3) can only occur when pWal->writeLock is false and iPage==0 */ static SQLITE_NOINLINE int walIndexPageRealloc( Wal *pWal, /* The WAL context */ @@ -60211,7 +61032,9 @@ static SQLITE_NOINLINE int walIndexPageRealloc( rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ, pWal->writeLock, (void volatile **)&pWal->apWiData[iPage] ); - assert( pWal->apWiData[iPage]!=0 || rc!=SQLITE_OK || pWal->writeLock==0 ); + assert( pWal->apWiData[iPage]!=0 + || rc!=SQLITE_OK + || (pWal->writeLock==0 && iPage==0) ); testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK ); if( rc==SQLITE_OK ){ if( iPage>0 && sqlite3FaultSim(600) ) rc = SQLITE_NOMEM; @@ -60550,8 +61373,8 @@ struct WalHashLoc { ** slot in the hash table is set to N, it refers to frame number ** (pLoc->iZero+N) in the log. ** -** Finally, set pLoc->aPgno so that pLoc->aPgno[1] is the page number of the -** first frame indexed by the hash table, frame (pLoc->iZero+1). +** Finally, set pLoc->aPgno so that pLoc->aPgno[0] is the page number of the +** first frame indexed by the hash table, frame (pLoc->iZero). */ static int walHashGet( Wal *pWal, /* WAL handle */ @@ -60563,7 +61386,7 @@ static int walHashGet( rc = walIndexPage(pWal, iHash, &pLoc->aPgno); assert( rc==SQLITE_OK || iHash>0 ); - if( rc==SQLITE_OK ){ + if( pLoc->aPgno ){ pLoc->aHash = (volatile ht_slot *)&pLoc->aPgno[HASHTABLE_NPAGE]; if( iHash==0 ){ pLoc->aPgno = &pLoc->aPgno[WALINDEX_HDR_SIZE/sizeof(u32)]; @@ -60571,7 +61394,8 @@ static int walHashGet( }else{ pLoc->iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE; } - pLoc->aPgno = &pLoc->aPgno[-1]; + }else if( NEVER(rc==SQLITE_OK) ){ + rc = SQLITE_ERROR; } return rc; } @@ -60622,7 +61446,6 @@ static void walCleanupHash(Wal *pWal){ int iLimit = 0; /* Zero values greater than this */ int nByte; /* Number of bytes to zero in aPgno[] */ int i; /* Used to iterate through aHash[] */ - int rc; /* Return code form walHashGet() */ assert( pWal->writeLock ); testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 ); @@ -60637,8 +61460,8 @@ static void walCleanupHash(Wal *pWal){ */ assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) ); assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] ); - rc = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc); - if( NEVER(rc) ) return; /* Defense-in-depth, in case (1) above is wrong */ + i = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc); + if( NEVER(i) ) return; /* Defense-in-depth, in case (1) above is wrong */ /* Zero all hash-table entries that correspond to frame numbers greater ** than pWal->hdr.mxFrame. @@ -60654,8 +61477,9 @@ static void walCleanupHash(Wal *pWal){ /* Zero the entries in the aPgno array that correspond to frames with ** frame numbers greater than pWal->hdr.mxFrame. */ - nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit+1]); - memset((void *)&sLoc.aPgno[iLimit+1], 0, nByte); + nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit]); + assert( nByte>=0 ); + memset((void *)&sLoc.aPgno[iLimit], 0, nByte); #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT /* Verify that the every entry in the mapping region is still reachable @@ -60664,11 +61488,11 @@ static void walCleanupHash(Wal *pWal){ if( iLimit ){ int j; /* Loop counter */ int iKey; /* Hash key */ - for(j=1; j<=iLimit; j++){ + for(j=0; j=0 ); + memset((void*)sLoc.aPgno, 0, nByte); } /* If the entry in aPgno[] is already set, then the previous writer @@ -60711,9 +61535,9 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){ ** Remove the remnants of that writers uncommitted transaction from ** the hash-table before writing any new entries. */ - if( sLoc.aPgno[idx] ){ + if( sLoc.aPgno[idx-1] ){ walCleanupHash(pWal); - assert( !sLoc.aPgno[idx] ); + assert( !sLoc.aPgno[idx-1] ); } /* Write the aPgno[] array entry and the hash-table slot. */ @@ -60721,7 +61545,7 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){ for(iKey=walHash(iPage); sLoc.aHash[iKey]; iKey=walNextHash(iKey)){ if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT; } - sLoc.aPgno[idx] = iPage; + sLoc.aPgno[idx-1] = iPage; AtomicStore(&sLoc.aHash[iKey], (ht_slot)idx); #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT @@ -60742,19 +61566,18 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){ */ if( (idx&0x3ff)==0 ){ int i; /* Loop counter */ - for(i=1; i<=idx; i++){ + for(i=0; iapWiData[iPg] = aPrivate; for(iFrame=iFirst; iFrame<=iLast; iFrame++){ @@ -61034,14 +61858,43 @@ SQLITE_PRIVATE int sqlite3WalOpen( assert( zWalName && zWalName[0] ); assert( pDbFd ); + /* Verify the values of various constants. Any changes to the values + ** of these constants would result in an incompatible on-disk format + ** for the -shm file. Any change that causes one of these asserts to + ** fail is a backward compatibility problem, even if the change otherwise + ** works. + ** + ** This table also serves as a helpful cross-reference when trying to + ** interpret hex dumps of the -shm file. + */ + assert( 48 == sizeof(WalIndexHdr) ); + assert( 40 == sizeof(WalCkptInfo) ); + assert( 120 == WALINDEX_LOCK_OFFSET ); + assert( 136 == WALINDEX_HDR_SIZE ); + assert( 4096 == HASHTABLE_NPAGE ); + assert( 4062 == HASHTABLE_NPAGE_ONE ); + assert( 8192 == HASHTABLE_NSLOT ); + assert( 383 == HASHTABLE_HASH_1 ); + assert( 32768 == WALINDEX_PGSZ ); + assert( 8 == SQLITE_SHM_NLOCK ); + assert( 5 == WAL_NREADER ); + assert( 24 == WAL_FRAME_HDRSIZE ); + assert( 32 == WAL_HDRSIZE ); + assert( 120 == WALINDEX_LOCK_OFFSET + WAL_WRITE_LOCK ); + assert( 121 == WALINDEX_LOCK_OFFSET + WAL_CKPT_LOCK ); + assert( 122 == WALINDEX_LOCK_OFFSET + WAL_RECOVER_LOCK ); + assert( 123 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(0) ); + assert( 124 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(1) ); + assert( 125 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(2) ); + assert( 126 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(3) ); + assert( 127 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(4) ); + /* In the amalgamation, the os_unix.c and os_win.c source files come before ** this source file. Verify that the #defines of the locking byte offsets ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value. ** For that matter, if the lock offset ever changes from its initial design ** value of 120, we need to know that so there is an assert() to check it. */ - assert( 120==WALINDEX_LOCK_OFFSET ); - assert( 136==WALINDEX_HDR_SIZE ); #ifdef WIN_SHM_BASE assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET ); #endif @@ -61343,7 +62196,6 @@ static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){ int nEntry; /* Number of entries in this segment */ ht_slot *aIndex; /* Sorted index for this segment */ - sLoc.aPgno++; if( (i+1)==nSegment ){ nEntry = (int)(iLast - sLoc.iZero); }else{ @@ -62482,7 +63334,8 @@ SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal){ rc = walHashGet(pWal, walFramePage(i), &sLoc); if( rc!=SQLITE_OK ) break; - pgno = sLoc.aPgno[i-sLoc.iZero]; + assert( i - sLoc.iZero - 1 >=0 ); + pgno = sLoc.aPgno[i-sLoc.iZero-1]; iDbOff = (i64)(pgno-1) * szPage; if( iDbOff+szPage<=szDb ){ @@ -62715,7 +63568,7 @@ SQLITE_PRIVATE int sqlite3WalFindFrame( iKey = walHash(pgno); while( (iH = AtomicLoad(&sLoc.aHash[iKey]))!=0 ){ u32 iFrame = iH + sLoc.iZero; - if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH]==pgno ){ + if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH-1]==pgno ){ assert( iFrame>iRead || CORRUPT_DB ); iRead = iFrame; } @@ -63967,7 +64820,6 @@ typedef struct CellInfo CellInfo; */ struct MemPage { u8 isInit; /* True if previously initialized. MUST BE FIRST! */ - u8 bBusy; /* Prevent endless loops on corrupt database files */ u8 intKey; /* True if table b-trees. False for index b-trees */ u8 intKeyLeaf; /* True if the leaf of an intKey table */ Pgno pgno; /* Page number for this page */ @@ -64045,7 +64897,7 @@ struct Btree { u8 hasIncrblobCur; /* True if there are one or more Incrblob cursors */ int wantToLock; /* Number of nested calls to sqlite3BtreeEnter() */ int nBackup; /* Number of backup operations reading this btree */ - u32 iDataVersion; /* Combines with pBt->pPager->iDataVersion */ + u32 iBDataVersion; /* Combines with pBt->pPager->iDataVersion */ Btree *pNext; /* List of other sharable Btrees from the same db */ Btree *pPrev; /* Back pointer of the same list */ #ifdef SQLITE_DEBUG @@ -64150,6 +65002,7 @@ struct BtShared { Btree *pWriter; /* Btree with currently open write transaction */ #endif u8 *pTmpSpace; /* Temp space sufficient to hold a single cell */ + int nPreformatSize; /* Size of last cell written by TransferRow() */ }; /* @@ -65267,7 +66120,7 @@ static void invalidateIncrblobCursors( int isClearTable /* True if all rows are being deleted */ ){ BtCursor *p; - if( pBtree->hasIncrblobCur==0 ) return; + assert( pBtree->hasIncrblobCur ); assert( sqlite3BtreeHoldsMutex(pBtree) ); pBtree->hasIncrblobCur = 0; for(p=pBtree->pBt->pCursor; p; p=p->pNext){ @@ -65547,15 +66400,13 @@ static int btreeMoveto( sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey); if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){ rc = SQLITE_CORRUPT_BKPT; - goto moveto_done; + }else{ + rc = sqlite3BtreeIndexMoveto(pCur, pIdxKey, pRes); } + sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey); }else{ pIdxKey = 0; - } - rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes); -moveto_done: - if( pIdxKey ){ - sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey); + rc = sqlite3BtreeTableMoveto(pCur, nKey, bias, pRes); } return rc; } @@ -65863,6 +66714,24 @@ static SQLITE_NOINLINE void btreeParseCellAdjustSizeForOverflow( pInfo->nSize = (u16)(&pInfo->pPayload[pInfo->nLocal] - pCell) + 4; } +/* +** Given a record with nPayload bytes of payload stored within btree +** page pPage, return the number of bytes of payload stored locally. +*/ +static int btreePayloadToLocal(MemPage *pPage, i64 nPayload){ + int maxLocal; /* Maximum amount of payload held locally */ + maxLocal = pPage->maxLocal; + if( nPayload<=maxLocal ){ + return nPayload; + }else{ + int minLocal; /* Minimum amount of payload held locally */ + int surplus; /* Overflow payload available for local storage */ + minLocal = pPage->minLocal; + surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize-4); + return ( surplus <= maxLocal ) ? surplus : minLocal; + } +} + /* ** The following routines are implementations of the MemPage.xParseCell() ** method. @@ -66150,6 +67019,7 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){ unsigned char *src; /* Source of content */ int iCellFirst; /* First allowable cell index */ int iCellLast; /* Last possible cell index */ + int iCellStart; /* First cell offset in input */ assert( sqlite3PagerIswriteable(pPage->pDbPage) ); assert( pPage->pBt!=0 ); @@ -66210,6 +67080,7 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){ cbrk = usableSize; iCellLast = usableSize - 4; + iCellStart = get2byte(&data[hdr+5]); for(i=0; iiCellLast ){ + if( pciCellLast ){ return SQLITE_CORRUPT_PAGE(pPage); } - assert( pc>=iCellFirst && pc<=iCellLast ); + assert( pc>=iCellStart && pc<=iCellLast ); size = pPage->xCellSize(pPage, &src[pc]); cbrk -= size; - if( cbrkusableSize ){ + if( cbrkusableSize ){ return SQLITE_CORRUPT_PAGE(pPage); } - assert( cbrk+size<=usableSize && cbrk>=iCellFirst ); + assert( cbrk+size<=usableSize && cbrk>=iCellStart ); testcase( cbrk+size==usableSize ); testcase( pc+size==usableSize ); put2byte(pAddr, cbrk); if( temp==0 ){ - int x; if( cbrk==pc ) continue; temp = sqlite3PagerTempSpace(pPage->pBt->pPager); - x = get2byte(&data[hdr+5]); - memcpy(&temp[x], &data[x], (cbrk+size) - x); + memcpy(&temp[iCellStart], &data[iCellStart], usableSize - iCellStart); src = temp; } memcpy(&data[cbrk], &src[pc], size); @@ -66386,7 +67255,7 @@ static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){ int g2; assert( pSpace+nByte<=data+pPage->pBt->usableSize ); *pIdx = g2 = (int)(pSpace-data); - if( NEVER(g2<=gap) ){ + if( g2<=gap ){ return SQLITE_CORRUPT_PAGE(pPage); }else{ return SQLITE_OK; @@ -67439,19 +68308,23 @@ static void freeTempSpace(BtShared *pBt){ */ SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p){ BtShared *pBt = p->pBt; - BtCursor *pCur; /* Close all cursors opened via this handle. */ assert( sqlite3_mutex_held(p->db->mutex) ); sqlite3BtreeEnter(p); - pCur = pBt->pCursor; - while( pCur ){ - BtCursor *pTmp = pCur; - pCur = pCur->pNext; - if( pTmp->pBtree==p ){ - sqlite3BtreeCloseCursor(pTmp); + + /* Verify that no other cursors have this Btree open */ +#ifdef SQLITE_DEBUG + { + BtCursor *pCur = pBt->pCursor; + while( pCur ){ + BtCursor *pTmp = pCur; + pCur = pCur->pNext; + assert( pTmp->pBtree!=p ); + } } +#endif /* Rollback any active transaction and free the handle structure. ** The call to sqlite3BtreeRollback() drops any table-locks held by @@ -67603,6 +68476,7 @@ SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, ((pageSize-1)&pageSize)==0 ){ assert( (pageSize & 7)==0 ); assert( !pBt->pCursor ); + if( nReserve>32 && pageSize==512 ) pageSize = 1024; pBt->pageSize = (u32)pageSize; freeTempSpace(pBt); } @@ -67794,7 +68668,6 @@ static int lockBtree(BtShared *pBt){ MemPage *pPage1; /* Page 1 of the database file */ u32 nPage; /* Number of pages in the database */ u32 nPageFile = 0; /* Number of pages in the database file */ - u32 nPageHeader; /* Number of pages in the database according to hdr */ assert( sqlite3_mutex_held(pBt->mutex) ); assert( pBt->pPage1==0 ); @@ -67806,7 +68679,7 @@ static int lockBtree(BtShared *pBt){ /* Do some checking to help insure the file we opened really is ** a valid database file. */ - nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData); + nPage = get4byte(28+(u8*)pPage1->aData); sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile); if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){ nPage = nPageFile; @@ -67841,7 +68714,7 @@ static int lockBtree(BtShared *pBt){ goto page1_init_failed; } - /* If the write version is set to 2, this database should be accessed + /* If the read version is set to 2, this database should be accessed ** in WAL mode. If the log is not already open, open it now. Then ** return SQLITE_OK and return without populating BtShared.pPage1. ** The caller detects this and calls this function again. This is @@ -68639,16 +69512,18 @@ SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *p){ /* ** This routine is called prior to sqlite3PagerCommit when a transaction ** is committed for an auto-vacuum database. -** -** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages -** the database file should be truncated to during the commit process. -** i.e. the database has been reorganized so that only the first *pnTrunc -** pages are in use. */ -static int autoVacuumCommit(BtShared *pBt){ +static int autoVacuumCommit(Btree *p){ int rc = SQLITE_OK; - Pager *pPager = pBt->pPager; - VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager); ) + Pager *pPager; + BtShared *pBt; + sqlite3 *db; + VVA_ONLY( int nRef ); + + assert( p!=0 ); + pBt = p->pBt; + pPager = pBt->pPager; + VVA_ONLY( nRef = sqlite3PagerRefcount(pPager); ) assert( sqlite3_mutex_held(pBt->mutex) ); invalidateAllOverflowCache(pBt); @@ -68656,6 +69531,7 @@ static int autoVacuumCommit(BtShared *pBt){ if( !pBt->incrVacuum ){ Pgno nFin; /* Number of pages in database after autovacuuming */ Pgno nFree; /* Number of pages on the freelist initially */ + Pgno nVac; /* Number of pages to vacuum */ Pgno iFree; /* The next page to be freed */ Pgno nOrig; /* Database size before freeing */ @@ -68669,18 +69545,42 @@ static int autoVacuumCommit(BtShared *pBt){ } nFree = get4byte(&pBt->pPage1->aData[36]); - nFin = finalDbSize(pBt, nOrig, nFree); + db = p->db; + if( db->xAutovacPages ){ + int iDb; + for(iDb=0; ALWAYS(iDbnDb); iDb++){ + if( db->aDb[iDb].pBt==p ) break; + } + nVac = db->xAutovacPages( + db->pAutovacPagesArg, + db->aDb[iDb].zDbSName, + nOrig, + nFree, + pBt->pageSize + ); + if( nVac>nFree ){ + nVac = nFree; + } + if( nVac==0 ){ + return SQLITE_OK; + } + }else{ + nVac = nFree; + } + nFin = finalDbSize(pBt, nOrig, nVac); if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT; if( nFinnFin && rc==SQLITE_OK; iFree--){ - rc = incrVacuumStep(pBt, nFin, iFree, 1); + rc = incrVacuumStep(pBt, nFin, iFree, nVac==nFree); } if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){ rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); - put4byte(&pBt->pPage1->aData[32], 0); - put4byte(&pBt->pPage1->aData[36], 0); + if( nVac==nFree ){ + put4byte(&pBt->pPage1->aData[32], 0); + put4byte(&pBt->pPage1->aData[36], 0); + } put4byte(&pBt->pPage1->aData[28], nFin); pBt->bDoTruncate = 1; pBt->nPage = nFin; @@ -68731,7 +69631,7 @@ SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zSuperJrnl){ sqlite3BtreeEnter(p); #ifndef SQLITE_OMIT_AUTOVACUUM if( pBt->autoVacuum ){ - rc = autoVacuumCommit(pBt); + rc = autoVacuumCommit(p); if( rc!=SQLITE_OK ){ sqlite3BtreeLeave(p); return rc; @@ -68832,7 +69732,7 @@ SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){ sqlite3BtreeLeave(p); return rc; } - p->iDataVersion--; /* Compensate for pPager->iDataVersion++; */ + p->iBDataVersion--; /* Compensate for pPager->iDataVersion++; */ pBt->inTransaction = TRANS_READ; btreeClearHasContent(pBt); } @@ -69242,7 +70142,14 @@ SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){ unlockBtreeIfUnused(pBt); sqlite3_free(pCur->aOverflow); sqlite3_free(pCur->pKey); - sqlite3BtreeLeave(pBtree); + if( (pBt->openFlags & BTREE_SINGLE) && pBt->pCursor==0 ){ + /* Since the BtShared is not sharable, there is no need to + ** worry about the missing sqlite3BtreeLeave() call here. */ + assert( pBtree->sharable==0 ); + sqlite3BtreeClose(pBtree); + }else{ + sqlite3BtreeLeave(pBtree); + } pCur->pBtree = 0; } return SQLITE_OK; @@ -69529,7 +70436,9 @@ static int accessPayload( assert( pPage ); assert( eOp==0 || eOp==1 ); assert( pCur->eState==CURSOR_VALID ); - assert( pCur->ixnCell ); + if( pCur->ix>=pPage->nCell ){ + return SQLITE_CORRUPT_PAGE(pPage); + } assert( cursorHoldsMutex(pCur) ); getCellInfo(pCur); @@ -69716,7 +70625,6 @@ SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void assert( cursorHoldsMutex(pCur) ); assert( pCur->eState==CURSOR_VALID ); assert( pCur->iPage>=0 && pCur->pPage ); - assert( pCur->ixpPage->nCell ); return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0); } @@ -69778,7 +70686,7 @@ static const void *fetchPayload( assert( pCur->eState==CURSOR_VALID ); assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); assert( cursorOwnsBtShared(pCur) ); - assert( pCur->ixpPage->nCell ); + assert( pCur->ixpPage->nCell || CORRUPT_DB ); assert( pCur->info.nSize>0 ); assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB ); assert( pCur->info.pPayloadpPage->aDataEnd ||CORRUPT_DB); @@ -70084,7 +70992,9 @@ SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){ for(ii=0; iiiPage; ii++){ assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell ); } - assert( pCur->ix==pCur->pPage->nCell-1 ); + assert( pCur->ix==pCur->pPage->nCell-1 || CORRUPT_DB ); + testcase( pCur->ix!=pCur->pPage->nCell-1 ); + /* ^-- dbsqlfuzz b92b72e4de80b5140c30ab71372ca719b8feb618 */ assert( pCur->pPage->leaf ); #endif *pRes = 0; @@ -70109,12 +71019,8 @@ SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){ return rc; } -/* Move the cursor so that it points to an entry near the key -** specified by pIdxKey or intKey. Return a success code. -** -** For INTKEY tables, the intKey parameter is used. pIdxKey -** must be NULL. For index tables, pIdxKey is used and intKey -** is ignored. +/* Move the cursor so that it points to an entry in a table (a.k.a INTKEY) +** table near the key intKey. Return a success code. ** ** If an exact match is not found, then the cursor is always ** left pointing at a leaf page which would hold the entry if it @@ -70127,39 +71033,32 @@ SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){ ** *pRes is as follows: ** ** *pRes<0 The cursor is left pointing at an entry that -** is smaller than intKey/pIdxKey or if the table is empty +** is smaller than intKey or if the table is empty ** and the cursor is therefore left point to nothing. ** ** *pRes==0 The cursor is left pointing at an entry that -** exactly matches intKey/pIdxKey. +** exactly matches intKey. ** ** *pRes>0 The cursor is left pointing at an entry that -** is larger than intKey/pIdxKey. -** -** For index tables, the pIdxKey->eqSeen field is set to 1 if there -** exists an entry in the table that exactly matches pIdxKey. +** is larger than intKey. */ -SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( +SQLITE_PRIVATE int sqlite3BtreeTableMoveto( BtCursor *pCur, /* The cursor to be moved */ - UnpackedRecord *pIdxKey, /* Unpacked index key */ i64 intKey, /* The table key */ int biasRight, /* If true, bias the search to the high end */ int *pRes /* Write search results here */ ){ int rc; - RecordCompare xRecordCompare; assert( cursorOwnsBtShared(pCur) ); assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); assert( pRes ); - assert( (pIdxKey==0)==(pCur->pKeyInfo==0) ); - assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) ); + assert( pCur->pKeyInfo==0 ); + assert( pCur->eState!=CURSOR_VALID || pCur->curIntKey!=0 ); /* If the cursor is already positioned at the point we are trying ** to move to, then just return without doing any work */ - if( pIdxKey==0 - && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 - ){ + if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 ){ if( pCur->info.nKey==intKey ){ *pRes = 0; return SQLITE_OK; @@ -70181,9 +71080,7 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( if( pCur->info.nKey==intKey ){ return SQLITE_OK; } - }else if( rc==SQLITE_DONE ){ - rc = SQLITE_OK; - }else{ + }else if( rc!=SQLITE_DONE ){ return rc; } } @@ -70194,17 +71091,6 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( pCur->pBtree->nSeek++; /* Performance measurement during testing */ #endif - if( pIdxKey ){ - xRecordCompare = sqlite3VdbeFindCompare(pIdxKey); - pIdxKey->errCode = 0; - assert( pIdxKey->default_rc==1 - || pIdxKey->default_rc==0 - || pIdxKey->default_rc==-1 - ); - }else{ - xRecordCompare = 0; /* All keys are integers */ - } - rc = moveToRoot(pCur); if( rc ){ if( rc==SQLITE_EMPTY ){ @@ -70219,7 +71105,8 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( assert( pCur->eState==CURSOR_VALID ); assert( pCur->pPage->nCell > 0 ); assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey ); - assert( pCur->curIntKey || pIdxKey ); + assert( pCur->curIntKey ); + for(;;){ int lwr, upr, idx, c; Pgno chldPg; @@ -70233,133 +71120,238 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( ** be the right kind (index or table) of b-tree page. Otherwise ** a moveToChild() or moveToRoot() call would have detected corruption. */ assert( pPage->nCell>0 ); - assert( pPage->intKey==(pIdxKey==0) ); + assert( pPage->intKey ); lwr = 0; upr = pPage->nCell-1; assert( biasRight==0 || biasRight==1 ); idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */ pCur->ix = (u16)idx; - if( xRecordCompare==0 ){ - for(;;){ - i64 nCellKey; - pCell = findCellPastPtr(pPage, idx); - if( pPage->intKeyLeaf ){ - while( 0x80 <= *(pCell++) ){ - if( pCell>=pPage->aDataEnd ){ - return SQLITE_CORRUPT_PAGE(pPage); - } + for(;;){ + i64 nCellKey; + pCell = findCellPastPtr(pPage, idx); + if( pPage->intKeyLeaf ){ + while( 0x80 <= *(pCell++) ){ + if( pCell>=pPage->aDataEnd ){ + return SQLITE_CORRUPT_PAGE(pPage); } } - getVarint(pCell, (u64*)&nCellKey); - if( nCellKeyupr ){ c = -1; break; } - }else if( nCellKey>intKey ){ - upr = idx-1; - if( lwr>upr ){ c = +1; break; } + } + getVarint(pCell, (u64*)&nCellKey); + if( nCellKeyupr ){ c = -1; break; } + }else if( nCellKey>intKey ){ + upr = idx-1; + if( lwr>upr ){ c = +1; break; } + }else{ + assert( nCellKey==intKey ); + pCur->ix = (u16)idx; + if( !pPage->leaf ){ + lwr = idx; + goto moveto_table_next_layer; }else{ - assert( nCellKey==intKey ); - pCur->ix = (u16)idx; - if( !pPage->leaf ){ - lwr = idx; - goto moveto_next_layer; - }else{ - pCur->curFlags |= BTCF_ValidNKey; - pCur->info.nKey = nCellKey; - pCur->info.nSize = 0; - *pRes = 0; - return SQLITE_OK; - } + pCur->curFlags |= BTCF_ValidNKey; + pCur->info.nKey = nCellKey; + pCur->info.nSize = 0; + *pRes = 0; + return SQLITE_OK; } - assert( lwr+upr>=0 ); - idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2; */ } + assert( lwr+upr>=0 ); + idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2; */ + } + assert( lwr==upr+1 || !pPage->leaf ); + assert( pPage->isInit ); + if( pPage->leaf ){ + assert( pCur->ixpPage->nCell ); + pCur->ix = (u16)idx; + *pRes = c; + rc = SQLITE_OK; + goto moveto_table_finish; + } +moveto_table_next_layer: + if( lwr>=pPage->nCell ){ + chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); }else{ - for(;;){ - int nCell; /* Size of the pCell cell in bytes */ - pCell = findCellPastPtr(pPage, idx); - - /* The maximum supported page-size is 65536 bytes. This means that - ** the maximum number of record bytes stored on an index B-Tree - ** page is less than 16384 bytes and may be stored as a 2-byte - ** varint. This information is used to attempt to avoid parsing - ** the entire cell by checking for the cases where the record is - ** stored entirely within the b-tree page by inspecting the first - ** 2 bytes of the cell. - */ - nCell = pCell[0]; - if( nCell<=pPage->max1bytePayload ){ - /* This branch runs if the record-size field of the cell is a - ** single byte varint and the record fits entirely on the main - ** b-tree page. */ - testcase( pCell+nCell+1==pPage->aDataEnd ); - c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey); - }else if( !(pCell[1] & 0x80) - && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal - ){ - /* The record-size field is a 2 byte varint and the record - ** fits entirely on the main b-tree page. */ - testcase( pCell+nCell+2==pPage->aDataEnd ); - c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey); - }else{ - /* The record flows over onto one or more overflow pages. In - ** this case the whole cell needs to be parsed, a buffer allocated - ** and accessPayload() used to retrieve the record into the - ** buffer before VdbeRecordCompare() can be called. - ** - ** If the record is corrupt, the xRecordCompare routine may read - ** up to two varints past the end of the buffer. An extra 18 - ** bytes of padding is allocated at the end of the buffer in - ** case this happens. */ - void *pCellKey; - u8 * const pCellBody = pCell - pPage->childPtrSize; - const int nOverrun = 18; /* Size of the overrun padding */ - pPage->xParseCell(pPage, pCellBody, &pCur->info); - nCell = (int)pCur->info.nKey; - testcase( nCell<0 ); /* True if key size is 2^32 or more */ - testcase( nCell==0 ); /* Invalid key size: 0x80 0x80 0x00 */ - testcase( nCell==1 ); /* Invalid key size: 0x80 0x80 0x01 */ - testcase( nCell==2 ); /* Minimum legal index key size */ - if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){ - rc = SQLITE_CORRUPT_PAGE(pPage); - goto moveto_finish; - } - pCellKey = sqlite3Malloc( nCell+nOverrun ); - if( pCellKey==0 ){ - rc = SQLITE_NOMEM_BKPT; - goto moveto_finish; - } - pCur->ix = (u16)idx; - rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0); - memset(((u8*)pCellKey)+nCell,0,nOverrun); /* Fix uninit warnings */ - pCur->curFlags &= ~BTCF_ValidOvfl; - if( rc ){ - sqlite3_free(pCellKey); - goto moveto_finish; - } - c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey); - sqlite3_free(pCellKey); + chldPg = get4byte(findCell(pPage, lwr)); + } + pCur->ix = (u16)lwr; + rc = moveToChild(pCur, chldPg); + if( rc ) break; + } +moveto_table_finish: + pCur->info.nSize = 0; + assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); + return rc; +} + +/* Move the cursor so that it points to an entry in an index table +** near the key pIdxKey. Return a success code. +** +** If an exact match is not found, then the cursor is always +** left pointing at a leaf page which would hold the entry if it +** were present. The cursor might point to an entry that comes +** before or after the key. +** +** An integer is written into *pRes which is the result of +** comparing the key with the entry to which the cursor is +** pointing. The meaning of the integer written into +** *pRes is as follows: +** +** *pRes<0 The cursor is left pointing at an entry that +** is smaller than pIdxKey or if the table is empty +** and the cursor is therefore left point to nothing. +** +** *pRes==0 The cursor is left pointing at an entry that +** exactly matches pIdxKey. +** +** *pRes>0 The cursor is left pointing at an entry that +** is larger than pIdxKey. +** +** The pIdxKey->eqSeen field is set to 1 if there +** exists an entry in the table that exactly matches pIdxKey. +*/ +SQLITE_PRIVATE int sqlite3BtreeIndexMoveto( + BtCursor *pCur, /* The cursor to be moved */ + UnpackedRecord *pIdxKey, /* Unpacked index key */ + int *pRes /* Write search results here */ +){ + int rc; + RecordCompare xRecordCompare; + + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + assert( pRes ); + assert( pCur->pKeyInfo!=0 ); + +#ifdef SQLITE_DEBUG + pCur->pBtree->nSeek++; /* Performance measurement during testing */ +#endif + + xRecordCompare = sqlite3VdbeFindCompare(pIdxKey); + pIdxKey->errCode = 0; + assert( pIdxKey->default_rc==1 + || pIdxKey->default_rc==0 + || pIdxKey->default_rc==-1 + ); + + rc = moveToRoot(pCur); + if( rc ){ + if( rc==SQLITE_EMPTY ){ + assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 ); + *pRes = -1; + return SQLITE_OK; + } + return rc; + } + assert( pCur->pPage ); + assert( pCur->pPage->isInit ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->pPage->nCell > 0 ); + assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey ); + assert( pCur->curIntKey || pIdxKey ); + for(;;){ + int lwr, upr, idx, c; + Pgno chldPg; + MemPage *pPage = pCur->pPage; + u8 *pCell; /* Pointer to current cell in pPage */ + + /* pPage->nCell must be greater than zero. If this is the root-page + ** the cursor would have been INVALID above and this for(;;) loop + ** not run. If this is not the root-page, then the moveToChild() routine + ** would have already detected db corruption. Similarly, pPage must + ** be the right kind (index or table) of b-tree page. Otherwise + ** a moveToChild() or moveToRoot() call would have detected corruption. */ + assert( pPage->nCell>0 ); + assert( pPage->intKey==(pIdxKey==0) ); + lwr = 0; + upr = pPage->nCell-1; + idx = upr>>1; /* idx = (lwr+upr)/2; */ + pCur->ix = (u16)idx; + for(;;){ + int nCell; /* Size of the pCell cell in bytes */ + pCell = findCellPastPtr(pPage, idx); + + /* The maximum supported page-size is 65536 bytes. This means that + ** the maximum number of record bytes stored on an index B-Tree + ** page is less than 16384 bytes and may be stored as a 2-byte + ** varint. This information is used to attempt to avoid parsing + ** the entire cell by checking for the cases where the record is + ** stored entirely within the b-tree page by inspecting the first + ** 2 bytes of the cell. + */ + nCell = pCell[0]; + if( nCell<=pPage->max1bytePayload ){ + /* This branch runs if the record-size field of the cell is a + ** single byte varint and the record fits entirely on the main + ** b-tree page. */ + testcase( pCell+nCell+1==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey); + }else if( !(pCell[1] & 0x80) + && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal + ){ + /* The record-size field is a 2 byte varint and the record + ** fits entirely on the main b-tree page. */ + testcase( pCell+nCell+2==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey); + }else{ + /* The record flows over onto one or more overflow pages. In + ** this case the whole cell needs to be parsed, a buffer allocated + ** and accessPayload() used to retrieve the record into the + ** buffer before VdbeRecordCompare() can be called. + ** + ** If the record is corrupt, the xRecordCompare routine may read + ** up to two varints past the end of the buffer. An extra 18 + ** bytes of padding is allocated at the end of the buffer in + ** case this happens. */ + void *pCellKey; + u8 * const pCellBody = pCell - pPage->childPtrSize; + const int nOverrun = 18; /* Size of the overrun padding */ + pPage->xParseCell(pPage, pCellBody, &pCur->info); + nCell = (int)pCur->info.nKey; + testcase( nCell<0 ); /* True if key size is 2^32 or more */ + testcase( nCell==0 ); /* Invalid key size: 0x80 0x80 0x00 */ + testcase( nCell==1 ); /* Invalid key size: 0x80 0x80 0x01 */ + testcase( nCell==2 ); /* Minimum legal index key size */ + if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){ + rc = SQLITE_CORRUPT_PAGE(pPage); + goto moveto_index_finish; + } + pCellKey = sqlite3Malloc( nCell+nOverrun ); + if( pCellKey==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto moveto_index_finish; } - assert( - (pIdxKey->errCode!=SQLITE_CORRUPT || c==0) - && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed) - ); - if( c<0 ){ - lwr = idx+1; - }else if( c>0 ){ - upr = idx-1; - }else{ - assert( c==0 ); - *pRes = 0; - rc = SQLITE_OK; - pCur->ix = (u16)idx; - if( pIdxKey->errCode ) rc = SQLITE_CORRUPT_BKPT; - goto moveto_finish; + pCur->ix = (u16)idx; + rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0); + memset(((u8*)pCellKey)+nCell,0,nOverrun); /* Fix uninit warnings */ + pCur->curFlags &= ~BTCF_ValidOvfl; + if( rc ){ + sqlite3_free(pCellKey); + goto moveto_index_finish; } - if( lwr>upr ) break; - assert( lwr+upr>=0 ); - idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2 */ + c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey); + sqlite3_free(pCellKey); + } + assert( + (pIdxKey->errCode!=SQLITE_CORRUPT || c==0) + && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed) + ); + if( c<0 ){ + lwr = idx+1; + }else if( c>0 ){ + upr = idx-1; + }else{ + assert( c==0 ); + *pRes = 0; + rc = SQLITE_OK; + pCur->ix = (u16)idx; + if( pIdxKey->errCode ) rc = SQLITE_CORRUPT_BKPT; + goto moveto_index_finish; } + if( lwr>upr ) break; + assert( lwr+upr>=0 ); + idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2 */ } assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) ); assert( pPage->isInit ); @@ -70368,9 +71360,8 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( pCur->ix = (u16)idx; *pRes = c; rc = SQLITE_OK; - goto moveto_finish; + goto moveto_index_finish; } -moveto_next_layer: if( lwr>=pPage->nCell ){ chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); }else{ @@ -70380,7 +71371,7 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( rc = moveToChild(pCur, chldPg); if( rc ) break; } -moveto_finish: +moveto_index_finish: pCur->info.nSize = 0; assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); return rc; @@ -70481,16 +71472,6 @@ static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){ return SQLITE_CORRUPT_BKPT; } - /* If the database file is corrupt, it is possible for the value of idx - ** to be invalid here. This can only occur if a second cursor modifies - ** the page while cursor pCur is holding a reference to it. Which can - ** only happen if the database is corrupt in such a way as to link the - ** page into more than one b-tree structure. - ** - ** Update 2019-12-23: appears to long longer be possible after the - ** addition of anotherValidCursor() condition on balance_deeper(). */ - harmless( idx>pPage->nCell ); - if( idx>=pPage->nCell ){ if( !pPage->leaf ){ rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); @@ -70851,7 +71832,7 @@ static int allocateBtreePage( iPage = get4byte(&aData[8+closest*4]); testcase( iPage==mxPage ); - if( iPage>mxPage ){ + if( iPage>mxPage || iPage<2 ){ rc = SQLITE_CORRUPT_PGNO(iTrunk); goto end_allocate_page; } @@ -70978,7 +71959,7 @@ static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){ assert( CORRUPT_DB || iPage>1 ); assert( !pMemPage || pMemPage->pgno==iPage ); - if( iPage<2 || iPage>pBt->nPage ){ + if( NEVER(iPage<2) || iPage>pBt->nPage ){ return SQLITE_CORRUPT_BKPT; } if( pMemPage ){ @@ -71107,10 +72088,9 @@ static void freePage(MemPage *pPage, int *pRC){ } /* -** Free any overflow pages associated with the given Cell. Store -** size information about the cell in pInfo. +** Free the overflow pages associated with the given Cell. */ -static int clearCell( +static SQLITE_NOINLINE int clearCellOverflow( MemPage *pPage, /* The page that contains the Cell */ unsigned char *pCell, /* First byte of the Cell */ CellInfo *pInfo /* Size information about the cell */ @@ -71122,10 +72102,7 @@ static int clearCell( u32 ovflPageSize; assert( sqlite3_mutex_held(pPage->pBt->mutex) ); - pPage->xParseCell(pPage, pCell, pInfo); - if( pInfo->nLocal==pInfo->nPayload ){ - return SQLITE_OK; /* No overflow pages. Return without doing anything */ - } + assert( pInfo->nLocal!=pInfo->nPayload ); testcase( pCell + pInfo->nSize == pPage->aDataEnd ); testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd ); if( pCell + pInfo->nSize > pPage->aDataEnd ){ @@ -71181,6 +72158,21 @@ static int clearCell( return SQLITE_OK; } +/* Call xParseCell to compute the size of a cell. If the cell contains +** overflow, then invoke cellClearOverflow to clear out that overflow. +** STore the result code (SQLITE_OK or some error code) in rc. +** +** Implemented as macro to force inlining for performance. +*/ +#define BTREE_CLEAR_CELL(rc, pPage, pCell, sInfo) \ + pPage->xParseCell(pPage, pCell, &sInfo); \ + if( sInfo.nLocal!=sInfo.nPayload ){ \ + rc = clearCellOverflow(pPage, pCell, &sInfo); \ + }else{ \ + rc = SQLITE_OK; \ + } + + /* ** Create the byte sequence used to represent a cell on page pPage ** and write that byte sequence into pCell[]. Overflow pages are @@ -71703,7 +72695,7 @@ static int rebuildPage( u8 *pCell = pCArray->apCell[i]; u16 sz = pCArray->szCell[i]; assert( sz>0 ); - if( SQLITE_WITHIN(pCell,aData,pEnd) ){ + if( SQLITE_WITHIN(pCell,aData+j,pEnd) ){ if( ((uptr)(pCell+sz))>(uptr)pEnd ) return SQLITE_CORRUPT_BKPT; pCell = &pTmp[pCell - aData]; }else if( (uptr)(pCell+sz)>(uptr)pSrcEnd @@ -71716,9 +72708,8 @@ static int rebuildPage( put2byte(pCellptr, (pData - aData)); pCellptr += 2; if( pData < pCellptr ) return SQLITE_CORRUPT_BKPT; - memcpy(pData, pCell, sz); + memmove(pData, pCell, sz); assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB ); - testcase( sz!=pPg->xCellSize(pPg,pCell) ) i++; if( i>=iEnd ) break; if( pCArray->ixNx[k]<=i ){ @@ -71857,7 +72848,9 @@ static int pageFreeArray( } pFree = pCell; szFree = sz; - if( pFree+sz>pEnd ) return 0; + if( pFree+sz>pEnd ){ + return 0; + } }else{ pFree = pCell; szFree += sz; @@ -71922,6 +72915,7 @@ static int editPage( pData = &aData[get2byteNotZero(&aData[hdr+5])]; if( pDatapPg->aDataEnd) ) goto editpage_fail; /* Add cells to the start of the page */ if( iNewpBt; assert( sqlite3_mutex_held(pBt->mutex) ); assert( sqlite3PagerIswriteable(pParent->pDbPage) ); @@ -72338,7 +73331,9 @@ static int balance_nonroot( } pgno = get4byte(pRight); while( 1 ){ - rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0); + if( rc==SQLITE_OK ){ + rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0); + } if( rc ){ memset(apOld, 0, (i+1)*sizeof(MemPage*)); goto balance_cleanup; @@ -72350,6 +73345,7 @@ static int balance_nonroot( goto balance_cleanup; } } + nMaxCells += apOld[i]->nCell + ArraySize(pParent->apOvfl); if( (i--)==0 ) break; if( pParent->nOverflow && i+nxDiv==pParent->aiOvfl[0] ){ @@ -72377,12 +73373,10 @@ static int balance_nonroot( if( pBt->btsFlags & BTS_FAST_SECURE ){ int iOff; + /* If the following if() condition is not true, the db is corrupted. + ** The call to dropCell() below will detect this. */ iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData); - if( (iOff+szNew[i])>(int)pBt->usableSize ){ - rc = SQLITE_CORRUPT_BKPT; - memset(apOld, 0, (i+1)*sizeof(MemPage*)); - goto balance_cleanup; - }else{ + if( (iOff+szNew[i])<=(int)pBt->usableSize ){ memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]); apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData]; } @@ -72393,7 +73387,6 @@ static int balance_nonroot( /* Make nMaxCells a multiple of 4 in order to preserve 8-byte ** alignment */ - nMaxCells = nOld*(MX_CELL(pBt) + ArraySize(pParent->apOvfl)); nMaxCells = (nMaxCells + 3)&~3; /* @@ -72510,7 +73503,7 @@ static int balance_nonroot( b.szCell[b.nCell] = b.szCell[b.nCell] - leafCorrection; if( !pOld->leaf ){ assert( leafCorrection==0 ); - assert( pOld->hdrOffset==0 ); + assert( pOld->hdrOffset==0 || CORRUPT_DB ); /* The right pointer of the child page pOld becomes the left ** pointer of the divider cell */ memcpy(b.apCell[b.nCell], &pOld->aData[8], 4); @@ -72676,6 +73669,11 @@ static int balance_nonroot( apOld[i] = 0; rc = sqlite3PagerWrite(pNew->pDbPage); nNew++; + if( sqlite3PagerPageRefcount(pNew->pDbPage)!=1+(i==(iParentIdx-nxDiv)) + && rc==SQLITE_OK + ){ + rc = SQLITE_CORRUPT_BKPT; + } if( rc ) goto balance_cleanup; }else{ assert( i>0 ); @@ -72712,7 +73710,7 @@ static int balance_nonroot( aPgOrder[i] = aPgno[i] = apNew[i]->pgno; aPgFlags[i] = apNew[i]->pDbPage->flags; for(j=0; jmaxLocal+23 ); assert( iOvflSpace <= (int)pBt->pageSize ); + for(k=0; b.ixNx[k]<=i && ALWAYS(kpgno, &rc); if( rc!=SQLITE_OK ) goto balance_cleanup; assert( sqlite3PagerIswriteable(pParent->pDbPage) ); @@ -73086,7 +74091,7 @@ static int balance_deeper(MemPage *pRoot, MemPage **ppChild){ ** Return SQLITE_CORRUPT if any cursor other than pCur is currently valid ** on the same B-tree as pCur. ** -** This can if a database is corrupt with two or more SQL tables +** This can occur if a database is corrupt with two or more SQL tables ** pointing to the same b-tree. If an insert occurs on one SQL table ** and causes a BEFORE TRIGGER to do a secondary insert on the other SQL ** table linked to the same b-tree. If the secondary insert causes a @@ -73315,7 +74320,7 @@ static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){ do{ rc = btreeGetPage(pBt, ovflPgno, &pPage, 0); if( rc ) return rc; - if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 ){ + if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 || pPage->isInit ){ rc = SQLITE_CORRUPT_BKPT; }else{ if( iOffset+ovflPageSize<(u32)nTotal ){ @@ -73380,7 +74385,8 @@ SQLITE_PRIVATE int sqlite3BtreeInsert( unsigned char *oldCell; unsigned char *newCell = 0; - assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND))==flags ); + assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND|BTREE_PREFORMAT))==flags ); + assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 ); if( pCur->eState==CURSOR_FAULT ){ assert( pCur->skipNext!=SQLITE_OK ); @@ -73398,7 +74404,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert( ** keys with no associated data. If the cursor was opened expecting an ** intkey table, the caller should be inserting integer keys with a ** blob of associated data. */ - assert( (pX->pKey==0)==(pCur->pKeyInfo==0) ); + assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) ); /* Save the positions of any other cursors open on this table. ** @@ -73414,13 +74420,23 @@ SQLITE_PRIVATE int sqlite3BtreeInsert( if( pCur->curFlags & BTCF_Multiple ){ rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur); if( rc ) return rc; + if( loc && pCur->iPage<0 ){ + /* This can only happen if the schema is corrupt such that there is more + ** than one table or index with the same root page as used by the cursor. + ** Which can only happen if the SQLITE_NoSchemaError flag was set when + ** the schema was loaded. This cannot be asserted though, as a user might + ** set the flag, load the schema, and then unset the flag. */ + return SQLITE_CORRUPT_BKPT; + } } if( pCur->pKeyInfo==0 ){ assert( pX->pKey==0 ); /* If this is an insert into a table b-tree, invalidate any incrblob ** cursors open on the row being replaced */ - invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0); + if( p->hasIncrblobCur ){ + invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0); + } /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing ** to a row with the same key as the new entry being inserted. @@ -73453,7 +74469,8 @@ SQLITE_PRIVATE int sqlite3BtreeInsert( ** to an adjacent cell. Move the cursor so that it is pointing either ** to the cell to be overwritten or an adjacent cell. */ - rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, flags!=0, &loc); + rc = sqlite3BtreeTableMoveto(pCur, pX->nKey, + (flags & BTREE_APPEND)!=0, &loc); if( rc ) return rc; } }else{ @@ -73476,13 +74493,11 @@ SQLITE_PRIVATE int sqlite3BtreeInsert( r.aMem = pX->aMem; r.nField = pX->nMem; r.default_rc = 0; - r.errCode = 0; - r.r1 = 0; - r.r2 = 0; r.eqSeen = 0; - rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, flags!=0, &loc); + rc = sqlite3BtreeIndexMoveto(pCur, &r, &loc); }else{ - rc = btreeMoveto(pCur, pX->pKey, pX->nKey, flags!=0, &loc); + rc = btreeMoveto(pCur, pX->pKey, pX->nKey, + (flags & BTREE_APPEND)!=0, &loc); } if( rc ) return rc; } @@ -73501,17 +74516,16 @@ SQLITE_PRIVATE int sqlite3BtreeInsert( return btreeOverwriteCell(pCur, &x2); } } - } assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) || CORRUPT_DB ); pPage = pCur->pPage; - assert( pPage->intKey || pX->nKey>=0 ); + assert( pPage->intKey || pX->nKey>=0 || (flags & BTREE_PREFORMAT) ); assert( pPage->leaf || !pPage->intKey ); if( pPage->nFree<0 ){ - if( pCur->eState>CURSOR_INVALID ){ + if( NEVER(pCur->eState>CURSOR_INVALID) ){ rc = SQLITE_CORRUPT_BKPT; }else{ rc = btreeComputeFreeSpace(pPage); @@ -73525,14 +74539,31 @@ SQLITE_PRIVATE int sqlite3BtreeInsert( assert( pPage->isInit ); newCell = pBt->pTmpSpace; assert( newCell!=0 ); - rc = fillInCell(pPage, newCell, pX, &szNew); + if( flags & BTREE_PREFORMAT ){ + rc = SQLITE_OK; + szNew = pBt->nPreformatSize; + if( szNew<4 ) szNew = 4; + if( ISAUTOVACUUM && szNew>pPage->maxLocal ){ + CellInfo info; + pPage->xParseCell(pPage, newCell, &info); + if( info.nPayload!=info.nLocal ){ + Pgno ovfl = get4byte(&newCell[szNew-4]); + ptrmapPut(pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, &rc); + } + } + }else{ + rc = fillInCell(pPage, newCell, pX, &szNew); + } if( rc ) goto end_insert; assert( szNew==pPage->xCellSize(pPage, newCell) ); assert( szNew <= MX_CELL_SIZE(pBt) ); idx = pCur->ix; if( loc==0 ){ CellInfo info; - assert( idxnCell ); + assert( idx>=0 ); + if( idx>=pPage->nCell ){ + return SQLITE_CORRUPT_BKPT; + } rc = sqlite3PagerWrite(pPage->pDbPage); if( rc ){ goto end_insert; @@ -73541,7 +74572,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert( if( !pPage->leaf ){ memcpy(newCell, oldCell, 4); } - rc = clearCell(pPage, oldCell, &info); + BTREE_CLEAR_CELL(rc, pPage, oldCell, info); testcase( pCur->curFlags & BTCF_ValidOvfl ); invalidateOverflowCache(pCur); if( info.nSize==szNew && info.nLocal==info.nPayload @@ -73632,6 +74663,114 @@ SQLITE_PRIVATE int sqlite3BtreeInsert( return rc; } +/* +** This function is used as part of copying the current row from cursor +** pSrc into cursor pDest. If the cursors are open on intkey tables, then +** parameter iKey is used as the rowid value when the record is copied +** into pDest. Otherwise, the record is copied verbatim. +** +** This function does not actually write the new value to cursor pDest. +** Instead, it creates and populates any required overflow pages and +** writes the data for the new cell into the BtShared.pTmpSpace buffer +** for the destination database. The size of the cell, in bytes, is left +** in BtShared.nPreformatSize. The caller completes the insertion by +** calling sqlite3BtreeInsert() with the BTREE_PREFORMAT flag specified. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64 iKey){ + int rc = SQLITE_OK; + BtShared *pBt = pDest->pBt; + u8 *aOut = pBt->pTmpSpace; /* Pointer to next output buffer */ + const u8 *aIn; /* Pointer to next input buffer */ + u32 nIn; /* Size of input buffer aIn[] */ + u32 nRem; /* Bytes of data still to copy */ + + getCellInfo(pSrc); + aOut += putVarint32(aOut, pSrc->info.nPayload); + if( pDest->pKeyInfo==0 ) aOut += putVarint(aOut, iKey); + nIn = pSrc->info.nLocal; + aIn = pSrc->info.pPayload; + if( aIn+nIn>pSrc->pPage->aDataEnd ){ + return SQLITE_CORRUPT_BKPT; + } + nRem = pSrc->info.nPayload; + if( nIn==nRem && nInpPage->maxLocal ){ + memcpy(aOut, aIn, nIn); + pBt->nPreformatSize = nIn + (aOut - pBt->pTmpSpace); + }else{ + Pager *pSrcPager = pSrc->pBt->pPager; + u8 *pPgnoOut = 0; + Pgno ovflIn = 0; + DbPage *pPageIn = 0; + MemPage *pPageOut = 0; + u32 nOut; /* Size of output buffer aOut[] */ + + nOut = btreePayloadToLocal(pDest->pPage, pSrc->info.nPayload); + pBt->nPreformatSize = nOut + (aOut - pBt->pTmpSpace); + if( nOutinfo.nPayload ){ + pPgnoOut = &aOut[nOut]; + pBt->nPreformatSize += 4; + } + + if( nRem>nIn ){ + if( aIn+nIn+4>pSrc->pPage->aDataEnd ){ + return SQLITE_CORRUPT_BKPT; + } + ovflIn = get4byte(&pSrc->info.pPayload[nIn]); + } + + do { + nRem -= nOut; + do{ + assert( nOut>0 ); + if( nIn>0 ){ + int nCopy = MIN(nOut, nIn); + memcpy(aOut, aIn, nCopy); + nOut -= nCopy; + nIn -= nCopy; + aOut += nCopy; + aIn += nCopy; + } + if( nOut>0 ){ + sqlite3PagerUnref(pPageIn); + pPageIn = 0; + rc = sqlite3PagerGet(pSrcPager, ovflIn, &pPageIn, PAGER_GET_READONLY); + if( rc==SQLITE_OK ){ + aIn = (const u8*)sqlite3PagerGetData(pPageIn); + ovflIn = get4byte(aIn); + aIn += 4; + nIn = pSrc->pBt->usableSize - 4; + } + } + }while( rc==SQLITE_OK && nOut>0 ); + + if( rc==SQLITE_OK && nRem>0 && ALWAYS(pPgnoOut) ){ + Pgno pgnoNew; + MemPage *pNew = 0; + rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0); + put4byte(pPgnoOut, pgnoNew); + if( ISAUTOVACUUM && pPageOut ){ + ptrmapPut(pBt, pgnoNew, PTRMAP_OVERFLOW2, pPageOut->pgno, &rc); + } + releasePage(pPageOut); + pPageOut = pNew; + if( pPageOut ){ + pPgnoOut = pPageOut->aData; + put4byte(pPgnoOut, 0); + aOut = &pPgnoOut[4]; + nOut = MIN(pBt->usableSize - 4, nRem); + } + } + }while( nRem>0 && rc==SQLITE_OK ); + + releasePage(pPageOut); + sqlite3PagerUnref(pPageIn); + } + + return rc; +} + /* ** Delete the entry that the cursor is pointing to. ** @@ -73670,9 +74809,10 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){ assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 ); if( pCur->eState==CURSOR_REQUIRESEEK ){ rc = btreeRestoreCursorPosition(pCur); - if( rc ) return rc; + assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID ); + if( rc || pCur->eState!=CURSOR_VALID ) return rc; } - assert( pCur->eState==CURSOR_VALID ); + assert( CORRUPT_DB || pCur->eState==CURSOR_VALID ); iCellDepth = pCur->iPage; iCellIdx = pCur->ix; @@ -73725,7 +74865,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){ /* If this is a delete operation to remove a row from a table b-tree, ** invalidate any incrblob cursors open on the row being deleted. */ - if( pCur->pKeyInfo==0 ){ + if( pCur->pKeyInfo==0 && p->hasIncrblobCur ){ invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0); } @@ -73734,7 +74874,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){ ** itself from within the page. */ rc = sqlite3PagerWrite(pPage->pDbPage); if( rc ) return rc; - rc = clearCell(pPage, pCell, &info); + BTREE_CLEAR_CELL(rc, pPage, pCell, info); dropCell(pPage, iCellIdx, info.nSize, &rc); if( rc ) return rc; @@ -73994,7 +75134,7 @@ static int clearDatabasePage( BtShared *pBt, /* The BTree that contains the table */ Pgno pgno, /* Page number to clear */ int freePageFlag, /* Deallocate page if true */ - int *pnChange /* Add number of Cells freed to this counter */ + i64 *pnChange /* Add number of Cells freed to this counter */ ){ MemPage *pPage; int rc; @@ -74009,11 +75149,12 @@ static int clearDatabasePage( } rc = getAndInitPage(pBt, pgno, &pPage, 0, 0); if( rc ) return rc; - if( pPage->bBusy ){ + if( (pBt->openFlags & BTREE_SINGLE)==0 + && sqlite3PagerPageRefcount(pPage->pDbPage)!=1 + ){ rc = SQLITE_CORRUPT_BKPT; goto cleardatabasepage_out; } - pPage->bBusy = 1; hdr = pPage->hdrOffset; for(i=0; inCell; i++){ pCell = findCell(pPage, i); @@ -74021,14 +75162,15 @@ static int clearDatabasePage( rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange); if( rc ) goto cleardatabasepage_out; } - rc = clearCell(pPage, pCell, &info); + BTREE_CLEAR_CELL(rc, pPage, pCell, info); if( rc ) goto cleardatabasepage_out; } if( !pPage->leaf ){ rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange); if( rc ) goto cleardatabasepage_out; - }else if( pnChange ){ - assert( pPage->intKey || CORRUPT_DB ); + if( pPage->intKey ) pnChange = 0; + } + if( pnChange ){ testcase( !pPage->intKey ); *pnChange += pPage->nCell; } @@ -74039,7 +75181,6 @@ static int clearDatabasePage( } cleardatabasepage_out: - pPage->bBusy = 0; releasePage(pPage); return rc; } @@ -74053,11 +75194,10 @@ static int clearDatabasePage( ** read cursors on the table. Open write cursors are moved to the ** root of the table. ** -** If pnChange is not NULL, then table iTable must be an intkey table. The -** integer value pointed to by pnChange is incremented by the number of -** entries in the table. +** If pnChange is not NULL, then the integer value pointed to by pnChange +** is incremented by the number of entries in the table. */ -SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){ +SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, i64 *pnChange){ int rc; BtShared *pBt = p->pBt; sqlite3BtreeEnter(p); @@ -74069,7 +75209,9 @@ SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){ /* Invalidate all incrblob cursors open on table iTable (assuming iTable ** is the root of a table b-tree - if it is not, the following call is ** a no-op). */ - invalidateIncrblobCursors(p, (Pgno)iTable, 0, 1); + if( p->hasIncrblobCur ){ + invalidateIncrblobCursors(p, (Pgno)iTable, 0, 1); + } rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange); } sqlite3BtreeLeave(p); @@ -74117,10 +75259,10 @@ static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){ return SQLITE_CORRUPT_BKPT; } - rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0); - if( rc ) return rc; rc = sqlite3BtreeClearTable(p, iTable, 0); - if( rc ){ + if( rc ) return rc; + rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0); + if( NEVER(rc) ){ releasePage(pPage); return rc; } @@ -74229,7 +75371,7 @@ SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){ assert( idx>=0 && idx<=15 ); if( idx==BTREE_DATA_VERSION ){ - *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion; + *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iBDataVersion; }else{ *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]); } @@ -76152,7 +77294,9 @@ SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){ /* The szMalloc field holds the correct memory allocation size */ assert( p->szMalloc==0 - || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc) ); + || (p->flags==MEM_Undefined + && p->szMalloc<=sqlite3DbMallocSize(p->db,p->zMalloc)) + || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc)); /* If p holds a string or blob, the Mem.z must point to exactly ** one of the following: @@ -76275,6 +77419,7 @@ SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){ #ifndef SQLITE_OMIT_UTF16 int rc; #endif + assert( pMem!=0 ); assert( !sqlite3VdbeMemIsRowSet(pMem) ); assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE || desiredEnc==SQLITE_UTF16BE ); @@ -76316,7 +77461,9 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPre testcase( bPreserve && pMem->z==0 ); assert( pMem->szMalloc==0 - || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) ); + || (pMem->flags==MEM_Undefined + && pMem->szMalloc<=sqlite3DbMallocSize(pMem->db,pMem->zMalloc)) + || pMem->szMalloc==sqlite3DbMallocSize(pMem->db,pMem->zMalloc)); if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){ if( pMem->db ){ pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n); @@ -76405,6 +77552,7 @@ static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){ ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails. */ SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){ + assert( pMem!=0 ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); assert( !sqlite3VdbeMemIsRowSet(pMem) ); if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){ @@ -76429,6 +77577,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){ #ifndef SQLITE_OMIT_INCRBLOB SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){ int nByte; + assert( pMem!=0 ); assert( pMem->flags & MEM_Zero ); assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) ); testcase( sqlite3_value_nochange(pMem) ); @@ -76444,6 +77593,8 @@ SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){ if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){ return SQLITE_NOMEM_BKPT; } + assert( pMem->z!=0 ); + assert( sqlite3DbMallocSize(pMem->db,pMem->z) >= nByte ); memset(&pMem->z[pMem->n], 0, pMem->u.nZero); pMem->n += pMem->u.nZero; @@ -76456,6 +77607,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){ ** Make sure the given Mem is \u0000 terminated. */ SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){ + assert( pMem!=0 ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) ); testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 ); @@ -76483,6 +77635,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){ SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){ const int nByte = 32; + assert( pMem!=0 ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); assert( !(pMem->flags&MEM_Zero) ); assert( !(pMem->flags&(MEM_Str|MEM_Blob)) ); @@ -76518,6 +77671,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){ sqlite3_context ctx; Mem t; assert( pFunc!=0 ); + assert( pMem!=0 ); assert( pFunc->xFinalize!=0 ); assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); @@ -76668,6 +77822,7 @@ static SQLITE_NOINLINE i64 memIntValue(Mem *pMem){ } SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){ int flags; + assert( pMem!=0 ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); assert( EIGHT_BYTE_ALIGNMENT(pMem) ); flags = pMem->flags; @@ -76696,6 +77851,7 @@ static SQLITE_NOINLINE double memRealValue(Mem *pMem){ return val; } SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){ + assert( pMem!=0 ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); assert( EIGHT_BYTE_ALIGNMENT(pMem) ); if( pMem->flags & MEM_Real ){ @@ -76728,6 +77884,7 @@ SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem *pMem, int ifNull){ */ SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){ i64 ix; + assert( pMem!=0 ); assert( pMem->flags & MEM_Real ); assert( !sqlite3VdbeMemIsRowSet(pMem) ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); @@ -76755,6 +77912,7 @@ SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){ ** Convert pMem to type integer. Invalidate any prior representations. */ SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){ + assert( pMem!=0 ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); assert( !sqlite3VdbeMemIsRowSet(pMem) ); assert( EIGHT_BYTE_ALIGNMENT(pMem) ); @@ -76769,6 +77927,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){ ** Invalidate any prior representations. */ SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){ + assert( pMem!=0 ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); assert( EIGHT_BYTE_ALIGNMENT(pMem) ); @@ -76802,6 +77961,7 @@ SQLITE_PRIVATE int sqlite3RealSameAsInt(double r1, sqlite3_int64 i){ ** as much of the string as we can and ignore the rest. */ SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){ + assert( pMem!=0 ); testcase( pMem->flags & MEM_Int ); testcase( pMem->flags & MEM_Real ); testcase( pMem->flags & MEM_IntReal ); @@ -76911,6 +78071,7 @@ SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value *p){ ** Delete any previous value and set the value to be a BLOB of length ** n containing all zeros. */ +#ifndef SQLITE_OMIT_INCRBLOB SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){ sqlite3VdbeMemRelease(pMem); pMem->flags = MEM_Blob|MEM_Zero; @@ -76920,6 +78081,21 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){ pMem->enc = SQLITE_UTF8; pMem->z = 0; } +#else +SQLITE_PRIVATE int sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){ + int nByte = n>0?n:1; + if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){ + return SQLITE_NOMEM_BKPT; + } + assert( pMem->z!=0 ); + assert( sqlite3DbMallocSize(pMem->db, pMem->z)>=nByte ); + memset(pMem->z, 0, nByte); + pMem->n = n>0?n:0; + pMem->flags = MEM_Blob; + pMem->enc = SQLITE_UTF8; + return SQLITE_OK; +} +#endif /* ** The pMem is known to contain content that needs to be destroyed prior @@ -77145,14 +78321,15 @@ SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){ SQLITE_PRIVATE int sqlite3VdbeMemSetStr( Mem *pMem, /* Memory cell to set to string value */ const char *z, /* String pointer */ - int n, /* Bytes in string, or negative */ + i64 n, /* Bytes in string, or negative */ u8 enc, /* Encoding of z. 0 for BLOBs */ void (*xDel)(void*) /* Destructor function */ ){ - int nByte = n; /* New value for pMem->n */ + i64 nByte = n; /* New value for pMem->n */ int iLimit; /* Maximum allowed string or blob size */ u16 flags = 0; /* New value for pMem->flags */ + assert( pMem!=0 ); assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); assert( !sqlite3VdbeMemIsRowSet(pMem) ); @@ -77171,7 +78348,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr( if( nByte<0 ){ assert( enc!=0 ); if( enc==SQLITE_UTF8 ){ - nByte = 0x7fffffff & (int)strlen(z); + nByte = strlen(z); }else{ for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){} } @@ -77183,7 +78360,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr( ** management (one of MEM_Dyn or MEM_Static). */ if( xDel==SQLITE_TRANSIENT ){ - u32 nAlloc = nByte; + i64 nAlloc = nByte; if( flags&MEM_Term ){ nAlloc += (enc==SQLITE_UTF8?1:2); } @@ -77209,7 +78386,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr( } } - pMem->n = nByte; + pMem->n = (int)(nByte & 0x7fffffff); pMem->flags = flags; if( enc ){ pMem->enc = enc; @@ -77229,7 +78406,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr( #endif if( nByte>iLimit ){ - return SQLITE_TOOBIG; + return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG); } return SQLITE_OK; @@ -77461,7 +78638,7 @@ static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){ #ifdef SQLITE_ENABLE_STAT4 static int valueFromFunction( sqlite3 *db, /* The database connection */ - Expr *p, /* The expression to evaluate */ + const Expr *p, /* The expression to evaluate */ u8 enc, /* Encoding to use */ u8 aff, /* Affinity to use */ sqlite3_value **ppVal, /* Write the new value here */ @@ -77478,8 +78655,10 @@ static int valueFromFunction( assert( pCtx!=0 ); assert( (p->flags & EP_TokenOnly)==0 ); + assert( ExprUseXList(p) ); pList = p->x.pList; if( pList ) nVal = pList->nExpr; + assert( !ExprHasProperty(p, EP_IntValue) ); pFunc = sqlite3FindFunction(db, p->u.zToken, nVal, enc, 0); assert( pFunc ); if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0 @@ -77555,7 +78734,7 @@ static int valueFromFunction( */ static int valueFromExpr( sqlite3 *db, /* The database connection */ - Expr *pExpr, /* The expression to evaluate */ + const Expr *pExpr, /* The expression to evaluate */ u8 enc, /* Encoding to use */ u8 affinity, /* Affinity to use */ sqlite3_value **ppVal, /* Write the new value here */ @@ -77583,7 +78762,9 @@ static int valueFromExpr( assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 ); if( op==TK_CAST ){ - u8 aff = sqlite3AffinityType(pExpr->u.zToken,0); + u8 aff; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + aff = sqlite3AffinityType(pExpr->u.zToken,0); rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx); testcase( rc!=SQLITE_OK ); if( *ppVal ){ @@ -77656,6 +78837,7 @@ static int valueFromExpr( #ifndef SQLITE_OMIT_BLOB_LITERAL else if( op==TK_BLOB ){ int nVal; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' ); assert( pExpr->u.zToken[1]=='\'' ); pVal = valueNew(db, pCtx); @@ -77673,6 +78855,7 @@ static int valueFromExpr( } #endif else if( op==TK_TRUEFALSE ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); pVal = valueNew(db, pCtx); if( pVal ){ pVal->flags = MEM_Int; @@ -77710,7 +78893,7 @@ static int valueFromExpr( */ SQLITE_PRIVATE int sqlite3ValueFromExpr( sqlite3 *db, /* The database connection */ - Expr *pExpr, /* The expression to evaluate */ + const Expr *pExpr, /* The expression to evaluate */ u8 enc, /* Encoding to use */ u8 affinity, /* Affinity to use */ sqlite3_value **ppVal /* Write the new value here */ @@ -78020,7 +79203,7 @@ SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){ p->pNext = db->pVdbe; p->pPrev = 0; db->pVdbe = p; - p->magic = VDBE_MAGIC_INIT; + p->iVdbeMagic = VDBE_MAGIC_INIT; p->pParse = pParse; pParse->pVdbe = p; assert( pParse->aLabel==0 ); @@ -78221,13 +79404,15 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){ VdbeOp *pOp; i = p->nOp; - assert( p->magic==VDBE_MAGIC_INIT ); + assert( p->iVdbeMagic==VDBE_MAGIC_INIT ); assert( op>=0 && op<0xff ); if( p->nOpAlloc<=i ){ return growOp3(p, op, p1, p2, p3); } + assert( p->aOp!=0 ); p->nOp++; pOp = &p->aOp[i]; + assert( pOp!=0 ); pOp->opcode = (u8)op; pOp->p5 = 0; pOp->p1 = p1; @@ -78456,9 +79641,10 @@ SQLITE_PRIVATE void sqlite3VdbeExplainPop(Parse *pParse){ ** The zWhere string must have been obtained from sqlite3_malloc(). ** This routine will take ownership of the allocated memory. */ -SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){ +SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){ int j; sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC); + sqlite3VdbeChangeP5(p, p5); for(j=0; jdb->nDb; j++) sqlite3VdbeUsesBtree(p, j); sqlite3MayAbort(p->pParse); } @@ -78550,7 +79736,7 @@ static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){ SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *v, int x){ Parse *p = v->pParse; int j = ADDR(x); - assert( v->magic==VDBE_MAGIC_INIT ); + assert( v->iVdbeMagic==VDBE_MAGIC_INIT ); assert( j<-p->nLabel ); assert( j>=0 ); #ifdef SQLITE_DEBUG @@ -78875,7 +80061,7 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){ ** Return the address of the next instruction to be inserted. */ SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){ - assert( p->magic==VDBE_MAGIC_INIT ); + assert( p->iVdbeMagic==VDBE_MAGIC_INIT ); return p->nOp; } @@ -78960,7 +80146,7 @@ SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList( int i; VdbeOp *pOut, *pFirst; assert( nOp>0 ); - assert( p->magic==VDBE_MAGIC_INIT ); + assert( p->iVdbeMagic==VDBE_MAGIC_INIT ); if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){ return 0; } @@ -79284,7 +80470,7 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int sqlite3 *db; assert( p!=0 ); db = p->db; - assert( p->magic==VDBE_MAGIC_INIT ); + assert( p->iVdbeMagic==VDBE_MAGIC_INIT ); assert( p->aOp!=0 || db->mallocFailed ); if( db->mallocFailed ){ if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4); @@ -79413,7 +80599,7 @@ SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ /* C89 specifies that the constant "dummy" will be initialized to all ** zeros, which is correct. MSVC generates a warning, nevertheless. */ static VdbeOp dummy; /* Ignore the MSVC warning about no initializer */ - assert( p->magic==VDBE_MAGIC_INIT ); + assert( p->iVdbeMagic==VDBE_MAGIC_INIT ); if( addr<0 ){ addr = p->nOp - 1; } @@ -79469,13 +80655,9 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayComment( if( zOpName[nOpName+1] ){ int seenCom = 0; char c; - zSynopsis = zOpName += nOpName + 1; + zSynopsis = zOpName + nOpName + 1; if( strncmp(zSynopsis,"IF ",3)==0 ){ - if( pOp->p5 & SQLITE_STOREP2 ){ - sqlite3_snprintf(sizeof(zAlt), zAlt, "r[P2] = (%s)", zSynopsis+3); - }else{ - sqlite3_snprintf(sizeof(zAlt), zAlt, "if %s goto P2", zSynopsis+3); - } + sqlite3_snprintf(sizeof(zAlt), zAlt, "if %s goto P2", zSynopsis+3); zSynopsis = zAlt; } for(ii=0; (c = zSynopsis[ii])!=0; ii++){ @@ -79546,6 +80728,7 @@ static void displayP4Expr(StrAccum *p, Expr *pExpr){ const char *zOp = 0; switch( pExpr->op ){ case TK_STRING: + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3_str_appendf(p, "%Q", pExpr->u.zToken); break; case TK_INTEGER: @@ -79648,7 +80831,7 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){ case P4_COLLSEQ: { static const char *const encnames[] = {"?", "8", "16LE", "16BE"}; CollSeq *pColl = pOp->p4.pColl; - assert( pColl->enc>=0 && pColl->enc<4 ); + assert( pColl->enc<4 ); sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName, encnames[pColl->enc]); break; @@ -79892,8 +81075,8 @@ static void releaseMemArray(Mem *p, int N){ */ testcase( p->flags & MEM_Agg ); testcase( p->flags & MEM_Dyn ); - testcase( p->xDel==sqlite3VdbeFrameMemDel ); if( p->flags&(MEM_Agg|MEM_Dyn) ){ + testcase( (p->flags & MEM_Dyn)!=0 && p->xDel==sqlite3VdbeFrameMemDel ); sqlite3VdbeMemRelease(p); }else if( p->szMalloc ){ sqlite3DbFreeNN(db, p->zMalloc); @@ -80098,7 +81281,7 @@ SQLITE_PRIVATE int sqlite3VdbeList( Op *pOp; /* Current opcode */ assert( p->explain ); - assert( p->magic==VDBE_MAGIC_RUN ); + assert( p->iVdbeMagic==VDBE_MAGIC_RUN ); assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM ); /* Even though this opcode does not use dynamic strings for @@ -80278,14 +81461,14 @@ SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){ int i; #endif assert( p!=0 ); - assert( p->magic==VDBE_MAGIC_INIT || p->magic==VDBE_MAGIC_RESET ); + assert( p->iVdbeMagic==VDBE_MAGIC_INIT || p->iVdbeMagic==VDBE_MAGIC_RESET ); /* There should be at least one opcode. */ assert( p->nOp>0 ); /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */ - p->magic = VDBE_MAGIC_RUN; + p->iVdbeMagic = VDBE_MAGIC_RUN; #ifdef SQLITE_DEBUG for(i=0; inMem; i++){ @@ -80341,8 +81524,10 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady( assert( p!=0 ); assert( p->nOp>0 ); assert( pParse!=0 ); - assert( p->magic==VDBE_MAGIC_INIT ); + assert( p->iVdbeMagic==VDBE_MAGIC_INIT ); assert( pParse==p->pParse ); + p->pVList = pParse->pVList; + pParse->pVList = 0; db = p->db; assert( db->mallocFailed==0 ); nVar = pParse->nVar; @@ -80427,8 +81612,6 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady( } } - p->pVList = pParse->pVList; - pParse->pVList = 0; if( db->mallocFailed ){ p->nVar = 0; p->nCursor = 0; @@ -80456,20 +81639,15 @@ SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){ return; } assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE ); + assert( pCx->pBtx==0 || pCx->isEphemeral ); switch( pCx->eCurType ){ case CURTYPE_SORTER: { sqlite3VdbeSorterClose(p->db, pCx); break; } case CURTYPE_BTREE: { - if( pCx->isEphemeral ){ - if( pCx->pBtx ) sqlite3BtreeClose(pCx->pBtx); - /* The pCx->pCursor will be close automatically, if it exists, by - ** the call above. */ - }else{ - assert( pCx->uc.pCursor!=0 ); - sqlite3BtreeCloseCursor(pCx->uc.pCursor); - } + assert( pCx->uc.pCursor!=0 ); + sqlite3BtreeCloseCursor(pCx->uc.pCursor); break; } #ifndef SQLITE_OMIT_VIRTUALTABLE @@ -80998,9 +82176,9 @@ SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){ ** has made changes and is in autocommit mode, then commit those ** changes. If a rollback is needed, then do the rollback. ** -** This routine is the only way to move the state of a VM from -** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to -** call this on a VM that is in the SQLITE_MAGIC_HALT state. +** This routine is the only way to move the sqlite3eOpenState of a VM from +** SQLITE_STATE_RUN to SQLITE_STATE_HALT. It is harmless to +** call this on a VM that is in the SQLITE_STATE_HALT state. ** ** Return an error code. If the commit could not complete because of ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it @@ -81026,7 +82204,7 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){ ** one, or the complete transaction if there is no statement transaction. */ - if( p->magic!=VDBE_MAGIC_RUN ){ + if( p->iVdbeMagic!=VDBE_MAGIC_RUN ){ return SQLITE_OK; } if( db->mallocFailed ){ @@ -81046,9 +82224,15 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){ sqlite3VdbeEnter(p); /* Check for one of the special errors */ - mrc = p->rc & 0xff; - isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR - || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL; + if( p->rc ){ + mrc = p->rc & 0xff; + isSpecialError = mrc==SQLITE_NOMEM + || mrc==SQLITE_IOERR + || mrc==SQLITE_INTERRUPT + || mrc==SQLITE_FULL; + }else{ + mrc = isSpecialError = 0; + } if( isSpecialError ){ /* If the query was read-only and the error code is SQLITE_INTERRUPT, ** no rollback is necessary. Otherwise, at least a savepoint @@ -81100,6 +82284,9 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){ return SQLITE_ERROR; } rc = SQLITE_CONSTRAINT_FOREIGNKEY; + }else if( db->flags & SQLITE_CorruptRdOnly ){ + rc = SQLITE_CORRUPT; + db->flags &= ~SQLITE_CorruptRdOnly; }else{ /* The auto-commit flag is true, the vdbe program was successful ** or hit an 'OR FAIL' constraint and there are no deferred foreign @@ -81184,7 +82371,7 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){ assert( db->nVdbeRead>=db->nVdbeWrite ); assert( db->nVdbeWrite>=0 ); } - p->magic = VDBE_MAGIC_HALT; + p->iVdbeMagic = VDBE_MAGIC_HALT; checkActiveVdbeCnt(db); if( db->mallocFailed ){ p->rc = SQLITE_NOMEM_BKPT; @@ -81357,7 +82544,7 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){ } } #endif - p->magic = VDBE_MAGIC_RESET; + p->iVdbeMagic = VDBE_MAGIC_RESET; return p->rc & db->errMask; } @@ -81367,7 +82554,7 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){ */ SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe *p){ int rc = SQLITE_OK; - if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){ + if( p->iVdbeMagic==VDBE_MAGIC_RUN || p->iVdbeMagic==VDBE_MAGIC_HALT ){ rc = sqlite3VdbeReset(p); assert( (rc & p->db->errMask)==rc ); } @@ -81428,7 +82615,7 @@ SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){ vdbeFreeOpArray(db, pSub->aOp, pSub->nOp); sqlite3DbFree(db, pSub); } - if( p->magic!=VDBE_MAGIC_INIT ){ + if( p->iVdbeMagic!=VDBE_MAGIC_INIT ){ releaseMemArray(p->aVar, p->nVar); sqlite3DbFree(db, p->pVList); sqlite3DbFree(db, p->pFree); @@ -81476,7 +82663,7 @@ SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){ if( p->pNext ){ p->pNext->pPrev = p->pPrev; } - p->magic = VDBE_MAGIC_DEAD; + p->iVdbeMagic = VDBE_MAGIC_DEAD; p->db = 0; sqlite3DbFreeNN(db, p); } @@ -81494,7 +82681,7 @@ SQLITE_PRIVATE int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor *p){ assert( p->deferredMoveto ); assert( p->isTable ); assert( p->eCurType==CURTYPE_BTREE ); - rc = sqlite3BtreeMovetoUnpacked(p->uc.pCursor, 0, p->movetoTarget, 0, &res); + rc = sqlite3BtreeTableMoveto(p->uc.pCursor, p->movetoTarget, 0, &res); if( rc ) return rc; if( res!=0 ) return SQLITE_CORRUPT_BKPT; #ifdef SQLITE_TEST @@ -81553,6 +82740,7 @@ SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor **pp, u32 *piCol){ assert( p->eCurType==CURTYPE_BTREE || p->eCurType==CURTYPE_PSEUDO ); if( p->deferredMoveto ){ u32 iMap; + assert( !p->isEphemeral ); if( p->aAltMap && (iMap = p->aAltMap[1+*piCol])>0 && !p->nullRow ){ *pp = p->pAltCursor; *piCol = iMap - 1; @@ -82277,7 +83465,7 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem ** number. Return negative, zero, or positive if the first (i64) is less than, ** equal to, or greater than the second (double). */ -static int sqlite3IntFloatCompare(i64 i, double r){ +SQLITE_PRIVATE int sqlite3IntFloatCompare(i64 i, double r){ if( sizeof(LONGDOUBLE_TYPE)>8 ){ LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i; testcase( xmutex) ); db->nChange = nChange; db->nTotalChange += nChange; @@ -83181,7 +84369,8 @@ SQLITE_PRIVATE void sqlite3VdbePreUpdateHook( const char *zDb, /* Database name */ Table *pTab, /* Modified table */ i64 iKey1, /* Initial key value */ - int iReg /* Register for new.* record */ + int iReg, /* Register for new.* record */ + int iBlobWrite ){ sqlite3 *db = v->db; i64 iKey2; @@ -83202,6 +84391,8 @@ SQLITE_PRIVATE void sqlite3VdbePreUpdateHook( } } + assert( pCsr!=0 ); + assert( pCsr->eCurType==CURTYPE_BTREE ); assert( pCsr->nField==pTab->nCol || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1) ); @@ -83217,6 +84408,7 @@ SQLITE_PRIVATE void sqlite3VdbePreUpdateHook( preupdate.iKey1 = iKey1; preupdate.iKey2 = iKey2; preupdate.pTab = pTab; + preupdate.iBlobWrite = iBlobWrite; db->pPreUpdate = &preupdate; db->xPreUpdateCallback(db->pPreUpdateArg, db, op, zDb, zTbl, iKey1, iKey2); @@ -83600,8 +84792,8 @@ SQLITE_API void sqlite3_value_free(sqlite3_value *pOld){ ** the function result. ** ** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the -** result as a string or blob but if the string or blob is too large, it -** then sets the error code to SQLITE_TOOBIG +** result as a string or blob. Appropriate errors are set if the string/blob +** is too big or if an OOM occurs. ** ** The invokeValueDestructor(P,X) routine invokes destructor function X() ** on value P is not going to be used and need to be destroyed. @@ -83613,8 +84805,16 @@ static void setResultStrOrError( u8 enc, /* Encoding of z. 0 for BLOBs */ void (*xDel)(void*) /* Destructor function */ ){ - if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){ - sqlite3_result_error_toobig(pCtx); + int rc = sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel); + if( rc ){ + if( rc==SQLITE_TOOBIG ){ + sqlite3_result_error_toobig(pCtx); + }else{ + /* The only errors possible from sqlite3VdbeMemSetStr are + ** SQLITE_TOOBIG and SQLITE_NOMEM */ + assert( rc==SQLITE_NOMEM ); + sqlite3_result_error_nomem(pCtx); + } } } static int invokeValueDestructor( @@ -83630,7 +84830,7 @@ static int invokeValueDestructor( }else{ xDel((void*)p); } - if( pCtx ) sqlite3_result_error_toobig(pCtx); + sqlite3_result_error_toobig(pCtx); return SQLITE_TOOBIG; } SQLITE_API void sqlite3_result_blob( @@ -83771,8 +84971,12 @@ SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){ if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){ return SQLITE_TOOBIG; } +#ifndef SQLITE_OMIT_INCRBLOB sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n); return SQLITE_OK; +#else + return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n); +#endif } SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){ pCtx->isError = errCode ? errCode : -1; @@ -83855,7 +85059,7 @@ static int sqlite3Step(Vdbe *p){ int rc; assert(p); - if( p->magic!=VDBE_MAGIC_RUN ){ + if( p->iVdbeMagic!=VDBE_MAGIC_RUN ){ /* We used to require that sqlite3_reset() be called before retrying ** sqlite3_step() after any error or after SQLITE_DONE. But beginning ** with version 3.7.0, we changed this so that sqlite3_reset() would @@ -84571,7 +85775,7 @@ static int vdbeUnbind(Vdbe *p, int i){ return SQLITE_MISUSE_BKPT; } sqlite3_mutex_enter(p->db->mutex); - if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){ + if( p->iVdbeMagic!=VDBE_MAGIC_RUN || p->pc>=0 ){ sqlite3Error(p->db, SQLITE_MISUSE); sqlite3_mutex_leave(p->db->mutex); sqlite3_log(SQLITE_MISUSE, @@ -84612,7 +85816,7 @@ static int bindText( sqlite3_stmt *pStmt, /* The statement to bind against */ int i, /* Index of the parameter to bind */ const void *zData, /* Pointer to the data to be bound */ - int nData, /* Number of bytes of data to be bound */ + i64 nData, /* Number of bytes of data to be bound */ void (*xDel)(void*), /* Destructor for the data */ u8 encoding /* Encoding for the data */ ){ @@ -84664,11 +85868,7 @@ SQLITE_API int sqlite3_bind_blob64( void (*xDel)(void*) ){ assert( xDel!=SQLITE_DYNAMIC ); - if( nData>0x7fffffff ){ - return invokeValueDestructor(zData, xDel, 0); - }else{ - return bindText(pStmt, i, zData, (int)nData, xDel, 0); - } + return bindText(pStmt, i, zData, nData, xDel, 0); } SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){ int rc; @@ -84738,12 +85938,8 @@ SQLITE_API int sqlite3_bind_text64( unsigned char enc ){ assert( xDel!=SQLITE_DYNAMIC ); - if( nData>0x7fffffff ){ - return invokeValueDestructor(zData, xDel, 0); - }else{ - if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; - return bindText(pStmt, i, zData, (int)nData, xDel, enc); - } + if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; + return bindText(pStmt, i, zData, nData, xDel, enc); } #ifndef SQLITE_OMIT_UTF16 SQLITE_API int sqlite3_bind_text16( @@ -84792,7 +85988,11 @@ SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){ Vdbe *p = (Vdbe *)pStmt; rc = vdbeUnbind(p, i); if( rc==SQLITE_OK ){ +#ifndef SQLITE_OMIT_INCRBLOB sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n); +#else + rc = sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n); +#endif sqlite3_mutex_leave(p->db->mutex); } return rc; @@ -84925,7 +86125,7 @@ SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){ */ SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){ Vdbe *v = (Vdbe*)pStmt; - return v!=0 && v->magic==VDBE_MAGIC_RUN && v->pc>=0; + return v!=0 && v->iVdbeMagic==VDBE_MAGIC_RUN && v->pc>=0; } /* @@ -85080,6 +86280,7 @@ SQLITE_API int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppVa u32 nRec; u8 *aRec; + assert( p->pCsr->eCurType==CURTYPE_BTREE ); nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor); aRec = sqlite3DbMallocRaw(db, nRec); if( !aRec ) goto preupdate_old_out; @@ -85143,6 +86344,17 @@ SQLITE_API int sqlite3_preupdate_depth(sqlite3 *db){ } #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** This function is designed to be called from within a pre-update callback +** only. +*/ +SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *db){ + PreUpdate *p = db->pPreUpdate; + return (p ? p->iBlobWrite : -1); +} +#endif + #ifdef SQLITE_ENABLE_PREUPDATE_HOOK /* ** This function is called from within a pre-update callback to retrieve @@ -85376,11 +86588,9 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql( #ifndef SQLITE_OMIT_UTF16 Mem utf8; /* Used to convert UTF16 into UTF8 for display */ #endif - char zBase[100]; /* Initial working space */ db = p->db; - sqlite3StrAccumInit(&out, 0, zBase, sizeof(zBase), - db->aLimit[SQLITE_LIMIT_LENGTH]); + sqlite3StrAccumInit(&out, 0, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); if( db->nVdbeExec>1 ){ while( *zRawSql ){ const char *zStart = zRawSql; @@ -85417,7 +86627,7 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql( assert( idx>0 ); } zRawSql += nToken; - nextIndex = idx + 1; + nextIndex = MAX(idx + 1, nextIndex); assert( idx>0 && idx<=p->nVar ); pVar = &p->aVar[idx-1]; if( pVar->flags & MEM_Null ){ @@ -85761,26 +86971,39 @@ static VdbeCursor *allocateCursor( assert( iCur>=0 && iCurnCursor ); if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/ - /* Before calling sqlite3VdbeFreeCursor(), ensure the isEphemeral flag - ** is clear. Otherwise, if this is an ephemeral cursor created by - ** OP_OpenDup, the cursor will not be closed and will still be part - ** of a BtShared.pCursor list. */ - if( p->apCsr[iCur]->pBtx==0 ) p->apCsr[iCur]->isEphemeral = 0; sqlite3VdbeFreeCursor(p, p->apCsr[iCur]); p->apCsr[iCur] = 0; } - if( SQLITE_OK==sqlite3VdbeMemClearAndResize(pMem, nByte) ){ - p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z; - memset(pCx, 0, offsetof(VdbeCursor,pAltCursor)); - pCx->eCurType = eCurType; - pCx->iDb = iDb; - pCx->nField = nField; - pCx->aOffset = &pCx->aType[nField]; - if( eCurType==CURTYPE_BTREE ){ - pCx->uc.pCursor = (BtCursor*) - &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField]; - sqlite3BtreeCursorZero(pCx->uc.pCursor); + + /* There used to be a call to sqlite3VdbeMemClearAndResize() to make sure + ** the pMem used to hold space for the cursor has enough storage available + ** in pMem->zMalloc. But for the special case of the aMem[] entries used + ** to hold cursors, it is faster to in-line the logic. */ + assert( pMem->flags==MEM_Undefined ); + assert( (pMem->flags & MEM_Dyn)==0 ); + assert( pMem->szMalloc==0 || pMem->z==pMem->zMalloc ); + if( pMem->szMallocszMalloc>0 ){ + sqlite3DbFreeNN(pMem->db, pMem->zMalloc); + } + pMem->z = pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, nByte); + if( pMem->zMalloc==0 ){ + pMem->szMalloc = 0; + return 0; } + pMem->szMalloc = nByte; + } + + p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->zMalloc; + memset(pCx, 0, offsetof(VdbeCursor,pAltCursor)); + pCx->eCurType = eCurType; + pCx->iDb = iDb; + pCx->nField = nField; + pCx->aOffset = &pCx->aType[nField]; + if( eCurType==CURTYPE_BTREE ){ + pCx->uc.pCursor = (BtCursor*) + &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField]; + sqlite3BtreeCursorZero(pCx->uc.pCursor); } return pCx; } @@ -85927,7 +87150,10 @@ static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){ sqlite3_int64 ix; assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ); assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ); - ExpandBlob(pMem); + if( ExpandBlob(pMem) ){ + pMem->u.i = 0; + return MEM_Int; + } rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc); if( rc<=0 ){ if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){ @@ -86065,6 +87291,11 @@ static void registerTrace(int iReg, Mem *p){ printf("\n"); sqlite3VdbeCheckMemInvariants(p); } +/**/ void sqlite3PrintMem(Mem *pMem){ + memTracePrint(pMem); + printf("\n"); + fflush(stdout); +} #endif #ifdef SQLITE_DEBUG @@ -86092,96 +87323,7 @@ SQLITE_PRIVATE void sqlite3VdbeRegisterDump(Vdbe *v){ ** hwtime.h contains inline assembler code for implementing ** high-performance timing routines. */ -/************** Include hwtime.h in the middle of vdbe.c *********************/ -/************** Begin file hwtime.h ******************************************/ -/* -** 2008 May 27 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -****************************************************************************** -** -** This file contains inline asm code for retrieving "high-performance" -** counters for x86 and x86_64 class CPUs. -*/ -#ifndef SQLITE_HWTIME_H -#define SQLITE_HWTIME_H - -/* -** The following routine only works on pentium-class (or newer) processors. -** It uses the RDTSC opcode to read the cycle count value out of the -** processor and returns that value. This can be used for high-res -** profiling. -*/ -#if !defined(__STRICT_ANSI__) && \ - (defined(__GNUC__) || defined(_MSC_VER)) && \ - (defined(i386) || defined(__i386__) || defined(_M_IX86)) - - #if defined(__GNUC__) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned int lo, hi; - __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); - return (sqlite_uint64)hi << 32 | lo; - } - - #elif defined(_MSC_VER) - - __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ - __asm { - rdtsc - ret ; return value at EDX:EAX - } - } - - #endif - -#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__)) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned long val; - __asm__ __volatile__ ("rdtsc" : "=A" (val)); - return val; - } - -#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__)) - - __inline__ sqlite_uint64 sqlite3Hwtime(void){ - unsigned long long retval; - unsigned long junk; - __asm__ __volatile__ ("\n\ - 1: mftbu %1\n\ - mftb %L0\n\ - mftbu %0\n\ - cmpw %0,%1\n\ - bne 1b" - : "=r" (retval), "=r" (junk)); - return retval; - } - -#else - - /* - ** asm() is needed for hardware timing support. Without asm(), - ** disable the sqlite3Hwtime() routine. - ** - ** sqlite3Hwtime() is only used for some obscure debugging - ** and analysis configurations, not in any deliverable, so this - ** should not be a great loss. - */ -SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } - -#endif - -#endif /* !defined(SQLITE_HWTIME_H) */ - -/************** End of hwtime.h **********************************************/ -/************** Continuing where we left off in vdbe.c ***********************/ +/* #include "hwtime.h" */ #endif @@ -86228,6 +87370,19 @@ static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){ } } +/* +** Return the symbolic name for the data type of a pMem +*/ +static const char *vdbeMemTypeName(Mem *pMem){ + static const char *azTypes[] = { + /* SQLITE_INTEGER */ "INT", + /* SQLITE_FLOAT */ "REAL", + /* SQLITE_TEXT */ "TEXT", + /* SQLITE_BLOB */ "BLOB", + /* SQLITE_NULL */ "NULL" + }; + return azTypes[sqlite3_value_type(pMem)-1]; +} /* ** Execute as much of a VDBE program as we can. @@ -86263,7 +87418,7 @@ SQLITE_PRIVATE int sqlite3VdbeExec( #endif /*** INSERT STACK UNION HERE ***/ - assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */ + assert( p->iVdbeMagic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */ sqlite3VdbeEnter(p); #ifndef SQLITE_OMIT_PROGRESS_CALLBACK if( db->xProgress ){ @@ -87023,6 +88178,26 @@ case OP_IntCopy: { /* out2 */ break; } +/* Opcode: ChngCntRow P1 P2 * * * +** Synopsis: output=r[P1] +** +** Output value in register P1 as the chance count for a DML statement, +** due to the "PRAGMA count_changes=ON" setting. Or, if there was a +** foreign key error in the statement, trigger the error now. +** +** This opcode is a variant of OP_ResultRow that checks the foreign key +** immediate constraint count and throws an error if the count is +** non-zero. The P2 opcode must be 1. +*/ +case OP_ChngCntRow: { + assert( pOp->p2==1 ); + if( (rc = sqlite3VdbeCheckFk(p,0))!=SQLITE_OK ){ + goto abort_due_to_error; + } + /* Fall through to the next case, OP_ResultRow */ + /* no break */ deliberate_fall_through +} + /* Opcode: ResultRow P1 P2 * * * ** Synopsis: output=r[P1@P2] ** @@ -87036,37 +88211,9 @@ case OP_ResultRow: { Mem *pMem; int i; assert( p->nResColumn==pOp->p2 ); - assert( pOp->p1>0 ); + assert( pOp->p1>0 || CORRUPT_DB ); assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 ); - /* If this statement has violated immediate foreign key constraints, do - ** not return the number of rows modified. And do not RELEASE the statement - ** transaction. It needs to be rolled back. */ - if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){ - assert( db->flags&SQLITE_CountRows ); - assert( p->usesStmtJournal ); - goto abort_due_to_error; - } - - /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then - ** DML statements invoke this opcode to return the number of rows - ** modified to the user. This is the only way that a VM that - ** opens a statement transaction may invoke this opcode. - ** - ** In case this is such a statement, close any statement transaction - ** opened by this VM before returning control to the user. This is to - ** ensure that statement-transactions are always nested, not overlapping. - ** If the open statement-transaction is not closed here, then the user - ** may step another VM that opens its own statement transaction. This - ** may lead to overlapping statement transactions. - ** - ** The statement transaction is never a top-level transaction. Hence - ** the RELEASE call below can never fail. - */ - assert( p->iStatement==0 || db->flags&SQLITE_CountRows ); - rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE); - assert( rc==SQLITE_OK ); - /* Invalidate all ephemeral cursor row caches */ p->cacheCtr = (p->cacheCtr + 2)|1; @@ -87506,8 +88653,7 @@ case OP_Cast: { /* in1 */ ** Synopsis: IF r[P3]==r[P1] ** ** Compare the values in register P1 and P3. If reg(P3)==reg(P1) then -** jump to address P2. Or if the SQLITE_STOREP2 flag is set in P5, then -** store the result of comparison in register P2. +** jump to address P2. ** ** The SQLITE_AFF_MASK portion of P5 must be an affinity character - ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made @@ -87533,9 +88679,8 @@ case OP_Cast: { /* in1 */ ** If neither operand is NULL the result is the same as it would be if ** the SQLITE_NULLEQ flag were omitted from P5. ** -** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the -** content of r[P2] is only changed if the new value is NULL or 0 (false). -** In other words, a prior r[P2] value will not be overwritten by 1 (true). +** This opcode saves the result of comparison for use by the new +** OP_Jump opcode. */ /* Opcode: Ne P1 P2 P3 P4 P5 ** Synopsis: IF r[P3]!=r[P1] @@ -87543,17 +88688,12 @@ case OP_Cast: { /* in1 */ ** This works just like the Eq opcode except that the jump is taken if ** the operands in registers P1 and P3 are not equal. See the Eq opcode for ** additional information. -** -** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the -** content of r[P2] is only changed if the new value is NULL or 1 (true). -** In other words, a prior r[P2] value will not be overwritten by 0 (false). */ /* Opcode: Lt P1 P2 P3 P4 P5 ** Synopsis: IF r[P3]p3]; flags1 = pIn1->flags; flags3 = pIn3->flags; + if( (flags1 & flags3 & MEM_Int)!=0 ){ + assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT || CORRUPT_DB ); + /* Common case of comparison of two integers */ + if( pIn3->u.i > pIn1->u.i ){ + iCompare = +1; + if( sqlite3aGTb[pOp->opcode] ){ + VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3); + goto jump_to_p2; + } + }else if( pIn3->u.i < pIn1->u.i ){ + iCompare = -1; + if( sqlite3aLTb[pOp->opcode] ){ + VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3); + goto jump_to_p2; + } + }else{ + iCompare = 0; + if( sqlite3aEQb[pOp->opcode] ){ + VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3); + goto jump_to_p2; + } + } + VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3); + break; + } if( (flags1 | flags3)&MEM_Null ){ /* One or both operands are NULL */ if( pOp->p5 & SQLITE_NULLEQ ){ @@ -87635,22 +88803,16 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ ** then the result is always NULL. ** The jump is taken if the SQLITE_JUMPIFNULL bit is set. */ - if( pOp->p5 & SQLITE_STOREP2 ){ - pOut = &aMem[pOp->p2]; - iCompare = 1; /* Operands are not equal */ - memAboutToChange(p, pOut); - MemSetTypeFlag(pOut, MEM_Null); - REGISTER_TRACE(pOp->p2, pOut); - }else{ - VdbeBranchTaken(2,3); - if( pOp->p5 & SQLITE_JUMPIFNULL ){ - goto jump_to_p2; - } + iCompare = 1; /* Operands are not equal */ + VdbeBranchTaken(2,3); + if( pOp->p5 & SQLITE_JUMPIFNULL ){ + goto jump_to_p2; } break; } }else{ - /* Neither operand is NULL. Do a comparison. */ + /* Neither operand is NULL and we couldn't do the special high-speed + ** integer comparison case. So do a general-case comparison. */ affinity = pOp->p5 & SQLITE_AFF_MASK; if( affinity>=SQLITE_AFF_NUMERIC ){ if( (flags1 | flags3)&MEM_Str ){ @@ -87663,14 +88825,6 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ applyNumericAffinity(pIn3,0); } } - /* Handle the common case of integer comparison here, as an - ** optimization, to avoid a call to sqlite3MemCompare() */ - if( (pIn1->flags & pIn3->flags & MEM_Int)!=0 ){ - if( pIn3->u.i > pIn1->u.i ){ res = +1; goto compare_op; } - if( pIn3->u.i < pIn1->u.i ){ res = -1; goto compare_op; } - res = 0; - goto compare_op; - } }else if( affinity==SQLITE_AFF_TEXT ){ if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){ testcase( pIn1->flags & MEM_Int ); @@ -87693,7 +88847,7 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 ); res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl); } -compare_op: + /* At this point, res is negative, zero, or positive if reg[P1] is ** less than, equal to, or greater than reg[P3], respectively. Compute ** the answer to this operator in res2, depending on what the comparison @@ -87702,16 +88856,14 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ ** order: NE, EQ, GT, LE, LT, GE */ assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 ); assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 ); - if( res<0 ){ /* ne, eq, gt, le, lt, ge */ - static const unsigned char aLTb[] = { 1, 0, 0, 1, 1, 0 }; - res2 = aLTb[pOp->opcode - OP_Ne]; + if( res<0 ){ + res2 = sqlite3aLTb[pOp->opcode]; }else if( res==0 ){ - static const unsigned char aEQb[] = { 0, 1, 0, 1, 0, 1 }; - res2 = aEQb[pOp->opcode - OP_Ne]; + res2 = sqlite3aEQb[pOp->opcode]; }else{ - static const unsigned char aGTb[] = { 1, 0, 1, 0, 0, 1 }; - res2 = aGTb[pOp->opcode - OP_Ne]; + res2 = sqlite3aGTb[pOp->opcode]; } + iCompare = res; /* Undo any changes made by applyAffinity() to the input registers. */ assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) ); @@ -87719,67 +88871,39 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); pIn1->flags = flags1; - if( pOp->p5 & SQLITE_STOREP2 ){ - pOut = &aMem[pOp->p2]; - iCompare = res; - if( (pOp->p5 & SQLITE_KEEPNULL)!=0 ){ - /* The KEEPNULL flag prevents OP_Eq from overwriting a NULL with 1 - ** and prevents OP_Ne from overwriting NULL with 0. This flag - ** is only used in contexts where either: - ** (1) op==OP_Eq && (r[P2]==NULL || r[P2]==0) - ** (2) op==OP_Ne && (r[P2]==NULL || r[P2]==1) - ** Therefore it is not necessary to check the content of r[P2] for - ** NULL. */ - assert( pOp->opcode==OP_Ne || pOp->opcode==OP_Eq ); - assert( res2==0 || res2==1 ); - testcase( res2==0 && pOp->opcode==OP_Eq ); - testcase( res2==1 && pOp->opcode==OP_Eq ); - testcase( res2==0 && pOp->opcode==OP_Ne ); - testcase( res2==1 && pOp->opcode==OP_Ne ); - if( (pOp->opcode==OP_Eq)==res2 ) break; - } - memAboutToChange(p, pOut); - MemSetTypeFlag(pOut, MEM_Int); - pOut->u.i = res2; - REGISTER_TRACE(pOp->p2, pOut); - }else{ - VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3); - if( res2 ){ - goto jump_to_p2; - } + VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3); + if( res2 ){ + goto jump_to_p2; } break; } -/* Opcode: ElseNotEq * P2 * * * +/* Opcode: ElseEq * P2 * * * ** ** This opcode must follow an OP_Lt or OP_Gt comparison operator. There ** can be zero or more OP_ReleaseReg opcodes intervening, but no other ** opcodes are allowed to occur between this instruction and the previous -** OP_Lt or OP_Gt. Furthermore, the prior OP_Lt or OP_Gt must have the -** SQLITE_STOREP2 bit set in the P5 field. +** OP_Lt or OP_Gt. ** ** If result of an OP_Eq comparison on the same two operands as the -** prior OP_Lt or OP_Gt would have been NULL or false (0), then then -** jump to P2. If the result of an OP_Eq comparison on the two previous -** operands would have been true (1), then fall through. +** prior OP_Lt or OP_Gt would have been true, then jump to P2. +** If the result of an OP_Eq comparison on the two previous +** operands would have been false or NULL, then fall through. */ -case OP_ElseNotEq: { /* same as TK_ESCAPE, jump */ +case OP_ElseEq: { /* same as TK_ESCAPE, jump */ #ifdef SQLITE_DEBUG /* Verify the preconditions of this opcode - that it follows an OP_Lt or - ** OP_Gt with the SQLITE_STOREP2 flag set, with zero or more intervening - ** OP_ReleaseReg opcodes */ + ** OP_Gt with zero or more intervening OP_ReleaseReg opcodes */ int iAddr; for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){ if( aOp[iAddr].opcode==OP_ReleaseReg ) continue; assert( aOp[iAddr].opcode==OP_Lt || aOp[iAddr].opcode==OP_Gt ); - assert( aOp[iAddr].p5 & SQLITE_STOREP2 ); break; } #endif /* SQLITE_DEBUG */ - VdbeBranchTaken(iCompare!=0, 2); - if( iCompare!=0 ) goto jump_to_p2; + VdbeBranchTaken(iCompare==0, 2); + if( iCompare==0 ) goto jump_to_p2; break; } @@ -88090,6 +89214,40 @@ case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */ break; } +/* Opcode: IsNullOrType P1 P2 P3 * * +** Synopsis: if typeof(r[P1]) IN (P3,5) goto P2 +** +** Jump to P2 if the value in register P1 is NULL or has a datatype P3. +** P3 is an integer which should be one of SQLITE_INTEGER, SQLITE_FLOAT, +** SQLITE_BLOB, SQLITE_NULL, or SQLITE_TEXT. +*/ +case OP_IsNullOrType: { /* jump, in1 */ + int doTheJump; + pIn1 = &aMem[pOp->p1]; + doTheJump = (pIn1->flags & MEM_Null)!=0 || sqlite3_value_type(pIn1)==pOp->p3; + VdbeBranchTaken( doTheJump, 2); + if( doTheJump ) goto jump_to_p2; + break; +} + +/* Opcode: ZeroOrNull P1 P2 P3 * * +** Synopsis: r[P2] = 0 OR NULL +** +** If all both registers P1 and P3 are NOT NULL, then store a zero in +** register P2. If either registers P1 or P3 are NULL then put +** a NULL in register P2. +*/ +case OP_ZeroOrNull: { /* in1, in2, out2, in3 */ + if( (aMem[pOp->p1].flags & MEM_Null)!=0 + || (aMem[pOp->p3].flags & MEM_Null)!=0 + ){ + sqlite3VdbeMemSetNull(aMem + pOp->p2); + }else{ + sqlite3VdbeMemSetInt64(aMem + pOp->p2, 0); + } + break; +} + /* Opcode: NotNull P1 P2 * * * ** Synopsis: if r[P1]!=NULL goto P2 ** @@ -88440,6 +89598,108 @@ case OP_Column: { } } +/* Opcode: TypeCheck P1 P2 P3 P4 * +** Synopsis: typecheck(r[P1@P2]) +** +** Apply affinities to the range of P2 registers beginning with P1. +** Take the affinities from the Table object in P4. If any value +** cannot be coerced into the correct type, then raise an error. +** +** This opcode is similar to OP_Affinity except that this opcode +** forces the register type to the Table column type. This is used +** to implement "strict affinity". +** +** GENERATED ALWAYS AS ... STATIC columns are only checked if P3 +** is zero. When P3 is non-zero, no type checking occurs for +** static generated columns. Virtual columns are computed at query time +** and so they are never checked. +** +** Preconditions: +** +**
      +**
    • P2 should be the number of non-virtual columns in the +** table of P4. +**
    • Table P4 should be a STRICT table. +**
    +** +** If any precondition is false, an assertion fault occurs. +*/ +case OP_TypeCheck: { + Table *pTab; + Column *aCol; + int i; + + assert( pOp->p4type==P4_TABLE ); + pTab = pOp->p4.pTab; + assert( pTab->tabFlags & TF_Strict ); + assert( pTab->nNVCol==pOp->p2 ); + aCol = pTab->aCol; + pIn1 = &aMem[pOp->p1]; + for(i=0; inCol; i++){ + if( aCol[i].colFlags & COLFLAG_GENERATED ){ + if( aCol[i].colFlags & COLFLAG_VIRTUAL ) continue; + if( pOp->p3 ){ pIn1++; continue; } + } + assert( pIn1 < &aMem[pOp->p1+pOp->p2] ); + applyAffinity(pIn1, aCol[i].affinity, encoding); + if( (pIn1->flags & MEM_Null)==0 ){ + switch( aCol[i].eCType ){ + case COLTYPE_BLOB: { + if( (pIn1->flags & MEM_Blob)==0 ) goto vdbe_type_error; + break; + } + case COLTYPE_INTEGER: + case COLTYPE_INT: { + if( (pIn1->flags & MEM_Int)==0 ) goto vdbe_type_error; + break; + } + case COLTYPE_TEXT: { + if( (pIn1->flags & MEM_Str)==0 ) goto vdbe_type_error; + break; + } + case COLTYPE_REAL: { + if( pIn1->flags & MEM_Int ){ + /* When applying REAL affinity, if the result is still an MEM_Int + ** that will fit in 6 bytes, then change the type to MEM_IntReal + ** so that we keep the high-resolution integer value but know that + ** the type really wants to be REAL. */ + testcase( pIn1->u.i==140737488355328LL ); + testcase( pIn1->u.i==140737488355327LL ); + testcase( pIn1->u.i==-140737488355328LL ); + testcase( pIn1->u.i==-140737488355329LL ); + if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL){ + pIn1->flags |= MEM_IntReal; + pIn1->flags &= ~MEM_Int; + }else{ + pIn1->u.r = (double)pIn1->u.i; + pIn1->flags |= MEM_Real; + pIn1->flags &= ~MEM_Int; + } + }else if( (pIn1->flags & MEM_Real)==0 ){ + goto vdbe_type_error; + } + break; + } + default: { + /* COLTYPE_ANY. Accept anything. */ + break; + } + } + } + REGISTER_TRACE((int)(pIn1-aMem), pIn1); + pIn1++; + } + assert( pIn1 == &aMem[pOp->p1+pOp->p2] ); + break; + +vdbe_type_error: + sqlite3VdbeError(p, "cannot store %s value in %s column %s.%s", + vdbeMemTypeName(pIn1), sqlite3StdType[aCol[i].eCType-1], + pTab->zName, aCol[i].zCnName); + rc = SQLITE_CONSTRAINT_DATATYPE; + goto abort_due_to_error; +} + /* Opcode: Affinity P1 P2 * P4 * ** Synopsis: affinity(r[P1@P2]) ** @@ -89103,8 +90363,16 @@ case OP_Transaction: { assert( pOp->p2>=0 && pOp->p2<=2 ); assert( pOp->p1>=0 && pOp->p1nDb ); assert( DbMaskTest(p->btreeMask, pOp->p1) ); - if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){ - rc = SQLITE_READONLY; + assert( rc==SQLITE_OK ); + if( pOp->p2 && (db->flags & (SQLITE_QueryOnly|SQLITE_CorruptRdOnly))!=0 ){ + if( db->flags & SQLITE_QueryOnly ){ + /* Writes prohibited by the "PRAGMA query_only=TRUE" statement */ + rc = SQLITE_READONLY; + }else{ + /* Writes prohibited due to a prior SQLITE_CORRUPT in the current + ** transaction */ + rc = SQLITE_CORRUPT; + } goto abort_due_to_error; } pBt = db->aDb[pOp->p1].pBt; @@ -89146,7 +90414,8 @@ case OP_Transaction: { } } assert( pOp->p5==0 || pOp->p4type==P4_INT32 ); - if( pOp->p5 + if( rc==SQLITE_OK + && pOp->p5 && (iMeta!=pOp->p3 || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i) ){ @@ -89356,6 +90625,8 @@ case OP_ReopenIdx: { pCur = p->apCsr[pOp->p1]; if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){ assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */ + assert( pCur->eCurType==CURTYPE_BTREE ); + sqlite3BtreeClearCursor(pCur->uc.pCursor); goto open_cursor_set_hints; } /* If the cursor is not currently open or is open on a different @@ -89459,7 +90730,7 @@ case OP_OpenDup: { pOrig = p->apCsr[pOp->p2]; assert( pOrig ); - assert( pOrig->pBtx!=0 ); /* Only ephemeral cursors can be duplicated */ + assert( pOrig->isEphemeral ); /* Only ephemeral cursors can be duplicated */ pCx = allocateCursor(p, pOp->p1, pOrig->nField, -1, CURTYPE_BTREE); if( pCx==0 ) goto no_mem; @@ -89469,7 +90740,10 @@ case OP_OpenDup: { pCx->isTable = pOrig->isTable; pCx->pgnoRoot = pOrig->pgnoRoot; pCx->isOrdered = pOrig->isOrdered; - rc = sqlite3BtreeCursor(pOrig->pBtx, pCx->pgnoRoot, BTREE_WRCSR, + pCx->pBtx = pOrig->pBtx; + pCx->hasBeenDuped = 1; + pOrig->hasBeenDuped = 1; + rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR, pCx->pKeyInfo, pCx->uc.pCursor); /* The sqlite3BtreeCursor() routine can only fail for the first cursor ** opened for a database. Since there is already an open cursor when this @@ -89535,9 +90809,10 @@ case OP_OpenEphemeral: { aMem[pOp->p3].z = ""; } pCx = p->apCsr[pOp->p1]; - if( pCx && pCx->pBtx ){ - /* If the ephermeral table is already open, erase all existing content - ** so that the table is empty again, rather than creating a new table. */ + if( pCx && !pCx->hasBeenDuped && ALWAYS(pOp->p2<=pCx->nField) ){ + /* If the ephermeral table is already open and has no duplicates from + ** OP_OpenDup, then erase all existing content so that the table is + ** empty again, rather than creating a new table. */ assert( pCx->isEphemeral ); pCx->seqCount = 0; pCx->cacheStatus = CACHE_STALE; @@ -89551,33 +90826,36 @@ case OP_OpenEphemeral: { vfsFlags); if( rc==SQLITE_OK ){ rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1, 0); - } - if( rc==SQLITE_OK ){ - /* If a transient index is required, create it by calling - ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before - ** opening it. If a transient table is required, just use the - ** automatically created table with root-page 1 (an BLOB_INTKEY table). - */ - if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){ - assert( pOp->p4type==P4_KEYINFO ); - rc = sqlite3BtreeCreateTable(pCx->pBtx, &pCx->pgnoRoot, - BTREE_BLOBKEY | pOp->p5); - if( rc==SQLITE_OK ){ - assert( pCx->pgnoRoot==SCHEMA_ROOT+1 ); - assert( pKeyInfo->db==db ); - assert( pKeyInfo->enc==ENC(db) ); - rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR, - pKeyInfo, pCx->uc.pCursor); + if( rc==SQLITE_OK ){ + /* If a transient index is required, create it by calling + ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before + ** opening it. If a transient table is required, just use the + ** automatically created table with root-page 1 (an BLOB_INTKEY table). + */ + if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){ + assert( pOp->p4type==P4_KEYINFO ); + rc = sqlite3BtreeCreateTable(pCx->pBtx, &pCx->pgnoRoot, + BTREE_BLOBKEY | pOp->p5); + if( rc==SQLITE_OK ){ + assert( pCx->pgnoRoot==SCHEMA_ROOT+1 ); + assert( pKeyInfo->db==db ); + assert( pKeyInfo->enc==ENC(db) ); + rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR, + pKeyInfo, pCx->uc.pCursor); + } + pCx->isTable = 0; + }else{ + pCx->pgnoRoot = SCHEMA_ROOT; + rc = sqlite3BtreeCursor(pCx->pBtx, SCHEMA_ROOT, BTREE_WRCSR, + 0, pCx->uc.pCursor); + pCx->isTable = 1; } - pCx->isTable = 0; - }else{ - pCx->pgnoRoot = SCHEMA_ROOT; - rc = sqlite3BtreeCursor(pCx->pBtx, SCHEMA_ROOT, BTREE_WRCSR, - 0, pCx->uc.pCursor); - pCx->isTable = 1; + } + pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED); + if( rc ){ + sqlite3BtreeClose(pCx->pBtx); } } - pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED); } if( rc ) goto abort_due_to_error; pCx->nullRow = 1; @@ -89836,6 +91114,7 @@ case OP_SeekGT: { /* jump, in3, group */ /* If the P3 value could not be converted into an integer without ** loss of information, then special processing is required... */ if( (newType & (MEM_Int|MEM_IntReal))==0 ){ + int c; if( (newType & MEM_Real)==0 ){ if( (newType & MEM_Null) || oc>=OP_SeekGE ){ VdbeBranchTaken(1,2); @@ -89845,7 +91124,8 @@ case OP_SeekGT: { /* jump, in3, group */ if( rc!=SQLITE_OK ) goto abort_due_to_error; goto seek_not_found; } - }else + } + c = sqlite3IntFloatCompare(iKey, pIn3->u.r); /* If the approximation iKey is larger than the actual real search ** term, substitute >= for > and < for <=. e.g. if the search term @@ -89854,7 +91134,7 @@ case OP_SeekGT: { /* jump, in3, group */ ** (x > 4.9) -> (x >= 5) ** (x <= 4.9) -> (x < 5) */ - if( pIn3->u.r<(double)iKey ){ + if( c>0 ){ assert( OP_SeekGE==(OP_SeekGT-1) ); assert( OP_SeekLT==(OP_SeekLE-1) ); assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) ); @@ -89863,14 +91143,14 @@ case OP_SeekGT: { /* jump, in3, group */ /* If the approximation iKey is smaller than the actual real search ** term, substitute <= for < and > for >=. */ - else if( pIn3->u.r>(double)iKey ){ + else if( c<0 ){ assert( OP_SeekLE==(OP_SeekLT+1) ); assert( OP_SeekGT==(OP_SeekGE+1) ); assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) ); if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++; } } - rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res); + rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)iKey, 0, &res); pC->movetoTarget = iKey; /* Used by OP_Delete */ if( rc!=SQLITE_OK ){ goto abort_due_to_error; @@ -89917,7 +91197,7 @@ case OP_SeekGT: { /* jump, in3, group */ { int i; for(i=0; iuc.pCursor, &r, 0, 0, &res); + rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &res); if( rc!=SQLITE_OK ){ goto abort_due_to_error; } @@ -90011,13 +91291,13 @@ case OP_SeekGT: { /* jump, in3, group */ ** ** There are three possible outcomes from this opcode:
      ** -**
    1. If after This.P1 steps, the cursor is still point to a place that -** is earlier in the btree than the target row, -** then fall through into the subsquence OP_SeekGE opcode. +**
    2. If after This.P1 steps, the cursor is still pointing to a place that +** is earlier in the btree than the target row, then fall through +** into the subsquence OP_SeekGE opcode. ** **
    3. If the cursor is successfully moved to the target row by 0 or more ** sqlite3BtreeNext() calls, then jump to This.P2, which will land just -** past the OP_IdxGT opcode that follows the OP_SeekGE. +** past the OP_IdxGT or OP_IdxGE opcode that follows the OP_SeekGE. ** **
    4. If the cursor ends up past the target row (indicating the the target ** row does not exist in the btree) then jump to SeekOP.P2. @@ -90034,7 +91314,8 @@ case OP_SeekScan: { /* pOp->p2 points to the first instruction past the OP_IdxGT that ** follows the OP_SeekGE. */ assert( pOp->p2>=(int)(pOp-aOp)+2 ); - assert( aOp[pOp->p2-1].opcode==OP_IdxGT ); + assert( aOp[pOp->p2-1].opcode==OP_IdxGT || aOp[pOp->p2-1].opcode==OP_IdxGE ); + testcase( aOp[pOp->p2-1].opcode==OP_IdxGE ); assert( pOp[1].p1==aOp[pOp->p2-1].p1 ); assert( pOp[1].p2==aOp[pOp->p2-1].p2 ); assert( pOp[1].p3==aOp[pOp->p2-1].p3 ); @@ -90138,8 +91419,18 @@ case OP_SeekHit: { assert( pC!=0 ); assert( pOp->p3>=pOp->p2 ); if( pC->seekHitp2 ){ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p2); + } +#endif pC->seekHit = pOp->p2; }else if( pC->seekHit>pOp->p3 ){ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p3); + } +#endif pC->seekHit = pOp->p3; } break; @@ -90254,6 +91545,11 @@ case OP_IfNoHope: { /* jump, in3 */ assert( pOp->p1>=0 && pOp->p1nCursor ); pC = p->apCsr[pOp->p1]; assert( pC!=0 ); +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("seekHit is %d\n", pC->seekHit); + } +#endif if( pC->seekHit>=pOp->p4.i ) break; /* Fall through into OP_NotFound */ /* no break */ deliberate_fall_through @@ -90320,7 +91616,7 @@ case OP_Found: { /* jump, in3 */ } } } - rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res); + rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &res); if( pFree ) sqlite3DbFreeNN(db, pFree); if( rc!=SQLITE_OK ){ goto abort_due_to_error; @@ -90429,7 +91725,7 @@ case OP_NotExists: /* jump, in3 */ pCrsr = pC->uc.pCursor; assert( pCrsr!=0 ); res = 0; - rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res); + rc = sqlite3BtreeTableMoveto(pCrsr, iKey, 0, &res); assert( rc==SQLITE_OK || res==0 ); pC->movetoTarget = iKey; /* Used by OP_Delete */ pC->nullRow = 0; @@ -90487,8 +91783,10 @@ case OP_NewRowid: { /* out2 */ VdbeCursor *pC; /* Cursor of table to get the new rowid */ int res; /* Result of an sqlite3BtreeLast() */ int cnt; /* Counter to limit the number of searches */ +#ifndef SQLITE_OMIT_AUTOINCREMENT Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */ VdbeFrame *pFrame; /* Root frame of VDBE */ +#endif v = 0; res = 0; @@ -90584,7 +91882,7 @@ case OP_NewRowid: { /* out2 */ do{ sqlite3_randomness(sizeof(v), &v); v &= (MAX_ROWID>>1); v++; /* Ensure that v is greater than zero */ - }while( ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v, + }while( ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v, 0, &res))==SQLITE_OK) && (res==0) && (++cnt<100)); @@ -90674,14 +91972,14 @@ case OP_Insert: { assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) ); }else{ pTab = 0; - zDb = 0; /* Not needed. Silence a compiler warning. */ + zDb = 0; } #ifdef SQLITE_ENABLE_PREUPDATE_HOOK /* Invoke the pre-update hook, if any */ if( pTab ){ if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){ - sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2); + sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1); } if( db->xUpdateCallback==0 || pTab->aCol==0 ){ /* Prevent post-update hook from running in cases when it should not */ @@ -90704,7 +92002,8 @@ case OP_Insert: { } x.pKey = 0; rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, - (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), seekResult + (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)), + seekResult ); pC->deferredMoveto = 0; pC->cacheStatus = CACHE_STALE; @@ -90721,6 +92020,33 @@ case OP_Insert: { break; } +/* Opcode: RowCell P1 P2 P3 * * +** +** P1 and P2 are both open cursors. Both must be opened on the same type +** of table - intkey or index. This opcode is used as part of copying +** the current row from P2 into P1. If the cursors are opened on intkey +** tables, register P3 contains the rowid to use with the new record in +** P1. If they are opened on index tables, P3 is not used. +** +** This opcode must be followed by either an Insert or InsertIdx opcode +** with the OPFLAG_PREFORMAT flag set to complete the insert operation. +*/ +case OP_RowCell: { + VdbeCursor *pDest; /* Cursor to write to */ + VdbeCursor *pSrc; /* Cursor to read from */ + i64 iKey; /* Rowid value to insert with */ + assert( pOp[1].opcode==OP_Insert || pOp[1].opcode==OP_IdxInsert ); + assert( pOp[1].opcode==OP_Insert || pOp->p3==0 ); + assert( pOp[1].opcode==OP_IdxInsert || pOp->p3>0 ); + assert( pOp[1].p5 & OPFLAG_PREFORMAT ); + pDest = p->apCsr[pOp->p1]; + pSrc = p->apCsr[pOp->p2]; + iKey = pOp->p3 ? aMem[pOp->p3].u.i : 0; + rc = sqlite3BtreeTransferRow(pDest->uc.pCursor, pSrc->uc.pCursor, iKey); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + break; +}; + /* Opcode: Delete P1 P2 P3 P4 P5 ** ** Delete the record at which the P1 cursor is currently pointing. @@ -90799,13 +92125,14 @@ case OP_Delete: { pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor); } }else{ - zDb = 0; /* Not needed. Silence a compiler warning. */ - pTab = 0; /* Not needed. Silence a compiler warning. */ + zDb = 0; + pTab = 0; } #ifdef SQLITE_ENABLE_PREUPDATE_HOOK /* Invoke the pre-update-hook if required. */ - if( db->xPreUpdateCallback && pOp->p4.pTab ){ + assert( db->xPreUpdateCallback==0 || pTab==pOp->p4.pTab ); + if( db->xPreUpdateCallback && pTab ){ assert( !(opflags & OPFLAG_ISUPDATE) || HasRowid(pTab)==0 || (aMem[pOp->p3].flags & MEM_Int) @@ -90813,7 +92140,7 @@ case OP_Delete: { sqlite3VdbePreUpdateHook(p, pC, (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE, zDb, pTab, pC->movetoTarget, - pOp->p3 + pOp->p3, -1 ); } if( opflags & OPFLAG_ISNOOP ) break; @@ -90846,7 +92173,7 @@ case OP_Delete: { /* Invoke the update-hook if required. */ if( opflags & OPFLAG_NCHANGE ){ p->nChange++; - if( db->xUpdateCallback && HasRowid(pTab) ){ + if( db->xUpdateCallback && ALWAYS(pTab!=0) && HasRowid(pTab) ){ db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName, pC->movetoTarget); assert( pC->iDb>=0 ); @@ -91376,7 +92703,7 @@ case OP_IdxInsert: { /* in2 */ assert( pC!=0 ); assert( !isSorter(pC) ); pIn2 = &aMem[pOp->p2]; - assert( pIn2->flags & MEM_Blob ); + assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) ); if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; assert( pC->eCurType==CURTYPE_BTREE ); assert( pC->isTable==0 ); @@ -91387,7 +92714,7 @@ case OP_IdxInsert: { /* in2 */ x.aMem = aMem + pOp->p3; x.nMem = (u16)pOp->p4.i; rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, - (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), + (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)), ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0) ); assert( pC->deferredMoveto==0 ); @@ -91433,7 +92760,8 @@ case OP_SorterInsert: { /* in2 */ ** an UPDATE or DELETE statement and the index entry to be updated ** or deleted is not found. For some uses of IdxDelete ** (example: the EXCEPT operator) it does not matter that no matching -** entry is found. For those cases, P5 is zero. +** entry is found. For those cases, P5 is zero. Also, do not raise +** this (self-correcting and non-critical) error if in writable_schema mode. */ case OP_IdxDelete: { VdbeCursor *pC; @@ -91454,13 +92782,13 @@ case OP_IdxDelete: { r.nField = (u16)pOp->p3; r.default_rc = 0; r.aMem = &aMem[pOp->p2]; - rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res); + rc = sqlite3BtreeIndexMoveto(pCrsr, &r, &res); if( rc ) goto abort_due_to_error; if( res==0 ){ rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE); if( rc ) goto abort_due_to_error; - }else if( pOp->p5 ){ - rc = SQLITE_CORRUPT_INDEX; + }else if( pOp->p5 && !sqlite3WritableSchema(db) ){ + rc = sqlite3ReportError(SQLITE_CORRUPT_INDEX, __LINE__, "index corruption"); goto abort_due_to_error; } assert( pC->deferredMoveto==0 ); @@ -91539,6 +92867,8 @@ case OP_IdxRowid: { /* out2 */ pTabCur->deferredMoveto = 1; assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 ); pTabCur->aAltMap = pOp->p4.ai; + assert( !pC->isEphemeral ); + assert( !pTabCur->isEphemeral ); pTabCur->pAltCursor = pC; }else{ pOut = out2Prerelease(p, pOp); @@ -91757,24 +93087,21 @@ case OP_Destroy: { /* out2 */ ** P2==1 then the table to be clear is in the auxiliary database file ** that is used to store tables create using CREATE TEMPORARY TABLE. ** -** If the P3 value is non-zero, then the table referred to must be an -** intkey table (an SQL table, not an index). In this case the row change -** count is incremented by the number of rows in the table being cleared. -** If P3 is greater than zero, then the value stored in register P3 is -** also incremented by the number of rows in the table being cleared. +** If the P3 value is non-zero, then the row change count is incremented +** by the number of rows in the table being cleared. If P3 is greater +** than zero, then the value stored in register P3 is also incremented +** by the number of rows in the table being cleared. ** ** See also: Destroy */ case OP_Clear: { - int nChange; + i64 nChange; sqlite3VdbeIncrWriteCounter(p, 0); nChange = 0; assert( p->readOnly==0 ); assert( DbMaskTest(p->btreeMask, pOp->p2) ); - rc = sqlite3BtreeClearTable( - db->aDb[pOp->p2].pBt, (u32)pOp->p1, (pOp->p3 ? &nChange : 0) - ); + rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, (u32)pOp->p1, &nChange); if( pOp->p3 ){ p->nChange += nChange; if( pOp->p3>0 ){ @@ -91880,19 +93207,21 @@ case OP_ParseSchema: { iDb = pOp->p1; assert( iDb>=0 && iDbnDb ); - assert( DbHasProperty(db, iDb, DB_SchemaLoaded) ); + assert( DbHasProperty(db, iDb, DB_SchemaLoaded) + || db->mallocFailed + || (CORRUPT_DB && (db->flags & SQLITE_NoSchemaError)!=0) ); #ifndef SQLITE_OMIT_ALTERTABLE if( pOp->p4.z==0 ){ sqlite3SchemaClear(db->aDb[iDb].pSchema); db->mDbFlags &= ~DBFLAG_SchemaKnownOk; - rc = sqlite3InitOne(db, iDb, &p->zErrMsg, INITFLAG_AlterTable); + rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5); db->mDbFlags |= DBFLAG_SchemaChange; p->expired = 0; }else #endif { - zSchema = DFLT_SCHEMA_TABLE; + zSchema = LEGACY_SCHEMA_TABLE; initData.db = db; initData.iDb = iDb; initData.pzErrMsg = &p->zErrMsg; @@ -92762,6 +94091,7 @@ case OP_JournalMode: { /* out2 */ pPager = sqlite3BtreePager(pBt); eOld = sqlite3PagerGetJournalMode(pPager); if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld; + assert( sqlite3BtreeHoldsMutex(pBt) ); if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld; #ifndef SQLITE_OMIT_WAL @@ -93111,6 +94441,7 @@ case OP_VFilter: { /* jump */ pCur = p->apCsr[pOp->p1]; assert( memIsValid(pQuery) ); REGISTER_TRACE(pOp->p3, pQuery); + assert( pCur!=0 ); assert( pCur->eCurType==CURTYPE_VTAB ); pVCur = pCur->uc.pVCur; pVtab = pVCur->pVtab; @@ -93122,7 +94453,6 @@ case OP_VFilter: { /* jump */ iQuery = (int)pQuery->u.i; /* Invoke the xFilter method */ - res = 0; apArg = p->apArg; for(i = 0; iapCsr[pOp->p1]; + assert( pCur!=0 ); assert( pCur->eCurType==CURTYPE_VTAB ); assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); pDest = &aMem[pOp->p3]; @@ -93212,8 +94543,8 @@ case OP_VNext: { /* jump */ int res; VdbeCursor *pCur; - res = 0; pCur = p->apCsr[pOp->p1]; + assert( pCur!=0 ); assert( pCur->eCurType==CURTYPE_VTAB ); if( pCur->nullRow ){ break; @@ -93309,7 +94640,7 @@ case OP_VUpdate: { const sqlite3_module *pModule; int nArg; int i; - sqlite_int64 rowid; + sqlite_int64 rowid = 0; Mem **apArg; Mem *pX; @@ -93754,6 +95085,18 @@ default: { /* This is really OP_Noop, OP_Explain */ rc = SQLITE_CORRUPT_BKPT; } assert( rc ); +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeTrace ){ + const char *zTrace = p->zSql; + if( zTrace==0 ){ + if( aOp[0].opcode==OP_Trace ){ + zTrace = aOp[0].p4.z; + } + if( zTrace==0 ) zTrace = "???"; + } + printf("ABORT-due-to-error (rc=%d): %s\n", rc, zTrace); + } +#endif if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){ sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc)); } @@ -93764,6 +95107,9 @@ default: { /* This is really OP_Noop, OP_Explain */ (int)(pOp - aOp), p->zSql, p->zErrMsg); sqlite3VdbeHalt(p); if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db); + if( rc==SQLITE_CORRUPT && db->autoCommit==0 ){ + db->flags |= SQLITE_CorruptRdOnly; + } rc = SQLITE_ERROR; if( resetSchemaOnFault>0 ){ sqlite3ResetOneSchema(db, resetSchemaOnFault-1); @@ -93895,7 +95241,10 @@ static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){ } if( rc==SQLITE_ROW ){ VdbeCursor *pC = v->apCsr[0]; - u32 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0; + u32 type; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0; testcase( pC->nHdrParsed==p->iCol ); testcase( pC->nHdrParsed==p->iCol+1 ); if( type<12 ){ @@ -93987,7 +95336,7 @@ SQLITE_API int sqlite3_blob_open( sqlite3ErrorMsg(&sParse, "cannot open table without rowid: %s", zTable); } #ifndef SQLITE_OMIT_VIEW - if( pTab && pTab->pSelect ){ + if( pTab && IsView(pTab) ){ pTab = 0; sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable); } @@ -94007,7 +95356,7 @@ SQLITE_API int sqlite3_blob_open( /* Now search pTab for the exact column. */ for(iCol=0; iColnCol; iCol++) { - if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){ + if( sqlite3StrICmp(pTab->aCol[iCol].zCnName, zColumn)==0 ){ break; } } @@ -94032,7 +95381,8 @@ SQLITE_API int sqlite3_blob_open( ** key columns must be indexed. The check below will pick up this ** case. */ FKey *pFKey; - for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + assert( IsOrdinaryTable(pTab) ); + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ int j; for(j=0; jnCol; j++){ if( pFKey->aCol[j].iFrom==iCol ){ @@ -94239,8 +95589,10 @@ static int blobReadWrite( */ sqlite3_int64 iKey; iKey = sqlite3BtreeIntegerKey(p->pCsr); + assert( v->apCsr[0]!=0 ); + assert( v->apCsr[0]->eCurType==CURTYPE_BTREE ); sqlite3VdbePreUpdateHook( - v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1 + v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol ); } #endif @@ -94311,6 +95663,7 @@ SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){ rc = SQLITE_ABORT; }else{ char *zErr; + ((Vdbe*)p->pStmt)->rc = SQLITE_OK; rc = blobSeekToRow(p, iRow, &zErr); if( rc!=SQLITE_OK ){ sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr); @@ -95404,8 +96757,9 @@ static void vdbeSorterWorkDebug(SortSubtask *pTask, const char *zEvent){ fprintf(stderr, "%lld:%d %s\n", t, iTask, zEvent); } static void vdbeSorterRewindDebug(const char *zEvent){ - i64 t; - sqlite3OsCurrentTimeInt64(sqlite3_vfs_find(0), &t); + i64 t = 0; + sqlite3_vfs *pVfs = sqlite3_vfs_find(0); + if( ALWAYS(pVfs) ) sqlite3OsCurrentTimeInt64(pVfs, &t); fprintf(stderr, "%lld:X %s\n", t, zEvent); } static void vdbeSorterPopulateDebug( @@ -95619,7 +96973,7 @@ static void vdbeSorterExtendFile(sqlite3 *db, sqlite3_file *pFd, i64 nByte){ sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_CHUNK_SIZE, &chunksize); sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_SIZE_HINT, &nByte); sqlite3OsFetch(pFd, 0, (int)nByte, &p); - sqlite3OsUnfetch(pFd, 0, p); + if( p ) sqlite3OsUnfetch(pFd, 0, p); } } #else @@ -96337,6 +97691,7 @@ static int vdbeIncrMergerNew( vdbeMergeEngineFree(pMerger); rc = SQLITE_NOMEM_BKPT; } + assert( *ppOut!=0 || rc!=SQLITE_OK ); return rc; } @@ -97594,7 +98949,6 @@ struct MemJournal { int nChunkSize; /* In-memory chunk-size */ int nSpill; /* Bytes of data before flushing */ - int nSize; /* Bytes of data currently in memory */ FileChunk *pFirst; /* Head of in-memory chunk-list */ FilePoint endpoint; /* Pointer to the end of the file */ FilePoint readpoint; /* Pointer to the end of the last xRead() */ @@ -97655,14 +99009,13 @@ static int memjrnlRead( /* ** Free the list of FileChunk structures headed at MemJournal.pFirst. */ -static void memjrnlFreeChunks(MemJournal *p){ +static void memjrnlFreeChunks(FileChunk *pFirst){ FileChunk *pIter; FileChunk *pNext; - for(pIter=p->pFirst; pIter; pIter=pNext){ + for(pIter=pFirst; pIter; pIter=pNext){ pNext = pIter->pNext; sqlite3_free(pIter); } - p->pFirst = 0; } /* @@ -97689,7 +99042,7 @@ static int memjrnlCreateFile(MemJournal *p){ } if( rc==SQLITE_OK ){ /* No error has occurred. Free the in-memory buffers. */ - memjrnlFreeChunks(©); + memjrnlFreeChunks(copy.pFirst); } } if( rc!=SQLITE_OK ){ @@ -97772,7 +99125,6 @@ static int memjrnlWrite( nWrite -= iSpace; p->endpoint.iOffset += iSpace; } - p->nSize = iAmt + iOfst; } } @@ -97780,19 +99132,29 @@ static int memjrnlWrite( } /* -** Truncate the file. -** -** If the journal file is already on disk, truncate it there. Or, if it -** is still in main memory but is being truncated to zero bytes in size, -** ignore +** Truncate the in-memory file. */ static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ MemJournal *p = (MemJournal *)pJfd; - if( ALWAYS(size==0) ){ - memjrnlFreeChunks(p); - p->nSize = 0; - p->endpoint.pChunk = 0; - p->endpoint.iOffset = 0; + assert( p->endpoint.pChunk==0 || p->endpoint.pChunk->pNext==0 ); + if( sizeendpoint.iOffset ){ + FileChunk *pIter = 0; + if( size==0 ){ + memjrnlFreeChunks(p->pFirst); + p->pFirst = 0; + }else{ + i64 iOff = p->nChunkSize; + for(pIter=p->pFirst; ALWAYS(pIter) && iOff<=size; pIter=pIter->pNext){ + iOff += p->nChunkSize; + } + if( ALWAYS(pIter) ){ + memjrnlFreeChunks(pIter->pNext); + pIter->pNext = 0; + } + } + + p->endpoint.pChunk = pIter; + p->endpoint.iOffset = size; p->readpoint.pChunk = 0; p->readpoint.iOffset = 0; } @@ -97804,7 +99166,7 @@ static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ */ static int memjrnlClose(sqlite3_file *pJfd){ MemJournal *p = (MemJournal *)pJfd; - memjrnlFreeChunks(p); + memjrnlFreeChunks(p->pFirst); return SQLITE_OK; } @@ -97978,7 +99340,7 @@ SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *pVfs){ ** Walk all expressions linked into the list of Window objects passed ** as the second argument. */ -static int walkWindowList(Walker *pWalker, Window *pList){ +static int walkWindowList(Walker *pWalker, Window *pList, int bOneOnly){ Window *pWin; for(pWin=pList; pWin; pWin=pWin->pNextWin){ int rc; @@ -97988,15 +99350,11 @@ static int walkWindowList(Walker *pWalker, Window *pList){ if( rc ) return WRC_Abort; rc = sqlite3WalkExpr(pWalker, pWin->pFilter); if( rc ) return WRC_Abort; - - /* The next two are purely for calls to sqlite3RenameExprUnmap() - ** within sqlite3WindowOffsetExpr(). Because of constraints imposed - ** by sqlite3WindowOffsetExpr(), they can never fail. The results do - ** not matter anyhow. */ rc = sqlite3WalkExpr(pWalker, pWin->pStart); - if( NEVER(rc) ) return WRC_Abort; + if( rc ) return WRC_Abort; rc = sqlite3WalkExpr(pWalker, pWin->pEnd); - if( NEVER(rc) ) return WRC_Abort; + if( rc ) return WRC_Abort; + if( bOneOnly ) break; } return WRC_Continue; } @@ -98035,7 +99393,7 @@ static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){ assert( !ExprHasProperty(pExpr, EP_WinFunc) ); pExpr = pExpr->pRight; continue; - }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + }else if( ExprUseXSelect(pExpr) ){ assert( !ExprHasProperty(pExpr, EP_WinFunc) ); if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort; }else{ @@ -98044,7 +99402,7 @@ static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){ } #ifndef SQLITE_OMIT_WINDOWFUNC if( ExprHasProperty(pExpr, EP_WinFunc) ){ - if( walkWindowList(pWalker, pExpr->y.pWin) ) return WRC_Abort; + if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort; } #endif } @@ -98072,6 +99430,16 @@ SQLITE_PRIVATE int sqlite3WalkExprList(Walker *pWalker, ExprList *p){ return WRC_Continue; } +/* +** This is a no-op callback for Walker->xSelectCallback2. If this +** callback is set, then the Select->pWinDefn list is traversed. +*/ +SQLITE_PRIVATE void sqlite3WalkWinDefnDummyCallback(Walker *pWalker, Select *p){ + UNUSED_PARAMETER(pWalker); + UNUSED_PARAMETER(p); + /* No-op */ +} + /* ** Walk all expressions associated with SELECT statement p. Do ** not invoke the SELECT callback on p, but do (of course) invoke @@ -98085,13 +99453,18 @@ SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){ if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort; if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort; if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort; -#if !defined(SQLITE_OMIT_WINDOWFUNC) && !defined(SQLITE_OMIT_ALTERTABLE) - { - Parse *pParse = pWalker->pParse; - if( pParse && IN_RENAME_OBJECT ){ +#if !defined(SQLITE_OMIT_WINDOWFUNC) + if( p->pWinDefn ){ + Parse *pParse; + if( pWalker->xSelectCallback2==sqlite3WalkWinDefnDummyCallback + || ((pParse = pWalker->pParse)!=0 && IN_RENAME_OBJECT) +#ifndef SQLITE_OMIT_CTE + || pWalker->xSelectCallback2==sqlite3SelectPopWith +#endif + ){ /* The following may return WRC_Abort if there are unresolvable ** symbols (e.g. a table that does not exist) in a window definition. */ - int rc = walkWindowList(pWalker, p->pWinDefn); + int rc = walkWindowList(pWalker, p->pWinDefn, 0); return rc; } } @@ -98109,10 +99482,10 @@ SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){ SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){ SrcList *pSrc; int i; - struct SrcList_item *pItem; + SrcItem *pItem; pSrc = p->pSrc; - if( pSrc ){ + if( ALWAYS(pSrc) ){ for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ if( pItem->pSelect && sqlite3WalkSelect(pWalker, pItem->pSelect) ){ return WRC_Abort; @@ -98275,7 +99648,6 @@ static void resolveAlias( ExprList *pEList, /* A result set */ int iCol, /* A column in the result set. 0..pEList->nExpr-1 */ Expr *pExpr, /* Transform this into an alias to the result set */ - const char *zType, /* "GROUP" or "ORDER" or "" */ int nSubquery /* Number of subqueries that the label is moving */ ){ Expr *pOrig; /* The iCol-th column of the result set */ @@ -98287,9 +99659,13 @@ static void resolveAlias( assert( pOrig!=0 ); db = pParse->db; pDup = sqlite3ExprDup(db, pOrig, 0); - if( pDup!=0 ){ - if( zType[0]!='G' ) incrAggFunctionDepth(pDup, nSubquery); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDup); + pDup = 0; + }else{ + incrAggFunctionDepth(pDup, nSubquery); if( pExpr->op==TK_COLLATE ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken); } @@ -98309,15 +99685,12 @@ static void resolveAlias( pExpr->flags |= EP_MemToken; } if( ExprHasProperty(pExpr, EP_WinFunc) ){ - if( pExpr->y.pWin!=0 ){ + if( ALWAYS(pExpr->y.pWin!=0) ){ pExpr->y.pWin->pOwner = pExpr; - }else{ - assert( db->mallocFailed ); } } sqlite3DbFree(db, pDup); } - ExprSetProperty(pExpr, EP_Alias); } @@ -98396,6 +99769,7 @@ SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){ Table *pExTab; n = pExpr->iColumn; + assert( ExprUseYTab(pExpr) ); pExTab = pExpr->y.pTab; assert( pExTab!=0 ); if( (pExTab->tabFlags & TF_HasGenerated)!=0 @@ -98452,8 +99826,8 @@ static int lookupName( int cntTab = 0; /* Number of matching table names */ int nSubquery = 0; /* How many levels of subquery */ sqlite3 *db = pParse->db; /* The database connection */ - struct SrcList_item *pItem; /* Use for looping over pSrcList items */ - struct SrcList_item *pMatch = 0; /* The matching pSrcList item */ + SrcItem *pItem; /* Use for looping over pSrcList items */ + SrcItem *pMatch = 0; /* The matching pSrcList item */ NameContext *pTopNC = pNC; /* First namecontext in the list */ Schema *pSchema = 0; /* Schema of the expression */ int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */ @@ -98509,7 +99883,7 @@ static int lookupName( u8 hCol; pTab = pItem->pTab; assert( pTab!=0 && pTab->zName!=0 ); - assert( pTab->nCol>0 ); + assert( pTab->nCol>0 || pParse->nErr ); if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){ int hit = 0; pEList = pItem->pSelect->pEList; @@ -98533,16 +99907,16 @@ static int lookupName( if( sqlite3StrICmp(zTabName, zTab)!=0 ){ continue; } + assert( ExprUseYTab(pExpr) ); if( IN_RENAME_OBJECT && pItem->zAlias ){ sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab); } } - if( 0==(cntTab++) ){ - pMatch = pItem; - } hCol = sqlite3StrIHash(zCol); for(j=0, pCol=pTab->aCol; jnCol; j++, pCol++){ - if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){ + if( pCol->hName==hCol + && sqlite3StrICmp(pCol->zCnName, zCol)==0 + ){ /* If there has been exactly one prior match and this match ** is for the right-hand table of a NATURAL JOIN or is in a ** USING clause, then skip this match. @@ -98558,9 +99932,14 @@ static int lookupName( break; } } + if( 0==cnt && VisibleRowid(pTab) ){ + cntTab++; + pMatch = pItem; + } } if( pMatch ){ pExpr->iTable = pMatch->iCursor; + assert( ExprUseYTab(pExpr) ); pExpr->y.pTab = pMatch->pTab; /* RIGHT JOIN not (yet) supported */ assert( (pMatch->fg.jointype & JT_RIGHT)==0 ); @@ -98574,25 +99953,33 @@ static int lookupName( #if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) /* If we have not already resolved the name, then maybe ** it is a new.* or old.* trigger argument reference. Or - ** maybe it is an excluded.* from an upsert. + ** maybe it is an excluded.* from an upsert. Or maybe it is + ** a reference in the RETURNING clause to a table being modified. */ - if( zDb==0 && zTab!=0 && cntTab==0 ){ + if( cnt==0 && zDb==0 ){ pTab = 0; #ifndef SQLITE_OMIT_TRIGGER if( pParse->pTriggerTab!=0 ){ int op = pParse->eTriggerOp; assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT ); - if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){ + if( pParse->bReturning ){ + if( (pNC->ncFlags & NC_UBaseReg)!=0 + && (zTab==0 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0) + ){ + pExpr->iTable = op!=TK_DELETE; + pTab = pParse->pTriggerTab; + } + }else if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){ pExpr->iTable = 1; pTab = pParse->pTriggerTab; - }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){ + }else if( op!=TK_INSERT && zTab && sqlite3StrICmp("old",zTab)==0 ){ pExpr->iTable = 0; pTab = pParse->pTriggerTab; } } #endif /* SQLITE_OMIT_TRIGGER */ #ifndef SQLITE_OMIT_UPSERT - if( (pNC->ncFlags & NC_UUpsert)!=0 ){ + if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){ Upsert *pUpsert = pNC->uNC.pUpsert; if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){ pTab = pUpsert->pUpsertSrc->a[0].pTab; @@ -98607,7 +99994,9 @@ static int lookupName( pSchema = pTab->pSchema; cntTab++; for(iCol=0, pCol=pTab->aCol; iColnCol; iCol++, pCol++){ - if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){ + if( pCol->hName==hCol + && sqlite3StrICmp(pCol->zCnName, zCol)==0 + ){ if( iCol==pTab->iPKey ){ iCol = -1; } @@ -98620,9 +100009,11 @@ static int lookupName( } if( iColnCol ){ cnt++; + pMatch = 0; #ifndef SQLITE_OMIT_UPSERT if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){ testcase( iCol==(-1) ); + assert( ExprUseYTab(pExpr) ); if( IN_RENAME_OBJECT ){ pExpr->iColumn = iCol; pExpr->y.pTab = pTab; @@ -98631,27 +100022,33 @@ static int lookupName( pExpr->iTable = pNC->uNC.pUpsert->regData + sqlite3TableColumnToStorage(pTab, iCol); eNewExprOp = TK_REGISTER; - ExprSetProperty(pExpr, EP_Alias); } }else #endif /* SQLITE_OMIT_UPSERT */ { -#ifndef SQLITE_OMIT_TRIGGER - if( iCol<0 ){ - pExpr->affExpr = SQLITE_AFF_INTEGER; - }else if( pExpr->iTable==0 ){ - testcase( iCol==31 ); - testcase( iCol==32 ); - pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<y.pTab = pTab; - pExpr->iColumn = (i16)iCol; - eNewExprOp = TK_TRIGGER; + if( pParse->bReturning ){ + eNewExprOp = TK_REGISTER; + pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable + + sqlite3TableColumnToStorage(pTab, iCol) + 1; + }else{ + pExpr->iColumn = (i16)iCol; + eNewExprOp = TK_TRIGGER; +#ifndef SQLITE_OMIT_TRIGGER + if( iCol<0 ){ + pExpr->affExpr = SQLITE_AFF_INTEGER; + }else if( pExpr->iTable==0 ){ + testcase( iCol==31 ); + testcase( iCol==32 ); + pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<ncFlags & (NC_IdxExpr|NC_GenCol))==0 && sqlite3IsRowid(zCol) - && VisibleRowid(pMatch->pTab) + && ALWAYS(VisibleRowid(pMatch->pTab)) ){ cnt = 1; pExpr->iColumn = -1; @@ -98691,8 +100088,8 @@ static int lookupName( ** is supported for backwards compatibility only. Hence, we issue a warning ** on sqlite3_log() whenever the capability is used. */ - if( (pNC->ncFlags & NC_UEList)!=0 - && cnt==0 + if( cnt==0 + && (pNC->ncFlags & NC_UEList)!=0 && zTab==0 ){ pEList = pNC->uNC.pEList; @@ -98704,8 +100101,8 @@ static int lookupName( ){ Expr *pOrig; assert( pExpr->pLeft==0 && pExpr->pRight==0 ); - assert( pExpr->x.pList==0 ); - assert( pExpr->x.pSelect==0 ); + assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 ); + assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 ); pOrig = pEList->a[j].pExpr; if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){ sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs); @@ -98721,7 +100118,7 @@ static int lookupName( sqlite3ErrorMsg(pParse, "row value misused"); return WRC_Abort; } - resolveAlias(pParse, pEList, j, pExpr, "", nSubquery); + resolveAlias(pParse, pEList, j, pExpr, nSubquery); cnt = 1; pMatch = 0; assert( zTab==0 && zDb==0 ); @@ -98777,7 +100174,7 @@ static int lookupName( sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol); #endif pExpr->op = TK_STRING; - pExpr->y.pTab = 0; + memset(&pExpr->y, 0, sizeof(pExpr->y)); return WRC_Prune; } if( sqlite3ExprIdToTrueFalse(pExpr) ){ @@ -98800,7 +100197,7 @@ static int lookupName( sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol); } pParse->checkSchema = 1; - pTopNC->nErr++; + pTopNC->nNcErr++; } /* If a column from a table in pSrcList is referenced, then record @@ -98823,18 +100220,24 @@ static int lookupName( /* Clean up and return */ - sqlite3ExprDelete(db, pExpr->pLeft); - pExpr->pLeft = 0; - sqlite3ExprDelete(db, pExpr->pRight); - pExpr->pRight = 0; + if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){ + sqlite3ExprDelete(db, pExpr->pLeft); + pExpr->pLeft = 0; + sqlite3ExprDelete(db, pExpr->pRight); + pExpr->pRight = 0; + } pExpr->op = eNewExprOp; ExprSetProperty(pExpr, EP_Leaf); lookupname_end: if( cnt==1 ){ assert( pNC!=0 ); - if( !ExprHasProperty(pExpr, EP_Alias) ){ +#ifndef SQLITE_OMIT_AUTHORIZATION + if( pParse->db->xAuth + && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER) + ){ sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList); } +#endif /* Increment the nRef value on all name contexts from TopNC up to ** the point where the name matched. */ for(;;){ @@ -98856,8 +100259,10 @@ static int lookupName( SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){ Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0); if( p ){ - struct SrcList_item *pItem = &pSrc->a[iSrc]; - Table *pTab = p->y.pTab = pItem->pTab; + SrcItem *pItem = &pSrc->a[iSrc]; + Table *pTab; + assert( ExprUseYTab(p) ); + pTab = p->y.pTab = pItem->pTab; p->iTable = pItem->iCursor; if( p->y.pTab->iPKey==iCol ){ p->iColumn = -1; @@ -98924,6 +100329,7 @@ static void notValidImpl( static int exprProbability(Expr *p){ double r = -1.0; if( p->op!=TK_FLOAT ) return -1; + assert( !ExprHasProperty(p, EP_IntValue) ); sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8); assert( r>=0.0 ); if( r>1.0 ) return -1; @@ -98968,10 +100374,11 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ */ case TK_ROW: { SrcList *pSrcList = pNC->pSrcList; - struct SrcList_item *pItem; + SrcItem *pItem; assert( pSrcList && pSrcList->nSrc>=1 ); pItem = pSrcList->a; pExpr->op = TK_COLUMN; + assert( ExprUseYTab(pExpr) ); pExpr->y.pTab = pItem->pTab; pExpr->iTable = pItem->iCursor; pExpr->iColumn--; @@ -98979,6 +100386,49 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ break; } + /* An optimization: Attempt to convert + ** + ** "expr IS NOT NULL" --> "TRUE" + ** "expr IS NULL" --> "FALSE" + ** + ** if we can prove that "expr" is never NULL. Call this the + ** "NOT NULL strength reduction optimization". + ** + ** If this optimization occurs, also restore the NameContext ref-counts + ** to the state they where in before the "column" LHS expression was + ** resolved. This prevents "column" from being counted as having been + ** referenced, which might prevent a SELECT from being erroneously + ** marked as correlated. + */ + case TK_NOTNULL: + case TK_ISNULL: { + int anRef[8]; + NameContext *p; + int i; + for(i=0, p=pNC; p && ipNext, i++){ + anRef[i] = p->nRef; + } + sqlite3WalkExpr(pWalker, pExpr->pLeft); + if( 0==sqlite3ExprCanBeNull(pExpr->pLeft) && !IN_RENAME_OBJECT ){ + testcase( ExprHasProperty(pExpr, EP_FromJoin) ); + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + if( pExpr->op==TK_NOTNULL ){ + pExpr->u.zToken = "true"; + ExprSetProperty(pExpr, EP_IsTrue); + }else{ + pExpr->u.zToken = "false"; + ExprSetProperty(pExpr, EP_IsFalse); + } + pExpr->op = TK_TRUEFALSE; + for(i=0, p=pNC; p && ipNext, i++){ + p->nRef = anRef[i]; + } + sqlite3ExprDelete(pParse->db, pExpr->pLeft); + pExpr->pLeft = 0; + } + return WRC_Prune; + } + /* A column name: ID ** Or table name and column name: ID.ID ** Or a database, table and column: ID.ID.ID @@ -98997,6 +100447,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ if( pExpr->op==TK_ID ){ zDb = 0; zTable = 0; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); zColumn = pExpr->u.zToken; }else{ Expr *pLeft = pExpr->pLeft; @@ -99009,12 +100460,15 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ zDb = 0; }else{ assert( pRight->op==TK_DOT ); + assert( !ExprHasProperty(pRight, EP_IntValue) ); zDb = pLeft->u.zToken; pLeft = pRight->pLeft; pRight = pRight->pRight; } + assert( ExprUseUToken(pLeft) && ExprUseUToken(pRight) ); zTable = pLeft->u.zToken; zColumn = pRight->u.zToken; + assert( ExprUseYTab(pExpr) ); if( IN_RENAME_OBJECT ){ sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight); sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft); @@ -99039,7 +100493,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ #ifndef SQLITE_OMIT_WINDOWFUNC Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0); #endif - assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) ); zId = pExpr->u.zToken; nId = sqlite3Strlen30(zId); pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0); @@ -99060,7 +100514,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ sqlite3ErrorMsg(pParse, "second argument to likelihood() must be a " "constant between 0.0 and 1.0"); - pNC->nErr++; + pNC->nNcErr++; } }else{ /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is @@ -99082,7 +100536,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ if( auth==SQLITE_DENY ){ sqlite3ErrorMsg(pParse, "not authorized to use function: %s", pDef->zName); - pNC->nErr++; + pNC->nNcErr++; } pExpr->op = TK_NULL; return WRC_Prune; @@ -99138,7 +100592,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ sqlite3ErrorMsg(pParse, "%.*s() may not be used as a window function", nId, zId ); - pNC->nErr++; + pNC->nNcErr++; }else if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin) @@ -99151,13 +100605,13 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ zType = "aggregate"; } sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId); - pNC->nErr++; + pNC->nNcErr++; is_agg = 0; } #else if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){ sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId); - pNC->nErr++; + pNC->nNcErr++; is_agg = 0; } #endif @@ -99167,11 +100621,11 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ #endif ){ sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId); - pNC->nErr++; + pNC->nNcErr++; }else if( wrong_num_args ){ sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()", nId, zId); - pNC->nErr++; + pNC->nNcErr++; } #ifndef SQLITE_OMIT_WINDOWFUNC else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){ @@ -99179,7 +100633,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ "FILTER may not be used with non-aggregate %.*s()", nId, zId ); - pNC->nErr++; + pNC->nNcErr++; } #endif if( is_agg ){ @@ -99203,9 +100657,10 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ #ifndef SQLITE_OMIT_WINDOWFUNC if( pWin ){ Select *pSel = pNC->pWinSelect; - assert( pWin==pExpr->y.pWin ); + assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) ); if( IN_RENAME_OBJECT==0 ){ sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef); + if( pParse->db->mallocFailed ) break; } sqlite3WalkExprList(pWalker, pWin->pPartition); sqlite3WalkExprList(pWalker, pWin->pOrderBy); @@ -99215,7 +100670,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ }else #endif /* SQLITE_OMIT_WINDOWFUNC */ { - NameContext *pNC2 = pNC; + NameContext *pNC2; /* For looping up thru outer contexts */ pExpr->op = TK_AGG_FUNCTION; pExpr->op2 = 0; #ifndef SQLITE_OMIT_WINDOWFUNC @@ -99223,16 +100678,22 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter); } #endif - while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){ + pNC2 = pNC; + while( pNC2 + && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0 + ){ pExpr->op2++; pNC2 = pNC2->pNext; } assert( pDef!=0 || IN_RENAME_OBJECT ); if( pNC2 && pDef ){ assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg ); + assert( SQLITE_FUNC_ANYORDER==NC_OrderAgg ); testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 ); - pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX); - + testcase( (pDef->funcFlags & SQLITE_FUNC_ANYORDER)!=0 ); + pNC2->ncFlags |= NC_HasAgg + | ((pDef->funcFlags^SQLITE_FUNC_ANYORDER) + & (SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER)); } } pNC->ncFlags |= savedAllowFlags; @@ -99248,15 +100709,17 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ #endif case TK_IN: { testcase( pExpr->op==TK_IN ); - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( ExprUseXSelect(pExpr) ){ int nRef = pNC->nRef; testcase( pNC->ncFlags & NC_IsCheck ); testcase( pNC->ncFlags & NC_PartIdx ); testcase( pNC->ncFlags & NC_IdxExpr ); testcase( pNC->ncFlags & NC_GenCol ); - sqlite3ResolveNotValid(pParse, pNC, "subqueries", - NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr); - sqlite3WalkSelect(pWalker, pExpr->x.pSelect); + if( pNC->ncFlags & NC_SelfRef ){ + notValidImpl(pParse, pNC, "subqueries", pExpr); + }else{ + sqlite3WalkSelect(pWalker, pExpr->x.pSelect); + } assert( pNC->nRef>=nRef ); if( nRef!=pNC->nRef ){ ExprSetProperty(pExpr, EP_VarSelect); @@ -99280,7 +100743,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ assert( !ExprHasProperty(pExpr, EP_Reduced) ); /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE", ** and "x IS NOT FALSE". */ - if( pRight && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){ + if( ALWAYS(pRight) && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){ int rc = resolveExprStep(pWalker, pRight); if( rc==WRC_Abort ) return WRC_Abort; if( pRight->op==TK_TRUEFALSE ){ @@ -99303,6 +100766,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){ assert( pExpr->pLeft!=0 ); nLeft = sqlite3ExprVectorSize(pExpr->pLeft); if( pExpr->op==TK_BETWEEN ){ + assert( ExprUseXList(pExpr) ); nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr); if( nRight==nLeft ){ nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr); @@ -99351,7 +100815,9 @@ static int resolveAsName( UNUSED_PARAMETER(pParse); if( pE->op==TK_ID ){ - char *zCol = pE->u.zToken; + const char *zCol; + assert( !ExprHasProperty(pE, EP_IntValue) ); + zCol = pE->u.zToken; for(i=0; inExpr; i++){ if( pEList->a[i].eEName==ENAME_NAME && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0 @@ -99402,11 +100868,11 @@ static int resolveOrderByTermToExprList( nc.pParse = pParse; nc.pSrcList = pSelect->pSrc; nc.uNC.pEList = pEList; - nc.ncFlags = NC_AllowAgg|NC_UEList; - nc.nErr = 0; + nc.ncFlags = NC_AllowAgg|NC_UEList|NC_NoSelect; + nc.nNcErr = 0; db = pParse->db; savedSuppErr = db->suppressErr; - if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1; + db->suppressErr = 1; rc = sqlite3ResolveExprNames(&nc, pE); db->suppressErr = savedSuppErr; if( rc ) return 0; @@ -99505,29 +100971,24 @@ static int resolveCompoundOrderBy( ** Once the comparisons are finished, the duplicate expression ** is deleted. ** - ** Or, if this is running as part of an ALTER TABLE operation, - ** resolve the symbols in the actual expression, not a duplicate. - ** And, if one of the comparisons is successful, leave the expression - ** as is instead of transforming it to an integer as in the usual - ** case. This allows the code in alter.c to modify column - ** refererences within the ORDER BY expression as required. */ - if( IN_RENAME_OBJECT ){ - pDup = pE; - }else{ - pDup = sqlite3ExprDup(db, pE, 0); - } + ** If this is running as part of an ALTER TABLE operation and + ** the symbols resolve successfully, also resolve the symbols in the + ** actual expression. This allows the code in alter.c to modify + ** column references within the ORDER BY expression as required. */ + pDup = sqlite3ExprDup(db, pE, 0); if( !db->mallocFailed ){ assert(pDup); iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup); + if( IN_RENAME_OBJECT && iCol>0 ){ + resolveOrderByTermToExprList(pParse, pSelect, pE); + } } - if( !IN_RENAME_OBJECT ){ - sqlite3ExprDelete(db, pDup); - } + sqlite3ExprDelete(db, pDup); } } if( iCol>0 ){ /* Convert the ORDER BY term into an integer column number iCol, - ** taking care to preserve the COLLATE clause if it exists */ + ** taking care to preserve the COLLATE clause if it exists. */ if( !IN_RENAME_OBJECT ){ Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); if( pNew==0 ) return 1; @@ -99596,8 +101057,7 @@ SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy( resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr); return 1; } - resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr, - zType,0); + resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0); } } return 0; @@ -99663,7 +101123,7 @@ static int resolveOrderGroupBy( Parse *pParse; /* Parsing context */ int nResult; /* Number of terms in the result set */ - if( pOrderBy==0 ) return 0; + assert( pOrderBy!=0 ); nResult = pSelect->pEList->nExpr; pParse = pNC->pParse; for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ @@ -99753,8 +101213,10 @@ static int resolveSelectStep(Walker *pWalker, Select *p){ while( p ){ assert( (p->selFlags & SF_Expanded)!=0 ); assert( (p->selFlags & SF_Resolved)==0 ); + assert( db->suppressErr==0 ); /* SF_Resolved not set if errors suppressed */ p->selFlags |= SF_Resolved; + /* Resolve the expressions in the LIMIT and OFFSET clauses. These ** are not allowed to refer to any names, so pass an empty NameContext. */ @@ -99779,30 +101241,29 @@ static int resolveSelectStep(Walker *pWalker, Select *p){ p->pOrderBy = 0; } - /* Recursively resolve names in all subqueries + /* Recursively resolve names in all subqueries in the FROM clause */ for(i=0; ipSrc->nSrc; i++){ - struct SrcList_item *pItem = &p->pSrc->a[i]; + SrcItem *pItem = &p->pSrc->a[i]; if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){ - NameContext *pNC; /* Used to iterate name contexts */ - int nRef = 0; /* Refcount for pOuterNC and outer contexts */ + int nRef = pOuterNC ? pOuterNC->nRef : 0; const char *zSavedContext = pParse->zAuthContext; - /* Count the total number of references to pOuterNC and all of its - ** parent contexts. After resolving references to expressions in - ** pItem->pSelect, check if this value has changed. If so, then - ** SELECT statement pItem->pSelect must be correlated. Set the - ** pItem->fg.isCorrelated flag if this is the case. */ - for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef; - if( pItem->zName ) pParse->zAuthContext = pItem->zName; sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC); pParse->zAuthContext = zSavedContext; if( pParse->nErr || db->mallocFailed ) return WRC_Abort; - for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef; - assert( pItem->fg.isCorrelated==0 && nRef<=0 ); - pItem->fg.isCorrelated = (nRef!=0); + /* If the number of references to the outer context changed when + ** expressions in the sub-select were resolved, the sub-select + ** is correlated. It is not required to check the refcount on any + ** but the innermost outer context object, as lookupName() increments + ** the refcount on all contexts between the current one and the + ** context containing the column when it resolves a name. */ + if( pOuterNC ){ + assert( pItem->fg.isCorrelated==0 && pOuterNC->nRef>=nRef ); + pItem->fg.isCorrelated = (pOuterNC->nRef>nRef); + } } } @@ -99824,18 +101285,12 @@ static int resolveSelectStep(Walker *pWalker, Select *p){ pGroupBy = p->pGroupBy; if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){ assert( NC_MinMaxAgg==SF_MinMaxAgg ); - p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg); + assert( NC_OrderAgg==SF_OrderByReqd ); + p->selFlags |= SF_Aggregate | (sNC.ncFlags&(NC_MinMaxAgg|NC_OrderAgg)); }else{ sNC.ncFlags &= ~NC_AllowAgg; } - /* If a HAVING clause is present, then there must be a GROUP BY clause. - */ - if( p->pHaving && !pGroupBy ){ - sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); - return WRC_Abort; - } - /* Add the output column list to the name-context before parsing the ** other expressions in the SELECT statement. This is so that ** expressions in the WHERE clause (etc.) can refer to expressions by @@ -99844,15 +101299,21 @@ static int resolveSelectStep(Walker *pWalker, Select *p){ ** Minor point: If this is the case, then the expression will be ** re-evaluated for each reference to it. */ - assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert))==0 ); + assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert|NC_UBaseReg))==0 ); sNC.uNC.pEList = p->pEList; sNC.ncFlags |= NC_UEList; - if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; + if( p->pHaving ){ + if( !pGroupBy ){ + sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); + return WRC_Abort; + } + if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; + } if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort; /* Resolve names in table-valued-function arguments */ for(i=0; ipSrc->nSrc; i++){ - struct SrcList_item *pItem = &p->pSrc->a[i]; + SrcItem *pItem = &p->pSrc->a[i]; if( pItem->fg.isTabFunc && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg) ){ @@ -99860,6 +101321,19 @@ static int resolveSelectStep(Walker *pWalker, Select *p){ } } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( IN_RENAME_OBJECT ){ + Window *pWin; + for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){ + if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy) + || sqlite3ResolveExprListNames(&sNC, pWin->pPartition) + ){ + return WRC_Abort; + } + } + } +#endif + /* The ORDER BY and GROUP BY clauses may not refer to terms in ** outer queries */ @@ -99887,7 +101361,8 @@ static int resolveSelectStep(Walker *pWalker, Select *p){ ** is not detected until much later, and so we need to go ahead and ** resolve those symbols on the incorrect ORDER BY for consistency. */ - if( isCompound<=nCompound /* Defer right-most ORDER BY of a compound */ + if( p->pOrderBy!=0 + && isCompound<=nCompound /* Defer right-most ORDER BY of a compound */ && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER") ){ return WRC_Abort; @@ -99915,19 +101390,6 @@ static int resolveSelectStep(Walker *pWalker, Select *p){ } } -#ifndef SQLITE_OMIT_WINDOWFUNC - if( IN_RENAME_OBJECT ){ - Window *pWin; - for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){ - if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy) - || sqlite3ResolveExprListNames(&sNC, pWin->pPartition) - ){ - return WRC_Abort; - } - } - } -#endif - /* If this is part of a compound SELECT, check that it has the right ** number of expressions in the select list. */ if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){ @@ -100007,11 +101469,11 @@ SQLITE_PRIVATE int sqlite3ResolveExprNames( Walker w; if( pExpr==0 ) return SQLITE_OK; - savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin); - pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin); + savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); w.pParse = pNC->pParse; w.xExprCallback = resolveExprStep; - w.xSelectCallback = resolveSelectStep; + w.xSelectCallback = (pNC->ncFlags & NC_NoSelect) ? 0 : resolveSelectStep; w.xSelectCallback2 = 0; w.u.pNC = pNC; #if SQLITE_MAX_EXPR_DEPTH>0 @@ -100030,7 +101492,7 @@ SQLITE_PRIVATE int sqlite3ResolveExprNames( testcase( pNC->ncFlags & NC_HasWin ); ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) ); pNC->ncFlags |= savedHasAgg; - return pNC->nErr>0 || w.pParse->nErr>0; + return pNC->nNcErr>0 || w.pParse->nErr>0; } /* @@ -100051,8 +101513,8 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames( w.xSelectCallback = resolveSelectStep; w.xSelectCallback2 = 0; w.u.pNC = pNC; - savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin); - pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin); + savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); for(i=0; inExpr; i++){ Expr *pExpr = pList->a[i].pExpr; if( pExpr==0 ) continue; @@ -100070,12 +101532,13 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames( assert( EP_Win==NC_HasWin ); testcase( pNC->ncFlags & NC_HasAgg ); testcase( pNC->ncFlags & NC_HasWin ); - if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin) ){ + if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg) ){ ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) ); - savedHasAgg |= pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin); - pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin); + savedHasAgg |= pNC->ncFlags & + (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); } - if( pNC->nErr>0 || w.pParse->nErr>0 ) return WRC_Abort; + if( w.pParse->nErr>0 ) return WRC_Abort; } pNC->ncFlags |= savedHasAgg; return WRC_Continue; @@ -100187,9 +101650,9 @@ static int exprCodeVector(Parse *pParse, Expr *p, int *piToFree); /* ** Return the affinity character for a single column of a table. */ -SQLITE_PRIVATE char sqlite3TableColumnAffinity(Table *pTab, int iCol){ - assert( iColnCol ); - return iCol>=0 ? pTab->aCol[iCol].affinity : SQLITE_AFF_INTEGER; +SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){ + if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER; + return pTab->aCol[iCol].affinity; } /* @@ -100218,30 +101681,36 @@ SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){ assert( pExpr!=0 ); } op = pExpr->op; + if( op==TK_REGISTER ) op = pExpr->op2; + if( op==TK_COLUMN || op==TK_AGG_COLUMN ){ + assert( ExprUseYTab(pExpr) ); + if( pExpr->y.pTab ){ + return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn); + } + } if( op==TK_SELECT ){ - assert( pExpr->flags&EP_xIsSelect ); + assert( ExprUseXSelect(pExpr) ); assert( pExpr->x.pSelect!=0 ); assert( pExpr->x.pSelect->pEList!=0 ); assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 ); return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr); } - if( op==TK_REGISTER ) op = pExpr->op2; #ifndef SQLITE_OMIT_CAST if( op==TK_CAST ){ assert( !ExprHasProperty(pExpr, EP_IntValue) ); return sqlite3AffinityType(pExpr->u.zToken, 0); } #endif - if( (op==TK_AGG_COLUMN || op==TK_COLUMN) && pExpr->y.pTab ){ - return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn); - } if( op==TK_SELECT_COLUMN ){ - assert( pExpr->pLeft->flags&EP_xIsSelect ); + assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) ); + assert( pExpr->iColumn < pExpr->iTable ); + assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr ); return sqlite3ExprAffinity( pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr ); } if( op==TK_VECTOR ){ + assert( ExprUseXList(pExpr) ); return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr); } return pExpr->affExpr; @@ -100256,7 +101725,7 @@ SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){ ** and the pExpr parameter is returned unchanged. */ SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken( - Parse *pParse, /* Parsing context */ + const Parse *pParse, /* Parsing context */ Expr *pExpr, /* Add the "COLLATE" clause to this expression */ const Token *pCollName, /* Name of collating sequence */ int dequote /* True to dequote pCollName */ @@ -100271,7 +101740,11 @@ SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken( } return pExpr; } -SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){ +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString( + const Parse *pParse, /* Parsing context */ + Expr *pExpr, /* Add the "COLLATE" clause to this expression */ + const char *zC /* The collating sequence name */ +){ Token s; assert( zC!=0 ); sqlite3TokenInit(&s, (char*)zC); @@ -100297,7 +101770,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){ SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){ while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){ if( ExprHasProperty(pExpr, EP_Unlikely) ){ - assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + assert( ExprUseXList(pExpr) ); assert( pExpr->x.pList->nExpr>0 ); assert( pExpr->op==TK_FUNCTION ); pExpr = pExpr->x.pList->a[0].pExpr; @@ -100330,27 +101803,30 @@ SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){ while( p ){ int op = p->op; if( op==TK_REGISTER ) op = p->op2; - if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_TRIGGER) - && p->y.pTab!=0 - ){ - /* op==TK_REGISTER && p->y.pTab!=0 happens when pExpr was originally - ** a TK_COLUMN but was previously evaluated and cached in a register */ - int j = p->iColumn; - if( j>=0 ){ - const char *zColl = p->y.pTab->aCol[j].zColl; - pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0); + if( op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_TRIGGER ){ + assert( ExprUseYTab(p) ); + if( p->y.pTab!=0 ){ + /* op==TK_REGISTER && p->y.pTab!=0 happens when pExpr was originally + ** a TK_COLUMN but was previously evaluated and cached in a register */ + int j = p->iColumn; + if( j>=0 ){ + const char *zColl = sqlite3ColumnColl(&p->y.pTab->aCol[j]); + pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0); + } + break; } - break; } if( op==TK_CAST || op==TK_UPLUS ){ p = p->pLeft; continue; } if( op==TK_VECTOR ){ + assert( ExprUseXList(p) ); p = p->x.pList->a[0].pExpr; continue; } if( op==TK_COLLATE ){ + assert( !ExprHasProperty(p, EP_IntValue) ); pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken); break; } @@ -100360,11 +101836,9 @@ SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){ }else{ Expr *pNext = p->pRight; /* The Expr.x union is never used at the same time as Expr.pRight */ + assert( ExprUseXList(p) ); assert( p->x.pList==0 || p->pRight==0 ); - if( p->x.pList!=0 - && !db->mallocFailed - && ALWAYS(!ExprHasProperty(p, EP_xIsSelect)) - ){ + if( p->x.pList!=0 && !db->mallocFailed ){ int i; for(i=0; ALWAYS(ix.pList->nExpr); i++){ if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){ @@ -100447,7 +101921,7 @@ static char comparisonAffinity(const Expr *pExpr){ aff = sqlite3ExprAffinity(pExpr->pLeft); if( pExpr->pRight ){ aff = sqlite3CompareAffinity(pExpr->pRight, aff); - }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + }else if( ExprUseXSelect(pExpr) ){ aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff); }else if( aff==0 ){ aff = SQLITE_AFF_BLOB; @@ -100573,7 +102047,7 @@ static int codeCompare( ** But a TK_SELECT might be either a vector or a scalar. It is only ** considered a vector if it has two or more result columns. */ -SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr){ +SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr){ return sqlite3ExprVectorSize(pExpr)>1; } @@ -100583,12 +102057,14 @@ SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr){ ** is a sub-select, return the number of columns in the sub-select. For ** any other type of expression, return 1. */ -SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr){ +SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr){ u8 op = pExpr->op; if( op==TK_REGISTER ) op = pExpr->op2; if( op==TK_VECTOR ){ + assert( ExprUseXList(pExpr) ); return pExpr->x.pList->nExpr; }else if( op==TK_SELECT ){ + assert( ExprUseXSelect(pExpr) ); return pExpr->x.pSelect->pEList->nExpr; }else{ return 1; @@ -100611,12 +102087,14 @@ SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr){ ** been positioned. */ SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr *pVector, int i){ - assert( iop==TK_ERROR ); if( sqlite3ExprIsVector(pVector) ){ assert( pVector->op2==0 || pVector->op==TK_REGISTER ); if( pVector->op==TK_SELECT || pVector->op2==TK_SELECT ){ + assert( ExprUseXSelect(pVector) ); return pVector->x.pSelect->pEList->a[i].pExpr; }else{ + assert( ExprUseXList(pVector) ); return pVector->x.pList->a[i].pExpr; } } @@ -100647,11 +102125,12 @@ SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr *pVector, int i){ SQLITE_PRIVATE Expr *sqlite3ExprForVectorField( Parse *pParse, /* Parsing context */ Expr *pVector, /* The vector. List of expressions or a sub-SELECT */ - int iField /* Which column of the vector to return */ + int iField, /* Which column of the vector to return */ + int nField /* Total number of columns in the vector */ ){ Expr *pRet; if( pVector->op==TK_SELECT ){ - assert( pVector->flags & EP_xIsSelect ); + assert( ExprUseXSelect(pVector) ); /* The TK_SELECT_COLUMN Expr node: ** ** pLeft: pVector containing TK_SELECT. Not deleted. @@ -100670,14 +102149,23 @@ SQLITE_PRIVATE Expr *sqlite3ExprForVectorField( */ pRet = sqlite3PExpr(pParse, TK_SELECT_COLUMN, 0, 0); if( pRet ){ + pRet->iTable = nField; pRet->iColumn = iField; pRet->pLeft = pVector; } - assert( pRet==0 || pRet->iTable==0 ); }else{ - if( pVector->op==TK_VECTOR ) pVector = pVector->x.pList->a[iField].pExpr; + if( pVector->op==TK_VECTOR ){ + Expr **ppVector; + assert( ExprUseXList(pVector) ); + ppVector = &pVector->x.pList->a[iField].pExpr; + pVector = *ppVector; + if( IN_RENAME_OBJECT ){ + /* This must be a vector UPDATE inside a trigger */ + *ppVector = 0; + return pVector; + } + } pRet = sqlite3ExprDup(pParse->db, pVector, 0); - sqlite3RenameTokenRemap(pParse, pRet, pVector); } return pRet; } @@ -100727,17 +102215,22 @@ static int exprVectorRegister( int *pRegFree /* OUT: Temp register to free */ ){ u8 op = pVector->op; - assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT ); + assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT || op==TK_ERROR ); if( op==TK_REGISTER ){ *ppExpr = sqlite3VectorFieldSubexpr(pVector, iField); return pVector->iTable+iField; } if( op==TK_SELECT ){ + assert( ExprUseXSelect(pVector) ); *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr; return regSelect+iField; } - *ppExpr = pVector->x.pList->a[iField].pExpr; - return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree); + if( op==TK_VECTOR ){ + assert( ExprUseXList(pVector) ); + *ppExpr = pVector->x.pList->a[iField].pExpr; + return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree); + } + return 0; } /* @@ -100766,6 +102259,7 @@ static void codeVectorCompare( int regLeft = 0; int regRight = 0; u8 opx = op; + int addrCmp = 0; int addrDone = sqlite3VdbeMakeLabel(pParse); int isCommuted = ExprHasProperty(pExpr,EP_Commuted); @@ -100785,21 +102279,24 @@ static void codeVectorCompare( assert( p5==0 || pExpr->op!=op ); assert( p5==SQLITE_NULLEQ || pExpr->op==op ); - p5 |= SQLITE_STOREP2; - if( opx==TK_LE ) opx = TK_LT; - if( opx==TK_GE ) opx = TK_GT; + if( op==TK_LE ) opx = TK_LT; + if( op==TK_GE ) opx = TK_GT; + if( op==TK_NE ) opx = TK_EQ; regLeft = exprCodeSubselect(pParse, pLeft); regRight = exprCodeSubselect(pParse, pRight); + sqlite3VdbeAddOp2(v, OP_Integer, 1, dest); for(i=0; 1 /*Loop exits by "break"*/; i++){ int regFree1 = 0, regFree2 = 0; - Expr *pL, *pR; + Expr *pL = 0, *pR = 0; int r1, r2; assert( i>=0 && i0 @@ -100857,14 +102360,14 @@ SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){ ** to by pnHeight, the second parameter, then set *pnHeight to that ** value. */ -static void heightOfExpr(Expr *p, int *pnHeight){ +static void heightOfExpr(const Expr *p, int *pnHeight){ if( p ){ if( p->nHeight>*pnHeight ){ *pnHeight = p->nHeight; } } } -static void heightOfExprList(ExprList *p, int *pnHeight){ +static void heightOfExprList(const ExprList *p, int *pnHeight){ if( p ){ int i; for(i=0; inExpr; i++){ @@ -100872,8 +102375,8 @@ static void heightOfExprList(ExprList *p, int *pnHeight){ } } } -static void heightOfSelect(Select *pSelect, int *pnHeight){ - Select *p; +static void heightOfSelect(const Select *pSelect, int *pnHeight){ + const Select *p; for(p=pSelect; p; p=p->pPrior){ heightOfExpr(p->pWhere, pnHeight); heightOfExpr(p->pHaving, pnHeight); @@ -100898,7 +102401,7 @@ static void exprSetHeight(Expr *p){ int nHeight = 0; heightOfExpr(p->pLeft, &nHeight); heightOfExpr(p->pRight, &nHeight); - if( ExprHasProperty(p, EP_xIsSelect) ){ + if( ExprUseXSelect(p) ){ heightOfSelect(p->x.pSelect, &nHeight); }else if( p->x.pList ){ heightOfExprList(p->x.pList, &nHeight); @@ -100925,7 +102428,7 @@ SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ ** Return the maximum height of any expression tree referenced ** by the select statement passed as an argument. */ -SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *p){ +SQLITE_PRIVATE int sqlite3SelectExprHeight(const Select *p){ int nHeight = 0; heightOfSelect(p, &nHeight); return nHeight; @@ -100937,7 +102440,7 @@ SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *p){ */ SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ if( pParse->nErr ) return; - if( p && p->x.pList && !ExprHasProperty(p, EP_xIsSelect) ){ + if( p && ExprUseXList(p) && p->x.pList ){ p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList); } } @@ -101095,6 +102598,63 @@ SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pS } } +/* +** Expression list pEList is a list of vector values. This function +** converts the contents of pEList to a VALUES(...) Select statement +** returning 1 row for each element of the list. For example, the +** expression list: +** +** ( (1,2), (3,4) (5,6) ) +** +** is translated to the equivalent of: +** +** VALUES(1,2), (3,4), (5,6) +** +** Each of the vector values in pEList must contain exactly nElem terms. +** If a list element that is not a vector or does not contain nElem terms, +** an error message is left in pParse. +** +** This is used as part of processing IN(...) expressions with a list +** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))". +*/ +SQLITE_PRIVATE Select *sqlite3ExprListToValues(Parse *pParse, int nElem, ExprList *pEList){ + int ii; + Select *pRet = 0; + assert( nElem>1 ); + for(ii=0; iinExpr; ii++){ + Select *pSel; + Expr *pExpr = pEList->a[ii].pExpr; + int nExprElem; + if( pExpr->op==TK_VECTOR ){ + assert( ExprUseXList(pExpr) ); + nExprElem = pExpr->x.pList->nExpr; + }else{ + nExprElem = 1; + } + if( nExprElem!=nElem ){ + sqlite3ErrorMsg(pParse, "IN(...) element has %d term%s - expected %d", + nExprElem, nExprElem>1?"s":"", nElem + ); + break; + } + assert( ExprUseXList(pExpr) ); + pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0); + pExpr->x.pList = 0; + if( pSel ){ + if( pRet ){ + pSel->op = TK_ALL; + pSel->pPrior = pRet; + } + pRet = pSel; + } + } + + if( pRet && pRet->pPrior ){ + pRet->selFlags |= SF_MultiValue; + } + sqlite3ExprListDelete(pParse->db, pEList); + return pRet; +} /* ** Join two expressions using an AND operator. If either expression is @@ -101113,8 +102673,8 @@ SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){ }else if( (ExprAlwaysFalse(pLeft) || ExprAlwaysFalse(pRight)) && !IN_RENAME_OBJECT ){ - sqlite3ExprDelete(db, pLeft); - sqlite3ExprDelete(db, pRight); + sqlite3ExprDeferredDelete(pParse, pLeft); + sqlite3ExprDeferredDelete(pParse, pRight); return sqlite3Expr(db, TK_INTEGER, "0"); }else{ return sqlite3PExpr(pParse, TK_AND, pLeft, pRight); @@ -101128,7 +102688,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){ SQLITE_PRIVATE Expr *sqlite3ExprFunction( Parse *pParse, /* Parsing context */ ExprList *pList, /* Argument list */ - Token *pToken, /* Name of the function */ + const Token *pToken, /* Name of the function */ int eDistinct /* SF_Distinct or SF_ALL or 0 */ ){ Expr *pNew; @@ -101139,12 +102699,15 @@ SQLITE_PRIVATE Expr *sqlite3ExprFunction( sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */ return 0; } - if( pList && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){ + if( pList + && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] + && !pParse->nested + ){ sqlite3ErrorMsg(pParse, "too many arguments on function %T", pToken); } pNew->x.pList = pList; ExprSetProperty(pNew, EP_HasFunc); - assert( !ExprHasProperty(pNew, EP_xIsSelect) ); + assert( ExprUseXList(pNew) ); sqlite3ExprSetHeightAndFlags(pParse, pNew); if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct); return pNew; @@ -101163,8 +102726,8 @@ SQLITE_PRIVATE Expr *sqlite3ExprFunction( */ SQLITE_PRIVATE void sqlite3ExprFunctionUsable( Parse *pParse, /* Parsing and code generating context */ - Expr *pExpr, /* The function invocation */ - FuncDef *pDef /* The function being invoked */ + const Expr *pExpr, /* The function invocation */ + const FuncDef *pDef /* The function being invoked */ ){ assert( !IN_RENAME_OBJECT ); assert( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 ); @@ -101270,27 +102833,26 @@ SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n */ static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){ assert( p!=0 ); - /* Sanity check: Assert that the IntValue is non-negative if it exists */ - assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 ); - - assert( !ExprHasProperty(p, EP_WinFunc) || p->y.pWin!=0 || db->mallocFailed ); - assert( p->op!=TK_FUNCTION || ExprHasProperty(p, EP_TokenOnly|EP_Reduced) - || p->y.pWin==0 || ExprHasProperty(p, EP_WinFunc) ); + assert( !ExprUseUValue(p) || p->u.iValue>=0 ); + assert( !ExprUseYWin(p) || !ExprUseYSub(p) ); + assert( !ExprUseYWin(p) || p->y.pWin!=0 || db->mallocFailed ); + assert( p->op!=TK_FUNCTION || !ExprUseYSub(p) ); #ifdef SQLITE_DEBUG if( ExprHasProperty(p, EP_Leaf) && !ExprHasProperty(p, EP_TokenOnly) ){ assert( p->pLeft==0 ); assert( p->pRight==0 ); - assert( p->x.pSelect==0 ); + assert( !ExprUseXSelect(p) || p->x.pSelect==0 ); + assert( !ExprUseXList(p) || p->x.pList==0 ); } #endif if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){ /* The Expr.x union is never used at the same time as Expr.pRight */ - assert( p->x.pList==0 || p->pRight==0 ); + assert( (ExprUseXList(p) && p->x.pList==0) || p->pRight==0 ); if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft); if( p->pRight ){ assert( !ExprHasProperty(p, EP_WinFunc) ); sqlite3ExprDeleteNN(db, p->pRight); - }else if( ExprHasProperty(p, EP_xIsSelect) ){ + }else if( ExprUseXSelect(p) ){ assert( !ExprHasProperty(p, EP_WinFunc) ); sqlite3SelectDelete(db, p->x.pSelect); }else{ @@ -101302,7 +102864,10 @@ static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){ #endif } } - if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken); + if( ExprHasProperty(p, EP_MemToken) ){ + assert( !ExprHasProperty(p, EP_IntValue) ); + sqlite3DbFree(db, p->u.zToken); + } if( !ExprHasProperty(p, EP_Static) ){ sqlite3DbFreeNN(db, p); } @@ -101311,6 +102876,22 @@ SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){ if( p ) sqlite3ExprDeleteNN(db, p); } + +/* +** Arrange to cause pExpr to be deleted when the pParse is deleted. +** This is similar to sqlite3ExprDelete() except that the delete is +** deferred untilthe pParse is deleted. +** +** The pExpr might be deleted immediately on an OOM error. +** +** The deferred delete is (currently) implemented by adding the +** pExpr to the pParse->pConstExpr list with a register number of 0. +*/ +SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){ + pParse->pConstExpr = + sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr); +} + /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the ** expression. */ @@ -101328,7 +102909,7 @@ SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse *pParse, Expr *p){ ** passed as the first argument. This is always one of EXPR_FULLSIZE, ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE. */ -static int exprStructSize(Expr *p){ +static int exprStructSize(const Expr *p){ if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE; if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE; return EXPR_FULLSIZE; @@ -101368,7 +102949,7 @@ static int exprStructSize(Expr *p){ ** of dupedExprStructSize() contain multiple assert() statements that attempt ** to enforce this constraint. */ -static int dupedExprStructSize(Expr *p, int flags){ +static int dupedExprStructSize(const Expr *p, int flags){ int nSize; assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */ assert( EXPR_FULLSIZE<=0xfff ); @@ -101399,7 +102980,7 @@ static int dupedExprStructSize(Expr *p, int flags){ ** of the Expr structure and a copy of the Expr.u.zToken string (if that ** string is defined.) */ -static int dupedExprNodeSize(Expr *p, int flags){ +static int dupedExprNodeSize(const Expr *p, int flags){ int nByte = dupedExprStructSize(p, flags) & 0xfff; if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){ nByte += sqlite3Strlen30NN(p->u.zToken)+1; @@ -101420,7 +103001,7 @@ static int dupedExprNodeSize(Expr *p, int flags){ ** and Expr.pRight variables (but not for any structures pointed to or ** descended from the Expr.x.pList or Expr.x.pSelect variables). */ -static int dupedExprSize(Expr *p, int flags){ +static int dupedExprSize(const Expr *p, int flags){ int nByte = 0; if( p ){ nByte = dupedExprNodeSize(p, flags); @@ -101439,7 +103020,7 @@ static int dupedExprSize(Expr *p, int flags){ ** if any. Before returning, *pzBuffer is set to the first byte past the ** portion of the buffer copied into by this function. */ -static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){ +static Expr *exprDup(sqlite3 *db, const Expr *p, int dupFlags, u8 **pzBuffer){ Expr *pNew; /* Value to return */ u8 *zAlloc; /* Memory space from which to build Expr object */ u32 staticFlag; /* EP_Static if space not obtained from malloc */ @@ -101453,6 +103034,7 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){ if( pzBuffer ){ zAlloc = *pzBuffer; staticFlag = EP_Static; + assert( zAlloc!=0 ); }else{ zAlloc = sqlite3DbMallocRawNN(db, dupedExprSize(p, dupFlags)); staticFlag = 0; @@ -101501,7 +103083,7 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){ if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_Leaf)) ){ /* Fill in the pNew->x.pSelect or pNew->x.pList member. */ - if( ExprHasProperty(p, EP_xIsSelect) ){ + if( ExprUseXSelect(p) ){ pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, dupFlags); }else{ pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, dupFlags); @@ -101530,8 +103112,8 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){ if( !ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){ if( pNew->op==TK_SELECT_COLUMN ){ pNew->pLeft = p->pLeft; - assert( p->iColumn==0 || p->pRight==0 ); - assert( p->pRight==0 || p->pRight==p->pLeft ); + assert( p->pRight==0 || p->pRight==p->pLeft + || ExprHasProperty(p->pLeft, EP_Subquery) ); }else{ pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0); } @@ -101548,7 +103130,7 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){ ** and the db->mallocFailed flag set. */ #ifndef SQLITE_OMIT_CTE -static With *withDup(sqlite3 *db, With *p){ +SQLITE_PRIVATE With *sqlite3WithDup(sqlite3 *db, With *p){ With *pRet = 0; if( p ){ sqlite3_int64 nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1); @@ -101566,7 +103148,7 @@ static With *withDup(sqlite3 *db, With *p){ return pRet; } #else -# define withDup(x,y) 0 +# define sqlite3WithDup(x,y) 0 #endif #ifndef SQLITE_OMIT_WINDOWFUNC @@ -101619,20 +103201,23 @@ static void gatherSelectWindows(Select *p){ ** truncated version of the usual Expr structure that will be stored as ** part of the in-memory representation of the database schema. */ -SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){ +SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, const Expr *p, int flags){ assert( flags==0 || flags==EXPRDUP_REDUCE ); return p ? exprDup(db, p, flags, 0) : 0; } -SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){ +SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, const ExprList *p, int flags){ ExprList *pNew; - struct ExprList_item *pItem, *pOldItem; + struct ExprList_item *pItem; + const struct ExprList_item *pOldItem; int i; - Expr *pPriorSelectCol = 0; + Expr *pPriorSelectColOld = 0; + Expr *pPriorSelectColNew = 0; assert( db!=0 ); if( p==0 ) return 0; pNew = sqlite3DbMallocRawNN(db, sqlite3DbMallocSize(db, p)); if( pNew==0 ) return 0; pNew->nExpr = p->nExpr; + pNew->nAlloc = p->nAlloc; pItem = pNew->a; pOldItem = p->a; for(i=0; inExpr; i++, pItem++, pOldItem++){ @@ -101643,16 +103228,17 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags) && pOldExpr->op==TK_SELECT_COLUMN && (pNewExpr = pItem->pExpr)!=0 ){ - assert( pNewExpr->iColumn==0 || i>0 ); - if( pNewExpr->iColumn==0 ){ - assert( pOldExpr->pLeft==pOldExpr->pRight ); - pPriorSelectCol = pNewExpr->pLeft = pNewExpr->pRight; + if( pNewExpr->pRight ){ + pPriorSelectColOld = pOldExpr->pRight; + pPriorSelectColNew = pNewExpr->pRight; + pNewExpr->pLeft = pNewExpr->pRight; }else{ - assert( i>0 ); - assert( pItem[-1].pExpr!=0 ); - assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 ); - assert( pPriorSelectCol==pItem[-1].pExpr->pLeft ); - pNewExpr->pLeft = pPriorSelectCol; + if( pOldExpr->pLeft!=pPriorSelectColOld ){ + pPriorSelectColOld = pOldExpr->pLeft; + pPriorSelectColNew = sqlite3ExprDup(db, pPriorSelectColOld, flags); + pNewExpr->pRight = pPriorSelectColNew; + } + pNewExpr->pLeft = pPriorSelectColNew; } } pItem->zEName = sqlite3DbStrDup(db, pOldItem->zEName); @@ -101674,7 +103260,7 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags) */ #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \ || !defined(SQLITE_OMIT_SUBQUERY) -SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){ +SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, const SrcList *p, int flags){ SrcList *pNew; int i; int nByte; @@ -101685,8 +103271,8 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){ if( pNew==0 ) return 0; pNew->nSrc = pNew->nAlloc = p->nSrc; for(i=0; inSrc; i++){ - struct SrcList_item *pNewItem = &pNew->a[i]; - struct SrcList_item *pOldItem = &p->a[i]; + SrcItem *pNewItem = &pNew->a[i]; + const SrcItem *pOldItem = &p->a[i]; Table *pTab; pNewItem->pSchema = pOldItem->pSchema; pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase); @@ -101699,7 +103285,10 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){ if( pNewItem->fg.isIndexedBy ){ pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy); } - pNewItem->pIBIndex = pOldItem->pIBIndex; + pNewItem->u2 = pOldItem->u2; + if( pNewItem->fg.isCte ){ + pNewItem->u2.pCteUse->nUse++; + } if( pNewItem->fg.isTabFunc ){ pNewItem->u1.pFuncArg = sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags); @@ -101715,7 +103304,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){ } return pNew; } -SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){ +SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, const IdList *p){ IdList *pNew; int i; assert( db!=0 ); @@ -101739,11 +103328,11 @@ SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){ } return pNew; } -SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *pDup, int flags){ +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *pDup, int flags){ Select *pRet = 0; Select *pNext = 0; Select **pp = &pRet; - Select *p; + const Select *p; assert( db!=0 ); for(p=pDup; p; p=p->pPrior){ @@ -101765,13 +103354,21 @@ SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *pDup, int flags){ pNew->addrOpenEphm[0] = -1; pNew->addrOpenEphm[1] = -1; pNew->nSelectRow = p->nSelectRow; - pNew->pWith = withDup(db, p->pWith); + pNew->pWith = sqlite3WithDup(db, p->pWith); #ifndef SQLITE_OMIT_WINDOWFUNC pNew->pWin = 0; pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn); if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew); #endif pNew->selId = p->selId; + if( db->mallocFailed ){ + /* Any prior OOM might have left the Select object incomplete. + ** Delete the whole thing rather than allow an incomplete Select + ** to be used by the code generator. */ + pNew->pNext = 0; + sqlite3SelectDelete(db, pNew); + break; + } *pp = pNew; pp = &pNew->pPrior; pNext = pNew; @@ -101780,7 +103377,7 @@ SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *pDup, int flags){ return pRet; } #else -SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){ +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *p, int flags){ assert( p==0 ); return 0; } @@ -101802,41 +103399,64 @@ SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){ ** NULL is returned. If non-NULL is returned, then it is guaranteed ** that the new entry was successfully appended. */ +static const struct ExprList_item zeroItem = {0}; +SQLITE_PRIVATE SQLITE_NOINLINE ExprList *sqlite3ExprListAppendNew( + sqlite3 *db, /* Database handle. Used for memory allocation */ + Expr *pExpr /* Expression to be appended. Might be NULL */ +){ + struct ExprList_item *pItem; + ExprList *pList; + + pList = sqlite3DbMallocRawNN(db, sizeof(ExprList)+sizeof(pList->a[0])*4 ); + if( pList==0 ){ + sqlite3ExprDelete(db, pExpr); + return 0; + } + pList->nAlloc = 4; + pList->nExpr = 1; + pItem = &pList->a[0]; + *pItem = zeroItem; + pItem->pExpr = pExpr; + return pList; +} +SQLITE_PRIVATE SQLITE_NOINLINE ExprList *sqlite3ExprListAppendGrow( + sqlite3 *db, /* Database handle. Used for memory allocation */ + ExprList *pList, /* List to which to append. Might be NULL */ + Expr *pExpr /* Expression to be appended. Might be NULL */ +){ + struct ExprList_item *pItem; + ExprList *pNew; + pList->nAlloc *= 2; + pNew = sqlite3DbRealloc(db, pList, + sizeof(*pList)+(pList->nAlloc-1)*sizeof(pList->a[0])); + if( pNew==0 ){ + sqlite3ExprListDelete(db, pList); + sqlite3ExprDelete(db, pExpr); + return 0; + }else{ + pList = pNew; + } + pItem = &pList->a[pList->nExpr++]; + *pItem = zeroItem; + pItem->pExpr = pExpr; + return pList; +} SQLITE_PRIVATE ExprList *sqlite3ExprListAppend( Parse *pParse, /* Parsing context */ ExprList *pList, /* List to which to append. Might be NULL */ Expr *pExpr /* Expression to be appended. Might be NULL */ ){ struct ExprList_item *pItem; - sqlite3 *db = pParse->db; - assert( db!=0 ); if( pList==0 ){ - pList = sqlite3DbMallocRawNN(db, sizeof(ExprList) ); - if( pList==0 ){ - goto no_mem; - } - pList->nExpr = 0; - }else if( (pList->nExpr & (pList->nExpr-1))==0 ){ - ExprList *pNew; - pNew = sqlite3DbRealloc(db, pList, - sizeof(*pList)+(2*(sqlite3_int64)pList->nExpr-1)*sizeof(pList->a[0])); - if( pNew==0 ){ - goto no_mem; - } - pList = pNew; + return sqlite3ExprListAppendNew(pParse->db,pExpr); + } + if( pList->nAllocnExpr+1 ){ + return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr); } pItem = &pList->a[pList->nExpr++]; - assert( offsetof(struct ExprList_item,zEName)==sizeof(pItem->pExpr) ); - assert( offsetof(struct ExprList_item,pExpr)==0 ); - memset(&pItem->zEName,0,sizeof(*pItem)-offsetof(struct ExprList_item,zEName)); + *pItem = zeroItem; pItem->pExpr = pExpr; return pList; - -no_mem: - /* Avoid leaking memory if malloc has failed. */ - sqlite3ExprDelete(db, pExpr); - sqlite3ExprListDelete(db, pList); - return 0; } /* @@ -101877,11 +103497,9 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector( } for(i=0; inId; i++){ - Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i); + Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId); assert( pSubExpr!=0 || db->mallocFailed ); - assert( pSubExpr==0 || pSubExpr->iTable==0 ); if( pSubExpr==0 ) continue; - pSubExpr->iTable = pColumns->nId; pList = sqlite3ExprListAppend(pParse, pList, pSubExpr); if( pList ){ assert( pList->nExpr==iFirst+i+1 ); @@ -101955,7 +103573,7 @@ SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList *p, int iSortOrder, int SQLITE_PRIVATE void sqlite3ExprListSetName( Parse *pParse, /* Parsing context */ ExprList *pList, /* List to which to add the span. */ - Token *pName, /* Name to be added */ + const Token *pName, /* Name to be added */ int dequote /* True to cause the name to be dequoted */ ){ assert( pList!=0 || pParse->db->mallocFailed!=0 ); @@ -101973,7 +103591,7 @@ SQLITE_PRIVATE void sqlite3ExprListSetName( ** to the token-map. */ sqlite3Dequote(pItem->zEName); if( IN_RENAME_OBJECT ){ - sqlite3RenameTokenMap(pParse, (void*)pItem->zEName, pName); + sqlite3RenameTokenMap(pParse, (const void*)pItem->zEName, pName); } } } @@ -102092,7 +103710,7 @@ SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char *zIn){ SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){ u32 v; assert( pExpr->op==TK_ID || pExpr->op==TK_STRING ); - if( !ExprHasProperty(pExpr, EP_Quoted) + if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue) && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0 ){ pExpr->op = TK_TRUEFALSE; @@ -102109,6 +103727,7 @@ SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){ SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){ pExpr = sqlite3ExprSkipCollate((Expr*)pExpr); assert( pExpr->op==TK_TRUEFALSE ); + assert( !ExprHasProperty(pExpr, EP_IntValue) ); assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0 || sqlite3StrICmp(pExpr->u.zToken,"false")==0 ); return pExpr->u.zToken[4]==0; @@ -102313,7 +103932,7 @@ static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){ } /* Check if pExpr is a sub-select. If so, consider it variable. */ - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( ExprUseXSelect(pExpr) ){ pWalker->eCode = 0; return WRC_Abort; } @@ -102401,7 +104020,7 @@ SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr *p){ ** in *pValue. If the expression is not an integer or if it is too big ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged. */ -SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){ +SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr *p, int *pValue){ int rc = 0; if( NEVER(p==0) ) return 0; /* Used to only happen following on OOM */ @@ -102420,9 +104039,9 @@ SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){ break; } case TK_UMINUS: { - int v; + int v = 0; if( sqlite3ExprIsInteger(p->pLeft, &v) ){ - assert( v!=(-2147483647-1) ); + assert( ((unsigned int)v)!=0x80000000 ); *pValue = -v; rc = 1; } @@ -102449,8 +104068,10 @@ SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){ */ SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){ u8 op; + assert( p!=0 ); while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; + assert( p!=0 ); } op = p->op; if( op==TK_REGISTER ) op = p->op2; @@ -102461,6 +104082,7 @@ SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){ case TK_BLOB: return 0; case TK_COLUMN: + assert( ExprUseYTab(p) ); return ExprHasProperty(p, EP_CanBeNull) || p->y.pTab==0 || /* Reference to column of index on expression */ (p->iColumn>=0 @@ -102532,13 +104154,13 @@ SQLITE_PRIVATE int sqlite3IsRowid(const char *z){ ** table, then return NULL. */ #ifndef SQLITE_OMIT_SUBQUERY -static Select *isCandidateForInOpt(Expr *pX){ +static Select *isCandidateForInOpt(const Expr *pX){ Select *p; SrcList *pSrc; ExprList *pEList; Table *pTab; int i; - if( !ExprHasProperty(pX, EP_xIsSelect) ) return 0; /* Not a subquery */ + if( !ExprUseXSelect(pX) ) return 0; /* Not a subquery */ if( ExprHasProperty(pX, EP_VarSelect) ) return 0; /* Correlated subq */ p = pX->x.pSelect; if( p->pPrior ) return 0; /* Not a compound SELECT */ @@ -102556,7 +104178,7 @@ static Select *isCandidateForInOpt(Expr *pX){ if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */ pTab = pSrc->a[0].pTab; assert( pTab!=0 ); - assert( pTab->pSelect==0 ); /* FROM clause is not a view */ + assert( !IsView(pTab) ); /* FROM clause is not a view */ if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */ pEList = p->pEList; assert( pEList!=0 ); @@ -102709,7 +104331,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex( ** or not NULL is actually possible (it may not be, for example, due ** to NOT NULL constraints in the schema). If no NULL values are possible, ** set prRhsHasNull to 0 before continuing. */ - if( prRhsHasNull && (pX->flags & EP_xIsSelect) ){ + if( prRhsHasNull && ExprUseXSelect(pX) ){ int i; ExprList *pEList = pX->x.pSelect->pEList; for(i=0; inExpr; i++){ @@ -102737,7 +104359,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex( /* Code an OP_Transaction and OP_TableLock for . */ iDb = sqlite3SchemaToIndex(db, pTab->pSchema); - assert( iDb>=0 && iDb=0 && iDbtnum, 0, pTab->zName); @@ -102810,7 +104432,8 @@ SQLITE_PRIVATE int sqlite3FindInIndex( CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs); int j; - assert( pReq!=0 || pRhs->iColumn==XN_ROWID || pParse->nErr ); + assert( pReq!=0 || pRhs->iColumn==XN_ROWID + || pParse->nErr || db->mallocFailed ); for(j=0; jaiColumn[j]!=pRhs->iColumn ) continue; assert( pIdx->azColl[j] ); @@ -102865,7 +104488,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex( */ if( eType==0 && (inFlags & IN_INDEX_NOOP_OK) - && !ExprHasProperty(pX, EP_xIsSelect) + && ExprUseXList(pX) && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2) ){ eType = IN_INDEX_NOOP; @@ -102910,10 +104533,10 @@ SQLITE_PRIVATE int sqlite3FindInIndex( ** It is the responsibility of the caller to ensure that the returned ** string is eventually freed using sqlite3DbFree(). */ -static char *exprINAffinity(Parse *pParse, Expr *pExpr){ +static char *exprINAffinity(Parse *pParse, const Expr *pExpr){ Expr *pLeft = pExpr->pLeft; int nVal = sqlite3ExprVectorSize(pLeft); - Select *pSelect = (pExpr->flags & EP_xIsSelect) ? pExpr->x.pSelect : 0; + Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0; char *zRet; assert( pExpr->op==TK_IN ); @@ -102963,7 +104586,7 @@ SQLITE_PRIVATE void sqlite3SubselectError(Parse *pParse, int nActual, int nExpec */ SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){ #ifndef SQLITE_OMIT_SUBQUERY - if( pExpr->flags & EP_xIsSelect ){ + if( ExprUseXSelect(pExpr) ){ sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1); }else #endif @@ -103027,10 +104650,11 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN( */ if( ExprHasProperty(pExpr, EP_Subrtn) ){ addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( ExprUseXSelect(pExpr) ){ ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d", pExpr->x.pSelect->selId)); } + assert( ExprUseYSub(pExpr) ); sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, pExpr->y.sub.iAddr); sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable); @@ -103039,6 +104663,7 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN( } /* Begin coding the subroutine */ + assert( !ExprUseYWin(pExpr) ); ExprSetProperty(pExpr, EP_Subrtn); assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); pExpr->y.sub.regReturn = ++pParse->nMem; @@ -103059,7 +104684,7 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN( pExpr->iTable = iTab; addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal); #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( ExprUseXSelect(pExpr) ){ VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId)); }else{ VdbeComment((v, "RHS of IN operator")); @@ -103067,7 +104692,7 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN( #endif pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1); - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( ExprUseXSelect(pExpr) ){ /* Case 1: expr IN (SELECT ...) ** ** Generate code to write the results of the select into the temporary @@ -103082,19 +104707,23 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN( /* If the LHS and RHS of the IN operator do not match, that ** error will have been caught long before we reach this point. */ if( ALWAYS(pEList->nExpr==nVal) ){ + Select *pCopy; SelectDest dest; int i; + int rc; sqlite3SelectDestInit(&dest, SRT_Set, iTab); dest.zAffSdst = exprINAffinity(pParse, pExpr); pSelect->iLimit = 0; testcase( pSelect->selFlags & SF_Distinct ); testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */ - if( sqlite3Select(pParse, pSelect, &dest) ){ - sqlite3DbFree(pParse->db, dest.zAffSdst); + pCopy = sqlite3SelectDup(pParse->db, pSelect, 0); + rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest); + sqlite3SelectDelete(pParse->db, pCopy); + sqlite3DbFree(pParse->db, dest.zAffSdst); + if( rc ){ sqlite3KeyInfoUnref(pKeyInfo); return; } - sqlite3DbFree(pParse->db, dest.zAffSdst); assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */ assert( pEList!=0 ); assert( pEList->nExpr>0 ); @@ -103161,6 +104790,7 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN( if( addrOnce ){ sqlite3VdbeJumpHere(v, addrOnce); /* Subroutine return */ + assert( ExprUseYSub(pExpr) ); sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn); sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1); sqlite3ClearTempRegCache(pParse); @@ -103193,12 +104823,33 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ Vdbe *v = pParse->pVdbe; assert( v!=0 ); + if( pParse->nErr ) return 0; testcase( pExpr->op==TK_EXISTS ); testcase( pExpr->op==TK_SELECT ); assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT ); - assert( ExprHasProperty(pExpr, EP_xIsSelect) ); + assert( ExprUseXSelect(pExpr) ); pSel = pExpr->x.pSelect; + /* If this routine has already been coded, then invoke it as a + ** subroutine. */ + if( ExprHasProperty(pExpr, EP_Subrtn) ){ + ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId)); + assert( ExprUseYSub(pExpr) ); + sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, + pExpr->y.sub.iAddr); + return pExpr->iTable; + } + + /* Begin coding the subroutine */ + assert( !ExprUseYWin(pExpr) ); + assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) ); + ExprSetProperty(pExpr, EP_Subrtn); + pExpr->y.sub.regReturn = ++pParse->nMem; + pExpr->y.sub.iAddr = + sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1; + VdbeComment((v, "return address")); + + /* The evaluation of the EXISTS/SELECT must be repeated every time it ** is encountered if any of the following is true: ** @@ -103210,22 +104861,6 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ ** save the results, and reuse the same result on subsequent invocations. */ if( !ExprHasProperty(pExpr, EP_VarSelect) ){ - /* If this routine has already been coded, then invoke it as a - ** subroutine. */ - if( ExprHasProperty(pExpr, EP_Subrtn) ){ - ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId)); - sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, - pExpr->y.sub.iAddr); - return pExpr->iTable; - } - - /* Begin coding the subroutine */ - ExprSetProperty(pExpr, EP_Subrtn); - pExpr->y.sub.regReturn = ++pParse->nMem; - pExpr->y.sub.iAddr = - sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1; - VdbeComment((v, "return address")); - addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); } @@ -103274,19 +104909,23 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ } pSel->iLimit = 0; if( sqlite3Select(pParse, pSel, &dest) ){ + if( pParse->nErr ){ + pExpr->op2 = pExpr->op; + pExpr->op = TK_ERROR; + } return 0; } pExpr->iTable = rReg = dest.iSDParm; ExprSetVVAProperty(pExpr, EP_NoReduce); if( addrOnce ){ sqlite3VdbeJumpHere(v, addrOnce); - - /* Subroutine return */ - sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn); - sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1); - sqlite3ClearTempRegCache(pParse); } + /* Subroutine return */ + assert( ExprUseYSub(pExpr) ); + sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn); + sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1); + sqlite3ClearTempRegCache(pParse); return rReg; } #endif /* SQLITE_OMIT_SUBQUERY */ @@ -103300,7 +104939,7 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ */ SQLITE_PRIVATE int sqlite3ExprCheckIN(Parse *pParse, Expr *pIn){ int nVector = sqlite3ExprVectorSize(pIn->pLeft); - if( (pIn->flags & EP_xIsSelect) ){ + if( ExprUseXSelect(pIn) && !pParse->db->mallocFailed ){ if( nVector!=pIn->x.pSelect->pEList->nExpr ){ sqlite3SubselectError(pParse, pIn->x.pSelect->pEList->nExpr, nVector); return 1; @@ -103434,13 +105073,15 @@ static void sqlite3ExprCodeIN( ** This is step (1) in the in-operator.md optimized algorithm. */ if( eType==IN_INDEX_NOOP ){ - ExprList *pList = pExpr->x.pList; - CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft); + ExprList *pList; + CollSeq *pColl; int labelOk = sqlite3VdbeMakeLabel(pParse); int r2, regToFree; int regCkNull = 0; int ii; - assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + assert( ExprUseXList(pExpr) ); + pList = pExpr->x.pList; + pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft); if( destIfNull!=destIfFalse ){ regCkNull = sqlite3GetTempReg(pParse); sqlite3VdbeAddOp3(v, OP_BitAnd, rLhs, rLhs, regCkNull); @@ -103491,6 +105132,7 @@ static void sqlite3ExprCodeIN( if( pParse->nErr ) goto sqlite3ExprCodeIN_finished; for(i=0; ipLeft, i); + if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error; if( sqlite3ExprCanBeNull(p) ){ sqlite3VdbeAddOp2(v, OP_IsNull, rLhs+i, destStep2); VdbeCoverage(v); @@ -103676,9 +105318,10 @@ SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn( ** and store the result in register regOut */ SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn( - Parse *pParse, - Column *pCol, - int regOut + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table containing the generated column */ + Column *pCol, /* The generated column */ + int regOut /* Put the result in this register */ ){ int iAddr; Vdbe *v = pParse->pVdbe; @@ -103689,7 +105332,7 @@ SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn( }else{ iAddr = 0; } - sqlite3ExprCodeCopy(pParse, pCol->pDflt, regOut); + sqlite3ExprCodeCopy(pParse, sqlite3ColumnExpr(pTab,pCol), regOut); if( pCol->affinity>=SQLITE_AFF_TEXT ){ sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1); } @@ -103725,12 +105368,13 @@ SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable( }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){ Parse *pParse = sqlite3VdbeParser(v); if( pCol->colFlags & COLFLAG_BUSY ){ - sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pCol->zName); + sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", + pCol->zCnName); }else{ int savedSelfTab = pParse->iSelfTab; pCol->colFlags |= COLFLAG_BUSY; pParse->iSelfTab = iTabCur+1; - sqlite3ExprCodeGeneratedColumn(pParse, pCol, regOut); + sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, regOut); pParse->iSelfTab = savedSelfTab; pCol->colFlags &= ~COLFLAG_BUSY; } @@ -103823,6 +105467,7 @@ static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable){ int i; iResult = pParse->nMem+1; pParse->nMem += nResult; + assert( ExprUseXList(p) ); for(i=0; ix.pList->a[i].pExpr, i+iResult); } @@ -103897,6 +105542,7 @@ static int exprCodeInlineFunction( ** Test-only SQL functions that are only usable if enabled ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS */ +#if !defined(SQLITE_UNTESTABLE) case INLINEFUNC_expr_compare: { /* Compare two expressions using sqlite3ExprCompare() */ assert( nFarg==2 ); @@ -103930,7 +105576,6 @@ static int exprCodeInlineFunction( break; } -#ifdef SQLITE_DEBUG case INLINEFUNC_affinity: { /* The AFFINITY() function evaluates to a string that describes ** the type affinity of the argument. This is used for testing of @@ -103944,7 +105589,7 @@ static int exprCodeInlineFunction( (aff<=SQLITE_AFF_NONE) ? "none" : azAff[aff-SQLITE_AFF_BLOB]); break; } -#endif +#endif /* !defined(SQLITE_UNTESTABLE) */ } return target; } @@ -103998,7 +105643,8 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) if( pCol->iColumn<0 ){ VdbeComment((v,"%s.rowid",pTab->zName)); }else{ - VdbeComment((v,"%s.%s",pTab->zName,pTab->aCol[pCol->iColumn].zName)); + VdbeComment((v,"%s.%s", + pTab->zName, pTab->aCol[pCol->iColumn].zCnName)); if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){ sqlite3VdbeAddOp1(v, OP_RealAffinity, target); } @@ -104020,6 +105666,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) */ int aff; iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target); + assert( ExprUseYTab(pExpr) ); if( pExpr->y.pTab ){ aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn); }else{ @@ -104043,9 +105690,11 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) ** immediately prior to the first column. */ Column *pCol; - Table *pTab = pExpr->y.pTab; + Table *pTab; int iSrc; int iCol = pExpr->iColumn; + assert( ExprUseYTab(pExpr) ); + pTab = pExpr->y.pTab; assert( pTab!=0 ); assert( iCol>=XN_ROWID ); assert( iColnCol ); @@ -104059,12 +105708,12 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) if( pCol->colFlags & COLFLAG_GENERATED ){ if( pCol->colFlags & COLFLAG_BUSY ){ sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", - pCol->zName); + pCol->zCnName); return 0; } pCol->colFlags |= COLFLAG_BUSY; if( pCol->colFlags & COLFLAG_NOTAVAIL ){ - sqlite3ExprCodeGeneratedColumn(pParse, pCol, iSrc); + sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, iSrc); } pCol->colFlags &= ~(COLFLAG_BUSY|COLFLAG_NOTAVAIL); return iSrc; @@ -104083,6 +105732,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) iTab = pParse->iSelfTab - 1; } } + assert( ExprUseYTab(pExpr) ); iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab, pExpr->iColumn, iTab, target, pExpr->op2); @@ -104116,7 +105766,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) ** Expr node to be passed into this function, it will be handled ** sanely and not crash. But keep the assert() to bring the problem ** to the attention of the developers. */ - assert( op==TK_NULL ); + assert( op==TK_NULL || op==TK_ERROR || pParse->db->mallocFailed ); sqlite3VdbeAddOp2(v, OP_Null, 0, target); return target; } @@ -104160,6 +105810,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target); inReg = target; } + assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3VdbeAddOp2(v, OP_Cast, target, sqlite3AffinityType(pExpr->u.zToken, 0)); return inReg; @@ -104182,8 +105833,9 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) }else{ r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1); r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); - codeCompare(pParse, pLeft, pExpr->pRight, op, - r1, r2, inReg, SQLITE_STOREP2 | p5, + sqlite3VdbeAddOp2(v, OP_Integer, 1, inReg); + codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2, + sqlite3VdbeCurrentAddr(v)+2, p5, ExprHasProperty(pExpr,EP_Commuted)); assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); @@ -104191,6 +105843,11 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq); assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne); + if( p5==SQLITE_NULLEQ ){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, inReg); + }else{ + sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, inReg, r2); + } testcase( regFree1==0 ); testcase( regFree2==0 ); } @@ -104321,8 +105978,8 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) ** multiple times if we know they always give the same result */ return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1); } - assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); assert( !ExprHasProperty(pExpr, EP_TokenOnly) ); + assert( ExprUseXList(pExpr) ); pFarg = pExpr->x.pList; nFarg = pFarg ? pFarg->nExpr : 0; assert( !ExprHasProperty(pExpr, EP_IntValue) ); @@ -104411,7 +106068,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ); } #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC - if( pDef->funcFlags & SQLITE_FUNC_OFFSET ){ + if( (pDef->funcFlags & SQLITE_FUNC_OFFSET)!=0 && ALWAYS(pFarg!=0) ){ Expr *pArg = pFarg->a[0].pExpr; if( pArg->op==TK_COLUMN ){ sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target); @@ -104441,7 +106098,10 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) testcase( op==TK_SELECT ); if( pParse->db->mallocFailed ){ return 0; - }else if( op==TK_SELECT && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 ){ + }else if( op==TK_SELECT + && ALWAYS( ExprUseXSelect(pExpr) ) + && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 + ){ sqlite3SubselectError(pParse, nCol, 1); }else{ return sqlite3CodeSubselect(pParse, pExpr); @@ -104453,10 +106113,9 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) if( pExpr->pLeft->iTable==0 ){ pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft); } - assert( pExpr->iTable==0 || pExpr->pLeft->op==TK_SELECT ); - if( pExpr->iTable!=0 - && pExpr->iTable!=(n = sqlite3ExprVectorSize(pExpr->pLeft)) - ){ + assert( pExpr->pLeft->op==TK_SELECT || pExpr->pLeft->op==TK_ERROR ); + n = sqlite3ExprVectorSize(pExpr->pLeft); + if( pExpr->iTable!=n ){ sqlite3ErrorMsg(pParse, "%d columns assigned %d values", pExpr->iTable, n); } @@ -104524,9 +106183,14 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) ** p1==1 -> old.a p1==4 -> new.a ** p1==2 -> old.b p1==5 -> new.b */ - Table *pTab = pExpr->y.pTab; - int iCol = pExpr->iColumn; - int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + Table *pTab; + int iCol; + int p1; + + assert( ExprUseYTab(pExpr) ); + pTab = pExpr->y.pTab; + iCol = pExpr->iColumn; + p1 = pExpr->iTable * (pTab->nCol+1) + 1 + sqlite3TableColumnToStorage(pTab, iCol); assert( pExpr->iTable==0 || pExpr->iTable==1 ); @@ -104537,7 +106201,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) sqlite3VdbeAddOp2(v, OP_Param, p1, target); VdbeComment((v, "r[%d]=%s.%s", target, (pExpr->iTable ? "new" : "old"), - (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zName) + (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName) )); #ifndef SQLITE_OMIT_FLOATING_POINT @@ -104614,7 +106278,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target) Expr *pDel = 0; sqlite3 *db = pParse->db; - assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList ); + assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 ); assert(pExpr->x.pList->nExpr > 0); pEList = pExpr->x.pList; aListelem = pEList->a; @@ -104811,7 +106475,7 @@ SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){ inReg = sqlite3ExprCodeTarget(pParse, pExpr, target); if( inReg!=target ){ u8 op; - if( ExprHasProperty(pExpr,EP_Subquery) ){ + if( ALWAYS(pExpr) && ExprHasProperty(pExpr,EP_Subquery) ){ op = OP_Copy; }else{ op = OP_SCopy; @@ -104959,7 +106623,7 @@ static void exprCodeBetween( memset(&compRight, 0, sizeof(Expr)); memset(&exprAnd, 0, sizeof(Expr)); - assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + assert( ExprUseXList(pExpr) ); pDel = sqlite3ExprDup(db, pExpr->pLeft, 0); if( db->mallocFailed==0 ){ exprAnd.op = TK_AND; @@ -105349,7 +107013,11 @@ SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,i ** Otherwise, if the values are not the same or if pExpr is not a simple ** SQL value, zero is returned. */ -static int exprCompareVariable(Parse *pParse, Expr *pVar, Expr *pExpr){ +static int exprCompareVariable( + const Parse *pParse, + const Expr *pVar, + const Expr *pExpr +){ int res = 0; int iVar; sqlite3_value *pL, *pR = 0; @@ -105401,7 +107069,12 @@ static int exprCompareVariable(Parse *pParse, Expr *pVar, Expr *pExpr){ ** Argument pParse should normally be NULL. If it is not NULL and pA or ** pB causes a return value of 2. */ -SQLITE_PRIVATE int sqlite3ExprCompare(Parse *pParse, Expr *pA, Expr *pB, int iTab){ +SQLITE_PRIVATE int sqlite3ExprCompare( + const Parse *pParse, + const Expr *pA, + const Expr *pB, + int iTab +){ u32 combinedFlags; if( pA==0 || pB==0 ){ return pB==pA ? 0 : 2; @@ -105425,7 +107098,9 @@ SQLITE_PRIVATE int sqlite3ExprCompare(Parse *pParse, Expr *pA, Expr *pB, int iTa } return 2; } - if( pA->op!=TK_COLUMN && pA->op!=TK_AGG_COLUMN && pA->u.zToken ){ + assert( !ExprHasProperty(pA, EP_IntValue) ); + assert( !ExprHasProperty(pB, EP_IntValue) ); + if( pA->u.zToken ){ if( pA->op==TK_FUNCTION || pA->op==TK_AGG_FUNCTION ){ if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; #ifndef SQLITE_OMIT_WINDOWFUNC @@ -105443,7 +107118,12 @@ SQLITE_PRIVATE int sqlite3ExprCompare(Parse *pParse, Expr *pA, Expr *pB, int iTa return 0; }else if( pA->op==TK_COLLATE ){ if( sqlite3_stricmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; - }else if( ALWAYS(pB->u.zToken!=0) && strcmp(pA->u.zToken,pB->u.zToken)!=0 ){ + }else + if( pB->u.zToken!=0 + && pA->op!=TK_COLUMN + && pA->op!=TK_AGG_COLUMN + && strcmp(pA->u.zToken,pB->u.zToken)!=0 + ){ return 2; } } @@ -105485,7 +107165,7 @@ SQLITE_PRIVATE int sqlite3ExprCompare(Parse *pParse, Expr *pA, Expr *pB, int iTa ** Two NULL pointers are considered to be the same. But a NULL pointer ** always differs from a non-NULL pointer. */ -SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){ +SQLITE_PRIVATE int sqlite3ExprListCompare(const ExprList *pA, const ExprList *pB, int iTab){ int i; if( pA==0 && pB==0 ) return 0; if( pA==0 || pB==0 ) return 1; @@ -105504,7 +107184,7 @@ SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){ ** Like sqlite3ExprCompare() except COLLATE operators at the top-level ** are ignored. */ -SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA, Expr *pB, int iTab){ +SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA,Expr *pB, int iTab){ return sqlite3ExprCompare(0, sqlite3ExprSkipCollateAndLikely(pA), sqlite3ExprSkipCollateAndLikely(pB), @@ -105518,9 +107198,9 @@ SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA, Expr *pB, int iTab){ ** non-NULL if pNN is not NULL */ static int exprImpliesNotNull( - Parse *pParse, /* Parsing context */ - Expr *p, /* The expression to be checked */ - Expr *pNN, /* The expression that is NOT NULL */ + const Parse *pParse,/* Parsing context */ + const Expr *p, /* The expression to be checked */ + const Expr *pNN, /* The expression that is NOT NULL */ int iTab, /* Table being evaluated */ int seenNot /* Return true only if p can be any non-NULL value */ ){ @@ -105532,12 +107212,13 @@ static int exprImpliesNotNull( switch( p->op ){ case TK_IN: { if( seenNot && ExprHasProperty(p, EP_xIsSelect) ) return 0; - assert( ExprHasProperty(p,EP_xIsSelect) - || (p->x.pList!=0 && p->x.pList->nExpr>0) ); + assert( ExprUseXSelect(p) || (p->x.pList!=0 && p->x.pList->nExpr>0) ); return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); } case TK_BETWEEN: { - ExprList *pList = p->x.pList; + ExprList *pList; + assert( ExprUseXList(p) ); + pList = p->x.pList; assert( pList!=0 ); assert( pList->nExpr==2 ); if( seenNot ) return 0; @@ -105613,7 +107294,12 @@ static int exprImpliesNotNull( ** improvement. Returning false might cause a performance reduction, but ** it will always give the correct answer and is hence always safe. */ -SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Parse *pParse, Expr *pE1, Expr *pE2, int iTab){ +SQLITE_PRIVATE int sqlite3ExprImpliesExpr( + const Parse *pParse, + const Expr *pE1, + const Expr *pE2, + int iTab +){ if( sqlite3ExprCompare(pParse, pE1, pE2, iTab)==0 ){ return 1; } @@ -105709,10 +107395,14 @@ static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){ testcase( pExpr->op==TK_GE ); /* The y.pTab=0 assignment in wherecode.c always happens after the ** impliesNotNullRow() test */ - if( (pLeft->op==TK_COLUMN && ALWAYS(pLeft->y.pTab!=0) - && IsVirtual(pLeft->y.pTab)) - || (pRight->op==TK_COLUMN && ALWAYS(pRight->y.pTab!=0) - && IsVirtual(pRight->y.pTab)) + assert( pLeft->op!=TK_COLUMN || ExprUseYTab(pLeft) ); + assert( pRight->op!=TK_COLUMN || ExprUseYTab(pRight) ); + if( (pLeft->op==TK_COLUMN + && pLeft->y.pTab!=0 + && IsVirtual(pLeft->y.pTab)) + || (pRight->op==TK_COLUMN + && pRight->y.pTab!=0 + && IsVirtual(pRight->y.pTab)) ){ return WRC_Prune; } @@ -105821,88 +107511,125 @@ SQLITE_PRIVATE int sqlite3ExprCoveredByIndex( } -/* -** An instance of the following structure is used by the tree walker -** to count references to table columns in the arguments of an -** aggregate function, in order to implement the -** sqlite3FunctionThisSrc() routine. -*/ -struct SrcCount { - SrcList *pSrc; /* One particular FROM clause in a nested query */ - int iSrcInner; /* Smallest cursor number in this context */ - int nThis; /* Number of references to columns in pSrcList */ - int nOther; /* Number of references to columns in other FROM clauses */ +/* Structure used to pass information throught the Walker in order to +** implement sqlite3ReferencesSrcList(). +*/ +struct RefSrcList { + sqlite3 *db; /* Database connection used for sqlite3DbRealloc() */ + SrcList *pRef; /* Looking for references to these tables */ + i64 nExclude; /* Number of tables to exclude from the search */ + int *aiExclude; /* Cursor IDs for tables to exclude from the search */ }; /* -** xSelect callback for sqlite3FunctionUsesThisSrc(). If this is the first -** SELECT with a FROM clause encountered during this iteration, set -** SrcCount.iSrcInner to the cursor number of the leftmost object in -** the FROM cause. +** Walker SELECT callbacks for sqlite3ReferencesSrcList(). +** +** When entering a new subquery on the pExpr argument, add all FROM clause +** entries for that subquery to the exclude list. +** +** When leaving the subquery, remove those entries from the exclude list. */ -static int selectSrcCount(Walker *pWalker, Select *pSel){ - struct SrcCount *p = pWalker->u.pSrcCount; - if( p->iSrcInner==0x7FFFFFFF && ALWAYS(pSel->pSrc) && pSel->pSrc->nSrc ){ - pWalker->u.pSrcCount->iSrcInner = pSel->pSrc->a[0].iCursor; +static int selectRefEnter(Walker *pWalker, Select *pSelect){ + struct RefSrcList *p = pWalker->u.pRefSrcList; + SrcList *pSrc = pSelect->pSrc; + i64 i, j; + int *piNew; + if( pSrc->nSrc==0 ) return WRC_Continue; + j = p->nExclude; + p->nExclude += pSrc->nSrc; + piNew = sqlite3DbRealloc(p->db, p->aiExclude, p->nExclude*sizeof(int)); + if( piNew==0 ){ + p->nExclude = 0; + return WRC_Abort; + }else{ + p->aiExclude = piNew; + } + for(i=0; inSrc; i++, j++){ + p->aiExclude[j] = pSrc->a[i].iCursor; } return WRC_Continue; } +static void selectRefLeave(Walker *pWalker, Select *pSelect){ + struct RefSrcList *p = pWalker->u.pRefSrcList; + SrcList *pSrc = pSelect->pSrc; + if( p->nExclude ){ + assert( p->nExclude>=pSrc->nSrc ); + p->nExclude -= pSrc->nSrc; + } +} -/* -** Count the number of references to columns. +/* This is the Walker EXPR callback for sqlite3ReferencesSrcList(). +** +** Set the 0x01 bit of pWalker->eCode if there is a reference to any +** of the tables shown in RefSrcList.pRef. +** +** Set the 0x02 bit of pWalker->eCode if there is a reference to a +** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude. */ -static int exprSrcCount(Walker *pWalker, Expr *pExpr){ - /* There was once a NEVER() on the second term on the grounds that - ** sqlite3FunctionUsesThisSrc() was always called before - ** sqlite3ExprAnalyzeAggregates() and so the TK_COLUMNs have not yet - ** been converted into TK_AGG_COLUMN. But this is no longer true due - ** to window functions - sqlite3WindowRewrite() may now indirectly call - ** FunctionUsesThisSrc() when creating a new sub-select. */ - if( pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN ){ +static int exprRefToSrcList(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_COLUMN + || pExpr->op==TK_AGG_COLUMN + ){ int i; - struct SrcCount *p = pWalker->u.pSrcCount; - SrcList *pSrc = p->pSrc; + struct RefSrcList *p = pWalker->u.pRefSrcList; + SrcList *pSrc = p->pRef; int nSrc = pSrc ? pSrc->nSrc : 0; for(i=0; iiTable==pSrc->a[i].iCursor ) break; + if( pExpr->iTable==pSrc->a[i].iCursor ){ + pWalker->eCode |= 1; + return WRC_Continue; + } } - if( inThis++; - }else if( pExpr->iTableiSrcInner ){ - /* In a well-formed parse tree (no name resolution errors), - ** TK_COLUMN nodes with smaller Expr.iTable values are in an - ** outer context. Those are the only ones to count as "other" */ - p->nOther++; + for(i=0; inExclude && p->aiExclude[i]!=pExpr->iTable; i++){} + if( i>=p->nExclude ){ + pWalker->eCode |= 2; } } return WRC_Continue; } /* -** Determine if any of the arguments to the pExpr Function reference -** pSrcList. Return true if they do. Also return true if the function -** has no arguments or has only constant arguments. Return false if pExpr -** references columns but not columns of tables found in pSrcList. +** Check to see if pExpr references any tables in pSrcList. +** Possible return values: +** +** 1 pExpr does references a table in pSrcList. +** +** 0 pExpr references some table that is not defined in either +** pSrcList or in subqueries of pExpr itself. +** +** -1 pExpr only references no tables at all, or it only +** references tables defined in subqueries of pExpr itself. +** +** As currently used, pExpr is always an aggregate function call. That +** fact is exploited for efficiency. */ -SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr *pExpr, SrcList *pSrcList){ +SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){ Walker w; - struct SrcCount cnt; - assert( pExpr->op==TK_AGG_FUNCTION ); + struct RefSrcList x; memset(&w, 0, sizeof(w)); - w.xExprCallback = exprSrcCount; - w.xSelectCallback = selectSrcCount; - w.u.pSrcCount = &cnt; - cnt.pSrc = pSrcList; - cnt.iSrcInner = (pSrcList&&pSrcList->nSrc)?pSrcList->a[0].iCursor:0x7FFFFFFF; - cnt.nThis = 0; - cnt.nOther = 0; + memset(&x, 0, sizeof(x)); + w.xExprCallback = exprRefToSrcList; + w.xSelectCallback = selectRefEnter; + w.xSelectCallback2 = selectRefLeave; + w.u.pRefSrcList = &x; + x.db = pParse->db; + x.pRef = pSrcList; + assert( pExpr->op==TK_AGG_FUNCTION ); + assert( ExprUseXList(pExpr) ); sqlite3WalkExprList(&w, pExpr->x.pList); #ifndef SQLITE_OMIT_WINDOWFUNC if( ExprHasProperty(pExpr, EP_WinFunc) ){ sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter); } #endif - return cnt.nThis>0 || cnt.nOther==0; + sqlite3DbFree(pParse->db, x.aiExclude); + if( w.eCode & 0x01 ){ + return 1; + }else if( w.eCode ){ + return 0; + }else{ + return -1; + } } /* @@ -105933,8 +107660,7 @@ static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){ pExpr = sqlite3ExprDup(db, pExpr, 0); if( pExpr ){ pAggInfo->aCol[iAgg].pCExpr = pExpr; - pParse->pConstExpr = - sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr); + sqlite3ExprDeferredDelete(pParse, pExpr); } } }else{ @@ -105943,8 +107669,7 @@ static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){ pExpr = sqlite3ExprDup(db, pExpr, 0); if( pExpr ){ pAggInfo->aFunc[iAgg].pFExpr = pExpr; - pParse->pConstExpr = - sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr); + sqlite3ExprDeferredDelete(pParse, pExpr); } } } @@ -106016,7 +107741,7 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){ /* Check to see if the column is in one of the tables in the FROM ** clause of the aggregate query */ if( ALWAYS(pSrcList!=0) ){ - struct SrcList_item *pItem = pSrcList->a; + SrcItem *pItem = pSrcList->a; for(i=0; inSrc; i++, pItem++){ struct AggInfo_col *pCol; assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); @@ -106039,6 +107764,7 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){ && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0 ){ pCol = &pAggInfo->aCol[k]; + assert( ExprUseYTab(pExpr) ); pCol->pTab = pExpr->y.pTab; pCol->iTable = pExpr->iTable; pCol->iColumn = pExpr->iColumn; @@ -106087,6 +107813,7 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){ */ struct AggInfo_func *pItem = pAggInfo->aFunc; for(i=0; inFunc; i++, pItem++){ + if( pItem->pFExpr==pExpr ) break; if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){ break; } @@ -106101,7 +107828,7 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){ pItem = &pAggInfo->aFunc[i]; pItem->pFExpr = pExpr; pItem->iMem = ++pParse->nMem; - assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( ExprUseUToken(pExpr) ); pItem->pFunc = sqlite3FindFunction(pParse->db, pExpr->u.zToken, pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0); @@ -106287,6 +108014,7 @@ SQLITE_PRIVATE int sqlite3NoTempsInRange(Parse *pParse, int iFirst, int iLast){ static int isAlterableTable(Parse *pParse, Table *pTab){ if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) #ifndef SQLITE_OMIT_VIRTUALTABLE + || (pTab->tabFlags & TF_Eponymous)!=0 || ( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(pParse->db) ) @@ -106305,25 +108033,56 @@ static int isAlterableTable(Parse *pParse, Table *pTab){ ** statement to ensure that the operation has not rendered any schema ** objects unusable. */ -static void renameTestSchema(Parse *pParse, const char *zDb, int bTemp){ +static void renameTestSchema( + Parse *pParse, /* Parse context */ + const char *zDb, /* Name of db to verify schema of */ + int bTemp, /* True if this is the temp db */ + const char *zWhen, /* "when" part of error message */ + int bNoDQS /* Do not allow DQS in the schema */ +){ + pParse->colNamesSet = 1; sqlite3NestedParse(pParse, "SELECT 1 " - "FROM \"%w\"." DFLT_SCHEMA_TABLE " " + "FROM \"%w\"." LEGACY_SCHEMA_TABLE " " "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" " AND sql NOT LIKE 'create virtual%%'" - " AND sqlite_rename_test(%Q, sql, type, name, %d)=NULL ", + " AND sqlite_rename_test(%Q, sql, type, name, %d, %Q, %d)=NULL ", zDb, - zDb, bTemp + zDb, bTemp, zWhen, bNoDQS ); if( bTemp==0 ){ sqlite3NestedParse(pParse, "SELECT 1 " - "FROM temp." DFLT_SCHEMA_TABLE " " + "FROM temp." LEGACY_SCHEMA_TABLE " " "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" " AND sql NOT LIKE 'create virtual%%'" - " AND sqlite_rename_test(%Q, sql, type, name, 1)=NULL ", - zDb + " AND sqlite_rename_test(%Q, sql, type, name, 1, %Q, %d)=NULL ", + zDb, zWhen, bNoDQS + ); + } +} + +/* +** Generate VM code to replace any double-quoted strings (but not double-quoted +** identifiers) within the "sql" column of the sqlite_schema table in +** database zDb with their single-quoted equivalents. If argument bTemp is +** not true, similarly update all SQL statements in the sqlite_schema table +** of the temp db. +*/ +static void renameFixQuotes(Parse *pParse, const char *zDb, int bTemp){ + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE + " SET sql = sqlite_rename_quotefix(%Q, sql)" + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + " AND sql NOT LIKE 'create virtual%%'" , zDb, zDb + ); + if( bTemp==0 ){ + sqlite3NestedParse(pParse, + "UPDATE temp." LEGACY_SCHEMA_TABLE + " SET sql = sqlite_rename_quotefix('temp', sql)" + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + " AND sql NOT LIKE 'create virtual%%'" ); } } @@ -106332,12 +108091,12 @@ static void renameTestSchema(Parse *pParse, const char *zDb, int bTemp){ ** Generate code to reload the schema for database iDb. And, if iDb!=1, for ** the temp database as well. */ -static void renameReloadSchema(Parse *pParse, int iDb){ +static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){ Vdbe *v = pParse->pVdbe; if( v ){ sqlite3ChangeCookie(pParse, iDb); - sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0); - if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0); + sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5); + if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5); } } @@ -106359,9 +108118,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable( const char *zTabName; /* Original name of the table */ Vdbe *v; VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */ - u32 savedDbFlags; /* Saved value of db->mDbFlags */ - savedDbFlags = db->mDbFlags; if( NEVER(db->mallocFailed) ) goto exit_rename_table; assert( pSrc->nSrc==1 ); assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); @@ -106370,7 +108127,6 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable( if( !pTab ) goto exit_rename_table; iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); zDb = db->aDb[iDb].zDbSName; - db->mDbFlags |= DBFLAG_PreferBuiltin; /* Get a NULL terminated version of the new table name. */ zName = sqlite3NameFromToken(db, pName); @@ -106399,7 +108155,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable( } #ifndef SQLITE_OMIT_VIEW - if( pTab->pSelect ){ + if( IsView(pTab) ){ sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName); goto exit_rename_table; } @@ -106441,7 +108197,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable( /* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in ** the schema to use the new table name. */ sqlite3NestedParse(pParse, - "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET " + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET " "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, %d) " "WHERE (type!='index' OR tbl_name=%Q COLLATE nocase)" "AND name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" @@ -106451,7 +108207,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable( /* Update the tbl_name and name columns of the sqlite_schema table ** as required. */ sqlite3NestedParse(pParse, - "UPDATE %Q." DFLT_SCHEMA_TABLE " SET " + "UPDATE %Q." LEGACY_SCHEMA_TABLE " SET " "tbl_name = %Q, " "name = CASE " "WHEN type='table' THEN %Q " @@ -106486,7 +108242,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable( "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), " "tbl_name = " "CASE WHEN tbl_name=%Q COLLATE nocase AND " - " sqlite_rename_test(%Q, sql, type, name, 1) " + " sqlite_rename_test(%Q, sql, type, name, 1, 'after rename', 0) " "THEN %Q ELSE tbl_name END " "WHERE type IN ('view', 'trigger')" , zDb, zTabName, zName, zTabName, zDb, zName); @@ -106505,13 +108261,12 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable( } #endif - renameReloadSchema(pParse, iDb); - renameTestSchema(pParse, zDb, iDb==1); + renameReloadSchema(pParse, iDb, INITFLAG_AlterRename); + renameTestSchema(pParse, zDb, iDb==1, "after rename", 0); exit_rename_table: sqlite3SrcListDelete(db, pSrc); sqlite3DbFree(db, zName); - db->mDbFlags = savedDbFlags; } /* @@ -106561,7 +108316,7 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){ zDb = db->aDb[iDb].zDbSName; zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */ pCol = &pNew->aCol[pNew->nCol-1]; - pDflt = pCol->pDflt; + pDflt = sqlite3ColumnExpr(pNew, pCol); pTab = sqlite3FindTable(db, zTab, zDb); assert( pTab ); @@ -106595,7 +108350,8 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){ if( pDflt && pDflt->pLeft->op==TK_NULL ){ pDflt = 0; } - if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){ + assert( IsOrdinaryTable(pNew) ); + if( (db->flags&SQLITE_ForeignKeys) && pNew->u.tab.pFKey && pDflt ){ sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, "Cannot add a REFERENCES column with non-NULL default value"); } @@ -106632,28 +108388,30 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){ zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n); if( zCol ){ char *zEnd = &zCol[pColDef->n-1]; - u32 savedDbFlags = db->mDbFlags; while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){ *zEnd-- = '\0'; } - db->mDbFlags |= DBFLAG_PreferBuiltin; + /* substr() operations on characters, but addColOffset is in bytes. So we + ** have to use printf() to translate between these units: */ + assert( IsOrdinaryTable(pTab) ); + assert( IsOrdinaryTable(pNew) ); sqlite3NestedParse(pParse, - "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET " - "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) " + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET " + "sql = printf('%%.%ds, ',sql) || %Q" + " || substr(sql,1+length(printf('%%.%ds',sql))) " "WHERE type = 'table' AND name = %Q", - zDb, pNew->addColOffset, zCol, pNew->addColOffset+1, + zDb, pNew->u.tab.addColOffset, zCol, pNew->u.tab.addColOffset, zTab ); sqlite3DbFree(db, zCol); - db->mDbFlags = savedDbFlags; } - /* Make sure the schema version is at least 3. But do not upgrade - ** from less than 3 to 4, as that will corrupt any preexisting DESC - ** index. - */ v = sqlite3GetVdbe(pParse); if( v ){ + /* Make sure the schema version is at least 3. But do not upgrade + ** from less than 3 to 4, as that will corrupt any preexisting DESC + ** index. + */ r1 = sqlite3GetTempReg(pParse); sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT); sqlite3VdbeUsesBtree(v, iDb); @@ -106662,10 +108420,25 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){ VdbeCoverage(v); sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3); sqlite3ReleaseTempReg(pParse, r1); - } - /* Reload the table definition */ - renameReloadSchema(pParse, iDb); + /* Reload the table definition */ + renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd); + + /* Verify that constraints are still satisfied */ + if( pNew->pCheck!=0 + || (pCol->notNull && (pCol->colFlags & COLFLAG_GENERATED)!=0) + ){ + sqlite3NestedParse(pParse, + "SELECT CASE WHEN quick_check GLOB 'CHECK*'" + " THEN raise(ABORT,'CHECK constraint failed')" + " ELSE raise(ABORT,'NOT NULL constraint failed')" + " END" + " FROM pragma_quick_check(\"%w\",\"%w\")" + " WHERE quick_check GLOB 'CHECK*' OR quick_check GLOB 'NULL*'", + zTab, zDb + ); + } + } } /* @@ -106706,7 +108479,7 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){ #endif /* Make sure this is not an attempt to ALTER a view. */ - if( pTab->pSelect ){ + if( IsView(pTab) ){ sqlite3ErrorMsg(pParse, "Cannot add a column to a view"); goto exit_begin_add_column; } @@ -106715,7 +108488,8 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){ } sqlite3MayAbort(pParse); - assert( pTab->addColOffset>0 ); + assert( IsOrdinaryTable(pTab) ); + assert( pTab->u.tab.addColOffset>0 ); iDb = sqlite3SchemaToIndex(db, pTab->pSchema); /* Put a copy of the Table struct in Parse.pNewTable for the @@ -106742,13 +108516,13 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){ memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol); for(i=0; inCol; i++){ Column *pCol = &pNew->aCol[i]; - pCol->zName = sqlite3DbStrDup(db, pCol->zName); - pCol->hName = sqlite3StrIHash(pCol->zName); - pCol->zColl = 0; - pCol->pDflt = 0; + pCol->zCnName = sqlite3DbStrDup(db, pCol->zCnName); + pCol->hName = sqlite3StrIHash(pCol->zCnName); } + assert( IsOrdinaryTable(pNew) ); + pNew->u.tab.pDfltList = sqlite3ExprListDup(db, pTab->u.tab.pDfltList, 0); pNew->pSchema = db->aDb[iDb].pSchema; - pNew->addColOffset = pTab->addColOffset; + pNew->u.tab.addColOffset = pTab->u.tab.addColOffset; pNew->nTabRef = 1; exit_begin_add_column: @@ -106765,10 +108539,10 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){ ** Or, if pTab is not a view or virtual table, zero is returned. */ #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) -static int isRealTable(Parse *pParse, Table *pTab){ +static int isRealTable(Parse *pParse, Table *pTab, int bDrop){ const char *zType = 0; #ifndef SQLITE_OMIT_VIEW - if( pTab->pSelect ){ + if( IsView(pTab) ){ zType = "view"; } #endif @@ -106778,15 +108552,16 @@ static int isRealTable(Parse *pParse, Table *pTab){ } #endif if( zType ){ - sqlite3ErrorMsg( - pParse, "cannot rename columns of %s \"%s\"", zType, pTab->zName + sqlite3ErrorMsg(pParse, "cannot %s %s \"%s\"", + (bDrop ? "drop column from" : "rename columns of"), + zType, pTab->zName ); return 1; } return 0; } #else /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */ -# define isRealTable(x,y) (0) +# define isRealTable(x,y,z) (0) #endif /* @@ -106815,7 +108590,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameColumn( /* Cannot alter a system table */ if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column; - if( SQLITE_OK!=isRealTable(pParse, pTab) ) goto exit_rename_column; + if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column; /* Which schema holds the table to be altered */ iSchema = sqlite3SchemaToIndex(db, pTab->pSchema); @@ -106834,13 +108609,17 @@ SQLITE_PRIVATE void sqlite3AlterRenameColumn( zOld = sqlite3NameFromToken(db, pOld); if( !zOld ) goto exit_rename_column; for(iCol=0; iColnCol; iCol++){ - if( 0==sqlite3StrICmp(pTab->aCol[iCol].zName, zOld) ) break; + if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break; } if( iCol==pTab->nCol ){ sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zOld); goto exit_rename_column; } + /* Ensure the schema contains no double-quoted strings */ + renameTestSchema(pParse, zDb, iSchema==1, "", 0); + renameFixQuotes(pParse, zDb, iSchema==1); + /* Do the rename operation using a recursive UPDATE statement that ** uses the sqlite_rename_column() SQL function to compute the new ** CREATE statement text for the sqlite_schema table. @@ -106851,26 +108630,25 @@ SQLITE_PRIVATE void sqlite3AlterRenameColumn( assert( pNew->n>0 ); bQuote = sqlite3Isquote(pNew->z[0]); sqlite3NestedParse(pParse, - "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET " + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET " "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, %d) " "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X' " - " AND (type != 'index' OR tbl_name = %Q)" - " AND sql NOT LIKE 'create virtual%%'", + " AND (type != 'index' OR tbl_name = %Q)", zDb, zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1, pTab->zName ); sqlite3NestedParse(pParse, - "UPDATE temp." DFLT_SCHEMA_TABLE " SET " + "UPDATE temp." LEGACY_SCHEMA_TABLE " SET " "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) " "WHERE type IN ('trigger', 'view')", zDb, pTab->zName, iCol, zNew, bQuote ); /* Drop and reload the database schema. */ - renameReloadSchema(pParse, iSchema); - renameTestSchema(pParse, zDb, iSchema==1); + renameReloadSchema(pParse, iSchema, INITFLAG_AlterRename); + renameTestSchema(pParse, zDb, iSchema==1, "after rename", 1); exit_rename_column: sqlite3SrcListDelete(db, pSrc); @@ -106897,7 +108675,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameColumn( ** the parse tree. */ struct RenameToken { - void *p; /* Parse tree element created by token t */ + const void *p; /* Parse tree element created by token t */ Token t; /* The token that created parse tree element p */ RenameToken *pNext; /* Next is a list of all RenameToken objects */ }; @@ -106939,9 +108717,9 @@ struct RenameCtx { ** Technically, as x no longer points into a valid object or to the byte ** following a valid object, it may not be used in comparison operations. */ -static void renameTokenCheckAll(Parse *pParse, void *pPtr){ +static void renameTokenCheckAll(Parse *pParse, const void *pPtr){ if( pParse->nErr==0 && pParse->db->mallocFailed==0 ){ - RenameToken *p; + const RenameToken *p; u8 i = 0; for(p=pParse->pRename; p; p=p->pNext){ if( p->p ){ @@ -106967,7 +108745,11 @@ static void renameTokenCheckAll(Parse *pParse, void *pPtr){ ** with tail recursion in tokenExpr() routine, for a small performance ** improvement. */ -SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse *pParse, void *pPtr, Token *pToken){ +SQLITE_PRIVATE const void *sqlite3RenameTokenMap( + Parse *pParse, + const void *pPtr, + const Token *pToken +){ RenameToken *pNew; assert( pPtr || pParse->db->mallocFailed ); renameTokenCheckAll(pParse, pPtr); @@ -106989,7 +108771,7 @@ SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse *pParse, void *pPtr, Token *pTo ** with parse tree element pFrom. This function remaps the associated token ** to parse tree element pTo. */ -SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, void *pTo, void *pFrom){ +SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, const void *pTo, const void *pFrom){ RenameToken *p; renameTokenCheckAll(pParse, pTo); for(p=pParse->pRename; p; p=p->pNext){ @@ -107005,7 +108787,10 @@ SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, void *pTo, void *pFro */ static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){ Parse *pParse = pWalker->pParse; - sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr); + sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr); + if( ExprUseYTab(pExpr) ){ + sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab); + } return WRC_Continue; } @@ -107016,15 +108801,31 @@ static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){ static void renameWalkWith(Walker *pWalker, Select *pSelect){ With *pWith = pSelect->pWith; if( pWith ){ + Parse *pParse = pWalker->pParse; int i; + With *pCopy = 0; + assert( pWith->nCte>0 ); + if( (pWith->a[0].pSelect->selFlags & SF_Expanded)==0 ){ + /* Push a copy of the With object onto the with-stack. We use a copy + ** here as the original will be expanded and resolved (flags SF_Expanded + ** and SF_Resolved) below. And the parser code that uses the with-stack + ** fails if the Select objects on it have already been expanded and + ** resolved. */ + pCopy = sqlite3WithDup(pParse->db, pWith); + pCopy = sqlite3WithPush(pParse, pCopy, 1); + } for(i=0; inCte; i++){ Select *p = pWith->a[i].pSelect; NameContext sNC; memset(&sNC, 0, sizeof(sNC)); - sNC.pParse = pWalker->pParse; - sqlite3SelectPrep(sNC.pParse, p, &sNC); + sNC.pParse = pParse; + if( pCopy ) sqlite3SelectPrep(sNC.pParse, p, &sNC); + if( sNC.pParse->db->mallocFailed ) return; sqlite3WalkSelect(pWalker, p); - sqlite3RenameExprlistUnmap(pWalker->pParse, pWith->a[i].pCols); + sqlite3RenameExprlistUnmap(pParse, pWith->a[i].pCols); + } + if( pCopy && pParse->pWith==pCopy ){ + pParse->pWith = pCopy->pOuter; } } } @@ -107034,12 +108835,12 @@ static void renameWalkWith(Walker *pWalker, Select *pSelect){ */ static void unmapColumnIdlistNames( Parse *pParse, - IdList *pIdList + const IdList *pIdList ){ if( pIdList ){ int ii; for(ii=0; iinId; ii++){ - sqlite3RenameTokenRemap(pParse, 0, (void*)pIdList->a[ii].zName); + sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName); } } } @@ -107051,7 +108852,11 @@ static int renameUnmapSelectCb(Walker *pWalker, Select *p){ Parse *pParse = pWalker->pParse; int i; if( pParse->nErr ) return WRC_Abort; - if( NEVER(p->selFlags & SF_View) ) return WRC_Prune; + testcase( p->selFlags & SF_View ); + testcase( p->selFlags & SF_CopyCte ); + if( p->selFlags & (SF_View|SF_CopyCte) ){ + return WRC_Prune; + } if( ALWAYS(p->pEList) ){ ExprList *pList = p->pEList; for(i=0; inExpr; i++){ @@ -107064,7 +108869,7 @@ static int renameUnmapSelectCb(Walker *pWalker, Select *p){ SrcList *pSrc = p->pSrc; for(i=0; inSrc; i++){ sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName); - if( sqlite3WalkExpr(pWalker, pSrc->a[i].pOn) ) return WRC_Abort; + sqlite3WalkExpr(pWalker, pSrc->a[i].pOn); unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing); } } @@ -107122,23 +108927,35 @@ static void renameTokenFree(sqlite3 *db, RenameToken *pToken){ /* ** Search the Parse object passed as the first argument for a RenameToken -** object associated with parse tree element pPtr. If found, remove it -** from the Parse object and add it to the list maintained by the -** RenameCtx object passed as the second argument. +** object associated with parse tree element pPtr. If found, return a pointer +** to it. Otherwise, return NULL. +** +** If the second argument passed to this function is not NULL and a matching +** RenameToken object is found, remove it from the Parse object and add it to +** the list maintained by the RenameCtx object. */ -static void renameTokenFind(Parse *pParse, struct RenameCtx *pCtx, void *pPtr){ +static RenameToken *renameTokenFind( + Parse *pParse, + struct RenameCtx *pCtx, + const void *pPtr +){ RenameToken **pp; - assert( pPtr!=0 ); + if( NEVER(pPtr==0) ){ + return 0; + } for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){ if( (*pp)->p==pPtr ){ RenameToken *pToken = *pp; - *pp = pToken->pNext; - pToken->pNext = pCtx->pList; - pCtx->pList = pToken; - pCtx->nList++; - break; + if( pCtx ){ + *pp = pToken->pNext; + pToken->pNext = pCtx->pList; + pCtx->pList = pToken; + pCtx->nList++; + } + return pToken; } } + return 0; } /* @@ -107147,7 +108964,11 @@ static void renameTokenFind(Parse *pParse, struct RenameCtx *pCtx, void *pPtr){ ** descend into sub-select statements. */ static int renameColumnSelectCb(Walker *pWalker, Select *p){ - if( p->selFlags & SF_View ) return WRC_Prune; + if( p->selFlags & (SF_View|SF_CopyCte) ){ + testcase( p->selFlags & SF_View ); + testcase( p->selFlags & SF_CopyCte ); + return WRC_Prune; + } renameWalkWith(pWalker, p); return WRC_Continue; } @@ -107170,6 +108991,7 @@ static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){ renameTokenFind(pWalker->pParse, p, (void*)pExpr); }else if( pExpr->op==TK_COLUMN && pExpr->iColumn==p->iCol + && ALWAYS(ExprUseYTab(pExpr)) && p->pTab==pExpr->y.pTab ){ renameTokenFind(pWalker->pParse, p, (void*)pExpr); @@ -107209,7 +109031,7 @@ static RenameToken *renameColumnTokenNext(RenameCtx *pCtx){ */ static void renameColumnParseError( sqlite3_context *pCtx, - int bPost, + const char *zWhen, sqlite3_value *pType, sqlite3_value *pObject, Parse *pParse @@ -107218,8 +109040,8 @@ static void renameColumnParseError( const char *zN = (const char*)sqlite3_value_text(pObject); char *zErr; - zErr = sqlite3_mprintf("error in %s %s%s: %s", - zT, zN, (bPost ? " after rename" : ""), + zErr = sqlite3_mprintf("error in %s %s%s%s: %s", + zT, zN, (zWhen[0] ? " " : ""), zWhen, pParse->zErrMsg ); sqlite3_result_error(pCtx, zErr, -1); @@ -107235,18 +109057,18 @@ static void renameColumnParseError( static void renameColumnElistNames( Parse *pParse, RenameCtx *pCtx, - ExprList *pEList, + const ExprList *pEList, const char *zOld ){ if( pEList ){ int i; for(i=0; inExpr; i++){ - char *zName = pEList->a[i].zEName; + const char *zName = pEList->a[i].zEName; if( ALWAYS(pEList->a[i].eEName==ENAME_NAME) && ALWAYS(zName!=0) && 0==sqlite3_stricmp(zName, zOld) ){ - renameTokenFind(pParse, pCtx, (void*)zName); + renameTokenFind(pParse, pCtx, (const void*)zName); } } } @@ -107260,15 +109082,15 @@ static void renameColumnElistNames( static void renameColumnIdlistNames( Parse *pParse, RenameCtx *pCtx, - IdList *pIdList, + const IdList *pIdList, const char *zOld ){ if( pIdList ){ int i; for(i=0; inId; i++){ - char *zName = pIdList->a[i].zName; + const char *zName = pIdList->a[i].zName; if( 0==sqlite3_stricmp(zName, zOld) ){ - renameTokenFind(pParse, pCtx, (void*)zName); + renameTokenFind(pParse, pCtx, (const void*)zName); } } } @@ -107298,7 +109120,7 @@ static int renameParseSql( p->eParseMode = PARSE_MODE_RENAME; p->db = db; p->nQueryLoop = 1; - rc = sqlite3RunParser(p, zSql, &zErr); + rc = zSql ? sqlite3RunParser(p, zSql, &zErr) : SQLITE_NOMEM; assert( p->zErrMsg==0 ); assert( rc!=SQLITE_OK || zErr==0 ); p->zErrMsg = zErr; @@ -107341,51 +109163,76 @@ static int renameEditSql( const char *zNew, /* New token text */ int bQuote /* True to always quote token */ ){ - int nNew = sqlite3Strlen30(zNew); - int nSql = sqlite3Strlen30(zSql); + i64 nNew = sqlite3Strlen30(zNew); + i64 nSql = sqlite3Strlen30(zSql); sqlite3 *db = sqlite3_context_db_handle(pCtx); int rc = SQLITE_OK; - char *zQuot; + char *zQuot = 0; char *zOut; - int nQuot; - - /* Set zQuot to point to a buffer containing a quoted copy of the - ** identifier zNew. If the corresponding identifier in the original - ** ALTER TABLE statement was quoted (bQuote==1), then set zNew to - ** point to zQuot so that all substitutions are made using the - ** quoted version of the new column name. */ - zQuot = sqlite3MPrintf(db, "\"%w\"", zNew); - if( zQuot==0 ){ - return SQLITE_NOMEM; + i64 nQuot = 0; + char *zBuf1 = 0; + char *zBuf2 = 0; + + if( zNew ){ + /* Set zQuot to point to a buffer containing a quoted copy of the + ** identifier zNew. If the corresponding identifier in the original + ** ALTER TABLE statement was quoted (bQuote==1), then set zNew to + ** point to zQuot so that all substitutions are made using the + ** quoted version of the new column name. */ + zQuot = sqlite3MPrintf(db, "\"%w\" ", zNew); + if( zQuot==0 ){ + return SQLITE_NOMEM; + }else{ + nQuot = sqlite3Strlen30(zQuot)-1; + } + + assert( nQuot>=nNew ); + zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1); }else{ - nQuot = sqlite3Strlen30(zQuot); - } - if( bQuote ){ - zNew = zQuot; - nNew = nQuot; + zOut = (char*)sqlite3DbMallocZero(db, (nSql*2+1) * 3); + if( zOut ){ + zBuf1 = &zOut[nSql*2+1]; + zBuf2 = &zOut[nSql*4+2]; + } } /* At this point pRename->pList contains a list of RenameToken objects ** corresponding to all tokens in the input SQL that must be replaced - ** with the new column name. All that remains is to construct and - ** return the edited SQL string. */ - assert( nQuot>=nNew ); - zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1); + ** with the new column name, or with single-quoted versions of themselves. + ** All that remains is to construct and return the edited SQL string. */ if( zOut ){ int nOut = nSql; memcpy(zOut, zSql, nSql); while( pRename->pList ){ int iOff; /* Offset of token to replace in zOut */ - RenameToken *pBest = renameColumnTokenNext(pRename); - u32 nReplace; const char *zReplace; - if( sqlite3IsIdChar(*pBest->t.z) ){ - nReplace = nNew; - zReplace = zNew; + RenameToken *pBest = renameColumnTokenNext(pRename); + + if( zNew ){ + if( bQuote==0 && sqlite3IsIdChar(*pBest->t.z) ){ + nReplace = nNew; + zReplace = zNew; + }else{ + nReplace = nQuot; + zReplace = zQuot; + if( pBest->t.z[pBest->t.n]=='"' ) nReplace++; + } }else{ - nReplace = nQuot; - zReplace = zQuot; + /* Dequote the double-quoted token. Then requote it again, this time + ** using single quotes. If the character immediately following the + ** original token within the input SQL was a single quote ('), then + ** add another space after the new, single-quoted version of the + ** token. This is so that (SELECT "string"'alias') maps to + ** (SELECT 'string' 'alias'), and not (SELECT 'string''alias'). */ + memcpy(zBuf1, pBest->t.z, pBest->t.n); + zBuf1[pBest->t.n] = 0; + sqlite3Dequote(zBuf1); + sqlite3_snprintf(nSql*2, zBuf2, "%Q%s", zBuf1, + pBest->t.z[pBest->t.n]=='\'' ? " " : "" + ); + zReplace = zBuf2; + nReplace = sqlite3Strlen30(zReplace); } iOff = pBest->t.z - zSql; @@ -107451,7 +109298,7 @@ static int renameResolveTrigger(Parse *pParse){ if( pSrc ){ int i; for(i=0; inSrc && rc==SQLITE_OK; i++){ - struct SrcList_item *p = &pSrc->a[i]; + SrcItem *p = &pSrc->a[i]; p->iCursor = pParse->nTab++; if( p->pSelect ){ sqlite3SelectPrep(pParse, p->pSelect, 0); @@ -107469,6 +109316,9 @@ static int renameResolveTrigger(Parse *pParse){ } } } + if( rc==SQLITE_OK && db->mallocFailed ){ + rc = SQLITE_NOMEM; + } sNC.pSrcList = pSrc; if( rc==SQLITE_OK && pStep->pWhere ){ rc = sqlite3ResolveExprNames(&sNC, pStep->pWhere); @@ -107477,9 +109327,8 @@ static int renameResolveTrigger(Parse *pParse){ rc = sqlite3ResolveExprListNames(&sNC, pStep->pExprList); } assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) ); - if( pStep->pUpsert ){ + if( pStep->pUpsert && rc==SQLITE_OK ){ Upsert *pUpsert = pStep->pUpsert; - assert( rc==SQLITE_OK ); pUpsert->pUpsertSrc = pSrc; sNC.uNC.pUpsert = pUpsert; sNC.ncFlags = NC_UUpsert; @@ -107617,7 +109466,7 @@ static void renameColumnFunc( sqlite3BtreeLeaveAll(db); return; } - zOld = pTab->aCol[iCol].zName; + zOld = pTab->aCol[iCol].zCnName; memset(&sCtx, 0, sizeof(sCtx)); sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol); @@ -107636,8 +109485,8 @@ static void renameColumnFunc( sCtx.pTab = pTab; if( rc!=SQLITE_OK ) goto renameColumnFunc_done; if( sParse.pNewTable ){ - Select *pSelect = sParse.pNewTable->pSelect; - if( pSelect ){ + if( IsView(sParse.pNewTable) ){ + Select *pSelect = sParse.pNewTable->u.view.pSelect; pSelect->selFlags &= ~SF_View; sParse.rc = SQLITE_OK; sqlite3SelectPrep(&sParse, pSelect, 0); @@ -107646,16 +109495,17 @@ static void renameColumnFunc( sqlite3WalkSelect(&sWalker, pSelect); } if( rc!=SQLITE_OK ) goto renameColumnFunc_done; - }else{ + }else if( IsOrdinaryTable(sParse.pNewTable) ){ /* A regular table */ int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName); FKey *pFKey; - assert( sParse.pNewTable->pSelect==0 ); sCtx.pTab = sParse.pNewTable; if( bFKOnly==0 ){ - renameTokenFind( - &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zName - ); + if( iColnCol ){ + renameTokenFind( + &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zCnName + ); + } if( sCtx.iCol<0 ){ renameTokenFind(&sParse, &sCtx, (void*)&sParse.pNewTable->iPKey); } @@ -107666,14 +109516,17 @@ static void renameColumnFunc( for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){ sqlite3WalkExprList(&sWalker, pIdx->aColExpr); } - } #ifndef SQLITE_OMIT_GENERATED_COLUMNS - for(i=0; inCol; i++){ - sqlite3WalkExpr(&sWalker, sParse.pNewTable->aCol[i].pDflt); - } + for(i=0; inCol; i++){ + Expr *pExpr = sqlite3ColumnExpr(sParse.pNewTable, + &sParse.pNewTable->aCol[i]); + sqlite3WalkExpr(&sWalker, pExpr); + } #endif + } - for(pFKey=sParse.pNewTable->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + assert( IsOrdinaryTable(sParse.pNewTable) ); + for(pFKey=sParse.pNewTable->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ for(i=0; inCol; i++){ if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){ renameTokenFind(&sParse, &sCtx, (void*)&pFKey->aCol[i]); @@ -107725,7 +109578,7 @@ static void renameColumnFunc( renameColumnFunc_done: if( rc!=SQLITE_OK ){ if( sParse.zErrMsg ){ - renameColumnParseError(context, 0, argv[1], argv[2], &sParse); + renameColumnParseError(context, "", argv[1], argv[2], &sParse); }else{ sqlite3_result_error_code(context, rc); } @@ -107744,7 +109597,10 @@ static void renameColumnFunc( */ static int renameTableExprCb(Walker *pWalker, Expr *pExpr){ RenameCtx *p = pWalker->u.pRename; - if( pExpr->op==TK_COLUMN && p->pTab==pExpr->y.pTab ){ + if( pExpr->op==TK_COLUMN + && ALWAYS(ExprUseYTab(pExpr)) + && p->pTab==pExpr->y.pTab + ){ renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab); } return WRC_Continue; @@ -107757,13 +109613,17 @@ static int renameTableSelectCb(Walker *pWalker, Select *pSelect){ int i; RenameCtx *p = pWalker->u.pRename; SrcList *pSrc = pSelect->pSrc; - if( pSelect->selFlags & SF_View ) return WRC_Prune; - if( pSrc==0 ){ + if( pSelect->selFlags & (SF_View|SF_CopyCte) ){ + testcase( pSelect->selFlags & SF_View ); + testcase( pSelect->selFlags & SF_CopyCte ); + return WRC_Prune; + } + if( NEVER(pSrc==0) ){ assert( pWalker->pParse->db->mallocFailed ); return WRC_Abort; } for(i=0; inSrc; i++){ - struct SrcList_item *pItem = &pSrc->a[i]; + SrcItem *pItem = &pSrc->a[i]; if( pItem->pTab==p->pTab ){ renameTokenFind(pWalker->pParse, p, pItem->zName); } @@ -107835,28 +109695,31 @@ static void renameTableFunc( if( sParse.pNewTable ){ Table *pTab = sParse.pNewTable; - if( pTab->pSelect ){ + if( IsView(pTab) ){ if( isLegacy==0 ){ - Select *pSelect = pTab->pSelect; + Select *pSelect = pTab->u.view.pSelect; NameContext sNC; memset(&sNC, 0, sizeof(sNC)); sNC.pParse = &sParse; assert( pSelect->selFlags & SF_View ); pSelect->selFlags &= ~SF_View; - sqlite3SelectPrep(&sParse, pTab->pSelect, &sNC); + sqlite3SelectPrep(&sParse, pTab->u.view.pSelect, &sNC); if( sParse.nErr ){ rc = sParse.rc; }else{ - sqlite3WalkSelect(&sWalker, pTab->pSelect); + sqlite3WalkSelect(&sWalker, pTab->u.view.pSelect); } } }else{ /* Modify any FK definitions to point to the new table. */ #ifndef SQLITE_OMIT_FOREIGN_KEY - if( isLegacy==0 || (db->flags & SQLITE_ForeignKeys) ){ + if( (isLegacy==0 || (db->flags & SQLITE_ForeignKeys)) + && !IsVirtual(pTab) + ){ FKey *pFKey; - for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + assert( IsOrdinaryTable(pTab) ); + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ if( sqlite3_stricmp(pFKey->zTo, zOld)==0 ){ renameTokenFind(&sParse, &sCtx, (void*)pFKey->zTo); } @@ -107914,7 +109777,7 @@ static void renameTableFunc( } if( rc!=SQLITE_OK ){ if( sParse.zErrMsg ){ - renameColumnParseError(context, 0, argv[1], argv[2], &sParse); + renameColumnParseError(context, "", argv[1], argv[2], &sParse); }else{ sqlite3_result_error_code(context, rc); } @@ -107931,6 +109794,121 @@ static void renameTableFunc( return; } +static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){ + renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr); + } + return WRC_Continue; +} + +/* +** The implementation of an SQL scalar function that rewrites DDL statements +** so that any string literals that use double-quotes are modified so that +** they use single quotes. +** +** Two arguments must be passed: +** +** 0: Database name ("main", "temp" etc.). +** 1: SQL statement to edit. +** +** The returned value is the modified SQL statement. For example, given +** the database schema: +** +** CREATE TABLE t1(a, b, c); +** +** SELECT sqlite_rename_quotefix('main', +** 'CREATE VIEW v1 AS SELECT "a", "string" FROM t1' +** ); +** +** returns the string: +** +** CREATE VIEW v1 AS SELECT "a", 'string' FROM t1 +*/ +static void renameQuotefixFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + char const *zDb = (const char*)sqlite3_value_text(argv[0]); + char const *zInput = (const char*)sqlite3_value_text(argv[1]); + +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; + db->xAuth = 0; +#endif + + sqlite3BtreeEnterAll(db); + + UNUSED_PARAMETER(NotUsed); + if( zDb && zInput ){ + int rc; + Parse sParse; + rc = renameParseSql(&sParse, zDb, db, zInput, 0); + + if( rc==SQLITE_OK ){ + RenameCtx sCtx; + Walker sWalker; + + /* Walker to find tokens that need to be replaced. */ + memset(&sCtx, 0, sizeof(RenameCtx)); + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = &sParse; + sWalker.xExprCallback = renameQuotefixExprCb; + sWalker.xSelectCallback = renameColumnSelectCb; + sWalker.u.pRename = &sCtx; + + if( sParse.pNewTable ){ + if( IsView(sParse.pNewTable) ){ + Select *pSelect = sParse.pNewTable->u.view.pSelect; + pSelect->selFlags &= ~SF_View; + sParse.rc = SQLITE_OK; + sqlite3SelectPrep(&sParse, pSelect, 0); + rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc); + if( rc==SQLITE_OK ){ + sqlite3WalkSelect(&sWalker, pSelect); + } + }else{ + int i; + sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck); +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + for(i=0; inCol; i++){ + sqlite3WalkExpr(&sWalker, + sqlite3ColumnExpr(sParse.pNewTable, + &sParse.pNewTable->aCol[i])); + } +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + } + }else if( sParse.pNewIndex ){ + sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr); + sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere); + }else{ +#ifndef SQLITE_OMIT_TRIGGER + rc = renameResolveTrigger(&sParse); + if( rc==SQLITE_OK ){ + renameWalkTrigger(&sWalker, sParse.pNewTrigger); + } +#endif /* SQLITE_OMIT_TRIGGER */ + } + + if( rc==SQLITE_OK ){ + rc = renameEditSql(context, &sCtx, zInput, 0, 0); + } + renameTokenFree(db, sCtx.pList); + } + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(context, rc); + } + renameParseCleanup(&sParse); + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif + + sqlite3BtreeLeaveAll(db); +} + /* ** An SQL user function that checks that there are no parse or symbol ** resolution problems in a CREATE TRIGGER|TABLE|VIEW|INDEX statement. @@ -107943,6 +109921,8 @@ static void renameTableFunc( ** 2: Object type ("view", "table", "trigger" or "index"). ** 3: Object name. ** 4: True if object is from temp schema. +** 5: "when" part of error message. +** 6: True to disable the DQS quirk when parsing SQL. ** ** Unless it finds an error, this function normally returns NULL. However, it ** returns integer value 1 if: @@ -107960,6 +109940,8 @@ static void renameTableTest( char const *zInput = (const char*)sqlite3_value_text(argv[1]); int bTemp = sqlite3_value_int(argv[4]); int isLegacy = (db->flags & SQLITE_LegacyAlter); + char const *zWhen = (const char*)sqlite3_value_text(argv[5]); + int bNoDQS = sqlite3_value_int(argv[6]); #ifndef SQLITE_OMIT_AUTHORIZATION sqlite3_xauth xAuth = db->xAuth; @@ -107967,16 +109949,20 @@ static void renameTableTest( #endif UNUSED_PARAMETER(NotUsed); + if( zDb && zInput ){ int rc; Parse sParse; + int flags = db->flags; + if( bNoDQS ) db->flags &= ~(SQLITE_DqsDML|SQLITE_DqsDDL); rc = renameParseSql(&sParse, zDb, db, zInput, bTemp); + db->flags |= (flags & (SQLITE_DqsDML|SQLITE_DqsDDL)); if( rc==SQLITE_OK ){ - if( isLegacy==0 && sParse.pNewTable && sParse.pNewTable->pSelect ){ + if( isLegacy==0 && sParse.pNewTable && IsView(sParse.pNewTable) ){ NameContext sNC; memset(&sNC, 0, sizeof(sNC)); sNC.pParse = &sParse; - sqlite3SelectPrep(&sParse, sParse.pNewTable->pSelect, &sNC); + sqlite3SelectPrep(&sParse, sParse.pNewTable->u.view.pSelect, &sNC); if( sParse.nErr ) rc = sParse.rc; } @@ -107992,8 +109978,8 @@ static void renameTableTest( } } - if( rc!=SQLITE_OK ){ - renameColumnParseError(context, 1, argv[2], argv[3], &sParse); + if( rc!=SQLITE_OK && zWhen ){ + renameColumnParseError(context, zWhen, argv[2], argv[3],&sParse); } renameParseCleanup(&sParse); } @@ -108003,14 +109989,226 @@ static void renameTableTest( #endif } +/* +** The implementation of internal UDF sqlite_drop_column(). +** +** Arguments: +** +** argv[0]: An integer - the index of the schema containing the table +** argv[1]: CREATE TABLE statement to modify. +** argv[2]: An integer - the index of the column to remove. +** +** The value returned is a string containing the CREATE TABLE statement +** with column argv[2] removed. +*/ +static void dropColumnFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + int iSchema = sqlite3_value_int(argv[0]); + const char *zSql = (const char*)sqlite3_value_text(argv[1]); + int iCol = sqlite3_value_int(argv[2]); + const char *zDb = db->aDb[iSchema].zDbSName; + int rc; + Parse sParse; + RenameToken *pCol; + Table *pTab; + const char *zEnd; + char *zNew = 0; + +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; + db->xAuth = 0; +#endif + + UNUSED_PARAMETER(NotUsed); + rc = renameParseSql(&sParse, zDb, db, zSql, iSchema==1); + if( rc!=SQLITE_OK ) goto drop_column_done; + pTab = sParse.pNewTable; + if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){ + /* This can happen if the sqlite_schema table is corrupt */ + rc = SQLITE_CORRUPT_BKPT; + goto drop_column_done; + } + + pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName); + if( iColnCol-1 ){ + RenameToken *pEnd; + pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName); + zEnd = (const char*)pEnd->t.z; + }else{ + assert( IsOrdinaryTable(pTab) ); + zEnd = (const char*)&zSql[pTab->u.tab.addColOffset]; + while( ALWAYS(pCol->t.z[0]!=0) && pCol->t.z[0]!=',' ) pCol->t.z--; + } + + zNew = sqlite3MPrintf(db, "%.*s%s", pCol->t.z-zSql, zSql, zEnd); + sqlite3_result_text(context, zNew, -1, SQLITE_TRANSIENT); + sqlite3_free(zNew); + +drop_column_done: + renameParseCleanup(&sParse); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(context, rc); + } +} + +/* +** This function is called by the parser upon parsing an +** +** ALTER TABLE pSrc DROP COLUMN pName +** +** statement. Argument pSrc contains the possibly qualified name of the +** table being edited, and token pName the name of the column to drop. +*/ +SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse *pParse, SrcList *pSrc, const Token *pName){ + sqlite3 *db = pParse->db; /* Database handle */ + Table *pTab; /* Table to modify */ + int iDb; /* Index of db containing pTab in aDb[] */ + const char *zDb; /* Database containing pTab ("main" etc.) */ + char *zCol = 0; /* Name of column to drop */ + int iCol; /* Index of column zCol in pTab->aCol[] */ + + /* Look up the table being altered. */ + assert( pParse->pNewTable==0 ); + assert( sqlite3BtreeHoldsAllMutexes(db) ); + if( NEVER(db->mallocFailed) ) goto exit_drop_column; + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_drop_column; + + /* Make sure this is not an attempt to ALTER a view, virtual table or + ** system table. */ + if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_drop_column; + if( SQLITE_OK!=isRealTable(pParse, pTab, 1) ) goto exit_drop_column; + + /* Find the index of the column being dropped. */ + zCol = sqlite3NameFromToken(db, pName); + if( zCol==0 ){ + assert( db->mallocFailed ); + goto exit_drop_column; + } + iCol = sqlite3ColumnIndex(pTab, zCol); + if( iCol<0 ){ + sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zCol); + goto exit_drop_column; + } + + /* Do not allow the user to drop a PRIMARY KEY column or a column + ** constrained by a UNIQUE constraint. */ + if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){ + sqlite3ErrorMsg(pParse, "cannot drop %s column: \"%s\"", + (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE", + zCol + ); + goto exit_drop_column; + } + + /* Do not allow the number of columns to go to zero */ + if( pTab->nCol<=1 ){ + sqlite3ErrorMsg(pParse, "cannot drop column \"%s\": no other columns exist",zCol); + goto exit_drop_column; + } + + /* Edit the sqlite_schema table */ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 ); + zDb = db->aDb[iDb].zDbSName; + renameTestSchema(pParse, zDb, iDb==1, "", 0); + renameFixQuotes(pParse, zDb, iDb==1); + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET " + "sql = sqlite_drop_column(%d, sql, %d) " + "WHERE (type=='table' AND tbl_name=%Q COLLATE nocase)" + , zDb, iDb, iCol, pTab->zName + ); + + /* Drop and reload the database schema. */ + renameReloadSchema(pParse, iDb, INITFLAG_AlterDrop); + renameTestSchema(pParse, zDb, iDb==1, "after drop column", 1); + + /* Edit rows of table on disk */ + if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){ + int i; + int addr; + int reg; + int regRec; + Index *pPk = 0; + int nField = 0; /* Number of non-virtual columns after drop */ + int iCur; + Vdbe *v = sqlite3GetVdbe(pParse); + iCur = pParse->nTab++; + sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite); + addr = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v); + reg = ++pParse->nMem; + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_Rowid, iCur, reg); + pParse->nMem += pTab->nCol; + }else{ + pPk = sqlite3PrimaryKeyIndex(pTab); + pParse->nMem += pPk->nColumn; + for(i=0; inKeyCol; i++){ + sqlite3VdbeAddOp3(v, OP_Column, iCur, i, reg+i+1); + } + nField = pPk->nKeyCol; + } + regRec = ++pParse->nMem; + for(i=0; inCol; i++){ + if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){ + int regOut; + if( pPk ){ + int iPos = sqlite3TableColumnToIndex(pPk, i); + int iColPos = sqlite3TableColumnToIndex(pPk, iCol); + if( iPosnKeyCol ) continue; + regOut = reg+1+iPos-(iPos>iColPos); + }else{ + regOut = reg+1+nField; + } + if( i==pTab->iPKey ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regOut); + }else{ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut); + } + nField++; + } + } + if( nField==0 ){ + /* dbsqlfuzz 5f09e7bcc78b4954d06bf9f2400d7715f48d1fef */ + pParse->nMem++; + sqlite3VdbeAddOp2(v, OP_Null, 0, reg+1); + nField = 1; + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, reg+1, nField, regRec); + if( pPk ){ + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iCur, regRec, reg+1, pPk->nKeyCol); + }else{ + sqlite3VdbeAddOp3(v, OP_Insert, iCur, regRec, reg); + } + sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION); + + sqlite3VdbeAddOp2(v, OP_Next, iCur, addr+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr); + } + +exit_drop_column: + sqlite3DbFree(db, zCol); + sqlite3SrcListDelete(db, pSrc); +} + /* ** Register built-in functions used to help implement ALTER TABLE */ SQLITE_PRIVATE void sqlite3AlterFunctions(void){ static FuncDef aAlterTableFuncs[] = { - INTERNAL_FUNCTION(sqlite_rename_column, 9, renameColumnFunc), - INTERNAL_FUNCTION(sqlite_rename_table, 7, renameTableFunc), - INTERNAL_FUNCTION(sqlite_rename_test, 5, renameTableTest), + INTERNAL_FUNCTION(sqlite_rename_column, 9, renameColumnFunc), + INTERNAL_FUNCTION(sqlite_rename_table, 7, renameTableFunc), + INTERNAL_FUNCTION(sqlite_rename_test, 7, renameTableTest), + INTERNAL_FUNCTION(sqlite_drop_column, 3, dropColumnFunc), + INTERNAL_FUNCTION(sqlite_rename_quotefix,2, renameQuotefixFunc), }; sqlite3InsertBuiltinFuncs(aAlterTableFuncs, ArraySize(aAlterTableFuncs)); } @@ -108453,7 +110651,6 @@ static void statInit( + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample); } #endif - db = sqlite3_context_db_handle(context); p = sqlite3DbMallocZero(db, n); if( p==0 ){ sqlite3_result_error_nomem(context); @@ -108872,28 +111069,19 @@ static void statGet( ** ** I = (K+D-1)/D */ - char *z; - int i; - - char *zRet = sqlite3MallocZero( (p->nKeyCol+1)*25 ); - if( zRet==0 ){ - sqlite3_result_error_nomem(context); - return; - } + sqlite3_str sStat; /* Text of the constructed "stat" line */ + int i; /* Loop counter */ - sqlite3_snprintf(24, zRet, "%llu", + sqlite3StrAccumInit(&sStat, 0, 0, 0, (p->nKeyCol+1)*100); + sqlite3_str_appendf(&sStat, "%llu", p->nSkipAhead ? (u64)p->nEst : (u64)p->nRow); - z = zRet + sqlite3Strlen30(zRet); for(i=0; inKeyCol; i++){ u64 nDistinct = p->current.anDLt[i] + 1; u64 iVal = (p->nRow + nDistinct - 1) / nDistinct; - sqlite3_snprintf(24, z, " %llu", iVal); - z += sqlite3Strlen30(z); + sqlite3_str_appendf(&sStat, " %llu", iVal); assert( p->current.anEq[i] ); } - assert( z[0]=='\0' && z>zRet ); - - sqlite3_result_text(context, zRet, -1, sqlite3_free); + sqlite3ResultStrAccum(context, &sStat); } #ifdef SQLITE_ENABLE_STAT4 else if( eCall==STAT_GET_ROWID ){ @@ -108912,6 +111100,8 @@ static void statGet( } }else{ tRowcnt *aCnt = 0; + sqlite3_str sStat; + int i; assert( p->iGetnSample ); switch( eCall ){ @@ -108923,23 +111113,12 @@ static void statGet( break; } } - - { - char *zRet = sqlite3MallocZero(p->nCol * 25); - if( zRet==0 ){ - sqlite3_result_error_nomem(context); - }else{ - int i; - char *z = zRet; - for(i=0; inCol; i++){ - sqlite3_snprintf(24, z, "%llu ", (u64)aCnt[i]); - z += sqlite3Strlen30(z); - } - assert( z[0]=='\0' && z>zRet ); - z[-1] = '\0'; - sqlite3_result_text(context, zRet, -1, sqlite3_free); - } + sqlite3StrAccumInit(&sStat, 0, 0, 0, p->nCol*100); + for(i=0; inCol; i++){ + sqlite3_str_appendf(&sStat, "%llu ", (u64)aCnt[i]); } + if( sStat.nChar ) sStat.nChar--; + sqlite3ResultStrAccum(context, &sStat); } #endif /* SQLITE_ENABLE_STAT4 */ #ifndef SQLITE_DEBUG @@ -108988,7 +111167,7 @@ static void analyzeVdbeCommentIndexWithColumnName( }else if( i==XN_EXPR ){ VdbeComment((v,"%s.expr(%d)",pIdx->zName, k)); }else{ - VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zName)); + VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName)); } } #else @@ -109035,7 +111214,7 @@ static void analyzeOneTable( if( v==0 || NEVER(pTab==0) ){ return; } - if( pTab->tnum==0 ){ + if( !IsOrdinaryTable(pTab) ){ /* Do not gather statistics on views or virtual tables */ return; } @@ -109860,9 +112039,12 @@ static int loadStatTbl( */ static int loadStat4(sqlite3 *db, const char *zDb){ int rc = SQLITE_OK; /* Result codes from subroutines */ + const Table *pStat4; assert( db->lookaside.bDisable ); - if( sqlite3FindTable(db, "sqlite_stat4", zDb) ){ + if( (pStat4 = sqlite3FindTable(db, "sqlite_stat4", zDb))!=0 + && IsOrdinaryTable(pStat4) + ){ rc = loadStatTbl(db, "SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx", "SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlite_stat4", @@ -109899,6 +112081,7 @@ SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){ char *zSql; int rc = SQLITE_OK; Schema *pSchema = db->aDb[iDb].pSchema; + const Table *pStat1; assert( iDb>=0 && iDbnDb ); assert( db->aDb[iDb].pBt!=0 ); @@ -109921,7 +112104,9 @@ SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){ /* Load new statistics out of the sqlite_stat1 table */ sInfo.db = db; sInfo.zDatabase = db->aDb[iDb].zDbSName; - if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)!=0 ){ + if( (pStat1 = sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)) + && IsOrdinaryTable(pStat1) + ){ zSql = sqlite3MPrintf(db, "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase); if( zSql==0 ){ @@ -110061,7 +112246,7 @@ static void attachFunc( if( zFile==0 ) zFile = ""; if( zName==0 ) zName = ""; -#ifdef SQLITE_ENABLE_DESERIALIZE +#ifndef SQLITE_OMIT_DESERIALIZE # define REOPEN_AS_MEMDB(db) (db->init.reopenMemdb) #else # define REOPEN_AS_MEMDB(db) (0) @@ -110312,9 +112497,9 @@ static void codeAttach( sName.pParse = pParse; if( - SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) || - SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) || - SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey)) + SQLITE_OK!=resolveAttachExpr(&sName, pFilename) || + SQLITE_OK!=resolveAttachExpr(&sName, pDbname) || + SQLITE_OK!=resolveAttachExpr(&sName, pKey) ){ goto attach_end; } @@ -110323,6 +112508,7 @@ static void codeAttach( if( pAuthArg ){ char *zAuthArg; if( pAuthArg->op==TK_STRING ){ + assert( !ExprHasProperty(pAuthArg, EP_IntValue) ); zAuthArg = pAuthArg->u.zToken; }else{ zAuthArg = 0; @@ -110399,6 +112585,65 @@ SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *p } #endif /* SQLITE_OMIT_ATTACH */ +/* +** Expression callback used by sqlite3FixAAAA() routines. +*/ +static int fixExprCb(Walker *p, Expr *pExpr){ + DbFixer *pFix = p->u.pFix; + if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL); + if( pExpr->op==TK_VARIABLE ){ + if( pFix->pParse->db->init.busy ){ + pExpr->op = TK_NULL; + }else{ + sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType); + return WRC_Abort; + } + } + return WRC_Continue; +} + +/* +** Select callback used by sqlite3FixAAAA() routines. +*/ +static int fixSelectCb(Walker *p, Select *pSelect){ + DbFixer *pFix = p->u.pFix; + int i; + SrcItem *pItem; + sqlite3 *db = pFix->pParse->db; + int iDb = sqlite3FindDbName(db, pFix->zDb); + SrcList *pList = pSelect->pSrc; + + if( NEVER(pList==0) ) return WRC_Continue; + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pFix->bTemp==0 ){ + if( pItem->zDatabase ){ + if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){ + sqlite3ErrorMsg(pFix->pParse, + "%s %T cannot reference objects in database %s", + pFix->zType, pFix->pName, pItem->zDatabase); + return WRC_Abort; + } + sqlite3DbFree(db, pItem->zDatabase); + pItem->zDatabase = 0; + pItem->fg.notCte = 1; + } + pItem->pSchema = pFix->pSchema; + pItem->fg.fromDDL = 1; + } +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) + if( sqlite3WalkExpr(&pFix->w, pList->a[i].pOn) ) return WRC_Abort; +#endif + } + if( pSelect->pWith ){ + for(i=0; ipWith->nCte; i++){ + if( sqlite3WalkSelect(p, pSelect->pWith->a[i].pSelect) ){ + return WRC_Abort; + } + } + } + return WRC_Continue; +} + /* ** Initialize a DbFixer structure. This routine must be called prior ** to passing the structure to one of the sqliteFixAAAA() routines below. @@ -110410,9 +112655,7 @@ SQLITE_PRIVATE void sqlite3FixInit( const char *zType, /* "view", "trigger", or "index" */ const Token *pName /* Name of the view, trigger, or index */ ){ - sqlite3 *db; - - db = pParse->db; + sqlite3 *db = pParse->db; assert( db->nDb>iDb ); pFix->pParse = pParse; pFix->zDb = db->aDb[iDb].zDbSName; @@ -110420,6 +112663,13 @@ SQLITE_PRIVATE void sqlite3FixInit( pFix->zType = zType; pFix->pName = pName; pFix->bTemp = (iDb==1); + pFix->w.pParse = pParse; + pFix->w.xExprCallback = fixExprCb; + pFix->w.xSelectCallback = fixSelectCb; + pFix->w.xSelectCallback2 = sqlite3WalkWinDefnDummyCallback; + pFix->w.walkerDepth = 0; + pFix->w.eCode = 0; + pFix->w.u.pFix = pFix; } /* @@ -110440,115 +112690,27 @@ SQLITE_PRIVATE int sqlite3FixSrcList( DbFixer *pFix, /* Context of the fixation */ SrcList *pList /* The Source list to check and modify */ ){ - int i; - struct SrcList_item *pItem; - sqlite3 *db = pFix->pParse->db; - int iDb = sqlite3FindDbName(db, pFix->zDb); - - if( NEVER(pList==0) ) return 0; - - for(i=0, pItem=pList->a; inSrc; i++, pItem++){ - if( pFix->bTemp==0 ){ - if( pItem->zDatabase && iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){ - sqlite3ErrorMsg(pFix->pParse, - "%s %T cannot reference objects in database %s", - pFix->zType, pFix->pName, pItem->zDatabase); - return 1; - } - sqlite3DbFree(db, pItem->zDatabase); - pItem->zDatabase = 0; - pItem->pSchema = pFix->pSchema; - pItem->fg.fromDDL = 1; - } -#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) - if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1; - if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1; -#endif - if( pItem->fg.isTabFunc && sqlite3FixExprList(pFix, pItem->u1.pFuncArg) ){ - return 1; - } + int res = 0; + if( pList ){ + Select s; + memset(&s, 0, sizeof(s)); + s.pSrc = pList; + res = sqlite3WalkSelect(&pFix->w, &s); } - return 0; + return res; } #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) SQLITE_PRIVATE int sqlite3FixSelect( DbFixer *pFix, /* Context of the fixation */ Select *pSelect /* The SELECT statement to be fixed to one database */ ){ - while( pSelect ){ - if( sqlite3FixExprList(pFix, pSelect->pEList) ){ - return 1; - } - if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){ - return 1; - } - if( sqlite3FixExpr(pFix, pSelect->pWhere) ){ - return 1; - } - if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){ - return 1; - } - if( sqlite3FixExpr(pFix, pSelect->pHaving) ){ - return 1; - } - if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){ - return 1; - } - if( sqlite3FixExpr(pFix, pSelect->pLimit) ){ - return 1; - } - if( pSelect->pWith ){ - int i; - for(i=0; ipWith->nCte; i++){ - if( sqlite3FixSelect(pFix, pSelect->pWith->a[i].pSelect) ){ - return 1; - } - } - } - pSelect = pSelect->pPrior; - } - return 0; + return sqlite3WalkSelect(&pFix->w, pSelect); } SQLITE_PRIVATE int sqlite3FixExpr( DbFixer *pFix, /* Context of the fixation */ Expr *pExpr /* The expression to be fixed to one database */ ){ - while( pExpr ){ - if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL); - if( pExpr->op==TK_VARIABLE ){ - if( pFix->pParse->db->init.busy ){ - pExpr->op = TK_NULL; - }else{ - sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType); - return 1; - } - } - if( ExprHasProperty(pExpr, EP_TokenOnly|EP_Leaf) ) break; - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ - if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1; - }else{ - if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1; - } - if( sqlite3FixExpr(pFix, pExpr->pRight) ){ - return 1; - } - pExpr = pExpr->pLeft; - } - return 0; -} -SQLITE_PRIVATE int sqlite3FixExprList( - DbFixer *pFix, /* Context of the fixation */ - ExprList *pList /* The expression to be fixed to one database */ -){ - int i; - struct ExprList_item *pItem; - if( pList==0 ) return 0; - for(i=0, pItem=pList->a; inExpr; i++, pItem++){ - if( sqlite3FixExpr(pFix, pItem->pExpr) ){ - return 1; - } - } - return 0; + return sqlite3WalkExpr(&pFix->w, pExpr); } #endif @@ -110558,32 +112720,30 @@ SQLITE_PRIVATE int sqlite3FixTriggerStep( TriggerStep *pStep /* The trigger step be fixed to one database */ ){ while( pStep ){ - if( sqlite3FixSelect(pFix, pStep->pSelect) ){ - return 1; - } - if( sqlite3FixExpr(pFix, pStep->pWhere) ){ - return 1; - } - if( sqlite3FixExprList(pFix, pStep->pExprList) ){ - return 1; - } - if( pStep->pFrom && sqlite3FixSrcList(pFix, pStep->pFrom) ){ + if( sqlite3WalkSelect(&pFix->w, pStep->pSelect) + || sqlite3WalkExpr(&pFix->w, pStep->pWhere) + || sqlite3WalkExprList(&pFix->w, pStep->pExprList) + || sqlite3FixSrcList(pFix, pStep->pFrom) + ){ return 1; } #ifndef SQLITE_OMIT_UPSERT - if( pStep->pUpsert ){ - Upsert *pUp = pStep->pUpsert; - if( sqlite3FixExprList(pFix, pUp->pUpsertTarget) - || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere) - || sqlite3FixExprList(pFix, pUp->pUpsertSet) - || sqlite3FixExpr(pFix, pUp->pUpsertWhere) - ){ - return 1; + { + Upsert *pUp; + for(pUp=pStep->pUpsert; pUp; pUp=pUp->pNextUpsert){ + if( sqlite3WalkExprList(&pFix->w, pUp->pUpsertTarget) + || sqlite3WalkExpr(&pFix->w, pUp->pUpsertTargetWhere) + || sqlite3WalkExprList(&pFix->w, pUp->pUpsertSet) + || sqlite3WalkExpr(&pFix->w, pUp->pUpsertWhere) + ){ + return 1; + } } } #endif pStep = pStep->pNext; } + return 0; } #endif @@ -110735,7 +112895,6 @@ SQLITE_PRIVATE void sqlite3AuthRead( Schema *pSchema, /* The schema of the expression */ SrcList *pTabList /* All table that pExpr might refer to */ ){ - sqlite3 *db = pParse->db; Table *pTab = 0; /* The table being read */ const char *zCol; /* Name of the column of the table */ int iSrc; /* Index in pTabList->a[] of table being read */ @@ -110743,8 +112902,8 @@ SQLITE_PRIVATE void sqlite3AuthRead( int iCol; /* Index of column in table */ assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER ); - assert( !IN_RENAME_OBJECT || db->xAuth==0 ); - if( db->xAuth==0 ) return; + assert( !IN_RENAME_OBJECT ); + assert( pParse->db->xAuth!=0 ); iDb = sqlite3SchemaToIndex(pParse->db, pSchema); if( iDb<0 ){ /* An attempt to read a column out of a subquery or other @@ -110756,7 +112915,7 @@ SQLITE_PRIVATE void sqlite3AuthRead( pTab = pParse->pTriggerTab; }else{ assert( pTabList ); - for(iSrc=0; ALWAYS(iSrcnSrc); iSrc++){ + for(iSrc=0; iSrcnSrc; iSrc++){ if( pExpr->iTable==pTabList->a[iSrc].iCursor ){ pTab = pTabList->a[iSrc].pTab; break; @@ -110764,18 +112923,18 @@ SQLITE_PRIVATE void sqlite3AuthRead( } } iCol = pExpr->iColumn; - if( NEVER(pTab==0) ) return; + if( pTab==0 ) return; if( iCol>=0 ){ assert( iColnCol ); - zCol = pTab->aCol[iCol].zName; + zCol = pTab->aCol[iCol].zCnName; }else if( pTab->iPKey>=0 ){ assert( pTab->iPKeynCol ); - zCol = pTab->aCol[pTab->iPKey].zName; + zCol = pTab->aCol[pTab->iPKey].zCnName; }else{ zCol = "ROWID"; } - assert( iDb>=0 && iDbnDb ); + assert( iDb>=0 && iDbdb->nDb ); if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){ pExpr->op = TK_NULL; } @@ -110801,11 +112960,7 @@ SQLITE_PRIVATE int sqlite3AuthCheck( ** or if the parser is being invoked from within sqlite3_declare_vtab. */ assert( !IN_RENAME_OBJECT || db->xAuth==0 ); - if( db->init.busy || IN_SPECIAL_PARSE ){ - return SQLITE_OK; - } - - if( db->xAuth==0 ){ + if( db->xAuth==0 || db->init.busy || IN_SPECIAL_PARSE ){ return SQLITE_OK; } @@ -110914,7 +113069,7 @@ struct TableLock { ** code to make the lock occur is generated by a later call to ** codeTableLocks() which occurs during sqlite3FinishCoding(). */ -SQLITE_PRIVATE void sqlite3TableLock( +static SQLITE_NOINLINE void lockTable( Parse *pParse, /* Parsing context */ int iDb, /* Index of the database containing the table to lock */ Pgno iTab, /* Root page number of the table to be locked */ @@ -110927,8 +113082,6 @@ SQLITE_PRIVATE void sqlite3TableLock( TableLock *p; assert( iDb>=0 ); - if( iDb==1 ) return; - if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return; pToplevel = sqlite3ParseToplevel(pParse); for(i=0; inTableLock; i++){ p = &pToplevel->aTableLock[i]; @@ -110952,6 +113105,17 @@ SQLITE_PRIVATE void sqlite3TableLock( sqlite3OomFault(pToplevel->db); } } +SQLITE_PRIVATE void sqlite3TableLock( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database containing the table to lock */ + Pgno iTab, /* Root page number of the table to be locked */ + u8 isWriteLock, /* True for a write lock */ + const char *zName /* Name of the table to be locked */ +){ + if( iDb==1 ) return; + if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return; + lockTable(pParse, iDb, iTab, isWriteLock, zName); +} /* ** Code an OP_TableLock instruction for each table locked by the @@ -111011,10 +113175,40 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){ /* Begin by generating some termination code at the end of the ** vdbe program */ - v = sqlite3GetVdbe(pParse); + v = pParse->pVdbe; + if( v==0 ){ + if( db->init.busy ){ + pParse->rc = SQLITE_DONE; + return; + } + v = sqlite3GetVdbe(pParse); + if( v==0 ) pParse->rc = SQLITE_ERROR; + } assert( !pParse->isMultiWrite || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort)); if( v ){ + if( pParse->bReturning ){ + Returning *pReturning = pParse->u1.pReturning; + int addrRewind; + int i; + int reg; + + if( pReturning->nRetCol==0 ){ + assert( CORRUPT_DB ); + }else{ + addrRewind = + sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur); + VdbeCoverage(v); + reg = pReturning->iRetReg; + for(i=0; inRetCol; i++){ + sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i); + } + sqlite3VdbeAddOp2(v, OP_ResultRow, reg, i); + sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1); + VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrRewind); + } + } sqlite3VdbeAddOp0(v, OP_Halt); #if SQLITE_USER_AUTHENTICATION @@ -111092,12 +113286,20 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){ } } + if( pParse->bReturning ){ + Returning *pRet = pParse->u1.pReturning; + if( pRet->nRetCol==0 ){ + assert( CORRUPT_DB ); + }else{ + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol); + } + } + /* Finally, jump back to the beginning of the executable code. */ sqlite3VdbeGoto(v, 1); } } - /* Get the VDBE program ready for execution */ if( v && pParse->nErr==0 && !db->mallocFailed ){ @@ -111114,20 +113316,22 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){ /* ** Run the parser and code generator recursively in order to generate ** code for the SQL statement given onto the end of the pParse context -** currently under construction. When the parser is run recursively -** this way, the final OP_Halt is not appended and other initialization -** and finalization steps are omitted because those are handling by the -** outermost parser. +** currently under construction. Notes: ** -** Not everything is nestable. This facility is designed to permit -** INSERT, UPDATE, and DELETE operations against the schema table. Use -** care if you decide to try to use this routine for some other purposes. +** * The final OP_Halt is not appended and other initialization +** and finalization steps are omitted because those are handling by the +** outermost parser. +** +** * Built-in SQL functions always take precedence over application-defined +** SQL functions. In other words, it is not possible to override a +** built-in function. */ SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){ va_list ap; char *zSql; char *zErrMsg = 0; sqlite3 *db = pParse->db; + u32 savedDbFlags = db->mDbFlags; char saveBuf[PARSE_TAIL_SZ]; if( pParse->nErr ) return; @@ -111146,7 +113350,9 @@ SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){ pParse->nested++; memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ); memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ); + db->mDbFlags |= DBFLAG_PreferBuiltin; sqlite3RunParser(pParse, zSql, &zErrMsg); + db->mDbFlags = savedDbFlags; sqlite3DbFree(db, zErrMsg); sqlite3DbFree(db, zSql); memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ); @@ -111204,17 +113410,17 @@ SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const cha p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName); if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){ if( i==1 ){ - if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0 - || sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 - || sqlite3StrICmp(zName+7, &DFLT_SCHEMA_TABLE[7])==0 + if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 + || sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 + || sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){ p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, - DFLT_TEMP_SCHEMA_TABLE); + LEGACY_TEMP_SCHEMA_TABLE); } }else{ - if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){ + if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){ p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, - DFLT_SCHEMA_TABLE); + LEGACY_SCHEMA_TABLE); } } } @@ -111232,11 +113438,11 @@ SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const cha if( p ) break; } if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){ - if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){ - p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, DFLT_SCHEMA_TABLE); - }else if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0 ){ + if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){ + p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, LEGACY_SCHEMA_TABLE); + }else if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){ p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, - DFLT_TEMP_SCHEMA_TABLE); + LEGACY_TEMP_SCHEMA_TABLE); } } } @@ -111276,12 +113482,13 @@ SQLITE_PRIVATE Table *sqlite3LocateTable( /* If zName is the not the name of a table in the schema created using ** CREATE, then check to see if it is the name of an virtual table that ** can be an eponymous virtual table. */ - if( pParse->disableVtab==0 ){ + if( pParse->disableVtab==0 && db->init.busy==0 ){ Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName); if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){ pMod = sqlite3PragmaVtabRegister(db, zName); } if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){ + testcase( pMod->pEpoTab==0 ); return pMod->pEpoTab; } } @@ -111299,6 +113506,8 @@ SQLITE_PRIVATE Table *sqlite3LocateTable( }else{ sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName); } + }else{ + assert( HasRowid(p) || p->iPKey<0 ); } return p; @@ -111316,7 +113525,7 @@ SQLITE_PRIVATE Table *sqlite3LocateTable( SQLITE_PRIVATE Table *sqlite3LocateTableItem( Parse *pParse, u32 flags, - struct SrcList_item *p + SrcItem *p ){ const char *zDb; assert( p->pSchema==0 || p->zDatabase==0 ); @@ -111329,6 +113538,22 @@ SQLITE_PRIVATE Table *sqlite3LocateTableItem( return sqlite3LocateTable(pParse, flags, p->zName, zDb); } +/* +** Return the preferred table name for system tables. Translate legacy +** names into the new preferred names, as appropriate. +*/ +SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char *zName){ + if( sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){ + if( sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){ + return PREFERRED_SCHEMA_TABLE; + } + if( sqlite3StrICmp(zName+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){ + return PREFERRED_TEMP_SCHEMA_TABLE; + } + } + return zName; +} + /* ** Locate the in-memory structure that describes ** a particular index given the name of that index @@ -111493,6 +113718,84 @@ SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){ db->mDbFlags &= ~DBFLAG_SchemaChange; } +/* +** Set the expression associated with a column. This is usually +** the DEFAULT value, but might also be the expression that computes +** the value for a generated column. +*/ +SQLITE_PRIVATE void sqlite3ColumnSetExpr( + Parse *pParse, /* Parsing context */ + Table *pTab, /* The table containing the column */ + Column *pCol, /* The column to receive the new DEFAULT expression */ + Expr *pExpr /* The new default expression */ +){ + ExprList *pList; + assert( IsOrdinaryTable(pTab) ); + pList = pTab->u.tab.pDfltList; + if( pCol->iDflt==0 + || NEVER(pList==0) + || NEVER(pList->nExpriDflt) + ){ + pCol->iDflt = pList==0 ? 1 : pList->nExpr+1; + pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr); + }else{ + sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr); + pList->a[pCol->iDflt-1].pExpr = pExpr; + } +} + +/* +** Return the expression associated with a column. The expression might be +** the DEFAULT clause or the AS clause of a generated column. +** Return NULL if the column has no associated expression. +*/ +SQLITE_PRIVATE Expr *sqlite3ColumnExpr(Table *pTab, Column *pCol){ + if( pCol->iDflt==0 ) return 0; + if( NEVER(!IsOrdinaryTable(pTab)) ) return 0; + if( NEVER(pTab->u.tab.pDfltList==0) ) return 0; + if( NEVER(pTab->u.tab.pDfltList->nExpriDflt) ) return 0; + return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr; +} + +/* +** Set the collating sequence name for a column. +*/ +SQLITE_PRIVATE void sqlite3ColumnSetColl( + sqlite3 *db, + Column *pCol, + const char *zColl +){ + i64 nColl; + i64 n; + char *zNew; + assert( zColl!=0 ); + n = sqlite3Strlen30(pCol->zCnName) + 1; + if( pCol->colFlags & COLFLAG_HASTYPE ){ + n += sqlite3Strlen30(pCol->zCnName+n) + 1; + } + nColl = sqlite3Strlen30(zColl) + 1; + zNew = sqlite3DbRealloc(db, pCol->zCnName, nColl+n); + if( zNew ){ + pCol->zCnName = zNew; + memcpy(pCol->zCnName + n, zColl, nColl); + pCol->colFlags |= COLFLAG_HASCOLL; + } +} + +/* +** Return the collating squence name for a column +*/ +SQLITE_PRIVATE const char *sqlite3ColumnColl(Column *pCol){ + const char *z; + if( (pCol->colFlags & COLFLAG_HASCOLL)==0 ) return 0; + z = pCol->zCnName; + while( *z ){ z++; } + if( pCol->colFlags & COLFLAG_HASTYPE ){ + do{ z++; }while( *z ); + } + return z+1; +} + /* ** Delete memory allocated for the column names of a table or view (the ** Table.aCol[] array). @@ -111503,12 +113806,20 @@ SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){ assert( pTable!=0 ); if( (pCol = pTable->aCol)!=0 ){ for(i=0; inCol; i++, pCol++){ - assert( pCol->zName==0 || pCol->hName==sqlite3StrIHash(pCol->zName) ); - sqlite3DbFree(db, pCol->zName); - sqlite3ExprDelete(db, pCol->pDflt); - sqlite3DbFree(db, pCol->zColl); + assert( pCol->zCnName==0 || pCol->hName==sqlite3StrIHash(pCol->zCnName) ); + sqlite3DbFree(db, pCol->zCnName); } sqlite3DbFree(db, pTable->aCol); + if( IsOrdinaryTable(pTable) ){ + sqlite3ExprListDelete(db, pTable->u.tab.pDfltList); + } + if( db==0 || db->pnBytesFreed==0 ){ + pTable->aCol = 0; + pTable->nCol = 0; + if( IsOrdinaryTable(pTable) ){ + pTable->u.tab.pDfltList = 0; + } + } } } @@ -111560,19 +113871,25 @@ static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){ sqlite3FreeIndex(db, pIndex); } - /* Delete any foreign keys attached to this table. */ - sqlite3FkDelete(db, pTable); + if( IsOrdinaryTable(pTable) ){ + sqlite3FkDelete(db, pTable); + } +#ifndef SQLITE_OMIT_VIRTUAL_TABLE + else if( IsVirtual(pTable) ){ + sqlite3VtabClear(db, pTable); + } +#endif + else{ + assert( IsView(pTable) ); + sqlite3SelectDelete(db, pTable->u.view.pSelect); + } /* Delete the Table structure itself. */ sqlite3DeleteColumnNames(db, pTable); sqlite3DbFree(db, pTable->zName); sqlite3DbFree(db, pTable->zColAff); - sqlite3SelectDelete(db, pTable->pSelect); sqlite3ExprListDelete(db, pTable->pCheck); -#ifndef SQLITE_OMIT_VIRTUALTABLE - sqlite3VtabClear(db, pTable); -#endif sqlite3DbFree(db, pTable); /* Verify that no lookaside memory was used by schema tables */ @@ -111618,10 +113935,10 @@ SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char ** are not \000 terminated and are not persistent. The returned string ** is \000 terminated and is persistent. */ -SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, Token *pName){ +SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, const Token *pName){ char *zName; if( pName ){ - zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n); + zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n); sqlite3Dequote(zName); }else{ zName = 0; @@ -111635,7 +113952,7 @@ SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, Token *pName){ */ SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *p, int iDb){ Vdbe *v = sqlite3GetVdbe(p); - sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, DFLT_SCHEMA_TABLE); + sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, LEGACY_SCHEMA_TABLE); sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5); if( p->nTab==0 ){ p->nTab = 1; @@ -111715,7 +114032,7 @@ SQLITE_PRIVATE int sqlite3TwoPartName( return -1; } }else{ - assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT + assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE || (db->mDbFlags & DBFLAG_Vacuum)!=0); iDb = db->init.iDb; *pUnqual = pName1; @@ -111884,6 +114201,23 @@ SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){ } #endif +/* +** Insert a single OP_JournalMode query opcode in order to force the +** prepared statement to return false for sqlite3_stmt_readonly(). This +** is used by CREATE TABLE IF NOT EXISTS and similar if the table already +** exists, so that the prepared statement for CREATE TABLE IF NOT EXISTS +** will return false for sqlite3_stmt_readonly() even if that statement +** is a read-only no-op. +*/ +static void sqlite3ForceNotReadOnly(Parse *pParse){ + int iReg = ++pParse->nMem; + Vdbe *v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY); + sqlite3VdbeUsesBtree(v, 0); + } +} + /* ** Begin constructing a new table representation in memory. This is ** the first of several action routines that get called in response @@ -111983,6 +114317,7 @@ SQLITE_PRIVATE void sqlite3StartTable( }else{ assert( !db->init.busy || CORRUPT_DB ); sqlite3CodeVerifySchema(pParse, iDb); + sqlite3ForceNotReadOnly(pParse); } goto begin_table_error; } @@ -112011,17 +114346,6 @@ SQLITE_PRIVATE void sqlite3StartTable( assert( pParse->pNewTable==0 ); pParse->pNewTable = pTable; - /* If this is the magic sqlite_sequence table used by autoincrement, - ** then record a pointer to this table in the main database structure - ** so that INSERT can find the table easily. - */ -#ifndef SQLITE_OMIT_AUTOINCREMENT - if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){ - assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); - pTable->pSchema->pSeqTab = pTable; - } -#endif - /* Begin generating the code that will insert the table record into ** the schema table. Note in particular that we must go ahead ** and allocate the record number for the table entry now. Before any @@ -112074,7 +114398,8 @@ SQLITE_PRIVATE void sqlite3StartTable( }else #endif { - pParse->addrCrTab = + assert( !pParse->bReturning ); + pParse->u1.addrCrTab = sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY); } sqlite3OpenSchemaTable(pParse, iDb); @@ -112090,6 +114415,7 @@ SQLITE_PRIVATE void sqlite3StartTable( /* If an error occurs, we jump here */ begin_table_error: + pParse->checkSchema = 1; sqlite3DbFree(db, zName); return; } @@ -112099,14 +114425,88 @@ SQLITE_PRIVATE void sqlite3StartTable( */ #if SQLITE_ENABLE_HIDDEN_COLUMNS SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){ - if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){ + if( sqlite3_strnicmp(pCol->zCnName, "__hidden__", 10)==0 ){ pCol->colFlags |= COLFLAG_HIDDEN; + if( pTab ) pTab->tabFlags |= TF_HasHidden; }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){ pTab->tabFlags |= TF_OOOHidden; } } #endif +/* +** Name of the special TEMP trigger used to implement RETURNING. The +** name begins with "sqlite_" so that it is guaranteed not to collide +** with any application-generated triggers. +*/ +#define RETURNING_TRIGGER_NAME "sqlite_returning" + +/* +** Clean up the data structures associated with the RETURNING clause. +*/ +static void sqlite3DeleteReturning(sqlite3 *db, Returning *pRet){ + Hash *pHash; + pHash = &(db->aDb[1].pSchema->trigHash); + sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, 0); + sqlite3ExprListDelete(db, pRet->pReturnEL); + sqlite3DbFree(db, pRet); +} + +/* +** Add the RETURNING clause to the parse currently underway. +** +** This routine creates a special TEMP trigger that will fire for each row +** of the DML statement. That TEMP trigger contains a single SELECT +** statement with a result set that is the argument of the RETURNING clause. +** The trigger has the Trigger.bReturning flag and an opcode of +** TK_RETURNING instead of TK_SELECT, so that the trigger code generator +** knows to handle it specially. The TEMP trigger is automatically +** removed at the end of the parse. +** +** When this routine is called, we do not yet know if the RETURNING clause +** is attached to a DELETE, INSERT, or UPDATE, so construct it as a +** RETURNING trigger instead. It will then be converted into the appropriate +** type on the first call to sqlite3TriggersExist(). +*/ +SQLITE_PRIVATE void sqlite3AddReturning(Parse *pParse, ExprList *pList){ + Returning *pRet; + Hash *pHash; + sqlite3 *db = pParse->db; + if( pParse->pNewTrigger ){ + sqlite3ErrorMsg(pParse, "cannot use RETURNING in a trigger"); + }else{ + assert( pParse->bReturning==0 ); + } + pParse->bReturning = 1; + pRet = sqlite3DbMallocZero(db, sizeof(*pRet)); + if( pRet==0 ){ + sqlite3ExprListDelete(db, pList); + return; + } + pParse->u1.pReturning = pRet; + pRet->pParse = pParse; + pRet->pReturnEL = pList; + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3DeleteReturning, pRet); + testcase( pParse->earlyCleanup ); + if( db->mallocFailed ) return; + pRet->retTrig.zName = RETURNING_TRIGGER_NAME; + pRet->retTrig.op = TK_RETURNING; + pRet->retTrig.tr_tm = TRIGGER_AFTER; + pRet->retTrig.bReturning = 1; + pRet->retTrig.pSchema = db->aDb[1].pSchema; + pRet->retTrig.pTabSchema = db->aDb[1].pSchema; + pRet->retTrig.step_list = &pRet->retTStep; + pRet->retTStep.op = TK_RETURNING; + pRet->retTStep.pTrig = &pRet->retTrig; + pRet->retTStep.pExprList = pList; + pHash = &(db->aDb[1].pSchema->trigHash); + assert( sqlite3HashFind(pHash, RETURNING_TRIGGER_NAME)==0 || pParse->nErr ); + if( sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, &pRet->retTrig) + ==&pRet->retTrig ){ + sqlite3OomFault(db); + } +} /* ** Add a new column to the table currently being constructed. @@ -112116,60 +114516,104 @@ SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){ ** first to get things going. Then this routine is called for each ** column. */ -SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName, Token *pType){ +SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token sName, Token sType){ Table *p; int i; char *z; char *zType; Column *pCol; sqlite3 *db = pParse->db; + u8 hName; + Column *aNew; + u8 eType = COLTYPE_CUSTOM; + u8 szEst = 1; + char affinity = SQLITE_AFF_BLOB; + if( (p = pParse->pNewTable)==0 ) return; if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){ sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName); return; } - z = sqlite3DbMallocRaw(db, pName->n + pType->n + 2); + if( !IN_RENAME_OBJECT ) sqlite3DequoteToken(&sName); + + /* Because keywords GENERATE ALWAYS can be converted into indentifiers + ** by the parser, we can sometimes end up with a typename that ends + ** with "generated always". Check for this case and omit the surplus + ** text. */ + if( sType.n>=16 + && sqlite3_strnicmp(sType.z+(sType.n-6),"always",6)==0 + ){ + sType.n -= 6; + while( ALWAYS(sType.n>0) && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--; + if( sType.n>=9 + && sqlite3_strnicmp(sType.z+(sType.n-9),"generated",9)==0 + ){ + sType.n -= 9; + while( sType.n>0 && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--; + } + } + + /* Check for standard typenames. For standard typenames we will + ** set the Column.eType field rather than storing the typename after + ** the column name, in order to save space. */ + if( sType.n>=3 ){ + sqlite3DequoteToken(&sType); + for(i=0; i0) ); if( z==0 ) return; - if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, pName); - memcpy(z, pName->z, pName->n); - z[pName->n] = 0; + if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, &sName); + memcpy(z, sName.z, sName.n); + z[sName.n] = 0; sqlite3Dequote(z); + hName = sqlite3StrIHash(z); for(i=0; inCol; i++){ - if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){ + if( p->aCol[i].hName==hName && sqlite3StrICmp(z, p->aCol[i].zCnName)==0 ){ sqlite3ErrorMsg(pParse, "duplicate column name: %s", z); sqlite3DbFree(db, z); return; } } - if( (p->nCol & 0x7)==0 ){ - Column *aNew; - aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0])); - if( aNew==0 ){ - sqlite3DbFree(db, z); - return; - } - p->aCol = aNew; + aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0])); + if( aNew==0 ){ + sqlite3DbFree(db, z); + return; } + p->aCol = aNew; pCol = &p->aCol[p->nCol]; memset(pCol, 0, sizeof(p->aCol[0])); - pCol->zName = z; - pCol->hName = sqlite3StrIHash(z); + pCol->zCnName = z; + pCol->hName = hName; sqlite3ColumnPropertiesFromName(p, pCol); - if( pType->n==0 ){ + if( sType.n==0 ){ /* If there is no type specified, columns have the default affinity ** 'BLOB' with a default size of 4 bytes. */ - pCol->affinity = SQLITE_AFF_BLOB; - pCol->szEst = 1; + pCol->affinity = affinity; + pCol->eCType = eType; + pCol->szEst = szEst; #ifdef SQLITE_ENABLE_SORTER_REFERENCES - if( 4>=sqlite3GlobalConfig.szSorterRef ){ - pCol->colFlags |= COLFLAG_SORTERREF; + if( affinity==SQLITE_AFF_BLOB ){ + if( 4>=sqlite3GlobalConfig.szSorterRef ){ + pCol->colFlags |= COLFLAG_SORTERREF; + } } #endif }else{ zType = z + sqlite3Strlen30(z) + 1; - memcpy(zType, pType->z, pType->n); - zType[pType->n] = 0; + memcpy(zType, sType.z, sType.n); + zType[sType.n] = 0; sqlite3Dequote(zType); pCol->affinity = sqlite3AffinityType(zType, pCol); pCol->colFlags |= COLFLAG_HASTYPE; @@ -112324,7 +114768,7 @@ SQLITE_PRIVATE void sqlite3AddDefaultValue( pCol = &(p->aCol[p->nCol-1]); if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){ sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant", - pCol->zName); + pCol->zCnName); #ifndef SQLITE_OMIT_GENERATED_COLUMNS }else if( pCol->colFlags & COLFLAG_GENERATED ){ testcase( pCol->colFlags & COLFLAG_VIRTUAL ); @@ -112335,15 +114779,15 @@ SQLITE_PRIVATE void sqlite3AddDefaultValue( /* A copy of pExpr is used instead of the original, as pExpr contains ** tokens that point to volatile memory. */ - Expr x; - sqlite3ExprDelete(db, pCol->pDflt); + Expr x, *pDfltExpr; memset(&x, 0, sizeof(x)); x.op = TK_SPAN; x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd); x.pLeft = pExpr; x.flags = EP_Skip; - pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE); + pDfltExpr = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE); sqlite3DbFree(db, x.u.zToken); + sqlite3ColumnSetExpr(pParse, p, pCol, pDfltExpr); } } if( IN_RENAME_OBJECT ){ @@ -112439,9 +114883,11 @@ SQLITE_PRIVATE void sqlite3AddPrimaryKey( assert( pCExpr!=0 ); sqlite3StringToId(pCExpr); if( pCExpr->op==TK_ID ){ - const char *zCName = pCExpr->u.zToken; + const char *zCName; + assert( !ExprHasProperty(pCExpr, EP_IntValue) ); + zCName = pCExpr->u.zToken; for(iCol=0; iColnCol; iCol++){ - if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){ + if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){ pCol = &pTab->aCol[iCol]; makeColumnPartOfPrimaryKey(pParse, pCol); break; @@ -112452,7 +114898,7 @@ SQLITE_PRIVATE void sqlite3AddPrimaryKey( } if( nTerm==1 && pCol - && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0 + && pCol->eCType==COLTYPE_INTEGER && sortOrder!=SQLITE_SO_DESC ){ if( IN_RENAME_OBJECT && pList ){ @@ -112532,8 +114978,7 @@ SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){ if( sqlite3LocateCollSeq(pParse, zColl) ){ Index *pIdx; - sqlite3DbFree(db, p->aCol[i].zColl); - p->aCol[i].zColl = zColl; + sqlite3ColumnSetColl(db, &p->aCol[i], zColl); /* If the column is declared as " PRIMARY KEY COLLATE ", ** then an index may have been created on this column before the @@ -112542,12 +114987,11 @@ SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){ for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ assert( pIdx->nKeyCol==1 ); if( pIdx->aiColumn[0]==i ){ - pIdx->azColl[0] = p->aCol[i].zColl; + pIdx->azColl[0] = sqlite3ColumnColl(&p->aCol[i]); } } - }else{ - sqlite3DbFree(db, zColl); } + sqlite3DbFree(db, zColl); } /* Change the most recently parsed column to be a GENERATED ALWAYS AS @@ -112567,7 +115011,7 @@ SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns"); goto generated_done; } - if( pCol->pDflt ) goto generated_error; + if( pCol->iDflt>0 ) goto generated_error; if( pType ){ if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){ /* no-op */ @@ -112585,13 +115029,13 @@ SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType if( pCol->colFlags & COLFLAG_PRIMKEY ){ makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */ } - pCol->pDflt = pExpr; + sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr); pExpr = 0; goto generated_done; generated_error: sqlite3ErrorMsg(pParse, "error in generated column \"%s\"", - pCol->zName); + pCol->zCnName); generated_done: sqlite3ExprDelete(pParse->db, pExpr); #else @@ -112693,7 +115137,7 @@ static char *createTableStmt(sqlite3 *db, Table *p){ Column *pCol; n = 0; for(pCol = p->aCol, i=0; inCol; i++, pCol++){ - n += identLength(pCol->zName) + 5; + n += identLength(pCol->zCnName) + 5; } n += identLength(p->zName); if( n<50 ){ @@ -112729,7 +115173,7 @@ static char *createTableStmt(sqlite3 *db, Table *p){ sqlite3_snprintf(n-k, &zStmt[k], zSep); k += sqlite3Strlen30(&zStmt[k]); zSep = zSep2; - identPut(zStmt, &k, pCol->zName); + identPut(zStmt, &k, pCol->zCnName); assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 ); assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) ); testcase( pCol->affinity==SQLITE_AFF_BLOB ); @@ -112813,7 +115257,6 @@ static void estimateIndexWidth(Index *pIdx){ */ static int hasColumn(const i16 *aiCol, int nCol, int x){ while( nCol-- > 0 ){ - assert( aiCol[0]>=0 ); if( x==*(aiCol++) ){ return 1; } @@ -112926,7 +115369,9 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){ */ if( !db->init.imposterTable ){ for(i=0; inCol; i++){ - if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 ){ + if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 + && (pTab->aCol[i].notNull==OE_None) + ){ pTab->aCol[i].notNull = OE_Abort; } } @@ -112936,9 +115381,10 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){ /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY ** into BTREE_BLOBKEY. */ - if( pParse->addrCrTab ){ + assert( !pParse->bReturning ); + if( pParse->u1.addrCrTab ){ assert( v ); - sqlite3VdbeChangeP3(v, pParse->addrCrTab, BTREE_BLOBKEY); + sqlite3VdbeChangeP3(v, pParse->u1.addrCrTab, BTREE_BLOBKEY); } /* Locate the PRIMARY KEY index. Or, if this table was originally @@ -112947,10 +115393,13 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){ if( pTab->iPKey>=0 ){ ExprList *pList; Token ipkToken; - sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName); + sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zCnName); pList = sqlite3ExprListAppend(pParse, 0, sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0)); - if( pList==0 ) return; + if( pList==0 ){ + pTab->tabFlags &= ~TF_WithoutRowid; + return; + } if( IN_RENAME_OBJECT ){ sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey); } @@ -112959,7 +115408,10 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){ pTab->iPKey = -1; sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0, SQLITE_IDXTYPE_PRIMARYKEY); - if( db->mallocFailed || pParse->nErr ) return; + if( db->mallocFailed || pParse->nErr ){ + pTab->tabFlags &= ~TF_WithoutRowid; + return; + } pPk = sqlite3PrimaryKeyIndex(pTab); assert( pPk->nKeyCol==1 ); }else{ @@ -113071,7 +115523,7 @@ SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char * nName = sqlite3Strlen30(pTab->zName); if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0; if( zName[nName]!='_' ) return 0; - pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->azModuleArg[0]); + pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]); if( pMod==0 ) return 0; if( pMod->pModule->iVersion<3 ) return 0; if( pMod->pModule->xShadowName==0 ) return 0; @@ -113079,6 +115531,41 @@ SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char * } #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Table pTab is a virtual table. If it the virtual table implementation +** exists and has an xShadowName method, then loop over all other ordinary +** tables within the same schema looking for shadow tables of pTab, and mark +** any shadow tables seen using the TF_Shadow flag. +*/ +SQLITE_PRIVATE void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab){ + int nName; /* Length of pTab->zName */ + Module *pMod; /* Module for the virtual table */ + HashElem *k; /* For looping through the symbol table */ + + assert( IsVirtual(pTab) ); + pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]); + if( pMod==0 ) return; + if( NEVER(pMod->pModule==0) ) return; + if( pMod->pModule->iVersion<3 ) return; + if( pMod->pModule->xShadowName==0 ) return; + assert( pTab->zName!=0 ); + nName = sqlite3Strlen30(pTab->zName); + for(k=sqliteHashFirst(&pTab->pSchema->tblHash); k; k=sqliteHashNext(k)){ + Table *pOther = sqliteHashData(k); + assert( pOther->zName!=0 ); + if( !IsOrdinaryTable(pOther) ) continue; + if( pOther->tabFlags & TF_Shadow ) continue; + if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0 + && pOther->zName[nName]=='_' + && pMod->pModule->xShadowName(pOther->zName+nName+1) + ){ + pOther->tabFlags |= TF_Shadow; + } + } +} +#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ + #ifndef SQLITE_OMIT_VIRTUALTABLE /* ** Return true if zName is a shadow table name in the current database @@ -113152,7 +115639,7 @@ SQLITE_PRIVATE void sqlite3EndTable( Parse *pParse, /* Parse context */ Token *pCons, /* The ',' token after the last column defn. */ Token *pEnd, /* The ')' before options in the CREATE TABLE */ - u8 tabOpts, /* Extra table options. Usually 0. */ + u32 tabOpts, /* Extra table options. Usually 0. */ Select *pSelect /* Select from a "CREATE ... AS SELECT" */ ){ Table *p; /* The new table */ @@ -113163,7 +115650,6 @@ SQLITE_PRIVATE void sqlite3EndTable( if( pEnd==0 && pSelect==0 ){ return; } - assert( !db->mallocFailed ); p = pParse->pNewTable; if( p==0 ) return; @@ -113181,7 +115667,7 @@ SQLITE_PRIVATE void sqlite3EndTable( ** table itself. So mark it read-only. */ if( db->init.busy ){ - if( pSelect ){ + if( pSelect || (!IsOrdinaryTable(p) && db->init.newTnum) ){ sqlite3ErrorMsg(pParse, ""); return; } @@ -113189,6 +115675,44 @@ SQLITE_PRIVATE void sqlite3EndTable( if( p->tnum==1 ) p->tabFlags |= TF_Readonly; } + /* Special processing for tables that include the STRICT keyword: + ** + ** * Do not allow custom column datatypes. Every column must have + ** a datatype that is one of INT, INTEGER, REAL, TEXT, or BLOB. + ** + ** * If a PRIMARY KEY is defined, other than the INTEGER PRIMARY KEY, + ** then all columns of the PRIMARY KEY must have a NOT NULL + ** constraint. + */ + if( tabOpts & TF_Strict ){ + int ii; + p->tabFlags |= TF_Strict; + for(ii=0; iinCol; ii++){ + Column *pCol = &p->aCol[ii]; + if( pCol->eCType==COLTYPE_CUSTOM ){ + if( pCol->colFlags & COLFLAG_HASTYPE ){ + sqlite3ErrorMsg(pParse, + "unknown datatype for %s.%s: \"%s\"", + p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "") + ); + }else{ + sqlite3ErrorMsg(pParse, "missing datatype for %s.%s", + p->zName, pCol->zCnName); + } + return; + }else if( pCol->eCType==COLTYPE_ANY ){ + pCol->affinity = SQLITE_AFF_BLOB; + } + if( (pCol->colFlags & COLFLAG_PRIMKEY)!=0 + && p->iPKey!=ii + && pCol->notNull == OE_None + ){ + pCol->notNull = OE_Abort; + p->tabFlags |= TF_HasNotNull; + } + } + } + assert( (p->tabFlags & TF_HasPrimaryKey)==0 || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 ); assert( (p->tabFlags & TF_HasPrimaryKey)!=0 @@ -113233,7 +115757,7 @@ SQLITE_PRIVATE void sqlite3EndTable( for(ii=0; iinCol; ii++){ u32 colFlags = p->aCol[ii].colFlags; if( (colFlags & COLFLAG_GENERATED)!=0 ){ - Expr *pX = p->aCol[ii].pDflt; + Expr *pX = sqlite3ColumnExpr(p, &p->aCol[ii]); testcase( colFlags & COLFLAG_VIRTUAL ); testcase( colFlags & COLFLAG_STORED ); if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){ @@ -113243,8 +115767,8 @@ SQLITE_PRIVATE void sqlite3EndTable( ** tree that have been allocated from lookaside memory, which is ** illegal in a schema and will lead to errors or heap corruption ** when the database connection closes. */ - sqlite3ExprDelete(db, pX); - p->aCol[ii].pDflt = sqlite3ExprAlloc(db, TK_NULL, 0, 0); + sqlite3ColumnSetExpr(pParse, p, &p->aCol[ii], + sqlite3ExprAlloc(db, TK_NULL, 0, 0)); } }else{ nNG++; @@ -113284,7 +115808,7 @@ SQLITE_PRIVATE void sqlite3EndTable( /* ** Initialize zType for the new view or table. */ - if( p->pSelect==0 ){ + if( IsOrdinaryTable(p) ){ /* A regular table */ zType = "table"; zType2 = "TABLE"; @@ -113370,7 +115894,7 @@ SQLITE_PRIVATE void sqlite3EndTable( ** the information we've collected. */ sqlite3NestedParse(pParse, - "UPDATE %Q." DFLT_SCHEMA_TABLE + "UPDATE %Q." LEGACY_SCHEMA_TABLE " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q" " WHERE rowid=#%d", db->aDb[iDb].zDbSName, @@ -113388,7 +115912,7 @@ SQLITE_PRIVATE void sqlite3EndTable( /* Check to see if we need to create an sqlite_sequence table for ** keeping track of autoincrement keys. */ - if( (p->tabFlags & TF_Autoincrement)!=0 ){ + if( (p->tabFlags & TF_Autoincrement)!=0 && !IN_SPECIAL_PARSE ){ Db *pDb = &db->aDb[iDb]; assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); if( pDb->pSchema->pSeqTab==0 ){ @@ -113402,7 +115926,7 @@ SQLITE_PRIVATE void sqlite3EndTable( /* Reparse everything to update our internal data structures */ sqlite3VdbeAddParseSchemaOp(v, iDb, - sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName)); + sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0); } /* Add the table to the in-memory representation of the database. @@ -113411,6 +115935,7 @@ SQLITE_PRIVATE void sqlite3EndTable( Table *pOld; Schema *pSchema = p->pSchema; assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + assert( HasRowid(p) || p->iPKey<0 ); pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p); if( pOld ){ assert( p==pOld ); /* Malloc must have failed inside HashInsert() */ @@ -113420,19 +115945,27 @@ SQLITE_PRIVATE void sqlite3EndTable( pParse->pNewTable = 0; db->mDbFlags |= DBFLAG_SchemaChange; -#ifndef SQLITE_OMIT_ALTERTABLE - if( !p->pSelect ){ - const char *zName = (const char *)pParse->sNameToken.z; - int nName; - assert( !pSelect && pCons && pEnd ); - if( pCons->z==0 ){ - pCons = pEnd; - } - nName = (int)((const char *)pCons->z - zName); - p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName); + /* If this is the magic sqlite_sequence table used by autoincrement, + ** then record a pointer to this table in the main database structure + ** so that INSERT can find the table easily. */ + assert( !pParse->nested ); +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( strcmp(p->zName, "sqlite_sequence")==0 ){ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + p->pSchema->pSeqTab = p; } #endif } + +#ifndef SQLITE_OMIT_ALTERTABLE + if( !pSelect && IsOrdinaryTable(p) ){ + assert( pCons && pEnd ); + if( pCons->z==0 ){ + pCons = pEnd; + } + p->u.tab.addColOffset = 13 + (int)(pCons->z - pParse->sNameToken.z); + } +#endif } #ifndef SQLITE_OMIT_VIEW @@ -113465,6 +115998,16 @@ SQLITE_PRIVATE void sqlite3CreateView( sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr); p = pParse->pNewTable; if( p==0 || pParse->nErr ) goto create_view_fail; + + /* Legacy versions of SQLite allowed the use of the magic "rowid" column + ** on a view, even though views do not have rowids. The following flag + ** setting fixes this problem. But the fix can be disabled by compiling + ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that + ** depend upon the old buggy behavior. */ +#ifndef SQLITE_ALLOW_ROWID_IN_VIEW + p->tabFlags |= TF_NoVisibleRowid; +#endif + sqlite3TwoPartName(pParse, pName1, pName2, &pName); iDb = sqlite3SchemaToIndex(db, p->pSchema); sqlite3FixInit(&sFix, pParse, iDb, "view", pName); @@ -113477,12 +116020,13 @@ SQLITE_PRIVATE void sqlite3CreateView( */ pSelect->selFlags |= SF_View; if( IN_RENAME_OBJECT ){ - p->pSelect = pSelect; + p->u.view.pSelect = pSelect; pSelect = 0; }else{ - p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + p->u.view.pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); } p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE); + p->eTabType = TABTYP_VIEW; if( db->mallocFailed ) goto create_view_fail; /* Locate the end of the CREATE VIEW statement. Make sEnd point to @@ -113536,13 +116080,12 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ assert( pTable ); #ifndef SQLITE_OMIT_VIRTUALTABLE - db->nSchemaLock++; - rc = sqlite3VtabCallConnect(pParse, pTable); - db->nSchemaLock--; - if( rc ){ - return 1; + if( IsVirtual(pTable) ){ + db->nSchemaLock++; + rc = sqlite3VtabCallConnect(pParse, pTable); + db->nSchemaLock--; + return rc; } - if( IsVirtual(pTable) ) return 0; #endif #ifndef SQLITE_OMIT_VIEW @@ -113579,8 +116122,8 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ ** to be permanent. So the computation is done on a copy of the SELECT ** statement that defines the view. */ - assert( pTable->pSelect ); - pSel = sqlite3SelectDup(db, pTable->pSelect, 0); + assert( IsView(pTable) ); + pSel = sqlite3SelectDup(db, pTable->u.view.pSelect, 0); if( pSel ){ u8 eParseMode = pParse->eParseMode; pParse->eParseMode = PARSE_MODE_NORMAL; @@ -113623,6 +116166,7 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ assert( pTable->aCol==0 ); pTable->nCol = pSelTab->nCol; pTable->aCol = pSelTab->aCol; + pTable->tabFlags |= (pSelTab->tabFlags & COLFLAG_NOINSERT); pSelTab->nCol = 0; pSelTab->aCol = 0; assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) ); @@ -113638,8 +116182,6 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ pTable->pSchema->schemaFlags |= DB_UnresetViews; if( db->mallocFailed ){ sqlite3DeleteColumnNames(db, pTable); - pTable->aCol = 0; - pTable->nCol = 0; } #endif /* SQLITE_OMIT_VIEW */ return nErr; @@ -113656,10 +116198,8 @@ static void sqliteViewResetAll(sqlite3 *db, int idx){ if( !DbHasProperty(db, idx, DB_UnresetViews) ) return; for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){ Table *pTab = sqliteHashData(i); - if( pTab->pSelect ){ + if( IsView(pTab) ){ sqlite3DeleteColumnNames(db, pTab); - pTab->aCol = 0; - pTab->nCol = 0; } } DbClearProperty(db, idx, DB_UnresetViews); @@ -113733,7 +116273,7 @@ static void destroyRootPage(Parse *pParse, int iTable, int iDb){ ** token for additional information. */ sqlite3NestedParse(pParse, - "UPDATE %Q." DFLT_SCHEMA_TABLE + "UPDATE %Q." LEGACY_SCHEMA_TABLE " SET rootpage=%d WHERE #%d AND rootpage=#%d", pParse->db->aDb[iDb].zDbSName, iTable, r1, r1); #endif @@ -113868,7 +116408,7 @@ SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, in ** database. */ sqlite3NestedParse(pParse, - "DELETE FROM %Q." DFLT_SCHEMA_TABLE + "DELETE FROM %Q." LEGACY_SCHEMA_TABLE " WHERE tbl_name=%Q and type!='trigger'", pDb->zDbSName, pTab->zName); if( !isView && !IsVirtual(pTab) ){ @@ -113896,6 +116436,7 @@ SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables(sqlite3 *db){ if( (db->flags & SQLITE_Defensive)!=0 && db->pVtabCtx==0 && db->nVdbeExec==0 + && !sqlite3VtabInSync(db) ){ return 1; } @@ -113915,6 +116456,9 @@ static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){ if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){ return 1; } + if( pTab->tabFlags & TF_Eponymous ){ + return 1; + } return 0; } @@ -113940,7 +116484,10 @@ SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, if( noErr ) db->suppressErr--; if( pTab==0 ){ - if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase); + if( noErr ){ + sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase); + sqlite3ForceNotReadOnly(pParse); + } goto exit_drop_table; } iDb = sqlite3SchemaToIndex(db, pTab->pSchema); @@ -113996,11 +116543,11 @@ SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used ** on a table. */ - if( isView && pTab->pSelect==0 ){ + if( isView && !IsView(pTab) ){ sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName); goto exit_drop_table; } - if( !isView && pTab->pSelect ){ + if( !isView && IsView(pTab) ){ sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName); goto exit_drop_table; } @@ -114051,7 +116598,7 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey( FKey *pFKey = 0; FKey *pNextTo; Table *p = pParse->pNewTable; - int nByte; + i64 nByte; int i; int nCol; char *z; @@ -114064,7 +116611,7 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey( if( pToCol && pToCol->nExpr!=1 ){ sqlite3ErrorMsg(pParse, "foreign key on %s" " should reference only one column of table %T", - p->aCol[iCol].zName, pTo); + p->aCol[iCol].zCnName, pTo); goto fk_end; } nCol = 1; @@ -114087,7 +116634,8 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey( goto fk_end; } pFKey->pFrom = p; - pFKey->pNextFrom = p->pFKey; + assert( IsOrdinaryTable(p) ); + pFKey->pNextFrom = p->u.tab.pFKey; z = (char*)&pFKey->aCol[nCol]; pFKey->zTo = z; if( IN_RENAME_OBJECT ){ @@ -114104,7 +116652,7 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey( for(i=0; inCol; j++){ - if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zEName)==0 ){ + if( sqlite3StrICmp(p->aCol[j].zCnName, pFromCol->a[i].zEName)==0 ){ pFKey->aCol[i].iFrom = j; break; } @@ -114152,7 +116700,8 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey( /* Link the foreign key to the table as the last step. */ - p->pFKey = pFKey; + assert( IsOrdinaryTable(p) ); + p->u.tab.pFKey = pFKey; pFKey = 0; fk_end: @@ -114173,7 +116722,9 @@ SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){ #ifndef SQLITE_OMIT_FOREIGN_KEY Table *pTab; FKey *pFKey; - if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return; + if( (pTab = pParse->pNewTable)==0 ) return; + if( NEVER(!IsOrdinaryTable(pTab)) ) return; + if( (pFKey = pTab->u.tab.pFKey)==0 ) return; assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */ pFKey->isDeferred = (u8)isDeferred; #endif @@ -114465,7 +117016,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex( goto exit_create_index; } #ifndef SQLITE_OMIT_VIEW - if( pTab->pSelect ){ + if( IsView(pTab) ){ sqlite3ErrorMsg(pParse, "views may not be indexed"); goto exit_create_index; } @@ -114510,6 +117061,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex( }else{ assert( !db->init.busy ); sqlite3CodeVerifySchema(pParse, iDb); + sqlite3ForceNotReadOnly(pParse); } goto exit_create_index; } @@ -114555,7 +117107,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex( Token prevCol; Column *pCol = &pTab->aCol[pTab->nCol-1]; pCol->colFlags |= COLFLAG_UNIQUE; - sqlite3TokenInit(&prevCol, pCol->zName); + sqlite3TokenInit(&prevCol, pCol->zCnName); pList = sqlite3ExprListAppend(pParse, 0, sqlite3ExprAlloc(db, TK_ID, &prevCol, 0)); if( pList==0 ) goto exit_create_index; @@ -114573,6 +117125,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex( Expr *pExpr = pList->a[i].pExpr; assert( pExpr!=0 ); if( pExpr->op==TK_COLLATE ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken)); } } @@ -114668,6 +117221,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex( zColl = 0; if( pListItem->pExpr->op==TK_COLLATE ){ int nColl; + assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) ); zColl = pListItem->pExpr->u.zToken; nColl = sqlite3Strlen30(zColl) + 1; assert( nExtra>=nColl ); @@ -114676,7 +117230,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex( zExtra += nColl; nExtra -= nColl; }else if( j>=0 ){ - zColl = pTab->aCol[j].zColl; + zColl = sqlite3ColumnColl(&pTab->aCol[j]); } if( !zColl ) zColl = sqlite3StrBINARY; if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){ @@ -114874,7 +117428,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex( /* Add an entry in sqlite_schema for this index */ sqlite3NestedParse(pParse, - "INSERT INTO %Q." DFLT_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);", + "INSERT INTO %Q." LEGACY_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);", db->aDb[iDb].zDbSName, pIndex->zName, pTab->zName, @@ -114890,7 +117444,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex( sqlite3RefillIndex(pParse, pIndex, iMem); sqlite3ChangeCookie(pParse, iDb); sqlite3VdbeAddParseSchemaOp(v, iDb, - sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName)); + sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0); sqlite3VdbeAddOp2(v, OP_Expire, 0, 1); } @@ -114911,8 +117465,12 @@ SQLITE_PRIVATE void sqlite3CreateIndex( /* Clean up before exiting */ exit_create_index: if( pIndex ) sqlite3FreeIndex(db, pIndex); - if( pTab ){ /* Ensure all REPLACE indexes are at the end of the list */ - Index **ppFrom = &pTab->pIndex; + if( pTab ){ + /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list. + ** The list was already ordered when this routine was entered, so at this + ** point at most a single index (the newly added index) will be out of + ** order. So we have to reorder at most one index. */ + Index **ppFrom; Index *pThis; for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){ Index *pNext; @@ -114925,6 +117483,16 @@ SQLITE_PRIVATE void sqlite3CreateIndex( } break; } +#ifdef SQLITE_DEBUG + /* Verify that all REPLACE indexes really are now at the end + ** of the index list. In other words, no other index type ever + ** comes after a REPLACE index on the list. */ + for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){ + assert( pThis->onError!=OE_Replace + || pThis->pNext==0 + || pThis->pNext->onError==OE_Replace ); + } +#endif } sqlite3ExprDelete(db, pPIWhere); sqlite3ExprListDelete(db, pList); @@ -114976,7 +117544,7 @@ SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){ if( x<99 ){ pIdx->pTable->nRowLogEst = x = 99; } - if( pIdx->pPartIdxWhere!=0 ) x -= 10; assert( 10==sqlite3LogEst(2) ); + if( pIdx->pPartIdxWhere!=0 ){ x -= 10; assert( 10==sqlite3LogEst(2) ); } a[0] = x; /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is @@ -115011,9 +117579,10 @@ SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase); if( pIndex==0 ){ if( !ifExists ){ - sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0); + sqlite3ErrorMsg(pParse, "no such index: %S", pName->a); }else{ sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase); + sqlite3ForceNotReadOnly(pParse); } pParse->checkSchema = 1; goto exit_drop_index; @@ -115033,7 +117602,7 @@ SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ goto exit_drop_index; } - if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX; + if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX; if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){ goto exit_drop_index; } @@ -115045,7 +117614,7 @@ SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists if( v ){ sqlite3BeginWriteOperation(pParse, 1, iDb); sqlite3NestedParse(pParse, - "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='index'", + "DELETE FROM %Q." LEGACY_SCHEMA_TABLE " WHERE name=%Q AND type='index'", db->aDb[iDb].zDbSName, pIndex->zName ); sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName); @@ -115283,7 +117852,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppend( Token *pTable, /* Table to append */ Token *pDatabase /* Database of the table */ ){ - struct SrcList_item *pItem; + SrcItem *pItem; sqlite3 *db; assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */ assert( pParse!=0 ); @@ -115324,9 +117893,9 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppend( */ SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){ int i; - struct SrcList_item *pItem; - assert(pList || pParse->db->mallocFailed ); - if( pList ){ + SrcItem *pItem; + assert( pList || pParse->db->mallocFailed ); + if( ALWAYS(pList) ){ for(i=0, pItem=pList->a; inSrc; i++, pItem++){ if( pItem->iCursor>=0 ) continue; pItem->iCursor = pParse->nTab++; @@ -115342,7 +117911,7 @@ SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){ */ SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){ int i; - struct SrcList_item *pItem; + SrcItem *pItem; if( pList==0 ) return; for(pItem=pList->a, i=0; inSrc; i++, pItem++){ if( pItem->zDatabase ) sqlite3DbFreeNN(db, pItem->zDatabase); @@ -115384,7 +117953,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm( Expr *pOn, /* The ON clause of a join */ IdList *pUsing /* The USING clause of a join */ ){ - struct SrcList_item *pItem; + SrcItem *pItem; sqlite3 *db = pParse->db; if( !p && (pOn || pUsing) ){ sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s", @@ -115428,7 +117997,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm( SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){ assert( pIndexedBy!=0 ); if( p && pIndexedBy->n>0 ){ - struct SrcList_item *pItem; + SrcItem *pItem; assert( p->nSrc>0 ); pItem = &p->a[p->nSrc-1]; assert( pItem->fg.notIndexed==0 ); @@ -115441,6 +118010,7 @@ SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pI }else{ pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy); pItem->fg.isIndexedBy = 1; + assert( pItem->fg.isCte==0 ); /* No collision on union u2 */ } } } @@ -115458,7 +118028,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, Src sqlite3SrcListDelete(pParse->db, p2); }else{ p1 = pNew; - memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(struct SrcList_item)); + memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(SrcItem)); sqlite3DbFree(pParse->db, p2); } } @@ -115471,7 +118041,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, Src */ SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){ if( p ){ - struct SrcList_item *pItem = &p->a[p->nSrc-1]; + SrcItem *pItem = &p->a[p->nSrc-1]; assert( pItem->fg.notIndexed==0 ); assert( pItem->fg.isIndexedBy==0 ); assert( pItem->fg.isTabFunc==0 ); @@ -115626,7 +118196,7 @@ SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){ static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){ assert( iDb>=0 && iDbdb->nDb ); assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 ); - assert( iDbdb, iDb, 0) ); if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){ DbMaskSet(pToplevel->cookieMask, iDb); @@ -115753,7 +118323,7 @@ SQLITE_PRIVATE void sqlite3UniqueConstraint( for(j=0; jnKeyCol; j++){ char *zCol; assert( pIdx->aiColumn[j]>=0 ); - zCol = pTab->aCol[pIdx->aiColumn[j]].zName; + zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName; if( j ) sqlite3_str_append(&errMsg, ", ", 2); sqlite3_str_appendall(&errMsg, pTab->zName); sqlite3_str_append(&errMsg, ".", 1); @@ -115780,7 +118350,7 @@ SQLITE_PRIVATE void sqlite3RowidConstraint( int rc; if( pTab->iPKey>=0 ){ zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName, - pTab->aCol[pTab->iPKey].zName); + pTab->aCol[pTab->iPKey].zCnName); rc = SQLITE_CONSTRAINT_PRIMARYKEY; }else{ zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName); @@ -115968,24 +118538,76 @@ SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){ } #ifndef SQLITE_OMIT_CTE +/* +** Create a new CTE object +*/ +SQLITE_PRIVATE Cte *sqlite3CteNew( + Parse *pParse, /* Parsing context */ + Token *pName, /* Name of the common-table */ + ExprList *pArglist, /* Optional column name list for the table */ + Select *pQuery, /* Query used to initialize the table */ + u8 eM10d /* The MATERIALIZED flag */ +){ + Cte *pNew; + sqlite3 *db = pParse->db; + + pNew = sqlite3DbMallocZero(db, sizeof(*pNew)); + assert( pNew!=0 || db->mallocFailed ); + + if( db->mallocFailed ){ + sqlite3ExprListDelete(db, pArglist); + sqlite3SelectDelete(db, pQuery); + }else{ + pNew->pSelect = pQuery; + pNew->pCols = pArglist; + pNew->zName = sqlite3NameFromToken(pParse->db, pName); + pNew->eM10d = eM10d; + } + return pNew; +} + +/* +** Clear information from a Cte object, but do not deallocate storage +** for the object itself. +*/ +static void cteClear(sqlite3 *db, Cte *pCte){ + assert( pCte!=0 ); + sqlite3ExprListDelete(db, pCte->pCols); + sqlite3SelectDelete(db, pCte->pSelect); + sqlite3DbFree(db, pCte->zName); +} + +/* +** Free the contents of the CTE object passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3CteDelete(sqlite3 *db, Cte *pCte){ + assert( pCte!=0 ); + cteClear(db, pCte); + sqlite3DbFree(db, pCte); +} + /* ** This routine is invoked once per CTE by the parser while parsing a -** WITH clause. +** WITH clause. The CTE described by teh third argument is added to +** the WITH clause of the second argument. If the second argument is +** NULL, then a new WITH argument is created. */ SQLITE_PRIVATE With *sqlite3WithAdd( Parse *pParse, /* Parsing context */ With *pWith, /* Existing WITH clause, or NULL */ - Token *pName, /* Name of the common-table */ - ExprList *pArglist, /* Optional column name list for the table */ - Select *pQuery /* Query used to initialize the table */ + Cte *pCte /* CTE to add to the WITH clause */ ){ sqlite3 *db = pParse->db; With *pNew; char *zName; + if( pCte==0 ){ + return pWith; + } + /* Check that the CTE name is unique within this WITH clause. If ** not, store an error in the Parse structure. */ - zName = sqlite3NameFromToken(pParse->db, pName); + zName = pCte->zName; if( zName && pWith ){ int i; for(i=0; inCte; i++){ @@ -116004,16 +118626,11 @@ SQLITE_PRIVATE With *sqlite3WithAdd( assert( (pNew!=0 && zName!=0) || db->mallocFailed ); if( db->mallocFailed ){ - sqlite3ExprListDelete(db, pArglist); - sqlite3SelectDelete(db, pQuery); - sqlite3DbFree(db, zName); + sqlite3CteDelete(db, pCte); pNew = pWith; }else{ - pNew->a[pNew->nCte].pSelect = pQuery; - pNew->a[pNew->nCte].pCols = pArglist; - pNew->a[pNew->nCte].zName = zName; - pNew->a[pNew->nCte].zCteErr = 0; - pNew->nCte++; + pNew->a[pNew->nCte++] = *pCte; + sqlite3DbFree(db, pCte); } return pNew; @@ -116026,10 +118643,7 @@ SQLITE_PRIVATE void sqlite3WithDelete(sqlite3 *db, With *pWith){ if( pWith ){ int i; for(i=0; inCte; i++){ - struct Cte *pCte = &pWith->a[i]; - sqlite3ExprListDelete(db, pCte->pCols); - sqlite3SelectDelete(db, pCte->pSelect); - sqlite3DbFree(db, pCte->zName); + cteClear(db, &pWith->a[i]); } sqlite3DbFree(db, pWith); } @@ -116377,6 +118991,7 @@ SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch( ){ FuncDef *p; for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){ + assert( p->funcFlags & SQLITE_FUNC_BUILTIN ); if( sqlite3StrICmp(p->zName, zFunc)==0 ){ return p; } @@ -116398,6 +119013,7 @@ SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs( int nName = sqlite3Strlen30(zName); int h = SQLITE_FUNC_HASH(zName[0], nName); assert( zName[0]>='a' && zName[0]<='z' ); + assert( aDef[i].funcFlags & SQLITE_FUNC_BUILTIN ); pOther = sqlite3FunctionSearch(h, zName); if( pOther ){ assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] ); @@ -116608,7 +119224,7 @@ SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){ ** */ SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ - struct SrcList_item *pItem = pSrc->a; + SrcItem *pItem = pSrc->a; Table *pTab; assert( pItem && pSrc->nSrc>=1 ); pTab = sqlite3LocateTableItem(pParse, 0, pItem); @@ -116616,9 +119232,9 @@ SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ pItem->pTab = pTab; if( pTab ){ pTab->nTabRef++; - } - if( sqlite3IndexedByLookup(pParse, pItem) ){ - pTab = 0; + if( pItem->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pItem) ){ + pTab = 0; + } } return pTab; } @@ -116663,7 +119279,7 @@ SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){ return 1; } #ifndef SQLITE_OMIT_VIEW - if( !viewOk && pTab->pSelect ){ + if( !viewOk && IsView(pTab) ){ sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName); return 1; } @@ -116767,13 +119383,13 @@ SQLITE_PRIVATE Expr *sqlite3LimitWhere( }else{ Index *pPk = sqlite3PrimaryKeyIndex(pTab); if( pPk->nKeyCol==1 ){ - const char *zName = pTab->aCol[pPk->aiColumn[0]].zName; + const char *zName = pTab->aCol[pPk->aiColumn[0]].zCnName; pLhs = sqlite3Expr(db, TK_ID, zName); pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName)); }else{ int i; for(i=0; inKeyCol; i++){ - Expr *p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zName); + Expr *p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zCnName); pEList = sqlite3ExprListAppend(pParse, pEList, p); } pLhs = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); @@ -116786,9 +119402,16 @@ SQLITE_PRIVATE Expr *sqlite3LimitWhere( /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree ** and the SELECT subtree. */ pSrc->a[0].pTab = 0; - pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0); + pSelectSrc = sqlite3SrcListDup(db, pSrc, 0); pSrc->a[0].pTab = pTab; - pSrc->a[0].pIBIndex = 0; + if( pSrc->a[0].fg.isIndexedBy ){ + assert( pSrc->a[0].fg.isCte==0 ); + pSrc->a[0].u2.pIBIndex = 0; + pSrc->a[0].fg.isIndexedBy = 0; + sqlite3DbFree(db, pSrc->a[0].u1.zIndexedBy); + }else if( pSrc->a[0].fg.isCte ){ + pSrc->a[0].u2.pCteUse->nUse++; + } /* generate the SELECT expression tree. */ pSelect = sqlite3SelectNew(pParse, pEList, pSelectSrc, pWhere, 0 ,0, @@ -116874,7 +119497,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom( */ #ifndef SQLITE_OMIT_TRIGGER pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); - isView = pTab->pSelect!=0; + isView = IsView(pTab); #else # define pTrigger 0 # define isView 0 @@ -116966,6 +119589,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom( if( (db->flags & SQLITE_CountRows)!=0 && !pParse->nested && !pParse->pTriggerTab + && !pParse->bReturning ){ memCnt = ++pParse->nMem; sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt); @@ -117000,6 +119624,9 @@ SQLITE_PRIVATE void sqlite3DeleteFrom( for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ assert( pIdx->pSchema==pTab->pSchema ); sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb); + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){ + sqlite3VdbeChangeP3(v, -1, memCnt ? memCnt : -1); + } } }else #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */ @@ -117120,7 +119747,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom( if( eOnePass!=ONEPASS_OFF ){ assert( nKey==nPk ); /* OP_Found will use an unpacked key */ if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){ - assert( pPk!=0 || pTab->pSelect!=0 ); + assert( pPk!=0 || IsView(pTab) ); sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey); VdbeCoverage(v); } @@ -117187,7 +119814,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom( ** invoke the callback function. */ if( memCnt ){ - sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1); + sqlite3VdbeAddOp2(v, OP_ChngCntRow, memCnt, 1); sqlite3VdbeSetNumCols(v, 1); sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC); } @@ -117354,7 +119981,7 @@ SQLITE_PRIVATE void sqlite3GenerateRowDelete( ** the update-hook is not invoked for rows removed by REPLACE, but the ** pre-update-hook is. */ - if( pTab->pSelect==0 ){ + if( !IsView(pTab) ){ u8 p5 = 0; sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek); sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0)); @@ -117511,13 +120138,15 @@ SQLITE_PRIVATE int sqlite3GenerateIndexKey( continue; } sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j); - /* If the column affinity is REAL but the number is an integer, then it - ** might be stored in the table as an integer (using a compact - ** representation) then converted to REAL by an OP_RealAffinity opcode. - ** But we are getting ready to store this value back into an index, where - ** it should be converted by to INTEGER again. So omit the OP_RealAffinity - ** opcode if it is present */ - sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity); + if( pIdx->aiColumn[j]>=0 ){ + /* If the column affinity is REAL but the number is an integer, then it + ** might be stored in the table as an integer (using a compact + ** representation) then converted to REAL by an OP_RealAffinity opcode. + ** But we are getting ready to store this value back into an index, where + ** it should be converted by to INTEGER again. So omit the + ** OP_RealAffinity opcode if it is present */ + sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity); + } } if( regOut ){ sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut); @@ -118112,9 +120741,9 @@ static void last_insert_rowid( /* ** Implementation of the changes() SQL function. ** -** IMP: R-62073-11209 The changes() SQL function is a wrapper -** around the sqlite3_changes() C/C++ function and hence follows the same -** rules for counting changes. +** IMP: R-32760-32347 The changes() SQL function is a wrapper +** around the sqlite3_changes64() C/C++ function and hence follows the +** same rules for counting changes. */ static void changes( sqlite3_context *context, @@ -118123,12 +120752,12 @@ static void changes( ){ sqlite3 *db = sqlite3_context_db_handle(context); UNUSED_PARAMETER2(NotUsed, NotUsed2); - sqlite3_result_int(context, sqlite3_changes(db)); + sqlite3_result_int64(context, sqlite3_changes64(db)); } /* ** Implementation of the total_changes() SQL function. The return value is -** the same as the sqlite3_total_changes() API function. +** the same as the sqlite3_total_changes64() API function. */ static void total_changes( sqlite3_context *context, @@ -118137,9 +120766,9 @@ static void total_changes( ){ sqlite3 *db = sqlite3_context_db_handle(context); UNUSED_PARAMETER2(NotUsed, NotUsed2); - /* IMP: R-52756-41993 This function is a wrapper around the - ** sqlite3_total_changes() C/C++ interface. */ - sqlite3_result_int(context, sqlite3_total_changes(db)); + /* IMP: R-11217-42568 This function is a wrapper around the + ** sqlite3_total_changes64() C/C++ interface. */ + sqlite3_result_int64(context, sqlite3_total_changes64(db)); } /* @@ -118235,7 +120864,8 @@ static int patternCompare( /* Skip over multiple "*" characters in the pattern. If there ** are also "?" characters, skip those as well, but consume a ** single character of the input string for each "?" skipped */ - while( (c=Utf8Read(zPattern)) == matchAll || c == matchOne ){ + while( (c=Utf8Read(zPattern)) == matchAll + || (c == matchOne && matchOne!=0) ){ if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){ return SQLITE_NOWILDCARDMATCH; } @@ -118856,10 +121486,10 @@ static void trimFunc( ){ const unsigned char *zIn; /* Input string */ const unsigned char *zCharSet; /* Set of characters to trim */ - int nIn; /* Number of bytes in input */ + unsigned int nIn; /* Number of bytes in input */ int flags; /* 1: trimleft 2: trimright 3: trim */ int i; /* Loop counter */ - unsigned char *aLen = 0; /* Length of each character in zCharSet */ + unsigned int *aLen = 0; /* Length of each character in zCharSet */ unsigned char **azChar = 0; /* Individual characters in zCharSet */ int nChar; /* Number of characters in zCharSet */ @@ -118868,13 +121498,13 @@ static void trimFunc( } zIn = sqlite3_value_text(argv[0]); if( zIn==0 ) return; - nIn = sqlite3_value_bytes(argv[0]); + nIn = (unsigned)sqlite3_value_bytes(argv[0]); assert( zIn==sqlite3_value_text(argv[0]) ); if( argc==1 ){ - static const unsigned char lenOne[] = { 1 }; + static const unsigned lenOne[] = { 1 }; static unsigned char * const azOne[] = { (u8*)" " }; nChar = 1; - aLen = (u8*)lenOne; + aLen = (unsigned*)lenOne; azChar = (unsigned char **)azOne; zCharSet = 0; }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ @@ -118885,15 +121515,16 @@ static void trimFunc( SQLITE_SKIP_UTF8(z); } if( nChar>0 ){ - azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1)); + azChar = contextMalloc(context, + ((i64)nChar)*(sizeof(char*)+sizeof(unsigned))); if( azChar==0 ){ return; } - aLen = (unsigned char*)&azChar[nChar]; + aLen = (unsigned*)&azChar[nChar]; for(z=zCharSet, nChar=0; *z; nChar++){ azChar[nChar] = (unsigned char *)z; SQLITE_SKIP_UTF8(z); - aLen[nChar] = (u8)(z - azChar[nChar]); + aLen[nChar] = (unsigned)(z - azChar[nChar]); } } } @@ -118901,7 +121532,7 @@ static void trimFunc( flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context)); if( flags & 1 ){ while( nIn>0 ){ - int len = 0; + unsigned int len = 0; for(i=0; i0 ){ - int len = 0; + unsigned int len = 0; for(i=0; imxAlloc==0; - pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; - if( !firstTerm ){ - if( argc==2 ){ - zSep = (char*)sqlite3_value_text(argv[1]); - nSep = sqlite3_value_bytes(argv[1]); - }else{ - zSep = ","; - nSep = 1; + int firstTerm = pGCC->str.mxAlloc==0; + pGCC->str.mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; + if( argc==1 ){ + if( !firstTerm ){ + sqlite3_str_appendchar(&pGCC->str, 1, ','); } - if( zSep ) sqlite3_str_append(pAccum, zSep, nSep); +#ifndef SQLITE_OMIT_WINDOWFUNC + else{ + pGCC->nFirstSepLength = 1; + } +#endif + }else if( !firstTerm ){ + zSep = (char*)sqlite3_value_text(argv[1]); + nSep = sqlite3_value_bytes(argv[1]); + if( zSep ){ + sqlite3_str_append(&pGCC->str, zSep, nSep); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + else{ + nSep = 0; + } + if( nSep != pGCC->nFirstSepLength || pGCC->pnSepLengths != 0 ){ + int *pnsl = pGCC->pnSepLengths; + if( pnsl == 0 ){ + /* First separator length variation seen, start tracking them. */ + pnsl = (int*)sqlite3_malloc64((pGCC->nAccum+1) * sizeof(int)); + if( pnsl!=0 ){ + int i = 0, nA = pGCC->nAccum-1; + while( inFirstSepLength; + } + }else{ + pnsl = (int*)sqlite3_realloc64(pnsl, pGCC->nAccum * sizeof(int)); + } + if( pnsl!=0 ){ + if( ALWAYS(pGCC->nAccum>0) ){ + pnsl[pGCC->nAccum-1] = nSep; + } + pGCC->pnSepLengths = pnsl; + }else{ + sqlite3StrAccumSetError(&pGCC->str, SQLITE_NOMEM); + } + } +#endif } +#ifndef SQLITE_OMIT_WINDOWFUNC + else{ + pGCC->nFirstSepLength = sqlite3_value_bytes(argv[1]); + } + pGCC->nAccum += 1; +#endif zVal = (char*)sqlite3_value_text(argv[0]); nVal = sqlite3_value_bytes(argv[0]); - if( zVal ) sqlite3_str_append(pAccum, zVal, nVal); + if( zVal ) sqlite3_str_append(&pGCC->str, zVal, nVal); } } + #ifndef SQLITE_OMIT_WINDOWFUNC static void groupConcatInverse( sqlite3_context *context, int argc, sqlite3_value **argv ){ - int n; - StrAccum *pAccum; + GroupConcatCtx *pGCC; assert( argc==1 || argc==2 ); + (void)argc; /* Suppress unused parameter warning */ if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; - pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); - /* pAccum is always non-NULL since groupConcatStep() will have always + pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC)); + /* pGCC is always non-NULL since groupConcatStep() will have always ** run frist to initialize it */ - if( ALWAYS(pAccum) ){ - n = sqlite3_value_bytes(argv[0]); - if( argc==2 ){ - n += sqlite3_value_bytes(argv[1]); + if( ALWAYS(pGCC) ){ + int nVS; + /* Must call sqlite3_value_text() to convert the argument into text prior + ** to invoking sqlite3_value_bytes(), in case the text encoding is UTF16 */ + (void)sqlite3_value_text(argv[0]); + nVS = sqlite3_value_bytes(argv[0]); + pGCC->nAccum -= 1; + if( pGCC->pnSepLengths!=0 ){ + assert(pGCC->nAccum >= 0); + if( pGCC->nAccum>0 ){ + nVS += *pGCC->pnSepLengths; + memmove(pGCC->pnSepLengths, pGCC->pnSepLengths+1, + (pGCC->nAccum-1)*sizeof(int)); + } }else{ - n++; + /* If removing single accumulated string, harmlessly over-do. */ + nVS += pGCC->nFirstSepLength; } - if( n>=(int)pAccum->nChar ){ - pAccum->nChar = 0; + if( nVS>=(int)pGCC->str.nChar ){ + pGCC->str.nChar = 0; }else{ - pAccum->nChar -= n; - memmove(pAccum->zText, &pAccum->zText[n], pAccum->nChar); + pGCC->str.nChar -= nVS; + memmove(pGCC->str.zText, &pGCC->str.zText[nVS], pGCC->str.nChar); + } + if( pGCC->str.nChar==0 ){ + pGCC->str.mxAlloc = 0; + sqlite3_free(pGCC->pnSepLengths); + pGCC->pnSepLengths = 0; } - if( pAccum->nChar==0 ) pAccum->mxAlloc = 0; } } #else # define groupConcatInverse 0 #endif /* SQLITE_OMIT_WINDOWFUNC */ static void groupConcatFinalize(sqlite3_context *context){ - StrAccum *pAccum; - pAccum = sqlite3_aggregate_context(context, 0); - if( pAccum ){ - if( pAccum->accError==SQLITE_TOOBIG ){ - sqlite3_result_error_toobig(context); - }else if( pAccum->accError==SQLITE_NOMEM ){ - sqlite3_result_error_nomem(context); - }else{ - sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, - sqlite3_free); - } + GroupConcatCtx *pGCC + = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0); + if( pGCC ){ + sqlite3ResultStrAccum(context, &pGCC->str); +#ifndef SQLITE_OMIT_WINDOWFUNC + sqlite3_free(pGCC->pnSepLengths); +#endif } } #ifndef SQLITE_OMIT_WINDOWFUNC static void groupConcatValue(sqlite3_context *context){ - sqlite3_str *pAccum; - pAccum = (sqlite3_str*)sqlite3_aggregate_context(context, 0); - if( pAccum ){ + GroupConcatCtx *pGCC + = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0); + if( pGCC ){ + StrAccum *pAccum = &pGCC->str; if( pAccum->accError==SQLITE_TOOBIG ){ sqlite3_result_error_toobig(context); }else if( pAccum->accError==SQLITE_NOMEM ){ sqlite3_result_error_nomem(context); }else{ const char *zText = sqlite3_str_value(pAccum); - sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); + sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT); } } } @@ -119406,11 +122107,14 @@ SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive) SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ FuncDef *pDef; int nExpr; - if( pExpr->op!=TK_FUNCTION || !pExpr->x.pList ){ + assert( pExpr!=0 ); + assert( pExpr->op==TK_FUNCTION ); + assert( ExprUseXList(pExpr) ); + if( !pExpr->x.pList ){ return 0; } - assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); nExpr = pExpr->x.pList->nExpr; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0); #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION if( pDef==0 ) return 0; @@ -119434,6 +122138,7 @@ SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocas Expr *pEscape = pExpr->x.pList->a[2].pExpr; char *zEscape; if( pEscape->op!=TK_STRING ) return 0; + assert( !ExprHasProperty(pEscape, EP_IntValue) ); zEscape = pEscape->u.zToken; if( zEscape[0]==0 || zEscape[1]!=0 ) return 0; if( zEscape[0]==aWc[0] ) return 0; @@ -119445,6 +122150,201 @@ SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocas return 1; } +/* Mathematical Constants */ +#ifndef M_PI +# define M_PI 3.141592653589793238462643383279502884 +#endif +#ifndef M_LN10 +# define M_LN10 2.302585092994045684017991454684364208 +#endif +#ifndef M_LN2 +# define M_LN2 0.693147180559945309417232121458176568 +#endif + + +/* Extra math functions that require linking with -lm +*/ +#ifdef SQLITE_ENABLE_MATH_FUNCTIONS +/* +** Implementation SQL functions: +** +** ceil(X) +** ceiling(X) +** floor(X) +** +** The sqlite3_user_data() pointer is a pointer to the libm implementation +** of the underlying C function. +*/ +static void ceilingFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + assert( argc==1 ); + switch( sqlite3_value_numeric_type(argv[0]) ){ + case SQLITE_INTEGER: { + sqlite3_result_int64(context, sqlite3_value_int64(argv[0])); + break; + } + case SQLITE_FLOAT: { + double (*x)(double) = (double(*)(double))sqlite3_user_data(context); + sqlite3_result_double(context, x(sqlite3_value_double(argv[0]))); + break; + } + default: { + break; + } + } +} + +/* +** On some systems, ceil() and floor() are intrinsic function. You are +** unable to take a pointer to these functions. Hence, we here wrap them +** in our own actual functions. +*/ +static double xCeil(double x){ return ceil(x); } +static double xFloor(double x){ return floor(x); } + +/* +** Implementation of SQL functions: +** +** ln(X) - natural logarithm +** log(X) - log X base 10 +** log10(X) - log X base 10 +** log(B,X) - log X base B +*/ +static void logFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + double x, b, ans; + assert( argc==1 || argc==2 ); + switch( sqlite3_value_numeric_type(argv[0]) ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: + x = sqlite3_value_double(argv[0]); + if( x<=0.0 ) return; + break; + default: + return; + } + if( argc==2 ){ + switch( sqlite3_value_numeric_type(argv[0]) ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: + b = log(x); + if( b<=0.0 ) return; + x = sqlite3_value_double(argv[1]); + if( x<=0.0 ) return; + break; + default: + return; + } + ans = log(x)/b; + }else{ + ans = log(x); + switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){ + case 1: + /* Convert from natural logarithm to log base 10 */ + ans *= 1.0/M_LN10; + break; + case 2: + /* Convert from natural logarithm to log base 2 */ + ans *= 1.0/M_LN2; + break; + default: + break; + } + } + sqlite3_result_double(context, ans); +} + +/* +** Functions to converts degrees to radians and radians to degrees. +*/ +static double degToRad(double x){ return x*(M_PI/180.0); } +static double radToDeg(double x){ return x*(180.0/M_PI); } + +/* +** Implementation of 1-argument SQL math functions: +** +** exp(X) - Compute e to the X-th power +*/ +static void math1Func( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int type0; + double v0, ans; + double (*x)(double); + assert( argc==1 ); + type0 = sqlite3_value_numeric_type(argv[0]); + if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; + v0 = sqlite3_value_double(argv[0]); + x = (double(*)(double))sqlite3_user_data(context); + ans = x(v0); + sqlite3_result_double(context, ans); +} + +/* +** Implementation of 2-argument SQL math functions: +** +** power(X,Y) - Compute X to the Y-th power +*/ +static void math2Func( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int type0, type1; + double v0, v1, ans; + double (*x)(double,double); + assert( argc==2 ); + type0 = sqlite3_value_numeric_type(argv[0]); + if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; + type1 = sqlite3_value_numeric_type(argv[1]); + if( type1!=SQLITE_INTEGER && type1!=SQLITE_FLOAT ) return; + v0 = sqlite3_value_double(argv[0]); + v1 = sqlite3_value_double(argv[1]); + x = (double(*)(double,double))sqlite3_user_data(context); + ans = x(v0, v1); + sqlite3_result_double(context, ans); +} + +/* +** Implementation of 0-argument pi() function. +*/ +static void piFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + assert( argc==0 ); + sqlite3_result_double(context, M_PI); +} + +#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */ + +/* +** Implementation of sign(X) function. +*/ +static void signFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int type0; + double x; + UNUSED_PARAMETER(argc); + assert( argc==1 ); + type0 = sqlite3_value_numeric_type(argv[0]); + if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; + x = sqlite3_value_double(argv[0]); + sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0); +} + /* ** All of the FuncDef structures in the aBuiltinFunc[] array above ** to the global function hash table. This occurs at start-time (as @@ -119465,12 +122365,12 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){ */ static FuncDef aBuiltinFunc[] = { /***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/ +#if !defined(SQLITE_UNTESTABLE) TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0), TEST_FUNC(expr_compare, 2, INLINEFUNC_expr_compare, 0), TEST_FUNC(expr_implies_expr, 2, INLINEFUNC_expr_implies_expr, 0), -#ifdef SQLITE_DEBUG - TEST_FUNC(affinity, 1, INLINEFUNC_affinity, 0), -#endif + TEST_FUNC(affinity, 1, INLINEFUNC_affinity, 0), +#endif /* !defined(SQLITE_UNTESTABLE) */ /***** Regular functions *****/ #ifdef SQLITE_SOUNDEX FUNCTION(soundex, 1, 0, 0, soundexFunc ), @@ -119502,11 +122402,11 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){ FUNCTION(min, -1, 0, 1, minmaxFunc ), FUNCTION(min, 0, 0, 1, 0 ), WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, - SQLITE_FUNC_MINMAX ), + SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ), FUNCTION(max, -1, 1, 1, minmaxFunc ), FUNCTION(max, 0, 1, 1, 0 ), WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, - SQLITE_FUNC_MINMAX ), + SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ), FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), FUNCTION(instr, 2, 0, 0, instrFunc ), @@ -119542,9 +122442,10 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){ WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0), WAGGREGATE(avg, 1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0), WAGGREGATE(count, 0,0,0, countStep, - countFinalize, countFinalize, countInverse, SQLITE_FUNC_COUNT ), + countFinalize, countFinalize, countInverse, + SQLITE_FUNC_COUNT|SQLITE_FUNC_ANYORDER ), WAGGREGATE(count, 1,0,0, countStep, - countFinalize, countFinalize, countInverse, 0 ), + countFinalize, countFinalize, countInverse, SQLITE_FUNC_ANYORDER ), WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep, groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep, @@ -119563,6 +122464,43 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){ #endif FUNCTION(coalesce, 1, 0, 0, 0 ), FUNCTION(coalesce, 0, 0, 0, 0 ), +#ifdef SQLITE_ENABLE_MATH_FUNCTIONS + MFUNCTION(ceil, 1, xCeil, ceilingFunc ), + MFUNCTION(ceiling, 1, xCeil, ceilingFunc ), + MFUNCTION(floor, 1, xFloor, ceilingFunc ), +#if SQLITE_HAVE_C99_MATH_FUNCS + MFUNCTION(trunc, 1, trunc, ceilingFunc ), +#endif + FUNCTION(ln, 1, 0, 0, logFunc ), + FUNCTION(log, 1, 1, 0, logFunc ), + FUNCTION(log10, 1, 1, 0, logFunc ), + FUNCTION(log2, 1, 2, 0, logFunc ), + FUNCTION(log, 2, 0, 0, logFunc ), + MFUNCTION(exp, 1, exp, math1Func ), + MFUNCTION(pow, 2, pow, math2Func ), + MFUNCTION(power, 2, pow, math2Func ), + MFUNCTION(mod, 2, fmod, math2Func ), + MFUNCTION(acos, 1, acos, math1Func ), + MFUNCTION(asin, 1, asin, math1Func ), + MFUNCTION(atan, 1, atan, math1Func ), + MFUNCTION(atan2, 2, atan2, math2Func ), + MFUNCTION(cos, 1, cos, math1Func ), + MFUNCTION(sin, 1, sin, math1Func ), + MFUNCTION(tan, 1, tan, math1Func ), + MFUNCTION(cosh, 1, cosh, math1Func ), + MFUNCTION(sinh, 1, sinh, math1Func ), + MFUNCTION(tanh, 1, tanh, math1Func ), +#if SQLITE_HAVE_C99_MATH_FUNCS + MFUNCTION(acosh, 1, acosh, math1Func ), + MFUNCTION(asinh, 1, asinh, math1Func ), + MFUNCTION(atanh, 1, atanh, math1Func ), +#endif + MFUNCTION(sqrt, 1, sqrt, math1Func ), + MFUNCTION(radians, 1, degToRad, math1Func ), + MFUNCTION(degrees, 1, radToDeg, math1Func ), + FUNCTION(pi, 0, 0, 0, piFunc ), +#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */ + FUNCTION(sign, 1, 0, 0, signFunc ), INLINE_FUNC(coalesce, -1, INLINEFUNC_coalesce, 0 ), INLINE_FUNC(iif, 3, INLINEFUNC_iif, 0 ), }; @@ -119582,6 +122520,7 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){ for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){ int n = sqlite3Strlen30(p->zName); int h = p->zName[0] + n; + assert( p->funcFlags & SQLITE_FUNC_BUILTIN ); printf(" %s(%d)", p->zName, h); } printf("\n"); @@ -119809,7 +122748,9 @@ SQLITE_PRIVATE int sqlite3FkLocateIndex( */ if( pParent->iPKey>=0 ){ if( !zKey ) return 0; - if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0; + if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zCnName, zKey) ){ + return 0; + } } }else if( paiCol ){ assert( nCol>1 ); @@ -119851,11 +122792,11 @@ SQLITE_PRIVATE int sqlite3FkLocateIndex( /* If the index uses a collation sequence that is different from ** the default collation sequence for the column, this index is ** unusable. Bail out early in this case. */ - zDfltColl = pParent->aCol[iCol].zColl; + zDfltColl = sqlite3ColumnColl(&pParent->aCol[iCol]); if( !zDfltColl ) zDfltColl = sqlite3StrBINARY; if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break; - zIdxCol = pParent->aCol[iCol].zName; + zIdxCol = pParent->aCol[iCol].zCnName; for(j=0; jaCol[j].zCol, zIdxCol)==0 ){ if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom; @@ -120079,7 +123020,7 @@ static Expr *exprTableRegister( pCol = &pTab->aCol[iCol]; pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1; pExpr->affExpr = pCol->affinity; - zColl = pCol->zColl; + zColl = sqlite3ColumnColl(pCol); if( zColl==0 ) zColl = db->pDfltColl->zName; pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl); }else{ @@ -120102,6 +123043,7 @@ static Expr *exprTableColumn( ){ Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0); if( pExpr ){ + assert( ExprUseYTab(pExpr) ); pExpr->y.pTab = pTab; pExpr->iTable = iCursor; pExpr->iColumn = iCol; @@ -120188,7 +123130,7 @@ static void fkScanChildren( pLeft = exprTableRegister(pParse, pTab, regData, iCol); iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; assert( iCol>=0 ); - zCol = pFKey->pFrom->aCol[iCol].zName; + zCol = pFKey->pFrom->aCol[iCol].zCnName; pRight = sqlite3Expr(db, TK_ID, zCol); pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight); pWhere = sqlite3ExprAnd(pParse, pWhere, pEq); @@ -120223,7 +123165,7 @@ static void fkScanChildren( i16 iCol = pIdx->aiColumn[i]; assert( iCol>=0 ); pLeft = exprTableRegister(pParse, pTab, regData, iCol); - pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zName); + pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName); pEq = sqlite3PExpr(pParse, TK_IS, pLeft, pRight); pAll = sqlite3ExprAnd(pParse, pAll, pEq); } @@ -120312,12 +123254,12 @@ static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){ */ SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){ sqlite3 *db = pParse->db; - if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) ){ + if( (db->flags&SQLITE_ForeignKeys) && IsOrdinaryTable(pTab) ){ int iSkip = 0; Vdbe *v = sqlite3GetVdbe(pParse); assert( v ); /* VDBE has already been allocated */ - assert( pTab->pSelect==0 ); /* Not a view */ + assert( IsOrdinaryTable(pTab) ); if( sqlite3FkReferences(pTab)==0 ){ /* Search for a deferred foreign key constraint for which this table ** is the child table. If one cannot be found, return without @@ -120325,7 +123267,7 @@ SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTa ** the entire DELETE if there are no outstanding deferred constraints ** when this statement is run. */ FKey *p; - for(p=pTab->pFKey; p; p=p->pNextFrom){ + for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){ if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break; } if( !p ) return; @@ -120414,7 +123356,7 @@ static int fkParentIsModified( if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){ Column *pCol = &pTab->aCol[iKey]; if( zKey ){ - if( 0==sqlite3StrICmp(pCol->zName, zKey) ) return 1; + if( 0==sqlite3StrICmp(pCol->zCnName, zKey) ) return 1; }else if( pCol->colFlags & COLFLAG_PRIMKEY ){ return 1; } @@ -120481,13 +123423,14 @@ SQLITE_PRIVATE void sqlite3FkCheck( /* If foreign-keys are disabled, this function is a no-op. */ if( (db->flags&SQLITE_ForeignKeys)==0 ) return; + if( !IsOrdinaryTable(pTab) ) return; iDb = sqlite3SchemaToIndex(db, pTab->pSchema); zDb = db->aDb[iDb].zDbSName; /* Loop through all the foreign key constraints for which pTab is the ** child table (the table that the foreign key definition is part of). */ - for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ Table *pTo; /* Parent table of foreign key pFKey */ Index *pIdx = 0; /* Index on key columns in pTo */ int *aiFree = 0; @@ -120554,7 +123497,7 @@ SQLITE_PRIVATE void sqlite3FkCheck( ** values read from the parent table are NULL. */ if( db->xAuth ){ int rcauth; - char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName; + char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zCnName; rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb); bIgnore = (rcauth==SQLITE_IGNORE); } @@ -120618,7 +123561,7 @@ SQLITE_PRIVATE void sqlite3FkCheck( ** child table as a SrcList for sqlite3WhereBegin() */ pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); if( pSrc ){ - struct SrcList_item *pItem = pSrc->a; + SrcItem *pItem = pSrc->a; pItem->pTab = pFKey->pFrom; pItem->zName = pFKey->pFrom->zName; pItem->pTab->nTabRef++; @@ -120669,10 +123612,10 @@ SQLITE_PRIVATE u32 sqlite3FkOldmask( Table *pTab /* Table being modified */ ){ u32 mask = 0; - if( pParse->db->flags&SQLITE_ForeignKeys ){ + if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){ FKey *p; int i; - for(p=pTab->pFKey; p; p=p->pNextFrom){ + for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){ for(i=0; inCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom); } for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ @@ -120706,7 +123649,9 @@ SQLITE_PRIVATE u32 sqlite3FkOldmask( ** ** For an UPDATE, this function returns 2 if: ** -** * There are any FKs for which pTab is the child and the parent table, or +** * There are any FKs for which pTab is the child and the parent table +** and any FK processing at all is required (even of a different FK), or +** ** * the UPDATE modifies one or more parent keys for which the action is ** not "NO ACTION" (i.e. is CASCADE, SET DEFAULT or SET NULL). ** @@ -120718,23 +123663,24 @@ SQLITE_PRIVATE int sqlite3FkRequired( int *aChange, /* Non-NULL for UPDATE operations */ int chngRowid /* True for UPDATE that affects rowid */ ){ - int eRet = 0; - if( pParse->db->flags&SQLITE_ForeignKeys ){ + int eRet = 1; /* Value to return if bHaveFK is true */ + int bHaveFK = 0; /* If FK processing is required */ + if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){ if( !aChange ){ /* A DELETE operation. Foreign key processing is required if the ** table in question is either the child or parent table for any ** foreign key constraint. */ - eRet = (sqlite3FkReferences(pTab) || pTab->pFKey); + bHaveFK = (sqlite3FkReferences(pTab) || pTab->u.tab.pFKey); }else{ /* This is an UPDATE. Foreign key processing is only required if the ** operation modifies one or more child or parent key columns. */ FKey *p; /* Check if any child key columns are being modified. */ - for(p=pTab->pFKey; p; p=p->pNextFrom){ - if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) return 2; + for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){ if( fkChildIsModified(pTab, p, aChange, chngRowid) ){ - eRet = 1; + if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2; + bHaveFK = 1; } } @@ -120742,12 +123688,12 @@ SQLITE_PRIVATE int sqlite3FkRequired( for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ if( fkParentIsModified(pTab, p, aChange, chngRowid) ){ if( p->aAction[1]!=OE_None ) return 2; - eRet = 1; + bHaveFK = 1; } } } } - return eRet; + return bHaveFK ? eRet : 0; } /* @@ -120824,8 +123770,8 @@ static Trigger *fkActionTrigger( assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKeynCol) ); assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); sqlite3TokenInit(&tToCol, - pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName); - sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zName); + pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zCnName); + sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zCnName); /* Create the expression "OLD.zToCol = zFromCol". It is important ** that the "OLD.zToCol" term is on the LHS of the = operator, so @@ -120870,7 +123816,7 @@ static Trigger *fkActionTrigger( testcase( pCol->colFlags & COLFLAG_STORED ); pDflt = 0; }else{ - pDflt = pCol->pDflt; + pDflt = sqlite3ColumnExpr(pFKey->pFrom, pCol); } if( pDflt ){ pNew = sqlite3ExprDup(db, pDflt, 0); @@ -121007,9 +123953,9 @@ SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){ FKey *pFKey; /* Iterator variable */ FKey *pNext; /* Copy of pFKey->pNextFrom */ - assert( db==0 || IsVirtual(pTab) - || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) ); - for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){ + assert( IsOrdinaryTable(pTab) ); + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pNext){ + assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) ); /* Remove the FK from the fkeyHash hash table. */ if( !db || db->pnBytesFreed==0 ){ @@ -121156,28 +124102,68 @@ SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){ } /* +** Make changes to the evolving bytecode to do affinity transformations +** of values that are about to be gathered into a row for table pTab. +** +** For ordinary (legacy, non-strict) tables: +** ----------------------------------------- +** ** Compute the affinity string for table pTab, if it has not already been ** computed. As an optimization, omit trailing SQLITE_AFF_BLOB affinities. ** -** If the affinity exists (if it is no entirely SQLITE_AFF_BLOB values) and -** if iReg>0 then code an OP_Affinity opcode that will set the affinities -** for register iReg and following. Or if affinities exists and iReg==0, +** If the affinity string is empty (because it was all SQLITE_AFF_BLOB entries +** which were then optimized out) then this routine becomes a no-op. +** +** Otherwise if iReg>0 then code an OP_Affinity opcode that will set the +** affinities for register iReg and following. Or if iReg==0, ** then just set the P4 operand of the previous opcode (which should be ** an OP_MakeRecord) to the affinity string. ** ** A column affinity string has one character per column: ** -** Character Column affinity -** ------------------------------ -** 'A' BLOB -** 'B' TEXT -** 'C' NUMERIC -** 'D' INTEGER -** 'E' REAL +** Character Column affinity +** --------- --------------- +** 'A' BLOB +** 'B' TEXT +** 'C' NUMERIC +** 'D' INTEGER +** 'E' REAL +** +** For STRICT tables: +** ------------------ +** +** Generate an appropropriate OP_TypeCheck opcode that will verify the +** datatypes against the column definitions in pTab. If iReg==0, that +** means an OP_MakeRecord opcode has already been generated and should be +** the last opcode generated. The new OP_TypeCheck needs to be inserted +** before the OP_MakeRecord. The new OP_TypeCheck should use the same +** register set as the OP_MakeRecord. If iReg>0 then register iReg is +** the first of a series of registers that will form the new record. +** Apply the type checking to that array of registers. */ SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){ int i, j; - char *zColAff = pTab->zColAff; + char *zColAff; + if( pTab->tabFlags & TF_Strict ){ + if( iReg==0 ){ + /* Move the previous opcode (which should be OP_MakeRecord) forward + ** by one slot and insert a new OP_TypeCheck where the current + ** OP_MakeRecord is found */ + VdbeOp *pPrev; + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); + pPrev = sqlite3VdbeGetOp(v, -1); + assert( pPrev!=0 ); + assert( pPrev->opcode==OP_MakeRecord || sqlite3VdbeDb(v)->mallocFailed ); + pPrev->opcode = OP_TypeCheck; + sqlite3VdbeAddOp3(v, OP_MakeRecord, pPrev->p1, pPrev->p2, pPrev->p3); + }else{ + /* Insert an isolated OP_Typecheck */ + sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol); + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); + } + return; + } + zColAff = pTab->zColAff; if( zColAff==0 ){ sqlite3 *db = sqlite3VdbeDb(v); zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1); @@ -121203,6 +124189,8 @@ SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){ if( iReg ){ sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i); }else{ + assert( sqlite3VdbeGetOp(v, -1)->opcode==OP_MakeRecord + || sqlite3VdbeDb(v)->mallocFailed ); sqlite3VdbeChangeP4(v, -1, zColAff, i); } } @@ -121286,24 +124274,30 @@ SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns( ** that appropriate affinity has been applied to the regular columns */ sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore); - if( (pTab->tabFlags & TF_HasStored)!=0 - && (pOp = sqlite3VdbeGetOp(pParse->pVdbe,-1))->opcode==OP_Affinity - ){ - /* Change the OP_Affinity argument to '@' (NONE) for all stored - ** columns. '@' is the no-op affinity and those columns have not - ** yet been computed. */ - int ii, jj; - char *zP4 = pOp->p4.z; - assert( zP4!=0 ); - assert( pOp->p4type==P4_DYNAMIC ); - for(ii=jj=0; zP4[jj]; ii++){ - if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){ - continue; - } - if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){ - zP4[jj] = SQLITE_AFF_NONE; + if( (pTab->tabFlags & TF_HasStored)!=0 ){ + pOp = sqlite3VdbeGetOp(pParse->pVdbe,-1); + if( pOp->opcode==OP_Affinity ){ + /* Change the OP_Affinity argument to '@' (NONE) for all stored + ** columns. '@' is the no-op affinity and those columns have not + ** yet been computed. */ + int ii, jj; + char *zP4 = pOp->p4.z; + assert( zP4!=0 ); + assert( pOp->p4type==P4_DYNAMIC ); + for(ii=jj=0; zP4[jj]; ii++){ + if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){ + continue; + } + if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){ + zP4[jj] = SQLITE_AFF_NONE; + } + jj++; } - jj++; + }else if( pOp->opcode==OP_TypeCheck ){ + /* If an OP_TypeCheck was generated because the table is STRICT, + ** then set the P3 operand to indicate that generated columns should + ** not be checked */ + pOp->p3 = 1; } } @@ -121339,7 +124333,7 @@ SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns( int x; pCol->colFlags |= COLFLAG_BUSY; w.eCode = 0; - sqlite3WalkExpr(&w, pCol->pDflt); + sqlite3WalkExpr(&w, sqlite3ColumnExpr(pTab, pCol)); pCol->colFlags &= ~COLFLAG_BUSY; if( w.eCode & COLFLAG_NOTAVAIL ){ pRedo = pCol; @@ -121348,13 +124342,13 @@ SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns( eProgress = 1; assert( pCol->colFlags & COLFLAG_GENERATED ); x = sqlite3TableColumnToStorage(pTab, i) + iRegStore; - sqlite3ExprCodeGeneratedColumn(pParse, pCol, x); + sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, x); pCol->colFlags &= ~COLFLAG_NOTAVAIL; } } }while( pRedo && eProgress ); if( pRedo ){ - sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zName); + sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zCnName); } pParse->iSelfTab = 0; } @@ -121404,7 +124398,7 @@ static int autoIncBegin( ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */ if( pSeqTab==0 || !HasRowid(pSeqTab) - || IsVirtual(pSeqTab) + || NEVER(IsVirtual(pSeqTab)) || pSeqTab->nCol!=2 ){ pParse->nErr++; @@ -121416,7 +124410,9 @@ static int autoIncBegin( while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; } if( pInfo==0 ){ pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo)); - if( pInfo==0 ) return 0; + sqlite3ParserAddCleanup(pToplevel, sqlite3DbFree, pInfo); + testcase( pParse->earlyCleanup ); + if( pParse->db->mallocFailed ) return 0; pInfo->pNext = pToplevel->pAinc; pToplevel->pAinc = pInfo; pInfo->pTab = pTab; @@ -121747,7 +124743,7 @@ SQLITE_PRIVATE void sqlite3Insert( */ #ifndef SQLITE_OMIT_TRIGGER pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask); - isView = pTab->pSelect!=0; + isView = IsView(pTab); #else # define pTrigger 0 # define tmask 0 @@ -121838,7 +124834,7 @@ SQLITE_PRIVATE void sqlite3Insert( } for(i=0; inId; i++){ for(j=0; jnCol; j++){ - if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){ + if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){ pColumn->a[i].idx = j; if( i!=j ) bIdListInOrder = 0; if( j==pTab->iPKey ){ @@ -121848,7 +124844,7 @@ SQLITE_PRIVATE void sqlite3Insert( if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){ sqlite3ErrorMsg(pParse, "cannot INSERT into generated column \"%s\"", - pTab->aCol[j].zName); + pTab->aCol[j].zCnName); goto insert_cleanup; } #endif @@ -121861,7 +124857,7 @@ SQLITE_PRIVATE void sqlite3Insert( bIdListInOrder = 0; }else{ sqlite3ErrorMsg(pParse, "table %S has no column named %s", - pTabList, 0, pColumn->a[i].zName); + pTabList->a, pColumn->a[i].zName); pParse->checkSchema = 1; goto insert_cleanup; } @@ -121974,19 +124970,24 @@ SQLITE_PRIVATE void sqlite3Insert( } } #endif - } - /* Make sure the number of columns in the source data matches the number - ** of columns to be inserted into the table. - */ - for(i=0; inCol; i++){ - if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++; - } - if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){ - sqlite3ErrorMsg(pParse, - "table %S has %d columns but %d values were supplied", - pTabList, 0, pTab->nCol-nHidden, nColumn); - goto insert_cleanup; + /* Make sure the number of columns in the source data matches the number + ** of columns to be inserted into the table. + */ + assert( TF_HasHidden==COLFLAG_HIDDEN ); + assert( TF_HasGenerated==COLFLAG_GENERATED ); + assert( COLFLAG_NOINSERT==(COLFLAG_GENERATED|COLFLAG_HIDDEN) ); + if( (pTab->tabFlags & (TF_HasGenerated|TF_HasHidden))!=0 ){ + for(i=0; inCol; i++){ + if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++; + } + } + if( nColumn!=(pTab->nCol-nHidden) ){ + sqlite3ErrorMsg(pParse, + "table %S has %d columns but %d values were supplied", + pTabList->a, pTab->nCol-nHidden, nColumn); + goto insert_cleanup; + } } if( pColumn!=0 && nColumn!=pColumn->nId ){ sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId); @@ -121998,6 +124999,7 @@ SQLITE_PRIVATE void sqlite3Insert( if( (db->flags & SQLITE_CountRows)!=0 && !pParse->nested && !pParse->pTriggerTab + && !pParse->bReturning ){ regRowCount = ++pParse->nMem; sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); @@ -122021,12 +125023,13 @@ SQLITE_PRIVATE void sqlite3Insert( } #ifndef SQLITE_OMIT_UPSERT if( pUpsert ){ + Upsert *pNx; if( IsVirtual(pTab) ){ sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"", pTab->zName); goto insert_cleanup; } - if( pTab->pSelect ){ + if( IsView(pTab) ){ sqlite3ErrorMsg(pParse, "cannot UPSERT a view"); goto insert_cleanup; } @@ -122034,13 +125037,19 @@ SQLITE_PRIVATE void sqlite3Insert( goto insert_cleanup; } pTabList->a[0].iCursor = iDataCur; - pUpsert->pUpsertSrc = pTabList; - pUpsert->regData = regData; - pUpsert->iDataCur = iDataCur; - pUpsert->iIdxCur = iIdxCur; - if( pUpsert->pUpsertTarget ){ - sqlite3UpsertAnalyzeTarget(pParse, pTabList, pUpsert); - } + pNx = pUpsert; + do{ + pNx->pUpsertSrc = pTabList; + pNx->regData = regData; + pNx->iDataCur = iDataCur; + pNx->iIdxCur = iIdxCur; + if( pNx->pUpsertTarget ){ + if( sqlite3UpsertAnalyzeTarget(pParse, pTabList, pNx) ){ + goto insert_cleanup; + } + } + pNx = pNx->pNextUpsert; + }while( pNx!=0 ); } #endif @@ -122119,7 +125128,9 @@ SQLITE_PRIVATE void sqlite3Insert( }else if( pColumn==0 ){ /* Hidden columns that are not explicitly named in the INSERT ** get there default value */ - sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore); + sqlite3ExprCodeFactorable(pParse, + sqlite3ColumnExpr(pTab, &pTab->aCol[i]), + iRegStore); continue; } } @@ -122128,13 +125139,17 @@ SQLITE_PRIVATE void sqlite3Insert( if( j>=pColumn->nId ){ /* A column not named in the insert column list gets its ** default value */ - sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore); + sqlite3ExprCodeFactorable(pParse, + sqlite3ColumnExpr(pTab, &pTab->aCol[i]), + iRegStore); continue; } k = j; }else if( nColumn==0 ){ /* This is INSERT INTO ... DEFAULT VALUES. Load the default value. */ - sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore); + sqlite3ExprCodeFactorable(pParse, + sqlite3ColumnExpr(pTab, &pTab->aCol[i]), + iRegStore); continue; }else{ k = i - nHidden; @@ -122181,11 +125196,6 @@ SQLITE_PRIVATE void sqlite3Insert( sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v); } - /* Cannot have triggers on a virtual table. If it were possible, - ** this block would have to account for hidden column. - */ - assert( !IsVirtual(pTab) ); - /* Copy the new data already generated. */ assert( pTab->nNVCol>0 ); sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1); @@ -122284,7 +125294,7 @@ SQLITE_PRIVATE void sqlite3Insert( }else #endif { - int isReplace; /* Set to true if constraints may cause a replace */ + int isReplace = 0;/* Set to true if constraints may cause a replace */ int bUseSeek; /* True to use OPFLAG_SEEKRESULT */ sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0, pUpsert @@ -122304,6 +125314,13 @@ SQLITE_PRIVATE void sqlite3Insert( regIns, aRegIdx, 0, appendFlag, bUseSeek ); } +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW + }else if( pParse->bReturning ){ + /* If there is a RETURNING clause, populate the rowid register with + ** constant value -1, in case one or more of the returned expressions + ** refer to the "rowid" of the view. */ + sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid); +#endif } /* Update the count of rows that are inserted @@ -122340,7 +125357,9 @@ SQLITE_PRIVATE void sqlite3Insert( sqlite3VdbeJumpHere(v, addrInsTop); } +#ifndef SQLITE_OMIT_XFER_OPT insert_end: +#endif /* SQLITE_OMIT_XFER_OPT */ /* Update the sqlite_sequence table by storing the content of the ** maximum rowid counter values recorded while inserting into ** autoincrement tables. @@ -122355,7 +125374,7 @@ SQLITE_PRIVATE void sqlite3Insert( ** invoke the callback function. */ if( regRowCount ){ - sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1); + sqlite3VdbeAddOp2(v, OP_ChngCntRow, regRowCount, 1); sqlite3VdbeSetNumCols(v, 1); sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC); } @@ -122445,6 +125464,70 @@ SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn( return w.eCode!=0; } +/* +** The sqlite3GenerateConstraintChecks() routine usually wants to visit +** the indexes of a table in the order provided in the Table->pIndex list. +** However, sometimes (rarely - when there is an upsert) it wants to visit +** the indexes in a different order. The following data structures accomplish +** this. +** +** The IndexIterator object is used to walk through all of the indexes +** of a table in either Index.pNext order, or in some other order established +** by an array of IndexListTerm objects. +*/ +typedef struct IndexListTerm IndexListTerm; +typedef struct IndexIterator IndexIterator; +struct IndexIterator { + int eType; /* 0 for Index.pNext list. 1 for an array of IndexListTerm */ + int i; /* Index of the current item from the list */ + union { + struct { /* Use this object for eType==0: A Index.pNext list */ + Index *pIdx; /* The current Index */ + } lx; + struct { /* Use this object for eType==1; Array of IndexListTerm */ + int nIdx; /* Size of the array */ + IndexListTerm *aIdx; /* Array of IndexListTerms */ + } ax; + } u; +}; + +/* When IndexIterator.eType==1, then each index is an array of instances +** of the following object +*/ +struct IndexListTerm { + Index *p; /* The index */ + int ix; /* Which entry in the original Table.pIndex list is this index*/ +}; + +/* Return the first index on the list */ +static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){ + assert( pIter->i==0 ); + if( pIter->eType ){ + *pIx = pIter->u.ax.aIdx[0].ix; + return pIter->u.ax.aIdx[0].p; + }else{ + *pIx = 0; + return pIter->u.lx.pIdx; + } +} + +/* Return the next index from the list. Return NULL when out of indexes */ +static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){ + if( pIter->eType ){ + int i = ++pIter->i; + if( i>=pIter->u.ax.nIdx ){ + *pIx = i; + return 0; + } + *pIx = pIter->u.ax.aIdx[i].ix; + return pIter->u.ax.aIdx[i].p; + }else{ + ++(*pIx); + pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext; + return pIter->u.lx.pIdx; + } +} + /* ** Generate code to do constraint checks prior to an INSERT or an UPDATE ** on table pTab. @@ -122553,7 +125636,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( ){ Vdbe *v; /* VDBE under constrution */ Index *pIdx; /* Pointer to one of the indices */ - Index *pPk = 0; /* The PRIMARY KEY index */ + Index *pPk = 0; /* The PRIMARY KEY index for WITHOUT ROWID tables */ sqlite3 *db; /* Database connection */ int i; /* loop counter */ int ix; /* Index loop counter */ @@ -122561,11 +125644,11 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( int onError; /* Conflict resolution strategy */ int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */ int nPkField; /* Number of fields in PRIMARY KEY. 1 for ROWID tables */ - Index *pUpIdx = 0; /* Index to which to apply the upsert */ - u8 isUpdate; /* True if this is an UPDATE operation */ + Upsert *pUpsertClause = 0; /* The specific ON CONFLICT clause for pIdx */ + u8 isUpdate; /* True if this is an UPDATE operation */ u8 bAffinityDone = 0; /* True if the OP_Affinity operation has been run */ - int upsertBypass = 0; /* Address of Goto to bypass upsert subroutine */ - int upsertJump = 0; /* Address of Goto that jumps into upsert subroutine */ + int upsertIpkReturn = 0; /* Address of Goto at end of IPK uniqueness check */ + int upsertIpkDelay = 0; /* Address of Goto to bypass initial IPK check */ int ipkTop = 0; /* Top of the IPK uniqueness check */ int ipkBottom = 0; /* OP_Goto at the end of the IPK uniqueness check */ /* Variables associated with retesting uniqueness constraints after @@ -122575,12 +125658,13 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( int lblRecheckOk = 0; /* Each recheck jumps to this label if it passes */ Trigger *pTrigger; /* List of DELETE triggers on the table pTab */ int nReplaceTrig = 0; /* Number of replace triggers coded */ + IndexIterator sIdxIter; /* Index iterator */ isUpdate = regOldData!=0; db = pParse->db; v = pParse->pVdbe; assert( v!=0 ); - assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + assert( !IsView(pTab) ); /* This table is not a VIEW */ nCol = pTab->nCol; /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for @@ -122631,7 +125715,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( } if( onError==OE_Replace ){ if( b2ndPass /* REPLACE becomes ABORT on the 2nd pass */ - || pCol->pDflt==0 /* REPLACE is ABORT if no DEFAULT value */ + || pCol->iDflt==0 /* REPLACE is ABORT if no DEFAULT value */ ){ testcase( pCol->colFlags & COLFLAG_VIRTUAL ); testcase( pCol->colFlags & COLFLAG_STORED ); @@ -122653,7 +125737,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( VdbeCoverage(v); assert( (pCol->colFlags & COLFLAG_GENERATED)==0 ); nSeenReplace++; - sqlite3ExprCodeCopy(pParse, pCol->pDflt, iReg); + sqlite3ExprCodeCopy(pParse, + sqlite3ColumnExpr(pTab, pCol), iReg); sqlite3VdbeJumpHere(v, addr1); break; } @@ -122663,7 +125748,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( case OE_Rollback: case OE_Fail: { char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName, - pCol->zName); + pCol->zCnName); sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL, onError, iReg); sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC); @@ -122772,19 +125857,63 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( ** list of indexes attached to a table puts all OE_Replace indexes last ** in the list. See sqlite3CreateIndex() for where that happens. */ - + sIdxIter.eType = 0; + sIdxIter.i = 0; + sIdxIter.u.ax.aIdx = 0; /* Silence harmless compiler warning */ + sIdxIter.u.lx.pIdx = pTab->pIndex; if( pUpsert ){ if( pUpsert->pUpsertTarget==0 ){ - /* An ON CONFLICT DO NOTHING clause, without a constraint-target. - ** Make all unique constraint resolution be OE_Ignore */ - assert( pUpsert->pUpsertSet==0 ); - overrideError = OE_Ignore; - pUpsert = 0; - }else if( (pUpIdx = pUpsert->pUpsertIdx)!=0 ){ - /* If the constraint-target uniqueness check must be run first. - ** Jump to that uniqueness check now */ - upsertJump = sqlite3VdbeAddOp0(v, OP_Goto); - VdbeComment((v, "UPSERT constraint goes first")); + /* There is just on ON CONFLICT clause and it has no constraint-target */ + assert( pUpsert->pNextUpsert==0 ); + if( pUpsert->isDoUpdate==0 ){ + /* A single ON CONFLICT DO NOTHING clause, without a constraint-target. + ** Make all unique constraint resolution be OE_Ignore */ + overrideError = OE_Ignore; + pUpsert = 0; + }else{ + /* A single ON CONFLICT DO UPDATE. Make all resolutions OE_Update */ + overrideError = OE_Update; + } + }else if( pTab->pIndex!=0 ){ + /* Otherwise, we'll need to run the IndexListTerm array version of the + ** iterator to ensure that all of the ON CONFLICT conditions are + ** checked first and in order. */ + int nIdx, jj; + u64 nByte; + Upsert *pTerm; + u8 *bUsed; + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ + assert( aRegIdx[nIdx]>0 ); + } + sIdxIter.eType = 1; + sIdxIter.u.ax.nIdx = nIdx; + nByte = (sizeof(IndexListTerm)+1)*nIdx + nIdx; + sIdxIter.u.ax.aIdx = sqlite3DbMallocZero(db, nByte); + if( sIdxIter.u.ax.aIdx==0 ) return; /* OOM */ + bUsed = (u8*)&sIdxIter.u.ax.aIdx[nIdx]; + pUpsert->pToFree = sIdxIter.u.ax.aIdx; + for(i=0, pTerm=pUpsert; pTerm; pTerm=pTerm->pNextUpsert){ + if( pTerm->pUpsertTarget==0 ) break; + if( pTerm->pUpsertIdx==0 ) continue; /* Skip ON CONFLICT for the IPK */ + jj = 0; + pIdx = pTab->pIndex; + while( ALWAYS(pIdx!=0) && pIdx!=pTerm->pUpsertIdx ){ + pIdx = pIdx->pNext; + jj++; + } + if( bUsed[jj] ) continue; /* Duplicate ON CONFLICT clause ignored */ + bUsed[jj] = 1; + sIdxIter.u.ax.aIdx[i].p = pIdx; + sIdxIter.u.ax.aIdx[i].ix = jj; + i++; + } + for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){ + if( bUsed[jj] ) continue; + sIdxIter.u.ax.aIdx[i].p = pIdx; + sIdxIter.u.ax.aIdx[i].ix = jj; + i++; + } + assert( i==nIdx ); } } @@ -122847,11 +125976,20 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( } /* figure out whether or not upsert applies in this case */ - if( pUpsert && pUpsert->pUpsertIdx==0 ){ - if( pUpsert->pUpsertSet==0 ){ - onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */ - }else{ - onError = OE_Update; /* DO UPDATE */ + if( pUpsert ){ + pUpsertClause = sqlite3UpsertOfIndex(pUpsert,0); + if( pUpsertClause!=0 ){ + if( pUpsertClause->isDoUpdate==0 ){ + onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */ + }else{ + onError = OE_Update; /* DO UPDATE */ + } + } + if( pUpsertClause!=pUpsert ){ + /* The first ON CONFLICT clause has a conflict target other than + ** the IPK. We have to jump ahead to that first ON CONFLICT clause + ** and then come back here and deal with the IPK afterwards */ + upsertIpkDelay = sqlite3VdbeAddOp0(v, OP_Goto); } } @@ -122861,7 +125999,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( ** the UNIQUE constraints have run. */ if( onError==OE_Replace /* IPK rule is REPLACE */ - && onError!=overrideError /* Rules for other contraints are different */ + && onError!=overrideError /* Rules for other constraints are different */ && pTab->pIndex /* There exist other constraints */ ){ ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1; @@ -122958,7 +126096,9 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( } } sqlite3VdbeResolveLabel(v, addrRowidOk); - if( ipkTop ){ + if( pUpsert && pUpsertClause!=pUpsert ){ + upsertIpkReturn = sqlite3VdbeAddOp0(v, OP_Goto); + }else if( ipkTop ){ ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto); sqlite3VdbeJumpHere(v, ipkTop-1); } @@ -122971,7 +126111,10 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( ** This loop also handles the case of the PRIMARY KEY index for a ** WITHOUT ROWID table. */ - for(ix=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, ix++){ + for(pIdx = indexIteratorFirst(&sIdxIter, &ix); + pIdx; + pIdx = indexIteratorNext(&sIdxIter, &ix) + ){ int regIdx; /* Range of registers hold conent for pIdx */ int regR; /* Range of registers holding conflicting PK */ int iThisCur; /* Cursor for this UNIQUE index */ @@ -122979,15 +126122,14 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( int addrConflictCk; /* First opcode in the conflict check logic */ if( aRegIdx[ix]==0 ) continue; /* Skip indices that do not change */ - if( pUpIdx==pIdx ){ - addrUniqueOk = upsertJump+1; - upsertBypass = sqlite3VdbeGoto(v, 0); - VdbeComment((v, "Skip upsert subroutine")); - sqlite3VdbeJumpHere(v, upsertJump); - }else{ - addrUniqueOk = sqlite3VdbeMakeLabel(pParse); + if( pUpsert ){ + pUpsertClause = sqlite3UpsertOfIndex(pUpsert, pIdx); + if( upsertIpkDelay && pUpsertClause==pUpsert ){ + sqlite3VdbeJumpHere(v, upsertIpkDelay); + } } - if( bAffinityDone==0 && (pUpIdx==0 || pUpIdx==pIdx) ){ + addrUniqueOk = sqlite3VdbeMakeLabel(pParse); + if( bAffinityDone==0 ){ sqlite3TableAffinity(v, pTab, regNewData+1); bAffinityDone = 1; } @@ -123024,7 +126166,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField ); x = sqlite3TableColumnToStorage(pTab, iField) + regNewData + 1; sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i); - VdbeComment((v, "%s", pTab->aCol[iField].zName)); + VdbeComment((v, "%s", pTab->aCol[iField].zCnName)); } } sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]); @@ -123058,8 +126200,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( } /* Figure out if the upsert clause applies to this index */ - if( pUpIdx==pIdx ){ - if( pUpsert->pUpsertSet==0 ){ + if( pUpsertClause ){ + if( pUpsertClause->isDoUpdate==0 ){ onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */ }else{ onError = OE_Update; /* DO UPDATE */ @@ -123076,6 +126218,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row ** must be explicitly deleted in order to ensure any pre-update hook ** is invoked. */ + assert( IsOrdinaryTable(pTab) ); #ifndef SQLITE_ENABLE_PREUPDATE_HOOK if( (ix==0 && pIdx->pNext==0) /* Condition 3 */ && pPk==pIdx /* Condition 2 */ @@ -123083,7 +126226,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( && ( 0==(db->flags&SQLITE_RecTriggers) || /* Condition 4 */ 0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0)) && ( 0==(db->flags&SQLITE_ForeignKeys) || /* Condition 5 */ - (0==pTab->pFKey && 0==sqlite3FkReferences(pTab))) + (0==pTab->u.tab.pFKey && 0==sqlite3FkReferences(pTab))) ){ sqlite3VdbeResolveLabel(v, addrUniqueOk); continue; @@ -123097,7 +126240,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( regIdx, pIdx->nKeyCol); VdbeCoverage(v); /* Generate code to handle collisions */ - regR = (pIdx==pPk) ? regIdx : sqlite3GetTempRange(pParse, nPkField); + regR = pIdx==pPk ? regIdx : sqlite3GetTempRange(pParse, nPkField); if( isUpdate || onError==OE_Replace ){ if( HasRowid(pTab) ){ sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR); @@ -123118,7 +126261,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( x = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]); sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i); VdbeComment((v, "%s.%s", pTab->zName, - pTab->aCol[pPk->aiColumn[i]].zName)); + pTab->aCol[pPk->aiColumn[i]].zCnName)); } } if( isUpdate ){ @@ -123182,7 +126325,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( assert( onError==OE_Replace ); nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk; - assert( nConflictCk>0 ); + assert( nConflictCk>0 || db->mallocFailed ); + testcase( nConflictCk<=0 ); testcase( nConflictCk>1 ); if( regTrigCnt ){ sqlite3MultiWrite(pParse); @@ -123249,13 +126393,16 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( break; } } - if( pUpIdx==pIdx ){ - sqlite3VdbeGoto(v, upsertJump+1); - sqlite3VdbeJumpHere(v, upsertBypass); - }else{ - sqlite3VdbeResolveLabel(v, addrUniqueOk); - } + sqlite3VdbeResolveLabel(v, addrUniqueOk); if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField); + if( pUpsertClause + && upsertIpkReturn + && sqlite3UpsertNextIsIPK(pUpsertClause) + ){ + sqlite3VdbeGoto(v, upsertIpkDelay+1); + sqlite3VdbeJumpHere(v, upsertIpkReturn); + upsertIpkReturn = 0; + } } /* If the IPK constraint is a REPLACE, run it last */ @@ -123314,13 +126461,39 @@ SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){ if( pTab->pSchema->file_format<2 ) return; for(i=pTab->nCol-1; i>0; i--){ - if( pTab->aCol[i].pDflt!=0 ) break; + if( pTab->aCol[i].iDflt!=0 ) break; if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break; } sqlite3VdbeChangeP5(v, i+1); } #endif +/* +** Table pTab is a WITHOUT ROWID table that is being written to. The cursor +** number is iCur, and register regData contains the new record for the +** PK index. This function adds code to invoke the pre-update hook, +** if one is registered. +*/ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +static void codeWithoutRowidPreupdate( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being updated */ + int iCur, /* Cursor number for table */ + int regData /* Data containing new record */ +){ + Vdbe *v = pParse->pVdbe; + int r = sqlite3GetTempReg(pParse); + assert( !HasRowid(pTab) ); + assert( 0==(pParse->db->mDbFlags & DBFLAG_Vacuum) || CORRUPT_DB ); + sqlite3VdbeAddOp2(v, OP_Integer, 0, r); + sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE); + sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP); + sqlite3ReleaseTempReg(pParse, r); +} +#else +# define codeWithoutRowidPreupdate(a,b,c,d) +#endif + /* ** This routine generates code to finish the INSERT or UPDATE operation ** that was started by a prior call to sqlite3GenerateConstraintChecks. @@ -123353,7 +126526,7 @@ SQLITE_PRIVATE void sqlite3CompleteInsertion( v = pParse->pVdbe; assert( v!=0 ); - assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + assert( !IsView(pTab) ); /* This table is not a VIEW */ for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ /* All REPLACE indexes are at the end of the list */ assert( pIdx->onError!=OE_Replace @@ -123369,17 +126542,9 @@ SQLITE_PRIVATE void sqlite3CompleteInsertion( assert( pParse->nested==0 ); pik_flags |= OPFLAG_NCHANGE; pik_flags |= (update_flags & OPFLAG_SAVEPOSITION); -#ifdef SQLITE_ENABLE_PREUPDATE_HOOK if( update_flags==0 ){ - int r = sqlite3GetTempReg(pParse); - sqlite3VdbeAddOp2(v, OP_Integer, 0, r); - sqlite3VdbeAddOp4(v, OP_Insert, - iIdxCur+i, aRegIdx[i], r, (char*)pTab, P4_TABLE - ); - sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP); - sqlite3ReleaseTempReg(pParse, r); + codeWithoutRowidPreupdate(pParse, pTab, iIdxCur+i, aRegIdx[i]); } -#endif } sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i], aRegIdx[i]+1, @@ -123447,8 +126612,9 @@ SQLITE_PRIVATE int sqlite3OpenTableAndIndices( assert( op==OP_OpenWrite || p5==0 ); if( IsVirtual(pTab) ){ /* This routine is a no-op for virtual tables. Leave the output - ** variables *piDataCur and *piIdxCur uninitialized so that valgrind - ** can detect if they are used by mistake in the caller. */ + ** variables *piDataCur and *piIdxCur set to illegal cursor numbers + ** for improved error detection. */ + *piDataCur = *piIdxCur = -999; return 0; } iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); @@ -123577,7 +126743,7 @@ static int xferOptimization( ExprList *pEList; /* The result set of the SELECT */ Table *pSrc; /* The table in the FROM clause of SELECT */ Index *pSrcIdx, *pDestIdx; /* Source and destination indices */ - struct SrcList_item *pItem; /* An element of pSelect->pSrc */ + SrcItem *pItem; /* An element of pSelect->pSrc */ int i; /* Loop counter */ int iDbSrc; /* The database of pSrc */ int iSrc, iDest; /* Cursors from source and destination */ @@ -123663,13 +126829,8 @@ static int xferOptimization( if( HasRowid(pDest)!=HasRowid(pSrc) ){ return 0; /* source and destination must both be WITHOUT ROWID or not */ } -#ifndef SQLITE_OMIT_VIRTUALTABLE - if( IsVirtual(pSrc) ){ - return 0; /* tab2 must not be a virtual table */ - } -#endif - if( pSrc->pSelect ){ - return 0; /* tab2 may not be a view */ + if( !IsOrdinaryTable(pSrc) ){ + return 0; /* tab2 may not be a view or virtual table */ } if( pDest->nCol!=pSrc->nCol ){ return 0; /* Number of columns must be the same in tab1 and tab2 */ @@ -123677,6 +126838,9 @@ static int xferOptimization( if( pDest->iPKey!=pSrc->iPKey ){ return 0; /* Both tables must have the same INTEGER PRIMARY KEY */ } + if( (pDest->tabFlags & TF_Strict)!=0 && (pSrc->tabFlags & TF_Strict)==0 ){ + return 0; /* Cannot feed from a non-strict into a strict table */ + } for(i=0; inCol; i++){ Column *pDestCol = &pDest->aCol[i]; Column *pSrcCol = &pSrc->aCol[i]; @@ -123713,7 +126877,9 @@ static int xferOptimization( ** This requirement could be relaxed for VIRTUAL columns, I suppose. */ if( (pDestCol->colFlags & COLFLAG_GENERATED)!=0 ){ - if( sqlite3ExprCompare(0, pSrcCol->pDflt, pDestCol->pDflt, -1)!=0 ){ + if( sqlite3ExprCompare(0, + sqlite3ColumnExpr(pSrc, pSrcCol), + sqlite3ColumnExpr(pDest, pDestCol), -1)!=0 ){ testcase( pDestCol->colFlags & COLFLAG_VIRTUAL ); testcase( pDestCol->colFlags & COLFLAG_STORED ); return 0; /* Different generator expressions */ @@ -123723,7 +126889,8 @@ static int xferOptimization( if( pDestCol->affinity!=pSrcCol->affinity ){ return 0; /* Affinity must be the same on all columns */ } - if( sqlite3_stricmp(pDestCol->zColl, pSrcCol->zColl)!=0 ){ + if( sqlite3_stricmp(sqlite3ColumnColl(pDestCol), + sqlite3ColumnColl(pSrcCol))!=0 ){ return 0; /* Collating sequence must be the same on all columns */ } if( pDestCol->notNull && !pSrcCol->notNull ){ @@ -123731,11 +126898,15 @@ static int xferOptimization( } /* Default values for second and subsequent columns need to match. */ if( (pDestCol->colFlags & COLFLAG_GENERATED)==0 && i>0 ){ - assert( pDestCol->pDflt==0 || pDestCol->pDflt->op==TK_SPAN ); - assert( pSrcCol->pDflt==0 || pSrcCol->pDflt->op==TK_SPAN ); - if( (pDestCol->pDflt==0)!=(pSrcCol->pDflt==0) - || (pDestCol->pDflt && strcmp(pDestCol->pDflt->u.zToken, - pSrcCol->pDflt->u.zToken)!=0) + Expr *pDestExpr = sqlite3ColumnExpr(pDest, pDestCol); + Expr *pSrcExpr = sqlite3ColumnExpr(pSrc, pSrcCol); + assert( pDestExpr==0 || pDestExpr->op==TK_SPAN ); + assert( pDestExpr==0 || !ExprHasProperty(pDestExpr, EP_IntValue) ); + assert( pSrcExpr==0 || pSrcExpr->op==TK_SPAN ); + assert( pSrcExpr==0 || !ExprHasProperty(pSrcExpr, EP_IntValue) ); + if( (pDestExpr==0)!=(pSrcExpr==0) + || (pDestExpr!=0 && strcmp(pDestExpr->u.zToken, + pSrcExpr->u.zToken)!=0) ){ return 0; /* Default values must be the same for all columns */ } @@ -123772,7 +126943,8 @@ static int xferOptimization( ** the extra complication to make this rule less restrictive is probably ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e] */ - if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){ + assert( IsOrdinaryTable(pDest) ); + if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->u.tab.pFKey!=0 ){ return 0; } #endif @@ -123794,6 +126966,7 @@ static int xferOptimization( iDest = pParse->nTab++; regAutoinc = autoIncBegin(pParse, iDbDest, pDest); regData = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_Null, 0, regData); regRowid = sqlite3GetTempReg(pParse); sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite); assert( HasRowid(pDest) || destHasUniqueIdx ); @@ -123829,11 +127002,13 @@ static int xferOptimization( emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v); if( pDest->iPKey>=0 ){ addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid); - sqlite3VdbeVerifyAbortable(v, onError); - addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid); - VdbeCoverage(v); - sqlite3RowidConstraint(pParse, onError, pDest); - sqlite3VdbeJumpHere(v, addr2); + if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){ + sqlite3VdbeVerifyAbortable(v, onError); + addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid); + VdbeCoverage(v); + sqlite3RowidConstraint(pParse, onError, pDest); + sqlite3VdbeJumpHere(v, addr2); + } autoIncStep(pParse, regAutoinc, regRowid); }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){ addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid); @@ -123841,16 +127016,28 @@ static int xferOptimization( addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid); assert( (pDest->tabFlags & TF_Autoincrement)==0 ); } + if( db->mDbFlags & DBFLAG_Vacuum ){ sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest); - insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT; + insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT; }else{ - insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND; + insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND|OPFLAG_PREFORMAT; + } +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){ + sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1); + insFlags &= ~OPFLAG_PREFORMAT; + }else +#endif + { + sqlite3VdbeAddOp3(v, OP_RowCell, iDest, iSrc, regRowid); + } + sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid); + if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){ + sqlite3VdbeChangeP4(v, -1, (char*)pDest, P4_TABLE); } - sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1); - sqlite3VdbeAddOp4(v, OP_Insert, iDest, regData, regRowid, - (char*)pDest, P4_TABLE); sqlite3VdbeChangeP5(v, insFlags); + sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v); sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0); sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); @@ -123892,13 +127079,22 @@ static int xferOptimization( if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break; } if( i==pSrcIdx->nColumn ){ - idxInsFlags = OPFLAG_USESEEKRESULT; + idxInsFlags = OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT; sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest); + sqlite3VdbeAddOp2(v, OP_RowCell, iDest, iSrc); } }else if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){ idxInsFlags |= OPFLAG_NCHANGE; } - sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1); + if( idxInsFlags!=(OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT) ){ + sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1); + if( (db->mDbFlags & DBFLAG_Vacuum)==0 + && !HasRowid(pDest) + && IsPrimaryKeyIndex(pDestIdx) + ){ + codeWithoutRowidPreupdate(pParse, pDest, iDest, regData); + } + } sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData); sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND); sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v); @@ -124426,6 +127622,13 @@ struct sqlite3_api_routines { sqlite3_file *(*database_file_object)(const char*); /* Version 3.34.0 and later */ int (*txn_state)(sqlite3*,const char*); + /* Version 3.36.1 and later */ + sqlite3_int64 (*changes64)(sqlite3*); + sqlite3_int64 (*total_changes64)(sqlite3*); + /* Version 3.37.0 and later */ + int (*autovacuum_pages)(sqlite3*, + unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), + void*, void(*)(void*)); }; /* @@ -124732,6 +127935,11 @@ typedef int (*sqlite3_loadext_entry)( #define sqlite3_database_file_object sqlite3_api->database_file_object /* Version 3.34.0 and later */ #define sqlite3_txn_state sqlite3_api->txn_state +/* Version 3.36.1 and later */ +#define sqlite3_changes64 sqlite3_api->changes64 +#define sqlite3_total_changes64 sqlite3_api->total_changes64 +/* Version 3.37.0 and later */ +#define sqlite3_autovacuum_pages sqlite3_api->autovacuum_pages #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */ #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) @@ -125216,6 +128424,11 @@ static const sqlite3_api_routines sqlite3Apis = { sqlite3_database_file_object, /* Version 3.34.0 and later */ sqlite3_txn_state, + /* Version 3.36.1 and later */ + sqlite3_changes64, + sqlite3_total_changes64, + /* Version 3.37.0 and later */ + sqlite3_autovacuum_pages, }; /* True if x is the directory separator character @@ -125251,7 +128464,7 @@ static int sqlite3LoadExtension( const char *zEntry; char *zAltEntry = 0; void **aHandle; - u64 nMsg = 300 + sqlite3Strlen30(zFile); + u64 nMsg = strlen(zFile); int ii; int rc; @@ -125285,6 +128498,12 @@ static int sqlite3LoadExtension( zEntry = zProc ? zProc : "sqlite3_extension_init"; + /* tag-20210611-1. Some dlopen() implementations will segfault if given + ** an oversize filename. Most filesystems have a pathname limit of 4K, + ** so limit the extension filename length to about twice that. + ** https://sqlite.org/forum/forumpost/08a0d6d9bf */ + if( nMsg>SQLITE_MAX_PATHLEN ) goto extension_not_found; + handle = sqlite3OsDlOpen(pVfs, zFile); #if SQLITE_OS_UNIX || SQLITE_OS_WIN for(ii=0; iiaExtension[db->nExtension++] = handle; return SQLITE_OK; + +extension_not_found: + if( pzErrMsg ){ + nMsg += 300; + *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg); + if( zErrmsg ){ + assert( nMsg<0x7fffffff ); /* zErrmsg would be NULL if not so */ + sqlite3_snprintf((int)nMsg, zErrmsg, + "unable to open shared library [%.*s]", SQLITE_MAX_PATHLEN, zFile); + sqlite3OsDlError(pVfs, nMsg-1, zErrmsg); + } + } + return SQLITE_ERROR; } SQLITE_API int sqlite3_load_extension( sqlite3 *db, /* Load the extension into this database connection */ @@ -125668,13 +128891,14 @@ SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){ #define PragTyp_SOFT_HEAP_LIMIT 35 #define PragTyp_SYNCHRONOUS 36 #define PragTyp_TABLE_INFO 37 -#define PragTyp_TEMP_STORE 38 -#define PragTyp_TEMP_STORE_DIRECTORY 39 -#define PragTyp_THREADS 40 -#define PragTyp_WAL_AUTOCHECKPOINT 41 -#define PragTyp_WAL_CHECKPOINT 42 -#define PragTyp_LOCK_STATUS 43 -#define PragTyp_STATS 44 +#define PragTyp_TABLE_LIST 38 +#define PragTyp_TEMP_STORE 39 +#define PragTyp_TEMP_STORE_DIRECTORY 40 +#define PragTyp_THREADS 41 +#define PragTyp_WAL_AUTOCHECKPOINT 42 +#define PragTyp_WAL_CHECKPOINT 43 +#define PragTyp_LOCK_STATUS 44 +#define PragTyp_STATS 45 /* Property flags associated with various pragma. */ #define PragFlg_NeedSchema 0x01 /* Force schema load before running */ @@ -125707,45 +128931,51 @@ static const char *const pragCName[] = { /* 13 */ "pk", /* 14 */ "hidden", /* table_info reuses 8 */ - /* 15 */ "seqno", /* Used by: index_xinfo */ - /* 16 */ "cid", - /* 17 */ "name", - /* 18 */ "desc", - /* 19 */ "coll", - /* 20 */ "key", - /* 21 */ "name", /* Used by: function_list */ - /* 22 */ "builtin", - /* 23 */ "type", - /* 24 */ "enc", - /* 25 */ "narg", - /* 26 */ "flags", - /* 27 */ "tbl", /* Used by: stats */ - /* 28 */ "idx", - /* 29 */ "wdth", - /* 30 */ "hght", - /* 31 */ "flgs", - /* 32 */ "seq", /* Used by: index_list */ - /* 33 */ "name", - /* 34 */ "unique", - /* 35 */ "origin", - /* 36 */ "partial", - /* 37 */ "table", /* Used by: foreign_key_check */ - /* 38 */ "rowid", - /* 39 */ "parent", - /* 40 */ "fkid", - /* index_info reuses 15 */ - /* 41 */ "seq", /* Used by: database_list */ - /* 42 */ "name", - /* 43 */ "file", - /* 44 */ "busy", /* Used by: wal_checkpoint */ - /* 45 */ "log", - /* 46 */ "checkpointed", - /* collation_list reuses 32 */ - /* 47 */ "database", /* Used by: lock_status */ - /* 48 */ "status", - /* 49 */ "cache_size", /* Used by: default_cache_size */ + /* 15 */ "schema", /* Used by: table_list */ + /* 16 */ "name", + /* 17 */ "type", + /* 18 */ "ncol", + /* 19 */ "wr", + /* 20 */ "strict", + /* 21 */ "seqno", /* Used by: index_xinfo */ + /* 22 */ "cid", + /* 23 */ "name", + /* 24 */ "desc", + /* 25 */ "coll", + /* 26 */ "key", + /* 27 */ "name", /* Used by: function_list */ + /* 28 */ "builtin", + /* 29 */ "type", + /* 30 */ "enc", + /* 31 */ "narg", + /* 32 */ "flags", + /* 33 */ "tbl", /* Used by: stats */ + /* 34 */ "idx", + /* 35 */ "wdth", + /* 36 */ "hght", + /* 37 */ "flgs", + /* 38 */ "seq", /* Used by: index_list */ + /* 39 */ "name", + /* 40 */ "unique", + /* 41 */ "origin", + /* 42 */ "partial", + /* 43 */ "table", /* Used by: foreign_key_check */ + /* 44 */ "rowid", + /* 45 */ "parent", + /* 46 */ "fkid", + /* index_info reuses 21 */ + /* 47 */ "seq", /* Used by: database_list */ + /* 48 */ "name", + /* 49 */ "file", + /* 50 */ "busy", /* Used by: wal_checkpoint */ + /* 51 */ "log", + /* 52 */ "checkpointed", + /* collation_list reuses 38 */ + /* 53 */ "database", /* Used by: lock_status */ + /* 54 */ "status", + /* 55 */ "cache_size", /* Used by: default_cache_size */ /* module_list pragma_list reuses 9 */ - /* 50 */ "timeout", /* Used by: busy_timeout */ + /* 56 */ "timeout", /* Used by: busy_timeout */ }; /* Definitions of all built-in pragmas */ @@ -125796,7 +129026,7 @@ static const PragmaName aPragmaName[] = { {/* zName: */ "busy_timeout", /* ePragTyp: */ PragTyp_BUSY_TIMEOUT, /* ePragFlg: */ PragFlg_Result0, - /* ColNames: */ 50, 1, + /* ColNames: */ 56, 1, /* iArg: */ 0 }, #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) {/* zName: */ "cache_size", @@ -125835,7 +129065,7 @@ static const PragmaName aPragmaName[] = { {/* zName: */ "collation_list", /* ePragTyp: */ PragTyp_COLLATION_LIST, /* ePragFlg: */ PragFlg_Result0, - /* ColNames: */ 32, 2, + /* ColNames: */ 38, 2, /* iArg: */ 0 }, #endif #if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS) @@ -125870,14 +129100,14 @@ static const PragmaName aPragmaName[] = { {/* zName: */ "database_list", /* ePragTyp: */ PragTyp_DATABASE_LIST, /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0, - /* ColNames: */ 41, 3, + /* ColNames: */ 47, 3, /* iArg: */ 0 }, #endif #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED) {/* zName: */ "default_cache_size", /* ePragTyp: */ PragTyp_DEFAULT_CACHE_SIZE, /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, - /* ColNames: */ 49, 1, + /* ColNames: */ 55, 1, /* iArg: */ 0 }, #endif #if !defined(SQLITE_OMIT_FLAG_PRAGMAS) @@ -125907,7 +129137,7 @@ static const PragmaName aPragmaName[] = { {/* zName: */ "foreign_key_check", /* ePragTyp: */ PragTyp_FOREIGN_KEY_CHECK, /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt, - /* ColNames: */ 37, 4, + /* ColNames: */ 43, 4, /* iArg: */ 0 }, #endif #if !defined(SQLITE_OMIT_FOREIGN_KEY) @@ -125950,7 +129180,7 @@ static const PragmaName aPragmaName[] = { {/* zName: */ "function_list", /* ePragTyp: */ PragTyp_FUNCTION_LIST, /* ePragFlg: */ PragFlg_Result0, - /* ColNames: */ 21, 6, + /* ColNames: */ 27, 6, /* iArg: */ 0 }, #endif #endif @@ -125979,23 +129209,23 @@ static const PragmaName aPragmaName[] = { {/* zName: */ "index_info", /* ePragTyp: */ PragTyp_INDEX_INFO, /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, - /* ColNames: */ 15, 3, + /* ColNames: */ 21, 3, /* iArg: */ 0 }, {/* zName: */ "index_list", /* ePragTyp: */ PragTyp_INDEX_LIST, /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, - /* ColNames: */ 32, 5, + /* ColNames: */ 38, 5, /* iArg: */ 0 }, {/* zName: */ "index_xinfo", /* ePragTyp: */ PragTyp_INDEX_INFO, /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, - /* ColNames: */ 15, 6, + /* ColNames: */ 21, 6, /* iArg: */ 1 }, #endif #if !defined(SQLITE_OMIT_INTEGRITY_CHECK) {/* zName: */ "integrity_check", /* ePragTyp: */ PragTyp_INTEGRITY_CHECK, - /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt, /* ColNames: */ 0, 0, /* iArg: */ 0 }, #endif @@ -126029,7 +129259,7 @@ static const PragmaName aPragmaName[] = { {/* zName: */ "lock_status", /* ePragTyp: */ PragTyp_LOCK_STATUS, /* ePragFlg: */ PragFlg_Result0, - /* ColNames: */ 47, 2, + /* ColNames: */ 53, 2, /* iArg: */ 0 }, #endif #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) @@ -126103,7 +129333,7 @@ static const PragmaName aPragmaName[] = { #if !defined(SQLITE_OMIT_INTEGRITY_CHECK) {/* zName: */ "quick_check", /* ePragTyp: */ PragTyp_INTEGRITY_CHECK, - /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt, /* ColNames: */ 0, 0, /* iArg: */ 0 }, #endif @@ -126168,7 +129398,7 @@ static const PragmaName aPragmaName[] = { {/* zName: */ "stats", /* ePragTyp: */ PragTyp_STATS, /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq, - /* ColNames: */ 27, 5, + /* ColNames: */ 33, 5, /* iArg: */ 0 }, #endif #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) @@ -126184,6 +129414,11 @@ static const PragmaName aPragmaName[] = { /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, /* ColNames: */ 8, 6, /* iArg: */ 0 }, + {/* zName: */ "table_list", + /* ePragTyp: */ PragTyp_TABLE_LIST, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1, + /* ColNames: */ 15, 6, + /* iArg: */ 0 }, {/* zName: */ "table_xinfo", /* ePragTyp: */ PragTyp_TABLE_INFO, /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, @@ -126259,7 +129494,7 @@ static const PragmaName aPragmaName[] = { {/* zName: */ "wal_checkpoint", /* ePragTyp: */ PragTyp_WAL_CHECKPOINT, /* ePragFlg: */ PragFlg_NeedSchema, - /* ColNames: */ 44, 3, + /* ColNames: */ 50, 3, /* iArg: */ 0 }, #endif #if !defined(SQLITE_OMIT_FLAG_PRAGMAS) @@ -126270,7 +129505,7 @@ static const PragmaName aPragmaName[] = { /* iArg: */ SQLITE_WriteSchema|SQLITE_NoSchemaError }, #endif }; -/* Number of pragmas: 67 on by default, 77 total. */ +/* Number of pragmas: 68 on by default, 78 total. */ /************** End of pragma.h **********************************************/ /************** Continuing where we left off in pragma.c *********************/ @@ -126712,7 +129947,11 @@ SQLITE_PRIVATE void sqlite3Pragma( /* Locate the pragma in the lookup table */ pPragma = pragmaLocate(zLeft); - if( pPragma==0 ) goto pragma_out; + if( pPragma==0 ){ + /* IMP: R-43042-22504 No error messages are generated if an + ** unknown pragma is issued. */ + goto pragma_out; + } /* Make sure the database schema is loaded if the pragma requires that */ if( (pPragma->mPragFlg & PragFlg_NeedSchema)!=0 ){ @@ -127362,6 +130601,14 @@ SQLITE_PRIVATE void sqlite3Pragma( }else{ db->flags &= ~mask; if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0; + if( (mask & SQLITE_WriteSchema)!=0 + && sqlite3_stricmp(zRight, "reset")==0 + ){ + /* IMP: R-60817-01178 If the argument is "RESET" then schema + ** writing is disabled (as with "PRAGMA writable_schema=OFF") and, + ** in addition, the schema is reloaded. */ + sqlite3ResetAllSchemasOfConnection(db); + } } /* Many of the flag-pragmas modify the code generated by the SQL @@ -127402,6 +130649,7 @@ SQLITE_PRIVATE void sqlite3Pragma( sqlite3ViewGetColumnNames(pParse, pTab); for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ int isHidden = 0; + const Expr *pColExpr; if( pCol->colFlags & COLFLAG_NOINSERT ){ if( pPragma->iArg==0 ){ nHidden++; @@ -127422,13 +130670,16 @@ SQLITE_PRIVATE void sqlite3Pragma( }else{ for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){} } - assert( pCol->pDflt==0 || pCol->pDflt->op==TK_SPAN || isHidden>=2 ); + pColExpr = sqlite3ColumnExpr(pTab,pCol); + assert( pColExpr==0 || pColExpr->op==TK_SPAN || isHidden>=2 ); + assert( pColExpr==0 || !ExprHasProperty(pColExpr, EP_IntValue) + || isHidden>=2 ); sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi", i-nHidden, - pCol->zName, + pCol->zCnName, sqlite3ColumnType(pCol,""), pCol->notNull ? 1 : 0, - pCol->pDflt && isHidden<2 ? pCol->pDflt->u.zToken : 0, + (isHidden>=2 || pColExpr==0) ? 0 : pColExpr->u.zToken, k, isHidden); } @@ -127436,6 +130687,81 @@ SQLITE_PRIVATE void sqlite3Pragma( } break; + /* + ** PRAGMA table_list + ** + ** Return a single row for each table, virtual table, or view in the + ** entire schema. + ** + ** schema: Name of attached database hold this table + ** name: Name of the table itself + ** type: "table", "view", "virtual", "shadow" + ** ncol: Number of columns + ** wr: True for a WITHOUT ROWID table + ** strict: True for a STRICT table + */ + case PragTyp_TABLE_LIST: { + int ii; + pParse->nMem = 6; + sqlite3CodeVerifyNamedSchema(pParse, zDb); + for(ii=0; iinDb; ii++){ + HashElem *k; + Hash *pHash; + int initNCol; + if( zDb && sqlite3_stricmp(zDb, db->aDb[ii].zDbSName)!=0 ) continue; + + /* Ensure that the Table.nCol field is initialized for all views + ** and virtual tables. Each time we initialize a Table.nCol value + ** for a table, that can potentially disrupt the hash table, so restart + ** the initialization scan. + */ + pHash = &db->aDb[ii].pSchema->tblHash; + initNCol = sqliteHashCount(pHash); + while( initNCol-- ){ + for(k=sqliteHashFirst(pHash); 1; k=sqliteHashNext(k) ){ + Table *pTab; + if( k==0 ){ initNCol = 0; break; } + pTab = sqliteHashData(k); + if( pTab->nCol==0 ){ + char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName); + if( zSql ){ + sqlite3_stmt *pDummy = 0; + (void)sqlite3_prepare(db, zSql, -1, &pDummy, 0); + (void)sqlite3_finalize(pDummy); + sqlite3DbFree(db, zSql); + } + pHash = &db->aDb[ii].pSchema->tblHash; + break; + } + } + } + + for(k=sqliteHashFirst(pHash); k; k=sqliteHashNext(k) ){ + Table *pTab = sqliteHashData(k); + const char *zType; + if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue; + if( IsView(pTab) ){ + zType = "view"; + }else if( IsVirtual(pTab) ){ + zType = "virtual"; + }else if( pTab->tabFlags & TF_Shadow ){ + zType = "shadow"; + }else{ + zType = "table"; + } + sqlite3VdbeMultiLoad(v, 1, "sssiii", + db->aDb[ii].zDbSName, + sqlite3PreferredTableName(pTab->zName), + zType, + pTab->nCol, + (pTab->tabFlags & TF_WithoutRowid)!=0, + (pTab->tabFlags & TF_Strict)!=0 + ); + } + } + } + break; + #ifdef SQLITE_DEBUG case PragTyp_STATS: { Index *pIdx; @@ -127445,7 +130771,7 @@ SQLITE_PRIVATE void sqlite3Pragma( for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){ Table *pTab = sqliteHashData(i); sqlite3VdbeMultiLoad(v, 1, "ssiii", - pTab->zName, + sqlite3PreferredTableName(pTab->zName), 0, pTab->szTabRow, pTab->nRowLogEst, @@ -127495,7 +130821,7 @@ SQLITE_PRIVATE void sqlite3Pragma( for(i=0; iaiColumn[i]; sqlite3VdbeMultiLoad(v, 1, "iisX", i, cnum, - cnum<0 ? 0 : pTab->aCol[cnum].zName); + cnum<0 ? 0 : pTab->aCol[cnum].zCnName); if( pPragma->iArg ){ sqlite3VdbeMultiLoad(v, 4, "isiX", pIdx->aSortOrder[i], @@ -127564,11 +130890,13 @@ SQLITE_PRIVATE void sqlite3Pragma( pParse->nMem = 6; for(i=0; iu.pHash ){ + assert( p->funcFlags & SQLITE_FUNC_BUILTIN ); pragmaFunclistLine(v, p, 1, showInternFunc); } } for(j=sqliteHashFirst(&db->aFunc); j; j=sqliteHashNext(j)){ p = (FuncDef*)sqliteHashData(j); + assert( (p->funcFlags & SQLITE_FUNC_BUILTIN)==0 ); pragmaFunclistLine(v, p, 0, showInternFunc); } } @@ -127602,8 +130930,8 @@ SQLITE_PRIVATE void sqlite3Pragma( FKey *pFK; Table *pTab; pTab = sqlite3FindTable(db, zRight, zDb); - if( pTab ){ - pFK = pTab->pFKey; + if( pTab && IsOrdinaryTable(pTab) ){ + pFK = pTab->u.tab.pFKey; if( pFK ){ int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); int i = 0; @@ -127616,7 +130944,7 @@ SQLITE_PRIVATE void sqlite3Pragma( i, j, pFK->zTo, - pTab->aCol[pFK->aCol[j].iFrom].zName, + pTab->aCol[pFK->aCol[j].iFrom].zCnName, pFK->aCol[j].zCol, actionName(pFK->aAction[1]), /* ON UPDATE */ actionName(pFK->aAction[0]), /* ON DELETE */ @@ -127662,7 +130990,7 @@ SQLITE_PRIVATE void sqlite3Pragma( pTab = (Table*)sqliteHashData(k); k = sqliteHashNext(k); } - if( pTab==0 || pTab->pFKey==0 ) continue; + if( pTab==0 || !IsOrdinaryTable(pTab) || pTab->u.tab.pFKey==0 ) continue; iDb = sqlite3SchemaToIndex(db, pTab->pSchema); zDb = db->aDb[iDb].zDbSName; sqlite3CodeVerifySchema(pParse, iDb); @@ -127670,7 +130998,8 @@ SQLITE_PRIVATE void sqlite3Pragma( if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow; sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead); sqlite3VdbeLoadString(v, regResult, pTab->zName); - for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){ + assert( IsOrdinaryTable(pTab) ); + for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){ pParent = sqlite3FindTable(db, pFK->zTo, zDb); if( pParent==0 ) continue; pIdx = 0; @@ -127692,7 +131021,8 @@ SQLITE_PRIVATE void sqlite3Pragma( if( pFK ) break; if( pParse->nTabnTab = i; addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v); - for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){ + assert( IsOrdinaryTable(pTab) ); + for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){ pParent = sqlite3FindTable(db, pFK->zTo, zDb); pIdx = 0; aiCols = 0; @@ -127706,6 +131036,7 @@ SQLITE_PRIVATE void sqlite3Pragma( ** regRow..regRow+n. If any of the child key values are NULL, this ** row cannot cause an FK violation. Jump directly to addrOk in ** this case. */ + if( regRow+pFK->nCol>pParse->nMem ) pParse->nMem = regRow+pFK->nCol; for(j=0; jnCol; j++){ int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom; sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j); @@ -127892,8 +131223,9 @@ SQLITE_PRIVATE void sqlite3Pragma( int loopTop; int iDataCur, iIdxCur; int r1 = -1; + int bStrict; - if( pTab->tnum<1 ) continue; /* Skip VIEWs or VIRTUAL TABLEs */ + if( !IsOrdinaryTable(pTab) ) continue; if( pObjTab && pObjTab!=pTab ) continue; pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0, @@ -127913,23 +131245,48 @@ SQLITE_PRIVATE void sqlite3Pragma( /* Sanity check on record header decoding */ sqlite3VdbeAddOp3(v, OP_Column, iDataCur, pTab->nNVCol-1,3); sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); + VdbeComment((v, "(right-most column)")); } - /* Verify that all NOT NULL columns really are NOT NULL */ + /* Verify that all NOT NULL columns really are NOT NULL. At the + ** same time verify the type of the content of STRICT tables */ + bStrict = (pTab->tabFlags & TF_Strict)!=0; for(j=0; jnCol; j++){ char *zErr; - int jmp2; + Column *pCol = pTab->aCol + j; + int doError, jmp2; if( j==pTab->iPKey ) continue; - if( pTab->aCol[j].notNull==0 ) continue; + if( pCol->notNull==0 && !bStrict ) continue; + doError = bStrict ? sqlite3VdbeMakeLabel(pParse) : 0; sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3); if( sqlite3VdbeGetOp(v,-1)->opcode==OP_Column ){ sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); } - jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v); - zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName, - pTab->aCol[j].zName); - sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); - integrityCheckResultRow(v); - sqlite3VdbeJumpHere(v, jmp2); + if( pCol->notNull ){ + jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v); + zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName, + pCol->zCnName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + if( bStrict && pCol->eCType!=COLTYPE_ANY ){ + sqlite3VdbeGoto(v, doError); + }else{ + integrityCheckResultRow(v); + } + sqlite3VdbeJumpHere(v, jmp2); + } + if( (pTab->tabFlags & TF_Strict)!=0 + && pCol->eCType!=COLTYPE_ANY + ){ + jmp2 = sqlite3VdbeAddOp3(v, OP_IsNullOrType, 3, 0, + sqlite3StdTypeMap[pCol->eCType-1]); + VdbeCoverage(v); + zErr = sqlite3MPrintf(db, "non-%s value in %s.%s", + sqlite3StdType[pCol->eCType-1], + pTab->zName, pTab->aCol[j].zCnName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + sqlite3VdbeResolveLabel(v, doError); + integrityCheckResultRow(v); + sqlite3VdbeJumpHere(v, jmp2); + } } /* Verify CHECK constraints */ if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){ @@ -128214,7 +131571,7 @@ SQLITE_PRIVATE void sqlite3Pragma( ** Checkpoint the database. */ case PragTyp_WAL_CHECKPOINT: { - int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED); + int iBt = (pId2->z?iDb:SQLITE_MAX_DB); int eMode = SQLITE_CHECKPOINT_PASSIVE; if( zRight ){ if( sqlite3StrICmp(zRight, "full")==0 ){ @@ -128463,12 +131820,12 @@ SQLITE_PRIVATE void sqlite3Pragma( case PragTyp_ANALYSIS_LIMIT: { sqlite3_int64 N; if( zRight - && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK + && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK /* IMP: R-40975-20399 */ && N>=0 ){ db->nAnalysisLimit = (int)(N&0x7fffffff); } - returnSingleInt(v, db->nAnalysisLimit); + returnSingleInt(v, db->nAnalysisLimit); /* IMP: R-57594-65522 */ break; } @@ -128862,7 +132219,7 @@ SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName) */ static void corruptSchema( InitData *pData, /* Initialization context */ - const char *zObj, /* Object being parsed at the point of error */ + char **azObj, /* Type and name of object being parsed */ const char *zExtra /* Error information */ ){ sqlite3 *db = pData->db; @@ -128870,14 +132227,23 @@ static void corruptSchema( pData->rc = SQLITE_NOMEM_BKPT; }else if( pData->pzErrMsg[0]!=0 ){ /* A error message has already been generated. Do not overwrite it */ - }else if( pData->mInitFlags & INITFLAG_AlterTable ){ - *pData->pzErrMsg = sqlite3DbStrDup(db, zExtra); + }else if( pData->mInitFlags & (INITFLAG_AlterMask) ){ + static const char *azAlterType[] = { + "rename", + "drop column", + "add column" + }; + *pData->pzErrMsg = sqlite3MPrintf(db, + "error in %s %s after %s: %s", azObj[0], azObj[1], + azAlterType[(pData->mInitFlags&INITFLAG_AlterMask)-1], + zExtra + ); pData->rc = SQLITE_ERROR; }else if( db->flags & SQLITE_WriteSchema ){ pData->rc = SQLITE_CORRUPT_BKPT; }else{ char *z; - if( zObj==0 ) zObj = "?"; + const char *zObj = azObj[1] ? azObj[1] : "?"; z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj); if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra); *pData->pzErrMsg = z; @@ -128933,21 +132299,28 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char UNUSED_PARAMETER2(NotUsed, argc); assert( sqlite3_mutex_held(db->mutex) ); db->mDbFlags |= DBFLAG_EncodingFixed; + if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ pData->nInitRow++; if( db->mallocFailed ){ - corruptSchema(pData, argv[1], 0); + corruptSchema(pData, argv, 0); return 1; } assert( iDb>=0 && iDbnDb ); - if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ if( argv[3]==0 ){ - corruptSchema(pData, argv[1], 0); - }else if( sqlite3_strnicmp(argv[4],"create ",7)==0 ){ + corruptSchema(pData, argv, 0); + }else if( argv[4] + && 'c'==sqlite3UpperToLower[(unsigned char)argv[4][0]] + && 'r'==sqlite3UpperToLower[(unsigned char)argv[4][1]] ){ /* Call the parser to process a CREATE TABLE, INDEX or VIEW. ** But because db->init.busy is set to 1, no VDBE code is generated ** or executed. All the parser does is build the internal data ** structures that describe the table, index, or view. + ** + ** No other valid SQL statement, other than the variable CREATE statements, + ** can begin with the letters "C" and "R". Thus, it is not possible run + ** any other kind of statement while parsing the schema, even a corrupt + ** schema. */ int rc; u8 saved_iDb = db->init.iDb; @@ -128960,11 +132333,11 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char || (db->init.newTnum>pData->mxPage && pData->mxPage>0) ){ if( sqlite3Config.bExtraSchemaChecks ){ - corruptSchema(pData, argv[1], "invalid rootpage"); + corruptSchema(pData, argv, "invalid rootpage"); } } db->init.orphanTrigger = 0; - db->init.azInit = argv; + db->init.azInit = (const char**)argv; pStmt = 0; TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0); rc = db->errCode; @@ -128979,13 +132352,14 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char if( rc==SQLITE_NOMEM ){ sqlite3OomFault(db); }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){ - corruptSchema(pData, argv[1], sqlite3_errmsg(db)); + corruptSchema(pData, argv, sqlite3_errmsg(db)); } } } + db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */ sqlite3_finalize(pStmt); }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){ - corruptSchema(pData, argv[1], 0); + corruptSchema(pData, argv, 0); }else{ /* If the SQL column is blank it means this is an index that ** was created to be the PRIMARY KEY or to fulfill a UNIQUE @@ -128996,7 +132370,7 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char Index *pIndex; pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName); if( pIndex==0 ){ - corruptSchema(pData, argv[1], "orphan index"); + corruptSchema(pData, argv, "orphan index"); }else if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0 || pIndex->tnum<2 @@ -129004,7 +132378,7 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char || sqlite3IndexHasDuplicateRootPage(pIndex) ){ if( sqlite3Config.bExtraSchemaChecks ){ - corruptSchema(pData, argv[1], "invalid rootpage"); + corruptSchema(pData, argv, "invalid rootpage"); } } } @@ -129207,18 +132581,22 @@ SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFl } #endif } + assert( pDb == &(db->aDb[iDb]) ); if( db->mallocFailed ){ rc = SQLITE_NOMEM_BKPT; sqlite3ResetAllSchemasOfConnection(db); - } + pDb = &db->aDb[iDb]; + }else if( rc==SQLITE_OK || (db->flags&SQLITE_NoSchemaError)){ - /* Black magic: If the SQLITE_NoSchemaError flag is set, then consider - ** the schema loaded, even if errors occurred. In this situation the - ** current sqlite3_prepare() operation will fail, but the following one - ** will attempt to compile the supplied statement against whatever subset - ** of the schema was loaded before the error occurred. The primary - ** purpose of this is to allow access to the sqlite_schema table - ** even when its contents have been corrupted. + /* Hack: If the SQLITE_NoSchemaError flag is set, then consider + ** the schema loaded, even if errors (other than OOM) occurred. In + ** this situation the current sqlite3_prepare() operation will fail, + ** but the following one will attempt to compile the supplied statement + ** against whatever subset of the schema was loaded before the error + ** occurred. + ** + ** The primary purpose of this is to allow access to the sqlite_schema + ** table even when its contents have been corrupted. */ DbSetProperty(db, iDb, DB_SchemaLoaded); rc = SQLITE_OK; @@ -129328,6 +132706,7 @@ static void schemaIsValid(Parse *pParse){ rc = sqlite3BtreeBeginTrans(pBt, 0, 0); if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ sqlite3OomFault(db); + pParse->rc = SQLITE_NOMEM; } if( rc!=SQLITE_OK ) return; openedTransaction = 1; @@ -129384,28 +132763,21 @@ SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ return i; } -/* -** Deallocate a single AggInfo object -*/ -static void agginfoFree(sqlite3 *db, AggInfo *p){ - sqlite3DbFree(db, p->aCol); - sqlite3DbFree(db, p->aFunc); - sqlite3DbFree(db, p); -} - /* ** Free all memory allocations in the pParse object */ SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){ sqlite3 *db = pParse->db; - AggInfo *pThis = pParse->pAggList; - while( pThis ){ - AggInfo *pNext = pThis->pNext; - agginfoFree(db, pThis); - pThis = pNext; + while( pParse->pCleanup ){ + ParseCleanup *pCleanup = pParse->pCleanup; + pParse->pCleanup = pCleanup->pNext; + pCleanup->xCleanup(db, pCleanup->pPtr); + sqlite3DbFreeNN(db, pCleanup); } sqlite3DbFree(db, pParse->aLabel); - sqlite3ExprListDelete(db, pParse->pConstExpr); + if( pParse->pConstExpr ){ + sqlite3ExprListDelete(db, pParse->pConstExpr); + } if( db ){ assert( db->lookaside.bDisable >= pParse->disableLookaside ); db->lookaside.bDisable -= pParse->disableLookaside; @@ -129414,6 +132786,55 @@ SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){ pParse->disableLookaside = 0; } +/* +** Add a new cleanup operation to a Parser. The cleanup should happen when +** the parser object is destroyed. But, beware: the cleanup might happen +** immediately. +** +** Use this mechanism for uncommon cleanups. There is a higher setup +** cost for this mechansim (an extra malloc), so it should not be used +** for common cleanups that happen on most calls. But for less +** common cleanups, we save a single NULL-pointer comparison in +** sqlite3ParserReset(), which reduces the total CPU cycle count. +** +** If a memory allocation error occurs, then the cleanup happens immediately. +** When either SQLITE_DEBUG or SQLITE_COVERAGE_TEST are defined, the +** pParse->earlyCleanup flag is set in that case. Calling code show verify +** that test cases exist for which this happens, to guard against possible +** use-after-free errors following an OOM. The preferred way to do this is +** to immediately follow the call to this routine with: +** +** testcase( pParse->earlyCleanup ); +** +** This routine returns a copy of its pPtr input (the third parameter) +** except if an early cleanup occurs, in which case it returns NULL. So +** another way to check for early cleanup is to check the return value. +** Or, stop using the pPtr parameter with this call and use only its +** return value thereafter. Something like this: +** +** pObj = sqlite3ParserAddCleanup(pParse, destructor, pObj); +*/ +SQLITE_PRIVATE void *sqlite3ParserAddCleanup( + Parse *pParse, /* Destroy when this Parser finishes */ + void (*xCleanup)(sqlite3*,void*), /* The cleanup routine */ + void *pPtr /* Pointer to object to be cleaned up */ +){ + ParseCleanup *pCleanup = sqlite3DbMallocRaw(pParse->db, sizeof(*pCleanup)); + if( pCleanup ){ + pCleanup->pNext = pParse->pCleanup; + pParse->pCleanup = pCleanup; + pCleanup->pPtr = pPtr; + pCleanup->xCleanup = xCleanup; + }else{ + xCleanup(pParse->db, pPtr); + pPtr = 0; +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) + pParse->earlyCleanup = 1; +#endif + } + return pPtr; +} + /* ** Compile the UTF-8 encoded SQL statement zSql into a statement handle. */ @@ -129512,12 +132933,6 @@ static int sqlite3Prepare( } assert( 0==sParse.nQueryLoop ); - if( sParse.rc==SQLITE_DONE ){ - sParse.rc = SQLITE_OK; - } - if( sParse.checkSchema ){ - schemaIsValid(&sParse); - } if( pzTail ){ *pzTail = sParse.zTail; } @@ -129527,21 +132942,30 @@ static int sqlite3Prepare( } if( db->mallocFailed ){ sParse.rc = SQLITE_NOMEM_BKPT; + sParse.checkSchema = 0; } - rc = sParse.rc; - if( rc!=SQLITE_OK ){ - if( sParse.pVdbe ) sqlite3VdbeFinalize(sParse.pVdbe); - assert(!(*ppStmt)); + if( sParse.rc!=SQLITE_OK && sParse.rc!=SQLITE_DONE ){ + if( sParse.checkSchema ){ + schemaIsValid(&sParse); + } + if( sParse.pVdbe ){ + sqlite3VdbeFinalize(sParse.pVdbe); + } + assert( 0==(*ppStmt) ); + rc = sParse.rc; + if( zErrMsg ){ + sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg); + sqlite3DbFree(db, zErrMsg); + }else{ + sqlite3Error(db, rc); + } }else{ + assert( zErrMsg==0 ); *ppStmt = (sqlite3_stmt*)sParse.pVdbe; + rc = SQLITE_OK; + sqlite3ErrorClear(db); } - if( zErrMsg ){ - sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg); - sqlite3DbFree(db, zErrMsg); - }else{ - sqlite3Error(db, rc); - } /* Delete any TriggerPrg structures allocated while parsing this statement. */ while( sParse.pTriggerPrg ){ @@ -129887,12 +133311,16 @@ static void clearSelect(sqlite3 *db, Select *p, int bFree){ sqlite3ExprDelete(db, p->pHaving); sqlite3ExprListDelete(db, p->pOrderBy); sqlite3ExprDelete(db, p->pLimit); + if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith); #ifndef SQLITE_OMIT_WINDOWFUNC if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){ sqlite3WindowListDelete(db, p->pWinDefn); } + while( p->pWin ){ + assert( p->pWin->ppThis==&p->pWin ); + sqlite3WindowUnlinkFromSelect(p->pWin); + } #endif - if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith); if( bFree ) sqlite3DbFreeNN(db, p); p = pPrior; bFree = 1; @@ -130064,12 +133492,12 @@ SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *p ** Return the index of a column in a table. Return -1 if the column ** is not contained in the table. */ -static int columnIndex(Table *pTab, const char *zCol){ +SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol){ int i; u8 h = sqlite3StrIHash(zCol); Column *pCol; for(pCol=pTab->aCol, i=0; inCol; pCol++, i++){ - if( pCol->hName==h && sqlite3StrICmp(pCol->zName, zCol)==0 ) return i; + if( pCol->hName==h && sqlite3StrICmp(pCol->zCnName, zCol)==0 ) return i; } return -1; } @@ -130096,7 +133524,7 @@ static int tableAndColumnIndex( assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */ for(i=0; ia[i].pTab, zCol); + iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol); if( iCol>=0 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0) ){ @@ -130145,11 +133573,14 @@ static void addWhereTerm( pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight); pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2); + assert( pE2!=0 || pEq==0 ); /* Due to db->mallocFailed test + ** in sqlite3DbMallocRawNN() called from + ** sqlite3PExpr(). */ if( pEq && isOuterJoin ){ ExprSetProperty(pEq, EP_FromJoin); assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) ); ExprSetVVAProperty(pEq, EP_NoReduce); - pEq->iRightJoinTable = (i16)pE2->iTable; + pEq->iRightJoinTable = pE2->iTable; } *ppWhere = sqlite3ExprAnd(pParse, *ppWhere, pEq); } @@ -130185,11 +133616,14 @@ SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr *p, int iTable){ ExprSetProperty(p, EP_FromJoin); assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) ); ExprSetVVAProperty(p, EP_NoReduce); - p->iRightJoinTable = (i16)iTable; - if( p->op==TK_FUNCTION && p->x.pList ){ - int i; - for(i=0; ix.pList->nExpr; i++){ - sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable); + p->iRightJoinTable = iTable; + if( p->op==TK_FUNCTION ){ + assert( ExprUseXList(p) ); + if( p->x.pList ){ + int i; + for(i=0; ix.pList->nExpr; i++){ + sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable); + } } } sqlite3SetJoinExpr(p->pLeft, iTable); @@ -130209,10 +133643,16 @@ static void unsetJoinExpr(Expr *p, int iTable){ && (iTable<0 || p->iRightJoinTable==iTable) ){ ExprClearProperty(p, EP_FromJoin); } - if( p->op==TK_FUNCTION && p->x.pList ){ - int i; - for(i=0; ix.pList->nExpr; i++){ - unsetJoinExpr(p->x.pList->a[i].pExpr, iTable); + if( p->op==TK_COLUMN && p->iTable==iTable ){ + ExprClearProperty(p, EP_CanBeNull); + } + if( p->op==TK_FUNCTION ){ + assert( ExprUseXList(p) ); + if( p->x.pList ){ + int i; + for(i=0; ix.pList->nExpr; i++){ + unsetJoinExpr(p->x.pList->a[i].pExpr, iTable); + } } } unsetJoinExpr(p->pLeft, iTable); @@ -130237,8 +133677,8 @@ static void unsetJoinExpr(Expr *p, int iTable){ static int sqliteProcessJoin(Parse *pParse, Select *p){ SrcList *pSrc; /* All tables in the FROM clause */ int i, j; /* Loop counters */ - struct SrcList_item *pLeft; /* Left table being joined */ - struct SrcList_item *pRight; /* Right table being joined */ + SrcItem *pLeft; /* Left table being joined */ + SrcItem *pRight; /* Right table being joined */ pSrc = p->pSrc; pLeft = &pSrc->a[0]; @@ -130265,7 +133705,7 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){ int iLeftCol; /* Matching column in the left table */ if( IsHiddenColumn(&pRightTab->aCol[j]) ) continue; - zName = pRightTab->aCol[j].zName; + zName = pRightTab->aCol[j].zCnName; if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 1) ){ addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j, isOuter, &p->pWhere); @@ -130306,7 +133746,7 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){ int iRightCol; /* Column number of matching column on the right */ zName = pList->a[j].zName; - iRightCol = columnIndex(pRightTab, zName); + iRightCol = sqlite3ColumnIndex(pRightTab, zName); if( iRightCol<0 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 0) ){ @@ -130536,31 +133976,157 @@ static void codeOffset( } /* -** Add code that will check to make sure the N registers starting at iMem -** form a distinct entry. iTab is a sorting index that holds previously -** seen combinations of the N values. A new entry is made in iTab -** if the current N values are new. +** Add code that will check to make sure the array of registers starting at +** iMem form a distinct entry. This is used by both "SELECT DISTINCT ..." and +** distinct aggregates ("SELECT count(DISTINCT ) ..."). Three strategies +** are available. Which is used depends on the value of parameter eTnctType, +** as follows: ** -** A jump to addrRepeat is made and the N+1 values are popped from the -** stack if the top N elements are not distinct. -*/ -static void codeDistinct( +** WHERE_DISTINCT_UNORDERED/WHERE_DISTINCT_NOOP: +** Build an ephemeral table that contains all entries seen before and +** skip entries which have been seen before. +** +** Parameter iTab is the cursor number of an ephemeral table that must +** be opened before the VM code generated by this routine is executed. +** The ephemeral cursor table is queried for a record identical to the +** record formed by the current array of registers. If one is found, +** jump to VM address addrRepeat. Otherwise, insert a new record into +** the ephemeral cursor and proceed. +** +** The returned value in this case is a copy of parameter iTab. +** +** WHERE_DISTINCT_ORDERED: +** In this case rows are being delivered sorted order. The ephermal +** table is not required. Instead, the current set of values +** is compared against previous row. If they match, the new row +** is not distinct and control jumps to VM address addrRepeat. Otherwise, +** the VM program proceeds with processing the new row. +** +** The returned value in this case is the register number of the first +** in an array of registers used to store the previous result row so that +** it can be compared to the next. The caller must ensure that this +** register is initialized to NULL. (The fixDistinctOpenEph() routine +** will take care of this initialization.) +** +** WHERE_DISTINCT_UNIQUE: +** In this case it has already been determined that the rows are distinct. +** No special action is required. The return value is zero. +** +** Parameter pEList is the list of expressions used to generated the +** contents of each row. It is used by this routine to determine (a) +** how many elements there are in the array of registers and (b) the +** collation sequences that should be used for the comparisons if +** eTnctType is WHERE_DISTINCT_ORDERED. +*/ +static int codeDistinct( Parse *pParse, /* Parsing and code generating context */ + int eTnctType, /* WHERE_DISTINCT_* value */ int iTab, /* A sorting index used to test for distinctness */ int addrRepeat, /* Jump to here if not distinct */ - int N, /* Number of elements */ - int iMem /* First element */ + ExprList *pEList, /* Expression for each element */ + int regElem /* First element */ ){ - Vdbe *v; - int r1; + int iRet = 0; + int nResultCol = pEList->nExpr; + Vdbe *v = pParse->pVdbe; - v = pParse->pVdbe; - r1 = sqlite3GetTempReg(pParse); - sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v); - sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1); - sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, iMem, N); - sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); - sqlite3ReleaseTempReg(pParse, r1); + switch( eTnctType ){ + case WHERE_DISTINCT_ORDERED: { + int i; + int iJump; /* Jump destination */ + int regPrev; /* Previous row content */ + + /* Allocate space for the previous row */ + iRet = regPrev = pParse->nMem+1; + pParse->nMem += nResultCol; + + iJump = sqlite3VdbeCurrentAddr(v) + nResultCol; + for(i=0; ia[i].pExpr); + if( idb->mallocFailed ); + sqlite3VdbeAddOp3(v, OP_Copy, regElem, regPrev, nResultCol-1); + break; + } + + case WHERE_DISTINCT_UNIQUE: { + /* nothing to do */ + break; + } + + default: { + int r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, regElem, nResultCol); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regElem, nResultCol, r1); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, regElem, nResultCol); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + sqlite3ReleaseTempReg(pParse, r1); + iRet = iTab; + break; + } + } + + return iRet; +} + +/* +** This routine runs after codeDistinct(). It makes necessary +** adjustments to the OP_OpenEphemeral opcode that the codeDistinct() +** routine made use of. This processing must be done separately since +** sometimes codeDistinct is called before the OP_OpenEphemeral is actually +** laid down. +** +** WHERE_DISTINCT_NOOP: +** WHERE_DISTINCT_UNORDERED: +** +** No adjustments necessary. This function is a no-op. +** +** WHERE_DISTINCT_UNIQUE: +** +** The ephemeral table is not needed. So change the +** OP_OpenEphemeral opcode into an OP_Noop. +** +** WHERE_DISTINCT_ORDERED: +** +** The ephemeral table is not needed. But we do need register +** iVal to be initialized to NULL. So change the OP_OpenEphemeral +** into an OP_Null on the iVal register. +*/ +static void fixDistinctOpenEph( + Parse *pParse, /* Parsing and code generating context */ + int eTnctType, /* WHERE_DISTINCT_* value */ + int iVal, /* Value returned by codeDistinct() */ + int iOpenEphAddr /* Address of OP_OpenEphemeral instruction for iTab */ +){ + if( pParse->nErr==0 + && (eTnctType==WHERE_DISTINCT_UNIQUE || eTnctType==WHERE_DISTINCT_ORDERED) + ){ + Vdbe *v = pParse->pVdbe; + sqlite3VdbeChangeToNoop(v, iOpenEphAddr); + if( sqlite3VdbeGetOp(v, iOpenEphAddr+1)->opcode==OP_Explain ){ + sqlite3VdbeChangeToNoop(v, iOpenEphAddr+1); + } + if( eTnctType==WHERE_DISTINCT_ORDERED ){ + /* Change the OP_OpenEphemeral to an OP_Null that sets the MEM_Cleared + ** bit on the first register of the previous value. This will cause the + ** OP_Ne added in codeDistinct() to always fail on the first iteration of + ** the loop even if the first row is all NULLs. */ + VdbeOp *pOp = sqlite3VdbeGetOp(v, iOpenEphAddr); + pOp->opcode = OP_Null; + pOp->p1 = 1; + pOp->p2 = iVal; + } + } } #ifdef SQLITE_ENABLE_SORTER_REFERENCES @@ -130601,9 +134167,13 @@ static void selectExprDefer( struct ExprList_item *pItem = &pEList->a[i]; if( pItem->u.x.iOrderByCol==0 ){ Expr *pExpr = pItem->pExpr; - Table *pTab = pExpr->y.pTab; - if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 && pTab && !IsVirtual(pTab) - && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF) + Table *pTab; + if( pExpr->op==TK_COLUMN + && pExpr->iColumn>=0 + && ALWAYS( ExprUseYTab(pExpr) ) + && (pTab = pExpr->y.pTab)!=0 + && IsOrdinaryTable(pTab) + && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0 ){ int j; for(j=0; jiTable = pExpr->iTable; + assert( ExprUseYTab(pNew) ); pNew->y.pTab = pExpr->y.pTab; pNew->iColumn = pPk ? pPk->aiColumn[k] : -1; pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew); @@ -130808,59 +134379,11 @@ static void selectInnerLoop( ** part of the result. */ if( hasDistinct ){ - switch( pDistinct->eTnctType ){ - case WHERE_DISTINCT_ORDERED: { - VdbeOp *pOp; /* No longer required OpenEphemeral instr. */ - int iJump; /* Jump destination */ - int regPrev; /* Previous row content */ - - /* Allocate space for the previous row */ - regPrev = pParse->nMem+1; - pParse->nMem += nResultCol; - - /* Change the OP_OpenEphemeral coded earlier to an OP_Null - ** sets the MEM_Cleared bit on the first register of the - ** previous value. This will cause the OP_Ne below to always - ** fail on the first iteration of the loop even if the first - ** row is all NULLs. - */ - sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct); - pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct); - pOp->opcode = OP_Null; - pOp->p1 = 1; - pOp->p2 = regPrev; - pOp = 0; /* Ensure pOp is not used after sqlite3VdbeAddOp() */ - - iJump = sqlite3VdbeCurrentAddr(v) + nResultCol; - for(i=0; ipEList->a[i].pExpr); - if( idb->mallocFailed ); - sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1); - break; - } - - case WHERE_DISTINCT_UNIQUE: { - sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct); - break; - } - - default: { - assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED ); - codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol, - regResult); - break; - } - } + int eType = pDistinct->eTnctType; + int iTab = pDistinct->tabTnct; + assert( nResultCol==p->pEList->nExpr ); + iTab = codeDistinct(pParse, eType, iTab, iContinue, p->pEList, regResult); + fixDistinctOpenEph(pParse, eType, iTab, pDistinct->addrTnct); if( pSort==0 ){ codeOffset(v, p->iOffset, iContinue); } @@ -131185,7 +134708,7 @@ SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList( /* ** Name of the connection operator, used for error messages. */ -static const char *selectOpName(int id){ +SQLITE_PRIVATE const char *sqlite3SelectOpName(int id){ char *z; switch( id ){ case TK_ALL: z = "UNION ALL"; break; @@ -131520,13 +135043,19 @@ static const char *columnTypeImpl( break; } - assert( pTab && pExpr->y.pTab==pTab ); + assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab ); if( pS ){ /* The "table" is actually a sub-select or a view in the FROM clause ** of the SELECT statement. Return the declaration type and origin ** data for the result-set column of the sub-select. */ - if( iCol>=0 && iColpEList->nExpr ){ + if( iColpEList->nExpr +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW + && iCol>=0 +#else + && ALWAYS(iCol>=0) +#endif + ){ /* If iCol is less than zero, then the expression requests the ** rowid of the sub-select or view. This expression is legal (see ** test case misc2.2.2) - it always evaluates to NULL. @@ -131548,7 +135077,7 @@ static const char *columnTypeImpl( zType = "INTEGER"; zOrigCol = "rowid"; }else{ - zOrigCol = pTab->aCol[iCol].zName; + zOrigCol = pTab->aCol[iCol].zCnName; zType = sqlite3ColumnType(&pTab->aCol[iCol],0); } zOrigTab = pTab->zName; @@ -131574,9 +135103,11 @@ static const char *columnTypeImpl( ** statement. */ NameContext sNC; - Select *pS = pExpr->x.pSelect; - Expr *p = pS->pEList->a[0].pExpr; - assert( ExprHasProperty(pExpr, EP_xIsSelect) ); + Select *pS; + Expr *p; + assert( ExprUseXSelect(pExpr) ); + pS = pExpr->x.pSelect; + p = pS->pEList->a[0].pExpr; sNC.pSrcList = pS->pSrc; sNC.pNext = pNC; sNC.pParse = pNC->pParse; @@ -131668,7 +135199,7 @@ static void generateColumnTypes( ** then the result column name with the table name ** prefix, ex: TABLE.COLUMN. Otherwise use zSpan. */ -static void generateColumnNames( +SQLITE_PRIVATE void sqlite3GenerateColumnNames( Parse *pParse, /* Parser context */ Select *pSelect /* Generate column names for this SELECT statement */ ){ @@ -131705,7 +135236,8 @@ static void generateColumnNames( assert( p!=0 ); assert( p->op!=TK_AGG_COLUMN ); /* Agg processing has not run yet */ - assert( p->op!=TK_COLUMN || p->y.pTab!=0 ); /* Covering idx not yet coded */ + assert( p->op!=TK_COLUMN + || (ExprUseYTab(p) && p->y.pTab!=0) ); /* Covering idx not yet coded */ if( pEList->a[i].zEName && pEList->a[i].eEName==ENAME_NAME ){ /* An AS clause always takes first priority */ char *zName = pEList->a[i].zEName; @@ -131720,7 +135252,7 @@ static void generateColumnNames( if( iCol<0 ){ zCol = "rowid"; }else{ - zCol = pTab->aCol[iCol].zName; + zCol = pTab->aCol[iCol].zCnName; } if( fullName ){ char *zName = 0; @@ -131758,7 +135290,7 @@ static void generateColumnNames( ** and will break if those assumptions changes. Hence, use extreme caution ** when modifying this routine to avoid breaking legacy. ** -** See Also: generateColumnNames() +** See Also: sqlite3GenerateColumnNames() */ SQLITE_PRIVATE int sqlite3ColumnsFromExprList( Parse *pParse, /* Parsing context */ @@ -131781,7 +135313,7 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList( nCol = pEList->nExpr; aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol); testcase( aCol==0 ); - if( nCol>32767 ) nCol = 32767; + if( NEVER(nCol>32767) ) nCol = 32767; }else{ nCol = 0; aCol = 0; @@ -131801,11 +135333,14 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList( pColExpr = pColExpr->pRight; assert( pColExpr!=0 ); } - if( pColExpr->op==TK_COLUMN && (pTab = pColExpr->y.pTab)!=0 ){ + if( pColExpr->op==TK_COLUMN + && ALWAYS( ExprUseYTab(pColExpr) ) + && (pTab = pColExpr->y.pTab)!=0 + ){ /* For columns use the column name name */ int iCol = pColExpr->iColumn; if( iCol<0 ) iCol = pTab->iPKey; - zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid"; + zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid"; }else if( pColExpr->op==TK_ID ){ assert( !ExprHasProperty(pColExpr, EP_IntValue) ); zName = pColExpr->u.zToken; @@ -131833,7 +135368,7 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList( zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt); if( cnt>3 ) sqlite3_randomness(sizeof(cnt), &cnt); } - pCol->zName = zName; + pCol->zCnName = zName; pCol->hName = sqlite3StrIHash(zName); sqlite3ColumnPropertiesFromName(0, pCol); if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){ @@ -131843,7 +135378,7 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList( sqlite3HashClear(&ht); if( db->mallocFailed ){ for(j=0; jpEList->a; for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ const char *zType; - int n, m; + i64 n, m; + pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT); p = a[i].pExpr; zType = columnType(&sNC, p, 0, 0, 0); /* pCol->szEst = ... // Column size est for SELECT tables never used */ pCol->affinity = sqlite3ExprAffinity(p); if( zType ){ m = sqlite3Strlen30(zType); - n = sqlite3Strlen30(pCol->zName); - pCol->zName = sqlite3DbReallocOrFree(db, pCol->zName, n+m+2); - if( pCol->zName ){ - memcpy(&pCol->zName[n+1], zType, m+1); + n = sqlite3Strlen30(pCol->zCnName); + pCol->zCnName = sqlite3DbReallocOrFree(db, pCol->zCnName, n+m+2); + if( pCol->zCnName ){ + memcpy(&pCol->zCnName[n+1], zType, m+1); pCol->colFlags |= COLFLAG_HASTYPE; + }else{ + testcase( pCol->colFlags & COLFLAG_HASTYPE ); + pCol->colFlags &= ~(COLFLAG_HASTYPE|COLFLAG_HASCOLL); } } if( pCol->affinity<=SQLITE_AFF_NONE ) pCol->affinity = aff; pColl = sqlite3ExprCollSeq(pParse, p); - if( pColl && pCol->zColl==0 ){ - pCol->zColl = sqlite3DbStrDup(db, pColl->zName); + if( pColl ){ + assert( pTab->pIndex==0 ); + sqlite3ColumnSetColl(db, pCol, pColl->zName); } } pTab->szTabRow = 1; /* Any non-zero value works */ @@ -132068,7 +135608,7 @@ static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){ */ static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){ ExprList *pOrderBy = p->pOrderBy; - int nOrderBy = p->pOrderBy->nExpr; + int nOrderBy = ALWAYS(pOrderBy!=0) ? pOrderBy->nExpr : 0; sqlite3 *db = pParse->db; KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1); if( pRet ){ @@ -132140,7 +135680,7 @@ static void generateWithRecursiveQuery( SrcList *pSrc = p->pSrc; /* The FROM clause of the recursive query */ int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */ Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */ - Select *pSetup = p->pPrior; /* The setup query */ + Select *pSetup; /* The setup query */ Select *pFirstRec; /* Left-most recursive term */ int addrTop; /* Top of the loop */ int addrCont, addrBreak; /* CONTINUE and BREAK addresses */ @@ -132224,7 +135764,6 @@ static void generateWithRecursiveQuery( ** iDistinct table. pFirstRec is left pointing to the left-most ** recursive term of the CTE. */ - pFirstRec = p; for(pFirstRec=p; ALWAYS(pFirstRec!=0); pFirstRec=pFirstRec->pPrior){ if( pFirstRec->selFlags & SF_Aggregate ){ sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported"); @@ -132403,12 +135942,8 @@ static int multiSelect( db = pParse->db; pPrior = p->pPrior; dest = *pDest; - if( pPrior->pOrderBy || pPrior->pLimit ){ - sqlite3ErrorMsg(pParse,"%s clause should come after %s not before", - pPrior->pOrderBy!=0 ? "ORDER BY" : "LIMIT", selectOpName(p->op)); - rc = 1; - goto multi_select_end; - } + assert( pPrior->pOrderBy==0 ); + assert( pPrior->pLimit==0 ); v = sqlite3GetVdbe(pParse); assert( v!=0 ); /* The VDBE already created by calling function */ @@ -132459,13 +135994,14 @@ static int multiSelect( switch( p->op ){ case TK_ALL: { int addr = 0; - int nLimit; + int nLimit = 0; /* Initialize to suppress harmless compiler warning */ assert( !pPrior->pLimit ); pPrior->iLimit = p->iLimit; pPrior->iOffset = p->iOffset; pPrior->pLimit = p->pLimit; + SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL left...\n")); rc = sqlite3Select(pParse, pPrior, &dest); - p->pLimit = 0; + pPrior->pLimit = 0; if( rc ){ goto multi_select_end; } @@ -132481,13 +136017,14 @@ static int multiSelect( } } ExplainQueryPlan((pParse, 1, "UNION ALL")); + SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL right...\n")); rc = sqlite3Select(pParse, p, &dest); testcase( rc!=SQLITE_OK ); pDelete = p->pPrior; p->pPrior = pPrior; p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow); - if( pPrior->pLimit - && sqlite3ExprIsInteger(pPrior->pLimit->pLeft, &nLimit) + if( p->pLimit + && sqlite3ExprIsInteger(p->pLimit->pLeft, &nLimit) && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit) ){ p->nSelectRow = sqlite3LogEst((u64)nLimit); @@ -132533,6 +136070,7 @@ static int multiSelect( */ assert( !pPrior->pOrderBy ); sqlite3SelectDestInit(&uniondest, priorOp, unionTab); + SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION left...\n")); rc = sqlite3Select(pParse, pPrior, &uniondest); if( rc ){ goto multi_select_end; @@ -132551,7 +136089,8 @@ static int multiSelect( p->pLimit = 0; uniondest.eDest = op; ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE", - selectOpName(p->op))); + sqlite3SelectOpName(p->op))); + SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION right...\n")); rc = sqlite3Select(pParse, p, &uniondest); testcase( rc!=SQLITE_OK ); assert( p->pOrderBy==0 ); @@ -132612,6 +136151,7 @@ static int multiSelect( /* Code the SELECTs to our left into temporary table "tab1". */ sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1); + SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT left...\n")); rc = sqlite3Select(pParse, pPrior, &intersectdest); if( rc ){ goto multi_select_end; @@ -132627,7 +136167,8 @@ static int multiSelect( p->pLimit = 0; intersectdest.iSDParm = tab2; ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE", - selectOpName(p->op))); + sqlite3SelectOpName(p->op))); + SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT right...\n")); rc = sqlite3Select(pParse, p, &intersectdest); testcase( rc!=SQLITE_OK ); pDelete = p->pPrior; @@ -132688,6 +136229,7 @@ static int multiSelect( int nCol; /* Number of columns in result set */ assert( p->pNext==0 ); + assert( p->pEList!=0 ); nCol = p->pEList->nExpr; pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1); if( !pKeyInfo ){ @@ -132722,7 +136264,11 @@ static int multiSelect( multi_select_end: pDest->iSdst = dest.iSdst; pDest->nSdst = dest.nSdst; - sqlite3SelectDelete(db, pDelete); + if( pDelete ){ + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3SelectDelete, + pDelete); + } return rc; } #endif /* SQLITE_OMIT_COMPOUND_SELECT */ @@ -132736,7 +136282,8 @@ SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){ sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms"); }else{ sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s" - " do not have the same number of result columns", selectOpName(p->op)); + " do not have the same number of result columns", + sqlite3SelectOpName(p->op)); } } @@ -132833,10 +136380,8 @@ static int generateOutputSubroutine( ** if it is the RHS of a row-value IN operator. */ case SRT_Mem: { - if( pParse->nErr==0 ){ - testcase( pIn->nSdst>1 ); - sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst); - } + testcase( pIn->nSdst>1 ); + sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst); /* The LIMIT clause will jump out of the loop for us */ break; } @@ -133036,6 +136581,7 @@ static int multiSelectOrderBy( for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){ struct ExprList_item *pItem; for(j=0, pItem=pOrderBy->a; ju.x.iOrderByCol>0 ); if( pItem->u.x.iOrderByCol==i ) break; } @@ -133062,6 +136608,7 @@ static int multiSelectOrderBy( struct ExprList_item *pItem; aPermute[0] = nOrderBy; for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){ + assert( pItem!=0 ); assert( pItem->u.x.iOrderByCol>0 ); assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr ); aPermute[i] = pItem->u.x.iOrderByCol - 1; @@ -133128,7 +136675,7 @@ static int multiSelectOrderBy( sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA); sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB); - ExplainQueryPlan((pParse, 1, "MERGE (%s)", selectOpName(p->op))); + ExplainQueryPlan((pParse, 1, "MERGE (%s)", sqlite3SelectOpName(p->op))); /* Generate a coroutine to evaluate the SELECT statement to the ** left of the compound operator - the "A" select. @@ -133262,6 +136809,9 @@ static int multiSelectOrderBy( p->pPrior = pPrior; pPrior->pNext = p; + sqlite3ExprListDelete(db, pPrior->pOrderBy); + pPrior->pOrderBy = 0; + /*** TBD: Insert subroutine calls to close cursors on incomplete **** subqueries ****/ ExplainQueryPlanPop(pParse); @@ -133316,9 +136866,12 @@ static Expr *substExpr( && pExpr->iTable==pSubst->iTable && !ExprHasProperty(pExpr, EP_FixedCol) ){ +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW if( pExpr->iColumn<0 ){ pExpr->op = TK_NULL; - }else{ + }else +#endif + { Expr *pNew; Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr; Expr ifNullRow; @@ -133338,10 +136891,14 @@ static Expr *substExpr( } testcase( ExprHasProperty(pCopy, EP_Subquery) ); pNew = sqlite3ExprDup(db, pCopy, 0); - if( pNew && pSubst->isLeftJoin ){ + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pNew); + return pExpr; + } + if( pSubst->isLeftJoin ){ ExprSetProperty(pNew, EP_CanBeNull); } - if( pNew && ExprHasProperty(pExpr,EP_FromJoin) ){ + if( ExprHasProperty(pExpr,EP_FromJoin) ){ sqlite3SetJoinExpr(pNew, pExpr->iRightJoinTable); } sqlite3ExprDelete(db, pExpr); @@ -133349,15 +136906,13 @@ static Expr *substExpr( /* Ensure that the expression now has an implicit collation sequence, ** just as it did when it was a column of a view or sub-query. */ - if( pExpr ){ - if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){ - CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr); - pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr, - (pColl ? pColl->zName : "BINARY") - ); - } - ExprClearProperty(pExpr, EP_Collate); + if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){ + CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr); + pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr, + (pColl ? pColl->zName : "BINARY") + ); } + ExprClearProperty(pExpr, EP_Collate); } } }else{ @@ -133366,7 +136921,7 @@ static Expr *substExpr( } pExpr->pLeft = substExpr(pSubst, pExpr->pLeft); pExpr->pRight = substExpr(pSubst, pExpr->pRight); - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( ExprUseXSelect(pExpr) ){ substSelect(pSubst, pExpr->x.pSelect, 1); }else{ substExprList(pSubst, pExpr->x.pList); @@ -133398,7 +136953,7 @@ static void substSelect( int doPrior /* Do substitutes on p->pPrior too */ ){ SrcList *pSrc; - struct SrcList_item *pItem; + SrcItem *pItem; int i; if( !p ) return; do{ @@ -133428,7 +136983,7 @@ static void substSelect( ** pSrcItem->colUsed mask. */ static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){ - struct SrcList_item *pItem; + SrcItem *pItem; if( pExpr->op!=TK_COLUMN ) return WRC_Continue; pItem = pWalker->u.pSrcItem; if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue; @@ -133438,7 +136993,7 @@ static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){ } static void recomputeColumnsUsed( Select *pSelect, /* The complete SELECT statement */ - struct SrcList_item *pSrcItem /* Which FROM clause item to recompute */ + SrcItem *pSrcItem /* Which FROM clause item to recompute */ ){ Walker w; if( NEVER(pSrcItem->pTab==0) ) return; @@ -133451,6 +137006,103 @@ static void recomputeColumnsUsed( } #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** Assign new cursor numbers to each of the items in pSrc. For each +** new cursor number assigned, set an entry in the aCsrMap[] array +** to map the old cursor number to the new: +** +** aCsrMap[iOld+1] = iNew; +** +** The array is guaranteed by the caller to be large enough for all +** existing cursor numbers in pSrc. aCsrMap[0] is the array size. +** +** If pSrc contains any sub-selects, call this routine recursively +** on the FROM clause of each such sub-select, with iExcept set to -1. +*/ +static void srclistRenumberCursors( + Parse *pParse, /* Parse context */ + int *aCsrMap, /* Array to store cursor mappings in */ + SrcList *pSrc, /* FROM clause to renumber */ + int iExcept /* FROM clause item to skip */ +){ + int i; + SrcItem *pItem; + for(i=0, pItem=pSrc->a; inSrc; i++, pItem++){ + if( i!=iExcept ){ + Select *p; + assert( pItem->iCursor < aCsrMap[0] ); + if( !pItem->fg.isRecursive || aCsrMap[pItem->iCursor+1]==0 ){ + aCsrMap[pItem->iCursor+1] = pParse->nTab++; + } + pItem->iCursor = aCsrMap[pItem->iCursor+1]; + for(p=pItem->pSelect; p; p=p->pPrior){ + srclistRenumberCursors(pParse, aCsrMap, p->pSrc, -1); + } + } + } +} + +/* +** *piCursor is a cursor number. Change it if it needs to be mapped. +*/ +static void renumberCursorDoMapping(Walker *pWalker, int *piCursor){ + int *aCsrMap = pWalker->u.aiCol; + int iCsr = *piCursor; + if( iCsr < aCsrMap[0] && aCsrMap[iCsr+1]>0 ){ + *piCursor = aCsrMap[iCsr+1]; + } +} + +/* +** Expression walker callback used by renumberCursors() to update +** Expr objects to match newly assigned cursor numbers. +*/ +static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){ + int op = pExpr->op; + if( op==TK_COLUMN || op==TK_IF_NULL_ROW ){ + renumberCursorDoMapping(pWalker, &pExpr->iTable); + } + if( ExprHasProperty(pExpr, EP_FromJoin) ){ + renumberCursorDoMapping(pWalker, &pExpr->iRightJoinTable); + } + return WRC_Continue; +} + +/* +** Assign a new cursor number to each cursor in the FROM clause (Select.pSrc) +** of the SELECT statement passed as the second argument, and to each +** cursor in the FROM clause of any FROM clause sub-selects, recursively. +** Except, do not assign a new cursor number to the iExcept'th element in +** the FROM clause of (*p). Update all expressions and other references +** to refer to the new cursor numbers. +** +** Argument aCsrMap is an array that may be used for temporary working +** space. Two guarantees are made by the caller: +** +** * the array is larger than the largest cursor number used within the +** select statement passed as an argument, and +** +** * the array entries for all cursor numbers that do *not* appear in +** FROM clauses of the select statement as described above are +** initialized to zero. +*/ +static void renumberCursors( + Parse *pParse, /* Parse context */ + Select *p, /* Select to renumber cursors within */ + int iExcept, /* FROM clause item to skip */ + int *aCsrMap /* Working space */ +){ + Walker w; + srclistRenumberCursors(pParse, aCsrMap, p->pSrc, iExcept); + memset(&w, 0, sizeof(w)); + w.u.aiCol = aCsrMap; + w.xExprCallback = renumberCursorsCb; + w.xSelectCallback = sqlite3SelectWalkNoop; + sqlite3WalkSelect(&w, p); +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) /* ** This routine attempts to flatten subqueries as a performance optimization. @@ -133545,9 +137197,9 @@ static void recomputeColumnsUsed( ** (17c) every term within the subquery compound must have a FROM clause ** (17d) the outer query may not be ** (17d1) aggregate, or -** (17d2) DISTINCT, or -** (17d3) a join. -** (17e) the subquery may not contain window functions +** (17d2) DISTINCT +** (17e) the subquery may not contain window functions, and +** (17f) the subquery must not be the RHS of a LEFT JOIN. ** ** The parent and sub-query may contain WHERE clauses. Subject to ** rules (11), (13) and (14), they may also contain ORDER BY, @@ -133563,8 +137215,8 @@ static void recomputeColumnsUsed( ** syntax error and return a detailed message. ** ** (18) If the sub-query is a compound select, then all terms of the -** ORDER BY clause of the parent must be simple references to -** columns of the sub-query. +** ORDER BY clause of the parent must be copies of a term returned +** by the parent query. ** ** (19) If the subquery uses LIMIT then the outer query may not ** have a WHERE clause. @@ -133580,9 +137232,8 @@ static void recomputeColumnsUsed( ** ** (22) The subquery may not be a recursive CTE. ** -** (**) Subsumed into restriction (17d3). Was: If the outer query is -** a recursive CTE, then the sub-query may not be a compound query. -** This restriction is because transforming the +** (23) If the outer query is a recursive CTE, then the sub-query may not be +** a compound query. This restriction is because transforming the ** parent to a compound query confuses the code that handles ** recursive queries in multiSelect(). ** @@ -133624,9 +137275,10 @@ static int flattenSubquery( int isLeftJoin = 0; /* True if pSub is the right side of a LEFT JOIN */ int i; /* Loop counter */ Expr *pWhere; /* The WHERE clause */ - struct SrcList_item *pSubitem; /* The subquery */ + SrcItem *pSubitem; /* The subquery */ sqlite3 *db = pParse->db; Walker w; /* Walker to persist agginfo data */ + int *aCsrMap = 0; /* Check to see if flattening is permitted. Return 0 if not. */ @@ -133722,13 +137374,14 @@ static int flattenSubquery( if( pSub->pOrderBy ){ return 0; /* Restriction (20) */ } - if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){ - return 0; /* (17d1), (17d2), or (17d3) */ + if( isAgg || (p->selFlags & SF_Distinct)!=0 || isLeftJoin>0 ){ + return 0; /* (17d1), (17d2), or (17f) */ } for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){ testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct ); testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate ); assert( pSub->pSrc!=0 ); + assert( (pSub->selFlags & SF_Recursive)==0 ); assert( pSub->pEList->nExpr==pSub1->pEList->nExpr ); if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0 /* (17b) */ || (pSub1->pPrior && pSub1->op!=TK_ALL) /* (17a) */ @@ -133749,15 +137402,16 @@ static int flattenSubquery( if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0; } } - } - /* Ex-restriction (23): - ** The only way that the recursive part of a CTE can contain a compound - ** subquery is for the subquery to be one term of a join. But if the - ** subquery is a join, then the flattening has already been stopped by - ** restriction (17d3) - */ - assert( (p->selFlags & SF_Recursive)==0 || pSub->pPrior==0 ); + /* Restriction (23) */ + if( (p->selFlags & SF_Recursive) ) return 0; + + if( pSrc->nSrc>1 ){ + if( pParse->nSelect>500 ) return 0; + aCsrMap = sqlite3DbMallocZero(db, ((i64)pParse->nTab+1)*sizeof(int)); + if( aCsrMap ) aCsrMap[0] = pParse->nTab; + } + } /***** If we reach this point, flattening is permitted. *****/ SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n", @@ -133769,6 +137423,17 @@ static int flattenSubquery( testcase( i==SQLITE_DENY ); pParse->zAuthContext = zSavedAuthContext; + /* Delete the transient structures associated with thesubquery */ + pSub1 = pSubitem->pSelect; + sqlite3DbFree(db, pSubitem->zDatabase); + sqlite3DbFree(db, pSubitem->zName); + sqlite3DbFree(db, pSubitem->zAlias); + pSubitem->zDatabase = 0; + pSubitem->zName = 0; + pSubitem->zAlias = 0; + pSubitem->pSelect = 0; + assert( pSubitem->pOn==0 ); + /* If the sub-query is a compound SELECT statement, then (by restrictions ** 17 and 18 above) it must be a UNION ALL and the parent query must ** be of the form: @@ -133807,18 +137472,23 @@ static int flattenSubquery( ExprList *pOrderBy = p->pOrderBy; Expr *pLimit = p->pLimit; Select *pPrior = p->pPrior; + Table *pItemTab = pSubitem->pTab; + pSubitem->pTab = 0; p->pOrderBy = 0; - p->pSrc = 0; p->pPrior = 0; p->pLimit = 0; pNew = sqlite3SelectDup(db, p, 0); p->pLimit = pLimit; p->pOrderBy = pOrderBy; - p->pSrc = pSrc; p->op = TK_ALL; + pSubitem->pTab = pItemTab; if( pNew==0 ){ p->pPrior = pPrior; }else{ + pNew->selId = ++pParse->nSelect; + if( aCsrMap && ALWAYS(db->mallocFailed==0) ){ + renumberCursors(pParse, pNew, iFrom, aCsrMap); + } pNew->pPrior = pPrior; if( pPrior ) pPrior->pNext = pNew; pNew->pNext = p; @@ -133826,24 +137496,13 @@ static int flattenSubquery( SELECTTRACE(2,pParse,p,("compound-subquery flattener" " creates %u as peer\n",pNew->selId)); } - if( db->mallocFailed ) return 1; + assert( pSubitem->pSelect==0 ); + } + sqlite3DbFree(db, aCsrMap); + if( db->mallocFailed ){ + pSubitem->pSelect = pSub1; + return 1; } - - /* Begin flattening the iFrom-th entry of the FROM clause - ** in the outer query. - */ - pSub = pSub1 = pSubitem->pSelect; - - /* Delete the transient table structure associated with the - ** subquery - */ - sqlite3DbFree(db, pSubitem->zDatabase); - sqlite3DbFree(db, pSubitem->zName); - sqlite3DbFree(db, pSubitem->zAlias); - pSubitem->zDatabase = 0; - pSubitem->zName = 0; - pSubitem->zAlias = 0; - pSubitem->pSelect = 0; /* Defer deleting the Table object associated with the ** subquery until code generation is @@ -133856,8 +137515,10 @@ static int flattenSubquery( Table *pTabToDel = pSubitem->pTab; if( pTabToDel->nTabRef==1 ){ Parse *pToplevel = sqlite3ParseToplevel(pParse); - pTabToDel->pNextZombie = pToplevel->pZombieTab; - pToplevel->pZombieTab = pTabToDel; + sqlite3ParserAddCleanup(pToplevel, + (void(*)(sqlite3*,void*))sqlite3DeleteTable, + pTabToDel); + testcase( pToplevel->earlyCleanup ); }else{ pTabToDel->nTabRef--; } @@ -133877,6 +137538,7 @@ static int flattenSubquery( ** those references with expressions that resolve to the subquery FROM ** elements we are now copying in. */ + pSub = pSub1; for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){ int nSubSrc; u8 jointype = 0; @@ -133885,14 +137547,8 @@ static int flattenSubquery( nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */ pSrc = pParent->pSrc; /* FROM clause of the outer query */ - if( pSrc ){ - assert( pParent==p ); /* First time through the loop */ - jointype = pSubitem->fg.jointype; - }else{ - assert( pParent!=p ); /* 2nd and subsequent times through the loop */ - pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); - if( pSrc==0 ) break; - pParent->pSrc = pSrc; + if( pParent==p ){ + jointype = pSubitem->fg.jointype; /* First time through the loop */ } /* The subquery uses a single slot of the FROM clause of the outer @@ -134012,7 +137668,7 @@ static int flattenSubquery( sqlite3SelectDelete(db, pSub1); #if SELECTTRACE_ENABLED - if( sqlite3_unsupported_selecttrace & 0x100 ){ + if( sqlite3SelectTrace & 0x100 ){ SELECTTRACE(0x100,pParse,p,("After flattening:\n")); sqlite3TreeViewSelect(0, p, 0); } @@ -134029,8 +137685,10 @@ static int flattenSubquery( typedef struct WhereConst WhereConst; struct WhereConst { Parse *pParse; /* Parsing context */ + u8 *pOomFault; /* Pointer to pParse->db->mallocFailed */ int nConst; /* Number for COLUMN=CONSTANT terms */ int nChng; /* Number of times a constant is propagated */ + int bHasAffBlob; /* At least one column in apExpr[] as affinity BLOB */ Expr **apExpr; /* [i*2] is COLUMN and [i*2+1] is VALUE */ }; @@ -134069,6 +137727,9 @@ static void constInsert( return; /* Already present. Return without doing anything. */ } } + if( sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){ + pConst->bHasAffBlob = 1; + } pConst->nConst++; pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr, @@ -134089,7 +137750,7 @@ static void constInsert( */ static void findConstInWhere(WhereConst *pConst, Expr *pExpr){ Expr *pRight, *pLeft; - if( pExpr==0 ) return; + if( NEVER(pExpr==0) ) return; if( ExprHasProperty(pExpr, EP_FromJoin) ) return; if( pExpr->op==TK_AND ){ findConstInWhere(pConst, pExpr->pRight); @@ -134110,37 +137771,83 @@ static void findConstInWhere(WhereConst *pConst, Expr *pExpr){ } /* -** This is a Walker expression callback. pExpr is a candidate expression -** to be replaced by a value. If pExpr is equivalent to one of the -** columns named in pWalker->u.pConst, then overwrite it with its -** corresponding value. +** This is a helper function for Walker callback propagateConstantExprRewrite(). +** +** Argument pExpr is a candidate expression to be replaced by a value. If +** pExpr is equivalent to one of the columns named in pWalker->u.pConst, +** then overwrite it with the corresponding value. Except, do not do so +** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr +** is SQLITE_AFF_BLOB. */ -static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){ +static int propagateConstantExprRewriteOne( + WhereConst *pConst, + Expr *pExpr, + int bIgnoreAffBlob +){ int i; - WhereConst *pConst; + if( pConst->pOomFault[0] ) return WRC_Prune; if( pExpr->op!=TK_COLUMN ) return WRC_Continue; if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){ testcase( ExprHasProperty(pExpr, EP_FixedCol) ); testcase( ExprHasProperty(pExpr, EP_FromJoin) ); return WRC_Continue; } - pConst = pWalker->u.pConst; for(i=0; inConst; i++){ Expr *pColumn = pConst->apExpr[i*2]; if( pColumn==pExpr ) continue; if( pColumn->iTable!=pExpr->iTable ) continue; if( pColumn->iColumn!=pExpr->iColumn ) continue; + if( bIgnoreAffBlob && sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){ + break; + } /* A match is found. Add the EP_FixedCol property */ pConst->nChng++; ExprClearProperty(pExpr, EP_Leaf); ExprSetProperty(pExpr, EP_FixedCol); assert( pExpr->pLeft==0 ); pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0); + if( pConst->pParse->db->mallocFailed ) return WRC_Prune; break; } return WRC_Prune; } +/* +** This is a Walker expression callback. pExpr is a node from the WHERE +** clause of a SELECT statement. This function examines pExpr to see if +** any substitutions based on the contents of pWalker->u.pConst should +** be made to pExpr or its immediate children. +** +** A substitution is made if: +** +** + pExpr is a column with an affinity other than BLOB that matches +** one of the columns in pWalker->u.pConst, or +** +** + pExpr is a binary comparison operator (=, <=, >=, <, >) that +** uses an affinity other than TEXT and one of its immediate +** children is a column that matches one of the columns in +** pWalker->u.pConst. +*/ +static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){ + WhereConst *pConst = pWalker->u.pConst; + assert( TK_GT==TK_EQ+1 ); + assert( TK_LE==TK_EQ+2 ); + assert( TK_LT==TK_EQ+3 ); + assert( TK_GE==TK_EQ+4 ); + if( pConst->bHasAffBlob ){ + if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE) + || pExpr->op==TK_IS + ){ + propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0); + if( pConst->pOomFault[0] ) return WRC_Prune; + if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){ + propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0); + } + } + } + return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob); +} + /* ** The WHERE-clause constant propagation optimization. ** @@ -134176,6 +137883,21 @@ static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){ ** routines know to generate the constant "123" instead of looking up the ** column value. Also, to avoid collation problems, this optimization is ** only attempted if the "a=123" term uses the default BINARY collation. +** +** 2021-05-25 forum post 6a06202608: Another troublesome case is... +** +** CREATE TABLE t1(x); +** INSERT INTO t1 VALUES(10.0); +** SELECT 1 FROM t1 WHERE x=10 AND x LIKE 10; +** +** The query should return no rows, because the t1.x value is '10.0' not '10' +** and '10.0' is not LIKE '10'. But if we are not careful, the first WHERE +** term "x=10" will cause the second WHERE term to become "10 LIKE 10", +** resulting in a false positive. To avoid this, constant propagation for +** columns with BLOB affinity is only allowed if the constant is used with +** operators ==, <=, <, >=, >, or IS in a way that will cause the correct +** type conversions to occur. See logic associated with the bHasAffBlob flag +** for details. */ static int propagateConstants( Parse *pParse, /* The parsing context */ @@ -134185,10 +137907,12 @@ static int propagateConstants( Walker w; int nChng = 0; x.pParse = pParse; + x.pOomFault = &pParse->db->mallocFailed; do{ x.nConst = 0; x.nChng = 0; x.apExpr = 0; + x.bHasAffBlob = 0; findConstInWhere(&x, p->pWhere); if( x.nConst ){ memset(&w, 0, sizeof(w)); @@ -134206,6 +137930,35 @@ static int propagateConstants( return nChng; } +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +# if !defined(SQLITE_OMIT_WINDOWFUNC) +/* +** This function is called to determine whether or not it is safe to +** push WHERE clause expression pExpr down to FROM clause sub-query +** pSubq, which contains at least one window function. Return 1 +** if it is safe and the expression should be pushed down, or 0 +** otherwise. +** +** It is only safe to push the expression down if it consists only +** of constants and copies of expressions that appear in the PARTITION +** BY clause of all window function used by the sub-query. It is safe +** to filter out entire partitions, but not rows within partitions, as +** this may change the results of the window functions. +** +** At the time this function is called it is guaranteed that +** +** * the sub-query uses only one distinct window frame, and +** * that the window frame has a PARTITION BY clase. +*/ +static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){ + assert( pSubq->pWin->pPartition ); + assert( (pSubq->selFlags & SF_MultiPart)==0 ); + assert( pSubq->pPrior==0 ); + return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition); +} +# endif /* SQLITE_OMIT_WINDOWFUNC */ +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) /* ** Make copies of relevant WHERE clause terms of the outer query into @@ -134253,9 +138006,24 @@ static int propagateConstants( ** But if the (b2=2) term were to be pushed down into the bb subquery, ** then the (1,1,NULL) row would be suppressed. ** -** (6) The inner query features one or more window-functions (since -** changes to the WHERE clause of the inner query could change the -** window over which window functions are calculated). +** (6) Window functions make things tricky as changes to the WHERE clause +** of the inner query could change the window over which window +** functions are calculated. Therefore, do not attempt the optimization +** if: +** +** (6a) The inner query uses multiple incompatible window partitions. +** +** (6b) The inner query is a compound and uses window-functions. +** +** (6c) The WHERE clause does not consist entirely of constants and +** copies of expressions found in the PARTITION BY clause of +** all window-functions used by the sub-query. It is safe to +** filter out entire partitions, as this does not change the +** window over which any window-function is calculated. +** +** (7) The inner query is a Common Table Expression (CTE) that should +** be materialized. (This restriction is implemented in the calling +** routine.) ** ** Return 0 if no changes are made and non-zero if one or more WHERE clause ** terms are duplicated into the subquery. @@ -134269,13 +138037,17 @@ static int pushDownWhereTerms( ){ Expr *pNew; int nChng = 0; - Select *pSel; if( pWhere==0 ) return 0; - if( pSubq->selFlags & SF_Recursive ) return 0; /* restriction (2) */ + if( pSubq->selFlags & (SF_Recursive|SF_MultiPart) ) return 0; #ifndef SQLITE_OMIT_WINDOWFUNC - for(pSel=pSubq; pSel; pSel=pSel->pPrior){ - if( pSel->pWin ) return 0; /* restriction (6) */ + if( pSubq->pPrior ){ + Select *pSel; + for(pSel=pSubq; pSel; pSel=pSel->pPrior){ + if( pSel->pWin ) return 0; /* restriction (6b) */ + } + }else{ + if( pSubq->pWin && pSubq->pWin->pPartition==0 ) return 0; } #endif @@ -134311,6 +138083,7 @@ static int pushDownWhereTerms( } if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){ nChng++; + pSubq->selFlags |= SF_PushDown; while( pSubq ){ SubstContext x; pNew = sqlite3ExprDup(pParse->db, pWhere, 0); @@ -134321,6 +138094,14 @@ static int pushDownWhereTerms( x.isLeftJoin = 0; x.pEList = pSubq->pEList; pNew = substExpr(&x, pNew); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pSubq->pWin && 0==pushDownWindowCheck(pParse, pSubq, pNew) ){ + /* Restriction 6c has prevented push-down in this case */ + sqlite3ExprDelete(pParse->db, pNew); + nChng--; + break; + } +#endif if( pSubq->selFlags & SF_Aggregate ){ pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew); }else{ @@ -134351,7 +138132,7 @@ static int pushDownWhereTerms( */ static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){ int eRet = WHERE_ORDERBY_NORMAL; /* Return value */ - ExprList *pEList = pFunc->x.pList; /* Arguments to agg function */ + ExprList *pEList; /* Arguments to agg function */ const char *zFunc; /* Name of aggregate function pFunc */ ExprList *pOrderBy; u8 sortFlags = 0; @@ -134359,9 +138140,16 @@ static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){ assert( *ppMinMax==0 ); assert( pFunc->op==TK_AGG_FUNCTION ); assert( !IsWindowFunc(pFunc) ); - if( pEList==0 || pEList->nExpr!=1 || ExprHasProperty(pFunc, EP_WinFunc) ){ + assert( ExprUseXList(pFunc) ); + pEList = pFunc->x.pList; + if( pEList==0 + || pEList->nExpr!=1 + || ExprHasProperty(pFunc, EP_WinFunc) + || OptimizationDisabled(db, SQLITE_MinMaxOpt) + ){ return eRet; } + assert( !ExprHasProperty(pFunc, EP_IntValue) ); zFunc = pFunc->u.zToken; if( sqlite3StrICmp(zFunc, "min")==0 ){ eRet = WHERE_ORDERBY_MIN; @@ -134389,7 +138177,13 @@ static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){ ** ** where table is a database table, not a sub-select or view. If the query ** does match this pattern, then a pointer to the Table object representing -** is returned. Otherwise, 0 is returned. +** is returned. Otherwise, NULL is returned. +** +** This routine checks to see if it is safe to use the count optimization. +** A correct answer is still obtained (though perhaps more slowly) if +** this routine returns NULL when it could have returned a table pointer. +** But returning the pointer when NULL should have been returned can +** result in incorrect answers and/or crashes. So, when in doubt, return NULL. */ static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){ Table *pTab; @@ -134397,19 +138191,26 @@ static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){ assert( !p->pGroupBy ); - if( p->pWhere || p->pEList->nExpr!=1 - || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect + if( p->pWhere + || p->pEList->nExpr!=1 + || p->pSrc->nSrc!=1 + || p->pSrc->a[0].pSelect + || pAggInfo->nFunc!=1 ){ return 0; } pTab = p->pSrc->a[0].pTab; + assert( pTab!=0 ); + assert( !IsView(pTab) ); + if( !IsOrdinaryTable(pTab) ) return 0; pExpr = p->pEList->a[0].pExpr; - assert( pTab && !pTab->pSelect && pExpr ); - - if( IsVirtual(pTab) ) return 0; + assert( pExpr!=0 ); if( pExpr->op!=TK_AGG_FUNCTION ) return 0; - if( NEVER(pAggInfo->nFunc==0) ) return 0; + if( pExpr->pAggInfo!=pAggInfo ) return 0; if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0; + assert( pAggInfo->aFunc[0].pFExpr==pExpr ); + testcase( ExprHasProperty(pExpr, EP_Distinct) ); + testcase( ExprHasProperty(pExpr, EP_WinFunc) ); if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0; return pTab; @@ -134422,24 +138223,27 @@ static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){ ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate ** pFrom->pIndex and return SQLITE_OK. */ -SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){ - if( pFrom->pTab && pFrom->fg.isIndexedBy ){ - Table *pTab = pFrom->pTab; - char *zIndexedBy = pFrom->u1.zIndexedBy; - Index *pIdx; - for(pIdx=pTab->pIndex; - pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy); - pIdx=pIdx->pNext - ); - if( !pIdx ){ - sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0); - pParse->checkSchema = 1; - return SQLITE_ERROR; - } - pFrom->pIBIndex = pIdx; +SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, SrcItem *pFrom){ + Table *pTab = pFrom->pTab; + char *zIndexedBy = pFrom->u1.zIndexedBy; + Index *pIdx; + assert( pTab!=0 ); + assert( pFrom->fg.isIndexedBy!=0 ); + + for(pIdx=pTab->pIndex; + pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy); + pIdx=pIdx->pNext + ); + if( !pIdx ){ + sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0); + pParse->checkSchema = 1; + return SQLITE_ERROR; } + assert( pFrom->fg.isCte==0 ); + pFrom->u2.pIBIndex = pIdx; return SQLITE_OK; } + /* ** Detect compound SELECT statements that use an ORDER BY clause with ** an alternative collating sequence. @@ -134526,7 +138330,7 @@ static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){ ** arguments. If it does, leave an error message in pParse and return ** non-zero, since pFrom is not allowed to be a table-valued function. */ -static int cannotBeFunction(Parse *pParse, struct SrcList_item *pFrom){ +static int cannotBeFunction(Parse *pParse, SrcItem *pFrom){ if( pFrom->fg.isTabFunc ){ sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName); return 1; @@ -134547,21 +138351,22 @@ static int cannotBeFunction(Parse *pParse, struct SrcList_item *pFrom){ */ static struct Cte *searchWith( With *pWith, /* Current innermost WITH clause */ - struct SrcList_item *pItem, /* FROM clause element to resolve */ + SrcItem *pItem, /* FROM clause element to resolve */ With **ppContext /* OUT: WITH clause return value belongs to */ ){ - const char *zName; - if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){ - With *p; - for(p=pWith; p; p=p->pOuter){ - int i; - for(i=0; inCte; i++){ - if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){ - *ppContext = p; - return &p->a[i]; - } + const char *zName = pItem->zName; + With *p; + assert( pItem->zDatabase==0 ); + assert( zName!=0 ); + for(p=pWith; p; p=p->pOuter){ + int i; + for(i=0; inCte; i++){ + if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){ + *ppContext = p; + return &p->a[i]; } } + if( p->bView ) break; } return 0; } @@ -134571,52 +138376,83 @@ static struct Cte *searchWith( ** ** This routine pushes the WITH clause passed as the second argument ** onto the top of the stack. If argument bFree is true, then this -** WITH clause will never be popped from the stack. In this case it -** should be freed along with the Parse object. In other cases, when +** WITH clause will never be popped from the stack but should instead +** be freed along with the Parse object. In other cases, when ** bFree==0, the With object will be freed along with the SELECT ** statement with which it is associated. +** +** This routine returns a copy of pWith. Or, if bFree is true and +** the pWith object is destroyed immediately due to an OOM condition, +** then this routine return NULL. +** +** If bFree is true, do not continue to use the pWith pointer after +** calling this routine, Instead, use only the return value. */ -SQLITE_PRIVATE void sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){ - assert( bFree==0 || (pParse->pWith==0 && pParse->pWithToFree==0) ); +SQLITE_PRIVATE With *sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){ if( pWith ){ - assert( pParse->pWith!=pWith ); - pWith->pOuter = pParse->pWith; - pParse->pWith = pWith; - if( bFree ) pParse->pWithToFree = pWith; + if( bFree ){ + pWith = (With*)sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3WithDelete, + pWith); + if( pWith==0 ) return 0; + } + if( pParse->nErr==0 ){ + assert( pParse->pWith!=pWith ); + pWith->pOuter = pParse->pWith; + pParse->pWith = pWith; + } } + return pWith; } /* ** This function checks if argument pFrom refers to a CTE declared by -** a WITH clause on the stack currently maintained by the parser. And, -** if currently processing a CTE expression, if it is a recursive -** reference to the current CTE. +** a WITH clause on the stack currently maintained by the parser (on the +** pParse->pWith linked list). And if currently processing a CTE +** CTE expression, through routine checks to see if the reference is +** a recursive reference to the CTE. ** -** If pFrom falls into either of the two categories above, pFrom->pTab -** and other fields are populated accordingly. The caller should check -** (pFrom->pTab!=0) to determine whether or not a successful match -** was found. +** If pFrom matches a CTE according to either of these two above, pFrom->pTab +** and other fields are populated accordingly. ** -** Whether or not a match is found, SQLITE_OK is returned if no error -** occurs. If an error does occur, an error message is stored in the -** parser and some error code other than SQLITE_OK returned. +** Return 0 if no match is found. +** Return 1 if a match is found. +** Return 2 if an error condition is detected. */ -static int withExpand( - Walker *pWalker, - struct SrcList_item *pFrom +static int resolveFromTermToCte( + Parse *pParse, /* The parsing context */ + Walker *pWalker, /* Current tree walker */ + SrcItem *pFrom /* The FROM clause term to check */ ){ - Parse *pParse = pWalker->pParse; - sqlite3 *db = pParse->db; - struct Cte *pCte; /* Matched CTE (or NULL if no match) */ - With *pWith; /* WITH clause that pCte belongs to */ + Cte *pCte; /* Matched CTE (or NULL if no match) */ + With *pWith; /* The matching WITH */ assert( pFrom->pTab==0 ); + if( pParse->pWith==0 ){ + /* There are no WITH clauses in the stack. No match is possible */ + return 0; + } if( pParse->nErr ){ - return SQLITE_ERROR; + /* Prior errors might have left pParse->pWith in a goofy state, so + ** go no further. */ + return 0; + } + if( pFrom->zDatabase!=0 ){ + /* The FROM term contains a schema qualifier (ex: main.t1) and so + ** it cannot possibly be a CTE reference. */ + return 0; + } + if( pFrom->fg.notCte ){ + /* The FROM term is specifically excluded from matching a CTE. + ** (1) It is part of a trigger that used to have zDatabase but had + ** zDatabase removed by sqlite3FixTriggerStep(). + ** (2) This is the first term in the FROM clause of an UPDATE. + */ + return 0; } - pCte = searchWith(pParse->pWith, pFrom, &pWith); if( pCte ){ + sqlite3 *db = pParse->db; Table *pTab; ExprList *pEList; Select *pSel; @@ -134625,6 +138461,7 @@ static int withExpand( int bMayRecursive; /* True if compound joined by UNION [ALL] */ With *pSavedWith; /* Initial value of pParse->pWith */ int iRecTab = -1; /* Cursor for recursive table */ + CteUse *pCteUse; /* If pCte->zCteErr is non-NULL at this point, then this is an illegal ** recursive reference to CTE pCte. Leave an error in pParse and return @@ -134632,21 +138469,44 @@ static int withExpand( ** In this case, proceed. */ if( pCte->zCteErr ){ sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName); - return SQLITE_ERROR; + return 2; } - if( cannotBeFunction(pParse, pFrom) ) return SQLITE_ERROR; + if( cannotBeFunction(pParse, pFrom) ) return 2; assert( pFrom->pTab==0 ); - pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table)); - if( pTab==0 ) return WRC_Abort; + pTab = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTab==0 ) return 2; + pCteUse = pCte->pUse; + if( pCteUse==0 ){ + pCte->pUse = pCteUse = sqlite3DbMallocZero(db, sizeof(pCteUse[0])); + if( pCteUse==0 + || sqlite3ParserAddCleanup(pParse,sqlite3DbFree,pCteUse)==0 + ){ + sqlite3DbFree(db, pTab); + return 2; + } + pCteUse->eM10d = pCte->eM10d; + } + pFrom->pTab = pTab; pTab->nTabRef = 1; pTab->zName = sqlite3DbStrDup(db, pCte->zName); pTab->iPKey = -1; pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid; pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0); - if( db->mallocFailed ) return SQLITE_NOMEM_BKPT; + if( db->mallocFailed ) return 2; + pFrom->pSelect->selFlags |= SF_CopyCte; assert( pFrom->pSelect ); + if( pFrom->fg.isIndexedBy ){ + sqlite3ErrorMsg(pParse, "no such index: \"%s\"", pFrom->u1.zIndexedBy); + return 2; + } + pFrom->fg.isCte = 1; + pFrom->u2.pCteUse = pCteUse; + pCteUse->nUse++; + if( pCteUse->nUse>=2 && pCteUse->eM10d==M10d_Any ){ + pCteUse->eM10d = M10d_Yes; + } /* Check if this is a recursive CTE. */ pRecTerm = pSel = pFrom->pSelect; @@ -134656,7 +138516,7 @@ static int withExpand( SrcList *pSrc = pRecTerm->pSrc; assert( pRecTerm->pPrior!=0 ); for(i=0; inSrc; i++){ - struct SrcList_item *pItem = &pSrc->a[i]; + SrcItem *pItem = &pSrc->a[i]; if( pItem->zDatabase==0 && pItem->zName!=0 && 0==sqlite3StrICmp(pItem->zName, pCte->zName) @@ -134668,7 +138528,7 @@ static int withExpand( sqlite3ErrorMsg(pParse, "multiple references to recursive table: %s", pCte->zName ); - return SQLITE_ERROR; + return 2; } pRecTerm->selFlags |= SF_Recursive; if( iRecTab<0 ) iRecTab = pParse->nTab++; @@ -134683,16 +138543,24 @@ static int withExpand( pSavedWith = pParse->pWith; pParse->pWith = pWith; if( pSel->selFlags & SF_Recursive ){ + int rc; assert( pRecTerm!=0 ); assert( (pRecTerm->selFlags & SF_Recursive)==0 ); assert( pRecTerm->pNext!=0 ); assert( (pRecTerm->pNext->selFlags & SF_Recursive)!=0 ); assert( pRecTerm->pWith==0 ); pRecTerm->pWith = pSel->pWith; - sqlite3WalkSelect(pWalker, pRecTerm); + rc = sqlite3WalkSelect(pWalker, pRecTerm); pRecTerm->pWith = 0; + if( rc ){ + pParse->pWith = pSavedWith; + return 2; + } }else{ - sqlite3WalkSelect(pWalker, pSel); + if( sqlite3WalkSelect(pWalker, pSel) ){ + pParse->pWith = pSavedWith; + return 2; + } } pParse->pWith = pWith; @@ -134704,7 +138572,7 @@ static int withExpand( pCte->zName, pEList->nExpr, pCte->pCols->nExpr ); pParse->pWith = pSavedWith; - return SQLITE_ERROR; + return 2; } pEList = pCte->pCols; } @@ -134720,9 +138588,9 @@ static int withExpand( } pCte->zCteErr = 0; pParse->pWith = pSavedWith; + return 1; /* Success */ } - - return SQLITE_OK; + return 0; /* No match */ } #endif @@ -134735,7 +138603,7 @@ static int withExpand( ** sqlite3SelectExpand() when walking a SELECT tree to resolve table ** names and other FROM clause elements. */ -static void selectPopWith(Walker *pWalker, Select *p){ +SQLITE_PRIVATE void sqlite3SelectPopWith(Walker *pWalker, Select *p){ Parse *pParse = pWalker->pParse; if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){ With *pWith = findRightmost(p)->pWith; @@ -134745,8 +138613,6 @@ static void selectPopWith(Walker *pWalker, Select *p){ } } } -#else -#define selectPopWith 0 #endif /* @@ -134756,7 +138622,7 @@ static void selectPopWith(Walker *pWalker, Select *p){ ** SQLITE_OK is returned. Otherwise, if an OOM error is encountered, ** SQLITE_NOMEM. */ -SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, struct SrcList_item *pFrom){ +SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom){ Select *pSel = pFrom->pSelect; Table *pTab; @@ -134773,7 +138639,13 @@ SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, struct SrcList_item *pFr sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol); pTab->iPKey = -1; pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); - pTab->tabFlags |= TF_Ephemeral; +#ifndef SQLITE_ALLOW_ROWID_IN_VIEW + /* The usual case - do not allow ROWID on a subquery */ + pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid; +#else + pTab->tabFlags |= TF_Ephemeral; /* Legacy compatibility mode */ +#endif + return pParse->nErr ? SQLITE_ERROR : SQLITE_OK; } @@ -134804,10 +138676,10 @@ SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, struct SrcList_item *pFr */ static int selectExpander(Walker *pWalker, Select *p){ Parse *pParse = pWalker->pParse; - int i, j, k; + int i, j, k, rc; SrcList *pTabList; ExprList *pEList; - struct SrcList_item *pFrom; + SrcItem *pFrom; sqlite3 *db = pParse->db; Expr *pE, *pRight, *pExpr; u16 selFlags = p->selFlags; @@ -134827,6 +138699,15 @@ static int selectExpander(Walker *pWalker, Select *p){ } pTabList = p->pSrc; pEList = p->pEList; + if( pParse->pWith && (p->selFlags & SF_View) ){ + if( p->pWith==0 ){ + p->pWith = (With*)sqlite3DbMallocZero(db, sizeof(With)); + if( p->pWith==0 ){ + return WRC_Abort; + } + } + p->pWith->bView = 1; + } sqlite3WithPush(pParse, p->pWith, 0); /* Make sure cursor numbers have been assigned to all entries in @@ -134843,10 +138724,6 @@ static int selectExpander(Walker *pWalker, Select *p){ assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 ); if( pFrom->pTab ) continue; assert( pFrom->fg.isRecursive==0 ); -#ifndef SQLITE_OMIT_CTE - if( withExpand(pWalker, pFrom) ) return WRC_Abort; - if( pFrom->pTab ) {} else -#endif if( pFrom->zName==0 ){ #ifndef SQLITE_OMIT_SUBQUERY Select *pSel = pFrom->pSelect; @@ -134855,6 +138732,12 @@ static int selectExpander(Walker *pWalker, Select *p){ assert( pFrom->pTab==0 ); if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort; if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort; +#endif +#ifndef SQLITE_OMIT_CTE + }else if( (rc = resolveFromTermToCte(pParse, pWalker, pFrom))!=0 ){ + if( rc>1 ) return WRC_Abort; + pTab = pFrom->pTab; + assert( pTab!=0 ); #endif }else{ /* An ordinary table or view name in the FROM clause */ @@ -134872,26 +138755,31 @@ static int selectExpander(Walker *pWalker, Select *p){ return WRC_Abort; } #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) - if( IsVirtual(pTab) || pTab->pSelect ){ + if( !IsOrdinaryTable(pTab) ){ i16 nCol; u8 eCodeOrig = pWalker->eCode; if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort; assert( pFrom->pSelect==0 ); - if( pTab->pSelect && (db->flags & SQLITE_EnableView)==0 ){ - sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited", - pTab->zName); + if( IsView(pTab) ){ + if( (db->flags & SQLITE_EnableView)==0 + && pTab->pSchema!=db->aDb[1].pSchema + ){ + sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited", + pTab->zName); + } + pFrom->pSelect = sqlite3SelectDup(db, pTab->u.view.pSelect, 0); } #ifndef SQLITE_OMIT_VIRTUALTABLE - if( IsVirtual(pTab) + else if( ALWAYS(IsVirtual(pTab)) && pFrom->fg.fromDDL - && ALWAYS(pTab->pVTable!=0) - && pTab->pVTable->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0) + && ALWAYS(pTab->u.vtab.p!=0) + && pTab->u.vtab.p->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0) ){ sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"", pTab->zName); } + assert( SQLITE_VTABRISK_Normal==1 && SQLITE_VTABRISK_High==2 ); #endif - pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0); nCol = pTab->nCol; pTab->nCol = -1; pWalker->eCode = 1; /* Turn on Select.selId renumbering */ @@ -134903,7 +138791,7 @@ static int selectExpander(Walker *pWalker, Select *p){ } /* Locate the index named by the INDEXED BY clause, if any. */ - if( sqlite3IndexedByLookup(pParse, pFrom) ){ + if( pFrom->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pFrom) ){ return WRC_Abort; } } @@ -134991,7 +138879,7 @@ static int selectExpander(Walker *pWalker, Select *p){ zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*"; } for(j=0; jnCol; j++){ - char *zName = pTab->aCol[j].zName; + char *zName = pTab->aCol[j].zCnName; char *zColname; /* The computed column name */ char *zToFree; /* Malloced string that needs to be freed */ Token sColname; /* Computed column name as a token */ @@ -135122,7 +139010,7 @@ static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){ sqlite3WalkSelect(&w, pSelect); } w.xSelectCallback = selectExpander; - w.xSelectCallback2 = selectPopWith; + w.xSelectCallback2 = sqlite3SelectPopWith; w.eCode = 0; sqlite3WalkSelect(&w, pSelect); } @@ -135146,7 +139034,7 @@ static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){ Parse *pParse; int i; SrcList *pTabList; - struct SrcList_item *pFrom; + SrcItem *pFrom; assert( p->selFlags & SF_Resolved ); if( p->selFlags & SF_HasTypeInfo ) return; @@ -135248,15 +139136,17 @@ static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){ for(pFunc=pAggInfo->aFunc, i=0; inFunc; i++, pFunc++){ if( pFunc->iDistinct>=0 ){ Expr *pE = pFunc->pFExpr; - assert( !ExprHasProperty(pE, EP_xIsSelect) ); + assert( ExprUseXList(pE) ); if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){ sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one " "argument"); pFunc->iDistinct = -1; }else{ KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0); - sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0, - (char*)pKeyInfo, P4_KEYINFO); + pFunc->iDistAddr = sqlite3VdbeAddOp4(v, OP_OpenEphemeral, + pFunc->iDistinct, 0, 0, (char*)pKeyInfo, P4_KEYINFO); + ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s(DISTINCT)", + pFunc->pFunc->zName)); } } } @@ -135271,8 +139161,9 @@ static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){ int i; struct AggInfo_func *pF; for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ - ExprList *pList = pF->pFExpr->x.pList; - assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) ); + ExprList *pList; + assert( ExprUseXList(pF->pFExpr) ); + pList = pF->pFExpr->x.pList; sqlite3VdbeAddOp2(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0); sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF); } @@ -135288,7 +139179,12 @@ static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){ ** registers if register regAcc contains 0. The caller will take care ** of setting and clearing regAcc. */ -static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){ +static void updateAccumulator( + Parse *pParse, + int regAcc, + AggInfo *pAggInfo, + int eDistinctType +){ Vdbe *v = pParse->pVdbe; int i; int regHit = 0; @@ -135301,9 +139197,10 @@ static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){ int nArg; int addrNext = 0; int regAgg; - ExprList *pList = pF->pFExpr->x.pList; - assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) ); + ExprList *pList; + assert( ExprUseXList(pF->pFExpr) ); assert( !IsWindowFunc(pF->pFExpr) ); + pList = pF->pFExpr->x.pList; if( ExprHasProperty(pF->pFExpr, EP_WinFunc) ){ Expr *pFilter = pF->pFExpr->y.pWin->pFilter; if( pAggInfo->nAccumulator @@ -135334,13 +139231,12 @@ static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){ nArg = 0; regAgg = 0; } - if( pF->iDistinct>=0 ){ + if( pF->iDistinct>=0 && pList ){ if( addrNext==0 ){ addrNext = sqlite3VdbeMakeLabel(pParse); } - testcase( nArg==0 ); /* Error condition */ - testcase( nArg>1 ); /* Also an error */ - codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg); + pF->iDistinct = codeDistinct(pParse, eDistinctType, + pF->iDistinct, addrNext, pList, regAgg); } if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){ CollSeq *pColl = 0; @@ -135392,7 +139288,7 @@ static void explainSimpleCount( ){ if( pParse->explain==2 ){ int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx))); - sqlite3VdbeExplain(pParse, 0, "SCAN TABLE %s%s%s", + sqlite3VdbeExplain(pParse, 0, "SCAN %s%s%s", pTab->zName, bCover ? " USING COVERING INDEX " : "", bCover ? pIdx->zName : "" @@ -135417,7 +139313,17 @@ static void explainSimpleCount( static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){ if( pExpr->op!=TK_AND ){ Select *pS = pWalker->u.pSelect; - if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) ){ + /* This routine is called before the HAVING clause of the current + ** SELECT is analyzed for aggregates. So if pExpr->pAggInfo is set + ** here, it indicates that the expression is a correlated reference to a + ** column from an outer aggregate query, or an aggregate function that + ** belongs to an outer query. Do not move the expression to the WHERE + ** clause in this obscure case, as doing so may corrupt the outer Select + ** statements AggInfo structure. */ + if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) + && ExprAlwaysFalse(pExpr)==0 + && pExpr->pAggInfo==0 + ){ sqlite3 *db = pWalker->pParse->db; Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1"); if( pNew ){ @@ -135456,7 +139362,7 @@ static void havingToWhere(Parse *pParse, Select *p){ sWalker.u.pSelect = p; sqlite3WalkExpr(&sWalker, p->pHaving); #if SELECTTRACE_ENABLED - if( sWalker.eCode && (sqlite3_unsupported_selecttrace & 0x100)!=0 ){ + if( sWalker.eCode && (sqlite3SelectTrace & 0x100)!=0 ){ SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n")); sqlite3TreeViewSelect(0, p, 0); } @@ -135468,11 +139374,13 @@ static void havingToWhere(Parse *pParse, Select *p){ ** If it is, then return the SrcList_item for the prior view. If it is not, ** then return 0. */ -static struct SrcList_item *isSelfJoinView( +static SrcItem *isSelfJoinView( SrcList *pTabList, /* Search for self-joins in this FROM clause */ - struct SrcList_item *pThis /* Search for prior reference to this subquery */ + SrcItem *pThis /* Search for prior reference to this subquery */ ){ - struct SrcList_item *pItem; + SrcItem *pItem; + assert( pThis->pSelect!=0 ); + if( pThis->pSelect->selFlags & SF_PushDown ) return 0; for(pItem = pTabList->a; pItempSelect==0 ) continue; @@ -135488,9 +139396,7 @@ static struct SrcList_item *isSelfJoinView( ** names in the same FROM clause. */ continue; } - if( sqlite3ExprCompare(0, pThis->pSelect->pWhere, pS1->pWhere, -1) - || sqlite3ExprCompare(0, pThis->pSelect->pHaving, pS1->pHaving, -1) - ){ + if( pItem->pSelect->selFlags & SF_PushDown ){ /* The view was modified by some other optimization such as ** pushDownWhereTerms() */ continue; @@ -135500,6 +139406,15 @@ static struct SrcList_item *isSelfJoinView( return 0; } +/* +** Deallocate a single AggInfo object +*/ +static void agginfoFree(sqlite3 *db, AggInfo *p){ + sqlite3DbFree(db, p->aCol); + sqlite3DbFree(db, p->aFunc); + sqlite3DbFreeNN(db, p); +} + #ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION /* ** Attempt to transform a query of the form @@ -135531,7 +139446,9 @@ static int countOfViewOptimization(Parse *pParse, Select *p){ if( p->pGroupBy ) return 0; pExpr = p->pEList->a[0].pExpr; if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */ + assert( ExprUseUToken(pExpr) ); if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */ + assert( ExprUseXList(pExpr) ); if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */ if( p->pSrc->nSrc!=1 ) return 0; /* One table in FROM */ pSub = p->pSrc->a[0].pSelect; @@ -135578,7 +139495,7 @@ static int countOfViewOptimization(Parse *pParse, Select *p){ p->selFlags &= ~SF_Aggregate; #if SELECTTRACE_ENABLED - if( sqlite3_unsupported_selecttrace & 0x400 ){ + if( sqlite3SelectTrace & 0x400 ){ SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n")); sqlite3TreeViewSelect(0, p, 0); } @@ -135631,7 +139548,7 @@ SQLITE_PRIVATE int sqlite3Select( if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; #if SELECTTRACE_ENABLED SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain)); - if( sqlite3_unsupported_selecttrace & 0x100 ){ + if( sqlite3SelectTrace & 0x100 ){ sqlite3TreeViewSelect(0, p, 0); } #endif @@ -135645,8 +139562,19 @@ SQLITE_PRIVATE int sqlite3Select( pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard || pDest->eDest==SRT_DistQueue || pDest->eDest==SRT_DistFifo ); /* All of these destinations are also able to ignore the ORDER BY clause */ - sqlite3ExprListDelete(db, p->pOrderBy); - p->pOrderBy = 0; + if( p->pOrderBy ){ +#if SELECTTRACE_ENABLED + SELECTTRACE(1,pParse,p, ("dropping superfluous ORDER BY:\n")); + if( sqlite3SelectTrace & 0x100 ){ + sqlite3TreeViewExprList(0, p->pOrderBy, 0, "ORDERBY"); + } +#endif + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3ExprListDelete, + p->pOrderBy); + testcase( pParse->earlyCleanup ); + p->pOrderBy = 0; + } p->selFlags &= ~SF_Distinct; p->selFlags |= SF_NoopOrderBy; } @@ -135656,20 +139584,25 @@ SQLITE_PRIVATE int sqlite3Select( } assert( p->pEList!=0 ); #if SELECTTRACE_ENABLED - if( sqlite3_unsupported_selecttrace & 0x104 ){ + if( sqlite3SelectTrace & 0x104 ){ SELECTTRACE(0x104,pParse,p, ("after name resolution:\n")); sqlite3TreeViewSelect(0, p, 0); } #endif - /* If the SF_UpdateFrom flag is set, then this function is being called + /* If the SF_UFSrcCheck flag is set, then this function is being called ** as part of populating the temp table for an UPDATE...FROM statement. ** In this case, it is an error if the target object (pSrc->a[0]) name - ** or alias is duplicated within FROM clause (pSrc->a[1..n]). */ - if( p->selFlags & SF_UpdateFrom ){ - struct SrcList_item *p0 = &p->pSrc->a[0]; + ** or alias is duplicated within FROM clause (pSrc->a[1..n]). + ** + ** Postgres disallows this case too. The reason is that some other + ** systems handle this case differently, and not all the same way, + ** which is just confusing. To avoid this, we follow PG's lead and + ** disallow it altogether. */ + if( p->selFlags & SF_UFSrcCheck ){ + SrcItem *p0 = &p->pSrc->a[0]; for(i=1; ipSrc->nSrc; i++){ - struct SrcList_item *p1 = &p->pSrc->a[i]; + SrcItem *p1 = &p->pSrc->a[i]; if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){ sqlite3ErrorMsg(pParse, "target object/alias may not appear in FROM clause: %s", @@ -135678,20 +139611,25 @@ SQLITE_PRIVATE int sqlite3Select( goto select_end; } } + + /* Clear the SF_UFSrcCheck flag. The check has already been performed, + ** and leaving this flag set can cause errors if a compound sub-query + ** in p->pSrc is flattened into this query and this function called + ** again as part of compound SELECT processing. */ + p->selFlags &= ~SF_UFSrcCheck; } if( pDest->eDest==SRT_Output ){ - generateColumnNames(pParse, p); + sqlite3GenerateColumnNames(pParse, p); } #ifndef SQLITE_OMIT_WINDOWFUNC - rc = sqlite3WindowRewrite(pParse, p); - if( rc ){ + if( sqlite3WindowRewrite(pParse, p) ){ assert( db->mallocFailed || pParse->nErr>0 ); goto select_end; } #if SELECTTRACE_ENABLED - if( p->pWin && (sqlite3_unsupported_selecttrace & 0x108)!=0 ){ + if( p->pWin && (sqlite3SelectTrace & 0x108)!=0 ){ SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n")); sqlite3TreeViewSelect(0, p, 0); } @@ -135707,7 +139645,7 @@ SQLITE_PRIVATE int sqlite3Select( */ #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) for(i=0; !p->pPrior && inSrc; i++){ - struct SrcList_item *pItem = &pTabList->a[i]; + SrcItem *pItem = &pTabList->a[i]; Select *pSub = pItem->pSelect; Table *pTab = pItem->pTab; @@ -135750,6 +139688,39 @@ SQLITE_PRIVATE int sqlite3Select( if( (pSub->selFlags & SF_Aggregate)!=0 ) continue; assert( pSub->pGroupBy==0 ); + /* If a FROM-clause subquery has an ORDER BY clause that is not + ** really doing anything, then delete it now so that it does not + ** interfere with query flattening. See the discussion at + ** https://sqlite.org/forum/forumpost/2d76f2bcf65d256a + ** + ** Beware of these cases where the ORDER BY clause may not be safely + ** omitted: + ** + ** (1) There is also a LIMIT clause + ** (2) The subquery was added to help with window-function + ** processing + ** (3) The subquery is in the FROM clause of an UPDATE + ** (4) The outer query uses an aggregate function other than + ** the built-in count(), min(), or max(). + ** (5) The ORDER BY isn't going to accomplish anything because + ** one of: + ** (a) The outer query has a different ORDER BY clause + ** (b) The subquery is part of a join + ** See forum post 062d576715d277c8 + */ + if( pSub->pOrderBy!=0 + && (p->pOrderBy!=0 || pTabList->nSrc>1) /* Condition (5) */ + && pSub->pLimit==0 /* Condition (1) */ + && (pSub->selFlags & SF_OrderByReqd)==0 /* Condition (2) */ + && (p->selFlags & SF_OrderByReqd)==0 /* Condition (3) and (4) */ + && OptimizationEnabled(db, SQLITE_OmitOrderBy) + ){ + SELECTTRACE(0x100,pParse,p, + ("omit superfluous ORDER BY on %r FROM-clause subquery\n",i+1)); + sqlite3ExprListDelete(db, pSub->pOrderBy); + pSub->pOrderBy = 0; + } + /* If the outer query contains a "complex" result set (that is, ** if the result set of the outer query uses functions or subqueries) ** and if the subquery contains an ORDER BY clause and if @@ -135798,7 +139769,7 @@ SQLITE_PRIVATE int sqlite3Select( rc = multiSelect(pParse, p, pDest); #if SELECTTRACE_ENABLED SELECTTRACE(0x1,pParse,p,("end compound-select processing\n")); - if( (sqlite3_unsupported_selecttrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){ + if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){ sqlite3TreeViewSelect(0, p, 0); } #endif @@ -135812,12 +139783,13 @@ SQLITE_PRIVATE int sqlite3Select( ** as the equivalent optimization will be handled by query planner in ** sqlite3WhereBegin(). */ - if( pTabList->nSrc>1 + if( p->pWhere!=0 + && p->pWhere->op==TK_AND && OptimizationEnabled(db, SQLITE_PropagateConst) && propagateConstants(pParse, p) ){ #if SELECTTRACE_ENABLED - if( sqlite3_unsupported_selecttrace & 0x100 ){ + if( sqlite3SelectTrace & 0x100 ){ SELECTTRACE(0x100,pParse,p,("After constant propagation:\n")); sqlite3TreeViewSelect(0, p, 0); } @@ -135841,7 +139813,8 @@ SQLITE_PRIVATE int sqlite3Select( ** (2) Generate code for all sub-queries */ for(i=0; inSrc; i++){ - struct SrcList_item *pItem = &pTabList->a[i]; + SrcItem *pItem = &pTabList->a[i]; + SrcItem *pPrior; SelectDest dest; Select *pSub; #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) @@ -135874,19 +139847,8 @@ SQLITE_PRIVATE int sqlite3Select( pSub = pItem->pSelect; if( pSub==0 ) continue; - /* The code for a subquery should only be generated once, though it is - ** technically harmless for it to be generated multiple times. The - ** following assert() will detect if something changes to cause - ** the same subquery to be coded multiple times, as a signal to the - ** developers to try to optimize the situation. - ** - ** Update 2019-07-24: - ** See ticket https://sqlite.org/src/tktview/c52b09c7f38903b1311cec40. - ** The dbsqlfuzz fuzzer found a case where the same subquery gets - ** coded twice. So this assert() now becomes a testcase(). It should - ** be very rare, though. - */ - testcase( pItem->addrFillSub!=0 ); + /* The code for a subquery should only be generated once. */ + assert( pItem->addrFillSub==0 ); /* Increment Parse.nHeight by the height of the largest expression ** tree referred to by this, the parent select. The child select @@ -135901,16 +139863,19 @@ SQLITE_PRIVATE int sqlite3Select( ** inside the subquery. This can help the subquery to run more efficiently. */ if( OptimizationEnabled(db, SQLITE_PushDown) + && (pItem->fg.isCte==0 + || (pItem->u2.pCteUse->eM10d!=M10d_Yes && pItem->u2.pCteUse->nUse<2)) && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor, (pItem->fg.jointype & JT_OUTER)!=0) ){ #if SELECTTRACE_ENABLED - if( sqlite3_unsupported_selecttrace & 0x100 ){ + if( sqlite3SelectTrace & 0x100 ){ SELECTTRACE(0x100,pParse,p, ("After WHERE-clause push-down into subquery %d:\n", pSub->selId)); sqlite3TreeViewSelect(0, p, 0); } #endif + assert( pItem->pSelect && (pItem->pSelect->selFlags & SF_PushDown)!=0 ); }else{ SELECTTRACE(0x100,pParse,p,("Push-down not possible\n")); } @@ -135920,16 +139885,18 @@ SQLITE_PRIVATE int sqlite3Select( /* Generate code to implement the subquery ** - ** The subquery is implemented as a co-routine if the subquery is - ** guaranteed to be the outer loop (so that it does not need to be - ** computed more than once) + ** The subquery is implemented as a co-routine if: + ** (1) the subquery is guaranteed to be the outer loop (so that + ** it does not need to be computed more than once), and + ** (2) the subquery is not a CTE that should be materialized ** - ** TODO: Are there other reasons beside (1) to use a co-routine + ** TODO: Are there other reasons beside (1) and (2) to use a co-routine ** implementation? */ if( i==0 && (pTabList->nSrc==1 || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0) /* (1) */ + && (pItem->fg.isCte==0 || pItem->u2.pCteUse->eM10d!=M10d_Yes) /* (2) */ ){ /* Implement a co-routine that will return a single row of the result ** set on each invocation. @@ -135938,10 +139905,10 @@ SQLITE_PRIVATE int sqlite3Select( pItem->regReturn = ++pParse->nMem; sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop); - VdbeComment((v, "%s", pItem->pTab->zName)); + VdbeComment((v, "%!S", pItem)); pItem->addrFillSub = addrTop; sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn); - ExplainQueryPlan((pParse, 1, "CO-ROUTINE %u", pSub->selId)); + ExplainQueryPlan((pParse, 1, "CO-ROUTINE %!S", pItem)); sqlite3Select(pParse, pSub, &dest); pItem->pTab->nRowLogEst = pSub->nSelectRow; pItem->fg.viaCoroutine = 1; @@ -135949,18 +139916,34 @@ SQLITE_PRIVATE int sqlite3Select( sqlite3VdbeEndCoroutine(v, pItem->regReturn); sqlite3VdbeJumpHere(v, addrTop-1); sqlite3ClearTempRegCache(pParse); - }else{ - /* Generate a subroutine that will fill an ephemeral table with - ** the content of this subquery. pItem->addrFillSub will point - ** to the address of the generated subroutine. pItem->regReturn - ** is a register allocated to hold the subroutine return address - */ + }else if( pItem->fg.isCte && pItem->u2.pCteUse->addrM9e>0 ){ + /* This is a CTE for which materialization code has already been + ** generated. Invoke the subroutine to compute the materialization, + ** the make the pItem->iCursor be a copy of the ephemerial table that + ** holds the result of the materialization. */ + CteUse *pCteUse = pItem->u2.pCteUse; + sqlite3VdbeAddOp2(v, OP_Gosub, pCteUse->regRtn, pCteUse->addrM9e); + if( pItem->iCursor!=pCteUse->iCur ){ + sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pCteUse->iCur); + VdbeComment((v, "%!S", pItem)); + } + pSub->nSelectRow = pCteUse->nRowEst; + }else if( (pPrior = isSelfJoinView(pTabList, pItem))!=0 ){ + /* This view has already been materialized by a prior entry in + ** this same FROM clause. Reuse it. */ + if( pPrior->addrFillSub ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub); + } + sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor); + pSub->nSelectRow = pPrior->pSelect->nSelectRow; + }else{ + /* Materialize the view. If the view is not correlated, generate a + ** subroutine to do the materialization so that subsequent uses of + ** the same view can reuse the materialization. */ int topAddr; int onceAddr = 0; int retAddr; - struct SrcList_item *pPrior; - testcase( pItem->addrFillSub==0 ); /* Ticket c52b09c7f38903b1311 */ pItem->regReturn = ++pParse->nMem; topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn); pItem->addrFillSub = topAddr+1; @@ -135969,26 +139952,26 @@ SQLITE_PRIVATE int sqlite3Select( ** a trigger, then we only need to compute the value of the subquery ** once. */ onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); - VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName)); + VdbeComment((v, "materialize %!S", pItem)); }else{ - VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName)); - } - pPrior = isSelfJoinView(pTabList, pItem); - if( pPrior ){ - sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor); - assert( pPrior->pSelect!=0 ); - pSub->nSelectRow = pPrior->pSelect->nSelectRow; - }else{ - sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor); - ExplainQueryPlan((pParse, 1, "MATERIALIZE %u", pSub->selId)); - sqlite3Select(pParse, pSub, &dest); + VdbeNoopComment((v, "materialize %!S", pItem)); } + sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor); + ExplainQueryPlan((pParse, 1, "MATERIALIZE %!S", pItem)); + sqlite3Select(pParse, pSub, &dest); pItem->pTab->nRowLogEst = pSub->nSelectRow; if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr); retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn); - VdbeComment((v, "end %s", pItem->pTab->zName)); + VdbeComment((v, "end %!S", pItem)); sqlite3VdbeChangeP1(v, topAddr, retAddr); sqlite3ClearTempRegCache(pParse); + if( pItem->fg.isCte && pItem->fg.isCorrelated==0 ){ + CteUse *pCteUse = pItem->u2.pCteUse; + pCteUse->addrM9e = pItem->addrFillSub; + pCteUse->regRtn = pItem->regReturn; + pCteUse->iCur = pItem->iCursor; + pCteUse->nRowEst = pSub->nSelectRow; + } } if( db->mallocFailed ) goto select_end; pParse->nHeight -= sqlite3SelectExprHeight(p); @@ -136005,7 +139988,7 @@ SQLITE_PRIVATE int sqlite3Select( sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0; #if SELECTTRACE_ENABLED - if( sqlite3_unsupported_selecttrace & 0x400 ){ + if( sqlite3SelectTrace & 0x400 ){ SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n")); sqlite3TreeViewSelect(0, p, 0); } @@ -136041,7 +140024,7 @@ SQLITE_PRIVATE int sqlite3Select( assert( sDistinct.isTnct ); #if SELECTTRACE_ENABLED - if( sqlite3_unsupported_selecttrace & 0x400 ){ + if( sqlite3SelectTrace & 0x400 ){ SELECTTRACE(0x400,pParse,p,("Transform DISTINCT into GROUP BY:\n")); sqlite3TreeViewSelect(0, p, 0); } @@ -136133,6 +140116,7 @@ SQLITE_PRIVATE int sqlite3Select( sSort.pOrderBy = 0; } } + SELECTTRACE(1,pParse,p,("WhereBegin returns\n")); /* If sorting index that was created by a prior OP_OpenEphemeral ** instruction ended up not being needed, then change the OP_OpenEphemeral @@ -136171,6 +140155,7 @@ SQLITE_PRIVATE int sqlite3Select( /* End the database scan loop. */ + SELECTTRACE(1,pParse,p,("WhereEnd\n")); sqlite3WhereEnd(pWInfo); } }else{ @@ -136241,11 +140226,14 @@ SQLITE_PRIVATE int sqlite3Select( ** SELECT statement. */ pAggInfo = sqlite3DbMallocZero(db, sizeof(*pAggInfo) ); - if( pAggInfo==0 ){ + if( pAggInfo ){ + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))agginfoFree, pAggInfo); + testcase( pParse->earlyCleanup ); + } + if( db->mallocFailed ){ goto select_end; } - pAggInfo->pNext = pParse->pAggList; - pParse->pAggList = pAggInfo; pAggInfo->selId = p->selId; memset(&sNC, 0, sizeof(sNC)); sNC.pParse = pParse; @@ -136275,7 +140263,7 @@ SQLITE_PRIVATE int sqlite3Select( } for(i=0; inFunc; i++){ Expr *pExpr = pAggInfo->aFunc[i].pFExpr; - assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + assert( ExprUseXList(pExpr) ); sNC.ncFlags |= NC_InAggFunc; sqlite3ExprAnalyzeAggList(&sNC, pExpr->x.pList); #ifndef SQLITE_OMIT_WINDOWFUNC @@ -136289,10 +140277,14 @@ SQLITE_PRIVATE int sqlite3Select( pAggInfo->mxReg = pParse->nMem; if( db->mallocFailed ) goto select_end; #if SELECTTRACE_ENABLED - if( sqlite3_unsupported_selecttrace & 0x400 ){ + if( sqlite3SelectTrace & 0x400 ){ int ii; SELECTTRACE(0x400,pParse,p,("After aggregate analysis %p:\n", pAggInfo)); sqlite3TreeViewSelect(0, p, 0); + if( minMaxFlag ){ + sqlite3DebugPrintf("MIN/MAX Optimization (0x%02x) adds:\n", minMaxFlag); + sqlite3TreeViewExprList(0, pMinMaxOrderBy, 0, "ORDERBY"); + } for(ii=0; iinColumn; ii++){ sqlite3DebugPrintf("agg-column[%d] iMem=%d\n", ii, pAggInfo->aCol[ii].iMem); @@ -136320,6 +140312,22 @@ SQLITE_PRIVATE int sqlite3Select( int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */ int addrReset; /* Subroutine for resetting the accumulator */ int regReset; /* Return address register for reset subroutine */ + ExprList *pDistinct = 0; + u16 distFlag = 0; + int eDist = WHERE_DISTINCT_NOOP; + + if( pAggInfo->nFunc==1 + && pAggInfo->aFunc[0].iDistinct>=0 + && ALWAYS(pAggInfo->aFunc[0].pFExpr!=0) + && ALWAYS(ExprUseXList(pAggInfo->aFunc[0].pFExpr)) + && pAggInfo->aFunc[0].pFExpr->x.pList!=0 + ){ + Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr; + pExpr = sqlite3ExprDup(db, pExpr, 0); + pDistinct = sqlite3ExprListDup(db, pGroupBy, 0); + pDistinct = sqlite3ExprListAppend(pParse, pDistinct, pExpr); + distFlag = pDistinct ? (WHERE_WANT_DISTINCT|WHERE_AGG_DISTINCT) : 0; + } /* If there is a GROUP BY clause we might need a sorting index to ** implement it. Allocate that sorting index now. If it turns out @@ -136356,10 +140364,15 @@ SQLITE_PRIVATE int sqlite3Select( */ sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); SELECTTRACE(1,pParse,p,("WhereBegin\n")); - pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0, - WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0), 0 + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, pDistinct, + WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0) | distFlag, 0 ); - if( pWInfo==0 ) goto select_end; + if( pWInfo==0 ){ + sqlite3ExprListDelete(db, pDistinct); + goto select_end; + } + eDist = sqlite3WhereIsDistinct(pWInfo); + SELECTTRACE(1,pParse,p,("WhereBegin returns\n")); if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){ /* The optimizer is able to deliver rows in group by order so ** we do not have to sort. The OP_OpenEphemeral table will be @@ -136408,6 +140421,7 @@ SQLITE_PRIVATE int sqlite3Select( sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord); sqlite3ReleaseTempReg(pParse, regRecord); sqlite3ReleaseTempRange(pParse, regBase, nCol); + SELECTTRACE(1,pParse,p,("WhereEnd\n")); sqlite3WhereEnd(pWInfo); pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++; sortOut = sqlite3GetTempReg(pParse); @@ -136475,19 +140489,21 @@ SQLITE_PRIVATE int sqlite3Select( ** the current row */ sqlite3VdbeJumpHere(v, addr1); - updateAccumulator(pParse, iUseFlag, pAggInfo); + updateAccumulator(pParse, iUseFlag, pAggInfo, eDist); sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag); VdbeComment((v, "indicate data in accumulator")); /* End of the loop */ if( groupBySort ){ - sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx, addrTopOfLoop); + sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx,addrTopOfLoop); VdbeCoverage(v); }else{ + SELECTTRACE(1,pParse,p,("WhereEnd\n")); sqlite3WhereEnd(pWInfo); sqlite3VdbeChangeToNoop(v, addrSortingIdx); } + sqlite3ExprListDelete(db, pDistinct); /* Output the final row of result */ @@ -136531,6 +140547,10 @@ SQLITE_PRIVATE int sqlite3Select( VdbeComment((v, "indicate accumulator empty")); sqlite3VdbeAddOp1(v, OP_Return, regReset); + if( eDist!=WHERE_DISTINCT_NOOP ){ + struct AggInfo_func *pF = &pAggInfo->aFunc[0]; + fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr); + } } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */ else { Table *pTab; @@ -136594,7 +140614,9 @@ SQLITE_PRIVATE int sqlite3Select( explainSimpleCount(pParse, pTab, pBest); }else{ int regAcc = 0; /* "populate accumulators" flag */ - int addrSkip; + ExprList *pDistinct = 0; + u16 distFlag = 0; + int eDist; /* If there are accumulator registers but no min() or max() functions ** without FILTER clauses, allocate register regAcc. Register regAcc @@ -136618,6 +140640,10 @@ SQLITE_PRIVATE int sqlite3Select( regAcc = ++pParse->nMem; sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc); } + }else if( pAggInfo->nFunc==1 && pAggInfo->aFunc[0].iDistinct>=0 ){ + assert( ExprUseXList(pAggInfo->aFunc[0].pFExpr) ); + pDistinct = pAggInfo->aFunc[0].pFExpr->x.pList; + distFlag = pDistinct ? (WHERE_WANT_DISTINCT|WHERE_AGG_DISTINCT) : 0; } /* This case runs if the aggregate has no GROUP BY clause. The @@ -136637,16 +140663,23 @@ SQLITE_PRIVATE int sqlite3Select( SELECTTRACE(1,pParse,p,("WhereBegin\n")); pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy, - 0, minMaxFlag, 0); + pDistinct, minMaxFlag|distFlag, 0); if( pWInfo==0 ){ goto select_end; } - updateAccumulator(pParse, regAcc, pAggInfo); + SELECTTRACE(1,pParse,p,("WhereBegin returns\n")); + eDist = sqlite3WhereIsDistinct(pWInfo); + updateAccumulator(pParse, regAcc, pAggInfo, eDist); + if( eDist!=WHERE_DISTINCT_NOOP ){ + struct AggInfo_func *pF = &pAggInfo->aFunc[0]; + fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr); + } + if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc); - addrSkip = sqlite3WhereOrderByLimitOptLabel(pWInfo); - if( addrSkip!=sqlite3WhereContinueLabel(pWInfo) ){ - sqlite3VdbeGoto(v, addrSkip); + if( minMaxFlag ){ + sqlite3WhereMinMaxOptEarlyOut(v, pWInfo); } + SELECTTRACE(1,pParse,p,("WhereEnd\n")); sqlite3WhereEnd(pWInfo); finalizeAggFunctions(pParse, pAggInfo); } @@ -136686,20 +140719,20 @@ SQLITE_PRIVATE int sqlite3Select( ** successful coding of the SELECT. */ select_end: + assert( db->mallocFailed==0 || db->mallocFailed==1 ); + pParse->nErr += db->mallocFailed; sqlite3ExprListDelete(db, pMinMaxOrderBy); #ifdef SQLITE_DEBUG if( pAggInfo && !db->mallocFailed ){ for(i=0; inColumn; i++){ Expr *pExpr = pAggInfo->aCol[i].pCExpr; - assert( pExpr!=0 || db->mallocFailed ); - if( pExpr==0 ) continue; + assert( pExpr!=0 ); assert( pExpr->pAggInfo==pAggInfo ); assert( pExpr->iAgg==i ); } for(i=0; inFunc; i++){ Expr *pExpr = pAggInfo->aFunc[i].pFExpr; - assert( pExpr!=0 || db->mallocFailed ); - if( pExpr==0 ) continue; + assert( pExpr!=0 ); assert( pExpr->pAggInfo==pAggInfo ); assert( pExpr->iAgg==i ); } @@ -136708,7 +140741,7 @@ SQLITE_PRIVATE int sqlite3Select( #if SELECTTRACE_ENABLED SELECTTRACE(0x1,pParse,p,("end processing\n")); - if( (sqlite3_unsupported_selecttrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){ + if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){ sqlite3TreeViewSelect(0, p, 0); } #endif @@ -136969,28 +141002,51 @@ SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerS ** pTab as well as the triggers lised in pTab->pTrigger. */ SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){ - Schema * const pTmpSchema = pParse->db->aDb[1].pSchema; - Trigger *pList = 0; /* List of triggers to return */ + Schema *pTmpSchema; /* Schema of the pTab table */ + Trigger *pList; /* List of triggers to return */ + HashElem *p; /* Loop variable for TEMP triggers */ if( pParse->disableTriggers ){ return 0; } - - if( pTmpSchema!=pTab->pSchema ){ - HashElem *p; - assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) ); - for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){ - Trigger *pTrig = (Trigger *)sqliteHashData(p); - if( pTrig->pTabSchema==pTab->pSchema - && 0==sqlite3StrICmp(pTrig->table, pTab->zName) - ){ - pTrig->pNext = (pList ? pList : pTab->pTrigger); - pList = pTrig; - } + pTmpSchema = pParse->db->aDb[1].pSchema; + p = sqliteHashFirst(&pTmpSchema->trigHash); + pList = pTab->pTrigger; + while( p ){ + Trigger *pTrig = (Trigger *)sqliteHashData(p); + if( pTrig->pTabSchema==pTab->pSchema + && pTrig->table + && 0==sqlite3StrICmp(pTrig->table, pTab->zName) + && pTrig->pTabSchema!=pTmpSchema + ){ + pTrig->pNext = pList; + pList = pTrig; + }else if( pTrig->op==TK_RETURNING +#ifndef SQLITE_OMIT_VIRTUALTABLE + && pParse->db->pVtabCtx==0 +#endif + ){ + assert( pParse->bReturning ); + assert( &(pParse->u1.pReturning->retTrig) == pTrig ); + pTrig->table = pTab->zName; + pTrig->pTabSchema = pTab->pSchema; + pTrig->pNext = pList; + pList = pTrig; } + p = sqliteHashNext(p); } - - return (pList ? pList : pTab->pTrigger); +#if 0 + if( pList ){ + Trigger *pX; + printf("Triggers for %s:", pTab->zName); + for(pX=pList; pX; pX=pX->pNext){ + printf(" %s", pX->zName); + } + printf("\n"); + fflush(stdout); + } +#endif + return pList; } /* @@ -137117,14 +141173,14 @@ SQLITE_PRIVATE void sqlite3BeginTrigger( /* INSTEAD of triggers are only for views and views only support INSTEAD ** of triggers. */ - if( pTab->pSelect && tr_tm!=TK_INSTEAD ){ + if( IsView(pTab) && tr_tm!=TK_INSTEAD ){ sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S", - (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0); + (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName->a); goto trigger_orphan_error; } - if( !pTab->pSelect && tr_tm==TK_INSTEAD ){ + if( !IsView(pTab) && tr_tm==TK_INSTEAD ){ sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF" - " trigger on table: %S", pTableName, 0); + " trigger on table: %S", pTableName->a); goto trigger_orphan_error; } @@ -137259,14 +141315,14 @@ SQLITE_PRIVATE void sqlite3FinishTrigger( z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n); testcase( z==0 ); sqlite3NestedParse(pParse, - "INSERT INTO %Q." DFLT_SCHEMA_TABLE + "INSERT INTO %Q." LEGACY_SCHEMA_TABLE " VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')", db->aDb[iDb].zDbSName, zName, pTrig->table, z); sqlite3DbFree(db, z); sqlite3ChangeCookie(pParse, iDb); sqlite3VdbeAddParseSchemaOp(v, iDb, - sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName)); + sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName), 0); } if( db->init.busy ){ @@ -137479,7 +141535,7 @@ SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep( ** Recursively delete a Trigger structure */ SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){ - if( pTrigger==0 ) return; + if( pTrigger==0 || pTrigger->bReturning ) return; sqlite3DeleteTriggerStep(db, pTrigger->step_list); sqlite3DbFree(db, pTrigger->zName); sqlite3DbFree(db, pTrigger->table); @@ -137521,7 +141577,7 @@ SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr) } if( !pTrigger ){ if( !noErr ){ - sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0); + sqlite3ErrorMsg(pParse, "no such trigger: %S", pName->a); }else{ sqlite3CodeVerifyNamedSchema(pParse, zDb); } @@ -137573,7 +141629,7 @@ SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){ */ if( (v = sqlite3GetVdbe(pParse))!=0 ){ sqlite3NestedParse(pParse, - "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'", + "DELETE FROM %Q." LEGACY_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'", db->aDb[iDb].zDbSName, pTrigger->zName ); sqlite3ChangeCookie(pParse, iDb); @@ -137644,15 +141700,53 @@ SQLITE_PRIVATE Trigger *sqlite3TriggersExist( Trigger *pList = 0; Trigger *p; - if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){ - pList = sqlite3TriggerList(pParse, pTab); - } - assert( pList==0 || IsVirtual(pTab)==0 ); - for(p=pList; p; p=p->pNext){ - if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){ - mask |= p->tr_tm; + pList = sqlite3TriggerList(pParse, pTab); + assert( pList==0 || IsVirtual(pTab)==0 + || (pList->bReturning && pList->pNext==0) ); + if( pList!=0 ){ + p = pList; + if( (pParse->db->flags & SQLITE_EnableTrigger)==0 + && pTab->pTrigger!=0 + ){ + /* The SQLITE_DBCONFIG_ENABLE_TRIGGER setting is off. That means that + ** only TEMP triggers are allowed. Truncate the pList so that it + ** includes only TEMP triggers */ + if( pList==pTab->pTrigger ){ + pList = 0; + goto exit_triggers_exist; + } + while( ALWAYS(p->pNext) && p->pNext!=pTab->pTrigger ) p = p->pNext; + p->pNext = 0; + p = pList; } + do{ + if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){ + mask |= p->tr_tm; + }else if( p->op==TK_RETURNING ){ + /* The first time a RETURNING trigger is seen, the "op" value tells + ** us what time of trigger it should be. */ + assert( sqlite3IsToplevel(pParse) ); + p->op = op; + if( IsVirtual(pTab) ){ + if( op!=TK_INSERT ){ + sqlite3ErrorMsg(pParse, + "%s RETURNING is not available on virtual tables", + op==TK_DELETE ? "DELETE" : "UPDATE"); + } + p->tr_tm = TRIGGER_BEFORE; + }else{ + p->tr_tm = TRIGGER_AFTER; + } + mask |= p->tr_tm; + }else if( p->bReturning && p->op==TK_INSERT && op==TK_UPDATE + && sqlite3IsToplevel(pParse) ){ + /* Also fire a RETURNING trigger for an UPSERT */ + mask |= p->tr_tm; + } + p = p->pNext; + }while( p ); } +exit_triggers_exist: if( pMask ){ *pMask = mask; } @@ -137695,6 +141789,138 @@ SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc( return pSrc; } +/* +** Return true if the pExpr term from the RETURNING clause argument +** list is of the form "*". Raise an error if the terms if of the +** form "table.*". +*/ +static int isAsteriskTerm( + Parse *pParse, /* Parsing context */ + Expr *pTerm /* A term in the RETURNING clause */ +){ + assert( pTerm!=0 ); + if( pTerm->op==TK_ASTERISK ) return 1; + if( pTerm->op!=TK_DOT ) return 0; + assert( pTerm->pRight!=0 ); + assert( pTerm->pLeft!=0 ); + if( pTerm->pRight->op!=TK_ASTERISK ) return 0; + sqlite3ErrorMsg(pParse, "RETURNING may not use \"TABLE.*\" wildcards"); + return 1; +} + +/* The input list pList is the list of result set terms from a RETURNING +** clause. The table that we are returning from is pTab. +** +** This routine makes a copy of the pList, and at the same time expands +** any "*" wildcards to be the complete set of columns from pTab. +*/ +static ExprList *sqlite3ExpandReturning( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* The arguments to RETURNING */ + Table *pTab /* The table being updated */ +){ + ExprList *pNew = 0; + sqlite3 *db = pParse->db; + int i; + + for(i=0; inExpr; i++){ + Expr *pOldExpr = pList->a[i].pExpr; + if( NEVER(pOldExpr==0) ) continue; + if( isAsteriskTerm(pParse, pOldExpr) ){ + int jj; + for(jj=0; jjnCol; jj++){ + Expr *pNewExpr; + if( IsHiddenColumn(pTab->aCol+jj) ) continue; + pNewExpr = sqlite3Expr(db, TK_ID, pTab->aCol[jj].zCnName); + pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr); + if( !db->mallocFailed ){ + struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1]; + pItem->zEName = sqlite3DbStrDup(db, pTab->aCol[jj].zCnName); + pItem->eEName = ENAME_NAME; + } + } + }else{ + Expr *pNewExpr = sqlite3ExprDup(db, pOldExpr, 0); + pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr); + if( !db->mallocFailed && ALWAYS(pList->a[i].zEName!=0) ){ + struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1]; + pItem->zEName = sqlite3DbStrDup(db, pList->a[i].zEName); + pItem->eEName = pList->a[i].eEName; + } + } + } + return pNew; +} + +/* +** Generate code for the RETURNING trigger. Unlike other triggers +** that invoke a subprogram in the bytecode, the code for RETURNING +** is generated in-line. +*/ +static void codeReturningTrigger( + Parse *pParse, /* Parse context */ + Trigger *pTrigger, /* The trigger step that defines the RETURNING */ + Table *pTab, /* The table to code triggers from */ + int regIn /* The first in an array of registers */ +){ + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + ExprList *pNew; + Returning *pReturning; + Select sSelect; + SrcList sFrom; + + assert( v!=0 ); + assert( pParse->bReturning ); + pReturning = pParse->u1.pReturning; + assert( pTrigger == &(pReturning->retTrig) ); + memset(&sSelect, 0, sizeof(sSelect)); + memset(&sFrom, 0, sizeof(sFrom)); + sSelect.pEList = sqlite3ExprListDup(db, pReturning->pReturnEL, 0); + sSelect.pSrc = &sFrom; + sFrom.nSrc = 1; + sFrom.a[0].pTab = pTab; + sFrom.a[0].iCursor = -1; + sqlite3SelectPrep(pParse, &sSelect, 0); + if( db->mallocFailed==0 && pParse->nErr==0 ){ + sqlite3GenerateColumnNames(pParse, &sSelect); + } + sqlite3ExprListDelete(db, sSelect.pEList); + pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab); + if( pNew ){ + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + if( pReturning->nRetCol==0 ){ + pReturning->nRetCol = pNew->nExpr; + pReturning->iRetCur = pParse->nTab++; + } + sNC.pParse = pParse; + sNC.uNC.iBaseReg = regIn; + sNC.ncFlags = NC_UBaseReg; + pParse->eTriggerOp = pTrigger->op; + pParse->pTriggerTab = pTab; + if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK ){ + int i; + int nCol = pNew->nExpr; + int reg = pParse->nMem+1; + pParse->nMem += nCol+2; + pReturning->iRetReg = reg; + for(i=0; ia[i].pExpr; + sqlite3ExprCodeFactorable(pParse, pCol, reg+i); + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, i, reg+i); + sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1); + sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1); + } + sqlite3ExprListDelete(db, pNew); + pParse->eTriggerOp = 0; + pParse->pTriggerTab = 0; + } +} + + + /* ** Generate VDBE code for the statements inside the body of a single ** trigger. @@ -137744,6 +141970,7 @@ static int codeTriggerProgram( sqlite3ExprDup(db, pStep->pWhere, 0), pParse->eOrconf, 0, 0, 0 ); + sqlite3VdbeAddOp0(v, OP_ResetCount); break; } case TK_INSERT: { @@ -137754,6 +141981,7 @@ static int codeTriggerProgram( pParse->eOrconf, sqlite3UpsertDup(db, pStep->pUpsert) ); + sqlite3VdbeAddOp0(v, OP_ResetCount); break; } case TK_DELETE: { @@ -137761,6 +141989,7 @@ static int codeTriggerProgram( sqlite3TriggerStepSrc(pParse, pStep), sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0 ); + sqlite3VdbeAddOp0(v, OP_ResetCount); break; } default: assert( pStep->op==TK_SELECT ); { @@ -137772,9 +142001,6 @@ static int codeTriggerProgram( break; } } - if( pStep->op!=TK_SELECT ){ - sqlite3VdbeAddOp0(v, OP_ResetCount); - } } return 0; @@ -137890,8 +142116,8 @@ static TriggerPrg *codeRowTrigger( ** OP_Halt inserted at the end of the program. */ if( pTrigger->pWhen ){ pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0); - if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen) - && db->mallocFailed==0 + if( db->mallocFailed==0 + && SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen) ){ iEndTrigger = sqlite3VdbeMakeLabel(pSubParse); sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL); @@ -137921,7 +142147,6 @@ static TriggerPrg *codeRowTrigger( sqlite3VdbeDelete(v); } - assert( !pSubParse->pAinc && !pSubParse->pZombieTab ); assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg ); sqlite3ParserReset(pSubParse); sqlite3StackFree(db, pSubParse); @@ -138023,7 +142248,7 @@ SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect( ** ... ... ** reg+N OLD.* value of right-most column of pTab ** reg+N+1 NEW.rowid -** reg+N+2 OLD.* value of left-most column of pTab +** reg+N+2 NEW.* value of left-most column of pTab ** ... ... ** reg+N+N+1 NEW.* value of right-most column of pTab ** @@ -138068,12 +142293,20 @@ SQLITE_PRIVATE void sqlite3CodeRowTrigger( assert( p->pSchema==p->pTabSchema || p->pSchema==pParse->db->aDb[1].pSchema ); - /* Determine whether we should code this trigger */ - if( p->op==op + /* Determine whether we should code this trigger. One of two choices: + ** 1. The trigger is an exact match to the current DML statement + ** 2. This is a RETURNING trigger for INSERT but we are currently + ** doing the UPDATE part of an UPSERT. + */ + if( (p->op==op || (p->bReturning && p->op==TK_INSERT && op==TK_UPDATE)) && p->tr_tm==tr_tm && checkColumnOverlap(p->pColumns, pChanges) ){ - sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump); + if( !p->bReturning ){ + sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump); + }else if( sqlite3IsToplevel(pParse) ){ + codeReturningTrigger(pParse, p, pTab, reg); + } } } } @@ -138118,13 +142351,18 @@ SQLITE_PRIVATE u32 sqlite3TriggerColmask( assert( isNew==1 || isNew==0 ); for(p=pTrigger; p; p=p->pNext){ - if( p->op==op && (tr_tm&p->tr_tm) + if( p->op==op + && (tr_tm&p->tr_tm) && checkColumnOverlap(p->pColumns,pChanges) ){ - TriggerPrg *pPrg; - pPrg = getRowTrigger(pParse, p, pTab, orconf); - if( pPrg ){ - mask |= pPrg->aColmask[isNew]; + if( p->bReturning ){ + mask = 0xffffffff; + }else{ + TriggerPrg *pPrg; + pPrg = getRowTrigger(pParse, p, pTab, orconf); + if( pPrg ){ + mask |= pPrg->aColmask[isNew]; + } } } } @@ -138198,13 +142436,14 @@ static void updateVirtualTable( */ SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){ assert( pTab!=0 ); - if( !pTab->pSelect ){ + if( !IsView(pTab) ){ sqlite3_value *pValue = 0; u8 enc = ENC(sqlite3VdbeDb(v)); Column *pCol = &pTab->aCol[i]; - VdbeComment((v, "%s.%s", pTab->zName, pCol->zName)); + VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName)); assert( inCol ); - sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc, + sqlite3ValueFromExpr(sqlite3VdbeDb(v), + sqlite3ColumnExpr(pTab,pCol), enc, pCol->affinity, &pValue); if( pValue ){ sqlite3VdbeAppendP4(v, pValue, P4_MEM); @@ -138358,6 +142597,7 @@ static void updateFromSelect( assert( pTabList->nSrc>1 ); if( pSrc ){ + pSrc->a[0].fg.notCte = 1; pSrc->a[0].iCursor = -1; pSrc->a[0].pTab->nTabRef--; pSrc->a[0].pTab = 0; @@ -138373,7 +142613,7 @@ static void updateFromSelect( pList = sqlite3ExprListAppend(pParse, pList, pNew); } eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom; - }else if( pTab->pSelect ){ + }else if( IsView(pTab) ){ for(i=0; inCol; i++){ pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i)); } @@ -138387,7 +142627,8 @@ static void updateFromSelect( } #endif } - if( ALWAYS(pChanges) ){ + assert( pChanges!=0 || pParse->db->mallocFailed ); + if( pChanges ){ for(i=0; inExpr; i++){ pList = sqlite3ExprListAppend(pParse, pList, sqlite3ExprDup(db, pChanges->a[i].pExpr, 0) @@ -138395,8 +142636,9 @@ static void updateFromSelect( } } pSelect = sqlite3SelectNew(pParse, pList, - pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UpdateFrom|SF_IncludeHidden, pLimit2 + pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UFSrcCheck|SF_IncludeHidden, pLimit2 ); + if( pSelect ) pSelect->selFlags |= SF_OrderByReqd; sqlite3SelectDestInit(&dest, eDest, iEph); dest.iSDParm2 = (pPk ? pPk->nKeyCol : -1); sqlite3Select(pParse, pSelect, &dest); @@ -138496,7 +142738,7 @@ SQLITE_PRIVATE void sqlite3Update( */ #ifndef SQLITE_OMIT_TRIGGER pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask); - isView = pTab->pSelect!=0; + isView = IsView(pTab); assert( pTrigger || tmask==0 ); #else # define pTrigger 0 @@ -138585,13 +142827,16 @@ SQLITE_PRIVATE void sqlite3Update( */ chngRowid = chngPk = 0; for(i=0; inExpr; i++){ + u8 hCol = sqlite3StrIHash(pChanges->a[i].zEName); /* If this is an UPDATE with a FROM clause, do not resolve expressions ** here. The call to sqlite3Select() below will do that. */ if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){ goto update_cleanup; } for(j=0; jnCol; j++){ - if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zEName)==0 ){ + if( pTab->aCol[j].hName==hCol + && sqlite3StrICmp(pTab->aCol[j].zCnName, pChanges->a[i].zEName)==0 + ){ if( j==pTab->iPKey ){ chngRowid = 1; pRowidExpr = pChanges->a[i].pExpr; @@ -138605,7 +142850,7 @@ SQLITE_PRIVATE void sqlite3Update( testcase( pTab->aCol[j].colFlags & COLFLAG_STORED ); sqlite3ErrorMsg(pParse, "cannot UPDATE generated column \"%s\"", - pTab->aCol[j].zName); + pTab->aCol[j].zCnName); goto update_cleanup; } #endif @@ -138629,7 +142874,7 @@ SQLITE_PRIVATE void sqlite3Update( { int rc; rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName, - j<0 ? "ROWID" : pTab->aCol[j].zName, + j<0 ? "ROWID" : pTab->aCol[j].zCnName, db->aDb[iDb].zDbSName); if( rc==SQLITE_DENY ){ goto update_cleanup; @@ -138661,8 +142906,10 @@ SQLITE_PRIVATE void sqlite3Update( for(i=0; inCol; i++){ if( aXRef[i]>=0 ) continue; if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue; - if( sqlite3ExprReferencesUpdatedColumn(pTab->aCol[i].pDflt, - aXRef, chngRowid) ){ + if( sqlite3ExprReferencesUpdatedColumn( + sqlite3ColumnExpr(pTab, &pTab->aCol[i]), + aXRef, chngRowid) + ){ aXRef[i] = 99999; bProgress = 1; } @@ -138781,6 +143028,7 @@ SQLITE_PRIVATE void sqlite3Update( if( (db->flags&SQLITE_CountRows)!=0 && !pParse->pTriggerTab && !pParse->nested + && !pParse->bReturning && pUpsert==0 ){ regRowCount = ++pParse->nMem; @@ -138936,7 +143184,12 @@ SQLITE_PRIVATE void sqlite3Update( /* Top of the update loop */ if( eOnePass!=ONEPASS_OFF ){ - if( !isView && aiCurOnePass[0]!=iDataCur && aiCurOnePass[1]!=iDataCur ){ + if( aiCurOnePass[0]!=iDataCur + && aiCurOnePass[1]!=iDataCur +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW + && !isView +#endif + ){ assert( pPk ); sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey); VdbeCoverage(v); @@ -139244,7 +143497,7 @@ SQLITE_PRIVATE void sqlite3Update( ** that information. */ if( regRowCount ){ - sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1); + sqlite3VdbeAddOp2(v, OP_ChngCntRow, regRowCount, 1); sqlite3VdbeSetNumCols(v, 1); sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC); } @@ -139479,16 +143732,23 @@ static void updateVirtualTable( /* ** Free a list of Upsert objects */ -SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3 *db, Upsert *p){ - if( p ){ +static void SQLITE_NOINLINE upsertDelete(sqlite3 *db, Upsert *p){ + do{ + Upsert *pNext = p->pNextUpsert; sqlite3ExprListDelete(db, p->pUpsertTarget); sqlite3ExprDelete(db, p->pUpsertTargetWhere); sqlite3ExprListDelete(db, p->pUpsertSet); sqlite3ExprDelete(db, p->pUpsertWhere); + sqlite3DbFree(db, p->pToFree); sqlite3DbFree(db, p); - } + p = pNext; + }while( p ); +} +SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3 *db, Upsert *p){ + if( p ) upsertDelete(db, p); } + /* ** Duplicate an Upsert object. */ @@ -139498,7 +143758,8 @@ SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3 *db, Upsert *p){ sqlite3ExprListDup(db, p->pUpsertTarget, 0), sqlite3ExprDup(db, p->pUpsertTargetWhere, 0), sqlite3ExprListDup(db, p->pUpsertSet, 0), - sqlite3ExprDup(db, p->pUpsertWhere, 0) + sqlite3ExprDup(db, p->pUpsertWhere, 0), + sqlite3UpsertDup(db, p->pNextUpsert) ); } @@ -139510,22 +143771,25 @@ SQLITE_PRIVATE Upsert *sqlite3UpsertNew( ExprList *pTarget, /* Target argument to ON CONFLICT, or NULL */ Expr *pTargetWhere, /* Optional WHERE clause on the target */ ExprList *pSet, /* UPDATE columns, or NULL for a DO NOTHING */ - Expr *pWhere /* WHERE clause for the ON CONFLICT UPDATE */ + Expr *pWhere, /* WHERE clause for the ON CONFLICT UPDATE */ + Upsert *pNext /* Next ON CONFLICT clause in the list */ ){ Upsert *pNew; - pNew = sqlite3DbMallocRaw(db, sizeof(Upsert)); + pNew = sqlite3DbMallocZero(db, sizeof(Upsert)); if( pNew==0 ){ sqlite3ExprListDelete(db, pTarget); sqlite3ExprDelete(db, pTargetWhere); sqlite3ExprListDelete(db, pSet); sqlite3ExprDelete(db, pWhere); + sqlite3UpsertDelete(db, pNext); return 0; }else{ pNew->pUpsertTarget = pTarget; pNew->pUpsertTargetWhere = pTargetWhere; pNew->pUpsertSet = pSet; pNew->pUpsertWhere = pWhere; - pNew->pUpsertIdx = 0; + pNew->isDoUpdate = pSet!=0; + pNew->pNextUpsert = pNext; } return pNew; } @@ -139550,6 +143814,7 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget( Expr *pTerm; /* One term of the conflict-target clause */ NameContext sNC; /* Context for resolving symbolic names */ Expr sCol[2]; /* Index column converted into an Expr */ + int nClause = 0; /* Counter of ON CONFLICT clauses */ assert( pTabList->nSrc==1 ); assert( pTabList->a[0].pTab!=0 ); @@ -139563,87 +143828,131 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget( memset(&sNC, 0, sizeof(sNC)); sNC.pParse = pParse; sNC.pSrcList = pTabList; - rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget); - if( rc ) return rc; - rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere); - if( rc ) return rc; + for(; pUpsert && pUpsert->pUpsertTarget; + pUpsert=pUpsert->pNextUpsert, nClause++){ + rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget); + if( rc ) return rc; + rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere); + if( rc ) return rc; - /* Check to see if the conflict target matches the rowid. */ - pTab = pTabList->a[0].pTab; - pTarget = pUpsert->pUpsertTarget; - iCursor = pTabList->a[0].iCursor; - if( HasRowid(pTab) - && pTarget->nExpr==1 - && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN - && pTerm->iColumn==XN_ROWID - ){ - /* The conflict-target is the rowid of the primary table */ - assert( pUpsert->pUpsertIdx==0 ); - return SQLITE_OK; - } + /* Check to see if the conflict target matches the rowid. */ + pTab = pTabList->a[0].pTab; + pTarget = pUpsert->pUpsertTarget; + iCursor = pTabList->a[0].iCursor; + if( HasRowid(pTab) + && pTarget->nExpr==1 + && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN + && pTerm->iColumn==XN_ROWID + ){ + /* The conflict-target is the rowid of the primary table */ + assert( pUpsert->pUpsertIdx==0 ); + continue; + } - /* Initialize sCol[0..1] to be an expression parse tree for a - ** single column of an index. The sCol[0] node will be the TK_COLLATE - ** operator and sCol[1] will be the TK_COLUMN operator. Code below - ** will populate the specific collation and column number values - ** prior to comparing against the conflict-target expression. - */ - memset(sCol, 0, sizeof(sCol)); - sCol[0].op = TK_COLLATE; - sCol[0].pLeft = &sCol[1]; - sCol[1].op = TK_COLUMN; - sCol[1].iTable = pTabList->a[0].iCursor; + /* Initialize sCol[0..1] to be an expression parse tree for a + ** single column of an index. The sCol[0] node will be the TK_COLLATE + ** operator and sCol[1] will be the TK_COLUMN operator. Code below + ** will populate the specific collation and column number values + ** prior to comparing against the conflict-target expression. + */ + memset(sCol, 0, sizeof(sCol)); + sCol[0].op = TK_COLLATE; + sCol[0].pLeft = &sCol[1]; + sCol[1].op = TK_COLUMN; + sCol[1].iTable = pTabList->a[0].iCursor; - /* Check for matches against other indexes */ - for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ - int ii, jj, nn; - if( !IsUniqueIndex(pIdx) ) continue; - if( pTarget->nExpr!=pIdx->nKeyCol ) continue; - if( pIdx->pPartIdxWhere ){ - if( pUpsert->pUpsertTargetWhere==0 ) continue; - if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere, - pIdx->pPartIdxWhere, iCursor)!=0 ){ - continue; + /* Check for matches against other indexes */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int ii, jj, nn; + if( !IsUniqueIndex(pIdx) ) continue; + if( pTarget->nExpr!=pIdx->nKeyCol ) continue; + if( pIdx->pPartIdxWhere ){ + if( pUpsert->pUpsertTargetWhere==0 ) continue; + if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere, + pIdx->pPartIdxWhere, iCursor)!=0 ){ + continue; + } } - } - nn = pIdx->nKeyCol; - for(ii=0; iiazColl[ii]; - if( pIdx->aiColumn[ii]==XN_EXPR ){ - assert( pIdx->aColExpr!=0 ); - assert( pIdx->aColExpr->nExpr>ii ); - pExpr = pIdx->aColExpr->a[ii].pExpr; - if( pExpr->op!=TK_COLLATE ){ - sCol[0].pLeft = pExpr; + nn = pIdx->nKeyCol; + for(ii=0; iiazColl[ii]; + if( pIdx->aiColumn[ii]==XN_EXPR ){ + assert( pIdx->aColExpr!=0 ); + assert( pIdx->aColExpr->nExpr>ii ); + pExpr = pIdx->aColExpr->a[ii].pExpr; + if( pExpr->op!=TK_COLLATE ){ + sCol[0].pLeft = pExpr; + pExpr = &sCol[0]; + } + }else{ + sCol[0].pLeft = &sCol[1]; + sCol[1].iColumn = pIdx->aiColumn[ii]; pExpr = &sCol[0]; } - }else{ - sCol[0].pLeft = &sCol[1]; - sCol[1].iColumn = pIdx->aiColumn[ii]; - pExpr = &sCol[0]; - } - for(jj=0; jja[jj].pExpr, pExpr,iCursor)<2 ){ - break; /* Column ii of the index matches column jj of target */ + for(jj=0; jja[jj].pExpr,pExpr,iCursor)<2 ){ + break; /* Column ii of the index matches column jj of target */ + } + } + if( jj>=nn ){ + /* The target contains no match for column jj of the index */ + break; } } - if( jj>=nn ){ - /* The target contains no match for column jj of the index */ - break; + if( iipUpsertIdx = pIdx; + break; } - if( iipUpsertIdx==0 ){ + char zWhich[16]; + if( nClause==0 && pUpsert->pNextUpsert==0 ){ + zWhich[0] = 0; + }else{ + sqlite3_snprintf(sizeof(zWhich),zWhich,"%r ", nClause+1); + } + sqlite3ErrorMsg(pParse, "%sON CONFLICT clause does not match any " + "PRIMARY KEY or UNIQUE constraint", zWhich); + return SQLITE_ERROR; } - pUpsert->pUpsertIdx = pIdx; - return SQLITE_OK; } - sqlite3ErrorMsg(pParse, "ON CONFLICT clause does not match any " - "PRIMARY KEY or UNIQUE constraint"); - return SQLITE_ERROR; + return SQLITE_OK; +} + +/* +** Return true if pUpsert is the last ON CONFLICT clause with a +** conflict target, or if pUpsert is followed by another ON CONFLICT +** clause that targets the INTEGER PRIMARY KEY. +*/ +SQLITE_PRIVATE int sqlite3UpsertNextIsIPK(Upsert *pUpsert){ + Upsert *pNext; + if( NEVER(pUpsert==0) ) return 0; + pNext = pUpsert->pNextUpsert; + if( pNext==0 ) return 1; + if( pNext->pUpsertTarget==0 ) return 1; + if( pNext->pUpsertIdx==0 ) return 1; + return 0; +} + +/* +** Given the list of ON CONFLICT clauses described by pUpsert, and +** a particular index pIdx, return a pointer to the particular ON CONFLICT +** clause that applies to the index. Or, if the index is not subject to +** any ON CONFLICT clause, return NULL. +*/ +SQLITE_PRIVATE Upsert *sqlite3UpsertOfIndex(Upsert *pUpsert, Index *pIdx){ + while( + pUpsert + && pUpsert->pUpsertTarget!=0 + && pUpsert->pUpsertIdx!=pIdx + ){ + pUpsert = pUpsert->pNextUpsert; + } + return pUpsert; } /* @@ -139667,11 +143976,13 @@ SQLITE_PRIVATE void sqlite3UpsertDoUpdate( SrcList *pSrc; /* FROM clause for the UPDATE */ int iDataCur; int i; + Upsert *pTop = pUpsert; assert( v!=0 ); assert( pUpsert!=0 ); - VdbeNoopComment((v, "Begin DO UPDATE of UPSERT")); iDataCur = pUpsert->iDataCur; + pUpsert = sqlite3UpsertOfIndex(pTop, pIdx); + VdbeNoopComment((v, "Begin DO UPDATE of UPSERT")); if( pIdx && iCur!=iDataCur ){ if( HasRowid(pTab) ){ int regRowid = sqlite3GetTempReg(pParse); @@ -139690,7 +144001,7 @@ SQLITE_PRIVATE void sqlite3UpsertDoUpdate( k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]); sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i); VdbeComment((v, "%s.%s", pIdx->zName, - pTab->aCol[pPk->aiColumn[i]].zName)); + pTab->aCol[pPk->aiColumn[i]].zCnName)); } sqlite3VdbeVerifyAbortable(v, OE_Abort); i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk); @@ -139701,19 +144012,17 @@ SQLITE_PRIVATE void sqlite3UpsertDoUpdate( sqlite3VdbeJumpHere(v, i); } } - /* pUpsert does not own pUpsertSrc - the outer INSERT statement does. So - ** we have to make a copy before passing it down into sqlite3Update() */ - pSrc = sqlite3SrcListDup(db, pUpsert->pUpsertSrc, 0); + /* pUpsert does not own pTop->pUpsertSrc - the outer INSERT statement does. + ** So we have to make a copy before passing it down into sqlite3Update() */ + pSrc = sqlite3SrcListDup(db, pTop->pUpsertSrc, 0); /* excluded.* columns of type REAL need to be converted to a hard real */ for(i=0; inCol; i++){ if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){ - sqlite3VdbeAddOp1(v, OP_RealAffinity, pUpsert->regData+i); + sqlite3VdbeAddOp1(v, OP_RealAffinity, pTop->regData+i); } } - sqlite3Update(pParse, pSrc, pUpsert->pUpsertSet, - pUpsert->pUpsertWhere, OE_Abort, 0, 0, pUpsert); - pUpsert->pUpsertSet = 0; /* Will have been deleted by sqlite3Update() */ - pUpsert->pUpsertWhere = 0; /* Will have been deleted by sqlite3Update() */ + sqlite3Update(pParse, pSrc, sqlite3ExprListDup(db,pUpsert->pUpsertSet,0), + sqlite3ExprDup(db,pUpsert->pUpsertWhere,0), OE_Abort, 0, 0, pUpsert); VdbeNoopComment((v, "End DO UPDATE of UPSERT")); } @@ -139874,8 +144183,8 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum( Btree *pTemp; /* The temporary database we vacuum into */ u32 saved_mDbFlags; /* Saved value of db->mDbFlags */ u64 saved_flags; /* Saved value of db->flags */ - int saved_nChange; /* Saved value of db->nChange */ - int saved_nTotalChange; /* Saved value of db->nTotalChange */ + i64 saved_nChange; /* Saved value of db->nChange */ + i64 saved_nTotalChange; /* Saved value of db->nTotalChange */ u32 saved_openFlags; /* Saved value of db->openFlags */ u8 saved_mTrace; /* Saved trace settings */ Db *pDb = 0; /* Database to detach at end of vacuum */ @@ -139973,7 +144282,9 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum( /* Do not attempt to change the page size for a WAL database */ if( sqlite3PagerGetJournalMode(sqlite3BtreePager(pMain)) - ==PAGER_JOURNALMODE_WAL ){ + ==PAGER_JOURNALMODE_WAL + && pOut==0 + ){ db->nextPagesize = 0; } @@ -140322,7 +144633,7 @@ SQLITE_PRIVATE void sqlite3VtabLock(VTable *pVTab){ SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){ VTable *pVtab; assert( IsVirtual(pTab) ); - for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext); + for(pVtab=pTab->u.vtab.p; pVtab && pVtab->db!=db; pVtab=pVtab->pNext); return pVtab; } @@ -140335,7 +144646,8 @@ SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){ assert( db ); assert( pVTab->nRef>0 ); - assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE ); + assert( db->eOpenState==SQLITE_STATE_OPEN + || db->eOpenState==SQLITE_STATE_ZOMBIE ); pVTab->nRef--; if( pVTab->nRef==0 ){ @@ -140350,21 +144662,24 @@ SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){ /* ** Table p is a virtual table. This function moves all elements in the -** p->pVTable list to the sqlite3.pDisconnect lists of their associated +** p->u.vtab.p list to the sqlite3.pDisconnect lists of their associated ** database connections to be disconnected at the next opportunity. ** Except, if argument db is not NULL, then the entry associated with -** connection db is left in the p->pVTable list. +** connection db is left in the p->u.vtab.p list. */ static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){ VTable *pRet = 0; - VTable *pVTable = p->pVTable; - p->pVTable = 0; + VTable *pVTable; + + assert( IsVirtual(p) ); + pVTable = p->u.vtab.p; + p->u.vtab.p = 0; /* Assert that the mutex (if any) associated with the BtShared database ** that contains table p is held by the caller. See header comments ** above function sqlite3VtabUnlockList() for an explanation of why ** this makes it safe to access the sqlite3.pDisconnect list of any - ** database connection that may have an entry in the p->pVTable list. + ** database connection that may have an entry in the p->u.vtab.p list. */ assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) ); @@ -140374,7 +144689,7 @@ static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){ assert( db2 ); if( db2==db ){ pRet = pVTable; - p->pVTable = pRet; + p->u.vtab.p = pRet; pRet->pNext = 0; }else{ pVTable->pNext = db2->pDisconnect; @@ -140402,7 +144717,7 @@ SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p){ assert( sqlite3BtreeHoldsAllMutexes(db) ); assert( sqlite3_mutex_held(db->mutex) ); - for(ppVTab=&p->pVTable; *ppVTab; ppVTab=&(*ppVTab)->pNext){ + for(ppVTab=&p->u.vtab.p; *ppVTab; ppVTab=&(*ppVTab)->pNext){ if( (*ppVTab)->db==db ){ VTable *pVTab = *ppVTab; *ppVTab = pVTab->pNext; @@ -140465,37 +144780,41 @@ SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){ ** database connection. */ SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){ + assert( IsVirtual(p) ); if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p); - if( p->azModuleArg ){ + if( p->u.vtab.azArg ){ int i; - for(i=0; inModuleArg; i++){ - if( i!=1 ) sqlite3DbFree(db, p->azModuleArg[i]); + for(i=0; iu.vtab.nArg; i++){ + if( i!=1 ) sqlite3DbFree(db, p->u.vtab.azArg[i]); } - sqlite3DbFree(db, p->azModuleArg); + sqlite3DbFree(db, p->u.vtab.azArg); } } /* -** Add a new module argument to pTable->azModuleArg[]. +** Add a new module argument to pTable->u.vtab.azArg[]. ** The string is not copied - the pointer is stored. The ** string will be freed automatically when the table is ** deleted. */ static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){ - sqlite3_int64 nBytes = sizeof(char *)*(2+pTable->nModuleArg); + sqlite3_int64 nBytes; char **azModuleArg; sqlite3 *db = pParse->db; - if( pTable->nModuleArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){ + + assert( IsVirtual(pTable) ); + nBytes = sizeof(char *)*(2+pTable->u.vtab.nArg); + if( pTable->u.vtab.nArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){ sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName); } - azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes); + azModuleArg = sqlite3DbRealloc(db, pTable->u.vtab.azArg, nBytes); if( azModuleArg==0 ){ sqlite3DbFree(db, zArg); }else{ - int i = pTable->nModuleArg++; + int i = pTable->u.vtab.nArg++; azModuleArg[i] = zArg; azModuleArg[i+1] = 0; - pTable->azModuleArg = azModuleArg; + pTable->u.vtab.azArg = azModuleArg; } } @@ -140518,10 +144837,11 @@ SQLITE_PRIVATE void sqlite3VtabBeginParse( pTable = pParse->pNewTable; if( pTable==0 ) return; assert( 0==pTable->pIndex ); + pTable->eTabType = TABTYP_VTAB; db = pParse->db; - assert( pTable->nModuleArg==0 ); + assert( pTable->u.vtab.nArg==0 ); addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName)); addModuleArgument(pParse, pTable, 0); addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName)); @@ -140538,11 +144858,11 @@ SQLITE_PRIVATE void sqlite3VtabBeginParse( ** sqlite_schema table, has already been made by sqlite3StartTable(). ** The second call, to obtain permission to create the table, is made now. */ - if( pTable->azModuleArg ){ + if( pTable->u.vtab.azArg ){ int iDb = sqlite3SchemaToIndex(db, pTable->pSchema); assert( iDb>=0 ); /* The database the table is being created in */ sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName, - pTable->azModuleArg[0], pParse->db->aDb[iDb].zDbSName); + pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName); } #endif } @@ -140570,9 +144890,10 @@ SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){ sqlite3 *db = pParse->db; /* The database connection */ if( pTab==0 ) return; + assert( IsVirtual(pTab) ); addArgumentToVtab(pParse); pParse->sArg.z = 0; - if( pTab->nModuleArg<1 ) return; + if( pTab->u.vtab.nArg<1 ) return; /* If the CREATE VIRTUAL TABLE statement is being entered for the ** first time (in other words if the virtual table is actually being @@ -140605,7 +144926,7 @@ SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){ */ iDb = sqlite3SchemaToIndex(db, pTab->pSchema); sqlite3NestedParse(pParse, - "UPDATE %Q." DFLT_SCHEMA_TABLE " " + "UPDATE %Q." LEGACY_SCHEMA_TABLE " " "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q " "WHERE rowid=#%d", db->aDb[iDb].zDbSName, @@ -140619,24 +144940,20 @@ SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){ sqlite3VdbeAddOp0(v, OP_Expire); zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt); - sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere); + sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0); sqlite3DbFree(db, zStmt); iReg = ++pParse->nMem; sqlite3VdbeLoadString(v, iReg, pTab->zName); sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg); - } - - /* If we are rereading the sqlite_schema table create the in-memory - ** record of the table. The xConnect() method is not called until - ** the first time the virtual table is used in an SQL statement. This - ** allows a schema that contains virtual tables to be loaded before - ** the required virtual table implementations are registered. */ - else { + }else{ + /* If we are rereading the sqlite_schema table create the in-memory + ** record of the table. */ Table *pOld; Schema *pSchema = pTab->pSchema; const char *zName = pTab->zName; - assert( sqlite3SchemaMutexHeld(db, 0, pSchema) ); + assert( zName!=0 ); + sqlite3MarkAllShadowTablesOf(db, pTab); pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab); if( pOld ){ sqlite3OomFault(db); @@ -140687,13 +145004,16 @@ static int vtabCallConstructor( VtabCtx sCtx; VTable *pVTable; int rc; - const char *const*azArg = (const char *const*)pTab->azModuleArg; - int nArg = pTab->nModuleArg; + const char *const*azArg; + int nArg = pTab->u.vtab.nArg; char *zErr = 0; char *zModuleName; int iDb; VtabCtx *pCtx; + assert( IsVirtual(pTab) ); + azArg = (const char *const*)pTab->u.vtab.azArg; + /* Check that the virtual-table is not already being initialized */ for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){ if( pCtx->pTab==pTab ){ @@ -140720,7 +145040,7 @@ static int vtabCallConstructor( pVTable->eVtabRisk = SQLITE_VTABRISK_Normal; iDb = sqlite3SchemaToIndex(db, pTab->pSchema); - pTab->azModuleArg[1] = db->aDb[iDb].zDbSName; + pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName; /* Invoke the virtual table constructor */ assert( &db->pVtabCtx ); @@ -140759,12 +145079,12 @@ static int vtabCallConstructor( int iCol; u16 oooHidden = 0; /* If everything went according to plan, link the new VTable structure - ** into the linked list headed by pTab->pVTable. Then loop through the + ** into the linked list headed by pTab->u.vtab.p. Then loop through the ** columns of the table to see if any of them contain the token "hidden". ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from ** the type string. */ - pVTable->pNext = pTab->pVTable; - pTab->pVTable = pVTable; + pVTable->pNext = pTab->u.vtab.p; + pTab->u.vtab.p = pVTable; for(iCol=0; iColnCol; iCol++){ char *zType = sqlite3ColumnType(&pTab->aCol[iCol], ""); @@ -140790,6 +145110,7 @@ static int vtabCallConstructor( zType[i-1] = '\0'; } pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN; + pTab->tabFlags |= TF_HasHidden; oooHidden = TF_OOOHidden; }else{ pTab->tabFlags |= oooHidden; @@ -140816,16 +145137,17 @@ SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){ int rc; assert( pTab ); - if( !IsVirtual(pTab) || sqlite3GetVTable(db, pTab) ){ + assert( IsVirtual(pTab) ); + if( sqlite3GetVTable(db, pTab) ){ return SQLITE_OK; } /* Locate the required virtual table module */ - zMod = pTab->azModuleArg[0]; + zMod = pTab->u.vtab.azArg[0]; pMod = (Module*)sqlite3HashFind(&db->aModule, zMod); if( !pMod ){ - const char *zModule = pTab->azModuleArg[0]; + const char *zModule = pTab->u.vtab.azArg[0]; sqlite3ErrorMsg(pParse, "no such module: %s", zModule); rc = SQLITE_ERROR; }else{ @@ -140888,10 +145210,10 @@ SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, const char *zMod; pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName); - assert( pTab && IsVirtual(pTab) && !pTab->pVTable ); + assert( pTab && IsVirtual(pTab) && !pTab->u.vtab.p ); /* Locate the required virtual table module */ - zMod = pTab->azModuleArg[0]; + zMod = pTab->u.vtab.azArg[0]; pMod = (Module*)sqlite3HashFind(&db->aModule, zMod); /* If the module has been registered and includes a Create method, @@ -140928,6 +145250,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){ Table *pTab; char *zErr = 0; Parse sParse; + int initBusy; #ifdef SQLITE_ENABLE_API_ARMOR if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){ @@ -140947,18 +145270,24 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){ memset(&sParse, 0, sizeof(sParse)); sParse.eParseMode = PARSE_MODE_DECLARE_VTAB; sParse.db = db; + /* We should never be able to reach this point while loading the + ** schema. Nevertheless, defend against that (turn off db->init.busy) + ** in case a bug arises. */ + assert( db->init.busy==0 ); + initBusy = db->init.busy; + db->init.busy = 0; sParse.nQueryLoop = 1; if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable, &zErr) && sParse.pNewTable && !db->mallocFailed - && !sParse.pNewTable->pSelect - && !IsVirtual(sParse.pNewTable) + && IsOrdinaryTable(sParse.pNewTable) ){ if( !pTab->aCol ){ Table *pNew = sParse.pNewTable; Index *pIdx; pTab->aCol = pNew->aCol; - pTab->nCol = pNew->nCol; + sqlite3ExprListDelete(db, pNew->u.tab.pDfltList); + pTab->nNVCol = pTab->nCol = pNew->nCol; pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid); pNew->nCol = 0; pNew->aCol = 0; @@ -140993,6 +145322,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){ } sqlite3DeleteTable(db, sParse.pNewTable); sqlite3ParserReset(&sParse); + db->init.busy = initBusy; assert( (rc&0xff)==rc ); rc = sqlite3ApiExit(db, rc); @@ -141012,10 +145342,13 @@ SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab Table *pTab; pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName); - if( pTab!=0 && ALWAYS(pTab->pVTable!=0) ){ + if( ALWAYS(pTab!=0) + && ALWAYS(IsVirtual(pTab)) + && ALWAYS(pTab->u.vtab.p!=0) + ){ VTable *p; int (*xDestroy)(sqlite3_vtab *); - for(p=pTab->pVTable; p; p=p->pNext){ + for(p=pTab->u.vtab.p; p; p=p->pNext){ assert( p->pVtab ); if( p->pVtab->nRef>0 ){ return SQLITE_LOCKED; @@ -141029,9 +145362,9 @@ SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab rc = xDestroy(p->pVtab); /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */ if( rc==SQLITE_OK ){ - assert( pTab->pVTable==p && p->pNext==0 ); + assert( pTab->u.vtab.p==p && p->pNext==0 ); p->pVtab = 0; - pTab->pVTable = 0; + pTab->u.vtab.p = 0; sqlite3VtabUnlock(p); } sqlite3DeleteTable(db, pTab); @@ -141245,6 +145578,7 @@ SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction( /* Check to see the left operand is a column in a virtual table */ if( NEVER(pExpr==0) ) return pDef; if( pExpr->op!=TK_COLUMN ) return pDef; + assert( ExprUseYTab(pExpr) ); pTab = pExpr->y.pTab; if( pTab==0 ) return pDef; if( !IsVirtual(pTab) ) return pDef; @@ -141319,8 +145653,9 @@ SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){ /* ** Check to see if virtual table module pMod can be have an eponymous ** virtual table instance. If it can, create one if one does not already -** exist. Return non-zero if the eponymous virtual table instance exists -** when this routine returns, and return zero if it does not exist. +** exist. Return non-zero if either the eponymous virtual table instance +** exists when this routine returns or if an attempt to create it failed +** and an error message was left in pParse. ** ** An eponymous virtual table instance is one that is named after its ** module, and more importantly, does not require a CREATE VIRTUAL TABLE @@ -141347,9 +145682,11 @@ SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){ } pMod->pEpoTab = pTab; pTab->nTabRef = 1; + pTab->eTabType = TABTYP_VTAB; pTab->pSchema = db->aDb[0].pSchema; - assert( pTab->nModuleArg==0 ); + assert( pTab->u.vtab.nArg==0 ); pTab->iPKey = -1; + pTab->tabFlags |= TF_Eponymous; addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName)); addModuleArgument(pParse, pTab, 0); addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName)); @@ -141358,7 +145695,6 @@ SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){ sqlite3ErrorMsg(pParse, "%s", zErr); sqlite3DbFree(db, zErr); sqlite3VtabEponymousTableClear(db, pMod); - return 0; } return 1; } @@ -141490,19 +145826,6 @@ SQLITE_API int sqlite3_vtab_config(sqlite3 *db, int op, ...){ #ifndef SQLITE_WHEREINT_H #define SQLITE_WHEREINT_H -/* -** Trace output macros -*/ -#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) -/***/ extern int sqlite3WhereTrace; -#endif -#if defined(SQLITE_DEBUG) \ - && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE)) -# define WHERETRACE(K,X) if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X -# define WHERETRACE_ENABLED 1 -#else -# define WHERETRACE(K,X) -#endif /* Forward references */ @@ -141564,7 +145887,7 @@ struct WhereLevel { u8 eEndLoopOp; /* IN Loop terminator. OP_Next or OP_Prev */ } *aInLoop; /* Information about each nested IN operator */ } in; /* Used when pWLoop->wsFlags&WHERE_IN_ABLE */ - Index *pCovidx; /* Possible covering index for WHERE_MULTI_OR */ + Index *pCoveringIdx; /* Possible covering index for WHERE_MULTI_OR */ } u; struct WhereLoop *pWLoop; /* The selected WhereLoop object */ Bitmask notReady; /* FROM entries not usable at this level */ @@ -141756,11 +146079,7 @@ struct WhereTerm { #define TERM_ORINFO 0x0010 /* Need to free the WhereTerm.u.pOrInfo object */ #define TERM_ANDINFO 0x0020 /* Need to free the WhereTerm.u.pAndInfo obj */ #define TERM_OR_OK 0x0040 /* Used during OR-clause processing */ -#ifdef SQLITE_ENABLE_STAT4 -# define TERM_VNULL 0x0080 /* Manufactured x>NULL or x<=NULL term */ -#else -# define TERM_VNULL 0x0000 /* Disabled if not using stat4 */ -#endif +#define TERM_VNULL 0x0080 /* Manufactured x>NULL or x<=NULL term */ #define TERM_LIKEOPT 0x0100 /* Virtual terms from the LIKE optimization */ #define TERM_LIKECOND 0x0200 /* Conditionally this LIKE operator term */ #define TERM_LIKE 0x0400 /* The original LIKE operator */ @@ -141783,8 +146102,8 @@ struct WhereScan { const char *zCollName; /* Required collating sequence, if not NULL */ Expr *pIdxExpr; /* Search for this index expression */ char idxaff; /* Must match this affinity, if zCollName!=NULL */ - unsigned char nEquiv; /* Number of entries in aEquiv[] */ - unsigned char iEquiv; /* Next unused slot in aEquiv[] */ + unsigned char nEquiv; /* Number of entries in aiCur[] and aiColumn[] */ + unsigned char iEquiv; /* Next unused slot in aiCur[] and aiColumn[] */ u32 opMask; /* Acceptable operators */ int k; /* Resume scanning at this->pWC->a[this->k] */ int aiCur[11]; /* Cursors in the equivalence class */ @@ -142030,7 +146349,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet*, Expr*); SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet*, Expr*); SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet*, ExprList*); SQLITE_PRIVATE void sqlite3WhereExprAnalyze(SrcList*, WhereClause*); -SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, struct SrcList_item*, WhereClause*); +SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, SrcItem*, WhereClause*); @@ -142093,6 +146412,7 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, struct SrcList_item*, WhereC #define WHERE_IN_EARLYOUT 0x00040000 /* Perhaps quit IN loops early */ #define WHERE_BIGNULL_SORT 0x00080000 /* Column nEq of index is BIGNULL */ #define WHERE_IN_SEEKSCAN 0x00100000 /* Seek-scan optimization for IN */ +#define WHERE_TRANSCONS 0x00200000 /* Uses a transitive constraint */ #endif /* !defined(SQLITE_WHEREINT_H) */ @@ -142108,7 +146428,7 @@ static const char *explainIndexColumnName(Index *pIdx, int i){ i = pIdx->aiColumn[i]; if( i==XN_EXPR ) return ""; if( i==XN_ROWID ) return "rowid"; - return pIdx->pTable->aCol[i].zName; + return pIdx->pTable->aCol[i].zCnName; } /* @@ -142208,7 +146528,7 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan( if( sqlite3ParseToplevel(pParse)->explain==2 ) #endif { - struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom]; + SrcItem *pItem = &pTabList->a[pLevel->iFrom]; Vdbe *v = pParse->pVdbe; /* VM being constructed */ sqlite3 *db = pParse->db; /* Database handle */ int isSearch; /* True for a SEARCH. False for SCAN. */ @@ -142227,16 +146547,8 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan( || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX)); sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH); - sqlite3_str_appendall(&str, isSearch ? "SEARCH" : "SCAN"); - if( pItem->pSelect ){ - sqlite3_str_appendf(&str, " SUBQUERY %u", pItem->pSelect->selId); - }else{ - sqlite3_str_appendf(&str, " TABLE %s", pItem->zName); - } - - if( pItem->zAlias ){ - sqlite3_str_appendf(&str, " AS %s", pItem->zAlias); - } + str.printfFlags = SQLITE_PRINTF_INTERNAL; + sqlite3_str_appendf(&str, "%s %S", isSearch ? "SEARCH" : "SCAN", pItem); if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){ const char *zFmt = 0; Index *pIdx; @@ -142384,6 +146696,12 @@ static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){ }else{ pTerm->wtFlags |= TERM_CODED; } +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace & 0x20000 ){ + sqlite3DebugPrintf("DISABLE-"); + sqlite3WhereTermPrint(pTerm, (int)(pTerm - (pTerm->pWC->a))); + } +#endif if( pTerm->iParent<0 ) break; pTerm = &pTerm->pWC->a[pTerm->iParent]; assert( pTerm!=0 ); @@ -142497,16 +146815,23 @@ static Expr *removeUnindexableInClauseTerms( Expr *pNew; pNew = sqlite3ExprDup(db, pX, 0); if( db->mallocFailed==0 ){ - ExprList *pOrigRhs = pNew->x.pSelect->pEList; /* Original unmodified RHS */ - ExprList *pOrigLhs = pNew->pLeft->x.pList; /* Original unmodified LHS */ + ExprList *pOrigRhs; /* Original unmodified RHS */ + ExprList *pOrigLhs; /* Original unmodified LHS */ ExprList *pRhs = 0; /* New RHS after modifications */ ExprList *pLhs = 0; /* New LHS after mods */ int i; /* Loop counter */ Select *pSelect; /* Pointer to the SELECT on the RHS */ + assert( ExprUseXSelect(pNew) ); + pOrigRhs = pNew->x.pSelect->pEList; + assert( pNew->pLeft!=0 ); + assert( ExprUseXList(pNew->pLeft) ); + pOrigLhs = pNew->pLeft->x.pList; for(i=iEq; inLTerm; i++){ if( pLoop->aLTerm[i]->pExpr==pX ){ - int iField = pLoop->aLTerm[i]->u.x.iField - 1; + int iField; + assert( (pLoop->aLTerm[i]->eOperator & (WO_OR|WO_AND))==0 ); + iField = pLoop->aLTerm[i]->u.x.iField - 1; if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */ pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr); pOrigRhs->a[iField].pExpr = 0; @@ -142621,7 +146946,7 @@ static int codeEqualityTerm( } iTab = 0; - if( (pX->flags & EP_xIsSelect)==0 || pX->x.pSelect->pEList->nExpr==1 ){ + if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){ eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab); }else{ sqlite3 *db = pParse->db; @@ -142643,8 +146968,8 @@ static int codeEqualityTerm( sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0); VdbeCoverageIf(v, bRev); VdbeCoverageIf(v, !bRev); - assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 ); + assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 ); pLoop->wsFlags |= WHERE_IN_ABLE; if( pLevel->u.in.nIn==0 ){ pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse); @@ -142701,7 +147026,22 @@ static int codeEqualityTerm( sqlite3DbFree(pParse->db, aiMap); #endif } - disableTerm(pLevel, pTerm); + + /* As an optimization, try to disable the WHERE clause term that is + ** driving the index as it will always be true. The correct answer is + ** obtained regardless, but we might get the answer with fewer CPU cycles + ** by omitting the term. + ** + ** But do not disable the term unless we are certain that the term is + ** not a transitive constraint. For an example of where that does not + ** work, see https://sqlite.org/forum/forumpost/eb8613976a (2021-05-04) + */ + if( (pLevel->pWLoop->wsFlags & WHERE_TRANSCONS)==0 + || (pTerm->eOperator & WO_EQUIV)==0 + ){ + disableTerm(pLevel, pTerm); + } + return iReg; } @@ -142787,6 +147127,7 @@ static int codeAllEqualityTerms( if( nSkip ){ int iIdxCur = pLevel->iIdxCur; + sqlite3VdbeAddOp3(v, OP_Null, 0, regBase, regBase+nSkip-1); sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur); VdbeCoverageIf(v, bRev==0); VdbeCoverageIf(v, bRev!=0); @@ -142821,7 +147162,7 @@ static int codeAllEqualityTerms( sqlite3ReleaseTempReg(pParse, regBase); regBase = r1; }else{ - sqlite3VdbeAddOp2(v, OP_SCopy, r1, regBase+j); + sqlite3VdbeAddOp2(v, OP_Copy, r1, regBase+j); } } if( pTerm->eOperator & WO_IN ){ @@ -142838,7 +147179,7 @@ static int codeAllEqualityTerms( sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk); VdbeCoverage(v); } - if( zAff ){ + if( pParse->db->mallocFailed==0 && pParse->nErr==0 ){ if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){ zAff[j] = SQLITE_AFF_BLOB; } @@ -143001,7 +147342,7 @@ static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){ ** Insert an OP_CursorHint instruction if it is appropriate to do so. */ static void codeCursorHint( - struct SrcList_item *pTabItem, /* FROM clause item */ + SrcItem *pTabItem, /* FROM clause item */ WhereInfo *pWInfo, /* The where clause */ WhereLevel *pLevel, /* Which loop to provide hints for */ WhereTerm *pEndRange /* Hint this end-of-scan boundary term if not NULL */ @@ -143170,7 +147511,7 @@ static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){ assert( nReg>0 ); if( p && sqlite3ExprIsVector(p) ){ #ifndef SQLITE_OMIT_SUBQUERY - if( (p->flags & EP_xIsSelect) ){ + if( ExprUseXSelect(p) ){ Vdbe *v = pParse->pVdbe; int iSelect; assert( p->op==TK_SELECT ); @@ -143180,14 +147521,16 @@ static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){ #endif { int i; - ExprList *pList = p->x.pList; + const ExprList *pList; + assert( ExprUseXList(p) ); + pList = p->x.pList; assert( nReg<=pList->nExpr ); for(i=0; ia[i].pExpr, iReg+i); } } }else{ - assert( nReg==1 ); + assert( nReg==1 || pParse->nErr ); sqlite3ExprCode(pParse, p, iReg); } } @@ -143233,10 +147576,10 @@ static int whereIndexExprTransNode(Walker *p, Expr *pExpr){ pExpr->op = TK_COLUMN; pExpr->iTable = pX->iIdxCur; pExpr->iColumn = pX->iIdxCol; - pExpr->y.pTab = 0; testcase( ExprHasProperty(pExpr, EP_Skip) ); testcase( ExprHasProperty(pExpr, EP_Unlikely) ); - ExprClearProperty(pExpr, EP_Skip|EP_Unlikely); + ExprClearProperty(pExpr, EP_Skip|EP_Unlikely|EP_WinFunc|EP_Subrtn); + pExpr->y.pTab = 0; return WRC_Prune; }else{ return WRC_Continue; @@ -143251,7 +147594,7 @@ static int whereIndexExprTransColumn(Walker *p, Expr *pExpr){ if( pExpr->op==TK_COLUMN ){ IdxExprTrans *pX = p->u.pIdxTrans; if( pExpr->iTable==pX->iTabCur && pExpr->iColumn==pX->iTabCol ){ - assert( pExpr->y.pTab!=0 ); + assert( ExprUseYTab(pExpr) && pExpr->y.pTab!=0 ); preserveExpr(pX, pExpr); pExpr->affExpr = sqlite3TableColumnAffinity(pExpr->y.pTab,pExpr->iColumn); pExpr->iTable = pX->iIdxCur; @@ -143299,15 +147642,16 @@ static void whereIndexExprTrans( for(iIdxCol=0; iIdxColnColumn; iIdxCol++){ i16 iRef = pIdx->aiColumn[iIdxCol]; if( iRef==XN_EXPR ){ - assert( aColExpr->a[iIdxCol].pExpr!=0 ); + assert( aColExpr!=0 && aColExpr->a[iIdxCol].pExpr!=0 ); x.pIdxExpr = aColExpr->a[iIdxCol].pExpr; if( sqlite3ExprIsConstant(x.pIdxExpr) ) continue; w.xExprCallback = whereIndexExprTransNode; #ifndef SQLITE_OMIT_GENERATED_COLUMNS }else if( iRef>=0 && (pTab->aCol[iRef].colFlags & COLFLAG_VIRTUAL)!=0 - && (pTab->aCol[iRef].zColl==0 - || sqlite3StrICmp(pTab->aCol[iRef].zColl, sqlite3StrBINARY)==0) + && ((pTab->aCol[iRef].colFlags & COLFLAG_HASCOLL)==0 + || sqlite3StrICmp(sqlite3ColumnColl(&pTab->aCol[iRef]), + sqlite3StrBINARY)==0) ){ /* Check to see if there are direct references to generated columns ** that are contained in the index. Pulling the generated column @@ -143376,7 +147720,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( WhereClause *pWC; /* Decomposition of the entire WHERE clause */ WhereTerm *pTerm; /* A WHERE clause term */ sqlite3 *db; /* Database connection */ - struct SrcList_item *pTabItem; /* FROM clause term being coded */ + SrcItem *pTabItem; /* FROM clause term being coded */ int addrBrk; /* Jump here to break out of the loop */ int addrHalt; /* addrBrk for the outermost loop */ int addrCont; /* Jump here to continue with next cycle */ @@ -143487,7 +147831,12 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( pLevel->p1 = iCur; pLevel->op = pWInfo->eOnePass ? OP_Noop : OP_VNext; pLevel->p2 = sqlite3VdbeCurrentAddr(v); - iIn = pLevel->u.in.nIn; + assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 ); + if( pLoop->wsFlags & WHERE_IN_ABLE ){ + iIn = pLevel->u.in.nIn; + }else{ + iIn = 0; + } for(j=nConstraint-1; j>=0; j--){ pTerm = pLoop->aLTerm[j]; if( (pTerm->eOperator & WO_IN)!=0 ) iIn--; @@ -143564,9 +147913,6 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( sqlite3VdbeAddOp3(v, OP_SeekRowid, iCur, addrNxt, iRowidReg); VdbeCoverage(v); pLevel->op = OP_Noop; - if( (pTerm->prereqAll & pLevel->notReady)==0 ){ - pTerm->wtFlags |= TERM_CODED; - } }else if( (pLoop->wsFlags & WHERE_IPK)!=0 && (pLoop->wsFlags & WHERE_COLUMN_RANGE)!=0 ){ @@ -143814,14 +148160,18 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( ** a forward order scan on a descending index, interchange the ** start and end terms (pRangeStart and pRangeEnd). */ - if( (nEqnKeyCol && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC)) - || (bRev && pIdx->nKeyCol==nEq) - ){ + if( (nEqnColumn && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC)) ){ SWAP(WhereTerm *, pRangeEnd, pRangeStart); SWAP(u8, bSeekPastNull, bStopAtNull); SWAP(u8, nBtm, nTop); } + if( iLevel>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)!=0 ){ + /* In case OP_SeekScan is used, ensure that the index cursor does not + ** point to a valid row for the first iteration of this loop. */ + sqlite3VdbeAddOp1(v, OP_NullRow, iIdxCur); + } + /* Generate code to evaluate all constraint terms using == or IN ** and store the values of those terms in an array of registers ** starting at regBase. @@ -143933,8 +148283,19 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( ** range (if any). */ nConstraint = nEq; + assert( pLevel->p2==0 ); if( pRangeEnd ){ Expr *pRight = pRangeEnd->pExpr->pRight; + if( addrSeekScan ){ + /* For a seek-scan that has a range on the lowest term of the index, + ** we have to make the top of the loop be code that sets the end + ** condition of the range. Otherwise, the OP_SeekScan might jump + ** over that initialization, leaving the range-end value set to the + ** range-start value, resulting in a wrong answer. + ** See ticket 5981a8c041a3c2f3 (2021-11-02). + */ + pLevel->p2 = sqlite3VdbeCurrentAddr(v); + } codeExprOrVector(pParse, pRight, regBase+nEq, nTop); whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd); if( (pRangeEnd->wtFlags & TERM_VNULL)==0 @@ -143968,7 +148329,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( sqlite3DbFree(db, zEndAff); /* Top of the loop body */ - pLevel->p2 = sqlite3VdbeCurrentAddr(v); + if( pLevel->p2==0 ) pLevel->p2 = sqlite3VdbeCurrentAddr(v); /* Check if the index cursor is past the end of the range. */ if( nConstraint ){ @@ -144158,7 +148519,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( */ if( pWInfo->nLevel>1 ){ int nNotReady; /* The number of notReady tables */ - struct SrcList_item *origSrc; /* Original list of tables */ + SrcItem *origSrc; /* Original list of tables */ nNotReady = pWInfo->nLevel - iLevel - 1; pOrTab = sqlite3StackAllocRaw(db, sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0])); @@ -144231,7 +148592,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( /* The extra 0x10000 bit on the opcode is masked off and does not ** become part of the new Expr.op. However, it does make the ** op==TK_AND comparison inside of sqlite3PExpr() false, and this - ** prevents sqlite3PExpr() from implementing AND short-circuit + ** prevents sqlite3PExpr() from applying the AND short-circuit ** optimization, which we do not want here. */ pAndExpr = sqlite3PExpr(pParse, TK_AND|0x10000, 0, pAndExpr); } @@ -144247,10 +148608,16 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){ WhereInfo *pSubWInfo; /* Info for single OR-term scan */ Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */ + Expr *pDelete; /* Local copy of OR clause term */ int jmp1 = 0; /* Address of jump operation */ testcase( (pTabItem[0].fg.jointype & JT_LEFT)!=0 && !ExprHasProperty(pOrExpr, EP_FromJoin) ); /* See TH3 vtab25.400 and ticket 614b25314c766238 */ + pDelete = pOrExpr = sqlite3ExprDup(db, pOrExpr, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDelete); + continue; + } if( pAndExpr ){ pAndExpr->pLeft = pOrExpr; pOrExpr = pAndExpr; @@ -144365,10 +148732,14 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( sqlite3WhereEnd(pSubWInfo); ExplainQueryPlanPop(pParse); } + sqlite3ExprDelete(db, pDelete); } } ExplainQueryPlanPop(pParse); - pLevel->u.pCovidx = pCov; + assert( pLevel->pWLoop==pLoop ); + assert( (pLoop->wsFlags & WHERE_MULTI_OR)!=0 ); + assert( (pLoop->wsFlags & WHERE_IN_ABLE)==0 ); + pLevel->u.pCoveringIdx = pCov; if( pCov ) pLevel->iIdxCur = iCovCur; if( pAndExpr ){ pAndExpr->pLeft = 0; @@ -144512,12 +148883,13 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( #endif assert( !ExprHasProperty(pE, EP_FromJoin) ); assert( (pTerm->prereqRight & pLevel->notReady)!=0 ); + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.x.leftColumn, notReady, WO_EQ|WO_IN|WO_IS, 0); if( pAlt==0 ) continue; if( pAlt->wtFlags & (TERM_CODED) ) continue; if( (pAlt->eOperator & WO_IN) - && (pAlt->pExpr->flags & EP_xIsSelect) + && ExprUseXSelect(pAlt->pExpr) && (pAlt->pExpr->x.pSelect->pEList->nExpr>1) ){ continue; @@ -144529,6 +148901,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( sEAlt = *pAlt->pExpr; sEAlt.pLeft = pE->pLeft; sqlite3ExprIfFalse(pParse, &sEAlt, addrCont, SQLITE_JUMPIFNULL); + pAlt->wtFlags |= TERM_CODED; } /* For a LEFT OUTER JOIN, generate code that will record the fact that @@ -144765,6 +149138,7 @@ static int isLikeOrGlob( #ifdef SQLITE_EBCDIC if( *pnoCase ) return 0; #endif + assert( ExprUseXList(pExpr) ); pList = pExpr->x.pList; pLeft = pList->a[1].pExpr; @@ -144780,7 +149154,8 @@ static int isLikeOrGlob( sqlite3VdbeSetVarmask(pParse->pVdbe, iCol); assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER ); }else if( op==TK_STRING ){ - z = (u8*)pRight->u.zToken; + assert( !ExprHasProperty(pRight, EP_IntValue) ); + z = (u8*)pRight->u.zToken; } if( z ){ @@ -144809,7 +149184,9 @@ static int isLikeOrGlob( pPrefix = sqlite3Expr(db, TK_STRING, (char*)z); if( pPrefix ){ int iFrom, iTo; - char *zNew = pPrefix->u.zToken; + char *zNew; + assert( !ExprHasProperty(pPrefix, EP_IntValue) ); + zNew = pPrefix->u.zToken; zNew[cnt] = 0; for(iFrom=iTo=0; iFromop!=TK_COLUMN || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT - || IsVirtual(pLeft->y.pTab) /* Value might be numeric */ + || (ALWAYS( ExprUseYTab(pLeft) ) + && pLeft->y.pTab + && IsVirtual(pLeft->y.pTab)) /* Might be numeric */ ){ int isNum; double rDummy; @@ -144861,6 +149240,7 @@ static int isLikeOrGlob( if( op==TK_VARIABLE ){ Vdbe *v = pParse->pVdbe; sqlite3VdbeSetVarmask(v, pRight->iColumn); + assert( !ExprHasProperty(pRight, EP_IntValue) ); if( *pisComplete && pRight->u.zToken[1] ){ /* If the rhs of the LIKE expression is a variable, and the current ** value of the variable means there is no need to invoke the LIKE @@ -144934,6 +149314,7 @@ static int isAuxiliaryVtabOperator( Expr *pCol; /* Column reference */ int i; + assert( ExprUseXList(pExpr) ); pList = pExpr->x.pList; if( pList==0 || pList->nExpr!=2 ){ return 0; @@ -144947,9 +149328,11 @@ static int isAuxiliaryVtabOperator( ** MATCH(expression,vtab_column) */ pCol = pList->a[1].pExpr; + assert( pCol->op!=TK_COLUMN || ExprUseYTab(pCol) ); testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 ); if( ExprIsVtab(pCol) ){ for(i=0; iu.zToken, aOp[i].zOp)==0 ){ *peOp2 = aOp[i].eOp2; *ppRight = pList->a[0].pExpr; @@ -144970,6 +149353,7 @@ static int isAuxiliaryVtabOperator( ** with function names in an arbitrary case. */ pCol = pList->a[0].pExpr; + assert( pCol->op!=TK_COLUMN || ExprUseYTab(pCol) ); testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 ); if( ExprIsVtab(pCol) ){ sqlite3_vtab *pVtab; @@ -144979,7 +149363,8 @@ static int isAuxiliaryVtabOperator( pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab; assert( pVtab!=0 ); assert( pVtab->pModule!=0 ); - pMod = (sqlite3_module *)pVtab->pModule; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pMod = (sqlite3_module *)pVtab->pModule; if( pMod->xFindFunction!=0 ){ i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed); if( i>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){ @@ -144994,10 +149379,12 @@ static int isAuxiliaryVtabOperator( int res = 0; Expr *pLeft = pExpr->pLeft; Expr *pRight = pExpr->pRight; + assert( pLeft->op!=TK_COLUMN || ExprUseYTab(pLeft) ); testcase( pLeft->op==TK_COLUMN && pLeft->y.pTab==0 ); if( ExprIsVtab(pLeft) ){ res++; } + assert( pRight==0 || pRight->op!=TK_COLUMN || ExprUseYTab(pRight) ); testcase( pRight && pRight->op==TK_COLUMN && pRight->y.pTab==0 ); if( pRight && ExprIsVtab(pRight) ){ res++; @@ -145081,6 +149468,7 @@ static void whereCombineDisjuncts( int op; /* Operator for the combined expression */ int idxNew; /* Index in pWC of the next virtual term */ + if( (pOne->wtFlags | pTwo->wtFlags) & TERM_VNULL ) return; if( (pOne->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return; if( (pTwo->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return; if( (eOp & (WO_EQ|WO_LT|WO_LE))!=eOp @@ -145249,6 +149637,7 @@ static void exprAnalyzeOrTerm( pOrTerm->u.pAndInfo = pAndInfo; pOrTerm->wtFlags |= TERM_ANDINFO; pOrTerm->eOperator = WO_AND; + pOrTerm->leftCursor = -1; pAndWC = &pAndInfo->wc; memset(pAndWC->aStatic, 0, sizeof(pAndWC->aStatic)); sqlite3WhereClauseInit(pAndWC, pWC->pWInfo); @@ -145291,11 +149680,10 @@ static void exprAnalyzeOrTerm( ** empty. */ pOrInfo->indexable = indexable; + pTerm->eOperator = WO_OR; + pTerm->leftCursor = -1; if( indexable ){ - pTerm->eOperator = WO_OR; pWC->hasOr = 1; - }else{ - pTerm->eOperator = WO_OR; } /* For a two-way OR, attempt to implementation case 2. @@ -145368,6 +149756,7 @@ static void exprAnalyzeOrTerm( assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) ); continue; } + assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 ); iColumn = pOrTerm->u.x.leftColumn; iCursor = pOrTerm->leftCursor; pLeft = pOrTerm->pExpr->pLeft; @@ -145388,6 +149777,7 @@ static void exprAnalyzeOrTerm( okToChngToIN = 1; for(; i>=0 && okToChngToIN; i--, pOrTerm++){ assert( pOrTerm->eOperator & WO_EQ ); + assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 ); if( pOrTerm->leftCursor!=iCursor ){ pOrTerm->wtFlags &= ~TERM_OR_OK; }else if( pOrTerm->u.x.leftColumn!=iColumn || (iColumn==XN_EXPR @@ -145424,6 +149814,7 @@ static void exprAnalyzeOrTerm( for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){ if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue; assert( pOrTerm->eOperator & WO_EQ ); + assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 ); assert( pOrTerm->leftCursor==iCursor ); assert( pOrTerm->u.x.leftColumn==iColumn ); pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0); @@ -145436,12 +149827,12 @@ static void exprAnalyzeOrTerm( if( pNew ){ int idxNew; transferJoinMarkings(pNew, pExpr); - assert( !ExprHasProperty(pNew, EP_xIsSelect) ); + assert( ExprUseXList(pNew) ); pNew->x.pList = pList; idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC); testcase( idxNew==0 ); exprAnalyze(pSrc, pWC, idxNew); - /* pTerm = &pWC->a[idxTerm]; // would be needed if pTerm where used again */ + /* pTerm = &pWC->a[idxTerm]; // would be needed if pTerm where reused */ markTermAsChild(pWC, idxNew, idxTerm); }else{ sqlite3ExprListDelete(db, pList); @@ -145564,7 +149955,9 @@ static int exprMightBeIndexed( assert( TK_ISop==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){ + assert( ExprUseXList(pExpr) ); pExpr = pExpr->x.pList->a[0].pExpr; + } if( pExpr->op==TK_COLUMN ){ @@ -145577,6 +149970,7 @@ static int exprMightBeIndexed( return exprMightBeIndexed2(pFrom,mPrereq,aiCurCol,pExpr); } + /* ** The input to this routine is an WhereTerm structure with only the ** "pExpr" field filled in. The job of this routine is to analyze the @@ -145628,7 +150022,7 @@ static void exprAnalyze( if( op==TK_IN ){ assert( pExpr->pRight==0 ); if( sqlite3ExprCheckIN(pParse, pExpr) ) return; - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( ExprUseXSelect(pExpr) ){ pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect); }else{ pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList); @@ -145664,17 +150058,20 @@ static void exprAnalyze( if( pTerm->u.x.iField>0 ){ assert( op==TK_IN ); assert( pLeft->op==TK_VECTOR ); + assert( ExprUseXList(pLeft) ); pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr; } if( exprMightBeIndexed(pSrc, prereqLeft, aiCurCol, pLeft, op) ){ pTerm->leftCursor = aiCurCol[0]; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); pTerm->u.x.leftColumn = aiCurCol[1]; pTerm->eOperator = operatorMask(op) & opMask; } if( op==TK_IS ) pTerm->wtFlags |= TERM_IS; if( pRight && exprMightBeIndexed(pSrc, pTerm->prereqRight, aiCurCol, pRight, op) + && !ExprHasProperty(pRight, EP_FixedCol) ){ WhereTerm *pNew; Expr *pDup; @@ -145705,11 +150102,23 @@ static void exprAnalyze( } pNew->wtFlags |= exprCommute(pParse, pDup); pNew->leftCursor = aiCurCol[0]; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); pNew->u.x.leftColumn = aiCurCol[1]; testcase( (prereqLeft | extraRight) != prereqLeft ); pNew->prereqRight = prereqLeft | extraRight; pNew->prereqAll = prereqAll; pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask; + }else + if( op==TK_ISNULL + && !ExprHasProperty(pExpr,EP_FromJoin) + && 0==sqlite3ExprCanBeNull(pLeft) + ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pExpr->op = TK_TRUEFALSE; + pExpr->u.zToken = "false"; + ExprSetProperty(pExpr, EP_IsFalse); + pTerm->prereqAll = 0; + pTerm->eOperator = 0; } } @@ -145730,9 +150139,11 @@ static void exprAnalyze( ** BETWEEN term is skipped. */ else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){ - ExprList *pList = pExpr->x.pList; + ExprList *pList; int i; static const u8 ops[] = {TK_GE, TK_LE}; + assert( ExprUseXList(pExpr) ); + pList = pExpr->x.pList; assert( pList!=0 ); assert( pList->nExpr==2 ); for(i=0; i<2; i++){ @@ -145761,6 +150172,42 @@ static void exprAnalyze( pTerm = &pWC->a[idxTerm]; } #endif /* SQLITE_OMIT_OR_OPTIMIZATION */ + /* The form "x IS NOT NULL" can sometimes be evaluated more efficiently + ** as "x>NULL" if x is not an INTEGER PRIMARY KEY. So construct a + ** virtual term of that form. + ** + ** The virtual term must be tagged with TERM_VNULL. + */ + else if( pExpr->op==TK_NOTNULL ){ + if( pExpr->pLeft->op==TK_COLUMN + && pExpr->pLeft->iColumn>=0 + && !ExprHasProperty(pExpr, EP_FromJoin) + ){ + Expr *pNewExpr; + Expr *pLeft = pExpr->pLeft; + int idxNew; + WhereTerm *pNewTerm; + + pNewExpr = sqlite3PExpr(pParse, TK_GT, + sqlite3ExprDup(db, pLeft, 0), + sqlite3ExprAlloc(db, TK_NULL, 0, 0)); + + idxNew = whereClauseInsert(pWC, pNewExpr, + TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL); + if( idxNew ){ + pNewTerm = &pWC->a[idxNew]; + pNewTerm->prereqRight = 0; + pNewTerm->leftCursor = pLeft->iTable; + pNewTerm->u.x.leftColumn = pLeft->iColumn; + pNewTerm->eOperator = WO_GT; + markTermAsChild(pWC, idxNew, idxTerm); + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + pNewTerm->prereqAll = pTerm->prereqAll; + } + } + } + #ifndef SQLITE_OMIT_LIKE_OPTIMIZATION /* Add constraints to reduce the search space on a LIKE or GLOB @@ -145776,7 +150223,8 @@ static void exprAnalyze( ** bound is made all lowercase so that the bounds also work when comparing ** BLOBs. */ - if( pWC->op==TK_AND + else if( pExpr->op==TK_FUNCTION + && pWC->op==TK_AND && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase) ){ Expr *pLeft; /* LHS of LIKE/GLOB operator */ @@ -145788,8 +150236,12 @@ static void exprAnalyze( const char *zCollSeqName; /* Name of collating sequence */ const u16 wtFlags = TERM_LIKEOPT | TERM_VIRTUAL | TERM_DYNAMIC; + assert( ExprUseXList(pExpr) ); pLeft = pExpr->x.pList->a[1].pExpr; pStr2 = sqlite3ExprDup(db, pStr1, 0); + assert( pStr1==0 || !ExprHasProperty(pStr1, EP_IntValue) ); + assert( pStr2==0 || !ExprHasProperty(pStr2, EP_IntValue) ); + /* Convert the lower bound to upper-case and the upper bound to ** lower-case (upper-case is less than lower-case in ASCII) so that @@ -145846,52 +150298,6 @@ static void exprAnalyze( } #endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */ -#ifndef SQLITE_OMIT_VIRTUALTABLE - /* Add a WO_AUX auxiliary term to the constraint set if the - ** current expression is of the form "column OP expr" where OP - ** is an operator that gets passed into virtual tables but which is - ** not normally optimized for ordinary tables. In other words, OP - ** is one of MATCH, LIKE, GLOB, REGEXP, !=, IS, IS NOT, or NOT NULL. - ** This information is used by the xBestIndex methods of - ** virtual tables. The native query optimizer does not attempt - ** to do anything with MATCH functions. - */ - if( pWC->op==TK_AND ){ - Expr *pRight = 0, *pLeft = 0; - int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight); - while( res-- > 0 ){ - int idxNew; - WhereTerm *pNewTerm; - Bitmask prereqColumn, prereqExpr; - - prereqExpr = sqlite3WhereExprUsage(pMaskSet, pRight); - prereqColumn = sqlite3WhereExprUsage(pMaskSet, pLeft); - if( (prereqExpr & prereqColumn)==0 ){ - Expr *pNewExpr; - pNewExpr = sqlite3PExpr(pParse, TK_MATCH, - 0, sqlite3ExprDup(db, pRight, 0)); - if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){ - ExprSetProperty(pNewExpr, EP_FromJoin); - pNewExpr->iRightJoinTable = pExpr->iRightJoinTable; - } - idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC); - testcase( idxNew==0 ); - pNewTerm = &pWC->a[idxNew]; - pNewTerm->prereqRight = prereqExpr; - pNewTerm->leftCursor = pLeft->iTable; - pNewTerm->u.x.leftColumn = pLeft->iColumn; - pNewTerm->eOperator = WO_AUX; - pNewTerm->eMatchOp = eOp2; - markTermAsChild(pWC, idxNew, idxTerm); - pTerm = &pWC->a[idxTerm]; - pTerm->wtFlags |= TERM_COPIED; - pNewTerm->prereqAll = pTerm->prereqAll; - } - SWAP(Expr*, pLeft, pRight); - } - } -#endif /* SQLITE_OMIT_VIRTUALTABLE */ - /* If there is a vector == or IS term - e.g. "(a, b) == (?, ?)" - create ** new terms for each component comparison - "a = ?" and "b = ?". The ** new terms completely replace the original vector comparison, which is @@ -145899,19 +150305,19 @@ static void exprAnalyze( ** ** This is only required if at least one side of the comparison operation ** is not a sub-select. */ - if( pWC->op==TK_AND - && (pExpr->op==TK_EQ || pExpr->op==TK_IS) - && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1 - && sqlite3ExprVectorSize(pExpr->pRight)==nLeft - && ( (pExpr->pLeft->flags & EP_xIsSelect)==0 - || (pExpr->pRight->flags & EP_xIsSelect)==0) + if( (pExpr->op==TK_EQ || pExpr->op==TK_IS) + && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1 + && sqlite3ExprVectorSize(pExpr->pRight)==nLeft + && ( (pExpr->pLeft->flags & EP_xIsSelect)==0 + || (pExpr->pRight->flags & EP_xIsSelect)==0) + && pWC->op==TK_AND ){ int i; for(i=0; ipLeft, i); - Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i); + Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i, nLeft); + Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft); pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight); transferJoinMarkings(pNew, pExpr); @@ -145932,12 +150338,15 @@ static void exprAnalyze( ** This only works if the RHS is a simple SELECT (not a compound) that does ** not use window functions. */ - if( pWC->op==TK_AND && pExpr->op==TK_IN && pTerm->u.x.iField==0 + else if( pExpr->op==TK_IN + && pTerm->u.x.iField==0 && pExpr->pLeft->op==TK_VECTOR + && ALWAYS( ExprUseXSelect(pExpr) ) && pExpr->x.pSelect->pPrior==0 #ifndef SQLITE_OMIT_WINDOWFUNC && pExpr->x.pSelect->pWin==0 #endif + && pWC->op==TK_AND ){ int i; for(i=0; ipLeft); i++){ @@ -145949,44 +150358,51 @@ static void exprAnalyze( } } -#ifdef SQLITE_ENABLE_STAT4 - /* When sqlite_stat4 histogram data is available an operator of the - ** form "x IS NOT NULL" can sometimes be evaluated more efficiently - ** as "x>NULL" if x is not an INTEGER PRIMARY KEY. So construct a - ** virtual term of that form. - ** - ** Note that the virtual term must be tagged with TERM_VNULL. +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Add a WO_AUX auxiliary term to the constraint set if the + ** current expression is of the form "column OP expr" where OP + ** is an operator that gets passed into virtual tables but which is + ** not normally optimized for ordinary tables. In other words, OP + ** is one of MATCH, LIKE, GLOB, REGEXP, !=, IS, IS NOT, or NOT NULL. + ** This information is used by the xBestIndex methods of + ** virtual tables. The native query optimizer does not attempt + ** to do anything with MATCH functions. */ - if( pExpr->op==TK_NOTNULL - && pExpr->pLeft->op==TK_COLUMN - && pExpr->pLeft->iColumn>=0 - && !ExprHasProperty(pExpr, EP_FromJoin) - && OptimizationEnabled(db, SQLITE_Stat4) - ){ - Expr *pNewExpr; - Expr *pLeft = pExpr->pLeft; - int idxNew; - WhereTerm *pNewTerm; - - pNewExpr = sqlite3PExpr(pParse, TK_GT, - sqlite3ExprDup(db, pLeft, 0), - sqlite3ExprAlloc(db, TK_NULL, 0, 0)); - - idxNew = whereClauseInsert(pWC, pNewExpr, - TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL); - if( idxNew ){ - pNewTerm = &pWC->a[idxNew]; - pNewTerm->prereqRight = 0; - pNewTerm->leftCursor = pLeft->iTable; - pNewTerm->u.x.leftColumn = pLeft->iColumn; - pNewTerm->eOperator = WO_GT; - markTermAsChild(pWC, idxNew, idxTerm); - pTerm = &pWC->a[idxTerm]; - pTerm->wtFlags |= TERM_COPIED; - pNewTerm->prereqAll = pTerm->prereqAll; + else if( pWC->op==TK_AND ){ + Expr *pRight = 0, *pLeft = 0; + int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight); + while( res-- > 0 ){ + int idxNew; + WhereTerm *pNewTerm; + Bitmask prereqColumn, prereqExpr; + + prereqExpr = sqlite3WhereExprUsage(pMaskSet, pRight); + prereqColumn = sqlite3WhereExprUsage(pMaskSet, pLeft); + if( (prereqExpr & prereqColumn)==0 ){ + Expr *pNewExpr; + pNewExpr = sqlite3PExpr(pParse, TK_MATCH, + 0, sqlite3ExprDup(db, pRight, 0)); + if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){ + ExprSetProperty(pNewExpr, EP_FromJoin); + pNewExpr->iRightJoinTable = pExpr->iRightJoinTable; + } + idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + pNewTerm = &pWC->a[idxNew]; + pNewTerm->prereqRight = prereqExpr; + pNewTerm->leftCursor = pLeft->iTable; + pNewTerm->u.x.leftColumn = pLeft->iColumn; + pNewTerm->eOperator = WO_AUX; + pNewTerm->eMatchOp = eOp2; + markTermAsChild(pWC, idxNew, idxTerm); + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + pNewTerm->prereqAll = pTerm->prereqAll; + } + SWAP(Expr*, pLeft, pRight); } } -#endif /* SQLITE_ENABLE_STAT4 */ +#endif /* SQLITE_OMIT_VIRTUALTABLE */ /* Prevent ON clause terms of a LEFT JOIN from being used to drive ** an index for tables to the left of the join. @@ -146089,14 +150505,15 @@ SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet *pMaskSet, Expr *p){ if( p->pRight ){ mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight); assert( p->x.pList==0 ); - }else if( ExprHasProperty(p, EP_xIsSelect) ){ + }else if( ExprUseXSelect(p) ){ if( ExprHasProperty(p, EP_VarSelect) ) pMaskSet->bVarSelect = 1; mask |= exprSelectUsage(pMaskSet, p->x.pSelect); }else if( p->x.pList ){ mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList); } #ifndef SQLITE_OMIT_WINDOWFUNC - if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && p->y.pWin ){ + if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && ExprUseYWin(p) ){ + assert( p->y.pWin!=0 ); mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition); mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pOrderBy); mask |= sqlite3WhereExprUsage(pMaskSet, p->y.pWin->pFilter); @@ -146146,7 +150563,7 @@ SQLITE_PRIVATE void sqlite3WhereExprAnalyze( */ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs( Parse *pParse, /* Parsing context */ - struct SrcList_item *pItem, /* The FROM clause term to process */ + SrcItem *pItem, /* The FROM clause term to process */ WhereClause *pWC /* Xfer function arguments to here */ ){ Table *pTab; @@ -146171,6 +150588,7 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs( if( pColRef==0 ) return; pColRef->iTable = pItem->iCursor; pColRef->iColumn = k++; + assert( ExprUseYTab(pColRef) ); pColRef->y.pTab = pTab; pRhs = sqlite3PExpr(pParse, TK_UPLUS, sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0); @@ -146223,12 +150641,6 @@ struct HiddenIndexInfo { /* Forward declaration of methods */ static int whereLoopResize(sqlite3*, WhereLoop*, int); -/* Test variable that can be set to enable WHERE tracing */ -#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) -/***/ int sqlite3WhereTrace = 0; -#endif - - /* ** Return the estimated number of output rows from a WHERE clause */ @@ -146291,6 +150703,32 @@ SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo *pWInfo){ return pInner->addrNxt; } +/* +** While generating code for the min/max optimization, after handling +** the aggregate-step call to min() or max(), check to see if any +** additional looping is required. If the output order is such that +** we are certain that the correct answer has already been found, then +** code an OP_Goto to by pass subsequent processing. +** +** Any extra OP_Goto that is coded here is an optimization. The +** correct answer should be obtained regardless. This OP_Goto just +** makes the answer appear faster. +*/ +SQLITE_PRIVATE void sqlite3WhereMinMaxOptEarlyOut(Vdbe *v, WhereInfo *pWInfo){ + WhereLevel *pInner; + int i; + if( !pWInfo->bOrderedInnerLoop ) return; + if( pWInfo->nOBSat==0 ) return; + for(i=pWInfo->nLevel-1; i>=0; i--){ + pInner = &pWInfo->a[i]; + if( (pInner->pWLoop->wsFlags & WHERE_COLUMN_IN)!=0 ){ + sqlite3VdbeGoto(v, pInner->addrNxt); + return; + } + } + sqlite3VdbeGoto(v, pWInfo->iBreak); +} + /* ** Return the VDBE address or label to jump to in order to continue ** immediately with the next row of a WHERE clause. @@ -146427,7 +150865,9 @@ static void createMask(WhereMaskSet *pMaskSet, int iCursor){ */ static Expr *whereRightSubexprIsColumn(Expr *p){ p = sqlite3ExprSkipCollateAndLikely(p->pRight); - if( ALWAYS(p!=0) && p->op==TK_COLUMN ) return p; + if( ALWAYS(p!=0) && p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){ + return p; + } return 0; } @@ -146450,8 +150890,10 @@ static WhereTerm *whereScanNext(WhereScan *pScan){ iColumn = pScan->aiColumn[pScan->iEquiv-1]; iCur = pScan->aiCur[pScan->iEquiv-1]; assert( pWC!=0 ); + assert( iCur>=0 ); do{ for(pTerm=pWC->a+k; knTerm; k++, pTerm++){ + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 || pTerm->leftCursor<0 ); if( pTerm->leftCursor==iCur && pTerm->u.x.leftColumn==iColumn && (iColumn!=XN_EXPR @@ -146493,7 +150935,8 @@ static WhereTerm *whereScanNext(WhereScan *pScan){ } } if( (pTerm->eOperator & (WO_EQ|WO_IS))!=0 - && (pX = pTerm->pExpr->pRight)->op==TK_COLUMN + && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0)) + && pX->op==TK_COLUMN && pX->iTable==pScan->aiCur[0] && pX->iColumn==pScan->aiColumn[0] ){ @@ -146502,6 +150945,18 @@ static WhereTerm *whereScanNext(WhereScan *pScan){ } pScan->pWC = pWC; pScan->k = k+1; +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace & 0x20000 ){ + int ii; + sqlite3DebugPrintf("SCAN-TERM %p: nEquiv=%d", + pTerm, pScan->nEquiv); + for(ii=0; iinEquiv; ii++){ + sqlite3DebugPrintf(" {%d:%d}", + pScan->aiCur[ii], pScan->aiColumn[ii]); + } + sqlite3DebugPrintf("\n"); + } +#endif return pTerm; } } @@ -146658,7 +151113,7 @@ static int findIndexCol( for(i=0; inExpr; i++){ Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr); if( ALWAYS(p!=0) - && p->op==TK_COLUMN + && (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN) && p->iColumn==pIdx->aiColumn[iCol] && p->iTable==iBase ){ @@ -146723,7 +151178,8 @@ static int isDistinctRedundant( for(i=0; inExpr; i++){ Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr); if( NEVER(p==0) ) continue; - if( p->op==TK_COLUMN && p->iTable==iBase && p->iColumn<0 ) return 1; + if( p->op!=TK_COLUMN && p->op!=TK_AGG_COLUMN ) continue; + if( p->iTable==iBase && p->iColumn<0 ) return 1; } /* Loop through all indices on the table, checking each to see if it makes @@ -146741,6 +151197,7 @@ static int isDistinctRedundant( */ for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ if( !IsUniqueIndex(pIdx) ) continue; + if( pIdx->pPartIdxWhere ) continue; for(i=0; inKeyCol; i++){ if( 0==sqlite3WhereFindTerm(pWC, iBase, i, ~(Bitmask)0, WO_EQ, pIdx) ){ if( findIndexCol(pParse, pDistinct, iBase, pIdx, i)<0 ) break; @@ -146795,14 +151252,14 @@ static void translateColumnToCopy( pOp->p2 = pOp->p3; pOp->p3 = 0; }else if( pOp->opcode==OP_Rowid ){ - if( iAutoidxCur ){ - pOp->opcode = OP_Sequence; - pOp->p1 = iAutoidxCur; - }else{ + pOp->opcode = OP_Sequence; + pOp->p1 = iAutoidxCur; +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW + if( iAutoidxCur==0 ){ pOp->opcode = OP_Null; - pOp->p1 = 0; pOp->p3 = 0; } +#endif } } } @@ -146860,7 +151317,7 @@ static void whereTraceIndexInfoOutputs(sqlite3_index_info *p){ */ static int termCanDriveIndex( WhereTerm *pTerm, /* WHERE clause term to check */ - struct SrcList_item *pSrc, /* Table we are trying to access */ + SrcItem *pSrc, /* Table we are trying to access */ Bitmask notReady /* Tables in outer loops of the join */ ){ char aff; @@ -146876,6 +151333,7 @@ static int termCanDriveIndex( return 0; } if( (pTerm->prereqRight & notReady)!=0 ) return 0; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); if( pTerm->u.x.leftColumn<0 ) return 0; aff = pSrc->pTab->aCol[pTerm->u.x.leftColumn].affinity; if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0; @@ -146894,7 +151352,7 @@ static int termCanDriveIndex( static void constructAutomaticIndex( Parse *pParse, /* The parsing context */ WhereClause *pWC, /* The WHERE clause */ - struct SrcList_item *pSrc, /* The FROM clause term to get the next index */ + SrcItem *pSrc, /* The FROM clause term to get the next index */ Bitmask notReady, /* Mask of cursors that are not available */ WhereLevel *pLevel /* Write new index here */ ){ @@ -146918,7 +151376,7 @@ static void constructAutomaticIndex( u8 sentWarning = 0; /* True if a warnning has been issued */ Expr *pPartial = 0; /* Partial Index Expression */ int iContinue = 0; /* Jump here to skip excluded rows */ - struct SrcList_item *pTabItem; /* FROM clause term being indexed */ + SrcItem *pTabItem; /* FROM clause term being indexed */ int addrCounter = 0; /* Address where integer counter is initialized */ int regBase; /* Array of registers where record is assembled */ @@ -146948,14 +151406,17 @@ static void constructAutomaticIndex( sqlite3ExprDup(pParse->db, pExpr, 0)); } if( termCanDriveIndex(pTerm, pSrc, notReady) ){ - int iCol = pTerm->u.x.leftColumn; - Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); + int iCol; + Bitmask cMask; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); + iCol = pTerm->u.x.leftColumn; + cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); testcase( iCol==BMS ); testcase( iCol==BMS-1 ); if( !sentWarning ){ sqlite3_log(SQLITE_WARNING_AUTOINDEX, "automatic index on %s(%s)", pTable->zName, - pTable->aCol[iCol].zName); + pTable->aCol[iCol].zCnName); sentWarning = 1; } if( (idxCols & cMask)==0 ){ @@ -146967,7 +151428,7 @@ static void constructAutomaticIndex( } } } - assert( nKeyCol>0 ); + assert( nKeyCol>0 || pParse->db->mallocFailed ); pLoop->u.btree.nEq = pLoop->nLTerm = nKeyCol; pLoop->wsFlags = WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WHERE_INDEXED | WHERE_AUTO_INDEX; @@ -147001,8 +151462,11 @@ static void constructAutomaticIndex( idxCols = 0; for(pTerm=pWC->a; pTermu.x.leftColumn; - Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); + int iCol; + Bitmask cMask; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); + iCol = pTerm->u.x.leftColumn; + cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); testcase( iCol==BMS-1 ); testcase( iCol==BMS ); if( (idxCols & cMask)==0 ){ @@ -147102,7 +151566,7 @@ static sqlite3_index_info *allocateIndexInfo( Parse *pParse, /* The parsing context */ WhereClause *pWC, /* The WHERE clause being analyzed */ Bitmask mUnusable, /* Ignore terms with these prereqs */ - struct SrcList_item *pSrc, /* The FROM clause term that is the vtab */ + SrcItem *pSrc, /* The FROM clause term that is the vtab */ ExprList *pOrderBy, /* The ORDER BY clause */ u16 *pmNoOmit /* Mask of terms not to omit */ ){ @@ -147129,6 +151593,7 @@ static sqlite3_index_info *allocateIndexInfo( testcase( pTerm->eOperator & WO_ALL ); if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue; if( pTerm->wtFlags & TERM_VNULL ) continue; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); assert( pTerm->u.x.leftColumn>=(-1) ); nTerm++; } @@ -147189,6 +151654,7 @@ static sqlite3_index_info *allocateIndexInfo( ){ continue; } + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); assert( pTerm->u.x.leftColumn>=(-1) ); pIdxCons[j].iColumn = pTerm->u.x.leftColumn; pIdxCons[j].iTermOffset = i; @@ -147952,6 +152418,7 @@ SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm){ if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) zType[2] = 'L'; if( pTerm->wtFlags & TERM_CODED ) zType[3] = 'C'; if( pTerm->eOperator & WO_SINGLE ){ + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); sqlite3_snprintf(sizeof(zLeft),zLeft,"left={%d:%d}", pTerm->leftCursor, pTerm->u.x.leftColumn); }else if( (pTerm->eOperator & WO_OR)!=0 && pTerm->u.pOrInfo!=0 ){ @@ -147969,7 +152436,7 @@ SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm){ sqlite3DebugPrintf(" prob=%-3d prereq=%llx,%llx", pTerm->truthProb, (u64)pTerm->prereqAll, (u64)pTerm->prereqRight); } - if( pTerm->u.x.iField ){ + if( (pTerm->eOperator & (WO_OR|WO_AND))==0 && pTerm->u.x.iField ){ sqlite3DebugPrintf(" iField=%d", pTerm->u.x.iField); } if( pTerm->iParent>=0 ){ @@ -148000,7 +152467,7 @@ SQLITE_PRIVATE void sqlite3WhereClausePrint(WhereClause *pWC){ SQLITE_PRIVATE void sqlite3WhereLoopPrint(WhereLoop *p, WhereClause *pWC){ WhereInfo *pWInfo = pWC->pWInfo; int nb = 1+(pWInfo->pTabList->nSrc+3)/4; - struct SrcList_item *pItem = pWInfo->pTabList->a + p->iTab; + SrcItem *pItem = pWInfo->pTabList->a + p->iTab; Table *pTab = pItem->pTab; Bitmask mAll = (((Bitmask)1)<<(nb*4)) - 1; sqlite3DebugPrintf("%c%2d.%0*llx.%0*llx", p->cId, @@ -148104,7 +152571,7 @@ static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){ static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){ whereLoopClearUnion(db, pTo); if( whereLoopResize(db, pTo, pFrom->nLTerm) ){ - memset(&pTo->u, 0, sizeof(pTo->u)); + memset(pTo, 0, WHERE_LOOP_XFER_SZ); return SQLITE_NOMEM_BKPT; } memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ); @@ -148133,7 +152600,8 @@ static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){ assert( pWInfo!=0 ); for(i=0; inLevel; i++){ WhereLevel *pLevel = &pWInfo->a[i]; - if( pLevel->pWLoop && (pLevel->pWLoop->wsFlags & WHERE_IN_ABLE) ){ + if( pLevel->pWLoop && (pLevel->pWLoop->wsFlags & WHERE_IN_ABLE)!=0 ){ + assert( (pLevel->pWLoop->wsFlags & WHERE_MULTI_OR)==0 ); sqlite3DbFree(db, pLevel->u.in.aInLoop); } } @@ -148147,10 +152615,22 @@ static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){ sqlite3DbFreeNN(db, pWInfo); } +/* Undo all Expr node modifications +*/ +static void whereUndoExprMods(WhereInfo *pWInfo){ + while( pWInfo->pExprMods ){ + WhereExprMod *p = pWInfo->pExprMods; + pWInfo->pExprMods = p->pNext; + memcpy(p->pExpr, &p->orig, sizeof(p->orig)); + sqlite3DbFree(pWInfo->pParse->db, p); + } +} + /* ** Return TRUE if all of the following are true: ** -** (1) X has the same or lower cost that Y +** (1) X has the same or lower cost, or returns the same or fewer rows, +** than Y. ** (2) X uses fewer WHERE clause terms than Y ** (3) Every WHERE clause term used by X is also used by Y ** (4) X skips at least as many columns as Y @@ -148173,11 +152653,8 @@ static int whereLoopCheaperProperSubset( if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){ return 0; /* X is not a subset of Y */ } + if( pX->rRun>pY->rRun && pX->nOut>pY->nOut ) return 0; if( pY->nSkip > pX->nSkip ) return 0; - if( pX->rRun >= pY->rRun ){ - if( pX->rRun > pY->rRun ) return 0; /* X costs more than Y */ - if( pX->nOut > pY->nOut ) return 0; /* X costs more than Y */ - } for(i=pX->nLTerm-1; i>=0; i--){ if( pX->aLTerm[i]==0 ) continue; for(j=pY->nLTerm-1; j>=0; j--){ @@ -148193,8 +152670,8 @@ static int whereLoopCheaperProperSubset( } /* -** Try to adjust the cost of WhereLoop pTemplate upwards or downwards so -** that: +** Try to adjust the cost and number of output rows of WhereLoop pTemplate +** upwards or downwards so that: ** ** (1) pTemplate costs less than any other WhereLoops that are a proper ** subset of pTemplate @@ -148215,16 +152692,20 @@ static void whereLoopAdjustCost(const WhereLoop *p, WhereLoop *pTemplate){ /* Adjust pTemplate cost downward so that it is cheaper than its ** subset p. */ WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n", - pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut-1)); - pTemplate->rRun = p->rRun; - pTemplate->nOut = p->nOut - 1; + pTemplate->rRun, pTemplate->nOut, + MIN(p->rRun, pTemplate->rRun), + MIN(p->nOut - 1, pTemplate->nOut))); + pTemplate->rRun = MIN(p->rRun, pTemplate->rRun); + pTemplate->nOut = MIN(p->nOut - 1, pTemplate->nOut); }else if( whereLoopCheaperProperSubset(pTemplate, p) ){ /* Adjust pTemplate cost upward so that it is costlier than p since ** pTemplate is a proper subset of p */ WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n", - pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut+1)); - pTemplate->rRun = p->rRun; - pTemplate->nOut = p->nOut + 1; + pTemplate->rRun, pTemplate->nOut, + MAX(p->rRun, pTemplate->rRun), + MAX(p->nOut + 1, pTemplate->nOut))); + pTemplate->rRun = MAX(p->rRun, pTemplate->rRun); + pTemplate->nOut = MAX(p->nOut + 1, pTemplate->nOut); } } } @@ -148555,9 +153036,12 @@ static int whereRangeVectorLen( char aff; /* Comparison affinity */ char idxaff = 0; /* Indexed columns affinity */ CollSeq *pColl; /* Comparison collation sequence */ - Expr *pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr; - Expr *pRhs = pTerm->pExpr->pRight; - if( pRhs->flags & EP_xIsSelect ){ + Expr *pLhs, *pRhs; + + assert( ExprUseXList(pTerm->pExpr->pLeft) ); + pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr; + pRhs = pTerm->pExpr->pRight; + if( ExprUseXSelect(pRhs) ){ pRhs = pRhs->x.pSelect->pEList->a[i].pExpr; }else{ pRhs = pRhs->x.pList->a[i].pExpr; @@ -148611,7 +153095,7 @@ static int whereRangeVectorLen( */ static int whereLoopAddBtreeIndex( WhereLoopBuilder *pBuilder, /* The WhereLoop factory */ - struct SrcList_item *pSrc, /* FROM clause term being analyzed */ + SrcItem *pSrc, /* FROM clause term being analyzed */ Index *pProbe, /* An index on pSrc */ LogEst nInMul /* log(Number of iterations due to IN) */ ){ @@ -148652,6 +153136,8 @@ static int whereLoopAddBtreeIndex( if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE); assert( pNew->u.btree.nEqnColumn ); + assert( pNew->u.btree.nEqnKeyCol + || pProbe->idxType!=SQLITE_IDXTYPE_PRIMARYKEY ); saved_nEq = pNew->u.btree.nEq; saved_nBtm = pNew->u.btree.nBtm; @@ -148716,7 +153202,7 @@ static int whereLoopAddBtreeIndex( if( eOp & WO_IN ){ Expr *pExpr = pTerm->pExpr; - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( ExprUseXSelect(pExpr) ){ /* "x IN (SELECT ...)": TUNING: the SELECT returns 25 rows */ int i; nIn = 46; assert( 46==sqlite3LogEst(25) ); @@ -148734,7 +153220,7 @@ static int whereLoopAddBtreeIndex( nIn = sqlite3LogEst(pExpr->x.pList->nExpr); } if( pProbe->hasStat1 && rLogSize>=10 ){ - LogEst M, logK, safetyMargin; + LogEst M, logK, x; /* Let: ** N = the total number of rows in the table ** K = the number of entries on the RHS of the IN operator @@ -148757,16 +153243,25 @@ static int whereLoopAddBtreeIndex( */ M = pProbe->aiRowLogEst[saved_nEq]; logK = estLog(nIn); - safetyMargin = 10; /* TUNING: extra weight for indexed IN */ - if( M + logK + safetyMargin < nIn + rLogSize ){ + /* TUNING v----- 10 to bias toward indexed IN */ + x = M + logK + 10 - (nIn + rLogSize); + if( x>=0 ){ WHERETRACE(0x40, - ("Scan preferred over IN operator on column %d of \"%s\" (%d<%d)\n", - saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize)); + ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d) " + "prefers indexed lookup\n", + saved_nEq, M, logK, nIn, rLogSize, x)); + }else if( nInMul<2 && OptimizationEnabled(db, SQLITE_SeekScan) ){ + WHERETRACE(0x40, + ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d" + " nInMul=%d) prefers skip-scan\n", + saved_nEq, M, logK, nIn, rLogSize, x, nInMul)); pNew->wsFlags |= WHERE_IN_SEEKSCAN; }else{ WHERETRACE(0x40, - ("IN operator preferred on column %d of \"%s\" (%d>=%d)\n", - saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize)); + ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d" + " nInMul=%d) prefers normal scan\n", + saved_nEq, M, logK, nIn, rLogSize, x, nInMul)); + continue; } } pNew->wsFlags |= WHERE_COLUMN_IN; @@ -148785,6 +153280,7 @@ static int whereLoopAddBtreeIndex( pNew->wsFlags |= WHERE_UNQ_WANTED; } } + if( scan.iEquiv>1 ) pNew->wsFlags |= WHERE_TRANSCONS; }else if( eOp & WO_ISNULL ){ pNew->wsFlags |= WHERE_COLUMN_NULL; }else if( eOp & (WO_GT|WO_GE) ){ @@ -148797,7 +153293,7 @@ static int whereLoopAddBtreeIndex( pBtm = pTerm; pTop = 0; if( pTerm->wtFlags & TERM_LIKEOPT ){ - /* Range contraints that come from the LIKE optimization are + /* Range constraints that come from the LIKE optimization are ** always used in pairs. */ pTop = &pTerm[1]; assert( (pTop-(pTerm->pWC->a))pWC->nTerm ); @@ -148846,8 +153342,8 @@ static int whereLoopAddBtreeIndex( tRowcnt nOut = 0; if( nInMul==0 && pProbe->nSample - && pNew->u.btree.nEq<=pProbe->nSampleCol - && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect)) + && ALWAYS(pNew->u.btree.nEq<=pProbe->nSampleCol) + && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr)) && OptimizationEnabled(db, SQLITE_Stat4) ){ Expr *pExpr = pTerm->pExpr; @@ -148928,6 +153424,8 @@ static int whereLoopAddBtreeIndex( if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 && pNew->u.btree.nEqnColumn + && (pNew->u.btree.nEqnKeyCol || + pProbe->idxType!=SQLITE_IDXTYPE_PRIMARYKEY) ){ whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nInMul+nIn); } @@ -149049,6 +153547,7 @@ static int whereUsablePartialIndex( if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab) && (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin)) && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab) + && (pTerm->wtFlags & TERM_VNULL)==0 ){ return 1; } @@ -149102,13 +153601,12 @@ static int whereLoopAddBtree( LogEst aiRowEstPk[2]; /* The aiRowLogEst[] value for the sPk index */ i16 aiColumnPk = -1; /* The aColumn[] value for the sPk index */ SrcList *pTabList; /* The FROM clause */ - struct SrcList_item *pSrc; /* The FROM clause btree term to add */ + SrcItem *pSrc; /* The FROM clause btree term to add */ WhereLoop *pNew; /* Template WhereLoop object */ int rc = SQLITE_OK; /* Return code */ int iSortIdx = 1; /* Index number */ int b; /* A boolean value */ LogEst rSize; /* number of rows in the table */ - LogEst rLogSize; /* Logarithm of the number of rows in the table */ WhereClause *pWC; /* The parsed WHERE clause */ Table *pTab; /* Table being queried */ @@ -149120,9 +153618,10 @@ static int whereLoopAddBtree( pWC = pBuilder->pWC; assert( !IsVirtual(pSrc->pTab) ); - if( pSrc->pIBIndex ){ + if( pSrc->fg.isIndexedBy ){ + assert( pSrc->fg.isCte==0 ); /* An INDEXED BY clause specifies a particular index to use */ - pProbe = pSrc->pIBIndex; + pProbe = pSrc->u2.pIBIndex; }else if( !HasRowid(pTab) ){ pProbe = pTab->pIndex; }else{ @@ -149151,22 +153650,23 @@ static int whereLoopAddBtree( pProbe = &sPk; } rSize = pTab->nRowLogEst; - rLogSize = estLog(rSize); #ifndef SQLITE_OMIT_AUTOMATIC_INDEX /* Automatic indexes */ if( !pBuilder->pOrSet /* Not part of an OR optimization */ && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0 - && pSrc->pIBIndex==0 /* Has no INDEXED BY clause */ + && !pSrc->fg.isIndexedBy /* Has no INDEXED BY clause */ && !pSrc->fg.notIndexed /* Has no NOT INDEXED clause */ && HasRowid(pTab) /* Not WITHOUT ROWID table. (FIXME: Why not?) */ && !pSrc->fg.isCorrelated /* Not a correlated subquery */ && !pSrc->fg.isRecursive /* Not a recursive common table expression. */ ){ /* Generate auto-index WhereLoops */ + LogEst rLogSize; /* Logarithm of the number of rows in the table */ WhereTerm *pTerm; WhereTerm *pWCEnd = pWC->a + pWC->nTerm; + rLogSize = estLog(rSize); for(pTerm=pWC->a; rc==SQLITE_OK && pTermprereqRight & pNew->maskSelf ) continue; if( termCanDriveIndex(pTerm, pSrc, 0) ){ @@ -149184,7 +153684,7 @@ static int whereLoopAddBtree( ** those objects, since there is no opportunity to add schema ** indexes on subqueries and views. */ pNew->rSetup = rLogSize + rSize; - if( pTab->pSelect==0 && (pTab->tabFlags & TF_Ephemeral)==0 ){ + if( !IsView(pTab) && (pTab->tabFlags & TF_Ephemeral)==0 ){ pNew->rSetup += 28; }else{ pNew->rSetup -= 10; @@ -149208,7 +153708,7 @@ static int whereLoopAddBtree( /* Loop over all indices. If there was an INDEXED BY clause, then only ** consider index pProbe. */ for(; rc==SQLITE_OK && pProbe; - pProbe=(pSrc->pIBIndex ? 0 : pProbe->pNext), iSortIdx++ + pProbe=(pSrc->fg.isIndexedBy ? 0 : pProbe->pNext), iSortIdx++ ){ int isLeft = (pSrc->fg.jointype & JT_OUTER)!=0; if( pProbe->pPartIdxWhere!=0 @@ -149383,7 +153883,7 @@ static int whereLoopAddVirtualOne( int rc = SQLITE_OK; WhereLoop *pNew = pBuilder->pNew; Parse *pParse = pBuilder->pWInfo->pParse; - struct SrcList_item *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab]; + SrcItem *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab]; int nConstraint = pIdxInfo->nConstraint; assert( (mUsable & mPrereq)==mPrereq ); @@ -149575,7 +154075,7 @@ static int whereLoopAddVirtual( WhereInfo *pWInfo; /* WHERE analysis context */ Parse *pParse; /* The parsing context */ WhereClause *pWC; /* The WHERE clause */ - struct SrcList_item *pSrc; /* The FROM clause term to search */ + SrcItem *pSrc; /* The FROM clause term to search */ sqlite3_index_info *p; /* Object to pass to xBestIndex() */ int nConstraint; /* Number of constraints in p */ int bIn; /* True if plan uses IN(...) operator */ @@ -149703,7 +154203,7 @@ static int whereLoopAddOr( WhereClause tempWC; WhereLoopBuilder sSubBuild; WhereOrSet sSum, sCur; - struct SrcList_item *pItem; + SrcItem *pItem; pWC = pBuilder->pWC; pWCEnd = pWC->a + pWC->nTerm; @@ -149759,7 +154259,9 @@ static int whereLoopAddOr( if( rc==SQLITE_OK ){ rc = whereLoopAddOr(&sSubBuild, mPrereq, mUnusable); } - assert( rc==SQLITE_OK || rc==SQLITE_DONE || sCur.n==0 ); + assert( rc==SQLITE_OK || rc==SQLITE_DONE || sCur.n==0 + || rc==SQLITE_NOMEM ); + testcase( rc==SQLITE_NOMEM && sCur.n>0 ); testcase( rc==SQLITE_DONE ); if( sCur.n==0 ){ sSum.n = 0; @@ -149819,8 +154321,8 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){ Bitmask mPrior = 0; int iTab; SrcList *pTabList = pWInfo->pTabList; - struct SrcList_item *pItem; - struct SrcList_item *pEnd = &pTabList->a[pWInfo->nLevel]; + SrcItem *pItem; + SrcItem *pEnd = &pTabList->a[pWInfo->nLevel]; sqlite3 *db = pWInfo->pParse->db; int rc = SQLITE_OK; WhereLoop *pNew; @@ -149843,7 +154345,7 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){ } #ifndef SQLITE_OMIT_VIRTUALTABLE if( IsVirtual(pItem->pTab) ){ - struct SrcList_item *p; + SrcItem *p; for(p=&pItem[1]; pfg.jointype & (JT_LEFT|JT_CROSS)) ){ mUnusable |= sqlite3WhereGetMask(&pWInfo->sMaskSet, p->iCursor); @@ -149988,7 +154490,7 @@ static i8 wherePathSatisfiesOrderBy( if( MASKBIT(i) & obSat ) continue; pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr); if( NEVER(pOBExpr==0) ) continue; - if( pOBExpr->op!=TK_COLUMN ) continue; + if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) continue; if( pOBExpr->iTable!=iCur ) continue; pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn, ~ready, eqOpMask, 0); @@ -150028,6 +154530,10 @@ static i8 wherePathSatisfiesOrderBy( assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) ); assert( pIndex->aiColumn[nColumn-1]==XN_ROWID || !HasRowid(pIndex->pTable)); + /* All relevant terms of the index must also be non-NULL in order + ** for isOrderDistinct to be true. So the isOrderDistint value + ** computed here might be a false positive. Corrections will be + ** made at tag-20210426-1 below */ isOrderDistinct = IsUniqueIndex(pIndex) && (pLoop->wsFlags & WHERE_SKIPSCAN)==0; } @@ -150095,14 +154601,18 @@ static i8 wherePathSatisfiesOrderBy( } /* An unconstrained column that might be NULL means that this - ** WhereLoop is not well-ordered + ** WhereLoop is not well-ordered. tag-20210426-1 */ - if( isOrderDistinct - && iColumn>=0 - && j>=pLoop->u.btree.nEq - && pIndex->pTable->aCol[iColumn].notNull==0 - ){ - isOrderDistinct = 0; + if( isOrderDistinct ){ + if( iColumn>=0 + && j>=pLoop->u.btree.nEq + && pIndex->pTable->aCol[iColumn].notNull==0 + ){ + isOrderDistinct = 0; + } + if( iColumn==XN_EXPR ){ + isOrderDistinct = 0; + } } /* Find the ORDER BY term that corresponds to the j-th column @@ -150117,7 +154627,7 @@ static i8 wherePathSatisfiesOrderBy( if( NEVER(pOBExpr==0) ) continue; if( (wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY))==0 ) bOnce = 0; if( iColumn>=XN_ROWID ){ - if( pOBExpr->op!=TK_COLUMN ) continue; + if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) continue; if( pOBExpr->iTable!=iCur ) continue; if( pOBExpr->iColumn!=iColumn ) continue; }else{ @@ -150196,7 +154706,7 @@ static i8 wherePathSatisfiesOrderBy( if( obSat==obDone ) return (i8)nOrderBy; if( !isOrderDistinct ){ for(i=nOrderBy-1; i>0; i--){ - Bitmask m = MASKBIT(i) - 1; + Bitmask m = ALWAYS(iwctrlFlags & WHERE_WANT_DISTINCT) ){ /* TUNING: In the sort for a DISTINCT operator, assume that the DISTINCT ** reduces the number of output rows by a factor of 2 */ - if( nRow>10 ) nRow -= 10; assert( 10==sqlite3LogEst(2) ); + if( nRow>10 ){ nRow -= 10; assert( 10==sqlite3LogEst(2) ); } } rSortCost += estLog(nRow); return rSortCost; @@ -150698,7 +155208,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){ */ static int whereShortCut(WhereLoopBuilder *pBuilder){ WhereInfo *pWInfo; - struct SrcList_item *pItem; + SrcItem *pItem; WhereClause *pWC; WhereTerm *pTerm; WhereLoop *pLoop; @@ -150706,6 +155216,7 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){ int j; Table *pTab; Index *pIdx; + WhereScan scan; pWInfo = pBuilder->pWInfo; if( pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE ) return 0; @@ -150719,7 +155230,8 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){ pLoop = pBuilder->pNew; pLoop->wsFlags = 0; pLoop->nSkip = 0; - pTerm = sqlite3WhereFindTerm(pWC, iCur, -1, 0, WO_EQ|WO_IS, 0); + pTerm = whereScanInit(&scan, pWC, iCur, -1, WO_EQ|WO_IS, 0); + while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan); if( pTerm ){ testcase( pTerm->eOperator & WO_IS ); pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_IPK|WHERE_ONEROW; @@ -150738,7 +155250,8 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){ ) continue; opMask = pIdx->uniqNotNull ? (WO_EQ|WO_IS) : WO_EQ; for(j=0; jnKeyCol; j++){ - pTerm = sqlite3WhereFindTerm(pWC, iCur, j, 0, opMask, pIdx); + pTerm = whereScanInit(&scan, pWC, iCur, j, opMask, pIdx); + while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan); if( pTerm==0 ) break; testcase( pTerm->eOperator & WO_IS ); pLoop->aLTerm[j] = pTerm; @@ -150767,8 +155280,14 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){ if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){ pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; } + if( scan.iEquiv>1 ) pLoop->wsFlags |= WHERE_TRANSCONS; #ifdef SQLITE_DEBUG pLoop->cId = '0'; +#endif +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace ){ + sqlite3DebugPrintf("whereShortCut() used to compute solution\n"); + } #endif return 1; } @@ -151157,7 +155676,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){ pWInfo->revMask = ALLBITS; } - if( pParse->nErr || NEVER(db->mallocFailed) ){ + if( pParse->nErr || db->mallocFailed ){ goto whereBeginError; } #ifdef WHERETRACE_ENABLED @@ -151218,7 +155737,8 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( */ notReady = ~(Bitmask)0; if( pWInfo->nLevel>=2 - && pResultSet!=0 /* guarantees condition (1) above */ + && pResultSet!=0 /* these two combine to guarantee */ + && 0==(wctrlFlags & WHERE_AGG_DISTINCT) /* condition (1) above */ && OptimizationEnabled(db, SQLITE_OmitNoopJoin) ){ int i; @@ -151228,7 +155748,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( } for(i=pWInfo->nLevel-1; i>=1; i--){ WhereTerm *pTerm, *pEnd; - struct SrcList_item *pItem; + SrcItem *pItem; pLoop = pWInfo->a[i].pWLoop; pItem = &pWInfo->pTabList->a[pLoop->iTab]; if( (pItem->fg.jointype & JT_LEFT)==0 ) continue; @@ -151318,13 +155838,13 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( for(ii=0, pLevel=pWInfo->a; iia[pLevel->iFrom]; pTab = pTabItem->pTab; iDb = sqlite3SchemaToIndex(db, pTab->pSchema); pLoop = pLevel->pWLoop; - if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){ + if( (pTab->tabFlags & TF_Ephemeral)!=0 || IsView(pTab) ){ /* Do nothing */ }else #ifndef SQLITE_OMIT_VIRTUALTABLE @@ -151449,6 +155969,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( for(ii=0; iinErr ) goto whereBeginError; pLevel = &pWInfo->a[ii]; wsFlags = pLevel->pWLoop->wsFlags; #ifndef SQLITE_OMIT_AUTOMATIC_INDEX @@ -151477,6 +155998,8 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( /* Jump here if malloc fails */ whereBeginError: if( pWInfo ){ + testcase( pWInfo->pExprMods!=0 ); + whereUndoExprMods(pWInfo); pParse->nQueryLoop = pWInfo->savedNQueryLoop; whereInfoFree(db, pWInfo); } @@ -151568,11 +156091,13 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ }else{ sqlite3VdbeResolveLabel(v, pLevel->addrCont); } - if( pLoop->wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){ + if( (pLoop->wsFlags & WHERE_IN_ABLE)!=0 && pLevel->u.in.nIn>0 ){ struct InLoop *pIn; int j; sqlite3VdbeResolveLabel(v, pLevel->addrNxt); for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){ + assert( sqlite3VdbeGetOp(v, pIn->addrInTop+1)->opcode==OP_IsNull + || pParse->db->mallocFailed ); sqlite3VdbeJumpHere(v, pIn->addrInTop+1); if( pIn->eEndLoopOp!=OP_Noop ){ if( pIn->nPrefix ){ @@ -151597,6 +156122,11 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ sqlite3VdbeCurrentAddr(v)+2, pIn->iBase, pIn->nPrefix); VdbeCoverage(v); + /* Retarget the OP_IsNull against the left operand of IN so + ** it jumps past the OP_IfNoHope. This is because the + ** OP_IsNull also bypasses the OP_Affinity opcode that is + ** required by OP_IfNoHope. */ + sqlite3VdbeJumpHere(v, pIn->addrInTop+1); } } sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop); @@ -151630,8 +156160,14 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iTabCur); } if( (ws & WHERE_INDEXED) - || ((ws & WHERE_MULTI_OR) && pLevel->u.pCovidx) + || ((ws & WHERE_MULTI_OR) && pLevel->u.pCoveringIdx) ){ + if( ws & WHERE_MULTI_OR ){ + Index *pIx = pLevel->u.pCoveringIdx; + int iDb = sqlite3SchemaToIndex(db, pIx->pSchema); + sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIx); + } sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur); } if( pLevel->op==OP_Return ){ @@ -151655,7 +156191,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ int k, last; VdbeOp *pOp, *pLastOp; Index *pIdx = 0; - struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom]; + SrcItem *pTabItem = &pTabList->a[pLevel->iFrom]; Table *pTab = pTabItem->pTab; assert( pTab!=0 ); pLoop = pLevel->pWLoop; @@ -151678,7 +156214,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ ** created for the ONEPASS optimization. */ if( (pTab->tabFlags & TF_Ephemeral)==0 - && pTab->pSelect==0 + && !IsView(pTab) && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 ){ int ws = pLoop->wsFlags; @@ -151708,7 +156244,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ if( pLoop->wsFlags & (WHERE_INDEXED|WHERE_IDX_ONLY) ){ pIdx = pLoop->u.btree.pIndex; }else if( pLoop->wsFlags & WHERE_MULTI_OR ){ - pIdx = pLevel->u.pCovidx; + pIdx = pLevel->u.pCoveringIdx; } if( pIdx && !db->mallocFailed @@ -151731,7 +156267,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ #endif pOp = sqlite3VdbeGetOp(v, k); pLastOp = pOp + (last - k); - assert( pOpp1!=pLevel->iTabCur ){ /* no-op */ @@ -151776,16 +156312,9 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ } } - /* Undo all Expr node modifications */ - while( pWInfo->pExprMods ){ - WhereExprMod *p = pWInfo->pExprMods; - pWInfo->pExprMods = p->pNext; - memcpy(p->pExpr, &p->orig, sizeof(p->orig)); - sqlite3DbFree(db, p); - } - /* Final cleanup */ + if( pWInfo->pExprMods ) whereUndoExprMods(pWInfo); pParse->nQueryLoop = pWInfo->savedNQueryLoop; whereInfoFree(db, pWInfo); return; @@ -152376,7 +156905,7 @@ static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ } /* Window functions that use all window interfaces: xStep, xFinal, ** xValue, and xInverse */ #define WINDOWFUNCALL(name,nArg,extra) { \ - nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ + nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ name ## StepFunc, name ## FinalizeFunc, name ## ValueFunc, \ name ## InvFunc, name ## Name, {0} \ } @@ -152384,7 +156913,7 @@ static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ } /* Window functions that are implemented using bytecode and thus have ** no-op routines for their methods */ #define WINDOWFUNCNOOP(name,nArg,extra) { \ - nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ + nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ noopStepFunc, noopValueFunc, noopValueFunc, \ noopStepFunc, name ## Name, {0} \ } @@ -152393,7 +156922,7 @@ static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ } ** same routine for xFinalize and xValue and which never call ** xInverse. */ #define WINDOWFUNCX(name,nArg,extra) { \ - nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ + nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ name ## StepFunc, name ## ValueFunc, name ## ValueFunc, \ noopStepFunc, name ## Name, {0} \ } @@ -152583,6 +157112,7 @@ static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){ case TK_AGG_FUNCTION: case TK_COLUMN: { int iCol = -1; + if( pParse->db->mallocFailed ) return WRC_Abort; if( p->pSub ){ int i; for(i=0; ipSub->nExpr; i++){ @@ -152692,14 +157222,17 @@ static ExprList *exprListAppendList( int i; int nInit = pList ? pList->nExpr : 0; for(i=0; inExpr; i++){ - Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0); + sqlite3 *db = pParse->db; + Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0); assert( pDup==0 || !ExprHasProperty(pDup, EP_MemToken) ); - if( bIntToNull && pDup ){ + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDup); + break; + } + if( bIntToNull ){ int iDummy; Expr *pSub; - for(pSub=pDup; ExprHasProperty(pSub, EP_Skip); pSub=pSub->pLeft){ - assert( pSub ); - } + pSub = sqlite3ExprSkipCollateAndLikely(pDup); if( sqlite3ExprIsInteger(pSub, &iDummy) ){ pSub->op = TK_NULL; pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse); @@ -152730,6 +157263,15 @@ static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){ return WRC_Continue; } +static int disallowAggregatesInOrderByCb(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_AGG_FUNCTION && pExpr->pAggInfo==0 ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3ErrorMsg(pWalker->pParse, + "misuse of aggregate: %s()", pExpr->u.zToken); + } + return WRC_Continue; +} + /* ** If the SELECT statement passed as the second argument does not invoke ** any SQL window functions, this function is a no-op. Otherwise, it @@ -152739,7 +157281,7 @@ static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){ */ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){ int rc = SQLITE_OK; - if( p->pWin && p->pPrior==0 && (p->selFlags & SF_WinRewrite)==0 ){ + if( p->pWin && p->pPrior==0 && ALWAYS((p->selFlags & SF_WinRewrite)==0) ){ Vdbe *v = sqlite3GetVdbe(pParse); sqlite3 *db = pParse->db; Select *pSub = 0; /* The subquery */ @@ -152763,6 +157305,11 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){ } sqlite3AggInfoPersistWalkerInit(&w, pParse); sqlite3WalkSelect(&w, p); + if( (p->selFlags & SF_Aggregate)==0 ){ + w.xExprCallback = disallowAggregatesInOrderByCb; + w.xSelectCallback = 0; + sqlite3WalkExprList(&w, p->pOrderBy); + } p->pSrc = 0; p->pWhere = 0; @@ -152807,7 +157354,9 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){ ** window function - one for the accumulator, another for interim ** results. */ for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ - ExprList *pArgs = pWin->pOwner->x.pList; + ExprList *pArgs; + assert( ExprUseXList(pWin->pOwner) ); + pArgs = pWin->pOwner->x.pList; if( pWin->pFunc->funcFlags & SQLITE_FUNC_SUBTYPE ){ selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist); pWin->iArgCol = (pSublist ? pSublist->nExpr : 0); @@ -152844,11 +157393,14 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){ ("New window-function subquery in FROM clause of (%u/%p)\n", p->selId, p)); p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); + assert( pSub!=0 || p->pSrc==0 ); /* Due to db->mallocFailed test inside + ** of sqlite3DbMallocRawNN() called from + ** sqlite3SrcListAppend() */ if( p->pSrc ){ Table *pTab2; p->pSrc->a[0].pSelect = pSub; sqlite3SrcListAssignCursors(pParse, p->pSrc); - pSub->selFlags |= SF_Expanded; + pSub->selFlags |= SF_Expanded|SF_OrderByReqd; pTab2 = sqlite3ResultSetOfSelect(pParse, pSub, SQLITE_AFF_NONE); pSub->selFlags |= (selFlags & SF_Aggregate); if( pTab2==0 ){ @@ -152871,7 +157423,11 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){ sqlite3SelectDelete(db, pSub); } if( db->mallocFailed ) rc = SQLITE_NOMEM; - sqlite3DbFree(db, pTab); + + /* Defer deleting the temporary table pTab because if an error occurred, + ** there could still be references to that table embedded in the + ** result-set or ORDER BY clause of the SELECT statement p. */ + sqlite3ParserAddCleanup(pParse, sqlite3DbFree, pTab); } if( rc ){ @@ -153099,15 +157655,19 @@ SQLITE_PRIVATE void sqlite3WindowAttach(Parse *pParse, Expr *p, Window *pWin){ ** SELECT, or (b) the windows already linked use a compatible window frame. */ SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin){ - if( pSel!=0 - && (0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0)) - ){ - pWin->pNextWin = pSel->pWin; - if( pSel->pWin ){ - pSel->pWin->ppThis = &pWin->pNextWin; + if( pSel ){ + if( 0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0) ){ + pWin->pNextWin = pSel->pWin; + if( pSel->pWin ){ + pSel->pWin->ppThis = &pWin->pNextWin; + } + pSel->pWin = pWin; + pWin->ppThis = &pSel->pWin; + }else{ + if( sqlite3ExprListCompare(pWin->pPartition, pSel->pWin->pPartition,-1) ){ + pSel->selFlags |= SF_MultiPart; + } } - pSel->pWin = pWin; - pWin->ppThis = &pSel->pWin; } } @@ -153116,7 +157676,12 @@ SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin){ ** different, or 2 if it cannot be determined if the objects are identical ** or not. Identical window objects can be processed in a single scan. */ -SQLITE_PRIVATE int sqlite3WindowCompare(Parse *pParse, Window *p1, Window *p2, int bFilter){ +SQLITE_PRIVATE int sqlite3WindowCompare( + const Parse *pParse, + const Window *p1, + const Window *p2, + int bFilter +){ int res; if( NEVER(p1==0) || NEVER(p2==0) ) return 1; if( p1->eFrmType!=p2->eFrmType ) return 1; @@ -153188,8 +157753,11 @@ SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse *pParse, Select *pSelect){ ** regApp+1: integer value used to ensure keys are unique ** regApp+2: output of MakeRecord */ - ExprList *pList = pWin->pOwner->x.pList; - KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0); + ExprList *pList; + KeyInfo *pKeyInfo; + assert( ExprUseXList(pWin->pOwner) ); + pList = pWin->pOwner->x.pList; + pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0); pWin->csrApp = pParse->nTab++; pWin->regApp = pParse->nMem+1; pParse->nMem += 3; @@ -153260,6 +157828,7 @@ static void windowCheckValue(Parse *pParse, int reg, int eCond){ VdbeCoverageIf(v, eCond==2); } sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg); + sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC); VdbeCoverageNeverNullIf(v, eCond==0); /* NULL case captured by */ VdbeCoverageNeverNullIf(v, eCond==1); /* the OP_MustBeInt */ VdbeCoverageNeverNullIf(v, eCond==2); @@ -153276,7 +157845,9 @@ static void windowCheckValue(Parse *pParse, int reg, int eCond){ ** with the object passed as the only argument to this function. */ static int windowArgCount(Window *pWin){ - ExprList *pList = pWin->pOwner->x.pList; + const ExprList *pList; + assert( ExprUseXList(pWin->pOwner) ); + pList = pWin->pOwner->x.pList; return (pList ? pList->nExpr : 0); } @@ -153354,6 +157925,7 @@ struct WindowCodeArg { int regGosub; /* Register used with OP_Gosub(addrGosub) */ int regArg; /* First in array of accumulator registers */ int eDelete; /* See above */ + int regRowid; WindowCsrAndReg start; WindowCsrAndReg current; @@ -153460,6 +158032,7 @@ static void windowAggStep( int addrIf = 0; if( pWin->pFilter ){ int regTmp; + assert( ExprUseXList(pWin->pOwner) ); assert( pWin->bExprArgs || !nArg ||nArg==pWin->pOwner->x.pList->nExpr ); assert( pWin->bExprArgs || nArg ||pWin->pOwner->x.pList==0 ); regTmp = sqlite3GetTempReg(pParse); @@ -153470,15 +158043,16 @@ static void windowAggStep( } if( pWin->bExprArgs ){ - int iStart = sqlite3VdbeCurrentAddr(v); - VdbeOp *pOp, *pEnd; + int iOp = sqlite3VdbeCurrentAddr(v); + int iEnd; + assert( ExprUseXList(pWin->pOwner) ); nArg = pWin->pOwner->x.pList->nExpr; regArg = sqlite3GetTempRange(pParse, nArg); sqlite3ExprCodeExprList(pParse, pWin->pOwner->x.pList, regArg, 0, 0); - pEnd = sqlite3VdbeGetOp(v, -1); - for(pOp=sqlite3VdbeGetOp(v, iStart); pOp<=pEnd; pOp++){ + for(iEnd=sqlite3VdbeCurrentAddr(v); iOpopcode==OP_Column && pOp->p1==pWin->iEphCsr ){ pOp->p1 = csr; } @@ -153487,6 +158061,7 @@ static void windowAggStep( if( pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){ CollSeq *pColl; assert( nArg>0 ); + assert( ExprUseXList(pWin->pOwner) ); pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr); sqlite3VdbeAddOp4(v, OP_CollSeq, 0,0,0, (const char*)pColl, P4_COLLSEQ); } @@ -153672,6 +158247,7 @@ static void windowReturnOneRow(WindowCodeArg *p){ for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ FuncDef *pFunc = pWin->pFunc; + assert( ExprUseXList(pWin->pOwner) ); if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){ @@ -153837,7 +158413,7 @@ static void windowIfNewPeer( ** if( csr1.peerVal - regVal <= csr2.peerVal ) goto lbl; ** ** A special type of arithmetic is used such that if csr1.peerVal is not -** a numeric type (real or integer), then the result of the addition addition +** a numeric type (real or integer), then the result of the addition ** or subtraction is a a copy of csr1.peerVal. */ static void windowCodeRangeTest( @@ -153856,6 +158432,12 @@ static void windowCodeRangeTest( int regString = ++pParse->nMem; /* Reg. for constant value '' */ int arith = OP_Add; /* OP_Add or OP_Subtract */ int addrGe; /* Jump destination */ + int addrDone = sqlite3VdbeMakeLabel(pParse); /* Address past OP_Ge */ + CollSeq *pColl; + + /* Read the peer-value from each cursor into a register */ + windowReadPeerValues(p, csr1, reg1); + windowReadPeerValues(p, csr2, reg2); assert( op==OP_Ge || op==OP_Gt || op==OP_Le ); assert( pOrderBy && pOrderBy->nExpr==1 ); @@ -153868,34 +158450,11 @@ static void windowCodeRangeTest( arith = OP_Subtract; } - /* Read the peer-value from each cursor into a register */ - windowReadPeerValues(p, csr1, reg1); - windowReadPeerValues(p, csr2, reg2); - VdbeModuleComment((v, "CodeRangeTest: if( R%d %s R%d %s R%d ) goto lbl", reg1, (arith==OP_Add ? "+" : "-"), regVal, ((op==OP_Ge) ? ">=" : (op==OP_Le) ? "<=" : (op==OP_Gt) ? ">" : "<"), reg2 )); - /* Register reg1 currently contains csr1.peerVal (the peer-value from csr1). - ** This block adds (or subtracts for DESC) the numeric value in regVal - ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob), - ** then leave reg1 as it is. In pseudo-code, this is implemented as: - ** - ** if( reg1>='' ) goto addrGe; - ** reg1 = reg1 +/- regVal - ** addrGe: - ** - ** Since all strings and blobs are greater-than-or-equal-to an empty string, - ** the add/subtract is skipped for these, as required. If reg1 is a NULL, - ** then the arithmetic is performed, but since adding or subtracting from - ** NULL is always NULL anyway, this case is handled as required too. */ - sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC); - addrGe = sqlite3VdbeAddOp3(v, OP_Ge, regString, 0, reg1); - VdbeCoverage(v); - sqlite3VdbeAddOp3(v, arith, regVal, reg1, reg1); - sqlite3VdbeJumpHere(v, addrGe); - /* If the BIGNULL flag is set for the ORDER BY, then it is required to ** consider NULL values to be larger than all other values, instead of ** the usual smaller. The VDBE opcodes OP_Ge and so on do not handle this @@ -153932,21 +158491,46 @@ static void windowCodeRangeTest( break; default: assert( op==OP_Lt ); /* no-op */ break; } - sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone); /* This block runs if reg1 is not NULL, but reg2 is. */ sqlite3VdbeJumpHere(v, addr); sqlite3VdbeAddOp2(v, OP_IsNull, reg2, lbl); VdbeCoverage(v); if( op==OP_Gt || op==OP_Ge ){ - sqlite3VdbeChangeP2(v, -1, sqlite3VdbeCurrentAddr(v)+1); + sqlite3VdbeChangeP2(v, -1, addrDone); } } + /* Register reg1 currently contains csr1.peerVal (the peer-value from csr1). + ** This block adds (or subtracts for DESC) the numeric value in regVal + ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob), + ** then leave reg1 as it is. In pseudo-code, this is implemented as: + ** + ** if( reg1>='' ) goto addrGe; + ** reg1 = reg1 +/- regVal + ** addrGe: + ** + ** Since all strings and blobs are greater-than-or-equal-to an empty string, + ** the add/subtract is skipped for these, as required. If reg1 is a NULL, + ** then the arithmetic is performed, but since adding or subtracting from + ** NULL is always NULL anyway, this case is handled as required too. */ + sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC); + addrGe = sqlite3VdbeAddOp3(v, OP_Ge, regString, 0, reg1); + VdbeCoverage(v); + if( (op==OP_Ge && arith==OP_Add) || (op==OP_Le && arith==OP_Subtract) ){ + sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, arith, regVal, reg1, reg1); + sqlite3VdbeJumpHere(v, addrGe); + /* Compare registers reg2 and reg1, taking the jump if required. Note that ** control skips over this test if the BIGNULL flag is set and either ** reg1 or reg2 contain a NULL value. */ sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v); + pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr); + sqlite3VdbeAppendP4(v, (void*)pColl, P4_COLLSEQ); sqlite3VdbeChangeP5(v, SQLITE_NULLEQ); + sqlite3VdbeResolveLabel(v, addrDone); assert( op==OP_Ge || op==OP_Gt || op==OP_Lt || op==OP_Le ); testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge); @@ -154022,16 +158606,24 @@ static int windowCodeOp( /* If this is a (RANGE BETWEEN a FOLLOWING AND b FOLLOWING) or ** (RANGE BETWEEN b PRECEDING AND a PRECEDING) frame, ensure the ** start cursor does not advance past the end cursor within the - ** temporary table. It otherwise might, if (a>b). */ + ** temporary table. It otherwise might, if (a>b). Also ensure that, + ** if the input cursor is still finding new rows, that the end + ** cursor does not go past it to EOF. */ if( pMWin->eStart==pMWin->eEnd && regCountdown - && pMWin->eFrmType==TK_RANGE && op==WINDOW_AGGINVERSE + && pMWin->eFrmType==TK_RANGE ){ int regRowid1 = sqlite3GetTempReg(pParse); int regRowid2 = sqlite3GetTempReg(pParse); - sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1); - sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2); - sqlite3VdbeAddOp3(v, OP_Ge, regRowid2, lblDone, regRowid1); - VdbeCoverage(v); + if( op==WINDOW_AGGINVERSE ){ + sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1); + sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2); + sqlite3VdbeAddOp3(v, OP_Ge, regRowid2, lblDone, regRowid1); + VdbeCoverage(v); + }else if( p->regRowid ){ + sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid1); + sqlite3VdbeAddOp3(v, OP_Ge, p->regRowid, lblDone, regRowid1); + VdbeCoverageNeverNull(v); + } sqlite3ReleaseTempReg(pParse, regRowid1); sqlite3ReleaseTempReg(pParse, regRowid2); assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING ); @@ -154528,7 +159120,6 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep( int addrEmpty; /* Address of OP_Rewind in flush: */ int regNew; /* Array of registers holding new input row */ int regRecord; /* regNew array in record form */ - int regRowid; /* Rowid for regRecord in eph table */ int regNewPeer = 0; /* Peer values for new row (part of regNew) */ int regPeer = 0; /* Peer values for current row */ int regFlushPart = 0; /* Register for "Gosub flush_partition" */ @@ -154600,7 +159191,7 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep( regNew = pParse->nMem+1; pParse->nMem += nInput; regRecord = ++pParse->nMem; - regRowid = ++pParse->nMem; + s.regRowid = ++pParse->nMem; /* If the window frame contains an " PRECEDING" or " FOLLOWING" ** clause, allocate registers to store the results of evaluating each @@ -154656,9 +159247,9 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep( } /* Insert the new row into the ephemeral table */ - sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, regRowid); - sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, regRowid); - addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, regRowid); + sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, s.regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, s.regRowid); + addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, s.regRowid); VdbeCoverageNeverNull(v); /* This block is run for the first row of each partition */ @@ -154776,6 +159367,7 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep( sqlite3VdbeJumpHere(v, addrGosubFlush); } + s.regRowid = 0; addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite); VdbeCoverage(v); if( pMWin->eEnd==TK_PRECEDING ){ @@ -154952,11 +159544,21 @@ static void updateDeleteLimitError( static void parserDoubleLinkSelect(Parse *pParse, Select *p){ assert( p!=0 ); if( p->pPrior ){ - Select *pNext = 0, *pLoop; - int mxSelect, cnt = 0; - for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){ + Select *pNext = 0, *pLoop = p; + int mxSelect, cnt = 1; + while(1){ pLoop->pNext = pNext; pLoop->selFlags |= SF_Compound; + pNext = pLoop; + pLoop = pLoop->pPrior; + if( pLoop==0 ) break; + cnt++; + if( pLoop->pOrderBy || pLoop->pLimit ){ + sqlite3ErrorMsg(pParse,"%s clause should come after %s not before", + pLoop->pOrderBy!=0 ? "ORDER BY" : "LIMIT", + sqlite3SelectOpName(pNext->op)); + break; + } } if( (p->selFlags & SF_MultiValue)==0 && (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 && @@ -154967,6 +159569,19 @@ static void updateDeleteLimitError( } } + /* Attach a With object describing the WITH clause to a Select + ** object describing the query for which the WITH clause is a prefix. + */ + static Select *attachWithToSelect(Parse *pParse, Select *pSelect, With *pWith){ + if( pSelect ){ + pSelect->pWith = pWith; + parserDoubleLinkSelect(pParse, pSelect); + }else{ + sqlite3WithDelete(pParse->db, pWith); + } + return pSelect; + } + /* Construct a new Expr object from a single identifier. Use the ** new Expr to populate pOut. Set the span of pOut to be the identifier @@ -154982,9 +159597,9 @@ static void updateDeleteLimitError( ExprClearVVAProperties(p); p->iAgg = -1; p->pLeft = p->pRight = 0; - p->x.pList = 0; p->pAggInfo = 0; - p->y.pTab = 0; + memset(&p->x, 0, sizeof(p->x)); + memset(&p->y, 0, sizeof(p->y)); p->op2 = 0; p->iTable = 0; p->iColumn = 0; @@ -155070,8 +159685,8 @@ static void updateDeleteLimitError( #define TK_LP 22 #define TK_RP 23 #define TK_AS 24 -#define TK_WITHOUT 25 -#define TK_COMMA 26 +#define TK_COMMA 25 +#define TK_WITHOUT 26 #define TK_ABORT 27 #define TK_ACTION 28 #define TK_AFTER 29 @@ -155142,90 +159757,93 @@ static void updateDeleteLimitError( #define TK_TIES 94 #define TK_GENERATED 95 #define TK_ALWAYS 96 -#define TK_REINDEX 97 -#define TK_RENAME 98 -#define TK_CTIME_KW 99 -#define TK_ANY 100 -#define TK_BITAND 101 -#define TK_BITOR 102 -#define TK_LSHIFT 103 -#define TK_RSHIFT 104 -#define TK_PLUS 105 -#define TK_MINUS 106 -#define TK_STAR 107 -#define TK_SLASH 108 -#define TK_REM 109 -#define TK_CONCAT 110 -#define TK_COLLATE 111 -#define TK_BITNOT 112 -#define TK_ON 113 -#define TK_INDEXED 114 -#define TK_STRING 115 -#define TK_JOIN_KW 116 -#define TK_CONSTRAINT 117 -#define TK_DEFAULT 118 -#define TK_NULL 119 -#define TK_PRIMARY 120 -#define TK_UNIQUE 121 -#define TK_CHECK 122 -#define TK_REFERENCES 123 -#define TK_AUTOINCR 124 -#define TK_INSERT 125 -#define TK_DELETE 126 -#define TK_UPDATE 127 -#define TK_SET 128 -#define TK_DEFERRABLE 129 -#define TK_FOREIGN 130 -#define TK_DROP 131 -#define TK_UNION 132 -#define TK_ALL 133 -#define TK_EXCEPT 134 -#define TK_INTERSECT 135 -#define TK_SELECT 136 -#define TK_VALUES 137 -#define TK_DISTINCT 138 -#define TK_DOT 139 -#define TK_FROM 140 -#define TK_JOIN 141 -#define TK_USING 142 -#define TK_ORDER 143 -#define TK_GROUP 144 -#define TK_HAVING 145 -#define TK_LIMIT 146 -#define TK_WHERE 147 -#define TK_INTO 148 -#define TK_NOTHING 149 -#define TK_FLOAT 150 -#define TK_BLOB 151 -#define TK_INTEGER 152 -#define TK_VARIABLE 153 -#define TK_CASE 154 -#define TK_WHEN 155 -#define TK_THEN 156 -#define TK_ELSE 157 -#define TK_INDEX 158 -#define TK_ALTER 159 -#define TK_ADD 160 -#define TK_WINDOW 161 -#define TK_OVER 162 -#define TK_FILTER 163 -#define TK_COLUMN 164 -#define TK_AGG_FUNCTION 165 -#define TK_AGG_COLUMN 166 -#define TK_TRUEFALSE 167 -#define TK_ISNOT 168 -#define TK_FUNCTION 169 -#define TK_UMINUS 170 -#define TK_UPLUS 171 -#define TK_TRUTH 172 -#define TK_REGISTER 173 -#define TK_VECTOR 174 -#define TK_SELECT_COLUMN 175 -#define TK_IF_NULL_ROW 176 -#define TK_ASTERISK 177 -#define TK_SPAN 178 -#define TK_SPACE 179 -#define TK_ILLEGAL 180 +#define TK_MATERIALIZED 97 +#define TK_REINDEX 98 +#define TK_RENAME 99 +#define TK_CTIME_KW 100 +#define TK_ANY 101 +#define TK_BITAND 102 +#define TK_BITOR 103 +#define TK_LSHIFT 104 +#define TK_RSHIFT 105 +#define TK_PLUS 106 +#define TK_MINUS 107 +#define TK_STAR 108 +#define TK_SLASH 109 +#define TK_REM 110 +#define TK_CONCAT 111 +#define TK_COLLATE 112 +#define TK_BITNOT 113 +#define TK_ON 114 +#define TK_INDEXED 115 +#define TK_STRING 116 +#define TK_JOIN_KW 117 +#define TK_CONSTRAINT 118 +#define TK_DEFAULT 119 +#define TK_NULL 120 +#define TK_PRIMARY 121 +#define TK_UNIQUE 122 +#define TK_CHECK 123 +#define TK_REFERENCES 124 +#define TK_AUTOINCR 125 +#define TK_INSERT 126 +#define TK_DELETE 127 +#define TK_UPDATE 128 +#define TK_SET 129 +#define TK_DEFERRABLE 130 +#define TK_FOREIGN 131 +#define TK_DROP 132 +#define TK_UNION 133 +#define TK_ALL 134 +#define TK_EXCEPT 135 +#define TK_INTERSECT 136 +#define TK_SELECT 137 +#define TK_VALUES 138 +#define TK_DISTINCT 139 +#define TK_DOT 140 +#define TK_FROM 141 +#define TK_JOIN 142 +#define TK_USING 143 +#define TK_ORDER 144 +#define TK_GROUP 145 +#define TK_HAVING 146 +#define TK_LIMIT 147 +#define TK_WHERE 148 +#define TK_RETURNING 149 +#define TK_INTO 150 +#define TK_NOTHING 151 +#define TK_FLOAT 152 +#define TK_BLOB 153 +#define TK_INTEGER 154 +#define TK_VARIABLE 155 +#define TK_CASE 156 +#define TK_WHEN 157 +#define TK_THEN 158 +#define TK_ELSE 159 +#define TK_INDEX 160 +#define TK_ALTER 161 +#define TK_ADD 162 +#define TK_WINDOW 163 +#define TK_OVER 164 +#define TK_FILTER 165 +#define TK_COLUMN 166 +#define TK_AGG_FUNCTION 167 +#define TK_AGG_COLUMN 168 +#define TK_TRUEFALSE 169 +#define TK_ISNOT 170 +#define TK_FUNCTION 171 +#define TK_UMINUS 172 +#define TK_UPLUS 173 +#define TK_TRUTH 174 +#define TK_REGISTER 175 +#define TK_VECTOR 176 +#define TK_SELECT_COLUMN 177 +#define TK_IF_NULL_ROW 178 +#define TK_ASTERISK 179 +#define TK_SPAN 180 +#define TK_ERROR 181 +#define TK_SPACE 182 +#define TK_ILLEGAL 183 #endif /**************** End token definitions ***************************************/ @@ -155285,28 +159903,30 @@ static void updateDeleteLimitError( #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 310 +#define YYNOCODE 318 #define YYACTIONTYPE unsigned short int -#define YYWILDCARD 100 +#define YYWILDCARD 101 #define sqlite3ParserTOKENTYPE Token typedef union { int yyinit; sqlite3ParserTOKENTYPE yy0; - SrcList* yy47; - u8 yy58; - struct FrameBound yy77; - With* yy131; - int yy192; - Expr* yy202; - struct {int value; int mask;} yy207; - struct TrigEvent yy230; - ExprList* yy242; - Window* yy303; - Upsert* yy318; - const char* yy436; - TriggerStep* yy447; - Select* yy539; - IdList* yy600; + With* yy43; + u32 yy51; + int yy64; + struct FrameBound yy81; + struct {int value; int mask;} yy83; + TriggerStep* yy95; + Upsert* yy138; + IdList* yy240; + Cte* yy255; + Select* yy303; + Window* yy375; + u8 yy534; + ExprList* yy562; + struct TrigEvent yy570; + const char* yy600; + SrcList* yy607; + Expr* yy626; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -155322,18 +159942,18 @@ typedef union { #define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse; #define sqlite3ParserCTX_STORE yypParser->pParse=pParse; #define YYFALLBACK 1 -#define YYNSTATE 553 -#define YYNRULE 385 -#define YYNRULE_WITH_ACTION 325 -#define YYNTOKEN 181 -#define YY_MAX_SHIFT 552 -#define YY_MIN_SHIFTREDUCE 803 -#define YY_MAX_SHIFTREDUCE 1187 -#define YY_ERROR_ACTION 1188 -#define YY_ACCEPT_ACTION 1189 -#define YY_NO_ACTION 1190 -#define YY_MIN_REDUCE 1191 -#define YY_MAX_REDUCE 1575 +#define YYNSTATE 572 +#define YYNRULE 401 +#define YYNRULE_WITH_ACTION 339 +#define YYNTOKEN 184 +#define YY_MAX_SHIFT 571 +#define YY_MIN_SHIFTREDUCE 829 +#define YY_MAX_SHIFTREDUCE 1229 +#define YY_ERROR_ACTION 1230 +#define YY_ACCEPT_ACTION 1231 +#define YY_NO_ACTION 1232 +#define YY_MIN_REDUCE 1233 +#define YY_MAX_REDUCE 1633 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -155400,586 +160020,606 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (1962) +#define YY_ACTTAB_COUNT (2037) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 546, 1222, 546, 451, 1260, 546, 1239, 546, 114, 111, - /* 10 */ 211, 546, 1537, 546, 1260, 523, 114, 111, 211, 392, - /* 20 */ 1232, 344, 42, 42, 42, 42, 1225, 42, 42, 71, - /* 30 */ 71, 937, 1224, 71, 71, 71, 71, 1462, 1493, 938, - /* 40 */ 820, 453, 6, 121, 122, 112, 1165, 1165, 1006, 1009, - /* 50 */ 999, 999, 119, 119, 120, 120, 120, 120, 1543, 392, - /* 60 */ 1358, 1517, 552, 2, 1193, 194, 528, 436, 143, 291, - /* 70 */ 528, 136, 528, 371, 261, 504, 272, 385, 1273, 527, - /* 80 */ 503, 493, 164, 121, 122, 112, 1165, 1165, 1006, 1009, - /* 90 */ 999, 999, 119, 119, 120, 120, 120, 120, 1358, 442, - /* 100 */ 1514, 118, 118, 118, 118, 117, 117, 116, 116, 116, - /* 110 */ 115, 424, 266, 266, 266, 266, 1498, 358, 1500, 435, - /* 120 */ 357, 1498, 517, 524, 1485, 543, 1114, 543, 1114, 392, - /* 130 */ 405, 241, 208, 114, 111, 211, 98, 290, 537, 221, - /* 140 */ 1029, 118, 118, 118, 118, 117, 117, 116, 116, 116, - /* 150 */ 115, 424, 1142, 121, 122, 112, 1165, 1165, 1006, 1009, - /* 160 */ 999, 999, 119, 119, 120, 120, 120, 120, 406, 428, - /* 170 */ 117, 117, 116, 116, 116, 115, 424, 1418, 468, 123, - /* 180 */ 118, 118, 118, 118, 117, 117, 116, 116, 116, 115, - /* 190 */ 424, 116, 116, 116, 115, 424, 540, 540, 540, 392, - /* 200 */ 505, 120, 120, 120, 120, 113, 1051, 1142, 1143, 1144, - /* 210 */ 1051, 118, 118, 118, 118, 117, 117, 116, 116, 116, - /* 220 */ 115, 424, 1461, 121, 122, 112, 1165, 1165, 1006, 1009, - /* 230 */ 999, 999, 119, 119, 120, 120, 120, 120, 392, 444, - /* 240 */ 316, 83, 463, 81, 359, 382, 1142, 80, 118, 118, - /* 250 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 179, - /* 260 */ 434, 424, 121, 122, 112, 1165, 1165, 1006, 1009, 999, - /* 270 */ 999, 119, 119, 120, 120, 120, 120, 434, 433, 266, - /* 280 */ 266, 118, 118, 118, 118, 117, 117, 116, 116, 116, - /* 290 */ 115, 424, 543, 1109, 903, 506, 1142, 114, 111, 211, - /* 300 */ 1431, 1142, 1143, 1144, 206, 491, 1109, 392, 449, 1109, - /* 310 */ 545, 330, 120, 120, 120, 120, 298, 1431, 1433, 17, - /* 320 */ 118, 118, 118, 118, 117, 117, 116, 116, 116, 115, - /* 330 */ 424, 121, 122, 112, 1165, 1165, 1006, 1009, 999, 999, - /* 340 */ 119, 119, 120, 120, 120, 120, 392, 1358, 434, 1142, - /* 350 */ 482, 1142, 1143, 1144, 996, 996, 1007, 1010, 445, 118, - /* 360 */ 118, 118, 118, 117, 117, 116, 116, 116, 115, 424, - /* 370 */ 121, 122, 112, 1165, 1165, 1006, 1009, 999, 999, 119, - /* 380 */ 119, 120, 120, 120, 120, 1054, 1054, 465, 1431, 118, - /* 390 */ 118, 118, 118, 117, 117, 116, 116, 116, 115, 424, - /* 400 */ 1142, 451, 546, 1426, 1142, 1143, 1144, 233, 966, 1142, - /* 410 */ 481, 478, 477, 171, 360, 392, 164, 407, 414, 842, - /* 420 */ 476, 164, 185, 334, 71, 71, 1243, 1000, 118, 118, - /* 430 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 121, - /* 440 */ 122, 112, 1165, 1165, 1006, 1009, 999, 999, 119, 119, - /* 450 */ 120, 120, 120, 120, 392, 1142, 1143, 1144, 835, 12, - /* 460 */ 314, 509, 163, 356, 1142, 1143, 1144, 114, 111, 211, - /* 470 */ 508, 290, 537, 546, 276, 180, 290, 537, 121, 122, - /* 480 */ 112, 1165, 1165, 1006, 1009, 999, 999, 119, 119, 120, - /* 490 */ 120, 120, 120, 345, 484, 71, 71, 118, 118, 118, - /* 500 */ 118, 117, 117, 116, 116, 116, 115, 424, 1142, 209, - /* 510 */ 411, 523, 1142, 1109, 1571, 378, 252, 269, 342, 487, - /* 520 */ 337, 486, 238, 392, 513, 364, 1109, 1127, 333, 1109, - /* 530 */ 191, 409, 286, 32, 457, 443, 118, 118, 118, 118, - /* 540 */ 117, 117, 116, 116, 116, 115, 424, 121, 122, 112, - /* 550 */ 1165, 1165, 1006, 1009, 999, 999, 119, 119, 120, 120, - /* 560 */ 120, 120, 392, 1142, 1143, 1144, 987, 1142, 1143, 1144, - /* 570 */ 1142, 233, 492, 1492, 481, 478, 477, 6, 163, 546, - /* 580 */ 512, 546, 115, 424, 476, 5, 121, 122, 112, 1165, - /* 590 */ 1165, 1006, 1009, 999, 999, 119, 119, 120, 120, 120, - /* 600 */ 120, 13, 13, 13, 13, 118, 118, 118, 118, 117, - /* 610 */ 117, 116, 116, 116, 115, 424, 403, 502, 408, 546, - /* 620 */ 1486, 544, 1142, 892, 892, 1142, 1143, 1144, 1473, 1142, - /* 630 */ 275, 392, 808, 809, 810, 971, 422, 422, 422, 16, - /* 640 */ 16, 55, 55, 1242, 118, 118, 118, 118, 117, 117, - /* 650 */ 116, 116, 116, 115, 424, 121, 122, 112, 1165, 1165, - /* 660 */ 1006, 1009, 999, 999, 119, 119, 120, 120, 120, 120, - /* 670 */ 392, 1189, 1, 1, 552, 2, 1193, 1142, 1143, 1144, - /* 680 */ 194, 291, 898, 136, 1142, 1143, 1144, 897, 521, 1492, - /* 690 */ 1273, 3, 380, 6, 121, 122, 112, 1165, 1165, 1006, - /* 700 */ 1009, 999, 999, 119, 119, 120, 120, 120, 120, 858, - /* 710 */ 546, 924, 546, 118, 118, 118, 118, 117, 117, 116, - /* 720 */ 116, 116, 115, 424, 266, 266, 1092, 1569, 1142, 551, - /* 730 */ 1569, 1193, 13, 13, 13, 13, 291, 543, 136, 392, - /* 740 */ 485, 421, 420, 966, 344, 1273, 468, 410, 859, 279, - /* 750 */ 140, 221, 118, 118, 118, 118, 117, 117, 116, 116, - /* 760 */ 116, 115, 424, 121, 122, 112, 1165, 1165, 1006, 1009, - /* 770 */ 999, 999, 119, 119, 120, 120, 120, 120, 546, 266, - /* 780 */ 266, 428, 392, 1142, 1143, 1144, 1172, 830, 1172, 468, - /* 790 */ 431, 145, 543, 1146, 401, 314, 439, 302, 838, 1490, - /* 800 */ 71, 71, 412, 6, 1090, 473, 221, 100, 112, 1165, - /* 810 */ 1165, 1006, 1009, 999, 999, 119, 119, 120, 120, 120, - /* 820 */ 120, 118, 118, 118, 118, 117, 117, 116, 116, 116, - /* 830 */ 115, 424, 237, 1425, 546, 451, 428, 287, 986, 546, - /* 840 */ 236, 235, 234, 830, 97, 529, 429, 1265, 1265, 1146, - /* 850 */ 494, 307, 430, 838, 977, 546, 71, 71, 976, 1241, - /* 860 */ 546, 51, 51, 300, 118, 118, 118, 118, 117, 117, - /* 870 */ 116, 116, 116, 115, 424, 194, 103, 70, 70, 266, - /* 880 */ 266, 546, 71, 71, 266, 266, 30, 391, 344, 976, - /* 890 */ 976, 978, 543, 528, 1109, 328, 392, 543, 495, 397, - /* 900 */ 1470, 195, 530, 13, 13, 1358, 240, 1109, 277, 280, - /* 910 */ 1109, 280, 304, 457, 306, 333, 392, 31, 188, 419, - /* 920 */ 121, 122, 112, 1165, 1165, 1006, 1009, 999, 999, 119, - /* 930 */ 119, 120, 120, 120, 120, 142, 392, 365, 457, 986, - /* 940 */ 121, 122, 112, 1165, 1165, 1006, 1009, 999, 999, 119, - /* 950 */ 119, 120, 120, 120, 120, 977, 323, 1142, 326, 976, - /* 960 */ 121, 110, 112, 1165, 1165, 1006, 1009, 999, 999, 119, - /* 970 */ 119, 120, 120, 120, 120, 464, 377, 1185, 118, 118, - /* 980 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 1142, - /* 990 */ 976, 976, 978, 305, 9, 366, 244, 362, 118, 118, - /* 1000 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 313, - /* 1010 */ 546, 344, 1142, 1143, 1144, 299, 290, 537, 118, 118, - /* 1020 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 1263, - /* 1030 */ 1263, 1163, 13, 13, 278, 421, 420, 468, 392, 923, - /* 1040 */ 260, 260, 289, 1169, 1142, 1143, 1144, 189, 1171, 266, - /* 1050 */ 266, 468, 390, 543, 1186, 546, 1170, 263, 144, 489, - /* 1060 */ 922, 546, 543, 122, 112, 1165, 1165, 1006, 1009, 999, - /* 1070 */ 999, 119, 119, 120, 120, 120, 120, 71, 71, 1142, - /* 1080 */ 1172, 1272, 1172, 13, 13, 898, 1070, 1163, 546, 468, - /* 1090 */ 897, 107, 538, 1491, 4, 1268, 1109, 6, 525, 1049, - /* 1100 */ 12, 1071, 1092, 1570, 312, 455, 1570, 520, 541, 1109, - /* 1110 */ 56, 56, 1109, 1489, 423, 1358, 1072, 6, 345, 285, - /* 1120 */ 118, 118, 118, 118, 117, 117, 116, 116, 116, 115, - /* 1130 */ 424, 425, 1271, 321, 1142, 1143, 1144, 878, 266, 266, - /* 1140 */ 1277, 107, 538, 535, 4, 1488, 293, 879, 1211, 6, - /* 1150 */ 210, 543, 543, 164, 294, 496, 416, 204, 541, 267, - /* 1160 */ 267, 1214, 398, 511, 499, 204, 266, 266, 396, 531, - /* 1170 */ 8, 986, 543, 519, 546, 922, 458, 105, 105, 543, - /* 1180 */ 1090, 425, 266, 266, 106, 417, 425, 548, 547, 266, - /* 1190 */ 266, 976, 518, 535, 1373, 543, 15, 15, 266, 266, - /* 1200 */ 456, 1120, 543, 266, 266, 1070, 1372, 515, 290, 537, - /* 1210 */ 546, 543, 514, 97, 444, 316, 543, 546, 922, 125, - /* 1220 */ 1071, 986, 976, 976, 978, 979, 27, 105, 105, 401, - /* 1230 */ 343, 1511, 44, 44, 106, 1072, 425, 548, 547, 57, - /* 1240 */ 57, 976, 343, 1511, 107, 538, 546, 4, 462, 401, - /* 1250 */ 214, 1120, 459, 297, 377, 1091, 534, 1309, 546, 539, - /* 1260 */ 398, 541, 290, 537, 104, 244, 102, 526, 58, 58, - /* 1270 */ 546, 199, 976, 976, 978, 979, 27, 1516, 1131, 427, - /* 1280 */ 59, 59, 270, 237, 425, 138, 95, 375, 375, 374, - /* 1290 */ 255, 372, 60, 60, 817, 1180, 535, 546, 273, 546, - /* 1300 */ 1163, 1308, 389, 388, 546, 438, 546, 215, 210, 296, - /* 1310 */ 515, 849, 546, 265, 208, 516, 1476, 295, 274, 61, - /* 1320 */ 61, 62, 62, 308, 986, 109, 45, 45, 46, 46, - /* 1330 */ 105, 105, 1186, 922, 47, 47, 341, 106, 546, 425, - /* 1340 */ 548, 547, 1542, 546, 976, 867, 340, 217, 546, 937, - /* 1350 */ 397, 107, 538, 218, 4, 156, 1163, 938, 158, 546, - /* 1360 */ 49, 49, 1162, 546, 268, 50, 50, 546, 541, 1450, - /* 1370 */ 63, 63, 546, 1449, 216, 976, 976, 978, 979, 27, - /* 1380 */ 446, 64, 64, 546, 460, 65, 65, 546, 318, 14, - /* 1390 */ 14, 425, 1305, 546, 66, 66, 1087, 546, 141, 379, - /* 1400 */ 38, 546, 963, 535, 322, 127, 127, 546, 393, 67, - /* 1410 */ 67, 546, 325, 290, 537, 52, 52, 515, 546, 68, - /* 1420 */ 68, 845, 514, 69, 69, 399, 165, 857, 856, 53, - /* 1430 */ 53, 986, 311, 151, 151, 97, 432, 105, 105, 327, - /* 1440 */ 152, 152, 526, 1048, 106, 1048, 425, 548, 547, 1131, - /* 1450 */ 427, 976, 1032, 270, 968, 239, 329, 243, 375, 375, - /* 1460 */ 374, 255, 372, 940, 941, 817, 1296, 546, 220, 546, - /* 1470 */ 107, 538, 546, 4, 546, 1256, 199, 845, 215, 1036, - /* 1480 */ 296, 1530, 976, 976, 978, 979, 27, 541, 295, 76, - /* 1490 */ 76, 54, 54, 980, 72, 72, 128, 128, 864, 865, - /* 1500 */ 107, 538, 546, 4, 1047, 546, 1047, 533, 469, 546, - /* 1510 */ 425, 546, 450, 1240, 546, 243, 546, 541, 217, 546, - /* 1520 */ 452, 197, 535, 243, 73, 73, 156, 129, 129, 158, - /* 1530 */ 336, 130, 130, 126, 126, 1036, 150, 150, 149, 149, - /* 1540 */ 425, 134, 134, 317, 474, 216, 97, 239, 331, 980, - /* 1550 */ 986, 97, 535, 346, 347, 546, 105, 105, 902, 931, - /* 1560 */ 546, 895, 243, 106, 109, 425, 548, 547, 546, 1505, - /* 1570 */ 976, 828, 99, 538, 139, 4, 546, 133, 133, 393, - /* 1580 */ 986, 1317, 131, 131, 290, 537, 105, 105, 1357, 541, - /* 1590 */ 132, 132, 1292, 106, 1303, 425, 548, 547, 75, 75, - /* 1600 */ 976, 976, 976, 978, 979, 27, 546, 432, 896, 1289, - /* 1610 */ 532, 109, 425, 1363, 546, 1221, 1213, 1202, 258, 546, - /* 1620 */ 349, 546, 1201, 11, 535, 1203, 1524, 351, 77, 77, - /* 1630 */ 376, 976, 976, 978, 979, 27, 74, 74, 353, 213, - /* 1640 */ 301, 43, 43, 48, 48, 437, 310, 201, 303, 1350, - /* 1650 */ 315, 355, 986, 454, 479, 1239, 339, 192, 105, 105, - /* 1660 */ 1422, 1421, 193, 536, 205, 106, 1527, 425, 548, 547, - /* 1670 */ 1180, 167, 976, 270, 247, 1469, 1467, 1177, 375, 375, - /* 1680 */ 374, 255, 372, 200, 369, 817, 400, 83, 79, 82, - /* 1690 */ 1427, 448, 177, 95, 1342, 161, 169, 1339, 215, 440, - /* 1700 */ 296, 172, 173, 976, 976, 978, 979, 27, 295, 174, - /* 1710 */ 175, 441, 472, 223, 1347, 383, 35, 381, 36, 461, - /* 1720 */ 88, 1353, 181, 447, 384, 1416, 227, 467, 259, 229, - /* 1730 */ 186, 488, 470, 324, 1250, 230, 231, 320, 217, 1204, - /* 1740 */ 1438, 1259, 386, 1258, 413, 90, 156, 849, 1541, 158, - /* 1750 */ 206, 415, 1540, 507, 1300, 1257, 94, 348, 1229, 1301, - /* 1760 */ 387, 1510, 1228, 338, 1227, 216, 350, 1539, 498, 283, - /* 1770 */ 284, 1249, 501, 1299, 352, 245, 246, 418, 1298, 354, - /* 1780 */ 1496, 1495, 124, 10, 526, 363, 101, 1324, 253, 96, - /* 1790 */ 510, 1210, 34, 549, 1137, 254, 256, 257, 166, 393, - /* 1800 */ 550, 1199, 1282, 361, 290, 537, 1281, 196, 367, 368, - /* 1810 */ 1194, 153, 1454, 137, 281, 1323, 1455, 804, 154, 426, - /* 1820 */ 198, 155, 1453, 1452, 292, 212, 202, 432, 1402, 203, - /* 1830 */ 271, 135, 288, 78, 1046, 1044, 960, 168, 157, 881, - /* 1840 */ 170, 219, 309, 222, 1060, 176, 964, 159, 402, 84, - /* 1850 */ 178, 404, 85, 86, 87, 160, 1063, 224, 394, 395, - /* 1860 */ 225, 1059, 146, 18, 226, 319, 243, 1174, 466, 228, - /* 1870 */ 1052, 182, 183, 37, 819, 471, 340, 232, 332, 483, - /* 1880 */ 184, 89, 162, 19, 20, 475, 91, 480, 847, 335, - /* 1890 */ 147, 860, 282, 92, 490, 93, 1125, 148, 1012, 1095, - /* 1900 */ 39, 497, 1096, 40, 500, 262, 207, 264, 930, 187, - /* 1910 */ 925, 109, 1111, 1115, 1113, 7, 1099, 242, 33, 1119, - /* 1920 */ 21, 522, 22, 23, 24, 1118, 25, 190, 97, 26, - /* 1930 */ 1027, 1013, 1011, 1015, 1069, 1016, 1068, 249, 248, 28, - /* 1940 */ 41, 891, 981, 829, 108, 29, 250, 542, 251, 370, - /* 1950 */ 373, 1133, 1132, 1190, 1190, 1190, 1190, 1190, 1190, 1190, - /* 1960 */ 1532, 1531, + /* 0 */ 564, 115, 112, 220, 169, 199, 115, 112, 220, 564, + /* 10 */ 375, 1266, 564, 376, 564, 270, 1309, 1309, 406, 407, + /* 20 */ 1084, 199, 1513, 41, 41, 515, 489, 521, 558, 558, + /* 30 */ 558, 965, 41, 41, 395, 41, 41, 51, 51, 966, + /* 40 */ 296, 1269, 296, 122, 123, 113, 1207, 1207, 1041, 1044, + /* 50 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 564, 407, + /* 60 */ 275, 275, 275, 275, 1268, 115, 112, 220, 115, 112, + /* 70 */ 220, 1512, 846, 561, 516, 561, 115, 112, 220, 250, + /* 80 */ 217, 71, 71, 122, 123, 113, 1207, 1207, 1041, 1044, + /* 90 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 440, 440, + /* 100 */ 440, 1149, 119, 119, 119, 119, 118, 118, 117, 117, + /* 110 */ 117, 116, 442, 1183, 1149, 116, 442, 1149, 546, 513, + /* 120 */ 1548, 1554, 374, 442, 6, 1183, 1154, 522, 1154, 407, + /* 130 */ 1556, 461, 373, 1554, 535, 99, 463, 332, 121, 121, + /* 140 */ 121, 121, 119, 119, 119, 119, 118, 118, 117, 117, + /* 150 */ 117, 116, 442, 122, 123, 113, 1207, 1207, 1041, 1044, + /* 160 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 1257, 1183, + /* 170 */ 1184, 1185, 243, 1064, 564, 502, 499, 498, 567, 124, + /* 180 */ 567, 1183, 1184, 1185, 474, 497, 119, 119, 119, 119, + /* 190 */ 118, 118, 117, 117, 117, 116, 442, 70, 70, 407, + /* 200 */ 121, 121, 121, 121, 114, 117, 117, 117, 116, 442, + /* 210 */ 1409, 1469, 119, 119, 119, 119, 118, 118, 117, 117, + /* 220 */ 117, 116, 442, 122, 123, 113, 1207, 1207, 1041, 1044, + /* 230 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 407, 1031, + /* 240 */ 1031, 1042, 1045, 81, 382, 541, 378, 80, 119, 119, + /* 250 */ 119, 119, 118, 118, 117, 117, 117, 116, 442, 381, + /* 260 */ 463, 332, 122, 123, 113, 1207, 1207, 1041, 1044, 1034, + /* 270 */ 1034, 120, 120, 121, 121, 121, 121, 262, 215, 512, + /* 280 */ 1424, 422, 119, 119, 119, 119, 118, 118, 117, 117, + /* 290 */ 117, 116, 442, 1231, 1, 1, 571, 2, 1235, 1573, + /* 300 */ 571, 2, 1235, 307, 1149, 141, 1600, 307, 407, 141, + /* 310 */ 1183, 361, 1317, 1035, 866, 531, 1317, 1149, 359, 1567, + /* 320 */ 1149, 119, 119, 119, 119, 118, 118, 117, 117, 117, + /* 330 */ 116, 442, 122, 123, 113, 1207, 1207, 1041, 1044, 1034, + /* 340 */ 1034, 120, 120, 121, 121, 121, 121, 275, 275, 1001, + /* 350 */ 426, 275, 275, 1128, 1627, 1021, 1627, 137, 542, 1541, + /* 360 */ 561, 272, 950, 950, 561, 1423, 1183, 1184, 1185, 1594, + /* 370 */ 866, 1012, 530, 315, 231, 1011, 468, 1276, 231, 119, + /* 380 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 442, + /* 390 */ 1570, 119, 119, 119, 119, 118, 118, 117, 117, 117, + /* 400 */ 116, 442, 330, 359, 1567, 564, 446, 1011, 1011, 1013, + /* 410 */ 446, 207, 564, 306, 555, 407, 363, 1021, 363, 346, + /* 420 */ 184, 118, 118, 117, 117, 117, 116, 442, 71, 71, + /* 430 */ 439, 438, 1126, 1012, 472, 71, 71, 1011, 205, 122, + /* 440 */ 123, 113, 1207, 1207, 1041, 1044, 1034, 1034, 120, 120, + /* 450 */ 121, 121, 121, 121, 219, 219, 472, 1183, 407, 570, + /* 460 */ 1183, 1235, 503, 1477, 149, 546, 307, 489, 141, 1011, + /* 470 */ 1011, 1013, 546, 140, 545, 1317, 1214, 191, 1214, 950, + /* 480 */ 950, 514, 122, 123, 113, 1207, 1207, 1041, 1044, 1034, + /* 490 */ 1034, 120, 120, 121, 121, 121, 121, 563, 119, 119, + /* 500 */ 119, 119, 118, 118, 117, 117, 117, 116, 442, 283, + /* 510 */ 275, 275, 415, 1183, 1184, 1185, 1183, 1184, 1185, 372, + /* 520 */ 1183, 243, 344, 561, 502, 499, 498, 1539, 407, 1540, + /* 530 */ 1183, 288, 870, 143, 497, 1549, 185, 231, 9, 6, + /* 540 */ 253, 119, 119, 119, 119, 118, 118, 117, 117, 117, + /* 550 */ 116, 442, 122, 123, 113, 1207, 1207, 1041, 1044, 1034, + /* 560 */ 1034, 120, 120, 121, 121, 121, 121, 407, 137, 446, + /* 570 */ 447, 863, 169, 1183, 397, 1204, 1183, 1184, 1185, 931, + /* 580 */ 526, 1001, 98, 339, 564, 342, 1183, 1184, 1185, 306, + /* 590 */ 555, 122, 123, 113, 1207, 1207, 1041, 1044, 1034, 1034, + /* 600 */ 120, 120, 121, 121, 121, 121, 452, 71, 71, 275, + /* 610 */ 275, 119, 119, 119, 119, 118, 118, 117, 117, 117, + /* 620 */ 116, 442, 561, 417, 306, 555, 1183, 1307, 1307, 1183, + /* 630 */ 1184, 1185, 1204, 1149, 330, 458, 318, 407, 363, 470, + /* 640 */ 431, 1167, 32, 541, 527, 350, 1149, 1629, 393, 1149, + /* 650 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116, + /* 660 */ 442, 122, 123, 113, 1207, 1207, 1041, 1044, 1034, 1034, + /* 670 */ 120, 120, 121, 121, 121, 121, 407, 199, 472, 1183, + /* 680 */ 1022, 472, 1183, 1184, 1185, 386, 151, 539, 1548, 277, + /* 690 */ 400, 137, 6, 317, 5, 564, 562, 3, 920, 920, + /* 700 */ 122, 123, 113, 1207, 1207, 1041, 1044, 1034, 1034, 120, + /* 710 */ 120, 121, 121, 121, 121, 411, 505, 83, 71, 71, + /* 720 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116, + /* 730 */ 442, 1183, 218, 428, 1183, 1183, 1184, 1185, 363, 261, + /* 740 */ 278, 358, 508, 353, 507, 248, 407, 306, 555, 1539, + /* 750 */ 1006, 349, 363, 291, 489, 302, 293, 1542, 281, 119, + /* 760 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 442, + /* 770 */ 122, 123, 113, 1207, 1207, 1041, 1044, 1034, 1034, 120, + /* 780 */ 120, 121, 121, 121, 121, 407, 148, 1183, 1184, 1185, + /* 790 */ 1183, 1184, 1185, 275, 275, 1304, 1257, 1283, 483, 1476, + /* 800 */ 150, 489, 480, 564, 1187, 1304, 561, 1587, 1255, 122, + /* 810 */ 123, 113, 1207, 1207, 1041, 1044, 1034, 1034, 120, 120, + /* 820 */ 121, 121, 121, 121, 564, 886, 13, 13, 520, 119, + /* 830 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 442, + /* 840 */ 1183, 420, 417, 564, 269, 269, 1316, 13, 13, 1539, + /* 850 */ 1546, 16, 16, 322, 6, 407, 506, 561, 1089, 1089, + /* 860 */ 486, 1187, 425, 1539, 887, 292, 71, 71, 119, 119, + /* 870 */ 119, 119, 118, 118, 117, 117, 117, 116, 442, 122, + /* 880 */ 123, 113, 1207, 1207, 1041, 1044, 1034, 1034, 120, 120, + /* 890 */ 121, 121, 121, 121, 564, 12, 1183, 1184, 1185, 407, + /* 900 */ 275, 275, 451, 303, 834, 835, 836, 417, 489, 276, + /* 910 */ 276, 1547, 284, 561, 319, 6, 321, 71, 71, 429, + /* 920 */ 451, 450, 561, 952, 101, 113, 1207, 1207, 1041, 1044, + /* 930 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 119, 119, + /* 940 */ 119, 119, 118, 118, 117, 117, 117, 116, 442, 1105, + /* 950 */ 1183, 489, 564, 1312, 437, 455, 478, 564, 246, 245, + /* 960 */ 244, 1409, 1545, 547, 1106, 405, 6, 1544, 196, 1258, + /* 970 */ 413, 6, 105, 462, 103, 71, 71, 286, 564, 1107, + /* 980 */ 13, 13, 119, 119, 119, 119, 118, 118, 117, 117, + /* 990 */ 117, 116, 442, 451, 104, 427, 337, 320, 275, 275, + /* 1000 */ 906, 13, 13, 564, 1482, 1105, 1183, 1184, 1185, 126, + /* 1010 */ 907, 561, 546, 564, 407, 478, 295, 1321, 253, 200, + /* 1020 */ 1106, 548, 1482, 1484, 280, 1409, 55, 55, 1287, 561, + /* 1030 */ 478, 380, 423, 951, 407, 1107, 71, 71, 122, 123, + /* 1040 */ 113, 1207, 1207, 1041, 1044, 1034, 1034, 120, 120, 121, + /* 1050 */ 121, 121, 121, 1204, 407, 287, 552, 309, 122, 123, + /* 1060 */ 113, 1207, 1207, 1041, 1044, 1034, 1034, 120, 120, 121, + /* 1070 */ 121, 121, 121, 441, 1128, 1628, 146, 1628, 122, 111, + /* 1080 */ 113, 1207, 1207, 1041, 1044, 1034, 1034, 120, 120, 121, + /* 1090 */ 121, 121, 121, 404, 403, 1482, 424, 119, 119, 119, + /* 1100 */ 119, 118, 118, 117, 117, 117, 116, 442, 1183, 564, + /* 1110 */ 1204, 544, 1086, 858, 329, 361, 1086, 119, 119, 119, + /* 1120 */ 119, 118, 118, 117, 117, 117, 116, 442, 564, 294, + /* 1130 */ 144, 523, 56, 56, 224, 564, 510, 119, 119, 119, + /* 1140 */ 119, 118, 118, 117, 117, 117, 116, 442, 484, 1409, + /* 1150 */ 537, 15, 15, 1126, 434, 439, 438, 407, 13, 13, + /* 1160 */ 1523, 12, 926, 1211, 1183, 1184, 1185, 925, 1213, 536, + /* 1170 */ 858, 557, 413, 193, 1525, 494, 1212, 448, 1160, 1222, + /* 1180 */ 1183, 564, 123, 113, 1207, 1207, 1041, 1044, 1034, 1034, + /* 1190 */ 120, 120, 121, 121, 121, 121, 1521, 1149, 564, 965, + /* 1200 */ 564, 1214, 247, 1214, 13, 13, 1409, 966, 538, 564, + /* 1210 */ 1149, 108, 556, 1149, 4, 310, 392, 1227, 17, 194, + /* 1220 */ 485, 43, 43, 57, 57, 306, 555, 524, 559, 1160, + /* 1230 */ 464, 564, 44, 44, 392, 1127, 1183, 1184, 1185, 479, + /* 1240 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116, + /* 1250 */ 442, 443, 564, 327, 13, 13, 564, 418, 1315, 414, + /* 1260 */ 171, 564, 311, 553, 213, 529, 1253, 564, 517, 543, + /* 1270 */ 412, 108, 556, 137, 4, 58, 58, 435, 314, 59, + /* 1280 */ 59, 274, 217, 549, 60, 60, 349, 476, 559, 1353, + /* 1290 */ 61, 61, 1021, 275, 275, 1228, 213, 564, 106, 106, + /* 1300 */ 8, 275, 275, 275, 275, 107, 561, 443, 566, 565, + /* 1310 */ 564, 443, 1011, 1228, 561, 564, 561, 564, 275, 275, + /* 1320 */ 62, 62, 1352, 553, 247, 456, 564, 98, 110, 306, + /* 1330 */ 555, 561, 564, 45, 45, 405, 1203, 533, 46, 46, + /* 1340 */ 47, 47, 532, 465, 1011, 1011, 1013, 1014, 27, 49, + /* 1350 */ 49, 564, 1021, 405, 469, 50, 50, 564, 106, 106, + /* 1360 */ 305, 564, 84, 204, 405, 107, 564, 443, 566, 565, + /* 1370 */ 405, 564, 1011, 564, 63, 63, 564, 1599, 564, 895, + /* 1380 */ 64, 64, 457, 477, 65, 65, 147, 96, 38, 14, + /* 1390 */ 14, 1528, 412, 564, 66, 66, 128, 128, 926, 67, + /* 1400 */ 67, 52, 52, 925, 1011, 1011, 1013, 1014, 27, 1572, + /* 1410 */ 1171, 445, 208, 1123, 279, 394, 68, 68, 228, 390, + /* 1420 */ 390, 389, 264, 387, 1171, 445, 843, 877, 279, 108, + /* 1430 */ 556, 453, 4, 390, 390, 389, 264, 387, 564, 225, + /* 1440 */ 843, 313, 328, 1003, 98, 252, 559, 544, 471, 312, + /* 1450 */ 252, 564, 208, 225, 564, 313, 473, 30, 252, 279, + /* 1460 */ 466, 69, 69, 312, 390, 390, 389, 264, 387, 443, + /* 1470 */ 333, 843, 98, 564, 53, 53, 323, 157, 157, 227, + /* 1480 */ 495, 553, 249, 289, 225, 564, 313, 162, 31, 1501, + /* 1490 */ 135, 564, 1500, 227, 312, 533, 158, 158, 885, 884, + /* 1500 */ 534, 162, 873, 301, 135, 564, 481, 226, 76, 76, + /* 1510 */ 1021, 347, 1071, 98, 54, 54, 106, 106, 1067, 564, + /* 1520 */ 249, 226, 519, 107, 227, 443, 566, 565, 72, 72, + /* 1530 */ 1011, 334, 162, 564, 230, 135, 108, 556, 959, 4, + /* 1540 */ 252, 408, 129, 129, 564, 1349, 306, 555, 564, 923, + /* 1550 */ 564, 110, 226, 559, 564, 408, 73, 73, 564, 873, + /* 1560 */ 306, 555, 1011, 1011, 1013, 1014, 27, 130, 130, 1071, + /* 1570 */ 449, 131, 131, 127, 127, 357, 443, 156, 156, 892, + /* 1580 */ 893, 155, 155, 338, 449, 356, 408, 564, 553, 968, + /* 1590 */ 969, 306, 555, 1015, 341, 564, 108, 556, 564, 4, + /* 1600 */ 1132, 1286, 533, 564, 856, 343, 145, 532, 345, 1300, + /* 1610 */ 136, 136, 1083, 559, 1083, 449, 564, 1021, 134, 134, + /* 1620 */ 1284, 132, 132, 106, 106, 1285, 133, 133, 564, 352, + /* 1630 */ 107, 564, 443, 566, 565, 1340, 443, 1011, 362, 75, + /* 1640 */ 75, 1082, 564, 1082, 564, 924, 1561, 110, 553, 551, + /* 1650 */ 1015, 77, 77, 1361, 74, 74, 1408, 1336, 1347, 550, + /* 1660 */ 1414, 1265, 1256, 1244, 1243, 42, 42, 48, 48, 1011, + /* 1670 */ 1011, 1013, 1014, 27, 1245, 1580, 490, 1021, 267, 202, + /* 1680 */ 1333, 365, 11, 106, 106, 930, 367, 210, 369, 391, + /* 1690 */ 107, 1395, 443, 566, 565, 223, 1390, 1011, 500, 454, + /* 1700 */ 282, 1400, 285, 108, 556, 214, 4, 325, 1383, 1283, + /* 1710 */ 475, 355, 1473, 1583, 1472, 1399, 371, 1222, 326, 398, + /* 1720 */ 559, 290, 331, 197, 100, 556, 209, 4, 198, 1011, + /* 1730 */ 1011, 1013, 1014, 27, 385, 256, 1520, 1518, 554, 1219, + /* 1740 */ 416, 559, 83, 443, 173, 206, 182, 221, 459, 167, + /* 1750 */ 177, 460, 175, 493, 233, 553, 79, 178, 1396, 179, + /* 1760 */ 35, 180, 96, 1402, 443, 396, 36, 467, 1478, 1401, + /* 1770 */ 482, 237, 1404, 399, 82, 186, 553, 1467, 89, 488, + /* 1780 */ 190, 268, 239, 491, 1021, 340, 240, 401, 1246, 1489, + /* 1790 */ 106, 106, 336, 509, 1294, 241, 1303, 107, 430, 443, + /* 1800 */ 566, 565, 1302, 91, 1011, 1021, 1598, 1301, 1273, 215, + /* 1810 */ 1597, 106, 106, 402, 877, 432, 354, 1272, 107, 1271, + /* 1820 */ 443, 566, 565, 1596, 1566, 1011, 1293, 433, 518, 299, + /* 1830 */ 300, 360, 95, 525, 1344, 364, 1011, 1011, 1013, 1014, + /* 1840 */ 27, 254, 255, 1552, 436, 1551, 125, 544, 10, 379, + /* 1850 */ 1326, 1453, 102, 97, 1345, 528, 304, 1011, 1011, 1013, + /* 1860 */ 1014, 27, 366, 377, 1343, 1342, 368, 370, 1325, 384, + /* 1870 */ 201, 383, 34, 1368, 1367, 568, 1177, 266, 263, 265, + /* 1880 */ 1505, 159, 569, 1241, 1236, 1506, 160, 142, 1504, 1503, + /* 1890 */ 297, 211, 830, 161, 212, 78, 444, 203, 308, 222, + /* 1900 */ 1081, 139, 1079, 316, 174, 163, 1203, 229, 176, 909, + /* 1910 */ 324, 232, 1095, 181, 409, 410, 172, 164, 165, 419, + /* 1920 */ 183, 85, 86, 421, 166, 87, 88, 1098, 1094, 234, + /* 1930 */ 235, 152, 18, 236, 335, 1087, 1216, 252, 187, 487, + /* 1940 */ 238, 188, 37, 845, 492, 356, 242, 496, 351, 501, + /* 1950 */ 189, 90, 19, 504, 348, 20, 875, 92, 298, 168, + /* 1960 */ 888, 153, 93, 511, 94, 1165, 154, 1047, 1134, 39, + /* 1970 */ 216, 1133, 271, 273, 958, 192, 953, 110, 1151, 1155, + /* 1980 */ 251, 7, 21, 1159, 1139, 22, 1153, 33, 23, 24, + /* 1990 */ 25, 540, 1158, 195, 98, 1062, 26, 1048, 1046, 1050, + /* 2000 */ 1104, 1051, 1103, 257, 258, 28, 40, 1173, 1016, 857, + /* 2010 */ 109, 29, 560, 388, 138, 1172, 259, 170, 260, 1232, + /* 2020 */ 1232, 919, 1232, 1232, 1232, 1232, 1232, 1232, 1232, 1232, + /* 2030 */ 1232, 1232, 1589, 1232, 1232, 1232, 1588, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 189, 211, 189, 189, 218, 189, 220, 189, 267, 268, - /* 10 */ 269, 189, 210, 189, 228, 189, 267, 268, 269, 19, - /* 20 */ 218, 189, 211, 212, 211, 212, 211, 211, 212, 211, - /* 30 */ 212, 31, 211, 211, 212, 211, 212, 288, 300, 39, - /* 40 */ 21, 189, 304, 43, 44, 45, 46, 47, 48, 49, - /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 225, 19, - /* 60 */ 189, 183, 184, 185, 186, 189, 248, 263, 236, 191, - /* 70 */ 248, 193, 248, 197, 208, 257, 262, 201, 200, 257, - /* 80 */ 200, 257, 81, 43, 44, 45, 46, 47, 48, 49, - /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 189, 80, - /* 100 */ 189, 101, 102, 103, 104, 105, 106, 107, 108, 109, - /* 110 */ 110, 111, 234, 235, 234, 235, 305, 306, 305, 118, - /* 120 */ 307, 305, 306, 297, 298, 247, 86, 247, 88, 19, - /* 130 */ 259, 251, 252, 267, 268, 269, 26, 136, 137, 261, - /* 140 */ 121, 101, 102, 103, 104, 105, 106, 107, 108, 109, - /* 150 */ 110, 111, 59, 43, 44, 45, 46, 47, 48, 49, - /* 160 */ 50, 51, 52, 53, 54, 55, 56, 57, 259, 291, - /* 170 */ 105, 106, 107, 108, 109, 110, 111, 158, 189, 69, - /* 180 */ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - /* 190 */ 111, 107, 108, 109, 110, 111, 205, 206, 207, 19, - /* 200 */ 19, 54, 55, 56, 57, 58, 29, 114, 115, 116, - /* 210 */ 33, 101, 102, 103, 104, 105, 106, 107, 108, 109, - /* 220 */ 110, 111, 233, 43, 44, 45, 46, 47, 48, 49, - /* 230 */ 50, 51, 52, 53, 54, 55, 56, 57, 19, 126, - /* 240 */ 127, 148, 65, 24, 214, 200, 59, 67, 101, 102, - /* 250 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 22, - /* 260 */ 189, 111, 43, 44, 45, 46, 47, 48, 49, 50, - /* 270 */ 51, 52, 53, 54, 55, 56, 57, 206, 207, 234, - /* 280 */ 235, 101, 102, 103, 104, 105, 106, 107, 108, 109, - /* 290 */ 110, 111, 247, 76, 107, 114, 59, 267, 268, 269, - /* 300 */ 189, 114, 115, 116, 162, 163, 89, 19, 263, 92, - /* 310 */ 189, 23, 54, 55, 56, 57, 189, 206, 207, 22, - /* 320 */ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - /* 330 */ 111, 43, 44, 45, 46, 47, 48, 49, 50, 51, - /* 340 */ 52, 53, 54, 55, 56, 57, 19, 189, 277, 59, - /* 350 */ 23, 114, 115, 116, 46, 47, 48, 49, 61, 101, - /* 360 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - /* 370 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - /* 380 */ 53, 54, 55, 56, 57, 125, 126, 127, 277, 101, - /* 390 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - /* 400 */ 59, 189, 189, 276, 114, 115, 116, 117, 73, 59, - /* 410 */ 120, 121, 122, 72, 214, 19, 81, 259, 19, 23, - /* 420 */ 130, 81, 72, 24, 211, 212, 221, 119, 101, 102, - /* 430 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 43, + /* 0 */ 192, 273, 274, 275, 192, 192, 273, 274, 275, 192, + /* 10 */ 218, 215, 192, 218, 192, 212, 234, 235, 205, 19, + /* 20 */ 11, 192, 294, 215, 216, 203, 192, 203, 209, 210, + /* 30 */ 211, 31, 215, 216, 205, 215, 216, 215, 216, 39, + /* 40 */ 227, 215, 229, 43, 44, 45, 46, 47, 48, 49, + /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 192, 19, + /* 60 */ 238, 239, 238, 239, 215, 273, 274, 275, 273, 274, + /* 70 */ 275, 237, 21, 251, 252, 251, 273, 274, 275, 255, + /* 80 */ 256, 215, 216, 43, 44, 45, 46, 47, 48, 49, + /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 209, 210, + /* 100 */ 211, 76, 102, 103, 104, 105, 106, 107, 108, 109, + /* 110 */ 110, 111, 112, 59, 89, 111, 112, 92, 252, 307, + /* 120 */ 308, 313, 314, 112, 312, 59, 86, 261, 88, 19, + /* 130 */ 313, 80, 315, 313, 314, 25, 127, 128, 54, 55, + /* 140 */ 56, 57, 102, 103, 104, 105, 106, 107, 108, 109, + /* 150 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49, + /* 160 */ 50, 51, 52, 53, 54, 55, 56, 57, 192, 115, + /* 170 */ 116, 117, 118, 122, 192, 121, 122, 123, 202, 69, + /* 180 */ 204, 115, 116, 117, 192, 131, 102, 103, 104, 105, + /* 190 */ 106, 107, 108, 109, 110, 111, 112, 215, 216, 19, + /* 200 */ 54, 55, 56, 57, 58, 108, 109, 110, 111, 112, + /* 210 */ 192, 160, 102, 103, 104, 105, 106, 107, 108, 109, + /* 220 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49, + /* 230 */ 50, 51, 52, 53, 54, 55, 56, 57, 19, 46, + /* 240 */ 47, 48, 49, 24, 248, 192, 250, 67, 102, 103, + /* 250 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 277, + /* 260 */ 127, 128, 43, 44, 45, 46, 47, 48, 49, 50, + /* 270 */ 51, 52, 53, 54, 55, 56, 57, 26, 164, 165, + /* 280 */ 272, 263, 102, 103, 104, 105, 106, 107, 108, 109, + /* 290 */ 110, 111, 112, 184, 185, 186, 187, 188, 189, 186, + /* 300 */ 187, 188, 189, 194, 76, 196, 229, 194, 19, 196, + /* 310 */ 59, 192, 203, 120, 59, 87, 203, 89, 310, 311, + /* 320 */ 92, 102, 103, 104, 105, 106, 107, 108, 109, 110, + /* 330 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50, + /* 340 */ 51, 52, 53, 54, 55, 56, 57, 238, 239, 73, + /* 350 */ 231, 238, 239, 22, 23, 100, 25, 81, 305, 306, + /* 360 */ 251, 23, 25, 25, 251, 272, 115, 116, 117, 214, + /* 370 */ 115, 116, 144, 192, 265, 120, 114, 222, 265, 102, + /* 380 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + /* 390 */ 192, 102, 103, 104, 105, 106, 107, 108, 109, 110, + /* 400 */ 111, 112, 126, 310, 311, 192, 297, 152, 153, 154, + /* 410 */ 297, 149, 192, 137, 138, 19, 192, 100, 192, 23, + /* 420 */ 22, 106, 107, 108, 109, 110, 111, 112, 215, 216, + /* 430 */ 106, 107, 101, 116, 192, 215, 216, 120, 149, 43, /* 440 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - /* 450 */ 54, 55, 56, 57, 19, 114, 115, 116, 23, 208, - /* 460 */ 125, 248, 189, 189, 114, 115, 116, 267, 268, 269, - /* 470 */ 189, 136, 137, 189, 262, 22, 136, 137, 43, 44, - /* 480 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - /* 490 */ 55, 56, 57, 189, 95, 211, 212, 101, 102, 103, - /* 500 */ 104, 105, 106, 107, 108, 109, 110, 111, 59, 189, - /* 510 */ 111, 189, 59, 76, 294, 295, 117, 118, 119, 120, - /* 520 */ 121, 122, 123, 19, 87, 189, 89, 23, 129, 92, - /* 530 */ 279, 227, 248, 22, 189, 284, 101, 102, 103, 104, - /* 540 */ 105, 106, 107, 108, 109, 110, 111, 43, 44, 45, - /* 550 */ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - /* 560 */ 56, 57, 19, 114, 115, 116, 23, 114, 115, 116, - /* 570 */ 59, 117, 299, 300, 120, 121, 122, 304, 189, 189, - /* 580 */ 143, 189, 110, 111, 130, 22, 43, 44, 45, 46, - /* 590 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - /* 600 */ 57, 211, 212, 211, 212, 101, 102, 103, 104, 105, - /* 610 */ 106, 107, 108, 109, 110, 111, 226, 189, 226, 189, - /* 620 */ 298, 132, 59, 134, 135, 114, 115, 116, 189, 59, - /* 630 */ 285, 19, 7, 8, 9, 23, 205, 206, 207, 211, - /* 640 */ 212, 211, 212, 221, 101, 102, 103, 104, 105, 106, - /* 650 */ 107, 108, 109, 110, 111, 43, 44, 45, 46, 47, - /* 660 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - /* 670 */ 19, 181, 182, 183, 184, 185, 186, 114, 115, 116, - /* 680 */ 189, 191, 133, 193, 114, 115, 116, 138, 299, 300, - /* 690 */ 200, 22, 201, 304, 43, 44, 45, 46, 47, 48, - /* 700 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 35, - /* 710 */ 189, 141, 189, 101, 102, 103, 104, 105, 106, 107, - /* 720 */ 108, 109, 110, 111, 234, 235, 22, 23, 59, 184, - /* 730 */ 26, 186, 211, 212, 211, 212, 191, 247, 193, 19, - /* 740 */ 66, 105, 106, 73, 189, 200, 189, 226, 74, 226, - /* 750 */ 22, 261, 101, 102, 103, 104, 105, 106, 107, 108, - /* 760 */ 109, 110, 111, 43, 44, 45, 46, 47, 48, 49, - /* 770 */ 50, 51, 52, 53, 54, 55, 56, 57, 189, 234, - /* 780 */ 235, 291, 19, 114, 115, 116, 150, 59, 152, 189, - /* 790 */ 233, 236, 247, 59, 189, 125, 126, 127, 59, 300, - /* 800 */ 211, 212, 128, 304, 100, 19, 261, 156, 45, 46, - /* 810 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - /* 820 */ 57, 101, 102, 103, 104, 105, 106, 107, 108, 109, - /* 830 */ 110, 111, 46, 233, 189, 189, 291, 248, 99, 189, - /* 840 */ 125, 126, 127, 115, 26, 200, 289, 230, 231, 115, - /* 850 */ 200, 16, 189, 114, 115, 189, 211, 212, 119, 221, - /* 860 */ 189, 211, 212, 258, 101, 102, 103, 104, 105, 106, - /* 870 */ 107, 108, 109, 110, 111, 189, 156, 211, 212, 234, - /* 880 */ 235, 189, 211, 212, 234, 235, 22, 201, 189, 150, - /* 890 */ 151, 152, 247, 248, 76, 16, 19, 247, 248, 113, - /* 900 */ 189, 24, 257, 211, 212, 189, 26, 89, 262, 223, - /* 910 */ 92, 225, 77, 189, 79, 129, 19, 53, 226, 248, - /* 920 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - /* 930 */ 53, 54, 55, 56, 57, 236, 19, 271, 189, 99, - /* 940 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - /* 950 */ 53, 54, 55, 56, 57, 115, 77, 59, 79, 119, - /* 960 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - /* 970 */ 53, 54, 55, 56, 57, 259, 22, 23, 101, 102, - /* 980 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 59, - /* 990 */ 150, 151, 152, 158, 22, 244, 24, 246, 101, 102, - /* 1000 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 285, - /* 1010 */ 189, 189, 114, 115, 116, 200, 136, 137, 101, 102, - /* 1020 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 230, - /* 1030 */ 231, 59, 211, 212, 285, 105, 106, 189, 19, 141, - /* 1040 */ 234, 235, 239, 113, 114, 115, 116, 226, 118, 234, - /* 1050 */ 235, 189, 249, 247, 100, 189, 126, 23, 236, 107, - /* 1060 */ 26, 189, 247, 44, 45, 46, 47, 48, 49, 50, - /* 1070 */ 51, 52, 53, 54, 55, 56, 57, 211, 212, 59, - /* 1080 */ 150, 233, 152, 211, 212, 133, 12, 115, 189, 189, - /* 1090 */ 138, 19, 20, 300, 22, 233, 76, 304, 226, 11, - /* 1100 */ 208, 27, 22, 23, 200, 19, 26, 87, 36, 89, - /* 1110 */ 211, 212, 92, 300, 248, 189, 42, 304, 189, 250, - /* 1120 */ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - /* 1130 */ 111, 59, 200, 233, 114, 115, 116, 63, 234, 235, - /* 1140 */ 235, 19, 20, 71, 22, 300, 189, 73, 200, 304, - /* 1150 */ 116, 247, 247, 81, 189, 200, 227, 26, 36, 234, - /* 1160 */ 235, 203, 204, 143, 200, 26, 234, 235, 194, 200, - /* 1170 */ 48, 99, 247, 66, 189, 141, 284, 105, 106, 247, - /* 1180 */ 100, 59, 234, 235, 112, 259, 114, 115, 116, 234, - /* 1190 */ 235, 119, 85, 71, 266, 247, 211, 212, 234, 235, - /* 1200 */ 114, 94, 247, 234, 235, 12, 266, 85, 136, 137, - /* 1210 */ 189, 247, 90, 26, 126, 127, 247, 189, 26, 22, - /* 1220 */ 27, 99, 150, 151, 152, 153, 154, 105, 106, 189, - /* 1230 */ 302, 303, 211, 212, 112, 42, 114, 115, 116, 211, - /* 1240 */ 212, 119, 302, 303, 19, 20, 189, 22, 274, 189, - /* 1250 */ 15, 144, 278, 189, 22, 23, 63, 189, 189, 203, - /* 1260 */ 204, 36, 136, 137, 155, 24, 157, 143, 211, 212, - /* 1270 */ 189, 140, 150, 151, 152, 153, 154, 0, 1, 2, - /* 1280 */ 211, 212, 5, 46, 59, 161, 147, 10, 11, 12, - /* 1290 */ 13, 14, 211, 212, 17, 60, 71, 189, 258, 189, - /* 1300 */ 59, 189, 105, 106, 189, 189, 189, 30, 116, 32, - /* 1310 */ 85, 124, 189, 251, 252, 90, 189, 40, 258, 211, - /* 1320 */ 212, 211, 212, 189, 99, 26, 211, 212, 211, 212, - /* 1330 */ 105, 106, 100, 141, 211, 212, 119, 112, 189, 114, - /* 1340 */ 115, 116, 23, 189, 119, 26, 129, 70, 189, 31, - /* 1350 */ 113, 19, 20, 24, 22, 78, 115, 39, 81, 189, - /* 1360 */ 211, 212, 26, 189, 22, 211, 212, 189, 36, 189, - /* 1370 */ 211, 212, 189, 189, 97, 150, 151, 152, 153, 154, - /* 1380 */ 127, 211, 212, 189, 189, 211, 212, 189, 189, 211, - /* 1390 */ 212, 59, 189, 189, 211, 212, 23, 189, 22, 26, - /* 1400 */ 24, 189, 149, 71, 189, 211, 212, 189, 131, 211, - /* 1410 */ 212, 189, 189, 136, 137, 211, 212, 85, 189, 211, - /* 1420 */ 212, 59, 90, 211, 212, 292, 293, 118, 119, 211, - /* 1430 */ 212, 99, 23, 211, 212, 26, 159, 105, 106, 189, - /* 1440 */ 211, 212, 143, 150, 112, 152, 114, 115, 116, 1, - /* 1450 */ 2, 119, 23, 5, 23, 26, 189, 26, 10, 11, - /* 1460 */ 12, 13, 14, 83, 84, 17, 253, 189, 139, 189, - /* 1470 */ 19, 20, 189, 22, 189, 189, 140, 115, 30, 59, - /* 1480 */ 32, 139, 150, 151, 152, 153, 154, 36, 40, 211, - /* 1490 */ 212, 211, 212, 59, 211, 212, 211, 212, 7, 8, - /* 1500 */ 19, 20, 189, 22, 150, 189, 152, 231, 281, 189, - /* 1510 */ 59, 189, 23, 189, 189, 26, 189, 36, 70, 189, - /* 1520 */ 23, 237, 71, 26, 211, 212, 78, 211, 212, 81, - /* 1530 */ 189, 211, 212, 211, 212, 115, 211, 212, 211, 212, - /* 1540 */ 59, 211, 212, 23, 23, 97, 26, 26, 23, 115, - /* 1550 */ 99, 26, 71, 189, 189, 189, 105, 106, 107, 23, - /* 1560 */ 189, 23, 26, 112, 26, 114, 115, 116, 189, 309, - /* 1570 */ 119, 23, 19, 20, 26, 22, 189, 211, 212, 131, - /* 1580 */ 99, 189, 211, 212, 136, 137, 105, 106, 189, 36, - /* 1590 */ 211, 212, 189, 112, 189, 114, 115, 116, 211, 212, - /* 1600 */ 119, 150, 151, 152, 153, 154, 189, 159, 23, 250, - /* 1610 */ 189, 26, 59, 189, 189, 189, 189, 189, 280, 189, - /* 1620 */ 250, 189, 189, 238, 71, 189, 189, 250, 211, 212, - /* 1630 */ 187, 150, 151, 152, 153, 154, 211, 212, 250, 290, - /* 1640 */ 240, 211, 212, 211, 212, 254, 286, 209, 254, 241, - /* 1650 */ 240, 254, 99, 286, 215, 220, 214, 244, 105, 106, - /* 1660 */ 214, 214, 244, 273, 224, 112, 192, 114, 115, 116, - /* 1670 */ 60, 290, 119, 5, 139, 196, 196, 38, 10, 11, - /* 1680 */ 12, 13, 14, 238, 240, 17, 196, 148, 287, 287, - /* 1690 */ 276, 113, 22, 147, 241, 43, 229, 241, 30, 18, - /* 1700 */ 32, 232, 232, 150, 151, 152, 153, 154, 40, 232, - /* 1710 */ 232, 196, 18, 195, 265, 265, 264, 241, 264, 196, - /* 1720 */ 155, 229, 229, 241, 241, 241, 195, 62, 196, 195, - /* 1730 */ 22, 113, 216, 196, 222, 195, 195, 282, 70, 196, - /* 1740 */ 283, 213, 216, 213, 64, 22, 78, 124, 219, 81, - /* 1750 */ 162, 111, 219, 142, 256, 213, 113, 255, 213, 256, - /* 1760 */ 216, 303, 215, 213, 213, 97, 255, 213, 216, 275, - /* 1770 */ 275, 222, 216, 256, 255, 196, 91, 82, 256, 255, - /* 1780 */ 308, 308, 146, 22, 143, 196, 155, 260, 25, 145, - /* 1790 */ 144, 199, 26, 198, 13, 190, 190, 6, 293, 131, - /* 1800 */ 188, 188, 245, 244, 136, 137, 245, 243, 242, 241, - /* 1810 */ 188, 202, 208, 217, 217, 260, 208, 4, 202, 3, - /* 1820 */ 22, 202, 208, 208, 160, 15, 209, 159, 270, 209, - /* 1830 */ 98, 16, 272, 208, 23, 23, 137, 148, 128, 20, - /* 1840 */ 140, 24, 16, 142, 1, 140, 149, 128, 61, 53, - /* 1850 */ 148, 37, 53, 53, 53, 128, 114, 34, 296, 296, - /* 1860 */ 139, 1, 5, 22, 113, 158, 26, 75, 41, 139, - /* 1870 */ 68, 68, 113, 24, 20, 19, 129, 123, 23, 96, - /* 1880 */ 22, 22, 37, 22, 22, 67, 22, 67, 59, 24, - /* 1890 */ 23, 28, 67, 147, 22, 26, 23, 23, 23, 23, - /* 1900 */ 22, 24, 23, 22, 24, 23, 139, 23, 114, 22, - /* 1910 */ 141, 26, 88, 75, 86, 44, 23, 34, 22, 75, - /* 1920 */ 34, 24, 34, 34, 34, 93, 34, 26, 26, 34, - /* 1930 */ 23, 23, 23, 23, 23, 11, 23, 22, 26, 22, - /* 1940 */ 22, 133, 23, 23, 22, 22, 139, 26, 139, 23, - /* 1950 */ 15, 1, 1, 310, 310, 310, 310, 310, 310, 310, - /* 1960 */ 139, 139, 310, 310, 310, 310, 310, 310, 310, 310, - /* 1970 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 1980 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 1990 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2000 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2010 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2020 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2030 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2040 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2050 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2060 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2070 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2080 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2090 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2100 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2110 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2120 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2130 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, - /* 2140 */ 310, 310, 310, + /* 450 */ 54, 55, 56, 57, 117, 117, 192, 59, 19, 187, + /* 460 */ 59, 189, 23, 282, 240, 252, 194, 192, 196, 152, + /* 470 */ 153, 154, 252, 72, 261, 203, 152, 25, 154, 142, + /* 480 */ 142, 261, 43, 44, 45, 46, 47, 48, 49, 50, + /* 490 */ 51, 52, 53, 54, 55, 56, 57, 192, 102, 103, + /* 500 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 267, + /* 510 */ 238, 239, 237, 115, 116, 117, 115, 116, 117, 192, + /* 520 */ 59, 118, 16, 251, 121, 122, 123, 303, 19, 303, + /* 530 */ 59, 267, 23, 72, 131, 308, 22, 265, 22, 312, + /* 540 */ 24, 102, 103, 104, 105, 106, 107, 108, 109, 110, + /* 550 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50, + /* 560 */ 51, 52, 53, 54, 55, 56, 57, 19, 81, 297, + /* 570 */ 295, 23, 192, 59, 203, 59, 115, 116, 117, 108, + /* 580 */ 192, 73, 25, 77, 192, 79, 115, 116, 117, 137, + /* 590 */ 138, 43, 44, 45, 46, 47, 48, 49, 50, 51, + /* 600 */ 52, 53, 54, 55, 56, 57, 119, 215, 216, 238, + /* 610 */ 239, 102, 103, 104, 105, 106, 107, 108, 109, 110, + /* 620 */ 111, 112, 251, 192, 137, 138, 59, 234, 235, 115, + /* 630 */ 116, 117, 116, 76, 126, 127, 128, 19, 192, 268, + /* 640 */ 19, 23, 22, 192, 252, 24, 89, 300, 301, 92, + /* 650 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + /* 660 */ 112, 43, 44, 45, 46, 47, 48, 49, 50, 51, + /* 670 */ 52, 53, 54, 55, 56, 57, 19, 192, 192, 59, + /* 680 */ 23, 192, 115, 116, 117, 200, 240, 307, 308, 22, + /* 690 */ 205, 81, 312, 262, 22, 192, 133, 22, 135, 136, + /* 700 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + /* 710 */ 53, 54, 55, 56, 57, 197, 95, 150, 215, 216, + /* 720 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + /* 730 */ 112, 59, 192, 112, 59, 115, 116, 117, 192, 118, + /* 740 */ 119, 120, 121, 122, 123, 124, 19, 137, 138, 303, + /* 750 */ 23, 130, 192, 267, 192, 252, 267, 306, 203, 102, + /* 760 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + /* 770 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + /* 780 */ 53, 54, 55, 56, 57, 19, 240, 115, 116, 117, + /* 790 */ 115, 116, 117, 238, 239, 222, 192, 224, 280, 237, + /* 800 */ 240, 192, 284, 192, 59, 232, 251, 140, 204, 43, + /* 810 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + /* 820 */ 54, 55, 56, 57, 192, 35, 215, 216, 192, 102, + /* 830 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + /* 840 */ 59, 230, 192, 192, 238, 239, 237, 215, 216, 303, + /* 850 */ 308, 215, 216, 16, 312, 19, 66, 251, 126, 127, + /* 860 */ 128, 116, 230, 303, 74, 203, 215, 216, 102, 103, + /* 870 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 43, + /* 880 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + /* 890 */ 54, 55, 56, 57, 192, 212, 115, 116, 117, 19, + /* 900 */ 238, 239, 192, 252, 7, 8, 9, 192, 192, 238, + /* 910 */ 239, 308, 262, 251, 77, 312, 79, 215, 216, 129, + /* 920 */ 210, 211, 251, 142, 158, 45, 46, 47, 48, 49, + /* 930 */ 50, 51, 52, 53, 54, 55, 56, 57, 102, 103, + /* 940 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 12, + /* 950 */ 59, 192, 192, 237, 252, 243, 192, 192, 126, 127, + /* 960 */ 128, 192, 308, 203, 27, 253, 312, 308, 285, 207, + /* 970 */ 208, 312, 157, 290, 159, 215, 216, 262, 192, 42, + /* 980 */ 215, 216, 102, 103, 104, 105, 106, 107, 108, 109, + /* 990 */ 110, 111, 112, 283, 158, 230, 237, 160, 238, 239, + /* 1000 */ 63, 215, 216, 192, 192, 12, 115, 116, 117, 22, + /* 1010 */ 73, 251, 252, 192, 19, 192, 230, 239, 24, 24, + /* 1020 */ 27, 261, 210, 211, 99, 192, 215, 216, 225, 251, + /* 1030 */ 192, 192, 263, 142, 19, 42, 215, 216, 43, 44, + /* 1040 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + /* 1050 */ 55, 56, 57, 59, 19, 291, 63, 132, 43, 44, + /* 1060 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + /* 1070 */ 55, 56, 57, 252, 22, 23, 22, 25, 43, 44, + /* 1080 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + /* 1090 */ 55, 56, 57, 106, 107, 283, 263, 102, 103, 104, + /* 1100 */ 105, 106, 107, 108, 109, 110, 111, 112, 59, 192, + /* 1110 */ 116, 144, 29, 59, 291, 192, 33, 102, 103, 104, + /* 1120 */ 105, 106, 107, 108, 109, 110, 111, 112, 192, 291, + /* 1130 */ 163, 19, 215, 216, 15, 192, 108, 102, 103, 104, + /* 1140 */ 105, 106, 107, 108, 109, 110, 111, 112, 65, 192, + /* 1150 */ 66, 215, 216, 101, 231, 106, 107, 19, 215, 216, + /* 1160 */ 192, 212, 134, 114, 115, 116, 117, 139, 119, 85, + /* 1170 */ 116, 207, 208, 230, 192, 19, 127, 192, 94, 60, + /* 1180 */ 59, 192, 44, 45, 46, 47, 48, 49, 50, 51, + /* 1190 */ 52, 53, 54, 55, 56, 57, 192, 76, 192, 31, + /* 1200 */ 192, 152, 46, 154, 215, 216, 192, 39, 87, 192, + /* 1210 */ 89, 19, 20, 92, 22, 192, 22, 23, 22, 230, + /* 1220 */ 263, 215, 216, 215, 216, 137, 138, 115, 36, 145, + /* 1230 */ 128, 192, 215, 216, 22, 23, 115, 116, 117, 290, + /* 1240 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + /* 1250 */ 112, 59, 192, 151, 215, 216, 192, 61, 203, 298, + /* 1260 */ 299, 192, 192, 71, 25, 144, 203, 192, 203, 230, + /* 1270 */ 114, 19, 20, 81, 22, 215, 216, 263, 192, 215, + /* 1280 */ 216, 255, 256, 203, 215, 216, 130, 19, 36, 192, + /* 1290 */ 215, 216, 100, 238, 239, 101, 25, 192, 106, 107, + /* 1300 */ 48, 238, 239, 238, 239, 113, 251, 115, 116, 117, + /* 1310 */ 192, 59, 120, 101, 251, 192, 251, 192, 238, 239, + /* 1320 */ 215, 216, 192, 71, 46, 243, 192, 25, 25, 137, + /* 1330 */ 138, 251, 192, 215, 216, 253, 25, 85, 215, 216, + /* 1340 */ 215, 216, 90, 243, 152, 153, 154, 155, 156, 215, + /* 1350 */ 216, 192, 100, 253, 243, 215, 216, 192, 106, 107, + /* 1360 */ 243, 192, 148, 149, 253, 113, 192, 115, 116, 117, + /* 1370 */ 253, 192, 120, 192, 215, 216, 192, 23, 192, 25, + /* 1380 */ 215, 216, 192, 115, 215, 216, 22, 148, 24, 215, + /* 1390 */ 216, 192, 114, 192, 215, 216, 215, 216, 134, 215, + /* 1400 */ 216, 215, 216, 139, 152, 153, 154, 155, 156, 0, + /* 1410 */ 1, 2, 141, 23, 5, 25, 215, 216, 24, 10, + /* 1420 */ 11, 12, 13, 14, 1, 2, 17, 125, 5, 19, + /* 1430 */ 20, 268, 22, 10, 11, 12, 13, 14, 192, 30, + /* 1440 */ 17, 32, 23, 23, 25, 25, 36, 144, 23, 40, + /* 1450 */ 25, 192, 141, 30, 192, 32, 23, 22, 25, 5, + /* 1460 */ 128, 215, 216, 40, 10, 11, 12, 13, 14, 59, + /* 1470 */ 23, 17, 25, 192, 215, 216, 192, 215, 216, 70, + /* 1480 */ 23, 71, 25, 151, 30, 192, 32, 78, 53, 192, + /* 1490 */ 81, 192, 192, 70, 40, 85, 215, 216, 119, 120, + /* 1500 */ 90, 78, 59, 254, 81, 192, 192, 98, 215, 216, + /* 1510 */ 100, 23, 59, 25, 215, 216, 106, 107, 23, 192, + /* 1520 */ 25, 98, 19, 113, 70, 115, 116, 117, 215, 216, + /* 1530 */ 120, 192, 78, 192, 140, 81, 19, 20, 23, 22, + /* 1540 */ 25, 132, 215, 216, 192, 192, 137, 138, 192, 23, + /* 1550 */ 192, 25, 98, 36, 192, 132, 215, 216, 192, 116, + /* 1560 */ 137, 138, 152, 153, 154, 155, 156, 215, 216, 116, + /* 1570 */ 161, 215, 216, 215, 216, 120, 59, 215, 216, 7, + /* 1580 */ 8, 215, 216, 192, 161, 130, 132, 192, 71, 83, + /* 1590 */ 84, 137, 138, 59, 192, 192, 19, 20, 192, 22, + /* 1600 */ 97, 225, 85, 192, 23, 192, 25, 90, 192, 192, + /* 1610 */ 215, 216, 152, 36, 154, 161, 192, 100, 215, 216, + /* 1620 */ 192, 215, 216, 106, 107, 225, 215, 216, 192, 192, + /* 1630 */ 113, 192, 115, 116, 117, 257, 59, 120, 192, 215, + /* 1640 */ 216, 152, 192, 154, 192, 23, 317, 25, 71, 235, + /* 1650 */ 116, 215, 216, 192, 215, 216, 192, 192, 192, 192, + /* 1660 */ 192, 192, 192, 192, 192, 215, 216, 215, 216, 152, + /* 1670 */ 153, 154, 155, 156, 192, 192, 287, 100, 286, 241, + /* 1680 */ 254, 254, 242, 106, 107, 108, 254, 213, 254, 190, + /* 1690 */ 113, 270, 115, 116, 117, 296, 266, 120, 219, 258, + /* 1700 */ 244, 270, 258, 19, 20, 228, 22, 292, 266, 224, + /* 1710 */ 292, 218, 218, 195, 218, 270, 258, 60, 245, 270, + /* 1720 */ 36, 245, 244, 248, 19, 20, 242, 22, 248, 152, + /* 1730 */ 153, 154, 155, 156, 244, 140, 199, 199, 279, 38, + /* 1740 */ 199, 36, 150, 59, 296, 149, 22, 296, 18, 43, + /* 1750 */ 236, 199, 233, 18, 198, 71, 293, 236, 271, 236, + /* 1760 */ 269, 236, 148, 271, 59, 245, 269, 245, 282, 271, + /* 1770 */ 199, 198, 233, 245, 293, 233, 71, 245, 157, 62, + /* 1780 */ 22, 199, 198, 220, 100, 199, 198, 220, 199, 289, + /* 1790 */ 106, 107, 288, 114, 226, 198, 217, 113, 64, 115, + /* 1800 */ 116, 117, 217, 22, 120, 100, 223, 217, 217, 164, + /* 1810 */ 223, 106, 107, 220, 125, 24, 217, 219, 113, 217, + /* 1820 */ 115, 116, 117, 217, 311, 120, 226, 112, 304, 281, + /* 1830 */ 281, 220, 114, 143, 260, 259, 152, 153, 154, 155, + /* 1840 */ 156, 199, 91, 316, 82, 316, 147, 144, 22, 199, + /* 1850 */ 249, 276, 157, 146, 260, 145, 278, 152, 153, 154, + /* 1860 */ 155, 156, 259, 248, 260, 260, 259, 259, 249, 245, + /* 1870 */ 247, 246, 25, 264, 264, 201, 13, 6, 193, 193, + /* 1880 */ 212, 206, 191, 191, 191, 212, 206, 221, 212, 212, + /* 1890 */ 221, 213, 4, 206, 213, 212, 3, 22, 162, 15, + /* 1900 */ 23, 16, 23, 138, 150, 129, 25, 24, 141, 20, + /* 1910 */ 16, 143, 1, 141, 302, 302, 299, 129, 129, 61, + /* 1920 */ 150, 53, 53, 37, 129, 53, 53, 115, 1, 34, + /* 1930 */ 140, 5, 22, 114, 160, 68, 75, 25, 68, 41, + /* 1940 */ 140, 114, 24, 20, 19, 130, 124, 67, 24, 67, + /* 1950 */ 22, 22, 22, 96, 23, 22, 59, 22, 67, 37, + /* 1960 */ 28, 23, 148, 22, 25, 23, 23, 23, 23, 22, + /* 1970 */ 140, 97, 23, 23, 115, 22, 142, 25, 88, 75, + /* 1980 */ 34, 44, 34, 75, 23, 34, 86, 22, 34, 34, + /* 1990 */ 34, 24, 93, 25, 25, 23, 34, 23, 23, 23, + /* 2000 */ 23, 11, 23, 25, 22, 22, 22, 1, 23, 23, + /* 2010 */ 22, 22, 25, 15, 23, 1, 140, 25, 140, 318, + /* 2020 */ 318, 134, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2030 */ 318, 318, 140, 318, 318, 318, 140, 318, 318, 318, + /* 2040 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2050 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2060 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2070 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2080 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2090 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2100 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2110 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2120 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2130 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2140 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2150 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2160 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2170 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2180 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2190 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2200 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2210 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, + /* 2220 */ 318, }; -#define YY_SHIFT_COUNT (552) +#define YY_SHIFT_COUNT (571) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (1951) +#define YY_SHIFT_MAX (2014) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 1448, 1277, 1668, 1072, 1072, 340, 1122, 1225, 1332, 1481, - /* 10 */ 1481, 1481, 335, 0, 0, 180, 897, 1481, 1481, 1481, - /* 20 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, - /* 30 */ 930, 930, 1020, 1020, 290, 1, 340, 340, 340, 340, - /* 40 */ 340, 340, 40, 110, 219, 288, 327, 396, 435, 504, - /* 50 */ 543, 612, 651, 720, 877, 897, 897, 897, 897, 897, - /* 60 */ 897, 897, 897, 897, 897, 897, 897, 897, 897, 897, - /* 70 */ 897, 897, 897, 917, 897, 1019, 763, 763, 1451, 1481, - /* 80 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, - /* 90 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, - /* 100 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, - /* 110 */ 1481, 1481, 1553, 1481, 1481, 1481, 1481, 1481, 1481, 1481, - /* 120 */ 1481, 1481, 1481, 1481, 1481, 1481, 147, 258, 258, 258, - /* 130 */ 258, 258, 79, 65, 84, 449, 19, 786, 449, 636, - /* 140 */ 636, 449, 880, 880, 880, 880, 113, 142, 142, 472, - /* 150 */ 150, 1962, 1962, 399, 399, 399, 93, 237, 341, 237, - /* 160 */ 237, 1074, 1074, 437, 350, 704, 1080, 449, 449, 449, - /* 170 */ 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, - /* 180 */ 449, 449, 449, 449, 449, 449, 449, 449, 818, 818, - /* 190 */ 449, 1088, 217, 217, 734, 734, 1124, 1126, 1962, 1962, - /* 200 */ 1962, 739, 840, 840, 453, 454, 511, 187, 563, 570, - /* 210 */ 898, 669, 449, 449, 449, 449, 449, 449, 449, 449, - /* 220 */ 449, 670, 449, 449, 449, 449, 449, 449, 449, 449, - /* 230 */ 449, 449, 449, 449, 674, 674, 674, 449, 449, 449, - /* 240 */ 449, 1034, 449, 449, 449, 972, 1107, 449, 449, 1193, - /* 250 */ 449, 449, 449, 449, 449, 449, 449, 449, 260, 177, - /* 260 */ 489, 1241, 1241, 1241, 1241, 1192, 489, 489, 952, 1197, - /* 270 */ 625, 1235, 1131, 181, 181, 1086, 1139, 1131, 1086, 1187, - /* 280 */ 1319, 1237, 1318, 1318, 1318, 181, 1299, 1299, 1109, 1336, - /* 290 */ 549, 1376, 1610, 1535, 1535, 1639, 1639, 1535, 1539, 1578, - /* 300 */ 1670, 1546, 1652, 1546, 1681, 1681, 1681, 1681, 1535, 1694, - /* 310 */ 1546, 1546, 1578, 1670, 1652, 1546, 1652, 1546, 1535, 1694, - /* 320 */ 1565, 1665, 1535, 1694, 1708, 1535, 1694, 1535, 1694, 1708, - /* 330 */ 1618, 1618, 1618, 1680, 1723, 1723, 1708, 1618, 1623, 1618, - /* 340 */ 1680, 1618, 1618, 1588, 1708, 1640, 1640, 1708, 1611, 1643, - /* 350 */ 1611, 1643, 1611, 1643, 1611, 1643, 1535, 1685, 1685, 1695, - /* 360 */ 1695, 1636, 1641, 1761, 1535, 1631, 1636, 1644, 1646, 1546, - /* 370 */ 1763, 1766, 1781, 1781, 1791, 1791, 1791, 1962, 1962, 1962, - /* 380 */ 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, - /* 390 */ 1962, 1962, 308, 835, 954, 1232, 879, 715, 728, 1373, - /* 400 */ 864, 1329, 1253, 1409, 297, 1431, 1489, 1497, 1520, 1521, - /* 410 */ 1525, 1362, 1309, 1491, 1217, 1420, 1429, 1536, 1380, 1538, - /* 420 */ 1293, 1354, 1548, 1585, 1434, 1342, 1813, 1816, 1798, 1664, - /* 430 */ 1810, 1732, 1815, 1811, 1812, 1699, 1689, 1710, 1817, 1700, - /* 440 */ 1819, 1701, 1826, 1843, 1705, 1697, 1719, 1787, 1814, 1702, - /* 450 */ 1796, 1799, 1800, 1801, 1727, 1742, 1823, 1721, 1860, 1857, - /* 460 */ 1841, 1751, 1707, 1802, 1840, 1803, 1792, 1827, 1730, 1759, - /* 470 */ 1849, 1854, 1856, 1747, 1754, 1858, 1818, 1859, 1861, 1855, - /* 480 */ 1862, 1820, 1829, 1865, 1783, 1863, 1864, 1825, 1845, 1867, - /* 490 */ 1746, 1872, 1873, 1874, 1875, 1869, 1876, 1878, 1877, 1879, - /* 500 */ 1881, 1880, 1767, 1882, 1884, 1794, 1883, 1887, 1769, 1885, - /* 510 */ 1886, 1888, 1889, 1890, 1824, 1838, 1828, 1871, 1844, 1832, - /* 520 */ 1892, 1893, 1896, 1897, 1901, 1902, 1895, 1907, 1885, 1908, - /* 530 */ 1909, 1910, 1911, 1912, 1913, 1915, 1924, 1917, 1918, 1919, - /* 540 */ 1920, 1922, 1923, 1921, 1808, 1807, 1809, 1821, 1822, 1926, - /* 550 */ 1935, 1950, 1951, + /* 0 */ 1423, 1409, 1454, 1192, 1192, 610, 1252, 1410, 1517, 1684, + /* 10 */ 1684, 1684, 276, 0, 0, 180, 1015, 1684, 1684, 1684, + /* 20 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, + /* 30 */ 1049, 1049, 1121, 1121, 54, 487, 610, 610, 610, 610, + /* 40 */ 610, 40, 110, 219, 289, 396, 439, 509, 548, 618, + /* 50 */ 657, 727, 766, 836, 995, 1015, 1015, 1015, 1015, 1015, + /* 60 */ 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, + /* 70 */ 1015, 1015, 1015, 1035, 1015, 1138, 880, 880, 1577, 1684, + /* 80 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, + /* 90 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, + /* 100 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, + /* 110 */ 1684, 1684, 1684, 1705, 1684, 1684, 1684, 1684, 1684, 1684, + /* 120 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 146, 84, 84, + /* 130 */ 84, 84, 84, 277, 315, 401, 97, 461, 251, 66, + /* 140 */ 66, 51, 1156, 66, 66, 324, 324, 66, 452, 452, + /* 150 */ 452, 452, 133, 114, 114, 4, 11, 2037, 2037, 621, + /* 160 */ 621, 621, 567, 398, 398, 398, 398, 937, 937, 228, + /* 170 */ 251, 331, 1052, 66, 66, 66, 66, 66, 66, 66, + /* 180 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, + /* 190 */ 66, 66, 66, 557, 557, 66, 9, 25, 25, 745, + /* 200 */ 745, 967, 1088, 2037, 2037, 2037, 2037, 2037, 2037, 2037, + /* 210 */ 255, 317, 317, 514, 403, 620, 471, 672, 781, 891, + /* 220 */ 675, 66, 66, 66, 66, 66, 66, 66, 66, 66, + /* 230 */ 66, 508, 66, 66, 66, 66, 66, 66, 66, 66, + /* 240 */ 66, 66, 66, 66, 790, 790, 790, 66, 66, 66, + /* 250 */ 338, 66, 66, 66, 516, 1084, 66, 66, 993, 66, + /* 260 */ 66, 66, 66, 66, 66, 66, 66, 732, 1083, 563, + /* 270 */ 994, 994, 994, 994, 337, 563, 563, 1028, 987, 897, + /* 280 */ 1119, 262, 1214, 1271, 1112, 1214, 1112, 1268, 1239, 262, + /* 290 */ 262, 1239, 262, 1271, 1268, 1302, 1354, 1278, 1168, 1168, + /* 300 */ 1168, 1112, 1303, 1303, 815, 1311, 1264, 1364, 1657, 1657, + /* 310 */ 1595, 1595, 1701, 1701, 1595, 1592, 1596, 1724, 1706, 1730, + /* 320 */ 1730, 1730, 1730, 1595, 1735, 1614, 1596, 1596, 1614, 1724, + /* 330 */ 1706, 1614, 1706, 1614, 1595, 1735, 1621, 1717, 1595, 1735, + /* 340 */ 1758, 1595, 1735, 1595, 1735, 1758, 1679, 1679, 1679, 1734, + /* 350 */ 1781, 1781, 1758, 1679, 1689, 1679, 1734, 1679, 1679, 1645, + /* 360 */ 1791, 1715, 1715, 1758, 1690, 1718, 1690, 1718, 1690, 1718, + /* 370 */ 1690, 1718, 1595, 1751, 1751, 1762, 1762, 1699, 1703, 1826, + /* 380 */ 1595, 1695, 1699, 1707, 1710, 1614, 1847, 1863, 1863, 1871, + /* 390 */ 1871, 1871, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, + /* 400 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 193, 837, 1194, + /* 410 */ 1212, 506, 832, 1054, 1390, 925, 1435, 1394, 1102, 1332, + /* 420 */ 1419, 1196, 1420, 1425, 1433, 1447, 1457, 1488, 1443, 1379, + /* 430 */ 1572, 1455, 1503, 1453, 1495, 1515, 1506, 1526, 1460, 1489, + /* 440 */ 1581, 1622, 1534, 667, 1888, 1893, 1875, 1736, 1884, 1885, + /* 450 */ 1877, 1879, 1765, 1754, 1776, 1881, 1881, 1883, 1767, 1889, + /* 460 */ 1768, 1894, 1911, 1772, 1788, 1881, 1789, 1858, 1886, 1881, + /* 470 */ 1770, 1868, 1869, 1872, 1873, 1795, 1812, 1895, 1790, 1927, + /* 480 */ 1926, 1910, 1819, 1774, 1867, 1912, 1870, 1861, 1898, 1800, + /* 490 */ 1827, 1918, 1923, 1925, 1815, 1822, 1928, 1880, 1929, 1930, + /* 500 */ 1931, 1933, 1882, 1897, 1924, 1857, 1932, 1935, 1891, 1922, + /* 510 */ 1938, 1814, 1941, 1942, 1943, 1944, 1939, 1945, 1947, 1874, + /* 520 */ 1830, 1949, 1950, 1859, 1946, 1953, 1834, 1952, 1948, 1951, + /* 530 */ 1954, 1955, 1890, 1904, 1900, 1937, 1908, 1899, 1956, 1961, + /* 540 */ 1965, 1967, 1968, 1969, 1962, 1972, 1952, 1974, 1975, 1976, + /* 550 */ 1977, 1978, 1979, 1982, 1990, 1983, 1984, 1985, 1986, 1988, + /* 560 */ 1989, 1987, 1887, 1876, 1878, 1892, 1896, 1992, 1991, 1998, + /* 570 */ 2006, 2014, }; -#define YY_REDUCE_COUNT (391) -#define YY_REDUCE_MIN (-262) -#define YY_REDUCE_MAX (1625) +#define YY_REDUCE_COUNT (406) +#define YY_REDUCE_MIN (-272) +#define YY_REDUCE_MAX (1693) static const short yy_reduce_ofst[] = { - /* 0 */ 490, -122, 545, 645, 650, -120, -189, -187, -184, -182, - /* 10 */ -178, -176, 45, 30, 200, -251, -134, 390, 392, 521, - /* 20 */ 523, 213, 692, 821, 284, 589, 872, 666, 671, 866, - /* 30 */ 71, 111, 273, 389, 686, 815, 904, 932, 948, 955, - /* 40 */ 964, 969, -259, -259, -259, -259, -259, -259, -259, -259, - /* 50 */ -259, -259, -259, -259, -259, -259, -259, -259, -259, -259, - /* 60 */ -259, -259, -259, -259, -259, -259, -259, -259, -259, -259, - /* 70 */ -259, -259, -259, -259, -259, -259, -259, -259, 428, 430, - /* 80 */ 899, 985, 1021, 1028, 1057, 1069, 1081, 1108, 1110, 1115, - /* 90 */ 1117, 1123, 1149, 1154, 1159, 1170, 1174, 1178, 1183, 1194, - /* 100 */ 1198, 1204, 1208, 1212, 1218, 1222, 1229, 1278, 1280, 1283, - /* 110 */ 1285, 1313, 1316, 1320, 1322, 1325, 1327, 1330, 1366, 1371, - /* 120 */ 1379, 1387, 1417, 1425, 1430, 1432, -259, -259, -259, -259, - /* 130 */ -259, -259, -259, -259, -259, 557, 974, -214, -174, -9, - /* 140 */ 431, -124, 806, 925, 806, 925, 251, 928, 940, -259, - /* 150 */ -259, -259, -259, -198, -198, -198, 127, -186, -168, 212, - /* 160 */ 646, 617, 799, -262, 555, 220, 220, 491, 605, 1040, - /* 170 */ 1060, 699, -11, 600, 848, 862, 345, -129, 724, -91, - /* 180 */ 158, 749, 716, 900, 304, 822, 929, 926, 499, 793, - /* 190 */ 322, 892, 813, 845, 958, 1056, 751, 905, 1133, 1062, - /* 200 */ 803, -210, -185, -179, -148, -167, -89, 121, 274, 281, - /* 210 */ 320, 336, 439, 663, 711, 957, 965, 1064, 1068, 1112, - /* 220 */ 1116, -196, 1127, 1134, 1180, 1184, 1195, 1199, 1203, 1215, - /* 230 */ 1223, 1250, 1267, 1286, 205, 422, 638, 1324, 1341, 1364, - /* 240 */ 1365, 1213, 1392, 1399, 1403, 869, 1260, 1405, 1421, 1276, - /* 250 */ 1424, 121, 1426, 1427, 1428, 1433, 1436, 1437, 1227, 1338, - /* 260 */ 1284, 1359, 1370, 1377, 1388, 1213, 1284, 1284, 1385, 1438, - /* 270 */ 1443, 1349, 1400, 1391, 1394, 1360, 1408, 1410, 1367, 1439, - /* 280 */ 1440, 1435, 1442, 1446, 1447, 1397, 1413, 1418, 1390, 1444, - /* 290 */ 1445, 1474, 1381, 1479, 1480, 1401, 1402, 1490, 1414, 1449, - /* 300 */ 1452, 1453, 1467, 1456, 1469, 1470, 1477, 1478, 1515, 1518, - /* 310 */ 1476, 1482, 1450, 1454, 1492, 1483, 1493, 1484, 1523, 1531, - /* 320 */ 1457, 1455, 1532, 1534, 1516, 1537, 1540, 1543, 1541, 1526, - /* 330 */ 1528, 1530, 1542, 1512, 1529, 1533, 1544, 1545, 1547, 1550, - /* 340 */ 1549, 1551, 1554, 1458, 1552, 1494, 1495, 1556, 1498, 1502, - /* 350 */ 1503, 1511, 1517, 1519, 1522, 1524, 1579, 1472, 1473, 1527, - /* 360 */ 1555, 1557, 1559, 1558, 1589, 1560, 1561, 1564, 1566, 1568, - /* 370 */ 1592, 1595, 1605, 1606, 1612, 1613, 1622, 1562, 1563, 1505, - /* 380 */ 1609, 1604, 1608, 1614, 1615, 1616, 1596, 1597, 1617, 1620, - /* 390 */ 1625, 1619, + /* 0 */ 109, 113, 272, 760, -178, -176, -192, -183, -180, -134, + /* 10 */ 213, 220, 371, -208, -205, -272, -197, 611, 632, 765, + /* 20 */ 786, 392, 943, 989, 503, 651, 1039, -18, 702, 821, + /* 30 */ 710, 812, -188, 380, -187, 555, 662, 1055, 1063, 1065, + /* 40 */ 1080, -267, -267, -267, -267, -267, -267, -267, -267, -267, + /* 50 */ -267, -267, -267, -267, -267, -267, -267, -267, -267, -267, + /* 60 */ -267, -267, -267, -267, -267, -267, -267, -267, -267, -267, + /* 70 */ -267, -267, -267, -267, -267, -267, -267, -267, 636, 811, + /* 80 */ 917, 936, 1006, 1008, 1017, 1060, 1064, 1069, 1075, 1105, + /* 90 */ 1118, 1123, 1125, 1134, 1140, 1159, 1165, 1169, 1174, 1179, + /* 100 */ 1181, 1184, 1186, 1201, 1246, 1259, 1262, 1281, 1293, 1299, + /* 110 */ 1313, 1327, 1341, 1352, 1356, 1358, 1362, 1366, 1395, 1403, + /* 120 */ 1406, 1411, 1424, 1436, 1439, 1450, 1452, -267, -267, -267, + /* 130 */ -267, -267, -267, -267, -267, 224, -267, 446, -24, 275, + /* 140 */ 546, 518, 573, 560, 53, -181, -111, 485, 606, 671, + /* 150 */ 606, 671, 683, 8, 93, -267, -267, -267, -267, 155, + /* 160 */ 155, 155, 181, 242, 264, 486, 489, -218, 393, 227, + /* 170 */ 604, 347, 347, -171, 431, 650, 715, -166, 562, 609, + /* 180 */ 716, 764, 18, 823, 769, 833, 838, 957, 759, 119, + /* 190 */ 923, 226, 1014, 542, 603, 451, 949, 654, 659, 762, + /* 200 */ 964, -4, 778, 961, 712, 1082, 1100, 1111, 1026, 1117, + /* 210 */ -204, -174, -151, -8, 77, 198, 305, 327, 388, 540, + /* 220 */ 839, 968, 982, 985, 1004, 1023, 1070, 1086, 1097, 1130, + /* 230 */ 1190, 1163, 1199, 1284, 1297, 1300, 1314, 1339, 1353, 1391, + /* 240 */ 1402, 1413, 1416, 1417, 803, 1376, 1400, 1428, 1437, 1446, + /* 250 */ 1378, 1461, 1464, 1465, 1249, 1329, 1466, 1467, 1414, 1468, + /* 260 */ 305, 1469, 1470, 1471, 1472, 1482, 1483, 1389, 1392, 1438, + /* 270 */ 1426, 1427, 1432, 1434, 1378, 1438, 1438, 1440, 1474, 1499, + /* 280 */ 1399, 1421, 1430, 1456, 1441, 1442, 1444, 1415, 1473, 1431, + /* 290 */ 1445, 1476, 1449, 1478, 1418, 1479, 1477, 1485, 1493, 1494, + /* 300 */ 1496, 1458, 1475, 1480, 1459, 1490, 1484, 1518, 1448, 1451, + /* 310 */ 1537, 1538, 1463, 1481, 1541, 1486, 1487, 1491, 1519, 1514, + /* 320 */ 1521, 1523, 1525, 1552, 1556, 1520, 1492, 1498, 1522, 1497, + /* 330 */ 1539, 1528, 1542, 1532, 1571, 1573, 1500, 1504, 1582, 1584, + /* 340 */ 1563, 1586, 1588, 1589, 1597, 1567, 1579, 1585, 1590, 1568, + /* 350 */ 1583, 1587, 1593, 1591, 1598, 1599, 1600, 1602, 1606, 1513, + /* 360 */ 1524, 1548, 1549, 1611, 1574, 1576, 1594, 1603, 1604, 1607, + /* 370 */ 1605, 1608, 1642, 1527, 1529, 1609, 1610, 1601, 1615, 1575, + /* 380 */ 1650, 1578, 1619, 1623, 1625, 1624, 1674, 1685, 1686, 1691, + /* 390 */ 1692, 1693, 1612, 1613, 1617, 1675, 1668, 1673, 1676, 1677, + /* 400 */ 1680, 1666, 1669, 1678, 1681, 1683, 1687, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1575, 1575, 1575, 1411, 1188, 1297, 1188, 1188, 1188, 1411, - /* 10 */ 1411, 1411, 1188, 1327, 1327, 1464, 1219, 1188, 1188, 1188, - /* 20 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1410, 1188, 1188, - /* 30 */ 1188, 1188, 1494, 1494, 1188, 1188, 1188, 1188, 1188, 1188, - /* 40 */ 1188, 1188, 1188, 1336, 1188, 1188, 1188, 1188, 1188, 1188, - /* 50 */ 1412, 1413, 1188, 1188, 1188, 1463, 1465, 1428, 1346, 1345, - /* 60 */ 1344, 1343, 1446, 1314, 1341, 1334, 1338, 1406, 1407, 1405, - /* 70 */ 1409, 1413, 1412, 1188, 1337, 1377, 1391, 1376, 1188, 1188, - /* 80 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 90 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 100 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 110 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 120 */ 1188, 1188, 1188, 1188, 1188, 1188, 1385, 1390, 1396, 1389, - /* 130 */ 1386, 1379, 1378, 1380, 1381, 1188, 1209, 1261, 1188, 1188, - /* 140 */ 1188, 1188, 1482, 1481, 1188, 1188, 1219, 1371, 1370, 1382, - /* 150 */ 1383, 1393, 1392, 1471, 1529, 1528, 1429, 1188, 1188, 1188, - /* 160 */ 1188, 1188, 1188, 1494, 1188, 1188, 1188, 1188, 1188, 1188, - /* 170 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 180 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1494, 1494, - /* 190 */ 1188, 1219, 1494, 1494, 1215, 1215, 1321, 1188, 1477, 1297, - /* 200 */ 1288, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 210 */ 1188, 1188, 1188, 1188, 1188, 1468, 1466, 1188, 1188, 1188, - /* 220 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 230 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 240 */ 1188, 1188, 1188, 1188, 1188, 1293, 1188, 1188, 1188, 1188, - /* 250 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1523, 1188, 1441, - /* 260 */ 1275, 1293, 1293, 1293, 1293, 1295, 1276, 1274, 1287, 1220, - /* 270 */ 1195, 1567, 1294, 1316, 1316, 1564, 1340, 1294, 1564, 1236, - /* 280 */ 1545, 1231, 1327, 1327, 1327, 1316, 1321, 1321, 1408, 1294, - /* 290 */ 1287, 1188, 1567, 1302, 1302, 1566, 1566, 1302, 1429, 1349, - /* 300 */ 1355, 1340, 1264, 1340, 1270, 1270, 1270, 1270, 1302, 1206, - /* 310 */ 1340, 1340, 1349, 1355, 1264, 1340, 1264, 1340, 1302, 1206, - /* 320 */ 1445, 1561, 1302, 1206, 1419, 1302, 1206, 1302, 1206, 1419, - /* 330 */ 1262, 1262, 1262, 1251, 1188, 1188, 1419, 1262, 1236, 1262, - /* 340 */ 1251, 1262, 1262, 1512, 1419, 1423, 1423, 1419, 1320, 1315, - /* 350 */ 1320, 1315, 1320, 1315, 1320, 1315, 1302, 1504, 1504, 1330, - /* 360 */ 1330, 1335, 1321, 1414, 1302, 1188, 1335, 1333, 1331, 1340, - /* 370 */ 1212, 1254, 1526, 1526, 1522, 1522, 1522, 1572, 1572, 1477, - /* 380 */ 1538, 1219, 1219, 1219, 1219, 1538, 1238, 1238, 1220, 1220, - /* 390 */ 1219, 1538, 1188, 1188, 1188, 1188, 1188, 1188, 1533, 1188, - /* 400 */ 1430, 1306, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 410 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 420 */ 1188, 1188, 1188, 1188, 1188, 1360, 1188, 1191, 1474, 1188, - /* 430 */ 1188, 1472, 1188, 1188, 1188, 1188, 1188, 1188, 1307, 1188, - /* 440 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 450 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1563, 1188, 1188, - /* 460 */ 1188, 1188, 1188, 1188, 1444, 1443, 1188, 1188, 1304, 1188, - /* 470 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 480 */ 1188, 1188, 1234, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 490 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 500 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1332, - /* 510 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 520 */ 1188, 1188, 1188, 1188, 1509, 1322, 1188, 1188, 1554, 1188, - /* 530 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, - /* 540 */ 1188, 1188, 1188, 1549, 1278, 1362, 1188, 1361, 1365, 1188, - /* 550 */ 1200, 1188, 1188, + /* 0 */ 1633, 1633, 1633, 1462, 1230, 1341, 1230, 1230, 1230, 1462, + /* 10 */ 1462, 1462, 1230, 1371, 1371, 1515, 1263, 1230, 1230, 1230, + /* 20 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1461, 1230, 1230, + /* 30 */ 1230, 1230, 1550, 1550, 1230, 1230, 1230, 1230, 1230, 1230, + /* 40 */ 1230, 1230, 1380, 1230, 1387, 1230, 1230, 1230, 1230, 1230, + /* 50 */ 1463, 1464, 1230, 1230, 1230, 1514, 1516, 1479, 1394, 1393, + /* 60 */ 1392, 1391, 1497, 1358, 1385, 1378, 1382, 1457, 1458, 1456, + /* 70 */ 1460, 1464, 1463, 1230, 1381, 1428, 1442, 1427, 1230, 1230, + /* 80 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 90 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 100 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 110 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 120 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1436, 1441, 1447, + /* 130 */ 1440, 1437, 1430, 1429, 1431, 1230, 1432, 1230, 1254, 1230, + /* 140 */ 1230, 1251, 1305, 1230, 1230, 1230, 1230, 1230, 1534, 1533, + /* 150 */ 1230, 1230, 1263, 1422, 1421, 1433, 1434, 1444, 1443, 1522, + /* 160 */ 1586, 1585, 1480, 1230, 1230, 1230, 1230, 1230, 1230, 1550, + /* 170 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 180 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 190 */ 1230, 1230, 1230, 1550, 1550, 1230, 1263, 1550, 1550, 1259, + /* 200 */ 1259, 1365, 1230, 1529, 1332, 1332, 1332, 1332, 1341, 1332, + /* 210 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 220 */ 1230, 1230, 1230, 1230, 1230, 1519, 1517, 1230, 1230, 1230, + /* 230 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 240 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 250 */ 1230, 1230, 1230, 1230, 1337, 1230, 1230, 1230, 1230, 1230, + /* 260 */ 1230, 1230, 1230, 1230, 1230, 1230, 1579, 1230, 1492, 1319, + /* 270 */ 1337, 1337, 1337, 1337, 1339, 1320, 1318, 1331, 1264, 1237, + /* 280 */ 1625, 1397, 1386, 1338, 1360, 1386, 1360, 1622, 1384, 1397, + /* 290 */ 1397, 1384, 1397, 1338, 1622, 1280, 1602, 1275, 1371, 1371, + /* 300 */ 1371, 1360, 1365, 1365, 1459, 1338, 1331, 1230, 1625, 1625, + /* 310 */ 1346, 1346, 1624, 1624, 1346, 1480, 1609, 1406, 1308, 1314, + /* 320 */ 1314, 1314, 1314, 1346, 1248, 1384, 1609, 1609, 1384, 1406, + /* 330 */ 1308, 1384, 1308, 1384, 1346, 1248, 1496, 1619, 1346, 1248, + /* 340 */ 1470, 1346, 1248, 1346, 1248, 1470, 1306, 1306, 1306, 1295, + /* 350 */ 1230, 1230, 1470, 1306, 1280, 1306, 1295, 1306, 1306, 1568, + /* 360 */ 1230, 1474, 1474, 1470, 1364, 1359, 1364, 1359, 1364, 1359, + /* 370 */ 1364, 1359, 1346, 1560, 1560, 1374, 1374, 1379, 1365, 1465, + /* 380 */ 1346, 1230, 1379, 1377, 1375, 1384, 1298, 1582, 1582, 1578, + /* 390 */ 1578, 1578, 1630, 1630, 1529, 1595, 1263, 1263, 1263, 1263, + /* 400 */ 1595, 1282, 1282, 1264, 1264, 1263, 1595, 1230, 1230, 1230, + /* 410 */ 1230, 1230, 1230, 1590, 1230, 1524, 1481, 1350, 1230, 1230, + /* 420 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 430 */ 1230, 1230, 1535, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 440 */ 1230, 1230, 1230, 1411, 1230, 1233, 1526, 1230, 1230, 1230, + /* 450 */ 1230, 1230, 1230, 1230, 1230, 1388, 1389, 1351, 1230, 1230, + /* 460 */ 1230, 1230, 1230, 1230, 1230, 1403, 1230, 1230, 1230, 1398, + /* 470 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1621, 1230, + /* 480 */ 1230, 1230, 1230, 1230, 1230, 1495, 1494, 1230, 1230, 1348, + /* 490 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 500 */ 1230, 1230, 1230, 1278, 1230, 1230, 1230, 1230, 1230, 1230, + /* 510 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 520 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1376, 1230, 1230, + /* 530 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 540 */ 1230, 1230, 1565, 1366, 1230, 1230, 1612, 1230, 1230, 1230, + /* 550 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + /* 560 */ 1230, 1606, 1322, 1413, 1230, 1412, 1416, 1252, 1230, 1242, + /* 570 */ 1230, 1230, }; /********** End of lemon-generated parsing tables *****************************/ @@ -156024,8 +160664,8 @@ static const YYCODETYPE yyFallback[] = { 0, /* LP => nothing */ 0, /* RP => nothing */ 0, /* AS => nothing */ - 59, /* WITHOUT => ID */ 0, /* COMMA => nothing */ + 59, /* WITHOUT => ID */ 59, /* ABORT => ID */ 59, /* ACTION => ID */ 59, /* AFTER => ID */ @@ -156096,6 +160736,7 @@ static const YYCODETYPE yyFallback[] = { 59, /* TIES => ID */ 59, /* GENERATED => ID */ 59, /* ALWAYS => ID */ + 59, /* MATERIALIZED => ID */ 59, /* REINDEX => ID */ 59, /* RENAME => ID */ 59, /* CTIME_KW => ID */ @@ -156147,6 +160788,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* HAVING => nothing */ 0, /* LIMIT => nothing */ 0, /* WHERE => nothing */ + 0, /* RETURNING => nothing */ 0, /* INTO => nothing */ 0, /* NOTHING => nothing */ 0, /* FLOAT => nothing */ @@ -156178,6 +160820,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* IF_NULL_ROW => nothing */ 0, /* ASTERISK => nothing */ 0, /* SPAN => nothing */ + 0, /* ERROR => nothing */ 0, /* SPACE => nothing */ 0, /* ILLEGAL => nothing */ }; @@ -156231,9 +160874,9 @@ struct yyParser { }; typedef struct yyParser yyParser; +/* #include */ #ifndef NDEBUG /* #include */ -/* #include */ static FILE *yyTraceFILE = 0; static char *yyTracePrompt = 0; #endif /* NDEBUG */ @@ -156293,8 +160936,8 @@ static const char *const yyTokenName[] = { /* 22 */ "LP", /* 23 */ "RP", /* 24 */ "AS", - /* 25 */ "WITHOUT", - /* 26 */ "COMMA", + /* 25 */ "COMMA", + /* 26 */ "WITHOUT", /* 27 */ "ABORT", /* 28 */ "ACTION", /* 29 */ "AFTER", @@ -156365,219 +161008,227 @@ static const char *const yyTokenName[] = { /* 94 */ "TIES", /* 95 */ "GENERATED", /* 96 */ "ALWAYS", - /* 97 */ "REINDEX", - /* 98 */ "RENAME", - /* 99 */ "CTIME_KW", - /* 100 */ "ANY", - /* 101 */ "BITAND", - /* 102 */ "BITOR", - /* 103 */ "LSHIFT", - /* 104 */ "RSHIFT", - /* 105 */ "PLUS", - /* 106 */ "MINUS", - /* 107 */ "STAR", - /* 108 */ "SLASH", - /* 109 */ "REM", - /* 110 */ "CONCAT", - /* 111 */ "COLLATE", - /* 112 */ "BITNOT", - /* 113 */ "ON", - /* 114 */ "INDEXED", - /* 115 */ "STRING", - /* 116 */ "JOIN_KW", - /* 117 */ "CONSTRAINT", - /* 118 */ "DEFAULT", - /* 119 */ "NULL", - /* 120 */ "PRIMARY", - /* 121 */ "UNIQUE", - /* 122 */ "CHECK", - /* 123 */ "REFERENCES", - /* 124 */ "AUTOINCR", - /* 125 */ "INSERT", - /* 126 */ "DELETE", - /* 127 */ "UPDATE", - /* 128 */ "SET", - /* 129 */ "DEFERRABLE", - /* 130 */ "FOREIGN", - /* 131 */ "DROP", - /* 132 */ "UNION", - /* 133 */ "ALL", - /* 134 */ "EXCEPT", - /* 135 */ "INTERSECT", - /* 136 */ "SELECT", - /* 137 */ "VALUES", - /* 138 */ "DISTINCT", - /* 139 */ "DOT", - /* 140 */ "FROM", - /* 141 */ "JOIN", - /* 142 */ "USING", - /* 143 */ "ORDER", - /* 144 */ "GROUP", - /* 145 */ "HAVING", - /* 146 */ "LIMIT", - /* 147 */ "WHERE", - /* 148 */ "INTO", - /* 149 */ "NOTHING", - /* 150 */ "FLOAT", - /* 151 */ "BLOB", - /* 152 */ "INTEGER", - /* 153 */ "VARIABLE", - /* 154 */ "CASE", - /* 155 */ "WHEN", - /* 156 */ "THEN", - /* 157 */ "ELSE", - /* 158 */ "INDEX", - /* 159 */ "ALTER", - /* 160 */ "ADD", - /* 161 */ "WINDOW", - /* 162 */ "OVER", - /* 163 */ "FILTER", - /* 164 */ "COLUMN", - /* 165 */ "AGG_FUNCTION", - /* 166 */ "AGG_COLUMN", - /* 167 */ "TRUEFALSE", - /* 168 */ "ISNOT", - /* 169 */ "FUNCTION", - /* 170 */ "UMINUS", - /* 171 */ "UPLUS", - /* 172 */ "TRUTH", - /* 173 */ "REGISTER", - /* 174 */ "VECTOR", - /* 175 */ "SELECT_COLUMN", - /* 176 */ "IF_NULL_ROW", - /* 177 */ "ASTERISK", - /* 178 */ "SPAN", - /* 179 */ "SPACE", - /* 180 */ "ILLEGAL", - /* 181 */ "input", - /* 182 */ "cmdlist", - /* 183 */ "ecmd", - /* 184 */ "cmdx", - /* 185 */ "explain", - /* 186 */ "cmd", - /* 187 */ "transtype", - /* 188 */ "trans_opt", - /* 189 */ "nm", - /* 190 */ "savepoint_opt", - /* 191 */ "create_table", - /* 192 */ "create_table_args", - /* 193 */ "createkw", - /* 194 */ "temp", - /* 195 */ "ifnotexists", - /* 196 */ "dbnm", - /* 197 */ "columnlist", - /* 198 */ "conslist_opt", - /* 199 */ "table_options", - /* 200 */ "select", - /* 201 */ "columnname", - /* 202 */ "carglist", - /* 203 */ "typetoken", - /* 204 */ "typename", - /* 205 */ "signed", - /* 206 */ "plus_num", - /* 207 */ "minus_num", - /* 208 */ "scanpt", - /* 209 */ "scantok", - /* 210 */ "ccons", - /* 211 */ "term", - /* 212 */ "expr", - /* 213 */ "onconf", - /* 214 */ "sortorder", - /* 215 */ "autoinc", - /* 216 */ "eidlist_opt", - /* 217 */ "refargs", - /* 218 */ "defer_subclause", - /* 219 */ "generated", - /* 220 */ "refarg", - /* 221 */ "refact", - /* 222 */ "init_deferred_pred_opt", - /* 223 */ "conslist", - /* 224 */ "tconscomma", - /* 225 */ "tcons", - /* 226 */ "sortlist", - /* 227 */ "eidlist", - /* 228 */ "defer_subclause_opt", - /* 229 */ "orconf", - /* 230 */ "resolvetype", - /* 231 */ "raisetype", - /* 232 */ "ifexists", - /* 233 */ "fullname", - /* 234 */ "selectnowith", - /* 235 */ "oneselect", - /* 236 */ "wqlist", - /* 237 */ "multiselect_op", - /* 238 */ "distinct", - /* 239 */ "selcollist", - /* 240 */ "from", - /* 241 */ "where_opt", - /* 242 */ "groupby_opt", - /* 243 */ "having_opt", - /* 244 */ "orderby_opt", - /* 245 */ "limit_opt", - /* 246 */ "window_clause", - /* 247 */ "values", - /* 248 */ "nexprlist", - /* 249 */ "sclp", - /* 250 */ "as", - /* 251 */ "seltablist", - /* 252 */ "stl_prefix", - /* 253 */ "joinop", - /* 254 */ "indexed_opt", - /* 255 */ "on_opt", - /* 256 */ "using_opt", - /* 257 */ "exprlist", - /* 258 */ "xfullname", - /* 259 */ "idlist", - /* 260 */ "nulls", - /* 261 */ "with", - /* 262 */ "setlist", - /* 263 */ "insert_cmd", - /* 264 */ "idlist_opt", - /* 265 */ "upsert", - /* 266 */ "filter_over", - /* 267 */ "likeop", - /* 268 */ "between_op", - /* 269 */ "in_op", - /* 270 */ "paren_exprlist", - /* 271 */ "case_operand", - /* 272 */ "case_exprlist", - /* 273 */ "case_else", - /* 274 */ "uniqueflag", - /* 275 */ "collate", - /* 276 */ "vinto", - /* 277 */ "nmnum", - /* 278 */ "trigger_decl", - /* 279 */ "trigger_cmd_list", - /* 280 */ "trigger_time", - /* 281 */ "trigger_event", - /* 282 */ "foreach_clause", - /* 283 */ "when_clause", - /* 284 */ "trigger_cmd", - /* 285 */ "trnm", - /* 286 */ "tridxby", - /* 287 */ "database_kw_opt", - /* 288 */ "key_opt", - /* 289 */ "add_column_fullname", - /* 290 */ "kwcolumn_opt", - /* 291 */ "create_vtab", - /* 292 */ "vtabarglist", - /* 293 */ "vtabarg", - /* 294 */ "vtabargtoken", - /* 295 */ "lp", - /* 296 */ "anylist", - /* 297 */ "windowdefn_list", - /* 298 */ "windowdefn", - /* 299 */ "window", - /* 300 */ "frame_opt", - /* 301 */ "part_opt", - /* 302 */ "filter_clause", - /* 303 */ "over_clause", - /* 304 */ "range_or_rows", - /* 305 */ "frame_bound", - /* 306 */ "frame_bound_s", - /* 307 */ "frame_bound_e", - /* 308 */ "frame_exclude_opt", - /* 309 */ "frame_exclude", + /* 97 */ "MATERIALIZED", + /* 98 */ "REINDEX", + /* 99 */ "RENAME", + /* 100 */ "CTIME_KW", + /* 101 */ "ANY", + /* 102 */ "BITAND", + /* 103 */ "BITOR", + /* 104 */ "LSHIFT", + /* 105 */ "RSHIFT", + /* 106 */ "PLUS", + /* 107 */ "MINUS", + /* 108 */ "STAR", + /* 109 */ "SLASH", + /* 110 */ "REM", + /* 111 */ "CONCAT", + /* 112 */ "COLLATE", + /* 113 */ "BITNOT", + /* 114 */ "ON", + /* 115 */ "INDEXED", + /* 116 */ "STRING", + /* 117 */ "JOIN_KW", + /* 118 */ "CONSTRAINT", + /* 119 */ "DEFAULT", + /* 120 */ "NULL", + /* 121 */ "PRIMARY", + /* 122 */ "UNIQUE", + /* 123 */ "CHECK", + /* 124 */ "REFERENCES", + /* 125 */ "AUTOINCR", + /* 126 */ "INSERT", + /* 127 */ "DELETE", + /* 128 */ "UPDATE", + /* 129 */ "SET", + /* 130 */ "DEFERRABLE", + /* 131 */ "FOREIGN", + /* 132 */ "DROP", + /* 133 */ "UNION", + /* 134 */ "ALL", + /* 135 */ "EXCEPT", + /* 136 */ "INTERSECT", + /* 137 */ "SELECT", + /* 138 */ "VALUES", + /* 139 */ "DISTINCT", + /* 140 */ "DOT", + /* 141 */ "FROM", + /* 142 */ "JOIN", + /* 143 */ "USING", + /* 144 */ "ORDER", + /* 145 */ "GROUP", + /* 146 */ "HAVING", + /* 147 */ "LIMIT", + /* 148 */ "WHERE", + /* 149 */ "RETURNING", + /* 150 */ "INTO", + /* 151 */ "NOTHING", + /* 152 */ "FLOAT", + /* 153 */ "BLOB", + /* 154 */ "INTEGER", + /* 155 */ "VARIABLE", + /* 156 */ "CASE", + /* 157 */ "WHEN", + /* 158 */ "THEN", + /* 159 */ "ELSE", + /* 160 */ "INDEX", + /* 161 */ "ALTER", + /* 162 */ "ADD", + /* 163 */ "WINDOW", + /* 164 */ "OVER", + /* 165 */ "FILTER", + /* 166 */ "COLUMN", + /* 167 */ "AGG_FUNCTION", + /* 168 */ "AGG_COLUMN", + /* 169 */ "TRUEFALSE", + /* 170 */ "ISNOT", + /* 171 */ "FUNCTION", + /* 172 */ "UMINUS", + /* 173 */ "UPLUS", + /* 174 */ "TRUTH", + /* 175 */ "REGISTER", + /* 176 */ "VECTOR", + /* 177 */ "SELECT_COLUMN", + /* 178 */ "IF_NULL_ROW", + /* 179 */ "ASTERISK", + /* 180 */ "SPAN", + /* 181 */ "ERROR", + /* 182 */ "SPACE", + /* 183 */ "ILLEGAL", + /* 184 */ "input", + /* 185 */ "cmdlist", + /* 186 */ "ecmd", + /* 187 */ "cmdx", + /* 188 */ "explain", + /* 189 */ "cmd", + /* 190 */ "transtype", + /* 191 */ "trans_opt", + /* 192 */ "nm", + /* 193 */ "savepoint_opt", + /* 194 */ "create_table", + /* 195 */ "create_table_args", + /* 196 */ "createkw", + /* 197 */ "temp", + /* 198 */ "ifnotexists", + /* 199 */ "dbnm", + /* 200 */ "columnlist", + /* 201 */ "conslist_opt", + /* 202 */ "table_option_set", + /* 203 */ "select", + /* 204 */ "table_option", + /* 205 */ "columnname", + /* 206 */ "carglist", + /* 207 */ "typetoken", + /* 208 */ "typename", + /* 209 */ "signed", + /* 210 */ "plus_num", + /* 211 */ "minus_num", + /* 212 */ "scanpt", + /* 213 */ "scantok", + /* 214 */ "ccons", + /* 215 */ "term", + /* 216 */ "expr", + /* 217 */ "onconf", + /* 218 */ "sortorder", + /* 219 */ "autoinc", + /* 220 */ "eidlist_opt", + /* 221 */ "refargs", + /* 222 */ "defer_subclause", + /* 223 */ "generated", + /* 224 */ "refarg", + /* 225 */ "refact", + /* 226 */ "init_deferred_pred_opt", + /* 227 */ "conslist", + /* 228 */ "tconscomma", + /* 229 */ "tcons", + /* 230 */ "sortlist", + /* 231 */ "eidlist", + /* 232 */ "defer_subclause_opt", + /* 233 */ "orconf", + /* 234 */ "resolvetype", + /* 235 */ "raisetype", + /* 236 */ "ifexists", + /* 237 */ "fullname", + /* 238 */ "selectnowith", + /* 239 */ "oneselect", + /* 240 */ "wqlist", + /* 241 */ "multiselect_op", + /* 242 */ "distinct", + /* 243 */ "selcollist", + /* 244 */ "from", + /* 245 */ "where_opt", + /* 246 */ "groupby_opt", + /* 247 */ "having_opt", + /* 248 */ "orderby_opt", + /* 249 */ "limit_opt", + /* 250 */ "window_clause", + /* 251 */ "values", + /* 252 */ "nexprlist", + /* 253 */ "sclp", + /* 254 */ "as", + /* 255 */ "seltablist", + /* 256 */ "stl_prefix", + /* 257 */ "joinop", + /* 258 */ "indexed_opt", + /* 259 */ "on_opt", + /* 260 */ "using_opt", + /* 261 */ "exprlist", + /* 262 */ "xfullname", + /* 263 */ "idlist", + /* 264 */ "nulls", + /* 265 */ "with", + /* 266 */ "where_opt_ret", + /* 267 */ "setlist", + /* 268 */ "insert_cmd", + /* 269 */ "idlist_opt", + /* 270 */ "upsert", + /* 271 */ "returning", + /* 272 */ "filter_over", + /* 273 */ "likeop", + /* 274 */ "between_op", + /* 275 */ "in_op", + /* 276 */ "paren_exprlist", + /* 277 */ "case_operand", + /* 278 */ "case_exprlist", + /* 279 */ "case_else", + /* 280 */ "uniqueflag", + /* 281 */ "collate", + /* 282 */ "vinto", + /* 283 */ "nmnum", + /* 284 */ "trigger_decl", + /* 285 */ "trigger_cmd_list", + /* 286 */ "trigger_time", + /* 287 */ "trigger_event", + /* 288 */ "foreach_clause", + /* 289 */ "when_clause", + /* 290 */ "trigger_cmd", + /* 291 */ "trnm", + /* 292 */ "tridxby", + /* 293 */ "database_kw_opt", + /* 294 */ "key_opt", + /* 295 */ "add_column_fullname", + /* 296 */ "kwcolumn_opt", + /* 297 */ "create_vtab", + /* 298 */ "vtabarglist", + /* 299 */ "vtabarg", + /* 300 */ "vtabargtoken", + /* 301 */ "lp", + /* 302 */ "anylist", + /* 303 */ "wqitem", + /* 304 */ "wqas", + /* 305 */ "windowdefn_list", + /* 306 */ "windowdefn", + /* 307 */ "window", + /* 308 */ "frame_opt", + /* 309 */ "part_opt", + /* 310 */ "filter_clause", + /* 311 */ "over_clause", + /* 312 */ "range_or_rows", + /* 313 */ "frame_bound", + /* 314 */ "frame_bound_s", + /* 315 */ "frame_bound_e", + /* 316 */ "frame_exclude_opt", + /* 317 */ "frame_exclude", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -156604,372 +161255,388 @@ static const char *const yyRuleName[] = { /* 16 */ "ifnotexists ::= IF NOT EXISTS", /* 17 */ "temp ::= TEMP", /* 18 */ "temp ::=", - /* 19 */ "create_table_args ::= LP columnlist conslist_opt RP table_options", + /* 19 */ "create_table_args ::= LP columnlist conslist_opt RP table_option_set", /* 20 */ "create_table_args ::= AS select", - /* 21 */ "table_options ::=", - /* 22 */ "table_options ::= WITHOUT nm", - /* 23 */ "columnname ::= nm typetoken", - /* 24 */ "typetoken ::=", - /* 25 */ "typetoken ::= typename LP signed RP", - /* 26 */ "typetoken ::= typename LP signed COMMA signed RP", - /* 27 */ "typename ::= typename ID|STRING", - /* 28 */ "scanpt ::=", - /* 29 */ "scantok ::=", - /* 30 */ "ccons ::= CONSTRAINT nm", - /* 31 */ "ccons ::= DEFAULT scantok term", - /* 32 */ "ccons ::= DEFAULT LP expr RP", - /* 33 */ "ccons ::= DEFAULT PLUS scantok term", - /* 34 */ "ccons ::= DEFAULT MINUS scantok term", - /* 35 */ "ccons ::= DEFAULT scantok ID|INDEXED", - /* 36 */ "ccons ::= NOT NULL onconf", - /* 37 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc", - /* 38 */ "ccons ::= UNIQUE onconf", - /* 39 */ "ccons ::= CHECK LP expr RP", - /* 40 */ "ccons ::= REFERENCES nm eidlist_opt refargs", - /* 41 */ "ccons ::= defer_subclause", - /* 42 */ "ccons ::= COLLATE ID|STRING", - /* 43 */ "generated ::= LP expr RP", - /* 44 */ "generated ::= LP expr RP ID", - /* 45 */ "autoinc ::=", - /* 46 */ "autoinc ::= AUTOINCR", - /* 47 */ "refargs ::=", - /* 48 */ "refargs ::= refargs refarg", - /* 49 */ "refarg ::= MATCH nm", - /* 50 */ "refarg ::= ON INSERT refact", - /* 51 */ "refarg ::= ON DELETE refact", - /* 52 */ "refarg ::= ON UPDATE refact", - /* 53 */ "refact ::= SET NULL", - /* 54 */ "refact ::= SET DEFAULT", - /* 55 */ "refact ::= CASCADE", - /* 56 */ "refact ::= RESTRICT", - /* 57 */ "refact ::= NO ACTION", - /* 58 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", - /* 59 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", - /* 60 */ "init_deferred_pred_opt ::=", - /* 61 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", - /* 62 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", - /* 63 */ "conslist_opt ::=", - /* 64 */ "tconscomma ::= COMMA", - /* 65 */ "tcons ::= CONSTRAINT nm", - /* 66 */ "tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf", - /* 67 */ "tcons ::= UNIQUE LP sortlist RP onconf", - /* 68 */ "tcons ::= CHECK LP expr RP onconf", - /* 69 */ "tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt", - /* 70 */ "defer_subclause_opt ::=", - /* 71 */ "onconf ::=", - /* 72 */ "onconf ::= ON CONFLICT resolvetype", - /* 73 */ "orconf ::=", - /* 74 */ "orconf ::= OR resolvetype", - /* 75 */ "resolvetype ::= IGNORE", - /* 76 */ "resolvetype ::= REPLACE", - /* 77 */ "cmd ::= DROP TABLE ifexists fullname", - /* 78 */ "ifexists ::= IF EXISTS", - /* 79 */ "ifexists ::=", - /* 80 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select", - /* 81 */ "cmd ::= DROP VIEW ifexists fullname", - /* 82 */ "cmd ::= select", - /* 83 */ "select ::= WITH wqlist selectnowith", - /* 84 */ "select ::= WITH RECURSIVE wqlist selectnowith", - /* 85 */ "select ::= selectnowith", - /* 86 */ "selectnowith ::= selectnowith multiselect_op oneselect", - /* 87 */ "multiselect_op ::= UNION", - /* 88 */ "multiselect_op ::= UNION ALL", - /* 89 */ "multiselect_op ::= EXCEPT|INTERSECT", - /* 90 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", - /* 91 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt", - /* 92 */ "values ::= VALUES LP nexprlist RP", - /* 93 */ "values ::= values COMMA LP nexprlist RP", - /* 94 */ "distinct ::= DISTINCT", - /* 95 */ "distinct ::= ALL", - /* 96 */ "distinct ::=", - /* 97 */ "sclp ::=", - /* 98 */ "selcollist ::= sclp scanpt expr scanpt as", - /* 99 */ "selcollist ::= sclp scanpt STAR", - /* 100 */ "selcollist ::= sclp scanpt nm DOT STAR", - /* 101 */ "as ::= AS nm", - /* 102 */ "as ::=", - /* 103 */ "from ::=", - /* 104 */ "from ::= FROM seltablist", - /* 105 */ "stl_prefix ::= seltablist joinop", - /* 106 */ "stl_prefix ::=", - /* 107 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt", - /* 108 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt", - /* 109 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt", - /* 110 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt", - /* 111 */ "dbnm ::=", - /* 112 */ "dbnm ::= DOT nm", - /* 113 */ "fullname ::= nm", - /* 114 */ "fullname ::= nm DOT nm", - /* 115 */ "xfullname ::= nm", - /* 116 */ "xfullname ::= nm DOT nm", - /* 117 */ "xfullname ::= nm DOT nm AS nm", - /* 118 */ "xfullname ::= nm AS nm", - /* 119 */ "joinop ::= COMMA|JOIN", - /* 120 */ "joinop ::= JOIN_KW JOIN", - /* 121 */ "joinop ::= JOIN_KW nm JOIN", - /* 122 */ "joinop ::= JOIN_KW nm nm JOIN", - /* 123 */ "on_opt ::= ON expr", - /* 124 */ "on_opt ::=", - /* 125 */ "indexed_opt ::=", - /* 126 */ "indexed_opt ::= INDEXED BY nm", - /* 127 */ "indexed_opt ::= NOT INDEXED", - /* 128 */ "using_opt ::= USING LP idlist RP", - /* 129 */ "using_opt ::=", - /* 130 */ "orderby_opt ::=", - /* 131 */ "orderby_opt ::= ORDER BY sortlist", - /* 132 */ "sortlist ::= sortlist COMMA expr sortorder nulls", - /* 133 */ "sortlist ::= expr sortorder nulls", - /* 134 */ "sortorder ::= ASC", - /* 135 */ "sortorder ::= DESC", - /* 136 */ "sortorder ::=", - /* 137 */ "nulls ::= NULLS FIRST", - /* 138 */ "nulls ::= NULLS LAST", - /* 139 */ "nulls ::=", - /* 140 */ "groupby_opt ::=", - /* 141 */ "groupby_opt ::= GROUP BY nexprlist", - /* 142 */ "having_opt ::=", - /* 143 */ "having_opt ::= HAVING expr", - /* 144 */ "limit_opt ::=", - /* 145 */ "limit_opt ::= LIMIT expr", - /* 146 */ "limit_opt ::= LIMIT expr OFFSET expr", - /* 147 */ "limit_opt ::= LIMIT expr COMMA expr", - /* 148 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt", - /* 149 */ "where_opt ::=", - /* 150 */ "where_opt ::= WHERE expr", - /* 151 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt", - /* 152 */ "setlist ::= setlist COMMA nm EQ expr", - /* 153 */ "setlist ::= setlist COMMA LP idlist RP EQ expr", - /* 154 */ "setlist ::= nm EQ expr", - /* 155 */ "setlist ::= LP idlist RP EQ expr", - /* 156 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert", - /* 157 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES", - /* 158 */ "upsert ::=", - /* 159 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt", - /* 160 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING", - /* 161 */ "upsert ::= ON CONFLICT DO NOTHING", - /* 162 */ "insert_cmd ::= INSERT orconf", - /* 163 */ "insert_cmd ::= REPLACE", - /* 164 */ "idlist_opt ::=", - /* 165 */ "idlist_opt ::= LP idlist RP", - /* 166 */ "idlist ::= idlist COMMA nm", - /* 167 */ "idlist ::= nm", - /* 168 */ "expr ::= LP expr RP", - /* 169 */ "expr ::= ID|INDEXED", - /* 170 */ "expr ::= JOIN_KW", - /* 171 */ "expr ::= nm DOT nm", - /* 172 */ "expr ::= nm DOT nm DOT nm", - /* 173 */ "term ::= NULL|FLOAT|BLOB", - /* 174 */ "term ::= STRING", - /* 175 */ "term ::= INTEGER", - /* 176 */ "expr ::= VARIABLE", - /* 177 */ "expr ::= expr COLLATE ID|STRING", - /* 178 */ "expr ::= CAST LP expr AS typetoken RP", - /* 179 */ "expr ::= ID|INDEXED LP distinct exprlist RP", - /* 180 */ "expr ::= ID|INDEXED LP STAR RP", - /* 181 */ "expr ::= ID|INDEXED LP distinct exprlist RP filter_over", - /* 182 */ "expr ::= ID|INDEXED LP STAR RP filter_over", - /* 183 */ "term ::= CTIME_KW", - /* 184 */ "expr ::= LP nexprlist COMMA expr RP", - /* 185 */ "expr ::= expr AND expr", - /* 186 */ "expr ::= expr OR expr", - /* 187 */ "expr ::= expr LT|GT|GE|LE expr", - /* 188 */ "expr ::= expr EQ|NE expr", - /* 189 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr", - /* 190 */ "expr ::= expr PLUS|MINUS expr", - /* 191 */ "expr ::= expr STAR|SLASH|REM expr", - /* 192 */ "expr ::= expr CONCAT expr", - /* 193 */ "likeop ::= NOT LIKE_KW|MATCH", - /* 194 */ "expr ::= expr likeop expr", - /* 195 */ "expr ::= expr likeop expr ESCAPE expr", - /* 196 */ "expr ::= expr ISNULL|NOTNULL", - /* 197 */ "expr ::= expr NOT NULL", - /* 198 */ "expr ::= expr IS expr", - /* 199 */ "expr ::= expr IS NOT expr", - /* 200 */ "expr ::= NOT expr", - /* 201 */ "expr ::= BITNOT expr", - /* 202 */ "expr ::= PLUS|MINUS expr", - /* 203 */ "between_op ::= BETWEEN", - /* 204 */ "between_op ::= NOT BETWEEN", - /* 205 */ "expr ::= expr between_op expr AND expr", - /* 206 */ "in_op ::= IN", - /* 207 */ "in_op ::= NOT IN", - /* 208 */ "expr ::= expr in_op LP exprlist RP", - /* 209 */ "expr ::= LP select RP", - /* 210 */ "expr ::= expr in_op LP select RP", - /* 211 */ "expr ::= expr in_op nm dbnm paren_exprlist", - /* 212 */ "expr ::= EXISTS LP select RP", - /* 213 */ "expr ::= CASE case_operand case_exprlist case_else END", - /* 214 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", - /* 215 */ "case_exprlist ::= WHEN expr THEN expr", - /* 216 */ "case_else ::= ELSE expr", - /* 217 */ "case_else ::=", - /* 218 */ "case_operand ::= expr", - /* 219 */ "case_operand ::=", - /* 220 */ "exprlist ::=", - /* 221 */ "nexprlist ::= nexprlist COMMA expr", - /* 222 */ "nexprlist ::= expr", - /* 223 */ "paren_exprlist ::=", - /* 224 */ "paren_exprlist ::= LP exprlist RP", - /* 225 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt", - /* 226 */ "uniqueflag ::= UNIQUE", - /* 227 */ "uniqueflag ::=", - /* 228 */ "eidlist_opt ::=", - /* 229 */ "eidlist_opt ::= LP eidlist RP", - /* 230 */ "eidlist ::= eidlist COMMA nm collate sortorder", - /* 231 */ "eidlist ::= nm collate sortorder", - /* 232 */ "collate ::=", - /* 233 */ "collate ::= COLLATE ID|STRING", - /* 234 */ "cmd ::= DROP INDEX ifexists fullname", - /* 235 */ "cmd ::= VACUUM vinto", - /* 236 */ "cmd ::= VACUUM nm vinto", - /* 237 */ "vinto ::= INTO expr", - /* 238 */ "vinto ::=", - /* 239 */ "cmd ::= PRAGMA nm dbnm", - /* 240 */ "cmd ::= PRAGMA nm dbnm EQ nmnum", - /* 241 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP", - /* 242 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", - /* 243 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP", - /* 244 */ "plus_num ::= PLUS INTEGER|FLOAT", - /* 245 */ "minus_num ::= MINUS INTEGER|FLOAT", - /* 246 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END", - /* 247 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", - /* 248 */ "trigger_time ::= BEFORE|AFTER", - /* 249 */ "trigger_time ::= INSTEAD OF", - /* 250 */ "trigger_time ::=", - /* 251 */ "trigger_event ::= DELETE|INSERT", - /* 252 */ "trigger_event ::= UPDATE", - /* 253 */ "trigger_event ::= UPDATE OF idlist", - /* 254 */ "when_clause ::=", - /* 255 */ "when_clause ::= WHEN expr", - /* 256 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", - /* 257 */ "trigger_cmd_list ::= trigger_cmd SEMI", - /* 258 */ "trnm ::= nm DOT nm", - /* 259 */ "tridxby ::= INDEXED BY nm", - /* 260 */ "tridxby ::= NOT INDEXED", - /* 261 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt", - /* 262 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt", - /* 263 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt", - /* 264 */ "trigger_cmd ::= scanpt select scanpt", - /* 265 */ "expr ::= RAISE LP IGNORE RP", - /* 266 */ "expr ::= RAISE LP raisetype COMMA nm RP", - /* 267 */ "raisetype ::= ROLLBACK", - /* 268 */ "raisetype ::= ABORT", - /* 269 */ "raisetype ::= FAIL", - /* 270 */ "cmd ::= DROP TRIGGER ifexists fullname", - /* 271 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", - /* 272 */ "cmd ::= DETACH database_kw_opt expr", - /* 273 */ "key_opt ::=", - /* 274 */ "key_opt ::= KEY expr", - /* 275 */ "cmd ::= REINDEX", - /* 276 */ "cmd ::= REINDEX nm dbnm", - /* 277 */ "cmd ::= ANALYZE", - /* 278 */ "cmd ::= ANALYZE nm dbnm", - /* 279 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", - /* 280 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist", - /* 281 */ "add_column_fullname ::= fullname", - /* 282 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm", - /* 283 */ "cmd ::= create_vtab", - /* 284 */ "cmd ::= create_vtab LP vtabarglist RP", - /* 285 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm", - /* 286 */ "vtabarg ::=", - /* 287 */ "vtabargtoken ::= ANY", - /* 288 */ "vtabargtoken ::= lp anylist RP", - /* 289 */ "lp ::= LP", - /* 290 */ "with ::= WITH wqlist", - /* 291 */ "with ::= WITH RECURSIVE wqlist", - /* 292 */ "wqlist ::= nm eidlist_opt AS LP select RP", - /* 293 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP", - /* 294 */ "windowdefn_list ::= windowdefn", - /* 295 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn", - /* 296 */ "windowdefn ::= nm AS LP window RP", - /* 297 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt", - /* 298 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt", - /* 299 */ "window ::= ORDER BY sortlist frame_opt", - /* 300 */ "window ::= nm ORDER BY sortlist frame_opt", - /* 301 */ "window ::= frame_opt", - /* 302 */ "window ::= nm frame_opt", - /* 303 */ "frame_opt ::=", - /* 304 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt", - /* 305 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt", - /* 306 */ "range_or_rows ::= RANGE|ROWS|GROUPS", - /* 307 */ "frame_bound_s ::= frame_bound", - /* 308 */ "frame_bound_s ::= UNBOUNDED PRECEDING", - /* 309 */ "frame_bound_e ::= frame_bound", - /* 310 */ "frame_bound_e ::= UNBOUNDED FOLLOWING", - /* 311 */ "frame_bound ::= expr PRECEDING|FOLLOWING", - /* 312 */ "frame_bound ::= CURRENT ROW", - /* 313 */ "frame_exclude_opt ::=", - /* 314 */ "frame_exclude_opt ::= EXCLUDE frame_exclude", - /* 315 */ "frame_exclude ::= NO OTHERS", - /* 316 */ "frame_exclude ::= CURRENT ROW", - /* 317 */ "frame_exclude ::= GROUP|TIES", - /* 318 */ "window_clause ::= WINDOW windowdefn_list", - /* 319 */ "filter_over ::= filter_clause over_clause", - /* 320 */ "filter_over ::= over_clause", - /* 321 */ "filter_over ::= filter_clause", - /* 322 */ "over_clause ::= OVER LP window RP", - /* 323 */ "over_clause ::= OVER nm", - /* 324 */ "filter_clause ::= FILTER LP WHERE expr RP", - /* 325 */ "input ::= cmdlist", - /* 326 */ "cmdlist ::= cmdlist ecmd", - /* 327 */ "cmdlist ::= ecmd", - /* 328 */ "ecmd ::= SEMI", - /* 329 */ "ecmd ::= cmdx SEMI", - /* 330 */ "ecmd ::= explain cmdx SEMI", - /* 331 */ "trans_opt ::=", - /* 332 */ "trans_opt ::= TRANSACTION", - /* 333 */ "trans_opt ::= TRANSACTION nm", - /* 334 */ "savepoint_opt ::= SAVEPOINT", - /* 335 */ "savepoint_opt ::=", - /* 336 */ "cmd ::= create_table create_table_args", - /* 337 */ "columnlist ::= columnlist COMMA columnname carglist", - /* 338 */ "columnlist ::= columnname carglist", - /* 339 */ "nm ::= ID|INDEXED", - /* 340 */ "nm ::= STRING", - /* 341 */ "nm ::= JOIN_KW", - /* 342 */ "typetoken ::= typename", - /* 343 */ "typename ::= ID|STRING", - /* 344 */ "signed ::= plus_num", - /* 345 */ "signed ::= minus_num", - /* 346 */ "carglist ::= carglist ccons", - /* 347 */ "carglist ::=", - /* 348 */ "ccons ::= NULL onconf", - /* 349 */ "ccons ::= GENERATED ALWAYS AS generated", - /* 350 */ "ccons ::= AS generated", - /* 351 */ "conslist_opt ::= COMMA conslist", - /* 352 */ "conslist ::= conslist tconscomma tcons", - /* 353 */ "conslist ::= tcons", - /* 354 */ "tconscomma ::=", - /* 355 */ "defer_subclause_opt ::= defer_subclause", - /* 356 */ "resolvetype ::= raisetype", - /* 357 */ "selectnowith ::= oneselect", - /* 358 */ "oneselect ::= values", - /* 359 */ "sclp ::= selcollist COMMA", - /* 360 */ "as ::= ID|STRING", - /* 361 */ "expr ::= term", - /* 362 */ "likeop ::= LIKE_KW|MATCH", - /* 363 */ "exprlist ::= nexprlist", - /* 364 */ "nmnum ::= plus_num", - /* 365 */ "nmnum ::= nm", - /* 366 */ "nmnum ::= ON", - /* 367 */ "nmnum ::= DELETE", - /* 368 */ "nmnum ::= DEFAULT", - /* 369 */ "plus_num ::= INTEGER|FLOAT", - /* 370 */ "foreach_clause ::=", - /* 371 */ "foreach_clause ::= FOR EACH ROW", - /* 372 */ "trnm ::= nm", - /* 373 */ "tridxby ::=", - /* 374 */ "database_kw_opt ::= DATABASE", - /* 375 */ "database_kw_opt ::=", - /* 376 */ "kwcolumn_opt ::=", - /* 377 */ "kwcolumn_opt ::= COLUMNKW", - /* 378 */ "vtabarglist ::= vtabarg", - /* 379 */ "vtabarglist ::= vtabarglist COMMA vtabarg", - /* 380 */ "vtabarg ::= vtabarg vtabargtoken", - /* 381 */ "anylist ::=", - /* 382 */ "anylist ::= anylist LP anylist RP", - /* 383 */ "anylist ::= anylist ANY", - /* 384 */ "with ::=", + /* 21 */ "table_option_set ::=", + /* 22 */ "table_option_set ::= table_option_set COMMA table_option", + /* 23 */ "table_option ::= WITHOUT nm", + /* 24 */ "table_option ::= nm", + /* 25 */ "columnname ::= nm typetoken", + /* 26 */ "typetoken ::=", + /* 27 */ "typetoken ::= typename LP signed RP", + /* 28 */ "typetoken ::= typename LP signed COMMA signed RP", + /* 29 */ "typename ::= typename ID|STRING", + /* 30 */ "scanpt ::=", + /* 31 */ "scantok ::=", + /* 32 */ "ccons ::= CONSTRAINT nm", + /* 33 */ "ccons ::= DEFAULT scantok term", + /* 34 */ "ccons ::= DEFAULT LP expr RP", + /* 35 */ "ccons ::= DEFAULT PLUS scantok term", + /* 36 */ "ccons ::= DEFAULT MINUS scantok term", + /* 37 */ "ccons ::= DEFAULT scantok ID|INDEXED", + /* 38 */ "ccons ::= NOT NULL onconf", + /* 39 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc", + /* 40 */ "ccons ::= UNIQUE onconf", + /* 41 */ "ccons ::= CHECK LP expr RP", + /* 42 */ "ccons ::= REFERENCES nm eidlist_opt refargs", + /* 43 */ "ccons ::= defer_subclause", + /* 44 */ "ccons ::= COLLATE ID|STRING", + /* 45 */ "generated ::= LP expr RP", + /* 46 */ "generated ::= LP expr RP ID", + /* 47 */ "autoinc ::=", + /* 48 */ "autoinc ::= AUTOINCR", + /* 49 */ "refargs ::=", + /* 50 */ "refargs ::= refargs refarg", + /* 51 */ "refarg ::= MATCH nm", + /* 52 */ "refarg ::= ON INSERT refact", + /* 53 */ "refarg ::= ON DELETE refact", + /* 54 */ "refarg ::= ON UPDATE refact", + /* 55 */ "refact ::= SET NULL", + /* 56 */ "refact ::= SET DEFAULT", + /* 57 */ "refact ::= CASCADE", + /* 58 */ "refact ::= RESTRICT", + /* 59 */ "refact ::= NO ACTION", + /* 60 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", + /* 61 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", + /* 62 */ "init_deferred_pred_opt ::=", + /* 63 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", + /* 64 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", + /* 65 */ "conslist_opt ::=", + /* 66 */ "tconscomma ::= COMMA", + /* 67 */ "tcons ::= CONSTRAINT nm", + /* 68 */ "tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf", + /* 69 */ "tcons ::= UNIQUE LP sortlist RP onconf", + /* 70 */ "tcons ::= CHECK LP expr RP onconf", + /* 71 */ "tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt", + /* 72 */ "defer_subclause_opt ::=", + /* 73 */ "onconf ::=", + /* 74 */ "onconf ::= ON CONFLICT resolvetype", + /* 75 */ "orconf ::=", + /* 76 */ "orconf ::= OR resolvetype", + /* 77 */ "resolvetype ::= IGNORE", + /* 78 */ "resolvetype ::= REPLACE", + /* 79 */ "cmd ::= DROP TABLE ifexists fullname", + /* 80 */ "ifexists ::= IF EXISTS", + /* 81 */ "ifexists ::=", + /* 82 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select", + /* 83 */ "cmd ::= DROP VIEW ifexists fullname", + /* 84 */ "cmd ::= select", + /* 85 */ "select ::= WITH wqlist selectnowith", + /* 86 */ "select ::= WITH RECURSIVE wqlist selectnowith", + /* 87 */ "select ::= selectnowith", + /* 88 */ "selectnowith ::= selectnowith multiselect_op oneselect", + /* 89 */ "multiselect_op ::= UNION", + /* 90 */ "multiselect_op ::= UNION ALL", + /* 91 */ "multiselect_op ::= EXCEPT|INTERSECT", + /* 92 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", + /* 93 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt", + /* 94 */ "values ::= VALUES LP nexprlist RP", + /* 95 */ "values ::= values COMMA LP nexprlist RP", + /* 96 */ "distinct ::= DISTINCT", + /* 97 */ "distinct ::= ALL", + /* 98 */ "distinct ::=", + /* 99 */ "sclp ::=", + /* 100 */ "selcollist ::= sclp scanpt expr scanpt as", + /* 101 */ "selcollist ::= sclp scanpt STAR", + /* 102 */ "selcollist ::= sclp scanpt nm DOT STAR", + /* 103 */ "as ::= AS nm", + /* 104 */ "as ::=", + /* 105 */ "from ::=", + /* 106 */ "from ::= FROM seltablist", + /* 107 */ "stl_prefix ::= seltablist joinop", + /* 108 */ "stl_prefix ::=", + /* 109 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt", + /* 110 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt", + /* 111 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt", + /* 112 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt", + /* 113 */ "dbnm ::=", + /* 114 */ "dbnm ::= DOT nm", + /* 115 */ "fullname ::= nm", + /* 116 */ "fullname ::= nm DOT nm", + /* 117 */ "xfullname ::= nm", + /* 118 */ "xfullname ::= nm DOT nm", + /* 119 */ "xfullname ::= nm DOT nm AS nm", + /* 120 */ "xfullname ::= nm AS nm", + /* 121 */ "joinop ::= COMMA|JOIN", + /* 122 */ "joinop ::= JOIN_KW JOIN", + /* 123 */ "joinop ::= JOIN_KW nm JOIN", + /* 124 */ "joinop ::= JOIN_KW nm nm JOIN", + /* 125 */ "on_opt ::= ON expr", + /* 126 */ "on_opt ::=", + /* 127 */ "indexed_opt ::=", + /* 128 */ "indexed_opt ::= INDEXED BY nm", + /* 129 */ "indexed_opt ::= NOT INDEXED", + /* 130 */ "using_opt ::= USING LP idlist RP", + /* 131 */ "using_opt ::=", + /* 132 */ "orderby_opt ::=", + /* 133 */ "orderby_opt ::= ORDER BY sortlist", + /* 134 */ "sortlist ::= sortlist COMMA expr sortorder nulls", + /* 135 */ "sortlist ::= expr sortorder nulls", + /* 136 */ "sortorder ::= ASC", + /* 137 */ "sortorder ::= DESC", + /* 138 */ "sortorder ::=", + /* 139 */ "nulls ::= NULLS FIRST", + /* 140 */ "nulls ::= NULLS LAST", + /* 141 */ "nulls ::=", + /* 142 */ "groupby_opt ::=", + /* 143 */ "groupby_opt ::= GROUP BY nexprlist", + /* 144 */ "having_opt ::=", + /* 145 */ "having_opt ::= HAVING expr", + /* 146 */ "limit_opt ::=", + /* 147 */ "limit_opt ::= LIMIT expr", + /* 148 */ "limit_opt ::= LIMIT expr OFFSET expr", + /* 149 */ "limit_opt ::= LIMIT expr COMMA expr", + /* 150 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret", + /* 151 */ "where_opt ::=", + /* 152 */ "where_opt ::= WHERE expr", + /* 153 */ "where_opt_ret ::=", + /* 154 */ "where_opt_ret ::= WHERE expr", + /* 155 */ "where_opt_ret ::= RETURNING selcollist", + /* 156 */ "where_opt_ret ::= WHERE expr RETURNING selcollist", + /* 157 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret", + /* 158 */ "setlist ::= setlist COMMA nm EQ expr", + /* 159 */ "setlist ::= setlist COMMA LP idlist RP EQ expr", + /* 160 */ "setlist ::= nm EQ expr", + /* 161 */ "setlist ::= LP idlist RP EQ expr", + /* 162 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert", + /* 163 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning", + /* 164 */ "upsert ::=", + /* 165 */ "upsert ::= RETURNING selcollist", + /* 166 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert", + /* 167 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert", + /* 168 */ "upsert ::= ON CONFLICT DO NOTHING returning", + /* 169 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning", + /* 170 */ "returning ::= RETURNING selcollist", + /* 171 */ "insert_cmd ::= INSERT orconf", + /* 172 */ "insert_cmd ::= REPLACE", + /* 173 */ "idlist_opt ::=", + /* 174 */ "idlist_opt ::= LP idlist RP", + /* 175 */ "idlist ::= idlist COMMA nm", + /* 176 */ "idlist ::= nm", + /* 177 */ "expr ::= LP expr RP", + /* 178 */ "expr ::= ID|INDEXED", + /* 179 */ "expr ::= JOIN_KW", + /* 180 */ "expr ::= nm DOT nm", + /* 181 */ "expr ::= nm DOT nm DOT nm", + /* 182 */ "term ::= NULL|FLOAT|BLOB", + /* 183 */ "term ::= STRING", + /* 184 */ "term ::= INTEGER", + /* 185 */ "expr ::= VARIABLE", + /* 186 */ "expr ::= expr COLLATE ID|STRING", + /* 187 */ "expr ::= CAST LP expr AS typetoken RP", + /* 188 */ "expr ::= ID|INDEXED LP distinct exprlist RP", + /* 189 */ "expr ::= ID|INDEXED LP STAR RP", + /* 190 */ "expr ::= ID|INDEXED LP distinct exprlist RP filter_over", + /* 191 */ "expr ::= ID|INDEXED LP STAR RP filter_over", + /* 192 */ "term ::= CTIME_KW", + /* 193 */ "expr ::= LP nexprlist COMMA expr RP", + /* 194 */ "expr ::= expr AND expr", + /* 195 */ "expr ::= expr OR expr", + /* 196 */ "expr ::= expr LT|GT|GE|LE expr", + /* 197 */ "expr ::= expr EQ|NE expr", + /* 198 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr", + /* 199 */ "expr ::= expr PLUS|MINUS expr", + /* 200 */ "expr ::= expr STAR|SLASH|REM expr", + /* 201 */ "expr ::= expr CONCAT expr", + /* 202 */ "likeop ::= NOT LIKE_KW|MATCH", + /* 203 */ "expr ::= expr likeop expr", + /* 204 */ "expr ::= expr likeop expr ESCAPE expr", + /* 205 */ "expr ::= expr ISNULL|NOTNULL", + /* 206 */ "expr ::= expr NOT NULL", + /* 207 */ "expr ::= expr IS expr", + /* 208 */ "expr ::= expr IS NOT expr", + /* 209 */ "expr ::= NOT expr", + /* 210 */ "expr ::= BITNOT expr", + /* 211 */ "expr ::= PLUS|MINUS expr", + /* 212 */ "between_op ::= BETWEEN", + /* 213 */ "between_op ::= NOT BETWEEN", + /* 214 */ "expr ::= expr between_op expr AND expr", + /* 215 */ "in_op ::= IN", + /* 216 */ "in_op ::= NOT IN", + /* 217 */ "expr ::= expr in_op LP exprlist RP", + /* 218 */ "expr ::= LP select RP", + /* 219 */ "expr ::= expr in_op LP select RP", + /* 220 */ "expr ::= expr in_op nm dbnm paren_exprlist", + /* 221 */ "expr ::= EXISTS LP select RP", + /* 222 */ "expr ::= CASE case_operand case_exprlist case_else END", + /* 223 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", + /* 224 */ "case_exprlist ::= WHEN expr THEN expr", + /* 225 */ "case_else ::= ELSE expr", + /* 226 */ "case_else ::=", + /* 227 */ "case_operand ::= expr", + /* 228 */ "case_operand ::=", + /* 229 */ "exprlist ::=", + /* 230 */ "nexprlist ::= nexprlist COMMA expr", + /* 231 */ "nexprlist ::= expr", + /* 232 */ "paren_exprlist ::=", + /* 233 */ "paren_exprlist ::= LP exprlist RP", + /* 234 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt", + /* 235 */ "uniqueflag ::= UNIQUE", + /* 236 */ "uniqueflag ::=", + /* 237 */ "eidlist_opt ::=", + /* 238 */ "eidlist_opt ::= LP eidlist RP", + /* 239 */ "eidlist ::= eidlist COMMA nm collate sortorder", + /* 240 */ "eidlist ::= nm collate sortorder", + /* 241 */ "collate ::=", + /* 242 */ "collate ::= COLLATE ID|STRING", + /* 243 */ "cmd ::= DROP INDEX ifexists fullname", + /* 244 */ "cmd ::= VACUUM vinto", + /* 245 */ "cmd ::= VACUUM nm vinto", + /* 246 */ "vinto ::= INTO expr", + /* 247 */ "vinto ::=", + /* 248 */ "cmd ::= PRAGMA nm dbnm", + /* 249 */ "cmd ::= PRAGMA nm dbnm EQ nmnum", + /* 250 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP", + /* 251 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", + /* 252 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP", + /* 253 */ "plus_num ::= PLUS INTEGER|FLOAT", + /* 254 */ "minus_num ::= MINUS INTEGER|FLOAT", + /* 255 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END", + /* 256 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", + /* 257 */ "trigger_time ::= BEFORE|AFTER", + /* 258 */ "trigger_time ::= INSTEAD OF", + /* 259 */ "trigger_time ::=", + /* 260 */ "trigger_event ::= DELETE|INSERT", + /* 261 */ "trigger_event ::= UPDATE", + /* 262 */ "trigger_event ::= UPDATE OF idlist", + /* 263 */ "when_clause ::=", + /* 264 */ "when_clause ::= WHEN expr", + /* 265 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", + /* 266 */ "trigger_cmd_list ::= trigger_cmd SEMI", + /* 267 */ "trnm ::= nm DOT nm", + /* 268 */ "tridxby ::= INDEXED BY nm", + /* 269 */ "tridxby ::= NOT INDEXED", + /* 270 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt", + /* 271 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt", + /* 272 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt", + /* 273 */ "trigger_cmd ::= scanpt select scanpt", + /* 274 */ "expr ::= RAISE LP IGNORE RP", + /* 275 */ "expr ::= RAISE LP raisetype COMMA nm RP", + /* 276 */ "raisetype ::= ROLLBACK", + /* 277 */ "raisetype ::= ABORT", + /* 278 */ "raisetype ::= FAIL", + /* 279 */ "cmd ::= DROP TRIGGER ifexists fullname", + /* 280 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", + /* 281 */ "cmd ::= DETACH database_kw_opt expr", + /* 282 */ "key_opt ::=", + /* 283 */ "key_opt ::= KEY expr", + /* 284 */ "cmd ::= REINDEX", + /* 285 */ "cmd ::= REINDEX nm dbnm", + /* 286 */ "cmd ::= ANALYZE", + /* 287 */ "cmd ::= ANALYZE nm dbnm", + /* 288 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", + /* 289 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist", + /* 290 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm", + /* 291 */ "add_column_fullname ::= fullname", + /* 292 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm", + /* 293 */ "cmd ::= create_vtab", + /* 294 */ "cmd ::= create_vtab LP vtabarglist RP", + /* 295 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm", + /* 296 */ "vtabarg ::=", + /* 297 */ "vtabargtoken ::= ANY", + /* 298 */ "vtabargtoken ::= lp anylist RP", + /* 299 */ "lp ::= LP", + /* 300 */ "with ::= WITH wqlist", + /* 301 */ "with ::= WITH RECURSIVE wqlist", + /* 302 */ "wqas ::= AS", + /* 303 */ "wqas ::= AS MATERIALIZED", + /* 304 */ "wqas ::= AS NOT MATERIALIZED", + /* 305 */ "wqitem ::= nm eidlist_opt wqas LP select RP", + /* 306 */ "wqlist ::= wqitem", + /* 307 */ "wqlist ::= wqlist COMMA wqitem", + /* 308 */ "windowdefn_list ::= windowdefn", + /* 309 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn", + /* 310 */ "windowdefn ::= nm AS LP window RP", + /* 311 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt", + /* 312 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt", + /* 313 */ "window ::= ORDER BY sortlist frame_opt", + /* 314 */ "window ::= nm ORDER BY sortlist frame_opt", + /* 315 */ "window ::= frame_opt", + /* 316 */ "window ::= nm frame_opt", + /* 317 */ "frame_opt ::=", + /* 318 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt", + /* 319 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt", + /* 320 */ "range_or_rows ::= RANGE|ROWS|GROUPS", + /* 321 */ "frame_bound_s ::= frame_bound", + /* 322 */ "frame_bound_s ::= UNBOUNDED PRECEDING", + /* 323 */ "frame_bound_e ::= frame_bound", + /* 324 */ "frame_bound_e ::= UNBOUNDED FOLLOWING", + /* 325 */ "frame_bound ::= expr PRECEDING|FOLLOWING", + /* 326 */ "frame_bound ::= CURRENT ROW", + /* 327 */ "frame_exclude_opt ::=", + /* 328 */ "frame_exclude_opt ::= EXCLUDE frame_exclude", + /* 329 */ "frame_exclude ::= NO OTHERS", + /* 330 */ "frame_exclude ::= CURRENT ROW", + /* 331 */ "frame_exclude ::= GROUP|TIES", + /* 332 */ "window_clause ::= WINDOW windowdefn_list", + /* 333 */ "filter_over ::= filter_clause over_clause", + /* 334 */ "filter_over ::= over_clause", + /* 335 */ "filter_over ::= filter_clause", + /* 336 */ "over_clause ::= OVER LP window RP", + /* 337 */ "over_clause ::= OVER nm", + /* 338 */ "filter_clause ::= FILTER LP WHERE expr RP", + /* 339 */ "input ::= cmdlist", + /* 340 */ "cmdlist ::= cmdlist ecmd", + /* 341 */ "cmdlist ::= ecmd", + /* 342 */ "ecmd ::= SEMI", + /* 343 */ "ecmd ::= cmdx SEMI", + /* 344 */ "ecmd ::= explain cmdx SEMI", + /* 345 */ "trans_opt ::=", + /* 346 */ "trans_opt ::= TRANSACTION", + /* 347 */ "trans_opt ::= TRANSACTION nm", + /* 348 */ "savepoint_opt ::= SAVEPOINT", + /* 349 */ "savepoint_opt ::=", + /* 350 */ "cmd ::= create_table create_table_args", + /* 351 */ "table_option_set ::= table_option", + /* 352 */ "columnlist ::= columnlist COMMA columnname carglist", + /* 353 */ "columnlist ::= columnname carglist", + /* 354 */ "nm ::= ID|INDEXED", + /* 355 */ "nm ::= STRING", + /* 356 */ "nm ::= JOIN_KW", + /* 357 */ "typetoken ::= typename", + /* 358 */ "typename ::= ID|STRING", + /* 359 */ "signed ::= plus_num", + /* 360 */ "signed ::= minus_num", + /* 361 */ "carglist ::= carglist ccons", + /* 362 */ "carglist ::=", + /* 363 */ "ccons ::= NULL onconf", + /* 364 */ "ccons ::= GENERATED ALWAYS AS generated", + /* 365 */ "ccons ::= AS generated", + /* 366 */ "conslist_opt ::= COMMA conslist", + /* 367 */ "conslist ::= conslist tconscomma tcons", + /* 368 */ "conslist ::= tcons", + /* 369 */ "tconscomma ::=", + /* 370 */ "defer_subclause_opt ::= defer_subclause", + /* 371 */ "resolvetype ::= raisetype", + /* 372 */ "selectnowith ::= oneselect", + /* 373 */ "oneselect ::= values", + /* 374 */ "sclp ::= selcollist COMMA", + /* 375 */ "as ::= ID|STRING", + /* 376 */ "returning ::=", + /* 377 */ "expr ::= term", + /* 378 */ "likeop ::= LIKE_KW|MATCH", + /* 379 */ "exprlist ::= nexprlist", + /* 380 */ "nmnum ::= plus_num", + /* 381 */ "nmnum ::= nm", + /* 382 */ "nmnum ::= ON", + /* 383 */ "nmnum ::= DELETE", + /* 384 */ "nmnum ::= DEFAULT", + /* 385 */ "plus_num ::= INTEGER|FLOAT", + /* 386 */ "foreach_clause ::=", + /* 387 */ "foreach_clause ::= FOR EACH ROW", + /* 388 */ "trnm ::= nm", + /* 389 */ "tridxby ::=", + /* 390 */ "database_kw_opt ::= DATABASE", + /* 391 */ "database_kw_opt ::=", + /* 392 */ "kwcolumn_opt ::=", + /* 393 */ "kwcolumn_opt ::= COLUMNKW", + /* 394 */ "vtabarglist ::= vtabarg", + /* 395 */ "vtabarglist ::= vtabarglist COMMA vtabarg", + /* 396 */ "vtabarg ::= vtabarg vtabargtoken", + /* 397 */ "anylist ::=", + /* 398 */ "anylist ::= anylist LP anylist RP", + /* 399 */ "anylist ::= anylist ANY", + /* 400 */ "with ::=", }; #endif /* NDEBUG */ @@ -157095,98 +161762,99 @@ static void yy_destructor( ** inside the C code. */ /********* Begin destructor definitions ***************************************/ - case 200: /* select */ - case 234: /* selectnowith */ - case 235: /* oneselect */ - case 247: /* values */ + case 203: /* select */ + case 238: /* selectnowith */ + case 239: /* oneselect */ + case 251: /* values */ { -sqlite3SelectDelete(pParse->db, (yypminor->yy539)); -} - break; - case 211: /* term */ - case 212: /* expr */ - case 241: /* where_opt */ - case 243: /* having_opt */ - case 255: /* on_opt */ - case 271: /* case_operand */ - case 273: /* case_else */ - case 276: /* vinto */ - case 283: /* when_clause */ - case 288: /* key_opt */ - case 302: /* filter_clause */ +sqlite3SelectDelete(pParse->db, (yypminor->yy303)); +} + break; + case 215: /* term */ + case 216: /* expr */ + case 245: /* where_opt */ + case 247: /* having_opt */ + case 259: /* on_opt */ + case 266: /* where_opt_ret */ + case 277: /* case_operand */ + case 279: /* case_else */ + case 282: /* vinto */ + case 289: /* when_clause */ + case 294: /* key_opt */ + case 310: /* filter_clause */ { -sqlite3ExprDelete(pParse->db, (yypminor->yy202)); -} - break; - case 216: /* eidlist_opt */ - case 226: /* sortlist */ - case 227: /* eidlist */ - case 239: /* selcollist */ - case 242: /* groupby_opt */ - case 244: /* orderby_opt */ - case 248: /* nexprlist */ - case 249: /* sclp */ - case 257: /* exprlist */ - case 262: /* setlist */ - case 270: /* paren_exprlist */ - case 272: /* case_exprlist */ - case 301: /* part_opt */ +sqlite3ExprDelete(pParse->db, (yypminor->yy626)); +} + break; + case 220: /* eidlist_opt */ + case 230: /* sortlist */ + case 231: /* eidlist */ + case 243: /* selcollist */ + case 246: /* groupby_opt */ + case 248: /* orderby_opt */ + case 252: /* nexprlist */ + case 253: /* sclp */ + case 261: /* exprlist */ + case 267: /* setlist */ + case 276: /* paren_exprlist */ + case 278: /* case_exprlist */ + case 309: /* part_opt */ { -sqlite3ExprListDelete(pParse->db, (yypminor->yy242)); +sqlite3ExprListDelete(pParse->db, (yypminor->yy562)); } break; - case 233: /* fullname */ - case 240: /* from */ - case 251: /* seltablist */ - case 252: /* stl_prefix */ - case 258: /* xfullname */ + case 237: /* fullname */ + case 244: /* from */ + case 255: /* seltablist */ + case 256: /* stl_prefix */ + case 262: /* xfullname */ { -sqlite3SrcListDelete(pParse->db, (yypminor->yy47)); +sqlite3SrcListDelete(pParse->db, (yypminor->yy607)); } break; - case 236: /* wqlist */ + case 240: /* wqlist */ { -sqlite3WithDelete(pParse->db, (yypminor->yy131)); +sqlite3WithDelete(pParse->db, (yypminor->yy43)); } break; - case 246: /* window_clause */ - case 297: /* windowdefn_list */ + case 250: /* window_clause */ + case 305: /* windowdefn_list */ { -sqlite3WindowListDelete(pParse->db, (yypminor->yy303)); +sqlite3WindowListDelete(pParse->db, (yypminor->yy375)); } break; - case 256: /* using_opt */ - case 259: /* idlist */ - case 264: /* idlist_opt */ + case 260: /* using_opt */ + case 263: /* idlist */ + case 269: /* idlist_opt */ { -sqlite3IdListDelete(pParse->db, (yypminor->yy600)); +sqlite3IdListDelete(pParse->db, (yypminor->yy240)); } break; - case 266: /* filter_over */ - case 298: /* windowdefn */ - case 299: /* window */ - case 300: /* frame_opt */ - case 303: /* over_clause */ + case 272: /* filter_over */ + case 306: /* windowdefn */ + case 307: /* window */ + case 308: /* frame_opt */ + case 311: /* over_clause */ { -sqlite3WindowDelete(pParse->db, (yypminor->yy303)); +sqlite3WindowDelete(pParse->db, (yypminor->yy375)); } break; - case 279: /* trigger_cmd_list */ - case 284: /* trigger_cmd */ + case 285: /* trigger_cmd_list */ + case 290: /* trigger_cmd */ { -sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy447)); +sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy95)); } break; - case 281: /* trigger_event */ + case 287: /* trigger_event */ { -sqlite3IdListDelete(pParse->db, (yypminor->yy230).b); +sqlite3IdListDelete(pParse->db, (yypminor->yy570).b); } break; - case 305: /* frame_bound */ - case 306: /* frame_bound_s */ - case 307: /* frame_bound_e */ + case 313: /* frame_bound */ + case 314: /* frame_bound_s */ + case 315: /* frame_bound_e */ { -sqlite3ExprDelete(pParse->db, (yypminor->yy77).pExpr); +sqlite3ExprDelete(pParse->db, (yypminor->yy81).pExpr); } break; /********* End destructor definitions *****************************************/ @@ -157477,391 +162145,407 @@ static void yy_shift( /* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side ** of that rule */ static const YYCODETYPE yyRuleInfoLhs[] = { - 185, /* (0) explain ::= EXPLAIN */ - 185, /* (1) explain ::= EXPLAIN QUERY PLAN */ - 184, /* (2) cmdx ::= cmd */ - 186, /* (3) cmd ::= BEGIN transtype trans_opt */ - 187, /* (4) transtype ::= */ - 187, /* (5) transtype ::= DEFERRED */ - 187, /* (6) transtype ::= IMMEDIATE */ - 187, /* (7) transtype ::= EXCLUSIVE */ - 186, /* (8) cmd ::= COMMIT|END trans_opt */ - 186, /* (9) cmd ::= ROLLBACK trans_opt */ - 186, /* (10) cmd ::= SAVEPOINT nm */ - 186, /* (11) cmd ::= RELEASE savepoint_opt nm */ - 186, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ - 191, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */ - 193, /* (14) createkw ::= CREATE */ - 195, /* (15) ifnotexists ::= */ - 195, /* (16) ifnotexists ::= IF NOT EXISTS */ - 194, /* (17) temp ::= TEMP */ - 194, /* (18) temp ::= */ - 192, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */ - 192, /* (20) create_table_args ::= AS select */ - 199, /* (21) table_options ::= */ - 199, /* (22) table_options ::= WITHOUT nm */ - 201, /* (23) columnname ::= nm typetoken */ - 203, /* (24) typetoken ::= */ - 203, /* (25) typetoken ::= typename LP signed RP */ - 203, /* (26) typetoken ::= typename LP signed COMMA signed RP */ - 204, /* (27) typename ::= typename ID|STRING */ - 208, /* (28) scanpt ::= */ - 209, /* (29) scantok ::= */ - 210, /* (30) ccons ::= CONSTRAINT nm */ - 210, /* (31) ccons ::= DEFAULT scantok term */ - 210, /* (32) ccons ::= DEFAULT LP expr RP */ - 210, /* (33) ccons ::= DEFAULT PLUS scantok term */ - 210, /* (34) ccons ::= DEFAULT MINUS scantok term */ - 210, /* (35) ccons ::= DEFAULT scantok ID|INDEXED */ - 210, /* (36) ccons ::= NOT NULL onconf */ - 210, /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */ - 210, /* (38) ccons ::= UNIQUE onconf */ - 210, /* (39) ccons ::= CHECK LP expr RP */ - 210, /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */ - 210, /* (41) ccons ::= defer_subclause */ - 210, /* (42) ccons ::= COLLATE ID|STRING */ - 219, /* (43) generated ::= LP expr RP */ - 219, /* (44) generated ::= LP expr RP ID */ - 215, /* (45) autoinc ::= */ - 215, /* (46) autoinc ::= AUTOINCR */ - 217, /* (47) refargs ::= */ - 217, /* (48) refargs ::= refargs refarg */ - 220, /* (49) refarg ::= MATCH nm */ - 220, /* (50) refarg ::= ON INSERT refact */ - 220, /* (51) refarg ::= ON DELETE refact */ - 220, /* (52) refarg ::= ON UPDATE refact */ - 221, /* (53) refact ::= SET NULL */ - 221, /* (54) refact ::= SET DEFAULT */ - 221, /* (55) refact ::= CASCADE */ - 221, /* (56) refact ::= RESTRICT */ - 221, /* (57) refact ::= NO ACTION */ - 218, /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ - 218, /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ - 222, /* (60) init_deferred_pred_opt ::= */ - 222, /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */ - 222, /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ - 198, /* (63) conslist_opt ::= */ - 224, /* (64) tconscomma ::= COMMA */ - 225, /* (65) tcons ::= CONSTRAINT nm */ - 225, /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ - 225, /* (67) tcons ::= UNIQUE LP sortlist RP onconf */ - 225, /* (68) tcons ::= CHECK LP expr RP onconf */ - 225, /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ - 228, /* (70) defer_subclause_opt ::= */ - 213, /* (71) onconf ::= */ - 213, /* (72) onconf ::= ON CONFLICT resolvetype */ - 229, /* (73) orconf ::= */ - 229, /* (74) orconf ::= OR resolvetype */ - 230, /* (75) resolvetype ::= IGNORE */ - 230, /* (76) resolvetype ::= REPLACE */ - 186, /* (77) cmd ::= DROP TABLE ifexists fullname */ - 232, /* (78) ifexists ::= IF EXISTS */ - 232, /* (79) ifexists ::= */ - 186, /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ - 186, /* (81) cmd ::= DROP VIEW ifexists fullname */ - 186, /* (82) cmd ::= select */ - 200, /* (83) select ::= WITH wqlist selectnowith */ - 200, /* (84) select ::= WITH RECURSIVE wqlist selectnowith */ - 200, /* (85) select ::= selectnowith */ - 234, /* (86) selectnowith ::= selectnowith multiselect_op oneselect */ - 237, /* (87) multiselect_op ::= UNION */ - 237, /* (88) multiselect_op ::= UNION ALL */ - 237, /* (89) multiselect_op ::= EXCEPT|INTERSECT */ - 235, /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ - 235, /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ - 247, /* (92) values ::= VALUES LP nexprlist RP */ - 247, /* (93) values ::= values COMMA LP nexprlist RP */ - 238, /* (94) distinct ::= DISTINCT */ - 238, /* (95) distinct ::= ALL */ - 238, /* (96) distinct ::= */ - 249, /* (97) sclp ::= */ - 239, /* (98) selcollist ::= sclp scanpt expr scanpt as */ - 239, /* (99) selcollist ::= sclp scanpt STAR */ - 239, /* (100) selcollist ::= sclp scanpt nm DOT STAR */ - 250, /* (101) as ::= AS nm */ - 250, /* (102) as ::= */ - 240, /* (103) from ::= */ - 240, /* (104) from ::= FROM seltablist */ - 252, /* (105) stl_prefix ::= seltablist joinop */ - 252, /* (106) stl_prefix ::= */ - 251, /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ - 251, /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ - 251, /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */ - 251, /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ - 196, /* (111) dbnm ::= */ - 196, /* (112) dbnm ::= DOT nm */ - 233, /* (113) fullname ::= nm */ - 233, /* (114) fullname ::= nm DOT nm */ - 258, /* (115) xfullname ::= nm */ - 258, /* (116) xfullname ::= nm DOT nm */ - 258, /* (117) xfullname ::= nm DOT nm AS nm */ - 258, /* (118) xfullname ::= nm AS nm */ - 253, /* (119) joinop ::= COMMA|JOIN */ - 253, /* (120) joinop ::= JOIN_KW JOIN */ - 253, /* (121) joinop ::= JOIN_KW nm JOIN */ - 253, /* (122) joinop ::= JOIN_KW nm nm JOIN */ - 255, /* (123) on_opt ::= ON expr */ - 255, /* (124) on_opt ::= */ - 254, /* (125) indexed_opt ::= */ - 254, /* (126) indexed_opt ::= INDEXED BY nm */ - 254, /* (127) indexed_opt ::= NOT INDEXED */ - 256, /* (128) using_opt ::= USING LP idlist RP */ - 256, /* (129) using_opt ::= */ - 244, /* (130) orderby_opt ::= */ - 244, /* (131) orderby_opt ::= ORDER BY sortlist */ - 226, /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */ - 226, /* (133) sortlist ::= expr sortorder nulls */ - 214, /* (134) sortorder ::= ASC */ - 214, /* (135) sortorder ::= DESC */ - 214, /* (136) sortorder ::= */ - 260, /* (137) nulls ::= NULLS FIRST */ - 260, /* (138) nulls ::= NULLS LAST */ - 260, /* (139) nulls ::= */ - 242, /* (140) groupby_opt ::= */ - 242, /* (141) groupby_opt ::= GROUP BY nexprlist */ - 243, /* (142) having_opt ::= */ - 243, /* (143) having_opt ::= HAVING expr */ - 245, /* (144) limit_opt ::= */ - 245, /* (145) limit_opt ::= LIMIT expr */ - 245, /* (146) limit_opt ::= LIMIT expr OFFSET expr */ - 245, /* (147) limit_opt ::= LIMIT expr COMMA expr */ - 186, /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt */ - 241, /* (149) where_opt ::= */ - 241, /* (150) where_opt ::= WHERE expr */ - 186, /* (151) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */ - 262, /* (152) setlist ::= setlist COMMA nm EQ expr */ - 262, /* (153) setlist ::= setlist COMMA LP idlist RP EQ expr */ - 262, /* (154) setlist ::= nm EQ expr */ - 262, /* (155) setlist ::= LP idlist RP EQ expr */ - 186, /* (156) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ - 186, /* (157) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */ - 265, /* (158) upsert ::= */ - 265, /* (159) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */ - 265, /* (160) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */ - 265, /* (161) upsert ::= ON CONFLICT DO NOTHING */ - 263, /* (162) insert_cmd ::= INSERT orconf */ - 263, /* (163) insert_cmd ::= REPLACE */ - 264, /* (164) idlist_opt ::= */ - 264, /* (165) idlist_opt ::= LP idlist RP */ - 259, /* (166) idlist ::= idlist COMMA nm */ - 259, /* (167) idlist ::= nm */ - 212, /* (168) expr ::= LP expr RP */ - 212, /* (169) expr ::= ID|INDEXED */ - 212, /* (170) expr ::= JOIN_KW */ - 212, /* (171) expr ::= nm DOT nm */ - 212, /* (172) expr ::= nm DOT nm DOT nm */ - 211, /* (173) term ::= NULL|FLOAT|BLOB */ - 211, /* (174) term ::= STRING */ - 211, /* (175) term ::= INTEGER */ - 212, /* (176) expr ::= VARIABLE */ - 212, /* (177) expr ::= expr COLLATE ID|STRING */ - 212, /* (178) expr ::= CAST LP expr AS typetoken RP */ - 212, /* (179) expr ::= ID|INDEXED LP distinct exprlist RP */ - 212, /* (180) expr ::= ID|INDEXED LP STAR RP */ - 212, /* (181) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ - 212, /* (182) expr ::= ID|INDEXED LP STAR RP filter_over */ - 211, /* (183) term ::= CTIME_KW */ - 212, /* (184) expr ::= LP nexprlist COMMA expr RP */ - 212, /* (185) expr ::= expr AND expr */ - 212, /* (186) expr ::= expr OR expr */ - 212, /* (187) expr ::= expr LT|GT|GE|LE expr */ - 212, /* (188) expr ::= expr EQ|NE expr */ - 212, /* (189) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ - 212, /* (190) expr ::= expr PLUS|MINUS expr */ - 212, /* (191) expr ::= expr STAR|SLASH|REM expr */ - 212, /* (192) expr ::= expr CONCAT expr */ - 267, /* (193) likeop ::= NOT LIKE_KW|MATCH */ - 212, /* (194) expr ::= expr likeop expr */ - 212, /* (195) expr ::= expr likeop expr ESCAPE expr */ - 212, /* (196) expr ::= expr ISNULL|NOTNULL */ - 212, /* (197) expr ::= expr NOT NULL */ - 212, /* (198) expr ::= expr IS expr */ - 212, /* (199) expr ::= expr IS NOT expr */ - 212, /* (200) expr ::= NOT expr */ - 212, /* (201) expr ::= BITNOT expr */ - 212, /* (202) expr ::= PLUS|MINUS expr */ - 268, /* (203) between_op ::= BETWEEN */ - 268, /* (204) between_op ::= NOT BETWEEN */ - 212, /* (205) expr ::= expr between_op expr AND expr */ - 269, /* (206) in_op ::= IN */ - 269, /* (207) in_op ::= NOT IN */ - 212, /* (208) expr ::= expr in_op LP exprlist RP */ - 212, /* (209) expr ::= LP select RP */ - 212, /* (210) expr ::= expr in_op LP select RP */ - 212, /* (211) expr ::= expr in_op nm dbnm paren_exprlist */ - 212, /* (212) expr ::= EXISTS LP select RP */ - 212, /* (213) expr ::= CASE case_operand case_exprlist case_else END */ - 272, /* (214) case_exprlist ::= case_exprlist WHEN expr THEN expr */ - 272, /* (215) case_exprlist ::= WHEN expr THEN expr */ - 273, /* (216) case_else ::= ELSE expr */ - 273, /* (217) case_else ::= */ - 271, /* (218) case_operand ::= expr */ - 271, /* (219) case_operand ::= */ - 257, /* (220) exprlist ::= */ - 248, /* (221) nexprlist ::= nexprlist COMMA expr */ - 248, /* (222) nexprlist ::= expr */ - 270, /* (223) paren_exprlist ::= */ - 270, /* (224) paren_exprlist ::= LP exprlist RP */ - 186, /* (225) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ - 274, /* (226) uniqueflag ::= UNIQUE */ - 274, /* (227) uniqueflag ::= */ - 216, /* (228) eidlist_opt ::= */ - 216, /* (229) eidlist_opt ::= LP eidlist RP */ - 227, /* (230) eidlist ::= eidlist COMMA nm collate sortorder */ - 227, /* (231) eidlist ::= nm collate sortorder */ - 275, /* (232) collate ::= */ - 275, /* (233) collate ::= COLLATE ID|STRING */ - 186, /* (234) cmd ::= DROP INDEX ifexists fullname */ - 186, /* (235) cmd ::= VACUUM vinto */ - 186, /* (236) cmd ::= VACUUM nm vinto */ - 276, /* (237) vinto ::= INTO expr */ - 276, /* (238) vinto ::= */ - 186, /* (239) cmd ::= PRAGMA nm dbnm */ - 186, /* (240) cmd ::= PRAGMA nm dbnm EQ nmnum */ - 186, /* (241) cmd ::= PRAGMA nm dbnm LP nmnum RP */ - 186, /* (242) cmd ::= PRAGMA nm dbnm EQ minus_num */ - 186, /* (243) cmd ::= PRAGMA nm dbnm LP minus_num RP */ - 206, /* (244) plus_num ::= PLUS INTEGER|FLOAT */ - 207, /* (245) minus_num ::= MINUS INTEGER|FLOAT */ - 186, /* (246) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ - 278, /* (247) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ - 280, /* (248) trigger_time ::= BEFORE|AFTER */ - 280, /* (249) trigger_time ::= INSTEAD OF */ - 280, /* (250) trigger_time ::= */ - 281, /* (251) trigger_event ::= DELETE|INSERT */ - 281, /* (252) trigger_event ::= UPDATE */ - 281, /* (253) trigger_event ::= UPDATE OF idlist */ - 283, /* (254) when_clause ::= */ - 283, /* (255) when_clause ::= WHEN expr */ - 279, /* (256) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ - 279, /* (257) trigger_cmd_list ::= trigger_cmd SEMI */ - 285, /* (258) trnm ::= nm DOT nm */ - 286, /* (259) tridxby ::= INDEXED BY nm */ - 286, /* (260) tridxby ::= NOT INDEXED */ - 284, /* (261) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ - 284, /* (262) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ - 284, /* (263) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ - 284, /* (264) trigger_cmd ::= scanpt select scanpt */ - 212, /* (265) expr ::= RAISE LP IGNORE RP */ - 212, /* (266) expr ::= RAISE LP raisetype COMMA nm RP */ - 231, /* (267) raisetype ::= ROLLBACK */ - 231, /* (268) raisetype ::= ABORT */ - 231, /* (269) raisetype ::= FAIL */ - 186, /* (270) cmd ::= DROP TRIGGER ifexists fullname */ - 186, /* (271) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ - 186, /* (272) cmd ::= DETACH database_kw_opt expr */ - 288, /* (273) key_opt ::= */ - 288, /* (274) key_opt ::= KEY expr */ - 186, /* (275) cmd ::= REINDEX */ - 186, /* (276) cmd ::= REINDEX nm dbnm */ - 186, /* (277) cmd ::= ANALYZE */ - 186, /* (278) cmd ::= ANALYZE nm dbnm */ - 186, /* (279) cmd ::= ALTER TABLE fullname RENAME TO nm */ - 186, /* (280) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ - 289, /* (281) add_column_fullname ::= fullname */ - 186, /* (282) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ - 186, /* (283) cmd ::= create_vtab */ - 186, /* (284) cmd ::= create_vtab LP vtabarglist RP */ - 291, /* (285) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ - 293, /* (286) vtabarg ::= */ - 294, /* (287) vtabargtoken ::= ANY */ - 294, /* (288) vtabargtoken ::= lp anylist RP */ - 295, /* (289) lp ::= LP */ - 261, /* (290) with ::= WITH wqlist */ - 261, /* (291) with ::= WITH RECURSIVE wqlist */ - 236, /* (292) wqlist ::= nm eidlist_opt AS LP select RP */ - 236, /* (293) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */ - 297, /* (294) windowdefn_list ::= windowdefn */ - 297, /* (295) windowdefn_list ::= windowdefn_list COMMA windowdefn */ - 298, /* (296) windowdefn ::= nm AS LP window RP */ - 299, /* (297) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ - 299, /* (298) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ - 299, /* (299) window ::= ORDER BY sortlist frame_opt */ - 299, /* (300) window ::= nm ORDER BY sortlist frame_opt */ - 299, /* (301) window ::= frame_opt */ - 299, /* (302) window ::= nm frame_opt */ - 300, /* (303) frame_opt ::= */ - 300, /* (304) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ - 300, /* (305) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ - 304, /* (306) range_or_rows ::= RANGE|ROWS|GROUPS */ - 306, /* (307) frame_bound_s ::= frame_bound */ - 306, /* (308) frame_bound_s ::= UNBOUNDED PRECEDING */ - 307, /* (309) frame_bound_e ::= frame_bound */ - 307, /* (310) frame_bound_e ::= UNBOUNDED FOLLOWING */ - 305, /* (311) frame_bound ::= expr PRECEDING|FOLLOWING */ - 305, /* (312) frame_bound ::= CURRENT ROW */ - 308, /* (313) frame_exclude_opt ::= */ - 308, /* (314) frame_exclude_opt ::= EXCLUDE frame_exclude */ - 309, /* (315) frame_exclude ::= NO OTHERS */ - 309, /* (316) frame_exclude ::= CURRENT ROW */ - 309, /* (317) frame_exclude ::= GROUP|TIES */ - 246, /* (318) window_clause ::= WINDOW windowdefn_list */ - 266, /* (319) filter_over ::= filter_clause over_clause */ - 266, /* (320) filter_over ::= over_clause */ - 266, /* (321) filter_over ::= filter_clause */ - 303, /* (322) over_clause ::= OVER LP window RP */ - 303, /* (323) over_clause ::= OVER nm */ - 302, /* (324) filter_clause ::= FILTER LP WHERE expr RP */ - 181, /* (325) input ::= cmdlist */ - 182, /* (326) cmdlist ::= cmdlist ecmd */ - 182, /* (327) cmdlist ::= ecmd */ - 183, /* (328) ecmd ::= SEMI */ - 183, /* (329) ecmd ::= cmdx SEMI */ - 183, /* (330) ecmd ::= explain cmdx SEMI */ - 188, /* (331) trans_opt ::= */ - 188, /* (332) trans_opt ::= TRANSACTION */ - 188, /* (333) trans_opt ::= TRANSACTION nm */ - 190, /* (334) savepoint_opt ::= SAVEPOINT */ - 190, /* (335) savepoint_opt ::= */ - 186, /* (336) cmd ::= create_table create_table_args */ - 197, /* (337) columnlist ::= columnlist COMMA columnname carglist */ - 197, /* (338) columnlist ::= columnname carglist */ - 189, /* (339) nm ::= ID|INDEXED */ - 189, /* (340) nm ::= STRING */ - 189, /* (341) nm ::= JOIN_KW */ - 203, /* (342) typetoken ::= typename */ - 204, /* (343) typename ::= ID|STRING */ - 205, /* (344) signed ::= plus_num */ - 205, /* (345) signed ::= minus_num */ - 202, /* (346) carglist ::= carglist ccons */ - 202, /* (347) carglist ::= */ - 210, /* (348) ccons ::= NULL onconf */ - 210, /* (349) ccons ::= GENERATED ALWAYS AS generated */ - 210, /* (350) ccons ::= AS generated */ - 198, /* (351) conslist_opt ::= COMMA conslist */ - 223, /* (352) conslist ::= conslist tconscomma tcons */ - 223, /* (353) conslist ::= tcons */ - 224, /* (354) tconscomma ::= */ - 228, /* (355) defer_subclause_opt ::= defer_subclause */ - 230, /* (356) resolvetype ::= raisetype */ - 234, /* (357) selectnowith ::= oneselect */ - 235, /* (358) oneselect ::= values */ - 249, /* (359) sclp ::= selcollist COMMA */ - 250, /* (360) as ::= ID|STRING */ - 212, /* (361) expr ::= term */ - 267, /* (362) likeop ::= LIKE_KW|MATCH */ - 257, /* (363) exprlist ::= nexprlist */ - 277, /* (364) nmnum ::= plus_num */ - 277, /* (365) nmnum ::= nm */ - 277, /* (366) nmnum ::= ON */ - 277, /* (367) nmnum ::= DELETE */ - 277, /* (368) nmnum ::= DEFAULT */ - 206, /* (369) plus_num ::= INTEGER|FLOAT */ - 282, /* (370) foreach_clause ::= */ - 282, /* (371) foreach_clause ::= FOR EACH ROW */ - 285, /* (372) trnm ::= nm */ - 286, /* (373) tridxby ::= */ - 287, /* (374) database_kw_opt ::= DATABASE */ - 287, /* (375) database_kw_opt ::= */ - 290, /* (376) kwcolumn_opt ::= */ - 290, /* (377) kwcolumn_opt ::= COLUMNKW */ - 292, /* (378) vtabarglist ::= vtabarg */ - 292, /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */ - 293, /* (380) vtabarg ::= vtabarg vtabargtoken */ - 296, /* (381) anylist ::= */ - 296, /* (382) anylist ::= anylist LP anylist RP */ - 296, /* (383) anylist ::= anylist ANY */ - 261, /* (384) with ::= */ + 188, /* (0) explain ::= EXPLAIN */ + 188, /* (1) explain ::= EXPLAIN QUERY PLAN */ + 187, /* (2) cmdx ::= cmd */ + 189, /* (3) cmd ::= BEGIN transtype trans_opt */ + 190, /* (4) transtype ::= */ + 190, /* (5) transtype ::= DEFERRED */ + 190, /* (6) transtype ::= IMMEDIATE */ + 190, /* (7) transtype ::= EXCLUSIVE */ + 189, /* (8) cmd ::= COMMIT|END trans_opt */ + 189, /* (9) cmd ::= ROLLBACK trans_opt */ + 189, /* (10) cmd ::= SAVEPOINT nm */ + 189, /* (11) cmd ::= RELEASE savepoint_opt nm */ + 189, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ + 194, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */ + 196, /* (14) createkw ::= CREATE */ + 198, /* (15) ifnotexists ::= */ + 198, /* (16) ifnotexists ::= IF NOT EXISTS */ + 197, /* (17) temp ::= TEMP */ + 197, /* (18) temp ::= */ + 195, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */ + 195, /* (20) create_table_args ::= AS select */ + 202, /* (21) table_option_set ::= */ + 202, /* (22) table_option_set ::= table_option_set COMMA table_option */ + 204, /* (23) table_option ::= WITHOUT nm */ + 204, /* (24) table_option ::= nm */ + 205, /* (25) columnname ::= nm typetoken */ + 207, /* (26) typetoken ::= */ + 207, /* (27) typetoken ::= typename LP signed RP */ + 207, /* (28) typetoken ::= typename LP signed COMMA signed RP */ + 208, /* (29) typename ::= typename ID|STRING */ + 212, /* (30) scanpt ::= */ + 213, /* (31) scantok ::= */ + 214, /* (32) ccons ::= CONSTRAINT nm */ + 214, /* (33) ccons ::= DEFAULT scantok term */ + 214, /* (34) ccons ::= DEFAULT LP expr RP */ + 214, /* (35) ccons ::= DEFAULT PLUS scantok term */ + 214, /* (36) ccons ::= DEFAULT MINUS scantok term */ + 214, /* (37) ccons ::= DEFAULT scantok ID|INDEXED */ + 214, /* (38) ccons ::= NOT NULL onconf */ + 214, /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */ + 214, /* (40) ccons ::= UNIQUE onconf */ + 214, /* (41) ccons ::= CHECK LP expr RP */ + 214, /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */ + 214, /* (43) ccons ::= defer_subclause */ + 214, /* (44) ccons ::= COLLATE ID|STRING */ + 223, /* (45) generated ::= LP expr RP */ + 223, /* (46) generated ::= LP expr RP ID */ + 219, /* (47) autoinc ::= */ + 219, /* (48) autoinc ::= AUTOINCR */ + 221, /* (49) refargs ::= */ + 221, /* (50) refargs ::= refargs refarg */ + 224, /* (51) refarg ::= MATCH nm */ + 224, /* (52) refarg ::= ON INSERT refact */ + 224, /* (53) refarg ::= ON DELETE refact */ + 224, /* (54) refarg ::= ON UPDATE refact */ + 225, /* (55) refact ::= SET NULL */ + 225, /* (56) refact ::= SET DEFAULT */ + 225, /* (57) refact ::= CASCADE */ + 225, /* (58) refact ::= RESTRICT */ + 225, /* (59) refact ::= NO ACTION */ + 222, /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ + 222, /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + 226, /* (62) init_deferred_pred_opt ::= */ + 226, /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */ + 226, /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ + 201, /* (65) conslist_opt ::= */ + 228, /* (66) tconscomma ::= COMMA */ + 229, /* (67) tcons ::= CONSTRAINT nm */ + 229, /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ + 229, /* (69) tcons ::= UNIQUE LP sortlist RP onconf */ + 229, /* (70) tcons ::= CHECK LP expr RP onconf */ + 229, /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ + 232, /* (72) defer_subclause_opt ::= */ + 217, /* (73) onconf ::= */ + 217, /* (74) onconf ::= ON CONFLICT resolvetype */ + 233, /* (75) orconf ::= */ + 233, /* (76) orconf ::= OR resolvetype */ + 234, /* (77) resolvetype ::= IGNORE */ + 234, /* (78) resolvetype ::= REPLACE */ + 189, /* (79) cmd ::= DROP TABLE ifexists fullname */ + 236, /* (80) ifexists ::= IF EXISTS */ + 236, /* (81) ifexists ::= */ + 189, /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ + 189, /* (83) cmd ::= DROP VIEW ifexists fullname */ + 189, /* (84) cmd ::= select */ + 203, /* (85) select ::= WITH wqlist selectnowith */ + 203, /* (86) select ::= WITH RECURSIVE wqlist selectnowith */ + 203, /* (87) select ::= selectnowith */ + 238, /* (88) selectnowith ::= selectnowith multiselect_op oneselect */ + 241, /* (89) multiselect_op ::= UNION */ + 241, /* (90) multiselect_op ::= UNION ALL */ + 241, /* (91) multiselect_op ::= EXCEPT|INTERSECT */ + 239, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ + 239, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ + 251, /* (94) values ::= VALUES LP nexprlist RP */ + 251, /* (95) values ::= values COMMA LP nexprlist RP */ + 242, /* (96) distinct ::= DISTINCT */ + 242, /* (97) distinct ::= ALL */ + 242, /* (98) distinct ::= */ + 253, /* (99) sclp ::= */ + 243, /* (100) selcollist ::= sclp scanpt expr scanpt as */ + 243, /* (101) selcollist ::= sclp scanpt STAR */ + 243, /* (102) selcollist ::= sclp scanpt nm DOT STAR */ + 254, /* (103) as ::= AS nm */ + 254, /* (104) as ::= */ + 244, /* (105) from ::= */ + 244, /* (106) from ::= FROM seltablist */ + 256, /* (107) stl_prefix ::= seltablist joinop */ + 256, /* (108) stl_prefix ::= */ + 255, /* (109) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ + 255, /* (110) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ + 255, /* (111) seltablist ::= stl_prefix LP select RP as on_opt using_opt */ + 255, /* (112) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ + 199, /* (113) dbnm ::= */ + 199, /* (114) dbnm ::= DOT nm */ + 237, /* (115) fullname ::= nm */ + 237, /* (116) fullname ::= nm DOT nm */ + 262, /* (117) xfullname ::= nm */ + 262, /* (118) xfullname ::= nm DOT nm */ + 262, /* (119) xfullname ::= nm DOT nm AS nm */ + 262, /* (120) xfullname ::= nm AS nm */ + 257, /* (121) joinop ::= COMMA|JOIN */ + 257, /* (122) joinop ::= JOIN_KW JOIN */ + 257, /* (123) joinop ::= JOIN_KW nm JOIN */ + 257, /* (124) joinop ::= JOIN_KW nm nm JOIN */ + 259, /* (125) on_opt ::= ON expr */ + 259, /* (126) on_opt ::= */ + 258, /* (127) indexed_opt ::= */ + 258, /* (128) indexed_opt ::= INDEXED BY nm */ + 258, /* (129) indexed_opt ::= NOT INDEXED */ + 260, /* (130) using_opt ::= USING LP idlist RP */ + 260, /* (131) using_opt ::= */ + 248, /* (132) orderby_opt ::= */ + 248, /* (133) orderby_opt ::= ORDER BY sortlist */ + 230, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */ + 230, /* (135) sortlist ::= expr sortorder nulls */ + 218, /* (136) sortorder ::= ASC */ + 218, /* (137) sortorder ::= DESC */ + 218, /* (138) sortorder ::= */ + 264, /* (139) nulls ::= NULLS FIRST */ + 264, /* (140) nulls ::= NULLS LAST */ + 264, /* (141) nulls ::= */ + 246, /* (142) groupby_opt ::= */ + 246, /* (143) groupby_opt ::= GROUP BY nexprlist */ + 247, /* (144) having_opt ::= */ + 247, /* (145) having_opt ::= HAVING expr */ + 249, /* (146) limit_opt ::= */ + 249, /* (147) limit_opt ::= LIMIT expr */ + 249, /* (148) limit_opt ::= LIMIT expr OFFSET expr */ + 249, /* (149) limit_opt ::= LIMIT expr COMMA expr */ + 189, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ + 245, /* (151) where_opt ::= */ + 245, /* (152) where_opt ::= WHERE expr */ + 266, /* (153) where_opt_ret ::= */ + 266, /* (154) where_opt_ret ::= WHERE expr */ + 266, /* (155) where_opt_ret ::= RETURNING selcollist */ + 266, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */ + 189, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ + 267, /* (158) setlist ::= setlist COMMA nm EQ expr */ + 267, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */ + 267, /* (160) setlist ::= nm EQ expr */ + 267, /* (161) setlist ::= LP idlist RP EQ expr */ + 189, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ + 189, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ + 270, /* (164) upsert ::= */ + 270, /* (165) upsert ::= RETURNING selcollist */ + 270, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ + 270, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ + 270, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */ + 270, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ + 271, /* (170) returning ::= RETURNING selcollist */ + 268, /* (171) insert_cmd ::= INSERT orconf */ + 268, /* (172) insert_cmd ::= REPLACE */ + 269, /* (173) idlist_opt ::= */ + 269, /* (174) idlist_opt ::= LP idlist RP */ + 263, /* (175) idlist ::= idlist COMMA nm */ + 263, /* (176) idlist ::= nm */ + 216, /* (177) expr ::= LP expr RP */ + 216, /* (178) expr ::= ID|INDEXED */ + 216, /* (179) expr ::= JOIN_KW */ + 216, /* (180) expr ::= nm DOT nm */ + 216, /* (181) expr ::= nm DOT nm DOT nm */ + 215, /* (182) term ::= NULL|FLOAT|BLOB */ + 215, /* (183) term ::= STRING */ + 215, /* (184) term ::= INTEGER */ + 216, /* (185) expr ::= VARIABLE */ + 216, /* (186) expr ::= expr COLLATE ID|STRING */ + 216, /* (187) expr ::= CAST LP expr AS typetoken RP */ + 216, /* (188) expr ::= ID|INDEXED LP distinct exprlist RP */ + 216, /* (189) expr ::= ID|INDEXED LP STAR RP */ + 216, /* (190) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ + 216, /* (191) expr ::= ID|INDEXED LP STAR RP filter_over */ + 215, /* (192) term ::= CTIME_KW */ + 216, /* (193) expr ::= LP nexprlist COMMA expr RP */ + 216, /* (194) expr ::= expr AND expr */ + 216, /* (195) expr ::= expr OR expr */ + 216, /* (196) expr ::= expr LT|GT|GE|LE expr */ + 216, /* (197) expr ::= expr EQ|NE expr */ + 216, /* (198) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ + 216, /* (199) expr ::= expr PLUS|MINUS expr */ + 216, /* (200) expr ::= expr STAR|SLASH|REM expr */ + 216, /* (201) expr ::= expr CONCAT expr */ + 273, /* (202) likeop ::= NOT LIKE_KW|MATCH */ + 216, /* (203) expr ::= expr likeop expr */ + 216, /* (204) expr ::= expr likeop expr ESCAPE expr */ + 216, /* (205) expr ::= expr ISNULL|NOTNULL */ + 216, /* (206) expr ::= expr NOT NULL */ + 216, /* (207) expr ::= expr IS expr */ + 216, /* (208) expr ::= expr IS NOT expr */ + 216, /* (209) expr ::= NOT expr */ + 216, /* (210) expr ::= BITNOT expr */ + 216, /* (211) expr ::= PLUS|MINUS expr */ + 274, /* (212) between_op ::= BETWEEN */ + 274, /* (213) between_op ::= NOT BETWEEN */ + 216, /* (214) expr ::= expr between_op expr AND expr */ + 275, /* (215) in_op ::= IN */ + 275, /* (216) in_op ::= NOT IN */ + 216, /* (217) expr ::= expr in_op LP exprlist RP */ + 216, /* (218) expr ::= LP select RP */ + 216, /* (219) expr ::= expr in_op LP select RP */ + 216, /* (220) expr ::= expr in_op nm dbnm paren_exprlist */ + 216, /* (221) expr ::= EXISTS LP select RP */ + 216, /* (222) expr ::= CASE case_operand case_exprlist case_else END */ + 278, /* (223) case_exprlist ::= case_exprlist WHEN expr THEN expr */ + 278, /* (224) case_exprlist ::= WHEN expr THEN expr */ + 279, /* (225) case_else ::= ELSE expr */ + 279, /* (226) case_else ::= */ + 277, /* (227) case_operand ::= expr */ + 277, /* (228) case_operand ::= */ + 261, /* (229) exprlist ::= */ + 252, /* (230) nexprlist ::= nexprlist COMMA expr */ + 252, /* (231) nexprlist ::= expr */ + 276, /* (232) paren_exprlist ::= */ + 276, /* (233) paren_exprlist ::= LP exprlist RP */ + 189, /* (234) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ + 280, /* (235) uniqueflag ::= UNIQUE */ + 280, /* (236) uniqueflag ::= */ + 220, /* (237) eidlist_opt ::= */ + 220, /* (238) eidlist_opt ::= LP eidlist RP */ + 231, /* (239) eidlist ::= eidlist COMMA nm collate sortorder */ + 231, /* (240) eidlist ::= nm collate sortorder */ + 281, /* (241) collate ::= */ + 281, /* (242) collate ::= COLLATE ID|STRING */ + 189, /* (243) cmd ::= DROP INDEX ifexists fullname */ + 189, /* (244) cmd ::= VACUUM vinto */ + 189, /* (245) cmd ::= VACUUM nm vinto */ + 282, /* (246) vinto ::= INTO expr */ + 282, /* (247) vinto ::= */ + 189, /* (248) cmd ::= PRAGMA nm dbnm */ + 189, /* (249) cmd ::= PRAGMA nm dbnm EQ nmnum */ + 189, /* (250) cmd ::= PRAGMA nm dbnm LP nmnum RP */ + 189, /* (251) cmd ::= PRAGMA nm dbnm EQ minus_num */ + 189, /* (252) cmd ::= PRAGMA nm dbnm LP minus_num RP */ + 210, /* (253) plus_num ::= PLUS INTEGER|FLOAT */ + 211, /* (254) minus_num ::= MINUS INTEGER|FLOAT */ + 189, /* (255) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ + 284, /* (256) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ + 286, /* (257) trigger_time ::= BEFORE|AFTER */ + 286, /* (258) trigger_time ::= INSTEAD OF */ + 286, /* (259) trigger_time ::= */ + 287, /* (260) trigger_event ::= DELETE|INSERT */ + 287, /* (261) trigger_event ::= UPDATE */ + 287, /* (262) trigger_event ::= UPDATE OF idlist */ + 289, /* (263) when_clause ::= */ + 289, /* (264) when_clause ::= WHEN expr */ + 285, /* (265) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ + 285, /* (266) trigger_cmd_list ::= trigger_cmd SEMI */ + 291, /* (267) trnm ::= nm DOT nm */ + 292, /* (268) tridxby ::= INDEXED BY nm */ + 292, /* (269) tridxby ::= NOT INDEXED */ + 290, /* (270) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ + 290, /* (271) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ + 290, /* (272) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ + 290, /* (273) trigger_cmd ::= scanpt select scanpt */ + 216, /* (274) expr ::= RAISE LP IGNORE RP */ + 216, /* (275) expr ::= RAISE LP raisetype COMMA nm RP */ + 235, /* (276) raisetype ::= ROLLBACK */ + 235, /* (277) raisetype ::= ABORT */ + 235, /* (278) raisetype ::= FAIL */ + 189, /* (279) cmd ::= DROP TRIGGER ifexists fullname */ + 189, /* (280) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ + 189, /* (281) cmd ::= DETACH database_kw_opt expr */ + 294, /* (282) key_opt ::= */ + 294, /* (283) key_opt ::= KEY expr */ + 189, /* (284) cmd ::= REINDEX */ + 189, /* (285) cmd ::= REINDEX nm dbnm */ + 189, /* (286) cmd ::= ANALYZE */ + 189, /* (287) cmd ::= ANALYZE nm dbnm */ + 189, /* (288) cmd ::= ALTER TABLE fullname RENAME TO nm */ + 189, /* (289) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ + 189, /* (290) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ + 295, /* (291) add_column_fullname ::= fullname */ + 189, /* (292) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ + 189, /* (293) cmd ::= create_vtab */ + 189, /* (294) cmd ::= create_vtab LP vtabarglist RP */ + 297, /* (295) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ + 299, /* (296) vtabarg ::= */ + 300, /* (297) vtabargtoken ::= ANY */ + 300, /* (298) vtabargtoken ::= lp anylist RP */ + 301, /* (299) lp ::= LP */ + 265, /* (300) with ::= WITH wqlist */ + 265, /* (301) with ::= WITH RECURSIVE wqlist */ + 304, /* (302) wqas ::= AS */ + 304, /* (303) wqas ::= AS MATERIALIZED */ + 304, /* (304) wqas ::= AS NOT MATERIALIZED */ + 303, /* (305) wqitem ::= nm eidlist_opt wqas LP select RP */ + 240, /* (306) wqlist ::= wqitem */ + 240, /* (307) wqlist ::= wqlist COMMA wqitem */ + 305, /* (308) windowdefn_list ::= windowdefn */ + 305, /* (309) windowdefn_list ::= windowdefn_list COMMA windowdefn */ + 306, /* (310) windowdefn ::= nm AS LP window RP */ + 307, /* (311) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ + 307, /* (312) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ + 307, /* (313) window ::= ORDER BY sortlist frame_opt */ + 307, /* (314) window ::= nm ORDER BY sortlist frame_opt */ + 307, /* (315) window ::= frame_opt */ + 307, /* (316) window ::= nm frame_opt */ + 308, /* (317) frame_opt ::= */ + 308, /* (318) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ + 308, /* (319) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ + 312, /* (320) range_or_rows ::= RANGE|ROWS|GROUPS */ + 314, /* (321) frame_bound_s ::= frame_bound */ + 314, /* (322) frame_bound_s ::= UNBOUNDED PRECEDING */ + 315, /* (323) frame_bound_e ::= frame_bound */ + 315, /* (324) frame_bound_e ::= UNBOUNDED FOLLOWING */ + 313, /* (325) frame_bound ::= expr PRECEDING|FOLLOWING */ + 313, /* (326) frame_bound ::= CURRENT ROW */ + 316, /* (327) frame_exclude_opt ::= */ + 316, /* (328) frame_exclude_opt ::= EXCLUDE frame_exclude */ + 317, /* (329) frame_exclude ::= NO OTHERS */ + 317, /* (330) frame_exclude ::= CURRENT ROW */ + 317, /* (331) frame_exclude ::= GROUP|TIES */ + 250, /* (332) window_clause ::= WINDOW windowdefn_list */ + 272, /* (333) filter_over ::= filter_clause over_clause */ + 272, /* (334) filter_over ::= over_clause */ + 272, /* (335) filter_over ::= filter_clause */ + 311, /* (336) over_clause ::= OVER LP window RP */ + 311, /* (337) over_clause ::= OVER nm */ + 310, /* (338) filter_clause ::= FILTER LP WHERE expr RP */ + 184, /* (339) input ::= cmdlist */ + 185, /* (340) cmdlist ::= cmdlist ecmd */ + 185, /* (341) cmdlist ::= ecmd */ + 186, /* (342) ecmd ::= SEMI */ + 186, /* (343) ecmd ::= cmdx SEMI */ + 186, /* (344) ecmd ::= explain cmdx SEMI */ + 191, /* (345) trans_opt ::= */ + 191, /* (346) trans_opt ::= TRANSACTION */ + 191, /* (347) trans_opt ::= TRANSACTION nm */ + 193, /* (348) savepoint_opt ::= SAVEPOINT */ + 193, /* (349) savepoint_opt ::= */ + 189, /* (350) cmd ::= create_table create_table_args */ + 202, /* (351) table_option_set ::= table_option */ + 200, /* (352) columnlist ::= columnlist COMMA columnname carglist */ + 200, /* (353) columnlist ::= columnname carglist */ + 192, /* (354) nm ::= ID|INDEXED */ + 192, /* (355) nm ::= STRING */ + 192, /* (356) nm ::= JOIN_KW */ + 207, /* (357) typetoken ::= typename */ + 208, /* (358) typename ::= ID|STRING */ + 209, /* (359) signed ::= plus_num */ + 209, /* (360) signed ::= minus_num */ + 206, /* (361) carglist ::= carglist ccons */ + 206, /* (362) carglist ::= */ + 214, /* (363) ccons ::= NULL onconf */ + 214, /* (364) ccons ::= GENERATED ALWAYS AS generated */ + 214, /* (365) ccons ::= AS generated */ + 201, /* (366) conslist_opt ::= COMMA conslist */ + 227, /* (367) conslist ::= conslist tconscomma tcons */ + 227, /* (368) conslist ::= tcons */ + 228, /* (369) tconscomma ::= */ + 232, /* (370) defer_subclause_opt ::= defer_subclause */ + 234, /* (371) resolvetype ::= raisetype */ + 238, /* (372) selectnowith ::= oneselect */ + 239, /* (373) oneselect ::= values */ + 253, /* (374) sclp ::= selcollist COMMA */ + 254, /* (375) as ::= ID|STRING */ + 271, /* (376) returning ::= */ + 216, /* (377) expr ::= term */ + 273, /* (378) likeop ::= LIKE_KW|MATCH */ + 261, /* (379) exprlist ::= nexprlist */ + 283, /* (380) nmnum ::= plus_num */ + 283, /* (381) nmnum ::= nm */ + 283, /* (382) nmnum ::= ON */ + 283, /* (383) nmnum ::= DELETE */ + 283, /* (384) nmnum ::= DEFAULT */ + 210, /* (385) plus_num ::= INTEGER|FLOAT */ + 288, /* (386) foreach_clause ::= */ + 288, /* (387) foreach_clause ::= FOR EACH ROW */ + 291, /* (388) trnm ::= nm */ + 292, /* (389) tridxby ::= */ + 293, /* (390) database_kw_opt ::= DATABASE */ + 293, /* (391) database_kw_opt ::= */ + 296, /* (392) kwcolumn_opt ::= */ + 296, /* (393) kwcolumn_opt ::= COLUMNKW */ + 298, /* (394) vtabarglist ::= vtabarg */ + 298, /* (395) vtabarglist ::= vtabarglist COMMA vtabarg */ + 299, /* (396) vtabarg ::= vtabarg vtabargtoken */ + 302, /* (397) anylist ::= */ + 302, /* (398) anylist ::= anylist LP anylist RP */ + 302, /* (399) anylist ::= anylist ANY */ + 265, /* (400) with ::= */ }; /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number @@ -157886,372 +162570,388 @@ static const signed char yyRuleInfoNRhs[] = { -3, /* (16) ifnotexists ::= IF NOT EXISTS */ -1, /* (17) temp ::= TEMP */ 0, /* (18) temp ::= */ - -5, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */ + -5, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */ -2, /* (20) create_table_args ::= AS select */ - 0, /* (21) table_options ::= */ - -2, /* (22) table_options ::= WITHOUT nm */ - -2, /* (23) columnname ::= nm typetoken */ - 0, /* (24) typetoken ::= */ - -4, /* (25) typetoken ::= typename LP signed RP */ - -6, /* (26) typetoken ::= typename LP signed COMMA signed RP */ - -2, /* (27) typename ::= typename ID|STRING */ - 0, /* (28) scanpt ::= */ - 0, /* (29) scantok ::= */ - -2, /* (30) ccons ::= CONSTRAINT nm */ - -3, /* (31) ccons ::= DEFAULT scantok term */ - -4, /* (32) ccons ::= DEFAULT LP expr RP */ - -4, /* (33) ccons ::= DEFAULT PLUS scantok term */ - -4, /* (34) ccons ::= DEFAULT MINUS scantok term */ - -3, /* (35) ccons ::= DEFAULT scantok ID|INDEXED */ - -3, /* (36) ccons ::= NOT NULL onconf */ - -5, /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */ - -2, /* (38) ccons ::= UNIQUE onconf */ - -4, /* (39) ccons ::= CHECK LP expr RP */ - -4, /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */ - -1, /* (41) ccons ::= defer_subclause */ - -2, /* (42) ccons ::= COLLATE ID|STRING */ - -3, /* (43) generated ::= LP expr RP */ - -4, /* (44) generated ::= LP expr RP ID */ - 0, /* (45) autoinc ::= */ - -1, /* (46) autoinc ::= AUTOINCR */ - 0, /* (47) refargs ::= */ - -2, /* (48) refargs ::= refargs refarg */ - -2, /* (49) refarg ::= MATCH nm */ - -3, /* (50) refarg ::= ON INSERT refact */ - -3, /* (51) refarg ::= ON DELETE refact */ - -3, /* (52) refarg ::= ON UPDATE refact */ - -2, /* (53) refact ::= SET NULL */ - -2, /* (54) refact ::= SET DEFAULT */ - -1, /* (55) refact ::= CASCADE */ - -1, /* (56) refact ::= RESTRICT */ - -2, /* (57) refact ::= NO ACTION */ - -3, /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ - -2, /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ - 0, /* (60) init_deferred_pred_opt ::= */ - -2, /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */ - -2, /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ - 0, /* (63) conslist_opt ::= */ - -1, /* (64) tconscomma ::= COMMA */ - -2, /* (65) tcons ::= CONSTRAINT nm */ - -7, /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ - -5, /* (67) tcons ::= UNIQUE LP sortlist RP onconf */ - -5, /* (68) tcons ::= CHECK LP expr RP onconf */ - -10, /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ - 0, /* (70) defer_subclause_opt ::= */ - 0, /* (71) onconf ::= */ - -3, /* (72) onconf ::= ON CONFLICT resolvetype */ - 0, /* (73) orconf ::= */ - -2, /* (74) orconf ::= OR resolvetype */ - -1, /* (75) resolvetype ::= IGNORE */ - -1, /* (76) resolvetype ::= REPLACE */ - -4, /* (77) cmd ::= DROP TABLE ifexists fullname */ - -2, /* (78) ifexists ::= IF EXISTS */ - 0, /* (79) ifexists ::= */ - -9, /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ - -4, /* (81) cmd ::= DROP VIEW ifexists fullname */ - -1, /* (82) cmd ::= select */ - -3, /* (83) select ::= WITH wqlist selectnowith */ - -4, /* (84) select ::= WITH RECURSIVE wqlist selectnowith */ - -1, /* (85) select ::= selectnowith */ - -3, /* (86) selectnowith ::= selectnowith multiselect_op oneselect */ - -1, /* (87) multiselect_op ::= UNION */ - -2, /* (88) multiselect_op ::= UNION ALL */ - -1, /* (89) multiselect_op ::= EXCEPT|INTERSECT */ - -9, /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ - -10, /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ - -4, /* (92) values ::= VALUES LP nexprlist RP */ - -5, /* (93) values ::= values COMMA LP nexprlist RP */ - -1, /* (94) distinct ::= DISTINCT */ - -1, /* (95) distinct ::= ALL */ - 0, /* (96) distinct ::= */ - 0, /* (97) sclp ::= */ - -5, /* (98) selcollist ::= sclp scanpt expr scanpt as */ - -3, /* (99) selcollist ::= sclp scanpt STAR */ - -5, /* (100) selcollist ::= sclp scanpt nm DOT STAR */ - -2, /* (101) as ::= AS nm */ - 0, /* (102) as ::= */ - 0, /* (103) from ::= */ - -2, /* (104) from ::= FROM seltablist */ - -2, /* (105) stl_prefix ::= seltablist joinop */ - 0, /* (106) stl_prefix ::= */ - -7, /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ - -9, /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ - -7, /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */ - -7, /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ - 0, /* (111) dbnm ::= */ - -2, /* (112) dbnm ::= DOT nm */ - -1, /* (113) fullname ::= nm */ - -3, /* (114) fullname ::= nm DOT nm */ - -1, /* (115) xfullname ::= nm */ - -3, /* (116) xfullname ::= nm DOT nm */ - -5, /* (117) xfullname ::= nm DOT nm AS nm */ - -3, /* (118) xfullname ::= nm AS nm */ - -1, /* (119) joinop ::= COMMA|JOIN */ - -2, /* (120) joinop ::= JOIN_KW JOIN */ - -3, /* (121) joinop ::= JOIN_KW nm JOIN */ - -4, /* (122) joinop ::= JOIN_KW nm nm JOIN */ - -2, /* (123) on_opt ::= ON expr */ - 0, /* (124) on_opt ::= */ - 0, /* (125) indexed_opt ::= */ - -3, /* (126) indexed_opt ::= INDEXED BY nm */ - -2, /* (127) indexed_opt ::= NOT INDEXED */ - -4, /* (128) using_opt ::= USING LP idlist RP */ - 0, /* (129) using_opt ::= */ - 0, /* (130) orderby_opt ::= */ - -3, /* (131) orderby_opt ::= ORDER BY sortlist */ - -5, /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */ - -3, /* (133) sortlist ::= expr sortorder nulls */ - -1, /* (134) sortorder ::= ASC */ - -1, /* (135) sortorder ::= DESC */ - 0, /* (136) sortorder ::= */ - -2, /* (137) nulls ::= NULLS FIRST */ - -2, /* (138) nulls ::= NULLS LAST */ - 0, /* (139) nulls ::= */ - 0, /* (140) groupby_opt ::= */ - -3, /* (141) groupby_opt ::= GROUP BY nexprlist */ - 0, /* (142) having_opt ::= */ - -2, /* (143) having_opt ::= HAVING expr */ - 0, /* (144) limit_opt ::= */ - -2, /* (145) limit_opt ::= LIMIT expr */ - -4, /* (146) limit_opt ::= LIMIT expr OFFSET expr */ - -4, /* (147) limit_opt ::= LIMIT expr COMMA expr */ - -6, /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt */ - 0, /* (149) where_opt ::= */ - -2, /* (150) where_opt ::= WHERE expr */ - -9, /* (151) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */ - -5, /* (152) setlist ::= setlist COMMA nm EQ expr */ - -7, /* (153) setlist ::= setlist COMMA LP idlist RP EQ expr */ - -3, /* (154) setlist ::= nm EQ expr */ - -5, /* (155) setlist ::= LP idlist RP EQ expr */ - -7, /* (156) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ - -7, /* (157) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */ - 0, /* (158) upsert ::= */ - -11, /* (159) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */ - -8, /* (160) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */ - -4, /* (161) upsert ::= ON CONFLICT DO NOTHING */ - -2, /* (162) insert_cmd ::= INSERT orconf */ - -1, /* (163) insert_cmd ::= REPLACE */ - 0, /* (164) idlist_opt ::= */ - -3, /* (165) idlist_opt ::= LP idlist RP */ - -3, /* (166) idlist ::= idlist COMMA nm */ - -1, /* (167) idlist ::= nm */ - -3, /* (168) expr ::= LP expr RP */ - -1, /* (169) expr ::= ID|INDEXED */ - -1, /* (170) expr ::= JOIN_KW */ - -3, /* (171) expr ::= nm DOT nm */ - -5, /* (172) expr ::= nm DOT nm DOT nm */ - -1, /* (173) term ::= NULL|FLOAT|BLOB */ - -1, /* (174) term ::= STRING */ - -1, /* (175) term ::= INTEGER */ - -1, /* (176) expr ::= VARIABLE */ - -3, /* (177) expr ::= expr COLLATE ID|STRING */ - -6, /* (178) expr ::= CAST LP expr AS typetoken RP */ - -5, /* (179) expr ::= ID|INDEXED LP distinct exprlist RP */ - -4, /* (180) expr ::= ID|INDEXED LP STAR RP */ - -6, /* (181) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ - -5, /* (182) expr ::= ID|INDEXED LP STAR RP filter_over */ - -1, /* (183) term ::= CTIME_KW */ - -5, /* (184) expr ::= LP nexprlist COMMA expr RP */ - -3, /* (185) expr ::= expr AND expr */ - -3, /* (186) expr ::= expr OR expr */ - -3, /* (187) expr ::= expr LT|GT|GE|LE expr */ - -3, /* (188) expr ::= expr EQ|NE expr */ - -3, /* (189) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ - -3, /* (190) expr ::= expr PLUS|MINUS expr */ - -3, /* (191) expr ::= expr STAR|SLASH|REM expr */ - -3, /* (192) expr ::= expr CONCAT expr */ - -2, /* (193) likeop ::= NOT LIKE_KW|MATCH */ - -3, /* (194) expr ::= expr likeop expr */ - -5, /* (195) expr ::= expr likeop expr ESCAPE expr */ - -2, /* (196) expr ::= expr ISNULL|NOTNULL */ - -3, /* (197) expr ::= expr NOT NULL */ - -3, /* (198) expr ::= expr IS expr */ - -4, /* (199) expr ::= expr IS NOT expr */ - -2, /* (200) expr ::= NOT expr */ - -2, /* (201) expr ::= BITNOT expr */ - -2, /* (202) expr ::= PLUS|MINUS expr */ - -1, /* (203) between_op ::= BETWEEN */ - -2, /* (204) between_op ::= NOT BETWEEN */ - -5, /* (205) expr ::= expr between_op expr AND expr */ - -1, /* (206) in_op ::= IN */ - -2, /* (207) in_op ::= NOT IN */ - -5, /* (208) expr ::= expr in_op LP exprlist RP */ - -3, /* (209) expr ::= LP select RP */ - -5, /* (210) expr ::= expr in_op LP select RP */ - -5, /* (211) expr ::= expr in_op nm dbnm paren_exprlist */ - -4, /* (212) expr ::= EXISTS LP select RP */ - -5, /* (213) expr ::= CASE case_operand case_exprlist case_else END */ - -5, /* (214) case_exprlist ::= case_exprlist WHEN expr THEN expr */ - -4, /* (215) case_exprlist ::= WHEN expr THEN expr */ - -2, /* (216) case_else ::= ELSE expr */ - 0, /* (217) case_else ::= */ - -1, /* (218) case_operand ::= expr */ - 0, /* (219) case_operand ::= */ - 0, /* (220) exprlist ::= */ - -3, /* (221) nexprlist ::= nexprlist COMMA expr */ - -1, /* (222) nexprlist ::= expr */ - 0, /* (223) paren_exprlist ::= */ - -3, /* (224) paren_exprlist ::= LP exprlist RP */ - -12, /* (225) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ - -1, /* (226) uniqueflag ::= UNIQUE */ - 0, /* (227) uniqueflag ::= */ - 0, /* (228) eidlist_opt ::= */ - -3, /* (229) eidlist_opt ::= LP eidlist RP */ - -5, /* (230) eidlist ::= eidlist COMMA nm collate sortorder */ - -3, /* (231) eidlist ::= nm collate sortorder */ - 0, /* (232) collate ::= */ - -2, /* (233) collate ::= COLLATE ID|STRING */ - -4, /* (234) cmd ::= DROP INDEX ifexists fullname */ - -2, /* (235) cmd ::= VACUUM vinto */ - -3, /* (236) cmd ::= VACUUM nm vinto */ - -2, /* (237) vinto ::= INTO expr */ - 0, /* (238) vinto ::= */ - -3, /* (239) cmd ::= PRAGMA nm dbnm */ - -5, /* (240) cmd ::= PRAGMA nm dbnm EQ nmnum */ - -6, /* (241) cmd ::= PRAGMA nm dbnm LP nmnum RP */ - -5, /* (242) cmd ::= PRAGMA nm dbnm EQ minus_num */ - -6, /* (243) cmd ::= PRAGMA nm dbnm LP minus_num RP */ - -2, /* (244) plus_num ::= PLUS INTEGER|FLOAT */ - -2, /* (245) minus_num ::= MINUS INTEGER|FLOAT */ - -5, /* (246) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ - -11, /* (247) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ - -1, /* (248) trigger_time ::= BEFORE|AFTER */ - -2, /* (249) trigger_time ::= INSTEAD OF */ - 0, /* (250) trigger_time ::= */ - -1, /* (251) trigger_event ::= DELETE|INSERT */ - -1, /* (252) trigger_event ::= UPDATE */ - -3, /* (253) trigger_event ::= UPDATE OF idlist */ - 0, /* (254) when_clause ::= */ - -2, /* (255) when_clause ::= WHEN expr */ - -3, /* (256) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ - -2, /* (257) trigger_cmd_list ::= trigger_cmd SEMI */ - -3, /* (258) trnm ::= nm DOT nm */ - -3, /* (259) tridxby ::= INDEXED BY nm */ - -2, /* (260) tridxby ::= NOT INDEXED */ - -9, /* (261) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ - -8, /* (262) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ - -6, /* (263) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ - -3, /* (264) trigger_cmd ::= scanpt select scanpt */ - -4, /* (265) expr ::= RAISE LP IGNORE RP */ - -6, /* (266) expr ::= RAISE LP raisetype COMMA nm RP */ - -1, /* (267) raisetype ::= ROLLBACK */ - -1, /* (268) raisetype ::= ABORT */ - -1, /* (269) raisetype ::= FAIL */ - -4, /* (270) cmd ::= DROP TRIGGER ifexists fullname */ - -6, /* (271) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ - -3, /* (272) cmd ::= DETACH database_kw_opt expr */ - 0, /* (273) key_opt ::= */ - -2, /* (274) key_opt ::= KEY expr */ - -1, /* (275) cmd ::= REINDEX */ - -3, /* (276) cmd ::= REINDEX nm dbnm */ - -1, /* (277) cmd ::= ANALYZE */ - -3, /* (278) cmd ::= ANALYZE nm dbnm */ - -6, /* (279) cmd ::= ALTER TABLE fullname RENAME TO nm */ - -7, /* (280) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ - -1, /* (281) add_column_fullname ::= fullname */ - -8, /* (282) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ - -1, /* (283) cmd ::= create_vtab */ - -4, /* (284) cmd ::= create_vtab LP vtabarglist RP */ - -8, /* (285) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ - 0, /* (286) vtabarg ::= */ - -1, /* (287) vtabargtoken ::= ANY */ - -3, /* (288) vtabargtoken ::= lp anylist RP */ - -1, /* (289) lp ::= LP */ - -2, /* (290) with ::= WITH wqlist */ - -3, /* (291) with ::= WITH RECURSIVE wqlist */ - -6, /* (292) wqlist ::= nm eidlist_opt AS LP select RP */ - -8, /* (293) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */ - -1, /* (294) windowdefn_list ::= windowdefn */ - -3, /* (295) windowdefn_list ::= windowdefn_list COMMA windowdefn */ - -5, /* (296) windowdefn ::= nm AS LP window RP */ - -5, /* (297) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ - -6, /* (298) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ - -4, /* (299) window ::= ORDER BY sortlist frame_opt */ - -5, /* (300) window ::= nm ORDER BY sortlist frame_opt */ - -1, /* (301) window ::= frame_opt */ - -2, /* (302) window ::= nm frame_opt */ - 0, /* (303) frame_opt ::= */ - -3, /* (304) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ - -6, /* (305) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ - -1, /* (306) range_or_rows ::= RANGE|ROWS|GROUPS */ - -1, /* (307) frame_bound_s ::= frame_bound */ - -2, /* (308) frame_bound_s ::= UNBOUNDED PRECEDING */ - -1, /* (309) frame_bound_e ::= frame_bound */ - -2, /* (310) frame_bound_e ::= UNBOUNDED FOLLOWING */ - -2, /* (311) frame_bound ::= expr PRECEDING|FOLLOWING */ - -2, /* (312) frame_bound ::= CURRENT ROW */ - 0, /* (313) frame_exclude_opt ::= */ - -2, /* (314) frame_exclude_opt ::= EXCLUDE frame_exclude */ - -2, /* (315) frame_exclude ::= NO OTHERS */ - -2, /* (316) frame_exclude ::= CURRENT ROW */ - -1, /* (317) frame_exclude ::= GROUP|TIES */ - -2, /* (318) window_clause ::= WINDOW windowdefn_list */ - -2, /* (319) filter_over ::= filter_clause over_clause */ - -1, /* (320) filter_over ::= over_clause */ - -1, /* (321) filter_over ::= filter_clause */ - -4, /* (322) over_clause ::= OVER LP window RP */ - -2, /* (323) over_clause ::= OVER nm */ - -5, /* (324) filter_clause ::= FILTER LP WHERE expr RP */ - -1, /* (325) input ::= cmdlist */ - -2, /* (326) cmdlist ::= cmdlist ecmd */ - -1, /* (327) cmdlist ::= ecmd */ - -1, /* (328) ecmd ::= SEMI */ - -2, /* (329) ecmd ::= cmdx SEMI */ - -3, /* (330) ecmd ::= explain cmdx SEMI */ - 0, /* (331) trans_opt ::= */ - -1, /* (332) trans_opt ::= TRANSACTION */ - -2, /* (333) trans_opt ::= TRANSACTION nm */ - -1, /* (334) savepoint_opt ::= SAVEPOINT */ - 0, /* (335) savepoint_opt ::= */ - -2, /* (336) cmd ::= create_table create_table_args */ - -4, /* (337) columnlist ::= columnlist COMMA columnname carglist */ - -2, /* (338) columnlist ::= columnname carglist */ - -1, /* (339) nm ::= ID|INDEXED */ - -1, /* (340) nm ::= STRING */ - -1, /* (341) nm ::= JOIN_KW */ - -1, /* (342) typetoken ::= typename */ - -1, /* (343) typename ::= ID|STRING */ - -1, /* (344) signed ::= plus_num */ - -1, /* (345) signed ::= minus_num */ - -2, /* (346) carglist ::= carglist ccons */ - 0, /* (347) carglist ::= */ - -2, /* (348) ccons ::= NULL onconf */ - -4, /* (349) ccons ::= GENERATED ALWAYS AS generated */ - -2, /* (350) ccons ::= AS generated */ - -2, /* (351) conslist_opt ::= COMMA conslist */ - -3, /* (352) conslist ::= conslist tconscomma tcons */ - -1, /* (353) conslist ::= tcons */ - 0, /* (354) tconscomma ::= */ - -1, /* (355) defer_subclause_opt ::= defer_subclause */ - -1, /* (356) resolvetype ::= raisetype */ - -1, /* (357) selectnowith ::= oneselect */ - -1, /* (358) oneselect ::= values */ - -2, /* (359) sclp ::= selcollist COMMA */ - -1, /* (360) as ::= ID|STRING */ - -1, /* (361) expr ::= term */ - -1, /* (362) likeop ::= LIKE_KW|MATCH */ - -1, /* (363) exprlist ::= nexprlist */ - -1, /* (364) nmnum ::= plus_num */ - -1, /* (365) nmnum ::= nm */ - -1, /* (366) nmnum ::= ON */ - -1, /* (367) nmnum ::= DELETE */ - -1, /* (368) nmnum ::= DEFAULT */ - -1, /* (369) plus_num ::= INTEGER|FLOAT */ - 0, /* (370) foreach_clause ::= */ - -3, /* (371) foreach_clause ::= FOR EACH ROW */ - -1, /* (372) trnm ::= nm */ - 0, /* (373) tridxby ::= */ - -1, /* (374) database_kw_opt ::= DATABASE */ - 0, /* (375) database_kw_opt ::= */ - 0, /* (376) kwcolumn_opt ::= */ - -1, /* (377) kwcolumn_opt ::= COLUMNKW */ - -1, /* (378) vtabarglist ::= vtabarg */ - -3, /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */ - -2, /* (380) vtabarg ::= vtabarg vtabargtoken */ - 0, /* (381) anylist ::= */ - -4, /* (382) anylist ::= anylist LP anylist RP */ - -2, /* (383) anylist ::= anylist ANY */ - 0, /* (384) with ::= */ + 0, /* (21) table_option_set ::= */ + -3, /* (22) table_option_set ::= table_option_set COMMA table_option */ + -2, /* (23) table_option ::= WITHOUT nm */ + -1, /* (24) table_option ::= nm */ + -2, /* (25) columnname ::= nm typetoken */ + 0, /* (26) typetoken ::= */ + -4, /* (27) typetoken ::= typename LP signed RP */ + -6, /* (28) typetoken ::= typename LP signed COMMA signed RP */ + -2, /* (29) typename ::= typename ID|STRING */ + 0, /* (30) scanpt ::= */ + 0, /* (31) scantok ::= */ + -2, /* (32) ccons ::= CONSTRAINT nm */ + -3, /* (33) ccons ::= DEFAULT scantok term */ + -4, /* (34) ccons ::= DEFAULT LP expr RP */ + -4, /* (35) ccons ::= DEFAULT PLUS scantok term */ + -4, /* (36) ccons ::= DEFAULT MINUS scantok term */ + -3, /* (37) ccons ::= DEFAULT scantok ID|INDEXED */ + -3, /* (38) ccons ::= NOT NULL onconf */ + -5, /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */ + -2, /* (40) ccons ::= UNIQUE onconf */ + -4, /* (41) ccons ::= CHECK LP expr RP */ + -4, /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */ + -1, /* (43) ccons ::= defer_subclause */ + -2, /* (44) ccons ::= COLLATE ID|STRING */ + -3, /* (45) generated ::= LP expr RP */ + -4, /* (46) generated ::= LP expr RP ID */ + 0, /* (47) autoinc ::= */ + -1, /* (48) autoinc ::= AUTOINCR */ + 0, /* (49) refargs ::= */ + -2, /* (50) refargs ::= refargs refarg */ + -2, /* (51) refarg ::= MATCH nm */ + -3, /* (52) refarg ::= ON INSERT refact */ + -3, /* (53) refarg ::= ON DELETE refact */ + -3, /* (54) refarg ::= ON UPDATE refact */ + -2, /* (55) refact ::= SET NULL */ + -2, /* (56) refact ::= SET DEFAULT */ + -1, /* (57) refact ::= CASCADE */ + -1, /* (58) refact ::= RESTRICT */ + -2, /* (59) refact ::= NO ACTION */ + -3, /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ + -2, /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + 0, /* (62) init_deferred_pred_opt ::= */ + -2, /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */ + -2, /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ + 0, /* (65) conslist_opt ::= */ + -1, /* (66) tconscomma ::= COMMA */ + -2, /* (67) tcons ::= CONSTRAINT nm */ + -7, /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ + -5, /* (69) tcons ::= UNIQUE LP sortlist RP onconf */ + -5, /* (70) tcons ::= CHECK LP expr RP onconf */ + -10, /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ + 0, /* (72) defer_subclause_opt ::= */ + 0, /* (73) onconf ::= */ + -3, /* (74) onconf ::= ON CONFLICT resolvetype */ + 0, /* (75) orconf ::= */ + -2, /* (76) orconf ::= OR resolvetype */ + -1, /* (77) resolvetype ::= IGNORE */ + -1, /* (78) resolvetype ::= REPLACE */ + -4, /* (79) cmd ::= DROP TABLE ifexists fullname */ + -2, /* (80) ifexists ::= IF EXISTS */ + 0, /* (81) ifexists ::= */ + -9, /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ + -4, /* (83) cmd ::= DROP VIEW ifexists fullname */ + -1, /* (84) cmd ::= select */ + -3, /* (85) select ::= WITH wqlist selectnowith */ + -4, /* (86) select ::= WITH RECURSIVE wqlist selectnowith */ + -1, /* (87) select ::= selectnowith */ + -3, /* (88) selectnowith ::= selectnowith multiselect_op oneselect */ + -1, /* (89) multiselect_op ::= UNION */ + -2, /* (90) multiselect_op ::= UNION ALL */ + -1, /* (91) multiselect_op ::= EXCEPT|INTERSECT */ + -9, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ + -10, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ + -4, /* (94) values ::= VALUES LP nexprlist RP */ + -5, /* (95) values ::= values COMMA LP nexprlist RP */ + -1, /* (96) distinct ::= DISTINCT */ + -1, /* (97) distinct ::= ALL */ + 0, /* (98) distinct ::= */ + 0, /* (99) sclp ::= */ + -5, /* (100) selcollist ::= sclp scanpt expr scanpt as */ + -3, /* (101) selcollist ::= sclp scanpt STAR */ + -5, /* (102) selcollist ::= sclp scanpt nm DOT STAR */ + -2, /* (103) as ::= AS nm */ + 0, /* (104) as ::= */ + 0, /* (105) from ::= */ + -2, /* (106) from ::= FROM seltablist */ + -2, /* (107) stl_prefix ::= seltablist joinop */ + 0, /* (108) stl_prefix ::= */ + -7, /* (109) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ + -9, /* (110) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ + -7, /* (111) seltablist ::= stl_prefix LP select RP as on_opt using_opt */ + -7, /* (112) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ + 0, /* (113) dbnm ::= */ + -2, /* (114) dbnm ::= DOT nm */ + -1, /* (115) fullname ::= nm */ + -3, /* (116) fullname ::= nm DOT nm */ + -1, /* (117) xfullname ::= nm */ + -3, /* (118) xfullname ::= nm DOT nm */ + -5, /* (119) xfullname ::= nm DOT nm AS nm */ + -3, /* (120) xfullname ::= nm AS nm */ + -1, /* (121) joinop ::= COMMA|JOIN */ + -2, /* (122) joinop ::= JOIN_KW JOIN */ + -3, /* (123) joinop ::= JOIN_KW nm JOIN */ + -4, /* (124) joinop ::= JOIN_KW nm nm JOIN */ + -2, /* (125) on_opt ::= ON expr */ + 0, /* (126) on_opt ::= */ + 0, /* (127) indexed_opt ::= */ + -3, /* (128) indexed_opt ::= INDEXED BY nm */ + -2, /* (129) indexed_opt ::= NOT INDEXED */ + -4, /* (130) using_opt ::= USING LP idlist RP */ + 0, /* (131) using_opt ::= */ + 0, /* (132) orderby_opt ::= */ + -3, /* (133) orderby_opt ::= ORDER BY sortlist */ + -5, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */ + -3, /* (135) sortlist ::= expr sortorder nulls */ + -1, /* (136) sortorder ::= ASC */ + -1, /* (137) sortorder ::= DESC */ + 0, /* (138) sortorder ::= */ + -2, /* (139) nulls ::= NULLS FIRST */ + -2, /* (140) nulls ::= NULLS LAST */ + 0, /* (141) nulls ::= */ + 0, /* (142) groupby_opt ::= */ + -3, /* (143) groupby_opt ::= GROUP BY nexprlist */ + 0, /* (144) having_opt ::= */ + -2, /* (145) having_opt ::= HAVING expr */ + 0, /* (146) limit_opt ::= */ + -2, /* (147) limit_opt ::= LIMIT expr */ + -4, /* (148) limit_opt ::= LIMIT expr OFFSET expr */ + -4, /* (149) limit_opt ::= LIMIT expr COMMA expr */ + -6, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ + 0, /* (151) where_opt ::= */ + -2, /* (152) where_opt ::= WHERE expr */ + 0, /* (153) where_opt_ret ::= */ + -2, /* (154) where_opt_ret ::= WHERE expr */ + -2, /* (155) where_opt_ret ::= RETURNING selcollist */ + -4, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */ + -9, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ + -5, /* (158) setlist ::= setlist COMMA nm EQ expr */ + -7, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */ + -3, /* (160) setlist ::= nm EQ expr */ + -5, /* (161) setlist ::= LP idlist RP EQ expr */ + -7, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ + -8, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ + 0, /* (164) upsert ::= */ + -2, /* (165) upsert ::= RETURNING selcollist */ + -12, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ + -9, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ + -5, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */ + -8, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ + -2, /* (170) returning ::= RETURNING selcollist */ + -2, /* (171) insert_cmd ::= INSERT orconf */ + -1, /* (172) insert_cmd ::= REPLACE */ + 0, /* (173) idlist_opt ::= */ + -3, /* (174) idlist_opt ::= LP idlist RP */ + -3, /* (175) idlist ::= idlist COMMA nm */ + -1, /* (176) idlist ::= nm */ + -3, /* (177) expr ::= LP expr RP */ + -1, /* (178) expr ::= ID|INDEXED */ + -1, /* (179) expr ::= JOIN_KW */ + -3, /* (180) expr ::= nm DOT nm */ + -5, /* (181) expr ::= nm DOT nm DOT nm */ + -1, /* (182) term ::= NULL|FLOAT|BLOB */ + -1, /* (183) term ::= STRING */ + -1, /* (184) term ::= INTEGER */ + -1, /* (185) expr ::= VARIABLE */ + -3, /* (186) expr ::= expr COLLATE ID|STRING */ + -6, /* (187) expr ::= CAST LP expr AS typetoken RP */ + -5, /* (188) expr ::= ID|INDEXED LP distinct exprlist RP */ + -4, /* (189) expr ::= ID|INDEXED LP STAR RP */ + -6, /* (190) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ + -5, /* (191) expr ::= ID|INDEXED LP STAR RP filter_over */ + -1, /* (192) term ::= CTIME_KW */ + -5, /* (193) expr ::= LP nexprlist COMMA expr RP */ + -3, /* (194) expr ::= expr AND expr */ + -3, /* (195) expr ::= expr OR expr */ + -3, /* (196) expr ::= expr LT|GT|GE|LE expr */ + -3, /* (197) expr ::= expr EQ|NE expr */ + -3, /* (198) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ + -3, /* (199) expr ::= expr PLUS|MINUS expr */ + -3, /* (200) expr ::= expr STAR|SLASH|REM expr */ + -3, /* (201) expr ::= expr CONCAT expr */ + -2, /* (202) likeop ::= NOT LIKE_KW|MATCH */ + -3, /* (203) expr ::= expr likeop expr */ + -5, /* (204) expr ::= expr likeop expr ESCAPE expr */ + -2, /* (205) expr ::= expr ISNULL|NOTNULL */ + -3, /* (206) expr ::= expr NOT NULL */ + -3, /* (207) expr ::= expr IS expr */ + -4, /* (208) expr ::= expr IS NOT expr */ + -2, /* (209) expr ::= NOT expr */ + -2, /* (210) expr ::= BITNOT expr */ + -2, /* (211) expr ::= PLUS|MINUS expr */ + -1, /* (212) between_op ::= BETWEEN */ + -2, /* (213) between_op ::= NOT BETWEEN */ + -5, /* (214) expr ::= expr between_op expr AND expr */ + -1, /* (215) in_op ::= IN */ + -2, /* (216) in_op ::= NOT IN */ + -5, /* (217) expr ::= expr in_op LP exprlist RP */ + -3, /* (218) expr ::= LP select RP */ + -5, /* (219) expr ::= expr in_op LP select RP */ + -5, /* (220) expr ::= expr in_op nm dbnm paren_exprlist */ + -4, /* (221) expr ::= EXISTS LP select RP */ + -5, /* (222) expr ::= CASE case_operand case_exprlist case_else END */ + -5, /* (223) case_exprlist ::= case_exprlist WHEN expr THEN expr */ + -4, /* (224) case_exprlist ::= WHEN expr THEN expr */ + -2, /* (225) case_else ::= ELSE expr */ + 0, /* (226) case_else ::= */ + -1, /* (227) case_operand ::= expr */ + 0, /* (228) case_operand ::= */ + 0, /* (229) exprlist ::= */ + -3, /* (230) nexprlist ::= nexprlist COMMA expr */ + -1, /* (231) nexprlist ::= expr */ + 0, /* (232) paren_exprlist ::= */ + -3, /* (233) paren_exprlist ::= LP exprlist RP */ + -12, /* (234) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ + -1, /* (235) uniqueflag ::= UNIQUE */ + 0, /* (236) uniqueflag ::= */ + 0, /* (237) eidlist_opt ::= */ + -3, /* (238) eidlist_opt ::= LP eidlist RP */ + -5, /* (239) eidlist ::= eidlist COMMA nm collate sortorder */ + -3, /* (240) eidlist ::= nm collate sortorder */ + 0, /* (241) collate ::= */ + -2, /* (242) collate ::= COLLATE ID|STRING */ + -4, /* (243) cmd ::= DROP INDEX ifexists fullname */ + -2, /* (244) cmd ::= VACUUM vinto */ + -3, /* (245) cmd ::= VACUUM nm vinto */ + -2, /* (246) vinto ::= INTO expr */ + 0, /* (247) vinto ::= */ + -3, /* (248) cmd ::= PRAGMA nm dbnm */ + -5, /* (249) cmd ::= PRAGMA nm dbnm EQ nmnum */ + -6, /* (250) cmd ::= PRAGMA nm dbnm LP nmnum RP */ + -5, /* (251) cmd ::= PRAGMA nm dbnm EQ minus_num */ + -6, /* (252) cmd ::= PRAGMA nm dbnm LP minus_num RP */ + -2, /* (253) plus_num ::= PLUS INTEGER|FLOAT */ + -2, /* (254) minus_num ::= MINUS INTEGER|FLOAT */ + -5, /* (255) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ + -11, /* (256) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ + -1, /* (257) trigger_time ::= BEFORE|AFTER */ + -2, /* (258) trigger_time ::= INSTEAD OF */ + 0, /* (259) trigger_time ::= */ + -1, /* (260) trigger_event ::= DELETE|INSERT */ + -1, /* (261) trigger_event ::= UPDATE */ + -3, /* (262) trigger_event ::= UPDATE OF idlist */ + 0, /* (263) when_clause ::= */ + -2, /* (264) when_clause ::= WHEN expr */ + -3, /* (265) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ + -2, /* (266) trigger_cmd_list ::= trigger_cmd SEMI */ + -3, /* (267) trnm ::= nm DOT nm */ + -3, /* (268) tridxby ::= INDEXED BY nm */ + -2, /* (269) tridxby ::= NOT INDEXED */ + -9, /* (270) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ + -8, /* (271) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ + -6, /* (272) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ + -3, /* (273) trigger_cmd ::= scanpt select scanpt */ + -4, /* (274) expr ::= RAISE LP IGNORE RP */ + -6, /* (275) expr ::= RAISE LP raisetype COMMA nm RP */ + -1, /* (276) raisetype ::= ROLLBACK */ + -1, /* (277) raisetype ::= ABORT */ + -1, /* (278) raisetype ::= FAIL */ + -4, /* (279) cmd ::= DROP TRIGGER ifexists fullname */ + -6, /* (280) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ + -3, /* (281) cmd ::= DETACH database_kw_opt expr */ + 0, /* (282) key_opt ::= */ + -2, /* (283) key_opt ::= KEY expr */ + -1, /* (284) cmd ::= REINDEX */ + -3, /* (285) cmd ::= REINDEX nm dbnm */ + -1, /* (286) cmd ::= ANALYZE */ + -3, /* (287) cmd ::= ANALYZE nm dbnm */ + -6, /* (288) cmd ::= ALTER TABLE fullname RENAME TO nm */ + -7, /* (289) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ + -6, /* (290) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ + -1, /* (291) add_column_fullname ::= fullname */ + -8, /* (292) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ + -1, /* (293) cmd ::= create_vtab */ + -4, /* (294) cmd ::= create_vtab LP vtabarglist RP */ + -8, /* (295) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ + 0, /* (296) vtabarg ::= */ + -1, /* (297) vtabargtoken ::= ANY */ + -3, /* (298) vtabargtoken ::= lp anylist RP */ + -1, /* (299) lp ::= LP */ + -2, /* (300) with ::= WITH wqlist */ + -3, /* (301) with ::= WITH RECURSIVE wqlist */ + -1, /* (302) wqas ::= AS */ + -2, /* (303) wqas ::= AS MATERIALIZED */ + -3, /* (304) wqas ::= AS NOT MATERIALIZED */ + -6, /* (305) wqitem ::= nm eidlist_opt wqas LP select RP */ + -1, /* (306) wqlist ::= wqitem */ + -3, /* (307) wqlist ::= wqlist COMMA wqitem */ + -1, /* (308) windowdefn_list ::= windowdefn */ + -3, /* (309) windowdefn_list ::= windowdefn_list COMMA windowdefn */ + -5, /* (310) windowdefn ::= nm AS LP window RP */ + -5, /* (311) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ + -6, /* (312) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ + -4, /* (313) window ::= ORDER BY sortlist frame_opt */ + -5, /* (314) window ::= nm ORDER BY sortlist frame_opt */ + -1, /* (315) window ::= frame_opt */ + -2, /* (316) window ::= nm frame_opt */ + 0, /* (317) frame_opt ::= */ + -3, /* (318) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ + -6, /* (319) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ + -1, /* (320) range_or_rows ::= RANGE|ROWS|GROUPS */ + -1, /* (321) frame_bound_s ::= frame_bound */ + -2, /* (322) frame_bound_s ::= UNBOUNDED PRECEDING */ + -1, /* (323) frame_bound_e ::= frame_bound */ + -2, /* (324) frame_bound_e ::= UNBOUNDED FOLLOWING */ + -2, /* (325) frame_bound ::= expr PRECEDING|FOLLOWING */ + -2, /* (326) frame_bound ::= CURRENT ROW */ + 0, /* (327) frame_exclude_opt ::= */ + -2, /* (328) frame_exclude_opt ::= EXCLUDE frame_exclude */ + -2, /* (329) frame_exclude ::= NO OTHERS */ + -2, /* (330) frame_exclude ::= CURRENT ROW */ + -1, /* (331) frame_exclude ::= GROUP|TIES */ + -2, /* (332) window_clause ::= WINDOW windowdefn_list */ + -2, /* (333) filter_over ::= filter_clause over_clause */ + -1, /* (334) filter_over ::= over_clause */ + -1, /* (335) filter_over ::= filter_clause */ + -4, /* (336) over_clause ::= OVER LP window RP */ + -2, /* (337) over_clause ::= OVER nm */ + -5, /* (338) filter_clause ::= FILTER LP WHERE expr RP */ + -1, /* (339) input ::= cmdlist */ + -2, /* (340) cmdlist ::= cmdlist ecmd */ + -1, /* (341) cmdlist ::= ecmd */ + -1, /* (342) ecmd ::= SEMI */ + -2, /* (343) ecmd ::= cmdx SEMI */ + -3, /* (344) ecmd ::= explain cmdx SEMI */ + 0, /* (345) trans_opt ::= */ + -1, /* (346) trans_opt ::= TRANSACTION */ + -2, /* (347) trans_opt ::= TRANSACTION nm */ + -1, /* (348) savepoint_opt ::= SAVEPOINT */ + 0, /* (349) savepoint_opt ::= */ + -2, /* (350) cmd ::= create_table create_table_args */ + -1, /* (351) table_option_set ::= table_option */ + -4, /* (352) columnlist ::= columnlist COMMA columnname carglist */ + -2, /* (353) columnlist ::= columnname carglist */ + -1, /* (354) nm ::= ID|INDEXED */ + -1, /* (355) nm ::= STRING */ + -1, /* (356) nm ::= JOIN_KW */ + -1, /* (357) typetoken ::= typename */ + -1, /* (358) typename ::= ID|STRING */ + -1, /* (359) signed ::= plus_num */ + -1, /* (360) signed ::= minus_num */ + -2, /* (361) carglist ::= carglist ccons */ + 0, /* (362) carglist ::= */ + -2, /* (363) ccons ::= NULL onconf */ + -4, /* (364) ccons ::= GENERATED ALWAYS AS generated */ + -2, /* (365) ccons ::= AS generated */ + -2, /* (366) conslist_opt ::= COMMA conslist */ + -3, /* (367) conslist ::= conslist tconscomma tcons */ + -1, /* (368) conslist ::= tcons */ + 0, /* (369) tconscomma ::= */ + -1, /* (370) defer_subclause_opt ::= defer_subclause */ + -1, /* (371) resolvetype ::= raisetype */ + -1, /* (372) selectnowith ::= oneselect */ + -1, /* (373) oneselect ::= values */ + -2, /* (374) sclp ::= selcollist COMMA */ + -1, /* (375) as ::= ID|STRING */ + 0, /* (376) returning ::= */ + -1, /* (377) expr ::= term */ + -1, /* (378) likeop ::= LIKE_KW|MATCH */ + -1, /* (379) exprlist ::= nexprlist */ + -1, /* (380) nmnum ::= plus_num */ + -1, /* (381) nmnum ::= nm */ + -1, /* (382) nmnum ::= ON */ + -1, /* (383) nmnum ::= DELETE */ + -1, /* (384) nmnum ::= DEFAULT */ + -1, /* (385) plus_num ::= INTEGER|FLOAT */ + 0, /* (386) foreach_clause ::= */ + -3, /* (387) foreach_clause ::= FOR EACH ROW */ + -1, /* (388) trnm ::= nm */ + 0, /* (389) tridxby ::= */ + -1, /* (390) database_kw_opt ::= DATABASE */ + 0, /* (391) database_kw_opt ::= */ + 0, /* (392) kwcolumn_opt ::= */ + -1, /* (393) kwcolumn_opt ::= COLUMNKW */ + -1, /* (394) vtabarglist ::= vtabarg */ + -3, /* (395) vtabarglist ::= vtabarglist COMMA vtabarg */ + -2, /* (396) vtabarg ::= vtabarg vtabargtoken */ + 0, /* (397) anylist ::= */ + -4, /* (398) anylist ::= anylist LP anylist RP */ + -2, /* (399) anylist ::= anylist ANY */ + 0, /* (400) with ::= */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -158281,55 +162981,6 @@ static YYACTIONTYPE yy_reduce( (void)yyLookahead; (void)yyLookaheadToken; yymsp = yypParser->yytos; - assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ); -#ifndef NDEBUG - if( yyTraceFILE ){ - yysize = yyRuleInfoNRhs[yyruleno]; - if( yysize ){ - fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", - yyTracePrompt, - yyruleno, yyRuleName[yyruleno], - yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ - yypParser->yyhwm++; - assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack)); - } -#endif -#if YYSTACKDEPTH>0 - if( yypParser->yytos>=yypParser->yystackEnd ){ - yyStackOverflow(yypParser); - /* The call to yyStackOverflow() above pops the stack until it is - ** empty, causing the main parser loop to exit. So the return value - ** is never used and does not matter. */ - return 0; - } -#else - if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ - if( yyGrowStack(yypParser) ){ - yyStackOverflow(yypParser); - /* The call to yyStackOverflow() above pops the stack until it is - ** empty, causing the main parser loop to exit. So the return value - ** is never used and does not matter. */ - return 0; - } - yymsp = yypParser->yytos; - } -#endif - } switch( yyruleno ){ /* Beginning here are the reduction cases. A typical example @@ -158352,16 +163003,16 @@ static YYACTIONTYPE yy_reduce( { sqlite3FinishCoding(pParse); } break; case 3: /* cmd ::= BEGIN transtype trans_opt */ -{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy192);} +{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy64);} break; case 4: /* transtype ::= */ -{yymsp[1].minor.yy192 = TK_DEFERRED;} +{yymsp[1].minor.yy64 = TK_DEFERRED;} break; case 5: /* transtype ::= DEFERRED */ case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6); case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7); - case 306: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==306); -{yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-X*/} + case 320: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==320); +{yymsp[0].minor.yy64 = yymsp[0].major; /*A-overwrites-X*/} break; case 8: /* cmd ::= COMMIT|END trans_opt */ case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9); @@ -158384,7 +163035,7 @@ static YYACTIONTYPE yy_reduce( break; case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */ { - sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy192,0,0,yymsp[-2].minor.yy192); + sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy64,0,0,yymsp[-2].minor.yy64); } break; case 14: /* createkw ::= CREATE */ @@ -158392,96 +163043,112 @@ static YYACTIONTYPE yy_reduce( break; case 15: /* ifnotexists ::= */ case 18: /* temp ::= */ yytestcase(yyruleno==18); - case 21: /* table_options ::= */ yytestcase(yyruleno==21); - case 45: /* autoinc ::= */ yytestcase(yyruleno==45); - case 60: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==60); - case 70: /* defer_subclause_opt ::= */ yytestcase(yyruleno==70); - case 79: /* ifexists ::= */ yytestcase(yyruleno==79); - case 96: /* distinct ::= */ yytestcase(yyruleno==96); - case 232: /* collate ::= */ yytestcase(yyruleno==232); -{yymsp[1].minor.yy192 = 0;} + case 47: /* autoinc ::= */ yytestcase(yyruleno==47); + case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62); + case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72); + case 81: /* ifexists ::= */ yytestcase(yyruleno==81); + case 98: /* distinct ::= */ yytestcase(yyruleno==98); + case 241: /* collate ::= */ yytestcase(yyruleno==241); +{yymsp[1].minor.yy64 = 0;} break; case 16: /* ifnotexists ::= IF NOT EXISTS */ -{yymsp[-2].minor.yy192 = 1;} +{yymsp[-2].minor.yy64 = 1;} break; case 17: /* temp ::= TEMP */ - case 46: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==46); -{yymsp[0].minor.yy192 = 1;} +{yymsp[0].minor.yy64 = pParse->db->init.busy==0;} break; - case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_options */ + case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */ { - sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy192,0); + sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy51,0); } break; case 20: /* create_table_args ::= AS select */ { - sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy539); - sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy539); + sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy303); + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy303); } break; - case 22: /* table_options ::= WITHOUT nm */ + case 21: /* table_option_set ::= */ +{yymsp[1].minor.yy51 = 0;} + break; + case 22: /* table_option_set ::= table_option_set COMMA table_option */ +{yylhsminor.yy51 = yymsp[-2].minor.yy51|yymsp[0].minor.yy51;} + yymsp[-2].minor.yy51 = yylhsminor.yy51; + break; + case 23: /* table_option ::= WITHOUT nm */ { if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){ - yymsp[-1].minor.yy192 = TF_WithoutRowid | TF_NoVisibleRowid; + yymsp[-1].minor.yy51 = TF_WithoutRowid | TF_NoVisibleRowid; + }else{ + yymsp[-1].minor.yy51 = 0; + sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); + } +} + break; + case 24: /* table_option ::= nm */ +{ + if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){ + yylhsminor.yy51 = TF_Strict; }else{ - yymsp[-1].minor.yy192 = 0; + yylhsminor.yy51 = 0; sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); } } + yymsp[0].minor.yy51 = yylhsminor.yy51; break; - case 23: /* columnname ::= nm typetoken */ -{sqlite3AddColumn(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);} + case 25: /* columnname ::= nm typetoken */ +{sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);} break; - case 24: /* typetoken ::= */ - case 63: /* conslist_opt ::= */ yytestcase(yyruleno==63); - case 102: /* as ::= */ yytestcase(yyruleno==102); + case 26: /* typetoken ::= */ + case 65: /* conslist_opt ::= */ yytestcase(yyruleno==65); + case 104: /* as ::= */ yytestcase(yyruleno==104); {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;} break; - case 25: /* typetoken ::= typename LP signed RP */ + case 27: /* typetoken ::= typename LP signed RP */ { yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z); } break; - case 26: /* typetoken ::= typename LP signed COMMA signed RP */ + case 28: /* typetoken ::= typename LP signed COMMA signed RP */ { yymsp[-5].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z); } break; - case 27: /* typename ::= typename ID|STRING */ + case 29: /* typename ::= typename ID|STRING */ {yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);} break; - case 28: /* scanpt ::= */ + case 30: /* scanpt ::= */ { assert( yyLookahead!=YYNOCODE ); - yymsp[1].minor.yy436 = yyLookaheadToken.z; + yymsp[1].minor.yy600 = yyLookaheadToken.z; } break; - case 29: /* scantok ::= */ + case 31: /* scantok ::= */ { assert( yyLookahead!=YYNOCODE ); yymsp[1].minor.yy0 = yyLookaheadToken; } break; - case 30: /* ccons ::= CONSTRAINT nm */ - case 65: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==65); + case 32: /* ccons ::= CONSTRAINT nm */ + case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67); {pParse->constraintName = yymsp[0].minor.yy0;} break; - case 31: /* ccons ::= DEFAULT scantok term */ -{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy202,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} + case 33: /* ccons ::= DEFAULT scantok term */ +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy626,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} break; - case 32: /* ccons ::= DEFAULT LP expr RP */ -{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy202,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);} + case 34: /* ccons ::= DEFAULT LP expr RP */ +{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy626,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);} break; - case 33: /* ccons ::= DEFAULT PLUS scantok term */ -{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy202,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} + case 35: /* ccons ::= DEFAULT PLUS scantok term */ +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy626,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} break; - case 34: /* ccons ::= DEFAULT MINUS scantok term */ + case 36: /* ccons ::= DEFAULT MINUS scantok term */ { - Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy202, 0); + Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy626, 0); sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]); } break; - case 35: /* ccons ::= DEFAULT scantok ID|INDEXED */ + case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */ { Expr *p = tokenExpr(pParse, TK_STRING, yymsp[0].minor.yy0); if( p ){ @@ -158491,177 +163158,162 @@ static YYACTIONTYPE yy_reduce( sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n); } break; - case 36: /* ccons ::= NOT NULL onconf */ -{sqlite3AddNotNull(pParse, yymsp[0].minor.yy192);} + case 38: /* ccons ::= NOT NULL onconf */ +{sqlite3AddNotNull(pParse, yymsp[0].minor.yy64);} break; - case 37: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */ -{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy192,yymsp[0].minor.yy192,yymsp[-2].minor.yy192);} + case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */ +{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy64,yymsp[0].minor.yy64,yymsp[-2].minor.yy64);} break; - case 38: /* ccons ::= UNIQUE onconf */ -{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy192,0,0,0,0, + case 40: /* ccons ::= UNIQUE onconf */ +{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy64,0,0,0,0, SQLITE_IDXTYPE_UNIQUE);} break; - case 39: /* ccons ::= CHECK LP expr RP */ -{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy202,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);} + case 41: /* ccons ::= CHECK LP expr RP */ +{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy626,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);} break; - case 40: /* ccons ::= REFERENCES nm eidlist_opt refargs */ -{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy242,yymsp[0].minor.yy192);} + case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */ +{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy562,yymsp[0].minor.yy64);} break; - case 41: /* ccons ::= defer_subclause */ -{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy192);} + case 43: /* ccons ::= defer_subclause */ +{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy64);} break; - case 42: /* ccons ::= COLLATE ID|STRING */ + case 44: /* ccons ::= COLLATE ID|STRING */ {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);} break; - case 43: /* generated ::= LP expr RP */ -{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy202,0);} + case 45: /* generated ::= LP expr RP */ +{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy626,0);} + break; + case 46: /* generated ::= LP expr RP ID */ +{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy626,&yymsp[0].minor.yy0);} break; - case 44: /* generated ::= LP expr RP ID */ -{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy202,&yymsp[0].minor.yy0);} + case 48: /* autoinc ::= AUTOINCR */ +{yymsp[0].minor.yy64 = 1;} break; - case 47: /* refargs ::= */ -{ yymsp[1].minor.yy192 = OE_None*0x0101; /* EV: R-19803-45884 */} + case 49: /* refargs ::= */ +{ yymsp[1].minor.yy64 = OE_None*0x0101; /* EV: R-19803-45884 */} break; - case 48: /* refargs ::= refargs refarg */ -{ yymsp[-1].minor.yy192 = (yymsp[-1].minor.yy192 & ~yymsp[0].minor.yy207.mask) | yymsp[0].minor.yy207.value; } + case 50: /* refargs ::= refargs refarg */ +{ yymsp[-1].minor.yy64 = (yymsp[-1].minor.yy64 & ~yymsp[0].minor.yy83.mask) | yymsp[0].minor.yy83.value; } break; - case 49: /* refarg ::= MATCH nm */ -{ yymsp[-1].minor.yy207.value = 0; yymsp[-1].minor.yy207.mask = 0x000000; } + case 51: /* refarg ::= MATCH nm */ +{ yymsp[-1].minor.yy83.value = 0; yymsp[-1].minor.yy83.mask = 0x000000; } break; - case 50: /* refarg ::= ON INSERT refact */ -{ yymsp[-2].minor.yy207.value = 0; yymsp[-2].minor.yy207.mask = 0x000000; } + case 52: /* refarg ::= ON INSERT refact */ +{ yymsp[-2].minor.yy83.value = 0; yymsp[-2].minor.yy83.mask = 0x000000; } break; - case 51: /* refarg ::= ON DELETE refact */ -{ yymsp[-2].minor.yy207.value = yymsp[0].minor.yy192; yymsp[-2].minor.yy207.mask = 0x0000ff; } + case 53: /* refarg ::= ON DELETE refact */ +{ yymsp[-2].minor.yy83.value = yymsp[0].minor.yy64; yymsp[-2].minor.yy83.mask = 0x0000ff; } break; - case 52: /* refarg ::= ON UPDATE refact */ -{ yymsp[-2].minor.yy207.value = yymsp[0].minor.yy192<<8; yymsp[-2].minor.yy207.mask = 0x00ff00; } + case 54: /* refarg ::= ON UPDATE refact */ +{ yymsp[-2].minor.yy83.value = yymsp[0].minor.yy64<<8; yymsp[-2].minor.yy83.mask = 0x00ff00; } break; - case 53: /* refact ::= SET NULL */ -{ yymsp[-1].minor.yy192 = OE_SetNull; /* EV: R-33326-45252 */} + case 55: /* refact ::= SET NULL */ +{ yymsp[-1].minor.yy64 = OE_SetNull; /* EV: R-33326-45252 */} break; - case 54: /* refact ::= SET DEFAULT */ -{ yymsp[-1].minor.yy192 = OE_SetDflt; /* EV: R-33326-45252 */} + case 56: /* refact ::= SET DEFAULT */ +{ yymsp[-1].minor.yy64 = OE_SetDflt; /* EV: R-33326-45252 */} break; - case 55: /* refact ::= CASCADE */ -{ yymsp[0].minor.yy192 = OE_Cascade; /* EV: R-33326-45252 */} + case 57: /* refact ::= CASCADE */ +{ yymsp[0].minor.yy64 = OE_Cascade; /* EV: R-33326-45252 */} break; - case 56: /* refact ::= RESTRICT */ -{ yymsp[0].minor.yy192 = OE_Restrict; /* EV: R-33326-45252 */} + case 58: /* refact ::= RESTRICT */ +{ yymsp[0].minor.yy64 = OE_Restrict; /* EV: R-33326-45252 */} break; - case 57: /* refact ::= NO ACTION */ -{ yymsp[-1].minor.yy192 = OE_None; /* EV: R-33326-45252 */} + case 59: /* refact ::= NO ACTION */ +{ yymsp[-1].minor.yy64 = OE_None; /* EV: R-33326-45252 */} break; - case 58: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ -{yymsp[-2].minor.yy192 = 0;} + case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ +{yymsp[-2].minor.yy64 = 0;} break; - case 59: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ - case 74: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==74); - case 162: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==162); -{yymsp[-1].minor.yy192 = yymsp[0].minor.yy192;} + case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76); + case 171: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==171); +{yymsp[-1].minor.yy64 = yymsp[0].minor.yy64;} break; - case 61: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ - case 78: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==78); - case 204: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==204); - case 207: /* in_op ::= NOT IN */ yytestcase(yyruleno==207); - case 233: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==233); -{yymsp[-1].minor.yy192 = 1;} + case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ + case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80); + case 213: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==213); + case 216: /* in_op ::= NOT IN */ yytestcase(yyruleno==216); + case 242: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==242); +{yymsp[-1].minor.yy64 = 1;} break; - case 62: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ -{yymsp[-1].minor.yy192 = 0;} + case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ +{yymsp[-1].minor.yy64 = 0;} break; - case 64: /* tconscomma ::= COMMA */ + case 66: /* tconscomma ::= COMMA */ {pParse->constraintName.n = 0;} break; - case 66: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ -{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy242,yymsp[0].minor.yy192,yymsp[-2].minor.yy192,0);} + case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ +{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy562,yymsp[0].minor.yy64,yymsp[-2].minor.yy64,0);} break; - case 67: /* tcons ::= UNIQUE LP sortlist RP onconf */ -{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy242,yymsp[0].minor.yy192,0,0,0,0, + case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */ +{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy562,yymsp[0].minor.yy64,0,0,0,0, SQLITE_IDXTYPE_UNIQUE);} break; - case 68: /* tcons ::= CHECK LP expr RP onconf */ -{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy202,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);} + case 70: /* tcons ::= CHECK LP expr RP onconf */ +{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy626,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);} break; - case 69: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ + case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ { - sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy242, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy242, yymsp[-1].minor.yy192); - sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy192); + sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy562, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy562, yymsp[-1].minor.yy64); + sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy64); } break; - case 71: /* onconf ::= */ - case 73: /* orconf ::= */ yytestcase(yyruleno==73); -{yymsp[1].minor.yy192 = OE_Default;} + case 73: /* onconf ::= */ + case 75: /* orconf ::= */ yytestcase(yyruleno==75); +{yymsp[1].minor.yy64 = OE_Default;} break; - case 72: /* onconf ::= ON CONFLICT resolvetype */ -{yymsp[-2].minor.yy192 = yymsp[0].minor.yy192;} + case 74: /* onconf ::= ON CONFLICT resolvetype */ +{yymsp[-2].minor.yy64 = yymsp[0].minor.yy64;} break; - case 75: /* resolvetype ::= IGNORE */ -{yymsp[0].minor.yy192 = OE_Ignore;} + case 77: /* resolvetype ::= IGNORE */ +{yymsp[0].minor.yy64 = OE_Ignore;} break; - case 76: /* resolvetype ::= REPLACE */ - case 163: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==163); -{yymsp[0].minor.yy192 = OE_Replace;} + case 78: /* resolvetype ::= REPLACE */ + case 172: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==172); +{yymsp[0].minor.yy64 = OE_Replace;} break; - case 77: /* cmd ::= DROP TABLE ifexists fullname */ + case 79: /* cmd ::= DROP TABLE ifexists fullname */ { - sqlite3DropTable(pParse, yymsp[0].minor.yy47, 0, yymsp[-1].minor.yy192); + sqlite3DropTable(pParse, yymsp[0].minor.yy607, 0, yymsp[-1].minor.yy64); } break; - case 80: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ + case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ { - sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy242, yymsp[0].minor.yy539, yymsp[-7].minor.yy192, yymsp[-5].minor.yy192); + sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy562, yymsp[0].minor.yy303, yymsp[-7].minor.yy64, yymsp[-5].minor.yy64); } break; - case 81: /* cmd ::= DROP VIEW ifexists fullname */ + case 83: /* cmd ::= DROP VIEW ifexists fullname */ { - sqlite3DropTable(pParse, yymsp[0].minor.yy47, 1, yymsp[-1].minor.yy192); + sqlite3DropTable(pParse, yymsp[0].minor.yy607, 1, yymsp[-1].minor.yy64); } break; - case 82: /* cmd ::= select */ + case 84: /* cmd ::= select */ { SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0}; - sqlite3Select(pParse, yymsp[0].minor.yy539, &dest); - sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy539); + sqlite3Select(pParse, yymsp[0].minor.yy303, &dest); + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy303); } break; - case 83: /* select ::= WITH wqlist selectnowith */ -{ - Select *p = yymsp[0].minor.yy539; - if( p ){ - p->pWith = yymsp[-1].minor.yy131; - parserDoubleLinkSelect(pParse, p); - }else{ - sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy131); - } - yymsp[-2].minor.yy539 = p; -} + case 85: /* select ::= WITH wqlist selectnowith */ +{yymsp[-2].minor.yy303 = attachWithToSelect(pParse,yymsp[0].minor.yy303,yymsp[-1].minor.yy43);} break; - case 84: /* select ::= WITH RECURSIVE wqlist selectnowith */ -{ - Select *p = yymsp[0].minor.yy539; - if( p ){ - p->pWith = yymsp[-1].minor.yy131; - parserDoubleLinkSelect(pParse, p); - }else{ - sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy131); - } - yymsp[-3].minor.yy539 = p; -} + case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */ +{yymsp[-3].minor.yy303 = attachWithToSelect(pParse,yymsp[0].minor.yy303,yymsp[-1].minor.yy43);} break; - case 85: /* select ::= selectnowith */ + case 87: /* select ::= selectnowith */ { - Select *p = yymsp[0].minor.yy539; + Select *p = yymsp[0].minor.yy303; if( p ){ parserDoubleLinkSelect(pParse, p); } - yymsp[0].minor.yy539 = p; /*A-overwrites-X*/ + yymsp[0].minor.yy303 = p; /*A-overwrites-X*/ } break; - case 86: /* selectnowith ::= selectnowith multiselect_op oneselect */ + case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */ { - Select *pRhs = yymsp[0].minor.yy539; - Select *pLhs = yymsp[-2].minor.yy539; + Select *pRhs = yymsp[0].minor.yy303; + Select *pLhs = yymsp[-2].minor.yy303; if( pRhs && pRhs->pPrior ){ SrcList *pFrom; Token x; @@ -158671,140 +163323,140 @@ static YYACTIONTYPE yy_reduce( pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0); } if( pRhs ){ - pRhs->op = (u8)yymsp[-1].minor.yy192; + pRhs->op = (u8)yymsp[-1].minor.yy64; pRhs->pPrior = pLhs; if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue; pRhs->selFlags &= ~SF_MultiValue; - if( yymsp[-1].minor.yy192!=TK_ALL ) pParse->hasCompound = 1; + if( yymsp[-1].minor.yy64!=TK_ALL ) pParse->hasCompound = 1; }else{ sqlite3SelectDelete(pParse->db, pLhs); } - yymsp[-2].minor.yy539 = pRhs; + yymsp[-2].minor.yy303 = pRhs; } break; - case 87: /* multiselect_op ::= UNION */ - case 89: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==89); -{yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-OP*/} + case 89: /* multiselect_op ::= UNION */ + case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91); +{yymsp[0].minor.yy64 = yymsp[0].major; /*A-overwrites-OP*/} break; - case 88: /* multiselect_op ::= UNION ALL */ -{yymsp[-1].minor.yy192 = TK_ALL;} + case 90: /* multiselect_op ::= UNION ALL */ +{yymsp[-1].minor.yy64 = TK_ALL;} break; - case 90: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ + case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ { - yymsp[-8].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy242,yymsp[-5].minor.yy47,yymsp[-4].minor.yy202,yymsp[-3].minor.yy242,yymsp[-2].minor.yy202,yymsp[-1].minor.yy242,yymsp[-7].minor.yy192,yymsp[0].minor.yy202); + yymsp[-8].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy562,yymsp[-5].minor.yy607,yymsp[-4].minor.yy626,yymsp[-3].minor.yy562,yymsp[-2].minor.yy626,yymsp[-1].minor.yy562,yymsp[-7].minor.yy64,yymsp[0].minor.yy626); } break; - case 91: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ + case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ { - yymsp[-9].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy242,yymsp[-6].minor.yy47,yymsp[-5].minor.yy202,yymsp[-4].minor.yy242,yymsp[-3].minor.yy202,yymsp[-1].minor.yy242,yymsp[-8].minor.yy192,yymsp[0].minor.yy202); - if( yymsp[-9].minor.yy539 ){ - yymsp[-9].minor.yy539->pWinDefn = yymsp[-2].minor.yy303; + yymsp[-9].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy562,yymsp[-6].minor.yy607,yymsp[-5].minor.yy626,yymsp[-4].minor.yy562,yymsp[-3].minor.yy626,yymsp[-1].minor.yy562,yymsp[-8].minor.yy64,yymsp[0].minor.yy626); + if( yymsp[-9].minor.yy303 ){ + yymsp[-9].minor.yy303->pWinDefn = yymsp[-2].minor.yy375; }else{ - sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy303); + sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy375); } } break; - case 92: /* values ::= VALUES LP nexprlist RP */ + case 94: /* values ::= VALUES LP nexprlist RP */ { - yymsp[-3].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy242,0,0,0,0,0,SF_Values,0); + yymsp[-3].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy562,0,0,0,0,0,SF_Values,0); } break; - case 93: /* values ::= values COMMA LP nexprlist RP */ + case 95: /* values ::= values COMMA LP nexprlist RP */ { - Select *pRight, *pLeft = yymsp[-4].minor.yy539; - pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy242,0,0,0,0,0,SF_Values|SF_MultiValue,0); + Select *pRight, *pLeft = yymsp[-4].minor.yy303; + pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy562,0,0,0,0,0,SF_Values|SF_MultiValue,0); if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue; if( pRight ){ pRight->op = TK_ALL; pRight->pPrior = pLeft; - yymsp[-4].minor.yy539 = pRight; + yymsp[-4].minor.yy303 = pRight; }else{ - yymsp[-4].minor.yy539 = pLeft; + yymsp[-4].minor.yy303 = pLeft; } } break; - case 94: /* distinct ::= DISTINCT */ -{yymsp[0].minor.yy192 = SF_Distinct;} + case 96: /* distinct ::= DISTINCT */ +{yymsp[0].minor.yy64 = SF_Distinct;} break; - case 95: /* distinct ::= ALL */ -{yymsp[0].minor.yy192 = SF_All;} + case 97: /* distinct ::= ALL */ +{yymsp[0].minor.yy64 = SF_All;} break; - case 97: /* sclp ::= */ - case 130: /* orderby_opt ::= */ yytestcase(yyruleno==130); - case 140: /* groupby_opt ::= */ yytestcase(yyruleno==140); - case 220: /* exprlist ::= */ yytestcase(yyruleno==220); - case 223: /* paren_exprlist ::= */ yytestcase(yyruleno==223); - case 228: /* eidlist_opt ::= */ yytestcase(yyruleno==228); -{yymsp[1].minor.yy242 = 0;} + case 99: /* sclp ::= */ + case 132: /* orderby_opt ::= */ yytestcase(yyruleno==132); + case 142: /* groupby_opt ::= */ yytestcase(yyruleno==142); + case 229: /* exprlist ::= */ yytestcase(yyruleno==229); + case 232: /* paren_exprlist ::= */ yytestcase(yyruleno==232); + case 237: /* eidlist_opt ::= */ yytestcase(yyruleno==237); +{yymsp[1].minor.yy562 = 0;} break; - case 98: /* selcollist ::= sclp scanpt expr scanpt as */ + case 100: /* selcollist ::= sclp scanpt expr scanpt as */ { - yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy242, yymsp[-2].minor.yy202); - if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy242, &yymsp[0].minor.yy0, 1); - sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy242,yymsp[-3].minor.yy436,yymsp[-1].minor.yy436); + yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy562, yymsp[-2].minor.yy626); + if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy562, &yymsp[0].minor.yy0, 1); + sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy562,yymsp[-3].minor.yy600,yymsp[-1].minor.yy600); } break; - case 99: /* selcollist ::= sclp scanpt STAR */ + case 101: /* selcollist ::= sclp scanpt STAR */ { Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0); - yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy242, p); + yymsp[-2].minor.yy562 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy562, p); } break; - case 100: /* selcollist ::= sclp scanpt nm DOT STAR */ + case 102: /* selcollist ::= sclp scanpt nm DOT STAR */ { Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0); Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1); Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); - yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, pDot); + yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562, pDot); } break; - case 101: /* as ::= AS nm */ - case 112: /* dbnm ::= DOT nm */ yytestcase(yyruleno==112); - case 244: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==244); - case 245: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==245); + case 103: /* as ::= AS nm */ + case 114: /* dbnm ::= DOT nm */ yytestcase(yyruleno==114); + case 253: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==253); + case 254: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==254); {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;} break; - case 103: /* from ::= */ - case 106: /* stl_prefix ::= */ yytestcase(yyruleno==106); -{yymsp[1].minor.yy47 = 0;} + case 105: /* from ::= */ + case 108: /* stl_prefix ::= */ yytestcase(yyruleno==108); +{yymsp[1].minor.yy607 = 0;} break; - case 104: /* from ::= FROM seltablist */ + case 106: /* from ::= FROM seltablist */ { - yymsp[-1].minor.yy47 = yymsp[0].minor.yy47; - sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy47); + yymsp[-1].minor.yy607 = yymsp[0].minor.yy607; + sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy607); } break; - case 105: /* stl_prefix ::= seltablist joinop */ + case 107: /* stl_prefix ::= seltablist joinop */ { - if( ALWAYS(yymsp[-1].minor.yy47 && yymsp[-1].minor.yy47->nSrc>0) ) yymsp[-1].minor.yy47->a[yymsp[-1].minor.yy47->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy192; + if( ALWAYS(yymsp[-1].minor.yy607 && yymsp[-1].minor.yy607->nSrc>0) ) yymsp[-1].minor.yy607->a[yymsp[-1].minor.yy607->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy64; } break; - case 107: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ + case 109: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ { - yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); - sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy47, &yymsp[-2].minor.yy0); + yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); + sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy607, &yymsp[-2].minor.yy0); } break; - case 108: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ + case 110: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ { - yymsp[-8].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy47,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); - sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy47, yymsp[-4].minor.yy242); + yymsp[-8].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy607,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); + sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy607, yymsp[-4].minor.yy562); } break; - case 109: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */ + case 111: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */ { - yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy539,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); + yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy303,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); } break; - case 110: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ + case 112: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ { - if( yymsp[-6].minor.yy47==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy202==0 && yymsp[0].minor.yy600==0 ){ - yymsp[-6].minor.yy47 = yymsp[-4].minor.yy47; - }else if( yymsp[-4].minor.yy47->nSrc==1 ){ - yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); - if( yymsp[-6].minor.yy47 ){ - struct SrcList_item *pNew = &yymsp[-6].minor.yy47->a[yymsp[-6].minor.yy47->nSrc-1]; - struct SrcList_item *pOld = yymsp[-4].minor.yy47->a; + if( yymsp[-6].minor.yy607==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy626==0 && yymsp[0].minor.yy240==0 ){ + yymsp[-6].minor.yy607 = yymsp[-4].minor.yy607; + }else if( yymsp[-4].minor.yy607->nSrc==1 ){ + yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); + if( yymsp[-6].minor.yy607 ){ + SrcItem *pNew = &yymsp[-6].minor.yy607->a[yymsp[-6].minor.yy607->nSrc-1]; + SrcItem *pOld = yymsp[-4].minor.yy607->a; pNew->zName = pOld->zName; pNew->zDatabase = pOld->zDatabase; pNew->pSelect = pOld->pSelect; @@ -158817,209 +163469,226 @@ static YYACTIONTYPE yy_reduce( pOld->zName = pOld->zDatabase = 0; pOld->pSelect = 0; } - sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy47); + sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy607); }else{ Select *pSubquery; - sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy47); - pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy47,0,0,0,0,SF_NestedFrom,0); - yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); + sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy607); + pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy607,0,0,0,0,SF_NestedFrom,0); + yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); } } break; - case 111: /* dbnm ::= */ - case 125: /* indexed_opt ::= */ yytestcase(yyruleno==125); + case 113: /* dbnm ::= */ + case 127: /* indexed_opt ::= */ yytestcase(yyruleno==127); {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;} break; - case 113: /* fullname ::= nm */ + case 115: /* fullname ::= nm */ { - yylhsminor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); - if( IN_RENAME_OBJECT && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.yy0); + yylhsminor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); + if( IN_RENAME_OBJECT && yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy47 = yylhsminor.yy47; + yymsp[0].minor.yy607 = yylhsminor.yy607; break; - case 114: /* fullname ::= nm DOT nm */ + case 116: /* fullname ::= nm DOT nm */ { - yylhsminor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); - if( IN_RENAME_OBJECT && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.yy0); + yylhsminor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); + if( IN_RENAME_OBJECT && yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy47 = yylhsminor.yy47; + yymsp[-2].minor.yy607 = yylhsminor.yy607; break; - case 115: /* xfullname ::= nm */ -{yymsp[0].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/} + case 117: /* xfullname ::= nm */ +{yymsp[0].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/} break; - case 116: /* xfullname ::= nm DOT nm */ -{yymsp[-2].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/} + case 118: /* xfullname ::= nm DOT nm */ +{yymsp[-2].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/} break; - case 117: /* xfullname ::= nm DOT nm AS nm */ + case 119: /* xfullname ::= nm DOT nm AS nm */ { - yymsp[-4].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/ - if( yymsp[-4].minor.yy47 ) yymsp[-4].minor.yy47->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); + yymsp[-4].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/ + if( yymsp[-4].minor.yy607 ) yymsp[-4].minor.yy607->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); } break; - case 118: /* xfullname ::= nm AS nm */ + case 120: /* xfullname ::= nm AS nm */ { - yymsp[-2].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/ - if( yymsp[-2].minor.yy47 ) yymsp[-2].minor.yy47->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); + yymsp[-2].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/ + if( yymsp[-2].minor.yy607 ) yymsp[-2].minor.yy607->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); } break; - case 119: /* joinop ::= COMMA|JOIN */ -{ yymsp[0].minor.yy192 = JT_INNER; } + case 121: /* joinop ::= COMMA|JOIN */ +{ yymsp[0].minor.yy64 = JT_INNER; } break; - case 120: /* joinop ::= JOIN_KW JOIN */ -{yymsp[-1].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/} + case 122: /* joinop ::= JOIN_KW JOIN */ +{yymsp[-1].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/} break; - case 121: /* joinop ::= JOIN_KW nm JOIN */ -{yymsp[-2].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/} + case 123: /* joinop ::= JOIN_KW nm JOIN */ +{yymsp[-2].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/} break; - case 122: /* joinop ::= JOIN_KW nm nm JOIN */ -{yymsp[-3].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/} + case 124: /* joinop ::= JOIN_KW nm nm JOIN */ +{yymsp[-3].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/} break; - case 123: /* on_opt ::= ON expr */ - case 143: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==143); - case 150: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==150); - case 216: /* case_else ::= ELSE expr */ yytestcase(yyruleno==216); - case 237: /* vinto ::= INTO expr */ yytestcase(yyruleno==237); -{yymsp[-1].minor.yy202 = yymsp[0].minor.yy202;} + case 125: /* on_opt ::= ON expr */ + case 145: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==145); + case 152: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==152); + case 154: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==154); + case 225: /* case_else ::= ELSE expr */ yytestcase(yyruleno==225); + case 246: /* vinto ::= INTO expr */ yytestcase(yyruleno==246); +{yymsp[-1].minor.yy626 = yymsp[0].minor.yy626;} break; - case 124: /* on_opt ::= */ - case 142: /* having_opt ::= */ yytestcase(yyruleno==142); - case 144: /* limit_opt ::= */ yytestcase(yyruleno==144); - case 149: /* where_opt ::= */ yytestcase(yyruleno==149); - case 217: /* case_else ::= */ yytestcase(yyruleno==217); - case 219: /* case_operand ::= */ yytestcase(yyruleno==219); - case 238: /* vinto ::= */ yytestcase(yyruleno==238); -{yymsp[1].minor.yy202 = 0;} + case 126: /* on_opt ::= */ + case 144: /* having_opt ::= */ yytestcase(yyruleno==144); + case 146: /* limit_opt ::= */ yytestcase(yyruleno==146); + case 151: /* where_opt ::= */ yytestcase(yyruleno==151); + case 153: /* where_opt_ret ::= */ yytestcase(yyruleno==153); + case 226: /* case_else ::= */ yytestcase(yyruleno==226); + case 228: /* case_operand ::= */ yytestcase(yyruleno==228); + case 247: /* vinto ::= */ yytestcase(yyruleno==247); +{yymsp[1].minor.yy626 = 0;} break; - case 126: /* indexed_opt ::= INDEXED BY nm */ + case 128: /* indexed_opt ::= INDEXED BY nm */ {yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;} break; - case 127: /* indexed_opt ::= NOT INDEXED */ + case 129: /* indexed_opt ::= NOT INDEXED */ {yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;} break; - case 128: /* using_opt ::= USING LP idlist RP */ -{yymsp[-3].minor.yy600 = yymsp[-1].minor.yy600;} + case 130: /* using_opt ::= USING LP idlist RP */ +{yymsp[-3].minor.yy240 = yymsp[-1].minor.yy240;} break; - case 129: /* using_opt ::= */ - case 164: /* idlist_opt ::= */ yytestcase(yyruleno==164); -{yymsp[1].minor.yy600 = 0;} + case 131: /* using_opt ::= */ + case 173: /* idlist_opt ::= */ yytestcase(yyruleno==173); +{yymsp[1].minor.yy240 = 0;} break; - case 131: /* orderby_opt ::= ORDER BY sortlist */ - case 141: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==141); -{yymsp[-2].minor.yy242 = yymsp[0].minor.yy242;} + case 133: /* orderby_opt ::= ORDER BY sortlist */ + case 143: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==143); +{yymsp[-2].minor.yy562 = yymsp[0].minor.yy562;} break; - case 132: /* sortlist ::= sortlist COMMA expr sortorder nulls */ + case 134: /* sortlist ::= sortlist COMMA expr sortorder nulls */ { - yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242,yymsp[-2].minor.yy202); - sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy242,yymsp[-1].minor.yy192,yymsp[0].minor.yy192); + yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562,yymsp[-2].minor.yy626); + sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy562,yymsp[-1].minor.yy64,yymsp[0].minor.yy64); } break; - case 133: /* sortlist ::= expr sortorder nulls */ + case 135: /* sortlist ::= expr sortorder nulls */ { - yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy202); /*A-overwrites-Y*/ - sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy242,yymsp[-1].minor.yy192,yymsp[0].minor.yy192); + yymsp[-2].minor.yy562 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy626); /*A-overwrites-Y*/ + sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy562,yymsp[-1].minor.yy64,yymsp[0].minor.yy64); } break; - case 134: /* sortorder ::= ASC */ -{yymsp[0].minor.yy192 = SQLITE_SO_ASC;} + case 136: /* sortorder ::= ASC */ +{yymsp[0].minor.yy64 = SQLITE_SO_ASC;} break; - case 135: /* sortorder ::= DESC */ -{yymsp[0].minor.yy192 = SQLITE_SO_DESC;} + case 137: /* sortorder ::= DESC */ +{yymsp[0].minor.yy64 = SQLITE_SO_DESC;} break; - case 136: /* sortorder ::= */ - case 139: /* nulls ::= */ yytestcase(yyruleno==139); -{yymsp[1].minor.yy192 = SQLITE_SO_UNDEFINED;} + case 138: /* sortorder ::= */ + case 141: /* nulls ::= */ yytestcase(yyruleno==141); +{yymsp[1].minor.yy64 = SQLITE_SO_UNDEFINED;} break; - case 137: /* nulls ::= NULLS FIRST */ -{yymsp[-1].minor.yy192 = SQLITE_SO_ASC;} + case 139: /* nulls ::= NULLS FIRST */ +{yymsp[-1].minor.yy64 = SQLITE_SO_ASC;} break; - case 138: /* nulls ::= NULLS LAST */ -{yymsp[-1].minor.yy192 = SQLITE_SO_DESC;} + case 140: /* nulls ::= NULLS LAST */ +{yymsp[-1].minor.yy64 = SQLITE_SO_DESC;} break; - case 145: /* limit_opt ::= LIMIT expr */ -{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy202,0);} + case 147: /* limit_opt ::= LIMIT expr */ +{yymsp[-1].minor.yy626 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy626,0);} break; - case 146: /* limit_opt ::= LIMIT expr OFFSET expr */ -{yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);} + case 148: /* limit_opt ::= LIMIT expr OFFSET expr */ +{yymsp[-3].minor.yy626 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);} break; - case 147: /* limit_opt ::= LIMIT expr COMMA expr */ -{yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy202,yymsp[-2].minor.yy202);} + case 149: /* limit_opt ::= LIMIT expr COMMA expr */ +{yymsp[-3].minor.yy626 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy626,yymsp[-2].minor.yy626);} break; - case 148: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt */ + case 150: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ { - sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy47, &yymsp[-1].minor.yy0); - sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy47,yymsp[0].minor.yy202,0,0); + sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy607, &yymsp[-1].minor.yy0); + sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy607,yymsp[0].minor.yy626,0,0); } break; - case 151: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */ + case 155: /* where_opt_ret ::= RETURNING selcollist */ +{sqlite3AddReturning(pParse,yymsp[0].minor.yy562); yymsp[-1].minor.yy626 = 0;} + break; + case 156: /* where_opt_ret ::= WHERE expr RETURNING selcollist */ +{sqlite3AddReturning(pParse,yymsp[0].minor.yy562); yymsp[-3].minor.yy626 = yymsp[-2].minor.yy626;} + break; + case 157: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ { - sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy47, &yymsp[-4].minor.yy0); - sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy242,"set list"); - yymsp[-5].minor.yy47 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy47, yymsp[-1].minor.yy47); - sqlite3Update(pParse,yymsp[-5].minor.yy47,yymsp[-2].minor.yy242,yymsp[0].minor.yy202,yymsp[-6].minor.yy192,0,0,0); + sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy607, &yymsp[-4].minor.yy0); + sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy562,"set list"); + yymsp[-5].minor.yy607 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy607, yymsp[-1].minor.yy607); + sqlite3Update(pParse,yymsp[-5].minor.yy607,yymsp[-2].minor.yy562,yymsp[0].minor.yy626,yymsp[-6].minor.yy64,0,0,0); } break; - case 152: /* setlist ::= setlist COMMA nm EQ expr */ + case 158: /* setlist ::= setlist COMMA nm EQ expr */ { - yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy242, yymsp[0].minor.yy202); - sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy242, &yymsp[-2].minor.yy0, 1); + yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy562, yymsp[0].minor.yy626); + sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy562, &yymsp[-2].minor.yy0, 1); } break; - case 153: /* setlist ::= setlist COMMA LP idlist RP EQ expr */ + case 159: /* setlist ::= setlist COMMA LP idlist RP EQ expr */ { - yymsp[-6].minor.yy242 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy242, yymsp[-3].minor.yy600, yymsp[0].minor.yy202); + yymsp[-6].minor.yy562 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy562, yymsp[-3].minor.yy240, yymsp[0].minor.yy626); } break; - case 154: /* setlist ::= nm EQ expr */ + case 160: /* setlist ::= nm EQ expr */ { - yylhsminor.yy242 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy202); - sqlite3ExprListSetName(pParse, yylhsminor.yy242, &yymsp[-2].minor.yy0, 1); + yylhsminor.yy562 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy626); + sqlite3ExprListSetName(pParse, yylhsminor.yy562, &yymsp[-2].minor.yy0, 1); } - yymsp[-2].minor.yy242 = yylhsminor.yy242; + yymsp[-2].minor.yy562 = yylhsminor.yy562; break; - case 155: /* setlist ::= LP idlist RP EQ expr */ + case 161: /* setlist ::= LP idlist RP EQ expr */ { - yymsp[-4].minor.yy242 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy600, yymsp[0].minor.yy202); + yymsp[-4].minor.yy562 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy240, yymsp[0].minor.yy626); } break; - case 156: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ + case 162: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ { - sqlite3Insert(pParse, yymsp[-3].minor.yy47, yymsp[-1].minor.yy539, yymsp[-2].minor.yy600, yymsp[-5].minor.yy192, yymsp[0].minor.yy318); + sqlite3Insert(pParse, yymsp[-3].minor.yy607, yymsp[-1].minor.yy303, yymsp[-2].minor.yy240, yymsp[-5].minor.yy64, yymsp[0].minor.yy138); } break; - case 157: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */ + case 163: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ { - sqlite3Insert(pParse, yymsp[-3].minor.yy47, 0, yymsp[-2].minor.yy600, yymsp[-5].minor.yy192, 0); + sqlite3Insert(pParse, yymsp[-4].minor.yy607, 0, yymsp[-3].minor.yy240, yymsp[-6].minor.yy64, 0); } break; - case 158: /* upsert ::= */ -{ yymsp[1].minor.yy318 = 0; } + case 164: /* upsert ::= */ +{ yymsp[1].minor.yy138 = 0; } + break; + case 165: /* upsert ::= RETURNING selcollist */ +{ yymsp[-1].minor.yy138 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy562); } + break; + case 166: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ +{ yymsp[-11].minor.yy138 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy562,yymsp[-6].minor.yy626,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626,yymsp[0].minor.yy138);} break; - case 159: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */ -{ yymsp[-10].minor.yy318 = sqlite3UpsertNew(pParse->db,yymsp[-7].minor.yy242,yymsp[-5].minor.yy202,yymsp[-1].minor.yy242,yymsp[0].minor.yy202);} + case 167: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ +{ yymsp[-8].minor.yy138 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy562,yymsp[-3].minor.yy626,0,0,yymsp[0].minor.yy138); } break; - case 160: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */ -{ yymsp[-7].minor.yy318 = sqlite3UpsertNew(pParse->db,yymsp[-4].minor.yy242,yymsp[-2].minor.yy202,0,0); } + case 168: /* upsert ::= ON CONFLICT DO NOTHING returning */ +{ yymsp[-4].minor.yy138 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); } break; - case 161: /* upsert ::= ON CONFLICT DO NOTHING */ -{ yymsp[-3].minor.yy318 = sqlite3UpsertNew(pParse->db,0,0,0,0); } + case 169: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ +{ yymsp[-7].minor.yy138 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626,0);} break; - case 165: /* idlist_opt ::= LP idlist RP */ -{yymsp[-2].minor.yy600 = yymsp[-1].minor.yy600;} + case 170: /* returning ::= RETURNING selcollist */ +{sqlite3AddReturning(pParse,yymsp[0].minor.yy562);} break; - case 166: /* idlist ::= idlist COMMA nm */ -{yymsp[-2].minor.yy600 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy600,&yymsp[0].minor.yy0);} + case 174: /* idlist_opt ::= LP idlist RP */ +{yymsp[-2].minor.yy240 = yymsp[-1].minor.yy240;} break; - case 167: /* idlist ::= nm */ -{yymsp[0].minor.yy600 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/} + case 175: /* idlist ::= idlist COMMA nm */ +{yymsp[-2].minor.yy240 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy240,&yymsp[0].minor.yy0);} break; - case 168: /* expr ::= LP expr RP */ -{yymsp[-2].minor.yy202 = yymsp[-1].minor.yy202;} + case 176: /* idlist ::= nm */ +{yymsp[0].minor.yy240 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/} break; - case 169: /* expr ::= ID|INDEXED */ - case 170: /* expr ::= JOIN_KW */ yytestcase(yyruleno==170); -{yymsp[0].minor.yy202=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/} + case 177: /* expr ::= LP expr RP */ +{yymsp[-2].minor.yy626 = yymsp[-1].minor.yy626;} break; - case 171: /* expr ::= nm DOT nm */ + case 178: /* expr ::= ID|INDEXED */ + case 179: /* expr ::= JOIN_KW */ yytestcase(yyruleno==179); +{yymsp[0].minor.yy626=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/} + break; + case 180: /* expr ::= nm DOT nm */ { Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1); Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1); @@ -159027,11 +163696,11 @@ static YYACTIONTYPE yy_reduce( sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0); sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0); } - yylhsminor.yy202 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); + yylhsminor.yy626 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); } - yymsp[-2].minor.yy202 = yylhsminor.yy202; + yymsp[-2].minor.yy626 = yylhsminor.yy626; break; - case 172: /* expr ::= nm DOT nm DOT nm */ + case 181: /* expr ::= nm DOT nm DOT nm */ { Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-4].minor.yy0, 1); Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1); @@ -159041,26 +163710,26 @@ static YYACTIONTYPE yy_reduce( sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0); sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0); } - yylhsminor.yy202 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); + yylhsminor.yy626 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); } - yymsp[-4].minor.yy202 = yylhsminor.yy202; + yymsp[-4].minor.yy626 = yylhsminor.yy626; break; - case 173: /* term ::= NULL|FLOAT|BLOB */ - case 174: /* term ::= STRING */ yytestcase(yyruleno==174); -{yymsp[0].minor.yy202=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/} + case 182: /* term ::= NULL|FLOAT|BLOB */ + case 183: /* term ::= STRING */ yytestcase(yyruleno==183); +{yymsp[0].minor.yy626=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/} break; - case 175: /* term ::= INTEGER */ + case 184: /* term ::= INTEGER */ { - yylhsminor.yy202 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1); + yylhsminor.yy626 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1); } - yymsp[0].minor.yy202 = yylhsminor.yy202; + yymsp[0].minor.yy626 = yylhsminor.yy626; break; - case 176: /* expr ::= VARIABLE */ + case 185: /* expr ::= VARIABLE */ { if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){ u32 n = yymsp[0].minor.yy0.n; - yymsp[0].minor.yy202 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0); - sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy202, n); + yymsp[0].minor.yy626 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0); + sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy626, n); }else{ /* When doing a nested parse, one can include terms in an expression ** that look like this: #1 #2 ... These terms refer to registers @@ -159069,159 +163738,159 @@ static YYACTIONTYPE yy_reduce( assert( t.n>=2 ); if( pParse->nested==0 ){ sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t); - yymsp[0].minor.yy202 = 0; + yymsp[0].minor.yy626 = 0; }else{ - yymsp[0].minor.yy202 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); - if( yymsp[0].minor.yy202 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy202->iTable); + yymsp[0].minor.yy626 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); + if( yymsp[0].minor.yy626 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy626->iTable); } } } break; - case 177: /* expr ::= expr COLLATE ID|STRING */ + case 186: /* expr ::= expr COLLATE ID|STRING */ { - yymsp[-2].minor.yy202 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy202, &yymsp[0].minor.yy0, 1); + yymsp[-2].minor.yy626 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy626, &yymsp[0].minor.yy0, 1); } break; - case 178: /* expr ::= CAST LP expr AS typetoken RP */ + case 187: /* expr ::= CAST LP expr AS typetoken RP */ { - yymsp[-5].minor.yy202 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1); - sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy202, yymsp[-3].minor.yy202, 0); + yymsp[-5].minor.yy626 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1); + sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy626, yymsp[-3].minor.yy626, 0); } break; - case 179: /* expr ::= ID|INDEXED LP distinct exprlist RP */ + case 188: /* expr ::= ID|INDEXED LP distinct exprlist RP */ { - yylhsminor.yy202 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy242, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy192); + yylhsminor.yy626 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy562, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy64); } - yymsp[-4].minor.yy202 = yylhsminor.yy202; + yymsp[-4].minor.yy626 = yylhsminor.yy626; break; - case 180: /* expr ::= ID|INDEXED LP STAR RP */ + case 189: /* expr ::= ID|INDEXED LP STAR RP */ { - yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0); + yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0); } - yymsp[-3].minor.yy202 = yylhsminor.yy202; + yymsp[-3].minor.yy626 = yylhsminor.yy626; break; - case 181: /* expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ + case 190: /* expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ { - yylhsminor.yy202 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy242, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy192); - sqlite3WindowAttach(pParse, yylhsminor.yy202, yymsp[0].minor.yy303); + yylhsminor.yy626 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy562, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy64); + sqlite3WindowAttach(pParse, yylhsminor.yy626, yymsp[0].minor.yy375); } - yymsp[-5].minor.yy202 = yylhsminor.yy202; + yymsp[-5].minor.yy626 = yylhsminor.yy626; break; - case 182: /* expr ::= ID|INDEXED LP STAR RP filter_over */ + case 191: /* expr ::= ID|INDEXED LP STAR RP filter_over */ { - yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0); - sqlite3WindowAttach(pParse, yylhsminor.yy202, yymsp[0].minor.yy303); + yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0); + sqlite3WindowAttach(pParse, yylhsminor.yy626, yymsp[0].minor.yy375); } - yymsp[-4].minor.yy202 = yylhsminor.yy202; + yymsp[-4].minor.yy626 = yylhsminor.yy626; break; - case 183: /* term ::= CTIME_KW */ + case 192: /* term ::= CTIME_KW */ { - yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0); + yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0); } - yymsp[0].minor.yy202 = yylhsminor.yy202; + yymsp[0].minor.yy626 = yylhsminor.yy626; break; - case 184: /* expr ::= LP nexprlist COMMA expr RP */ + case 193: /* expr ::= LP nexprlist COMMA expr RP */ { - ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy242, yymsp[-1].minor.yy202); - yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); - if( yymsp[-4].minor.yy202 ){ - yymsp[-4].minor.yy202->x.pList = pList; + ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy562, yymsp[-1].minor.yy626); + yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); + if( yymsp[-4].minor.yy626 ){ + yymsp[-4].minor.yy626->x.pList = pList; if( ALWAYS(pList->nExpr) ){ - yymsp[-4].minor.yy202->flags |= pList->a[0].pExpr->flags & EP_Propagate; + yymsp[-4].minor.yy626->flags |= pList->a[0].pExpr->flags & EP_Propagate; } }else{ sqlite3ExprListDelete(pParse->db, pList); } } break; - case 185: /* expr ::= expr AND expr */ -{yymsp[-2].minor.yy202=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);} + case 194: /* expr ::= expr AND expr */ +{yymsp[-2].minor.yy626=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);} break; - case 186: /* expr ::= expr OR expr */ - case 187: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==187); - case 188: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==188); - case 189: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==189); - case 190: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==190); - case 191: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==191); - case 192: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==192); -{yymsp[-2].minor.yy202=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);} + case 195: /* expr ::= expr OR expr */ + case 196: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==196); + case 197: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==197); + case 198: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==198); + case 199: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==199); + case 200: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==200); + case 201: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==201); +{yymsp[-2].minor.yy626=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);} break; - case 193: /* likeop ::= NOT LIKE_KW|MATCH */ + case 202: /* likeop ::= NOT LIKE_KW|MATCH */ {yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/} break; - case 194: /* expr ::= expr likeop expr */ + case 203: /* expr ::= expr likeop expr */ { ExprList *pList; int bNot = yymsp[-1].minor.yy0.n & 0x80000000; yymsp[-1].minor.yy0.n &= 0x7fffffff; - pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy202); - pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy202); - yymsp[-2].minor.yy202 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); - if( bNot ) yymsp[-2].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy202, 0); - if( yymsp[-2].minor.yy202 ) yymsp[-2].minor.yy202->flags |= EP_InfixFunc; + pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy626); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy626); + yymsp[-2].minor.yy626 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); + if( bNot ) yymsp[-2].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy626, 0); + if( yymsp[-2].minor.yy626 ) yymsp[-2].minor.yy626->flags |= EP_InfixFunc; } break; - case 195: /* expr ::= expr likeop expr ESCAPE expr */ + case 204: /* expr ::= expr likeop expr ESCAPE expr */ { ExprList *pList; int bNot = yymsp[-3].minor.yy0.n & 0x80000000; yymsp[-3].minor.yy0.n &= 0x7fffffff; - pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202); - pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy202); - pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy202); - yymsp[-4].minor.yy202 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0); - if( bNot ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); - if( yymsp[-4].minor.yy202 ) yymsp[-4].minor.yy202->flags |= EP_InfixFunc; + pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy626); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy626); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy626); + yymsp[-4].minor.yy626 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0); + if( bNot ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); + if( yymsp[-4].minor.yy626 ) yymsp[-4].minor.yy626->flags |= EP_InfixFunc; } break; - case 196: /* expr ::= expr ISNULL|NOTNULL */ -{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy202,0);} + case 205: /* expr ::= expr ISNULL|NOTNULL */ +{yymsp[-1].minor.yy626 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy626,0);} break; - case 197: /* expr ::= expr NOT NULL */ -{yymsp[-2].minor.yy202 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy202,0);} + case 206: /* expr ::= expr NOT NULL */ +{yymsp[-2].minor.yy626 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy626,0);} break; - case 198: /* expr ::= expr IS expr */ + case 207: /* expr ::= expr IS expr */ { - yymsp[-2].minor.yy202 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy202,yymsp[0].minor.yy202); - binaryToUnaryIfNull(pParse, yymsp[0].minor.yy202, yymsp[-2].minor.yy202, TK_ISNULL); + yymsp[-2].minor.yy626 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy626,yymsp[0].minor.yy626); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy626, yymsp[-2].minor.yy626, TK_ISNULL); } break; - case 199: /* expr ::= expr IS NOT expr */ + case 208: /* expr ::= expr IS NOT expr */ { - yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy202,yymsp[0].minor.yy202); - binaryToUnaryIfNull(pParse, yymsp[0].minor.yy202, yymsp[-3].minor.yy202, TK_NOTNULL); + yymsp[-3].minor.yy626 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy626,yymsp[0].minor.yy626); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy626, yymsp[-3].minor.yy626, TK_NOTNULL); } break; - case 200: /* expr ::= NOT expr */ - case 201: /* expr ::= BITNOT expr */ yytestcase(yyruleno==201); -{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy202, 0);/*A-overwrites-B*/} + case 209: /* expr ::= NOT expr */ + case 210: /* expr ::= BITNOT expr */ yytestcase(yyruleno==210); +{yymsp[-1].minor.yy626 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy626, 0);/*A-overwrites-B*/} break; - case 202: /* expr ::= PLUS|MINUS expr */ + case 211: /* expr ::= PLUS|MINUS expr */ { - yymsp[-1].minor.yy202 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy202, 0); + yymsp[-1].minor.yy626 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy626, 0); /*A-overwrites-B*/ } break; - case 203: /* between_op ::= BETWEEN */ - case 206: /* in_op ::= IN */ yytestcase(yyruleno==206); -{yymsp[0].minor.yy192 = 0;} + case 212: /* between_op ::= BETWEEN */ + case 215: /* in_op ::= IN */ yytestcase(yyruleno==215); +{yymsp[0].minor.yy64 = 0;} break; - case 205: /* expr ::= expr between_op expr AND expr */ + case 214: /* expr ::= expr between_op expr AND expr */ { - ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202); - pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy202); - yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy202, 0); - if( yymsp[-4].minor.yy202 ){ - yymsp[-4].minor.yy202->x.pList = pList; + ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy626); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy626); + yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy626, 0); + if( yymsp[-4].minor.yy626 ){ + yymsp[-4].minor.yy626->x.pList = pList; }else{ sqlite3ExprListDelete(pParse->db, pList); } - if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); + if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); } break; - case 208: /* expr ::= expr in_op LP exprlist RP */ + case 217: /* expr ::= expr in_op LP exprlist RP */ { - if( yymsp[-1].minor.yy242==0 ){ + if( yymsp[-1].minor.yy562==0 ){ /* Expressions of the form ** ** expr1 IN () @@ -159230,197 +163899,205 @@ static YYACTIONTYPE yy_reduce( ** simplify to constants 0 (false) and 1 (true), respectively, ** regardless of the value of expr1. */ - sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy202); - yymsp[-4].minor.yy202 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy192 ? "1" : "0"); - }else if( yymsp[-1].minor.yy242->nExpr==1 && sqlite3ExprIsConstant(yymsp[-1].minor.yy242->a[0].pExpr) ){ - Expr *pRHS = yymsp[-1].minor.yy242->a[0].pExpr; - yymsp[-1].minor.yy242->a[0].pExpr = 0; - sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy242); - pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0); - yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy202, pRHS); - if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); - }else{ - yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0); - if( yymsp[-4].minor.yy202 ){ - yymsp[-4].minor.yy202->x.pList = yymsp[-1].minor.yy242; - sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy202); + sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy626); + yymsp[-4].minor.yy626 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy64 ? "1" : "0"); + }else{ + Expr *pRHS = yymsp[-1].minor.yy562->a[0].pExpr; + if( yymsp[-1].minor.yy562->nExpr==1 && sqlite3ExprIsConstant(pRHS) && yymsp[-4].minor.yy626->op!=TK_VECTOR ){ + yymsp[-1].minor.yy562->a[0].pExpr = 0; + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy562); + pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0); + yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy626, pRHS); }else{ - sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy242); + yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0); + if( yymsp[-4].minor.yy626==0 ){ + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy562); + }else if( yymsp[-4].minor.yy626->pLeft->op==TK_VECTOR ){ + int nExpr = yymsp[-4].minor.yy626->pLeft->x.pList->nExpr; + Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy562); + if( pSelectRHS ){ + parserDoubleLinkSelect(pParse, pSelectRHS); + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy626, pSelectRHS); + } + }else{ + yymsp[-4].minor.yy626->x.pList = yymsp[-1].minor.yy562; + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy626); + } } - if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); + if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); } } break; - case 209: /* expr ::= LP select RP */ + case 218: /* expr ::= LP select RP */ { - yymsp[-2].minor.yy202 = sqlite3PExpr(pParse, TK_SELECT, 0, 0); - sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy202, yymsp[-1].minor.yy539); + yymsp[-2].minor.yy626 = sqlite3PExpr(pParse, TK_SELECT, 0, 0); + sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy626, yymsp[-1].minor.yy303); } break; - case 210: /* expr ::= expr in_op LP select RP */ + case 219: /* expr ::= expr in_op LP select RP */ { - yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0); - sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy202, yymsp[-1].minor.yy539); - if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); + yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0); + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy626, yymsp[-1].minor.yy303); + if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); } break; - case 211: /* expr ::= expr in_op nm dbnm paren_exprlist */ + case 220: /* expr ::= expr in_op nm dbnm paren_exprlist */ { SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0); - if( yymsp[0].minor.yy242 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy242); - yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0); - sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy202, pSelect); - if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); + if( yymsp[0].minor.yy562 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy562); + yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0); + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy626, pSelect); + if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); } break; - case 212: /* expr ::= EXISTS LP select RP */ + case 221: /* expr ::= EXISTS LP select RP */ { Expr *p; - p = yymsp[-3].minor.yy202 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); - sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy539); + p = yymsp[-3].minor.yy626 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); + sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy303); } break; - case 213: /* expr ::= CASE case_operand case_exprlist case_else END */ + case 222: /* expr ::= CASE case_operand case_exprlist case_else END */ { - yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy202, 0); - if( yymsp[-4].minor.yy202 ){ - yymsp[-4].minor.yy202->x.pList = yymsp[-1].minor.yy202 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy242,yymsp[-1].minor.yy202) : yymsp[-2].minor.yy242; - sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy202); + yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy626, 0); + if( yymsp[-4].minor.yy626 ){ + yymsp[-4].minor.yy626->x.pList = yymsp[-1].minor.yy626 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626) : yymsp[-2].minor.yy562; + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy626); }else{ - sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy242); - sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy202); + sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy562); + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy626); } } break; - case 214: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */ + case 223: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */ { - yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, yymsp[-2].minor.yy202); - yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, yymsp[0].minor.yy202); + yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562, yymsp[-2].minor.yy626); + yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562, yymsp[0].minor.yy626); } break; - case 215: /* case_exprlist ::= WHEN expr THEN expr */ + case 224: /* case_exprlist ::= WHEN expr THEN expr */ { - yymsp[-3].minor.yy242 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202); - yymsp[-3].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy242, yymsp[0].minor.yy202); + yymsp[-3].minor.yy562 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy626); + yymsp[-3].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy562, yymsp[0].minor.yy626); } break; - case 218: /* case_operand ::= expr */ -{yymsp[0].minor.yy202 = yymsp[0].minor.yy202; /*A-overwrites-X*/} + case 227: /* case_operand ::= expr */ +{yymsp[0].minor.yy626 = yymsp[0].minor.yy626; /*A-overwrites-X*/} break; - case 221: /* nexprlist ::= nexprlist COMMA expr */ -{yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy242,yymsp[0].minor.yy202);} + case 230: /* nexprlist ::= nexprlist COMMA expr */ +{yymsp[-2].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy562,yymsp[0].minor.yy626);} break; - case 222: /* nexprlist ::= expr */ -{yymsp[0].minor.yy242 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy202); /*A-overwrites-Y*/} + case 231: /* nexprlist ::= expr */ +{yymsp[0].minor.yy562 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy626); /*A-overwrites-Y*/} break; - case 224: /* paren_exprlist ::= LP exprlist RP */ - case 229: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==229); -{yymsp[-2].minor.yy242 = yymsp[-1].minor.yy242;} + case 233: /* paren_exprlist ::= LP exprlist RP */ + case 238: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==238); +{yymsp[-2].minor.yy562 = yymsp[-1].minor.yy562;} break; - case 225: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ + case 234: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ { sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, - sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy242, yymsp[-10].minor.yy192, - &yymsp[-11].minor.yy0, yymsp[0].minor.yy202, SQLITE_SO_ASC, yymsp[-8].minor.yy192, SQLITE_IDXTYPE_APPDEF); + sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy562, yymsp[-10].minor.yy64, + &yymsp[-11].minor.yy0, yymsp[0].minor.yy626, SQLITE_SO_ASC, yymsp[-8].minor.yy64, SQLITE_IDXTYPE_APPDEF); if( IN_RENAME_OBJECT && pParse->pNewIndex ){ sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0); } } break; - case 226: /* uniqueflag ::= UNIQUE */ - case 268: /* raisetype ::= ABORT */ yytestcase(yyruleno==268); -{yymsp[0].minor.yy192 = OE_Abort;} + case 235: /* uniqueflag ::= UNIQUE */ + case 277: /* raisetype ::= ABORT */ yytestcase(yyruleno==277); +{yymsp[0].minor.yy64 = OE_Abort;} break; - case 227: /* uniqueflag ::= */ -{yymsp[1].minor.yy192 = OE_None;} + case 236: /* uniqueflag ::= */ +{yymsp[1].minor.yy64 = OE_None;} break; - case 230: /* eidlist ::= eidlist COMMA nm collate sortorder */ + case 239: /* eidlist ::= eidlist COMMA nm collate sortorder */ { - yymsp[-4].minor.yy242 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy242, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy192, yymsp[0].minor.yy192); + yymsp[-4].minor.yy562 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy562, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy64, yymsp[0].minor.yy64); } break; - case 231: /* eidlist ::= nm collate sortorder */ + case 240: /* eidlist ::= nm collate sortorder */ { - yymsp[-2].minor.yy242 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy192, yymsp[0].minor.yy192); /*A-overwrites-Y*/ + yymsp[-2].minor.yy562 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy64, yymsp[0].minor.yy64); /*A-overwrites-Y*/ } break; - case 234: /* cmd ::= DROP INDEX ifexists fullname */ -{sqlite3DropIndex(pParse, yymsp[0].minor.yy47, yymsp[-1].minor.yy192);} + case 243: /* cmd ::= DROP INDEX ifexists fullname */ +{sqlite3DropIndex(pParse, yymsp[0].minor.yy607, yymsp[-1].minor.yy64);} break; - case 235: /* cmd ::= VACUUM vinto */ -{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy202);} + case 244: /* cmd ::= VACUUM vinto */ +{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy626);} break; - case 236: /* cmd ::= VACUUM nm vinto */ -{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy202);} + case 245: /* cmd ::= VACUUM nm vinto */ +{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy626);} break; - case 239: /* cmd ::= PRAGMA nm dbnm */ + case 248: /* cmd ::= PRAGMA nm dbnm */ {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);} break; - case 240: /* cmd ::= PRAGMA nm dbnm EQ nmnum */ + case 249: /* cmd ::= PRAGMA nm dbnm EQ nmnum */ {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);} break; - case 241: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */ + case 250: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */ {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);} break; - case 242: /* cmd ::= PRAGMA nm dbnm EQ minus_num */ + case 251: /* cmd ::= PRAGMA nm dbnm EQ minus_num */ {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);} break; - case 243: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */ + case 252: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */ {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);} break; - case 246: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ + case 255: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ { Token all; all.z = yymsp[-3].minor.yy0.z; all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n; - sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy447, &all); + sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy95, &all); } break; - case 247: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ + case 256: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ { - sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy192, yymsp[-4].minor.yy230.a, yymsp[-4].minor.yy230.b, yymsp[-2].minor.yy47, yymsp[0].minor.yy202, yymsp[-10].minor.yy192, yymsp[-8].minor.yy192); + sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy64, yymsp[-4].minor.yy570.a, yymsp[-4].minor.yy570.b, yymsp[-2].minor.yy607, yymsp[0].minor.yy626, yymsp[-10].minor.yy64, yymsp[-8].minor.yy64); yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/ } break; - case 248: /* trigger_time ::= BEFORE|AFTER */ -{ yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-X*/ } + case 257: /* trigger_time ::= BEFORE|AFTER */ +{ yymsp[0].minor.yy64 = yymsp[0].major; /*A-overwrites-X*/ } break; - case 249: /* trigger_time ::= INSTEAD OF */ -{ yymsp[-1].minor.yy192 = TK_INSTEAD;} + case 258: /* trigger_time ::= INSTEAD OF */ +{ yymsp[-1].minor.yy64 = TK_INSTEAD;} break; - case 250: /* trigger_time ::= */ -{ yymsp[1].minor.yy192 = TK_BEFORE; } + case 259: /* trigger_time ::= */ +{ yymsp[1].minor.yy64 = TK_BEFORE; } break; - case 251: /* trigger_event ::= DELETE|INSERT */ - case 252: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==252); -{yymsp[0].minor.yy230.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy230.b = 0;} + case 260: /* trigger_event ::= DELETE|INSERT */ + case 261: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==261); +{yymsp[0].minor.yy570.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy570.b = 0;} break; - case 253: /* trigger_event ::= UPDATE OF idlist */ -{yymsp[-2].minor.yy230.a = TK_UPDATE; yymsp[-2].minor.yy230.b = yymsp[0].minor.yy600;} + case 262: /* trigger_event ::= UPDATE OF idlist */ +{yymsp[-2].minor.yy570.a = TK_UPDATE; yymsp[-2].minor.yy570.b = yymsp[0].minor.yy240;} break; - case 254: /* when_clause ::= */ - case 273: /* key_opt ::= */ yytestcase(yyruleno==273); -{ yymsp[1].minor.yy202 = 0; } + case 263: /* when_clause ::= */ + case 282: /* key_opt ::= */ yytestcase(yyruleno==282); +{ yymsp[1].minor.yy626 = 0; } break; - case 255: /* when_clause ::= WHEN expr */ - case 274: /* key_opt ::= KEY expr */ yytestcase(yyruleno==274); -{ yymsp[-1].minor.yy202 = yymsp[0].minor.yy202; } + case 264: /* when_clause ::= WHEN expr */ + case 283: /* key_opt ::= KEY expr */ yytestcase(yyruleno==283); +{ yymsp[-1].minor.yy626 = yymsp[0].minor.yy626; } break; - case 256: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ + case 265: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ { - assert( yymsp[-2].minor.yy447!=0 ); - yymsp[-2].minor.yy447->pLast->pNext = yymsp[-1].minor.yy447; - yymsp[-2].minor.yy447->pLast = yymsp[-1].minor.yy447; + assert( yymsp[-2].minor.yy95!=0 ); + yymsp[-2].minor.yy95->pLast->pNext = yymsp[-1].minor.yy95; + yymsp[-2].minor.yy95->pLast = yymsp[-1].minor.yy95; } break; - case 257: /* trigger_cmd_list ::= trigger_cmd SEMI */ + case 266: /* trigger_cmd_list ::= trigger_cmd SEMI */ { - assert( yymsp[-1].minor.yy447!=0 ); - yymsp[-1].minor.yy447->pLast = yymsp[-1].minor.yy447; + assert( yymsp[-1].minor.yy95!=0 ); + yymsp[-1].minor.yy95->pLast = yymsp[-1].minor.yy95; } break; - case 258: /* trnm ::= nm DOT nm */ + case 267: /* trnm ::= nm DOT nm */ { yymsp[-2].minor.yy0 = yymsp[0].minor.yy0; sqlite3ErrorMsg(pParse, @@ -159428,344 +164105,369 @@ static YYACTIONTYPE yy_reduce( "statements within triggers"); } break; - case 259: /* tridxby ::= INDEXED BY nm */ + case 268: /* tridxby ::= INDEXED BY nm */ { sqlite3ErrorMsg(pParse, "the INDEXED BY clause is not allowed on UPDATE or DELETE statements " "within triggers"); } break; - case 260: /* tridxby ::= NOT INDEXED */ + case 269: /* tridxby ::= NOT INDEXED */ { sqlite3ErrorMsg(pParse, "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements " "within triggers"); } break; - case 261: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ -{yylhsminor.yy447 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy47, yymsp[-3].minor.yy242, yymsp[-1].minor.yy202, yymsp[-7].minor.yy192, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy436);} - yymsp[-8].minor.yy447 = yylhsminor.yy447; + case 270: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ +{yylhsminor.yy95 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy607, yymsp[-3].minor.yy562, yymsp[-1].minor.yy626, yymsp[-7].minor.yy64, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy600);} + yymsp[-8].minor.yy95 = yylhsminor.yy95; break; - case 262: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ + case 271: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ { - yylhsminor.yy447 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy600,yymsp[-2].minor.yy539,yymsp[-6].minor.yy192,yymsp[-1].minor.yy318,yymsp[-7].minor.yy436,yymsp[0].minor.yy436);/*yylhsminor.yy447-overwrites-yymsp[-6].minor.yy192*/ + yylhsminor.yy95 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy240,yymsp[-2].minor.yy303,yymsp[-6].minor.yy64,yymsp[-1].minor.yy138,yymsp[-7].minor.yy600,yymsp[0].minor.yy600);/*yylhsminor.yy95-overwrites-yymsp[-6].minor.yy64*/ } - yymsp[-7].minor.yy447 = yylhsminor.yy447; + yymsp[-7].minor.yy95 = yylhsminor.yy95; break; - case 263: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ -{yylhsminor.yy447 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy202, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy436);} - yymsp[-5].minor.yy447 = yylhsminor.yy447; + case 272: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ +{yylhsminor.yy95 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy626, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy600);} + yymsp[-5].minor.yy95 = yylhsminor.yy95; break; - case 264: /* trigger_cmd ::= scanpt select scanpt */ -{yylhsminor.yy447 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy539, yymsp[-2].minor.yy436, yymsp[0].minor.yy436); /*yylhsminor.yy447-overwrites-yymsp[-1].minor.yy539*/} - yymsp[-2].minor.yy447 = yylhsminor.yy447; + case 273: /* trigger_cmd ::= scanpt select scanpt */ +{yylhsminor.yy95 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy303, yymsp[-2].minor.yy600, yymsp[0].minor.yy600); /*yylhsminor.yy95-overwrites-yymsp[-1].minor.yy303*/} + yymsp[-2].minor.yy95 = yylhsminor.yy95; break; - case 265: /* expr ::= RAISE LP IGNORE RP */ + case 274: /* expr ::= RAISE LP IGNORE RP */ { - yymsp[-3].minor.yy202 = sqlite3PExpr(pParse, TK_RAISE, 0, 0); - if( yymsp[-3].minor.yy202 ){ - yymsp[-3].minor.yy202->affExpr = OE_Ignore; + yymsp[-3].minor.yy626 = sqlite3PExpr(pParse, TK_RAISE, 0, 0); + if( yymsp[-3].minor.yy626 ){ + yymsp[-3].minor.yy626->affExpr = OE_Ignore; } } break; - case 266: /* expr ::= RAISE LP raisetype COMMA nm RP */ + case 275: /* expr ::= RAISE LP raisetype COMMA nm RP */ { - yymsp[-5].minor.yy202 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1); - if( yymsp[-5].minor.yy202 ) { - yymsp[-5].minor.yy202->affExpr = (char)yymsp[-3].minor.yy192; + yymsp[-5].minor.yy626 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1); + if( yymsp[-5].minor.yy626 ) { + yymsp[-5].minor.yy626->affExpr = (char)yymsp[-3].minor.yy64; } } break; - case 267: /* raisetype ::= ROLLBACK */ -{yymsp[0].minor.yy192 = OE_Rollback;} + case 276: /* raisetype ::= ROLLBACK */ +{yymsp[0].minor.yy64 = OE_Rollback;} break; - case 269: /* raisetype ::= FAIL */ -{yymsp[0].minor.yy192 = OE_Fail;} + case 278: /* raisetype ::= FAIL */ +{yymsp[0].minor.yy64 = OE_Fail;} break; - case 270: /* cmd ::= DROP TRIGGER ifexists fullname */ + case 279: /* cmd ::= DROP TRIGGER ifexists fullname */ { - sqlite3DropTrigger(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy192); + sqlite3DropTrigger(pParse,yymsp[0].minor.yy607,yymsp[-1].minor.yy64); } break; - case 271: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ + case 280: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ { - sqlite3Attach(pParse, yymsp[-3].minor.yy202, yymsp[-1].minor.yy202, yymsp[0].minor.yy202); + sqlite3Attach(pParse, yymsp[-3].minor.yy626, yymsp[-1].minor.yy626, yymsp[0].minor.yy626); } break; - case 272: /* cmd ::= DETACH database_kw_opt expr */ + case 281: /* cmd ::= DETACH database_kw_opt expr */ { - sqlite3Detach(pParse, yymsp[0].minor.yy202); + sqlite3Detach(pParse, yymsp[0].minor.yy626); } break; - case 275: /* cmd ::= REINDEX */ + case 284: /* cmd ::= REINDEX */ {sqlite3Reindex(pParse, 0, 0);} break; - case 276: /* cmd ::= REINDEX nm dbnm */ + case 285: /* cmd ::= REINDEX nm dbnm */ {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} break; - case 277: /* cmd ::= ANALYZE */ + case 286: /* cmd ::= ANALYZE */ {sqlite3Analyze(pParse, 0, 0);} break; - case 278: /* cmd ::= ANALYZE nm dbnm */ + case 287: /* cmd ::= ANALYZE nm dbnm */ {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} break; - case 279: /* cmd ::= ALTER TABLE fullname RENAME TO nm */ + case 288: /* cmd ::= ALTER TABLE fullname RENAME TO nm */ { - sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy47,&yymsp[0].minor.yy0); + sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy607,&yymsp[0].minor.yy0); } break; - case 280: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ + case 289: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ { yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n; sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0); } break; - case 281: /* add_column_fullname ::= fullname */ + case 290: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ +{ + sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy607, &yymsp[0].minor.yy0); +} + break; + case 291: /* add_column_fullname ::= fullname */ { disableLookaside(pParse); - sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy47); + sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy607); } break; - case 282: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ + case 292: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ { - sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy47, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); + sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy607, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 283: /* cmd ::= create_vtab */ + case 293: /* cmd ::= create_vtab */ {sqlite3VtabFinishParse(pParse,0);} break; - case 284: /* cmd ::= create_vtab LP vtabarglist RP */ + case 294: /* cmd ::= create_vtab LP vtabarglist RP */ {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);} break; - case 285: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ + case 295: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ { - sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy192); + sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy64); } break; - case 286: /* vtabarg ::= */ + case 296: /* vtabarg ::= */ {sqlite3VtabArgInit(pParse);} break; - case 287: /* vtabargtoken ::= ANY */ - case 288: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==288); - case 289: /* lp ::= LP */ yytestcase(yyruleno==289); + case 297: /* vtabargtoken ::= ANY */ + case 298: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==298); + case 299: /* lp ::= LP */ yytestcase(yyruleno==299); {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);} break; - case 290: /* with ::= WITH wqlist */ - case 291: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==291); -{ sqlite3WithPush(pParse, yymsp[0].minor.yy131, 1); } + case 300: /* with ::= WITH wqlist */ + case 301: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==301); +{ sqlite3WithPush(pParse, yymsp[0].minor.yy43, 1); } + break; + case 302: /* wqas ::= AS */ +{yymsp[0].minor.yy534 = M10d_Any;} break; - case 292: /* wqlist ::= nm eidlist_opt AS LP select RP */ + case 303: /* wqas ::= AS MATERIALIZED */ +{yymsp[-1].minor.yy534 = M10d_Yes;} + break; + case 304: /* wqas ::= AS NOT MATERIALIZED */ +{yymsp[-2].minor.yy534 = M10d_No;} + break; + case 305: /* wqitem ::= nm eidlist_opt wqas LP select RP */ +{ + yymsp[-5].minor.yy255 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy562, yymsp[-1].minor.yy303, yymsp[-3].minor.yy534); /*A-overwrites-X*/ +} + break; + case 306: /* wqlist ::= wqitem */ { - yymsp[-5].minor.yy131 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy242, yymsp[-1].minor.yy539); /*A-overwrites-X*/ + yymsp[0].minor.yy43 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy255); /*A-overwrites-X*/ } break; - case 293: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */ + case 307: /* wqlist ::= wqlist COMMA wqitem */ { - yymsp[-7].minor.yy131 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy131, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy242, yymsp[-1].minor.yy539); + yymsp[-2].minor.yy43 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy43, yymsp[0].minor.yy255); } break; - case 294: /* windowdefn_list ::= windowdefn */ -{ yylhsminor.yy303 = yymsp[0].minor.yy303; } - yymsp[0].minor.yy303 = yylhsminor.yy303; + case 308: /* windowdefn_list ::= windowdefn */ +{ yylhsminor.yy375 = yymsp[0].minor.yy375; } + yymsp[0].minor.yy375 = yylhsminor.yy375; break; - case 295: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */ + case 309: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */ { - assert( yymsp[0].minor.yy303!=0 ); - sqlite3WindowChain(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy303); - yymsp[0].minor.yy303->pNextWin = yymsp[-2].minor.yy303; - yylhsminor.yy303 = yymsp[0].minor.yy303; + assert( yymsp[0].minor.yy375!=0 ); + sqlite3WindowChain(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy375); + yymsp[0].minor.yy375->pNextWin = yymsp[-2].minor.yy375; + yylhsminor.yy375 = yymsp[0].minor.yy375; } - yymsp[-2].minor.yy303 = yylhsminor.yy303; + yymsp[-2].minor.yy375 = yylhsminor.yy375; break; - case 296: /* windowdefn ::= nm AS LP window RP */ + case 310: /* windowdefn ::= nm AS LP window RP */ { - if( ALWAYS(yymsp[-1].minor.yy303) ){ - yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n); + if( ALWAYS(yymsp[-1].minor.yy375) ){ + yymsp[-1].minor.yy375->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n); } - yylhsminor.yy303 = yymsp[-1].minor.yy303; + yylhsminor.yy375 = yymsp[-1].minor.yy375; } - yymsp[-4].minor.yy303 = yylhsminor.yy303; + yymsp[-4].minor.yy375 = yylhsminor.yy375; break; - case 297: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */ + case 311: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */ { - yymsp[-4].minor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy242, yymsp[-1].minor.yy242, 0); + yymsp[-4].minor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy562, yymsp[-1].minor.yy562, 0); } break; - case 298: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ + case 312: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ { - yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy242, yymsp[-1].minor.yy242, &yymsp[-5].minor.yy0); + yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy562, yymsp[-1].minor.yy562, &yymsp[-5].minor.yy0); } - yymsp[-5].minor.yy303 = yylhsminor.yy303; + yymsp[-5].minor.yy375 = yylhsminor.yy375; break; - case 299: /* window ::= ORDER BY sortlist frame_opt */ + case 313: /* window ::= ORDER BY sortlist frame_opt */ { - yymsp[-3].minor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, yymsp[-1].minor.yy242, 0); + yymsp[-3].minor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, yymsp[-1].minor.yy562, 0); } break; - case 300: /* window ::= nm ORDER BY sortlist frame_opt */ + case 314: /* window ::= nm ORDER BY sortlist frame_opt */ { - yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, yymsp[-1].minor.yy242, &yymsp[-4].minor.yy0); + yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, yymsp[-1].minor.yy562, &yymsp[-4].minor.yy0); } - yymsp[-4].minor.yy303 = yylhsminor.yy303; + yymsp[-4].minor.yy375 = yylhsminor.yy375; break; - case 301: /* window ::= frame_opt */ - case 320: /* filter_over ::= over_clause */ yytestcase(yyruleno==320); + case 315: /* window ::= frame_opt */ + case 334: /* filter_over ::= over_clause */ yytestcase(yyruleno==334); { - yylhsminor.yy303 = yymsp[0].minor.yy303; + yylhsminor.yy375 = yymsp[0].minor.yy375; } - yymsp[0].minor.yy303 = yylhsminor.yy303; + yymsp[0].minor.yy375 = yylhsminor.yy375; break; - case 302: /* window ::= nm frame_opt */ + case 316: /* window ::= nm frame_opt */ { - yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, 0, &yymsp[-1].minor.yy0); + yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, 0, &yymsp[-1].minor.yy0); } - yymsp[-1].minor.yy303 = yylhsminor.yy303; + yymsp[-1].minor.yy375 = yylhsminor.yy375; break; - case 303: /* frame_opt ::= */ + case 317: /* frame_opt ::= */ { - yymsp[1].minor.yy303 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0); + yymsp[1].minor.yy375 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0); } break; - case 304: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ + case 318: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ { - yylhsminor.yy303 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy192, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.yy77.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy58); + yylhsminor.yy375 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy64, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.yy81.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy534); } - yymsp[-2].minor.yy303 = yylhsminor.yy303; + yymsp[-2].minor.yy375 = yylhsminor.yy375; break; - case 305: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ + case 319: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ { - yylhsminor.yy303 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy192, yymsp[-3].minor.yy77.eType, yymsp[-3].minor.yy77.pExpr, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.yy77.pExpr, yymsp[0].minor.yy58); + yylhsminor.yy375 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy64, yymsp[-3].minor.yy81.eType, yymsp[-3].minor.yy81.pExpr, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.yy81.pExpr, yymsp[0].minor.yy534); } - yymsp[-5].minor.yy303 = yylhsminor.yy303; + yymsp[-5].minor.yy375 = yylhsminor.yy375; break; - case 307: /* frame_bound_s ::= frame_bound */ - case 309: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==309); -{yylhsminor.yy77 = yymsp[0].minor.yy77;} - yymsp[0].minor.yy77 = yylhsminor.yy77; + case 321: /* frame_bound_s ::= frame_bound */ + case 323: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==323); +{yylhsminor.yy81 = yymsp[0].minor.yy81;} + yymsp[0].minor.yy81 = yylhsminor.yy81; break; - case 308: /* frame_bound_s ::= UNBOUNDED PRECEDING */ - case 310: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==310); - case 312: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==312); -{yylhsminor.yy77.eType = yymsp[-1].major; yylhsminor.yy77.pExpr = 0;} - yymsp[-1].minor.yy77 = yylhsminor.yy77; + case 322: /* frame_bound_s ::= UNBOUNDED PRECEDING */ + case 324: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==324); + case 326: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==326); +{yylhsminor.yy81.eType = yymsp[-1].major; yylhsminor.yy81.pExpr = 0;} + yymsp[-1].minor.yy81 = yylhsminor.yy81; break; - case 311: /* frame_bound ::= expr PRECEDING|FOLLOWING */ -{yylhsminor.yy77.eType = yymsp[0].major; yylhsminor.yy77.pExpr = yymsp[-1].minor.yy202;} - yymsp[-1].minor.yy77 = yylhsminor.yy77; + case 325: /* frame_bound ::= expr PRECEDING|FOLLOWING */ +{yylhsminor.yy81.eType = yymsp[0].major; yylhsminor.yy81.pExpr = yymsp[-1].minor.yy626;} + yymsp[-1].minor.yy81 = yylhsminor.yy81; break; - case 313: /* frame_exclude_opt ::= */ -{yymsp[1].minor.yy58 = 0;} + case 327: /* frame_exclude_opt ::= */ +{yymsp[1].minor.yy534 = 0;} break; - case 314: /* frame_exclude_opt ::= EXCLUDE frame_exclude */ -{yymsp[-1].minor.yy58 = yymsp[0].minor.yy58;} + case 328: /* frame_exclude_opt ::= EXCLUDE frame_exclude */ +{yymsp[-1].minor.yy534 = yymsp[0].minor.yy534;} break; - case 315: /* frame_exclude ::= NO OTHERS */ - case 316: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==316); -{yymsp[-1].minor.yy58 = yymsp[-1].major; /*A-overwrites-X*/} + case 329: /* frame_exclude ::= NO OTHERS */ + case 330: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==330); +{yymsp[-1].minor.yy534 = yymsp[-1].major; /*A-overwrites-X*/} break; - case 317: /* frame_exclude ::= GROUP|TIES */ -{yymsp[0].minor.yy58 = yymsp[0].major; /*A-overwrites-X*/} + case 331: /* frame_exclude ::= GROUP|TIES */ +{yymsp[0].minor.yy534 = yymsp[0].major; /*A-overwrites-X*/} break; - case 318: /* window_clause ::= WINDOW windowdefn_list */ -{ yymsp[-1].minor.yy303 = yymsp[0].minor.yy303; } + case 332: /* window_clause ::= WINDOW windowdefn_list */ +{ yymsp[-1].minor.yy375 = yymsp[0].minor.yy375; } break; - case 319: /* filter_over ::= filter_clause over_clause */ + case 333: /* filter_over ::= filter_clause over_clause */ { - yymsp[0].minor.yy303->pFilter = yymsp[-1].minor.yy202; - yylhsminor.yy303 = yymsp[0].minor.yy303; + if( yymsp[0].minor.yy375 ){ + yymsp[0].minor.yy375->pFilter = yymsp[-1].minor.yy626; + }else{ + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy626); + } + yylhsminor.yy375 = yymsp[0].minor.yy375; } - yymsp[-1].minor.yy303 = yylhsminor.yy303; + yymsp[-1].minor.yy375 = yylhsminor.yy375; break; - case 321: /* filter_over ::= filter_clause */ + case 335: /* filter_over ::= filter_clause */ { - yylhsminor.yy303 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); - if( yylhsminor.yy303 ){ - yylhsminor.yy303->eFrmType = TK_FILTER; - yylhsminor.yy303->pFilter = yymsp[0].minor.yy202; + yylhsminor.yy375 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); + if( yylhsminor.yy375 ){ + yylhsminor.yy375->eFrmType = TK_FILTER; + yylhsminor.yy375->pFilter = yymsp[0].minor.yy626; }else{ - sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy202); + sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy626); } } - yymsp[0].minor.yy303 = yylhsminor.yy303; + yymsp[0].minor.yy375 = yylhsminor.yy375; break; - case 322: /* over_clause ::= OVER LP window RP */ + case 336: /* over_clause ::= OVER LP window RP */ { - yymsp[-3].minor.yy303 = yymsp[-1].minor.yy303; - assert( yymsp[-3].minor.yy303!=0 ); + yymsp[-3].minor.yy375 = yymsp[-1].minor.yy375; + assert( yymsp[-3].minor.yy375!=0 ); } break; - case 323: /* over_clause ::= OVER nm */ + case 337: /* over_clause ::= OVER nm */ { - yymsp[-1].minor.yy303 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); - if( yymsp[-1].minor.yy303 ){ - yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n); + yymsp[-1].minor.yy375 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); + if( yymsp[-1].minor.yy375 ){ + yymsp[-1].minor.yy375->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n); } } break; - case 324: /* filter_clause ::= FILTER LP WHERE expr RP */ -{ yymsp[-4].minor.yy202 = yymsp[-1].minor.yy202; } + case 338: /* filter_clause ::= FILTER LP WHERE expr RP */ +{ yymsp[-4].minor.yy626 = yymsp[-1].minor.yy626; } break; default: - /* (325) input ::= cmdlist */ yytestcase(yyruleno==325); - /* (326) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==326); - /* (327) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=327); - /* (328) ecmd ::= SEMI */ yytestcase(yyruleno==328); - /* (329) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==329); - /* (330) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=330); - /* (331) trans_opt ::= */ yytestcase(yyruleno==331); - /* (332) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==332); - /* (333) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==333); - /* (334) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==334); - /* (335) savepoint_opt ::= */ yytestcase(yyruleno==335); - /* (336) cmd ::= create_table create_table_args */ yytestcase(yyruleno==336); - /* (337) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==337); - /* (338) columnlist ::= columnname carglist */ yytestcase(yyruleno==338); - /* (339) nm ::= ID|INDEXED */ yytestcase(yyruleno==339); - /* (340) nm ::= STRING */ yytestcase(yyruleno==340); - /* (341) nm ::= JOIN_KW */ yytestcase(yyruleno==341); - /* (342) typetoken ::= typename */ yytestcase(yyruleno==342); - /* (343) typename ::= ID|STRING */ yytestcase(yyruleno==343); - /* (344) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=344); - /* (345) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=345); - /* (346) carglist ::= carglist ccons */ yytestcase(yyruleno==346); - /* (347) carglist ::= */ yytestcase(yyruleno==347); - /* (348) ccons ::= NULL onconf */ yytestcase(yyruleno==348); - /* (349) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==349); - /* (350) ccons ::= AS generated */ yytestcase(yyruleno==350); - /* (351) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==351); - /* (352) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==352); - /* (353) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=353); - /* (354) tconscomma ::= */ yytestcase(yyruleno==354); - /* (355) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=355); - /* (356) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=356); - /* (357) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=357); - /* (358) oneselect ::= values */ yytestcase(yyruleno==358); - /* (359) sclp ::= selcollist COMMA */ yytestcase(yyruleno==359); - /* (360) as ::= ID|STRING */ yytestcase(yyruleno==360); - /* (361) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=361); - /* (362) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==362); - /* (363) exprlist ::= nexprlist */ yytestcase(yyruleno==363); - /* (364) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=364); - /* (365) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=365); - /* (366) nmnum ::= ON */ yytestcase(yyruleno==366); - /* (367) nmnum ::= DELETE */ yytestcase(yyruleno==367); - /* (368) nmnum ::= DEFAULT */ yytestcase(yyruleno==368); - /* (369) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==369); - /* (370) foreach_clause ::= */ yytestcase(yyruleno==370); - /* (371) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==371); - /* (372) trnm ::= nm */ yytestcase(yyruleno==372); - /* (373) tridxby ::= */ yytestcase(yyruleno==373); - /* (374) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==374); - /* (375) database_kw_opt ::= */ yytestcase(yyruleno==375); - /* (376) kwcolumn_opt ::= */ yytestcase(yyruleno==376); - /* (377) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==377); - /* (378) vtabarglist ::= vtabarg */ yytestcase(yyruleno==378); - /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==379); - /* (380) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==380); - /* (381) anylist ::= */ yytestcase(yyruleno==381); - /* (382) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==382); - /* (383) anylist ::= anylist ANY */ yytestcase(yyruleno==383); - /* (384) with ::= */ yytestcase(yyruleno==384); + /* (339) input ::= cmdlist */ yytestcase(yyruleno==339); + /* (340) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==340); + /* (341) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=341); + /* (342) ecmd ::= SEMI */ yytestcase(yyruleno==342); + /* (343) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==343); + /* (344) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=344); + /* (345) trans_opt ::= */ yytestcase(yyruleno==345); + /* (346) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==346); + /* (347) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==347); + /* (348) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==348); + /* (349) savepoint_opt ::= */ yytestcase(yyruleno==349); + /* (350) cmd ::= create_table create_table_args */ yytestcase(yyruleno==350); + /* (351) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=351); + /* (352) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==352); + /* (353) columnlist ::= columnname carglist */ yytestcase(yyruleno==353); + /* (354) nm ::= ID|INDEXED */ yytestcase(yyruleno==354); + /* (355) nm ::= STRING */ yytestcase(yyruleno==355); + /* (356) nm ::= JOIN_KW */ yytestcase(yyruleno==356); + /* (357) typetoken ::= typename */ yytestcase(yyruleno==357); + /* (358) typename ::= ID|STRING */ yytestcase(yyruleno==358); + /* (359) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=359); + /* (360) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=360); + /* (361) carglist ::= carglist ccons */ yytestcase(yyruleno==361); + /* (362) carglist ::= */ yytestcase(yyruleno==362); + /* (363) ccons ::= NULL onconf */ yytestcase(yyruleno==363); + /* (364) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==364); + /* (365) ccons ::= AS generated */ yytestcase(yyruleno==365); + /* (366) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==366); + /* (367) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==367); + /* (368) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=368); + /* (369) tconscomma ::= */ yytestcase(yyruleno==369); + /* (370) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=370); + /* (371) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=371); + /* (372) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=372); + /* (373) oneselect ::= values */ yytestcase(yyruleno==373); + /* (374) sclp ::= selcollist COMMA */ yytestcase(yyruleno==374); + /* (375) as ::= ID|STRING */ yytestcase(yyruleno==375); + /* (376) returning ::= */ yytestcase(yyruleno==376); + /* (377) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=377); + /* (378) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==378); + /* (379) exprlist ::= nexprlist */ yytestcase(yyruleno==379); + /* (380) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=380); + /* (381) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=381); + /* (382) nmnum ::= ON */ yytestcase(yyruleno==382); + /* (383) nmnum ::= DELETE */ yytestcase(yyruleno==383); + /* (384) nmnum ::= DEFAULT */ yytestcase(yyruleno==384); + /* (385) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==385); + /* (386) foreach_clause ::= */ yytestcase(yyruleno==386); + /* (387) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==387); + /* (388) trnm ::= nm */ yytestcase(yyruleno==388); + /* (389) tridxby ::= */ yytestcase(yyruleno==389); + /* (390) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==390); + /* (391) database_kw_opt ::= */ yytestcase(yyruleno==391); + /* (392) kwcolumn_opt ::= */ yytestcase(yyruleno==392); + /* (393) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==393); + /* (394) vtabarglist ::= vtabarg */ yytestcase(yyruleno==394); + /* (395) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==395); + /* (396) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==396); + /* (397) anylist ::= */ yytestcase(yyruleno==397); + /* (398) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==398); + /* (399) anylist ::= anylist ANY */ yytestcase(yyruleno==399); + /* (400) with ::= */ yytestcase(yyruleno==400); break; /********** End reduce actions ************************************************/ }; @@ -159917,12 +164619,56 @@ SQLITE_PRIVATE void sqlite3Parser( } #endif - do{ + while(1){ /* Exit by "break" */ + assert( yypParser->yytos>=yypParser->yystack ); assert( yyact==yypParser->yytos->stateno ); yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact); if( yyact >= YY_MIN_REDUCE ){ - yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor, - yyminor sqlite3ParserCTX_PARAM); + unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */ +#ifndef NDEBUG + assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ); + if( yyTraceFILE ){ + int yysize = yyRuleInfoNRhs[yyruleno]; + if( yysize ){ + fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", + yyTracePrompt, + yyruleno, yyRuleName[yyruleno], + yyrulenoyytos[yysize].stateno); + }else{ + fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n", + yyTracePrompt, yyruleno, yyRuleName[yyruleno], + yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == + (int)(yypParser->yytos - yypParser->yystack)); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>=yypParser->yystackEnd ){ + yyStackOverflow(yypParser); + break; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ + if( yyGrowStack(yypParser) ){ + yyStackOverflow(yypParser); + break; + } + } +#endif + } + yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor sqlite3ParserCTX_PARAM); }else if( yyact <= YY_MAX_SHIFTREDUCE ){ yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor); #ifndef YYNOERRORRECOVERY @@ -159978,14 +164724,13 @@ SQLITE_PRIVATE void sqlite3Parser( yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion); yymajor = YYNOCODE; }else{ - while( yypParser->yytos >= yypParser->yystack - && (yyact = yy_find_reduce_action( - yypParser->yytos->stateno, - YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE - ){ + while( yypParser->yytos > yypParser->yystack ){ + yyact = yy_find_reduce_action(yypParser->yytos->stateno, + YYERRORSYMBOL); + if( yyact<=YY_MAX_SHIFTREDUCE ) break; yy_pop_parser_stack(yypParser); } - if( yypParser->yytos < yypParser->yystack || yymajor==0 ){ + if( yypParser->yytos <= yypParser->yystack || yymajor==0 ){ yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); yy_parse_failed(yypParser); #ifndef YYNOERRORRECOVERY @@ -160035,7 +164780,7 @@ SQLITE_PRIVATE void sqlite3Parser( break; #endif } - }while( yypParser->yytos>yypParser->yystack ); + } #ifndef NDEBUG if( yyTraceFILE ){ yyStackEntry *i; @@ -160096,8 +164841,8 @@ SQLITE_PRIVATE int sqlite3ParserFallback(int iToken){ ** all of them need to be used within the switch. */ #define CC_X 0 /* The letter 'x', or start of BLOB literal */ -#define CC_KYWD 1 /* Alphabetics or '_'. Usable in a keyword */ -#define CC_ID 2 /* unicode characters usable in IDs */ +#define CC_KYWD0 1 /* First letter of a keyword */ +#define CC_KYWD 2 /* Alphabetics or '_'. Usable in a keyword */ #define CC_DIGIT 3 /* Digits */ #define CC_DOLLAR 4 /* '$' */ #define CC_VARALPHA 5 /* '@', '#', ':'. Alphabetic SQL variables */ @@ -160122,47 +164867,49 @@ SQLITE_PRIVATE int sqlite3ParserFallback(int iToken){ #define CC_AND 24 /* '&' */ #define CC_TILDA 25 /* '~' */ #define CC_DOT 26 /* '.' */ -#define CC_ILLEGAL 27 /* Illegal character */ -#define CC_NUL 28 /* 0x00 */ +#define CC_ID 27 /* unicode characters usable in IDs */ +#define CC_ILLEGAL 28 /* Illegal character */ +#define CC_NUL 29 /* 0x00 */ +#define CC_BOM 30 /* First byte of UTF8 BOM: 0xEF 0xBB 0xBF */ static const unsigned char aiClass[] = { #ifdef SQLITE_ASCII /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */ -/* 0x */ 28, 27, 27, 27, 27, 27, 27, 27, 27, 7, 7, 27, 7, 7, 27, 27, -/* 1x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* 0x */ 29, 28, 28, 28, 28, 28, 28, 28, 28, 7, 7, 28, 7, 7, 28, 28, +/* 1x */ 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, /* 2x */ 7, 15, 8, 5, 4, 22, 24, 8, 17, 18, 21, 20, 23, 11, 26, 16, /* 3x */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 19, 12, 14, 13, 6, /* 4x */ 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -/* 5x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 9, 27, 27, 27, 1, +/* 5x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 9, 28, 28, 28, 2, /* 6x */ 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -/* 7x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 27, 10, 27, 25, 27, -/* 8x */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -/* 9x */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -/* Ax */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -/* Bx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -/* Cx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -/* Dx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -/* Ex */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -/* Fx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 +/* 7x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 28, 10, 28, 25, 28, +/* 8x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* 9x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Ax */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Bx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Cx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Dx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Ex */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 30, +/* Fx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27 #endif #ifdef SQLITE_EBCDIC /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */ -/* 0x */ 27, 27, 27, 27, 27, 7, 27, 27, 27, 27, 27, 27, 7, 7, 27, 27, -/* 1x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -/* 2x */ 27, 27, 27, 27, 27, 7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -/* 3x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -/* 4x */ 7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 12, 17, 20, 10, -/* 5x */ 24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 15, 4, 21, 18, 19, 27, -/* 6x */ 11, 16, 27, 27, 27, 27, 27, 27, 27, 27, 27, 23, 22, 1, 13, 6, -/* 7x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 8, 5, 5, 5, 8, 14, 8, -/* 8x */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, -/* 9x */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, -/* Ax */ 27, 25, 1, 1, 1, 1, 1, 0, 1, 1, 27, 27, 27, 27, 27, 27, -/* Bx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 9, 27, 27, 27, 27, 27, -/* Cx */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, -/* Dx */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, -/* Ex */ 27, 27, 1, 1, 1, 1, 1, 0, 1, 1, 27, 27, 27, 27, 27, 27, -/* Fx */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 27, 27, 27, 27, 27, 27, +/* 0x */ 29, 28, 28, 28, 28, 7, 28, 28, 28, 28, 28, 28, 7, 7, 28, 28, +/* 1x */ 28, 28, 28, 28, 28, 7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +/* 2x */ 28, 28, 28, 28, 28, 7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +/* 3x */ 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +/* 4x */ 7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 26, 12, 17, 20, 10, +/* 5x */ 24, 28, 28, 28, 28, 28, 28, 28, 28, 28, 15, 4, 21, 18, 19, 28, +/* 6x */ 11, 16, 28, 28, 28, 28, 28, 28, 28, 28, 28, 23, 22, 2, 13, 6, +/* 7x */ 28, 28, 28, 28, 28, 28, 28, 28, 28, 8, 5, 5, 5, 8, 14, 8, +/* 8x */ 28, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28, 28, +/* 9x */ 28, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28, 28, +/* Ax */ 28, 25, 1, 1, 1, 1, 1, 0, 2, 2, 28, 28, 28, 28, 28, 28, +/* Bx */ 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 9, 28, 28, 28, 28, 28, +/* Cx */ 28, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28, 28, +/* Dx */ 28, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28, 28, +/* Ex */ 28, 28, 1, 1, 1, 1, 1, 0, 2, 2, 28, 28, 28, 28, 28, 28, +/* Fx */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 28, 28, 28, 28, 28, 28, #endif }; @@ -160227,20 +164974,21 @@ const unsigned char ebcdicToAscii[] = { ** is substantially reduced. This is important for embedded applications ** on platforms with limited memory. */ -/* Hash score: 227 */ -/* zKWText[] encodes 984 bytes of keyword text in 648 bytes */ +/* Hash score: 231 */ +/* zKWText[] encodes 1007 bytes of keyword text in 667 bytes */ /* REINDEXEDESCAPEACHECKEYBEFOREIGNOREGEXPLAINSTEADDATABASELECT */ /* ABLEFTHENDEFERRABLELSEXCLUDELETEMPORARYISNULLSAVEPOINTERSECT */ /* IESNOTNULLIKEXCEPTRANSACTIONATURALTERAISEXCLUSIVEXISTS */ /* CONSTRAINTOFFSETRIGGERANGENERATEDETACHAVINGLOBEGINNEREFERENCES */ /* UNIQUERYWITHOUTERELEASEATTACHBETWEENOTHINGROUPSCASCADEFAULT */ /* CASECOLLATECREATECURRENT_DATEIMMEDIATEJOINSERTMATCHPLANALYZE */ -/* PRAGMABORTUPDATEVALUESVIRTUALWAYSWHENWHERECURSIVEAFTERENAMEAND */ -/* EFERREDISTINCTAUTOINCREMENTCASTCOLUMNCOMMITCONFLICTCROSS */ -/* CURRENT_TIMESTAMPARTITIONDROPRECEDINGFAILASTFILTEREPLACEFIRST */ -/* FOLLOWINGFROMFULLIMITIFORDERESTRICTOTHERSOVERIGHTROLLBACKROWS */ -/* UNBOUNDEDUNIONUSINGVACUUMVIEWINDOWBYINITIALLYPRIMARY */ -static const char zKWText[647] = { +/* PRAGMATERIALIZEDEFERREDISTINCTUPDATEVALUESVIRTUALWAYSWHENWHERE */ +/* CURSIVEABORTAFTERENAMEANDROPARTITIONAUTOINCREMENTCASTCOLUMN */ +/* COMMITCONFLICTCROSSCURRENT_TIMESTAMPRECEDINGFAILASTFILTER */ +/* EPLACEFIRSTFOLLOWINGFROMFULLIMITIFORDERESTRICTOTHERSOVER */ +/* ETURNINGRIGHTROLLBACKROWSUNBOUNDEDUNIONUSINGVACUUMVIEWINDOWBY */ +/* INITIALLYPRIMARY */ +static const char zKWText[666] = { 'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H', 'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G', 'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A', @@ -160261,86 +165009,87 @@ static const char zKWText[647] = { 'C','R','E','A','T','E','C','U','R','R','E','N','T','_','D','A','T','E', 'I','M','M','E','D','I','A','T','E','J','O','I','N','S','E','R','T','M', 'A','T','C','H','P','L','A','N','A','L','Y','Z','E','P','R','A','G','M', - 'A','B','O','R','T','U','P','D','A','T','E','V','A','L','U','E','S','V', - 'I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H','E','R', - 'E','C','U','R','S','I','V','E','A','F','T','E','R','E','N','A','M','E', - 'A','N','D','E','F','E','R','R','E','D','I','S','T','I','N','C','T','A', - 'U','T','O','I','N','C','R','E','M','E','N','T','C','A','S','T','C','O', - 'L','U','M','N','C','O','M','M','I','T','C','O','N','F','L','I','C','T', - 'C','R','O','S','S','C','U','R','R','E','N','T','_','T','I','M','E','S', - 'T','A','M','P','A','R','T','I','T','I','O','N','D','R','O','P','R','E', - 'C','E','D','I','N','G','F','A','I','L','A','S','T','F','I','L','T','E', - 'R','E','P','L','A','C','E','F','I','R','S','T','F','O','L','L','O','W', - 'I','N','G','F','R','O','M','F','U','L','L','I','M','I','T','I','F','O', - 'R','D','E','R','E','S','T','R','I','C','T','O','T','H','E','R','S','O', - 'V','E','R','I','G','H','T','R','O','L','L','B','A','C','K','R','O','W', - 'S','U','N','B','O','U','N','D','E','D','U','N','I','O','N','U','S','I', - 'N','G','V','A','C','U','U','M','V','I','E','W','I','N','D','O','W','B', - 'Y','I','N','I','T','I','A','L','L','Y','P','R','I','M','A','R','Y', + 'A','T','E','R','I','A','L','I','Z','E','D','E','F','E','R','R','E','D', + 'I','S','T','I','N','C','T','U','P','D','A','T','E','V','A','L','U','E', + 'S','V','I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H', + 'E','R','E','C','U','R','S','I','V','E','A','B','O','R','T','A','F','T', + 'E','R','E','N','A','M','E','A','N','D','R','O','P','A','R','T','I','T', + 'I','O','N','A','U','T','O','I','N','C','R','E','M','E','N','T','C','A', + 'S','T','C','O','L','U','M','N','C','O','M','M','I','T','C','O','N','F', + 'L','I','C','T','C','R','O','S','S','C','U','R','R','E','N','T','_','T', + 'I','M','E','S','T','A','M','P','R','E','C','E','D','I','N','G','F','A', + 'I','L','A','S','T','F','I','L','T','E','R','E','P','L','A','C','E','F', + 'I','R','S','T','F','O','L','L','O','W','I','N','G','F','R','O','M','F', + 'U','L','L','I','M','I','T','I','F','O','R','D','E','R','E','S','T','R', + 'I','C','T','O','T','H','E','R','S','O','V','E','R','E','T','U','R','N', + 'I','N','G','R','I','G','H','T','R','O','L','L','B','A','C','K','R','O', + 'W','S','U','N','B','O','U','N','D','E','D','U','N','I','O','N','U','S', + 'I','N','G','V','A','C','U','U','M','V','I','E','W','I','N','D','O','W', + 'B','Y','I','N','I','T','I','A','L','L','Y','P','R','I','M','A','R','Y', }; /* aKWHash[i] is the hash value for the i-th keyword */ static const unsigned char aKWHash[127] = { - 84, 102, 132, 82, 114, 29, 0, 0, 91, 0, 85, 72, 0, - 53, 35, 86, 15, 0, 42, 94, 54, 126, 133, 19, 0, 0, - 138, 0, 40, 128, 0, 22, 104, 0, 9, 0, 0, 122, 80, - 0, 78, 6, 0, 65, 99, 145, 0, 134, 112, 0, 0, 48, - 0, 100, 24, 0, 17, 0, 27, 70, 23, 26, 5, 60, 140, - 107, 121, 0, 73, 101, 71, 143, 61, 119, 74, 0, 49, 0, - 11, 41, 0, 110, 0, 0, 0, 106, 10, 108, 113, 124, 14, - 50, 123, 0, 89, 0, 18, 120, 142, 56, 129, 137, 88, 83, - 37, 30, 125, 0, 0, 105, 51, 130, 127, 0, 34, 0, 0, - 44, 0, 95, 38, 39, 0, 20, 45, 116, 90, + 84, 92, 134, 82, 105, 29, 0, 0, 94, 0, 85, 72, 0, + 53, 35, 86, 15, 0, 42, 97, 54, 89, 135, 19, 0, 0, + 140, 0, 40, 129, 0, 22, 107, 0, 9, 0, 0, 123, 80, + 0, 78, 6, 0, 65, 103, 147, 0, 136, 115, 0, 0, 48, + 0, 90, 24, 0, 17, 0, 27, 70, 23, 26, 5, 60, 142, + 110, 122, 0, 73, 91, 71, 145, 61, 120, 74, 0, 49, 0, + 11, 41, 0, 113, 0, 0, 0, 109, 10, 111, 116, 125, 14, + 50, 124, 0, 100, 0, 18, 121, 144, 56, 130, 139, 88, 83, + 37, 30, 126, 0, 0, 108, 51, 131, 128, 0, 34, 0, 0, + 132, 0, 98, 38, 39, 0, 20, 45, 117, 93, }; /* aKWNext[] forms the hash collision chain. If aKWHash[i]==0 ** then the i-th keyword has no more hash collisions. Otherwise, ** the next keyword with the same hash is aKWHash[i]-1. */ -static const unsigned char aKWNext[145] = { - 0, 0, 0, 0, 4, 0, 43, 0, 0, 103, 111, 0, 0, - 0, 2, 0, 0, 141, 0, 0, 0, 13, 0, 0, 0, 0, - 139, 0, 0, 118, 52, 0, 0, 135, 12, 0, 0, 62, 0, - 136, 0, 131, 0, 0, 36, 0, 0, 28, 77, 0, 0, 0, +static const unsigned char aKWNext[147] = { + 0, 0, 0, 0, 4, 0, 43, 0, 0, 106, 114, 0, 0, + 0, 2, 0, 0, 143, 0, 0, 0, 13, 0, 0, 0, 0, + 141, 0, 0, 119, 52, 0, 0, 137, 12, 0, 0, 62, 0, + 138, 0, 133, 0, 0, 36, 0, 0, 28, 77, 0, 0, 0, 0, 59, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 69, 0, 0, 0, 0, 0, 144, 3, 0, 58, 0, 1, - 75, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 64, 66, - 63, 0, 0, 0, 0, 46, 0, 16, 0, 115, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 81, 97, 0, 8, 0, 109, - 21, 7, 67, 0, 79, 93, 117, 0, 0, 68, 0, 0, 96, - 0, 55, 0, 76, 0, 92, 32, 33, 57, 25, 0, 98, 0, - 0, 87, + 0, 69, 0, 0, 0, 0, 0, 146, 3, 0, 58, 0, 1, + 75, 0, 0, 0, 31, 0, 0, 0, 0, 0, 127, 0, 104, + 0, 64, 66, 63, 0, 0, 0, 0, 0, 46, 0, 16, 8, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 81, 101, 0, + 112, 21, 7, 67, 0, 79, 96, 118, 0, 0, 68, 0, 0, + 99, 44, 0, 55, 0, 76, 0, 95, 32, 33, 57, 25, 0, + 102, 0, 0, 87, }; /* aKWLen[i] is the length (in bytes) of the i-th keyword */ -static const unsigned char aKWLen[145] = { +static const unsigned char aKWLen[147] = { 7, 7, 5, 4, 6, 4, 5, 3, 6, 7, 3, 6, 6, 7, 7, 3, 8, 2, 6, 5, 4, 4, 3, 10, 4, 7, 6, 9, 4, 2, 6, 5, 9, 9, 4, 7, 3, 2, 4, 4, 6, 11, 6, 2, 7, 5, 5, 9, 6, 10, 4, 6, 2, 3, 7, 5, 9, 6, 6, 4, 5, 5, 10, 6, 5, 7, 4, 5, 7, 6, 7, 7, 6, 5, 7, 3, 7, 4, - 7, 6, 12, 9, 4, 6, 5, 4, 7, 6, 5, 6, 6, - 7, 6, 4, 5, 9, 5, 6, 3, 8, 8, 2, 13, 2, - 2, 4, 6, 6, 8, 5, 17, 12, 7, 9, 4, 9, 4, - 4, 6, 7, 5, 9, 4, 4, 5, 2, 5, 8, 6, 4, - 5, 8, 4, 3, 9, 5, 5, 6, 4, 6, 2, 2, 9, - 3, 7, + 7, 6, 12, 9, 4, 6, 5, 4, 7, 6, 12, 8, 8, + 2, 6, 6, 7, 6, 4, 5, 9, 5, 5, 6, 3, 4, + 9, 13, 2, 2, 4, 6, 6, 8, 5, 17, 12, 7, 9, + 4, 4, 6, 7, 5, 9, 4, 4, 5, 2, 5, 8, 6, + 4, 9, 5, 8, 4, 3, 9, 5, 5, 6, 4, 6, 2, + 2, 9, 3, 7, }; /* aKWOffset[i] is the index into zKWText[] of the start of ** the text for the i-th keyword. */ -static const unsigned short int aKWOffset[145] = { +static const unsigned short int aKWOffset[147] = { 0, 2, 2, 8, 9, 14, 16, 20, 23, 25, 25, 29, 33, 36, 41, 46, 48, 53, 54, 59, 62, 65, 67, 69, 78, 81, 86, 90, 90, 94, 99, 101, 105, 111, 119, 123, 123, 123, 126, 129, 132, 137, 142, 146, 147, 152, 156, 160, 168, 174, 181, 184, 184, 187, 189, 195, 198, 206, 211, 216, 219, 222, 226, 236, 239, 244, 244, 248, 252, 259, 265, 271, 277, 277, 283, 284, 288, 295, - 299, 306, 312, 324, 333, 335, 341, 346, 348, 355, 360, 365, 371, - 377, 382, 388, 392, 395, 404, 408, 414, 416, 423, 424, 431, 433, - 435, 444, 448, 454, 460, 468, 473, 473, 473, 489, 498, 501, 510, - 513, 517, 522, 529, 534, 543, 547, 550, 555, 557, 561, 569, 575, - 578, 583, 591, 591, 595, 604, 609, 614, 620, 623, 626, 629, 631, - 636, 640, + 299, 306, 312, 324, 333, 335, 341, 346, 348, 355, 359, 370, 377, + 378, 385, 391, 397, 402, 408, 412, 415, 424, 429, 433, 439, 441, + 444, 453, 455, 457, 466, 470, 476, 482, 490, 495, 495, 495, 511, + 520, 523, 527, 532, 539, 544, 553, 557, 560, 565, 567, 571, 579, + 585, 588, 597, 602, 610, 610, 614, 623, 628, 633, 639, 642, 645, + 648, 650, 655, 659, }; /* aKWCode[i] is the parser symbol code for the i-th keyword */ -static const unsigned char aKWCode[145] = { +static const unsigned char aKWCode[147] = { TK_REINDEX, TK_INDEXED, TK_INDEX, TK_DESC, TK_ESCAPE, TK_EACH, TK_CHECK, TK_KEY, TK_BEFORE, TK_FOREIGN, TK_FOR, TK_IGNORE, TK_LIKE_KW, TK_EXPLAIN, TK_INSTEAD, @@ -160358,18 +165107,19 @@ static const unsigned char aKWCode[145] = { TK_BETWEEN, TK_NOTHING, TK_GROUPS, TK_GROUP, TK_CASCADE, TK_ASC, TK_DEFAULT, TK_CASE, TK_COLLATE, TK_CREATE, TK_CTIME_KW, TK_IMMEDIATE, TK_JOIN, TK_INSERT, TK_MATCH, - TK_PLAN, TK_ANALYZE, TK_PRAGMA, TK_ABORT, TK_UPDATE, - TK_VALUES, TK_VIRTUAL, TK_ALWAYS, TK_WHEN, TK_WHERE, - TK_RECURSIVE, TK_AFTER, TK_RENAME, TK_AND, TK_DEFERRED, - TK_DISTINCT, TK_IS, TK_AUTOINCR, TK_TO, TK_IN, - TK_CAST, TK_COLUMNKW, TK_COMMIT, TK_CONFLICT, TK_JOIN_KW, - TK_CTIME_KW, TK_CTIME_KW, TK_CURRENT, TK_PARTITION, TK_DROP, - TK_PRECEDING, TK_FAIL, TK_LAST, TK_FILTER, TK_REPLACE, - TK_FIRST, TK_FOLLOWING, TK_FROM, TK_JOIN_KW, TK_LIMIT, - TK_IF, TK_ORDER, TK_RESTRICT, TK_OTHERS, TK_OVER, - TK_JOIN_KW, TK_ROLLBACK, TK_ROWS, TK_ROW, TK_UNBOUNDED, - TK_UNION, TK_USING, TK_VACUUM, TK_VIEW, TK_WINDOW, - TK_DO, TK_BY, TK_INITIALLY, TK_ALL, TK_PRIMARY, + TK_PLAN, TK_ANALYZE, TK_PRAGMA, TK_MATERIALIZED, TK_DEFERRED, + TK_DISTINCT, TK_IS, TK_UPDATE, TK_VALUES, TK_VIRTUAL, + TK_ALWAYS, TK_WHEN, TK_WHERE, TK_RECURSIVE, TK_ABORT, + TK_AFTER, TK_RENAME, TK_AND, TK_DROP, TK_PARTITION, + TK_AUTOINCR, TK_TO, TK_IN, TK_CAST, TK_COLUMNKW, + TK_COMMIT, TK_CONFLICT, TK_JOIN_KW, TK_CTIME_KW, TK_CTIME_KW, + TK_CURRENT, TK_PRECEDING, TK_FAIL, TK_LAST, TK_FILTER, + TK_REPLACE, TK_FIRST, TK_FOLLOWING, TK_FROM, TK_JOIN_KW, + TK_LIMIT, TK_IF, TK_ORDER, TK_RESTRICT, TK_OTHERS, + TK_OVER, TK_RETURNING, TK_JOIN_KW, TK_ROLLBACK, TK_ROWS, + TK_ROW, TK_UNBOUNDED, TK_UNION, TK_USING, TK_VACUUM, + TK_VIEW, TK_WINDOW, TK_DO, TK_BY, TK_INITIALLY, + TK_ALL, TK_PRIMARY, }; /* Hash table decoded: ** 0: INSERT @@ -160393,7 +165143,7 @@ static const unsigned char aKWCode[145] = { ** 18: TRANSACTION RIGHT ** 19: WHEN ** 20: SET HAVING -** 21: IF +** 21: MATERIALIZED IF ** 22: ROWS ** 23: SELECT ** 24: @@ -160489,7 +165239,7 @@ static const unsigned char aKWCode[145] = { ** 114: INTERSECT UNBOUNDED ** 115: ** 116: -** 117: ON +** 117: RETURNING ON ** 118: ** 119: WHERE ** 120: NO INNER @@ -160507,7 +165257,7 @@ static int keywordCode(const char *z, int n, int *pType){ int i, j; const char *zKW; if( n>=2 ){ - i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n) % 127; + i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n*1) % 127; for(i=((int)aKWHash[i])-1; i>=0; i=((int)aKWNext[i])-1){ if( aKWLen[i]!=n ) continue; zKW = &zKWText[aKWOffset[i]]; @@ -160612,63 +165362,65 @@ static int keywordCode(const char *z, int n, int *pType){ testcase( i==85 ); /* PLAN */ testcase( i==86 ); /* ANALYZE */ testcase( i==87 ); /* PRAGMA */ - testcase( i==88 ); /* ABORT */ - testcase( i==89 ); /* UPDATE */ - testcase( i==90 ); /* VALUES */ - testcase( i==91 ); /* VIRTUAL */ - testcase( i==92 ); /* ALWAYS */ - testcase( i==93 ); /* WHEN */ - testcase( i==94 ); /* WHERE */ - testcase( i==95 ); /* RECURSIVE */ - testcase( i==96 ); /* AFTER */ - testcase( i==97 ); /* RENAME */ - testcase( i==98 ); /* AND */ - testcase( i==99 ); /* DEFERRED */ - testcase( i==100 ); /* DISTINCT */ - testcase( i==101 ); /* IS */ - testcase( i==102 ); /* AUTOINCREMENT */ - testcase( i==103 ); /* TO */ - testcase( i==104 ); /* IN */ - testcase( i==105 ); /* CAST */ - testcase( i==106 ); /* COLUMN */ - testcase( i==107 ); /* COMMIT */ - testcase( i==108 ); /* CONFLICT */ - testcase( i==109 ); /* CROSS */ - testcase( i==110 ); /* CURRENT_TIMESTAMP */ - testcase( i==111 ); /* CURRENT_TIME */ - testcase( i==112 ); /* CURRENT */ - testcase( i==113 ); /* PARTITION */ - testcase( i==114 ); /* DROP */ - testcase( i==115 ); /* PRECEDING */ - testcase( i==116 ); /* FAIL */ - testcase( i==117 ); /* LAST */ - testcase( i==118 ); /* FILTER */ - testcase( i==119 ); /* REPLACE */ - testcase( i==120 ); /* FIRST */ - testcase( i==121 ); /* FOLLOWING */ - testcase( i==122 ); /* FROM */ - testcase( i==123 ); /* FULL */ - testcase( i==124 ); /* LIMIT */ - testcase( i==125 ); /* IF */ - testcase( i==126 ); /* ORDER */ - testcase( i==127 ); /* RESTRICT */ - testcase( i==128 ); /* OTHERS */ - testcase( i==129 ); /* OVER */ - testcase( i==130 ); /* RIGHT */ - testcase( i==131 ); /* ROLLBACK */ - testcase( i==132 ); /* ROWS */ - testcase( i==133 ); /* ROW */ - testcase( i==134 ); /* UNBOUNDED */ - testcase( i==135 ); /* UNION */ - testcase( i==136 ); /* USING */ - testcase( i==137 ); /* VACUUM */ - testcase( i==138 ); /* VIEW */ - testcase( i==139 ); /* WINDOW */ - testcase( i==140 ); /* DO */ - testcase( i==141 ); /* BY */ - testcase( i==142 ); /* INITIALLY */ - testcase( i==143 ); /* ALL */ - testcase( i==144 ); /* PRIMARY */ + testcase( i==88 ); /* MATERIALIZED */ + testcase( i==89 ); /* DEFERRED */ + testcase( i==90 ); /* DISTINCT */ + testcase( i==91 ); /* IS */ + testcase( i==92 ); /* UPDATE */ + testcase( i==93 ); /* VALUES */ + testcase( i==94 ); /* VIRTUAL */ + testcase( i==95 ); /* ALWAYS */ + testcase( i==96 ); /* WHEN */ + testcase( i==97 ); /* WHERE */ + testcase( i==98 ); /* RECURSIVE */ + testcase( i==99 ); /* ABORT */ + testcase( i==100 ); /* AFTER */ + testcase( i==101 ); /* RENAME */ + testcase( i==102 ); /* AND */ + testcase( i==103 ); /* DROP */ + testcase( i==104 ); /* PARTITION */ + testcase( i==105 ); /* AUTOINCREMENT */ + testcase( i==106 ); /* TO */ + testcase( i==107 ); /* IN */ + testcase( i==108 ); /* CAST */ + testcase( i==109 ); /* COLUMN */ + testcase( i==110 ); /* COMMIT */ + testcase( i==111 ); /* CONFLICT */ + testcase( i==112 ); /* CROSS */ + testcase( i==113 ); /* CURRENT_TIMESTAMP */ + testcase( i==114 ); /* CURRENT_TIME */ + testcase( i==115 ); /* CURRENT */ + testcase( i==116 ); /* PRECEDING */ + testcase( i==117 ); /* FAIL */ + testcase( i==118 ); /* LAST */ + testcase( i==119 ); /* FILTER */ + testcase( i==120 ); /* REPLACE */ + testcase( i==121 ); /* FIRST */ + testcase( i==122 ); /* FOLLOWING */ + testcase( i==123 ); /* FROM */ + testcase( i==124 ); /* FULL */ + testcase( i==125 ); /* LIMIT */ + testcase( i==126 ); /* IF */ + testcase( i==127 ); /* ORDER */ + testcase( i==128 ); /* RESTRICT */ + testcase( i==129 ); /* OTHERS */ + testcase( i==130 ); /* OVER */ + testcase( i==131 ); /* RETURNING */ + testcase( i==132 ); /* RIGHT */ + testcase( i==133 ); /* ROLLBACK */ + testcase( i==134 ); /* ROWS */ + testcase( i==135 ); /* ROW */ + testcase( i==136 ); /* UNBOUNDED */ + testcase( i==137 ); /* UNION */ + testcase( i==138 ); /* USING */ + testcase( i==139 ); /* VACUUM */ + testcase( i==140 ); /* VIEW */ + testcase( i==141 ); /* WINDOW */ + testcase( i==142 ); /* DO */ + testcase( i==143 ); /* BY */ + testcase( i==144 ); /* INITIALLY */ + testcase( i==145 ); /* ALL */ + testcase( i==146 ); /* PRIMARY */ *pType = aKWCode[i]; break; } @@ -160680,7 +165432,7 @@ SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){ keywordCode((char*)z, n, &id); return id; } -#define SQLITE_N_KEYWORD 145 +#define SQLITE_N_KEYWORD 147 SQLITE_API int sqlite3_keyword_name(int i,const char **pzName,int *pnName){ if( i<0 || i>=SQLITE_N_KEYWORD ) return SQLITE_ERROR; *pzName = zKWText + aKWOffset[i]; @@ -161049,7 +165801,7 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){ if( n==0 ) *tokenType = TK_ILLEGAL; return i; } - case CC_KYWD: { + case CC_KYWD0: { for(i=1; aiClass[z[i]]<=CC_KYWD; i++){} if( IdChar(z[i]) ){ /* This token started out using characters that can appear in keywords, @@ -161079,10 +165831,19 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){ ** SQL keywords start with the letter 'x'. Fall through */ /* no break */ deliberate_fall_through } + case CC_KYWD: case CC_ID: { i = 1; break; } + case CC_BOM: { + if( z[1]==0xbb && z[2]==0xbf ){ + *tokenType = TK_SPACE; + return 3; + } + i = 1; + break; + } case CC_NUL: { *tokenType = TK_ILLEGAL; return 0; @@ -161112,6 +165873,7 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr int lastTokenParsed = -1; /* type of the previous token */ sqlite3 *db = pParse->db; /* The database connection */ int mxSqlLen; /* Max length of an SQL string */ + Parse *pParentParse = 0; /* Outer parse context, if any */ #ifdef sqlite3Parser_ENGINEALWAYSONSTACK yyParser sEngine; /* Space to hold the Lemon-generated Parser object */ #endif @@ -161147,7 +165909,7 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr assert( pParse->pNewTrigger==0 ); assert( pParse->nVar==0 ); assert( pParse->pVList==0 ); - pParse->pParentParse = db->pParse; + pParentParse = db->pParse; db->pParse = pParse; while( 1 ){ n = sqlite3GetToken((u8*)zSql, &tokenType); @@ -161261,21 +166023,8 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr if( !IN_RENAME_OBJECT ){ sqlite3DeleteTrigger(db, pParse->pNewTrigger); } - - if( pParse->pWithToFree ) sqlite3WithDelete(db, pParse->pWithToFree); sqlite3DbFree(db, pParse->pVList); - while( pParse->pAinc ){ - AutoincInfo *p = pParse->pAinc; - pParse->pAinc = p->pNext; - sqlite3DbFreeNN(db, p); - } - while( pParse->pZombieTab ){ - Table *p = pParse->pZombieTab; - pParse->pZombieTab = p->pNextZombie; - sqlite3DeleteTable(db, p); - } - db->pParse = pParse->pParentParse; - pParse->pParentParse = 0; + db->pParse = pParentParse; assert( nErr==0 || pParse->rc!=SQLITE_OK ); return nErr; } @@ -162111,7 +166860,7 @@ SQLITE_API int sqlite3_initialize(void){ sqlite3GlobalConfig.isPCacheInit = 1; rc = sqlite3OsInit(); } -#ifdef SQLITE_ENABLE_DESERIALIZE +#ifndef SQLITE_OMIT_DESERIALIZE if( rc==SQLITE_OK ){ rc = sqlite3MemdbInit(); } @@ -162526,12 +167275,12 @@ SQLITE_API int sqlite3_config(int op, ...){ } #endif /* SQLITE_ENABLE_SORTER_REFERENCES */ -#ifdef SQLITE_ENABLE_DESERIALIZE +#ifndef SQLITE_OMIT_DESERIALIZE case SQLITE_CONFIG_MEMDB_MAXSIZE: { sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64); break; } -#endif /* SQLITE_ENABLE_DESERIALIZE */ +#endif /* SQLITE_OMIT_DESERIALIZE */ default: { rc = SQLITE_ERROR; @@ -162892,7 +167641,7 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid) /* ** Return the number of changes in the most recent call to sqlite3_exec(). */ -SQLITE_API int sqlite3_changes(sqlite3 *db){ +SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3 *db){ #ifdef SQLITE_ENABLE_API_ARMOR if( !sqlite3SafetyCheckOk(db) ){ (void)SQLITE_MISUSE_BKPT; @@ -162901,11 +167650,14 @@ SQLITE_API int sqlite3_changes(sqlite3 *db){ #endif return db->nChange; } +SQLITE_API int sqlite3_changes(sqlite3 *db){ + return (int)sqlite3_changes64(db); +} /* ** Return the number of changes since the database handle was opened. */ -SQLITE_API int sqlite3_total_changes(sqlite3 *db){ +SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3 *db){ #ifdef SQLITE_ENABLE_API_ARMOR if( !sqlite3SafetyCheckOk(db) ){ (void)SQLITE_MISUSE_BKPT; @@ -162914,6 +167666,9 @@ SQLITE_API int sqlite3_total_changes(sqlite3 *db){ #endif return db->nTotalChange; } +SQLITE_API int sqlite3_total_changes(sqlite3 *db){ + return (int)sqlite3_total_changes64(db); +} /* ** Close all open savepoints. This function only manipulates fields of the @@ -162938,7 +167693,9 @@ SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){ ** with SQLITE_ANY as the encoding. */ static void functionDestroy(sqlite3 *db, FuncDef *p){ - FuncDestructor *pDestructor = p->u.pDestructor; + FuncDestructor *pDestructor; + assert( (p->funcFlags & SQLITE_FUNC_BUILTIN)==0 ); + pDestructor = p->u.pDestructor; if( pDestructor ){ pDestructor->nRef--; if( pDestructor->nRef==0 ){ @@ -163042,7 +167799,7 @@ static int sqlite3Close(sqlite3 *db, int forceZombie){ /* Convert the connection into a zombie and then close it. */ - db->magic = SQLITE_MAGIC_ZOMBIE; + db->eOpenState = SQLITE_STATE_ZOMBIE; sqlite3LeaveMutexAndCloseZombie(db); return SQLITE_OK; } @@ -163080,7 +167837,7 @@ SQLITE_API int sqlite3_txn_state(sqlite3 *db, const char *zSchema){ /* ** Two variations on the public interface for closing a database ** connection. The sqlite3_close() version returns SQLITE_BUSY and -** leaves the connection option if there are unfinalized prepared +** leaves the connection open if there are unfinalized prepared ** statements or unfinished sqlite3_backups. The sqlite3_close_v2() ** version forces the connection to become a zombie if there are ** unclosed resources, and arranges for deallocation when the last @@ -163106,7 +167863,7 @@ SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){ ** or if the connection has not yet been closed by sqlite3_close_v2(), ** then just leave the mutex and return. */ - if( db->magic!=SQLITE_MAGIC_ZOMBIE || connectionIsBusy(db) ){ + if( db->eOpenState!=SQLITE_STATE_ZOMBIE || connectionIsBusy(db) ){ sqlite3_mutex_leave(db->mutex); return; } @@ -163192,7 +167949,7 @@ SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){ sqlite3_free(db->auth.zAuthPW); #endif - db->magic = SQLITE_MAGIC_ERROR; + db->eOpenState = SQLITE_STATE_ERROR; /* The temp-database schema is allocated differently from the other schema ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()). @@ -163201,8 +167958,11 @@ SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){ ** structure? */ sqlite3DbFree(db, db->aDb[1].pSchema); + if( db->xAutovacDestr ){ + db->xAutovacDestr(db->pAutovacPagesArg); + } sqlite3_mutex_leave(db->mutex); - db->magic = SQLITE_MAGIC_CLOSED; + db->eOpenState = SQLITE_STATE_CLOSED; sqlite3_mutex_free(db->mutex); assert( sqlite3LookasideUsed(db,0)==0 ); if( db->lookaside.bMalloced ){ @@ -163255,7 +168015,7 @@ SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){ /* Any deferred constraint violations have now been resolved. */ db->nDeferredCons = 0; db->nDeferredImmCons = 0; - db->flags &= ~(u64)SQLITE_DeferFKs; + db->flags &= ~(u64)(SQLITE_DeferFKs|SQLITE_CorruptRdOnly); /* If one has been configured, invoke the rollback-hook callback */ if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){ @@ -163590,7 +168350,7 @@ SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms){ */ SQLITE_API void sqlite3_interrupt(sqlite3 *db){ #ifdef SQLITE_ENABLE_API_ARMOR - if( !sqlite3SafetyCheckOk(db) && (db==0 || db->magic!=SQLITE_MAGIC_ZOMBIE) ){ + if( !sqlite3SafetyCheckOk(db) && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE) ){ (void)SQLITE_MISUSE_BKPT; return; } @@ -163619,7 +168379,6 @@ SQLITE_PRIVATE int sqlite3CreateFunc( FuncDestructor *pDestructor ){ FuncDef *p; - int nName; int extraFlags; assert( sqlite3_mutex_held(db->mutex) ); @@ -163629,7 +168388,7 @@ SQLITE_PRIVATE int sqlite3CreateFunc( || ((xFinal==0)!=(xStep==0)) /* Both or neither of xFinal and xStep */ || ((xValue==0)!=(xInverse==0)) /* Both or neither of xValue, xInverse */ || (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) - || (255<(nName = sqlite3Strlen30( zFunctionName))) + || (255nRef==0 ){ - assert( rc!=SQLITE_OK ); + assert( rc!=SQLITE_OK || (xStep==0 && xFinal==0) ); xDestroy(p); sqlite3_free(pArg); } @@ -164088,6 +168862,34 @@ SQLITE_API void *sqlite3_preupdate_hook( } #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ +/* +** Register a function to be invoked prior to each autovacuum that +** determines the number of pages to vacuum. +*/ +SQLITE_API int sqlite3_autovacuum_pages( + sqlite3 *db, /* Attach the hook to this database */ + unsigned int (*xCallback)(void*,const char*,u32,u32,u32), + void *pArg, /* Argument to the function */ + void (*xDestructor)(void*) /* Destructor for pArg */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + if( xDestructor ) xDestructor(pArg); + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( db->xAutovacDestr ){ + db->xAutovacDestr(db->pAutovacPagesArg); + } + db->xAutovacPages = xCallback; + db->pAutovacPagesArg = pArg; + db->xAutovacDestr = xDestructor; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + + #ifndef SQLITE_OMIT_WAL /* ** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint(). @@ -164180,7 +168982,7 @@ SQLITE_API int sqlite3_wal_checkpoint_v2( return SQLITE_OK; #else int rc; /* Return code */ - int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */ + int iDb; /* Schema to checkpoint */ #ifdef SQLITE_ENABLE_API_ARMOR if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; @@ -164203,6 +169005,8 @@ SQLITE_API int sqlite3_wal_checkpoint_v2( sqlite3_mutex_enter(db->mutex); if( zDb && zDb[0] ){ iDb = sqlite3FindDbName(db, zDb); + }else{ + iDb = SQLITE_MAX_DB; /* This means process all schemas */ } if( iDb<0 ){ rc = SQLITE_ERROR; @@ -164251,7 +169055,7 @@ SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){ ** associated with the specific b-tree being checkpointed is taken by ** this function while the checkpoint is running. ** -** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are +** If iDb is passed SQLITE_MAX_DB then all attached databases are ** checkpointed. If an error is encountered it is returned immediately - ** no attempt is made to checkpoint any remaining databases. ** @@ -164266,9 +169070,11 @@ SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog assert( sqlite3_mutex_held(db->mutex) ); assert( !pnLog || *pnLog==-1 ); assert( !pnCkpt || *pnCkpt==-1 ); + testcase( iDb==SQLITE_MAX_ATTACHED ); /* See forum post a006d86f72 */ + testcase( iDb==SQLITE_MAX_DB ); for(i=0; inDb && rc==SQLITE_OK; i++){ - if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){ + if( i==iDb || iDb==SQLITE_MAX_DB ){ rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt); pnLog = 0; pnCkpt = 0; @@ -164877,7 +169683,7 @@ SQLITE_PRIVATE int sqlite3ParseUri( */ static const char *uriParameter(const char *zFilename, const char *zParam){ zFilename += sqlite3Strlen30(zFilename) + 1; - while( zFilename[0] ){ + while( ALWAYS(zFilename!=0) && zFilename[0] ){ int x = strcmp(zFilename, zParam); zFilename += sqlite3Strlen30(zFilename) + 1; if( x==0 ) return zFilename; @@ -164937,8 +169743,8 @@ static int openDatabase( ** dealt with in the previous code block. Besides these, the only ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY, ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE, - ** SQLITE_OPEN_PRIVATECACHE, and some reserved bits. Silently mask - ** off all other flags. + ** SQLITE_OPEN_PRIVATECACHE, SQLITE_OPEN_EXRESCODE, and some reserved + ** bits. Silently mask off all other flags. */ flags &= ~( SQLITE_OPEN_DELETEONCLOSE | SQLITE_OPEN_EXCLUSIVE | @@ -164973,9 +169779,9 @@ static int openDatabase( } } sqlite3_mutex_enter(db->mutex); - db->errMask = 0xff; + db->errMask = (flags & SQLITE_OPEN_EXRESCODE)!=0 ? 0xffffffff : 0xff; db->nDb = 2; - db->magic = SQLITE_MAGIC_BUSY; + db->eOpenState = SQLITE_STATE_BUSY; db->aDb = db->aDbStatic; db->lookaside.bDisable = 1; db->lookaside.sz = 0; @@ -164987,7 +169793,15 @@ static int openDatabase( db->nextAutovac = -1; db->szMmap = sqlite3GlobalConfig.szMmap; db->nextPagesize = 0; + db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */ +#ifdef SQLITE_ENABLE_SORTER_MMAP + /* Beginning with version 3.37.0, using the VFS xFetch() API to memory-map + ** the temporary files used to do external sorts (see code in vdbesort.c) + ** is disabled. It can still be used either by defining + ** SQLITE_ENABLE_SORTER_MMAP at compile time or by using the + ** SQLITE_TESTCTRL_SORTER_MMAP test-control at runtime. */ db->nMaxSorterMmap = 0x7FFFFFFF; +#endif db->flags |= SQLITE_ShortColNames | SQLITE_EnableTrigger | SQLITE_EnableView @@ -165135,7 +169949,7 @@ static int openDatabase( db->aDb[1].zDbSName = "temp"; db->aDb[1].safety_level = PAGER_SYNCHRONOUS_OFF; - db->magic = SQLITE_MAGIC_OPEN; + db->eOpenState = SQLITE_STATE_OPEN; if( db->mallocFailed ){ goto opendb_out; } @@ -165197,12 +170011,12 @@ static int openDatabase( sqlite3_mutex_leave(db->mutex); } rc = sqlite3_errcode(db); - assert( db!=0 || rc==SQLITE_NOMEM ); - if( rc==SQLITE_NOMEM ){ + assert( db!=0 || (rc&0xff)==SQLITE_NOMEM ); + if( (rc&0xff)==SQLITE_NOMEM ){ sqlite3_close(db); db = 0; }else if( rc!=SQLITE_OK ){ - db->magic = SQLITE_MAGIC_SICK; + db->eOpenState = SQLITE_STATE_SICK; } *ppDb = db; #ifdef SQLITE_ENABLE_SQLLOG @@ -165213,7 +170027,7 @@ static int openDatabase( } #endif sqlite3_free_filename(zOpen); - return rc & 0xff; + return rc; } @@ -165513,7 +170327,7 @@ SQLITE_API int sqlite3_table_column_metadata( /* Locate the table in question */ pTab = sqlite3FindTable(db, zTableName, zDbName); - if( !pTab || pTab->pSelect ){ + if( !pTab || IsView(pTab) ){ pTab = 0; goto error_out; } @@ -165524,7 +170338,7 @@ SQLITE_API int sqlite3_table_column_metadata( }else{ for(iCol=0; iColnCol; iCol++){ pCol = &pTab->aCol[iCol]; - if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){ + if( 0==sqlite3StrICmp(pCol->zCnName, zColumnName) ){ break; } } @@ -165551,7 +170365,7 @@ SQLITE_API int sqlite3_table_column_metadata( */ if( pCol ){ zDataType = sqlite3ColumnType(pCol,0); - zCollSeq = pCol->zColl; + zCollSeq = sqlite3ColumnColl(pCol); notnull = pCol->notNull!=0; primarykey = (pCol->colFlags & COLFLAG_PRIMKEY)!=0; autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0; @@ -165886,7 +170700,7 @@ SQLITE_API int sqlite3_test_control(int op, ...){ */ case SQLITE_TESTCTRL_OPTIMIZATIONS: { sqlite3 *db = va_arg(ap, sqlite3*); - db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff); + db->dbOptFlags = va_arg(ap, u32); break; } @@ -166061,7 +170875,56 @@ SQLITE_API int sqlite3_test_control(int op, ...){ break; } + /* sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, op, ptr) + ** + ** "ptr" is a pointer to a u32. + ** + ** op==0 Store the current sqlite3SelectTrace in *ptr + ** op==1 Set sqlite3SelectTrace to the value *ptr + ** op==3 Store the current sqlite3WhereTrace in *ptr + ** op==3 Set sqlite3WhereTrace to the value *ptr + */ + case SQLITE_TESTCTRL_TRACEFLAGS: { + int opTrace = va_arg(ap, int); + u32 *ptr = va_arg(ap, u32*); + switch( opTrace ){ + case 0: *ptr = sqlite3SelectTrace; break; + case 1: sqlite3SelectTrace = *ptr; break; + case 2: *ptr = sqlite3WhereTrace; break; + case 3: sqlite3WhereTrace = *ptr; break; + } + break; + } +#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD) + /* sqlite3_test_control(SQLITE_TESTCTRL_TUNE, id, *piValue) + ** + ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value + ** of the id-th tuning parameter to *piValue. If "id" is between -1 + ** and -SQLITE_NTUNE, then write the current value of the (-id)-th + ** tuning parameter into *piValue. + ** + ** Tuning parameters are for use during transient development builds, + ** to help find the best values for constants in the query planner. + ** Access tuning parameters using the Tuning(ID) macro. Set the + ** parameters in the CLI using ".testctrl tune ID VALUE". + ** + ** Transient use only. Tuning parameters should not be used in + ** checked-in code. + */ + case SQLITE_TESTCTRL_TUNE: { + int id = va_arg(ap, int); + int *piValue = va_arg(ap, int*); + if( id>0 && id<=SQLITE_NTUNE ){ + Tuning(id) = *piValue; + }else if( id<0 && id>=-SQLITE_NTUNE ){ + *piValue = Tuning(-id); + }else{ + rc = SQLITE_NOTFOUND; + } + break; + } +#endif } va_end(ap); #endif /* SQLITE_UNTESTABLE */ @@ -166169,7 +171032,7 @@ SQLITE_API const char *sqlite3_uri_key(const char *zFilename, int N){ if( zFilename==0 || N<0 ) return 0; zFilename = databaseName(zFilename); zFilename += sqlite3Strlen30(zFilename) + 1; - while( zFilename[0] && (N--)>0 ){ + while( ALWAYS(zFilename) && zFilename[0] && (N--)>0 ){ zFilename += sqlite3Strlen30(zFilename) + 1; zFilename += sqlite3Strlen30(zFilename) + 1; } @@ -166212,12 +171075,14 @@ SQLITE_API sqlite3_int64 sqlite3_uri_int64( ** corruption. */ SQLITE_API const char *sqlite3_filename_database(const char *zFilename){ + if( zFilename==0 ) return 0; return databaseName(zFilename); } SQLITE_API const char *sqlite3_filename_journal(const char *zFilename){ + if( zFilename==0 ) return 0; zFilename = databaseName(zFilename); zFilename += sqlite3Strlen30(zFilename) + 1; - while( zFilename[0] ){ + while( ALWAYS(zFilename) && zFilename[0] ){ zFilename += sqlite3Strlen30(zFilename) + 1; zFilename += sqlite3Strlen30(zFilename) + 1; } @@ -166228,7 +171093,7 @@ SQLITE_API const char *sqlite3_filename_wal(const char *zFilename){ return 0; #else zFilename = sqlite3_filename_journal(zFilename); - zFilename += sqlite3Strlen30(zFilename) + 1; + if( zFilename ) zFilename += sqlite3Strlen30(zFilename) + 1; return zFilename; #endif } @@ -167504,7 +172369,7 @@ SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const voi ** is used for assert() conditions that are true only if it can be ** guranteed that the database is not corrupt. */ -#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) +#ifdef SQLITE_DEBUG SQLITE_API extern int sqlite3_fts3_may_be_corrupt; # define assert_fts3_nc(x) assert(sqlite3_fts3_may_be_corrupt || (x)) #else @@ -167521,17 +172386,18 @@ SQLITE_API extern int sqlite3_fts3_may_be_corrupt; ** Macros indicating that conditional expressions are always true or ** false. */ -#ifdef SQLITE_COVERAGE_TEST -# define ALWAYS(x) (1) -# define NEVER(X) (0) -#elif defined(SQLITE_DEBUG) -# define ALWAYS(x) sqlite3Fts3Always((x)!=0) -# define NEVER(x) sqlite3Fts3Never((x)!=0) -SQLITE_PRIVATE int sqlite3Fts3Always(int b); -SQLITE_PRIVATE int sqlite3Fts3Never(int b); +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) +# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1 +#endif +#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS) +# define ALWAYS(X) (1) +# define NEVER(X) (0) +#elif !defined(NDEBUG) +# define ALWAYS(X) ((X)?1:(assert(0),0)) +# define NEVER(X) ((X)?(assert(0),1):0) #else -# define ALWAYS(x) (x) -# define NEVER(x) (x) +# define ALWAYS(X) (X) +# define NEVER(X) (X) #endif /* @@ -167990,6 +172856,7 @@ SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *); SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash*); SQLITE_PRIVATE int sqlite3Fts3InitTerm(sqlite3 *db); #endif +SQLITE_PRIVATE void *sqlite3Fts3MallocZero(i64 nByte); SQLITE_PRIVATE int sqlite3Fts3OpenTokenizer(sqlite3_tokenizer *, int, const char *, int, sqlite3_tokenizer_cursor ** @@ -168047,20 +172914,15 @@ static int fts3EvalStart(Fts3Cursor *pCsr); static int fts3TermSegReaderCursor( Fts3Cursor *, const char *, int, int, Fts3MultiSegReader **); -#ifndef SQLITE_AMALGAMATION -# if defined(SQLITE_DEBUG) -SQLITE_PRIVATE int sqlite3Fts3Always(int b) { assert( b ); return b; } -SQLITE_PRIVATE int sqlite3Fts3Never(int b) { assert( !b ); return b; } -# endif -#endif - /* ** This variable is set to false when running tests for which the on disk ** structures should not be corrupt. Otherwise, true. If it is false, extra ** assert() conditions in the fts3 code are activated - conditions that are ** only true if it is guaranteed that the fts3 database is not corrupt. */ +#ifdef SQLITE_DEBUG SQLITE_API int sqlite3_fts3_may_be_corrupt = 1; +#endif /* ** Write a 64-bit variable-length integer to memory starting at p[0]. @@ -169631,7 +174493,7 @@ static int fts3ScanInteriorNode( char *zBuffer = 0; /* Buffer to load terms into */ i64 nAlloc = 0; /* Size of allocated buffer */ int isFirstTerm = 1; /* True when processing first term on page */ - sqlite3_int64 iChild; /* Block id of child node to descend to */ + u64 iChild; /* Block id of child node to descend to */ int nBuffer = 0; /* Total term size */ /* Skip over the 'height' varint that occurs at the start of every @@ -169647,8 +174509,8 @@ static int fts3ScanInteriorNode( ** table, then there are always 20 bytes of zeroed padding following the ** nNode bytes of content (see sqlite3Fts3ReadBlock() for details). */ - zCsr += sqlite3Fts3GetVarint(zCsr, &iChild); - zCsr += sqlite3Fts3GetVarint(zCsr, &iChild); + zCsr += sqlite3Fts3GetVarintU(zCsr, &iChild); + zCsr += sqlite3Fts3GetVarintU(zCsr, &iChild); if( zCsr>zEnd ){ return FTS_CORRUPT_VTAB; } @@ -169701,20 +174563,20 @@ static int fts3ScanInteriorNode( */ cmp = memcmp(zTerm, zBuffer, (nBuffer>nTerm ? nTerm : nBuffer)); if( piFirst && (cmp<0 || (cmp==0 && nBuffer>nTerm)) ){ - *piFirst = iChild; + *piFirst = (i64)iChild; piFirst = 0; } if( piLast && cmp<0 ){ - *piLast = iChild; + *piLast = (i64)iChild; piLast = 0; } iChild++; }; - if( piFirst ) *piFirst = iChild; - if( piLast ) *piLast = iChild; + if( piFirst ) *piFirst = (i64)iChild; + if( piLast ) *piLast = (i64)iChild; finish_scan: sqlite3_free(zBuffer); @@ -171320,14 +176182,20 @@ static int fts3SetHasStat(Fts3Table *p){ */ static int fts3BeginMethod(sqlite3_vtab *pVtab){ Fts3Table *p = (Fts3Table*)pVtab; + int rc; UNUSED_PARAMETER(pVtab); assert( p->pSegments==0 ); assert( p->nPendingData==0 ); assert( p->inTransaction!=1 ); - TESTONLY( p->inTransaction = 1 ); - TESTONLY( p->mxSavepoint = -1; ); p->nLeafAdd = 0; - return fts3SetHasStat(p); + rc = fts3SetHasStat(p); +#ifdef SQLITE_DEBUG + if( rc==SQLITE_OK ){ + p->inTransaction = 1; + p->mxSavepoint = -1; + } +#endif + return rc; } /* @@ -172856,16 +177724,15 @@ static int fts3EvalStart(Fts3Cursor *pCsr){ #ifndef SQLITE_DISABLE_FTS4_DEFERRED if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){ Fts3TokenAndCost *aTC; - Fts3Expr **apOr; aTC = (Fts3TokenAndCost *)sqlite3_malloc64( sizeof(Fts3TokenAndCost) * nToken + sizeof(Fts3Expr *) * nOr * 2 ); - apOr = (Fts3Expr **)&aTC[nToken]; if( !aTC ){ rc = SQLITE_NOMEM; }else{ + Fts3Expr **apOr = (Fts3Expr **)&aTC[nToken]; int ii; Fts3TokenAndCost *pTC = aTC; Fts3Expr **ppOr = apOr; @@ -172946,9 +177813,9 @@ static int fts3EvalNearTrim( ); if( res ){ nNew = (int)(pOut - pPhrase->doclist.pList) - 1; - if( nNew>=0 ){ + assert_fts3_nc( nNew<=pPhrase->doclist.nList && nNew>0 ); + if( nNew>=0 && nNew<=pPhrase->doclist.nList ){ assert( pPhrase->doclist.pList[nNew]=='\0' ); - assert( nNew<=pPhrase->doclist.nList && nNew>0 ); memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew); pPhrase->doclist.nList = nNew; } @@ -173071,8 +177938,8 @@ static void fts3EvalNextRow( Fts3Expr *pRight = pExpr->pRight; sqlite3_int64 iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid); - assert( pLeft->bStart || pLeft->iDocid==pRight->iDocid ); - assert( pRight->bStart || pLeft->iDocid==pRight->iDocid ); + assert_fts3_nc( pLeft->bStart || pLeft->iDocid==pRight->iDocid ); + assert_fts3_nc( pRight->bStart || pLeft->iDocid==pRight->iDocid ); if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){ fts3EvalNextRow(pCsr, pLeft, pRc); @@ -173710,6 +178577,9 @@ SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist( if( bEofSave==0 && pNear->iDocid==iDocid ) break; } assert( rc!=SQLITE_OK || pPhrase->bIncr==0 ); + if( rc==SQLITE_OK && pNear->bEof!=bEofSave ){ + rc = FTS_CORRUPT_VTAB; + } } if( bTreeEof ){ while( rc==SQLITE_OK && !pNear->bEof ){ @@ -174132,6 +179002,7 @@ static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){ if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM; memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat); iCol = 0; + rc = SQLITE_OK; while( iaStat[iCol+1].nDoc++; eState = 2; @@ -174183,7 +179058,6 @@ static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){ } pCsr->iCol = 0; - rc = SQLITE_OK; }else{ pCsr->isEof = 1; } @@ -174241,6 +179115,7 @@ static int fts3auxFilterMethod( sqlite3Fts3SegReaderFinish(&pCsr->csr); sqlite3_free((void *)pCsr->filter.zTerm); sqlite3_free(pCsr->aStat); + sqlite3_free(pCsr->zStop); memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr); pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY; @@ -174511,7 +179386,7 @@ static int fts3isspace(char c){ ** zero the memory before returning a pointer to it. If unsuccessful, ** return NULL. */ -static void *fts3MallocZero(sqlite3_int64 nByte){ +SQLITE_PRIVATE void *sqlite3Fts3MallocZero(sqlite3_int64 nByte){ void *pRet = sqlite3_malloc64(nByte); if( pRet ) memset(pRet, 0, nByte); return pRet; @@ -174592,7 +179467,7 @@ static int getNextToken( rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition); if( rc==SQLITE_OK ){ nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken; - pRet = (Fts3Expr *)fts3MallocZero(nByte); + pRet = (Fts3Expr *)sqlite3Fts3MallocZero(nByte); if( !pRet ){ rc = SQLITE_NOMEM; }else{ @@ -174847,7 +179722,7 @@ static int getNextNode( if( fts3isspace(cNext) || cNext=='"' || cNext=='(' || cNext==')' || cNext==0 ){ - pRet = (Fts3Expr *)fts3MallocZero(sizeof(Fts3Expr)); + pRet = (Fts3Expr *)sqlite3Fts3MallocZero(sizeof(Fts3Expr)); if( !pRet ){ return SQLITE_NOMEM; } @@ -174882,6 +179757,11 @@ static int getNextNode( if( *zInput=='(' ){ int nConsumed = 0; pParse->nNest++; +#if !defined(SQLITE_MAX_EXPR_DEPTH) + if( pParse->nNest>1000 ) return SQLITE_ERROR; +#elif SQLITE_MAX_EXPR_DEPTH>0 + if( pParse->nNest>SQLITE_MAX_EXPR_DEPTH ) return SQLITE_ERROR; +#endif rc = fts3ExprParse(pParse, zInput+1, nInput-1, ppExpr, &nConsumed); *pnConsumed = (int)(zInput - z) + 1 + nConsumed; return rc; @@ -175021,7 +179901,7 @@ static int fts3ExprParse( && p->eType==FTSQUERY_PHRASE && pParse->isNot ){ /* Create an implicit NOT operator. */ - Fts3Expr *pNot = fts3MallocZero(sizeof(Fts3Expr)); + Fts3Expr *pNot = sqlite3Fts3MallocZero(sizeof(Fts3Expr)); if( !pNot ){ sqlite3Fts3ExprFree(p); rc = SQLITE_NOMEM; @@ -175055,7 +179935,7 @@ static int fts3ExprParse( /* Insert an implicit AND operator. */ Fts3Expr *pAnd; assert( pRet && pPrev ); - pAnd = fts3MallocZero(sizeof(Fts3Expr)); + pAnd = sqlite3Fts3MallocZero(sizeof(Fts3Expr)); if( !pAnd ){ sqlite3Fts3ExprFree(p); rc = SQLITE_NOMEM; @@ -179285,8 +184165,18 @@ static int fts3SegReaderNext( char *aCopy; PendingList *pList = (PendingList *)fts3HashData(pElem); int nCopy = pList->nData+1; - pReader->zTerm = (char *)fts3HashKey(pElem); - pReader->nTerm = fts3HashKeysize(pElem); + + int nTerm = fts3HashKeysize(pElem); + if( (nTerm+1)>pReader->nTermAlloc ){ + sqlite3_free(pReader->zTerm); + pReader->zTerm = (char*)sqlite3_malloc((nTerm+1)*2); + if( !pReader->zTerm ) return SQLITE_NOMEM; + pReader->nTermAlloc = (nTerm+1)*2; + } + memcpy(pReader->zTerm, fts3HashKey(pElem), nTerm); + pReader->zTerm[nTerm] = '\0'; + pReader->nTerm = nTerm; + aCopy = (char*)sqlite3_malloc(nCopy); if( !aCopy ) return SQLITE_NOMEM; memcpy(aCopy, pList->aData, nCopy); @@ -179539,9 +184429,7 @@ SQLITE_PRIVATE int sqlite3Fts3MsrOvfl( */ SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *pReader){ if( pReader ){ - if( !fts3SegReaderIsPending(pReader) ){ - sqlite3_free(pReader->zTerm); - } + sqlite3_free(pReader->zTerm); if( !fts3SegReaderIsRootOnly(pReader) ){ sqlite3_free(pReader->aNode); } @@ -179757,7 +184645,7 @@ static int fts3SegReaderCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ if( rc==0 ){ rc = pRhs->iIdx - pLhs->iIdx; } - assert( rc!=0 ); + assert_fts3_nc( rc!=0 ); return rc; } @@ -179953,8 +184841,8 @@ static int fts3PrefixCompress( int nNext /* Size of buffer zNext in bytes */ ){ int n; - UNUSED_PARAMETER(nNext); - for(n=0; nterm, nPrefix+nSuffix, &rc); - if( rc==SQLITE_OK ){ + if( rc==SQLITE_OK && ALWAYS(p->term.a!=0) ){ memcpy(&p->term.a[nPrefix], &p->aNode[p->iOff], nSuffix); p->term.n = nPrefix+nSuffix; p->iOff += nSuffix; @@ -182127,7 +187015,11 @@ static int fts3TermCmp( int nCmp = MIN(nLhs, nRhs); int res; - res = (nCmp ? memcmp(zLhs, zRhs, nCmp) : 0); + if( nCmp && ALWAYS(zLhs) && ALWAYS(zRhs) ){ + res = memcmp(zLhs, zRhs, nCmp); + }else{ + res = 0; + } if( res==0 ) res = nLhs - nRhs; return res; @@ -182285,17 +187177,20 @@ static int fts3IncrmergeLoad( while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader); blobGrowBuffer(&pNode->key, reader.term.n, &rc); if( rc==SQLITE_OK ){ - memcpy(pNode->key.a, reader.term.a, reader.term.n); + assert_fts3_nc( reader.term.n>0 || reader.aNode==0 ); + if( reader.term.n>0 ){ + memcpy(pNode->key.a, reader.term.a, reader.term.n); + } pNode->key.n = reader.term.n; if( i>0 ){ char *aBlock = 0; int nBlock = 0; pNode = &pWriter->aNodeWriter[i-1]; pNode->iBlock = reader.iChild; - rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock, 0); + rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock,0); blobGrowBuffer(&pNode->block, MAX(nBlock, p->nNodeSize)+FTS3_NODE_PADDING, &rc - ); + ); if( rc==SQLITE_OK ){ memcpy(pNode->block.a, aBlock, nBlock); pNode->block.n = nBlock; @@ -182768,7 +187663,7 @@ static int fts3IncrmergeHintLoad(Fts3Table *p, Blob *pHint){ if( aHint ){ blobGrowBuffer(pHint, nHint, &rc); if( rc==SQLITE_OK ){ - memcpy(pHint->a, aHint, nHint); + if( ALWAYS(pHint->a!=0) ) memcpy(pHint->a, aHint, nHint); pHint->n = nHint; } } @@ -183764,6 +188659,10 @@ SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *p){ /* #include */ /* #include */ +#ifndef SQLITE_AMALGAMATION +typedef sqlite3_int64 i64; +#endif + /* ** Characters that may appear in the second argument to matchinfo(). */ @@ -183814,9 +188713,9 @@ struct SnippetIter { struct SnippetPhrase { int nToken; /* Number of tokens in phrase */ char *pList; /* Pointer to start of phrase position list */ - int iHead; /* Next value in position list */ + i64 iHead; /* Next value in position list */ char *pHead; /* Position list data following iHead */ - int iTail; /* Next value in trailing position list */ + i64 iTail; /* Next value in trailing position list */ char *pTail; /* Position list data following iTail */ }; @@ -183881,9 +188780,8 @@ static MatchinfoBuffer *fts3MIBufferNew(size_t nElem, const char *zMatchinfo){ + sizeof(MatchinfoBuffer); sqlite3_int64 nStr = strlen(zMatchinfo); - pRet = sqlite3_malloc64(nByte + nStr+1); + pRet = sqlite3Fts3MallocZero(nByte + nStr+1); if( pRet ){ - memset(pRet, 0, nByte); pRet->aMatchinfo[0] = (u8*)(&pRet->aMatchinfo[1]) - (u8*)pRet; pRet->aMatchinfo[1+nElem] = pRet->aMatchinfo[0] + sizeof(u32)*((int)nElem+1); @@ -183981,7 +188879,7 @@ SQLITE_PRIVATE void sqlite3Fts3MIBufferFree(MatchinfoBuffer *p){ ** After it returns, *piPos contains the value of the next element of the ** list and *pp is advanced to the following varint. */ -static void fts3GetDeltaPosition(char **pp, int *piPos){ +static void fts3GetDeltaPosition(char **pp, i64 *piPos){ int iVal; *pp += fts3GetVarint32(*pp, &iVal); *piPos += (iVal-2); @@ -184090,10 +188988,10 @@ static int fts3ExprPhraseCount(Fts3Expr *pExpr){ ** arguments so that it points to the first element with a value greater ** than or equal to parameter iNext. */ -static void fts3SnippetAdvance(char **ppIter, int *piIter, int iNext){ +static void fts3SnippetAdvance(char **ppIter, i64 *piIter, int iNext){ char *pIter = *ppIter; if( pIter ){ - int iIter = *piIter; + i64 iIter = *piIter; while( iIteraPhrase[i]; if( pPhrase->pTail ){ char *pCsr = pPhrase->pTail; - int iCsr = pPhrase->iTail; + i64 iCsr = pPhrase->iTail; while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){ int j; @@ -184222,7 +189120,7 @@ static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){ rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr); assert( rc==SQLITE_OK || pCsr==0 ); if( pCsr ){ - int iFirst = 0; + i64 iFirst = 0; pPhrase->pList = pCsr; fts3GetDeltaPosition(&pCsr, &iFirst); if( iFirst<0 ){ @@ -184287,11 +189185,10 @@ static int fts3BestSnippet( ** the required space using malloc(). */ nByte = sizeof(SnippetPhrase) * nList; - sIter.aPhrase = (SnippetPhrase *)sqlite3_malloc64(nByte); + sIter.aPhrase = (SnippetPhrase *)sqlite3Fts3MallocZero(nByte); if( !sIter.aPhrase ){ return SQLITE_NOMEM; } - memset(sIter.aPhrase, 0, nByte); /* Initialize the contents of the SnippetIter object. Then iterate through ** the set of phrases in the expression to populate the aPhrase[] array. @@ -184855,10 +189752,12 @@ static int fts3MatchinfoLcsCb( ** position list for the next column. */ static int fts3LcsIteratorAdvance(LcsIterator *pIter){ - char *pRead = pIter->pRead; + char *pRead; sqlite3_int64 iRead; int rc = 0; + if( NEVER(pIter==0) ) return 1; + pRead = pIter->pRead; pRead += sqlite3Fts3GetVarint(pRead, &iRead); if( iRead==0 || iRead==1 ){ pRead = 0; @@ -184892,9 +189791,8 @@ static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){ /* Allocate and populate the array of LcsIterator objects. The array ** contains one element for each matchable phrase in the query. **/ - aIter = sqlite3_malloc64(sizeof(LcsIterator) * pCsr->nPhrase); + aIter = sqlite3Fts3MallocZero(sizeof(LcsIterator) * pCsr->nPhrase); if( !aIter ) return SQLITE_NOMEM; - memset(aIter, 0, sizeof(LcsIterator) * pCsr->nPhrase); (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter); for(i=0; inPhrase; i++){ @@ -185286,8 +190184,8 @@ typedef struct TermOffsetCtx TermOffsetCtx; struct TermOffset { char *pList; /* Position-list */ - int iPos; /* Position just read from pList */ - int iOff; /* Offset of this term from read positions */ + i64 iPos; /* Position just read from pList */ + i64 iOff; /* Offset of this term from read positions */ }; struct TermOffsetCtx { @@ -185306,7 +190204,7 @@ static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){ int nTerm; /* Number of tokens in phrase */ int iTerm; /* For looping through nTerm phrase terms */ char *pList; /* Pointer to position list for phrase */ - int iPos = 0; /* First position in position-list */ + i64 iPos = 0; /* First position in position-list */ int rc; UNUSED_PARAMETER(iPhrase); @@ -185355,7 +190253,7 @@ SQLITE_PRIVATE void sqlite3Fts3Offsets( if( rc!=SQLITE_OK ) goto offsets_out; /* Allocate the array of TermOffset iterators. */ - sCtx.aTerm = (TermOffset *)sqlite3_malloc64(sizeof(TermOffset)*nToken); + sCtx.aTerm = (TermOffset *)sqlite3Fts3MallocZero(sizeof(TermOffset)*nToken); if( 0==sCtx.aTerm ){ rc = SQLITE_NOMEM; goto offsets_out; @@ -185376,13 +190274,13 @@ SQLITE_PRIVATE void sqlite3Fts3Offsets( const char *zDoc; int nDoc; - /* Initialize the contents of sCtx.aTerm[] for column iCol. There is - ** no way that this operation can fail, so the return code from - ** fts3ExprIterate() can be discarded. + /* Initialize the contents of sCtx.aTerm[] for column iCol. This + ** operation may fail if the database contains corrupt records. */ sCtx.iCol = iCol; sCtx.iTerm = 0; - (void)fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx); + rc = fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx); + if( rc!=SQLITE_OK ) goto offsets_out; /* Retreive the text stored in column iCol. If an SQL NULL is stored ** in column iCol, jump immediately to the next iteration of the loop. @@ -185783,6 +190681,7 @@ static int unicodeOpen( pCsr->aInput = (const unsigned char *)aInput; if( aInput==0 ){ pCsr->nInput = 0; + pCsr->aInput = (const unsigned char*)""; }else if( nInput<0 ){ pCsr->nInput = (int)strlen(aInput); }else{ @@ -186379,7 +191278,34 @@ static const char jsonIsSpace[] = { typedef unsigned int u32; typedef unsigned short int u16; typedef unsigned char u8; +# if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) +# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1 +# endif +# if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS) +# define ALWAYS(X) (1) +# define NEVER(X) (0) +# elif !defined(NDEBUG) +# define ALWAYS(X) ((X)?1:(assert(0),0)) +# define NEVER(X) ((X)?(assert(0),1):0) +# else +# define ALWAYS(X) (X) +# define NEVER(X) (X) +# endif +# define testcase(X) #endif +#if !defined(SQLITE_DEBUG) && !defined(SQLITE_COVERAGE_TEST) +# define VVA(X) +#else +# define VVA(X) X +#endif + +/* +** Some of the testcase() macros in this file are problematic for gcov +** in that they generate false-miss errors randomly. This is a gcov problem, +** not a problem in this case. But to work around it, we disable the +** problematic test cases for production builds. +*/ +#define json_testcase(X) /* Objects */ typedef struct JsonString JsonString; @@ -186437,13 +191363,14 @@ static const char * const jsonType[] = { struct JsonNode { u8 eType; /* One of the JSON_ type values */ u8 jnFlags; /* JNODE flags */ + u8 eU; /* Which union element to use */ u32 n; /* Bytes of content, or number of sub-nodes */ union { - const char *zJContent; /* Content for INT, REAL, and STRING */ - u32 iAppend; /* More terms for ARRAY and OBJECT */ - u32 iKey; /* Key for ARRAY objects in json_tree() */ - u32 iReplace; /* Replacement content for JNODE_REPLACE */ - JsonNode *pPatch; /* Node chain of patch for JNODE_PATCH */ + const char *zJContent; /* 1: Content for INT, REAL, and STRING */ + u32 iAppend; /* 2: More terms for ARRAY and OBJECT */ + u32 iKey; /* 3: Key for ARRAY objects in json_tree() */ + u32 iReplace; /* 4: Replacement content for JNODE_REPLACE */ + JsonNode *pPatch; /* 5: Node chain of patch for JNODE_PATCH */ } u; }; @@ -186582,7 +191509,7 @@ static void jsonAppendSeparator(JsonString *p){ */ static void jsonAppendString(JsonString *p, const char *zIn, u32 N){ u32 i; - if( (N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0 ) return; + if( zIn==0 || ((N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0) ) return; p->zBuf[p->nUsed++] = '"'; for(i=0; ijnFlags & (JNODE_REPLACE|JNODE_PATCH) ){ - if( pNode->jnFlags & JNODE_REPLACE ){ + if( (pNode->jnFlags & JNODE_REPLACE)!=0 && ALWAYS(aReplace!=0) ){ + assert( pNode->eU==4 ); jsonAppendValue(pOut, aReplace[pNode->u.iReplace]); return; } + assert( pNode->eU==5 ); pNode = pNode->u.pPatch; } switch( pNode->eType ){ @@ -186744,6 +191674,7 @@ static void jsonRenderNode( } case JSON_STRING: { if( pNode->jnFlags & JNODE_RAW ){ + assert( pNode->eU==1 ); jsonAppendString(pOut, pNode->u.zJContent, pNode->n); break; } @@ -186751,6 +191682,7 @@ static void jsonRenderNode( } case JSON_REAL: case JSON_INT: { + assert( pNode->eU==1 ); jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n); break; } @@ -186766,6 +191698,7 @@ static void jsonRenderNode( j += jsonNodeSize(&pNode[j]); } if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; + assert( pNode->eU==2 ); pNode = &pNode[pNode->u.iAppend]; j = 1; } @@ -186786,6 +191719,7 @@ static void jsonRenderNode( j += 1 + jsonNodeSize(&pNode[j+1]); } if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; + assert( pNode->eU==2 ); pNode = &pNode[pNode->u.iAppend]; j = 1; } @@ -186865,7 +191799,9 @@ static void jsonReturn( } case JSON_INT: { sqlite3_int64 i = 0; - const char *z = pNode->u.zJContent; + const char *z; + assert( pNode->eU==1 ); + z = pNode->u.zJContent; if( z[0]=='-' ){ z++; } while( z[0]>='0' && z[0]<='9' ){ unsigned v = *(z++) - '0'; @@ -186888,14 +191824,17 @@ static void jsonReturn( sqlite3_result_int64(pCtx, i); int_done: break; - int_as_real: i=0; /* no break */ deliberate_fall_through + int_as_real: ; /* no break */ deliberate_fall_through } case JSON_REAL: { double r; #ifdef SQLITE_AMALGAMATION - const char *z = pNode->u.zJContent; + const char *z; + assert( pNode->eU==1 ); + z = pNode->u.zJContent; sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8); #else + assert( pNode->eU==1 ); r = strtod(pNode->u.zJContent, 0); #endif sqlite3_result_double(pCtx, r); @@ -186906,6 +191845,7 @@ static void jsonReturn( ** json_insert() and json_replace() and those routines do not ** call jsonReturn() */ if( pNode->jnFlags & JNODE_RAW ){ + assert( pNode->eU==1 ); sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n, SQLITE_TRANSIENT); }else @@ -186913,15 +191853,18 @@ static void jsonReturn( assert( (pNode->jnFlags & JNODE_RAW)==0 ); if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){ /* JSON formatted without any backslash-escapes */ + assert( pNode->eU==1 ); sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2, SQLITE_TRANSIENT); }else{ /* Translate JSON formatted string into raw text */ u32 i; u32 n = pNode->n; - const char *z = pNode->u.zJContent; + const char *z; char *zOut; u32 j; + assert( pNode->eU==1 ); + z = pNode->u.zJContent; zOut = sqlite3_malloc( n+1 ); if( zOut==0 ){ sqlite3_result_error_nomem(pCtx); @@ -187042,12 +191985,13 @@ static int jsonParseAddNode( const char *zContent /* Content */ ){ JsonNode *p; - if( pParse->nNode>=pParse->nAlloc ){ + if( pParse->aNode==0 || pParse->nNode>=pParse->nAlloc ){ return jsonParseAddNodeExpand(pParse, eType, n, zContent); } p = &pParse->aNode[pParse->nNode]; p->eType = (u8)eType; p->jnFlags = 0; + VVA( p->eU = zContent ? 1 : 0 ); p->n = n; p->u.zJContent = zContent; return pParse->nNode++; @@ -187115,6 +192059,7 @@ static int jsonParseValue(JsonParse *pParse, u32 i){ /* Parse array */ iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); if( iThis<0 ) return -1; + memset(&pParse->aNode[iThis].u, 0, sizeof(pParse->aNode[iThis].u)); for(j=i+1;;j++){ while( safe_isspace(z[j]) ){ j++; } if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1; @@ -187379,6 +192324,7 @@ static JsonParse *jsonParseCached( ** a match. */ static int jsonLabelCompare(JsonNode *pNode, const char *zKey, u32 nKey){ + assert( pNode->eU==1 ); if( pNode->jnFlags & JNODE_RAW ){ if( pNode->n!=nKey ) return 0; return strncmp(pNode->u.zJContent, zKey, nKey)==0; @@ -187444,6 +192390,7 @@ static JsonNode *jsonLookupStep( j += jsonNodeSize(&pRoot[j]); } if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; + assert( pRoot->eU==2 ); iRoot += pRoot->u.iAppend; pRoot = &pParse->aNode[iRoot]; j = 1; @@ -187458,8 +192405,10 @@ static JsonNode *jsonLookupStep( if( pParse->oom ) return 0; if( pNode ){ pRoot = &pParse->aNode[iRoot]; + assert( pRoot->eU==0 ); pRoot->u.iAppend = iStart - iRoot; pRoot->jnFlags |= JNODE_APPEND; + VVA( pRoot->eU = 2 ); pParse->aNode[iLabel].jnFlags |= JNODE_RAW; } return pNode; @@ -187482,6 +192431,7 @@ static JsonNode *jsonLookupStep( j += jsonNodeSize(&pBase[j]); } if( (pBase->jnFlags & JNODE_APPEND)==0 ) break; + assert( pBase->eU==2 ); iBase += pBase->u.iAppend; pBase = &pParse->aNode[iBase]; j = 1; @@ -187515,6 +192465,7 @@ static JsonNode *jsonLookupStep( j += jsonNodeSize(&pRoot[j]); } if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; + assert( pRoot->eU==2 ); iRoot += pRoot->u.iAppend; pRoot = &pParse->aNode[iRoot]; j = 1; @@ -187530,8 +192481,10 @@ static JsonNode *jsonLookupStep( if( pParse->oom ) return 0; if( pNode ){ pRoot = &pParse->aNode[iRoot]; + assert( pRoot->eU==0 ); pRoot->u.iAppend = iStart - iRoot; pRoot->jnFlags |= JNODE_APPEND; + VVA( pRoot->eU = 2 ); } return pNode; } @@ -187685,9 +192638,13 @@ static void jsonParseFunc( } jsonPrintf(100, &s,"node %3u: %7s n=%-4d up=%-4d", i, zType, x.aNode[i].n, x.aUp[i]); + assert( x.aNode[i].eU==0 || x.aNode[i].eU==1 ); if( x.aNode[i].u.zJContent!=0 ){ + assert( x.aNode[i].eU==1 ); jsonAppendRaw(&s, " ", 1); jsonAppendRaw(&s, x.aNode[i].u.zJContent, x.aNode[i].n); + }else{ + assert( x.aNode[i].eU==0 ); } jsonAppendRaw(&s, "\n", 1); } @@ -187870,6 +192827,7 @@ static JsonNode *jsonMergePatch( const char *zKey; assert( pPatch[i].eType==JSON_STRING ); assert( pPatch[i].jnFlags & JNODE_LABEL ); + assert( pPatch[i].eU==1 ); nKey = pPatch[i].n; zKey = pPatch[i].u.zJContent; assert( (pPatch[i].jnFlags & JNODE_RAW)==0 ); @@ -187886,6 +192844,12 @@ static JsonNode *jsonMergePatch( if( pNew==0 ) return 0; pTarget = &pParse->aNode[iTarget]; if( pNew!=&pTarget[j+1] ){ + assert( pTarget[j+1].eU==0 + || pTarget[j+1].eU==1 + || pTarget[j+1].eU==2 ); + testcase( pTarget[j+1].eU==1 ); + testcase( pTarget[j+1].eU==2 ); + VVA( pTarget[j+1].eU = 5 ); pTarget[j+1].u.pPatch = pNew; pTarget[j+1].jnFlags |= JNODE_PATCH; } @@ -187901,9 +192865,14 @@ static JsonNode *jsonMergePatch( if( pParse->oom ) return 0; jsonRemoveAllNulls(pPatch); pTarget = &pParse->aNode[iTarget]; + assert( pParse->aNode[iRoot].eU==0 || pParse->aNode[iRoot].eU==2 ); + testcase( pParse->aNode[iRoot].eU==2 ); pParse->aNode[iRoot].jnFlags |= JNODE_APPEND; + VVA( pParse->aNode[iRoot].eU = 2 ); pParse->aNode[iRoot].u.iAppend = iStart - iRoot; iRoot = iStart; + assert( pParse->aNode[iPatch].eU==0 ); + VVA( pParse->aNode[iPatch].eU = 5 ); pParse->aNode[iPatch].jnFlags |= JNODE_PATCH; pParse->aNode[iPatch].u.pPatch = &pPatch[i+1]; } @@ -188045,11 +193014,15 @@ static void jsonReplaceFunc( pNode = jsonLookup(&x, zPath, 0, ctx); if( x.nErr ) goto replace_err; if( pNode ){ + assert( pNode->eU==0 || pNode->eU==1 || pNode->eU==4 ); + json_testcase( pNode->eU!=0 && pNode->eU!=1 ); pNode->jnFlags |= (u8)JNODE_REPLACE; + VVA( pNode->eU = 4 ); pNode->u.iReplace = i + 1; } } if( x.aNode[0].jnFlags & JNODE_REPLACE ){ + assert( x.aNode[0].eU==4 ); sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); }else{ jsonReturnJson(x.aNode, ctx, argv); @@ -188099,11 +193072,15 @@ static void jsonSetFunc( }else if( x.nErr ){ goto jsonSetDone; }else if( pNode && (bApnd || bIsSet) ){ + json_testcase( pNode->eU!=0 && pNode->eU!=1 && pNode->eU!=4 ); + assert( pNode->eU!=3 || pNode->eU!=5 ); + VVA( pNode->eU = 4 ); pNode->jnFlags |= (u8)JNODE_REPLACE; pNode->u.iReplace = i + 1; } } if( x.aNode[0].jnFlags & JNODE_REPLACE ){ + assert( x.aNode[0].eU==4 ); sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); }else{ jsonReturnJson(x.aNode, ctx, argv); @@ -188181,8 +193158,8 @@ static void jsonArrayStep( jsonAppendChar(pStr, '['); }else if( pStr->nUsed>1 ){ jsonAppendChar(pStr, ','); - pStr->pCtx = ctx; } + pStr->pCtx = ctx; jsonAppendValue(pStr, argv[0]); } } @@ -188242,11 +193219,7 @@ static void jsonGroupInverse( if( NEVER(!pStr) ) return; #endif z = pStr->zBuf; - for(i=1; (c = z[i])!=',' || inStr || nNest; i++){ - if( i>=pStr->nUsed ){ - pStr->nUsed = 1; - return; - } + for(i=1; inUsed && ((c = z[i])!=',' || inStr || nNest); i++){ if( c=='"' ){ inStr = !inStr; }else if( c=='\\' ){ @@ -188256,8 +193229,13 @@ static void jsonGroupInverse( if( c=='}' || c==']' ) nNest--; } } - pStr->nUsed -= i; - memmove(&z[1], &z[i+1], (size_t)pStr->nUsed-1); + if( inUsed ){ + pStr->nUsed -= i; + memmove(&z[1], &z[i+1], (size_t)pStr->nUsed-1); + z[pStr->nUsed] = 0; + }else{ + pStr->nUsed = 1; + } } #else # define jsonGroupInverse 0 @@ -188285,8 +193263,8 @@ static void jsonObjectStep( jsonAppendChar(pStr, '{'); }else if( pStr->nUsed>1 ){ jsonAppendChar(pStr, ','); - pStr->pCtx = ctx; } + pStr->pCtx = ctx; z = (const char*)sqlite3_value_text(argv[0]); n = (u32)sqlite3_value_bytes(argv[0]); jsonAppendString(pStr, z, n); @@ -188453,6 +193431,9 @@ static int jsonEachNext(sqlite3_vtab_cursor *cur){ JsonNode *pUp = &p->sParse.aNode[iUp]; p->eType = pUp->eType; if( pUp->eType==JSON_ARRAY ){ + assert( pUp->eU==0 || pUp->eU==3 ); + json_testcase( pUp->eU==3 ); + VVA( pUp->eU = 3 ); if( iUp==p->i-1 ){ pUp->u.iKey = 0; }else{ @@ -188499,12 +193480,15 @@ static void jsonEachComputePath( pNode = &p->sParse.aNode[i]; pUp = &p->sParse.aNode[iUp]; if( pUp->eType==JSON_ARRAY ){ + assert( pUp->eU==3 || (pUp->eU==0 && pUp->u.iKey==0) ); + testcase( pUp->eU==0 ); jsonPrintf(30, pStr, "[%d]", pUp->u.iKey); }else{ assert( pUp->eType==JSON_OBJECT ); if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--; assert( pNode->eType==JSON_STRING ); assert( pNode->jnFlags & JNODE_LABEL ); + assert( pNode->eU==1 ); jsonPrintf(pNode->n+1, pStr, ".%.*s", pNode->n-2, pNode->u.zJContent+1); } } @@ -188526,6 +193510,7 @@ static int jsonEachColumn( u32 iKey; if( p->bRecursive ){ if( p->iRowid==0 ) break; + assert( p->sParse.aNode[p->sParse.aUp[p->i]].eU==3 ); iKey = p->sParse.aNode[p->sParse.aUp[p->i]].u.iKey; }else{ iKey = p->iRowid; @@ -188575,6 +193560,7 @@ static int jsonEachColumn( if( p->eType==JSON_ARRAY ){ jsonPrintf(30, &x, "[%d]", p->iRowid); }else if( p->eType==JSON_OBJECT ){ + assert( pThis->eU==1 ); jsonPrintf(pThis->n, &x, ".%.*s", pThis->n-2, pThis->u.zJContent+1); } } @@ -188642,6 +193628,7 @@ static int jsonEachBestIndex( if( pConstraint->iColumn < JEACH_JSON ) continue; iCol = pConstraint->iColumn - JEACH_JSON; assert( iCol==0 || iCol==1 ); + testcase( iCol==0 ); iMask = 1 << iCol; if( pConstraint->usable==0 ){ unusableMask |= iMask; @@ -188739,6 +193726,8 @@ static int jsonEachFilter( p->iBegin = p->i = (int)(pNode - p->sParse.aNode); p->eType = pNode->eType; if( p->eType>=JSON_ARRAY ){ + assert( pNode->eU==0 ); + VVA( pNode->eU = 3 ); pNode->u.iKey = 0; p->iEnd = p->i + pNode->n + 1; if( p->bRecursive ){ @@ -188981,7 +193970,11 @@ SQLITE_API int sqlite3_json_init( #endif SQLITE_PRIVATE int sqlite3GetToken(const unsigned char*,int*); /* In the SQLite core */ -#ifndef SQLITE_AMALGAMATION +/* +** If building separately, we will need some setup that is normally +** found in sqliteInt.h +*/ +#if !defined(SQLITE_AMALGAMATION) #include "sqlite3rtree.h" typedef sqlite3_int64 i64; typedef sqlite3_uint64 u64; @@ -188994,7 +193987,20 @@ typedef unsigned int u32; #if defined(NDEBUG) && defined(SQLITE_DEBUG) # undef NDEBUG #endif +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) +# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1 #endif +#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS) +# define ALWAYS(X) (1) +# define NEVER(X) (0) +#elif !defined(NDEBUG) +# define ALWAYS(X) ((X)?1:(assert(0),0)) +# define NEVER(X) ((X)?(assert(0),1):0) +#else +# define ALWAYS(X) (X) +# define NEVER(X) (X) +#endif +#endif /* !defined(SQLITE_AMALGAMATION) */ /* #include */ /* #include */ @@ -189052,7 +194058,9 @@ struct Rtree { u8 nBytesPerCell; /* Bytes consumed per cell */ u8 inWrTrans; /* True if inside write transaction */ u8 nAux; /* # of auxiliary columns in %_rowid */ +#ifdef SQLITE_ENABLE_GEOPOLY u8 nAuxNotNull; /* Number of initial not-null aux columns */ +#endif #ifdef SQLITE_DEBUG u8 bCorrupt; /* Shadow table corruption detected */ #endif @@ -189334,7 +194342,12 @@ struct RtreeMatchArg { ** it is not, make it a no-op. */ #ifndef SQLITE_AMALGAMATION -# define testcase(X) +# if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG) + unsigned int sqlite3RtreeTestcase = 0; +# define testcase(X) if( X ){ sqlite3RtreeTestcase += __LINE__; } +# else +# define testcase(X) +# endif #endif /* @@ -189583,18 +194596,6 @@ static void nodeBlobReset(Rtree *pRtree){ } } -/* -** Check to see if pNode is the same as pParent or any of the parents -** of pParent. -*/ -static int nodeInParentChain(const RtreeNode *pNode, const RtreeNode *pParent){ - do{ - if( pNode==pParent ) return 1; - pParent = pParent->pParent; - }while( pParent ); - return 0; -} - /* ** Obtain a reference to an r-tree node. */ @@ -189611,14 +194612,7 @@ static int nodeAcquire( ** increase its reference count and return it. */ if( (pNode = nodeHashLookup(pRtree, iNode))!=0 ){ - if( pParent && !pNode->pParent ){ - if( nodeInParentChain(pNode, pParent) ){ - RTREE_IS_CORRUPT(pRtree); - return SQLITE_CORRUPT_VTAB; - } - pParent->nRef++; - pNode->pParent = pParent; - }else if( pParent && pNode->pParent && pParent!=pNode->pParent ){ + if( pParent && pParent!=pNode->pParent ){ RTREE_IS_CORRUPT(pRtree); return SQLITE_CORRUPT_VTAB; } @@ -189676,7 +194670,7 @@ static int nodeAcquire( ** are the leaves, and so on. If the depth as specified on the root node ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt. */ - if( pNode && rc==SQLITE_OK && iNode==1 ){ + if( rc==SQLITE_OK && pNode && iNode==1 ){ pRtree->iDepth = readInt16(pNode->zData); if( pRtree->iDepth>RTREE_MAX_DEPTH ){ rc = SQLITE_CORRUPT_VTAB; @@ -190199,20 +195193,29 @@ static void rtreeNonleafConstraint( switch( p->op ){ case RTREE_TRUE: return; /* Always satisfied */ case RTREE_FALSE: break; /* Never satisfied */ + case RTREE_EQ: + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the lower bound of the coordinate pair */ + if( p->u.rValue>=val ){ + pCellData += 4; + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the upper bound of the coordinate pair */ + if( p->u.rValue<=val ) return; + } + break; case RTREE_LE: case RTREE_LT: - case RTREE_EQ: RTREE_DECODE_COORD(eInt, pCellData, val); /* val now holds the lower bound of the coordinate pair */ if( p->u.rValue>=val ) return; - if( p->op!=RTREE_EQ ) break; /* RTREE_LE and RTREE_LT end here */ - /* Fall through for the RTREE_EQ case */ + break; - default: /* RTREE_GT or RTREE_GE, or fallthrough of RTREE_EQ */ + default: pCellData += 4; RTREE_DECODE_COORD(eInt, pCellData, val); /* val now holds the upper bound of the coordinate pair */ if( p->u.rValue<=val ) return; + break; } *peWithin = NOT_WITHIN; } @@ -190282,11 +195285,12 @@ static int nodeRowidIndex( */ static int nodeParentIndex(Rtree *pRtree, RtreeNode *pNode, int *piIndex){ RtreeNode *pParent = pNode->pParent; - if( pParent ){ + if( ALWAYS(pParent) ){ return nodeRowidIndex(pRtree, pParent, pNode->iNode, piIndex); + }else{ + *piIndex = -1; + return SQLITE_OK; } - *piIndex = -1; - return SQLITE_OK; } /* @@ -190409,7 +195413,8 @@ static RtreeSearchPoint *rtreeSearchPointNew( pNew = rtreeEnqueue(pCur, rScore, iLevel); if( pNew==0 ) return 0; ii = (int)(pNew - pCur->aPoint) + 1; - if( iiaNode[ii]==0 ); pCur->aNode[ii] = pCur->aNode[0]; }else{ @@ -190470,7 +195475,7 @@ static void rtreeSearchPointPop(RtreeCursor *p){ if( p->bPoint ){ p->anQueue[p->sPoint.iLevel]--; p->bPoint = 0; - }else if( p->nPoint ){ + }else if( ALWAYS(p->nPoint) ){ p->anQueue[p->aPoint[0].iLevel]--; n = --p->nPoint; p->aPoint[0] = p->aPoint[n]; @@ -190611,7 +195616,7 @@ static int rtreeRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){ RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); int rc = SQLITE_OK; RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); - if( rc==SQLITE_OK && p ){ + if( rc==SQLITE_OK && ALWAYS(p) ){ *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell); } return rc; @@ -190629,7 +195634,7 @@ static int rtreeColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); if( rc ) return rc; - if( p==0 ) return SQLITE_OK; + if( NEVER(p==0) ) return SQLITE_OK; if( i==0 ){ sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell)); }else if( i<=pRtree->nDim2 ){ @@ -190828,8 +195833,11 @@ static int rtreeFilter( } if( rc==SQLITE_OK ){ RtreeSearchPoint *pNew; + assert( pCsr->bPoint==0 ); /* Due to the resetCursor() call above */ pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1)); - if( pNew==0 ) return SQLITE_NOMEM; + if( NEVER(pNew==0) ){ /* Because pCsr->bPoint was FALSE */ + return SQLITE_NOMEM; + } pNew->id = 1; pNew->iCell = 0; pNew->eWithin = PARTLY_WITHIN; @@ -190906,7 +195914,7 @@ static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii]; if( bMatch==0 && p->usable - && p->iColumn==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ + && p->iColumn<=0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ ){ /* We have an equality constraint on the rowid. Use strategy 1. */ int jj; @@ -191112,7 +196120,7 @@ static int ChooseLeaf( int nCell = NCELL(pNode); RtreeCell cell; - RtreeNode *pChild; + RtreeNode *pChild = 0; RtreeCell *aCell = 0; @@ -191159,12 +196167,19 @@ static int AdjustTree( ){ RtreeNode *p = pNode; int cnt = 0; + int rc; while( p->pParent ){ RtreeNode *pParent = p->pParent; RtreeCell cell; int iCell; - if( (++cnt)>1000 || nodeParentIndex(pRtree, p, &iCell) ){ + cnt++; + if( NEVER(cnt>100) ){ + RTREE_IS_CORRUPT(pRtree); + return SQLITE_CORRUPT_VTAB; + } + rc = nodeParentIndex(pRtree, p, &iCell); + if( NEVER(rc!=SQLITE_OK) ){ RTREE_IS_CORRUPT(pRtree); return SQLITE_CORRUPT_VTAB; } @@ -191453,12 +196468,17 @@ static int updateMapping( xSetMapping = ((iHeight==0)?rowidWrite:parentWrite); if( iHeight>0 ){ RtreeNode *pChild = nodeHashLookup(pRtree, iRowid); + RtreeNode *p; + for(p=pNode; p; p=p->pParent){ + if( p==pChild ) return SQLITE_CORRUPT_VTAB; + } if( pChild ){ nodeRelease(pRtree, pChild->pParent); nodeReference(pNode); pChild->pParent = pNode; } } + if( NEVER(pNode==0) ) return SQLITE_ERROR; return xSetMapping(pRtree, iRowid, pNode->iNode); } @@ -191548,11 +196568,12 @@ static int SplitNode( RtreeNode *pParent = pLeft->pParent; int iCell; rc = nodeParentIndex(pRtree, pLeft, &iCell); - if( rc==SQLITE_OK ){ + if( ALWAYS(rc==SQLITE_OK) ){ nodeOverwriteCell(pRtree, pParent, &leftbbox, iCell); rc = AdjustTree(pRtree, pParent, &leftbbox); + assert( rc==SQLITE_OK ); } - if( rc!=SQLITE_OK ){ + if( NEVER(rc!=SQLITE_OK) ){ goto splitnode_out; } } @@ -191627,7 +196648,7 @@ static int fixLeafParent(Rtree *pRtree, RtreeNode *pLeaf){ */ iNode = sqlite3_column_int64(pRtree->pReadParent, 0); for(pTest=pLeaf; pTest && pTest->iNode!=iNode; pTest=pTest->pParent); - if( !pTest ){ + if( pTest==0 ){ rc2 = nodeAcquire(pRtree, iNode, 0, &pChild->pParent); } } @@ -191658,6 +196679,7 @@ static int removeNode(Rtree *pRtree, RtreeNode *pNode, int iHeight){ pParent = pNode->pParent; pNode->pParent = 0; rc = deleteCell(pRtree, pParent, iCell, iHeight+1); + testcase( rc!=SQLITE_OK ); } rc2 = nodeRelease(pRtree, pParent); if( rc==SQLITE_OK ){ @@ -191880,7 +196902,7 @@ static int rtreeInsertCell( } }else{ rc = AdjustTree(pRtree, pNode, pCell); - if( rc==SQLITE_OK ){ + if( ALWAYS(rc==SQLITE_OK) ){ if( iHeight==0 ){ rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode); }else{ @@ -191986,7 +197008,7 @@ static int rtreeDeleteRowid(Rtree *pRtree, sqlite3_int64 iDelete){ int rc2; RtreeNode *pChild = 0; i64 iChild = nodeGetRowid(pRtree, pRoot, 0); - rc = nodeAcquire(pRtree, iChild, pRoot, &pChild); + rc = nodeAcquire(pRtree, iChild, pRoot, &pChild); /* tag-20210916a */ if( rc==SQLITE_OK ){ rc = removeNode(pRtree, pChild, pRtree->iDepth-1); } @@ -192321,7 +197343,7 @@ static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){ char *zSql; sqlite3_stmt *p; int rc; - i64 nRow = 0; + i64 nRow = RTREE_MIN_ROWEST; rc = sqlite3_table_column_metadata( db, pRtree->zDb, "sqlite_stat1",0,0,0,0,0,0 @@ -192338,20 +197360,10 @@ static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){ if( rc==SQLITE_OK ){ if( sqlite3_step(p)==SQLITE_ROW ) nRow = sqlite3_column_int64(p, 0); rc = sqlite3_finalize(p); - }else if( rc!=SQLITE_NOMEM ){ - rc = SQLITE_OK; - } - - if( rc==SQLITE_OK ){ - if( nRow==0 ){ - pRtree->nRowEst = RTREE_DEFAULT_ROWEST; - }else{ - pRtree->nRowEst = MAX(nRow, RTREE_MIN_ROWEST); - } } sqlite3_free(zSql); } - + pRtree->nRowEst = MAX(nRow, RTREE_MIN_ROWEST); return rc; } @@ -192501,9 +197513,12 @@ static int rtreeSqlInit( sqlite3_str_appendf(p, "UPDATE \"%w\".\"%w_rowid\"SET ", zDb, zPrefix); for(ii=0; iinAux; ii++){ if( ii ) sqlite3_str_append(p, ",", 1); +#ifdef SQLITE_ENABLE_GEOPOLY if( iinAuxNotNull ){ sqlite3_str_appendf(p,"a%d=coalesce(?%d,a%d)",ii,ii+2,ii); - }else{ + }else +#endif + { sqlite3_str_appendf(p,"a%d=?%d",ii,ii+2); } } @@ -192768,6 +197783,7 @@ static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){ tree.nDim2 = tree.nDim*2; tree.nBytesPerCell = 8 + 8 * tree.nDim; node.zData = (u8 *)sqlite3_value_blob(apArg[1]); + if( node.zData==0 ) return; nData = sqlite3_value_bytes(apArg[1]); if( nData<4 ) return; if( nData=(4+6*sizeof(GeoCoord)) ){ const unsigned char *a = sqlite3_value_blob(pVal); int nVertex; + if( a==0 ){ + if( pCtx ) sqlite3_result_error_nomem(pCtx); + return 0; + } nVertex = (a[1]<<16) + (a[2]<<8) + a[3]; if( (a[0]==0 || a[0]==1) && (nVertex*2*sizeof(GeoCoord) + 4)==(unsigned int)nByte @@ -193970,7 +198998,7 @@ static GeoPoly *geopolyBBox( aCoord[2].f = mnY; aCoord[3].f = mxY; } - }else{ + }else if( aCoord ){ memset(aCoord, 0, sizeof(RtreeCoord)*4); } return pOut; @@ -194421,11 +199449,11 @@ static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2){ }else{ /* Remove a segment */ if( pActive==pThisEvent->pSeg ){ - pActive = pActive->pNext; + pActive = ALWAYS(pActive) ? pActive->pNext : 0; }else{ for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ if( pSeg->pNext==pThisEvent->pSeg ){ - pSeg->pNext = pSeg->pNext->pNext; + pSeg->pNext = ALWAYS(pSeg->pNext) ? pSeg->pNext->pNext : 0; break; } } @@ -194669,6 +199697,7 @@ static int geopolyFilter( RtreeCoord bbox[4]; RtreeConstraint *p; assert( argc==1 ); + assert( argv[0]!=0 ); geopolyBBox(0, argv[0], bbox, &rc); if( rc ){ goto geopoly_filter_end; @@ -194896,6 +199925,7 @@ static int geopolyUpdate( || !sqlite3_value_nochange(aData[2]) /* UPDATE _shape */ || oldRowid!=newRowid) /* Rowid change */ ){ + assert( aData[2]!=0 ); geopolyBBox(0, aData[2], cell.aCoord, &rc); if( rc ){ if( rc==SQLITE_ERROR ){ @@ -195249,7 +200279,10 @@ SQLITE_API int sqlite3_rtree_query_callback( /* Allocate and populate the context object. */ pGeomCtx = (RtreeGeomCallback *)sqlite3_malloc(sizeof(RtreeGeomCallback)); - if( !pGeomCtx ) return SQLITE_NOMEM; + if( !pGeomCtx ){ + if( xDestructor ) xDestructor(pContext); + return SQLITE_NOMEM; + } pGeomCtx->xGeom = 0; pGeomCtx->xQueryFunc = xQueryFunc; pGeomCtx->xDestructor = xDestructor; @@ -196820,6 +201853,13 @@ SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName); # define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;} #endif +/* +** Name of the URI option that causes RBU to take an exclusive lock as +** part of the incremental checkpoint operation. +*/ +#define RBU_EXCLUSIVE_CHECKPOINT "rbu_exclusive_checkpoint" + + /* ** The rbu_state table is used to save the state of a partially applied ** update so that it can be resumed later. The table consists of integer @@ -197904,7 +202944,9 @@ static void rbuTableType( assert( p->rc==SQLITE_OK ); p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[0], &p->zErrmsg, sqlite3_mprintf( - "SELECT (sql LIKE 'create virtual%%'), rootpage" + "SELECT " + " (sql COLLATE nocase BETWEEN 'CREATE VIRTUAL' AND 'CREATE VIRTUAM')," + " rootpage" " FROM sqlite_schema" " WHERE name=%Q", zTab )); @@ -198330,7 +203372,9 @@ char *rbuVacuumIndexStart( zSep = ""; for(iCol=0; iColnCol; iCol++){ const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol); - if( zQuoted[0]=='N' ){ + if( zQuoted==0 ){ + p->rc = SQLITE_NOMEM; + }else if( zQuoted[0]=='N' ){ bFailed = 1; break; } @@ -199435,7 +204479,7 @@ static RbuState *rbuLoadState(sqlite3rbu *p){ break; case RBU_STATE_OALSZ: - pRet->iOalSz = (u32)sqlite3_column_int64(pStmt, 1); + pRet->iOalSz = sqlite3_column_int64(pStmt, 1); break; case RBU_STATE_PHASEONESTEP: @@ -199462,13 +204506,19 @@ static RbuState *rbuLoadState(sqlite3rbu *p){ /* ** Open the database handle and attach the RBU database as "rbu". If an ** error occurs, leave an error code and message in the RBU handle. +** +** If argument dbMain is not NULL, then it is a database handle already +** open on the target database. Use this handle instead of opening a new +** one. */ -static void rbuOpenDatabase(sqlite3rbu *p, int *pbRetry){ +static void rbuOpenDatabase(sqlite3rbu *p, sqlite3 *dbMain, int *pbRetry){ assert( p->rc || (p->dbMain==0 && p->dbRbu==0) ); assert( p->rc || rbuIsVacuum(p) || p->zTarget!=0 ); + assert( dbMain==0 || rbuIsVacuum(p)==0 ); /* Open the RBU database */ p->dbRbu = rbuOpenDbhandle(p, p->zRbu, 1); + p->dbMain = dbMain; if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){ sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p); @@ -199834,15 +204884,31 @@ static void rbuCheckpointFrame(sqlite3rbu *p, RbuFrame *pFrame){ /* -** Take an EXCLUSIVE lock on the database file. +** Take an EXCLUSIVE lock on the database file. Return SQLITE_OK if +** successful, or an SQLite error code otherwise. */ -static void rbuLockDatabase(sqlite3rbu *p){ - sqlite3_file *pReal = p->pTargetFd->pReal; - assert( p->rc==SQLITE_OK ); - p->rc = pReal->pMethods->xLock(pReal, SQLITE_LOCK_SHARED); - if( p->rc==SQLITE_OK ){ - p->rc = pReal->pMethods->xLock(pReal, SQLITE_LOCK_EXCLUSIVE); +static int rbuLockDatabase(sqlite3 *db){ + int rc = SQLITE_OK; + sqlite3_file *fd = 0; + sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, &fd); + + if( fd->pMethods ){ + rc = fd->pMethods->xLock(fd, SQLITE_LOCK_SHARED); + if( rc==SQLITE_OK ){ + rc = fd->pMethods->xLock(fd, SQLITE_LOCK_EXCLUSIVE); + } } + return rc; +} + +/* +** Return true if the database handle passed as the only argument +** was opened with the rbu_exclusive_checkpoint=1 URI parameter +** specified. Or false otherwise. +*/ +static int rbuExclusiveCheckpoint(sqlite3 *db){ + const char *zUri = sqlite3_db_filename(db, 0); + return sqlite3_uri_boolean(zUri, RBU_EXCLUSIVE_CHECKPOINT, 0); } #if defined(_WIN32_WCE) @@ -199900,18 +204966,24 @@ static void rbuMoveOalFile(sqlite3rbu *p){ ** In order to ensure that there are no database readers, an EXCLUSIVE ** lock is obtained here before the *-oal is moved to *-wal. */ - rbuLockDatabase(p); - if( p->rc==SQLITE_OK ){ - rbuFileSuffix3(zBase, zWal); - rbuFileSuffix3(zBase, zOal); + sqlite3 *dbMain = 0; + rbuFileSuffix3(zBase, zWal); + rbuFileSuffix3(zBase, zOal); + + /* Re-open the databases. */ + rbuObjIterFinalize(&p->objiter); + sqlite3_close(p->dbRbu); + sqlite3_close(p->dbMain); + p->dbMain = 0; + p->dbRbu = 0; - /* Re-open the databases. */ - rbuObjIterFinalize(&p->objiter); - sqlite3_close(p->dbRbu); - sqlite3_close(p->dbMain); - p->dbMain = 0; - p->dbRbu = 0; + dbMain = rbuOpenDbhandle(p, p->zTarget, 1); + if( dbMain ){ + assert( p->rc==SQLITE_OK ); + p->rc = rbuLockDatabase(dbMain); + } + if( p->rc==SQLITE_OK ){ #if defined(_WIN32_WCE) { LPWSTR zWideOal; @@ -199938,11 +205010,19 @@ static void rbuMoveOalFile(sqlite3rbu *p){ #else p->rc = rename(zOal, zWal) ? SQLITE_IOERR : SQLITE_OK; #endif + } - if( p->rc==SQLITE_OK ){ - rbuOpenDatabase(p, 0); - rbuSetupCheckpoint(p, 0); - } + if( p->rc!=SQLITE_OK + || rbuIsVacuum(p) + || rbuExclusiveCheckpoint(dbMain)==0 + ){ + sqlite3_close(dbMain); + dbMain = 0; + } + + if( p->rc==SQLITE_OK ){ + rbuOpenDatabase(p, dbMain, 0); + rbuSetupCheckpoint(p, 0); } } @@ -200693,9 +205773,9 @@ static sqlite3rbu *openRbuHandle( ** If this is the case, it will have been checkpointed and deleted ** when the handle was closed and a second attempt to open the ** database may succeed. */ - rbuOpenDatabase(p, &bRetry); + rbuOpenDatabase(p, 0, &bRetry); if( bRetry ){ - rbuOpenDatabase(p, 0); + rbuOpenDatabase(p, 0, 0); } } @@ -200790,6 +205870,14 @@ static sqlite3rbu *openRbuHandle( }else if( p->eStage==RBU_STAGE_MOVE ){ /* no-op */ }else if( p->eStage==RBU_STAGE_CKPT ){ + if( !rbuIsVacuum(p) && rbuExclusiveCheckpoint(p->dbMain) ){ + /* If the rbu_exclusive_checkpoint=1 URI parameter was specified + ** and an incremental checkpoint is being resumed, attempt an + ** exclusive lock on the db file. If this fails, so be it. */ + p->eStage = RBU_STAGE_DONE; + rbuLockDatabase(p->dbMain); + p->eStage = RBU_STAGE_CKPT; + } rbuSetupCheckpoint(p, pState); }else if( p->eStage==RBU_STAGE_DONE ){ p->rc = SQLITE_DONE; @@ -200827,7 +205915,6 @@ SQLITE_API sqlite3rbu *sqlite3rbu_open( const char *zState ){ if( zTarget==0 || zRbu==0 ){ return rbuMisuseError(); } - /* TODO: Check that zTarget and zRbu are non-NULL */ return openRbuHandle(zTarget, zRbu, zState); } @@ -201538,22 +206625,24 @@ static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){ #endif assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) ); - if( pRbu && (pRbu->eStage==RBU_STAGE_OAL || pRbu->eStage==RBU_STAGE_MOVE) ){ - /* Magic number 1 is the WAL_CKPT_LOCK lock. Preventing SQLite from - ** taking this lock also prevents any checkpoints from occurring. - ** todo: really, it's not clear why this might occur, as - ** wal_autocheckpoint ought to be turned off. */ + if( pRbu && ( + pRbu->eStage==RBU_STAGE_OAL + || pRbu->eStage==RBU_STAGE_MOVE + || pRbu->eStage==RBU_STAGE_DONE + )){ + /* Prevent SQLite from taking a shm-lock on the target file when it + ** is supplying heap memory to the upper layer in place of *-shm + ** segments. */ if( ofst==WAL_LOCK_CKPT && n==1 ) rc = SQLITE_BUSY; }else{ int bCapture = 0; if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){ bCapture = 1; } - if( bCapture==0 || 0==(flags & SQLITE_SHM_UNLOCK) ){ rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags); if( bCapture && rc==SQLITE_OK ){ - pRbu->mLock |= (1 << ofst); + pRbu->mLock |= ((1<pRbu && pDb->pRbu->eStage==RBU_STAGE_OAL ){ - /* This call is to open a *-wal file. Intead, open the *-oal. This - ** code ensures that the string passed to xOpen() is terminated by a - ** pair of '\0' bytes in case the VFS attempts to extract a URI - ** parameter from it. */ - const char *zBase = zName; - size_t nCopy; - char *zCopy; + /* This call is to open a *-wal file. Intead, open the *-oal. */ + size_t nOpen; if( rbuIsVacuum(pDb->pRbu) ){ - zBase = sqlite3_db_filename(pDb->pRbu->dbRbu, "main"); - zBase = sqlite3_filename_wal(zBase); - } - nCopy = strlen(zBase); - zCopy = sqlite3_malloc64(nCopy+2); - if( zCopy ){ - memcpy(zCopy, zBase, nCopy); - zCopy[nCopy-3] = 'o'; - zCopy[nCopy] = '\0'; - zCopy[nCopy+1] = '\0'; - zOpen = (const char*)(pFd->zDel = zCopy); - }else{ - rc = SQLITE_NOMEM; + zOpen = sqlite3_db_filename(pDb->pRbu->dbRbu, "main"); + zOpen = sqlite3_filename_wal(zOpen); } + nOpen = strlen(zOpen); + ((char*)zOpen)[nOpen-3] = 'o'; pFd->pRbu = pDb->pRbu; } pDb->pWalFd = pFd; @@ -202042,6 +207117,15 @@ SQLITE_API sqlite3_int64 sqlite3rbu_temp_size(sqlite3rbu *pRbu){ #if (defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)) \ && !defined(SQLITE_OMIT_VIRTUALTABLE) +/* +** The pager and btree modules arrange objects in memory so that there are +** always approximately 200 bytes of addressable memory following each page +** buffer. This way small buffer overreads caused by corrupt database pages +** do not cause undefined behaviour. This module pads each page buffer +** by the following number of bytes for the same purpose. +*/ +#define DBSTAT_PAGE_PADDING_BYTES 256 + /* ** Page paths: ** @@ -202109,9 +207193,8 @@ struct StatCell { /* Size information for a single btree page */ struct StatPage { u32 iPgno; /* Page number */ - DbPage *pPg; /* Page content */ + u8 *aPg; /* Page buffer from sqlite3_malloc() */ int iCell; /* Current cell */ - char *zPath; /* Path to this page */ /* Variables populated by statDecodePage(): */ @@ -202323,18 +207406,25 @@ static void statClearCells(StatPage *p){ } static void statClearPage(StatPage *p){ + u8 *aPg = p->aPg; statClearCells(p); - sqlite3PagerUnref(p->pPg); sqlite3_free(p->zPath); memset(p, 0, sizeof(StatPage)); + p->aPg = aPg; } static void statResetCsr(StatCursor *pCsr){ int i; - sqlite3_reset(pCsr->pStmt); + /* In some circumstances, specifically if an OOM has occurred, the call + ** to sqlite3_reset() may cause the pager to be reset (emptied). It is + ** important that statClearPage() is called to free any page refs before + ** this happens. dbsqlfuzz 9ed3e4e3816219d3509d711636c38542bf3f40b1. */ for(i=0; iaPage); i++){ statClearPage(&pCsr->aPage[i]); + sqlite3_free(pCsr->aPage[i].aPg); + pCsr->aPage[i].aPg = 0; } + sqlite3_reset(pCsr->pStmt); pCsr->iPage = 0; sqlite3_free(pCsr->zPath); pCsr->zPath = 0; @@ -202399,7 +207489,7 @@ static int statDecodePage(Btree *pBt, StatPage *p){ int isLeaf; int szPage; - u8 *aData = sqlite3PagerGetData(p->pPg); + u8 *aData = p->aPg; u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0]; p->flags = aHdr[0]; @@ -202470,7 +207560,7 @@ static int statDecodePage(Btree *pBt, StatPage *p){ if( nPayload>(u32)nLocal ){ int j; int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4); - if( iOff+nLocal>nUsable || nPayload>0x7fffffff ){ + if( iOff+nLocal+4>nUsable || nPayload>0x7fffffff ){ goto statPageIsCorrupt; } pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4); @@ -202529,6 +207619,38 @@ static void statSizeAndOffset(StatCursor *pCsr){ } } +/* +** Load a copy of the page data for page iPg into the buffer belonging +** to page object pPg. Allocate the buffer if necessary. Return SQLITE_OK +** if successful, or an SQLite error code otherwise. +*/ +static int statGetPage( + Btree *pBt, /* Load page from this b-tree */ + u32 iPg, /* Page number to load */ + StatPage *pPg /* Load page into this object */ +){ + int pgsz = sqlite3BtreeGetPageSize(pBt); + DbPage *pDbPage = 0; + int rc; + + if( pPg->aPg==0 ){ + pPg->aPg = (u8*)sqlite3_malloc(pgsz + DBSTAT_PAGE_PADDING_BYTES); + if( pPg->aPg==0 ){ + return SQLITE_NOMEM_BKPT; + } + memset(&pPg->aPg[pgsz], 0, DBSTAT_PAGE_PADDING_BYTES); + } + + rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPg, &pDbPage, 0); + if( rc==SQLITE_OK ){ + const u8 *a = sqlite3PagerGetData(pDbPage); + memcpy(pPg->aPg, a, pgsz); + sqlite3PagerUnref(pDbPage); + } + + return rc; +} + /* ** Move a DBSTAT cursor to the next entry. Normally, the next ** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0), @@ -202547,7 +207669,7 @@ static int statNext(sqlite3_vtab_cursor *pCursor){ pCsr->zPath = 0; statNextRestart: - if( pCsr->aPage[0].pPg==0 ){ + if( pCsr->iPage<0 ){ /* Start measuring space on the next btree */ statResetCounts(pCsr); rc = sqlite3_step(pCsr->pStmt); @@ -202559,7 +207681,7 @@ static int statNext(sqlite3_vtab_cursor *pCursor){ pCsr->isEof = 1; return sqlite3_reset(pCsr->pStmt); } - rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg, 0); + rc = statGetPage(pBt, iRoot, &pCsr->aPage[0]); pCsr->aPage[0].iPgno = iRoot; pCsr->aPage[0].iCell = 0; if( !pCsr->isAgg ){ @@ -202610,9 +207732,8 @@ static int statNext(sqlite3_vtab_cursor *pCursor){ if( !p->iRightChildPg || p->iCell>p->nCell ){ statClearPage(p); - if( pCsr->iPage>0 ){ - pCsr->iPage--; - }else if( pCsr->isAgg ){ + pCsr->iPage--; + if( pCsr->isAgg && pCsr->iPage<0 ){ /* label-statNext-done: When computing aggregate space usage over ** an entire btree, this is the exit point from this function */ return SQLITE_OK; @@ -202631,7 +207752,7 @@ static int statNext(sqlite3_vtab_cursor *pCursor){ }else{ p[1].iPgno = p->aCell[p->iCell].iChildPg; } - rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg, 0); + rc = statGetPage(pBt, p[1].iPgno, &p[1]); pCsr->nPage++; p[1].iCell = 0; if( !pCsr->isAgg ){ @@ -202761,6 +207882,7 @@ static int statFilter( } if( rc==SQLITE_OK ){ + pCsr->iPage = -1; rc = statNext(pCursor); } return rc; @@ -203334,12 +208456,15 @@ struct SessionHook { struct sqlite3_session { sqlite3 *db; /* Database handle session is attached to */ char *zDb; /* Name of database session is attached to */ + int bEnableSize; /* True if changeset_size() enabled */ int bEnable; /* True if currently recording */ int bIndirect; /* True if all changes are indirect */ int bAutoAttach; /* True to auto-attach tables */ int rc; /* Non-zero if an error has occurred */ void *pFilterCtx; /* First argument to pass to xTableFilter */ int (*xTableFilter)(void *pCtx, const char *zTab); + i64 nMalloc; /* Number of bytes of data allocated */ + i64 nMaxChangesetSize; sqlite3_value *pZeroBlob; /* Value containing X'' */ sqlite3_session *pNext; /* Next session object on same db. */ SessionTable *pTable; /* List of attached tables */ @@ -203382,6 +208507,7 @@ struct sqlite3_changeset_iter { SessionBuffer tblhdr; /* Buffer to hold apValue/zTab/abPK/ */ int bPatchset; /* True if this is a patchset */ int bInvert; /* True to invert changeset */ + int bSkipEmpty; /* Skip noop UPDATE changes */ int rc; /* Iterator error code */ sqlite3_stmt *pConflict; /* Points to conflicting row, if any */ char *zTab; /* Current table */ @@ -203581,8 +208707,9 @@ struct SessionTable { ** this structure stored in a SessionTable.aChange[] hash table. */ struct SessionChange { - int op; /* One of UPDATE, DELETE, INSERT */ - int bIndirect; /* True if this change is "indirect" */ + u8 op; /* One of UPDATE, DELETE, INSERT */ + u8 bIndirect; /* True if this change is "indirect" */ + int nMaxSize; /* Max size of eventual changeset record */ int nRecord; /* Number of bytes in buffer aRecord[] */ u8 *aRecord; /* Buffer containing old.* record */ SessionChange *pNext; /* For hash-table collisions */ @@ -203707,7 +208834,7 @@ static int sessionSerializeValue( if( aBuf ){ sessionVarintPut(&aBuf[1], n); - if( n ) memcpy(&aBuf[nVarint + 1], z, n); + if( n>0 ) memcpy(&aBuf[nVarint + 1], z, n); } nByte = 1 + nVarint + n; @@ -203723,6 +208850,26 @@ static int sessionSerializeValue( return SQLITE_OK; } +/* +** Allocate and return a pointer to a buffer nByte bytes in size. If +** pSession is not NULL, increase the sqlite3_session.nMalloc variable +** by the number of bytes allocated. +*/ +static void *sessionMalloc64(sqlite3_session *pSession, i64 nByte){ + void *pRet = sqlite3_malloc64(nByte); + if( pSession ) pSession->nMalloc += sqlite3_msize(pRet); + return pRet; +} + +/* +** Free buffer pFree, which must have been allocated by an earlier +** call to sessionMalloc64(). If pSession is not NULL, decrease the +** sqlite3_session.nMalloc counter by the number of bytes freed. +*/ +static void sessionFree(sqlite3_session *pSession, void *pFree){ + if( pSession ) pSession->nMalloc -= sqlite3_msize(pFree); + sqlite3_free(pFree); +} /* ** This macro is used to calculate hash key values for data structures. In @@ -204190,13 +209337,19 @@ static int sessionPreupdateEqual( ** Growing the hash table in this case is a performance optimization only, ** it is not required for correct operation. */ -static int sessionGrowHash(int bPatchset, SessionTable *pTab){ +static int sessionGrowHash( + sqlite3_session *pSession, /* For memory accounting. May be NULL */ + int bPatchset, + SessionTable *pTab +){ if( pTab->nChange==0 || pTab->nEntry>=(pTab->nChange/2) ){ int i; SessionChange **apNew; sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128); - apNew = (SessionChange **)sqlite3_malloc64(sizeof(SessionChange *) * nNew); + apNew = (SessionChange**)sessionMalloc64( + pSession, sizeof(SessionChange*) * nNew + ); if( apNew==0 ){ if( pTab->nChange==0 ){ return SQLITE_ERROR; @@ -204217,7 +209370,7 @@ static int sessionGrowHash(int bPatchset, SessionTable *pTab){ } } - sqlite3_free(pTab->apChange); + sessionFree(pSession, pTab->apChange); pTab->nChange = nNew; pTab->apChange = apNew; } @@ -204251,6 +209404,7 @@ static int sessionGrowHash(int bPatchset, SessionTable *pTab){ ** be freed using sqlite3_free() by the caller */ static int sessionTableInfo( + sqlite3_session *pSession, /* For memory accounting. May be NULL */ sqlite3 *db, /* Database connection */ const char *zDb, /* Name of attached database (e.g. "main") */ const char *zThis, /* Table name */ @@ -204285,16 +209439,32 @@ static int sessionTableInfo( }else if( rc==SQLITE_ERROR ){ zPragma = sqlite3_mprintf(""); }else{ + *pazCol = 0; + *pabPK = 0; + *pnCol = 0; + if( pzTab ) *pzTab = 0; return rc; } }else{ zPragma = sqlite3_mprintf("PRAGMA '%q'.table_info('%q')", zDb, zThis); } - if( !zPragma ) return SQLITE_NOMEM; + if( !zPragma ){ + *pazCol = 0; + *pabPK = 0; + *pnCol = 0; + if( pzTab ) *pzTab = 0; + return SQLITE_NOMEM; + } rc = sqlite3_prepare_v2(db, zPragma, -1, &pStmt, 0); sqlite3_free(zPragma); - if( rc!=SQLITE_OK ) return rc; + if( rc!=SQLITE_OK ){ + *pazCol = 0; + *pabPK = 0; + *pnCol = 0; + if( pzTab ) *pzTab = 0; + return rc; + } nByte = nThis + 1; while( SQLITE_ROW==sqlite3_step(pStmt) ){ @@ -204305,7 +209475,7 @@ static int sessionTableInfo( if( rc==SQLITE_OK ){ nByte += nDbCol * (sizeof(const char *) + sizeof(u8) + 1); - pAlloc = sqlite3_malloc64(nByte); + pAlloc = sessionMalloc64(pSession, nByte); if( pAlloc==0 ){ rc = SQLITE_NOMEM; } @@ -204348,7 +209518,7 @@ static int sessionTableInfo( *pabPK = 0; *pnCol = 0; if( pzTab ) *pzTab = 0; - sqlite3_free(azCol); + sessionFree(pSession, azCol); } sqlite3_finalize(pStmt); return rc; @@ -204370,7 +209540,7 @@ static int sessionInitTable(sqlite3_session *pSession, SessionTable *pTab){ if( pTab->nCol==0 ){ u8 *abPK; assert( pTab->azCol==0 || pTab->abPK==0 ); - pSession->rc = sessionTableInfo(pSession->db, pSession->zDb, + pSession->rc = sessionTableInfo(pSession, pSession->db, pSession->zDb, pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK ); if( pSession->rc==SQLITE_OK ){ @@ -204384,6 +209554,12 @@ static int sessionInitTable(sqlite3_session *pSession, SessionTable *pTab){ if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){ pTab->bStat1 = 1; } + + if( pSession->bEnableSize ){ + pSession->nMaxChangesetSize += ( + 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1 + ); + } } } return (pSession->rc || pTab->abPK==0); @@ -204429,6 +209605,103 @@ static int sessionStat1Depth(void *pCtx){ return p->hook.xDepth(p->hook.pCtx); } +static int sessionUpdateMaxSize( + int op, + sqlite3_session *pSession, /* Session object pTab is attached to */ + SessionTable *pTab, /* Table that change applies to */ + SessionChange *pC /* Update pC->nMaxSize */ +){ + i64 nNew = 2; + if( pC->op==SQLITE_INSERT ){ + if( op!=SQLITE_DELETE ){ + int ii; + for(ii=0; iinCol; ii++){ + sqlite3_value *p = 0; + pSession->hook.xNew(pSession->hook.pCtx, ii, &p); + sessionSerializeValue(0, p, &nNew); + } + } + }else if( op==SQLITE_DELETE ){ + nNew += pC->nRecord; + if( sqlite3_preupdate_blobwrite(pSession->db)>=0 ){ + nNew += pC->nRecord; + } + }else{ + int ii; + u8 *pCsr = pC->aRecord; + for(ii=0; iinCol; ii++){ + int bChanged = 1; + int nOld = 0; + int eType; + sqlite3_value *p = 0; + pSession->hook.xNew(pSession->hook.pCtx, ii, &p); + if( p==0 ){ + return SQLITE_NOMEM; + } + + eType = *pCsr++; + switch( eType ){ + case SQLITE_NULL: + bChanged = sqlite3_value_type(p)!=SQLITE_NULL; + break; + + case SQLITE_FLOAT: + case SQLITE_INTEGER: { + if( eType==sqlite3_value_type(p) ){ + sqlite3_int64 iVal = sessionGetI64(pCsr); + if( eType==SQLITE_INTEGER ){ + bChanged = (iVal!=sqlite3_value_int64(p)); + }else{ + double dVal; + memcpy(&dVal, &iVal, 8); + bChanged = (dVal!=sqlite3_value_double(p)); + } + } + nOld = 8; + pCsr += 8; + break; + } + + default: { + int nByte; + nOld = sessionVarintGet(pCsr, &nByte); + pCsr += nOld; + nOld += nByte; + assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB ); + if( eType==sqlite3_value_type(p) + && nByte==sqlite3_value_bytes(p) + && (nByte==0 || 0==memcmp(pCsr, sqlite3_value_blob(p), nByte)) + ){ + bChanged = 0; + } + pCsr += nByte; + break; + } + } + + if( bChanged && pTab->abPK[ii] ){ + nNew = pC->nRecord + 2; + break; + } + + if( bChanged ){ + nNew += 1 + nOld; + sessionSerializeValue(0, p, &nNew); + }else if( pTab->abPK[ii] ){ + nNew += 2 + nOld; + }else{ + nNew += 2; + } + } + } + + if( nNew>pC->nMaxSize ){ + int nIncr = nNew - pC->nMaxSize; + pC->nMaxSize = nNew; + pSession->nMaxChangesetSize += nIncr; + } + return SQLITE_OK; +} /* ** This function is only called from with a pre-update-hook reporting a @@ -204461,7 +209734,7 @@ static void sessionPreupdateOneChange( } /* Grow the hash table if required */ - if( sessionGrowHash(0, pTab) ){ + if( sessionGrowHash(pSession, 0, pTab) ){ pSession->rc = SQLITE_NOMEM; return; } @@ -204502,7 +209775,6 @@ static void sessionPreupdateOneChange( /* Create a new change object containing all the old values (if ** this is an SQLITE_UPDATE or SQLITE_DELETE), or just the PK ** values (if this is an INSERT). */ - SessionChange *pChange; /* New change object */ sqlite3_int64 nByte; /* Number of bytes to allocate */ int i; /* Used to iterate through columns */ @@ -204528,13 +209800,13 @@ static void sessionPreupdateOneChange( } /* Allocate the change object */ - pChange = (SessionChange *)sqlite3_malloc64(nByte); - if( !pChange ){ + pC = (SessionChange *)sessionMalloc64(pSession, nByte); + if( !pC ){ rc = SQLITE_NOMEM; goto error_out; }else{ - memset(pChange, 0, sizeof(SessionChange)); - pChange->aRecord = (u8 *)&pChange[1]; + memset(pC, 0, sizeof(SessionChange)); + pC->aRecord = (u8 *)&pC[1]; } /* Populate the change object. None of the preupdate_old(), @@ -204549,17 +209821,17 @@ static void sessionPreupdateOneChange( }else if( pTab->abPK[i] ){ pSession->hook.xNew(pSession->hook.pCtx, i, &p); } - sessionSerializeValue(&pChange->aRecord[nByte], p, &nByte); + sessionSerializeValue(&pC->aRecord[nByte], p, &nByte); } /* Add the change to the hash-table */ if( pSession->bIndirect || pSession->hook.xDepth(pSession->hook.pCtx) ){ - pChange->bIndirect = 1; + pC->bIndirect = 1; } - pChange->nRecord = nByte; - pChange->op = op; - pChange->pNext = pTab->apChange[iHash]; - pTab->apChange[iHash] = pChange; + pC->nRecord = nByte; + pC->op = op; + pC->pNext = pTab->apChange[iHash]; + pTab->apChange[iHash] = pC; }else if( pC->bIndirect ){ /* If the existing change is considered "indirect", but this current @@ -204570,8 +209842,14 @@ static void sessionPreupdateOneChange( pC->bIndirect = 0; } } + + assert( rc==SQLITE_OK ); + if( pSession->bEnableSize ){ + rc = sessionUpdateMaxSize(op, pSession, pTab, pC); + } } + /* If an error has occurred, mark the session object as failed. */ error_out: if( pTab->bStat1 ){ @@ -204604,7 +209882,11 @@ static int sessionFindTable( ){ rc = sqlite3session_attach(pSession, zName); if( rc==SQLITE_OK ){ - for(pRet=pSession->pTable; pRet->pNext; pRet=pRet->pNext); + pRet = pSession->pTable; + while( ALWAYS(pRet) && pRet->pNext ){ + pRet = pRet->pNext; + } + assert( pRet!=0 ); assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) ); } } @@ -204901,7 +210183,7 @@ SQLITE_API int sqlite3session_diff( int nCol; /* Columns in zFrom.zTbl */ u8 *abPK; const char **azCol = 0; - rc = sessionTableInfo(db, zFrom, zTbl, &nCol, 0, &azCol, &abPK); + rc = sessionTableInfo(0, db, zFrom, zTbl, &nCol, 0, &azCol, &abPK); if( rc==SQLITE_OK ){ if( pTo->nCol!=nCol ){ bMismatch = 1; @@ -204999,7 +210281,7 @@ SQLITE_API int sqlite3session_create( ** Free the list of table objects passed as the first argument. The contents ** of the changed-rows hash tables are also deleted. */ -static void sessionDeleteTable(SessionTable *pList){ +static void sessionDeleteTable(sqlite3_session *pSession, SessionTable *pList){ SessionTable *pNext; SessionTable *pTab; @@ -205011,12 +210293,12 @@ static void sessionDeleteTable(SessionTable *pList){ SessionChange *pNextChange; for(p=pTab->apChange[i]; p; p=pNextChange){ pNextChange = p->pNext; - sqlite3_free(p); + sessionFree(pSession, p); } } - sqlite3_free((char*)pTab->azCol); /* cast works around VC++ bug */ - sqlite3_free(pTab->apChange); - sqlite3_free(pTab); + sessionFree(pSession, (char*)pTab->azCol); /* cast works around VC++ bug */ + sessionFree(pSession, pTab->apChange); + sessionFree(pSession, pTab); } } @@ -205044,9 +210326,11 @@ SQLITE_API void sqlite3session_delete(sqlite3_session *pSession){ /* Delete all attached table objects. And the contents of their ** associated hash-tables. */ - sessionDeleteTable(pSession->pTable); + sessionDeleteTable(pSession, pSession->pTable); - /* Free the session object itself. */ + /* Assert that all allocations have been freed and then free the + ** session object itself. */ + assert( pSession->nMalloc==0 ); sqlite3_free(pSession); } @@ -205093,7 +210377,8 @@ SQLITE_API int sqlite3session_attach( if( !pTab ){ /* Allocate new SessionTable object. */ - pTab = (SessionTable *)sqlite3_malloc64(sizeof(SessionTable) + nName + 1); + int nByte = sizeof(SessionTable) + nName + 1; + pTab = (SessionTable*)sessionMalloc64(pSession, nByte); if( !pTab ){ rc = SQLITE_NOMEM; }else{ @@ -205123,13 +210408,29 @@ SQLITE_API int sqlite3session_attach( ** If successful, return zero. Otherwise, if an OOM condition is encountered, ** set *pRc to SQLITE_NOMEM and return non-zero. */ -static int sessionBufferGrow(SessionBuffer *p, size_t nByte, int *pRc){ - if( *pRc==SQLITE_OK && (size_t)(p->nAlloc-p->nBuf)nBuf + nByte; + if( *pRc==SQLITE_OK && nReq>p->nAlloc ){ u8 *aNew; i64 nNew = p->nAlloc ? p->nAlloc : 128; + do { nNew = nNew*2; - }while( (size_t)(nNew-p->nBuf)SESSION_MAX_BUFFER_SZ ){ + nNew = SESSION_MAX_BUFFER_SZ; + if( nNewaBuf, nNew); if( 0==aNew ){ @@ -205358,6 +210659,7 @@ static int sessionAppendUpdate( int i; /* Used to iterate through columns */ u8 *pCsr = p->aRecord; /* Used to iterate through old.* values */ + assert( abPK!=0 ); sessionAppendByte(pBuf, SQLITE_UPDATE, &rc); sessionAppendByte(pBuf, p->bIndirect, &rc); for(i=0; ipTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){ if( pTab->nEntry ){ const char *zName = pTab->zName; - int nCol; /* Number of columns in table */ - u8 *abPK; /* Primary key array */ + int nCol = 0; /* Number of columns in table */ + u8 *abPK = 0; /* Primary key array */ const char **azCol = 0; /* Table columns */ int i; /* Used to iterate through hash buckets */ sqlite3_stmt *pSel = 0; /* SELECT statement to query table pTab */ @@ -205690,7 +210994,7 @@ static int sessionGenerateChangeset( int nNoop; /* Size of buffer after writing tbl header */ /* Check the table schema is still Ok. */ - rc = sessionTableInfo(db, pSession->zDb, zName, &nCol, 0, &azCol, &abPK); + rc = sessionTableInfo(0, db, pSession->zDb, zName, &nCol, 0,&azCol,&abPK); if( !rc && (pTab->nCol!=nCol || memcmp(abPK, pTab->abPK, nCol)) ){ rc = SQLITE_SCHEMA; } @@ -205720,6 +211024,7 @@ static int sessionGenerateChangeset( sessionAppendCol(&buf, pSel, iCol, &rc); } }else{ + assert( abPK!=0 ); /* Because sessionSelectStmt() returned ok */ rc = sessionAppendUpdate(&buf, bPatchset, pSel, p, abPK); } }else if( p->op!=SQLITE_INSERT ){ @@ -205780,7 +211085,14 @@ SQLITE_API int sqlite3session_changeset( int *pnChangeset, /* OUT: Size of buffer at *ppChangeset */ void **ppChangeset /* OUT: Buffer containing changeset */ ){ - return sessionGenerateChangeset(pSession, 0, 0, 0, pnChangeset, ppChangeset); + int rc; + + if( pnChangeset==0 || ppChangeset==0 ) return SQLITE_MISUSE; + rc = sessionGenerateChangeset(pSession, 0, 0, 0, pnChangeset,ppChangeset); + assert( rc || pnChangeset==0 + || pSession->bEnableSize==0 || *pnChangeset<=pSession->nMaxChangesetSize + ); + return rc; } /* @@ -205791,6 +211103,7 @@ SQLITE_API int sqlite3session_changeset_strm( int (*xOutput)(void *pOut, const void *pData, int nData), void *pOut ){ + if( xOutput==0 ) return SQLITE_MISUSE; return sessionGenerateChangeset(pSession, 0, xOutput, pOut, 0, 0); } @@ -205802,6 +211115,7 @@ SQLITE_API int sqlite3session_patchset_strm( int (*xOutput)(void *pOut, const void *pData, int nData), void *pOut ){ + if( xOutput==0 ) return SQLITE_MISUSE; return sessionGenerateChangeset(pSession, 1, xOutput, pOut, 0, 0); } @@ -205817,6 +211131,7 @@ SQLITE_API int sqlite3session_patchset( int *pnPatchset, /* OUT: Size of buffer at *ppChangeset */ void **ppPatchset /* OUT: Buffer containing changeset */ ){ + if( pnPatchset==0 || ppPatchset==0 ) return SQLITE_MISUSE; return sessionGenerateChangeset(pSession, 1, 0, 0, pnPatchset, ppPatchset); } @@ -205865,6 +211180,46 @@ SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession){ return (ret==0); } +/* +** Return the amount of heap memory in use. +*/ +SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession){ + return pSession->nMalloc; +} + +/* +** Configure the session object passed as the first argument. +*/ +SQLITE_API int sqlite3session_object_config(sqlite3_session *pSession, int op, void *pArg){ + int rc = SQLITE_OK; + switch( op ){ + case SQLITE_SESSION_OBJCONFIG_SIZE: { + int iArg = *(int*)pArg; + if( iArg>=0 ){ + if( pSession->pTable ){ + rc = SQLITE_MISUSE; + }else{ + pSession->bEnableSize = (iArg!=0); + } + } + *(int*)pArg = pSession->bEnableSize; + break; + } + + default: + rc = SQLITE_MISUSE; + } + + return rc; +} + +/* +** Return the maximum size of sqlite3session_changeset() output. +*/ +SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession){ + return pSession->nMaxChangesetSize; +} + /* ** Do the work for either sqlite3changeset_start() or start_strm(). */ @@ -205874,7 +211229,8 @@ static int sessionChangesetStart( void *pIn, int nChangeset, /* Size of buffer pChangeset in bytes */ void *pChangeset, /* Pointer to buffer containing changeset */ - int bInvert /* True to invert changeset */ + int bInvert, /* True to invert changeset */ + int bSkipEmpty /* True to skip empty UPDATE changes */ ){ sqlite3_changeset_iter *pRet; /* Iterator to return */ int nByte; /* Number of bytes to allocate for iterator */ @@ -205895,6 +211251,7 @@ static int sessionChangesetStart( pRet->in.pIn = pIn; pRet->in.bEof = (xInput ? 0 : 1); pRet->bInvert = bInvert; + pRet->bSkipEmpty = bSkipEmpty; /* Populate the output variable and return success. */ *pp = pRet; @@ -205909,7 +211266,7 @@ SQLITE_API int sqlite3changeset_start( int nChangeset, /* Size of buffer pChangeset in bytes */ void *pChangeset /* Pointer to buffer containing changeset */ ){ - return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, 0); + return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, 0, 0); } SQLITE_API int sqlite3changeset_start_v2( sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */ @@ -205918,7 +211275,7 @@ SQLITE_API int sqlite3changeset_start_v2( int flags ){ int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT); - return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, bInvert); + return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, bInvert, 0); } /* @@ -205929,7 +211286,7 @@ SQLITE_API int sqlite3changeset_start_strm( int (*xInput)(void *pIn, void *pData, int *pnData), void *pIn ){ - return sessionChangesetStart(pp, xInput, pIn, 0, 0, 0); + return sessionChangesetStart(pp, xInput, pIn, 0, 0, 0, 0); } SQLITE_API int sqlite3changeset_start_v2_strm( sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */ @@ -205938,7 +211295,7 @@ SQLITE_API int sqlite3changeset_start_v2_strm( int flags ){ int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT); - return sessionChangesetStart(pp, xInput, pIn, 0, 0, bInvert); + return sessionChangesetStart(pp, xInput, pIn, 0, 0, bInvert, 0); } /* @@ -206064,11 +211421,14 @@ static int sessionReadRecord( SessionInput *pIn, /* Input data */ int nCol, /* Number of values in record */ u8 *abPK, /* Array of primary key flags, or NULL */ - sqlite3_value **apOut /* Write values to this array */ + sqlite3_value **apOut, /* Write values to this array */ + int *pbEmpty ){ int i; /* Used to iterate through columns */ int rc = SQLITE_OK; + assert( pbEmpty==0 || *pbEmpty==0 ); + if( pbEmpty ) *pbEmpty = 1; for(i=0; iaData[pIn->iNext++]; assert( apOut[i]==0 ); if( eType ){ + if( pbEmpty ) *pbEmpty = 0; apOut[i] = sqlite3ValueNew(0); if( !apOut[i] ) rc = SQLITE_NOMEM; } @@ -206259,31 +211620,27 @@ static int sessionChangesetReadTblhdr(sqlite3_changeset_iter *p){ } /* -** Advance the changeset iterator to the next change. +** Advance the changeset iterator to the next change. The differences between +** this function and sessionChangesetNext() are that ** -** If both paRec and pnRec are NULL, then this function works like the public -** API sqlite3changeset_next(). If SQLITE_ROW is returned, then the -** sqlite3changeset_new() and old() APIs may be used to query for values. +** * If pbEmpty is not NULL and the change is a no-op UPDATE (an UPDATE +** that modifies no columns), this function sets (*pbEmpty) to 1. ** -** Otherwise, if paRec and pnRec are not NULL, then a pointer to the change -** record is written to *paRec before returning and the number of bytes in -** the record to *pnRec. -** -** Either way, this function returns SQLITE_ROW if the iterator is -** successfully advanced to the next change in the changeset, an SQLite -** error code if an error occurs, or SQLITE_DONE if there are no further -** changes in the changeset. +** * If the iterator is configured to skip no-op UPDATEs, +** sessionChangesetNext() does that. This function does not. */ -static int sessionChangesetNext( +static int sessionChangesetNextOne( sqlite3_changeset_iter *p, /* Changeset iterator */ u8 **paRec, /* If non-NULL, store record pointer here */ int *pnRec, /* If non-NULL, store size of record here */ - int *pbNew /* If non-NULL, true if new table */ + int *pbNew, /* If non-NULL, true if new table */ + int *pbEmpty ){ int i; u8 op; assert( (paRec==0 && pnRec==0) || (paRec && pnRec) ); + assert( pbEmpty==0 || *pbEmpty==0 ); /* If the iterator is in the error-state, return immediately. */ if( p->rc!=SQLITE_OK ) return p->rc; @@ -206356,13 +211713,13 @@ static int sessionChangesetNext( /* If this is an UPDATE or DELETE, read the old.* record. */ if( p->op!=SQLITE_INSERT && (p->bPatchset==0 || p->op==SQLITE_DELETE) ){ u8 *abPK = p->bPatchset ? p->abPK : 0; - p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld); + p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld, 0); if( p->rc!=SQLITE_OK ) return p->rc; } /* If this is an INSERT or UPDATE, read the new.* record. */ if( p->op!=SQLITE_DELETE ){ - p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew); + p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew, pbEmpty); if( p->rc!=SQLITE_OK ) return p->rc; } @@ -206389,6 +211746,37 @@ static int sessionChangesetNext( return SQLITE_ROW; } +/* +** Advance the changeset iterator to the next change. +** +** If both paRec and pnRec are NULL, then this function works like the public +** API sqlite3changeset_next(). If SQLITE_ROW is returned, then the +** sqlite3changeset_new() and old() APIs may be used to query for values. +** +** Otherwise, if paRec and pnRec are not NULL, then a pointer to the change +** record is written to *paRec before returning and the number of bytes in +** the record to *pnRec. +** +** Either way, this function returns SQLITE_ROW if the iterator is +** successfully advanced to the next change in the changeset, an SQLite +** error code if an error occurs, or SQLITE_DONE if there are no further +** changes in the changeset. +*/ +static int sessionChangesetNext( + sqlite3_changeset_iter *p, /* Changeset iterator */ + u8 **paRec, /* If non-NULL, store record pointer here */ + int *pnRec, /* If non-NULL, store size of record here */ + int *pbNew /* If non-NULL, true if new table */ +){ + int bEmpty; + int rc; + do { + bEmpty = 0; + rc = sessionChangesetNextOne(p, paRec, pnRec, pbNew, &bEmpty); + }while( rc==SQLITE_ROW && p->bSkipEmpty && bEmpty); + return rc; +} + /* ** Advance an iterator created by sqlite3changeset_start() to the next ** change in the changeset. This function may return SQLITE_ROW, SQLITE_DONE @@ -206661,9 +212049,9 @@ static int sessionChangesetInvert( /* Read the old.* and new.* records for the update change. */ pInput->iNext += 2; - rc = sessionReadRecord(pInput, nCol, 0, &apVal[0]); + rc = sessionReadRecord(pInput, nCol, 0, &apVal[0], 0); if( rc==SQLITE_OK ){ - rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol]); + rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol], 0); } /* Write the new old.* record. Consists of the PK columns from the @@ -206707,11 +212095,11 @@ static int sessionChangesetInvert( } assert( rc==SQLITE_OK ); - if( pnInverted ){ + if( pnInverted && ALWAYS(ppInverted) ){ *pnInverted = sOut.nBuf; *ppInverted = sOut.aBuf; sOut.aBuf = 0; - }else if( sOut.nBuf>0 ){ + }else if( sOut.nBuf>0 && ALWAYS(xOutput!=0) ){ rc = xOutput(pOut, sOut.aBuf, sOut.nBuf); } @@ -206764,16 +212152,25 @@ SQLITE_API int sqlite3changeset_invert_strm( return rc; } + +typedef struct SessionUpdate SessionUpdate; +struct SessionUpdate { + sqlite3_stmt *pStmt; + u32 *aMask; + SessionUpdate *pNext; +}; + typedef struct SessionApplyCtx SessionApplyCtx; struct SessionApplyCtx { sqlite3 *db; sqlite3_stmt *pDelete; /* DELETE statement */ - sqlite3_stmt *pUpdate; /* UPDATE statement */ sqlite3_stmt *pInsert; /* INSERT statement */ sqlite3_stmt *pSelect; /* SELECT statement */ int nCol; /* Size of azCol[] and abPK[] arrays */ const char **azCol; /* Array of column names */ u8 *abPK; /* Boolean array - true if column is in PK */ + u32 *aUpdateMask; /* Used by sessionUpdateFind */ + SessionUpdate *pUp; int bStat1; /* True if table is sqlite_stat1 */ int bDeferConstraints; /* True to defer constraints */ int bInvertConstraints; /* Invert when iterating constraints buffer */ @@ -206783,6 +212180,167 @@ struct SessionApplyCtx { u8 bRebase; /* True to collect rebase information */ }; +/* Number of prepared UPDATE statements to cache. */ +#define SESSION_UPDATE_CACHE_SZ 12 + +/* +** Find a prepared UPDATE statement suitable for the UPDATE step currently +** being visited by the iterator. The UPDATE is of the form: +** +** UPDATE tbl SET col = ?, col2 = ? WHERE pk1 IS ? AND pk2 IS ? +*/ +static int sessionUpdateFind( + sqlite3_changeset_iter *pIter, + SessionApplyCtx *p, + int bPatchset, + sqlite3_stmt **ppStmt +){ + int rc = SQLITE_OK; + SessionUpdate *pUp = 0; + int nCol = pIter->nCol; + int nU32 = (pIter->nCol+33)/32; + int ii; + + if( p->aUpdateMask==0 ){ + p->aUpdateMask = sqlite3_malloc(nU32*sizeof(u32)); + if( p->aUpdateMask==0 ){ + rc = SQLITE_NOMEM; + } + } + + if( rc==SQLITE_OK ){ + memset(p->aUpdateMask, 0, nU32*sizeof(u32)); + rc = SQLITE_CORRUPT; + for(ii=0; iinCol; ii++){ + if( sessionChangesetNew(pIter, ii) ){ + p->aUpdateMask[ii/32] |= (1<<(ii%32)); + rc = SQLITE_OK; + } + } + } + + if( rc==SQLITE_OK ){ + if( bPatchset ) p->aUpdateMask[nCol/32] |= (1<<(nCol%32)); + + if( p->pUp ){ + int nUp = 0; + SessionUpdate **pp = &p->pUp; + while( 1 ){ + nUp++; + if( 0==memcmp(p->aUpdateMask, (*pp)->aMask, nU32*sizeof(u32)) ){ + pUp = *pp; + *pp = pUp->pNext; + pUp->pNext = p->pUp; + p->pUp = pUp; + break; + } + + if( (*pp)->pNext ){ + pp = &(*pp)->pNext; + }else{ + if( nUp>=SESSION_UPDATE_CACHE_SZ ){ + sqlite3_finalize((*pp)->pStmt); + sqlite3_free(*pp); + *pp = 0; + } + break; + } + } + } + + if( pUp==0 ){ + int nByte = sizeof(SessionUpdate) * nU32*sizeof(u32); + int bStat1 = (sqlite3_stricmp(pIter->zTab, "sqlite_stat1")==0); + pUp = (SessionUpdate*)sqlite3_malloc(nByte); + if( pUp==0 ){ + rc = SQLITE_NOMEM; + }else{ + const char *zSep = ""; + SessionBuffer buf; + + memset(&buf, 0, sizeof(buf)); + pUp->aMask = (u32*)&pUp[1]; + memcpy(pUp->aMask, p->aUpdateMask, nU32*sizeof(u32)); + + sessionAppendStr(&buf, "UPDATE main.", &rc); + sessionAppendIdent(&buf, pIter->zTab, &rc); + sessionAppendStr(&buf, " SET ", &rc); + + /* Create the assignments part of the UPDATE */ + for(ii=0; iinCol; ii++){ + if( p->abPK[ii]==0 && sessionChangesetNew(pIter, ii) ){ + sessionAppendStr(&buf, zSep, &rc); + sessionAppendIdent(&buf, p->azCol[ii], &rc); + sessionAppendStr(&buf, " = ?", &rc); + sessionAppendInteger(&buf, ii*2+1, &rc); + zSep = ", "; + } + } + + /* Create the WHERE clause part of the UPDATE */ + zSep = ""; + sessionAppendStr(&buf, " WHERE ", &rc); + for(ii=0; iinCol; ii++){ + if( p->abPK[ii] || (bPatchset==0 && sessionChangesetOld(pIter, ii)) ){ + sessionAppendStr(&buf, zSep, &rc); + if( bStat1 && ii==1 ){ + assert( sqlite3_stricmp(p->azCol[ii], "idx")==0 ); + sessionAppendStr(&buf, + "idx IS CASE " + "WHEN length(?4)=0 AND typeof(?4)='blob' THEN NULL " + "ELSE ?4 END ", &rc + ); + }else{ + sessionAppendIdent(&buf, p->azCol[ii], &rc); + sessionAppendStr(&buf, " IS ?", &rc); + sessionAppendInteger(&buf, ii*2+2, &rc); + } + zSep = " AND "; + } + } + + if( rc==SQLITE_OK ){ + char *zSql = (char*)buf.aBuf; + rc = sqlite3_prepare_v2(p->db, zSql, buf.nBuf, &pUp->pStmt, 0); + } + + if( rc!=SQLITE_OK ){ + sqlite3_free(pUp); + pUp = 0; + }else{ + pUp->pNext = p->pUp; + p->pUp = pUp; + } + sqlite3_free(buf.aBuf); + } + } + } + + assert( (rc==SQLITE_OK)==(pUp!=0) ); + if( pUp ){ + *ppStmt = pUp->pStmt; + }else{ + *ppStmt = 0; + } + return rc; +} + +/* +** Free all cached UPDATE statements. +*/ +static void sessionUpdateFree(SessionApplyCtx *p){ + SessionUpdate *pUp; + SessionUpdate *pNext; + for(pUp=p->pUp; pUp; pUp=pNext){ + pNext = pUp->pNext; + sqlite3_finalize(pUp->pStmt); + sqlite3_free(pUp); + } + p->pUp = 0; + sqlite3_free(p->aUpdateMask); + p->aUpdateMask = 0; +} + /* ** Formulate a statement to DELETE a row from database db. Assuming a table ** structure like this: @@ -206852,103 +212410,6 @@ static int sessionDeleteRow( return rc; } -/* -** Formulate and prepare a statement to UPDATE a row from database db. -** Assuming a table structure like this: -** -** CREATE TABLE x(a, b, c, d, PRIMARY KEY(a, c)); -** -** The UPDATE statement looks like this: -** -** UPDATE x SET -** a = CASE WHEN ?2 THEN ?3 ELSE a END, -** b = CASE WHEN ?5 THEN ?6 ELSE b END, -** c = CASE WHEN ?8 THEN ?9 ELSE c END, -** d = CASE WHEN ?11 THEN ?12 ELSE d END -** WHERE a = ?1 AND c = ?7 AND (?13 OR -** (?5==0 OR b IS ?4) AND (?11==0 OR d IS ?10) AND -** ) -** -** For each column in the table, there are three variables to bind: -** -** ?(i*3+1) The old.* value of the column, if any. -** ?(i*3+2) A boolean flag indicating that the value is being modified. -** ?(i*3+3) The new.* value of the column, if any. -** -** Also, a boolean flag that, if set to true, causes the statement to update -** a row even if the non-PK values do not match. This is required if the -** conflict-handler is invoked with CHANGESET_DATA and returns -** CHANGESET_REPLACE. This is variable "?(nCol*3+1)". -** -** If successful, SQLITE_OK is returned and SessionApplyCtx.pUpdate is left -** pointing to the prepared version of the SQL statement. -*/ -static int sessionUpdateRow( - sqlite3 *db, /* Database handle */ - const char *zTab, /* Table name */ - SessionApplyCtx *p /* Session changeset-apply context */ -){ - int rc = SQLITE_OK; - int i; - const char *zSep = ""; - SessionBuffer buf = {0, 0, 0}; - - /* Append "UPDATE tbl SET " */ - sessionAppendStr(&buf, "UPDATE main.", &rc); - sessionAppendIdent(&buf, zTab, &rc); - sessionAppendStr(&buf, " SET ", &rc); - - /* Append the assignments */ - for(i=0; inCol; i++){ - sessionAppendStr(&buf, zSep, &rc); - sessionAppendIdent(&buf, p->azCol[i], &rc); - sessionAppendStr(&buf, " = CASE WHEN ?", &rc); - sessionAppendInteger(&buf, i*3+2, &rc); - sessionAppendStr(&buf, " THEN ?", &rc); - sessionAppendInteger(&buf, i*3+3, &rc); - sessionAppendStr(&buf, " ELSE ", &rc); - sessionAppendIdent(&buf, p->azCol[i], &rc); - sessionAppendStr(&buf, " END", &rc); - zSep = ", "; - } - - /* Append the PK part of the WHERE clause */ - sessionAppendStr(&buf, " WHERE ", &rc); - for(i=0; inCol; i++){ - if( p->abPK[i] ){ - sessionAppendIdent(&buf, p->azCol[i], &rc); - sessionAppendStr(&buf, " = ?", &rc); - sessionAppendInteger(&buf, i*3+1, &rc); - sessionAppendStr(&buf, " AND ", &rc); - } - } - - /* Append the non-PK part of the WHERE clause */ - sessionAppendStr(&buf, " (?", &rc); - sessionAppendInteger(&buf, p->nCol*3+1, &rc); - sessionAppendStr(&buf, " OR 1", &rc); - for(i=0; inCol; i++){ - if( !p->abPK[i] ){ - sessionAppendStr(&buf, " AND (?", &rc); - sessionAppendInteger(&buf, i*3+2, &rc); - sessionAppendStr(&buf, "=0 OR ", &rc); - sessionAppendIdent(&buf, p->azCol[i], &rc); - sessionAppendStr(&buf, " IS ?", &rc); - sessionAppendInteger(&buf, i*3+1, &rc); - sessionAppendStr(&buf, ")", &rc); - } - } - sessionAppendStr(&buf, ")", &rc); - - if( rc==SQLITE_OK ){ - rc = sqlite3_prepare_v2(db, (char *)buf.aBuf, buf.nBuf, &p->pUpdate, 0); - } - sqlite3_free(buf.aBuf); - - return rc; -} - - /* ** Formulate and prepare an SQL statement to query table zTab by primary ** key. Assuming the following table structure: @@ -207029,17 +212490,6 @@ static int sessionStat1Sql(sqlite3 *db, SessionApplyCtx *p){ "?3)" ); } - if( rc==SQLITE_OK ){ - rc = sessionPrepare(db, &p->pUpdate, - "UPDATE main.sqlite_stat1 SET " - "tbl = CASE WHEN ?2 THEN ?3 ELSE tbl END, " - "idx = CASE WHEN ?5 THEN ?6 ELSE idx END, " - "stat = CASE WHEN ?8 THEN ?9 ELSE stat END " - "WHERE tbl=?1 AND idx IS " - "CASE WHEN length(?4)=0 AND typeof(?4)='blob' THEN NULL ELSE ?4 END " - "AND (?10 OR ?8=0 OR stat IS ?7)" - ); - } if( rc==SQLITE_OK ){ rc = sessionPrepare(db, &p->pDelete, "DELETE FROM main.sqlite_stat1 WHERE tbl=?1 AND idx IS " @@ -207105,7 +212555,7 @@ static int sessionBindRow( for(i=0; rc==SQLITE_OK && ipDelete && p->pUpdate && p->pInsert && p->pSelect ); + assert( p->pDelete && p->pInsert && p->pSelect ); assert( p->azCol && p->abPK ); assert( !pbReplace || *pbReplace==0 ); @@ -207396,29 +212846,28 @@ static int sessionApplyOneOp( }else if( op==SQLITE_UPDATE ){ int i; + sqlite3_stmt *pUp = 0; + int bPatchset = (pbRetry==0 || pIter->bPatchset); + + rc = sessionUpdateFind(pIter, p, bPatchset, &pUp); /* Bind values to the UPDATE statement. */ for(i=0; rc==SQLITE_OK && ipUpdate, i*3+2, !!pNew); - if( pOld ){ - rc = sessionBindValue(p->pUpdate, i*3+1, pOld); + if( p->abPK[i] || (bPatchset==0 && pOld) ){ + rc = sessionBindValue(pUp, i*2+2, pOld); } if( rc==SQLITE_OK && pNew ){ - rc = sessionBindValue(p->pUpdate, i*3+3, pNew); + rc = sessionBindValue(pUp, i*2+1, pNew); } } - if( rc==SQLITE_OK ){ - sqlite3_bind_int(p->pUpdate, nCol*3+1, pbRetry==0 || pIter->bPatchset); - } if( rc!=SQLITE_OK ) return rc; /* Attempt the UPDATE. In the case of a NOTFOUND or DATA conflict, ** the result will be SQLITE_OK with 0 rows modified. */ - sqlite3_step(p->pUpdate); - rc = sqlite3_reset(p->pUpdate); + sqlite3_step(pUp); + rc = sqlite3_reset(pUp); if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 ){ /* A NOTFOUND or DATA error. Search the table to see if it contains @@ -207550,7 +212999,7 @@ static int sessionRetryConstraints( memset(&pApply->constraints, 0, sizeof(SessionBuffer)); rc = sessionChangesetStart( - &pIter2, 0, 0, cons.nBuf, cons.aBuf, pApply->bInvertConstraints + &pIter2, 0, 0, cons.nBuf, cons.aBuf, pApply->bInvertConstraints, 1 ); if( rc==SQLITE_OK ){ size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*); @@ -207641,14 +213090,13 @@ static int sessionChangesetApply( ); if( rc!=SQLITE_OK ) break; + sessionUpdateFree(&sApply); sqlite3_free((char*)sApply.azCol); /* cast works around VC++ bug */ sqlite3_finalize(sApply.pDelete); - sqlite3_finalize(sApply.pUpdate); sqlite3_finalize(sApply.pInsert); sqlite3_finalize(sApply.pSelect); sApply.db = db; sApply.pDelete = 0; - sApply.pUpdate = 0; sApply.pInsert = 0; sApply.pSelect = 0; sApply.nCol = 0; @@ -207676,7 +213124,7 @@ static int sessionChangesetApply( int i; sqlite3changeset_pk(pIter, &abPK, 0); - rc = sessionTableInfo( + rc = sessionTableInfo(0, db, "main", zNew, &sApply.nCol, &zTab, &sApply.azCol, &sApply.abPK ); if( rc!=SQLITE_OK ) break; @@ -207712,11 +213160,10 @@ static int sessionChangesetApply( } sApply.bStat1 = 1; }else{ - if((rc = sessionSelectRow(db, zTab, &sApply)) - || (rc = sessionUpdateRow(db, zTab, &sApply)) - || (rc = sessionDeleteRow(db, zTab, &sApply)) - || (rc = sessionInsertRow(db, zTab, &sApply)) - ){ + if( (rc = sessionSelectRow(db, zTab, &sApply)) + || (rc = sessionDeleteRow(db, zTab, &sApply)) + || (rc = sessionInsertRow(db, zTab, &sApply)) + ){ break; } sApply.bStat1 = 0; @@ -207775,9 +213222,9 @@ static int sessionChangesetApply( *pnRebase = sApply.rebase.nBuf; sApply.rebase.aBuf = 0; } + sessionUpdateFree(&sApply); sqlite3_finalize(sApply.pInsert); sqlite3_finalize(sApply.pDelete); - sqlite3_finalize(sApply.pUpdate); sqlite3_finalize(sApply.pSelect); sqlite3_free((char*)sApply.azCol); /* cast works around VC++ bug */ sqlite3_free((char*)sApply.constraints.aBuf); @@ -207808,8 +213255,8 @@ SQLITE_API int sqlite3changeset_apply_v2( int flags ){ sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */ - int bInverse = !!(flags & SQLITE_CHANGESETAPPLY_INVERT); - int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset,bInverse); + int bInv = !!(flags & SQLITE_CHANGESETAPPLY_INVERT); + int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset, bInv, 1); if( rc==SQLITE_OK ){ rc = sessionChangesetApply( db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags @@ -207867,7 +213314,7 @@ SQLITE_API int sqlite3changeset_apply_v2_strm( ){ sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */ int bInverse = !!(flags & SQLITE_CHANGESETAPPLY_INVERT); - int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse); + int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse, 1); if( rc==SQLITE_OK ){ rc = sessionChangesetApply( db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags @@ -208155,7 +213602,7 @@ static int sessionChangesetToHash( } } - if( sessionGrowHash(pIter->bPatchset, pTab) ){ + if( sessionGrowHash(0, pIter->bPatchset, pTab) ){ rc = SQLITE_NOMEM; break; } @@ -208251,9 +213698,9 @@ static int sessionChangegroupOutput( if( rc==SQLITE_OK ){ if( xOutput ){ if( buf.nBuf>0 ) rc = xOutput(pOut, buf.aBuf, buf.nBuf); - }else{ + }else if( ppOut ){ *ppOut = buf.aBuf; - *pnOut = buf.nBuf; + if( pnOut ) *pnOut = buf.nBuf; buf.aBuf = 0; } } @@ -208341,7 +213788,7 @@ SQLITE_API int sqlite3changegroup_output_strm( */ SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup *pGrp){ if( pGrp ){ - sessionDeleteTable(pGrp->pList); + sessionDeleteTable(0, pGrp->pList); sqlite3_free(pGrp); } } @@ -208487,7 +213934,7 @@ static void sessionAppendPartialUpdate( int n1 = sessionSerialLen(a1); int n2 = sessionSerialLen(a2); if( pIter->abPK[i] || a2[0]==0 ){ - if( !pIter->abPK[i] ) bData = 1; + if( !pIter->abPK[i] && a1[0] ) bData = 1; memcpy(pOut, a1, n1); pOut += n1; }else if( a2[0]!=0xFF ){ @@ -208653,7 +214100,7 @@ static int sessionRebase( if( sOut.nBuf>0 ){ rc = xOutput(pOut, sOut.aBuf, sOut.nBuf); } - }else{ + }else if( ppOut ){ *ppOut = (void*)sOut.aBuf; *pnOut = sOut.nBuf; sOut.aBuf = 0; @@ -208742,7 +214189,7 @@ SQLITE_API int sqlite3rebaser_rebase_strm( */ SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p){ if( p ){ - sessionDeleteTable(p->grp.pList); + sessionDeleteTable(0, p->grp.pList); sqlite3_free(p); } } @@ -209396,8 +214843,20 @@ typedef sqlite3_uint64 u64; #endif #define testcase(x) -#define ALWAYS(x) 1 -#define NEVER(x) 0 + +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) +# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1 +#endif +#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS) +# define ALWAYS(X) (1) +# define NEVER(X) (0) +#elif !defined(NDEBUG) +# define ALWAYS(X) ((X)?1:(assert(0),0)) +# define NEVER(X) ((X)?(assert(0),1):0) +#else +# define ALWAYS(X) (X) +# define NEVER(X) (X) +#endif #define MIN(x,y) (((x) < (y)) ? (x) : (y)) #define MAX(x,y) (((x) > (y)) ? (x) : (y)) @@ -209457,7 +214916,7 @@ SQLITE_API extern int sqlite3_fts5_may_be_corrupt; ** A version of memcmp() that does not cause asan errors if one of the pointer ** parameters is NULL and the number of bytes to compare is zero. */ -#define fts5Memcmp(s1, s2, n) ((n)==0 ? 0 : memcmp((s1), (s2), (n))) +#define fts5Memcmp(s1, s2, n) ((n)<=0 ? 0 : memcmp((s1), (s2), (n))) /* Mark a function parameter as unused, to suppress nuisance compiler ** warnings. */ @@ -209796,6 +215255,9 @@ static void sqlite3Fts5IndexCloseReader(Fts5Index*); */ static const char *sqlite3Fts5IterTerm(Fts5IndexIter*, int*); static int sqlite3Fts5IterNextScan(Fts5IndexIter*); +static void *sqlite3Fts5StructureRef(Fts5Index*); +static void sqlite3Fts5StructureRelease(void*); +static int sqlite3Fts5StructureTest(Fts5Index*, void*); /* @@ -210573,9 +216035,9 @@ struct fts5yyParser { }; typedef struct fts5yyParser fts5yyParser; +/* #include */ #ifndef NDEBUG /* #include */ -/* #include */ static FILE *fts5yyTraceFILE = 0; static char *fts5yyTracePrompt = 0; #endif /* NDEBUG */ @@ -211204,55 +216666,6 @@ static fts5YYACTIONTYPE fts5yy_reduce( (void)fts5yyLookahead; (void)fts5yyLookaheadToken; fts5yymsp = fts5yypParser->fts5yytos; - assert( fts5yyruleno<(int)(sizeof(fts5yyRuleName)/sizeof(fts5yyRuleName[0])) ); -#ifndef NDEBUG - if( fts5yyTraceFILE ){ - fts5yysize = fts5yyRuleInfoNRhs[fts5yyruleno]; - if( fts5yysize ){ - fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", - fts5yyTracePrompt, - fts5yyruleno, fts5yyRuleName[fts5yyruleno], - fts5yyrulenofts5yytos - fts5yypParser->fts5yystack)>fts5yypParser->fts5yyhwm ){ - fts5yypParser->fts5yyhwm++; - assert( fts5yypParser->fts5yyhwm == (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack)); - } -#endif -#if fts5YYSTACKDEPTH>0 - if( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystackEnd ){ - fts5yyStackOverflow(fts5yypParser); - /* The call to fts5yyStackOverflow() above pops the stack until it is - ** empty, causing the main parser loop to exit. So the return value - ** is never used and does not matter. */ - return 0; - } -#else - if( fts5yypParser->fts5yytos>=&fts5yypParser->fts5yystack[fts5yypParser->fts5yystksz-1] ){ - if( fts5yyGrowStack(fts5yypParser) ){ - fts5yyStackOverflow(fts5yypParser); - /* The call to fts5yyStackOverflow() above pops the stack until it is - ** empty, causing the main parser loop to exit. So the return value - ** is never used and does not matter. */ - return 0; - } - fts5yymsp = fts5yypParser->fts5yytos; - } -#endif - } switch( fts5yyruleno ){ /* Beginning here are the reduction cases. A typical example @@ -211555,12 +216968,56 @@ static void sqlite3Fts5Parser( } #endif - do{ + while(1){ /* Exit by "break" */ + assert( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystack ); assert( fts5yyact==fts5yypParser->fts5yytos->stateno ); fts5yyact = fts5yy_find_shift_action((fts5YYCODETYPE)fts5yymajor,fts5yyact); if( fts5yyact >= fts5YY_MIN_REDUCE ){ - fts5yyact = fts5yy_reduce(fts5yypParser,fts5yyact-fts5YY_MIN_REDUCE,fts5yymajor, - fts5yyminor sqlite3Fts5ParserCTX_PARAM); + unsigned int fts5yyruleno = fts5yyact - fts5YY_MIN_REDUCE; /* Reduce by this rule */ +#ifndef NDEBUG + assert( fts5yyruleno<(int)(sizeof(fts5yyRuleName)/sizeof(fts5yyRuleName[0])) ); + if( fts5yyTraceFILE ){ + int fts5yysize = fts5yyRuleInfoNRhs[fts5yyruleno]; + if( fts5yysize ){ + fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", + fts5yyTracePrompt, + fts5yyruleno, fts5yyRuleName[fts5yyruleno], + fts5yyrulenofts5yytos[fts5yysize].stateno); + }else{ + fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s.\n", + fts5yyTracePrompt, fts5yyruleno, fts5yyRuleName[fts5yyruleno], + fts5yyrulenofts5yytos - fts5yypParser->fts5yystack)>fts5yypParser->fts5yyhwm ){ + fts5yypParser->fts5yyhwm++; + assert( fts5yypParser->fts5yyhwm == + (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack)); + } +#endif +#if fts5YYSTACKDEPTH>0 + if( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystackEnd ){ + fts5yyStackOverflow(fts5yypParser); + break; + } +#else + if( fts5yypParser->fts5yytos>=&fts5yypParser->fts5yystack[fts5yypParser->fts5yystksz-1] ){ + if( fts5yyGrowStack(fts5yypParser) ){ + fts5yyStackOverflow(fts5yypParser); + break; + } + } +#endif + } + fts5yyact = fts5yy_reduce(fts5yypParser,fts5yyruleno,fts5yymajor,fts5yyminor sqlite3Fts5ParserCTX_PARAM); }else if( fts5yyact <= fts5YY_MAX_SHIFTREDUCE ){ fts5yy_shift(fts5yypParser,fts5yyact,(fts5YYCODETYPE)fts5yymajor,fts5yyminor); #ifndef fts5YYNOERRORRECOVERY @@ -211616,14 +217073,13 @@ static void sqlite3Fts5Parser( fts5yy_destructor(fts5yypParser, (fts5YYCODETYPE)fts5yymajor, &fts5yyminorunion); fts5yymajor = fts5YYNOCODE; }else{ - while( fts5yypParser->fts5yytos >= fts5yypParser->fts5yystack - && (fts5yyact = fts5yy_find_reduce_action( - fts5yypParser->fts5yytos->stateno, - fts5YYERRORSYMBOL)) > fts5YY_MAX_SHIFTREDUCE - ){ + while( fts5yypParser->fts5yytos > fts5yypParser->fts5yystack ){ + fts5yyact = fts5yy_find_reduce_action(fts5yypParser->fts5yytos->stateno, + fts5YYERRORSYMBOL); + if( fts5yyact<=fts5YY_MAX_SHIFTREDUCE ) break; fts5yy_pop_parser_stack(fts5yypParser); } - if( fts5yypParser->fts5yytos < fts5yypParser->fts5yystack || fts5yymajor==0 ){ + if( fts5yypParser->fts5yytos <= fts5yypParser->fts5yystack || fts5yymajor==0 ){ fts5yy_destructor(fts5yypParser,(fts5YYCODETYPE)fts5yymajor,&fts5yyminorunion); fts5yy_parse_failed(fts5yypParser); #ifndef fts5YYNOERRORRECOVERY @@ -211673,7 +217129,7 @@ static void sqlite3Fts5Parser( break; #endif } - }while( fts5yypParser->fts5yytos>fts5yypParser->fts5yystack ); + } #ifndef NDEBUG if( fts5yyTraceFILE ){ fts5yyStackEntry *i; @@ -212486,7 +217942,6 @@ static void sqlite3Fts5BufferAppendBlob( u32 nData, const u8 *pData ){ - assert_nc( *pRc || nData>=0 ); if( nData ){ if( fts5BufferGrow(pRc, pBuf, nData) ) return; memcpy(&pBuf->p[pBuf->n], pData, nData); @@ -212596,7 +218051,7 @@ static int sqlite3Fts5PoslistNext64( return 1; }else{ i64 iOff = *piOff; - int iVal; + u32 iVal; fts5FastGetVarint32(a, i, iVal); if( iVal<=1 ){ if( iVal==0 ){ @@ -212605,15 +218060,19 @@ static int sqlite3Fts5PoslistNext64( } fts5FastGetVarint32(a, i, iVal); iOff = ((i64)iVal) << 32; + assert( iOff>=0 ); fts5FastGetVarint32(a, i, iVal); if( iVal<2 ){ /* This is a corrupt record. So stop parsing it here. */ *piOff = -1; return 1; } + *piOff = iOff + ((iVal-2) & 0x7FFFFFFF); + }else{ + *piOff = (iOff & (i64)0x7FFFFFFF<<32)+((iOff + (iVal-2)) & 0x7FFFFFFF); } - *piOff = iOff + ((iVal-2) & 0x7FFFFFFF); *pi = i; + assert_nc( *piOff>=iOff ); return 0; } } @@ -212652,14 +218111,16 @@ static void sqlite3Fts5PoslistSafeAppend( i64 *piPrev, i64 iPos ){ - static const i64 colmask = ((i64)(0x7FFFFFFF)) << 32; - if( (iPos & colmask) != (*piPrev & colmask) ){ - pBuf->p[pBuf->n++] = 1; - pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32)); - *piPrev = (iPos & colmask); + if( iPos>=*piPrev ){ + static const i64 colmask = ((i64)(0x7FFFFFFF)) << 32; + if( (iPos & colmask) != (*piPrev & colmask) ){ + pBuf->p[pBuf->n++] = 1; + pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32)); + *piPrev = (iPos & colmask); + } + pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-*piPrev)+2); + *piPrev = iPos; } - pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-*piPrev)+2); - *piPrev = iPos; } static int sqlite3Fts5PoslistWriterAppend( @@ -213361,7 +218822,7 @@ static int sqlite3Fts5ConfigParse( nByte = nArg * (sizeof(char*) + sizeof(u8)); pRet->azCol = (char**)sqlite3Fts5MallocZero(&rc, nByte); - pRet->abUnindexed = (u8*)&pRet->azCol[nArg]; + pRet->abUnindexed = pRet->azCol ? (u8*)&pRet->azCol[nArg] : 0; pRet->zDb = sqlite3Fts5Strndup(&rc, azArg[1], -1); pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1); pRet->bColumnsize = 1; @@ -213386,6 +218847,7 @@ static int sqlite3Fts5ConfigParse( z = fts5ConfigSkipWhitespace(z); if( z && *z=='=' ){ bOption = 1; + assert( zOne!=0 ); z++; if( bMustBeCol ) z = 0; } @@ -213402,7 +218864,11 @@ static int sqlite3Fts5ConfigParse( rc = SQLITE_ERROR; }else{ if( bOption ){ - rc = fts5ConfigParseSpecial(pGlobal, pRet, zOne, zTwo?zTwo:"", pzErr); + rc = fts5ConfigParseSpecial(pGlobal, pRet, + ALWAYS(zOne)?zOne:"", + zTwo?zTwo:"", + pzErr + ); }else{ rc = fts5ConfigParseColumn(pRet, zOne, zTwo, pzErr); zOne = 0; @@ -213920,6 +219386,7 @@ static void sqlite3Fts5ParseError(Fts5Parse *pParse, const char *zFmt, ...){ va_list ap; va_start(ap, zFmt); if( pParse->rc==SQLITE_OK ){ + assert( pParse->zErr==0 ); pParse->zErr = sqlite3_vmprintf(zFmt, ap); pParse->rc = SQLITE_ERROR; } @@ -214218,6 +219685,7 @@ static i64 fts5ExprSynonymRowid(Fts5ExprTerm *pTerm, int bDesc, int *pbEof){ int bRetValid = 0; Fts5ExprTerm *p; + assert( pTerm ); assert( pTerm->pSynonym ); assert( bDesc==0 || bDesc==1 ); for(p=pTerm; p; p=p->pSynonym){ @@ -215285,8 +220753,8 @@ static int sqlite3Fts5ExprFirst(Fts5Expr *p, Fts5Index *pIdx, i64 iFirst, int bD } /* If the iterator is not at a real match, skip forward until it is. */ - while( pRoot->bNomatch ){ - assert( pRoot->bEof==0 && rc==SQLITE_OK ); + while( pRoot->bNomatch && rc==SQLITE_OK ){ + assert( pRoot->bEof==0 ); rc = fts5ExprNodeNext(p, pRoot, 0, 0); } return rc; @@ -215658,7 +221126,7 @@ static int sqlite3Fts5ExprClonePhrase( sCtx.pPhrase = sqlite3Fts5MallocZero(&rc, sizeof(Fts5ExprPhrase)); } - if( rc==SQLITE_OK ){ + if( rc==SQLITE_OK && ALWAYS(sCtx.pPhrase) ){ /* All the allocations succeeded. Put the expression object together. */ pNew->pIndex = pExpr->pIndex; pNew->pConfig = pExpr->pConfig; @@ -215929,9 +221397,8 @@ static void sqlite3Fts5ParseSetColset( ){ Fts5Colset *pFree = pColset; if( pParse->pConfig->eDetail==FTS5_DETAIL_NONE ){ - pParse->rc = SQLITE_ERROR; - pParse->zErr = sqlite3_mprintf( - "fts5: column queries are not supported (detail=none)" + sqlite3Fts5ParseError(pParse, + "fts5: column queries are not supported (detail=none)" ); }else{ fts5ParseSetColset(pParse, pExpr, pColset, &pFree); @@ -216105,13 +221572,10 @@ static Fts5ExprNode *sqlite3Fts5ParseNode( || pPhrase->nTerm>1 || (pPhrase->nTerm>0 && pPhrase->aTerm[0].bFirst) ){ - assert( pParse->rc==SQLITE_OK ); - pParse->rc = SQLITE_ERROR; - assert( pParse->zErr==0 ); - pParse->zErr = sqlite3_mprintf( + sqlite3Fts5ParseError(pParse, "fts5: %s queries are not supported (detail!=full)", pNear->nPhrase==1 ? "phrase": "NEAR" - ); + ); sqlite3_free(pRet); pRet = 0; } @@ -216197,6 +221661,7 @@ static Fts5ExprNode *sqlite3Fts5ParseImplicitAnd( return pRet; } +#ifdef SQLITE_TEST static char *fts5ExprTermPrint(Fts5ExprTerm *pTerm){ sqlite3_int64 nByte = 0; Fts5ExprTerm *p; @@ -216563,12 +222028,14 @@ static void fts5ExprFold( sqlite3_result_int(pCtx, sqlite3Fts5UnicodeFold(iCode, bRemoveDiacritics)); } } +#endif /* ifdef SQLITE_TEST */ /* ** This is called during initialization to register the fts5_expr() scalar ** UDF with the SQLite handle passed as the only argument. */ static int sqlite3Fts5ExprInit(Fts5Global *pGlobal, sqlite3 *db){ +#ifdef SQLITE_TEST struct Fts5ExprFunc { const char *z; void (*x)(sqlite3_context*,int,sqlite3_value**); @@ -216586,6 +222053,10 @@ static int sqlite3Fts5ExprInit(Fts5Global *pGlobal, sqlite3 *db){ struct Fts5ExprFunc *p = &aFunc[i]; rc = sqlite3_create_function(db, p->z, -1, SQLITE_UTF8, pCtx, p->x, 0, 0); } +#else + int rc = SQLITE_OK; + UNUSED_PARAM2(pGlobal,db); +#endif /* Avoid warnings indicating that sqlite3Fts5ParserTrace() and ** sqlite3Fts5ParserFallback() are unused */ @@ -216636,6 +222107,15 @@ struct Fts5PoslistPopulator { int bMiss; }; +/* +** Clear the position lists associated with all phrases in the expression +** passed as the first argument. Argument bLive is true if the expression +** might be pointing to a real entry, otherwise it has just been reset. +** +** At present this function is only used for detail=col and detail=none +** fts5 tables. This implies that all phrases must be at most 1 token +** in size, as phrase matches are not supported without detail=full. +*/ static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){ Fts5PoslistPopulator *pRet; pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase); @@ -216645,7 +222125,7 @@ static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int b for(i=0; inPhrase; i++){ Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist; Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode; - assert( pExpr->apExprPhrase[i]->nTerm==1 ); + assert( pExpr->apExprPhrase[i]->nTerm<=1 ); if( bLive && (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof) ){ @@ -217196,7 +222676,7 @@ static int sqlite3Fts5HashWrite( p->bContent = 1; }else{ /* Append a new column value, if necessary */ - assert( iCol>=p->iCol ); + assert_nc( iCol>=p->iCol ); if( iCol!=p->iCol ){ if( pHash->eDetail==FTS5_DETAIL_FULL ){ pPtr[p->nData++] = 0x01; @@ -217832,7 +223312,7 @@ struct Fts5SegIter { int iLeafPgno; /* Current leaf page number */ Fts5Data *pLeaf; /* Current leaf data */ Fts5Data *pNextLeaf; /* Leaf page (iLeafPgno+1) */ - int iLeafOffset; /* Byte offset within current leaf */ + i64 iLeafOffset; /* Byte offset within current leaf */ /* Next method */ void (*xNext)(Fts5Index*, Fts5SegIter*, int*); @@ -218001,8 +223481,11 @@ static int fts5BufferCompareBlob( ** res = *pLeft - *pRight */ static int fts5BufferCompare(Fts5Buffer *pLeft, Fts5Buffer *pRight){ - int nCmp = MIN(pLeft->n, pRight->n); - int res = fts5Memcmp(pLeft->p, pRight->p, nCmp); + int nCmp, res; + nCmp = MIN(pLeft->n, pRight->n); + assert( nCmp<=0 || pLeft->p!=0 ); + assert( nCmp<=0 || pRight->p!=0 ); + res = fts5Memcmp(pLeft->p, pRight->p, nCmp); return (res==0 ? (pLeft->n - pRight->n) : res); } @@ -218098,6 +223581,7 @@ static Fts5Data *fts5DataRead(Fts5Index *p, i64 iRowid){ return pRet; } + /* ** Release a reference to data record returned by an earlier call to ** fts5DataRead(). @@ -218222,6 +223706,58 @@ static void fts5StructureRef(Fts5Structure *pStruct){ pStruct->nRef++; } +static void *sqlite3Fts5StructureRef(Fts5Index *p){ + fts5StructureRef(p->pStruct); + return (void*)p->pStruct; +} +static void sqlite3Fts5StructureRelease(void *p){ + if( p ){ + fts5StructureRelease((Fts5Structure*)p); + } +} +static int sqlite3Fts5StructureTest(Fts5Index *p, void *pStruct){ + if( p->pStruct!=(Fts5Structure*)pStruct ){ + return SQLITE_ABORT; + } + return SQLITE_OK; +} + +/* +** Ensure that structure object (*pp) is writable. +** +** This function is a no-op if (*pRc) is not SQLITE_OK when it is called. If +** an error occurs, (*pRc) is set to an SQLite error code before returning. +*/ +static void fts5StructureMakeWritable(int *pRc, Fts5Structure **pp){ + Fts5Structure *p = *pp; + if( *pRc==SQLITE_OK && p->nRef>1 ){ + i64 nByte = sizeof(Fts5Structure)+(p->nLevel-1)*sizeof(Fts5StructureLevel); + Fts5Structure *pNew; + pNew = (Fts5Structure*)sqlite3Fts5MallocZero(pRc, nByte); + if( pNew ){ + int i; + memcpy(pNew, p, nByte); + for(i=0; inLevel; i++) pNew->aLevel[i].aSeg = 0; + for(i=0; inLevel; i++){ + Fts5StructureLevel *pLvl = &pNew->aLevel[i]; + nByte = sizeof(Fts5StructureSegment) * pNew->aLevel[i].nSeg; + pLvl->aSeg = (Fts5StructureSegment*)sqlite3Fts5MallocZero(pRc, nByte); + if( pLvl->aSeg==0 ){ + for(i=0; inLevel; i++){ + sqlite3_free(pNew->aLevel[i].aSeg); + } + sqlite3_free(pNew); + return; + } + memcpy(pLvl->aSeg, p->aLevel[i].aSeg, nByte); + } + p->nRef--; + pNew->nRef = 1; + } + *pp = pNew; + } +} + /* ** Deserialize and return the structure record currently stored in serialized ** form within buffer pData/nData. @@ -218323,9 +223859,11 @@ static int fts5StructureDecode( } /* -** +** Add a level to the Fts5Structure.aLevel[] array of structure object +** (*ppStruct). */ static void fts5StructureAddLevel(int *pRc, Fts5Structure **ppStruct){ + fts5StructureMakeWritable(pRc, ppStruct); if( *pRc==SQLITE_OK ){ Fts5Structure *pStruct = *ppStruct; int nLevel = pStruct->nLevel; @@ -219012,7 +224550,7 @@ static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){ static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){ u8 *a = pIter->pLeaf->p; /* Buffer to read data from */ - int iOff = pIter->iLeafOffset; + i64 iOff = pIter->iLeafOffset; ASSERT_SZLEAF_OK(pIter->pLeaf); if( iOff>=pIter->pLeaf->szLeaf ){ @@ -219045,7 +224583,7 @@ static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){ */ static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){ u8 *a = pIter->pLeaf->p; /* Buffer to read data from */ - int iOff = pIter->iLeafOffset; /* Offset to read at */ + i64 iOff = pIter->iLeafOffset; /* Offset to read at */ int nNew; /* Bytes of new data */ iOff += fts5GetVarint32(&a[iOff], nNew); @@ -219119,6 +224657,7 @@ static void fts5SegIterInit( if( p->rc==SQLITE_OK ){ pIter->iLeafOffset = 4; + assert( pIter->pLeaf!=0 ); assert_nc( pIter->pLeaf->nn>4 ); assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 ); pIter->iPgidxOff = pIter->pLeaf->szLeaf+1; @@ -219471,14 +225010,9 @@ static void fts5SegIterNext( }else{ /* The following could be done by calling fts5SegIterLoadNPos(). But ** this block is particularly performance critical, so equivalent - ** code is inlined. - ** - ** Later: Switched back to fts5SegIterLoadNPos() because it supports - ** detail=none mode. Not ideal. - */ + ** code is inlined. */ int nSz; - assert( p->rc==SQLITE_OK ); - assert( pIter->iLeafOffset<=pIter->pLeaf->nn ); + assert_nc( pIter->iLeafOffset<=pIter->pLeaf->nn ); fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz); pIter->bDel = (nSz & 0x0001); pIter->nPos = nSz>>1; @@ -219507,7 +225041,7 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){ if( pDlidx ){ int iSegid = pIter->pSeg->iSegid; pgnoLast = fts5DlidxIterPgno(pDlidx); - pLast = fts5DataRead(p, FTS5_SEGMENT_ROWID(iSegid, pgnoLast)); + pLast = fts5LeafRead(p, FTS5_SEGMENT_ROWID(iSegid, pgnoLast)); }else{ Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */ @@ -219534,7 +225068,7 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){ ** forward to find the page containing the last rowid. */ for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){ i64 iAbs = FTS5_SEGMENT_ROWID(pSeg->iSegid, pgno); - Fts5Data *pNew = fts5DataRead(p, iAbs); + Fts5Data *pNew = fts5LeafRead(p, iAbs); if( pNew ){ int iRowid, bTermless; iRowid = fts5LeafFirstRowidOff(pNew); @@ -219565,6 +225099,10 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){ pIter->pLeaf = pLast; pIter->iLeafPgno = pgnoLast; iOff = fts5LeafFirstRowidOff(pLast); + if( iOff>pLast->szLeaf ){ + p->rc = FTS5_CORRUPT; + return; + } iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid); pIter->iLeafOffset = iOff; @@ -219573,7 +225111,6 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){ }else{ pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast); } - } fts5SegIterReverseInitPage(p, pIter); @@ -219625,21 +225162,20 @@ static void fts5LeafSeek( Fts5SegIter *pIter, /* Iterator to seek */ const u8 *pTerm, int nTerm /* Term to search for */ ){ - int iOff; + u32 iOff; const u8 *a = pIter->pLeaf->p; - int szLeaf = pIter->pLeaf->szLeaf; - int n = pIter->pLeaf->nn; + u32 n = (u32)pIter->pLeaf->nn; u32 nMatch = 0; u32 nKeep = 0; u32 nNew = 0; u32 iTermOff; - int iPgidx; /* Current offset in pgidx */ + u32 iPgidx; /* Current offset in pgidx */ int bEndOfPage = 0; assert( p->rc==SQLITE_OK ); - iPgidx = szLeaf; + iPgidx = (u32)pIter->pLeaf->szLeaf; iPgidx += fts5GetVarint32(&a[iPgidx], iTermOff); iOff = iTermOff; if( iOff>n ){ @@ -219705,15 +225241,15 @@ static void fts5LeafSeek( if( pIter->pLeaf==0 ) return; a = pIter->pLeaf->p; if( fts5LeafIsTermless(pIter->pLeaf)==0 ){ - iPgidx = pIter->pLeaf->szLeaf; + iPgidx = (u32)pIter->pLeaf->szLeaf; iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff); - if( iOff<4 || iOff>=pIter->pLeaf->szLeaf ){ + if( iOff<4 || (i64)iOff>=pIter->pLeaf->szLeaf ){ p->rc = FTS5_CORRUPT; return; }else{ nKeep = 0; iTermOff = iOff; - n = pIter->pLeaf->nn; + n = (u32)pIter->pLeaf->nn; iOff += fts5GetVarint32(&a[iOff], nNew); break; } @@ -220081,7 +225617,7 @@ static void fts5SegIterGotoPage( fts5SegIterNextPage(p, pIter); assert( p->rc!=SQLITE_OK || pIter->iLeafPgno==iLeafPgno ); - if( p->rc==SQLITE_OK ){ + if( p->rc==SQLITE_OK && ALWAYS(pIter->pLeaf!=0) ){ int iOff; u8 *a = pIter->pLeaf->p; int n = pIter->pLeaf->szLeaf; @@ -220470,7 +226006,7 @@ static void fts5ChunkIterate( int pgno = pSeg->iLeafPgno; int pgnoSave = 0; - /* This function does notmwork with detail=none databases. */ + /* This function does not work with detail=none databases. */ assert( p->pConfig->eDetail!=FTS5_DETAIL_NONE ); if( (pSeg->flags & FTS5_SEGITER_REVERSE)==0 ){ @@ -220483,6 +226019,9 @@ static void fts5ChunkIterate( fts5DataRelease(pData); if( nRem<=0 ){ break; + }else if( pSeg->pSeg==0 ){ + p->rc = FTS5_CORRUPT; + return; }else{ pgno++; pData = fts5LeafRead(p, FTS5_SEGMENT_ROWID(pSeg->pSeg->iSegid, pgno)); @@ -220510,7 +226049,11 @@ static void fts5SegiterPoslist( Fts5Colset *pColset, Fts5Buffer *pBuf ){ + assert( pBuf!=0 ); + assert( pSeg!=0 ); if( 0==fts5BufferGrow(&p->rc, pBuf, pSeg->nPos+FTS5_DATA_ZERO_PADDING) ){ + assert( pBuf->p!=0 ); + assert( pBuf->nSpace >= pBuf->n+pSeg->nPos+FTS5_DATA_ZERO_PADDING ); memset(&pBuf->p[pBuf->n+pSeg->nPos], 0, FTS5_DATA_ZERO_PADDING); if( pColset==0 ){ fts5ChunkIterate(p, pSeg, (void*)pBuf, fts5PoslistCallback); @@ -220534,66 +226077,72 @@ static void fts5SegiterPoslist( } /* -** IN/OUT parameter (*pa) points to a position list n bytes in size. If -** the position list contains entries for column iCol, then (*pa) is set -** to point to the sub-position-list for that column and the number of -** bytes in it returned. Or, if the argument position list does not -** contain any entries for column iCol, return 0. +** Parameter pPos points to a buffer containing a position list, size nPos. +** This function filters it according to pColset (which must be non-NULL) +** and sets pIter->base.pData/nData to point to the new position list. +** If memory is required for the new position list, use buffer pIter->poslist. +** Or, if the new position list is a contiguous subset of the input, set +** pIter->base.pData/nData to point directly to it. +** +** This function is a no-op if *pRc is other than SQLITE_OK when it is +** called. If an OOM error is encountered, *pRc is set to SQLITE_NOMEM +** before returning. */ -static int fts5IndexExtractCol( - const u8 **pa, /* IN/OUT: Pointer to poslist */ - int n, /* IN: Size of poslist in bytes */ - int iCol /* Column to extract from poslist */ -){ - int iCurrent = 0; /* Anything before the first 0x01 is col 0 */ - const u8 *p = *pa; - const u8 *pEnd = &p[n]; /* One byte past end of position list */ - - while( iCol>iCurrent ){ - /* Advance pointer p until it points to pEnd or an 0x01 byte that is - ** not part of a varint. Note that it is not possible for a negative - ** or extremely large varint to occur within an uncorrupted position - ** list. So the last byte of each varint may be assumed to have a clear - ** 0x80 bit. */ - while( *p!=0x01 ){ - while( *p++ & 0x80 ); - if( p>=pEnd ) return 0; - } - *pa = p++; - iCurrent = *p++; - if( iCurrent & 0x80 ){ - p--; - p += fts5GetVarint32(p, iCurrent); - } - } - if( iCol!=iCurrent ) return 0; - - /* Advance pointer p until it points to pEnd or an 0x01 byte that is - ** not part of a varint */ - while( pnCol; i++){ - const u8 *pSub = pPos; - int nSub = fts5IndexExtractCol(&pSub, nPos, pColset->aiCol[i]); - if( nSub ){ - fts5BufferAppendBlob(pRc, pBuf, nSub, pSub); + const u8 *p = pPos; + const u8 *aCopy = p; + const u8 *pEnd = &p[nPos]; /* One byte past end of position list */ + int i = 0; + int iCurrent = 0; + + if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){ + return; + } + + while( 1 ){ + while( pColset->aiCol[i]nCol ){ + pIter->base.pData = pIter->poslist.p; + pIter->base.nData = pIter->poslist.n; + return; + } + } + + /* Advance pointer p until it points to pEnd or an 0x01 byte that is + ** not part of a varint */ + while( paiCol[i]==iCurrent ){ + if( pColset->nCol==1 ){ + pIter->base.pData = aCopy; + pIter->base.nData = p-aCopy; + return; + } + fts5BufferSafeAppendBlob(&pIter->poslist, aCopy, p-aCopy); + } + if( p>=pEnd ){ + pIter->base.pData = pIter->poslist.p; + pIter->base.nData = pIter->poslist.n; + return; + } + aCopy = p++; + iCurrent = *p++; + if( iCurrent & 0x80 ){ + p--; + p += fts5GetVarint32(p, iCurrent); } } } + } /* @@ -220713,16 +226262,9 @@ static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){ /* All data is stored on the current page. Populate the output ** variables to point into the body of the page object. */ const u8 *a = &pSeg->pLeaf->p[pSeg->iLeafOffset]; - if( pColset->nCol==1 ){ - pIter->base.nData = fts5IndexExtractCol(&a, pSeg->nPos,pColset->aiCol[0]); - pIter->base.pData = a; - }else{ - int *pRc = &pIter->pIndex->rc; - fts5BufferZero(&pIter->poslist); - fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, &pIter->poslist); - pIter->base.pData = pIter->poslist.p; - pIter->base.nData = pIter->poslist.n; - } + int *pRc = &pIter->pIndex->rc; + fts5BufferZero(&pIter->poslist); + fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, pIter); }else{ /* The data is distributed over two or more pages. Copy it into the ** Fts5Iter.poslist buffer and then set the output pointer to point @@ -220735,6 +226277,7 @@ static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){ } static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){ + assert( pIter!=0 || (*pRc)!=SQLITE_OK ); if( *pRc==SQLITE_OK ){ Fts5Config *pConfig = pIter->pIndex->pConfig; if( pConfig->eDetail==FTS5_DETAIL_NONE ){ @@ -220806,7 +226349,10 @@ static void fts5MultiIterNew( } } *ppOut = pNew = fts5MultiIterAlloc(p, nSeg); - if( pNew==0 ) return; + if( pNew==0 ){ + assert( p->rc!=SQLITE_OK ); + goto fts5MultiIterNew_post_check; + } pNew->bRev = (0!=(flags & FTS5INDEX_QUERY_DESC)); pNew->bSkipEmpty = (0!=(flags & FTS5INDEX_QUERY_SKIPEMPTY)); pNew->pColset = pColset; @@ -220870,6 +226416,10 @@ static void fts5MultiIterNew( fts5MultiIterFree(pNew); *ppOut = 0; } + +fts5MultiIterNew_post_check: + assert( (*ppOut)!=0 || p->rc!=SQLITE_OK ); + return; } /* @@ -220917,7 +226467,8 @@ static void fts5MultiIterNew2( ** False otherwise. */ static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){ - assert( p->rc + assert( pIter!=0 || p->rc!=SQLITE_OK ); + assert( p->rc!=SQLITE_OK || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof ); return (p->rc || pIter->base.bEof); @@ -221721,6 +227272,7 @@ static void fts5IndexMergeLevel( ** and last leaf page number at the same time. */ fts5WriteFinish(p, &writer, &pSeg->pgnoLast); + assert( pIter!=0 || p->rc!=SQLITE_OK ); if( fts5MultiIterEof(p, pIter) ){ int i; @@ -221821,7 +227373,7 @@ static void fts5IndexAutomerge( Fts5Structure **ppStruct, /* IN/OUT: Current structure of index */ int nLeaf /* Number of output leaves just written */ ){ - if( p->rc==SQLITE_OK && p->pConfig->nAutomerge>0 ){ + if( p->rc==SQLITE_OK && p->pConfig->nAutomerge>0 && ALWAYS((*ppStruct)!=0) ){ Fts5Structure *pStruct = *ppStruct; u64 nWrite; /* Initial value of write-counter */ int nWork; /* Number of work-quanta to perform */ @@ -221944,14 +227496,14 @@ static void fts5FlushOneHash(Fts5Index *p){ fts5BufferSafeAppendBlob(pBuf, pDoclist, nDoclist); }else{ i64 iRowid = 0; - i64 iDelta = 0; + u64 iDelta = 0; int iOff = 0; /* The entire doclist will not fit on this leaf. The following ** loop iterates through the poslists that make up the current ** doclist. */ while( p->rc==SQLITE_OK && iOffaPoslist + pIter->nSize + pIter->nPoslist; - assert( pIter->aPoslist ); + assert( pIter->aPoslist || (p==0 && pIter->aPoslist==0) ); if( p>=pIter->aEof ){ pIter->aPoslist = 0; }else{ @@ -222225,6 +227777,9 @@ static void fts5DoclistIterNext(Fts5DoclistIter *pIter){ } pIter->aPoslist = p; + if( &pIter->aPoslist[pIter->nPoslist]>pIter->aEof ){ + pIter->aPoslist = 0; + } } } @@ -222233,9 +227788,11 @@ static void fts5DoclistIterInit( Fts5DoclistIter *pIter ){ memset(pIter, 0, sizeof(*pIter)); - pIter->aPoslist = pBuf->p; - pIter->aEof = &pBuf->p[pBuf->n]; - fts5DoclistIterNext(pIter); + if( pBuf->n>0 ){ + pIter->aPoslist = pBuf->p; + pIter->aEof = &pBuf->p[pBuf->n]; + fts5DoclistIterNext(pIter); + } } #if 0 @@ -222289,16 +227846,20 @@ static void fts5NextRowid(Fts5Buffer *pBuf, int *piOff, i64 *piRowid){ static void fts5MergeRowidLists( Fts5Index *p, /* FTS5 backend object */ Fts5Buffer *p1, /* First list to merge */ - Fts5Buffer *p2 /* Second list to merge */ + int nBuf, /* Number of entries in apBuf[] */ + Fts5Buffer *aBuf /* Array of other lists to merge into p1 */ ){ int i1 = 0; int i2 = 0; i64 iRowid1 = 0; i64 iRowid2 = 0; i64 iOut = 0; - + Fts5Buffer *p2 = &aBuf[0]; Fts5Buffer out; + + (void)nBuf; memset(&out, 0, sizeof(out)); + assert( nBuf==1 ); sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n); if( p->rc ) return; @@ -222325,180 +227886,214 @@ static void fts5MergeRowidLists( fts5BufferFree(&out); } +typedef struct PrefixMerger PrefixMerger; +struct PrefixMerger { + Fts5DoclistIter iter; /* Doclist iterator */ + i64 iPos; /* For iterating through a position list */ + int iOff; + u8 *aPos; + PrefixMerger *pNext; /* Next in docid/poslist order */ +}; + +static void fts5PrefixMergerInsertByRowid( + PrefixMerger **ppHead, + PrefixMerger *p +){ + if( p->iter.aPoslist ){ + PrefixMerger **pp = ppHead; + while( *pp && p->iter.iRowid>(*pp)->iter.iRowid ){ + pp = &(*pp)->pNext; + } + p->pNext = *pp; + *pp = p; + } +} + +static void fts5PrefixMergerInsertByPosition( + PrefixMerger **ppHead, + PrefixMerger *p +){ + if( p->iPos>=0 ){ + PrefixMerger **pp = ppHead; + while( *pp && p->iPos>(*pp)->iPos ){ + pp = &(*pp)->pNext; + } + p->pNext = *pp; + *pp = p; + } +} + + /* -** Buffers p1 and p2 contain doclists. This function merges the content -** of the two doclists together and sets buffer p1 to the result before -** returning. -** -** If an error occurs, an error code is left in p->rc. If an error has -** already occurred, this function is a no-op. +** Array aBuf[] contains nBuf doclists. These are all merged in with the +** doclist in buffer p1. */ static void fts5MergePrefixLists( Fts5Index *p, /* FTS5 backend object */ Fts5Buffer *p1, /* First list to merge */ - Fts5Buffer *p2 /* Second list to merge */ -){ - if( p2->n ){ - i64 iLastRowid = 0; - Fts5DoclistIter i1; - Fts5DoclistIter i2; - Fts5Buffer out = {0, 0, 0}; - Fts5Buffer tmp = {0, 0, 0}; - - /* The maximum size of the output is equal to the sum of the two - ** input sizes + 1 varint (9 bytes). The extra varint is because if the - ** first rowid in one input is a large negative number, and the first in - ** the other a non-negative number, the delta for the non-negative - ** number will be larger on disk than the literal integer value - ** was. - ** - ** Or, if the input position-lists are corrupt, then the output might - ** include up to 2 extra 10-byte positions created by interpreting -1 - ** (the value PoslistNext64() uses for EOF) as a position and appending - ** it to the output. This can happen at most once for each input - ** position-list, hence two 10 byte paddings. */ - if( sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n + 9+10+10) ) return; - fts5DoclistIterInit(p1, &i1); - fts5DoclistIterInit(p2, &i2); + int nBuf, /* Number of buffers in array aBuf[] */ + Fts5Buffer *aBuf /* Other lists to merge in */ +){ +#define fts5PrefixMergerNextPosition(p) \ + sqlite3Fts5PoslistNext64((p)->aPos,(p)->iter.nPoslist,&(p)->iOff,&(p)->iPos) +#define FTS5_MERGE_NLIST 16 + PrefixMerger aMerger[FTS5_MERGE_NLIST]; + PrefixMerger *pHead = 0; + int i; + int nOut = 0; + Fts5Buffer out = {0, 0, 0}; + Fts5Buffer tmp = {0, 0, 0}; + i64 iLastRowid = 0; + + /* Initialize a doclist-iterator for each input buffer. Arrange them in + ** a linked-list starting at pHead in ascending order of rowid. Avoid + ** linking any iterators already at EOF into the linked list at all. */ + assert( nBuf+1<=sizeof(aMerger)/sizeof(aMerger[0]) ); + memset(aMerger, 0, sizeof(PrefixMerger)*(nBuf+1)); + pHead = &aMerger[nBuf]; + fts5DoclistIterInit(p1, &pHead->iter); + for(i=0; in + 9 + 10*nBuf; + + /* The maximum size of the output is equal to the sum of the + ** input sizes + 1 varint (9 bytes). The extra varint is because if the + ** first rowid in one input is a large negative number, and the first in + ** the other a non-negative number, the delta for the non-negative + ** number will be larger on disk than the literal integer value + ** was. + ** + ** Or, if the input position-lists are corrupt, then the output might + ** include up to (nBuf+1) extra 10-byte positions created by interpreting -1 + ** (the value PoslistNext64() uses for EOF) as a position and appending + ** it to the output. This can happen at most once for each input + ** position-list, hence (nBuf+1) 10 byte paddings. */ + if( sqlite3Fts5BufferSize(&p->rc, &out, nOut) ) return; + + while( pHead ){ + fts5MergeAppendDocid(&out, iLastRowid, pHead->iter.iRowid); + + if( pHead->pNext && iLastRowid==pHead->pNext->iter.iRowid ){ + /* Merge data from two or more poslists */ + i64 iPrev = 0; + int nTmp = FTS5_DATA_ZERO_PADDING; + int nMerge = 0; + PrefixMerger *pSave = pHead; + PrefixMerger *pThis = 0; + int nTail = 0; + + pHead = 0; + while( pSave && pSave->iter.iRowid==iLastRowid ){ + PrefixMerger *pNext = pSave->pNext; + pSave->iOff = 0; + pSave->iPos = 0; + pSave->aPos = &pSave->iter.aPoslist[pSave->iter.nSize]; + fts5PrefixMergerNextPosition(pSave); + nTmp += pSave->iter.nPoslist + 10; + nMerge++; + fts5PrefixMergerInsertByPosition(&pHead, pSave); + pSave = pNext; + } + + if( pHead==0 || pHead->pNext==0 ){ + p->rc = FTS5_CORRUPT; + break; + } - while( 1 ){ - if( i1.iRowidp) + (i2.aPoslist-p2->p)+9+10+10) ); - } - else if( i2.iRowid!=i1.iRowid ){ - /* Copy entry from i2 */ - fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid); - fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.nPoslist+i2.nSize); - fts5DoclistIterNext(&i2); - if( i2.aPoslist==0 ) break; - assert( out.n<=((i1.aPoslist-p1->p) + (i2.aPoslist-p2->p)+9+10+10) ); + /* See the earlier comment in this function for an explanation of why + ** corrupt input position lists might cause the output to consume + ** at most nMerge*10 bytes of unexpected space. */ + if( sqlite3Fts5BufferSize(&p->rc, &tmp, nTmp+nMerge*10) ){ + break; } - else{ - /* Merge the two position lists. */ - i64 iPos1 = 0; - i64 iPos2 = 0; - int iOff1 = 0; - int iOff2 = 0; - u8 *a1 = &i1.aPoslist[i1.nSize]; - u8 *a2 = &i2.aPoslist[i2.nSize]; - int nCopy; - u8 *aCopy; - - i64 iPrev = 0; - Fts5PoslistWriter writer; - memset(&writer, 0, sizeof(writer)); - - /* See the earlier comment in this function for an explanation of why - ** corrupt input position lists might cause the output to consume - ** at most 20 bytes of unexpected space. */ - fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid); - fts5BufferZero(&tmp); - sqlite3Fts5BufferSize(&p->rc, &tmp, - i1.nPoslist + i2.nPoslist + 10 + 10 + FTS5_DATA_ZERO_PADDING - ); - if( p->rc ) break; + fts5BufferZero(&tmp); - sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1); - sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2); - assert_nc( iPos1>=0 && iPos2>=0 ); + pThis = pHead; + pHead = pThis->pNext; + sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, pThis->iPos); + fts5PrefixMergerNextPosition(pThis); + fts5PrefixMergerInsertByPosition(&pHead, pThis); - if( iPos1=0 && iPos2>=0 ){ - while( 1 ){ - if( iPos1pNext ){ + pThis = pHead; + if( pThis->iPos!=iPrev ){ + sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, pThis->iPos); } + fts5PrefixMergerNextPosition(pThis); + pHead = pThis->pNext; + fts5PrefixMergerInsertByPosition(&pHead, pThis); + } - if( iPos1>=0 ){ - if( iPos1!=iPrev ){ - sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1); - } - aCopy = &a1[iOff1]; - nCopy = i1.nPoslist - iOff1; - }else{ - assert_nc( iPos2>=0 && iPos2!=iPrev ); - sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2); - aCopy = &a2[iOff2]; - nCopy = i2.nPoslist - iOff2; - } - if( nCopy>0 ){ - fts5BufferSafeAppendBlob(&tmp, aCopy, nCopy); - } + if( pHead->iPos!=iPrev ){ + sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, pHead->iPos); + } + nTail = pHead->iter.nPoslist - pHead->iOff; - /* WRITEPOSLISTSIZE */ - assert_nc( tmp.n<=i1.nPoslist+i2.nPoslist ); - assert( tmp.n<=i1.nPoslist+i2.nPoslist+10+10 ); - if( tmp.n>i1.nPoslist+i2.nPoslist ){ - if( p->rc==SQLITE_OK ) p->rc = FTS5_CORRUPT; - break; + /* WRITEPOSLISTSIZE */ + assert_nc( tmp.n+nTail<=nTmp ); + assert( tmp.n+nTail<=nTmp+nMerge*10 ); + if( tmp.n+nTail>nTmp-FTS5_DATA_ZERO_PADDING ){ + if( p->rc==SQLITE_OK ) p->rc = FTS5_CORRUPT; + break; + } + fts5BufferSafeAppendVarint(&out, (tmp.n+nTail) * 2); + fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n); + if( nTail>0 ){ + fts5BufferSafeAppendBlob(&out, &pHead->aPos[pHead->iOff], nTail); + } + + pHead = pSave; + for(i=0; iiter.aPoslist && pX->iter.iRowid==iLastRowid ){ + fts5DoclistIterNext(&pX->iter); + fts5PrefixMergerInsertByRowid(&pHead, pX); } - fts5BufferSafeAppendVarint(&out, tmp.n * 2); - fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n); - fts5DoclistIterNext(&i1); - fts5DoclistIterNext(&i2); - assert_nc( out.n<=(p1->n+p2->n+9) ); - if( i1.aPoslist==0 || i2.aPoslist==0 ) break; - assert( out.n<=((i1.aPoslist-p1->p) + (i2.aPoslist-p2->p)+9+10+10) ); } - } - if( i1.aPoslist ){ - fts5MergeAppendDocid(&out, iLastRowid, i1.iRowid); - fts5BufferSafeAppendBlob(&out, i1.aPoslist, i1.aEof - i1.aPoslist); - } - else if( i2.aPoslist ){ - fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid); - fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.aEof - i2.aPoslist); + }else{ + /* Copy poslist from pHead to output */ + PrefixMerger *pThis = pHead; + Fts5DoclistIter *pI = &pThis->iter; + fts5BufferSafeAppendBlob(&out, pI->aPoslist, pI->nPoslist+pI->nSize); + fts5DoclistIterNext(pI); + pHead = pThis->pNext; + fts5PrefixMergerInsertByRowid(&pHead, pThis); } - assert_nc( out.n<=(p1->n+p2->n+9) ); - - fts5BufferFree(p1); - fts5BufferFree(&tmp); - memset(&out.p[out.n], 0, FTS5_DATA_ZERO_PADDING); - *p1 = out; } + + fts5BufferFree(p1); + fts5BufferFree(&tmp); + memset(&out.p[out.n], 0, FTS5_DATA_ZERO_PADDING); + *p1 = out; } static void fts5SetupPrefixIter( Fts5Index *p, /* Index to read from */ int bDesc, /* True for "ORDER BY rowid DESC" */ - const u8 *pToken, /* Buffer containing prefix to match */ + int iIdx, /* Index to scan for data */ + u8 *pToken, /* Buffer containing prefix to match */ int nToken, /* Size of buffer pToken in bytes */ Fts5Colset *pColset, /* Restrict matches to these columns */ Fts5Iter **ppIter /* OUT: New iterator */ ){ Fts5Structure *pStruct; Fts5Buffer *aBuf; - const int nBuf = 32; + int nBuf = 32; + int nMerge = 1; - void (*xMerge)(Fts5Index*, Fts5Buffer*, Fts5Buffer*); + void (*xMerge)(Fts5Index*, Fts5Buffer*, int, Fts5Buffer*); void (*xAppend)(Fts5Index*, i64, Fts5Iter*, Fts5Buffer*); if( p->pConfig->eDetail==FTS5_DETAIL_NONE ){ xMerge = fts5MergeRowidLists; xAppend = fts5AppendRowid; }else{ + nMerge = FTS5_MERGE_NLIST-1; + nBuf = nMerge*8; /* Sufficient to merge (16^8)==(2^32) lists */ xMerge = fts5MergePrefixLists; xAppend = fts5AppendPoslist; } @@ -222518,6 +228113,27 @@ static void fts5SetupPrefixIter( int bNewTerm = 1; memset(&doclist, 0, sizeof(doclist)); + if( iIdx!=0 ){ + int dummy = 0; + const int f2 = FTS5INDEX_QUERY_SKIPEMPTY|FTS5INDEX_QUERY_NOOUTPUT; + pToken[0] = FTS5_MAIN_PREFIX; + fts5MultiIterNew(p, pStruct, f2, pColset, pToken, nToken, -1, 0, &p1); + fts5IterSetOutputCb(&p->rc, p1); + for(; + fts5MultiIterEof(p, p1)==0; + fts5MultiIterNext2(p, p1, &dummy) + ){ + Fts5SegIter *pSeg = &p1->aSeg[ p1->aFirst[1].iFirst ]; + p1->xSetOutputs(p1, pSeg); + if( p1->base.nData ){ + xAppend(p, p1->base.iRowid-iLastRowid, p1, &doclist); + iLastRowid = p1->base.iRowid; + } + } + fts5MultiIterFree(p1); + } + + pToken[0] = FTS5_MAIN_PREFIX + iIdx; fts5MultiIterNew(p, pStruct, flags, pColset, pToken, nToken, -1, 0, &p1); fts5IterSetOutputCb(&p->rc, p1); for( /* no-op */ ; @@ -222538,13 +228154,21 @@ static void fts5SetupPrefixIter( if( p1->base.iRowid<=iLastRowid && doclist.n>0 ){ for(i=0; p->rc==SQLITE_OK && doclist.n; i++){ - assert( ibase.iRowid; } - for(i=0; irc==SQLITE_OK ){ - xMerge(p, &doclist, &aBuf[i]); + xMerge(p, &doclist, nMerge, &aBuf[i]); + } + for(iFree=i; iFreerc, &buf, nToken+1)==0 ){ int iIdx = 0; /* Index to search */ + int iPrefixIdx = 0; /* +1 prefix index */ if( nToken ) memcpy(&buf.p[1], pToken, nToken); /* Figure out which index to search and set iIdx accordingly. If this @@ -222834,7 +228463,9 @@ static int sqlite3Fts5IndexQuery( if( flags & FTS5INDEX_QUERY_PREFIX ){ int nChar = fts5IndexCharlen(pToken, nToken); for(iIdx=1; iIdx<=pConfig->nPrefix; iIdx++){ - if( pConfig->aPrefix[iIdx-1]==nChar ) break; + int nIdxChar = pConfig->aPrefix[iIdx-1]; + if( nIdxChar==nChar ) break; + if( nIdxChar==nChar+1 ) iPrefixIdx = iIdx; } } @@ -222851,13 +228482,16 @@ static int sqlite3Fts5IndexQuery( }else{ /* Scan multiple terms in the main index */ int bDesc = (flags & FTS5INDEX_QUERY_DESC)!=0; - buf.p[0] = FTS5_MAIN_PREFIX; - fts5SetupPrefixIter(p, bDesc, buf.p, nToken+1, pColset, &pRet); - assert( p->rc!=SQLITE_OK || pRet->pColset==0 ); - fts5IterSetOutputCb(&p->rc, pRet); - if( p->rc==SQLITE_OK ){ - Fts5SegIter *pSeg = &pRet->aSeg[pRet->aFirst[1].iFirst]; - if( pSeg->pLeaf ) pRet->xSetOutputs(pRet, pSeg); + fts5SetupPrefixIter(p, bDesc, iPrefixIdx, buf.p, nToken+1, pColset,&pRet); + if( pRet==0 ){ + assert( p->rc!=SQLITE_OK ); + }else{ + assert( pRet->pColset==0 ); + fts5IterSetOutputCb(&p->rc, pRet); + if( p->rc==SQLITE_OK ){ + Fts5SegIter *pSeg = &pRet->aSeg[pRet->aFirst[1].iFirst]; + if( pSeg->pLeaf ) pRet->xSetOutputs(pRet, pSeg); + } } } @@ -222925,8 +228559,9 @@ static int sqlite3Fts5IterNextFrom(Fts5IndexIter *pIndexIter, i64 iMatch){ static const char *sqlite3Fts5IterTerm(Fts5IndexIter *pIndexIter, int *pn){ int n; const char *z = (const char*)fts5MultiIterTerm((Fts5Iter*)pIndexIter, &n); + assert_nc( z || n<=1 ); *pn = n-1; - return &z[1]; + return (z ? &z[1] : 0); } /* @@ -223104,7 +228739,7 @@ static int fts5QueryCksum( Fts5IndexIter *pIter = 0; int rc = sqlite3Fts5IndexQuery(p, z, n, flags, 0, &pIter); - while( rc==SQLITE_OK && 0==sqlite3Fts5IterEof(pIter) ){ + while( rc==SQLITE_OK && ALWAYS(pIter!=0) && 0==sqlite3Fts5IterEof(pIter) ){ i64 rowid = pIter->iRowid; if( eDetail==FTS5_DETAIL_NONE ){ @@ -223469,6 +229104,7 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum, int bUseCksum Fts5Buffer poslist = {0,0,0}; /* Buffer used to hold a poslist */ Fts5Iter *pIter; /* Used to iterate through entire index */ Fts5Structure *pStruct; /* Index structure */ + int iLvl, iSeg; #ifdef SQLITE_DEBUG /* Used by extra internal tests only run if NDEBUG is not defined */ @@ -223479,15 +229115,16 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum, int bUseCksum /* Load the FTS index structure */ pStruct = fts5StructureRead(p); + if( pStruct==0 ){ + assert( p->rc!=SQLITE_OK ); + return fts5IndexReturn(p); + } /* Check that the internal nodes of each segment match the leaves */ - if( pStruct ){ - int iLvl, iSeg; - for(iLvl=0; iLvlnLevel; iLvl++){ - for(iSeg=0; iSegaLevel[iLvl].nSeg; iSeg++){ - Fts5StructureSegment *pSeg = &pStruct->aLevel[iLvl].aSeg[iSeg]; - fts5IndexIntegrityCheckSegment(p, pSeg); - } + for(iLvl=0; iLvlnLevel; iLvl++){ + for(iSeg=0; iSegaLevel[iLvl].nSeg; iSeg++){ + Fts5StructureSegment *pSeg = &pStruct->aLevel[iLvl].aSeg[iSeg]; + fts5IndexIntegrityCheckSegment(p, pSeg); } } @@ -223551,6 +229188,7 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum, int bUseCksum ** function only. */ +#ifdef SQLITE_TEST /* ** Decode a segment-data rowid from the %_data table. This function is ** the opposite of macro FTS5_SEGMENT_ROWID(). @@ -223573,7 +229211,9 @@ static void fts5DecodeRowid( *piSegid = (int)(iRowid & (((i64)1 << FTS5_DATA_ID_B) - 1)); } +#endif /* SQLITE_TEST */ +#ifdef SQLITE_TEST static void fts5DebugRowid(int *pRc, Fts5Buffer *pBuf, i64 iKey){ int iSegid, iHeight, iPgno, bDlidx; /* Rowid compenents */ fts5DecodeRowid(iKey, &iSegid, &bDlidx, &iHeight, &iPgno); @@ -223591,7 +229231,9 @@ static void fts5DebugRowid(int *pRc, Fts5Buffer *pBuf, i64 iKey){ ); } } +#endif /* SQLITE_TEST */ +#ifdef SQLITE_TEST static void fts5DebugStructure( int *pRc, /* IN/OUT: error code */ Fts5Buffer *pBuf, @@ -223613,7 +229255,9 @@ static void fts5DebugStructure( sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "}"); } } +#endif /* SQLITE_TEST */ +#ifdef SQLITE_TEST /* ** This is part of the fts5_decode() debugging aid. ** @@ -223638,7 +229282,9 @@ static void fts5DecodeStructure( fts5DebugStructure(pRc, pBuf, p); fts5StructureRelease(p); } +#endif /* SQLITE_TEST */ +#ifdef SQLITE_TEST /* ** This is part of the fts5_decode() debugging aid. ** @@ -223661,7 +229307,9 @@ static void fts5DecodeAverages( zSpace = " "; } } +#endif /* SQLITE_TEST */ +#ifdef SQLITE_TEST /* ** Buffer (a/n) is assumed to contain a list of serialized varints. Read ** each varint and append its string representation to buffer pBuf. Return @@ -223678,7 +229326,9 @@ static int fts5DecodePoslist(int *pRc, Fts5Buffer *pBuf, const u8 *a, int n){ } return iOff; } +#endif /* SQLITE_TEST */ +#ifdef SQLITE_TEST /* ** The start of buffer (a/n) contains the start of a doclist. The doclist ** may or may not finish within the buffer. This function appends a text @@ -223711,7 +229361,9 @@ static int fts5DecodeDoclist(int *pRc, Fts5Buffer *pBuf, const u8 *a, int n){ return iOff; } +#endif /* SQLITE_TEST */ +#ifdef SQLITE_TEST /* ** This function is part of the fts5_decode() debugging function. It is ** only ever used with detail=none tables. @@ -223752,7 +229404,9 @@ static void fts5DecodeRowidList( sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " %lld%s", iRowid, zApp); } } +#endif /* SQLITE_TEST */ +#ifdef SQLITE_TEST /* ** The implementation of user-defined scalar function fts5_decode(). */ @@ -223961,7 +229615,9 @@ static void fts5DecodeFunction( } fts5BufferFree(&s); } +#endif /* SQLITE_TEST */ +#ifdef SQLITE_TEST /* ** The implementation of user-defined scalar function fts5_rowid(). */ @@ -223995,6 +229651,7 @@ static void fts5RowidFunction( } } } +#endif /* SQLITE_TEST */ /* ** This is called as part of registering the FTS5 module with database @@ -224005,6 +229662,7 @@ static void fts5RowidFunction( ** SQLite error code is returned instead. */ static int sqlite3Fts5IndexInit(sqlite3 *db){ +#ifdef SQLITE_TEST int rc = sqlite3_create_function( db, "fts5_decode", 2, SQLITE_UTF8, 0, fts5DecodeFunction, 0, 0 ); @@ -224022,6 +229680,10 @@ static int sqlite3Fts5IndexInit(sqlite3 *db){ ); } return rc; +#else + return SQLITE_OK; + UNUSED_PARAM(db); +#endif } @@ -224057,7 +229719,9 @@ static int sqlite3Fts5IndexReset(Fts5Index *p){ ** assert() conditions in the fts5 code are activated - conditions that are ** only true if it is guaranteed that the fts5 database is not corrupt. */ +#ifdef SQLITE_DEBUG SQLITE_API int sqlite3_fts5_may_be_corrupt = 1; +#endif typedef struct Fts5Auxdata Fts5Auxdata; @@ -225407,7 +231071,8 @@ static int fts5FilterMethod( pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg ); if( rc==SQLITE_OK ){ - if( pCsr->ePlan==FTS5_PLAN_ROWID ){ + if( pRowidEq!=0 ){ + assert( pCsr->ePlan==FTS5_PLAN_ROWID ); sqlite3_bind_value(pCsr->pStmt, 1, pRowidEq); }else{ sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iFirstRowid); @@ -225982,13 +231647,15 @@ static int fts5CacheInstArray(Fts5Cursor *pCsr){ nInst++; if( nInst>=pCsr->nInstAlloc ){ - pCsr->nInstAlloc = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32; + int nNewSize = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32; aInst = (int*)sqlite3_realloc64( - pCsr->aInst, pCsr->nInstAlloc*sizeof(int)*3 + pCsr->aInst, nNewSize*sizeof(int)*3 ); if( aInst ){ pCsr->aInst = aInst; + pCsr->nInstAlloc = nNewSize; }else{ + nInst--; rc = SQLITE_NOMEM; break; } @@ -226212,7 +231879,8 @@ static int fts5ApiPhraseFirst( int n; int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n); if( rc==SQLITE_OK ){ - pIter->b = &pIter->a[n]; + assert( pIter->a || n==0 ); + pIter->b = (pIter->a ? &pIter->a[n] : 0); *piCol = 0; *piOff = 0; fts5ApiPhraseNext(pCtx, pIter, piCol, piOff); @@ -226271,7 +231939,8 @@ static int fts5ApiPhraseFirstColumn( rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n); } if( rc==SQLITE_OK ){ - pIter->b = &pIter->a[n]; + assert( pIter->a || n==0 ); + pIter->b = (pIter->a ? &pIter->a[n] : 0); *piCol = 0; fts5ApiPhraseNextColumn(pCtx, pIter, piCol); } @@ -226279,7 +231948,8 @@ static int fts5ApiPhraseFirstColumn( int n; rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n); if( rc==SQLITE_OK ){ - pIter->b = &pIter->a[n]; + assert( pIter->a || n==0 ); + pIter->b = (pIter->a ? &pIter->a[n] : 0); if( n<=0 ){ *piCol = -1; }else if( pIter->a[0]==0x01 ){ @@ -226757,7 +232427,7 @@ static int sqlite3Fts5GetTokenizer( *pzErr = sqlite3_mprintf("no such tokenizer: %s", azArg[0]); }else{ rc = pMod->x.xCreate( - pMod->pUserData, &azArg[1], (nArg?nArg-1:0), &pConfig->pTok + pMod->pUserData, (azArg?&azArg[1]:0), (nArg?nArg-1:0), &pConfig->pTok ); pConfig->pTokApi = &pMod->x; if( rc!=SQLITE_OK ){ @@ -226820,7 +232490,7 @@ static void fts5SourceIdFunc( ){ assert( nArg==0 ); UNUSED_PARAM2(nArg, apUnused); - sqlite3_result_text(pCtx, "fts5: 2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089fed5b", -1, SQLITE_TRANSIENT); + sqlite3_result_text(pCtx, "fts5: 2021-11-27 14:13:22 bd41822c7424d393a30e92ff6cb254d25c26769889c1499a18a0b9339f5d6c8a", -1, SQLITE_TRANSIENT); } /* @@ -227371,12 +233041,16 @@ static int fts5StorageDeleteFromIndex( if( pConfig->abUnindexed[iCol-1]==0 ){ const char *zText; int nText; + assert( pSeek==0 || apVal==0 ); + assert( pSeek!=0 || apVal!=0 ); if( pSeek ){ zText = (const char*)sqlite3_column_text(pSeek, iCol); nText = sqlite3_column_bytes(pSeek, iCol); - }else{ + }else if( ALWAYS(apVal) ){ zText = (const char*)sqlite3_value_text(apVal[iCol-1]); nText = sqlite3_value_bytes(apVal[iCol-1]); + }else{ + continue; } ctx.szCol = 0; rc = sqlite3Fts5Tokenize(pConfig, FTS5_TOKENIZE_DOCUMENT, @@ -228012,8 +233686,9 @@ static int sqlite3Fts5StorageDocsize(Fts5Storage *p, i64 iRowid, int *aCol){ assert( p->pConfig->bColumnsize ); rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP_DOCSIZE, &pLookup, 0); - if( rc==SQLITE_OK ){ + if( pLookup ){ int bCorrupt = 1; + assert( rc==SQLITE_OK ); sqlite3_bind_int64(pLookup, 1, iRowid); if( SQLITE_ROW==sqlite3_step(pLookup) ){ const u8 *aBlob = sqlite3_column_blob(pLookup, 0); @@ -228026,6 +233701,8 @@ static int sqlite3Fts5StorageDocsize(Fts5Storage *p, i64 iRowid, int *aCol){ if( bCorrupt && rc==SQLITE_OK ){ rc = FTS5_CORRUPT; } + }else{ + assert( rc!=SQLITE_OK ); } return rc; @@ -230716,6 +236393,7 @@ struct Fts5VocabCursor { int bEof; /* True if this cursor is at EOF */ Fts5IndexIter *pIter; /* Term/rowid iterator object */ + void *pStruct; /* From sqlite3Fts5StructureRef() */ int nLeTerm; /* Size of zLeTerm in bytes */ char *zLeTerm; /* (term <= $zLeTerm) paramater, or NULL */ @@ -231029,7 +236707,7 @@ static int fts5VocabOpenMethod( } if( rc==SQLITE_OK ){ - int nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor); + i64 nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor); pCsr = (Fts5VocabCursor*)sqlite3Fts5MallocZero(&rc, nByte); } @@ -231049,6 +236727,8 @@ static int fts5VocabOpenMethod( static void fts5VocabResetCursor(Fts5VocabCursor *pCsr){ pCsr->rowid = 0; sqlite3Fts5IterClose(pCsr->pIter); + sqlite3Fts5StructureRelease(pCsr->pStruct); + pCsr->pStruct = 0; pCsr->pIter = 0; sqlite3_free(pCsr->zLeTerm); pCsr->nLeTerm = -1; @@ -231126,9 +236806,11 @@ static int fts5VocabInstanceNext(Fts5VocabCursor *pCsr){ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){ Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor; Fts5VocabTable *pTab = (Fts5VocabTable*)pCursor->pVtab; - int rc = SQLITE_OK; int nCol = pCsr->pFts5->pConfig->nCol; + int rc; + rc = sqlite3Fts5StructureTest(pCsr->pFts5->pIndex, pCsr->pStruct); + if( rc!=SQLITE_OK ) return rc; pCsr->rowid++; if( pTab->eType==FTS5_VOCAB_INSTANCE ){ @@ -231302,6 +236984,9 @@ static int fts5VocabFilterMethod( if( rc==SQLITE_OK ){ Fts5Index *pIndex = pCsr->pFts5->pIndex; rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter); + if( rc==SQLITE_OK ){ + pCsr->pStruct = sqlite3Fts5StructureRef(pIndex); + } } if( rc==SQLITE_OK && eType==FTS5_VOCAB_INSTANCE ){ rc = fts5VocabInstanceNewTerm(pCsr); @@ -231746,10 +237431,6 @@ SQLITE_API int sqlite3_stmt_init( #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */ /************** End of stmt.c ************************************************/ -#if __LINE__!=231748 -#undef SQLITE_SOURCE_ID -#define SQLITE_SOURCE_ID "2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089falt2" -#endif /* Return the source-id for this library */ SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; } /************************** End of sqlite3.c ******************************/ diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.h b/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.h index cc3b023bfa..6bf2c58aed 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.h +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.h @@ -44,7 +44,30 @@ extern "C" { /* -** Provide the ability to override linkage features of the interface. +** Facilitate override of interface linkage and calling conventions. +** Be aware that these macros may not be used within this particular +** translation of the amalgamation and its associated header file. +** +** The SQLITE_EXTERN and SQLITE_API macros are used to instruct the +** compiler that the target identifier should have external linkage. +** +** The SQLITE_CDECL macro is used to set the calling convention for +** public functions that accept a variable number of arguments. +** +** The SQLITE_APICALL macro is used to set the calling convention for +** public functions that accept a fixed number of arguments. +** +** The SQLITE_STDCALL macro is no longer used and is now deprecated. +** +** The SQLITE_CALLBACK macro is used to set the calling convention for +** function pointers. +** +** The SQLITE_SYSAPI macro is used to set the calling convention for +** functions provided by the operating system. +** +** Currently, the SQLITE_CDECL, SQLITE_APICALL, SQLITE_CALLBACK, and +** SQLITE_SYSAPI macros are used only when building for environments +** that require non-default calling conventions. */ #ifndef SQLITE_EXTERN # define SQLITE_EXTERN extern @@ -124,9 +147,9 @@ extern "C" { ** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite_version()] and [sqlite_source_id()]. */ -#define SQLITE_VERSION "3.34.0" -#define SQLITE_VERSION_NUMBER 3034000 -#define SQLITE_SOURCE_ID "2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089fed5b" +#define SQLITE_VERSION "3.37.0" +#define SQLITE_VERSION_NUMBER 3037000 +#define SQLITE_SOURCE_ID "2021-11-27 14:13:22 bd41822c7424d393a30e92ff6cb254d25c26769889c1499a18a0b9339f5d6c8a" /* ** CAPI3REF: Run-Time Library Version Numbers @@ -538,6 +561,7 @@ SQLITE_API int sqlite3_exec( #define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) #define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8)) #define SQLITE_CONSTRAINT_PINNED (SQLITE_CONSTRAINT |(11<<8)) +#define SQLITE_CONSTRAINT_DATATYPE (SQLITE_CONSTRAINT |(12<<8)) #define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8)) #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8)) #define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8)) @@ -551,6 +575,19 @@ SQLITE_API int sqlite3_exec( ** These bit values are intended for use in the ** 3rd parameter to the [sqlite3_open_v2()] interface and ** in the 4th parameter to the [sqlite3_vfs.xOpen] method. +** +** Only those flags marked as "Ok for sqlite3_open_v2()" may be +** used as the third argument to the [sqlite3_open_v2()] interface. +** The other flags have historically been ignored by sqlite3_open_v2(), +** though future versions of SQLite might change so that an error is +** raised if any of the disallowed bits are passed into sqlite3_open_v2(). +** Applications should not depend on the historical behavior. +** +** Note in particular that passing the SQLITE_OPEN_EXCLUSIVE flag into +** [sqlite3_open_v2()] does *not* cause the underlying database file +** to be opened using O_EXCL. Passing SQLITE_OPEN_EXCLUSIVE into +** [sqlite3_open_v2()] has historically be a no-op and might become an +** error in future versions of SQLite. */ #define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ #define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ @@ -573,6 +610,7 @@ SQLITE_API int sqlite3_exec( #define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ #define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ #define SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_EXRESCODE 0x02000000 /* Extended result codes */ /* Reserved: 0x00F00000 */ /* Legacy compatibility: */ @@ -1129,6 +1167,23 @@ struct sqlite3_io_methods { ** file to the database file, but before the *-shm file is updated to ** record the fact that the pages have been checkpointed. ** +** +**
    5. [[SQLITE_FCNTL_EXTERNAL_READER]] +** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect +** whether or not there is a database client in another process with a wal-mode +** transaction open on the database or not. It is only available on unix.The +** (void*) argument passed with this file-control should be a pointer to a +** value of type (int). The integer value is set to 1 if the database is a wal +** mode database and there exists at least one client in another process that +** currently has an SQL transaction open on the database. It is set to 0 if +** the database is not a wal-mode db, or if there is no such connection in any +** other process. This opcode cannot be used to detect transactions opened +** by clients within the current process, only within other processes. +** +** +**
    6. [[SQLITE_FCNTL_CKSM_FILE]] +** Used by the cksmvfs VFS module only. +** */ #define SQLITE_FCNTL_LOCKSTATE 1 #define SQLITE_FCNTL_GET_LOCKPROXYFILE 2 @@ -1168,6 +1223,8 @@ struct sqlite3_io_methods { #define SQLITE_FCNTL_CKPT_DONE 37 #define SQLITE_FCNTL_RESERVE_BYTES 38 #define SQLITE_FCNTL_CKPT_START 39 +#define SQLITE_FCNTL_EXTERNAL_READER 40 +#define SQLITE_FCNTL_CKSM_FILE 41 /* deprecated names */ #define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE @@ -2116,7 +2173,13 @@ struct sqlite3_mem_methods { ** The second parameter is a pointer to an integer into which ** is written 0 or 1 to indicate whether triggers are disabled or enabled ** following this call. The second parameter may be a NULL pointer, in -** which case the trigger setting is not reported back. +** which case the trigger setting is not reported back. +** +**

      Originally this option disabled all triggers. ^(However, since +** SQLite version 3.35.0, TEMP triggers are still allowed even if +** this option is off. So, in other words, this option now only disables +** triggers in the main database schema or in the schemas of ATTACH-ed +** databases.)^ ** ** [[SQLITE_DBCONFIG_ENABLE_VIEW]] **

      SQLITE_DBCONFIG_ENABLE_VIEW
      @@ -2127,7 +2190,13 @@ struct sqlite3_mem_methods { ** The second parameter is a pointer to an integer into which ** is written 0 or 1 to indicate whether views are disabled or enabled ** following this call. The second parameter may be a NULL pointer, in -** which case the view setting is not reported back. +** which case the view setting is not reported back. +** +**

      Originally this option disabled all views. ^(However, since +** SQLite version 3.35.0, TEMP views are still allowed even if +** this option is off. So, in other words, this option now only disables +** views in the main database schema or in the schemas of ATTACH-ed +** databases.)^ ** ** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]] **

      SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER
      @@ -2434,11 +2503,14 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64); ** CAPI3REF: Count The Number Of Rows Modified ** METHOD: sqlite3 ** -** ^This function returns the number of rows modified, inserted or +** ^These functions return the number of rows modified, inserted or ** deleted by the most recently completed INSERT, UPDATE or DELETE ** statement on the database connection specified by the only parameter. -** ^Executing any other type of SQL statement does not modify the value -** returned by this function. +** The two functions are identical except for the type of the return value +** and that if the number of rows modified by the most recent INSERT, UPDATE +** or DELETE is greater than the maximum value supported by type "int", then +** the return value of sqlite3_changes() is undefined. ^Executing any other +** type of SQL statement does not modify the value returned by these functions. ** ** ^Only changes made directly by the INSERT, UPDATE or DELETE statement are ** considered - auxiliary changes caused by [CREATE TRIGGER | triggers], @@ -2487,16 +2559,21 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64); ** */ SQLITE_API int sqlite3_changes(sqlite3*); +SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*); /* ** CAPI3REF: Total Number Of Rows Modified ** METHOD: sqlite3 ** -** ^This function returns the total number of rows inserted, modified or +** ^These functions return the total number of rows inserted, modified or ** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed ** since the database connection was opened, including those executed as -** part of trigger programs. ^Executing any other type of SQL statement -** does not affect the value returned by sqlite3_total_changes(). +** part of trigger programs. The two functions are identical except for the +** type of the return value and that if the number of rows modified by the +** connection exceeds the maximum value supported by type "int", then +** the return value of sqlite3_total_changes() is undefined. ^Executing +** any other type of SQL statement does not affect the value returned by +** sqlite3_total_changes(). ** ** ^Changes made as part of [foreign key actions] are included in the ** count, but those made as part of REPLACE constraint resolution are @@ -2524,6 +2601,7 @@ SQLITE_API int sqlite3_changes(sqlite3*); ** */ SQLITE_API int sqlite3_total_changes(sqlite3*); +SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*); /* ** CAPI3REF: Interrupt A Long-Running Query @@ -3353,6 +3431,14 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); ** the default shared cache setting provided by ** [sqlite3_enable_shared_cache()].)^ ** +** [[OPEN_EXRESCODE]] ^(
      [SQLITE_OPEN_EXRESCODE]
      +**
      The database connection comes up in "extended result code mode". +** In other words, the database behaves has if +** [sqlite3_extended_result_codes(db,1)] where called on the database +** connection as soon as the connection is created. In addition to setting +** the extended result code mode, this flag also causes [sqlite3_open_v2()] +** to return an extended result code.
      +** ** [[OPEN_NOFOLLOW]] ^(
      [SQLITE_OPEN_NOFOLLOW]
      **
      The database filename is not allowed to be a symbolic link
      ** )^ @@ -3360,7 +3446,15 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); ** If the 3rd parameter to sqlite3_open_v2() is not one of the ** required combinations shown above optionally combined with other ** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits] -** then the behavior is undefined. +** then the behavior is undefined. Historic versions of SQLite +** have silently ignored surplus bits in the flags parameter to +** sqlite3_open_v2(), however that behavior might not be carried through +** into future versions of SQLite and so applications should not rely +** upon it. Note in particular that the SQLITE_OPEN_EXCLUSIVE flag is a no-op +** for sqlite3_open_v2(). The SQLITE_OPEN_EXCLUSIVE does *not* cause +** the open to fail if the database already exists. The SQLITE_OPEN_EXCLUSIVE +** flag is intended for use by the [sqlite3_vfs|VFS interface] only, and not +** by sqlite3_open_v2(). ** ** ^The fourth parameter to sqlite3_open_v2() is the name of the ** [sqlite3_vfs] object that defines the operating system interface that @@ -3500,6 +3594,7 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); ** that uses dot-files in place of posix advisory locking. **
      7. file:data.db?mode=readonly ** An error. "readonly" is not a valid option for the "mode" parameter. +** Use "ro" instead: "file:data.db?mode=ro". **
      ** ** ^URI hexadecimal escape sequences (%HH) are supported within the path and @@ -3698,7 +3793,7 @@ SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*); ** If the Y parameter to sqlite3_free_filename(Y) is anything other ** than a NULL pointer or a pointer previously acquired from ** sqlite3_create_filename(), then bad things such as heap -** corruption or segfaults may occur. The value Y should be +** corruption or segfaults may occur. The value Y should not be ** used again after sqlite3_free_filename(Y) has been called. This means ** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y, ** then the corresponding [sqlite3_module.xClose() method should also be @@ -4127,12 +4222,17 @@ SQLITE_API int sqlite3_prepare16_v3( ** are managed by SQLite and are automatically freed when the prepared ** statement is finalized. ** ^The string returned by sqlite3_expanded_sql(P), on the other hand, -** is obtained from [sqlite3_malloc()] and must be free by the application +** is obtained from [sqlite3_malloc()] and must be freed by the application ** by passing it to [sqlite3_free()]. +** +** ^The sqlite3_normalized_sql() interface is only available if +** the [SQLITE_ENABLE_NORMALIZE] compile-time option is defined. */ SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt); +#ifdef SQLITE_ENABLE_NORMALIZE SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); +#endif /* ** CAPI3REF: Determine If An SQL Statement Writes The Database @@ -4167,6 +4267,15 @@ SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); ** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and ** [BEGIN|BEGIN EXCLUSIVE] commands do touch the database and so ** sqlite3_stmt_readonly() returns false for those commands. +** +** ^This routine returns false if there is any possibility that the +** statement might change the database file. ^A false return does +** not guarantee that the statement will change the database file. +** ^For example, an UPDATE statement might have a WHERE clause that +** makes it a no-op, but the sqlite3_stmt_readonly() result would still +** be false. ^Similarly, a CREATE TABLE IF NOT EXISTS statement is a +** read-only no-op if the table already exists, but +** sqlite3_stmt_readonly() still returns false for such a statement. */ SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt); @@ -4336,18 +4445,22 @@ typedef struct sqlite3_context sqlite3_context; ** contain embedded NULs. The result of expressions involving strings ** with embedded NULs is undefined. ** -** ^The fifth argument to the BLOB and string binding interfaces -** is a destructor used to dispose of the BLOB or -** string after SQLite has finished with it. ^The destructor is called -** to dispose of the BLOB or string even if the call to the bind API fails, -** except the destructor is not called if the third parameter is a NULL -** pointer or the fourth parameter is negative. -** ^If the fifth argument is -** the special value [SQLITE_STATIC], then SQLite assumes that the -** information is in static, unmanaged space and does not need to be freed. -** ^If the fifth argument has the value [SQLITE_TRANSIENT], then -** SQLite makes its own private copy of the data immediately, before -** the sqlite3_bind_*() routine returns. +** ^The fifth argument to the BLOB and string binding interfaces controls +** or indicates the lifetime of the object referenced by the third parameter. +** These three options exist: +** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished +** with it may be passed. ^It is called to dispose of the BLOB or string even +** if the call to the bind API fails, except the destructor is not called if +** the third parameter is a NULL pointer or the fourth parameter is negative. +** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that +** the application remains responsible for disposing of the object. ^In this +** case, the object and the provided pointer to it must remain valid until +** either the prepared statement is finalized or the same SQL parameter is +** bound to something else, whichever occurs sooner. +** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the +** object is to be copied prior to the return from sqlite3_bind_*(). ^The +** object and pointer to it must remain valid until then. ^SQLite will then +** manage the lifetime of its private copy. ** ** ^The sixth argument to sqlite3_bind_text64() must be one of ** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE] @@ -5089,7 +5202,6 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); ** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions, ** index expressions, or the WHERE clause of partial indexes. ** -** ** For best security, the [SQLITE_DIRECTONLY] flag is recommended for ** all application-defined SQL functions that do not need to be ** used inside of triggers, view, CHECK constraints, or other elements of @@ -5099,7 +5211,6 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); ** a database file to include invocations of the function with parameters ** chosen by the attacker, which the application will then execute when ** the database file is opened and read. -** ** ** ^(The fifth parameter is an arbitrary pointer. The implementation of the ** function can gain access to this pointer using [sqlite3_user_data()].)^ @@ -6305,6 +6416,72 @@ SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); +/* +** CAPI3REF: Autovacuum Compaction Amount Callback +** METHOD: sqlite3 +** +** ^The sqlite3_autovacuum_pages(D,C,P,X) interface registers a callback +** function C that is invoked prior to each autovacuum of the database +** file. ^The callback is passed a copy of the generic data pointer (P), +** the schema-name of the attached database that is being autovacuumed, +** the the size of the database file in pages, the number of free pages, +** and the number of bytes per page, respectively. The callback should +** return the number of free pages that should be removed by the +** autovacuum. ^If the callback returns zero, then no autovacuum happens. +** ^If the value returned is greater than or equal to the number of +** free pages, then a complete autovacuum happens. +** +**

      ^If there are multiple ATTACH-ed database files that are being +** modified as part of a transaction commit, then the autovacuum pages +** callback is invoked separately for each file. +** +**

      The callback is not reentrant. The callback function should +** not attempt to invoke any other SQLite interface. If it does, bad +** things may happen, including segmentation faults and corrupt database +** files. The callback function should be a simple function that +** does some arithmetic on its input parameters and returns a result. +** +** ^The X parameter to sqlite3_autovacuum_pages(D,C,P,X) is an optional +** destructor for the P parameter. ^If X is not NULL, then X(P) is +** invoked whenever the database connection closes or when the callback +** is overwritten by another invocation of sqlite3_autovacuum_pages(). +** +**

      ^There is only one autovacuum pages callback per database connection. +** ^Each call to the sqlite3_autovacuum_pages() interface overrides all +** previous invocations for that database connection. ^If the callback +** argument (C) to sqlite3_autovacuum_pages(D,C,P,X) is a NULL pointer, +** then the autovacuum steps callback is cancelled. The return value +** from sqlite3_autovacuum_pages() is normally SQLITE_OK, but might +** be some other error code if something goes wrong. The current +** implementation will only return SQLITE_OK or SQLITE_MISUSE, but other +** return codes might be added in future releases. +** +**

      If no autovacuum pages callback is specified (the usual case) or +** a NULL pointer is provided for the callback, +** then the default behavior is to vacuum all free pages. So, in other +** words, the default behavior is the same as if the callback function +** were something like this: +** +** 

      +**     unsigned int demonstration_autovac_pages_callback(
+**       void *pClientData,
+**       const char *zSchema,
+**       unsigned int nDbPage,
+**       unsigned int nFreePage,
+**       unsigned int nBytePerPage
+**     ){
+**       return nFreePage;
+**     }
+**
      +*/ +SQLITE_API int sqlite3_autovacuum_pages( + sqlite3 *db, + unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), + void*, + void(*)(void*) +); + + /* ** CAPI3REF: Data Change Notification Callbacks ** METHOD: sqlite3 @@ -7766,7 +7943,9 @@ SQLITE_API int sqlite3_test_control(int op, ...); #define SQLITE_TESTCTRL_PRNG_SEED 28 #define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29 #define SQLITE_TESTCTRL_SEEK_COUNT 30 -#define SQLITE_TESTCTRL_LAST 30 /* Largest TESTCTRL */ +#define SQLITE_TESTCTRL_TRACEFLAGS 31 +#define SQLITE_TESTCTRL_TUNE 32 +#define SQLITE_TESTCTRL_LAST 32 /* Largest TESTCTRL */ /* ** CAPI3REF: SQL Keyword Checking @@ -8966,8 +9145,9 @@ SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...); ** ** A single database handle may have at most a single write-ahead log callback ** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any -** previously registered write-ahead log callback. ^Note that the -** [sqlite3_wal_autocheckpoint()] interface and the +** previously registered write-ahead log callback. ^The return value is +** a copy of the third parameter from the previous call, if any, or 0. +** ^Note that the [sqlite3_wal_autocheckpoint()] interface and the ** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will ** overwrite any prior [sqlite3_wal_hook()] settings. */ @@ -9518,6 +9698,15 @@ SQLITE_API int sqlite3_db_cacheflush(sqlite3*); ** triggers; or 2 for changes resulting from triggers called by top-level ** triggers; and so forth. ** +** When the [sqlite3_blob_write()] API is used to update a blob column, +** the pre-update hook is invoked with SQLITE_DELETE. This is because the +** in this case the new values are not available. In this case, when a +** callback made with op==SQLITE_DELETE is actuall a write using the +** sqlite3_blob_write() API, the [sqlite3_preupdate_blobwrite()] returns +** the index of the column being written. In other cases, where the +** pre-update hook is being invoked for some other reason, including a +** regular DELETE, sqlite3_preupdate_blobwrite() returns -1. +** ** See also: [sqlite3_update_hook()] */ #if defined(SQLITE_ENABLE_PREUPDATE_HOOK) @@ -9538,6 +9727,7 @@ SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **); SQLITE_API int sqlite3_preupdate_count(sqlite3 *); SQLITE_API int sqlite3_preupdate_depth(sqlite3 *); SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **); +SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *); #endif /* @@ -9776,8 +9966,8 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const c ** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory ** allocation error occurs. ** -** This interface is only available if SQLite is compiled with the -** [SQLITE_ENABLE_DESERIALIZE] option. +** This interface is omitted if SQLite is compiled with the +** [SQLITE_OMIT_DESERIALIZE] option. */ SQLITE_API unsigned char *sqlite3_serialize( sqlite3 *db, /* The database connection */ @@ -9824,12 +10014,16 @@ SQLITE_API unsigned char *sqlite3_serialize( ** database is currently in a read transaction or is involved in a backup ** operation. ** +** It is not possible to deserialized into the TEMP database. If the +** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the +** function returns SQLITE_ERROR. +** ** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the ** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then ** [sqlite3_free()] is invoked on argument P prior to returning. ** -** This interface is only available if SQLite is compiled with the -** [SQLITE_ENABLE_DESERIALIZE] option. +** This interface is omitted if SQLite is compiled with the +** [SQLITE_OMIT_DESERIALIZE] option. */ SQLITE_API int sqlite3_deserialize( sqlite3 *db, /* The database connection */ @@ -10078,6 +10272,38 @@ SQLITE_API int sqlite3session_create( */ SQLITE_API void sqlite3session_delete(sqlite3_session *pSession); +/* +** CAPIREF: Conigure a Session Object +** METHOD: sqlite3_session +** +** This method is used to configure a session object after it has been +** created. At present the only valid value for the second parameter is +** [SQLITE_SESSION_OBJCONFIG_SIZE]. +** +** Arguments for sqlite3session_object_config() +** +** The following values may passed as the the 4th parameter to +** sqlite3session_object_config(). +** +**
      SQLITE_SESSION_OBJCONFIG_SIZE
      +** This option is used to set, clear or query the flag that enables +** the [sqlite3session_changeset_size()] API. Because it imposes some +** computational overhead, this API is disabled by default. Argument +** pArg must point to a value of type (int). If the value is initially +** 0, then the sqlite3session_changeset_size() API is disabled. If it +** is greater than 0, then the same API is enabled. Or, if the initial +** value is less than zero, no change is made. In all cases the (int) +** variable is set to 1 if the sqlite3session_changeset_size() API is +** enabled following the current call, or 0 otherwise. +** +** It is an error (SQLITE_MISUSE) to attempt to modify this setting after +** the first table has been attached to the session object. +*/ +SQLITE_API int sqlite3session_object_config(sqlite3_session*, int op, void *pArg); + +/* +*/ +#define SQLITE_SESSION_OBJCONFIG_SIZE 1 /* ** CAPI3REF: Enable Or Disable A Session Object @@ -10322,6 +10548,22 @@ SQLITE_API int sqlite3session_changeset( void **ppChangeset /* OUT: Buffer containing changeset */ ); +/* +** CAPI3REF: Return An Upper-limit For The Size Of The Changeset +** METHOD: sqlite3_session +** +** By default, this function always returns 0. For it to return +** a useful result, the sqlite3_session object must have been configured +** to enable this API using sqlite3session_object_config() with the +** SQLITE_SESSION_OBJCONFIG_SIZE verb. +** +** When enabled, this function returns an upper limit, in bytes, for the size +** of the changeset that might be produced if sqlite3session_changeset() were +** called. The final changeset size might be equal to or smaller than the +** size in bytes returned by this function. +*/ +SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession); + /* ** CAPI3REF: Load The Difference Between Tables Into A Session ** METHOD: sqlite3_session @@ -10439,6 +10681,14 @@ SQLITE_API int sqlite3session_patchset( */ SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession); +/* +** CAPI3REF: Query for the amount of heap memory used by a session object. +** +** This API returns the total amount of heap memory in bytes currently +** used by the session object passed as the only argument. +*/ +SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession); + /* ** CAPI3REF: Create An Iterator To Traverse A Changeset ** CONSTRUCTOR: sqlite3_changeset_iter @@ -10541,18 +10791,23 @@ SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter); ** call to [sqlite3changeset_next()] must have returned [SQLITE_ROW]. If this ** is not the case, this function returns [SQLITE_MISUSE]. ** -** If argument pzTab is not NULL, then *pzTab is set to point to a -** nul-terminated utf-8 encoded string containing the name of the table -** affected by the current change. The buffer remains valid until either -** sqlite3changeset_next() is called on the iterator or until the -** conflict-handler function returns. If pnCol is not NULL, then *pnCol is -** set to the number of columns in the table affected by the change. If -** pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change +** Arguments pOp, pnCol and pzTab may not be NULL. Upon return, three +** outputs are set through these pointers: +** +** *pOp is set to one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], +** depending on the type of change that the iterator currently points to; +** +** *pnCol is set to the number of columns in the table affected by the change; and +** +** *pzTab is set to point to a nul-terminated utf-8 encoded string containing +** the name of the table affected by the current change. The buffer remains +** valid until either sqlite3changeset_next() is called on the iterator +** or until the conflict-handler function returns. +** +** If pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change ** is an indirect change, or false (0) otherwise. See the documentation for ** [sqlite3session_indirect()] for a description of direct and indirect -** changes. Finally, if pOp is not NULL, then *pOp is set to one of -** [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], depending on the -** type of change that the iterator currently points to. +** changes. ** ** If no error occurs, SQLITE_OK is returned. If an error does occur, an ** SQLite error code is returned. The values of the output variables may not diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3.go b/vendor/github.com/mattn/go-sqlite3/sqlite3.go index d1ff406375..6ade8c9712 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3.go +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3.go @@ -21,8 +21,10 @@ package sqlite3 #cgo CFLAGS: -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT #cgo CFLAGS: -Wno-deprecated-declarations #cgo linux,!android CFLAGS: -DHAVE_PREAD64=1 -DHAVE_PWRITE64=1 +#cgo openbsd CFLAGS: -I/usr/local/include +#cgo openbsd LDFLAGS: -L/usr/local/lib #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif @@ -828,6 +830,10 @@ func (c *SQLiteConn) exec(ctx context.Context, query string, args []namedValue) tail := s.(*SQLiteStmt).t s.Close() if tail == "" { + if res == nil { + // https://github.com/mattn/go-sqlite3/issues/963 + res = &SQLiteResult{0, 0} + } return res, nil } query = tail @@ -1409,12 +1415,6 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) { return nil, errors.New("sqlite succeeded without returning a database") } - rv = C.sqlite3_busy_timeout(db, C.int(busyTimeout)) - if rv != C.SQLITE_OK { - C.sqlite3_close_v2(db) - return nil, Error{Code: ErrNo(rv)} - } - exec := func(s string) error { cs := C.CString(s) rv := C.sqlite3_exec(db, cs, nil, nil, nil) @@ -1425,6 +1425,12 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) { return nil } + // Busy timeout + if err := exec(fmt.Sprintf("PRAGMA busy_timeout = %d;", busyTimeout)); err != nil { + C.sqlite3_close_v2(db) + return nil, err + } + // USER AUTHENTICATION // // User Authentication is always performed even when @@ -1676,7 +1682,7 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) { // // Because default is NORMAL this statement is always executed if err := exec(fmt.Sprintf("PRAGMA synchronous = %s;", synchronousMode)); err != nil { - C.sqlite3_close_v2(db) + conn.Close() return nil, err } @@ -2007,6 +2013,13 @@ func (s *SQLiteStmt) execSync(args []namedValue) (driver.Result, error) { return &SQLiteResult{id: int64(rowid), changes: int64(changes)}, nil } +// Readonly reports if this statement is considered readonly by SQLite. +// +// See: https://sqlite.org/c3ref/stmt_readonly.html +func (s *SQLiteStmt) Readonly() bool { + return C.sqlite3_stmt_readonly(s.s) == 1 +} + // Close the rows. func (rc *SQLiteRows) Close() error { rc.s.mu.Lock() diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_context.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_context.go index 90800feeb3..7c7431dcce 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3_context.go +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_context.go @@ -8,7 +8,7 @@ package sqlite3 /* #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension.go index f2418196f6..9433fea82c 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension.go +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension.go @@ -9,7 +9,7 @@ package sqlite3 /* #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_column_metadata.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_column_metadata.go new file mode 100644 index 0000000000..c67fa82b10 --- /dev/null +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_column_metadata.go @@ -0,0 +1,21 @@ +// +build sqlite_column_metadata + +package sqlite3 + +/* +#ifndef USE_LIBSQLITE3 +#cgo CFLAGS: -DSQLITE_ENABLE_COLUMN_METADATA +#include +#else +#include +#endif +*/ +import "C" + +// ColumnTableName returns the table that is the origin of a particular result +// column in a SELECT statement. +// +// See https://www.sqlite.org/c3ref/column_database_name.html +func (s *SQLiteStmt) ColumnTableName(n int) string { + return C.GoString(C.sqlite3_column_table_name(s.s, C.int(n))) +} diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate_hook.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate_hook.go index db7a666219..b2e18bbcbb 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate_hook.go +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate_hook.go @@ -13,7 +13,7 @@ package sqlite3 #cgo LDFLAGS: -lm #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.c b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.c index 1af1726b44..fc37b336c3 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.c +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.c @@ -5,7 +5,7 @@ #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY #include -#include +#include "sqlite3-binding.h" extern int unlock_notify_wait(sqlite3 *db); diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go index 43f53e807c..adfa26c545 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go @@ -12,7 +12,7 @@ package sqlite3 #cgo CFLAGS: -DSQLITE_ENABLE_UNLOCK_NOTIFY #include -#include +#include "sqlite3-binding.h" extern void unlock_notify_callback(void *arg, int argc); */ diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go index 94203b397d..b62b60840a 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go @@ -11,7 +11,7 @@ package sqlite3 #cgo CFLAGS: -DSQLITE_USER_AUTHENTICATION #cgo LDFLAGS: -lm #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go index 8fd6cdffe7..4a93c46528 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go @@ -19,7 +19,7 @@ package sqlite3 #cgo CFLAGS: -Wno-deprecated-declarations #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif @@ -472,10 +472,21 @@ func goVBestIndex(pVTab unsafe.Pointer, icp unsafe.Pointer) *C.char { } info.idxNum = C.int(res.IdxNum) - idxStr := C.CString(res.IdxStr) - defer C.free(unsafe.Pointer(idxStr)) - info.idxStr = idxStr - info.needToFreeIdxStr = C.int(0) + info.idxStr = (*C.char)(C.sqlite3_malloc(C.int(len(res.IdxStr) + 1))) + if info.idxStr == nil { + // C.malloc and C.CString ordinarily do this for you. See https://golang.org/cmd/cgo/ + panic("out of memory") + } + info.needToFreeIdxStr = C.int(1) + + idxStr := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(info.idxStr)), + Len: len(res.IdxStr) + 1, + Cap: len(res.IdxStr) + 1, + })) + copy(idxStr, res.IdxStr) + idxStr[len(idxStr)-1] = 0 // null-terminated string + if res.AlreadyOrdered { info.orderByConsumed = C.int(1) } diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_trace.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_trace.go index 4c8d9928a8..56bb91490d 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3_trace.go +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_trace.go @@ -9,7 +9,7 @@ package sqlite3 /* #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_type.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_type.go index b4128db4b3..0fd8210bb6 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3_type.go +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_type.go @@ -1,5 +1,4 @@ // Copyright (C) 2019 Yasuhiro Matsumoto . -// // Use of this source code is governed by an MIT-style // license that can be found in the LICENSE file. @@ -7,15 +6,16 @@ package sqlite3 /* #ifndef USE_LIBSQLITE3 -#include +#include "sqlite3-binding.h" #else #include #endif */ import "C" import ( + "database/sql" "reflect" - "time" + "strings" ) // ColumnTypeDatabaseTypeName implement RowsColumnTypeDatabaseTypeName. @@ -31,32 +31,78 @@ func (rc *SQLiteRows) ColumnTypeLength(index int) (length int64, ok bool) { func (rc *SQLiteRows) ColumnTypePrecisionScale(index int) (precision, scale int64, ok bool) { return 0, 0, false } +*/ // ColumnTypeNullable implement RowsColumnTypeNullable. func (rc *SQLiteRows) ColumnTypeNullable(i int) (nullable, ok bool) { - return false, false + return true, true } -*/ // ColumnTypeScanType implement RowsColumnTypeScanType. func (rc *SQLiteRows) ColumnTypeScanType(i int) reflect.Type { - switch C.sqlite3_column_type(rc.s.s, C.int(i)) { - case C.SQLITE_INTEGER: - switch C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i))) { - case "timestamp", "datetime", "date": - return reflect.TypeOf(time.Time{}) - case "boolean": - return reflect.TypeOf(false) - } - return reflect.TypeOf(int64(0)) - case C.SQLITE_FLOAT: - return reflect.TypeOf(float64(0)) - case C.SQLITE_BLOB: - return reflect.SliceOf(reflect.TypeOf(byte(0))) - case C.SQLITE_NULL: - return reflect.TypeOf(nil) - case C.SQLITE_TEXT: - return reflect.TypeOf("") - } - return reflect.SliceOf(reflect.TypeOf(byte(0))) + //ct := C.sqlite3_column_type(rc.s.s, C.int(i)) // Always returns 5 + return scanType(C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i)))) +} + +const ( + SQLITE_INTEGER = iota + SQLITE_TEXT + SQLITE_BLOB + SQLITE_REAL + SQLITE_NUMERIC + SQLITE_TIME + SQLITE_BOOL + SQLITE_NULL +) + +func scanType(cdt string) reflect.Type { + t := strings.ToUpper(cdt) + i := databaseTypeConvSqlite(t) + switch i { + case SQLITE_INTEGER: + return reflect.TypeOf(sql.NullInt64{}) + case SQLITE_TEXT: + return reflect.TypeOf(sql.NullString{}) + case SQLITE_BLOB: + return reflect.TypeOf(sql.RawBytes{}) + case SQLITE_REAL: + return reflect.TypeOf(sql.NullFloat64{}) + case SQLITE_NUMERIC: + return reflect.TypeOf(sql.NullFloat64{}) + case SQLITE_BOOL: + return reflect.TypeOf(sql.NullBool{}) + case SQLITE_TIME: + return reflect.TypeOf(sql.NullTime{}) + } + return reflect.TypeOf(new(interface{})) +} + +func databaseTypeConvSqlite(t string) int { + if strings.Contains(t, "INT") { + return SQLITE_INTEGER + } + if t == "CLOB" || t == "TEXT" || + strings.Contains(t, "CHAR") { + return SQLITE_TEXT + } + if t == "BLOB" { + return SQLITE_BLOB + } + if t == "REAL" || t == "FLOAT" || + strings.Contains(t, "DOUBLE") { + return SQLITE_REAL + } + if t == "DATE" || t == "DATETIME" || + t == "TIMESTAMP" { + return SQLITE_TIME + } + if t == "NUMERIC" || + strings.Contains(t, "DECIMAL") { + return SQLITE_NUMERIC + } + if t == "BOOLEAN" { + return SQLITE_BOOL + } + + return SQLITE_NULL } diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3ext.h b/vendor/github.com/mattn/go-sqlite3/sqlite3ext.h index b2b6e0c8dd..fd6e2d4e86 100644 --- a/vendor/github.com/mattn/go-sqlite3/sqlite3ext.h +++ b/vendor/github.com/mattn/go-sqlite3/sqlite3ext.h @@ -19,6 +19,10 @@ #ifndef SQLITE3EXT_H #define SQLITE3EXT_H #include "sqlite3-binding.h" +#ifdef __clang__ +#define assert(condition) ((void)0) +#endif + /* ** The following structure holds pointers to all of the SQLite API @@ -338,6 +342,13 @@ struct sqlite3_api_routines { sqlite3_file *(*database_file_object)(const char*); /* Version 3.34.0 and later */ int (*txn_state)(sqlite3*,const char*); + /* Version 3.36.1 and later */ + sqlite3_int64 (*changes64)(sqlite3*); + sqlite3_int64 (*total_changes64)(sqlite3*); + /* Version 3.37.0 and later */ + int (*autovacuum_pages)(sqlite3*, + unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), + void*, void(*)(void*)); }; /* @@ -644,6 +655,11 @@ typedef int (*sqlite3_loadext_entry)( #define sqlite3_database_file_object sqlite3_api->database_file_object /* Version 3.34.0 and later */ #define sqlite3_txn_state sqlite3_api->txn_state +/* Version 3.36.1 and later */ +#define sqlite3_changes64 sqlite3_api->changes64 +#define sqlite3_total_changes64 sqlite3_api->total_changes64 +/* Version 3.37.0 and later */ +#define sqlite3_autovacuum_pages sqlite3_api->autovacuum_pages #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */ #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) diff --git a/vendor/github.com/modern-go/reflect2/.travis.yml b/vendor/github.com/modern-go/reflect2/.travis.yml index fbb43744d9..b097728dbf 100644 --- a/vendor/github.com/modern-go/reflect2/.travis.yml +++ b/vendor/github.com/modern-go/reflect2/.travis.yml @@ -1,7 +1,7 @@ language: go go: - - 1.8.x + - 1.9.x - 1.x before_install: diff --git a/vendor/github.com/modern-go/reflect2/Gopkg.lock b/vendor/github.com/modern-go/reflect2/Gopkg.lock index 2a3a69893b..10ef811182 100644 --- a/vendor/github.com/modern-go/reflect2/Gopkg.lock +++ b/vendor/github.com/modern-go/reflect2/Gopkg.lock @@ -1,15 +1,9 @@ # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. -[[projects]] - name = "github.com/modern-go/concurrent" - packages = ["."] - revision = "e0a39a4cb4216ea8db28e22a69f4ec25610d513a" - version = "1.0.0" - [solve-meta] analyzer-name = "dep" analyzer-version = 1 - inputs-digest = "daee8a88b3498b61c5640056665b8b9eea062006f5e596bbb6a3ed9119a11ec7" + input-imports = [] solver-name = "gps-cdcl" solver-version = 1 diff --git a/vendor/github.com/modern-go/reflect2/Gopkg.toml b/vendor/github.com/modern-go/reflect2/Gopkg.toml index 2f4f4dbdcc..a9bc5061b0 100644 --- a/vendor/github.com/modern-go/reflect2/Gopkg.toml +++ b/vendor/github.com/modern-go/reflect2/Gopkg.toml @@ -26,10 +26,6 @@ ignored = [] -[[constraint]] - name = "github.com/modern-go/concurrent" - version = "1.0.0" - [prune] go-tests = true unused-packages = true diff --git a/vendor/github.com/modern-go/reflect2/go.mod b/vendor/github.com/modern-go/reflect2/go.mod new file mode 100644 index 0000000000..9057e9b33f --- /dev/null +++ b/vendor/github.com/modern-go/reflect2/go.mod @@ -0,0 +1,3 @@ +module github.com/modern-go/reflect2 + +go 1.12 diff --git a/vendor/github.com/modern-go/reflect2/go_above_118.go b/vendor/github.com/modern-go/reflect2/go_above_118.go new file mode 100644 index 0000000000..2b4116f6c9 --- /dev/null +++ b/vendor/github.com/modern-go/reflect2/go_above_118.go @@ -0,0 +1,23 @@ +//+build go1.18 + +package reflect2 + +import ( + "unsafe" +) + +// m escapes into the return value, but the caller of mapiterinit +// doesn't let the return value escape. +//go:noescape +//go:linkname mapiterinit reflect.mapiterinit +func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer, it *hiter) + +func (type2 *UnsafeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator { + var it hiter + mapiterinit(type2.rtype, *(*unsafe.Pointer)(obj), &it) + return &UnsafeMapIterator{ + hiter: &it, + pKeyRType: type2.pKeyRType, + pElemRType: type2.pElemRType, + } +} \ No newline at end of file diff --git a/vendor/github.com/modern-go/reflect2/go_above_17.go b/vendor/github.com/modern-go/reflect2/go_above_17.go deleted file mode 100644 index 5c1cea8683..0000000000 --- a/vendor/github.com/modern-go/reflect2/go_above_17.go +++ /dev/null @@ -1,8 +0,0 @@ -//+build go1.7 - -package reflect2 - -import "unsafe" - -//go:linkname resolveTypeOff reflect.resolveTypeOff -func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer diff --git a/vendor/github.com/modern-go/reflect2/go_above_19.go b/vendor/github.com/modern-go/reflect2/go_above_19.go index c7e3b78011..974f7685e4 100644 --- a/vendor/github.com/modern-go/reflect2/go_above_19.go +++ b/vendor/github.com/modern-go/reflect2/go_above_19.go @@ -6,6 +6,9 @@ import ( "unsafe" ) +//go:linkname resolveTypeOff reflect.resolveTypeOff +func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer + //go:linkname makemap reflect.makemap func makemap(rtype unsafe.Pointer, cap int) (m unsafe.Pointer) diff --git a/vendor/github.com/modern-go/reflect2/go_below_118.go b/vendor/github.com/modern-go/reflect2/go_below_118.go new file mode 100644 index 0000000000..00003dbd7c --- /dev/null +++ b/vendor/github.com/modern-go/reflect2/go_below_118.go @@ -0,0 +1,21 @@ +//+build !go1.18 + +package reflect2 + +import ( + "unsafe" +) + +// m escapes into the return value, but the caller of mapiterinit +// doesn't let the return value escape. +//go:noescape +//go:linkname mapiterinit reflect.mapiterinit +func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer) (val *hiter) + +func (type2 *UnsafeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator { + return &UnsafeMapIterator{ + hiter: mapiterinit(type2.rtype, *(*unsafe.Pointer)(obj)), + pKeyRType: type2.pKeyRType, + pElemRType: type2.pElemRType, + } +} \ No newline at end of file diff --git a/vendor/github.com/modern-go/reflect2/go_below_17.go b/vendor/github.com/modern-go/reflect2/go_below_17.go deleted file mode 100644 index 65a93c889b..0000000000 --- a/vendor/github.com/modern-go/reflect2/go_below_17.go +++ /dev/null @@ -1,9 +0,0 @@ -//+build !go1.7 - -package reflect2 - -import "unsafe" - -func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer { - return nil -} diff --git a/vendor/github.com/modern-go/reflect2/go_below_19.go b/vendor/github.com/modern-go/reflect2/go_below_19.go deleted file mode 100644 index b050ef70cd..0000000000 --- a/vendor/github.com/modern-go/reflect2/go_below_19.go +++ /dev/null @@ -1,14 +0,0 @@ -//+build !go1.9 - -package reflect2 - -import ( - "unsafe" -) - -//go:linkname makemap reflect.makemap -func makemap(rtype unsafe.Pointer) (m unsafe.Pointer) - -func makeMapWithSize(rtype unsafe.Pointer, cap int) unsafe.Pointer { - return makemap(rtype) -} diff --git a/vendor/github.com/modern-go/reflect2/reflect2.go b/vendor/github.com/modern-go/reflect2/reflect2.go index 63b49c7991..c43c8b9d62 100644 --- a/vendor/github.com/modern-go/reflect2/reflect2.go +++ b/vendor/github.com/modern-go/reflect2/reflect2.go @@ -1,8 +1,9 @@ package reflect2 import ( - "github.com/modern-go/concurrent" "reflect" + "runtime" + "sync" "unsafe" ) @@ -130,13 +131,13 @@ var ConfigSafe = Config{UseSafeImplementation: true}.Froze() type frozenConfig struct { useSafeImplementation bool - cache *concurrent.Map + cache *sync.Map } func (cfg Config) Froze() *frozenConfig { return &frozenConfig{ useSafeImplementation: cfg.UseSafeImplementation, - cache: concurrent.NewMap(), + cache: new(sync.Map), } } @@ -288,11 +289,12 @@ func NoEscape(p unsafe.Pointer) unsafe.Pointer { } func UnsafeCastString(str string) []byte { + bytes := make([]byte, 0) stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&str)) - sliceHeader := &reflect.SliceHeader{ - Data: stringHeader.Data, - Cap: stringHeader.Len, - Len: stringHeader.Len, - } - return *(*[]byte)(unsafe.Pointer(sliceHeader)) + sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&bytes)) + sliceHeader.Data = stringHeader.Data + sliceHeader.Cap = stringHeader.Len + sliceHeader.Len = stringHeader.Len + runtime.KeepAlive(str) + return bytes } diff --git a/vendor/github.com/modern-go/reflect2/test.sh b/vendor/github.com/modern-go/reflect2/test.sh deleted file mode 100644 index 3d2b9768ce..0000000000 --- a/vendor/github.com/modern-go/reflect2/test.sh +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/env bash - -set -e -echo "" > coverage.txt - -for d in $(go list github.com/modern-go/reflect2-tests/... | grep -v vendor); do - go test -coverprofile=profile.out -coverpkg=github.com/modern-go/reflect2 $d - if [ -f profile.out ]; then - cat profile.out >> coverage.txt - rm profile.out - fi -done diff --git a/vendor/github.com/modern-go/reflect2/type_map.go b/vendor/github.com/modern-go/reflect2/type_map.go index 3acfb55803..4b13c3155c 100644 --- a/vendor/github.com/modern-go/reflect2/type_map.go +++ b/vendor/github.com/modern-go/reflect2/type_map.go @@ -1,17 +1,13 @@ +// +build !gccgo + package reflect2 import ( "reflect" - "runtime" - "strings" "sync" "unsafe" ) -// typelinks1 for 1.5 ~ 1.6 -//go:linkname typelinks1 reflect.typelinks -func typelinks1() [][]unsafe.Pointer - // typelinks2 for 1.7 ~ //go:linkname typelinks2 reflect.typelinks func typelinks2() (sections []unsafe.Pointer, offset [][]int32) @@ -27,49 +23,10 @@ func discoverTypes() { types = make(map[string]reflect.Type) packages = make(map[string]map[string]reflect.Type) - ver := runtime.Version() - if ver == "go1.5" || strings.HasPrefix(ver, "go1.5.") { - loadGo15Types() - } else if ver == "go1.6" || strings.HasPrefix(ver, "go1.6.") { - loadGo15Types() - } else { - loadGo17Types() - } -} - -func loadGo15Types() { - var obj interface{} = reflect.TypeOf(0) - typePtrss := typelinks1() - for _, typePtrs := range typePtrss { - for _, typePtr := range typePtrs { - (*emptyInterface)(unsafe.Pointer(&obj)).word = typePtr - typ := obj.(reflect.Type) - if typ.Kind() == reflect.Ptr && typ.Elem().Kind() == reflect.Struct { - loadedType := typ.Elem() - pkgTypes := packages[loadedType.PkgPath()] - if pkgTypes == nil { - pkgTypes = map[string]reflect.Type{} - packages[loadedType.PkgPath()] = pkgTypes - } - types[loadedType.String()] = loadedType - pkgTypes[loadedType.Name()] = loadedType - } - if typ.Kind() == reflect.Slice && typ.Elem().Kind() == reflect.Ptr && - typ.Elem().Elem().Kind() == reflect.Struct { - loadedType := typ.Elem().Elem() - pkgTypes := packages[loadedType.PkgPath()] - if pkgTypes == nil { - pkgTypes = map[string]reflect.Type{} - packages[loadedType.PkgPath()] = pkgTypes - } - types[loadedType.String()] = loadedType - pkgTypes[loadedType.Name()] = loadedType - } - } - } + loadGoTypes() } -func loadGo17Types() { +func loadGoTypes() { var obj interface{} = reflect.TypeOf(0) sections, offset := typelinks2() for i, offs := range offset { diff --git a/vendor/github.com/modern-go/reflect2/unsafe_link.go b/vendor/github.com/modern-go/reflect2/unsafe_link.go index 57229c8db4..b49f614efc 100644 --- a/vendor/github.com/modern-go/reflect2/unsafe_link.go +++ b/vendor/github.com/modern-go/reflect2/unsafe_link.go @@ -19,18 +19,12 @@ func typedslicecopy(elemType unsafe.Pointer, dst, src sliceHeader) int //go:linkname mapassign reflect.mapassign //go:noescape -func mapassign(rtype unsafe.Pointer, m unsafe.Pointer, key, val unsafe.Pointer) +func mapassign(rtype unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer, val unsafe.Pointer) //go:linkname mapaccess reflect.mapaccess //go:noescape func mapaccess(rtype unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer) -// m escapes into the return value, but the caller of mapiterinit -// doesn't let the return value escape. -//go:noescape -//go:linkname mapiterinit reflect.mapiterinit -func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer) *hiter - //go:noescape //go:linkname mapiternext reflect.mapiternext func mapiternext(it *hiter) @@ -42,9 +36,21 @@ func ifaceE2I(rtype unsafe.Pointer, src interface{}, dst unsafe.Pointer) // If you modify hiter, also change cmd/internal/gc/reflect.go to indicate // the layout of this structure. type hiter struct { - key unsafe.Pointer // Must be in first position. Write nil to indicate iteration end (see cmd/internal/gc/range.go). - value unsafe.Pointer // Must be in second position (see cmd/internal/gc/range.go). - // rest fields are ignored + key unsafe.Pointer + value unsafe.Pointer + t unsafe.Pointer + h unsafe.Pointer + buckets unsafe.Pointer + bptr unsafe.Pointer + overflow *[]unsafe.Pointer + oldoverflow *[]unsafe.Pointer + startBucket uintptr + offset uint8 + wrapped bool + B uint8 + i uint8 + bucket uintptr + checkBucket uintptr } // add returns p+x. diff --git a/vendor/github.com/modern-go/reflect2/unsafe_map.go b/vendor/github.com/modern-go/reflect2/unsafe_map.go index f2e76e6bb1..37872da819 100644 --- a/vendor/github.com/modern-go/reflect2/unsafe_map.go +++ b/vendor/github.com/modern-go/reflect2/unsafe_map.go @@ -107,14 +107,6 @@ func (type2 *UnsafeMapType) Iterate(obj interface{}) MapIterator { return type2.UnsafeIterate(objEFace.data) } -func (type2 *UnsafeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator { - return &UnsafeMapIterator{ - hiter: mapiterinit(type2.rtype, *(*unsafe.Pointer)(obj)), - pKeyRType: type2.pKeyRType, - pElemRType: type2.pElemRType, - } -} - type UnsafeMapIterator struct { *hiter pKeyRType unsafe.Pointer diff --git a/vendor/github.com/onsi/ginkgo/config/config.go b/vendor/github.com/onsi/ginkgo/config/config.go index 5f3f43969b..3130c77897 100644 --- a/vendor/github.com/onsi/ginkgo/config/config.go +++ b/vendor/github.com/onsi/ginkgo/config/config.go @@ -20,7 +20,7 @@ import ( "fmt" ) -const VERSION = "1.16.4" +const VERSION = "1.16.5" type GinkgoConfigType struct { RandomSeed int64 diff --git a/vendor/github.com/onsi/ginkgo/ginkgo/bootstrap_command.go b/vendor/github.com/onsi/ginkgo/ginkgo/bootstrap_command.go index 6f5af39134..ea10e97963 100644 --- a/vendor/github.com/onsi/ginkgo/ginkgo/bootstrap_command.go +++ b/vendor/github.com/onsi/ginkgo/ginkgo/bootstrap_command.go @@ -37,6 +37,7 @@ func BuildBootstrapCommand() *Command { }, Command: func(args []string, additionalArgs []string) { generateBootstrap(agouti, noDot, internal, customBootstrapFile) + emitRCAdvertisement() }, } } diff --git a/vendor/github.com/onsi/ginkgo/ginkgo/generate_command.go b/vendor/github.com/onsi/ginkgo/ginkgo/generate_command.go index 27758bebac..f792716764 100644 --- a/vendor/github.com/onsi/ginkgo/ginkgo/generate_command.go +++ b/vendor/github.com/onsi/ginkgo/ginkgo/generate_command.go @@ -36,6 +36,7 @@ func BuildGenerateCommand() *Command { }, Command: func(args []string, additionalArgs []string) { generateSpec(args, agouti, noDot, internal, customTestFile) + emitRCAdvertisement() }, } } diff --git a/vendor/github.com/onsi/ginkgo/ginkgo/help_command.go b/vendor/github.com/onsi/ginkgo/ginkgo/help_command.go index 23b1d2f117..db3f40406d 100644 --- a/vendor/github.com/onsi/ginkgo/ginkgo/help_command.go +++ b/vendor/github.com/onsi/ginkgo/ginkgo/help_command.go @@ -20,6 +20,7 @@ func BuildHelpCommand() *Command { func printHelp(args []string, additionalArgs []string) { if len(args) == 0 { usage() + emitRCAdvertisement() } else { command, found := commandMatching(args[0]) if !found { @@ -27,5 +28,6 @@ func printHelp(args []string, additionalArgs []string) { } usageForCommand(command, true) + emitRCAdvertisement() } } diff --git a/vendor/github.com/onsi/ginkgo/ginkgo/main.go b/vendor/github.com/onsi/ginkgo/ginkgo/main.go index ac725bf408..ae0e1daf61 100644 --- a/vendor/github.com/onsi/ginkgo/ginkgo/main.go +++ b/vendor/github.com/onsi/ginkgo/ginkgo/main.go @@ -131,9 +131,11 @@ import ( "fmt" "os" "os/exec" + "path/filepath" "strings" "github.com/onsi/ginkgo/config" + "github.com/onsi/ginkgo/formatter" "github.com/onsi/ginkgo/ginkgo/testsuite" ) @@ -243,6 +245,7 @@ func usageForCommand(command *Command, longForm bool) { func complainAndQuit(complaint string) { fmt.Fprintf(os.Stderr, "%s\nFor usage instructions:\n\tginkgo help\n", complaint) + emitRCAdvertisement() os.Exit(1) } @@ -306,3 +309,29 @@ func pluralizedWord(singular, plural string, count int) string { } return plural } + +func emitRCAdvertisement() { + ackRC := os.Getenv("ACK_GINKGO_RC") + if ackRC != "" { + return + } + home, err := os.UserHomeDir() + if err == nil { + _, err := os.Stat(filepath.Join(home, ".ack-ginkgo-rc")) + if err == nil { + return + } + } + + out := formatter.F("\n{{light-yellow}}Ginkgo 2.0 is coming soon!{{/}}\n") + out += formatter.F("{{light-yellow}}=========================={{/}}\n") + out += formatter.F("{{bold}}{{green}}Ginkgo 2.0{{/}} is under active development and will introduce several new features, improvements, and a small handful of breaking changes.\n") + out += formatter.F("A release candidate for 2.0 is now available and 2.0 should GA in Fall 2021. {{bold}}Please give the RC a try and send us feedback!{{/}}\n") + out += formatter.F(" - To learn more, view the migration guide at {{cyan}}{{underline}}https://github.com/onsi/ginkgo/blob/ver2/docs/MIGRATING_TO_V2.md{{/}}\n") + out += formatter.F(" - For instructions on using the Release Candidate visit {{cyan}}{{underline}}https://github.com/onsi/ginkgo/blob/ver2/docs/MIGRATING_TO_V2.md#using-the-beta{{/}}\n") + out += formatter.F(" - To comment, chime in at {{cyan}}{{underline}}https://github.com/onsi/ginkgo/issues/711{{/}}\n\n") + out += formatter.F("To {{bold}}{{coral}}silence this notice{{/}}, set the environment variable: {{bold}}ACK_GINKGO_RC=true{{/}}\n") + out += formatter.F("Alternatively you can: {{bold}}touch $HOME/.ack-ginkgo-rc{{/}}") + + fmt.Println(out) +} diff --git a/vendor/github.com/onsi/ginkgo/ginkgo/run_command.go b/vendor/github.com/onsi/ginkgo/ginkgo/run_command.go index c7f80d1437..f3d4e99a55 100644 --- a/vendor/github.com/onsi/ginkgo/ginkgo/run_command.go +++ b/vendor/github.com/onsi/ginkgo/ginkgo/run_command.go @@ -161,6 +161,7 @@ func (r *SpecRunner) RunSpecs(args []string, additionalArgs []string) { } } else { fmt.Printf("Test Suite Failed\n") + emitRCAdvertisement() os.Exit(1) } } diff --git a/vendor/github.com/onsi/ginkgo/ginkgo/version_command.go b/vendor/github.com/onsi/ginkgo/ginkgo/version_command.go index f586908e87..a5b68c216f 100644 --- a/vendor/github.com/onsi/ginkgo/ginkgo/version_command.go +++ b/vendor/github.com/onsi/ginkgo/ginkgo/version_command.go @@ -21,4 +21,5 @@ func BuildVersionCommand() *Command { func printVersion([]string, []string) { fmt.Printf("Ginkgo Version %s\n", config.VERSION) + emitRCAdvertisement() } diff --git a/vendor/github.com/onsi/ginkgo/types/deprecation_support.go b/vendor/github.com/onsi/ginkgo/types/deprecation_support.go index 305c134b78..d5a6658f35 100644 --- a/vendor/github.com/onsi/ginkgo/types/deprecation_support.go +++ b/vendor/github.com/onsi/ginkgo/types/deprecation_support.go @@ -52,6 +52,14 @@ func (d deprecations) Measure() Deprecation { } } +func (d deprecations) ParallelNode() Deprecation { + return Deprecation{ + Message: "GinkgoParallelNode is deprecated and will be removed in Ginkgo V2. Please use GinkgoParallelProcess instead.", + DocLink: "renamed-ginkgoparallelnode", + Version: "1.16.5", + } +} + func (d deprecations) Convert() Deprecation { return Deprecation{ Message: "The convert command is deprecated in Ginkgo V2", @@ -99,16 +107,18 @@ func (d *DeprecationTracker) DidTrackDeprecations() bool { } func (d *DeprecationTracker) DeprecationsReport() string { - out := formatter.F("{{light-yellow}}You're using deprecated Ginkgo functionality:{{/}}\n") + out := formatter.F("\n{{light-yellow}}You're using deprecated Ginkgo functionality:{{/}}\n") out += formatter.F("{{light-yellow}}============================================={{/}}\n") - out += formatter.F("Ginkgo 2.0 is under active development and will introduce (a small number of) breaking changes.\n") - out += formatter.F("To learn more, view the migration guide at {{cyan}}{{underline}}https://github.com/onsi/ginkgo/blob/v2/docs/MIGRATING_TO_V2.md{{/}}\n") - out += formatter.F("To comment, chime in at {{cyan}}{{underline}}https://github.com/onsi/ginkgo/issues/711{{/}}\n\n") + out += formatter.F("{{bold}}{{green}}Ginkgo 2.0{{/}} is under active development and will introduce several new features, improvements, and a small handful of breaking changes.\n") + out += formatter.F("A release candidate for 2.0 is now available and 2.0 should GA in Fall 2021. {{bold}}Please give the RC a try and send us feedback!{{/}}\n") + out += formatter.F(" - To learn more, view the migration guide at {{cyan}}{{underline}}https://github.com/onsi/ginkgo/blob/ver2/docs/MIGRATING_TO_V2.md{{/}}\n") + out += formatter.F(" - For instructions on using the Release Candidate visit {{cyan}}{{underline}}https://github.com/onsi/ginkgo/blob/ver2/docs/MIGRATING_TO_V2.md#using-the-beta{{/}}\n") + out += formatter.F(" - To comment, chime in at {{cyan}}{{underline}}https://github.com/onsi/ginkgo/issues/711{{/}}\n\n") for deprecation, locations := range d.deprecations { out += formatter.Fi(1, "{{yellow}}"+deprecation.Message+"{{/}}\n") if deprecation.DocLink != "" { - out += formatter.Fi(1, "{{bold}}Learn more at:{{/}} {{cyan}}{{underline}}https://github.com/onsi/ginkgo/blob/v2/docs/MIGRATING_TO_V2.md#%s{{/}}\n", deprecation.DocLink) + out += formatter.Fi(1, "{{bold}}Learn more at:{{/}} {{cyan}}{{underline}}https://github.com/onsi/ginkgo/blob/ver2/docs/MIGRATING_TO_V2.md#%s{{/}}\n", deprecation.DocLink) } for _, location := range locations { out += formatter.Fi(2, "{{gray}}%s{{/}}\n", location) diff --git a/vendor/github.com/onsi/gomega/types/types.go b/vendor/github.com/onsi/gomega/types/types.go index c75fcb3cce..c315ef0656 100644 --- a/vendor/github.com/onsi/gomega/types/types.go +++ b/vendor/github.com/onsi/gomega/types/types.go @@ -66,6 +66,10 @@ func MatchMayChangeInTheFuture(matcher GomegaMatcher, value interface{}) bool { type AsyncAssertion interface { Should(matcher GomegaMatcher, optionalDescription ...interface{}) bool ShouldNot(matcher GomegaMatcher, optionalDescription ...interface{}) bool + + WithOffset(offset int) AsyncAssertion + WithTimeout(interval time.Duration) AsyncAssertion + WithPolling(interval time.Duration) AsyncAssertion } // Assertions are returned by Ω and Expect and enable assertions against Gomega matchers @@ -76,4 +80,8 @@ type Assertion interface { To(matcher GomegaMatcher, optionalDescription ...interface{}) bool ToNot(matcher GomegaMatcher, optionalDescription ...interface{}) bool NotTo(matcher GomegaMatcher, optionalDescription ...interface{}) bool + + WithOffset(offset int) Assertion + + Error() Assertion } diff --git a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_catalogsources.yaml b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_catalogsources.yaml index 192cf663fb..318393f814 100644 --- a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_catalogsources.yaml +++ b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_catalogsources.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: catalogsources.operators.coreos.com spec: @@ -145,7 +145,7 @@ spec: description: Represents the state of a CatalogSource. Note that Message and Reason represent the original status information, which may be migrated to be conditions based in the future. Any new features introduced will use conditions. type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_clusterserviceversions.yaml b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_clusterserviceversions.yaml index 7d3a2abe33..4f2753d321 100644 --- a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_clusterserviceversions.yaml +++ b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_clusterserviceversions.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: clusterserviceversions.operators.coreos.com spec: @@ -570,7 +570,7 @@ spec: items: type: string verbs: - description: Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + description: Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. type: array items: type: string @@ -1297,7 +1297,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1343,7 +1343,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -1358,11 +1358,11 @@ spec: - type: string x-kubernetes-int-or-string: true preStop: - description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod''s termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' + description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod''s termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1408,7 +1408,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -1427,7 +1427,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1439,6 +1439,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -1489,7 +1502,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -1550,7 +1563,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1562,6 +1575,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -1612,7 +1638,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -1661,10 +1687,10 @@ spec: type: object properties: allowPrivilegeEscalation: - description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN' + description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.' type: boolean capabilities: - description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. + description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. type: object properties: add: @@ -1680,27 +1706,27 @@ spec: description: Capability represent POSIX capabilities type type: string privileged: - description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. type: boolean procMount: - description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. + description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. type: string readOnlyRootFilesystem: - description: Whether this container has a read-only root filesystem. Default is false. + description: Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. type: boolean runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -1716,7 +1742,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. + description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -1728,7 +1754,7 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -1748,7 +1774,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -1760,6 +1786,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -1810,7 +1849,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -1927,10 +1966,10 @@ spec: description: 'EnableServiceLinks indicates whether information about services should be injected into pod''s environment variables, matching the syntax of Docker links. Optional: Defaults to true.' type: boolean ephemeralContainers: - description: List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is alpha-level and is only honored by servers that enable the EphemeralContainers feature. + description: List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate. type: array items: - description: An EphemeralContainer is a container that may be added temporarily to an existing pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a pod is removed or restarted. If an ephemeral container causes a pod to exceed its resource allocation, the pod may be evicted. Ephemeral containers may not be added by directly updating the pod spec. They must be added via the pod's ephemeralcontainers subresource, and they will appear in the pod spec once added. This is an alpha feature enabled by the EphemeralContainers feature flag. + description: "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation. \n To add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted. \n This is a beta feature available on clusters that haven't disabled the EphemeralContainers feature gate." type: object required: - name @@ -2070,7 +2109,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2116,7 +2155,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2131,11 +2170,11 @@ spec: - type: string x-kubernetes-int-or-string: true preStop: - description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod''s termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' + description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod''s termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2181,7 +2220,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2200,7 +2239,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2212,6 +2251,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -2262,7 +2314,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -2314,12 +2366,16 @@ spec: description: Protocol for port. Must be UDP, TCP, or SCTP. Defaults to "TCP". type: string default: TCP + x-kubernetes-list-map-keys: + - containerPort + - protocol + x-kubernetes-list-type: map readinessProbe: description: Probes are not allowed for ephemeral containers. type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2331,6 +2387,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -2381,7 +2450,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -2430,10 +2499,10 @@ spec: type: object properties: allowPrivilegeEscalation: - description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN' + description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.' type: boolean capabilities: - description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. + description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. type: object properties: add: @@ -2449,27 +2518,27 @@ spec: description: Capability represent POSIX capabilities type type: string privileged: - description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. type: boolean procMount: - description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. + description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. type: string readOnlyRootFilesystem: - description: Whether this container has a read-only root filesystem. Default is false. + description: Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. type: boolean runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -2485,7 +2554,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. + description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -2497,7 +2566,7 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -2517,7 +2586,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2529,6 +2598,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -2579,7 +2661,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -2608,7 +2690,7 @@ spec: description: Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false type: boolean targetContainerName: - description: If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container is run in whatever namespaces are shared for the pod. Note that the container runtime must support this feature. + description: "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec. \n The container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined." type: string terminationMessagePath: description: 'Optional: Path at which the file to which the container''s termination message will be written is mounted into the container''s filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.' @@ -2636,7 +2718,7 @@ spec: description: name must match the name of a persistentVolumeClaim in the pod type: string volumeMounts: - description: Pod volumes to mount into the container's filesystem. Cannot be updated. + description: Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated. type: array items: description: VolumeMount describes a mounting of a Volume within a container. @@ -2847,7 +2929,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2893,7 +2975,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2908,11 +2990,11 @@ spec: - type: string x-kubernetes-int-or-string: true preStop: - description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod''s termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' + description: 'PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod''s termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod''s termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks' type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2958,7 +3040,7 @@ spec: description: Scheme to use for connecting to the host. Defaults to HTTP. type: string tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. type: object required: - port @@ -2977,7 +3059,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -2989,6 +3071,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -3039,7 +3134,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -3100,7 +3195,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -3112,6 +3207,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -3162,7 +3270,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -3211,10 +3319,10 @@ spec: type: object properties: allowPrivilegeEscalation: - description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN' + description: 'AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.' type: boolean capabilities: - description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. + description: The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. type: object properties: add: @@ -3230,27 +3338,27 @@ spec: description: Capability represent POSIX capabilities type type: string privileged: - description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + description: Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. type: boolean procMount: - description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. + description: procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. type: string readOnlyRootFilesystem: - description: Whether this container has a read-only root filesystem. Default is false. + description: Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. type: boolean runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -3266,7 +3374,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. + description: The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -3278,7 +3386,7 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -3298,7 +3406,7 @@ spec: type: object properties: exec: - description: One and only one of the following should be specified. Exec specifies the action to take. + description: Exec specifies the action to take. type: object properties: command: @@ -3310,6 +3418,19 @@ spec: description: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. type: integer format: int32 + grpc: + description: GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate. + type: object + required: + - port + properties: + port: + description: Port number of the gRPC service. Number must be in the range 1 to 65535. + type: integer + format: int32 + service: + description: "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). \n If this is not specified, the default behavior is defined by gRPC." + type: string httpGet: description: HTTPGet specifies the http request to perform. type: object @@ -3360,7 +3481,7 @@ spec: type: integer format: int32 tcpSocket: - description: 'TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook' + description: TCPSocket specifies an action involving a TCP port. type: object required: - port @@ -3453,6 +3574,15 @@ spec: additionalProperties: type: string x-kubernetes-map-type: atomic + os: + description: "Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set. \n If the OS field is set to linux, the following fields must be unset: -securityContext.windowsOptions \n If the OS field is set to windows, following fields must be unset: - spec.hostPID - spec.hostIPC - spec.securityContext.seLinuxOptions - spec.securityContext.seccompProfile - spec.securityContext.fsGroup - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls - spec.shareProcessNamespace - spec.securityContext.runAsUser - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups - spec.containers[*].securityContext.seLinuxOptions - spec.containers[*].securityContext.seccompProfile - spec.containers[*].securityContext.capabilities - spec.containers[*].securityContext.readOnlyRootFilesystem - spec.containers[*].securityContext.privileged - spec.containers[*].securityContext.allowPrivilegeEscalation - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser - spec.containers[*].securityContext.runAsGroup This is an alpha field and requires the IdentifyPodOS feature" + type: object + required: + - name + properties: + name: + description: 'Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null' + type: string overhead: description: 'Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md This field is beta-level as of Kubernetes v1.18, and is only honored by servers that enable the PodOverhead feature.' type: object @@ -3498,25 +3628,25 @@ spec: type: object properties: fsGroup: - description: "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: \n 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- \n If unset, the Kubelet will not modify the ownership and permissions of any volume." + description: "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: \n 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- \n If unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows." type: integer format: int64 fsGroupChangePolicy: - description: 'fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used.' + description: 'fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used. Note that this field cannot be set when spec.os.name is windows.' type: string runAsGroup: - description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + description: The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 runAsNonRoot: description: Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. type: boolean runAsUser: - description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + description: The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. type: integer format: int64 seLinuxOptions: - description: The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + description: The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. type: object properties: level: @@ -3532,7 +3662,7 @@ spec: description: User is a SELinux user label that applies to the container. type: string seccompProfile: - description: The seccomp options to use by the containers in this pod. + description: The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows. type: object required: - type @@ -3544,13 +3674,13 @@ spec: description: "type indicates which kind of seccomp profile will be applied. Valid options are: \n Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied." type: string supplementalGroups: - description: A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. + description: A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows. type: array items: type: integer format: int64 sysctls: - description: Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. + description: Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows. type: array items: description: Sysctl defines a kernel parameter to be set @@ -3566,7 +3696,7 @@ spec: description: Value of a property to set type: string windowsOptions: - description: The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + description: The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. type: object properties: gmsaCredentialSpec: @@ -3672,7 +3802,7 @@ spec: description: TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a "bucket", and try to put balanced number of pods into each bucket. It's a required field. type: string whenUnsatisfiable: - description: 'WhenUnsatisfiable indicates how to deal with a pod if it doesn''t satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered "Unsatisfiable" for an incoming pod if and only if every possible node assigment for that pod would violate "MaxSkew" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won''t make it *more* imbalanced. It''s a required field.' + description: 'WhenUnsatisfiable indicates how to deal with a pod if it doesn''t satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered "Unsatisfiable" for an incoming pod if and only if every possible node assignment for that pod would violate "MaxSkew" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won''t make it *more* imbalanced. It''s a required field.' type: string x-kubernetes-list-map-keys: - topologyKey @@ -3930,7 +4060,7 @@ spec: - type: string x-kubernetes-int-or-string: true ephemeral: - description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time. \n This is a beta feature and only available when the GenericEphemeralVolume feature gate is enabled." + description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time." type: object properties: volumeClaimTemplate: @@ -3968,7 +4098,7 @@ spec: description: Name is the name of resource being referenced type: string dataSourceRef: - description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' + description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' type: object required: - kind @@ -3984,7 +4114,7 @@ spec: description: Name is the name of resource being referenced type: string resources: - description: 'Resources represents the minimum resources the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' + description: 'Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' type: object properties: limits: @@ -4632,7 +4762,7 @@ spec: items: type: string verbs: - description: Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + description: Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. type: array items: type: string @@ -4689,7 +4819,7 @@ spec: nativeAPIs: type: array items: - description: GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling + description: GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling type: object required: - group @@ -4761,7 +4891,6 @@ spec: items: type: string version: - description: OperatorVersion is a wrapper around semver.Version which supports correct marshaling to YAML and JSON. type: string webhookdefinitions: type: array diff --git a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_installplans.yaml b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_installplans.yaml index 616f51ba0d..8e9b85e371 100644 --- a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_installplans.yaml +++ b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_installplans.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: installplans.operators.coreos.com spec: @@ -222,6 +222,8 @@ spec: - resource - status properties: + optional: + type: boolean resolving: type: string resource: diff --git a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_olmconfigs.yaml b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_olmconfigs.yaml index 58c07d034a..44dfcd937e 100644 --- a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_olmconfigs.yaml +++ b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_olmconfigs.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: olmconfigs.operators.coreos.com spec: @@ -50,7 +50,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operatorconditions.yaml b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operatorconditions.yaml index eb9a6d5a79..aa6bd41955 100644 --- a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operatorconditions.yaml +++ b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operatorconditions.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: operatorconditions.operators.coreos.com spec: @@ -45,7 +45,7 @@ spec: overrides: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - message @@ -95,7 +95,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime @@ -162,7 +162,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime @@ -209,7 +209,7 @@ spec: overrides: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - message @@ -259,7 +259,7 @@ spec: conditions: type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operatorgroups.yaml b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operatorgroups.yaml index e59131ac3a..56ef0b5c4f 100644 --- a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operatorgroups.yaml +++ b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operatorgroups.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: operatorgroups.operators.coreos.com spec: @@ -90,7 +90,7 @@ spec: description: Conditions is an array of the OperatorGroup's conditions. type: array items: - description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime diff --git a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operators.yaml b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operators.yaml index ef206c5e7a..e7dce32925 100644 --- a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operators.yaml +++ b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_operators.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: operators.operators.coreos.com spec: diff --git a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_subscriptions.yaml b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_subscriptions.yaml index f4070f0878..5a67668800 100644 --- a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_subscriptions.yaml +++ b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_subscriptions.yaml @@ -2,7 +2,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.6.2 + controller-gen.kubebuilder.io/version: v0.8.0 creationTimestamp: null name: subscriptions.operators.coreos.com spec: @@ -533,7 +533,7 @@ spec: - type: string x-kubernetes-int-or-string: true ephemeral: - description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time. \n This is a beta feature and only available when the GenericEphemeralVolume feature gate is enabled." + description: "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. \n Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). \n Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. \n Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. \n A pod can use both types of ephemeral volumes and persistent volumes at the same time." type: object properties: volumeClaimTemplate: @@ -571,7 +571,7 @@ spec: description: Name is the name of resource being referenced type: string dataSourceRef: - description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' + description: 'Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.' type: object required: - kind @@ -587,7 +587,7 @@ spec: description: Name is the name of resource being referenced type: string resources: - description: 'Resources represents the minimum resources the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' + description: 'Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources' type: object properties: limits: diff --git a/vendor/github.com/operator-framework/api/crds/zz_defs.go b/vendor/github.com/operator-framework/api/crds/zz_defs.go index fc6f90c368..31a7d8bb5e 100644 --- a/vendor/github.com/operator-framework/api/crds/zz_defs.go +++ b/vendor/github.com/operator-framework/api/crds/zz_defs.go @@ -85,7 +85,7 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _operatorsCoreosCom_catalogsourcesYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x3b\x6b\x73\xdc\x36\x92\xdf\xfd\x2b\xba\x74\x57\x65\x29\x37\x43\x59\xce\x96\x6f\x77\x2e\x4e\x4a\x91\xed\x9c\x2a\xb1\xad\xb2\x6c\x5f\xdd\x5a\xbe\x5b\x0c\xd9\xc3\x41\x04\x02\x34\x00\x4a\x9a\x6c\xe5\xbf\x6f\x75\x03\x20\x39\x2f\xce\x48\x71\xe6\x8b\x45\x3c\x1a\xfd\x7e\x01\x16\xb5\xfc\x88\xd6\x49\xa3\x27\x20\x6a\x89\x77\x1e\x35\x7d\xb9\xec\xfa\xaf\x2e\x93\xe6\xf8\xe6\xe4\xd1\xb5\xd4\xc5\x04\xce\x1a\xe7\x4d\xf5\x0e\x9d\x69\x6c\x8e\x2f\x70\x26\xb5\xf4\xd2\xe8\x47\x15\x7a\x51\x08\x2f\x26\x8f\x00\x84\xd6\xc6\x0b\x1a\x76\xf4\x09\x90\x1b\xed\xad\x51\x0a\xed\xb8\x44\x9d\x5d\x37\x53\x9c\x36\x52\x15\x68\x19\x78\x3a\xfa\xe6\x49\xf6\x2c\x7b\xfa\x08\x20\xb7\xc8\xdb\xdf\xcb\x0a\x9d\x17\x55\x3d\x01\xdd\x28\xf5\x08\x40\x8b\x0a\x27\x90\x0b\x2f\x94\x29\x03\x12\x2e\x33\x35\x5a\xe1\x8d\x75\x59\x6e\x2c\x1a\xfa\xa7\x7a\xe4\x6a\xcc\xe9\xf4\xd2\x9a\xa6\x9e\xc0\xc6\x35\x01\x5e\x42\x52\x78\x2c\x8d\x95\xe9\x1b\x60\x0c\x46\x55\xfc\x77\x24\x3e\x1c\x7b\xc9\xc7\xf2\xb8\x92\xce\xff\xbc\x3e\xf7\x8b\x74\x9e\xe7\x6b\xd5\x58\xa1\x56\x11\xe6\x29\x37\x37\xd6\xbf\xe9\x8e\xa7\xe3\x72\xe1\x9d\xcd\xc3\xb4\xd4\x65\xa3\x84\x5d\xd9\xfb\x08\xc0\xe5\xa6\xc6\x09\xf0\xd6\x5a\xe4\x58\x3c\x02\x88\x2c\x8c\xa0\xc6\x20\x8a\x82\xc5\x22\xd4\x85\x95\xda\xa3\x3d\x33\xaa\xa9\x74\x7b\x14\xad\x29\xd0\xe5\x56\xd6\x9e\x59\xff\x7e\x8e\x50\x5b\xf4\x7e\xc1\x2c\x01\x33\x03\x3f\xc7\x74\x76\xbb\x0b\xe0\x57\x67\xf4\x85\xf0\xf3\x09\x64\xc4\xe1\xac\x90\xae\x56\x62\x41\xd8\xf4\x56\x05\x31\xbd\x08\x73\xbd\x71\xbf\x20\xd4\x9d\xb7\x52\x97\x43\xa8\xd0\xba\xfd\x71\x08\xac\x79\xbf\xa8\xd7\x51\x58\x19\xdc\xf7\xfc\xba\x99\x2a\xe9\xe6\x68\xf7\x47\xa2\xdd\xb2\x86\xc3\xc5\x86\x99\x2d\x88\xf4\x80\x26\x83\xca\xd6\x8c\x61\xed\x80\xd3\x72\x9d\xc6\x42\xf8\x34\x18\x16\xdd\x9c\x08\x55\xcf\xc5\x49\x1c\x74\xf9\x1c\x2b\xd1\xe9\x83\xa9\x51\x9f\x5e\x9c\x7f\xfc\xf6\x72\x65\x02\x96\xb9\xb3\xa4\xe7\x20\x1d\x08\xb0\x58\x1b\x27\xbd\xb1\x0b\xe2\xd6\xd9\xe5\x47\x37\x82\xb3\x77\x2f\xdc\x08\x84\x2e\x5a\xc3\x83\x5a\xe4\xd7\xa2\x44\x97\xad\xe1\x6a\xa6\xbf\x62\xee\x7b\xc3\x16\xbf\x34\xd2\x62\xd1\xc7\x82\xd8\x93\x78\xb2\x32\x4c\xfc\xef\x0d\xd5\x96\xce\xf4\x3d\x43\x0e\xbf\x9e\x97\x5b\x1a\x5f\xa1\xf0\x31\xb1\x21\xac\x83\x82\x1c\x1c\x3a\x56\x81\x68\x63\x58\x44\xde\x05\xd5\x90\x8e\xe8\xb7\xe8\x50\x07\x97\x47\xc3\x42\x47\x9a\x32\xb8\x44\x4b\x1b\xc9\xdc\x1b\x55\x90\x27\xbc\x41\xeb\xc1\x62\x6e\x4a\x2d\x7f\x6b\xa1\x39\xf0\x86\x8f\x51\xc2\xa3\xf3\xc0\x56\xab\x85\x82\x1b\xa1\x1a\x0c\xac\xac\xc4\x02\x2c\x12\x5c\x68\x74\x0f\x02\x2f\x71\x19\xbc\x36\x16\x41\xea\x99\x99\xc0\xdc\xfb\xda\x4d\x8e\x8f\x4b\xe9\x93\x0f\xcf\x4d\x55\x35\x5a\xfa\xc5\x31\xbb\x63\x39\x6d\xc8\x1d\x1e\x17\x78\x83\xea\xd8\xc9\x72\x2c\x6c\x3e\x97\x1e\x73\xdf\x58\x3c\x16\xb5\x1c\x33\xb2\x9a\xfd\x78\x56\x15\xff\x66\xa3\xd7\x77\x8f\x57\xd8\xb7\x51\x99\x21\xb9\xcd\x41\x5e\x93\xf3\x0c\x5a\x14\xb6\x07\x5a\x3a\x96\xd2\x10\x71\xe5\xdd\xcb\xcb\xf7\x90\x10\x08\x6c\x0f\x1c\xee\x96\xba\x8e\xd9\xc4\x28\xa9\x67\x68\xc3\xca\x99\x35\x15\x43\x41\x5d\xd4\x46\x6a\x1f\x4c\x5a\x49\xd4\x1e\x5c\x33\xad\xa4\x77\xac\x73\xe8\x3c\xc9\x21\x83\x33\x0e\x61\x30\x45\x68\x6a\xb2\xa4\x22\x83\x73\x0d\x67\xa2\x42\x75\x26\x1c\xfe\xe9\xac\x26\x8e\xba\x31\xb1\x6f\x7f\x66\xf7\x23\xf0\xfa\x86\x35\x1b\x03\x48\x11\x72\xaf\xc5\xdb\x8c\x12\x82\x05\x6e\xf2\xc0\x30\x60\x8b\xf4\x13\x45\x61\xd1\x6d\x98\x58\x33\xc8\xb0\x30\xe8\xc9\xdc\x38\x92\x9f\xf0\xf0\xf6\x97\xd7\x90\x0b\x0d\x8d\x43\x32\x9e\xdc\x68\x4d\x0a\xe1\x0d\x08\x8a\x65\x63\xbc\x93\x8e\x15\xc8\x62\x29\x9d\xb7\x8b\x0c\x5e\x19\x5b\x09\x3f\x81\xef\xd2\xd0\x98\xc1\x19\x0b\xb2\xfe\x7e\xf2\x5d\x6d\xac\xff\x1e\xde\x6a\xb5\x20\xa0\x05\xdc\xce\x51\xc3\x65\x4b\x1b\x3c\xef\x7d\xfc\x64\xeb\x3c\x83\xf3\x52\x1b\x9b\x56\x92\x56\x9d\x57\xa2\x44\x98\x49\x54\xac\xd7\x0e\x7d\xb6\x2a\xc1\x41\x29\x42\x48\x97\x66\xb2\x7c\x2d\xea\x9d\xac\x39\x4b\x2b\xe9\x2c\x3a\xbe\x1f\xbc\xbb\x49\x6f\x58\x95\x89\x24\xfa\x53\xe4\xd7\x20\xe2\x29\x95\xa8\xc7\x8e\xcd\xa6\xc7\xa6\xfd\x38\x70\x96\x00\x10\xff\xba\xe1\xf3\xe8\xb9\xb2\xfb\x92\xdd\xa7\xec\xde\x7b\xbb\x34\x64\x27\xd3\x5e\x6f\x8a\x22\x7b\x9c\x51\xda\x3a\xbf\x30\x45\x20\x7b\xe7\x29\x3f\xf5\x57\x03\xde\xd5\xc6\xa1\x83\x42\xce\x66\x68\xc9\xef\x98\x1b\xb4\x56\x16\xe8\x60\x66\x2c\xcb\xab\x36\x05\xdb\x64\x2b\xbf\xa5\x50\x7b\x61\x8a\x7d\x05\x43\x47\x73\xc0\x08\xca\x18\xd5\x70\x2b\xb9\x1b\xad\x1d\x76\x18\x2f\xfd\xb4\x29\xf0\x12\x15\xe6\xde\xd8\xcd\x2b\x56\x78\xf2\xa6\xb7\x21\x7a\xfd\xf4\x75\x3b\x97\xf9\x1c\xaa\xc6\xb1\xd7\xf5\xb6\xc1\x25\xbe\x78\x03\x33\xe9\xc1\x68\x10\x7c\x2c\xf9\xfa\xf5\x9d\x95\xf0\xf9\x3c\xae\x78\xec\x40\x89\x29\x2a\xb7\x0a\x67\x8a\x1c\x72\x8b\x46\x61\x41\x00\xd9\x97\x30\xcc\x2d\x24\xec\xe0\x12\x04\x57\xd6\xe6\xdb\xc3\x3c\x83\x5d\x5a\x16\x18\x2f\x8d\x95\x7e\x71\xa6\x84\x73\xdb\x74\x7a\x8d\xbb\xe7\x33\x56\x1f\x39\x93\x58\x8c\x40\xea\x42\x52\x49\xe3\x12\xed\x8f\x5d\x0b\x37\xa3\xb5\x14\xe0\x7a\xeb\x13\x87\xd2\x1a\xb8\x95\x4a\x11\xb3\x0a\x9c\x89\x46\xb1\x93\xfc\x0d\xad\x01\xc9\xda\x69\x59\xaf\xb4\x49\xd3\xc3\xcc\x1b\xa0\xd5\x1b\x45\x09\x62\x57\xbd\xec\xa0\xf2\x7d\xb7\x1e\x84\xc5\x7e\x76\x1e\xc3\x10\x11\xca\xe4\xf6\x40\x0f\xa3\x27\xac\x5d\x2a\x53\xfa\x3f\xe9\xb1\x1a\x90\xe5\x7a\xe9\x40\x5a\x46\x59\x47\x87\x28\xab\xba\xf7\x82\xb4\x8e\xd3\xbc\x30\x83\x0e\x84\x5e\x80\x17\x21\x23\x11\x51\x7f\xa3\xc4\xbc\x95\xb5\x42\xf8\xee\x1a\x17\xa3\x90\x03\xe2\x6c\x86\xb9\xff\x1e\x1a\x97\xb2\x22\x5e\x4f\x1f\x6d\x92\xfd\x5d\xfa\xeb\xfb\x6d\x14\xef\xa5\xcf\xbb\x6d\x3f\xfc\x02\x4a\x43\x2b\x56\x38\xf4\x92\x37\xac\x28\x67\xe0\x40\x80\x45\xfc\x61\xb2\x32\x78\x59\xd5\x7e\x01\x15\x0a\xed\x92\x65\x2b\xb5\xb4\xd8\x65\xf0\x3f\xe4\x07\x7b\x6a\x2c\x94\x32\xb7\x6d\x4e\xcc\x1a\xf2\xc6\x5c\x46\x7b\x1f\xc1\x85\xc5\x19\xda\x6e\x84\xdd\xe4\x1b\xf3\xf2\x0e\xf3\xc6\x6f\xf5\x00\x7d\xbe\x0d\xa8\x72\xf8\x5d\xe3\xe2\x1e\x0c\xf9\x19\x17\x29\x76\x07\xca\xae\x71\x11\x94\x81\x87\x3a\x1d\x12\x75\xad\x24\x86\xf4\x74\x88\x33\xd7\xb8\x70\x6c\xdf\xb4\xff\x3a\x40\x47\x5a\x3f\xea\xb4\x24\xb9\xd9\x97\x94\x21\xb9\xff\x0a\xfa\x9a\x9b\x6a\x2a\x75\x38\x2c\x80\x4e\xa2\x60\xe8\x89\xa1\xba\xe0\x4f\x3e\xe6\x6b\xb0\x2b\x21\x75\x0f\x9e\xbd\x4d\x74\x74\xb9\x3f\x08\xc2\xe8\x31\xa5\xf1\x2a\x58\xfc\x5c\xd6\xa9\xa4\x62\xd4\x33\xf8\x28\x94\xec\xea\xd1\xa0\x1b\x81\x03\x4c\xd5\xcb\x2f\x8d\x50\x19\xbc\x08\xfe\x8c\xa9\x8f\x43\x71\x11\x31\xf2\x4b\x23\x6f\x84\xa2\xf8\xed\x0d\x79\xc8\x22\x17\xb6\xe0\x08\x13\xeb\x34\x67\x82\xf4\x04\x3b\x02\x4a\x4f\x93\xb5\x77\x32\x72\x5c\x23\x42\x2d\xac\x97\x79\xa3\x84\x4d\xbd\xa7\xc5\x57\xe1\x68\xa7\x34\x97\x98\x1b\x5d\x0c\x5a\xf0\x56\xef\x1a\xf7\xf6\x79\xcc\x21\x02\xad\x34\x05\xa7\x28\xb2\xc2\x55\x25\x3d\x5c\x0e\xe3\x66\x96\xac\xba\x35\xb1\x11\x18\x8a\x1e\xb7\xd2\xc5\x32\xae\x4d\x95\x65\x48\xa5\x8f\x7a\xee\xb1\xb5\x8a\x0c\x7e\x5c\xa4\x48\x33\x02\xe9\x43\xec\xf1\x94\xd7\x8c\x52\x02\x10\x55\x36\x32\xbb\x33\xa8\x99\xb1\x48\xe9\xed\x61\x61\x78\x0f\xde\xc8\xdc\x1f\x65\xf0\x77\x0a\x66\x24\x78\x8d\xa5\xf0\xf2\x06\x93\x8a\xa7\xc0\xe7\x2d\x52\xe9\x07\xc2\xc1\x13\x38\xe4\x6d\x20\xab\x0a\x0b\x29\x3c\xaa\xc5\x11\x4c\x17\x7c\x8c\x5b\x38\x8f\xd5\x3e\xa2\xa3\xa2\xbe\x5c\xea\x03\xad\xff\x66\xb1\x44\x91\xda\x3f\xfb\xcb\xc0\x4a\x46\xf6\x1e\x92\xfd\xc8\x85\xf5\x92\xab\x09\xb5\xf6\x8a\x08\xdb\x18\x64\x5a\x2f\xd2\xfa\x0d\xe9\xa2\x2d\x8c\x3a\xbb\x4a\x9d\x8d\x29\xb6\x6e\xa6\x15\xf0\xaf\xa4\x07\x82\x0a\x0b\xd6\xf2\xa0\xb9\x7f\x40\xc7\x65\x3e\x54\x1a\x6c\x8d\x68\xdb\x2b\x57\xe0\xea\x75\x2a\x1c\x3e\xfb\xcb\x96\x92\x20\xf4\x9d\x48\xe6\xeb\xd5\x2d\xec\x11\x28\x3b\xe0\xdb\x84\xb5\xd3\xac\xdb\xe3\x1f\x04\x41\x52\x11\xb0\xb3\x5c\x69\x4b\x05\xa1\x5b\x79\x8f\x53\x45\xc8\x0d\x7c\x21\x35\xda\x00\x8d\x9c\x9f\xd4\xce\x0b\xed\x25\x7b\xb6\xb6\x76\x4c\xb5\xe4\xad\xf4\xf3\xfb\x94\x2b\xac\x6b\xd1\xd1\x04\xe5\x8a\xdd\x81\x35\xff\x70\xef\xb2\x32\x25\xb4\xbb\xfb\x0c\x17\x29\xf5\x0d\x67\x0a\xe7\x64\x49\x59\x26\xdc\xa2\x2c\xe7\x3e\x85\x93\xe5\x6c\x93\x46\xe3\x11\xf2\x37\xb6\xa6\xaa\x0d\x02\xd2\x73\x04\x98\x22\x31\xd0\x35\x15\x16\xc9\x67\x14\x58\xa3\x2e\x50\xe7\x0b\xee\x6a\xa9\x1b\xb4\x19\x7c\x70\x24\x29\xf8\x6f\x59\xce\x89\x85\xe1\xd0\x7e\xaa\xc4\x59\x01\x85\xea\x65\x0c\x24\x65\xf6\x94\xd7\x58\xaa\x68\x88\xfd\x94\x03\x25\x08\x58\xac\xac\x77\x50\x34\xdc\x6b\x5b\x45\xa2\x21\x3e\x64\x9c\xc5\x5a\xa1\xcb\xb6\x91\xd0\x96\x04\xc1\xe0\x89\xa4\xd2\x84\xae\x1a\x77\x7e\xc9\x77\x7a\xd3\xf9\x51\x19\x5a\x21\x2d\x0c\xa9\xfd\xb7\x4f\x03\xdc\x54\x4c\x44\xd7\x63\x40\xac\x12\x43\x9a\x03\x8d\x0e\xcc\xc7\x7e\x3d\x92\xdc\xcc\x93\x00\x6a\xd3\x3e\x76\xc7\xa2\x5a\x45\xb9\xf3\xe9\x56\xe8\x6b\x2c\x40\xe1\x9d\xcc\x4d\x69\x45\x3d\x97\xb9\x50\x6a\xc1\x66\xca\xe5\xa0\xf4\x8e\xbb\x28\x03\x6d\x9b\x6d\x6e\xbc\xbd\x02\xb8\x77\xfb\xc2\x61\x6e\xd1\xef\x6e\x85\x5d\x86\x75\x5d\x50\xa6\x08\x48\x2c\x8e\x00\x82\x8e\x44\x9d\x4b\xfd\x1e\x91\xe7\x64\x48\xac\xba\x46\x7b\x8c\x09\x48\x4f\x95\x33\x38\xe7\x90\x3a\x45\xc7\x5a\x7e\x8d\x58\x07\x4d\x53\xd2\x79\x70\x95\x50\x6a\x04\x4e\xea\x1c\x01\x45\x3e\x0f\xec\xd4\x88\xa9\xa0\xf6\x56\x62\x48\x83\x28\xd4\x2e\x5a\xd9\xa0\xf6\x9b\x93\x9a\xe1\xba\x6b\xa0\xe6\x1a\x66\x63\xeb\x53\x76\x73\xb2\xf3\x45\x29\x26\xc6\x3b\x27\xd7\x5d\xef\xdd\xe3\xe8\xd0\x27\xbe\xf4\x94\x7c\x94\xbb\x7d\xcd\x87\xa5\xe5\xed\x3d\xc3\xdc\xdc\xa6\x8e\xf3\x9a\x91\x93\xe3\x75\x49\xb6\x85\x74\x39\x59\x3a\x16\x70\x66\xb4\xe3\xfc\x34\x5c\x3c\xf0\xc5\xc1\x8d\x50\x41\x15\x12\xe0\xda\x28\xc5\x26\xdf\xa4\x72\x82\xf2\x78\x0d\x58\x4d\xb1\x28\xb0\x20\xb2\x02\x2a\x5b\xc2\xdc\x1f\x6c\x15\xa5\xf8\x70\x61\x94\x1a\x8e\x62\x83\x75\xe9\x3e\x55\x69\x62\xc0\x50\x6e\xb4\x1c\xfa\x12\xc7\xa4\x6b\x6d\xa6\x40\x8f\xb6\x92\x3a\xa6\x47\x94\xea\xb6\x8c\x9d\xa2\xbf\x45\xd4\x90\xcf\x31\xbf\x6e\x4d\x29\xde\xdb\xac\x48\x2d\x5e\x1a\x2d\x7b\xac\xee\x4a\xcc\x28\xc5\x85\x86\x43\x04\x49\x35\x81\xc6\xdb\xb4\x67\xc5\x46\x7b\xce\x5e\xdc\x08\xa9\xc4\x54\x21\x47\xcd\xf6\x6b\xb4\x74\x7f\x94\xe2\x79\xdd\x28\x45\x49\xac\x2e\xa0\x7c\x77\x71\x06\xde\x8a\xd9\x4c\xe6\x34\x55\x48\x8b\xb9\x8f\x3d\x89\x6d\x24\x0c\xa5\x6b\x5b\x2d\xc2\x79\xe1\x9b\x35\x19\x0d\x08\x78\x48\xb0\x54\x87\xc8\xad\x0d\xa2\x25\x51\xbe\x5b\x2e\x56\x08\x0d\x0c\xc5\xd6\x52\x33\x35\x83\x37\x86\x6b\x04\xe1\xe1\x35\x3a\x0a\xbb\xcc\xa0\x77\x28\x9c\xd1\x3d\xef\xca\xd9\xaf\x95\xa5\xd4\x42\x45\xa2\xf8\xd6\x87\x52\x74\x69\x74\x5b\x7b\x88\x05\x19\x65\x25\x4b\x2b\x7c\xeb\x14\x3b\xbc\x63\x74\x89\x71\x71\xd6\xf8\xc6\x62\x06\xa7\x7a\xc1\xf2\x9e\xa1\xa0\x01\x82\xec\xad\x29\x9a\x9c\xf2\x25\x72\xb0\x8d\xeb\x03\xf9\xaa\x6e\x74\x89\x6b\x07\x67\xe9\x90\x94\xe8\x39\x32\x00\x21\x63\xf3\xd4\x68\x04\xe1\x6a\xaa\xe3\x92\x4e\x36\x96\x9b\xd8\x2d\x83\x39\x58\x9c\x5e\x9c\x43\x7a\x1a\x92\xc1\x78\x3c\x86\xf7\x34\xec\xbc\x6d\x72\x8e\x2f\x64\x42\xba\x88\x91\x22\x68\x1f\x13\x29\x38\xed\x64\x32\x20\x76\x3e\x42\x0a\x56\x0b\x3f\x87\x2c\x30\x3e\xeb\xb1\x02\xe0\x15\xc5\x9a\x3b\x51\xd5\xac\xf7\xe4\xba\x5f\x19\x73\x19\x24\x14\x0e\xfc\x27\x13\x7a\x7c\xbc\xaa\x14\x66\x4a\x39\x6a\xec\x20\xb2\x6e\xcc\x8c\x79\xec\x96\x69\xca\xd2\xe6\x9f\xb5\xb9\xd5\x9b\x50\xe0\x33\x85\xc5\x09\x5c\x1d\x9c\x26\x13\xbc\x3a\x18\xc1\xd5\xc1\x85\x35\x25\xe5\xae\x52\x97\x34\x40\x9a\x75\x75\xf0\x02\x4b\x2b\x0a\x2c\xae\x0e\x12\xe8\xff\xa8\xa9\xd4\x7a\x8d\xb6\xc4\x9f\x71\xf1\x9c\x01\x2e\x4d\xa5\xf0\xf0\xbc\xa2\x35\xed\x1c\xc5\x64\x0a\x5c\xcf\x2b\x51\x2f\x0d\xbe\x16\xf5\x12\xa0\xb3\x4e\x01\x3f\x7d\xae\xd0\x8b\x9b\x93\xac\x13\xf5\x3f\x7e\x75\x46\x4f\xae\x0e\x3a\x9a\x46\xa6\x22\x95\xa9\xfd\xe2\xea\x00\x96\x30\x98\x5c\x1d\x30\x0e\x69\x3c\x21\x3d\xb9\x3a\xa0\xd3\x68\xd8\x1a\x6f\xa6\xcd\x6c\x72\x75\x30\x5d\x78\x74\xa3\x93\x91\xc5\x7a\x44\x99\xd4\xf3\xee\x84\xab\x83\x7f\xc0\x95\x4e\x48\x73\xa1\x18\x24\xed\xe0\xf7\x83\x81\x78\x3f\x10\x14\x86\x8b\x3b\xaa\xde\x94\x70\xfe\xbd\x15\xda\xc9\xf4\x8c\x62\xeb\xd2\x2a\x38\x83\xad\xf3\x96\x1d\xc4\xd6\xe9\xa0\x25\x5b\xa7\xb7\x84\xd6\x7d\xc2\xda\x3a\x0d\x7b\xb6\xa4\xd7\x37\xa6\x7c\x87\x66\xba\x26\x4e\x2b\x23\x0a\x10\x71\x35\x19\x2a\x25\xf9\x64\xff\xd1\xf9\x51\x3a\xa9\x59\x6e\x59\x34\xee\xb6\xfa\x6f\xaf\x40\x1b\x5d\xa0\x55\x0b\x4a\x37\x3a\xa8\xf9\x9c\xaa\x81\x22\x83\xd0\x54\x10\x6d\x0b\xe7\x9a\x0c\x8c\x43\x97\xee\x75\xb6\x19\xaf\x16\x22\x39\x96\xe0\x10\x22\x18\x8e\x82\x79\x8e\xb5\xe7\x30\xf8\xf0\x9b\x16\xe8\x75\x5c\x28\xed\x1a\xfb\xed\xea\x11\x95\x63\x4f\xc6\xc7\xd5\xf1\xd2\xba\xa9\x04\xc5\x15\x51\x10\xbe\xdd\x5c\xa8\xed\x42\x2d\x16\xfc\xad\x98\x9a\x26\xf6\x7e\x5b\x39\x44\x56\xc7\x28\xc3\x59\x5b\xed\x17\x3b\xdb\x29\x7b\x11\x5f\x89\xbb\x5f\x50\x97\x7e\x3e\x81\x6f\x9f\xfe\xe7\xb3\xbf\x6e\x59\x18\x9c\x26\x16\x3f\xa1\x8e\x8d\xa2\x3d\xd9\xb0\xbe\x71\xb5\xa3\xd8\xbd\x74\x2a\xbb\x35\x6d\x07\xbc\xd3\xa0\x5b\xc1\xf7\x98\x31\x96\x36\x35\xf1\x85\xa2\x40\x68\x44\xe4\x38\xa2\x0c\x6a\x23\x30\xd9\x3a\x77\xb5\x80\x93\xa7\x23\x98\x46\x16\xaf\xbb\xf5\x4f\x77\x9f\xb3\x0d\x28\x4b\x07\x7f\x1b\xad\xe0\x23\x1d\x90\xa8\xcc\x8c\x15\x27\xd4\x9f\x16\x43\x98\x4c\x9d\x82\xf5\x30\x89\x2d\xbe\xbb\x04\xb7\xab\x59\xb8\x5f\xa3\xb0\x92\x5a\x56\x4d\x35\x81\x27\x5b\x96\x04\x97\xb6\xa7\x34\xc3\xe2\x2e\x4b\x10\xe4\xba\x4a\x2b\x2a\xca\x87\x72\x90\x05\x6a\x2f\x67\x12\x6d\x5f\xb5\xb9\x17\x10\x36\xa6\xab\xd8\x96\x8b\x7c\x4b\x4b\x7e\xa8\xa7\xec\x17\x21\x09\xb2\x1c\x9d\xe3\xd5\x4e\xde\x77\x50\x8b\x1a\x83\x35\x84\xea\x06\xf0\xae\x0e\x79\x6c\xef\x8e\xa2\x42\xa1\xa5\x2e\xd3\xed\x6f\x6a\x34\x87\x68\x7c\x3b\x47\x0e\x3d\x6d\x13\x33\x5c\x06\xe4\x54\x49\x15\x5c\x54\x09\x28\x1b\x61\x85\xf6\x54\xe3\x9e\x5e\x9c\x87\x04\x7e\xb5\xe1\x29\xba\x27\x41\xc9\x1a\x83\xa9\x06\x67\x45\x28\xc6\x67\x44\x6c\xb1\x5f\xcf\x54\x4f\x9e\x3c\x1d\x14\x79\xbb\x6e\xfb\xfd\x9e\xf0\x1e\xad\x9e\xc0\xff\x7d\x3a\x1d\xff\x5d\x8c\x7f\xfb\x7c\x18\xff\x78\x32\xfe\xdb\xff\x8f\x26\x9f\xbf\xe9\x7d\x7e\x3e\xfa\xe1\xdf\xb7\x40\xda\x9c\xe9\x6f\x51\x9f\x18\x44\x52\x12\x99\x24\x3a\xe2\x08\x63\x66\xf0\xde\x36\x38\x82\x57\x42\x39\x1c\xc1\x07\xcd\xa1\xe1\x0f\x32\x0d\x75\x53\x0d\x55\x82\x63\x38\xa0\x53\x37\x27\x1f\xed\x12\x46\x69\x78\x4d\x44\x77\xa8\xb6\xdd\x8f\x49\xa9\x0f\xd1\xf3\x34\xbd\xa7\x67\xfc\x56\x89\x0c\xc9\x64\x31\xfd\xcd\x72\x53\x1d\xf7\x9e\xa6\x51\xde\xfd\x5a\xe8\x05\x74\x6e\x2d\x24\xab\xab\x9a\xee\x3c\xf9\x26\x91\x5b\xe3\x5c\xfb\xb6\xce\x81\x92\xd7\x08\xa7\x5d\x51\x49\xce\x72\x8a\xb9\xe0\x44\xdd\x4e\xa5\xb7\x22\x74\x84\x53\x6e\xd9\xb5\x9b\x66\x8d\x82\x43\xaa\x65\x33\x7e\x4f\xb1\xe6\x5d\x8f\x62\x6b\x77\x2a\x95\xf4\x8b\x50\x67\xe7\x46\xcf\x94\x8c\xf5\x41\x55\x1b\xeb\x85\xf6\xb1\x09\x89\x25\xde\x81\xec\xee\xc5\xa5\x83\xc3\x42\xbb\x93\x93\xa7\xdf\x5e\x36\xd3\xc2\x54\x42\xea\x57\x95\x3f\x3e\xfa\xe1\xf0\x4b\x23\x14\x5f\x01\xbf\x11\x15\xbe\xaa\xfc\xd1\xd7\x0b\x8b\x27\xcf\xf6\xb0\xa2\xc3\x4f\xc1\x56\x3e\x1f\x7e\x1a\xc7\xbf\xbe\x49\x43\x47\x3f\x1c\x5e\x65\x83\xf3\x47\xdf\x10\x0d\x3d\x0b\xfc\xfc\x69\xdc\x99\x5f\xf6\xf9\x9b\xa3\x1f\x7a\x73\x47\x9b\x8c\xf1\x6e\x7c\xdd\x4c\xd1\x6a\xf4\xe8\xc6\x54\x0d\x8c\x2b\x51\x8f\xaf\x71\xb1\xc5\x38\xb7\xa6\xa3\xeb\x80\x02\xc7\x2a\x51\x6f\x2a\xcd\xc3\x13\xb3\x77\xc8\xcf\x9a\xf2\x8d\x4a\xfe\x07\xaf\x67\xb4\xd8\x92\x92\x85\x29\x7e\x04\xff\x80\x96\x14\xc5\x9d\xd0\x86\x1b\x4a\xa7\xf7\xd0\x96\xfd\xf2\x47\x3d\xf0\x8c\x67\xe7\x21\x2d\x9d\x0f\x86\x90\xec\x7b\xcb\x0b\xe8\xbd\xe1\x34\x72\x6b\xa5\xb5\xdc\xe0\x3c\x7f\x11\x52\x5f\x76\x3d\x9c\xce\xcd\x0d\xd5\x79\x8d\x96\x5f\x1a\x84\xf3\x17\xd1\x1f\x8d\x40\xea\x5c\x35\x05\x65\x0a\x1f\x3e\x9c\xbf\xa0\xe2\xfe\xc7\xe8\x6e\x6e\x11\x0a\xa3\x1f\x7b\x78\xfb\xe6\x97\xff\xe5\x4e\x01\xaf\x18\x85\x80\x1e\x2e\xab\x84\x92\xe1\xf1\x74\x0a\xc0\xf0\x23\x12\xac\x78\x72\x2e\xea\xb6\xb9\xc2\xee\x4e\x17\x30\x47\x55\x53\x02\x71\x8d\xe0\x1a\x1b\xb1\x23\xc0\xe1\x3a\x98\x78\x0d\xf1\xb2\xb8\x44\xcf\x4a\xae\xf8\x11\xf0\x43\x98\x16\x9f\xa5\x4a\xa3\x2f\x29\x0b\xfc\x13\xec\x83\x14\xf9\x6d\xcc\x59\xf9\x8c\x07\x18\xc3\xc0\x5b\xdc\x9d\x14\x42\x34\xa6\xb3\x40\xe9\x9f\x6e\x49\x6b\xf4\x3e\xe8\xc4\xd0\xec\xe4\x6b\xcf\x77\x3b\x9a\xd3\x6b\x6f\xbc\x96\x4b\xe7\x95\xff\x12\xc1\x8d\xd7\xf6\xe6\x74\x2e\x1c\x4c\x11\x35\xf7\x7a\x43\x6b\x10\x75\xd4\x3a\xec\xba\xb4\x4d\x3d\xf6\x66\x5c\x6c\x16\xde\x0e\xce\xed\xe6\xda\x40\xe5\xba\x44\xdb\xe9\xbd\x0b\xd5\xdb\xf9\x62\x13\x0f\x5c\xe8\x75\xf2\xab\xa2\x94\x83\xdc\x97\xb0\xed\x85\xc9\x4a\xcb\x97\x2b\x8b\xd8\xd4\x88\x75\xc6\x3a\x4a\x54\x3d\x2e\x75\x36\xbc\xe1\xab\xbe\xe5\xae\xdf\xfd\x71\x0c\x62\xbe\x44\x7b\x23\x1f\x14\xfc\x76\x19\x66\x1e\x1e\xa1\x9c\xfe\xf9\x66\x45\xa9\xd7\x83\x0f\xe1\xf6\x5f\x6e\x76\xdc\xed\x0c\x00\x70\x81\x83\x43\x8f\x5d\xef\x03\xe3\xbe\xc1\x32\x78\x93\x09\x3f\x3c\x4e\x43\xde\x58\xbe\x8f\xef\x8f\x35\xd3\x36\x51\xee\xa0\xc7\x1a\x08\xfe\xf9\xfb\xa3\x7f\x05\x00\x00\xff\xff\x53\x7d\x47\x3d\x4a\x39\x00\x00") +var _operatorsCoreosCom_catalogsourcesYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x5b\x7b\x73\xdc\x36\x92\xff\xdf\x9f\xa2\x4b\x77\x55\x96\x72\x33\x94\x95\x6c\xe5\xb2\x73\x79\x94\x22\xdb\x39\x55\x62\x47\x65\x39\xb9\xba\xb5\x7c\xb7\x18\xb2\x87\x83\x08\x04\x68\x00\x94\xc4\x6c\xed\x77\xdf\xea\x06\x40\x72\x5e\x9c\x91\xe3\xcc\x3f\x16\xf1\x68\x00\xfd\xfc\x75\x03\x16\xb5\xfc\x15\xad\x93\x46\xcf\x40\xd4\x12\x1f\x3c\x6a\xfa\x72\xd9\xed\x57\x2e\x93\xe6\xf4\xee\xec\xc9\xad\xd4\xc5\x0c\x2e\x1a\xe7\x4d\xf5\x06\x9d\x69\x6c\x8e\xcf\x71\x21\xb5\xf4\xd2\xe8\x27\x15\x7a\x51\x08\x2f\x66\x4f\x00\x84\xd6\xc6\x0b\x6a\x76\xf4\x09\x90\x1b\xed\xad\x51\x0a\xed\xb4\x44\x9d\xdd\x36\x73\x9c\x37\x52\x15\x68\x99\x78\x5a\xfa\xee\x59\xf6\x55\xf6\xec\x09\x40\x6e\x91\xa7\xbf\x95\x15\x3a\x2f\xaa\x7a\x06\xba\x51\xea\x09\x80\x16\x15\xce\x20\x17\x5e\x28\x53\x86\x4d\xb8\xcc\xd4\x68\x85\x37\xd6\x65\xb9\xb1\x68\xe8\x9f\xea\x89\xab\x31\xa7\xd5\x4b\x6b\x9a\x7a\x06\x5b\xc7\x04\x7a\x69\x93\xc2\x63\x69\xac\x4c\xdf\x00\x53\x30\xaa\xe2\xbf\xe3\xe1\xc3\xb2\xd7\xbc\x2c\xb7\x2b\xe9\xfc\x8f\x9b\x7d\x3f\x49\xe7\xb9\xbf\x56\x8d\x15\x6a\x7d\xc3\xdc\xe5\x96\xc6\xfa\xd7\xfd\xf2\xb4\x5c\x2e\xbc\xb3\x79\xe8\x96\xba\x6c\x94\xb0\x6b\x73\x9f\x00\xb8\xdc\xd4\x38\x03\x9e\x5a\x8b\x1c\x8b\x27\x00\x91\x85\x91\xd4\x14\x44\x51\xb0\x58\x84\xba\xb2\x52\x7b\xb4\x17\x46\x35\x95\xee\x96\xa2\x31\x05\xba\xdc\xca\xda\x33\xeb\xdf\x2e\x11\x6a\x8b\xde\xb7\xcc\x12\x30\x0b\xf0\x4b\x4c\x6b\x77\xb3\x00\x7e\x73\x46\x5f\x09\xbf\x9c\x41\x46\x1c\xce\x0a\xe9\x6a\x25\x5a\xda\xcd\x60\x54\x10\xd3\xf3\xd0\x37\x68\xf7\x2d\x6d\xdd\x79\x2b\x75\x39\xb6\x15\x1a\x77\xf8\x1e\x02\x6b\xde\xb6\xf5\xe6\x16\xd6\x1a\x0f\x5d\xbf\x6e\xe6\x4a\xba\x25\xda\xc3\x37\xd1\x4d\xd9\xd8\xc3\xd5\x96\x9e\x1d\x1b\x19\x10\x4d\x06\x95\x6d\x18\xc3\xc6\x02\xe7\xe5\xe6\x19\x0b\xe1\x53\x63\x18\x74\x77\x26\x54\xbd\x14\x67\xb1\xd1\xe5\x4b\xac\x44\xaf\x0f\xa6\x46\x7d\x7e\x75\xf9\xeb\x17\xd7\x6b\x1d\xb0\xca\x9d\x15\x3d\x07\xe9\x40\x80\xc5\xda\x38\xe9\x8d\x6d\x89\x5b\x17\xd7\xbf\xba\x09\x5c\xbc\x79\xee\x26\x20\x74\xd1\x19\x1e\xd4\x22\xbf\x15\x25\xba\x6c\x63\xaf\x66\xfe\x1b\xe6\x7e\xd0\x6c\xf1\x43\x23\x2d\x16\xc3\x5d\x10\x7b\x12\x4f\xd6\x9a\x89\xff\x83\xa6\xda\xd2\x9a\x7e\x60\xc8\xe1\x37\xf0\x72\x2b\xed\x6b\x27\x7c\x4a\x6c\x08\xe3\xa0\x20\x07\x87\x8e\x55\x20\xda\x18\x16\x91\x77\x41\x35\xa4\xa3\xf3\x5b\x74\xa8\x83\xcb\xa3\x66\xa1\xe3\x99\x32\xb8\x46\x4b\x13\xc9\xdc\x1b\x55\x90\x27\xbc\x43\xeb\xc1\x62\x6e\x4a\x2d\x7f\xef\xa8\x39\xf0\x86\x97\x51\xc2\xa3\xf3\xc0\x56\xab\x85\x82\x3b\xa1\x1a\x0c\xac\xac\x44\x0b\x16\x89\x2e\x34\x7a\x40\x81\x87\xb8\x0c\x5e\x19\x8b\x20\xf5\xc2\xcc\x60\xe9\x7d\xed\x66\xa7\xa7\xa5\xf4\xc9\x87\xe7\xa6\xaa\x1a\x2d\x7d\x7b\xca\xee\x58\xce\x1b\x72\x87\xa7\x05\xde\xa1\x3a\x75\xb2\x9c\x0a\x9b\x2f\xa5\xc7\xdc\x37\x16\x4f\x45\x2d\xa7\xbc\x59\xcd\x7e\x3c\xab\x8a\x7f\xb3\xd1\xeb\xbb\xa7\x6b\xec\xdb\xaa\xcc\x90\xdc\xe6\x28\xaf\xc9\x79\x06\x2d\x0a\xd3\xc3\x59\x7a\x96\x52\x13\x71\xe5\xcd\x8b\xeb\xb7\x90\x36\x10\xd8\x1e\x38\xdc\x0f\x75\x3d\xb3\x89\x51\x52\x2f\xd0\x86\x91\x0b\x6b\x2a\xa6\x82\xba\xa8\x8d\xd4\x3e\x98\xb4\x92\xa8\x3d\xb8\x66\x5e\x49\xef\x58\xe7\xd0\x79\x92\x43\x06\x17\x1c\xc2\x60\x8e\xd0\xd4\x64\x49\x45\x06\x97\x1a\x2e\x44\x85\xea\x42\x38\xfc\xd3\x59\x4d\x1c\x75\x53\x62\xdf\xe1\xcc\x1e\x46\xe0\xcd\x09\x1b\x36\x06\x90\x22\xe4\x41\x83\x77\x19\x25\x04\x0b\xdc\xe6\x81\x61\xc4\x16\xe9\x27\x8a\xc2\xa2\xdb\xd2\xb1\x61\x90\x61\x60\xd0\x93\xa5\x71\x24\x3f\xe1\xe1\xe7\x9f\x5e\x41\x2e\x34\x34\x0e\xc9\x78\x72\xa3\x35\x29\x84\x37\x20\x28\x96\x4d\xf1\x41\x3a\x56\x20\x8b\xa5\x74\xde\xb6\x19\xbc\x34\xb6\x12\x7e\x06\x5f\xa7\xa6\x29\x93\x33\x16\x64\xfd\xed\xec\xeb\xda\x58\xff\x2d\xfc\xac\x55\x4b\x44\x0b\xb8\x5f\xa2\x86\xeb\xee\x6c\xf0\xcd\xe0\xe3\x07\x5b\xe7\x19\x5c\x96\xda\xd8\x34\x92\xb4\xea\xb2\x12\x25\xc2\x42\xa2\x62\xbd\x76\xe8\xb3\x75\x09\x8e\x4a\x11\x02\x5c\x5a\xc8\xf2\x95\xa8\xf7\xb2\xe6\x22\x8d\xa4\xb5\x68\xf9\x61\xf0\xee\x3b\xbd\x61\x55\xa6\x23\xd1\x9f\x22\xbf\x05\x11\x57\xa9\x44\x3d\x75\x6c\x36\x03\x36\x1d\xc6\x81\x8b\x44\x80\xf8\xd7\x37\x5f\x46\xcf\x95\x3d\xf6\xd8\xc3\x93\x3d\x7a\x6e\x0f\x43\xf6\x32\xed\xd5\xb6\x28\x72\xc0\x1a\xa5\xad\xf3\x2b\x53\x84\x63\xef\x5d\xe5\x87\xe1\x68\xc0\x87\xda\x38\x74\x50\xc8\xc5\x02\x2d\xf9\x1d\x73\x87\xd6\xca\x02\x1d\x2c\x8c\x65\x79\xd5\xa6\x60\x9b\xec\xe4\xb7\x12\x6a\xaf\x4c\x71\xa8\x60\x68\x69\x0e\x18\x41\x19\xa3\x1a\xee\x3c\xee\x56\x6b\x87\x3d\xc6\x4b\x3f\x6d\x0a\xbc\x46\x85\xb9\x37\x76\xfb\x88\x35\x9e\xbc\x1e\x4c\x88\x5e\x3f\x7d\xdd\x2f\x65\xbe\x84\xaa\x71\xec\x75\xbd\x6d\x70\x85\x2f\xde\xc0\x42\x7a\x30\x1a\x04\x2f\x4b\xbe\x7e\x73\x66\x25\x7c\xbe\x8c\x23\x9e\x3a\x50\x62\x8e\xca\xad\xd3\x99\x23\x87\xdc\xa2\x51\x58\x10\x41\xf6\x25\x4c\x73\xc7\x11\xf6\x70\x09\x82\x2b\xeb\xf0\xf6\x38\xcf\x60\x9f\x96\x05\xc6\x4b\x63\xa5\x6f\x2f\x94\x70\x6e\x97\x4e\x6f\x70\xf7\x72\xc1\xea\x23\x17\x12\x8b\x09\x48\x5d\x48\x4a\x69\x5c\x3a\xfb\x53\xd7\xd1\xcd\x68\x2c\x05\xb8\xc1\xf8\xc4\xa1\x34\x06\xee\xa5\x52\xc4\xac\x02\x17\xa2\x51\xec\x24\x7f\x47\x6b\x40\xb2\x76\x5a\xd6\x2b\x6d\x52\xf7\x38\xf3\x46\xce\xea\x8d\x22\x80\xd8\x67\x2f\x7b\x4e\xf9\xb6\x1f\x0f\xc2\xe2\x10\x9d\xc7\x30\x44\x07\xe5\xe3\x0e\x48\x8f\x6f\x4f\x58\xbb\x92\xa6\x0c\x7f\xd2\x63\x35\x22\xcb\xcd\xd4\x81\xb4\x8c\x50\x47\xbf\x51\x56\x75\xef\x05\x69\x1d\xc3\xbc\xd0\x83\x0e\x84\x6e\xc1\x8b\x80\x48\x44\xd4\xdf\x28\x31\x6f\x65\xad\x10\xbe\xbe\xc5\x76\x12\x30\x20\x2e\x16\x98\xfb\x6f\xa1\x71\x09\x15\xf1\x78\xfa\xe8\x40\xf6\xd7\xe9\xaf\x6f\x77\x9d\xf8\x20\x7d\xde\x6f\xfb\xe1\x17\xb6\x34\x36\x62\x8d\x43\x2f\x78\xc2\x9a\x72\x06\x0e\x04\x5a\xc4\x1f\x3e\x56\x06\x2f\xaa\xda\xb7\x50\xa1\xd0\x2e\x59\xb6\x52\x2b\x83\x5d\x06\xff\x43\x7e\x70\xa0\xc6\x42\x29\x73\xdf\x61\x62\xd6\x90\xd7\xe6\x3a\xda\xfb\x04\xae\x2c\x2e\xd0\xf6\x2d\xec\x26\x5f\x9b\x17\x0f\x98\x37\x7e\xa7\x07\x18\xf2\x6d\x44\x95\xc3\xef\x16\xdb\x47\x30\xe4\x47\x6c\x53\xec\x0e\x27\xbb\xc5\x36\x28\x03\x37\xf5\x3a\x24\xea\x5a\x49\x0c\xf0\x74\x8c\x33\xb7\xd8\x3a\xb6\x6f\x9a\x7f\x1b\xa8\x23\x8d\x9f\xf4\x5a\x92\xdc\xec\x0b\x42\x48\xee\xbf\x82\xbe\xe6\xa6\x9a\x4b\x1d\x16\x0b\xa4\x93\x28\x98\x7a\x62\xa8\x2e\xf8\x93\x97\xf9\x14\xec\x4a\x9b\x7a\x04\xcf\x7e\x4e\xe7\xe8\xb1\x3f\x08\xda\xd1\x53\x82\xf1\x2a\x58\xfc\x52\xd6\x29\xa5\xe2\xad\x67\xf0\xab\x50\xb2\xcf\x47\x83\x6e\x04\x0e\xf0\xa9\x5e\x7c\x68\x84\xca\xe0\x79\xf0\x67\x7c\xfa\xd8\x14\x07\x11\x23\x3f\x34\xf2\x4e\x28\x8a\xdf\xde\x90\x87\x2c\x72\x61\x0b\x8e\x30\x31\x4f\x73\x26\x48\x4f\xb0\x23\x20\x78\x9a\xac\xbd\x97\x91\xe3\x1c\x11\x6a\x61\xbd\xcc\x1b\x25\x6c\xaa\x3d\xb5\x9f\x84\xa3\xbd\xd2\x5c\x63\x6e\x74\x31\x6a\xc1\x3b\xbd\x6b\x9c\x3b\xe4\x31\x87\x08\xb4\xd2\x14\x0c\x51\x64\x85\xeb\x4a\x7a\xbc\x1a\xc6\xcd\x22\x59\x75\x67\x62\x13\x30\x14\x3d\xee\xa5\x8b\x69\x5c\x07\x95\x65\x80\xd2\x27\x03\xf7\xd8\x59\x45\x06\xdf\xb7\x29\xd2\x4c\x40\xfa\x10\x7b\x3c\xe1\x9a\x49\x02\x00\x51\x65\x23\xb3\x7b\x83\x5a\x18\x8b\x04\x6f\x8f\x0b\xc3\x73\xf0\x4e\xe6\xfe\x24\x83\xbf\x51\x30\x23\xc1\x6b\x2c\x85\x97\x77\x98\x54\x3c\x05\x3e\x6f\x91\x52\x3f\x10\x0e\x9e\xc1\x31\x4f\x03\x59\x55\x58\x48\xe1\x51\xb5\x27\x30\x6f\x79\x19\xd7\x3a\x8f\xd5\x21\xa2\xa3\xa4\xbe\x5c\xa9\x03\x6d\xfe\x16\x31\x45\x91\xda\x7f\xf9\x97\x91\x91\xbc\xd9\x47\x48\xf6\x57\x4e\xac\x57\x5c\x4d\xc8\xb5\xd7\x44\xd8\xc5\x20\xd3\x79\x91\xce\x6f\x48\x17\x6d\x61\xd2\xdb\x55\xaa\x6c\xcc\xb1\x73\x33\x9d\x80\x7f\x23\x3d\x10\x94\x58\xb0\x96\x07\xcd\xfd\x03\x3a\x2e\xf3\xb1\xd4\x60\x67\x44\xdb\x9d\xb9\x02\x67\xaf\x73\xe1\xf0\xcb\xbf\xec\x48\x09\x42\xdd\x89\x64\xbe\x99\xdd\xc2\x01\x81\xb2\x27\xbe\x4b\x58\x7b\xcd\xba\x5b\xfe\xa3\x28\x48\x4a\x02\xf6\xa6\x2b\x5d\xaa\x20\x74\x27\xef\x69\xca\x08\xb9\x80\x2f\xa4\x46\x1b\xa8\x91\xf3\x93\xda\x79\xa1\xbd\x64\xcf\xd6\xe5\x8e\x29\x97\xbc\x97\x7e\xf9\x98\x74\x85\x75\x2d\x3a\x9a\xa0\x5c\xb1\x3a\xb0\xe1\x1f\x1e\x9d\x56\x26\x40\xbb\xbf\xce\x70\x95\xa0\x6f\x58\x53\x38\x27\x4b\x42\x99\x70\x8f\xb2\x5c\xfa\x14\x4e\x56\xd1\x26\xb5\xc6\x25\xe4\xef\x6c\x4d\x55\x17\x04\xa4\xe7\x08\x30\x47\x62\xa0\x6b\x2a\x2c\x92\xcf\x28\xb0\x46\x5d\xa0\xce\x5b\xae\x6a\xa9\x3b\xb4\x19\xfc\xe2\x48\x52\xf0\xdf\xb2\x5c\x12\x0b\xc3\xa2\x43\xa8\xc4\xa8\x80\x42\xf5\xea\x0e\x24\x21\x7b\xc2\x35\x96\x32\x1a\x62\x3f\x61\xa0\x44\x01\x8b\xb5\xf1\x0e\x8a\x86\x6b\x6d\xeb\x9b\x68\x88\x0f\x19\xa3\x58\x2b\x74\xd9\x15\x12\xba\x94\x20\x18\x3c\x1d\xa9\x34\xa1\xaa\xc6\x95\x5f\xf2\x9d\xde\xf4\x7e\x54\x86\x52\x48\x47\x43\x6a\xff\xc5\xe7\x81\x6e\x4a\x26\xa2\xeb\x31\x20\xd6\x0f\x43\x9a\x03\x8d\x0e\xcc\xc7\x61\x3e\x92\xdc\xcc\xb3\x40\x6a\xdb\x3c\x76\xc7\xa2\x5a\xdf\x72\xef\xd3\xad\xd0\xb7\x58\x80\xc2\x07\x99\x9b\xd2\x8a\x7a\x29\x73\xa1\x54\xcb\x66\xca\xe9\xa0\xf4\x8e\xab\x28\x23\x65\x9b\x5d\x6e\xbc\xbb\x02\x78\x74\xf9\xc2\x61\x6e\xd1\xef\x2f\x85\x5d\x87\x71\x7d\x50\xa6\x08\x48\x2c\x8e\x04\x82\x8e\x44\x9d\x4b\xf5\x1e\x91\xe7\x64\x48\xac\xba\x46\x7b\x8c\x00\x64\xa0\xca\x19\x5c\x72\x48\x9d\xa3\x63\x2d\xbf\x45\xac\x83\xa6\x29\xe9\x3c\xb8\x4a\x28\x35\x01\x27\x75\x8e\x80\x22\x5f\x06\x76\x6a\xc4\x94\x50\x7b\x2b\x31\xc0\x20\x0a\xb5\x6d\x27\x1b\xd4\x7e\x3b\xa8\x19\xcf\xbb\x46\x72\xae\x71\x36\x76\x3e\x65\x3f\x27\x7b\x5f\x94\x62\x62\xbc\x73\x72\xfd\xf5\xde\x23\x96\x0e\x75\xe2\x6b\x4f\xe0\xa3\xdc\xef\x6b\x7e\x59\x19\xde\xdd\x33\x2c\xcd\x7d\xaa\x38\x6f\x18\x39\x39\x5e\x97\x64\x5b\x48\x97\x93\xa5\x63\x01\x17\x46\x3b\xc6\xa7\xe1\xe2\x81\x2f\x0e\xee\x84\x0a\xaa\x90\x08\xd7\x46\x29\x36\xf9\x26\xa5\x13\x84\xe3\x35\x60\x35\xc7\xa2\xc0\x82\x8e\x15\xb6\xb2\x23\xcc\xfd\xc1\x52\x51\x8a\x0f\x57\x46\xa9\xf1\x28\x36\x9a\x97\x1e\x92\x95\x26\x06\x8c\x61\xa3\xd5\xd0\x97\x38\x26\x5d\x67\x33\x05\x7a\xb4\x95\xd4\x11\x1e\x11\xd4\xed\x18\x3b\x47\x7f\x8f\xa8\x21\x5f\x62\x7e\xdb\x99\x52\xbc\xb7\x59\x93\x5a\xbc\x34\x5a\xf5\x58\xfd\x95\x98\x51\x8a\x13\x0d\x87\x08\x92\x72\x02\x8d\xf7\x69\xce\x9a\x8d\x0e\x9c\xbd\xb8\x13\x52\x89\xb9\x42\x8e\x9a\xdd\xd7\x64\xe5\xfe\x28\xc5\xf3\xba\x51\x8a\x40\xac\x2e\xa0\x7c\x73\x75\x01\xde\x8a\xc5\x42\xe6\xd4\x55\x48\x8b\xb9\x8f\x35\x89\x5d\x47\x18\x83\x6b\x3b\x2d\xc2\x79\xe1\x9b\x0d\x19\x8d\x08\x78\x4c\xb0\x94\x87\xc8\x9d\x05\xa2\x15\x51\xbe\x59\x4d\x56\x68\x1b\x18\x92\xad\x95\x62\x6a\x06\xaf\x0d\xe7\x08\xc2\xc3\x2b\x74\x14\x76\x99\x41\x6f\x50\x38\xa3\x07\xde\x95\xd1\xaf\x95\xa5\xd4\x42\xc5\x43\xf1\xad\x0f\x41\x74\x69\x74\x97\x7b\x88\x96\x8c\xb2\x92\xa5\x15\xbe\x73\x8a\xfd\xbe\x63\x74\x89\x71\x71\xd1\xf8\xc6\x62\x06\xe7\xba\x65\x79\x2f\x50\x50\x03\x51\xf6\xd6\x14\x4d\x4e\x78\x89\x1c\x6c\xe3\x86\x44\x3e\xa9\x1b\x5d\xe1\xda\xd1\x45\x5a\x24\x01\x3d\x47\x06\x20\x64\x2c\x9e\x1a\x8d\x20\x5c\x4d\x79\x5c\xd2\xc9\xc6\x72\x11\xbb\x63\x30\x07\x8b\xf3\xab\x4b\x48\x4f\x43\x32\x98\x4e\xa7\xf0\x96\x9a\x9d\xb7\x4d\xce\xf1\x85\x4c\x48\x17\x31\x52\x04\xed\xe3\x43\x0a\x86\x9d\x7c\x0c\x88\x95\x8f\x00\xc1\x6a\xe1\x97\x90\x05\xc6\x67\x03\x56\x00\xbc\xa4\x58\xf3\x20\xaa\x9a\xf5\x9e\x5c\xf7\x4b\x63\xae\x83\x84\xc2\x82\xff\x80\xd3\xd3\x75\x85\x30\x73\xc2\xa7\xb1\x7a\xc8\x7a\xb1\x30\xe6\xa9\x5b\x3d\x4f\x46\x13\x7f\xd4\xe6\x5e\x6f\x5b\x9a\xd7\x12\x16\x67\x70\x73\x74\x9e\x4c\xef\xe6\x68\x02\x37\x47\x57\xd6\x94\x84\x59\xa5\x2e\xa9\x81\x34\xea\xe6\xe8\x39\x96\x56\x14\x58\xdc\x1c\x11\xd9\xff\xa8\x29\xbd\x7a\x85\xb6\xc4\x1f\xb1\xfd\x86\x89\x75\xcd\x29\x1c\x7c\x53\x51\x3f\xb7\x53\xfc\xa5\x20\xf5\x4d\x25\xea\xae\xe1\x95\xa8\xbb\xc9\x17\xbd\x92\xbd\x7b\x5f\xa1\x17\x77\x67\x59\x2f\xce\xbf\xff\xe6\x8c\x9e\xdd\x1c\xf5\xfb\x9f\x98\x8a\xd4\xa2\xf6\xed\xcd\x11\xac\xac\x3a\xbb\x39\xe2\x75\x53\x7b\xda\xe4\xec\xe6\x88\x56\xa2\x66\x6b\xbc\x99\x37\x8b\xd9\xcd\xd1\xbc\xf5\xe8\x26\x67\x13\x8b\xf5\x84\xd0\xd2\x37\xfd\x0a\x37\x47\x7f\x87\x1b\x4d\x9b\xe5\x44\x30\x48\xd2\xc1\x3f\x8f\x46\xe2\xf9\x88\xd3\x1f\x4f\xde\x28\x3b\x53\xc2\xf9\xb7\x56\x68\x27\xd3\x33\x89\x9d\x43\xab\x60\xec\x3b\xfb\x2d\x3b\x80\x9d\xdd\x41\x1b\x76\x76\xef\x08\x9d\x87\x84\xad\xcd\x33\x1c\x58\x72\xde\x9c\x98\xf0\x0c\xf5\xf4\x45\x9a\x4e\x3e\x14\x00\xe2\x68\x32\x44\x02\xf1\x64\xdf\xd1\xb9\x11\x5c\xd4\x2c\xb7\x2c\x1a\x6f\x97\xdd\x77\x57\x9c\x8d\x2e\xd0\xaa\x96\xe0\x44\x4f\x35\x5f\x12\xda\x2f\x32\x08\x45\x03\xd1\x95\x68\x6e\xc9\x90\x38\x34\xe9\x41\xe5\x9a\xf7\xd5\x51\x24\xc7\x11\x0c\x3e\x92\xe1\x28\x97\xe7\x58\x7b\x0e\x73\x1f\x7f\x93\x02\x83\x8a\x0a\xc1\xaa\xa9\xdf\xad\x1e\x51\x39\x0e\x64\x7c\x1c\x1d\x2f\xa5\x9b\x4a\x50\xdc\x10\x05\xed\xb7\xef\x0b\xb9\x5b\xc8\xb5\x82\x3f\x15\x73\xd3\xc4\xda\x6e\x27\x87\xc8\xea\x18\x45\x18\x95\xd5\xbe\xdd\x5b\x2e\x39\xe8\xf0\x95\x78\xf8\x09\x75\xe9\x97\x33\xf8\xe2\xf3\xff\xfc\xf2\xab\x1d\x03\x83\x63\xc4\xe2\x07\xd4\xb1\x10\x74\x20\x1b\x36\x27\xae\x57\x0c\xfb\x97\x4c\x65\x3f\xa6\xab\x70\xf7\x1a\x74\x2f\xf8\x9e\x32\xc6\xca\xa6\x26\xbe\x90\x97\x0f\x85\x86\x1c\x27\x84\x90\xb6\x12\x93\x9d\x03\x57\x2d\x9c\x7d\x3e\x81\x79\x64\xf1\xa6\xfb\x7e\xf7\xf0\x3e\xdb\xb2\x65\xe9\xe0\xaf\x93\xb5\xfd\x48\x07\x24\x2a\xb3\x60\xc5\x09\xf9\xa5\xc5\x10\x06\x53\x25\x60\x33\x0c\x62\xb7\xdf\x7d\x82\xdb\x57\x0c\x3c\xac\x10\x58\x49\x2d\xab\xa6\x9a\xc1\xb3\x1d\x43\x82\x4b\x3b\x50\x9a\x61\x70\x8f\x02\x04\xb9\xae\xd2\x8a\x8a\xf0\x4e\x0e\xb2\x40\xed\xe5\x42\xa2\x1d\xaa\x36\xe7\xfa\x61\x62\xba\x6a\xed\xb8\xc8\xb7\xb0\xe4\x87\x06\xca\x7e\x15\x40\x8e\xe5\x08\x1c\xaf\x6e\xf2\xa1\x83\x6a\x6b\x0c\xd6\x10\xb2\x17\xc0\x87\x3a\xe0\xd4\xc1\x1d\x44\x85\x42\x4b\x5d\xa6\xdb\xdd\x54\x48\x0e\x51\xf7\x7e\x89\x1c\x7a\xba\x22\x65\x28\xf6\xe7\x94\x29\x15\x9c\x34\x09\x28\x1b\x61\x85\xf6\x94\xc3\x9e\x5f\x5d\x06\x80\xbe\x5e\xd0\x14\xfd\x93\x9f\x64\x8d\xc1\x54\x83\xb3\xa2\x2d\xc6\x67\x42\x6c\xb1\x9f\xce\x54\xcf\x9e\x7d\x3e\x2a\xf2\x6e\xdc\xee\xfb\x3b\xe1\x3d\x5a\x3d\x83\xff\x7b\x77\x3e\xfd\x9b\x98\xfe\xfe\xfe\x38\xfe\xf1\x6c\xfa\xd7\xff\x9f\xcc\xde\x7f\x36\xf8\x7c\x7f\xf2\xdd\xbf\xef\xa0\xb4\x1d\xc9\xef\x50\x9f\x18\x44\x12\x48\x4c\x12\x9d\x70\x84\x31\x0b\x78\x6b\x1b\x9c\xc0\x4b\xa1\x1c\x4e\xe0\x17\xcd\xa1\xe1\x0f\x32\x0d\x75\x53\x8d\x65\x7a\x53\x38\xa2\x55\xb7\x83\x8f\x6e\x08\x6f\x69\x7c\x4c\xdc\xee\x58\xee\x7a\x18\x93\x52\x9d\x61\xe0\x69\x06\x4f\xcb\xf8\x2d\x12\x19\x92\xc9\x22\xbc\xcd\x72\x53\x9d\x0e\x9e\x9e\x11\xae\x7e\x25\x74\x0b\xbd\x5b\x0b\xa0\x74\x5d\xd3\x9d\x27\xdf\x24\x72\x6b\x9c\xeb\xde\xce\x39\x50\xf2\x16\xe1\xbc\x4f\x1a\xc9\x59\xce\x31\x17\x0c\xc4\xed\x5c\x7a\x2b\x42\xc5\x37\xe1\xca\xbe\x9c\xb4\x68\x14\x1c\x53\xae\x9a\xf1\x7b\x89\x0d\xef\x7a\x12\x4b\xb7\x73\xa9\xa4\x6f\x43\x1e\x9d\x1b\xbd\x50\x32\xe2\xff\xaa\x36\xd6\x0b\xed\x63\x91\x11\x4b\x7c\x00\xd9\xdf\x7b\x4b\x07\xc7\x85\x76\x67\x67\x9f\x7f\x71\xdd\xcc\x0b\x53\x09\xa9\x5f\x56\xfe\xf4\xe4\xbb\xe3\x0f\x8d\x50\x7c\xc5\xfb\x5a\x54\xf8\xb2\xf2\x27\x9f\x2e\x2c\x9e\x7d\x79\x80\x15\x1d\xbf\x0b\xb6\xf2\xfe\xf8\xdd\x34\xfe\xf5\x59\x6a\x3a\xf9\xee\xf8\x26\x1b\xed\x3f\xf9\x8c\xce\x30\xb0\xc0\xf7\xef\xa6\xbd\xf9\x65\xef\x3f\x3b\xf9\x6e\xd0\x77\xb2\xcd\x18\x1f\xa6\xb7\xcd\x1c\xad\x46\x8f\x6e\x4a\x59\xc0\xb4\x12\xf5\xf4\x16\xdb\x1d\xc6\xb9\x13\x8e\x6e\x12\x0a\x1c\xab\x44\xbd\x2d\xf5\x0e\x4f\xc8\xde\x20\x3f\x5b\xca\xb7\x2a\xf9\x1f\xbc\x7e\xd1\x62\x07\x24\x0b\x5d\xfc\xc8\xfd\x23\x4a\x4e\x14\x77\x42\x99\x6d\x0c\x4e\x1f\xa0\x2d\x87\xe1\x47\x3d\xf2\x4c\x67\xef\x22\xdd\x39\x3f\x9a\x42\xb2\xef\x1d\x2f\x9c\x0f\xa6\xd3\xc8\x9d\x99\xd6\x6a\x01\xf3\xf2\x79\x80\xbe\xec\x7a\x18\xce\x2d\x0d\xe5\x79\x8d\x96\x1f\x1a\x84\xcb\xe7\xd1\x1f\x4d\x40\xea\x5c\x35\x05\x21\x85\x5f\x7e\xb9\x7c\x4e\xc9\xfb\xf7\xd1\xdd\xdc\x23\x14\x46\x3f\xf5\xf0\xf3\xeb\x9f\xfe\x97\x2b\x01\x3c\x62\x12\x02\x7a\xb8\x8c\x12\x4a\x86\xc7\xd1\x29\x00\xc3\xf7\x48\xb4\xe2\xca\xb9\xa8\xbb\xe2\x09\xbb\x3b\x5d\xc0\x12\x55\x4d\x00\xe2\x16\xc1\x35\x36\xee\x8e\x08\x87\xeb\x5e\xe2\x35\xc4\xcb\xe0\x12\x3d\x2b\xb9\xe2\x47\xbe\x1f\xc3\xb4\xf8\xec\x54\x1a\x7d\x4d\x28\xf0\x4f\xb0\x0f\x52\xe4\x9f\x23\x66\xe5\x35\x3e\xc2\x18\x46\xde\xda\xee\x3d\x21\x44\x63\xba\x08\x27\xfd\xd3\x2d\x69\xe3\xbc\x1f\xb5\x62\x28\x66\xf2\xb5\xe6\x9b\x3d\xc5\xe7\x8d\x37\x5c\xab\xa9\xf3\xda\x7f\x79\xe0\xc2\x6a\x77\x33\xba\x14\x0e\xe6\x88\x9a\x6b\xb9\xa1\xf4\x87\x3a\x6a\x1d\xf6\x55\xd8\xa6\x9e\x7a\x33\x2d\xb6\x0b\x6f\x0f\xe7\xf6\x73\x6d\x24\x73\x5d\x39\xdb\xf9\xa3\x13\xd5\xfb\x65\xbb\x8d\x07\x2e\xd4\x32\xf9\xd5\x50\xc2\x20\x8f\x3d\xd8\xee\xc4\x64\xad\xa4\xcb\x99\x45\x2c\x6a\xc4\x3c\x63\x73\x4b\x94\x3d\xae\x54\x36\xbc\xe1\xab\xbc\xd5\xca\xde\xe3\xf7\x18\xc4\x7c\x8d\xf6\x4e\x7e\x54\xf0\xdb\x67\x98\x79\x78\x64\x72\xfe\xe7\x9b\x15\x41\xaf\x8f\x5e\x84\x4b\x7f\xb9\xd9\x73\x77\x33\x42\xc0\x05\x0e\x8e\x3d\x66\x7d\x0c\x8d\xc7\x06\xcb\xe0\x4d\x66\xfc\xb0\x38\x35\x79\x63\xf9\xbe\x7d\xd8\xd6\xcc\x3b\xa0\xdc\x53\x8f\x39\x10\xfc\xe3\x9f\x4f\xfe\x15\x00\x00\xff\xff\xfd\x93\x0e\xb4\x2a\x39\x00\x00") func operatorsCoreosCom_catalogsourcesYamlBytes() ([]byte, error) { return bindataRead( @@ -105,7 +105,7 @@ func operatorsCoreosCom_catalogsourcesYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_clusterserviceversionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xfd\x7b\x73\xe4\xb6\x95\x30\x8c\xff\x9f\x4f\x81\x92\xbd\x8f\xa4\x75\x77\x6b\x26\xc9\xe6\xb7\x3b\xbf\xbc\xeb\xd2\x4a\xb2\xa3\xd7\x33\x1a\x95\x24\xdb\x4f\xca\xf1\x3a\x68\xf2\x74\x37\x56\x24\xc0\x00\x60\x4b\x9d\xc7\xcf\x77\x7f\x0b\x07\x00\x09\xf6\x45\xea\x26\x39\xa3\x8b\x81\x54\xc5\xa3\x26\x09\x82\x07\x07\xe7\x7e\xa1\x05\xfb\x01\xa4\x62\x82\xbf\x23\xb4\x60\x70\xaf\x81\x9b\xbf\xd4\xe8\xf6\xdf\xd5\x88\x89\xa3\xf9\xdb\xdf\xdd\x32\x9e\xbe\x23\x27\xa5\xd2\x22\xbf\x02\x25\x4a\x99\xc0\x29\x4c\x18\x67\x9a\x09\xfe\xbb\x1c\x34\x4d\xa9\xa6\xef\x7e\x47\x08\xe5\x5c\x68\x6a\x7e\x56\xe6\x4f\x42\x12\xc1\xb5\x14\x59\x06\x72\x38\x05\x3e\xba\x2d\xc7\x30\x2e\x59\x96\x82\xc4\xc9\xfd\xab\xe7\x6f\x46\x7f\x1a\xfd\xfe\x77\x84\x24\x12\xf0\xf1\x1b\x96\x83\xd2\x34\x2f\xde\x11\x5e\x66\xd9\xef\x08\xe1\x34\x87\x77\x24\xc9\x4a\xa5\x41\x2a\x90\x73\x96\x80\x7b\x5e\x8d\x44\x01\x92\x6a\x21\xd5\x28\x11\x12\x84\xf9\x4f\xfe\x3b\x55\x40\x62\x56\x31\x95\xa2\x2c\xde\x91\xb5\xf7\xd8\x79\xfd\x62\xa9\x86\xa9\x90\xcc\xff\x4d\xc8\x90\x88\x2c\xc7\x7f\x3b\x20\xd8\xd7\x5f\xdb\xd7\x3b\xc8\xe1\xf5\x8c\x29\xfd\xdd\xe6\x7b\xde\x33\xa5\xf1\xbe\x22\x2b\x25\xcd\x36\x7d\x08\xde\xa2\x66\x42\xea\x8b\x7a\x59\x66\x19\x89\x9a\x87\xff\x76\x37\x32\x3e\x2d\x33\x2a\x37\xcc\xf6\x3b\x42\x54\x22\x0a\x78\x47\x70\xb2\x82\x26\x90\xfe\x8e\x10\xff\x2e\x3b\xf9\x90\xd0\x34\xc5\x8d\xa4\xd9\xa5\x64\x5c\x83\x3c\x11\x59\x99\xf3\xea\xe5\xe6\x9e\x14\x54\x22\x59\xa1\x71\xb3\x6e\x66\x80\x50\x23\x62\x42\xf4\x0c\xc8\xc9\xf5\x0f\xd5\xad\x84\xfc\x8f\x12\xfc\x92\xea\xd9\x3b\x32\x32\x1b\x30\x4a\x99\x2a\x32\xba\x30\x4b\x08\xee\xb2\xbb\x79\x6a\xaf\x05\xbf\xeb\x85\x59\xaf\xd2\x92\xf1\xe9\x43\xef\x77\x1f\xb1\xdd\x12\xe6\xc1\x3e\x85\xaf\xff\x61\xe5\xf7\x6d\x5f\xef\x3f\x9f\x9a\x37\x13\x3d\xa3\x9a\xe8\x19\x53\x44\x70\x20\x12\x8a\x8c\x26\xa0\x1e\x58\xd0\x9a\x5b\xec\x8a\xae\x56\x2f\x6c\x58\x52\x38\xa5\xa6\xba\x54\xa3\x62\x46\xd5\x2a\x88\x2f\x97\x7e\x5d\x33\x9d\xbd\x71\xfe\x96\x66\xc5\x8c\xbe\x75\x3f\xaa\x64\x06\x39\xad\x71\x40\x14\xc0\x8f\x2f\xcf\x7f\xf8\xc3\xf5\xd2\x05\xd2\x84\xce\x5a\xec\x27\x4c\x19\x50\x21\x05\x21\x9e\x84\xe0\xde\x2d\x0a\x20\x7f\x5f\xfb\xcc\x75\x01\xc9\xdf\x47\x2b\x2b\x17\xe3\xff\x81\x44\x07\x3f\x4b\xf8\x47\xc9\x24\xa4\xe1\x8a\x0c\x80\x3c\x59\x5a\xfa\xd9\xc0\x3f\xf8\xa9\x90\x86\x2c\xe8\xe0\xc8\xdb\x11\xd0\xc5\xc6\xef\x4b\x5f\xbb\x6f\x40\xe2\xbe\x31\x35\x24\x11\x14\xe2\xa3\xc3\x38\x48\x1d\x1c\x2d\x9e\x32\x65\x90\x43\x82\x02\x6e\x89\x24\xa2\x10\x77\xdf\x34\x22\x06\x00\x20\x95\x21\x00\x65\x96\x1a\xda\x39\x07\xa9\x89\x84\x44\x4c\x39\xfb\x67\x35\x9b\x22\x5a\xe0\x6b\x32\xaa\x41\x69\x82\xa7\x96\xd3\x8c\xcc\x69\x56\xc2\x80\x50\x9e\x92\x9c\x2e\x88\x04\x33\x2f\x29\x79\x30\x03\xde\xa2\x46\xe4\x83\x90\x40\x18\x9f\x88\x77\x64\xa6\x75\xa1\xde\x1d\x1d\x4d\x99\xf6\x54\x3f\x11\x79\x5e\x72\xa6\x17\x47\x48\xc0\xd9\xb8\x34\x84\xf3\x28\x85\x39\x64\x47\x8a\x4d\x87\x54\x26\x33\xa6\x21\xd1\xa5\x84\x23\x5a\xb0\x21\x2e\x96\x23\xe5\x1f\xe5\xe9\x17\xd2\x6d\xb2\xda\x5f\x02\xdf\x5a\x74\x26\x9e\xc0\x3e\x08\x6b\x43\x5e\x2d\x26\xd9\xc7\xed\xb7\xd4\x20\x35\x3f\x19\xa8\x5c\x9d\x5d\xdf\x10\xbf\x00\x77\x2e\x11\xc2\xf5\xad\xaa\x06\xb6\x01\x14\xe3\x13\x90\xf6\xce\x89\x14\x39\xce\x02\x3c\x2d\x04\xe3\x1a\xff\x48\x32\x06\x5c\x13\x55\x8e\x73\xa6\x15\xe2\x1c\x28\x6d\xf6\x61\x44\x4e\x90\xe9\x91\x31\x90\xb2\x48\xa9\x86\x74\x44\xce\x39\x39\xa1\x39\x64\x27\x54\xc1\x27\x07\xb5\x81\xa8\x1a\x1a\xf0\x6d\x0f\xec\x90\x67\xaf\x3e\xb0\x72\xc6\x08\xf1\xbc\x74\xe3\xee\x6c\x3c\xc3\x24\x85\x24\xa3\xd2\x0a\x05\x44\x43\x96\x91\x8f\xef\x3f\x90\x99\xb8\x33\x58\xcc\xb8\xd2\x34\xcb\xf0\x14\x38\xfe\x6c\xc9\x69\x42\x39\xc9\x29\xa7\x53\x20\xb4\x28\x14\x99\x08\x49\x28\x99\xb2\x39\x70\x7f\xba\x46\xdb\x2e\x7e\x13\x91\x20\x96\xb8\xaf\x65\x50\xfe\xaa\x5b\xe0\xd2\x95\x4d\x64\xc3\x8c\x15\x19\xe8\x01\xa8\x1d\xd7\xf7\x22\x66\x73\x52\x72\xa5\x65\x89\x9b\x9d\x92\x5b\x58\x38\x24\xcf\x69\x41\x94\x16\xe6\xc7\x3b\xa6\x67\x84\x86\x08\x4e\x35\x62\xf1\x18\x88\x02\x4d\xc6\x0b\x62\xc4\x38\x24\x08\x5a\x88\x0c\xa9\x05\x3e\x8b\x84\x41\x82\x96\x0c\xe6\x40\xa8\x1c\x33\x2d\xa9\x5c\x54\xd8\xb0\x0c\xd0\x47\x80\x8a\x1f\x1b\x08\x0f\x9b\x41\x42\x1e\xc2\x45\x62\xc9\xad\x93\x5d\xd2\x4a\xb0\xdc\x02\x7a\x97\xe7\x0e\xdf\x6a\x71\x54\x39\x7c\x03\x45\x0c\x5e\x39\xf9\xa0\x92\x6b\xf1\x4d\x0e\xb1\x52\x22\x64\x85\x19\x06\x6c\x21\x12\x8e\xc1\x90\x13\x49\xb9\xb9\xb0\x16\xb9\x5b\x40\xeb\x21\xb4\x31\x43\xdc\xf1\x75\x38\x1a\xce\x4d\xa5\x6c\x08\x4c\xe1\x60\x1a\xf2\x0d\x33\x3f\x08\xbb\xea\x67\xb3\xc0\x39\x4b\xc1\x00\x51\x53\x66\x51\xc7\x9c\x56\x3a\x16\xa5\xb6\xb0\x73\xb7\xa4\x64\xce\x28\xa1\xd3\xa9\x84\x29\x22\xf0\xc6\xd7\x3e\x02\x13\x3b\x36\x1f\xd0\x7a\x0c\xad\x24\xff\xe0\x1d\x86\x0c\x3e\x78\x03\x5f\x77\xcc\xc3\x1b\x56\x85\xc5\xe6\x78\x6c\x0f\xed\xa0\x89\x81\x89\x07\xad\x90\x0f\xde\xbc\xcd\xde\xda\xf1\xc8\x0e\xdb\xd1\xdc\xe7\xa5\x85\xb8\xab\x63\x73\x3e\x6a\xd2\x6c\xc8\x01\xde\x58\x13\xdf\x31\x90\x02\xe4\x44\xc8\xdc\x1c\x14\x4e\x28\x49\xac\xfc\x56\x11\x1e\x24\x8d\x3c\x79\x08\x9c\x64\xdb\xfd\xb7\x63\x1b\x2c\xb0\x63\x48\x0a\xaa\x67\x8f\xdc\xb6\xdd\x56\xd9\x11\x02\xed\xd1\x9b\x1f\xa1\x66\x2b\x73\xd7\x1c\xa6\xf7\xb9\x0d\x18\x7a\x9f\x14\x79\xce\x36\xb3\x36\x50\xed\x8a\xde\x7d\x00\xa5\x0c\xcb\x46\x29\x4d\xd2\x3b\x02\x3c\x11\x86\x58\xfc\xbf\xd7\x1f\x2f\xec\xb4\x23\x72\xae\x09\xcb\x8b\x0c\x72\x23\x88\x91\x0f\x54\xaa\x19\xcd\x40\x22\x77\xfa\x9e\xe7\x8d\xbf\x1d\x26\x96\x0a\x52\x43\x8b\x52\xc8\xe8\xc2\x4e\x96\x42\x22\x52\x43\xa3\x85\x24\x85\x11\x70\xf3\xa2\xd4\x40\xa8\xbd\x8a\xef\x65\x7c\xba\x8e\x48\x77\x02\x0d\x31\x92\x48\x4e\xf5\x3b\x32\x5e\xe8\xc7\x50\x9f\x90\xfb\x61\xba\x2d\x0d\x08\x17\xf3\x38\x25\xb0\x63\x2b\x7a\x10\x4e\xfc\xe8\x57\x1a\x21\x94\x32\x0e\xf2\x52\x48\xbd\x0d\xd1\x32\xca\xc7\x14\xe4\x83\x77\x7a\x90\x31\xae\xff\xf0\xfb\x07\xee\x4c\xa1\xc8\xc4\xc2\xe0\xc5\xe3\x67\x65\xcb\xef\xd9\xfa\x5c\x6f\x3b\xdf\xb6\x67\x79\xcb\xf9\xac\x71\xaa\x8f\x99\xd6\x29\x50\xad\x26\xe2\x7d\x7d\x5b\xa5\x04\x3e\x19\xf3\xbb\x3c\xf7\xd6\x86\x2b\x98\x80\x04\x9e\x38\xda\xf4\x5d\x39\x06\xc9\x41\x83\x0a\x04\xe9\x45\xe1\x28\x8d\x91\x05\x97\xd9\xdd\xd3\x70\xb9\x47\xe4\x19\x7f\xdb\x23\x52\x8d\xbf\xed\x31\xd9\xc6\x8e\x5d\xd8\xe6\xe3\x48\x67\xc7\x4e\x34\xf6\x71\x04\x6c\x31\xe9\x7c\xbd\x39\xa7\xc3\xbc\x46\x27\x7e\x06\x12\xde\x75\x63\x19\x0d\xf9\x6e\xc2\x20\x4b\x09\x33\xc2\x9b\x59\x2c\x19\x67\x22\xb9\x75\x76\xcb\xab\x53\xa2\x84\x15\xf7\x8c\x84\x6f\x18\x6d\x22\xb8\x2a\x73\x20\xec\x31\x0c\x8e\x22\x5d\x14\xe9\xa2\x48\xf7\x52\x44\x3a\xeb\x1f\x78\x0e\x94\x6a\x69\x21\x1b\x69\x15\xde\x17\xa9\xd5\x43\x23\x52\x2b\x1c\x91\x5a\x3d\x32\x5e\x1c\xb5\xda\x4a\x4e\x7b\x74\xae\xc7\x0e\x72\x34\xa6\x46\x63\x6a\x34\xa6\xba\x11\x79\x99\x1b\x91\x97\x45\x5e\x16\x8d\xa9\x0f\x4d\x19\x8d\xa9\x3b\x4e\x14\x8d\xa9\xd1\x98\x1a\x8d\xa9\xd1\x98\xfa\xd8\xc7\x44\x91\x2e\x8a\x74\x51\xa4\xdb\x76\x31\xd1\x98\x1a\x8d\xa9\x0f\x8d\x48\xad\x82\x11\xa9\xd5\x03\xe3\x75\x53\xab\xee\xc6\xd4\x24\x03\xca\xd7\x2b\x55\x4b\xf1\xdf\x78\x1f\x8a\x46\x6c\xc2\x5c\x1e\x84\x7b\x9a\x8c\x61\x46\xe7\x4c\x94\x92\xdc\xcd\x80\xfb\x94\x1d\x32\x05\xad\x0c\x16\x80\x86\x75\x82\xf9\x23\xb4\xe6\x61\xfa\x32\x24\xc0\xe9\x38\x5b\x3b\xf1\x63\xa4\xc4\x3d\xf9\xb0\xf1\x78\x2c\x84\xf9\xba\x55\x88\xa1\xaa\xe3\x35\x9d\x5d\xe2\x99\xf7\x36\xe5\xd8\xad\x0f\x6a\x3e\xb9\x3a\xed\x2b\x94\x99\xfc\x8d\x93\xf3\x6a\x56\x82\x96\x69\x4c\x94\x30\x3c\xc4\xfc\xfa\xf1\x8e\x43\x8a\x49\x6e\x03\xc2\xb4\xb9\xc1\x1c\x7a\x96\x30\x9d\x2d\xaa\x17\x8f\xf6\x76\xdf\xc4\x67\x14\x12\x7d\x72\x75\xba\xbd\xf9\xde\x6f\xc0\xe7\xb0\xd4\x47\x3b\x7c\xb4\xc3\x57\x23\x8a\x41\x2d\x27\x8d\x62\xd0\x03\xe3\x75\x8b\x41\xcf\xdd\x6e\x1d\xad\xcd\x24\x5a\x9b\x1f\xbe\x2d\x5a\x9b\xa3\xb5\x39\xda\x6f\x36\x8c\x28\xb8\xe0\x88\x82\xcb\x23\xe3\xc5\x09\x2e\xd1\xda\x1c\xa9\x55\xa4\x56\x91\x5a\xbd\x0c\x6a\xf5\x12\x43\x77\xa3\xd1\x2f\x1a\xfd\xa2\xd1\x2f\x72\xa3\xc8\x8d\x1e\x19\x2f\x8e\x1b\x45\xa3\xdf\xae\x13\x45\xa3\xdf\xda\x11\x8d\x7e\x8f\x8c\x68\xf4\x8b\x46\xbf\x0d\x23\x0a\x2e\x2d\x27\x8d\x82\xcb\x03\xe3\x75\x0b\x2e\xd1\xe8\x17\xa9\x55\xa4\x56\x91\x5a\xbd\x0c\x6a\xd5\xdd\xe8\xf7\xc8\x49\x7a\xf8\xd9\x87\x4f\xca\x83\xcf\xb2\xe4\xa1\x17\x6e\x82\xe8\x03\x10\x7c\x94\x70\x3d\x46\xae\x86\x64\x4c\x15\xfc\xe9\x8f\x2b\x75\xcb\xc3\x5b\x72\x48\x19\x35\xaf\x5a\x7b\xc7\xe3\x24\xac\x7e\xc5\xe6\x3d\xdb\x62\xef\xab\x65\xb4\x9c\xc5\x15\x56\x7e\x34\x28\xd6\x6c\x6d\x7a\x6e\x6f\xbe\xd6\x92\x6a\x98\x2e\x82\x42\xde\x68\x93\xad\x39\x0f\xdf\x50\x80\xbe\x52\x1a\xef\x66\x20\x01\x1f\xf2\xa5\xa7\x95\x9f\x94\xa9\x2a\x7a\x39\x6d\x51\xdc\xf7\xb1\x70\x64\xff\x9e\x35\x97\x1f\xdb\xb4\x75\xd5\xb7\xd7\x02\xcb\x03\xe8\xd4\x5a\xaf\x4f\xab\x14\xe0\x65\x88\x15\x54\x1a\x0a\xe9\xad\xdc\xc8\xb4\x83\xbb\x97\xe0\xbd\x89\x28\x6e\xc1\xa9\x1f\xe7\xd0\xc3\x20\x53\x79\x93\x65\x7d\x1b\xc6\xec\x7a\x60\x5c\x82\xcc\x99\x52\x9b\x02\xae\x9b\x4b\x7f\x8c\x6c\x6e\x41\x2e\x37\xc0\xdf\x7f\x51\xb0\x9c\x4a\x7c\xc2\x1d\x90\x63\x9a\x10\x59\x66\x46\x98\xe2\x29\x71\xe5\xaf\x09\x4d\x12\x51\x72\x4d\x38\x40\x6a\x2d\x1b\xeb\x70\x75\x0b\x62\xbb\x85\xfc\xb4\xad\xf4\x34\xb4\xeb\x7c\xf4\x2e\xf7\x0d\xc7\xf6\x13\xd6\x16\x54\x0f\xc7\xf6\xd2\x16\xbe\xfe\x71\xae\xb5\x0b\x2b\xdc\x9a\x11\x36\xf6\xf7\x52\x64\x2c\x59\x5c\x95\x19\x90\x99\xc8\x52\x85\x65\xfd\x0d\x77\xaf\x1c\x0e\xa1\x88\x5c\xe0\xdd\xb8\xfa\x01\x19\x97\x9a\xa4\x02\x14\xe1\x42\xfb\xc2\x00\x8d\xc7\xad\x8b\xe9\x6e\x66\x5b\x3b\x98\x87\x08\x2d\x8a\x0c\x53\x29\x84\x11\x5a\xee\x66\x2c\x99\xd9\x7e\x35\x05\x4d\x60\xdd\x6d\xdb\x4b\x2f\x5b\x89\xd7\x64\x27\x11\x9b\x78\x9b\xd5\xf8\x31\x54\x21\x3b\xca\xda\xc4\x96\x88\xff\x56\x8a\xb2\xd8\xf2\xf6\x55\xcb\xa2\x7d\xda\x50\x79\xbd\xd4\xc0\xc6\x5f\x74\x2e\x23\xbb\x37\xf6\xb6\xca\x24\x3a\x22\xe4\x7c\x42\xf2\x32\xd3\xac\xc8\xf0\x11\x5b\x6d\x40\x11\x2a\xa1\xe6\x1b\x03\x42\xf9\xc2\x7b\xa0\x5c\x9b\x08\x48\x09\x9d\x9a\x19\x35\xf6\x87\xf1\x25\xe9\x79\x99\x83\x39\xcd\x69\xfd\x12\x54\xa7\xf8\xa2\x9e\x9d\xdc\xb1\x2c\x33\xf2\x2c\xcd\x32\x71\xb7\x9e\x2d\xad\x1b\xbb\x09\x85\x64\x37\xc1\x90\xec\x2e\x02\x13\xc2\x05\xf7\xa6\xdd\xef\xaf\xde\xb7\xdb\xc4\x8b\xe6\x1c\xae\x17\x08\x68\x03\xd2\x82\x4a\xcd\x68\x46\x4a\x99\x29\xbb\x8f\xd4\x28\x01\xd2\x37\x53\x99\x51\xf4\x0c\x26\xa0\x6c\xd7\x0e\xf2\xaf\x76\xe7\x1c\x60\xed\xf9\x14\x3c\x5b\x10\x6a\x77\x7e\x52\x66\xd9\x80\x4c\x18\xa7\x86\xec\x42\xe1\x33\x61\x8c\xfe\x44\xae\x19\x4f\xc0\x7c\xd3\xb0\x12\x2c\x70\x45\x66\x46\x73\xbe\xab\x43\x9a\x0e\x5c\x5b\x11\xab\x2d\x2b\xf7\x0a\x73\x60\x13\x3a\xce\x00\xfb\x5a\x38\x91\xe5\x4a\x64\x68\xde\x76\x86\xef\xd4\xf6\x22\xa1\xe1\xe5\xff\x62\x1c\x95\x14\x72\x85\x8c\xc3\x28\x3b\xc0\xf4\xcc\xe8\x3e\x45\x91\x2d\x0c\xa1\x30\xb8\x53\x23\xd4\x81\x2a\x93\x99\xf9\xa4\xbd\x42\xa4\x6a\xcf\x90\x91\x3d\x05\x89\x04\xad\xf6\x0e\xcd\x5f\xcb\xdf\x80\xdf\x17\x3e\x77\x44\x0b\xb6\x77\x38\x20\x08\x20\x6c\x74\x22\xf4\xec\xe5\xe2\xa1\xff\xd6\x46\x7f\xad\xc7\x46\x53\x6b\x0d\x67\x70\x5d\x3b\x44\x61\x9b\x60\x18\x1a\xad\x01\xf3\xa4\x0c\x52\x22\x1a\xf8\xf6\x50\xab\xc4\x9a\x90\x63\x4e\x20\x2f\xf4\x02\xb1\x38\x07\xca\xdd\xdd\x30\x07\xb9\xd0\x33\xa3\xad\x32\xf5\xf2\x0f\xff\x96\x8e\xa5\x7a\xac\x05\xb8\x3b\xf0\x1e\xb8\x35\x92\xdb\xce\x4a\xcb\xc0\xdd\xff\xd7\xfd\x50\xea\x35\xe2\x53\x4d\xcd\x5f\x2c\x28\x91\xbd\xb6\x02\xe3\x0f\xe6\xc9\x26\x08\xed\x4f\x96\x5a\x56\xf4\xe3\xfd\x7b\xdb\x45\xc9\xc1\xea\x3b\xc6\x53\x2b\xa2\x1e\x6b\xdb\x9e\x08\xae\xc0\x2c\x38\xb1\x99\x89\xbe\xc6\x51\x6a\x09\xa4\xdb\x89\xb5\xe0\xc7\xb5\xbf\x44\xd0\xaf\x0a\xb6\xdb\x0a\xa3\x8f\x4c\x1f\x68\x3e\xcf\x41\x59\xc1\x7e\x4d\x0d\xf9\xc7\x50\xb0\x81\x75\x46\x19\x14\xc8\xe8\x18\x32\xdb\x8c\xc9\x5c\xad\x97\x4f\x8e\xdf\x7f\xa8\xfa\x96\x49\xa0\x8f\x58\xba\x3e\x81\x8a\xb2\x85\x4b\x75\xa5\xfb\xdb\xea\xd8\x5e\x2a\x45\x50\xec\x66\x26\x26\xd7\xa0\xed\x01\xcc\x69\x61\xce\x9f\x9d\x63\xad\x95\xf3\x3d\x42\xfa\xf1\xc3\xb2\x93\x34\xbf\x7d\xb7\xa6\x75\x2f\xd9\xea\xa8\x6c\xe7\x0b\xde\xe5\xec\x3d\x60\xfb\xa8\x47\x03\xcc\x4b\x08\xed\x24\x7e\x27\xa3\x27\x55\xe7\x3d\x8b\xc1\xca\xa6\x4c\xdb\x04\x75\xe9\x7f\xaf\xa7\xe8\x79\x0b\x76\x51\xa7\x8c\x46\x9d\x41\xa2\xc5\xc3\x05\xe1\xfc\xcd\x1a\xf2\x22\x7b\xec\xe4\x91\x9d\x55\xaf\x9c\xf1\x2b\xa0\xe9\xe2\x1a\x12\xc1\xd3\x2d\x09\x6c\x63\x3f\x3e\x30\xce\xf2\x32\x27\xbc\xcc\xc7\x80\x20\x56\x76\x2e\x24\x24\x56\xad\xa5\x84\xc3\x5d\xb6\x70\xc4\x23\x25\x85\x48\x3d\x3d\x19\x1b\x35\x8c\xa6\x0b\xec\x7c\x86\xa5\x53\xf9\xc2\x4c\xc2\x74\xcd\x7d\x24\x49\x24\x55\x46\x60\x1a\xe0\xa4\x4c\x1b\x5e\x36\x06\xf4\x3a\xb1\x14\xcc\x1e\xd3\x39\x65\x99\x11\xba\x47\xe4\x14\x26\xb4\xcc\xb0\x81\x1f\x79\x43\x0e\xcc\xcb\xbc\xa6\xb5\xee\x01\x23\x08\x2b\x61\x74\x74\xe5\xb2\xdf\x71\x41\x87\x3b\xd8\xd1\xb7\xa9\xec\xe7\xc7\xb6\x15\xfe\xfc\x28\x68\xa9\xb6\x55\xd0\x1b\x1b\x73\xce\x53\x73\x1e\x42\x19\x35\x20\xe9\x4c\xb9\x99\xb7\x63\xd9\x0f\x57\x45\x58\xb3\x6a\x29\xa6\x12\x94\x3a\x05\x9a\x66\x8c\x43\x7b\xfc\xba\x99\x01\xc9\xe9\x3d\xe2\x98\x66\x39\x18\x49\x24\xc4\x30\x1a\x7e\x95\x16\x24\xa7\xb7\x50\xbd\x9e\x8c\x61\x82\x0d\x1a\xf1\x83\x83\xdd\xb7\xf8\x33\xa1\x2c\x83\x74\x84\xef\x08\x66\xa9\xfb\x1a\x5b\xc4\x31\x7f\x33\x5e\x82\x79\xaa\x90\x02\xd5\x4c\xfb\x68\xc8\xe3\x91\x87\x52\x73\xb3\xa5\xc3\xbe\x97\xdf\xe5\x12\x28\xce\xee\x13\x6b\xfe\x93\x40\x15\xde\x66\x71\x53\x95\x72\x62\x94\x4a\xaf\x8b\x06\x0b\x72\x4d\x60\xc9\x85\xd0\xae\x25\x60\xf5\x81\xf8\xb4\x6b\x51\x09\x4a\xb3\x1c\x0f\x58\x5a\x4a\xdf\x30\x13\x61\x46\xd7\x6f\x7d\xe3\xa8\xfc\xe9\xcd\x9b\x2d\xe5\xb7\x4f\x8f\xf4\x12\x50\x87\x6e\x83\x2f\x17\x15\x1d\xf2\xe4\xdf\x28\xc7\x66\x8f\x99\x13\x90\xb1\xf3\x27\x48\xf4\x20\x32\xa5\x19\x9f\x96\x4c\xcd\xc8\x18\xf4\x1d\x00\x27\x70\x6f\x6b\x5f\x90\x7f\x82\x14\xb8\xa9\x06\xbc\xb5\xf3\xa0\x01\xb4\xb7\xcf\x07\x62\x73\xa6\x98\xe0\x7f\x61\x4a\x0b\xb9\x78\xcf\x72\xf6\x48\x51\x52\x3f\x56\xfb\x1f\x57\x10\x14\x59\x8a\x5d\x8b\x59\x42\xaf\xc1\x7e\xb0\x04\xb4\x6d\x6a\x61\x15\x57\x62\xce\xc9\x98\x26\xb7\x9f\x0c\xc0\x6f\x9e\x0b\x84\x3d\xbb\x6e\x01\x55\x94\xf7\xaa\x09\x90\x6c\x59\xa4\x3c\xbb\xb7\xf0\x69\x40\xf9\x6e\x26\x14\xe0\x0d\xd6\xfc\x88\x8f\x79\x77\x01\x53\x15\xc1\x30\xa7\x5b\x70\x50\x84\x4e\x26\xcd\x3b\xea\xc3\x8e\x92\x67\x5e\x2a\x4d\x72\xaa\x93\x99\x35\x72\x89\xb4\x12\x27\xf6\x95\x13\xfb\x77\x81\xf2\xd6\xe6\xe5\xdd\x0d\xc1\xc4\xae\xf3\xec\xde\xe8\x96\x8f\xfa\x79\x9a\xa3\x01\xf2\xe5\x69\x9a\xba\x71\xd6\xdc\x10\x27\xb7\xe5\xb6\x79\xf0\x0d\x9a\x86\xeb\x5f\x70\x17\x8e\x2f\x4e\xb7\x37\xd2\xb4\x51\x70\x77\x56\x71\x97\x8d\xe0\x0f\x7c\x94\x37\xa6\xba\x2b\x4d\x4b\xb8\x6d\x1a\x3d\x20\x94\xdc\xc2\xc2\xf6\x97\x5e\x69\xd8\x2b\x21\x73\x92\x04\x60\xdf\x5a\x73\x93\x6b\x36\xbd\xc3\x7a\x77\xc6\x1e\x3b\x76\x73\x52\xf8\x31\x34\x0b\xdd\xf1\x09\xff\xd1\x3b\x3c\xb6\x3b\x82\xdb\x71\x0b\x8b\xdd\x1e\x58\xda\x6e\xb3\x0b\x4e\xf7\xb1\xfb\x6e\x7e\xa8\x04\xbd\x6a\xab\x77\xf3\x1e\x85\x63\x67\xe3\x95\x1f\x1e\x88\x9d\x3e\xaf\x42\xbf\xd0\xca\x64\xbe\x71\x5f\x59\x64\x34\x67\x7a\xc6\x0a\x64\x44\xde\x4d\xe0\xdb\x9f\xff\x40\x33\x96\x56\x53\xd8\xf3\x7b\xce\x07\x46\x7c\x32\xff\x41\xa2\x6b\xc5\xb5\x53\x01\xea\x42\x68\xfc\xe5\xb3\x01\xc8\x2e\xb3\x13\x78\xec\x14\xce\x3e\x8d\x54\x06\x15\xaf\xa0\x73\xba\x1a\xf9\x9a\x5f\x15\x28\x99\x22\xe7\x9c\x08\xe9\xe1\x80\xbd\xec\xed\x44\x76\x0a\xe4\x13\x63\xeb\xfa\x40\xcb\xf5\xda\x39\x1c\xf8\x84\x6c\x40\xef\x81\xe9\xdc\x54\x28\x1f\xd8\x2b\xb6\x57\x7e\x86\xd2\xae\x13\x55\xa9\x77\x7f\xb3\x84\xe4\x20\xa7\xe8\x8b\x49\xb6\xf6\x45\x34\x37\x65\x37\xba\x6b\xc7\xce\xd4\x37\x7c\xe1\x4e\x58\x80\xac\xc9\x9a\x80\xba\x30\x37\x3b\x43\xc3\xe4\xf4\x7f\x0c\x05\xc7\x3d\xf8\xbf\xa4\xa0\x4c\xaa\x11\x39\x26\x8a\xf1\x69\x06\x8d\x6b\x4e\xc3\x08\xa7\x31\x33\x30\x45\x0c\xa9\x9d\xd3\xcc\xe9\x52\x94\x13\xb0\x36\x2b\x33\xfb\x32\x4b\x1d\x38\x49\xc5\x50\x9e\xca\x05\xb6\x77\x0b\x8b\xbd\xc1\x0a\xd2\xec\x9d\xf3\x3d\xcb\x5b\x56\xd0\xa4\x62\x44\xe8\x3d\xdb\xc3\x6b\x7b\x7d\x72\xe1\x1d\x19\x4e\x5b\x3b\x5a\xf3\xa5\x5b\x63\x84\x8f\xfa\x68\x29\xac\x37\xb4\x44\x17\xeb\xa4\x05\x29\x15\x58\x69\x1d\x4f\x19\x01\x2f\x67\xa2\x54\x89\x8a\x29\x87\x3b\x94\x1e\x9f\x8d\xe0\x67\x34\x09\xc6\xa7\xdf\x17\x29\xd5\x5b\x85\x9b\xda\xd1\x80\xc8\xfe\x95\x9d\x84\x94\x38\x8b\xc1\xad\x09\x9b\x92\x82\x4a\x9a\xab\x11\xb9\x74\x75\x0f\x11\xd3\xd8\x24\xb4\x25\x3a\xd8\xdd\x2c\x0a\x20\xff\x0f\xb9\x0a\xd7\x32\x22\xc3\xe1\x90\xdc\x7c\x3c\xfd\xf8\x8e\xd8\x5f\xac\x94\xad\x05\x99\x08\x54\x82\x44\x29\xcd\xab\xe6\xc0\x51\xf1\x37\xf2\xbd\xe0\xf0\x71\x62\x4e\x08\xd5\x30\x07\x49\xee\xcc\x56\x25\x2c\x85\xca\x7a\x35\xda\xff\xb4\x78\xdc\x4e\x32\xc9\xe9\xfd\x75\x29\xa7\x3b\x6c\x00\x59\xd9\x84\xd0\x64\x53\x2b\x93\x88\x7a\x61\xde\xae\x4a\x66\x90\x96\x19\xa4\x84\x8e\xc5\x1c\x1a\x26\xdb\xe6\x63\xc8\xd2\x4b\xf0\x0f\x1a\x9e\x37\x56\x22\x2b\x75\xa5\xac\x1e\xc0\xfd\x3b\xf2\x6f\xe8\xf4\xa6\xa4\x00\x99\x00\xd7\x74\x0a\xcb\x66\x00\x7b\xdf\xdb\x37\xff\x72\xe8\xf8\x91\x99\xd1\x59\x4f\xde\x18\x8c\xf8\x40\xef\xbf\xe7\xb5\x69\x90\x29\xf2\x66\x44\x8e\x97\x5e\x86\xcf\x65\x49\x99\xa1\xad\x05\x1d\xf9\xc1\x2b\xc7\x0b\x22\x45\x89\xae\x7c\x52\x16\x4d\x6d\xf6\xf7\xff\xf6\x2f\x46\xe9\xa3\x79\x91\xc1\x3b\x5f\x2e\xd5\xaa\xcd\x46\x86\xd1\x82\xfc\xe1\xcd\xbf\x58\xea\x69\xce\x67\xad\x15\xd6\x30\xa3\x06\x60\x65\x41\x58\x6e\x83\x34\x21\x5b\xd4\x75\x57\x65\x13\xfd\x95\xa6\x52\xab\x01\x41\x7f\x7f\x25\x1c\x6a\xa1\x69\xb6\xa4\xe5\xa3\x16\x0e\x77\x16\x48\xa9\x40\x98\x00\x1a\xaa\xc8\xdb\x3f\xbc\xf9\x97\x55\x73\xca\x47\x9e\x00\x3e\x89\x4f\x60\x00\xc6\xd8\x28\xf7\xb7\x2c\xcb\x20\x1d\x3c\xba\xfc\x49\x29\xf5\x0c\xe4\x80\x00\x57\xde\x58\x65\xd6\xb7\xb4\x36\x9c\x5d\x96\x9c\xa3\x8c\x60\xad\xc3\x68\xd1\x0a\x2c\x5c\xee\x63\x0d\x23\xd4\x24\x17\x4a\xaf\x5f\xf2\xf6\xc7\xcd\x0c\xca\x17\x1f\x27\xbb\x8a\x03\xc3\x16\x66\x88\xd5\xa7\x5b\x88\x94\xf7\xc3\xdb\x2a\x87\x72\xc8\xb8\x1e\x0a\x39\xb4\xd3\xbc\x23\x5a\x96\x8f\x7b\x0d\xea\x91\x37\x4e\xc0\x67\x20\x03\x65\x70\xde\x56\x76\xf5\x93\x9c\xfc\xf6\xe7\x39\x15\x77\x7c\x33\xe5\x40\xc2\xe9\x68\x46\xcb\x53\xdf\xb4\xb8\x2d\x1d\x1b\xf3\x76\x73\xf7\xff\x6f\x15\xbb\x77\x20\x07\xee\xec\x56\xa7\xdd\xc8\x55\xe8\xf1\x18\x6c\xf1\xf6\xea\xd8\x5a\xce\x67\x6d\x4e\xe6\x06\xfb\x9a\x35\x94\x6b\xe5\x84\xaf\xa1\x40\x76\x1d\xb5\x43\x46\x63\x44\x81\x39\xe7\x6a\xe3\x41\xcf\x80\x2a\xbd\x0e\x14\xf1\xa0\x3f\x3e\x1e\x0e\xed\x5f\x1e\x4d\xa1\xd3\x48\x48\x08\xf2\xda\xc6\x78\x62\x11\x65\xef\x0a\xac\x87\xcf\x86\xa2\x35\x84\xa8\xbd\xea\x48\x98\xfd\x6b\xca\x57\x9f\x2a\xa0\xc6\x1b\x39\xdb\x88\xd6\xee\xd1\x20\xe4\xd7\x99\x4e\x1d\xf1\xaa\x3c\x8a\xd6\xa5\xf9\x6c\xa4\xe8\x1c\x34\x7d\x38\xfd\x63\x79\x34\x89\xf6\xb5\xa6\x3c\xa5\x32\x75\xab\xdc\xdf\x57\xd5\x94\x23\xf2\x01\x7d\x69\x7c\x22\xde\x91\x99\xd6\x85\x7a\x77\x74\x34\x65\x7a\x74\xfb\xef\x6a\xc4\xc4\x51\x22\xf2\xbc\xe4\x4c\x2f\x8e\xd0\x81\xc6\xc6\xa5\x16\x52\x1d\xa5\x30\x87\xec\x48\xb1\xe9\x90\xca\x64\xc6\x34\x24\xba\x94\x70\x44\x0b\x36\xac\x65\x66\x35\xca\xd3\x2f\xfc\x8b\x3e\xb1\x60\xdc\x38\x43\x68\x5d\x92\x73\x18\x96\xfc\x96\x8b\x3b\x3e\x44\x4d\x56\xed\x74\x9a\xb6\x8b\x62\xf0\x63\x09\xde\xbb\x04\x2e\x14\x22\xfd\xe4\x9b\x60\x3e\x66\x48\x79\x3a\xb4\x4e\xc7\x4f\xbc\x17\x6d\x6c\xbb\xc3\x3a\x30\x60\x9b\x58\x74\x3b\xda\x69\x43\x34\xd1\x6c\x0e\xad\x9c\xd8\x7e\x34\xb6\xfb\xa3\x0f\x25\x4d\x4b\x69\x77\x3c\xf0\x66\x7b\xdf\x4c\x4e\x17\x28\xeb\xe0\xbb\x89\xb0\xac\x9c\x8b\x14\x9c\xe5\x73\x8e\xaa\xfd\xb5\x61\xe6\x37\x46\x14\x76\x3e\x6e\xb4\xfb\x2e\x94\x86\xdc\x12\x27\xfb\x7c\xb6\x20\x5a\x2e\xac\x63\x5c\xde\x1a\xe5\xd3\x79\xae\x8d\xc4\x7f\x8b\xf7\x29\x25\x12\x86\xa2\x4f\x0d\x57\x2f\x77\x79\x1b\x1e\x25\x85\x50\x0c\xdf\xed\x78\xde\x6e\x96\xb9\xf6\xec\x32\x70\xd3\xfd\xe9\x8f\xbb\x6c\xdd\x04\x1b\x2c\xec\x68\x65\x6f\x46\x50\x4c\xc2\xd8\x7f\xb7\x3d\xfb\xca\x2b\xae\x46\x2c\x49\x04\x57\x5a\x52\xb6\x39\xbb\x69\xfd\x68\xe9\x0a\x69\xef\x6f\x20\x88\x41\xc7\xad\x80\x42\x56\x63\xb0\x3c\x53\x44\xb4\xf4\xa0\x0e\x01\x63\x93\x9f\x7c\x2c\xa1\x21\x5c\x2d\x4d\xab\x2d\x60\x44\x3a\xc1\xc9\x3e\x0d\x13\x90\x12\xd2\x53\x94\x3e\xaf\xab\xef\x3a\x9f\x72\x51\xfd\x7c\x76\x0f\x49\xb9\x6d\x8e\xf8\xea\x58\xb1\xe5\x79\x83\x88\x0b\x3b\xb1\x8b\x30\x47\xd7\x5f\x70\xf2\x87\x40\xb0\x3b\x41\x44\x51\xcd\xd4\xc4\x66\x92\x55\x1b\x01\x81\xe3\xb3\x42\xe1\xca\x3d\x8c\x2c\xce\x26\x45\x30\x8d\xe4\x26\x99\x09\xa1\xcc\x29\xc7\xfd\xc4\x79\xe7\x4c\x58\x9f\x1f\xa6\xb5\x48\x92\x1b\x1a\xe3\xd3\x5b\xea\xe9\xad\xa1\xb6\x7e\x8c\x29\xab\x82\x57\x10\xf4\x5e\x2a\x33\x0d\x1a\x1e\xcd\x1f\x53\x94\x9a\x94\x26\xaa\xcc\xcd\xa4\x77\xc0\xa6\x33\xad\x06\x84\x8d\x60\x84\x58\x03\x34\x99\x05\xd3\xe6\x00\xba\xd1\x1f\x25\x44\xb5\xd0\x4a\x7c\x50\xe5\x3b\xb8\x04\x9d\x41\xc5\x63\x96\xf7\x72\x2d\xb8\x06\x04\x74\x32\x3a\x1c\x90\x3a\x85\xdc\xac\x71\xbc\x20\x4c\x83\xa1\xd9\xa8\x8b\x48\x51\x4e\xed\x97\x80\x8f\xe9\xc4\x75\x55\xc9\x20\xe8\x45\x4d\x51\x67\xdc\xb3\x1f\xb7\x67\xf6\x0d\x57\x5e\xe6\x46\x5f\xac\x88\x3a\x9a\xd5\x7d\x4b\x1d\x21\x25\xa8\x42\x58\x6d\x73\xd9\xe0\xfe\xff\xaf\x1e\x3a\x50\x87\x35\x30\x67\x6c\x3a\xf3\xb0\xa4\x8e\x11\x34\xf7\x60\xf7\xb3\x47\x3a\xf9\x52\xec\x68\xe9\x51\xb1\xa3\xe9\xdb\xf6\x99\x14\x35\x56\x05\xfb\xaf\x41\xe6\x15\x14\x11\x45\x90\x64\x38\x3b\xb7\x6f\x65\xe3\x70\x8c\xbc\x21\x07\x88\x64\x4c\xef\x2b\x44\xf8\xa1\x28\x0e\x47\xe4\x98\xf0\xb2\x3a\x73\x0f\xbd\x80\x8b\x6a\x7e\x37\x91\x79\xa9\x12\xf5\x5c\x2d\xbf\xb8\x13\xb9\xb3\xa3\x9d\xa7\x3c\x1c\x43\x07\x01\x78\xbc\x60\xe2\x43\x93\x58\x58\xb7\x9c\xa0\x1b\xe9\xf6\x73\xf8\xaf\x68\x3f\xc7\x4a\x80\x05\x1e\xd7\x3a\x8a\x02\x64\x3e\x08\xa5\xa7\xea\x40\x36\x4f\xb1\x85\x45\x5b\xac\x20\xfd\x60\x06\xe9\x09\xae\xa4\x53\x84\xce\xfa\xb1\x1c\xc6\xe2\xf3\xab\x1a\xd0\x6e\x10\xf9\xf1\x02\xaf\xee\x18\xbc\xb4\x79\x74\xa5\x74\xf5\xe8\x44\xf3\xea\xf1\x20\xe2\x3d\xbf\xc0\x9e\xf5\xa3\x27\xb4\xb5\xa3\x3b\x69\xab\xc7\xee\xa1\x41\x9b\xe6\x69\x11\x30\xb4\x7e\xf4\x75\x36\xed\x68\x11\x5c\xb4\x7e\xac\x88\xa8\x9f\x26\xd6\x68\xfd\x68\x6d\x24\x5d\x3f\xda\xc6\x25\xad\x1f\x4b\x49\x8c\x9f\x28\x48\x69\xd0\x8c\x50\x22\xdf\x6a\x7b\x8e\xdf\x77\xe2\x27\xf5\xe8\x19\xc4\xed\x22\x9b\xd6\x8f\x65\x01\xf0\x85\x44\x39\xad\x99\xea\x5b\x6d\xa6\x79\xbf\xf1\x61\x9b\xbd\xee\xe3\x74\x9c\x42\x31\x70\xa9\x33\xde\xce\x8c\x11\xd5\x85\x04\x2c\x38\x80\x61\x5f\xde\x0e\xf3\x79\x02\xab\xd6\x8f\xfe\x18\xa7\x1d\x3d\xb1\x4f\x3b\x7a\x43\x6e\x14\x78\xbe\xb1\x76\xe1\x27\x94\x75\xac\x65\x3a\xca\x3a\x51\xd6\xd9\x61\x44\x59\x67\xdb\x11\x65\x9d\x4d\x23\xca\x3a\x6b\x46\x94\x75\xa2\xac\xd3\x69\x3c\x3f\x59\xc7\x5a\xaa\x7a\x33\x98\xfd\x68\x0d\xae\xcb\x16\x32\x94\xa6\x7c\x48\x4f\xd3\x54\x66\x78\xff\xb5\x23\xb1\x37\x68\x5e\x73\x91\xea\x92\xf2\x29\x90\xb7\xc3\xb7\x6f\xb6\x4c\x07\x5c\x3f\xba\x04\xed\x84\x63\xd7\xd4\xc1\xe5\xb1\xc9\x23\xf1\xc9\xbc\x4b\xee\xa4\x56\x0e\x8f\x86\x84\xb9\xc1\x41\x54\xd5\xbb\xca\x41\x13\xaa\x1b\x06\x71\x96\x43\xe5\x10\x6d\xa4\x20\xd7\x31\xbd\x82\x3b\x7f\x87\xd9\xd4\x51\xbb\x15\x24\x40\x6d\x1c\xfb\x18\xaa\x55\x88\x1c\x6c\x82\xa9\x3f\xf4\x66\x09\xe0\x61\x45\x0e\x60\x34\x1d\x91\xd4\x26\x6b\x53\xee\x62\xc6\x0e\x07\xa1\x7b\x3c\x37\xc4\x55\xe2\x7f\xcc\xb2\x9d\x7f\x1c\xe6\xc0\x75\x49\xb3\x6c\x41\x60\xce\x12\x5d\x7d\x1f\x06\x04\x32\x6d\x9d\x9d\x5d\x5c\x29\x1d\xc4\xc3\xae\x22\xe1\x70\xe5\x6c\xed\xe6\xaf\xf6\xa3\xbb\xec\xb6\xb2\x8e\xf6\xf4\x66\x49\x2e\xb1\x10\x1a\x6d\x54\xab\xb4\x79\x9b\xf5\x57\xe2\x3f\x11\xc1\x3f\x5e\xb5\x75\x8f\x91\x9e\x78\x42\x67\x3e\xb0\xac\x40\x95\x59\x66\xd0\xdb\x7a\xcc\x56\x41\xb0\xc6\x93\xb5\x26\xdb\xc6\xba\x59\xf3\x20\xeb\x06\xef\xb9\x11\x85\xc8\xc4\x74\x11\xee\xa0\xed\xd5\x12\x94\xb7\xa1\x44\x95\x63\x27\x02\x9a\x43\x74\xb1\xb4\xe5\xd1\x17\xb2\x71\x44\x5f\xc8\xca\x88\xf6\x81\xe5\x11\xed\x03\x3b\x8c\x68\x1f\x58\x33\xa2\x7d\x60\x75\x44\xfb\x40\xb4\x0f\x74\x19\xaf\xdf\x3e\x40\xa2\x2f\x64\xd3\x88\xb2\x4e\x3d\xa2\xac\xb3\xfd\x88\xb2\xce\xea\x88\xb2\x4e\x94\x75\xa2\xac\x13\x65\x9d\xb6\xa3\x03\x72\x17\x22\xed\x3d\x45\xa6\x10\xe9\x03\x19\x32\xd6\x5e\x9d\x88\x61\x26\x92\xaa\xb2\x88\x79\xc4\x79\x3e\x14\xcd\xad\x09\x7d\x40\xfe\x29\x38\xd8\xf4\x04\x5b\xb2\x36\x07\x22\xb0\x3d\x44\x21\xd2\x03\x75\xd8\x22\xf0\x3c\x66\xd8\xc4\x0c\x9b\xdf\x40\x86\xcd\x8c\x2a\x57\xf8\x08\x49\xeb\xe6\x84\x9b\xe0\xf8\xdf\x80\xcc\x7f\xb3\xf9\x36\x06\xe1\x1c\xc2\x60\xf7\xb8\x1a\x29\x2c\xec\x52\xe7\xdb\x85\xf4\xb2\x09\x31\xa7\x97\xd9\xe6\x3b\x69\x0a\x29\x29\x40\x0e\x2d\x92\x09\x32\x61\xae\xfe\xd7\x12\xfe\x3a\x08\xbf\xf0\xbc\x99\x26\x24\x5e\x74\xf2\x4c\xf3\x53\x7a\xf3\x4d\x85\x2e\xba\x06\x57\x7c\x71\xa9\x34\xfd\x68\xa5\x43\xa2\x9d\x3b\xed\xbb\x4e\x7a\x69\x5f\x4a\x24\x2a\x79\xd7\x3b\x95\x39\xde\x3c\xd6\x16\xa7\xfd\x47\x09\x72\x41\xc4\x1c\x64\xad\x18\x55\x7d\x7b\x06\x55\x93\x99\x84\xba\x02\xc8\xfd\x18\x78\x7a\x31\x45\xf4\xa9\xa9\xf7\xed\x35\x24\xcf\xac\xfa\xf1\xe6\xd1\xaf\xe2\xd0\xa3\xda\xf0\xd2\x6a\x29\x6f\x1e\xbd\x9a\xdf\x48\xcf\x26\x38\xd2\xa3\x19\x8e\xf4\x6b\x8a\x23\xbd\x9b\xe3\x48\x9f\x26\x39\xf2\xd9\x2b\x40\x6f\x1e\x3d\x9b\x8f\x48\xef\x56\x3a\xf2\x02\xeb\x49\x6f\x1e\x9f\x00\xdc\x7d\x5a\xec\x48\xac\x4e\xdd\x79\xf4\x6d\x50\x23\x7d\x1b\xd5\x48\xdf\x78\xd8\xaa\x0a\xf6\xe6\x11\xeb\x63\x7f\x02\x39\xad\x37\x21\xa2\x6b\x4d\xed\xc7\x16\xda\x03\x4e\x56\x5d\x7d\x3f\x97\x02\x64\xb9\x74\xdd\x4a\xd6\xbc\x3b\xe8\xd5\x85\xa1\x9a\x61\xcb\x53\x1f\xb7\x8a\x18\x8d\xbf\xa7\xde\xe0\x55\xf2\xa0\x78\x5c\x30\xd9\x4a\xeb\x98\xda\x74\x56\x35\x8f\x31\x4a\x41\xdd\x74\x2a\x78\x18\xef\x1d\xd9\x70\xd2\x5a\x9a\xe0\xe9\x72\x80\x69\xfd\x04\xea\x17\xb6\xd1\xed\x9e\xb7\x63\xef\xab\xfa\x8e\xbd\x51\xd8\x13\xd7\xcd\x78\xf0\x7f\xfe\xef\x61\xa3\x7a\x4b\x3d\xa1\xa3\xca\xd5\xd9\x19\x83\xa6\xc3\x0c\xe6\x90\xe1\x3a\x7c\xc3\xe5\x99\x40\x8b\xb1\x2d\x7b\x1a\x18\xa4\x2e\x96\x77\x94\x4c\x80\xea\x52\x62\x05\x51\xe0\x74\x9c\x75\x3f\x2b\x51\xc1\x8c\x0a\xe6\x76\x23\x2a\x98\x1b\x47\x54\x30\x3b\x8c\xa8\x60\x6e\x37\xa2\x82\xb9\x79\x44\x05\x33\x2a\x98\x2d\x46\x54\x30\xa3\x82\xd9\x76\xfc\x86\x15\xcc\x7e\x03\xa7\x43\x75\xcf\xc5\xa1\xa0\xfc\xa8\xa9\x66\x49\x1d\x54\xed\xef\xb2\xff\xea\x57\xcd\x0c\x55\xc8\xf5\x4a\x66\xa8\x88\xae\x28\xda\xa3\x47\x34\xca\x4a\xe7\x5c\x79\xf2\x41\x65\xf3\xb5\xc5\x86\xf7\x86\x88\x81\xd3\xb9\x57\x4c\xbc\xf1\xa1\x6b\x75\x6b\xf7\x2a\xae\x2d\x25\x07\xde\xdb\x8f\xad\x5a\xb8\xd0\xcd\x8b\x5c\xb3\x61\x7d\x47\xe5\xff\xc7\xb0\x9d\x46\xc5\x80\x86\x93\xba\x8a\x92\xab\x22\xb0\x6a\xe4\x31\xd4\x11\x64\x63\x0d\xd8\x1a\x77\xc2\xb8\x8d\xa5\xf4\x6d\x85\x04\xf7\x61\x59\x96\x9c\x22\x01\xf4\x68\x6e\x25\x5f\x5c\x0f\x8a\xbf\x35\xec\x82\x38\x22\x8a\x67\x8c\x72\x97\x6e\x2b\xb8\xef\x7b\x6f\x7b\xd9\xd7\xe2\x72\xd5\xad\xa5\x7a\xfb\x88\x9c\x21\xd2\x87\x13\x33\x85\xf0\xa1\xb6\xc3\x4a\x3f\x26\x8a\xe7\x55\x1a\xe2\x6e\xe7\xd2\x10\x4b\x31\x29\xb1\x32\x44\xac\x0c\xd1\xa9\x32\x04\x5e\xb4\x87\xbb\xf7\x12\x11\xe4\x47\xd7\x80\x49\x02\x82\x2a\x2f\x33\xcd\x8a\x3a\xc6\x5b\xd9\x57\x65\x56\x91\x98\xb8\x58\xd3\x26\xbe\x9b\xb7\xd1\x64\xb6\x8c\xf7\x38\x1f\xc6\x84\x2b\x24\x27\x2e\x9e\x13\xdb\x25\x61\x4d\x03\xaf\x75\xd8\xa0\x55\xf6\xf2\x63\x11\x4f\x91\x60\xab\x5a\x69\xb6\xdd\xbc\x0c\x9d\xcf\x0c\x4a\x18\x8a\xfd\x00\x83\x08\x5b\x66\x60\x5c\x2c\x9b\x03\xaf\xb9\xc4\x81\x3a\x3c\xf4\xc2\x50\xaf\xdc\xeb\x93\x70\x9f\x3f\x07\x5c\xe2\x3f\xb7\xe1\x3f\xf8\x41\x15\x07\xaa\xc1\x57\xf3\x9f\x97\x1d\x74\xd9\x3d\x7e\xae\x0f\x83\x5c\x6f\x71\x73\x4f\x1e\x33\xf7\x5b\xaa\xae\xf1\x2c\x5d\x18\xcf\x4e\xeb\x78\x1d\x6e\x8b\x98\x92\xba\xfd\x78\x09\x29\xa9\x4f\xe4\x9a\x78\x39\x99\xa9\x2f\xd6\x1d\xf1\x52\x32\x53\xa3\x0b\x62\xa7\xf1\x5a\x13\x46\x9b\xa3\x47\x97\x43\x74\x37\xf4\x2c\x53\xf5\xc2\xfc\x3f\x8d\x9b\xa1\x17\xfc\xeb\x35\x7e\x2d\xc6\xae\xbd\xf2\xd8\xb5\xa8\xe8\x45\x45\xaf\x39\xa2\xa2\xb7\x32\xa2\xa2\xb7\xc3\x88\x8a\xde\xe6\x11\x15\xbd\xd5\x11\x15\xbd\xa8\xe8\x6d\x31\xa2\xa2\x17\x15\xbd\x6d\xc7\x6f\x4c\xd1\xeb\xaf\x68\x7c\x8c\x21\xeb\x3f\x86\xac\x1f\x42\xd8\x03\xf9\xeb\x05\xe9\x7a\x8a\x19\x8b\xf1\x62\xcf\x3b\x5e\xac\x63\xe9\x3c\xae\xd9\xa7\x29\x9f\x17\xee\xf6\xa6\x1a\x7a\x74\x2e\x58\x4a\x8a\x52\xbb\x0a\x62\xb1\x8e\xde\x73\xae\xa3\xd7\xd8\xd1\x58\x4c\x6f\xab\x62\x7a\x9b\x60\x16\x2b\xea\x6d\x18\xcf\x27\x8a\x2d\x56\xd4\xdb\x75\xc4\x8a\x7a\xeb\x47\xac\xa8\xf7\xc0\x88\x15\xf5\x62\x45\xbd\x58\xf0\xa0\xc3\x88\x05\x0f\xd6\x8c\x58\xf0\xa0\xfd\x88\x05\x0f\xb6\x1a\xb1\xe0\x41\x2c\x78\xd0\x1c\xd1\x09\xd5\x6d\xc4\x82\x07\x1d\x47\x74\x4c\xc5\x82\x07\x9d\x26\x8c\x15\xf5\x62\x54\xe2\xee\x23\x2a\x98\x51\xc1\xdc\x6e\x44\x05\x73\xe3\x88\x0a\x66\x87\x11\x15\xcc\xed\x46\x54\x30\x37\x8f\xa8\x60\x46\x05\xb3\xc5\x88\x0a\x66\x54\x30\xdb\x8e\xdf\xb0\x82\x19\x2b\xea\x3d\xf7\x68\x48\xf2\x1c\x53\x9e\x62\x45\xbd\x18\x21\xd9\x6a\xbb\x63\x45\xbd\xc7\xc7\x6f\xbe\xa2\x5e\x23\x5a\xef\xe9\xca\xea\xed\xbe\x8c\x58\x5b\x2f\xd6\xd6\x8b\xb5\xf5\x62\x6d\xbd\x58\x5b\x2f\xd6\xd6\xdb\x7e\x3c\x7f\x67\xc6\xb3\xd3\x3f\x5e\x87\x03\x23\x96\x5c\xd8\x7e\xc4\x92\x0b\x1b\x47\x2c\xb9\x10\x4b\x2e\x44\x67\x44\x9b\x11\x4b\x2e\xec\x38\xa2\xe3\x21\x96\x5c\xd8\x69\xc4\xda\x7a\x31\x8a\x6d\xfb\x11\x15\xbd\xa8\xe8\x35\x47\x54\xf4\x56\x46\x54\xf4\x76\x18\x51\xd1\xdb\x3c\xa2\xa2\xb7\x3a\xa2\xa2\x17\x15\xbd\x2d\x46\x54\xf4\xa2\xa2\xb7\xed\xf8\x8d\x29\x7a\xb1\xb6\xde\x73\x8e\x26\x8b\xb5\xf5\xd6\x8c\x18\x39\xf6\xbc\x23\xc7\x5a\xe2\x0a\x2d\xb5\xc8\x45\xc9\xf5\x35\xc8\x39\x4b\xe0\x38\x49\xcc\x5f\x37\xe2\x16\x76\x8c\x56\x6a\x6a\xa1\x0f\x4c\x4b\x18\x4f\x59\x82\x7a\xe4\xdd\x0c\xb0\x34\x9e\x11\x6f\xf1\x3e\x42\xed\x8d\x44\xe3\x9d\x35\x7a\xe1\x3a\x0d\x4d\xc3\x10\x1e\x9c\x7a\x57\x78\x59\x08\x8d\x85\xc8\x80\xf2\x1d\x9e\x74\xcc\x10\xe4\x8e\xa7\xb9\x01\x90\xf7\x8e\x12\xd7\x93\x91\x31\x64\x82\x4f\x5d\xc4\x90\x3b\x01\x23\x72\x52\xdf\x90\x50\x8e\x87\xa7\x94\x12\xb8\xce\x16\x08\x07\x2c\xd2\x85\x4a\x43\x2e\xe6\x90\x22\xc5\xc6\x40\x25\x2b\x46\x52\x4d\x32\xa0\xe6\x5d\x1c\xea\x97\x99\xc3\x43\xc9\x25\xce\x6f\x27\x1d\x83\x0b\x9e\x6a\x05\xc4\xdd\x69\x63\x2b\x6a\xb8\x64\xd8\x70\x52\x13\xb2\xa5\x04\xd5\xa3\xe0\x0b\xf1\x68\x2e\x44\x49\xee\xa8\x15\x94\x64\xc9\xf1\x30\xe3\xa7\x1b\xd0\xee\xf8\xf2\x0e\x22\x49\x7b\xeb\xc3\x10\xa9\xda\x8e\x8f\x75\xb1\x06\x50\x39\x6d\xc5\xa4\x1a\x5b\xb3\x7f\x2c\xa7\xa5\x95\x08\x1d\x2a\x03\xd7\x72\x81\x11\x7d\x56\xa4\x48\x45\x72\x6b\xd0\x30\xa7\x53\xd8\xdf\x57\xe4\xe4\xc3\xa9\xa1\x7d\xa5\x32\xa4\xda\x95\x09\x74\xb4\xb0\x90\x62\xce\x52\x83\xd9\x3f\x50\xc9\xe8\x38\x33\x32\xe7\x04\x24\x70\x23\x12\x7c\x79\xf0\xc3\xf1\xd5\x2f\x17\xc7\x1f\xce\x0e\x51\xfa\x84\xfb\x82\x72\x73\x24\x4a\x55\xc7\xa1\x3a\x9c\x30\x2f\x02\x3e\x67\x52\x70\xb3\x38\xd4\xd3\x28\x99\xfb\x59\x93\xea\x24\x48\x50\x22\x9b\x43\x6a\x65\xe4\xea\x6d\x9e\xe5\x30\x5e\x94\xda\xeb\x8d\x18\x1d\x69\x4e\x0f\x4f\x66\x94\x4f\xcd\x3a\x4f\x45\x69\xe6\xfb\xf2\x4b\x5c\x91\x84\xb4\x4c\xac\xd4\x44\x3d\xca\x7e\x39\xf0\x6c\xc2\x10\x7a\x65\x6b\x3a\xaa\x84\x16\x7e\xcd\xe1\x67\xa9\x05\xd7\xf4\xfe\x9d\x0d\x0f\xdc\xfb\x32\xb8\xb4\xe7\xeb\x61\x0a\xf3\x0a\xcb\x6c\xec\xaa\x32\x2c\xc5\x98\x91\xbd\xf0\xee\x11\x39\x33\xef\x80\x34\x04\xa0\x8d\xee\x84\x39\x48\xd4\x3a\x1d\xf8\x06\x44\xc2\x94\xca\x34\x03\x85\x71\x8d\x9e\x30\x5b\xcd\xc0\x01\x0c\x2a\x9d\x96\x0b\xbd\x8e\x92\x90\x0f\x02\x63\x1c\x27\xe2\x1d\x99\x69\x5d\xa8\x77\x47\x47\xb7\xe5\x18\x24\x07\x0d\x6a\xc4\xc4\x51\x2a\x12\x75\xa4\xa9\xba\x55\x47\x8c\x9b\x93\x35\x4c\xa9\xa6\xc3\xe0\x48\x1f\x59\xb6\x3d\x4c\x44\x9e\x53\x9e\x0e\xa9\x43\xad\x61\xb5\xad\x47\x5f\x38\x86\x3a\xa4\xd5\x5d\x8c\x0f\xe9\x50\xcd\x20\xcb\xf6\x5b\x20\x73\x37\x81\xaf\x83\xa0\xd7\x49\xc0\x73\xdf\xde\xfd\xf4\x9e\x55\x87\xd5\xc2\x60\x44\x2e\x84\x76\xe1\xb7\x2e\xd2\x1b\x89\x28\xc2\x77\xfd\x79\x3e\xbb\xb8\xb9\xfa\xeb\xe5\xc7\xf3\x8b\x9b\x78\xac\xe3\xb1\x8e\xc7\xba\xc3\xb1\x06\x3e\xef\x7c\xa4\xbd\xb4\x19\x1c\x93\x6a\xbf\x91\x47\x2b\xd0\xfe\x18\x54\x1b\xd0\x59\x36\xb4\xe3\xc9\xa0\xde\x80\xc0\x19\x9f\xff\x40\x9b\xa6\x75\xbe\x16\x1c\xc4\xdd\x60\x45\xe4\x4a\xfa\xee\x12\x7b\xdf\xc1\x8c\xd5\xd5\x6f\xd5\x4a\x7e\xb4\xa3\xbb\x4f\xc9\xbc\xba\xbd\x89\xa1\xb1\x7d\x17\x34\xaf\xeb\x6b\xaf\xd9\xb5\x11\xf9\xe0\x15\x1e\x72\xf2\xcb\xf9\xe9\xd9\xc5\xcd\xf9\x37\xe7\x67\x57\xed\x35\xe8\x1e\x6c\x2d\x68\x4d\xe8\x09\x00\xfb\x2d\xb9\x64\x21\x61\xce\x44\xa9\xb2\x45\x65\xff\x58\x4f\x04\x96\x4f\xbf\x73\xf8\x2e\x2a\x4d\x7c\xed\x63\x91\xd9\xf6\xcb\x6c\x4f\x61\x42\xcb\xcc\xea\x4d\x7b\x7b\xa3\x36\x5c\xce\x8e\xbe\xd0\xf7\x1b\x29\x3a\xd4\x8f\x6e\xa0\xf0\xb5\xad\x3c\x3f\x11\x72\xe3\x31\xde\x77\x61\x07\x0d\xd6\xe3\x84\x47\x6b\x9b\x73\xd2\xa3\xf5\x8e\x75\x84\x4e\x47\xf7\x42\x3f\x4e\xf7\x44\xf0\x09\x9b\x7e\xa0\xc5\x77\xb0\xb8\x82\x49\x37\x03\x71\x13\xde\x68\x77\x74\x3e\x64\xb4\x52\x1a\x76\x66\x5f\xd6\xcd\x3f\xd3\x9b\x77\xa6\xaf\xb0\x8c\xee\x21\x19\xfd\x45\x50\xf4\x12\x3d\xb1\x52\xcd\xdf\x5a\xa0\x9d\x2d\xb9\xaf\xe0\x9a\x5e\x5c\xf6\xdd\xb8\xbc\x1f\x4d\x66\x17\xb2\x7b\x47\x67\xf5\xb6\x6a\x47\x22\x78\x02\x85\x56\x47\x62\x6e\x38\x17\xdc\x1d\xdd\x09\x79\x6b\xf4\x08\xa3\xb8\x0e\x2d\xd6\xaa\x23\xf4\x16\x1c\x7d\x61\xfd\x5f\x37\x1f\x4f\x3f\xbe\x23\xc7\x69\xea\x5a\xb3\x94\x0a\x26\x65\xe6\x9a\x21\x8c\x08\x2d\xd8\x0f\x20\x15\x13\x7c\x40\x6e\x19\x4f\x07\xa4\x64\xe9\xd7\xed\x89\xb3\x1f\x3d\xee\x82\x28\xac\x8f\xb3\xe7\x9d\xb8\x46\xef\xca\xa2\xc1\xbb\x2a\x22\x62\xb8\x16\xd3\x0a\x71\xd3\xdb\x9b\x9d\x90\xd1\x13\x68\x76\x37\xce\x2f\x0f\xdc\xc2\x7e\xe9\xea\x7e\x4d\x58\xad\x6f\xd3\x21\x6a\x21\xd2\x77\x44\x95\x45\x21\xa4\x56\x24\x07\x4d\x8d\xd2\x3b\x32\x18\x36\x68\xfe\x89\x5e\xaa\x01\xf9\x7b\xf5\x23\xba\x9a\xd4\x4f\xfb\xfb\x7f\xfe\xee\xec\xaf\xff\xb9\xbf\xff\xf3\xdf\xc3\xab\xc8\x0a\x6d\xf8\x4f\xf3\x16\x55\x40\x32\xe2\x22\x85\x0b\x7c\x07\xfe\xa9\x1a\x0e\x16\x77\x41\x53\x5d\xaa\xd1\x4c\x28\x7d\x7e\x59\xfd\x59\x88\x74\xf9\x2f\xd5\x41\xe2\x20\xcf\x93\x31\xe0\x16\x5d\x52\x3d\x7b\x26\xec\xa1\xa6\x25\x3d\x1f\x55\x37\x6b\xd8\x02\x28\xa7\xf8\xcf\x6f\x3c\x08\x8c\xf4\x74\x27\x99\xd6\xe8\x74\x73\x69\xe6\x62\x32\x30\xa7\xb6\x16\x3b\xe7\x6f\xf7\x9e\x15\x83\xa9\x76\xb0\x67\x80\x21\x44\x1c\xb4\xec\x41\xae\x18\xec\xaa\x73\xf9\xf8\xf2\x9c\xcc\x2d\x84\x9f\x0d\x70\x7c\xea\xf0\x37\x9f\x94\xc6\x55\x2d\xa3\x1c\xa8\x2a\x0d\xf1\x9d\x8d\x06\xaa\x12\x98\x49\xc6\x72\xe6\x82\x0c\x5d\x7b\x29\x45\x0e\xec\x8f\xa3\xa4\x28\x07\xee\x86\x51\x0e\xb9\x90\x8b\xea\x4f\x28\x66\x90\x1b\x4d\x6b\xa8\xb4\x90\x74\x0a\x83\xea\x71\xfb\x58\xf5\x97\x7d\xb0\xf1\x82\xd5\xa7\xad\x2a\x5c\x3b\x49\x1d\x45\x86\xf4\xf5\xd1\x36\x0f\xfa\x67\x42\xda\x2a\xcc\xb8\xf8\x04\x22\x61\x65\x89\xb3\x02\x67\x05\x45\xd4\x27\xe7\x22\x2b\x73\x50\x83\x4a\x0c\xb2\xd6\x00\x3e\x37\x9a\xa5\x7a\x56\x82\x5a\xca\xe6\x4c\xf5\x11\x3f\xbc\x46\x4e\x63\x2e\x14\x5f\x94\xba\x28\xb5\xab\x65\x13\xb4\xa5\x13\x0a\xed\x16\x55\xc1\x81\x06\xd9\x7f\xdb\xb5\xe0\x16\x21\x05\xd5\x1a\x24\x7f\x47\xfe\xfb\xe0\x6f\x5f\xfd\x3a\x3c\xfc\xfa\xe0\xe0\xa7\x37\xc3\xff\xf8\xf9\xab\x83\xbf\x8d\xf0\x1f\xff\x7a\xf8\xf5\xe1\xaf\xfe\x8f\xaf\x0e\x0f\x0f\x0e\x7e\xfa\xee\xc3\xb7\x37\x97\x67\x3f\xb3\xc3\x5f\x7f\xe2\x65\x7e\x6b\xff\xfa\xf5\xe0\x27\x38\xfb\x79\xcb\x49\x0e\x0f\xbf\xfe\xb2\xf3\xd2\x29\x5f\x7c\xec\x48\x40\xed\x18\xf6\x56\x8a\x68\x79\xc6\x9e\x02\xac\xef\x87\xb5\xd2\x34\x64\x5c\x0f\x85\x1c\xda\xa9\xdf\x11\x2d\xcb\x6e\xc4\xa4\x66\x4a\x7d\x9f\x7f\xdf\x7b\xec\x5d\xcd\x90\x2a\x76\xfd\x6c\x0e\xb8\x82\x44\x82\xfe\x1c\x96\x1c\xfb\x26\x2f\xa7\x2c\x05\x3b\xbe\x36\x3e\xf7\x5b\x30\xee\x54\xc1\x82\xb8\xaf\xb5\x24\x3a\x91\x22\x1f\x91\xc0\xbd\x31\xc7\x4c\x0f\x77\xdf\x2d\x74\xb0\x82\xfa\x11\x8d\x41\xd1\x18\xb4\x61\x3c\x6a\x0c\xba\xb6\x78\xf8\x6c\x2d\x41\xc0\xe7\x6d\x5d\x18\x6b\x3d\xe8\x5e\xd7\xd1\x82\x14\xa2\x28\x33\xaa\x37\x78\xc6\xd6\xb8\xd3\xdd\x51\xaf\x23\x91\xeb\x48\x1a\xcb\xd0\xf2\xf5\x3e\x4c\x72\x9c\x65\x84\x71\x7b\xf0\x71\x02\xef\x30\x93\x60\x55\x1b\x42\xad\x3f\x7b\x6e\x96\x70\xe7\x4a\xd6\x85\xe1\x9e\x8a\x28\x4d\xa5\xc6\xa8\x63\x2c\x69\x67\x59\x89\xf3\x3e\x31\x5e\x17\xb6\xab\x84\xc3\x2a\x09\x64\x6d\x5f\xcf\x8c\x2a\xed\x97\x8d\xab\xd1\xf4\x16\xbd\x8d\x09\xa4\xc0\x13\xc0\x8c\xb4\x12\xea\x6f\x1d\x1b\xbd\x8d\x9c\xf1\xb9\x9d\x83\x92\xb4\xb4\xc1\x20\x96\xfc\xad\x9f\xe3\x75\x05\x20\x18\x44\xbc\xf6\xed\x97\xab\x38\x04\xa4\xfa\x95\x86\x5d\x25\xf6\x55\x56\x56\xf5\x34\x91\x07\xdd\x79\x66\xe5\xd9\xea\x24\x0c\xad\x30\xcb\xda\xfc\xdc\x64\x92\xaf\xc1\x19\xd8\x9d\x7d\xfe\xe6\x58\x67\x4f\x6c\xb3\x1f\x96\xb9\x83\xef\xa4\x4f\x36\xd9\x87\xb3\xa4\x90\x30\x61\xf7\x3d\x9d\xd3\x63\x5e\x5b\x62\x58\x0a\x5c\xb3\x09\xb3\x1d\xfb\x0b\x09\x05\xf0\xb4\x2a\x8a\x8a\x59\xe1\xbc\x09\x9b\x67\x19\xcc\x63\x05\xee\x7e\x49\xd9\xf5\x3a\x61\x3f\xd2\x31\x12\xe9\x58\xeb\xf1\x99\xe8\x98\xc3\xdc\xe7\x43\xc4\x30\xf2\xbc\x7b\xe8\xfb\x69\x10\xc7\x8e\x58\xbc\x33\x96\xd5\x09\x5d\x47\x38\x8b\x5a\xaa\x1e\x54\xd1\x45\x2d\x6c\xe4\x1a\x99\xb1\xa9\x01\xab\xad\x28\x64\x85\x26\x92\x53\x4e\xa7\x36\xab\x5b\x0b\x6f\xa7\x35\x5a\x96\x41\x62\xc9\xd2\x86\x70\x6f\x5f\xc3\x38\x31\x88\x9d\x09\x9a\xe2\x45\x29\xb2\x0c\xa4\x22\x19\xbb\x05\x72\x0a\x45\x26\x16\x2e\x49\x9b\xa7\xe4\x5a\x53\x6d\x50\xfa\x1a\x74\x3b\x9f\x6f\x27\x74\xc5\x15\x5f\x96\x59\x76\x29\x32\x96\xb4\xb2\xa8\x34\xb7\xed\x1c\xf7\xab\x28\xb3\x8c\x14\x38\xe5\x88\x7c\xe4\x48\x31\x8e\xb3\x3b\xba\x50\x03\x72\x01\x73\x90\x03\x72\x3e\xb9\x10\xfa\xd2\x8a\xde\xcd\x68\x3b\x7b\x23\x61\x13\xf2\x0e\x6b\xda\x68\xa2\xe9\x14\x15\x27\xef\x03\x1c\x18\xf8\x87\x13\x58\xe2\x70\xc7\xd4\x5a\x4d\xa5\x33\xe2\x7c\x81\x33\x19\x42\x65\xff\xfe\xec\xdb\x94\xb1\x09\x24\x8b\x24\xeb\x7e\xae\x8e\x13\x8c\x5e\xa8\xf3\xcc\x03\xfc\x76\x65\xda\x5d\x6a\x27\xaa\x80\x8c\x13\x5b\x3f\xdd\x16\x86\xaf\x51\xbd\x5a\x91\x55\x75\x55\xaf\x1a\x62\x6b\xce\xd9\x95\x67\x16\x42\xe9\x6b\xa3\x9e\xf7\x52\x65\x7d\xff\xd2\x4f\x47\xb0\x96\x74\x96\x41\x4a\x58\x9e\x43\x6a\x54\xf8\x6c\x41\xe8\x44\x63\x8a\x6d\xc3\x3c\x90\x48\xb0\x58\xeb\x6a\x97\xcc\x28\x4f\x33\x90\x64\x42\x59\xe6\x8c\x01\x8d\xfb\x35\xc8\x9c\x71\xb4\x09\x58\x77\x2c\xda\x17\xcc\x5f\x49\x22\xa4\xaf\x7b\xcf\xb4\xf2\x97\xea\x83\x89\x4c\x24\x40\x80\x65\xbf\x32\x19\x67\x22\xb9\x55\xa4\xe4\x9a\x65\x76\x31\x42\xdc\x92\x44\xe4\x45\x86\x47\xa7\xc3\xc9\xaa\xfe\x39\xac\x50\x69\x68\x66\x57\x47\x5f\xd4\x97\xf0\x87\xb6\xdc\xbc\x07\x29\xac\x0f\x19\x0c\xee\x21\xe9\x2d\xbd\xdf\xd0\x52\xb3\xcb\xe8\xef\x17\xbc\x12\xc5\x26\xc2\x30\x30\xb3\xd7\x75\x62\x76\x45\x2e\x47\xe4\xec\x1e\x92\xa0\x0a\x05\xf6\x87\x40\x42\x80\x59\xa1\xf4\x16\x5e\x51\xd9\xbb\x0e\xc9\x77\xe1\x68\x80\xfd\xc4\xce\xe9\xab\x66\xb9\x57\x90\x8c\x71\x24\x8b\x2e\x21\x8f\x30\xae\x8c\x40\xd0\x38\x43\xf6\xc4\x3a\x41\x97\xa4\x4c\x62\xcd\x84\x45\x15\x7c\xed\xe7\xc2\x72\x04\x42\x68\x72\xb0\x7f\xb4\x7f\xb8\x62\xb3\xdc\x37\x82\x4b\x06\x96\x44\x5b\x03\x66\x52\x2f\x4a\xb1\xbc\xc8\x16\xb8\x8e\xfd\x74\x40\x98\xf6\xd1\xd9\xb2\xe4\x7e\x55\x2e\x4b\x70\x40\x94\x20\x5a\x52\x5f\x8a\xc5\xfe\x6a\x6e\xd2\xb2\x74\xcc\xe1\x60\xff\xd7\xfd\x01\x01\x9d\x1c\x92\x3b\xc1\xf7\x35\x2e\x7f\x44\x6e\x84\x11\xbf\xeb\x89\x16\xa2\x24\x1c\x6c\x32\x00\xdc\x17\x19\x4b\x98\xce\x16\x48\xe8\x88\x28\xb5\xcd\x38\xa6\xda\x67\x27\x9e\xdd\x33\xed\x62\xdc\x0c\xda\xbe\x41\x68\x5a\x62\x47\xa8\x91\x8e\xe6\x70\x34\x03\x9a\xe9\x99\x0d\x2c\xe1\x82\x0f\xff\x09\x52\x60\xde\x22\x77\x57\x5e\x5d\x89\xc0\x5e\xb4\x0d\x43\x7b\xbf\x85\xfe\x9a\x0a\xfd\xe5\xe6\xe6\xf2\x5b\xd0\x4b\x24\xc3\xbc\xc5\x87\xfb\xa0\x05\x01\xe4\x44\xc8\xfc\x19\xd0\x8e\x7e\x1c\x9c\x43\x52\x08\xf9\x1c\x48\xd8\x4c\xa8\x4e\x7b\x49\x56\xf6\x53\x28\x8d\x4a\x94\x13\xe2\x38\x24\x66\x07\x9b\x71\x27\xbe\xef\xce\xf9\xe5\x88\xfc\x55\x94\xe6\x6b\xc6\x74\x9c\x2d\xaa\xba\x0d\x0a\x34\xd9\x33\x53\xed\x19\xf2\x64\xb0\xe1\x2f\x40\x53\xa3\xd9\x18\xea\x01\xf4\x79\xf4\xd7\x22\xee\x3c\xb8\xb5\xf5\xcb\x07\x4a\xa5\x45\x4e\x66\xee\xb3\x9b\xe9\x9a\xee\x64\x8c\xf0\xf4\xf8\x5c\x28\x09\x85\xa5\x70\xee\x99\x57\x47\xbf\x56\xe8\x86\x85\xbb\xfb\x7d\x8c\x35\xaf\x92\x10\x6c\xae\xc1\x94\x4d\x26\xe2\x16\x58\x06\xd5\xa0\x9d\x7b\x25\x1c\xcf\xb8\x50\x69\xeb\xe4\xcf\xe5\x89\xd0\x11\xd8\x3d\x3e\xac\xd7\x32\xa5\xfd\xc4\x1a\x90\x75\x86\x59\x87\x33\xd6\x68\xd3\x13\x10\x3f\x4d\x9d\xcc\xcf\x01\x80\x7e\x36\x9f\xf4\x09\x81\xa2\x87\x70\xf0\xd5\x60\x70\x2d\x8c\xfa\x8a\xe9\x9a\x96\xb8\x22\x99\x50\x20\xe7\x6d\x13\xc0\xeb\xd1\xdf\xa7\x8b\xf6\x86\x02\x3f\xd6\xe4\x56\x4b\xc2\xcb\x7c\x0c\xb2\xce\x66\x91\x7a\x15\x20\x41\x34\xc3\x85\xbd\xdd\x9b\x80\x9b\xed\x1c\xcd\x93\x7f\xfa\xb7\x7f\xfb\xc3\xbf\x8d\xec\xf4\x55\x64\x03\x27\xe7\xc7\x17\xc7\xbf\x5c\xff\x70\x82\x09\xb5\x5d\xa1\xda\x53\xd8\x66\xdf\x41\x9b\xbd\x86\x6c\x7e\xd2\x80\x4d\x4c\x13\xe9\x4c\x45\x9a\xfe\x02\x9c\xd2\x60\x80\xd1\xdb\x8c\xc6\xe9\x64\xbf\xa0\xb4\x99\x91\x35\x9b\xf6\x57\x73\xd4\x9e\xc5\x19\xd3\x49\x71\x2d\x92\xdb\x1e\xf5\x9a\xfd\x9b\x93\x4b\x3b\x65\x58\x93\x93\x7b\x63\x08\xe3\x73\x91\xcd\x6d\x39\xdf\x9b\x93\x4b\x3c\x79\x23\xfc\x17\x1a\xa2\x50\xa3\x5e\x98\x67\x7d\x22\x83\x73\x4f\x19\xed\xdb\x5a\xd0\x28\x91\x40\x33\xa6\x34\x4b\xf0\xb9\xda\x4c\x6a\x66\xe8\xe2\x97\x8a\x9a\xd2\xba\xd1\xbb\xa6\xb4\xff\xd1\xbb\xed\x76\x56\x9a\xba\x06\x1e\x3e\x63\xbe\xe4\xf8\x91\xcd\xf8\x88\x7c\xe9\x37\xc1\x97\x0a\x09\xd7\x5a\x14\x3d\x79\x42\xec\x64\x1b\xfc\x20\x63\x98\x08\x09\xcb\x8e\x90\xc0\xb1\xe1\x1b\x0c\x73\xcc\xfe\xf3\x26\x28\xd1\x70\x5e\xd8\x90\x4b\x55\x26\x33\x6f\x4d\xe4\xa0\xd4\x11\xba\x3c\xca\xc2\xaa\x98\xe8\x44\x29\x25\x0c\xcc\xd7\x41\x8e\xab\x1b\xd4\x69\x0c\xe6\xf5\xc0\xed\x8f\xa0\x13\x6b\x66\xf5\xfe\x17\x67\x51\xf5\xcb\x5f\x76\x95\x24\x92\xaa\x19\x60\xfd\x10\xb8\x67\x75\x9f\x13\xaa\x04\xb7\xc6\x5e\xf7\x39\xc8\x68\x14\x29\xa8\x52\x75\x05\x67\xf7\x12\xfb\xd0\xa5\x48\xf7\xf7\x55\xe3\x81\xa9\xa4\x09\x90\x02\x24\x13\x29\xc1\x7c\xe2\x54\xdc\x71\x32\x86\x29\xe3\xca\xc3\xcf\x4c\xe4\x01\x6d\xd8\x8d\x2d\xb6\xeb\xab\xc5\x8d\xc8\x55\xa3\x08\x8a\x4b\x4f\x4a\x44\x7d\xa2\xdd\x2a\x96\x9d\x4c\x18\x11\x1a\xb4\x69\xae\x36\xc6\x87\xcd\xea\xc7\x17\xdd\x83\xb7\xc9\x80\xb6\xbe\xb6\x11\x3a\x58\x9c\x9f\x26\xb3\x6e\x8e\xdf\xe8\x9e\xda\x72\x44\xf7\xd4\x6e\x23\xba\xa7\xa2\x7b\x6a\xf3\x78\x76\xe6\xdd\xe8\x9e\x8a\x4a\xd7\xf2\x88\xee\xa9\xe8\x9e\xda\x30\x9e\x1d\xfd\x8a\xee\xa9\x2d\x46\x74\x4f\x6d\x39\xa2\x7b\x2a\xba\xa7\xa2\x7b\x2a\xba\xa7\x7e\x43\x66\x40\x3f\xa2\x7b\x6a\x65\x92\xe8\x9e\x0a\x80\x11\x35\xa5\x35\x23\xba\xa7\xd6\x8c\xe8\x9e\x0a\x46\xe4\x4b\x2d\xf8\x92\x77\xee\x5c\x1a\xbd\xac\x7b\xce\xda\x25\x3a\x0e\x58\xe2\x7c\x44\x61\x2f\xb8\xea\x55\x41\xfb\xb7\xa0\xe6\x87\x4f\xb5\x71\xde\xa0\xda\xc7\xb4\x36\x1f\x6a\x57\x77\x84\x4f\x22\x54\x47\x85\xb0\xff\x57\x3b\x23\x02\x2f\x84\xd5\x4e\xdb\xe7\xa4\x3d\x59\xb6\x55\x17\xd7\xc3\xb3\x76\x3b\x3c\x13\xd7\x4e\x0f\xae\x86\xe8\x66\x78\x75\x6e\x86\xd7\xd3\x43\xd7\x39\xf3\x6f\x66\x12\xd4\x4c\x64\xad\x11\xbd\x81\xe4\x1f\x18\x67\x79\x99\x1b\x9c\x53\x06\x9f\xd9\xbc\x8a\x1a\x50\x15\xba\x5a\x42\x6f\x2d\x85\xe6\x46\x96\x02\x16\x40\xa5\x2c\x33\xdb\x88\x69\x9d\x33\x8a\xa2\xba\x2a\x93\x04\x00\xdb\xab\x85\x5a\xcc\x1f\x46\xd5\x9b\xaa\x76\x1a\x6f\xbb\xd1\x9b\x6e\xbc\xdf\x96\x28\xc5\x59\xfe\xf0\xfb\x56\x73\x74\xf4\xf2\x7c\x7e\x0f\x4f\x0f\x64\xba\xbb\xbe\xd2\x49\x57\xe9\x83\x4b\x74\xd5\x51\x5e\x9a\x27\xa7\x37\x8f\x66\x0f\x1e\x9c\x67\xe4\xbd\x79\x36\x6c\xe1\xb9\x78\x6c\x9e\x61\xf5\xd5\x1e\x1c\x0c\x7d\x78\x68\xfa\xf3\xce\x7c\x82\x22\xa5\x9f\xc6\x2b\xd3\xa3\x36\xdc\x93\x37\xe6\x73\x78\x62\x7a\xf9\xea\xae\x1e\x98\xcf\xe7\x7d\xe9\xe7\x73\x3b\x5a\xb7\x5e\x85\xc7\xa5\x07\xab\x56\x9f\x16\xad\xde\xac\x59\x9f\xcc\xc3\xd2\xdd\xbb\xf2\x0c\x3c\x2b\x9d\x81\xcc\x38\xd3\x8c\x66\xa7\x90\xd1\xc5\x35\x24\x82\xa7\xad\x39\xcc\x52\xd5\xba\xea\xfc\x28\x3b\xad\xd3\xd1\x9a\xf1\xc7\x33\xea\x8a\xf3\x42\xea\x43\xaa\xbd\xf9\xcf\x09\x14\xd8\xd0\xc4\xae\xf2\x59\x1a\xf4\xc8\xb3\x51\x06\x6d\x30\x76\x9f\x9b\xf8\x17\x71\x47\xc4\x44\x03\x27\x07\x8c\xfb\x7d\x3c\x0c\xd4\xc0\x5a\x33\xaf\xd0\xda\x5c\x7d\xfb\xc6\xdf\xfc\xfa\x54\x6e\x34\x2e\x28\xf5\xe9\x2d\x20\xee\x45\x8f\x9b\x40\xdc\x8d\x93\x32\x6b\x9a\x41\xac\x69\xa4\x49\x6f\xde\xd6\xe5\x45\xdf\xe2\xbc\xd5\x69\xa3\x3c\x25\x2e\x71\xe3\xf5\x6d\x5a\x67\xbf\xf1\x6b\xf0\x19\x47\xdb\x0b\xe9\xdb\xf6\xf2\x44\xbe\xe1\x67\x28\x35\xbf\x50\x7f\x70\x94\x9a\x77\x18\x41\xfe\xd7\xb7\x92\x26\x70\xd9\xbb\xc0\xe1\x8f\x13\x49\x4b\xe9\xd2\xf6\x2a\xb9\xa3\x3a\x3c\x1c\x20\xb5\xa7\xa9\x4a\x8a\xc3\x6c\xb4\x49\x99\x65\x0b\x52\x16\x82\x37\x33\x0f\xad\xd3\x6a\x39\x61\xcd\xcc\xb6\xee\x2d\xb5\x94\x5a\x48\xe1\x18\xb0\x2c\x39\x37\xf4\xbc\x6e\x38\x84\x52\xa9\xb2\xb4\x3a\x4c\x8b\x53\x6c\x6a\x96\x6f\x98\x29\x66\xcc\xb1\x1c\xea\x96\x14\xf5\x84\xe6\xe9\x89\x90\x09\x1b\x67\x0b\x32\xa3\x59\xd5\x5d\x82\x92\x5b\x96\x65\x6e\x9a\x11\xb9\x06\x4d\xf4\x8c\xb9\xc6\xe0\x24\x13\x7c\x8a\x8b\xa3\xdc\x77\x35\x83\xc4\x3c\x9b\x64\x40\x79\x59\xd8\xf7\x19\xb6\xbe\x10\xa5\xf4\xef\x73\x65\x2d\xab\x59\x98\x22\x9c\x65\x83\xa0\x77\xd2\x83\x1b\x5b\x37\xa8\x57\xe0\x73\x0a\xef\x98\x82\x41\x38\xa7\xaf\xcc\xab\x82\xce\x19\x85\x14\x73\x96\xda\xee\x17\x1e\x6c\xd8\xa5\xd5\x76\xc7\xa8\xce\x33\x17\x7c\xc8\x61\x4a\x51\xea\x71\xa7\xc8\xee\x99\x9d\xc7\xba\xe2\x78\x8a\xfd\x32\x8c\xba\x20\x8a\x46\x2a\xeb\x9c\xd9\x4e\x9f\x01\xe4\xc8\x01\x17\x44\x20\x7b\x2d\x39\xd3\xb6\x7b\xf4\xac\xd4\x24\x15\x77\xfc\x70\x64\xab\x12\x33\x45\x28\x19\x83\xf6\x9d\x6c\x7d\x67\x45\x26\x41\x11\xe0\x74\x9c\x99\x3d\xc7\x80\x87\x9b\xb5\x00\x22\x13\xa0\xba\x94\x40\xa6\x54\xc3\x5a\xa1\xc9\x7e\xef\xc3\xe0\x65\xaa\xea\xf2\x5e\x72\x05\xad\xfb\x5b\xf7\x2c\x69\xfd\xe9\x8f\xed\x68\x04\xcb\x41\x94\xfa\xb3\xa8\x92\x77\x33\x96\xcc\x42\xc9\x98\xe5\xa0\x88\x28\x97\x74\xec\xb7\xee\xb1\xf5\x3b\x14\xf5\xc9\x75\xa3\xad\x95\x78\x8d\x29\x6d\x39\xe5\xb8\x6e\x2b\x4b\xcd\x01\x3c\xbd\xb8\xfe\xe5\xfd\xf1\x7f\x9d\xbd\x1f\x91\x33\x9a\xcc\xc2\x7c\x74\x4e\x28\x12\x0d\x24\x14\x33\x3a\x07\x42\x49\xc9\xd9\x3f\x4a\x5b\x9d\x9c\x1c\x54\xcf\x1e\xf6\x5a\x0b\xb9\x25\xf7\xc5\xd6\xd7\xbd\xf5\x5a\xb2\x8d\xb4\x6d\x80\x83\x50\x80\xdd\x11\x96\xc5\xa7\x33\x73\xc9\x2a\x1a\x28\x6a\xcd\xc0\x10\x23\x36\x77\x64\xd8\x15\x97\xa6\x69\x15\x72\x61\xf0\xdc\xa0\x85\x61\x55\x74\x8c\xa1\x12\x33\x20\x1c\xb4\x41\xeb\xca\x60\x25\xb8\x6a\x14\x06\x28\x15\xa8\x01\x19\x97\x18\xdc\x51\x48\x96\x53\xc9\xb2\x45\x38\x99\xe1\x55\x17\xc2\xab\x43\x8b\xe5\x25\x9d\x7e\x3c\xbb\x26\x17\x1f\x6f\x48\x21\x6d\xc9\x00\x8c\xce\xc0\xeb\xf8\x59\x63\x30\x4f\xb8\x1e\x9d\x23\x72\xcc\x17\xf6\xa2\x3d\xe0\x4c\x11\xa3\x0b\x01\xb2\x60\x27\x43\xfa\xa2\xf0\x7b\x6f\x46\xf8\xbf\x3d\xf3\x95\xd2\x08\x99\x55\xd0\x49\xb2\x12\x3c\x66\xc5\x50\x36\xce\x02\x68\xba\x6f\x7f\x55\xdd\x96\xaa\xb0\xb9\x4b\x03\xc4\xa0\xdb\x12\xad\xb6\x1a\xc1\x6b\xbb\x6f\x31\x3e\xcd\x42\xac\x6a\x47\xf6\xbb\xea\x96\x5d\x35\xcb\x61\xfd\x05\x97\x6d\x15\xcc\x5e\xba\x3e\xd5\x6b\xe8\xa9\x57\x4a\xcd\xfd\xbc\x3a\xe5\x28\x82\x08\xdb\x5f\x9e\x5f\xfa\x13\xe0\xa4\x9b\x7c\xa9\x67\x22\x3e\x6c\x9d\x1a\x03\xf2\x86\xfc\x99\xdc\x93\x3f\xa3\x7a\xf5\xa7\xae\x9d\x65\xba\x2a\x3e\xdd\xcd\x3b\x56\xab\x3f\xbf\xec\x09\xe2\x3f\x1a\xea\x64\x66\x34\x50\xd5\x82\x8c\x99\x13\xe7\xe1\x5e\x83\x34\x74\xd4\xed\xc4\x93\xf6\xe4\x31\x0b\xfc\x8c\x68\x66\x7d\x17\xe7\x93\xb0\x25\x84\xde\x11\xd1\xcc\xe3\x7f\x11\x4a\x5f\x38\x2a\xd4\x6c\x30\x51\xcf\x96\x53\x9d\xcc\x9a\x64\xcc\x08\x6a\x4a\xd7\x07\x4c\x91\x54\xa0\x25\xcd\xc6\x01\xce\x58\x87\x48\x8c\xe7\x83\xc6\xdd\x9c\xf3\x8d\xfd\x7c\x68\xa7\x96\x0c\x28\xa8\xf9\x38\xc1\x2a\x28\x2f\x53\x88\xd4\xc9\x64\x66\x59\x69\xc0\x33\x1e\x10\xca\x9c\xad\xa6\x32\x59\x23\x2e\x99\xf3\x94\x50\x6e\x03\xb8\x27\x20\xa5\x0d\xdd\x1c\x2f\xd0\x83\xcc\x12\xe8\xbc\x79\x9d\x4e\x52\x21\x85\x16\x89\xe8\xd0\x36\xa8\xe9\x30\x77\xd3\x21\x10\xac\xf1\xd7\xdb\xdc\xbf\x3f\xbd\x1c\x90\x9b\x93\x4b\xec\xa6\x72\x7d\x72\x73\xd9\xd4\x54\xf6\x6e\x4e\x2e\xf7\x9e\x14\x14\xc4\x4b\x56\xef\xcc\x32\x5b\x4c\xd2\x30\x3c\x19\xb1\x6d\x98\xd3\x62\x78\x0b\x8b\x96\x3c\xb5\x0f\xbe\x3e\xac\x76\xb8\x97\x0f\xb2\x60\xce\x69\xb1\xf3\x6c\x12\x68\xca\x3e\x53\x16\x85\x3b\x59\xf5\x3b\xd7\xa7\x53\xe4\x62\x0e\xa9\x15\x87\xfd\x13\xc0\xd3\x42\x30\x23\x2f\xc6\x1c\x8b\xdd\x9f\x8e\x39\x16\x0f\x8d\x98\x63\x11\x73\x2c\x62\x8e\xc5\xc3\x23\xe6\x58\xb8\xf1\xf4\x66\x50\x12\x73\x2c\x5a\x8e\xd7\xe5\xe7\x8f\x39\x16\x3b\x8d\x98\x63\xb1\x3a\x62\x8e\xc5\x86\x11\x73\x2c\x36\x8c\x98\x63\x11\x73\x2c\x62\x8e\x45\x8c\x16\x7b\x74\xae\xe7\x19\x2d\x46\x62\x8e\x85\x1b\x31\xc7\xe2\x55\xc4\xc4\x90\x98\x63\xb1\xd5\x88\x39\x16\x31\xc7\xa2\xcd\x88\x39\x16\x38\xa2\xed\x25\xe6\x58\xf8\x11\x73\x2c\xec\xf8\xed\x48\xcd\x31\xc7\x22\xe6\x58\xc4\x1c\x8b\x98\x63\xf1\xe0\x2a\x62\x8e\xc5\x6b\xd0\x27\x7d\x0f\xbc\xee\x39\x03\xfb\x27\x22\x2f\x4a\x0d\xe4\xca\x4f\x59\x49\x91\x96\x30\x30\x15\x4a\x04\xdd\x43\x78\x12\xc1\x27\x6c\xea\x28\xfb\x91\x6d\x30\x37\xac\xbe\x67\x18\x34\x75\x7b\x81\xf1\x3b\x19\xcb\x59\xbb\x44\x0e\xb2\xb2\x31\xef\x71\xae\xc0\xc9\x63\x4e\x52\x4e\xef\xf1\x88\xd0\x5c\x94\xb6\x29\x5f\xe2\xf6\xaf\x02\xa1\x75\x85\x3d\xbb\x9d\x21\xfd\xa8\x38\x75\x46\xca\x65\x0f\xda\x46\x41\xb5\x06\xc9\xdf\x91\xff\x3e\xf8\xdb\x57\xbf\x0e\x0f\xbf\x3e\x38\xf8\xe9\xcd\xf0\x3f\x7e\xfe\xea\xe0\x6f\x23\xfc\xc7\xbf\x1e\x7e\x7d\xf8\xab\xff\xe3\xab\xc3\xc3\x83\x83\x9f\xbe\xfb\xf0\xed\xcd\xe5\xd9\xcf\xec\xf0\xd7\x9f\x78\x99\xdf\xda\xbf\x7e\x3d\xf8\x09\xce\x7e\xde\x72\x92\xc3\xc3\xaf\xbf\x6c\xbd\xe4\xce\x22\x71\x7f\x02\x71\x4f\xe2\xf0\x27\x11\x86\x9d\x77\xb8\xa7\xb3\x78\xe5\x66\x5b\x3e\x8d\x8e\x61\x3d\x74\x1a\x3d\x35\x45\x31\xaf\x9a\x87\x29\x22\x72\xa6\x8d\x70\x68\xe4\x41\x1a\xc6\x85\x31\xdd\x50\x4a\x1d\x1d\xc0\x80\x4a\xaa\x6d\x8f\xd0\x2a\xa6\x2a\x88\xd3\x16\x5e\xf2\x73\xbd\x57\x2b\x7b\x05\x9e\xe7\x61\x0a\x13\xc6\xc1\xf9\xc1\x22\x6d\x78\x7c\x44\xda\xf0\x1a\x69\x83\x82\xa4\x94\x4c\x2f\x4e\x04\xd7\x70\xdf\xca\xc2\xd2\x24\x0d\xd7\xcd\x09\x89\x3d\x67\x2e\x8b\xd2\x5d\x23\xa2\xb0\x01\x94\x4b\xe9\xac\x55\x08\xae\x2c\x39\x2a\x98\x36\x4b\x06\xb4\xd5\xfe\x50\xef\xc1\x98\xc8\xe5\x97\x78\x7d\xce\xaa\x99\xff\x28\xd9\x9c\x66\x46\xdb\xad\x9f\xb8\x44\x0d\x26\x7c\x68\xdb\x33\xaf\xa9\xba\xad\x0f\x3c\x0c\x8d\x0c\x5d\xad\xf9\xc8\x7f\x12\xfe\x04\xf7\xfa\x25\x4a\x69\x28\x20\x5d\x4a\x36\x67\x19\x4c\xe1\x4c\x25\x34\x43\xba\xd6\x0f\xaf\x38\xde\x30\x3b\x6e\xbc\x14\x99\x22\x77\x33\xc0\xee\xca\xd4\x9b\x00\x30\xc3\x65\x4a\x19\x27\xb9\xd9\xa2\xc2\x3f\xac\xac\x2d\xc1\x90\xff\x82\x4a\xb3\xc1\x95\xcd\x00\x55\xe4\xb1\x10\x99\x0b\x1d\xce\x16\xf5\xfc\x2e\xf6\x9e\x8b\x5f\x38\xdc\xfd\x62\x66\x53\x64\x92\xd1\x69\x65\x2a\x50\xa0\x57\xac\x7d\xf5\xd4\x1b\x3f\x00\xe3\x72\x4b\x20\x34\xbb\xa3\x0b\x55\x1b\x4e\xc2\x3e\xe0\xef\xc8\xdb\x43\x44\x67\xaa\x48\x35\x47\x4a\x7e\x7f\x88\xbe\xc4\x93\xe3\xcb\x5f\xae\xff\x7a\xfd\xcb\xf1\xe9\x87\xf3\x8b\x6e\x9c\xc2\x7c\x3b\x50\xde\x6a\x8e\x84\x16\x74\xcc\x32\xd6\x85\x41\xac\x44\x9b\x84\x93\x22\x0b\x4e\xd3\xa3\x54\x8a\xc2\xc2\xc9\xdb\xa8\x6a\x4e\xd9\xd4\x82\xc3\xcc\x64\xdc\x9e\x49\x73\xc2\xa9\xa4\x5c\xd7\xc6\x9a\x1a\xe4\xb2\xe4\x46\xb1\x7e\xe1\x81\xf9\x34\xed\x2f\x28\xff\x38\x4d\x21\x6d\x40\xef\xd5\x05\x01\x9e\xf8\x8f\x5b\xd4\x39\xda\xe4\xf2\xe3\xf5\xf9\xff\x5e\x42\xc3\x45\xd1\x2d\xe6\xa9\x9f\xbc\x30\x29\x8a\xde\x76\xf7\xca\xe5\x1d\xc5\xfd\x7d\x16\xfb\x5b\xf1\xaa\x7e\x3c\xed\x57\x25\x6f\x96\xf1\xa8\xe7\x27\xb9\x48\x61\x44\x2e\x2b\x2b\x7d\xf3\x6a\x90\xde\x4b\x25\x10\x73\x0b\xd7\x8c\x66\xd9\x22\x14\x90\xb4\xb0\xc9\x34\x8d\xcc\xe4\x90\x0e\x4f\x68\xa6\x3a\x12\xd3\x2e\x9c\xc9\x30\xe1\x0f\x46\x99\xec\x05\x9a\xd5\x6c\x24\x05\x2e\xb4\x93\x4a\xcd\x2a\x31\x59\x5b\x8a\x84\x58\xcd\x35\x08\x8b\x6a\x70\x17\x65\x0d\xfd\x9e\x31\x31\xe5\x61\x75\x59\xcd\x6c\xad\xbc\xa5\x82\x65\xe9\xd6\x31\xa6\x5a\x97\x35\xb3\x4b\xa0\x29\xe6\xa4\x15\x54\xcf\x6c\x54\x43\x4e\xd5\x2d\xa4\xf6\x07\x27\xd7\x54\x66\x7e\x33\x63\xf5\xaa\x1b\xb3\x6e\x6f\xd3\x47\x79\xc6\xc6\x5a\xa0\x2f\xa0\x5d\xd1\x0d\xd2\xc7\x11\x30\xdf\xf4\x91\x67\x8b\x2b\x21\xf4\x37\x55\x2e\x56\x2f\x1b\xf8\xa3\x93\x14\x9b\x66\x58\x14\xa5\x30\x08\x21\x1d\x22\x30\x11\xa5\xc3\x34\xb0\xd3\x7a\xc3\x9e\x18\xa1\x65\xc9\x8f\xd5\xb7\x52\x94\xad\x39\xc0\x8a\xa0\xf5\xed\xf9\x29\x9e\xe3\xd2\x79\xd9\xb8\x96\x0b\xcc\x3a\x5d\x2d\x18\x54\xc9\xb4\xdf\x3b\x3f\x61\x88\x91\xb5\x4b\x87\x7c\xa0\x0b\x42\x33\x25\xbc\x70\xcc\xf8\x5a\x05\xca\x69\x67\xe6\xf2\x58\xe8\xd9\x8a\x5a\x66\xd0\x79\xf5\xb9\x41\xe0\x74\xab\x2b\x18\x31\xbe\xf2\xb8\xa6\xb7\xa0\x48\x21\x21\x81\x14\x78\xd2\x71\xd7\x9e\xda\xd5\x84\x3b\x7f\x21\xb8\x39\x16\xbd\xec\xfd\x79\xe5\x63\x44\x43\x58\x73\xa7\xd1\x5b\xe9\xf4\x0e\x8a\x3e\x4b\x3c\x14\xa5\x02\x69\x1d\xac\xb2\x04\xbb\x11\xdf\x95\x63\xc8\x40\x5b\x65\x08\xeb\x4e\x50\x6d\x15\x69\x96\xd3\x29\x10\xaa\x2b\x44\xd1\x82\x00\x57\x86\xdc\x58\xd3\x9b\x26\xa9\x80\x3a\x81\x92\x2a\xf2\xfd\xf9\x29\x79\x43\x0e\xcc\xbb\x0e\x71\xfb\x27\x94\x65\xe8\xce\xd4\x54\x2e\xaf\x91\x4d\xfc\x14\xb8\x24\xc4\x3d\x22\xa4\x3d\xa2\x03\xc2\x05\x51\x65\x32\xf3\x6b\x32\x1a\x97\x57\xd8\x5c\x3c\x1f\x1a\xf5\x5f\x21\xaa\x76\x26\x30\xdf\x2b\x90\xbd\xd1\x97\xef\x5b\xd0\x97\x50\x84\x30\x38\xd7\x84\x9e\x45\xac\x1c\x34\x4d\xa9\xa6\x8e\xee\xd4\x59\xd7\xaf\x71\x4b\x9f\x9a\xfa\x28\x78\xcf\x78\x79\x6f\x23\x56\xfa\x53\xf2\xaf\xcf\x70\x5a\x92\x78\xa0\xe1\xa6\xd1\xa2\xc8\x98\xcd\x77\x5e\x8a\xa0\x3a\x6f\x6c\xf5\x60\x83\x88\x84\xc7\x9c\x66\x99\x30\xe4\xcd\x70\x76\xca\x53\x91\xaf\xbc\xcc\x08\x50\xd0\x28\x74\x37\x22\xaf\x12\x79\x9e\xdc\x1c\x91\xc1\x1c\x3a\xd4\x74\x59\xae\xcb\x67\x66\x33\xb2\x98\xdf\x50\x9c\x9e\x64\x74\x0c\x99\xe5\x2c\x16\x81\xd4\x2a\x02\x3d\x75\x14\xa2\x14\x59\x7f\x39\x18\x57\x22\x03\x1b\xd6\xe3\x01\x61\xa6\x7f\x11\x70\xc0\x49\xfa\x82\x03\x2a\x32\x0d\x38\xa0\x4a\xf6\x12\xe0\x50\x76\x60\xb4\x64\x19\x0e\x86\x6b\x37\xe1\x80\xac\xf3\xb9\xc3\x41\x41\x92\x88\xbc\xb8\x94\xc2\xa8\x5c\xbd\xb1\x16\x37\x6d\xed\x2b\xb2\x3a\xf9\x9a\x20\x1c\x24\xe5\xcd\x9b\xa9\x0c\x02\xfa\xa8\xb6\x34\xde\x47\xf5\xfd\xaf\xb0\x43\xb2\x21\x3d\xcb\x7c\xc8\xcf\xd2\x70\x2b\x99\x27\xdd\x85\x17\x5e\x4e\xa0\x83\x95\xac\x17\x66\x22\x12\x9a\x61\xc9\xbd\x6e\x18\x43\x96\xb1\x66\x79\xe2\x20\x0a\x13\x5d\x4b\xf8\x9b\xf7\xfb\x63\xf5\x35\xfc\xc5\xd9\xbe\xb8\x48\x21\x70\x41\xda\xf0\xd1\x1b\x1b\xad\x87\xf7\xf9\x00\x50\xc3\xd5\xbd\x37\x30\x6d\x3c\xad\x85\xab\x00\xf3\xa1\x2a\xe4\x67\x16\x08\x3c\x65\x7c\x8a\x16\x9d\x01\x91\x90\xd9\xd0\x51\x77\x86\x6f\xad\xfa\xb5\x8f\x18\xed\x27\xf5\xe8\xec\x5f\x8d\x92\x10\x13\xdc\xcd\x8c\x46\x0e\x2f\xdf\x4c\x2c\xb5\x64\x8a\xec\xbd\xf7\x00\xe8\x50\xf9\xec\x39\x32\x88\x3d\xfb\x85\xd5\x6e\x5a\x1b\xdb\x2d\xe3\xa9\x8b\xb2\x6c\x00\xab\xaa\x51\x6b\xa5\x50\x8c\xdf\x65\x69\x48\x1a\xde\x91\xbf\x71\x52\x01\x8b\x0c\x5b\xa3\xc7\x95\x15\x58\xbd\x79\x69\xf8\xb0\xc9\xaf\x7a\xc9\xf2\x34\xdf\x73\xdc\x7b\xf3\xde\xa1\x51\x7b\x57\xef\xf3\xdf\xb2\xf7\x94\xfb\x7a\xc7\x78\x2a\xee\x54\xdf\x3a\xc4\x8f\x76\x5a\x2f\x50\x27\x06\xad\x35\xe3\x53\x15\xea\x11\x34\xcb\x1a\x66\xd8\x75\x8a\x84\xdf\xe1\xaa\x22\xf1\xaa\x00\xbf\x14\x1d\x1e\x95\x80\x1d\xc6\x34\x57\xf4\x44\x9a\x4f\xd1\x8c\x66\xd7\x45\xfb\xd2\x6c\x64\x19\x0d\xbe\xfd\x70\x7d\xdc\x9c\xda\xd0\xb3\x3b\xac\x78\x6d\x80\x6d\xae\x13\x9a\xe6\x4c\x29\x34\x03\xc1\x78\x26\xc4\x2d\x39\xf0\x61\x1b\x53\xa6\x67\xe5\x78\x94\x88\x3c\x88\xe0\x18\x2a\x36\x55\x47\x0e\x69\x87\x66\xf5\x87\x84\xf1\xac\x8a\x46\x41\x35\x92\x6b\xe5\xcd\x18\xf8\x92\xa4\x5a\x05\xee\xad\xab\xd7\xe9\xbc\xcc\xab\xcb\xb4\x15\x3a\x19\x64\x4f\x5f\x70\x66\x75\x7b\x2e\x3a\xd6\xce\x78\x64\x8b\xf0\xdb\x5d\x6a\x4a\x98\x46\xb5\x16\x8e\x56\x7a\x7b\x72\x20\x39\xe9\x20\x01\xd5\x5f\x55\x9e\xbf\xd4\x73\x92\x14\x6c\xf6\x04\x60\xd4\x09\xdd\x18\xdc\x84\x56\xd9\x7d\x4c\xc2\x73\x8f\xee\x87\x12\x2d\x7a\x7d\x6c\x9a\x87\xd1\x07\xb2\x62\x46\x87\x56\x49\x36\x24\x09\x69\x98\x97\x01\x66\x82\x0b\x17\x9c\x6e\xb8\xa0\xe0\x88\xd2\xa8\x2d\x58\x47\x10\xee\x89\xa3\xb1\xc1\x52\x4f\x6a\xff\x60\xe8\x43\xc2\x24\x1e\x5b\x04\xa0\x5e\xc3\x1d\xd3\x33\x5f\xe1\xbe\xe1\x70\xc2\x95\x48\x50\xe8\x3d\xe0\x04\xa4\x14\xd2\x05\xc2\x78\xab\x2d\xce\x84\xa4\x18\x23\x69\x0c\x92\x50\xf3\xd7\xbe\x0a\x5d\x94\x75\x09\x5c\x8c\x13\x33\xd8\x04\x93\x09\x24\x28\x29\x85\x00\xb6\x64\xf7\xa0\xae\xdc\xe7\xa2\xbb\x0d\x82\xb9\x12\xba\x39\xbb\x37\x6f\x09\x9f\x0a\x9d\xa1\xae\x62\xde\xfa\xcb\x87\x23\x42\xce\x79\x15\x39\x39\x30\xbb\x18\xde\xe9\x43\x7e\xb4\xf9\xc4\xb0\xfe\x32\x7e\x40\x68\x77\x32\xe2\x9d\x2c\x7b\xc0\xf8\x2e\xc6\x60\x12\x1a\x84\x7b\x25\x07\x68\x18\x76\x93\x9a\xad\xf7\x4c\xbc\x8b\xa1\xd8\xdc\xf2\xa9\x8c\xc5\x2f\x83\xd3\x93\xae\x74\xce\xa5\xc4\xf7\x54\x14\xf7\x3a\x98\x2d\x10\xbf\x2b\x77\xd3\xa5\x48\x6d\x49\x8c\x2a\xa5\x1f\x7b\x59\x60\x89\x0e\xf6\x4f\x2f\x60\xd5\x42\x1a\x17\x36\x2a\x3b\xac\x95\xe1\x6a\x82\xa6\xc4\xc8\xca\x99\xd7\xed\xf3\x22\x03\xcc\x9e\x0b\x66\xae\x13\x03\x83\x2a\xba\x83\x6a\x21\x75\x21\x5e\x57\xa1\x63\x40\xfe\x07\x0f\x65\x15\x00\xe8\x8b\x07\x5c\x56\x8f\x5b\x15\x8f\x29\x5f\x52\x1b\x33\xdb\xb4\xf0\xa6\x03\x92\xb2\xc9\x04\x7c\xa0\xa1\x51\xfd\xa8\xa4\xb9\x21\xf1\x8a\x38\x10\x8c\x61\xca\x6c\x24\x5b\x45\xd8\xf6\x55\x9d\x01\x3f\xb0\xc4\x90\x69\x92\xb3\xe9\xcc\x22\x0a\xa1\x98\x19\x49\xbc\x4b\x2d\x13\x34\x25\x88\xdb\x42\x92\x3b\x2a\x73\xc3\x37\x68\x32\x43\xff\x1c\xe5\x24\x2d\x25\x96\x89\xd4\x40\xd3\xc5\x50\x69\xaa\x8d\xa8\x0b\xd2\x69\x84\x7e\xfd\xb1\x94\xf0\x83\x23\x96\x12\xde\x3c\x62\x29\xe1\x58\x4a\x38\x96\x12\x7e\x78\xc4\x52\xc2\x6e\x3c\x7d\xb6\x2f\x89\xa5\x84\x5b\x8e\xd7\x55\xce\x26\x96\x12\xde\x69\xc4\x52\xc2\xab\x23\x96\x12\xde\x30\x62\x29\xe1\x0d\x23\x96\x12\x8e\xa5\x84\x63\x29\xe1\x58\x14\xed\xd1\xb9\x9e\x67\x51\x34\x12\x4b\x09\xbb\x11\x4b\x09\xbf\x8a\xd2\x4f\x24\x96\x12\xde\x6a\xc4\x52\xc2\xb1\x94\x70\x9b\x11\x4b\x09\xe3\x88\xb6\x97\x58\x4a\xd8\x8f\x58\x4a\xd8\x8e\xdf\x8e\xd4\x1c\x4b\x09\xc7\x52\xc2\xb1\x94\x70\x2c\x25\xfc\xe0\x2a\x62\x29\xe1\xd7\xa0\x4f\x2a\x9d\xb2\x56\x95\xcf\xb6\x29\x54\xe1\x22\x43\x82\xd4\xd6\x71\x39\x99\x80\x44\xca\x85\x6f\x5e\x89\x42\xa8\x0a\x5a\x55\xb4\xcc\xc5\x19\x60\x59\x3c\x09\x34\x75\x01\xef\x1b\x1e\x77\xb9\xb4\x58\xa1\xac\x8e\xd4\x3c\xfb\xf8\x4d\x3f\x55\x31\xba\xc5\x28\xe2\x9a\x3f\xf2\xa4\x7b\xac\x5a\x0d\xf0\x75\x09\x18\x0e\xee\x49\x26\x94\x8b\x30\x45\x60\x25\x33\xca\x39\x78\xe5\x91\x69\x34\xca\x8c\x01\x38\x11\x05\x70\x4b\xbf\x29\x51\x8c\x4f\x33\x20\x54\x6b\x9a\xcc\x46\xe6\x4d\xdc\x03\xbb\x8e\x06\x75\xbf\x28\x2d\x81\xe6\x3e\x2e\x36\xa7\xcc\x4e\x45\x68\x22\x85\x52\x24\x2f\x33\xcd\x8a\x6a\x32\xa2\x00\x03\xda\x2d\xa3\xaa\x80\x81\xe1\x25\x75\x08\xe9\xa0\x7e\x9b\x5b\x96\x08\x8b\x02\xa1\xea\x3a\xc0\x3a\xa8\x79\xa1\x17\x55\x1c\x1d\x90\x09\x93\x4a\x93\x24\x63\xc8\xad\xf1\x8d\x36\x77\x10\xe7\x1b\x78\x5e\xcd\xdd\x4a\x95\x5b\x2a\x4f\x51\x6c\x2d\xb4\xb2\x51\x69\xf5\x84\x6e\xaa\x94\x29\x27\xe6\xab\x01\xa1\xbe\xe4\x8d\x05\xb4\x5f\x29\x82\xda\x73\x16\x3b\xbb\xfb\x29\x98\x2e\xa8\x93\x57\x87\xed\xd5\x88\x8e\x21\xc6\x1e\x39\x07\x8d\x68\xea\x5a\xa0\xc0\x70\x97\x95\x63\x80\x1b\xc0\x61\x6e\x70\x00\x12\x30\xfc\x95\x6e\xc0\xfa\xcf\x8e\xf4\x01\x53\xfc\x00\x4a\xd1\x29\x5c\xb6\xf4\x5a\x6c\xd2\xc8\xd0\x71\x51\x6f\x0c\xa2\x42\x66\xd3\xd3\xaa\x5f\xea\x30\xa7\xa6\x18\x44\x72\xbb\xa6\x4a\xf8\xb9\x93\x4c\x6b\xc0\x4d\xc5\xe2\x48\xe8\xf8\x5c\x4e\x40\xdd\x5f\x0a\x96\xfa\xe0\x27\xa9\x1f\x36\x44\x9d\xa7\x36\x74\x69\x0c\x64\x2c\x19\x4c\xc8\x84\x61\x3c\x14\x46\x28\x0d\x6c\xb9\x0f\x6a\x2d\x0a\x4a\x19\x7d\x57\x70\x2f\xcb\xfa\x75\x8d\xc8\x8f\x6e\x61\x5a\x96\x3c\xa1\x41\x11\x40\x4c\xd1\x62\x13\x32\xc5\x08\x27\x27\x2d\xfe\xf1\xcd\x7f\xfc\x89\x8c\x17\x86\xa5\xa1\x64\xa5\x85\xa6\x59\xf5\x91\x19\xf0\xa9\x81\x95\x3d\x9e\xcd\x24\xa3\x0a\x02\x58\xc5\xdc\x2e\xfc\xed\xef\x6f\xc7\x4d\x1e\x7b\x94\xc2\xfc\x28\x80\xdf\x30\x13\xd3\x75\x75\xe1\xdb\x87\x4c\xb6\x54\x89\xd6\xa0\x99\xc8\x58\xb2\xe8\x8c\x68\xbe\xee\x0c\x99\x89\x3b\x2b\xeb\xaf\xc1\x9e\x3a\x06\xb2\x10\x45\x99\x59\x0b\xf6\x37\x55\x7a\x5e\xa9\x60\x35\x07\x67\xed\xb9\x40\x9b\xab\x9b\x62\xb9\x5e\xac\x0d\x6c\xf3\xaf\x14\x2e\xb6\xdb\x59\x05\xab\xf2\x33\xa8\x08\x7d\x43\xb3\x6c\x4c\x93\xdb\x1b\xf1\x5e\x4c\xd5\x47\x7e\x26\xa5\x90\xcd\xb5\x64\xd4\x50\xcb\x59\xc9\x6f\x6d\xe5\xea\x2a\x45\x58\x4c\x8d\x68\x55\x94\xda\x07\x12\xaf\xfb\x60\x9b\x70\xea\x89\xb0\x57\x83\xea\x59\xe0\x9e\xd5\xba\x8e\x4b\x95\xb0\x18\x19\xce\xaf\x42\x64\xfb\xfd\x9b\x3f\xfe\xbb\x45\x5d\x22\x24\xf9\xf7\x37\x18\xfc\xa8\x06\xf6\x10\x23\x6d\x33\x8c\x22\xa7\x59\x66\xd4\x86\x10\x29\x0d\xa0\xd7\x21\xe1\x67\xc7\x41\xdd\x1d\xdd\xb6\x16\xa5\x6e\x6e\xfe\x8a\x72\x14\xd3\x0a\xb2\xc9\xc0\x66\x05\x54\x6a\xcd\x3e\x32\x86\x7d\x47\x7d\x30\x35\xe3\x19\x08\x40\x73\x91\x95\x39\x9c\xc2\x9c\xf5\xd1\xbc\xa2\x31\x9b\x57\xf5\x33\xa6\x30\x01\x63\x9c\x89\xe4\x96\xa4\xee\x62\x10\xc6\xb2\x5c\x42\xb5\x3d\x14\xda\x06\xf4\x74\x08\xe4\xd9\xf8\xfd\x8d\x10\x9e\x9c\x16\x45\x15\xa3\x2f\xe9\x5d\x03\x18\x78\x26\x31\xdf\xb7\x63\x3d\x85\xce\x66\xe6\xae\x46\xe6\xa1\xfb\x22\x43\x37\x5b\x4f\xd1\x3a\x84\xa5\xbb\x8d\xba\x5e\x7d\x7b\xc3\x64\x03\x21\xea\x09\xfd\x69\x28\xf0\xdf\x36\x3c\x7b\x25\x2b\xa9\x4a\x6c\xa9\x10\xc3\x0a\x00\x06\x7d\x90\x24\xb7\x37\xb8\xf6\x60\xdd\xec\x16\xbf\xd4\x80\x0b\xaf\xac\xca\x39\xd5\x4e\x20\xf4\xe6\x6b\x4a\x0a\x90\x8a\x29\xc3\x97\x7f\xc0\x03\x75\x92\x51\x96\x07\x26\xc0\xa7\x01\x82\x3d\xdc\x58\xf9\xb2\x3b\xa5\xbc\x14\xa9\x9b\x10\x49\xa1\xad\xfa\xb9\x46\xac\x6d\x4a\xb5\x3d\x32\xd4\xa7\x26\x95\x3f\xd4\xd0\x6c\x52\x4a\xf3\x4b\x45\x2a\xed\x5d\xaf\x89\x40\xe2\xf7\xbd\x54\xfa\x58\x2d\xbe\x27\x32\x80\x84\xd1\x6d\x6e\x93\x12\x36\x94\x47\x7b\x50\x02\x91\xde\xe9\x81\x23\x62\x5d\xea\xe6\x4c\xb8\x47\xc9\xfe\xbb\xfd\x27\x25\x92\x16\x44\x52\x14\x74\xda\xa9\x87\xc1\x12\xa4\x96\xa7\x0d\x13\xbd\x8d\x1a\x84\xd7\xab\xb2\x43\x78\x17\xa4\x75\x21\x0a\x2c\x33\x62\xbd\xa3\x1e\xc0\x4e\x41\xb0\xf9\x90\x77\x74\x41\xa8\x14\x25\x4f\x9d\x7d\xa9\x32\xf0\x7d\x58\x7a\xf1\x85\xe0\xe0\x0d\xe7\xcb\x79\xe2\x68\xd1\x67\x9c\xbc\x1d\xbd\x7d\xf3\x5a\x38\x15\x7e\xe1\x12\xa7\xba\xa8\x38\x95\xa5\x4f\x4f\xfa\xad\xbe\xda\x71\x4f\xdf\xfb\xc1\x99\x58\xea\x62\xc6\xcc\x17\x6b\xc5\x9f\xee\x24\xd3\x10\xf4\x36\x3a\x40\xc5\xc5\xe8\x87\x41\x56\xf4\x61\x8f\x35\xbc\xfb\x49\x43\x57\xe5\xf8\x13\xd2\x2d\x47\xa0\xf0\xb8\xad\xb3\x70\xa9\x07\x48\x58\x08\xa8\xbd\x3d\x72\x60\xef\xdc\xb7\x99\x81\x87\x4f\x8a\x5a\x0e\x68\x67\xf7\x45\x87\x1a\x73\x0d\xc0\x9d\xdd\x17\x14\x6d\x70\x45\x8f\x10\xfc\x2f\x98\xd1\x39\x60\x46\x24\xcb\xa8\xcc\xd0\xe7\x78\x6d\xd7\x4e\xc6\xa5\x26\xc0\xe7\x4c\x0a\x8e\x01\x3e\x73\x2a\x19\x56\xa5\x90\x80\x99\xd5\x46\x17\xfd\xf2\xe0\x87\xe3\x2b\x0c\x68\x38\x74\x29\xe1\x6e\x95\xa5\xf2\xe5\x23\xc2\x95\x04\xd3\x3d\xba\x7d\x7e\x1d\x06\x86\x48\x73\xfd\xba\xcc\x7b\xf2\x52\x97\xb6\x20\xfe\x7d\x92\x95\x8a\xcd\x9f\x8a\x92\xb8\x54\xd5\x53\xd6\x6a\x9f\x97\xd2\x66\x6b\x40\xad\x64\xc0\xa2\x69\x1d\x59\xcb\x23\x15\x58\xf7\x55\x55\xb3\x2a\xf4\x81\x3b\xd3\x93\xcb\x65\xb7\xb1\x78\xbe\x64\xd9\x8a\x08\x81\x75\x1b\x9e\xd6\x08\x95\x72\x75\x82\x2b\xdc\x0d\xac\xcd\xe8\xe6\x46\x52\xe0\xe9\xc5\x75\x58\x04\xc0\xaa\x4b\x22\x1d\x91\xcb\xfa\xc7\xba\x52\x04\xd6\x2f\xaa\x94\x48\x90\xd3\xba\x26\xee\x14\x38\x48\x14\x12\xcc\x94\x8d\x76\x72\x64\x4c\x95\x75\xf2\x9c\x5e\x5c\x5b\x9b\xed\x6e\x30\x6b\x2d\x66\xb7\x97\x50\x0d\xc7\xb7\x39\x11\x2d\x84\xdb\x66\xb7\x9a\xca\x60\x65\x00\x83\x4a\xa9\x9d\x98\x9c\x5f\x12\x9a\xa6\x12\xdd\x3e\x4e\xf4\x09\x4a\xbd\x55\xbe\x05\xac\xca\x40\x15\x84\x6b\x0a\xc0\x8d\x24\xae\x06\x2c\x39\x2d\x8b\x8c\x59\x37\x42\xf8\x40\x5d\x4d\x02\xdb\xab\xec\x8e\xb4\x5d\xd4\xbc\xd6\x4a\x5e\x07\x2a\x24\xda\x56\x75\x7b\x60\xf7\x24\x28\x91\xcd\xeb\x82\x9a\x4b\xbb\xe6\x4e\x04\x9a\xc4\xab\x5d\xf3\x45\xdc\xb6\xda\x31\xe0\x5a\x9a\xa3\xb9\xbc\x5b\xd8\xbd\x37\x2b\xf1\x34\x55\x13\xb2\x39\xa0\x7f\xdc\xd5\xaf\x73\x65\x94\xea\x12\x9f\xd6\x37\x6c\xab\xac\x02\x95\x9e\xa2\xe1\xaa\x5a\x9e\x44\xf2\x54\x88\xb0\x6c\xec\x38\xbd\xb8\xb6\x94\xd0\x7e\x7c\xd5\x95\x6f\xdd\x2e\xd5\x54\xad\x35\x06\x3e\x59\x95\x8f\x2e\x9a\xc7\x52\x5b\x25\xd7\xa6\xb4\x53\x20\x4b\x07\xf1\xaf\x53\xe6\x5e\x87\xb7\x2b\xa0\x32\x99\xb5\x81\xff\x03\x84\xc0\x4e\x4a\x52\x61\x23\x01\x26\x42\xa2\x4a\x3c\x44\xf2\x9e\x09\x71\x5b\x16\xdb\x50\x74\x37\x8d\xed\x95\xb3\x15\x81\x68\x3c\xf1\x9b\xa2\xe9\x29\x57\x6d\xfc\xbd\x4d\xd9\x07\xb4\x95\x78\x70\xa2\x3a\x1b\x43\x2c\xeb\x4d\x27\x59\xa9\x34\xc8\x6f\x98\x54\x7a\xcf\x17\x5c\x45\x0c\xb6\x36\x91\xfd\xf0\x86\x1f\x99\x9e\xb9\xd2\x69\xfb\x83\xe6\x25\xf3\xb7\x9b\x78\xdf\xe8\xb4\xfb\x17\x82\xc3\xfe\x68\x59\xec\xaa\x48\x79\x45\xd6\x36\xf2\x14\xb7\x74\x05\x99\x8d\x17\xc5\x0b\x01\xae\xdc\xb8\xb2\x71\xe6\x0d\x9e\xfe\x29\xd0\x84\x62\x89\x26\xbc\x7b\x56\x97\x79\xb3\x05\x58\x6c\x9d\x3a\xe1\x04\xbd\x45\x08\xa2\xa0\x26\x8b\x16\x9b\x3f\xbb\x8d\x3c\xb7\x33\x06\xd8\xf2\x7f\xd7\x20\xe7\x2c\x81\xf7\x8c\xdf\xee\x88\x7e\xcd\xe8\x92\xb3\x95\xd9\x1a\x05\x79\xad\x8f\x96\x71\x1b\x7c\x67\x58\x0c\x1d\x8b\x52\xa3\xec\x86\x0e\xc7\x5a\x71\x64\xfc\x7f\xec\x5e\xa0\xbd\xbd\xb0\x15\xb3\xd6\xe9\x88\x6a\x60\x8d\x3e\x5e\x09\x54\x0b\xae\x29\xd6\xf6\x3b\x15\xc9\x2d\x48\x92\x99\x65\x8c\x48\x1d\xf8\xd2\xa8\x26\x27\x4b\xd8\x31\xea\xa2\xad\xa5\x03\x8a\x19\xe4\x20\x69\x56\x17\x55\xec\x00\xea\xf7\x8e\x70\x56\xb3\x86\x31\x29\xb6\xba\x90\x2b\x83\x66\xce\xe1\xd9\xba\xbb\x72\xba\xf0\x95\x26\x19\xc7\x70\x83\x7b\xa6\xd0\xac\x5f\x88\x34\xcc\x62\x2b\x15\xc8\x61\x95\x63\xe8\xf2\x78\x54\x15\x88\x93\xc2\xb8\x9c\x4e\x19\x9f\x3a\xea\x8c\x34\xbd\xae\x35\x56\x6b\x3a\x18\xe9\x9d\x48\xb0\x05\x1f\x51\x7a\xb0\xf1\x65\x2c\xbc\x3f\x17\xa9\xbd\x7d\xbc\xb0\xda\xa0\xdf\xd9\x3a\x40\xfa\x9c\x13\x21\x5d\x9d\x05\x9a\xa6\xb8\xf6\xd5\x2f\x74\x2d\xbd\xc3\xaf\x1a\x54\x71\x1c\x36\xb2\xbb\x7a\x2a\x00\x8b\x2a\xc7\xbe\x47\xf7\x63\x35\x36\x99\xb2\x05\xbe\x82\xf2\x9a\x5e\x35\x58\xae\xad\x79\xb6\xba\xfb\x3e\x3e\xba\xcd\x39\xdf\x9d\xbd\xb4\x62\x2d\x4d\x6e\xcd\xd7\x7c\x85\x0d\x13\x5f\xf2\x8e\x3a\xcc\xa2\xd8\x53\x54\x43\x5e\x08\x49\x25\xb3\xe4\x6e\x19\xcf\x0c\xbf\x58\x83\x60\x73\xdb\xab\x71\x0d\x8e\xad\xc5\x65\xa4\xb6\x5c\x54\x2d\xe4\x0d\x5f\x50\xc9\x0c\xd2\x12\xa3\xd4\xa7\x25\xc5\x56\xb0\x86\x5a\x38\xa3\xfa\xc2\x85\xff\x59\xa4\xab\x02\x0b\xab\x74\x84\x05\x06\xe3\x60\xb5\x3d\xf3\x0b\x62\xab\x0d\x41\xb4\xad\x34\xb1\x2f\x5f\x18\x8d\xb8\x01\x09\x13\x8a\x6d\xfe\xa8\x3f\x54\x70\x9f\x80\x21\x6b\x5a\xd5\x8b\x75\xf1\x29\x58\x4b\xd4\x63\xba\x83\x21\xcc\x59\x82\x6f\xd8\x78\x84\xdd\x17\x58\x60\x8f\x17\x75\x6b\xe3\x0d\x87\xe7\xc6\x7c\x5b\x95\x2c\x84\x4f\xf9\x14\x81\xad\x0e\xc5\x32\x04\x9b\x8a\x90\x7f\x0f\x11\x3c\x71\xd3\x07\xf9\x04\xdc\x1e\xa1\x2a\x33\xc0\x75\x21\xf4\xd1\x25\x0f\x1c\x12\x5b\x77\x76\x47\xf4\xed\xa0\x67\xb4\x77\x22\xb6\x72\xfe\x75\x51\x69\xa8\x9c\x76\x57\xff\xf6\x8f\xe5\xb4\xcc\x6d\x59\x60\xb1\x54\x99\xd5\xf5\xb3\xb4\xec\x14\x2d\x76\x86\x19\x9f\x7c\x38\x0d\x93\x33\xc2\xa8\x73\x9f\xda\x62\x84\xbc\x8e\x96\xdc\x65\x53\xae\x39\x68\xb5\x7d\xb8\xe6\x1a\x4e\x3f\x75\xb6\xca\xea\x6d\x1e\x2d\x19\x2f\x8c\x9c\x81\xd2\x51\x6d\xad\xe4\xc9\x8c\xf2\x29\x1a\xf8\x45\x69\xe6\xfb\xf2\x4b\x5c\x91\x84\xb4\x4c\x5c\x49\x79\x1f\xd9\xfd\xa5\xb7\x6b\xba\x4a\x47\xd8\x57\x4a\x25\xb4\xf0\x6b\x0e\x3f\xcb\x0a\x21\xef\x08\x1b\xc1\x88\xec\x7d\x19\x5c\xda\xb3\x6f\x2f\xa4\x30\xaf\x70\x41\xe1\xb8\xaa\x8c\x69\x3c\xde\x7b\xe1\xdd\x23\x72\x66\xde\x81\xbe\x9e\x0a\x80\x41\xdc\xf2\xb8\x06\xdf\x80\x48\x98\x52\x99\x66\x98\x4b\x38\xa9\xc4\x2d\x9b\x71\xe4\x00\x86\xa4\x17\x23\x05\xb9\xd0\xeb\xec\xae\x3b\xf5\xbb\xb7\x42\xda\x30\xa5\x9a\x0e\xb1\x0c\xbf\x25\x62\x47\xd6\x70\x30\x74\x85\x10\x87\xd4\xa1\x56\xd0\x11\xff\x0b\x97\x33\x36\xa4\xd5\x5d\x8c\x0f\xe9\x10\x4b\x12\xb6\x8f\x82\x7d\x82\x80\x89\x4e\x3a\x7c\x87\x7a\x98\xcb\x82\x77\x55\x46\x19\x61\x30\x22\x17\x42\xd7\x65\x73\xab\xd8\x0c\x57\xf2\x71\xdd\x79\x3e\xbb\xb8\xb9\xfa\xeb\xe5\xc7\xf3\x8b\x9b\x78\xac\xe3\xb1\x8e\xc7\xba\xc3\xb1\x06\x3e\xef\x7c\xa4\x2b\x05\x6f\x9d\xce\xbb\x54\x8a\x2f\x48\x19\x7f\x45\xd1\x67\x67\x7c\xfe\x03\x95\x75\x2f\x77\x94\x1f\xd7\xba\x89\x7d\xb3\x77\x24\x71\x27\x2f\x3e\xfc\xec\x09\x83\xc7\x7a\x0c\xca\xb9\x08\x2a\x1d\xac\xdb\xb5\xb0\x01\xd6\xc9\x2f\xe7\xa7\x67\x17\x37\xe7\xdf\x9c\x9f\x5d\x3d\x69\x34\x45\xc7\x52\x78\x4d\xa6\xdc\x92\x4b\x16\x12\xe6\x4c\x94\x2a\x5b\x54\x8d\xa6\xd6\x13\x81\xd5\x80\x3c\x9e\x12\xca\x17\xde\x9e\xb6\xfe\xb1\xc8\x6c\xfb\x65\xb6\xcd\xe0\x92\x0e\x85\x4b\xfa\x42\xdf\x6f\xa4\x68\xdd\x48\x7f\xd9\xb6\x6f\xed\x13\xde\xa6\xbf\x0e\x9f\xf6\x5d\x8d\x83\x06\xeb\x71\xc2\x63\x5d\x50\xc1\x08\xa3\x79\xa1\x3b\x94\x09\xef\xa5\xf8\x69\x3f\x75\x42\x6d\x20\xc6\x07\x5a\x7c\x07\x8b\x2b\xe8\x58\x1f\x65\xc9\x97\x92\x41\x62\x18\x1d\xb9\x85\x85\x75\xb1\x9e\xf8\x97\x75\xa9\xe3\xf2\x2c\x6b\xc7\xde\x42\x97\xba\xbe\x7d\x16\x7d\xbd\x85\x0e\x91\x99\x7e\xac\x94\x3f\x35\x5b\x88\x72\x9a\xd9\xd3\x6e\xbb\x47\xfa\x2d\xf8\xfa\x09\x8a\xdc\xee\x87\xec\xde\xd1\x59\xbd\x73\xf9\x08\x31\x37\x9c\x0b\xee\x8e\x5c\x54\xda\xd0\x28\xae\x43\x8b\xb5\xea\x08\x43\x6f\x8e\xbe\xc0\xff\xb8\xa2\x60\xc7\x69\xea\xa2\xa3\x4b\x05\x93\x32\xb3\xb6\x7a\x35\x22\xb4\x60\x3f\x80\x54\x68\x52\xbd\x65\x3c\x1d\x90\x92\xa5\x5f\x77\xa9\x2a\x65\x47\x8f\xbb\x20\xbc\x47\xaa\xdf\x9d\xb8\x76\x0e\xc7\x90\x77\x55\x44\x84\xd8\xd4\x47\xc4\x4d\x6f\x03\x76\x42\x46\x4f\xa0\xe9\xda\x89\x8a\xd8\x2d\xec\x97\xae\xee\xd7\x84\xd5\x3a\x73\xaa\x0a\x5c\xe9\x3b\x5f\x68\x4e\x55\xed\xa3\x46\x06\xc3\x06\xcd\x3f\x55\x41\x13\x18\x90\xbf\x57\x3f\x62\xc3\x65\xf5\xd3\xfe\xfe\x9f\xbf\x3b\xfb\xeb\x7f\xee\xef\xff\xfc\xf7\xf0\x2a\xb2\x42\xd4\x9a\x97\x6e\x41\x1b\x3c\x17\x29\x5c\xe0\x3b\xf0\x4f\x27\xae\x1d\x27\x89\x28\xb9\x76\x17\x30\x6d\x79\x34\x13\x4a\x9f\x5f\x56\x7f\x16\x22\x5d\xfe\x4b\x75\x2a\x95\xf6\x2c\x19\x03\x6e\x51\x87\xf4\x1b\x3b\xfa\x63\x0f\x35\x2d\xe9\xf9\xa8\xba\x59\x3d\x36\x62\xc9\x5d\xeb\x89\xf9\xc6\x83\x00\x5b\x5c\xfa\xfa\x08\x1c\x93\xca\x8d\x64\xda\xac\x9b\xb7\x37\x7f\xdb\xa9\x99\xaf\x1d\x3d\x92\xb6\x6a\x07\x7b\x06\x18\x42\xc4\xb7\x52\xc2\x83\x5c\x31\x58\xaf\xa5\xd4\xee\xe6\xe3\xcb\x73\x32\xb7\x10\x7e\x36\xc0\xf1\x4e\xb4\x6f\x3e\x29\x8d\xab\xbd\xa0\x4b\xc9\xab\xef\xac\xbf\xda\x5f\x77\x85\x04\x54\x55\xdb\x0b\x8c\x62\x73\x60\x7f\x1c\x25\x45\x39\x70\x37\x8c\x72\xc8\x85\x5c\x54\x7f\x56\x2e\xc2\xa1\xd2\x42\xd2\x29\x26\x9e\xd8\xc7\xed\x63\xd5\x5f\xf6\xc1\xc6\x0b\x56\x9f\xb6\xaa\x70\x52\x4a\x23\x34\x64\x8b\xba\xf4\xe7\xeb\xa3\x6d\x1e\xf4\xcf\x84\xb4\x55\x98\xd1\xb5\xef\xa3\x1d\x4d\x84\xac\x83\x04\x50\xe0\xac\xa0\x88\xfa\xa4\x4b\xac\x1d\x54\x62\x90\xb5\x06\xf0\xb9\xd1\x2c\x5b\x97\x06\xab\x47\x8f\xd4\x2c\x65\x73\xa6\x44\x87\xf4\x9a\x6a\xa2\xcd\x39\x03\xae\xb6\x87\x8d\x8c\xaa\xcc\x66\xf7\x05\x56\x43\xaa\xce\xeb\x12\xd9\x7f\xdb\xa5\xd3\xb7\x1d\x05\xd5\x1a\x24\x7f\x47\xfe\xfb\xe0\x6f\x5f\xfd\x3a\x3c\xfc\xfa\xe0\xe0\xa7\x37\xc3\xff\xf8\xf9\xab\x83\xbf\x8d\xf0\x1f\xff\x7a\xf8\xf5\xe1\xaf\xfe\x8f\xaf\x0e\x0f\x0f\x0e\x7e\xfa\xee\xc3\xb7\x37\x97\x67\x3f\xb3\xc3\x5f\x7f\xe2\x65\x7e\x6b\xff\xfa\xf5\xe0\x27\x38\xfb\x79\xcb\x49\x0e\x0f\xbf\xfe\xb2\xf3\xd2\x7b\x28\x4e\x6a\x47\x9f\x25\x4a\x9b\x33\xf6\x82\x7e\x9f\xb0\xc8\xbf\x1d\x1e\xbd\xfa\x3e\xff\x3e\x3c\xfa\x5d\xcd\x90\x2a\x76\xfd\x6c\x0e\xb8\x82\x44\x82\xfe\x1c\x96\x1c\xfb\xa6\x20\x50\x66\x5f\x91\x4a\xb5\x78\x6d\x7c\xee\xb7\x60\xdc\xf1\x62\xbb\xdd\xd7\x5a\x12\x9d\x48\x91\xfb\xb4\x77\x74\x6f\x60\x9b\x6b\x7f\xdf\x2d\x74\x6a\x96\x68\x47\x34\x06\x45\x63\xd0\x86\xf1\xa8\x31\xe8\xda\xe2\xe1\xb3\xb5\x04\x01\x9f\xb7\x75\x61\xac\xf5\xa0\x7b\x5d\x27\xac\x11\xb7\x9d\x43\x6d\xe4\x8f\xba\xaa\x3c\x71\x75\x24\x8d\x65\x68\xf9\x7a\x1f\x26\x76\xb1\x67\xdc\x1e\x7c\x9c\xa0\xce\x2b\x71\x5d\x0d\x6c\x09\x43\x98\x9b\x25\x54\x35\xb0\x1b\xd5\x2e\x31\xba\x14\x63\x5e\x7f\xb4\x21\xa8\xb7\x36\x2a\xd5\x28\x69\x8c\xd7\x75\x42\x2b\xe1\xb0\x2e\x2e\x4d\x95\x12\x89\x8d\xa6\xad\xb2\x1c\xb0\x74\x9d\x5b\x36\xae\x06\xfb\x4c\x07\xfd\xc8\x6d\xe1\xe9\xfa\x5b\xc7\x0b\xac\x87\xc9\xe7\xbe\xf8\x76\xea\x73\x66\x70\x25\xeb\xe7\x78\x5d\x01\x08\x06\x11\x9d\x13\x2c\x88\x43\x40\xaa\x5f\x69\xd8\x14\x43\x31\xc4\xa4\xb6\xb2\xb6\x6b\xf3\xd7\x99\x8b\x77\xe7\x99\x95\x67\xab\x93\x30\xb4\xc2\x2c\x6b\xf3\x73\x93\x49\xbe\x06\x67\x60\x77\xf6\xf9\x9b\x63\x9d\x3d\xb1\xcd\x7e\x58\xe6\x0e\xbe\x93\x3e\xd9\x64\x1f\xce\x92\x42\xc2\x84\xdd\xf7\x74\x4e\x8f\x79\x6d\x89\x61\x29\x70\xcd\x26\xcc\xe6\xd0\x14\x12\x0a\xe0\x36\x79\x81\x26\x33\xa4\xfd\x8e\x53\xd6\xce\xe9\xe7\x18\xcc\x63\x05\xee\x7e\x49\xd9\xf5\x3a\x61\x3f\xd2\x31\x12\xe9\x58\xeb\xf1\x99\xe8\x98\xc3\xdc\xe7\x43\xc4\x30\xf2\xbc\x7b\xe8\xfb\x69\x10\xc7\x8e\x58\xbc\x33\x96\xd5\x79\x4e\x47\x38\x4b\x2b\xeb\x73\x27\x64\xc0\xd7\x5e\x96\x59\xd6\x53\xf5\xed\xfd\x73\x84\x46\x51\x66\x99\x4b\x3a\x1e\x91\x8f\x1c\xcf\xe3\x31\x76\x79\x18\x90\x0b\x98\x83\x1c\x90\xf3\xc9\x85\xd0\x97\x56\xb0\x6d\xc6\xb2\xd9\x1b\x09\x9b\x90\x77\x46\x65\x52\x9a\x68\x5b\x69\x3f\xa8\x0b\x24\x64\x63\x82\xba\xe4\x58\x87\x18\xf4\xcd\xdb\xf2\x85\xcf\x68\x1b\x3e\xd1\x36\x55\xad\x4c\x7a\xd0\x4d\x7d\xcb\x3a\x17\x1d\x87\x11\x91\xce\x35\xb2\x2e\xa7\xf7\x05\x96\xd9\x28\x84\xd2\xd7\x46\x85\xed\xa7\xcd\xcd\xa5\x9f\x0e\x3b\x47\xd0\x2c\x83\xb4\xd1\xe7\xc8\xf6\xe7\xa0\x4d\x15\x1a\xb3\x8d\xab\x76\x11\x40\x66\x94\xa7\x19\x48\x2c\xf9\xae\x96\xeb\x5a\xb1\xba\xc7\x41\xd5\x95\xc2\xa7\x85\xd2\x24\x11\x32\x75\xcd\x6a\x5d\xf2\x26\x2e\xa6\x3a\x5e\x48\x68\x73\xca\xe9\xd4\x76\x29\x5c\x29\x1c\x8c\xe5\xa4\x55\xd0\xda\x62\x26\xc4\x2d\x49\x44\x5e\x64\x78\x00\x3a\x9c\x8f\xba\xb3\x4e\x85\xa2\x43\xec\xa6\x78\x14\x34\xdd\xc1\x1f\x9e\xb0\x3b\x62\x1f\x72\x0a\xdc\x43\xd2\x5b\x57\x3e\x43\x11\xcd\x2e\xa3\x4f\x5c\xf0\x4a\x5c\x99\x08\x73\x18\xcd\x5e\xd7\xf5\x08\x2a\xa2\x37\x22\x67\xf7\x90\x04\x9d\x2d\xcd\x13\xae\xb5\xa5\x16\x68\x0f\xe9\xde\xb1\xb8\xb3\x29\xbf\x2f\xf3\x79\x87\x04\xb5\x70\x2c\x55\x9f\xc3\x39\x7d\xb1\x6d\xf7\x0a\xec\x5b\x60\x13\xa4\x31\x69\xcd\xd7\xdf\x6e\x9c\x21\x7b\x62\x57\x4a\xd6\x55\x01\xca\x7e\x2e\x4c\xd4\x16\x42\x93\x83\xfd\xa3\xfd\xc3\x15\xbb\xde\x52\xc5\xe6\x9b\xe0\x49\x86\x25\x0a\x0b\xac\xf7\x07\xc9\x7e\x3a\x20\x4c\x7b\x1a\x6d\x2b\x25\xe0\xaa\x5c\x26\xdd\x80\x28\x41\xb4\xa4\x29\x73\x9a\x13\xfe\x6a\x6e\xd2\xb2\x74\x65\x12\x0e\xf6\x7f\xdd\x1f\x10\xd0\xc9\x21\xb9\x13\x7c\x5f\xe3\xf2\xb1\xa6\x48\xa9\x82\x89\x16\xa2\xc4\xd6\x7d\x16\x04\x55\x81\x10\x43\xe8\x88\x28\x6d\x9f\x9f\x19\xd5\x3e\x83\xef\xec\x9e\x69\xdf\xdb\x42\x4c\xc8\x1b\xdb\x66\x08\xa8\xb3\x2c\x66\x6c\x0e\x47\x33\xa0\x99\x9e\xd9\xe0\x0b\x2e\xf8\xd0\x76\x8a\x33\x14\xc8\x5d\xe9\xea\x87\xe8\x66\xa6\x0b\x47\x07\x93\xdd\xea\x82\x3a\x4a\xe4\x86\xf6\x7e\xdb\xbe\x17\x2e\x59\x69\x13\x7d\x73\x73\xf9\x6d\xa3\x19\x2e\x12\x7f\xad\x0b\x1f\x12\x13\x14\xdb\x78\x06\xb4\xa3\x1f\x27\x60\xa7\x4e\xb6\xa4\x47\x12\xd6\xb5\xa3\x2d\x59\x6d\xfb\xbd\x5b\x2b\x5b\xf2\x57\x51\x62\x0b\x3e\x3a\xce\x16\xe4\x8e\x72\xed\xd3\xf7\xf6\xcc\x54\x7b\x86\x3c\x19\x6c\xf8\x0b\xd0\x14\xa4\x42\xea\x01\xb4\x75\x51\x31\x3f\x7a\x73\x4e\x05\x6b\xeb\x97\x0f\x94\x4a\x8b\x9c\xcc\xdc\x67\x37\x53\x1a\xdd\xc9\x18\xe1\xe9\xf1\xf9\x42\x12\x0a\x4b\xe1\xdc\x33\xaf\x8e\x7e\xad\xd0\x0d\x0b\xf7\x46\xf1\xfd\x24\x04\x5b\xd8\xa2\x85\x71\x0b\x2c\xdb\x5c\xb1\x27\x5a\xda\x43\x50\x01\xe9\x31\xb0\x80\x74\x4b\x90\x5c\x9e\x08\x9d\x65\xdd\x63\xa8\x7a\x8b\x55\x20\xbd\xf9\xe3\xc9\x3a\xe3\xa5\xc3\x19\x1b\x39\xdb\x13\x10\x7b\xf5\x82\x93\xee\x29\x98\xe1\x78\x18\x00\xfd\x6c\x3e\xe9\x13\x02\x45\x0f\x21\xd3\xab\x01\xd3\x2b\x2d\xc6\x91\x4c\xd8\x4a\x55\xcf\x86\xcb\x74\xed\xb7\x4e\xd6\xe7\x1f\x4b\xc2\xab\xf6\xb8\xfa\x45\xf4\x5c\x27\xfd\x85\x36\xf6\x1d\xd8\xd8\x6b\x58\xe3\x27\x0d\x6a\xc4\x54\x8a\xce\x54\xa4\x69\x53\xc7\x29\x0d\x06\x18\xbd\xcd\x68\x9c\x4e\xf6\x73\x46\x21\xdf\xc2\xa3\x69\x45\x35\x47\xed\x59\x9c\x31\x9d\x14\xd7\x22\xb9\xed\x51\xaf\xd9\xbf\x39\xb9\xb4\x53\x06\xaa\x0d\xe5\xde\x18\xc2\xf8\x5c\x64\x73\x5b\xe9\xef\xe6\xe4\x12\x4f\xde\x08\xff\x85\x86\x28\xd4\xa8\x17\xe6\x59\x1f\xec\xef\x5c\x38\x46\xfb\xb6\x16\x34\x4a\x24\xd0\x8c\x29\xcd\x12\x7c\xae\xb2\x6d\xe1\x0c\x5d\x7c\x37\x51\x53\x5a\x37\x7a\xd7\x94\x82\x6e\xb3\xbb\x2a\x4d\x5d\x83\xf3\x9e\x31\x5f\x72\xfc\x48\x56\xcd\xd4\x22\x5f\xea\x69\xbe\xe7\xcb\x97\x0a\x09\xd7\x5a\x14\x3d\x79\x42\xec\x64\x1b\xfc\x20\x63\x98\x08\x09\xcb\x8e\x90\xc0\xb1\x91\x96\xe0\x0a\x71\x1e\x5f\x9e\x57\x26\x28\xd1\x70\x5e\xd8\xb0\x44\x5f\x7d\x33\x63\x73\xe0\xa0\xd4\x11\xba\x3c\xca\xc2\xaa\x98\xbe\x6f\xee\xc0\x7c\x1d\xe4\x85\xad\x5f\x59\x85\xfa\xbb\xae\xbd\xf8\x23\x68\x5b\x78\xb2\xf2\xbf\x38\x8b\xaa\x5f\xfe\xb2\xab\x24\x91\x54\xcd\x6c\x47\x5b\xb8\x67\xda\x75\x65\x96\x40\x95\xe0\xd6\xd8\x1b\x34\xd7\x65\x8a\x14\x54\xa9\xba\x0c\xb8\x7b\x89\x7d\xe8\xd2\x96\x0e\x0e\x1f\x98\x4a\x9a\x00\x29\x40\x32\x91\x12\xcc\xb9\x4d\xc5\x1d\x27\x63\x98\x32\xae\x3c\xfc\xcc\x44\x1e\xd0\x86\xdd\x00\xda\x86\x7d\x45\xb5\x11\xb9\x6a\x14\x0a\x71\x29\x3c\x89\xa8\x4f\xb4\x5b\xc5\xb2\x93\x09\xa3\x26\x11\xbc\xb6\xad\x4c\xb5\x31\x61\xa7\x9d\x47\x16\xdd\x83\xb7\xc9\x36\x83\xf2\xd7\x36\x42\x07\x0b\x9e\xd2\x64\xd6\xcd\x7d\x1b\xdd\x53\x5b\x8e\xe8\x9e\xda\x6d\x44\xf7\x54\x74\x4f\x6d\x1e\xcf\xce\xbc\x1b\xdd\x53\x51\xe9\x5a\x1e\xd1\x3d\x15\xdd\x53\x1b\xc6\xb3\xa3\x5f\xd1\x3d\xb5\xc5\x88\xee\xa9\x2d\x47\x74\x4f\x45\xf7\x54\x74\x4f\x45\xf7\xd4\x6f\xc8\x0c\xe8\x47\x74\x4f\xad\x4c\x12\xdd\x53\x01\x30\xa2\xa6\xb4\x66\x44\xf7\xd4\x9a\x11\xdd\x53\xc1\x88\x7c\xa9\x05\x5f\xf2\xce\x9d\x4b\xa3\x97\x75\x6f\x23\x8c\xda\x1d\xd6\xf3\x7b\xa5\x69\x4d\x5d\x6c\xfc\xcf\xda\xbe\xff\x4c\x7c\x28\x3d\xd8\xf4\xa3\x3d\xff\xd5\xd9\xf3\xfb\xb1\x85\xf5\x60\x07\xeb\x4c\xca\x9d\xd7\xfc\x66\x26\x41\xcd\x44\xd6\x1a\xd1\x1b\x48\xfe\x81\x71\x96\x97\xb9\xc1\x39\x65\xf0\x99\xcd\x2b\xf7\xbc\xaa\x5b\x32\xa3\xd7\xde\x9a\xe4\xcc\x8d\x2c\x05\xac\xc6\x49\x59\x66\xb6\x11\xf3\x27\x67\x14\x65\x62\x55\x26\x09\x00\xf6\xfa\x0a\xd5\x85\x3f\x8c\xaa\x37\x55\xbd\x1d\xde\x76\xa3\x37\xdd\x98\xac\xad\x97\x89\xb3\xfc\xe1\xf7\xad\xe6\xe8\xe8\x4e\xf9\xfc\xae\x94\x1e\xc8\x74\x77\xc5\xa0\x93\x52\xd0\x07\x97\xe8\xaa\x0c\xbc\x34\x97\x49\x6f\xae\xc3\x1e\x5c\x25\xcf\xc8\x4d\xf2\x6c\xd8\xc2\x73\x71\x8d\x3c\xc3\x52\xa0\x3d\x58\xf2\xfb\x70\x85\xf4\xe7\x06\xf9\x04\x15\x33\x3f\x8d\xfb\xa3\x47\xb5\xb3\x27\xb7\xc7\xe7\x70\x79\xf4\xf2\xd5\x5d\x5d\x1d\x9f\xcf\xcd\xd1\xcf\xe7\x76\x34\x23\xbd\x0a\xd7\x46\x0f\xe6\xa3\x3e\x4d\x47\xbd\x99\x8d\x3e\x99\x2b\xa3\xbb\x1b\xe3\x19\xb8\x30\x3a\x03\x99\x71\xa6\x19\xcd\x4e\x21\xa3\x8b\x6b\x48\x04\x4f\x5b\x73\x98\xa5\x12\x6a\xd5\xf9\x51\x76\x5a\xa7\xa3\x35\x03\x7d\x67\xd4\x55\x8a\x85\xd4\xc7\x2e\x7b\x93\x9e\x13\x28\xd0\x1a\x67\x57\xd9\xa6\x0e\xd3\x9d\x90\xb7\x99\xa0\xa9\x3a\x2a\x84\xfd\xbf\x3a\x8c\x37\x88\xdf\xb5\xef\xea\x16\xc0\xfb\xd4\xca\xa0\x8d\x7a\xee\x73\x13\xff\x22\xee\x88\x98\x68\xe0\xe4\x80\x71\xbf\x8f\x87\x81\x1a\x58\x6b\xe6\x15\x5a\x9b\xab\x6f\xdf\xf8\x9b\x5f\x9f\xca\x8d\xc6\x05\xa5\x3e\xbd\x05\xc4\xbd\xe8\x71\x13\x88\xbb\x71\x52\x66\x4d\x33\x88\x35\x8d\x34\xe9\xcd\xdb\xba\xd6\xe5\x5b\x9c\xb7\x3a\x6d\x94\xa7\xc4\x65\x48\xbc\xbe\x4d\xeb\xec\xa0\x7d\x0d\xce\xd9\x68\x7b\x21\x7d\xdb\x5e\x9e\xc8\x09\xfb\x0c\xa5\xe6\x17\xea\x78\x8d\x52\xf3\x0e\x23\x48\xb4\xfa\x56\xd2\x04\x2e\x7b\x17\x38\xfc\x71\x22\x69\x29\x5d\x7e\x5c\x25\x77\x54\x87\x87\x03\xa4\xf6\x34\x55\xd9\x67\x98\xf6\x35\x29\xb3\x6c\x41\xca\x42\xf0\x66\x8a\x9f\x75\x5a\x2d\x67\x86\x99\xd9\xd6\xbd\xa5\x96\x52\x0b\x29\x1c\x03\x96\x25\xe7\x86\x9e\xd7\xdd\x6f\x50\x2a\x55\x96\x56\x87\xf9\x67\x8a\x4d\xcd\xf2\x0d\x33\xc5\xd4\x34\x96\x43\xdd\x1f\xa1\x9e\xd0\x3c\x3d\x11\x32\x61\xe3\x6c\x41\x66\x34\xab\x5a\x1d\x50\x72\xcb\xb2\xcc\x4d\x33\x22\xd7\xa0\x89\x9e\x31\xd7\xa5\x9a\x64\x82\x4f\x71\x71\x94\xfb\x16\x5b\x90\x98\x67\x93\x0c\x28\x2f\x0b\xfb\x3e\xc3\xd6\x17\xa2\x94\xfe\x7d\xae\x7e\x64\x35\x0b\x53\x84\xb3\x6c\x10\x34\xf2\x79\x70\x63\xeb\x6e\xe9\x0a\x7c\xf2\xde\x1d\x53\x30\x08\xe7\x14\x73\x90\x92\xa5\xce\x69\x60\x7f\x2b\xa4\x98\xb3\xd4\xb6\x62\xf0\x60\xc3\x96\xa1\xb6\x55\x43\x75\x9e\xb9\xe0\x43\x0e\x53\x8a\x52\x8f\x3b\x45\x76\xcf\xec\x3c\xd6\x15\xc7\x53\x6c\xde\x60\xd4\x05\x51\x34\x72\x46\xe7\xcc\xb6\x9d\x0c\x20\x47\x0e\xb8\x20\x02\xd9\x6b\xc9\x99\xb6\xad\x8c\x67\xa5\x26\xa9\xb8\xe3\x87\x66\x72\xa6\x0c\x1c\x28\x19\x83\xf6\x6d\x55\x7d\x9b\x3f\x26\x41\x11\xe0\x74\x9c\x99\x3d\xc7\x98\x80\x9b\xb5\x00\x22\x13\xa0\xba\x94\x40\xa6\x54\xc3\x5a\xa1\xc9\x7e\xef\xc3\xe0\x65\xaa\x6a\x39\x5e\x72\x05\xad\x9b\x2d\xf7\x2c\x69\xfd\xe9\x8f\xed\x68\x04\xcb\x41\x94\xfa\xb3\xa8\x92\xb6\x1d\x7f\x20\x19\xb3\x1c\x14\x11\xe5\x92\x8e\xfd\xd6\x3d\xb6\x7e\x87\xa2\x3e\xb9\x6e\xb4\xb5\x12\xaf\x31\xa5\xb9\x6e\x80\xab\xf1\x33\x41\xb7\x53\x6a\x8e\xe2\xe9\xc5\xf5\x2f\xef\x8f\xff\xeb\xec\xbd\x3b\x9f\x3c\x64\xfa\x25\x67\xff\x28\x81\xd0\x5c\x18\xb9\x3a\x0b\xc3\x70\x06\x68\x1e\x08\x7e\xc0\x93\xdc\x6f\xc0\x4e\x4b\x86\x8c\xad\x99\xbb\x87\x25\x61\x83\xe7\x4f\x1f\x95\xf4\xd4\x2d\x6b\xaa\x96\x9b\xe6\x83\xc3\x96\x35\x94\x70\xd0\xe6\xe4\x59\x89\xd2\xb6\x30\x62\x7c\x9a\x85\xc2\x64\x3b\x72\xd5\x55\x27\xea\xaa\x11\x0d\xeb\x2f\xb8\x6c\xab\x18\xf5\xd2\x3a\xa7\x5e\x43\x4f\x0d\x27\x6a\xaa\xed\xd5\x00\xdb\x11\xd4\xab\x01\x56\xf4\x38\xbf\x24\x34\x4d\x25\x8a\x29\x78\xea\xf3\xa5\xc6\x73\xf8\xb0\x35\xc6\x0f\xc8\x1b\xf2\x67\x72\x4f\xfe\x8c\x6a\xc1\x9f\xba\xb6\xe7\xe8\x2a\xb0\x77\x37\x4b\x58\x6d\xf4\xfc\xb2\x27\x88\xff\x38\xa3\x1a\x67\x34\x50\xd5\x82\x8c\x99\x13\x43\xe1\x5e\x83\x34\x62\x91\xdb\x89\x27\x6d\x6c\x62\x16\xf8\x19\xd1\xcc\xda\xdc\xcf\x27\x61\xe5\x7f\xbd\x23\xa2\x99\xc7\x8d\x7e\x7f\xe1\xa8\x50\xb3\x8f\x40\x3d\x5b\x4e\x75\x32\x6b\x92\x31\x23\x60\xa8\x06\x73\x4a\x05\x92\x71\x1b\xbf\x36\x63\x1d\x22\x08\x9e\x0f\x1a\x77\x73\x2a\x37\xf6\xf3\xa1\x9d\x5a\x52\xfc\x91\xcf\x3b\xc1\x20\xa8\x3f\x52\x88\x74\x44\xce\x68\x32\xc3\x65\xa5\x01\xcf\x30\x1a\x08\x4e\x36\xa3\x73\xb3\xf1\xee\x59\xdb\x77\x03\xa5\x95\xca\xd4\x8a\xb8\x64\xce\x53\x42\xb9\xed\x7c\x37\x01\x29\x6d\xc8\xe1\x78\x81\x9e\x4f\x96\x40\xe7\xcd\xeb\x74\x92\x0a\x29\xb4\x48\x44\x87\xde\x2b\xcb\xd1\xcf\x38\x1d\x02\xc1\x1a\x2d\xbd\xad\xf8\xfb\xd3\xcb\x01\xb9\x39\xb9\xc4\xa6\x19\xd7\x27\x37\x97\x4d\x09\x7b\xef\xe6\xe4\xb2\x43\x0f\xff\x5e\x6c\x1e\xce\xcc\xf6\xce\x2c\x73\xe7\x49\x24\xd0\x94\xc5\x38\xf2\xed\x47\x8c\x23\xdf\x3c\x62\x1c\x79\x8c\x23\x8f\x71\xe4\x0f\x8f\x18\x47\xee\xc6\xd3\x9b\x7a\x48\x8c\x23\x6f\x39\x5e\x97\x2f\x33\xc6\x91\xef\x34\x62\x1c\xf9\xea\x88\x71\xe4\x1b\x46\x8c\x23\xdf\x30\x62\x1c\x79\x8c\x23\x8f\x71\xe4\x31\x22\xe6\xd1\xb9\x9e\x67\x44\x0c\x89\x71\xe4\x6e\xc4\x38\xf2\x57\xe1\xf7\x27\x31\x8e\x7c\xab\x11\xe3\xc8\x63\x1c\x79\x9b\x11\xe3\xc8\x71\x44\xdb\x4b\x8c\x23\xf7\x23\xc6\x91\xdb\xf1\xdb\x91\x9a\x63\x1c\x79\x8c\x23\x8f\x71\xe4\x31\x8e\xfc\xc1\x55\xc4\x38\xf2\xd7\xa0\x4f\xfa\x86\x5a\xdd\x83\xa0\xaf\xfc\x4c\xdb\x87\xd5\x90\xb3\x35\xbf\xa2\x59\x45\x15\x66\x12\x59\x4f\x99\x49\xa0\xe9\x02\xa7\x4c\xd0\x2d\x53\x0b\x59\x2f\x30\x3a\x27\x63\x39\x6b\x17\x77\x4e\x56\x0e\xcd\x7b\x9c\x2b\x70\xe1\x18\xb0\xe4\xf4\x1e\x0f\x00\xcd\x45\x69\xfb\x77\x25\x22\x2f\x4a\xdd\x84\x29\x6e\x4f\x9b\xd6\x5b\x13\x36\x75\x1c\xf5\xc8\x76\x09\x1b\x56\xd3\x0e\x83\xce\x5c\x4f\xa8\xc0\xd0\xd4\x87\x9f\x5c\xf6\xa0\x4b\x14\x54\x6b\x90\xfc\x1d\xf9\xef\x83\xbf\x7d\xf5\xeb\xf0\xf0\xeb\x83\x83\x9f\xde\x0c\xff\xe3\xe7\xaf\x0e\xfe\x36\xc2\x7f\xfc\xeb\xe1\xd7\x87\xbf\xfa\x3f\xbe\x3a\x3c\x3c\x38\xf8\xe9\xbb\x0f\xdf\xde\x5c\x9e\xfd\xcc\x0e\x7f\xfd\x89\x97\xf9\xad\xfd\xeb\xd7\x83\x9f\xe0\xec\xe7\x2d\x27\x39\x3c\xfc\xfa\xcb\xd6\x4b\xee\x2c\xf0\xf6\x27\xee\xf6\x24\xec\x7e\x12\x51\xd7\xf9\x7e\x7b\x3a\x8b\x57\x6e\xb6\xe5\xd3\xe8\xd8\xd1\x43\xa7\xd1\x6b\xdc\x28\xc4\x55\xf3\x30\x45\x44\xce\xb4\x76\x54\x94\x86\x51\x5f\x4c\x37\x54\x4e\x47\x07\xb0\xdb\x21\xd5\xb6\x9d\x60\x15\x31\x15\x44\xec\x0a\x2f\xd7\xb9\x36\x8d\x95\x35\x02\xcf\xf3\x30\x85\x09\xe3\xe0\xbc\x5c\x91\x36\x3c\x3e\x22\x6d\x78\x8d\xb4\x41\x41\x52\x4a\xa6\x17\x27\x82\x6b\xb8\x6f\x65\x3f\xd9\x64\x40\xba\x6e\x4e\x4d\xec\x89\xb3\x94\xc2\xbf\x96\x88\xc2\x06\x4a\x6e\x4c\xcd\xab\x82\x6e\x65\xc9\x51\xa5\xb4\x39\x14\xa0\xad\xbe\x87\x9a\x0e\x46\x41\x2e\xbf\xce\x6b\x70\x76\xea\x7f\x94\x6c\x4e\x33\xa3\xdf\xd6\x4f\x5c\xa2\xce\x12\x3e\xd4\xca\x88\xf5\xc4\x32\x16\x8a\x37\x97\x92\xcd\x59\x06\x53\x38\x53\x09\xcd\x90\x2a\xf5\x43\xe9\x8f\x37\xcc\x8e\x5b\x24\x45\xa6\xc8\xdd\x0c\xb0\x8d\x2a\xf5\xea\x39\x66\x2a\x4c\x29\xe3\x24\x37\x44\xb5\xf0\x0f\x2b\xab\xe7\x1b\xe2\x6d\xa4\x5e\xae\x6b\x7d\x1e\xd5\xd7\xb1\x10\x99\x0b\xeb\xcd\x16\xf5\xfc\xae\xad\x2d\x17\xbf\x70\xb8\xfb\xc5\xcc\xa6\xc8\x24\xa3\xd3\x4a\x8d\x57\xa0\x57\x2c\x71\xf5\xd4\x1b\x3f\x00\x63\x66\x4b\x20\x34\xbb\xa3\x0b\x55\x1b\x35\xc2\x86\xbf\xef\xc8\xdb\x43\x44\x3c\xaa\x48\x35\x47\x4a\x7e\x7f\x88\x7e\xbe\x93\xe3\xcb\x5f\xae\xff\x7a\xfd\xcb\xf1\xe9\x87\xf3\x8b\x6e\x74\xde\x7c\x3b\x50\xde\x6a\x8e\x84\x16\x74\xcc\x32\xd6\x85\xbc\xaf\x44\x82\x84\x93\x22\x03\x4d\xd3\xa3\x54\x8a\xc2\xc2\xc9\xdb\x8f\x42\x1d\xe7\x74\xc9\x2c\xec\x78\xb6\xdd\x9e\x49\x73\xc2\xa9\xa4\x5c\xd7\x86\x94\x1a\xe4\xb2\xe4\x46\xe9\x7d\xe1\x41\xf3\x34\xed\x2f\x60\xfe\x38\x4d\x21\x6d\x40\xef\xd5\x05\xe8\x9d\xf8\x8f\x5b\xd4\xb9\xb6\xe4\xf2\xe3\xf5\xf9\xff\x5e\x42\xc3\x45\xd1\x2d\x1e\xa9\x9f\xfc\x1e\xd9\xbe\x03\x39\x59\x35\x26\xe4\x62\x1e\xf7\xf7\xb9\xec\x6f\xc5\xab\xfa\xf1\x82\x5f\x95\x3c\x64\x27\x3c\x98\x9f\xe4\x22\x85\x11\xb9\xac\x2c\xe8\xcd\xab\x61\x0d\x01\x09\xc4\xdc\xc2\x35\xc3\x56\xe7\x81\x28\xa3\x85\x4d\x74\x69\x64\x98\x86\x74\x78\x42\x33\xd5\x91\x98\x76\xe1\x4c\x86\x09\x7f\x30\xaa\x60\x2f\xd0\xac\x66\x23\x29\x70\xa1\x9d\x24\x69\x56\x89\x49\xb7\x52\x24\xc4\xea\x9d\x41\xc8\x52\x83\xbb\xb8\x06\xf8\x9e\x31\x31\xe5\x61\x75\x59\xcd\x6c\x2d\xb0\xa5\x02\xb5\x9e\x31\xd5\x9a\xa8\x99\x5d\x02\x4d\x31\x5f\xac\xa0\x7a\x66\x23\x0e\x72\xaa\x6e\x21\xb5\x3f\x38\xb9\xa6\x32\xc1\xdb\x66\xf8\xee\x55\x37\x66\xdd\xde\xde\x8e\xf2\x8c\x8d\x83\x40\x3b\x3d\xb4\x8e\x4e\xef\x7c\x04\xcc\x37\x7d\xe4\xd9\xe2\x4a\x08\xfd\x4d\x95\x27\xd5\xcb\x06\xfe\xe8\x24\x45\x74\xb3\x34\x43\xa6\x30\x40\x20\x1d\x22\x30\x11\xa5\xc3\x14\xad\xd3\x7a\xc3\x9e\x18\xa1\x65\xc9\x8f\xd5\xb7\x52\x94\xad\x39\xc0\x8a\xa0\xf5\xed\xf9\x29\x9e\xe3\xd2\x79\xc0\xb8\x96\x8b\x42\x30\x6b\x3e\xd9\x20\xd3\x7e\xef\x7c\x78\x21\x46\xd6\xee\x16\xf2\x81\x2e\x08\xcd\x94\xf0\xc2\x31\xe3\xeb\x54\x1d\xe2\xf4\x28\x73\x79\x2c\xf4\x6c\x45\x81\x32\xe8\xbc\xfa\xdc\x20\x70\x88\xd5\x75\x53\x18\x5f\x79\x5c\xd3\x5b\x50\xa4\x90\x90\x40\x0a\x3c\xe9\xb8\x6b\x4f\xed\x06\xc2\x9d\xbf\x10\xdc\x1c\x8b\x5e\xf6\xfe\xbc\xf2\xff\xa1\x19\xab\xb9\xd3\xe8\x49\x74\x7a\x07\x45\x7f\x22\x1e\x8a\x52\x81\xb4\xce\x4f\x59\x82\xdd\x88\xef\xca\x31\x64\xa0\xad\x32\x84\xf5\x03\xa8\xb6\x2a\x2f\xcb\xe9\x14\x08\xd5\x15\xa2\x68\x41\x80\x2b\x43\x6e\xac\xe1\x4c\x93\x54\x40\x9d\xdc\x48\x15\xf9\xfe\xfc\x94\xbc\x21\x07\xe6\x5d\x87\xb8\xfd\x13\xca\x32\x74\x35\x6a\x2a\x97\xd7\xc8\x26\x7e\x0a\x5c\x12\xe2\x1e\x11\xd2\x1e\xd1\x01\xe1\x82\xa8\x32\x99\xf9\x35\x19\x8d\xcb\x2b\x6c\x2e\xd6\x0e\x4d\xf2\xaf\x10\x55\x3b\x13\x98\xef\x15\xc8\xde\xe8\xcb\xf7\x2d\xe8\x4b\x28\x42\x18\x9c\x6b\x42\xcf\x22\x56\x0e\x9a\xa6\x54\x53\x47\x77\xea\x8c\xe8\xd7\xb8\xa5\x4f\x4d\x7d\x14\xbc\x67\xbc\xbc\xb7\xb6\xb5\xfe\x94\xfc\xeb\x33\x9c\x16\x51\x00\x81\x86\x9b\x46\x8b\x22\x63\xb5\xe7\x31\x88\x6e\x3a\x6f\x6c\xf5\x60\x83\x88\x84\xc7\xdc\x3b\x30\x0d\x67\xa7\x3c\x15\xf9\xca\xcb\xd0\x5b\x4a\x93\x59\xf8\x82\x57\x89\x3c\x4f\x6e\x8e\xc8\x60\x0e\x1d\x6a\x73\x2c\x21\xce\x7b\x33\x9b\x91\xc5\xfc\x86\xe2\xf4\x24\xa3\x63\xc8\x2c\x67\xb1\x08\xa4\x56\x11\xe8\xa9\x23\x04\xa5\xc8\xfa\xcb\x8f\xb8\x12\x19\xd8\x90\x1b\x0f\x08\x33\xfd\x8b\x80\x03\x4e\xd2\x17\x1c\x50\x91\x69\xc0\x01\x55\xb2\x97\x00\x87\xb2\x03\xa3\x25\xcb\x70\x30\x5c\xbb\x09\x07\x64\x9d\xcf\x1d\x0e\x0a\x92\x44\xe4\xc5\xa5\x14\x46\xe5\xea\x8d\xb5\xb8\x69\x6b\xff\x8e\xd5\xc9\xd1\xe0\x1b\x6a\x7f\xce\x9b\xd3\xbc\x99\xca\x20\xd8\x8e\x6a\x4b\xe3\x7d\xc4\xdd\xff\x0a\x58\x0e\x92\x9e\x65\x3e\xe4\x67\x69\x38\x80\xcc\x93\xee\xc2\x0b\x4f\xf5\xef\x60\x25\xeb\x85\x99\x88\x84\x66\x58\x3a\xad\x1b\xc6\x90\x65\xac\x59\x9e\x38\x88\x90\x44\xd7\x12\xfe\xe6\xbd\xf6\x58\x45\x0b\x7f\x71\xb6\x2f\x2e\x52\x08\x9c\x85\x36\xb4\xf3\xc6\x46\xd2\xe1\x7d\x3e\x38\xd3\x70\x75\xe7\xbc\x87\xb4\xf1\xb4\x16\xae\x3a\xcb\x87\xaa\x20\x9b\x59\x20\xf0\x94\xf1\x29\x5a\x74\x06\x44\x42\x66\xc3\x3a\xdd\x19\xbe\xb5\xea\xd7\x3e\x62\xb4\x9f\xd4\xa3\xb3\x7f\x35\x4a\x42\x4c\x70\x37\x33\x1a\x39\xbc\x7c\x33\xb1\xd4\x92\x29\xb2\xf7\xde\x03\xa0\x43\x05\xab\xe7\xc8\x20\xf6\xec\x17\x56\xbb\x69\x6d\x6c\xb7\x8c\xa7\x2e\x02\xb2\x01\x2c\xaf\x24\x3a\x29\x14\x63\x6b\x59\x1a\x92\x86\x77\xe4\x6f\x9c\x54\xc0\x22\xc3\xd6\xe8\x71\x65\x05\x56\x6f\x5e\x1a\x3e\x6c\xf2\xab\x5e\xb2\x3c\xcd\xf7\x1c\xf7\xde\xbc\x77\x68\xd4\xde\xd5\xfb\xfc\xb7\xec\x3d\xe5\xbe\xde\x31\x9e\x8a\x3b\xd5\xb7\x0e\xf1\xa3\x9d\xd6\x0b\xd4\x89\x41\x6b\xcd\xf8\x54\x85\x7a\x44\xb3\x4e\xee\x7a\x45\xc2\xef\xf0\x44\x0a\x9b\x86\xb7\x2a\xc0\x2f\x45\x6e\x47\x25\x60\x87\x31\xcd\x15\x3d\x91\xe6\x53\x34\xa3\xd9\x75\xd1\xbe\x6c\x1a\x59\x46\x83\x6f\x3f\x5c\x1f\x37\xa7\x36\xf4\xec\x6e\x06\xd2\xf2\x5e\x73\x9d\xd0\x34\x67\x4a\xa1\x19\x08\xc6\x33\x21\x6e\xc9\x81\x0f\xb4\x9a\x32\x3d\x2b\xc7\xa3\x44\xe4\x41\xcc\xd5\x50\xb1\xa9\x3a\x72\x48\x3b\x34\xab\x3f\x24\x8c\x67\x55\x04\x09\xaa\x91\x5c\x2b\x6f\xc6\xc0\x97\x24\xd5\x2a\x70\x6f\x5d\xdd\x45\xe7\x65\x5e\x5d\xa6\xad\xb4\xc8\x20\x7b\xfa\x62\x30\xab\xdb\x73\xd1\xb1\xae\xc5\x23\x5b\x84\xdf\xee\xd2\x46\xc2\x14\xa7\xb5\x70\xb4\xd2\xdb\x93\x03\xc9\x49\x07\x09\xa8\xfe\x2a\xe6\xfc\xa5\x9e\x93\xa4\x60\x33\x1b\x00\xa3\x4e\xe8\xc6\x30\x24\xb4\xca\xee\x63\x82\x9c\x7b\x74\x3f\x94\x68\xd1\xeb\x63\x53\x30\x8c\x3e\x90\x15\x33\x3a\xb4\x4a\xb2\x21\x49\x48\xc3\xbc\x0c\x30\x13\x5c\x48\x8b\xa2\x86\x0b\x0a\x8e\x28\x8d\xda\x82\x75\x04\xe1\x9e\x38\x1a\x1b\x2c\xf5\xa4\xf6\x0f\x86\x3e\x24\x4c\xb0\xb1\x09\xfa\xf5\x1a\xee\x98\x9e\x61\x11\xb9\xd9\x92\xc3\x09\x57\x22\x41\xa1\xf7\x80\x13\x90\x52\x48\x17\x08\xe3\xad\xb6\x38\x13\x92\x62\x8c\xa4\x31\x48\x42\xcd\x5f\xfb\x2a\x74\x51\xd6\xa5\x4c\x31\xb6\xcb\x60\x13\x4c\x26\x90\xa0\xa4\x14\x02\xd8\x92\xdd\x83\xba\xaa\x9e\x0f\x9d\xd7\xc2\x97\x42\xcd\xd9\xbd\x79\x4b\xf8\xd4\x52\x41\x75\x2e\xf8\x70\xfd\xe5\xc3\x11\x21\xe7\xbc\x8a\x7b\x1c\x98\x5d\x0c\xef\xf4\x21\x3f\xda\x7c\x62\x58\x47\x17\x3f\x20\xb4\x3b\x19\xf1\x4e\x96\x3d\x60\x7c\x17\x63\x30\x09\x0d\xc2\xbd\x92\x03\x34\x0c\xbb\x49\xcd\xd6\x7b\x26\xde\xc5\x50\x6c\x6e\xf9\x54\xc6\xe2\x97\xc1\xe9\x49\x57\x3a\xe7\xd2\xd5\x63\xed\xd7\xed\x46\xac\xfd\xba\x79\xc4\xda\xaf\xb1\xf6\x6b\xac\xfd\xfa\xf0\x88\xb5\x5f\xdd\x78\xfa\xf4\x4c\x12\x6b\xbf\xb6\x1c\xaf\xab\xfe\x48\xac\xfd\xba\xd3\x88\xb5\x5f\x57\x47\xac\xfd\xba\x61\xc4\xda\xaf\x1b\x46\xac\xfd\x1a\x6b\xbf\xc6\xda\xaf\xb1\x8a\xd5\xa3\x73\x3d\xcf\x2a\x56\x24\xd6\x7e\x75\x23\xd6\x7e\x7d\x15\xb5\x7a\x48\xac\xfd\xba\xd5\x88\xb5\x5f\x63\xed\xd7\x36\x23\xd6\x7e\xc5\x11\x6d\x2f\xb1\xf6\xab\x1f\xb1\xf6\xab\x1d\xbf\x1d\xa9\x39\xd6\x7e\x8d\xb5\x5f\x63\xed\xd7\x58\xfb\xf5\xc1\x55\xc4\xda\xaf\xaf\x41\x9f\x54\x3a\x65\xad\xca\x61\x6d\x53\xbd\xc0\x45\x86\x04\xf9\x8e\xe3\x72\x32\x01\x89\x94\x0b\xdf\xbc\x12\x85\x50\x55\x39\xaa\x68\x99\x8b\x33\xc0\xaa\x66\x12\x68\xea\xa2\xa0\x37\x3c\xee\x12\x2c\xb1\x6c\x55\x1d\xbe\x77\xf6\xf1\x9b\x7e\x4a\x25\x74\x0b\x5c\xc3\x35\x7f\xe4\x49\xf7\x00\xa6\x1a\xe0\xeb\xa2\xf2\x1d\xdc\x93\x4c\x28\x17\x76\x88\xc0\x4a\x66\x94\x73\xf0\xca\x23\xd3\x68\x94\x19\x03\x70\x22\x0a\xe0\x96\x7e\x53\xa2\x18\x9f\x66\x40\xa8\xd6\x34\x99\x8d\xcc\x9b\xb8\x07\x76\x1d\x22\xe8\x7e\x51\x5a\x02\xcd\x7d\xb0\x64\x4e\x99\x9d\x8a\xd0\x44\x0a\xa5\x48\x5e\x66\x9a\x15\xd5\x64\x44\x01\x46\x39\x5b\x46\x55\x01\x03\xc3\x4b\xea\xb8\xc2\x41\xfd\x36\xb7\x2c\x11\x56\x8a\x41\xd5\x75\x80\xa5\x2d\xf3\x42\x2f\x88\xf9\xe4\xcc\x95\xbb\x93\x4a\x93\x24\x63\xc8\xad\xf1\x8d\x36\xa1\x0c\xe7\x1b\x78\x5e\xcd\xdd\x4a\x95\x5b\x2a\x4f\x51\x6c\x2d\xb4\x22\x18\x86\x57\x4f\xe8\xa6\x4a\x99\x72\x62\xbe\x1a\x10\xea\xeb\xa0\x58\x40\xfb\x95\x22\xa8\x3d\x67\xb1\xb3\xbb\x9f\x82\xe9\x82\xe2\x69\x06\x37\xad\x35\xac\x46\x74\x8c\x3b\xf5\xc8\x39\x68\x84\xd8\xd6\x02\x05\x86\xbb\xac\x1c\x03\xdc\x00\x0e\x73\x83\x03\x90\x80\xe1\xaf\x74\x03\xd6\x7f\x76\xa4\xd7\x54\x4e\x41\x57\x41\xb9\x6d\x63\x35\x9b\x05\x22\x82\x2a\x87\xa1\x1e\x52\x43\x0c\x81\x73\x29\x52\x8c\xb8\x77\x55\x24\x0c\xce\xac\x29\xa3\x68\x17\xe8\x0a\xe0\xac\xbb\xc1\xcb\x45\x36\xd4\xa9\x7a\xa9\x2a\x68\x02\x8a\x1c\x9c\x5f\x9e\x0c\xc8\xe5\xf9\xa9\x8b\x67\x12\x93\x75\x69\x7c\x8e\x84\x59\x04\xdc\x54\xd0\x91\x29\xff\x8e\xbb\x19\xd5\xb8\x9d\xc1\x8b\x50\x12\x9d\x51\xe9\x02\x15\x7d\xe5\x6b\x72\x21\x34\xac\x2b\x94\xe1\xa9\x01\x8a\x5f\xce\x06\xe1\x30\xcd\x8a\x33\xed\x09\x60\x4b\xb5\x25\x90\x8f\x3e\x80\x52\x74\x0a\x97\x2d\x1d\x58\x9b\x94\x73\xf4\x61\xd5\x67\x14\xa9\x42\x66\xd3\xd7\xaa\x5f\xea\x88\xb7\xa6\x44\x4c\x72\xbb\xa6\x6a\xbf\xef\x24\xd3\x1a\xf0\x7c\x63\xf1\x24\xf4\x81\x2f\x27\xa8\xee\x2f\xc5\xcd\x7d\xf0\x93\xd4\x0f\x1b\xfe\xce\x53\x1b\xc5\x36\x06\x32\x96\x0c\x26\x64\xc2\x30\x34\x0e\x83\xd5\x06\xb6\x1c\x08\xb5\xc6\x25\xa5\x40\xe2\x7a\x9c\x5a\xe3\xd7\x35\x22\x3f\xba\x85\x69\x59\x72\x5b\x01\xdd\x49\xdc\x98\xc2\xc5\x26\x64\x8a\xc1\x6e\x4e\x71\xf8\xe3\x9b\xff\xf8\x13\x19\x2f\x8c\x74\x83\xa8\xad\x85\xa6\x59\xf5\x91\x19\xf0\xa9\x81\x95\xa5\xd4\xcd\x24\xa4\x0a\x02\x58\xa3\xdc\x2e\xfc\xed\xef\x6f\xc7\x4d\x71\xeb\x28\x85\xf9\x51\x00\xbf\x61\x26\xa6\x23\x72\x42\xb9\xc1\x75\xa3\x46\x14\x29\x5a\xf2\xdb\xd7\x0d\xed\x0f\xcd\x44\xc6\x92\x45\x77\xb2\xe3\x74\x13\x32\x13\x77\x56\xed\x5b\x83\x3d\x75\x38\x6c\x21\x8a\x32\xb3\xce\x8c\x6f\xaa\xf4\xbd\x52\xc1\x6a\x8e\xce\xda\x73\x81\xe6\x77\x37\xc5\xd2\xd1\x76\x31\x8e\xfe\x95\xc2\xc5\x7e\x3b\x03\x71\x55\x9e\x06\x75\xe2\x6f\x68\x96\x8d\x69\x72\x7b\x23\xde\x8b\xa9\xfa\xc8\xcf\xa4\x14\xb2\xb9\x96\x8c\x1a\xc6\x39\x2b\xf9\xad\xad\x4b\x5d\xa5\x10\x8b\xa9\x91\xb2\x8b\x52\xfb\x4a\xa3\xeb\x3e\xd8\x26\xa4\x7a\x7e\xec\x35\xe2\x7a\x16\xb8\x67\xb5\xda\xeb\x52\x29\x2c\x46\x86\xf3\xab\x10\xd9\x7e\xff\xe6\x8f\xff\x6e\x51\x97\x08\x49\xfe\xfd\x0d\xc6\xc1\xaa\x81\x3d\xc4\x48\x17\x8d\xcc\x90\xd3\x2c\x33\xe4\x35\x44\x4a\x03\xe8\x75\x48\xf8\xd9\x71\x50\x77\x47\xb7\xad\xa5\xea\x9b\x9b\xbf\x22\x4b\x60\x5a\x41\x36\x19\xd8\xac\x81\x4a\xc3\xdd\x47\x19\x61\xdf\x51\x1f\x4c\xdd\x78\x06\xb2\xf0\x5c\x64\x65\x0e\xa7\x30\x67\x7d\x34\x9e\x68\xcc\xe6\xad\x3e\x19\x53\x98\xa0\x31\xce\x44\x72\x4b\x52\x77\x31\x88\x68\x5a\x2e\xb1\xda\x1e\x0a\x6d\x63\xbb\x3a\xc4\x74\x6d\xfc\xfe\x46\x34\x57\x4e\x8b\x82\xf1\xa9\x4d\x4e\x92\xf4\xae\x01\x0c\x3c\x93\x98\x0f\xdc\xb1\xde\x42\x67\x8f\x43\x57\x7f\xc3\xd0\x7d\x91\xa1\x9b\xad\xa7\x68\x1d\xcd\xd4\xdd\x5d\x51\xaf\xbe\xbd\x8d\xba\x81\x10\xf5\x84\xfe\x34\x14\xf8\x6f\x1b\xa9\xbf\x22\x2e\x57\xe2\x63\x85\x18\x56\x00\x30\xe8\x83\x24\xb9\xbd\xed\xbd\x07\x43\x77\xb7\x50\xb6\x06\x5c\x78\xe5\x60\xc8\xa9\x76\x02\xa1\xd7\x20\x28\x29\x40\x2a\xa6\x0c\x5f\xfe\x01\x0f\xd4\x49\x46\x59\x1e\x58\x83\x9f\x06\x08\xf6\x70\x63\x65\xcc\xee\x94\xf2\x52\xa4\x6e\x42\x24\x85\xb6\x2a\xe8\x1a\xb1\xb6\x29\xd5\xf6\xc8\x50\x9f\x9a\x54\xfe\x50\x43\xb3\x49\x29\xcd\x2f\x15\xa9\xb4\x77\xbd\x26\x02\x89\xdf\xf7\x52\xe9\x63\xb5\xf8\x9e\xc8\x00\x12\x46\xb7\xb9\x4d\x4a\xd8\x50\x1e\xed\x41\x09\x44\x7a\xa7\x07\x8e\x88\x8d\xae\x30\x67\xc2\x3d\x4a\xf6\xdf\xed\x3f\x29\x91\xb4\x20\x92\xa2\xa0\xd3\x4e\x3d\x0e\x96\x20\xb5\x3c\x6d\x98\x08\x6e\xd4\x20\xbc\x5e\x95\x25\xc2\xbb\x20\xad\x0b\x55\x60\x19\x12\xeb\x28\xf7\x00\x76\x0a\x02\xf6\xa0\x21\x77\x74\x41\xa8\x14\x25\x4f\x9d\xa9\xb1\xb2\xf5\x7e\x58\x7a\xf1\x85\xe0\xe0\x7d\x28\xcb\x79\xe4\xe8\xdc\x61\x9c\xbc\x1d\xbd\x7d\xf3\x5a\x38\x15\x7e\xe1\x12\xa7\xba\xa8\x38\x95\xa5\x4f\x4f\xfa\xad\xbe\x1a\x72\x4f\xdf\xfb\xc1\x99\x58\xea\x62\xc7\xcc\x17\x73\xc5\x9f\xee\x24\xd3\x10\x74\x2e\x3a\x40\xc5\xc5\xe8\x87\x41\xd6\xf4\x61\x8f\x35\xbe\xfb\x49\x53\x57\xe5\xf8\x13\xd2\x2d\x47\xa0\xf0\xb8\xad\xb3\x70\xa9\x07\x48\x58\x08\xa8\xbd\x3d\x72\x60\xef\xdc\xb7\x49\xa2\x87\x4f\x8a\x5a\x0e\x68\x67\xf7\x45\x87\x1a\x74\x0d\xc0\x9d\xdd\x17\x14\x6d\x70\x45\x8f\x10\xfc\x2f\x98\xd1\x39\x60\x72\x2c\xcb\xa8\xcc\xd0\xfd\x7c\x6d\xd7\x4e\xc6\xa5\x26\xc0\xe7\x4c\x0a\x8e\xb1\x5e\x73\x2a\x19\x56\xad\x90\x30\x01\x09\xdc\xe8\xa2\x5f\x1e\xfc\x70\x7c\x85\xb1\x2d\x87\xb6\x96\xbd\x5f\x65\xa9\x7c\x79\x89\x70\x25\xc1\x74\x8f\x6e\x9f\x5f\x87\x81\x21\xd2\x5c\xbf\x2e\xf3\x9e\xbc\xd4\xa5\x2d\x98\x7f\x9f\x64\xa5\x62\xf3\xa7\xa2\x24\x2e\x6b\xf9\x94\xb5\xda\xe7\xa5\x0c\xea\x1a\x50\x2b\xc9\xd0\xb5\x0d\xfe\x91\x0a\xad\xfb\xaa\xaa\x69\x15\x86\x43\x38\xd3\x13\xc9\xd9\x74\xa6\x5d\x58\xa6\x2f\x69\xb6\x22\x42\x60\x5d\x87\xa7\x35\x42\x19\xb6\x7b\x9c\x31\xaa\x76\x15\xb9\x56\x32\x0e\xdd\x2c\x18\x44\xc1\x5d\x21\x2a\x9a\x55\xb6\x15\xf3\x22\x6b\x70\x3c\xbf\x74\xde\x29\x0f\x37\xc6\xff\xc7\x06\xad\x54\xda\x85\x0d\x42\xb1\x8f\x58\xab\xe1\x24\xac\x19\xe0\x83\x35\x90\xf8\x63\x95\x15\xb4\x6a\x71\xc1\x87\xb3\xa0\x20\x49\x21\xd2\x1d\xb3\xf1\xda\x2a\x1e\xad\x54\x8e\xf5\x10\x24\x33\x91\xa5\xbe\x2f\xa7\x35\xc9\x8c\x41\xdf\x01\x70\x72\x7e\x89\xf0\x33\x9f\x88\xde\x9e\x0d\x50\xb4\xde\x01\x2c\x3d\x12\x68\xa4\x0d\x78\xee\x8a\x60\x1d\xb4\x92\x2e\x22\x7d\xf5\xa5\x9d\xcf\xfc\x5f\x2a\x98\x79\x8f\x18\x1d\x8b\x39\x20\x48\xd3\x54\x82\xea\x50\xba\xe3\x09\xf4\xd4\x4e\xa4\x94\xb5\xea\xbb\xd0\xf4\x6f\x54\x60\xf3\x16\x22\x14\xdf\xf1\xa8\x22\xe2\x7d\x66\x0a\x76\x7e\x79\xd2\x81\x7a\xed\x7f\xef\xdc\x1b\x66\xaa\xfd\x7d\x45\x58\x91\xd4\xfe\xd4\x11\xa9\xbd\x86\x41\x46\x83\x95\x18\x77\x73\x59\xb5\x15\x13\x03\xa2\xd6\x91\x48\x13\x6e\xa7\x31\x64\xc5\x65\x33\x57\x5e\x62\xa6\xac\x9b\xb8\x01\x0d\xe5\x9f\x08\x01\xe2\x03\x11\x2c\x91\x77\x61\x19\x83\x2a\xc0\x77\x89\x30\xa1\x05\xdd\x87\xf6\x05\x54\x7c\x05\x98\x9f\x0d\x96\x97\xe7\xa7\x7d\xa2\x4b\xc1\xd2\x67\x87\x2e\xbb\xeb\x97\xcd\xdc\xb5\x66\xc9\x07\x37\xa1\x3f\xec\x97\x22\xdd\x20\x26\xd5\x8c\x06\xef\x0f\xbb\x0b\x6a\x41\x28\xb1\x66\xc2\xa5\xbe\xb1\x2d\x80\xb2\x33\x95\x40\x51\xeb\xb2\xcc\xb2\x6b\x48\x24\xec\x6a\x1e\x6d\xee\xff\xf9\xd2\x5c\x9b\x44\x9e\x40\x7e\xc7\x3a\x02\xee\x66\x5e\x17\x78\xab\xb0\x26\xcc\x12\x2c\xca\x0c\xe3\x4c\x29\x5f\x78\x80\xe3\xea\x55\xe0\x8b\x62\xca\xc7\xac\xd8\x10\xa9\xc6\x2e\x28\xa8\x5e\x56\x75\x0b\xa1\x4a\x59\x8f\x29\xe3\x29\x9b\xb3\xb4\xa4\x19\xbe\x08\xa5\xd0\xb0\xa7\x6f\xc5\x21\x73\x5f\xb0\x90\x7c\x23\x24\x81\x7b\x6a\x6e\x1b\x54\x42\x2c\x55\x88\x0e\xa9\x48\x6e\x41\x0e\xac\x28\x76\x8a\x7f\x9c\xa0\xc4\x6b\x4b\xf2\xfa\x75\x18\x5d\xc2\x95\xe9\x6b\xd3\x26\xd8\xf7\x01\xb6\x70\xf8\xc2\x7e\xee\x82\xf1\xe9\x10\x7f\x31\x1f\xe2\xde\x34\x14\x7c\x48\x87\x06\x0d\x5f\x88\xe0\x87\x35\x78\x3f\xa2\x64\x75\xe5\xf1\xc5\xab\x08\x46\x91\x13\xe5\x74\x86\xc0\x92\x39\xf5\x65\xb1\x32\xd0\x58\xf1\xc8\xf9\x75\x6d\x69\x0a\xf7\x6c\xea\xc4\xb4\xb0\x02\x54\x13\xd7\x5e\x88\xf0\xd7\xd6\x42\xb6\x14\x29\x1c\x90\x2d\x07\x23\xbd\x33\x06\x8a\x39\xc8\x39\x83\xbb\x23\xc7\x3a\x87\x77\x4c\xcf\x86\x16\x22\xea\x08\x01\x7b\xf4\x85\x15\x2f\x6d\xe2\xd6\x71\x9a\x3a\xb3\x65\xa9\x60\x52\x66\xae\x5f\xee\x88\xd0\x82\xfd\x00\x52\x61\x5d\xc5\x5b\xc6\xd3\x01\x29\x59\xfa\xf5\x67\x0c\x7c\x61\x9c\xd5\x21\x76\x9d\xa8\xe0\x7b\x47\xe5\x5c\xbe\x30\xfb\x67\xdd\xd2\xd6\x05\x07\x8d\x21\x13\x7c\x1a\x64\x3b\xa3\x78\x71\xce\x99\x5e\x69\xcd\x67\xab\x96\xa1\x8a\x2c\x64\x8a\x81\x8c\x4c\xc8\x86\x3d\xd8\xcc\x87\xb5\x9c\x82\x70\x48\x43\x22\x59\x63\x3e\x0c\x67\x51\x15\x33\x22\x36\x20\xc2\x27\x46\xfa\x0a\x99\xbe\x46\x94\x2d\x59\x36\xa3\x3c\xc5\x3f\x93\x44\xc8\xd4\xad\x97\xe9\x2a\xf6\xd2\x06\x05\xd9\x48\x14\x64\x6b\xd8\x5d\x9d\x2f\xbf\x19\x35\x50\x99\x37\x02\xf5\xbc\xd8\x53\x72\xf6\x8f\x12\x08\xcd\x85\x21\xec\xcb\x85\x9c\x97\x20\x92\xd3\x05\xf2\x56\x5c\xea\xfb\x2a\xd3\xcf\x26\x13\xaa\x01\xb9\x02\x9a\xb2\x20\x21\x7a\x40\xde\x37\x33\xa4\x07\x66\x2d\xd7\x36\x75\xd3\xfd\x64\x57\xef\x9b\xab\x5f\x59\x27\x51\xee\xe3\x8a\x56\x3f\xc6\xec\x8a\xa6\xb7\xc0\xad\x52\x6e\x40\x83\x7e\xb0\x52\xe2\x1e\x24\x33\x48\x4b\xe4\x52\xe3\x05\x99\x30\x5b\xdd\x1d\x45\x05\x36\x9d\x81\xd2\x5e\xb8\x3c\xc2\x58\x9d\xba\x4d\x8d\x5f\x00\xa2\x6f\x10\x69\x5b\x9b\xb1\x72\x8a\xa5\x4b\x85\xeb\x4c\xef\x92\x49\xac\xce\xa6\xca\xdc\x9f\xe5\x65\x48\xab\x91\xef\x69\x6f\x56\x1e\x54\xcd\x66\x4b\xc0\x45\x27\x9d\xb3\xc3\x91\x09\x55\x33\xac\x29\xbf\xbc\x05\x89\x35\xc9\x24\xa5\x34\x04\xc3\x96\x99\xa5\xd8\x44\x16\x3b\x16\x62\xbf\xd1\x75\x86\x9b\x8e\xc9\x03\x66\xb1\xed\xfb\xde\x3f\x1d\x13\x3b\xae\x82\xc1\x0d\xe0\x93\x25\x4a\x60\x77\xd2\x30\x2c\x5f\x5b\xca\xb7\x21\xc7\xcd\x30\x54\xe1\xf3\xb1\xa4\xf6\xfe\xd1\x56\x7e\xcd\x2e\x1c\x90\xca\x69\x77\xcb\xc7\xfe\xb1\x9c\x96\xf6\xa0\x3b\x2a\x5c\x17\xa5\x75\xad\x3c\x51\x6a\xb3\x32\xa6\x51\x67\x4e\x3e\x9c\x86\x29\x48\x61\x6e\x85\x4f\xe0\x1a\x91\x1f\xba\x1a\xa9\x97\xad\xd4\x86\x9a\xd7\xa6\xef\xa4\x3a\x59\x86\x62\x64\x73\xaf\x5f\x54\x6f\xf3\x72\x28\xe3\x45\xa9\x1d\x1b\xac\x35\x4e\x9e\xcc\x28\x9f\xa2\x92\x29\x4a\x33\xdf\x97\x5f\xe2\x8a\x24\xa4\x65\xe2\xaa\xe9\x7b\x94\xfd\xd2\x9b\x6c\x5d\x3d\x2f\xa4\x55\x2a\xa1\x85\x5f\x73\xf8\x59\x6a\xc1\x35\xbd\x7f\x47\xd8\x08\x46\x64\xef\xcb\xe0\xd2\x9e\x7d\x7b\x21\x85\x79\x85\x4b\x7d\xc0\x55\x65\x4c\x63\xf8\xf6\x5e\x78\xf7\x88\x9c\x99\x77\xa0\x1b\xab\x02\x60\x10\x9d\x3f\xae\xc1\x37\x20\x12\xa6\x54\xa6\x99\x33\xb7\xdc\x05\x29\x1d\x15\xc0\xe0\x9e\x29\xad\x2c\x0f\xd2\x1d\x28\x93\xa6\xea\xd6\xd0\x21\x73\xb2\x86\x29\xd5\x74\x18\x1c\xe9\x23\xab\xb7\x0d\x5d\xb9\xcf\x21\x75\xa8\x55\x93\xac\xa3\x2f\x5c\x66\xe4\x90\x56\x77\x31\x23\x91\x63\xe1\xcd\xf6\x72\xce\x4b\xb3\xb1\x75\xa8\xfa\xda\x3c\xbd\x67\x75\x05\x69\x84\x01\x46\xf1\xd7\xf2\x52\x45\x44\x5d\x61\xd3\x75\xe7\xf9\xec\xe2\xe6\xea\xaf\x97\x1f\xcf\x2f\x6e\xe2\xb1\x8e\xc7\x3a\x1e\xeb\x0e\xc7\x1a\xf8\xbc\xf3\x91\xf6\x7a\xd3\x3a\x97\xef\x72\xc1\xc9\x20\x35\xe8\x15\x05\xd6\x9d\xf1\xf9\x0f\x54\xd6\x6d\xec\x9d\xbf\x6a\x8d\x07\xdc\xf7\xb9\x47\x12\x77\xf2\xe2\x23\xeb\x9e\x30\x2e\xae\xc7\x78\xa3\xd0\xa4\xb2\x6e\xd7\xc2\xde\x5f\x27\xbf\x9c\x9f\x9e\x5d\xdc\x9c\x7f\x73\x7e\x76\xf5\xa4\x81\x22\x1d\x0b\x3e\x36\x99\x72\x4b\x2e\x59\x48\x98\x33\x51\xaa\x6c\x51\xf5\xd8\x5a\x4f\x04\x56\x63\x0d\x79\x8a\xb6\x0e\x05\x12\xa3\xae\xd7\x3e\x16\x99\x6d\xbf\xcc\xb6\x19\x37\xd3\xa1\x3c\x4f\x5f\xe8\xfb\x8d\x14\x79\x4f\x28\x7c\x6d\xad\x30\xde\x19\xbe\x0e\x9f\xf6\x5d\x25\x8f\x06\xeb\x71\xc2\x63\x5d\x36\xc4\x08\xa3\x79\xa1\x3b\x14\xc3\xef\xa5\xc4\x6f\x3f\xd5\x70\x6d\xac\xce\x07\x5a\x7c\x07\x8b\x2b\xe8\x58\x05\xa8\x09\x6f\xc8\x20\x31\x8c\x8e\xdc\xc2\xc2\x06\x66\x9e\xf8\x97\x75\xa9\x56\xf4\xff\xb1\xf7\x3f\xdc\x8d\xdb\x48\xde\x28\xfc\x55\x70\x3c\x7b\x5e\xdb\x89\x24\x77\x27\x99\x99\x6c\x3f\x79\x93\xe3\xd8\xee\x8c\x9f\x74\xbb\xbd\xb6\x3b\xb9\x73\xd3\xd9\x19\x88\x84\x24\x8c\x49\x80\x01\x40\xb9\x35\x9b\xfd\xee\xf7\xa0\x0a\x00\x41\x49\xb6\x65\x92\x6e\xc9\x8e\x38\xe7\x4c\xc7\x12\x05\x82\x85\x42\xa1\xfe\xfe\x6a\x23\x11\x92\xaf\x59\x1b\xf4\xea\x2e\xa1\x8d\xaf\x59\x8b\xa4\x53\x7f\x2d\x80\xfc\xda\x25\x04\x3d\xcd\xae\x69\xbb\xd5\x23\xdd\xc2\x1a\x3f\x02\x94\xf3\xf3\x8d\xa0\xd4\xaf\x0e\x57\xc1\x07\x82\x3b\x5e\x09\x8c\xc9\xcf\x6a\x67\x57\x10\x22\x04\xab\x3a\x81\x37\x7d\xd0\xc1\x29\x19\x1d\x91\xa6\x6d\x13\x2e\x82\x4b\xd8\xad\x5c\xdd\xad\x04\x2b\xe6\xf8\x07\x9c\xb9\xf4\x95\x87\x32\xd0\xa1\x73\xd6\xc0\x72\x58\xaf\xfe\x27\x84\x44\x7b\xe4\x9f\xe1\x43\xe8\x35\xad\x7f\xd9\xdd\xfd\xe6\xc7\x93\xbf\x7f\xbb\xbb\xfb\xeb\x3f\xe3\x6f\xe1\x28\xc4\x40\x79\xfd\x16\xc0\x75\x12\x32\x65\x67\xf0\x0c\xf8\xd3\xa9\x6b\x87\x18\x3c\x71\x5f\x40\x45\xf6\x00\xb3\x96\xc2\x9f\x85\x4c\xe7\xff\xd2\xad\x00\x01\x37\xf2\x60\x80\x25\x6a\x51\x59\x84\x57\x77\xc7\x43\x25\x4b\x3a\xde\xaa\x6e\x54\xcf\x8d\x00\x2c\x8d\x90\x64\xaf\x3d\x09\xa0\xbb\xa7\x87\x7e\x10\x50\x2f\x6f\x35\xd3\x3a\x3a\xe4\xce\xf4\x65\xab\x3e\xc6\x78\x75\x28\xda\xc2\x0a\x76\x4c\x30\xa0\x88\x6f\x18\x06\x1b\x39\x1c\xb0\x21\x61\x26\x74\x9f\x3b\x3c\x3f\x25\x53\xa4\xf0\xc6\x10\xc7\x07\x36\x5f\x3f\xaa\x8c\x0b\xe1\xd3\xf9\xba\xdc\x57\x98\x80\xe3\xbf\x77\x18\x09\x3a\x20\xd8\x31\x6b\xd8\xec\xe1\x87\x83\xa4\x28\x7b\xee\x86\x41\xce\x72\xa9\x66\xe1\xcf\x00\x36\xd3\xd7\x46\x2a\x3a\x86\x9a\x1a\xfc\x39\xfe\x2c\xfc\x85\x3f\xac\x3d\x60\xf1\xd7\x68\x0a\x57\x51\xd4\x00\x70\xfb\xfc\x64\x9b\x27\xfd\x86\x88\xb6\xa4\x2d\x8c\x52\xfd\xaa\x33\x64\xf0\xc4\xa1\xc2\x19\xa8\x08\xf6\xa4\xab\x19\xee\x55\xf9\x70\xe0\x0d\x10\x53\x6b\x59\x36\x06\xc0\xab\xae\x0e\xa5\x59\xca\xa7\x5c\xcb\x16\x95\x43\x61\xa0\xdb\x73\x27\x1d\x6c\x09\xe6\x6f\x05\xb7\xd9\xc7\x02\x30\xbf\xc2\x7e\x9d\x13\xfb\x2f\xdb\x34\x39\xc7\xab\xa0\xc6\x30\x25\x5e\x91\xff\xde\xfb\xf0\xf9\xef\xfd\xfd\xef\xf6\xf6\x7e\x79\xd1\xff\xcf\x5f\x3f\xdf\xfb\x30\x80\xff\xf8\x6c\xff\xbb\xfd\xdf\xfd\x1f\x9f\xef\xef\xef\xed\xfd\xf2\xe3\xdb\x1f\xae\xce\x4f\x7e\xe5\xfb\xbf\xff\x22\xca\xfc\x1a\xff\xfa\x7d\xef\x17\x76\xf2\xeb\x8a\x83\xec\xef\x7f\xf7\x1f\xad\xa7\xde\x01\x04\x2f\x5e\x5d\x02\xf1\xd6\x47\xec\x84\xfd\x1e\xb1\x95\x05\x5e\x9e\xbd\xba\xde\xff\x17\x5e\x6a\x46\xf9\x3c\xfe\xb8\xde\x98\x0d\x8e\x09\xa1\x9f\xc2\x93\x83\x4f\xaa\xd7\xda\x04\xd3\xe2\xb9\x9d\x73\x7f\x04\xe7\x8e\x57\xdb\x71\x5d\x2b\x4d\x74\xa4\x64\xee\x2b\xfa\x21\xbc\x81\xb5\x67\xee\xbe\x6b\xd6\xaa\x25\x28\x5e\x5b\x67\xd0\xd6\x19\x74\xcb\x75\xaf\x33\x08\xcb\x11\x36\xd7\x13\xc4\xc4\xb4\x69\x08\x63\x69\x04\xdd\xdb\x3a\x31\xfc\xdd\x6a\x01\xb5\x81\xdf\xea\x3a\x44\xe2\xaa\x4c\x1a\x3c\xd0\xf2\xe5\x31\x4c\x68\xe0\xcf\x05\x6e\x7c\x18\x20\x80\x7e\x32\xd7\xbb\xc3\xd5\x5f\x4e\xed\x14\x02\xd2\x7b\x0d\xbb\x13\xb2\x8a\xb9\x18\x3b\x24\x0b\x3c\x4a\x5c\xf4\x89\x8b\x0a\x0d\x37\x28\x87\x15\x84\x3a\xd5\x5a\x26\xd0\xf8\x08\x71\xf2\x02\x2a\x9f\x9b\x36\xcc\xc6\xd0\x6b\x16\xb7\x62\x47\x78\xf5\xea\x5d\x87\x33\x40\x7d\x15\x53\x0f\x31\x9f\x96\x98\x0c\x82\xe2\x6f\xf9\x18\xcf\x2b\x01\xc1\x32\xa2\x0b\x82\x45\x79\x08\x20\xf5\x83\x85\x4d\x21\x15\x43\x8e\x2a\x2f\x6b\xb3\x66\x96\xad\x4f\xf1\xf6\x67\x66\x88\x6c\xb5\x52\x86\x16\x0e\xcb\xca\xfd\x5c\x3f\x24\x9f\x43\x30\xb0\xfd\xf1\xf9\x87\x3b\x3a\x3b\x3a\x36\xbb\x39\x32\x1f\x10\x3b\xe9\xf2\x98\xec\x22\x58\x52\x28\x36\xe2\x1f\x3b\xda\xa7\x87\x51\x65\x22\x4f\x99\x30\x7c\xc4\xb1\x5f\x6f\xa1\x58\xc1\x04\xf6\xcc\xa7\xc9\x04\x64\xbf\x3b\x29\xab\xe0\xf4\x26\x26\xf3\xa0\xc2\xdd\xad\x28\xbb\x5c\xa6\xec\x6f\xe5\x18\xd9\xca\xb1\xc6\xd7\x27\x92\x63\x8e\x73\x37\x47\x88\x41\xe6\x79\xfb\xd4\xf7\xe3\x28\x8f\x1d\xb8\xb8\x7d\xe5\xf0\x1c\x1a\x5c\x90\x8b\x46\x62\xe6\x1a\x96\xaf\x29\x92\xb1\x29\xcb\x9c\xd2\x44\x72\x2a\xe8\x18\xdb\xf0\x19\x19\x40\x7f\xa4\x0a\x2d\x8e\xe6\x11\x7d\x40\x89\xf7\x95\x5d\xf0\xa5\x92\x59\xc6\x94\x26\x19\xbf\x66\xe4\x98\x15\x99\x9c\xe5\x2e\xf1\x35\x25\x97\x86\x1a\xcb\xd2\x97\xcc\x34\x8b\xf9\xb6\x43\x03\xf1\xc5\xec\x1d\x41\x9f\x63\x75\x3c\xd4\x96\x93\xc2\x15\x4e\xbe\x13\x20\x31\x0e\xa1\xdb\x4a\x8f\x9c\xb1\x29\x53\x3d\x72\x3a\x3a\x93\xe6\x1c\x55\xef\x7a\xb6\x1d\xde\x48\xf8\x88\xbc\xb2\x46\x9d\x36\xc4\x60\xc7\x8b\xa8\xce\x5d\xaa\xda\x00\x15\xde\x5b\x17\x65\x79\x8b\x25\xe7\x30\x52\x28\x38\x6f\x14\xc6\x68\xb5\x4c\xa1\xa5\x50\xeb\x05\x3a\xc4\x32\xd2\x0a\xc9\x37\xe2\x6f\x84\x67\xf0\x08\x66\x60\x02\x72\x41\x14\xd3\x85\x14\x9a\xd5\xe1\x19\xab\x16\x94\x60\xea\xea\x4e\x2d\xc4\xc6\x27\x67\xdb\x33\xb3\x90\xda\x40\xe5\x6c\x37\x8d\xaa\xce\xfd\x70\x50\x88\x4c\xb3\x8c\xa5\xb5\x4e\x65\xd8\x61\x87\xd6\xdd\x03\x09\x34\x67\xf0\x0d\x5f\x98\xab\x4f\xae\x95\x36\xd7\xee\x0f\x5d\xef\x7c\x5f\x19\xdf\x3f\xf9\xb6\x82\xe6\x6a\x63\xc2\x21\x12\x31\xc0\x02\xde\x33\xa0\x80\xeb\xa8\x39\xcd\x44\xca\x6b\x92\xc8\xbc\xc8\x60\xeb\xb4\xd8\x59\x55\x6f\xac\xc0\x4a\x7d\xe8\x87\x7a\x10\xb5\xcd\x82\x0f\xd6\xd8\xdf\xb4\x0b\x1d\x8c\x7d\x64\x49\x67\x7d\x35\xad\x2c\xb5\xab\x0c\xf1\x7e\x29\x82\x2a\x36\x92\xf6\x00\x83\xe2\xec\x80\x3f\x18\x81\xed\x9c\x7c\x64\x49\xd4\x9b\x16\x10\xb0\x12\x8f\x27\x61\x37\x7a\xfb\x9e\xe3\xad\xc3\x14\x5d\x85\x06\x5a\x14\xdf\xc5\xd7\x1c\x68\x20\x8c\xe9\x31\xd2\xdd\x23\xa0\xdd\x04\xd8\x4f\x58\x90\x17\x83\x6e\x04\x1e\xc6\x1d\xbb\x80\x34\x18\x92\xaf\xfd\x58\xd0\xd5\x47\x4a\x43\xf6\x76\x0f\x76\xf7\x17\x7c\x96\x73\x40\xdb\x57\xd1\x2f\x39\x20\x4b\x16\x00\xd3\xc8\x92\xdd\xb4\x47\xb8\xf1\xd9\xd9\xd8\x27\x08\x66\xe5\xaa\x04\x7b\x44\x4b\x62\x14\x4d\xb9\xd3\x7e\xe0\x53\x7b\x93\x51\xa5\x3b\x1c\xf6\x76\x7f\xdf\x75\x6d\x8a\x6e\xa4\xd8\x35\x30\xfd\x01\xb9\x42\x94\x9a\x30\xd0\x4c\x96\xd0\x7c\x13\x49\x50\x64\x3c\xe1\x26\x9b\x81\xa0\x23\xb2\xc4\x4e\x5d\xf6\x98\x71\xd5\x89\x27\x1f\xb9\xf1\x2d\x49\xe4\x88\xbc\xc0\x46\x61\x8c\x3a\xaf\x69\xc6\xa7\xec\x60\xc2\x68\x66\x26\x98\x58\x22\xa4\xe8\x63\xaf\x47\x2b\x81\xdc\x37\x6d\x63\x2c\xed\x5c\x90\xf1\xd5\xc2\x1d\xb9\x38\xa1\x96\xd6\x86\x95\xbd\x3f\x34\xef\x66\x4d\x16\xc0\xc2\xae\xae\xce\x7f\xa8\xb5\xb3\x06\xe1\x6f\x4c\xe1\xd3\x7d\xa2\xa6\xef\x1b\x20\x3b\xba\x09\x70\xb6\xea\x45\x4d\x3a\x14\x61\x6d\x7b\x52\x93\xe5\xe0\x6f\xab\x37\xa3\x26\x7f\x97\x25\x40\x87\xd0\x61\x36\x0b\xb8\x0d\x9a\x19\xb2\x63\x87\xda\xb1\xe2\xc9\x72\xc3\xdf\x18\x4d\x11\x56\x43\x1b\x46\x1b\x69\x7c\xf1\xd5\x59\xe0\x2d\x9a\x5b\xb7\xe7\x40\xa9\x8d\xcc\xc9\xc4\xbd\x76\xbd\x5c\xd3\xed\x8c\x01\xec\x1e\x5f\x0b\xa5\x58\x81\x12\xce\xfd\xe6\xd9\xc9\xaf\x05\xb9\x81\x74\xaf\xf5\x4c\x48\x62\xb2\xc5\x9d\x75\xb8\x40\x62\x21\x4a\x4d\x47\xb2\xb4\x83\x84\x09\xd2\x61\xd2\x04\x69\x57\xfc\x39\x3f\x10\x04\x02\xdb\xe7\x87\x75\x96\x87\x41\x3a\xcb\x35\x20\xcb\x1c\xb3\x8e\x67\xd0\x69\xd3\x11\x11\x3b\x8d\xf0\x93\xf6\xe5\xa5\xf1\x75\x37\x01\xba\x59\x7c\xd2\x25\x05\x8a\x0e\xd2\xc1\x17\x93\xc1\x11\x74\x0a\xca\x35\x51\xb8\x82\x98\xd0\x4c\x4d\x9b\x16\x80\x57\x57\x77\xaf\x2e\x9b\x3b\x0a\xfc\xb5\xa4\xb6\x5a\x11\x11\x1a\x5c\x7b\x50\xd5\x45\x82\x44\xd9\x0c\xae\x1f\xb6\x77\x01\xfb\xe3\x88\x8a\x31\x23\x2f\xed\x2f\xff\xf2\xe7\x3f\x7f\xf9\xe7\x01\x0e\x1f\x32\x1b\x04\x39\x3d\x3c\x3b\xfc\xc7\xe5\x4f\x47\x50\x50\xdb\x96\xaa\x1d\xa5\x6d\x76\x9d\xb4\xd9\x69\xca\xe6\xa3\x26\x6c\x42\x99\x48\x6b\x29\x52\x8f\x17\xc0\x90\x31\xba\xa8\xd3\xfd\x22\x54\x3e\xab\x6b\xd6\xfd\xaf\x76\xab\x6d\xc4\x1e\x33\x49\x71\x29\x93\xeb\x0e\xed\x9a\xdd\xab\xa3\x73\x1c\x32\x32\x6d\xa8\xf0\xce\x10\x2e\xa6\x32\x9b\x02\xfa\x2a\xb9\x3a\x3a\x87\x9d\x37\x80\xff\x02\x47\x14\x58\xd4\x33\x66\xaa\x42\x06\x17\x9e\x0a\x18\xaa\x50\xa4\x41\x33\xae\x0d\x4f\xe0\x77\x95\x9b\xd4\x8e\xd0\x26\x2e\xb5\xb5\x94\x96\x5d\x9d\x5b\x4a\x51\x93\xe0\x87\x1a\x4d\x6d\x13\x0f\x37\xf8\x5c\x72\xe7\x91\xaa\x75\xd1\xde\x9e\x4b\x1d\x8c\xb7\xb9\xe7\x52\xa1\xd8\xa5\x91\x8d\xba\x05\x90\xc5\x48\x08\x0e\x76\x4b\x1c\x64\xc8\x46\x52\xb1\xf9\x40\x48\x14\xd8\x48\x4b\xd8\x84\x54\x40\xf5\x9f\x77\x41\xc9\x5a\xf0\x02\x53\x2e\x7d\x87\xec\xcc\x61\xa2\x1e\xe8\x18\x08\xd5\xb7\x3b\xee\xd9\xb7\x63\x39\xcc\xae\x57\x95\x31\xb8\x66\xcb\xf0\x21\x33\x09\xba\x59\x7d\xfc\xc5\x79\x54\xfd\xf4\xe7\x43\x25\x89\xa2\x7a\x82\x8d\x88\xd9\x47\x6e\x02\xe4\x2a\xd5\x52\xa0\xb3\x37\xea\x89\xcc\x75\x84\xc9\x1d\x05\x79\xf0\x47\xe7\x32\x9d\xef\x39\x3e\x56\x34\x61\xa4\x60\x8a\xcb\x94\x40\x3d\x71\x2a\x6f\x04\x19\xb2\x31\x17\xda\xd3\x0f\xc0\xd9\x1d\xa1\xed\x71\xc3\xc0\x37\xec\xd1\xe2\x06\xe4\xa2\x06\x82\xe2\xca\x93\x12\x59\xed\x68\x37\x8b\xf9\x20\x13\x64\x84\x02\x79\xb1\x1b\x50\x58\x98\xb8\x41\xd2\x3d\x93\xee\x20\xda\x84\x3d\xbc\xfc\x77\xb7\x52\x87\x6b\x4b\xf5\x64\xd2\x2e\xf0\xbb\x0d\x4f\xad\x78\x6d\xc3\x53\x0f\xbb\xb6\xe1\xa9\x6d\x78\xea\xf6\x6b\xe3\xdc\xbb\xdb\xf0\xd4\xd6\xe8\x9a\xbf\xb6\xe1\xa9\x6d\x78\xea\x96\x6b\xe3\xe4\xd7\x36\x3c\xb5\xc2\xb5\x0d\x4f\xad\x78\x6d\xc3\x53\xdb\xf0\xd4\x36\x3c\xb5\x0d\x4f\xfd\x81\xdc\x80\xfe\xda\x86\xa7\x16\x06\xd9\x86\xa7\x22\x62\x6c\x2d\xa5\x25\xd7\x36\x3c\xb5\xe4\xda\x86\xa7\xa2\x6b\x7b\x2e\x35\x38\x97\x7c\x70\xe7\xdc\xda\x65\xed\x6b\xd6\xce\x21\x70\xc0\x13\x17\x23\x92\xa3\x5a\x9d\x13\x3e\x6a\x50\x35\xa0\x88\x30\x3f\x7c\xa9\x8d\x8b\x06\x55\x31\xa6\xa5\xf5\x50\x2d\xdb\xc3\x15\x32\xad\x82\x11\x51\x14\x02\xad\xd3\xe6\x35\x69\x6b\xab\xb6\x6a\x13\x7a\xd8\xe8\xb0\xc3\x86\x84\x76\x3a\x08\x35\x6c\xc3\x0c\xcf\x2e\xcc\xd0\x8d\x8b\xae\x03\xf7\x5c\xeb\x13\xc6\x05\xf3\xaf\x26\x8a\xe9\x89\xcc\x1a\x33\x7a\x8d\xc9\xdf\x72\xc1\xf3\x32\x87\xbe\xb1\x96\x9f\xf9\x34\x64\x0d\x84\xe6\xd8\x4e\xd0\xa3\xa7\x30\x6a\x30\xeb\x1b\xcb\x42\x59\xe7\x84\x82\xaa\xae\xcb\x24\x61\x2c\x8d\x5a\xde\x83\x62\xf6\xe5\x20\x3c\x29\xb4\xd3\x78\xd9\x4e\xde\xb4\x3b\xfb\x11\xa2\x14\x46\xf9\xf2\x8b\x46\x63\xb4\x8c\xf2\x7c\xfa\x08\x4f\x07\x62\xba\xbd\xbd\xd2\xca\x56\xe9\xe2\x94\x68\x6b\xa3\x3c\xb5\x48\x4e\x67\x11\xcd\x0e\x22\x38\x1b\x14\xbd\xd9\x98\x63\x61\x53\x22\x36\x1b\x88\xbe\xda\x41\x80\xa1\x8b\x08\x4d\x77\xd1\x99\x47\x00\x29\x7d\x9c\xa8\x4c\x87\xd6\x70\x47\xd1\x98\x4f\x11\x89\xe9\xe4\xad\xdb\x46\x60\x3e\x5d\xf4\xa5\x9b\xd7\x6d\xe9\xdd\x7a\x16\x11\x97\x0e\xbc\x5a\x5d\x7a\xb4\x3a\xf3\x66\x3d\x5a\x84\xa5\x7d\x74\x65\x03\x22\x2b\xad\x89\xcc\x05\x37\x9c\x66\xc7\x2c\xa3\xb3\x4b\x96\x48\x91\x36\x3e\x61\xe6\x50\xeb\xc2\xfe\xd1\x38\xac\xb3\xd1\xea\xf9\xc7\x13\xea\xc0\x79\x59\xea\x53\xaa\xbd\xfb\xcf\x29\x14\xd0\xd0\x04\x67\xb9\x91\x0e\x3d\xb2\x31\xc6\x20\x26\x63\x77\xb9\x88\x7f\x93\x37\x44\x8e\x0c\x13\x64\x8f\x0b\xbf\x8e\xfb\x91\x19\x58\x59\xe6\x81\xad\xed\xb7\x2f\x5f\xf8\x9b\x9f\x9f\xc9\x0d\xce\x05\xad\x1f\xdf\x03\xe2\x1e\x74\xbf\x0b\xc4\xdd\x38\x2a\xb3\xba\x1b\x04\x5d\x23\x75\x79\xf3\xb2\x82\x17\x7d\x09\xe3\x86\xdd\x46\x45\x4a\x5c\xe1\xc6\xf3\x5b\xb4\xd6\x71\xe3\xe7\x10\x33\xde\xfa\x5e\x48\xd7\xbe\x97\x35\xc5\x86\x37\x50\x6b\x7e\xa2\xf1\xe0\xad\xd6\xfc\x80\x2b\xaa\xff\xfa\x41\xd1\x84\x9d\x77\xae\x70\xf8\xed\x44\xd2\x52\xb9\xb2\xbd\xa0\x77\x84\xcd\x23\x18\x4b\x71\x37\x85\xa2\x38\xa8\x46\x1b\x95\x59\x36\x23\x65\x21\x45\xbd\xf2\x10\x83\x56\xf3\x05\x6b\x76\xb4\x65\x4f\xa9\xb4\xd4\x42\x49\x77\x00\xab\x52\x08\x2b\xcf\xab\x86\x43\xa0\x95\x6a\x94\xd5\x71\x59\x9c\xe6\x63\x3b\x7d\x7b\x98\x42\xc5\x1c\xcf\x59\xd5\x92\xa2\x1a\xd0\xfe\x7a\x24\x55\xc2\x87\xd9\x8c\x4c\x68\x16\xba\x4b\x50\x72\xcd\xb3\xcc\x0d\x33\x20\x97\xcc\x10\x33\xe1\xae\x31\x38\xc9\xa4\x18\xc3\xe4\xa8\xf0\x5d\xcd\x58\x62\x7f\x9b\x64\x8c\x8a\xb2\xc0\xe7\xd9\x63\x7d\x26\x4b\xe5\x9f\xe7\x60\x2d\xc3\x28\x5c\x13\xc1\xb3\x5e\xd4\x3b\xe9\xce\x85\xad\x1a\xd4\x6b\xe6\x6b\x0a\x6f\xb8\x66\xbd\x78\x4c\x8f\xcc\xab\xa3\xce\x19\x85\x92\x53\x9e\x62\xf7\x0b\x4f\x36\xe8\xd2\x8a\xdd\x31\xc2\x7e\x16\x52\xf4\x05\x1b\x53\xd0\x7a\xdc\x2e\xc2\x35\xc3\x71\x30\x14\x27\x52\xe8\x97\x61\xcd\x05\x59\xd4\x4a\x59\xa7\x1c\x3b\x7d\x46\x94\x23\x7b\x42\x12\x09\xc7\x6b\x29\xb8\xc1\xee\xd1\x93\xd2\x90\x54\xde\x88\xfd\x01\xa2\x12\x73\x4d\x28\x19\x32\xe3\x3b\xd9\xfa\xce\x8a\x5c\x31\x4d\x98\xa0\xc3\xcc\xae\x39\x24\x3c\x5c\x2d\x25\x10\x19\x31\x6a\x4a\xc5\xc8\x98\x1a\xb6\x54\x69\xc2\xf7\xbd\x9b\xbc\x5c\x87\x2e\xef\xa5\xd0\xac\x71\x7f\xeb\x8e\x35\xad\xbf\x7c\xd5\x4c\x46\xf0\x9c\xc9\xd2\x7c\x12\x53\xf2\x66\xc2\x93\x49\xac\x19\xf3\x9c\x69\x22\xcb\x39\x1b\xfb\xa5\xfb\xd9\xf2\x15\xda\xda\x93\xcb\xae\xa6\x5e\xe2\x25\xae\xb4\xf9\x92\xe3\xaa\xad\x2c\xb5\x1b\xf0\xf8\xec\xf2\x1f\x6f\x0e\xbf\x3f\x79\x33\x20\x27\x34\x99\xc4\xf5\xe8\x82\x50\x10\x1a\x20\x28\x26\x74\xca\x08\x25\xa5\xe0\xbf\x95\x88\x4e\x4e\xf6\xc2\x6f\xf7\x3b\xc5\x42\x6e\x78\xfa\x42\xeb\xeb\xce\x7a\x2d\x61\x23\x6d\x4c\x70\x90\x9a\x41\x77\x84\x79\xf5\xe9\xc4\x7e\x85\x86\x06\xa8\x5a\x13\x66\x85\x11\x9f\x3a\x31\xec\xc0\xa5\x69\x1a\x52\x2e\x2c\x9f\x5b\xb6\xb0\x47\x15\x1d\x42\xaa\xc4\x84\x11\xc1\x8c\x65\xeb\xe0\xb0\x92\x42\xd7\x80\x01\x4a\xcd\x74\x8f\x0c\x4b\x48\xee\x28\x14\xcf\xa9\xe2\xd9\x2c\x1e\xcc\x9e\x55\x67\xd2\x9b\x43\xb3\xf9\x29\x1d\xbf\x3b\xb9\x24\x67\xef\xae\x48\xa1\x10\x32\x00\xb2\x33\xe0\x7b\x78\xad\x21\xb3\xbf\x70\x3d\x3a\x07\xe4\x50\xcc\xf0\x4b\xdc\xe0\x5c\x13\x6b\x0b\x31\x38\x82\x9d\x0e\xe9\x41\xe1\x77\x5e\x0c\xe0\x7f\x3b\xf6\x2d\x95\x55\x32\x43\xd2\x49\xb2\x90\x3c\x86\x6a\x28\x1f\x66\x11\x35\xdd\xbb\x3f\xab\x6e\x4b\x21\x6d\xee\xdc\x12\x31\xea\xb6\x44\xc3\x52\x03\x79\xb1\xfb\x16\x17\xe3\x2c\xe6\xaa\x66\x62\xbf\xad\x6d\xd9\xd6\xb2\xec\x57\x6f\x70\xde\xd4\xc0\xec\xa4\xeb\x53\x35\x87\x8e\x7a\xa5\x54\xa7\x9f\x37\xa7\x9c\x44\x90\x71\xfb\xcb\xd3\x73\xbf\x03\x9c\x76\x93\xcf\xf5\x4c\x84\x1f\x63\x50\xa3\x47\x5e\x90\x6f\xc8\x47\xf2\x0d\x98\x57\x7f\x69\xdb\x59\xa6\xad\xe1\xd3\xde\xbd\x83\x56\xfd\xe9\x79\x47\x14\xff\xd9\x4a\x27\x3b\xa2\xa5\xaa\x91\x64\xc8\x9d\x3a\xcf\x3e\x1a\xa6\xac\x1c\x75\x2b\xb1\xd6\x9e\x3c\x76\x82\x9f\x90\xcd\x30\x76\x71\x3a\x8a\x5b\x42\x98\x07\x32\x9a\xfd\xf9\xdf\xa4\x36\x67\x4e\x0a\xd5\x1b\x4c\x54\xa3\xe5\xd4\x24\x93\xba\x18\xb3\x8a\x9a\x36\xd5\x06\xd3\x24\x95\xe0\x49\xc3\x3c\xc0\x09\x6f\x91\x89\xb1\x39\x6c\xdc\x2e\x38\x5f\x5b\xcf\xbb\x56\x6a\xce\x81\x02\x96\x8f\x53\xac\x22\x78\x99\x42\xa6\x4e\x27\xb3\xd3\x4a\xa3\x33\xe3\x0e\xa5\xcc\xf9\x6a\x82\xcb\x1a\x78\xc9\xee\xa7\x84\x0a\x4c\xe0\x1e\x31\xa5\x30\x75\x73\x38\x83\x08\x32\x4f\x58\xeb\xc5\x6b\xb5\x93\x0a\x25\x8d\x4c\x64\x8b\xb6\x41\xf5\x80\xb9\x1b\x0e\x88\x80\xce\x5f\xef\x73\x7f\x7f\x7c\xde\x23\x57\x47\xe7\xd0\x4d\xe5\xf2\xe8\xea\xbc\x6e\xa9\xec\x5c\x1d\x9d\xef\xac\x95\x14\xc4\x6b\x56\xaf\xec\x34\x1b\x0c\x52\x73\x3c\x59\xb5\xad\x9f\xd3\xa2\x7f\xcd\x66\x0d\xcf\xd4\x2e\xce\xf5\x7e\x58\xe1\x4e\x5e\x08\xc9\x9c\xd3\xe2\xc1\xa3\x29\x46\x53\xfe\x89\xaa\x28\xdc\xce\xaa\x9e\xb9\xbc\x9c\x22\x97\x53\x96\xa2\x3a\xec\x7f\xc1\x44\x5a\x48\x6e\xf5\xc5\x6d\x8d\xc5\xc3\x7f\xbd\xad\xb1\xb8\xeb\xda\xd6\x58\x6c\x6b\x2c\xb6\x35\x16\x77\x5f\xdb\x1a\x0b\x77\xad\xdf\x0d\x4a\xb6\x35\x16\x0d\xaf\xe7\x15\xe7\xdf\xd6\x58\x3c\xe8\xda\xd6\x58\x2c\x5e\xdb\x1a\x8b\x5b\xae\x6d\x8d\xc5\x2d\xd7\xb6\xc6\x62\x5b\x63\xb1\xad\xb1\xd8\x66\x8b\xdd\x3b\xd6\x66\x66\x8b\x91\x6d\x8d\x85\xbb\xb6\x35\x16\xcf\x22\x27\x86\x6c\x6b\x2c\x56\xba\xb6\x35\x16\xdb\x1a\x8b\x26\xd7\xb6\xc6\x02\xae\xad\xef\x65\x5b\x63\xe1\xaf\x6d\x8d\x05\x5e\x7f\x1c\xad\x79\x5b\x63\xb1\xad\xb1\xd8\xd6\x58\x6c\x6b\x2c\xee\x9c\xc5\xb6\xc6\xe2\x39\xd8\x93\xbe\x07\x5e\xfb\x9a\x81\xdd\x23\x99\x17\xa5\x61\xe4\xc2\x0f\x19\xb4\x48\x14\x0c\x5c\xc7\x1a\x41\xfb\x14\x9e\x44\x8a\x11\x1f\x3b\xc9\x7e\x80\x0d\xe6\xfa\xe1\x7d\xfa\x51\x53\xb7\x27\x98\xbf\x93\xf1\x9c\x37\x2b\xe4\x20\x0b\x0b\xf3\x06\xc6\x8a\x82\x3c\x76\x27\xe5\xf4\x23\x6c\x11\x9a\xcb\x12\x9b\xf2\x25\x6e\xfd\x02\x09\x31\x14\xb6\x71\x2b\x43\xba\x31\x71\xaa\x8a\x94\xf3\x0e\xac\x8d\x82\x1a\xc3\x94\x78\x45\xfe\x7b\xef\xc3\xe7\xbf\xf7\xf7\xbf\xdb\xdb\xfb\xe5\x45\xff\x3f\x7f\xfd\x7c\xef\xc3\x00\xfe\xe3\xb3\xfd\xef\xf6\x7f\xf7\x7f\x7c\xbe\xbf\xbf\xb7\xf7\xcb\x8f\x6f\x7f\xb8\x3a\x3f\xf9\x95\xef\xff\xfe\x8b\x28\xf3\x6b\xfc\xeb\xf7\xbd\x5f\xd8\xc9\xaf\x2b\x0e\xb2\xbf\xff\xdd\x7f\x34\x9e\x72\x6b\x95\xb8\x3b\x85\xb8\x23\x75\xf8\x51\x94\x61\x17\x1d\xee\x68\x2f\x5e\xb8\xd1\xe6\x77\xa3\x3b\xb0\xee\xda\x8d\x5e\x9a\x82\x9a\x17\xc6\xe1\x9a\xc8\x9c\x1b\xab\x1c\x5a\x7d\x90\xc6\x79\x61\xdc\xd4\x8c\x52\x27\x07\x20\xa1\x92\x1a\xec\x11\x1a\x72\xaa\xa2\x3c\x6d\xe9\x35\x3f\xd7\x7b\x35\xf8\x2b\x60\x3f\xf7\x53\x36\xe2\x82\xb9\x38\xd8\x56\x36\xdc\x7f\x6d\x65\xc3\x73\x94\x0d\x9a\x25\xa5\xe2\x66\x76\x24\x85\x61\x1f\x1b\x79\x58\xea\xa2\xe1\xb2\x3e\x20\xc1\x7d\xe6\xaa\x28\xdd\x77\x44\x16\x98\x40\x39\x57\xce\x1a\x52\x70\x55\x29\xc0\xc0\xc4\x2a\x19\x66\xd0\xfa\x03\xbb\x07\x72\x22\xe7\x1f\xe2\xed\x39\x34\x33\x7f\x2b\xf9\x94\x66\xd6\xda\xad\x7e\x71\x0e\x16\x4c\xfc\xa3\x55\xf7\xbc\xa1\xfa\xba\xda\xf0\xac\x6f\x75\xe8\x30\xe7\x03\xff\x4a\xf0\x11\xfb\x68\x9e\xa2\x96\x06\x0a\xd2\xb9\xe2\x53\x9e\xb1\x31\x3b\xd1\x09\xcd\x40\xae\x75\x73\x56\x1c\xde\x32\x3a\x2c\xbc\x92\x99\x26\x37\x13\x06\xdd\x95\xa9\x77\x01\x40\x85\xcb\x98\x72\x41\x72\xbb\x44\x85\xff\xb1\x46\x5f\x82\x15\xff\x05\x55\x76\x81\x83\xcf\x00\x4c\xe4\xa1\x94\x99\x4b\x1d\xce\x66\xd5\xf8\x2e\xf7\x5e\xc8\x7f\x08\x76\xf3\x0f\x3b\x9a\x26\xa3\x8c\x8e\x83\xab\x40\x33\xb3\xe0\xed\xab\x86\xbe\xf5\x05\x20\x2f\xb7\x64\x84\x66\x37\x74\xa6\x2b\xc7\x49\xdc\x07\xfc\x15\x79\xb9\x0f\xec\x4c\x35\x09\x63\xa4\xe4\x8b\x7d\x88\x25\x1e\x1d\x9e\xff\xe3\xf2\xef\x97\xff\x38\x3c\x7e\x7b\x7a\xd6\xee\xa4\xb0\xef\xce\xa8\x68\x34\x46\x42\x0b\x3a\xe4\x19\x6f\x73\x40\x2c\x64\x9b\xc4\x83\xc2\x11\x9c\xa6\x07\xa9\x92\x05\xd2\xc9\xfb\xa8\xaa\x93\xb2\x6e\x05\xc7\x95\xc9\xb0\x3c\xa3\xfa\x80\x63\x45\x85\xa9\x9c\x35\x15\xc9\x55\x29\xac\x61\xfd\xc4\x13\xf3\x69\xda\x5d\x52\xfe\x61\x9a\xb2\xb4\x46\xbd\x67\x97\x04\x78\xe4\x5f\x6e\x56\xd5\x68\x93\xf3\x77\x97\xa7\xff\xcf\x1c\x1b\xce\x8a\x76\x39\x4f\xdd\xd4\x85\x29\x59\x74\xb6\xba\x17\xae\xee\x68\xbb\xbe\x1b\xb1\xbe\xe1\xac\xea\x26\xd2\x7e\x51\x8a\x3a\x8c\x47\x35\x3e\xc9\x65\xca\x06\xe4\x3c\x78\xe9\xeb\xdf\x46\xe5\xbd\x54\x31\x62\x6f\x11\x86\xd3\x2c\x9b\xc5\x0a\x92\x91\x58\x4c\x53\xab\x4c\x8e\xe5\xf0\x88\x66\xba\xa5\x30\x6d\x73\x32\xd9\x43\xf8\xad\x35\x26\x3b\xa1\x66\x18\x8d\xa4\x4c\x48\xe3\xb4\x52\x3b\x4b\x28\xd6\x56\x32\x21\x68\xb9\x46\x69\x51\xb5\xd3\x45\xa3\xa3\xdf\x1f\x4c\x5c\x7b\x5a\x9d\x87\x91\xd1\xcb\x5b\x6a\x36\xaf\xdd\xba\x83\xa9\xb2\x65\xed\xe8\x8a\xd1\x14\x6a\xd2\x0a\x6a\x26\x98\xd5\x90\x53\x7d\xcd\x52\xfc\xc0\xe9\x35\xc1\xcd\x6f\x47\x0c\x8f\xba\xb2\xf3\xf6\x3e\x7d\xd0\x67\x30\xd7\x02\x62\x01\xcd\x40\x37\x48\x17\x5b\xc0\xbe\xd3\x3b\x91\xcd\x2e\xa4\x34\xaf\x43\x2d\x56\x27\x0b\xf8\xb3\xd3\x14\xeb\x6e\x58\x50\xa5\x20\x09\x21\xed\x03\x31\x81\xa5\xe3\x32\xb0\xe3\x6a\xc1\xd6\xcc\xd0\xaa\x14\x87\xfa\x07\x25\xcb\xc6\x27\xc0\x82\xa2\xf5\xc3\xe9\x31\xec\xe3\xd2\x45\xd9\x84\x51\x33\xa8\x3a\x5d\x04\x0c\x0a\x3a\xed\x7b\x17\x27\x8c\x39\xb2\x0a\xe9\x90\xb7\x74\x46\x68\xa6\xa5\x57\x8e\xb9\x58\x6a\x40\x39\xeb\xcc\x7e\x3d\x94\x66\xb2\x60\x96\x59\x76\x5e\xfc\x5d\x2f\x0a\xba\x55\x08\x46\x5c\x2c\xfc\xdc\xd0\x6b\xa6\x49\xa1\x58\xc2\x52\x26\x92\x96\xab\xb6\xee\x50\x13\xac\xfc\x99\x14\x76\x5b\x74\xb2\xf6\xa7\x21\xc6\x08\x8e\xb0\xfa\x4a\x43\xb4\xd2\xd9\x1d\x14\x62\x96\xb0\x29\x4a\xcd\x14\x06\x58\x55\xc9\x70\x21\x7e\x2c\x87\x2c\x63\x06\x8d\x21\xc0\x9d\xa0\x06\x0d\x69\x9e\xd3\x31\x23\xd4\x04\x46\x31\x92\x30\xa1\xad\xb8\x41\xd7\x9b\x21\xa9\x64\x55\x01\x25\xd5\xe4\xfd\xe9\x31\x79\x41\xf6\xec\xb3\xf6\x61\xf9\x47\x94\x67\x10\xce\x34\x54\xcd\xcf\x91\x8f\xfc\x10\x30\x25\xe0\x3d\x22\x15\x6e\xd1\x1e\x11\x92\xe8\x32\x99\xf8\x39\x59\x8b\xcb\x1b\x6c\x2e\x9f\x0f\x9c\xfa\xcf\x90\x55\x5b\x0b\x98\xf7\x9a\xa9\xce\xe4\xcb\xfb\x06\xf2\x25\x56\x21\x2c\xcf\xd5\xa9\x87\x8c\x95\x33\x43\x53\x6a\xa8\x93\x3b\x55\xd5\xf5\x73\x5c\xd2\x75\x4b\x1f\xcd\xde\x70\x51\x7e\xc4\x8c\x95\xee\x8c\xfc\xcb\x13\x18\x96\x24\x9e\x68\xb0\x68\xb4\x28\x32\x8e\xf5\xce\x73\x19\x54\xa7\xb5\xa5\xee\xdd\xa2\x22\xc1\x36\xa7\x59\x26\xad\x78\xb3\x27\x3b\x15\xa9\xcc\x17\x1e\x66\x15\x28\x56\x03\xba\x1b\x90\x67\xc9\x3c\x6b\x77\x47\x64\x6c\xca\x5a\x60\xba\xcc\xe3\xf2\xd9\xd1\xac\x2e\xe6\x17\x14\x86\x27\x19\x1d\xb2\x0c\x4f\x16\x64\x20\xbd\xc8\x40\xeb\xce\x42\x54\x32\xeb\xae\x06\xe3\x42\x66\x0c\xd3\x7a\x3c\x21\xec\xf0\x4f\x82\x0e\x30\x48\x57\x74\x00\x43\xa6\x46\x07\x30\xc9\x9e\x02\x1d\xca\x16\x07\x2d\x99\xa7\x83\x3d\xb5\xeb\x74\x80\xa3\x73\xd3\xe9\xa0\x59\x92\xc8\xbc\x38\x57\xd2\x9a\x5c\x9d\x1d\x2d\x6e\xd8\x2a\x56\x84\x36\xf9\x92\x24\x1c\x10\xe5\xf5\x9b\xa9\x8a\x12\xfa\xa8\x41\x19\xef\xb3\xfa\xfe\x7f\x71\x87\x64\x2b\x7a\xe6\xcf\x21\x3f\x4a\x2d\xac\x64\x7f\xe9\xbe\x78\xe2\x70\x02\x2d\xbc\x64\x9d\x1c\x26\x32\xa1\x19\x40\xee\xb5\xe3\x18\x32\xcf\x35\xf3\x03\x47\x59\x98\x10\x5a\x82\xcf\x7c\xdc\x1f\xd0\xd7\xe0\x13\xe7\xfb\x12\x32\x65\x51\x08\x12\xd3\x47\xaf\x30\x5b\x0f\xee\xf3\x09\xa0\xf6\x54\xf7\xd1\xc0\xb4\xf6\x6b\x23\x1d\x02\xcc\xdb\x00\xe4\x67\x27\xc8\x44\xca\xc5\x18\x3c\x3a\x3d\xa2\x58\x86\xa9\xa3\x6e\x0f\x5f\xa3\xf9\xb5\x0b\x1c\xed\x07\xf5\xec\xec\x1f\x0d\x9a\x10\x97\xc2\x8d\x0c\x4e\x0e\xaf\xdf\x8c\x50\x5a\x72\x4d\x76\xde\x78\x02\xb4\x40\x3e\xdb\xc4\x03\x62\x07\xdf\x30\xac\x26\xfa\xd8\xae\xb9\x48\x5d\x96\x65\x8d\x58\x01\xa3\x16\xb5\x50\xc8\xdf\xe5\x69\x2c\x1a\x5e\x91\x0f\x82\x04\x62\x91\x7e\x63\xf6\xb8\x40\x85\xd5\xbb\x97\xfa\x77\xbb\xfc\xc2\x43\xe6\x87\x79\x2f\x60\xed\xed\x73\xfb\xd6\xec\x5d\xbc\xcf\xbf\xcb\xce\x3a\xd7\xf5\x86\x8b\x54\xde\xe8\xae\x6d\x88\x9f\x71\x58\xaf\x50\x27\x96\xad\x0d\x17\x63\x1d\xdb\x11\x34\xcb\x6a\x6e\xd8\x65\x86\x84\x5f\xe1\x80\x48\xbc\xa8\xc0\xcf\x65\x87\x6f\x8d\x80\x07\x5c\xe3\x5c\xd3\x23\x65\x5f\xc5\x70\x9a\x5d\x16\xcd\xa1\xd9\xc8\x3c\x1b\xfc\xf0\xf6\xf2\xb0\x3e\xb4\x95\x67\x37\x80\x78\x6d\x89\x6d\xbf\x27\x34\xcd\xb9\xd6\xe0\x06\x62\xc3\x89\x94\xd7\x64\xcf\xa7\x6d\x8c\xb9\x99\x94\xc3\x41\x22\xf3\x28\x83\xa3\xaf\xf9\x58\x1f\x38\xa6\xed\xdb\xd9\xef\x13\x2e\xb2\x90\x8d\x02\x66\xa4\x30\xda\xbb\x31\xe0\x21\x49\x98\x05\xac\xad\xc3\xeb\x74\x51\xe6\xc5\x69\x22\x42\x27\x67\xd9\xfa\x01\x67\x16\x97\xe7\xac\x25\x76\xc6\x3d\x4b\x04\xef\xee\x4a\x53\xe2\x32\xaa\xa5\x74\x44\xed\x6d\xed\x44\x72\xda\x41\xc2\x74\x77\xa8\x3c\x7f\xab\xc6\x24\x29\xc3\xea\x09\x06\x59\x27\xf4\xd6\xe4\x26\xf0\xca\xee\x42\x11\x9e\xfb\xe9\x6e\xac\xd1\x42\xd4\x07\xcb\x3c\xac\x3d\x90\x15\x13\xda\x47\x23\xd9\x8a\x24\x90\x61\x5e\x07\x98\x48\x21\x5d\x72\xba\x3d\x05\xa5\x00\x96\x06\x6b\x01\x03\x41\xb0\x26\x4e\xc6\x46\x53\x3d\xaa\xe2\x83\x71\x0c\x09\x8a\x78\x10\x04\xa0\x9a\xc3\x0d\x37\x13\x8f\x70\x5f\x0b\x38\xc1\x4c\x14\xd3\x10\x3d\x10\x84\x29\x25\x95\x4b\x84\xf1\x5e\x5b\x18\x09\x44\x31\x64\xd2\x58\x26\xa1\xf6\xaf\x5d\x1d\x87\x28\x2b\x08\x5c\xc8\x13\xb3\xdc\xc4\x46\x23\x96\x80\xa6\x14\x13\x18\xc5\xee\x5e\x85\xdc\xe7\xb2\xbb\x2d\x83\x39\x08\xdd\x9c\x7f\xb4\x4f\x89\x7f\x15\x07\x43\x1d\x62\xde\xf2\xaf\xf7\x07\x84\x9c\x8a\x90\x39\xd9\xb3\xab\x18\xdf\xe9\x53\x7e\x8c\x7d\xc5\x18\x7f\x19\x5e\x20\xf6\x3b\x59\xf5\x4e\x95\x1d\x70\x7c\x1b\x67\x30\x89\x1d\xc2\x9d\x8a\x03\x70\x0c\xbb\x41\xed\xd2\xfb\x43\xbc\x8d\xa3\xd8\xde\xf2\x58\xce\xe2\xa7\x71\xd2\x93\xb6\x72\xce\x95\xc4\x77\x04\x8a\x7b\x19\x8d\x16\xa9\xdf\x21\xdc\x74\x2e\x53\x84\xc4\x08\x25\xfd\xd0\xcb\x02\x20\x3a\xf8\xbf\xbd\x82\x55\x29\x69\x42\x62\x56\x76\x8c\x95\xe1\x30\x41\x53\x62\x75\xe5\xcc\xdb\xf6\x79\x91\x31\xa8\x9e\x8b\x46\xae\x0a\x03\x23\x14\xdd\x5e\x98\x48\x05\xc4\xeb\x10\x3a\x7a\xe4\x5f\xb0\x29\x43\x02\xa0\x07\x0f\x38\x0f\x3f\x47\x13\x8f\x6b\x0f\xa9\x0d\x95\x6d\x46\x7a\xd7\x01\x49\xf9\x68\xc4\x7c\xa2\xa1\x35\xfd\xa8\xa2\xb9\x15\xf1\x9a\x38\x12\x0c\xd9\x98\x63\x26\x5b\x10\x6c\xbb\xba\xaa\x80\xef\xa1\x30\xe4\x86\xe4\x7c\x3c\x41\x46\x21\x14\x2a\x23\x89\x0f\xa9\x65\x92\xa6\x04\x78\x5b\x2a\x72\x43\x55\x6e\xcf\x0d\x9a\x4c\x20\x3e\x47\x05\x49\x4b\x05\x30\x91\x86\xd1\x74\xd6\xd7\x86\x1a\xab\xea\x32\xe5\x2c\x42\x3f\xff\x2d\x94\xf0\x9d\xd7\x16\x4a\xf8\xf6\x6b\x0b\x25\xbc\x85\x12\xde\x42\x09\xdf\x7d\x6d\xa1\x84\xdd\xb5\xfe\x6a\x5f\xb2\x85\x12\x6e\x78\x3d\x2f\x38\x9b\x2d\x94\xf0\x83\xae\x2d\x94\xf0\xe2\xb5\x85\x12\xbe\xe5\xda\x42\x09\xdf\x72\x6d\xa1\x84\xb7\x50\xc2\x5b\x28\xe1\x2d\x28\xda\xbd\x63\x6d\x26\x28\x1a\xd9\x42\x09\xbb\x6b\x0b\x25\xfc\x2c\xa0\x9f\xc8\x16\x4a\x78\xa5\x6b\x0b\x25\xbc\x85\x12\x6e\x72\x6d\xa1\x84\xe1\xda\xfa\x5e\xb6\x50\xc2\xfe\xda\x42\x09\xe3\xf5\xc7\xd1\x9a\xb7\x50\xc2\x5b\x28\xe1\x2d\x94\xf0\x16\x4a\xf8\xce\x59\x6c\xa1\x84\x9f\x83\x3d\xa9\x4d\xca\x1b\x21\x9f\xad\x02\x54\xe1\x32\x43\xa2\xd2\xd6\x61\x39\x1a\x31\x05\x92\x0b\x9e\xbc\x90\x85\x10\x00\xad\x82\x2c\x73\x79\x06\x00\x8b\xa7\x18\x4d\x5d\xc2\xfb\x2d\x3f\x77\xb5\xb4\x80\x50\x56\x65\x6a\x9e\xbc\x7b\xdd\x0d\x2a\x46\xbb\x1c\x45\x98\xf3\x3b\x91\xb4\xcf\x55\xab\x08\xbe\xac\x00\xc3\xd1\x3d\xc9\xa4\x76\x19\xa6\x40\xac\x64\x42\x85\x60\xde\x78\xe4\x06\x9c\x32\x43\xc6\x04\x91\x05\x13\x28\xbf\x29\xd1\x5c\x8c\x33\x46\xa8\x31\x34\x99\x0c\xec\x93\x84\x27\x76\x95\x0d\xea\x3e\xd1\x46\x31\x9a\xfb\xbc\xd8\x9c\x72\x1c\x8a\xd0\x44\x49\xad\x49\x5e\x66\x86\x17\x61\x30\xa2\x19\x24\xb4\xe3\x41\x15\x88\x01\xe9\x25\x55\x0a\x69\xaf\x7a\x9a\x9b\x96\x8c\x41\x81\xc0\x74\xed\x01\x0e\x6a\x5e\x98\x59\xc8\xa3\x63\x64\xc4\x95\x36\x24\xc9\x38\x9c\xd6\xf0\x44\xac\x1d\x84\xf1\x7a\xfe\xac\x16\x6e\xa6\xda\x4d\x55\xa4\xa0\xb6\x16\x46\x63\x56\x5a\x35\xa0\x1b\x2a\xe5\xda\xa9\xf9\xba\x47\xa8\x87\xbc\x41\x42\xfb\x99\x02\xa9\xfd\xc9\x82\xa3\xbb\x8f\xa2\xe1\x22\x9c\xbc\x2a\x6d\xaf\x62\x74\x48\x31\xf6\xcc\xd9\xab\x65\x53\x57\x0a\x05\xa4\xbb\x2c\x6c\x03\x58\x00\xc1\xa6\x96\x07\x58\xc2\xec\xf9\x4a\x6f\xe1\xfa\x4f\xce\xf4\xd1\xa1\xf8\x96\x69\x4d\xc7\xec\xbc\x61\xd4\xe2\x36\x8b\x0c\x02\x17\xd5\xc2\x00\x2b\x64\x58\x9e\x16\x3e\xa9\xd2\x9c\xea\x6a\x10\xc9\x71\x4e\x41\xf9\xb9\x51\xdc\x18\x06\x8b\x0a\xe0\x48\x10\xf8\x9c\x2f\x40\xdd\x9d\x4b\x96\x7a\xeb\x07\xa9\x7e\x6c\x85\xba\x48\x31\x75\x69\xc8\xc8\x50\x71\x36\x22\x23\x0e\xf9\x50\x90\xa1\xd4\x43\xb8\x0f\x8a\x1e\x05\xad\xad\xbd\x2b\x85\xd7\x65\xfd\xbc\x06\xe4\x67\x37\x31\xa3\x4a\x91\xd0\x08\x04\x10\x4a\xb4\xf8\x88\x8c\x21\xc3\xc9\x69\x8b\x5f\xbd\xf8\xcf\xbf\x90\xe1\xcc\x1e\x69\xa0\x59\x19\x69\x68\x16\x5e\x32\x63\x62\x6c\x69\x85\xdb\xb3\x5e\x64\x14\x28\x00\x28\xe6\x38\xf1\x97\x5f\x5c\x0f\xeb\x67\xec\x41\xca\xa6\x07\x11\xfd\xfa\x99\x1c\x2f\xc3\x85\x6f\x9e\x32\xd9\xd0\x24\x5a\xc2\x66\x32\xe3\xc9\xac\x35\xa3\x79\xdc\x19\x32\x91\x37\xa8\xeb\x2f\xe1\x9e\x2a\x07\xb2\x90\x45\x99\xa1\x07\xfb\x75\x28\xcf\x2b\x35\x5b\xac\xc1\x59\xba\x2f\xc0\xe7\xea\x86\x98\xc7\x8b\xc5\xc4\x36\xff\x48\xe9\x72\xbb\x9d\x57\x30\xc0\xcf\x80\x21\xf4\x9a\x66\xd9\x90\x26\xd7\x57\xf2\x8d\x1c\xeb\x77\xe2\x44\x29\xa9\xea\x73\xc9\xa8\x95\x96\x93\x52\x5c\x23\x72\x75\x28\x11\x96\x63\xab\x5a\x15\xa5\xf1\x89\xc4\xcb\x5e\x18\x0b\x4e\xbd\x10\xf6\x66\x50\x35\x0a\xfb\xc8\x2b\x5b\xc7\x95\x4a\x20\x47\xc6\xe3\xeb\x98\xd9\xbe\x78\xf1\xd5\xd7\xc8\xba\x44\x2a\xf2\xf5\x0b\x48\x7e\xd4\x3d\xdc\xc4\x20\xdb\xec\x41\x91\xd3\x2c\xb3\x66\x43\xcc\x94\x96\xd0\xcb\x98\xf0\x93\xf3\xa0\x69\xcf\x6e\x2b\xab\x52\x57\x57\x7f\x07\x3d\x8a\x1b\xcd\xb2\x51\x0f\xab\x02\x82\x59\xb3\x0b\x07\xc3\xae\x93\x3e\x50\x9a\xb1\x01\x0a\xd0\x54\x66\x65\xce\x8e\xd9\x94\x77\xd1\xbc\xa2\x36\x9a\x37\xf5\x33\xae\xa1\x00\x63\x98\xc9\xe4\x9a\xa4\xee\xcb\x28\x8d\x65\x1e\x42\xb5\x39\x15\x9a\x26\xf4\xb4\x48\xe4\xb9\xf5\xfd\x6b\x29\x3c\x39\x2d\x8a\x90\xa3\xaf\xe8\x4d\x8d\x18\xb0\x27\xa1\xde\xb7\x25\x9e\x42\x6b\x37\x73\x5b\x27\x73\xdf\xbd\x91\x95\x9b\x8d\x87\x68\x9c\xc2\xd2\xde\x47\x5d\xcd\xbe\xb9\x63\xb2\xc6\x10\xd5\x80\x7e\x37\x14\xf0\xdf\x98\x9e\xbd\x50\x95\x14\x0a\x5b\x02\x63\xa0\x02\x60\xd9\x07\x44\x72\x73\x87\x6b\x07\xde\xcd\x76\xf9\x4b\x35\xba\x88\xe0\x55\xce\xa9\x71\x0a\xa1\x77\x5f\x53\x52\x30\xa5\xb9\xb6\xe7\xf2\x4f\xb0\xa1\x8e\x32\xca\xf3\xc8\x05\xb8\x1e\x22\xe0\xe6\x06\xe4\xcb\xf6\x92\xf2\x5c\xa6\x6e\x40\x10\x85\x88\xfa\xb9\x44\xad\xad\x6b\xb5\x1d\x1e\xa8\xeb\x16\x95\x3f\x55\xd4\xac\x4b\x4a\xfb\x49\x10\x95\x78\xd7\x73\x12\x90\xf0\x7e\x4f\x55\x3e\x86\xc9\x77\x24\x06\x40\x30\xba\xc5\xad\x4b\xc2\x9a\xf1\x88\x1b\x25\x52\xe9\x9d\x1d\x38\x20\x18\x52\xb7\x7b\xc2\xfd\x94\xec\xbe\xda\x5d\xab\x90\x44\x12\x29\x59\xd0\x71\xab\x1e\x06\x73\x94\x9a\x1f\x36\x2e\xf4\xb6\x66\x10\x7c\x1f\x60\x87\xe0\x2e\x96\x56\x40\x14\x00\x33\x82\xd1\x51\x4f\x60\x67\x20\x60\x3d\xe4\x0d\x9d\x11\xaa\x64\x29\x52\xe7\x5f\x0a\x0e\xbe\xb7\x73\x0f\x3e\x93\x82\x79\xc7\xf9\x7c\x9d\x38\x78\xf4\xb9\x20\x2f\x07\x2f\x5f\x3c\x97\x93\x0a\xde\x70\xee\xa4\x3a\x0b\x27\x15\xca\xa7\xb5\xbe\xab\x47\x3b\xee\xe8\x7d\xdf\x3a\x17\x4b\x05\x66\xcc\x3d\x58\x2b\x7c\x74\xa3\xb8\x61\x51\x6f\xa3\x3d\x30\x5c\xac\x7d\x18\x55\x45\xef\x77\x88\xe1\xdd\x4d\x19\xba\x2e\x87\x8f\x28\xb7\x9c\x80\x82\xed\xb6\xcc\xc3\xa5\xef\x10\x61\x31\xa1\x76\x76\xc8\x1e\xde\xb9\x8b\x95\x81\xfb\x6b\x65\x2d\x47\xb4\x93\x8f\x45\x0b\x8c\xb9\x1a\xe1\x4e\x3e\x16\x14\x7c\x70\x45\x87\x14\xfc\x9e\x4d\xe8\x94\x41\x45\x24\xcf\xa8\xca\x20\xe6\x78\x89\x73\x27\xc3\xd2\x10\x26\xa6\x5c\x49\x01\x09\x3e\x53\xaa\x38\xa0\x52\x28\x06\x95\xd5\xd6\x16\xfd\x8f\xbd\x9f\x0e\x2f\x20\xa1\x61\xdf\x95\x84\xbb\x59\x96\xda\xc3\x47\xc4\x33\x89\x86\xbb\x77\xf9\xfc\x3c\x2c\x0d\x41\xe6\xfa\x79\xd9\xe7\xe4\xa5\x29\x11\x10\xff\x63\x92\x95\x9a\x4f\xd7\x25\x49\x5c\xa9\xea\x31\x6f\xb4\xce\x73\x65\xb3\x15\xa1\x16\x2a\x60\xc1\xb5\x0e\x47\xcb\x3d\x08\xac\xbb\x3a\x60\x56\xc5\x31\x70\xe7\x7a\x72\xb5\xec\x98\x8b\xe7\x21\xcb\x16\x54\x08\xc0\x6d\x58\xaf\x13\x4a\xc8\x94\x3d\x1c\xf5\xa2\x9e\xde\xe3\x86\xc0\x98\x79\x54\x0e\xa8\x93\x09\x4b\x4b\x80\x57\xe1\x1a\xc1\x01\xad\xf9\x40\x2b\x18\x2b\x01\xfd\x19\x4e\x47\xa1\x36\x58\xf4\xc1\x39\x88\x34\xf7\xbf\x57\xbe\x92\xd8\x7f\xa0\xe7\x46\x04\xa3\xd4\x8e\xd5\x23\x54\xeb\x32\xc7\x2d\x81\xf0\xdb\x23\x6e\x74\xe8\xad\xe7\xb5\x63\xbb\x31\x1e\x58\x9d\xd5\x82\xbe\x97\x2c\x03\xe6\x6a\x41\xe3\xdd\xb3\x68\x1c\x24\xb4\xf6\x7f\x39\x86\x73\x09\x13\x10\x6d\x0b\x49\xa1\x12\xbc\xa4\x23\x0e\xed\x2b\xa8\xa3\xf7\xe5\x92\x5f\xa2\xea\x80\x77\x00\x3c\x03\x1d\xb2\x4c\xcf\x0f\x34\xac\x16\xc5\xc1\xfa\x39\xc2\xb7\xec\x0e\x48\xb5\xe6\x63\x01\x7d\xc3\xec\x68\x0f\xec\x10\xd6\xd8\x66\xea\xa2\xfb\x5f\x63\xa9\x56\xcb\xc2\xca\x69\xd1\x77\x56\xaf\x91\x39\x4f\x1e\x30\x92\x9c\x32\x35\x61\xf4\x81\x06\xdf\x5c\x5c\xcc\x8d\x51\xb5\x8e\xd1\xae\xca\xd1\xed\x1b\xff\x10\xbb\xbf\x64\x02\xd9\xf6\xe8\xa7\xf7\xd9\x4f\x14\x58\x04\x1b\x53\x8e\xf9\x94\x09\x0f\xfc\x77\x94\xd1\xd0\x7c\xcc\x43\x25\x39\xf0\xc1\xd2\xc8\x10\xf9\xb0\xe6\x54\x85\x5e\x06\x81\x52\xe7\x74\x8d\xc7\x89\x6e\x71\xad\xcb\x32\x0f\xd6\xbf\xca\x9d\x10\x7c\xc0\xd6\x1f\xbd\xea\x95\x72\x6f\xa0\xd5\xe0\x71\x48\x02\x21\xb2\xd0\x15\x14\x03\x11\xf7\x3f\xc2\xc5\xb5\x2d\x2f\x2e\x1b\xc6\xed\xb9\x80\xe3\x54\x11\x36\xb3\xca\xeb\x8c\x40\x73\x89\xd3\x51\xfd\x49\xbc\x06\x7d\x09\xd9\xd8\xb0\x87\xab\x43\xe5\x5c\xa6\x97\x05\x4b\x7a\x24\x2c\x65\xdc\xb9\xcd\x39\x6d\x30\xb5\x25\xc2\x6f\xc4\xe3\x48\x29\xa6\x0b\x89\x08\x9c\xf1\x63\xe3\x06\xa1\xdc\xd4\x22\xf6\xd8\x88\x00\x2c\xb4\x0a\x2b\xe1\xdf\x4c\xc9\xa5\x82\x60\xcc\xcd\xe0\xfa\x6b\x90\x02\x4c\x4c\xa8\x48\x50\x00\x1f\x5c\xb3\x42\x1f\x68\x3e\xc6\x4d\xff\x97\xaf\xbf\x06\x09\xe0\x49\x72\x70\x71\x72\x78\xfc\xf6\x64\x90\xa7\x4b\x8c\x38\x8f\xf5\x05\x61\xb1\x1f\xc3\x46\x22\xd3\x97\x83\x97\x5f\x63\xdc\x9e\x6b\x04\x20\x89\xe0\xbf\xb0\x26\x6d\x11\xfb\xeb\x5c\xa6\x81\x6e\x2e\x6f\xeb\x81\xd1\xc8\xb5\xca\xa0\x27\xd3\x77\xb4\x61\x46\x6d\xdb\x2c\xda\x56\x99\xb3\x1d\x66\xcb\x16\x8a\x59\xf5\x86\x4b\xd1\x24\xce\x5c\xb7\xef\xe6\x86\xf2\xce\x7b\xf7\x97\x15\xc4\xfe\x69\x62\x6c\x65\xb3\x46\x79\x9d\xc9\x1b\xc8\x0d\xe1\x52\x71\x33\x1b\x00\x54\x8f\x1c\x91\x33\x36\x65\xaa\xe7\x47\x7d\x63\x6f\x3a\x0f\xf7\xc4\x06\xc4\xb2\x3b\xa2\xae\x38\xb7\x6d\xd4\x1e\x19\xc7\x69\x08\x67\x52\x9c\x87\xd9\x85\x61\xdc\xce\xeb\x43\xc6\xe4\xa7\x50\xce\x3c\x19\x5a\xac\x03\xa2\x1f\xbb\x17\x70\x8d\x92\x7f\xa2\x8a\xcb\x52\x13\xf4\x89\xc7\x98\x83\x18\x47\x0f\x24\x02\xd5\xcc\x79\xb9\xc2\x20\x21\x3d\xde\x3b\xba\x02\x7d\x0e\xc3\x79\x73\xb4\xfc\x48\xe3\xc6\x2e\xfa\xd4\x3f\x4a\xf9\x7c\x9f\x05\xb8\x42\x3c\xcc\x96\x9e\x5f\xfe\x44\xd6\xf1\x44\x61\x18\x3f\x0f\x38\x1b\xac\xc2\x8f\xa3\x4c\xf8\xd8\x67\x95\xc1\xfb\xa3\xee\x1e\x7d\x1a\x98\xad\xc1\x92\x36\xd9\xf1\x4d\x93\x1b\x8b\xf9\xf7\x6b\xc1\x16\x75\x50\xb7\x18\x17\xce\xa7\x55\x57\x5b\x70\x07\xf9\x04\x0e\xc1\x7e\xa2\xb8\xe1\x09\xcd\x76\xe0\x08\xf3\x5f\x59\xdb\xdb\x30\x15\x7f\xab\x18\x31\x37\x12\x9f\x42\x33\x72\xcd\x66\x37\x52\xa5\x5e\xbf\xf0\x4f\xac\xd6\x42\x1b\xff\x48\xce\x9c\x2c\x40\x48\x2e\x95\x33\x45\x86\xcc\xbb\x11\xe6\x6e\x9e\x0d\xc8\xa1\x98\x39\x1f\xac\x88\x2b\x2d\xbc\x1a\x31\x9c\xa1\x8e\x83\x5a\x60\x8d\x49\xdc\x79\xe8\x9f\x46\xb1\x06\xe6\x36\x13\xdb\x2a\x90\x61\x17\x78\xed\xc5\xdb\xd8\x52\xb9\x54\x6f\xd8\x1d\x0a\x13\xd5\xa5\xff\xfa\x93\x48\x0b\xab\x9f\x71\xc1\xb4\xfe\xc1\x2e\x65\x1b\x75\xbb\xce\x1d\x14\xd4\x2a\x37\x36\xc8\xc9\x2a\xaf\x8a\xd9\x2d\x45\x7d\xcf\x77\x4b\xa1\x70\xe7\x80\x1c\xc2\x07\x90\x18\x68\x35\x47\x28\x25\xb0\x83\x59\x8b\x77\xae\xb7\x21\xde\x71\x78\x76\xec\x13\xb8\x50\xe9\xd0\x75\xcc\x46\x54\xf9\xeb\x33\x01\x4d\xd5\xa5\x11\xb1\xdf\x4a\x0a\xad\xaa\x76\xae\x54\xc9\x76\x9a\xa9\x7a\x88\x06\x7a\xf0\xe7\xaf\x5f\x80\xb6\x17\x9e\x07\x62\xff\x81\x59\xd1\x4d\x03\x85\x8d\x42\x84\xf3\xd1\xd1\x8b\x98\x1f\x3c\xc1\xbd\xdd\xe4\x3c\x77\x50\xe0\x04\xcb\x14\x68\xde\xc8\xbe\x6c\x14\x10\x6c\x1e\x0a\xec\x57\xd3\xbd\x7a\x78\x27\x84\x36\x51\xbc\xda\x73\xbb\x70\xf5\x55\xa3\xe1\xaa\x60\xa3\xe5\xea\x39\x51\xd0\x1e\xf1\x76\xdd\xc7\x90\x13\x04\x82\x0b\x5c\x23\x20\x1e\x67\x45\x8b\xfc\xa7\x06\xf2\x06\xd2\x7d\x5b\xab\x8a\xbb\x17\x38\x10\x29\x2a\xdd\x70\x21\x8d\x33\xb8\xb9\x41\xef\x70\x5a\xe1\x21\xe4\xc4\xf7\xc8\x3b\xf1\x1a\x93\x04\x7b\xa8\x28\xd6\xea\xb9\xf1\xa6\x4e\x6b\x25\x0e\xfe\xe4\xde\xbd\x8f\x53\x6e\x22\x14\x1e\x4e\xee\xc8\xf2\x6d\x79\xfa\xef\x5e\xcc\x8d\x55\x63\xbd\x9a\x65\xef\x4e\x48\x5e\x75\x50\x70\xe2\x93\x8c\x95\x2c\x0b\xef\x4e\xae\xb7\x43\xa8\x20\x84\xd1\x0b\x8a\xbd\xba\x84\xac\x0f\x1d\x9c\x37\xc0\xc0\xac\x42\x21\x4f\x49\x82\xe6\xbd\x3f\x75\x31\x15\x1c\x3d\x20\xaa\x14\xf5\x56\x83\x91\x43\x76\x27\x63\x63\x9a\xcc\x76\xea\xcf\x59\xe6\xfe\xe6\x90\xa1\xcc\x73\x84\x5f\xc4\xe7\x55\x89\x9d\x90\xff\x09\xfa\x03\xee\x35\x50\x0d\x42\x3f\x58\x7f\xe4\xfb\xca\x84\x09\x15\x29\xb8\x79\x1a\x7b\x16\xfe\xfc\xf5\x9f\xfb\x6e\xb4\x3e\x4e\x65\xbe\xc6\xcb\xd5\x6a\x2d\x75\x27\x7c\xd5\xc8\x15\xf0\x60\xfe\x0b\xde\xee\x4e\x55\xcf\xda\x12\x5b\x7d\x8a\xeb\x02\xd8\x01\xfd\x21\xe1\xf4\x0f\x4f\xbf\x4b\x3b\x5b\x3e\x48\xe8\x41\x1f\x86\xf8\x24\xe4\xaa\xe3\x4b\xb7\xd9\xad\xf3\x50\xd5\x13\x99\xa5\xb0\xaf\x9c\x93\xc9\x3f\x8a\x50\x63\x14\x1f\x96\xd0\x2d\x47\xa4\x00\x75\x5a\xaf\x33\x71\x5d\x39\x06\xa4\x2a\x34\x88\x8d\x67\x60\xfc\x01\x21\x97\xcc\xb5\x54\x8e\xe6\x01\x62\xd9\x93\x12\x0c\x29\xe0\x45\x68\xde\x87\x36\xdb\x27\x72\x48\x35\x3f\xbd\x47\x4d\xbb\xf6\xd6\x3b\xd9\x1c\x06\xa3\x46\x97\x85\x43\x3d\xa0\x19\xca\xc3\x85\x1e\x5f\x73\x07\x19\xa4\x60\x81\x44\xbc\x94\x79\x88\xd9\x5a\x5a\x68\x04\xe9\x03\x5e\xf6\xfd\x5c\x8d\x84\xfa\xa6\xb1\x73\xc5\xde\xd8\x21\x26\xbc\x40\x13\x9c\x9a\xf0\x73\x08\x7c\xd8\xaf\xe3\x72\x55\xe8\x90\xf3\x12\x6d\x60\x79\x03\x4e\xf0\x1f\x4e\x8f\xc3\x1e\xb1\x77\xbd\xbe\x04\x82\x90\x2f\x06\xae\x5d\x97\x19\xf3\x94\x0c\x31\xd8\x65\xc5\xeb\x9e\x60\x37\x98\x3e\xe7\xfc\xc4\x41\x0d\x9f\xfa\xb4\x32\x1c\x2d\x3c\xdc\x0d\xb9\x4f\xbe\x74\x9d\x97\x98\xf2\x46\xfc\x90\xbb\xf4\x9a\x77\x17\xbb\xde\x3b\x7f\xd3\x57\x37\xfd\x7e\xbf\x6f\xe7\xea\x85\xfa\x92\x9e\xb6\x76\xbf\xe7\x32\xe5\xa3\xd9\x1c\x25\x2c\x9b\x57\x8f\x00\x8e\xa4\x62\xe6\x66\xd7\xa0\xd5\x4e\x3b\x3f\x5e\x9b\x0a\x54\xc7\x9c\x47\xb0\xde\x4d\xcb\x3c\xea\x72\x63\xc9\x90\xce\x2a\xd6\x64\xc8\x26\x74\xca\x25\x14\xa6\x02\x8f\x41\xc2\xe0\x2d\x74\xf5\x3e\x1f\xb7\xe8\x0e\xeb\x08\x6d\x72\xf6\xb1\x90\x88\xa4\x08\x09\xb9\xd0\x24\x62\x3e\x98\x02\x6e\x6e\xbb\x29\x20\xaf\xa0\xc6\xf4\x4e\x7d\x40\x34\x11\x4f\x04\x32\xa4\x76\xc8\x30\x9d\xbd\xb9\x65\xde\x1f\x90\x53\xc7\x19\x60\xfe\x09\xe9\x5a\x4d\x10\x29\x08\x2b\x26\x2c\x67\x8a\x66\xf5\x07\xb9\xc2\xa4\x57\x56\x5a\x2a\xcb\x64\x18\xb0\xc8\x69\x81\xc2\x12\x64\x5f\xca\x95\xef\x35\xe5\x44\x9c\xe5\xd7\x9d\x77\xd0\xf1\xf9\x2d\xd7\xa0\xa9\x38\xd7\x07\xea\x95\x3b\xcb\xce\x23\xff\x5d\xc8\xf2\x7a\x78\xe5\x50\x0b\x87\x70\x9b\xfe\xe4\x6b\xea\x4c\xbe\xee\xde\xae\x2e\x8e\x4c\x4d\x9b\xf4\xd8\xf5\xc9\x8e\x76\x7d\xc9\xb7\x1d\xc9\x57\xe9\x48\xbe\x6e\x16\x6d\xca\x8f\xcd\x92\xfe\x5a\xb4\x20\xdf\xc8\xe6\xe3\xeb\x5e\xbd\x27\x2e\x60\xda\xb6\x1e\x7f\x78\xd3\xf1\x55\x9a\x05\x3e\x7a\xd7\xf1\x67\xc4\x35\x0d\x2b\x36\xda\x15\x3c\xb4\xe8\x39\xbe\xd6\x6e\xe3\x2d\x13\x7f\x9b\x77\x18\x5f\x6b\x6f\xf1\x96\x6f\xdd\xbc\x5d\xec\x5a\x3b\x89\xb7\x7c\xeb\xe6\xdd\xc3\xd7\xda\x37\xbc\xc5\x5b\xb7\xed\x15\xfe\xa0\x2e\xe1\x6c\xce\x79\x12\x3c\xca\x9f\x56\x0c\xb6\x29\x5a\x6b\xd8\xac\xbb\xa5\xe4\xed\xa4\x41\xf7\xb6\x35\x77\x97\xad\xb9\x37\x43\xbe\x6e\x1b\x71\xb7\x6b\xc4\xdd\x46\x72\x46\xee\x62\xf0\xcf\xb4\xd5\xa4\x0f\x03\x32\x04\x38\x9f\x6b\xdd\xb6\x2b\xf4\x28\x67\x54\xb9\xae\x66\x73\x8a\x6f\x0f\x56\xc7\xe5\x78\x2e\x1c\x2e\x98\x07\x94\x53\x35\x23\x3f\x9c\x1e\xa3\xfe\x5b\x53\xc3\x85\xf4\x8f\x0e\x9c\x92\x3a\x80\x20\x2a\x66\xed\xd5\xd6\x66\x35\xd6\x8d\x2b\xac\xdb\x62\xd7\xb5\xb2\xb1\x66\x3a\x31\x59\x5b\x96\xb8\xc4\x51\x20\x46\x44\x68\xe0\x0f\x41\x73\xa6\x0b\x9a\x58\xe9\xe7\xee\x80\x40\x6d\x54\x3f\x31\xb0\x96\x8b\x0b\x82\x96\xa2\xc2\x77\xf6\xf7\xef\xcd\x1f\xc8\x7e\x4b\xee\xbb\x62\x22\xef\x95\xc9\x68\x29\x92\xc9\x13\x59\xf1\x25\xc4\x0b\x3e\x72\x4a\xae\x99\x12\x2c\xab\x7a\x86\xfa\x1a\x13\xd6\xa4\xf6\xbd\x65\xe9\x7c\xbb\xc2\xf9\x16\x45\xef\xcd\x5b\x00\xb5\x2d\x97\x6f\x53\x84\xbc\xa4\x2f\xca\x08\xcf\x26\x3b\xa5\x99\x6b\x97\xd5\x70\xf0\xd6\x95\xa1\xad\x9a\xfa\xd4\x51\x20\x10\xc2\x76\x23\xde\xcd\x35\xea\xef\xce\x4d\xe4\x5b\x52\x87\x82\x3c\x1f\xc1\x7e\xa8\xab\xc8\x2b\x2c\x8b\x30\x18\xbb\x7a\xc1\x0d\x53\xc7\x0c\x7e\x1a\x6e\xde\xb5\xf8\x77\xc6\xb9\xa6\x47\xca\x4e\xdc\x70\x9a\x5d\x16\x4d\xdb\xf3\xd6\xd6\xfd\x87\xb7\x97\x87\xf5\x41\xad\xf6\x7d\x03\x49\xb5\x96\xa8\xf6\xfb\x28\x35\xfc\x86\x0d\x27\x52\x5e\x93\xbd\x28\xe5\x66\x52\x0e\x07\x89\xcc\xa3\xfc\xae\xbe\xe6\x63\x7d\xe0\xf8\xb3\x6f\xe7\xbd\x4f\xb8\x00\x30\xb6\x45\x10\x3b\xff\x90\x24\xcc\x02\xd6\xd0\xe5\x26\xb9\x63\x70\x71\x9a\x20\x64\x30\x15\x62\x1d\xf6\xc1\xe2\x62\x34\xef\x16\x7f\xcf\x82\xf8\x6a\xda\x18\x73\xe8\x56\xaa\xa1\x39\xbf\x16\x92\x4c\xaa\xb6\xff\x1d\xd0\xe1\x6f\xd5\x68\x31\x76\x08\x1f\xd5\x60\x4d\x2b\x3b\x23\x04\xca\x76\xa1\xbd\x82\xfb\xe9\x6e\xec\x74\xae\x97\xa3\xd0\xac\x98\x84\xc2\x31\x11\xc7\xce\x87\x2c\xae\x12\x8b\x0a\x36\xe6\x0b\xc5\x9c\xc0\x8c\xa6\x7a\x54\xf9\x4f\x7c\x16\xd9\x28\xa3\x63\x80\x67\x9f\xab\xba\x00\xe9\x08\x2d\x88\xad\xed\x10\xdd\xec\x4b\xeb\x3c\xf4\x30\x20\x1f\x6a\x4c\xe8\xf6\x81\x34\x97\x9e\x0f\xf1\xff\x43\x3b\x6f\xdf\x4b\xbd\x96\xeb\x0d\x56\x7e\x28\x2e\xd4\x96\x77\x30\x72\x6f\x6d\xf6\x98\xc0\x28\x3a\xf7\xaa\x9e\xcc\x90\x1d\x83\x02\x1f\x7e\x4f\x49\xce\x3f\xda\xa7\xc4\xbf\x8a\xb3\xca\x5d\x2f\xe4\xe5\x5f\xef\x5b\x5b\xa6\x32\x7c\x7a\x76\x15\xe3\x3b\x23\x58\x60\x01\x5f\x9c\x61\x5a\x38\xbe\x40\x1c\x26\x70\x08\xbf\x6d\xf8\xbb\x39\x2e\x47\x08\xd3\x75\xb4\xd5\x21\x5c\xe7\x86\xb3\x0b\xed\xcf\xdf\x36\xe1\x3b\x7b\x4b\x17\x21\xbc\xc5\x43\x76\xf3\xcf\x66\xd2\x26\x7f\x50\x4d\x79\xc2\x0e\x93\x44\x96\xa2\x55\xfa\xe0\x31\xb3\xaf\x40\x0d\x4b\x2f\x6b\x63\xa2\xbf\x39\x85\x6f\xb1\x62\x9a\x66\x9c\x62\x4d\x7d\xfd\x4e\x2c\xa6\xaa\xc6\x01\x7f\xf5\xdc\x0c\x1d\xcb\x60\xbb\xdd\x4f\x93\x90\xba\xf0\xfc\x76\x49\x96\x8b\x6f\xb3\x78\xc2\xcd\x51\xd0\xb9\xaa\x17\xd2\x9d\x57\xcb\x35\x37\x54\x5f\x57\x48\x03\x0c\xca\x4d\xc2\x66\x8a\x3e\x77\x2f\xda\xa7\xf8\xd4\x46\xe8\x03\x0d\xa8\x6b\xac\xdc\xb3\x2f\x7f\xa8\x5f\xff\xd7\xf1\x59\xbb\x94\xdf\x00\xb2\x8e\x75\x0c\x13\x37\x74\xd0\xb5\xe3\xf2\xf1\xb8\x0c\xcd\x3e\xb9\x47\x14\x75\xf8\xb1\xae\x77\x48\xc6\x28\xfa\x34\xc8\x5e\x94\x91\xbd\x3f\xb0\x32\xbd\x0a\xf5\xa2\xa8\x77\xad\x3e\x72\x46\x85\x8e\x4a\x0d\x19\x0c\xed\xd3\x19\xc3\x7c\xf0\x20\x74\xab\xed\xcc\xff\x3d\xef\xb3\xac\xdf\x81\xad\xff\x49\x69\xb4\xfd\x1c\x1f\xee\x05\xe6\x0a\x8f\x57\x6c\xcc\xb5\x51\x33\xdf\x84\x64\x14\x4d\xc2\x79\x65\xc2\x2d\xd7\x6c\x46\xfe\xf6\xe3\xc9\xdf\xff\xf1\xe6\xdd\xd1\xe1\x9b\x7f\xbc\x3d\x3c\xfa\xdb\xe9\xd9\xc9\x87\x0f\x97\x7f\xbf\xbc\x3a\x79\xfb\xe1\xc3\x51\xa9\x14\x13\xc6\x95\x5d\x5e\x32\xf3\xe1\x83\xe3\x54\xfd\xe1\xc3\x55\x52\xf0\xe2\xc3\x87\x73\xef\xc4\x40\x78\xe1\xff\x3a\x3e\x03\xf9\x89\xd5\x3f\x21\xe5\x06\xce\x56\x24\x3a\xcc\x7b\x42\x75\x95\x5e\x57\xab\xab\x68\x00\x49\xd5\xf4\xb8\xd3\x13\xaa\x98\x3b\x9a\xcf\xbc\x27\xab\xd5\x66\xb7\x03\x56\x7d\x01\xbc\x87\x34\x78\xc9\xc8\x90\x99\x1b\xe6\xca\xd5\xe6\x8f\xb9\x38\x8b\xf7\x67\x6c\x8f\x83\xc9\xfa\xf6\x28\x5a\x82\x3d\x8e\xca\x99\x24\x53\xce\x6e\x10\x1b\x01\xdb\xbc\x54\x00\xf8\x50\xbe\x8a\x25\x8c\xf3\xe1\x2e\xa7\x24\x15\x32\x0d\x60\xff\x73\x6e\xdd\x05\x97\x6e\xad\x5c\x02\x91\x4b\x58\x4a\xce\x4f\x8f\xc9\xcb\x01\x2a\x39\xa7\xc7\x08\xa4\xb4\x8c\xac\x24\x71\x68\x3f\xf6\x40\xc5\xd3\x77\x49\xba\x78\xc5\x00\x4d\x84\x51\x03\x0e\x28\x87\xa9\xcc\xe9\x43\xdb\x7a\xdc\x53\x78\x80\x4d\x97\x7e\x2b\x69\x86\x3a\xc0\xb9\x4c\x17\x25\xd3\xce\x37\xfe\xa3\x6f\x07\xdf\x84\x79\x7c\x3b\xf8\x06\xda\x39\x79\xb2\x7d\x3b\xd0\xd3\x64\xf0\x8d\x2b\x84\x25\xee\xa6\xa5\xd9\xa1\x0b\x55\x2d\x4e\x9f\xc5\xdf\xc0\xb3\x29\xe8\xbb\x9f\xa4\x4e\xa1\xc3\xbe\x58\x1d\x77\xc3\x42\x2d\x10\x6a\x6c\x13\xc5\xa8\x6b\xd7\x9e\xb2\x8c\x99\xa8\xbf\xfd\xda\xdb\x31\xdd\xde\x9f\xca\x87\xaa\x6a\xdd\xbb\x62\xe7\x52\xd0\x97\xfe\xf0\x4d\xbe\x62\x83\xe1\xcb\xaa\x01\x6b\x83\x0d\xd0\xb2\x22\xff\x41\x61\x1b\x23\x33\x86\xeb\xd3\x66\xa7\x2c\x2d\x88\xda\xd5\xf1\xe8\x4d\x08\xb1\x8e\xaa\xe3\x2b\x0f\xc5\x65\x39\xe2\x2a\xcc\x1f\x2c\x0d\x6c\x5e\x83\xb1\x49\xfc\x06\xca\x94\x66\xc4\x9e\x5a\x06\x3d\x19\x71\x25\xa0\x51\xd0\x66\xe7\x9b\x6b\x36\xeb\x21\x70\x03\x2a\x21\xdf\x46\x98\x82\xa1\xf4\x55\x16\x76\x40\xa9\xc8\x37\xfe\xbf\xbe\x7d\xa8\xb5\xd6\xc2\x8f\xda\xc6\x8b\x8a\x2f\xd5\x3a\x74\x75\x82\xf5\x0f\x75\x24\x07\xa4\xac\x2b\x8d\x30\x12\xc9\x35\x20\x27\x50\xdf\x88\x1a\xa9\xc3\x55\xcb\xb2\xda\xcd\xda\xf7\x48\xaa\xa1\x00\x80\xff\x25\xaa\x8b\x38\x93\x97\xae\xa4\x0e\x90\x59\x46\x4c\x55\x9f\x80\x80\x39\x93\x27\x1f\x59\x52\x3e\x14\x2d\x05\xaf\x56\xbe\xbf\x6b\xd6\xbe\x6b\xc5\x8f\x2c\xa0\xd6\x20\x6d\xac\x16\x1e\xb2\xe2\xab\xdd\x19\xa5\x66\xdd\x4d\xdb\x6b\x36\xd3\x01\x0c\xec\x1a\x47\x77\xd5\xab\x81\x7f\xfd\x41\x76\xf2\x91\x6b\xa3\xff\x8f\x6f\x99\x91\x0f\xab\x66\x25\x14\x73\xa4\xaa\xd1\xfd\x92\x08\xe8\xa5\x81\x8f\xf9\xd4\x04\xf7\x2f\xd0\x9a\xea\xef\x3c\x25\x22\xa8\x37\x6a\xdf\x69\x57\xbb\xec\x1e\x29\xa0\x44\x29\xc6\x0c\xab\xf2\x52\xf0\xc7\xc8\x9f\x48\x43\xa0\xcb\x89\x55\xf2\xea\xc7\x8c\xfb\xc8\xdd\xc4\x01\x3d\x82\x4f\x69\xc6\xd0\xae\xbf\xe1\x59\x9a\x50\x85\x21\x72\x07\x1c\xa3\x1d\x94\xa3\x43\x4c\xb0\x67\x9c\x93\x64\xd5\x2a\x6b\x17\x8b\xa3\xca\xf0\xa4\xcc\xa8\x22\x76\x3f\x8e\xa5\x7a\x20\xbe\x0c\x5e\xed\x5a\xb7\x04\x16\x6d\xd1\xd1\xb0\x2e\xdf\xe7\x47\x9c\x07\xe4\x73\xda\x8b\x35\x99\xa0\xb6\xa3\xbe\x51\xf6\xea\x50\x90\x72\xe4\x65\x53\x10\x14\x31\xa4\x9b\xa9\x39\xc7\xf9\x18\xfc\xdf\xfb\xd1\xe1\x11\x76\xe6\x80\x7c\x1f\xca\x7c\x7b\xa4\xf2\x19\x43\x31\xa1\x7b\xa6\xdb\x36\x6e\xb9\xaa\x4d\x3d\x92\x0a\xfa\xf0\xec\xa5\x12\x7e\xc3\xa6\x3c\x31\xfb\x03\xf2\xff\x5a\x4d\x11\x9c\xc8\x5e\x9d\x74\xdb\x2c\x14\x50\x56\xc0\x72\x2f\xc8\x1e\xfc\x2c\x56\x25\xf7\x7d\xa0\xc8\x75\x1e\x78\x62\xd9\x28\x2d\x42\xd4\x4b\xc2\xd3\x35\x31\x8a\x9a\xe2\x1c\x6b\x84\x93\x5f\x06\x09\x19\x64\x22\xd7\x6e\x97\xd6\x3c\xb7\x21\xce\xe2\x45\x68\x60\x9c\x7f\x81\x8f\x9e\x28\x36\x86\xfd\x87\xbb\xe7\x13\xee\x3e\x23\x0b\x99\xc9\xf1\xec\xb2\x50\x8c\xa6\x47\x52\x68\xa3\x40\x34\xb4\xc1\xf1\xba\x6d\xcc\xa8\xf5\xc3\x44\xde\x10\xea\xea\x90\xe5\x08\x41\xd5\x64\x39\x9e\x20\xd8\x2d\xfc\xd0\xb7\x49\xf3\x53\x74\x46\xa7\x1e\x90\xcb\x00\x66\x0b\x0c\x1e\xb0\x71\x61\x14\x70\x78\xdc\xd0\x99\xdb\x4c\x74\x08\xdd\x72\xab\x84\x20\x3f\x19\x0c\xfd\xdc\xfa\xfe\x20\x95\x0f\xcf\x8e\x1f\x8a\x20\xbc\x46\x85\xf6\x96\x57\x89\x7a\xe7\x43\x0b\xb5\x40\xdf\xa0\x91\x02\xdd\x68\x2e\x9d\xa6\x8a\x98\xa3\x9e\x32\x9f\x50\x37\x6d\x03\xb2\x93\xd3\x8f\x97\xd7\xec\xa6\xc1\x2f\xfd\x8b\xfe\xc8\x1e\x9e\xcb\xd5\x07\x7b\xf4\xbd\xd0\xd4\x70\x3d\x02\xa8\xf1\x4f\xa8\x8f\x43\xca\x7d\x33\x44\x64\xbc\xea\x95\x2b\xf1\x68\xa1\x5b\xb2\xc7\xd5\xab\x31\x8b\xcb\xbf\xab\xec\x20\x3c\x00\xb1\x04\x20\x80\x29\xdb\x1d\x94\xb8\x06\x03\x46\x56\x71\x68\x8c\x54\x84\x5e\xc3\x7e\xd7\x9a\x09\xe3\x6a\x0e\x42\x75\x6e\xef\x37\x17\x8c\x8d\x53\xd9\xda\xe6\x85\x01\x79\x4e\x3e\x5a\xcd\x43\x37\xcb\x34\xc2\xab\xde\x1f\x64\x6e\x50\x0c\x8f\xf9\x04\xca\xb9\x65\xa8\xe1\x74\x83\xd9\x1b\x7f\xd2\x54\xce\x55\x57\xbb\x0e\x43\xa4\x5d\x97\x21\xb2\x24\xcf\xf8\xd6\xd7\x9f\x03\xfb\x8e\xab\xd5\x9c\x53\x48\xf7\x50\x81\x47\x07\x36\x15\xd5\xc1\xee\x1a\xbf\x66\x41\x9b\xb3\x46\x91\xbd\x09\x7f\xd7\x16\xca\xbf\x45\x97\x22\xd2\x41\xa7\x22\x02\xb2\xec\xba\x81\x04\x8c\x7f\xef\x89\xd5\x78\x90\xf6\x3d\x8b\x48\x73\x83\xba\xba\x6a\x0c\x75\x5d\x99\xd6\xc8\x59\x35\xd3\xba\x12\x76\x95\x61\xdd\xea\xd9\x1d\x34\xf2\x20\x2d\x6d\xdc\xea\xaa\x11\x42\x3e\xc0\xda\xa5\x10\x60\x92\x23\xbf\x3b\x96\xda\xbc\xa7\xa2\x47\xce\xa4\xb1\xff\x44\xe6\xef\xb1\x64\xfa\x4c\x1a\xf8\x64\x23\x48\x89\xaf\xd0\x21\x21\x9d\x71\x86\xb8\x5e\x20\x37\x5d\x88\xd6\x9e\x78\x9e\x60\x4b\x0c\x8b\x53\x41\xa4\xf2\x14\x0b\xd6\x85\x76\x43\xc4\x61\x05\x07\x8e\x74\xab\x71\x62\xc7\x89\xe9\x7c\xc7\x70\x6e\x28\xc8\xfe\xc2\x6f\x00\x24\xb3\xc8\x20\x41\x3f\x2d\x15\x62\x95\x5a\x5d\xd3\xb0\x31\x4f\x48\xce\xd4\x18\x1a\x1f\x36\xc9\xab\x8f\xaf\xf6\xe7\x0a\x5e\x2d\x4f\x97\x78\x32\x2d\x78\x09\x8e\x6c\x50\xb1\x3a\x54\x01\x70\x3c\x3c\xd6\x72\x0a\x96\xd4\xff\x04\x1f\xf4\xff\x92\x82\x72\x05\xd8\xa6\x2e\x76\x1c\x7f\xe7\xa2\x2f\xf1\x30\x76\x84\x05\xdf\x12\x15\x84\x61\x21\x90\x1d\x7d\x5e\xf1\xe8\x91\x9b\x89\xd4\x78\x18\x06\xf7\xc7\xce\x35\x9b\xed\xf4\x16\x58\x6f\xe7\x54\xec\x54\x81\xe1\x1a\xb3\x85\x43\x18\x32\x08\x77\xe0\xbb\x9d\xc7\xd3\x55\x5a\x1d\xb6\x5d\x80\xcc\xcf\x4f\xa8\x21\x5f\x39\x9b\xa7\x7d\x2f\xf7\xb7\x38\x50\x64\x9f\x63\x4c\x70\xac\x58\xd4\xc7\x1d\x14\xf5\x1c\xe3\x9c\xa5\x60\x53\x66\x17\x2b\xe5\xda\x01\xb9\xf9\x14\x83\x7f\x2e\x98\x44\xff\xff\x63\x79\x26\x8d\xb7\xda\xff\xe9\xdd\x5e\xc8\x7f\x1f\x79\x5e\xe6\x88\x98\x64\xac\xa5\x90\xf2\x91\x07\x7c\xf5\x99\x0d\x75\x7b\xa1\x6e\xb6\x3a\x3e\x36\x54\x8d\x21\xc3\xd1\xd9\x0b\x9e\xcd\xc6\x99\x1c\xd2\x8c\xe4\x5c\xd8\xc7\x0c\xc8\x6b\xa9\x08\xfb\x48\xf3\x22\x63\x58\x4e\x46\xbe\xec\xff\x5b\x0a\x46\x5c\x34\xbc\x47\x3c\x2d\x5c\x92\x84\x91\xe4\x25\x72\x6d\x05\xfc\x1e\x52\x1d\x6a\x06\x58\x70\x5b\x68\xf2\xf2\xe0\xe5\xc1\x8b\x57\xe4\x77\x62\x87\x7e\xe9\xfe\xfd\xc2\xfd\xfb\x25\xf9\x9d\xfc\x4e\x08\x39\x27\xa4\xf6\x2f\x81\x7f\xfb\x84\x8f\xe2\x39\xbc\xb4\xd3\x4c\x64\xee\x5e\x18\x3c\xb9\xa1\xea\x33\xf4\x8f\x31\xd2\x0d\x0d\x45\x3f\x89\xcc\x19\xcc\xe1\xe5\xff\xf1\xf7\x40\xc0\xd5\x60\x8b\x1f\x98\xd4\x1e\x4c\x69\x9f\xdc\x80\x6b\x2a\xa7\xd7\x68\x96\x1d\x26\xa6\xa4\x99\x7d\xf8\xde\x17\xfd\x17\xfb\x44\x8a\xfa\xed\x53\x2e\xa1\x35\xba\x9b\xe1\xde\xcb\xfd\xc1\xc2\x94\xbf\x58\x32\xe5\xb9\x6e\x37\xae\xe6\xce\x0e\x7a\x3b\xd7\x78\x86\x39\x14\xb3\x1b\x3a\x0b\x6c\xe3\xcd\xd2\x31\x9f\x06\x6c\xf4\x08\x87\x02\x62\x76\xc0\x05\xdc\x23\x03\xe1\xa0\x33\xc2\xcd\x80\x9c\x9a\xdd\x5d\xdf\x5b\xc9\x6a\xcc\x1e\xc4\xfd\x38\x86\x0b\x04\xc2\xc3\xa2\xbf\x98\xcb\xe9\x6d\xd1\x58\xbf\x13\xe7\xe8\x83\x50\xd8\xdd\xd3\x2b\xff\x46\x07\x4e\xf5\x30\x96\xdf\xc1\x56\xf4\xcb\x11\xd6\xc9\x62\xa7\xa3\x01\xb4\xb1\x72\xb4\x77\x09\x23\xa8\x3a\xbb\xdd\xc3\x75\xb0\x9e\x38\xe4\xdf\x27\x34\x8b\x83\x75\x89\x04\x80\x36\xc5\x7c\xa3\xa4\x38\xbd\x28\xf8\xa5\xc8\xcf\xd5\x9d\x98\x56\x04\xf1\x57\x1c\xe8\x5b\x4c\x67\xdf\x19\x96\xc9\x35\x33\xfe\xdc\x51\x90\x11\x51\x94\x86\x0c\x69\x46\x85\xd5\x60\x16\xfc\x10\x46\xe2\x60\xf8\x4b\x60\x98\x25\xfc\xf2\xa9\xe3\x23\x0b\xbb\xa3\xbd\xd0\xff\x79\x7e\xc8\x28\x22\xeb\x1c\x85\x29\xa3\x99\x4f\xa5\x00\x7c\xf4\x00\x58\x25\x76\x77\xab\x7d\x05\x6b\x83\xc2\xaf\x72\xb0\x5a\xb9\x50\x93\xfb\x64\xcf\xe7\x3e\x12\xc3\xb2\x0c\xb9\xa7\xea\x4b\x66\x37\x59\xdc\xe8\x8c\xc3\x08\x75\x19\xb0\xf4\x87\xf5\xee\x68\x18\xd4\xb7\x92\x5d\xcc\x42\xb5\x7c\x8f\x10\x68\x0d\x38\xe6\x53\x2b\x94\x56\x12\x1a\x28\x18\x27\x2c\x2b\x88\x62\x69\x99\xe0\xe0\x84\xe8\x6b\x76\x63\x75\xaa\xea\x4d\x5d\x4b\x21\xcf\xb2\x3b\x35\xa2\xee\x20\x46\xb4\xa8\x8b\x44\x3e\x02\x86\xf4\x1d\x37\xd9\x94\xa9\x19\x29\xa4\xd6\xdc\xae\x03\xec\x25\xc8\x86\x03\xbd\x2b\x20\xeb\x40\x26\x16\x4c\xcb\x8b\xe1\x1d\x27\x76\x77\xac\xa0\xd6\xb2\xb6\x3d\x3e\xcd\x51\xf7\xa5\x3d\x66\xee\x3e\xea\xce\xe1\x7f\x8b\x47\xde\xe9\x88\x2c\xe1\xc1\x30\x97\x1a\xf3\x3c\xe4\x14\xfc\x02\x0e\xab\x2f\xf7\xa3\xc3\xf0\xcb\x83\x2f\x0e\x5e\xee\xd9\xb9\x7e\xb1\x6f\x67\x5d\x3b\xe6\x5e\x86\x63\x2e\xfc\xd2\xcd\x88\xe9\xda\x41\x67\x0d\x30\x6c\xa0\x2b\x55\xea\x22\x3c\x3e\x8b\xce\xce\x48\x1b\x17\x6f\xe3\xb9\x97\x2f\x3d\xe0\xbb\x8a\x59\x6f\x24\xec\x1c\x38\x6f\xb9\x21\x9f\xe5\x52\xb1\xcf\xa2\xfb\x6f\x3d\xa0\x9a\x9f\x3b\x6d\xfb\xa9\x65\x5c\x1b\x68\xaa\x76\xcd\x66\x0f\xd6\x74\xdb\xb8\xd7\xdb\x3a\xd7\x17\xdf\x02\x09\x92\xd3\xe2\x01\xe3\xb8\xbe\xed\x6d\x52\x78\xdf\x38\xc7\x6c\x68\x01\x0f\x8e\x47\xd4\x8a\x5c\x5f\x53\xac\x95\x0a\xf9\xb4\x43\x96\x49\xc4\x39\x75\xa9\x03\x0f\x48\xd5\x0f\xb0\xf0\xda\x48\x45\xc7\xec\xc0\x3d\xf6\xa9\xb4\x83\x70\x5d\xe0\x6b\x5e\x26\x2c\x67\x74\x20\xa9\x3e\xa5\xd9\xc7\x1f\x40\x0a\xd0\x04\xb2\x01\x81\x90\x35\x38\x87\x28\xcf\xf0\x89\x84\xb2\x1a\x54\xbf\xb7\x71\x9c\xd2\x1b\x7d\x92\x51\x6d\x78\xf2\x7d\x26\x93\xeb\x4b\x23\x55\x07\xda\xc5\xe1\xcf\x97\x0b\xa3\xd6\xd6\x54\x90\xc3\x9f\x2f\xc9\x31\xd7\xd7\x15\xba\x3e\xa2\x6a\xd6\x13\xf0\x68\x00\xc6\x71\xb5\x18\x24\xa7\xd6\xfe\x63\xde\xc6\x13\x01\xd7\xb7\xbb\xbd\xf2\x27\x7a\xa3\x19\x4e\x7f\x68\xa7\x6f\xbf\x66\xcd\x45\xf0\xda\x80\x14\xf0\x75\x4e\x8f\xd7\x10\xf8\x1a\xe9\xa6\x6d\x47\xc8\x02\x33\xbd\xe6\x19\x73\x1d\xc0\x00\x12\xa8\x8e\xf1\x0c\x5c\x33\x93\x25\xb9\xa1\xe8\xb3\x02\x99\x3a\x20\x57\xbc\x78\x45\x4e\x22\xbc\x56\x2c\x48\xa8\x0f\x65\xf5\x8d\x80\x1f\xe2\xb2\x04\x80\xcb\xd0\x75\x65\x45\xb0\xcb\x8a\x21\x27\xa8\x4c\xe9\x57\x64\x87\x7d\x34\x5f\xed\xf4\xc8\xce\xc7\x91\xb6\xff\x08\x33\x02\x74\x65\xd7\xa3\xc1\x2a\x75\x62\xc4\x54\x65\xc0\xe0\x0f\x16\x4b\x07\xbb\x67\x52\x72\xf5\xee\xf8\xdd\x2b\x50\xe0\x53\x49\x6e\x98\xef\x62\xe6\x0b\x61\x9d\x34\x8c\xc8\x00\x15\x1d\x89\xcc\x0b\x25\x73\x1e\xa5\xab\xc2\x26\x6b\xc2\xf3\xa4\x0b\x7f\x29\x24\xa5\xc1\xf2\x77\xc2\x41\x90\xed\xeb\x87\x9c\x03\x86\xbf\x8d\x7f\x4e\x47\x44\xa2\x53\xaa\x9e\x23\xcf\x75\xb8\xc9\x72\x8c\x1b\x05\xdb\x71\x55\x3c\x62\xd5\x6f\xf7\xd5\x41\xca\xa6\x07\x3a\xa5\x2f\x7b\xf0\x18\x64\x00\x07\x7e\x1f\xe6\x44\x35\xd9\x79\xb9\x33\x20\x97\xbe\xaf\x79\x2f\x9e\x63\x75\x9f\xb5\x06\xfc\x80\xe0\x56\x7d\xb1\x43\xf6\x30\x49\x1d\x74\x8a\x8c\xf9\x92\xe5\x80\xb1\x01\x3e\xfc\xfd\x46\x2a\x24\xe9\xc0\x7d\x41\x5a\xbb\x30\x88\x6b\x19\xf6\x4e\x64\x8d\x43\x7b\x73\x55\x55\x6e\x0d\x76\x0c\x74\xdf\x32\x12\x2a\x08\x98\xeb\x07\x8b\xa2\xe2\xc2\x3d\xb1\x22\x24\x17\x4e\x3b\x79\x6b\x17\x1f\xbb\xc0\xc3\x00\x77\x32\xcb\x0e\x54\x1f\xed\x6c\xcc\x99\x44\x3a\xa8\xe6\x26\xe1\x68\xe9\x66\x3d\xde\x0b\xfe\x5b\xc9\xc8\xe9\x71\xe8\xd9\xc8\x94\xe6\xda\x58\xc9\x95\xd6\x74\x04\x8e\x8a\xc3\xde\x61\x4e\xff\x2d\x05\x39\xf9\xfe\xd2\x4d\x65\x7f\x03\x09\xdc\x50\x00\xd2\x7f\x97\x8a\x59\xd5\xa8\xb5\x1e\x76\xe8\x47\x9a\xd7\xbd\xec\xe7\xe4\x98\x1a\x8a\x2a\x18\x4a\x33\x59\x55\x98\xc2\x4e\x18\x42\xe6\x8f\x2f\x1f\x6e\xa8\x45\x93\xf5\xab\x41\x96\x83\xce\x9a\x63\x4a\xd9\x9f\xbf\xbf\x38\x5d\x83\x12\x95\xc0\x29\x3c\x7e\x2b\xd3\x8e\x34\x29\x80\xf7\x38\xc2\x51\x49\x6e\x87\x25\x67\x52\xb0\x1e\x08\x3b\x62\xa5\x9d\xfb\xcf\x9f\x15\x37\x0f\xad\x98\xac\xae\xd6\xc7\xbf\x5f\xb1\x4e\xde\xda\x1e\xfe\x67\x51\x65\x3c\xc0\x38\x80\x54\x71\x8a\xc0\x30\x93\x43\xe2\xa4\xc1\x3a\xdf\xf8\xfd\xc5\x69\x67\x2f\xfc\xfe\xe2\x74\x73\x5f\xb6\x43\xe3\x60\xde\x36\xa8\xf4\xb7\x0a\x7b\x75\x5e\xe9\x5f\x5d\xe3\x1f\x74\xa5\xeb\xaf\x8b\xd2\xd7\x5c\x34\xce\x0a\xab\x8b\x8e\x13\x5f\x1f\xe9\x22\x35\x50\x92\x9d\xbe\x22\x79\x99\x19\x28\x7f\x03\xc6\xb2\x9c\xa6\xed\xe9\xed\x59\x8c\x38\x28\x08\x42\x8e\x19\x86\x17\xd2\x57\x3e\x21\x21\xfc\x62\xf9\x0f\xde\x52\x41\xc7\xf6\x76\x38\x0f\x49\x8e\x7f\x46\x1c\xbd\x87\x0e\x74\x11\xbe\xa2\x53\xca\x33\x3a\xe4\x19\x37\xd0\xfe\x7f\x7f\xe0\x15\x31\x8d\xb5\xb0\x76\xca\x6b\x13\x6a\x9d\xaa\xb0\x71\x7d\x10\x28\x98\x64\xcf\x8e\x7f\x70\x63\x05\xf7\xfe\xa0\xd2\x5e\x01\x8d\x0c\x12\xe5\x51\xc5\xad\xa9\xb6\x1e\xe5\x61\x4e\xb3\x6d\xc7\xae\x4d\xd5\x4a\x58\xe6\xd7\x0d\x21\xa0\x17\xd5\x1e\x3b\xd2\x52\xb5\x07\xbe\x70\xa0\x13\xcf\x5c\xf3\xc1\x0e\x52\x2d\x74\x1f\xd8\x32\x0d\x7f\xdf\x56\xfb\xd9\xee\x97\xfb\xaf\x6a\x81\x3b\xa1\x52\x0c\x22\x84\x43\xcf\xa5\x49\xe3\x0e\xba\x74\xa2\xda\x83\x0b\x81\x76\x65\xf7\x4d\x93\x22\x0a\xbc\x5a\x4b\xd7\xc0\xa9\x9d\x10\x02\x61\x57\x1a\x6f\x9c\x96\xef\x93\xb0\x62\x32\x6a\x5f\x03\x79\xc4\x8a\xc9\xeb\xcb\x7a\x28\xc5\x7e\x46\x5e\x5f\x2e\x91\x7b\x98\x2b\x63\xdf\x5b\x63\x80\x65\x57\x93\x8c\x8f\x98\xe1\x8d\x88\xb0\x66\xc9\x97\x4b\xc1\x8d\x54\x7a\x1d\x35\x1f\xee\xd1\xdd\xe8\x5d\x17\x9e\x10\xe4\xad\x1b\x17\x13\x3e\x13\x99\x65\x2c\x31\xae\xe7\x21\x2c\xab\x7f\xf0\x32\x47\x88\x4b\x05\xd0\xbe\xc7\xaf\x73\x7a\x1c\x20\xab\x1d\x5c\x9c\x1c\x1e\xbf\x3d\x19\xe4\xe9\x9f\x26\xf2\xa6\x6f\x64\xbf\xd4\xac\xcf\x4d\x3b\x5d\x69\x8d\x45\x21\x1d\x38\xa0\xcd\xa4\x9b\x05\xac\x10\x89\xde\xeb\x0a\x33\xcc\x07\x7e\x95\x94\x66\x11\x35\x6c\x54\x66\x19\xae\xa9\x51\x8c\xf5\x62\x77\xe2\x03\x31\xd5\xaa\x6b\xb3\xf4\xd7\xdd\xe5\x7d\x7d\xbb\x3f\x9a\x37\x65\x33\xb4\x3f\xe5\x9b\xaa\xc6\xe4\x0e\xda\x5f\x86\x91\x7d\x42\x9f\x65\x7c\xbb\x12\xd7\x6c\x46\x20\xbb\x7f\x24\x15\x20\x6d\xd6\xb9\x90\x99\x04\xc8\x75\x00\x2d\x15\x9d\xae\xb0\x21\xa4\x6e\xa3\x45\xc0\x8b\x5c\xb0\xd1\xe3\x10\xfa\x82\x8d\xb0\x80\xc2\xe7\x38\x3b\xeb\x82\x96\x66\x82\x99\x90\x88\x7c\x84\xe4\x5c\x4a\x79\x57\x91\xb1\x21\xa4\x6e\x95\x4b\xdf\x45\xbd\x57\x1b\xe0\x7d\xb2\xb0\x5e\xb1\x9b\xd0\x2d\x92\x79\x70\x5c\x41\x4e\xad\x6d\xc9\x6e\x0e\x6e\xa4\xba\xe6\x62\xdc\xbf\xe1\x66\xd2\x47\x4a\xe9\x03\xc0\x61\x3b\xf8\x13\xfc\xe3\xa2\xb5\x87\x69\xea\x32\xcb\x4a\xcd\x46\x65\x86\x39\x5f\x7a\x40\x68\xc1\x7f\x62\x4a\x43\x0a\xe3\x35\x17\x69\x8f\x94\x3c\xfd\xae\xe9\x8a\x91\x2e\x36\x48\xf3\x2e\x62\x77\x9e\x8b\xca\x8b\x1f\x45\x53\xa9\x11\x85\xd7\x92\xa8\xc6\xfa\x34\xcd\xb9\xd8\x14\xce\x6f\xaa\xda\x73\x91\x36\xa3\x60\x9d\x7a\x47\x30\x4e\x5d\xb7\xc7\xb1\x7d\xcc\x38\x64\xd1\x50\xef\xcb\xc0\x2e\x55\x2e\x9f\xa6\x9e\x4d\xb3\x92\x40\xc9\x67\xfa\xb7\xac\x8f\x4f\xe9\x17\x69\x45\xd7\x6d\x6a\xcc\x43\xae\xc7\x4c\x8d\xe9\xd6\xfd\xfd\x09\x12\x5e\x1e\x95\xc7\xc8\x56\xed\x5d\x03\xad\xdb\x6b\xba\x8f\xa0\x7f\x01\x0e\xbc\xf6\xc5\xc9\xa0\x5e\xa1\xec\xf1\xbe\x2d\xec\xcc\x17\x80\x87\x7d\x99\x51\x22\x85\x70\x98\x74\xef\x0a\x26\x2e\x0d\x4d\xae\x5b\xc6\x45\xb7\x3a\xd3\x1f\x4c\x67\xea\x36\x57\xc6\xa7\x41\xa7\x81\x47\xb1\x8a\xca\xa5\x94\x55\x59\xd2\xb8\xb1\x9f\xa0\xd4\x45\x84\xf5\xb7\xb4\x68\xef\x01\xf5\x23\xcd\x29\x4a\xe1\x63\xe7\xf4\x84\xaa\x9a\x42\x16\x65\x86\x90\x6b\x5c\x3b\x3a\x7e\x7a\xc5\xa6\xed\x06\x77\xfa\x72\x77\x39\x23\x95\x0c\xcd\x65\xca\xc8\x90\x9b\x4a\x3a\x6a\x66\xb0\x76\xd7\x01\xd1\x48\x41\x12\x07\x36\x07\x5a\x87\xd5\x30\xdc\x84\x22\x8d\x44\x10\x99\x18\x5f\xf3\x17\xca\x7c\x5f\xbc\x78\xf1\x02\x8b\x2e\xff\xfa\xd7\xbf\x12\xa9\xa0\xe3\x43\xc2\xf3\xc5\x1b\xe1\xae\x3f\xbf\x7c\x39\x20\x7f\x3f\x7c\xfb\x06\x72\xff\x0b\xa3\x11\x07\x1c\x47\xb6\x37\xd4\x7e\xac\x7b\xe4\xff\x5e\xbe\x3b\xf3\x6a\xa3\x9e\xfb\x16\x4c\xed\xf0\x7a\x75\xf4\xc5\x17\x7f\xf9\xea\xab\x01\x39\xe6\x0a\x6a\x9f\x38\x0b\xad\xb9\x82\xb7\x84\x2a\x86\x45\xa2\x00\x11\xe8\xf5\x2a\x1e\x40\xf4\x1d\x7e\x02\xf6\x1e\xc4\x7a\x46\xcb\x81\x19\x4f\x0c\x96\x59\xa1\x20\x0b\x5d\x85\x01\xb8\xd1\x41\xa1\xba\x64\x5d\x98\x5c\x8f\x64\xfc\x9a\x91\x91\x86\x96\x9c\x55\x31\xbd\x6b\x77\xe3\x4a\x4a\x70\xb0\x6a\xad\x34\x33\x4f\x3c\xf7\xb3\x95\x2f\x78\x1e\xc0\xb8\xd6\x70\x0d\x4a\x3d\xaf\xd9\xac\x8f\x1c\x56\x50\x1e\x0a\x46\x20\x39\xae\xd6\x63\x21\x78\x6d\xd2\x48\xae\x78\x8c\xc5\x42\xc9\x7f\xe1\xe2\x43\x0d\x69\x24\x89\xa1\x12\x15\x5b\xd4\x02\x58\x82\x88\x1a\x76\xf8\x3a\x58\xd7\xd4\xcb\x7f\xec\x90\x42\x17\xe1\x96\x33\xae\xed\x23\xae\xd9\x4c\xdf\xf5\xe4\xaa\x57\x8c\xe5\x4f\x8d\x9c\x52\x8a\x85\x5f\x3b\xe4\x7d\x27\x19\x5d\x93\x05\x87\x78\x53\x8d\x81\xe5\xff\xae\x10\xda\xdd\xeb\xa9\x14\x08\x51\x4b\x57\xd6\xcc\x94\x8e\x34\x90\x77\x6e\x9f\x0d\x0d\x00\xe0\x0d\x73\xaa\xae\x99\xef\xcc\x4b\xb3\x01\x39\xb7\x93\x0c\x90\x23\xa1\x31\x32\xd8\xad\x74\x06\x8f\x75\x4a\x1a\x3c\x64\x77\x30\xd8\xc5\x8d\x27\x15\xd1\x86\x2a\xb7\x8b\xec\xe7\xcf\x03\xc5\xea\x2d\x2d\x34\xa2\xaa\x58\xad\x14\x10\x87\x24\x20\xb5\x9a\x49\xd5\x17\x10\x69\xbd\x45\x9e\x22\x7d\x20\x4c\xe3\x01\x36\x11\x75\xea\xca\xc9\x06\x23\xfd\xf6\xde\x08\x2c\xa4\xbc\x85\x52\x81\x57\x2b\xd5\xc2\xc1\xec\x66\xec\x49\xe9\x12\xcb\xdb\x6a\x38\x49\x19\x69\x6b\x73\xcd\x3c\x9f\xaa\xca\x80\x57\x17\x8a\x03\x5e\xed\xd5\x07\xbc\xda\x04\x74\xf1\x5a\xd8\xa1\xe1\xa4\xc2\xc3\x68\x54\x91\x1e\x40\xcf\x8b\x70\xc4\x1b\x89\x1d\x42\x7c\xa7\x1b\x41\xe8\x50\xcb\xac\x34\xf8\xd3\xea\xcb\xf8\x98\x83\x41\x3d\xf8\x12\x9c\x6d\xe1\xb6\xe8\xd0\x83\xe3\x1e\xcf\x89\x36\xe7\x1f\x5e\xad\xc5\x44\x67\x6d\x90\x9f\xb7\x57\xa1\x35\x9d\xbd\xee\xd4\x4d\xae\x93\x2b\x86\xba\x99\x30\x97\x85\x10\xe9\x75\x56\x78\x5a\x91\x00\x4a\xa3\x57\xd1\xb0\xed\x78\xba\x16\x2f\x61\xa2\x79\x7b\xb7\xc0\xe5\x29\xd9\x0b\xed\x46\x43\x3a\xdb\xa9\x30\x4c\x8d\x68\xc2\xf6\x63\x77\x01\x2b\x26\x2c\x67\x8a\x66\x21\x43\xd9\xd7\x29\x4f\xa8\x48\x33\x57\xbc\xcf\x14\x6c\x5c\xf6\xd1\x30\x25\x68\x06\x8f\x48\x15\x9f\x32\xa5\xc9\xde\xf7\xcc\xda\x12\xd8\xa6\x74\xff\x09\xa6\x91\xe2\x8b\xac\xc3\x99\x01\x0f\xee\x26\x01\x14\x86\x5a\xd6\x29\xb1\x5a\x2a\x8f\x59\x64\x97\x55\xc7\x6e\xa0\x81\xdd\x10\x70\x62\x82\xd0\x85\x8e\x40\x18\x8d\xf4\x0d\xf0\x00\xb8\x38\x31\x38\x30\xd5\xae\x21\x1e\x20\xc2\x38\x79\xee\xa0\x42\xd6\x56\x0a\xf0\x49\x8a\x2e\xee\x2a\x99\x18\x39\x03\x52\x4e\x79\xea\xd5\x20\xc8\x66\xa8\x50\xb7\x0a\xaa\xa3\x4a\x7e\xaa\xb5\x74\xfd\x3e\xa3\x35\x42\x73\x14\x94\xa5\x3a\xa6\xb4\x8f\x14\xc7\xf1\x2e\x09\xc8\xac\x8d\x1a\x5a\x90\x4e\x0e\x44\x99\xb2\xf3\x72\x98\x71\x3d\xb9\xec\x34\xb4\x71\xb6\x64\x60\x4c\x0c\x5c\x48\x2e\xb9\x35\xdc\xa1\x99\xd0\xdc\xf5\x1f\x43\x35\x8b\x5b\x2d\x5b\xc2\x32\xf8\x5f\xc7\xbb\x43\x42\xa1\x38\x74\x35\xf3\x5f\x45\xf3\x70\xc8\x1d\xd8\x4e\x27\x65\xef\x45\x51\xfb\x3c\xa1\x59\xa6\xe7\x1b\x49\xfb\x83\x0c\x35\x53\x8f\xe6\x81\x5c\xc1\x2d\xc3\xf8\xd9\x43\xd6\x0c\x4a\xb1\x80\x6c\xba\xf4\xc5\x34\xc9\x25\x56\xfc\x0b\x22\x85\xbf\x09\xba\x02\xf9\x1f\x04\x0a\x21\xde\x18\x32\xdd\x1a\x31\x25\xb7\x31\x9d\xa7\x17\xd3\xe9\x34\x2a\x7c\x19\x5a\x34\x50\x18\xb8\x0f\x85\x4d\xbe\xd1\x2c\x0d\x85\xff\x95\xe1\x38\xb8\x2f\x7c\xbc\xb6\x08\x2e\xce\xef\xd0\x38\x58\xd0\x6e\xfc\xb6\x3f\xcd\x0d\x0a\xaa\x98\xb5\xbc\x41\x30\xf5\x9d\x6d\x9d\x44\x3b\xc9\x99\xc4\x61\x7b\x2f\x8a\xb3\xea\x4c\x87\xe3\x1c\x3f\xdc\xd5\x24\x95\x49\x69\x6d\xae\x8a\xec\x55\xc2\x44\x3b\xb4\xf7\xe7\x05\x3f\x9b\xca\x1b\x71\x43\x55\x7a\x78\xde\xa8\x6a\xb5\xae\x9c\x55\x63\xc5\xaa\xb7\x7f\x04\xb1\x9f\xd3\xa1\x6f\xf8\x1f\xc0\x9f\xb6\x81\xbb\xf9\x21\xee\xf3\xae\xb9\x36\xe0\xab\xc5\xe9\xc8\x36\xf4\xb7\x0d\xfd\x3d\x9b\xd0\x9f\x1d\xa9\xde\x29\xa5\x26\x5e\x9c\x43\xd6\x52\xfc\x59\xc4\x90\x22\x91\x8a\xa7\xe7\x7c\x3d\xec\x9c\xce\x8f\x9b\xb7\xe2\xba\xc8\x4e\xf0\x32\x17\xd4\xb1\xe7\x10\x6f\xda\x80\x78\x11\xd0\xb2\x85\x31\x88\xd7\x6d\xa5\x62\x88\xd4\x8a\x81\xe7\x28\x82\x5d\xc8\xf4\x15\x02\xa7\x42\xe7\x74\xec\xd9\xd1\x73\xb8\xcd\x3d\xe7\xbb\x10\x51\xaf\x70\x6c\xcd\xec\xd5\x9f\x4e\x62\x02\x2d\x19\x80\x74\xc4\x04\x04\x18\x01\xa8\x73\xde\x86\x1b\x48\x67\x1c\x61\xaf\xca\xd0\x69\x3b\xd2\xbc\x02\x8d\xa3\x7a\x46\xd0\xc9\x84\xe5\xd8\x3f\xfc\xb5\x27\x81\x95\x8d\xd6\x78\x30\x0c\x11\xd2\x98\xca\x35\x91\xa3\x5e\x0d\x42\x61\x67\xfa\x72\xa7\x5d\x8c\x81\x74\x17\x8e\x24\x7e\x1f\x9d\xb7\x8e\xed\x90\x79\x82\x9d\xd7\x42\x3a\x76\x0f\x81\xce\x93\x61\xeb\xe2\xb9\x2c\x0b\x38\x3f\x90\xc2\x1b\x43\x9c\x4d\x89\xd5\xf6\x42\xd4\xe0\x09\x28\x7f\xdb\x58\xed\x73\x8c\xd5\x46\x07\xa3\x17\x74\x8e\xb0\x71\xfc\x36\x0e\x09\xf8\x20\xee\x90\x79\xa3\xc6\xd9\x30\x3e\x82\xeb\xc3\xb7\x52\xd5\x53\x93\x76\x07\x83\xdd\x5d\x1f\xd4\x75\x7c\x5f\x9a\x51\xff\x6b\xc2\x44\x22\x53\x64\x16\x3b\xbe\xd2\x06\xd4\xbd\xca\xcb\x16\xcf\x25\xf7\xcf\x8a\xd3\x9b\x60\xec\x2e\x96\xba\xb5\x6c\xf1\x68\x7c\xaf\x1f\x41\x89\xa9\x54\x97\x80\xf9\xe7\x48\x14\x30\x9d\x9d\x0e\xe3\xbf\xd7\x24\xe3\x39\x77\xfd\xc3\xec\x46\x67\xda\x68\xb2\x87\x1f\x0e\x92\xa2\xec\xb9\x1b\x06\x39\xcb\xa5\x9a\xf5\xc2\x4d\xf6\xcb\xda\xaf\xdc\x1d\xfb\xd8\x87\xa2\x54\x8a\x09\x93\xcd\x9e\xb3\x06\xe4\x89\xb8\x21\x0a\x50\x58\xe3\x36\x48\x1e\xd5\x35\x57\x33\x17\x22\xbe\xe0\x2d\x8f\x30\xf6\x03\x58\xab\xee\x85\x90\x04\x7c\xca\xc4\x94\x4c\xa9\x7a\x20\x7a\xfa\xb2\xab\x43\x9d\x27\xe5\x53\xae\xdb\x36\xf7\x23\xb7\x3b\xa1\xa1\x75\x57\x69\x8a\xd2\x38\x89\xee\x77\xa0\x47\xda\x0e\x3b\x6f\x4e\x39\x7c\xb9\xd3\x7a\x4a\x05\x35\x86\x29\xf1\x8a\xfc\xf7\xde\x87\xcf\x7f\xef\xef\x7f\xb7\xb7\xf7\xcb\x8b\xfe\x7f\xfe\xfa\xf9\xde\x87\x01\xfc\xc7\x67\xfb\xdf\xed\xff\xee\xff\xf8\x7c\x7f\x7f\x6f\xef\x97\x1f\xdf\xfe\x70\x75\x7e\xf2\x2b\xdf\xff\xfd\x17\x51\xe6\xd7\xf8\xd7\xef\x7b\xbf\xb0\x93\x5f\x57\x1c\x64\x7f\xff\xbb\xff\x68\x3d\x75\x2a\x66\xef\x5a\x8a\x42\xbc\xfa\x1d\x1e\xc9\xf5\x11\x3b\x61\xbf\xb9\xd6\x0a\x5c\x98\xbe\x54\x7d\x1c\xfa\x15\x31\xaa\x6c\x27\x4c\xaa\xe3\xa5\xeb\xfd\x5f\xa9\x01\x15\xe4\xbc\x57\xea\xd7\xbc\xc1\x21\xe2\x79\xcc\x3b\x28\x0c\x3e\x71\x23\xd5\x2b\x5e\x0c\xcb\x0b\xa9\xa8\x9a\x91\xd4\x79\x33\x67\x4b\x00\x7f\x22\xc4\x9f\xd6\x68\xba\xf0\x46\x29\x57\x6b\xa8\x0d\x6e\x0d\xe0\xc3\x52\x5e\xe6\xdd\x38\xe1\x7f\x06\xe4\x79\x87\x5a\xef\x13\x88\xf0\x01\x3e\x7c\x31\xa4\xc9\x35\xda\x4b\x61\x6d\x50\x4b\x8c\x41\xa4\x77\x5c\xde\x43\xce\xa8\x08\x6e\x7c\xc8\x64\x91\x29\xb3\x0b\xe7\x6f\xc6\xb1\x6b\x2e\x77\x0c\xa7\xbb\x2c\xc1\xaa\x0d\x93\x54\xe4\x2d\xa8\x3b\x6b\x5d\x6b\xd2\x09\x6c\x07\xff\x37\x7b\x63\x75\xbc\x8e\xe0\xe2\x25\x18\x93\x0e\x23\x6b\x04\x8d\xa4\xaa\xf4\xaf\x9a\xda\x00\xeb\x16\xf6\x9c\x0f\xce\xda\xd5\xb3\x73\x42\xc5\x13\xbc\xce\x99\xc6\x5c\x14\x9e\x40\xa3\x23\x30\x3c\x81\xfa\x61\xc5\xae\xa2\x86\x88\xa5\xb6\x4f\x92\xa2\x7e\x4f\xf5\x20\xec\x03\x35\x44\x16\x70\xed\x0d\xe7\xcc\x65\xfb\xcd\xa5\xa7\x4b\xe4\xac\x80\x72\x62\x6f\x5b\xea\x12\x2c\x10\xf7\x14\xa7\x47\xcb\x11\x64\x4b\x44\x0d\x69\x7c\xcf\x95\x05\xbe\x14\x3c\xab\x33\xa6\x6f\xb4\x10\x5e\xbc\x14\x2e\x5b\x70\x81\xcb\x96\x33\x59\xa9\x99\xea\x8f\x4b\x9e\x76\xc7\x5e\x4f\x4e\xa7\x68\xa9\x49\x74\xa5\x3f\x74\xa2\x35\x74\xae\x2b\x84\x7c\xcc\xd6\x67\xe5\xce\x49\x48\xed\xac\x1d\x96\x71\x63\x88\x7a\x9a\x27\x0d\x0d\xbf\xbc\x30\xf0\xb9\x04\x57\xc1\x4f\xe4\x0e\xd1\x64\x96\x38\x50\x25\x5e\xeb\x4d\x83\xc3\xe2\x9e\x80\x8a\xa8\xbe\xfd\x3f\xef\x4f\xf2\x21\xd4\x21\x1b\x61\x16\x13\xfe\x06\xdc\x00\xae\x8e\x2b\x65\x19\x33\x50\x96\xc5\x44\xd5\xf1\x4e\x13\xc5\x72\x39\xb5\xdb\xec\x83\x20\xef\xb5\x0b\x86\xf3\xd1\x2b\x42\xf7\x6b\x85\xc1\xae\xcd\xae\x60\x2c\xc5\xe2\xae\xa8\x71\x9e\x2a\x85\xee\x91\xe1\xbe\x4f\x56\xd5\xd8\xdb\x51\x81\xc7\xcc\xb5\xaf\x02\x27\x95\x62\x96\x00\x00\x0f\xa5\x64\x4e\xb4\xa0\x85\x9e\x48\x03\xfe\x10\x5a\xd0\x84\x9b\x99\x25\xb7\x51\x34\xb9\x86\x16\xd1\x8a\xb9\x27\xf6\x48\xb2\xef\xb2\xd6\x63\x0a\xd6\x4b\xce\xcc\x44\xc9\x72\x3c\x81\x1a\x28\xbc\x2b\xc9\xa8\xf6\x04\x58\xfa\x7b\x67\xa3\x6b\x92\xce\x04\xcd\x79\x12\x5a\x67\x28\x39\xe5\x9a\x4b\x17\xc9\xc2\x71\xed\x1e\x23\xe7\xa1\xc7\x00\x06\xc8\x8e\x32\xca\x73\xb2\xa7\x19\x23\x81\x31\xf0\x9b\x4b\x54\x16\xd1\x59\xa8\x98\xfd\x79\x1c\x3d\x73\x28\x8a\x0e\x2a\xc0\x7e\x52\xc9\xe0\x90\x90\x80\x4a\x00\x6c\xee\x74\xf9\xa3\xf7\xc3\xd2\x2d\x9f\x99\x54\x90\xd0\xe6\xbb\xdf\x30\x91\xca\x28\xf5\xe5\xf0\xfc\x54\xc7\x86\xac\xeb\x19\x88\x23\xc1\x17\x99\x14\xe3\x18\x64\xae\xe2\x52\x2b\xf0\x05\xf4\x7f\x9c\xf2\xb4\xa4\x19\x8a\x7a\x37\x99\xa3\xcb\x53\xfc\x39\x1f\x4f\x4c\xff\x86\x81\x9b\x13\x4f\xc4\x2a\x35\xda\x3f\x94\x2f\xa4\xd4\x72\x0d\x47\x83\x71\xee\x34\x74\x19\x43\x87\x45\x3a\x03\x84\x5a\x97\xbc\x59\xcb\xba\xf1\x48\xed\x38\x44\xa0\x7b\x44\x74\x98\xde\x61\xe8\x06\x68\xb5\x21\xf0\x03\x5b\x2a\x03\xd7\x2e\xce\x0d\x5a\x1b\x56\x7d\x25\xc2\xc7\x26\xea\x2e\x0a\x9a\xef\x07\x81\x1e\x5d\x08\x16\x0f\xa3\xdc\xed\xaa\x6b\xa3\x43\x9a\x86\xa2\x4e\xb7\x0d\x7f\x60\x82\x29\x9e\xcc\xb1\x4e\xf8\xe9\x98\x1a\xd8\x7c\x4c\xd8\x9f\xa5\x83\x26\xa6\xf2\x9a\xf5\xe2\x69\xc5\x8c\x57\x2c\x2f\x32\x6a\xba\xc9\x54\xd9\xf9\x39\xf2\xa6\x47\xb1\x68\xbb\xfb\xa9\x48\xfb\x34\xb3\x7c\x7f\xfe\xd3\x91\xab\x87\xc3\xfd\x5c\xcb\x86\xbb\xaa\x3a\x7f\xa2\x3a\x82\x7a\xd9\xd2\x6d\x0c\x20\x6a\x43\x96\x82\xf8\x73\x4f\x06\x97\xc7\x8d\xc0\x56\xb0\xf6\x8f\xf3\x9f\x8e\x7a\x84\x0f\xd8\xc0\xff\x15\x6e\xf5\xf2\xd7\xc8\x31\xd6\x4b\x84\x3a\x1c\xd8\x35\x30\x95\xd8\x97\x1c\xff\xf6\x9f\xdf\xd8\x49\xda\x6f\xbf\xed\x7f\x13\x75\x0e\xfa\xf6\x9f\x96\x8f\x94\xbd\xa1\xfe\x69\x9c\xae\x0e\x92\xd6\xfe\xf5\xcf\x73\x99\x5e\x16\x2c\x19\xe0\x6b\xe9\x7f\xba\x3e\xea\x4c\x18\xab\xcc\x9f\x4b\x48\x54\xe3\x29\xee\x25\x78\xb6\x62\xff\xf2\xf1\x06\xd7\x80\xd4\x49\xac\x84\x1a\x26\xe0\xc8\xf1\x75\xc9\x42\x1a\xfc\x39\xb6\x2e\x85\xf9\xef\x8d\xe2\x6e\xa2\x46\x4a\x10\x26\x28\xb0\x0e\x05\x61\x1f\xb9\x06\x14\x1a\x7c\x57\x20\x07\x75\xb9\xf0\xfe\x14\xb5\xc3\x5a\x0a\x07\xd4\x21\x68\x67\x6a\xe7\xf6\x99\x90\xe6\xb3\xb0\xfc\x3e\xcf\x11\x8e\x4a\x49\xe8\x54\x02\xd2\x05\x1c\x22\x82\x94\x02\x1c\xe5\x55\x37\xc0\xe1\x8c\xe4\x5c\x1b\x7a\xcd\x06\xe4\xd2\x9e\x92\x71\xc2\x02\x52\x4f\x10\xe8\xe7\xc2\x52\x52\x0a\xc3\x33\xf8\xb6\x1a\xc7\x4e\x39\x3e\x3d\x4f\x47\x44\x97\x09\xb4\xbc\x55\xac\xef\xcf\x63\x77\xd7\x82\x24\xab\xde\xa5\x17\x16\x7b\x42\xd1\x40\x2b\x52\xf8\x29\x36\xd0\x15\x8e\xbd\x16\xb2\xb3\xed\x3c\xa5\x48\xaa\x33\x18\x88\x09\x5d\x94\xed\xb1\x9b\xf9\x7c\x22\xb4\x15\x5d\xfc\x41\xb0\x84\x69\x4d\xd5\x0c\x1b\x8c\xf2\xd0\x07\xd1\x25\xce\x82\x50\xca\xa9\x28\x61\x00\xc5\xb0\x5b\x6d\x99\x00\x75\x28\x19\x2a\x79\xcd\x44\xa8\x48\x08\x02\x2f\xa4\x65\x57\x49\xa8\x90\x0e\x20\x49\x32\xa1\x62\xcc\xaa\xa2\xf3\x9c\xa6\x40\xfb\x1f\x83\x6e\xe7\xdf\xc7\x52\x80\x8e\xac\x8a\xc4\x0d\x90\x62\x68\x0f\xc2\x10\x45\xf9\x20\x88\x77\xc3\xf4\xaa\x30\x87\x7d\x25\x9e\x35\x92\x89\xa4\x1b\xbf\x7a\x7b\x8f\x7a\x1f\xf4\x97\x35\xa6\x80\xe7\xcc\xd0\x94\x1a\xda\x59\x1a\xf8\x5b\x1a\x1a\x69\xba\x1c\x11\x60\x87\x28\x77\xc4\x9d\xe4\x5e\x79\x95\x05\x8f\x61\x08\x40\x1a\x4c\xfc\xea\x63\x0f\x7a\xcb\xd7\x2e\x86\x89\xd9\xdd\xa0\x1a\xba\xf6\xea\x30\xbc\x1f\x0d\x45\x16\x4b\x49\x5a\x82\xa2\x59\x89\xb4\x36\x31\xf6\x4e\x42\x30\x76\xa1\x3b\xa3\xf2\x55\x95\x4a\x90\xd4\x53\xbd\x97\xaa\x81\x78\xd6\x31\x61\x38\xb6\x4a\xf7\xb8\x11\x8e\xf8\xa5\xc0\xad\x3a\xb7\x0c\xb0\x4e\x63\x66\x74\x95\xa4\x89\xa7\x89\x15\x91\xee\x2c\x77\x6e\x0b\x38\x6a\xdc\xd2\x38\xcb\x7f\xb9\x3e\x8a\x0b\xa7\xa5\x3b\x2d\xec\xf9\xb5\xf6\x95\xe9\x2e\x16\x85\x1d\x65\xdf\xca\xb4\x7d\x50\x6b\xae\x35\x6a\x35\x70\x55\xb3\x82\xf5\x4b\x1a\xdc\x4a\xf8\x64\x08\xf1\xeb\x1a\xaa\x06\x1e\x01\x13\x3a\x6d\xee\x9d\xad\xf4\xdf\x7e\x68\x7b\x06\x8f\xeb\xc3\xe3\xfa\x2f\xdb\xfa\xc1\xdb\x27\x41\xfa\xab\x65\x32\x64\x7d\x42\x1d\x04\x3e\xac\x68\xbd\xec\x24\x2e\x31\xdf\x9b\x32\x9c\xbc\x2e\xc5\x23\xa4\xd5\xb8\xc2\x5c\xc6\xad\xbc\x7c\x45\x3e\xab\xe9\x5a\x4e\xa7\x0d\x96\x37\x56\x41\xed\x79\x53\x7c\xe0\x96\xdc\x43\x7c\xd5\x6f\xdf\x9f\x1b\x0c\x94\xbc\xe5\x56\xa9\xaf\xb6\x0a\x8a\xb7\x55\x92\xa1\xa7\x7d\x28\x76\xb5\x6c\xac\x64\x96\xf9\x46\xe8\x68\x8a\xcf\x25\x49\x41\xdf\x1e\x0c\xbb\xf4\x82\xcb\x23\x68\xfa\x82\xdd\x04\x95\x8e\x6a\x44\x2a\xf5\x41\x7f\x70\xcb\xf8\xcc\xb5\x65\xe3\x85\x8a\xb0\x43\x31\xc3\xa9\x1f\x87\xc5\xba\xcd\x00\xeb\xf9\x14\x25\x4b\x78\x98\x0b\xcd\x6e\xe8\x4c\xc3\xfe\xaa\x2c\xc2\xf0\x7c\x87\xdb\x5e\x0d\x7c\xc1\x46\x2d\x9a\xb3\xc7\x57\x67\x69\x01\xdd\x25\x06\x00\x2a\x0b\x17\xcd\xb3\x7d\xab\x61\x1a\xf4\xb3\x9e\xbf\xba\xcb\x2f\x80\x14\x4b\xc8\xaf\xea\x22\x50\x5b\x6f\x3a\x74\x7e\x0a\x03\x7b\x9b\x6d\x0c\x7f\xf8\xb3\x3c\x44\x1c\x87\xcc\xee\xb7\x0a\x4b\x0a\x78\x37\xfe\xed\x92\x04\xb4\x8a\xe9\x7f\x84\xc6\x44\x2e\xb4\xe3\x0b\x8b\xed\x51\x70\x78\x7e\x8a\x4f\x1c\x40\xeb\x59\x2a\x66\x4e\xcb\x32\x13\xae\xd2\x7e\x41\x95\x99\xa1\x73\xa4\x57\x7b\x5a\x28\xaa\xec\x80\x1c\x9d\xc6\x98\xdb\x74\x2e\x8b\xaf\xda\x1a\x01\xf9\xdc\xfa\xf8\xa0\xdc\xad\x2b\xb3\x69\x14\x69\x5b\xe2\xe9\xaf\x7a\x1d\x71\x84\x46\xe6\xbd\x16\x4f\x82\x22\x69\x2c\x88\xbb\x3d\x91\xe7\x32\x61\xf0\x60\x05\x7d\xd9\xf9\x96\x64\x5c\x72\x16\xf4\x33\x30\xf4\xed\xb4\x7a\x84\x8f\xec\x91\x26\x45\xdf\xd5\xb7\x07\xd7\xbb\xd3\xf1\x7c\xca\x28\x1a\xed\x76\xb3\xa2\x43\x35\x7e\x56\x3c\x40\xd8\xdd\x64\x4f\x48\x81\x3b\x1e\xef\xdd\xc7\x8c\xd9\x5b\x3c\xc6\x70\xcb\x80\xfc\x3c\x61\x22\x3e\xee\x62\x5f\x7b\x2f\x1c\xbb\x5c\xa4\x76\xb9\xe1\x2c\x04\xdb\x5f\x97\x49\xc2\x58\xf0\x16\xc5\xbd\xd7\x2b\x89\xe4\xa6\x9c\x53\x93\x4c\x98\x26\x5a\x02\xf8\xa8\x36\x34\xcb\x2a\x2f\x8d\x23\x97\x04\xcd\xc1\x3b\xe8\x23\x85\xa2\x56\x16\xee\x1c\x56\x45\x46\x9d\x57\x64\x54\x8a\x04\x73\xb2\xb8\x99\xf9\x19\xc4\x27\x3c\xfc\x0c\x4c\x53\x8d\xce\x1b\x3e\x42\x6f\x70\x64\x62\x06\x62\x82\x48\x9d\xa1\x10\xad\x9f\xf5\x0e\x76\xcf\xca\xcf\x21\x4d\xae\x6f\xa8\x4a\x35\x54\xbc\x53\xc3\xb1\xa9\x60\xaf\x36\xec\x5e\x34\x07\xfb\xf4\x9a\x6e\xb0\x1f\x0c\x59\x68\x28\x2d\xe7\x1e\x43\x68\x69\x64\x4e\x0d\x4f\xc0\x45\xc3\x47\x91\x6f\x3f\x0f\x7d\x1e\x42\x9c\x16\x65\x39\x9c\x0e\xee\x35\xc0\x5a\x53\x58\xa1\x61\x6e\x24\xe1\xb9\xd5\xb9\x28\x34\x4c\x1e\x85\xfa\x76\x1f\x88\xb8\x6b\xa6\x56\xb1\xfc\x19\xc2\x40\xd1\x5d\xe8\xfc\xb1\x66\xb9\x86\xe1\x43\x9c\x21\x38\xd8\x5d\x21\x77\x6f\x4e\x25\x22\xfe\x57\x96\xab\xed\x6c\x23\x66\xed\xd9\x05\xba\x61\x56\xd7\xd2\x77\xb2\xac\x1e\x2c\x9b\x13\x1f\x0b\xac\xfa\xe5\xda\x3b\x0c\x5c\x1a\xf7\x5e\xaa\x64\x51\x38\xd7\x5f\xbe\xbf\x38\x27\x88\xee\xa9\x29\xd3\x10\xd9\xf6\xa9\xe1\x96\x14\x63\x26\x98\xa2\x06\xe2\x03\x0e\xad\x10\x76\xef\xfc\x43\x20\x6b\x98\x44\x60\xe6\x7b\x87\x59\x31\xa1\xfb\xe4\xbd\x6b\x9a\x1f\xf8\x37\xe4\x9a\xaf\xa4\x91\xa2\x33\xd1\x47\x05\xb6\xaa\xe4\x5d\xc3\x6c\x55\xc9\xad\x2a\xd9\xe0\xda\xaa\x92\xf3\xd7\x56\x95\x8c\xaf\x90\xce\xdc\xad\x1a\x79\x11\xea\x13\xa2\xec\x92\x38\x5f\xab\x2a\x60\x78\x7c\x2f\x5f\x78\xd6\x06\x9d\x30\x5d\xca\x62\x4c\x5d\xeb\x9c\xa7\x77\xdf\x60\x4a\x1c\x7e\x38\x74\x4b\xe5\xb3\xf4\xaa\x0c\x41\xab\x25\x96\x86\x45\x4b\xea\x94\x87\x07\xaf\x61\x0d\xf5\xe5\x00\x3b\x5b\xf7\xc3\xb0\xfd\x2a\x29\xaf\x71\x23\xc0\xf8\xea\x70\x35\x49\xe7\xf0\x24\xf1\xf5\xe4\x72\xf8\xea\x57\x67\xb5\x01\xe4\x51\xea\x03\x48\xf7\x35\x02\xe4\xf1\xeb\x04\x48\xa8\xdb\xea\x7e\xdf\x5f\xf8\x3a\xb2\xb9\x9d\xef\x44\xf7\x5d\x3b\xbf\x86\x53\x16\xc6\xe1\x9a\xc8\x9c\x1b\xc3\x7c\x5e\x45\xd8\xc9\xe0\x0d\x8f\xeb\x68\x9c\xcc\x01\xb3\x1b\x93\x27\xd8\xc7\xd0\x69\x29\xd2\xe7\x40\x2b\xbb\xe1\x1a\x8c\x08\x2a\xac\x09\x88\x70\xb1\x20\x3b\xfa\x2e\xef\xd6\x9b\xb5\x5b\x39\xd4\x7e\xdc\xad\x1c\x8a\xaf\xad\x1c\x22\xd0\xb2\x2a\x83\xa2\x8d\x4e\x95\xc7\x43\x4c\xb8\x20\xbf\x95\x4c\xcd\x88\x9c\xb2\x28\xaf\x13\x9a\x52\x69\x9e\xba\xcc\x48\xe7\xb7\x6b\x6b\x75\x6d\xa8\x5e\x07\x7e\xc5\x93\x8f\x56\x7f\x06\x6c\x81\xce\x25\xfd\xfc\x03\xea\x10\x41\xb8\x0a\x7e\x89\xbd\x68\xb7\x32\x56\x0f\x1c\x06\x78\xf5\x09\xf8\xe2\x0e\xcf\x8e\xbb\x34\x81\xbb\x88\xa4\x93\xee\xa2\xe9\xe4\x36\x46\x5d\x46\x22\x24\x65\xf8\x06\x0e\xb3\x90\xf1\x10\x7c\x70\xe4\x9a\xcd\x7a\x2e\xb1\xc8\x75\x21\xf4\x37\x63\x8e\x5e\xbd\x55\x4a\x3b\x08\xbe\xfa\xd5\xf1\xa9\xd3\xa5\xcf\x0c\xaf\xb6\xad\x31\xea\x63\x79\xe2\x76\x73\x10\x76\x7c\xb0\x76\xd0\x42\x23\xbe\x6a\x4c\xea\x5a\xda\x40\xd2\x3b\x70\x2b\x80\xf2\xfb\x52\xa5\xc0\xa0\x50\x9e\x05\x12\xb6\x1b\xf6\x22\x5d\xbb\x6d\xf0\xf2\xcb\xf8\x48\xc4\x0a\x5b\xb0\x56\x13\x73\xcd\x66\xbb\xda\xa1\x54\x48\xa1\x27\xbc\xf0\xbd\x14\x41\x4e\xba\x5d\x49\x7e\x82\x54\x30\x3f\x04\x4a\xc4\x53\xd1\x23\x67\xd2\xd8\x7f\x4e\x20\xb7\x15\x43\x10\x92\xe9\x33\x69\xe0\x93\x8d\x26\x37\xbe\xda\x23\x11\xdb\xc5\x2f\x38\x44\x1f\x30\x8b\x1b\xea\x44\x7d\xc6\x23\x10\xd5\x25\xb7\x84\x85\xe1\x9a\x9c\x0a\x22\x95\xa7\xaa\xf1\x2d\xa3\xb4\x1b\xc2\x7b\x75\xa3\x60\xd1\x92\x31\xdc\x62\x48\x55\x5b\x8b\x3b\x86\x0b\x71\x27\xee\xbf\x01\xaf\x2f\x04\xea\x42\x9a\x26\xb4\x2d\xa2\x86\x8d\x79\x42\x72\xa6\xc6\x80\x68\x92\x4c\xba\x5e\xe2\xae\xce\x45\xbc\x3a\x3c\x1d\xf1\xea\x94\x0f\x41\x45\x79\x03\x09\xb8\x8f\xa3\xfe\xe0\xd8\x78\x5c\xe7\xb4\xb0\x2c\xf8\x3f\xf6\x54\x06\x2e\xf8\x5f\x68\x8b\xa6\x07\xe4\x90\x68\x2e\xc6\x19\xab\x7d\xe7\x02\x07\xf1\x30\x76\x04\x6b\xb3\xfe\x56\xf2\x29\xcd\x18\x26\xcc\x53\x11\x7a\x99\xc8\xd1\x82\xd2\xd5\x73\xbd\xd1\xac\x5c\x0e\x21\xea\x9d\x6b\x36\xdb\xe9\x2d\xb0\xed\xce\xa9\xd8\xa9\xc0\x91\x6a\x8c\x1a\x94\x0b\x88\x5e\xee\xc0\x77\x3b\x9f\x46\x4f\x7b\x02\xa6\x6b\x67\x3c\xe9\xdc\xcc\x47\x19\xd5\xba\x0b\x9c\x96\xdb\xb1\xc7\x2f\xa3\x27\x55\x75\xd7\xae\xe8\x22\xc1\x74\xe8\xee\x7c\xe4\x50\x63\xd8\x55\x0a\x6c\x07\x74\x9e\xba\x86\xce\x6d\x81\xdc\xe6\xcf\x9c\x30\x6c\x28\x43\xbd\x89\x51\x0a\xaa\x6c\x95\x5b\x28\xfe\x13\xc4\xc3\xe5\x28\xee\x03\xc1\x35\xb8\x9f\xb8\x2f\x4c\x15\xd2\x10\x2e\x92\xac\x4c\xb1\x03\x06\xfc\x14\x9c\x57\xdd\x18\xaa\x9d\x91\xb7\x73\x06\xfe\x29\x0c\xeb\x75\x4e\x9f\x59\xb3\x50\xfb\x33\x9f\x02\x01\x69\x27\x21\x9b\x00\xa9\xbd\x4e\x6a\x8d\x1a\x55\x39\xd4\x5b\x85\x1c\xd5\xf5\xc8\xd7\x7c\xa8\x18\x39\x9a\x50\x21\x58\x16\xe1\xb0\x38\x47\x27\x35\x86\x26\x13\x4c\x7f\xa6\xc4\xee\xe3\x8c\x99\x5d\x8d\x2d\xea\x73\x9a\x4c\xb8\x08\xe0\x05\x22\xe0\x11\x55\xa5\x54\x6b\x68\xae\xd3\xd6\x10\xea\xb0\x2f\xcb\xee\xed\x8d\x59\x2a\x50\xef\xd1\xdc\x3d\x15\xba\xbd\xdb\xe5\x40\x6b\x3c\x71\xa1\x4b\x08\xdc\x7b\x77\x6b\x97\x3c\xb8\xa7\xb9\x18\x31\xa5\x70\x4d\x86\xcc\xfd\x80\xf0\x5a\xdf\xd5\x81\xeb\xf7\x30\x91\x37\x24\x95\xe4\x06\x3a\x90\x4e\xad\x6a\x00\xf9\x37\xda\x2b\x15\xd1\x4c\x21\x23\x2e\x91\x79\xa1\x64\xce\xb5\xaf\xf1\x73\x0c\xb1\x36\xd8\x91\xac\x6c\x8c\xd3\x7a\x1b\xb8\xe6\xeb\x23\x62\xa8\x1a\x33\x63\x07\x27\xa2\xcc\x87\xac\x25\xac\xca\xba\x21\xbc\x3b\xed\x94\x11\x51\xea\x9e\x06\x18\xe4\xc2\x3d\x17\x01\x4f\x20\x19\x6f\x24\x95\x4b\x29\x0c\x5f\x3a\x9c\x76\xcb\x72\x3f\xb9\x73\xb1\x14\x46\xb7\x84\x4d\x6f\xd3\x40\x03\x97\xff\xe7\x9f\xcf\xba\xc1\x3d\x5f\xca\x5b\x37\x52\x65\xe9\x0d\x4f\x31\x51\x43\x93\x3d\xfb\xb8\xfd\x76\xef\xbc\x46\xe0\xf3\xd6\x1b\xf9\xe6\x86\xa7\x8f\x41\x6e\x9f\x19\x6c\xc9\x4d\x80\xde\xae\x57\x3f\x87\xbe\x70\xf0\xd8\x7d\x72\xc2\xb1\x8e\xdc\xfe\x85\x88\xa2\xf9\x90\x8b\x0a\x09\x21\x30\x04\x9c\x7c\x56\x2e\x78\x8b\x5c\x33\x83\x15\xc0\x50\x44\x2b\xcd\x84\x68\x9e\x97\x99\xa1\x82\xc9\x52\x67\xb3\x96\x6c\xfc\x54\x97\x74\x94\xb1\x8f\xb8\x9b\xdb\xeb\x2f\x61\xa8\xba\x1e\x33\x46\xb4\x07\xbf\xc2\x0b\x8a\x4c\x95\xdc\x9c\x1e\x04\xa5\x26\x94\xb1\xb3\x8f\x2c\x71\x75\x4e\x45\x56\x8e\x79\xa3\x92\xd6\x6d\x53\xc0\x46\xbf\x5e\xad\x29\x60\xd5\xf2\xac\xd4\xac\x42\xfa\x6a\xd7\x74\xfb\x69\xf4\xf0\x7b\x54\x55\xf1\x6a\x79\xa3\xbe\x94\x15\x4c\xa4\x80\x1c\x1e\xed\x38\x9c\xee\xda\xa8\xed\x10\xbb\xbb\x3e\x17\x4e\x3e\x1a\x45\xad\x90\xcf\x01\x4e\xc6\xc1\x82\xf3\x11\xa1\xa2\xad\xc0\x7e\x2e\xbd\xa5\xc8\x56\x6f\x7c\xf0\xa5\x3b\xed\x2f\x19\x11\xac\xd6\x5f\xb2\xe3\xee\x92\x78\xfa\xb9\x8d\xae\xeb\x65\x51\x4b\xba\x40\xba\xa7\xc4\xf5\x4b\x6d\xbb\x41\xea\x25\x4d\xe2\xe6\x66\xb5\xc6\x3d\xb9\x6d\x0d\xf9\xb4\x5a\x43\x8e\x00\x69\xa8\x3d\x8c\xef\x6b\x1c\x67\xce\x77\xe6\x3e\x74\x3a\xe7\x2a\xbe\x32\xb7\xa3\xa2\xe3\x15\x7a\xbe\xb8\x81\x5c\xdd\x3e\xd1\x76\x35\xaa\x24\xfd\x52\x88\x66\x42\x7b\xdd\x1d\xf4\xa8\xa1\x9a\x99\x36\x1e\xdd\xc5\x82\x06\xaf\x0f\xe2\xd8\xd8\x78\x12\x0a\x0d\x3d\xdc\x0e\xe9\x7f\xeb\x34\x47\x51\xbb\xd3\xea\x8c\x9e\xd0\x1e\xe9\x97\x85\xd4\x2d\x1c\x23\xb5\xcb\x9b\x50\xd3\xb2\x97\x7a\x8b\x53\xd6\xcd\xf6\xfd\xfb\xd3\xe3\x4e\x68\x66\x07\x9a\xa3\xd9\x20\xa0\xe9\x95\x82\xff\x56\xc6\x36\x30\x20\x0f\x06\x2a\xb9\xfb\xd7\x41\x8a\x71\xc2\x2a\x67\xfc\x31\xd7\xd7\xed\x81\xb8\x7f\x38\x3a\xa9\x0f\x59\xdf\xcc\x3f\x1c\x9d\x10\xf7\xe9\x4a\x3e\xf0\x87\x38\xc1\xdb\xe2\x39\x8f\x13\x56\x85\xc7\x52\xae\xaf\xd7\x00\xe2\xdd\xd6\x3c\x2d\xd2\xb3\x66\xd5\x82\x9b\xec\xcf\xf7\xd8\x9f\x11\x40\xed\x4c\x96\xe4\xc6\xa1\xd2\x39\x03\xee\x8a\x17\xaf\xc8\x89\xd0\xa5\x62\x55\x96\xd3\xbc\x2d\x67\x75\xa8\x95\xcd\x39\x00\xfe\xd3\xaf\x3a\xf3\xff\x77\xcd\x9f\xcf\x25\xa0\x50\x50\x65\xc0\x06\xeb\x08\xc7\x1c\xda\x94\xba\x21\x3d\x11\xee\x61\x9e\xd3\x91\xaf\x53\xe8\x39\x54\xaa\x00\xf6\xed\x6f\xb2\xec\x12\xc1\x54\xc6\x0c\xf2\x3a\x00\xd0\x92\x83\x94\x4d\x0f\x74\x4a\x5f\xf6\xe0\x31\x1e\xcc\xc8\xd4\xe6\x44\x35\xd9\x79\xb9\x33\x20\x97\x3c\xe7\x19\x55\xd9\xac\xd6\x71\xab\xba\xcf\x1e\xa6\x7e\x40\x48\x02\x79\xb1\x43\xf6\xa4\x82\x91\x13\x2a\x48\xc6\x7c\x25\xbf\xdb\xbe\x33\x34\x1f\xf6\x37\x43\x16\x92\x8d\x89\xc6\xa0\x58\xec\x86\xbd\xde\xe3\x71\x5e\x03\x3b\x3d\xae\xce\x33\x2e\xec\x21\x37\x20\xef\xdd\xe9\xe4\x8e\x7d\x64\x01\xd8\xb5\xfe\x8e\xcd\x5a\xa2\x8d\xf1\x59\xb4\xf3\x44\x2c\x3a\x3a\x36\x8d\xd0\x4d\xbd\x1d\x63\x6e\x2e\x58\x21\x3b\x50\xd1\x70\xa0\x39\xcf\x3e\x37\xf6\x03\xa9\x39\x74\x49\xa1\x86\x50\x14\x44\x49\x99\x51\x6b\x91\xa1\x5f\x7f\x40\x8e\x4f\xce\x2f\x4e\x8e\x0e\xaf\x4e\x8e\x5f\x11\x3f\x12\x8f\x75\xfa\x01\xb9\x8a\xf1\x8a\xa3\x92\x2f\x07\x0a\x1b\x9e\xd5\x73\x82\x95\x8a\xaa\xc5\x03\xe0\x37\x52\x41\x4e\x05\x37\x55\xe7\x2a\x4c\xa2\xcf\xa4\x70\x69\xf1\xf6\xd7\x2e\xae\x30\xe6\x98\xbc\x29\xdc\x60\xf6\xeb\xfa\x68\xb0\x43\xb1\xcf\x4b\x98\x4a\x23\xef\xc6\x9a\x75\xbb\x6a\x79\xd6\x61\x65\xfa\x26\x2d\x9d\x6c\xf2\x2b\x0c\xc8\x56\x5d\x79\xf0\x44\x0d\xcd\x06\x3d\xfe\xaa\x54\xb5\x5e\x80\x83\xc1\xee\x80\xd8\xb3\x7a\x77\xb0\xeb\x55\xb9\x6c\xa1\x61\x65\x18\x34\x86\xb9\xae\xf3\xf7\x80\x90\x77\xbe\x8c\x10\x70\x8b\x96\xf7\xbe\x44\xb0\xbe\xa8\xd3\xe1\xdc\x2e\xf1\x2d\x51\xcb\x61\xfc\x50\x87\x8b\x3d\xe6\x53\x26\xf0\xc5\xd6\x27\x98\xfd\x54\x3b\x59\xb5\x8b\xea\xcd\xdf\x5f\xbc\x59\xdf\x4b\xa1\x64\xe9\xe4\x95\x8e\x64\x9e\x23\x62\xf3\x24\x20\x8d\x54\x60\x21\x41\xea\xad\xc5\x38\x47\x9c\xea\x51\xa3\x0d\x3b\x27\xf1\xfd\x50\x73\xc6\x78\xf8\xd8\xd5\xf5\x8a\xca\x1e\x7a\x78\x9b\x2c\x07\x94\xae\x3d\xf4\xa6\x3b\x3e\x0f\xc2\x7b\x1c\x5c\x9c\x1c\x1e\xbf\x3d\x19\xe4\xe9\x13\x14\xbe\x4c\xa4\x85\xe4\xc2\xe8\xa6\x86\x79\xb3\x76\xdb\x6d\xc5\x76\x98\x76\x37\xba\xd9\x89\x1f\x2e\x4e\xf4\xf4\xcf\x88\x90\xef\x53\x66\x28\xcf\x74\xc4\x61\x46\x16\x32\x93\xe3\xe5\x5d\xb7\x1e\xc0\x3a\x7f\x42\xec\xd4\x3e\xed\x5b\x9e\x5c\x9f\xc5\xda\xbc\x55\x6f\x9d\xa2\xbe\x35\x2f\xf4\xd2\x08\xd4\x0a\x96\x20\x74\xd4\x7d\x06\x04\xfb\x84\x26\xc2\x02\x15\xd1\x27\x03\x22\xce\x37\x26\xa8\x90\xfe\xa3\x06\xde\xab\xda\x0e\xeb\x21\x7e\x53\xb3\xc1\x4a\xf3\xa6\x9d\xe2\xeb\x54\xff\x9b\x1b\xa9\x7e\x88\x14\x8a\xf5\x03\xa0\x32\x74\x90\x96\x2a\xd2\xc1\xe2\x33\xc5\x3b\x71\xbd\xcb\x17\xef\xca\x66\xf3\xce\xdc\x4a\x4b\x0f\x3e\x74\xc4\xab\xcb\xb2\x59\xd5\x2e\xc3\xb9\xb4\xe8\x18\x81\x92\x95\x8b\x94\x15\x8a\x4f\x79\xc6\xc6\xd0\x70\x87\x8b\xb1\x6f\x3d\x1e\xe1\xed\x43\xfb\x4b\xb6\x30\x2f\xbb\xd8\xda\xc4\x0d\xe0\x80\xb3\xce\xde\x5d\x41\x13\x27\x48\x85\x69\x6d\x4c\xda\x07\x42\xb3\xeb\x7e\xbf\x0f\xfe\xbb\xbd\x7f\x59\xab\x26\xcd\xf6\xc9\xcf\xcc\x3d\x47\x42\xa3\x29\x05\x9d\xd4\x27\x32\x74\xfa\x81\xb9\x56\x94\x05\x86\xc6\xe4\x38\x77\xd7\x81\xbd\xd3\xaa\xcf\x78\x9c\xd7\xee\xe7\x0c\xc0\x9c\xab\x98\xff\x53\xb4\x80\xd6\x74\x88\x76\x2c\xed\x7d\x9c\x68\xd9\x1e\x09\x71\xfd\xc2\x9d\x0b\x94\xe8\x59\x9e\x71\x71\x5d\xa1\x87\x8f\xa4\xe5\x63\xac\xeb\xe5\xe2\xda\xef\x1a\xc5\x68\x76\xfb\x89\xd1\x84\x47\xd7\x76\x5a\x98\xce\x42\x09\x57\xb3\x02\xf3\xd8\x82\xf0\x72\x49\x56\xb1\xa8\xdf\xd9\x79\xd2\x14\xe3\x3a\xd1\xbc\xbd\x78\x3f\xbd\x3c\xba\x3c\xad\xc9\x76\x41\xf0\xb3\x4f\x19\xb0\xbb\xed\x70\x85\x97\x7c\xd2\x16\x04\xff\xad\x59\x86\x53\x9f\x64\x65\xd3\x5f\x62\x12\xf5\xb9\x54\x86\x66\x6b\x10\x9c\xc9\x84\x16\x87\xa5\x99\x1c\x73\x9d\xc8\x29\xeb\xc8\x0d\x71\x33\xc1\x0e\x64\xbe\xe1\x02\xf7\x4c\x8a\xcf\x20\x47\x7f\x3b\x3c\x27\xb4\xb4\x5c\x67\x5c\x73\x99\xb5\xa5\xa7\x79\x0a\x5c\x62\xc9\xef\x23\xbe\xbf\x7b\xc2\x46\xbd\xfd\x36\x28\xfc\xe8\x41\x61\x90\x8b\xcf\x25\x10\xcc\x05\x37\x9c\x1a\xa9\x3a\x8b\xd6\x1d\x95\xda\xc8\xdc\x6d\x91\x53\x3f\x3c\xe4\x38\x81\xaa\x55\x7b\x62\xbd\x1b\x2b\x18\x8a\x40\xde\x53\x61\xcd\x3a\x9a\xb0\xb9\x3a\x93\x1e\xf4\x6f\xc1\xb1\x79\xb8\xe7\x1b\x57\x6d\x04\xc0\xe4\xd9\xb7\xaf\x6a\xbd\x0d\x17\x5a\xde\x7a\xa7\x63\xd5\x46\x75\x6d\xde\x62\xfe\x5b\x37\xf2\xc9\x39\xf7\x91\x2e\xff\x55\xd2\x0c\xe9\x79\xb6\x4e\x4f\x78\x7d\x1d\x3b\x79\x4d\xcf\x53\x7e\xdd\xcf\x82\xf7\xab\xd4\x88\xab\x8e\x77\x18\x45\x85\xb6\xcc\x50\xf7\x2f\xec\xba\x14\x83\x5d\xb2\x67\x92\x62\x7f\x6d\x94\xe9\xaa\x9a\x13\x5f\xd6\xad\xfd\x9b\x50\xc5\xd9\xee\xbd\xd6\x9e\x37\x00\x7b\xb8\x1b\xe7\x69\x8d\x40\xa8\x92\x91\x37\x5c\x1b\xdf\xc6\x15\x3e\xe0\xda\xf5\xbd\x02\xed\xfb\x9c\x48\x45\x78\xf1\x0f\x9a\xa6\xea\x15\x9e\xf5\xce\x3a\x84\xff\xd6\x01\xa1\x9c\x8a\x90\xb1\xb2\x67\x66\x85\x6b\xaf\x70\x75\x74\x4e\xb0\x3b\xf4\xd7\x7f\x79\x01\x9a\xf8\x97\x5f\xfc\xe5\x45\x4b\x56\x7b\xaa\xd5\x71\xa4\x6b\x2f\x64\xe7\x79\x0a\xcf\xa4\x86\x02\x14\x50\xac\x9e\x80\xd3\xcd\x49\x41\xe4\x7b\xcb\x84\xe1\xcc\xed\x52\x4d\xdd\xd6\x1b\xfc\x81\xea\x0d\x48\x28\x18\x47\x39\xfa\x58\xf2\x19\x45\xf3\xf9\x53\x11\xcd\x0d\xa9\xd9\x94\x73\xeb\x1c\x8b\xd2\x6d\x77\x57\xc7\xb9\x1c\x50\x4f\x79\x7c\x76\xf9\x8f\x37\x87\xdf\x9f\xbc\x81\xf7\x74\xd9\xf0\x96\x15\x9d\x59\xd2\x24\x77\x7b\x75\xd6\x6e\xee\x29\x6a\x4a\xce\x2e\x22\xf6\x67\xaf\x2f\xe7\x5c\x71\xf6\x93\x07\x86\xe9\xdb\xda\x96\x62\xd4\x82\x7a\x4f\x2d\x48\x00\xad\xac\x99\x5a\x4f\x71\x77\xc7\x11\x86\x08\x40\xbd\xe6\xd4\xb0\x3c\x84\xef\xd8\xda\xef\xd0\x90\x37\xc8\xc6\xa9\x71\x77\x07\x93\x2d\xc5\x90\x8a\x9d\x87\x91\x3f\x29\xb5\xdb\xa9\x87\xaa\x2b\xe4\x81\xdd\x4b\x18\xcb\x27\x3c\x58\x11\x86\x79\xd4\xca\x9e\xa8\xf6\x2c\x65\x3a\x34\xbd\x7d\x06\xdc\x5a\x2c\xeb\xf6\xd6\xfe\x74\x58\xda\x44\xce\xb5\x3a\xc6\x20\x4d\x2d\x44\x5f\xab\x5e\xbe\xad\x6b\xa2\xcf\x65\xa4\xce\x55\xa5\x0b\x9a\x74\xda\x8b\xa7\xfa\x08\x3f\x01\xa0\xb7\xa7\x78\xc0\xc0\xc4\xd7\x54\x66\x15\x9e\xdd\xcd\x76\x3c\xf2\xc3\xcd\x83\x81\x3c\x88\x4b\x7c\x97\xe8\x42\x7a\xb0\x97\x18\x35\x64\x23\x59\x88\x6c\xdc\x39\xf4\x73\x43\x07\xc2\x3a\x9d\x07\xc5\x44\x1a\x29\x3a\x2e\x21\x3d\x5f\x32\x68\x5d\x9e\xe1\x1d\x47\x55\xfb\xf5\x8a\x2f\xb0\xc2\x26\x84\xa6\xad\xc1\xe1\x4f\x6c\x29\x7c\x90\xba\x1e\xa2\x7e\x7a\x02\xa8\x48\x4f\x8f\xd7\x20\x7b\x9e\x3e\x0c\xcf\x43\x83\x73\x6b\x4b\x2f\x4d\x3b\xaa\x4b\x3f\x3d\x76\xb6\x80\xaf\x3d\xd7\x6e\xf3\x90\xdb\x77\xcf\x5a\xf4\x24\xa9\xcc\x8d\x54\x5d\xc1\x97\x9d\xd7\x86\x9b\xcb\x57\x74\xdf\x2d\xe0\x49\x3c\x4f\x59\x81\x6f\xf9\xe4\xe5\xc5\x25\x24\x72\xcd\x75\x94\x9c\x97\x10\xa1\x52\xf7\x11\x84\xc8\xd3\x11\x1e\x9d\x6a\x25\x8f\x0b\x1b\xb5\x36\x93\xd6\xef\x8a\x4e\x68\xf4\x93\x1b\xcc\xb9\x36\x2d\x7f\x54\xe2\x96\x06\x61\xe4\x1e\xba\x16\xf1\xaa\xa4\x15\x3f\xcd\xa4\x48\xfd\x40\x31\x2c\xd7\xd8\xca\x2f\xcb\xec\x7a\x4a\x11\x37\x01\x74\xe0\x52\x3d\x82\x7d\xf4\x72\x5a\xb8\x7e\xe3\xa9\xbc\x11\x37\x54\xa5\xe4\xf0\xfc\xf4\xd3\x0b\xd1\xd6\xc5\x8f\xb8\x0b\xda\x60\xd2\xd7\xa8\x08\x28\xf4\x43\x6e\x34\x66\xb3\x43\x3e\xba\x89\x7d\x48\xf6\x00\x0a\x19\x22\x56\x84\x59\x71\xe5\x66\x11\xe9\x48\x82\xc8\xc4\x50\xd7\xd9\x3d\x74\xbd\x7f\xf1\xe2\x05\x86\x14\x5e\xfc\xf5\xaf\x7f\x25\xd0\x75\x31\x65\x09\xcf\x17\x6f\x84\xbb\xfe\xfc\xf2\xe5\x80\xfc\xfd\xf0\xed\x1b\x42\x13\xb0\xc0\x10\x52\x15\x47\x86\xb5\x8b\x7f\xac\x7b\xe4\xff\x5e\xbe\x3b\xab\xda\xbd\xd7\xbf\x05\xd6\xc8\xfd\xeb\x0d\xc8\x71\x94\x7e\x1e\xbb\xfc\xa9\x99\x40\x4a\xbe\x90\x86\xd0\xd1\x08\x98\x13\x45\x32\xd7\x5e\x5c\x78\x5c\x34\x3e\x9e\xf8\x6e\xdd\x96\xad\x32\xc8\x8b\xe7\x76\x8a\x10\x62\xf1\x50\x82\x98\xe6\x0f\x63\x85\xd3\x01\xa6\xd2\x23\x19\xbf\x66\x64\xa4\xa1\x67\x77\xd5\x44\x43\x31\x6d\xed\xa7\x84\x0a\x3b\x3a\x0e\x16\xa6\x6e\x27\xf1\xb4\x73\x17\x5a\x76\x77\xae\x31\xac\x6f\x0c\xe7\xeb\x92\x50\x9e\x58\xb2\x3f\xd5\x5c\x82\xba\xbe\x18\xde\x07\xb9\xc8\x41\xf1\x05\xb1\x49\x68\x26\xc5\x38\x66\xba\x4a\x8f\xf0\x09\x88\xb3\x82\x35\x25\x46\x47\xdd\x54\xba\xe9\x4d\x86\x92\xfb\x2d\x6d\xd9\xdf\xbf\x1e\x5a\x8d\xa0\x10\xe9\x50\x96\xc6\xa7\xbc\xe1\x93\x00\x02\x0b\x30\x12\x91\xe0\xad\x1e\xdc\x59\x63\x9a\xee\x5a\xbd\x75\xd4\x67\xa9\x7e\x10\xd7\x94\xcd\x1e\x61\x34\x99\x90\x6b\x36\xeb\xa3\x88\x2f\x28\xa0\x1f\x00\x9d\x8f\x2d\x75\xb1\xbf\x50\x3d\xa3\x20\x61\xa9\xb5\x03\xdd\x22\xf8\xcc\xc4\x8a\xeb\x03\x7a\x82\x37\x95\xb4\xd3\xa8\x5d\xdf\x22\x11\x39\x0e\x7d\xa3\xc2\x44\x0a\xe3\x9a\x20\x86\x46\x45\x90\x69\x39\x57\x61\x6f\x25\x0a\x4b\xed\xcf\xf4\x5d\x4f\xae\xd2\x31\xed\x91\xe1\x94\x89\x52\x2c\xfc\x1a\x90\xc0\x21\xef\x55\x33\x87\xe7\x43\x7d\x03\xbc\x28\xa5\x73\xc2\x13\xa8\xaa\xb1\xb7\xbb\x7b\x3d\x95\x02\x21\x6a\x08\x00\x9a\x99\xd2\x91\x06\x72\x69\xed\xb3\x99\xd6\x84\xc3\x1b\xe6\x54\x5d\x33\x0f\x66\x4b\xb3\x01\x39\xb7\x93\x0c\x38\xe5\xd8\x37\x6e\x8a\x45\x10\x56\xa6\xc4\xd0\x06\xf6\x21\xbb\x83\xc1\x2e\x9e\x85\x4b\x80\x0e\x5a\xf3\x4b\x97\x2d\xc3\x3a\x6b\x15\x56\xd7\x83\x68\xa1\xb1\x75\x9a\xb5\x0e\xa0\x3d\xa1\x04\xdc\x11\x33\xf1\xda\x02\x6d\x09\x3e\x1d\x5f\x1d\xf7\xac\xea\xb6\xed\x65\x77\x4d\x2f\x5b\x84\xc0\xeb\x57\xd7\xcd\x2e\x3b\x6c\x75\x59\x4f\x38\x76\xf2\xa7\x3a\x41\xba\xea\xbb\xd7\x79\x63\xc5\xbc\x83\xb6\x56\xfe\xba\x0d\xb9\x38\x5f\xc5\xba\x00\x45\xdb\xca\xf2\x27\x65\x4e\x9c\x8e\x40\x86\x2e\x47\x6b\x89\xac\xb4\x70\xa4\x58\x0a\xac\xdf\x8e\xe8\xa2\x57\x3c\xe9\xc8\xb0\x98\xbf\xda\x1b\x1a\xf3\x57\x9b\x64\x96\xf9\x6b\x61\x9f\x87\x33\xb5\x88\x4a\x69\x61\x89\x8c\x84\x1e\x8c\x26\x08\x83\x01\x79\xeb\xce\x5c\x64\x6e\x3a\xd4\x32\x2b\x4d\x80\x55\x58\x72\x20\xc3\xa0\xbe\x63\x23\xc2\x0d\xf9\xdb\xa2\xe3\x19\x14\x13\x3c\xb3\xba\x39\xa9\xf1\xea\x50\xd8\xb4\x4d\x46\xc5\xeb\x0f\x96\x92\x8a\x57\x87\xab\xe0\xf5\xc2\x8e\x57\xe2\xd2\x61\x4a\xfa\x3a\xc0\x9a\xf6\x0a\x69\xa9\x46\xa3\x6a\xec\x15\x51\x6c\x78\xd8\x14\x6d\xb9\xba\xda\x3b\x5e\xdd\xeb\x38\x6f\xe0\xe1\xf9\xe9\xa3\x5b\x99\xd1\xb3\xb6\x76\xe6\x4a\xd7\x12\x87\x2f\x00\x11\x78\x27\xd0\x71\x45\x51\x17\x60\xb3\xf2\xf7\x0f\x60\xae\x2c\xbc\xf8\x6b\x7b\xee\x44\x41\xa9\xb9\x96\x0f\xe8\xc1\xad\x4e\xa8\xa8\x4d\x84\x4f\x97\x01\x69\xf6\xfc\x4d\x9b\x0d\x35\x48\x80\xfa\x2d\xea\x5e\xe6\xaf\xf9\xc4\x52\x47\x44\x72\x09\xbd\xf6\xd1\x7b\x12\xb9\x61\x0a\x99\xbe\xc2\xa6\xcd\x54\x08\x69\xb0\xc7\x7c\x0f\x9b\xf5\xeb\x1e\xba\x57\xac\x92\x19\x25\x5a\xa9\x28\x84\xd9\xb1\x5a\xd9\x19\xf3\x90\xce\x19\x88\x00\x13\x01\xed\xce\xbb\xe1\x24\xf2\x08\xdc\x64\xaf\x4a\x2b\xe9\xb2\xaf\x7a\x3d\xdc\x88\xe3\x7b\x26\xd2\xc9\x84\xe5\x14\x1b\x5c\x78\x02\x59\x79\x7d\xa3\xb8\x31\x0c\xf1\xaf\x99\xca\x35\x91\xa3\x9e\x37\x91\x10\xf5\x64\xfa\x72\xa7\xbb\xfe\xf4\x8f\x60\x2b\x13\xbf\x43\x9b\xc2\x57\xdd\x76\xd5\x7d\xff\x35\x3b\xc2\xee\x4e\x30\x98\x33\xe8\xb8\x23\xe6\x9c\x90\x56\x89\x98\x22\xfd\x37\x9a\x74\x9b\xe7\x66\xe8\x05\x65\x74\xeb\x66\xd8\xba\x19\xba\x18\xf1\xd1\xdc\x0c\xd1\xc1\xed\x85\xa9\x5b\x80\xd8\xf5\x10\xe3\xbf\x7b\xff\x43\x85\xeb\x10\x61\x19\x5b\x96\xf7\x9e\x07\xa9\xea\xfe\xff\xdd\xc1\x60\x77\xd7\xfb\x23\xdc\xfe\x28\xcd\xa8\xff\x35\x61\x22\x91\x29\x32\x95\x1d\x5f\x69\x03\x4a\x6d\x65\x80\xc7\x73\xc9\xfd\xb3\xe2\x18\x02\x8c\xdd\x2d\x4b\x74\x28\xa1\x7c\xce\xc8\xeb\x47\x55\xc1\x2a\xc5\x2b\xc0\x57\x39\x02\x06\x94\x3f\xa7\x81\x55\x39\x2c\x19\xcf\xb9\xc3\xd5\xb3\xe2\x82\x69\xa3\xc9\x1e\x7e\x38\x48\x8a\xb2\xe7\x6e\x18\xe4\x2c\x97\x6a\xd6\x0b\x37\xd9\x2f\x6b\xbf\x72\x77\xec\x83\xd6\x96\x94\x4a\x31\x61\xb2\xd9\x1f\x57\x7f\xf3\x24\xde\x60\xf5\x2d\x70\x45\x9b\x12\x8b\x65\xd7\x5c\xd9\x45\x00\xb6\x07\x47\x5d\xa0\x36\x9c\x43\xae\xd8\xa1\x17\xdc\x47\xf0\x29\x13\x53\x32\xa5\xaa\x71\xb1\xc3\xb2\xeb\x51\x34\xb6\x94\x4f\xb9\x96\x8d\xcb\xc5\x96\x0e\xb9\xe8\xfd\xe2\xae\x11\x80\x2c\x4d\x51\x1a\x77\xba\xf8\xbd\xed\xa1\xe6\xc2\x9e\x9e\x53\x7c\x5f\xee\x74\x38\xb9\x82\x1a\xc3\x94\x78\x45\xfe\x7b\xef\xc3\xe7\xbf\xf7\xf7\xbf\xdb\xdb\xfb\xe5\x45\xff\x3f\x7f\xfd\x7c\xef\xc3\x00\xfe\xe3\xb3\xfd\xef\xf6\x7f\xf7\x7f\x7c\xbe\xbf\xbf\xb7\xf7\xcb\x8f\x6f\x7f\xb8\x3a\x3f\xf9\x95\xef\xff\xfe\x8b\x28\xf3\x6b\xfc\xeb\xf7\xbd\x5f\xd8\xc9\xaf\x2b\x0e\xb2\xbf\xff\xdd\x7f\x74\xf8\x12\x54\xcc\xde\x75\x26\x82\xf1\xea\x3f\x8a\x1a\x51\x1f\xbb\x63\xd6\x25\xe4\x63\xbf\x72\x5e\xf7\xb9\x30\x7d\xa9\xfa\xf8\x90\x57\xc4\xa8\xb2\x2b\xd1\x55\x1d\x7f\x8f\x27\x63\x2a\x25\xa6\x42\x6e\xf4\x86\xcd\x06\x0a\x11\xcc\x1c\x7d\x74\x6f\xb0\x6b\x97\xba\x75\x04\xaf\x72\x3d\x4a\xc2\x91\x43\x86\xf9\x83\x67\x1b\x5d\xba\x8e\xbc\xdb\x54\xa3\x85\x6b\x9b\x6a\xb4\x78\x6d\x53\x8d\x1e\x78\x6d\x53\x8d\x36\xd0\x07\xb8\x4d\x35\xda\xfa\x00\x9f\x88\x0f\x70\x9b\x6a\xb4\xea\xb5\x4d\x35\x6a\x7c\x3d\xcd\x54\x23\xa7\xc0\x57\x79\x46\x1b\x9b\x66\xe4\x1a\xfc\x1f\x26\x89\x2c\x85\xb9\x92\xd7\xac\x65\x54\x76\x25\x03\x73\xe1\x99\x9b\x69\x6d\x76\xa5\x52\x76\xa0\x02\x76\xa7\xfc\xd1\x32\xe5\xd6\xcc\xec\x78\x1b\x1c\xba\x61\xbd\x9d\x69\x8f\x45\x91\xb2\x34\x3c\xcf\x0b\x2b\x63\xd7\x7b\x40\x0e\x89\x62\x09\x2f\xb8\x15\xed\x00\xa6\x03\x9f\xe3\x3e\x09\xfd\x80\xb9\xd1\x2c\x1b\xb9\x9e\xa8\xa2\xaa\x19\x56\x91\x09\xe9\xce\x8a\xa5\x8f\x41\xad\x40\xfa\x36\x96\x44\x4f\x64\x99\xa5\x44\xb1\x7f\x79\x75\xc2\xcd\xe6\x2a\x1e\x21\x76\x84\xc2\xab\x54\x8f\x75\x83\xd3\x82\x3b\xd4\xad\x4d\x12\x70\xec\x63\xc1\x15\x6c\xb6\x4b\x96\x48\x91\x76\xed\xde\x38\x99\x1f\xdf\xaf\xb5\x8b\xe6\xb0\x94\xa4\x25\xde\x00\x85\x90\x34\xe3\x29\x37\xb3\x90\x85\x81\xdb\xde\x2a\xa2\xd8\x85\xd6\x31\x82\xae\x16\x82\xd0\xa2\x50\x92\x26\x13\xa6\xa3\xb7\x41\xb5\xd2\x81\x4d\x84\xfa\xca\xac\x1c\x73\x81\x9a\x25\xfc\xc6\xaa\x21\xd9\x8c\x28\x69\x7c\x42\xd9\x2d\x0f\xbc\x8a\x06\x83\x9f\xa3\x2e\x61\xd4\x0c\xb2\xce\x64\x3c\x04\xce\x8a\x8f\xe2\x3f\x34\x91\x59\xea\x71\x4b\xbf\x7e\x61\x55\xf9\xc4\x71\xb1\x95\xf6\x80\x2a\x69\x24\xc9\xac\x5a\x64\x4f\x80\xdb\x7f\xfc\xc5\x57\x64\x22\x4b\xa5\x07\x31\x84\xc0\x4b\xf8\x0c\x9d\x14\xde\x14\x30\x24\x63\x54\x1b\xf2\xf2\x05\xc9\xb9\x28\xed\x59\xde\x11\xe3\x75\xa5\xbd\x46\x7a\xeb\x5f\xbe\x6a\x39\x5a\x37\x1a\xeb\x62\x06\x8b\xe3\xd6\x02\xfb\xb3\x39\xc5\xd5\xed\x71\x04\xc5\xc0\x1e\x8d\x73\x6a\xac\x3b\x92\xe2\x55\x14\x46\xae\x79\xe7\xff\x56\xca\xe1\xcc\xb4\x87\x81\xf9\x2f\x1c\xa7\x8e\xff\xe2\x3f\x5c\x05\x4b\xb5\x82\x52\x6d\x30\x95\xb5\x77\x8b\x1e\x73\x6d\x1a\xf5\x8a\xae\x70\x63\x1a\xfc\xb8\xed\x61\x3e\xb6\x16\x6f\x27\x45\xeb\x60\x3b\x7b\x5b\xcd\x3b\x95\x93\x84\x69\x10\x45\x1e\x3e\x0d\xfc\xb3\xf8\xd4\x86\x0f\xdd\x2c\xc4\x96\x3b\x11\x59\x3c\xf3\x77\xd0\x19\xb3\x15\xb1\xda\xe8\xf6\x9e\xb1\x3b\xa2\x16\x0e\x56\x97\x11\x9a\x8b\x31\x36\xb2\xcc\xcb\xcc\xf0\x22\xab\x28\x17\x7e\xe0\x0e\xe0\xd8\xe1\x4f\x23\x0f\x33\x45\xe0\x28\x84\x06\x87\xe0\xc8\x5e\x18\x8b\x09\x83\xfd\x18\x95\x3d\xc7\x0b\xaa\x68\x20\x7f\x22\xf3\x9c\xea\x7d\x17\x3b\xa0\x90\xbb\x82\x92\xdd\x1e\xc3\x8a\x66\xe1\xf5\xe3\x5c\x81\x75\x31\xae\x61\x82\x8a\xc6\x41\xbb\xba\xc3\x05\x86\x22\xf2\x26\xa4\xc7\x63\xff\xf4\x39\x8e\x75\x0a\xf1\xf7\x34\xb9\x66\x22\x25\xef\xb5\x27\x5c\x3a\x13\x34\x77\xe0\xea\x85\x92\xd8\xb7\x9b\xa5\x73\xbf\xd7\x3d\xe7\x48\x44\x94\x11\x0f\x02\x85\xfa\xd6\xba\xa8\x58\xea\x8e\xd0\x75\xdf\x6b\xab\x7c\xdd\x2d\xef\x34\x3a\x69\x15\x9f\x26\xcc\xeb\x8e\x76\x02\xeb\x7a\xf9\x69\x63\xc4\x37\xb2\x1c\x87\xc9\x35\xcd\xc4\x5d\x08\x47\x7a\x08\x3e\x02\x8e\x3a\xcd\xac\x88\x9b\x05\x78\x9d\x39\x06\x1b\xce\xd6\xd7\xb2\x5f\x0d\xdb\x03\x34\xed\x5e\x7c\x7f\x5c\x17\x66\x17\x34\x95\x9a\x7c\x9f\xc9\xe4\x9a\x1c\x33\x30\x1a\x1e\xb3\xdd\xbb\x1a\xa6\x4f\xbb\x4d\x63\x4e\xc7\xcd\xf2\x3c\xfa\x24\x97\x82\x1b\xa9\x9a\xc8\xe3\x0d\x02\xdb\xdb\xb6\xda\x5b\x0e\x22\xae\x86\xe9\xb3\x69\xb4\x67\x99\xbc\xa3\x0e\xbb\x13\x46\x14\x88\x18\x18\xd4\x77\xff\x68\x28\x30\xfe\x34\x91\x37\x7d\x23\xfb\xa5\x66\x7d\xde\x38\x4f\xa9\x35\x7d\xae\xd9\x0c\x92\xbe\x3a\xa1\xd0\x8f\x38\x58\xcd\x44\x37\x12\x3c\xe7\xf0\xb9\x55\xe4\x2e\xbe\x3f\xb6\xa7\xf7\x20\x36\x4b\x0e\x98\x49\x0e\x12\x56\x4c\x0e\xdc\x74\x9e\x3c\x59\xbd\x7c\xec\x86\xae\x87\x24\x91\x59\xe6\x70\xbb\xe4\x88\x1c\xb1\x62\x12\x1e\xb1\x19\xb4\x7a\xca\xcd\xd2\x0a\x29\xbb\x69\xac\x14\x89\x08\x3b\xa6\x93\x10\x11\xa3\xab\xe1\xc3\x7a\x41\x6f\x22\x6b\x7f\xc2\x9e\x24\x4d\x7a\xcb\x6d\x04\x79\x37\xa7\x47\xdd\xee\xa5\x1f\x0e\xfc\x3f\x51\xb8\xb9\xde\x92\xce\xe7\x8b\xd6\x44\xf4\xe9\x08\x2d\xcc\x94\xa5\x44\x4e\x99\x52\x3c\x65\x9a\x04\x19\x1d\x3b\x96\x78\xb6\x19\x94\xdf\x76\xc7\x7b\x5a\xf9\x01\x9b\xe3\x53\x88\x84\xb7\x1d\x73\x51\x78\xd3\x34\xe7\x62\x33\xb8\xbc\x21\xbd\x74\x42\x33\x76\xfa\xae\xb5\xe9\x7d\x89\xe3\xd4\xad\x6f\xff\x61\x04\xb2\x7f\x0f\xf0\xfc\x8f\x81\x67\x89\x90\x69\xb3\x68\xd8\x9a\x6d\xe8\x31\x35\xec\xa6\xa1\xe2\xd3\xaf\x44\x7d\xd3\xdf\x83\xe5\xf5\xb4\x6d\xf0\x35\x35\xc8\x88\xf6\x35\xa2\xde\xaf\x4b\x9d\x72\x1c\xd4\x8d\x6b\xd9\x93\x62\xae\xbf\x98\xdf\x9a\x87\xe7\xa7\xe4\x07\x7c\xde\xfa\x3a\x7e\x28\x69\xd0\x92\x39\x96\x39\xe5\x1d\x35\x62\x8f\x1a\x3a\xc5\x2f\x7c\x1e\x1e\x46\xf0\x69\x71\x17\xfa\x11\x1f\x97\x8a\xa5\xc4\x79\x3f\xb6\x6d\x0c\x36\xb8\x8d\x41\xb7\x4a\x71\xa5\x13\x47\x1e\x73\x5f\x19\x53\xe9\xc1\x9e\x8b\x40\x1d\x08\x29\x48\x44\x33\xa1\x39\x64\x1d\x44\x89\x71\xa0\x2c\x43\xfe\x77\x28\x83\x41\xc5\xb9\x47\xde\xc8\x31\x17\x5e\x3a\x49\x97\xec\x32\xa2\x3c\x6b\x47\xce\xad\xa6\xfb\x07\xd3\x74\xb5\xce\x4e\x04\x1d\x66\xcd\x33\x19\xeb\x07\x6f\x46\x21\x4f\x8a\xc1\x98\x07\x29\xd7\xf6\x5f\x72\x79\xf9\x06\x62\xb3\xa5\xf0\x96\x21\x44\x1d\xdd\xb1\x11\xea\x8b\x51\xb8\xac\x4f\x1e\xa0\xcc\xee\xac\x4f\xc5\xa9\x48\xed\xeb\x32\x5d\x4b\x00\x76\x4f\xc1\x2e\x20\xa1\x7a\x0d\xb3\x0f\x87\x8c\x5c\x4d\x78\x72\x7d\x1e\x85\x60\xa5\xb2\x9f\x89\xe8\xa3\x9a\xa2\x31\xff\xdd\xba\x0e\x1c\xf7\x5a\xe7\x5d\xb9\xbd\xae\xa2\x13\xf7\xd2\x91\xcc\x0e\x4e\xa8\xd6\x32\xe1\x55\xcc\x1f\x9c\xc2\xd5\x91\x9c\xc2\x91\xbc\x3e\x32\x80\x96\xf8\x28\xfa\x87\x67\x1c\xa7\xb4\x52\x1d\xeb\x1b\x5c\x78\x6a\xad\xed\xd5\x91\x95\x3b\xeb\xae\x79\x55\xeb\xa7\xe9\xad\xbe\xb9\xf0\xb3\xaf\x07\x75\x8c\xe2\xf5\x79\xd7\xc0\x79\x91\x55\x42\x5f\x4d\xd7\xdf\x63\x2d\xc4\x6a\x5e\xac\xbd\xcc\x0b\x37\x97\x7b\x83\x9f\xb9\x80\x34\x08\x95\x42\x16\x65\x86\x59\xab\xed\xdb\x8a\xfa\x68\x1e\x3e\x67\x0d\x01\xea\x4d\x6b\x46\xf4\xd0\x72\xbe\xe7\xd1\x97\x28\x32\x08\x5e\xfc\xe5\xab\xaf\x9e\x7a\xa7\xa2\x76\x8e\xb3\x75\xb7\x2a\x6a\x15\xea\xda\xa2\x14\x6c\x51\x0a\xee\xba\xd6\x1e\x89\xfd\xf4\x38\x04\x9d\x14\x89\x75\x51\x20\xd6\x16\x69\xa0\x65\x71\x59\x37\x85\x65\xad\xb1\x04\x1e\x15\x41\xa0\xa3\x1a\xab\xf6\x68\x01\x5b\x8c\x80\x3f\x06\x46\x40\x77\xb5\x55\x5d\xe1\x01\xb4\xaf\xa9\x7a\xfe\xb5\xff\xad\xc5\x44\xdb\x0a\xf3\x87\xd7\x95\x77\xd5\xbf\xa2\x2b\x3f\x7b\x67\x8e\x81\x9a\x57\xd7\xd9\xbb\x9e\x33\x30\xf3\xba\x42\x7c\x37\xd2\x0a\x8d\x35\x5a\xbb\xa4\xb5\xb3\x00\xa7\x22\x1b\x9d\xc1\x75\xae\xc1\x91\xde\x5d\xce\x85\xd8\xc3\xc7\x9b\x1f\x59\xdf\x86\x98\xb7\x6d\xd4\xb7\xf1\xc7\x70\xdd\x12\x7f\xd4\x35\x8c\x57\xef\x11\x04\x49\x08\x2a\x98\x1c\xc6\x7d\x54\xaa\xfd\x7f\x78\x7e\x4a\x12\xc5\x00\xd2\x80\x66\x7a\x40\x96\x68\x68\x3e\x52\xe3\x34\x3a\xaf\x99\x51\x63\x58\x5e\x98\xb6\x0c\xb7\x0d\x3f\xfe\xc1\xc2\x8f\x1d\xc7\x0c\x7e\x0a\xc3\x79\x6f\xd1\xa4\xcc\xa9\xe8\x5b\x69\x01\x81\xc8\x5a\x3e\xc7\xdc\xc1\x37\x20\xbe\x06\x0e\xa9\x49\x15\x43\x70\xf3\x52\xf0\xdf\x4a\x56\xf9\x17\x82\x7a\xb1\x01\xa1\x16\x98\x47\xc7\xb4\x43\xd5\x69\x4e\x8a\x24\x72\xa1\x94\xc9\x11\x24\xd0\xd1\x0b\x8c\x48\xff\xaa\xf9\xca\xcc\x84\xa1\x9a\x76\x0e\xe0\x00\xd5\x5d\x75\xfb\x0e\x0d\x3c\x9a\x65\xf2\x06\x9f\x1d\x2b\x1e\x76\xfd\xec\x5c\x1c\x1e\xc7\x90\x91\x9c\x2b\x25\x95\x0b\xf1\xc4\xd3\xc1\xb4\x1c\x6b\x27\x32\x85\x06\x97\x72\x59\x15\x97\xcc\xc4\xac\x62\x24\xa1\x02\x0b\x17\xed\x7f\xfb\xa4\x64\xec\x7f\xe6\xe4\xdd\x90\x4d\xe8\x94\xcb\x52\xe1\xaf\x8d\x24\x3b\xee\x2b\x38\x72\x67\xb2\x0c\x6e\xee\x12\xea\x94\xc2\xdb\xe9\x25\x74\x3a\xab\xbe\x04\x03\x35\x95\xde\x7f\xd8\x67\x1f\xb9\x36\x8b\xef\xe2\x49\xe4\x1b\x24\xac\x83\xf3\xa6\xba\xb0\x07\xec\x4f\x8d\x6b\x4e\xeb\xfc\x16\x8f\x56\x57\x49\xa7\x97\xf0\xd5\x7d\x0a\xa9\x43\x6a\xc1\x52\x71\x5f\x14\xf6\xf4\xd2\x3d\xf1\x2d\x1b\x76\x66\xda\x6a\xc4\x4f\x45\x23\x0e\x09\x12\x19\x4f\x66\xa7\xc7\xdd\xe8\x7c\x21\x31\xc2\x0e\x4a\xbe\xa7\x9a\xa5\xe4\x2d\x15\x74\x8c\xce\x91\xbd\xcb\xf3\xef\xdf\xee\x5b\x26\x01\xe7\xcb\xe9\xf1\xd2\xec\x89\xcb\x78\x66\x67\xeb\x2a\xdf\x26\xf3\x34\xea\x4c\x2b\x78\x20\x95\xd6\x56\xc0\x4e\xc2\xc9\xde\xa6\x65\xd7\x22\xb8\x11\xa6\x43\x78\xa4\x32\x3d\x2f\x5e\xa7\x79\x7a\xfd\x98\xaf\x1b\xf9\xaa\xef\x7a\xa7\xd5\x02\x4d\x2b\x04\x93\xe6\xd6\x5e\x51\xc3\xc6\xb3\x63\x56\x64\x72\x66\x97\xfb\x3c\x72\x9d\xe3\xad\x43\x3c\xea\xd5\x90\x26\x44\x95\x19\xc3\xee\x35\xf3\x10\x61\x82\xb1\xb4\x92\x53\x5c\x68\x43\x01\x20\x0c\xc7\xbf\x73\x46\x2b\x1f\x30\xab\x1e\x25\x7d\x9c\xe7\xbd\x77\xd5\xe1\x14\xed\x86\xba\xf3\x27\xab\x1f\x26\xf0\xf8\xfb\x39\xf4\x21\xc1\xc3\x95\xc3\x84\x75\x06\x87\x3d\x7d\x51\x66\xf6\xe8\xc8\xd2\xb9\x26\xa2\xa0\x5b\xb9\x35\x46\x64\x06\x90\x00\x76\xf6\x3d\x32\x2c\xad\xe2\xc5\x74\xcd\xbf\xbc\x08\x4b\x79\x33\xc1\xb8\xb1\xfd\x11\xa1\x45\x91\x71\xcc\xeb\x95\xca\x05\x7f\x23\x6f\xe3\xe2\x6d\xab\x08\x92\x07\xea\x1f\x0f\xd3\x37\xfa\x64\xca\xd4\x70\x15\x4c\x85\x87\xaa\x12\xb4\xe0\x10\x3b\x59\x59\xf3\xa8\x83\x42\x9e\x9f\xe2\xaf\xbd\xa5\x16\x9b\x66\xfe\x4b\x5c\x41\xb7\x36\x1e\x50\xd0\x75\xa5\x41\x6b\x23\xa0\x02\x1d\x9e\x9f\x22\x0c\x95\x03\x06\xaa\x5c\x16\x56\xb7\xa7\x98\x1c\x58\xa1\x11\xd2\xb1\x1d\xd1\x10\x29\xc2\x43\x99\x28\x73\x86\x60\x42\x55\x3b\x2b\x6b\xf0\x89\x59\x35\x7a\xe5\xf1\xb0\xf6\xc9\xea\xea\xc4\xc3\xc3\xe8\x0f\x0c\x9b\x3f\xf8\xe4\x11\x52\x5c\xb8\xd7\x7c\x7f\xf1\xa6\xd9\x22\x9e\xd5\xc7\x70\xe0\x31\x0c\x70\xf2\x0a\xaa\x0c\xa7\x19\x29\x55\xe6\xc3\x70\x98\xf4\xee\xd2\xd2\x26\x74\x1a\x01\xec\x0c\x08\xf9\x0c\x57\xce\x11\x16\xf7\x27\xb6\x77\xc5\x95\x1f\x95\x59\xd6\x23\x23\x2e\xa8\x15\xbb\xac\x20\x71\x38\xe8\x92\x8b\xc4\x9a\x5f\xd6\xd6\x77\xfd\x5a\x60\x46\xde\x28\x0b\x9b\x14\xa2\x8c\x10\x2d\x65\x59\x0a\xa0\x8b\xf0\x08\xbb\x61\x13\x70\x11\x58\xab\xf1\x28\x2b\xb5\x61\xea\x42\xda\xc3\x20\xca\x6b\x01\x38\x0a\x1a\x7f\xfd\x3d\x17\x29\xa4\x30\x5d\xc0\xc1\x91\x50\x41\x18\x07\xe7\x8b\x1d\x12\xe2\xd4\x96\x77\x2a\x86\xda\xd3\x65\x32\xb1\xaf\xb4\x53\xc8\x54\xef\x58\x31\xb2\x83\x2e\x3a\xbd\xb3\x6f\xff\x9a\x7f\x07\x4c\x53\x89\x7e\x77\x40\x0b\xbe\xb3\xdf\x23\x40\x20\x08\x9c\x49\x33\x79\xba\x7c\xe8\xdf\x15\x6c\xe2\x46\x5c\x78\x11\x8f\x00\x3c\x28\xaa\xee\x5f\x37\x13\x6e\x58\x68\xbe\x8d\x9e\x9d\x80\xaf\x32\x2f\xac\x09\x39\x14\x84\xe5\x85\x01\x6f\x31\xc9\x19\xf5\x21\x64\x36\x65\x6a\x66\x6d\x72\x00\xa2\x78\xf2\x9b\x3f\xf0\x63\x2b\x82\xcf\x75\x36\xaf\x98\x1c\x76\xd8\x02\x71\x77\x3f\xdb\xad\xd9\xf9\x59\x16\x49\xf3\x27\x4b\x4a\x38\x5e\x1b\x91\xf1\x27\xfb\xcb\x3a\x09\xf1\x23\x94\x96\x41\x7e\xbc\x79\xe3\x02\x19\x48\xab\x1f\xb9\x48\x51\x45\x3d\x34\x46\xf1\x61\x69\xd8\x05\xb3\x13\x4e\x30\xe5\xc1\x77\xe1\x73\xd9\xd1\x6e\x25\x96\x92\x1f\xe6\xfe\x14\x49\xbf\xa8\xd8\xae\xaa\x8c\xde\x31\xbc\xd7\xe5\x6f\x1b\xea\xce\x01\x9c\x41\xf0\x56\xa6\xcb\x37\xd5\x5c\x65\x48\x75\xb3\x53\x55\xa2\xce\x96\x7e\x2c\xa7\xc4\xce\x8a\xa5\x9a\xfe\xdd\xcb\x71\x07\xe9\x6f\x9b\x49\xe5\x1b\x00\x09\x1a\x7d\x73\x35\x2b\x98\x43\xda\x26\xa3\x8c\x8e\x2b\x36\x02\x79\x88\xea\xd3\xd1\xe5\x4f\xfe\x15\x34\xe1\xcb\x15\xd9\x7b\x35\xdd\xfb\x74\xdb\x7e\x45\xa5\x5b\xef\xb0\x0f\x59\xfa\xe5\xfd\x0a\x6e\x18\xfc\x76\x6e\x5a\x25\xec\x67\xee\x74\xa9\xdd\x46\xff\x2b\x87\xf0\x45\x23\x4e\xf0\x00\x62\xde\xdc\x84\x4c\x24\xd0\x50\x2e\x7f\xaa\xb1\xc9\x3d\xf3\xbd\x85\x69\xaf\xd9\xec\x46\xaa\xe5\x68\xe0\x8d\xf9\xeb\xce\x27\x62\x77\xfe\x7b\x37\xc8\x5b\x5a\xd8\xd7\xae\xf2\x3c\x51\xe0\xb9\xa8\x23\x5a\x05\x98\xa1\xe5\xb3\xe2\xa4\x1a\x53\xc1\xff\x8d\xc9\xb1\x89\xdd\xc7\x52\xd9\x3f\xf7\x30\x72\x81\x16\x7d\xc6\x12\xb3\xef\xf8\x6f\xa9\xdc\xbb\x87\x41\x69\x9a\x72\xd4\x2b\xce\xef\xe1\xa5\xbb\x89\xc0\xc5\xf5\x63\xd0\xfc\x8e\x8d\x75\x3f\xef\xdf\x1d\xfa\x5c\x41\x36\x97\xea\x8e\xec\xa6\x3b\x7f\x9f\x53\xee\x3a\xba\x6e\x1c\x55\x58\x4e\x79\xd3\xd7\xc2\xab\x05\x5d\x73\x6a\x4a\xc5\xcd\xd2\x03\xe9\xee\x1f\x72\xf1\x63\x39\x64\x2e\xda\xfb\xe0\x9f\x0b\x48\xde\x3b\x3c\x3f\xed\x76\x39\x16\xe1\xa5\xdd\x04\xad\x46\x43\x4a\x41\xf3\x21\x1f\x97\xb2\xd4\xd9\x2c\x76\x57\x52\x08\x56\x5b\x73\x1f\xfd\x35\x62\xd7\x10\x2a\xa4\x98\xe5\xee\x56\x91\x64\x65\xca\x6a\x23\x42\x4c\x6f\x2a\x79\x4a\x68\x69\x64\x4e\x0d\x4f\x48\x22\xf1\xbb\xfa\x48\xa5\x66\x84\xde\xf2\xdb\xa4\xd4\x46\xe6\x24\xa7\x4a\x4f\x68\x96\xdd\xb6\xc6\x1d\x9c\x6a\x77\x01\x68\xf7\xe1\xfd\x6f\xfd\x72\x8a\xb3\x6e\xc8\xdf\xf7\xe0\x85\xaf\xc0\xdf\x76\x72\xad\x06\x98\xde\xce\xa5\x2b\x8c\xe1\x4a\xe2\x97\xc2\xf5\xdc\xb3\x30\xf7\x51\xe7\xae\x9d\x7b\xef\x7b\xdd\x21\x0d\xef\xfc\x2d\xa4\xce\xb2\xf4\x34\xa7\xe3\x15\x14\xc9\x37\xd6\x6e\xa0\x62\xe6\x7f\x86\x28\x92\xba\x47\xa4\x72\x39\x20\xa1\x27\xb7\xfb\x2a\x00\x90\x2a\xf2\x0e\xc2\x6c\x52\xb9\x64\x6a\xc7\xa5\x90\x5a\xcf\xd4\x48\xaa\xdc\xea\x75\x5c\x91\x51\x29\xd0\xb4\x70\xb9\xd7\x60\xac\x38\x2f\x0e\xcd\xb4\x0c\x3b\x10\xe2\x76\xc2\x4f\x82\x50\x4d\x6e\x58\x96\x0d\xc8\x61\x96\x39\x78\xcb\x08\x1a\xa1\x2a\x79\xae\x32\x04\x86\x33\x92\xf2\x31\xd3\x86\xec\x5d\xfe\xed\x70\x1f\x4e\x6d\xf0\x70\xcc\x88\xa1\xbe\x4e\xac\xee\xb9\x81\xf3\x3f\x2d\x41\x4f\x48\xa8\xa1\x99\x1c\x63\x90\x1c\x3c\xb8\x22\x25\x45\x46\x67\x00\x52\x5f\x50\x05\x89\xa2\x09\x7a\x6f\x88\x2a\x05\xc0\xf3\x7e\xd2\x13\xe7\x7e\x51\x70\x17\x82\x6e\x1f\x78\xb2\xe1\x56\xbf\x07\xb5\xf4\x71\x8f\x32\xc5\x8a\x8c\xde\xe2\x6f\xb8\xa3\xec\xd7\xaa\xb9\x60\xc2\x4a\xc1\xc2\x18\x03\x72\x89\xbc\x93\x53\x93\x60\x08\xf3\x9f\x39\x33\x34\xa5\x86\x0e\xac\x2d\xf8\xcf\x7a\x61\x9a\xcc\x52\x3b\xd0\xed\x0b\x7d\xcb\x9c\x51\x5f\x5c\xde\x8c\xbd\xbe\x0b\xad\x52\x1b\x6e\x07\xfd\xdc\xef\xc7\x3b\x1d\x1c\x2d\xe5\x13\xbc\xfe\xc9\x47\x6b\x8a\xdd\x19\x5d\xab\xcd\x75\xfe\x47\x75\xff\x43\x56\x7f\x13\xc7\xad\x39\x03\x5c\xc4\x2b\xd7\xcf\xc7\x7f\x02\xce\xd5\xc3\xb3\xe3\xdb\x1d\x61\xf7\xbb\x0c\xee\x71\x11\xd4\x43\x06\x77\x4c\xcf\xbb\x9e\xdd\x37\xf5\xb8\x81\x2f\x4e\x81\xfa\x3d\x2c\xf5\xa0\x1e\x3c\xc5\xdf\x8c\x0b\x56\xaf\x3c\xc4\xdf\xdd\xee\x1f\x59\x29\x70\xb3\x4a\xb8\xe6\xbe\x42\xaf\x7e\x98\xec\xad\x37\xad\x16\xbd\xb9\xb7\x18\xab\x46\x70\x57\xed\x08\xc5\x95\x40\x79\x28\xd9\xf0\xce\xd3\x40\xec\x55\xa3\x5d\x2b\xfa\x77\xfc\xab\x3e\x60\xa2\x61\x29\x6b\x69\x44\xd7\x6c\xb6\xab\x5d\x2d\x8a\x14\x7a\xc2\x0b\xac\x16\x74\x01\x0a\xb7\xba\xe4\x27\x9a\xf1\x34\x0c\x81\x5c\x7d\x2a\x7a\xe4\x4c\x1a\xfb\xcf\xc9\x47\xae\x0d\x9a\x9f\xc7\x92\xe9\x33\x69\xe0\x93\x4e\x5e\x15\xa7\xf0\x80\x17\x75\x06\x30\xfa\xb8\x61\x5f\x45\x66\xb2\x7f\xa1\x53\x27\xf6\x3c\x51\xb8\x26\xa7\xc2\x6a\x04\xee\x8d\x42\x15\xad\x76\x43\xf8\x42\x11\x21\x45\x1f\xbc\xdf\x4b\xc7\x70\x84\x90\xaa\x46\x87\x3b\x86\x73\x43\x61\x3a\x1f\x7c\xc3\xb5\x17\xe2\xe1\xcc\xa6\xde\xed\xc6\x13\x92\x33\x35\x86\x78\x4e\x72\x4f\x3c\x63\x55\x57\xe4\x4a\x0e\xc8\x7b\xd7\x0a\x44\xe6\x9b\x5b\x1d\x17\x0b\x8b\x14\xdd\x8f\x62\x29\x47\x6f\xc6\xff\x58\xe9\x03\x94\xfa\x5f\x28\xa5\xd6\x03\x72\xe8\x9b\xa5\xc4\xdf\xb9\xb8\x56\x3c\x8c\x1d\x81\x6b\x62\x45\xc9\x94\x66\x0c\x91\xe3\xa9\x08\x55\x50\x72\xb4\x20\xd8\x7b\xae\xa4\xda\xee\xd9\xa0\x32\xed\x5c\xb3\xd9\x4e\x6f\x61\x69\x77\x4e\xc5\x4e\x55\x02\x57\x5b\xcc\x20\x44\x41\xdb\xda\x81\xef\x76\x9a\x9f\x05\x77\x0a\xcb\xd5\xdd\x2b\xf7\xae\x9b\xbe\xe6\xcb\x03\xd3\x4b\x95\x8d\x3d\xbd\x6f\x49\x08\xc1\x60\x45\x72\xa9\xc0\x9d\x69\x3f\x8d\x81\x34\xac\xaa\x7a\xcd\x8b\xa2\xc2\x1d\x29\x8b\xb1\xa2\x29\x23\x63\x45\x8b\xc9\x43\xd5\x12\xd4\x6d\x96\x0d\xff\x64\x14\xdd\x5b\x88\x7f\x87\x45\x57\x23\xbf\x37\x40\xbc\xe1\x0d\x9b\xe5\x46\xd1\xa2\x60\x8a\x50\x25\x4b\x70\xda\xe5\x53\xa6\x06\xfe\x16\x4c\xb9\x08\x7e\xe6\x44\x2a\xc5\x12\xe3\x4d\x74\x97\x15\x8c\x05\xab\x22\x85\x6a\xd4\x07\xab\x7d\x37\x6c\x38\x91\xf2\x1a\xaa\xe6\x80\x1d\x1f\xd1\x0b\xf2\x33\x3e\xeb\xb8\xfa\xcc\x1b\xb4\x9a\xa4\xcc\x50\x9e\x41\xae\xc9\xbb\x37\x6f\x5d\x36\x8a\xd7\x26\xfc\x2c\x97\x27\x76\x74\x60\x86\xd0\xd4\x65\x49\x5d\xb0\x29\x67\x37\x8e\xfe\xb7\xe5\x91\xf4\xc9\x98\x09\x48\x9e\xb8\x23\xc9\xa8\x4f\x34\x4f\xd9\x09\x14\xe3\xde\x3e\x50\x0b\xf7\xfd\x2d\x73\xbe\x4f\x84\xdc\x7d\x8e\xdc\x7b\x86\xac\x70\xd6\x07\x23\xfc\x5c\xaa\x3b\x80\x7f\x56\xab\x0d\x5e\xad\xee\xd7\x65\xa7\xbf\x22\x5f\x7d\xf5\xe5\xad\x37\xe5\xf4\x23\xcf\xcb\xfc\x15\xf9\xcb\x9f\xff\xfc\xe5\x9f\x6f\xbf\x8d\x0b\xbc\xed\xe5\xed\xef\xe7\xf6\xfc\xd1\xc5\xf1\x06\xd0\x3b\x0d\xd9\x7e\x77\x87\x06\x57\x18\x6a\x44\x79\x56\x2a\x97\x92\xba\xa2\xa1\xf2\x3a\xfe\x0d\x84\x75\xaa\x62\x0a\xea\x47\xf4\xc9\x68\x2e\x49\x6d\xc4\x05\xd3\xd0\x1a\xa5\x14\x8a\x25\x72\x2c\xf8\xbf\x59\xea\x3b\xa3\x40\xe2\x09\x00\xac\x7b\x16\x27\x4c\xa4\xd8\x93\xd2\x9e\xbc\x13\x2a\xd2\xec\xae\x84\x84\x15\xde\x34\xde\xc1\xad\x48\x06\xe7\xdf\x83\x08\xf6\xb6\xfa\xc5\x1c\xb9\xa0\xb3\xa6\x0b\x82\xe1\xb9\x8a\x64\x6b\xf5\xa6\x28\x18\x2f\xef\x30\xef\x97\xcc\x71\xc1\xfa\x44\xc3\x19\x3e\xfb\xad\x64\x6a\x06\x85\x23\x95\x79\x11\x25\xaa\x5d\x55\xb8\x02\xfe\x35\x9c\x5e\x87\x48\x2e\x73\x16\x79\xa5\x4a\x55\xe9\x28\x73\xcf\x86\xdf\x30\x0c\xe2\xfb\x70\x16\x39\x24\xa2\xcc\xb2\xdb\x6e\x15\xf2\xae\xc0\x57\x4c\xbb\x7b\x0c\xda\xd5\x2c\xcd\x55\x9d\x13\x4b\x28\xfd\x49\x5d\x14\xf1\x8b\x77\x64\x50\x6c\xb6\xd3\x22\x7e\xe1\x95\x72\x4e\x57\xcf\x37\x5d\x0d\xaf\x66\x05\x67\x06\x5e\x0f\x49\x48\x5d\x11\x65\xe6\x31\xdd\x1b\x78\x3d\x28\x7f\x68\x35\x57\xc7\x92\xa9\x6f\x9c\xc3\xa3\xc1\xcb\xaf\xe2\xfc\x58\xf2\xea\x5b\x17\xc8\x02\xc1\x57\xcd\xc9\x7a\x40\x3e\xd6\x8a\x2b\xb9\x82\x6b\x04\xaf\xad\x83\xe4\x41\x27\xd1\x0a\x82\xf9\x61\xce\x92\x95\x57\x55\x31\x2e\xa6\x12\x51\x9a\x1f\xa4\xc3\x5d\x2c\xfc\x70\x4e\x95\xbb\x01\xc9\xea\x74\xb9\xa0\xfc\xc6\x2a\xad\x35\x68\x49\xa9\xef\x77\xb9\xdf\xfd\x06\x77\xd7\xa6\x74\x62\x83\xd4\xdf\xbc\xcc\xd8\xcf\xdc\x4c\xde\x79\x34\x76\xc7\xd5\xa6\x2c\x32\x78\xd9\xe8\x0b\xcb\x42\x17\x95\x66\x78\x8a\x1d\xbc\x58\x22\xf3\x9c\x89\x14\x53\x99\x72\x7a\xcd\x48\xd5\x08\xd2\xea\x78\xa0\x06\xc3\x70\xec\x63\x41\x45\xa5\x27\x4e\xad\x2c\xbf\x8b\xa3\x56\xe4\xa7\x55\xcf\xda\x95\x8b\x3e\xee\x2e\xf6\x88\xaa\x35\x6a\x45\x1d\x64\xc8\x32\x09\x4e\x1c\xcc\x57\xc5\x5c\x6b\x77\x2b\x88\x64\xf7\xa9\x3b\xf5\x1c\xf2\x23\x13\xe3\x0a\x67\x4a\x67\xd0\xa4\xd5\x49\x60\x29\xd8\x80\x5c\x38\x15\x66\x35\xad\x68\x15\x71\xba\xa2\x28\x5d\xf9\x40\xac\xb0\x19\x1e\x4c\x59\xff\xbb\x98\xb6\x53\xff\xd9\x2a\xd4\xf5\x37\x3f\x67\xfa\x86\x4e\x09\x0f\x23\x6f\x7d\x4b\x57\xa7\x42\xa0\xed\x9c\xf0\x4a\xb0\x05\x30\xb8\xea\xfa\xe4\xe8\xe2\xe4\xf0\xea\xa4\x47\xde\x9f\x1f\xc3\xbf\xc7\x27\x6f\x4e\xec\xbf\x47\xef\xce\xce\x4e\x8e\xae\xac\x1e\xf1\x19\xe2\xc0\x5b\x33\xce\x52\xd7\x9e\x47\xb2\x2e\x2d\xa8\x98\x91\x51\x69\xac\x38\xa8\x1e\x56\x9b\x05\x45\x1f\x00\x4d\x53\x6b\x32\x3e\xb9\x35\x5c\x4e\xf0\x79\xb7\x49\xdc\xec\x02\xa1\xf3\x5d\x31\xd7\xfd\x6a\xd2\xca\x4c\xb2\x72\x55\x44\x6d\xca\x3b\x0d\xcb\x21\x3e\x08\xf2\x5a\x2a\xe2\xfa\x7c\xbd\x22\xbb\x85\x4c\xf5\xae\x2b\x3a\xb1\xff\x3d\xc0\x8f\x0e\x32\x39\xde\x0d\xb5\x28\x8c\x64\x72\x4c\x74\x39\x0c\x35\x42\x70\x9a\xc2\xdd\x9f\xf9\xdb\x6a\xa5\x15\xbd\x50\x28\x14\xfd\x2a\x0c\x5e\xfb\x4d\x7c\x43\x3c\xee\x01\x34\xf9\xaa\xdd\x69\x3f\x98\x1f\xf0\xb3\x83\xe5\x33\xf0\x8a\x13\x57\x73\xbf\xf8\x20\x2c\xbb\xde\xf0\x2c\x4d\xa8\x4a\x17\x78\x16\x0e\x37\x5c\x72\xa0\x1e\xe2\xe6\x62\x8f\xe4\x6a\x70\x07\x9e\x21\xa7\x4c\x65\xb4\xc0\x3c\x75\x00\x2e\x86\x04\x28\x78\xc8\x31\x2b\x18\xd4\x69\xf9\xae\xdd\x4c\x24\x99\x04\x9c\x0e\x3c\x19\x7b\xf5\x57\xc7\x84\x28\x0f\x4a\xe8\x8a\x7d\xaa\x1d\xb2\xb3\xb1\x62\x0e\x92\x9d\x1f\xc4\xbd\x98\x1e\x7d\x2b\xd8\x4b\xa8\x1e\x41\xa3\x31\x68\xbe\x8c\xec\xb8\x2a\xb8\x9d\x1e\xd9\x09\x78\x26\xa9\xd3\x92\x77\x3e\xdb\xa9\x6e\x88\xeb\xa8\x40\x49\x76\x81\xa9\x3e\x3c\x27\xae\xb6\x84\x05\xf6\xe1\xb3\xf0\xe8\x0a\x93\xc6\x1e\x6d\xce\x89\x05\x73\xa8\x0f\x34\xa8\x4d\x64\xe1\xa9\x55\x09\xe0\xbd\x4f\xb4\xd3\x8f\x7e\x6e\xa0\x5c\x1e\x4b\x09\x1d\x71\x54\x54\x71\x33\x20\x97\x35\xe6\x09\xe1\xbf\x18\x34\x87\x2b\x52\x50\x65\x4d\x11\x7f\x67\xbd\x5f\xd8\x67\xf7\x76\x0b\x5b\x81\x09\xa2\xf8\xca\x8a\x5a\xfb\x65\xf8\xc5\x51\x46\xb5\x5e\xe2\x79\x05\x41\x60\x07\x26\x0c\x47\x26\xd4\x07\x9f\x00\x84\x7a\x42\xa7\x77\xc0\x25\xac\x30\x69\x43\xd5\x98\x99\xbb\x23\x23\x54\xcc\xde\xdd\x09\x93\xd6\x5f\x19\x58\xb5\xbf\xda\x6e\xfa\xd8\xaf\x40\xb9\xfa\x5c\x98\xbe\x54\x7d\xfc\xc9\x2b\x62\x54\x79\x5b\x8c\xcb\xf0\x9c\xc9\xd2\x5c\xb2\x44\x8a\xe5\x75\x15\xee\xbe\xce\x42\x3d\x0f\x28\x36\x71\xd1\xc6\x43\xaf\x46\xf8\x8a\x93\xd8\xc9\x5e\xe9\x18\x3e\xc2\x58\x07\x69\x79\xf7\xe6\x6d\x9b\xc5\x26\x50\x66\x7d\xf7\x4a\xfe\xe4\xc4\xbe\x18\x87\x99\xba\x99\xdf\xf9\xb3\xb7\xa5\x79\xf8\x8f\xfe\x3f\xe6\xae\x2c\xb7\x6d\x1e\x08\xbf\xe7\x14\x7c\xfb\xff\x02\x8d\x7b\x86\xc2\x79\xeb\x82\xc2\x4e\x0f\xc0\x48\x74\x2c\xd4\x96\x0c\x52\x8a\xbb\xa0\x77\x2f\x38\x33\xa4\x4c\x99\x9b\x22\xd9\xb1\x1e\x6d\x72\xb8\x88\x43\xcd\xfa\xcd\xd2\x7a\xae\xe2\xad\x69\x33\xe2\xc0\x1c\xc1\xf5\xab\x96\xb7\xdd\xd9\x69\x70\xde\x0d\x5d\x96\x6b\x4c\x6c\x23\x99\x7e\x0d\xfd\x4e\x8d\x7c\xe7\xf8\x04\x88\x73\x0b\xed\x4c\xc8\xe4\x82\x51\x47\xcd\x9f\xad\xe4\x15\x2a\x90\xbc\x68\x3b\xc8\x9d\xe6\x2d\x85\x57\x12\xbc\xce\x9d\x6f\x19\x5e\x95\x31\xa6\x26\x16\x42\xb6\xea\x33\x57\xed\xf7\x43\xc9\x03\x39\x54\x83\xb0\x49\xd5\x02\xc3\xa0\x60\x7d\xac\x45\xa9\x6f\x78\xda\x02\xa4\xc7\x8e\xfa\xea\xed\x90\xe2\x58\x4f\x7e\xcf\x40\xba\xfb\xbd\x1e\xca\x3f\xeb\x55\xa3\xf7\xe4\xa3\xf7\x02\x72\x03\x46\x52\xb3\xd5\x9f\x13\x09\xd4\x58\x2d\x7e\xfa\x34\xee\xe9\x33\xde\x09\x5e\xfb\x83\xf6\x07\x27\x0a\xda\x8d\x3f\x43\x34\x00\x3b\x6e\x2b\x2d\xb2\x62\xae\x99\x62\x46\x84\x2a\xc5\x4e\x04\x52\xce\x26\x06\xb4\xd2\x08\x0f\x34\x40\x56\xb0\xd5\x37\xb7\x8f\x35\xe8\x93\x10\x4e\x29\x1c\xbd\xb0\x4c\xd2\x83\xd5\x9a\x86\xab\x02\xf1\xe5\x69\xd7\x14\x3f\x10\x64\x0c\xf0\x06\xaa\xdf\x42\x9a\xe8\xf7\xca\x56\xf5\xa2\xca\x53\xcf\xa6\x2a\xa6\xd9\x37\x53\x7e\x08\xa8\x68\xda\x7a\x03\x2d\xfd\x46\xf6\x96\xc5\xae\xa6\x1c\xbe\xeb\x04\xd0\x1a\x45\x05\xb2\x06\x1c\xcf\xc1\xb9\xce\x82\x81\x36\x80\x81\x48\x2a\x23\xdf\x53\x8e\xcd\x87\x4f\xe1\x7c\x94\x59\x83\x62\x63\x59\x31\xd8\x02\xb6\xaf\x2e\xa2\x50\x38\xd1\xfc\x99\x5c\xcb\x57\x22\x4f\x86\xe5\x0b\xe9\x76\xca\x39\xd4\x66\x0d\x71\x9c\xdd\xdb\x17\x4c\x46\xe8\x9f\x31\x3e\xbc\x5c\xf0\xd5\x51\x5e\xa6\x7a\x0c\x48\xa6\x0b\x6e\x62\xd5\x0e\x4a\x35\x45\x4f\xfc\xa6\x91\x41\x05\x66\xbe\xc9\xc7\xb3\xaa\x92\x84\xb4\xf4\x19\x8e\x5d\x3b\x4f\x21\xd2\xb7\x97\xed\xf2\x9e\x71\xb6\xad\x54\xdb\x48\x72\xad\x41\xf1\x30\xc9\xa1\x42\xa9\x3f\x06\x6c\x9e\x68\xb8\xa5\x9d\x02\xe3\x87\x83\xe0\xb6\xd8\x10\x7d\x9b\xa0\x5a\x90\x14\x45\x23\x4b\xef\xc4\x8c\x76\xef\x95\xa5\xbc\xc3\xcf\x90\x21\xba\xe3\xaa\x7d\xb4\x73\xd0\x02\x42\xe6\x6d\xec\x8a\x3f\xb4\xc4\x7e\x35\x06\x6e\xa6\xa9\xfb\x3f\x1b\xc6\x6b\xb4\x6a\x4c\x93\xc1\xd3\x42\x46\xbf\x36\x94\xe6\x5e\xb5\xae\xa3\x95\xdc\x4e\x96\x78\x9d\x99\xef\x85\x52\xd1\x74\xa7\x41\x90\x06\xe0\x04\x33\x8b\x13\x4c\xdd\xcd\xc7\x1e\x05\x04\x0c\xc7\x34\xa8\x60\xbf\xc2\x47\x8d\x81\x98\x80\x06\x05\xcb\x56\x93\x5e\xd9\x61\xcb\x55\xee\x62\x2c\x17\xd9\x40\xe3\x6c\x76\xc8\x9c\x8d\x14\x5c\xc5\x12\x36\x07\x7b\xfb\x24\x2b\xb1\x61\x4b\xbe\x17\xbb\x25\x57\x73\x6e\x2e\xdc\x00\x0b\x26\x16\xcf\x0b\xf6\xdf\xea\xc4\xdb\xfa\xb5\x69\xbf\xc4\x0a\x36\x24\x30\x0a\x72\x38\xfa\xa2\xbc\x3c\x59\x49\x48\x73\xee\x44\x9e\x9d\x3c\xc3\x08\x87\xde\x04\x6f\xc6\xb3\x8e\x43\xfc\xe8\x72\x62\x27\xc1\xe2\x57\xbc\x96\x23\x13\x29\x95\x21\x2e\xbc\x65\xfe\x4b\x2c\xc9\x92\x58\x7b\x4d\x26\x67\xab\x7b\x74\x34\x57\x30\xfb\x9f\x06\xd8\x61\x65\xfe\x4a\x69\x15\x6c\x4e\xb1\xe5\x6d\x53\xfe\xe9\x05\x06\xff\x8f\xc8\xe5\xf7\xf1\xaf\xf0\x54\x38\x81\x12\x1c\x2d\xfa\x04\x5c\x33\x00\xe3\xc1\x8c\x4a\xb6\x0e\xb2\x01\xd0\xb9\xd8\x50\x95\x33\x6a\xe3\x9c\x8f\xff\xa1\x8e\x9c\x78\xc1\xaa\x8d\x90\xf0\x21\x58\x2d\x94\x66\x8a\x77\x91\xe1\x33\x15\xaa\x3c\x65\x2a\xad\xe8\x26\x95\x58\x96\x7e\xb5\xa6\x51\xec\x05\xe3\x93\xab\xb3\x65\xe8\xc4\x23\x94\xb5\xb4\xc6\x33\x82\x58\x52\xfc\x1b\x49\xcf\x6f\xc0\x1d\x3e\x03\xe4\x61\xdd\x65\x05\x97\x34\x3a\x86\x0b\x7d\x03\x17\x80\x3e\x8d\x77\x37\x5d\x4f\xae\xfd\x76\x35\xbc\x03\x21\xdc\xd0\x3d\xe1\x73\x2d\xab\xeb\xaa\xf9\xf6\x3c\x89\xe3\x91\x4d\xef\x06\x40\x49\x92\x07\xe8\xb2\x70\x09\xf8\xa4\x4e\xdd\xdb\x9f\xb7\x1c\x58\xa8\xe8\x19\xbb\x10\x3e\x8c\x12\xf2\x45\x94\x8e\xa7\x8e\xb0\xe5\xdd\xdf\x4e\xfc\xb6\x3d\x7d\xda\x76\xf6\xe7\xef\xdd\xbf\x00\x00\x00\xff\xff\x12\xac\x7d\xb1\x7e\x88\x07\x00") +var _operatorsCoreosCom_clusterserviceversionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xfd\x7d\x77\xe3\xb6\xb5\x28\x8c\xff\xdf\x4f\x81\xe5\xe6\x5c\xdb\x27\x92\x3c\xd3\xf6\xf4\xd7\xce\xaf\xcf\xc9\xf2\xb1\x9d\xc4\x4f\x66\x3c\x5a\x63\x27\xb9\x5d\x49\x4e\x0a\x91\x5b\x12\x8e\x49\x80\x05\x40\xd9\xea\xcd\xfd\xee\xcf\xc2\x06\x40\x82\x7a\xb1\x25\x91\x33\x96\x3d\x40\xd7\x6a\xc6\x22\x09\x82\x1b\x1b\xfb\xfd\x85\x16\xec\x07\x90\x8a\x09\xfe\x86\xd0\x82\xc1\xbd\x06\x6e\xfe\x52\x83\xdb\xbf\xa8\x01\x13\x27\xb3\xd7\xbf\xbb\x65\x3c\x7d\x43\xce\x4a\xa5\x45\xfe\x01\x94\x28\x65\x02\xe7\x30\x66\x9c\x69\x26\xf8\xef\x72\xd0\x34\xa5\x9a\xbe\xf9\x1d\x21\x94\x73\xa1\xa9\xf9\x59\x99\x3f\x09\x49\x04\xd7\x52\x64\x19\xc8\xfe\x04\xf8\xe0\xb6\x1c\xc1\xa8\x64\x59\x0a\x12\x27\xf7\xaf\x9e\xbd\x1a\xfc\x65\xf0\xea\x77\x84\x24\x12\xf0\xf1\x1b\x96\x83\xd2\x34\x2f\xde\x10\x5e\x66\xd9\xef\x08\xe1\x34\x87\x37\x24\xc9\x4a\xa5\x41\x2a\x90\x33\x96\x80\x7b\x5e\x0d\x44\x01\x92\x6a\x21\xd5\x20\x11\x12\x84\xf9\x4f\xfe\x3b\x55\x40\x62\x56\x31\x91\xa2\x2c\xde\x90\x95\xf7\xd8\x79\xfd\x62\xa9\x86\x89\x90\xcc\xff\x4d\x48\x9f\x88\x2c\xc7\x7f\x3b\x20\xd8\xd7\x5f\xdb\xd7\x3b\xc8\xe1\xf5\x8c\x29\xfd\xdd\xfa\x7b\xde\x32\xa5\xf1\xbe\x22\x2b\x25\xcd\xd6\x7d\x08\xde\xa2\xa6\x42\xea\xab\x7a\x59\x66\x19\x89\x9a\x85\xff\x76\x37\x32\x3e\x29\x33\x2a\xd7\xcc\xf6\x3b\x42\x54\x22\x0a\x78\x43\x70\xb2\x82\x26\x90\xfe\x8e\x10\xff\x2e\x3b\x79\x9f\xd0\x34\xc5\x8d\xa4\xd9\x50\x32\xae\x41\x9e\x89\xac\xcc\x79\xf5\x72\x73\x4f\x0a\x2a\x91\xac\xd0\xb8\x59\x37\x53\x40\xa8\x11\x31\x26\x7a\x0a\xe4\xec\xfa\x87\xea\x56\x42\xfe\x47\x09\x3e\xa4\x7a\xfa\x86\x0c\xcc\x06\x0c\x52\xa6\x8a\x8c\xce\xcd\x12\x82\xbb\xec\x6e\x9e\xdb\x6b\xc1\xef\x7a\x6e\xd6\xab\xb4\x64\x7c\xf2\xd0\xfb\xdd\x47\x6c\xb6\x84\x59\xb0\x4f\xe1\xeb\x7f\x58\xfa\x7d\xd3\xd7\xfb\xcf\xa7\xe6\xcd\x44\x4f\xa9\x26\x7a\xca\x14\x11\x1c\x88\x84\x22\xa3\x09\xa8\x07\x16\xb4\xe2\x16\xbb\xa2\x0f\xcb\x17\xd6\x2c\x29\x9c\x52\x53\x5d\xaa\x41\x31\xa5\x6a\x19\xc4\xc3\x85\x5f\x57\x4c\x67\x6f\x9c\xbd\xa6\x59\x31\xa5\xaf\xdd\x8f\x2a\x99\x42\x4e\x6b\x1c\x10\x05\xf0\xd3\xe1\xe5\x0f\x7f\xbc\x5e\xb8\x40\x9a\xd0\x59\x89\xfd\x84\x29\x03\x2a\xa4\x20\xc4\x93\x10\xdc\xbb\x79\x01\xe4\x1f\x2b\x9f\xb9\x2e\x20\xf9\xc7\x60\x69\xe5\x62\xf4\x3f\x90\xe8\xe0\x67\x09\xff\x2c\x99\x84\x34\x5c\x91\x01\x90\x27\x4b\x0b\x3f\x1b\xf8\x07\x3f\x15\xd2\x90\x05\x1d\x1c\x79\x3b\x02\xba\xd8\xf8\x7d\xe1\x6b\x0f\x0d\x48\xdc\x37\xa6\x86\x24\x82\x42\x7c\x74\x18\x07\xa9\x83\xa3\xc5\x53\xa6\x0c\x72\x48\x50\xc0\x2d\x91\x44\x14\xe2\xee\x9b\x06\xc4\x00\x00\xa4\x32\x04\xa0\xcc\x52\x43\x3b\x67\x20\x35\x91\x90\x88\x09\x67\xff\xaa\x66\x53\x44\x0b\x7c\x4d\x46\x35\x28\x4d\xf0\xd4\x72\x9a\x91\x19\xcd\x4a\xe8\x11\xca\x53\x92\xd3\x39\x91\x60\xe6\x25\x25\x0f\x66\xc0\x5b\xd4\x80\xbc\x13\x12\x08\xe3\x63\xf1\x86\x4c\xb5\x2e\xd4\x9b\x93\x93\x09\xd3\x9e\xea\x27\x22\xcf\x4b\xce\xf4\xfc\x04\x09\x38\x1b\x95\x86\x70\x9e\xa4\x30\x83\xec\x44\xb1\x49\x9f\xca\x64\xca\x34\x24\xba\x94\x70\x42\x0b\xd6\xc7\xc5\x72\xa4\xfc\x83\x3c\xfd\xbd\x74\x9b\xac\x0e\x17\xc0\xb7\x12\x9d\x89\x27\xb0\x0f\xc2\xda\x90\x57\x8b\x49\xf6\x71\xfb\x2d\x35\x48\xcd\x4f\x06\x2a\x1f\x2e\xae\x6f\x88\x5f\x80\x3b\x97\x08\xe1\xfa\x56\x55\x03\xdb\x00\x8a\xf1\x31\x48\x7b\xe7\x58\x8a\x1c\x67\x01\x9e\x16\x82\x71\x8d\x7f\x24\x19\x03\xae\x89\x2a\x47\x39\xd3\x0a\x71\x0e\x94\x36\xfb\x30\x20\x67\xc8\xf4\xc8\x08\x48\x59\xa4\x54\x43\x3a\x20\x97\x9c\x9c\xd1\x1c\xb2\x33\xaa\xe0\xa3\x83\xda\x40\x54\xf5\x0d\xf8\x36\x07\x76\xc8\xb3\x97\x1f\x58\x3a\x63\x84\x78\x5e\xba\x76\x77\xd6\x9e\x61\x92\x42\x92\x51\x69\x85\x02\xa2\x21\xcb\xc8\xfb\xb7\xef\xc8\x54\xdc\x19\x2c\x66\x5c\x69\x9a\x65\x78\x0a\x1c\x7f\xb6\xe4\x34\xa1\x9c\xe4\x94\xd3\x09\x10\x5a\x14\x8a\x8c\x85\x24\x94\x4c\xd8\x0c\xb8\x3f\x5d\x83\x4d\x17\xbf\x8e\x48\x10\x4b\xdc\x57\x32\x28\x7f\xd5\x2d\x70\xe1\xca\x3a\xb2\x61\xc6\x92\x0c\xf4\x00\xd4\x4e\xeb\x7b\x11\xb3\x39\x29\xb9\xd2\xb2\xc4\xcd\x4e\xc9\x2d\xcc\x1d\x92\xe7\xb4\x20\x4a\x0b\xf3\xe3\x1d\xd3\x53\x42\x43\x04\xa7\x1a\xb1\x78\x04\x44\x81\x26\xa3\x39\x31\x62\x1c\x12\x04\x2d\x44\x86\xd4\x02\x9f\x45\xc2\x20\x41\x4b\x06\x33\x20\x54\x8e\x98\x96\x54\xce\x2b\x6c\x58\x04\xe8\x23\x40\xc5\x8f\x0d\x84\x87\xf5\x20\x21\x0f\xe1\x22\xb1\xe4\xd6\xc9\x2e\x69\x25\x58\x6e\x00\xbd\xe1\xa5\xc3\xb7\x5a\x1c\x55\x0e\xdf\x40\x11\x83\x57\x4e\x3e\xa8\xe4\x5a\x7c\x93\x43\xac\x94\x08\x59\x61\x86\x01\x5b\x88\x84\x23\x30\xe4\x44\x52\x6e\x2e\xac\x44\xee\x1d\xa0\xf5\x10\xda\x98\x21\xee\xf8\x2a\x1c\x0d\xe7\xa6\x52\x36\x04\xa6\x70\x30\x0d\xf9\x9a\x99\x1f\x84\x5d\xf5\xb3\x59\xe0\x8c\xa5\x60\x80\xa8\x29\xb3\xa8\x63\x4e\x2b\x1d\x89\x52\x5b\xd8\xb9\x5b\x52\x32\x63\x94\xd0\xc9\x44\xc2\x04\x11\x78\xed\x6b\x1f\x81\x89\x1d\xeb\x0f\x68\x3d\xfa\x56\x92\x7f\xf0\x0e\x43\x06\x1f\xbc\x81\xaf\x3a\xe6\xe1\x0d\xcb\xc2\x62\x73\x3c\xb6\x87\x76\xd0\xc4\xc0\xc4\x83\x56\xc8\x07\x6f\xde\x64\x6f\xed\x78\x64\x87\xed\x68\xee\xf3\xc2\x42\xdc\xd5\x91\x39\x1f\x35\x69\x36\xe4\x00\x6f\xac\x89\xef\x08\x48\x01\x72\x2c\x64\x6e\x0e\x0a\x27\x94\x24\x56\x7e\xab\x08\x0f\x92\x46\x9e\x3c\x04\x4e\xb2\xe9\xfe\xdb\xb1\x09\x16\xd8\xd1\x27\x05\xd5\xd3\x47\x6e\xdb\x6c\xab\xec\x08\x81\xf6\xe8\xcd\x8f\x50\xb3\xa5\xb9\x6b\x0e\xd3\xf9\xdc\x06\x0c\x9d\x4f\x8a\x3c\x67\x93\x59\x1b\xa8\xf6\x81\xde\xbd\x03\xa5\x0c\xcb\x46\x29\x4d\xd2\x3b\x02\x3c\x11\x86\x58\xfc\xbf\xd7\xef\xaf\xec\xb4\x03\x72\xa9\x09\xcb\x8b\x0c\x72\x23\x88\x91\x77\x54\xaa\x29\xcd\x40\x22\x77\xfa\x9e\xe7\x8d\xbf\x1d\x26\x96\x0a\x52\x43\x8b\x52\xc8\xe8\xdc\x4e\x96\x42\x22\x52\x43\xa3\x85\x24\x85\x11\x70\xf3\xa2\xd4\x40\xa8\xbd\x8a\xef\x65\x7c\xb2\x8a\x48\xb7\x02\x0d\x31\x92\x48\x4e\xf5\x1b\x32\x9a\xeb\xc7\x50\x9f\x90\xfb\x7e\xba\x29\x0d\x08\x17\xf3\x38\x25\xb0\x63\x23\x7a\x10\x4e\xfc\xe8\x57\x1a\x21\x94\x32\x0e\x72\x28\xa4\xde\x84\x68\x19\xe5\x63\x02\xf2\xc1\x3b\x3d\xc8\x18\xd7\x7f\xfc\xc3\x03\x77\xa6\x50\x64\x62\x6e\xf0\xe2\xf1\xb3\xb2\xe1\xf7\x6c\x7c\xae\x37\x9d\x6f\xd3\xb3\xbc\xe1\x7c\xd6\x38\xd5\xc5\x4c\xab\x14\xa8\x9d\x26\xe2\x5d\x7d\x5b\xa5\x04\x3e\x19\xf3\x1b\x5e\x7a\x6b\xc3\x07\x18\x83\x04\x9e\x38\xda\xf4\x5d\x39\x02\xc9\x41\x83\x0a\x04\xe9\x79\xe1\x28\x8d\x91\x05\x17\xd9\xdd\xd3\x70\xb9\x47\xe4\x19\x7f\xdb\x23\x52\x8d\xbf\xed\x31\xd9\xc6\x8e\x6d\xd8\xe6\xe3\x48\x67\xc7\x56\x34\xf6\x71\x04\xdc\x61\xd2\xd9\x6a\x73\x4e\x8b\x79\x8d\x4e\xbc\x07\x12\xde\x75\x63\x19\x0d\xf9\x6e\xcc\x20\x4b\x09\x33\xc2\x9b\x59\x2c\x19\x65\x22\xb9\x75\x76\xcb\x0f\xe7\x44\x09\x2b\xee\x19\x09\xdf\x30\xda\x44\x70\x55\xe6\x40\xd8\x63\x18\x1c\x45\xba\x28\xd2\x45\x91\xee\xb9\x88\x74\xd6\x3f\xb0\x0f\x94\x6a\x61\x21\x6b\x69\x15\xde\x17\xa9\xd5\x43\x23\x52\x2b\x1c\x91\x5a\x3d\x32\x9e\x1d\xb5\xda\x48\x4e\x7b\x74\xae\xc7\x0e\x72\x34\xa6\x46\x63\x6a\x34\xa6\xba\x11\x79\x99\x1b\x91\x97\x45\x5e\x16\x8d\xa9\x0f\x4d\x19\x8d\xa9\x5b\x4e\x14\x8d\xa9\xd1\x98\x1a\x8d\xa9\xd1\x98\xfa\xd8\xc7\x44\x91\x2e\x8a\x74\x51\xa4\xdb\x74\x31\xd1\x98\x1a\x8d\xa9\x0f\x8d\x48\xad\x82\x11\xa9\xd5\x03\xe3\x65\x53\xab\xf6\xc6\xd4\x24\x03\xca\x57\x2b\x55\x0b\xf1\xdf\x78\x1f\x8a\x46\x6c\xcc\x5c\x1e\x84\x7b\x9a\x8c\x60\x4a\x67\x4c\x94\x92\xdc\x4d\x81\xfb\x94\x1d\x32\x01\xad\x0c\x16\x80\x86\x55\x82\xf9\x23\xb4\xe6\x61\xfa\xd2\x27\xc0\xe9\x28\x5b\x39\xf1\x63\xa4\xc4\x3d\xf9\xb0\xf1\x78\x24\x84\xf9\xba\x65\x88\xa1\xaa\xe3\x35\x9d\x6d\xe2\x99\x0f\xd6\xe5\xd8\xad\x0e\x6a\x3e\xfb\x70\xde\x55\x28\x33\xf9\x99\x93\xcb\x6a\x56\x82\x96\x69\x4c\x94\x30\x3c\xc4\xfc\xfa\xfe\x8e\x43\x8a\x49\x6e\x3d\xc2\xb4\xb9\xc1\x1c\x7a\x96\x30\x9d\xcd\xab\x17\x0f\x0e\xb6\xdf\xc4\x3d\x0a\x89\x3e\xfb\x70\xbe\xb9\xf9\xde\x6f\xc0\xa7\xb0\xd4\x47\x3b\x7c\xb4\xc3\x57\x23\x8a\x41\x3b\x4e\x1a\xc5\xa0\x07\xc6\xcb\x16\x83\xf6\xdd\x6e\x1d\xad\xcd\x24\x5a\x9b\x1f\xbe\x2d\x5a\x9b\xa3\xb5\x39\xda\x6f\xd6\x8c\x28\xb8\xe0\x88\x82\xcb\x23\xe3\xd9\x09\x2e\xd1\xda\x1c\xa9\x55\xa4\x56\x91\x5a\x3d\x0f\x6a\xf5\x1c\x43\x77\xa3\xd1\x2f\x1a\xfd\xa2\xd1\x2f\x72\xa3\xc8\x8d\x1e\x19\xcf\x8e\x1b\x45\xa3\xdf\xb6\x13\x45\xa3\xdf\xca\x11\x8d\x7e\x8f\x8c\x68\xf4\x8b\x46\xbf\x35\x23\x0a\x2e\x3b\x4e\x1a\x05\x97\x07\xc6\xcb\x16\x5c\xa2\xd1\x2f\x52\xab\x48\xad\x22\xb5\x7a\x1e\xd4\xaa\xbd\xd1\xef\x91\x93\xf4\xf0\xb3\x0f\x9f\x94\x07\x9f\x65\xc9\x43\x2f\x5c\x07\xd1\x07\x20\xf8\x28\xe1\x7a\x8c\x5c\xf5\xc9\x88\x2a\xf8\xf3\x9f\x96\xea\x96\x87\xb7\xe4\x90\x32\x6a\x5e\xb5\xf2\x8e\xc7\x49\x58\xfd\x8a\xf5\x7b\xb6\xc1\xde\x57\xcb\xd8\x71\x16\x57\x58\xf9\xd1\xa0\x58\xb3\xb5\xe9\xa5\xbd\xf9\x5a\x4b\xaa\x61\x32\x0f\x0a\x79\xa3\x4d\xb6\xe6\x3c\x7c\x4d\x01\xfa\x4a\x69\xbc\x9b\x82\x04\x7c\xc8\x97\x9e\x56\x7e\x52\xa6\xaa\xe8\xe5\x74\x87\xe2\xbe\x8f\x85\x23\xfb\xf7\xac\xb8\xfc\xd8\xa6\xad\xaa\xbe\xbd\x12\x58\x1e\x40\xe7\xd6\x7a\x7d\x5e\xa5\x00\x2f\x42\xac\xa0\xd2\x50\x48\x6f\xe5\x46\xa6\x1d\xdc\xbd\x00\xef\x75\x44\x71\x03\x4e\xfd\x38\x87\xee\x07\x99\xca\xeb\x2c\xeb\x9b\x30\x66\xd7\x03\x63\x08\x32\x67\x4a\xad\x0b\xb8\x6e\x2e\xfd\x31\xb2\xb9\x01\xb9\x5c\x03\x7f\xff\x45\xc1\x72\x2a\xf1\x09\x77\x40\x8e\x68\x42\x64\x99\x19\x61\x8a\xa7\xc4\x95\xbf\x26\x34\x49\x44\xc9\x35\xe1\x00\xa9\xb5\x6c\xac\xc2\xd5\x0d\x88\xed\x06\xf2\xd3\xa6\xd2\x53\xdf\xae\xf3\xd1\xbb\xdc\x37\x9c\xda\x4f\x58\x59\x50\x3d\x1c\x9b\x4b\x5b\xf8\xfa\xc7\xb9\xd6\x36\xac\x70\x63\x46\xd8\xd8\xdf\xa1\xc8\x58\x32\xff\x50\x66\x40\xa6\x22\x4b\x15\x96\xf5\x37\xdc\xbd\x72\x38\x84\x22\x72\x81\x77\xe3\xea\x7b\x64\x54\x6a\x92\x0a\x50\x84\x0b\xed\x0b\x03\x34\x1e\xb7\x2e\xa6\xbb\xa9\x6d\xed\x60\x1e\x22\xb4\x28\x32\x4c\xa5\x10\x46\x68\xb9\x9b\xb2\x64\x6a\xfb\xd5\x14\x34\x81\x55\xb7\x6d\x2e\xbd\x6c\x24\x5e\x93\xad\x44\x6c\xe2\x6d\x56\xa3\xc7\x50\x85\x6c\x29\x6b\x13\x5b\x22\xfe\x1b\x29\xca\x62\xc3\xdb\x97\x2d\x8b\xf6\x69\x43\xe5\xf5\x42\x03\x1b\x7f\xd1\xb9\x8c\xec\xde\xd8\xdb\x2a\x93\xe8\x80\x90\xcb\x31\xc9\xcb\x4c\xb3\x22\xc3\x47\x6c\xb5\x01\x45\xa8\x84\x9a\x6f\xf4\x08\xe5\x73\xef\x81\x72\x6d\x22\x20\x25\x74\x62\x66\xd4\xd8\x1f\xc6\x97\xa4\xe7\x65\x0e\xe6\x34\xa7\xf5\x4b\x50\x9d\xe2\xf3\x7a\x76\x72\xc7\xb2\xcc\xc8\xb3\x34\xcb\xc4\xdd\x6a\xb6\xb4\x6a\x6c\x27\x14\x92\xed\x04\x43\xb2\xbd\x08\x4c\x08\x17\xdc\x9b\x76\xbf\xff\xf0\x76\xb7\x4d\xbc\x6a\xce\xe1\x7a\x81\x80\x36\x20\x2d\xa8\xd4\x8c\x66\xa4\x94\x99\xb2\xfb\x48\x8d\x12\x20\x7d\x33\x95\x29\x45\xcf\x60\x02\xca\x76\xed\x20\xff\x6e\x77\xce\x01\xd6\x9e\x4f\xc1\xb3\x39\xa1\x76\xe7\xc7\x65\x96\xf5\xc8\x98\x71\x6a\xc8\x2e\x14\x3e\x13\xc6\xe8\x4f\xe4\x9a\xf1\x04\xcc\x37\xf5\x2b\xc1\x02\x57\x64\x66\x34\xe7\xbb\x3a\xa4\x69\xcf\xb5\x15\xb1\xda\xb2\x72\xaf\x30\x07\x36\xa1\xa3\x0c\xb0\xaf\x85\x13\x59\x3e\x88\x0c\xcd\xdb\xce\xf0\x9d\xda\x5e\x24\x34\xbc\xfc\x5f\x8c\xa3\x92\x42\x3e\x20\xe3\x30\xca\x0e\x30\x3d\x35\xba\x4f\x51\x64\x73\x43\x28\x0c\xee\xd4\x08\x75\xa4\xca\x64\x6a\x3e\xe9\xa0\x10\xa9\x3a\x30\x64\xe4\x40\x41\x22\x41\xab\x83\x63\xf3\xd7\xe2\x37\xe0\xf7\x85\xcf\x9d\xd0\x82\x1d\x1c\xf7\x08\x02\x08\x1b\x9d\x08\x3d\x7d\xbe\x78\xe8\xbf\xb5\xd1\x5f\xeb\xb1\xd1\xd4\x5a\xc3\x19\x5c\xd7\x0e\x51\xd8\x26\x18\x86\x46\x6b\xc0\x3c\x29\x83\x94\x88\x06\xbe\x3d\xd4\x32\xb1\x26\xe4\x94\x13\xc8\x0b\x3d\x47\x2c\xce\x81\x72\x77\x37\xcc\x40\xce\xf5\xd4\x68\xab\x4c\x3d\xff\xc3\xbf\xa1\x63\xa9\x1e\x2b\x01\xee\x0e\xbc\x07\x6e\x8d\xe4\xb6\xb3\xd2\x22\x70\x0f\xff\xfd\x30\x94\x7a\x8d\xf8\x54\x53\xf3\x67\x0b\x4a\x64\xaf\x3b\x81\xf1\x07\xf3\x64\x13\x84\xf6\x27\x4b\x2d\x2b\xfa\xf1\xf6\xad\xed\xa2\xe4\x60\xf5\x1d\xe3\xa9\xaa\x2a\x19\xa5\x96\x0c\x3a\x78\xaf\x04\x32\xae\xf0\x39\x02\x78\x59\x7c\xdd\x54\xe4\x7c\x64\xfa\x40\xbf\xd9\x07\x95\x04\xbb\x32\x35\xa4\x1c\x43\xa7\x7a\xd6\xe5\x64\x74\x91\x8c\x8e\x20\xb3\x2d\x97\xcc\xd5\x7a\xf9\xe4\xf4\xed\xbb\xaa\x3b\x99\x04\xfa\x88\x3d\xeb\x23\x28\x22\x1b\x38\x4e\x97\x7a\xbc\x2d\x8f\xcd\x65\x4f\x04\xc5\x76\xc6\x60\x72\x0d\xda\x1e\xb3\x9c\x16\xe6\x94\xd9\x39\x56\xda\x32\xdf\x22\xa4\x1f\x3f\x2c\x5b\xc9\xec\x9b\xf7\x64\x5a\xf5\x92\x8d\x8e\xca\x66\x1e\xdf\x6d\xce\xde\x03\x16\x8e\x7a\x34\xc0\xbc\x80\xd0\x4e\xae\x77\x92\x78\x52\xf5\xd7\xb3\x18\xac\x6c\x62\xb4\x4d\x43\x97\xfe\xf7\x7a\x8a\x8e\xb7\x60\x1b\xa5\xc9\xe8\xcd\x19\x24\x5a\x3c\x5c\xf6\xcd\xdf\xac\x21\x2f\xb2\xc7\x4e\x1e\xd9\x5a\xc1\xca\x19\xff\x00\x34\x9d\x5f\x43\x22\x78\xba\x21\x81\x6d\xec\xc7\x3b\xc6\x59\x5e\xe6\x84\x97\xf9\x08\x10\xc4\xca\xce\x85\x84\xc4\x2a\xaf\x94\x70\xb8\xcb\xe6\x8e\x78\xa4\xa4\x10\xa9\xa7\x27\x23\xa3\x6c\xd1\x74\x8e\xfd\xcd\xb0\x40\x2a\x9f\x9b\x49\x98\xae\xb9\x8f\x24\x89\xa4\xca\x88\x45\x3d\x9c\x94\x69\xc3\xb1\x46\x80\xbe\x25\x96\x82\xd9\x63\x3a\xa3\x2c\x33\xa2\xf5\x80\x9c\xc3\x98\x96\x19\xb6\xe9\x23\xaf\xc8\x91\x79\x99\xd7\xa7\x56\x3d\x60\xc4\x5d\x25\x8c\x26\xae\x5c\x8e\x3b\x2e\xe8\x78\x0b\x6b\xf9\x26\xf5\xfb\xfc\xd8\xb4\x8e\x9f\x1f\x05\x2d\xd5\xa6\x6a\x78\x63\x63\x2e\x79\x6a\xce\x43\x28\x89\x06\x24\x9d\x29\x37\xf3\x66\x2c\xfb\xe1\xda\x07\x2b\x56\x2d\xc5\x44\x82\x52\xe7\x40\xd3\x8c\x71\xd8\x1d\xbf\x6e\xa6\x40\x72\x7a\x8f\x38\xa6\x59\x0e\x46\x12\x09\x31\x8c\x86\x5f\xa5\x05\xc9\xe9\x2d\x54\xaf\x27\x23\x18\x63\x1b\x46\xfc\xe0\x60\xf7\x2d\xfe\x8c\x29\xcb\x20\x1d\xe0\x3b\x82\x59\xea\xee\xc5\x16\x71\xcc\xdf\x8c\x97\x60\x9e\x2a\xa4\x40\x65\xd2\x3e\x1a\xf2\x78\xe4\xa1\xd4\xdc\x6c\xe9\xb0\xef\xd8\x37\x5c\x00\xc5\xc5\x7d\x62\x8d\x7c\x12\xa8\xc2\xdb\x2c\x6e\xaa\x52\x8e\x8d\xea\xe8\x35\xce\x60\x41\xae\xd5\x2b\xb9\x12\xda\x35\xfe\xab\x3e\x10\x9f\x76\x8d\x28\x41\x69\x96\xe3\x01\x4b\x4b\xe9\xdb\x62\x22\xcc\xe8\xea\xad\x6f\x1c\x95\x3f\xbf\x7a\xb5\xa1\xfc\xf6\xf1\x91\x5e\x02\x6a\xca\xbb\xe0\xcb\x55\x45\x87\x3c\xf9\x37\x2a\xb0\xd9\x63\xe6\xc4\x60\xec\xef\x09\x12\xfd\x84\x4c\x69\xc6\x27\x25\x53\x53\x32\x02\x7d\x07\xc0\x09\xdc\xdb\x0a\x17\xe4\x5f\x20\x05\x6e\xaa\x01\x6f\xed\x22\x68\x00\xed\xf5\xfe\x40\x6c\xc6\x14\x13\xfc\x5b\xa6\xb4\x90\xf3\xb7\x2c\x67\x8f\x94\x1e\xf5\x63\xb9\xcb\x71\x05\x41\x91\xa5\xd8\x9b\x98\x25\xf4\x1a\xec\x07\x4b\x40\x0b\xa6\x16\x56\x3d\x25\xe6\x9c\x8c\x68\x72\xfb\xd1\x00\xfc\x6a\x5f\x20\xec\xd9\xf5\x0e\x50\x45\x79\xaf\x9a\x00\xc9\x96\x45\xca\x8b\x7b\x0b\x9f\x06\x94\xef\xa6\x42\x01\xde\x60\x8d\x8c\xf8\x98\x77\x0a\x30\x55\x11\x0c\x73\xba\x05\x07\x45\xe8\x78\xdc\xbc\xa3\x3e\xec\x28\x79\xe6\xa5\xd2\x24\xa7\x3a\x99\x5a\x53\x96\x48\x2b\x71\xe2\x50\x39\xb1\x7f\x1b\x28\x6f\x6c\x44\xde\xde\xdc\x4b\xec\x3a\x2f\xee\x8d\x6e\xf9\xa8\x37\xa7\x39\x1a\x20\x5f\x9c\xa6\xa9\x01\x67\xcd\x0d\x71\x72\x5b\x6e\x5b\x04\xdf\xa0\x01\xb8\xfe\x05\x77\xe1\xf4\xea\x7c\x73\x53\xcc\x2e\x0a\xee\xd6\x2a\xee\xa2\xa9\xfb\x81\x8f\xf2\x26\x53\x77\xa5\x69\xef\xb6\xad\xa1\x7b\x84\x92\x5b\x98\xdb\x2e\xd2\x4b\x6d\x79\x25\x64\x4e\x92\x00\xec\x4e\x6b\x6e\x72\x2d\xa5\xb7\x58\xef\xd6\xd8\x63\xc7\x76\xae\x08\x3f\xfa\x66\xa1\x5b\x3e\xe1\x3f\x7a\x8b\xc7\xb6\x47\x70\x3b\x6e\x61\xbe\xdd\x03\x0b\xdb\x6d\x76\xc1\xe9\x3e\x76\xdf\xcd\x0f\x95\xa0\x57\x6d\xf5\x76\x3e\xa2\x70\x6c\x6d\xa2\xf2\xc3\x03\xb1\xd5\xe7\x55\xe8\x17\x5a\x99\xcc\x37\x1e\x2a\x8b\x8c\xe6\x4c\x4f\x59\x81\x8c\xc8\x3b\x03\x7c\x93\xf3\x1f\x68\xc6\xd2\x6a\x0a\x7b\x7e\x2f\x79\xcf\x88\x4f\xe6\x3f\x48\x74\xad\xb8\x76\x2e\x40\x5d\x09\x8d\xbf\x7c\x32\x00\xd9\x65\xb6\x02\x8f\x9d\xc2\x59\xa1\x91\xca\xa0\xe2\x15\xf4\x47\x57\x03\x5f\xd9\xab\x02\x25\x53\xe4\x92\x13\x21\x3d\x1c\xb0\x63\xbd\x9d\xc8\x4e\x81\x7c\x62\x64\x1d\x1c\x68\x9f\x5e\x39\x87\x03\x9f\x90\x0d\xe8\x3d\x30\x9d\x9b\x0a\xe5\x03\x7b\xc5\x76\xc4\xcf\x50\xda\x75\xa2\x2a\xf5\x4e\x6e\x96\x90\x1c\xe4\x04\x3d\x2e\xc9\xc6\x1e\x87\xe6\xa6\x6c\x47\x77\xed\xd8\x9a\xfa\x86\x2f\xdc\x0a\x0b\x90\x35\x59\x13\x50\x1b\xe6\x66\x67\x68\x98\x9c\xfe\x8f\xa1\xe0\xb8\x07\xff\x97\x14\x94\x49\x35\x20\xa7\x44\x31\x3e\xc9\xa0\x71\xcd\x69\x18\xe1\x34\x66\x06\xa6\x88\x21\xb5\x33\x9a\x39\x5d\x8a\x72\x02\xd6\x66\x65\x66\x5f\x64\xa9\x3d\x27\xa9\x18\xca\x53\x39\xba\x0e\x6e\x61\x7e\xd0\x5b\x42\x9a\x83\x4b\x7e\x60\x79\xcb\x12\x9a\x54\x8c\x08\x7d\x64\x07\x78\xed\xa0\x4b\x2e\xbc\x25\xc3\xd9\xd5\x8e\xd6\x7c\xe9\xc6\x18\xe1\x63\x3b\x76\x14\xd6\x1b\x5a\xa2\x8b\x68\xd2\x82\x94\x0a\xac\xb4\x8e\xa7\x8c\x80\x97\x33\x51\xaa\x44\xc5\x94\xc3\x1d\x4a\x8f\x7b\x23\xf8\x19\x4d\x82\xf1\xc9\xf7\x45\x4a\xf5\x46\x41\xa5\x76\x34\x20\x72\xf8\xc1\x4e\x42\x4a\x9c\xc5\xe0\xd6\x98\x4d\x48\x41\x25\xcd\xd5\x80\x0c\x5d\x75\x43\xc4\x34\x36\x0e\x6d\x89\x0e\x76\x37\xf3\x02\xc8\xff\x43\x3e\x84\x6b\x19\x90\x7e\xbf\x4f\x6e\xde\x9f\xbf\x7f\x43\xec\x2f\x56\xca\xd6\x82\x8c\x05\x2a\x41\xa2\x94\xe6\x55\x33\xe0\xa8\xf8\x1b\xf9\x5e\x70\x78\x3f\x36\x27\x84\x6a\x98\x81\x24\x77\x66\xab\x12\x96\x42\x65\xbd\x1a\x1c\x7e\x5c\x3c\xde\x4d\x32\xc9\xe9\xfd\x75\x29\x27\x5b\x6c\x00\x59\xda\x84\xd0\x64\x53\x2b\x93\x88\x7a\x61\x76\xae\x4a\xa6\x90\x96\x19\xa4\x84\x8e\xc4\x0c\x1a\x26\xdb\xe6\x63\xc8\xd2\x4b\xf0\x0f\x1a\x9e\x37\x52\x22\x2b\x75\xa5\xac\x1e\xc1\xfd\x1b\xf2\x1f\xe8\xda\xa6\xa4\x00\x99\x00\xd7\x74\x02\x8b\x66\x00\x7b\xdf\xeb\x57\xff\x76\xec\xf8\x91\x99\xd1\x59\x4f\x5e\x19\x8c\x78\x47\xef\xbf\xe7\xb5\x69\x90\x29\xf2\x6a\x40\x4e\x17\x5e\x86\xcf\x65\x49\x99\xa1\xad\x05\xdd\xf5\xc1\x2b\x47\x73\x22\x45\x89\x0e\x7b\x52\x16\x4d\x6d\xf6\x0f\xff\xf1\x6f\x46\xe9\xa3\x79\x91\xc1\x1b\x5f\x14\xd5\xaa\xcd\x46\x86\xd1\x82\xfc\xf1\xd5\xbf\x59\xea\x69\xce\x67\xad\x15\xd6\x30\xa3\x06\x60\x65\x41\x58\x6e\x43\x31\x21\x9b\xd7\xd5\x55\x65\x13\xfd\x95\xa6\x52\xab\x1e\x41\xaf\x7e\x25\x1c\x6a\xa1\x69\xb6\xa0\xe5\xa3\x16\x0e\x77\x16\x48\xa9\x40\x98\x00\x1a\xaa\xc8\xeb\x3f\xbe\xfa\xb7\x65\x73\xca\x7b\x9e\x00\x3e\x89\x4f\x60\x98\xc5\xc8\x28\xf7\xb7\x2c\xcb\x20\xed\x3d\xba\xfc\x71\x29\xf5\x14\x64\x8f\x00\x57\xde\x58\x65\xd6\xb7\xb0\x36\x9c\x5d\x96\x9c\xa3\x8c\x60\xad\xc3\x68\xd1\x0a\x2c\x5c\xee\x63\x0d\x23\xd4\x24\x17\x4a\xaf\x5e\xf2\xe6\xc7\xcd\x0c\xca\xe7\xef\xc7\xdb\x8a\x03\xfd\x1d\xcc\x10\xcb\x4f\xef\x20\x52\xde\xf7\x6f\xab\x4c\xc9\x3e\xe3\xba\x2f\x64\xdf\x4e\xf3\x86\x68\x59\x3e\xee\x35\xa8\x47\xde\x38\x01\x9f\x80\x0c\x94\xc1\x79\x5b\xda\xd5\x8f\x72\xf2\x77\x3f\xcf\xa9\xb8\xe3\xeb\x29\x07\x12\x4e\x47\x33\x76\x3c\xf5\x4d\x8b\xdb\xc2\xb1\x31\x6f\x37\x77\xff\xff\x96\xb1\x7b\x0b\x72\xe0\xce\x6e\x75\xda\x8d\x5c\x85\x1e\x8f\xde\x06\x6f\xaf\x8e\xad\xe5\x7c\xd6\xe6\x64\x6e\xb0\xaf\x59\x41\xb9\x96\x4e\xf8\x0a\x0a\x64\xd7\x51\x3b\x64\x34\x46\x14\x98\x73\xae\xd6\x1e\xf4\x0c\xa8\xd2\xab\x40\x11\x0f\xfa\xe3\xe3\xe1\x00\xfe\xc5\xd1\x14\x3a\x8d\x84\x84\x20\xaf\x6d\x8c\x67\x16\x51\x0e\x3e\x80\xf5\xf0\xd9\x80\xb3\x86\x10\x75\x50\x1d\x09\xb3\x7f\x4d\xf9\xea\x63\x85\xcd\x78\x23\xe7\x2e\xa2\xb5\x7b\x34\x08\xec\x75\xa6\x53\x47\xbc\x2a\x8f\xa2\x75\x69\xee\x8d\x14\x9d\x83\xa6\x0f\x27\x79\x2c\x8e\x26\xd1\xbe\xd6\x94\xa7\x54\xa6\x6e\x95\x87\x87\xaa\x9a\x72\x40\xde\xa1\x2f\x8d\x8f\xc5\x1b\x32\xd5\xba\x50\x6f\x4e\x4e\x26\x4c\x0f\x6e\xff\xa2\x06\x4c\x9c\x24\x22\xcf\x4b\xce\xf4\xfc\x04\x1d\x68\x6c\x54\x6a\x21\xd5\x49\x0a\x33\xc8\x4e\x14\x9b\xf4\xa9\x4c\xa6\x4c\x43\xa2\x4b\x09\x27\xb4\x60\xfd\x5a\x66\x56\x83\x3c\xfd\xbd\x7f\xd1\x47\x16\x8c\x1b\x67\x08\xad\x4b\x72\x06\xfd\x92\xdf\x72\x71\xc7\xfb\xa8\xc9\xaa\xad\x4e\xd3\x66\x51\x0c\x7e\x2c\xc0\x7b\x9b\xc0\x85\x42\xa4\x1f\x7d\x13\xcc\xc7\xf4\x29\x4f\xfb\xd6\xe9\xf8\x91\xf7\x62\x17\xdb\x6e\xbf\x0e\x0c\xd8\x24\xe2\xdc\x8e\xdd\xb4\x21\x9a\x68\x36\x83\x9d\x9c\xd8\x7e\x34\xb6\xfb\xbd\x0f\x18\x4d\x4b\x69\x77\x3c\xf0\x66\x7b\xdf\x4c\x4e\xe7\x28\xeb\xe0\xbb\x89\xb0\xac\x9c\x8b\x14\x9c\xe5\x73\x86\xaa\xfd\xb5\x61\xe6\x37\x46\x14\x76\x3e\x6e\xb4\xfb\xce\x95\x86\xdc\x12\x27\xfb\x7c\x36\x27\x5a\xce\xad\x63\x5c\xde\x1a\xe5\xd3\x79\xae\x8d\xc4\x7f\x8b\xf7\x29\x25\x12\x86\xa2\x4f\x0d\x57\x2f\x77\x79\x1b\x1e\x25\x85\x50\x0c\xdf\xed\x78\xde\x76\x96\xb9\xdd\xd9\x65\xe0\xa6\xfb\xf3\x9f\xb6\xd9\xba\x31\xb6\x51\xd8\xd2\xca\xde\x8c\xa0\x18\x87\x11\xfe\x6e\x7b\x0e\x95\x57\x5c\x8d\x58\x92\x08\xae\xb4\xa4\x6c\x7d\x0e\xd3\xea\xb1\xa3\x2b\x64\x77\x7f\x03\x41\x0c\x3a\xdd\x09\x28\x64\x39\x06\xcb\x33\x45\x44\x4b\x0f\xea\x10\x30\x36\xc5\xc9\xc7\x12\x1a\xc2\xb5\xa3\x69\x75\x07\x18\x91\x56\x70\xb2\x4f\xc3\x18\xa4\x84\xf4\x1c\xa5\xcf\xeb\xea\xbb\x2e\x27\x5c\x54\x3f\x5f\xdc\x43\x52\x6e\x9a\x09\xbe\x3c\x96\x6c\x79\xde\x20\xe2\xc2\x4e\xec\x22\xcc\xd1\xf5\x17\x9c\xfc\x21\x10\xec\x4e\x10\x51\x54\x33\x35\xb6\xf9\x62\xd5\x46\x40\xe0\xf8\xac\x50\xb8\x72\x0f\x23\x8b\xb3\xa9\x0f\x4c\x23\xb9\x49\xa6\x42\x28\x73\xca\x71\x3f\x71\xde\x19\x13\xd6\xe7\x87\xc9\x2b\x92\xe4\x86\xc6\xf8\x24\x96\x7a\x7a\x6b\xa8\xad\x1f\x63\xca\xaa\xe0\x15\x04\xbd\x97\xca\x4c\x83\x86\x47\xf3\xc7\x04\xa5\x26\xa5\x89\x2a\x73\x33\xe9\x1d\xb0\xc9\x54\xab\x1e\x61\x03\x18\x20\xd6\x00\x4d\xa6\xc1\xb4\x39\x80\x6e\x74\x41\x09\x51\x2d\xb4\x12\x1f\x55\x59\x0d\x2e\x0d\xa7\x57\xf1\x98\xc5\xbd\x5c\x09\xae\x1e\x01\x9d\x0c\x8e\x7b\xa4\x4e\x14\x37\x6b\x1c\xcd\x09\xd3\x60\x68\x36\xea\x22\x52\x94\x13\xfb\x25\xe0\x63\x3a\x71\x5d\x55\xca\x07\x7a\x51\x53\xd4\x19\x0f\xec\xc7\x1d\x98\x7d\xc3\x95\x97\xb9\xd1\x17\x2b\xa2\x8e\x66\x75\xdf\x38\x47\x48\x09\xaa\x10\x56\xdb\x5c\x34\xb8\xff\xff\xab\x87\x8e\xd4\x71\x0d\xcc\x29\x9b\x4c\x3d\x2c\xa9\x63\x04\xcd\x3d\xd8\xfe\xec\x91\x56\xbe\x14\x3b\x76\xf4\xa8\xd8\xd1\xf4\x6d\xfb\x7c\x89\x1a\xab\x82\xfd\xd7\x20\xf3\x0a\x8a\x88\x22\x48\x32\x9c\x9d\xdb\x37\xac\x71\x38\x46\x5e\x91\x23\x44\x32\xa6\x0f\x15\x22\x7c\x5f\x14\xc7\x03\x72\x4a\x78\x59\x9d\xb9\x87\x5e\xc0\x45\x35\xbf\x9b\xc8\xbc\x54\x89\x7a\xae\x1d\xbf\xb8\x15\xb9\xb3\x63\x37\x4f\x79\x38\xfa\x0e\x02\xf0\x78\x59\xc4\x87\x26\xb1\xb0\xde\x71\x82\x76\xa4\xdb\xcf\xe1\xbf\x62\xf7\x39\x96\x02\x2c\xf0\xb8\xd6\x51\x14\x20\xf3\x5e\x28\x3d\x55\x07\xb2\x79\x8a\x2d\x2c\x76\xc5\x0a\xd2\x0d\x66\x90\x8e\xe0\x4a\x5a\x45\xe8\xac\x1e\x8b\x61\x2c\x3e\x8b\xaa\x01\xed\x06\x91\x1f\xcd\xf1\xea\x96\xc1\x4b\xeb\x47\x5b\x4a\x57\x8f\x56\x34\xaf\x1e\x0f\x22\xde\xfe\x05\xf6\xac\x1e\x1d\xa1\xad\x1d\xed\x49\x5b\x3d\xb6\x0f\x0d\x5a\x37\xcf\x0e\x01\x43\xab\x47\x57\x67\xd3\x8e\x1d\x82\x8b\x56\x8f\x25\x11\xf5\xe3\xc4\x1a\xad\x1e\x3b\x1b\x49\x57\x8f\x5d\xe3\x92\x56\x8f\x85\x54\xc5\x8f\x14\xa4\xd4\x6b\x46\x28\x91\x6f\xb4\x3d\xc7\x6f\x5b\xf1\x93\x7a\x74\x0c\xe2\xdd\x22\x9b\x56\x8f\x45\x01\xf0\x99\x44\x39\xad\x98\xea\x1b\x6d\xa6\x79\xbb\xf6\x61\x9b\xa3\xee\xe3\x74\x9c\x42\xd1\x73\xa9\x33\xde\xce\x8c\x11\xd5\x85\x04\x2c\x2b\x80\x61\x5f\xde\x0e\xf3\x69\x02\xab\x56\x8f\xee\x18\xa7\x1d\x1d\xb1\x4f\x3b\x3a\x43\x6e\x14\x78\xbe\xb6\x76\xe1\x27\x94\x75\xac\x65\x3a\xca\x3a\x51\xd6\xd9\x62\x44\x59\x67\xd3\x11\x65\x9d\x75\x23\xca\x3a\x2b\x46\x94\x75\xa2\xac\xd3\x6a\xec\x9f\xac\x63\x2d\x55\x9d\x19\xcc\x7e\xb4\x06\xd7\x45\x0b\x19\x4a\x53\x3e\xa4\xa7\x69\x2a\x33\xbc\xff\xda\x91\xd8\x1b\x34\xaf\xb9\x48\x75\x49\xf9\x04\xc8\xeb\xfe\xeb\x57\x1b\xa6\x03\xae\x1e\x6d\x82\x76\xc2\xb1\x6d\xea\xe0\xe2\x58\xe7\x91\xf8\x68\xde\x25\x77\x52\x2b\x87\x47\x43\xc2\x5c\xe3\x20\xaa\xaa\x5a\xe5\xa0\x09\xd5\x0d\x83\x38\xcb\xa1\x72\x88\x36\x52\x90\xeb\x98\x5e\xc1\x9d\xbf\xc3\x6c\xea\x60\xb7\x15\x24\x40\x6d\x1c\xfb\x08\xaa\x55\x88\x1c\x6c\x82\xa9\x3f\xf4\x66\x09\xe0\x61\x45\x8e\x60\x30\x19\x90\xd4\x26\x6b\x53\xee\x62\xc6\x8e\x7b\xa1\x7b\x3c\x37\xc4\x55\xe2\x7f\xcc\xb2\x9d\x7f\x1c\x66\xc0\x75\x49\xb3\x6c\x4e\x60\xc6\x12\x5d\x7d\x1f\x06\x04\x32\x6d\x9d\x9d\x6d\x5c\x29\x2d\xc4\xc3\xb6\x22\x61\x7f\xe9\x6c\x6d\xe7\xaf\xf6\xa3\xbd\xec\xb6\xb4\x8e\xdd\xe9\xcd\x82\x5c\x62\x21\x34\x58\xab\x56\x69\xf3\x36\xeb\xaf\xc4\x7f\x22\x82\xbf\xff\xb0\xab\x7b\x8c\x74\xc4\x13\x5a\xf3\x81\x45\x05\xaa\xcc\x32\x83\xde\xd6\x63\xb6\x0c\x82\x15\x9e\xac\x15\xd9\x36\xd6\xcd\x9a\x07\x59\x37\x78\xcf\x8d\x28\x44\x26\x26\xf3\x70\x07\x6d\x47\x96\xa0\xbc\x0d\x25\xaa\x1c\x39\x11\xd0\x1c\xa2\xab\x85\x2d\x8f\xbe\x90\xb5\x23\xfa\x42\x96\x46\xb4\x0f\x2c\x8e\x68\x1f\xd8\x62\x44\xfb\xc0\x8a\x11\xed\x03\xcb\x23\xda\x07\xa2\x7d\xa0\xcd\x78\xf9\xf6\x01\x12\x7d\x21\xeb\x46\x94\x75\xea\x11\x65\x9d\xcd\x47\x94\x75\x96\x47\x94\x75\xa2\xac\x13\x65\x9d\x28\xeb\xec\x3a\x5a\x20\x77\x21\xd2\xce\x53\x64\x0a\x91\x3e\x90\x21\x63\xed\xd5\x89\xe8\x67\x22\xa9\x2a\x8b\x98\x47\x9c\xe7\x43\xd1\xdc\x9a\xd0\x7b\xe4\x5f\x82\x83\x4d\x4f\xb0\x25\x6b\x73\x20\x02\x9b\x40\x14\x22\x3d\x52\xc7\x3b\x04\x9e\xc7\x0c\x9b\x98\x61\xf3\x19\x64\xd8\x4c\xa9\x72\x85\x8f\x90\xb4\xae\x4f\xb8\x09\x8e\xff\x0d\xc8\xfc\xb3\xcd\xb7\x31\x08\xe7\x10\x06\x7b\xc4\xd5\x48\x61\x61\x97\x3a\xdf\x2e\xa4\xc3\x26\xc4\x9c\x5e\x66\x5b\xec\xa4\x29\xa4\xa4\x00\xd9\xb7\x48\x26\xc8\x98\xb9\xfa\x5f\x0b\xf8\xeb\x20\xfc\xcc\xf3\x66\x9a\x90\x78\xd6\xc9\x33\xcd\x4f\xe9\xcc\x37\x15\xba\xe8\x1a\x5c\xf1\xd9\xa5\xd2\x74\xa3\x95\xf6\x89\x76\xee\xb4\xef\x5a\xe9\xa5\x5d\x29\x91\xa8\xe4\x5d\x6f\x55\xe6\x78\xfd\x58\x59\x9c\xf6\x9f\x25\xc8\x39\x11\x33\x90\xb5\x62\x54\x75\xe7\xe9\x55\x4d\x66\x12\xea\x0a\x20\x77\x63\xe0\xe9\xc4\x14\xd1\xa5\xa6\xde\xb5\xd7\x90\xec\x59\xf5\xe3\xf5\xa3\x5b\xc5\xa1\x43\xb5\xe1\xb9\xd5\x52\x5e\x3f\x3a\x35\xbf\x91\x8e\x4d\x70\xa4\x43\x33\x1c\xe9\xd6\x14\x47\x3a\x37\xc7\x91\x2e\x4d\x72\xe4\x93\x57\x80\x5e\x3f\x3a\x36\x1f\x91\xce\xad\x74\xe4\x19\xd6\x93\x5e\x3f\x3e\x02\xb8\xbb\xb4\xd8\x91\x58\x9d\xba\xf5\xe8\xda\xa0\x46\xba\x36\xaa\x91\xae\xf1\x70\xa7\x2a\xd8\xeb\x47\xac\x8f\xfd\x11\xe4\xb4\xce\x84\x88\xb6\x35\xb5\x1f\x5b\x68\x07\x38\x59\xf5\xee\xfd\x54\x0a\x90\xe5\xd2\x75\xc3\x58\xf3\xee\xa0\x57\x17\x86\x6a\x86\x8d\x4d\x7d\xdc\x2a\x62\x34\xfe\x9e\x7a\x83\x57\xc9\x83\xe2\x71\xc1\x64\x4b\xad\x63\x6a\xd3\x59\xd5\x3c\xc6\x28\x05\x75\xd3\xa9\xe0\x61\xbc\x77\x60\xc3\x49\x6b\x69\x82\xa7\x8b\x01\xa6\xf5\x13\xa8\x5f\xd8\x76\xb6\x07\xde\x8e\x7d\xa8\xea\x3b\x0e\x06\x61\xe7\x5b\x37\xe3\xd1\xff\xf9\xbf\xc7\x8d\xea\x2d\xf5\x84\x8e\x2a\x57\x67\x67\x04\x9a\xf6\x33\x98\x41\x86\xeb\xf0\x6d\x95\xa7\x02\x2d\xc6\xb6\xec\x69\x60\x90\xba\x5a\xdc\x51\x32\x06\xaa\x4b\x89\x15\x44\x81\xd3\x51\xd6\xfe\xac\x44\x05\x33\x2a\x98\x9b\x8d\xa8\x60\xae\x1d\x51\xc1\x6c\x31\xa2\x82\xb9\xd9\x88\x0a\xe6\xfa\x11\x15\xcc\xa8\x60\xee\x30\xa2\x82\x19\x15\xcc\x5d\xc7\x67\xac\x60\x76\x1b\x38\x1d\xaa\x7b\x2e\x0e\x05\xe5\x47\x4d\x35\x4b\xea\xa0\x6a\x7f\x97\xfd\x57\xb7\x6a\x66\xa8\x42\xae\x56\x32\x43\x45\x74\x49\xd1\x1e\x3c\xa2\x51\x56\x3a\xe7\xd2\x93\x0f\x2a\x9b\x2f\x2d\x36\xbc\x33\x44\x0c\x9c\xce\x9d\x62\xe2\x8d\x0f\x5d\xab\x5b\xbb\x57\x71\x6d\x29\x39\xf2\xde\x7e\x6c\xd5\xc2\x85\x6e\x5e\xe4\x9a\xf5\xeb\x3b\x2a\xff\x3f\x86\xed\x34\x2a\x06\x34\x9c\xd4\x55\x94\x5c\x15\x81\x55\x23\x8f\xa1\x8e\x20\x1b\x6b\xc0\xd6\xb8\x63\xc6\x6d\x2c\xa5\x6f\x2b\x24\xb8\x0f\xcb\xb2\xe4\x14\x09\xa0\x47\x73\x2b\xf9\xe2\x7a\x50\xfc\xad\x61\x17\xc4\x11\x51\x3c\x63\x94\xbb\x74\x5b\xc1\x7d\xdf\x7b\xdb\xcb\xbe\x16\x97\xab\x6e\x2d\xd5\xdb\x07\xe4\x02\x91\x3e\x9c\x98\x29\x84\x0f\xb5\x1d\x56\xba\x31\x51\xec\x57\x69\x88\xbb\xad\x4b\x43\x2c\xc4\xa4\xc4\xca\x10\xb1\x32\x44\xab\xca\x10\x78\xd1\x1e\xee\xce\x4b\x44\x90\x1f\x5d\x03\x26\x09\x08\xaa\xbc\xcc\x34\x2b\xea\x18\x6f\x65\x5f\x95\x59\x45\x62\xec\x62\x4d\x9b\xf8\x6e\xde\x46\x93\xe9\x22\xde\xe3\x7c\x18\x13\xae\x90\x9c\xb8\x78\x4e\x6c\x97\x84\x35\x0d\xbc\xd6\x61\x83\x56\xd9\xf3\x8f\x45\x3c\x47\x82\xad\x6a\xa5\xd9\x76\xf3\x32\x74\x3e\x33\x28\x61\x28\xf6\x03\x0c\x22\x6c\x99\x81\x71\xb1\x6c\x06\xbc\xe6\x12\x47\xea\xf8\xd8\x0b\x43\x9d\x72\xaf\x8f\xc2\x7d\xfe\x16\x70\x89\xff\xdc\x84\xff\xe0\x07\x55\x1c\xa8\x06\x5f\xcd\x7f\x9e\x77\xd0\x65\xfb\xf8\xb9\x2e\x0c\x72\x9d\xc5\xcd\x3d\x79\xcc\xdc\xe7\x54\x5d\x63\x2f\x5d\x18\x7b\xa7\x75\xbc\x0c\xb7\x45\x4c\x49\xdd\x7c\x3c\x87\x94\xd4\x27\x72\x4d\x3c\x9f\xcc\xd4\x67\xeb\x8e\x78\x2e\x99\xa9\xd1\x05\xb1\xd5\x78\xa9\x09\xa3\xcd\xd1\xa1\xcb\x21\xba\x1b\x3a\x96\xa9\x3a\x61\xfe\x1f\xc7\xcd\xd0\x09\xfe\x75\x1a\xbf\x16\x63\xd7\x5e\x78\xec\x5a\x54\xf4\xa2\xa2\xd7\x1c\x51\xd1\x5b\x1a\x51\xd1\xdb\x62\x44\x45\x6f\xfd\x88\x8a\xde\xf2\x88\x8a\x5e\x54\xf4\x36\x18\x51\xd1\x8b\x8a\xde\xa6\xe3\x33\x53\xf4\xba\x2b\x1a\x1f\x63\xc8\xba\x8f\x21\xeb\x86\x10\x76\x40\xfe\x3a\x41\xba\x8e\x62\xc6\x62\xbc\xd8\x7e\xc7\x8b\xb5\x2c\x9d\xc7\x35\xfb\x38\xe5\xf3\xc2\xdd\x5e\x57\x43\x8f\xce\x04\x4b\x49\x51\x6a\x57\x41\x2c\xd6\xd1\xdb\xe7\x3a\x7a\x8d\x1d\x8d\xc5\xf4\x36\x2a\xa6\xb7\x0e\x66\xb1\xa2\xde\x9a\xb1\x3f\x51\x6c\xb1\xa2\xde\xb6\x23\x56\xd4\x5b\x3d\x62\x45\xbd\x07\x46\xac\xa8\x17\x2b\xea\xc5\x82\x07\x2d\x46\x2c\x78\xb0\x62\xc4\x82\x07\xbb\x8f\x58\xf0\x60\xa3\x11\x0b\x1e\xc4\x82\x07\xcd\x11\x9d\x50\xed\x46\x2c\x78\xd0\x72\x44\xc7\x54\x2c\x78\xd0\x6a\xc2\x58\x51\x2f\x46\x25\x6e\x3f\xa2\x82\x19\x15\xcc\xcd\x46\x54\x30\xd7\x8e\xa8\x60\xb6\x18\x51\xc1\xdc\x6c\x44\x05\x73\xfd\x88\x0a\x66\x54\x30\x77\x18\x51\xc1\x8c\x0a\xe6\xae\xe3\x33\x56\x30\x63\x45\xbd\x7d\x8f\x86\x24\xfb\x98\xf2\x14\x2b\xea\xc5\x08\xc9\x9d\xb6\x3b\x56\xd4\x7b\x7c\x7c\xf6\x15\xf5\x1a\xd1\x7a\x4f\x57\x56\x6f\xfb\x65\xc4\xda\x7a\xb1\xb6\x5e\xac\xad\x17\x6b\xeb\xc5\xda\x7a\xb1\xb6\xde\xe6\x63\xff\x9d\x19\x7b\xa7\x7f\xbc\x0c\x07\x46\x2c\xb9\xb0\xf9\x88\x25\x17\xd6\x8e\x58\x72\x21\x96\x5c\x88\xce\x88\x5d\x46\x2c\xb9\xb0\xe5\x88\x8e\x87\x58\x72\x61\xab\x11\x6b\xeb\xc5\x28\xb6\xcd\x47\x54\xf4\xa2\xa2\xd7\x1c\x51\xd1\x5b\x1a\x51\xd1\xdb\x62\x44\x45\x6f\xfd\x88\x8a\xde\xf2\x88\x8a\x5e\x54\xf4\x36\x18\x51\xd1\x8b\x8a\xde\xa6\xe3\x33\x53\xf4\x62\x6d\xbd\x7d\x8e\x26\x8b\xb5\xf5\x56\x8c\x18\x39\xb6\xdf\x91\x63\x3b\xe2\x0a\x2d\xb5\xc8\x45\xc9\xf5\x35\xc8\x19\x4b\xe0\x34\x49\xcc\x5f\x37\xe2\x16\xb6\x8c\x56\x6a\x6a\xa1\x0f\x4c\x4b\x18\x4f\x59\x82\x7a\xe4\xdd\x14\xb0\x34\x9e\x11\x6f\xf1\x3e\x42\xed\x8d\x44\xe3\x9d\x35\x7a\xe1\x3a\x0d\x4d\xc3\x10\x1e\x9c\x7a\x5b\x78\x59\x08\x8d\x84\xc8\x80\xf2\x2d\x9e\x74\xcc\x10\xe4\x96\xa7\xb9\x01\x90\xb7\x8e\x12\xd7\x93\x91\x11\x64\x82\x4f\x5c\xc4\x90\x3b\x01\x03\x72\x56\xdf\x90\x50\x8e\x87\xa7\x94\x12\xb8\xce\xe6\x08\x07\x2c\xd2\x85\x4a\x43\x2e\x66\x90\x22\xc5\xc6\x40\x25\x2b\x46\x52\x4d\x32\xa0\xe6\x5d\x1c\xea\x97\x99\xc3\x43\xc9\x10\xe7\xb7\x93\x8e\xc0\x05\x4f\xed\x04\xc4\xed\x69\xe3\x4e\xd4\x70\xc1\xb0\xe1\xa4\x26\x64\x4b\x09\xaa\x47\xc1\x17\xe2\xd1\x9c\x8b\x92\xdc\x51\x2b\x28\xc9\x92\xe3\x61\xc6\x4f\x37\xa0\xdd\xf2\xe5\x2d\x44\x92\xdd\xad\x0f\x7d\xa4\x6a\x5b\x3e\xd6\xc6\x1a\x40\xe5\x64\x27\x26\xd5\xd8\x9a\xc3\x53\x39\x29\xad\x44\xe8\x50\x19\xb8\x96\x73\x8c\xe8\xb3\x22\x45\x2a\x92\x5b\x83\x86\x39\x9d\xc0\xe1\xa1\x22\x67\xef\xce\x0d\xed\x2b\x95\x21\xd5\xae\x4c\xa0\xa3\x85\x85\x14\x33\x96\x1a\xcc\xfe\x81\x4a\x46\x47\x99\x91\x39\xc7\x20\x81\x1b\x91\xe0\x8b\xa3\x1f\x4e\x3f\xfc\x7a\x75\xfa\xee\xe2\x18\xa5\x4f\xb8\x2f\x28\x37\x47\xa2\x54\x75\x1c\xaa\xc3\x09\xf3\x22\xe0\x33\x26\x05\x37\x8b\x43\x3d\x8d\x92\x99\x9f\x35\xa9\x4e\x82\x04\x25\xb2\x19\xa4\x56\x46\xae\xde\xe6\x59\x0e\xe3\x45\xa9\xbd\xde\x88\xd1\x91\xe6\xf4\xf0\x64\x4a\xf9\xc4\xac\xf3\x5c\x94\x66\xbe\x2f\xbe\xc0\x15\x49\x48\xcb\xc4\x4a\x4d\xd4\xa3\xec\x17\x3d\xcf\x26\x0c\xa1\x57\xb6\xa6\xa3\x4a\x68\xe1\xd7\x1c\x7e\x96\x9a\x73\x4d\xef\xdf\xd8\xf0\xc0\x83\x2f\x82\x4b\x07\xbe\x1e\xa6\x30\xaf\xb0\xcc\xc6\xae\x2a\xc3\x52\x8c\x19\x39\x08\xef\x1e\x90\x0b\xf3\x0e\x48\x43\x00\xda\xe8\x4e\x98\x81\x44\xad\xd3\x81\xaf\x47\x24\x4c\xa8\x4c\x33\x50\x18\xd7\xe8\x09\xb3\xd5\x0c\x1c\xc0\xa0\xd2\x69\xb9\xd0\xab\x28\x09\x79\x27\x30\xc6\x71\x2c\xde\x90\xa9\xd6\x85\x7a\x73\x72\x72\x5b\x8e\x40\x72\xd0\xa0\x06\x4c\x9c\xa4\x22\x51\x27\x9a\xaa\x5b\x75\xc2\xb8\x39\x59\xfd\x94\x6a\xda\x0f\x8e\xf4\x89\x65\xdb\xfd\x44\xe4\x39\xe5\x69\x9f\x3a\xd4\xea\x57\xdb\x7a\xf2\x7b\xc7\x50\xfb\xb4\xba\x8b\xf1\x3e\xed\xab\x29\x64\xd9\xe1\x0e\xc8\xdc\x4e\xe0\x6b\x21\xe8\xb5\x12\xf0\xdc\xb7\xb7\x3f\xbd\x17\xd5\x61\xb5\x30\x18\x90\x2b\xa1\x5d\xf8\xad\x8b\xf4\x46\x22\x8a\xf0\x5d\x7d\x9e\x2f\xae\x6e\x3e\xfc\x7d\xf8\xfe\xf2\xea\x26\x1e\xeb\x78\xac\xe3\xb1\x6e\x71\xac\x81\xcf\x5a\x1f\x69\x2f\x6d\x06\xc7\xa4\xda\x6f\xe4\xd1\x0a\xb4\x3f\x06\xd5\x06\xb4\x96\x0d\xed\x78\x32\xa8\x37\x20\x70\xc1\x67\x3f\xd0\xa6\x69\x9d\xaf\x04\x07\x71\x37\x58\x11\xb9\x92\xbe\xdb\xc4\xde\xb7\x30\x63\xb5\xf5\x5b\xed\x24\x3f\xda\xd1\xde\xa7\x64\x5e\xbd\xbb\x89\xa1\xb1\x7d\x57\x34\xaf\xeb\x6b\xaf\xd8\xb5\x01\x79\xe7\x15\x1e\x72\xf6\xeb\xe5\xf9\xc5\xd5\xcd\xe5\xd7\x97\x17\x1f\x76\xd7\xa0\x3b\xb0\xb5\xa0\x35\xa1\x23\x00\x1c\xee\xc8\x25\x0b\x09\x33\x26\x4a\x95\xcd\x2b\xfb\xc7\x6a\x22\xb0\x78\xfa\x9d\xc3\x77\x5e\x69\xe2\x2b\x1f\x8b\xcc\xb6\x5b\x66\x7b\x0e\x63\x5a\x66\x56\x6f\x3a\x38\x18\xec\xc2\xe5\xec\xe8\x0a\x7d\xbf\x96\xa2\x45\xfd\xe8\x06\x0a\x5f\xdb\xca\xf3\x63\x21\xd7\x1e\xe3\x43\x17\x76\xd0\x60\x3d\x4e\x78\xb4\xb6\x39\x27\x3d\x5a\xef\x58\x4b\xe8\xb4\x74\x2f\x74\xe3\x74\x4f\x04\x1f\xb3\xc9\x3b\x5a\x7c\x07\xf3\x0f\x30\x6e\x67\x20\x6e\xc2\x1b\xed\x8e\xce\x87\x8c\x56\x4a\xc3\xce\xec\xcb\xda\xf9\x67\x3a\xf3\xce\x74\x15\x96\xd1\x3e\x24\xa3\xbb\x08\x8a\x4e\xa2\x27\x96\xaa\xf9\x5b\x0b\xb4\xb3\x25\x77\x15\x5c\xd3\x89\xcb\xbe\x1d\x97\xf7\xa3\xc9\xec\x42\x76\xef\xe8\xac\xde\x54\xed\x48\x04\x4f\xa0\xd0\xea\x44\xcc\x0c\xe7\x82\xbb\x93\x3b\x21\x6f\x8d\x1e\x61\x14\xd7\xbe\xc5\x5a\x75\x82\xde\x82\x93\xdf\x5b\xff\xd7\xcd\xfb\xf3\xf7\x6f\xc8\x69\x9a\xba\xd6\x2c\xa5\x82\x71\x99\xb9\x66\x08\x03\x42\x0b\xf6\x03\x48\xc5\x04\xef\x91\x5b\xc6\xd3\x1e\x29\x59\xfa\xd5\xee\xc4\xd9\x8f\x0e\x77\x41\x14\xd6\xc7\xd9\xf1\x4e\x5c\xa3\x77\x65\xde\xe0\x5d\x15\x11\x31\x5c\x8b\x69\x85\xb8\xe9\xed\xcd\x4e\xc8\xe8\x08\x34\xdb\x1b\xe7\x17\x07\x6e\x61\xb7\x74\xf5\xb0\x26\xac\xd6\xb7\xe9\x10\xb5\x10\xe9\x1b\xa2\xca\xa2\x10\x52\x2b\x92\x83\xa6\x46\xe9\x1d\x18\x0c\xeb\x35\xff\x44\x2f\x55\x8f\xfc\xa3\xfa\x11\x5d\x4d\xea\xa7\xc3\xc3\xbf\x7d\x77\xf1\xf7\xff\x3c\x3c\xfc\xe5\x1f\xe1\x55\x64\x85\x36\xfc\xa7\x79\x8b\x2a\x20\x19\x70\x91\xc2\x15\xbe\x03\xff\x54\x0d\x07\x8b\xbb\xa0\xa9\x2e\xd5\x60\x2a\x94\xbe\x1c\x56\x7f\x16\x22\x5d\xfc\x4b\xb5\x90\x38\xc8\x7e\x32\x06\xdc\xa2\x21\xd5\xd3\x3d\x61\x0f\x35\x2d\xe9\xf8\xa8\xba\x59\xc3\x16\x40\x39\xc5\x7f\x7e\xed\x41\x60\xa4\xa7\x3b\xc9\xb4\x46\xa7\x9b\x4b\x33\x17\xe3\x9e\x39\xb5\xb5\xd8\x39\x7b\x7d\xb0\x57\x0c\xa6\xda\xc1\x8e\x01\x86\x10\x71\xd0\xb2\x07\xb9\x62\xb0\xcb\xce\xe5\xd3\xe1\x25\x99\x59\x08\xef\x0d\x70\x7c\xea\xf0\xd7\x1f\x95\xc6\x55\x2d\xa3\x1c\xa8\x2a\x0d\xf1\x8d\x8d\x06\xaa\x12\x98\x49\xc6\x72\xe6\x82\x0c\x5d\x7b\x29\x45\x8e\xec\x8f\x83\xa4\x28\x7b\xee\x86\x41\x0e\xb9\x90\xf3\xea\x4f\x28\xa6\x90\x1b\x4d\xab\xaf\xb4\x90\x74\x02\xbd\xea\x71\xfb\x58\xf5\x97\x7d\xb0\xf1\x82\xe5\xa7\xad\x2a\x5c\x3b\x49\x1d\x45\x86\xf4\xe5\xd1\x36\x0f\xfa\x3d\x21\x6d\x15\x66\x5c\x7d\x04\x91\xb0\xb2\xc4\x59\x81\xb3\x82\x22\xea\x93\x33\x91\x95\x39\xa8\x5e\x25\x06\x59\x6b\x00\x9f\x19\xcd\x52\xed\x95\xa0\x96\xb2\x19\x53\x5d\xc4\x0f\xaf\x90\xd3\x98\x0b\xc5\x17\xa5\x2e\x4a\xed\x6a\xd9\x04\x6d\xe9\x84\x42\xbb\x45\x55\x70\xa0\x41\xf6\x5f\xb7\x2d\xb8\x45\x48\x41\xb5\x06\xc9\xdf\x90\xff\x3e\xfa\xf9\xcb\xdf\xfa\xc7\x5f\x1d\x1d\xfd\xf4\xaa\xff\xd7\x5f\xbe\x3c\xfa\x79\x80\xff\xf8\xf7\xe3\xaf\x8e\x7f\xf3\x7f\x7c\x79\x7c\x7c\x74\xf4\xd3\x77\xef\xbe\xb9\x19\x5e\xfc\xc2\x8e\x7f\xfb\x89\x97\xf9\xad\xfd\xeb\xb7\xa3\x9f\xe0\xe2\x97\x0d\x27\x39\x3e\xfe\xea\x8b\xd6\x4b\xa7\x7c\xfe\xbe\x25\x01\xb5\xa3\xdf\x59\x29\xa2\xc5\x19\x3b\x0a\xb0\xbe\xef\xd7\x4a\x53\x9f\x71\xdd\x17\xb2\x6f\xa7\x7e\x43\xb4\x2c\xdb\x11\x93\x9a\x29\x75\x7d\xfe\x7d\xef\xb1\x37\x35\x43\xaa\xd8\xf5\xde\x1c\x70\x05\x89\x04\xfd\x29\x2c\x39\xf6\x4d\x5e\x4e\x59\x08\x76\x7c\x69\x7c\xee\x73\x30\xee\x54\xc1\x82\xb8\xaf\xb5\x24\x3a\x96\x22\x1f\x90\xc0\xbd\x31\xc3\x4c\x0f\x77\xdf\x2d\xb4\xb0\x82\xfa\x11\x8d\x41\xd1\x18\xb4\x66\x3c\x6a\x0c\xba\xb6\x78\xb8\xb7\x96\x20\xe0\xb3\x5d\x5d\x18\x2b\x3d\xe8\x5e\xd7\xd1\x82\x14\xa2\x28\x33\xaa\xd7\x78\xc6\x56\xb8\xd3\xdd\x51\xaf\x23\x91\xeb\x48\x1a\xcb\xd0\xf2\xd5\x3e\x4c\x72\x9a\x65\x84\x71\x7b\xf0\x71\x02\xef\x30\x93\x60\x55\x1b\x42\xad\x3f\x7b\x66\x96\x70\xe7\x4a\xd6\x85\xe1\x9e\x8a\x28\x4d\xa5\xc6\xa8\x63\x2c\x69\x67\x59\x89\xf3\x3e\x31\x5e\x17\xb6\xab\x84\xc3\x2a\x09\x64\x65\x5f\xcf\x8c\x2a\xed\x97\x8d\xab\xd1\xf4\x16\xbd\x8d\x09\xa4\xc0\x13\xc0\x8c\xb4\x12\xea\x6f\x1d\x19\xbd\x8d\x5c\xf0\x99\x9d\x83\x92\xb4\xb4\xc1\x20\x96\xfc\xad\x9e\xe3\x65\x05\x20\x18\x44\xbc\xf6\xed\x97\xab\x38\x04\xa4\xfa\x95\x86\x5d\x25\xf6\x55\x56\x56\xf5\x34\x91\x07\xed\x79\x66\xe5\xd9\x6a\x25\x0c\x2d\x31\xcb\xda\xfc\xdc\x64\x92\x2f\xc1\x19\xd8\x9e\x7d\x7e\x76\xac\xb3\x23\xb6\xd9\x0d\xcb\xdc\xc2\x77\xd2\x25\x9b\xec\xc2\x59\x52\x48\x18\xb3\xfb\x8e\xce\xe9\x29\xaf\x2d\x31\x2c\x05\xae\xd9\x98\xd9\x8e\xfd\x85\x84\x02\x78\x5a\x15\x45\xc5\xac\x70\xde\x84\xcd\x5e\x06\xf3\x58\x81\xbb\x5b\x52\x76\xbd\x4a\xd8\x8f\x74\x8c\x44\x3a\xb6\xf3\xf8\x44\x74\xcc\x61\xee\xfe\x10\x31\x8c\x3c\x6f\x1f\xfa\x7e\x1e\xc4\xb1\x23\x16\x6f\x8d\x65\x75\x42\xd7\x09\xce\xa2\x16\xaa\x07\x55\x74\x51\x0b\x1b\xb9\x46\xa6\x6c\x62\xc0\x6a\x2b\x0a\x59\xa1\x89\xe4\x94\xd3\x89\xcd\xea\xd6\xc2\xdb\x69\x8d\x96\x65\x90\x58\xb2\xb4\x21\xdc\xdb\xd7\x30\x4e\x0c\x62\x67\x82\xa6\x78\x51\x8a\x2c\x03\xa9\x48\xc6\x6e\x81\x9c\x43\x91\x89\xb9\x4b\xd2\xe6\x29\xb9\xd6\x54\x1b\x94\xbe\x06\xbd\x9b\xcf\xb7\x15\xba\xe2\x8a\x87\x65\x96\x0d\x45\xc6\x92\x9d\x2c\x2a\xcd\x6d\xbb\xc4\xfd\x2a\xca\x2c\x23\x05\x4e\x39\x20\xef\x39\x52\x8c\xd3\xec\x8e\xce\x55\x8f\x5c\xc1\x0c\x64\x8f\x5c\x8e\xaf\x84\x1e\x5a\xd1\xbb\x19\x6d\x67\x6f\x24\x6c\x4c\xde\x60\x4d\x1b\x4d\x34\x9d\xa0\xe2\xe4\x7d\x80\x3d\x03\xff\x70\x02\x4b\x1c\xee\x98\x5a\xa9\xa9\xb4\x46\x9c\xdf\xe3\x4c\x86\x50\xd9\xbf\x3f\xf9\x36\x65\x6c\x0c\xc9\x3c\xc9\xda\x9f\xab\xd3\x04\xa3\x17\xea\x3c\xf3\x00\xbf\x5d\x99\x76\x97\xda\x89\x2a\x20\xe3\xc4\xd6\x4f\xb7\x85\xe1\x6b\x54\xaf\x56\x64\x55\x5d\xd5\xa9\x86\xb8\x33\xe7\x6c\xcb\x33\x0b\xa1\xf4\xb5\x51\xcf\x3b\xa9\xb2\x7e\x38\xf4\xd3\x11\xac\x25\x9d\x65\x90\x12\x96\xe7\x90\x1a\x15\x3e\x9b\x13\x3a\xd6\x98\x62\xdb\x30\x0f\x24\x12\x2c\xd6\xba\xda\x25\x53\xca\xd3\x0c\x24\x19\x53\x96\x39\x63\x40\xe3\x7e\x0d\x32\x67\x1c\x6d\x02\xd6\x1d\x8b\xf6\x05\xf3\x57\x92\x08\xe9\xeb\xde\x33\xad\xfc\xa5\xfa\x60\x22\x13\x09\x10\x60\xd1\xaf\x4c\x46\x99\x48\x6e\x15\x29\xb9\x66\x99\x5d\x8c\x10\xb7\x24\x11\x79\x91\xe1\xd1\x69\x71\xb2\xaa\x7f\xf6\x2b\x54\xea\x9b\xd9\xd5\xc9\xef\xeb\x4b\xf8\xc3\xae\xdc\xbc\x03\x29\xac\x0b\x19\x0c\xee\x21\xe9\x2c\xbd\xff\xe2\x1e\x92\xa0\x9c\x04\x36\x7a\xc0\x13\x8d\xe9\x9d\xf4\x16\x5e\x50\xfd\xba\x16\x59\x74\xe1\x68\xc0\xef\xcc\xce\xe9\xcb\x5f\xb9\x57\x90\x8c\x71\xa4\x6f\x2e\xb3\x8e\x30\xae\x0c\x67\x6f\x1c\x06\x7b\xf4\x9c\xc4\x4a\x52\x26\xb1\xf8\xc1\xbc\x8a\xa2\xf6\x73\x61\x5d\x01\x21\x34\x39\x3a\x3c\x39\x3c\x5e\x32\x3e\x1e\x1a\x09\x24\x03\x4b\x6b\xad\x25\x32\xa9\x17\xa5\x58\x5e\x64\x73\x5c\xc7\x61\xda\x23\x4c\xfb\x30\x6b\x59\x72\xbf\x2a\x97\xee\xd7\x23\x4a\x10\x2d\xa9\xaf\xa9\x62\x7f\x35\x37\x69\x59\x3a\x2a\x7f\x74\xf8\xdb\x61\x8f\x80\x4e\x8e\xc9\x9d\xe0\x87\x1a\x97\x3f\x20\x37\xc2\xc8\xd1\xf5\x44\x73\x51\x12\x0e\x36\xaa\x1f\xee\x8b\x8c\x25\x4c\x67\x73\xa4\x58\x44\x94\xda\xa6\x0e\x53\xed\xd3\x0c\x2f\xee\x99\x76\xc1\x6a\x86\x64\xbc\x42\x68\x5a\xaa\x45\xa8\x11\x73\x66\x70\x32\x05\x9a\xe9\xa9\x8d\x10\xe1\x82\xf7\xff\x05\x52\x60\x02\x22\x77\x57\x5e\x5c\xad\xbf\x4e\xd4\x06\x43\x44\xbf\x81\xee\xba\x03\x7d\x7b\x73\x33\xfc\x06\xf4\x02\xc9\x30\x6f\xf1\x71\x3b\x68\x0a\x00\x39\x16\x32\xdf\x03\xda\xd1\x8d\xa7\xb2\x4f\x0a\x21\xf7\x81\x84\x4d\x85\x6a\xb5\x97\x64\x69\x3f\x85\xd2\xa8\x0d\x39\x69\x8c\x43\x62\x76\xb0\x19\x40\xe2\x1b\xe8\x5c\x0e\x07\xe4\xef\xa2\x34\x5f\x33\xa2\xa3\x6c\x5e\x15\x60\x50\xa0\xc9\x81\x99\xea\xc0\x90\x27\x83\x0d\xdf\x02\x4d\x8d\x8a\x62\xa8\x07\xd0\xfd\x68\x94\x45\xdc\x79\x70\x6b\xeb\x96\x0f\x94\x4a\x8b\x9c\x4c\xdd\x67\x37\xf3\x2e\xdd\xc9\x18\xe0\xe9\xf1\x49\x4d\x12\x0a\x4b\xe1\xdc\x33\x2f\x8e\x7e\x2d\xd1\x0d\x0b\x77\xf7\xfb\x08\x8b\x57\x25\x21\xd8\x5c\xa7\x28\x9b\x15\xc4\x2d\xb0\x0c\xaa\xc1\x6e\x7e\x92\x70\xec\x71\xc5\xd1\x9d\xb3\x38\x17\x27\x42\x8f\x5e\xfb\x40\xaf\x4e\xeb\x8d\x76\x13\x34\x40\x56\x59\x58\x1d\xce\x58\xeb\x4b\x47\x40\xfc\x38\x05\x2f\x3f\x05\x00\xba\xd9\x7c\xd2\x25\x04\x8a\x0e\xe2\xba\x97\xa3\xba\xb5\x30\x7a\x28\xe6\x5d\x5a\xe2\x8a\x64\x42\x81\x9c\xed\x9a\xc9\x5d\x8f\xee\x3e\x5d\xec\xae\xf1\xfb\xb1\x22\x49\x5a\x12\x5e\xe6\x23\x90\x75\x5a\x8a\xd4\xcb\x00\x09\xc2\x12\xae\xec\xed\xde\x96\xdb\xec\xcb\x68\x9e\xfc\xf3\x7f\xfc\xc7\x1f\xff\x63\x60\xa7\xaf\x42\x14\x38\xb9\x3c\xbd\x3a\xfd\xf5\xfa\x87\x33\xcc\x8c\x6d\x0b\xd5\x8e\xe2\x2f\xbb\x8e\xbe\xec\x34\xf6\xf2\xa3\x46\x5e\x62\xbe\x47\x6b\x2a\xd2\x34\xfc\xe3\x94\x06\x03\x8c\xde\x66\x34\x4e\x27\xfb\x05\x35\xca\x8c\xac\xd9\x34\xa4\x9a\xa3\xb6\x17\x67\x4c\x27\xc5\xb5\x48\x6e\x3b\xd4\x6b\xce\xa1\x90\x90\x58\x3b\xd9\xcd\xd9\xd0\xce\x6e\xf4\xcb\xab\xf7\x37\x75\x9e\x01\x06\xe3\x90\xb7\xde\xbe\xf4\xad\xb3\xa4\x19\x9d\xf4\x16\x0a\x5d\xa9\xee\x23\x9a\xdc\xde\x51\x99\xa2\x65\x8b\x6a\x36\x62\x19\xb3\x25\x7f\x7d\xb7\x49\x2e\x6c\xb4\x9f\xad\x6d\x26\xc6\x8b\x05\x35\x6b\x73\x28\x9a\xac\x6c\x10\xcd\x98\xb2\x0c\x2d\xa8\x25\xd7\x2c\x07\x17\x0e\x94\x14\x95\x49\x2f\xb4\x69\x47\xe5\xcb\x8f\xbd\x55\xbe\x0e\xdf\x7b\x97\xde\xd6\x7a\x58\xdb\xa0\xc4\x3d\x66\x75\x8e\xc5\xd9\x6c\x90\xc8\xea\x3e\x0b\x56\x57\x48\xb8\xd6\xa2\xe8\xc8\x4b\x62\x27\x5b\xe3\x23\x19\xc1\x58\x18\x22\xbc\xd6\xe9\xe1\x9b\x0f\x73\xcc\x0c\xf4\x56\x2d\xd1\x70\x6c\xd8\x70\x4c\x55\x26\x53\x6f\xa0\xe4\xa0\xd4\x09\xba\x43\xca\xc2\x6a\xad\x48\xae\x4b\x09\x3d\xf3\x75\x90\xe3\xea\x7a\x75\x8a\x83\x79\x3d\x70\xfb\x23\xe8\xc4\x5a\x6e\x03\x42\x8e\xf5\x40\xdd\xf2\x17\xdd\x28\x89\xa4\x6a\x0a\x58\x5b\x04\xee\x99\xef\x81\x32\x14\xe9\xe1\x61\xfd\x29\x86\xb1\x4c\x24\x4d\x80\x14\x20\x99\x30\xcc\xa8\xe4\x3a\x15\x77\x9c\x8c\x60\xc2\xb8\xf2\xa0\x30\x73\x7b\x98\xa1\x3f\x86\xa9\xaa\x24\xdc\x80\x7c\x68\x54\x3a\x71\x39\x48\x89\xa8\x8f\xa6\x5b\xf3\xa2\x27\x09\x39\x56\xd0\x8b\xb9\x82\xb0\x8f\x8d\xd5\x1b\x2c\xf9\xa8\xe4\xf8\xe6\x14\x32\x3a\xb7\xa1\xa6\x63\xc6\x69\xc6\xfe\x05\x52\x1d\x77\xe0\x71\x32\x20\xac\xaf\xad\x5d\x07\x16\xe8\xa7\xc9\xb4\x9d\xf3\x37\xba\xa8\x36\x1c\xd1\x45\xd5\x66\x92\xe8\xa2\x8a\x2e\xaa\x47\x46\x74\x51\x45\x17\xd5\xc2\xd8\x5b\x2d\x29\xba\xa8\x76\x1e\xd1\x45\xf5\xf0\x88\x2e\xaa\x0d\x46\x74\x51\x6d\x38\xa2\x8b\x2a\xba\xa8\xa2\x8b\x2a\xba\xa8\x3e\x23\xbb\x9d\x1f\xd1\x45\xb5\x34\x49\x74\x51\x45\x17\xd5\xc6\x63\x6f\x95\xaf\xe8\xa2\xb2\x23\xba\xa8\x9a\xe3\xf3\x62\x75\xde\xc1\x33\x34\xaa\x5e\xfb\x9c\xb6\x21\x3a\x15\x58\xe2\xfc\x44\x61\xaf\xb8\xea\x55\x41\x7b\xb8\xa0\x26\x88\x4f\xc5\x71\x1e\xa1\xda\xcf\xb4\x32\x5f\x6a\x5b\x57\x85\x4f\x32\x54\x27\x85\xb0\xff\x57\x3b\x2a\x02\x0f\x85\x55\x78\x77\xcf\x59\x7b\xb2\x6c\xac\x36\x6e\x89\x4f\xe3\x92\xd8\x13\xff\x4d\x07\x6e\x88\xe8\x82\x78\x71\x2e\x88\x97\xd3\x2c\xd7\x79\xe6\x6f\xa6\x12\xd4\x54\x64\x3b\x23\x7a\x03\xc9\xdf\x31\xce\xf2\x32\x37\x38\xa7\x0c\x3e\xb3\x59\x15\x02\xa0\x2a\x74\xb5\x14\xdb\x5a\x11\xcd\x8d\x2c\x05\xac\x74\x4a\x59\x66\xb6\x11\xf3\x37\xa7\x74\x66\x70\x5d\x95\x49\x02\x80\x7d\xd4\x42\x0d\xe7\x8f\x83\xea\x4d\x55\xdf\x8c\xd7\xed\xe8\x4d\x3b\x26\x6e\x6b\x91\xe2\x2c\x7f\xfc\xc3\x4e\x73\x4c\x64\xd1\x0d\x5d\xfe\xe6\xc3\xf0\x2c\x6c\x8e\xcd\x3d\x59\x66\x7c\x26\xb2\x99\xed\xab\x8f\x37\x19\x61\xcd\xb5\xe0\x67\xf6\xc6\xac\x98\xd2\x40\xbb\x71\x8a\x81\x22\xc0\xe9\x28\x33\x4f\x9a\xe7\x2a\x9e\x3c\xb4\x9c\x17\xa8\x2e\x25\x90\x09\xd5\x4f\x49\xf2\xdb\x2b\x31\xad\x14\x98\x2e\x38\x4e\x5b\x19\xbd\x69\x85\x33\x92\x78\xd3\x0e\x35\x41\xcc\xb0\x05\xf4\x37\x96\xc4\x5b\xd3\xca\xf6\xd2\x71\xfb\xc3\x45\xb0\xc2\x0d\x7e\x78\x67\x00\x3e\x70\xbd\x9e\x3d\x43\x0f\xd5\x20\xdf\x54\x4a\x0b\x52\x64\xb4\x6e\x0b\x85\x3b\xf0\x2d\x72\xa1\xb3\x29\x24\xb7\x1f\x9c\x2f\xf6\x48\x01\x54\xd2\xe9\x84\xe9\x69\x39\x1a\x24\x22\x3f\x31\x44\xc1\xfe\xdf\x28\x13\xa3\x93\x9c\x2a\x0d\xd2\x08\xac\x8e\xc9\xf5\x13\x33\x0b\xe3\x93\x41\x9e\x1e\x0f\xc8\xcf\xdc\xe6\xb7\xd7\x6d\x28\x83\xea\x0e\xe6\xfd\xbe\xd2\xc6\x08\x0c\x7d\x15\x32\xec\x1b\x3e\x9a\xe3\xf2\x06\xed\x5b\xc9\xb7\x60\x4a\x2d\xfd\xe0\x9f\xde\x07\x1e\x29\x17\xe9\xc0\xe4\xf2\xdc\x7c\xdd\x9d\xc5\x7c\x74\xe0\xe3\xde\x23\xff\xf6\xde\x08\xc7\xfb\xe2\xd3\xde\xc3\x62\xd3\x1d\xb8\x60\xbb\xf0\x61\x77\xe7\xbf\xfe\x08\x35\x99\x3f\x8e\xdf\xba\x43\xe3\x5e\x47\xfe\xea\x4f\xe1\xab\xee\xe4\xab\xdb\xfa\xa8\x3f\x9d\x7f\xba\x9b\xcf\xed\x52\x11\x78\xae\x3e\xe9\x0e\x8c\xf4\x5d\x1a\xe8\x3b\x33\xce\x7f\x34\x1f\x74\x7b\xff\xf3\x1e\xf8\x9e\x5b\x03\x99\x71\xa6\x19\xcd\xce\x21\xa3\xf3\x6b\x48\x04\x4f\x77\xe6\x30\x0b\x45\x3a\xab\xf3\xa3\xec\xb4\xce\x52\xd5\x4c\xb5\x98\x52\x57\x8b\xdc\x68\x54\x36\xb5\xc4\x7b\x33\x9c\x40\x81\x7e\x65\xbb\xca\xbd\xf4\x4f\x90\xbd\x31\x89\xd9\xbc\x93\x2e\x37\xf1\x5b\x71\x47\xc4\x58\x03\x27\x47\x8c\xfb\x7d\x3c\x0e\xd4\xc0\xda\x3e\x59\xa1\xb5\xb9\xfa\xfa\x95\xbf\xf9\xe5\x19\x1e\xd1\xc4\xaa\xd4\xc7\xb7\x03\xbb\x17\x3d\x6e\x08\x76\x37\x8e\xcb\xac\x69\x0c\xb6\x06\xe2\x26\xbd\x79\x5d\x57\x53\x7e\x8d\xf3\x56\xa7\x8d\xf2\x94\xb8\x5c\xb4\x97\xb7\x69\xad\x23\x6b\x9a\xa2\x5f\x15\x49\xf3\x98\xdd\xf8\xe6\x6c\x68\xcd\xc6\xd1\x5c\xb2\x2f\xe6\x92\x27\x8a\x4e\xd9\x43\x41\xf7\x99\x46\xa4\x44\x41\x77\x8b\x11\x64\xa7\x7e\x23\x69\x02\xc3\xce\x65\x04\x7f\x9c\x48\x5a\x4a\xea\x08\x60\x25\xf2\xf9\xc3\xc3\x01\x52\x7b\x9a\xaa\x8c\x5e\xcc\x95\x1d\x97\x59\x36\x27\x65\x21\x78\x33\xff\xd9\x7a\xdb\x17\xd3\x69\xd1\x24\xbf\xe2\x2d\xb5\x60\x59\x48\xe1\x78\xa6\x2c\x39\x37\x34\xb8\x6e\x89\x86\x82\x24\x16\x6a\xa6\x8d\xa4\x5d\xc5\x26\x66\xf9\x86\xff\x61\x3e\x6f\x1d\x82\xd8\x98\xd0\x3c\x3d\x16\x32\x61\xa3\x6c\x4e\xa6\x34\xab\xfa\xdf\x50\x72\xcb\xb2\xcc\x4d\x33\x20\xd7\xa0\xad\x4b\xc1\xf2\xce\x4c\xf0\x09\x2e\x8e\x72\xdf\x77\x11\x12\xf3\x6c\x92\x01\xe5\x65\x61\xdf\x67\x38\xf1\x5c\x94\xd2\xbf\x6f\x50\x39\x26\x2a\x0e\xcc\x59\xd6\x0b\xba\xbb\x3d\xb8\xb1\x55\xf4\x4f\xa9\x8c\x00\xf0\xde\x17\xa6\xee\x85\x73\xfa\xda\xe1\x2a\xe8\xed\x53\x48\x31\x63\xa9\xf5\x6e\x78\xb0\x61\x1f\x69\xdb\xbf\xa7\x3a\xcf\x5c\xf0\x3e\x87\x09\x45\x41\xc5\x9d\x22\xbb\x67\x76\x1e\x1b\x43\xc0\x53\xec\xe8\x63\x24\x7c\x51\x34\x12\xea\x67\xcc\xf6\x22\x0e\x20\x47\x8e\xb8\x20\x02\x23\x52\x4b\xce\xb4\xed\x6f\x3f\x2d\x35\x49\xc5\x1d\x3f\x0e\xfc\xae\x64\x04\xfa\x61\xaf\x2b\x3a\x5a\x6f\x56\x02\xa8\xe9\x7e\x5d\x25\xe7\xd8\xef\x7d\x18\xbc\x4c\x39\xd3\xe7\x98\x94\x5c\x41\x4b\xf6\xde\x99\x70\xf4\xe7\x3f\xed\x46\x23\x58\x0e\xa2\xd4\x9f\x44\xfb\xbb\x9b\xb2\x64\x1a\x0a\xb3\x2c\x07\x45\x44\xb9\xa0\x16\xbf\x76\x8f\xad\xde\xa1\xa8\x02\xae\x1a\xbb\x1a\x76\x57\x58\xbf\x16\x0b\x22\xd4\x8d\xaf\x31\x52\xfc\xfc\xea\xfa\xd7\xb7\xa7\xff\x75\xf1\x76\x40\x2e\x68\x32\x0d\xab\x62\x70\x42\x91\x68\x20\xa1\x98\xd2\x19\x10\x4a\x4a\xce\xfe\x59\x3a\x87\xef\x51\xf5\xec\x71\xa7\xd5\xda\x77\xe4\xbe\xd8\x9c\xbf\xb3\x6e\x70\xb6\xd5\xbf\x8d\xcc\x12\x0a\xb0\x7f\xcb\xa2\xf8\x74\x61\x2e\x59\xe5\x00\x45\x2d\x0c\x9d\x9f\xb0\x99\x23\xc3\xae\xfc\x3d\x4d\xab\x58\x31\x83\xe7\x06\x2d\x0c\xab\xa2\x23\x8c\xf1\x9a\x02\xe1\xa0\x0d\x5a\x57\x36\x26\xc1\x55\xa3\x3c\x49\xa9\x40\xf5\xc8\xa8\xc4\xa8\xb4\x42\xb2\x9c\x4a\x96\xcd\xc3\xc9\x0c\xaf\xba\xaa\x5c\xde\xf3\xc5\x25\x9d\xbf\xbf\xb8\xc6\x2c\x81\x42\xda\xc2\x25\x18\x56\x86\xd7\xf1\xb3\x46\x60\x9e\x70\x5d\x84\x07\xe4\x94\xcf\xed\x45\x7b\xc0\x99\x22\x19\x53\x1a\x90\x05\x3b\x19\xd2\x3b\xd3\x0f\x5e\x0d\xf0\x7f\x07\xe6\x2b\xa5\x11\x32\xab\x68\xb9\x64\x29\x7c\xd5\x8a\xa1\x6c\x94\x05\xd0\x74\xdf\xfe\xa2\xfa\xc1\xd5\x41\x42\x06\x88\x41\x3f\x38\x5a\x6d\x35\x82\xd7\xf6\x07\x64\x7c\x92\x85\x58\xb5\x1b\xd9\x6f\xab\x5b\xb6\xd5\x2c\xfb\xf5\x17\x0c\x77\x55\x30\x3b\xe9\x4b\x57\xaf\xa1\xa3\x6e\x4e\x35\xf7\xf3\xea\x94\xa3\x08\x22\x6c\xd0\x7b\x39\xf4\x27\xc0\x49\x37\xf9\x42\x57\xd7\xa2\x8e\x49\xea\x91\x57\xe4\x6f\xe4\x9e\xfc\x0d\xd5\xab\x3f\xb7\xed\x7d\xd5\x56\xf1\xe9\x22\xc4\xc8\x68\xf5\x97\xc3\x8e\x20\xfe\xa3\xa1\x4e\x66\x46\x03\x55\x2d\xc8\x88\x39\x71\x1e\xee\x35\x48\x43\x47\xdd\x4e\x3c\x69\xd7\x30\xb3\xc0\x4f\x88\x66\xd6\xdd\x70\x39\x6e\x86\x35\x6d\x87\x68\xe6\xf1\x6f\x85\xd2\x57\x8e\x0a\x35\x5b\xe0\xd4\xb3\xe5\x54\x27\xd3\x26\x19\x33\x82\x9a\xd2\xf5\x01\x53\x24\x15\x18\x65\x65\x03\x98\xa7\xac\x45\xf0\xc4\xfe\xa0\x71\x3b\x7f\x7a\x63\x3f\x1f\xda\xa9\x05\x03\x0a\x6a\x3e\x4e\xb0\x0a\x6a\x63\x15\x22\x75\x32\x99\x59\x56\x1a\xf0\x8c\x07\x84\x32\x67\xab\xa9\xac\xcc\x88\x4b\xe6\x3c\x25\x94\xdb\x14\x92\x31\x48\x69\x63\xce\x47\x73\x1f\xac\xd7\x7a\xf3\x5a\x9d\xa4\x42\x0a\x2d\x12\xd1\xa2\xb1\x59\xd3\xc7\xed\xa6\x43\x20\xd8\x38\x5f\x6f\x26\xff\xfe\x7c\xd8\x23\x37\x67\x43\xec\xf7\x74\x7d\x76\x33\x6c\x6a\x2a\x07\x37\x67\xc3\x83\x27\x05\x05\xf1\x92\x15\x1a\xa6\x77\x98\xa4\x61\x78\x32\x62\x5b\x3f\xa7\x45\xff\x16\xe6\x3b\xf2\xd4\x2e\xf8\x7a\xbf\xda\xe1\x4e\x3e\xc8\x82\x39\xa7\xc5\xd6\xb3\x49\xa0\x29\xfb\x44\x79\x5c\x3e\x0c\xb6\x7a\xe7\xea\x84\xae\x5c\xcc\x20\xb5\xe2\xb0\x7f\x02\x78\x5a\x08\x66\xe4\xc5\x98\xe5\xb5\xfd\xd3\x31\xcb\x6b\xe3\x11\xb3\xbc\x62\x96\xd7\xf2\xd8\x9b\x40\xd6\x98\xe5\xf5\xb2\xfc\xf6\x31\xcb\xeb\xb3\x77\xfe\xc7\x2c\xaf\xd5\x23\x66\x79\xc5\x2c\xaf\xcd\x46\xcc\xf2\xda\x7e\xec\x5d\xd8\x52\xcc\xf2\xda\x6a\xc4\x2c\xaf\xe5\x11\xb3\xbc\xd6\x8c\x98\xe5\xb5\x66\xc4\x2c\xaf\x98\xe5\x15\xb3\xbc\x62\xf0\xeb\xa3\x73\xed\x67\xf0\x2b\x89\x59\x5e\x6e\xc4\x2c\xaf\x17\x11\xe2\x47\x62\x96\xd7\x46\x23\x66\x79\xc5\x2c\xaf\x5d\x46\xcc\xf2\x7a\x29\xe6\x92\x98\xe5\x15\xb3\xbc\x3e\x1f\x41\x37\x66\x79\xc5\x2c\xaf\x98\xe5\x15\xb3\xbc\x1e\x5c\x45\xcc\xf2\x7a\x09\x2a\xa0\xef\x05\xdc\x3e\x6b\xe9\xf0\x4c\xe4\x45\xa9\x81\x7c\xf0\x53\x56\x52\xa4\x25\x0c\x4c\x85\x12\x41\xfb\x20\xc2\x44\xf0\x31\x9b\x38\xca\x7e\x62\x1b\xf0\xf6\xab\xef\xe9\x07\x4d\x6f\x9f\x61\x04\x61\xc6\x72\xb6\x5b\x2a\x19\x59\xda\x98\xb7\x38\x57\xe0\x97\x31\x27\x29\xa7\xf7\x78\x44\x68\x2e\x4a\xdb\xb4\x38\x71\xfb\x57\x81\xd0\x7a\xaf\xf6\x6e\x67\x48\x37\x2a\x4e\x9d\x13\x37\xec\x22\xac\x84\x6a\x0d\x92\xbf\x21\xff\x7d\xf4\xf3\x97\xbf\xf5\x8f\xbf\x3a\x3a\xfa\xe9\x55\xff\xaf\xbf\x7c\x79\xf4\xf3\x00\xff\xf1\xef\xc7\x5f\x1d\xff\xe6\xff\xf8\xf2\xf8\xf8\xe8\xe8\xa7\xef\xde\x7d\x73\x33\xbc\xf8\x85\x1d\xff\xf6\x13\x2f\xf3\x5b\xfb\xd7\x6f\x47\x3f\xc1\xc5\x2f\x1b\x4e\x72\x7c\xfc\xd5\x17\x3b\x2f\xb9\xb5\x48\xdc\x9d\x40\xdc\x91\x38\xfc\x51\x84\x61\xe7\xd0\xed\xe8\x2c\xba\x60\x94\xa5\xd3\xe8\x18\xd6\x43\xa7\xd1\x53\x53\x14\xf3\xaa\x79\x98\x22\x22\x67\xda\x08\x87\x46\x1e\xa4\x61\x40\x2b\xd3\x0d\xa5\xd4\xd1\x01\x0c\xe9\xa6\xda\xb6\x58\xaf\x82\x41\x83\x20\x16\xe1\x25\x3f\xd7\x83\x9e\xe5\x45\x86\xad\xcd\xf1\x3c\xf7\x7d\x2c\x0b\x32\xd7\x48\x1b\x1e\x1f\x91\x36\xbc\x44\xda\xa0\x20\x29\x25\xd3\xf3\x33\xc1\x35\xdc\xef\x64\x61\x69\x92\x86\xeb\xe6\x84\x2e\x66\xcc\xe5\x71\xbb\x6b\x44\x14\x36\xf2\x7b\x21\xa1\x7e\x2a\xca\x2c\xc5\x74\x8e\x92\xa3\x82\x69\xf3\xf4\x40\x5b\xed\x0f\xf5\x1e\x0c\xe6\x5e\x7c\x89\xd7\xe7\xac\x9a\xf9\xcf\x92\xcd\x68\x66\xb4\xdd\xfa\x89\x21\x6a\x30\xe1\x43\x9b\x9e\x79\x4d\xd5\x6d\x7d\xe0\xa1\x6f\x64\xe8\x6a\xcd\x27\xfe\x93\xf0\x27\xb8\xd7\xcf\x51\x4a\x43\x01\x69\x28\xd9\x8c\x65\x30\x81\x0b\x95\xd0\x0c\xe9\x5a\x37\xbc\xe2\x74\xcd\xec\xb8\xf1\x52\x64\x8a\xdc\x4d\xc1\xd0\x6a\x42\xbd\x09\x00\x73\xec\x26\x94\x71\x92\x9b\x2d\x2a\xfc\xc3\xca\xda\x12\x0c\xf9\x2f\xa8\x34\x1b\x5c\xd9\x0c\x50\x45\x1e\x09\x91\xb9\x9c\x87\x6c\x5e\xcf\xef\xb2\x7f\xb8\xf8\x95\xc3\xdd\xaf\x66\x36\x45\xc6\x19\x9d\x54\xa6\x02\x05\x7a\xc9\xda\x57\x4f\xbd\xf6\x03\x30\xa1\xa0\x04\x42\xb3\x3b\x3a\x57\xb5\xe1\x24\xa8\xfc\xa0\xde\x90\xd7\xc7\x88\xce\x54\x91\x6a\x8e\x94\xfc\xe1\x18\xdd\x7f\x67\xa7\xc3\x5f\xaf\xff\x7e\xfd\xeb\xe9\xf9\xbb\xcb\x2b\x72\x25\x34\x58\xa6\x16\x34\x08\x4c\x2a\x0d\xc3\xac\x12\xdf\x81\x5a\xba\x50\x03\xb4\x5d\x32\x45\xee\x18\x4f\xc5\x9d\xda\xd9\x46\x6b\xd1\xcf\x00\x0f\x28\xdf\x69\x8e\x84\x16\x14\xfb\x1e\xb6\xe0\x30\x4b\x11\x26\xe1\xa4\xc8\xc3\xd3\xf4\x24\x95\xa2\xb0\x40\xf0\x46\xae\x9a\xd5\x36\xd5\xe8\x30\x86\x15\xf7\x77\xdc\x9c\x70\x22\x29\xd7\xb5\xb5\xa7\xde\x33\xd7\x70\x71\xd0\x7a\x3b\x9e\x77\x4e\x13\x4d\xbb\xcb\x67\x3a\x4d\x53\x48\x1b\xe0\x7f\x71\x91\x83\x67\xfe\xe3\xe6\x75\x9d\x0a\x32\x7c\x7f\x7d\xf9\xbf\x17\xf0\x78\x5e\xb4\x0b\x94\xea\x26\x37\x56\x8a\xa2\xb3\xdd\xfd\xe0\x72\x2f\xe3\xfe\xee\xc5\xfe\x56\xdc\xb2\x1b\xf7\xfc\x87\x92\x37\x4b\x19\xd5\xf3\x93\x5c\xa4\x30\x20\xc3\xca\x4f\xd0\xbc\x1a\x94\x38\xa0\x12\x88\xb9\x85\x6b\x46\xb3\x6c\x1e\x8a\x68\x5a\xd8\x3c\xc4\x46\x75\x86\x90\x90\x8f\x69\xa6\x9e\x9a\x1a\xb7\xe1\x8d\x46\x8e\x78\x67\xf4\xe1\x4e\xb6\xa3\x9a\x8d\xa4\xc0\x85\x76\x82\xb5\x59\x25\x56\xbc\x90\x22\x21\x56\xf9\x0e\x82\xb1\x1a\xfc\x4d\x59\x5f\x85\x67\x8d\x4c\x79\x60\x0f\xab\x99\xad\xa1\xba\x54\xb0\x28\xa0\xfb\x5e\xc4\x95\x3a\x6e\x66\x97\x40\x53\xc1\xb3\x39\x46\x5e\xda\x58\x8a\x9c\xaa\x5b\x48\xed\x0f\x4e\x34\xab\x3c\x15\x66\xc6\xea\x55\x37\x66\xdd\xde\x2d\x81\x22\x99\x8d\xf0\x40\x77\x06\xa4\x4f\xbc\xeb\x2d\x0e\xa1\x01\xca\x7b\x9e\xcd\x3f\x08\xa1\xbf\xae\x12\x69\x3b\xc1\x80\x1f\x9d\xb4\xdc\x34\x45\xa3\x38\x49\xf1\xbd\x7d\xdc\x0d\x3c\x54\x61\x0e\xef\x79\xbd\xe3\xcf\xfd\x48\xc9\x92\x9f\xaa\x6f\xa4\x28\x77\x66\x62\x4b\xc2\xe6\x37\x97\xe7\x48\x8a\x4a\xe7\xaa\xe4\x5a\xce\xb1\x78\xc0\x72\xdd\xb7\x4a\x31\xf8\xde\x39\x5b\xc3\x33\x51\xfb\xc5\xc8\x3b\x3a\x27\x34\x53\xc2\xc3\x92\xf1\x95\x5a\xa8\x53\x71\xcd\xe5\x91\xd0\xd3\x25\xdd\xd6\x1c\xa8\xe5\xe7\x7a\x81\xe7\xb2\x2e\x44\xc7\xf8\xd2\xe3\x9a\xde\x82\x22\x85\x84\x04\x52\xe0\xc9\x53\x6f\xfb\x53\x3b\xfc\x10\x75\xae\x04\x37\x07\xb3\x13\xe4\xb9\xac\x3c\xbd\x0e\xa4\x21\xaa\xa0\xcf\xd8\x69\x7f\x14\x3d\xc7\x78\x2c\x4b\x05\xd2\xba\xb9\x65\x09\x76\x27\xbf\x2b\x47\x90\x19\xc8\x1b\x95\xd4\x75\x8b\xb7\xe6\x0c\x96\xd3\x09\x10\xaa\x2b\x4c\xd3\x82\x00\x57\x86\x62\x5a\x03\xa8\x26\xa9\x80\x3a\xff\x9e\x2a\xf2\xfd\xe5\x39\x79\x45\x8e\xcc\xbb\x8e\x11\x7f\xb0\x99\xbc\x16\x36\xc8\x6d\x51\x47\x1d\xfb\x29\x70\x49\x88\xbc\x44\x48\x4b\x24\x7a\x84\x0b\xa2\xca\x64\x1a\x76\xb0\xf7\x6a\xb3\x0b\x84\x44\xd7\xca\x7e\xe2\xfa\xd3\x52\xa8\xef\x15\xc8\xce\x08\xd4\xf7\x3b\x10\xa8\x50\x8c\x32\x38\xd7\x84\x9e\x45\xac\x1c\x34\x4d\xa9\xa6\x8e\x70\xf9\x1b\xf6\x76\x4b\x3f\x6f\xf2\xa5\xe0\x2d\xe3\xe5\xbd\x0d\x3c\xea\xce\xd4\x72\x7d\x81\xd3\x92\xc4\x43\x1d\x77\x9d\x16\x45\xc6\x6c\xbd\x8d\x85\x40\xb8\xcb\x06\xae\xf4\xd6\x88\x89\x48\x27\x68\x96\x09\x43\x1f\x8d\x70\x42\x79\x2a\xf2\xa5\x97\x19\x21\x12\x1a\x15\x53\x07\x24\x62\x5f\x73\xec\x89\x51\x28\x83\x19\xb4\xa8\x2e\xb6\x58\x21\xd6\xcc\x66\x80\xe3\x31\x02\xa7\x27\x19\x1d\x41\x66\x61\x6c\x31\x50\x2d\x63\xe0\x53\x47\xa3\x4a\x91\x75\x97\x3e\xf3\x41\x64\x60\xc3\xbb\x3c\x20\xcc\xf4\xcf\x02\x0e\x38\x49\x57\x70\x40\x6d\xb0\x01\x07\xd4\x6b\x9f\x03\x1c\xca\x16\xac\x9e\x2c\xc2\xc1\xc8\x0d\x4d\x38\x20\xf3\xde\x77\x38\x28\x48\x12\x91\x17\x43\x29\x8c\xda\xd9\x19\x6f\x72\xd3\xd6\x3e\x43\x6b\xd8\x58\x11\x8c\x85\xbc\xa0\x79\x33\x95\x41\x60\x27\xd5\x96\x49\xf8\xe8\xce\xff\x15\xf0\x2c\x24\x3d\x8b\x8c\xcc\xcf\xd2\x70\x2f\x9a\x27\xdd\x85\xe7\xcc\x0e\xba\xc8\x8d\x68\x61\xec\xec\x84\x1b\x89\x84\x66\x58\x3d\xb6\x1d\xca\x91\x45\xb4\x5b\x9c\x38\x08\xe7\x45\x1f\x25\xfe\xe6\x03\x48\xb0\x90\x28\xfe\xe2\x4c\x98\x5c\xa4\x10\xf8\xb2\x6d\x1c\xf2\x8d\x0d\xfb\xc4\xfb\x7c\x24\xb1\x91\x2b\xbc\x5b\x39\x6d\x3c\xad\x85\xab\x81\xf6\xae\xaa\x49\x6b\x16\x08\x3c\x65\x7c\x82\x76\xb5\x1e\x91\x90\xd9\x18\x64\x47\x04\x6e\xad\x06\x79\x88\x47\xc2\x4f\xea\xcf\x83\x7f\x35\xca\x62\x4c\x70\x37\x33\x5a\x8a\xbc\x84\x35\xb6\xe4\x96\x29\x72\xf0\xd6\x03\xa0\x45\x11\xcf\x7d\xe4\x30\x07\xf6\x0b\xab\xdd\xb4\x96\xce\x5b\xc6\x53\x17\xae\xdb\x00\x56\x55\x6e\xdd\xca\xc1\x18\x08\xce\xd2\x90\xb6\xbc\x21\x3f\x73\x52\x01\x8b\xf4\x77\x46\x8f\x0f\x56\x64\xf6\x36\xba\xfe\xc3\x86\xd7\xea\x25\x8b\xd3\x7c\xcf\x71\xef\xcd\x7b\xfb\x46\x73\x5f\xbe\xcf\x7f\xcb\x93\x96\xee\x71\xd4\xaf\x6b\x2d\xe6\x47\x3b\xad\x17\xe9\x13\x83\xd6\x9a\xf1\x89\x0a\x35\x19\x9a\x65\x0d\x63\xf8\x2a\x55\xc6\xef\x70\x55\x5c\x7f\x59\x85\x58\x48\x33\x78\x2e\x6a\x48\x66\xc4\x89\x67\xae\x84\x4c\x72\x45\xcf\xa4\x81\x84\x66\x34\xbb\x2e\x76\x2f\x52\x4a\x96\x0a\xe2\xbd\xbb\x3e\x6d\x4e\x8d\xcc\x1a\x7b\x3f\x98\xbd\x32\xd7\x09\x4d\x73\xa6\x14\x1a\xc2\x60\x34\x15\xe2\x96\x1c\xad\xa8\xc7\x15\xc4\x69\x29\x36\x51\x27\x0e\xe7\xfb\x66\xf5\xc7\x84\xf1\xac\x8a\x8a\x42\x3d\x98\x6b\xe5\x0d\x39\xf8\x92\xa4\x5a\x05\xee\xa1\xab\x5c\xed\x82\x15\x96\x97\x69\x6b\x55\x1b\x2c\x78\x72\x82\xbd\xbc\x3d\x57\x2d\xcb\xae\x3c\xb2\x45\x57\x0e\xb7\x17\x2b\xab\xad\x84\xa3\x95\x1e\x9f\x1c\x48\x4e\xb8\x48\x40\x75\x57\xd0\xe9\xdb\x7a\x4e\x92\x82\xcd\xe2\x01\x8c\x7e\xa2\x6b\x83\xec\xd0\x2e\x7d\x88\xc9\xa0\xee\xd1\xc3\x50\xa2\xbe\xa9\x89\x8b\xd1\x47\xb2\x62\x4a\xfb\x56\x49\x37\x14\x0d\x49\xa0\x17\x21\xa6\x82\x0b\x97\x24\x61\x98\xa8\xe0\x88\xd2\x48\xa2\xac\x37\x0f\xf7\xc4\x91\xe8\x60\xa9\x67\xb5\x97\x38\x74\x04\x62\x32\x99\xad\x1f\x51\xaf\xe1\x8e\xe9\xa9\xef\xf5\xd2\xf0\x1a\xe2\x4a\x24\x28\x74\xc0\x70\x02\x52\x0a\xe9\x02\xb2\xbc\xdd\x1a\x67\x42\x4a\x8e\x11\x5d\x06\x49\xa8\xf9\xeb\x50\x85\x8e\xea\xba\x18\x3c\xc6\x2b\x1a\x6c\x82\xf1\x18\x12\x14\xb4\x42\x00\x5b\xaa\x7d\x54\x97\xbe\x75\x59\x06\x06\xc1\x5c\x31\xf9\x9c\xdd\x9b\xb7\x84\x4f\x85\x2e\x71\x57\x72\x76\xf5\xe5\xe3\x01\x21\x97\xbc\x8a\xe0\xed\x99\x5d\x0c\xef\xf4\xa1\x67\xda\x7c\x62\xd8\x89\x00\x3f\x20\x34\x9c\x19\xe9\x50\x96\x1d\x60\x7c\x1b\x73\x38\x09\x4d\xe2\x9d\x92\x03\x34\x8d\xbb\x49\xcd\xd6\x7b\x19\xa0\x8d\xa9\xdc\xdc\xf2\xb1\xcc\xe5\xcf\xc3\x01\x42\xda\xd2\x39\x57\x4d\xa1\xa3\xf2\xf0\xd7\xc1\x6c\x81\xf4\x5e\x39\xdc\x86\x22\xb5\xd5\x54\xaa\x6a\x10\xd8\xd5\x09\xab\xbb\xb0\x7f\x79\xf9\xac\x96\xf1\xb8\xb0\xd9\x01\x61\x99\x15\x57\x54\x3b\x25\x46\xd4\xce\xbc\x6d\x21\x2f\x32\xc0\x2c\xce\x60\xe6\x3a\x41\x35\xa8\x27\xdf\xab\x16\x52\x97\xa4\x77\xc5\x5d\x7a\xe4\x7f\xf0\x50\x56\x81\xa8\xbe\xee\xc4\xb0\x7a\xdc\x6a\x88\x4c\xf9\xe6\x12\x98\x61\xa9\x85\x37\x5d\x90\x94\x8d\xc7\xe0\x03\x5e\x8d\xe6\x48\x25\xcd\x0d\x89\x57\xc4\x81\x60\x04\x13\x66\x03\x22\x2b\xc2\x76\x68\xc4\x3d\x97\xeb\xd7\xb3\xc4\x90\x69\x92\xb3\xc9\xd4\x22\x0a\xa1\x98\xa1\x4b\xbc\x53\x31\x13\x34\x25\x88\xdb\x42\x92\x3b\x2a\x73\xc3\x37\x68\x32\x45\x0f\x25\xe5\x24\x2d\x25\xd6\x59\xd6\x40\xd3\x79\x5f\x69\xaa\x8d\xa4\x0c\xd2\x29\x94\x7e\xfd\xb1\xa8\xfe\x83\x23\x16\xd5\xdf\x70\xc4\xa2\xfa\xb1\xa8\xfe\xf2\xd8\x9b\xe8\xd0\x58\x54\xff\x65\x95\x49\x8a\x45\xf5\x9f\xde\x9f\x10\x8b\xea\xc7\xa2\xfa\x0f\x8d\x58\x54\xff\x91\x11\x8b\xea\xef\x30\x5e\x00\xe5\x8a\x45\xf5\x77\x18\xb1\xa8\xfe\xea\x11\x8b\xea\x2f\x8f\x58\x54\x7f\xed\x88\x45\xf5\x77\x1e\xb1\xa8\x7e\x2c\xaa\x1f\x6b\x8d\x6e\x37\xd7\x7e\xd6\x1a\x25\xb1\xa8\xbe\x1b\xb1\xa8\xfe\x8b\xa8\xa8\x48\x62\x51\xfd\x8d\x46\x2c\xaa\x1f\x8b\xea\xef\x32\x62\x51\xfd\x97\x62\x2e\x89\x45\xf5\x63\x51\xfd\xcf\x47\xd0\x8d\x45\xf5\x63\x51\xfd\x58\x54\x3f\x16\xd5\x7f\x70\x15\xb1\xa8\xfe\x4b\x50\x01\x95\x4e\xd9\x4e\x35\x40\x37\x29\x57\xe4\xc2\xd0\x83\xea\x00\xa3\x72\x3c\x06\x89\x94\x0b\xdf\xbc\x14\x3e\x55\x57\x66\x5c\x74\xb2\x82\xee\x61\xe5\x23\x97\xb1\xb3\xe6\x71\x57\x8e\x00\x6b\x75\xd6\xb1\xe2\x17\xef\xbf\x5e\x51\x1b\x69\xe7\xb8\xc2\x5d\xa3\xa4\x71\xcd\xef\xf9\x6e\xfe\xf1\x35\x00\x5f\x95\x41\xe6\xe0\x9e\x64\x42\xb9\x18\x77\x04\x56\x32\xa5\x9c\x83\xd7\xf7\x98\x46\x3b\xca\x08\x80\x13\x51\x80\xf3\x4e\x53\xa2\x18\x9f\x64\x40\xa8\xd6\x34\x99\x0e\xcc\x9b\xb8\x07\x76\x1d\x8f\xee\x7e\x51\x5a\x02\xcd\x7d\x64\x7e\x4e\x99\x9d\x8a\xd0\x44\x0a\xa5\x48\x5e\x66\x9a\x15\xd5\x64\x44\x01\xa6\xd4\x58\x46\x55\x01\x03\xe3\xe2\xea\x20\xf6\x5e\xfd\x36\xb7\x2c\x11\x16\xa7\x43\x6d\xb3\x87\x15\xc1\xf3\x42\xcf\xab\x48\x5e\x20\x63\x26\x95\x26\x49\xc6\x90\x5b\xe3\x1b\x6d\xf6\x34\xce\xd7\xf3\xbc\x9a\xbb\x95\x2a\xb7\x54\x9e\xa2\xd8\x5a\x68\x65\xe3\x62\xeb\x09\xdd\x54\x29\x53\x4e\xcc\x57\x3d\x42\x7d\xe5\x34\x0b\x68\xbf\x52\x04\xb5\xe7\x2c\x76\x76\xf7\x53\x30\x5d\x50\x31\xb6\x0e\x1c\xae\x11\x1d\x93\x1c\x3c\x72\xf6\x1a\xf9\x1c\xb5\x40\x81\x71\x7a\x4b\xc7\x00\x37\x80\xc3\xcc\xe0\x00\x24\x60\xf8\x2b\x5d\x83\xf5\x9f\x1c\xe9\x03\xa6\xf8\x0e\x94\xa2\x13\x18\xee\xe8\x68\x58\xa7\x91\xa1\xaf\xa1\xde\x18\x44\x85\xcc\xe6\xd7\x56\xbf\xd4\xf1\x99\x4d\x31\x88\xe4\x76\x4d\x95\xf0\x73\x27\x99\xd6\x80\x9b\x8a\x35\xf6\xd0\x57\xb9\x98\x82\x7f\xb8\x10\xe5\xf9\xce\x4f\x52\x3f\x6c\x88\x3a\x4f\x6d\xcc\xe5\x08\xc8\x48\x32\x18\x93\x31\xc3\x40\x4e\x0c\xad\xec\xd9\x92\x4b\xd4\x5a\x01\x94\x32\xfa\xae\xe0\x5e\x96\xf5\xeb\x1a\x90\x1f\xdd\xc2\xb4\x2c\x79\x42\x83\x6a\xb6\x98\x63\xca\xc6\x64\x82\xa1\x99\x4e\x5a\xfc\xd3\xab\xbf\xfe\x99\x8c\xe6\x86\xa5\xa1\x64\xa5\x85\xa6\x59\xf5\x91\x19\xf0\x89\x81\x95\x3d\x9e\xcd\x2c\xc9\x0a\x02\xd8\xcf\xc3\x2e\xfc\xf5\x1f\x6e\x47\x4d\x1e\x7b\x92\xc2\xec\x24\x80\x5f\x3f\x13\x93\x55\x1d\x52\x76\x0f\xda\xde\x51\x25\x5a\x81\x66\x22\x63\xc9\xbc\x35\xa2\xf9\xda\x5f\x64\x2a\xee\xac\xac\xbf\x02\x7b\xea\x84\xab\x42\x14\x65\x66\x8d\xce\x5f\x57\xf9\xc5\xa5\x82\xe5\x2c\xc0\x95\xe7\x02\xcd\xa4\x6e\x8a\xc5\xca\xe9\x36\x22\xd7\xbf\x52\xb8\xec\x12\x67\xc8\xab\x4a\x80\xa1\x22\xf4\x35\xcd\xb2\x11\x4d\x6e\x6f\xc4\x5b\x31\x51\xef\xf9\x85\x94\x42\x36\xd7\x92\x51\x43\x2d\xa7\x25\xbf\xb5\x3d\x1c\xaa\x22\x09\x62\x62\x44\xab\xa2\xd4\x3e\x95\x61\xd5\x07\xdb\x8c\x79\x4f\x84\xbd\x1a\x54\xcf\x02\xf7\xac\xd6\x75\x5c\xb2\x96\xc5\xc8\x70\x7e\x15\x22\xdb\x1f\x5e\xfd\xe9\x2f\x16\x75\x89\x90\xe4\x2f\xaf\x30\x6a\x5b\xf5\xec\x21\x46\xda\x66\x18\x45\x4e\xb3\xcc\xa8\x0d\x21\x52\x1a\x40\xaf\x42\xc2\x4f\x8e\x83\xba\x3d\xba\x6d\x2c\x4a\xdd\xdc\xfc\x1d\xe5\x28\xa6\x15\x64\xe3\x9e\xcd\x4b\xaa\xd4\x9a\x43\x64\x0c\x87\x8e\xfa\x60\x72\xd8\x1e\x08\x40\x33\x91\x95\x39\x9c\xc3\x8c\x75\xd1\xc6\xa9\x31\x9b\x57\xf5\x33\xa6\x30\x05\x6c\x94\x89\xe4\x96\xa4\xee\x62\x10\x79\xb2\x58\x0b\x7c\x77\x28\xec\x1a\x83\xd3\x22\xf6\x66\xed\xf7\x37\xa2\x6e\x72\x5a\x14\x55\x96\x90\xa4\x77\x0d\x60\xe0\x99\xc4\x82\x05\x2d\x2b\xca\xb4\x36\x33\xb7\x35\x32\xf7\xdd\x17\x19\xba\xb9\xf3\x14\x3b\x47\x9d\xb4\xb7\x51\xd7\xab\xdf\xdd\x30\xd9\x40\x88\x7a\x42\x7f\x1a\x0a\xfc\xb7\xcd\x2b\x59\xca\x8b\xac\x52\xeb\x2a\xc4\xb0\x02\x80\x41\x1f\x24\xc9\xbb\x1b\x5c\x3b\xb0\x6e\xb6\x0b\x39\x6a\xc0\x85\x57\x56\xe5\x9c\x6a\x27\x10\x7a\xf3\x35\x25\x05\x48\xc5\x94\xe1\xcb\x3f\xe0\x81\x3a\xcb\x28\xcb\x03\x13\xe0\xd3\x00\xc1\x1e\x6e\x2c\xa0\xdc\x9e\x52\x0e\x45\xea\x26\x44\x52\x68\x8b\x47\xaf\x10\x6b\x9b\x52\x6d\x87\x0c\xf5\xa9\x49\xe5\x0f\x35\x34\x9b\x94\xd2\xfc\x52\x91\x4a\x7b\xd7\x4b\x22\x90\xf8\x7d\xcf\x95\x3e\x56\x8b\xef\x88\x0c\x20\x61\x74\x9b\xdb\xa4\x84\x0d\xe5\xd1\x1e\x94\x40\xa4\x77\x7a\xe0\x80\x58\x2f\xb8\x39\x13\xee\x51\x72\xf8\xe6\xf0\x49\x89\xa4\x05\x91\x14\x05\x9d\xb4\xea\xe6\xb3\x00\xa9\xc5\x69\xc3\x52\x13\x46\x0d\xc2\xeb\x55\xe1\x35\xbc\x0b\xd2\xba\x92\x0e\xd6\x49\xb2\xde\x51\x0f\x60\xa7\x20\xd8\x8c\xec\x3b\x3a\x27\x54\x8a\x92\xa7\xce\xbe\x54\x19\xf8\xde\x2d\xbc\xf8\x4a\x70\xf0\x86\xf3\xc5\x4a\x15\x68\xd1\x67\x9c\xbc\x1e\xbc\x7e\xf5\x52\x38\x15\x7e\xe1\x02\xa7\xba\xaa\x38\x95\xa5\x4f\x4f\xfa\xad\xbe\xe6\x7d\x47\xdf\xfb\xce\x99\x58\xea\x92\xf6\xcc\x17\xcc\xc6\x9f\xee\x24\xd3\x10\x74\xf9\x3b\x42\xc5\xc5\xe8\x87\x41\x5d\x86\xe3\x55\xbd\x24\x5a\x02\xa9\x5d\x21\x0c\x55\x8e\x3e\x22\xdd\x72\x04\x0a\x8f\xdb\x2a\x0b\x97\x7a\x80\x84\x85\x80\x3a\x38\x20\x47\xf6\xce\x43\x9b\xd2\x7c\xfc\xa4\xa8\xe5\x80\x76\x71\x5f\xb4\xa8\xb2\xb9\x90\x3d\x5f\x50\xb4\xc1\x15\x1d\x42\xf0\xbf\x60\x4a\x67\x80\xa9\xdc\x2c\xa3\x32\x43\x9f\xe3\xb5\x5d\x3b\x19\x95\x9a\x00\x9f\x31\x29\x78\x0e\x5c\x93\x19\x95\x0c\xeb\xe2\x48\xc0\xda\x0e\x46\x17\xfd\xe2\xe8\x87\xd3\x0f\x18\xd0\x70\xec\x8a\x52\xb8\x55\x96\xca\x17\xb0\x09\x57\x12\x4c\xf7\xe8\xf6\xf9\x75\x18\x18\x22\xcd\xf5\xeb\x32\xef\xc9\x4b\x5d\xda\xc6\x2c\xf7\x49\x56\x2a\x36\x7b\x2a\x4a\xe2\x72\xec\xcf\xd9\x4e\xfb\xbc\x90\xef\x5f\x03\x6a\x29\x75\x1f\x4d\xeb\x2b\x12\xf4\x96\x1c\x26\x87\xaa\x4a\xda\x0b\x7d\xe0\xce\xf4\xe4\xaa\x69\xd8\xf0\x39\x5f\x73\x71\x49\x84\xc0\xca\x31\x4f\x6b\x84\x4a\xb9\x3a\xc3\x15\x6e\x07\xd6\x66\x40\x72\x23\x8f\xef\xfc\xea\x3a\x2c\x43\x62\xd5\x25\x91\x0e\xc8\xb0\xfe\xb1\xae\x55\x83\x15\xd4\x2a\x25\x12\xe4\xa4\x2e\x2b\x3e\x01\x0e\x12\x85\x04\x33\x65\xa3\xb1\x2a\x19\x51\x65\x9d\x3c\xe7\x57\xd7\xd6\x66\xbb\x1d\xcc\x76\x16\xb3\x77\x97\x50\x0d\xc7\xb7\x69\x0c\x3b\x08\xb7\xcd\xae\x69\x95\xc1\xca\x00\x06\x95\x52\x3b\x31\xb9\x1c\x12\x9a\xa6\x12\xdd\x3e\x4e\xf4\x09\x6a\x55\x56\xbe\x05\xac\x0b\x43\x15\x84\x6b\x0a\xc0\x8d\x24\xae\x06\x2c\x39\x2f\x8b\x8c\x59\x37\x42\xf8\x40\x5d\xcf\x06\xdb\x7c\x6d\x8f\xb4\x6d\xd4\xbc\x9d\x95\xbc\x16\x54\x48\xec\x5a\x96\xf2\x81\xdd\x93\xa0\x44\x36\xab\x4b\x0a\x2f\xec\x9a\x3b\x11\x68\x12\xaf\x76\xcd\x57\xa1\xdc\x68\xc7\x80\x6b\x69\x8e\xe6\xe2\x6e\x61\x1f\xfb\xac\xc4\xd3\x54\x4d\xc8\x66\x80\xfe\x71\x57\x80\xd3\x15\x72\xab\x8b\x1c\x5b\xdf\xb0\xad\x33\x0d\x54\x7a\x8a\x86\xab\xda\xf1\x24\x92\xa7\x42\x84\x45\x63\xc7\xf9\xd5\xb5\xa5\x84\xf6\xe3\xab\xfe\xb4\xab\x76\xa9\xa6\x6a\x3b\x63\xe0\x93\xd5\x19\x6a\xa3\x79\x2c\xb4\xf7\x73\x0d\xbb\x5b\x05\xb2\xb4\x10\xff\x5a\x25\xdb\xb5\x78\xbb\x02\x2a\x93\xe9\x2e\xf0\x7f\x80\x10\xd8\x49\x49\x2a\x6c\x24\xc0\x58\x48\x54\x89\xfb\x48\xde\x33\x21\x6e\xcb\x62\x13\x8a\xee\xa6\xb1\x2d\xd7\x36\x22\x10\x8d\x27\x3e\x2b\x9a\x9e\x72\xb5\x8b\xbf\xb7\x29\xfb\x80\xb6\x12\x0f\x4e\x54\x27\x50\x88\x45\xbd\xe9\x2c\x2b\x95\x06\xf9\x35\x93\x4a\x1f\xf8\x8a\xd1\x88\xc1\xd6\x26\x72\x18\xde\xf0\x23\xd3\x53\x57\xbc\xf1\xb0\xd7\xbc\x64\xfe\x76\x13\x1f\x1a\x9d\xf6\xf0\x4a\x70\x38\x1c\x2c\x8a\x5d\x15\x29\xaf\xc8\xda\x5a\x9e\xe2\x96\xae\x20\xb3\xf1\xa2\x78\x21\xc0\x95\x1b\x57\xb8\xd2\xbc\xc1\xd3\x3f\x05\x9a\x50\x2c\x12\x87\x77\x4f\xeb\x42\x93\xb6\x72\x94\xad\x94\x29\x9c\xa0\x37\x0f\x41\x14\x14\x93\xd2\x62\xfd\x67\xef\x22\xcf\x6d\x8d\x01\xb6\x00\xa9\xab\x17\xf2\x96\xf1\xdb\x2d\xd1\xaf\x19\x5d\x72\xb1\x34\x5b\xa3\xa2\xb8\xf5\xd1\x32\x6e\x83\xef\x0c\x8b\xa1\x23\x51\x6a\x5f\x93\x44\x05\x8a\x23\xe3\xff\x63\xf7\x02\xed\xed\x85\xad\xd9\xb7\x4a\x47\x54\x3d\x6b\xf4\xf1\x4a\xa0\x9a\x73\x4d\xb1\xba\xe8\xb9\x48\x6e\x41\x92\xcc\x2c\x63\x40\xea\xc0\x97\x46\x3d\x4b\x59\xc2\x96\x51\x17\xbb\x5a\x3a\xa0\x98\x42\x0e\x92\x66\x75\x59\xd7\x16\xa0\x7e\xeb\x08\x67\x35\x6b\x18\x93\x62\xcb\xa2\xb9\x42\x8c\xe6\x1c\x5e\xac\xba\x2b\xa7\x73\x5f\xeb\x96\x71\x0c\x37\xb8\x67\x0a\xcd\xfa\x85\x48\xc3\xc4\xb3\x52\x81\xec\x57\x69\x81\x2e\xf7\x46\x55\x81\x38\x29\x8c\xca\xc9\x84\xf1\x89\xa3\xce\x48\xd3\x83\x82\xdb\x95\xa6\x83\x91\xde\x89\x04\x5b\x72\x16\xa5\x07\x1b\x5f\xc6\xc2\xfb\x73\x91\xda\xdb\x47\x73\xab\x0d\xfa\x9d\xad\x03\xa4\x2f\x39\x11\xd2\x95\x46\xa0\x69\x8a\x6b\x5f\xfe\x42\xbc\xda\xfc\xaa\x5e\x15\xc7\x61\x23\xbb\xab\xa7\x02\xb0\xa8\x72\x64\x84\x9d\x52\x26\xb0\xca\x76\x1a\x14\xf9\xa5\x33\xca\x32\xb4\x53\x08\x4e\x12\x7b\x8a\x5d\xac\x99\x39\xfd\xfc\x10\xa3\xe0\xb0\x5d\x27\xbe\xf3\x62\x19\x03\x5a\x94\xa8\xda\x95\xcf\xec\xc4\x63\x9a\xe5\x85\x4e\xf9\x8a\x6f\xb1\x01\xe3\x1a\xf2\x42\x48\x2a\xe7\x8b\x1e\x53\x43\x13\x0d\xc6\x99\xfd\x5a\xd8\x98\xa1\x48\x91\x6d\xac\xc0\xb3\x99\x6d\x1d\xbc\x02\xd5\x56\xa2\x34\x12\x5d\x2e\x88\xdf\x40\xc3\x1e\x54\x32\x85\xb4\xc4\x60\xf5\x49\x49\xb1\xb5\xb9\x21\x1a\xce\xb6\x3e\x77\x51\x80\x16\xf7\xaa\xf8\xc2\x2a\x2b\x61\x8e\x31\x39\x58\xf6\xd3\xfc\x82\xe5\x43\x6d\x24\xa2\xed\xec\x8c\x5d\x5e\xab\xa0\xc4\x9b\xba\xd9\x04\x7e\x2c\xcc\x58\xa2\xfd\x43\xe3\x75\x78\x9a\xd0\xaa\xa1\xec\x50\xb8\x72\x83\x09\x18\xda\xa7\x55\xfd\x29\x2e\x88\x05\x0b\x8a\xfe\xcc\x0d\x4f\x5a\x8f\xfa\x35\x9e\x3f\x82\xe1\x28\xc6\x37\xb7\xe2\x01\x6a\x51\x41\x69\xd5\xb7\x9b\x35\x2d\xe4\x0d\x38\xdc\xee\xfc\x9c\x6c\x5b\x07\xaa\x85\xbe\xb1\xbb\x33\x71\x27\x27\x60\x1b\xd5\x86\xca\x49\x7b\x35\xf0\xf0\x54\x4e\xca\xdc\x16\x28\x17\x0b\x35\xa2\x5d\x7b\x64\xcb\x56\xd1\x72\x67\x98\xf2\xd9\xbb\xf3\x30\x49\x23\x8c\x3e\xf7\x29\x2e\x46\xd8\x6b\x69\xd1\x5d\x34\xe9\x5e\x1a\xf5\xb3\xb2\x13\xd7\xdc\xc3\xe9\xa9\xce\x66\x59\xbd\xcd\xeb\xe9\x8c\x17\x46\xde\x40\x29\xa9\xb6\x5a\xf2\x64\x4a\xf9\x04\x0d\xfd\xa2\x34\xf3\x7d\xf1\x05\xae\x48\x42\x5a\x26\xae\x37\x86\x8f\xf0\xfe\xc2\xdb\x37\x5d\x91\x22\x6c\xd1\xa7\x12\x5a\xf8\x35\x87\x9f\x65\x85\x91\x37\x84\x0d\x60\x40\x0e\xbe\x08\x2e\x1d\xd8\xb7\x17\x52\x98\x57\xb8\xe0\x70\x5c\x55\xc6\x34\x9e\xbd\x83\xf0\xee\x01\xb9\x30\xef\x40\x9f\x4f\x05\xc0\x20\x7e\x79\x54\x83\xaf\x47\x24\x4c\xa8\x4c\x33\xcc\x29\x1c\x57\x62\x97\xcd\x3c\x72\x00\xc3\x03\x8f\x11\x83\x5c\xe8\x55\xf6\xd7\x0d\x13\x3f\x34\x55\xb7\xea\xc4\x0a\x6b\xfd\x94\x6a\xda\xc7\x7e\x22\x96\x4e\x9d\x58\x03\x42\xdf\x55\x72\xed\x53\x87\x5a\xfd\x6a\x5b\x4f\x7e\xef\x72\xc7\xfa\xb4\xba\x8b\xf1\x3e\xed\x63\x4d\xd5\xdd\xa3\x61\x9f\x20\x70\xa2\x95\x2e\xdf\xa2\xa0\xef\xa2\x00\x5e\x15\x74\x47\x18\x60\x3b\x94\xba\x80\x77\x15\xa3\xe1\x6a\xd6\xae\x3a\xcf\x17\x57\x37\x1f\xfe\x3e\x7c\x7f\x79\x75\x13\x8f\x75\x3c\xd6\xf1\x58\xb7\x38\xd6\xc0\x67\xad\x8f\x74\xa5\xe8\xad\xd2\x7d\x17\xaa\xe8\x05\xa9\xe3\x2f\x28\x0a\xed\x82\xcf\x7e\xa0\x46\xd4\x2c\x24\x28\x94\x4c\x8c\xc4\xba\xca\x5d\xec\x6e\xb0\x8d\xc5\xce\x9e\x7d\x18\xda\x13\x06\x91\x75\x18\x9c\x73\x15\x54\x3c\x58\xb5\x6b\x61\x27\xbf\xb3\x5f\x2f\xcf\x2f\xae\x6e\x2e\xbf\xbe\xbc\xf8\xf0\xa4\x51\x15\x2d\xab\xd8\x35\x99\xf2\x8e\x5c\xb2\x90\x30\x63\xa2\x54\xd9\xbc\x2a\x84\xbb\x9a\x08\x2c\x07\xe6\x71\xa3\x18\xce\xab\x5a\xbf\x2b\x1f\x8b\xcc\xb6\x5b\x66\xdb\x0c\x32\x69\x51\xc0\xa4\x2b\xf4\xfd\x5a\x8a\xbc\x23\x14\xbe\xb6\xc6\x02\x6f\xdb\x5f\x85\x4f\x87\xae\xd6\x41\x83\xf5\x38\xe1\xb1\x2e\xac\x60\x84\xd1\xbc\xd0\x2d\xfa\x1c\x74\x52\xb7\xb4\x9b\x12\x9f\x36\x20\xe3\x1d\x2d\xbe\x83\xf9\x07\x68\x59\x27\x65\xc1\xa7\x92\x41\x62\x18\x1d\xb9\x85\xb9\x75\xb5\x9e\xf9\x97\xb5\xa9\xe7\xb2\x97\x65\x5f\x6f\xa1\x4d\x49\xde\x2e\xeb\xb5\xde\x42\x8b\x08\x4d\x3f\x96\x2a\x97\x9a\x2d\x44\x39\xcd\xec\x69\xbb\xdd\x23\xdd\xd6\x6a\xfd\x08\xf5\x69\x0f\x43\x76\xef\xe8\xac\xde\xba\x8c\x84\x98\x19\xce\x05\x77\x27\x2e\x3a\xad\x6f\x14\xd7\xbe\xc5\x5a\x75\x82\x21\x38\x27\xbf\xc7\xff\x90\x9b\xf7\xe7\xef\xdf\x90\xd3\x34\x75\x51\xd2\xa5\x82\x71\x99\x59\x9b\xbd\x1a\x10\x5a\xb0\x1f\x40\x2a\x6c\x14\x77\xcb\x78\xda\x23\x25\x4b\xbf\x6a\x53\x5d\xca\x8e\x0e\x77\x41\x78\xcf\x54\xb7\x3b\x71\xed\x1c\x8f\x21\xef\xaa\x88\x08\xb1\x29\x90\x88\x9b\xbe\xd0\x8c\x13\x32\x3a\x02\x4d\xdb\x9e\x78\xc4\x6e\x61\xb7\x74\xf5\xb0\x26\xac\xd6\xa9\x53\x55\xe2\x4a\xdf\x10\x55\x62\x45\x1c\x55\x35\xb2\xc3\xd6\xb0\xbd\xe6\x9f\xaa\xa0\x09\xf4\xc8\x3f\xaa\x1f\xb1\xf5\xbc\xfa\xe9\xf0\xf0\x6f\xdf\x5d\xfc\xfd\x3f\x0f\x0f\x7f\xf9\x47\x78\x15\x59\x21\x6a\xcd\x0b\xb7\xa0\x23\x8b\x8b\x14\xae\xf0\x1d\xf8\xa7\x13\xd7\x4e\x93\x44\x94\x5c\xbb\x0b\x98\xbe\x3c\x98\x0a\xa5\x2f\x87\xd5\x9f\x85\x48\x17\xff\x52\xad\x4a\xa6\xed\x25\x63\xc0\x2d\x6a\x91\x86\x63\x47\x77\xec\xa1\xa6\x25\x1d\x1f\x55\x37\x6b\xd5\xa2\x23\x99\x42\x6e\x8b\x36\x7d\xed\x41\x80\xcd\x76\x7d\x9d\x04\x8e\xc9\xe5\x46\x32\x6d\xd6\xcf\x3b\x98\xbd\x6e\xd5\x95\xdc\x8e\x0e\x49\x5b\xb5\x83\x1d\x03\x0c\x21\xe2\xa0\x65\x0f\x72\xc5\x60\xbd\x96\x52\xbb\x9d\x4f\x87\x97\x64\x66\x21\xbc\x37\xc0\xf1\xfe\xb7\xaf\x3f\x2a\x8d\x0b\xbd\x7c\x0d\x0d\xf1\x8d\xed\x4d\xeb\xaf\xbb\x82\x02\xaa\xaa\xf1\x05\x46\xb1\x39\xb2\x3f\x0e\x92\xa2\xec\xb9\x1b\x06\x39\xe4\x42\xce\xab\x3f\x2b\xef\x62\x5f\x69\x21\xe9\x04\x13\x50\xec\xe3\xf6\xb1\xea\x2f\xfb\x60\xe3\x05\xcb\x4f\x5b\x55\x38\x29\xa5\x11\x1a\xb2\xb9\xa7\xc8\x3b\x16\xc6\xa8\xc7\x1e\xd2\x36\x0f\xfa\x3d\x21\x6d\x15\x66\xb4\xed\x40\x6b\x47\x13\x21\xeb\x10\x01\x14\x38\x2b\x28\xa2\x3e\xe9\x12\x6c\x7b\x95\x18\x64\xad\x01\x7c\x66\x34\xcb\x9d\x4b\x84\xd5\xa3\x43\x6a\x96\xb2\x19\x53\xa2\x45\x9a\x4d\x35\xd1\xfa\xdc\x01\x57\xe3\xc3\x46\x48\x55\x66\xb3\xfb\x02\xab\x22\x55\xe7\x75\x81\xec\xbf\x6e\xd3\x18\xc9\x8e\x82\x6a\x0d\x92\xbf\x21\xff\x7d\xf4\xf3\x97\xbf\xf5\x8f\xbf\x3a\x3a\xfa\xe9\x55\xff\xaf\xbf\x7c\x79\xf4\xf3\x00\xff\xf1\xef\xc7\x5f\x1d\xff\xe6\xff\xf8\xf2\xf8\xf8\xe8\xe8\xa7\xef\xde\x7d\x73\x33\xbc\xf8\x85\x1d\xff\xf6\x13\x2f\xf3\x5b\xfb\xd7\x6f\x47\x3f\xc1\xc5\x2f\x1b\x4e\x72\x7c\xfc\xd5\x17\xad\x97\xde\x41\x91\x52\x3b\xba\x2c\x55\xda\x9c\xb1\x13\xf4\xfb\x88\xf5\xf9\xed\xf0\xe8\xd5\xf5\xf9\xf7\x61\xd2\x6f\x6a\x86\x54\xb1\xeb\xbd\x39\xe0\x0a\x12\x09\xfa\x53\x58\x72\xec\x9b\x82\x52\x09\x87\x8a\x54\xaa\xc5\x4b\xe3\x73\x9f\x83\x71\xa7\xea\xac\x87\xfb\x5a\x4b\xa2\x63\x29\x72\x9f\xfe\x8e\xee\x0d\x6c\xb8\xef\xef\xbb\x85\x56\xdd\x5e\xed\x88\xc6\xa0\x68\x0c\x5a\x33\x1e\x35\x06\x5d\x5b\x3c\xdc\x5b\x4b\x10\xf0\xd9\xae\x2e\x8c\x95\x1e\x74\xaf\xeb\x84\xb5\xe2\x36\x73\xa8\x0d\xfc\x51\xaf\x5b\x52\xd6\x91\x34\x96\xa1\xe5\xab\x7d\x98\xe4\x14\x9b\x4f\xdb\x83\x8f\x13\xd4\xf9\x25\x56\xb5\x71\xa5\x0c\x61\x66\x96\x50\xd5\xc2\x6e\x54\xbd\xc4\x10\x4b\x0c\x7a\xfd\xd1\xc6\xa0\xde\xda\xb0\x54\xa3\xa4\x31\x5e\xd7\x0b\xad\x84\xc3\xba\xc8\x34\x55\x4a\x24\x36\x9c\xb6\xca\x76\xc0\x12\x76\x6e\xd9\xb8\x1a\xec\x78\x5f\x48\x48\x20\x05\x9e\x80\x2b\x40\xdd\x68\xbf\x49\x39\xb9\xe0\x33\x5f\x84\x3b\xf5\xb9\x33\xb8\x92\xd5\x73\xbc\xac\x00\x04\x83\x88\xce\x09\x16\xc4\x21\x20\xd5\xaf\xe3\x68\x31\x14\x43\x8c\x6b\x2b\xeb\x6e\x1d\xfa\x5a\x73\xf1\xf6\x3c\xb3\xf2\x6c\xb5\x12\x86\x96\x98\x65\x6d\x7e\x6e\x32\xc9\x97\xe0\x0c\x6c\xcf\x3e\x3f\x3b\xd6\xd9\x11\xdb\xec\x86\x65\x6e\xe1\x3b\xe9\x92\x4d\x76\xe1\x2c\x29\x24\x8c\xd9\x7d\x47\xe7\xf4\x94\xd7\x96\x18\x96\x02\xd7\x6c\xcc\x6c\x2e\x4d\x21\xa1\x00\x6e\xf3\x13\x68\x32\x45\xda\xef\x38\x65\xed\x9c\xde\xc7\x60\x1e\x2b\x70\x77\x4b\xca\xae\x57\x09\xfb\x91\x8e\x91\x48\xc7\x76\x1e\x9f\x88\x8e\x39\xcc\xdd\x1f\x22\x86\x91\xe7\xed\x43\xdf\xcf\x83\x38\x76\xc4\xe2\xad\xb1\xac\xce\x76\x3a\xc1\x59\x76\xb2\x3e\xb7\x42\x06\x7c\xed\xb0\xcc\xb2\x8e\xaa\x70\x1f\x5e\x22\x34\x8a\x32\xcb\x5c\xf2\xf1\x80\xbc\xe7\x78\x1e\x4f\xb1\xdb\x43\x8f\x5c\xc1\x0c\x64\x8f\x5c\x8e\xaf\x84\x1e\x5a\xc1\xb6\x19\xcb\x66\x6f\x24\x6c\x4c\xde\x18\x95\x49\x69\xa2\x6d\xc5\xfd\xa0\x3e\x90\x90\x8d\x09\xea\xd2\x63\x2d\x62\xd0\xd7\x6f\xcb\xef\x7d\x5a\x68\xff\x89\xb6\xa9\x6a\x69\xd2\x81\x6e\xea\x66\xf2\xd1\x71\x18\x11\xe9\x5c\x23\xab\x72\x7b\x9f\x61\xb9\x8d\x42\x28\x7d\x6d\x54\xd8\x6e\xda\xdd\x0c\xfd\x74\xd8\x41\x82\x66\x19\xa4\x8d\x7e\x47\xb6\x4f\x07\x6d\xaa\xd0\x98\x75\x5c\xb5\x8d\x00\x32\xa5\x3c\xcd\x40\x62\xe9\x77\xb5\x58\xdf\x8a\xd5\xbd\x0e\xaa\xee\x14\x3e\x2f\x94\x26\x89\x90\xa9\xeb\x33\xeb\xf2\x33\x71\x31\xd5\xf1\x42\x42\x9b\x53\x4e\x27\x80\x66\x85\xa5\x02\xc2\x58\x56\x5a\x05\x2d\x2e\xa6\x42\xdc\x92\x44\xe4\x45\x86\x07\xa0\xc5\xf9\xa8\x3b\xec\x54\x28\xda\x37\xb3\xab\x93\xa0\xf9\x0e\xfe\xd0\xae\xf7\x4e\x2b\x49\xa5\x0b\x39\x05\xee\x21\xe9\xac\x3b\xdf\xc5\x3d\x24\x41\x7b\x49\xb3\x25\xae\xbf\xa4\x16\x68\xd8\x68\xdf\x35\xb8\xb5\x4d\xbe\x2b\x3b\x78\x8b\x4c\xb3\x70\x2c\x94\x93\xc3\x39\x7d\xf5\x6c\xf7\x0a\x6c\x44\x60\x93\x99\x31\xfb\xcc\x17\xd4\x6e\x1c\x06\x7b\xf4\x96\x6a\xd0\x55\x91\xc6\x7e\x2e\x4c\xb9\x16\x42\x93\xa3\xc3\x93\xc3\xe3\x25\x03\xdd\x42\x09\xe6\x9b\xe0\x49\x86\x35\x07\x0b\x2c\xe0\x07\xc9\x61\xda\x23\x4c\x7b\x62\x6b\x4b\x1f\xe0\xaa\x5c\x4a\x5c\x8f\x28\x41\xb4\xa4\x29\x73\x2a\x10\xfe\x6a\x6e\xd2\xb2\x74\x75\x0f\x8e\x0e\x7f\x3b\xec\x11\xd0\xc9\x31\xb9\x13\xfc\x50\xe3\xf2\xb1\x48\x48\xa9\x82\x89\xe6\xa2\xc4\x5e\x7c\x16\x04\x55\xc5\x0f\x43\xb1\x88\x28\x6d\xe3\x9e\x29\xd5\x3e\x15\xef\xe2\x9e\x69\xdf\xac\x42\x8c\xc9\x2b\xdb\x37\x08\xa8\x33\x11\x66\x6c\x06\x27\x53\xa0\x99\x9e\xda\x28\x0a\x2e\x78\xdf\xb6\x7e\x33\xa4\xc4\x5d\x69\xeb\x50\x68\x67\x6f\x0b\x47\x0b\xdb\xdb\xf2\x82\x5a\x8a\xd6\x86\x88\x7e\xb3\x7b\x3f\x5a\xb2\xd4\xaa\xf9\xe6\x66\xf8\x4d\xa3\x23\x2d\x52\x71\xad\x0b\x1f\xdb\x12\x54\xcf\xd8\x03\xda\xd1\x8d\x37\xaf\x55\x6b\x5a\xd2\x21\x09\x6b\xdb\xa2\x96\x2c\xb7\xde\xde\xae\x37\x2d\xf9\xbb\x28\xb1\xa7\x1e\x1d\x65\x73\x72\x47\xb9\xf6\x79\x78\x07\x66\xaa\x03\x43\x9e\x0c\x36\x7c\x0b\x34\x05\xa9\x90\x7a\x00\xdd\xb9\x4a\x98\x1f\x9d\x79\x99\x82\xb5\x75\xcb\x07\x4a\xa5\x45\x4e\xa6\xee\xb3\x9b\xb9\x89\xee\x64\x0c\xf0\xf4\xf8\xc4\x1f\x09\x85\xa5\x70\xee\x99\x17\x47\xbf\x96\xe8\x86\x85\x7b\xa3\x9a\x7e\x12\x82\x2d\xec\xb9\xc2\xb8\x05\x96\xed\x96\xd8\x11\x2d\xed\x20\x3a\x80\x74\x18\x21\x40\xda\x65\x3a\x2e\x4e\x84\x5e\xaf\xf6\xc1\x50\x9d\x05\x1d\x90\xce\x1c\xeb\x64\x95\x15\xd2\xe1\x8c\x0d\x81\xed\x08\x88\x9d\xba\xb3\x49\xfb\x5c\xca\x70\x3c\x0c\x80\x6e\x36\x9f\x74\x09\x81\xa2\x83\xd8\xe7\xe5\xc8\xe7\xa5\x9e\xe1\x48\x26\x6c\x55\xda\xbd\xe1\x32\x6d\x1b\xa8\x93\xd5\x89\xc4\x92\xf0\xaa\xdf\xad\x7e\x16\x4d\xd4\x49\x77\x31\x8a\x5d\x47\x28\x76\x1a\x9f\xf8\x51\xa3\x13\x31\x27\xa2\x35\x15\x69\x1a\xc7\x71\x4a\x83\x01\x46\x6f\x33\x1a\xa7\x93\xfd\x9c\x75\xc7\xf7\xe4\x68\x9a\x43\xcd\x51\xdb\x8b\x33\xa6\x93\xe2\x5a\x24\xb7\x1d\xea\x35\xe7\x50\x48\x48\xac\x9d\xec\xe6\x6c\x68\x67\x37\xfa\xe5\xd5\xfb\x9b\x3a\x16\x1f\x03\x56\x6a\xc3\xe5\xb7\xce\x92\x66\x74\xd2\x5b\x28\x74\xa5\xba\x8f\x68\x72\x7b\x47\x65\x8a\x96\x2d\xaa\xd9\x88\x65\x4c\xcf\x51\x39\x97\x80\x81\xfe\x5c\xd8\x88\x38\x5b\x0a\x52\xf8\x86\xae\x55\xb7\xf1\xca\x86\x85\x16\x32\x17\x3a\x33\xa6\xcc\xe8\xe3\x55\xd7\x5e\x1b\x32\x93\x14\x95\x49\x2f\xb4\x4c\x47\xe5\xcb\x8f\xbd\x55\xbe\x82\x8e\xb4\xdb\xea\x61\x6d\x03\xf7\xf6\x98\xd5\x39\x16\x27\xab\x86\x6b\x91\xd5\x75\x34\xdf\xfe\xb2\xba\x42\xc2\xb5\x16\x45\x47\x5e\x12\x3b\xd9\x1a\x1f\xc9\x08\xc6\xc2\x10\xe1\xb5\x4e\x8f\xb4\x04\x57\xa5\xf3\x74\x78\x59\x59\xb5\x44\xc3\xb1\x61\x43\x16\x7d\x69\xce\x8c\xcd\x80\x83\x52\x27\xe8\x0e\x29\x0b\xab\xb5\xfa\xde\xba\x3d\xf3\x75\x90\xe3\xea\x7a\x75\x1a\x80\xeb\xec\x8b\x3f\x82\x4e\xac\xe5\x36\x20\xe4\xd8\x34\xcc\x2d\x7f\xd1\x8d\x92\x48\xaa\xa6\xb6\xeb\x2d\xdc\x33\xed\x3a\x37\x0f\x6d\xa5\xe0\xb0\xf9\xee\x44\xd2\x04\x48\x01\x92\x09\xc3\x8c\x4a\xae\x53\x71\xc7\xc9\x08\x26\x8c\x2b\x0f\x0a\x2c\xbe\xe9\x60\x86\xfe\x18\xa6\xaa\xb2\x69\x03\xf2\xa1\x51\x0d\xc4\xe5\xe9\x24\xa2\x3e\x9a\x6e\xcd\x8b\x9e\x24\xe4\x58\x08\x27\xdb\x43\xa6\x82\x70\xd8\x56\xe7\xb1\x25\x1f\x95\x1c\xdf\x9c\x42\x46\xe7\x36\x1c\x13\x3b\x62\xb3\x7f\x81\x54\xc7\x1d\x78\x9c\x6c\x63\x28\x7f\x6d\xed\x3a\xb0\xea\x29\x4d\xa6\xed\x5c\xb8\xd1\x45\xb5\xe1\x88\x2e\xaa\x36\x93\x44\x17\x55\x74\x51\x3d\x32\xa2\x8b\x2a\xba\xa8\x16\xc6\xde\x6a\x49\xd1\x45\xb5\xf3\x88\x2e\xaa\x87\x47\x74\x51\x6d\x30\xa2\x8b\x6a\xc3\x11\x5d\x54\xd1\x45\x15\x5d\x54\xd1\x45\xf5\x19\xd9\xed\xfc\x88\x2e\xaa\xa5\x49\xa2\x8b\x2a\xba\xa8\x36\x1e\x7b\xab\x7c\x45\x17\x95\x1d\xd1\x45\xd5\x1c\x9f\x17\xab\xf3\x0e\x9e\xa1\x51\xf5\xda\xb7\x1b\x46\x85\xd1\xd1\xd8\x17\x99\xf6\xd4\xc6\xfe\xff\x69\x6c\xff\x7b\xe2\x28\xe9\xc0\xde\x1f\x6d\xfd\x2f\xce\xd6\xdf\x8d\x9d\xac\x03\x1b\x59\x6b\x9a\xec\x5c\xe0\x37\x53\x09\x6a\x2a\xb2\x9d\x11\xbd\x81\xe4\xef\x18\x67\x79\x99\x1b\x9c\x53\x06\x9f\xd9\xac\xf2\xb5\xab\xba\x07\x33\xba\xe0\xad\xb9\xce\xdc\xc8\x52\xc0\xb2\x9b\x94\x65\x66\x1b\x31\x51\x72\x4a\x67\x06\xd7\x55\x99\x24\x00\xd8\xd4\x2b\x54\x25\xfe\x38\xa8\xde\x54\x35\x71\x78\xdd\x8e\xde\xb4\xe3\x96\xb6\x30\x26\xce\xf2\xc7\x3f\xec\x34\xc7\x44\x16\xdd\xd0\xe5\x6f\x3e\x0c\xcf\x02\xba\x4c\xb9\x27\xcb\x8c\xcf\x44\x36\xb3\x3d\x6e\xf1\x26\x23\x15\x0d\xea\xee\x98\x9c\xd0\xac\x98\xd2\x40\x8d\x70\x12\xb8\xb2\xed\x98\xcd\x93\xe6\xb9\xaa\x6e\xea\xd0\x86\x52\xec\xdc\x2a\xb6\x1e\x1d\x90\xfc\xf6\xda\x42\x2b\x4d\xa1\x0b\x8e\xd3\x56\x18\x6e\x4a\x32\x46\xe4\x6d\x1a\x7c\x26\x88\x19\xb6\x9a\xfb\xc6\x22\x6f\x6b\x5a\xd9\x5e\x0c\x6d\x7f\xb8\x08\x96\x5b\xc1\x0f\xef\x0c\xc0\x07\xae\x9f\xb8\x67\xe8\xa1\xbe\xe1\x3b\x1c\x69\x41\x8a\x8c\xd6\x3d\x8a\x70\x07\xbe\x45\x2e\x74\x36\x85\xe4\xf6\x83\x73\x7a\x1e\x29\x80\x2a\x62\x65\xc2\xf4\xb4\x1c\x0d\x12\x91\x9f\x18\xa2\x60\xff\x6f\x94\x89\xd1\x49\x4e\x95\x06\x79\x92\x8a\xc4\x31\xb9\x7e\x62\x66\x61\x7c\x32\xc8\xd3\x63\xec\x75\x7b\xd9\xec\x89\x18\x14\x43\x30\xef\x77\xea\x20\x19\x81\xa1\xaf\x02\x55\xfe\xa0\x9c\x9a\x59\xde\xd6\x5d\x6c\xc3\xd1\x9a\x29\xb5\x74\x38\x7f\x7a\x67\x73\xa4\x5c\xa4\x03\xdb\xc6\x73\x73\x2a\x77\x16\x5c\xd1\x81\x33\x79\x8f\x1c\xc9\x7b\x23\x1c\xef\x8b\xf3\x78\x0f\x2b\x1f\x77\xe0\xeb\xec\xc2\x59\xdc\x9d\xa3\xf8\x23\x14\x08\xfe\x38\x0e\xe2\x0e\xad\x68\x1d\x39\x86\x3f\x85\x53\xb8\x93\xaf\x6e\xeb\x0c\xfe\x74\x8e\xe0\x6e\x3e\xb7\x4b\x45\xe0\xb9\x3a\x7f\x3b\xb0\x86\x77\x69\x09\xef\xcc\x0a\xfe\xd1\x9c\xbd\xed\x1d\xbd\x7b\xe0\xe4\x6d\x0d\x64\xc6\x99\x66\x34\x3b\x87\x8c\xce\xaf\x21\x11\x3c\xdd\x99\xc3\x2c\x54\x8c\xac\xce\x8f\xb2\xd3\x3a\x4b\x55\x33\xa7\x61\x4a\x5d\x61\x6c\xa3\x51\xd9\x1c\x0e\xef\xa1\x70\x02\x05\x3a\x17\xec\x2a\x77\x29\x3b\x77\x27\xe4\x6d\x26\x68\xaa\x4e\x0a\x61\xff\xaf\xce\x58\x08\x52\x15\xec\xbb\xda\xe5\x2a\x3c\xb5\x49\xcc\x26\x78\x74\xb9\x89\xdf\x8a\x3b\x22\xc6\x1a\x38\x39\x62\xdc\xef\xe3\x71\xa0\x06\xd6\xf6\xc9\x0a\xad\xcd\xd5\xd7\xaf\xfc\xcd\x2f\xcf\xf0\x88\x26\x56\xa5\x3e\xbe\x1d\xd8\xbd\xe8\x71\x43\xb0\xbb\x71\x5c\x66\x4d\x63\xb0\x35\x10\x37\xe9\xcd\xeb\xba\xb4\xef\x6b\x9c\xb7\x3a\x6d\x94\xa7\xc4\x25\x7d\xbd\xbc\x4d\x6b\x1d\xc2\xd2\x14\xfd\xaa\x90\x95\xc7\xec\xc6\x37\x67\x43\x6b\x36\x8e\xe6\x92\x7d\x31\x97\x3c\x51\x18\xc8\x1e\x0a\xba\xcf\x34\xf4\x23\x0a\xba\x5b\x8c\x20\x0d\xf4\x1b\x49\x13\x18\x76\x2e\x23\xf8\xe3\x44\xd2\x52\x52\x47\x00\x2b\x91\xcf\x1f\x1e\x0e\x90\xda\xd3\x54\xa5\xce\x62\x52\xea\xb8\xcc\xb2\x39\x29\x0b\xc1\x9b\x89\xc6\xd6\xdb\xbe\x98\xb7\x8a\x26\xf9\x15\x6f\xa9\x05\xcb\x42\x0a\xc7\x33\x65\xc9\xb9\xa1\xc1\x75\x7f\x2e\x14\x24\xb1\xae\x31\x6d\x64\xc7\x2a\x36\x31\xcb\x37\xfc\x0f\x13\x67\xeb\x58\xbf\xc6\x84\xe6\xe9\xb1\x90\x09\x1b\x65\x73\x32\xa5\x59\xd5\x8c\x85\x92\x5b\x96\x65\x6e\x9a\x01\xb9\x06\x6d\x5d\x0a\x96\x77\x66\x82\x4f\x70\x71\x94\xfb\x26\x80\x90\x98\x67\x93\x0c\x28\x2f\x0b\xfb\x3e\xc3\x89\xe7\xa2\x94\xfe\x7d\x83\xca\x31\x51\x37\xdd\x67\x59\x2f\x68\x35\xf6\xe0\xc6\x56\xed\x69\x4a\x65\x04\x80\xf7\xbe\x8e\x73\x2f\x9c\x53\xcc\x40\x4a\x96\x3a\x3b\xbf\xfd\xad\x90\x62\xc6\x52\xeb\xdd\xf0\x60\xc3\xa6\xc6\xb6\x99\x4c\x75\x9e\xb9\xe0\x7d\x0e\x13\x8a\x82\x8a\x3b\x45\x76\xcf\xec\x3c\x36\x86\x80\xa7\xd8\x5e\xc6\x48\xf8\xa2\x68\x64\xae\xcf\x98\x6d\x8c\x1b\x40\x8e\x1c\x71\x41\x04\x86\x7e\x96\x9c\x69\xdb\x6c\x7d\x5a\x6a\x92\x8a\x3b\x7e\x1c\xf8\x5d\xc9\x08\xf4\xc3\x5e\x57\x74\xb4\xde\xac\x04\x50\xd3\xfd\xba\x4a\xce\xb1\xdf\xfb\x30\x78\x99\x72\xa6\xcf\x31\x29\xb9\x82\x96\xec\xbd\x33\xe1\xe8\xcf\x7f\xda\x8d\x46\xb0\x1c\x44\xa9\x3f\x89\xf6\x77\x37\x65\xc9\x34\x14\x66\x59\x0e\x8a\x88\x72\x41\x2d\x7e\xed\x1e\x5b\xbd\x43\x51\x05\x5c\x35\x76\x35\xec\xae\xb0\x7e\xb9\x7e\xa5\xcb\x11\x7c\x41\x3f\x66\x0c\xce\x3e\xbf\xba\xfe\xf5\xed\xe9\x7f\x5d\xbc\x75\xe7\x93\x87\x4c\xbf\xe4\xec\x9f\x25\x10\x9a\x0b\x23\x0b\x67\x61\x20\x60\x0f\x35\xfa\xe0\x07\x3c\xc9\xdd\x86\x0c\xee\xc8\x90\xb1\x79\x7c\xfb\xc0\x48\x6c\x41\xff\xf1\xe3\x22\x9f\xba\xa9\x56\x1d\xdc\x62\xe4\xc6\xa0\xa9\x16\x25\x1c\xb4\x39\x79\x56\xa2\xb4\x4d\xd6\x18\x9f\x64\xa1\x30\xb9\x1b\xb9\x6a\xab\x13\xb5\xd5\x88\xfa\xf5\x17\x0c\x77\x55\x8c\x3a\x69\xee\x55\xaf\xa1\xa3\x96\x38\x35\xd5\xf6\x6a\x80\xed\x59\xec\xd5\x00\x2b\x7a\x5c\x0e\x09\x4d\x53\x89\x62\x0a\x9e\xfa\x7c\xa1\x35\x66\x51\xc7\xd2\xf4\xc8\x2b\xf2\x37\x72\x4f\xfe\x86\x6a\xc1\x9f\xdb\x36\x10\x6a\x2b\xb0\x77\x11\x1a\x63\xb4\xd1\xcb\x61\x47\x10\xff\x71\x4a\x35\xce\x68\xa0\xaa\x05\x19\x31\x27\x86\xc2\xbd\x06\x69\xc4\x22\xb7\x13\x4f\xda\x7a\xc9\x2c\xf0\x13\xa2\x99\x35\x93\x5f\x8e\x9b\xe1\x38\xdb\x21\x9a\x79\xdc\xe8\xf7\x57\x8e\x0a\x35\x3b\x9d\xd4\xb3\xe5\x54\x27\xd3\x26\x19\x33\x02\x86\x6a\x30\xa7\x54\x20\x19\xb7\x81\xb7\x53\xd6\xc2\xe9\xbf\x3f\x68\xdc\xce\x0f\xdc\xd8\xcf\x87\x76\x6a\x41\xf1\x47\x3e\xef\x04\x83\xa0\x78\x52\x21\xd2\x01\xb9\xa0\xc9\x14\x97\x95\x06\x3c\xc3\x68\x20\x38\xd9\x94\xce\xcc\xc6\xbb\x67\x6d\x67\x20\x94\x56\x2a\xeb\x28\xe2\x92\x39\x4f\x09\xe5\xb6\x37\xe7\x18\xa4\xb4\xb1\xd2\xa3\xb9\x0f\x32\x6b\xbd\x79\xad\x4e\x52\x21\x85\x16\x89\x68\xd1\x1d\x6a\x31\xff\x02\xa7\x43\x20\xd8\xf8\x54\x6f\xde\xfd\xfe\x7c\xd8\x23\x37\x67\x43\x6c\xeb\x73\x7d\x76\x33\x6c\x4a\xd8\x07\x37\x67\xc3\x83\x27\x05\x05\xf1\x66\x36\x34\xa8\xee\x30\x49\xc3\x60\x92\x31\xa5\xfb\x39\x2d\xfa\xb7\x30\xdf\x91\xa7\x76\xc1\xd7\xfb\xd5\x0e\x77\xf2\x41\x16\xcc\x39\x2d\xb6\x9e\x4d\x02\x4d\x59\x4c\xf4\xd9\x7c\xc4\x44\x9f\x0d\x47\x4c\xf4\x89\x89\x3e\xcb\x63\x6f\x62\x19\x63\xa2\xcf\xcb\x72\xdd\xc6\x44\x9f\xcf\xde\xff\x1b\x13\x7d\x56\x8f\x98\xe8\x13\x13\x7d\x36\x1b\x31\xd1\x67\xfb\xb1\x77\x91\x2b\x31\xd1\x67\xab\x11\x13\x7d\x96\x47\x4c\xf4\x59\x33\x62\xa2\xcf\x9a\x11\x13\x7d\x62\xa2\x4f\x4c\xf4\x89\xf1\x8f\x8f\xce\xb5\x9f\xf1\x8f\x24\x26\xfa\xb8\x11\x13\x7d\x5e\x44\x94\x17\x89\x89\x3e\x1b\x8d\x98\xe8\x13\x13\x7d\x76\x19\x31\xd1\xe7\xa5\x98\x4b\x62\xa2\x4f\x4c\xf4\xf9\x7c\x04\xdd\x98\xe8\x13\x13\x7d\x62\xa2\x4f\x4c\xf4\x79\x70\x15\x31\xd1\xe7\x25\xa8\x80\xbe\xef\x6a\xfb\x2c\x95\x0f\x7e\xa6\xcd\x03\xfb\xc8\xc5\x8a\x5f\xd1\x12\xa2\x0a\x33\x89\xac\xa7\xcc\x24\xd0\x74\x8e\x53\x62\xaf\x87\x40\xc8\x7a\x86\xf1\x81\x19\xcb\xd9\x6e\x89\x41\x64\xe9\xd0\xbc\xc5\xb9\x02\xaf\x8b\x01\x4b\x4e\xef\xf1\x00\xd0\x5c\x94\xb6\xfd\x6b\x22\xf2\xa2\xd4\x4d\x98\xe2\xf6\xec\xd2\xb9\x75\xcc\x26\x8e\xa3\x9e\xd8\x26\xb3\xfd\x6a\xda\x7e\xd0\xd8\xf5\x09\xdb\xb5\xd2\xd4\xc7\xcd\x0d\xbb\x08\x1a\xa1\x5a\x83\xe4\x6f\xc8\x7f\x1f\xfd\xfc\xe5\x6f\xfd\xe3\xaf\x8e\x8e\x7e\x7a\xd5\xff\xeb\x2f\x5f\x1e\xfd\x3c\xc0\x7f\xfc\xfb\xf1\x57\xc7\xbf\xf9\x3f\xbe\x3c\x3e\x3e\x3a\xfa\xe9\xbb\x77\xdf\xdc\x0c\x2f\x7e\x61\xc7\xbf\xfd\xc4\xcb\xfc\xd6\xfe\xf5\xdb\xd1\x4f\x70\xf1\xcb\x86\x93\x1c\x1f\x7f\xf5\xc5\xce\x4b\x6e\x2d\xf0\x76\x27\xee\x76\x24\xec\x7e\x14\x51\xd7\xb9\x6b\x3b\x3a\x8b\x2e\xd4\x64\xe9\x34\x3a\x76\xf4\xd0\x69\xf4\x1a\x37\x0a\x71\xd5\x3c\x4c\x11\x91\x33\xad\x1d\x15\xa5\x61\xb8\x2a\xd3\x0d\x95\xd3\xd1\x01\x6c\x8a\x4d\xb5\x6d\x56\x5d\x85\x7a\x06\x21\x2a\xc2\xcb\x75\xae\x9b\x37\xcb\x8b\x0c\x9b\x44\xe3\x79\xee\xfb\x48\x15\x64\x9d\x91\x36\x3c\x3e\x22\x6d\x78\x89\xb4\x41\x41\x52\x4a\xa6\xe7\x67\x82\x6b\xb8\xdf\xc9\x7e\xb2\xce\x80\x74\xdd\x9c\xda\xc5\x86\x29\x17\xd3\x66\xaf\x11\x51\xd8\x08\xef\xb5\xb9\xd3\x53\x51\x66\x29\x66\x26\x95\x1c\x55\x4a\x9b\xe4\x06\xda\xea\x7b\xa8\xe9\x60\xf8\xf6\xe2\xeb\xbc\x06\x67\xa7\xfe\x67\xc9\x66\x34\x33\xfa\x6d\xfd\xc4\x10\x75\x96\xf0\xa1\x9d\x8c\x58\x4f\x2c\x63\xa1\x78\x33\x94\x6c\xc6\x32\x98\xc0\x85\x4a\x68\x86\x54\xa9\x1b\x4a\x7f\xba\x66\x76\xdc\x22\x29\x32\x45\xee\xa6\x80\x5d\xf8\xa9\x57\xcf\x31\x95\x6c\x42\x19\x27\xb9\x21\xaa\x85\x7f\x58\x59\x3d\xdf\x10\x6f\x23\xf5\x72\x5d\xeb\xf3\xa8\xbe\x8e\x84\xc8\x5c\x3e\x42\x36\xaf\xe7\x67\xd6\xf4\xc6\xc5\xaf\x1c\xee\x7e\x35\xb3\x29\x32\xce\xe8\xa4\x52\xe3\x15\xe8\x25\x4b\x5c\x3d\xf5\xda\x0f\xc0\x60\xff\x12\x08\xcd\xee\xe8\x5c\xd5\x46\x8d\x7a\x0e\xa6\xde\x90\xd7\xc7\x88\x78\x54\x91\x6a\x8e\x94\xfc\xe1\x18\x5d\x73\x67\xa7\xc3\x5f\xaf\xff\x7e\xfd\xeb\xe9\xf9\xbb\xcb\x2b\x72\x25\x34\x58\x96\x14\x34\x4a\x4b\x28\x37\x1a\x82\x5b\x25\xbe\x03\x35\x68\xa1\x06\x68\x57\x64\x8a\xdc\x31\x9e\x8a\x3b\xb5\xb3\xfd\xd4\xa2\x9f\x01\x1e\x50\xbe\xd3\x1c\x09\x2d\x28\xf6\x7f\x6b\xc1\x1f\x96\xa2\x3f\xc2\x49\x91\x03\xa7\xe9\x49\x2a\x45\x61\x81\xe0\x0d\x50\xa1\x92\x74\xbe\x60\x57\xf6\xf1\xa5\xb8\xbf\xe3\xe6\x84\x13\x49\xb9\xae\x2d\x31\xf5\x9e\xb9\xc6\x73\x83\xd6\xdb\xf1\xbc\xf3\x8d\x68\xda\x5d\xae\xd1\x69\x9a\x42\xda\x00\xff\x8b\x8b\xea\x3b\xf3\x1f\x37\xaf\xcb\x31\x90\xe1\xfb\xeb\xcb\xff\xbd\x80\xc7\xf3\xa2\x5d\x10\x53\x37\x29\xa0\x52\x14\x9d\xed\xee\x07\xc8\xc5\x2c\xee\xef\xbe\xec\x6f\xc5\x2d\xbb\x71\x9d\x7f\x28\x79\xc8\xd0\x78\x30\x3f\xc9\x45\x0a\x03\x32\xac\x6c\xf8\xcd\xab\x61\x99\x19\x09\xc4\xdc\xc2\x35\xa3\x59\x36\x0f\x85\x29\x2d\x6c\x8e\x60\xa3\x08\x41\x48\xc8\xc7\x34\x53\x4f\x4d\x8d\xdb\xf0\x46\x23\x47\xbc\x33\xda\x6c\x27\xdb\x51\xcd\x46\x52\xe0\x42\x3b\x61\xd8\xac\x12\x0b\x3b\x48\x91\x10\xab\x3a\x07\x81\x52\x0d\xfe\xa6\xac\x1f\xc1\xb3\x46\xa6\x3c\xb0\x87\xd5\xcc\xd6\x88\x5c\x2a\x50\xab\x59\x63\xad\x4c\x9b\xd9\x25\xd0\x54\xf0\x6c\x8e\x51\x91\x36\xce\x21\xa7\xea\x16\x52\xfb\x83\x13\xcd\x2a\x2f\x82\x99\xb1\x7a\xd5\x8d\x59\xb7\x77\x19\xa0\x48\x66\xa3\x2f\xd0\xd5\x60\x34\xfc\x27\xdd\xf5\x16\x87\xd0\x00\xe5\x3d\xcf\xe6\x1f\x84\xd0\x5f\x57\x49\xae\x9d\x60\xc0\x8f\x4e\x5a\x46\x80\x34\x23\xbd\x28\xbe\xb7\x8f\xbb\x81\x87\x2a\xcc\xaf\x3d\xaf\x77\xfc\xb9\x1f\x29\x59\xf2\x53\xf5\x8d\x14\xe5\xce\x4c\x6c\x49\xd8\xfc\xe6\xf2\x1c\x49\x51\xe9\xdc\x88\x5c\xcb\x79\x21\x98\xb5\x41\xad\x51\x0c\xbe\x77\x8e\xd0\xf0\x4c\xd4\x3e\x2b\xf2\x8e\xce\x09\xcd\x94\xf0\xb0\x64\x7c\x95\xbe\x48\x9c\x32\x6a\x2e\x8f\x84\x9e\x2e\x69\xa1\xe6\x40\x2d\x3f\xd7\x0b\xbc\x8a\x75\x75\x30\xc6\x97\x1e\xd7\xf4\x16\x14\x29\x24\x24\x90\x02\x4f\x9e\x7a\xdb\x9f\xda\x19\x87\xa8\x73\x25\xb8\x39\x98\x9d\x20\xcf\x65\xe5\x85\x75\x20\x0d\x51\x05\xfd\xb9\x4e\xfb\xa3\xe8\xd5\xc5\x63\x59\x2a\x90\xd6\x05\x2d\x4b\xb0\x3b\xf9\x5d\x39\x82\xcc\x40\xde\xa8\xa4\xae\x6b\xb6\x35\x3c\xb0\x9c\x4e\x80\x50\x5d\x61\x9a\x16\x04\xb8\x32\x14\xd3\x9a\x2f\x35\x49\x05\xd4\xb9\xf1\x54\x91\xef\x2f\xcf\xc9\x2b\x72\x64\xde\x75\x8c\xf8\x83\x4d\xb5\xb5\xb0\x01\x68\x8b\x3a\xea\xd8\x4f\x81\x4b\x42\xe4\x25\x42\x5a\x22\xd1\x23\x5c\x10\x55\x26\xd3\xb0\x93\xb7\x57\x9b\x5d\x90\x22\x3a\x46\xf6\x13\xd7\x9f\x96\x42\x7d\xaf\x40\x76\x46\xa0\xbe\xdf\x81\x40\x85\x62\x94\xc1\xb9\x26\xf4\x2c\x62\xe5\xa0\x69\x4a\x35\x75\x84\xab\xea\xac\xbe\xaf\x5b\xfa\x79\x93\x2f\x05\x6f\x19\x2f\xef\xad\x89\xb4\x3b\x53\xcb\xf5\x05\x4e\x8b\x38\x84\x50\xc7\x5d\xa7\x45\x91\xb1\xda\x81\x1c\x04\xa9\x5d\x36\x70\xa5\xb7\x46\x4c\x44\x3a\xe1\xfd\xd0\x46\x38\xa1\x3c\x15\xf9\xd2\xcb\xd0\xe9\x4d\x93\x69\xf8\x82\x88\x7d\xcd\xb1\x27\x46\xa1\x0c\x66\xd0\xa2\x88\xd6\x02\xe6\xbd\x35\xb3\x19\xe0\x78\x8c\xc0\xe9\x49\x46\x47\x90\x59\x18\x5b\x0c\x54\xcb\x18\xf8\xd4\x91\xa2\x52\x64\xdd\xa5\xb6\x7c\x10\x19\xd8\xd0\x2b\x0f\x08\x33\xfd\xb3\x80\x03\x4e\xd2\x15\x1c\x50\x1b\x6c\xc0\x01\xf5\xda\xe7\x00\x87\xb2\x05\xab\x27\x8b\x70\x30\x72\x43\x13\x0e\xc8\xbc\xf7\x1d\x0e\x0a\x92\x44\xe4\xc5\x50\x0a\xa3\x76\x76\xc6\x9b\xdc\xb4\xb5\x9f\xcf\x1a\x36\xd0\x6e\x1f\x6a\xc0\xce\xab\xd7\xbc\x99\xca\x20\xe8\x92\x6a\xcb\x24\x7c\xe4\xe5\xff\x0a\x78\x16\x92\x9e\x45\x46\xe6\x67\x69\x38\x02\xcd\x93\xee\xc2\x73\x66\x07\x5d\xe4\x2d\xb4\x30\x76\x76\xc2\x8d\x44\x42\x33\x2c\x92\xda\x0e\xe5\xc8\x22\xda\x2d\x4e\x1c\x84\xda\xa2\x8f\x12\x7f\xf3\xe1\x1f\x58\x2f\x13\x7f\x71\x26\x4c\x2e\x52\x08\xbc\xce\x36\x46\xf8\xc6\x86\x64\xe2\x7d\x3e\xca\xd7\xc8\x15\x2e\x0a\x04\xd2\xc6\xd3\x5a\xb8\xfa\x64\xef\xaa\xd2\xab\x66\x81\xc0\x53\xc6\x27\x68\x57\xeb\x11\x09\x99\x8d\x0f\x76\x44\xe0\xd6\x6a\x90\x87\x78\x24\xfc\xa4\xfe\x3c\xf8\x57\xa3\x2c\xc6\x04\x77\x33\xa3\xa5\xc8\x4b\x58\x63\x4b\x6e\x99\x22\x07\x6f\x3d\x00\x5a\xd4\xaa\xdc\x47\x0e\x73\x60\xbf\xb0\xda\x4d\x6b\xe9\xbc\x65\x3c\x75\xa1\xb4\x0d\x60\x79\x3d\xd7\xc9\xc1\x18\xa4\xcd\xd2\x90\xb6\xbc\x21\x3f\x73\x52\x01\x8b\xf4\x77\x46\x8f\x0f\x56\x64\xf6\x36\xba\xfe\xc3\x86\xd7\xea\x25\x8b\xd3\x7c\xcf\x71\xef\xcd\x7b\xfb\x46\x73\x5f\xbe\xcf\x7f\xcb\x93\x96\xd5\x71\xd4\xaf\x6b\x2d\xe6\x47\x3b\xad\x17\xe9\x13\x83\xd6\x9a\xf1\x89\x0a\x35\x99\x66\x45\xfc\xd5\xaa\x8c\xdf\xe1\xb1\x14\x36\x05\x73\x59\x85\x58\x48\x01\x78\x2e\x6a\x48\x66\xc4\x89\x67\xae\x84\x4c\x72\x45\xcf\xa4\x81\x84\x66\x34\xbb\x2e\x76\x2f\x20\x4a\x96\x8a\xd5\xbd\xbb\x3e\x6d\x4e\x8d\xcc\x7a\x0a\xd2\xf2\x7e\x73\x9d\xd0\x34\x67\x4a\xa1\x21\x0c\x46\x53\x21\x6e\xc9\xd1\x8a\x5a\x59\x41\x94\x95\x62\x13\x75\xe2\x70\xbe\x6f\x56\x7f\x4c\x18\xcf\xaa\x48\x26\xd4\x83\xb9\x56\xde\x90\x83\x2f\x49\xaa\x55\xe0\x1e\xba\x02\xcd\x2e\x58\x61\x79\x99\xb6\x24\xb3\xc1\x82\x27\x27\xd8\xcb\xdb\x73\xd5\xb2\x24\xca\x23\x5b\x74\xe5\x70\x7b\xb1\xea\xd9\x4a\x38\x5a\xe9\xf1\xc9\x81\xe4\x84\x8b\x04\x54\x77\xc5\x96\xbe\xad\xe7\x24\x29\xd8\x0c\x1b\xc0\xe8\x27\xba\x36\x1c\x0e\xed\xd2\x87\x98\xa8\xe9\x1e\x3d\x0c\x25\xea\x9b\x9a\xb8\x18\x7d\x24\x2b\xa6\xb4\x6f\x95\x74\x43\xd1\x90\x04\x7a\x11\x62\x2a\xb8\x90\x16\x45\x0d\x13\x15\x1c\x51\x1a\x49\x94\xf5\xe6\xe1\x9e\x38\x12\x1d\x2c\xf5\xac\xf6\x12\x87\x8e\x40\x4c\xf4\xb2\xb5\x1d\xea\x35\xdc\x31\x3d\xc5\x2a\xac\xd3\x05\xaf\x21\xae\x44\x82\x42\x07\x0c\x27\x20\xa5\x90\x2e\x20\xcb\xdb\xad\x71\x26\xa4\xe4\x18\xd1\x65\x90\x84\x9a\xbf\x0e\x55\xe8\xa8\xae\x6b\x9e\x63\x8c\xa1\xc1\x26\x18\x8f\x21\x41\x41\x2b\x04\xb0\xa5\xda\x47\x75\x59\x5a\x9f\xc2\xa1\x85\xaf\x99\x9e\xb3\x7b\xf3\x96\xf0\xa9\x85\xce\x2b\x5c\xf0\xfe\xea\xcb\xc7\x03\x42\x2e\x79\x15\x7f\xdb\x33\xbb\x18\xde\xe9\x43\xcf\xb4\xf9\xc4\xb0\xe0\x3e\x7e\x40\x68\x38\x33\xd2\xa1\x2c\x3b\xc0\xf8\x36\xe6\x70\x12\x9a\xc4\x3b\x25\x07\x68\x1a\x77\x93\x9a\xad\xf7\x32\x40\x1b\x53\xb9\xb9\xe5\x63\x99\xcb\x9f\x87\x03\x84\xb4\xa5\x73\xae\xd2\x41\xac\x82\xbe\xd9\x88\x55\xd0\x37\x1c\xb1\x0a\x7a\xac\x82\xbe\x3c\xf6\x26\x64\x30\x56\x41\x7f\x59\x75\x6d\x62\x15\xf4\xa7\x37\x32\xc7\x2a\xe8\xb1\x0a\xfa\x43\x23\x56\x41\x7f\x64\xc4\x2a\xe8\x3b\x8c\x17\x40\xb9\x62\x15\xf4\x1d\x46\xac\x82\xbe\x7a\xc4\x2a\xe8\xcb\x23\x56\x41\x5f\x3b\x62\x15\xf4\x9d\x47\xac\x82\x1e\xab\xa0\xc7\xe2\x90\xdb\xcd\xb5\x9f\xc5\x21\x49\xac\x82\xee\x46\xac\x82\xfe\x22\x4a\xe0\x91\x58\x05\x7d\xa3\x11\xab\xa0\xc7\x2a\xe8\xbb\x8c\x58\x05\xfd\xa5\x98\x4b\x62\x15\xf4\x58\x05\xfd\xf3\x11\x74\x63\x15\xf4\x58\x05\x3d\x56\x41\x8f\x55\xd0\x1f\x5c\x45\xac\x82\xfe\x12\x54\x40\xa5\x53\xb6\x53\x61\xc8\x4d\x6a\xd8\xb8\xd8\xe4\x20\x65\x7c\x54\x8e\xc7\x20\x91\x72\xe1\x9b\x97\xc2\xa7\xea\x72\x7d\x8b\x4e\x56\xd0\x3d\x2c\x87\xe3\xd2\x38\xd6\x3c\xee\x72\xd4\xb1\x80\x63\x1d\x40\x7c\xf1\xfe\xeb\x15\x05\x73\x76\x8e\x2b\xdc\x35\x74\x16\xd7\xfc\x9e\xef\xe6\x1f\x5f\x03\xf0\x55\x69\x45\x0e\xee\x49\x26\x94\x0b\x7c\x46\x60\x25\x53\xca\x39\x78\x7d\x8f\x69\xb4\xa3\x8c\x00\x38\x11\x05\x38\xef\x34\x25\x8a\xf1\x49\x06\x84\x6a\x4d\x93\xe9\xc0\xbc\x89\x7b\x60\xd7\x41\xca\xee\x17\xa5\x25\xd0\xdc\x87\x6b\xe7\x94\xd9\xa9\x08\x4d\xa4\x50\x8a\xe4\x65\xa6\x59\x51\x4d\x46\x14\x60\x9e\x85\x65\x54\x15\x30\x30\x2e\xae\x8e\x6c\xee\xd5\x6f\x73\xcb\x12\x61\xc5\x32\xd4\x36\x7b\x58\xe4\x39\x2f\xf4\x9c\x98\x4f\xce\x5c\xe1\x57\xa9\x34\x49\x32\x86\xdc\x1a\xdf\x68\x53\x6a\x71\xbe\x9e\xe7\xd5\xdc\xad\x54\xb9\xa5\xf2\x14\xc5\xd6\x42\x2b\x82\x81\xc0\xf5\x84\x6e\xaa\x94\x29\x27\xe6\xab\x1e\xa1\xbe\x9c\x96\x05\xb4\x5f\x29\x82\xda\x73\x16\x3b\xbb\xfb\x29\x98\x2e\x28\x23\x6a\x70\xd3\x1a\xb0\x6a\x44\xc7\xc8\x77\x8f\x9c\xbd\x46\x90\x7f\x2d\x50\x60\x9c\xde\xd2\x31\xc0\x0d\xe0\x30\x33\x38\x00\x09\x18\xfe\x4a\xd7\x60\xfd\x27\x47\x7a\x4d\xe5\x04\x74\x15\xcf\xb4\x6b\xb4\x78\x33\x2c\x24\x2c\xf8\x1b\x2a\x22\x35\xc8\x10\x3a\x43\x91\x62\xd2\x4f\x9d\x59\xb5\xaa\xa2\xb0\x5d\xa1\x2b\xa4\xb6\xea\x06\x2f\x18\xd9\x20\xcd\xea\xa5\xaa\xa0\x09\x28\x72\x74\x39\x3c\xeb\x91\xe1\xe5\xb9\x8b\xc4\x14\xe3\x55\x99\xcc\x8e\x86\x59\x0c\x5c\x57\xdb\xb8\xaa\xd1\x16\x4c\x1f\x64\x7f\xba\x77\x0f\x2b\xf9\xea\x67\xee\x02\x4c\x17\x29\x00\x8a\x5c\x55\x7d\x73\xa2\x4a\x14\x91\x9c\x4d\x88\x55\xa9\x19\x0e\xf9\xa0\x4e\x48\xf4\x95\x87\xfc\x13\xd5\x42\x1c\x94\x5c\xde\x85\xf7\x75\x23\x81\x45\x7e\xbd\x94\xdc\x81\xc1\xa0\x2e\xee\x65\xa7\x78\x97\x56\x1a\x52\x20\x8a\xbd\x03\xa5\xe8\x04\x86\x3b\xba\xb7\xd6\xd9\x01\xd0\xc3\x55\x93\x03\x24\x40\x99\x4d\xf5\xad\x7e\xa9\xa3\x82\x9b\xc2\x37\xc9\xed\x9a\x2a\xcc\xba\x93\x4c\x6b\x40\x52\x82\xe5\xfe\x70\xb3\x17\xab\x01\x1c\x2e\xc4\x16\xbf\xf3\x93\xd4\x0f\x1b\x51\x82\xa7\x36\xd2\x77\x04\x64\x24\x19\x8c\xc9\x98\x61\xf8\x30\x06\xf4\xf6\x6c\xf5\x27\x6a\x6d\x4f\x4a\x81\xc4\xf5\x38\x0d\xca\xaf\x6b\x40\x7e\x74\x0b\xd3\xb2\xe4\xb6\xed\x88\x13\xee\x31\xdd\x95\x8d\xc9\x04\x03\x82\x9d\x8e\xf2\xa7\x57\x7f\xfd\x33\x19\xcd\x8d\x20\x85\x08\xa9\x85\xa6\x59\xf5\x91\x19\xf0\x89\x81\x95\x65\x0a\xcd\x84\xcd\x0a\x02\xd8\x18\xc4\x2e\xfc\xf5\x1f\x6e\x47\x4d\xc9\xee\x24\x85\xd9\x49\x00\xbf\x7e\x26\x26\x03\x72\x56\xe5\x47\x96\x45\x8a\x76\xfe\xdd\x8b\x75\x77\x87\x66\x22\x63\xc9\xbc\x35\xa2\xf9\x32\x64\x64\x2a\xee\xac\x86\xb9\x02\x7b\xea\xdc\xaf\x42\x14\x65\x66\x5d\x1d\x5f\x57\xa9\xce\xa5\x82\xe5\x84\xc4\x95\xe7\x02\x8d\xf3\x6e\x8a\x05\x3a\xea\xe2\xc0\xfd\x2b\x85\x4b\x74\x71\xe6\xe3\xaa\x1a\x19\x12\x93\xaf\x69\x96\x8d\x68\x72\x7b\x23\xde\x8a\x89\x7a\xcf\x2f\xa4\x14\xb2\xb9\x96\x8c\x1a\x1e\x3d\x2d\xf9\xad\x6d\x06\x51\xd5\x6b\x10\x13\x23\xd0\x17\xa5\xf6\xe5\xbd\x57\x7d\xb0\x4d\xde\xf7\xac\xdf\x2b\xdf\xf5\x2c\x70\xcf\x6a\x0d\xdb\xe5\x8d\x59\x8c\x0c\xe7\x57\x21\xb2\xfd\xe1\xd5\x9f\xfe\x62\x51\x97\x08\x49\xfe\xf2\x0a\x73\x05\x54\xcf\x1e\x62\xe4\xa8\x46\x3c\xc9\x69\x96\x19\x42\x1e\x22\xa5\x01\xf4\x2a\x24\xfc\xe4\x38\xa8\xdb\xa3\xdb\xc6\x02\xfc\xcd\xcd\xdf\x91\x8b\x30\xad\x20\x1b\xf7\x6c\x8a\x54\xa5\x4c\x1f\xa2\x38\x72\xe8\xa8\x0f\xe6\xa9\xed\x81\xd8\x3d\x13\x59\x99\xc3\x39\xcc\x58\x17\xdd\x9e\x1a\xb3\x79\x03\x53\xc6\x14\xf2\xc1\x51\x26\x92\x5b\x92\xba\x8b\x41\xbc\xd3\x62\x59\xf2\xdd\xa1\xb0\x6b\xe4\x57\x8b\x88\xaf\xb5\xdf\xdf\x88\xf5\xca\x69\x51\x18\x19\x00\x33\x31\x25\xbd\x6b\x00\x03\xcf\x24\xd6\x4e\x68\x59\xdc\xa6\xb5\x73\xa3\xad\x6b\xa3\xef\xbe\xc8\xd0\xcd\x9d\xa7\xd8\x39\xd6\xa9\xbd\x67\xa4\x5e\xfd\xee\xe6\xf0\x06\x42\xd4\x13\xfa\xd3\x50\xe0\xbf\x6d\x36\xd3\x92\x60\x5e\x95\xd5\xac\x10\xc3\x0a\x00\x06\x7d\x90\x24\xef\x6e\xe6\xef\xc0\xa6\xde\x2e\xd0\xad\x01\x17\x5e\xf9\x32\x72\xaa\x9d\x40\xe8\x75\x15\x4a\x0a\x90\x8a\x29\xc3\x97\x7f\xc0\x03\x75\x96\x51\x96\x07\x86\xe7\xa7\x01\x82\x3d\xdc\x58\xcb\xb9\x3d\xa5\x34\x7a\x8a\x9d\x10\x49\xa1\xad\x63\xbd\x42\xac\x6d\x4a\xb5\xd7\xe5\x08\xf1\x07\x6f\xdf\xa6\xa5\x5e\x87\x9c\xf8\xa9\x69\xec\x0f\xf5\x36\x34\x49\xac\xf9\xa5\xa2\xb1\xf6\xae\x97\x44\x59\xf1\xfb\x9e\x2b\x61\xad\x16\xdf\x11\xfd\x40\x8a\xea\x36\xb7\x49\x42\x1b\x5a\xa7\x3d\x61\x81\x2e\xe0\x14\xc8\x01\xb1\x41\x1b\xe6\x4c\xb8\x47\xc9\xe1\x9b\xc3\x27\xa5\xae\x16\x44\x52\x14\x74\xd2\xaa\x23\xd1\x02\xa4\x16\xa7\x0d\xcb\x65\x18\xfd\x29\x20\x25\x85\xbb\xcb\x50\x12\x5f\x0d\x08\x6b\x3d\x59\x67\xbe\x07\xb0\xd3\x2c\xb0\x63\x1c\xb9\xa3\x73\x42\xa5\x28\x79\xea\xcc\xa1\x95\x3d\xfa\xdd\xc2\x8b\xaf\x04\x07\xef\xe7\x59\xac\xb6\x81\x0e\x28\xc6\xc9\xeb\xc1\xeb\x57\x2f\x85\xc5\xe1\x17\x2e\xb0\xb8\xab\x8a\xc5\x59\xfa\xf4\xa4\xdf\xea\xeb\xf6\x77\xf4\xbd\xef\x9c\x6d\xa6\x2e\xcb\xcf\x7c\xd1\x6f\xfc\xe9\x4e\x32\x0d\x41\x9f\xc1\x23\xd4\x78\x8c\x62\x19\xd4\x96\x38\x5e\xd5\x0f\xa3\x25\x90\xda\x15\xf3\x50\xe5\xe8\x23\xd2\x2d\x47\xa0\xf0\xb8\xad\x32\x8d\xa9\x07\x48\x58\x08\xa8\x83\x03\x72\x64\xef\x3c\xb4\x19\xf8\xc7\x4f\x8a\x5a\x0e\x68\x17\xf7\x45\x8b\x4a\xa1\x0b\xc5\x1e\x0a\x8a\xc6\xbb\xa2\x43\x08\xfe\x17\x4c\xe9\x0c\xb0\xf2\x00\xcb\xa8\xcc\xd0\x45\x7e\x6d\xd7\x4e\x46\xa5\x26\xc0\x67\x4c\x0a\x8e\x76\xe2\x19\x95\x0c\x6b\xfb\x48\x18\x83\x04\x6e\x94\xd8\x2f\x8e\x7e\x38\xfd\x80\xf1\x37\xc7\xb6\xef\x8b\x5f\x65\xa9\x7c\x11\x9e\x70\x25\xc1\x74\x8f\x6e\x9f\x5f\x87\x81\x21\xd2\x5c\xbf\x2e\xf3\x9e\xbc\xd4\xa5\x6d\x2e\x73\x9f\x64\xa5\x62\xb3\xa7\xa2\x24\xae\x24\xc4\x39\xdb\x69\x9f\x17\xca\x53\xd4\x80\x5a\xaa\x34\x51\xbb\x09\x1e\x29\xc4\x7d\xa8\xaa\x1c\xd3\x30\x64\xc3\xd9\xac\x48\xce\x26\x53\xed\xa2\x3d\x17\x3c\x07\x81\x0b\x2a\x47\x33\xef\x53\x5a\xaf\x0c\xdb\x3d\xcd\x18\x55\xdb\x8a\x5c\x4b\x89\x8c\x6e\x16\x97\x60\x2f\x7c\x6c\x91\x37\xca\x98\x17\x59\x4b\xe5\xe5\xd0\x79\xd0\x3c\xdc\x18\xff\x1f\x1b\x58\x53\xa9\x25\x36\x50\xc6\x3e\x62\xcd\x8d\x63\x12\x94\x05\xf2\x01\x25\x48\xfc\xb1\x16\x15\x6a\x24\x5c\xf0\xfe\x34\x28\xdb\x54\x88\x74\xcb\x24\xbf\x5d\x15\x8f\x9d\x54\x8e\xd5\x10\x24\x53\x91\xa5\xbe\x8b\xb6\xb5\xe5\x8c\x40\xdf\x01\x70\x72\x39\x44\xf8\x99\x4f\x44\x8f\xd0\x1a\x28\x5a\xb7\x02\x16\x68\x0a\x54\xd9\x06\x3c\xb7\x45\xb0\x16\x5a\x49\x1b\x91\xbe\xfa\xd2\xd6\x67\xfe\xdb\x0a\x66\x3e\x22\x9b\x8e\xc4\x0c\x10\xa4\x69\x2a\x41\xb5\x28\x70\xf4\x04\x7a\x6a\x2b\x52\xca\x76\x6a\xf0\xd3\x74\x8c\x54\x60\xf3\xa6\x25\x14\xdf\xf1\xa8\x22\xe2\x7d\x62\x0a\x76\x39\x3c\x6b\x41\xbd\x0e\xbf\x77\x7e\x11\x33\xd5\xe1\xa1\x22\xac\x48\x6a\x9f\xeb\x80\xd4\xee\xc6\x20\x51\xc2\x4a\x8c\xdb\xf9\xba\x76\x15\x13\x03\xa2\xd6\x92\x48\x13\x6e\xa7\x31\x64\xc5\x25\x49\x3b\x73\x0e\x3a\x1d\x0a\x91\x62\x07\xa6\x1a\x1a\xca\x3f\x11\x02\xc4\x07\x4b\x58\x22\xef\x42\x47\x7a\x55\x10\xf2\x02\x61\x42\xd3\xbb\x0f\x3f\x0c\xa8\xf8\x12\x30\x3f\x19\x2c\x87\x97\xe7\x5d\xa2\x4b\xc1\xd2\xbd\x43\x97\xed\xf5\xcb\x66\x4a\x5c\xb3\x92\x84\x9b\xd0\x1f\xf6\xa1\x48\xd7\x88\x49\x35\xa3\xc1\xfb\xc3\x5e\xc0\x5a\x10\x4a\xac\x7d\x71\xa1\xcb\xfb\x0e\x40\xd9\x9a\x4a\xa0\xa8\x35\x2c\xb3\xec\x1a\x12\x09\xdb\xda\x55\x9b\xfb\x7f\xb9\x30\xd7\x3a\x91\x27\x90\xdf\xb1\x3c\x81\xbb\x99\xd7\x65\x30\x83\xc0\x8e\x3a\xf9\xb0\x28\x33\x8c\x85\xa5\x7c\xee\x01\x8e\xab\x57\x81\x13\x8b\x29\x1f\x56\x63\xc3\xb8\x1a\xbb\xa0\xa0\x7a\x59\xd5\x55\x8a\x2a\x65\x5d\xad\x8c\xa7\x6c\xc6\xd2\x92\x66\xf8\x22\x94\x42\xc3\x0e\xfc\x15\x87\xcc\x7d\x59\x57\xf2\xb5\x90\x04\xee\xa9\xb9\xad\x57\x09\xb1\x54\x21\x3a\xa4\x22\xb9\x05\xd9\xb3\xa2\xd8\x39\xfe\x71\x86\x12\xaf\xad\x7b\xee\xd7\x61\x74\x09\x57\xcc\x74\x97\xa6\xfe\xbe\x6b\xbf\x85\xc3\xef\xed\xe7\xce\x19\x9f\xf4\xf1\x17\xf3\x21\xee\x4d\x7d\xc1\xfb\xb4\x6f\xd0\xf0\x99\x08\x7e\x58\xe8\xfc\x3d\x4a\x56\x1f\x3c\xbe\x78\x15\xc1\x28\x72\xa2\x9c\x4c\x11\x58\x32\xa7\xbe\xe6\x60\x06\x1a\xcb\xc9\x39\x87\xb0\x8d\x02\x72\xcf\xa6\x4e\x4c\x0b\xcb\xeb\x35\x71\xed\x99\x08\x7f\xbb\x5a\xc8\x16\xa2\x99\x03\xb2\xe5\x60\xa4\xb7\xc6\x40\x31\x03\x39\x63\x70\x77\xe2\x58\x67\xff\x8e\xe9\x69\xdf\x42\x44\x9d\x20\x60\x4f\x7e\x6f\xc5\xcb\x9b\xf7\xe7\xef\xb1\x37\xb3\x33\x5b\x96\x0a\xc6\x65\xe6\xba\xdb\x0f\x08\x2d\xd8\x0f\x20\x15\x56\x9f\xbd\x65\x3c\xed\x91\x92\xa5\x5f\x7d\xc2\x88\x19\xc6\x59\x1d\x06\xd8\x8a\x0a\xbe\x75\x54\xce\xa5\x21\xb3\x7f\xd5\x0d\xe8\x5d\x54\xd1\x08\x32\xc1\x27\x41\x12\x35\x8a\x17\x97\x9c\xe9\xa5\x36\xb6\xb6\x24\x24\xaa\xc8\x42\xa6\x18\x6c\xc9\x84\x6c\xd8\x83\xcd\x7c\x58\x28\x2f\x08\xd9\x34\x24\x92\x35\xe6\xc3\x38\x18\x55\x31\x23\x62\x23\x29\x7c\xbe\xa5\xaf\x23\xec\x0b\xf0\xd9\x7a\x90\x53\xca\x53\xfc\x33\x49\x84\x4c\xdd\x7a\x99\xae\xe2\x43\x6d\x34\x91\x0d\x61\x41\xb6\x66\x28\x24\xe5\x8b\x6f\x46\x0d\x54\xe6\x8d\x58\x42\x2f\xf6\x94\x9c\xfd\xb3\x04\x42\x73\x61\x08\xfb\x62\xb5\xfc\x05\x88\xe4\x74\x8e\xbc\x15\x97\xfa\xd6\xc7\xbb\xbb\x24\x45\xd5\x23\x1f\x80\xa6\x2c\xc8\xb3\xee\x91\xb7\xcd\xc4\xeb\x9e\x59\xcb\xb5\xcd\x08\x75\x3f\xd9\xd5\x4b\x50\xa2\x94\x09\x7c\xb0\x4e\xa2\xdc\x07\x24\x2d\x7f\x8c\xd9\x15\x4d\x6f\x81\x5b\xa5\xdc\x80\x06\xfd\x60\xa5\xc4\x3d\x48\xa6\x90\x96\xc8\xa5\x46\x73\x32\x66\xb6\x85\x06\x8a\x0a\x6c\x32\x05\xa5\xbd\x70\x79\x82\x41\x3e\x75\x37\x32\xbf\x00\x44\xdf\x20\x1a\xb8\x36\x63\xe5\x14\x0b\x3c\xe3\x91\xa5\xda\x27\xbc\x58\x9d\x4d\x95\xb9\x3f\xcb\x8b\x90\x56\x03\xf2\xd6\xbc\xca\xe2\x53\xd0\x9a\x80\x2d\x00\x17\x9d\x74\xce\x0e\x47\xc6\x54\x4d\xb1\x71\xc7\xe2\x16\xb8\xaa\xff\x49\x29\x0d\xc1\xb0\xc5\xb8\x29\x36\x5c\xc7\xe6\xbc\xd8\x9b\x7b\x95\xe1\xa6\x65\x82\x83\x59\x6c\x3f\xe0\x77\xcf\x85\x89\xfd\x7f\xec\xfd\x0d\x77\xdb\x36\xd6\x2f\x8a\x7f\x15\x2c\xcf\xac\xbf\xad\x56\x52\x92\xce\xcb\xd3\xc9\xe9\x7f\xba\x5c\xdb\x69\x7d\x9a\x38\x7e\x6c\xa7\xbd\x73\x9b\x3e\x33\x10\x09\x49\x18\x93\x00\x0b\x80\x72\x34\x27\xe7\xbb\xdf\x85\xbd\x01\x10\xa4\x64\xc7\x26\x99\x48\x4e\xc5\x59\x6b\x1a\x4b\x14\x08\x02\x1b\xfb\x7d\xff\xf6\x61\x48\x58\xb7\x0b\x9f\x34\x38\x01\xee\xa4\x15\x58\x1e\xb2\x4a\x95\xa2\x8a\x98\x5a\xae\xf0\xe9\x44\x52\xfb\xf8\x68\xab\xb8\x66\x17\x09\x48\xd5\xac\xbb\xe7\x63\xff\x50\xcd\x4a\x3c\xe8\x8e\x0b\x57\xd0\xdd\xae\x6b\x35\x68\x6d\xa8\x63\x5a\x73\xe6\xe8\xd5\x71\x5c\x26\x15\xd7\x7f\xf8\x22\xb3\x31\xf9\xa9\xab\x93\xba\xe9\xa5\xb6\xdc\xbc\x72\x7d\x57\x5d\x37\x2c\xc7\xc8\x16\xde\xbe\x08\x4f\xf3\x7a\x28\x17\x45\x69\x9c\x18\xac\x2c\x4e\x91\xcc\xa9\x98\x81\x91\x29\x4b\x3b\xde\x1f\xff\x08\x33\x52\x2c\x2d\x13\xd7\xb2\xc4\x93\xec\x1f\xbd\xcb\xd6\xc1\x84\x01\xaf\xd2\x09\x2d\xfc\x9c\xe3\xd7\xd2\x4b\x61\xe8\xbb\xe7\x84\x8f\xd9\x98\xec\xfd\x31\xfa\x6a\x0f\x9f\x5e\x28\x69\x1f\xe1\xca\x33\x60\x56\x19\x37\x90\x26\xb1\x17\xdf\x3d\x26\x27\xf6\x19\x10\xc6\x0a\x0b\x18\x55\x10\x4c\xaa\xe5\x1b\x12\xc5\x66\x54\xa5\x99\x73\xb7\xdc\x44\x65\x27\x61\xc1\xd8\x3b\xae\x8d\x46\x19\x64\x3a\x70\x26\x43\xf5\xb5\xe5\x43\xf6\x64\x8d\x52\x6a\xe8\x28\x3a\xd2\x4f\xd0\x6e\x1b\x39\x2c\xe5\x11\x75\xa4\x55\xb1\xac\x27\x7f\x70\xd5\x9b\x23\x1a\xee\xe2\x56\x23\x07\x54\xe3\xf6\x7a\xce\x63\xf3\xb1\x75\x80\xd4\xae\x9f\xde\x93\x0a\x67\x1f\xd6\x00\xba\xd4\x54\xfa\x52\x60\xa2\x0e\x35\x7a\xdd\x79\x3e\x39\xbb\xba\xf8\xc7\xf9\xeb\xd3\xb3\xab\xdd\xb1\xde\x1d\xeb\xdd\xb1\xee\x70\xac\x99\x58\x74\x3e\xd2\xde\x6e\x5a\x17\xf2\x6d\xe2\x58\x46\xd5\x4b\x9f\x51\x62\xdd\x89\x58\xfc\x44\xad\x1a\x5d\x28\xa6\x41\x33\x81\x78\xd5\x9a\x08\xb8\xbb\x01\x95\xf6\xa3\x47\x9f\x59\xb7\xc1\xbc\xb8\x1e\xf3\x8d\x62\x97\xca\xba\x5d\x8b\x1b\x2c\x1e\xfd\xf3\xf4\xf8\xe4\xec\xea\xf4\xc5\xe9\xc9\xc5\x46\x13\x45\x3a\xe2\x48\xd6\x85\x72\x4b\x29\x59\x28\xb6\xe0\xb2\xd4\xd9\x32\x40\x51\xaf\x67\x02\xab\xb9\x86\x22\x05\x5f\x87\x47\xdb\x5e\xfb\xb3\x9d\xb0\xed\x57\xd8\xd6\xf3\x66\x3a\x40\x08\xf5\x45\xbe\x2f\x94\xcc\x7b\x22\xe1\x4b\xf4\xc2\xf8\x60\xf8\x3a\x7a\xda\x77\x68\x23\x35\xd1\xe3\x94\xc7\x0a\xda\xc4\x2a\xa3\x79\x61\x3a\x74\x1a\xe9\x05\x39\xb8\x1f\x90\x5d\xcc\xd5\x79\x45\x8b\x1f\xd9\xf2\x82\x75\x44\x2a\xaa\xaf\x37\xcb\x58\x62\x05\x1d\xb9\x66\x4b\x4c\xcc\x3c\xf2\x0f\xeb\x82\xa8\xb4\x95\xc0\xcb\xd7\xac\x0b\x28\x76\x9f\x88\xc9\xd7\xac\x43\xd2\xa9\xbf\x56\xb0\x83\xed\x16\x82\x9e\x66\xf7\xb4\xdb\xee\x91\x7e\xd1\x92\x3f\x02\x42\xf4\xe7\x1b\x41\xa9\x5f\x3d\xee\x82\x0f\x04\xf7\xbc\x13\x18\x93\x5f\xd6\x64\x57\x60\x22\x04\xcb\x41\x81\x36\x7d\xd0\xc1\x29\x19\x3d\x2d\x4d\xd7\x56\x85\x04\xb7\xb0\x5f\xbe\xba\x5f\x31\x56\xcc\xf1\x0f\x58\x78\xe9\x73\x0f\x9f\xa0\x43\x7f\x41\xe8\xd8\x3b\xac\xff\x09\x21\xd1\x21\xf9\x57\xf8\x30\xa3\x13\x96\xe9\x5f\xf6\xf7\xbf\xf9\xf1\xe4\x1f\x7f\xdf\xdf\xff\xf5\x5f\xf1\xb7\x20\x0a\x31\x50\x5e\xbf\x05\xb0\x20\x84\x4c\xd9\x19\x3c\x03\xfe\x74\xea\xda\x21\x06\x4f\xdc\x17\x50\xca\x3d\xc6\xac\xa5\xf0\x67\x21\xd3\xe6\x5f\xba\x13\x68\xe1\x56\x0a\x06\xd8\xa2\x0e\x95\x45\x78\xf5\x27\x1e\x2a\x5e\xd2\xf3\x51\x75\xa3\x86\x26\x39\xc9\x9c\xe5\x08\x9b\xf6\xc2\x2f\x01\xf4\x40\xf6\x98\x11\x02\x0a\xed\xad\x66\x5a\x47\xb0\xdc\x5b\x3c\xeb\xd4\x2c\x1e\xaf\x1e\x59\x5b\xd8\xc1\x9e\x17\x0c\x56\xc4\xad\x16\x1e\xe4\x20\x60\x43\xc2\x4c\xe8\xd1\x79\x78\x7e\x4a\x16\xb8\xc2\x5b\xb3\x38\x3e\xb0\xf9\xe2\xa3\xf2\xb8\x10\x3e\x6d\x16\xf4\x3e\xc7\x04\x1c\xff\xbd\x03\x57\xd0\x01\x65\x8f\x59\xc3\xe6\x00\x3f\x1c\x27\x45\x39\x74\x37\x8c\x73\x96\x4b\xb5\x0c\x7f\x86\xa2\xce\x91\x36\x52\xd1\x19\xd4\xd4\xe0\xcf\xf1\x67\xe1\x2f\xfc\x61\xed\x01\xab\xbf\x46\x53\xb8\x8a\xa2\x3a\x8e\xdc\x12\x24\xa4\xba\xb6\x90\xb7\xf9\xa5\xdf\x12\xd6\x96\x74\x85\x7a\xaa\x5f\x75\x82\x0c\x9e\x38\x54\x38\xc3\x2a\x82\x3d\xe9\x8a\x8d\x87\x55\x3e\x1c\x78\x03\xc4\xc2\x5a\x96\xad\x41\xfa\xaa\xab\x47\x6e\x96\xf2\x05\xd7\xb2\x43\xe5\x50\x18\xe8\xf6\xdc\x49\x87\x77\x82\xf9\x5b\xc1\x6d\xf6\xae\x00\x5c\xb2\x70\x5e\x1b\x6c\xff\x59\x97\xd6\x64\x78\x15\xd4\x18\xa6\xc4\x73\xf2\x3f\x07\x6f\xbf\x7c\x3f\x1a\x7c\x7b\x70\xf0\xcb\xd3\xd1\xdf\x7e\xfd\xf2\xe0\xed\x18\xfe\xf1\xc5\xe0\xdb\xc1\x7b\xff\xc7\x97\x83\xc1\xc1\xc1\x2f\x3f\xbe\xfa\xfe\xea\xfc\xe4\x57\x3e\x78\xff\x8b\x28\xf3\x6b\xfc\xeb\xfd\xc1\x2f\xec\xe4\xd7\x7b\x0e\x32\x18\x7c\xfb\xc7\xce\x53\xef\x01\x26\x18\xaf\x3e\xc1\x82\xeb\x23\xf6\x42\x7e\x1f\xb1\x43\x06\x5e\x9e\xbc\xfa\x3e\xff\x17\x9e\x6b\x46\xf9\x3c\x5e\x5c\x6f\xcd\x01\xc7\x84\xd0\x4f\xe1\xc9\xc1\x27\xd5\x6b\x6d\x82\x69\xf1\xb9\xc9\xb9\xdf\x83\x73\x27\xf4\xb6\x84\x7d\xad\x34\xd1\xa9\x92\xb9\xaf\xe8\x87\xf0\x06\xd6\x9e\xb9\xfb\xae\x59\xa7\x7e\xcb\x78\xed\x9c\x41\x3b\x67\xd0\x2d\xd7\x07\x9d\x41\x58\x8e\xb0\xbd\x9e\x20\x26\x16\x6d\x43\x18\x6b\x23\xe8\xde\xd6\x89\x71\xf3\xee\x17\x50\x1b\xfb\xa3\x5e\x35\x85\xad\x32\x69\x50\xa0\xe5\xeb\x63\x98\xe4\x10\xda\xbf\xe3\xc1\x87\x01\x02\x2e\x29\x43\xd3\xc6\xd7\x5f\x2e\xec\x14\x02\x1a\x7d\x0d\x77\x16\xb2\x8a\xb9\x98\x39\x24\x0b\x14\x25\x2e\xfa\xc4\x45\x85\xd8\x1b\x94\xc3\x0a\xe6\x9d\x6a\x2d\x13\xe8\xa7\x84\x00\x7b\x01\xce\xcf\x4d\x1b\x66\x63\xe8\x35\x44\x1b\x13\x96\x32\x91\x30\x07\x01\x5f\x6b\x80\x4b\x05\x39\x11\x0b\x0f\x83\x9f\x96\x98\x0c\x82\xec\x6f\xfd\x18\x9f\x57\x02\x82\x25\x44\x17\x04\x8b\xf2\x10\x80\xeb\x07\x0b\x9b\x42\x2a\x86\x9c\x56\x5e\xd6\x76\x3d\x32\x3b\x4b\xf1\xee\x32\x33\x44\xb6\x3a\x29\x43\x2b\xc2\xb2\x72\x3f\xd7\x85\xe4\xe7\x10\x0c\xec\x2e\x3e\x7f\x77\xa2\xb3\x27\xb1\xd9\x8f\xc8\x7c\x40\xec\xa4\x4f\x31\xd9\x47\xb0\xa4\x50\x6c\xca\xdf\xf5\x74\x4e\x0f\xa3\xca\x44\x9e\x32\x61\xf8\x94\x63\x1b\xe0\x42\xb1\x82\x09\x70\xb5\x42\x71\x86\xe5\xfd\x4e\x52\x56\xc1\xe9\x6d\x4c\xe6\x41\x85\xbb\x5f\x56\x76\xb9\x4e\xd9\xdf\xf1\x31\xb2\xe3\x63\xad\xaf\x4f\xc4\xc7\x1c\xe5\x6e\x0f\x13\x83\xcc\xf3\xee\xa9\xef\xc7\x51\x1e\x3b\x50\x71\xf7\xca\xe1\x06\x1a\x5c\xe0\x8b\x46\x62\xe6\x1a\x96\xaf\x29\x92\xb1\x05\xcb\x9c\xd2\x44\x72\x2a\xe8\x0c\x21\xfc\x8d\x0c\xa0\x3f\x52\x85\x36\x4c\x4d\x44\x1f\x50\xe2\x7d\x65\x17\x7c\xa9\x64\x96\x31\xa5\x49\xc6\xaf\x19\x39\x66\x45\x26\x97\xb9\x4b\x7c\x4d\xc9\xa5\xa1\xc6\x92\xf4\x25\x33\xed\x62\xbe\xdd\xd0\x40\x7c\x31\x7b\x4f\x98\xe9\x58\x1d\x0f\xb5\xe5\xa4\x70\x85\x93\xaf\x05\x70\x8c\x43\xe8\x08\x33\x24\x67\x6c\xc1\xd4\x90\x9c\x4e\xcf\xa4\x39\x47\xd5\xbb\x9e\x6d\x87\x37\x12\x3e\x25\xcf\xad\x51\xa7\x0d\x31\xd8\x95\x23\xaa\x73\x97\xaa\x36\x40\x85\xf7\xd6\x47\x59\xde\x6a\xc9\x39\x8c\x14\x0a\xce\x5b\x85\x31\x3a\x6d\x53\x68\x7b\xd4\x79\x83\x0e\xb1\x8c\xb4\x82\x00\x8e\xe8\x1b\xe1\x19\x3c\x82\x19\x98\x80\x5c\x10\xc5\x74\x21\x85\x66\x75\x78\xc6\x30\x23\x34\x75\xfb\xc5\x7e\x6d\x2d\x39\xbb\xca\xcc\x42\x6a\x03\x95\xb3\xfd\x34\xd3\x3a\xf7\xc3\x41\x21\x32\xcd\x32\x96\xd6\xba\xa9\x61\x17\x20\x5a\x77\x0f\x24\xd0\xd5\x21\x0d\x7d\x41\xb0\x3e\xb9\x56\xda\x5c\xbb\x3f\x74\xe6\xf3\xbd\x6f\x7c\x5b\xe6\xdb\x0a\x9a\xab\x83\x09\x42\x24\x22\x80\x15\xa0\x68\x80\x0f\xd7\x51\x03\x9d\xb9\x94\xd7\x24\x91\x79\x91\xc1\xd1\xe9\x70\xb2\xaa\xfe\x5d\x81\x94\x46\x76\x74\xfd\x24\x6a\xed\x05\x1f\x74\xeb\xec\xd5\x49\x0b\xeb\x43\x07\x63\xef\x58\xd2\x5b\xef\xcf\x93\x77\x2c\x89\x9a\xd7\x02\x94\x55\xe2\x81\x21\xec\x89\xed\xde\x93\xbc\x73\xbc\xa1\x2f\x1f\x7f\x87\x2a\xba\xf8\x6a\xa0\xff\xc1\x98\x1e\x25\xdd\x3d\x02\x1a\x4e\x80\x21\x84\x95\x75\x31\x7a\x46\x20\x46\x3c\x7a\x2b\x90\x81\x21\x8b\xda\x8f\x05\xad\xa5\xa4\x34\xe4\x60\xff\xc9\xfe\x60\xc5\xf9\xd8\x80\xda\xbe\x8a\x7e\xc9\x01\x22\xb2\x00\xbc\x45\x96\xec\xa7\x43\xc2\x8d\x4f\xb3\xc6\xbe\x47\x30\x2b\x57\xee\x37\x24\x5a\x12\xa3\x68\xca\x9d\x1a\x03\x9f\xda\x9b\x8c\x2a\x1d\x97\x3f\xd8\x7f\xbf\xef\x5a\x22\xdd\x48\xb1\x6f\x60\xfa\x63\x72\x85\x70\x33\x61\xa0\xa5\x2c\xa1\xd3\x27\x2e\x41\x91\xf1\x84\x9b\x6c\x09\x1c\x8b\xc8\x12\xdb\x82\x59\x79\xe1\xca\x0c\x4f\xde\x71\xe3\x9b\x92\xc8\x29\x79\x8a\x5d\xc9\x18\x75\xee\xcf\x8c\x2f\xd8\x93\x39\xa3\x99\x99\x63\x86\x88\x90\x62\x84\x8d\x25\x2d\x2b\x71\xdf\x74\x0d\x96\x74\xf3\x25\xc6\x57\x07\xbf\xe2\xea\x84\x3a\x9a\x0d\x96\x89\x7e\xdf\xbe\xdb\x35\x59\x41\xfd\xba\xba\x3a\xff\xbe\xd6\xef\x1a\xb8\xb8\x31\x85\xcf\xdb\x89\x9a\xc2\x6f\x01\xef\xe8\x27\x52\xd9\xa9\xf1\x35\xe9\x91\x85\x75\x6d\x80\x4d\xd6\xa3\xb8\xdd\xbf\xf3\x35\xf9\x87\x2c\x01\x03\x84\x4e\xb2\x65\x00\x60\xd0\xcc\x90\x3d\x3b\xd4\x9e\x65\x4f\x96\x1a\x7e\x60\x34\x45\x7c\x0c\x6d\x18\x6d\xa5\xba\xc5\x57\x6f\x11\xb4\x68\x6e\xfd\xca\x81\x52\x1b\x99\x93\xb9\x7b\xed\x7a\xdd\xa5\x3b\x19\x63\x38\x3d\xbe\xa8\x49\xb1\x02\x39\x9c\xfb\xcd\x67\xc7\xbf\x56\xf8\x06\xae\x7b\xad\xf9\x41\x12\x2f\x5b\xdc\x5b\x87\x0b\x5c\x2c\x84\x9b\xe9\x89\x97\xf6\x90\xf9\x40\x7a\xcc\x7e\x20\xdd\xaa\x38\x9b\x03\x41\x44\xaf\x7b\xa2\x57\x6f\x09\x15\xa4\xb7\xa4\x01\xb2\xce\xc3\xea\x68\x06\xbd\x2f\x3d\x2d\x62\xaf\xa1\x7a\xd2\xbd\x4e\x34\xbe\xee\x5e\x80\x7e\x36\x9f\xf4\xb9\x02\x45\x0f\x79\xdd\xab\x59\xdd\x88\x1e\x05\x75\x97\xc8\x5c\x81\x4d\x68\xa6\x16\x6d\x2b\xb9\xab\xab\xbf\x57\x97\xed\x2d\x7e\x7f\xad\x29\x92\x56\x44\x84\x6e\xda\x1e\x1d\x75\x75\x41\xa2\xb4\x04\xd7\x7c\xdb\xfb\x72\xbd\x38\xa2\x62\xc6\xc8\x33\xfb\xcb\xbf\xfe\xe5\x2f\x7f\xfa\xcb\x18\x87\x0f\x29\x0a\x82\x9c\x1e\x9e\x1d\xfe\xf3\xf2\xa7\x23\xa8\x8c\xed\xba\xaa\x3d\xe5\x5f\xf6\x9d\x7d\xd9\x6b\xee\xe5\x47\xcd\xbc\x84\x7a\x8f\xce\x5c\xa4\xee\xf8\x87\x21\x63\x98\x50\xa7\xfb\x45\xf0\x7a\x56\xd7\xac\x3b\x52\xed\x51\xdb\x8a\x33\x66\x92\xe2\x52\x26\xd7\x3d\xda\x35\xc7\xac\x50\x2c\x41\x3f\xd9\xd5\xd1\x39\x8e\x6e\xed\xcb\xb3\xd7\x57\x55\x9d\x01\x24\xe3\x54\x18\x7a\x3f\x38\x4f\x9a\xb5\x49\xaf\x59\x61\x82\xe9\x3e\xa1\xc9\xf5\x0d\x55\x29\x78\xb6\xa8\xe1\x13\x9e\x71\x83\x90\x7f\x8a\xb9\xf6\x57\x98\xed\x87\xd8\x66\xbe\xbd\x30\xf2\x72\x74\x20\x78\x77\x28\xb8\xac\x30\x89\x66\x4a\x79\x06\x1e\x54\xd7\xd9\x17\xd3\x81\x92\x22\xb8\xf4\x62\x9f\xf6\xce\xf8\xf2\xd7\xd6\x1a\x5f\x51\xe7\xe1\x87\xda\x61\x5d\x93\x12\xb7\x58\xd4\x39\x11\xa7\x6a\x4d\xc0\x77\xa2\xae\x87\xf1\xb6\x57\xd4\x15\x8a\x5d\x1a\xd9\xaa\x93\x00\x59\x8d\x92\xe0\x60\xb7\xc4\x48\x26\x6c\x2a\x2d\x13\xbe\x35\xe8\x91\x96\x70\x08\xa9\x80\xca\x40\xef\xd5\x92\xb5\xc0\x06\xa6\x63\xfa\xb6\xdb\x99\xc3\x4b\x7d\xa2\x63\x90\x54\xdf\x43\x79\x68\xdf\x8e\xe5\x30\xbb\x61\x55\xe2\xe0\x3a\x38\xc3\x87\xcc\x24\xe8\xb9\x8d\x18\x39\x00\x86\xba\xe9\x37\xc3\x28\x89\xa2\x7a\x8e\xdd\x8d\xd9\x3b\xee\xdb\xdc\x9f\xcb\xb4\xd9\x93\x7c\xa6\x68\xc2\x48\xc1\x14\x97\x56\x18\x95\xc2\xa4\xf2\x46\x90\x09\x9b\x71\xa1\xfd\x52\x00\x06\xbb\x5b\x33\x88\xc7\x70\x1d\x20\xe1\xc6\xe4\xa2\x86\x74\xe2\x6a\x90\x12\x59\x1d\x4d\x37\xe7\x66\x24\x09\x24\x16\xac\x13\xb6\xfc\x09\x2b\x1c\x77\x41\xfa\xd0\x94\x0f\x4a\x01\x4f\x4e\x59\x46\x97\x98\x6a\x0a\x9d\xcf\xf9\x7f\x98\xd2\x83\x1e\x22\x4e\xd8\xc7\xcb\x7f\x77\xeb\x3c\xb8\x26\x8a\xd1\x64\xde\x2d\xf8\xbb\x0b\x51\xdd\xf3\xda\x85\xa8\xba\x0c\xb2\x0b\x51\xed\x42\x54\x1f\xb8\x76\x21\xaa\x5d\x88\xaa\x71\x6d\xad\x95\xb4\x0b\x51\xb5\xbe\x76\x21\xaa\xbb\xaf\x5d\x88\xea\x1e\xd7\x2e\x44\x75\xcf\x6b\x17\xa2\xda\x85\xa8\x76\x21\xaa\x5d\x88\xea\x77\xe4\xb7\xf3\xd7\x2e\x44\xb5\x32\xc8\x2e\x44\xb5\x0b\x51\xdd\xfb\xda\x5a\xe3\x6b\x17\xa2\xc2\x6b\x17\xa2\xaa\x5f\xbf\x2f\x51\xe7\x03\x3c\xe7\xd6\xd4\xeb\x5e\xd3\x76\x0e\x41\x05\x9e\xb8\x38\x91\x9c\xd6\xea\xa0\xf0\x51\xe3\xaa\x41\x45\x84\x09\xe2\x4b\x71\x5c\x44\xa8\x8a\x33\xad\xad\x97\xea\xd8\x3e\xae\x90\x69\x15\xa8\x88\x22\x14\x68\xf0\xb6\xaf\x59\xdb\x58\x35\x56\x97\xb0\xc4\xa7\x09\x49\x6c\x49\xfc\xa6\x87\x30\xc4\x2e\x04\xf1\xd9\x85\x20\xfa\x71\xdf\xf5\xe0\xba\xeb\x2c\x2a\x5c\x64\xfe\x6a\xae\x98\x9e\xcb\xac\x35\xa1\xd7\x88\xfc\x15\x17\x3c\x2f\x73\x68\x10\x6b\xe9\x99\x2f\x42\x0a\x40\xe8\x82\xed\x38\x36\x7a\x11\xa3\x4e\xb2\xbe\x83\x2c\xd4\x6f\xce\xe9\x02\xba\xa2\x96\x49\xc2\x58\x1a\xf5\xb6\x07\x0d\xeb\x4f\xe3\xf0\xa4\xd0\x37\xe3\x59\x37\x7e\xd3\x4d\x88\x23\x16\x29\x8c\xf2\xa7\xaf\x5a\x8d\x31\x53\x45\x3f\x7c\xf9\xfb\x8b\xf3\xa3\x88\x2f\x53\xe1\xd9\x32\x17\x0b\x99\xc1\xaa\x52\xbc\xc9\x2a\x6b\x63\xac\xdf\xc7\x76\xeb\x34\x2b\xe6\x34\xb2\x6e\x9c\x61\xa0\x09\x13\x74\x02\xad\x69\xed\xef\x82\x4c\x3e\x47\xc9\xcb\xa8\x29\x15\x23\x33\x6a\x36\xc9\xf2\xbb\x1b\x31\x9d\x0c\x98\x3e\x24\x4e\x57\x1d\xbd\xee\x85\xb3\x9a\x78\xdd\x0f\x35\x03\xca\x40\x00\xfd\x7b\x6b\xe2\x9d\x79\x65\x77\xed\xb8\xfb\xe1\x22\x80\x70\x03\x2f\xde\xdb\x02\xef\x5d\xba\xce\x51\x4e\xa0\xc7\x66\x90\x6f\x2a\x65\x24\x29\x32\x5a\xb5\x85\x82\x1d\xf8\x01\xa4\xd0\xd1\x9c\x25\xd7\x17\x2e\x16\x7b\xa0\x19\x0b\xda\xe9\x8c\x9b\x79\x39\x19\x27\x32\x7f\x62\x99\x02\xfe\xdf\x24\x93\x93\x27\x39\xd5\x86\x29\xab\xb0\x3a\x21\x37\x4a\xec\x28\x5c\xcc\xc6\x79\x3a\x18\x93\xb7\x02\xeb\xdb\xab\x36\x94\x11\xba\x83\x7d\xbe\x47\xda\x98\x30\xcb\x5f\x25\x78\x22\x22\x04\x3b\x3b\xbd\x71\x17\x9c\xe4\xce\x42\xa9\x63\x1c\xfc\xd3\xc7\xc0\x77\x9c\x8b\xf4\xe0\x72\x79\x6c\xb1\xee\xde\x72\x3e\x7a\x88\x71\x6f\x51\x7c\x7b\x6b\x94\xe3\x6d\x89\x69\x6f\x21\xd8\x74\x0f\x21\xd8\x3e\x62\xd8\xfd\xc5\xaf\x3f\x02\x26\xf3\xc7\x89\x5b\xf7\xe8\xdc\xeb\x29\x5e\xfd\x29\x62\xd5\xbd\xbc\x75\xd7\x18\xf5\xa7\x8b\x4f\xf7\xf3\xba\x7d\x1a\x02\x8f\x35\x26\xdd\x83\x93\xbe\x4f\x07\x7d\x6f\xce\xf9\x8f\x16\x83\xee\x1e\x7f\xde\x82\xd8\x73\xe7\x45\xe6\x82\x1b\x4e\xb3\x63\x96\xd1\xe5\x25\x4b\xa4\x48\x5b\x4b\x98\x06\x48\x67\x38\x3f\x1a\x87\x75\x9e\xaa\x7a\xa9\xc5\x9c\x3a\x2c\x72\x6b\x51\x61\x69\x89\x8f\x66\x38\x85\x02\xe2\xca\x38\xcb\xad\x8c\x4f\x90\xad\x71\x89\x61\xdd\x49\x9f\x9b\xf8\x83\xbc\x21\x72\x6a\x98\x20\x07\x5c\xf8\x7d\x1c\x44\x66\x60\xe5\x9f\x0c\x64\x6d\xbf\x7d\xf6\xd4\xdf\xfc\xf9\x39\x1e\xc1\xc5\xaa\xf5\xc7\xf7\x03\xbb\x07\x7d\xd8\x11\xec\x6e\x9c\x96\x59\xdd\x19\x8c\x0e\xe2\x3a\xbf\x79\x56\xa1\x29\x3f\x83\x71\xc3\x69\xa3\x22\x25\xae\x16\xed\xf3\xdb\xb4\xce\x99\x35\x75\xd5\x2f\x64\xd2\x7c\xc8\x6f\x7c\x75\x74\x8e\x6e\xe3\x9d\xbb\x64\x5b\xdc\x25\x1b\xca\x4e\xd9\x42\x45\xf7\x91\x66\xa4\xec\x14\xdd\x07\x5c\x51\x75\xea\xf7\x8a\x26\xec\xbc\x77\x1d\xc1\x1f\x27\x92\x96\x8a\x3a\x06\x18\x54\x3e\x7f\x78\x04\x63\x29\x9e\xa6\x50\xd1\x0b\xb5\xb2\xd3\x32\xcb\x96\xa4\x2c\xa4\xa8\xd7\x3f\x63\xb4\xbd\x59\x4e\x0b\x2e\xf9\x35\x4f\xa9\x14\xcb\x42\x49\x27\x33\x55\x29\x84\xe5\xc1\x55\x4b\x34\x50\x24\x01\xa8\x99\xd6\x8a\x76\x35\x9f\xd9\xe9\x5b\xf9\x07\xf5\xbc\x55\x0a\x62\x6d\x40\xfb\xeb\xa9\x54\x09\x9f\x64\x4b\x32\xa7\x59\xe8\x7f\x43\xc9\x35\xcf\x32\x37\xcc\x98\x5c\x32\x83\x21\x05\x94\x9d\x99\x14\x33\x98\x1c\x15\xbe\xef\x22\x4b\xec\x6f\x93\x8c\x51\x51\x16\xf8\x3c\x2b\x89\x97\xb2\x54\xfe\x79\xe3\x10\x98\x08\x12\x58\xf0\x6c\x18\x75\x77\xbb\x73\x63\x43\xf6\x4f\xa9\xad\x02\xf0\xda\x03\x53\x0f\xe3\x31\x3d\x76\xb8\x8e\x7a\xfb\x14\x4a\x2e\x78\x8a\xd1\x0d\xbf\x6c\xd0\x47\x1a\xfb\xf7\x84\xf3\x2c\xa4\x18\x09\x36\xa3\xa0\xa8\xb8\x53\x84\x7b\x86\xe3\x60\x0e\x81\x48\xa1\xa3\x8f\xd5\xf0\x65\x51\x2b\xa8\x5f\x70\xec\x45\x1c\xad\x1c\x39\x10\x92\x48\xc8\x48\x2d\x05\x37\xd8\xdf\x7e\x5e\x1a\x92\xca\x1b\x31\x88\xe2\xae\x64\xc2\xcc\xdd\x51\x57\x08\xb4\x5e\xad\x5d\xa0\x7a\xf8\x75\x9d\x9e\x83\xef\x7b\xf7\xf2\x72\xed\x5c\x9f\x53\x52\x0a\xcd\x3a\x8a\xf7\xde\x94\xa3\xbf\xfe\xb9\x1d\x8f\xe0\x39\x93\xa5\xf9\x24\xd6\xdf\xcd\x9c\x27\xf3\x58\x99\xe5\x39\xd3\x44\x96\x0d\xb3\xf8\x99\xfb\xd9\xfa\x1d\xda\x99\x80\xeb\xae\xb6\x8e\xdd\x35\xde\xaf\x26\x20\x42\xd5\xf8\x1a\x32\xc5\x8f\xcf\x2e\xff\xf9\xf2\xf0\xbb\x93\x97\x63\x72\x42\x93\x79\x8c\x8a\x21\x08\x05\xa6\x01\x8c\x62\x4e\x17\x8c\x50\x52\x0a\xfe\x5b\xe9\x02\xbe\x07\xe1\xb7\x83\x5e\xd1\xda\x5b\x4a\x5f\x68\xce\xdf\x5b\x37\x38\x6c\xf5\x8f\x99\x59\x52\x33\xe8\xdf\xd2\x54\x9f\x4e\xec\x57\x68\x1c\x80\xaa\x05\xa9\xf3\x33\xbe\x70\x6c\xd8\xc1\xdf\xd3\x34\xe4\x8a\x59\x3a\xb7\x64\x61\x45\x15\x9d\x40\x8e\xd7\x9c\x11\xc1\x8c\x25\xeb\xe0\x63\x92\x42\xd7\xe0\x49\x4a\xcd\xf4\x90\x4c\x4a\xc8\x4a\x2b\x14\xcf\xa9\xe2\xd9\x32\x1e\xcc\xca\xaa\xb3\x10\xf2\x5e\x36\xa7\x74\xfc\xfa\xe4\x12\xaa\x04\x0a\x85\xc0\x25\x90\x56\x06\xdf\xc3\x6b\x4d\x98\xfd\x85\xeb\x22\x3c\x26\x87\x62\x89\x5f\xe2\x01\xe7\x9a\x64\x5c\x1b\x06\x22\xd8\xe9\x90\x3e\x98\xbe\xf7\x74\x0c\xff\xdb\xb3\x6f\xa9\xac\x92\x19\xb2\xe5\x92\x95\xf4\x55\x54\x43\xf9\x24\x8b\x56\xd3\xbd\xfb\x67\xd5\x0f\xae\x4a\x12\xb2\x8b\x18\xf5\x83\xa3\x61\xab\x61\x79\xb1\x3f\x20\x17\xb3\x2c\xa6\xaa\x76\x6c\xbf\xab\x6d\xd9\xd5\xb2\x1c\x55\x6f\x70\xde\xd6\xc0\xec\xa5\x2f\x5d\x35\x87\x9e\xba\x39\x55\xd2\xcf\x9b\x53\x8e\x23\xc8\xb8\x41\xef\xe9\xb9\x3f\x01\x4e\xbb\xc9\x1b\x5d\x5d\x8b\x2a\x27\x69\x48\x9e\x92\x6f\xc8\x3b\xf2\x0d\x98\x57\x7f\xed\xda\xfb\xaa\xab\xe1\xd3\x47\x8a\x91\xb5\xea\x4f\xcf\x7b\x5a\xf1\x9f\x2d\x77\xb2\x23\xda\x55\x35\x92\x4c\xb8\x53\xe7\xd9\x3b\xc3\x94\xe5\xa3\x6e\x27\x36\xda\x35\xcc\x4e\xf0\x13\x92\x19\x86\x1b\x4e\xa7\xf5\xb4\xa6\x87\x11\x9a\xfd\xf9\x0f\x52\x9b\x33\xc7\x85\xea\x2d\x70\xaa\xd1\x72\x6a\x92\x79\x9d\x8d\x59\x45\x4d\x9b\xea\x80\x69\x92\x4a\xc8\xb2\xc2\x04\xe6\x39\xef\x90\x3c\xb1\x3d\x64\xdc\x2d\x9e\x5e\xdb\xcf\xbb\x76\xaa\xe1\x40\x01\xcb\xc7\x29\x56\x11\x36\x56\x21\x53\xa7\x93\xd9\x69\xa5\x91\xcc\xb8\x43\x29\x73\xbe\x9a\xe0\x65\x06\x5a\xb2\xe7\x29\xa1\x02\x4b\x48\xa6\x4c\x29\xcc\x39\x9f\x2c\x7d\xb2\x5e\xe7\xcd\xeb\x74\x92\x0a\x25\x8d\x4c\x64\x87\xc6\x66\xf5\x18\xb7\x1b\x0e\x16\x01\xf3\x7c\xbd\x9b\xfc\xcd\xf1\xf9\x90\x5c\x1d\x9d\x43\xbf\xa7\xcb\xa3\xab\xf3\xba\xa5\xb2\x77\x75\x74\xbe\xb7\xd1\xa5\x20\x5e\xb3\x02\xc7\x74\x8b\x41\x6a\x8e\x27\xab\xb6\x8d\x72\x5a\x8c\xae\xd9\xb2\xa5\x4c\xed\x43\xae\x8f\xc2\x0e\xf7\xf2\x42\xb8\xcc\x39\x2d\x1e\x3c\x9a\x62\x34\xe5\x9f\xa8\x8e\xcb\xa7\xc1\x86\x67\xae\x2f\xe8\xca\xe5\x82\xa5\xa8\x0e\xfb\x5f\x30\x91\x16\x92\x5b\x7d\x71\x57\xe5\xf5\xf0\x5f\xef\xaa\xbc\xee\x7d\xed\xaa\xbc\x76\x55\x5e\xab\xd7\xd6\x24\xb2\xee\xaa\xbc\x3e\xaf\xb8\xfd\xae\xca\xeb\x77\x1f\xfc\xdf\x55\x79\xad\xbf\x76\x55\x5e\xbb\x2a\xaf\xfb\x5d\xbb\x2a\xaf\x87\x5f\x5b\x97\xb6\xb4\xab\xf2\x7a\xd0\xb5\xab\xf2\x5a\xbd\x76\x55\x5e\xb7\x5c\xbb\x2a\xaf\x5b\xae\x5d\x95\xd7\xae\xca\x6b\x57\xe5\xb5\x4b\x7e\xfd\xe0\x58\xdb\x99\xfc\x4a\x76\x55\x5e\xee\xda\x55\x79\x7d\x16\x29\x7e\x64\x57\xe5\x75\xaf\x6b\x57\xe5\xb5\xab\xf2\x6a\x73\xed\xaa\xbc\x3e\x17\x77\xc9\xae\xca\x6b\x57\xe5\xf5\xfb\x51\x74\x77\x55\x5e\xbb\x2a\xaf\x5d\x95\xd7\xae\xca\xeb\xce\x59\xec\xaa\xbc\x3e\x07\x13\xd0\xf7\x02\xee\x5e\xb5\xb4\x7f\x24\xf3\xa2\x34\x8c\x5c\xf8\x21\x83\x16\x89\x8c\x81\xeb\x58\x23\xe8\x9e\x44\x98\x48\x31\xe5\x33\xc7\xd9\x9f\x60\x03\xde\x51\x78\x9f\x51\xd4\xf4\xf6\x11\x66\x10\x66\x3c\xe7\xed\x4a\xc9\xc8\xca\xc6\xbc\x84\xb1\xa2\xb8\x8c\x3d\x49\x39\x7d\x07\x47\x84\xe6\xb2\xc4\xa6\xc5\x89\xdb\xbf\xb0\x84\x18\xbd\xda\xba\x9d\x21\xfd\x98\x38\x55\x4d\xdc\x79\x1f\x69\x25\xd4\x18\xa6\xc4\x73\xf2\x3f\x07\x6f\xbf\x7c\x3f\x1a\x7c\x7b\x70\xf0\xcb\xd3\xd1\xdf\x7e\xfd\xf2\xe0\xed\x18\xfe\xf1\xc5\xe0\xdb\xc1\x7b\xff\xc7\x97\x83\xc1\xc1\xc1\x2f\x3f\xbe\xfa\xfe\xea\xfc\xe4\x57\x3e\x78\xff\x8b\x28\xf3\x6b\xfc\xeb\xfd\xc1\x2f\xec\xe4\xd7\x7b\x0e\x32\x18\x7c\xfb\xc7\xd6\x53\xee\xac\x12\xf7\xa7\x10\xf7\xa4\x0e\x7f\x14\x65\xd8\x05\x74\x7b\x3a\x8b\x2e\x19\x65\xe5\x34\x3a\x81\x75\xd7\x69\xf4\xdc\x14\xd4\xbc\x30\x0e\xd7\x44\xe6\xdc\x58\xe5\xd0\xea\x83\x34\x4e\x68\xe5\xa6\x66\x94\x3a\x3e\x00\x29\xdd\xd4\x60\x8b\xf5\x90\x0c\x1a\x25\xb1\x48\xaf\xf9\xb9\x1e\xf4\x3c\x2f\x32\x68\x6d\x0e\xe7\x79\xe4\x73\x59\x40\xb8\xee\x78\xc3\x87\xaf\x1d\x6f\xf8\x1c\x79\x83\x66\x49\xa9\xb8\x59\x1e\x49\x61\xd8\xbb\x56\x1e\x96\x3a\x6b\xb8\xac\x0f\xe8\x72\xc6\x5c\x1d\xb7\xfb\x8e\xc8\x02\x33\xbf\x1b\x05\xf5\x73\x59\x66\x29\x94\x73\x94\x02\x0c\x4c\xac\xd3\x63\x06\xad\x3f\xb0\x7b\x20\x99\xbb\xf9\x10\x6f\xcf\xa1\x99\xf9\x5b\xc9\x17\x34\xb3\xd6\x6e\xf5\x8b\x73\xb0\x60\xe2\x1f\xdd\xf7\xcc\x1b\xaa\xaf\xab\x03\xcf\x46\x56\x87\x0e\x73\x7e\xe2\x5f\x09\x3e\x62\xef\xcc\x63\xd4\xd2\x40\x41\x3a\x57\x7c\xc1\x33\x36\x63\x27\x3a\xa1\x19\xf0\xb5\x7e\x64\xc5\xe1\x2d\xa3\xc3\xc6\x2b\x99\x69\x72\x33\x67\x96\x57\x13\xea\x5d\x00\x50\x63\x37\xa3\x5c\x90\xdc\x6e\x51\xe1\x7f\xac\xd1\x97\x60\xd9\x7f\x41\x95\xdd\xe0\xe0\x33\x00\x13\x79\x22\x65\xe6\x6a\x1e\xb2\x65\x35\xbe\xab\xfe\x11\xf2\x9f\x82\xdd\xfc\xd3\x8e\xa6\xc9\x34\xa3\xb3\xe0\x2a\xd0\xcc\xac\x78\xfb\xaa\xa1\x6f\x7d\x01\x28\x28\x28\x19\xa1\xd9\x0d\x5d\xea\xca\x71\x12\x21\x3f\xe8\xe7\xe4\xd9\x00\xc8\x99\x6a\x12\xc6\x48\xc9\x57\x03\x08\xff\x1d\x1d\x9e\xff\xf3\xf2\x1f\x97\xff\x3c\x3c\x7e\x75\x7a\x46\xce\xa4\x61\x28\xd4\xa2\x06\x81\x49\xb0\x30\xec\x2c\xe1\x19\x60\xa5\x4b\x3d\x06\xdf\x25\xd7\xe4\x86\x8b\x54\xde\xe8\xd6\x3e\x5a\x24\x3f\xbb\x78\x8c\x8a\x56\x63\x24\xb4\xa0\xd0\xf7\xb0\x83\x84\x59\xc9\x30\x89\x07\x05\x19\x9e\xa6\x4f\x52\x25\x0b\x5c\x04\xef\xe4\xaa\x44\x6d\xdd\x8c\x8e\x73\x58\x61\x7f\xa7\xf5\x01\x67\x8a\x0a\x53\x79\x7b\xaa\x3d\x73\x0d\x17\xc7\x9d\xb7\xe3\x71\xd7\x34\xd1\xb4\xbf\x7a\xa6\xc3\x34\x65\x69\x6d\xf9\x3f\xbb\xcc\xc1\x23\xff\x72\xcb\x0a\xa7\x82\x9c\xbf\xbe\x3c\xfd\x7f\x1a\x74\xbc\x2c\xba\x25\x4a\xf5\x53\x1b\xab\x64\xd1\xdb\xee\x5e\xb8\xda\xcb\xdd\xfe\x6e\xc5\xfe\x06\x69\xd9\x4f\x78\xfe\xa2\x14\x75\x28\xa3\x6a\x7c\x92\xcb\x94\x8d\xc9\x79\x88\x13\xd4\xbf\x8d\x20\x0e\xa8\x62\xc4\xde\x22\x0c\xa7\x59\xb6\x8c\x55\x34\x23\xb1\x0e\xb1\x86\xce\x10\x33\xf2\x29\xcd\xf4\xa6\xb9\x71\x17\xd9\x68\xf5\x88\x57\xd6\x1e\xee\x65\x3b\xc2\x68\x24\x65\x42\x1a\xa7\x58\xdb\x59\x02\xe2\x85\x92\x09\x41\xe3\x3b\x4a\xc6\xaa\xc9\x37\x8d\xb1\x0a\x2f\x1a\xb9\xf6\x8b\x7d\x1e\x46\x46\x47\x75\xa9\x59\x53\x41\xf7\xbd\x88\x83\x39\x6e\x47\x57\x8c\xa6\x52\x64\x4b\xc8\xbc\xc4\x5c\x8a\x9c\xea\x6b\x96\xe2\x07\x4e\x35\x0b\x91\x0a\x3b\x62\x78\xd4\x95\x9d\xb7\x0f\x4b\x80\x4a\x86\x19\x1e\x10\xce\x60\xe9\x86\x77\xbd\xc3\x21\xb4\x8b\xf2\x5a\x64\xcb\x0b\x29\xcd\x8b\x50\x48\xdb\x0b\x05\xfc\xec\xb4\xe5\xba\x2b\x1a\xd4\x49\x0a\xcf\x1d\xc1\x6e\xc0\xa1\x8a\x6b\x78\x8f\xab\x1d\x7f\xec\x47\x4a\x95\xe2\x50\x7f\xaf\x64\xd9\x5a\x88\xad\x28\x9b\xdf\x9f\x1e\x03\x2b\x2a\x5d\xa8\x52\x18\xb5\x04\xf0\x80\x55\xdc\xb7\x60\x18\xbc\x71\xc1\xd6\xf8\x4c\x54\x71\x31\xf2\x8a\x2e\x09\xcd\xb4\xf4\x6b\xc9\xc5\x5a\x2b\xd4\x99\xb8\xf6\xeb\x89\x34\xf3\x15\xdb\xd6\x1e\xa8\xd5\xdf\x0d\xa3\xc8\x65\x05\x44\xc7\xc5\xca\xcf\x0d\xbd\x66\x9a\x14\x8a\x25\x2c\x65\x22\xd9\xf4\xb6\x6f\x3a\xe0\x07\xa4\x73\x26\x85\x3d\x98\xbd\x10\xcf\x69\x88\xf4\xba\x25\x8d\x49\x05\x62\xc6\xce\xfa\xa3\x10\x39\x86\x63\x59\x6a\xa6\x30\xcc\xad\x4a\x86\x3b\xf9\x63\x39\x61\x99\x5d\x79\x6b\x92\xba\x6e\xf1\xe8\xce\xe0\x39\x9d\x31\x42\x4d\xa0\x34\x23\x09\x13\xda\x72\x4c\x74\x80\x1a\x92\x4a\x56\xd5\xdf\x53\x4d\xde\x9c\x1e\x93\xa7\xe4\xc0\x3e\x6b\x00\xf4\x03\xcd\xe4\x8d\xc4\x24\xb7\xa6\x8d\x3a\xf5\x43\xc0\x94\x80\x78\x89\x54\xc8\x24\x86\x44\x48\xa2\xcb\x64\x1e\x77\xb0\xf7\x66\xb3\x4b\x84\x84\xd0\xca\x76\xd2\xfa\x66\x39\xd4\x1b\xcd\x54\x6f\x0c\xea\x4d\x0b\x06\x15\xab\x51\x96\xe6\xea\xab\x87\x84\x95\x33\x43\x53\x6a\xa8\x63\x5c\xfe\x86\xad\xdd\xd2\xdf\x37\xfb\xd2\xec\x25\x17\xe5\x3b\x4c\x3c\xea\xcf\xd5\x72\x79\x02\xc3\x92\xc4\xaf\x3a\xec\x3a\x2d\x8a\x8c\x23\xde\x46\x23\x11\xee\xb4\x46\x2b\xc3\x5b\xd4\x44\xe0\x13\x34\xcb\xa4\xe5\x8f\x56\x39\xa1\x22\x95\xf9\xca\xc3\xac\x12\xc9\x6a\x88\xa9\x63\xb2\xa3\xbe\xfa\xb5\x25\x4e\xa1\x8c\x2d\x58\x07\x74\xb1\x26\x42\xac\x1d\xcd\x2e\x8e\xa7\x08\x18\x9e\x64\x74\xc2\x32\x5c\x63\xa4\x40\xbd\x4a\x81\x9b\xce\x46\x55\x32\xeb\xaf\x7c\xe6\x42\x66\x0c\xd3\xbb\xfc\x42\xd8\xe1\x1f\xc5\x3a\xc0\x20\x7d\xad\x03\x58\x83\xb5\x75\x00\xbb\xf6\x31\xac\x43\xd9\x41\xd4\x93\xe6\x3a\x58\xbd\xa1\xbe\x0e\x20\xbc\xb7\x7d\x1d\x34\x4b\x12\x99\x17\xe7\x4a\x5a\xb3\xb3\x37\xd9\xe4\x86\xad\x62\x86\xe8\xd8\x58\x93\x8c\x05\xb2\xa0\x7e\x33\x55\x51\x62\x27\x35\x28\x24\x7c\x76\xe7\xff\x2f\x92\x59\xc0\x7a\x9a\x82\xcc\x8f\x52\x0b\x2f\xda\x5f\xba\x2f\x1e\xb3\x38\xe8\xa3\x36\xa2\x83\xb3\xb3\x17\x69\x24\x13\x9a\x01\x7a\x6c\x37\x92\x23\x4d\xb2\x6b\x0e\x1c\xa5\xf3\x42\x8c\x12\x3e\xf3\x09\x24\x00\x24\x0a\x9f\x38\x17\xa6\x90\x29\x8b\x62\xd9\x98\x87\x7c\x85\x69\x9f\x70\x9f\xcf\x24\xb6\x7a\x85\x0f\x2b\xa7\xb5\x5f\x1b\xe9\x30\xd0\x5e\x05\x4c\x5a\x3b\x41\x26\x52\x2e\x66\xe0\x57\x1b\x12\xc5\x32\xcc\x41\x76\x4c\xe0\x1a\x2d\xc8\x7d\x38\x12\x7e\x50\x7f\x1e\xfc\xa3\x41\x17\xe3\x52\xb8\x91\xc1\x53\xe4\x35\xac\x29\xb2\x5b\xae\xc9\xde\x4b\xbf\x00\x1d\x40\x3c\xb7\x51\xc2\xec\xe1\x1b\x86\xdd\x44\x4f\xe7\x35\x17\xa9\x4b\xd7\xad\x2d\x56\x80\x5b\x47\x3d\x18\x12\xc1\x79\x1a\xf3\x96\xe7\xe4\xad\x20\x61\xb1\xc8\xa8\x35\x79\x5c\xa0\xca\xec\x7d\x74\xa3\xbb\x1d\xaf\xe1\x21\xcd\x61\xde\x08\xd8\x7b\xfb\xdc\x91\xb5\xdc\x57\xef\xf3\xef\xb2\x51\xe8\x1e\xc7\xfd\xfa\xb6\x62\x7e\xc6\x61\xbd\x4a\x9f\x58\xb2\x36\x5c\xcc\x74\x6c\xc9\xd0\x2c\xab\x39\xc3\xd7\x99\x32\x7e\x87\x03\xb8\xfe\xaa\x09\xd1\x28\x33\x78\x2c\x66\x48\x66\xd5\x89\x47\x6e\x84\xcc\x72\x4d\x8f\x94\x5d\x09\xc3\x69\x76\x59\xb4\x07\x29\x25\x2b\x80\x78\xaf\x2e\x0f\xeb\x43\x83\xb0\x86\xde\x0f\x76\xaf\xec\xf7\x84\xa6\x39\xd7\x1a\x1c\x61\x6c\x32\x97\xf2\x9a\x1c\xac\xc1\xe3\x8a\xf2\xb4\x34\x9f\xe9\x27\x8e\xe6\x47\x76\xf6\x03\xc2\x45\x16\xb2\xa2\xc0\x0e\x16\x46\x7b\x47\x0e\x3c\x24\x09\xb3\x80\x3d\x74\xc8\xd5\x2e\x59\x61\x75\x9a\x88\x55\x6d\xa9\x60\xe3\x0c\x7b\x75\x7b\xce\x3a\xc2\xae\x7c\x60\x8b\xce\x1c\x6d\x37\x91\xd5\xd6\xae\x23\x6a\x8f\x1b\x5f\x24\xa7\x5c\x24\x4c\xf7\x07\xe8\xf4\x43\x35\x26\x49\x19\x56\xf1\x30\xc8\x7e\xa2\xb7\x26\xd9\x81\x5f\x7a\x1f\x8a\x41\xdd\x4f\xf7\x63\x8d\xfa\xaa\x62\x2e\xd6\x1e\xc9\x8a\x39\x1d\xa1\x91\x6e\x39\x1a\xb0\x40\xaf\x42\xcc\xa5\x90\xae\x48\xc2\x0a\x51\x29\x80\xa4\x81\x45\x61\x34\x0f\xf6\xc4\xb1\xe8\x68\xaa\x47\x55\x94\x38\x0e\x04\x42\x31\x19\xe2\x47\x54\x73\xb8\xe1\x66\xee\x7b\xbd\xd4\xa2\x86\x30\x13\xc5\x34\x04\x60\x04\x61\x4a\x49\xe5\x12\xb2\xbc\xdf\x1a\x46\x02\x4e\x0e\x19\x5d\x96\x48\xa8\xfd\x6b\x5f\xc7\x81\xea\x0a\x0c\x1e\xf2\x15\x2d\x35\xb1\xe9\x94\x25\xa0\x68\xc5\x0b\x8c\x5c\xfb\xa0\x82\xbe\x75\x55\x06\x96\xc0\x1c\x98\x7c\xce\xdf\xd9\xa7\xc4\xbf\x8a\x43\xe2\x0e\x72\x76\xfd\xd7\x83\x31\x21\xa7\x22\x64\xf0\x0e\xed\x2e\xc6\x77\xfa\xd4\x33\x63\x5f\x31\xee\x44\x00\x2f\x10\x3b\xce\xac\x76\xa8\xca\x1e\x28\xbe\x8b\x3b\x9c\xc4\x2e\xf1\x5e\xd9\x01\xb8\xc6\xdd\xa0\x76\xeb\xbd\x0e\xd0\xc5\x55\x6e\x6f\xf9\x58\xee\xf2\xc7\x11\x00\x21\x5d\xf9\x9c\x43\x53\xe8\x09\x1e\xfe\x32\x1a\x2d\xd2\xde\x43\xc0\xed\x5c\xa6\x88\xa6\x12\xd0\x20\xa0\xab\x13\xa0\xbb\xf0\xff\x78\xfd\xac\xd2\xf1\x84\xc4\xea\x80\x18\x66\xc5\x81\x6a\xa7\xc4\xaa\xda\x99\xf7\x2d\xe4\x45\xc6\xa0\x8a\x33\x1a\xb9\x2a\x50\x8d\xf0\xe4\x87\x61\x22\x15\x24\xbd\x03\x77\x19\x92\x7f\xc3\xa1\x0c\x89\xa8\x1e\x77\xe2\x3c\xfc\x1c\x2d\x44\xae\x7d\x73\x09\xa8\xb0\x34\xd2\xbb\x2e\x48\xca\xa7\x53\xe6\x13\x5e\xad\xe5\x48\x15\xcd\x2d\x8b\xd7\xc4\x2d\xc1\x84\xcd\x38\x26\x44\x06\xc6\xb6\x6f\xd5\x3d\x57\xeb\x37\x44\x66\xc8\x0d\xc9\xf9\x6c\x8e\x84\x42\x28\x54\xe8\x12\x1f\x54\xcc\x24\x4d\x09\xd0\xb6\x54\xe4\x86\xaa\xdc\xca\x0d\x9a\xcc\x21\x42\x49\x05\x49\x4b\x05\x38\xcb\x86\xd1\x74\x39\xd2\x86\x1a\xab\x29\x33\xe5\x0c\x4a\x3f\xff\x1d\xa8\xfe\x9d\xd7\x0e\x54\xff\x9e\xd7\x0e\x54\x7f\x07\xaa\xbf\x7a\x6d\x4d\x76\xe8\x0e\x54\xff\xf3\x82\x49\xda\x81\xea\x6f\x3e\x9e\xb0\x03\xd5\xdf\x81\xea\xdf\x75\xed\x40\xf5\x3f\x70\xed\x40\xf5\x5b\x5c\x9f\x01\xe7\xda\x81\xea\xb7\xb8\x76\xa0\xfa\xeb\xaf\x1d\xa8\xfe\xea\xb5\x03\xd5\xbf\xf5\xda\x81\xea\xb7\xbe\x76\xa0\xfa\x3b\x50\xfd\x1d\xd6\xe8\xc3\xc6\xda\x4e\xac\x51\xb2\x03\xd5\x77\xd7\x0e\x54\xff\xb3\x40\x54\x24\x3b\x50\xfd\x7b\x5d\x3b\x50\xfd\x1d\xa8\x7e\x9b\x6b\x07\xaa\xff\xb9\xb8\x4b\x76\xa0\xfa\x3b\x50\xfd\xdf\x8f\xa2\xbb\x03\xd5\xdf\x81\xea\xef\x40\xf5\x77\xa0\xfa\x77\xce\x62\x07\xaa\xff\x39\x98\x80\xda\xa4\xbc\x15\x06\xe8\x7d\xe0\x8a\x5c\x1a\x7a\x84\x0e\x30\x29\xa7\x53\xa6\x80\x73\xc1\x93\x57\xd2\xa7\x2a\x64\xc6\x66\x90\x95\x99\x21\x20\x1f\xb9\x8a\x9d\x5b\x7e\xee\xe0\x08\x00\xab\xb3\xca\x15\x3f\x79\xfd\x62\x0d\x36\x52\xeb\xbc\xc2\xb6\x59\xd2\x30\xe7\xd7\xa2\x5d\x7c\xfc\x96\x05\x5f\x57\x41\xe6\xd6\x3d\xc9\xa4\x76\x39\xee\xb0\x58\xc9\x9c\x0a\xc1\xbc\xbd\xc7\x0d\xf8\x51\x26\x8c\x09\x22\x0b\xe6\xa2\xd3\x94\x68\x2e\x66\x19\x23\xd4\x18\x9a\xcc\xc7\xf6\x49\xc2\x2f\x76\x95\x8f\xee\x3e\xd1\x46\x31\x9a\xfb\xcc\xfc\x9c\x72\x1c\x8a\xd0\x44\x49\xad\x49\x5e\x66\x86\x17\x61\x30\xa2\x19\x94\xd4\xa0\xa0\x0a\x8b\x01\x79\x71\x55\x12\xfb\xb0\x7a\x9a\x9b\x96\x8c\xc1\xe9\xc0\xda\x1c\x02\x22\x78\x5e\x98\x65\xc8\xe4\x65\x64\xca\x95\x36\x24\xc9\x38\x48\x6b\x78\x22\x56\x4f\xc3\x78\x43\x2f\xab\x85\x9b\xa9\x76\x53\x15\x29\xa8\xad\x85\xd1\x98\x17\x5b\x0d\xe8\x86\x4a\xb9\x76\x6a\xbe\x1e\x12\xea\x91\xd3\x70\xa1\xfd\x4c\x61\xa9\xbd\x64\xc1\xd1\xdd\x47\xd1\x70\x11\x62\x6c\x95\x38\x5c\x11\x3a\x14\x39\x78\xe2\x1c\xd6\xea\x39\x2a\x85\x02\xf2\xf4\x56\x8e\x01\x6c\x80\x60\x0b\x4b\x03\x2c\x61\x56\xbe\xd2\x5b\xa8\xfe\x93\x13\x7d\x24\x14\x5f\x31\xad\xe9\x8c\x9d\xb7\x0c\x34\xdc\x66\x91\x41\xac\xa1\xda\x18\x20\x85\x0c\xeb\x6b\xc3\x27\x55\x7e\x66\x5d\x0d\x22\x39\xce\x29\x28\x3f\x37\x8a\x1b\xc3\x60\x53\x01\x63\x0f\x62\x95\xcd\x12\xfc\xfd\x46\x96\xe7\x2b\x3f\x48\xf5\x63\xcb\xd4\x45\x8a\x39\x97\x13\x46\x26\x8a\xb3\x29\x99\x72\x48\xe4\x84\xd4\xca\x21\x42\x2e\x51\xf4\x02\x68\x6d\xed\x5d\x29\xbc\x2e\xeb\xe7\x35\x26\x3f\xbb\x89\x19\x55\x8a\x84\x46\x68\xb6\x50\x63\xca\xa7\x64\x06\xa9\x99\x4e\x5b\xfc\xf3\xd3\xbf\xfd\x95\x4c\x96\x56\xa4\x81\x66\x65\xa4\xa1\x59\x78\xc9\x8c\x89\x99\x5d\x2b\x3c\x9e\xf5\x2a\xc9\xb0\x02\xd0\xcf\x03\x27\xfe\xec\xab\xeb\x49\x5d\xc6\x3e\x49\xd9\xe2\x49\xb4\x7e\xa3\x4c\xce\xd6\x75\x48\x69\x9f\xb4\xdd\xd2\x24\x5a\x43\x66\x32\xe3\xc9\xb2\x33\xa1\x79\xec\x2f\x32\x97\x37\xa8\xeb\xaf\xa1\x9e\xaa\xe0\xaa\x90\x45\x99\xa1\xd3\xf9\x45\xa8\x2f\x2e\x35\x5b\xad\x02\x5c\x7b\x2e\xc0\x4d\xea\x86\x68\x22\xa7\x63\x46\xae\x7f\xa4\x74\xd5\x25\xce\x91\x17\x20\xc0\xc0\x10\x7a\x41\xb3\x6c\x42\x93\xeb\x2b\xf9\x52\xce\xf4\x6b\x71\xa2\x94\x54\xf5\xb9\x64\xd4\x72\xcb\x79\x29\xae\xb1\x87\x43\x00\x49\x90\x33\xab\x5a\x15\xa5\xf1\xa5\x0c\xeb\x5e\x18\x2b\xe6\x3d\x13\xf6\x66\x50\x35\x0a\x7b\xc7\x2b\x5b\xc7\x15\x6b\x21\x45\xc6\xe3\xeb\x98\xd8\xbe\x7a\xfa\xe7\xaf\x91\x74\x89\x54\xe4\xeb\xa7\x90\xb5\xad\x87\x78\x88\x81\xb7\x59\x41\x91\xd3\x2c\xb3\x66\x43\x4c\x94\x76\xa1\xd7\x11\xe1\x27\xa7\x41\xd3\x9d\xdc\xee\xad\x4a\x5d\x5d\xfd\x03\xf4\x28\x6e\x34\xcb\xa6\x43\xac\x4b\x0a\x66\xcd\x3e\x08\x86\x7d\xc7\x7d\xa0\x38\x6c\x0b\x14\xa0\x85\xcc\xca\x9c\x1d\xb3\x05\xef\xa3\x8d\x53\x6d\x34\x6f\xea\x67\x5c\x43\x09\xd8\x24\x93\xc9\x35\x49\xdd\x97\x51\xe6\x49\x13\x0b\xbc\xfd\x2a\xb4\xcd\xc1\xe9\x90\x7b\x73\xeb\xfb\xd7\xb2\x6e\x72\x5a\x14\xa1\x4a\x48\xd1\x9b\xda\x62\xc0\x99\x04\xc0\x82\x8e\x88\x32\x9d\xdd\xcc\x5d\x9d\xcc\x23\xf7\x46\x96\x6f\xb6\x1e\xa2\x75\xd6\x49\x77\x1f\x75\x35\xfb\xf6\x8e\xc9\x1a\x41\x54\x03\xfa\xd3\x50\xc0\xbf\xb1\xae\x64\xa5\x2e\x32\x94\xd6\x05\xc2\x40\x05\xc0\x92\x0f\xb0\xe4\xf6\x0e\xd7\x1e\xbc\x9b\xdd\x52\x8e\x6a\xeb\x22\x82\x57\x39\xa7\xc6\x29\x84\xde\x7d\x4d\x49\xc1\x94\xe6\xda\xca\xe5\x9f\xe0\x40\x1d\x65\x94\xe7\x91\x0b\x70\x33\x8b\x80\x87\x1b\x00\x94\xbb\x73\xca\x73\x99\xba\x01\x81\x15\x22\x78\xf4\x1a\xb5\xb6\xae\xd5\xf6\x28\x50\x37\xcd\x2a\x7f\xaa\x56\xb3\xce\x29\xed\x27\x81\x55\xe2\x5d\x9f\x13\x83\x84\xf7\x7b\xac\xfc\x31\x4c\xbe\x27\x36\x00\x8c\xd1\x6d\x6e\x9d\x13\xd6\x8c\x47\x3c\x28\x91\x4a\xef\xec\xc0\x31\xc1\x28\xb8\x3d\x13\xee\xa7\x64\xff\xf9\xfe\x46\x99\x24\x2e\x91\x92\x05\x9d\x75\xea\xe6\xd3\x58\xa9\xe6\xb0\x31\xd4\x84\x35\x83\xe0\xfb\x00\xbc\x06\x77\xb1\xb4\x42\xd2\x01\x9c\x24\x8c\x8e\xfa\x05\x76\x06\x02\x56\x64\xdf\xd0\x25\xa1\x4a\x96\x22\x75\xfe\xa5\xe0\xe0\x7b\xd5\x78\xf0\x99\x14\xcc\x3b\xce\x9b\x48\x15\xe0\xd1\xe7\x82\x3c\x1b\x3f\x7b\xfa\xb9\x48\x2a\x78\xc3\x86\xa4\x3a\x0b\x92\x0a\xf9\xd3\x46\xdf\xd5\x63\xde\xf7\xf4\xbe\xaf\x9c\x8b\xa5\x82\xb4\xe7\x1e\x30\x1b\x3e\xba\x51\xdc\xb0\xa8\xcb\xdf\x01\x18\x2e\xd6\x3e\x8c\x70\x19\x06\xeb\x7a\x49\x74\x5c\xa4\x6e\x40\x18\xba\x9c\x7c\x44\xbe\xe5\x18\x14\x1c\xb7\x75\x1e\x2e\x7d\x07\x0b\x8b\x17\x6a\x6f\x8f\x1c\xe0\x9d\xfb\x58\xd2\x3c\xd8\x28\x69\xb9\x45\x3b\x79\x57\x74\x40\xd9\x6c\x54\xcf\x17\x14\x7c\x70\x45\x8f\x2b\xf8\x1d\x9b\xd3\x05\x83\x52\x6e\x9e\x51\x95\x41\xcc\xf1\x12\xe7\x4e\x26\xa5\x21\x4c\x2c\xb8\x92\x22\x67\xc2\x90\x05\x55\x1c\x70\x71\x14\x03\x6c\x07\x6b\x8b\xfe\xf1\xe0\xa7\xc3\x0b\x48\x68\x18\x38\x50\x0a\x37\xcb\x52\x7b\x00\x9b\x78\x26\xd1\x70\x1f\xdc\x3e\x3f\x0f\xbb\x86\xc0\x73\xfd\xbc\xec\x73\xf2\xd2\x94\xd8\x98\xe5\x5d\x92\x95\x9a\x2f\x36\xc5\x49\x5c\x8d\xfd\x31\x6f\xb5\xcf\x8d\x7a\xff\x6a\xa1\x56\x4a\xf7\xc1\xb5\xbe\xa6\x40\x6f\x25\x60\xb2\xaf\x43\xd1\x5e\x1c\x03\x77\xae\x27\x87\xa6\x81\xe9\x73\x1e\x73\x71\x45\x85\x00\xe4\x98\xcd\x3a\xa1\x84\x4c\xd9\xc3\x71\x77\xea\xe9\x3d\x6e\x08\x8c\x99\x47\x15\x7c\x3a\x99\xb3\xb4\x04\x80\x27\xae\x11\x1e\xd5\x9a\x0f\xb4\xc2\xe1\x13\xd0\x27\xe8\x74\x1a\x40\x0d\xc4\x08\x9c\x83\xb8\xe6\xfe\xf7\xca\x43\x20\xf8\x0f\x74\x63\x44\x30\x4a\xed\x58\x43\x42\xb5\x2e\x73\x3c\x12\xd8\x02\x61\xca\x8d\x0e\x5d\x66\xbd\x76\x6c\x0f\xc6\x03\x0b\xaa\x3a\xac\xef\x25\xcb\x80\xb8\x3a\xac\xf1\xfe\x59\x34\x0e\x2e\xb4\xf6\x7f\x39\x82\x73\x09\x13\x10\x6d\x0b\x79\x9c\x12\xbc\xa4\x53\x0e\x6d\x94\xa8\x5b\xef\xcb\x35\xbf\x44\xd5\x01\xef\x00\x80\x18\x3a\x61\x99\x6e\x0e\x34\xa9\x36\xc5\xe1\x92\xba\x85\xef\xd8\x27\x97\x6a\xcd\x67\x02\x3a\x68\xda\xd1\x1e\xd8\x2b\xb3\xb5\xcd\xd4\x47\x1f\xdc\xd6\x5c\xad\x96\x85\x95\xd3\x62\xe4\xac\x5e\x23\x73\x9e\x3c\x60\x24\xf9\xc0\x29\x37\x6a\xa5\x6b\x35\xb8\xaf\x2f\x57\x3c\x3e\x3a\xf2\x6a\x8c\xc9\xa5\xcc\x5d\x8a\x93\x88\xfa\x78\xf9\x76\xaa\x56\x62\x28\x66\xd7\x02\x12\x8f\x78\x15\x8d\x87\xbe\x37\xbe\x0a\x1a\x9e\x13\x54\x72\x17\xc6\x05\x00\x4a\xd7\xce\x55\x66\x99\xbc\x81\xc4\x62\x1c\xd7\xd3\x36\xa4\xc0\x3c\x27\xa3\x46\x6f\xda\x71\x1d\x36\xf4\xee\xe7\xb8\x7b\x87\x1f\x7e\x0a\xe6\xe7\x00\x20\xdf\xe9\x71\xfc\xe7\xe9\xf9\x91\xff\xb3\x39\x93\x7a\x1b\x86\xdb\xef\x8a\x01\xb1\x6f\xbb\x6b\x8a\x9d\x8c\x3e\xf0\xf5\xd1\x9c\x0a\x1f\xb7\xba\xf5\x79\x4b\x9d\x98\xac\x9a\xce\x9c\x2a\xe6\x00\xe3\x2c\xe3\xd6\x05\x4d\x6e\x9d\x45\x40\x67\xbb\xf3\x86\x3b\x67\xaa\xcb\xc2\x77\xd8\xce\xe0\xc6\x30\x93\x8a\xca\x7e\xf9\xe2\xd7\x7b\x2e\xe6\x87\x7e\xb3\x6e\x69\xef\xfe\x4d\xad\x4f\xdf\xbd\x7e\xb1\xbe\x8b\xd7\xfd\x7e\x1b\x35\xc2\xbb\xd7\xfd\xb7\x35\xe1\xbd\xef\xd3\x7c\xf3\xb6\xfb\xbd\x58\x73\xb7\xef\x71\x3b\xee\xfd\x7d\xd0\x4a\xec\x91\x3c\x05\xd4\xcd\xe9\xf2\x5c\xa6\xf6\x74\x62\x92\xdc\xc3\xa0\x0d\x5a\xf3\xfb\xb6\xbe\xb1\x16\x1e\xad\xf6\x9e\xac\x76\x9e\x81\x86\xb6\x70\x0b\xf2\xa9\x43\x65\x13\x33\x52\xc3\x9a\x2a\x95\x62\x02\xba\xe4\x97\x90\x16\xe9\xbb\xdf\x23\x47\x07\xce\xec\x70\x3d\x11\x9c\x9e\x1c\x06\xc1\xe9\xd2\xe5\x72\x0a\x58\x9f\x11\xb6\xf5\xb4\x84\xec\x47\x90\x13\x88\x5d\x27\x85\x9d\xc7\xf3\x75\x70\x1a\xb2\x60\x22\x6a\x8d\xef\x54\xec\x91\xa5\xc0\x1a\xc0\x06\x6a\x0d\xe3\x3c\xfd\x43\x91\x51\x33\x95\x2a\x1f\x79\x5d\x72\x54\xd3\x28\xc8\x11\xe4\xe1\x68\x6f\x8c\x61\x32\x2c\x62\x70\x8a\x34\x63\x91\xe8\x0f\xaf\x2a\x52\x44\xac\x22\xa5\x50\x2c\x91\x33\xc1\xff\x53\x2d\x04\x08\xc1\xe0\x49\xa2\xda\x8a\x5d\x22\xca\x2c\x7b\x78\xd2\x42\x4b\x8d\x41\x2e\x98\x9a\x33\xfa\x40\xe2\x6d\xe4\xbf\xb8\x31\xaa\x56\xa5\xda\x01\x10\x38\xfd\xd8\x3f\xc4\xea\xd1\x32\x81\x42\x38\x8c\xc7\xfb\x2c\x67\x0a\xd2\xdf\xaa\x85\x94\xcc\xf8\x82\x09\x8f\x50\x7e\x94\xd1\xd0\x6e\xdb\x83\xb2\x3a\x94\xf4\xd2\xc8\x90\xe1\x40\xa8\x89\x70\x92\x21\x21\xca\x05\x57\xe3\x71\xa2\x5b\x5c\xb3\xee\xcc\x37\x46\xbb\xcf\x9d\x90\x64\x80\x9d\x22\x87\xd5\x2b\xe5\xde\x11\x5b\x03\xe2\x24\x09\xa4\xc2\x78\xbb\xc5\xa5\xc0\x7c\xf8\x11\x2e\x7f\xcd\xf2\xa0\x75\xc3\x38\xdd\x3a\x20\xc6\x56\x0b\x9b\x59\xe1\xb1\x44\x8d\xe8\x74\x5a\x7f\x12\xaf\x61\xf4\x43\xa1\x14\xe8\xea\x95\xf1\x78\x2e\x53\xab\xb2\x0d\x49\xd8\xca\xb8\x57\xb9\x0b\xce\xe0\x99\x8c\x0e\x23\x6a\x74\x4a\x31\x5d\x48\x6c\x15\x10\x3f\x76\x18\x39\xcb\xb8\xa9\x65\xe6\x61\xd3\xb7\x70\x34\x10\xcc\xed\x3f\x4c\xc9\xb5\x0a\xff\x8c\x9b\xf1\xf5\xd7\xa0\xed\x33\x31\xa7\x22\x41\x43\xeb\xc9\x35\x2b\xf4\x13\xcd\x67\xa8\xdc\xff\xf5\xeb\xaf\x41\xd3\xf7\x4b\xf2\xe4\xe2\xe4\xf0\xf8\xd5\xc9\x38\x4f\xd7\x38\x6b\x3d\xaa\x30\xa4\xbf\xfc\x18\x14\x66\xb2\x78\x36\x7e\xf6\x35\xe6\xe7\x71\x8d\x58\xc3\x11\xd0\x30\x96\x8b\xaf\xa2\x0c\x5b\xa1\xe3\xd7\xcd\x89\x9e\x07\x66\x1d\x6d\xd4\xd6\x28\xa8\x31\x4c\x89\xe7\xe4\x7f\x0e\xde\x7e\xf9\x7e\x34\xf8\xf6\xe0\xe0\x97\xa7\xa3\xbf\xfd\xfa\xe5\xc1\xdb\x31\xfc\xe3\x8b\xc1\xb7\x83\xf7\xfe\x8f\x2f\x07\x83\x83\x83\x5f\x7e\x7c\xf5\xfd\xd5\xf9\xc9\xaf\x7c\xf0\xfe\x17\x51\xe6\xd7\xf8\xd7\xfb\x83\x5f\xd8\xc9\xaf\xf7\x1c\x64\x30\xf8\xf6\x8f\x0f\x9c\x68\xcb\xca\x99\xae\xd5\x32\x9d\x2a\x64\x7a\xac\x8a\x29\x14\x63\x39\xf0\xdc\x36\xf9\x64\x75\x3f\x6e\x63\x28\x2f\xd5\xdd\x5f\x96\x11\xfb\xa7\x89\x99\xe5\xcd\x1a\xf9\x75\x26\x6f\x20\x07\x94\x4b\xab\xaf\x8d\xc9\x6b\x10\xbe\xe4\x8c\x2d\x98\x1a\xfa\x51\x5f\xda\x9b\xce\xc3\x3d\xb1\xa3\x70\xdd\x1d\x51\x0b\xd3\xdb\x0e\xea\x90\xcc\xe2\x74\xc3\x33\x29\xce\xc3\xec\xc2\x30\xee\xe4\x8d\x1e\x0e\x4c\xd7\x72\x7b\xfd\x32\x74\xd8\x07\x6c\xd3\xe2\x5e\x00\xf8\xeb\x98\xfc\x44\x15\x97\xa5\x76\xba\x54\x8c\x6e\x8e\xf9\x72\x61\x89\xc0\x05\xe3\xa2\x59\x61\x90\x50\x06\xe7\x03\x5a\x61\x7d\x0e\x83\xbc\x39\x5a\x2f\xd2\xb8\xb1\x9b\xbe\xf0\x8f\x52\x3e\xaf\x77\x05\x18\x1d\x85\xd9\x5a\xf9\xe5\x25\xb2\x8e\x27\x0a\xc3\xf8\x79\x80\x6c\xb0\x9a\x24\x8e\x32\xe7\x33\x9f\x3d\x0e\xef\x8f\xb6\x7a\xf4\x69\x20\xb6\x16\x5b\xda\xe6\xc4\xb7\x2d\x62\x28\x9a\xef\xd7\x81\x2c\xea\xf0\xd1\x31\x02\xb5\x2f\x9f\xaa\x8e\xe0\x1e\xd2\x09\x08\xc1\x51\xa2\xb8\xe1\x09\xcd\xf6\x40\x84\xf9\xaf\x92\xac\xb4\x7a\x6e\xfc\xad\x62\xc4\xdc\x48\x7c\x0a\xcd\xc8\x35\x5b\xde\x48\x95\x7a\xfd\xc2\x3f\xb1\xda\x0b\x6d\xfc\x23\xad\x35\x0b\xbc\x00\x7d\x2a\x2a\x67\x8a\x4c\x98\x0f\x17\x34\x6e\x5e\x8e\xc9\xa1\x58\xba\x58\xab\x88\x2b\x2a\x23\x18\x3a\xd0\x71\x50\x0b\xac\x11\x89\x93\x87\xfe\x69\x14\x6b\x5d\x6f\x73\xa5\x5b\x05\x32\x9c\x02\xaf\xbd\x78\x5f\xba\x54\xae\xa4\x0b\x4e\x87\xc2\x82\x34\xe9\xbf\xfe\x24\xdc\xc2\xea\x67\x5c\x30\xad\xbf\xb7\x5b\xd9\x45\xdd\xae\x53\x07\x05\xb5\xca\x8d\x0d\x7c\xb2\xca\x9f\x66\xf6\x48\x61\x40\xdc\x72\x74\x99\x56\x77\x8e\xc9\x21\x7c\x00\x05\x00\x56\x73\x84\x92\x41\x3b\x18\x37\xba\xd9\x4b\x1f\xef\x38\x3c\x3b\xf6\x89\xda\xa8\x74\xe8\x3a\x3a\x3c\xaa\xfc\xf5\x99\x80\xa6\xea\xd2\x85\xd9\x6f\x25\x85\xb6\xc0\x7b\x57\xaa\x64\x7b\xed\x54\x3d\xec\x3b\xf0\xe4\x2f\x5f\x3f\x05\x6d\x2f\x3c\x0f\xd8\xfe\x03\xab\x9f\xda\x26\x04\xb5\x4a\x05\x6a\x66\x41\x5d\xc4\xf4\xe0\x17\xdc\xdb\x4d\x2e\x42\x07\x85\xcc\xb0\x4d\x61\xcd\x5b\xf9\x91\x5b\x25\xfe\xb4\x4f\xf9\x19\x55\xd3\xbd\x7a\x78\xcb\xb6\x2e\xd9\x3a\xb5\xe7\xf6\x11\xd2\xab\x46\xc3\x5d\xd1\xb8\x25\xe1\x39\x91\x1b\x1b\x3b\x7b\xb8\x8f\x21\xf7\x17\x18\x17\x84\x40\x80\x3d\x2e\x8b\x0e\x79\xce\x2d\xf8\x0d\x94\xf5\x74\x56\x15\xf7\x2f\x70\x20\x52\x54\xba\xe1\x4a\xb9\x46\x08\x67\x83\xde\xe1\xb4\xc2\x43\xa8\x7d\x1b\x92\xd7\xe2\x05\x16\x03\x0c\x51\x51\xac\x41\xad\xe0\x4d\xbd\xd6\x44\x3e\xf9\x83\x7b\xf7\x11\x4e\xb9\x0d\x53\x78\xf8\x72\x47\x96\x6f\x47\xe9\xbf\x7f\xd1\x18\xab\x46\x7a\x35\xcb\xde\x49\x48\x5e\xb5\x7a\x73\xec\x93\xcc\x94\x2c\x0b\x1f\x36\xae\xf7\x6d\xab\x9a\x95\x60\xb4\x13\xdb\x1a\x0b\x59\x1f\x3a\x38\x6f\x80\x80\x59\xe5\xf5\x4b\x49\x82\xe6\xbd\x97\xba\x58\xf2\x85\x1e\x10\x55\x8a\x7a\x5b\xf7\x28\xf0\xba\x97\xb1\x19\x4d\x96\x7b\xf5\xe7\xac\x0b\x73\xa3\xc3\x97\xe7\x88\x0f\x8f\xcf\xab\x0a\x38\xa0\xce\x03\xf4\x07\x3c\x6b\xa0\x1a\x94\xda\x4d\xd1\x8b\x7c\x5f\x81\x88\x9e\x39\xd5\xc1\xb3\xf0\x97\xaf\xff\x32\xf2\xbe\x43\x9c\x4a\xb3\x96\xdb\xd5\x64\xaf\x75\x27\xfc\xb9\x95\x2b\xe0\xc1\xf4\x17\xa2\xda\xbd\xaa\x9e\xb5\x2d\xb6\xfa\x14\xd7\x05\x90\x03\xfa\x43\x82\xf4\x0f\x4f\xbf\x4b\x3b\x5b\x3f\x88\xdf\xaf\x6a\x88\x4f\xb2\x5c\xf5\x90\x43\x97\xd3\xda\x6c\x8a\x33\x97\x59\x0a\xe7\xca\x39\x99\xfc\xa3\x08\x35\x46\xf1\x49\x69\x9c\x57\x38\x91\x79\x5e\xaf\x27\x75\xed\x03\xc7\xa4\x2a\x28\x8c\x8d\x67\x20\xfc\x31\x21\x97\x8c\x61\xeb\xcc\x68\x1e\xc0\x96\xfd\x52\x3a\xe7\xb2\x9c\x62\x9f\x73\xb4\xd9\x3e\x91\x43\xaa\xbd\xf4\x76\x91\xc7\x8e\x41\x8a\xbd\xc3\x60\xd4\xc4\x01\x42\xe4\x87\x2b\xdd\x8c\x1b\x82\x0c\x52\xad\xab\x88\xb4\xcb\xbc\xb2\x6b\xa1\x11\x3f\x17\x68\xf9\x47\xec\x7c\x0a\x69\xa5\x10\x26\x45\x57\xec\x8d\x1d\x62\xce\x0b\x34\xc1\xa9\x09\x3f\x87\x04\x07\xfb\x75\x0c\x4b\x01\xad\x3c\x9f\xa1\x0d\x2c\x6f\xc0\x09\xfe\xfd\xe9\x71\x38\x23\xf6\xae\x17\x97\x18\x03\xfb\x6a\xec\x1a\x13\x9b\x19\x4f\xc9\x04\x93\x5a\x2c\x7b\x3d\x10\xec\x06\xd3\xe4\x9d\x9f\x38\xa8\xe1\x0b\x9f\x3e\x8e\xa3\x85\x87\xbb\x21\x07\xe4\x4f\xae\x45\x2c\x53\xde\x88\x9f\x70\x97\x46\xfb\xfa\x62\xdf\x7b\xe7\x6f\x46\xea\x66\x34\x1a\x8d\x5c\xec\x1b\x98\xfa\xb0\xb6\x06\x81\xf7\xe7\x32\xe5\xd3\x65\x63\x25\x2c\x99\x57\x8f\x00\x8a\xa4\x62\xe9\x66\xd7\xbd\x9b\xf1\xc3\xa1\xcb\xbb\x39\x02\xbb\x40\x55\xac\x89\xab\x77\x0d\xc7\xad\x0b\xd5\xa3\x59\xad\x2b\xc4\x77\x39\x45\x22\x85\xca\x82\x5b\x36\xc6\x3b\x8d\x1c\xd5\x38\x1c\x43\x34\xea\xd9\xbb\x42\x22\x4a\x32\x54\xee\x40\x3f\xbb\x66\x34\x06\xfc\xe4\xf6\x54\x41\x02\x62\xed\xd4\x38\xfd\x03\x03\x80\x7e\x11\xc8\x84\xda\x21\xc3\x74\x0e\x1a\x74\x32\x18\x93\x53\x47\x5a\x60\x3f\x0a\xe9\xba\xe2\x11\x29\x08\x2b\xe6\x2c\x67\x8a\x66\xf5\x07\xb9\x0a\xe6\xe7\x96\xdd\x2a\x4b\xa5\x18\xf1\xc8\x69\x81\xdc\x16\x98\x67\xca\x95\xef\xaa\x1b\x45\x22\xf7\x5e\x8b\x0b\x29\xcd\x2b\xae\x41\xd5\x71\xbe\x13\x54\x4c\xf7\xd6\x09\x34\xff\x5d\x95\x0e\xde\x95\x92\x3f\x59\xb8\x8f\xf8\xce\x78\x7d\xf0\x5a\xcb\x41\x2c\xd3\x7a\x68\xf3\xbb\x37\x0e\xe0\xa8\xd6\x63\xb8\xf2\x02\xaf\x69\x6d\xb7\xd2\xd7\xee\x13\x37\xb6\x73\x19\x6b\xd4\xd4\x90\xc4\x3e\x75\x33\xf6\xcd\x71\x2f\x20\x99\x33\x09\xe7\xa4\x23\xd1\x9c\xae\xf6\xd3\xab\x48\x04\xbc\x83\xa1\x51\xa8\x90\x62\x04\xfd\xad\x4a\xed\xe3\xb4\xca\x7b\x88\x6b\x02\xc8\x35\xdd\x44\xb1\x89\x8d\x13\x69\x65\x01\x58\xd5\x49\xe8\x52\xb1\x90\xbd\x99\x4a\x56\xf5\xba\xa2\x9a\xbc\x39\x3d\x26\x4f\xc9\x01\x64\x2e\x87\xea\x75\xc4\xeb\xb0\x96\x6f\x23\xbd\x76\xea\x87\xa8\x5b\x3a\x0e\x2c\x43\x48\xe4\x45\xbe\x11\xa8\x14\x41\x0c\x3b\xd0\xd1\x5b\xda\x37\x6e\x9a\xc6\xdb\xd2\x63\xbb\xfa\x84\x90\x12\xd4\x03\x0f\x7a\xd3\x82\x07\xc5\x8a\x75\x1f\xcd\x37\x37\xbd\x7b\xbf\x77\x0e\x55\xcf\xea\xeb\x81\xa8\x2e\x4f\x60\x40\x04\xca\x78\x67\x9c\x1a\xff\xc0\xce\xee\xab\x80\x48\x0e\x15\x2a\x60\x27\x28\x2a\x52\x99\xaf\x3c\xcd\xee\x26\x18\x6f\xd1\x6e\xee\xc8\xee\xb6\xab\x53\x79\x6b\xb7\xea\x50\xb0\xf1\x7b\x28\x0b\x7e\x09\xbe\x02\xae\x03\x25\xa0\xf3\x00\x12\xe6\x57\xcc\xd6\xce\xa8\x11\x9d\xab\xa4\x94\xcc\x5a\x16\x1a\xd6\xde\xfa\x42\x66\xae\xc0\xc3\xbf\xb6\x1d\x78\x6b\xdf\xda\xb4\x8c\x2a\x34\xd9\xcb\xb2\x68\xbc\x35\xb8\x73\xb6\xf5\xad\xcb\x56\x52\x9a\x34\xdf\x1a\xf2\x7f\x6b\x6f\x0d\x72\x77\x1b\xdf\xba\x9e\xee\xdd\x83\x30\x71\x03\x12\xe9\x92\xce\x5d\x97\x85\x26\x00\x4c\x95\x10\x0a\x4e\xa8\xc7\xc5\x47\xbb\x40\x04\x60\x8a\xd5\xa7\x66\xdd\x32\xa1\xd9\x1c\xbb\xdc\xb7\xdb\x67\xd2\xdc\xeb\xe6\x90\x51\xee\x06\xb5\xb3\x85\xcf\xa2\x0c\x4a\x8a\xe8\x55\xb2\x8a\xdf\x34\x62\x35\xce\x4d\xe7\x7e\xe9\x93\x27\xac\xfc\xad\x12\x3a\xe3\x5f\x1b\xe9\x1a\xef\x7a\x94\x7c\x0a\x13\x64\x98\x9e\x59\x50\x33\x1f\x12\xc5\x32\x04\xbe\x75\xe7\xec\x1a\x4d\xa9\xfd\x5a\x96\xa8\xa7\x58\xff\x68\x50\x58\xa0\xf1\x36\x8c\x0c\x2e\x1f\xaf\x86\x4c\x91\x7f\x71\x4d\xf6\x5e\xfa\x05\xd8\x7b\xcc\x0c\x7a\x0f\xdf\x27\xec\x1d\x7a\xb1\xae\xb9\x48\x1d\x22\x6c\x6d\x69\x42\x46\x32\xea\x86\xde\xc3\xe4\xcf\x3a\x55\x0c\x9c\xbd\x61\x69\xc8\xa8\x35\x31\xb8\xc8\x99\x8f\x9f\x8e\x6e\x51\x32\xbd\x4f\xc5\x3f\xa4\x39\xcc\x1b\x01\x3b\x2d\xa0\x58\x44\xc8\x35\xf7\xf9\x77\x69\xd7\x1d\xb2\x0b\xeb\x5d\xa9\xea\xe9\xc8\x7e\x0f\x03\x0e\xd7\x0c\x8b\x84\x22\x15\xbe\xc2\xea\x74\x76\xa1\x6b\x7e\xdd\x50\xbd\x87\xb0\x3b\x2e\xd3\x76\x45\x3a\x61\x36\x56\x4e\xd5\x92\x7c\x7f\x7a\x8c\x1a\x78\xcd\x10\x10\xd2\x3f\x3a\x50\x4a\xea\xe0\x18\xa9\x58\x6e\x81\xe2\xdc\x0e\x12\xa7\x35\x20\x4e\x57\xa8\xe1\x4e\x66\x22\xd6\xac\x75\xa4\xa9\x4b\x57\xf9\x36\x97\x59\x4a\x68\x20\x30\xe1\xab\xde\x52\xff\x1c\x8c\xb7\x47\xe5\xae\x63\x6b\x7c\xb9\x58\x76\x29\xaa\xc2\x18\x7f\xff\x41\x53\x25\xf0\x67\x7a\xe0\x6a\xbf\xbd\x67\x2a\xa3\xa5\x48\xe6\xbf\x17\x92\x59\xb3\xfa\x21\xd4\x41\xc9\x35\x53\x82\x65\xa4\xa0\x8a\xe6\xcc\x84\xee\x8e\x9a\xb5\xc1\x3a\xea\x08\x95\xd4\x0d\x28\xa9\x03\xc8\x51\xfb\x2e\x8d\x5d\xe1\x91\xba\x80\xce\xac\x69\x5d\x37\x45\xe9\x68\xa7\xb4\x74\x1d\x4d\x5b\x0e\xde\x19\x09\xa4\x53\xdf\xc5\x3a\xea\x17\xb6\x2c\xd8\x8a\x77\xab\xd7\x35\xf7\x60\xdd\xfc\x8c\x03\x56\x00\x0c\x3e\x93\xe1\xa1\xee\x32\xaf\x32\xad\xc2\x9e\xed\xeb\x15\x57\x54\xbd\x47\xc4\x27\xf6\x95\xb7\xe6\xbb\x50\xf6\xf8\xa8\x3c\x5c\xb3\x5c\xd3\x23\xc5\xa0\xc0\x96\x66\x97\x05\x4b\x7a\xd0\xb0\xbf\x7f\x75\x79\x58\x1f\x14\x84\x12\xe4\x66\xdb\x3d\xb1\xdf\x47\x15\x06\x37\x6c\x32\x97\xf2\x9a\x1c\xac\xa9\xf2\x8c\xea\x6b\x34\x9f\xe9\x27\x8e\xbc\x47\x76\xde\x03\xc2\x05\x60\xf7\xae\x62\x1e\xfb\x87\x24\x61\x16\xb0\x57\x2e\xc5\xcd\x89\xe1\xd5\x69\x02\x8f\xc2\x8c\x9a\x4d\x18\x38\xab\x9b\xf1\xf0\x7c\x2f\x7f\x7d\x60\x43\x6e\xab\xf6\x5d\xbb\x6a\xe8\xd0\xd8\xc8\x92\x38\x73\xdb\xaa\xef\x3d\xac\xc3\x0f\xd5\x68\x31\xd4\x1c\x9f\xd6\x50\xf0\x2b\x43\x29\x04\x2b\xf7\xa1\x1b\x97\xfb\xe9\x7e\xac\xd5\xd7\xab\x9a\xa0\x8c\xdd\xd7\x1f\x8a\x38\x83\x62\xc2\xe2\x62\xc3\xa8\xee\xa7\x59\x6f\xe8\xf8\x6d\x34\xd5\xa3\xca\x83\xe4\x93\x11\xa7\x19\x9d\x41\x37\x9f\x46\xf1\x0e\x30\x57\x59\x62\x54\x33\xbe\xd9\x57\x68\xfa\x4e\x15\x00\x94\xad\x91\x8b\xf9\x60\xa6\xab\xf2\x80\x2c\x90\x43\x3b\x6f\xbb\x2c\xe7\x3e\xf7\xd9\x4f\x01\xdc\x14\xa1\x46\x55\x5b\xda\xc1\xfc\x0d\xbe\x60\xb5\x05\x46\xce\x7b\xe0\x61\x7a\x0c\x26\x59\xa1\xbc\x80\xdf\x53\x92\xf3\x77\xf6\x29\xf1\xaf\xe2\xe2\x04\x91\x42\x94\x78\xfd\xd7\x03\x6b\x8c\x55\x96\xdb\xd0\xee\x62\x7c\x67\xd4\x45\x42\xc0\x17\x67\x58\x5d\x80\x2f\x10\x47\x5a\x5c\x43\x88\x2e\xf4\xdd\x1e\xc6\x2d\x84\x4a\x7b\x3a\xea\x10\x32\x75\xc3\xd9\x8d\xf6\xe2\xbb\x4b\x08\xd5\xde\xd2\x47\x18\x75\x55\x46\x7f\x72\xd1\xfe\x29\x79\x98\x66\x6a\xc1\x13\x76\x98\x24\xb2\x14\x9d\xb2\x50\x8f\x99\x7d\x05\x6a\x58\x7a\x59\x1b\x13\x3d\xee\x29\x7c\x8b\x85\xf7\x34\xe3\x14\x21\x98\xea\x77\x62\x4d\x5e\x35\x0e\x78\xec\x1b\x33\x74\x24\xa3\x0d\xa3\xed\x32\x4a\x3b\xae\x50\xd7\xcc\xfa\xd5\x37\x5e\x27\xe1\x1a\x2b\xe8\x9c\xf5\x2b\x59\xf3\xf7\x2b\x59\x30\x54\x5f\x57\xc0\x54\x0c\xaa\x96\xc2\x61\x8a\x3e\x77\x2f\x3a\xa2\xf8\xd4\x56\x60\x55\x2d\x56\xd7\x58\xbe\x67\x5f\xfe\x50\xbf\xf8\xef\xe3\xb3\x6e\x99\xe3\xa1\x27\x0f\x96\xc3\xcc\xdd\xd0\x41\x55\x8f\x51\x08\xe2\x6a\x46\xfb\xe4\x21\x51\xd4\xb5\x1b\x70\xad\xe6\x32\x46\xd1\xa7\x42\x0e\xa2\xc4\xfe\xc1\xd8\xf2\xf4\x2a\x5a\x8e\xac\xde\x75\x86\xcb\x19\x15\x3a\xaa\x58\x65\x30\xb4\xcf\x8a\x0d\xf3\x41\x41\xe8\x76\xdb\x79\x0f\x0e\xbc\xd3\xb5\x7e\x87\x36\xaa\x4c\x0c\x29\x8d\xb6\x9f\xe3\xc3\x3d\xc3\xbc\xc7\xe3\x15\x9b\x71\x6d\xd4\xd2\xf7\xac\x9b\x46\x93\x70\x5e\xa1\x70\xcb\x35\x5b\x92\x1f\x7e\x3c\xf9\xc7\x3f\x5f\xbe\x3e\x3a\x7c\xf9\xcf\x57\x87\x47\x3f\x9c\x9e\x9d\xbc\x7d\x7b\xf9\x8f\xcb\xab\x93\x57\x6f\xdf\x1e\x21\xa0\x8a\xab\xde\xbd\x64\xe6\xed\x5b\x47\xa9\xfa\xed\xdb\xab\xa4\xe0\xc5\xdb\xb7\xe7\xde\x07\x82\xdd\x28\xfe\xfb\xf8\x0c\xf8\x27\x16\x91\x85\xb4\x27\x90\xad\xb8\xe8\x30\xef\x39\xd5\x55\x92\x65\xad\x3c\xa7\x05\x82\x69\x5b\x71\xb7\x16\x3f\xaa\xd3\x61\xb7\x03\x56\x6d\xa4\xbc\x8b\x37\x78\xe9\xc8\x84\x99\x1b\xe6\xaa\x1e\xd7\x02\x94\xd1\xa8\x8e\x3a\xc2\x1c\x5b\xd7\xaa\x06\x95\x33\x49\x16\x9c\xdd\x20\xc4\x06\x76\x05\xac\xfa\x25\x41\x15\x34\x56\xc2\xae\xc2\xa0\x81\x92\x54\xc8\x34\xf4\x86\x6a\xf8\xa5\x57\x7c\xd2\xb5\xaa\x1b\x04\xba\x63\x29\x39\x3f\x3d\x26\xcf\xc6\xa8\xe4\x9c\x1e\x23\xee\xe6\x5a\x58\x2e\x6f\xa9\x5a\x81\x8a\xd2\x77\x4d\xd5\x41\x45\x00\x6d\x98\x51\x0b\x0a\x28\x27\xa9\xcc\xe9\x43\xbb\xc0\x7d\xa0\x7e\x05\x7b\x74\xfe\x56\xd2\x0c\x75\x80\x73\x99\xae\x72\xa6\xbd\x6f\xfc\x47\x7f\x1f\x7f\x13\xe6\xf1\xf7\xf1\x37\xd0\xfd\xd3\x2f\xdb\xdf\xc7\x7a\x91\x8c\xbf\x71\xf5\xd4\xc4\xdd\xb4\x36\x47\x78\xa5\x38\xca\xe9\xb3\xf8\x1b\x78\x36\x05\x7d\xf7\x93\x94\xbb\xf4\xd8\x46\xb5\xe7\xe6\xa9\xa8\x05\x42\xa9\x76\xa2\x18\xc5\x54\x73\x92\xb2\x8c\x55\xb0\x37\x5b\xd0\xbd\xf3\xf6\x76\xa6\x3e\xd6\x56\x6b\xf6\x1a\xfb\xa6\x82\xbe\xf4\xbb\xef\x09\x1b\x1b\x0c\x7f\xaa\x5a\xec\xb7\x38\x00\x1d\x81\x1d\x1e\x14\x36\x32\x32\x63\xb8\x3f\x5d\x4e\xca\xda\xba\xba\x7d\x1d\x8f\xde\x66\x21\x36\x51\xbc\x7e\xe5\x91\x5b\x2d\x45\x5c\x85\xf9\x83\xa5\x81\xbd\x0e\x31\xb8\x8a\xdf\x40\xb5\xdb\x92\x58\xa9\x65\xd0\x93\x11\x17\x94\x1a\x05\x5d\x19\xbf\xb9\x66\xcb\x21\xe2\x7f\xa0\x12\xf2\xf7\x08\x82\x3a\x54\x50\x23\xce\x9c\x54\xe4\x1b\xff\xaf\xbf\x3f\xd4\x5a\xeb\xe0\x47\xed\xe2\x45\xc5\x97\xea\x1c\xf9\x3a\xc1\x2a\x98\x3a\x20\x08\xae\xac\x2b\x90\x31\x12\x97\x6b\x4c\x4e\xa0\x4c\x16\x35\x52\x07\xc3\x9b\x65\xb5\x9b\xb5\x6f\xa9\x59\x03\x93\x00\xff\x4b\x54\x1d\x73\x26\x2f\x5d\x65\x26\x00\xfc\x4c\x99\xaa\x3e\x01\x06\x73\x26\x4f\xde\xb1\xa4\x7c\x28\xe8\x0e\x5e\x9d\x7c\x7f\xd7\xac\x7b\x93\xb3\x1f\x59\x00\x3f\xc2\xb5\xb1\x5a\x78\xa8\x4c\xa8\x4e\x67\x94\x9c\x76\xf7\xda\x5e\xb3\xa5\x0e\x98\x72\xd7\x38\xba\x2b\x82\x0e\xf4\xeb\x05\xd9\xc9\x3b\xae\x8d\xfe\x5f\xbe\xc3\x5a\x3e\xa9\x7a\xdb\x51\xcc\x12\xab\x46\x8f\xf0\x04\xed\x9f\xf0\x98\x4f\xbd\xe0\xfe\x05\x3a\xaf\xfa\x6b\xbf\x12\x11\x62\x20\xb5\xef\xb4\xaf\x5d\x7a\x92\x14\x50\xa8\x16\x43\xcf\x55\x89\x35\xf8\x63\xa4\x4f\x5c\x43\x58\x97\x13\xab\xe4\xd5\xc5\x8c\xfb\xc8\xdd\xc4\x01\x84\x84\x2f\x68\xc6\x84\x83\xed\xcd\xd2\x84\x2a\x0c\xd1\x3b\xfc\x21\xed\x90\xbf\x1d\xf0\x86\x95\x71\x8e\x93\x55\xbb\xac\x5d\x28\x8f\x2a\xc3\x93\x32\xa3\x8a\xd8\xf3\x38\x93\xea\x81\x30\x45\x78\x75\xeb\xf4\x17\x48\xb4\x43\x03\xec\x3a\x7f\x6f\x8e\xd8\xc4\x75\x74\xda\x8b\x35\x99\xa0\xbe\xa6\x7e\x50\x0e\xea\xc8\xe1\x72\xea\x79\x53\x60\x14\x31\x32\xa0\xa9\x39\xc7\xf9\x0c\xfc\xdf\x83\x48\x78\x84\x93\x39\x26\xdf\x85\x6a\xf1\x21\xa9\x7c\xc6\x50\x93\xea\x9e\xe9\x8e\x8d\xdb\xae\xea\x50\x4f\xa5\x82\xb6\x8d\x07\xa9\x84\xdf\xb0\x05\x4f\xcc\x60\x4c\xfe\x5f\xab\x29\x82\x13\xd9\xab\x93\xee\x98\x85\x3a\xdc\x0a\x9f\xf0\x29\x39\x80\x9f\xc5\xaa\xe4\xc0\x07\x8a\x1c\xf0\xe9\x23\xcb\x86\xe9\x10\xe1\x5e\x13\xdd\xae\xb1\x51\xd4\x14\x1b\xa4\x11\x24\xbf\x0c\x1c\x32\xf0\x44\xae\xdd\x29\xad\x79\x6e\x43\x9c\xc5\xb3\xd0\x40\x38\xff\x06\x1f\x3d\x51\x6c\x06\xe7\x0f\x4f\xcf\x27\x3c\x7d\x46\x16\x32\x93\xb3\xe5\x65\xa1\x18\x4d\x8f\xa4\xd0\x46\x01\x6b\xe8\x02\x07\x77\xdb\x98\x51\xa7\xb0\xb9\xbc\x21\xd4\x95\xb3\xcb\x29\x62\xf3\xc9\x72\x36\xc7\xde\x08\xf0\x43\xdf\x55\xd7\x4f\xd1\x19\x9d\x7a\x4c\x2e\x43\xef\x03\x20\xf0\xd0\x4a\x01\x46\x01\x87\xc7\x0d\x5d\xba\xc3\x44\x27\x3c\x65\x3a\xca\x51\xf6\x93\xc1\xd0\xcf\xad\xef\x0f\x5c\xf9\xf0\xec\xf8\xa1\x0d\x27\x36\xa8\xd0\xde\xf2\x2a\x41\x33\xc2\x55\xaf\xd6\x37\x68\xa4\xb0\x6e\x34\x97\x4e\x53\x45\xe8\x5a\xbf\x32\x9f\x50\x37\xed\x82\xd5\x94\xd3\x77\x97\xd7\xec\xa6\xc5\x2f\xfd\x8b\xfe\xc8\x1e\x9e\x0a\x36\x02\x7b\xf4\x8d\xd0\xd4\x70\x3d\x85\xce\x34\x9f\x50\x1f\x87\xa2\x83\x76\x0d\x34\xf0\xaa\xd7\xee\xc4\xa3\xf9\xa2\xf0\x00\xcf\x58\x23\x16\x97\xff\x57\xd9\x41\x28\x00\xb1\x08\x22\xf4\xde\xb0\x27\x28\x71\xfd\xa8\x8c\xac\xe2\xd0\x18\xa9\x28\xf3\x09\x53\xe1\xec\xa3\x33\x80\xab\x06\x12\x6f\xe3\xec\xb7\x67\x8c\xad\x33\xe1\xba\xa6\x95\xc1\xf2\x9c\xbc\xb3\x9a\x87\x6e\x97\xa8\x84\x57\xbd\x9d\x5c\x63\x50\x0c\x8f\xf9\x04\xce\xc6\x36\xd4\xda\xba\x80\xd9\x1b\x7f\xd2\x96\xcf\x55\x57\xb7\x86\x94\xa4\x5b\x53\x4a\xb2\x26\x51\xfa\xd6\xd7\x6f\xf4\x86\x89\x0b\xfe\x9c\x53\x48\x0f\x51\x81\x47\x07\x36\x15\x95\x60\x87\x9b\x41\xa9\x77\xda\x9c\x35\x8a\xec\x4d\xf8\xbb\xae\x9d\x9f\x3a\x34\xb5\x24\x3d\x34\xb6\x24\xc0\xcb\xae\x5b\x70\xc0\xf8\xf7\x7e\xb1\x5a\x0f\xd2\xbd\xc5\x25\x69\x6f\x50\x57\x57\x8d\xa0\xae\x2b\xd3\x1a\x29\xab\x66\x5a\x57\xcc\xae\x32\xac\x3b\x3d\xbb\x87\xbe\x6f\xa4\xa3\x8d\x5b\x5d\xb5\x85\x90\x0f\xb0\x76\x29\x04\x98\xe4\xd4\x9f\x8e\xb5\x36\xef\xa9\x18\x92\x33\x69\xec\x7f\x22\xf3\xf7\x58\x32\x7d\x26\x0d\x7c\xb2\x15\x4b\x89\xaf\xd0\xe3\x42\xfa\xae\x09\xd8\x0f\xc4\xf2\x4d\x17\xa2\xb5\x12\xcf\x2f\xd8\x1a\xc3\xe2\x54\x10\xa9\xfc\x8a\x05\xeb\x42\xbb\x21\xe2\xb0\x82\xc3\xd8\xba\xd5\x38\xb1\xe3\xc4\xeb\x7c\xc7\x70\x6e\x28\xc8\xfe\xc2\x6f\x00\x6b\xb5\xc8\xa0\x40\x20\x2d\x15\x42\xde\x5a\x5d\xd3\xb0\x19\x4f\x48\xce\xd4\x0c\xfa\x64\x27\xf3\x3e\xb6\xaf\x8b\x5c\xc1\xab\xa3\x74\x89\x27\xd3\x81\x96\x40\x64\x83\x8a\xd5\xa3\x0a\x80\xe3\xa1\x58\xcb\x29\x58\x52\xff\x27\xf8\xa0\xff\x2f\x29\x28\x57\x00\x91\xeb\x62\xc7\xf1\x77\x2e\xfa\x12\x0f\x63\x47\x58\xf1\x2d\x51\x41\x18\x56\x32\xd9\xd1\x9b\x8a\xc7\x90\xdc\xcc\xa5\x46\x61\x18\xdc\x1f\x7b\xd7\x6c\xb9\x37\x5c\x21\xbd\xbd\x53\xb1\x57\x05\x86\x6b\xc4\x16\x84\x30\x64\x10\xee\xc1\x77\x7b\x1f\x4f\x57\xe9\x24\x6c\xfb\xe8\x55\xd0\x9c\x50\x4b\xba\x72\x36\x4f\x67\xcd\x7f\xff\x15\x0e\x14\xd9\xe7\x18\x13\x9c\x29\x86\xc5\x98\x60\x4a\x83\xa2\xee\x9a\xd9\x94\x82\x2d\x98\xdd\xac\x94\x6b\x87\x07\xe8\x53\x0c\xfe\xb5\x62\x12\xfd\xff\x8f\xe5\x99\x34\xde\x6a\xff\x97\x77\x7b\x21\xfd\xbd\xe3\x79\x99\x23\x6e\x96\xb1\x96\x42\xca\xa7\x1e\x37\xd8\x67\x36\xd4\xed\x85\xba\xd9\xea\xe8\xd8\x50\x35\x83\x0c\x47\x67\x2f\x78\x32\x9b\x65\x72\x42\x33\x92\x73\x61\x1f\x33\x26\x2f\xa4\x22\xec\x1d\xcd\x8b\x8c\x61\x3d\x1c\xf9\xd3\xe8\x3f\x52\x30\xe2\xa2\xe1\x43\xe2\xd7\xa2\xea\x8a\xf6\x0c\xa9\xb6\xea\x1f\x10\x52\x1d\x6a\x06\x58\x70\x5b\x68\xf2\xec\xc9\xb3\x27\x4f\x9f\x93\xf7\xc4\x0e\xfd\xcc\xfd\xf7\x2b\xf7\xdf\x3f\x91\xf7\xe4\x3d\x21\xe4\x9c\x90\xda\x7f\x09\xfc\x77\x44\xf8\x34\x9e\xc3\x33\x3b\xcd\x44\xe6\xee\x85\xc1\x93\x1b\xca\x56\x43\xbb\x41\x23\xdd\xd0\x50\x33\x94\xc8\x9c\xc1\x1c\x9e\xfd\x2f\x7f\x0f\x04\x5c\x0d\x76\x84\x84\x49\x1d\xc0\x94\x06\xe4\x06\x5c\x53\x39\xbd\x46\xb3\xec\x30\x31\x25\xcd\xec\xc3\x0f\xbe\x1a\x3d\x1d\x10\x29\xea\xb7\x2f\xb8\xb4\x2a\xb0\x9f\xe1\xc1\xb3\xc1\x78\x65\xca\x5f\xad\x99\x72\xa3\x39\xa2\x2b\x1a\xb4\x83\xde\x4e\x35\x9e\x60\x0e\xc5\xf2\x86\x2e\x03\xd9\x78\xb3\x74\xc6\x17\x01\x62\x3f\x82\xf2\x80\x98\x1d\x50\x01\xf7\xe8\x4c\x38\xe8\x92\x70\x33\x26\xa7\x66\x7f\xdf\xb7\xe2\xb4\x1a\xb3\xef\x05\x70\x1c\xa3\x4e\xc2\xc2\xc3\xa6\x3f\x6d\xe4\xf4\xb6\xc0\x38\xeb\xd5\x39\xfa\x20\x30\x7f\xf7\xf4\xca\xbf\xd1\x83\x53\x3d\x8c\xe5\x4f\xb0\x65\xfd\x72\x8a\x85\xbe\xd8\x18\x73\x0c\x5d\x4f\xdd\xda\xbb\x84\x11\x54\x9d\xdd\xe9\xe1\x3a\x58\x4f\x1c\xf2\xef\x93\xa8\xd3\x94\x42\x2f\x1d\x4f\x99\x62\xbe\xaf\x66\x9c\x5e\x14\xfc\x52\xe4\xe7\xea\x4e\x4c\x2b\x82\xf8\x2b\x0e\xf4\x77\x4c\x67\xdf\x9b\x94\xc9\x35\x33\x5e\xee\x28\xc8\x88\x28\x4a\x43\x26\x34\xa3\xc2\x6a\x30\x2b\x7e\x08\x23\x71\x30\xfc\x25\x10\xcc\x1a\x7a\xf9\xd4\xf1\x91\x95\xd3\xd1\x9d\xe9\xff\xdc\x1c\x32\x8a\xc8\x3a\x47\x61\xca\x68\xe6\x53\x29\x00\x66\x3f\x80\x86\x89\xfd\xfd\xea\x5c\xc1\xde\x20\xf3\xab\x1c\xac\x96\x2f\xd4\xf8\x3e\x39\xf0\xb9\x8f\xc4\xb0\x2c\x43\xea\xa9\xda\xd8\xda\x43\x16\xf7\xc5\xe5\x30\x42\x9d\x07\xac\xfd\x61\xbd\x99\x2e\x06\xf5\x2d\x67\x17\xcb\x50\xee\x3f\x84\x3e\xd2\x33\xbe\xb0\x2c\xe9\x5e\x2c\x03\xd9\xe2\x9c\x65\x05\x51\x2c\x2d\x13\x57\x04\x70\xcd\x6e\xac\x3e\x55\xbd\xa5\xeb\x4a\xe5\xc9\x75\xaf\xb6\xa0\x7b\x08\x33\x2e\xea\xec\x90\x4f\x81\x18\x7d\x73\x76\xb6\x60\x6a\x49\x0a\xa9\x35\xb7\x7b\x00\xe7\x08\x33\xe1\x40\xe9\x0a\xc8\x44\x90\x86\x05\xb3\xf2\x3c\x78\xcf\xf1\xdc\x3d\xcb\xa5\xb5\xac\x9d\x8d\x4f\x23\xe7\xfe\x64\x65\xcc\xdd\x72\xee\x1c\xfe\xb7\x2a\xef\x4e\xa7\x64\x0d\x01\x86\xb9\xd4\x28\xe7\x21\x22\xf0\x2b\x90\x54\x7f\x1a\x44\x92\xf0\x4f\x4f\xbe\x7a\xf2\xec\xc0\xce\xf5\xab\x81\x9d\x75\x4d\xc6\x3d\x0b\x32\x2e\xfc\xd2\xcd\x88\xe9\x9a\x94\xb3\xd6\x17\xa4\x3d\x42\x8b\x11\x07\x8c\xe5\x52\xe8\xec\x8c\xb4\x71\xc1\x36\x9e\x7b\xe6\x82\x64\x57\x51\xea\x8d\x84\x63\x03\xc2\x96\x1b\xf2\x45\x2e\x15\xfb\x22\xba\xff\x56\xe9\xd4\x5e\xe8\x74\xed\xbd\x9b\x71\x6d\xa0\x01\xef\x35\x5b\x3e\x58\xcd\xed\xe2\x5b\xef\xea\x59\x5f\x7d\x0b\x5c\x90\x9c\x16\x0f\x18\x07\xc1\x59\x3b\xf5\x39\x79\xe9\xbc\xb2\x6e\x28\xe7\x75\x44\x95\xc8\xf5\xc0\xc7\x42\xa9\x90\x4c\x3b\x61\x99\x44\xa8\x5b\x97\x37\xf0\x80\x3c\xfd\xd0\x5a\x40\x1b\xa9\xe8\x8c\x3d\x71\x8f\x7d\x2c\x2d\x45\x7e\x42\x34\xdc\x9a\x8b\x09\x6b\x19\x1d\x4e\xae\xcf\x67\xf6\xc1\x07\xe0\x02\x34\x81\x54\x40\x58\xc8\x1a\x18\x45\xdc\x9f\xf9\x71\xc4\xb1\x5a\x54\xce\x77\xf1\x9a\xd2\x1b\x7d\x92\x51\x6d\x78\xf2\x5d\x26\x93\xeb\x4b\x23\x55\x0f\xaa\xc5\xe1\xcf\x97\x2b\xa3\xd6\xf6\x54\x90\xc3\x9f\x2f\xc9\x31\xd7\xd7\x55\x87\x06\x84\x35\xad\x67\xdf\xd1\x00\xeb\xe3\x0a\x31\x48\x4e\xad\xf1\xc7\xbc\x81\x27\x02\xb4\x73\x7f\x67\xe5\x0f\xf4\x46\x33\x9c\xfe\xc4\x4e\xdf\x7e\xcd\xda\xb3\xe0\x8d\x81\x30\xe0\xeb\x9c\x1e\x6f\x20\xea\x35\xd5\x6d\x5b\xd7\x90\x15\x62\x8a\x7a\x48\x03\xa0\x51\x1d\xe6\x1b\xa8\x66\x29\x4b\x72\x43\xd1\x61\x05\x3c\x75\x4c\xae\x78\xf1\x9c\x9c\x44\x80\xb9\x58\x8d\x50\x1f\xca\xea\x1b\x01\xbc\xc4\xa5\x08\x00\x95\xad\xf6\x02\x3e\x41\x65\x4a\x3f\x27\x7b\xec\x9d\xf9\xf3\xde\x90\xec\xbd\x9b\x6a\xfb\x1f\x61\xa6\x00\xb0\xed\xfa\x7c\x58\xad\x4e\x4c\x99\xaa\xac\x17\xfc\xc1\x6a\xdd\x60\xff\x44\x4a\xae\x5e\x1f\xbf\x7e\x0e\xda\x7b\x2a\xc9\x0d\xf3\x9d\xf0\x7c\x15\xac\xe3\x86\xd1\x32\x40\x39\x47\x22\xf3\x42\xc9\x9c\x47\xb9\xaa\x70\xc8\xda\xd0\x3c\xe9\xc3\x59\x0a\x19\x69\xb0\xfd\xbd\x50\x10\xa4\xfa\xfa\x21\x1b\xcd\x05\x6e\xa3\x9f\xd3\x29\x91\xe8\x91\xaa\x27\xc8\x73\x1d\x6e\xb2\x14\xe3\x46\xc1\x96\x6e\x15\x8d\x58\xf5\xdb\x7d\xf5\x24\x65\x8b\x27\x3a\xa5\xcf\x86\xf0\x18\x24\x00\xd7\x40\x21\xcc\x89\x6a\xb2\xf7\x6c\x6f\x4c\x2e\x79\xce\x33\xaa\x32\xd7\x6b\xc6\x0d\x51\xdd\x67\xad\x01\x3f\x20\xf8\x54\x9f\xee\x91\x03\xcc\x50\x07\x9d\x22\x63\xbe\x5e\x39\xe0\x73\x80\x03\x7f\xd0\x4a\x85\x24\x3d\xf8\x2e\x48\x67\xff\x05\x71\x6d\xe7\x5e\x8b\xac\x75\x5c\xaf\x51\x52\xe5\xf6\x60\xcf\x40\x07\x37\x23\xa1\x7c\x80\xb9\x9e\xc2\xc8\x2a\x2e\xdc\x13\xab\x85\xe4\xc2\x69\x27\xd0\x32\x1e\xc8\x00\x07\xb8\x93\x58\xf6\xa0\xf4\x68\x6f\x6b\x64\x12\xe9\xa1\x94\x9b\x04\xd1\xd2\xcf\x7e\xbc\x11\xfc\xb7\x92\x91\xd3\xe3\xd0\xf7\x93\x29\xcd\xb5\xb1\x9c\x2b\xad\xe9\x08\x1c\x15\x87\x83\xc3\x9c\xfe\x47\x0a\x72\xf2\xdd\xa5\x9b\xca\x60\x0b\x17\xb8\x25\x03\xa4\xff\x29\x15\xb3\xaa\x51\x67\x3d\xec\xd0\x8f\xd4\xd4\xbd\xec\xe7\xe4\x98\x1a\x8a\x2a\x18\x72\x33\x59\x95\x97\xc2\x49\x98\x40\xda\x8f\xaf\x1d\x6e\xa9\x45\x93\xcd\xab\x41\x96\x82\xce\xda\xe3\x51\xd9\x9f\xbf\xb9\x38\xdd\x80\x12\x95\x80\x14\x9e\xbd\x92\x69\x4f\x9a\x14\x60\x7b\x1c\xe1\xa8\x24\xb7\xc3\x92\x33\x29\xd8\x10\x98\x1d\xb1\xdc\xce\xfd\xf3\x67\xc5\xcd\x43\xcb\x25\xab\xab\xb3\xf8\xf7\x3b\xd6\xcb\x5b\x5b\xe1\x7f\x16\x95\xc5\x03\x86\x03\x70\x15\xa7\x08\x4c\x32\x39\x21\x8e\x1b\x6c\xf2\x8d\xdf\x5c\x9c\xf6\xf6\xc2\x6f\x2e\x4e\xb7\xf7\x65\x7b\x34\x0e\x9a\xb6\x41\xa5\xbf\x55\xc8\xb1\x4d\xa5\xff\xfe\x1a\xff\xb8\x2f\x5d\x7f\x53\x2b\x7d\xcd\x45\xeb\x94\xb0\x3a\xeb\x38\xf1\xc5\x91\x2e\x4c\x03\xf5\xd8\xe9\x73\x92\x97\x99\x81\xda\x37\x20\x2c\x4b\x69\xda\x4a\x6f\x4f\x62\xc4\xe1\x40\x10\x72\xcc\x30\xb6\x90\x3e\xf7\xd9\x08\xe1\x17\xeb\x7f\xf0\x8a\x0a\x3a\xb3\xb7\x83\x3c\x24\x39\xfe\x19\x51\xf4\x01\x7a\xd0\x45\xf8\x8a\x2e\x28\xcf\xe8\x84\x67\xdc\x2c\xad\x1e\x37\x18\x7b\x45\x4c\x63\x21\xac\x9d\xf2\xc6\x98\x5a\xaf\x2a\x6c\x5c\x1c\x04\x0a\x26\x39\xb0\xe3\x3f\xb9\xb1\x8c\x7b\x30\xae\xb4\x57\x80\x22\x83\x2c\x79\x54\x71\x6b\xaa\xad\x87\x78\x68\x68\xb6\xdd\xc8\xb5\xad\x5a\x09\xdb\xfc\xa2\x25\x80\xf5\xaa\xda\x63\x47\x5a\xab\xf6\xc0\x17\x0e\x71\xe2\x33\xd7\x7c\xb0\x89\x58\x07\xdd\x07\x8e\x4c\xcb\xdf\x77\xd5\x7e\x76\xe7\xe5\xc3\x57\xb5\xc1\xbd\xac\x52\x8c\x20\x84\x43\x37\x72\xa4\xf1\x04\x5d\x3a\x56\xed\x91\x85\x40\xbb\xb2\xe7\xa6\x4d\x05\x05\x5e\x9d\xb9\x6b\xa0\xd4\x5e\x16\x02\x31\x57\x5a\x1f\x9c\x8e\xef\x93\xb0\x62\x3e\xed\x5e\x00\x79\xc4\x8a\xf9\x8b\xcb\x7a\x28\xc5\x7e\x46\x5e\x5c\xae\xe1\x7b\x98\x28\x63\xdf\x5b\x63\x80\x65\x5f\x93\x8c\x4f\x99\xe1\xad\x16\x61\xc3\x9c\x2f\x97\x82\x1b\xa9\xf4\x26\x0a\x3e\xdc\xa3\xfb\xd1\xbb\x2e\xfc\x42\x90\x57\x6e\x5c\xcc\xf6\x4c\x64\x96\xb1\xc4\xb8\xb6\x97\xb0\xad\xfe\xc1\xeb\x1c\x21\x2e\x15\x40\xfb\x3e\xd1\xce\xe9\xf1\x04\x49\xed\xc9\xc5\xc9\xe1\xf1\xab\x93\x71\x9e\xfe\x61\x2e\x6f\x46\x46\x8e\x4a\xcd\x46\xdc\x74\xd3\x95\x36\x58\x11\xd2\x83\x03\xda\xcc\xfb\xd9\xc0\x0a\x8e\xe8\x8d\xae\x00\xc3\x7c\xe0\x57\x49\x69\x56\x21\xc3\xa6\x65\x96\xe1\x9e\x1a\xc5\xd8\x30\x76\x27\x3e\x10\x50\xad\xba\xb6\x4b\x7f\xdd\x5f\xdf\x1b\xba\x7f\xd1\xbc\x2d\x87\xa1\xbb\x94\x6f\xab\x1a\x93\x3b\xd6\xfe\x32\x8c\xec\xb3\xf9\x2c\xe1\xdb\x9d\xb8\x66\x4b\x02\xa9\xfd\x53\xa9\x00\x66\xb3\x4e\x85\xcc\x24\xb0\x5c\x4f\xa0\xa7\xa5\xd3\x15\xb6\x64\xa9\xbb\x68\x11\xf0\x22\x17\x6c\xfa\x71\x16\xfa\x82\x4d\xb1\x7a\xc2\x27\x38\x3b\xeb\x82\x96\x66\x8e\x69\x90\x08\x7b\x84\xcb\xb9\x76\xe5\x5d\x39\xc6\x96\x2c\x75\xa7\x44\xfa\x3e\x8a\xbd\xba\x80\xf6\x93\x95\xfd\x8a\xdd\x84\x6e\x93\xcc\x83\xe3\x0a\x72\x61\x6d\x4b\x76\xf3\xe4\x46\xaa\x6b\x2e\x66\xa3\x1b\x6e\xe6\x23\x5c\x29\xfd\x04\x40\xd8\x9e\xfc\x01\xfe\xe3\xa2\xb5\x87\x69\xea\x32\xcb\x4a\xcd\xa6\x65\x86\x39\x5f\x7a\x4c\x68\xc1\x7f\x62\x4a\x43\xfe\xe2\x35\x17\xe9\x90\x94\x3c\xfd\xb6\xed\x8e\x91\x3e\x0e\x48\xfb\x26\x6a\x77\xca\x45\xe5\xd9\x8f\xa2\xa9\xd4\x08\xc1\x6b\x97\xa8\x46\xfa\x34\xcd\xb9\xd8\x16\xca\x6f\xab\xda\x73\x91\xb6\x5b\xc1\xfa\xea\x1d\xc1\x38\x75\xdd\x1e\xc7\xf6\x31\xe3\x90\x45\x43\xbd\x2f\x03\x7b\x6c\xb9\x7c\x9a\x7a\x36\xcd\xbd\x18\x4a\xbe\xd4\xbf\x65\x23\x7c\xca\xa8\x48\xab\x75\xdd\xa5\xc6\x3c\xe4\xfa\x98\xa9\x31\xfd\xba\xbf\x3f\x41\xc2\xcb\x47\xa5\x31\xb2\x53\x7b\x37\xb0\xd6\xdd\x35\xdd\x8f\xa0\x7f\x01\x08\xbc\xf6\x95\xc9\xa0\x5e\x21\xef\xf1\xbe\x2d\xec\x2b\x18\x50\x87\x7d\x8d\x51\x22\x85\x70\x80\x74\xaf\x0b\x26\x2e\x0d\x4d\xae\x3b\xc6\x45\x77\x3a\xd3\xef\x4c\x67\xea\x37\x57\xc6\xa7\x41\xa7\x81\x46\xb1\x84\xca\xa5\x94\x55\x59\xd2\x78\xb0\x1f\x21\xd7\x45\x78\xf5\x57\xb4\xe8\xee\x01\xf5\x23\x35\x14\xa5\xf0\xb1\x73\x7a\x42\x55\x4d\x21\x8b\x32\x43\xbc\x35\xae\xdd\x3a\x7e\x7a\xc5\xa6\xeb\x01\x77\xfa\x72\x7f\x39\x23\x15\x0f\xcd\x65\xca\xc8\x84\x9b\x8a\x3b\x6a\x66\xb0\x70\xd7\xa1\xd0\x48\x41\x12\x87\x34\x07\x5a\x87\xd5\x30\xdc\x84\x22\x8d\x44\x10\x99\x18\x5f\xf0\x17\x6a\x7c\x9f\x3e\x7d\xfa\x14\x2b\x2e\xff\xeb\xbf\xfe\x8b\x48\x05\xed\x1e\x12\x9e\xaf\xde\x08\x77\xfd\xe5\xd9\xb3\x31\xf9\xc7\xe1\xab\x97\x90\xfb\x5f\x18\x8d\x20\xe0\x38\xb2\xbd\xa1\xf6\x63\x3d\x24\xff\xfb\xf2\xf5\x99\x57\x1b\x75\xe3\x5b\x30\xb5\xc3\xeb\xd5\xa1\x17\x9f\xfe\xf5\xcf\x7f\x1e\x93\x63\xae\xa0\xf6\x89\xb3\xd0\xd6\x2b\x78\x4b\xa8\x62\x58\x21\x0a\xf8\x80\x5e\xaf\xe2\x01\x41\xdf\x81\x27\x60\xe3\x43\x2c\x66\xb4\x14\x98\xf1\xc4\x60\x99\x15\x32\xb2\xd0\x54\x19\x50\x1b\x1d\x0e\xaa\x4b\xd6\x85\xc9\x0d\x49\xc6\xaf\x19\x99\x6a\x68\x28\x5a\x55\xd2\xbb\x5e\x37\xae\xa4\x04\x07\xab\xf6\x4a\x33\xf3\xc8\x73\x3f\x3b\xf9\x82\x9b\xe8\xc5\xb5\x66\x6d\x50\xe7\x79\xcd\x96\x23\xa4\xb0\x82\xf2\x50\x30\x02\xc9\x71\xb5\x06\x0b\xc1\x6b\x93\x46\x7c\xc5\x03\x2c\x16\x4a\xfe\x1b\x37\x1f\x0a\x48\x23\x4e\x0c\x65\xa8\xd8\x60\x17\x90\x12\x44\xd4\xad\xc3\x17\xc1\xba\x8e\x5e\xfe\x63\x07\x13\xba\x8a\xb5\x9c\x71\x6d\x1f\x71\xcd\x96\xfa\xae\x27\x57\x8d\x62\x2c\x7d\x6a\xa4\x94\x52\xac\xfc\xda\xc1\xee\x3b\xce\xe8\x3a\x2c\x38\xb8\x9b\x6a\x0c\xac\xfd\x77\x55\xd0\xee\x5e\xbf\x4a\x61\x21\x6a\xe9\xca\x9a\x99\xd2\x2d\x0d\xe4\x9d\xdb\x67\x03\xfa\x3f\xbc\x61\x4e\xd5\x35\xf3\x7d\x85\x69\x36\x26\xe7\x76\x92\x01\x6f\x24\xb4\x75\x06\xbb\x95\x2e\xe1\xb1\x4e\x49\x83\x87\xec\x8f\xc7\xfb\x78\xf0\xa4\x22\xda\x50\xe5\x4e\x91\xfd\xfc\xf3\x80\xb0\x7a\x45\x0b\x8d\x90\x2a\x56\x2b\x05\xb8\x21\x09\x30\xad\x66\x5e\xf5\x14\xc4\xb5\xde\xc1\x4e\x91\x11\x2c\x4c\xeb\x01\xb6\x11\x72\xea\xca\xf1\x06\x23\xfd\xf1\xde\x0a\x20\xa4\xbc\x83\x52\x81\x57\x27\xd5\xc2\x61\xec\x66\xec\x51\xe9\x12\xeb\x7b\x6a\x38\x4e\x19\x69\x6b\x8d\x46\xa0\x8f\x55\x65\xc0\xab\x0f\xc5\x01\xaf\xee\xea\x03\x5e\x5d\x02\xba\x78\xad\x9c\xd0\x20\xa9\x50\x18\x4d\xab\xa5\x07\xc4\xf3\x22\x88\x78\x23\xb1\x3d\x88\x6f\x73\x23\x08\x9d\x68\x99\x95\x06\x7f\x5a\x7d\x19\x8b\x39\x18\xd4\x23\x2f\x81\x6c\x0b\xb7\x45\x42\x0f\xc4\x3d\xca\x89\x2e\xf2\x0f\xaf\xce\x6c\xa2\xb7\x16\xca\x9f\xb7\x57\xa1\xf3\x3a\x7b\xdd\xa9\x9f\x5c\x27\x57\x0c\x75\x33\x67\x2e\x0b\x21\xd2\xeb\x2c\xf3\xb4\x2c\x01\x94\x46\xaf\xa2\x61\xcb\xf2\x74\x23\x5e\xc2\x44\xf3\xee\x6e\x81\xcb\x53\x72\x10\x7a\x8d\x86\x74\xb6\x53\x61\x98\x9a\xd2\x84\x0d\x62\x77\x01\x2b\xe6\x2c\x67\x8a\x66\x21\x43\xd9\xd7\x29\xcf\xa9\x48\x33\x57\xbc\xcf\x14\x1c\x5c\xf6\xce\x30\x25\x68\x06\x8f\x48\x15\x5f\x30\xa5\xc9\xc1\x77\xcc\xda\x12\xd8\xa3\x74\xf0\x08\xd3\x48\xf1\x45\x36\xe1\xcc\x80\x07\xf7\x93\x00\x0a\x43\xad\x6b\x93\x58\x6d\x95\x07\x2c\xb2\xdb\xaa\x63\x37\xd0\xd8\x1e\x08\x90\x98\xc0\x74\xa1\x1d\x10\x46\x23\x7d\xf7\x3b\x40\x2d\x4e\x0c\x0e\x4c\xb5\xeb\x86\x07\x90\x30\x8e\x9f\x3b\xa8\x90\x8d\x95\x02\x7c\x92\xa2\x8b\xbb\x4a\x26\xa6\xce\x80\x94\x0b\x9e\x7a\x35\x08\xb2\x19\x2a\xc8\xad\x82\xea\xa8\x92\x9f\x6a\x2d\x5d\xb3\xcf\x68\x8f\xd0\x1c\x05\x65\xa9\x0e\x28\xed\x23\xc5\x71\xbc\x4b\x02\x2c\x6b\xab\x6e\x16\xa4\x17\x81\x28\x53\x76\x5e\x4e\x32\xae\xe7\x97\xbd\x86\x36\xce\xd6\x0c\x8c\x89\x81\x2b\xc9\x25\xb7\x86\x3b\x34\x13\x9a\xbb\xe6\x63\xa8\x66\x71\xab\x65\x4b\xd8\x06\xff\xeb\xf8\x74\x48\x28\x14\x87\x96\x66\xfe\xab\x68\x1e\x0e\xb9\x03\x7b\xe9\xa4\xec\x8d\x28\x6a\x9f\x27\x34\xcb\x74\xb3\x8b\xb4\x17\x64\xa8\x99\x7a\x34\x0f\xa4\x0a\x6e\x09\xc6\xcf\x1e\xb2\x66\x90\x8b\x05\x58\xd3\xb5\x2f\xa6\x49\x2e\xb1\xe2\x5f\x10\x29\xfc\x4d\xd0\x12\xc8\xff\x20\xac\x10\x82\x8d\x21\xd1\x6d\x10\x50\x72\x17\xd3\x79\x7c\x31\x9d\x5e\xa3\xc2\x97\xa1\x3f\x03\x85\x81\x47\x50\xd8\xe4\xbb\xcc\xd2\x50\xf8\x5f\x19\x8e\xe3\x0f\x85\x8f\x37\x16\xc1\xc5\xf9\x1d\x1a\x87\x09\xda\x8f\xdf\xf6\xa7\xc6\xa0\xa0\x8a\x59\xcb\x1b\x18\xd3\xc8\xd9\xd6\x49\x74\x92\x9c\x49\x1c\x8e\xf7\x2a\x3b\xab\x64\x3a\x88\x73\xfc\x70\x5f\x93\x54\x26\xa5\xb5\xb9\xaa\x65\xaf\x12\x26\xba\x41\xbd\x7f\x5e\xd8\xb3\xa9\xbc\x11\x37\x54\xa5\x87\xe7\xad\xaa\x56\xeb\xca\x59\x35\x56\xac\x7a\xfb\x47\x10\xfb\x39\x9d\xf8\x6e\xff\x01\xfc\x69\x17\xb8\x6b\x0e\xf1\x21\xef\x9a\xeb\x01\x7e\xbf\x38\x1d\xd9\x85\xfe\x76\xa1\xbf\xcf\x26\xf4\x67\x47\xaa\xb7\x49\xa9\xb1\x17\xe7\x90\xb5\x2b\xfe\x59\xc4\x90\x22\x96\x8a\xd2\xb3\x59\x0f\xdb\xd0\xf9\xf1\xf0\x56\x54\x17\xd9\x09\x9e\xe7\x82\x3a\xf6\x39\xc4\x9b\xb6\x20\x5e\x04\x6b\xd9\xc1\x18\xc4\xeb\xb6\x52\x31\x44\x6a\xc5\xc0\x73\x14\xc1\x2e\x64\xfa\x1c\x81\x53\xa1\x6d\x3a\x36\xec\x18\x3a\xd0\xe6\xa1\xf3\x5d\x88\xa8\x51\x38\xf6\x65\xf6\xea\x4f\x2f\x31\x81\x8e\x04\x40\x7a\x22\x02\x02\x84\x00\xab\x73\xde\x85\x1a\x48\x6f\x14\x61\xaf\xca\xd0\xe9\x3a\x52\x53\x81\xc6\x51\x3d\x21\xe8\x64\xce\x72\x6c\x1e\xfe\xc2\x2f\x81\xe5\x8d\xd6\x78\x30\x0c\x11\xd2\x98\xca\x35\x91\xd3\x61\x0d\x42\x61\x6f\xf1\x6c\xaf\x5b\x8c\x81\xf4\x17\x8e\x24\xfe\x1c\x9d\x77\x8e\xed\x90\xe6\x82\x9d\xd7\x42\x3a\xf6\x0c\x81\xce\x93\x61\xdf\xe2\x46\x96\x05\xc8\x0f\x5c\xe1\xad\x59\x9c\x6d\x89\xd5\x0e\x43\xd4\xe0\x11\x28\x7f\xbb\x58\xed\xe7\x18\xab\x8d\x04\xa3\x67\x74\x6e\x61\xe3\xf8\x6d\x1c\x12\xf0\x41\xdc\x09\xf3\x46\x8d\xb3\x61\x7c\x04\xd7\x87\x6f\xa5\xaa\xa7\x26\xed\x8f\xc7\xfb\xfb\x3e\xa8\xeb\xe8\xbe\x34\xd3\xd1\xd7\x84\x89\x44\xa6\x48\x2c\x76\x7c\xa5\x0d\xa8\x7b\x95\x97\x2d\x9e\x4b\xee\x9f\x15\xa7\x37\xc1\xd8\x7d\x6c\x75\x67\xde\xe2\xd1\xf8\x5e\x7c\x04\x25\xa6\x52\x5d\x02\xe6\x9f\x5b\xa2\x80\xe9\xec\x74\x18\xff\xbd\x26\x19\xcf\xb9\x6b\x1e\x66\x0f\x3a\xd3\x46\x93\x03\xfc\x70\x9c\x14\xe5\xd0\xdd\x30\xce\x59\x2e\xd5\x72\x18\x6e\xb2\x5f\xd6\x7e\xe5\xee\x18\x60\x13\x8a\x52\x29\x26\x4c\xb6\xfc\x9c\x35\x20\xbf\x88\x5b\xa2\x00\x85\x3d\xee\x82\xe4\x51\x5d\x8d\x9a\xb9\x10\xf1\x05\x6f\x79\x84\xb1\x1f\xc0\x5a\xf5\x30\x84\x24\xe0\x53\x26\x16\x64\x41\xd5\x03\xd1\xd3\xd7\x5d\x3d\xea\x3c\x29\x5f\x70\xdd\xb5\xb3\x1f\xb9\xdd\x09\x0d\x7d\xbb\x4a\x53\x94\xc6\x71\x74\x7f\x02\x3d\xd2\x76\x38\x79\x0d\xe5\xf0\xd9\x5e\xe7\x29\x15\xd4\x18\xa6\xc4\x73\xf2\x3f\x07\x6f\xbf\x7c\x3f\x1a\x7c\x7b\x70\xf0\xcb\xd3\xd1\xdf\x7e\xfd\xf2\xe0\xed\x18\xfe\xf1\xc5\xe0\xdb\xc1\x7b\xff\xc7\x97\x83\xc1\xc1\xc1\x2f\x3f\xbe\xfa\xfe\xea\xfc\xe4\x57\x3e\x78\xff\x8b\x28\xf3\x6b\xfc\xeb\xfd\xc1\x2f\xec\xe4\xd7\x7b\x0e\x32\x18\x7c\xfb\xc7\xce\x53\xa7\x62\xf9\xba\x23\x2b\xc4\x6b\xd4\xa3\x48\xae\x8f\xd8\x0b\xf9\x35\x5a\x2b\x70\x61\x46\x52\x8d\x70\xe8\xe7\xc4\xa8\xb2\x1b\x33\xa9\xc4\x4b\xdf\xe7\xbf\x52\x03\x2a\xc8\x79\xaf\xd4\x6f\xf8\x80\x43\xc4\xf3\x98\xf7\x50\x18\x7c\xe2\x46\xaa\x57\xbc\x18\x96\x17\x52\x51\xb5\x24\xa9\xf3\x66\x2e\xd7\x00\xfe\x44\x88\x3f\x9d\xd1\x74\xe1\x8d\x52\xae\x36\x50\x1b\xdc\x19\xc0\x87\xa5\xbc\xcc\xfb\x71\xc2\xff\x0c\xc8\xf3\x0e\xb5\xde\x27\x10\xe1\x03\x7c\xf8\x62\x42\x93\x6b\xb4\x97\xc2\xde\xa0\x96\x18\x83\x48\xef\xb9\xbc\x87\x9c\x51\x11\xdc\xf8\x90\xc9\x22\x53\x66\x37\xce\xdf\x8c\x63\xd7\x5c\xee\x18\x4e\x77\x59\x82\x55\x0f\x26\xa9\xc8\x2b\x50\x77\x36\xba\xd7\xa4\x17\xd8\x0e\xfe\x1f\xf6\xd2\xea\x78\x3d\xc1\xc5\x4b\x30\x26\x1d\x46\xd6\x14\xba\x48\x55\xe9\x5f\x35\xb5\x01\xf6\x2d\x9c\x39\x1f\x9c\xb5\xbb\x67\xe7\x84\x8a\x27\x78\x9d\x33\x8d\xb9\x28\x3c\x81\x46\x47\x60\x78\xc2\xea\x87\x1d\xbb\x8a\xba\x21\x96\xda\x3e\x49\x8a\xfa\x3d\xd5\x83\xb0\x0f\xd4\x04\x49\xc0\xf5\x36\x6c\x98\xcb\xf6\x9b\x4b\xbf\x2e\x91\xb3\x02\xca\x89\xbd\x6d\xa9\x4b\xb0\x40\xdc\x53\x9c\x1e\x2d\xa7\x90\x2d\x11\x35\xa4\xf1\x3d\x57\x56\xe8\x52\xf0\xac\x4e\x98\xbe\xd1\x42\x78\xf1\x52\xb8\x6c\xc1\x15\x2a\x5b\x4f\x64\xa5\x66\x6a\x34\x2b\x79\xda\x1f\x79\x3d\x3a\x9d\xa2\xa3\x26\xd1\x97\xfe\xd0\x8b\xd6\xd0\xbb\xae\x10\xf2\x31\x3b\xcb\xca\xbd\x93\x90\xda\x59\x13\x96\x71\x63\x88\x7a\x9a\x27\x0d\x0d\xbf\x3c\x33\xf0\xb9\x04\x57\xc1\x4f\xe4\x84\x68\xb2\x4c\x1c\xa8\x12\xaf\xf5\xa6\xc1\x61\xf1\x4c\x40\x45\xd4\xc8\xfe\x9f\xf7\x27\xf9\x10\xea\x84\x4d\x31\x8b\x09\x7f\x03\x6e\x00\x57\xc7\x95\xb2\x8c\x19\x28\xcb\x62\xa2\x6a\x77\xa7\x89\x62\xb9\x5c\xd8\x63\xf6\x56\x90\x37\xda\x05\xc3\xf9\xf4\x39\xa1\x83\x5a\x61\xb0\xeb\xb1\x2b\x18\x4b\xb1\xb8\x2b\xea\x9a\xa7\x4a\xa1\x87\x64\x32\xf0\xc9\xaa\x1a\x1b\x3b\x2a\xf0\x98\xb9\xf6\x55\xe0\xa4\x52\xcc\x2e\x00\xc0\x43\x29\x99\x13\x2d\x68\xa1\xe7\xd2\x80\x3f\x84\x16\x34\xe1\x66\x49\x8c\xa2\xc9\x35\x34\x87\x56\xcc\x3d\x6e\x48\x92\x81\x4b\x59\x8f\x97\xaf\x5e\x6f\x66\xe6\x4a\x96\xb3\x39\x14\x40\xe1\x5d\x49\x46\xb5\x7f\xfb\xb5\xbf\x77\x06\xba\x26\xe9\x52\xd0\x9c\x27\xa1\x6f\x86\x92\x0b\xae\xb9\x74\x61\x2c\x3f\xee\x79\xe8\x2e\x80\xa1\xb1\xa3\x8c\xf2\x9c\x1c\x68\xc6\x48\x20\x09\xfc\xe6\x12\xd5\x44\x74\x13\xaa\x7a\xa2\x9c\x03\x4f\x74\x08\x01\xf6\x93\x8a\xf5\x86\x3c\x04\x94\xfd\x76\xe6\x6b\x1f\x3a\x08\xdb\xb5\x7e\x4e\x52\x41\x12\x9b\xef\x78\xc3\x44\x2a\xa3\x74\x97\xc3\xf3\x53\x1d\x1b\xaf\xae\x4f\x20\x8e\x04\x5f\x64\x52\xcc\x62\x60\xb9\x8a\x32\x2d\x93\x17\xd0\xf0\x71\xc1\xd3\x92\x66\xc8\xde\xdd\x64\x8e\x2e\x4f\xf1\xe7\x7c\x36\x37\xa3\x1b\x06\xae\x4d\x94\x82\x55\x3a\xb4\x7f\x28\x5f\x49\xa3\xe5\x1a\xc4\x81\x71\x2e\x34\x74\x13\x43\x53\x45\xba\x04\x54\x5a\x97\xb0\x59\xcb\xb4\xf1\xe8\xec\x38\xc4\xba\x15\x87\xe9\x1d\x86\x0e\x80\x56\x03\x02\xdf\xaf\x5d\x62\xa0\xd4\xd5\xb9\x41\x3b\xc3\xaa\x97\x44\xf8\xd8\x44\xed\x44\xad\xb6\xdb\xc6\x70\xdd\xb0\x96\xba\xa8\xc8\xe4\x8a\xe5\x45\x46\x4d\x3f\x79\x23\x7b\x3f\x47\xbe\xed\x28\x32\x6c\x8f\x23\x15\xe9\x88\x66\x96\x22\xcf\x7f\x3a\x72\xd5\x69\x78\xc0\x6a\xb9\x69\x57\x55\x13\x4e\x54\x0e\x50\x4b\x5a\x7b\xb4\x00\xd2\x6c\xc2\x52\x60\x46\xee\xc9\xe0\x80\xb8\x11\xd8\x95\xd5\xfe\x71\xfe\xd3\xd1\x90\xf0\x31\x1b\xfb\xbf\xc2\xad\x9e\x1b\x1a\x39\xc3\xea\x85\x50\x15\x03\xf4\x0c\x53\x89\x3d\xbb\xf1\x6f\xff\xf5\x8d\x9d\xa4\xfd\xf6\xef\xa3\x6f\xa2\x3e\x3e\x7f\xff\x97\x65\xae\xca\xde\x50\xff\x34\x4e\x1e\x07\xbe\x67\xff\xfa\xd7\xb9\x4c\x2f\x0b\x96\x8c\xf1\xb5\xf4\xbf\x5c\x4b\x73\x26\x8c\x55\xad\xcf\x25\xa4\x8d\xf1\x14\xa9\x1c\x9e\xad\xd8\xbf\xbd\xf7\xdf\xf5\x03\x75\x8c\x24\xa1\x86\x09\x10\x00\xbe\x4a\x58\x48\x83\x3f\xc7\x4e\xa2\x30\xff\x83\x69\xdc\xdb\xd3\x48\x09\xc7\x1c\x59\xc9\xa1\x20\xec\x1d\xd7\x80\x09\x83\xef\x0a\xcb\x41\x5d\x66\xba\x97\x69\x76\x58\xbb\xc2\x01\x03\x08\x9a\x8b\xda\xb9\x7d\x21\xa4\xf9\x22\x6c\xbf\xcf\x3a\x04\xc1\x25\x09\x5d\x48\xc0\x9d\x00\xae\x2e\x48\x29\xc0\x6d\x5d\xf5\xe6\x9b\x2c\x49\xce\xb5\xa1\xd7\x6c\x4c\x2e\xad\xcc\x8a\xd3\x07\x70\xf5\x04\x81\xee\x2a\x2c\x25\xa5\x30\x3c\x83\x6f\xab\x71\xec\x94\x63\x59\x76\x3a\x25\xba\x4c\xa0\xfb\xac\x62\x23\x2f\x1d\xdd\x5d\x2b\x3c\xa6\x7a\x97\x61\xd8\xec\x39\x45\x73\xa9\x48\xe1\xa7\xd8\xcb\x56\x38\xf2\x5a\xc9\x95\xb6\xf3\x94\x22\xa9\x24\x22\x2c\x26\x34\x34\xb6\x42\x30\xf3\xd9\x3d\x68\xb9\xb9\x68\x80\x60\x09\xd3\x9a\xaa\x25\xb6\xfb\xe4\xa1\x2b\xa1\x4b\x63\x05\x49\x9d\x53\x51\xc2\x00\x8a\x61\xf3\xd8\x32\x81\xd5\xa1\x64\xa2\xe4\x35\x13\xa1\x3e\xc0\xee\x62\x3d\x49\xba\x4a\x09\x85\xe0\xbc\x24\xc9\x9c\x8a\x19\xab\x4a\xc0\x73\x9a\xc2\xda\xff\x18\x34\x2d\xff\x3e\x76\x05\xe8\xd4\x2a\x2c\xdc\xc0\x52\x4c\xac\x7c\x0a\x31\x8d\xb7\x82\x78\xa7\xc8\xb0\x0a\x3a\xd8\x57\xe2\x59\x2b\x9e\x48\xfa\xf1\x72\x77\xf7\x6f\x8f\x40\xa1\xd8\x60\x42\x76\xce\x0c\x4d\xa9\xa1\xbd\x25\x65\xbf\xa2\xa1\xad\xa5\xcb\xd8\x00\x72\x88\x32\x39\x9c\x8c\xf5\xaa\xa4\x2c\x78\x0c\x0a\x00\xdc\x60\xee\x77\x1f\xdb\xc1\x5b\xba\x76\x11\x45\xcc\xb5\x06\x5d\xcd\x75\x3a\x87\xe1\xfd\x68\xc8\xb2\x58\x4a\xd2\x12\xd4\xbe\x8a\xa5\x75\x89\x78\xf7\x12\x10\xb1\x1b\xdd\xdb\x2a\x5f\x55\x81\xfd\xa4\x9e\x78\xbd\x56\x41\x43\x59\xc7\x84\xe1\xd8\xb5\xdc\xa3\x38\xb8\xc5\x2f\x05\x1e\xd5\xc6\x36\xc0\x3e\xcd\x98\xd1\x55\xca\x24\x4a\x13\xcb\x22\x9d\x2c\x77\x4e\x04\x10\x35\x6e\x6b\x9c\x1d\xbe\x5e\x53\xc4\x8d\xd3\xd2\x49\x0b\x2b\xbf\x36\xbe\x33\xfd\x45\x86\xb0\xbf\xeb\x2b\x99\x76\x0f\x31\x35\x1a\x95\x56\x03\x57\x15\x24\x58\x4d\xa4\xc1\xc9\x83\x4f\x86\x80\xbb\xae\x61\x5c\xa0\x08\x98\xd3\x45\x7b\x5f\x69\xa5\x99\x8e\x42\x13\x32\x78\xdc\x08\x1e\x37\x7a\xd6\xd5\x2b\xdd\x3d\x25\xd1\x5f\x1d\x53\x13\xeb\x13\xea\x21\x0c\x61\x59\xeb\x65\x2f\x51\x82\x66\xa7\xc8\x20\x79\x5d\xc2\x45\x48\x72\x71\x65\xb2\x8c\x5b\x7e\xf9\x9c\x7c\x51\xd3\xb5\x9c\x4e\x1b\xec\x60\xac\x49\x3a\xf0\x86\xf1\xd8\x6d\xb9\x07\xdc\xaa\xdf\x3e\x68\x0c\x06\x4a\xde\x7a\x7b\xd1\xd7\x3e\x05\xc5\xdb\x2a\xc9\xd0\x62\x3e\x94\x9e\x5a\x32\x56\x32\xcb\x7c\x5b\x72\xb4\x8d\x1b\x29\x4b\xd0\x45\x07\x83\x20\xc3\xe0\x80\x08\x9a\xbe\x60\x37\x41\xa5\xa3\x1a\x71\x43\x7d\x08\x1e\x9c\x24\x3e\x8f\x6c\xdd\x78\xa1\x3e\xeb\x50\x2c\x71\xea\xc7\x61\xb3\xbc\x63\x81\xcc\xec\x83\xac\xee\x2f\xe8\x24\xc3\x44\x9b\xb0\xf0\x30\x17\x9a\xdd\xd0\xa5\x86\xf3\x55\xd9\x6a\xe1\xf9\x0e\x45\xbd\x1a\xf8\x82\x4d\x3b\xb4\x4a\x8f\xaf\xde\x82\xf4\xfd\x85\xe9\x01\x23\x85\x8b\xf6\xb9\xb7\xd5\x30\x2d\xba\x4b\x37\xaf\xfe\xa2\xfd\x90\xf0\x08\xd9\x4e\x7d\x84\x4d\xeb\x2d\x80\xce\x4f\x61\x60\x6f\xb3\xcd\xe0\x0f\x2f\xcb\x43\xfc\x6f\xc2\xec\x79\xab\x90\x9d\x80\x76\xe3\xdf\xae\x49\x07\xab\x88\xfe\x47\x68\x13\xe4\x02\x2d\xbe\xcc\xd7\x8a\x82\xc3\xf3\x53\x7c\xe2\x18\x1a\xc1\x52\xb1\x74\x5a\x96\x99\x73\x95\x8e\x0a\xaa\xcc\x12\xdd\x16\xc3\xda\xd3\x42\x89\x63\x0f\xcb\xd1\x6b\xc4\xb7\x4b\x1f\xb1\xf8\xaa\xed\x11\x2c\x9f\xdb\x1f\x1f\x22\xbb\x75\x67\xb6\x6d\x45\xba\x16\x5c\xfa\xab\x5e\xd5\x1b\x61\x83\x79\xaf\xc5\xa3\x58\x91\x34\x66\xc4\xfd\x4a\xe4\x46\x5e\x0a\x0a\x56\xd0\x97\x9d\x6f\x49\xc6\x05\x60\x41\x3f\x03\x43\xdf\x4e\x6b\x48\xf8\xd4\x8a\x34\x29\x46\xae\xda\x3c\x38\xc2\x9d\x8e\xe7\x13\x38\xd1\x68\xb7\x87\x15\x5d\x9d\xf1\xb3\xe2\x01\xc2\xe9\x26\x07\x42\x0a\x3c\xf1\x78\xef\x00\xf3\x57\x6f\xf1\xe5\xc2\x2d\x63\xf2\xf3\x9c\x89\x58\xdc\xc5\xce\xef\x61\x10\xbb\x5c\xa4\x76\xbb\x41\x16\x82\xed\xaf\xcb\x24\x61\x2c\x78\x8b\xe2\x4e\xe8\x15\x47\x72\x53\xce\xa9\x49\xe6\x4c\x13\x2d\x01\x0a\x54\x1b\x9a\x65\x95\x97\xc6\x2d\x97\x04\xcd\xc1\x7b\xcc\x23\x85\xa2\x56\xa4\xed\x1c\x56\x45\x46\x9d\x57\x64\x5a\x8a\x04\x33\xa4\xb8\x59\xfa\x19\xc4\x12\x1e\x7e\x06\xa6\xa9\x46\xe7\x0d\x9f\xa2\x9f\x36\x32\x31\xc3\x62\x02\x4b\x5d\x22\x13\xad\xcb\x7a\x07\x82\x67\xf9\xe7\x84\x26\xd7\x37\x54\xa5\x1a\xea\xcf\xa9\xe1\xd8\xe2\x6f\x58\x1b\xf6\x20\x9a\x83\x7d\x7a\x4d\x37\x18\x04\x43\x16\xda\x3b\xcb\xc6\x63\x08\x2d\x8d\xcc\xa9\xe1\x09\xb8\x68\xf8\x34\xf2\xba\xe7\xa1\xeb\x42\x88\x9a\x22\x2f\x07\xe9\xe0\x5e\x03\xac\x35\x85\xf5\x12\xe6\x46\x12\x9e\x5b\x9d\x8b\x42\xfb\xe2\x69\xa8\x36\xf7\xf1\x81\xbb\x66\x6a\x15\xcb\x9f\x21\x28\x13\xdd\x85\xce\x1f\x6b\x96\x6b\x18\x3e\x44\x00\x82\xeb\xdb\x95\x55\x0f\x1b\x2a\x91\xfb\x8d\xa5\x69\x3b\xd7\x88\x54\x87\x76\x7b\x6e\x98\xd5\xb4\xf4\x9d\x04\xab\xc7\xeb\x66\xc4\x67\x02\x2b\x70\xb9\xf6\xee\x02\x97\x52\x7d\x90\x2a\x59\x14\xce\xf1\x97\x0f\x9a\x33\x82\x38\x9b\x5a\x30\x0d\x31\x66\x9f\xa4\x6d\x97\x61\xc6\x04\x53\xd4\x80\xd7\xde\xe1\x06\xc2\xc9\x6d\x3e\xa2\x76\x60\xc6\xe4\xe0\x30\x2b\xe6\x74\x40\xde\xb8\xe6\xf5\x81\x72\x43\xce\xf7\xbd\x74\x51\x74\x23\x3a\x75\x74\xa7\x44\xde\x39\xcc\x4e\x89\xdc\x29\x91\x2d\xae\x9d\x12\xd9\xbc\x76\x4a\x64\x7c\x85\xb4\xe2\x7e\x15\xc8\x8b\x50\x27\x10\x65\x79\xc4\x79\x53\x55\x21\xc1\x6d\xfe\xbd\xd3\x29\xb9\x60\x89\x5c\x30\x85\x42\xe4\xe4\x5d\x41\x85\x55\x96\x5e\x50\x9e\x59\x11\xe2\x45\x49\xe5\xd1\x80\x1e\x36\x75\x7f\x7a\xe4\x44\x0a\xfb\xe1\x0e\x6b\xee\x26\xe5\x30\x2b\xec\xfd\x2e\x6a\x5f\x28\xb6\xe0\xb2\xd4\x3e\xbb\xab\x34\xc8\x2c\xb4\x71\x0a\xcd\x9c\xcf\x42\xef\xb8\x90\x7b\xa1\x58\x22\x55\x5a\x81\x4f\x69\x43\x4d\xa9\xeb\xd5\xa0\x09\x3a\xb0\xfb\xf3\x5d\x86\x75\xdc\x22\xe9\xd9\xa7\x9c\xc1\xf4\xb8\xde\xcf\xeb\xfe\x4b\x4c\xbb\xc3\x0f\x27\x8e\x0c\x7d\x26\x60\x95\x85\x68\x75\xdf\xd2\xb0\x88\x5c\x1d\x61\x3d\x78\x0f\x6b\xc8\x32\x4f\xb0\x7b\xf6\x28\x0c\x3b\xaa\x12\xff\x5a\x37\x1b\x8c\xaf\x1e\x77\x93\xf4\x0e\x81\x12\x5f\x8f\x2e\x4f\xb0\x7e\xf5\x56\x7f\x40\x3e\x4a\x0d\x02\xe9\xbf\x0e\x81\x7c\xfc\x5a\x04\x12\x6a\xc3\xfa\x3f\xf7\x17\xbe\x56\xad\x71\xf2\x9d\x58\xba\xeb\xe4\xd7\xb0\xd0\xc2\x38\x5c\x13\x99\x73\x63\x98\xcf\x16\x09\x27\x19\x7c\xfc\x71\xad\x8e\xe3\x39\xe0\x4c\xc0\x94\x10\xf6\x2e\x74\x73\x8a\x74\x55\xd0\x38\x6f\xb8\x06\x03\x89\x0a\x6b\xd8\x22\x24\x2d\xf0\x8e\x91\xcb\xed\xf5\xc6\xfa\x8e\x0f\x75\x1f\x77\xc7\x87\xe2\x6b\xc7\x87\x08\xb4\xc5\xca\xa0\x30\xa4\x57\xc5\xf8\x10\xd3\x48\xc8\x6f\x25\x53\x4b\x62\x95\xdb\x2a\x8f\x14\x1a\x5f\x69\x9e\xba\x4c\x4c\xe7\x8d\xec\x6a\x51\x6e\xa9\x5e\x07\xde\xd2\x93\x77\xd6\x36\x00\xfc\x82\xde\x39\x7d\xf3\x01\x75\x18\x22\xdc\x05\xbf\xc5\x35\x8b\x60\xec\x70\xc6\x23\x1b\xc1\x9a\x07\x87\x67\xc7\x7d\x9a\xf7\x7d\xe4\x07\x90\xfe\x72\x04\xc8\x6d\x84\xba\x6e\x89\x70\x29\xc3\x37\x20\xcc\x42\x1e\x47\xf0\x2e\x92\x6b\xb6\x1c\xba\x74\x29\xd7\xe9\xd0\xdf\x8c\x99\x87\xf5\x76\x2c\xdd\x60\xfe\xea\x57\xcf\x52\xa7\x4f\x7f\x20\x5e\x5d\xdb\x6f\xd4\xc7\xf2\x8b\xdb\x8f\x20\xec\x59\xb0\xf6\xd0\xa6\x23\xbe\x6a\x44\xea\xda\xe6\x40\x92\x3d\x50\x2b\x00\xff\xfb\x72\xa8\x40\xa0\x50\x02\x06\x1c\xb6\x1f\xf2\x22\x7d\xbb\xa4\xf0\xf2\xdb\xf8\x91\x16\x2b\x1c\xc1\x5a\xdd\xcd\x35\x5b\xee\x6b\x87\x84\x21\x85\x9e\xf3\xc2\xf7\x6b\x04\x3e\xe9\x4e\x25\xf9\x09\x12\xdc\xfc\x10\xc8\x11\x4f\xc5\x90\x9c\x49\x63\xff\x73\x02\x19\xbb\x18\x58\x91\x4c\x9f\x49\x03\x9f\x6c\xf5\x72\xe3\xab\x7d\xa4\xc5\x76\x71\x19\x0e\x71\x15\xcc\x4d\x87\x5a\x54\x9f\xc7\x09\x8b\xea\x52\x76\xc2\xc6\x70\x4d\x4e\x05\x91\xca\xaf\xaa\xf1\x6d\xa9\xb4\x1b\xc2\x7b\xac\xa3\x10\xd8\x9a\x31\xdc\x66\x48\x55\xdb\x8b\x3b\x86\x0b\xd1\x34\xee\xbf\x01\x8f\x36\x84\x1f\x43\xf2\x29\xb4\x46\xa2\x86\xcd\x78\x42\x72\xa6\x66\x80\x9a\x92\xcc\xfb\xde\xe2\xbe\xe4\x22\x5e\x3d\x4a\x47\xbc\x7a\xa5\x43\x50\x51\x5e\x42\x5a\xf1\xc7\x51\x7f\x70\x6c\x14\xd7\x39\x2d\x2c\x09\xfe\x1f\x2b\x95\x81\x0a\xfe\x2f\xb4\x5e\xd3\x63\x72\x48\x34\x17\xb3\x8c\xd5\xbe\x73\x3e\xcc\x78\x18\x3b\x82\xb5\x59\x7f\x2b\xf9\x82\x66\x0c\xcb\x00\xa8\x08\xfd\x52\xe4\x74\x45\xe9\x1a\xba\xfe\x6b\x96\x2f\x87\xc0\xfb\xde\x35\x5b\xee\x0d\x57\xc8\x76\xef\x54\xec\x55\x00\x4c\x35\x42\x0d\xca\x05\xc4\x64\xf7\xe0\xbb\xbd\x4f\xa3\xa7\x3d\x02\xd3\xb5\x37\x9a\x74\x6e\xe6\xa3\x8c\x6a\xdd\x07\x16\xcc\xed\xf8\xe6\x97\xd1\x93\xaa\xda\x6e\x57\x4a\xd2\xbb\x8f\x1c\x4a\x19\xfb\x4a\xec\xed\x61\x9d\x17\xae\x69\x74\x57\xb0\xb8\xa6\xcc\x09\xc3\x86\x52\xd7\x9b\x18\x09\xa1\xca\xc1\xb9\x65\xc5\x7f\x82\x68\x87\x9c\xc6\xbd\x26\xb8\x06\xf7\x13\xf7\xc5\xaf\x42\x1a\xc2\x45\x92\x95\x2e\xd0\x01\x3f\x05\xe7\x55\x3f\x86\x6a\x6f\xcb\xdb\x3b\x01\xff\x14\x86\xf5\x3a\xa7\xcf\x17\x5a\xa9\x68\x6a\xa6\x76\x40\x32\x4d\xc8\x94\xc0\xd5\xde\xe4\x6a\x4d\x5b\xd5\x6e\xd4\xdb\x91\x1c\xd5\xf5\xc8\x17\x7c\xa2\x18\x39\x9a\x53\x21\x58\x16\x61\xbd\x38\x47\x27\x35\x86\x26\x73\x8c\xc7\x51\x62\xcf\x71\xc6\xcc\xbe\xc6\x36\xf8\x39\x4d\xe6\x5c\x04\x80\x04\x11\x30\x8f\xaa\x02\xb1\x0d\x34\xf0\xe9\x6a\x08\xf5\xd8\xfb\x65\xff\xf6\xe6\x2f\x15\x70\xf8\xb4\x71\x4f\x85\xa0\xef\x4e\x39\xac\x35\x4a\x5c\xe8\x44\x02\xf7\xde\xdd\x3e\x26\x0f\xee\x69\x2e\xa6\x4c\x29\xdc\x93\x09\x73\x3f\x20\xbc\xd6\xdb\x75\xec\x7a\x4a\xcc\xe5\x0d\x49\x25\xb9\x81\x2e\xa7\x0b\xab\x1a\x40\x66\x91\xf6\x4a\x45\x34\x53\xc8\xf3\x4b\x64\x5e\x28\x99\x73\xed\x2b\x17\x1d\x41\x6c\x0c\xda\x24\x2b\x5b\x63\xc1\xde\x06\xe0\xf9\xe2\x88\x18\xaa\x66\xcc\xd8\xc1\x89\x28\xf3\x09\xeb\x08\xdd\xb2\x69\x98\xf0\x5e\xbb\x71\x44\x2b\xf5\x81\x26\x1b\xe4\xc2\x3d\x17\x41\x55\x20\xc5\x70\x2a\x95\x4b\x94\x0c\x5f\x3a\x2c\x78\x4b\x72\x3f\x39\xb9\x58\x0a\xa3\x3b\x42\xb3\x77\x69\xd2\x81\xdb\xff\xf3\xcf\x67\xfd\x60\xab\xaf\xa5\xad\x1b\xa9\xb2\xf4\x86\xa7\x98\x84\xa2\xc9\x81\x7d\xdc\xa0\xdb\x3b\x6f\x10\x5c\xbd\xf3\x41\xbe\xb9\xe1\xe9\xc7\x58\x6e\x9f\xef\x6c\x97\x9b\xc0\x7a\xf3\x94\x09\x63\xb9\xa0\xd2\xe4\x00\x1e\x3b\x20\x27\x1c\xab\xe3\xed\x5f\x88\x5a\x9a\x4f\xb8\xa8\x90\x17\x02\x41\x80\xe4\xb3\x7c\xc1\x5b\xe4\x9a\x19\xac\x6b\x86\xd2\x60\x69\xe6\x44\xf3\xbc\xcc\x0c\x15\x4c\x96\x3a\x5b\x76\x24\xe3\xc7\xba\xa5\xd3\x8c\xbd\xc3\xd3\xdc\x5d\x7f\x09\x43\xd5\xf5\x18\x48\x88\xad\xc0\x4c\x56\x14\x99\x2a\x65\x3b\x7d\x12\x94\x9a\x50\x9c\xcf\xde\xb1\xc4\x55\x6f\x15\x59\x39\xe3\xad\x0a\x75\x77\x8d\x07\x5b\xfd\xfa\x7e\x8d\x07\xab\xb6\x6a\xa5\x66\x15\x9a\x58\xb7\xc6\xde\x8f\xa3\x4f\xe0\x47\x55\x15\xaf\xd6\x37\x03\x4c\x59\xc1\x44\x0a\xe8\xe4\xd1\x89\xc3\xe9\x6e\x6c\xb5\x1d\x2a\x78\xdf\x72\xe1\xe4\x9d\x51\xd4\x32\xf9\xdc\xb2\x73\x0f\x3d\xce\xa7\x84\x8a\xae\x0c\xfb\x73\xe9\x5f\x45\x76\x7a\xe3\x83\x2f\xdd\x6b\x0f\xcb\x68\xc1\x6a\x3d\x2c\x7b\xee\x60\x89\xd2\xcf\x1d\x74\x5d\x2f\xf6\x5a\xd3\x69\xd2\x3d\xa5\x5e\x64\xd2\xad\xe3\xa4\x5e\xd3\x88\xae\x31\xab\x0d\x9e\xc9\x5d\xfb\xc9\xc7\xd5\x7e\x72\x0a\xf8\x49\xdd\xa1\x82\x5f\xe0\x38\x0d\xdf\x99\xfb\xd0\xe9\x9c\xf7\xf1\x95\xb9\x13\x15\x89\x57\xe8\x2b\xe3\x06\x72\x68\x04\x44\xdb\xdd\xa8\x0a\x10\x4a\x21\xda\x31\xed\x4d\x77\xe9\xa3\x86\x6a\x66\xba\x78\x74\x57\x8b\x35\xbc\x3e\x88\x63\x63\x73\x4b\x28\x9f\xf4\x20\x42\x64\xf4\x77\xa7\x39\x8a\xda\x9d\x56\x67\xf4\x0b\xed\xd1\x84\x59\x48\xdd\xc2\x31\x52\xbb\xbd\x09\x35\x1d\xfb\xb5\x77\x90\xb2\x6e\xb6\x6f\xde\x9c\x1e\xf7\xb2\x66\x76\xa0\xc6\x9a\x39\x1a\x04\xbc\x59\xfe\x5b\x19\xdb\xc0\x80\x74\x18\x56\xc9\xdd\xbf\x89\xa5\x98\x25\xac\x72\xc6\x1f\x73\x7d\xdd\x1d\xec\xfb\xfb\xa3\x93\xfa\x90\xf5\xc3\xfc\xfd\xd1\x09\x71\x9f\xde\xcb\x07\xfe\x10\x27\x78\x57\xcc\xe8\x59\xc2\xaa\xf0\x58\xca\xf5\xf5\x06\x80\xc2\xbb\x9a\xa7\x45\x7a\xd6\xae\x12\x72\x9b\xfd\xf9\x1e\x6b\x34\x02\xc1\x5d\xca\x92\xdc\x38\xac\x3d\x67\xc0\x5d\xf1\xe2\x39\x39\x11\xba\x54\xac\xca\x72\x6a\xda\x72\x56\x87\xba\xb7\x39\x07\x70\x86\xfa\x79\x6f\xfe\xff\xbe\xe9\xf3\x73\x09\x28\x14\x54\x19\xb0\xc1\x7a\xc2\x4a\x87\x56\xa8\x6e\x48\xbf\x08\x1f\x20\x9e\xd3\xa9\xaf\x53\x18\x3a\xac\xad\x00\x28\xee\x6f\xb2\xe4\x12\x81\x6f\xc6\x04\xf2\x22\x00\xde\x92\x27\x29\x5b\x3c\xd1\x29\x7d\x36\x84\xc7\xf8\xea\x3a\x53\x9b\x13\xd5\x64\xef\xd9\xde\x98\x5c\xf2\x9c\x67\x54\x65\xcb\x5a\x57\xaf\xea\x3e\x2b\x4c\xfd\x80\x90\x04\xf2\x74\x8f\x1c\x48\x05\x23\x27\x54\x90\x8c\x79\x7c\x02\x77\x7c\x97\x68\x3e\x0c\xb6\x83\x17\x92\xad\x89\xc6\x20\x5b\xec\x87\xbc\xde\xa0\x38\xaf\x41\xb8\x1e\x57\xf2\x8c\x0b\x2b\xe4\xc6\xe4\x8d\x93\x4e\x4e\xec\x23\x09\xc0\xa9\xf5\x77\x6c\xd7\x16\x6d\x8d\xcf\xa2\x9b\x27\x62\xd5\xd1\xb1\x6d\x0b\xdd\xd6\xdb\x31\xe3\xe6\x82\x15\xb2\x07\x15\x0d\x07\x6a\x78\xf6\xb9\xb1\x1f\x48\xcd\xa1\x13\x0b\x35\x84\x22\x23\x4a\xca\x8c\x5a\x8b\x0c\xfd\xfa\x63\x72\x7c\x72\x7e\x71\x72\x74\x78\x75\x72\xfc\x9c\xf8\x91\x78\xac\xd3\x8f\xc9\x55\x8c\xc2\x1c\x95\x7c\x39\xa8\xdb\xf0\xac\xa1\x63\xac\x54\x54\x6d\x24\x00\x95\x92\x0a\x72\x2a\xb8\xa9\xba\x63\x61\x12\x7d\x26\x85\x4b\x8b\xb7\xbf\x76\x71\x85\x19\xc7\xe4\x4d\xe1\x06\xb3\x5f\xd7\x47\x83\x13\x8a\xbd\x64\xc2\x54\x5a\x79\x37\x36\xac\xdb\x55\xdb\xb3\x09\x2b\xd3\x37\x82\xe9\xe5\x90\x5f\x61\x40\xb6\xea\xfc\x83\x12\x35\x34\x34\xf4\xa8\xb2\x52\xd5\xfa\x0d\x8e\xc7\xfb\x63\x62\x65\xf5\xfe\x78\xdf\xab\x72\xd9\x4a\x53\xcc\x30\x68\x0c\xde\x5d\xa7\xef\x31\x21\xaf\x7d\x19\x21\xa0\x31\xad\xef\xaf\x89\x10\x84\x51\x37\xc5\xc6\x29\xf1\xa5\xec\xe5\x24\x7e\xa8\x43\xfb\x9e\xf1\x05\x13\xf8\x62\x9b\x63\xcc\x7e\xaa\xbd\xec\xda\x45\xf5\xe6\x6f\x2e\x5e\x6e\xee\xa5\x90\xb3\xf4\xf2\x4a\x47\x32\xcf\x11\x87\x7a\x1e\x50\x54\x2a\x20\x94\xc0\xf5\x36\x62\x9c\x23\xfa\xf6\xb4\xd5\x81\x6d\x70\x7c\x3f\x54\xc3\x18\x0f\x1f\xbb\xba\x5e\x51\xd9\x43\x0f\x6f\xc5\xe5\xe0\xdf\xb5\x07\x14\x75\xe2\xf3\x49\x78\x8f\x27\x17\x27\x87\xc7\xaf\x4e\xc6\x79\xfa\x08\x99\x2f\x13\x69\x21\xb9\x30\xba\xad\x61\xde\xae\xa5\x77\x57\xb6\x1d\xa6\xdd\x8f\x6e\x76\xe2\x87\x8b\x13\x3d\xfd\x33\x22\x3c\xff\x94\x19\xca\x33\x1d\x51\x98\x91\x85\xcc\xe4\x6c\x7d\x67\xaf\x07\x90\xce\x1f\x10\x11\x76\x44\x47\x96\x26\x37\x67\xb1\xb6\x6f\x07\x5c\x5f\x51\xdf\xfe\xd7\x2e\x64\xb5\x5a\xc1\x12\x84\xae\xbd\x9f\xc1\x82\x7d\x42\x13\x61\x65\x15\xd1\x27\x03\x2c\xce\xb7\x5b\xa8\xfa\x17\x44\x4d\xc2\xef\x6b\x3b\x6c\x66\xf1\xdb\x9a\x0d\x96\x9b\xb7\xed\x46\x5f\x5f\xf5\x1f\xdc\x48\x75\x21\x52\x28\x36\x0a\x30\xd1\xd0\xa5\x5a\xaa\x48\x07\x8b\x65\x8a\x77\xe2\x7a\x97\x2f\xde\x95\x2d\x9b\xce\xdc\x4a\x4b\x0f\x3e\x74\x44\xe2\xcb\xb2\x65\xd5\x04\xc4\xb9\xb4\xe8\x0c\xe1\x9f\x95\x8b\x94\x15\x8a\x2f\x78\xc6\x66\xd0\xe0\x87\x8b\x59\x84\x61\x14\xa3\x1e\xb9\x86\x3f\xf5\xa8\xd1\x2b\xfb\x57\xd4\x64\x0e\x28\xeb\xec\xf5\x15\xf4\x8a\x82\x54\x98\xce\xc6\xa4\x7d\x20\x34\xd4\x1e\x8d\x46\xe0\xbf\x3b\xf8\xb7\xb5\x6a\xd2\x6c\x40\x7e\x66\xee\x39\x12\x9a\x59\x29\xe8\xd6\x3e\x97\xa1\xb3\x10\xcc\xb5\x5a\x59\x20\x68\x4c\x8e\x73\x77\x3d\xb1\x77\x5a\xf5\x19\xc5\x79\xed\x7e\xce\x00\xa2\xba\x8a\xf9\x3f\x46\x0b\x68\x43\x42\xb4\x67\x6e\xef\xe3\x44\xeb\xce\x48\x88\xeb\x17\x4e\x2e\x50\xa2\x97\x79\xc6\xc5\x75\x85\x89\x3e\x95\x96\x8e\xb1\xae\x97\x8b\x6b\x7f\x6a\x14\xa3\xd9\xed\x12\xa3\x0d\x8d\x6e\x4c\x5a\x98\xde\x42\x09\x57\xcb\x02\xf3\xd8\x02\xf3\x72\x49\x56\x31\xab\xdf\xdb\x7b\xd4\x2b\xc6\x75\xa2\x79\x77\xf6\x7e\x7a\x79\x74\x79\x5a\xe3\xed\x82\xe0\x67\x9f\x32\x60\x77\x9b\x70\x85\x97\x7c\xd4\x16\x04\xff\xad\x5d\x86\xd3\x88\x64\x65\xdb\x5f\x62\x12\xf5\xb9\x54\x86\x66\x1b\x60\x9c\xc9\x9c\x16\x87\xa5\x99\x1f\x73\x0d\x50\x85\xfd\xa8\x7f\x37\x73\xec\xab\xe6\xdb\x48\x70\x4f\xa4\xf8\x0c\x72\xf4\xc3\xe1\x39\xa1\xa5\xa5\x3a\xe3\x5a\xe6\x6c\x2c\x3d\xcd\xaf\xc0\x25\x96\xfc\x7e\xc4\xf7\x77\x4f\xd8\xaa\xb7\xdf\x05\x85\x3f\x7a\x50\x18\xf8\xe2\xe7\x12\x08\xe6\x82\x1b\x4e\x8d\x54\xbd\x45\xeb\x8e\x4a\x6d\x64\xee\x8e\xc8\xa9\x1f\x1e\x72\x9c\x40\xd5\xaa\x3d\xb1\xde\xf4\x15\x0c\x45\x58\xde\x53\x61\xcd\x3a\x9a\xb0\x46\x9d\xc9\x10\xba\xd2\xe0\xd8\x3c\xdc\xf3\x8d\xab\x36\x02\xb8\xf5\xec\xef\xcf\x6b\x1d\x1b\x57\xda\xea\x7a\xa7\x63\xd5\xb3\x75\x63\xde\x62\xfe\x5b\x3f\xfc\xc9\x39\xf7\x71\x5d\xfe\xbb\xa4\x19\xae\xe7\xd9\x26\x3d\xe1\xf5\x7d\xec\xe5\x35\x3d\x4d\xf9\x7d\x3f\x0b\xde\xaf\x52\x23\x62\x3c\xde\x61\x14\x15\xda\x12\x43\xdd\xbf\xb0\xef\x52\x0c\xf6\xc9\x81\x49\x8a\xc1\xc6\x56\xa6\xaf\x6a\x4e\x7c\x59\xb7\xf7\x2f\x43\x15\x67\xb7\xf7\xda\x78\xde\x00\x9c\xe1\x7e\x9c\xa7\xb5\x05\x42\x95\x8c\xbc\xe4\xda\xf8\xe6\xb4\xf0\x01\xd7\xae\x9b\x17\x68\xdf\xe7\x44\x2a\xc2\x8b\x7f\xd2\x34\x55\xcf\x51\xd6\x3b\xeb\x10\xfe\xad\x03\xfa\x3a\x15\x21\x63\xe5\xc0\x2c\x0b\xd7\x34\xe2\xea\xe8\x9c\x60\x13\xea\xaf\xff\xfa\x14\x34\xf1\x3f\x7d\xf5\xd7\xa7\x1d\x49\xed\xb1\x56\xc7\x91\xbe\xbd\x90\xbd\xe7\x29\x7c\x26\x35\x14\xa0\x80\x62\xf5\x04\x48\x37\xc7\x05\x91\xee\x2d\x11\x06\x99\xdb\xa7\x9a\xba\xab\x37\xf8\x1d\xd5\x1b\x90\x50\x30\x8e\x7c\xf4\x63\xf1\x67\x64\xcd\xe7\x8f\x85\x35\xb7\x5c\xcd\xb6\x94\x5b\xa7\x58\xe4\x6e\xfb\xfb\x3a\xce\xe5\x80\x7a\xca\xe3\xb3\xcb\x7f\xbe\x3c\xfc\xee\xe4\x25\xbc\xa7\xcb\x86\xb7\xa4\xe8\xcc\x92\x36\xb9\xdb\xf7\x27\xed\xf6\x9e\xa2\xb6\xcb\xd9\x47\xc4\xfe\xec\xc5\x65\xc3\x15\x67\x3f\x79\x60\x98\xbe\xab\x6d\x29\xa6\x1d\x56\xef\xb1\x05\x09\xa0\x41\x37\x53\x9b\x29\xee\xee\x39\xc2\x10\x01\xa8\xd7\x9c\x1a\x96\x86\xf0\x1d\x3b\xfb\x1d\x5a\xd2\x06\xd9\x3a\x35\xee\xee\x60\xb2\x5d\x31\x5c\xc5\xde\xc3\xc8\x9f\x74\xb5\xbb\xa9\x87\xaa\x2f\xe4\x81\xfd\x4b\x18\xcb\x27\x3c\x58\x16\x86\x79\xd4\xca\x4a\x54\x2b\x4b\x99\x0e\xad\x7c\x3f\x03\x6a\x2d\xd6\x75\xb1\xeb\x2e\x1d\xd6\x36\xc7\x73\x0d\x9c\x7d\x13\x9f\x28\x44\x5f\xab\x5e\xbe\xad\x17\xa4\xcf\x65\xa4\xce\x55\xa5\x0b\x9a\xf4\xda\x47\xbc\xfa\x08\x3f\x01\xa0\xb7\xc7\x28\x60\x60\xe2\x1b\x2a\xb3\x0a\xcf\xee\xe7\x38\x1e\xf9\xe1\x9a\x60\x20\x0f\xa2\x12\xdf\xfb\xba\x90\x1e\xec\x25\x46\x0d\xd9\x4a\x12\x22\x5b\x27\x87\x7e\x6e\xe9\x40\xd8\xa4\xf3\xa0\x98\x4b\x23\x45\xcf\x25\xa4\xe7\x6b\x06\xad\xf3\x33\xbc\xe3\xa8\x6a\x2a\x5f\xd1\x05\x56\xd8\x84\xd0\xb4\x35\x38\xbc\xc4\x96\xc2\x07\xa9\xeb\x21\xea\xc7\xc7\x80\x8a\xf4\xf4\x78\x03\xbc\xe7\xf1\xc3\xf0\x3c\x34\x38\xb7\xb1\xf4\xd2\xb4\xa7\xba\xf4\xd3\x63\x67\x0b\xf8\xda\x73\xed\x0e\x0f\xb9\xfd\xf4\x6c\x44\x4f\x92\xca\xdc\x48\xd5\x17\x7c\xd9\x79\x6d\xb8\x46\xbe\xa2\xfb\x6e\x05\x4f\xe2\xf3\xe4\x15\xf8\x96\x8f\x9e\x5f\x5c\x42\x22\x57\xa3\x5b\x66\x93\x43\x84\x4a\xdd\x8f\xc0\x44\x1e\x0f\xf3\xe8\x55\x2b\xf9\xb8\xb0\x51\x1b\x33\x69\xfd\xa9\xe8\x65\x8d\x7e\x72\x83\x39\xd7\xa6\xa5\x8f\x8a\xdd\xd2\xc0\x8c\xdc\x43\x37\xc2\x5e\x95\xb4\xec\xa7\x1d\x17\xa9\x0b\x14\xc3\x72\x8d\xad\xfc\xb2\xcc\xee\xa7\x14\x71\x13\x40\x07\x2e\x35\x24\xd8\x47\x2f\xa7\x85\xeb\xa4\x9e\xca\x1b\x71\x43\x55\x4a\x0e\xcf\x4f\x3f\x3d\x13\xed\x5c\xfc\x88\xa7\xa0\x0b\x26\x7d\x6d\x15\x01\x85\x7e\xc2\x8d\xc6\x6c\x76\xc8\x47\x37\xb1\x0f\xc9\x0a\xa0\x90\x21\x62\x59\x98\x65\x57\x6e\x16\x91\x8e\x24\x88\x4c\x0c\xcd\x7c\x23\x5e\xd7\xcb\xff\xe9\xd3\xa7\x18\x52\x78\xfa\x5f\xff\xf5\x5f\x04\xba\x2e\xa6\x2c\xe1\xf9\xea\x8d\x70\xd7\x5f\x9e\x3d\x1b\x93\x7f\x1c\xbe\x7a\x49\x68\x02\x16\x18\x42\xaa\xe2\xc8\xb0\x77\xf1\x8f\xf5\x90\xfc\xef\xcb\xd7\x67\x55\x2b\xfb\xfa\xb7\x40\x1a\xb9\x7f\xbd\x31\x39\x8e\xd2\xcf\x63\x97\x3f\x35\x73\x48\xc9\x17\xd2\x10\x3a\x9d\x02\x71\x22\x4b\xe6\xda\xb3\x0b\x8f\x8b\xc6\x67\x73\xdf\x89\xdc\x92\x55\x06\x79\xf1\xdc\x4e\x11\x42\x2c\x1e\x4a\x10\xd3\xfc\x61\xac\x20\x1d\x60\x2a\x43\x92\xf1\x6b\x46\xa6\x1a\xfa\x91\x57\x4d\x34\x14\xd3\xd6\x7e\x4a\xa8\xb0\xa3\xe3\x60\x61\xea\x76\x12\x8f\x3b\x77\xa1\x63\xe7\xea\x1a\xc1\xfa\xc6\x70\xbe\x2e\x09\xf9\x89\x5d\xf6\xc7\x9a\x4b\x50\xd7\x17\xc3\xfb\x20\x15\x39\x28\xbe\xc0\x36\x09\xcd\xa4\x98\xc5\x44\x57\xe9\x11\x3e\x01\x71\x59\xb0\xb6\x8b\xd1\x53\x37\x95\x7e\x7a\x93\x21\xe7\x7e\x45\x8b\x6e\xed\x21\xea\xa1\xd5\x08\x0a\x91\x4e\x64\x69\x7c\xca\x1b\x3e\x09\x20\xb0\x00\x23\x11\x17\xbc\xd3\x83\x7b\x6b\x4c\xd3\x5f\xab\xb7\x9e\xfa\x2c\xd5\x05\x71\x4d\xd9\x1c\x12\x46\x93\x39\xb9\x66\xcb\x11\xb2\xf8\x82\x02\xfa\x01\xac\xf3\xb1\x5d\xdd\x5a\x9f\xf5\xaa\xd9\xbe\xb5\x03\xdd\x26\xf8\xcc\xc4\x8a\xea\x03\x7a\x82\x37\x95\xb4\xd3\xa8\x5d\xdf\x22\x11\x39\x0e\x7d\xa3\xc2\x44\x0a\xe3\x9a\x20\x86\x46\x45\x90\x69\xd9\xa8\xb0\xb7\x1c\x85\xa5\xf6\x67\xfa\xae\x27\x57\xe9\x98\x56\x64\x38\x65\xa2\x14\x2b\xbf\x06\x24\x70\xc8\x7b\xd5\xcc\xe1\xf9\x50\xdf\x00\x2f\x4a\xe9\x9c\xf3\x04\xaa\x6a\xec\xed\xee\x5e\xbf\x4a\x61\x21\x6a\x08\x00\x9a\x99\xd2\x2d\x0d\xe4\xd2\xda\x67\x33\xad\x09\x87\x37\xcc\xa9\xba\x66\x1e\xcc\x96\x66\x63\x72\x6e\x27\x19\x70\xca\xb1\x6f\xdc\x02\x8b\x20\x2c\x4f\x89\xa1\x0d\xec\x43\xf6\xc7\xe3\x7d\x94\x85\x6b\x80\x0e\x3a\xd3\x4b\x9f\x2d\xc3\x7a\x6b\x15\x56\xd7\x83\x68\xa1\xb1\x75\x9a\xb5\x0e\xa0\x3d\xa1\x04\xdc\x11\x33\xf7\xda\x02\xed\x08\x3e\x1d\x5f\x3d\xf7\xac\xea\xb7\xed\x65\x7f\x4d\x2f\x3b\x84\xc0\xeb\x57\xdf\xcd\x2e\x7b\x6c\x75\x59\x4f\x38\x76\xfc\xa7\x92\x20\x7d\xf5\xdd\xeb\xbd\xb1\x62\xde\x43\x5b\x2b\x7f\xdd\x86\x5c\x9c\xdf\xc7\xba\x00\x45\xdb\xf2\xf2\x47\x65\x4e\x9c\x4e\x81\x87\xae\x47\x6b\x89\xac\xb4\x20\x52\xec\x0a\x6c\xde\x8e\xe8\xa3\x57\x3c\xe9\xc9\xb0\x68\x5e\xdd\x0d\x8d\xe6\xd5\x25\x99\xa5\x79\xad\x9c\xf3\x20\x53\x8b\xa8\x94\x16\xb6\xc8\x48\xe8\xc1\x68\x02\x33\x18\x93\x57\x4e\xe6\x22\x71\xd3\x89\x96\x59\x69\x02\xac\xc2\x1a\x81\x0c\x83\xfa\x8e\x8d\x08\x37\xe4\x6f\x8b\xc4\x33\x28\x26\x28\xb3\xfa\x91\xd4\x78\xf5\xc8\x6c\xba\x26\xa3\xe2\xf5\x3b\x4b\x49\xc5\xab\xc7\x5d\xf0\x7a\x61\xcf\x3b\x71\xe9\x30\x25\x7d\x1d\x60\x4d\x7b\x85\xb4\x54\xa3\x51\x35\xf6\x8a\x28\x36\x3c\x6c\x8b\xb6\x5c\x5d\xdd\x1d\xaf\xee\x75\x9c\x37\xf0\xf0\xfc\xf4\xa3\x5b\x99\xd1\xb3\x76\x76\xe6\xbd\xae\x35\x0e\x5f\x00\x22\xf0\x4e\xa0\xe3\x6a\x45\x5d\x80\xcd\xf2\xdf\xdf\x81\xb9\xb2\xf2\xe2\x2f\xac\xdc\x89\x82\x52\x8d\x96\x0f\xe8\xc1\xad\x24\x54\xd4\x26\xc2\xa7\xcb\x00\x37\xfb\xfc\x4d\x9b\x2d\x35\x48\x60\xf5\x3b\xd4\xbd\x34\xaf\x66\x62\xa9\x5b\x44\x72\x09\xbd\xf6\xd1\x7b\x12\xb9\x61\x0a\x99\x3e\xc7\xa6\xcd\x54\x08\x69\xb0\xc7\xfc\x10\x9b\xf5\xeb\x21\xba\x57\xac\x92\x19\x25\x5a\xa9\x28\x84\xd9\xb3\x5a\xd9\x1b\xf1\x90\xde\x09\x88\x00\x11\xc1\xda\x9d\xf7\x43\x49\xe4\x23\x50\x93\xbd\x2a\xad\xa4\xcf\xbe\xea\xf5\x70\x23\x8e\xef\x89\x48\x27\x73\x96\x53\x6c\x70\xe1\x17\xc8\xf2\xeb\x1b\xc5\x8d\x61\x88\x7f\xcd\x54\xae\x89\x9c\x0e\xbd\x89\x84\xa8\x27\x8b\x67\x7b\xfd\xf5\xa7\xff\x08\xb6\x32\xf1\x27\xb4\x2d\x7c\xd5\x6d\x57\xdd\xf7\x5f\xb3\x23\xec\xe9\x04\x83\x39\x83\x8e\x3b\xa2\xe1\x84\xb4\x4a\xc4\x02\xd7\x7f\xab\x97\x6e\xfb\xdc\x0c\xc3\xa0\x8c\xee\xdc\x0c\x3b\x37\x43\x1f\x23\x7e\x34\x37\x43\x24\xb8\x3d\x33\x75\x1b\x10\xbb\x1e\x62\xfc\x77\xef\x7f\xa8\x70\x1d\x22\x2c\x63\x4b\xf2\xde\xf3\x20\x55\xdd\xff\xbf\x3f\x1e\xef\xef\x7b\x7f\x84\x3b\x1f\xa5\x99\x8e\xbe\x26\x4c\x24\x32\x45\xa2\xb2\xe3\x2b\x6d\x40\xa9\xad\x0c\xf0\x78\x2e\xb9\x7f\x56\x1c\x43\x80\xb1\xfb\x25\x89\x1e\x39\x94\xcf\x19\x79\xf1\x51\x55\xb0\x4a\xf1\x0a\xf0\x55\x6e\x01\x03\xca\x9f\xd3\xc0\xaa\x1c\x96\x8c\xe7\xdc\xe1\xea\x59\x76\xc1\xb4\xd1\xe4\x00\x3f\x1c\x27\x45\x39\x74\x37\x8c\x73\x96\x4b\xb5\x1c\x86\x9b\xec\x97\xb5\x5f\xb9\x3b\x06\xa0\xb5\x25\xa5\x52\x4c\x98\x6c\xf9\xfb\xd5\xdf\xfc\x12\x6f\xb1\xfa\x16\xa8\xa2\x4b\x89\xc5\xba\xab\x51\x76\x11\x80\xed\xc1\x51\x17\x56\x1b\xe4\x90\x2b\x76\x18\x06\xf7\x11\x7c\xca\xc4\x82\x2c\xa8\x6a\x5d\xec\xb0\xee\xfa\x28\x1a\x5b\xca\x17\x5c\xcb\xd6\xe5\x62\x6b\x87\x5c\xf5\x7e\x71\xd7\x08\x40\x96\xa6\x28\x8d\x93\x2e\xfe\x6c\x7b\xa8\xb9\x70\xa6\x1b\x8a\xef\xb3\xbd\x1e\x27\x57\x50\x63\x98\x12\xcf\xc9\xff\x1c\xbc\xfd\xf2\xfd\x68\xf0\xed\xc1\xc1\x2f\x4f\x47\x7f\xfb\xf5\xcb\x83\xb7\x63\xf8\xc7\x17\x83\x6f\x07\xef\xfd\x1f\x5f\x0e\x06\x07\x07\xbf\xfc\xf8\xea\xfb\xab\xf3\x93\x5f\xf9\xe0\xfd\x2f\xa2\xcc\xaf\xf1\xaf\xf7\x07\xbf\xb0\x93\x5f\xef\x39\xc8\x60\xf0\xed\x1f\x7b\x7c\x09\x2a\x96\xaf\x7b\x63\xc1\x78\x8d\x3e\x8a\x1a\x51\x1f\xbb\x67\xd2\x25\xe4\xdd\xa8\x72\x5e\x8f\xb8\x30\x23\xa9\x46\xf8\x90\xe7\xc4\xa8\xb2\x2f\xd6\x55\x89\xbf\x8f\xc7\x63\x2a\x25\xa6\x42\x6e\xf4\x86\xcd\x16\x32\x11\xcc\x1c\xfd\xe8\xde\x60\xd7\x2e\x75\xe7\x08\xbe\xcf\xf5\x51\x12\x8e\x1c\x32\xcc\xef\x3c\xdb\xe8\xd2\x75\xe4\xdd\xa5\x1a\xad\x5c\xbb\x54\xa3\xd5\x6b\x97\x6a\xf4\xc0\x6b\x97\x6a\xb4\x85\x3e\xc0\x5d\xaa\xd1\xce\x07\xf8\x48\x7c\x80\xbb\x54\xa3\xfb\x5e\xbb\x54\xa3\xd6\xd7\xe3\x4c\x35\x72\x0a\x7c\x95\x67\xb4\xb5\x69\x46\xae\xc1\xff\x61\x92\xc8\x52\x98\x2b\x79\xcd\x3a\x46\x65\xef\x65\x60\xae\x3c\x73\x3b\xad\xcd\xbe\x54\xca\x1e\x54\xc0\xfe\x94\x3f\x5a\xa6\xdc\x9a\x99\x3d\x1f\x83\x43\x37\xac\xb7\x33\xad\x58\x14\x29\x4b\xc3\xf3\x3c\xb3\x32\x76\xbf\xc7\xe4\x90\x28\x96\xf0\x82\x5b\xd6\x0e\x60\x3a\xf0\x39\x9e\x93\xd0\x0f\x98\x1b\xcd\xb2\xa9\xeb\x89\x2a\xaa\x9a\x61\x15\x99\x90\x4e\x56\xac\x7d\x0c\x6a\x05\xd2\xb7\xb1\x24\x7a\x2e\xcb\x2c\x25\x8a\xfd\xdb\xab\x13\x6e\x36\x57\xf1\x08\xb1\x23\x14\x5e\xa5\x7a\xac\x1b\x9c\x16\xdc\xa1\x6e\x6d\x13\x83\x63\xef\x0a\xae\xe0\xb0\x5d\xb2\x44\x8a\xb4\x6f\xf7\xc6\x49\x73\x7c\xbf\xd7\x2e\x9a\xc3\x52\x92\x96\x78\x03\x14\x42\xd2\x8c\xa7\xdc\x2c\x43\x16\x06\x1e\x7b\xab\x88\x62\x17\x5a\x47\x08\xba\xda\x08\x42\x8b\x42\x49\x9a\xcc\x99\x8e\xde\x06\xd5\x4a\x07\x36\x11\xea\x2b\xb3\x72\xc6\x05\x6a\x96\xf0\x1b\xab\x86\x64\x4b\xa2\xa4\xf1\x09\x65\xb7\x3c\xf0\x2a\x1a\x0c\x7e\x8e\xba\x84\x51\x4b\xc8\x3a\x93\xf1\x10\x38\x2b\x3e\x8d\xff\xd0\x44\x66\xa9\xc7\x2d\xfd\xfa\xa9\x55\xe5\x13\x47\xc5\x96\xdb\x03\xaa\xa4\x91\x24\xb3\x6a\x91\x95\x00\xb7\xff\xf8\xab\x3f\x93\xb9\x2c\x95\x1e\xc7\x10\x02\xcf\xe0\x33\x74\x52\x78\x53\xc0\x90\x8c\x51\x6d\xc8\xb3\xa7\x24\xe7\xa2\xb4\xb2\xbc\x27\xc2\xeb\x4b\x7b\x8d\xf4\xd6\xbf\xfe\xb9\xe3\x68\xfd\x68\xac\xab\x19\x2c\x8e\x5a\x0b\xec\xcf\xe6\x14\x57\x77\xc6\x11\x14\x03\x7b\x34\x36\xd4\x58\x27\x92\xe2\x5d\x14\x46\x6e\xf8\xe4\xff\x56\xca\xc9\xd2\x74\x87\x81\xf9\x6f\x1c\xa7\x8e\xff\xe2\x3f\xbc\x0f\x96\x6a\x05\xa5\xda\x62\x2a\x1b\xef\x16\x3d\xe3\xda\xb4\xea\x15\x5d\xe1\xc6\xb4\xf8\x71\x57\x61\x3e\xb3\x16\x6f\x2f\x45\xeb\x60\x3b\x7b\x5b\xcd\x3b\x95\x93\x84\x69\x60\x45\x1e\x3e\x0d\xfc\xb3\xf8\xd4\x96\x0f\xdd\x2e\xc4\x96\x3b\x11\x59\x3c\xf1\xf7\xd0\x19\xb3\xd3\x62\x75\xd1\xed\x3d\x61\xf7\xb4\x5a\x38\x58\x9d\x47\x68\x2e\x66\xd8\xc8\x32\x2f\x33\xc3\x8b\xac\x5a\xb9\xf0\x03\x27\x80\x63\x87\x3f\x8d\x3c\xcc\x14\x81\xa3\x10\x1a\x1c\x82\x23\x07\x61\x2c\x26\x0c\xf6\x63\x54\x56\x8e\x17\x54\xd1\xb0\xfc\x89\xcc\x73\xaa\x07\x2e\x76\x40\x21\x77\x05\x39\xbb\x15\xc3\x8a\x66\xe1\xf5\xe3\x5c\x81\x4d\x11\xae\x61\x82\x8a\xd6\x41\xbb\xba\xc3\x05\x86\x22\xf2\x26\xa4\xc7\x63\xff\xf4\x06\xc5\x3a\x85\xf8\x3b\x9a\x5c\x33\x91\x92\x37\xda\x2f\x5c\xba\x14\x34\x77\xe0\xea\x85\x92\xd8\xb7\x9b\xa5\x8d\xdf\xeb\xa1\x73\x24\x22\xca\x88\x07\x81\x42\x7d\x6b\x53\xab\x58\xea\x9e\xd0\x75\xdf\x68\xab\x7c\xdd\xcd\xef\x34\x3a\x69\x15\x5f\x24\xcc\xeb\x8e\x76\x02\x9b\x7a\xf9\x45\x6b\xc4\x37\xb2\x1e\x87\xc9\x35\xcd\xc4\x53\x08\x22\x3d\x04\x1f\x01\x47\x9d\x66\x96\xc5\x2d\x03\xbc\x4e\x83\xc0\x26\xcb\xcd\xb5\xec\x57\x93\xee\x00\x4d\xfb\x17\xdf\x1d\xd7\x99\xd9\x05\x4d\xa5\x26\xdf\x65\x32\xb9\x26\xc7\x0c\x8c\x86\x8f\xd9\xee\x5d\x4d\xd2\xc7\xdd\xa6\x31\xa7\xb3\x76\x79\x1e\x23\x92\x4b\xc1\x8d\x54\x6d\xf8\xf1\x16\x81\xed\xed\x5a\xed\xad\x07\x11\x57\x93\xf4\xb3\x69\xb4\x67\x89\xbc\xa7\x0e\xbb\x73\x46\x14\xb0\x18\x18\xd4\x77\xff\x68\xc9\x30\xfe\x30\x97\x37\x23\x23\x47\xa5\x66\x23\xde\x3a\x4f\xa9\xf3\xfa\x5c\xb3\x25\x24\x7d\xf5\xb2\x42\x3f\xe2\x60\x35\x13\xdd\x48\xf0\x9c\xc3\xe7\x56\x91\xbb\xf8\xee\xd8\x4a\xef\x71\x6c\x96\x3c\x61\x26\x79\x92\xb0\x62\xfe\xc4\x4d\xe7\xd1\x2f\xab\xe7\x8f\xfd\xac\xeb\x21\x49\x64\x96\x39\xdc\x2e\x39\x25\x47\xac\x98\x87\x47\x6c\xc7\x5a\x3d\xe6\x66\x69\x85\x94\xfd\x34\x56\x8a\x58\x84\x1d\xd3\x71\x88\x88\xd0\xd5\xe4\x61\xbd\xa0\xb7\x91\xb4\x3f\x61\x4f\x92\x36\xbd\xe5\xb6\x62\x79\xb7\xa7\x47\xdd\xfe\xa5\x1f\x0e\xfc\x3f\x51\xb8\xb9\xde\x92\xce\xe7\x8b\xd6\x58\xf4\xe9\x14\x2d\xcc\x94\xa5\x44\x2e\x98\x52\x3c\x65\x9a\x04\x1e\x1d\x3b\x96\x78\xb6\x1d\x2b\xbf\xeb\x8e\xf7\xb8\xf2\x03\xb6\xc7\xa7\x10\x31\x6f\x3b\xe6\x2a\xf3\xa6\x69\xce\xc5\x76\x50\x79\xcb\xf5\xd2\x09\xcd\xd8\xe9\xeb\xce\xa6\xf7\x25\x8e\x53\xb7\xbe\xfd\x87\x11\xc8\xfe\x07\x80\xe7\x7f\x0c\x34\x4b\x84\x4c\xdb\x45\xc3\x36\x6c\x43\xcf\xa8\x61\x37\x2d\x15\x9f\x51\xc5\xea\xdb\xfe\x1e\x2c\xaf\xc7\x6d\x83\x6f\xa8\x41\x46\x74\xae\x11\xf5\x7e\x53\xea\x94\xa3\xa0\x7e\x5c\xcb\x7e\x29\x1a\xfd\xc5\xfc\xd1\x3c\x3c\x3f\x25\xdf\xe3\xf3\x36\xd7\xf1\x43\x49\x83\x96\xcc\xb1\xcc\x29\xef\xa9\x11\x7b\xd4\xd0\x29\x7e\xe1\xf3\xf0\x30\x82\x4f\x8b\xbb\xd0\x4f\xf9\xac\x54\x2c\x25\xce\xfb\xb1\x6b\x63\xb0\xc5\x6d\x0c\xfa\x55\x8a\x2b\x9d\x38\xf2\x98\xfb\xca\x98\x4a\x0f\xf6\x54\x04\xea\x40\x48\x41\x22\x9a\x09\xcd\x21\xeb\x20\x4a\x8c\x03\x65\x19\xf2\xbf\x43\x19\x0c\x2a\xce\x43\xf2\x52\xce\xb8\xf0\xdc\x49\xba\x64\x97\x29\xe5\x59\xb7\xe5\xdc\x69\xba\xbf\x33\x4d\x57\xeb\xec\x44\xd0\x49\xd6\x3e\x93\xb1\x2e\x78\x33\x0a\x79\x52\x0c\xc6\x7c\x92\x72\x6d\xff\x4b\x2e\x2f\x5f\x42\x6c\xb6\x14\xde\x32\x84\xa8\xa3\x13\x1b\xa1\xbe\x18\x99\xcb\xe6\xf8\x01\xf2\xec\xde\xfa\x54\x9c\x8a\xd4\xbe\x2e\xd3\xb5\x04\x60\xf7\x14\xec\x02\x12\xaa\xd7\x30\xfb\x70\xc2\xc8\xd5\x9c\x27\xd7\xe7\x51\x08\x56\x2a\xfb\x99\x88\x3e\xaa\x29\x1a\xcd\xef\x36\x25\x70\xdc\x6b\x9d\xf7\xe5\xf6\xba\x8a\x24\xee\xa5\x5b\x32\x3b\x38\xa1\x5a\xcb\x84\x57\x31\x7f\x70\x0a\x57\x22\x39\x05\x91\xbc\xb9\x65\x00\x2d\xf1\xa3\xe8\x1f\x9e\x70\x9c\xd2\x4a\x75\xac\x6f\x70\xe1\x57\x6b\x63\xaf\x8e\xa4\xdc\x5b\x77\xcd\xab\x5a\x3f\x4d\x6f\xf5\x35\xc2\xcf\xbe\x1e\xd4\x11\x8a\xd7\xe7\x5d\x03\xe7\x55\x52\x09\x7d\x35\x5d\x7f\x8f\x8d\x2c\x56\xfb\x62\xed\x75\x5e\xb8\x46\xee\x0d\x7e\xe6\x02\xd2\xc0\x54\x0a\x59\x94\x19\x66\xad\x76\x6f\x2b\xea\xa3\x79\xf8\x9c\x0d\x04\xa8\xb7\xad\x19\xd1\x43\xcb\xf9\x3e\x8f\xbe\x44\x91\x41\xf0\xf4\xaf\x7f\xfe\xf3\x63\xef\x54\xd4\xcd\x71\xb6\xe9\x56\x45\x9d\x42\x5d\x3b\x94\x82\x1d\x4a\xc1\x5d\xd7\xc6\x23\xb1\x9f\x1e\x87\xa0\x97\x22\xb1\x3e\x0a\xc4\xba\x22\x0d\x74\x2c\x2e\xeb\xa7\xb0\xac\x33\x96\xc0\x47\x45\x10\xe8\xa9\xc6\xaa\x3b\x5a\xc0\x0e\x23\xe0\xf7\x81\x11\xd0\x5f\x6d\x55\x5f\x78\x00\xdd\x6b\xaa\x3e\xff\xda\xff\xce\x6c\xa2\x6b\x85\xf9\xc3\xeb\xca\xfb\xea\x5f\xd1\x97\x9f\xbd\x37\xc7\x40\xcd\xab\xeb\xec\x5d\x4f\x19\x98\x79\x5d\x21\xbe\x1b\x69\x99\xc6\x06\xad\x5d\xd2\xd9\x59\x80\x53\x91\xad\x64\x70\x9d\x6a\x70\xa4\xd7\x97\x8d\x10\x7b\xf8\x78\xfb\x23\xeb\xbb\x10\xf3\xae\x8d\xfa\x2e\xfe\x18\xae\x5b\xe2\x8f\xba\x86\xf1\xea\x3d\x82\xc0\x09\x41\x05\x93\x93\xb8\x8f\x4a\x75\xfe\x0f\xcf\x4f\x49\xa2\x18\x40\x1a\xd0\x4c\x8f\xc9\x1a\x0d\xcd\x47\x6a\x9c\x46\xe7\x35\x33\x6a\x0c\xcb\x0b\xd3\x95\xe0\x76\xe1\xc7\xdf\x59\xf8\xb1\xe7\x98\xc1\x4f\x61\x38\xef\x2d\x9a\x97\x39\x15\x23\xcb\x2d\x20\x10\x59\xcb\xe7\x68\x08\xbe\x31\xf1\x35\x70\xb8\x9a\x54\x31\x04\x37\x2f\x05\xff\xad\x64\x95\x7f\x21\xa8\x17\x5b\x10\x6a\x81\x79\xf4\xbc\x76\xa8\x3a\x35\xb8\x48\x22\x57\x4a\x99\xdc\x82\x84\x75\xf4\x0c\x23\xd2\xbf\x6a\xbe\x32\x33\x67\xa8\xa6\x9d\x03\x38\x40\x75\x57\xdd\xbe\x43\x03\x8f\x66\x99\xbc\xc1\x67\xc7\x8a\x87\xdd\x3f\x3b\x17\x87\xc7\x31\x61\x24\xe7\x4a\x49\xe5\x42\x3c\xf1\x74\x30\x2d\xc7\xda\x89\x4c\xa1\xc1\xa5\x5c\x56\xc5\x25\x33\x31\xa9\x18\x49\xa8\xc0\xc2\x45\xfb\x6f\x9f\x94\x8c\xfd\xcf\x1c\xbf\x9b\xb0\x39\x5d\x70\x59\x2a\xfc\xb5\x91\x64\xcf\x7d\x05\x22\x77\x29\xcb\xe0\xe6\x2e\xa1\x4e\x29\xbc\x9d\x5e\xb3\x4e\x67\xd5\x97\x60\xa0\xa6\xd2\xfb\x0f\x47\xec\x1d\xd7\x66\xf5\x5d\xfc\x12\xf9\x06\x09\x9b\xa0\xbc\x85\x2e\xac\x80\xfd\xa9\x75\xcd\x69\x9d\xde\xe2\xd1\xea\x2a\xe9\xe2\x12\xbe\xfa\x90\x42\xea\x90\x5a\xb0\x54\xdc\x17\x85\x3d\xbe\x74\x4f\x7c\xcb\x96\x9d\x99\x76\x1a\xf1\x63\xd1\x88\x43\x82\x44\xc6\x93\xe5\xe9\x71\x3f\x3a\x5f\x48\x8c\xb0\x83\x92\xef\xa8\x66\x29\x79\x45\x05\x9d\xa1\x73\xe4\xe0\xf2\xfc\xbb\x57\x03\x4b\x24\xe0\x7c\x39\x3d\x5e\x9b\x3d\x71\x19\xcf\xec\x6c\x53\xe5\xdb\xa4\xb9\x46\xbd\x69\x05\x0f\x5c\xa5\x8d\x15\xb0\x93\x20\xd9\xbb\xb4\xec\x5a\x05\x37\xc2\x74\x08\x8f\x54\xa6\x9b\xec\x75\x91\xa7\xd7\x1f\xf3\x75\x23\x5f\xf5\x5d\xef\x74\xbf\x40\xd3\x3d\x82\x49\x8d\xbd\x57\xd4\xb0\xd9\xf2\x98\x15\x99\x5c\xda\xed\x3e\x8f\x5c\xe7\x78\xeb\x04\x45\xbd\x9a\xd0\x84\xa8\x32\x63\xd8\xbd\xa6\x09\x11\x26\x18\x4b\x2b\x3e\xc5\x85\x36\x14\x00\xc2\x70\xfc\x3b\x67\x74\x6f\x01\x73\x5f\x51\x32\xc2\x79\x7e\xf0\xae\x3a\x9c\xa2\x3d\x50\x77\xfe\xe4\xfe\xc2\x04\x1e\xff\x61\x0a\x7d\x48\xf0\xf0\xde\x61\xc2\x3a\x81\xc3\x99\xbe\x28\x33\x2b\x3a\xb2\xb4\xd1\x44\x14\x74\x2b\xb7\xc7\x88\xcc\x00\x1c\xc0\xce\x7e\x48\x26\xa5\x55\xbc\x98\xae\xf9\x97\x57\x61\x29\x6f\xe6\x18\x37\xb6\x3f\x22\xb4\x28\x32\x8e\x79\xbd\x52\xb9\xe0\x6f\xe4\x6d\x5c\xbd\xed\x3e\x8c\xe4\x81\xfa\xc7\xc3\xf4\x8d\x11\x59\x30\x35\xb9\x0f\xa6\xc2\x43\x55\x09\x5a\x70\x88\x9d\xdc\x5b\xf3\xa8\x83\x42\x9e\x9f\xe2\xaf\xbd\xa5\x16\x9b\x66\xfe\x4b\xdc\x41\xb7\x37\x1e\x50\xd0\x75\xa5\x41\x6b\x23\xa0\x02\x1d\x9e\x9f\x22\x0c\x95\x03\x06\xaa\x5c\x16\x56\xb7\xa7\x98\x1c\x58\xa1\x11\xd2\x99\x1d\xd1\x10\x29\xc2\x43\x99\x28\x73\x86\x60\x42\x55\x3b\x2b\x6b\xf0\x89\x65\x35\x7a\xe5\xf1\xb0\xf6\xc9\xfd\xd5\x89\x87\x87\xd1\x1f\x18\x36\x7f\xb0\xe4\x11\x52\x5c\xb8\xd7\x7c\x73\xf1\xb2\xdd\x26\x9e\xd5\xc7\x70\xe0\x31\x0c\x70\xf2\x0a\xaa\x0c\xa7\x19\x29\x55\xe6\xc3\x70\x98\xf4\xee\xd2\xd2\xe6\x74\x11\x01\xec\x8c\x09\xf9\x02\x77\xce\x2d\x2c\x9e\x4f\x6c\xef\x8a\x3b\x3f\x2d\xb3\x6c\x48\xa6\x5c\x50\xcb\x76\x59\x41\xe2\x70\xd0\x25\x17\x89\x35\xbf\xac\xad\xef\xfa\xb5\xc0\x8c\xbc\x51\x16\x0e\x29\x44\x19\x21\x5a\xca\xb2\x14\x40\x17\xe1\x11\xf6\xc0\x26\xe0\x22\xb0\x56\xe3\x51\x56\x6a\xc3\xd4\x85\xb4\xc2\x20\xca\x6b\x01\x38\x0a\x1a\x7f\xfd\x1d\x17\x29\xa4\x30\x5d\x80\xe0\x48\xa8\x20\x8c\x83\xf3\xc5\x0e\x09\x71\x6a\x4b\x3b\x15\x41\x1d\xe8\x32\x99\xdb\x57\xda\x2b\x64\xaa\xf7\x2c\x1b\xd9\x43\x17\x9d\xde\x1b\xd8\xbf\x9a\xef\x80\x69\x2a\xd1\xef\x9e\xd0\x82\xef\x0d\x86\x04\x16\x08\x02\x67\xd2\xcc\x1f\x2f\x1d\xfa\x77\x05\x9b\xb8\x15\x15\x5e\xc4\x23\x00\x0d\x8a\xaa\xfb\xd7\xcd\x9c\x1b\x16\x9a\x6f\xa3\x67\x27\xe0\xab\x34\x99\x35\x21\x87\x82\xb0\xbc\x30\xe0\x2d\x26\x39\xa3\x3e\x84\xcc\x16\x4c\x2d\xad\x4d\x0e\x40\x14\x8f\xfe\xf0\x07\x7a\xec\xb4\xe0\x8d\xce\xe6\x15\x91\xc3\x09\x5b\x59\xdc\xfd\x2f\xf6\x6b\x76\x7e\x96\x45\xdc\xfc\xd1\x2e\x25\x88\xd7\x56\xcb\xf8\x93\xfd\x65\x7d\x09\xf1\x23\xe4\x96\x81\x7f\xbc\x7c\xe9\x02\x19\xb8\x56\x3f\x72\x91\xea\xd0\x6b\xcf\xe5\x40\xbb\xf5\x5e\xbb\xc8\x30\xc3\xc7\xb8\xc0\xab\xea\xeb\x7d\x55\xce\x3b\x86\xf7\x1a\xfb\x6d\x43\xdd\x39\x80\x53\xfb\x5f\xc9\x74\xfd\xd1\x69\xd4\x7f\x54\x37\x3b\x85\x24\xea\x5f\xe9\xc7\x72\xaa\xea\xb2\x58\xab\xcf\xdf\xbd\x1d\x77\x2c\xfd\x6d\x33\xa9\x3c\x00\xc0\x27\xa3\x6f\xae\x96\x05\x73\x78\xda\x64\x9a\xd1\x59\x45\x46\xc0\xf5\x50\x49\x3a\xba\xfc\xc9\xbf\x82\x26\x7c\xbd\xba\xfa\x41\x7d\xf6\x43\x1a\xec\xa8\x5a\xa5\x5b\xef\xb0\x0f\x59\xfb\xe5\x87\xd5\xd8\x30\xf8\xed\xd4\x74\x9f\xe0\x9e\xb9\xd3\x71\x76\xdb\xfa\x5f\x39\x1c\x2f\x1a\x51\x82\x87\x09\xf3\x46\x25\xe4\x1b\x81\x1e\x72\xf9\x53\x8d\x4c\x3e\x30\xdf\x5b\x88\xf6\x9a\x2d\x6f\xa4\x5a\x8f\xf9\xdd\x9a\xbe\xee\x7c\x22\xf6\xe0\xff\xe0\x01\x79\x45\x0b\xfb\xda\x55\x36\x27\x5a\xde\x2e\xb6\x88\xba\x3f\xe6\x61\xf9\xdc\x37\xa9\x66\x54\xf0\xff\x60\x0a\x6c\x62\xcf\xb1\x54\xf6\xcf\x03\x8c\x4f\xa0\xdd\x9e\xb1\xc4\x0c\x1c\xfd\xad\xe5\x7b\x1f\x20\x50\x9a\xa6\x1c\xb5\x87\xf3\x0f\xd0\xd2\xdd\x8b\xc0\xc5\xf5\xc7\x58\xf3\x3b\x0e\xd6\x87\x69\xff\xee\x00\xe7\x3d\x78\x73\xa9\xee\xc8\x61\xba\xf3\xf7\x39\xe5\xae\x6f\xeb\xd6\xad\x0a\xcb\x29\x6f\xfb\x5a\x78\x75\x58\xd7\x9c\x9a\x52\x71\xb3\x56\x20\xdd\xfd\x43\x2e\x7e\x2c\x27\xcc\xc5\x74\x1f\xfc\x73\x01\x29\x7a\x87\xe7\xa7\xfd\x6e\xc7\x2a\x88\xb4\x9b\xa0\xd5\x5b\x48\x29\x68\x3e\xe1\xb3\x52\x96\x3a\x5b\xc6\x4e\x49\x0a\x21\x69\x6b\xd4\xa3\x57\x46\xec\x1b\x42\x85\x14\xcb\xdc\xdd\x2a\x92\xac\x4c\x59\x6d\x44\x88\xdc\x2d\x24\x4f\x09\x2d\x8d\xcc\xa9\xe1\x09\x49\x24\x53\x09\x44\xf9\xe2\x91\x4a\xcd\x08\xbd\xe5\xb7\x49\xa9\x8d\xcc\x49\x4e\x95\x9e\xd3\x2c\xbb\x6d\x8f\x7b\x90\x6a\x77\xc1\x64\x8f\xe0\xfd\x6f\xfd\x72\x81\xb3\x6e\x49\xdf\x1f\x40\x05\xbf\x07\x7d\xdb\xc9\x75\x1a\x60\x71\x3b\x95\xde\x63\x0c\x57\xf8\xbe\x16\x94\xe7\x03\x1b\xf3\xa1\xd5\xb9\xeb\xe4\x7e\xf0\xbd\xee\xe0\x86\x77\xfe\x16\x12\x64\x59\x7a\x9a\xd3\xd9\x3d\x14\xc9\x97\xd6\x3a\xa0\x62\xe9\x7f\x86\x58\x91\x7a\x48\xa4\x72\x99\x1e\xa1\xf3\xb6\xfb\x2a\xc0\x8c\x2a\xf2\x1a\x82\x69\x52\xb9\x94\x69\x47\xa5\x90\x40\xcf\xd4\x54\xaa\xdc\xea\x75\x5c\x91\x69\x29\xc0\x49\xa6\x5d\x86\x35\x98\x24\xce\x57\x43\x33\x2d\xc3\x09\x84\xe8\x9c\xf0\x93\x20\x54\x93\x1b\x96\x65\x63\x72\x98\x65\x0e\xc4\x32\x02\x40\xa8\x0a\x9b\xab\x3c\x80\xc9\x92\xa4\x7c\xc6\xb4\x21\x07\x97\x3f\x1c\x0e\x40\x6a\x83\x1f\x63\x49\x0c\xf5\xd5\x60\x75\xff\x0c\xc8\xff\xb4\x04\x3d\x21\xa1\x86\x66\x72\x86\xa1\x70\xf0\xd3\x8a\x94\x14\x19\x5d\x02\x14\x7d\x41\x15\xa4\x83\x26\xe8\xa3\x21\xaa\x14\x00\xc2\xfb\x49\x25\xce\x87\x59\xc1\x5d\x38\xb9\x23\xa0\xc9\x96\x47\xfd\x03\xd8\xa4\x1f\x57\x94\x29\x56\x64\xf4\x16\xaf\xc2\x1d\xc5\xbd\x56\xcd\x05\x13\x56\x0a\x16\xc6\x18\x93\x4b\xa4\x9d\x9c\x9a\x04\x03\x95\xff\xca\x99\xa1\x29\x35\x74\x6c\x6d\xc1\x7f\xd5\xcb\xcf\x64\x96\xda\x81\x6e\xdf\xe8\x5b\xe6\x8c\xfa\xe2\xfa\x96\xeb\xf5\x53\x68\x95\xda\x70\x3b\xe8\xe7\xfe\x3c\xde\xe9\xc6\xe8\xc8\x9f\xe0\xf5\x4f\xde\x59\x53\xec\xce\x18\x5a\x6d\xae\xcd\x1f\xd5\xbd\x0c\x59\xfd\x4d\x1c\xb5\xe6\x0c\xd0\x0f\xaf\x5c\xd7\x1e\xff\x09\xb8\x50\x0f\xcf\x8e\x6f\x77\x77\x7d\xd8\x65\xf0\x01\x17\x41\x3d\x30\xf0\xff\xb1\x77\x3d\xbd\xad\xdb\x48\xfc\xde\x4f\x41\xf8\x92\x36\x88\xf3\xb0\x68\xdf\x1e\xde\x2d\x70\x52\x20\xd8\xfc\x79\x70\xd2\xf6\xd2\x0b\x63\x31\xb6\x10\x99\xf4\x92\x92\x9d\xb4\xe8\x77\x5f\x70\x66\x48\x89\xb6\x44\x51\xb1\x93\xa6\x8b\xe7\x4b\x02\x89\xa4\xc8\x21\x39\x9c\x7f\xbf\x61\xa4\x7b\xce\xc0\x4c\x6f\x42\xef\x80\x83\xa0\x00\x4a\x0f\x01\x1d\xdc\xa5\x48\x71\x85\x71\xc2\x42\x7c\x21\xd6\xeb\xb6\x8f\x24\xb9\x67\x52\x9c\x32\x7d\x70\xae\xb1\xef\x6c\x67\xa1\x34\x1f\x4d\x2f\xe4\x2a\x20\x38\x61\x1a\x01\x42\x09\x94\x07\x60\x86\x33\x91\x7a\x62\xa7\xfa\xb4\x12\xed\x3b\x6e\xa8\x03\x3a\xea\xa7\x32\x08\x16\x7a\x12\x2f\x47\x86\x10\x27\x4a\x9a\x45\xbe\x42\x4c\x20\xb9\x21\x68\x76\xd9\xaf\xbc\xc8\x33\xdf\x04\xae\xea\x4b\x79\xc2\x6e\x54\x69\xff\x5c\x3c\xe7\xa6\x44\xf5\xf3\x5c\x09\x73\xa3\x4a\x78\x72\x90\xa1\x62\x17\x06\x0c\x94\x14\x60\xb4\x64\xc3\xbe\x6a\xa8\xc9\x6e\x40\x97\xc4\xf6\x1c\x51\x72\xc3\x2e\xa5\x95\x08\x68\x44\x1e\x2b\x6b\xa8\x09\x07\x07\x91\x4a\x8e\xc1\xc6\xdd\xda\x06\x11\x42\xe9\x80\x0e\x91\xe6\xa8\x29\x0c\xda\x83\x37\xb9\x71\x4c\xdc\x9f\xd9\xdc\x99\xdd\xf2\x19\x5b\x0a\x3d\x07\xaf\xcd\xac\xc7\x6b\x91\x6a\x8a\x4c\x32\x40\xf6\xce\x15\xb0\xcc\xab\x4e\xc3\xc5\xce\x24\x35\xca\x23\x5b\x5a\xa2\x35\xe3\x4f\xcb\x7d\x80\x52\x7f\x01\x60\xda\x9c\xb2\x33\x77\x25\x4a\xf3\x1d\x79\xaf\x9a\xcd\xd8\x16\x72\xc3\x2c\x2b\x59\xf3\x42\x60\x7e\x78\x2e\x3d\xd6\x49\x3d\xee\x30\xf6\x13\x02\x4e\xdb\x3d\xeb\x45\xa6\xd1\x93\x78\x19\x9d\xec\x4c\xed\xe8\x52\x8e\x6a\xa0\x5b\x30\x99\x9e\x89\x82\xb4\x35\x82\x77\xa3\xd7\x9f\x05\x51\x66\x99\x6e\x5e\xe9\x9d\x37\xf3\x94\xb7\xbb\x9f\x5b\x85\x8d\xef\xcd\x0f\x96\x84\xe0\xf2\xd5\x6c\xa9\x34\x98\x33\xed\xd3\x66\xba\x0c\x2b\xaa\x3e\xe5\xab\x55\x9d\x5d\xa4\x5a\xcd\x35\xcf\x04\x9b\x6b\xbe\x5a\x0c\x15\x4b\x50\xb6\x69\x6b\xfe\x1f\x23\xe8\x76\x10\x3f\xa2\xd1\x45\xeb\x6d\xc4\xc3\x42\xa9\x27\x40\xa5\xc1\x42\x78\x43\xfb\xc3\x6f\xf8\xad\xf3\xfa\x99\x53\x25\x0d\xcb\x44\xc9\xf3\x02\x62\x39\x6e\xaf\xae\x29\xda\xc3\x9d\xe3\xae\x97\xed\x81\x13\x07\x50\x00\x78\x46\x51\x48\x53\xb1\xce\xc5\x86\xac\x12\x5d\x71\x1a\x63\x36\x17\x12\x82\x13\x22\x41\x3c\x63\x66\xf2\x4c\x5c\x00\xd8\xb5\xbb\xa1\x3d\x0c\xe7\x1d\x7d\xee\xdb\xbc\x71\x0e\xde\xcb\xbd\x13\x4e\x59\xaf\xfe\x7e\x55\x3a\x92\x58\x27\x0d\x7b\x9b\x86\xab\xa5\xe8\xef\x2f\xec\xa7\x9f\x7e\xec\x2c\xb4\xe4\xcf\xf9\xb2\x5a\x7e\x61\xff\xfe\xfc\xf9\xc7\xcf\xdd\xc5\x72\x89\xc5\xfe\xd5\x3d\x3e\xda\x6d\x93\xe9\xf9\x07\xa0\x77\xe6\xa3\xe9\xe2\x4e\xb9\x84\xa6\x1e\x79\x5e\x54\x9a\x42\x3e\x13\x55\x84\x9f\x9b\x75\xc0\xa1\x52\x83\x15\xb8\x6b\xd1\x05\x7b\x51\x10\xd8\x63\x2e\x85\x81\xab\x47\x2a\xa9\xc5\x4c\xcd\x65\xfe\x87\xc8\xdc\xcd\x23\x10\xd8\x01\x09\xcc\xdd\x12\x67\x42\x66\x78\xe7\xa3\x3d\xf3\x16\x5c\x66\x45\xcc\xe1\x9f\x30\xd2\xe6\x0e\xde\x8b\x64\x70\xf2\x0c\x22\xd8\x75\x5d\x63\x8b\x5c\x70\x73\x25\xb9\x9f\xf0\x44\x43\xb2\xed\x35\x52\x64\x8c\x77\x11\xc5\xba\xa5\x8f\x3b\x7a\x1f\xaa\xac\xf0\xec\xbf\x95\xd0\x2f\x00\xcc\xa8\x05\xfb\x46\x20\xd8\x7d\x8d\xdb\x77\xc3\x20\x89\x0a\x33\xa5\x6c\xe9\xc2\xb5\x10\x53\x87\x7b\x6c\x7d\x1b\xea\x08\x74\x9f\x3b\x47\x12\x3b\x63\xb2\x2a\x8a\xae\xa2\x52\xc5\x5c\x4e\x4d\xda\xf5\xa8\x92\x69\x3a\x5e\xaa\x59\xa0\x85\xd2\xef\x6a\x1c\x68\x0e\xfc\x40\xa2\xfc\xc7\x36\x17\x34\x07\x9c\x14\xd3\x99\x1e\xcf\x99\x96\x0f\x26\xc1\x8c\x80\xbf\x21\x01\x9f\x89\x59\x5c\xde\xd2\xb0\x80\xbf\x41\xf1\x39\x69\x46\x86\x96\xae\x7f\x38\x53\xc3\x2b\x06\x9f\x62\x76\x68\x19\xfa\x37\xe3\xc3\x0e\xc1\x53\xa3\xa1\x06\x44\x42\x25\xce\x64\x82\x51\x02\x7f\xdf\x4c\x13\x83\x4e\xa2\x04\xc6\x3c\xcc\x4c\x91\x3c\xab\x5a\xe4\x72\xad\x30\x0b\xf2\x20\x19\x6e\xba\x53\x71\x4b\x94\xdb\x00\x67\x25\x59\xce\x0b\xbf\x4d\x91\xd6\x2a\xb4\xac\x32\xfd\xc6\xee\xf8\x08\xe2\xd8\x8f\x83\xe8\x20\xe1\xc8\xab\x42\xfc\x96\x97\x8b\x5b\x97\xed\x9c\x56\x75\x59\xad\x0a\x18\x6c\xe3\x85\x5d\x42\xd3\x5a\x32\xbc\xc4\x1b\xb2\xc4\x4c\x2d\x97\x42\x66\x18\x44\xb4\xe4\x4f\x82\xd5\x17\x2d\x5a\x19\x0f\xc4\x60\x68\x4e\x3c\xaf\xb8\xac\xe5\xc4\xb5\xe5\xe5\xb1\x15\x95\xb8\x9e\x52\xcf\xda\x64\x50\x45\x1c\x4c\xd1\x40\x43\x04\xa0\x09\xf6\x20\x0a\x05\xd0\x69\x8c\x14\xc5\x58\x66\x2a\x0a\x2c\x99\x9e\xd2\xa9\x47\x99\x15\x85\x9c\xd7\x79\x9c\x4c\x01\x97\xa0\x12\x07\x56\x52\x9c\xb2\x29\x89\x30\x69\x52\x51\x0a\x3b\x4d\x64\xa5\xc9\x07\x62\x9d\xfb\x60\x30\x65\x5d\xbd\x26\x6d\xd7\xee\x59\x0a\x75\x5d\xe1\xff\x67\xfa\xfa\x9b\x08\x86\x91\x37\xdc\xd2\xf5\xa9\xe0\x69\xbb\xc5\xbc\x66\x78\xc5\x2e\x98\xea\xc6\x6c\x32\xbd\x38\xbb\xbf\x38\x61\xbf\x7c\x3d\x87\xbf\xe7\x17\x57\x17\xf6\xef\xe4\xf6\xe6\xe6\x62\x72\x6f\xe5\x88\x63\xcc\xb3\x6e\xd5\x38\x4b\x5d\x7b\x1e\xa9\x90\x5b\x70\xf9\xc2\x1e\xab\xd2\xb2\x83\xfa\x63\x41\x2f\x38\xda\x00\x78\x96\x59\x95\xf1\x1f\x37\x87\xed\x04\xdf\x36\x9b\x34\x2f\x93\xc0\xd4\xf4\x04\x96\xea\x17\x93\x92\x17\x49\x32\xea\x20\xe8\xf2\xe8\x95\x70\x83\xdf\x25\xfb\x59\x69\x46\xf7\x68\x7d\x61\x47\x2b\x95\x99\x23\x02\x75\xd8\xff\x4f\xf1\xd1\xa7\x42\xcd\x8f\x3c\xd6\x43\xb0\x42\xcd\x99\xa9\x1e\x3c\x06\x07\x4e\x53\x28\x7d\xec\x8a\x05\xd0\x85\x13\x0f\xc4\x69\xd4\xf2\x8d\x07\x75\x9a\x05\x9a\xed\x7e\x82\x4b\xb4\x82\x92\xf6\xc1\x76\x83\xc7\x9f\xda\x7b\xe0\x04\xa7\x5c\x6f\xd5\xf8\x5d\xda\xe5\xba\xc9\x8b\x6c\xc6\x75\xb6\xb3\x66\xe1\x70\xc3\x29\x07\xea\x61\x5e\x5a\xbc\x83\xb8\x6e\x9c\x92\x53\xa8\xb5\xd0\x05\x5f\x61\x84\x38\x24\x06\x86\xd0\x23\xf8\xc8\xb9\x58\x09\xc0\x41\xb9\x5b\xb1\x85\x9c\x15\x0a\xf2\x60\xe0\xc9\x78\x12\x0e\x1d\x43\x91\x5c\xd2\x3f\x02\xd3\xd4\x3b\x64\xf4\x61\xd9\x1c\x84\x19\x0f\x5a\xbd\x18\x98\xdc\x99\x4c\xc5\xe3\x36\x50\x69\xf4\x92\xaf\x60\x23\x42\x99\x8d\x4e\xd8\xc8\xe7\x0b\xc9\x48\x4a\x1e\x1d\x8f\xea\x02\x4d\x9c\x12\x08\xc9\xe4\x12\x1a\xc3\x77\x9a\x68\x46\x98\x60\xe7\xb8\xf2\x9f\xae\x73\xbe\xd8\xa3\x8d\x8c\x58\xd0\x87\xb0\xa1\xd3\xa0\x23\x3b\x5f\xad\x21\x76\xbd\x5f\xb4\xdd\x6f\x54\x2f\x01\x8e\x8e\x50\x3d\x22\x8e\x16\x76\x36\x5c\x40\xda\x5d\xb0\x78\xbc\xe3\xad\x99\x94\x26\xd7\x6c\xc5\xb5\x55\x45\x5c\xc9\xf0\x3e\xae\xe3\xde\xdb\xb8\x12\x16\x41\xc3\xbf\x92\x28\xb5\xdf\xf9\x1a\x93\x82\x1b\xd3\x62\x79\x05\x46\x60\x1b\x66\x02\x5b\x66\xdc\x39\x9f\x20\xc9\xf3\x82\xaf\x23\xe9\x08\x12\x3a\x5d\x72\x3d\x17\x65\xdc\x33\xc2\xe5\xcb\x6d\x34\x0d\xd9\x38\x39\x71\xe9\x38\x6d\x37\x3d\x8f\xeb\xa4\x57\xe3\x5c\x96\x63\xa5\xc7\x58\xe5\x0b\x2b\x75\xd5\xe5\xe3\x2a\xf3\xa5\x50\x55\x79\x27\x66\x4a\xb6\x23\x1a\xa8\xdc\xc1\x5c\x3d\x03\x60\x1e\xe4\x6d\x3c\x73\x62\x84\xc3\x7a\x34\x8d\xec\xb5\x8c\xe1\x3c\x8c\x61\x12\x94\xdb\xab\xeb\x7d\x26\x9b\x01\x8c\x39\x3e\x93\xbf\x12\xdb\x97\x73\xdf\x53\xea\x79\xb4\xda\x75\x55\x0e\xaf\x34\xf1\x9e\xab\x78\x69\x22\x46\x3c\xf1\x45\xe7\xf8\x4d\xc9\xcb\x6a\x67\x35\x04\x73\x43\xcc\xf2\x0e\x21\x65\x24\xd3\xdf\x41\xbd\xa6\x91\x6f\x17\xff\x8f\x79\x64\xa1\x9c\x0b\x56\x3c\x65\x54\xd1\xee\xcf\x52\xf3\x1c\x15\x48\x3e\x2b\x2b\xc0\x26\xf3\x92\x02\x1b\x29\x7d\xcd\x77\x6d\xc3\x68\x55\x19\x63\x6a\xe2\x4c\xe8\xd2\x5c\x71\x53\xfe\xb2\xca\x78\x07\x7a\x69\x2b\x60\xd1\x94\xb0\x61\x50\xb0\xde\x48\x91\x59\x0e\x4f\x24\xc0\xf6\xd8\xc6\xb2\xde\x0a\x5b\x1c\xea\xc9\xaf\x37\x90\xad\x3e\xb6\x9f\x6a\xef\xf5\x54\x59\x9a\x9c\xb5\x32\xa0\x30\x54\xa3\xaf\xb7\xf6\x38\xd1\xd0\x1a\x93\xe2\xb9\x4d\xe3\xde\xbf\xc7\x85\xe0\xb2\x3d\x5c\x7e\x6b\x45\x41\xb9\xe1\x6b\x88\x3e\xc0\x36\x8b\xdc\x8a\xac\x88\xf2\x32\xcc\x89\x50\x99\x28\x44\x07\xd8\x6b\xcf\x50\x52\xfa\xc2\x39\x7d\x20\x29\xcc\xe9\x6b\x58\xc7\x1b\xf4\x49\x08\x27\xf0\x44\x2d\x2c\x93\xf4\xe0\xb5\xa6\xed\x51\x81\xf8\xf2\x50\xa8\xd9\x13\x26\xf1\x02\x3c\x7f\xfe\x87\xd0\x2e\xee\x3c\xf7\xb7\x66\xd1\xcd\x4e\x73\x77\xeb\xa4\xa3\x9b\xbb\xde\x07\x5a\xb1\x6d\x5b\x02\xfa\xf6\x95\xae\x2d\x8b\x95\x24\xf4\xdc\xfb\x84\xae\x3a\x45\x05\xe2\xf5\x03\xcf\xc1\xae\xce\x82\xb9\x43\x20\xc7\x20\xa9\x8c\x7c\x49\xe8\x96\x4f\xff\xe9\x46\x82\x1c\x34\x1c\x35\x86\x47\xc1\x12\x40\x3e\x39\x8b\xa6\x9a\x89\x22\x57\x52\x2d\x5f\x3d\x08\x15\x96\x2e\xa4\xfb\x2e\xa7\xb4\x76\xd0\xe0\xc2\x83\x7b\xfb\x3a\x61\x00\xf5\x6f\x88\x0f\x2f\x35\xb9\xe9\x20\x2f\x93\x1c\x92\x84\x32\x4c\x1e\xe2\xd5\x0e\x02\x79\xa2\x27\xfe\x51\xe9\x4e\x05\xe6\x70\x9d\x8f\xe3\x99\x7a\x1b\xb2\xd2\x67\x77\xec\xda\x2e\x78\xc7\x72\x2f\x5f\xe5\x84\x71\xb6\xc8\x4d\xa9\x34\xb9\xd6\xe0\x72\x2e\xcd\xe1\x06\xd0\xf6\x18\xb0\xc3\x44\xc3\x4d\x7c\x17\x18\x5f\xad\x04\xf7\x97\xf9\xd0\xd9\x04\xb7\xf1\x68\x31\x53\x3a\x6b\xed\x98\xd3\xee\x5b\x65\xa9\xd6\xcf\x1f\x00\x9b\x59\x70\x53\xde\xfb\x3e\x58\x01\x21\x91\x1b\x87\xe2\x0f\x0d\xb1\x1e\x8d\x4b\xe7\xa2\x64\xfd\x52\x31\x2e\xd1\xaa\xb1\x9f\x0c\xde\x2f\x64\xd4\x63\x43\x69\xee\x55\xe3\xda\x78\xc9\xad\x31\xc4\xf7\xe9\xf9\x52\x18\x13\x05\x1a\x6d\x05\x69\x40\x1e\x5e\xe6\xf3\xf0\x52\x75\x77\xd8\xa3\x80\x80\xe1\x98\x2e\xeb\xd6\x4b\xf7\x52\x63\x20\x26\xa0\x41\xc1\x6f\xab\xbd\xa6\x6c\xb5\xe0\x26\x75\x30\x7e\x17\xf9\x10\xdf\xe4\xed\x90\xd8\x1b\x2d\xb8\x89\x41\x25\xb7\x68\xfb\xa0\x73\xf1\xc8\x26\x7c\x29\x8a\x09\x37\x87\x24\x2e\x70\x80\x53\x26\x4e\xe7\xa7\xec\x68\xda\xf0\xb6\xde\xa8\xf2\x3a\x76\x21\x42\x4f\x76\x80\x94\x1d\xfd\xa6\x7b\x79\x6f\x25\xa1\x7f\xe7\xee\xb9\x67\xf7\xee\x61\x64\x87\x7e\x88\xbd\x19\xc7\xfb\x76\xed\xc7\x70\x27\x56\x1a\x2c\x7e\xb3\xd7\xee\xc8\x1e\x30\x63\xd7\x2e\xfc\xc8\xfb\xaf\x67\x48\xbe\x89\xbb\x56\x93\xc9\xce\xe8\xee\x03\xcd\x15\xcc\xfe\xcd\x00\x3b\xbc\xf9\x3e\x37\x56\x05\x3b\xa4\xd8\xf2\xf7\x82\xed\x69\x02\x3b\xdf\x47\xe4\xf2\x71\xfc\x14\xde\x17\xc8\x9f\x81\xa3\xc5\xae\x80\xf7\x0c\xc0\x38\x77\x5f\x25\x5b\x07\xd9\x00\x68\x5d\x3c\xd2\x2d\x62\x54\x26\x58\x1f\xdf\xc3\x3d\x6d\x62\x8d\xb7\x22\x02\xe0\x43\x30\x29\x8c\xdd\x14\x3f\x44\x3e\x9f\xa8\x50\xa5\x29\x53\xfd\x8a\x6e\xaf\x12\xcb\xfa\xa7\xd6\x15\x8a\x4d\x30\xfe\x52\x75\xb6\x04\x9d\x78\x80\xb2\xd6\xaf\xf1\x0c\x68\xac\x57\xfc\x1b\xd8\x5e\xbb\x01\x77\xfb\xb7\x95\xd9\xd7\x56\x99\x02\x93\x46\xc7\xf0\xcc\x72\xe0\x19\x64\x77\x46\xde\x4d\xec\x29\xb4\xdf\x4e\xb7\x79\x20\x84\x1b\x86\x2b\xfc\x50\xc3\xaa\xaa\xfc\x70\x34\xef\xcd\xa0\x91\xdc\xde\x07\x48\x07\xd2\xbb\x80\xde\x36\x51\x01\xfe\xfa\x56\xdd\xdf\xbf\xde\x52\x12\x32\x45\xd7\xd8\x1b\x65\x66\x31\x42\xaf\x45\x16\x78\xea\x28\x77\x7b\xf8\xac\xe1\xb7\xad\xdb\x27\xb2\xb3\x3f\xff\xfa\xee\x7f\x01\x00\x00\xff\xff\xef\x60\xf6\xa9\xa9\xc4\x07\x00") func operatorsCoreosCom_clusterserviceversionsYamlBytes() ([]byte, error) { return bindataRead( @@ -125,7 +125,7 @@ func operatorsCoreosCom_clusterserviceversionsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_installplansYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\xdd\x6f\x1b\x37\x12\x7f\xf7\x5f\x31\x70\x1f\xd2\x02\x96\xdc\xe6\x80\xc3\x41\x6f\x39\xf7\x7a\xf0\x5d\x3f\x82\xd8\xcd\x4b\xaf\x0f\xa3\xdd\x91\x96\x35\x97\x64\xf9\x21\x47\x57\xf4\x7f\x3f\x0c\xb9\x9f\xd2\xee\x6a\xe5\x38\x69\x70\xe8\xbe\x24\xde\x1d\x92\xf3\x3d\xbf\x21\x29\x34\xe2\x2d\x59\x27\xb4\x5a\x01\x1a\x41\xef\x3c\x29\xfe\xcb\x2d\x1f\xfe\xe6\x96\x42\x5f\xef\xbe\xba\x78\x10\x2a\x5f\xc1\x4d\x70\x5e\x97\x6f\xc8\xe9\x60\x33\xfa\x9a\x36\x42\x09\x2f\xb4\xba\x28\xc9\x63\x8e\x1e\x57\x17\x00\xa8\x94\xf6\xc8\xaf\x1d\xff\x09\x90\x69\xe5\xad\x96\x92\xec\x62\x4b\x6a\xf9\x10\xd6\xb4\x0e\x42\xe6\x64\xe3\xe4\xf5\xd2\xbb\x2f\x97\x7f\x5d\xbe\xbc\x00\xc8\x2c\xc5\xe1\xf7\xa2\x24\xe7\xb1\x34\x2b\x50\x41\xca\x0b\x00\x85\x25\xad\x40\x28\xe7\x51\x4a\x23\x51\xb9\xa5\x36\x64\xd1\x6b\xeb\x96\x99\xb6\xa4\xf9\x9f\xf2\xc2\x19\xca\x78\xed\xad\xd5\xc1\xac\x60\x90\x26\xcd\x56\xb3\x88\x9e\xb6\xda\x8a\xfa\x6f\x80\x05\x68\x59\xc6\xff\x27\xd1\x6f\xd3\xa2\xaf\x25\xaa\xf8\x56\x0a\xe7\xff\x7d\xf8\xe5\x5b\xe1\x7c\xfc\x6a\x64\xb0\x28\xfb\xac\xc6\x0f\xae\xd0\xd6\x7f\xdf\x2e\xcc\x0b\x09\x93\x3e\x09\xb5\x0d\x12\x6d\x6f\xd4\x05\x80\xcb\xb4\xa1\x15\xc4\x41\x06\x33\xca\x2f\x00\x2a\xa5\x55\x93\x2c\x00\xf3\x3c\x1a\x02\xe5\x6b\x2b\x94\x27\x7b\xa3\x65\x28\x55\xb3\x08\xd3\xe4\xe4\x32\x2b\x8c\x8f\xca\xbe\x2f\x08\x36\xc2\x3a\x0f\x37\x77\x6f\x41\x28\xf0\x05\x45\x99\x40\x6f\x20\x93\xc1\x79\xb2\x77\x64\x77\x22\xa3\xca\x37\xe2\xfa\xcd\x74\x00\xbf\x38\xad\x5e\xa3\x2f\x56\xb0\x64\x75\x2f\xc7\x07\xfd\xf4\xe5\xcf\x9d\x71\xc9\x86\x37\x77\x6f\x3b\xef\xfc\x9e\x25\x74\xde\x0a\xb5\x9d\xe2\x18\x8d\xb1\x7a\x87\x12\x4a\x9d\xd3\x04\x2f\x35\xdd\xd1\xb2\xaf\x8e\x3f\x8c\xac\x3d\x3c\x65\x54\xfe\xd0\x94\xbd\x0f\x69\xca\xb5\xd6\x92\x2a\x6f\xa9\x89\x77\x5f\xa1\x34\x05\x7e\x55\xbd\x74\x59\x41\x25\xb6\x46\xd2\x86\xd4\xab\xd7\xb7\x6f\xff\x72\x77\xf0\x01\xfa\xba\xe8\xb8\x1c\xe4\x1c\x85\xe4\xa2\x01\x2b\xc7\x89\xd1\xc3\x86\x44\x70\x14\x2d\xda\x46\xc0\x11\x9b\x7a\xfd\x0b\x65\xbe\xf3\xda\xd2\xaf\x41\x58\xca\xbb\xab\xb3\x46\xea\x18\x3f\x78\xcd\xda\xe9\xbc\x32\x96\xd7\xf2\x9d\x48\x4a\x4f\x27\xc9\xf4\xde\x1f\x48\xf6\x82\xc5\x4f\x74\x3d\xc9\x2a\x87\xa7\xbc\xd2\x19\x0b\xe5\x0b\xe1\xc0\x92\xb1\xe4\x48\xf9\x56\x68\x55\xc9\xb4\x04\x76\x46\xb2\x8e\xa3\x2e\xc8\x9c\x13\xd1\x8e\xac\x07\x4b\x99\xde\x2a\xf1\xdf\x66\x36\x07\x5e\xa7\x08\x40\x4f\xce\x43\x0c\x21\x85\x12\x76\x28\x03\x5d\x01\xaa\x1c\x4a\xdc\x83\x25\x9e\x17\x82\xea\xcc\x10\x49\xdc\x12\xbe\xd3\x96\x0d\xb0\xd1\x2b\x28\xbc\x37\x6e\x75\x7d\xbd\x15\xbe\x4e\xa1\x99\x2e\xcb\xa0\x84\xdf\x5f\xc7\x6c\x28\xd6\x81\xad\x71\x9d\xd3\x8e\xe4\xb5\x13\xdb\x05\xda\xac\x10\x9e\x32\x1f\x2c\x5d\xa3\x11\x8b\xc8\xac\x8a\x69\x74\x59\xe6\x9f\xd9\x2a\xe9\xba\x17\x07\xea\x1b\xf4\x5f\xa8\xf3\xd6\xa4\xae\x39\x7f\x81\x70\xec\x26\x71\x78\x92\xa5\x55\x29\xbf\x62\xad\xbc\xf9\xc7\xdd\x3d\xd4\x0c\x24\xb5\x27\x0d\xb7\xa4\xae\x55\x36\x2b\x4a\xa8\x0d\xd9\x44\xb9\xb1\xba\x8c\xb3\x90\xca\x8d\x16\xca\xc7\x3f\x32\x29\x48\x79\x70\x61\x5d\x0a\xef\xa2\xcf\x91\xf3\x6c\x87\x25\xdc\xc4\x0a\x02\x6b\x82\x60\x72\xf4\x94\x2f\xe1\x56\xc1\x0d\x96\x24\x6f\xd0\xd1\x07\x57\x35\x6b\xd4\x2d\x58\x7d\xf3\x95\xdd\x2d\x80\xc7\x03\x8e\x62\x0c\xa0\x2e\x51\xa3\xd6\xe9\xc4\xf8\x9d\xa1\xac\x89\x86\x26\xa6\x5f\x19\x23\x45\x96\xdc\xbe\xf1\x0e\x76\xe4\x75\x93\x08\x7a\x59\x69\x92\x9d\xb1\xb0\x87\x54\x5e\x8e\xd3\x66\xff\xd3\xd1\x42\xfc\x69\x56\x19\x81\x89\x9c\x01\x31\x6f\xa4\xa5\x8f\xbf\x1c\xe8\xab\x4e\xed\xec\xd0\xec\x61\xc1\x91\x6d\x0b\x86\xd1\x52\x64\x7b\xd8\x68\xcb\xf9\xa1\xa3\xdb\x25\xdc\x7a\x28\x83\x8b\xfe\xa6\x15\xb1\x66\x2f\x5f\x05\xaf\x4b\xf4\x22\xbb\x04\x6d\xe1\xf2\x3b\x54\x01\xe5\xe5\x72\x80\x85\x51\x87\x68\x79\x1f\x52\xe9\x70\x8d\x68\x9f\x71\xd5\x8d\xcf\x85\xd6\xe2\x7e\xe0\xab\xf0\x54\x0e\x0e\x3b\xc1\xfd\x96\x14\x17\x8d\x81\x8c\xdd\x0e\xe5\x44\xb9\x25\x7b\xf4\x3d\x79\xe3\xf8\xb8\x91\x25\xd3\xb0\x06\xe9\x9c\x35\xde\x79\xf4\xe1\x48\xce\x9e\x8b\x5c\x76\x63\x2a\x92\x77\x12\x58\x55\x40\x37\xda\x96\x29\xa6\x70\xad\x43\x4a\x56\x69\x6a\xf6\x0c\xe7\xc9\xb8\x26\x54\x38\xd8\x32\x5d\x1a\x49\xbe\x5f\x7b\x97\xf0\x1f\x05\xd5\x0a\x9c\x0e\xbd\x45\x21\xe3\x54\x98\xf9\x80\x32\xce\x48\x55\x85\xde\x3b\x4f\xe5\xf2\xf2\x79\x22\x35\x43\x8f\x52\x6f\xef\x52\x36\x18\x20\x30\x05\x3a\x3a\x27\xfe\xbc\x27\x15\x38\x0b\x57\xce\xf8\x2a\xcb\x74\x50\xfe\x0d\x6d\x4e\x87\xe4\xf8\x58\xb0\xb4\x21\x4b\x2a\xab\xea\xbb\x4b\x04\x80\x89\x02\x7c\x81\x9e\x23\x39\xb8\xa4\xe6\x5c\x27\x1c\x9c\x37\x50\xa6\x56\xf8\x78\x54\x0e\x2a\xef\x94\xbc\x30\x89\x55\x86\xc5\x7c\x7d\x5b\xe3\x93\x04\x4b\xa8\x96\xce\x0f\x31\x07\xa7\xa2\x80\x9f\x8d\x20\x99\x47\xfc\x39\x87\x83\x17\xb7\x95\x42\x63\x15\xf7\x1a\x10\x8c\xa0\x8c\x7a\x70\x28\x2a\x8c\x30\xaf\x5e\x72\xc1\xb3\x54\x7d\xbb\x4a\xb5\xba\x82\x01\x2d\x5c\xf2\x28\x14\x20\xe3\x02\x91\xc3\xbf\xee\x7e\xf8\xfe\xfa\x9f\x3a\xf1\xc6\x96\x22\xe7\x92\x27\x97\xa4\xfc\x15\xb8\x90\x15\x80\x8e\x59\x63\xf7\x64\xff\xa7\x65\x89\x4a\x6c\xc8\xf9\x65\x35\x1b\x59\xf7\xd3\xcb\x9f\x97\xf0\x8d\xb6\x40\xef\x90\x83\xe7\x0a\x44\xd2\x5a\x03\x2a\x2a\xd7\x88\xa9\x9c\x85\x69\xc6\xc2\xa3\xf0\x45\x64\xc9\xe8\xbc\x62\xfa\x31\x32\xeb\xf1\x81\xf3\x77\x62\x36\x70\x2f\xf3\x40\x2b\xb8\x4c\xad\x49\xb3\xf4\x6f\x0c\xc3\x7f\xbf\x84\xcf\x1f\x0b\xb2\x04\x97\xfc\xe7\x65\x5a\xb0\xc1\x80\xfc\xae\xb6\x63\xbb\x70\x74\x48\x6f\xc5\x76\x4b\x31\xf2\x19\xd0\x30\x68\xf8\x82\x2b\x84\xd8\x80\xd2\x1d\xe2\x38\x05\xeb\xd3\x50\x26\x36\x82\xf2\x23\x46\x7e\x7a\xf9\xf3\x25\x7c\xde\x97\x0b\x84\xca\xe9\x1d\xbc\x4c\xed\x98\x70\x2c\xe3\x17\x4b\xb8\x8f\x96\xd9\x2b\x8f\xef\x78\xce\xac\xd0\x8e\x14\x68\x25\xf7\xcc\x71\x81\x3b\x02\xa7\x4b\x82\x47\x92\x72\x91\x50\x42\x0e\x8f\xb8\x67\x19\x6a\x55\xb2\x55\x11\x0c\x5a\x7f\x80\x90\xef\x7f\xf8\xfa\x87\x55\x5a\x8d\xcd\xb6\x55\xbc\x04\xa3\xaf\x8d\x60\xfc\xcb\xc0\x37\xa1\xb8\x68\x73\x66\x24\x24\x23\x71\xea\x2b\x50\x6d\xa9\x6e\x1e\x37\x81\xf1\xd4\xf2\x10\x31\xcd\xf6\xf8\x21\xb8\x3a\xec\xec\x11\xb6\x1e\x06\xda\x1f\x08\x0a\x67\x8b\x18\x7b\xc0\x59\x22\x7e\xdf\xf1\xc1\x49\x11\x1f\xc2\x9a\xac\x22\x4f\x51\xca\x5c\x67\x8e\x05\xcc\xc8\x78\x77\xad\x77\x9c\x54\xe9\xf1\xfa\x51\xdb\x07\xa1\xb6\x0b\x76\xb2\x45\xb2\xbc\xbb\x8e\xbb\x1f\xd7\x9f\xc5\x7f\xde\x4b\xa2\xd1\x52\x3d\x2c\x56\x24\xff\x18\xb2\xf1\x3a\xee\xfa\xc9\xa2\xd5\x90\xfa\x9c\x4a\xf0\xe2\x2e\x05\x7c\x76\x38\x9a\xc3\xe5\xb1\x10\x59\x51\x37\xad\x9d\x0c\x57\x62\x9e\x52\x20\xaa\xfd\x07\x77\x63\x56\x60\xb0\xbc\xf6\x7e\x51\xed\xcb\x2d\x50\xe5\xfc\x7f\x27\x9c\xe7\xf7\x4f\xd6\x58\x10\x33\x03\xf8\xc7\xdb\xaf\x3f\x8e\x73\x07\xf1\xc4\x68\x5d\x07\x95\x4b\xfa\x56\xeb\x87\x60\x06\x41\x42\x4f\xa0\xbf\x77\xa9\xeb\xfe\xa3\xea\xd2\x84\x5a\x18\xab\xb7\x96\x6b\x65\xa7\xcb\x05\x13\x64\x4a\xaf\x41\x19\xcc\x1e\x70\x4b\xd5\xa2\xb1\x8c\x70\x6f\x5c\x95\xa3\xaa\x15\x18\x87\x39\x4f\xc0\xfd\xa3\xdc\xa7\xdd\x80\x8a\xcf\x11\x36\xeb\xba\xc8\x3c\x46\x04\x5b\xf1\x7d\x9a\xdf\x93\xc0\x6c\x0a\xdb\xa6\xe7\x00\xe1\xbe\xa1\xcd\x28\xa1\xc8\xd9\xef\x37\x62\xa0\x3d\xa9\x49\x0c\xfa\x62\xf4\xa3\x25\x23\x71\x08\x44\xc3\x0c\x08\x09\x47\x7c\x8e\xd1\x1d\x58\xe3\xe6\x60\x58\x6d\x91\x3a\x61\x54\x5a\xee\x91\xc5\x37\x95\x15\x58\x24\x78\x44\x17\x33\x90\xdc\x51\x1e\x37\x60\xc6\x70\xe8\x0c\x8b\xcc\x93\x16\x66\xc1\xe6\x01\x79\x9f\x00\x9e\xbb\x8c\x4f\xa4\xa3\xf4\x9c\x04\xd2\x03\x3c\xfd\x09\xa7\xff\x84\xd3\x9f\x38\x9c\x3e\x2b\x06\xa6\xa0\xf5\x90\xfb\x7f\xaa\x00\xfb\x2c\xa1\xa7\xc0\xf6\x90\xd0\x9f\x08\xe4\x3e\x5b\xc6\x49\xf8\x3d\x26\xe8\x27\x02\xc2\xcf\x12\x76\x26\x20\x1f\x12\xf9\xff\x19\x96\x9f\xa5\xc3\x09\x88\x3e\xa4\xb7\x4f\x02\xa8\xcf\x16\x30\xd3\x2a\x9d\x82\x4f\xa0\x94\x3e\xd6\x6a\x06\x1c\xee\x03\x33\xd3\x28\x7b\xfb\xb4\x5d\x98\x7c\x0a\x4e\x8d\x41\xf2\xf4\x4c\x00\xf3\xee\x24\x27\x30\xd9\x69\xac\x9c\x9e\x45\xb5\x7d\x7d\x82\x88\xd7\x9c\x20\x99\x87\x00\x01\x24\x3a\x7f\x6f\x51\x39\x51\xdf\xe0\x98\xa6\x3f\xb0\xc8\xb7\xc8\x6d\x87\x28\x9b\x2e\x23\xd9\x07\x7c\x33\x65\x05\x68\xe3\x51\x4d\xb5\x2f\xcf\x98\x46\x69\x5f\x8c\x35\x1d\xed\x33\x33\x4a\xf8\x49\xe7\x00\x2b\xc8\xd1\xd3\x82\x39\x3a\x29\xf6\x8f\xf1\xb0\xf2\xd9\x44\x66\x0c\x6f\xac\x5e\x53\xfe\x87\x49\x55\x92\x73\xb8\x3d\x4f\x9c\x57\x50\x84\x12\x15\x58\xc2\x1c\xd7\x92\xea\x49\x18\x8d\xc5\xd3\x4a\xb5\x85\x9c\x3c\x0a\xe9\x3a\x27\x2c\xad\x7d\x9f\x4d\x58\x4b\xe8\x4e\x55\x09\x38\xbe\x62\x92\x86\xc5\x83\xc2\x9e\x3d\x5e\xb8\x68\xe4\x0f\xc1\xe9\xf0\xc9\xd5\x24\xa7\x77\xcd\x89\x54\x8f\xc9\xab\xfa\x04\xf3\xde\x06\xba\x82\x6f\x50\x3a\xba\x82\x1f\xd5\x83\xd2\x8f\xcf\xc7\x6f\x24\x3c\x4b\xaf\x7b\x13\xb9\x6a\xf8\x7c\x06\x56\xda\xee\x7e\x66\xb2\xbf\x6d\x06\xd4\x3b\x34\x55\x87\xbe\x08\x4a\xfc\x1a\xfa\x8d\x4a\x73\xc8\xf4\xf9\x61\x0b\x73\x73\xf7\x36\x3a\x47\x6a\xb7\x5d\x6a\x64\xea\xd6\xee\xe6\xee\xad\xfb\xe2\x44\x6d\x98\x94\xca\x4c\x36\xaa\x3d\x79\xb8\xa7\x3d\x68\xb5\xa4\xce\x3a\x57\x7f\xda\x6d\x19\x13\xa4\x5c\xc2\xad\x7f\xe1\x98\x07\x91\xa1\x94\x7b\xee\x5a\x44\xc9\x81\xd9\xa0\x9e\x53\x55\x6d\x9a\xf3\x19\x05\xe2\x28\xd8\x68\xb3\xa1\xcc\x8b\x1d\x75\x86\xd7\x8a\x4e\x1b\x4e\x94\x57\x72\xbc\x17\x73\xf5\x56\xce\x4c\xd6\xde\x54\xe4\xb5\xa3\x74\xed\xdf\x6a\xb5\x9a\x34\xf5\x9a\xd1\x69\x14\xc1\x46\x07\x95\x03\xfa\x68\x9e\x27\xf2\xdc\x3f\xc3\xfd\x78\x07\xfe\xd3\xf8\xe9\x79\x36\x1b\x3b\x27\xf0\x0d\xfa\x9a\x02\x5f\x6d\x92\xa3\x77\x94\x85\xce\x1d\xaf\xee\x1d\x8e\xa7\xed\x35\x9e\x76\xd9\x73\xd0\xcc\xac\xf4\x39\xb7\xfe\xce\xc5\x13\xcf\xba\xe8\xc9\x72\x3f\x2b\xd2\xa6\xab\xee\x30\xfe\x7e\x93\x8a\x6e\xdc\xea\xcc\xb0\x24\x99\xa1\xa3\xfc\xb0\x16\x27\x30\x3e\xa7\x00\xcf\x60\xf4\x54\xd1\x9d\x31\xc5\x74\x1d\x3c\xe9\xf6\xb1\x2a\x26\xaa\x75\x7d\x0b\xa2\x69\x37\x7a\xfe\xcd\xf9\x04\x21\x23\x1b\x8b\x4c\xba\x44\x87\xac\xab\xc7\x42\x3f\x39\x33\x4e\x58\xbb\xc7\xfa\x77\x35\x7e\xe3\x05\x23\xb6\x5b\x1c\x61\xbb\xaa\xfe\xb5\xd8\x8e\xf2\xde\x55\x9a\x58\x24\x4b\xdc\xc7\xab\x69\xa5\xd1\xd6\x63\x3a\xe0\x08\x2a\x27\xeb\x3c\xaa\x9c\xc7\x3e\x16\xfb\xa8\x06\xc3\x32\x17\xe8\x40\x78\x07\xa9\x2f\xf6\x95\xc1\xce\xbe\x83\x15\xef\xbb\x9c\x14\xb2\xa3\xec\xd7\x3c\xa0\x81\x08\xbd\xc5\x53\x5d\xed\x19\x66\xd2\x0a\xd3\x8c\x49\x9c\xb8\x58\xf5\xbe\x79\xf6\xce\x93\x39\xcc\xab\x1d\x21\x54\x84\xe3\x3b\x91\xa7\xcb\x48\x64\x40\xa8\xe7\x49\xaa\xa7\x0f\x70\xd2\xc1\xc4\x78\x58\x2d\x9a\x5d\x9a\x51\x82\x89\x8e\xf6\x74\x52\x6f\xd6\x7f\xcf\x44\x37\x7e\xc7\x2d\x3d\x47\xf6\xa8\x7f\x37\x31\x61\x97\xce\x2d\xdb\x78\x8f\xd3\xdb\x0a\x03\xed\x67\x59\x07\xe6\x6e\x1e\xcc\xd9\x3a\x58\xa4\x9f\x4f\x4c\x52\x3c\x08\x75\x7c\xf3\xb3\x4b\xc0\xd0\x69\x92\xa0\xbd\xf2\x37\x93\x2c\x6e\x29\x4e\xd2\x56\xc7\x49\xef\x79\x9a\x95\x7e\x3b\xf2\x71\xb6\xdf\x67\x4e\x54\x1f\xfe\x3c\xcb\x64\xa7\xf7\xc7\x67\x4e\xd4\x9a\xe6\x99\xa7\x9b\xb1\xb3\x3d\x73\xce\xdd\x9c\x2d\xe3\x67\x00\x0d\x47\x21\x5f\xf5\xe9\x13\xd5\xc4\xa0\xf5\x22\x0b\x12\x6d\x1b\xfb\x31\x3d\x1f\xfd\xe2\xe8\x6c\x9e\x9d\x47\xeb\xc7\xf0\xe3\xe1\x76\x42\xa2\xac\x39\x8d\xfb\x51\x8f\x05\xa9\xe6\xd8\x2e\xfd\x80\x0b\xd6\xb4\xe5\xb2\x67\x8c\xdc\xd7\xbf\x0e\x68\xef\x9e\x4b\xe1\x7c\xac\xfc\x6d\x15\x9f\x7b\x89\x61\x54\xed\x63\xe0\xd5\x91\xdd\x51\xbe\x02\x6f\x43\xf3\xca\x6b\xcb\x88\xa6\xf7\x2e\xac\x1b\xfe\x5a\x35\x54\x76\x84\xdf\x7e\xbf\xf8\x5f\x00\x00\x00\xff\xff\xaa\x07\xfe\xc9\xfd\x36\x00\x00") +var _operatorsCoreosCom_installplansYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\x4b\x93\xdb\x36\x12\xbe\xcf\xaf\xe8\x9a\x1c\x9c\x54\x59\x9a\x24\x7b\x49\xe9\xe6\x9d\x6c\xb6\x66\x37\x0f\x97\x67\xe2\x4b\x36\x87\x16\xd9\x12\x91\x01\x01\x04\x0f\xc9\xda\x54\xfe\xfb\x56\x03\x7c\x4a\x24\x45\x8d\x27\x8e\x6b\x2b\xbc\xd8\x43\x36\x80\x7e\xf7\xd7\x00\x84\x46\xbc\x25\xeb\x84\x56\x2b\x40\x23\xe8\x9d\x27\xc5\x7f\xb9\xe5\xe3\x57\x6e\x29\xf4\xcd\xee\x8b\xab\x47\xa1\xf2\x15\xdc\x06\xe7\x75\xf9\x86\x9c\x0e\x36\xa3\xaf\x69\x23\x94\xf0\x42\xab\xab\x92\x3c\xe6\xe8\x71\x75\x05\x80\x4a\x69\x8f\xfc\xda\xf1\x9f\x00\x99\x56\xde\x6a\x29\xc9\x2e\xb6\xa4\x96\x8f\x61\x4d\xeb\x20\x64\x4e\x36\x4e\x5e\x2f\xbd\xfb\x7c\xf9\xd5\xf2\xf3\x2b\x80\xcc\x52\x1c\xfe\x20\x4a\x72\x1e\x4b\xb3\x02\x15\xa4\xbc\x02\x50\x58\xd2\x0a\x84\x72\x1e\xa5\x34\x12\x95\x5b\x6a\x43\x16\xbd\xb6\x6e\x99\x69\x4b\x9a\xff\x29\xaf\x9c\xa1\x8c\xd7\xde\x5a\x1d\xcc\x0a\x06\x69\xd2\x6c\x35\x8b\xe8\x69\xab\xad\xa8\xff\x06\x58\x80\x96\x65\xfc\x7f\x12\xfd\x2e\x2d\xfa\x5a\xa2\x8a\x6f\xa5\x70\xfe\xdf\xc7\x5f\xbe\x15\xce\xc7\xaf\x46\x06\x8b\xb2\xcf\x6a\xfc\xe0\x0a\x6d\xfd\xf7\xed\xc2\xbc\x90\x30\xe9\x93\x50\xdb\x20\xd1\xf6\x46\x5d\x01\xb8\x4c\x1b\x5a\x41\x1c\x64\x30\xa3\xfc\x0a\xa0\x52\x5a\x35\xc9\x02\x30\xcf\xa3\x21\x50\xbe\xb6\x42\x79\xb2\xb7\x5a\x86\x52\x35\x8b\x30\x4d\x4e\x2e\xb3\xc2\xf8\xa8\xec\x87\x82\x60\x23\xac\xf3\x70\x7b\xff\x16\x84\x02\x5f\x50\x94\x09\xf4\x06\x32\x19\x9c\x27\x7b\x4f\x76\x27\x32\xaa\x7c\x23\xae\xdf\x4c\x07\xf0\x8b\xd3\xea\x35\xfa\x62\x05\x4b\x56\xf7\x72\x7c\xd0\x4f\x9f\xff\xdc\x19\x97\x6c\x78\x7b\xff\xb6\xf3\xce\x1f\x58\x42\xe7\xad\x50\xdb\x29\x8e\xd1\x18\xab\x77\x28\xa1\xd4\x39\x4d\xf0\x52\xd3\x9d\x2c\xfb\xea\xf4\xc3\xc8\xda\xc3\x53\x46\xe5\x0f\x4d\xd9\xfb\x90\xa6\x5c\x6b\x2d\xa9\xf2\x96\x9a\x78\xf7\x05\x4a\x53\xe0\x17\xd5\x4b\x97\x15\x54\x62\x6b\x24\x6d\x48\xbd\x7a\x7d\xf7\xf6\x6f\xf7\x47\x1f\xa0\xaf\x8b\x8e\xcb\x41\xce\x51\x48\x2e\x1a\xb0\x72\x9c\x18\x3d\x6c\x48\x04\x47\xd1\xa2\x6d\x04\x9c\xb0\xa9\xd7\xbf\x50\xe6\x3b\xaf\x2d\xfd\x1a\x84\xa5\xbc\xbb\x3a\x6b\xa4\x8e\xf1\xa3\xd7\xac\x9d\xce\x2b\x63\x79\x2d\xdf\x89\xa4\xf4\x74\x92\x4c\xef\xfd\x91\x64\x2f\x58\xfc\x44\xd7\x93\xac\x72\x78\xca\x2b\x9d\xb1\x50\xbe\x10\x0e\x2c\x19\x4b\x8e\x94\x6f\x85\x56\x95\x4c\x4b\x60\x67\x24\xeb\x38\xea\x82\xcc\x39\x11\xed\xc8\x7a\xb0\x94\xe9\xad\x12\xff\x6d\x66\x73\xe0\x75\x8a\x00\xf4\xe4\x3c\xc4\x10\x52\x28\x61\x87\x32\xd0\x4b\x40\x95\x43\x89\x07\xb0\xc4\xf3\x42\x50\x9d\x19\x22\x89\x5b\xc2\x77\xda\xb2\x01\x36\x7a\x05\x85\xf7\xc6\xad\x6e\x6e\xb6\xc2\xd7\x29\x34\xd3\x65\x19\x94\xf0\x87\x9b\x98\x0d\xc5\x3a\xb0\x35\x6e\x72\xda\x91\xbc\x71\x62\xbb\x40\x9b\x15\xc2\x53\xe6\x83\xa5\x1b\x34\x62\x11\x99\x55\x31\x8d\x2e\xcb\xfc\x13\x5b\x25\x5d\xf7\xe2\x48\x7d\x83\xfe\x0b\x75\xde\x9a\xd4\x35\xe7\x2f\x10\x8e\xdd\x24\x0e\x4f\xb2\xb4\x2a\xe5\x57\xac\x95\x37\xff\xb8\x7f\x80\x9a\x81\xa4\xf6\xa4\xe1\x96\xd4\xb5\xca\x66\x45\x09\xb5\x21\x9b\x28\x37\x56\x97\x71\x16\x52\xb9\xd1\x42\xf9\xf8\x47\x26\x05\x29\x0f\x2e\xac\x4b\xe1\x5d\xf4\x39\x72\x9e\xed\xb0\x84\xdb\x58\x41\x60\x4d\x10\x4c\x8e\x9e\xf2\x25\xdc\x29\xb8\xc5\x92\xe4\x2d\x3a\xfa\xc3\x55\xcd\x1a\x75\x0b\x56\xdf\x7c\x65\x77\x0b\xe0\xe9\x80\x93\x18\x03\xa8\x4b\xd4\xa8\x75\x3a\x31\x7e\x6f\x28\x6b\xa2\xa1\x89\xe9\x57\xc6\x48\x91\x25\xb7\x6f\xbc\x83\x1d\x79\xdd\x24\x82\x5e\x56\x9a\x64\x67\x2c\xec\x21\x95\x97\xd3\xb4\xd9\xff\x74\xb2\x10\x7f\x9a\x55\x46\x60\x22\x67\x40\xcc\x1b\x69\xe9\xd3\x2f\x47\xfa\xaa\x53\x3b\x3b\x34\x7b\x58\x70\x64\xdb\x82\x61\xb4\x14\xd9\x01\x36\xda\x72\x7e\xe8\xe8\x76\x09\x77\x1e\xca\xe0\xa2\xbf\x69\x45\xac\xd9\xeb\x57\xc1\xeb\x12\xbd\xc8\xae\x41\x5b\xb8\xfe\x0e\x55\x40\x79\xbd\x1c\x60\x61\xd4\x21\x5a\xde\x87\x54\x3a\x5c\x23\xda\x67\x5c\x75\xe3\x73\xa1\xb5\x78\x18\xf8\x2a\x3c\x95\x83\xc3\xce\x70\xbf\x25\xc5\x45\x63\x20\x63\xb7\x43\x39\x51\x6e\xc9\x9e\x7c\x4f\xde\x38\x3e\x6e\x64\xc9\x34\xac\x41\x3a\x17\x8d\x77\x1e\x7d\x38\x91\xb3\xe7\x22\xd7\xdd\x98\x8a\xe4\x9d\x04\x56\x15\xd0\x8d\xb6\x65\x8a\x29\x5c\xeb\x90\x92\x55\x9a\x9a\x3d\xc3\x79\x32\xae\x09\x15\x0e\xb6\x4c\x97\x46\x92\xef\xd7\xde\x25\xfc\x47\x41\xb5\x02\xa7\x43\x6f\x51\xc8\x38\x15\x66\x3e\xa0\x8c\x33\x52\x55\xa1\x0f\xce\x53\xb9\xbc\x7e\x9e\x48\xcd\xd0\xa3\xd4\xdb\xfb\x94\x0d\x06\x08\x4c\x81\x8e\x2e\x89\x3f\xef\x49\x05\xce\xc2\x95\x33\xbe\xca\x32\x1d\x94\x7f\x43\x9b\xf3\x21\x39\x3e\x16\x2c\x6d\xc8\x92\xca\xaa\xfa\xee\x12\x01\x60\xa2\x00\x5f\xa0\xe7\x48\x0e\x2e\xa9\x39\xd7\x09\x07\xe7\x0d\x94\xa9\x15\x3e\x1e\x95\x83\xca\x3b\x27\x2f\x4c\x62\x95\x61\x31\x5f\xdf\xd5\xf8\x24\xc1\x12\xaa\xa5\xf3\x43\xcc\xc1\xb9\x28\xe0\x67\x23\x48\xe6\x11\x7f\xce\xe1\xe0\xc5\x5d\xa5\xd0\x58\xc5\xbd\x06\x04\x23\x28\xa3\x1e\x1c\x8a\x0a\x23\xcc\xab\x97\x5c\xf0\x2c\x55\xdf\x5e\xa6\x5a\x5d\xc1\x80\x16\x2e\x79\x14\x0a\x90\x71\x81\xc8\xe1\x5f\xf7\x3f\x7c\x7f\xf3\x4f\x9d\x78\x63\x4b\x91\x73\xc9\x93\x4b\x52\xfe\x25\xb8\x90\x15\x80\x8e\x59\x63\xf7\x64\xff\xa7\x65\x89\x4a\x6c\xc8\xf9\x65\x35\x1b\x59\xf7\xd3\x97\x3f\x2f\xe1\x1b\x6d\x81\xde\x21\x07\xcf\x4b\x10\x49\x6b\x0d\xa8\xa8\x5c\x23\xa6\x72\x16\xa6\x19\x0b\x7b\xe1\x8b\xc8\x92\xd1\x79\xc5\xf4\x3e\x32\xeb\xf1\x91\xf3\x77\x62\x36\x70\x2f\xf3\x48\x2b\xb8\x4e\xad\x49\xb3\xf4\x6f\x0c\xc3\x7f\xbf\x86\x4f\xf7\x05\x59\x82\x6b\xfe\xf3\x3a\x2d\xd8\x60\x40\x7e\x57\xdb\xb1\x5d\x38\x3a\xa4\xb7\x62\xbb\xa5\x18\xf9\x0c\x68\x18\x34\x7c\xc6\x15\x42\x6c\x40\xe9\x0e\x71\x9c\x82\xf5\x69\x28\x13\x1b\x41\xf9\x09\x23\x3f\x7d\xf9\xf3\x35\x7c\xda\x97\x0b\x84\xca\xe9\x1d\x7c\x99\xda\x31\xe1\x58\xc6\xcf\x96\xf0\x10\x2d\x73\x50\x1e\xdf\xf1\x9c\x59\xa1\x1d\x29\xd0\x4a\x1e\x98\xe3\x02\x77\x04\x4e\x97\x04\x7b\x92\x72\x91\x50\x42\x0e\x7b\x3c\xb0\x0c\xb5\x2a\xd9\xaa\x08\x06\xad\x3f\x42\xc8\x0f\x3f\x7c\xfd\xc3\x2a\xad\xc6\x66\xdb\x2a\x5e\x82\xd1\xd7\x46\x30\xfe\x65\xe0\x9b\x50\x5c\xb4\x39\x33\x12\x92\x91\x38\xf5\x15\xa8\xb6\x54\x37\x8f\x9b\xc0\x78\x6a\x79\x8c\x98\x66\x7b\xfc\x10\x5c\x1d\x76\xf6\x08\x5b\x8f\x03\xed\x4f\x04\x85\xb3\x45\x8c\x3d\xe0\x2c\x11\xbf\xef\xf8\xe0\xa4\x88\x8f\x61\x4d\x56\x91\xa7\x28\x65\xae\x33\xc7\x02\x66\x64\xbc\xbb\xd1\x3b\x4e\xaa\xb4\xbf\xd9\x6b\xfb\x28\xd4\x76\xc1\x4e\xb6\x48\x96\x77\x37\x71\xf7\xe3\xe6\x93\xf8\xcf\x7b\x49\x34\x5a\xaa\x87\xc5\x8a\xe4\x1f\x42\x36\x5e\xc7\xdd\x3c\x59\xb4\x1a\x52\x5f\x52\x09\x5e\xdc\xa7\x80\xcf\x8e\x47\x73\xb8\xec\x0b\x91\x15\x75\xd3\xda\xc9\x70\x25\xe6\x29\x05\xa2\x3a\xfc\xe1\x6e\xcc\x0a\x0c\x96\xd7\x3e\x2c\xaa\x7d\xb9\x05\xaa\x9c\xff\xef\x84\xf3\xfc\xfe\xc9\x1a\x0b\x62\x66\x00\xff\x78\xf7\xf5\x87\x71\xee\x20\x9e\x18\xad\xeb\xa0\x72\x49\xdf\x6a\xfd\x18\xcc\x20\x48\xe8\x09\xf4\xf7\x2e\x75\xdd\x7f\x54\x5d\x9a\x50\x0b\x63\xf5\xd6\x72\xad\xec\x74\xb9\x60\x82\x4c\xe9\x35\x28\x83\xd9\x23\x6e\xa9\x5a\x34\x96\x11\xee\x8d\xab\x72\x54\xb5\x02\xe3\x30\xe7\x09\xb8\x7f\x94\xfb\xb4\x1b\x50\xf1\x39\xc2\x66\x5d\x17\x99\xc7\x88\x60\x2b\xbe\xcf\xf3\x7b\x16\x98\x4d\x61\xdb\xf4\x1c\x21\xdc\x37\xb4\x19\x25\x14\x39\xfb\xfd\x46\x0c\xb4\x27\x35\x89\x41\x5f\x8c\x7e\xb4\x64\x24\x0e\x81\x68\x98\x01\x21\xe1\x84\xcf\x31\xba\x23\x6b\xdc\x1e\x0d\xab\x2d\x52\x27\x8c\x4a\xcb\x3d\xb2\xf8\xa6\xb2\x02\x8b\x04\x7b\x74\x31\x03\xc9\x1d\xe5\x71\x03\x66\x0c\x87\xce\xb0\xc8\x3c\x69\x61\x16\x6c\x1e\x90\xf7\x09\xe0\xb9\xcb\xf8\x44\x3a\x4a\xcf\x59\x20\x3d\xc0\xd3\x5f\x70\xfa\x2f\x38\xfd\x91\xc3\xe9\x8b\x62\x60\x0a\x5a\x0f\xb9\xff\xc7\x0a\xb0\x2f\x12\x7a\x0a\x6c\x0f\x09\xfd\x91\x40\xee\x8b\x65\x9c\x84\xdf\x63\x82\x7e\x24\x20\xfc\x22\x61\x67\x02\xf2\x21\x91\xff\x9f\x61\xf9\x45\x3a\x9c\x80\xe8\x43\x7a\xfb\x28\x80\xfa\x6c\x01\x33\xad\xd2\x29\xf8\x04\x4a\xe9\x63\xad\x66\xc0\xf1\x3e\x30\x33\x8d\xb2\xb7\x4f\xdb\x85\xc9\xe7\xe0\xd4\x18\x24\x4f\xcf\x04\x30\xef\x4e\x72\x06\x93\x9d\xc7\xca\xe9\x59\x54\xdb\xd7\x67\x88\x78\xcd\x09\x92\x79\x08\x10\x40\xa2\xf3\x0f\x16\x95\x13\xf5\x0d\x8e\x69\xfa\x23\x8b\x7c\x8b\xdc\x76\x88\xb2\xe9\x32\x92\x7d\xc0\x37\x53\x56\x80\x36\x1e\xd5\x54\xfb\xf2\x8c\x69\x94\xf6\xc5\x58\xd3\xd1\x3e\x33\xa3\x84\x9f\x74\x0e\xb0\x82\x1c\x3d\x2d\x98\xa3\xb3\x62\xff\x18\x0f\x2b\x9f\x4d\x64\xc6\xf0\xc6\xea\x35\xe5\x7f\x9a\x54\x25\x39\x87\xdb\xcb\xc4\x79\x05\x45\x28\x51\x81\x25\xcc\x71\x2d\xa9\x9e\x84\xd1\x58\x3c\xad\x54\x5b\xc8\xc9\xa3\x90\xae\x73\xc2\xd2\xda\xf7\xd9\x84\xb5\x84\xee\x5c\x95\x80\xd3\x2b\x26\x69\x58\x3c\x28\xec\xd9\xe3\x85\x8b\x46\xfe\x23\x38\x1d\x3e\xb9\x9a\xe4\xf4\xbe\x39\x91\xea\x31\xf9\xb2\x3e\xc1\x7c\xb0\x81\x5e\xc2\x37\x28\x1d\xbd\x84\x1f\xd5\xa3\xd2\xfb\xe7\xe3\x37\x12\x5e\xa4\xd7\x83\x89\x5c\x35\x7c\x3e\x03\x2b\x6d\x77\x3f\x33\xd9\xdf\x35\x03\xea\x1d\x9a\xaa\x43\x5f\x04\x25\x7e\x0d\xfd\x46\xa5\x39\x64\xfa\xf4\xb8\x85\xb9\xbd\x7f\x1b\x9d\x23\xb5\xdb\x2e\x35\x32\x75\x6b\x77\x7b\xff\xd6\x7d\x76\xa6\x36\x4c\x4a\x65\x26\x1b\xd5\x9e\x3c\xdc\xd3\x1e\xb5\x5a\x52\x67\x9d\xab\x3f\xed\xb6\x8c\x09\x52\x2e\xe1\xce\xbf\x70\xcc\x83\xc8\x50\xca\x03\x77\x2d\xa2\xe4\xc0\x6c\x50\xcf\xb9\xaa\x36\xcd\xf9\x8c\x02\x71\x12\x6c\xb4\xd9\x50\xe6\xc5\x8e\x3a\xc3\x6b\x45\xa7\x0d\x27\xca\x2b\x39\xde\x8b\xb9\x7a\x2b\x67\x26\x6b\x6f\x2a\xf2\xda\x51\xba\xf6\x6f\xb5\x5a\x4d\x9a\x7a\xcd\xe8\x34\x8a\x60\xa3\x83\xca\x01\x7d\x34\xcf\x13\x79\xee\x9f\xe1\x7e\xb8\x03\xff\x69\xfc\xf4\x3c\x9b\x8d\x9d\x13\xf8\x06\x7d\x4d\x81\xaf\x36\xc9\xd1\x3b\xca\x42\xe7\x8e\x57\xf7\x0e\xc7\xd3\xf6\x1a\xcf\xbb\xec\x25\x68\x66\x56\xfa\x9c\x5b\x7f\xe7\xe2\x89\x67\x5d\xf4\x6c\xb9\x9f\x15\x69\xd3\x55\x77\x18\x7f\xbf\x49\x45\x37\x6e\x75\x66\x58\x92\xcc\xd0\x51\x7e\x5c\x8b\x13\x18\x9f\x53\x80\x67\x30\x7a\xae\xe8\xce\x98\x62\xba\x0e\x9e\x75\xfb\x58\x15\x13\xd5\xba\xbe\x05\xd1\xb4\x1b\x3d\xff\xe6\x7c\x82\x90\x91\x8d\x45\x26\x5d\xa2\x43\xd6\xd5\xbe\xd0\x4f\xce\x8c\x13\xd6\xee\xb1\xfe\x5d\x8d\xdf\x78\xc1\x88\xed\x16\x27\xd8\xae\xaa\x7f\x2d\xb6\xa3\xbc\x77\x95\x26\x16\xc9\x12\x0f\xf1\x6a\x5a\x69\xb4\xf5\x98\x0e\x38\x82\xca\xc9\x3a\x8f\x2a\xe7\xb1\xfb\xe2\x10\xd5\x60\x58\xe6\x02\x1d\x08\xef\x20\xf5\xc5\xbe\x32\xd8\xc5\x77\xb0\xe2\x7d\x97\xb3\x42\x76\x94\xfd\x9a\x07\x34\x10\xa1\xb7\x78\xaa\xab\x3d\xc3\x4c\x5a\x61\x9a\x31\x89\x13\x17\xab\xde\x37\xcf\xde\x7b\x32\xc7\x79\xb5\x23\x84\x8a\x70\x7c\x27\xf2\x74\x19\x89\x0c\x08\xf5\x3c\x49\xf5\xfc\x01\x4e\x3a\x98\x18\x0f\xab\x45\xb3\x4b\x33\x4a\x30\xd1\xd1\x9e\x4f\xea\xda\xa4\x9b\xf2\xe7\x62\x7f\xec\x6e\x5e\x7a\x1a\x29\xde\x33\x5d\x8e\xdf\x94\x4b\xcf\x89\x55\xeb\x5f\x5f\x4c\x58\xb7\x73\x57\x37\xde\x06\xf5\xb6\x42\x52\x87\x59\x36\x86\xb9\x5b\x10\x73\x36\x20\x16\xe9\x47\x18\x93\x14\x8f\x42\x9d\xde\x1f\xed\x12\x30\x00\x9b\x24\x68\x2f\x0e\xce\x24\x8b\x1b\x93\x93\xb4\xd5\xa1\xd4\x7b\x9e\x89\xa5\x5f\xa0\x7c\x98\x4d\xfc\x99\x13\xd5\x47\x48\xcf\x32\xd9\xf9\x5d\xf6\x99\x13\xb5\xa6\x79\xe6\xe9\x66\xec\x8f\xcf\x9c\x73\x37\x67\xe3\xf9\x19\xa0\xc7\x49\xc8\x57\xdd\xfe\x44\x4d\x32\x68\xbd\xc8\x82\x44\xdb\xc6\x7e\x4c\xf2\x27\xbf\x5b\xba\x98\x67\xe7\xd1\xfa\x31\x14\x7a\xbc\x29\x91\x28\x6b\x4e\xe3\xae\xd6\xbe\x20\xd5\x1c\xfe\xa5\x9f\x81\xc1\x9a\xb6\x5c\x3c\x8d\x91\x87\xfa\x37\x06\xed\x0d\x76\x29\x9c\x8f\xf8\xa1\xc5\x02\x73\xaf\x42\x8c\xaa\x7d\x0c\x02\x3b\xb2\x3b\xca\x57\xe0\x6d\x68\x5e\x79\x6d\x19\x17\xf5\xde\x85\x75\xc3\x5f\xab\x86\xca\x8e\xf0\xdb\xef\x57\xff\x0b\x00\x00\xff\xff\xae\xb2\xfa\x2c\x43\x37\x00\x00") func operatorsCoreosCom_installplansYamlBytes() ([]byte, error) { return bindataRead( @@ -145,7 +145,7 @@ func operatorsCoreosCom_installplansYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_olmconfigsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x58\xef\x6e\xdb\x46\x12\xff\xee\xa7\x18\xe8\x0e\x88\x9d\x93\xa8\x38\x39\xe4\x5a\x02\x41\x10\x28\xe7\x22\x48\x7c\x0d\x62\x5f\x0e\x38\xcb\x77\x1d\x92\x23\x6a\x1b\x72\x97\xdd\x9d\xb5\xad\x16\x7d\xf7\x62\x76\x49\x8a\x92\x45\xc7\x40\x5b\x7e\x11\xb9\x3b\x3b\x3b\x7f\x7f\x33\x23\x6c\xd4\x67\xb2\x4e\x19\x9d\x02\x36\x8a\xee\x98\xb4\x7c\xb9\xe4\xcb\x37\x2e\x51\x66\x7e\x73\x7a\xf4\x45\xe9\x22\x85\x85\x77\x6c\xea\x4f\xe4\x8c\xb7\x39\xbd\xa5\x95\xd2\x8a\x95\xd1\x47\x35\x31\x16\xc8\x98\x1e\x01\xa0\xd6\x86\x51\x96\x9d\x7c\x02\xe4\x46\xb3\x35\x55\x45\x76\x56\x92\x4e\xbe\xf8\x8c\x32\xaf\xaa\x82\x6c\x60\xde\x5d\x7d\xf3\x2c\x79\x99\x3c\x3f\x02\xc8\x2d\x85\xe3\x97\xaa\x26\xc7\x58\x37\x29\x68\x5f\x55\x47\x00\x1a\x6b\x4a\xc1\x54\x75\x6e\xf4\x4a\x95\x2e\x31\x0d\x59\x64\x63\x5d\x92\x1b\x4b\x46\x7e\xea\x23\xd7\x50\x2e\x37\x97\xd6\xf8\x26\x85\x83\x34\x91\x57\x27\x20\x32\x95\xc6\xaa\xee\x1b\x60\x26\x97\x84\xf7\xa8\xf8\xf7\x1f\xce\x17\xe1\xca\xb0\x56\x29\xc7\xef\x77\xd7\x3f\x28\xc7\x61\xaf\xa9\xbc\xc5\x6a\x28\x64\x58\x76\x4a\x97\xbe\x42\x3b\xd8\x38\x02\x70\xb9\x69\x28\x85\x45\xe5\x1d\x93\x3d\x02\x68\x8d\xd1\xca\x31\x6b\x15\xbe\x39\x6d\xc5\x72\xf9\x9a\x6a\xec\x84\x04\x51\x4d\xbf\xf9\xf8\xee\xf3\x8b\x8b\xbd\x0d\x80\x82\x5c\x6e\x55\xc3\xc1\xb4\xbd\x98\xa0\x1c\x20\xd8\xd6\x81\xf2\xd2\x18\xed\x54\x56\x11\xac\x8c\x85\x28\x98\xb7\x4a\x97\x72\x26\x19\xf0\xe3\x8d\x48\x6a\xb2\x1f\x29\xe7\xc1\xb2\xa5\x9f\xbc\xb2\x54\x0c\xaf\x16\xc1\xbb\x80\x18\x2c\x37\x56\x3c\xc1\x03\x2b\xc7\x67\x10\x7e\x3b\xeb\x7b\x3a\x3c\x11\x45\x23\x1d\x14\x12\x79\xe4\x80\xd7\xd4\x99\x8c\x8a\xd6\x3a\x60\x56\xc0\x6b\xe5\xc0\x52\x63\xc9\x91\x8e\xb1\x28\xcb\xa8\x5b\x05\x12\xb8\x20\x2b\x07\xc1\xad\x8d\xaf\x0a\x51\xfc\x86\x2c\x83\xa5\xdc\x94\x5a\xfd\xdc\x73\x73\xc0\x26\x5c\x53\x21\x93\x63\x50\x9a\xc9\x6a\xac\xe0\x06\x2b\x4f\x53\x40\x5d\x40\x8d\x1b\xb0\x24\x7c\xc1\xeb\x01\x87\x40\xe2\x12\x38\x37\x96\x40\xe9\x95\x49\x61\xcd\xdc\xb8\x74\x3e\x2f\x15\x77\xc9\x95\x9b\xba\xf6\x5a\xf1\x66\x1e\xf2\x44\x65\x5e\x62\x75\x5e\xd0\x0d\x55\x73\xa7\xca\x19\xda\x7c\xad\x98\x72\xf6\x96\xe6\xd8\xa8\x59\x10\x56\x87\x04\x4b\xea\xe2\x2f\x9d\x37\xdd\x93\x3d\xf3\x45\x97\x39\x16\x77\xee\x6c\x85\x98\x7e\xd0\xd6\x12\xdd\x31\x56\xe2\xf1\xa8\xcb\xd6\xa4\xb2\x24\x56\xf9\xf4\xcf\x8b\xcb\x6d\x38\x05\xb3\x47\x0b\x6f\x49\xdd\xd6\xd8\x62\x28\xa5\x57\x64\x23\xe5\xca\x9a\x3a\x70\x21\x5d\x34\x46\x69\x0e\x1f\x79\xa5\x48\x33\x38\x9f\xd5\x8a\x5d\x08\x30\x72\x2c\x7e\x48\x60\x11\xb0\x05\x32\x02\xdf\x14\xc8\x54\x24\xf0\x4e\xc3\x02\x6b\xaa\x16\xe8\xe8\x4f\x37\xb5\x58\xd4\xcd\xc4\x7c\x8f\x37\xf6\x10\x1a\xef\x1f\xb8\x97\x50\x00\x1d\x7c\x8d\x7a\xa7\xcf\xe6\x8b\x86\x72\xf1\x92\x98\x4d\x4e\x85\x1c\x46\x3d\x48\xf7\xce\x35\xc9\x63\x2f\x1f\x4f\x53\x79\x56\x84\x62\x9a\x03\x3b\x7b\x22\x9e\xb5\x84\x01\xfb\x51\xe9\x28\xa3\xe0\xa6\xe4\x61\x07\x33\x28\xb8\xf3\xfd\x87\xf3\x9e\xef\xbe\x98\x5f\x11\xf5\x6b\xe2\x06\xb1\x94\x93\x6b\x16\xa6\x51\x54\x2c\x2e\x3e\x8f\x90\xed\xc9\xff\x76\xff\x94\x98\xd9\x3b\x2a\x04\x0e\x5a\x96\x22\xf9\x13\x07\x93\x48\x04\x8b\x8b\xcf\x93\x4e\x91\xe0\x88\xbe\xee\x80\xd2\x8e\xb1\xaa\xa8\x00\xec\x62\x3c\x00\x7e\xc4\xff\x29\xdc\xae\xc9\x12\xe0\xee\x72\xd1\x33\x90\xbb\x8d\x96\xf4\x42\x86\x35\x3a\xc8\x88\xf4\x80\xa9\xd2\xc1\xe9\x2d\xf5\x77\x52\xf5\x22\x2d\xa3\x2d\x89\x1d\x60\x55\xc5\x72\xd7\x60\x2e\x80\xf4\x9f\x35\x69\xb0\x44\x5a\xd4\x28\xa6\xc1\x05\xb7\xaa\xaa\x04\xfe\xa4\xf6\x52\x10\x72\xa0\x98\x9b\x04\x8d\x08\xf3\xf5\x98\x90\x87\x5c\xb7\x75\x5f\x66\x4c\x45\xa8\x77\xe3\x9c\x91\xfd\x3d\x77\x8c\x44\x7a\xa0\xed\x63\x3d\x7e\xfd\xd9\xd1\x9e\x1b\x5d\xa8\x41\x1f\x73\x88\x29\x5a\x8b\x9b\x03\xbb\x8a\xa9\x1e\x8b\xc8\xa1\x86\x93\x45\x77\xc9\x36\x55\x0a\x62\x54\x55\xd4\x4f\xfc\x8e\x92\xdb\x1c\xeb\x1a\x41\xee\xad\x0d\x00\xc9\xe2\xa8\xae\xd8\xbd\xf9\xf8\x0e\xba\xbe\x2c\x81\xd9\x6c\x06\x97\xb2\xec\xd8\xfa\x9c\xc5\x6e\x52\xb8\x74\x41\x45\xe0\x5a\x28\x1b\xaa\x95\x13\xe6\x62\xc3\xa0\x46\x17\x9d\x2b\x45\x55\x01\x0d\xf2\x1a\x92\x68\xea\x64\x6b\x8a\x04\xe0\x4c\x42\xe1\x0e\xeb\xa6\xa2\x69\x30\x03\x9c\x19\xd3\x7a\x28\x5e\xf8\x4b\x50\x74\x3e\x87\x4f\x7d\x15\x08\x9c\x4d\xe6\xc8\xde\xc4\xde\x30\x14\x64\x58\x19\xf3\xc4\xed\xea\x94\x74\x87\xdf\x6b\x73\xab\x0f\x89\x10\xee\x44\x4b\x29\x2c\x27\x6f\x6e\x50\x55\x12\xc7\xcb\xc9\x14\x96\x93\x8f\xd6\x94\x96\x9c\xb4\x5b\xb2\x20\xe5\x79\x39\x79\x4b\xa5\xc5\x82\x8a\xe5\xa4\x63\xfd\xb7\x06\x39\x5f\x9f\x93\x2d\xe9\x3d\x6d\x5e\x05\x86\x3b\x5b\x17\x6c\xa5\x29\xdc\xbc\xaa\x85\xa6\xdf\x13\x04\xbb\xdc\x34\xf4\xaa\xc6\x66\x67\xf1\x1c\x9b\x1d\x46\xbd\x5b\x1d\x5c\x5d\x4b\x09\xb8\x39\x4d\xb6\xae\xfe\xe1\x47\x67\x74\xba\x9c\x6c\x75\x9a\x9a\x5a\x42\xa6\xe1\xcd\x72\x02\x3b\x12\xa4\xcb\x49\x90\xa1\x5b\xef\x84\x4e\x97\x13\xb9\x4d\x96\xad\x61\x93\xf9\x55\xba\x9c\x64\x1b\x26\x37\x3d\x9d\x5a\x6a\xa6\x92\xf1\xaf\xb6\x37\x2c\x27\x3f\xc0\x52\x77\x42\x1b\x5e\x93\x8d\x9e\x76\xf0\xeb\xe4\x60\xa0\x7e\x05\x79\xc7\x9a\xbf\xed\x33\x83\x0a\x1d\x5f\x5a\xd4\x4e\x75\x0d\xfd\x28\x69\x4d\xce\x61\x39\xbe\x6f\x09\x9d\xd1\xa3\xdb\x31\x4a\x46\xb7\x45\x97\x83\x9b\x5f\xab\x1f\x70\x40\x87\x31\xca\xbd\xdc\xbe\x7f\xb0\x03\x30\xd9\x01\x96\x85\x90\xd1\x7d\x5c\x70\x4f\x2d\x89\x2a\xed\x91\xe4\x7f\x0b\x77\x6c\x00\x75\xf0\x5b\xd2\x26\x77\xec\x5d\x33\x92\x02\xa2\x03\x2b\xaf\x0b\xb2\xd5\x46\xda\xb3\x2d\xd7\x7c\x8d\xba\x94\x5e\x09\xde\xad\x62\x61\x50\x0e\xa4\x8f\xfa\x22\x09\x36\x95\x83\x1a\xbc\xeb\x7a\xba\x20\x57\xcf\x51\x80\x25\x02\x42\xcb\x26\xb4\x85\x79\x4e\x0d\x4b\xd6\x8d\xc1\xfe\x03\x0d\xd1\xf0\x59\x19\x5b\x23\xa7\x20\xcd\xdc\x8c\xc7\xc3\xa3\x0d\x8e\x47\x1a\xbe\xa5\x8e\x0d\xec\xda\xd7\x28\xd5\x0e\x8b\x50\xb4\xfb\x3d\x5d\xa8\x1c\x43\x23\xdb\xe1\x2d\x66\xc6\x47\x04\xdc\xfa\xa1\x35\xb5\x74\xae\x19\x09\x52\x86\x1c\x6d\xd5\xfa\x9d\xca\xd7\x78\xf7\x81\x74\xc9\xeb\x14\x5e\x3c\xff\xc7\xcb\x6f\x46\x08\x23\x68\x52\xf1\x1d\x69\x29\xb5\x07\xe6\xa4\x11\x33\xdc\x3f\x38\xe8\xca\x83\x9e\x49\xd7\x9c\x26\xe5\x96\x26\xb6\x0e\x3b\x71\x79\x8b\x0e\x1c\x31\x64\x28\x2d\x90\x6f\xc4\x2e\x52\x05\x42\x0f\xa2\x73\x9a\x82\x5a\x1d\x66\xa6\x7a\x70\xaf\x36\x70\xfa\x7c\x0a\x59\x6b\xe2\xfb\xb0\x7e\x75\x77\x9d\x1c\x10\x59\x39\xf8\x76\xba\x27\x8f\x34\x44\x3e\x54\x44\x09\x1c\xb8\x55\xbc\x0e\xb3\xac\x14\xb5\x76\x5e\x3b\x50\x26\xa9\x97\xf7\x6b\x8e\x93\x62\x59\x86\x81\xfc\xf0\xd3\x85\xad\xd2\xfc\xf2\xef\xe3\xfe\x55\x5a\xd5\xbe\x4e\xe1\xd9\x08\x49\x84\xb4\x47\x7a\x33\x12\x6f\xbb\x04\x14\xe8\x2a\x2d\xd6\x35\xb2\xca\x41\x15\x32\xa7\xac\x14\xd9\x61\x68\x8b\xd2\xed\x41\xa9\xfb\x3b\x56\x7c\xe2\x5a\x1c\x1a\x04\xfb\x47\x6b\x0a\x9f\xcb\xac\x66\x56\x61\xa4\x50\x2b\x95\x0f\x01\x4a\x06\xa0\x90\x0d\x71\x04\x07\xba\x13\xa3\xf7\xc3\x6e\x9c\x87\x09\xb5\xd2\xa5\x6b\xaf\x94\x49\x4f\x00\x24\x56\xe3\xdb\x35\x85\xd2\x13\x46\xf7\xf6\x8c\x0d\x52\x39\x55\x90\x95\x1e\x19\x4a\x8f\x16\x35\x13\x15\x02\x3f\x92\x82\x2d\xed\x00\xf2\x70\x3b\xf6\x75\xd9\x18\x53\x35\x82\x95\x88\xd8\x8e\x8a\x21\x63\xff\xb8\x54\x3d\x7d\xf6\xfc\x41\x97\xf7\x74\xa3\x44\x0d\x32\x93\xd5\x29\xfc\xef\xea\xcd\xec\xbf\x38\xfb\xf9\xfa\xb8\x7d\x79\x36\xfb\xf6\xff\xd3\xf4\xfa\xe9\xe0\xf3\xfa\xe4\xf5\x5f\x47\x38\x1d\x6e\xa0\x47\xc2\xa7\x2d\x22\x5d\x13\xd9\x79\x74\x1a\x2a\x8c\x59\xc1\xa5\xf5\x34\x85\x33\xac\x1c\x4d\xe1\xdf\x3a\x94\x86\xdf\x69\x34\xd2\xbe\x1e\x97\x4e\xaa\xf2\x44\x6e\x3d\xdc\x7c\xf4\x24\x41\xa4\x87\x69\x5a\x71\x1f\x9a\x40\x1e\x67\xa4\xd0\xbe\xc5\x01\xb5\x43\x9a\xc1\xdf\x0b\x10\x10\x4f\x5a\xd6\xa4\x6d\x7f\x93\xdc\xd4\xf3\xc1\xdf\x0f\xd2\x77\x9f\xa3\xde\xc0\x16\xd6\x62\xb3\xba\x1f\xe9\x8e\x05\x9b\x30\xb7\xc6\xb9\x7e\x6c\x71\x50\xa9\x2f\x04\x7d\x47\x1b\xc1\x32\xa3\x1c\x43\xa3\x6e\x33\xc5\x16\xed\x66\x30\x97\x40\x8e\x3a\xfc\x1b\xe2\x68\xe5\x2b\x38\x76\x44\x90\x68\x53\xd0\x7d\x74\x3d\x89\x18\x8a\x99\xaa\x14\x6f\xc2\x18\x4b\x32\x87\x57\xaa\x9d\x0f\xea\xc6\x58\x46\xcd\x31\xdd\x2c\x95\x74\x07\x8a\xa1\x96\x9e\x93\xc2\xe8\x75\x5c\x68\x77\x7a\xfa\xfc\xc5\x85\xcf\x0a\x53\xa3\xd2\x67\x35\xcf\x4f\x5e\x1f\xff\xe4\xb1\x12\xe4\x29\xfe\x85\x35\x9d\xd5\x7c\xf2\xc7\x95\xc5\xd3\x97\x8f\xc8\xa2\xe3\xab\x98\x2b\xd7\xc7\x57\xb3\xf6\xed\x69\xb7\x74\xf2\xfa\x78\x99\x3c\xb8\x7f\xf2\x54\x74\x18\x64\xe0\xf5\xd5\x6c\x9b\x7e\xc9\xf5\xd3\x93\xd7\x83\xbd\x93\x2e\x19\x63\x9d\x4a\x81\xad\xef\x9a\x16\xc7\xc6\x4a\x93\xb2\xb3\xe6\xb3\xde\xbd\xdb\x20\x6c\x33\x17\x7e\xf9\xf5\xe8\xb7\x00\x00\x00\xff\xff\xc6\x78\xa2\x47\x7d\x17\x00\x00") +var _operatorsCoreosCom_olmconfigsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x58\x6f\x6f\xdb\x46\xd2\x7f\xef\x4f\x31\xd0\xf3\x00\xb1\x73\x12\x15\x27\x87\x5c\x4a\x20\x08\x02\xe5\x5c\x04\x89\xaf\x41\xec\xcb\x01\x67\xf9\xae\x43\x72\x44\x6d\x43\xee\xb2\xbb\xb3\xb6\xd5\xa2\xdf\xfd\x30\xbb\x24\x45\xc9\xa2\x63\xa0\xad\xde\x58\x9a\x9d\x9d\x9d\xbf\xbf\x99\x31\x36\xea\x0b\x59\xa7\x8c\x4e\x01\x1b\x45\x77\x4c\x5a\x7e\xb9\xe4\xeb\x2b\x97\x28\x33\xbf\x39\x3d\xfa\xaa\x74\x91\xc2\xc2\x3b\x36\xf5\x67\x72\xc6\xdb\x9c\xde\xd1\x4a\x69\xc5\xca\xe8\xa3\x9a\x18\x0b\x64\x4c\x8f\x00\x50\x6b\xc3\x28\x64\x27\x3f\x01\x72\xa3\xd9\x9a\xaa\x22\x3b\x2b\x49\x27\x5f\x7d\x46\x99\x57\x55\x41\x36\x08\xef\x9e\xbe\x79\x96\xbc\x4a\x9e\x1d\x01\xe4\x96\xc2\xf5\x4b\x55\x93\x63\xac\x9b\x14\xb4\xaf\xaa\x23\x00\x8d\x35\xa5\x60\xaa\x3a\x37\x7a\xa5\x4a\x97\x98\x86\x2c\xb2\xb1\x2e\xc9\x8d\x25\x23\x7f\xea\x23\xd7\x50\x2e\x2f\x97\xd6\xf8\x26\x85\x83\x3c\x51\x56\xa7\x20\x32\x95\xc6\xaa\xee\x37\xc0\x4c\x1e\x09\xdf\xa3\xe1\x3f\x7c\x3c\x5f\x84\x27\x03\xad\x52\x8e\x3f\xec\xd2\x3f\x2a\xc7\xe1\xac\xa9\xbc\xc5\x6a\xa8\x64\x20\x3b\xa5\x4b\x5f\xa1\x1d\x1c\x1c\x01\xb8\xdc\x34\x94\xc2\xa2\xf2\x8e\xc9\x1e\x01\xb4\xce\x68\xf5\x98\xb5\x06\xdf\x9c\xb6\x6a\xb9\x7c\x4d\x35\x76\x4a\x82\x98\xa6\xdf\x7e\x7a\xff\xe5\xc5\xc5\xde\x01\x40\x41\x2e\xb7\xaa\xe1\xe0\xda\x5e\x4d\x50\x0e\x10\x6c\x1b\x40\xf9\xd2\x18\xed\x54\x56\x11\xac\x8c\x85\xa8\x98\xb7\x4a\x97\x72\x27\x19\xc8\xe3\x8d\x68\x6a\xb2\x9f\x28\xe7\x01\xd9\xd2\xcf\x5e\x59\x2a\x86\x4f\x8b\xe2\x5d\x42\x0c\xc8\x8d\x95\x48\xf0\xc0\xcb\xf1\x33\x48\xbf\x1d\xfa\x9e\x0d\x4f\xc4\xd0\xc8\x07\x85\x64\x1e\x39\xe0\x35\x75\x2e\xa3\xa2\xf5\x0e\x98\x15\xf0\x5a\x39\xb0\xd4\x58\x72\xa4\x63\x2e\x0a\x19\x75\x6b\x40\x02\x17\x64\xe5\x22\xb8\xb5\xf1\x55\x21\x86\xdf\x90\x65\xb0\x94\x9b\x52\xab\x5f\x7a\x69\x0e\xd8\x84\x67\x2a\x64\x72\x0c\x4a\x33\x59\x8d\x15\xdc\x60\xe5\x69\x0a\xa8\x0b\xa8\x71\x03\x96\x44\x2e\x78\x3d\x90\x10\x58\x5c\x02\xe7\xc6\x12\x28\xbd\x32\x29\xac\x99\x1b\x97\xce\xe7\xa5\xe2\xae\xb8\x72\x53\xd7\x5e\x2b\xde\xcc\x43\x9d\xa8\xcc\x4b\xae\xce\x0b\xba\xa1\x6a\xee\x54\x39\x43\x9b\xaf\x15\x53\xce\xde\xd2\x1c\x1b\x35\x0b\xca\xea\x50\x60\x49\x5d\xfc\x5f\x17\x4d\xf7\x64\xcf\x7d\x31\x64\x8e\x25\x9c\x3b\x47\x21\xa7\x1f\xf4\xb5\x64\x77\xcc\x95\x78\x3d\xda\xb2\x75\xa9\x90\xc4\x2b\x9f\xff\x7e\x71\xb9\x4d\xa7\xe0\xf6\xe8\xe1\x2d\xab\xdb\x3a\x5b\x1c\xa5\xf4\x8a\x6c\xe4\x5c\x59\x53\x07\x29\xa4\x8b\xc6\x28\xcd\xe1\x47\x5e\x29\xd2\x0c\xce\x67\xb5\x62\x17\x12\x8c\x1c\x4b\x1c\x12\x58\x04\x6c\x81\x8c\xc0\x37\x05\x32\x15\x09\xbc\xd7\xb0\xc0\x9a\xaa\x05\x3a\xfa\xd3\x5d\x2d\x1e\x75\x33\x71\xdf\xe3\x9d\x3d\x84\xc6\xfb\x17\xee\x15\x14\x40\x07\x5f\xa3\xd1\xe9\xab\xf9\xa2\xa1\x5c\xa2\x24\x6e\x93\x5b\xa1\x86\x51\x0f\xca\xbd\x0b\x4d\xf2\xd8\xc7\xc7\xcb\x54\x3e\x2b\x42\x71\xcd\x81\x93\x3d\x15\xcf\x5a\xc6\x80\xfd\xa8\x74\xd4\x51\x70\x53\xea\xb0\x83\x19\x14\xdc\xf9\xe1\xe3\x79\x2f\x77\x5f\xcd\x6f\xa8\xfa\x2d\x75\x83\x5a\xca\xc9\x33\x0b\xd3\x28\x2a\x16\x17\x5f\x46\xd8\xf6\xf4\x7f\xb7\x7f\x4b\xdc\xec\x1d\x15\x02\x07\xad\x48\xd1\xfc\x89\x83\x49\x64\x82\xc5\xc5\x97\x49\x67\x48\x08\x44\xdf\x77\x40\x69\xc7\x58\x55\x54\x00\x76\x39\x1e\x00\x3f\xe2\xff\x14\x6e\xd7\x64\x09\x70\x97\x5c\xf4\x02\xe4\x6d\xa3\xa5\xbc\x90\x61\x8d\x0e\x32\x22\x3d\x10\xaa\x74\x08\x7a\xcb\xfd\xbd\x74\xbd\xc8\xcb\x68\x4b\x62\x07\x58\x55\xb1\xdd\x35\x98\x0b\x20\xfd\x6b\x4d\x1a\x2c\x91\x16\x33\x8a\x69\x08\xc1\xad\xaa\x2a\x81\x3f\xe9\xbd\x14\x94\x1c\x18\xe6\x26\xc1\x22\xc2\x7c\x3d\xa6\xe4\xa1\xd0\x6d\xc3\x97\x19\x53\x11\xea\xdd\x3c\x67\x64\x7f\x2f\x1c\x23\x99\x1e\x78\xfb\x5c\x8f\xbf\xfe\xec\x6c\xcf\x8d\x2e\xd4\x60\x8e\x39\x24\x14\xad\xc5\xcd\x81\x53\xc5\x54\x8f\x65\xe4\xd0\xc2\xc9\xa2\x7b\x64\x5b\x2a\x05\x31\xaa\x2a\xda\x27\x71\x47\xa9\x6d\x8e\x7d\x8d\x20\xf7\xd6\x06\x80\x64\x09\x54\xd7\xec\xde\x7e\x7a\x0f\xdd\x5c\x96\xc0\x6c\x36\x83\x4b\x21\x3b\xb6\x3e\x67\xf1\x9b\x34\x2e\x5d\x50\x11\xa4\x16\xca\x86\x6e\xe5\x44\xb8\xf8\x30\x98\xd1\x65\xe7\x4a\x51\x55\x40\x83\xbc\x86\x24\xba\x3a\xd9\xba\x22\x01\x38\x93\x54\xb8\xc3\xba\xa9\x68\x1a\xdc\x00\x67\xc6\xb4\x11\x8a\x0f\xfe\x0a\xf3\x39\x7c\xee\x3b\x40\x90\x6a\x32\x47\xf6\x26\xce\x85\xa1\x19\xc3\xca\x98\x27\x6e\xd7\x9e\x44\x2e\x7e\xd0\xe6\x56\x1f\x7a\x3a\xbc\x85\x96\x52\x58\x4e\xde\xde\xa0\xaa\x24\x7f\x97\x93\x29\x2c\x27\x9f\xac\x29\x2d\x39\x19\xb3\x84\x20\x6d\x79\x39\x79\x47\xa5\xc5\x82\x8a\xe5\x44\xc4\xfe\xa5\x41\xce\xd7\xe7\x64\x4b\xfa\x40\x9b\xd7\x41\x58\x4f\xbe\x60\x2b\x43\xe0\xe6\x75\x2d\xe7\x81\x2e\x68\x75\xb9\x69\xe8\x75\x8d\x4d\x4f\x38\xc7\xa6\xbf\xdc\x87\xce\xc1\xd5\xb5\xc0\xfc\xcd\x69\xb2\x0d\xe7\x8f\x3f\x39\xa3\xd3\xe5\x64\xab\xff\xd4\xd4\x92\x16\x0d\x6f\x96\x13\xd8\x79\x35\x5d\x4e\xc2\xbb\x1d\xbd\x53\x32\x5d\x4e\xe4\x25\x21\x5b\xc3\x26\xf3\xab\x74\x39\xc9\x36\x4c\x6e\x7a\x3a\xb5\xd4\x4c\xa5\xaa\x5f\x6f\x5f\x58\x4e\x7e\x84\xa5\x16\x65\x0d\xaf\xc9\xc6\x48\x3a\xf8\x6d\x72\x30\x11\xbf\x81\xac\x63\xc3\xdd\xf6\x33\x83\x0a\x1d\x5f\x5a\xd4\x4e\x75\x03\xfb\x28\x6b\x4d\xce\x61\x39\x7e\x6e\x09\x9d\xd1\xa3\xc7\x31\x1b\x46\x8f\xc5\x96\x83\x87\xdf\xea\x0f\x70\xc0\x86\x31\xce\xbd\xda\xbd\x7f\xb1\x03\x28\x39\x01\x16\x42\xa8\xd8\x3e\x27\xb8\xe7\x96\x42\x94\xf1\x47\xea\xbb\x85\x33\x36\x80\x3a\xc4\x2d\x69\x8b\x37\xce\xa6\x19\x49\x83\xd0\x41\x94\xd7\x05\xd9\x6a\x23\xe3\xd7\x56\x6a\xbe\x46\x5d\xca\x2c\x04\xef\x57\x11\xf8\x95\x03\x99\x93\xbe\x4a\x21\x4d\xe5\xa2\x06\xef\xba\x99\x2d\xe8\xd5\x4b\x14\xe0\x88\x05\xdf\x8a\x09\x63\x5f\x9e\x53\xc3\x52\x5d\x63\xb0\xfe\xc0\xc0\x33\xfc\xac\x8c\xad\x91\x53\x90\x61\x6d\xc6\xe3\xe9\xd1\x26\xc7\x23\x1d\xdf\x72\xc7\x01\x75\xed\x6b\x94\x6e\x86\x45\x68\xca\xfd\x99\x2e\x54\x8e\x61\x50\xed\xf0\x14\x33\xe3\x23\xc2\x6d\xe3\xd0\xba\x5a\x26\xd3\x8c\x04\x09\x43\x7d\xb6\x66\xfd\x4e\xe3\x6b\xbc\xfb\x48\xba\xe4\x75\x0a\x2f\x9e\xff\xed\xe5\xab\x11\xc6\x08\x8c\x54\x7c\x4f\x5a\x5a\xe9\x81\x3d\x68\xc4\x0d\xf7\x2f\x0e\xa6\xee\x60\x67\xd2\x0d\x9f\x49\xb9\xe5\x89\xa3\xc1\x4e\x5e\xde\xa2\x03\x47\x0c\x19\xca\x88\xe3\x1b\xf1\x8b\xa0\x7c\x98\x31\x74\x4e\x53\x50\xab\xc3\xc2\x54\x0f\xe0\xd5\x06\x4e\x9f\x4f\x21\x6b\x5d\x7c\x1f\xbe\xaf\xee\xae\x93\x03\x2a\x2b\x07\xdf\x4d\xf7\xf4\x91\x81\xc7\x87\x8e\x27\x89\x03\xb7\x8a\xd7\x61\x57\x95\xa6\xd5\xee\x63\x07\xda\x20\xf5\xfa\x7e\x2b\x70\xd2\x0c\xcb\xb0\x70\x1f\xfe\x74\x69\xab\x34\xbf\xfc\xeb\x78\x7c\x95\x56\xb5\xaf\x53\x78\x36\xc2\x12\x21\xed\x91\xd1\x8c\xcc\xdb\x29\x00\x05\xba\x4a\x8b\x75\x8d\xac\x72\x50\x85\xec\x21\x2b\x45\x76\x98\xda\x62\x74\x7b\x51\xfa\xfa\x8e\x17\x9f\xb8\x16\x87\x06\xc9\xfe\xc9\x9a\xc2\xe7\xb2\x8b\x99\x55\x58\x19\xd4\x4a\xe5\x43\x80\x92\x05\x27\x54\x43\x5c\xb1\x81\xee\xc4\xe9\xfd\x32\x1b\xf7\x5d\x42\xad\x74\xe9\xda\x27\x65\x93\x13\x00\x89\x5d\xf7\x76\x4d\xa1\xf5\x84\xd5\xbc\xbd\x63\x83\x56\x4e\x15\x64\x65\x06\x86\xd2\xa3\x45\xcd\x44\x85\xc0\x8f\x94\x60\xcb\x3b\x80\x3c\xdc\xae\x75\x5d\x35\xc6\x52\x8d\x60\x25\x2a\xb6\xab\x60\xa8\xd8\x3f\xae\x54\x4f\x9f\x3d\x7f\x30\xe4\x3d\xdf\x28\x53\x83\xcc\x64\x75\x0a\xff\xb9\x7a\x3b\xfb\x37\xce\x7e\xb9\x3e\x6e\xbf\x3c\x9b\x7d\xf7\xdf\x69\x7a\xfd\x74\xf0\xf3\xfa\xe4\xcd\xff\x8f\x48\x3a\x3c\x20\x8f\xa4\x4f\xdb\x44\xba\x21\xb1\x8b\xe8\x34\x74\x18\xb3\x82\x4b\xeb\x69\x0a\x67\x58\x39\x9a\xc2\x3f\x75\x68\x0d\xbf\xd3\x69\xa4\x7d\x3d\xae\x9d\x74\xe5\x89\xbc\x7a\x78\xf8\xe8\x59\x82\x4a\x0f\xf3\xb4\xea\x3e\xb4\x61\x3c\xce\x49\x61\x6c\x8b\x0b\x68\x87\x34\x83\x7f\x1f\x40\x40\x3c\x19\x4b\x93\x76\xbc\x4d\x72\x53\xcf\x07\xff\x5e\x90\xb9\xfa\x1c\xf5\x06\xb6\xb0\x16\x87\xd2\xfd\x4c\x77\x2c\xd8\x84\xb9\x35\xce\xf5\x6b\x89\x83\x4a\x7d\x25\xe8\x27\xd7\x08\x96\x19\xe5\x18\x06\x71\x9b\x29\xb6\x68\x37\x83\xbd\x03\x72\xd4\xe1\xbf\x1d\x8e\x56\xbe\x82\x63\x47\x04\x89\x36\x05\xdd\x47\xd7\x93\x88\xa1\x98\xa9\x4a\xf1\x26\xac\xa9\x24\x7b\x76\xa5\xda\xf9\xbf\x6e\x8c\x65\xd4\x1c\xcb\xcd\x52\x49\x77\xa0\x18\x6a\x99\x37\x29\xac\x56\xc7\x85\x76\xa7\xa7\xcf\x5f\x5c\xf8\xac\x30\x35\x2a\x7d\x56\xf3\xfc\xe4\xcd\xf1\xcf\x1e\x2b\x41\x9e\xe2\x1f\x58\xd3\x59\xcd\x27\x7f\x5c\x5b\x3c\x7d\xf9\x88\x2a\x3a\xbe\x8a\xb5\x72\x7d\x7c\x35\x6b\xbf\x3d\xed\x48\x27\x6f\x8e\x97\xc9\x83\xe7\x27\x4f\xc5\x86\x41\x05\x5e\x5f\xcd\xb6\xe5\x97\x5c\x3f\x3d\x79\x33\x38\x3b\xe9\x8a\x31\xf6\xa9\x14\xd8\xfa\x6e\x68\x71\x6c\xac\x0c\x29\x3b\x34\x9f\xf5\xe1\xdd\x26\x61\x5b\xb9\xf0\xeb\x6f\x47\xff\x0b\x00\x00\xff\xff\x65\x57\xc7\x70\x5d\x17\x00\x00") func operatorsCoreosCom_olmconfigsYamlBytes() ([]byte, error) { return bindataRead( @@ -165,7 +165,7 @@ func operatorsCoreosCom_olmconfigsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_operatorconditionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\x5f\x6f\x1b\xb9\x11\x7f\xf7\xa7\x18\xa8\x05\x62\xa7\xd2\x2a\xf6\x15\xe9\x9d\x80\x20\x08\x72\x4d\x11\x24\xbe\x04\xb1\x7b\x0f\xb5\xdc\x66\x76\x39\x5a\xf1\xb2\x4b\xee\x91\x5c\xd9\xba\xc3\x7d\xf7\x62\xc8\x5d\xed\xca\x5a\xc9\x2e\x92\x06\xd7\x82\x7c\xb1\x44\xce\x0e\x87\xf3\xff\x47\xaf\xb0\x92\x3f\x92\xb1\x52\xab\x19\x60\x25\xe9\xd6\x91\xe2\x6f\x36\xf9\xf4\xad\x4d\xa4\x9e\xae\x4e\x8f\x3e\x49\x25\x66\xf0\xb2\xb6\x4e\x97\x1f\xc8\xea\xda\x64\xf4\x3d\x2d\xa4\x92\x4e\x6a\x75\x54\x92\x43\x81\x0e\x67\x47\x00\xa8\x94\x76\xc8\xd3\x96\xbf\x02\x64\x5a\x39\xa3\x8b\x82\xcc\x24\x27\x95\x7c\xaa\x53\x4a\x6b\x59\x08\x32\x9e\x79\xbb\xf5\xea\x49\xf2\x34\x39\x3b\x02\xc8\x0c\xf9\xc7\x2f\x65\x49\xd6\x61\x59\xcd\x40\xd5\x45\x71\x04\xa0\xb0\xa4\x19\xe8\x8a\x0c\x3a\x6d\x32\xad\x84\xdf\xde\x26\xed\x94\x4d\x32\x6d\x48\xf3\x9f\xf2\xc8\x56\x94\xb1\x04\xb9\xd1\x75\xd5\x3d\xb6\x45\x13\x78\xb6\x82\xa2\xa3\x5c\x1b\xd9\x7e\x07\x98\x80\x2e\x4a\xff\x39\x28\xe0\x5d\xc3\xe3\x65\xbb\xb5\x5f\x2b\xa4\x75\x6f\x86\xd7\xdf\x4a\xeb\x3c\x4d\x55\xd4\x06\x8b\x21\xe1\xfd\xb2\x5d\x6a\xe3\x7e\xe8\x44\xe1\xad\xb3\xad\x4d\xac\x54\x79\x5d\xa0\x19\x60\x71\x04\x60\x33\x5d\xd1\x0c\x3c\x87\x0a\x33\x12\x47\x00\x8d\x66\x1b\x8e\x93\x46\x7b\xab\xd3\x66\x03\x9b\x2d\xa9\xc4\x76\x3b\x60\xb6\xea\xc5\xfb\xd7\x3f\x7e\x73\x71\x67\x01\x40\x90\xcd\x8c\xac\x9c\xb7\xd3\xce\x19\x41\x5a\xc0\xc6\x37\xa0\x75\x0e\xd0\x0b\x70\xeb\x8a\xe0\xe3\x0e\xfd\x47\xb8\x59\xca\x6c\xc9\x8f\xd5\x96\x04\x38\xcd\x47\x5d\xd1\x1a\xa4\x5a\x68\x53\x7a\xe3\xf3\xec\xbb\xb7\xe7\x80\xa9\xae\x1d\xb8\x25\x81\x75\xe8\x3c\x5b\x54\x1b\x15\x24\x3d\x21\x79\xb7\x19\xe8\xf4\x27\xca\x5c\x6f\xda\xd0\xcf\xb5\x34\x24\xfa\xe7\x61\x6d\xb4\x2e\xdb\x9b\xae\x0c\xf3\x75\x3d\xfb\x87\xd1\x0b\x90\xad\xf9\x3b\x8a\x79\xc4\xda\x0b\x74\x20\x38\x36\xc8\x7a\xc1\x1b\x3b\x90\x68\x54\xee\x55\xb3\x94\x16\x0c\x55\x86\x2c\xa9\x10\x2d\xed\xd1\xfc\x01\x12\xb8\x20\xc3\x0f\xb2\x67\xd4\x85\x08\x1a\x32\x0e\x0c\x65\x3a\x57\xf2\x97\x0d\x37\xcb\x9a\xe2\x6d\x0a\x74\x64\x1d\x48\xe5\xc8\x28\x2c\x60\x85\x45\x4d\x63\x40\x25\xa0\xc4\x35\x18\x62\xbe\x50\xab\x1e\x07\x4f\x62\x13\x38\xd7\x86\xbc\xf2\x67\xb0\x74\xae\xb2\xb3\xe9\x34\x97\xae\x0d\xff\x4c\x97\x65\xad\xa4\x5b\x4f\x7d\x24\xcb\xb4\xe6\x28\x9a\x0a\x5a\x51\x31\xb5\x32\x9f\xa0\xc9\x96\xd2\x51\xe6\x6a\x43\x53\xac\xe4\xc4\x0b\xab\x42\x68\x96\xe2\x0f\xa6\xf1\x09\xfb\xe8\x8e\xfa\x82\xc9\xac\x33\x52\xe5\x5b\x4b\x3e\xda\x0e\xea\x9a\xe3\x2d\x38\x5e\x78\x3c\x9c\xa5\x53\x29\x4f\xb1\x56\x3e\xfc\xf5\xe2\x12\x5a\x01\x82\xda\x83\x86\x3b\x52\xdb\x29\x9b\x15\x25\xd5\x82\x4c\xa0\x5c\x18\x5d\x7a\x2e\xa4\x44\xa5\xa5\x0a\x8e\x98\x15\x92\x94\x03\x5b\xa7\xa5\x74\xd6\x3b\x18\x59\xc7\x76\x48\xe0\xa5\xcf\x7e\x90\x12\xd4\x95\x40\x47\x22\x81\xd7\x0a\x5e\x62\x49\xc5\x4b\xb4\xf4\x5f\x57\x35\x6b\xd4\x4e\x58\x7d\x0f\x57\x76\x3f\x79\xef\x3e\xb0\x13\x50\x00\x6d\x62\xdd\x6b\x9d\x9d\x90\xbf\xa8\x28\x03\x2c\x0a\x7d\xc3\x16\xcb\x8a\xda\x3a\x32\x80\xa2\x94\x6a\x4f\xf8\x1f\x8e\xfb\x26\x3b\x8c\xa1\xd2\x8e\x4f\x8f\x45\xb1\x06\xbd\x22\x63\xa4\x60\xcb\x87\x67\x0c\x55\xda\x38\x12\x90\xae\x3d\xa7\xa1\xac\x71\xf0\xa0\xfb\x53\x42\x38\x72\x55\xe8\x75\xc9\x1e\xb4\xbb\xd8\x72\x45\x63\x70\x3d\xb0\x2a\x1d\x95\x83\x8f\x1d\x30\x14\x8f\xe6\x90\x43\xf2\x7c\xc6\x96\x5b\xd6\x1b\x75\x99\x9d\xbd\x10\xa5\xb2\x20\xc8\xa1\x2c\x2c\x2c\xb4\x01\xad\x08\x90\x7d\xc0\x85\x4c\x46\x90\xd5\xc6\xf8\x90\x68\x4d\xe5\xa3\xe7\xc5\xfb\xd7\x9b\x72\x90\xc0\x64\x32\x81\x4b\x9e\xb6\xce\xd4\x99\xe3\xd8\xe5\x54\xa5\x04\x09\xcf\x55\x48\xe3\xf3\x93\x65\xe6\x6c\x6b\x7f\x0c\xc0\xe0\x04\x0b\x49\x85\x80\x0a\xdd\x12\x12\xde\xa5\xe6\xf2\xbd\x29\xff\x00\xaf\xb4\x01\xba\xc5\xb2\x2a\x68\x1c\xea\xce\x2b\xad\x2f\x3c\x61\xb3\xe1\xaf\xfe\xa0\xd3\x29\x7c\xd8\xc4\x7d\x70\x8a\xd4\x92\x59\x85\x7e\xc5\x7b\x19\x2c\xb4\x7e\x64\xb7\xcf\x94\xb4\x0f\xbf\x51\xfa\x46\x0d\x89\xe0\xf7\x44\x43\x33\x98\x8f\x5e\xac\x50\x16\x98\x16\x34\x1f\x8d\x61\x3e\x7a\x6f\x74\x6e\xc8\x72\x01\xe7\x09\x4e\xc8\xf3\xd1\xf7\x94\x1b\x14\x24\xe6\xa3\x96\xf5\x9f\x2a\x74\xd9\xf2\x9c\x4c\x4e\x6f\x68\xfd\xcc\x33\xdc\x5a\xba\x70\x86\x1b\x94\xf5\xb3\x92\x69\x36\x6b\xdc\x7d\x5c\xae\x2b\x7a\x56\x62\xb5\x35\x79\x8e\xd5\x16\xa3\x8d\x59\x2d\x5c\x5d\x73\xd0\xaf\x4e\x93\xce\xd4\x1f\x7f\xb2\x5a\xcd\xe6\xa3\xee\x4c\x63\x5d\xb2\xcb\x54\x6e\x3d\x1f\xc1\x96\x04\xb3\xf9\xc8\xcb\xd0\xce\xb7\x42\xcf\xe6\x23\xde\x8d\xa7\x8d\x76\x3a\xad\x17\xb3\xf9\x28\x5d\x3b\xb2\xe3\xd3\xb1\xa1\x6a\xcc\x2d\xc8\xb3\x6e\x87\xf9\xe8\x23\xcc\x55\x2b\xb4\x76\x4b\x32\xc1\xd2\x16\x7e\x1b\x1d\x88\x8d\xc1\x50\x0d\x63\xb8\xdc\x77\x83\x0b\xbf\xb5\x98\xd3\xde\x75\x43\x68\x9b\x9e\x6b\x68\x39\x98\x7e\xef\x32\x0b\x38\xb8\x78\x28\x93\x84\x51\xa0\x75\x97\x06\x95\x95\x6d\xf7\xbb\x8f\xf2\x4e\xc0\xee\x3e\xc8\xd1\x15\x7a\x02\xeb\xc0\xf1\x84\x0f\xd3\x8d\xb1\xdd\x86\x9a\xa3\x8f\xab\x1c\x07\x75\x38\x1a\xe7\x56\x54\xde\x18\x49\x13\xb1\xa1\x05\x49\x09\x6e\x96\xa4\x3c\xab\x5a\x09\x32\xc5\x9a\x73\x6d\xc7\x35\x5b\xa2\xca\xb9\xe4\xc1\x6b\x4e\x01\xe8\x83\x9c\xcb\xe1\x27\x8e\x9a\x31\x3f\xa8\xa0\xb6\x6d\x69\xf6\x72\x6d\x38\x72\xb6\x08\x51\xde\xb0\xf1\xd5\x3d\xcb\xa8\x72\x1c\x4a\x77\x73\x76\x37\x0e\xa6\xcb\x76\x84\xc2\x32\x03\xae\xc9\x13\xde\x78\x0f\x65\xe3\x1c\x0f\x54\x7c\x43\x1d\xfa\x90\x65\x5d\xa2\x62\xef\x11\x2c\x6f\xb7\xa6\x84\xcc\xd0\xf7\x23\x6d\x12\xed\x6a\x5b\x67\x87\x46\xd5\xdc\x80\xa4\xc4\xe9\xcf\x07\x5e\x73\xac\xcf\x3c\x7c\x89\xb7\x6f\x49\xe5\x6e\x39\x83\x6f\xce\xfe\xf2\xf4\xdb\x3d\x84\x21\x13\x92\xf8\x1b\x29\xae\x93\x03\xed\xee\x1e\x35\xec\x3e\xd8\x6b\xae\xfc\x39\x93\xb6\xc7\x48\xf2\x8e\xc6\x7b\xc8\xb6\x5f\xde\xa0\x05\x4b\x0e\x52\x64\x60\x50\x57\xac\x17\x4e\xed\x52\x59\x87\x2a\xa3\x31\xc8\xc5\x30\x33\xb9\xc9\xd8\xc5\x1a\x4e\xcf\xc6\x90\x36\x2a\xde\xcd\xd5\x57\xb7\xd7\xc9\x80\xc8\xd2\xc2\x77\xe3\x3b\xf2\x70\xb7\x58\xfb\x32\xc7\x8e\x03\x37\xd2\x2d\xb9\x99\xf4\xb5\xaf\x69\xbb\x07\x6a\x1f\x6d\xe4\xbd\xcf\x70\x5c\x01\x73\x32\xf7\xba\xad\x54\xee\xe9\x9f\xf7\xdb\x57\x2a\x59\xd6\xe5\x0c\x9e\xec\x21\x09\x29\xed\x81\xd6\x0c\xc4\x5d\xe9\x47\x4e\x5d\xb9\xc1\x92\x3b\xb3\x0c\xa4\xe0\x86\x6b\x21\xc9\xf4\x5d\x9b\x0f\xdd\x3c\xc8\xc5\x7c\x4b\x8b\x8f\x6c\x93\x87\x7a\xce\xfe\xde\x68\x51\x67\xdc\x72\xeb\x85\xef\x27\xe5\x42\x66\xfd\x04\xc5\x7d\xac\x8f\x86\x80\xa4\x80\x6e\x59\xe9\x1b\xcc\x12\x60\x0d\xa1\x92\x2a\xb7\xcd\x96\xdc\xb0\x73\x02\x09\x25\xf6\x66\x49\xbe\x9e\x78\x04\xd6\x3c\x63\xbc\x54\x56\x0a\x32\x24\x00\x21\xaf\xd1\xa0\x72\x44\x82\xd3\x0f\x87\x60\x43\xdb\x4b\x79\xd8\x75\xef\x6d\x34\x86\x50\x0d\xc9\x8a\x45\x6c\x3a\x7e\x1f\xb1\x5f\x2e\x54\x4f\x9f\x9c\x1d\x34\xf9\x86\x6e\x2f\x51\x85\x8e\xb1\xe0\x0c\xfe\x79\xf5\x62\xf2\x0f\x9c\xfc\x72\x7d\xdc\x7c\x78\x32\xf9\xee\x5f\xe3\xd9\xf5\xe3\xde\xd7\xeb\x93\xe7\x7f\xdc\xc3\x29\x44\xd0\x03\xdd\xa7\x29\x22\x6d\x67\xd8\x5a\x74\xec\x2b\x8c\x5e\xc0\xa5\x61\x54\xfa\x0a\x0b\x4b\x63\xf8\xbb\xf2\xa5\xe1\x33\x95\x46\xaa\x2e\xf7\x4b\xc7\x55\x79\xc4\xbb\x0e\x77\x14\x1b\x12\x2f\xd2\x61\x9a\x46\xdc\x3d\x34\x5e\xd6\x87\x29\xc9\xf7\x64\x7a\xd1\xcf\x34\x3d\x94\x08\x3e\xe3\x71\x1f\x9a\x34\x3d\x6d\x92\xe9\x72\xda\x43\x91\xdc\x4c\x9f\xa3\x5a\x43\x97\xd6\x42\x07\x7a\xd7\xd3\x2d\xc3\x23\xc0\xcc\x68\x6b\x37\x30\xd8\x42\x21\x3f\x11\x6c\xda\xd4\x90\x2c\x53\xca\xd0\x77\xdf\x26\x95\xce\xa0\x59\x77\xd2\x59\xc8\x50\x79\x50\x6b\x69\x51\x17\x70\x6c\x89\x20\x51\x5a\xd0\x6e\x76\x3d\x09\x39\x14\x53\x59\x48\xb7\xe6\x2c\x29\x28\xd3\x6a\x51\xc8\xa6\xe9\x2f\x19\x94\xa1\x72\x21\xdc\x0c\xe5\x74\x0b\xd2\x41\xc9\x8d\x24\x59\x26\x39\x16\xca\x9e\x9e\x9e\x7d\x73\x51\xa7\x42\x97\x28\xd5\xab\xd2\x4d\x4f\x9e\x1f\xff\x5c\x63\xc1\x99\x47\xfc\x80\x25\xbd\x2a\xdd\xc9\x97\x2b\x8b\xa7\x4f\x1f\x10\x45\xc7\x57\x21\x56\xae\x8f\xaf\x26\xcd\xa7\xc7\xed\xd4\xc9\xf3\xe3\x79\x72\x70\xfd\xe4\x31\x9f\xa1\x17\x81\xd7\x57\x93\x2e\xfc\x92\xeb\xc7\x27\xcf\x7b\x6b\x27\xbb\xc1\xc8\x15\x4b\x66\xf4\x22\xcb\x74\xfd\xd5\x30\xe7\x70\xec\xdf\x83\xf6\x43\x0a\x68\xf1\xfe\x36\x6c\x1f\xc0\xfa\xd2\xd9\xa6\x7c\x06\x58\x1f\x3c\xa3\x49\x24\x9c\x60\x9d\x41\x59\x04\xb7\xca\x5c\x8d\x45\xef\x4e\x00\xec\xda\x3a\x2a\xbf\x10\xa4\xef\xdc\x38\xc2\xeb\x08\xaf\x23\xbc\xde\x19\xf7\xc3\xeb\x5d\x30\x1a\x91\x78\x44\xe2\xdd\x88\x48\x3c\x22\xf1\x88\xc4\x1f\x64\xcd\x88\xc4\x23\x12\xdf\x1e\x11\x89\x37\x34\x11\x89\x47\x24\xfe\xb5\x91\x78\xa8\x53\x33\x70\xa6\x6e\x9b\x16\xeb\xb4\xe1\x26\x05\x16\xec\xb2\xed\x64\x9d\x6e\xec\xdb\x79\x61\x13\xba\xf0\xeb\x6f\xdb\xaf\xe3\x9c\xc5\xd7\x71\xe2\xeb\x38\xf1\x75\x9c\xf8\x3a\x4e\x3b\xbe\xf6\xeb\x38\xdb\xd7\x73\xe1\x9d\x99\xad\xeb\x38\xef\xb3\x95\xd1\x2b\x29\xc8\xde\x79\x79\xc7\xf7\xe1\x77\xaa\x4c\x89\xaa\xee\xbf\x90\x43\x5f\xe7\x75\x9c\x78\x77\x17\xef\xee\xe2\xdd\x5d\xbc\xbb\x8b\x77\x77\xf1\xee\x2e\xde\xdd\xc5\xbb\xbb\x6e\xc4\xbb\xbb\x78\x77\xb7\xcf\xe4\xf1\xee\xae\x1d\xf1\xee\x2e\xde\xdd\x0d\x98\xe2\xff\xe3\xee\xae\xef\x41\xf1\x57\x1b\x11\x9a\x46\x68\xfa\x3f\x06\x4d\x23\xde\x8c\x78\x33\xe2\xcd\x81\x11\xf1\x66\xc4\x9b\x11\x6f\x46\xbc\xb9\x33\x22\xde\x6c\x68\x22\xde\x8c\x78\x33\xfe\x6a\xe3\x3f\xfc\xd5\xc6\xbb\xb7\xe7\xbd\x37\x41\xc2\x1b\x22\x3d\xcf\x5a\xe2\x8a\x20\x25\x52\x9b\x36\x22\xfe\x17\x37\x42\xe5\x08\x95\x7f\x0f\x50\x39\xfe\x17\x37\xa2\xea\x88\xaa\xf7\x8c\x88\xaa\x23\xaa\x8e\xa8\x3a\xa2\xea\x88\xaa\x0f\x91\x44\x54\x1d\x51\xf5\xd0\xf8\x1d\xff\x02\xa3\x3f\x77\xdf\x0f\x30\xfe\x1d\x00\x00\xff\xff\xcd\xc3\xfd\xa8\xf2\x56\x00\x00") +var _operatorsCoreosCom_operatorconditionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\xdd\x6f\x1b\xb9\x11\x7f\xf7\x5f\x31\x50\x0b\xc4\x4e\xa5\x55\x9c\x2b\xae\x39\x01\x41\x10\xe4\x9a\x22\x48\x7c\x09\x62\xf7\x1e\x6a\xb9\xcd\xec\x72\x24\xf1\xb2\x4b\xee\x91\x5c\xd9\xba\xc3\xfd\xef\xc5\x90\xfb\x25\x69\xa5\xf8\x90\x34\x68\x0b\xf2\xc5\x12\x3f\x86\xc3\xf9\xfe\xd1\x14\x96\xf2\x47\x32\x56\x6a\x35\x03\x2c\x25\xdd\x39\x52\xfc\xcd\x26\x1f\x9f\xd8\x44\xea\xe9\xfa\xfc\xe4\xa3\x54\x62\x06\x2f\x2a\xeb\x74\xf1\x9e\xac\xae\x4c\x46\xdf\xd3\x42\x2a\xe9\xa4\x56\x27\x05\x39\x14\xe8\x70\x76\x02\x80\x4a\x69\x87\xdc\x6d\xf9\x2b\x40\xa6\x95\x33\x3a\xcf\xc9\x4c\x96\xa4\x92\x8f\x55\x4a\x69\x25\x73\x41\xc6\x13\x6f\xb6\x5e\x3f\x4a\x9e\x24\x8f\x4e\x00\x32\x43\x7e\xf9\x95\x2c\xc8\x3a\x2c\xca\x19\xa8\x2a\xcf\x4f\x00\x14\x16\x34\x03\x5d\x92\x41\xa7\x4d\xa6\x95\xf0\xdb\xdb\xa4\xe9\xb2\x49\xa6\x0d\x69\xfe\x53\x9c\xd8\x92\x32\xe6\x60\x69\x74\x55\x76\xcb\xb6\xe6\x04\x9a\x0d\xa3\xe8\x68\xa9\x8d\x6c\xbe\x03\x4c\x40\xe7\x85\xff\x1c\x04\xf0\xb6\xa6\xf1\xa2\xd9\xda\x8f\xe5\xd2\xba\xd7\xc3\xe3\x6f\xa4\x75\x7e\x4e\x99\x57\x06\xf3\x21\xe6\xfd\xb0\x5d\x69\xe3\x7e\xe8\x58\xe1\xad\xb3\xad\x4d\xac\x54\xcb\x2a\x47\x33\x40\xe2\x04\xc0\x66\xba\xa4\x19\x78\x0a\x25\x66\x24\x4e\x00\x6a\xc9\xd6\x14\x27\xb5\xf4\xd6\xe7\xf5\x06\x36\x5b\x51\x81\xcd\x76\xc0\x64\xd5\xf3\x77\xaf\x7e\xfc\xe6\x72\x67\x00\x40\x90\xcd\x8c\x2c\x9d\xd7\xd3\xde\x19\x41\x5a\xc0\xda\x36\xa0\x31\x0e\xd0\x0b\x70\x9b\x92\xe0\xc3\xde\xfc\x0f\x70\xbb\x92\xd9\x8a\x97\x55\x96\x04\x38\xcd\x47\x5d\xd3\x06\xa4\x5a\x68\x53\x78\xe5\x73\xef\xdb\x37\x17\x80\xa9\xae\x1c\xb8\x15\x81\x75\xe8\x3c\x59\x54\xad\x08\x92\x1e\x93\xbc\xdb\x0c\x74\xfa\x13\x65\xae\xd7\x6d\xe8\xe7\x4a\x1a\x12\xfd\xf3\xb0\x34\x1a\x93\xed\x75\x97\x86\xe9\xba\x9e\xfe\x43\xeb\x39\xc8\x56\xff\x8e\x60\x1e\xb0\xf4\xc2\x3c\x10\xec\x1b\x64\x3d\xe3\xb5\x1e\x48\xd4\x22\xf7\xa2\x59\x49\x0b\x86\x4a\x43\x96\x54\xf0\x96\xe6\x68\xfe\x00\x09\x5c\x92\xe1\x85\x6c\x19\x55\x2e\x82\x84\x8c\x03\x43\x99\x5e\x2a\xf9\x4b\x4b\xcd\xb2\xa4\x78\x9b\x1c\x1d\x59\x07\x52\x39\x32\x0a\x73\x58\x63\x5e\xd1\x18\x50\x09\x28\x70\x03\x86\x98\x2e\x54\xaa\x47\xc1\x4f\xb1\x09\x5c\x68\x43\x5e\xf8\x33\x58\x39\x57\xda\xd9\x74\xba\x94\xae\x71\xff\x4c\x17\x45\xa5\xa4\xdb\x4c\xbd\x27\xcb\xb4\x62\x2f\x9a\x0a\x5a\x53\x3e\xb5\x72\x39\x41\x93\xad\xa4\xa3\xcc\x55\x86\xa6\x58\xca\x89\x67\x56\x05\xd7\x2c\xc4\x1f\x4c\x6d\x13\xf6\xc1\x8e\xf8\x82\xca\xac\x33\x52\x2d\xb7\x86\xbc\xb7\x1d\x95\x35\xfb\x5b\x30\xbc\xb0\x3c\x9c\xa5\x13\x29\x77\xb1\x54\xde\xff\xf5\xf2\x0a\x1a\x06\x82\xd8\x83\x84\xbb\xa9\xb6\x13\x36\x0b\x4a\xaa\x05\x99\x30\x73\x61\x74\xe1\xa9\x90\x12\xa5\x96\x2a\x18\x62\x96\x4b\x52\x0e\x6c\x95\x16\xd2\x59\x6f\x60\x64\x1d\xeb\x21\x81\x17\x3e\xfa\x41\x4a\x50\x95\x02\x1d\x89\x04\x5e\x29\x78\x81\x05\xe5\x2f\xd0\xd2\x7f\x5c\xd4\x2c\x51\x3b\x61\xf1\xdd\x5f\xd8\xfd\xe0\xbd\xbf\x60\xcf\xa1\x00\x9a\xc0\x7a\x50\x3b\x7b\x2e\x7f\x59\x52\x06\x98\xe7\xfa\x96\x35\x96\xe5\x95\x75\x64\x00\x45\x21\xd5\x01\xf7\x3f\xee\xf7\x75\x74\x18\x43\xa9\x1d\x9f\x1e\xf3\x7c\x03\x7a\x4d\xc6\x48\xc1\x9a\x0f\x6b\x0c\x95\xda\x38\x12\x90\x6e\x3c\xa5\xa1\xa8\x71\xf4\xa0\x87\x43\x42\x38\x72\x99\xeb\x4d\xc1\x16\xb4\x3f\xd8\x50\x45\x63\x70\x33\x30\x2a\x1d\x15\x83\xcb\x8e\x28\x8a\x5b\x7d\xc8\x21\x7e\x3e\x63\xcb\x2d\xed\x8d\xba\xc8\xce\x56\x88\x52\x59\x10\xe4\x50\xe6\x16\x16\xda\x80\x56\x04\xc8\x36\xe0\x42\x24\x23\xc8\x2a\x63\xbc\x4b\x34\xaa\xf2\xde\xf3\xfc\xdd\xab\x36\x1d\x24\x30\x99\x4c\xe0\x8a\xbb\xad\x33\x55\xe6\xd8\x77\x39\x54\x29\x41\xc2\x53\x15\xd2\xf8\xf8\x64\x99\x38\xeb\xda\x1f\x03\x30\x18\xc1\x42\x52\x2e\xa0\x44\xb7\x82\x84\x77\xa9\x38\x7d\xb7\xe9\x1f\xe0\xa5\x36\x40\x77\x58\x94\x39\x8d\x43\xde\x79\xa9\xf5\xa5\x9f\x58\x6f\xf8\x2b\x4c\xa7\xf0\xbe\xf5\xf9\x60\x10\xa9\x25\xb3\x0e\xb5\x8a\xb7\x30\x58\x68\xfd\xc0\x6e\x9f\x27\xe1\x85\xaf\x95\xbe\x55\x43\x5b\xfb\xbd\xd0\xd0\x0c\xe6\xa3\xe7\x6b\x94\x39\xa6\x39\xcd\x47\x63\x98\x8f\xde\x19\xbd\x34\x64\x39\x71\x73\x07\x07\xe2\xf9\xe8\x7b\x5a\x1a\x14\x24\xe6\x23\x26\xfb\xa7\x12\x5d\xb6\xba\x20\xb3\xa4\xd7\xb4\x79\xea\x89\xb5\xdd\x97\xce\x70\x41\xb2\x79\x5a\xf0\xb8\xef\xe7\x4a\xe3\x6a\x53\xd2\xd3\x02\xcb\xb6\xe3\x02\xcb\x76\x71\xab\x3a\x0b\xd7\x37\xec\xd8\xeb\xf3\xa4\x53\xe7\x87\x9f\xac\x56\xb3\xf9\xa8\xe3\x7f\xac\x0b\x36\x8b\xd2\x6d\xe6\x23\xd8\xda\x75\x36\x1f\xf9\x7d\x9b\xfe\x86\xc9\xd9\x7c\xc4\x3b\x71\xb7\xd1\x4e\xa7\xd5\x62\x36\x1f\xa5\x1b\x47\x76\x7c\x3e\x36\x54\x8e\xb9\xcc\x78\xda\xed\x30\x1f\x7d\x80\xb9\x62\x66\xb5\x5b\x91\x09\x9a\xb4\xf0\xdb\xe8\x88\xed\x0f\xba\x62\x68\xc3\xe9\xbc\x6b\x9c\xd8\xad\xc5\x25\x1d\x1c\x37\x84\xb6\xae\xa9\x86\x86\x83\x8a\x0f\x0e\x33\x83\x83\x83\xc7\x22\x45\x68\x39\x5a\x77\x65\x50\x59\xd9\x54\xb7\x87\x66\xee\x38\xe4\xfe\x42\xf6\x9e\x90\xf3\xad\x03\xc7\x1d\xde\x0d\x5b\x45\xbb\x76\x36\x7b\x17\x67\x31\x76\xda\x70\x34\x8e\x9d\xa8\xbc\x32\x92\xda\x23\x43\x89\x91\x12\xdc\xae\x48\x79\x52\x95\x12\x64\xf2\x0d\xc7\xd2\x8e\x6a\xb6\x42\xb5\xe4\x94\x06\xaf\xd8\xc5\xd1\x3b\x31\xa7\xbb\x8f\xec\x1d\x63\x5e\xa8\xa0\xb2\x4d\xea\xf5\x7c\xb5\x14\x39\x1a\x04\x2f\xae\xc9\xf8\xec\x9d\x65\x54\x3a\x76\x99\xdd\x98\xdc\xb5\xa3\xe1\xb0\x69\x21\x71\xcc\x80\x73\xee\x84\x37\x3e\x30\xb3\x36\x8e\x7b\x0a\xbe\x9e\x1d\xea\x8c\x55\x55\xa0\x62\xeb\x11\xcc\x6f\x37\xa6\x84\xcc\xd0\xd7\x1b\x4d\x90\xec\x72\x57\xa7\x87\x5a\xd4\x5c\x60\xa4\xc4\xe1\xcd\x3b\x5d\x7d\xac\xcf\x3c\x7c\x81\x77\x6f\x48\x2d\xdd\x6a\x06\xdf\x3c\xfe\xcb\xb7\x4f\x0e\x4c\x0c\xd1\x8e\xc4\xdf\x48\x71\x1e\x1c\x28\x67\x0f\x88\x61\x7f\x61\xaf\x78\xf2\xe7\x4c\x9a\x1a\x22\x59\x76\x73\xbc\x85\x6c\xdb\xe5\x2d\x5a\xb0\xe4\x20\x45\x2e\xfc\xab\x92\xe5\xc2\xa1\x5b\x2a\xeb\x50\x65\x34\x06\xb9\x18\x26\x26\xdb\xa8\x9c\x6f\xe0\xfc\xf1\x18\xd2\x5a\xc4\xfb\x31\xf9\xfa\xee\x26\x19\x60\x59\x5a\xf8\x6e\xbc\xc3\x0f\x57\x83\x95\x4f\x63\x6c\x38\x70\x2b\xdd\x8a\x8b\x45\x9f\xdb\xea\xb2\x7a\x20\xb7\x51\xcb\xef\xa7\x14\xc7\x19\x6e\x49\xe6\x93\x66\x2b\x95\xfb\xf6\xcf\x87\xf5\x2b\x95\x2c\xaa\x62\x06\x8f\x0e\x4c\x09\x21\xed\x9e\xda\x0c\x93\xbb\xd4\x8e\x1c\xba\x96\x06\x0b\xae\xbc\x32\x90\x82\x0b\xaa\x85\x24\xd3\x37\x6d\x3e\x74\xbd\x90\x93\xf5\x96\x14\x1f\xd8\x3a\x0e\xf5\x8c\xfd\x9d\xd1\xa2\xca\xb8\xa4\xd6\x0b\x5f\x2f\xca\x85\xcc\xfa\x01\x8a\xeb\x54\xef\x0d\x01\x29\x01\xdd\xb1\xd0\x5b\x4c\x12\x60\x0b\xa1\x92\x6a\x69\xeb\x2d\xb9\x20\xe7\x00\x12\x52\xe9\xed\x8a\x7c\x3e\xf1\x08\xab\x5e\x63\x3c\x57\x56\x0a\x32\x24\x00\x61\x59\xa1\x41\xe5\x88\x04\x87\x1f\x76\xc1\x7a\x6e\x2f\xe4\x61\x57\x9d\x37\xde\x18\x5c\x35\x04\x2b\x66\xb1\xae\xe8\xbd\xc7\x7e\x39\x57\x3d\x7f\xf4\xf8\xa8\xca\xdb\x79\x07\x27\x95\xe8\x18\xeb\xcd\xe0\x9f\xd7\xcf\x27\xff\xc0\xc9\x2f\x37\xa7\xf5\x87\x47\x93\xef\xfe\x35\x9e\xdd\x3c\xec\x7d\xbd\x39\x7b\xf6\xc7\x03\x94\x82\x07\xdd\xd3\x7c\xea\x24\xd2\x54\x7e\x8d\x46\xc7\x3e\xc3\xe8\x05\x5c\x19\x46\x9d\x2f\x31\xb7\x34\x86\xbf\x2b\x9f\x1a\x3e\x53\x68\xa4\xaa\xe2\x30\x77\x9c\x95\x47\xbc\xeb\x70\x45\xd1\x4e\xf1\x2c\x1d\x9f\x53\xb3\x7b\x60\x8e\xe7\xf5\x7e\x42\xf2\xb5\x98\x5e\xf4\x23\x4d\x0f\x05\x82\x8f\x78\x5c\x6b\x26\x75\xcd\x9a\x64\xba\x98\xf6\x50\x22\x17\xcb\x17\xa8\x36\xd0\x85\xb5\x50\x69\xee\x5a\xba\x65\xf8\x03\x98\x19\x6d\x6d\x0b\x73\x2d\xe4\xf2\x23\x41\x5b\x8e\x86\x60\x99\x52\x86\xbe\xba\x36\xa9\x74\x06\xcd\xa6\xe3\xce\x42\x86\xca\x83\x56\x4b\x8b\x2a\x87\x53\x4b\x04\x89\xd2\x82\xf6\xa3\xeb\x59\x88\xa1\x98\xca\x5c\xba\x0d\x47\x49\x41\x99\x56\x8b\x5c\xd6\x45\x7d\xc1\xa0\x0b\x95\x0b\xee\x66\x68\x49\x77\x20\x1d\x14\x5c\x44\x92\xe5\x29\xa7\x42\xd9\xf3\xf3\xc7\xdf\x5c\x56\xa9\xd0\x05\x4a\xf5\xb2\x70\xd3\xb3\x67\xa7\x3f\x57\x98\x73\xe4\x11\x3f\x60\x41\x2f\x0b\x77\xf6\xe5\xd2\xe2\xf9\xb7\xf7\xf0\xa2\xd3\xeb\xe0\x2b\x37\xa7\xd7\x93\xfa\xd3\xc3\xa6\xeb\xec\xd9\xe9\x3c\x39\x3a\x7e\xf6\x90\xcf\xd0\xf3\xc0\x9b\xeb\x49\xe7\x7e\xc9\xcd\xc3\xb3\x67\xbd\xb1\xb3\x7d\x67\xe4\x8c\x25\x33\x7a\x9e\x65\xba\xfa\x6a\x98\x72\xd8\xf7\x3f\x81\xe6\x43\x08\x68\xf0\xfc\x36\x2c\x1f\xc0\xf2\xd2\xd9\x3a\x7d\x06\xd8\x1e\x2c\xa3\x0e\x24\x1c\x60\x9d\x41\x99\x07\xb3\xca\x5c\x85\x79\x0f\xf3\x83\xdd\x58\x47\xc5\x17\x82\xec\x9d\x19\x47\xf8\x1c\xe1\x73\x84\xcf\x7b\x6d\x32\x00\x36\x23\xd2\x8e\x48\xbb\x6b\x11\x69\x47\xa4\x1d\x91\xf6\xbd\xb4\x19\x91\x76\x44\xda\xdb\x2d\x22\xed\x7a\x4e\x44\xda\x11\x69\x7f\x6d\xa4\x1d\xf2\xd4\x0c\x9c\xa9\x9a\xa2\xc5\x3a\x6d\xb8\x48\x81\x05\x9b\x6c\xd3\x59\xa5\xad\x7e\x3b\x2b\xac\x5d\x17\x7e\xfd\x6d\xfb\x39\xcd\xe3\xf8\x9c\x26\x3e\xa7\x89\xcf\x69\xe2\x73\x9a\xa6\x7d\xed\xe7\x34\xdb\xd7\x6f\xe1\xcd\xcb\xd6\x75\x9b\xb7\xd9\xd2\xe8\xb5\x14\x64\x77\x1e\xdf\xf8\x3a\x7c\x27\xcb\x14\xa8\xaa\xfe\x83\x1a\xfa\x3a\xcf\x69\xe2\xdd\x5c\xbc\x9b\x8b\x77\x73\xf1\x6e\xae\xd7\xe2\xdd\x5c\xdb\xe2\xdd\x5c\xbc\x9b\x8b\x77\x73\xf1\x6e\x2e\xde\xcd\xed\xb6\x78\x37\x17\x5a\xbc\x9b\x8b\x77\x73\x03\xed\x7f\xe3\x6e\xae\x6f\x41\xf1\x57\x15\x11\x7a\x46\xe8\xf9\x5f\x06\x3d\x23\x9e\x8c\x78\x32\xe2\xc9\x81\x16\xf1\x64\xc4\x93\x11\x4f\x46\x3c\xb9\xd7\x22\x9e\xac\xe7\x44\x3c\x19\xf1\x64\xfc\x55\xc5\xef\xfc\x55\xc5\xdb\x37\x17\xbd\x97\x1c\xe1\x85\x47\xcf\xb2\x56\xb8\x26\x48\x89\x54\x5b\x46\xc4\xff\xc2\x46\x28\x1c\xa1\x70\xfc\x2f\x2c\x44\xd4\x1c\x51\x73\x44\xcd\x11\x35\xef\x2a\x2e\xa2\xe6\x88\x9a\xb7\x55\x19\x51\xf3\xef\x17\x5a\x44\xcd\x11\x35\x0f\xa8\xe2\xff\x03\x35\x1f\xfb\x85\x44\xbf\xef\x53\x3f\x90\xf8\x77\x00\x00\x00\xff\xff\x79\xf0\xdc\xa4\x52\x56\x00\x00") func operatorsCoreosCom_operatorconditionsYamlBytes() ([]byte, error) { return bindataRead( @@ -185,7 +185,7 @@ func operatorsCoreosCom_operatorconditionsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_operatorgroupsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5a\xe9\x6f\x1b\x37\x16\xff\xee\xbf\xe2\x41\x5d\x20\x76\x56\x1a\xc5\xee\x22\xdb\x0a\x08\x02\x23\x69\x0a\x6f\x73\x18\xb1\xdb\x0f\x6b\x7b\xb7\xd4\xcc\xd3\x88\x35\x87\x9c\x92\x1c\xdb\x6a\x90\xff\x7d\xf1\x1e\x39\x87\x4e\xcb\x49\xda\xed\x2e\xa4\x2f\xf6\x0c\x8f\x79\xe7\xef\x1d\xa4\x28\xe5\x4f\x68\x9d\x34\x7a\x04\xa2\x94\x78\xe7\x51\xd3\x93\x4b\xae\xbf\x71\x89\x34\xc3\x9b\xc3\xbd\x6b\xa9\xb3\x11\xbc\xa8\x9c\x37\xc5\x7b\x74\xa6\xb2\x29\xbe\xc4\x89\xd4\xd2\x4b\xa3\xf7\x0a\xf4\x22\x13\x5e\x8c\xf6\x00\x84\xd6\xc6\x0b\x7a\xed\xe8\x11\x20\x35\xda\x5b\xa3\x14\xda\x41\x8e\x3a\xb9\xae\xc6\x38\xae\xa4\xca\xd0\xf2\xe6\xf5\xa7\x6f\x9e\x24\x4f\x93\xa3\x3d\x80\xd4\x22\x2f\x3f\x97\x05\x3a\x2f\x8a\x72\x04\xba\x52\x6a\x0f\x40\x8b\x02\x47\x60\x4a\xb4\xc2\x1b\x9b\x5b\x53\x95\x2e\xa9\x1f\x5d\x92\x1a\x8b\x86\xfe\x14\x7b\xae\xc4\x94\xbe\xce\x73\xda\x25\x73\x73\xc2\x7e\x35\x91\xc2\x63\x6e\xac\xac\x9f\x01\x06\x60\x54\xc1\xff\x07\xe6\xdf\xc5\x3d\xbe\xa7\x2d\xf9\xbd\x92\xce\xff\xb0\x3c\xf6\x5a\x3a\xcf\xe3\xa5\xaa\xac\x50\x8b\x04\xf3\x90\x9b\x1a\xeb\xdf\xb6\x9f\xe7\xcf\xe5\x61\x48\xea\xbc\x52\xc2\x2e\xac\xdb\x03\x70\xa9\x29\x71\x04\xbc\xac\x14\x29\x66\x7b\x00\x51\x7c\x71\x9b\x41\x14\xd1\xcd\x61\xdc\xd5\xa5\x53\x2c\x44\xfd\x0d\xa0\x2d\xf5\xf1\xe9\xc9\x4f\x5f\x9f\x2d\x0c\x00\x64\xe8\x52\x2b\x4b\xcf\xca\x98\x63\x08\xa4\x03\x3f\x45\xa8\xb4\xf4\x60\x26\x50\x54\xca\x4b\x8f\x5a\xe8\x74\x06\x13\x63\xe1\xdd\xeb\x37\x50\x08\x2d\x72\xcc\x3a\xa2\x86\x13\x4f\xba\x77\xde\x0a\xa9\xc3\x0e\x52\x3b\x2f\x94\x62\xf5\xd2\x4e\xcd\x64\x90\x1a\xa4\x77\x41\x23\xc4\x1b\x78\x03\x02\x48\x8d\x72\x22\x31\x03\x87\xfc\x69\x2f\x6c\x8e\xbe\x9d\xe6\x92\x0e\x07\x7e\x46\xe2\x31\xe3\x5f\x30\xf5\x9d\xd7\x16\x7f\xad\xa4\xc5\xac\xcb\x2c\x89\xaa\x36\xda\xce\xeb\xd2\x12\x45\xbe\x63\x05\xe1\xd7\x71\x91\xb9\xf7\x0b\x52\x7b\x44\xa2\x0d\xf3\x20\x23\xef\xc0\xc0\x76\x54\x12\xb1\xc1\x62\x67\x4e\xa6\xd2\x81\xc5\xd2\xa2\x43\xed\x1b\x89\x08\x1d\x19\x48\xe0\x0c\x2d\x2d\x24\x5b\xa9\x54\x46\xa2\xbc\x41\xeb\xc1\x62\x6a\x72\x2d\x7f\x6b\x76\x73\x24\x2b\xfa\x8c\x12\x1e\x9d\x07\xa9\x3d\x5a\x2d\x14\xdc\x08\x55\x61\x1f\x84\xce\xa0\x10\x33\xb0\x48\xfb\x42\xa5\x3b\x3b\xf0\x14\x97\xc0\x1b\x63\x49\x3b\x13\x33\x82\xa9\xf7\xa5\x1b\x0d\x87\xb9\xf4\x35\x00\xa4\xa6\x28\x48\xf9\xb3\x21\xfb\xb2\x1c\x57\xa4\xb3\x61\x86\x37\xa8\x86\x4e\xe6\x03\x61\xd3\xa9\xf4\x98\xfa\xca\xe2\x50\x94\x72\xc0\xc4\x6a\x06\x81\xa4\xc8\xbe\xb2\x11\x32\xdc\xa3\x05\xf1\x05\x95\x39\x6f\xa5\xce\xe7\x86\xd8\xe7\x36\xca\x9a\x3c\x8f\x2c\x53\xc4\xe5\x81\x97\x56\xa4\xf4\x8a\xa4\xf2\xfe\xbb\xb3\x73\xa8\x09\x08\x62\x0f\x12\x6e\xa7\xba\x56\xd8\x24\x28\xa9\x27\x68\xc3\xcc\x89\x35\x05\xef\x82\x3a\x2b\x8d\xd4\x9e\x1f\x52\x25\x51\x7b\x70\xd5\xb8\x20\xa3\x25\x03\x43\xe7\x49\x0f\x09\xbc\x60\xfc\x83\x31\x42\x55\x66\xc2\x63\x96\xc0\x89\x86\x17\xa2\x40\xf5\x42\x38\xfc\xdd\x45\x4d\x12\x75\x03\x12\xdf\xf6\xc2\xee\xc2\xf7\xf2\x82\x25\x87\x02\xa8\xe1\x75\xad\x76\xe6\xf0\xe3\xac\xc4\xb4\xc6\x10\x5a\xc9\x98\x21\xf4\x02\xc8\xd4\x2a\x4a\xb6\x25\x62\xbd\xbb\x32\x89\xa8\x30\xf5\xc6\x2e\x8f\x2c\x90\x7a\x16\x27\xc6\x15\x81\xcc\x39\xd2\x1e\xb9\xcd\xb8\xb3\x05\xa5\xf7\x51\xcb\x5a\x10\x3e\x9d\x7e\x77\x47\x36\xd9\x81\xf4\x7b\xa8\x5f\x5c\x14\x3c\x82\x22\x13\xa1\x89\x12\x63\x54\x8d\x28\x6a\x24\x2c\x82\xc9\x9f\x4f\x71\xee\x0d\x08\x8b\x70\xfc\xf6\x25\x66\xab\x98\x6b\x19\x14\xd6\x8a\xd9\x9a\x19\xd2\x63\xb1\x96\xf0\x05\xd2\x8f\x37\x90\x17\x1d\xbb\x1e\xf1\x53\xc1\xb1\xc4\x73\x24\x09\xa0\xd5\x07\x01\xd7\x38\x0b\xf8\x46\xb0\x19\x55\x16\x26\x5b\x64\x34\x64\x65\x5e\xe3\x8c\x27\x45\xb0\x5b\x4b\xdd\x3d\xfa\x0b\xbf\xd5\xd1\x64\xfe\x37\xa0\x4f\x6e\x1c\xaf\x89\x5d\x3b\xe9\x3e\x63\x09\xbf\x6b\x9c\x6d\x1a\x5e\x10\x38\xc9\x21\xba\x61\x90\x3c\xbd\x60\x69\xb1\x67\xd6\xc2\x16\x65\xa9\x24\x32\x9a\x6d\xdc\x7b\x2d\x9c\xcc\xff\x6a\x56\x1f\x40\x68\xa3\xca\x16\xa1\x83\xb2\x1f\xb9\xa0\x58\xb2\xf4\xa9\x2c\x63\x92\x10\x52\x83\x3a\x94\xfd\x24\x94\xec\xa4\x21\x6c\xd5\x27\xba\x0f\x6f\x8d\xa7\x3f\xdf\xdd\x49\x82\x6a\xb2\x87\x97\x06\xdd\x5b\xe3\xf9\xcd\x17\x61\x35\x90\xf0\x00\x46\xc3\x02\x36\x76\x1d\xfc\x8a\x38\xe9\xc6\x33\x4a\xa3\x26\xac\x9f\x46\x28\xd2\x51\x44\x31\xb6\xe6\x88\x33\x8c\xb0\x51\xd8\xa2\xa8\x1c\x07\x20\x6d\xf4\x00\x8b\xd2\xcf\x56\xee\x11\x05\x61\xec\x9c\x1c\x36\x6c\x17\xb7\x3a\xa7\xb8\x18\x46\x42\x06\xa3\x28\x15\x85\xac\x62\xa2\x39\x1a\x53\x2e\x2d\x53\x28\xd0\xe6\x08\x25\x21\xd4\x36\xe2\xdd\x84\x2b\xe1\x77\x0f\xba\x6c\xa9\x2b\x86\xcc\xd7\xe4\x00\x0f\x80\xd8\x30\x3f\xc0\x52\x21\x4a\x52\xd3\x07\x42\x1f\x96\xd4\x47\x28\x85\xa4\x8c\xf7\x98\xb3\x77\x85\x73\x63\x52\xb3\x4c\xbb\xdb\xd0\x0e\xd2\x01\x41\xc9\x8d\x50\x84\x77\x64\xc9\x1a\x50\x05\xf4\xa3\x24\x7b\x01\xd8\xfb\x70\x3b\x35\x2e\x80\xd9\x44\xa2\xe2\xdc\xa7\x77\x8d\xb3\x5e\x7f\x49\xb5\xbd\x13\xdd\x0b\xb8\xb8\xa4\xcc\x06\x44\x8d\x56\x33\xe8\xf1\x58\xef\xd3\x63\xc1\x46\xb0\x14\x59\xc6\xe5\xa1\x50\xa7\x5b\xa0\xd9\x46\xbd\x39\xb4\x37\x32\xc5\xe3\x34\x35\x95\xe6\xc2\x69\x8b\xb8\xbe\xb8\xa4\x06\x3f\x91\x15\x52\xcf\xd5\x16\x3c\x13\x44\x98\x0a\xb7\x53\x99\x4e\xe1\x56\x2a\xc5\x69\x9c\xc3\x8c\xd4\x93\x61\xa9\xcc\xac\x91\xf3\xbe\x3b\x08\x9a\xa5\x7c\xb2\x96\x3d\x57\x6a\xeb\x53\x83\x75\xcc\x51\xfa\x9f\x9e\x5a\x73\x23\x33\xcc\x8e\x4f\x4f\x56\x4a\x69\x9e\x39\x5e\x02\x1e\x95\x72\x5c\x7e\x51\xce\xe9\x4d\xcc\x39\x57\xa6\x30\x65\x67\xff\x4e\x91\xbe\x96\xd8\xb1\x31\x0a\xc5\xf2\x78\x48\x85\x9a\x22\xf4\x7e\x5a\xcf\x17\x16\x44\xb8\xc3\xbb\x52\xc9\x54\xfa\x1a\xbf\xdb\xdc\x8a\xeb\x19\x5e\xc4\xc0\x25\x39\x1b\x70\xe8\xfb\x6d\xae\x26\x1d\xc8\x5c\x1b\xbb\xda\x3e\x37\xe3\xc9\x06\x14\xb9\x07\x3b\xee\x06\xd7\xd5\x18\xad\x46\x8f\x6e\x40\x39\xd6\x20\x2e\xc0\x85\xf4\xd8\x0b\x5f\x2d\x7d\x62\x43\x82\xcc\xf3\x9b\x14\x39\x3c\xad\x4a\x92\xdf\x3f\x3c\x47\x5e\x9f\xaf\x0c\x40\x09\xe7\x7f\x0c\x55\xca\x03\x32\xeb\xd4\xe8\xe0\xd7\xf7\xab\xfe\x45\x33\x75\x31\xc6\xad\xb2\xd0\x76\xe3\x2f\xaa\xd4\x39\x8a\x7a\x0d\x49\x2d\x14\x66\xe8\x85\x54\x41\xe2\x46\x23\x08\x82\x06\x5f\x53\x99\x56\xd6\x72\xb5\xe7\xc9\xb3\xea\xca\xfd\xf8\xf4\x04\x1a\x6d\xc0\x60\x30\x08\x71\xd1\x79\x5b\xa5\x6c\xaf\x54\x85\xeb\x0c\x33\xde\x35\x93\x96\x4b\x6f\x47\x9b\xb7\x72\x88\x99\x57\x80\xf3\x52\xf8\x29\x24\x41\xf9\x49\x47\x14\x00\xaf\x8c\x05\xbc\x13\x45\xa9\xb0\xcf\x62\x80\x57\xc6\x44\x9b\x09\x1f\xfc\xc0\x8c\x0e\x87\xf0\xbe\x4d\x98\x38\x28\x8c\x09\xdb\x42\xbe\xc4\xdd\x05\x98\x18\x43\x92\xee\xf2\x94\xd4\x8b\x7f\xd0\xe6\x56\xaf\x22\x81\xbf\x29\x2c\x8e\xe0\xb2\x77\x7c\x23\xa4\x12\x63\x85\x97\xbd\x3e\x5c\xf6\x4e\xad\xc9\x39\x44\xe9\xfc\x32\xc6\x9c\xcb\xde\x4b\xcc\xad\xc8\x30\xbb\xec\xd5\x5b\xff\x95\xb3\x80\x37\x94\x10\xfc\x80\xb3\x67\xbc\xe1\xdc\xd0\x59\xc8\x1a\x66\xcf\x42\xd2\x50\x8f\x91\x93\x9d\xcf\x4a\x7c\x46\x11\xb3\xfb\xf2\x8d\x28\xe7\x36\xea\x58\xda\xc5\x15\xd5\xb3\x37\x87\x49\xab\xea\x9f\x7f\x71\x46\x8f\x2e\x7b\x2d\x4f\x7d\x53\x90\xc9\x94\x7e\x76\xd9\x83\x39\x0a\x46\x97\x3d\xa6\xa1\x7e\x5f\x13\x3d\xba\xec\xd1\xd7\xe8\xb5\x35\xde\x8c\xab\xc9\xe8\xb2\x37\x9e\x79\x74\xfd\xc3\xbe\xc5\xb2\x4f\x00\xf6\xac\xfd\xc2\x65\xef\x67\xb8\xd4\x35\xd1\xc6\x4f\xd1\x06\x4d\x3b\xf8\xd8\xdb\x80\x3e\x1b\x42\xea\x7d\xb5\x47\xf0\xe8\x73\x2b\xb4\x93\x75\x07\x75\xed\xd4\x02\x9d\x13\xf9\xfa\x71\x8b\xc2\xad\x0c\x0f\x61\x38\x58\xc9\xda\x61\xe2\x65\xe5\xe0\xfd\x85\xcd\x32\x0f\x5b\x16\x94\xcb\x0b\xdb\x72\xc7\x79\xf0\xf4\x82\x3d\xba\xb1\x0b\xdf\xcc\x26\x47\xb5\xa6\x60\xff\x8f\x00\xcc\x29\x19\xeb\x2d\x26\xbd\xb1\x11\x37\x46\xb8\x9d\xa2\x8e\x2d\xd1\x0c\xad\x9a\x51\xe6\xdb\xee\x9a\x4e\x85\xce\x31\x4b\x20\xa4\xdd\x82\xf1\x80\x02\xf4\x35\x39\x18\xa7\x6b\x1a\x2a\x57\x37\xa8\x98\xae\x66\x47\x02\x96\x00\x08\x71\x1b\x46\xce\x34\xc5\xd2\x93\xd7\xdd\x57\xbd\xde\x53\xa3\x4c\x8c\x2d\x84\x1f\x01\x61\xfe\xc0\xaf\x37\x8f\x68\x1c\x5b\x0a\x3e\xce\x0e\xd9\xf1\xb4\x2a\x84\x26\xeb\xc9\x88\xde\x76\x4c\x67\x32\x15\xdc\x95\xab\xf1\x56\x8c\x4d\x15\x10\xb0\xd5\x43\x14\x75\x21\x66\x24\x67\x4a\x13\xc8\x47\x23\x5b\x9f\xc9\x7c\x21\xee\x5e\xa3\xce\xfd\x74\x04\x5f\x1f\xfd\xfd\xe9\x37\x6b\x26\x06\xd0\xc4\xec\x7b\xd4\x14\x9f\x56\x34\x7d\xd7\x88\x61\x79\x61\xb7\x80\x25\x3e\x93\xba\xd3\x96\xe4\xed\x9c\xa6\x02\x6f\x2d\xe8\x56\x70\xc2\x03\x63\x41\xc9\x67\x55\x92\x5c\x28\x0a\x70\xff\x5c\xa7\xd8\x07\x39\x59\xbd\x99\x6c\xc0\x5d\xcd\xe0\xf0\xa8\x0f\xe3\x28\xe2\x65\x58\xbf\xb8\xbb\x4a\x56\x90\x2c\x1d\x7c\xdb\x5f\xa0\x87\x72\xdc\x8a\x23\x22\xa7\x97\xb7\xd2\x4f\xc1\x62\x08\x93\xb1\xf9\xbc\x22\x4c\x62\x43\xef\x7d\x8a\xa3\x60\x99\xe3\xfa\x6e\x48\x6d\xb6\x52\xfb\xa7\x7f\x5b\xaf\x5f\xa9\x65\x51\x15\x23\x78\xb2\x66\x4a\x80\xb4\x2d\xb5\x19\x26\xb7\x59\x82\x20\xe8\xca\xad\x28\x0a\x4e\xbd\x65\x86\xda\x53\xfd\x60\xbb\xa6\xed\xb9\x8e\xe2\x85\x13\x6e\x45\x75\xa4\xf8\xc8\x45\x1c\xea\x18\xfb\xa9\x35\x59\x95\xa2\xe5\xe8\x1c\x2b\x92\xb4\x0b\x50\xb3\x12\x83\x37\x84\xf3\x04\xca\x9a\x31\xf5\x4d\xe7\x3e\x34\xf7\x51\x68\xa9\x73\x17\x3f\x29\x5d\x00\x90\x10\x8d\x6f\xa7\xc8\xa1\x67\xae\x12\x64\xaa\x9c\xcc\xd0\x62\x06\x02\xf2\x4a\x58\xa1\x3d\x62\x46\xf0\x13\xaa\xc1\xd0\x4d\x6f\x21\x4f\xb4\x3d\xec\xda\x1b\x83\xab\x06\xb0\x22\x12\x63\xdf\x3b\xf4\x09\xbe\x98\xab\x1e\x3e\x39\xda\xa8\xf2\x66\xde\xfa\x5e\x9a\xf0\x1e\xad\x1e\xc1\xbf\x2e\x8e\x07\xff\x14\x83\xdf\xae\xf6\xe3\x3f\x4f\x06\xdf\xfe\xbb\x3f\xba\x7a\xdc\x79\xbc\x3a\x78\xfe\x97\x35\x3b\xad\x4e\xeb\xd7\x98\x4f\x0c\x22\x75\x12\x59\x6b\xb4\xcf\x11\xc6\x4c\xe0\xdc\x56\xd8\x87\x57\x42\x39\xec\xc3\x8f\x9a\x43\xc3\x67\x0a\x0d\x75\x55\x6c\x6e\x4b\xf6\xe8\xab\xab\x93\x8f\x66\x0a\x93\xb4\x79\x4e\x24\x77\x53\x67\x60\x3b\x21\x71\xfa\x66\x26\x5d\xa4\xe9\x9c\x95\x00\x23\x1e\xa5\xac\x49\x4c\x7f\x93\xd4\x14\xc3\xce\x59\x0a\xe5\xdd\x6f\x84\x9e\x41\x0b\x6b\x21\x59\x5d\xb4\x74\xe7\x09\x9b\x44\x6a\x8d\x73\xcd\x49\x83\x03\x25\xaf\x11\x9a\x8c\x36\x80\xe5\x18\x53\xc1\x89\xba\x1d\x4b\x6f\x85\x9d\x75\xea\x12\x48\x85\x8e\x3d\x81\x49\xa5\x60\xdf\x21\x42\xa2\x4d\x86\xcb\xe8\x7a\x10\x30\x54\x8c\xa5\x92\x7e\x16\x1a\x08\xa9\xd1\x13\x25\x63\x7d\x50\x94\xc6\x7a\xa1\x7d\xdd\x7c\xc9\xf1\x8e\x4a\x5d\xee\xfb\x84\x22\x79\x3f\xd3\xee\xf0\xf0\xe8\xeb\xb3\x6a\x9c\x99\x42\x48\xfd\xaa\xf0\xc3\x83\xe7\xfb\xbf\x56\x42\x71\xe7\x82\x6a\xea\x57\x85\x3f\xf8\x72\x61\xf1\xf0\xe9\x16\x5e\xb4\x7f\x11\x7c\xe5\x6a\xff\x62\x10\xff\x7b\x5c\xbf\x3a\x78\xbe\x7f\x99\x6c\x1c\x3f\x78\x4c\x3c\x74\x3c\xf0\xea\x62\xd0\xba\x5f\x72\xf5\xf8\xe0\x79\x67\xec\x60\xd9\x19\x3b\x55\xeb\xbd\x05\xe8\xeb\x76\x6e\xc8\x4e\x7c\x7d\xa9\xa0\xf6\xcc\xf9\xd4\x70\xb1\x24\x8d\x5e\x4c\xf1\x38\x6e\xf3\xe0\xee\xce\x36\x49\x97\xde\xbe\x9b\x32\xdf\x47\x09\x8d\xfb\xd5\x47\xe3\x4d\x04\x9a\x63\xea\xcf\xd8\x2f\x81\xa5\x0e\xdf\x7b\x9c\x3c\xb0\xc1\xf7\x1e\x27\x60\x71\x82\x16\x75\x8a\xb5\x60\xe6\xfb\x7a\xf1\xd8\xb7\x69\xfc\xfd\x0e\x67\x78\xeb\x2f\x0a\xac\x64\x81\x92\xfd\x78\x39\xa0\xb6\xc7\xc8\xc3\xda\x03\x89\x7b\x5d\x9a\xe3\xf1\xa9\xf0\xd3\xad\x28\x78\x74\x12\xc5\xc6\xdd\x7b\x3e\x4f\x29\x25\xa6\x38\x77\x17\x81\xf3\x38\x14\x59\x7c\x49\x89\x8f\xc5\x38\xd6\x0f\x19\x47\x3c\xb3\x68\xef\x2a\x50\xd2\x04\x82\x80\x58\x66\xf0\x8f\xb3\x77\x6f\x87\xdf\x9b\x98\x2b\x50\x35\xe3\x82\x6f\x71\xb7\xb9\x0f\xae\x4a\xa7\x20\x1c\x91\x46\xf5\xed\x19\xb7\x25\x0a\xa1\xe5\x04\x9d\x4f\xe2\x6e\x68\xdd\xc5\xd1\x55\x32\xdf\x0e\x91\xf1\x60\xa3\x3e\xd1\x8f\x06\xc0\xbe\x41\xcc\x34\x6b\x39\x69\x65\x92\x4a\x93\x45\xa2\x6f\x99\x58\x2f\xae\x11\x4c\x24\xb6\x42\x0e\x0a\x23\xe8\x91\x99\x74\x3e\xfd\x81\x1c\xeb\x63\x0f\xf6\x6f\xa7\x68\x11\x7a\xf4\xd8\x0b\x1f\x6c\x2e\x60\xd0\xbb\x4e\xc4\x8f\x1f\x0e\xf9\xbd\x95\x79\xce\xe9\x16\xdf\x26\xb8\x41\xed\x0f\x38\xbe\x4d\x40\x9b\xce\x64\x1d\xfb\xd4\x6d\x77\x7a\x91\x90\x8b\xa3\xab\x1e\xec\xcf\xf3\x45\x29\x28\xde\xc1\x51\xd3\x91\x2e\x4d\x76\x50\x57\xad\x33\xed\xc5\x1d\x17\x06\x53\xe3\x50\x87\xce\xbf\x37\x30\x15\x37\x08\xce\x50\xf1\x89\x4a\x0d\x42\x82\x99\xc1\x6d\x68\xd0\xd5\xa2\x0c\x87\x3a\xa5\xb0\x7e\xe1\x7a\xca\xf9\xbb\x97\xef\x46\xe1\x6b\xa4\xb6\x5c\xd7\x55\xee\x44\x6a\xa1\xe2\xe9\x43\x93\x1f\x12\x21\x55\x50\x92\x37\xb1\xb4\xad\x4f\x46\x26\x95\xaf\x2c\x26\x8b\xd7\x15\xb6\xb6\xf8\x55\x77\x45\x56\x1b\x3b\xdf\x19\x59\x74\xb4\xff\xe2\x8d\x8c\xad\x59\xd4\x6b\x4e\x3c\x96\x59\x7c\xdb\xb1\xc1\x8d\x2c\xb6\xd0\x4c\x5c\x66\x26\x75\xc4\x60\x8a\xa5\x77\x43\x73\x43\xd0\x89\xb7\xc3\x5b\x63\xaf\xa5\xce\x07\x64\x64\x83\xa0\x79\x37\xe4\x10\x33\xfc\x8a\xff\x7c\x16\x47\x1c\xa7\xb6\x67\x2b\x5c\x0c\xfb\x03\x78\xe3\xf0\x39\xfc\x64\xd6\xea\xfc\xf2\x21\x91\xe0\xd1\x59\x5d\xfc\x2d\xac\x26\x77\x09\x07\x52\xf1\xc6\x58\x07\xe1\x0a\x91\x05\x08\x14\x7a\xf6\xbb\x9b\x31\x09\x90\x6b\xfc\x74\x36\x88\x57\x3a\x07\x42\x67\x83\x26\xbf\x4e\x67\x9f\x2c\xb1\x4a\x6e\xe9\xc0\x3f\x9e\xbc\xfc\x63\x8c\xbb\x92\x0f\xf2\xd6\xd0\x45\x19\x81\xb7\x55\x9d\xdd\x39\x6f\xac\xc8\x71\xfe\x5d\x35\x6e\x8a\x8f\x96\xe1\x58\x57\xc2\x87\x8f\xfc\xaa\xbd\xc4\x29\x54\x39\x15\x47\xf5\xda\xdd\x55\xce\xdd\x55\xce\xdd\x55\xce\xdd\x55\xce\x8d\xc2\xde\x5d\xe5\xdc\x5d\xe5\xdc\x5d\xe5\xdc\x5d\xe5\xdc\x5d\xe5\xfc\x3c\x56\x77\x57\x39\x77\x57\x39\x77\x57\x39\x9b\xdf\xee\x2a\xe7\x96\xcc\xed\xae\x72\xfe\xd9\xaf\x72\xfe\x7f\x5f\xce\xdc\x1d\x8e\xfd\x6f\x1c\x8e\xed\x8e\xbb\x76\xc7\x5d\xbb\xe3\xae\xdd\x71\xd7\x27\x58\xfc\xee\xb8\x6b\x77\xdc\xb5\x3b\xee\xda\x1d\x77\xfd\x49\x8f\xbb\x26\x42\xb9\xad\xcf\xbb\xfe\x13\x00\x00\xff\xff\xf2\x1a\x66\xa5\x7c\x46\x00\x00") +var _operatorsCoreosCom_operatorgroupsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5a\xe9\x6f\x1b\x37\x94\xff\xee\xbf\xe2\x41\x5d\x20\x76\x56\x1a\xc5\xee\xa2\xdb\x0a\x08\x02\x23\x69\x0a\x6f\x73\x18\xb1\xdb\x0f\x6b\x7b\xb7\xd4\xcc\xd3\x88\x35\x87\x9c\x92\x1c\xdb\x6a\x90\xff\x7d\xf1\x1e\x39\x87\x6e\x39\x49\xbb\xdd\x85\xfc\x25\xd1\xf0\x7a\xe7\xef\x1d\xa4\x28\xe5\xaf\x68\x9d\x34\x7a\x04\xa2\x94\xf8\xe0\x51\xd3\x2f\x97\xdc\x7e\xef\x12\x69\x86\x77\xc7\x07\xb7\x52\x67\x23\x78\x59\x39\x6f\x8a\x0f\xe8\x4c\x65\x53\x7c\x85\x13\xa9\xa5\x97\x46\x1f\x14\xe8\x45\x26\xbc\x18\x1d\x00\x08\xad\x8d\x17\xf4\xd9\xd1\x4f\x80\xd4\x68\x6f\x8d\x52\x68\x07\x39\xea\xe4\xb6\x1a\xe3\xb8\x92\x2a\x43\xcb\x9b\xd7\x47\xdf\x3d\x4b\xbe\x4f\x9e\x1d\x00\xa4\x16\x79\xf9\xa5\x2c\xd0\x79\x51\x94\x23\xd0\x95\x52\x07\x00\x5a\x14\x38\x02\x53\xa2\x15\xde\xd8\xdc\x9a\xaa\x74\x49\xfd\xd3\x25\xa9\xb1\x68\xe8\x9f\xe2\xc0\x95\x98\xd2\xe9\x3c\xa7\x5d\x32\x37\x27\xec\x57\x13\x29\x3c\xe6\xc6\xca\xfa\x37\xc0\x00\x8c\x2a\xf8\xff\x81\xf9\xf7\x71\x8f\x9f\x68\x4b\xfe\xae\xa4\xf3\x3f\x2f\x8f\xbd\x91\xce\xf3\x78\xa9\x2a\x2b\xd4\x22\xc1\x3c\xe4\xa6\xc6\xfa\x77\xed\xf1\x7c\x5c\x1e\x86\xa4\xce\x2b\x25\xec\xc2\xba\x03\x00\x97\x9a\x12\x47\xc0\xcb\x4a\x91\x62\x76\x00\x10\xc5\x17\xb7\x19\x44\x11\xdd\x1d\xc7\x5d\x5d\x3a\xc5\x42\xd4\x67\x00\x6d\xa9\x4f\xcf\xcf\x7e\xfd\xf6\x62\x61\x00\x20\x43\x97\x5a\x59\x7a\x56\xc6\x1c\x43\x20\x1d\xf8\x29\x42\xa5\xa5\x07\x33\x81\xa2\x52\x5e\x7a\xd4\x42\xa7\x33\x98\x18\x0b\xef\xdf\xbc\x85\x42\x68\x91\x63\xd6\x11\x35\x9c\x79\xd2\xbd\xf3\x56\x48\x1d\x76\x90\xda\x79\xa1\x14\xab\x97\x76\x6a\x26\x83\xd4\x20\xbd\x0b\x1a\x21\xde\xc0\x1b\x10\x40\x6a\x94\x13\x89\x19\x38\xe4\xa3\xbd\xb0\x39\xfa\x76\x9a\x4b\x3a\x1c\xf8\x19\x89\xc7\x8c\x7f\xc7\xd4\x77\x3e\x5b\xfc\xa3\x92\x16\xb3\x2e\xb3\x24\xaa\xda\x68\x3b\x9f\x4b\x4b\x14\xf9\x8e\x15\x84\xbf\x8e\x8b\xcc\x7d\x5f\x90\xda\x13\x12\x6d\x98\x07\x19\x79\x07\x06\xb6\xa3\x92\x88\x0d\x16\x3b\x73\x32\x95\x0e\x2c\x96\x16\x1d\x6a\xdf\x48\x44\xe8\xc8\x40\x02\x17\x68\x69\x21\xd9\x4a\xa5\x32\x12\xe5\x1d\x5a\x0f\x16\x53\x93\x6b\xf9\x67\xb3\x9b\x23\x59\xd1\x31\x4a\x78\x74\x1e\xa4\xf6\x68\xb5\x50\x70\x27\x54\x85\x7d\x10\x3a\x83\x42\xcc\xc0\x22\xed\x0b\x95\xee\xec\xc0\x53\x5c\x02\x6f\x8d\x25\xed\x4c\xcc\x08\xa6\xde\x97\x6e\x34\x1c\xe6\xd2\xd7\x00\x90\x9a\xa2\x20\xe5\xcf\x86\xec\xcb\x72\x5c\x91\xce\x86\x19\xde\xa1\x1a\x3a\x99\x0f\x84\x4d\xa7\xd2\x63\xea\x2b\x8b\x43\x51\xca\x01\x13\xab\x19\x04\x92\x22\xfb\xc6\x46\xc8\x70\x4f\x16\xc4\x17\x54\xe6\xbc\x95\x3a\x9f\x1b\x62\x9f\xdb\x28\x6b\xf2\x3c\xb2\x4c\x11\x97\x07\x5e\x5a\x91\xd2\x27\x92\xca\x87\x1f\x2f\x2e\xa1\x26\x20\x88\x3d\x48\xb8\x9d\xea\x5a\x61\x93\xa0\xa4\x9e\xa0\x0d\x33\x27\xd6\x14\xbc\x0b\xea\xac\x34\x52\x7b\xfe\x91\x2a\x89\xda\x83\xab\xc6\x05\x19\x2d\x19\x18\x3a\x4f\x7a\x48\xe0\x25\xe3\x1f\x8c\x11\xaa\x32\x13\x1e\xb3\x04\xce\x34\xbc\x14\x05\xaa\x97\xc2\xe1\x5f\x2e\x6a\x92\xa8\x1b\x90\xf8\x76\x17\x76\x17\xbe\x97\x17\x2c\x39\x14\x40\x0d\xaf\x6b\xb5\x33\x87\x1f\x17\x25\xa6\x35\x86\xd0\x4a\xc6\x0c\xa1\x17\x40\xa6\x56\x51\xb2\x2b\x11\xeb\xdd\x95\x49\x44\x85\xa9\x37\x76\x79\x64\x81\xd4\x8b\x38\x31\xae\x08\x64\xce\x91\xf6\xc4\x6d\xc6\x9d\x1d\x28\xdd\x46\x2d\x6b\x41\xf8\x74\xfa\xe3\x03\xd9\x64\x07\xd2\xb7\x50\xbf\xb8\x28\x78\x04\x45\x26\x42\x13\x25\xc6\xa8\x1a\x51\xd4\x48\x58\x04\x93\xbf\x9c\xe2\xdc\x17\x10\x16\xe1\xf4\xdd\x2b\xcc\x56\x31\xd7\x32\x28\xac\x15\xb3\x35\x33\xa4\xc7\x62\x2d\xe1\x0b\xa4\x9f\x6e\x20\x2f\x3a\x76\x3d\xe2\xa7\x82\x63\x89\xe7\x48\x12\x40\xab\x0f\x02\x6e\x71\x16\xf0\x8d\x60\x33\xaa\x2c\x4c\xb6\xc8\x68\xc8\xca\xbc\xc5\x19\x4f\x8a\x60\xb7\x96\xba\x2d\xfa\x0b\x7f\xab\xa3\xc9\xfc\xdf\x80\x8e\xdc\x38\x5e\x13\xbb\x76\xd2\x36\x63\x09\x7f\xb7\x38\xdb\x34\xbc\x20\x70\x92\x43\x74\xc3\x20\x79\xfa\xc0\xd2\x62\xcf\xac\x85\x2d\xca\x52\x49\x64\x34\xdb\xb8\xf7\x5a\x38\x99\xff\xab\x59\x7d\x04\xa1\x8d\x2a\x5b\x84\x0e\xca\x7e\xe2\x82\x62\xc9\xd2\xa7\xb2\x8c\x49\x42\x48\x0d\xea\x50\xf6\xab\x50\xb2\x93\x86\xb0\x55\x9f\xe9\x3e\xbc\x33\x9e\xfe\xf9\xf1\x41\x12\x54\x93\x3d\xbc\x32\xe8\xde\x19\xcf\x5f\xbe\x0a\xab\x81\x84\x47\x30\x1a\x16\xb0\xb1\xeb\xe0\x57\xc4\x49\x37\x9e\x51\x1a\x35\x61\xfd\x34\x42\x91\x8e\x22\x8a\xb1\x35\x47\x9c\x61\x84\x8d\xc2\x16\x45\xe5\x38\x00\x69\xa3\x07\x58\x94\x7e\xb6\x72\x8f\x28\x08\x63\xe7\xe4\xb0\x61\xbb\xb8\xd5\x25\xc5\xc5\x30\x12\x32\x18\x45\xa9\x28\x64\x15\x13\xcd\xd1\x98\x72\x69\x99\x42\x81\x36\x47\x28\x09\xa1\x76\x11\xef\x26\x5c\x09\x7f\x5b\xd0\x65\x47\x5d\x31\x64\xbe\x21\x07\x78\x04\xc4\x86\xf9\x01\x96\x0a\x51\x92\x9a\x3e\x12\xfa\xb0\xa4\x3e\x41\x29\x24\x65\xbc\xa7\x9c\xbd\x2b\x9c\x1b\x93\x9a\x65\xda\xdd\x86\x76\x90\x0e\x08\x4a\xee\x84\x22\xbc\x23\x4b\xd6\x80\x2a\xa0\x1f\x25\xd9\x0b\xc0\xde\x87\xfb\xa9\x71\x01\xcc\x26\x12\x15\xe7\x3e\xbd\x5b\x9c\xf5\xfa\x4b\xaa\xed\x9d\xe9\x5e\xc0\xc5\x25\x65\x36\x20\x6a\xb4\x9a\x41\x8f\xc7\x7a\x9f\x1f\x0b\x36\x82\xa5\xc8\x32\x2e\x0f\x85\x3a\xdf\x01\xcd\x36\xea\xcd\xa1\xbd\x93\x29\x9e\xa6\xa9\xa9\x34\x17\x4e\x3b\xc4\xf5\xc5\x25\x35\xf8\x89\xac\x90\x7a\xae\xb6\xe0\x99\x20\xc2\x54\xb8\x9f\xca\x74\x0a\xf7\x52\x29\x4e\xe3\x1c\x66\xa4\x9e\x0c\x4b\x65\x66\x8d\x9c\x0f\xdd\x51\xd0\x2c\xe5\x93\xb5\xec\xb9\x52\x5b\x9f\x1a\xac\x63\x8e\xd2\xff\xf4\xdc\x9a\x3b\x99\x61\x76\x7a\x7e\xb6\x52\x4a\xf3\xcc\xf1\x12\xf0\xa8\x94\xe3\xf2\x8b\x72\x4e\x6f\x62\xce\xb9\x32\x85\x29\x3b\xfb\x77\x8a\xf4\xb5\xc4\x8e\x8d\x51\x28\x96\xc7\x43\x2a\xd4\x14\xa1\xdb\x69\xbd\x5c\x58\x10\xe1\x0e\x1f\x4a\x25\x53\xe9\x6b\xfc\x6e\x73\x2b\xae\x67\x78\x11\x03\x97\xe4\x6c\xc0\xa1\xef\xb7\xb9\x9a\x74\x20\x73\x6d\xec\x6a\xfb\xdc\x8c\x27\x1b\x50\x64\x0b\x76\x3c\x0c\x6e\xab\x31\x5a\x8d\x1e\xdd\x80\x72\xac\x41\x5c\x80\x0b\xe9\xb1\x17\xbe\x5a\x3a\x62\x43\x82\xcc\xf3\x9b\x14\x39\xfc\x5a\x95\x24\x7f\x78\x7c\x8e\xbc\x3e\x5f\x19\x80\x12\xce\xff\x12\xaa\x94\x47\x64\xd6\xa9\xd1\xc1\xaf\xb7\xab\xfe\x65\x33\x75\x31\xc6\xad\xb2\xd0\x76\xe3\xaf\xaa\xd4\x39\x8a\x7a\x0d\x49\x2d\x14\x66\xe8\x85\x54\x41\xe2\x46\x23\x08\x82\x06\x5f\x53\x99\x56\xd6\x72\xb5\xe7\xc9\xb3\xea\xca\xfd\xf4\xfc\x0c\x1a\x6d\xc0\x60\x30\x08\x71\xd1\x79\x5b\xa5\x6c\xaf\x54\x85\xeb\x0c\x33\xde\x35\x93\x96\x4b\x6f\x47\x9b\xb7\x72\x88\x99\x57\x80\xf3\x52\xf8\x29\x24\x41\xf9\x49\x47\x14\x00\xaf\x8d\x05\x7c\x10\x45\xa9\xb0\xcf\x62\x80\xd7\xc6\x44\x9b\x09\x07\x7e\x84\xe1\x10\x3e\xb4\xc9\x12\x07\x84\x31\xe1\x5a\xc8\x95\xb8\xb3\x00\x13\x63\x48\xca\x5d\x7e\x12\x5a\xf8\xb3\x36\xf7\x7a\xd5\xd1\x7c\x96\xb0\x38\x82\xeb\xde\xe9\x9d\x90\x4a\x8c\x15\x5e\xf7\xfa\x70\xdd\x3b\xb7\x26\xe7\xd0\xa4\xf3\xeb\x18\x6b\xae\x7b\xaf\x30\xb7\x22\xc3\xec\xba\x47\xdb\xfe\x2b\x47\xfe\xb7\x94\x04\xfc\x8c\xb3\xe7\xbc\x59\xf3\xf9\x22\x64\x09\xb3\xe7\x21\x49\xa0\xef\xe4\x50\x97\xb3\x12\x9f\x53\x74\xac\x3f\xbc\x15\x65\xb3\xb8\x63\x4d\x57\x37\x54\xb3\xde\x1d\x27\xad\x3a\x7f\xfb\xdd\x19\x3d\xba\xee\xb5\xf4\xf7\x4d\x41\x66\x51\xfa\xd9\x75\x0f\xe6\x4e\x1d\x5d\xf7\xf8\xdc\xfa\x7b\x4d\xe4\xe8\xba\x47\x27\xd1\x67\x6b\xbc\x19\x57\x93\xd1\x75\x6f\x3c\xf3\xe8\xfa\xc7\x7d\x8b\x65\x9f\x40\xea\x79\x7b\xc2\x75\xef\x37\xb8\xd6\x44\xac\xf1\x53\xb4\x41\x93\x0e\x3e\xf5\x36\xa0\xcb\x86\x90\xb9\xad\xb6\x08\x1e\x7b\x69\x85\x76\xb2\xee\x90\xae\x9d\x5a\xa0\x73\x22\x5f\x3f\x6e\x51\xb8\x95\xf0\x1f\x86\x83\x35\xac\x1d\x26\x5e\x56\x0e\x6e\x2f\x5c\x96\x79\xd8\xb1\x60\x5c\x5e\xd8\x96\x33\xce\x83\xa7\x0f\xec\xb1\x8d\x4d\xf8\x66\x36\x39\xa2\x35\x05\xfb\x77\x04\x58\x4e\xb9\x58\x6f\x31\xa9\x8d\x8d\xb6\x31\xc2\xfd\x14\x75\x6c\x79\x66\x68\xd5\x8c\x32\xdb\x76\xd7\x74\x2a\x74\x8e\x59\x02\x21\xad\x16\xec\xef\x14\x80\x6f\xc9\x91\x38\x1d\xd3\x50\xb9\xba\x01\xc5\x74\x35\x3b\x12\x70\x04\x87\x8f\xdb\x30\x32\xa6\x29\x96\x9e\xbc\x6b\x5b\x75\xba\xa5\x06\x99\x18\x5b\x08\x3f\x02\xc2\xf4\x81\x5f\x6f\x1e\xd1\x38\x76\x14\x7c\x9c\x1d\xb2\xdf\x69\x55\x08\x4d\xd6\x93\x11\xbd\xed\x98\xce\x64\x2a\xb8\xeb\x56\xe3\xa9\x18\x9b\x2a\x20\x5c\xab\x87\x28\xea\x42\xcc\x48\xce\x94\x06\x90\x7f\x46\xb6\xbe\x90\xf9\x42\x3c\xbc\x41\x9d\xfb\xe9\x08\xbe\x3d\xf9\xf7\xef\xbe\x5f\x33\x31\x00\x23\x66\x3f\xa1\xa6\xf8\xb3\xa2\xa9\xbb\x46\x0c\xcb\x0b\xbb\x05\x2a\xf1\x99\xd4\x9d\xb4\x24\x6f\xe7\x34\x15\x76\x6b\x41\xf7\x82\x13\x1a\x18\x0b\x4a\x2e\xab\x92\xe4\x42\x28\xcf\xfd\x71\x9d\x62\x1f\xe4\x64\xf5\x66\xb2\x01\x70\x35\x83\xe3\x93\x3e\x8c\xa3\x88\x97\xe1\xfb\xea\xe1\x26\x59\x41\xb2\x74\xf0\x43\x7f\x81\x1e\xca\x61\x2b\x8e\x78\x9c\x3e\xde\x4b\x3f\x05\x8b\x21\x0c\xc6\xe6\xf2\x8a\x30\x88\x0d\xbd\xdb\x14\x47\xc1\x30\xc7\xf5\xdd\x8e\xda\x6c\xa5\xf6\xdf\xfd\xdb\x7a\xfd\x4a\x2d\x8b\xaa\x18\xc1\xb3\x35\x53\x02\xa4\xed\xa8\xcd\x30\xb9\xcd\x02\x04\x41\x57\x6e\x45\x51\x70\x6a\x2d\x33\xd4\x9e\xea\x03\xdb\x35\x6d\xcf\x75\x12\x2f\x9c\x70\xab\xa9\x23\xc5\x27\x2e\xe2\x50\xc7\xd8\xcf\xad\xc9\xaa\x14\x2d\x47\xe0\x58\x71\xa4\x5d\x80\x9a\x95\x18\xbc\x21\xdc\x17\x50\x56\x8c\xa9\x6f\x3a\xf3\xa1\x79\x8f\x42\x4b\x9d\xbb\x78\xa4\x74\x01\x40\x42\xd4\xbd\x9f\x22\x87\x9e\xb9\x4a\x8f\xa9\x72\x32\x43\x8b\x19\x08\xc8\x2b\x61\x85\xf6\x88\x19\xc1\x4f\xa8\xf6\x42\xb7\xbc\x85\x3c\xd1\xf6\xa8\x6b\x6f\x0c\xae\x1a\xc0\x8a\x48\x8c\x7d\xed\xd0\x07\xf8\x6a\xae\x7a\xfc\xec\x64\xa3\xca\x9b\x79\xeb\x7b\x65\xc2\x7b\xb4\x7a\x04\xff\x75\x75\x3a\xf8\x4f\x31\xf8\xf3\xe6\x30\xfe\xe7\xd9\xe0\x87\xff\xee\x8f\x6e\x9e\x76\x7e\xde\x1c\xbd\xf8\x97\x35\x3b\xad\x4e\xdb\xd7\x98\x4f\x0c\x22\x75\x92\x58\x6b\xb4\xcf\x11\xc6\x4c\xe0\xd2\x56\xd8\x87\xd7\x42\x39\xec\xc3\x2f\x9a\x43\xc3\x17\x0a\x0d\x75\x55\x6c\x6e\x3b\xf6\xe8\xd4\xd5\xc9\x47\x33\x85\x49\xda\x3c\x27\x92\xbb\xa9\xf2\xdf\x4d\x48\x9c\xb6\x99\x49\x17\x69\x3a\x77\x21\xc0\x88\x47\x69\x69\x12\xd3\xdb\x24\x35\xc5\xb0\x73\x57\x42\x79\xf5\x5b\xa1\x67\xd0\xc2\x5a\x48\x4a\x17\x2d\xdd\x79\xc2\x26\x91\x5a\xe3\x5c\x73\x93\xe0\x40\xc9\x5b\x84\x26\x73\x0d\x60\x39\xc6\x54\x70\x22\x6e\xc7\xd2\x5b\x61\x67\x9d\xba\x03\x52\xa1\x63\xcd\x3f\xa9\x14\x1c\x3a\x44\x48\xb4\xc9\x70\x19\x5d\x8f\x02\x86\x8a\xb1\x54\xd2\xcf\x42\x83\x20\x35\x7a\xa2\x64\xcc\xff\x8b\xd2\x58\x2f\xb4\xaf\x9b\x2b\x39\x3e\x50\x29\xcb\x7d\x9d\x50\x04\x1f\x66\xda\x1d\x1f\x9f\x7c\x7b\x51\x8d\x33\x53\x08\xa9\x5f\x17\x7e\x78\xf4\xe2\xf0\x8f\x4a\x28\xee\x4c\x50\xcd\xfc\xba\xf0\x47\x5f\x2f\x2c\x1e\x7f\xb7\x83\x17\x1d\x5e\x05\x5f\xb9\x39\xbc\x1a\xc4\xff\x3d\xad\x3f\x1d\xbd\x38\xbc\x4e\x36\x8e\x1f\x3d\x25\x1e\x3a\x1e\x78\x73\x35\x68\xdd\x2f\xb9\x79\x7a\xf4\xa2\x33\x76\xb4\xec\x8c\x9d\xaa\x74\x6b\x81\xf9\xa6\x9d\x1b\xb2\x13\x5f\x3f\x1a\xa8\x3d\x73\x3e\x35\x5c\x2c\x39\xa3\x17\x53\x3c\x8e\xdb\x3c\xba\x7b\xb3\x4b\xd2\xa5\x77\xef\x96\xcc\xf7\x49\x42\x63\x7e\xf5\xd5\x77\x13\x81\xe6\x98\xfa\x27\xf6\x43\x60\xa9\x83\xf7\x01\x27\x8f\x6c\xe0\x7d\xc0\x09\x58\x9c\xa0\x45\x9d\x62\x2d\x98\xf9\xbe\x5d\xbc\xd6\x6d\x1a\x7b\x7f\xc1\x1d\xdd\xfa\x87\x00\x2b\x59\xa0\x64\x3f\x5e\xfe\xd7\xf6\x18\x79\x58\x7b\xe1\xb0\xd5\xa5\x39\x1e\x9f\x0b\x3f\xdd\x89\x82\x27\x67\x51\x6c\xdc\x9d\xe7\xfb\x92\x52\x62\x8a\x73\x6f\x0d\x38\x8f\x43\x91\xc5\x8f\x94\xf8\x58\x8c\x63\xfd\x90\x71\xc4\x3b\x89\xf6\x2d\x02\x25\x4d\x20\x08\x88\x65\x06\xff\x71\xf1\xfe\xdd\xf0\x27\x13\x73\x05\xaa\x66\x5c\xf0\x2d\xee\x26\xf7\xc1\x55\xe9\x14\x84\x23\xd2\xa8\xbe\xbd\xe0\xd6\x43\x21\xb4\x9c\xa0\xf3\x49\xdc\x0d\xad\xbb\x3a\xb9\x49\xe6\xdb\x1d\x32\x5e\x5c\xd4\x37\xf6\xd1\x00\xd8\x37\x88\x99\x66\x2d\x27\xad\x4c\x52\x69\xb2\x48\xf4\x3d\x13\xeb\xc5\x2d\x82\x89\xc4\x56\xc8\x41\x61\x04\x3d\x32\x93\xce\xd1\x1f\xc9\xb1\x3e\xf5\xe0\xf0\x7e\x8a\x16\xa1\x47\x3f\x7b\xe1\xc0\xe6\x81\x05\x7d\xeb\x44\xfc\x78\x70\xc8\xef\xad\xcc\x73\x4e\xb7\xf8\xb5\xc0\x1d\x6a\x7f\xc4\xf1\x6d\x02\xda\x74\x26\xeb\xd8\x87\x6e\xbb\xcf\x8b\x84\x5c\x9d\xdc\xf4\xe0\x70\x9e\x2f\x4a\x41\xf1\x01\x4e\x9a\x8e\x73\x69\xb2\xa3\xba\x6a\x9d\x69\x2f\x1e\xb8\x30\x98\x1a\x87\x3a\x74\xf6\xbd\x81\xa9\xb8\x43\x70\x86\x8a\x4f\x54\x6a\x10\x12\xcc\x0c\xee\x43\x03\xae\x16\x65\xb8\xb4\x29\x85\xf5\x0b\xcf\x4f\x2e\xdf\xbf\x7a\x3f\x0a\xa7\x91\xda\x72\x5d\x57\xb9\x13\xa9\x85\x8a\xb7\x0b\x4d\x7e\x48\x84\x54\x41\x49\xde\xc4\xd2\xb6\xbe\xf9\x98\x54\xbe\xb2\x98\x2c\x3e\x47\xd8\xd9\xe2\x57\xbd\x05\x59\x6d\xec\xfc\x26\x64\xd1\xd1\xfe\x17\x5f\x5c\xec\xcc\xa2\x5e\x73\xa3\xb1\xcc\xe2\xbb\x8e\x0d\x6e\x64\xb1\x85\x66\xe2\x32\x33\xa9\x23\x06\x53\x2c\xbd\x1b\x9a\x3b\x82\x4e\xbc\x1f\xde\x1b\x7b\x2b\x75\x3e\x20\x23\x1b\x04\xcd\xbb\x21\x87\x98\xe1\x37\xfc\xcf\x17\x71\xc4\x71\x6a\x77\xb6\xc2\xc3\xaf\xbf\x81\x37\x0e\x9f\xc3\xcf\x66\xad\xce\x2f\x1f\x13\x09\x9e\x5c\xd4\xc5\xdf\xc2\x6a\x72\x97\x70\xe1\x14\x5f\x84\x75\x10\xae\x10\x59\x80\x40\xa1\x67\x7f\xb9\x19\x93\x00\xb9\xc6\x4f\x67\x83\xf8\x64\x73\x20\x74\x36\x68\xf2\xeb\x74\xf6\xd9\x12\xab\xe4\x8e\x0e\xfc\xcb\xd9\xab\xbf\xc7\xb8\x2b\xf9\x28\x6f\x0d\x5d\x94\x11\x78\x5b\xd5\xd9\x9d\xf3\xc6\x8a\x1c\xe7\xbf\x55\xe3\xa6\xf8\x68\x19\x8e\x75\x25\x7c\xfc\xc4\x9f\xda\x47\x9a\x42\x95\x53\x71\x52\xaf\xdd\x3f\xd5\xdc\x3f\xd5\xdc\x3f\xd5\xdc\x3f\xd5\xdc\x28\xec\xfd\x53\xcd\xfd\x53\xcd\xfd\x53\xcd\xfd\x53\xcd\xfd\x53\xcd\x2f\x63\x75\xff\x54\x73\xff\x54\x73\xff\x54\xb3\xf9\xdb\x3f\xd5\xdc\x91\xb9\xfd\x53\xcd\x7f\xfa\x53\xcd\xff\xdf\x8f\x2f\xf7\x97\x63\xff\x37\x2e\xc7\xf6\xd7\x5d\xfb\xeb\xae\xfd\x75\xd7\xfe\xba\xeb\x33\x2c\x7e\x7f\xdd\xb5\xbf\xee\xda\x5f\x77\xed\xaf\xbb\xfe\xa1\xd7\x5d\x13\xa1\xdc\xce\xf7\x5d\xff\x13\x00\x00\xff\xff\xc7\xa0\x23\x13\x5c\x46\x00\x00") func operatorsCoreosCom_operatorgroupsYamlBytes() ([]byte, error) { return bindataRead( @@ -205,7 +205,7 @@ func operatorsCoreosCom_operatorgroupsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_operatorsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x59\x5f\x8f\xdb\xb8\x11\x7f\xdf\x4f\x31\xf0\x3d\xec\x1d\xe0\x3f\xbd\x14\x28\x0a\xbf\x2d\x76\x73\xc5\xb6\xd7\x4d\x90\xdd\xe4\xe5\x70\x0f\x63\x69\x6c\xb1\xa6\x48\x1d\x87\xb2\xd7\x0d\xf2\xdd\x8b\x21\x29\x5b\xb2\xbd\xb6\x9c\x6e\xd2\xf2\xc5\x16\x45\x0e\xe7\xef\x6f\x66\x28\xac\xd4\x27\x72\xac\xac\x99\x02\x56\x8a\x9e\x3d\x19\x79\xe2\xf1\xf2\xaf\x3c\x56\x76\xb2\xfa\xf9\x6a\xa9\x4c\x3e\x85\xdb\x9a\xbd\x2d\x3f\x10\xdb\xda\x65\x74\x47\x73\x65\x94\x57\xd6\x5c\x95\xe4\x31\x47\x8f\xd3\x2b\x00\x34\xc6\x7a\x94\x69\x96\x47\x80\xcc\x1a\xef\xac\xd6\xe4\x46\x0b\x32\xe3\x65\x3d\xa3\x59\xad\x74\x4e\x2e\x10\x6f\x8e\x5e\xfd\x69\xfc\x97\xf1\x9b\x2b\x80\xcc\x51\xd8\xfe\xa4\x4a\x62\x8f\x65\x35\x05\x53\x6b\x7d\x05\x60\xb0\xa4\x29\xd8\x8a\x1c\x7a\xeb\x78\xbc\xfb\x97\x59\x47\x56\x7e\xca\x2b\xae\x28\x93\x83\x17\xce\xd6\x55\x7b\x75\x6b\x4d\x24\xd5\xf0\x87\x9e\x16\xd6\xa9\xe6\x19\x60\x04\x56\x97\xe1\x7f\x94\xfb\x5d\xa2\x11\xa6\xb4\x62\xff\x8f\xce\xf4\xaf\x8a\x7d\x78\x55\xe9\xda\xa1\x6e\x9d\x19\x66\x59\x99\x45\xad\xd1\xed\xe6\xaf\x00\x38\xb3\x15\x4d\xe1\x56\xd7\xec\x49\x26\x92\x1e\x12\x0f\xa3\x24\xeb\xea\xe7\xc4\x12\x67\x05\x95\xd8\x30\x08\x42\xca\xdc\xbc\xbf\xff\xf4\xe7\xc7\xbd\x17\x00\x39\x71\xe6\x54\xe5\x83\x56\x1b\x1e\xc1\x51\xe5\x88\xc9\x78\x06\x84\x2c\x1e\xbb\x65\x68\xdc\xda\xee\x37\xc2\x98\x9d\xfd\x8b\x32\xdf\x9a\xae\x9c\x2c\xf6\x2d\x2d\xc5\xd1\xf2\x9e\xce\xfc\x1e\x1f\xd7\xc2\x6c\x5c\x07\xb9\x38\x0e\x31\xf8\x82\x1a\xb1\x29\x4f\x12\x82\x9d\x83\x2f\x14\xef\xf8\x0d\xbe\x20\xd3\x68\x12\x57\x63\x78\x24\x27\x1b\x81\x0b\x5b\xeb\x5c\x3c\x6c\x45\xce\x83\xa3\xcc\x2e\x8c\xfa\xf7\x96\x1a\x83\xb7\xe1\x18\x8d\x9e\xd8\x83\x32\x9e\x9c\x41\x0d\x2b\xd4\x35\x0d\x01\x4d\x0e\x25\x6e\xc0\x91\xd0\x85\xda\xb4\x28\x84\x25\x3c\x86\x7f\x5a\x47\xa0\xcc\xdc\x4e\xa1\xf0\xbe\xe2\xe9\x64\xb2\x50\xbe\x89\x8d\xcc\x96\x65\x6d\x94\xdf\x4c\x82\x9b\xab\x59\x2d\x76\x9f\xe4\xb4\x22\x3d\x61\xb5\x18\xa1\xcb\x0a\xe5\x29\xf3\xb5\xa3\x09\x56\x6a\x14\x98\x35\x21\x3e\xc6\x65\xfe\x83\x4b\xd1\xc4\xd7\x7b\xea\x8b\x76\x60\xef\x94\x59\x74\x5e\x05\x9f\x3c\xa9\x6b\x71\x4f\x50\x62\xe8\xb8\x3d\xca\xb2\x53\xa9\x4c\x89\x56\x3e\xbc\x7d\x7c\x82\x86\x81\xa8\xf6\xa8\xe1\x96\xb7\xec\x94\x2d\x8a\x52\x66\x4e\x2e\xae\x9c\x3b\x5b\x06\x2a\x64\xf2\xca\x2a\xe3\xc3\x43\xa6\x15\x19\x0f\x5c\xcf\x4a\xe5\xc5\x8a\x7f\xd4\xc4\x5e\xec\x30\x86\xdb\x00\x0d\x30\x23\xa8\xab\x1c\x3d\xe5\x63\xb8\x37\x70\x8b\x25\xe9\x5b\x64\xfa\xe6\xaa\x16\x8d\xf2\x48\xd4\xd7\x5f\xd9\x6d\x64\x3b\xdc\x70\x10\x25\x00\x0d\xfc\xbc\x68\x9d\x26\x22\x1f\x2b\xca\x3a\xa1\x90\x13\x2b\x27\xae\xeb\xd1\x93\x38\x7c\x07\x76\xfa\x1c\xed\xd1\xd7\xdc\xef\xf0\xb0\xb4\x73\xbc\x9d\xb1\x18\xba\x75\x3e\x9a\x1d\x7c\x48\xa4\x88\x41\x33\x5b\x56\xd6\x88\x63\xf4\xe5\xea\x65\xe8\x80\x90\x1c\x1a\x7a\x87\xef\xf6\x78\xbf\xdd\x2e\x4d\xf3\x33\xe2\xad\xf7\x8a\x0c\xe8\x23\x39\xa6\x28\xd0\x11\x70\xeb\xc1\xad\x0c\x71\x5b\xb1\xc5\x31\x9e\x04\x9c\x35\xce\x48\x3f\x92\xa6\xec\xd0\x3c\xe7\x24\x96\xd1\xd9\x7f\x7c\xc9\x9e\xf0\xbf\xb6\x77\xc4\xd8\x0e\x44\xe0\x8f\x9a\xdc\x06\xec\x8a\x9c\x84\x3b\x79\x31\xdc\x4e\x29\x35\x53\x2e\x18\xc8\x61\x67\x47\x2d\xd7\x27\x8c\xd9\x53\x4d\x7d\x44\x95\x51\xa2\xcf\x8a\xb7\xcf\x02\x29\xad\x1c\xd7\x43\xea\xfd\x8d\x49\x70\xc5\x41\xcc\xa8\x00\x6e\x94\x92\x8c\x56\x46\xd4\x7a\x2a\xa8\x33\x03\xe8\x08\x6e\x1e\xee\x28\x3f\xe6\x0f\x5d\x81\xd1\x39\xdc\x9c\x58\xa5\x3c\x95\x27\x85\xd8\x13\xe3\xe6\x04\xab\x09\xa7\x9b\x37\xc9\x8b\x8d\x47\x65\x38\xe5\xa0\x21\x20\x2c\x69\x13\xd3\x95\x64\xc1\x26\x28\xc3\x62\x47\x21\xb9\x05\xdb\x2e\x69\x13\x16\xa5\xdc\x75\x92\xc3\x1e\xb6\x8d\xe3\x74\x30\xec\xc6\x48\x8e\x3f\xbb\xc6\x1e\x07\xb5\xee\xe8\xe3\x54\x71\x2c\x69\x73\x6e\xc9\x9e\x31\x44\x47\x8a\x53\x55\x20\x56\x91\x89\xa0\x49\x99\xda\x1a\x02\xab\x4a\x2b\x0a\x89\xeb\x2c\xfd\x17\xb3\xc7\xe1\x68\xc4\xbf\x90\x69\x7b\xb4\x8c\x5b\xd2\xe6\x9a\xa3\x03\x48\x74\x14\xaa\x92\x58\xdf\xc2\x40\x53\xc1\x7c\x42\xad\xf2\x5d\x51\x1a\x22\xe1\xde\x0c\xe1\xc1\x7a\xf9\x79\xfb\xac\x24\x43\x8b\xdf\xdc\x59\xe2\x07\xeb\xc3\xcc\xab\x8a\x1d\x59\xb9\x50\xe8\xb8\x29\x04\x88\x89\x31\x29\x52\xb5\x4b\x1a\x1e\xc3\xfd\xbc\x83\x6a\xb2\xfa\xde\x80\x75\x8d\x74\xa1\xc8\x8c\x84\x22\x89\xb2\xe6\x50\x83\x18\x6b\x46\x54\x56\x7e\x73\x94\x46\x52\x8a\x75\x1d\x9d\x9c\x20\x97\x48\x3d\x49\x69\x14\xdf\xc4\x22\x56\x63\x46\x39\xe4\x75\x60\x3a\x14\x64\xd2\x6e\xa8\x0c\x4a\x72\x0b\x82\x4a\x10\xae\xaf\xaa\xcf\xe1\x52\x1c\x3d\xd0\xa9\x4d\xf4\x8c\xfd\x02\x04\x87\xec\x73\x21\x6c\xc7\x3d\x11\xde\x4a\xac\xc4\x74\x9f\x05\xc5\x82\xf6\xbe\x40\x85\xca\xf1\x18\x6e\x42\x7b\xa4\xa9\xf3\x4e\x99\xa0\xe7\x36\x19\xa1\xa0\x18\x04\x8a\x56\xa8\x05\x37\xc5\xd3\x0d\x90\x8e\x28\x6a\xe7\x07\xc9\x62\x08\xeb\x42\x6a\x01\x89\xef\xb9\x22\x1d\x4a\xe2\xc1\x92\x36\x83\xe1\x81\xb9\x07\xf7\x66\x10\xf1\xf5\xc0\xc0\x5b\x30\xb6\x46\x6f\x60\x10\xde\x0d\xfe\xbb\xfc\x72\x16\x74\x31\xcf\x43\x63\x8d\xfa\x7d\x4f\x24\x3c\x6b\x4b\x47\xf3\x17\x49\x74\x8c\xf7\x81\xe6\x51\x98\x56\x39\x31\x27\x47\x26\x14\x59\xf6\xc5\x1a\x62\x57\x75\x0c\x13\x8a\x52\x0e\x6b\xe5\x8b\x6e\xed\xf2\x92\x76\xce\x7b\xf8\x19\xbf\xee\x0a\xa1\xb2\xe2\x43\xc3\x76\xf4\xc1\xad\x14\x11\x23\x1b\x6e\x87\x40\xc6\xa9\xac\x68\x98\x95\x22\x37\x16\xd2\x62\xf9\x68\x86\x13\x99\xb4\x97\x41\xfb\xa5\xb3\x97\x3b\xe9\x13\x82\xde\xbc\xbf\x6f\x7a\xe8\xd8\x3a\x53\x23\xe8\x19\x00\xef\x09\xde\x3b\x1d\x5c\xc0\xd4\xed\x76\x53\x3b\x5f\xb5\xfa\xf0\x6d\x8b\x11\x5a\xc6\xc6\x83\xfa\x30\x7c\x1e\x02\x7b\xc1\xdf\x71\x76\x77\xdc\xb6\x99\xc5\x15\x2a\x8d\x33\xdd\xb4\x48\x31\xd9\xa6\x06\x69\xcb\xfc\x75\x74\x1b\x3a\x87\xe5\xbd\xcb\xae\xfe\x85\x97\x94\x55\xd1\x65\x7b\x2c\x94\xf3\xcf\x2c\xeb\x5f\x7d\x49\x27\xc3\xfe\xc9\xa1\x61\xd5\x5c\xd9\xf5\xc9\x3c\x7b\xad\x0d\x7b\xf0\xaa\xa4\xe4\x0d\x8d\x31\xfc\x96\x2c\xe5\xf1\xb6\xc1\x1a\x6a\x62\x33\xa0\xbf\xf5\x05\xbd\x08\x28\xed\x71\x41\xa5\x22\x63\x6e\x5d\x89\x7e\x0a\x39\x7a\x1a\x09\x67\xbd\xd4\xf0\x31\x5c\x6a\xbc\xaa\x0a\xd6\xc8\x62\x8d\x19\xe5\xff\x0f\x42\x96\xc4\x8c\x8b\xcb\xa5\xbb\x81\xa2\x2e\x51\xa2\x0b\xf3\x10\x47\x89\x10\x28\x93\xab\x0c\xc3\x75\x54\x4e\x1e\x95\x66\xc0\x99\xad\x63\xf4\xed\xcc\xff\xea\x16\x76\x84\x7c\x0e\x65\x8f\xc8\x11\x53\xbe\x6c\x15\xe5\x75\x4d\x75\xcd\xc1\x07\xbe\x25\xd7\xc7\xaf\x77\xce\x72\x9d\xae\x7a\xb6\x60\x9b\x18\x1e\x86\x68\xb2\x73\x78\x72\x35\x0d\xe1\x17\xd4\x4c\x43\xf8\x68\x96\xc6\xae\x5f\x9f\xf7\xb0\xf8\x62\x7d\x6f\xaa\xc0\xe1\x96\xe7\x57\x64\x2b\x14\x84\xef\xd1\x17\x17\xa4\xb5\xeb\xfb\x54\x0b\x85\x5a\x3e\x54\x11\x95\xa2\x8c\x3a\x97\xd3\xa0\x0c\x7b\xc2\x3c\x4d\x92\xf1\xca\x51\x7a\x37\x8c\x37\xa7\xa9\x83\xd9\x5d\x5e\x4b\x7d\x09\x28\x65\xa7\xca\xe1\xef\x8f\xef\x1e\x26\x7f\xb3\xa9\x64\xc5\x2c\x23\x4e\xa9\x45\xea\xcc\x21\x70\x9d\x15\x80\xdc\x5c\x17\x3e\x86\xa4\x53\xa2\x51\x73\x62\x3f\x4e\xd4\xc8\xf1\x6f\x6f\x7e\x1f\xc3\x2f\xd6\x01\x3d\x63\x59\x69\x1a\x82\x4a\x6d\x4e\x73\xc5\xdb\x2a\x8f\x82\x30\xdb\xbd\xa1\x12\x0a\x2c\x55\x36\x4f\x4c\xaf\x03\xb3\x1e\x97\x04\x36\x31\x5b\x13\x68\xb5\xa4\x29\x0c\xb8\xa2\xac\x75\xf4\x67\x83\x25\x7d\x19\xc0\x8f\xeb\x82\x1c\xc1\x40\x1e\x07\xf1\xc0\x6d\x09\x29\x73\x2d\xa7\x4c\x07\xc7\x3e\xdc\xa9\xc5\x82\x1c\xc5\x62\x9c\x56\x64\xfc\x4f\xd2\x89\xa9\x39\x18\xdb\x5a\x1c\x48\x88\x3e\x2b\xca\xd4\x5c\x51\x7e\xc0\xc8\x6f\x6f\x7e\x1f\xc0\x8f\x5d\xb9\x04\x75\xe8\x19\xde\xc4\x2e\x43\xb1\xc8\xf8\x53\x6a\xdc\x78\x63\x3c\x3e\x0b\xcd\x4c\x5a\x07\x13\x6b\x7e\x6f\xa1\xc0\x15\x01\xdb\x92\x60\x4d\x5a\x8f\xe2\xbd\x69\x0e\xeb\xd8\x92\x36\xaa\x8c\x2d\x5e\x85\xce\xef\x7d\xaf\x78\x7a\x77\xf7\x6e\x1a\x4f\x13\xb3\x2d\x8c\x1c\x61\xac\x87\xb9\x32\xa8\x53\xdf\xa1\x78\xd7\xa6\x70\x1d\x8d\xe4\x2d\x64\x05\x9a\x80\x95\x41\x1b\xf3\xda\xd7\x8e\xc6\xfb\xf7\xd7\x5f\x15\x03\xc7\x3e\x24\x9c\x72\xff\xf0\x59\x61\xbf\xc8\xfc\x1f\x5e\xda\x7f\x95\xd0\xe1\xbb\xda\x05\x42\x3f\xb4\xfc\xf4\xa4\xd0\xcb\x7a\x46\xce\x90\xa7\x20\x77\x6e\x33\x16\x91\x33\xaa\x3c\x4f\xec\x8a\xdc\x4a\xd1\x7a\xb2\xb6\x6e\xa9\xcc\x62\x24\x8e\x38\x8a\xde\xc1\x93\xf0\x2d\x72\xf2\x43\xf8\x79\x35\x19\xb9\xc2\xec\x62\x41\xc3\xa6\xef\x21\xad\x9c\xc3\x93\x57\x11\xb6\x69\xe4\x2e\xef\x9d\xae\x1f\x23\x70\x64\xfb\x34\x24\xec\xd6\x85\xca\x8a\xe6\x53\x64\x0b\x29\x4b\xcc\x23\x94\xa2\xd9\x7c\x73\xe7\x17\x95\xd6\x4e\xce\xde\x8c\xd2\x67\xf4\x11\x9a\x5c\xfe\xb3\x62\x2f\xf3\xaf\xa2\xc3\x5a\x5d\x04\x04\x1f\xef\xef\xbe\x4f\x48\xd4\xea\x2b\xa2\x3e\x7e\xc6\x9a\x82\x77\x75\x53\xd3\xb2\xb7\x4e\x2a\xd7\xce\x5c\x3d\xdb\xde\x58\xec\x84\x4f\x45\x16\x7c\xfe\x72\xf5\x9f\x00\x00\x00\xff\xff\xb3\x0d\x9b\xb8\x18\x21\x00\x00") +var _operatorsCoreosCom_operatorsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x59\xcd\x72\xe3\x36\x12\xbe\xfb\x29\xba\x94\x83\x93\x2a\xfd\x24\xb3\x97\x94\x6e\x2e\x7b\xb2\xe5\xdd\xac\x67\x6a\xec\x99\x4b\x2a\x87\x16\xd9\x12\xb1\x02\x01\x06\x0d\x4a\xd6\x4e\xcd\xbb\x6f\x35\x00\x4a\xa4\x24\x4b\xd4\xac\x27\x1b\x5c\x24\x82\x40\xa3\x7f\xbf\xee\x06\xb1\x52\x9f\xc8\xb1\xb2\x66\x0a\x58\x29\x7a\xf6\x64\xe4\x89\xc7\xcb\x9f\x79\xac\xec\x64\xf5\xd3\xd5\x52\x99\x7c\x0a\xb7\x35\x7b\x5b\x7e\x20\xb6\xb5\xcb\xe8\x8e\xe6\xca\x28\xaf\xac\xb9\x2a\xc9\x63\x8e\x1e\xa7\x57\x00\x68\x8c\xf5\x28\xd3\x2c\x8f\x00\x99\x35\xde\x59\xad\xc9\x8d\x16\x64\xc6\xcb\x7a\x46\xb3\x5a\xe9\x9c\x5c\x20\xde\x1c\xbd\xfa\x71\xfc\xf3\xf8\xc7\x2b\x80\xcc\x51\xd8\xfe\xa4\x4a\x62\x8f\x65\x35\x05\x53\x6b\x7d\x05\x60\xb0\xa4\x29\xd8\x8a\x1c\x7a\xeb\x78\xbc\xfb\x97\x59\x47\x56\x7e\xca\x2b\xae\x28\x93\x83\x17\xce\xd6\x55\x7b\x75\x6b\x4d\x24\xd5\xf0\x87\x9e\x16\xd6\xa9\xe6\x19\x60\x04\x56\x97\xe1\x7f\x94\xfb\x5d\xa2\x11\xa6\xb4\x62\xff\xcf\xce\xf4\xaf\x8a\x7d\x78\x55\xe9\xda\xa1\x6e\x9d\x19\x66\x59\x99\x45\xad\xd1\xed\xe6\xaf\x00\x38\xb3\x15\x4d\xe1\x56\xd7\xec\x49\x26\x92\x1e\x12\x0f\xa3\x24\xeb\xea\xa7\xc4\x12\x67\x05\x95\xd8\x30\x08\x42\xca\xdc\xbc\xbf\xff\xf4\xb7\xc7\xbd\x17\x00\x39\x71\xe6\x54\xe5\x83\x56\x1b\x1e\xc1\x51\xe5\x88\xc9\x78\x06\x84\x2c\x1e\xbb\x65\x68\xdc\xda\xee\x37\xc2\x98\x9d\xfd\x9b\x32\xdf\x9a\xae\x9c\x2c\xf6\x2d\x2d\xc5\xd1\xf2\x9e\xce\xfc\x1e\x1f\xd7\xc2\x6c\x5c\x07\xb9\x38\x0e\x31\xf8\x82\x1a\xb1\x29\x4f\x12\x82\x9d\x83\x2f\x14\xef\xf8\x0d\xbe\x20\xd3\x68\x12\x57\x63\x78\x24\x27\x1b\x81\x0b\x5b\xeb\x5c\x3c\x6c\x45\xce\x83\xa3\xcc\x2e\x8c\xfa\xcf\x96\x1a\x83\xb7\xe1\x18\x8d\x9e\xd8\x83\x32\x9e\x9c\x41\x0d\x2b\xd4\x35\x0d\x01\x4d\x0e\x25\x6e\xc0\x91\xd0\x85\xda\xb4\x28\x84\x25\x3c\x86\x7f\x59\x47\xa0\xcc\xdc\x4e\xa1\xf0\xbe\xe2\xe9\x64\xb2\x50\xbe\x89\x8d\xcc\x96\x65\x6d\x94\xdf\x4c\x82\x9b\xab\x59\x2d\x76\x9f\xe4\xb4\x22\x3d\x61\xb5\x18\xa1\xcb\x0a\xe5\x29\xf3\xb5\xa3\x09\x56\x6a\x14\x98\x35\x21\x3e\xc6\x65\xfe\x9d\x4b\xd1\xc4\xd7\x7b\xea\x8b\x76\x60\xef\x94\x59\x74\x5e\x05\x9f\x3c\xa9\x6b\x71\x4f\x50\x62\xe8\xb8\x3d\xca\xb2\x53\xa9\x4c\x89\x56\x3e\xbc\x7d\x7c\x82\x86\x81\xa8\xf6\xa8\xe1\x96\xb7\xec\x94\x2d\x8a\x52\x66\x4e\x2e\xae\x9c\x3b\x5b\x06\x2a\x64\xf2\xca\x2a\xe3\xc3\x43\xa6\x15\x19\x0f\x5c\xcf\x4a\xe5\xc5\x8a\x7f\xd4\xc4\x5e\xec\x30\x86\xdb\x00\x0d\x30\x23\xa8\xab\x1c\x3d\xe5\x63\xb8\x37\x70\x8b\x25\xe9\x5b\x64\xfa\xe6\xaa\x16\x8d\xf2\x48\xd4\xd7\x5f\xd9\x6d\x64\x3b\xdc\x70\x10\x25\x00\x0d\xfc\xbc\x68\x9d\x26\x22\x1f\x2b\xca\x3a\xa1\x90\x13\x2b\x27\xae\xeb\xd1\x93\x38\x7c\x07\x76\xfa\x1c\xed\xd1\xd7\xdc\xef\xf0\xb0\xb4\x73\xbc\x9d\xb1\x18\xba\x75\x3e\x9a\x1d\x7c\x48\xa4\x88\x41\x33\x5b\x56\xd6\x88\x63\xf4\xe5\xea\x65\xe8\x80\x90\x1c\x1a\x7a\x87\xef\xf6\x78\xbf\xdd\x2e\x4d\xf3\x33\xe2\xad\xf7\x8a\x0c\xe8\x23\x39\xa6\x28\xd0\x11\x70\xeb\xc1\xad\x0c\x71\x5b\xb1\xc5\x31\x9e\x04\x9c\x35\xce\x48\x3f\x92\xa6\xec\xd0\x3c\xe7\x24\x96\xd1\xd9\x7f\x7c\xc9\x9e\xf0\xbf\xb6\x77\xc4\xd8\x0e\x44\xe0\x8f\x9a\xdc\x06\xec\x8a\x9c\x84\x3b\x79\x31\xdc\x4e\x29\x35\x53\x2e\x18\xc8\x61\x67\x47\x2d\xd7\x27\x8c\xd9\x53\x4d\x7d\x44\x95\x51\xa2\xcf\x8a\xb7\xcf\x02\x29\xad\x1c\xd7\x43\xea\xfd\x8d\x49\x70\xc5\x41\xcc\xa8\x00\x6e\x94\x92\x8c\x56\x46\xd4\x7a\x2a\xa8\x33\x03\xe8\x08\x6e\x1e\xee\x28\x3f\xe6\x0f\x5d\x81\xd1\x39\xdc\x9c\x58\xa5\x3c\x95\x27\x85\xd8\x13\xe3\xe6\x04\xab\x09\xa7\x9b\x37\xc9\x8b\x8d\x47\x65\x38\xe5\xa0\x21\x20\x2c\x69\x13\xd3\x95\x64\xc1\x26\x28\xc3\x62\x47\x21\xb9\x05\xdb\x2e\x69\x13\x16\xa5\xdc\x75\x92\xc3\x1e\xb6\x8d\xe3\x74\x30\xec\xc6\x48\x8e\x3f\xbb\xc6\x1e\x07\xb5\xee\xe8\xe3\x54\x71\x2c\x69\x73\x6e\xc9\x9e\x31\x44\x47\x8a\x53\x55\x20\x56\x91\x89\xa0\x49\x99\xda\x1a\x02\xab\x4a\x2b\x0a\x89\xeb\x2c\xfd\x17\xb3\xc7\xe1\x68\xc4\xbf\x90\x69\x7b\xb4\x8c\x5b\xd2\xe6\x9a\xa3\x03\x48\x74\x14\xaa\x92\x58\xdf\xc2\x40\x53\xc1\x7c\x42\xad\xf2\x5d\x51\x1a\x22\xe1\xde\x0c\xe1\xc1\x7a\xf9\x79\xfb\xac\x24\x43\x8b\xdf\xdc\x59\xe2\x07\xeb\xc3\xcc\xab\x8a\x1d\x59\xb9\x50\xe8\xb8\x29\x04\x88\x89\x31\x29\x52\xb5\x4b\x1a\x1e\xc3\xfd\xbc\x83\x6a\xb2\xfa\xde\x80\x75\x8d\x74\xa1\xc8\x8c\x84\x22\x89\xb2\xe6\x50\x83\x18\x6b\x46\x54\x56\x7e\x73\x94\x46\x52\x8a\x75\x1d\x9d\x9c\x20\x97\x48\x3d\x49\x69\x14\xdf\xc4\x22\x56\x63\x46\x39\xe4\x75\x60\x3a\x14\x64\xd2\x6e\xa8\x0c\x4a\x72\x0b\x82\x4a\x10\xae\xaf\xaa\xcf\xe1\x52\x1c\x3d\xd0\xa9\x4d\xf4\x8c\xfd\x02\x04\x87\xec\x73\x21\x6c\xc7\x3d\x11\xde\x4a\xac\xc4\x74\x9f\x05\xc5\x82\xf6\xbe\x40\x85\xca\xf1\x18\x6e\x42\x7b\xa4\xa9\xf3\x4e\x99\xa0\xe7\x36\x19\xa1\xa0\x18\x04\x8a\x56\xa8\x05\x37\xc5\xd3\x0d\x90\x8e\x28\x6a\xe7\x07\xc9\x62\x08\xeb\x42\x6a\x01\x89\xef\xb9\x22\x1d\x4a\xe2\xc1\x92\x36\x83\xe1\x81\xb9\x07\xf7\x66\x10\xf1\xf5\xc0\xc0\x5b\x30\xb6\x46\x6f\x60\x10\xde\x0d\xfe\xb7\xfc\x72\x16\x74\x31\xcf\x43\x63\x8d\xfa\x7d\x4f\x24\x3c\x6b\x4b\x47\xf3\x17\x49\x74\x8c\xf7\x81\xe6\x51\x98\x56\x39\x31\x27\x47\x26\x14\x59\xf6\xc5\x1a\x62\x57\x75\x0c\x13\x8a\x52\x0e\x6b\xe5\x8b\x6e\xed\xf2\x92\x76\xce\x7b\xf8\x19\xbf\xee\x0a\xa1\xb2\xe2\x43\xc3\x76\xf4\xc1\xad\x14\x11\x23\x1b\x6e\x87\x40\xc6\xa9\xac\x68\x98\x95\x22\x37\x16\xd2\x62\xf9\x68\x86\x13\x99\xb4\x97\x41\xfb\xa5\xb3\x97\x3b\xe9\x13\x82\xde\xbc\xbf\x6f\x7a\xe8\xd8\x3a\x53\x23\xe8\x19\x00\xef\x09\xde\x3b\x1d\x5c\xc0\xd4\xed\x76\x53\x3b\x5f\xb5\xfa\xf0\x6d\x8b\x11\x5a\xc6\xc6\x83\xfa\x30\x7c\x1e\x02\x7b\xc1\xdf\x71\x76\x77\xdc\xb6\x99\xc5\x15\x2a\x8d\x33\xdd\xb4\x48\x31\xd9\xa6\x06\x69\xcb\xfc\x75\x74\x1b\x3a\x87\xe5\xbd\xcb\xae\xfe\x85\x97\x94\x55\xd1\x65\x7b\x2c\x94\xf3\xcf\x2c\xeb\x5f\x7d\x49\x27\xc3\xfe\xc9\xa1\x61\xd5\x5c\xd9\xf5\xc9\x3c\x7b\xad\x0d\x7b\xf0\xaa\xa4\xe4\x0d\x8d\x31\xfc\x96\x2c\xe5\xf1\xb6\xc1\x1a\x6a\x62\x33\xa0\xbf\xf5\x05\xbd\x08\x28\xed\x71\x41\xa5\x22\x63\x6e\x5d\x89\x7e\x0a\x39\x7a\x1a\x09\x67\xbd\xd4\xf0\x31\x5c\x6a\xbc\xaa\x0a\xd6\xc8\x62\x8d\x19\xe5\x7f\x05\x21\x4b\x62\xc6\xc5\xe5\xd2\xdd\x40\x51\x97\x28\xd1\x85\x79\x88\xa3\x44\x08\x94\xc9\x55\x86\xe1\x3a\x2a\x27\x8f\x4a\x33\xe0\xcc\xd6\x31\xfa\x76\xe6\x7f\x75\x0b\x3b\x42\x3e\x87\xb2\x47\xe4\x88\x29\x5f\xb6\x8a\xf2\xba\xa6\xba\xe6\xe0\x03\xdf\x92\xeb\xe3\xd7\x3b\x67\xb9\x4e\x57\x3d\x5b\xb0\x4d\x0c\x0f\x43\x34\xd9\x39\x3c\xb9\x9a\x86\xf0\x0b\x6a\xa6\x21\x7c\x34\x4b\x63\xd7\xaf\xcf\x7b\x58\x7c\xb1\xbe\x37\x55\xe0\x70\xcb\xf3\x2b\xb2\x15\x0a\xc2\xf7\xe8\x8b\x0b\xd2\xda\xf5\x7d\xaa\x85\x42\x2d\x1f\xaa\x88\x4a\x51\x46\x9d\xcb\x69\x50\x86\x3d\x61\x9e\x26\xc9\x78\xe5\x28\xbd\x1b\xc6\x9b\xd3\xd4\xc1\xec\x2e\xaf\xa5\xbe\x04\x94\xb2\x53\xe5\xf0\x8f\xc7\x77\x0f\x93\xbf\xdb\x54\xb2\x62\x96\x11\xa7\xd4\x22\x75\xe6\x10\xb8\xce\x0a\x40\x6e\xae\x0b\x1f\x43\xd2\x29\xd1\xa8\x39\xb1\x1f\x27\x6a\xe4\xf8\xb7\x37\xbf\x8f\xe1\x17\xeb\x80\x9e\xb1\xac\x34\x0d\x41\xa5\x36\xa7\xb9\xe2\x6d\x95\x47\x41\x98\xed\xde\x50\x09\x05\x96\x2a\x9b\x27\xa6\xd7\x81\x59\x8f\x4b\x02\x9b\x98\xad\x09\xb4\x5a\xd2\x14\x06\x5c\x51\xd6\x3a\xfa\xb3\xc1\x92\xbe\x0c\xe0\xfb\x75\x41\x8e\x60\x20\x8f\x83\x78\xe0\xb6\x84\x94\xb9\x96\x53\xa6\x83\x63\x1f\xee\xd4\x62\x41\x8e\x62\x31\x4e\x2b\x32\xfe\x07\xe9\xc4\xd4\x1c\x8c\x6d\x2d\x0e\x24\x44\x9f\x15\x65\x6a\xae\x28\x3f\x60\xe4\xb7\x37\xbf\x0f\xe0\xfb\xae\x5c\x82\x3a\xf4\x0c\x6f\x62\x97\xa1\x58\x64\xfc\x21\x35\x6e\xbc\x31\x1e\x9f\x85\x66\x26\xad\x83\x89\x35\xbf\xb7\x50\xe0\x8a\x80\x6d\x49\xb0\x26\xad\x47\xf1\xde\x34\x87\x75\x6c\x49\x1b\x55\xc6\x16\xaf\x42\xe7\xf7\xbe\x57\x3c\xbd\xbb\x7b\x37\x8d\xa7\x89\xd9\x16\x46\x8e\x30\xd6\xc3\x5c\x19\xd4\xa9\xef\x50\xbc\x6b\x53\xb8\x8e\x46\xf2\x16\xb2\x02\x4d\xc0\xca\xa0\x8d\x79\xed\x6b\x47\xe3\xfd\xfb\xeb\xaf\x8a\x81\x63\x1f\x12\x4e\xb9\x7f\xf8\xac\xb0\x5f\x64\xfe\x1f\x2f\xed\xbf\x4a\xe8\xf0\x5d\xed\x02\xa1\x1f\x5a\x7e\x7a\x52\xe8\x65\x3d\x23\x67\xc8\x53\x90\x3b\xb7\x19\x8b\xc8\x19\x55\x9e\x27\x76\x45\x6e\xa5\x68\x3d\x59\x5b\xb7\x54\x66\x31\x12\x47\x1c\x45\xef\xe0\x49\xf8\x16\x39\xf9\x2e\xfc\xbc\x9a\x8c\x5c\x61\x76\xb1\xa0\x61\xd3\x9f\x21\xad\x9c\xc3\x93\x57\x11\xb6\x69\xe4\x2e\xef\x9d\xae\x1f\x23\x70\x64\xfb\x34\x24\xec\xd6\x85\xca\x8a\xe6\x53\x64\x0b\x29\x4b\xcc\x23\x94\xa2\xd9\x7c\x73\xe7\x17\x95\xd6\x4e\xce\xde\x8c\xd2\x67\xf4\x11\x9a\x5c\xfe\xb3\x62\x2f\xf3\xaf\xa2\xc3\x5a\x5d\x04\x04\x1f\xef\xef\xfe\x9c\x90\xa8\xd5\x57\x44\x7d\xfc\x8c\x35\x05\xef\xea\xa6\xa6\x65\x6f\x9d\x54\xae\x9d\xb9\x7a\xb6\xbd\xb1\xd8\x09\x9f\x8a\x2c\xf8\xfc\xe5\xea\xbf\x01\x00\x00\xff\xff\x7e\x2b\xf8\xdd\x18\x21\x00\x00") func operatorsCoreosCom_operatorsYamlBytes() ([]byte, error) { return bindataRead( @@ -225,7 +225,7 @@ func operatorsCoreosCom_operatorsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_subscriptionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x7d\x6b\x73\xe3\xb8\x95\xe8\xf7\xf9\x15\x28\x27\x55\xb6\xb3\x92\xdc\x9d\x9d\x4d\x72\xbd\xa9\xa4\xdc\xb6\x7b\xa2\x9d\x6e\xb7\xb7\xe5\xee\xa9\xdc\x24\x37\x81\x48\x48\xc2\x98\x04\x38\x00\x28\xb7\xf2\xf8\xef\xb7\x70\x0e\x00\x82\xd4\x8b\x94\xe5\xc7\x4c\xcc\x0f\x33\x6d\x0a\x00\x81\x83\x83\xf3\xc2\x79\xd0\x82\x7f\x66\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x62\x98\xb0\x7f\xe9\xc1\xed\x6f\xf4\x80\xcb\x93\xf9\xeb\xaf\x6e\xb9\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x32\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x57\x39\x33\x34\xa5\x86\x9e\x7e\x45\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\xaa\x3f\x65\x62\x70\x5b\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xf8\xd5\xe0\x97\x5f\x11\x92\x28\x06\xdd\x6f\x78\xce\xb4\xa1\x79\x71\x4a\x44\x99\x65\x5f\x11\x22\x68\xce\x4e\x89\x2e\xc7\x3a\x51\xbc\x80\x4f\x0c\x64\xc1\x14\x35\x52\xe9\x41\x22\x15\x93\xf6\x7f\xf9\x57\xba\x60\x89\xfd\xf8\x54\xc9\xb2\x38\x25\x2b\xdb\xe0\x70\x7e\x8e\xd4\xb0\xa9\x54\xdc\xff\x4d\x48\x9f\xc8\x2c\x87\x7f\xe3\xda\x47\xd1\x57\xe1\x75\xc6\xb5\xf9\x76\xe9\xa7\x77\x5c\x1b\xf8\xb9\xc8\x4a\x45\xb3\xc6\x6c\xe1\x17\x3d\x93\xca\x5c\x55\xdf\xb6\xdf\xd2\xe5\x38\xfe\xb7\x6b\xc8\xc5\xb4\xcc\xa8\xaa\x0f\xf2\x15\x21\x3a\x91\x05\x3b\x25\x30\x46\x41\x13\x96\x7e\x45\x88\x83\xa3\x1b\xb3\x4f\x68\x9a\xc2\xde\xd0\xec\x5a\x71\x61\x98\x3a\x97\x59\x99\x8b\xf0\x4d\xdb\x26\x65\x61\xd4\x53\x72\x33\x63\xa4\xa0\xc9\x2d\x9d\x32\xff\xbd\x31\x4b\x89\x91\xa1\x03\x21\xdf\x6b\x29\xae\xa9\x99\x9d\x92\x81\x05\xf1\xc0\x42\x30\xfa\x19\xf7\xe7\x1a\x07\x89\xde\x9b\x85\x9d\xae\x36\x8a\x8b\xe9\xa6\xcf\x27\xd4\xd0\x4c\x4e\x09\xe2\x17\x99\x48\x45\xcc\x8c\x11\xfb\x29\x3e\xe1\x2c\xf5\xf3\xdb\x30\x23\xec\xba\x34\xa7\x51\xf3\x75\xeb\x29\xcd\xa8\x10\x2c\x23\x72\x42\xca\x22\xa5\x86\x69\x62\x64\x05\x9f\xcd\xe0\x71\x9d\x97\x66\x73\xbe\xf4\x7e\xc5\x74\xb0\xe9\xfc\x35\xcd\x8a\x19\x7d\xed\x5e\xea\x64\xc6\x72\x5a\xed\xa1\x2c\x98\x38\xbb\x1e\x7e\xfe\xcf\x51\xe3\x07\x52\x5f\x4a\x8c\xa2\xe4\x96\xb1\x42\x57\x87\x82\x94\x85\x5d\x93\x5d\x1c\x19\x2f\x88\x51\x34\xb9\xe5\x62\x0a\x4b\x9f\xe2\x7a\xcf\x71\x63\xf4\x60\x69\xca\x72\xfc\x3d\x4b\x4c\xf4\x5a\xb1\x1f\x4a\xae\x58\x1a\x4f\xc5\x42\xd6\x93\x88\xc6\x6b\x0b\xa7\xe8\x55\xa1\xec\xb4\x4c\x74\x0e\xf1\x89\x68\x54\xed\x7d\x63\x99\x87\x16\x16\xd8\x8e\xa4\x96\x3c\xd9\xe9\xcf\x98\x3f\x1c\x2c\x75\x00\xb4\xdb\x69\x66\x5c\x13\xc5\x0a\xc5\x34\x13\x48\xb0\xec\x6b\x2a\xdc\x9a\x06\x64\xc4\x94\xed\x68\x0f\x6c\x99\xa5\x96\x8e\xcd\x99\x32\x44\xb1\x44\x4e\x05\xff\x7b\x18\x0d\x40\x64\x3f\x93\x59\xfc\x30\x04\x8e\x9b\xa0\x19\x99\xd3\xac\x64\x3d\x42\x45\x4a\x72\xba\x20\x8a\xd9\x71\x49\x29\xa2\x11\xa0\x89\x1e\x90\xf7\x52\x31\xc2\xc5\x44\x9e\x92\x99\x31\x85\x3e\x3d\x39\x99\x72\xe3\x29\x70\x22\xf3\xbc\x14\xdc\x2c\x4e\x80\x98\xf2\x71\x69\x37\xee\x24\x65\x73\x96\x9d\x68\x3e\xed\x53\x95\xcc\xb8\x61\x89\x29\x15\x3b\xa1\x05\xef\xc3\x64\x05\x92\xc8\x3c\xfd\x99\x72\x34\x5b\x1f\x36\xc0\xb7\xf2\x1c\x10\x4f\xf5\x36\xc2\xda\x12\x3f\xc2\x35\xa1\xae\x3b\xae\xa5\x02\xa9\x7d\x65\xa1\xf2\xf1\x72\x74\x43\xfc\x04\x10\xec\x08\xe1\xaa\xa9\xae\x80\x6d\x01\xc5\xc5\x84\x29\x6c\x39\x51\x32\x87\x51\x98\x48\x0b\xc9\x85\x81\x3f\x92\x8c\x33\x61\xec\x31\xcc\xb9\xd1\x80\x73\x4c\x1b\xbb\x0f\x03\x72\x0e\x0c\x88\x8c\x99\x3b\xb0\xe9\x80\x0c\x05\x39\xa7\x39\xcb\xce\xa9\x66\x0f\x0e\x6a\x0b\x51\xdd\xb7\xe0\x6b\x0f\xec\x98\x7f\x2e\x77\x58\x3a\x63\x84\x78\x06\xb7\x76\x77\xe2\x03\x3f\x2a\x58\x12\x8e\x03\x15\xe4\xac\x28\x32\x9e\x20\xc6\x9b\x19\x35\x24\xa1\xc2\xc2\x8b\x0b\x6d\x68\x96\x01\x3b\x69\x35\x8b\x75\xa7\x9d\xc0\xd1\x6e\x30\x07\xff\x7a\x89\x42\xd7\x7f\x08\x4c\xad\xd1\x62\x1d\x65\xb0\x8f\xa3\xb3\xcb\x3f\x6c\x00\x39\x41\xc9\x64\xc2\xa7\xab\xba\xad\x85\xe5\x39\x74\x01\x99\x86\x72\xa1\xdd\x10\xa5\x42\x68\x56\x9c\xca\xf2\x2e\x5a\xe3\xdb\x83\xb5\xb3\x5b\x09\xd9\x6d\x6b\xb6\x0f\x13\xf3\xd5\x3f\x34\x16\x70\x29\xe6\x78\x50\xad\xcc\x62\x89\x1c\x13\x73\xae\xa4\xc8\xed\x21\x9a\x53\xc5\xe9\x38\x73\x8c\x8d\x59\xf2\x85\x67\x0c\x97\xc8\xd4\xaa\x23\xb5\xe6\xab\xb8\x1e\xaa\x14\x5d\xac\x69\xc1\x0d\xcb\xd7\xac\x66\xd5\xb4\x3f\x53\x15\x51\x09\x8b\xbc\xab\xa6\x4e\x5c\x03\x3b\x75\x4a\xce\xc3\xc4\xd7\x7e\x66\x0b\xdc\xf1\x59\x8f\xdb\xd5\xb3\x06\xcb\xfd\xb3\x6d\x03\xf1\x01\x4e\xbf\xe1\xf7\x06\x58\xec\x09\x41\x06\xc6\x56\x42\x63\x40\xde\x97\x1a\x76\x8b\x92\xf3\xbf\x0e\x2f\x2e\xaf\x6e\x86\x6f\x87\x97\x1f\xd7\x83\x83\x6c\x3b\x28\xd5\x03\x34\xbe\xc3\x64\x0f\x3f\xfb\x3d\x52\x6c\xc2\x14\x13\x09\xd3\xe4\xe7\x47\x9f\xcf\x3e\xfe\xf5\xea\xec\xfd\xe5\x31\xa1\x8a\x11\xf6\xa5\xa0\x22\x65\x29\x29\xb5\x67\x1a\x85\x62\x73\x2e\x4b\x9d\x2d\x1c\xe5\x4a\xd7\x20\x6d\x13\x5b\x81\xdb\x52\xb1\x20\x9a\xa9\x39\x4f\x56\x83\x48\x0f\xc8\x70\x42\x68\x85\x40\x49\xc0\x70\xcb\xa8\xb2\x39\x4b\x7b\x30\x6c\x98\xb4\xff\x0e\x17\x45\x69\x3c\xc3\xbb\xe3\x59\x06\xa7\x42\xa0\xac\x94\x0e\xc8\x85\x2c\xed\x78\x3f\xff\x39\x2c\x4c\xb1\xb4\x4c\x40\x88\xb6\xc4\x80\x8b\xa9\xfd\xa9\x47\xee\x66\x3c\x99\x11\x9a\x65\xf2\x4e\x03\xa5\x60\x3a\xa1\x85\x5f\x7a\x0c\x1d\xbd\x10\x86\x7e\x39\x25\x7c\xc0\x06\xe4\xe0\xe7\xd1\x4f\x07\xf8\xf5\x42\x49\xfb\x09\x94\x93\x71\x56\x19\x37\x4c\xd1\x8c\x1c\xc4\xad\x07\xe4\xd2\x7e\x83\xa5\xf1\x3e\xc0\x08\x82\xcd\x99\xb2\xab\xf0\xbb\xd0\x23\x8a\x4d\xa9\x4a\x33\xa6\xb5\xc5\xb3\xbb\x19\x33\x33\x86\xa2\x78\x00\x18\xfb\xc2\x2d\xc3\x95\x8a\x08\x69\x06\xe4\x82\x4d\x68\x99\x01\x07\x26\x07\x07\x83\x26\xe3\xdb\x1d\xd5\xde\x2a\x99\x77\x40\xb7\x51\x5d\x73\x58\xb5\xf7\x87\x1a\x47\xae\x91\x35\xcd\x52\xc2\x27\x4e\x82\xe1\xda\x2e\x8a\xb0\xbc\x30\x8b\x36\x87\x66\x0b\x1d\x21\xad\x09\x01\x09\x3c\xe9\x3d\x2d\xbe\x65\x8b\x8f\x6c\xb2\xad\x79\x73\xfd\x2c\x63\x89\x25\x94\xe4\x96\x2d\x40\x9c\x25\xe7\x7e\xc0\xcd\x4b\xe9\xb4\x1c\xd2\x92\x3c\xfa\xa7\x6f\xa7\xb3\xb5\x5d\x7b\x20\xd9\xe7\x96\x2d\xda\x34\x23\xcb\x3a\x9d\x05\x0d\xf0\x3a\x0b\xab\xed\x50\x21\xed\x51\xd6\x3f\xdb\x29\xfa\xca\xc9\x1d\xc6\xa4\xdd\x9d\x53\xb3\x52\x60\xbd\x2d\xc7\x4c\x09\x66\x18\xc8\xac\xa9\x4c\xb4\x15\x57\x13\x56\x18\x7d\x22\xe7\x96\xf2\xb1\xbb\x93\x3b\xa9\xac\x22\xd7\xbf\xe3\x66\xd6\xc7\x5d\xd5\x27\x60\xf4\x38\xf9\x19\xfc\x8f\xdc\x7c\xb8\xf8\x70\x4a\xce\xd2\x94\x48\x38\xe2\xa5\x66\x93\x32\x23\x13\xce\xb2\x54\x0f\x22\xad\xab\x07\xfa\x40\x8f\x94\x3c\xfd\xfd\xe6\xc3\xbd\x23\xc4\x64\x81\xc6\x8a\x1d\xa0\x36\x02\xa1\x6b\x51\xa3\x53\x01\xe9\x2d\x85\xb2\x2a\x82\xdd\xf3\xdc\xb1\x45\xc7\x50\x3a\x2c\x63\x2c\x65\xc6\xa8\xd8\xd2\x03\xc0\xd6\xfd\xcc\x1e\x56\x87\x16\x46\xf0\x08\x50\xc8\xf4\x94\xe8\xb2\x28\xa4\x32\x3a\xa8\x08\x60\x73\xe9\xd5\xff\x04\x79\xb9\x47\xfe\x16\x5e\x66\x74\xcc\x32\xfd\xa7\xc3\xc3\xdf\x7e\x7b\xf9\xc7\xdf\x1d\x1e\xfe\xe5\x6f\xf1\xaf\x91\x85\xae\xde\x04\x6d\x3a\x32\x05\x21\xdc\xfd\xe9\xd8\xe8\x59\x92\xc8\x52\x18\xf7\x83\xa1\xa6\xd4\x83\x99\xd4\x66\x78\x1d\xfe\x2c\x64\xda\xfc\x4b\x6f\xe1\x04\xe4\x61\x89\x0e\x80\xf3\x9a\x9a\xd9\x9e\x49\xcf\x7a\x6b\xc4\xea\xa7\xb6\xdd\xde\x3e\xe1\x76\xd9\x19\x24\xec\x3f\xdf\xfa\xe9\x5a\x0e\x74\xa7\xb8\x31\x4c\x80\xdc\xc1\x54\x6e\x39\x71\xcf\x62\x6e\xc5\x66\xe7\xaf\x0f\x1e\x84\x78\x05\xa8\xed\xb0\x38\x98\xbd\x5b\x19\x22\x73\x20\xb4\x5e\x82\xaa\x74\xa4\xb3\xeb\xa1\xb7\xcc\xec\x7d\x21\xde\xde\xf0\xf6\xde\x67\x32\x58\x2e\xdc\xb2\x82\xa4\x79\x4a\xa4\xc8\x16\xe1\x77\x4d\x32\x0e\xd6\x08\x2b\x80\x06\x8b\xc4\x11\xbe\x1c\x24\x45\xd9\x73\x0d\x06\x39\xcb\xa5\x5a\x84\x3f\x59\x31\x63\xb9\x95\xd8\xfa\xda\x48\x45\xa7\xac\x17\xba\x63\xb7\xf0\x17\x76\xac\x7d\x60\xb9\x37\x8a\xd4\x49\xa9\x2c\xf3\xc8\x16\x9e\x82\xb0\xf4\x69\xcf\xa2\x07\xd3\x9e\x8f\x62\xd8\x8d\xab\x1d\x59\x6e\xd0\x16\x9d\xc1\xd5\xaf\x0a\x64\xc8\xb9\xcc\xca\x9c\xe9\x5e\x60\x4f\x28\xad\x8b\xb9\x95\x26\x97\xcc\x3b\xab\x9f\x8e\xa7\x2f\xe5\x73\xae\xa5\xda\x99\x0f\x72\x67\xf2\x94\xa5\xb1\x9a\xca\x44\xaa\x9c\x9a\xa0\x2e\x7e\x29\xa4\x06\x1d\xc0\xe1\x6c\x83\xa4\xbc\x3e\x68\xf5\xd9\x82\x1a\xc3\x94\x38\x25\xff\xef\xe8\xcf\xff\xf1\xcf\xfe\xf1\xef\x8f\x8e\xfe\xf4\xaa\xff\x7f\xfe\xf2\x1f\x47\x7f\x1e\xc0\x3f\x7e\x71\xfc\xfb\xe3\x7f\xfa\x3f\xfe\xe3\xf8\xf8\xe8\xe8\x4f\xdf\xbe\xff\xe6\xe6\xfa\xf2\x2f\xfc\xf8\x9f\x7f\x12\x65\x7e\x8b\x7f\xfd\xf3\xe8\x4f\xec\xf2\x2f\x2d\x07\x39\x3e\xfe\xfd\xcf\x5b\x4d\x8f\x8a\xc5\x87\x16\x07\x1e\x9f\xbe\xdb\x20\x2e\x0c\x9b\x32\xd5\xb1\x57\xeb\x6d\x25\xe4\x4b\xbf\x12\xda\xfa\x5c\x98\xbe\x54\x7d\xec\x7e\x4a\x8c\x2a\xb7\x1f\x8c\x8a\xa8\xed\x82\xe7\x1f\xfd\x69\x8d\x4c\xb1\x9e\x34\xef\x1d\x91\x35\x4b\x14\x33\xfb\xd2\x60\x70\x34\xcf\x3f\x0a\x99\x1e\x6a\x22\xd6\x98\x09\xd7\x4d\xfb\xdf\x42\xa9\xf1\x22\x05\xc2\xab\xe2\xbc\x13\x25\xf3\x01\x89\xcc\x42\x73\x9a\xf1\xd4\xb7\xbb\x65\x5b\xb4\x5c\xff\xbc\x28\x41\x3f\x2e\x25\x68\x84\xfb\xfb\xe0\x1a\x10\x13\xf3\x4d\x66\x9a\xa6\x4d\xd7\xb6\xad\x9b\xa3\xbd\x00\x65\x24\x29\x64\x51\x66\xd4\xac\x31\xdb\xad\xb0\x4d\x3b\xdc\xd7\xc1\x4c\x68\x37\x1a\xec\xc0\x8e\xca\xe5\xab\x8d\xa1\xe4\x2c\xcb\x08\x17\x78\x12\x60\x00\x6f\xcd\x53\x0c\xe5\x25\x42\xd1\xe0\x3c\xb7\x53\xb8\x9b\xb1\xa6\xa1\x91\x6b\xab\xeb\x28\xc3\xc5\x74\x40\xbe\xb3\xbf\x23\xcd\x72\xa6\x31\x2e\x48\x5e\x66\x86\x17\x19\x23\x81\xdb\xa2\x0d\x2d\x2b\x19\xa1\x5a\xcb\x84\x53\xe3\x66\xec\xee\x0f\xb5\xf1\xd3\x86\xd9\x18\x7a\x0b\xa6\xd0\x84\xa5\x4c\x24\x6c\x40\x3e\xc3\x75\x61\x58\xeb\xd8\x0a\x83\x60\xde\x87\x31\x28\x49\x4b\xbc\xda\x41\x7a\xb0\x7a\x8c\x61\x9e\x97\x06\x0c\xc5\x8f\x65\xc5\xb7\x3b\xee\x2c\x73\x91\x31\x1f\x48\x55\x10\xad\x29\xdc\x3d\xc8\x49\xa5\xba\xeb\xfb\x99\xef\xdb\x11\xde\x60\x6e\xdb\xca\xa9\x96\x28\x6e\x65\x63\xa8\x53\xda\xc7\xb6\x18\xb6\xa3\xb3\x3f\x49\x1a\xdb\x81\xbe\xb6\xa7\xad\x1d\x8c\x4b\x5d\xe9\x69\x5b\x6b\x52\xa1\xd8\x84\x7f\xe9\x80\x8f\x67\xa2\x52\x51\x78\xca\x84\xb1\x8a\x80\x02\x82\xaa\x58\xc1\x04\xe8\xe1\x8c\x26\x33\xa0\x0b\x8e\x8a\x56\x96\xe1\x87\xbc\x31\x42\x29\xa3\xfb\xf1\x1a\xad\x92\x62\x5e\xce\xd6\x4f\xfc\x6c\xb9\x5d\xdf\xff\xc1\x12\x32\x65\xa8\x5b\xac\x57\xae\x1b\xfb\x18\xf5\x70\x7e\x2e\xfe\x2f\xbc\xc0\xf3\x93\xb4\xda\x5b\xb8\x72\x2a\x24\x9c\xb5\x09\x37\x44\x5a\x89\xc0\x7e\x77\x40\x46\x2b\x7a\xe6\xd4\x24\x33\xd7\xe2\xf0\x50\x13\x34\xda\x36\x07\x1a\xa3\x89\x30\x2d\x33\x96\x12\xef\xb0\x81\x83\x76\x44\xa9\x9a\xab\xc2\x09\xd5\x9a\x4f\x45\xbf\x90\x69\xdf\x8e\x76\xb2\x0e\x21\x5a\x1c\xaa\xd8\xd5\x70\xfb\xc1\xda\x8a\x57\xc1\x38\xd1\x6e\x9b\x3e\x06\xfb\x5b\x24\x5b\x24\x32\x2f\x4a\xc3\x22\xe3\x5c\xb0\xeb\x8c\x17\xe8\x59\x14\xc9\x90\x95\x44\x74\x3f\x98\xe6\x54\xd0\x29\xeb\xbb\x8f\xf7\xc3\xc7\xfb\xe1\x5b\xf7\x01\x73\x1b\xaa\x85\x26\xc5\x4d\xe7\xb0\x0e\xbc\x77\x68\xb2\xc4\x97\x63\x67\x3a\xca\xe9\x17\x9e\x97\x39\xa1\xb9\x2c\x05\xc8\x64\xcb\xe0\x84\xcb\x6b\x96\xee\x07\x60\x2b\x00\xa5\xd7\x42\xaa\x25\xb4\x48\x67\xc4\x24\xcf\xd7\xb2\xd5\xca\xa2\xd5\xcd\x92\xd5\xc1\x82\xb5\xb3\xe5\xca\x1b\xa9\xdb\xe3\xe3\x47\x6f\x37\x6f\x60\x24\x17\x5b\x31\xd2\x1f\x70\x70\xed\x08\xe3\x70\x4d\x64\xce\x8d\x09\x2e\x59\x01\xc3\x7a\x84\x9b\x9a\xf5\xd3\x9d\x05\x3e\x41\x1a\xcb\x35\x61\x5f\xac\x36\xc5\xc1\x8a\xee\x6f\x2d\x7a\xc8\x65\xef\xb8\x06\x03\x1a\x15\x84\xe7\x45\xc6\x72\xef\x43\xda\xf7\xba\x99\x73\x32\x78\x39\x1f\x2f\xe7\x63\x55\x27\xdd\x45\x16\x89\xc5\x10\x34\x14\x8c\x59\x56\x89\x23\x16\xb3\x0b\x99\x6a\x27\x2f\x78\x1c\xb2\x67\xe1\xf2\x0b\xd7\xe0\x89\xfb\x91\x81\x65\x60\xc4\x8c\x26\x77\x33\xa9\x19\xf6\xa0\x8a\xb9\x71\x22\xd6\xe8\x2d\x21\x70\x8f\x00\x4e\xa3\x93\x49\xbd\x45\xca\x8a\x4c\x2e\x72\x90\x6c\x87\x26\x96\x67\x82\xe8\xc2\xf2\x22\xa3\x86\x05\xc1\x66\xb3\xb5\xe1\xde\x9c\x0f\xbe\x7e\xf9\xc5\x4a\x00\x51\x1c\x44\x0b\xd8\x36\x3b\xd6\x4d\x53\x0d\x48\x3b\x22\x93\xa3\xcf\xf2\x0d\x48\xf8\xd5\x1b\x80\xe6\xd9\xd5\xc5\x7a\x07\x49\xd2\xca\xbc\x42\xb6\x9b\x58\x96\x96\x71\xb6\x61\xaa\x0d\xe9\x15\x7d\x7e\xbd\x07\x2b\x7a\xa0\xf7\xd0\x78\xd5\x73\xee\x73\x21\x3a\x00\x1b\x2b\x96\x61\xe8\x83\x33\x34\xdb\x46\xce\x73\x7d\x3f\x1a\x59\x5b\xbb\x7b\x1b\x9b\x7b\x3f\x4c\x7e\x4f\x4a\x60\x2b\xa3\x7c\x6d\x33\x40\xc9\x8e\x8f\x2a\xb8\x1c\x59\x48\xa2\x7d\xde\x6d\x04\x2d\x8a\x0c\xee\xeb\x64\x5b\xdf\xac\x96\xea\x18\x2e\xbf\xe3\xa4\xc3\x96\xc7\x0e\xb7\x76\xe6\x87\x1a\x11\xc0\x9e\x8e\x19\x2f\x9c\x37\x23\x5a\xeb\x7c\xfc\xc2\x67\xb0\xa3\x56\x31\x25\xf6\x24\x0c\x45\x8f\x5c\x49\x63\xff\x77\x89\x36\x51\x8b\x37\x17\x92\xe9\x2b\x69\xe0\xcd\x5e\x97\x8d\x53\xe9\xb8\x68\xec\x04\x07\x44\xe0\x99\x04\x83\x74\x14\xd0\x80\xbe\xa2\x40\x0a\x3d\x80\xb8\x26\x43\x41\xa4\xf2\xab\x0b\x56\x5d\xed\x86\xf0\x9a\xa1\x90\xa2\x8f\x6e\x84\xab\xc6\xb8\x0c\x3e\x94\x31\x4c\x36\x0c\xe7\x86\xba\xb1\x14\x18\x7f\xc1\x10\x96\x8c\x26\x2c\x25\x69\x09\x93\x86\x70\x0c\x6a\xd8\x94\x27\x24\x67\x6a\xca\x2c\xd3\x4e\x66\x6d\x41\xbd\x8d\x2e\xe1\xd3\x82\x3a\xc5\x83\x6e\xd9\x3f\x20\xc1\xef\x80\x4b\x74\x23\xdb\xd8\x07\xc9\x5b\x4e\x0b\xbb\x75\xff\xb0\x54\x0c\xa0\xf7\x2f\x52\x50\xae\xf4\x80\x9c\x79\xd7\xdb\xf8\x37\x67\x03\x8b\x87\xb1\x23\x58\xa9\xef\x87\x92\xcf\x69\x66\xe9\x26\x0a\x78\x0c\xc5\x3b\x3b\x7a\x93\x59\xf4\x1c\x2f\xb5\xe7\x1b\xfd\x5d\xb8\x26\x07\xb7\x6c\x71\xd0\x5b\xda\xee\x83\xa1\x38\x40\xfa\xba\xb4\xc1\x81\x18\x83\x47\xc9\x01\xfc\x76\x70\x3f\xfe\xf2\x00\xc2\xdf\xd6\xbd\x34\x32\x63\x2a\x0e\xfd\xdc\xb2\x87\x37\x55\x7b\x58\x5a\x75\xbd\x1b\x8d\xf4\x38\xb7\x14\x37\x5e\x6c\xb1\x67\xab\x9a\x17\xa0\x96\x31\x34\x99\xa1\x17\xb7\x9b\x17\xc4\xd1\x2c\x88\xdd\x33\x83\x74\x1d\x10\xc3\x71\x48\xa3\xe0\xd2\xe7\xb7\x01\xdb\x7a\x0c\xe4\xa7\xdf\x45\xfe\xed\xd0\xde\xfe\x11\x30\xe4\xb7\xfe\x5f\xbf\xbb\x67\xdc\x42\x3b\xc6\x86\x53\xea\x20\x60\x5c\x42\x07\xc2\x45\x0a\x17\x4c\x6e\xa9\x00\x01\x1c\xcb\xc2\x07\x96\x35\x20\x97\x96\x50\x91\x9c\x51\xa1\xbd\x99\x0b\x6e\xa2\xaa\xc6\xda\x5d\x99\x45\x7a\x95\x33\x29\x54\x27\x83\x91\x2b\x39\x72\xb6\xaf\x1e\xb9\x06\x5b\x6a\xf5\x06\x4e\xd2\x95\xbc\xfc\xc2\x92\xd2\xac\xbd\xcb\x8a\xe1\xb6\x95\x8b\x6c\x65\xf4\x35\x80\x7c\x5b\x31\x79\x5c\x59\x8d\xc9\x57\x18\x1c\xb3\xf9\x8d\x90\xb9\x65\x8b\x8a\xd9\x38\x11\x02\x48\x7e\xaf\xc2\x12\xcf\x0a\x90\x77\xfc\xb7\x37\x65\xe5\x63\x2e\xf0\x63\x38\xb4\xdf\x0a\x18\xdd\x03\xd4\x4a\x76\x59\x86\x9f\xd9\x07\xb8\xda\xc9\x19\x35\x98\x7d\xe8\x20\x63\x04\x2a\xb9\x5a\xba\x88\x44\x8a\xcb\x1f\x4a\x9a\xd5\x83\x10\xdc\x2b\xd7\x68\x89\xaa\xdf\xf1\x2c\x4d\xa8\x72\x5e\x5e\x18\xa6\xa9\x25\xee\x1e\x05\x42\x90\x50\x11\x4e\x7b\xb5\x47\x1a\xaf\x2a\x0b\xaa\x0c\x4f\xca\x8c\x2a\x1f\x39\xde\x2a\x50\x60\x2b\x44\x2b\xa4\x19\xb1\x44\x8a\xb4\x8b\x02\x70\xd3\xec\xdb\xbc\x6b\x2d\x98\xe2\x12\xbd\x8b\x79\xce\x9a\x48\x7a\x54\xb7\x69\xcb\x89\x3f\xd5\xe1\x88\xd5\x2c\x1f\x10\x9b\xe9\x19\x1e\x9f\x0a\xa9\x58\x7a\x1c\x91\xc7\x70\x2a\x06\xe4\xcd\xc2\x9b\x59\xc0\xe4\xe2\xa2\x2b\x34\x33\x3e\x10\xc6\xa3\xac\x03\x76\x75\xa0\x26\x52\x41\x70\xca\x51\x2a\x31\x22\x63\xce\x13\x73\x3c\x20\xff\x97\x29\x09\x1b\x2f\xd8\x94\x1a\x3e\x0f\xdc\x34\x28\xae\x8a\x51\x77\x83\xff\x8a\x1c\x41\x37\xc2\xf3\x9c\xa5\x9c\x1a\x96\x2d\x8e\x51\x8f\x65\x44\x2f\xb4\x61\x79\x9b\xad\x6b\x63\x34\x40\x5f\x3b\x68\xfb\xab\xaf\x37\xb4\xec\x1a\x43\xf5\xd9\x47\xa5\x54\x90\x41\x1f\x82\xc6\x16\x06\x1e\x24\x37\x88\x9b\xb1\x0f\x82\x0b\x6c\xf6\x92\x65\xbc\xc1\xdf\x5b\x3c\xa0\x44\x31\xc8\x40\xe0\x30\xf7\x9e\x38\x8e\xde\x94\xef\x65\x29\xd6\x9b\x04\x6b\x0b\x7f\xe7\x94\xf0\xcf\x51\xc7\xb5\x51\x8a\x8f\x22\x26\x44\x33\x89\x4c\x94\x94\x80\x5d\x12\xd8\xb9\x25\x0f\xd8\xaa\xf2\x44\xd9\x3a\xc9\xbd\x46\x24\xc2\x5c\xb6\x78\xbd\xef\x25\x6e\x31\x7c\xa8\x03\x2e\x83\x83\xb8\x03\x4c\x23\x6e\xcf\x38\x72\x00\xf8\x89\x10\xac\x10\x14\xbe\xc5\x52\xef\xc5\x66\xa9\x81\xeb\x4a\x0e\x4f\x0f\xf7\x42\x7c\x71\x39\x4a\x16\x74\x0a\xe7\xa9\xc3\xaa\x9a\x5d\x49\xca\x0c\x53\x39\x04\x5c\xcf\xe4\x1d\xfe\x8e\x6c\xab\x70\xad\x58\x5a\xc5\xb6\xcf\xa4\x06\xae\x54\x0f\x62\x84\xf3\x0b\x17\xa3\x77\x74\x41\xa8\x92\xa5\x48\x9d\xd4\x14\x08\xe8\xfb\xc6\x87\xaf\xa4\x00\x4a\x51\x6a\x0b\xab\x9b\x1a\x95\x1e\x33\x43\xed\xb1\x79\x3d\x78\xfd\x6a\x2f\x00\xeb\x18\xb7\x0a\xb3\x69\x58\x0a\xfd\x5d\xb9\x3f\x33\x7b\x99\x97\x62\x34\xfd\x20\xb2\x2e\xb2\xdc\x7b\x44\x2f\xe8\xda\x07\x25\x8c\x4f\xc0\x76\xdb\xc3\x57\x77\x8a\x1b\x16\x91\xc7\xa3\x09\xcd\x34\xb3\xaa\x7b\x29\x82\x08\x7b\x5c\x17\x41\xa0\x49\x9b\x05\x6d\xf7\x07\xd1\xe5\xf8\x9e\xe7\xcc\x1d\x28\x40\xb9\xea\x98\x05\x84\x3b\xd4\x1b\x8e\x5c\x3d\xb8\x93\x1c\x61\x4b\x2b\xb1\x49\x69\x8e\xf7\xe3\x24\x82\x0b\xb4\x9a\x75\x17\x95\xc4\xc7\x0d\x17\x7b\x5c\xed\x1b\x36\xa3\x73\xa6\x89\xe6\x39\xcf\xa8\xca\x20\x56\x70\x84\xf3\x23\xe3\xd2\xac\x8e\x40\xef\x16\xdd\x1c\xcf\x24\x1a\x6e\x2b\xa8\xfd\x3c\x2c\x9c\x80\x46\xf8\x79\xd9\xef\xe4\xa5\x29\x69\x96\x2d\x08\xfb\x92\x64\xa5\xe6\xf3\xfb\x9e\x26\x17\xfd\xb0\x03\xab\x6e\x72\xe9\x42\xa6\xa3\x82\x25\x8f\xc9\xa3\xeb\x1a\x86\x25\x55\xa9\xdf\x74\xe0\xc9\xa8\xec\x83\xe6\xbe\x00\xcf\xa7\x24\x61\x5a\x7b\x9f\xca\x45\xec\xe7\x19\xd6\xf0\x63\x49\x28\x40\xef\xf4\x65\x46\xb5\xe1\xc9\x9b\x4c\x26\xb7\x23\x23\x55\xa7\x98\xfd\xb3\xef\x46\x4b\xfd\x1b\x69\x18\xce\xbe\x1b\x91\x0b\xae\x6f\xe3\xc4\x2e\x78\x69\x1a\x9b\x4b\x28\xb9\x2d\xc7\x2c\x63\xe6\xf0\x50\x23\x97\xcb\x69\x32\xe3\x82\x79\x06\x27\x42\x48\x8a\x53\xf8\x2c\x94\xbb\xde\x99\xba\xc0\xa7\x13\x87\xaf\x3f\xa3\x77\x9a\xe1\xf4\xc7\x76\xfa\xf6\x67\xd6\x26\x22\x7d\xaf\xf7\x14\x38\x99\xe1\xc5\x9e\xee\x20\x26\xfa\xc6\xce\xb1\x9b\x71\xfb\xf0\x2d\xcf\x18\xea\x38\xb0\x44\xef\x95\xe6\xce\x01\xec\xd8\x42\x96\xe4\x8e\xa2\x56\x0c\x34\x70\x40\x6e\x78\x71\x4a\x2e\x85\x2e\x15\xab\xec\x19\x93\xc6\x50\x5c\x57\x91\x65\x5e\x9d\x82\x1d\x46\x95\xc3\x52\x3a\xa7\x5d\x91\xcb\x2f\x34\x2f\x32\xa6\x4f\xc9\x01\xfb\x62\xbe\x3e\xe8\x91\x83\x2f\x13\x6d\xff\x27\xcc\x44\x1f\x0c\xc8\x30\x0f\xf7\xec\x90\xfa\x47\x31\xef\xfa\x84\x1d\x2c\x33\x8e\xf8\xec\x83\x20\x88\x73\xa3\xb3\xd2\x5a\x2a\xc9\x1d\x66\xa0\xb0\x24\x9e\x29\x25\x55\xf0\x3c\x8f\xc0\x00\xdc\x25\x91\x79\xa1\x64\xce\x23\xc3\x1e\x20\xf8\x5e\xfd\xeb\xc0\xdc\xb0\x5d\x24\x5d\xde\x7f\xcc\xe9\xe6\x3a\x93\x3a\x73\x5c\xb7\xfb\xc3\x89\xf7\x98\x40\x55\xd1\xe9\xee\xa0\x7f\xba\x46\x76\xbf\xdd\x28\x96\x5a\xc5\x3b\xfc\x36\x44\xcd\x91\x93\x94\xcd\x4f\x74\x4a\x5f\xf7\xe0\x33\xda\x79\xfb\x99\xda\x9c\xa8\x26\x07\xaf\x0f\x06\x64\xe4\xb9\x6d\x2f\x9e\x63\xd5\x6e\x22\x55\x18\x10\x8c\xe9\xaf\x0e\xc8\x91\x54\x30\x72\x42\x05\xc9\x18\x9d\x3b\x03\x32\x9e\xa9\x05\xea\xb4\xc7\xad\xa3\x1e\xdb\x06\x80\x45\x5a\xfe\x7f\xfe\x72\x4b\xeb\x76\x92\xe8\xf2\xbe\x79\xcf\xc8\x03\x2b\x82\x1e\x80\x30\x29\x2d\x8d\xb5\x54\xd3\xb2\x55\x48\xab\xe5\xc6\xae\x16\xcc\xc5\x92\xa6\x8c\x03\x6c\xdc\xd4\x03\x90\x53\x0f\x9e\x80\xea\x92\x8e\xf1\xf5\x9e\xa4\x76\x85\xe6\x27\xc1\x7f\x28\x19\x19\x5e\x84\xc8\x7a\xa6\x34\xd7\xc6\x9e\xee\xb4\xc6\xc3\x38\x32\xb6\xa3\xb3\x9c\xfe\x5d\x0a\x72\xf9\x66\xe4\x3e\x7a\xfc\xa4\xe0\xd9\x4a\x24\xe8\xdf\x4b\xc5\x2c\x3b\xee\xe2\x30\xe0\xfb\x34\x39\xbb\x7d\x4f\x2e\xa8\xa1\xc8\xe0\x9d\xcb\x95\xa8\x28\xbc\xc5\xc2\x31\x17\xa9\xfb\x29\xe2\xdc\x8f\xcd\x64\xed\xee\x5d\x6d\x92\x97\xe2\x86\x9f\x3e\x0e\xf7\xc4\x8c\x13\xa0\xf1\xd3\xf7\x32\xed\xcc\x91\xff\x60\x01\x78\x8e\xfd\x49\x6e\x07\x20\x56\x67\xef\xc1\x71\x26\xf6\x3c\xbb\x7f\x7e\x67\x35\xce\xd6\xc4\xab\x15\x1b\xf1\xd0\xea\x38\xe7\x9b\x48\x4f\x07\xda\x61\x51\x03\xce\x8d\x63\x28\xe3\x4c\x8e\x89\xc3\xf7\x7d\xcf\xf7\xd3\xc7\xe1\x0e\xd3\xfd\xf4\x71\xf8\xb8\x53\xdd\x49\x3c\x6b\x4a\x67\x15\x0f\xae\xc2\x31\x9a\x62\x57\x7b\x99\x6b\xb0\x2f\x69\x6b\x9f\x70\x5a\x95\x55\x72\x0b\x94\x0e\x2f\xbf\x14\xe8\x7c\xe6\x8c\xfc\xa3\x19\x85\x38\xe6\x10\x5d\x07\x9b\x6a\x77\x59\x5b\xca\xee\xb7\xd7\x6a\x74\x40\x9f\xc8\x05\xc3\x2b\xcb\xf4\xd4\x3b\x02\x84\x1e\xab\x3b\xbc\x07\xb7\xcb\xf4\x14\xe9\x2a\x41\x2f\xcc\x34\xc2\xa6\x23\x34\x11\x89\xf0\x13\x9d\x53\x9e\xd1\x31\xcf\xb8\x59\x58\x0e\x7d\x3c\xa8\xb9\x96\x6a\x98\xf2\x5e\x0f\xf3\x8e\xa2\xc5\x92\x81\x8a\x1c\xd9\x91\x4e\xc0\xc0\x75\x3c\xa8\xa4\x8a\x19\x53\x2e\x08\x11\x45\x8f\x9a\xc8\xa1\x99\x01\x6c\x6b\x48\x1c\x6d\x51\x65\x3b\xbb\x07\xc0\xdb\xf3\xd1\x95\xa1\xd9\x3e\x2b\x19\x1a\xfc\x30\x72\x39\xe1\x9e\x33\x4f\xc3\x78\xa9\x56\x5c\x0d\xd0\x6a\x6b\xcb\xf6\x7c\xed\xa7\x8d\x53\x24\x04\xa3\xed\xc0\x04\xed\x54\x85\x63\x82\x3e\xbe\xbe\xe6\x46\x89\x58\x36\x72\xa4\xc4\xa5\x4b\x42\xbe\x69\x71\xeb\xdb\x16\xa9\x02\xba\x24\x58\xf0\x3b\xdf\x35\xe4\x6a\x06\x6e\x15\xdb\x91\xab\xf5\x6c\x12\x56\xcc\x26\x5d\xee\xa9\xcf\x59\x31\x7b\x3b\xaa\x9b\xe7\xec\x3b\xf2\x76\xb4\xe2\x5c\x02\x90\x61\xb5\x1a\x8d\x76\x87\x9a\x64\x7c\xc2\x0c\xdf\xb2\x84\x07\x38\x99\xb9\x14\xdc\x48\xb5\x3e\x2e\x99\x74\x3a\x6d\x7e\xb8\xae\xfc\xb0\xca\xe4\xf1\xde\x8d\x80\x0e\x70\x89\xcc\x32\x96\xf8\x3c\xd6\x00\x52\xff\x89\x55\xca\x0b\x73\x3a\x7b\xc8\xf2\x8f\x8a\xca\x09\x6e\xe8\xc9\xc7\xcb\xb3\x8b\xf7\x97\x83\x3c\xfd\xd9\x4c\xde\xf5\x8d\xec\x97\x9a\xf5\x79\x8b\x54\x21\x4f\xe7\x46\x88\x4f\xd1\x2a\x73\x55\x1d\xa4\x1f\x7c\x00\x23\xf9\xa4\xd1\x6d\x00\x4c\x39\xfe\x52\x48\x4a\xd3\x23\x8a\xba\x20\x45\xea\x2c\x41\x65\x96\x21\x94\x8d\x62\xac\x17\xab\xd4\x1b\x63\x33\x3a\x2f\x68\x57\x23\x42\xb5\xa8\x87\x25\xd0\x8f\x8f\x5c\x5d\x68\xfd\x76\x21\x62\x13\xe4\x46\x61\x0c\xef\x7f\x01\x57\x4d\x46\x82\x7f\x16\xf8\xdb\x4e\xa4\xb2\x58\xa3\xea\x18\xc0\x4c\x02\x8b\x3d\x29\x35\x53\x03\xc7\x31\x1e\x1d\x50\x1d\x92\xf5\xec\x90\x23\xad\x09\xa6\x8f\x6c\x82\x0e\xc9\x3e\x67\xae\x93\xa2\x68\x69\x66\x4c\x18\x9f\x72\xdc\x01\x63\x25\xdc\x9c\x87\xf3\xa3\x03\xaa\x65\x7a\xa0\x6e\xc9\x7c\x5e\x12\xe0\x74\x41\x43\x7b\x50\xee\x45\xb7\x43\x74\x94\xa2\xa9\x04\x17\x08\xcc\xe9\x56\x43\x30\x9a\xe6\x5c\x3c\xc3\x83\x98\x70\x91\x6e\x5b\x7f\x23\x71\x1d\xf4\xa8\xcb\x51\x38\x8a\xb7\x9e\x87\x9b\x38\xea\xf5\x1a\x0c\x21\x77\x77\x72\xf5\x1b\xb9\x56\x87\x2e\x5f\xe8\x1f\xb2\x3e\x7e\xa5\x5f\xa4\x15\x54\x5e\xae\xd7\xf6\x6f\xc0\x79\x84\x4b\xb3\x3d\xed\x2f\xf9\xf7\x13\x68\xee\x0d\xa9\x2e\x32\xcc\xbd\x78\x33\x54\x4d\xd1\x3e\x68\x0b\x33\x82\x61\xf9\x15\xa7\xbb\x5a\x10\x14\x54\xd1\x9c\x19\xa6\xd0\x75\xcc\x39\xa3\x09\xe7\xd5\xff\xa1\x60\x62\x64\x68\x72\xbb\xef\x14\xa2\x2f\xfc\xf4\xe1\xf8\xe9\xae\xb7\x65\xde\x49\x26\x0d\x98\xe0\x12\x0a\x2d\xe2\x9b\x59\x2e\x1c\xb3\x79\x26\x74\x25\xe4\xf1\xea\x62\x89\x08\x79\x9c\xea\x4c\xb4\xca\xeb\x85\xc6\x07\x70\x11\x0b\x89\xe9\xc0\xf5\x1d\xa1\xb0\x1f\xa6\xd7\xfe\x10\x38\x39\x66\x97\x7b\xa7\x8a\x1e\xe4\x32\x65\x64\xcc\x4d\x75\xd2\x35\x33\xa4\x60\x2a\xe7\x2e\x00\x5a\x0a\xac\xc1\xc7\x52\xe4\x5e\x96\x53\xb9\x4f\x47\x9c\x4d\x10\x99\x18\x5f\xe4\x8a\x8c\x99\xb9\x63\x4c\x90\x57\xaf\x5e\xbd\x02\x79\xe3\xd5\xaf\x7f\xfd\x6b\x02\x19\x17\x52\x96\xf0\x7c\xb9\x21\xb4\xfa\xaf\xd7\xaf\x07\xe4\x8f\x67\xef\xdf\x81\xff\x55\x61\x34\x19\x4b\x33\x73\x23\xdb\x06\xb5\xce\xba\x47\xfe\x67\xf4\xe1\xca\x8b\x09\xba\xf1\x2b\xa8\x14\x61\x79\x75\x67\xba\x57\xbf\xfa\xfa\xeb\x01\xb9\xe0\x0a\x22\x6f\x39\xc4\x0a\x04\x77\xc1\xc2\xbb\xd0\x09\x69\x96\x63\xdd\x1d\x9b\x70\xee\xb4\x39\x9f\xce\x0c\x56\x4b\x02\x4c\xc9\x78\x62\x30\xfb\x1e\x1e\x76\xcc\x85\xa4\x5d\x28\x89\x0b\x8c\x72\x8e\x23\x30\xb9\x1e\xc9\xf8\x2d\x23\x13\xfd\x8d\x92\x65\x51\x05\x04\x2a\xa6\xad\x8c\xea\x6a\x31\xe1\x60\xd5\x5e\x69\x66\x9e\xd4\x93\xa1\xa5\xa5\xa6\x86\x74\xc3\x9a\x00\xd2\x0b\xf9\xc7\xfa\x88\x09\x05\xe5\xc1\xb9\x0e\xae\x9b\x6b\xd9\xef\x83\x16\x99\x46\xe7\xd4\xc7\x77\x14\x4a\x7e\x8f\x9b\xc4\x85\x8f\x14\x72\x32\xaf\x76\x32\x97\x0b\xcc\x04\x9b\x2d\xaf\x47\xae\x5b\xbe\xe7\xa2\xe2\xa3\x18\xa3\xe1\x24\x0e\x46\x83\xd0\x6d\xae\xed\x27\x6a\xc9\x21\x57\x7c\x39\x2e\x4f\x68\x66\x1a\x77\xb4\x14\x4b\xbd\x5d\xad\x11\x47\x69\x5c\x05\x1a\x17\xe6\x55\x8d\x81\xee\xaa\x2e\x48\x26\xaa\x6b\x54\x4b\xd8\x56\x73\x92\xd1\xcc\x94\x0e\x34\xe0\xab\x64\xbf\xcd\xb4\x76\xb1\x36\x39\x55\xb7\x56\xec\x77\xe7\x7f\x00\x9e\xc1\x3a\xc4\xf9\x60\xd0\xd5\x9c\x85\x22\x75\xb1\x67\xbd\xfd\xc8\xe1\x60\x70\x88\x07\x44\x2a\xcc\x77\x89\xd8\x6e\xdf\x3f\x51\x4c\x71\xdd\x73\x9b\x16\x51\x09\x3a\x57\xda\x83\xd6\x3c\x82\xa9\x83\x54\x9b\x2c\xb7\x9d\xc4\x97\x6e\xf9\x82\xdb\x66\x0c\xc6\x96\x45\x9b\xb2\x05\x5d\x25\xa8\x0e\x09\x86\xd7\xd7\x4d\x71\x47\xa0\x5d\xce\xe0\xce\x39\x70\x09\x7a\x45\xec\x32\xc7\xae\x4c\xce\x05\xb1\xd5\x2a\x66\x3d\x7f\xae\x36\x9c\x60\xf8\x47\x9d\x56\x39\x5a\x10\x49\x08\x55\x75\xaa\x2a\x16\xe4\x59\x33\xaf\x18\x5d\xba\x65\x63\xef\xc2\xc8\xf0\x69\x77\x49\x80\xcf\xd2\x39\x08\x34\xb3\xa8\x55\xbb\xc8\xd0\x00\x00\x72\xa3\x3f\x2c\x03\xf2\xde\xd1\x54\x44\x2e\x3a\xd6\x32\x2b\x0d\x76\xad\x7e\x8c\x09\x2e\x0c\xea\x53\x0e\x00\x95\x0d\xcd\x22\xf2\x6b\xaa\x7a\x5f\xed\x28\x31\x3e\x1d\x0e\xe3\x4b\xea\xcb\x27\x4b\x2b\x5b\x65\xec\xd6\x0f\x96\x62\x36\xd1\xbc\x8b\xaa\x34\x1a\x92\xa3\xaa\x54\x86\xbf\xe6\x1e\x0a\xc3\xd4\x84\x26\xec\x38\x56\xa1\x42\x49\x92\xe0\x59\xe3\x63\x03\x66\x54\xa4\x19\x8a\xd6\x09\x53\x80\xf2\xec\x8b\x2b\x96\x6b\x3f\x91\x2a\x0e\x45\x60\x8f\xde\x30\x2b\x0f\x32\x6a\x4a\xc5\x5a\x45\x18\xed\xd7\xad\x10\xa6\xb1\x2f\xa5\x0d\x06\xeb\xea\x52\x01\x9d\xbc\x84\x2a\xa2\x63\x55\x81\x09\xa1\x8a\x20\xd5\xb1\x5a\x3a\xb0\xa8\x04\xf4\x18\x48\xc5\x42\x96\xca\xd9\xbd\x7d\x6e\xd1\x44\x2a\xab\x08\xe1\xc0\x54\x13\xc5\xa6\x56\x5a\x55\x20\xd6\x62\x8b\xac\xb4\x2f\xf6\xea\xfc\xb5\x67\x27\xb9\x4d\x2e\x6e\x13\x27\x3e\xcb\x39\x4f\x3d\x8b\x84\xbb\xa5\xaa\xc4\x5f\x41\x75\x14\x77\x12\xa5\x63\x8f\x20\x8c\xc2\x38\x30\xd2\x10\xd1\x59\xf3\x9f\x8e\xad\xbb\x12\x12\x3d\xb4\xa8\xa5\xd0\x85\x08\xcb\x94\x5d\x97\xe3\x8c\xeb\xd9\x68\x47\x53\xe0\xd5\x8a\x21\xd0\x61\x60\xe9\xa2\x6e\xad\x79\x50\x33\xa1\x39\xb0\x3c\x4b\xc6\x2d\xb3\x85\xda\xc1\x12\x80\xe8\x7b\xc7\x98\x29\x21\x30\x22\x63\x2e\x9c\xdf\xfe\x14\xcd\xc3\x45\x68\x61\x02\x8f\x94\x7d\x12\x45\xed\x7d\x42\xb3\x4c\x37\xa3\x57\x3d\xa1\x45\x99\xc3\x47\x6d\xe1\x9e\x72\xbb\xdd\xa1\x4c\x48\x23\x15\xe4\xda\x85\x69\x92\x4b\x8c\x70\x11\x44\x0a\xdf\x08\xf2\x90\xf8\x0e\x51\x54\x1f\xc4\xee\x02\xca\xec\xb9\x8e\xe2\x8b\x0d\xf4\xe1\x6c\xa0\x3b\xde\x34\x54\x95\x94\x68\x14\x11\x5c\x2f\xf5\xec\x49\xa9\x27\xb9\x5b\xae\x24\xf6\x7a\x2b\x80\xdf\x3c\x33\x58\x9e\xbc\x73\xce\xb3\xcf\x8d\xee\xc0\xa6\xad\xde\x01\x87\xb7\xef\x34\x8b\x24\xc2\x4c\xa7\x10\x84\x23\xb0\x7c\xe4\x2b\x9e\x03\xec\x06\x5f\x1e\x6a\x92\xca\xa4\x0c\xb9\x51\x01\x68\xd5\x05\x58\x9b\x0c\x82\xa4\xeb\x71\xea\x9e\xd6\x2a\xfe\xc8\x56\xac\x4a\xe5\x9d\xb8\xa3\x2a\x3d\xbb\xde\xe2\x97\x5e\x67\xe7\x55\xaf\x58\x50\xf2\x83\x41\x25\x3c\x3a\x96\xa5\xa9\xd2\x67\xfe\xb4\x4d\xcf\x46\x5a\x8a\xd0\xd2\xd2\x4c\x5e\x8c\xd7\x2f\xc6\xeb\xe6\xf3\xe0\xc6\x6b\xdb\xa7\x9e\x0b\xb6\x76\x5c\x7d\x8a\x01\x9e\xb5\x75\xa5\x7d\x48\x2b\x68\x44\x60\x90\xba\x37\xfd\xe0\x1b\x72\x1b\x1e\x91\x6a\x6f\x23\x59\xcf\x53\x20\x60\xd5\x4f\x6f\x31\x7d\x20\x3b\x68\xfb\x5a\xbd\xf8\xac\x73\xc1\xdd\x54\xbb\x17\xa4\x86\xa8\xd8\x6e\xcf\x65\x42\xee\x39\xbd\x4b\xa4\x55\x19\x3b\x4c\xc4\xdc\xa1\x54\x27\x3e\x1d\x81\x4f\x3a\x6f\x00\xe9\x58\x48\x17\x9f\xae\xbb\x41\x76\x28\xaa\x8b\xcf\x13\x97\xd6\xc5\xa7\xb3\x89\x9b\x74\x2f\xb3\xbb\x62\xb9\x0f\x5b\x6c\x77\xc7\xa5\x3d\xbe\xf5\xbe\x57\x95\x78\x7b\xfe\x6c\xfd\xc5\x7a\xbf\xf4\x3c\xa2\xf5\x3e\x22\xdc\x9e\x18\x38\x00\xc4\x16\xfd\xd8\xdc\xe6\xcd\xfa\x63\xe6\xc5\xca\x41\x95\x81\xcc\xa2\x9c\x37\xe8\x4b\x55\xbf\x36\x3d\x1c\x0c\x0e\x0f\xbd\x99\xdf\xe1\x67\x69\x26\xfd\xdf\x10\x26\x12\x99\xe2\xa6\xda\xf1\x95\x36\xc0\xf4\x2b\xed\x3c\x9e\x4b\xee\xbf\x15\x5f\xbd\xc2\xd8\xdd\xb6\xa4\xc3\x09\xee\x5e\x3a\x7b\x15\xa4\x1f\xa3\x80\x76\x5c\x26\xbb\x5e\x15\x1b\x5b\xdc\xa7\x14\x76\x0c\xbc\x07\xe7\xaf\xad\x8b\x63\xe3\xb3\x0b\x7b\xdd\xa1\x50\x36\x3e\x8f\x5c\x2e\x1b\x9f\x9d\x38\x6a\xa7\xd2\xd9\x2b\x16\xf7\x78\x05\xb4\xf1\x79\xa6\xc5\x54\xea\x4f\xa7\x62\xda\xf8\xec\x56\x52\xbb\xde\xb7\xe3\xd6\xef\xa5\xbc\x36\x3e\xdd\x8a\x6c\xe3\xb3\xef\x52\xdb\xf8\xb4\x84\x04\xd8\xc0\x2f\x78\xa7\xe0\x81\x4b\xd7\xa7\xee\xf9\x68\x58\x5e\x48\x45\xd5\x82\xa4\xce\xd6\xb0\x58\x11\x80\x19\x45\x60\xde\x3b\x2b\x0a\xcc\x3d\xe5\x6a\x4f\xf1\x03\x1d\x82\x2f\x59\xca\xcb\xb5\x25\x8b\xd7\x81\xed\x3b\xc8\x86\xe5\x32\x69\xf9\xcb\x4d\x1c\x2a\xa4\x12\xa4\xc9\xad\xab\x91\xe3\x61\x88\x9c\x3e\x4e\xb9\x73\xd0\xc8\x7c\x0c\xc6\x30\xb8\xe9\x73\xb5\x00\x7d\x63\x1c\xbb\x66\xb8\xc2\x2b\x0f\x77\xf7\x7f\xe4\x1a\x1e\x5b\xf9\xe3\x3d\x30\xbd\x47\xda\x13\xd2\x31\xc8\x8c\xff\x9d\x41\x81\xad\xce\x29\xac\x24\x88\xdd\xa1\xf0\x57\x26\x93\xe8\x62\xb9\xc6\x7e\x00\xea\x01\xb3\xbd\x61\xde\xc2\xde\x7e\x1d\x85\x07\xb0\xe8\x64\x1a\xef\xea\x78\x02\xb9\x1b\x41\x44\x07\xd8\x05\x78\xdf\x44\x65\xf0\x4a\x6d\xbf\x04\xa9\xd5\xa3\x36\xd5\x87\xee\x7c\x0a\x49\x13\x55\x2a\xab\x2b\x16\xf6\x97\x91\x87\x40\xa4\x94\x41\x78\x82\x97\xc2\x75\x09\x32\xa0\xfb\x8a\x93\x85\xe4\x04\xee\xa3\xaa\xba\x5f\x21\x7b\xe1\x12\x56\x09\x9e\xd5\xd1\xca\xa7\x6e\x0b\x0b\x2f\x85\xf3\x22\x58\xc2\x91\xd5\x28\x52\x6a\xa6\xfa\xd3\x92\xa7\xbb\x20\xc7\x33\xe6\x6e\xad\x79\x5a\x77\x4e\xd6\x91\x7f\xdd\x83\x6b\x05\x2f\x8b\x0e\x74\xff\xe0\x32\xb8\x66\xd4\x08\x7f\x9c\x12\xae\xee\xa6\x41\xbd\x27\x40\x38\x72\xfe\xbe\xe7\x26\xe8\xad\x8e\x21\x24\x8b\xc4\x85\xc9\xf2\x5a\x3e\x47\x1c\x16\x31\x0f\xbc\x52\xfb\xf6\x3f\x5e\xbf\xf5\xc6\xfa\x31\x9b\xc8\xaa\x04\x08\xaa\x3b\xce\x97\x36\x65\x19\x83\x3a\xe9\xbe\x06\xbb\x6d\x00\xd7\xbc\xb9\x9c\x5b\x64\xfe\xb3\x20\x9f\x7c\x52\x7a\x3e\x39\x25\xf4\xb8\x16\xaa\xe0\xca\xaa\x08\xc6\x52\x74\xb0\xcd\xaa\xef\xa8\x52\xe8\x1e\x19\x1f\x7b\x67\x13\x38\x71\xc2\xca\x7c\x99\x17\x67\x51\x69\x56\xcc\x02\x00\x02\x7e\x95\xcc\x89\x16\xb4\xd0\x33\x09\xd5\xf5\x13\x5a\xd0\x84\x9b\x85\x05\xb7\x51\x34\xb9\x85\x32\x3c\x8a\xb9\x2f\xf6\x48\x72\xec\xfc\xb5\x62\x08\xd6\xdd\x7e\xcd\x4c\xc9\x72\x3a\x03\x4f\x56\x6c\x95\x64\x54\x7b\x00\xac\xec\xef\xb4\x19\x4d\xd2\x85\xa0\x39\x4f\x42\xd2\x3c\x25\xe7\x5c\x73\xe9\xac\xb9\x38\xae\xc5\x7a\x72\x1d\xf2\x9e\xa1\x91\xf8\x3c\xa3\x3c\x27\x47\x9a\x31\x12\x10\x03\x7f\x71\xd5\xda\xd1\x78\xa1\x98\xed\x1e\x5b\x90\x65\x48\xde\x2d\x5c\xc6\x81\x8a\xd2\x85\x2b\x2a\x64\x94\x70\xdc\xd2\xd5\x9f\x3e\x0e\x5b\xb7\x7a\x66\x52\xc1\xc5\xbc\xcf\x5a\xc9\x44\x2a\xa3\xeb\xc9\xb3\xeb\xa1\x8e\xd5\x0e\xc4\x33\x97\xdb\x0d\x7e\xc8\xa4\x98\xc6\x21\xfb\x15\x96\x5a\xb2\x2a\xa0\x96\xc9\x9c\xa7\x25\xcd\x90\xa0\xba\xc9\x9c\x8f\x86\xd8\x9d\x4f\x67\xa6\x7f\xc7\xc0\xec\x82\x7c\xa7\x72\x6d\xf2\x1f\xe5\x4b\x6e\x39\x5c\x03\x01\x36\xce\x6c\x80\x26\x2c\x3b\xb5\x3b\xba\x80\xfc\x2e\xce\x85\xa4\x76\x33\xea\x73\x6b\xe1\x10\x01\xee\x11\xd0\x61\x7a\x67\xa1\x36\x85\x95\x18\xc0\x2e\x65\xa1\x0c\x58\xbb\x3c\x37\x0b\xf8\x28\xd7\x5d\x78\xed\xca\x90\x51\xbb\x47\x20\xc5\xfd\x59\xa0\x85\x09\xae\x3b\xc6\x91\xef\x15\x0c\x81\x76\x6c\xcc\x70\x04\x8e\xf5\xee\x18\x7e\xc3\x04\x53\x3c\x69\xa0\x4e\xe8\x3a\xa5\x06\x0e\x1f\x13\xb6\x5b\x3a\xd8\xac\x1a\x3d\x80\x8c\x37\xaf\x50\xe9\xc6\x55\x23\xec\x28\x7d\x1c\x7c\x17\x59\xe1\xa2\x7b\x13\x7b\x4a\xa9\x48\xfb\x34\xb3\xf8\x79\xfd\xf9\xdc\xf9\x45\xe3\xb9\xab\xf9\x05\xf8\xc2\x42\x5c\x84\x4c\xd4\x56\x4a\x59\x79\xdc\x20\x00\x7e\xcc\x52\x20\x53\x71\x0d\xc6\x3b\xab\x70\x3b\x14\xb9\xfe\x7c\xde\x23\x7c\xc0\x06\xfe\xaf\xd0\xd4\xd3\x49\x23\xa7\xe8\x55\x18\x3c\x45\x01\xbb\x61\x2a\xb1\x6d\x2b\xee\xfb\xb7\xdf\xda\x49\xda\x5f\x7f\xd7\xff\x6d\x94\xdb\xf3\x77\x7f\xb3\xfb\xad\x6c\x83\xfa\xdb\xd8\x35\x2d\x24\xb2\xff\xdb\xb5\x4b\xf4\xec\xd2\x40\xff\xcd\xd5\xb7\x62\xc2\x58\xc1\xf4\x5a\xc2\xa5\x3f\x4f\x11\xe7\xe1\xdb\x8a\x7d\xef\xed\x94\x00\xa6\x60\x23\x4a\xa8\x61\x02\x58\x83\x8f\xe1\x10\xd2\x60\x77\x57\xca\xd5\xce\xff\x08\x2c\x0c\x18\x6e\xd6\x23\x46\x4a\x38\xf4\x48\x58\xce\x04\x61\xbe\xfc\x25\xae\x15\xc0\x41\x9d\xdf\x9b\xe7\x76\x76\x58\x0b\xe1\x10\x91\x6b\xe7\x01\x73\xfb\x85\x90\xe6\x17\x61\xfb\x1b\x85\xb9\xe9\x5c\x72\x9f\xd3\xdb\x9e\x47\x81\x45\x12\x43\x96\xe9\xf1\x82\xe4\x5c\x1b\x7a\xcb\x06\x64\x64\xb9\x59\x7c\xb9\x86\xd0\x13\x04\x72\x41\xb2\x94\x94\xc2\xf0\x0c\x7e\xad\xc6\xb1\x53\x8e\xb9\xdc\x70\x42\x74\x09\x15\xc3\x0b\xc5\xfa\x9e\x6f\xba\x56\x4b\x14\xa7\x5a\x4b\x2f\x6c\xf6\x8c\xa2\xb2\x51\xa4\xd0\x15\xe0\x41\x85\x43\xaf\x25\x6f\x30\x3b\x4f\x29\x92\x8a\x57\x02\x30\xf5\x80\x5c\x01\x7b\xcc\xfc\x0d\x33\xea\x3d\xce\x1e\x2a\x58\xc2\xb4\xa6\x6a\xd1\x83\x5c\xe9\x3c\xe4\xd7\x76\x0e\x40\x40\x3c\x72\x2a\x30\x53\xb9\x62\x89\x14\xda\xa8\x32\x31\x58\xba\x6e\xac\xe4\x2d\x13\xc1\xfb\x30\x10\xa6\xe0\x06\x56\xb9\xe3\xc0\xf5\x99\x24\xc9\x8c\x8a\x69\x54\xfa\x25\xa7\x29\xc0\xfe\xdb\x20\x57\xf9\xf5\x58\x08\xd0\x89\x15\x65\xb8\x01\x50\x8c\x2d\xc3\x0a\x56\xdd\x3f\x0b\xe2\x15\xf7\x5e\x65\x76\xb5\x4b\xe2\xd9\x16\xda\xd5\x89\x7e\x91\x8e\x36\xc2\x3e\x48\x09\x7b\x76\x23\xcb\x99\xa1\x29\x35\x74\x07\x57\xb2\xf7\x55\xbd\x3a\x5f\xb2\x1e\x6b\x86\x86\x7b\x4e\xc7\xed\xbc\x80\x27\x0b\x1e\x87\x4b\xc1\x49\x9c\x79\xc8\x43\xfc\xb5\xb1\x38\xe5\xee\x1d\xd0\x43\x0c\xc4\x27\x5f\x10\xcc\x0e\xef\x47\x43\x72\x51\x55\x3b\xac\xc8\x49\xbb\x5b\xad\x8e\x06\x5d\x0b\xfa\x1d\x60\x74\x53\x5d\xbd\x25\x75\x77\xb1\x95\x82\x0e\x72\x09\x26\x0c\x57\x2c\x8e\x4e\x73\xa0\x2b\x05\x22\x79\x03\x88\x00\xe5\x29\x33\xba\x72\x78\x41\x3a\x6c\x89\x8b\xe3\x77\x4e\xfd\x05\x22\xed\x00\xeb\x34\xc8\xd5\x12\x17\x82\x5d\x4b\x47\x67\x2d\xe5\x7f\x10\xb8\xee\x62\xc3\xc6\x0c\xfd\xef\x65\xda\xc5\xec\xdd\x48\x6c\x5f\x0d\x51\x79\x81\xa2\x3f\xaf\x06\x33\x02\x7e\x03\x2e\xbf\x74\x2d\xc6\x0e\x89\xdc\x8c\xce\x77\xb7\x79\x55\x92\x58\x3f\x24\x05\x86\xcf\xf5\xe1\x73\xfd\xd7\xed\x6d\x83\x5d\x1c\x4a\xfc\xd3\xda\xb1\xa4\xfe\x91\x4e\x86\x58\x4b\x52\x46\x1d\xad\xa7\xcd\x8c\xe5\x81\xda\xbb\xeb\xc8\x70\x05\xec\x42\x26\x18\xb7\x74\xe2\x94\xfc\xa2\xc6\xdf\x9d\x1c\x15\xb4\x32\xf4\xf4\x3d\xf2\x6a\xda\xc0\x6d\x82\x0f\x48\xaf\x37\x3f\x6e\x0c\x06\x82\xc5\x6a\x8d\xc5\x7b\x14\x07\x61\xcf\x0a\x66\x0a\xec\x72\x3e\x90\xc1\x22\x96\x92\x59\xc6\x14\x2c\xc1\xa9\x69\x8d\xeb\x78\xc8\x25\x8a\xc6\xe1\x5e\x50\x87\x83\x74\x29\xd8\x5d\x10\x23\xa8\xc6\xac\x2d\xfe\xea\x8c\xb9\x2a\x74\x6b\xc7\x0b\x5e\xcf\x67\x62\x81\x53\xbf\x08\xdb\xb2\x4e\x38\xef\xc5\x15\xdd\x60\x2e\x34\xbb\xa3\x0b\x0d\x18\x5f\x69\x0b\xe1\xfb\x2e\x43\x5a\x35\xf0\x47\x36\xc1\xde\xad\xaf\xd6\x76\xba\x5c\xdb\xe5\x7a\x0d\xe2\x2e\xb9\x68\xe3\xcb\x54\x75\xd8\x58\x85\xa3\xf9\xec\x72\x1f\x07\x0e\x2f\x70\x0f\xdf\xed\x72\xa5\x9e\xf2\xf4\x7a\x08\x43\x78\x69\x7c\x0a\x7f\x78\x5e\x13\x6e\x1f\xc6\xcc\x62\x75\x15\x51\x0d\x18\x12\xf7\x5d\xe1\x92\x50\xa1\xd6\xb7\x90\x16\xd5\x19\xa0\x43\xd9\x2e\xc5\xc0\xa5\x04\xbe\x38\x80\xb4\xff\x54\x2c\x1c\x0f\x37\x33\xae\xd2\x7e\x41\x95\x59\xa0\x7a\xda\xab\x7d\x2d\xb8\xe7\x77\x5a\xf8\x8e\xf7\x42\xed\x32\x0e\xaf\x85\x30\x2c\xde\x97\xde\x73\x86\xff\xb5\x70\x7d\x8c\xf5\xb4\x0f\x00\x58\xb9\x9e\xab\x28\x1e\xde\xeb\x82\x4f\xb6\x9e\x34\x26\x1f\xbb\x72\x8c\xc6\xad\x2d\x12\xfe\xb8\xf2\x93\x8c\x1d\xa8\x03\x47\x07\xe5\xc7\x4e\xa0\x67\x75\x4e\x5a\x95\xea\x8e\xcc\x86\x4e\x2a\xf0\xee\x37\xae\x50\x90\x58\x38\x63\x50\xfc\xad\x78\x80\x70\x2e\xc8\x91\x90\x02\xcf\x0a\xb6\x3d\x46\xef\xa3\x35\xd6\x2e\x68\xe2\x2a\xbc\xd5\x0b\x6c\x46\x67\xd3\xb3\x05\x2e\x52\xbb\x59\x40\xab\x41\x1f\xd2\x65\x92\x30\x16\x34\xe8\xb8\xde\x4b\x75\x96\xdd\x94\x7d\xa5\x48\x2d\x21\x95\x8b\x36\x34\xcb\x2a\xcd\xd5\x81\x4b\x02\x67\xf3\xc6\xc5\x88\xe1\xd5\x42\x73\x9c\x12\x0f\x35\xc8\xd1\x63\xa6\x14\x09\xde\xfe\x73\xb3\xf0\x33\x88\x39\x10\x74\x03\x95\x41\xa3\x42\xcb\x27\x68\xc9\x8a\x44\xff\x00\x4c\x20\x46\xae\x02\x7a\x9d\x17\xb9\xb4\x0d\x96\xf2\x8c\x69\x72\x7b\x47\x55\x0a\x95\x70\x0b\x6a\x38\x26\xe2\xee\xd5\x86\x3d\x8a\xe6\x00\x75\xe8\x63\xe4\x3b\x0e\x0a\x06\x94\xd7\x90\x8d\xcf\x10\x5a\x1a\x99\x53\xc3\x13\x50\x5b\xf9\x24\xb2\x4b\xe6\x21\x6f\x61\xa3\x6a\x1f\xd0\xd5\x50\xff\xfd\x06\xef\x7a\x14\x23\xe6\x4e\x12\x9e\x5b\x99\x80\x42\x01\x8a\x49\x88\x31\xf2\x46\xd4\x4d\x33\xb5\x82\xcf\x77\x60\xc2\x8e\x5a\xa1\x42\x6c\xd5\x25\x0d\xc3\x07\x1b\x69\x30\x0e\xba\x20\x9d\x5e\x83\x65\x13\xdf\xcb\x62\xb5\x9d\x6d\x84\xac\x3d\xbb\x41\x77\xcc\xca\x02\x7a\x23\xca\xea\xc1\xaa\x39\x61\x51\x58\x4d\x52\xae\x1b\x95\x9d\x8f\x52\x25\x8b\xc2\x99\x43\xf2\xe3\xe5\x39\xc1\xcd\x84\x9a\x33\x1d\x95\x2f\x46\x4b\xf8\x94\x89\x50\x7f\xdb\x65\xbb\x80\xd3\xdb\xfc\x08\x78\x76\x91\x28\xf9\xd9\xd1\x59\x56\xcc\xe8\x31\xf9\xe4\x0a\xf5\x04\xfc\x0d\x7e\x7b\xad\x24\x26\x34\xb0\x78\x8b\xe6\x8b\xa8\xd3\xf2\x79\x11\x75\x5e\x44\x9d\x7f\x6f\x51\x27\x38\x8c\xed\x2a\xe6\x7c\x0c\x5e\x92\x8d\xb2\xde\xde\xe3\xa0\x72\xa3\x7c\x78\xbb\x45\xf8\xd6\x03\x53\xc0\xdd\xa8\x0d\xba\x4e\xdc\x03\x73\x0e\xdf\xa1\xf3\x45\x55\xe1\xd9\x44\xfe\x20\x95\x2f\x8a\x95\x36\x4a\xc3\x22\xd0\x3b\x26\xd4\x19\xd6\xb5\xd8\xd2\x13\xac\x2a\xd2\x0f\xc3\xf6\x2b\xf7\x8f\x16\xa9\xc5\xe3\x67\x27\xa8\x93\x7b\x84\x51\xc6\xcf\x33\xf6\x00\x69\x2c\xb6\xbb\x8f\x23\xb9\xa7\x9f\x23\xb9\x8f\xaf\x23\xd9\xa7\xbf\x23\x09\x5e\xd3\xf7\x39\x31\x1f\xbd\xbf\x76\xe3\xcc\x38\xe2\xb4\xe9\xcc\xd4\xa2\xf5\xc3\x38\x5c\xfb\x8a\x75\xee\xb6\x2f\x9c\x01\xb0\x97\xc5\x5e\xb7\xee\xb4\x82\xe2\x83\x57\x7a\xec\x4b\xc8\x8d\x1b\xf1\xfa\xaa\x7c\xb3\x91\x70\xfd\x9f\x17\x98\x66\x07\x4e\x5d\xdf\xf9\x46\x79\xc5\xe2\xe5\x04\xbf\x9c\xe0\xb6\xfd\x9f\xf2\x04\xa3\x5f\x71\x17\xb7\xf7\xba\x5c\x8d\x97\x78\xe4\x87\x92\xa9\x05\x91\x73\x16\xf9\xd3\x40\x12\x60\xcd\x53\xe7\x91\xe2\x6c\x0e\xed\x65\xd9\x47\xe4\xf9\x60\xd1\xb8\xfc\x62\x25\x23\x88\x10\xbb\x07\x2d\x6b\x0e\x55\x0f\x02\x46\x68\x79\xa0\x7b\xe2\x65\xa9\x88\x1e\xb8\xec\x60\xd5\x1b\xd0\xf7\xcf\xae\x2e\x76\x53\x00\xba\xdd\xef\x90\x5d\xee\x78\x96\x16\x7f\xb6\x61\x81\x08\x88\xf0\x4b\xbd\xfe\x51\xd0\xd2\xc9\x2d\x5b\xf4\xdc\x95\xb0\xcb\x6b\xee\x1b\xa3\x67\x43\x3d\x19\x67\xdb\x24\x10\xab\x00\xb4\x03\x55\xdc\x4d\xab\xc6\xa7\x7d\xfa\xc6\x7a\x2f\x0f\x84\xae\xc4\x77\x67\xb2\xdd\x29\xcd\x63\xfc\xd4\x50\xc1\xa5\x26\x05\xc7\x39\xc0\x09\x48\x69\xe7\x9d\x8a\x03\x1a\x80\x23\x35\x50\x8b\xae\x9b\x48\x76\x57\x0d\xf1\xf1\x80\xbd\xf7\x52\x03\x9a\xd6\xbc\x62\x6f\xd9\xe2\x50\xbb\x78\x3c\x29\xf4\x8c\x17\x3e\x8b\x3a\x50\x02\x87\xb9\xe4\x33\x5c\x95\xfb\x21\xf0\xcc\x0f\x45\x8f\x5c\x49\x63\xff\x77\x09\x5e\x33\x68\xc8\x93\x4c\x5f\x49\x03\x6f\x1e\x1d\x58\x38\xdd\x7b\x83\xca\xd9\xf0\x38\x58\xe0\xd0\xbb\x0b\x62\x21\xbc\x37\x06\x80\xc4\x5d\x40\x06\xb0\x72\x4d\x86\x82\x48\xe5\x61\x62\x7c\xda\x5d\xed\x86\xf0\x36\x97\xc8\x60\xba\x62\x0c\x07\x4a\xa9\x6a\x90\xdc\x30\x5c\xb0\xbd\x72\xff\x0b\xd8\x64\xc0\x58\x1d\x5c\x48\x20\x79\x2c\x35\x6c\xca\x13\x92\x33\x35\x85\xc8\xcb\x64\xb6\xfb\x06\x75\xa7\xdb\xf8\xec\x44\xbd\xe3\x0f\x77\xc6\x0c\x60\x75\xef\xc0\x89\xe7\xbe\x0c\x13\x47\x41\x16\x91\xd3\xc2\x22\xc5\x3f\x2c\x27\x80\x7d\xf9\x17\x24\x7b\xd6\x03\x72\xe6\x2b\x70\xc6\xbf\x39\x43\x5b\x3c\x8c\x1d\xc1\xca\xf1\x3f\x94\x7c\x4e\x33\x86\xae\x6d\x54\x84\xbc\x98\x72\xb2\xc4\xa6\x7b\x2e\xe3\xb3\xa5\x52\xe1\xe2\xe4\xe0\x96\x2d\x0e\x7a\x4b\x88\x74\x30\x14\x07\x55\xf8\x73\x0d\x75\x02\x43\x03\x9b\xfa\x01\xfc\x76\xb0\x6f\xce\xfe\x44\xe2\xfc\x0e\x58\xe2\x8c\x40\xe7\x19\xd5\xba\x5b\xe4\xe8\xfa\xfc\x63\xa3\x68\xcc\x2a\x82\xc7\x39\x2c\x26\xe8\x10\xb5\x3f\x5b\x15\xf8\xd1\x77\x77\xae\xe9\x04\xa5\xb9\x2b\x1f\xd2\x3e\xf5\x41\x93\xaa\x86\x01\x42\xa0\xc4\x5d\x1c\x6b\x56\xdd\x49\xae\x81\xd7\x67\xb8\xf5\x90\x93\x38\x5f\x22\xd7\xa0\xe2\x72\x1f\x3a\x21\xa4\x21\x5c\x24\x59\x99\x62\x9e\x47\xe8\x0a\x0a\x72\x57\x91\x7e\x07\xe0\xdc\x03\x79\x3e\x87\x01\xbc\x3c\xe2\x6f\x3f\x97\x7c\x56\x9b\xd7\x54\x70\x35\x18\x6e\x7c\x10\x56\xfb\x5e\xeb\x64\x8b\x87\x60\x3d\x9d\xe5\x79\x5d\xc6\x78\xcb\xc7\x8a\x91\xf3\x19\x15\x82\x65\x51\xbc\xa8\x33\x64\x84\x12\x4e\x20\x78\xb8\xc2\x4d\x87\xf5\xca\x4d\x9e\x8e\x89\x10\x9d\xbc\xf7\xea\xb5\x3f\xee\x42\x4a\x7b\xab\x84\xed\xb2\x1a\xce\xe4\x1d\x49\x25\xb9\x83\x5c\xfe\x73\xcb\x8e\xe0\x26\x52\x7b\x46\x16\xcd\x14\x7c\x03\x12\x99\x17\x4a\xe6\x5c\x7b\x0f\x70\xb7\x71\x7b\x0d\xb0\xcc\xca\x16\x79\x73\xd6\x25\x5c\x79\x7b\x4e\x0c\x55\x53\x66\xec\x30\x44\x94\xf9\x98\xb5\x0e\xff\x7c\x88\x84\x5d\xcf\xbd\x42\xd4\x7e\x8b\x3c\x21\xe8\xbf\xfb\xee\xaa\x73\x29\xd8\x55\x3b\x78\x27\x55\x96\xde\xf1\x14\x2f\xbd\x34\x39\xb2\x03\x1f\x3f\xff\xba\xad\x77\x77\x3c\xbd\x1f\x00\xbc\x67\x8f\x05\x00\x01\x08\xb8\xca\x45\x1c\x72\x4a\xc3\x07\x8e\xc9\x25\xc7\xd8\x18\xfb\x17\x66\x6d\xc9\xc7\x5c\x54\x51\x58\x61\x33\x80\xae\xda\xf3\xe0\xb5\x09\xcd\x0c\x46\x35\x40\x60\x80\x34\x33\xa2\x79\x5e\x66\x86\x0a\x26\x4b\x9d\x2d\x5a\xa3\xc5\xd3\x00\x79\x92\xb1\x2f\x88\xc5\x5d\xf8\x55\xe8\x54\xe7\x5b\x53\x8c\xfd\xf2\x30\x5f\x62\x5c\x95\xbb\x50\x7a\x12\x98\x58\x08\x96\x61\x5f\x58\xe2\x3c\x5b\x8b\xac\x9c\xf2\x2d\xce\xfb\xff\x66\x29\xbe\xab\x24\xca\xa5\x66\x55\x64\x7b\xdb\x22\x26\x4f\x97\x91\xfb\x41\x99\xf5\xcd\xea\xb4\xdb\x29\x2b\x98\x48\x21\x23\x58\x84\xab\x38\xdd\xbd\xc2\xca\x65\xd7\xda\x9d\x42\x5d\x7e\x31\x8a\x5a\x72\x93\x43\x50\xa5\x4b\xd6\xc5\x27\x84\x8a\xf6\xa4\xe3\x79\x64\xc1\x25\xff\x76\x3c\xfa\xc1\x8b\x24\xdf\x2f\xf7\x3a\x52\x51\x87\xf6\xba\xee\xb0\xba\x22\x47\xba\xfb\x4a\xec\x59\x7a\xdf\x5c\xe9\x7a\x45\x7a\xe8\xc6\xac\x5e\x8a\x47\xfe\x28\x12\xa7\x4f\x20\x26\xb5\x4b\x3a\xa1\xb7\xd8\xa3\xa1\xd9\xba\x97\xcd\x62\xc4\x1b\x34\x59\x87\xb7\x11\x49\x87\xdc\x9d\x6e\x20\x17\x57\x43\xb4\x85\x65\xe5\xc2\x55\x0a\xb1\x8d\x58\x3d\x44\x3e\x6c\x6a\xa8\x66\xa6\x9d\x55\x63\xd9\x2d\xcd\x73\x7a\x1c\x05\x13\xb0\x83\x43\xb4\x0f\xcc\x24\xfd\xdf\x39\x99\x40\xd4\x5a\x5a\x69\xc0\x03\xc4\x67\x1c\x62\xe1\x9a\x16\xc7\x48\xed\x36\x24\xd4\xb4\xae\x16\xd3\x8a\xde\xbb\x19\x7c\xfa\xd4\xb9\xa4\xa8\xed\xd2\x58\xf1\x20\xe4\x1b\x28\x05\xff\xa1\x8c\x25\x75\xc8\xcd\x10\xd6\xe8\xda\xef\x6b\x21\xd3\x84\x55\x26\xa2\x0b\xae\x6f\xbb\x24\xcd\xfa\xe6\xfc\xb2\xde\xb9\x8e\xf0\xdf\x9c\x5f\x12\xf7\xb6\x95\x15\xa7\x8b\x19\xe7\xbe\x39\x9d\xa6\x09\xab\x4c\xa3\x29\xd7\xb7\x8f\x5e\xb0\xbb\x48\xaf\xb6\xf9\x19\x3f\xb6\x95\xc9\xe7\x15\x89\x92\xdf\x2c\x64\x49\xee\x5c\x24\xbd\x13\x6a\x6f\x78\x71\x4a\x2e\x85\x2e\x15\xab\x6e\x3f\x9b\xf2\xad\xe5\xa4\xcf\xa9\xb0\xf7\xbd\x70\xe3\x39\x9b\xb9\x0a\xaa\x0c\x48\xb6\x9d\xf3\x88\x41\xaa\x7c\xd7\xd9\x2f\x61\xcb\xd6\x0f\x27\xde\x07\xad\xe7\xa2\x84\x43\xb2\x2d\xdf\xc8\x6e\x76\x94\x18\x23\xde\xde\xb7\x21\x35\x0d\x39\x49\xd9\xfc\x44\xa7\xf4\x75\x0f\x3e\xe3\x43\x59\x4d\x6d\x4e\x54\x93\x83\xd7\x07\x03\x32\xe2\x39\xcf\xa8\xca\x16\xb5\xdc\xc0\x55\x3b\xcb\x02\xfc\x80\x70\x99\xf5\xea\x80\x1c\x49\x05\x23\x27\x54\x90\x8c\xf9\x38\x19\x77\xa0\x16\x28\x02\x1e\x3f\x36\x15\x21\x0f\x6a\x23\x44\x82\xd2\x15\x0d\x3e\x21\xbb\xa9\xa5\x41\xb9\xa8\x28\x36\x17\x96\x8c\x0f\xc8\xa7\x55\xa5\xaf\xe1\x6c\xf8\x16\x4f\x05\xca\x07\xd5\xcd\xee\x59\x37\x7f\x49\xa1\x7b\x3a\x30\x6d\xd7\xea\xa6\xdc\x7c\x64\x85\xec\x24\x00\x60\x97\x86\x25\x8c\x1b\xfb\x42\x6a\x0e\xf9\x32\xa9\x81\xea\xb3\xca\xf0\xa4\xcc\xa8\x95\x89\xd1\x0e\x36\x20\x17\x97\xd7\x1f\x2f\xcf\xcf\x6e\x2e\x2f\x4e\x89\x1f\x89\xc7\xd2\xda\x80\xdc\xc4\x59\x84\x22\x97\x57\x97\xaa\x25\x7c\xab\xe7\x88\x0f\x15\x55\x1a\x42\xc8\x0d\x41\x05\x19\x0a\x6e\xaa\x2c\xbd\xe8\xa4\x95\x49\xe1\xdc\xae\x6c\x6f\x67\x87\x9b\x72\x74\x9d\x10\x6e\x30\xfb\x73\x7d\x34\x38\x1d\x98\xf1\x33\x4c\x65\x8b\x16\xf7\x00\x92\x43\x05\xdc\x7d\xc9\xee\x3e\x31\x67\xc7\xe3\x71\x83\x06\xf6\x2a\x37\x2a\x52\xfc\x90\x0e\xdc\x67\x45\x59\x51\x28\x99\x58\x5e\x72\x38\x38\xf4\x82\x42\xb6\x94\xfa\x3d\x0c\x1a\x27\x7e\xaa\xe3\xd6\x80\x90\x0f\xde\x85\x19\xa2\x56\x57\x67\x91\xc7\x54\x02\x51\x2e\xf2\x06\x86\xfa\xd2\x00\xe5\x38\xfe\xa8\xcb\x14\x35\xe5\x73\x26\x70\x61\xfb\x25\x48\xfe\xf3\x1d\x61\xfe\xb1\x9a\xf7\xa7\x8f\xef\xf6\x3b\x25\x3c\x67\x1d\x27\x74\x2e\xf3\x1c\xf3\x07\xcd\x42\xf4\x59\x15\x40\x16\x4e\xfb\xde\x14\x16\xcc\x84\x34\xd9\x82\xd4\x0d\x3a\xe5\x3b\x35\x14\x94\xf0\xda\x79\xe3\x8b\x4a\x4e\xed\x9e\xe6\xd7\x25\xdd\xd2\x3e\xa5\x86\x23\xd9\x27\x61\xc6\x27\x1f\x2f\xcf\x2e\xde\x5f\x0e\xf2\xf4\xd1\x49\x06\x13\x69\x21\xb9\x30\x7a\xbb\x5a\xb2\xad\xa8\x49\x7b\xb2\x12\x3e\xda\x95\xeb\x5e\xfa\x8e\xb1\x8b\x83\x1f\x2d\xca\x55\x96\x32\x43\x79\xa6\xa3\x7d\x34\xb2\x90\x99\x9c\xae\xce\xf9\xdb\x61\x83\x7e\x86\x99\x47\xfa\xb4\x6f\x77\x7e\xbf\xf2\x7a\x9b\x52\x0d\x75\x78\xf8\xd2\x0c\x90\x63\x30\xac\x35\xc8\xc1\x50\x51\xe1\x99\x2e\xf7\x41\x04\xaf\x25\x18\xa0\x36\x08\x87\xd8\xa7\x71\xab\xf2\xa2\x45\x65\x52\xda\x4a\x64\x0f\x0d\xba\xed\xc2\x98\xa5\x41\xdb\x6b\xe1\xd4\x61\xf6\x07\xd7\xa7\x4e\xe4\x0a\xc5\xfa\x21\x91\x0f\x54\xef\x90\x2a\xe2\xae\x31\xcd\xf3\x86\x17\x6f\xa6\xc1\x56\xd9\xa2\x69\x80\xa9\x64\x9f\x60\xb5\xc2\x38\xf4\x2c\x5b\x54\xa9\x01\x9d\x2a\x4c\xa7\x98\xa0\x47\x39\xfb\x6d\xa1\xf8\x9c\x67\x6c\x0a\x49\x40\xb9\x98\x46\xb5\x14\x7d\xc4\x3a\x24\x87\x67\x4b\xf3\xb2\x5b\xa5\x4d\x9c\xfa\x19\xf0\xe2\xea\xc3\x0d\x24\x96\x85\x4b\xc1\x7b\x0b\xd8\xf6\x83\x50\x68\xa4\xdf\xef\x83\xde\x7f\xf4\xbd\x95\x15\xd3\xec\x98\x7c\xc7\xdc\x77\x24\x24\xbf\x55\x50\x6d\x66\x26\x43\xf6\x51\x98\x6b\x05\x59\x40\x47\xbc\x34\x77\xad\x4e\x6c\x4b\x2b\x18\x21\xbb\xa9\xb5\x87\xe2\x9a\x98\xce\x0f\xef\x7b\x1e\x5f\xae\xdc\x23\xe9\xdf\x99\xca\x79\xab\xe8\x2a\xfc\x0c\x37\x32\x85\xa3\x87\x94\xe8\x45\x9e\x71\x71\x5b\x65\x8c\x9a\x48\x8b\x43\xe8\xa3\xcf\xc5\xad\xc7\x58\xc5\x68\xb6\x9e\x52\xee\x82\x1f\x7b\xa5\x92\x66\x07\xe3\xdd\xcd\xa2\xc0\xbb\xf0\x70\xec\xdd\x55\x6f\x4c\xe2\x0e\x0e\x9e\xdd\x7a\xb9\xee\x56\x69\xfd\x70\x38\x3a\x1f\xd5\xaa\x84\x5a\x9d\x0e\xde\x3d\xa6\x71\x79\x1d\x4b\x80\xe5\x3c\xa1\x64\xc7\x7f\xd8\x76\x53\xdb\x27\x59\xb9\xbd\x0d\xba\xf9\x5c\x4b\x65\x68\xb6\x27\x22\x90\xcc\x68\x71\x56\x9a\xd9\x05\xd7\x89\x9c\xb3\xce\xaa\xce\xdd\x0c\xb3\xf6\xfa\x84\x71\xdc\x6f\x3a\x8e\x46\xce\xff\x70\x76\x4d\x68\x69\x77\xd1\xb8\xb4\x92\x7b\xbd\xe2\xf6\xf3\x1f\xa1\x43\xfd\x5e\x66\xef\xc6\x7a\xf0\xb9\xbf\x5c\x08\xec\xf1\x42\x00\xce\xf8\x73\xbe\x04\xe0\x82\x1b\x4e\x8d\x6c\x59\xcb\xaa\xae\xbf\x97\xda\xc8\xdc\xa1\xe7\xd0\x0f\x04\xb7\xb2\xc0\x70\x6b\x63\xd7\x73\xf4\x83\xa0\x0d\xc0\x19\x0a\x2b\x16\xd3\x84\x35\x3c\x00\x7b\x90\xb9\x11\xc7\xe6\xa1\xcd\x6f\x9d\x67\x26\xa4\x7c\xca\x7e\x77\x5a\xcb\xa4\xbd\x54\x08\xc1\x1b\x15\xaa\xe4\xfa\x7b\xb5\xc4\xf0\x1f\xba\x9e\x6c\x67\xf6\xc2\x55\xfd\x6f\x49\x33\x84\xc6\xd5\xbe\x6d\x44\x75\xc8\x76\x9c\xa4\xdf\x4f\x0f\xf3\xab\xa0\x35\x97\x1a\xb3\x45\x61\x0b\xa3\xa8\xd0\x76\x23\xea\xba\xd1\xa1\xbb\xda\x39\x24\x47\x26\x29\x5a\x97\x6b\x7f\x20\xcf\x6c\x9c\xaa\x83\xfb\xbb\xe0\x91\xdd\x76\x56\x0f\x72\xdb\x02\xb8\xdb\xd5\xb4\x51\x5b\x08\x32\x5b\xf2\x8e\x6b\xe3\xd3\xe2\xc3\x0b\xae\x5d\x4e\x57\x90\x74\xae\xad\xea\xc4\x8b\xbf\xd2\x34\x55\xa7\xc8\x49\x7c\x49\x5d\x05\xf2\x8e\xcf\xbb\x44\x45\xb8\x8f\x3b\x32\x8b\xc2\xa5\x66\xbb\x39\xbf\x26\x58\x15\xe3\x37\xbf\xc2\x72\x9e\xff\xf9\xcb\x5f\xbd\x6a\xbd\xa1\x4f\xe7\xfe\xbc\xa3\xe5\x60\xef\x37\x36\xcf\xc2\x6b\x0e\xc4\x05\xf4\x97\x03\x7a\xe8\xce\x2e\xe2\x91\xdd\xd4\x40\xa5\x77\x13\x2a\x5e\x3c\xcc\x9e\xd4\xc3\x8c\x84\xa0\x07\xa4\x09\xf7\xa7\x2a\x48\x50\xae\x9f\x1f\x41\xd9\x0a\x8b\xed\x58\x53\xc7\x16\x3c\xbf\x56\xbf\x8b\x6e\x9f\xc0\xe7\xfa\xe2\x6a\xf4\xd7\x77\x67\x6f\x2e\xdf\xc1\x2c\x9d\x5f\x95\x45\x03\x2e\x76\xf6\x23\x6a\x8f\x56\x6d\x34\xc1\xed\xc0\xe8\x76\xcf\x71\xf5\x76\xd4\x50\x94\xed\x9b\x8e\x97\x1b\xf7\x95\x96\xc5\xa4\xd5\xda\x1f\xd7\x74\x05\x65\x23\x98\xda\x5f\x88\xc3\xce\x16\xae\x28\x25\x53\x4d\x19\xb2\x3b\x85\x33\xbc\xb7\xbe\xb2\x75\x07\xc8\x33\x30\xe2\xdb\xf5\x22\x0c\xf6\x6e\xbe\x7f\x20\x58\xb5\x65\xf1\xaa\x7b\xec\xcb\xe1\x08\x7a\xf9\x4b\x1e\x7b\x48\xd1\x23\x47\x59\x7a\x6d\x29\x35\xd3\x21\xc9\xfd\x33\xc5\x94\x62\x55\x46\xdc\x2e\xd4\x6b\x65\x4a\xdd\x5a\x3d\xa8\xda\xc5\x46\x2d\x62\x60\x5d\x0e\x69\x7f\xb7\x4f\x9d\x7a\xa9\x0b\x9a\xec\x35\xf3\x63\xf5\x0a\xdf\x40\x48\xf5\xe3\x13\x40\xf8\xec\x1e\x1d\x4a\xc3\x78\x5d\x11\xf9\xdc\x77\x6c\x06\x72\x75\xda\x21\x5f\x4f\xa1\x90\x3e\x48\x2e\x8e\xf8\x7a\xe2\xed\x23\x8f\x42\x3d\xbf\xdb\x51\x75\xd9\xb7\xda\x52\xcc\xa4\x91\x62\x67\x27\xf1\xeb\x15\xdd\xeb\xe7\x18\x5b\x9c\x57\x45\x42\xa2\x0a\x7d\xe0\x61\x18\x0c\xfa\x56\x8c\xf3\x5c\x42\x0a\x6f\xda\xaf\x1b\xf6\x1f\x5d\xf2\x48\x87\x17\x7b\x3a\x73\x3f\xa6\xe0\xc3\xae\x26\xd8\xbd\xba\x50\xa4\x9d\x23\x2e\x86\x17\x4e\xee\xf2\x51\x15\xda\xa1\x1d\x59\x8f\x77\x7b\xe3\x8b\x52\x99\x3b\xa9\xba\x87\x1a\x5f\xd7\x3a\x36\x6e\xf5\xdd\x6f\x4b\xd1\x44\xcf\xf1\x8c\xe0\x1c\x9f\xf8\x9c\x8c\xe0\xc2\xb4\x91\x2b\xba\x79\x32\x82\x17\xfb\x03\x1c\x9e\xa7\x3d\x34\x3b\x72\xa1\x87\x0d\x49\xdd\xab\xe0\xed\xb1\xac\xe3\x0a\x3f\xbb\x6e\xce\x40\x60\xf7\xa6\x22\x12\x34\x1c\x42\x37\xfc\xde\x88\x82\x92\x58\xb7\xaf\x03\x3d\x18\x1a\x96\x63\x81\x5f\x9a\x65\x16\x96\x52\xc4\x69\x83\x5d\xd8\x69\x8f\x60\xe6\xdd\x9c\x16\xbe\x5a\xb2\xbc\x13\x77\x54\xa5\xe4\xec\x7a\xb8\x9f\xa3\xdf\xc1\xb5\x18\xf1\xa7\x5d\x26\xa8\x7a\x59\x45\x99\x32\x32\xe6\x46\x57\x05\xcf\x98\x89\xb5\x41\x4b\xde\xc2\x1d\x91\x3d\xa4\xf6\x40\xba\xef\x45\xdc\x4f\x10\x99\x18\x9a\x35\x0a\xd0\xbf\x7a\xf5\x0a\x8d\x57\xaf\x7e\xfd\xeb\x5f\x63\x11\x9a\x94\x25\x3c\x5f\x6e\x08\xad\xfe\xeb\xf5\xeb\x01\xf9\xe3\xd9\xfb\x77\x50\x10\xaf\x30\x1a\xd3\x5d\xe0\xc8\x58\x92\x3b\xea\xac\x7b\xe4\x7f\x46\x1f\xae\xaa\x52\x1a\xf5\x5f\x5d\x35\x63\xb7\xbc\x01\xb9\x88\x5c\x80\x62\xf3\x14\x35\x33\x57\xfb\xc5\x10\x3a\x99\x60\x99\xc7\xb1\xaf\x32\x8a\x47\xca\x47\x36\x43\x49\x66\xac\xd1\x60\xb7\x3f\x03\xdf\x24\xab\x48\xa3\x31\xcf\x07\xd7\xa3\xab\x15\x8c\x15\xe8\x1f\x4c\xa5\x87\x45\xbd\x27\x1a\x2a\x35\x54\xa9\xe0\x14\xd3\x56\xa6\x74\xa5\xe7\x70\xb0\x30\x75\x3b\x89\xa7\xbc\x83\x69\x5d\x41\xa0\x86\x58\x3e\x71\x6d\x55\x1d\xfc\x7b\xbc\x56\xdc\xe6\x1c\xfb\x40\x77\x22\x75\x9e\x1f\x66\x83\x7b\xe5\x42\xd6\x03\xb9\x20\x34\x93\x50\xe5\x28\x6c\x6d\xc5\x8f\xa2\x2a\xe3\xdb\x97\xd2\x39\xf3\x5e\xd7\xec\xab\x48\x85\xde\xd3\xd6\x35\x4e\xea\x26\xed\x28\xb4\x9f\x8e\x65\x69\xfc\x15\x30\x8e\x89\xe5\xfd\xb0\xc6\x74\x87\xcc\x81\x3b\x24\x1b\xdc\x25\xe9\x6c\xe7\xbc\x95\x75\x32\x5f\x13\x02\x7a\x84\xd1\x64\x46\x6e\xd9\xa2\x8f\x84\xa9\xa0\x10\x8d\x12\xaa\x48\xb9\xdc\x8e\xf5\xfb\x92\x84\xa5\x56\xb2\x75\xc0\xf2\x37\xea\x15\x16\x85\x68\x16\x2f\x3e\x6a\x27\xe9\xb8\x9c\x91\x22\x52\xe0\x7d\x62\xe2\xa8\x0e\x6b\x48\x12\x89\x45\x98\xeb\x51\x17\xf6\x7c\xb1\xd4\x76\xd3\x9b\xbe\x5c\xb9\x11\x58\x42\xe7\x58\x55\x29\x96\x7a\xbb\xa2\xc3\x4e\x6c\x83\x0f\x52\x9f\x8a\x37\x72\x45\x80\xd2\x66\xae\x9c\x8d\x6b\xeb\xa1\x14\x00\x51\x8b\x0a\xd1\xcc\x94\x0e\x34\x58\x37\xa9\x14\x19\xd3\x9a\x70\x58\x61\x4e\xd5\x2d\xf3\x49\x49\x68\x36\x20\xd7\x76\x92\x21\xf3\x11\xe6\xc0\x9d\xa3\x1b\x99\x3d\xa3\x71\xb8\x8b\xfd\xc8\xe1\x60\x70\x88\x14\x7c\x45\xf0\x4b\x07\xcc\xd8\x2d\x81\xea\x0e\x89\x53\x1b\x25\x8d\x0b\x8d\x69\x60\xad\xd4\x06\x69\x8e\x25\x44\x71\x99\x99\xe7\x50\xb4\x75\xfa\x9d\xe5\xe5\xec\x90\xed\x73\xd7\x24\xd5\xbb\xa4\xa8\x6e\x75\x9d\x50\x7f\x76\x4f\x4d\xbd\x53\x62\xea\xa5\xda\xca\x6e\x8b\xdc\x31\xeb\x9e\xa9\xf7\x1e\x89\x94\xf3\x4e\x49\x3e\xfd\xb3\x2e\x27\x4c\xde\x46\xea\x73\xd5\xca\x32\xf6\xa3\x12\xf3\x86\x93\x55\xb5\xb6\x7c\xb8\x5b\x25\x27\x07\xa2\x69\x21\xf0\xf4\xf2\x5d\xb7\xea\x1c\xa4\xb3\xc0\xd7\x7c\xba\x08\x80\xcd\xa7\xdd\xa5\x5c\xf3\x59\x3a\x4d\x81\xba\x17\x91\x4b\x3a\x80\xd2\x48\xc8\xc4\x6c\xc2\x91\x1b\x40\xf9\x77\xc7\xa3\xa8\x95\x55\xb4\xcc\x4a\x13\xc2\x72\x56\xb0\x06\x18\xd4\xe7\x6d\xc6\x60\x48\xdf\x2c\x62\x14\xc0\x22\x91\xfe\x76\xe5\x19\xf8\xec\x74\xa4\xbb\x56\x18\xfb\xc9\x3a\x6e\xdc\x03\x86\x5e\x66\xd8\x19\x8e\x23\x97\x0d\xc1\x7b\x10\xd7\x64\x18\x70\xde\x30\x1a\x05\x24\x2f\x8e\xb8\x4a\x3d\x9d\x57\xd6\xce\xb0\xe2\xa6\xe8\xac\x08\x67\xd7\xc3\x3d\x4a\xf4\xd1\xa8\x3f\x69\x99\x1e\x4c\x37\xb5\xba\x29\x17\xd5\xca\x9d\x81\xd7\x52\x98\x67\x2f\x1a\x2e\x4d\xfb\xad\xa5\x8b\x91\x59\xb5\x91\x94\xcd\x95\x70\x0f\x14\x34\x4a\xe4\xe6\x2f\xf8\xe0\xbc\x3e\x77\x31\xf2\x11\x45\x42\x80\x47\xa7\x02\xd0\xfe\x59\x2e\x41\x06\x8b\x25\x23\xa8\x4d\x82\x3a\x5e\xa4\x2c\x16\x32\x3d\x75\xa5\x72\x85\x90\x58\xf5\x4b\xf7\xb0\xb8\x89\xee\xa1\x12\x68\x05\x85\xe8\x5a\x56\x45\x06\xf0\x9d\x45\x83\x9d\xca\xd4\xdc\xa7\x50\x8d\xdd\x40\x58\xf9\x75\xd7\x5d\x24\xf7\xac\x3b\x43\x22\x2e\xb4\x5b\x25\x8b\xba\xb1\x1a\x47\x0a\x75\xac\x93\x19\xcb\x29\x26\x85\xf3\xcb\xb3\x54\xe6\x4e\x71\x63\x18\x66\xf5\x61\x2a\xd7\x44\x4e\x7a\xb5\x0a\x71\x07\xf3\xd7\x07\xbb\xd4\xf3\xb8\x67\xc9\x15\x52\xed\xc2\x1e\x80\x71\x5d\x93\xce\x2c\x5e\x83\xba\x90\x41\x26\x47\xd1\x30\x32\x58\x06\x33\x47\xe8\x3d\xfa\xc2\x9f\x52\x45\xea\x05\x21\xe1\x45\x45\x7a\x51\x91\xf6\xa2\x22\x45\x8c\xc5\x13\x1c\x07\xa8\x58\x6d\x8a\x33\x4a\x79\xdd\xa9\x8a\xea\x89\xb2\xc4\x58\xd4\xf4\x5a\x93\x54\x75\x2b\x9a\x55\x7d\x0e\xbd\x2e\xe5\xf0\xb8\x34\x93\xfe\x6f\x08\x13\x89\x4c\x71\xf3\xed\xf8\x4a\x1b\x10\x6d\x2a\xf5\x23\x9e\x4b\xee\xbf\x15\x5b\xe2\x60\xec\x5d\xb7\x6e\x27\x3a\xe0\xef\xea\xde\xee\x89\xc1\x57\x6c\x3d\x04\xc1\xba\xe5\x87\x18\x79\xc7\xdf\xab\x5b\x42\xac\x05\x0c\xc8\xed\xcb\x9c\x92\x23\x7c\x39\x48\x8a\xb2\xe7\x1a\x0c\x72\x96\x4b\xb5\xe8\x85\x46\xf6\xc7\x5a\x2f\xd7\xe2\x18\x64\x82\xa4\x54\x56\xd9\xcb\x16\x3f\x56\xe9\xc0\x03\xe8\x91\x85\x83\xb0\x4f\xdd\xaa\xc1\xc4\x4f\xc3\xfd\x2e\x24\xba\x02\x55\xbe\xaa\x8e\x33\x09\xc9\xf7\x74\x2f\xa8\xa8\xf0\x96\x89\x39\x99\x53\xd5\xa1\x74\x75\xfc\xdc\x53\x1e\x48\xf9\x9c\xeb\xdd\x0a\xd6\xad\xd4\x9a\xb9\x4b\xeb\x25\x4b\x53\x94\xc6\x51\x4a\x7f\x2a\x7c\xa8\x77\x38\x0d\x0d\xa1\xe8\xf5\xc1\x4e\xd3\xf8\xd1\x14\x85\xc5\x67\xc7\xd2\xb0\xf8\xdc\xb7\x40\x6c\x7d\x94\x9d\xd1\x66\xaf\xe5\x9e\xfd\xe3\xd1\x62\x1f\xe7\xb0\x62\x91\x55\x7e\x02\x2f\x9c\x3e\xd2\x41\x43\x7f\x90\x3d\xda\x6a\x5c\x22\xf4\x9f\xb2\x99\x66\x4f\x57\xaf\x2e\x52\xef\xdf\xfc\xde\x75\xe4\x72\xe2\xbf\x5c\xba\xb6\x42\xbe\x97\x4b\xd7\x97\x4b\xd7\xb6\xcf\xcb\xa5\xeb\x8b\x45\xa1\xfe\xfc\xa8\x2d\x0a\x2f\x97\xae\x2f\x97\xae\xf7\x83\xe1\x83\x5c\xba\x3a\x31\xae\xba\x71\x7d\xd4\x0b\x57\x57\xd6\xe5\x2c\x49\x64\x29\xcc\x8d\xbc\x65\xad\x6f\x10\x5a\x09\xf3\x4b\xa3\x3f\x9e\x64\xdf\x5d\xb0\xe8\x24\x1e\xec\x22\x18\xd0\x32\xe5\x56\x78\xdf\x19\x81\xce\xdc\x00\x5e\x4e\xb7\xa4\x58\xa4\x2c\x0d\x23\xfb\x43\x6a\x2c\xac\x07\xe4\x8c\x28\x96\xf0\x82\xbb\xea\xdd\x14\xdf\x23\x86\x85\x2c\xfb\xdc\x68\x96\x4d\x5c\xb6\x73\x11\x17\x85\xa9\x44\x70\x47\xe1\x56\x7e\x06\x79\x8e\xf4\x49\xb2\x7d\x85\x1c\xc5\xbe\xf7\xcc\xca\xcd\xe6\x26\x1e\x21\x36\x8a\xc0\x52\x6a\xb5\x68\xe0\x63\x05\x77\x11\xc8\x0f\x7d\xb0\xd9\x97\x82\x2b\x40\xde\x11\x4b\xa4\x68\x53\x11\x73\xcd\x06\x5d\x36\x47\xf2\x3b\xe5\x2c\x9a\x58\x00\x3f\xd4\xbd\x9c\xd3\x8c\xa7\xdc\x2c\xc2\x5d\x9b\xab\xb2\x44\xf1\xc4\x84\x6d\xd4\x15\x18\x09\x2d\x0a\x25\x69\x32\x63\x3a\x9a\x37\x8a\x1c\x2e\x10\x2b\x78\x9d\x63\x25\x30\x90\x3a\xa0\x8f\x65\x7d\xd9\x82\x28\x69\xfc\x75\xf9\x9a\x0f\xde\x44\x83\x41\x77\xe4\x5f\x46\x2d\xe0\x4e\x5d\xc6\x43\xe0\xac\xf8\x24\xfe\x43\x13\x99\xa5\x3e\xbf\xc7\x6f\x5e\x59\x31\x2f\x71\x38\x68\xa9\x1c\x64\x80\x30\x92\x64\x96\x15\x5b\xca\xb7\xbe\xf3\x2f\xbf\x26\x33\x59\x2a\x3d\x88\x83\x84\x5e\xc3\x3b\x54\xd1\xbc\x98\x68\x48\xc6\xa8\x36\xe4\xf5\x2b\x92\x73\x51\x5a\x0e\xd4\x19\x6d\xba\x4b\x36\x91\x4c\xf3\xab\xaf\x5b\xf7\xeb\x2a\xcd\x2c\xdf\x48\x3a\xac\x2a\x30\x13\xaf\x13\x6a\xdc\x49\xc2\xe0\x32\xcc\x63\xdd\x10\x71\x1c\xd1\x8d\xa1\x2d\x8c\x7c\x80\xf3\xf5\x43\x29\xc7\x0b\xd3\x25\x10\xf1\x7f\xb1\x47\x3d\x02\xd1\xbf\x6c\x93\x5d\xa4\x4a\x2e\xb2\xf1\xa3\x0f\x52\x2b\x61\xca\xb5\xd9\x52\x29\xa1\x8a\x51\xdc\xd8\xac\x3d\x5b\x99\x5a\x79\xbf\x63\x58\x0a\xe8\x08\x5e\xd6\xf5\xe6\xa1\x24\x61\x58\xd3\xf0\xa2\xaa\xb4\x23\x24\x8e\xbf\x75\xf8\x27\x4e\xb6\xe5\x11\x64\x0f\x39\xba\x5b\x2e\xb5\x9d\x74\xe5\x51\xa2\xf3\x5a\xb1\x5b\xfd\x14\x68\x2e\xa6\x98\x52\x3b\x2f\x33\xc3\x8b\xac\x5a\x77\xe8\xe0\x08\x79\x6c\x36\xa3\x91\xa5\x87\x62\x70\x2e\xa6\x62\x02\x13\xe3\x51\x18\x8b\x09\x83\x99\xa1\x95\xe5\x07\x05\x55\x34\x00\x0f\xea\xa6\xea\x63\x67\x81\xa3\x70\x0f\x88\x94\xc7\x92\x73\x45\xb3\xb0\xd0\xf8\xee\x67\x9f\x48\x63\x98\xa0\xa2\x85\x81\xb9\xae\xea\x41\x27\x22\xef\x82\x0b\x18\x56\xd8\x68\x60\x8b\x13\x6a\xde\xd0\xe4\x96\x89\x14\xcb\x0f\xc1\xb2\xd3\x85\xa0\xb9\x4b\x45\x15\xd5\x54\x6e\xf4\xd7\x3d\x67\x6a\xc0\x48\x39\x1f\xaa\x8b\x5c\x77\x9f\x30\x28\x75\xe7\x5c\x2f\x9f\x34\xd6\x32\xde\x74\xce\x35\x1a\x61\x14\x9f\x27\xcc\xf3\x7f\xfb\xa9\x7d\x4e\x7d\xde\x22\x1e\x7d\x69\xf2\xce\x55\x91\x47\xf8\x0b\xe4\x3e\x18\xbf\x21\xeb\x14\xcd\xec\xd1\x5e\x84\xf0\xcc\xc6\xe6\x8e\x17\xfb\x2d\xa8\xa2\xc6\x5d\xc2\x68\x0f\x3f\xbe\xb9\xa8\x1f\xe2\x8f\x34\x95\x9a\xbc\xc9\x64\x72\x4b\x2e\x18\x08\x5d\x0f\x59\x10\x44\x8d\xd3\xa7\x4c\x18\x9d\xd3\xe9\xb6\xdb\xb1\x3e\xc9\xa5\xe0\x46\xaa\xcd\xf4\xe2\xa5\x3e\xe1\x93\xa4\x23\x56\xe3\xf4\x59\x27\x23\xb6\x08\xb6\x4b\x35\x42\x05\xc7\x10\xba\xfb\x5c\x7e\x3b\x1e\xaa\x9f\xcd\xe4\x5d\xdf\xc8\x7e\xa9\x59\x9f\xb7\xb8\x6f\xed\xb0\xba\x5b\xb6\x80\x4b\xe6\x8e\xeb\xfb\x16\xbb\xd5\x94\x03\x23\xc1\xa6\x04\xef\x2d\x8b\xfe\xf8\xe6\xc2\xf2\x86\x41\x2c\xec\x9d\x30\x93\x9c\x24\xac\x98\x9d\xb8\x0f\x3f\x4b\xa0\x78\x6a\xd1\x15\x2a\x67\x24\x91\x59\xe6\xe2\x9d\xe5\x84\x9c\xb3\x62\x16\x06\x7b\xec\x95\x3e\x5d\xaa\xdb\x42\xca\xae\x29\x3f\xa3\x03\x63\x7b\xbb\xf3\x12\x21\x8e\x1a\x77\xab\x63\xf0\x58\xa8\xf2\xac\x2b\x31\x3e\x20\x70\x1e\xb8\xaa\x7e\xad\x96\x7e\xec\x7a\x59\x4f\x07\xec\x7d\x38\x6a\xe4\x66\x38\x41\x49\x3a\x65\x29\x91\x73\xa6\x14\x4f\x99\x26\x81\xde\xc4\xaa\x27\xcf\x1e\x1b\x6e\x2f\x99\x89\x9f\x3c\x33\xf1\x0e\x3a\x4e\x44\x9e\x6c\xef\x65\xf2\x44\xd3\x9c\x8b\x67\x47\xa0\x74\x42\x33\x36\xfc\xd0\x41\x99\x18\x61\x8f\xba\x3e\xe1\x5f\x46\x09\xc5\xb6\xa4\xe9\xfa\x36\xe0\x0b\x11\x32\xdd\x66\x1f\x7d\x00\xad\x60\x4a\x0d\xbb\xdb\xca\xfe\xfa\x15\x81\xda\xde\x12\xe4\xce\xa7\xd4\x1f\x9e\x28\x35\x5e\x84\xe5\x98\xf7\x6b\x9f\xec\xd3\xed\x53\x57\xa3\x8b\x5f\x48\x23\x93\xac\x47\xd4\xb3\xeb\x21\xf9\x06\x47\xde\x6f\xa6\x3e\x25\x0d\x4a\x77\x17\x32\xa7\xbc\x73\xa1\x8d\x59\xbd\x30\xb5\x9f\xee\x75\x18\x96\xe0\xb8\x71\x8d\x90\x09\x9f\x96\x56\x03\x73\x5a\xd3\x4b\x12\xb5\x47\x11\x40\x2a\xf9\x23\xb2\x04\x79\x8f\xc3\x4a\xe6\xf0\x3b\x08\x4c\x21\x5c\x4d\x12\xcd\x84\xe6\x70\x4f\x12\x5d\x56\xbb\x72\x6f\x58\x5f\x10\xdd\x0b\x51\x48\xe9\x91\x77\x72\xca\x85\x3f\x95\xd2\x5d\xa3\x4d\x28\xcf\xda\x02\xe3\x45\xaa\x78\x72\xa9\x42\xeb\xec\x52\xd0\x71\xd6\xc6\x0b\xa0\x4e\xd6\x33\x0a\xf7\x9c\x0c\x7a\x9f\xa4\x5c\xdb\xff\x93\xd1\xe8\x1d\xd8\xc4\x4b\xe1\x65\x5d\xb0\x17\x3b\xb2\x16\x3c\xfd\xf1\x00\xee\xf7\xcc\x20\xa5\xd9\x21\xc7\xdd\x50\xa4\x76\xb2\x4c\xd7\xdc\x4e\xdc\x78\x98\xe9\x2f\x78\xce\xe2\xcd\xfd\x98\x91\x9b\x19\x4f\x6e\xaf\x23\xd3\xb7\x54\xf6\x9d\x88\x5e\xd5\x98\x50\xf3\xb7\x7d\x12\x44\x37\xd5\xeb\xee\x0a\xec\x4d\x44\xcf\x47\x6e\xc1\x76\x18\x42\xb5\x96\x09\xaf\xee\x39\xc0\x5c\x52\x11\xfc\x14\x08\xfe\x7e\x17\x01\x3c\xfd\x9e\xbc\xc9\x6f\x9a\xaf\x7a\xaa\x63\x5e\xc4\x85\x5f\xeb\x5e\x27\x8e\xa8\xb1\x43\x96\xee\x9b\x5a\x5e\x6e\x2f\x9b\x36\x8c\xf6\xde\x8b\xdb\x6d\x92\x97\x92\x7c\x95\xc5\xa5\x6d\x0a\xf9\xb9\x5d\x5e\xbe\xbd\x2d\xb5\x4d\x20\xc3\x2a\x6d\xb8\x71\x53\x87\xef\x9c\x19\x1f\x0e\x53\x21\x8b\x32\x43\x5f\x89\xfb\x27\x17\xf7\xd6\x59\xfc\xce\x9e\xcc\xfa\x8f\x91\x68\xb3\xab\x23\xf0\x4f\x23\xe7\x66\x24\x92\xbd\xfa\xd5\xd7\x5f\xff\xd8\xb3\x70\xb6\x55\x81\x1f\x22\x0d\x67\x4b\x93\xe8\x4b\xa4\xcd\x4b\xa4\x4d\x8c\x8a\x0f\x99\x46\x75\xcf\xb1\x34\x1d\x5d\x5c\xbb\xb9\xb7\xb6\x8f\x96\x69\xed\x04\xdb\xd5\x01\xb6\x43\x3c\xcc\x9e\xa2\x60\x3a\xfb\x82\x76\x89\x78\x79\x89\x73\xf9\xa9\xc5\xb9\xec\xe2\x03\xda\x3d\xa6\xa5\x8b\xef\xe7\x4f\x29\x7e\xa5\xc3\x61\x6c\x1f\x67\xd1\x3d\xba\xa2\x7b\x3e\xbb\xee\x96\xad\x5d\x4a\x1a\xc5\xf6\x19\xa7\x45\x54\x15\x04\x7d\xe1\x41\xcc\x8f\x65\xa4\x3d\x58\x8f\xa2\x43\x90\x0e\x0a\x14\x0e\x2f\xbb\xd4\x12\x74\x3a\xf9\x87\x51\xe3\x6a\x23\xbc\x7e\x9a\x1b\x8d\x9f\xe6\x95\xc1\x4b\x61\x90\xe7\x6d\xd3\xd6\xb5\xdc\x22\xde\x92\x00\x67\x1d\x18\xb1\x1c\xc7\x39\x0d\xab\x33\x72\x76\x3d\xb4\xea\x32\x84\xcf\xd0\x4c\x0f\xc8\x0a\x3e\xed\xed\x92\x8e\xaf\x7b\xfe\x4c\x8d\x61\x79\x61\xda\x6f\xf6\x8b\x49\xfb\xc9\x4d\xda\x3b\xdb\xe3\x3e\x87\x8e\xa1\x02\x64\x99\x53\xd1\xb7\x27\x0a\x8c\xdb\xb5\x5b\xb0\x06\x09\x1e\x10\xef\x95\x8b\xb0\xa0\x8a\x61\xd2\xa7\x7a\xc5\x5b\x1a\xd5\x3f\x7c\x18\x23\x24\x8c\xbd\xf3\xca\x91\x81\x36\x4e\x5a\x22\x97\xdc\x3e\xdd\x72\x02\x14\xfc\xa1\x8a\xb8\x70\x4d\x6f\x36\x33\x86\xcc\xfa\x1a\x02\x51\xaa\x56\x75\x49\x18\x45\x61\x9a\x65\xf2\x0e\xbf\x1d\x33\x30\x0b\x7d\x3b\x17\x17\x61\x35\x66\x24\xe7\x56\xa9\x76\xc6\xcf\x78\x3a\x78\x15\x69\x25\x6a\xa6\x50\x60\x55\xee\x36\x6b\xc4\x4c\xbc\xd1\x56\x21\x15\xe8\x08\x6d\xff\xed\x1d\x6f\x30\x2b\xae\xa3\x09\x63\x36\xa3\x73\x2e\x4b\x85\xbd\x8d\x24\x07\xee\x27\x60\x09\x0b\x59\x06\xd3\x14\x56\x49\x0c\xab\xd3\x2b\xe0\x74\x55\xfd\x08\xa2\x7c\x2a\xbd\x2d\xa1\xcf\xbe\x70\x6d\x96\xd7\xe2\x41\xe4\x93\xb6\xed\x0b\x6f\xe6\xba\xb0\x6c\xa1\x73\x45\xb4\xcf\x71\xbf\xba\x60\x32\x1f\xc1\x4f\x3f\xa2\x7a\x68\x5b\x73\x91\xbe\xc8\x3a\xfb\x96\x75\xc2\x75\x55\xc6\x93\x45\xe7\x4a\x61\xd5\x35\x95\xed\x4e\xde\x50\xcd\x52\xf2\x9e\x0a\x3a\x45\xb5\xec\x68\x74\xfd\xe6\xfd\xb1\xdd\x36\x50\xfb\x86\x17\x2b\xef\xb2\x46\xf1\x1c\xae\xf6\x19\x06\xb1\xb4\xc2\x1d\x38\x51\xc7\x35\xee\x35\x8c\x83\x04\x6e\xd2\x2e\x41\xec\x72\xe8\x65\xb3\xc6\x63\x83\x28\xcc\xf3\xf4\x9e\x55\x1d\xb9\xd0\x86\x66\xd9\x75\x46\xc5\x59\x51\x28\x39\x5f\xad\x09\xd7\x03\xc3\x5d\x43\xcf\xda\xd1\xf7\xc1\xbf\x2c\x10\xd0\x70\xd7\x2b\xc8\xb0\x1a\x7f\x40\x86\x26\x28\xc4\x52\x00\x1b\x3c\x38\x2b\x8d\xcc\xa9\xe1\xc9\x81\xd5\x9b\x0f\xde\x53\x51\xd2\x6c\xa5\x87\xd1\xc6\x65\xac\x13\xeb\x36\x76\x5a\x9f\x1c\xad\x45\xb7\x8d\xf2\xc1\xe6\xfe\x86\x2a\x4b\x5b\xce\x47\x9f\x3b\xf5\xd5\x86\x9a\x72\x89\x72\x6e\xa0\xe6\xeb\xe9\x77\x9f\x64\x54\x9b\x4f\x45\x6a\x4f\x72\xe3\xd7\x4d\x44\x3a\xa1\x86\x66\x72\xfa\x07\x46\xb3\xd5\xf8\x5c\xc3\x93\xf3\xb8\xb5\x37\xfe\x20\xca\x8c\xca\x71\x68\x78\xa8\x89\x15\x8a\x7d\xbc\xb6\x62\x19\x9b\x53\x61\x7c\x77\xac\x94\xad\x0f\xdd\xfa\x01\x8b\x78\x65\xf0\x4c\x99\x61\x2a\xe7\xa2\x3e\xe6\x08\xda\x9e\x4b\x91\x72\x34\xf5\x81\x31\x0b\x7b\xd4\xc7\x5d\x8f\x6a\xeb\xcc\xf9\x1b\x0c\xf8\x75\xca\x13\xcd\xa7\x0e\x0a\x6c\x36\x76\x32\xe1\x0c\x5f\xc2\xcd\x75\x6d\x6e\x4b\x90\x22\xb7\xc2\x0a\x73\x90\xf3\x62\x35\x91\xda\xca\xdb\xb7\xf1\xf4\xbe\xdf\x63\x9c\xc2\x7a\xbf\xc8\xbe\x9b\xf7\x3a\x43\xff\x26\x14\xc3\x67\xbb\x34\xd0\x9c\xca\x7a\x0a\xba\x0a\xef\x42\x37\x0c\xee\x6b\x54\x57\xaf\x35\x5a\x4f\xf1\x5b\x09\x4b\xed\xe4\x9a\xb6\x79\xd3\xeb\xb4\xb6\xca\xf2\xbd\xa4\x7e\xb6\x90\xf2\xb6\xb2\xa8\x96\xe9\xcb\xeb\xca\xf0\xd0\x39\xc5\x29\xa7\x3e\x50\x52\x70\x86\x89\x3a\xa8\x70\xc0\x02\xce\xc2\x68\xea\x5e\x5a\x0e\x66\xd5\x38\xf8\xad\xe7\xee\x9a\xd1\xb0\xeb\x7c\x17\xbc\x71\x98\x62\xa2\x0a\xb8\x2c\x38\xf9\x46\xba\x8b\x52\x17\x50\x6a\x69\x00\xf0\xed\x1e\xd1\x65\x32\x23\x54\xdb\xa9\x59\x84\xb6\x27\x9e\x0d\x72\x2a\xf8\x84\x69\x33\x08\x79\x68\xf5\x9f\x7e\xf9\x97\x01\x79\x2b\x15\x71\x7e\xd8\x3d\x9f\x01\xc2\xcd\xb3\xc2\x0b\xae\x71\x31\xa1\x6f\xa5\x69\x16\x32\x75\x93\xbe\x83\xc9\x1a\x7a\x6b\x79\x18\x4e\xb6\x64\x70\x5d\x70\x4a\x0e\xac\x90\x17\x7d\xfa\x1f\x96\x2d\xfd\xeb\x80\x1c\xdd\x01\xd3\x3e\xb0\x7f\x1e\xe0\x07\x83\x2f\x61\xac\x08\x57\x1f\xc6\x30\x3f\xc5\xa7\x53\xa6\x50\xe5\x23\x10\x0e\x77\xec\x32\x58\x08\x19\x35\xf6\x37\xbf\x95\x8a\xd8\x9c\xc8\x9f\x7e\xf9\x97\x03\x72\x54\x5f\x17\xe1\x22\x65\x5f\xc8\x2f\xd1\xf4\xcb\xb5\x5d\xe3\xb1\xbb\x40\xd1\x0b\x61\xe8\x17\x3b\x66\x32\x93\x9a\x09\x54\xbf\x8d\x24\x33\x3a\x67\x44\x4b\xab\xb5\xb2\x2c\xeb\x3b\xb3\x36\xb9\xa3\x90\x55\xc4\x83\x12\x82\xc0\x49\x41\x95\xa9\xa1\xc4\xc0\x59\x35\xe0\x6b\x76\xdb\xa6\xc2\x5f\xff\x4e\xb8\x70\x77\x46\xee\xb6\xca\xee\x39\x84\x34\xe2\x26\x19\x49\x92\x19\x15\xd3\x10\x47\x3d\x29\x4d\xa9\xd8\x96\xeb\x96\x96\x67\xe0\x96\x8b\x4e\xe1\xb6\xdf\x72\xd1\xbc\xb9\x5f\x6d\x0b\x9a\x72\xe3\x9d\xfe\x9d\x23\x9f\x59\x9c\xd8\x5d\x50\x7c\x5c\x1a\xa9\xf4\x49\xca\xe6\x2c\x3b\xd1\x7c\xda\xa7\x2a\x99\x71\xc3\x12\xbb\xac\x13\x5a\xf0\x7e\x22\x85\xdd\x71\xc8\x20\x90\xa7\x3f\x83\x22\x98\x7d\x3b\xd5\x2d\x79\x8d\x5b\x2e\x7a\xbb\x21\xec\x49\x0d\x60\x7b\x5b\x63\x0b\x1b\xce\xf2\x42\xd1\x9e\xf2\x08\xab\x05\xe3\xc5\xc9\x5e\x16\xeb\xd3\xf2\x76\xe7\x31\x87\x2e\xd3\x74\xd2\x1c\xc3\x1e\x3b\xf4\xd2\x80\x53\x59\xa3\x94\x39\x4d\x91\x94\x52\xb1\x78\x70\xe4\xb7\x20\x85\x84\xec\xc9\xa2\x9f\x60\x7d\xfb\x3e\x15\xa9\xfd\x37\xc6\xa3\x24\x8b\xbd\xc0\xb0\xe4\x9d\x08\xc1\xa7\xe1\xc5\xe3\x1c\x89\x92\xef\xe1\xd4\x3b\x79\xad\xa5\x10\x85\xa2\x2a\xb8\xec\x18\x55\x32\xcf\x34\xeb\x02\x2a\xd7\x7e\xd4\xff\x76\x77\x26\x21\x33\xd7\x36\x91\x6a\xf3\x4d\x47\x24\x3b\xb6\x9c\xef\xbb\xaa\x47\xb3\x26\xbe\x1d\xcc\xa5\x81\xf2\xd1\xf3\xb5\x65\x78\x05\x05\x18\xcc\xfa\x3b\xda\x56\x38\xe4\xef\xe8\xed\x44\xfa\x2b\xf3\x03\x25\x41\x29\xd9\xae\x40\x55\xfa\x4b\xad\xd2\x16\x2e\xca\x30\x6d\x08\x9d\x53\x9e\x81\x45\x5d\x8e\x35\x53\x73\x2c\x79\xe4\xd2\xe2\xd1\xa6\x9e\xe5\xaa\x1a\xa0\x18\xf5\x48\x9a\x8f\x5f\xc3\xf2\xae\x6c\x5a\x00\x68\x43\x8d\xd9\xaf\x9d\xf5\x5e\xf4\x1e\x54\x2f\xd7\xfe\x6c\xbf\xb0\xa3\x1a\x63\xf1\xef\x0f\x8c\x2a\x33\x66\xd4\xdc\xf0\x4d\x7c\x77\x09\xa5\x6b\xfd\xbc\xc1\xa5\x42\xe8\x3b\x46\xa6\xd2\x58\x11\xab\x04\xdc\x47\x99\x14\x13\xd0\x04\x44\x7b\x68\x8c\xae\x56\x79\xa3\x28\xc4\xbd\x48\xd1\x71\x99\xf5\x8e\xcb\xeb\x74\xd2\xb1\xc3\x24\x83\xad\x31\x05\x84\x14\xcc\xed\x1d\xde\x40\x00\x05\x7a\x9c\x25\xe7\x4c\xeb\x8d\xa9\x21\xea\x2e\x7c\xd8\x1a\x8f\x72\xe3\x3a\x2c\xf7\xbf\x61\xfc\x84\x15\xa0\x53\x66\x28\xcf\xfc\x51\x46\x50\x04\x28\x6d\xa3\xae\x1b\x17\xa8\x18\xd5\x9b\x04\x84\x66\x46\x2c\x2d\x05\x4e\x5a\x0a\xd6\xbf\x93\x2a\x25\xe7\x34\x67\xd9\x39\xd5\xcc\x8d\x15\x87\xab\xe1\x1e\x1d\xea\xbd\x4e\x79\xb5\xed\x6b\xcd\x94\xd1\xf8\xe3\x91\xc8\xe1\x46\xa5\x62\xe1\x04\x7b\xde\x04\x79\xa3\x4a\xd6\x23\x6f\x2d\xf7\xea\x91\x4f\xe2\x56\xc8\xbb\xfb\xcd\xd5\x6c\xbc\xb9\xa8\xbb\x59\xb9\xcc\x2d\x90\x22\xcf\x25\x84\xa9\x19\x7c\xc2\x74\x77\x9c\x91\x23\xf8\x6b\x4c\x8d\x75\x66\x13\x9a\xfa\x19\xd9\x7f\x2e\x99\xa0\xac\xa2\xa8\xe4\x54\x31\x8d\x39\x57\x56\x26\xf4\x6b\x6b\x72\xfe\x86\x09\x17\xf1\xb6\x75\x7a\xc3\x55\xbd\xfc\x4c\x3d\x5f\x9b\x56\xbf\xb8\xfd\x76\x1f\x2b\xb2\x95\xa2\xc6\x66\x2f\xbc\x68\xa2\x6b\x8c\x4f\xeb\x66\xb8\xda\xe8\x14\x71\xbd\xa8\x2d\x0a\x25\x9b\xac\xa3\x7e\x75\xe7\xa3\xcf\xeb\x81\xbd\x96\xf7\x6d\xe3\x4f\xdb\xcd\x52\xf7\x35\x48\x6d\x3d\x33\x5b\x8d\x50\x2f\xe6\xa7\x17\xf3\xd3\x8f\xc9\xfc\xb4\x15\xe3\x37\x99\x9c\x7e\x1c\xc6\xa6\xad\x4b\xdc\x64\x60\x7a\x96\xa6\xa5\x56\x2b\xda\x68\x4e\x7a\xb6\x86\xa4\xad\x4b\x6b\x69\x3c\xfa\xf7\x31\x1b\x6d\x85\xd8\x06\x53\xd1\x33\x34\x12\xb5\x11\xc8\x58\xda\x46\x4c\x1c\x46\x8d\x63\x41\xb1\x2a\x98\x18\x86\xf3\x2e\x35\xb1\x38\xb3\xab\xb4\x68\x05\xb8\xad\x73\x3b\x74\x93\x6b\x2f\x7b\x39\x81\xd1\x95\x13\x5c\x9a\x2c\xb9\xb8\xbc\xfe\x78\x79\x7e\x76\x73\x79\xd1\x94\xef\x56\x41\x7a\x8b\x24\xb6\xd9\x06\xd1\x8f\x24\xb1\x35\x0d\x2c\x41\x5e\xf3\x93\xc5\x81\x35\x3f\x95\x25\x5f\xd5\xeb\xfe\x72\xe1\xbd\xb8\xdc\xbd\xf8\xc7\xf6\xd3\xd9\xf6\x78\xda\xd3\x09\xd8\x82\x1e\x63\x56\xee\x99\xc9\x2c\xd5\xde\xd7\x74\x78\x11\xa2\x97\xb8\x48\xb2\x32\xb5\xc2\xc5\xa7\x4f\xc3\x0b\x3d\x20\xe4\x0d\x4b\x68\xa9\xc1\x0a\x93\x4a\x71\x68\xc8\x87\xab\x77\x7f\x04\x1f\x6a\x68\xd1\x0b\xc9\x3e\x20\x83\x2c\xa7\x98\x04\xd7\x60\x16\x32\xf2\x86\xa1\xa0\x02\x5f\x4e\x68\x61\xa9\x98\xc6\x2a\x0b\x06\x64\x91\x19\xcb\x0a\x4b\x31\x6f\x19\xa9\x72\x7f\xda\x81\xab\x1a\xe6\xde\xe5\x71\xca\x0c\x46\x3a\x6d\xf2\x6a\xdc\x08\xb5\x2d\x16\xd7\x7b\xd8\x5a\x6b\xea\xa3\xd3\xc6\xef\xa8\x76\x16\xab\x95\xb3\xdd\xb2\xbf\xdb\xed\x33\xeb\x4d\x1c\x6b\x8c\x1b\x48\x9e\xe1\xaf\xa5\x39\xdb\xc9\x56\x76\x0c\x74\x22\xe1\xa6\xb5\x35\x75\xbd\x1b\xd0\xea\x9c\xf5\x4b\xb6\x0c\xd6\x04\x72\xed\xc3\xc1\x8b\x3a\x9a\x72\xbb\xb9\x40\xc1\x8b\xb4\x56\x5d\xd2\x79\xdb\xd5\xdf\x95\xe3\x50\x5f\xb4\x9a\xaf\xb3\xc8\x90\x7f\xfc\xeb\xab\xff\x1f\x00\x00\xff\xff\x19\x53\xdb\x44\x5f\xac\x01\x00") +var _operatorsCoreosCom_subscriptionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x7d\x6b\x73\xe3\xb8\x95\xe8\xf7\xf9\x15\x28\x27\x55\xb6\xb3\x92\xdc\x9d\x9d\x4d\x72\xbd\xa9\xa4\xdc\xb6\x3b\xd1\x4e\xb7\xdb\xdb\x72\xf7\x54\x6e\x92\x9b\x40\x24\x24\x61\x4c\x02\x1c\x00\x94\x5b\x79\xfc\xf7\x5b\x38\x07\x00\x41\xea\x45\xca\xf2\x63\x66\xcc\x0f\x33\x6d\x0a\x00\x81\x83\x83\xf3\xc2\x79\xd0\x82\x7f\x66\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x62\x98\xb0\x7f\xe9\xc1\xed\x6f\xf4\x80\xcb\x93\xf9\xeb\xaf\x6e\xb9\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x32\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x57\x39\x33\x34\xa5\x86\x9e\x7e\x45\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\xaa\x3f\x65\x62\x70\x5b\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xf8\xcd\xe0\xd5\x57\x84\x24\x8a\x41\xf7\x1b\x9e\x33\x6d\x68\x5e\x9c\x12\x51\x66\xd9\x57\x84\x08\x9a\xb3\x53\xa2\xcb\xb1\x4e\x14\x2f\xe0\x13\x03\x59\x30\x45\x8d\x54\x7a\x90\x48\xc5\xa4\xfd\x5f\xfe\x95\x2e\x58\x62\x3f\x3e\x55\xb2\x2c\x4e\xc9\xca\x36\x38\x9c\x9f\x23\x35\x6c\x2a\x15\xf7\x7f\x13\xd2\x27\x32\xcb\xe1\xdf\xb8\xf6\x51\xf4\x55\x78\x9d\x71\x6d\xbe\x59\xfa\xe9\x1d\xd7\x06\x7e\x2e\xb2\x52\xd1\xac\x31\x5b\xf8\x45\xcf\xa4\x32\x57\xd5\xb7\xed\xb7\x74\x39\x8e\xff\xed\x1a\x72\x31\x2d\x33\xaa\xea\x83\x7c\x45\x88\x4e\x64\xc1\x4e\x09\x8c\x51\xd0\x84\xa5\x5f\x11\xe2\xe0\xe8\xc6\xec\x13\x9a\xa6\xb0\x37\x34\xbb\x56\x5c\x18\xa6\xce\x65\x56\xe6\x22\x7c\xd3\xb6\x49\x59\x18\xf5\x94\xdc\xcc\x18\x29\x68\x72\x4b\xa7\xcc\x7f\x6f\xcc\x52\x62\x64\xe8\x40\xc8\x77\x5a\x8a\x6b\x6a\x66\xa7\x64\x60\x41\x3c\xb0\x10\x8c\x7e\xc6\xfd\xb9\xc6\x41\xa2\xf7\x66\x61\xa7\xab\x8d\xe2\x62\xba\xe9\xf3\x09\x35\x34\x93\x53\x82\xf8\x45\x26\x52\x11\x33\x63\xc4\x7e\x8a\x4f\x38\x4b\xfd\xfc\x36\xcc\x08\xbb\x2e\xcd\x69\xd4\x7c\xdd\x7a\x4a\x33\x2a\x04\xcb\x88\x9c\x90\xb2\x48\xa9\x61\x9a\x18\x59\xc1\x67\x33\x78\x5c\xe7\xa5\xd9\x9c\x2f\xbd\x5f\x31\x1d\x6c\x3a\x7f\x4d\xb3\x62\x46\x5f\xbb\x97\x3a\x99\xb1\x9c\x56\x7b\x28\x0b\x26\xce\xae\x87\x9f\xff\x73\xd4\xf8\x81\xd4\x97\x12\xa3\x28\xb9\x65\xac\xd0\xd5\xa1\x20\x65\x61\xd7\x64\x17\x47\xc6\x0b\x62\x14\x4d\x6e\xb9\x98\xc2\xd2\xa7\xb8\xde\x73\xdc\x18\x3d\x58\x9a\xb2\x1c\x7f\xc7\x12\x13\xbd\x56\xec\xfb\x92\x2b\x96\xc6\x53\xb1\x90\xf5\x24\xa2\xf1\xda\xc2\x29\x7a\x55\x28\x3b\x2d\x13\x9d\x43\x7c\x22\x1a\x55\x7b\xdf\x58\xe6\xa1\x85\x05\xb6\x23\xa9\x25\x4f\x76\xfa\x33\xe6\x0f\x07\x4b\x1d\x00\xed\x76\x9a\x19\xd7\x44\xb1\x42\x31\xcd\x04\x12\x2c\xfb\x9a\x0a\xb7\xa6\x01\x19\x31\x65\x3b\xda\x03\x5b\x66\xa9\xa5\x63\x73\xa6\x0c\x51\x2c\x91\x53\xc1\xff\x11\x46\x03\x10\xd9\xcf\x64\x16\x3f\x0c\x81\xe3\x26\x68\x46\xe6\x34\x2b\x59\x8f\x50\x91\x92\x9c\x2e\x88\x62\x76\x5c\x52\x8a\x68\x04\x68\xa2\x07\xe4\xbd\x54\x8c\x70\x31\x91\xa7\x64\x66\x4c\xa1\x4f\x4f\x4e\xa6\xdc\x78\x0a\x9c\xc8\x3c\x2f\x05\x37\x8b\x13\x20\xa6\x7c\x5c\xda\x8d\x3b\x49\xd9\x9c\x65\x27\x9a\x4f\xfb\x54\x25\x33\x6e\x58\x62\x4a\xc5\x4e\x68\xc1\xfb\x30\x59\x81\x24\x32\x4f\x7f\xa6\x1c\xcd\xd6\x87\x0d\xf0\xad\x3c\x07\xc4\x53\xbd\x8d\xb0\xb6\xc4\x8f\x70\x4d\xa8\xeb\x8e\x6b\xa9\x40\x6a\x5f\x59\xa8\x7c\xbc\x1c\xdd\x10\x3f\x01\x04\x3b\x42\xb8\x6a\xaa\x2b\x60\x5b\x40\x71\x31\x61\x0a\x5b\x4e\x94\xcc\x61\x14\x26\xd2\x42\x72\x61\xe0\x8f\x24\xe3\x4c\x18\x7b\x0c\x73\x6e\x34\xe0\x1c\xd3\xc6\xee\xc3\x80\x9c\x03\x03\x22\x63\xe6\x0e\x6c\x3a\x20\x43\x41\xce\x69\xce\xb2\x73\xaa\xd9\x83\x83\xda\x42\x54\xf7\x2d\xf8\xda\x03\x3b\xe6\x9f\xcb\x1d\x96\xce\x18\x21\x9e\xc1\xad\xdd\x9d\xf8\xc0\x8f\x0a\x96\x84\xe3\x40\x05\x39\x2b\x8a\x8c\x27\x88\xf1\x66\x46\x0d\x49\xa8\xb0\xf0\xe2\x42\x1b\x9a\x65\xc0\x4e\x5a\xcd\x62\xdd\x69\x27\x70\xb4\x1b\xcc\xc1\xbf\x5e\xa2\xd0\xf5\x1f\x02\x53\x6b\xb4\x58\x47\x19\xec\xe3\xe8\xec\xf2\x0f\x1b\x40\x4e\x50\x32\x99\xf0\xe9\xaa\x6e\x6b\x61\x79\x0e\x5d\x40\xa6\xa1\x5c\x68\x37\x44\xa9\x10\x9a\x15\xa7\xb2\xbc\x8b\xd6\xf8\xf6\x60\xed\xec\x56\x42\x76\xdb\x9a\xed\xc3\xc4\x7c\xf5\x0f\x8d\x05\x5c\x8a\x39\x1e\x54\x2b\xb3\x58\x22\xc7\xc4\x9c\x2b\x29\x72\x7b\x88\xe6\x54\x71\x3a\xce\x1c\x63\x63\x96\x7c\xe1\x19\xc3\x25\x32\xb5\xea\x48\xad\xf9\x2a\xae\x87\x2a\x45\x17\x6b\x5a\x70\xc3\xf2\x35\xab\x59\x35\xed\xcf\x54\x45\x54\xc2\x22\xef\xaa\xa9\x13\xd7\xc0\x4e\x9d\x92\xf3\x30\xf1\xb5\x9f\xd9\x02\x77\x7c\xd6\xe3\x76\xf5\xac\xc1\x72\xff\x6c\xdb\x40\x7c\x80\xd3\x6f\xf8\xbd\x01\x16\x7b\x42\x90\x81\xb1\x95\xd0\x18\x90\xf7\xa5\x86\xdd\xa2\xe4\xfc\x6f\xc3\x8b\xcb\xab\x9b\xe1\xdb\xe1\xe5\xc7\xf5\xe0\x20\xdb\x0e\x4a\xf5\x00\x8d\xef\x30\xd9\xc3\xcf\x7e\x8f\x14\x9b\x30\xc5\x44\xc2\x34\xf9\xf9\xd1\xe7\xb3\x8f\x7f\xbb\x3a\x7b\x7f\x79\x4c\xa8\x62\x84\x7d\x29\xa8\x48\x59\x4a\x4a\xed\x99\x46\xa1\xd8\x9c\xcb\x52\x67\x0b\x47\xb9\xd2\x35\x48\xdb\xc4\x56\xe0\xb6\x54\x2c\x88\x66\x6a\xce\x93\xd5\x20\xd2\x03\x32\x9c\x10\x5a\x21\x50\x12\x30\xdc\x32\xaa\x6c\xce\xd2\x1e\x0c\x1b\x26\xed\xbf\xc3\x45\x51\x1a\xcf\xf0\xee\x78\x96\xc1\xa9\x10\x28\x2b\xa5\x03\x72\x21\x4b\x3b\xde\xcf\x7f\x0e\x0b\x53\x2c\x2d\x13\x10\xa2\x2d\x31\xe0\x62\x6a\x7f\xea\x91\xbb\x19\x4f\x66\x84\x66\x99\xbc\xd3\x40\x29\x98\x4e\x68\xe1\x97\x1e\x43\x47\x2f\x84\xa1\x5f\x4e\x09\x1f\xb0\x01\x39\xf8\x79\xf4\xd3\x01\x7e\xbd\x50\xd2\x7e\x02\xe5\x64\x9c\x55\xc6\x0d\x53\x34\x23\x07\x71\xeb\x01\xb9\xb4\xdf\x60\x69\xbc\x0f\x30\x82\x60\x73\xa6\xec\x2a\xfc\x2e\xf4\x88\x62\x53\xaa\xd2\x8c\x69\x6d\xf1\xec\x6e\xc6\xcc\x8c\xa1\x28\x1e\x00\xc6\xbe\x70\xcb\x70\xa5\x22\x42\x9a\x01\xb9\x60\x13\x5a\x66\xc0\x81\xc9\xc1\xc1\xa0\xc9\xf8\x76\x47\xb5\xb7\x4a\xe6\x1d\xd0\x6d\x54\xd7\x1c\x56\xed\xfd\xa1\xc6\x91\x6b\x64\x4d\xb3\x94\xf0\x89\x93\x60\xb8\xb6\x8b\x22\x2c\x2f\xcc\xa2\xcd\xa1\xd9\x42\x47\x48\x6b\x42\x40\x02\x4f\x7a\x4f\x8b\x6f\xd8\xe2\x23\x9b\x6c\x6b\xde\x5c\x3f\xcb\x58\x62\x09\x25\xb9\x65\x0b\x10\x67\xc9\xb9\x1f\x70\xf3\x52\x3a\x2d\x87\xb4\x24\x8f\xfe\xe9\xdb\xe9\x6c\x6d\xd7\x1e\x48\xf6\xb9\x65\x8b\x36\xcd\xc8\xb2\x4e\x67\x41\x03\xbc\xce\xc2\x6a\x3b\x54\x48\x7b\x94\xf5\xcf\x76\x8a\xbe\x72\x72\x87\x31\x69\x77\xe7\xd4\xac\x14\x58\x6f\xcb\x31\x53\x82\x19\x06\x32\x6b\x2a\x13\x6d\xc5\xd5\x84\x15\x46\x9f\xc8\xb9\xa5\x7c\xec\xee\xe4\x4e\x2a\xab\xc8\xf5\xef\xb8\x99\xf5\x71\x57\xf5\x09\x18\x3d\x4e\x7e\x06\xff\x23\x37\x1f\x2e\x3e\x9c\x92\xb3\x34\x25\x12\x8e\x78\xa9\xd9\xa4\xcc\xc8\x84\xb3\x2c\xd5\x83\x48\xeb\xea\x81\x3e\xd0\x23\x25\x4f\x7f\xbf\xf9\x70\xef\x08\x31\x59\xa0\xb1\x62\x07\xa8\x8d\x40\xe8\x5a\xd4\xe8\x54\x40\x7a\x4b\xa1\xac\x8a\x60\xf7\x3c\x77\x6c\xd1\x31\x94\x0e\xcb\x18\x4b\x99\x31\x2a\xb6\xf4\x00\xb0\x75\x3f\xb3\x87\xd5\xa1\x85\x11\x3c\x02\x14\x32\x3d\x25\xba\x2c\x0a\xa9\x8c\x0e\x2a\x02\xd8\x5c\x7a\xf5\x3f\x41\x5e\xee\x91\xbf\x87\x97\x19\x1d\xb3\x4c\xff\xf9\xf0\xf0\xb7\xdf\x5c\xfe\xe9\x77\x87\x87\x7f\xfd\x7b\xfc\x6b\x64\xa1\xab\x37\x41\x9b\x8e\x4c\x41\x08\x77\x7f\x3a\x36\x7a\x96\x24\xb2\x14\xc6\xfd\x60\xa8\x29\xf5\x60\x26\xb5\x19\x5e\x87\x3f\x0b\x99\x36\xff\xd2\x5b\x38\x01\x79\x58\xa2\x03\xe0\xbc\xa6\x66\xb6\x67\xd2\xb3\xde\x1a\xb1\xfa\xa9\x6d\xb7\xb7\x4f\xb8\x5d\x76\x06\x09\xfb\xcf\xb7\x7e\xba\x96\x03\xdd\x29\x6e\x0c\x13\x20\x77\x30\x95\x5b\x4e\xdc\xb3\x98\x5b\xb1\xd9\xf9\xeb\x83\x07\x21\x5e\x01\x6a\x3b\x2c\x0e\x66\xef\x56\x86\xc8\x1c\x08\xad\x97\xa0\x2a\x1d\xe9\xec\x7a\xe8\x2d\x33\x7b\x5f\x88\xb7\x37\xbc\xbd\xf7\x99\x0c\x96\x0b\xb7\xac\x20\x69\x9e\x12\x29\xb2\x45\xf8\x5d\x93\x8c\x83\x35\xc2\x0a\xa0\xc1\x22\x71\x84\x2f\x07\x49\x51\xf6\x5c\x83\x41\xce\x72\xa9\x16\xe1\x4f\x56\xcc\x58\x6e\x25\xb6\xbe\x36\x52\xd1\x29\xeb\x85\xee\xd8\x2d\xfc\x85\x1d\x6b\x1f\x58\xee\x8d\x22\x75\x52\x2a\xcb\x3c\xb2\x85\xa7\x20\x2c\x7d\xda\xb3\xe8\xc1\xb4\xe7\xa3\x18\x76\xe3\x6a\x47\x96\x1b\xb4\x45\x67\x70\xf5\xab\x02\x19\x72\x2e\xb3\x32\x67\xba\x17\xd8\x13\x4a\xeb\x62\x6e\xa5\xc9\x25\xf3\xce\xea\xa7\xe3\xe9\x4b\xf9\x9c\x6b\xa9\x76\xe6\x83\xdc\x99\x3c\x65\x69\xac\xa6\x32\x91\x2a\xa7\x26\xa8\x8b\x5f\x0a\xa9\x41\x07\x70\x38\xdb\x20\x29\xaf\x0f\x5a\x7d\xb6\xa0\xc6\x30\x25\x4e\xc9\xff\x3b\xfa\xcb\x7f\xfc\xab\x7f\xfc\xfb\xa3\xa3\x3f\xbf\xea\xff\x9f\xbf\xfe\xc7\xd1\x5f\x06\xf0\x8f\x5f\x1c\xff\xfe\xf8\x5f\xfe\x8f\xff\x38\x3e\x3e\x3a\xfa\xf3\x37\xef\xff\x70\x73\x7d\xf9\x57\x7e\xfc\xaf\x3f\x8b\x32\xbf\xc5\xbf\xfe\x75\xf4\x67\x76\xf9\xd7\x96\x83\x1c\x1f\xff\xfe\xe7\xad\xa6\x47\xc5\xe2\x43\x8b\x03\x8f\x4f\xdf\x6d\x10\x17\x86\x4d\x99\xea\xd8\xab\xf5\xb6\x12\xf2\xa5\x5f\x09\x6d\x7d\x2e\x4c\x5f\xaa\x3e\x76\x3f\x25\x46\x95\xdb\x0f\x46\x45\xd4\x76\xc1\xf3\x8f\xfe\xb4\x46\xa6\x58\x4f\x9a\xf7\x8e\xc8\x9a\x25\x8a\x99\x7d\x69\x30\x38\x9a\xe7\x1f\x85\x4c\x0f\x35\x11\x6b\xcc\x84\xeb\xa6\xfd\x93\x50\x6a\xbc\x48\x81\xf0\xaa\x38\xef\x44\xc9\x7c\x40\x22\xb3\xd0\x9c\x66\x3c\xf5\xed\x6e\xd9\x16\x2d\xd7\x3f\x2f\x4a\xd0\x0f\x4b\x09\x1a\xe1\xfe\x3e\xb8\x06\xc4\xc4\x7c\x93\x99\xa6\x69\xd3\xb5\x6d\xeb\xe6\x68\x2f\x40\x19\x49\x0a\x59\x94\x19\x35\x6b\xcc\x76\x2b\x6c\xd3\x0e\xf7\x75\x30\x13\xda\x8d\x06\x3b\xb0\xa3\x72\xf9\x6a\x63\x28\x39\xcb\x32\xc2\x05\x9e\x04\x18\xc0\x5b\xf3\x14\x43\x79\x89\x50\x34\x38\xcf\xed\x14\xee\x66\xac\x69\x68\xe4\xda\xea\x3a\xca\x70\x31\x1d\x90\x6f\xed\xef\x48\xb3\x9c\x69\x8c\x0b\x92\x97\x99\xe1\x45\xc6\x48\xe0\xb6\x68\x43\xcb\x4a\x46\xa8\xd6\x32\xe1\xd4\xb8\x19\xbb\xfb\x43\x6d\xfc\xb4\x61\x36\x86\xde\x82\x29\x34\x61\x29\x13\x09\x1b\x90\xcf\x70\x5d\x18\xd6\x3a\xb6\xc2\x20\x98\xf7\x61\x0c\x4a\xd2\x12\xaf\x76\x90\x1e\xac\x1e\x63\x98\xe7\xa5\x01\x43\xf1\x63\x59\xf1\xed\x8e\x3b\xcb\x5c\x64\xcc\x07\x52\x15\x44\x6b\x0a\x77\x0f\x72\x52\xa9\xee\xfa\x7e\xe6\xfb\x76\x84\x37\x98\xdb\xb6\x72\xaa\x25\x8a\x5b\xd9\x18\xea\x94\xf6\xb1\x2d\x86\xed\xe8\xec\x8f\x92\xc6\x76\xa0\xaf\xed\x69\x6b\x07\xe3\x52\x57\x7a\xda\xd6\x9a\x54\x28\x36\xe1\x5f\x3a\xe0\xe3\x99\xa8\x54\x14\x9e\x32\x61\xac\x22\xa0\x80\xa0\x2a\x56\x30\x01\x7a\x38\xa3\xc9\x0c\xe8\x82\xa3\xa2\x95\x65\xf8\x21\x6f\x8c\x50\xca\xe8\x7e\xbc\x46\xab\xa4\x98\x97\xb3\xf5\x23\x3f\x5b\x6e\xd7\xf7\x7f\xb0\x84\x4c\x19\xea\x16\xeb\x95\xeb\xc6\x3e\x46\x3d\x9c\x9f\x8b\xff\x0b\x2f\xf0\xfc\x24\xad\xf6\x16\xae\x9c\x0a\x09\x67\x6d\xc2\x0d\x91\x56\x22\xb0\xdf\x1d\x90\xd1\x8a\x9e\x39\x35\xc9\xcc\xb5\x38\x3c\xd4\x04\x8d\xb6\xcd\x81\xc6\x68\x22\x4c\xcb\x8c\xa5\xc4\x3b\x6c\xe0\xa0\x1d\x51\xaa\xe6\xaa\x70\x42\xb5\xe6\x53\xd1\x2f\x64\xda\xb7\xa3\x9d\xac\x43\x88\x16\x87\x2a\x76\x35\xdc\x7e\xb0\xb6\xe2\x55\x30\x4e\xb4\xdb\xa6\x8f\xc1\xfe\x16\xc9\x16\x89\xcc\x8b\xd2\xb0\xc8\x38\x17\xec\x3a\xe3\x05\x7a\x16\x45\x32\x64\x25\x11\xdd\x0f\xa6\x39\x15\x74\xca\xfa\xee\xe3\xfd\xf0\xf1\x7e\xf8\xd6\x7d\xc0\xdc\x86\x6a\xa1\x49\x71\xd3\x39\xac\x03\xef\x1d\x9a\x2c\xf1\xe5\xd8\x99\x8e\x72\xfa\x85\xe7\x65\x4e\x68\x2e\x4b\x01\x32\xd9\x32\x38\xe1\xf2\x9a\xa5\xfb\x01\xd8\x0a\x40\xe9\xb5\x90\x6a\x09\x2d\xd2\x19\x31\xc9\xf3\xb5\x6c\xb5\xb2\x68\x75\xb3\x64\x75\xb0\x60\xed\x6c\xb9\xf2\x46\xea\xf6\xf8\xf8\xd1\xdb\xcd\x1b\x18\xc9\xc5\x56\x8c\xf4\x07\x1c\x5c\x3b\xc2\x38\x5c\x13\x99\x73\x63\x82\x4b\x56\xc0\xb0\x1e\xe1\xa6\x66\xfd\x74\x67\x81\x4f\x90\xc6\x72\x4d\xd8\x17\xab\x4d\x71\xb0\xa2\xfb\x5b\x8b\x1e\x72\xd9\x3b\xae\xc1\x80\x46\x05\xe1\x79\x91\xb1\xdc\xfb\x90\xf6\xbd\x6e\xe6\x9c\x0c\x5e\xce\xc7\xcb\xf9\x58\xd5\x49\x77\x91\x45\x62\x31\x04\x0d\x05\x63\x96\x55\xe2\x88\xc5\xec\x42\xa6\xda\xc9\x0b\x1e\x87\xec\x59\xb8\xfc\xc2\x35\x78\xe2\x7e\x64\x60\x19\x18\x31\xa3\xc9\xdd\x4c\x6a\x86\x3d\xa8\x62\x6e\x9c\x88\x35\x7a\x4b\x08\xdc\x23\x80\xd3\xe8\x64\x52\x6f\x91\xb2\x22\x93\x8b\x1c\x24\xdb\xa1\x89\xe5\x99\x20\xba\xb0\xbc\xc8\xa8\x61\x41\xb0\xd9\x6c\x6d\xb8\x37\xe7\x83\xaf\x5f\x7e\xb1\x12\x40\x14\x07\xd1\x02\xb6\xcd\x8e\x75\xd3\x54\x03\xd2\x8e\xc8\xe4\xe8\xb3\x7c\x03\x12\x7e\xf5\x06\xa0\x79\x76\x75\xb1\xde\x41\x92\xb4\x32\xaf\x90\xed\x26\x96\xa5\x65\x9c\x6d\x98\x6a\x43\x7a\x45\x9f\x5f\xef\xc1\x8a\x1e\xe8\x3d\x34\x5e\xf5\x9c\xfb\x5c\x88\x0e\xc0\xc6\x8a\x65\x18\xfa\xe0\x0c\xcd\xb6\x91\xf3\x5c\xdf\x8f\x46\xd6\xd6\xee\xde\xc6\xe6\xde\x0f\x93\xdf\x93\x12\xd8\xca\x28\x5f\xdb\x0c\x50\xb2\xe3\xa3\x0a\x2e\x47\x16\x92\x68\x9f\x77\x1b\x41\x8b\x22\x83\xfb\x3a\xd9\xd6\x37\xab\xa5\x3a\x86\xcb\xef\x38\xe9\xb0\xe5\xb1\xc3\xad\x9d\xf9\xa1\x46\x04\xb0\xa7\x63\xc6\x0b\xe7\xcd\x88\xd6\x3a\x1f\xbf\xf0\x19\xec\xa8\x55\x4c\x89\x3d\x09\x43\xd1\x23\x57\xd2\xd8\xff\x5d\xa2\x4d\xd4\xe2\xcd\x85\x64\xfa\x4a\x1a\x78\xb3\xd7\x65\xe3\x54\x3a\x2e\x1a\x3b\xc1\x01\x11\x78\x26\xc1\x20\x1d\x05\x34\xa0\xaf\x28\x90\x42\x0f\x20\xae\xc9\x50\x10\xa9\xfc\xea\x82\x55\x57\xbb\x21\xbc\x66\x28\xa4\xe8\xa3\x1b\xe1\xaa\x31\x2e\x83\x0f\x65\x0c\x93\x0d\xc3\xb9\xa1\x6e\x2c\x05\xc6\x5f\x30\x84\x25\xa3\x09\x4b\x49\x5a\xc2\xa4\x21\x1c\x83\x1a\x36\xe5\x09\xc9\x99\x9a\x32\xcb\xb4\x93\x59\x5b\x50\x6f\xa3\x4b\xf8\xb4\xa0\x4e\xf1\xa0\x5b\xf6\x0f\x48\xf0\x3b\xe0\x12\xdd\xc8\x36\xf6\x41\xf2\x96\xd3\xc2\x6e\xdd\x3f\x2d\x15\x03\xe8\xfd\x9b\x14\x94\x2b\x3d\x20\x67\xde\xf5\x36\xfe\xcd\xd9\xc0\xe2\x61\xec\x08\x56\xea\xfb\xbe\xe4\x73\x9a\x59\xba\x89\x02\x1e\x43\xf1\xce\x8e\xde\x64\x16\x3d\xc7\x4b\xed\xf9\x46\x7f\x17\xae\xc9\xc1\x2d\x5b\x1c\xf4\x96\xb6\xfb\x60\x28\x0e\x90\xbe\x2e\x6d\x70\x20\xc6\xe0\x51\x72\x00\xbf\x1d\xdc\x8f\xbf\x3c\x80\xf0\xb7\x75\x2f\x8d\xcc\x98\x8a\x43\x3f\xb7\xec\xe1\x4d\xd5\x1e\x96\x56\x5d\xef\x46\x23\x3d\xce\x2d\xc5\x8d\x17\x5b\xec\xd9\xaa\xe6\x05\xa8\x65\x0c\x4d\x66\xe8\xc5\xed\xe6\x05\x71\x34\x0b\x62\xf7\xcc\x20\x5d\x07\xc4\x70\x1c\xd2\x28\xb8\xf4\xf9\x6d\xc0\xb6\x1e\x03\xf9\xe9\x77\x91\x7f\x3b\xb4\xb7\x7f\x04\x0c\xf9\xad\xff\xd7\xef\xee\x19\xb7\xd0\x8e\xb1\xe1\x94\x3a\x08\x18\x97\xd0\x81\x70\x91\xc2\x05\x93\x5b\x2a\x40\x00\xc7\xb2\xf0\x81\x65\x0d\xc8\xa5\x25\x54\x24\x67\x54\x68\x6f\xe6\x82\x9b\xa8\xaa\xb1\x76\x57\x66\x91\x5e\xe5\x4c\x0a\xd5\xc9\x60\xe4\x4a\x8e\x9c\xed\xab\x47\xae\xc1\x96\x5a\xbd\x81\x93\x74\x25\x2f\xbf\xb0\xa4\x34\x6b\xef\xb2\x62\xb8\x6d\xe5\x22\x5b\x19\x7d\x0d\x20\xdf\x54\x4c\x1e\x57\x56\x63\xf2\x15\x06\xc7\x6c\x7e\x23\x64\x6e\xd9\xa2\x62\x36\x4e\x84\x00\x92\xdf\xab\xb0\xc4\xb3\x02\xe4\x1d\xff\xed\x4d\x59\xf9\x98\x0b\xfc\x18\x0e\xed\xb7\x02\x46\xf7\x00\xb5\x92\x5d\x96\xe1\x67\xf6\x01\xae\x76\x72\x46\x0d\x66\x1f\x3a\xc8\x18\x81\x4a\xae\x96\x2e\x22\x91\xe2\xf2\xfb\x92\x66\xf5\x20\x04\xf7\xca\x35\x5a\xa2\xea\x77\x3c\x4b\x13\xaa\x9c\x97\x17\x86\x69\x6a\x89\xbb\x47\x81\x10\x24\x54\x84\xd3\x5e\xed\x91\xc6\xab\xca\x82\x2a\xc3\x93\x32\xa3\xca\x47\x8e\xb7\x0a\x14\xd8\x0a\xd1\x0a\x69\x46\x2c\x91\x22\xed\xa2\x00\xdc\x34\xfb\x36\xef\x5a\x0b\xa6\xb8\x44\xef\x62\x9e\xb3\x26\x92\x1e\xd5\x6d\xda\x72\xe2\x4f\x75\x38\x62\x35\xcb\x07\xc4\x66\x7a\x86\xc7\xa7\x42\x2a\x96\x1e\x47\xe4\x31\x9c\x8a\x01\x79\xb3\xf0\x66\x16\x30\xb9\xb8\xe8\x0a\xcd\x8c\x0f\x84\xf1\x28\xeb\x80\x5d\x1d\xa8\x89\x54\x10\x9c\x72\x94\x4a\x8c\xc8\x98\xf3\xc4\x1c\x0f\xc8\xff\x65\x4a\xc2\xc6\x0b\x36\xa5\x86\xcf\x03\x37\x0d\x8a\xab\x62\xd4\xdd\xe0\xbf\x22\x47\xd0\x8d\xf0\x3c\x67\x29\xa7\x86\x65\x8b\x63\xd4\x63\x19\xd1\x0b\x6d\x58\xde\x66\xeb\xda\x18\x0d\xd0\xd7\x0e\xda\xfe\xea\xeb\x0d\x2d\xbb\xc6\x50\x7d\xf6\x51\x29\x15\x64\xd0\x87\xa0\xb1\x85\x81\x07\xc9\x0d\xe2\x66\xec\x83\xe0\x02\x9b\xbd\x64\x19\x6f\xf0\x77\x16\x0f\x28\x51\x0c\x32\x10\x38\xcc\xbd\x27\x8e\xa3\x37\xe5\x7b\x59\x8a\xf5\x26\xc1\xda\xc2\xdf\x39\x25\xfc\x73\xd4\x71\x6d\x94\xe2\xa3\x88\x09\xd1\x4c\x22\x13\x25\x25\x60\x97\x04\x76\x6e\xc9\x03\xb6\xaa\x3c\x51\xb6\x4e\x72\xaf\x11\x89\x30\x97\x2d\x5e\xef\x7b\x89\x5b\x0c\x1f\xea\x80\xcb\xe0\x20\xee\x00\xd3\x88\xdb\x33\x8e\x1c\x00\x7e\x22\x04\x2b\x04\x85\x6f\xb1\xd4\x7b\xb1\x59\x6a\xe0\xba\x92\xc3\xd3\xc3\xbd\x10\x5f\x5c\x8e\x92\x05\x9d\xc2\x79\xea\xb0\xaa\x66\x57\x92\x32\xc3\x54\x0e\x01\xd7\x33\x79\x87\xbf\x23\xdb\x2a\x5c\x2b\x96\x56\xb1\xed\x33\xa9\x81\x2b\xd5\x83\x18\xe1\xfc\xc2\xc5\xe8\x1d\x5d\x10\xaa\x64\x29\x52\x27\x35\x05\x02\xfa\xbe\xf1\xe1\x2b\x29\x80\x52\x94\xda\xc2\xea\xa6\x46\xa5\xc7\xcc\x50\x7b\x6c\x5e\x0f\x5e\xbf\xda\x0b\xc0\x3a\xc6\xad\xc2\x6c\x1a\x96\x42\x7f\x57\xee\xcf\xcc\x5e\xe6\xa5\x18\x4d\x3f\x88\xac\x8b\x2c\xf7\x1e\xd1\x0b\xba\xf6\x41\x09\xe3\x13\xb0\xdd\xf6\xf0\xd5\x9d\xe2\x86\x45\xe4\xf1\x68\x42\x33\xcd\xac\xea\x5e\x8a\x20\xc2\x1e\xd7\x45\x10\x68\xd2\x66\x41\xdb\xfd\x41\x74\x39\xbe\xe7\x39\x73\x07\x0a\x50\xae\x3a\x66\x01\xe1\x0e\xf5\x86\x23\x57\x0f\xee\x24\x47\xd8\xd2\x4a\x6c\x52\x9a\xe3\xfd\x38\x89\xe0\x02\xad\x66\xdd\x45\x25\xf1\x71\xc3\xc5\x1e\x57\xfb\x86\xcd\xe8\x9c\x69\xa2\x79\xce\x33\xaa\x32\x88\x15\x1c\xe1\xfc\xc8\xb8\x34\xab\x23\xd0\xbb\x45\x37\xc7\x33\x89\x86\xdb\x0a\x6a\x3f\x0f\x0b\x27\xa0\x11\x7e\x5e\xf6\x3b\x79\x69\x4a\x9a\x65\x0b\xc2\xbe\x24\x59\xa9\xf9\xfc\xbe\xa7\xc9\x45\x3f\xec\xc0\xaa\x9b\x5c\xba\x90\xe9\xa8\x60\xc9\x63\xf2\xe8\xba\x86\x61\x49\x55\xea\x37\x1d\x78\x32\x2a\xfb\xa0\xb9\x2f\xc0\xf3\x29\x49\x98\xd6\xde\xa7\x72\x11\xfb\x79\x86\x35\xfc\x50\x12\x0a\xd0\x3b\x7d\x99\x51\x6d\x78\xf2\x26\x93\xc9\xed\xc8\x48\xd5\x29\x66\xff\xec\xdb\xd1\x52\xff\x46\x1a\x86\xb3\x6f\x47\xe4\x82\xeb\xdb\x38\xb1\x0b\x5e\x9a\xc6\xe6\x12\x4a\x6e\xcb\x31\xcb\x98\x39\x3c\xd4\xc8\xe5\x72\x9a\xcc\xb8\x60\x9e\xc1\x89\x10\x92\xe2\x14\x3e\x0b\xe5\xae\x77\xa6\x2e\xf0\xe9\xc4\xe1\xeb\xcf\xe8\x9d\x66\x38\xfd\xb1\x9d\xbe\xfd\x99\xb5\x89\x48\xdf\xeb\x3d\x05\x4e\x66\x78\xb1\xa7\x3b\x88\x89\xbe\xb1\x73\xec\x66\xdc\x3e\x7c\xcb\x33\x86\x3a\x0e\x2c\xd1\x7b\xa5\xb9\x73\x00\x3b\xb6\x90\x25\xb9\xa3\xa8\x15\x03\x0d\x1c\x90\x1b\x5e\x9c\x92\x4b\xa1\x4b\xc5\x2a\x7b\xc6\xa4\x31\x14\xd7\x55\x64\x99\x57\xa7\x60\x87\x51\xe5\xb0\x94\xce\x69\x57\xe4\xf2\x0b\xcd\x8b\x8c\xe9\x53\x72\xc0\xbe\x98\xaf\x0f\x7a\xe4\xe0\xcb\x44\xdb\xff\x09\x33\xd1\x07\x03\x32\xcc\xc3\x3d\x3b\xa4\xfe\x51\xcc\xbb\x3e\x61\x07\xcb\x8c\x23\x3e\xfb\x20\x08\xe2\xdc\xe8\xac\xb4\x96\x4a\x72\x87\x19\x28\x2c\x89\x67\x4a\x49\x15\x3c\xcf\x23\x30\x00\x77\x49\x64\x5e\x28\x99\xf3\xc8\xb0\x07\x08\xbe\x57\xff\x3a\x30\x37\x6c\x17\x49\x97\xf7\x1f\x73\xba\xb9\xce\xa4\xce\x1c\xd7\xed\xfe\x70\xe2\x3d\x26\x50\x55\x74\xba\x3b\xe8\x9f\xae\x91\xdd\x6f\x37\x8a\xa5\x56\xf1\x0e\xbf\x0d\x51\x73\xe4\x24\x65\xf3\x13\x9d\xd2\xd7\x3d\xf8\x8c\x76\xde\x7e\xa6\x36\x27\xaa\xc9\xc1\xeb\x83\x01\x19\x79\x6e\xdb\x8b\xe7\x58\xb5\x9b\x48\x15\x06\x04\x63\xfa\xab\x03\x72\x24\x15\x8c\x9c\x50\x41\x32\x46\xe7\xce\x80\x8c\x67\x6a\x81\x3a\xed\x71\xeb\xa8\xc7\xb6\x01\x60\x91\x96\xff\x9f\xbf\xdc\xd2\xba\x9d\x24\xba\xbc\x6f\xde\x33\xf2\xc0\x8a\xa0\x07\x20\x4c\x4a\x4b\x63\x2d\xd5\xb4\x6c\x15\xd2\x6a\xb9\xb1\xab\x05\x73\xb1\xa4\x29\xe3\x00\x1b\x37\xf5\x00\xe4\xd4\x83\x27\xa0\xba\xa4\x63\x7c\xbd\x27\xa9\x5d\xa1\xf9\x49\xf0\xef\x4b\x46\x86\x17\x21\xb2\x9e\x29\xcd\xb5\xb1\xa7\x3b\xad\xf1\x30\x8e\x8c\xed\xe8\x2c\xa7\xff\x90\x82\x5c\xbe\x19\xb9\x8f\x1e\x3f\x29\x78\xb6\x12\x09\xfa\x8f\x52\x31\xcb\x8e\xbb\x38\x0c\xf8\x3e\x4d\xce\x6e\xdf\x93\x0b\x6a\x28\x32\x78\xe7\x72\x25\x2a\x0a\x6f\xb1\x70\xcc\x45\xea\x7e\x8a\x38\xf7\x63\x33\x59\xbb\x7b\x57\x9b\xe4\xa5\xb8\xe1\xa7\x8f\xc3\x3d\x31\xe3\x04\x68\xfc\xf4\xbd\x4c\x3b\x73\xe4\x3f\x5a\x00\x9e\x63\x7f\x92\xdb\x01\x88\xd5\xd9\x7b\x70\x9c\x89\x3d\xcf\xee\x9f\xdf\x5a\x8d\xb3\x35\xf1\x6a\xc5\x46\x3c\xb4\x3a\xce\xf9\x26\xd2\xd3\x81\x76\x58\xd4\x80\x73\xe3\x18\xca\x38\x93\x63\xe2\xf0\x7d\xdf\xf3\xfd\xf4\x71\xb8\xc3\x74\x3f\x7d\x1c\x3e\xee\x54\x77\x12\xcf\x9a\xd2\x59\xc5\x83\xab\x70\x8c\xa6\xd8\xd5\x5e\xe6\x1a\xec\x4b\xda\xda\x27\x9c\x56\x65\x95\xdc\x02\xa5\xc3\xcb\x2f\x05\x3a\x9f\x39\x23\xff\x68\x46\x21\x8e\x39\x44\xd7\xc1\xa6\xda\x5d\xd6\x96\xb2\xfb\xed\xb5\x1a\x1d\xd0\x27\x72\xc1\xf0\xca\x32\x3d\xf5\x8e\x00\xa1\xc7\xea\x0e\xef\xc1\xed\x32\x3d\x45\xba\x4a\xd0\x0b\x33\x8d\xb0\xe9\x08\x4d\x44\x22\xfc\x44\xe7\x94\x67\x74\xcc\x33\x6e\x16\x96\x43\x1f\x0f\x6a\xae\xa5\x1a\xa6\xbc\xd7\xc3\xbc\xa3\x68\xb1\x64\xa0\x22\x47\x76\xa4\x13\x30\x70\x1d\x0f\x2a\xa9\x62\xc6\x94\x0b\x42\x44\xd1\xa3\x26\x72\x68\x66\x00\xdb\x1a\x12\x47\x5b\x54\xd9\xce\xee\x01\xf0\xf6\x7c\x74\x65\x68\xb6\xcf\x4a\x86\x06\x3f\x8c\x5c\x4e\xb8\xe7\xcc\xd3\x30\x5e\xaa\x15\x57\x03\xb4\xda\xda\xb2\x3d\x5f\xfb\x71\xe3\x14\x09\xc1\x68\x3b\x30\x41\x3b\x55\xe1\x98\xa0\x8f\xaf\xaf\xb9\x51\x22\x96\x8d\x1c\x29\x71\xe9\x92\x90\x6f\x5a\xdc\xfa\xa6\x45\xaa\x80\x2e\x09\x16\xfc\xce\x77\x0d\xb9\x9a\x81\x5b\xc5\x76\xe4\x6a\x3d\x9b\x84\x15\xb3\x49\x97\x7b\xea\x73\x56\xcc\xde\x8e\xea\xe6\x39\xfb\x8e\xbc\x1d\xad\x38\x97\x00\x64\x58\xad\x46\xa3\xdd\xa1\x26\x19\x9f\x30\xc3\xb7\x2c\xe1\x01\x4e\x66\x2e\x05\x37\x52\xad\x8f\x4b\x26\x9d\x4e\x9b\x1f\xae\x2b\x3f\xac\x32\x79\xbc\x77\x23\xa0\x03\x5c\x22\xb3\x8c\x25\x3e\x8f\x35\x80\xd4\x7f\x62\x95\xf2\xc2\x9c\xce\x1e\xb2\xfc\xa3\xa2\x72\x82\x1b\x7a\xf2\xf1\xf2\xec\xe2\xfd\xe5\x20\x4f\x7f\x36\x93\x77\x7d\x23\xfb\xa5\x66\x7d\xde\x22\x55\xc8\xd3\xb9\x11\xe2\x53\xb4\xca\x5c\x55\x07\xe9\x07\x1f\xc0\x48\x3e\x69\x74\x1b\x00\x53\x8e\xbf\x14\x92\xd2\xf4\x88\xa2\x2e\x48\x91\x3a\x4b\x50\x99\x65\x08\x65\xa3\x18\xeb\xc5\x2a\xf5\xc6\xd8\x8c\xce\x0b\xda\xd5\x88\x50\x2d\xea\x61\x09\xf4\xe3\x23\x57\x17\x5a\xbf\x5d\x88\xd8\x04\xb9\x51\x18\xc3\xfb\x5f\xc0\x55\x93\x91\xe0\x9f\x05\xfe\xb6\x13\xa9\x2c\xd6\xa8\x3a\x06\x30\x93\xc0\x62\x4f\x4a\xcd\xd4\xc0\x71\x8c\x47\x07\x54\x87\x64\x3d\x3b\xe4\x48\x6b\x82\xe9\x23\x9b\xa0\x43\xb2\xcf\x99\xeb\xa4\x28\x5a\x9a\x19\x13\xc6\xa7\x1c\x77\xc0\x58\x09\x37\xe7\xe1\xfc\xe8\x80\x6a\x99\x1e\xa8\x5b\x32\x9f\x97\x04\x38\x5d\xd0\xd0\x1e\x94\x7b\xd1\xed\x10\x1d\xa5\x68\x2a\xc1\x05\x02\x73\xba\xd5\x10\x8c\xa6\x39\x17\xcf\xf0\x20\x26\x5c\xa4\xdb\xd6\xdf\x48\x5c\x07\x3d\xea\x72\x14\x8e\xe2\xad\xe7\xe1\x26\x8e\x7a\xbd\x06\x43\xc8\xdd\x9d\x5c\xfd\x46\xae\xd5\xa1\xcb\x17\xfa\xfb\xac\x8f\x5f\xe9\x17\x69\x05\x95\x97\xeb\xb5\xfd\x1b\x70\x1e\xe1\xd2\x6c\x4f\xfb\x4b\x7e\x7a\x02\xcd\xbd\x21\xd5\x45\x86\xb9\x17\x6f\x86\xaa\x29\xda\x07\x6d\x61\x46\x30\x2c\xbf\xe2\x74\x57\x0b\x82\x82\x2a\x9a\x33\xc3\x14\xba\x8e\x39\x67\x34\xe1\xbc\xfa\x3f\x14\x4c\x8c\x0c\x4d\x6e\xf7\x9d\x42\xf4\x85\x9f\x3e\x1c\x3f\xdd\xf5\xb6\xcc\x3b\xc9\xa4\x01\x13\x5c\x42\xa1\x45\x7c\x33\xcb\x85\x63\x36\xcf\x84\xae\x84\x3c\x5e\x5d\x2c\x11\x21\x8f\x53\x9d\x89\x56\x79\xbd\xd0\xf8\x00\x2e\x62\x21\x31\x1d\xb8\xbe\x23\x14\xf6\xc3\xf4\xda\x1f\x02\x27\xc7\xec\x72\xef\x54\xd1\x83\x5c\xa6\x8c\x8c\xb9\xa9\x4e\xba\x66\x86\x14\x4c\xe5\xdc\x05\x40\x4b\x81\x35\xf8\x58\x8a\xdc\xcb\x72\x2a\xf7\xe9\x88\xb3\x09\x22\x13\xe3\x8b\x5c\x91\x31\x33\x77\x8c\x09\xf2\xea\xd5\xab\x57\x20\x6f\xbc\xfa\xf5\xaf\x7f\x4d\x20\xe3\x42\xca\x12\x9e\x2f\x37\x84\x56\xff\xf5\xfa\xf5\x80\xfc\xe9\xec\xfd\x3b\xf0\xbf\x2a\x8c\x26\x63\x69\x66\x6e\x64\xdb\xa0\xd6\x59\xf7\xc8\xff\x8c\x3e\x5c\x79\x31\x41\x37\x7e\x05\x95\x22\x2c\xaf\xee\x4c\xf7\xea\x57\x5f\x7f\x3d\x20\x17\x5c\x41\xe4\x2d\x87\x58\x81\xe0\x2e\x58\x78\x17\x3a\x21\xcd\x72\xac\xbb\x63\x13\xce\x9d\x36\xe7\xd3\x99\xc1\x6a\x49\x80\x29\x19\x4f\x0c\x66\xdf\xc3\xc3\x8e\xb9\x90\xb4\x0b\x25\x71\x81\x51\xce\x71\x04\x26\xd7\x23\x19\xbf\x65\x64\xa2\xff\xa0\x64\x59\x54\x01\x81\x8a\x69\x2b\xa3\xba\x5a\x4c\x38\x58\xb5\x57\x9a\x99\x27\xf5\x64\x68\x69\xa9\xa9\x21\xdd\xb0\x26\x80\xf4\x42\xfe\xb1\x3e\x62\x42\x41\x79\x70\xae\x83\xeb\xe6\x5a\xf6\xfb\xa0\x45\xa6\xd1\x39\xf5\xf1\x1d\x85\x92\xdf\xe1\x26\x71\xe1\x23\x85\x9c\xcc\xab\x9d\xcc\xe5\x02\x33\xc1\x66\xcb\xeb\x91\xeb\x96\xef\xb9\xa8\xf8\x28\xc6\x68\x38\x89\x83\xd1\x20\x74\x9b\x6b\xfb\x89\x5a\x72\xc8\x15\x5f\x8e\xcb\x13\x9a\x99\xc6\x1d\x2d\xc5\x52\x6f\x57\x6b\xc4\x51\x1a\x57\x81\xc6\x85\x79\x55\x63\xa0\xbb\xaa\x0b\x92\x89\xea\x1a\xd5\x12\xb6\xd5\x9c\x64\x34\x33\xa5\x03\x0d\xf8\x2a\xd9\x6f\x33\xad\x5d\xac\x4d\x4e\xd5\xad\x15\xfb\xdd\xf9\x1f\x80\x67\xb0\x0e\x71\x3e\x18\x74\x35\x67\xa1\x48\x5d\xec\x59\x6f\x3f\x72\x38\x18\x1c\xe2\x01\x91\x0a\xf3\x5d\x22\xb6\xdb\xf7\x4f\x14\x53\x5c\xf7\xdc\xa6\x45\x54\x82\xce\x95\xf6\xa0\x35\x8f\x60\xea\x20\xd5\x26\xcb\x6d\x27\xf1\xa5\x5b\xbe\xe0\xb6\x19\x83\xb1\x65\xd1\xa6\x6c\x41\x57\x09\xaa\x43\x82\xe1\xf5\x75\x53\xdc\x11\x68\x97\x33\xb8\x73\x0e\x5c\x82\x5e\x11\xbb\xcc\xb1\x2b\x93\x73\x41\x6c\xb5\x8a\x59\xcf\x9f\xab\x0d\x27\x18\xfe\x51\xa7\x55\x8e\x16\x44\x12\x42\x55\x9d\xaa\x8a\x05\x79\xd6\xcc\x2b\x46\x97\x6e\xd9\xd8\xbb\x30\x32\x7c\xda\x5d\x12\xe0\xb3\x74\x0e\x02\xcd\x2c\x6a\xd5\x2e\x32\x34\x00\x80\xdc\xe8\x0f\xcb\x80\xbc\x77\x34\x15\x91\x8b\x8e\xb5\xcc\x4a\x83\x5d\xab\x1f\x63\x82\x0b\x83\xfa\x94\x03\x40\x65\x43\xb3\x88\xfc\x9a\xaa\xde\x57\x3b\x4a\x8c\x4f\x87\xc3\xf8\x92\xfa\xf2\xc9\xd2\xca\x56\x19\xbb\xf5\x83\xa5\x98\x4d\x34\xef\xa2\x2a\x8d\x86\xe4\xa8\x2a\x95\xe1\xaf\xb9\x87\xc2\x30\x35\xa1\x09\x3b\x8e\x55\xa8\x50\x92\x24\x78\xd6\xf8\xd8\x80\x19\x15\x69\x86\xa2\x75\xc2\x14\xa0\x3c\xfb\xe2\x8a\xe5\xda\x4f\xa4\x8a\x43\x11\xd8\xa3\x37\xcc\xca\x83\x8c\x9a\x52\xb1\x56\x11\x46\xfb\x75\x2b\x84\x69\xec\x4b\x69\x83\xc1\xba\xba\x54\x40\x27\x2f\xa1\x8a\xe8\x58\x55\x60\x42\xa8\x22\x48\x75\xac\x96\x0e\x2c\x2a\x01\x3d\x06\x52\xb1\x90\xa5\x72\x76\x6f\x9f\x5b\x34\x91\xca\x2a\x42\x38\x30\xd5\x44\xb1\xa9\x95\x56\x15\x88\xb5\xd8\x22\x2b\xed\x8b\xbd\x3a\x7f\xed\xd9\x49\x6e\x93\x8b\xdb\xc4\x89\xcf\x72\xce\x53\xcf\x22\xe1\x6e\xa9\x2a\xf1\x57\x50\x1d\xc5\x9d\x44\xe9\xd8\x23\x08\xa3\x30\x0e\x8c\x34\x44\x74\xd6\xfc\xa7\x63\xeb\xae\x84\x44\x0f\x2d\x6a\x29\x74\x21\xc2\x32\x65\xd7\xe5\x38\xe3\x7a\x36\xda\xd1\x14\x78\xb5\x62\x08\x74\x18\x58\xba\xa8\x5b\x6b\x1e\xd4\x4c\x68\x0e\x2c\xcf\x92\x71\xcb\x6c\xa1\x76\xb0\x04\x20\xfa\xde\x31\x66\x4a\x08\x8c\xc8\x98\x0b\xe7\xb7\x3f\x45\xf3\x70\x11\x5a\x98\xc0\x23\x65\x9f\x44\x51\x7b\x9f\xd0\x2c\xd3\xcd\xe8\x55\x4f\x68\x51\xe6\xf0\x51\x5b\xb8\xa7\xdc\x6e\x77\x28\x13\xd2\x48\x05\xb9\x76\x61\x9a\xe4\x12\x23\x5c\x04\x91\xc2\x37\x82\x3c\x24\xbe\x43\x14\xd5\x07\xb1\xbb\x80\x32\x7b\xae\xa3\xf8\x62\x03\x7d\x38\x1b\xe8\x8e\x37\x0d\x55\x25\x25\x1a\x45\x04\xd7\x4b\x3d\x7b\x52\xea\x49\xee\x96\x2b\x89\xbd\xde\x0a\xe0\x37\xcf\x0c\x96\x27\xef\x9c\xf3\xec\x73\xa3\x3b\xb0\x69\xab\x77\xc0\xe1\xed\x3b\xcd\x22\x89\x30\xd3\x29\x04\xe1\x08\x2c\x1f\xf9\x8a\xe7\x00\xbb\xc1\x97\x87\x9a\xa4\x32\x29\x43\x6e\x54\x00\x5a\x75\x01\xd6\x26\x83\x20\xe9\x7a\x9c\xba\xa7\xb5\x8a\x3f\xb2\x15\xab\x52\x79\x27\xee\xa8\x4a\xcf\xae\xb7\xf8\xa5\xd7\xd9\x79\xd5\x2b\x16\x94\xfc\x60\x50\x09\x8f\x8e\x65\x69\xaa\xf4\x99\x3f\x6e\xd3\xb3\x91\x96\x22\xb4\xb4\x34\x93\x17\xe3\xf5\x8b\xf1\xba\xf9\x3c\xb8\xf1\xda\xf6\xa9\xe7\x82\xad\x1d\x57\x9f\x62\x80\x67\x6d\x5d\x69\x1f\xd2\x0a\x1a\x11\x18\xa4\xee\x4d\x3f\xf8\x86\xdc\x86\x47\xa4\xda\xdb\x48\xd6\xf3\x14\x08\x58\xf5\xd3\x5b\x4c\x1f\xc8\x0e\xda\xbe\x56\x2f\x3e\xeb\x5c\x70\x37\xd5\xee\x05\xa9\x21\x2a\xb6\xdb\x73\x99\x90\x7b\x4e\xef\x12\x69\x55\xc6\x0e\x13\x31\x77\x28\xd5\x89\x4f\x47\xe0\x93\xce\x1b\x40\x3a\x16\xd2\xc5\xa7\xeb\x6e\x90\x1d\x8a\xea\xe2\xf3\xc4\xa5\x75\xf1\xe9\x6c\xe2\x26\xdd\xcb\xec\xae\x58\xee\xc3\x16\xdb\xdd\x71\x69\x8f\x6f\xbd\xef\x55\x25\xde\x9e\x3f\x5b\x7f\xb1\xde\x2f\x3d\x8f\x68\xbd\x8f\x08\xb7\x27\x06\x0e\x00\xb1\x45\x3f\x36\xb7\x79\xb3\xfe\x98\x79\xb1\x72\x50\x65\x20\xb3\x28\xe7\x0d\xfa\x52\xd5\xaf\x4d\x0f\x07\x83\xc3\x43\x6f\xe6\x77\xf8\x59\x9a\x49\xff\x37\x84\x89\x44\xa6\xb8\xa9\x76\x7c\xa5\x0d\x30\xfd\x4a\x3b\x8f\xe7\x92\xfb\x6f\xc5\x57\xaf\x30\x76\xb7\x2d\xe9\x70\x82\xbb\x97\xce\x5e\x05\xe9\xc7\x28\xa0\x1d\x97\xc9\xae\x57\xc5\xc6\x16\xf7\x29\x85\x1d\x03\xef\xc1\xf9\x6b\xeb\xe2\xd8\xf8\xec\xc2\x5e\x77\x28\x94\x8d\xcf\x23\x97\xcb\xc6\x67\x27\x8e\xda\xa9\x74\xf6\x8a\xc5\x3d\x5e\x01\x6d\x7c\x9e\x69\x31\x95\xfa\xd3\xa9\x98\x36\x3e\xbb\x95\xd4\xae\xf7\xed\xb8\xf5\x7b\x29\xaf\x8d\x4f\xb7\x22\xdb\xf8\xec\xbb\xd4\x36\x3e\x2d\x21\x01\x36\xf0\x0b\xde\x29\x78\xe0\xd2\xf5\xa9\x7b\x3e\x1a\x96\x17\x52\x51\xb5\x20\xa9\xb3\x35\x2c\x56\x04\x60\x46\x11\x98\xf7\xce\x8a\x02\x73\x4f\xb9\xda\x53\xfc\x40\x87\xe0\x4b\x96\xf2\x72\x6d\xc9\xe2\x75\x60\xfb\x16\xb2\x61\xb9\x4c\x5a\xfe\x72\x13\x87\x0a\xa9\x04\x69\x72\xeb\x6a\xe4\x78\x18\x22\xa7\x8f\x53\xee\x1c\x34\x32\x1f\x83\x31\x0c\x6e\xfa\x5c\x2d\x40\xdf\x18\xc7\xae\x19\xae\xf0\xca\xc3\xdd\xfd\x1f\xb9\x86\xc7\x56\xfe\x78\x0f\x4c\xef\x91\xf6\x84\x74\x0c\x32\xe3\xff\x60\x50\x60\xab\x73\x0a\x2b\x09\x62\x77\x28\xfc\x95\xc9\x24\xba\x58\xae\xb1\x1f\x80\x7a\xc0\x6c\x6f\x98\xb7\xb0\xb7\x5f\x47\xe1\x01\x2c\x3a\x99\xc6\xbb\x3a\x9e\x40\xee\x46\x10\xd1\x01\x76\x01\xde\x37\x51\x19\xbc\x52\xdb\x2f\x41\x6a\xf5\xa8\x4d\xf5\xa1\x3b\x9f\x42\xd2\x44\x95\xca\xea\x8a\x85\xfd\x65\xe4\x21\x10\x29\x65\x10\x9e\xe0\xa5\x70\x5d\x82\x0c\xe8\xbe\xe2\x64\x21\x39\x81\xfb\xa8\xaa\xee\x57\xc8\x5e\xb8\x84\x55\x82\x67\x75\xb4\xf2\xa9\xdb\xc2\xc2\x4b\xe1\xbc\x08\x96\x70\x64\x35\x8a\x94\x9a\xa9\xfe\xb4\xe4\xe9\x2e\xc8\xf1\x8c\xb9\x5b\x6b\x9e\xd6\x9d\x93\x75\xe4\x5f\xf7\xe0\x5a\xc1\xcb\xa2\x03\xdd\x3f\xb8\x0c\xae\x19\x35\xc2\x1f\xa7\x84\xab\xbb\x69\x50\xef\x09\x10\x8e\x9c\xbf\xef\xb9\x09\x7a\xab\x63\x08\xc9\x22\x71\x61\xb2\xbc\x96\xcf\x11\x87\x45\xcc\x03\xaf\xd4\xbe\xfd\x8f\xd7\x6f\xbd\xb1\x7e\xcc\x26\xb2\x2a\x01\x82\xea\x8e\xf3\xa5\x4d\x59\xc6\xa0\x4e\xba\xaf\xc1\x6e\x1b\xc0\x35\x6f\x2e\xe7\x16\x99\xff\x22\xc8\x27\x9f\x94\x9e\x4f\x4e\x09\x3d\xae\x85\x2a\xb8\xb2\x2a\x82\xb1\x14\x1d\x6c\xb3\xea\x3b\xaa\x14\xba\x47\xc6\xc7\xde\xd9\x04\x4e\x9c\xb0\x32\x5f\xe6\xc5\x59\x54\x9a\x15\xb3\x00\x80\x80\x5f\x25\x73\xa2\x05\x2d\xf4\x4c\x42\x75\xfd\x84\x16\x34\xe1\x66\x41\x8c\xa2\xc9\x2d\xd4\xe0\x51\xcc\x7d\xae\x47\x92\x63\xe7\xac\x15\x83\xaf\xee\xf3\x6b\x66\x4a\x96\xd3\x19\xb8\xb1\x62\xab\x24\xa3\xda\xaf\x7e\x65\x7f\xa7\xca\x68\x92\x2e\x04\xcd\x79\x12\x32\xe6\x29\x39\xe7\x9a\x4b\x67\xca\xf5\xe3\x5e\x87\x8c\x67\x68\x1e\x3e\xcf\x28\xcf\xc9\x91\x66\x8c\x04\x94\xc0\x5f\x5c\x9d\x76\x34\x5b\xa8\xfa\x85\xbf\x0c\x39\xbb\x85\x4b\x34\x50\x11\xb8\x70\x33\x85\xfc\xd1\xce\x7c\xe5\x47\x8f\xc3\x76\xad\x9e\x93\x54\x70\x19\xef\x33\x55\x32\x91\xca\xe8\x4a\xf2\xec\x7a\xa8\x63\x55\x03\x71\xcb\xe5\x73\x83\x1f\x32\x29\xa6\x71\x98\x7e\x85\x99\x96\x94\x0a\xa8\x5f\x32\xe7\x69\x49\x33\x24\xa2\x6e\x32\xe7\xa3\x21\x76\xe7\xd3\x99\xe9\xdf\x31\x30\xb5\x20\xaf\xa9\xdc\x99\xfc\x47\xf9\x92\x2b\x0e\xd7\x40\x74\x8d\x33\x15\xa0\xd9\xca\x4e\xed\x8e\x2e\x20\xa7\x8b\x73\x1b\xa9\xdd\x86\xfa\x7c\x5a\x38\xc4\x2a\x88\xc3\xf4\xce\x42\x3d\x0a\x2b\x25\x80\x2d\xca\x82\x18\x30\x75\x79\x6e\x16\xf0\x51\x7e\xbb\xf0\xda\x95\x1e\xa3\x76\x83\xac\xe4\xb6\x59\x51\x79\x00\x89\x6b\x5e\x6d\xf2\x8d\xab\x0d\xd8\x51\x16\x38\xf8\x36\xb2\x89\x45\xb7\x18\xf6\xd8\x50\x91\xf6\x69\x66\x31\xe7\xfa\xf3\xb9\xf3\x52\xc6\x83\x50\xbb\xa5\xf7\x65\x7e\xb8\x08\x79\xa1\xad\xcc\xb0\xf2\x08\x40\x38\xfa\x98\xa5\x40\x34\xe2\x8a\x88\x77\x56\xfd\x75\x9b\x77\xfd\xf9\xbc\x47\xf8\x80\x0d\xfc\x5f\xa1\xa9\xa7\x5a\x46\x4e\xd1\xc7\x2f\xf8\x6d\x02\xde\xc1\x54\x62\x4b\x53\xdc\xf7\xef\xbf\xb5\x93\xb4\xbf\xfe\xae\xff\xdb\x28\xd3\xe6\xef\xfe\x6e\x89\xa0\xb2\x0d\xea\x6f\x63\x47\xb1\x90\x56\xfe\xef\xd7\x2e\xed\xb2\x4b\xca\xfc\x77\x57\x6d\x8a\x09\x63\xc5\xc4\x6b\x09\x57\xf0\x3c\x45\x6c\x84\x6f\x2b\xf6\x9d\xb7\x1a\x02\x98\x82\xc5\x26\xa1\x86\x09\x20\xd4\x3e\xa2\x42\x48\x83\xdd\x5d\x61\x55\x3b\xff\x23\xd0\xf7\x31\xf8\xab\x47\x8c\x94\x70\x1c\xf1\xc8\x9f\x09\xc2\x7c\x31\x4a\x5c\x2b\x80\x83\x3a\x2f\x34\xcf\x7b\xec\xb0\x16\xc2\x21\x3e\xd6\xce\x03\xe6\xf6\x0b\x21\xcd\x2f\xc2\xf6\x37\xca\x64\xd3\xb9\xe4\x3e\xc3\xb6\x3d\x29\x02\x4b\x16\x86\x9c\xcf\xe3\x05\xc9\xb9\x36\xf4\x96\x0d\xc8\xc8\xf2\x96\xf8\xaa\x0b\xa1\x27\x08\x64\x66\x64\x29\x29\x85\xe1\x19\xfc\x5a\x8d\x63\xa7\x1c\xf3\x9c\xe1\x84\xe8\x12\xea\x77\x17\x8a\xf5\x3d\x17\x73\xad\x96\x68\x41\xb5\x96\x5e\xd8\xec\x19\x45\xd1\xbf\x48\xa1\x2b\xc0\x83\x0a\x87\x5e\x4b\xbe\x59\x76\x9e\x52\x24\x15\xe7\x02\x60\xea\x01\xb9\x02\x66\x95\xf9\xfb\x5e\xd4\x42\x9c\x75\x52\xb0\x84\x69\x4d\xd5\xa2\x07\x99\xcb\x79\xc8\x76\xed\xdc\x71\x80\xa3\xe6\x54\x60\xde\x70\xc5\x12\x29\xb4\x51\x65\x62\xb0\x90\xdc\x58\xc9\x5b\x26\x82\x2f\xa0\xdd\xc5\xba\x53\x56\xe5\x1c\x03\x97\x59\x92\x24\x33\x2a\xa6\x51\x21\x96\x9c\xa6\x00\xfb\x6f\x82\x94\xe3\xd7\x63\x21\x40\x27\x56\xb0\xe0\x06\x40\x31\xb6\x7c\x24\xd8\x58\xff\x22\x88\x57\xa3\x7b\x95\x11\xd4\x2e\x89\x67\x5b\x68\x57\x27\xfa\x45\x3a\x5a\xec\xfa\xc0\xb6\xf7\xec\xd4\x95\x33\x43\x53\x6a\xe8\x0e\x8e\x5d\xef\xab\xea\x71\xbe\x80\x3c\x56\xf0\x0c\xb7\x8e\x8e\x0f\x79\x71\x4b\x16\x3c\x0e\x5e\x82\x93\x38\xf3\x90\x87\x68\x68\x63\x71\xca\xdd\x02\xa0\xbf\x16\xc8\x33\xbe\x3c\x97\x1d\xde\x8f\x86\xe4\xa2\xaa\x3d\x58\x91\x93\x76\x77\x4c\x1d\xcd\xab\x16\xf4\x3b\xc0\xe8\xa6\xba\x08\x4b\xea\xce\x5b\x2b\x45\x10\xe4\x12\x4c\x18\xae\x58\x1c\x2b\xe6\x40\x57\x0a\x44\xf2\x06\x10\x01\xca\x53\x66\x74\xe5\x7e\x82\x74\xd8\x12\x17\xc7\xef\x9c\x32\x0a\x44\xda\x01\xd6\xe9\x73\xab\x65\x21\x04\xbb\x96\x8e\xce\x5a\xca\xff\x20\x70\xdd\xc5\xa2\x8c\xf9\xf2\xdf\xcb\xb4\x8b\x11\xba\x91\x66\xbe\x1a\xa2\xf2\xc9\x44\xef\x5a\x0d\x4a\x3d\x7e\x03\xae\xa2\x74\x2d\xe2\x0d\x89\xdc\x8c\xce\x77\xb7\x40\x55\x32\x52\x3f\xa4\xe8\x85\xcf\xf5\xe1\x73\xfd\xd7\xed\x2d\x75\x5d\xdc\x3b\xfc\xd3\xda\xcd\xa3\xfe\x91\x4e\x66\x51\x4b\x52\x46\x1d\x6d\x99\xcd\xfc\xe1\x81\xda\xbb\xcb\xc1\x70\x21\xeb\x02\x18\x18\xb7\x74\xe2\x94\xfc\xa2\xc6\xdf\x9d\x1c\x15\x74\x24\xf4\xbb\x3d\xf2\x4a\xd3\xc0\x6d\x82\x0f\x0f\xaf\x37\x3f\x6e\x0c\x06\x82\xc5\x6a\x5d\xc2\xfb\xf7\x06\x61\xcf\x0a\x66\x0a\xac\x64\x3e\xac\xc0\x22\x96\x92\x59\xc6\x14\x2c\xc1\xe9\x4d\x8d\xcb\x71\xc8\xec\x89\xa6\xda\x5e\x50\x4e\x83\x74\x29\xd8\x5d\x10\x23\xa8\xc6\x1c\x2a\xfe\x22\x8b\xb9\x9a\x70\x6b\xc7\x0b\x3e\xc8\x67\x62\x81\x53\xbf\x08\xdb\xe2\x95\x4e\x32\xb5\x1f\xb2\xf2\xa6\xa0\xe3\x0c\x2f\x85\x03\xe0\x61\x2e\x34\xbb\xa3\x0b\x0d\x18\x5f\xc9\xf1\xe1\xfb\x2e\x5f\x59\x35\xf0\x47\x36\xc1\xde\xad\x2f\xba\x76\xba\xea\xda\xe5\xb2\x0b\xa2\x20\xb9\x68\xe3\x59\x54\x75\xd8\x58\x13\xa3\xf9\xec\x72\x3b\x06\xee\x27\x70\x2b\xde\xed\xaa\xa3\x9e\x80\xf4\x7a\x08\x43\x78\x69\x7c\x0a\x7f\x78\x5e\x13\xee\x02\xc6\xcc\x62\x75\x15\xdf\x0c\x18\x12\xf7\x5d\xe1\x20\x50\xa1\xd6\x37\x90\xa4\xd4\x99\x83\x43\x11\x2d\xc5\xc0\xc1\x03\xbe\x38\x80\x24\xfc\x54\x2c\x1c\x0f\x37\x33\xae\xd2\x7e\x41\x95\x59\xa0\xe2\xd8\xab\x7d\x2d\x38\xcb\x77\x5a\xf8\x8e\xb7\x34\xed\xf2\xff\xae\x85\x30\x2c\xde\x17\xc2\x73\x66\xf8\xb5\x70\x7d\x8c\xf5\xb4\x77\xc7\x5f\xb9\x9e\xab\x28\x3a\xdd\xeb\x82\x4f\xb6\x9e\x34\x26\x1f\xbb\x72\x8c\xc6\x1d\x2a\x12\xfe\xb8\x0e\x93\x8c\xdd\x99\x03\x47\x07\xe5\xc7\x4e\xa0\x67\x75\x4e\x5a\x15\xce\x8e\x8c\x78\x4e\x2a\xf0\xce\x30\xae\x6c\x8f\x58\x38\x33\x4d\xfc\xad\x78\x80\x70\x2e\xc8\x91\x90\x02\xcf\x0a\xb6\x3d\x46\x5f\xa0\x35\x76\x28\x68\xe2\xea\xad\xd5\xcb\x5d\x46\x67\xd3\xb3\x05\x2e\x52\xbb\x59\x40\xab\x41\x1f\xd2\x65\x92\x30\x16\x34\xe8\xb8\xfa\x4a\x75\x96\xdd\x94\x7d\xdd\x46\x2d\x21\xb1\x8a\x36\x34\xcb\x2a\xcd\xd5\x81\x4b\x02\x67\xf3\xd6\xbe\x88\xe1\xd5\x02\x65\x9c\x12\x0f\x15\xc1\x5d\x96\x4a\x91\xe0\x5d\x3c\x37\x0b\x3f\x83\x98\x03\x41\x37\x50\x19\x34\x2a\xb4\x7c\x82\x36\xa6\x48\xf4\x0f\xc0\x04\x62\xe4\xea\x91\xd7\x79\x91\x4b\xa2\x60\x29\xcf\x98\x26\xb7\x77\x54\xa5\x50\x97\xb6\xa0\x86\x63\x5a\xec\x5e\x6d\xd8\xa3\x68\x0e\x50\x15\x3e\x46\xbe\xe3\xa0\x60\x40\xb1\x0b\xd9\xf8\x0c\xa1\xa5\x91\x39\x35\x3c\x01\xb5\x95\x4f\x22\x8b\x61\x1e\xb2\x08\x36\x6a\xe8\x01\x5d\x0d\xd5\xd8\x6f\xf0\xe6\x45\x31\x62\xee\x24\xe1\xb9\x95\x09\x28\x94\x83\x98\x84\x88\x1f\x6f\xdb\xdc\x34\x53\x2b\xf8\x7c\x0b\x06\xe5\xa8\x15\x2a\xc4\x56\x5d\xd2\x30\x7c\xb0\x5e\x06\xb3\x9d\x0b\x99\xe9\x35\x58\xb6\xeb\x63\x71\xda\xce\x35\x42\xd5\x9e\xdd\x9e\x3b\x66\x25\x01\xbd\x11\x61\xf5\x60\xd5\x8c\xb0\x40\xab\x26\x29\xd7\x8d\x2a\xcb\x47\xa9\x92\x45\xe1\x8c\x21\xf9\x71\x73\x46\x70\x47\xa0\xe6\x4c\x47\x85\x84\xd1\x2c\x3d\x65\x22\x54\xc2\x76\x79\x27\xe0\xe4\x36\x3f\x51\x3b\x30\x03\x72\x74\x96\x15\x33\x7a\x4c\x3e\xb9\x82\x39\x01\x73\x83\xff\x5c\x2b\x59\x09\x4d\x2b\x4e\x5c\x7a\x11\x72\xda\x3e\x2f\x42\xce\x8b\x90\xf3\xd3\x16\x72\x82\xe3\xd6\xae\x02\xce\xc7\xe0\xad\xd8\x28\xaf\xed\x6f\xfe\x2b\x77\xc6\x75\x16\x8b\xe1\x84\x7c\x64\x89\x9c\x33\x85\x44\x0e\xca\x58\x5a\x66\xfe\x96\xf2\xcc\x92\x38\x4f\xea\x2a\x8d\x10\xb2\x99\xd6\xed\x70\x91\x12\x1e\xa0\xe9\xd0\x3c\x77\x93\x72\x31\x7b\xb6\xbd\xbb\x11\x2b\x14\x9b\x73\x59\x6a\xef\x9f\x50\x1a\x3c\x66\xda\x38\x86\x3b\xe3\xd3\x90\xe5\x3a\xdc\x6b\x2a\x96\x48\x95\x56\xc1\xe1\xda\x50\x53\xea\x7a\xc4\x43\x82\xa6\xb3\xfd\x59\x63\x02\x1c\x1f\x98\xba\xef\x46\x49\xd1\x3d\xe3\x1e\xa7\xe2\xf0\x1d\x3a\x78\x54\x55\xa4\x4d\xe4\x73\x52\xf9\xbb\x58\x19\xaa\x34\x2c\x42\x2b\x87\x00\x9d\x61\x5d\x8b\x5f\x3d\xc1\xca\x25\xfd\x30\x6c\xbf\x72\x31\x69\x91\xbe\x3c\x7e\x76\x82\x3a\xb9\x47\xa8\x66\xfc\x3c\x63\x2f\x93\xc6\x62\xbb\xfb\x51\x92\x7b\xfa\x52\x92\xfb\xf8\x53\x92\x7d\xfa\x54\x92\xe0\x99\x7d\x9f\x13\xf3\xd1\xfb\x84\x37\xce\x8c\x23\xbc\x9b\xce\x4c\x2d\x23\x40\x18\x87\x6b\x5f\x15\xcf\xdd\x61\x86\x33\x00\x56\xc0\xd8\xb3\xd7\x9d\x56\x50\xe7\xf0\xa2\x92\x7d\x09\xf9\x77\x23\x39\xa6\x2a\x11\x6d\x24\xb8\x1b\xe4\x05\xa6\xf2\x81\x53\xd7\x77\xfe\x57\x5e\x5d\x7a\x39\xc1\x2f\x27\xb8\x6d\xff\xa7\x3c\xc1\xe8\xbb\xdc\xc5\xb5\xbe\xae\x33\xe0\xd5\x24\xf9\xbe\x64\x6a\x41\xac\xe0\x53\xf9\xef\x40\xa2\x61\xcd\x53\xe7\x01\xe3\x2c\x29\xed\xe5\xf4\x47\xe4\xf9\x60\xa7\xb9\xfc\x62\xa5\x3e\x88\x42\xbb\x07\x2d\x6b\x0e\x55\x0f\x34\x46\x68\x79\xa0\xd7\xa4\xba\x81\xcb\x40\x16\xc9\x79\x56\xc4\x3b\xbb\xba\xd8\x4d\xb9\xe9\x76\x6b\x45\x76\xb9\xb9\x5a\x5a\xfc\xd9\x86\x05\x22\x20\xc2\x2f\xf5\x1a\x4b\xc1\xfe\x40\x6e\xd9\xa2\xe7\x2e\xba\x5d\xee\x74\xdf\x18\xfd\x35\xea\x09\x3f\xdb\x26\x9a\x58\x05\xa0\x1d\xa8\xe2\x6e\x16\x03\x7c\xda\xa7\x88\xac\xf7\xf2\x40\xe8\x4a\x7c\x77\x26\xdb\x9d\x52\x49\xc6\x4f\x0d\x15\x5c\xfa\x53\x70\xd4\x03\x9c\x80\xb4\x79\xde\x71\x39\xa0\x01\x38\x6b\x03\xb5\xe8\xba\x89\x64\x77\xb5\x17\x1f\x0f\xd8\x7b\x2f\x35\xa0\x69\xcd\xf3\xf6\x96\x2d\x0e\xb5\x8b\xf9\x93\x42\xcf\x78\xe1\x33\xb5\x03\x25\x70\x98\x4b\x3e\x83\x03\x80\x1f\x02\xcf\xfc\x50\xf4\xc8\x95\x34\xf6\x7f\x97\xe0\x0b\x84\xe6\x49\xc9\xf4\x95\x34\xf0\xe6\xd1\x81\x85\xd3\xbd\x37\xa8\x9c\x6d\x92\x83\x6d\x11\x7d\xd6\x20\xde\xc2\xfb\x98\x00\x48\xdc\xb5\x6a\x00\x2b\xd7\x64\x28\x88\x54\x1e\x26\xc6\xa7\xf6\xd5\x6e\x08\x6f\x4f\x8a\xcc\xc0\x2b\xc6\x70\xa0\x94\xaa\x06\xc9\x0d\xc3\x05\x8b\x32\xf7\xbf\x80\xbd\x09\x4c\xf0\xc1\x31\x06\x12\xd4\x52\xc3\xa6\x3c\x21\x39\x53\x53\x88\xee\x4c\x66\xbb\x6f\x50\x77\xba\x8d\xcf\x4e\xd4\x3b\xfe\x70\x67\xcc\x00\x56\xf7\x0e\x5c\x93\xee\xcb\x30\x71\x14\x64\x11\x39\x2d\x2c\x52\xfc\xd3\x72\x02\xd8\x97\x7f\x43\x42\x69\x3d\x20\x67\xbe\xca\x67\xfc\x9b\xb3\x5c\xc4\xc3\xd8\x11\xac\x1c\xff\x7d\xc9\xe7\x34\x63\xe8\xb0\x47\x45\xc8\xbd\x29\x27\x4b\x6c\xba\xe7\xb2\x4a\x5b\x2a\x15\xae\x83\x0e\x6e\xd9\xe2\xa0\xb7\x84\x48\x07\x43\x71\x50\x85\x58\xd7\x50\x27\x30\x34\xb8\x29\x38\x80\xdf\x0e\xf6\xcd\xd9\x9f\x48\x9c\xdf\x01\x4b\x9c\x11\xe8\x3c\xa3\x5a\x77\x8b\x4e\x5d\x9f\xe3\x6c\x14\x8d\x59\x45\x09\x39\x37\xcc\xbd\xdb\xaa\xc0\x5d\xbf\xbb\xcb\x50\x27\x28\xcd\x5d\x89\x92\xf6\xe9\x15\x9a\x54\x35\x0c\x10\x82\x31\xee\xe2\x78\xb6\xea\xa6\x75\x0d\xbc\x3e\x83\xcd\x50\x4e\xe2\x9c\x8c\x5c\x83\x8a\xcb\x7d\x78\x86\x90\x86\x70\x91\x64\xa5\x33\x17\x42\x57\x50\x90\xbb\x8a\xf4\x3b\x00\xe7\x1e\xc8\xf3\x39\x0c\xe0\xe5\x11\x7f\xa7\xbb\xe4\x89\xdb\xbc\x7e\x83\x0b\xcf\x70\x9b\x85\xb0\xda\xf7\x5a\x27\x5b\xfc\x1e\xeb\x29\x33\xcf\xeb\x32\xc6\x5b\x3e\x56\x8c\x9c\xcf\xa8\x10\x2c\x8b\x62\x52\x9d\x21\x23\x94\x89\x02\xc1\xc3\x15\x87\x3a\xac\x57\x87\xf2\x74\x4c\x84\x08\xe8\xbd\x57\xc8\xfd\x61\x17\x6b\xda\x5b\xb5\x6d\x97\x39\x71\x26\xef\x48\x2a\xc9\x1d\xd4\x0b\x98\x5b\x76\x04\x77\xac\xda\x33\xb2\x68\xa6\xe0\xf1\x90\xc8\xbc\x50\x32\xe7\xda\xfb\xb5\xbb\x8d\xdb\x6b\x10\x67\x56\xb6\xc8\xcd\xb3\x2e\xa9\xcb\xdb\x73\x62\xa8\x9a\x32\x63\x87\x21\xa2\xcc\xc7\xac\x75\x88\xe9\x43\x24\x05\x7b\xee\x55\xa8\xf6\x5b\x48\x0a\x41\xff\xed\xb7\x57\x9d\xcb\xcd\xae\xda\xc1\x3b\xa9\xb2\xf4\x8e\xa7\x78\xa1\xa7\xc9\x91\x1d\xf8\xf8\xf9\xd7\x86\xbd\xbb\xe3\xe9\xfd\x00\xe0\xfd\x95\x2c\x00\x08\x40\xc0\x55\x47\xe2\x90\xb7\x1a\x3e\x70\x4c\x2e\x39\x46\xfc\xd8\xbf\x30\x33\x4c\x3e\xe6\xa2\x8a\xfa\x0a\x9b\x01\x74\xd5\x9e\x07\xaf\x4d\x68\x66\x30\x56\x03\xc2\x1d\xa4\x99\x11\xcd\xf3\x32\x33\x54\x30\x59\xea\x6c\xd1\x1a\x2d\x9e\x06\xc8\x93\x8c\x7d\x41\x2c\xee\xc2\xaf\x42\xa7\x3a\xdf\x02\x17\x93\x2a\xb4\x71\x89\x71\x55\x4e\x50\xe9\x49\x60\x62\x21\x04\x88\x7d\x61\x89\xf3\xd7\x2d\xb2\x72\xca\xb7\x84\x24\xfc\xc4\xd2\x88\x57\x89\x9a\x4b\xcd\xaa\xe8\xf9\xb6\x85\x52\x9e\x2e\xeb\xf7\x83\x32\xeb\x9b\xd5\xa9\xbd\x53\x56\x30\x91\x42\xd6\xb1\x08\x57\x71\xba\x7b\x85\x95\xcb\xe0\xb5\x3b\x85\xba\xfc\x62\x14\xb5\xe4\x26\xb7\x84\xc5\x27\x04\xe3\x13\x42\x45\x7b\xd2\xf1\x3c\x32\xed\x92\x9f\x1c\x8f\x7e\xf0\x42\xcc\xf7\xcb\xef\x8e\x54\xd4\xa1\xbd\xae\xbb\xe1\xae\xc8\xc3\xee\xbe\x52\x77\xff\xbb\x5f\x3e\x76\xbd\x22\x05\x75\x63\x56\x2f\x05\x2a\x7f\x10\xc9\xd9\x27\x10\x69\xdb\x25\x65\xd1\x5b\xec\xd1\xd0\x6c\xdd\xcb\x66\xc1\xe3\x0d\x9a\xac\xc3\xdb\x88\xa4\x43\x7e\x50\x37\x90\x8b\x16\x22\xda\xc2\xb2\x72\x4f\x2b\x85\xd8\x46\xac\x1e\x22\xe7\x36\x35\x54\x33\xd3\xce\xaa\xb1\xec\x72\xe7\x39\x3d\x8e\x82\x49\xde\xc1\xcd\xdb\x87\x9b\x92\xfe\xef\x9c\x4c\x20\x6a\x2d\xad\x34\xe0\x01\xe2\xb3\x1a\xb1\x70\x4d\x8b\x63\xa4\x76\x1b\x12\x6a\x5a\x57\xa4\x69\x45\xef\xdd\x0c\x3e\x7d\xea\x5c\xb6\xd4\x76\x69\xac\xd8\xed\x34\xe4\xbd\xe1\xdf\x97\xb1\xa4\x0e\xb9\x20\xc2\x1a\x5d\xfb\x7d\x2d\x64\x9a\xb0\xca\x44\x74\xc1\xf5\x6d\x97\xc4\x5c\x7f\x38\xbf\xac\x77\xae\x23\xfc\x1f\xce\x2f\x89\x7b\xdb\xca\x8a\xd3\xc5\x8c\x73\xdf\xbc\x51\xd3\x84\x55\xa6\xd1\x94\xeb\xdb\x47\x2f\x0a\x5e\xa4\x57\xdb\x7c\xa8\x1f\xdb\xca\xe4\xf3\x98\x44\x09\x76\x16\xb2\x24\x77\x2e\x3f\x80\x13\x6a\x6f\x78\x71\x4a\x2e\x85\x2e\x15\xab\x6e\x3f\x9b\xf2\xad\xe5\xa4\xcf\xa9\x78\xf8\xbd\x70\xe3\x39\x9b\xb9\x0a\xaa\x0c\x48\xb6\x9d\x73\x95\x41\x3a\x7e\xd7\xd9\x2f\x61\xcb\xd6\x0f\x27\xde\x07\xad\xe7\x62\x9f\x43\x42\x2f\xdf\xc8\x6e\x76\x94\xee\x23\xde\xde\xb7\x21\x15\x0e\x39\x49\xd9\xfc\x44\xa7\xf4\x75\x0f\x3e\xe3\x7d\x83\x4d\x6d\x4e\x54\x93\x83\xd7\x07\x03\x32\xe2\x39\xcf\xa8\xca\x16\xb5\xfc\xc3\x55\x3b\xcb\x02\xfc\x80\x70\x99\xf5\xea\x80\x1c\x49\x05\x23\x27\x54\x90\x8c\xf9\xe8\x1f\x77\xa0\x16\x28\x02\x1e\x3f\x36\x15\x21\x0f\x6a\x23\x44\x82\xd2\x15\x0d\x3e\x21\xbb\xa9\x25\x77\xb9\xa8\x28\x36\x17\x96\x8c\x0f\xc8\xa7\x55\xe5\xb5\xe1\x6c\xf8\x16\x4f\x05\xca\x07\xd5\xcd\xee\x59\x9b\x7f\x49\xa1\x7b\x3a\x30\x6d\xd7\xea\xa6\xdc\x7c\x64\x85\xec\x24\x00\x60\x97\x86\x25\x8c\x1b\xfb\x42\x6a\x0e\x39\x39\xa9\x81\x0a\xb7\xca\xf0\xa4\xcc\xa8\x95\x89\xd1\x0e\x36\x20\x17\x97\xd7\x1f\x2f\xcf\xcf\x6e\x2e\x2f\x4e\x89\x1f\x89\xc7\xd2\xda\x80\xdc\xc4\xb9\x91\x22\x97\x57\x97\x80\x26\x7c\xab\xe7\x88\x0f\x15\x55\xaa\x43\xc8\x78\x41\x05\x19\x0a\x6e\xaa\x4c\xc0\xe8\xa4\x95\x49\xe1\xdc\xae\x6c\x6f\x67\x87\x9b\x72\x74\x9d\x10\x6e\x30\xfb\x73\x7d\x34\x38\x1d\x98\x55\x34\x4c\x65\x8b\x16\xf7\x00\x92\x43\x05\xdc\x7d\xc9\xee\x3e\xf9\x67\xc7\xe3\x71\x83\x06\xf6\x2a\xff\x2a\x52\xfc\x90\x72\xdc\xe7\x7a\x59\x51\x8c\x99\x58\x5e\x72\x38\x38\xf4\x82\x42\xb6\x94\x5e\x3e\x0c\x1a\xa7\xb3\xaa\xe3\xd6\x80\x90\x0f\xde\x85\x19\x62\x71\x57\x67\xaa\xc7\x04\x09\x51\xbe\xf3\x06\x86\xfa\x40\x91\x72\x1c\x7f\xd4\xe5\xbf\x9a\xf2\x39\x13\xb8\xb0\xfd\x12\x24\xff\xf9\x8e\x30\xff\x58\xcd\xfb\xd3\xc7\x77\xfb\x9d\x12\x9e\xb3\x8e\x13\x3a\x97\x79\x8e\x59\x91\x66\x21\xb2\xae\x0a\x8e\x0b\xa7\x7d\x6f\x0a\x0b\xe6\x77\x9a\x6c\x41\xea\x06\x9d\xf2\x9d\x1a\x0a\x4a\x78\xed\xbc\xf1\x45\x25\xa7\x76\x4f\x25\xec\x52\x89\x69\x9f\x28\xc4\x91\xec\x93\x30\xe3\x93\x8f\x97\x67\x17\xef\x2f\x07\x79\xfa\xe8\x24\x83\x89\xb4\x90\x5c\x18\xbd\x5d\x2d\xd9\x56\x38\xa5\x3d\x59\x09\x1f\xed\xca\x75\x2f\x7d\xc7\xd8\xc5\xc1\x8f\x16\x65\x60\x4b\x99\xa1\x3c\xd3\xd1\x3e\x1a\x59\xc8\x4c\x4e\x57\xe7\x15\xee\xb0\x41\x3f\xc3\x7c\x2a\x7d\xda\xb7\x3b\xbf\x5f\x79\xbd\x4d\x39\x88\x3a\x3c\x7c\xf9\x07\x0b\x86\x6a\xad\x41\x0e\x86\xaa\x0d\xcf\x74\xb9\x0f\x22\x78\x2d\xc1\x00\xb5\x41\x38\xc4\x3e\x39\x5d\x95\xed\x2d\x2a\xc5\xd2\x56\x22\x7b\x68\xd0\x6d\x17\xc6\x2c\x0d\xda\x5e\x6f\xa7\x0e\xb3\x3f\xba\x3e\x75\x22\x57\x28\xd6\x0f\xe9\x89\xa0\x42\x88\x54\x11\x77\x8d\x69\x9e\x37\xbc\x78\x33\x0d\xb6\xca\x16\x4d\x03\x4c\x25\xfb\x04\xab\x15\x46\xd8\x67\xd9\xa2\x4a\x78\xe8\x54\x61\x3a\xc5\xb4\x43\xca\xd9\x6f\x0b\xc5\xe7\x3c\x63\x53\x48\x3a\xca\xc5\x34\x8a\xfd\x8c\xa3\x45\x5d\x12\xd2\xba\x35\xf4\xbd\xfd\x2b\x4a\x2f\x0d\x78\x71\xf5\xe1\x06\xf2\xd7\xc2\xa5\xe0\xbd\x05\x6c\xfb\x41\x28\x66\xd2\xef\xf7\x41\xef\x3f\xfa\xce\xca\x8a\x69\x76\x4c\xbe\x65\xee\x3b\x12\x12\xec\x2a\xa8\x68\x33\x93\x21\xdb\x29\xcc\xb5\x82\x2c\xa0\x23\x5e\x9a\xbb\x56\x27\xb6\xa5\x15\x8c\x90\xdd\xd4\xda\x43\x01\x4f\x4c\x52\x88\xf7\x3d\x8f\x2f\x57\xee\x91\xf4\xef\x4c\xe5\xbc\x55\x74\x15\x7e\x86\x1b\x99\xc2\xd1\x43\x4a\xf4\x22\xcf\xb8\xb8\xad\xf2\x60\x4d\xa4\xc5\x21\xf4\xd1\xe7\xe2\xd6\x63\xac\x62\x34\x5b\x4f\x29\x77\xc1\x8f\xbd\x52\x49\xb3\x83\xf1\xee\x66\x51\xe0\x5d\x78\x38\xf6\xee\xaa\x37\x26\x71\x07\x07\xcf\x6e\xbd\x5c\x77\xab\xe6\x7e\x38\x1c\x9d\x8f\x6a\x95\x48\xad\x4e\x07\xef\x1e\xd3\xb8\xbc\x8e\x25\xc0\x72\x9e\x50\xb2\xe3\xdf\x6f\xbb\xa9\xed\x93\xac\xdc\xde\x06\xdd\x7c\xae\xa5\x32\x34\xdb\x13\x11\x48\x66\xb4\x38\x2b\xcd\xec\x82\x6b\x48\x20\xd0\x55\x08\xb8\x9b\x61\x2e\x62\x9f\x06\x8f\xfb\x4d\xc7\xd1\xc8\xf9\x1f\xcf\xae\x09\x2d\xed\x2e\x1a\x97\x2c\x73\xaf\x57\xdc\x7e\xfe\x23\x74\xa8\xdf\xcb\xec\xdd\x58\x0f\x3e\xf7\x97\x0b\x81\x3d\x5e\x08\xc0\x19\x7f\xce\x97\x00\x5c\x70\xc3\xa9\x91\x2d\xeb\x65\xd5\xf5\xf7\x52\x1b\x99\x3b\xf4\x1c\xfa\x81\xe0\x56\x16\x18\x6e\x6d\xec\x7a\x29\x00\x10\xb4\x01\x38\x43\x61\xc5\x62\x9a\xb0\x86\x07\x60\x0f\xf2\x51\xe2\xd8\x3c\xb4\xf9\xad\xf3\xcc\x84\x44\x56\xd9\xef\x4e\x6b\xf9\xc1\x97\x8a\x2d\x78\xa3\x42\x95\xc9\x7f\xaf\x96\x18\xfe\x7d\xd7\x93\xed\xcc\x5e\xb8\xaa\xff\x2d\x69\x86\xd0\xb8\xda\xb7\x8d\xa8\x0e\xd9\x8e\x93\xf4\xfb\xe9\x61\x7e\x15\xb4\xe6\x52\x63\x1e\x2c\x6c\x61\x14\x15\xda\x6e\x44\x5d\x37\x3a\x74\x57\x3b\x87\xe4\xc8\x24\x45\xeb\x92\xf0\x0f\xe4\x99\x8d\x53\x75\x70\x7f\x17\x3c\xb2\xdb\xce\xea\x41\x6e\x5b\x00\x77\xbb\x9a\x36\x6a\x0b\x41\x66\x4b\xde\x71\x6d\x7c\xb2\x7f\x78\xc1\xb5\xcb\x54\x0b\x92\xce\xb5\x55\x9d\x78\xf1\x37\x9a\xa6\xea\x14\x39\x89\x2f\xdb\xab\x40\xde\xf1\x39\xa5\xa8\x08\xf7\x71\x47\x66\x51\xb8\x84\x73\x37\xe7\xd7\x04\x8b\x6f\xfc\xe6\x57\x58\x32\xf4\x3f\x7f\xf9\xab\x57\xad\x37\xf4\xe9\xdc\x9f\x77\xb4\x1c\xec\xfd\xc6\xe6\x59\x78\xcd\x81\xb8\x80\xfe\x72\x40\x0f\xdd\xd9\x45\x3c\xb2\x9b\x1a\xa8\xf4\x6e\x42\xc5\x8b\x87\xd9\x93\x7a\x98\x91\x10\xf4\x80\x34\xe1\xfe\x54\x05\x09\xca\xf5\xf3\x23\x28\x5b\x61\xb1\x1d\x6b\xea\xd8\x82\xe7\xd7\xea\x77\xd1\xed\x13\xf8\x5c\x5f\x5c\x8d\xfe\xf6\xee\xec\xcd\xe5\x3b\x98\xa5\xf3\xab\xb2\x68\xc0\xc5\xce\x7e\x44\xed\xd1\xaa\x8d\x26\xb8\x1d\x18\xdd\xee\x39\xae\xde\x8e\x1a\x8a\xb2\x7d\xd3\xf1\x72\xe3\xbe\xd2\xb2\x98\xb4\x5a\xfb\xe3\x9a\xae\xa0\x18\x06\x53\xfb\x0b\x71\xd8\xd9\xc2\x15\xa5\x64\xaa\x29\x43\x76\xa7\x70\x86\xf7\xd6\x57\xb6\xee\x00\x79\x06\x46\x7c\xbb\x5e\x84\xc1\xde\xcd\xf7\x0f\x04\xab\xb6\x2c\x5e\x75\x8f\x7d\x39\x1c\x41\x2f\x7f\xc9\x63\x0f\x29\x7a\xe4\x28\x4b\xaf\x2d\xa5\x66\x3a\xa4\xee\x7f\xa6\x98\x52\xac\xca\xf4\xdb\x85\x7a\xad\x4c\x15\x5c\xab\x72\x55\xbb\xd8\xa8\x45\x0c\xac\xcb\x8c\xed\xef\xf6\xa9\x53\x2f\x75\x41\x93\xbd\xd6\xe1\xa8\x5e\xe1\x1b\x08\xa9\x7e\x7c\x02\x08\x9f\xdd\xa3\x43\x69\x18\xaf\x2b\x22\x9f\xfb\x8e\xcd\x40\xae\x4e\x3b\xe4\xab\x44\x14\xd2\x07\xc9\xc5\x11\x5f\x4f\xbc\x7d\xe4\x51\xa8\xe7\xb7\x3b\xaa\x2e\xfb\x56\x5b\x8a\x99\x34\x52\xec\xec\x24\x7e\xbd\xa2\x7b\xfd\x1c\x63\x8b\xf3\xaa\xf4\x49\x54\x11\x10\x3c\x0c\x83\x41\xdf\x8a\x71\x9e\x4b\x48\xe1\x4d\xfb\x75\xc3\xfe\xa3\x4b\x1e\xe9\xf0\x62\x4f\x67\xee\x87\x14\x7c\xd8\xd5\x04\xbb\x57\x17\x8a\xb4\x73\xc4\xc5\xf0\xc2\xc9\x5d\x3e\xaa\x42\x3b\xb4\x23\xeb\xf1\x6e\x6f\x7c\x51\x2a\x73\x27\x55\xf7\x50\xe3\xeb\x5a\xc7\xc6\xad\xbe\xfb\x6d\x29\x9a\xe8\x39\x9e\x11\x9c\xe3\x13\x9f\x93\x11\x5c\x98\x36\xf2\x60\x37\x4f\x46\xf0\x62\x7f\x80\xc3\xf3\xb4\x87\x66\x47\x2e\xf4\xb0\x21\xa9\x7b\x15\xbc\x3d\x96\x75\x5c\xe1\x67\xd7\xcd\x19\x08\xec\xde\x54\x44\x82\x86\x43\xe8\x86\xdf\x1b\x51\x50\x12\xab\x11\x76\xa0\x07\x43\xc3\x72\x2c\x28\x4c\xb3\xcc\xc2\x52\x8a\x38\x6d\xb0\x0b\x3b\xed\x11\xcc\xbc\x9b\xd3\xc2\x17\x65\x96\x77\xe2\x8e\xaa\x94\x9c\x5d\x0f\xf7\x73\xf4\x3b\xb8\x16\x23\xfe\xb4\xcb\x04\x55\x2f\x16\x29\x53\x46\xc6\xdc\xe8\xaa\x8c\x1b\x33\xb1\x36\x68\xc9\x5b\xb8\x23\xb2\x87\xd4\x1e\x48\xf7\xbd\x88\xfb\x09\x22\x13\x43\xb3\x46\x91\xfb\x57\xaf\x5e\xa1\xf1\xea\xd5\xaf\x7f\xfd\x6b\x2c\xad\x93\xb2\x84\xe7\xcb\x0d\xa1\xd5\x7f\xbd\x7e\x3d\x20\x7f\x3a\x7b\xff\x0e\xca\xfc\x15\x46\x63\xba\x0b\x1c\x19\xcb\x7e\x47\x9d\x75\x8f\xfc\xcf\xe8\xc3\x55\x55\x26\xa4\xfe\xab\xab\x9e\xec\x96\x37\x20\x17\x91\x0b\x50\x6c\x9e\xa2\x66\xe6\x2a\xda\x18\x42\x27\x13\x2c\x5e\x39\xf6\xb5\x53\xf1\x48\xf9\xc8\x66\x28\x01\x8d\xf5\x27\xec\xf6\x67\xe0\x9b\x64\x15\x69\x34\xe6\xf9\xe0\x7a\x74\xb5\x82\xb1\x02\xfd\x83\xa9\xf4\xb0\x70\xf8\x44\x43\x15\x8a\x2a\x15\x9c\x62\xda\xca\x94\xae\xa0\x1e\x0e\x16\xa6\x6e\x27\xf1\x94\x77\x30\xad\xab\x23\xd4\x10\xcb\x27\xae\xad\x8a\x90\x7f\x87\xd7\x8a\xdb\x9c\x63\x1f\xe8\x4e\xa4\xce\xf3\xc3\x6c\x70\xaf\x5c\xc8\x7a\x20\x17\x84\x66\x12\x6a\x37\x85\xad\xad\xf8\x51\x54\xd2\x7c\xfb\x52\x3a\x67\xde\xeb\x9a\x7d\x15\xa9\xd0\x7b\xda\xba\x7e\x4b\xdd\xa4\x1d\x85\xf6\xd3\xb1\x2c\x8d\xbf\x02\xc6\x31\xb1\x68\x21\x56\xce\xee\x90\x39\x70\x87\x64\x83\xbb\x24\x9d\xed\x9c\xb7\xb2\x4e\xe6\x6b\x42\x40\x8f\x30\x9a\xcc\xc8\x2d\x5b\xf4\x91\x30\x15\x14\xa2\x51\x42\x6d\xac\x7a\x65\x8b\xaa\x38\x89\x95\x6c\x1d\xb0\xfc\x8d\x7a\x85\x45\x21\x9a\xc5\x8b\x8f\xda\x49\x3a\x2e\x67\xa4\x88\x14\x78\x9f\x98\x38\xaa\x2e\x1b\x92\x44\x62\x69\xe9\x7a\xd4\x85\x3d\x5f\x2c\xb5\xdd\xf4\xa6\x2f\x57\x6e\x04\x96\xd0\x39\x56\x55\x8a\xa5\xde\xae\x94\xb2\x13\xdb\xe0\x83\xd4\xa7\xe2\x8d\x5c\x11\xa0\x60\x9b\x2b\xd5\xe3\xda\x7a\x28\x05\x40\xd4\xa2\x42\x34\x33\xa5\x03\x0d\x56\x84\x2a\x45\xc6\xb4\x26\x1c\x56\x98\x53\x75\xcb\x7c\x52\x12\x9a\x0d\xc8\xb5\x9d\x64\xc8\x7c\x84\x39\x70\xe7\xe8\x46\x66\xcf\x68\x1c\xee\x62\x3f\x72\x38\x18\x1c\x22\x05\x5f\x11\xfc\xd2\x01\x33\x76\x4b\xa0\xba\x43\xe2\xd4\x46\xa1\xe6\x42\x63\x1a\x58\x2b\xb5\x41\x9a\x63\x09\x51\x5c\x66\xe6\x39\x14\x6d\x9d\x7e\x67\x79\x39\x3b\x64\xfb\xdc\x35\x49\xf5\x2e\x29\xaa\x5b\x5d\x27\xd4\x9f\xdd\x53\x53\xef\x94\x98\x7a\xa9\x62\xb4\xdb\x22\x77\xcc\xba\x67\xea\xbd\x47\x22\xe5\xbc\x53\x92\x4f\xff\xac\xcb\x09\x93\xb7\x91\xfa\x5c\x25\xb6\x8c\xfd\xa0\xc4\xbc\xe1\x64\x55\x1d\x31\x1f\xee\x56\xc9\xc9\x81\x68\x5a\x08\x3c\xbd\x7c\xd7\xad\x3a\x07\xe9\x2c\xf0\x35\x9f\x2e\x02\x60\xf3\x69\x77\x29\xd7\x7c\x96\x4e\x53\xa0\xee\x45\xe4\x92\x0e\xa0\x34\x12\x32\x31\x9b\x70\xe4\x06\x50\xd4\xde\xf1\x28\x6a\x65\x15\x2d\xb3\xd2\x84\xb0\x9c\x15\xac\x01\x06\xf5\x79\x9b\x31\x18\xd2\x37\x8b\x18\x05\x96\xae\x02\xfa\xdb\x95\x67\xe0\xb3\xd3\x91\xee\x5a\x3d\xed\x47\xeb\xb8\x71\x0f\x18\x7a\x99\x61\x67\x38\x8e\x5c\x36\x04\xef\x41\x5c\x93\x61\xc0\x79\xc3\x68\x14\x90\xbc\x38\xe2\x2a\xf5\x74\x5e\x59\x3b\xc3\x8a\x9b\xa2\xb3\x22\x9c\x5d\x0f\xf7\x28\xd1\x47\xa3\xfe\xa8\x65\x7a\x30\xdd\xd4\xea\xa6\x5c\x54\x2b\x77\x06\x5e\x4b\x61\x9e\xbd\x68\xb8\x34\xed\xb7\x96\x2e\x46\x66\xd5\x46\x52\x36\x57\x98\x3e\x50\xd0\x28\x91\x9b\xbf\xe0\x83\xf3\xfa\xdc\xc5\xc8\x47\x14\x09\x01\x1e\x9d\xca\x5a\xfb\x67\xb9\x04\x19\x2c\x96\x8c\xa0\x36\x09\xea\x78\x91\xb2\x58\xc8\xf4\xd4\x15\x00\x16\x42\x62\xd5\x2f\xdd\xc3\xe2\x26\xba\x87\x4a\xa0\x15\x14\xa2\x6b\x59\x15\x19\xc0\x77\x16\x0d\x76\x2a\x53\x73\x9f\x42\x35\x76\x03\x61\xe5\xd7\x5d\x77\x91\xdc\xb3\xee\x0c\x89\xb8\xd0\x6e\x95\x2c\xea\xc6\x6a\x1c\x29\x54\xe7\x4e\x66\x2c\xa7\x98\x14\xce\x2f\xcf\x52\x99\x3b\xc5\x8d\x61\x98\xd5\x87\xa9\x5c\x13\x39\xe9\xd5\x2a\xc4\x1d\xcc\x5f\x1f\xec\x52\xcf\xe3\x9e\x25\x57\x48\xb5\x0b\x7b\x00\xc6\x75\x4d\x3a\xb3\x78\x0d\xea\x42\x06\x99\x1c\x45\xc3\xc8\x60\x19\xcc\x1c\xa1\xf7\xe8\x0b\x7f\x4a\x15\xa9\x17\x84\x84\x17\x15\xe9\x45\x45\xda\x8b\x8a\x14\x31\x16\x4f\x70\x1c\xa0\x62\xb5\x29\xce\x28\xe5\x75\xa7\x2a\xaa\x27\xca\x12\x63\x51\xd3\x6b\x4d\x52\xd5\xad\x68\x56\xf5\x39\xf4\xba\x94\xc3\xe3\xd2\x4c\xfa\xbf\x21\x4c\x24\x32\xc5\xcd\xb7\xe3\x2b\x6d\x40\xb4\xa9\xd4\x8f\x78\x2e\xb9\xff\x56\x6c\x89\x83\xb1\x77\xdd\xba\x9d\xe8\x80\xbf\xab\x7b\xbb\x27\x06\x5f\xb1\xf5\x10\x04\xeb\x0b\x1c\xfb\x18\x79\xc7\xdf\xab\x5b\x42\xac\x05\x0c\xc8\xed\xcb\x9c\x92\x23\x7c\x39\x48\x8a\xb2\xe7\x1a\x0c\x72\x96\x4b\xb5\xe8\x85\x46\xf6\xc7\x5a\x2f\xd7\xe2\x18\x64\x82\xa4\x54\x56\xd9\xcb\x16\x3f\x54\xe9\xc0\x03\xe8\x91\x85\x83\xb0\x4f\xdd\xaa\xc1\xc4\x4f\xc3\xfd\x2e\x24\xba\x02\x55\xbe\xaa\x8e\x33\x09\xc9\xf7\x74\x2f\xa8\xa8\xf0\x96\x89\x39\x99\x53\xd5\xa1\x74\x75\xfc\xdc\x53\x1e\x48\xf9\x9c\xeb\xdd\x0a\xd6\xad\xd4\x9a\xb9\x4b\xeb\x25\x4b\x53\x94\xc6\x51\x4a\x7f\x2a\x7c\xa8\x77\x38\x0d\x0d\xa1\xe8\xf5\xc1\x4e\xd3\xf8\xc1\x14\x85\xc5\x67\xc7\xd2\xb0\xf8\xdc\xb7\x40\x6c\x7d\x94\x9d\xd1\x66\xaf\xe5\x9e\xfd\xe3\xd1\x62\x1f\xe7\xb0\x62\x91\x55\x7e\x02\x2f\x9c\x3e\xd2\x41\x43\x7f\x90\x3d\xda\x6a\x5c\x22\xf4\x1f\xb3\x99\x66\x4f\x57\xaf\x2e\x52\xef\x27\x7e\xef\x3a\x72\x39\xf1\x5f\x2e\x5d\x5b\x21\xdf\xcb\xa5\xeb\xcb\xa5\x6b\xdb\xe7\xe5\xd2\xf5\xc5\xa2\x50\x7f\x7e\xd0\x16\x85\x97\x4b\xd7\x97\x4b\xd7\xfb\xc1\xf0\x41\x2e\x5d\x9d\x18\x57\xdd\xb8\x3e\xea\x85\xab\x2b\xeb\x72\x96\x24\xb2\x14\xe6\x46\xde\xb2\xd6\x37\x08\xad\x84\xf9\xa5\xd1\x1f\x4f\xb2\xef\x2e\x58\x74\x12\x0f\x76\x11\x0c\x68\x99\x72\x2b\xbc\xef\x8c\x40\x67\x6e\x00\x2f\xa7\x5b\x52\x2c\x52\x96\x86\x91\xfd\x21\x35\x16\xd6\x03\x72\x46\x14\x4b\x78\xc1\x5d\xf5\x6e\x8a\xef\x11\xc3\x42\x96\x7d\x6e\x34\xcb\x26\x2e\xdb\xb9\x88\x8b\xc2\x54\x22\xb8\xa3\x70\x2b\x3f\x83\x3c\x47\xfa\x24\xd9\xbe\x42\x8e\x62\xdf\x79\x66\xe5\x66\x73\x13\x8f\x10\x1b\x45\x60\x29\xb5\x5a\x34\xf0\xb1\x82\xbb\x08\xe4\x87\x3e\xd8\xec\x4b\xc1\x15\x20\xef\x88\x25\x52\xb4\xa9\x88\xb9\x66\x83\x2e\x9b\x23\xf9\x9d\x72\x16\x4d\x2c\x80\x1f\xea\x5e\xce\x69\xc6\x53\x6e\x16\xe1\xae\xcd\x55\x59\xa2\x78\x62\xc2\x36\xea\x0a\x8c\x84\x16\x85\x92\x34\x99\x31\x1d\xcd\x1b\x45\x0e\x17\x88\x15\xbc\xce\xb1\x12\x18\x48\x1d\xd0\xc7\xb2\xbe\x6c\x41\x94\x34\xfe\xba\x7c\xcd\x07\x6f\xa2\xc1\xa0\x3b\xf2\x2f\xa3\x16\x70\xa7\x2e\xe3\x21\x70\x56\x7c\x12\xff\xa1\x89\xcc\x52\x9f\xdf\xe3\x37\xaf\xac\x98\x97\x38\x1c\xb4\x54\x0e\x32\x40\x18\x49\x32\xcb\x8a\x2d\xe5\x5b\xdf\xf9\x97\x5f\x93\x99\x2c\x95\x1e\xc4\x41\x42\xaf\xe1\x1d\xaa\x68\x5e\x4c\x34\x24\x63\x54\x1b\xf2\xfa\x15\xc9\xb9\x28\x2d\x07\xea\x8c\x36\xdd\x25\x9b\x48\xa6\xf9\xd5\xd7\xad\xfb\x75\x95\x66\x96\x6f\x24\x1d\x56\x15\x98\x89\xd7\x09\x35\xee\x24\x61\x70\x19\xe6\xb1\x6e\x88\x38\x8e\xe8\xc6\xd0\x16\x46\x3e\xc0\xf9\xfa\xbe\x94\xe3\x85\xe9\x12\x88\xf8\xbf\xd8\xa3\x1e\x81\xe8\x5f\xb6\xc9\x2e\x52\x25\x17\xd9\xf8\xd1\x07\xa9\x95\x30\xe5\xda\x6c\xa9\x94\x50\xc5\x28\x6e\x6c\xd6\x9e\xad\x4c\xad\xbc\xdf\x31\x2c\x05\x74\x04\x2f\xeb\x7a\xf3\x50\x92\x30\xac\x69\x78\x51\x55\xda\x11\x12\xc7\xdf\x3a\xfc\x13\x27\xdb\xf2\x08\xb2\x87\x1c\xdd\x2d\x97\xda\x4e\xba\xf2\x28\xd1\x79\xad\xd8\xad\x7e\x0a\x34\x17\x53\x4c\xa9\x9d\x97\x99\xe1\x45\x56\xad\x3b\x74\x70\x84\x3c\x36\x9b\xd1\xc8\xd2\x43\x31\x38\x17\x53\x31\x81\x89\xf1\x28\x8c\xc5\x84\xc1\xcc\xd0\xca\xf2\x83\x82\x2a\x1a\x80\x07\x75\x53\xf5\xb1\xb3\xc0\x51\xb8\x07\x44\xca\x63\xc9\xb9\xa2\x59\x58\x68\x7c\xf7\xb3\x4f\xa4\x31\x4c\x50\xd1\xc2\xc0\x5c\x57\xf5\xa0\x13\x91\x77\xc1\x05\x0c\x2b\x6c\x34\xb0\xc5\x09\x35\x6f\x68\x72\xcb\x44\x8a\xe5\x87\x60\xd9\xe9\x42\xd0\xdc\xa5\xa2\x8a\x6a\x2a\x37\xfa\xeb\x9e\x33\x35\x60\xa4\x9c\x0f\xd5\x45\xae\xbb\x4f\x18\x94\xba\x73\xae\x97\x4f\x1a\x6b\x19\x6f\x3a\xe7\x1a\x8d\x30\x8a\xcf\x13\xe6\xf9\xbf\xfd\xd4\x3e\xa7\x3e\x6f\x11\x8f\xbe\x34\x79\xe7\xaa\xc8\x23\xfc\x05\x72\x1f\x8c\xdf\x90\x75\x8a\x66\xf6\x68\x2f\x42\x78\x66\x63\x73\xc7\x8b\xfd\x16\x54\x51\xe3\x2e\x61\xb4\x87\x1f\xdf\x5c\xd4\x0f\xf1\x47\x9a\x4a\x4d\xde\x64\x32\xb9\x25\x17\x0c\x84\xae\x87\x2c\x08\xa2\xc6\xe9\x53\x26\x8c\xce\xe9\x74\xdb\xed\x58\x9f\xe4\x52\x70\x23\xd5\x66\x7a\xf1\x52\x9f\xf0\x49\xd2\x11\xab\x71\xfa\xac\x93\x11\x5b\x04\xdb\xa5\x1a\xa1\x82\x63\x08\xdd\x7d\x2e\xbf\x1d\x0f\xd5\xcf\x66\xf2\xae\x6f\x64\xbf\xd4\xac\xcf\x5b\xdc\xb7\x76\x58\xdd\x2d\x5b\xc0\x25\x73\xc7\xf5\x7d\x83\xdd\x6a\xca\x81\x91\x60\x53\x82\xf7\x96\x45\x7f\x7c\x73\x61\x79\xc3\x20\x16\xf6\x4e\x98\x49\x4e\x12\x56\xcc\x4e\xdc\x87\x9f\x25\x50\x3c\xb5\xe8\x0a\x95\x33\x92\xc8\x2c\x73\xf1\xce\x72\x42\xce\x59\x31\x0b\x83\x3d\xf6\x4a\x9f\x2e\xd5\x6d\x21\x65\xd7\x94\x9f\xd1\x81\xb1\xbd\xdd\x79\x89\x10\x47\x8d\xbb\xd5\x31\x78\x2c\x54\x79\xd6\x95\x18\x1f\x10\x38\x0f\x5c\x55\xbf\x56\x4b\x3f\x76\xbd\xac\xa7\x03\xf6\x3e\x1c\x35\x72\x33\x9c\xa0\x24\x9d\xb2\x94\xc8\x39\x53\x8a\xa7\x4c\x93\x40\x6f\x62\xd5\x93\x67\x8f\x0d\xb7\x97\xcc\xc4\x4f\x9e\x99\x78\x07\x1d\x27\x22\x4f\xb6\xf7\x32\x79\xa2\x69\xce\xc5\xb3\x23\x50\x3a\xa1\x19\x1b\x7e\xe8\xa0\x4c\x8c\xb0\x47\x5d\x9f\xf0\x2f\xa3\x84\x62\x5b\xd2\x74\x7d\x13\xf0\x85\x08\x99\x6e\xb3\x8f\x3e\x80\x56\x30\xa5\x86\xdd\x6d\x65\x7f\xfd\x8a\x40\x6d\x6f\x09\x72\xe7\x53\xea\x0f\x4f\x94\x1a\x2f\xc2\x72\xcc\xfb\xb5\x4f\xf6\xe9\xf6\xa9\xab\xd1\xc5\x2f\xa4\x91\x49\xd6\x23\xea\xd9\xf5\x90\xfc\x01\x47\xde\x6f\xa6\x3e\x25\x0d\x4a\x77\x17\x32\xa7\xbc\x73\xa1\x8d\x59\xbd\x30\xb5\x9f\xee\x75\x18\x96\xe0\xb8\x71\x8d\x90\x09\x9f\x96\x56\x03\x73\x5a\xd3\x4b\x12\xb5\x47\x11\x40\x2a\xf9\x23\xb2\x04\x79\x8f\xc3\x4a\xe6\xf0\x3b\x08\x4c\x21\x5c\x4d\x12\xcd\x84\xe6\x70\x4f\x12\x5d\x56\xbb\x72\x6f\x58\x5f\x10\xdd\x0b\x51\x48\xe9\x91\x77\x72\xca\x85\x3f\x95\xd2\x5d\xa3\x4d\x28\xcf\xda\x02\xe3\x45\xaa\x78\x72\xa9\x42\xeb\xec\x52\xd0\x71\xd6\xc6\x0b\xa0\x4e\xd6\x33\x0a\xf7\x9c\x0c\x7a\x9f\xa4\x5c\xdb\xff\x93\xd1\xe8\x1d\xd8\xc4\x4b\xe1\x65\x5d\xb0\x17\x3b\xb2\x16\x3c\xfd\xf1\x00\xee\xf7\xcc\x20\xa5\xd9\x21\xc7\xdd\x50\xa4\x76\xb2\x4c\xd7\xdc\x4e\xdc\x78\x98\xe9\x2f\x78\xce\xe2\xcd\xfd\x98\x91\x9b\x19\x4f\x6e\xaf\x23\xd3\xb7\x54\xf6\x9d\x88\x5e\xd5\x98\x50\xf3\xb7\x7d\x12\x44\x37\xd5\xeb\xee\x0a\xec\x4d\x44\xcf\x47\x6e\xc1\x76\x18\x42\xb5\x96\x09\xaf\xee\x39\xc0\x5c\x52\x11\xfc\x14\x08\xfe\x7e\x17\x01\x3c\xfd\x9e\xbc\xc9\x6f\x9a\xaf\x7a\xaa\x63\x5e\xc4\x85\x5f\xeb\x5e\x27\x8e\xa8\xb1\x43\x96\xee\x9b\x5a\x5e\x6e\x2f\x9b\x36\x8c\xf6\xde\x8b\xdb\x6d\x92\x97\x92\x7c\x95\xc5\xa5\x6d\x0a\xf9\xb9\x5d\x5e\xbe\xbd\x2d\xb5\x4d\x20\xc3\x2a\x6d\xb8\x71\x53\x87\xef\x9c\x19\x1f\x0e\x53\x21\x8b\x32\x43\x5f\x89\xfb\x27\x17\xf7\xd6\x59\xfc\xce\x9e\xcc\xfa\x8f\x91\x68\xb3\xab\x23\xf0\x8f\x23\xe7\x66\x24\x92\xbd\xfa\xd5\xd7\x5f\xff\xd0\xb3\x70\xb6\x55\x81\x1f\x22\x0d\x67\x4b\x93\xe8\x4b\xa4\xcd\x4b\xa4\x4d\x8c\x8a\x0f\x99\x46\x75\xcf\xb1\x34\x1d\x5d\x5c\xbb\xb9\xb7\xb6\x8f\x96\x69\xed\x04\xdb\xd5\x01\xb6\x43\x3c\xcc\x9e\xa2\x60\x3a\xfb\x82\x76\x89\x78\x79\x89\x73\xf9\xb1\xc5\xb9\xec\xe2\x03\xda\x3d\xa6\xa5\x8b\xef\xe7\x8f\x29\x7e\xa5\xc3\x61\x6c\x1f\x67\xd1\x3d\xba\xa2\x7b\x3e\xbb\xee\x96\xad\x5d\x4a\x1a\xc5\xf6\x19\xa7\x45\x54\x15\x04\x7d\xe1\x41\xcc\x8f\x65\xa4\x3d\x58\x8f\xa2\x43\x90\x0e\x0a\x14\x0e\x2f\xbb\xd4\x12\x74\x3a\xf9\x87\x51\xe3\x6a\x23\xbc\x7e\x9a\x1b\x8d\x1f\xe7\x95\xc1\x4b\x61\x90\xe7\x6d\xd3\xd6\xb5\xdc\x22\xde\x92\x00\x67\x1d\x18\xb1\x1c\xc7\x39\x0d\xab\x33\x72\x76\x3d\xb4\xea\x32\x84\xcf\xd0\x4c\x0f\xc8\x0a\x3e\xed\xed\x92\x8e\xaf\x7b\xfe\x4c\x8d\x61\x79\x61\xda\x6f\xf6\x8b\x49\xfb\xc9\x4d\xda\x3b\xdb\xe3\x3e\x87\x8e\xa1\x02\x64\x99\x53\xd1\xb7\x27\x0a\x8c\xdb\xb5\x5b\xb0\x06\x09\x1e\x10\xef\x95\x8b\xb0\xa0\x8a\x61\xd2\xa7\x7a\xc5\x5b\x1a\xd5\x3f\x7c\x18\x23\x24\x8c\xbd\xf3\xca\x91\x81\x36\x4e\x5a\x22\x97\xdc\x3e\xdd\x72\x02\x14\xfc\xa1\x8a\xb8\x70\x4d\x6f\x36\x33\x86\xcc\xfa\x1a\x02\x51\xaa\x56\x75\x49\x18\x45\x61\x9a\x65\xf2\x0e\xbf\x1d\x33\x30\x0b\x7d\x3b\x17\x17\x61\x35\x66\x24\xe7\x56\xa9\x76\xc6\xcf\x78\x3a\x78\x15\x69\x25\x6a\xa6\x50\x60\x55\xee\x36\x6b\xc4\x4c\xbc\xd1\x56\x21\x15\xe8\x08\x6d\xff\xed\x1d\x6f\x30\x2b\xae\xa3\x09\x63\x36\xa3\x73\x2e\x4b\x85\xbd\x8d\x24\x07\xee\x27\x60\x09\x0b\x59\x06\xd3\x14\x56\x49\x0c\xab\xd3\x2b\xe0\x74\x55\xfd\x08\xa2\x7c\x2a\xbd\x2d\xa1\xcf\xbe\x70\x6d\x96\xd7\xe2\x41\xe4\x93\xb6\xed\x0b\x6f\xe6\xba\xb0\x6c\xa1\x73\x45\xb4\xcf\x71\xbf\xba\x60\x32\x1f\xc1\x4f\x3f\xa0\x7a\x68\x5b\x73\x91\xbe\xc8\x3a\xfb\x96\x75\xc2\x75\x55\xc6\x93\x45\xe7\x4a\x61\xd5\x35\x95\xed\x4e\xde\x50\xcd\x52\xf2\x9e\x0a\x3a\x45\xb5\xec\x68\x74\xfd\xe6\xfd\xb1\xdd\x36\x50\xfb\x86\x17\x2b\xef\xb2\x46\xf1\x1c\xae\xf6\x19\x06\xb1\xb4\xc2\x1d\x38\x51\xc7\x35\xee\x35\x8c\x83\x04\x6e\xd2\x2e\x41\xec\x72\xe8\x65\xb3\xc6\x63\x83\x28\xcc\xf3\xf4\x9e\x55\x1d\xb9\xd0\x86\x66\xd9\x75\x46\xc5\x59\x51\x28\x39\x5f\xad\x09\xd7\x03\xc3\x5d\x43\xcf\xda\xd1\xf7\xc1\xbf\x2c\x10\xd0\x70\xd7\x2b\xc8\xb0\x1a\x7f\x40\x86\x26\x28\xc4\x52\x00\x1b\x3c\x38\x2b\x8d\xcc\xa9\xe1\xc9\x81\xd5\x9b\x0f\xde\x53\x51\xd2\x6c\xa5\x87\xd1\xc6\x65\xac\x13\xeb\x36\x76\x5a\x9f\x1c\xad\x45\xb7\x8d\xf2\xc1\xe6\xfe\x86\x2a\x4b\x5b\xce\x47\x9f\x3b\xf5\xd5\x86\x9a\x72\x89\x72\x6e\xa0\xe6\xeb\xe9\x77\x9f\x64\x54\x9b\x4f\x45\x6a\x4f\x72\xe3\xd7\x4d\x44\x3a\xa1\x86\x66\x72\xfa\x47\x46\xb3\xd5\xf8\x5c\xc3\x93\xf3\xb8\xb5\x37\xfe\x20\xca\x8c\xca\x71\x68\x78\xa8\x89\x15\x8a\x7d\xbc\xb6\x62\x19\x9b\x53\x61\x7c\x77\xac\x94\xad\x0f\xdd\xfa\x01\x8b\x78\x65\xf0\x4c\x99\x61\x2a\xe7\xa2\x3e\xe6\x08\xda\x9e\x4b\x91\x72\x34\xf5\x81\x31\x0b\x7b\xd4\xc7\x5d\x8f\x6a\xeb\xcc\xf9\x1b\x0c\xf8\x75\xca\x13\xcd\xa7\x0e\x0a\x6c\x36\x76\x32\xe1\x0c\x5f\xc2\xcd\x75\x6d\x6e\x4b\x90\x22\xb7\xc2\x0a\x73\x90\xf3\x62\x35\x91\xda\xca\xdb\xb7\xf1\xf4\xbe\xdf\x63\x9c\xc2\x7a\xbf\xc8\xbe\x9b\xf7\x3a\x43\xff\x26\x14\xc3\x67\xbb\x34\xd0\x9c\xca\x7a\x0a\xba\x0a\xef\x42\x37\x0c\xee\x6b\x54\x57\xaf\x35\x5a\x4f\xf1\x5b\x09\x4b\xed\xe4\x9a\xb6\x79\xd3\xeb\xb4\xb6\xca\xf2\xbd\xa4\x7e\xb6\x90\xf2\xb6\xb2\xa8\x96\xe9\xcb\xeb\xca\xf0\xd0\x39\xc5\x29\xa7\x3e\x50\x52\x70\x86\x89\x3a\xa8\x70\xc0\x02\xce\xc2\x68\xea\x5e\x5a\x0e\x66\xd5\x38\xf8\xad\xe7\xee\x9a\xd1\xb0\xeb\x7c\x17\xbc\x71\x98\x62\xa2\x0a\xb8\x2c\x38\xf9\x83\x74\x17\xa5\x2e\xa0\xd4\xd2\x00\xe0\xdb\x3d\xa2\xcb\x64\x46\xa8\xb6\x53\xb3\x08\x6d\x4f\x3c\x1b\xe4\x54\xf0\x09\xd3\x66\x10\xf2\xd0\xea\x3f\xff\xf2\xaf\x03\xf2\x56\x2a\xe2\xfc\xb0\x7b\x3e\x03\x84\x9b\x67\x85\x17\x5c\xe3\x62\x42\xdf\x4a\xd3\x2c\x64\xea\x26\x7d\x07\x93\x35\xf4\xd6\xf2\x30\x9c\x6c\xc9\xe0\xba\xe0\x94\x1c\x58\x21\x2f\xfa\xf4\x3f\x2d\x5b\xfa\xf7\x01\x39\xba\x03\xa6\x7d\x60\xff\x3c\xc0\x0f\x06\x5f\xc2\x58\x11\xae\x3e\x8c\x61\x7e\x8a\x4f\xa7\x4c\xa1\xca\x47\x20\x1c\xee\xd8\x65\xb0\x10\x32\x6a\xec\x6f\x7e\x2b\x15\xb1\x39\x91\x3f\xff\xf2\xaf\x07\xe4\xa8\xbe\x2e\xc2\x45\xca\xbe\x90\x5f\xa2\xe9\x97\x6b\xbb\xc6\x63\x77\x81\xa2\x17\xc2\xd0\x2f\x76\xcc\x64\x26\x35\x13\xa8\x7e\x1b\x49\x66\x74\xce\x88\x96\x56\x6b\x65\x59\xd6\x77\x66\x6d\x72\x47\x21\xab\x88\x07\x25\x04\x81\x93\x82\x2a\x53\x43\x89\x81\xb3\x6a\xc0\xd7\xec\xb6\x4d\x85\xbf\xfe\x9d\x70\xe1\xee\x8c\xdc\x6d\x95\xdd\x73\x08\x69\xc4\x4d\x32\x92\x24\x33\x2a\xa6\x21\x8e\x7a\x52\x9a\x52\xb1\x2d\xd7\x2d\x2d\xcf\xc0\x2d\x17\x9d\xc2\x6d\xbf\xe1\xa2\x79\x73\xbf\xda\x16\x34\xe5\xc6\x3b\xfd\x3b\x47\x3e\xb3\x38\xb1\xbb\xa0\xf8\xb8\x34\x52\xe9\x93\x94\xcd\x59\x76\xa2\xf9\xb4\x4f\x55\x32\xe3\x86\x25\x76\x59\x27\xb4\xe0\xfd\x44\x0a\xbb\xe3\x90\x41\x20\x4f\x7f\x06\x45\x30\xfb\x76\xaa\x5b\xf2\x1a\xb7\x5c\xf4\x76\x43\xd8\x93\x1a\xc0\xf6\xb6\xc6\x16\x36\x9c\xe5\x85\xa2\x3d\xe5\x11\x56\x0b\xc6\x8b\x93\xbd\x2c\xd6\xa7\xe5\xed\xce\x63\x0e\x5d\xa6\xe9\xa4\x39\x86\x3d\x76\xe8\xa5\x01\xa7\xb2\x46\x29\x73\x9a\x22\x29\xa5\x62\xf1\xe0\xc8\x6f\x41\x0a\x09\xd9\x93\x45\x3f\xc1\xfa\xf6\x7d\x2a\x52\xfb\x6f\x8c\x47\x49\x16\x7b\x81\x61\xc9\x3b\x11\x82\x4f\xc3\x8b\xc7\x39\x12\x25\xdf\xc3\xa9\x77\xf2\x5a\x4b\x21\x0a\x45\x55\x70\xd9\x31\xaa\x64\x9e\x69\xd6\x05\x54\xae\xfd\xa8\xff\xed\xee\x4c\x42\x66\xae\x6d\x22\xd5\xe6\x9b\x8e\x48\x76\x6c\x39\xdf\x77\x55\x8f\x66\x4d\x7c\x3b\x98\x4b\x03\xe5\xa3\xe7\x6b\xcb\xf0\x0a\x0a\x30\x98\xf5\x77\xb4\xad\x70\xc8\xdf\xd1\xdb\x89\xf4\x57\xe6\x07\x4a\x82\x52\xb2\x5d\x81\xaa\xf4\x97\x5a\xa5\x2d\x5c\x94\x61\xda\x10\x3a\xa7\x3c\x03\x8b\xba\x1c\x6b\xa6\xe6\x58\xf2\xc8\xa5\xc5\xa3\x4d\x3d\xcb\x55\x35\x40\x31\xea\x91\x34\x1f\xbf\x86\xe5\x5d\xd9\xb4\x00\xd0\x86\x1a\xb3\x5f\x3b\xeb\xbd\xe8\x3d\xa8\x5e\xae\xfd\xd9\x7e\x61\x47\x35\xc6\xe2\xdf\x1f\x19\x55\x66\xcc\xa8\xb9\xe1\x9b\xf8\xee\x12\x4a\xd7\xfa\x79\x83\x4b\x85\xd0\x77\x8c\x4c\xa5\xb1\x22\x56\x09\xb8\x8f\x32\x29\x26\xa0\x09\x88\xf6\xd0\x18\x5d\xad\xf2\x46\x51\x88\x7b\x91\xa2\xe3\x32\xeb\x1d\x97\xd7\xe9\xa4\x63\x87\x49\x06\x5b\x63\x0a\x08\x29\x98\xdb\x3b\xbc\x81\x00\x0a\xf4\x38\x4b\xce\x99\xd6\x1b\x53\x43\xd4\x5d\xf8\xb0\x35\x1e\xe5\xc6\x75\x58\xee\x7f\xc3\xf8\x09\x2b\x40\xa7\xcc\x50\x9e\xf9\xa3\x8c\xa0\x08\x50\xda\x46\x5d\x37\x2e\x50\x31\xaa\x37\x09\x08\xcd\x8c\x58\x5a\x0a\x9c\xb4\x14\xac\x7f\x27\x55\x4a\xce\x69\xce\xb2\x73\xaa\x99\x1b\x2b\x0e\x57\xc3\x3d\x3a\xd4\x7b\x9d\xf2\x6a\xdb\xd7\x9a\x29\xa3\xf1\xc7\x23\x91\xc3\x8d\x4a\xc5\xc2\x09\xf6\xbc\x09\xf2\x46\x95\xac\x47\xde\x5a\xee\xd5\x23\x9f\xc4\xad\x90\x77\xf7\x9b\xab\xd9\x78\x73\x51\x77\xb3\x72\x99\x5b\x20\x45\x9e\x4b\x08\x53\x33\xf8\x84\xe9\xee\x38\x23\x47\xf0\xd7\x98\x1a\xeb\xcc\x26\x34\xf5\x33\xb2\xff\x5c\x32\x41\x59\x45\x51\xc9\xa9\x62\x1a\x73\xae\xac\x4c\xe8\xd7\xd6\xe4\xfc\x07\x26\x5c\xc4\xdb\xd6\xe9\x0d\x57\xf5\xf2\x33\xf5\x7c\x6d\x5a\xfd\xe2\xf6\xdb\x7d\xac\xc8\x56\x8a\x1a\x9b\xbd\xf0\xa2\x89\xae\x31\x3e\xad\x9b\xe1\x6a\xa3\x53\xc4\xf5\xa2\xb6\x28\x94\x6c\xb2\x8e\xfa\xd5\x9d\x8f\x3e\xaf\x07\xf6\x5a\xde\xb7\x8d\x3f\x6d\x37\x4b\xdd\xd7\x20\xb5\xf5\xcc\x6c\x35\x42\xbd\x98\x9f\x5e\xcc\x4f\x3f\x24\xf3\xd3\x56\x8c\xdf\x64\x72\xfa\x61\x18\x9b\xb6\x2e\x71\x93\x81\xe9\x59\x9a\x96\x5a\xad\x68\xa3\x39\xe9\xd9\x1a\x92\xb6\x2e\xad\xa5\xf1\xe8\xa7\x63\x36\xda\x0a\xb1\x0d\xa6\xa2\x67\x68\x24\x6a\x23\x90\xb1\xb4\x8d\x98\x38\x8c\x1a\xc7\x82\x62\x55\x30\x31\x0c\xe7\x5d\x6a\x62\x71\x66\x57\x69\xd1\x0a\x70\x5b\xe7\x76\xe8\x26\xd7\x5e\xf6\x72\x02\xa3\x2b\x27\xb8\x34\x59\x72\x71\x79\xfd\xf1\xf2\xfc\xec\xe6\xf2\xa2\x29\xdf\xad\x82\xf4\x16\x49\x6c\xb3\x0d\xa2\x1f\x49\x62\x6b\x1a\x58\x82\xbc\xe6\x27\x8b\x03\x6b\x7e\x2a\x4b\xbe\xaa\xd7\xfd\xe5\xc2\x7b\x71\xb9\x7b\xf1\x8f\xed\xa7\xb3\xed\xf1\xb4\xa7\x13\xb0\x05\x3d\xc6\xac\xdc\x33\x93\x59\xaa\xbd\xaf\xe9\xf0\x22\x44\x2f\x71\x91\x64\x65\x6a\x85\x8b\x4f\x9f\x86\x17\x7a\x40\xc8\x1b\x96\xd0\x52\x83\x15\x26\x95\xe2\xd0\x90\x0f\x57\xef\xfe\x04\x3e\xd4\xd0\xa2\x17\x92\x7d\x40\x06\x59\x4e\x31\x09\xae\xc1\x2c\x64\xe4\x0d\x43\x41\x05\xbe\x9c\xd0\xc2\x52\x31\x8d\x55\x16\x0c\xc8\x22\x33\x96\x15\x96\x62\xde\x32\x52\xe5\xfe\xb4\x03\x57\x35\xcc\xbd\xcb\xe3\x94\x19\x8c\x74\xda\xe4\xd5\xb8\x11\x6a\x5b\x2c\xae\xf7\xb0\xb5\xd6\xd4\x47\xa7\x8d\xdf\x51\xed\x2c\x56\x2b\x67\xbb\x65\x7f\xb7\xdb\x67\xd6\x9b\x38\xd6\x18\x37\x90\x3c\xc3\x5f\x4b\x73\xb6\x93\xad\xec\x18\xe8\x44\xc2\x4d\x6b\x6b\xea\x7a\x37\xa0\xd5\x39\xeb\x97\x6c\x19\xac\x09\xe4\xda\x87\x83\x17\x75\x34\xe5\x76\x73\x81\x82\x17\x69\xad\xba\xa4\xf3\xb6\xab\xbf\x2b\xc7\xa1\xbe\x68\x35\x5f\x67\x91\x21\xff\xfc\xf7\x57\xff\x3f\x00\x00\xff\xff\x20\x70\xf2\xef\xc3\xac\x01\x00") func operatorsCoreosCom_subscriptionsYamlBytes() ([]byte, error) { return bindataRead( diff --git a/vendor/github.com/operator-framework/api/pkg/encoding/encoding.go b/vendor/github.com/operator-framework/api/pkg/encoding/encoding.go new file mode 100644 index 0000000000..79cee4f0c7 --- /dev/null +++ b/vendor/github.com/operator-framework/api/pkg/encoding/encoding.go @@ -0,0 +1,50 @@ +package encoding + +import ( + "bytes" + "compress/gzip" + "encoding/base64" + "io" +) + +// GzipBase64Encode applies gzip compression to the given bytes, followed by base64 encoding. +func GzipBase64Encode(data []byte) ([]byte, error) { + buf := &bytes.Buffer{} + + bWriter := base64.NewEncoder(base64.StdEncoding, buf) + zWriter := gzip.NewWriter(bWriter) + _, err := zWriter.Write(data) + if err != nil { + zWriter.Close() + bWriter.Close() + return nil, err + } + + // Ensure all gzipped bytes are flushed to the underlying base64 encoder + err = zWriter.Close() + if err != nil { + return nil, err + } + + // Ensure all base64d bytes are flushed to the underlying buffer + err = bWriter.Close() + if err != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +// GzipBase64Decode applies base64 decoding to the given bytes, followed by gzip decompression. +func GzipBase64Decode(data []byte) ([]byte, error) { + bBuffer := bytes.NewReader(data) + + bReader := base64.NewDecoder(base64.StdEncoding, bBuffer) + zReader, err := gzip.NewReader(bReader) + if err != nil { + return nil, err + } + defer zReader.Close() + + return io.ReadAll(zReader) +} diff --git a/vendor/github.com/operator-framework/api/pkg/manifests/bundle.go b/vendor/github.com/operator-framework/api/pkg/manifests/bundle.go index e26a9b34e2..9be294a352 100644 --- a/vendor/github.com/operator-framework/api/pkg/manifests/bundle.go +++ b/vendor/github.com/operator-framework/api/pkg/manifests/bundle.go @@ -19,6 +19,10 @@ type Bundle struct { V1beta1CRDs []*apiextensionsv1beta1.CustomResourceDefinition V1CRDs []*apiextensionsv1.CustomResourceDefinition Dependencies []*Dependency + // CompressedSize stores the gzip size of the bundle + CompressedSize int64 + // Size stores the size of the bundle + Size int64 } func (b *Bundle) ObjectsToValidate() []interface{} { diff --git a/vendor/github.com/operator-framework/api/pkg/manifests/bundleloader.go b/vendor/github.com/operator-framework/api/pkg/manifests/bundleloader.go index ec90c0cd41..6a8d7e4cf4 100644 --- a/vendor/github.com/operator-framework/api/pkg/manifests/bundleloader.go +++ b/vendor/github.com/operator-framework/api/pkg/manifests/bundleloader.go @@ -13,6 +13,7 @@ import ( utilerrors "k8s.io/apimachinery/pkg/util/errors" "k8s.io/apimachinery/pkg/util/yaml" + "github.com/operator-framework/api/pkg/encoding" operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" ) @@ -35,6 +36,8 @@ func (b *bundleLoader) LoadBundle() error { errs = append(errs, err) } + errs = append(errs, b.calculateCompressedBundleSize()) + if !b.foundCSV { errs = append(errs, fmt.Errorf("unable to find a csv in bundle directory %s", b.dir)) } else if b.bundle == nil { @@ -44,6 +47,39 @@ func (b *bundleLoader) LoadBundle() error { return utilerrors.NewAggregate(errs) } +// Compress the bundle to check its size +func (b *bundleLoader) calculateCompressedBundleSize() error { + if b.bundle == nil { + return nil + } + err := filepath.Walk(b.dir, + func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if info.IsDir() { + return nil + } + data, err := os.ReadFile(path) + if err == nil { + // Sum the bundle amount + b.bundle.Size += info.Size() + + // Sum the compressed amount + contentGzip, err := encoding.GzipBase64Encode(data) + if err != nil { + return err + } + b.bundle.CompressedSize += int64(len(contentGzip)) + } + return err + }) + if err != nil { + return err + } + return nil +} + // collectWalkErrs calls the given walk func and appends any non-nil, non skip dir error returned to the given errors slice. func collectWalkErrs(walk filepath.WalkFunc, errs *[]error) filepath.WalkFunc { return func(path string, f os.FileInfo, err error) (walkErr error) { diff --git a/vendor/github.com/operator-framework/api/pkg/operators/v1/zz_generated.deepcopy.go b/vendor/github.com/operator-framework/api/pkg/operators/v1/zz_generated.deepcopy.go index 26afb9d030..89a3007bc1 100644 --- a/vendor/github.com/operator-framework/api/pkg/operators/v1/zz_generated.deepcopy.go +++ b/vendor/github.com/operator-framework/api/pkg/operators/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/catalogsource_types.go b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/catalogsource_types.go index e94618f9c7..726f8e1aa1 100644 --- a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/catalogsource_types.go +++ b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/catalogsource_types.go @@ -1,6 +1,7 @@ package v1alpha1 import ( + "encoding/json" "fmt" "github.com/sirupsen/logrus" corev1 "k8s.io/api/core/v1" @@ -10,8 +11,9 @@ import ( ) const ( - CatalogSourceCRDAPIVersion = GroupName + "/" + GroupVersion - CatalogSourceKind = "CatalogSource" + CatalogSourceCRDAPIVersion = GroupName + "/" + GroupVersion + CatalogSourceKind = "CatalogSource" + DefaultRegistryPollDuration = 15 * time.Minute ) // SourceType indicates the type of backing store for a CatalogSource @@ -36,6 +38,8 @@ const ( CatalogSourceConfigMapError ConditionReason = "ConfigMapError" // CatalogSourceRegistryServerError denotes when there is an issue querying the specified registry server. CatalogSourceRegistryServerError ConditionReason = "RegistryServerError" + // CatalogSourceIntervalInvalidError denotes if the registry polling interval is invalid. + CatalogSourceIntervalInvalidError ConditionReason = "InvalidIntervalError" ) type CatalogSourceSpec struct { @@ -119,7 +123,32 @@ type RegistryPoll struct { // Interval is used to determine the time interval between checks of the latest catalog source version. // The catalog operator polls to see if a new version of the catalog source is available. // If available, the latest image is pulled and gRPC traffic is directed to the latest catalog source. - Interval *metav1.Duration `json:"interval,omitempty"` + RawInterval string `json:"interval,omitempty"` + Interval *metav1.Duration `json:"-"` + ParsingError string `json:"-"` +} + +// UnmarshalJSON implements the encoding/json.Unmarshaler interface. +func (u *UpdateStrategy) UnmarshalJSON(data []byte) (err error) { + type alias struct { + *RegistryPoll `json:"registryPoll,omitempty"` + } + us := alias{} + if err = json.Unmarshal(data, &us); err != nil { + return err + } + registryPoll := &RegistryPoll{ + RawInterval: us.RegistryPoll.RawInterval, + } + duration, err := time.ParseDuration(registryPoll.RawInterval) + if err != nil { + registryPoll.ParsingError = fmt.Sprintf("error parsing spec.updateStrategy.registryPoll.interval. Using the default value of %s instead. Error: %s", DefaultRegistryPollDuration, err) + registryPoll.Interval = &metav1.Duration{Duration: DefaultRegistryPollDuration} + } else { + registryPoll.Interval = &metav1.Duration{Duration: duration} + } + u.RegistryPoll = registryPoll + return nil } type RegistryServiceStatus struct { diff --git a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/installplan_types.go b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/installplan_types.go index 6b56a5d727..5210436d98 100644 --- a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/installplan_types.go +++ b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/installplan_types.go @@ -71,6 +71,7 @@ const ( StepStatusNotPresent StepStatus = "NotPresent" StepStatusPresent StepStatus = "Present" StepStatusCreated StepStatus = "Created" + StepStatusNotCreated StepStatus = "NotCreated" StepStatusWaitingForAPI StepStatus = "WaitingForApi" StepStatusUnsupportedResource StepStatus = "UnsupportedResource" ) @@ -227,6 +228,7 @@ func ConditionMet(cond InstallPlanConditionType, now *metav1.Time) InstallPlanCo type Step struct { Resolving string `json:"resolving"` Resource StepResource `json:"resource"` + Optional bool `json:"optional,omitempty"` Status StepStatus `json:"status"` } diff --git a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go index 080b350ee7..c094738eed 100644 --- a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha2/zz_generated.deepcopy.go b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha2/zz_generated.deepcopy.go index 807a963162..3d81e86ed4 100644 --- a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha2/zz_generated.deepcopy.go +++ b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha2/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/github.com/operator-framework/api/pkg/operators/v2/zz_generated.deepcopy.go b/vendor/github.com/operator-framework/api/pkg/operators/v2/zz_generated.deepcopy.go index 06fbb625a1..8f7498c356 100644 --- a/vendor/github.com/operator-framework/api/pkg/operators/v2/zz_generated.deepcopy.go +++ b/vendor/github.com/operator-framework/api/pkg/operators/v2/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/github.com/operator-framework/api/pkg/validation/errors/error.go b/vendor/github.com/operator-framework/api/pkg/validation/errors/error.go index 4ff55c0dd5..9b4391658b 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/errors/error.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/errors/error.go @@ -101,6 +101,7 @@ const ( ErrorInvalidBundle ErrorType = "BundleNotValid" ErrorInvalidPackageManifest ErrorType = "PackageManifestNotValid" ErrorObjectFailedValidation ErrorType = "ObjectFailedValidation" + ErrorPropertiesAnnotationUsed ErrorType = "PropertiesAnnotationUsed" ) func NewError(t ErrorType, detail, field string, v interface{}) Error { @@ -116,7 +117,7 @@ func ErrInvalidBundle(detail string, value interface{}) Error { } func WarnInvalidBundle(detail string, value interface{}) Error { - return invalidBundle(LevelError, detail, value) + return invalidBundle(LevelWarn, detail, value) } func invalidBundle(lvl Level, detail string, value interface{}) Error { @@ -243,3 +244,7 @@ func invalidObject(lvl Level, detail string, value interface{}) Error { func WarnInvalidObject(detail string, value interface{}) Error { return failedValidation(LevelWarn, detail, value) } + +func WarnPropertiesAnnotationUsed(detail string) Error { + return Error{ErrorPropertiesAnnotationUsed, LevelWarn, "", "", detail} +} diff --git a/vendor/github.com/operator-framework/api/pkg/validation/internal/annotations.go b/vendor/github.com/operator-framework/api/pkg/validation/internal/annotations.go index 95ee22a2cf..2ab63aa9fb 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/internal/annotations.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/internal/annotations.go @@ -9,6 +9,8 @@ import ( "github.com/operator-framework/api/pkg/validation/errors" ) +const olmpropertiesAnnotation = "olm.properties" + // CaseSensitiveAnnotationKeySet is a set of annotation keys that are case sensitive // and can be used for validation purposes. The key is always lowercase and the value // contains the expected case sensitive string. This may not be an exhaustive list. @@ -24,8 +26,9 @@ var CaseSensitiveAnnotationKeySet = map[string]string{ /* ValidateAnnotationNames will check annotation keys to ensure they are using proper case. Uses CaseSensitiveAnnotationKeySet as a source for keys -which are known to be case sensitive. This function can be used anywhere -annotations need to be checked for case sensitivity. +which are known to be case sensitive. It also checks to see if the olm.properties +annotation is defined in order to add a warning if present. This function can be +used anywhere annotations need to be checked for case sensitivity. Arguments @@ -48,6 +51,16 @@ func ValidateAnnotationNames(annotations map[string]string, value interface{}) ( errs = append(errs, errors.ErrFailedValidation(fmt.Sprintf("provided annotation %s uses wrong case and should be %s instead", annotationKey, knownCaseSensitiveKey), value)) } } + + if annotationKey == olmpropertiesAnnotation { + errs = append( + errs, + errors.WarnPropertiesAnnotationUsed( + fmt.Sprintf( + "found %s annotation, please define these properties in metadata/properties.yaml instead", + annotationKey, + ))) + } } return errs } diff --git a/vendor/github.com/operator-framework/api/pkg/validation/internal/bundle.go b/vendor/github.com/operator-framework/api/pkg/validation/internal/bundle.go index d109deab72..9bb90a04d3 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/internal/bundle.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/internal/bundle.go @@ -15,6 +15,12 @@ import ( var BundleValidator interfaces.Validator = interfaces.ValidatorFunc(validateBundles) +// max_bundle_size is the maximum size of a bundle in bytes. +// This ensures the bundle can be staged in a single ConfigMap by OLM during installation. +// The value is derived from the standard upper bound for k8s resources (~1MB). +// We will use this value to check the bundle compressed is < ~1MB +const max_bundle_size = int64(1 << (10 * 2)) + func validateBundles(objs ...interface{}) (results []errors.ManifestResult) { for _, obj := range objs { switch v := obj.(type) { @@ -32,6 +38,10 @@ func validateBundle(bundle *manifests.Bundle) (result errors.ManifestResult) { if saErrors != nil { result.Add(saErrors...) } + sizeErrors := validateBundleSize(bundle) + if sizeErrors != nil { + result.Add(sizeErrors...) + } return result } @@ -99,7 +109,7 @@ func validateOwnedCRDs(bundle *manifests.Bundle, csv *operatorsv1alpha1.ClusterS // All CRDs present in a CSV must be present in the bundle. for key := range keySet { - result.Add(errors.WarnInvalidBundle(fmt.Sprintf("CRD %q is present in bundle %q but not defined in CSV", key, bundle.Name), key)) + result.Add(errors.ErrInvalidBundle(fmt.Sprintf("CRD %q is present in bundle %q but not defined in CSV", key, bundle.Name), key)) } return result @@ -117,6 +127,62 @@ func getOwnedCustomResourceDefintionKeys(csv *operatorsv1alpha1.ClusterServiceVe return keys } +// validateBundleSize will check the bundle size according to its limits +// note that this check will raise an error if the size is bigger than the max allowed +// and warnings when: +// - we are unable to check the bundle size because we are running a check without load the bundle +// - we could identify that the bundle size is close to the limit (bigger than 85%) +func validateBundleSize(bundle *manifests.Bundle) []errors.Error { + warnPercent := 0.85 + warnSize := float64(max_bundle_size) * warnPercent + var errs []errors.Error + + if bundle.CompressedSize == 0 { + errs = append(errs, errors.WarnFailedValidation("unable to check the bundle compressed size", bundle.Name)) + return errs + } + + if bundle.Size == 0 { + errs = append(errs, errors.WarnFailedValidation("unable to check the bundle size", bundle.Name)) + return errs + } + + // From OPM (https://github.com/operator-framework/operator-registry) 1.17.5 + // and OLM (https://github.com/operator-framework/operator-lifecycle-manager) : v0.19.0 + // the total size checked is compressed + if bundle.CompressedSize > max_bundle_size { + errs = append(errs, errors.ErrInvalidBundle( + fmt.Sprintf("maximum bundle compressed size with gzip size exceeded: size=~%s , max=%s. Bundle uncompressed size is %s", + formatBytesInUnit(bundle.CompressedSize), + formatBytesInUnit(max_bundle_size), + formatBytesInUnit(bundle.Size)), + bundle.Name)) + } else if float64(bundle.CompressedSize) > warnSize { + errs = append(errs, errors.WarnInvalidBundle( + fmt.Sprintf("nearing maximum bundle compressed size with gzip: size=~%s , max=%s. Bundle uncompressed size is %s", + formatBytesInUnit(bundle.CompressedSize), + formatBytesInUnit(max_bundle_size), + formatBytesInUnit(bundle.Size)), + bundle.Name)) + } + + return errs +} + +func formatBytesInUnit(b int64) string { + const unit = 1000 + if b < unit { + return fmt.Sprintf("%d B", b) + } + div, exp := int64(unit), 0 + for n := b / unit; n >= unit; n /= unit { + div *= unit + exp++ + } + return fmt.Sprintf("%.1f %cB", + float64(b)/float64(div), "kMGTPE"[exp]) +} + // getBundleCRDKeys returns a set of definition keys for all CRDs in bundle. func getBundleCRDKeys(bundle *manifests.Bundle) (keys []schema.GroupVersionKind) { // Collect all v1 and v1beta1 CRD keys, skipping group which CSVs do not support. diff --git a/vendor/github.com/operator-framework/api/pkg/validation/internal/community.go b/vendor/github.com/operator-framework/api/pkg/validation/internal/community.go index 178729b7f7..dfc7c4aabe 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/internal/community.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/internal/community.go @@ -3,11 +3,12 @@ package internal import ( "encoding/json" "fmt" - "github.com/blang/semver" "io/ioutil" "os" "strings" + "github.com/blang/semver" + "github.com/operator-framework/api/pkg/manifests" "github.com/operator-framework/api/pkg/validation/errors" interfaces "github.com/operator-framework/api/pkg/validation/interfaces" diff --git a/vendor/github.com/operator-framework/api/pkg/validation/internal/crd.go b/vendor/github.com/operator-framework/api/pkg/validation/internal/crd.go index 79dae726e1..9a38f7b863 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/internal/crd.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/internal/crd.go @@ -12,7 +12,6 @@ import ( "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation" "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/runtime/schema" ) var scheme = runtime.NewScheme() @@ -44,8 +43,7 @@ func validateV1Beta1CRD(crd *v1beta1.CustomResourceDefinition) (result errors.Ma return result } - gv := crd.GetObjectKind().GroupVersionKind().GroupVersion() - result = validateInternalCRD(internalCRD, gv) + result = validateInternalCRD(internalCRD) return result } @@ -58,13 +56,12 @@ func validateV1CRD(crd *v1.CustomResourceDefinition) (result errors.ManifestResu return result } - gv := crd.GetObjectKind().GroupVersionKind().GroupVersion() - result = validateInternalCRD(internalCRD, gv) + result = validateInternalCRD(internalCRD) return result } -func validateInternalCRD(crd *apiextensions.CustomResourceDefinition, gv schema.GroupVersion) (result errors.ManifestResult) { - errList := validation.ValidateCustomResourceDefinition(crd, gv) +func validateInternalCRD(crd *apiextensions.CustomResourceDefinition) (result errors.ManifestResult) { + errList := validation.ValidateCustomResourceDefinition(crd) for _, err := range errList { if !strings.Contains(err.Field, "openAPIV3Schema") && !strings.Contains(err.Field, "status") { result.Add(errors.NewError(errors.ErrorType(err.Type), err.Error(), err.Field, err.BadValue)) diff --git a/vendor/github.com/operator-framework/api/pkg/validation/internal/csv.go b/vendor/github.com/operator-framework/api/pkg/validation/internal/csv.go index ea7145d078..b5b7683c0c 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/internal/csv.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/internal/csv.go @@ -1,6 +1,7 @@ package internal import ( + "encoding/json" "fmt" "io" "reflect" @@ -97,6 +98,12 @@ func validateExamplesAnnotations(csv *v1alpha1.ClusterServiceVersion) (errs []er } else { examplesString = olmExamples } + + if err := validateJSON(examplesString); err != nil { + errs = append(errs, errors.ErrInvalidParse("invalid example", err)) + return errs + } + us := []unstructured.Unstructured{} dec := yaml.NewYAMLOrJSONDecoder(strings.NewReader(examplesString), 8) if err := dec.Decode(&us); err != nil && err != io.EOF { @@ -115,6 +122,31 @@ func validateExamplesAnnotations(csv *v1alpha1.ClusterServiceVersion) (errs []er return errs } +func validateJSON(value string) error { + var js json.RawMessage + + if len(value) == 0 { + return nil + } + + byteValue := []byte(value) + if err := json.Unmarshal(byteValue, &js); err != nil { + switch t := err.(type) { + case *json.SyntaxError: + jsn := string(byteValue[0:t.Offset]) + jsn += "<--(see the invalid character)" + return fmt.Errorf("invalid character at %v\n %s", t.Offset, jsn) + case *json.UnmarshalTypeError: + jsn := string(byteValue[0:t.Offset]) + jsn += "<--(see the invalid type)" + return fmt.Errorf("invalid value at %v\n %s", t.Offset, jsn) + default: + return err + } + } + return nil +} + func getProvidedAPIs(csv *v1alpha1.ClusterServiceVersion) (provided map[schema.GroupVersionKind]struct{}, errs []errors.Error) { provided = map[schema.GroupVersionKind]struct{}{} for _, owned := range csv.Spec.CustomResourceDefinitions.Owned { diff --git a/vendor/github.com/operator-framework/api/pkg/validation/internal/good_practices.go b/vendor/github.com/operator-framework/api/pkg/validation/internal/good_practices.go index 5f22c86fdf..4d294ea6bb 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/internal/good_practices.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/internal/good_practices.go @@ -65,10 +65,10 @@ func validateResourceRequests(csv *operatorsv1alpha1.ClusterServiceVersion) (err for _, dSpec := range deploymentSpec { for _, c := range dSpec.Spec.Template.Spec.Containers { if c.Resources.Requests == nil || !(len(c.Resources.Requests.Cpu().String()) != 0 && len(c.Resources.Requests.Memory().String()) != 0) { - msg := fmt.Errorf("unable to find the resource requests for the container %s. It is recommended "+ + msg := fmt.Errorf("unable to find the resource requests for the container: (%s). It is recommended "+ "to ensure the resource request for CPU and Memory. Be aware that for some clusters configurations "+ "it is required to specify requests or limits for those values. Otherwise, the system or quota may "+ - "reject Pod creation. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", c.Name) + "reject Pod creation. More info: https://master.sdk.operatorframework.io/docs/best-practices/managing-resources/", c.Name) warns = append(warns, msg) } } diff --git a/vendor/github.com/operator-framework/api/pkg/validation/internal/operatorhub.go b/vendor/github.com/operator-framework/api/pkg/validation/internal/operatorhub.go index f265b0c134..48456b3088 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/internal/operatorhub.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/internal/operatorhub.go @@ -11,7 +11,7 @@ import ( "regexp" "strings" - semver "github.com/blang/semver/v4" + "github.com/blang/semver/v4" "github.com/operator-framework/api/pkg/manifests" "github.com/operator-framework/api/pkg/operators/v1alpha1" "github.com/operator-framework/api/pkg/validation/errors" @@ -158,6 +158,10 @@ var validCategories = map[string]struct{}{ "Streaming & Messaging": {}, } +const minKubeVersionWarnMessage = "csv.Spec.minKubeVersion is not informed. It is recommended you provide this information. " + + "Otherwise, it would mean that your operator project can be distributed and installed in any cluster version " + + "available, which is not necessarily the case for all projects." + func validateOperatorHub(objs ...interface{}) (results []errors.ManifestResult) { // Obtain the k8s version if informed via the objects an optional diff --git a/vendor/github.com/operator-framework/api/pkg/validation/internal/removed_apis.go b/vendor/github.com/operator-framework/api/pkg/validation/internal/removed_apis.go index 9377b50b00..44dee85d06 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/internal/removed_apis.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/internal/removed_apis.go @@ -3,30 +3,48 @@ package internal import ( "fmt" "github.com/blang/semver" - "github.com/operator-framework/api/pkg/manifests" - "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" - "github.com/operator-framework/api/pkg/validation/errors" interfaces "github.com/operator-framework/api/pkg/validation/interfaces" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "sort" ) // k8sVersionKey defines the key which can be used by its consumers // to inform what is the K8S version that should be used to do the tests against. const k8sVersionKey = "k8s-version" -const minKubeVersionWarnMessage = "csv.Spec.minKubeVersion is not informed. It is recommended you provide this information. " + - "Otherwise, it would mean that your operator project can be distributed and installed in any cluster version " + - "available, which is not necessarily the case for all projects." - -// K8s version where the apis v1betav1 is no longer supported -const k8sVerV1betav1Unsupported = "1.22.0" +// DeprecateMessage defines the content of the message that will be raised as an error or warning +// when the removed apis are found +const DeprecateMessage = "this bundle is using APIs which were deprecated and removed in v%v.%v. " + + "More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v%v-%v. " + + "Migrate the API(s) for %s" -// K8s version where the apis v1betav1 was deprecated -const k8sVerV1betav1Deprecated = "1.16.0" +// K8sVersionsSupportedByValidator defines the k8s versions which this validator is implemented to +// perform the checks +var K8sVersionsSupportedByValidator = []string{"1.22.0", "1.25.0", "1.26.0"} -// AlphaDeprecatedAPIsValidator validates if the bundles is using versions API version which are deprecate or -// removed in specific Kubernetes versions informed via optional key value `k8s-version`. +// AlphaDeprecatedAPIsValidator implements Validator to validate bundle objects +// for API deprecation requirements. +// +// Note that this validator looks at the manifests. If any removed APIs for the mapped k8s versions are found, +// it raises a warning. +// +// This validator only raises an error when the deprecated API found is removed in the specified k8s +// version informed via the optional key `k8s-version`. +// +// The K8s versions supported and checks are: +// +// - 1.22 : https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-22 +// +// - 1.25 : https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-25 +// +// - 1.26 : https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-26 +// +// IMPORTANT: Note that in the case scenarios of 1.25 and 1.26 it is very unlikely the OperatorAuthors +// add manifests on the bundle using these APIs. On top of that some Kinds such as the CronJob +// are not currently a valid/supported by OLM and never would to be added to bundle. +// See: https://github.com/operator-framework/operator-registry/blob/v1.19.5/pkg/lib/bundle/supported_resources.go#L3-L23 var AlphaDeprecatedAPIsValidator interfaces.Validator = interfaces.ValidatorFunc(validateDeprecatedAPIsValidator) func validateDeprecatedAPIsValidator(objs ...interface{}) (results []errors.ManifestResult) { @@ -54,13 +72,14 @@ func validateDeprecatedAPIsValidator(objs ...interface{}) (results []errors.Mani } func validateDeprecatedAPIs(bundle *manifests.Bundle, k8sVersion string) errors.ManifestResult { - result := errors.ManifestResult{Name: bundle.Name} - + result := errors.ManifestResult{} if bundle == nil { result.Add(errors.ErrInvalidBundle("Bundle is nil", nil)) return result } + result.Name = bundle.Name + if bundle.CSV == nil { result.Add(errors.ErrInvalidBundle("Bundle csv is nil", bundle.Name)) return result @@ -78,34 +97,22 @@ func validateDeprecatedAPIs(bundle *manifests.Bundle, k8sVersion string) errors. } // validateDeprecatedAPIS will check if the operator bundle is using a deprecated or no longer supported k8s api -// Note if the k8s was informed via "k8s=1.22" it will be used. Otherwise, we will use the minKubeVersion in -// the CSV to do the checks. So, the criteria is >=minKubeVersion. By last, if the minKubeVersion is not provided +// Note if the k8s version was informed via "k8s-version" optional key it will be used. Otherwise, we will use the minKubeVersion in +// the CSV to do the checks. So, the criteria is >=minKubeVersion. Lastly, if the minKubeVersion is not provided // then, we should consider the operator bundle is intend to work well in any Kubernetes version. // Then, it means that: -//--optional-values="k8s-version=value" flag with a value => 1.16 <= 1.22 the validator will return result as warning. -//--optional-values="k8s-version=value" flag with a value => 1.22 the validator will return result as error. -//minKubeVersion >= 1.22 return the error result. -//minKubeVersion empty returns a warning since it would mean the same of allow install in any supported version +// - --optional-values="k8s-version=value" flag with a value <= unsupportedAPIVersion the validator will return result as warning. +// - --optional-values="k8s-version=value" flag with a value => unsupportedAPIVersion the validator will return result as error. +// - minKubeVersion >= unsupportedAPIVersion return the error result. +// - minKubeVersion empty returns a warning since it would mean the same of allow in any supported version func validateDeprecatedAPIS(bundle *manifests.Bundle, versionProvided string) (errs, warns []error) { - - // semver of the K8s version where the apis v1betav1 is no longer supported to allow us compare - semVerK8sVerV1betav1Unsupported := semver.MustParse(k8sVerV1betav1Unsupported) - // semver of the K8s version where the apis v1betav1 is deprecated to allow us compare - semVerk8sVerV1betav1Deprecated := semver.MustParse(k8sVerV1betav1Deprecated) // isVersionProvided defines if the k8s version to test against was or not informed isVersionProvided := len(versionProvided) > 0 + // semVerVersionProvided -- converts the k8s version informed in semver + semVerVersionProvided, _ := semver.ParseTolerant(versionProvided) - // Transform the key/option versionProvided in semver Version to compare - var semVerVersionProvided semver.Version - if isVersionProvided { - var err error - semVerVersionProvided, err = semver.ParseTolerant(versionProvided) - if err != nil { - errs = append(errs, fmt.Errorf("invalid value informed via the k8s key option : %s", versionProvided)) - } else { - // we might want to return it as info instead of warning in the future. - warns = append(warns, fmt.Errorf("checking APIs against Kubernetes version : %s", versionProvided)) - } + if err := verifyK8sVersionInformed(versionProvided); err != nil && isVersionProvided { + errs = append(errs, err) } // Transform the spec minKubeVersion in semver Version to compare @@ -118,39 +125,86 @@ func validateDeprecatedAPIS(bundle *manifests.Bundle, versionProvided string) (e } } - // if the k8s value was informed and it is >=1.16 we should check - // if the k8s value was not informed we also should check since the - // check should occurs with any minKubeVersion value: - // - if minKubeVersion empty then means that the project can be installed in any version - // - if minKubeVersion any version defined it means that we are considering install - // in any upper version from that where the check is always applied - if !isVersionProvided || semVerVersionProvided.GE(semVerk8sVerV1betav1Deprecated) { - deprecatedAPIs := getRemovedAPIsOn1_22From(bundle) - if len(deprecatedAPIs) > 0 { - deprecatedAPIsMessage := generateMessageWithDeprecatedAPIs(deprecatedAPIs) - // isUnsupported is true only if the key/value OR minKubeVersion were informed and are >= 1.22 - isUnsupported := semVerVersionProvided.GE(semVerK8sVerV1betav1Unsupported) || - semverMinKube.GE(semVerK8sVerV1betav1Unsupported) - // We only raise an error when the version >= 1.22 was informed via + // Check the bundle with all k8s versions implemented + for _, v := range K8sVersionsSupportedByValidator { + k8sVersionToCheck := semver.MustParse(v) + errs, warns = checkRemovedAPIsForVersion(bundle, + k8sVersionToCheck, + semVerVersionProvided, + semverMinKube, + errs, + warns) + } + + return errs, warns +} + +// checkRemovedAPIsForVersion will check if the bundle is using the removed APIs +// for the version informed (k8sVersionToCheck) +func checkRemovedAPIsForVersion( + bundle *manifests.Bundle, + k8sVersionToCheck, semVerVersionProvided, semverMinKube semver.Version, + errs []error, warns []error) ([]error, []error) { + + found := map[string][]string{} + switch k8sVersionToCheck.String() { + case "1.22.0": + found = getRemovedAPIsOn1_22From(bundle) + case "1.25.0": + found = getRemovedAPIsOn1_25From(bundle) + case "1.26.0": + found = getRemovedAPIsOn1_26From(bundle) + default: + panic(fmt.Errorf("invalid internal call to check the removed apis with the version (%s) which is not supported", k8sVersionToCheck.String())) + } + + if len(found) > 0 { + deprecatedAPIsMessage := generateMessageWithDeprecatedAPIs(found) + msg := fmt.Errorf(DeprecateMessage, + k8sVersionToCheck.Major, k8sVersionToCheck.Minor, + k8sVersionToCheck.Major, k8sVersionToCheck.Minor, + deprecatedAPIsMessage) + if isK8sVersionInformedEQ(semVerVersionProvided, k8sVersionToCheck, semverMinKube) { + // We only raise an error when the version >= 1.26 was informed via // the k8s key/value option or is specifically defined in the CSV - msg := fmt.Errorf("this bundle is using APIs which were deprecated and removed in v1.22. More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-22. Migrate the API(s) for %s", deprecatedAPIsMessage) - if isUnsupported { - errs = append(errs, msg) - } else { - warns = append(warns, msg) - } + errs = append(errs, msg) + } else { + warns = append(warns, msg) } } - return errs, warns } +// isK8sVersionInformedEQ returns true only if the key/value OR minKubeVersion were informed and are >= semVerAPIUnsupported +func isK8sVersionInformedEQ(semVerVersionProvided semver.Version, semVerAPIUnsupported semver.Version, semverMinKube semver.Version) bool { + return semVerVersionProvided.GE(semVerAPIUnsupported) || semverMinKube.GE(semVerAPIUnsupported) +} + +func verifyK8sVersionInformed(versionProvided string) error { + if _, err := semver.ParseTolerant(versionProvided); err != nil { + return fmt.Errorf("invalid value informed via the k8s key option : %s", versionProvided) + } + return nil +} + // generateMessageWithDeprecatedAPIs will return a list with the kind and the name // of the resource which were found and required to be upgraded func generateMessageWithDeprecatedAPIs(deprecatedAPIs map[string][]string) string { msg := "" count := 0 - for k, v := range deprecatedAPIs { + + keys := make([]string, 0, len(deprecatedAPIs)) + for k := range deprecatedAPIs { + keys = append(keys, k) + } + sort.Strings(keys) + + deprecatedAPIsSorted := make(map[string][]string) + for _, key := range keys { + deprecatedAPIsSorted[key] = deprecatedAPIs[key] + } + + for k, v := range deprecatedAPIsSorted { if count == len(deprecatedAPIs)-1 { msg = msg + fmt.Sprintf("%s: (%+q)", k, v) } else { @@ -160,9 +214,6 @@ func generateMessageWithDeprecatedAPIs(deprecatedAPIs map[string][]string) strin return msg } -// todo: we need to improve this code since we ought to map the kinds, apis and ocp/k8s versions -// where them are no longer supported ( removed ) instead of have this fixed in this way. - // getRemovedAPIsOn1_22From return the list of resources which were deprecated // and are no longer be supported in 1.22. More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-22 func getRemovedAPIsOn1_22From(bundle *manifests.Bundle) map[string][]string { @@ -228,3 +279,69 @@ func getRemovedAPIsOn1_22From(bundle *manifests.Bundle) map[string][]string { } return deprecatedAPIs } + +// getRemovedAPIsOn1_25From return the list of resources which were deprecated +// and are no longer be supported in 1.25. More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-25 +// +// IMPORTANT: Note that in the case scenarios of 1.25 and 1.26 it is very unlikely the OperatorAuthors +// add manifests on the bundle using these APIs. On top of that some Kinds such as the CronJob +// are not currently a valid/supported by OLM and never would to be added to bundle. +// See: https://github.com/operator-framework/operator-registry/blob/v1.19.5/pkg/lib/bundle/supported_resources.go#L3-L23 +func getRemovedAPIsOn1_25From(bundle *manifests.Bundle) map[string][]string { + deprecatedAPIs := make(map[string][]string) + for _, obj := range bundle.Objects { + switch u := obj.GetObjectKind().(type) { + case *unstructured.Unstructured: + switch u.GetAPIVersion() { + case "batch/v1beta1": + if u.GetKind() == "CronJob" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "discovery.k8s.io/v1beta1": + if u.GetKind() == "EndpointSlice" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "events.k8s.io/v1beta1": + if u.GetKind() == "Event" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "autoscaling/v2beta1": + if u.GetKind() == "HorizontalPodAutoscaler" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "policy/v1beta1": + if u.GetKind() == "PodDisruptionBudget" || u.GetKind() == "PodSecurityPolicy" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + case "node.k8s.io/v1beta1": + if u.GetKind() == "RuntimeClass" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + } + } + } + return deprecatedAPIs +} + +// getRemovedAPIsOn1_26From return the list of resources which were deprecated +// and are no longer be supported in 1.26. More info: https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-26 +// +// IMPORTANT: Note that in the case scenarios of 1.25 and 1.26 it is very unlikely the OperatorAuthors +// add manifests on the bundle using these APIs. On top of that some Kinds such as the CronJob +// are not currently a valid/supported by OLM and never would to be added to bundle. +// See: https://github.com/operator-framework/operator-registry/blob/v1.19.5/pkg/lib/bundle/supported_resources.go#L3-L23 +func getRemovedAPIsOn1_26From(bundle *manifests.Bundle) map[string][]string { + deprecatedAPIs := make(map[string][]string) + for _, obj := range bundle.Objects { + switch u := obj.GetObjectKind().(type) { + case *unstructured.Unstructured: + switch u.GetAPIVersion() { + case "autoscaling/v2beta2": + if u.GetKind() == "HorizontalPodAutoscaler" { + deprecatedAPIs[u.GetKind()] = append(deprecatedAPIs[u.GetKind()], obj.GetName()) + } + } + } + } + return deprecatedAPIs +} diff --git a/vendor/github.com/operator-framework/api/pkg/validation/validation.go b/vendor/github.com/operator-framework/api/pkg/validation/validation.go index d84a5ace77..1d87737fa2 100644 --- a/vendor/github.com/operator-framework/api/pkg/validation/validation.go +++ b/vendor/github.com/operator-framework/api/pkg/validation/validation.go @@ -48,6 +48,12 @@ var CommunityOperatorValidator = internal.CommunityOperatorValidator // AlphaDeprecatedAPIsValidator implements Validator to validate bundle objects // for API deprecation requirements. +// +// Note that this validator looks at the manifests. If any removed APIs for the mapped k8s versions are found, +// it raises a warning. +// +// This validator only raises an error when the deprecated API found is removed in the specified k8s +// version informed via the optional key `k8s-version`. var AlphaDeprecatedAPIsValidator = internal.AlphaDeprecatedAPIsValidator // GoodPracticesValidator implements Validator to validate the criteria defined as good practices diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go index 78f0acc70c..15f8492797 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go @@ -2,14 +2,13 @@ package main import ( "context" - "flag" "fmt" "net/http" "os" "time" configv1client "github.com/openshift/client-go/config/clientset/versioned/typed/config/v1" - log "github.com/sirupsen/logrus" + "github.com/sirupsen/logrus" utilclock "k8s.io/apimachinery/pkg/util/clock" k8sscheme "k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/tools/clientcmd" @@ -20,9 +19,7 @@ import ( "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorstatus" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/server" - "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/signals" "github.com/operator-framework/operator-lifecycle-manager/pkg/metrics" - olmversion "github.com/operator-framework/operator-lifecycle-manager/pkg/version" ) const ( @@ -36,80 +33,33 @@ const ( ) // config flags defined globally so that they appear on the test binary as well -var ( - kubeConfigPath = flag.String( - "kubeconfig", "", "absolute path to the kubeconfig file") - - wakeupInterval = flag.Duration( - "interval", defaultWakeupInterval, "wakeup interval") - - catalogNamespace = flag.String( - "namespace", defaultCatalogNamespace, "namespace where catalog will run and install catalog resources") - - configmapServerImage = flag.String( - "configmapServerImage", defaultConfigMapServerImage, "the image to use for serving the operator registry api for a configmap") - - opmImage = flag.String( - "opmImage", defaultOPMImage, "the image to use for unpacking bundle content with opm") - - utilImage = flag.String( - "util-image", defaultUtilImage, "an image containing custom olm utilities") - - writeStatusName = flag.String( - "writeStatusName", defaultOperatorName, "ClusterOperator name in which to write status, set to \"\" to disable.") - - debug = flag.Bool( - "debug", false, "use debug log level") - - version = flag.Bool("version", false, "displays olm version") - - tlsKeyPath = flag.String( - "tls-key", "", "Path to use for private key (requires tls-cert)") - - tlsCertPath = flag.String( - "tls-cert", "", "Path to use for certificate key (requires tls-key)") - - profiling = flag.Bool("profiling", false, "deprecated") - - clientCAPath = flag.String("client-ca", "", "path to watch for client ca bundle") - - installPlanTimeout = flag.Duration("install-plan-retry-timeout", 1*time.Minute, "time since first attempt at which plan execution errors are considered fatal") - bundleUnpackTimeout = flag.Duration("bundle-unpack-timeout", 10*time.Minute, "The time limit for bundle unpacking, after which InstallPlan execution is considered to have failed. 0 is considered as having no timeout.") -) func init() { metrics.RegisterCatalog() } func main() { - // Get exit signal context - ctx, cancel := context.WithCancel(signals.Context()) - defer cancel() - - // Parse the command-line flags. - flag.Parse() - - // Check if version flag was set - if *version { - fmt.Print(olmversion.String()) - os.Exit(0) - } - - logger := log.New() - if *debug { - logger.SetLevel(log.DebugLevel) + cmd := newRootCmd() + if err := cmd.Execute(); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) } - logger.Infof("log level %s", logger.Level) +} +func (o *options) run(ctx context.Context, logger *logrus.Logger) error { // If the catalogNamespaceEnvVarName environment variable is set, then update the value of catalogNamespace. if catalogNamespaceEnvVarValue := os.Getenv(catalogNamespaceEnvVarName); catalogNamespaceEnvVarValue != "" { logger.Infof("%s environment variable is set. Updating Global Catalog Namespace to %s", catalogNamespaceEnvVarName, catalogNamespaceEnvVarValue) - *catalogNamespace = catalogNamespaceEnvVarValue + o.catalogNamespace = catalogNamespaceEnvVarValue } - listenAndServe, err := server.GetListenAndServeFunc(server.WithLogger(logger), server.WithTLS(tlsCertPath, tlsKeyPath, clientCAPath), server.WithDebug(*debug)) + listenAndServe, err := server.GetListenAndServeFunc( + server.WithLogger(logger), + server.WithTLS(&o.tlsCertPath, &o.tlsKeyPath, &o.clientCAPath), + server.WithDebug(o.debug), + ) if err != nil { - logger.Fatalf("Error setting up health/metric/pprof service: %v", err) + return fmt.Errorf("error setting up health/metric/pprof service: %v", err) } go func() { @@ -119,29 +69,49 @@ func main() { }() // create a config client for operator status - config, err := clientcmd.BuildConfigFromFlags("", *kubeConfigPath) + config, err := clientcmd.BuildConfigFromFlags("", o.kubeconfig) if err != nil { - log.Fatalf("error configuring client: %s", err.Error()) + return fmt.Errorf("error configuring client: %s", err.Error()) } configClient, err := configv1client.NewForConfig(config) if err != nil { - log.Fatalf("error configuring client: %s", err.Error()) + return fmt.Errorf("error configuring client: %s", err.Error()) } - opClient := operatorclient.NewClientFromConfig(*kubeConfigPath, logger) - crClient, err := client.NewClient(*kubeConfigPath) + opClient := operatorclient.NewClientFromConfig(o.kubeconfig, logger) + crClient, err := client.NewClient(o.kubeconfig) if err != nil { - log.Fatalf("error configuring client: %s", err.Error()) + return fmt.Errorf("error configuring client: %s", err.Error()) } + // TODO(tflannag): Use options pattern for catalog operator // Create a new instance of the operator. - op, err := catalog.NewOperator(ctx, *kubeConfigPath, utilclock.RealClock{}, logger, *wakeupInterval, *configmapServerImage, *opmImage, *utilImage, *catalogNamespace, k8sscheme.Scheme, *installPlanTimeout, *bundleUnpackTimeout) + op, err := catalog.NewOperator( + ctx, + o.kubeconfig, + utilclock.RealClock{}, + logger, + o.wakeupInterval, + o.configMapServerImage, + o.opmImage, + o.utilImage, + o.catalogNamespace, + k8sscheme.Scheme, + o.installPlanTimeout, + o.bundleUnpackTimeout, + ) if err != nil { - log.Fatalf("error configuring catalog operator: %s", err.Error()) + return fmt.Errorf("error configuring catalog operator: %s", err.Error()) } - opCatalogTemplate, err := catalogtemplate.NewOperator(ctx, *kubeConfigPath, logger, *wakeupInterval, *catalogNamespace) + opCatalogTemplate, err := catalogtemplate.NewOperator( + ctx, + o.kubeconfig, + logger, + o.wakeupInterval, + o.catalogNamespace, + ) if err != nil { - log.Fatalf("error configuring catalog template operator: %s", err.Error()) + return fmt.Errorf("error configuring catalog template operator: %s", err.Error()) } op.Run(ctx) @@ -150,9 +120,11 @@ func main() { opCatalogTemplate.Run(ctx) <-opCatalogTemplate.Ready() - if *writeStatusName != "" { - operatorstatus.MonitorClusterStatus(*writeStatusName, op.AtLevel(), op.Done(), opClient, configClient, crClient) + if o.writeStatusName != "" { + operatorstatus.MonitorClusterStatus(o.writeStatusName, op.AtLevel(), op.Done(), opClient, configClient, crClient, logger) } <-op.Done() + + return nil } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/start.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/start.go new file mode 100644 index 0000000000..45a0953c08 --- /dev/null +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/start.go @@ -0,0 +1,84 @@ +package main + +import ( + "context" + "fmt" + "os" + "time" + + "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/signals" + olmversion "github.com/operator-framework/operator-lifecycle-manager/pkg/version" + "github.com/sirupsen/logrus" + "github.com/spf13/cobra" +) + +type options struct { + kubeconfig string + catalogNamespace string + configMapServerImage string + opmImage string + utilImage string + writeStatusName string + debug bool + version bool + profiling bool + tlsKeyPath string + tlsCertPath string + clientCAPath string + + installPlanTimeout time.Duration + bundleUnpackTimeout time.Duration + wakeupInterval time.Duration +} + +func newRootCmd() *cobra.Command { + o := options{} + + cmd := &cobra.Command{ + Use: "Start", + Short: "Starts the Catalog Operator", + SilenceUsage: true, + RunE: func(cmd *cobra.Command, args []string) error { + if o.version { + fmt.Print(olmversion.String()) + return nil + } + + logger := logrus.New() + if o.debug { + logger.SetLevel(logrus.DebugLevel) + } + logger.Infof("log level %s", logger.Level) + + ctx, cancel := context.WithCancel(signals.Context()) + defer cancel() + + if err := o.run(ctx, logger); err != nil { + return err + } + return nil + }, + } + + cmd.Flags().StringVar(&o.kubeconfig, "kubeconfig", os.Getenv("KUBECONFIG"), "absolute path to the kubeconfig file") + cmd.Flags().StringVar(&o.catalogNamespace, "namespace", defaultCatalogNamespace, "namespace where catalog will run and install catalog resources") + cmd.Flags().StringVar(&o.configMapServerImage, "configmapServerImage", defaultConfigMapServerImage, "the image to use for serving the operator registry api for a configmap") + cmd.Flags().StringVar(&o.opmImage, "opmImage", defaultOPMImage, "the image to use for unpacking bundle content with opm") + cmd.Flags().StringVar(&o.utilImage, "util-image", defaultUtilImage, "an image containing custom olm utilities") + cmd.Flags().StringVar(&o.writeStatusName, "writeStatusName", defaultOperatorName, "ClusterOperator name in which to write status, set to \"\" to disable.") + + cmd.Flags().BoolVar(&o.debug, "debug", false, "use debug log level") + cmd.Flags().BoolVar(&o.version, "version", false, "displays the olm version") + cmd.Flags().BoolVar(&o.profiling, "profiling", false, "deprecated") + cmd.Flags().MarkDeprecated("profiling", "profiling is now enabled by default") + + cmd.Flags().StringVar(&o.tlsKeyPath, "tls-key", "", "path to use for private key (requires tls-cert)") + cmd.Flags().StringVar(&o.tlsCertPath, "tls-cert", "", "path to use for certificate key (requires tls-key)") + cmd.Flags().StringVar(&o.clientCAPath, "client-ca", "", "path to watch for client ca bundle") + + cmd.Flags().DurationVar(&o.wakeupInterval, "interval", defaultWakeupInterval, "wakeup interval") + cmd.Flags().DurationVar(&o.bundleUnpackTimeout, "bundle-unpack-timeout", 10*time.Minute, "The time limit for bundle unpacking, after which InstallPlan execution is considered to have failed. 0 is considered as having no timeout.") + cmd.Flags().DurationVar(&o.installPlanTimeout, "install-plan-retry-timeout", 1*time.Minute, "time since first attempt at which plan execution errors are considered fatal") + + return cmd +} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/main.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/main.go index dd67a27a79..463526c086 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/main.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/main.go @@ -63,7 +63,7 @@ var ( tlsCertPath = pflag.String( "tls-cert", "", "Path to use for certificate key (requires tls-key)") - profiling = pflag.Bool("profiling", false, "deprecated") + _ = pflag.Bool("profiling", false, "deprecated") clientCAPath = pflag.String("client-ca", "", "path to watch for client ca bundle") @@ -173,7 +173,7 @@ func main() { // Emit CSV metric if err = op.EnsureCSVMetric(); err != nil { - logger.WithError(err).Fatalf("error emitting metrics for existing CSV") + logger.WithError(err).Fatal("error emitting metrics for existing CSV") } if *writeStatusName != "" { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/manager.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/manager.go index 5e8e33ab73..36b0d6b8f9 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/manager.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/manager.go @@ -118,7 +118,6 @@ func Manager(ctx context.Context, debug bool) (ctrl.Manager, error) { if err = adoptionReconciler.SetupWithManager(mgr); err != nil { return nil, err } - } setupLog.Info("manager configured") diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/package-server/main.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/package-server/main.go index e41353069a..c20de6282b 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/package-server/main.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/package-server/main.go @@ -6,6 +6,7 @@ import ( log "github.com/sirupsen/logrus" "k8s.io/component-base/logs" + "k8s.io/klog" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/signals" "github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/server" @@ -19,6 +20,11 @@ func main() { options := server.NewPackageServerOptions(os.Stdout, os.Stderr) cmd := server.NewCommandStartPackageServer(ctx, options) cmd.Flags().AddGoFlagSet(flag.CommandLine) + // klog flags used by dependencies need to be explicitly initialized now + klogFlags := flag.NewFlagSet("klog", flag.ExitOnError) + klog.InitFlags(klogFlags) + cmd.Flags().AddGoFlagSet(klogFlags) + if err := cmd.Flags().Parse(flag.Args()); err != nil { log.Fatal(err) } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/clientset.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/clientset.go index b4ef6d1c2f..43e2b2a0ba 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/clientset.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/clientset.go @@ -20,6 +20,7 @@ package versioned import ( "fmt" + "net/http" operatorsv1 "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1" operatorsv1alpha1 "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1alpha1" @@ -79,34 +80,53 @@ func (c *Clientset) Discovery() discovery.DiscoveryInterface { // NewForConfig creates a new Clientset for the given config. // If config's RateLimiter is not set and QPS and Burst are acceptable, // NewForConfig will generate a rate-limiter in configShallowCopy. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*Clientset, error) { configShallowCopy := *c + + // share the transport between all clients + httpClient, err := rest.HTTPClientFor(&configShallowCopy) + if err != nil { + return nil, err + } + + return NewForConfigAndClient(&configShallowCopy, httpClient) +} + +// NewForConfigAndClient creates a new Clientset for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +// If config's RateLimiter is not set and QPS and Burst are acceptable, +// NewForConfigAndClient will generate a rate-limiter in configShallowCopy. +func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset, error) { + configShallowCopy := *c if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 { if configShallowCopy.Burst <= 0 { return nil, fmt.Errorf("burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0") } configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst) } + var cs Clientset var err error - cs.operatorsV1alpha1, err = operatorsv1alpha1.NewForConfig(&configShallowCopy) + cs.operatorsV1alpha1, err = operatorsv1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.operatorsV1alpha2, err = operatorsv1alpha2.NewForConfig(&configShallowCopy) + cs.operatorsV1alpha2, err = operatorsv1alpha2.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.operatorsV1, err = operatorsv1.NewForConfig(&configShallowCopy) + cs.operatorsV1, err = operatorsv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.operatorsV2, err = operatorsv2.NewForConfig(&configShallowCopy) + cs.operatorsV2, err = operatorsv2.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy) + cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } @@ -116,14 +136,11 @@ func NewForConfig(c *rest.Config) (*Clientset, error) { // NewForConfigOrDie creates a new Clientset for the given config and // panics if there is an error in the config. func NewForConfigOrDie(c *rest.Config) *Clientset { - var cs Clientset - cs.operatorsV1alpha1 = operatorsv1alpha1.NewForConfigOrDie(c) - cs.operatorsV1alpha2 = operatorsv1alpha2.NewForConfigOrDie(c) - cs.operatorsV1 = operatorsv1.NewForConfigOrDie(c) - cs.operatorsV2 = operatorsv2.NewForConfigOrDie(c) - - cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) - return &cs + cs, err := NewForConfig(c) + if err != nil { + panic(err) + } + return cs } // New creates a new Clientset for the given RESTClient. diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1/operators_client.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1/operators_client.go index e1b950ccf4..436cd1ac5c 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1/operators_client.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1/operators_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "github.com/operator-framework/api/pkg/operators/v1" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/scheme" rest "k8s.io/client-go/rest" @@ -54,12 +56,28 @@ func (c *OperatorsV1Client) OperatorGroups(namespace string) OperatorGroupInterf } // NewForConfig creates a new OperatorsV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*OperatorsV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new OperatorsV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*OperatorsV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1alpha1/operators_client.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1alpha1/operators_client.go index 4dd3ac77ca..0e28266405 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1alpha1/operators_client.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1alpha1/operators_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1alpha1 import ( + "net/http" + v1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/scheme" rest "k8s.io/client-go/rest" @@ -54,12 +56,28 @@ func (c *OperatorsV1alpha1Client) Subscriptions(namespace string) SubscriptionIn } // NewForConfig creates a new OperatorsV1alpha1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*OperatorsV1alpha1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new OperatorsV1alpha1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*OperatorsV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1alpha2/operators_client.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1alpha2/operators_client.go index 63bb976d47..2985602607 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1alpha2/operators_client.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v1alpha2/operators_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1alpha2 import ( + "net/http" + v1alpha2 "github.com/operator-framework/api/pkg/operators/v1alpha2" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *OperatorsV1alpha2Client) OperatorGroups(namespace string) OperatorGroup } // NewForConfig creates a new OperatorsV1alpha2Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*OperatorsV1alpha2Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new OperatorsV1alpha2Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*OperatorsV1alpha2Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v2/operators_client.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v2/operators_client.go index 20b453770b..a09d46f08a 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v2/operators_client.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/typed/operators/v2/operators_client.go @@ -19,6 +19,8 @@ limitations under the License. package v2 import ( + "net/http" + v2 "github.com/operator-framework/api/pkg/operators/v2" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *OperatorsV2Client) OperatorConditions(namespace string) OperatorConditi } // NewForConfig creates a new OperatorsV2Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*OperatorsV2Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new OperatorsV2Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*OperatorsV2Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go index f30f610c61..55665aada6 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go @@ -384,7 +384,6 @@ const ( ) func (c *ConfigMapUnpacker) UnpackBundle(lookup *operatorsv1alpha1.BundleLookup, timeout time.Duration) (result *BundleUnpackResult, err error) { - result = newBundleUnpackResult(lookup) // if bundle lookup failed condition already present, then there is nothing more to do @@ -523,8 +522,8 @@ func (c *ConfigMapUnpacker) pendingContainerStatusMessages(job *batchv1.Job) (st podLabel := map[string]string{BundleUnpackPodLabel: job.GetName()} pods, listErr := c.podLister.Pods(job.GetNamespace()).List(k8slabels.SelectorFromValidatedSet(podLabel)) if listErr != nil { - c.logger.Errorf("Failed to list pods for job(%s): %v", job.GetName(), listErr) - return "", fmt.Errorf("Failed to list pods for job(%s): %v", job.GetName(), listErr) + c.logger.Errorf("failed to list pods for job(%s): %v", job.GetName(), listErr) + return "", fmt.Errorf("failed to list pods for job(%s): %v", job.GetName(), listErr) } // Ideally there should be just 1 pod running but inspect all pods in the pending phase @@ -570,14 +569,14 @@ func (c *ConfigMapUnpacker) ensureConfigmap(csRef *corev1.ObjectReference, name if err != nil && apierrors.IsAlreadyExists(err) { cm, err = c.client.CoreV1().ConfigMaps(fresh.GetNamespace()).Get(context.TODO(), fresh.GetName(), metav1.GetOptions{}) if err != nil { - return nil, fmt.Errorf("Failed to retrieve configmap %s: %v", fresh.GetName(), err) + return nil, fmt.Errorf("failed to retrieve configmap %s: %v", fresh.GetName(), err) } cm.SetLabels(map[string]string{ install.OLMManagedLabelKey: install.OLMManagedLabelValue, }) cm, err = c.client.CoreV1().ConfigMaps(cm.GetNamespace()).Update(context.TODO(), cm, metav1.UpdateOptions{}) if err != nil { - return nil, fmt.Errorf("Failed to update configmap %s: %v", cm.GetName(), err) + return nil, fmt.Errorf("failed to update configmap %s: %v", cm.GetName(), err) } } } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/apiservice.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/apiservice.go index c54a1f8ed6..1f1061c43b 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/apiservice.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/apiservice.go @@ -44,7 +44,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateAPIService(caPEM []byte, des apiService = apiService.DeepCopy() csv, ok := i.owner.(*v1alpha1.ClusterServiceVersion) if !ok { - return fmt.Errorf("APIServices require a CSV Owner.") + return fmt.Errorf("failed to typecast the APIService owner: APIServices require a CSV owner") } adoptable, err := IsAPIServiceAdoptable(i.strategyClient.GetOpLister(), csv, apiService) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/certresources.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/certresources.go index 49fd37f97f..1021a2d265 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/certresources.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/certresources.go @@ -246,7 +246,7 @@ func (i *StrategyDeploymentInstaller) installCertRequirementsForDeployment(deplo // Delete the Service to replace deleteErr := i.strategyClient.GetOpClient().DeleteService(service.GetNamespace(), service.GetName(), &metav1.DeleteOptions{}) - if err != nil && !k8serrors.IsNotFound(deleteErr) { + if deleteErr != nil && !k8serrors.IsNotFound(deleteErr) { return nil, nil, fmt.Errorf("could not delete existing service %s", service.GetName()) } } @@ -315,7 +315,6 @@ func (i *StrategyDeploymentInstaller) installCertRequirementsForDeployment(deplo logger.Warnf("could not update secret %s", secret.GetName()) return nil, nil, err } - } else if k8serrors.IsNotFound(err) { // Create the secret ownerutil.AddNonBlockingOwner(secret, i.owner) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/deployment.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/deployment.go index d458bf3469..61adbb623b 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/deployment.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/deployment.go @@ -179,23 +179,6 @@ func (i *StrategyDeploymentInstaller) deploymentForSpec(name string, spec appsv1 return } -func (i *StrategyDeploymentInstaller) cleanupPrevious(current *v1alpha1.StrategyDetailsDeployment, previous *v1alpha1.StrategyDetailsDeployment) error { - previousDeploymentsMap := map[string]struct{}{} - for _, d := range previous.DeploymentSpecs { - previousDeploymentsMap[d.Name] = struct{}{} - } - for _, d := range current.DeploymentSpecs { - delete(previousDeploymentsMap, d.Name) - } - log.Debugf("preparing to cleanup: %s", previousDeploymentsMap) - // delete deployments in old strategy but not new - var err error = nil - for name := range previousDeploymentsMap { - err = i.strategyClient.DeleteDeployment(name) - } - return err -} - func (i *StrategyDeploymentInstaller) Install(s Strategy) error { strategy, ok := s.(*v1alpha1.StrategyDetailsDeployment) if !ok { @@ -235,11 +218,6 @@ func (i *StrategyDeploymentInstaller) CheckInstalled(s Strategy) (installed bool } func (i *StrategyDeploymentInstaller) checkForDeployments(deploymentSpecs []v1alpha1.StrategyDeploymentSpec) error { - var depNames []string - for _, dep := range deploymentSpecs { - depNames = append(depNames, dep.Name) - } - // Check the owner is a CSV csv, ok := i.owner.(*v1alpha1.ClusterServiceVersion) if !ok { @@ -273,7 +251,7 @@ func (i *StrategyDeploymentInstaller) checkForDeployments(deploymentSpecs []v1al // check annotations if len(i.templateAnnotations) > 0 && dep.Spec.Template.Annotations == nil { - return StrategyError{Reason: StrategyErrReasonAnnotationsMissing, Message: fmt.Sprintf("no annotations found on deployment")} + return StrategyError{Reason: StrategyErrReasonAnnotationsMissing, Message: "no annotations found on deployment"} } for key, value := range i.templateAnnotations { if actualValue, ok := dep.Spec.Template.Annotations[key]; !ok { @@ -286,11 +264,11 @@ func (i *StrategyDeploymentInstaller) checkForDeployments(deploymentSpecs []v1al // check that the deployment spec hasn't changed since it was created labels := dep.GetLabels() if len(labels) == 0 { - return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment doesn't have a spec hash, update it")} + return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment %s doesn't have a spec hash, update it", dep.Name)} } existingDeploymentSpecHash, ok := labels[DeploymentSpecHashLabelKey] if !ok { - return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment doesn't have a spec hash, update it")} + return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment %s doesn't have a spec hash, update it", dep.Name)} } _, calculatedDeploymentHash, err := i.deploymentForSpec(spec.Name, spec.Spec, labels) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/rule_checker.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/rule_checker.go index b1550776d5..88dd64037f 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/rule_checker.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/rule_checker.go @@ -67,7 +67,6 @@ func (c *CSVRuleChecker) RuleSatisfied(sa *corev1.ServiceAccount, namespace stri if decision == authorizer.DecisionDeny || decision == authorizer.DecisionNoOpinion { return false, nil } - } return true, nil diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/webhook.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/webhook.go index c1dd4a1252..74c1987516 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/webhook.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/webhook.go @@ -24,18 +24,18 @@ func ValidWebhookRules(rules []admissionregistrationv1.RuleWithOperations) error // protect OLM resources if contains(apiGroupMap, "*") { - return fmt.Errorf("Webhook rules cannot include all groups") + return fmt.Errorf("webhook rules cannot include all groups") } if contains(apiGroupMap, "operators.coreos.com") { - return fmt.Errorf("Webhook rules cannot include the OLM group") + return fmt.Errorf("webhook rules cannot include the OLM group") } // protect Admission Webhook resources if contains(apiGroupMap, "admissionregistration.k8s.io") { resourceGroupMap := listToMap(rule.Resources) if contains(resourceGroupMap, "*") || contains(resourceGroupMap, "MutatingWebhookConfiguration") || contains(resourceGroupMap, "ValidatingWebhookConfiguration") { - return fmt.Errorf("Webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources") + return fmt.Errorf("webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources") } } } @@ -58,7 +58,7 @@ func contains(m map[string]struct{}, tar string) bool { func (i *StrategyDeploymentInstaller) createOrUpdateWebhook(caPEM []byte, desc v1alpha1.WebhookDescription) error { operatorGroups, err := i.strategyClient.GetOpLister().OperatorsV1().OperatorGroupLister().OperatorGroups(i.owner.GetNamespace()).List(labels.Everything()) if err != nil || len(operatorGroups) != 1 { - return fmt.Errorf("Error retrieving OperatorGroup info") + return fmt.Errorf("error retrieving OperatorGroup info") } ogNamespacelabelSelector, err := operatorGroups[0].NamespaceLabelSelector() if err != nil { @@ -190,15 +190,14 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by // get a list of owned CRDs csv, ok := i.owner.(*v1alpha1.ClusterServiceVersion) if !ok { - return fmt.Errorf("ConversionWebhook owner must be a ClusterServiceVersion") + return fmt.Errorf("unable to manage conversion webhook: conversion webhook owner must be a ClusterServiceVersion") } - if !isSingletonOperator(*csv) { - return fmt.Errorf("CSVs with conversion webhooks must support only AllNamespaces") + return fmt.Errorf("unable to manage conversion webhook: CSVs with conversion webhooks must support only AllNamespaces") } if len(desc.ConversionCRDs) == 0 { - return fmt.Errorf("Conversion Webhook must have at least one CRD specified") + return fmt.Errorf("unable to manager conversion webhook: conversion webhook must have at least one CRD specified") } // iterate over all the ConversionCRDs @@ -207,7 +206,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by // Get existing CRD on cluster crd, err := i.strategyClient.GetOpClient().ApiextensionsInterface().ApiextensionsV1().CustomResourceDefinitions().Get(context.TODO(), conversionCRD, metav1.GetOptions{}) if err != nil { - return fmt.Errorf("Unable to get CRD %s specified in Conversion Webhook: %v", conversionCRD, err) + return fmt.Errorf("unable to get CRD %s specified in Conversion Webhook: %v", conversionCRD, err) } // check if this CRD is an owned CRD @@ -219,7 +218,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by } } if !foundCRD { - return fmt.Errorf("CSV %s does not own CRD %s", csv.GetName(), conversionCRD) + return fmt.Errorf("csv %s does not own CRD %s", csv.GetName(), conversionCRD) } // crd.Spec.Conversion.Strategy specifies how custom resources are converted between versions. @@ -232,7 +231,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by // By default the strategy is none // Reference: // - https://v1-15.docs.kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definition-versioning/#specify-multiple-versions - if crd.Spec.PreserveUnknownFields != false { + if crd.Spec.PreserveUnknownFields { return fmt.Errorf("crd.Spec.PreserveUnknownFields must be false to let API Server call webhook to do the conversion") } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go index 8fb18ed92f..1031be4359 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go @@ -30,6 +30,7 @@ import ( operatorsv2 "github.com/operator-framework/api/pkg/operators/v2" "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/ownerutil" + "github.com/operator-framework/operator-lifecycle-manager/pkg/metrics" ) // AdoptionReconciler automagically associates Operator components with their respective operator resource. @@ -37,7 +38,6 @@ type AdoptionReconciler struct { client.Client log logr.Logger - mu sync.RWMutex factory decorators.OperatorFactory } @@ -114,6 +114,7 @@ func (r *AdoptionReconciler) ReconcileSubscription(ctx context.Context, req ctrl // Set up a convenient log object so we don't have to type request over and over again log := r.log.WithValues("request", req) log.V(1).Info("reconciling subscription") + metrics.EmitAdoptionSubscriptionReconcile(req.Namespace, req.Name) // Fetch the Subscription from the cache in := &operatorsv1alpha1.Subscription{} @@ -176,6 +177,7 @@ func (r *AdoptionReconciler) ReconcileClusterServiceVersion(ctx context.Context, // Set up a convenient log object so we don't have to type request over and over again log := r.log.WithValues("request", req) log.V(1).Info("reconciling csv") + metrics.EmitAdoptionCSVReconcile(req.Namespace, req.Name) // Fetch the CSV from the cache in := &operatorsv1alpha1.ClusterServiceVersion{} @@ -268,7 +270,7 @@ func (r *AdoptionReconciler) adopt(ctx context.Context, operator *decorators.Ope cObj, ok := component.(client.Object) if !ok { - return fmt.Errorf("Unable to typecast runtime.Object to client.Object") + return fmt.Errorf("unable to typecast runtime.Object to client.Object") } if err := r.Get(ctx, types.NamespacedName{Namespace: m.GetNamespace(), Name: m.GetName()}, cObj); err != nil { @@ -290,7 +292,7 @@ func (r *AdoptionReconciler) adopt(ctx context.Context, operator *decorators.Ope // Only update if freshly adopted pCObj, ok := candidate.(client.Object) if !ok { - return fmt.Errorf("Unable to typecast runtime.Object to client.Object") + return fmt.Errorf("unable to typecast runtime.Object to client.Object") } return r.Patch(ctx, pCObj, client.MergeFrom(cObj)) } @@ -301,7 +303,7 @@ func (r *AdoptionReconciler) adopt(ctx context.Context, operator *decorators.Ope func (r *AdoptionReconciler) disown(ctx context.Context, operator *decorators.Operator, component runtime.Object) error { cObj, ok := component.(client.Object) if !ok { - return fmt.Errorf("Unable to typecast runtime.Object to client.Object") + return fmt.Errorf("unable to typecast runtime.Object to client.Object") } candidate := component.DeepCopyObject() disowned, err := operator.DisownComponent(candidate) @@ -318,7 +320,7 @@ func (r *AdoptionReconciler) disown(ctx context.Context, operator *decorators.Op r.log.V(1).Info("component disowned", "component", candidate) uCObj, ok := candidate.(client.Object) if !ok { - return fmt.Errorf("Unable to typecast runtime.Object to client.Object") + return fmt.Errorf("unable to typecast runtime.Object to client.Object") } return r.Patch(ctx, uCObj, client.MergeFrom(cObj)) } @@ -326,7 +328,7 @@ func (r *AdoptionReconciler) disown(ctx context.Context, operator *decorators.Op func (r *AdoptionReconciler) disownFromAll(ctx context.Context, component runtime.Object) error { cObj, ok := component.(client.Object) if !ok { - return fmt.Errorf("Unable to typecast runtime.Object to client.Object") + return fmt.Errorf("unable to typecast runtime.Object to client.Object") } var operators []decorators.Operator for _, name := range decorators.OperatorNames(cObj.GetLabels()) { @@ -362,7 +364,7 @@ func (r *AdoptionReconciler) adoptees(ctx context.Context, operator decorators.O for _, list := range componentLists { cList, ok := list.(client.ObjectList) if !ok { - return nil, fmt.Errorf("Unable to typecast runtime.Object to client.ObjectList") + return nil, fmt.Errorf("unable to typecast runtime.Object to client.ObjectList") } if err := r.List(ctx, cList, opt); err != nil { return nil, err diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go index a749a9c114..71ab352dfd 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go @@ -116,6 +116,8 @@ type Operator struct { installPlanTimeout time.Duration bundleUnpackTimeout time.Duration clientFactory clients.Factory + muInstallPlan sync.Mutex + resolverSourceProvider *resolver.RegistrySourceProvider } type CatalogSourceSyncFunc func(logger *logrus.Entry, in *v1alpha1.CatalogSource) (out *v1alpha1.CatalogSource, continueSync bool, syncError error) @@ -187,8 +189,9 @@ func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clo clientFactory: clients.NewFactory(config), } op.sources = grpc.NewSourceStore(logger, 10*time.Second, 10*time.Minute, op.syncSourceState) + op.resolverSourceProvider = resolver.SourceProviderFromRegistryClientProvider(op.sources, logger) op.reconciler = reconciler.NewRegistryReconcilerFactory(lister, opClient, configmapRegistryImage, op.now, ssaClient) - res := resolver.NewOperatorStepResolver(lister, crClient, opClient.KubernetesInterface(), operatorNamespace, op.sources, logger) + res := resolver.NewOperatorStepResolver(lister, crClient, operatorNamespace, op.resolverSourceProvider, logger) op.resolver = resolver.NewInstrumentedResolver(res, metrics.RegisterDependencyResolutionSuccess, metrics.RegisterDependencyResolutionFailure) // Wire OLM CR sharedIndexInformers @@ -459,12 +462,12 @@ func (o *Operator) now() metav1.Time { func (o *Operator) syncSourceState(state grpc.SourceState) { o.sourcesLastUpdate.Set(o.now().Time) - o.logger.Infof("state.Key.Namespace=%s state.Key.Name=%s state.State=%s", state.Key.Namespace, state.Key.Name, state.State.String()) + o.logger.Debugf("state.Key.Namespace=%s state.Key.Name=%s state.State=%s", state.Key.Namespace, state.Key.Name, state.State.String()) metrics.RegisterCatalogSourceState(state.Key.Name, state.Key.Namespace, state.State) switch state.State { case connectivity.Ready: - o.resolver.Expire(resolvercache.SourceKey(state.Key)) + o.resolverSourceProvider.Invalidate(resolvercache.SourceKey(state.Key)) if o.namespace == state.Key.Namespace { namespaces, err := index.CatalogSubscriberNamespaces(o.catalogSubscriberIndexer, state.Key.Name, state.Key.Namespace) @@ -552,8 +555,6 @@ func (o *Operator) handleDeletion(obj interface{}) { }).Debug("handling object deletion") o.requeueOwners(metaObj) - - return } func (o *Operator) handleCatSrcDeletion(obj interface{}) { @@ -562,13 +563,13 @@ func (o *Operator) handleCatSrcDeletion(obj interface{}) { if !ok { tombstone, ok := obj.(cache.DeletedFinalStateUnknown) if !ok { - utilruntime.HandleError(fmt.Errorf("Couldn't get object from tombstone %#v", obj)) + utilruntime.HandleError(fmt.Errorf("couldn't get object from tombstone %#v", obj)) return } catsrc, ok = tombstone.Obj.(metav1.Object) if !ok { - utilruntime.HandleError(fmt.Errorf("Tombstone contained object that is not a Namespace %#v", obj)) + utilruntime.HandleError(fmt.Errorf("tombstone contained object that is not a Namespace %#v", obj)) return } } @@ -716,11 +717,10 @@ func (o *Operator) syncRegistryServer(logger *logrus.Entry, in *v1alpha1.Catalog logger.Debug("requeueing registry server for catalog update check: update pod not yet ready") o.catsrcQueueSet.RequeueAfter(out.GetNamespace(), out.GetName(), reconciler.CatalogPollingRequeuePeriod) return - } else { - syncError = fmt.Errorf("couldn't ensure registry server - %v", err) - out.SetError(v1alpha1.CatalogSourceRegistryServerError, syncError) - return } + syncError = fmt.Errorf("couldn't ensure registry server - %v", err) + out.SetError(v1alpha1.CatalogSourceRegistryServerError, syncError) + return } logger.Debug("ensured registry server") @@ -785,8 +785,6 @@ func (o *Operator) syncConnection(logger *logrus.Entry, in *v1alpha1.CatalogSour return } - logger = logger.WithField("address", address).WithField("currentSource", sourceKey) - if source.Address != address { source, syncError = connectFunc() if syncError != nil { @@ -798,8 +796,13 @@ func (o *Operator) syncConnection(logger *logrus.Entry, in *v1alpha1.CatalogSour updateConnectionStateFunc(out, source) } + // GRPCConnectionState update must fail before + if out.Status.GRPCConnectionState == nil { + updateConnectionStateFunc(out, source) + } + // connection is already good, but we need to update the sync time - if out.Status.GRPCConnectionState != nil && o.sourcesLastUpdate.After(out.Status.GRPCConnectionState.LastConnectTime.Time) { + if o.sourcesLastUpdate.After(out.Status.GRPCConnectionState.LastConnectTime.Time) { // Set connection status and return. out.Status.GRPCConnectionState.LastConnectTime = now out.Status.GRPCConnectionState.LastObservedState = source.ConnectionState.String() @@ -892,8 +895,6 @@ func (o *Operator) syncResolvingNamespace(obj interface{}) error { // get the set of sources that should be used for resolution and best-effort get their connections working logger.Debug("resolving sources") - querier := NewNamespaceSourceQuerier(o.sources.AsClients(o.namespace, namespace)) - logger.Debug("checking if subscriptions need update") subs, err := o.listSubscriptions(namespace) @@ -926,7 +927,7 @@ func (o *Operator) syncResolvingNamespace(obj interface{}) error { subscriptionUpdated = subscriptionUpdated || changedIP // record the current state of the desired corresponding CSV in the status. no-op if we don't know the csv yet. - sub, changedCSV, err := o.ensureSubscriptionCSVState(logger, sub, querier) + sub, changedCSV, err := o.ensureSubscriptionCSVState(logger, sub) if err != nil { logger.Debugf("error recording current state of CSV in status: %v", err) return err @@ -1110,7 +1111,7 @@ func (o *Operator) ensureSubscriptionInstallPlanState(logger *logrus.Entry, sub return out, true, nil } -func (o *Operator) ensureSubscriptionCSVState(logger *logrus.Entry, sub *v1alpha1.Subscription, querier SourceQuerier) (*v1alpha1.Subscription, bool, error) { +func (o *Operator) ensureSubscriptionCSVState(logger *logrus.Entry, sub *v1alpha1.Subscription) (*v1alpha1.Subscription, bool, error) { if sub.Status.CurrentCSV == "" { return sub, false, nil } @@ -1121,10 +1122,6 @@ func (o *Operator) ensureSubscriptionCSVState(logger *logrus.Entry, sub *v1alpha logger.WithError(err).WithField("currentCSV", sub.Status.CurrentCSV).Debug("error fetching csv listed in subscription status") out.Status.State = v1alpha1.SubscriptionStateUpgradePending } else { - // Check if an update is available for the current csv - if err := querier.Queryable(); err != nil { - return nil, false, err - } out.Status.State = v1alpha1.SubscriptionStateAtLatest out.Status.InstalledCSV = sub.Status.CurrentCSV } @@ -1173,6 +1170,26 @@ func (o *Operator) ensureInstallPlan(logger *logrus.Entry, namespace string, gen return nil, err } + // There are multiple(2) worker threads process the namespaceQueue. + // Both worker can work at the same time when 2 separate updates are made for the namespace. + // The following sequence causes 2 installplans are created for a subscription + // 1. worker 1 doesn't find the installplan + // 2. worker 2 doesn't find the installplan + // 3. both worker 1 and 2 create the installplan + // + // This lock prevents the step 2 in the sequence so that only one installplan is created for a subscription. + // The sequence is like the following with this lock + // 1. worker 1 locks + // 2. worker 1 doesn't find the installplan + // 3. worker 2 wait for unlock <--- difference + // 4. worker 1 creates the installplan + // 5. worker 1 unlocks + // 6. worker 2 locks + // 7. worker 2 finds the installplan <--- difference + // 8. worker 2 unlocks + o.muInstallPlan.Lock() + defer o.muInstallPlan.Unlock() + for _, installPlan := range installPlans { if installPlan.Spec.Generation == gen { return reference.GetReference(installPlan) @@ -1531,22 +1548,21 @@ func (o *Operator) syncInstallPlans(obj interface{}) (syncError error) { } syncError = ipFailError return - } else { - // reset condition/message if it had been set in previous sync. This condition is being reset since any delay in the next steps - // (bundle unpacking/plan step errors being retried for a duration) could lead to this condition sticking around, even after - // the serviceAccountQuerier returns no error since the error has been resolved (by creating the required resources), which would - // be confusing to the user - - // NOTE: this makes the assumption that the InstallPlanInstalledCheckFailed reason is only set in the previous if clause, which is - // true in the current iteration of the catalog operator. Any future implementation change that aims at setting the reason as - // InstallPlanInstalledCheckFailed must make sure that either this assumption is not breached, or the condition being set elsewhere - // is not being unset here unintentionally. - if cond := out.Status.GetCondition(v1alpha1.InstallPlanInstalled); cond.Reason == v1alpha1.InstallPlanReasonInstallCheckFailed { - plan, err = o.setInstallPlanInstalledCond(out, v1alpha1.InstallPlanConditionReason(corev1.ConditionUnknown), "", logger) - if err != nil { - syncError = err - return - } + } + // reset condition/message if it had been set in previous sync. This condition is being reset since any delay in the next steps + // (bundle unpacking/plan step errors being retried for a duration) could lead to this condition sticking around, even after + // the serviceAccountQuerier returns no error since the error has been resolved (by creating the required resources), which would + // be confusing to the user + + // NOTE: this makes the assumption that the InstallPlanInstalledCheckFailed reason is only set in the previous if clause, which is + // true in the current iteration of the catalog operator. Any future implementation change that aims at setting the reason as + // InstallPlanInstalledCheckFailed must make sure that either this assumption is not breached, or the condition being set elsewhere + // is not being unset here unintentionally. + if cond := out.Status.GetCondition(v1alpha1.InstallPlanInstalled); cond.Reason == v1alpha1.InstallPlanReasonInstallCheckFailed { + plan, err = o.setInstallPlanInstalledCond(out, v1alpha1.InstallPlanConditionReason(corev1.ConditionUnknown), "", logger) + if err != nil { + syncError = err + return } } @@ -1588,7 +1604,7 @@ func (o *Operator) syncInstallPlans(obj interface{}) (syncError error) { // which means bundle lookup has failed and the InstallPlan should be failed as well isFailed, cond := hasBundleLookupFailureCondition(plan) if isFailed { - err := fmt.Errorf("Bundle unpacking failed. Reason: %v, and Message: %v", cond.Reason, cond.Message) + err := fmt.Errorf("bundle unpacking failed. Reason: %v, and Message: %v", cond.Reason, cond.Message) // Mark the InstallPlan as failed for a fatal bundle unpack error logger.Infof("%v", err) @@ -1672,7 +1688,7 @@ func (o *Operator) transitionInstallPlanToFailed(plan *v1alpha1.InstallPlan, log logger.Errorf("error transitioning InstallPlan to failed") // retry sync with error to update InstallPlan status - return fmt.Errorf("InstallPlan failed: %s and error updating InstallPlan status as failed: %s", message, updateErr) + return fmt.Errorf("installplan failed: %s and error updating InstallPlan status as failed: %s", message, updateErr) } func (o *Operator) requeueSubscriptionForInstallPlan(plan *v1alpha1.InstallPlan, logger *logrus.Entry) { @@ -1869,7 +1885,7 @@ func (o *Operator) ExecutePlan(plan *v1alpha1.InstallPlan) error { // Get the set of initial installplan csv names initialCSVNames := getCSVNameSet(plan) // Get pre-existing CRD owners to make decisions about applying resolved CSVs - existingCRDOwners, err := o.getExistingApiOwners(plan.GetNamespace()) + existingCRDOwners, err := o.getExistingAPIOwners(plan.GetNamespace()) if err != nil { return err } @@ -2330,8 +2346,8 @@ func (o *Operator) ExecutePlan(plan *v1alpha1.InstallPlan) error { return nil } -// getExistingApiOwners creates a map of CRD names to existing owner CSVs in the given namespace -func (o *Operator) getExistingApiOwners(namespace string) (map[string][]string, error) { +// getExistingAPIOwners creates a map of CRD names to existing owner CSVs in the given namespace +func (o *Operator) getExistingAPIOwners(namespace string) (map[string][]string, error) { // Get a list of CSVs in the namespace csvList, err := o.client.OperatorsV1alpha1().ClusterServiceVersions(namespace).List(context.TODO(), metav1.ListOptions{}) @@ -2445,7 +2461,7 @@ func (o *Operator) apiresourceFromGVK(gvk schema.GroupVersionKind) (metav1.APIRe } } logger.Info("couldn't find GVK in api discovery") - return metav1.APIResource{}, olmerrors.GroupVersionKindNotFoundError{gvk.Group, gvk.Version, gvk.Kind} + return metav1.APIResource{}, olmerrors.GroupVersionKindNotFoundError{Group: gvk.Group, Version: gvk.Version, Kind: gvk.Kind} } const ( diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/querier.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/querier.go deleted file mode 100644 index 599210e257..0000000000 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/querier.go +++ /dev/null @@ -1,125 +0,0 @@ -//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o fakes/fake_registry_client.go ../../../../vendor/github.com/operator-framework/operator-registry/pkg/api.RegistryClient -//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o fakes/fake_registry_interface.go ../../registry/registry_client.go ClientInterface -package catalog - -import ( - "context" - "fmt" - - "github.com/blang/semver/v4" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/errors" - - "github.com/operator-framework/operator-registry/pkg/api" - "github.com/operator-framework/operator-registry/pkg/client" - - "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry" -) - -const SkipPackageAnnotationKey = "olm.skipRange" - -type SourceRef struct { - Address string - Client client.Interface - LastConnect metav1.Time - LastHealthy metav1.Time -} - -type SourceQuerier interface { - // Deprecated: This FindReplacement function will be deprecated soon - FindReplacement(currentVersion *semver.Version, bundleName, pkgName, channelName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error) - Queryable() error -} - -type NamespaceSourceQuerier struct { - sources map[registry.CatalogKey]registry.ClientInterface -} - -var _ SourceQuerier = &NamespaceSourceQuerier{} - -func NewNamespaceSourceQuerier(sources map[registry.CatalogKey]registry.ClientInterface) *NamespaceSourceQuerier { - return &NamespaceSourceQuerier{ - sources: sources, - } -} - -func (q *NamespaceSourceQuerier) Queryable() error { - if len(q.sources) == 0 { - return fmt.Errorf("no catalog sources available") - } - return nil -} - -// Deprecated: This FindReplacement function will be deprecated soon -func (q *NamespaceSourceQuerier) FindReplacement(currentVersion *semver.Version, bundleName, pkgName, channelName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error) { - errs := []error{} - - if initialSource.Name != "" && initialSource.Namespace != "" { - source, ok := q.sources[initialSource] - if !ok { - return nil, nil, fmt.Errorf("CatalogSource %s not found", initialSource.Name) - } - - bundle, err := q.findChannelHead(currentVersion, pkgName, channelName, source) - if bundle != nil { - return bundle, &initialSource, nil - } - if err != nil { - errs = append(errs, err) - } - - bundle, err = source.GetReplacementBundleInPackageChannel(context.TODO(), bundleName, pkgName, channelName) - if bundle != nil { - return bundle, &initialSource, nil - } - if err != nil { - errs = append(errs, err) - } - - return nil, nil, errors.NewAggregate(errs) - } - - for key, source := range q.sources { - bundle, err := q.findChannelHead(currentVersion, pkgName, channelName, source) - if bundle != nil { - return bundle, &initialSource, nil - } - if err != nil { - errs = append(errs, err) - } - - bundle, err = source.GetReplacementBundleInPackageChannel(context.TODO(), bundleName, pkgName, channelName) - if bundle != nil { - return bundle, &key, nil - } - if err != nil { - errs = append(errs, err) - } - } - return nil, nil, errors.NewAggregate(errs) -} - -func (q *NamespaceSourceQuerier) findChannelHead(currentVersion *semver.Version, pkgName, channelName string, source client.Interface) (*api.Bundle, error) { - if currentVersion == nil { - return nil, nil - } - - latest, err := source.GetBundleInPackageChannel(context.TODO(), pkgName, channelName) - if err != nil { - return nil, err - } - - if latest.SkipRange == "" { - return nil, nil - } - - r, err := semver.ParseRange(latest.SkipRange) - if err != nil { - return nil, err - } - - if r(*currentVersion) { - return latest, nil - } - return nil, nil -} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go index 1093c1ddd1..a6a80bfaff 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go @@ -102,9 +102,8 @@ func (b *builder) NewCRDV1Step(client apiextensionsv1client.ApiextensionsV1Inter if err != nil { if k8serrors.IsNotFound(err) { return v1alpha1.StepStatusNotPresent, nil - } else { - return v1alpha1.StepStatusNotPresent, errors.Wrapf(err, "error finding the %s CRD", crd.Name) } + return v1alpha1.StepStatusNotPresent, errors.Wrapf(err, "error finding the %s CRD", crd.Name) } established, namesAccepted := false, false for _, cdt := range crd.Status.Conditions { @@ -167,7 +166,7 @@ func (b *builder) NewCRDV1Step(client apiextensionsv1client.ApiextensionsV1Inter // Unexpected error creating the CRD. return v1alpha1.StepStatusUnknown, createError } - // If no error occured, make sure to wait for the API to become available. + // If no error occurred, make sure to wait for the API to become available. return v1alpha1.StepStatusWaitingForAPI, nil } return v1alpha1.StepStatusUnknown, nil @@ -186,9 +185,8 @@ func (b *builder) NewCRDV1Beta1Step(client apiextensionsv1beta1client.Apiextensi if err != nil { if k8serrors.IsNotFound(err) { return v1alpha1.StepStatusNotPresent, nil - } else { - return v1alpha1.StepStatusNotPresent, fmt.Errorf("error finding the %q CRD: %w", crd.Name, err) } + return v1alpha1.StepStatusNotPresent, fmt.Errorf("error finding the %q CRD: %w", crd.Name, err) } established, namesAccepted := false, false for _, cdt := range crd.Status.Conditions { @@ -252,7 +250,7 @@ func (b *builder) NewCRDV1Beta1Step(client apiextensionsv1beta1client.Apiextensi // Unexpected error creating the CRD. return v1alpha1.StepStatusUnknown, createError } - // If no error occured, make sure to wait for the API to become available. + // If no error occurred, make sure to wait for the API to become available. return v1alpha1.StepStatusWaitingForAPI, nil } return v1alpha1.StepStatusUnknown, nil diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go index 024cb3dd96..92cba65c58 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go @@ -243,7 +243,6 @@ func (c *catalogHealthState) UpdateHealth(now *metav1.Time, client clientv1alpha var known CatalogHealthKnownState switch { case missingTargeted: - healthy = false cond.Message = fmt.Sprintf("targeted catalogsource %s/%s missing", in.Spec.CatalogSourceNamespace, in.Spec.CatalogSource) fallthrough case !healthy: @@ -273,7 +272,6 @@ func (c *catalogHealthState) UpdateHealth(now *metav1.Time, client clientv1alpha case numNew < numOld: cond.Reason = v1alpha1.CatalogSourcesDeleted case numNew == 0 && numNew == numOld: - healthy = false cond.Reason = v1alpha1.NoCatalogSourcesFound cond.Message = "dependency resolution requires at least one catalogsource" case numNew == numOld: diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions.go deleted file mode 100644 index 298e0e3232..0000000000 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions.go +++ /dev/null @@ -1,51 +0,0 @@ -package catalog - -import ( - "errors" - - "github.com/operator-framework/api/pkg/operators/v1alpha1" -) - -var ( - ErrNilSubscription = errors.New("invalid Subscription object: ") -) - -const ( - PackageLabel = "olm.package" - CatalogLabel = "olm.catalog" - CatalogNamespaceLabel = "olm.catalog.namespace" - ChannelLabel = "olm.channel" -) - -func labelsForSubscription(sub *v1alpha1.Subscription) map[string]string { - return map[string]string{ - PackageLabel: sub.Spec.Package, - CatalogLabel: sub.Spec.CatalogSource, - CatalogNamespaceLabel: sub.Spec.CatalogSourceNamespace, - ChannelLabel: sub.Spec.Channel, - } -} - -// TODO remove this once UI no longer needs them -func legacyLabelsForSubscription(sub *v1alpha1.Subscription) map[string]string { - return map[string]string{ - "alm-package": sub.Spec.Package, - "alm-catalog": sub.Spec.CatalogSource, - "alm-channel": sub.Spec.Channel, - } -} - -func ensureLabels(sub *v1alpha1.Subscription) *v1alpha1.Subscription { - labels := sub.GetLabels() - if labels == nil { - labels = map[string]string{} - } - for k, v := range labelsForSubscription(sub) { - labels[k] = v - } - for k, v := range legacyLabelsForSubscription(sub) { - labels[k] = v - } - sub.SetLabels(labels) - return sub -} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go index c91dc7c90e..a9c5fe3cc5 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go @@ -137,7 +137,7 @@ func (o *Operator) syncCatalogSources(obj interface{}) error { "catSrcName": outputCatalogSource.GetName(), "id": queueinformer.NewLoopID(), }) - logger.Info("syncing catalog source for annotation templates") + logger.Debug("syncing catalog source for annotation templates") catalogImageTemplate := catalogsource.GetCatalogTemplateAnnotation(outputCatalogSource) if catalogImageTemplate == "" { @@ -175,7 +175,6 @@ func (o *Operator) syncCatalogSources(obj interface{}) error { // make sure that the processed image reference is actually different if outputCatalogSource.Spec.Image != processedCatalogImageTemplate { - outputCatalogSource.Spec.Image = processedCatalogImageTemplate if err := catalogsource.UpdateSpecAndStatusConditions(logger, o.client, outputCatalogSource, conditions...); err != nil { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go index 4046f7ee09..612a8a6244 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go @@ -22,9 +22,9 @@ import ( ) const ( - newOperatorError = "Cannot create new Operator: %s" - newComponentError = "Cannot create new Component: %s" - componentLabelKeyError = "Cannot generate component label key: %s" + newOperatorError = "cannot create new Operator: %s" + newComponentError = "cannot create new Component: %s" + componentLabelKeyError = "cannot generate component label key: %s" // ComponentLabelKeyPrefix is the key prefix used for labels marking operator component resources. ComponentLabelKeyPrefix = "operators.coreos.com/" @@ -295,7 +295,7 @@ func (o *Operator) AddComponents(components ...runtime.Object) error { if matches, err := component.Matches(selector); err != nil { return err } else if !matches { - return fmt.Errorf("Cannot add component %s/%s/%s to Operator %s: component labels not selected by %s", component.GetKind(), component.GetNamespace(), component.GetName(), o.GetName(), selector.String()) + return fmt.Errorf("cannot add component %s/%s/%s to Operator %s: component labels not selected by %s", component.GetKind(), component.GetNamespace(), component.GetName(), o.GetName(), selector.String()) } ref, err := component.Reference() diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go index 88a93fd1b4..79e79179af 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go @@ -88,7 +88,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion, // Check if the APIService points to the correct service if apiService.Spec.Service.Name != serviceName || apiService.Spec.Service.Namespace != csv.GetNamespace() { logger.WithFields(log.Fields{"service": apiService.Spec.Service.Name, "serviceNamespace": apiService.Spec.Service.Namespace}).Warnf("APIService service reference mismatch") - errs = append(errs, fmt.Errorf("APIService service reference mismatch")) + errs = append(errs, fmt.Errorf("found APIService and service reference mismatch")) continue } @@ -102,7 +102,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion, } if !certs.Active(ca) { logger.Warnf("CA cert not active") - errs = append(errs, fmt.Errorf("CA cert not active")) + errs = append(errs, fmt.Errorf("found the CA cert is not active")) continue } @@ -122,7 +122,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion, } if !certs.Active(cert) { logger.Warnf("serving cert not active") - errs = append(errs, fmt.Errorf("serving cert not active")) + errs = append(errs, fmt.Errorf("found the serving cert not active")) continue } @@ -155,7 +155,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion, } if hash, ok := deployment.Spec.Template.GetAnnotations()[install.OLMCAHashAnnotationKey]; !ok || hash != caHash { logger.WithField("deployment", desc.DeploymentName).Warnf("Deployment CA cert hash does not match expected") - errs = append(errs, fmt.Errorf("Deployment %s CA cert hash does not match expected", desc.DeploymentName)) + errs = append(errs, fmt.Errorf("deployment %s CA cert hash does not match expected", desc.DeploymentName)) continue } @@ -214,7 +214,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion, } if !satisfied { logger.WithField("rule", fmt.Sprintf("%+v", rule)).Warnf("Rule not satisfied") - errs = append(errs, fmt.Errorf("Rule %+v not satisfied", rule)) + errs = append(errs, fmt.Errorf("rule %+v not satisfied", rule)) continue } } @@ -260,7 +260,7 @@ func (a *Operator) getAPIServiceCABundle(csv *v1alpha1.ClusterServiceVersion, de return apiService.Spec.CABundle, nil } - return nil, fmt.Errorf("Unable to find ca") + return nil, fmt.Errorf("unable to find CA") } // getWebhookCABundle returns the CA associated with a webhook @@ -303,13 +303,13 @@ func (a *Operator) getWebhookCABundle(csv *v1alpha1.ClusterServiceVersion, desc } } - return nil, fmt.Errorf("Unable to find ca") + return nil, fmt.Errorf("unable to find CA") } -// updateDeploymentSpecsWithApiServiceData transforms an install strategy to include information about apiservices +// updateDeploymentSpecsWithAPIServiceData transforms an install strategy to include information about apiservices // it is used in generating hashes for deployment specs to know when something in the spec has changed, // but duplicates a lot of installAPIServiceRequirements and should be refactored. -func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.ClusterServiceVersion, strategy install.Strategy) (install.Strategy, error) { +func (a *Operator) updateDeploymentSpecsWithAPIServiceData(csv *v1alpha1.ClusterServiceVersion, strategy install.Strategy) (install.Strategy, error) { // Assume the strategy is for a deployment strategyDetailsDeployment, ok := strategy.(*v1alpha1.StrategyDetailsDeployment) if !ok { @@ -335,7 +335,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster depSpec, ok := depSpecs[desc.DeploymentName] if !ok { - return nil, fmt.Errorf("StrategyDetailsDeployment missing deployment %s for owned APIServices %s", desc.DeploymentName, fmt.Sprintf("%s.%s", desc.Version, desc.Group)) + return nil, fmt.Errorf("strategyDetailsDeployment is missing deployment %s for owned APIServices %s", desc.DeploymentName, fmt.Sprintf("%s.%s", desc.Version, desc.Group)) } if depSpec.Template.Spec.ServiceAccountName == "" { @@ -345,7 +345,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster // Update deployment with secret volume mount. secret, err := a.lister.CoreV1().SecretLister().Secrets(csv.GetNamespace()).Get(install.SecretName(install.ServiceName(desc.DeploymentName))) if err != nil { - return nil, fmt.Errorf("Unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName))) + return nil, fmt.Errorf("unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName))) } install.AddDefaultCertVolumeAndVolumeMounts(&depSpec, secret.GetName()) @@ -362,7 +362,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster depSpec, ok := depSpecs[desc.DeploymentName] if !ok { - return nil, fmt.Errorf("StrategyDetailsDeployment missing deployment %s for WebhookDescription %s", desc.DeploymentName, desc.GenerateName) + return nil, fmt.Errorf("strategyDetailsDeployment is missing deployment %s for WebhookDescription %s", desc.DeploymentName, desc.GenerateName) } if depSpec.Template.Spec.ServiceAccountName == "" { @@ -372,7 +372,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster // Update deployment with secret volume mount. secret, err := a.lister.CoreV1().SecretLister().Secrets(csv.GetNamespace()).Get(install.SecretName(install.ServiceName(desc.DeploymentName))) if err != nil { - return nil, fmt.Errorf("Unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName))) + return nil, fmt.Errorf("unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName))) } install.AddDefaultCertVolumeAndVolumeMounts(&depSpec, secret.GetName()) @@ -406,7 +406,7 @@ func (a *Operator) cleanUpRemovedWebhooks(csv *v1alpha1.ClusterServiceVersion) e for _, webhook := range validatingWebhookConfigurationList.Items { webhookGenerateNameLabel, ok := webhook.GetLabels()[install.WebhookDescKey] if !ok { - return fmt.Errorf("ValidatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name) + return fmt.Errorf("validatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name) } if _, ok := csvWebhookGenerateNames[webhookGenerateNameLabel]; !ok { err = a.opClient.KubernetesInterface().AdmissionregistrationV1().ValidatingWebhookConfigurations().Delete(context.TODO(), webhook.Name, metav1.DeleteOptions{}) @@ -424,7 +424,7 @@ func (a *Operator) cleanUpRemovedWebhooks(csv *v1alpha1.ClusterServiceVersion) e for _, webhook := range mutatingWebhookConfigurationList.Items { webhookGenerateNameLabel, ok := webhook.GetLabels()[install.WebhookDescKey] if !ok { - return fmt.Errorf("MutatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name) + return fmt.Errorf("mutatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name) } if _, ok := csvWebhookGenerateNames[webhookGenerateNameLabel]; !ok { err = a.opClient.KubernetesInterface().AdmissionregistrationV1().MutatingWebhookConfigurations().Delete(context.TODO(), webhook.Name, metav1.DeleteOptions{}) @@ -473,7 +473,7 @@ func (a *Operator) areWebhooksAvailable(csv *v1alpha1.ClusterServiceVersion) (bo } if crd.Spec.Conversion == nil || crd.Spec.Conversion.Strategy != "Webhook" || crd.Spec.Conversion.Webhook == nil || crd.Spec.Conversion.Webhook.ClientConfig == nil && crd.Spec.Conversion.Webhook.ClientConfig.CABundle == nil { - return false, fmt.Errorf("ConversionWebhook not ready") + return false, fmt.Errorf("conversionWebhook not ready") } webhookCount++ } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go index ffc9c3b264..180d0212a0 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go @@ -418,7 +418,6 @@ func newOperatorWithConfig(ctx context.Context, config *operatorConfig) (*Operat if err := op.RegisterQueueInformer(objGCQueueInformer); err != nil { return nil, err } - } // add queue for all namespaces as well @@ -617,8 +616,6 @@ func (a *Operator) syncSubscriptionDeleted(obj interface{}) { if !ok { a.logger.Debugf("casting Subscription failed, wrong type: %#v\n", obj) } - - return } func (a *Operator) syncAPIService(obj interface{}) (syncError error) { @@ -823,7 +820,6 @@ func (a *Operator) syncObject(obj interface{}) (syncError error) { return } } - } // Requeue all owner CSVs @@ -891,7 +887,6 @@ func (a *Operator) namespaceAddedOrRemoved(obj interface{}) { } } } - return } func (a *Operator) syncNamespace(obj interface{}) error { @@ -1193,7 +1188,6 @@ func (a *Operator) syncClusterServiceVersion(obj interface{}) (syncError error) outCSV.Status.Phase == clusterServiceVersion.Status.Phase && outCSV.Status.Reason == clusterServiceVersion.Status.Reason && outCSV.Status.Message == clusterServiceVersion.Status.Message) { - // Update CSV with status of transition. Log errors if we can't write them to the status. _, err := a.client.OperatorsV1alpha1().ClusterServiceVersions(outCSV.GetNamespace()).UpdateStatus(context.TODO(), outCSV, metav1.UpdateOptions{}) if err != nil { @@ -1252,7 +1246,7 @@ func (a *Operator) allNamespaceOperatorGroups() ([]*v1.OperatorGroup, error) { } func (a *Operator) syncOLMConfig(obj interface{}) (syncError error) { - a.logger.Info("Processing olmConfig") + a.logger.Debug("Processing olmConfig") olmConfig, ok := obj.(*v1.OLMConfig) if !ok { return fmt.Errorf("casting OLMConfig failed") @@ -1337,7 +1331,7 @@ func getCopiedCSVsCondition(isDisabled, csvIsRequeued bool) metav1.Condition { } if !isDisabled { condition.Reason = "CopiedCSVsEnabled" - condition.Message = "Copied CSVs are enabled and present accross the cluster" + condition.Message = "Copied CSVs are enabled and present across the cluster" if csvIsRequeued { condition.Message = "Copied CSVs are enabled and at least one copied CSVs is missing" } @@ -1719,6 +1713,10 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v // Check for intersecting provided APIs in intersecting OperatorGroups allGroups, err := a.lister.OperatorsV1().OperatorGroupLister().List(labels.Everything()) + if err != nil { + logger.WithError(err).Warn("failed to list operatorgroups") + return + } otherGroups := make([]v1.OperatorGroup, 0, len(allGroups)) for _, g := range allGroups { if g.GetName() != operatorGroup.GetName() || g.GetNamespace() != operatorGroup.GetNamespace() { @@ -1835,7 +1833,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v for _, desc := range out.Spec.WebhookDefinitions { _, present := webhookNames[desc.GenerateName] if present { - logger.WithError(fmt.Errorf("Repeated WebhookDescription name %s", desc.GenerateName)).Warn("CSV is invalid") + logger.WithError(fmt.Errorf("repeated WebhookDescription name %s", desc.GenerateName)).Warn("CSV is invalid") out.SetPhaseWithEventIfChanged(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonInvalidWebhookDescription, "CSV contains repeated WebhookDescription name", now, a.recorder) return } @@ -1911,7 +1909,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v return } - strategy, err := a.updateDeploymentSpecsWithApiServiceData(out, strategy) + strategy, err := a.updateDeploymentSpecsWithAPIServiceData(out, strategy) if err != nil { logger.WithError(err).Debug("Unable to calculate expected deployment") out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonNeedsReinstall, "calculated deployment install is bad", now, a.recorder) @@ -1927,7 +1925,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v // Set phase to failed if it's been a long time since the last transition (5 minutes) if out.Status.LastTransitionTime != nil && a.now().Sub(out.Status.LastTransitionTime.Time) >= 5*time.Minute { logger.Warn("install timed out") - out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonInstallCheckFailed, fmt.Sprintf("install timeout"), now, a.recorder) + out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonInstallCheckFailed, "install timeout", now, a.recorder) return } } @@ -1968,12 +1966,12 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v } else if !met { logger.Debug("CSV Requirements are no longer met") out.SetRequirementStatus(statuses) - out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonRequirementsNotMet, fmt.Sprintf("requirements no longer met"), now, a.recorder) + out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonRequirementsNotMet, "requirements no longer met", now, a.recorder) return } // Check install status - strategy, err = a.updateDeploymentSpecsWithApiServiceData(out, strategy) + strategy, err = a.updateDeploymentSpecsWithAPIServiceData(out, strategy) if err != nil { logger.WithError(err).Debug("Unable to calculate expected deployment") out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonNeedsReinstall, "calculated deployment install is bad", now, a.recorder) @@ -2039,7 +2037,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v } else if !met { logger.Debug("CSV Requirements are not met") out.SetRequirementStatus(statuses) - out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonRequirementsNotMet, fmt.Sprintf("requirements not met"), now, a.recorder) + out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonRequirementsNotMet, "requirements not met", now, a.recorder) return } @@ -2061,7 +2059,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v } // Check install status - strategy, err = a.updateDeploymentSpecsWithApiServiceData(out, strategy) + strategy, err = a.updateDeploymentSpecsWithAPIServiceData(out, strategy) if err != nil { logger.WithError(err).Debug("Unable to calculate expected deployment") out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonNeedsReinstall, "calculated deployment install is bad", now, a.recorder) @@ -2168,17 +2166,18 @@ func (a *Operator) updateInstallStatus(csv *v1alpha1.ClusterServiceVersion, inst } if !apiServicesInstalled { - csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, fmt.Sprintf("APIServices not installed"), now, a.recorder) + msg := "apiServices not installed" + csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, msg, now, a.recorder) if err := a.csvQueueSet.Requeue(csv.GetNamespace(), csv.GetName()); err != nil { a.logger.Warn(err.Error()) } - return fmt.Errorf("APIServices not installed") + return fmt.Errorf(msg) } if !webhooksInstalled || webhookErr != nil { - msg := "Webhooks not installed" - csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, fmt.Sprintf(msg), now, a.recorder) + msg := "webhooks not installed" + csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, msg, now, a.recorder) if err := a.csvQueueSet.Requeue(csv.GetNamespace(), csv.GetName()); err != nil { a.logger.Warn(err.Error()) } @@ -2240,10 +2239,14 @@ func (a *Operator) parseStrategiesAndUpdateStatus(csv *v1alpha1.ClusterServiceVe querierFunc := a.serviceAccountQuerier.NamespaceQuerier(csv.GetNamespace()) attenuate, err := a.clientAttenuator.AttenuateToServiceAccount(querierFunc) if err != nil { - a.logger.Errorf("failed to get a client for operator deployment- %v", err) + a.logger.Errorf("failed to get a client for operator deployment - %v", err) return nil, nil } kubeclient, err := a.clientFactory.WithConfigTransformer(attenuate).NewOperatorClient() + if err != nil { + a.logger.Errorf("failed to get an operator client for operator deployment - %v", err) + return nil, nil + } strName := strategy.GetStrategyName() installer := a.resolver.InstallerForStrategy(strName, kubeclient, a.lister, csv, csv.GetAnnotations(), csv.GetAllAPIServiceDescriptions(), csv.Spec.WebhookDefinitions, previousStrategy) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go index 6dfb5fca35..04ba9a7ebe 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go @@ -37,17 +37,17 @@ func (a *Operator) isOperatorUpgradeable(csv *v1alpha1.ClusterServiceVersion) (b return true, nil } logger.Infof("Upgradeable condition is overridden to false: %s", o.Message) - return false, fmt.Errorf("The operator is not upgradeable: %s", o.Message) + return false, fmt.Errorf("the operator is not upgradeable: %s", o.Message) } // Check for OperatorUpgradeable condition status if c := meta.FindStatusCondition(cond.Status.Conditions, operatorsv2.Upgradeable); c != nil { if c.ObservedGeneration != cond.ObjectMeta.Generation { logger.Debugf("Upgradeable condition's generation doesn't match: %d/%d", c.ObservedGeneration, cond.ObjectMeta.Generation) - return false, fmt.Errorf("The operatorcondition status %q=%q is outdated", c.Type, c.Status) + return false, fmt.Errorf("the operatorcondition status %q=%q is outdated", c.Type, c.Status) } if c.Status == metav1.ConditionFalse { - return false, fmt.Errorf("The operator is not upgradeable: %s", c.Message) + return false, fmt.Errorf("the operator is not upgradeable: %s", c.Message) } } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go index f308c6af9a..e7ca97a4ce 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go @@ -264,7 +264,7 @@ func (a *Operator) annotateCSVs(group *v1.OperatorGroup, targetNamespaces []stri } logger := logger.WithField("csv", csv.GetName()) - originalNamespacesAnnotation, _ := a.copyOperatorGroupAnnotations(&csv.ObjectMeta)[v1.OperatorGroupTargetsAnnotationKey] + originalNamespacesAnnotation := a.copyOperatorGroupAnnotations(&csv.ObjectMeta)[v1.OperatorGroupTargetsAnnotationKey] originalNamespaceSet := NewNamespaceSetFromString(originalNamespacesAnnotation) if a.operatorGroupAnnotationsDiffer(&csv.ObjectMeta, group) { @@ -367,7 +367,6 @@ func (a *Operator) pruneProvidedAPIs(group *v1.OperatorGroup, groupProvidedAPIs logger.WithError(err).Warn("could not update provided api annotations") } } - return } // ensureProvidedAPIClusterRole ensures that a clusterrole exists (admin, edit, or view) for a single provided API Type @@ -391,7 +390,10 @@ func (a *Operator) ensureProvidedAPIClusterRole(namePrefix, suffix string, verbs } existingCR, err := a.lister.RbacV1().ClusterRoleLister().Get(clusterRole.Name) - if existingCR == nil { + if err != nil && !k8serrors.IsNotFound(err) { + return err + } + if k8serrors.IsNotFound(err) { existingCR, err = a.opClient.KubernetesInterface().RbacV1().ClusterRoles().Create(context.TODO(), clusterRole, metav1.CreateOptions{}) if err == nil { return nil @@ -478,9 +480,7 @@ func (a *Operator) ensureRBACInTargetNamespace(csv *v1alpha1.ClusterServiceVersi logger.Debug("opgroup is global") // synthesize cluster permissions to verify rbac - for _, p := range strategyDetailsDeployment.Permissions { - strategyDetailsDeployment.ClusterPermissions = append(strategyDetailsDeployment.ClusterPermissions, p) - } + strategyDetailsDeployment.ClusterPermissions = append(strategyDetailsDeployment.ClusterPermissions, strategyDetailsDeployment.Permissions...) strategyDetailsDeployment.Permissions = nil permMet, _, err := a.permissionStatus(strategyDetailsDeployment, ruleChecker, corev1.NamespaceAll, csv) if err != nil { @@ -799,7 +799,6 @@ func (a *Operator) copyToNamespace(prototype *v1alpha1.ClusterServiceVersion, ns existing, err := a.copiedCSVLister.ClusterServiceVersions(nsTo).Get(prototype.GetName()) if k8serrors.IsNotFound(err) { - created, err := a.client.OperatorsV1alpha1().ClusterServiceVersions(nsTo).Create(context.TODO(), prototype, metav1.CreateOptions{}) if err != nil { return nil, err @@ -1007,7 +1006,10 @@ func (a *Operator) ensureOpGroupClusterRole(op *v1.OperatorGroup, suffix string, } existingRole, err := a.lister.RbacV1().ClusterRoleLister().Get(clusterRole.Name) - if existingRole == nil { + if err != nil && !k8serrors.IsNotFound(err) { + return err + } + if k8serrors.IsNotFound(err) { existingRole, err = a.opClient.KubernetesInterface().RbacV1().ClusterRoles().Create(context.TODO(), clusterRole, metav1.CreateOptions{}) if err == nil { return nil diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go index f75f001e4f..22ae894a32 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go @@ -27,12 +27,6 @@ func stripObject(obj client.Object) { obj.SetUID("") } -func watchNamespace(namespace *string) predicate.Funcs { - return predicate.NewPredicateFuncs(func(object client.Object) bool { - return object.GetNamespace() == *namespace - }) -} - func watchName(name *string) predicate.Funcs { return predicate.NewPredicateFuncs(func(object client.Object) bool { return object.GetName() == *name @@ -58,7 +52,7 @@ func versionsMatch(a []configv1.OperandVersion, b []configv1.OperandVersion) boo counts := map[configv1.OperandVersion]int{} for _, av := range a { - counts[av] += 1 + counts[av]++ } for _, bv := range b { @@ -72,7 +66,7 @@ func versionsMatch(a []configv1.OperandVersion, b []configv1.OperandVersion) boo continue } - counts[bv] -= 1 + counts[bv]-- } return len(counts) < 1 @@ -132,7 +126,7 @@ func incompatibleOperators(ctx context.Context, cli client.Client) (skews, error if desired == nil { // Note: This shouldn't happen - return nil, fmt.Errorf("Failed to determine current OpenShift Y-stream release") + return nil, fmt.Errorf("failed to determine current OpenShift Y-stream release") } next, err := nextY(*desired) @@ -142,7 +136,7 @@ func incompatibleOperators(ctx context.Context, cli client.Client) (skews, error csvList := &operatorsv1alpha1.ClusterServiceVersionList{} if err := cli.List(ctx, csvList); err != nil { - return nil, &transientError{fmt.Errorf("Failed to list ClusterServiceVersions: %w", err)} + return nil, &transientError{fmt.Errorf("failed to list ClusterServiceVersions: %w", err)} } var incompatible skews @@ -177,18 +171,18 @@ func incompatibleOperators(ctx context.Context, cli client.Client) (skews, error func desiredRelease(ctx context.Context, cli client.Client) (*semver.Version, error) { cv := configv1.ClusterVersion{} if err := cli.Get(ctx, client.ObjectKey{Name: "version"}, &cv); err != nil { // "version" is the name of OpenShift's ClusterVersion singleton - return nil, &transientError{fmt.Errorf("Failed to get ClusterVersion: %w", err)} + return nil, &transientError{fmt.Errorf("failed to get ClusterVersion: %w", err)} } v := cv.Status.Desired.Version if v == "" { // The release version hasn't been set yet - return nil, fmt.Errorf("Desired release version missing from ClusterVersion") + return nil, fmt.Errorf("desired release version missing from ClusterVersion") } desired, err := semver.ParseTolerant(v) if err != nil { - return nil, fmt.Errorf("ClusterVersion has invalid desired release version: %w", err) + return nil, fmt.Errorf("cluster version has invalid desired release version: %w", err) } return &desired, nil @@ -231,7 +225,7 @@ func maxOpenShiftVersion(csv *operatorsv1alpha1.ClusterServiceVersion) (*semver. } if max != nil { - return nil, fmt.Errorf(`Defining more than one "%s" property is not allowed`, MaxOpenShiftVersionProperty) + return nil, fmt.Errorf(`defining more than one "%s" property is not allowed`, MaxOpenShiftVersionProperty) } max = &property.Value @@ -245,12 +239,12 @@ func maxOpenShiftVersion(csv *operatorsv1alpha1.ClusterServiceVersion) (*semver. value := strings.Trim(*max, "\"") if value == "" { // Handle "" separately, so parse doesn't treat it as a zero - return nil, fmt.Errorf(`Value cannot be "" (an empty string)`) + return nil, fmt.Errorf(`value cannot be "" (an empty string)`) } version, err := semver.ParseTolerant(value) if err != nil { - return nil, fmt.Errorf(`Failed to parse "%s" as semver: %w`, value, err) + return nil, fmt.Errorf(`failed to parse "%s" as semver: %w`, value, err) } truncatedVersion := semver.Version{Major: version.Major, Minor: version.Minor} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go index e5b0a4b64a..59f8533ab2 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go @@ -51,12 +51,12 @@ func (c *ReconcilerConfig) apply(opts []ReconcilerOption) { func (c *ReconcilerConfig) complete() error { if c.Client == nil { - return fmt.Errorf("No client specified") + return fmt.Errorf("no client specified") } if c.Name == "" { - return fmt.Errorf("No ClusterOperator name specified") + return fmt.Errorf("no ClusterOperator name specified") } - if c.Log == nil { + if c.Log.GetSink() == nil { c.Log = ctrl.Log.WithName(c.Name) } if c.Now == nil { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go index 0583945ec4..84d4a9591b 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go @@ -38,7 +38,6 @@ func (s *SyncTracker) Start(ctx context.Context) error { }) return err - } func (s *SyncTracker) start(ctx context.Context) error { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go index 62aa4e2d06..e39ecb7d9a 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go @@ -28,6 +28,7 @@ import ( operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" operatorsv2 "github.com/operator-framework/api/pkg/operators/v2" "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators" + "github.com/operator-framework/operator-lifecycle-manager/pkg/metrics" ) var ( @@ -118,6 +119,7 @@ func (r *OperatorReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c // Set up a convenient log object so we don't have to type request over and over again log := r.log.WithValues("request", req) log.V(1).Info("reconciling operator") + metrics.EmitOperatorReconcile(req.Namespace, req.Name) // Get the Operator create := false @@ -159,7 +161,6 @@ func (r *OperatorReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c if err = r.updateComponents(ctx, operator); err != nil { log.Error(err, "Could not update components") return reconcile.Result{Requeue: true}, nil - } if create { @@ -205,7 +206,7 @@ func (r *OperatorReconciler) listComponents(ctx context.Context, selector labels for _, list := range componentLists { cList, ok := list.(client.ObjectList) if !ok { - return nil, fmt.Errorf("Unable to typecast runtime.Object to client.ObjectList") + return nil, fmt.Errorf("unable to typecast runtime.Object to client.ObjectList") } if err := r.List(ctx, cList, opt); err != nil { return nil, err @@ -233,7 +234,7 @@ func (r *OperatorReconciler) hasExistingComponents(ctx context.Context, name str for _, list := range components { items, err := meta.ExtractList(list) if err != nil { - return false, fmt.Errorf("Unable to extract list from runtime.Object") + return false, fmt.Errorf("unable to extract list from runtime.Object") } if len(items) > 0 { return true, nil diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operatorcondition_controller.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operatorcondition_controller.go index 6b6ab867f5..b8e255f0da 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operatorcondition_controller.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operatorcondition_controller.go @@ -22,6 +22,7 @@ import ( operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" operatorsv2 "github.com/operator-framework/api/pkg/operators/v2" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/ownerutil" + "github.com/operator-framework/operator-lifecycle-manager/pkg/metrics" ) const ( @@ -92,38 +93,34 @@ var _ reconcile.Reconciler = &OperatorConditionReconciler{} func (r *OperatorConditionReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { // Set up a convenient log object so we don't have to type request over and over again - log := r.log.WithValues("request", req) - log.V(2).Info("reconciling operatorcondition") + log := r.log.WithValues("request", req).V(1) + log.Info("reconciling") + metrics.EmitOperatorConditionReconcile(req.Namespace, req.Name) operatorCondition := &operatorsv2.OperatorCondition{} - err := r.Client.Get(context.TODO(), req.NamespacedName, operatorCondition) - if err != nil { - log.V(1).Error(err, "Unable to find operatorcondition") - return ctrl.Result{}, err + if err := r.Client.Get(ctx, req.NamespacedName, operatorCondition); err != nil { + log.Info("Unable to find OperatorCondition") + return ctrl.Result{}, client.IgnoreNotFound(err) } - err = r.ensureOperatorConditionRole(operatorCondition) - if err != nil { - log.V(1).Error(err, "Error ensuring OperatorCondition Role") - return ctrl.Result{Requeue: true}, err + if err := r.ensureOperatorConditionRole(operatorCondition); err != nil { + log.Info("Error ensuring OperatorCondition Role") + return ctrl.Result{}, err } - err = r.ensureOperatorConditionRoleBinding(operatorCondition) - if err != nil { - log.V(1).Error(err, "Error ensuring OperatorCondition RoleBinding") - return ctrl.Result{Requeue: true}, err + if err := r.ensureOperatorConditionRoleBinding(operatorCondition); err != nil { + log.Info("Error ensuring OperatorCondition RoleBinding") + return ctrl.Result{}, err } - err = r.ensureDeploymentEnvVars(operatorCondition) - if err != nil { - log.V(1).Error(err, "Error ensuring OperatorCondition Deployment EnvVars") - return ctrl.Result{Requeue: true}, err + if err := r.ensureDeploymentEnvVars(operatorCondition); err != nil { + log.Info("Error ensuring OperatorCondition Deployment EnvVars") + return ctrl.Result{}, err } - err = r.syncOperatorConditionStatus(operatorCondition) - if err != nil { - log.V(1).Error(err, "Error syncing OperatorCondition Status") - return ctrl.Result{Requeue: true}, err + if err := r.syncOperatorConditionStatus(operatorCondition); err != nil { + log.Info("Error syncing OperatorCondition Status") + return ctrl.Result{}, err } return ctrl.Result{}, nil diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operatorconditiongenerator_controller.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operatorconditiongenerator_controller.go index 1000b6b57d..8e37cd44aa 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operatorconditiongenerator_controller.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operatorconditiongenerator_controller.go @@ -20,6 +20,7 @@ import ( operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" operatorsv2 "github.com/operator-framework/api/pkg/operators/v2" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/ownerutil" + "github.com/operator-framework/operator-lifecycle-manager/pkg/metrics" ) // OperatorConditionGeneratorReconciler reconciles a ClusterServiceVersion object and creates an OperatorCondition. @@ -89,13 +90,13 @@ var _ reconcile.Reconciler = &OperatorConditionGeneratorReconciler{} func (r *OperatorConditionGeneratorReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { // Set up a convenient log object so we don't have to type request over and over again - log := r.log.WithValues("request", req) + log := r.log.WithValues("request", req).V(1) + metrics.EmitOperatorConditionGeneratorReconcile(req.Namespace, req.Name) in := &operatorsv1alpha1.ClusterServiceVersion{} - err := r.Client.Get(context.TODO(), req.NamespacedName, in) - if err != nil { - log.V(1).Error(err, "Unable to find ClusterServiceVersion") - return ctrl.Result{}, err + if err := r.Client.Get(ctx, req.NamespacedName, in); err != nil { + log.Info("Unable to find ClusterServiceVersion") + return ctrl.Result{}, client.IgnoreNotFound(err) } operatorCondition := &operatorsv2.OperatorCondition{ @@ -111,10 +112,9 @@ func (r *OperatorConditionGeneratorReconciler) Reconcile(ctx context.Context, re } ownerutil.AddOwner(operatorCondition, in, false, true) - err = r.ensureOperatorCondition(*operatorCondition) - if err != nil { - log.V(1).Error(err, "Error ensuring ClusterServiceVersion") - return ctrl.Result{Requeue: true}, err + if err := r.ensureOperatorCondition(*operatorCondition); err != nil { + log.Info("Error ensuring OperatorCondition") + return ctrl.Result{}, err } return ctrl.Result{}, nil diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/grpc/source.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/grpc/source.go index 052570175b..59856c7f32 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/grpc/source.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/grpc/source.go @@ -8,15 +8,16 @@ import ( "sync" "time" + "github.com/operator-framework/operator-registry/pkg/client" + "github.com/sirupsen/logrus" "golang.org/x/net/http/httpproxy" "golang.org/x/net/proxy" "google.golang.org/grpc" "google.golang.org/grpc/connectivity" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry" - "github.com/operator-framework/operator-registry/pkg/client" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) type SourceMeta struct { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go index 145d29bce7..2e50268e12 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go @@ -140,7 +140,7 @@ func (c *GrpcRegistryReconciler) currentService(source grpcCatalogSourceDecorato serviceName := source.Service().GetName() service, err := c.Lister.CoreV1().ServiceLister().Services(source.GetNamespace()).Get(serviceName) if err != nil { - logrus.WithField("service", serviceName).Warn("couldn't find service in cache") + logrus.WithField("service", serviceName).Debug("couldn't find service in cache") return nil } return service @@ -153,7 +153,7 @@ func (c *GrpcRegistryReconciler) currentPods(source grpcCatalogSourceDecorator) return nil } if len(pods) > 1 { - logrus.WithField("selector", source.Selector()).Warn("multiple pods found for selector") + logrus.WithField("selector", source.Selector()).Debug("multiple pods found for selector") } return pods } @@ -165,7 +165,7 @@ func (c *GrpcRegistryReconciler) currentUpdatePods(source grpcCatalogSourceDecor return nil } if len(pods) > 1 { - logrus.WithField("selector", source.Selector()).Warn("multiple pods found for selector") + logrus.WithField("selector", source.Selector()).Debug("multiple pods found for selector") } return pods } @@ -274,7 +274,7 @@ func (c *GrpcRegistryReconciler) ensureUpdatePod(source grpcCatalogSourceDecorat currentUpdatePods := c.currentUpdatePods(source) if source.Update() && len(currentUpdatePods) == 0 { - logrus.WithField("CatalogSource", source.GetName()).Infof("catalog update required at %s", time.Now().String()) + logrus.WithField("CatalogSource", source.GetName()).Debugf("catalog update required at %s", time.Now().String()) pod, err := c.createUpdatePod(source, saName) if err != nil { return errors.Wrapf(err, "creating update catalog source pod") @@ -315,7 +315,7 @@ func (c *GrpcRegistryReconciler) ensureUpdatePod(source grpcCatalogSourceDecorat return nil } // delete update pod right away, since the digest match, to prevent long-lived duplicate catalog pods - logrus.WithField("CatalogSource", source.GetName()).Info("catalog polling result: no update") + logrus.WithField("CatalogSource", source.GetName()).Debug("catalog polling result: no update") err := c.removePods([]*corev1.Pod{updatePod}, source.GetNamespace()) if err != nil { return errors.Wrapf(err, "error deleting duplicate catalog polling pod: %s", updatePod.GetName()) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go index 31e42eba04..050e20d07d 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go @@ -132,7 +132,7 @@ func Pod(source *v1alpha1.CatalogSource, name string, image string, saName strin }, }, ReadinessProbe: &v1.Probe{ - Handler: v1.Handler{ + ProbeHandler: v1.ProbeHandler{ Exec: &v1.ExecAction{ Command: []string{"grpc_health_probe", "-addr=:50051"}, }, @@ -141,7 +141,7 @@ func Pod(source *v1alpha1.CatalogSource, name string, image string, saName strin TimeoutSeconds: 5, }, LivenessProbe: &v1.Probe{ - Handler: v1.Handler{ + ProbeHandler: v1.ProbeHandler{ Exec: &v1.ExecAction{ Command: []string{"grpc_health_probe", "-addr=:50051"}, }, diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/registry_client.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/registry_client.go index fe9e2b6a3a..57a974bc63 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/registry_client.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/registry_client.go @@ -88,7 +88,7 @@ func (rc *Client) FindBundleThatProvides(ctx context.Context, group, version, ki } entry := rc.filterChannelEntries(ctx, it, excludedPackages) if entry == nil { - return nil, fmt.Errorf("Unable to find a channel entry that satisfies the requirements") + return nil, fmt.Errorf("unable to find a channel entry that satisfies the requirements") } bundle, err := rc.Client.Registry.GetBundle(ctx, ®istryapi.GetBundleRequest{PkgName: entry.PackageName, ChannelName: entry.ChannelName, CsvName: entry.BundleName}) if err != nil { @@ -101,7 +101,7 @@ func (rc *Client) FindBundleThatProvides(ctx context.Context, group, version, ki // API and come from the same package with original operator and returns the // first entry on the list from the default channel of that package func (rc *Client) filterChannelEntries(ctx context.Context, it *ChannelEntryIterator, excludedPackages map[string]struct{}) *opregistry.ChannelEntry { - defChannels := make(map[string]string, 0) + defChannels := make(map[string]string) var entries []*opregistry.ChannelEntry for e := it.Next(); e != nil; e = it.Next() { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go index e719265ff4..a53b40230d 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go @@ -10,9 +10,6 @@ import ( "github.com/sirupsen/logrus" "k8s.io/apimachinery/pkg/util/errors" - - "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1" - "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" ) const existingOperatorKey = "@existing" @@ -72,22 +69,26 @@ func (p StaticSourceProvider) Sources(namespaces ...string) map[SourceKey]Source type OperatorCacheProvider interface { Namespaced(namespaces ...string) MultiCatalogOperatorFinder - Expire(catalog SourceKey) } -type Cache struct { - logger logrus.StdLogger - sp SourceProvider - catsrcLister v1alpha1.CatalogSourceLister - snapshots map[SourceKey]*snapshotHeader - ttl time.Duration - sem chan struct{} - m sync.RWMutex +type SourcePriorityProvider interface { + Priority(SourceKey) int } -type catalogSourcePriority int +type constantSourcePriorityProvider int + +func (spp constantSourcePriorityProvider) Priority(SourceKey) int { + return int(spp) +} -var _ OperatorCacheProvider = &Cache{} +type Cache struct { + logger logrus.StdLogger + sp SourceProvider + sourcePriorityProvider SourcePriorityProvider + snapshots map[SourceKey]*snapshotHeader + sem chan struct{} + m sync.RWMutex +} type Option func(*Cache) @@ -97,9 +98,9 @@ func WithLogger(logger logrus.StdLogger) Option { } } -func WithCatalogSourceLister(catalogSourceLister v1alpha1.CatalogSourceLister) Option { +func WithSourcePriorityProvider(spp SourcePriorityProvider) Option { return func(c *Cache) { - c.catsrcLister = catalogSourceLister + c.sourcePriorityProvider = spp } } @@ -114,11 +115,10 @@ func New(sp SourceProvider, options ...Option) *Cache { logger.SetOutput(io.Discard) return logger }(), - sp: sp, - catsrcLister: operatorlister.NewLister().OperatorsV1alpha1().CatalogSourceLister(), - snapshots: make(map[SourceKey]*snapshotHeader), - ttl: 5 * time.Minute, - sem: make(chan struct{}, MaxConcurrentSnapshotUpdates), + sp: sp, + sourcePriorityProvider: constantSourcePriorityProvider(0), + snapshots: make(map[SourceKey]*snapshotHeader), + sem: make(chan struct{}, MaxConcurrentSnapshotUpdates), } for _, opt := range options { @@ -129,7 +129,6 @@ func New(sp SourceProvider, options ...Option) *Cache { } type NamespacedOperatorCache struct { - existing *SourceKey snapshots map[SourceKey]*snapshotHeader } @@ -146,22 +145,11 @@ func (c *NamespacedOperatorCache) Error() error { return errors.NewAggregate(errs) } -func (c *Cache) Expire(catalog SourceKey) { - c.m.Lock() - defer c.m.Unlock() - s, ok := c.snapshots[catalog] - if !ok { - return - } - s.expiry = time.Unix(0, 0) -} - func (c *Cache) Namespaced(namespaces ...string) MultiCatalogOperatorFinder { const ( CachePopulateTimeout = time.Minute ) - now := time.Now() sources := c.sp.Sources(namespaces...) result := NamespacedOperatorCache{ @@ -178,7 +166,7 @@ func (c *Cache) Namespaced(namespaces ...string) MultiCatalogOperatorFinder { func() { snapshot.m.RLock() defer snapshot.m.RUnlock() - if snapshot.Valid(now) { + if snapshot.Valid() { result.snapshots[key] = snapshot } else { misses = append(misses, key) @@ -201,7 +189,7 @@ func (c *Cache) Namespaced(namespaces ...string) MultiCatalogOperatorFinder { // Take the opportunity to clear expired snapshots while holding the lock. var expired []SourceKey for key, snapshot := range c.snapshots { - if !snapshot.Valid(now) { + if !snapshot.Valid() { snapshot.Cancel() expired = append(expired, key) } @@ -213,7 +201,7 @@ func (c *Cache) Namespaced(namespaces ...string) MultiCatalogOperatorFinder { // Check for any snapshots that were populated while waiting to acquire the lock. var found int for i := range misses { - if hdr, ok := c.snapshots[misses[i]]; ok && hdr.Valid(now) { + if hdr, ok := c.snapshots[misses[i]]; ok && hdr.Valid() { result.snapshots[misses[i]] = hdr misses[found], misses[i] = misses[i], misses[found] found++ @@ -225,14 +213,9 @@ func (c *Cache) Namespaced(namespaces ...string) MultiCatalogOperatorFinder { ctx, cancel := context.WithTimeout(context.Background(), CachePopulateTimeout) hdr := snapshotHeader{ - key: miss, - expiry: now.Add(c.ttl), - pop: cancel, - } - - // Ignoring error and treat catsrc priority as 0 if not found. - if catsrc, _ := c.catsrcLister.CatalogSources(miss.Namespace).Get(miss.Name); catsrc != nil { - hdr.priority = catsrc.Spec.Priority + key: miss, + pop: cancel, + priority: c.sourcePriorityProvider.Priority(miss), } hdr.m.Lock() @@ -243,7 +226,13 @@ func (c *Cache) Namespaced(namespaces ...string) MultiCatalogOperatorFinder { defer hdr.m.Unlock() c.sem <- struct{}{} defer func() { <-c.sem }() - hdr.snapshot, hdr.err = source.Snapshot(ctx) + if snapshot, err := source.Snapshot(ctx); err != nil { + hdr.err = err + } else if snapshot != nil { + hdr.snapshot = snapshot + } else { + hdr.err = fmt.Errorf("source %q produced no snapshot and no error", hdr.key) + } }(ctx, &hdr, sources[miss]) } @@ -266,7 +255,7 @@ func (c *NamespacedOperatorCache) FindPreferred(preferred *SourceKey, preferredN if preferred != nil && preferred.Empty() { preferred = nil } - sorted := newSortableSnapshots(c.existing, preferred, preferredNamespace, c.snapshots) + sorted := newSortableSnapshots(preferred, preferredNamespace, c.snapshots) sort.Sort(sorted) for _, snapshot := range sorted.snapshots { result = append(result, snapshot.Find(p...)...) @@ -274,29 +263,21 @@ func (c *NamespacedOperatorCache) FindPreferred(preferred *SourceKey, preferredN return result } -func (c *NamespacedOperatorCache) WithExistingOperators(snapshot *Snapshot, namespace string) MultiCatalogOperatorFinder { - key := NewVirtualSourceKey(namespace) - o := &NamespacedOperatorCache{ - existing: &key, - snapshots: map[SourceKey]*snapshotHeader{ - key: { - key: key, - snapshot: snapshot, - }, - }, - } - for k, v := range c.snapshots { - o.snapshots[k] = v - } - return o -} - func (c *NamespacedOperatorCache) Find(p ...Predicate) []*Entry { return c.FindPreferred(nil, "", p...) } type Snapshot struct { Entries []*Entry + + // Unless closed, the Snapshot is valid. + Valid <-chan struct{} +} + +func ValidOnce() <-chan struct{} { + c := make(chan struct{}) + close(c) + return c } var _ Source = &Snapshot{} @@ -309,7 +290,6 @@ type snapshotHeader struct { snapshot *Snapshot key SourceKey - expiry time.Time m sync.RWMutex pop context.CancelFunc err error @@ -320,10 +300,18 @@ func (hdr *snapshotHeader) Cancel() { hdr.pop() } -func (hdr *snapshotHeader) Valid(at time.Time) bool { +func (hdr *snapshotHeader) Valid() bool { hdr.m.RLock() defer hdr.m.RUnlock() - return hdr.snapshot != nil && hdr.err == nil && at.Before(hdr.expiry) + if hdr.snapshot == nil || hdr.err != nil { + return false + } + select { + case <-hdr.snapshot.Valid: + return false + default: + } + return true } type sortableSnapshots struct { @@ -333,7 +321,14 @@ type sortableSnapshots struct { existing *SourceKey } -func newSortableSnapshots(existing, preferred *SourceKey, preferredNamespace string, snapshots map[SourceKey]*snapshotHeader) sortableSnapshots { +func newSortableSnapshots(preferred *SourceKey, preferredNamespace string, snapshots map[SourceKey]*snapshotHeader) sortableSnapshots { + var existing *SourceKey + for key := range snapshots { + if key.Virtual() && key.Namespace == preferredNamespace { + existing = &key + break + } + } sorted := sortableSnapshots{ existing: existing, preferred: preferred, @@ -402,13 +397,13 @@ func (s sortableSnapshots) Swap(i, j int) { s.snapshots[i], s.snapshots[j] = s.snapshots[j], s.snapshots[i] } -func (s *snapshotHeader) Find(p ...Predicate) []*Entry { - s.m.RLock() - defer s.m.RUnlock() - if s.snapshot == nil { +func (hdr *snapshotHeader) Find(p ...Predicate) []*Entry { + hdr.m.RLock() + defer hdr.m.RUnlock() + if hdr.snapshot == nil { return nil } - return Filter(s.snapshot.Entries, p...) + return Filter(hdr.snapshot.Entries, p...) } type OperatorFinder interface { @@ -418,7 +413,6 @@ type OperatorFinder interface { type MultiCatalogOperatorFinder interface { Catalog(SourceKey) OperatorFinder FindPreferred(preferred *SourceKey, preferredNamespace string, predicates ...Predicate) []*Entry - WithExistingOperators(snapshot *Snapshot, namespace string) MultiCatalogOperatorFinder Error() error OperatorFinder } @@ -429,13 +423,6 @@ func (f EmptyOperatorFinder) Find(...Predicate) []*Entry { return nil } -func AtLeast(n int, operators []*Entry) ([]*Entry, error) { - if len(operators) < n { - return nil, fmt.Errorf("expected at least %d operator(s), got %d", n, len(operators)) - } - return operators, nil -} - func ExactlyOne(operators []*Entry) (*Entry, error) { if len(operators) != 1 { return nil, fmt.Errorf("expected exactly one operator, got %d", len(operators)) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go index 8e09d5dad4..85d9f3d914 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go @@ -14,6 +14,7 @@ import ( opregistry "github.com/operator-framework/operator-registry/pkg/registry" ) +// todo: drop fields from cache.Entry and move to pkg/controller/operators/olm type APISet map[opregistry.APIKey]struct{} func EmptyAPISet() APISet { @@ -106,9 +107,7 @@ func (s APISet) Intersection(sets ...APISet) APISet { func (s APISet) Difference(set APISet) APISet { difference := make(APISet).Union(s) for api := range set { - if _, ok := difference[api]; ok { - delete(difference, api) - } + delete(difference, api) } return difference @@ -135,59 +134,6 @@ func (s APISet) StripPlural() APISet { return set } -type APIOwnerSet map[opregistry.APIKey]*Entry - -func EmptyAPIOwnerSet() APIOwnerSet { - return map[opregistry.APIKey]*Entry{} -} - -type OperatorSet map[string]*Entry - -func EmptyOperatorSet() OperatorSet { - return map[string]*Entry{} -} - -// Snapshot returns a new set, pointing to the same values -func (o OperatorSet) Snapshot() OperatorSet { - out := make(map[string]*Entry) - for key, val := range o { - out[key] = val - } - return out -} - -type APIMultiOwnerSet map[opregistry.APIKey]OperatorSet - -func EmptyAPIMultiOwnerSet() APIMultiOwnerSet { - return map[opregistry.APIKey]OperatorSet{} -} - -func (s APIMultiOwnerSet) PopAPIKey() *opregistry.APIKey { - for a := range s { - api := &opregistry.APIKey{ - Group: a.Group, - Version: a.Version, - Kind: a.Kind, - Plural: a.Plural, - } - delete(s, a) - return api - } - return nil -} - -func (s APIMultiOwnerSet) PopAPIRequirers() OperatorSet { - requirers := EmptyOperatorSet() - for a := range s { - for key, op := range s[a] { - requirers[key] = op - } - delete(s, a) - return requirers - } - return nil -} - type OperatorSourceInfo struct { Package string Channel string @@ -201,9 +147,6 @@ func (i *OperatorSourceInfo) String() string { return fmt.Sprintf("%s/%s in %s/%s", i.Package, i.Channel, i.Catalog.Name, i.Catalog.Namespace) } -var NoCatalog = SourceKey{Name: "", Namespace: ""} -var ExistingOperator = OperatorSourceInfo{Package: "", Channel: "", StartingCSV: "", Catalog: NoCatalog, DefaultChannel: false} - type Entry struct { Name string Replaces string diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go index 037af4207d..73866ebbf1 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go @@ -235,7 +235,7 @@ func And(p ...Predicate) Predicate { func (p andPredicate) Test(o *Entry) bool { for _, predicate := range p.predicates { - if predicate.Test(o) == false { + if !predicate.Test(o) { return false } } @@ -265,7 +265,7 @@ type orPredicate struct { func (p orPredicate) Test(o *Entry) bool { for _, predicate := range p.predicates { - if predicate.Test(o) == true { + if predicate.Test(o) { return true } } @@ -295,7 +295,7 @@ type notPredicate struct { func (p notPredicate) Test(o *Entry) bool { // !pred && !pred is equivalent to !(pred || pred). - return !orPredicate{p.predicates}.Test(o) + return !orPredicate(p).Test(o) } func (p notPredicate) String() string { @@ -323,9 +323,9 @@ func (b booleanPredicate) Test(o *Entry) bool { func (b booleanPredicate) String() string { if b.result { - return fmt.Sprintf("predicate is true") + return "predicate is true" } - return fmt.Sprintf("predicate is false") + return "predicate is false" } func True() Predicate { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/hooks.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/hooks.go new file mode 100644 index 0000000000..aaa98e64c4 --- /dev/null +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/hooks.go @@ -0,0 +1,9 @@ +package resolver + +// stepResolverInitHook provides a way for the downstream +// to modify the step resolver at creation time. +// This is a bit of a hack to enable system constraints downstream +// without affecting the upstream. We may want to clean this up when +// either we have a more pluggable architecture; or system constraints +// come to the upstream +type stepResolverInitHook func(*OperatorStepResolver) error diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go index 453ae4a0b8..d55d67c4fc 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go @@ -4,7 +4,6 @@ import ( "time" "github.com/operator-framework/api/pkg/operators/v1alpha1" - "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache" ) type InstrumentedResolver struct { @@ -27,13 +26,9 @@ func (ir *InstrumentedResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step start := time.Now() steps, lookups, subs, err := ir.resolver.ResolveSteps(namespace) if err != nil { - ir.failureMetricsEmitter(time.Now().Sub(start)) + ir.failureMetricsEmitter(time.Since(start)) } else { - ir.successMetricsEmitter(time.Now().Sub(start)) + ir.successMetricsEmitter(time.Since(start)) } return steps, lookups, subs, err } - -func (ir *InstrumentedResolver) Expire(key cache.SourceKey) { - ir.resolver.Expire(key) -} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go index 4905aa3765..c19aba9f26 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go @@ -13,27 +13,31 @@ import ( "github.com/operator-framework/api/pkg/constraints" "github.com/operator-framework/api/pkg/operators/v1alpha1" - v1alpha1listers "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1" "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache" - "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/projection" "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver" "github.com/operator-framework/operator-registry/pkg/api" opregistry "github.com/operator-framework/operator-registry/pkg/registry" ) -type OperatorResolver interface { - SolveOperators(csvs []*v1alpha1.ClusterServiceVersion, subs []*v1alpha1.Subscription, add map[cache.OperatorSourceInfo]struct{}) (cache.OperatorSet, error) +// constraintProvider knows how to provide solver constraints for a given cache entry. +// For instance, it could be used to surface additional constraints against an entry given some +// properties it may expose. E.g. olm.maxOpenShiftVersion could be checked against the cluster version +// and prohibit any entry that doesn't meet the requirement +type constraintProvider interface { + // Constraints returns a set of solver constraints for a cache entry. + Constraints(e *cache.Entry) ([]solver.Constraint, error) } -type SatResolver struct { - cache cache.OperatorCacheProvider - log logrus.FieldLogger - pc *predicateConverter +type Resolver struct { + cache *cache.Cache + log logrus.FieldLogger + pc *predicateConverter + systemConstraintsProvider constraintProvider } -func NewDefaultSatResolver(rcp cache.SourceProvider, catsrcLister v1alpha1listers.CatalogSourceLister, logger logrus.FieldLogger) *SatResolver { - return &SatResolver{ - cache: cache.New(rcp, cache.WithLogger(logger), cache.WithCatalogSourceLister(catsrcLister)), +func NewDefaultResolver(rcp cache.SourceProvider, sourcePriorityProvider cache.SourcePriorityProvider, logger logrus.FieldLogger) *Resolver { + return &Resolver{ + cache: cache.New(rcp, cache.WithLogger(logger), cache.WithSourcePriorityProvider(sourcePriorityProvider)), log: logger, pc: &predicateConverter{ celEnv: constraints.NewCelEnvironment(), @@ -51,43 +55,45 @@ func (w *debugWriter) Write(b []byte) (int, error) { return n, nil } -func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.ClusterServiceVersion, subs []*v1alpha1.Subscription) (cache.OperatorSet, error) { +func (r *Resolver) Resolve(namespaces []string, subs []*v1alpha1.Subscription) ([]*cache.Entry, error) { var errs []error - installables := make(map[solver.Identifier]solver.Installable, 0) - visited := make(map[*cache.Entry]*BundleInstallable, 0) + variables := make(map[solver.Identifier]solver.Variable) + visited := make(map[*cache.Entry]*BundleVariable) // TODO: better abstraction startingCSVs := make(map[string]struct{}) - // build a virtual catalog of all currently installed CSVs - existingSnapshot, err := r.newSnapshotForNamespace(namespaces[0], subs, csvs) - if err != nil { - return nil, err + namespacedCache := r.cache.Namespaced(namespaces...) + + if len(namespaces) < 1 { + // the first namespace is treated as the preferred namespace today + return nil, fmt.Errorf("at least one namespace must be provided to resolution") } - namespacedCache := r.cache.Namespaced(namespaces...).WithExistingOperators(existingSnapshot, namespaces[0]) - _, existingInstallables, err := r.getBundleInstallables(namespaces[0], cache.Filter(existingSnapshot.Entries, cache.True()), namespacedCache, visited) + preferredNamespace := namespaces[0] + _, existingVariables, err := r.getBundleVariables(preferredNamespace, namespacedCache.Catalog(cache.NewVirtualSourceKey(preferredNamespace)).Find(cache.True()), namespacedCache, visited) if err != nil { return nil, err } - for _, i := range existingInstallables { - installables[i.Identifier()] = i + for _, i := range existingVariables { + variables[i.Identifier()] = i } // build constraints for each Subscription for _, sub := range subs { // find the currently installed operator (if it exists) var current *cache.Entry - for _, csv := range csvs { - if csv.Name == sub.Status.InstalledCSV { - op, err := newOperatorFromV1Alpha1CSV(csv) - if err != nil { - return nil, err - } - current = op - break + + matches := namespacedCache.Catalog(cache.NewVirtualSourceKey(sub.Namespace)).Find(cache.CSVNamePredicate(sub.Status.InstalledCSV)) + if len(matches) > 1 { + var names []string + for _, each := range matches { + names = append(names, each.Name) } + return nil, fmt.Errorf("multiple name matches for status.installedCSV of subscription %s/%s: %s", sub.Namespace, sub.Name, strings.Join(names, ", ")) + } else if len(matches) == 1 { + current = matches[0] } if current == nil && sub.Spec.StartingCSV != "" { @@ -95,25 +101,25 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust } // find operators, in channel order, that can skip from the current version or list the current in "replaces" - subInstallables, err := r.getSubscriptionInstallables(sub, current, namespacedCache, visited) + subVariables, err := r.getSubscriptionVariables(sub, current, namespacedCache, visited) if err != nil { errs = append(errs, err) continue } - for _, i := range subInstallables { - installables[i.Identifier()] = i + for _, i := range subVariables { + variables[i.Identifier()] = i } } - r.addInvariants(namespacedCache, installables) + r.addInvariants(namespacedCache, variables) if err := namespacedCache.Error(); err != nil { return nil, err } - input := make([]solver.Installable, 0) - for _, i := range installables { + input := make([]solver.Variable, 0) + for _, i := range variables { input = append(input, i) } @@ -124,16 +130,16 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust if err != nil { return nil, err } - solvedInstallables, err := s.Solve(context.TODO()) + solvedVariables, err := s.Solve(context.TODO()) if err != nil { return nil, err } - // get the set of bundle installables from the result solved installables - operatorInstallables := make([]BundleInstallable, 0) - for _, installable := range solvedInstallables { - if bundleInstallable, ok := installable.(*BundleInstallable); ok { - _, _, catalog, err := bundleInstallable.BundleSourceInfo() + // get the set of bundle variables from the result solved variables + operatorVariables := make([]BundleVariable, 0) + for _, variable := range solvedVariables { + if bundleVariable, ok := variable.(*BundleVariable); ok { + _, _, catalog, err := bundleVariable.BundleSourceInfo() if err != nil { return nil, fmt.Errorf("error determining origin of operator: %w", err) } @@ -141,13 +147,13 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust // Result is expected to contain only new things. continue } - operatorInstallables = append(operatorInstallables, *bundleInstallable) + operatorVariables = append(operatorVariables, *bundleVariable) } } - operators := make(map[string]*cache.Entry, 0) - for _, installableOperator := range operatorInstallables { - csvName, channel, catalog, err := installableOperator.BundleSourceInfo() + var operators []*cache.Entry + for _, variableOperator := range operatorVariables { + csvName, channel, catalog, err := variableOperator.BundleSourceInfo() if err != nil { errs = append(errs, err) continue @@ -158,16 +164,38 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust errs = append(errs, err) continue } - if len(installableOperator.Replaces) > 0 { - op.Replaces = installableOperator.Replaces // TODO: Don't mutate object from cache! - } - // lookup if this installable came from a starting CSV + // copy consumed fields to avoid directly mutating cache + op = &cache.Entry{ + Name: op.Name, + Replaces: op.Replaces, + Skips: op.Skips, + SkipRange: op.SkipRange, + ProvidedAPIs: op.ProvidedAPIs, + RequiredAPIs: op.RequiredAPIs, + Version: op.Version, + SourceInfo: &cache.OperatorSourceInfo{ + Package: op.SourceInfo.Package, + Channel: op.SourceInfo.Channel, + StartingCSV: op.SourceInfo.StartingCSV, + Catalog: op.SourceInfo.Catalog, + DefaultChannel: op.SourceInfo.DefaultChannel, + Subscription: op.SourceInfo.Subscription, + }, + Properties: op.Properties, + BundlePath: op.BundlePath, + Bundle: op.Bundle, + } + if len(variableOperator.Replaces) > 0 { + op.Replaces = variableOperator.Replaces + } + + // lookup if this variable came from a starting CSV if _, ok := startingCSVs[csvName]; ok { - op.SourceInfo.StartingCSV = csvName // TODO: Don't mutate object from cache! + op.SourceInfo.StartingCSV = csvName } - operators[csvName] = op + operators = append(operators, op) } if len(errs) > 0 { @@ -177,9 +205,28 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust return operators, nil } -func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, current *cache.Entry, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Entry]*BundleInstallable) (map[solver.Identifier]solver.Installable, error) { +// newBundleVariableFromEntry converts an entry into a bundle variable with +// system constraints applied, if they are defined for the entry +func (r *Resolver) newBundleVariableFromEntry(entry *cache.Entry) (*BundleVariable, error) { + bundleInstalleble, err := NewBundleVariableFromOperator(entry) + if err != nil { + return nil, err + } + + // apply system constraints if necessary + if r.systemConstraintsProvider != nil && !(entry.SourceInfo.Catalog.Virtual()) { + systemConstraints, err := r.systemConstraintsProvider.Constraints(entry) + if err != nil { + return nil, err + } + bundleInstalleble.constraints = append(bundleInstalleble.constraints, systemConstraints...) + } + return &bundleInstalleble, nil +} + +func (r *Resolver) getSubscriptionVariables(sub *v1alpha1.Subscription, current *cache.Entry, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Entry]*BundleVariable) (map[solver.Identifier]solver.Variable, error) { var cachePredicates, channelPredicates []cache.Predicate - installables := make(map[solver.Identifier]solver.Installable, 0) + variables := make(map[solver.Identifier]solver.Variable) catalog := cache.SourceKey{ Name: sub.Spec.CatalogSource, @@ -207,21 +254,21 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu )) entries = namespacedCache.Catalog(catalog).Find(cachePredicates...) - var si solver.Installable + var si solver.Variable switch { case nall == 0: - si = NewInvalidSubscriptionInstallable(sub.GetName(), fmt.Sprintf("no operators found from catalog %s in namespace %s referenced by subscription %s", sub.Spec.CatalogSource, sub.Spec.CatalogSourceNamespace, sub.GetName())) + si = NewInvalidSubscriptionVariable(sub.GetName(), fmt.Sprintf("no operators found from catalog %s in namespace %s referenced by subscription %s", sub.Spec.CatalogSource, sub.Spec.CatalogSourceNamespace, sub.GetName())) case npkg == 0: - si = NewInvalidSubscriptionInstallable(sub.GetName(), fmt.Sprintf("no operators found in package %s in the catalog referenced by subscription %s", sub.Spec.Package, sub.GetName())) + si = NewInvalidSubscriptionVariable(sub.GetName(), fmt.Sprintf("no operators found in package %s in the catalog referenced by subscription %s", sub.Spec.Package, sub.GetName())) case nch == 0: - si = NewInvalidSubscriptionInstallable(sub.GetName(), fmt.Sprintf("no operators found in channel %s of package %s in the catalog referenced by subscription %s", sub.Spec.Channel, sub.Spec.Package, sub.GetName())) + si = NewInvalidSubscriptionVariable(sub.GetName(), fmt.Sprintf("no operators found in channel %s of package %s in the catalog referenced by subscription %s", sub.Spec.Channel, sub.Spec.Package, sub.GetName())) case ncsv == 0: - si = NewInvalidSubscriptionInstallable(sub.GetName(), fmt.Sprintf("no operators found with name %s in channel %s of package %s in the catalog referenced by subscription %s", sub.Spec.StartingCSV, sub.Spec.Channel, sub.Spec.Package, sub.GetName())) + si = NewInvalidSubscriptionVariable(sub.GetName(), fmt.Sprintf("no operators found with name %s in channel %s of package %s in the catalog referenced by subscription %s", sub.Spec.StartingCSV, sub.Spec.Channel, sub.Spec.Package, sub.GetName())) } if si != nil { - installables[si.Identifier()] = si - return installables, nil + variables[si.Identifier()] = si + return variables, nil } } @@ -263,11 +310,11 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu } } - candidates := make([]*BundleInstallable, 0) + candidates := make([]*BundleVariable, 0) for _, o := range cache.Filter(sortedBundles, channelPredicates...) { predicates := append(cachePredicates, cache.CSVNamePredicate(o.Name)) stack := namespacedCache.Catalog(catalog).Find(predicates...) - id, installable, err := r.getBundleInstallables(sub.Namespace, stack, namespacedCache, visited) + id, variable, err := r.getBundleVariables(sub.Namespace, stack, namespacedCache, visited) if err != nil { return nil, err } @@ -275,11 +322,11 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu return nil, fmt.Errorf("could not find any potential bundles for subscription: %s", sub.Spec.Package) } - for _, i := range installable { + for _, i := range variable { if _, ok := id[i.Identifier()]; ok { candidates = append(candidates, i) } - installables[i.Identifier()] = i + variables[i.Identifier()] = i } } @@ -296,26 +343,26 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu // safe to remove this conflict if properties // annotations are made mandatory for // resolution. - c.AddConflict(bundleId(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace()))) + c.AddConflict(bundleID(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace()))) } depIds = append(depIds, c.Identifier()) } if current != nil { - depIds = append(depIds, bundleId(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace()))) + depIds = append(depIds, bundleID(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace()))) } // all candidates added as options for this constraint - subInstallable := NewSubscriptionInstallable(sub.GetName(), depIds) - installables[subInstallable.Identifier()] = subInstallable + subVariable := NewSubscriptionVariable(sub.GetName(), depIds) + variables[subVariable.Identifier()] = subVariable - return installables, nil + return variables, nil } -func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleStack []*cache.Entry, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Entry]*BundleInstallable) (map[solver.Identifier]struct{}, map[solver.Identifier]*BundleInstallable, error) { +func (r *Resolver) getBundleVariables(preferredNamespace string, bundleStack []*cache.Entry, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Entry]*BundleVariable) (map[solver.Identifier]struct{}, map[solver.Identifier]*BundleVariable, error) { errs := make([]error, 0) - installables := make(map[solver.Identifier]*BundleInstallable, 0) // all installables, including dependencies + variables := make(map[solver.Identifier]*BundleVariable) // all variables, including dependencies - // track the first layer of installable ids + // track the first layer of variable ids var initial = make(map[*cache.Entry]struct{}) for _, o := range bundleStack { initial[o] = struct{}{} @@ -330,17 +377,17 @@ func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleSta bundleStack = bundleStack[:len(bundleStack)-1] if b, ok := visited[bundle]; ok { - installables[b.identifier] = b + variables[b.identifier] = b continue } - bundleInstallable, err := NewBundleInstallableFromOperator(bundle) + bundleVariable, err := r.newBundleVariableFromEntry(bundle) if err != nil { errs = append(errs, err) continue } - visited[bundle] = &bundleInstallable + visited[bundle] = bundleVariable dependencyPredicates, err := r.pc.convertDependencyProperties(bundle.Properties) if err != nil { @@ -389,156 +436,46 @@ func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleSta // (after sorting) to remove all bundles that // don't satisfy the dependency. for _, b := range cache.Filter(sortedBundles, d) { - i, err := NewBundleInstallableFromOperator(b) + i, err := r.newBundleVariableFromEntry(b) if err != nil { errs = append(errs, err) continue } - installables[i.Identifier()] = &i + variables[i.Identifier()] = i bundleDependencies = append(bundleDependencies, i.Identifier()) bundleStack = append(bundleStack, b) } - bundleInstallable.AddConstraint(PrettyConstraint( + bundleVariable.AddConstraint(PrettyConstraint( solver.Dependency(bundleDependencies...), fmt.Sprintf("bundle %s requires an operator %s", bundle.Name, d.String()), )) } - installables[bundleInstallable.Identifier()] = &bundleInstallable + variables[bundleVariable.Identifier()] = bundleVariable } if len(errs) > 0 { return nil, nil, utilerrors.NewAggregate(errs) } - ids := make(map[solver.Identifier]struct{}, 0) // immediate installables found via predicates + ids := make(map[solver.Identifier]struct{}) // immediate variables found via predicates for o := range initial { ids[visited[o].Identifier()] = struct{}{} } - return ids, installables, nil -} - -func (r *SatResolver) inferProperties(csv *v1alpha1.ClusterServiceVersion, subs []*v1alpha1.Subscription) ([]*api.Property, error) { - var properties []*api.Property - - packages := make(map[string]struct{}) - for _, sub := range subs { - if sub.Status.InstalledCSV != csv.Name { - continue - } - // Without sanity checking the Subscription spec's - // package against catalog contents, updates to the - // Subscription spec could result in a bad package - // inference. - for _, entry := range r.cache.Namespaced(sub.Spec.CatalogSourceNamespace).Catalog(cache.SourceKey{Namespace: sub.Spec.CatalogSourceNamespace, Name: sub.Spec.CatalogSource}).Find(cache.And(cache.CSVNamePredicate(csv.Name), cache.PkgPredicate(sub.Spec.Package))) { - if pkg := entry.Package(); pkg != "" { - packages[pkg] = struct{}{} - } - } - } - if l := len(packages); l != 1 { - r.log.Warnf("could not unambiguously infer package name for %q (found %d distinct package names)", csv.Name, l) - return properties, nil - } - var pkg string - for pkg = range packages { - // Assign the single key to pkg. - } - var version string // Emit empty string rather than "0.0.0" if .spec.version is zero-valued. - if !csv.Spec.Version.Version.Equals(semver.Version{}) { - version = csv.Spec.Version.String() - } - if pp, err := json.Marshal(opregistry.PackageProperty{ - PackageName: pkg, - Version: version, - }); err != nil { - return nil, fmt.Errorf("failed to marshal inferred package property: %w", err) - } else { - properties = append(properties, &api.Property{ - Type: opregistry.PackageType, - Value: string(pp), - }) - } - - return properties, nil + return ids, variables, nil } -func (r *SatResolver) newSnapshotForNamespace(namespace string, subs []*v1alpha1.Subscription, csvs []*v1alpha1.ClusterServiceVersion) (*cache.Snapshot, error) { - existingOperatorCatalog := cache.NewVirtualSourceKey(namespace) - // build a catalog snapshot of CSVs without subscriptions - csvSubscriptions := make(map[*v1alpha1.ClusterServiceVersion]*v1alpha1.Subscription) - for _, sub := range subs { - for _, csv := range csvs { - if csv.Name == sub.Status.InstalledCSV { - csvSubscriptions[csv] = sub - break - } - } - } - var csvsMissingProperties []*v1alpha1.ClusterServiceVersion - standaloneOperators := make([]*cache.Entry, 0) - for _, csv := range csvs { - op, err := newOperatorFromV1Alpha1CSV(csv) - if err != nil { - return nil, err - } - - if anno, ok := csv.GetAnnotations()[projection.PropertiesAnnotationKey]; !ok { - csvsMissingProperties = append(csvsMissingProperties, csv) - if inferred, err := r.inferProperties(csv, subs); err != nil { - r.log.Warnf("unable to infer properties for csv %q: %w", csv.Name, err) - } else { - op.Properties = append(op.Properties, inferred...) - } - } else if props, err := projection.PropertyListFromPropertiesAnnotation(anno); err != nil { - return nil, fmt.Errorf("failed to retrieve properties of csv %q: %w", csv.GetName(), err) - } else { - op.Properties = props - } - - op.SourceInfo = &cache.OperatorSourceInfo{ - Catalog: existingOperatorCatalog, - Subscription: csvSubscriptions[csv], - } - // Try to determine source package name from properties and add to SourceInfo. - for _, p := range op.Properties { - if p.Type != opregistry.PackageType { - continue - } - var pp opregistry.PackageProperty - err := json.Unmarshal([]byte(p.Value), &pp) - if err != nil { - r.log.Warnf("failed to unmarshal package property of csv %q: %w", csv.Name, err) - continue - } - op.SourceInfo.Package = pp.PackageName - } - - standaloneOperators = append(standaloneOperators, op) - } - - if len(csvsMissingProperties) > 0 { - names := make([]string, len(csvsMissingProperties)) - for i, csv := range csvsMissingProperties { - names[i] = csv.GetName() - } - r.log.Infof("considered csvs without properties annotation during resolution: %v", names) - } - - return &cache.Snapshot{Entries: standaloneOperators}, nil -} - -func (r *SatResolver) addInvariants(namespacedCache cache.MultiCatalogOperatorFinder, installables map[solver.Identifier]solver.Installable) { +func (r *Resolver) addInvariants(namespacedCache cache.MultiCatalogOperatorFinder, variables map[solver.Identifier]solver.Variable) { // no two operators may provide the same GVK or Package in a namespace - gvkConflictToInstallable := make(map[opregistry.GVKProperty][]solver.Identifier) - packageConflictToInstallable := make(map[string][]solver.Identifier) - for _, installable := range installables { - bundleInstallable, ok := installable.(*BundleInstallable) + gvkConflictToVariable := make(map[opregistry.GVKProperty][]solver.Identifier) + packageConflictToVariable := make(map[string][]solver.Identifier) + for _, variable := range variables { + bundleVariable, ok := variable.(*BundleVariable) if !ok { continue } - csvName, channel, catalog, err := bundleInstallable.BundleSourceInfo() + csvName, channel, catalog, err := bundleVariable.BundleSourceInfo() if err != nil { continue } @@ -558,7 +495,7 @@ func (r *SatResolver) addInvariants(namespacedCache cache.MultiCatalogOperatorFi if err != nil { continue } - gvkConflictToInstallable[prop] = append(gvkConflictToInstallable[prop], installable.Identifier()) + gvkConflictToVariable[prop] = append(gvkConflictToVariable[prop], variable.Identifier()) } // cannot have the same package @@ -571,22 +508,22 @@ func (r *SatResolver) addInvariants(namespacedCache cache.MultiCatalogOperatorFi if err != nil { continue } - packageConflictToInstallable[prop.PackageName] = append(packageConflictToInstallable[prop.PackageName], installable.Identifier()) + packageConflictToVariable[prop.PackageName] = append(packageConflictToVariable[prop.PackageName], variable.Identifier()) } } - for gvk, is := range gvkConflictToInstallable { - s := NewSingleAPIProviderInstallable(gvk.Group, gvk.Version, gvk.Kind, is) - installables[s.Identifier()] = s + for gvk, is := range gvkConflictToVariable { + s := NewSingleAPIProviderVariable(gvk.Group, gvk.Version, gvk.Kind, is) + variables[s.Identifier()] = s } - for pkg, is := range packageConflictToInstallable { - s := NewSinglePackageInstanceInstallable(pkg, is) - installables[s.Identifier()] = s + for pkg, is := range packageConflictToVariable { + s := NewSinglePackageInstanceVariable(pkg, is) + variables[s.Identifier()] = s } } -func (r *SatResolver) sortBundles(bundles []*cache.Entry) ([]*cache.Entry, error) { +func (r *Resolver) sortBundles(bundles []*cache.Entry) ([]*cache.Entry, error) { // assume bundles have been passed in sorted by catalog already catalogOrder := make([]cache.SourceKey, 0) @@ -795,10 +732,8 @@ func (pc *predicateConverter) predicateForConstraintProperty(value string) (cach // convertConstraints creates predicates from each element of constraints, recursing on compound constraints. // New constraint types added to the constraints package must be handled here. func (pc *predicateConverter) convertConstraints(constraints ...constraints.Constraint) ([]cache.Predicate, error) { - preds := make([]cache.Predicate, len(constraints)) for i, constraint := range constraints { - var err error switch { case constraint.GVK != nil: @@ -828,7 +763,6 @@ func (pc *predicateConverter) convertConstraints(constraints ...constraints.Cons if err != nil { return nil, err } - } return preds, nil @@ -885,53 +819,8 @@ func predicateForRequiredLabelProperty(value string) (cache.Predicate, error) { return cache.LabelPredicate(label.Label), nil } -func newOperatorFromV1Alpha1CSV(csv *v1alpha1.ClusterServiceVersion) (*cache.Entry, error) { - providedAPIs := cache.EmptyAPISet() - for _, crdDef := range csv.Spec.CustomResourceDefinitions.Owned { - parts := strings.SplitN(crdDef.Name, ".", 2) - if len(parts) < 2 { - return nil, fmt.Errorf("error parsing crd name: %s", crdDef.Name) - } - providedAPIs[opregistry.APIKey{Plural: parts[0], Group: parts[1], Version: crdDef.Version, Kind: crdDef.Kind}] = struct{}{} - } - for _, api := range csv.Spec.APIServiceDefinitions.Owned { - providedAPIs[opregistry.APIKey{Group: api.Group, Version: api.Version, Kind: api.Kind, Plural: api.Name}] = struct{}{} - } - - requiredAPIs := cache.EmptyAPISet() - for _, crdDef := range csv.Spec.CustomResourceDefinitions.Required { - parts := strings.SplitN(crdDef.Name, ".", 2) - if len(parts) < 2 { - return nil, fmt.Errorf("error parsing crd name: %s", crdDef.Name) - } - requiredAPIs[opregistry.APIKey{Plural: parts[0], Group: parts[1], Version: crdDef.Version, Kind: crdDef.Kind}] = struct{}{} - } - for _, api := range csv.Spec.APIServiceDefinitions.Required { - requiredAPIs[opregistry.APIKey{Group: api.Group, Version: api.Version, Kind: api.Kind, Plural: api.Name}] = struct{}{} - } - - properties, err := providedAPIsToProperties(providedAPIs) - if err != nil { - return nil, err - } - dependencies, err := requiredAPIsToProperties(requiredAPIs) - if err != nil { - return nil, err - } - properties = append(properties, dependencies...) - - return &cache.Entry{ - Name: csv.GetName(), - Version: &csv.Spec.Version.Version, - ProvidedAPIs: providedAPIs, - RequiredAPIs: requiredAPIs, - SourceInfo: &cache.ExistingOperator, - Properties: properties, - }, nil -} - -func providedAPIsToProperties(apis cache.APISet) (out []*api.Property, err error) { - out = make([]*api.Property, 0) +func providedAPIsToProperties(apis cache.APISet) ([]*api.Property, error) { + var out []*api.Property for a := range apis { val, err := json.Marshal(opregistry.GVKProperty{ Group: a.Group, @@ -946,17 +835,14 @@ func providedAPIsToProperties(apis cache.APISet) (out []*api.Property, err error Value: string(val), }) } - if len(out) > 0 { - return - } - return nil, nil + sort.Slice(out, func(i, j int) bool { + return out[i].Value < out[j].Value + }) + return out, nil } -func requiredAPIsToProperties(apis cache.APISet) (out []*api.Property, err error) { - if len(apis) == 0 { - return - } - out = make([]*api.Property, 0) +func requiredAPIsToProperties(apis cache.APISet) ([]*api.Property, error) { + var out []*api.Property for a := range apis { val, err := json.Marshal(struct { Group string `json:"group"` @@ -975,8 +861,8 @@ func requiredAPIsToProperties(apis cache.APISet) (out []*api.Property, err error Value: string(val), }) } - if len(out) > 0 { - return - } - return nil, nil + sort.Slice(out, func(i, j int) bool { + return out[i].Value < out[j].Value + }) + return out, nil } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraints.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraints.go index 785ee409fd..b2b0b7792a 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraints.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraints.go @@ -9,7 +9,7 @@ import ( ) // Constraint implementations limit the circumstances under which a -// particular Installable can appear in a solution. +// particular Variable can appear in a solution. type Constraint interface { String(subject Identifier) string apply(c *logic.C, lm *litMapping, subject Identifier) z.Lit @@ -39,16 +39,16 @@ func (zeroConstraint) anchor() bool { } // AppliedConstraint values compose a single Constraint with the -// Installable it applies to. +// Variable it applies to. type AppliedConstraint struct { - Installable Installable - Constraint Constraint + Variable Variable + Constraint Constraint } // String implements fmt.Stringer and returns a human-readable message // representing the receiver. func (a AppliedConstraint) String() string { - return a.Constraint.String(a.Installable.Identifier()) + return a.Constraint.String(a.Variable.Identifier()) } type mandatory struct{} @@ -70,7 +70,7 @@ func (constraint mandatory) anchor() bool { } // Mandatory returns a Constraint that will permit only solutions that -// contain a particular Installable. +// contain a particular Variable. func Mandatory() Constraint { return mandatory{} } @@ -94,8 +94,8 @@ func (constraint prohibited) anchor() bool { } // Prohibited returns a Constraint that will reject any solution that -// contains a particular Installable. Callers may also decide to omit -// an Installable from input to Solve rather than apply such a +// contains a particular Variable. Callers may also decide to omit +// an Variable from input to Solve rather than apply such a // Constraint. func Prohibited() Constraint { return prohibited{} @@ -131,8 +131,8 @@ func (constraint dependency) anchor() bool { } // Dependency returns a Constraint that will only permit solutions -// containing a given Installable on the condition that at least one -// of the Installables identified by the given Identifiers also +// containing a given Variable on the condition that at least one +// of the Variables identified by the given Identifiers also // appears in the solution. Identifiers appearing earlier in the // argument list have higher preference than those appearing later. func Dependency(ids ...Identifier) Constraint { @@ -158,7 +158,7 @@ func (constraint conflict) anchor() bool { } // Conflict returns a Constraint that will permit solutions containing -// either the constrained Installable, the Installable identified by +// either the constrained Variable, the Variable identified by // the given Identifier, or neither, but not both. func Conflict(id Identifier) Constraint { return conflict(id) @@ -194,7 +194,7 @@ func (constraint leq) anchor() bool { } // AtMost returns a Constraint that forbids solutions that contain -// more than n of the Installables identified by the given +// more than n of the Variables identified by the given // Identifiers. func AtMost(n int, ids ...Identifier) Constraint { return leq{ diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/doc.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/doc.go new file mode 100644 index 0000000000..12f274546c --- /dev/null +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/doc.go @@ -0,0 +1,3 @@ +// Package solver implements a general-purpose solver for boolean +// constraint satisfiability problems. +package solver diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go index dedb5fb8da..eb7a739aca 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go @@ -22,44 +22,43 @@ func (inconsistentLitMapping) Error() string { } // litMapping performs translation between the input and output types of -// Solve (Constraints, Installables, etc.) and the variables that +// Solve (Constraints, Variables, etc.) and the variables that // appear in the SAT formula. type litMapping struct { - inorder []Installable - installables map[z.Lit]Installable - lits map[Identifier]z.Lit - constraints map[z.Lit]AppliedConstraint - c *logic.C - errs inconsistentLitMapping - buf []z.Lit + inorder []Variable + variables map[z.Lit]Variable + lits map[Identifier]z.Lit + constraints map[z.Lit]AppliedConstraint + c *logic.C + errs inconsistentLitMapping } // newLitMapping returns a new litMapping with its state initialized based on -// the provided slice of Installables. This includes construction of -// the translation tables between Installables/Constraints and the +// the provided slice of Variables. This includes construction of +// the translation tables between Variables/Constraints and the // inputs to the underlying solver. -func newLitMapping(installables []Installable) (*litMapping, error) { +func newLitMapping(variables []Variable) (*litMapping, error) { d := litMapping{ - inorder: installables, - installables: make(map[z.Lit]Installable, len(installables)), - lits: make(map[Identifier]z.Lit, len(installables)), - constraints: make(map[z.Lit]AppliedConstraint), - c: logic.NewCCap(len(installables)), + inorder: variables, + variables: make(map[z.Lit]Variable, len(variables)), + lits: make(map[Identifier]z.Lit, len(variables)), + constraints: make(map[z.Lit]AppliedConstraint), + c: logic.NewCCap(len(variables)), } // First pass to assign lits: - for _, installable := range installables { + for _, variable := range variables { im := d.c.Lit() - if _, ok := d.lits[installable.Identifier()]; ok { - return nil, DuplicateIdentifier(installable.Identifier()) + if _, ok := d.lits[variable.Identifier()]; ok { + return nil, DuplicateIdentifier(variable.Identifier()) } - d.lits[installable.Identifier()] = im - d.installables[im] = installable + d.lits[variable.Identifier()] = im + d.variables[im] = variable } - for _, installable := range installables { - for _, constraint := range installable.Constraints() { - m := constraint.apply(d.c, &d, installable.Identifier()) + for _, variable := range variables { + for _, constraint := range variable.Constraints() { + m := constraint.apply(d.c, &d, variable.Identifier()) if m == z.LitNull { // This constraint doesn't have a // useful representation in the SAT @@ -68,8 +67,8 @@ func newLitMapping(installables []Installable) (*litMapping, error) { } d.constraints[m] = AppliedConstraint{ - Installable: installable, - Constraint: constraint, + Variable: variable, + Constraint: constraint, } } } @@ -77,26 +76,26 @@ func newLitMapping(installables []Installable) (*litMapping, error) { return &d, nil } -// LitOf returns the positive literal corresponding to the Installable +// LitOf returns the positive literal corresponding to the Variable // with the given Identifier. func (d *litMapping) LitOf(id Identifier) z.Lit { m, ok := d.lits[id] if ok { return m } - d.errs = append(d.errs, fmt.Errorf("installable %q referenced but not provided", id)) + d.errs = append(d.errs, fmt.Errorf("variable %q referenced but not provided", id)) return z.LitNull } -// InstallableOf returns the Installable corresponding to the provided -// literal, or a zeroInstallable if no such Installable exists. -func (d *litMapping) InstallableOf(m z.Lit) Installable { - i, ok := d.installables[m] +// VariableOf returns the Variable corresponding to the provided +// literal, or a zeroVariable if no such Variable exists. +func (d *litMapping) VariableOf(m z.Lit) Variable { + i, ok := d.variables[m] if ok { return i } - d.errs = append(d.errs, fmt.Errorf("no installable corresponding to %s", m)) - return zeroInstallable{} + d.errs = append(d.errs, fmt.Errorf("no variable corresponding to %s", m)) + return zeroVariable{} } // ConstraintOf returns the constraint application corresponding to @@ -108,8 +107,8 @@ func (d *litMapping) ConstraintOf(m z.Lit) AppliedConstraint { } d.errs = append(d.errs, fmt.Errorf("no constraint corresponding to %s", m)) return AppliedConstraint{ - Installable: zeroInstallable{}, - Constraint: zeroConstraint{}, + Variable: zeroVariable{}, + Constraint: zeroConstraint{}, } } @@ -159,14 +158,14 @@ func (d *litMapping) CardinalityConstrainer(g inter.Adder, ms []z.Lit) *logic.Ca } // AnchorIdentifiers returns a slice containing the Identifiers of -// every Installable with at least one "anchor" constraint, in the +// every Variable with at least one "anchor" constraint, in the // order they appear in the input. func (d *litMapping) AnchorIdentifiers() []Identifier { var ids []Identifier - for _, installable := range d.inorder { - for _, constraint := range installable.Constraints() { + for _, variable := range d.inorder { + for _, constraint := range variable.Constraints() { if constraint.anchor() { - ids = append(ids, installable.Identifier()) + ids = append(ids, variable.Identifier()) break } } @@ -174,8 +173,8 @@ func (d *litMapping) AnchorIdentifiers() []Identifier { return ids } -func (d *litMapping) Installables(g inter.S) []Installable { - var result []Installable +func (d *litMapping) Variables(g inter.S) []Variable { + var result []Variable for _, i := range d.inorder { if g.Value(d.LitOf(i.Identifier())) { result = append(result, i) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go index ed84ea9309..523b311a76 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go @@ -26,8 +26,6 @@ type search struct { assumptions map[z.Lit]struct{} // set of assumed lits - duplicates guess stack - for fast lookup guesses []guess // stack of assumed guesses headChoice, tailChoice *choice // deque of unmade choices - heap []choice - position int tracer Tracer result int buffer []z.Lit @@ -58,8 +56,8 @@ func (h *search) PushGuess() { return } - installable := h.lits.InstallableOf(g.m) - for _, constraint := range installable.Constraints() { + variable := h.lits.VariableOf(g.m) + for _, constraint := range variable.Constraints() { var ms []z.Lit for _, dependency := range constraint.order() { ms = append(ms, h.lits.LitOf(dependency)) @@ -119,8 +117,8 @@ func (h *search) PopChoiceFront() choice { } h.headChoice = c.next return *c - } + func (h *search) PushChoiceBack(c choice) { if h.tailChoice == nil { h.headChoice = &c @@ -204,11 +202,11 @@ func (h *search) Do(ctx context.Context, anchors []z.Lit) (int, []z.Lit, map[z.L return result, lits, set } -func (h *search) Installables() []Installable { - result := make([]Installable, 0, len(h.guesses)) +func (h *search) Variables() []Variable { + result := make([]Variable, 0, len(h.guesses)) for _, g := range h.guesses { if g.m != z.LitNull { - result = append(result, h.lits.InstallableOf(g.candidates[g.index])) + result = append(result, h.lits.VariableOf(g.candidates[g.index])) } } return result diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go index 5d81f459a2..a323f4551b 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go @@ -11,7 +11,7 @@ import ( "github.com/go-air/gini/z" ) -var Incomplete = errors.New("cancelled before a solution could be found") +var ErrIncomplete = errors.New("cancelled before a solution could be found") // NotSatisfiable is an error composed of a minimal set of applied // constraints that is sufficient to make a solution impossible. @@ -30,7 +30,7 @@ func (e NotSatisfiable) Error() string { } type Solver interface { - Solve(context.Context) ([]Installable, error) + Solve(context.Context) ([]Variable, error) } type solver struct { @@ -46,11 +46,11 @@ const ( unknown = 0 ) -// Solve takes a slice containing all Installables and returns a slice -// containing only those Installables that were selected for +// Solve takes a slice containing all Variables and returns a slice +// containing only those Variables that were selected for // installation. If no solution is possible, or if the provided // Context times out or is cancelled, an error is returned. -func (s *solver) Solve(ctx context.Context) (result []Installable, err error) { +func (s *solver) Solve(ctx context.Context) (result []Variable, err error) { defer func() { // This likely indicates a bug, so discard whatever // return values were produced. @@ -63,7 +63,7 @@ func (s *solver) Solve(ctx context.Context) (result []Installable, err error) { // teach all constraints to the solver s.litMap.AddConstraints(s.g) - // collect literals of all mandatory installables to assume as a baseline + // collect literals of all mandatory variables to assume as a baseline var assumptions []z.Lit for _, anchor := range s.litMap.AnchorIdentifiers() { assumptions = append(assumptions, s.litMap.LitOf(anchor)) @@ -104,7 +104,7 @@ func (s *solver) Solve(ctx context.Context) (result []Installable, err error) { for w := 0; w <= cs.N(); w++ { s.g.Assume(cs.Leq(w)) if s.g.Solve() == satisfiable { - return s.litMap.Installables(s.g), nil + return s.litMap.Variables(s.g), nil } } // Something is wrong if we can't find a model anymore @@ -114,7 +114,7 @@ func (s *solver) Solve(ctx context.Context) (result []Installable, err error) { return nil, NotSatisfiable(s.litMap.Conflicts(s.g)) } - return nil, Incomplete + return nil, ErrIncomplete } func New(options ...Option) (Solver, error) { @@ -129,7 +129,7 @@ func New(options ...Option) (Solver, error) { type Option func(s *solver) error -func WithInput(input []Installable) Option { +func WithInput(input []Variable) Option { return func(s *solver) error { var err error s.litMap, err = newLitMapping(input) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/tracer.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/tracer.go index 37f2c3f4fc..b103536add 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/tracer.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/tracer.go @@ -6,7 +6,7 @@ import ( ) type SearchPosition interface { - Installables() []Installable + Variables() []Variable Conflicts() []AppliedConstraint } @@ -25,7 +25,7 @@ type LoggingTracer struct { func (t LoggingTracer) Trace(p SearchPosition) { fmt.Fprintf(t.Writer, "---\nAssumptions:\n") - for _, i := range p.Installables() { + for _, i := range p.Variables() { fmt.Fprintf(t.Writer, "- %s\n", i.Identifier()) } fmt.Fprintf(t.Writer, "Conflicts:\n") diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/installable.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/variable.go similarity index 53% rename from vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/installable.go rename to vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/variable.go index 8382ca0733..32afab7592 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/installable.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/variable.go @@ -1,6 +1,6 @@ package solver -// Identifier values uniquely identify particular Installables within +// Identifier values uniquely identify particular Variables within // the input to a single call to Solve. type Identifier string @@ -14,27 +14,27 @@ func IdentifierFromString(s string) Identifier { return Identifier(s) } -// Installable values are the basic unit of problems and solutions +// Variable values are the basic unit of problems and solutions // understood by this package. -type Installable interface { +type Variable interface { // Identifier returns the Identifier that uniquely identifies - // this Installable among all other Installables in a given + // this Variable among all other Variables in a given // problem. Identifier() Identifier // Constraints returns the set of constraints that apply to - // this Installable. + // this Variable. Constraints() []Constraint } -// zeroInstallable is returned by InstallableOf in error cases. -type zeroInstallable struct{} +// zeroVariable is returned by VariableOf in error cases. +type zeroVariable struct{} -var _ Installable = zeroInstallable{} +var _ Variable = zeroVariable{} -func (zeroInstallable) Identifier() Identifier { +func (zeroVariable) Identifier() Identifier { return "" } -func (zeroInstallable) Constraints() []Constraint { +func (zeroVariable) Constraints() []Constraint { return nil } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/source_csvs.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/source_csvs.go new file mode 100644 index 0000000000..d62228f2a7 --- /dev/null +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/source_csvs.go @@ -0,0 +1,217 @@ +package resolver + +import ( + "context" + "encoding/json" + "fmt" + "strings" + + "github.com/blang/semver/v4" + "github.com/operator-framework/api/pkg/operators/v1alpha1" + v1alpha1listers "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1" + "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache" + "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/projection" + "github.com/operator-framework/operator-registry/pkg/api" + opregistry "github.com/operator-framework/operator-registry/pkg/registry" + "github.com/sirupsen/logrus" + "k8s.io/apimachinery/pkg/labels" +) + +type csvSourceProvider struct { + csvLister v1alpha1listers.ClusterServiceVersionLister + subLister v1alpha1listers.SubscriptionLister + logger logrus.StdLogger +} + +func (csp *csvSourceProvider) Sources(namespaces ...string) map[cache.SourceKey]cache.Source { + result := make(map[cache.SourceKey]cache.Source) + for _, namespace := range namespaces { + result[cache.NewVirtualSourceKey(namespace)] = &csvSource{ + key: cache.NewVirtualSourceKey(namespace), + csvLister: csp.csvLister.ClusterServiceVersions(namespace), + subLister: csp.subLister.Subscriptions(namespace), + logger: csp.logger, + } + break // first ns is assumed to be the target ns, todo: make explicit + } + return result +} + +type csvSource struct { + key cache.SourceKey + csvLister v1alpha1listers.ClusterServiceVersionNamespaceLister + subLister v1alpha1listers.SubscriptionNamespaceLister + logger logrus.StdLogger +} + +func (s *csvSource) Snapshot(ctx context.Context) (*cache.Snapshot, error) { + csvs, err := s.csvLister.List(labels.Everything()) + if err != nil { + return nil, err + } + + subs, err := s.subLister.List(labels.Everything()) + if err != nil { + return nil, err + } + + // build a catalog snapshot of CSVs without subscriptions + csvSubscriptions := make(map[*v1alpha1.ClusterServiceVersion]*v1alpha1.Subscription) + for _, sub := range subs { + for _, csv := range csvs { + if csv.IsCopied() { + continue + } + if csv.Name == sub.Status.InstalledCSV { + csvSubscriptions[csv] = sub + break + } + } + } + + var csvsMissingProperties []*v1alpha1.ClusterServiceVersion + var entries []*cache.Entry + for _, csv := range csvs { + if csv.IsCopied() { + continue + } + entry, err := newEntryFromV1Alpha1CSV(csv) + if err != nil { + return nil, err + } + entry.SourceInfo = &cache.OperatorSourceInfo{ + Catalog: s.key, + Subscription: csvSubscriptions[csv], + } + + entries = append(entries, entry) + + if anno, ok := csv.GetAnnotations()[projection.PropertiesAnnotationKey]; !ok { + csvsMissingProperties = append(csvsMissingProperties, csv) + if inferred, err := s.inferProperties(csv, subs); err != nil { + s.logger.Printf("unable to infer properties for csv %q: %w", csv.Name, err) + } else { + entry.Properties = append(entry.Properties, inferred...) + } + } else if props, err := projection.PropertyListFromPropertiesAnnotation(anno); err != nil { + return nil, fmt.Errorf("failed to retrieve properties of csv %q: %w", csv.GetName(), err) + } else { + entry.Properties = props + } + + // Try to determine source package name from properties and add to SourceInfo. + for _, p := range entry.Properties { + if p.Type != opregistry.PackageType { + continue + } + var pp opregistry.PackageProperty + err := json.Unmarshal([]byte(p.Value), &pp) + if err != nil { + s.logger.Printf("failed to unmarshal package property of csv %q: %w", csv.Name, err) + continue + } + entry.SourceInfo.Package = pp.PackageName + } + } + + if len(csvsMissingProperties) > 0 { + names := make([]string, len(csvsMissingProperties)) + for i, csv := range csvsMissingProperties { + names[i] = csv.GetName() + } + s.logger.Printf("considered csvs without properties annotation during resolution: %v", names) + } + + return &cache.Snapshot{ + Entries: entries, + Valid: cache.ValidOnce(), + }, nil +} + +func (s *csvSource) inferProperties(csv *v1alpha1.ClusterServiceVersion, subs []*v1alpha1.Subscription) ([]*api.Property, error) { + var properties []*api.Property + + packages := make(map[string]struct{}) + for _, sub := range subs { + if sub.Status.InstalledCSV != csv.Name { + continue + } + if pkg := sub.Spec.Package; pkg != "" { + packages[pkg] = struct{}{} + } + // An erroneous package inference is possible if a user edits spec.package in a + // Subscription that already references a ClusterServiceVersion via + // status.installedCSV, but all recent versions of the catalog operator project + // properties onto all ClusterServiceVersions they create. + } + if l := len(packages); l != 1 { + s.logger.Printf("could not unambiguously infer package name for %q (found %d distinct package names)", csv.Name, l) + return properties, nil + } + var pkg string + for pkg = range packages { + // Assign the single key to pkg. + } + var version string // Emit empty string rather than "0.0.0" if .spec.version is zero-valued. + if !csv.Spec.Version.Version.Equals(semver.Version{}) { + version = csv.Spec.Version.String() + } + pp, err := json.Marshal(opregistry.PackageProperty{ + PackageName: pkg, + Version: version, + }) + if err != nil { + return nil, fmt.Errorf("failed to marshal inferred package property: %w", err) + } + properties = append(properties, &api.Property{ + Type: opregistry.PackageType, + Value: string(pp), + }) + + return properties, nil +} + +func newEntryFromV1Alpha1CSV(csv *v1alpha1.ClusterServiceVersion) (*cache.Entry, error) { + providedAPIs := cache.EmptyAPISet() + for _, crdDef := range csv.Spec.CustomResourceDefinitions.Owned { + parts := strings.SplitN(crdDef.Name, ".", 2) + if len(parts) < 2 { + return nil, fmt.Errorf("error parsing crd name: %s", crdDef.Name) + } + providedAPIs[opregistry.APIKey{Plural: parts[0], Group: parts[1], Version: crdDef.Version, Kind: crdDef.Kind}] = struct{}{} + } + for _, api := range csv.Spec.APIServiceDefinitions.Owned { + providedAPIs[opregistry.APIKey{Group: api.Group, Version: api.Version, Kind: api.Kind, Plural: api.Name}] = struct{}{} + } + + requiredAPIs := cache.EmptyAPISet() + for _, crdDef := range csv.Spec.CustomResourceDefinitions.Required { + parts := strings.SplitN(crdDef.Name, ".", 2) + if len(parts) < 2 { + return nil, fmt.Errorf("error parsing crd name: %s", crdDef.Name) + } + requiredAPIs[opregistry.APIKey{Plural: parts[0], Group: parts[1], Version: crdDef.Version, Kind: crdDef.Kind}] = struct{}{} + } + for _, api := range csv.Spec.APIServiceDefinitions.Required { + requiredAPIs[opregistry.APIKey{Group: api.Group, Version: api.Version, Kind: api.Kind, Plural: api.Name}] = struct{}{} + } + + properties, err := providedAPIsToProperties(providedAPIs) + if err != nil { + return nil, err + } + dependencies, err := requiredAPIsToProperties(requiredAPIs) + if err != nil { + return nil, err + } + properties = append(properties, dependencies...) + + return &cache.Entry{ + Name: csv.GetName(), + Version: &csv.Spec.Version.Version, + ProvidedAPIs: providedAPIs, + RequiredAPIs: requiredAPIs, + SourceInfo: &cache.OperatorSourceInfo{}, + Properties: properties, + }, nil +} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/source_registry.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/source_registry.go index 143e5a1956..ab3550a937 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/source_registry.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/source_registry.go @@ -4,6 +4,8 @@ import ( "context" "encoding/json" "fmt" + "sync" + "time" "github.com/blang/semver/v4" "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry" @@ -14,26 +16,93 @@ import ( "github.com/sirupsen/logrus" ) +// todo: move to pkg/controller/operators/catalog + type RegistryClientProvider interface { ClientsForNamespaces(namespaces ...string) map[registry.CatalogKey]client.Interface } -type registryClientAdapter struct { - rcp RegistryClientProvider - logger logrus.StdLogger +type sourceInvalidator struct { + m sync.Mutex + validChans map[cache.SourceKey]chan struct{} + ttl time.Duration // auto-invalidate after this ttl } -func SourceProviderFromRegistryClientProvider(rcp RegistryClientProvider, logger logrus.StdLogger) cache.SourceProvider { - return ®istryClientAdapter{ +func (i *sourceInvalidator) Invalidate(key cache.SourceKey) { + i.m.Lock() + defer i.m.Unlock() + if c, ok := i.validChans[key]; ok { + close(c) + delete(i.validChans, key) + } +} + +func (i *sourceInvalidator) GetValidChannel(key cache.SourceKey) <-chan struct{} { + i.m.Lock() + defer i.m.Unlock() + + if c, ok := i.validChans[key]; ok { + return c + } + c := make(chan struct{}) + i.validChans[key] = c + + go func() { + <-time.After(i.ttl) + + // be careful to avoid closing c (and panicking) after + // it has already been invalidated via Invalidate + i.m.Lock() + defer i.m.Unlock() + + if saved := i.validChans[key]; saved == c { + close(c) + delete(i.validChans, key) + } + }() + + return c +} + +type RegistrySourceProvider struct { + rcp RegistryClientProvider + logger logrus.StdLogger + invalidator *sourceInvalidator +} + +func SourceProviderFromRegistryClientProvider(rcp RegistryClientProvider, logger logrus.StdLogger) *RegistrySourceProvider { + return &RegistrySourceProvider{ rcp: rcp, logger: logger, + invalidator: &sourceInvalidator{ + validChans: make(map[cache.SourceKey]chan struct{}), + ttl: 5 * time.Minute, + }, } } +func (a *RegistrySourceProvider) Sources(namespaces ...string) map[cache.SourceKey]cache.Source { + result := make(map[cache.SourceKey]cache.Source) + for key, client := range a.rcp.ClientsForNamespaces(namespaces...) { + result[cache.SourceKey(key)] = ®istrySource{ + key: cache.SourceKey(key), + client: client, + logger: a.logger, + invalidator: a.invalidator, + } + } + return result +} + +func (a *RegistrySourceProvider) Invalidate(key cache.SourceKey) { + a.invalidator.Invalidate(key) +} + type registrySource struct { - key cache.SourceKey - client client.Interface - logger logrus.StdLogger + key cache.SourceKey + client client.Interface + logger logrus.StdLogger + invalidator *sourceInvalidator } func (s *registrySource) Snapshot(ctx context.Context) (*cache.Snapshot, error) { @@ -74,19 +143,10 @@ func (s *registrySource) Snapshot(ctx context.Context) (*cache.Snapshot, error) return nil, fmt.Errorf("error encountered while listing bundles: %w", err) } - return &cache.Snapshot{Entries: operators}, nil -} - -func (a *registryClientAdapter) Sources(namespaces ...string) map[cache.SourceKey]cache.Source { - result := make(map[cache.SourceKey]cache.Source) - for key, client := range a.rcp.ClientsForNamespaces(namespaces...) { - result[cache.SourceKey(key)] = ®istrySource{ - key: cache.SourceKey(key), - client: client, - logger: a.logger, - } - } - return result + return &cache.Snapshot{ + Entries: operators, + Valid: s.invalidator.GetValidChannel(s.key), + }, nil } func EnsurePackageProperty(o *cache.Entry, name, version string) { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go index 079b928065..aedaaa49db 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go @@ -4,14 +4,11 @@ package resolver import ( "context" "fmt" - "time" "github.com/sirupsen/logrus" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/labels" - "k8s.io/client-go/kubernetes" "github.com/operator-framework/api/pkg/operators/v1alpha1" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned" @@ -26,68 +23,75 @@ const ( BundleLookupConditionPacked v1alpha1.BundleLookupConditionType = "BundleLookupNotPersisted" ) -var timeNow = func() metav1.Time { return metav1.NewTime(time.Now().UTC()) } +// init hooks provides the downstream a way to modify the upstream behavior +var initHooks []stepResolverInitHook type StepResolver interface { ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) - Expire(key cache.SourceKey) } type OperatorStepResolver struct { subLister v1alpha1listers.SubscriptionLister csvLister v1alpha1listers.ClusterServiceVersionLister - ipLister v1alpha1listers.InstallPlanLister client versioned.Interface - kubeclient kubernetes.Interface globalCatalogNamespace string - satResolver *SatResolver + resolver *Resolver log logrus.FieldLogger } var _ StepResolver = &OperatorStepResolver{} -func NewOperatorStepResolver(lister operatorlister.OperatorLister, client versioned.Interface, kubeclient kubernetes.Interface, - globalCatalogNamespace string, provider RegistryClientProvider, log logrus.FieldLogger) *OperatorStepResolver { - return &OperatorStepResolver{ +type catsrcPriorityProvider struct { + lister v1alpha1listers.CatalogSourceLister +} + +func (pp catsrcPriorityProvider) Priority(key cache.SourceKey) int { + catsrc, err := pp.lister.CatalogSources(key.Namespace).Get(key.Name) + if err != nil { + return 0 + } + return catsrc.Spec.Priority +} + +func NewOperatorStepResolver(lister operatorlister.OperatorLister, client versioned.Interface, globalCatalogNamespace string, sourceProvider cache.SourceProvider, log logrus.FieldLogger) *OperatorStepResolver { + cacheSourceProvider := &mergedSourceProvider{ + sps: []cache.SourceProvider{ + sourceProvider, + //SourceProviderFromRegistryClientProvider(provider, log), + &csvSourceProvider{ + csvLister: lister.OperatorsV1alpha1().ClusterServiceVersionLister(), + subLister: lister.OperatorsV1alpha1().SubscriptionLister(), + logger: log, + }, + }, + } + stepResolver := &OperatorStepResolver{ subLister: lister.OperatorsV1alpha1().SubscriptionLister(), csvLister: lister.OperatorsV1alpha1().ClusterServiceVersionLister(), - ipLister: lister.OperatorsV1alpha1().InstallPlanLister(), client: client, - kubeclient: kubeclient, globalCatalogNamespace: globalCatalogNamespace, - satResolver: NewDefaultSatResolver(SourceProviderFromRegistryClientProvider(provider, log), lister.OperatorsV1alpha1().CatalogSourceLister(), log), + resolver: NewDefaultResolver(cacheSourceProvider, catsrcPriorityProvider{lister: lister.OperatorsV1alpha1().CatalogSourceLister()}, log), log: log, } -} - -func (r *OperatorStepResolver) Expire(key cache.SourceKey) { - r.satResolver.cache.Expire(key) -} -func (r *OperatorStepResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) { - // create a generation - a representation of the current set of installed operators and their provided/required apis - allCSVs, err := r.csvLister.ClusterServiceVersions(namespace).List(labels.Everything()) - if err != nil { - return nil, nil, nil, err - } - - // TODO: build this index ahead of time - // omit copied csvs from generation - they indicate that apis are provided to the namespace, not by the namespace - var csvs []*v1alpha1.ClusterServiceVersion - for i := range allCSVs { - if !allCSVs[i].IsCopied() { - csvs = append(csvs, allCSVs[i]) + // init hooks can be added to the downstream to + // modify resolver behaviour + for _, initHook := range initHooks { + if err := initHook(stepResolver); err != nil { + panic(err) } } + return stepResolver +} +func (r *OperatorStepResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) { subs, err := r.listSubscriptions(namespace) if err != nil { return nil, nil, nil, err } - var operators cache.OperatorSet namespaces := []string{namespace, r.globalCatalogNamespace} - operators, err = r.satResolver.SolveOperators(namespaces, csvs, subs) + operators, err := r.resolver.Resolve(namespaces, subs) if err != nil { return nil, nil, nil, err } @@ -97,7 +101,7 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step, steps := []*v1alpha1.Step{} updatedSubs := []*v1alpha1.Subscription{} bundleLookups := []v1alpha1.BundleLookup{} - for name, op := range operators { + for _, op := range operators { // Find any existing subscriptions that resolve to this operator. existingSubscriptions := make(map[*v1alpha1.Subscription]bool) sourceInfo := *op.SourceInfo @@ -166,11 +170,11 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step, }, }, } - if anno, err := projection.PropertiesAnnotationFromPropertyList(op.Properties); err != nil { + anno, err := projection.PropertiesAnnotationFromPropertyList(op.Properties) + if err != nil { return nil, nil, nil, fmt.Errorf("failed to serialize operator properties for %q: %w", op.Name, err) - } else { - lookup.Properties = anno } + lookup.Properties = anno bundleLookups = append(bundleLookups, lookup) } @@ -182,7 +186,7 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step, return nil, nil, nil, err } steps = append(steps, &v1alpha1.Step{ - Resolving: name, + Resolving: op.Name, Resource: subStep, Status: v1alpha1.StepStatusUnknown, }) @@ -231,3 +235,21 @@ func (r *OperatorStepResolver) listSubscriptions(namespace string) ([]*v1alpha1. return subs, nil } + +type mergedSourceProvider struct { + sps []cache.SourceProvider + logger logrus.StdLogger +} + +func (msp *mergedSourceProvider) Sources(namespaces ...string) map[cache.SourceKey]cache.Source { + result := make(map[cache.SourceKey]cache.Source) + for _, sp := range msp.sps { + for key, source := range sp.Sources(namespaces...) { + if _, ok := result[key]; ok { + msp.logger.Printf("warning: duplicate sourcekey: %q\n", key) + } + result[key] = source + } + } + return result +} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go index 7f2270881b..7860c7108a 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go @@ -120,17 +120,18 @@ func NewStepResourceFromBundle(bundle *api.Bundle, namespace, replaces, catalogS csv.SetNamespace(namespace) csv.Spec.Replaces = replaces - if anno, err := projection.PropertiesAnnotationFromPropertyList(bundle.Properties); err != nil { + anno, err := projection.PropertiesAnnotationFromPropertyList(bundle.Properties) + if err != nil { return nil, fmt.Errorf("failed to construct properties annotation for %q: %w", csv.GetName(), err) - } else { - annos := csv.GetAnnotations() - if annos == nil { - annos = make(map[string]string) - } - annos[projection.PropertiesAnnotationKey] = anno - csv.SetAnnotations(annos) } + annos := csv.GetAnnotations() + if annos == nil { + annos = make(map[string]string) + } + annos[projection.PropertiesAnnotationKey] = anno + csv.SetAnnotations(annos) + step, err := NewStepResourceFromObject(csv, catalogSourceName, catalogSourceNamespace) if err != nil { return nil, err diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/variable_types.go similarity index 75% rename from vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go rename to vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/variable_types.go index 580e3c7a32..108a0de84f 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/variable_types.go @@ -9,38 +9,38 @@ import ( operatorregistry "github.com/operator-framework/operator-registry/pkg/registry" ) -type BundleInstallable struct { +type BundleVariable struct { identifier solver.Identifier constraints []solver.Constraint Replaces string } -func (i BundleInstallable) Identifier() solver.Identifier { +func (i BundleVariable) Identifier() solver.Identifier { return i.identifier } -func (i BundleInstallable) Constraints() []solver.Constraint { +func (i BundleVariable) Constraints() []solver.Constraint { return i.constraints } -func (i *BundleInstallable) MakeProhibited() { +func (i *BundleVariable) MakeProhibited() { i.constraints = append(i.constraints, solver.Prohibited()) } -func (i *BundleInstallable) AddConflict(id solver.Identifier) { +func (i *BundleVariable) AddConflict(id solver.Identifier) { i.constraints = append(i.constraints, solver.Conflict(id)) } -func (i *BundleInstallable) AddConstraint(c solver.Constraint) { +func (i *BundleVariable) AddConstraint(c solver.Constraint) { i.constraints = append(i.constraints, c) } -func (i *BundleInstallable) BundleSourceInfo() (string, string, cache.SourceKey, error) { +func (i *BundleVariable) BundleSourceInfo() (string, string, cache.SourceKey, error) { info := strings.Split(i.identifier.String(), "/") // This should be enforced by Kube naming constraints if len(info) != 4 { - return "", "", cache.SourceKey{}, fmt.Errorf("Unable to parse identifier %s for source info", i.identifier) + return "", "", cache.SourceKey{}, fmt.Errorf("unable to parse identifier %s for source info", i.identifier) } catalog := cache.SourceKey{ Name: info[0], @@ -51,15 +51,15 @@ func (i *BundleInstallable) BundleSourceInfo() (string, string, cache.SourceKey, return csvName, channel, catalog, nil } -func bundleId(bundle, channel string, catalog cache.SourceKey) solver.Identifier { +func bundleID(bundle, channel string, catalog cache.SourceKey) solver.Identifier { return solver.IdentifierFromString(fmt.Sprintf("%s/%s/%s", catalog.String(), channel, bundle)) } -func NewBundleInstallableFromOperator(o *cache.Entry) (BundleInstallable, error) { +func NewBundleVariableFromOperator(o *cache.Entry) (BundleVariable, error) { if o.SourceInfo == nil { - return BundleInstallable{}, fmt.Errorf("unable to resolve the source of bundle %s", o.Name) + return BundleVariable{}, fmt.Errorf("unable to resolve the source of bundle %s", o.Name) } - id := bundleId(o.Name, o.Channel(), o.SourceInfo.Catalog) + id := bundleID(o.Name, o.Channel(), o.SourceInfo.Catalog) var constraints []solver.Constraint if o.SourceInfo.Catalog.Virtual() && o.SourceInfo.Subscription == nil { // CSVs already associated with a Subscription @@ -79,27 +79,27 @@ func NewBundleInstallableFromOperator(o *cache.Entry) (BundleInstallable, error) break } } - return BundleInstallable{ + return BundleVariable{ identifier: id, constraints: constraints, }, nil } -type GenericInstallable struct { +type GenericVariable struct { identifier solver.Identifier constraints []solver.Constraint } -func (i GenericInstallable) Identifier() solver.Identifier { +func (i GenericVariable) Identifier() solver.Identifier { return i.identifier } -func (i GenericInstallable) Constraints() []solver.Constraint { +func (i GenericVariable) Constraints() []solver.Constraint { return i.constraints } -func NewInvalidSubscriptionInstallable(name string, reason string) solver.Installable { - return GenericInstallable{ +func NewInvalidSubscriptionVariable(name string, reason string) solver.Variable { + return GenericVariable{ identifier: solver.IdentifierFromString(fmt.Sprintf("subscription:%s", name)), constraints: []solver.Constraint{ PrettyConstraint(solver.Mandatory(), fmt.Sprintf("subscription %s exists", name)), @@ -108,8 +108,8 @@ func NewInvalidSubscriptionInstallable(name string, reason string) solver.Instal } } -func NewSubscriptionInstallable(name string, dependencies []solver.Identifier) solver.Installable { - result := GenericInstallable{ +func NewSubscriptionVariable(name string, dependencies []solver.Identifier) solver.Variable { + result := GenericVariable{ identifier: solver.IdentifierFromString(fmt.Sprintf("subscription:%s", name)), constraints: []solver.Constraint{ PrettyConstraint(solver.Mandatory(), fmt.Sprintf("subscription %s exists", name)), @@ -136,9 +136,9 @@ func NewSubscriptionInstallable(name string, dependencies []solver.Identifier) s return result } -func NewSingleAPIProviderInstallable(group, version, kind string, providers []solver.Identifier) solver.Installable { +func NewSingleAPIProviderVariable(group, version, kind string, providers []solver.Identifier) solver.Variable { gvk := fmt.Sprintf("%s (%s/%s)", kind, group, version) - result := GenericInstallable{ + result := GenericVariable{ identifier: solver.IdentifierFromString(gvk), } if len(providers) <= 1 { @@ -157,8 +157,8 @@ func NewSingleAPIProviderInstallable(group, version, kind string, providers []so return result } -func NewSinglePackageInstanceInstallable(pkg string, providers []solver.Identifier) solver.Installable { - result := GenericInstallable{ +func NewSinglePackageInstanceVariable(pkg string, providers []solver.Identifier) solver.Variable { + result := GenericVariable{ identifier: solver.IdentifierFromString(pkg), } if len(providers) <= 1 { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/csv/replace_finder.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/csv/replace_finder.go index 352db051c0..0fc4610ce0 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/csv/replace_finder.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/csv/replace_finder.go @@ -41,7 +41,7 @@ func (r *replace) IsBeingReplaced(in *v1alpha1.ClusterServiceVersion, csvsInName continue } - r.logger.Infof("checking %s", csv.GetName()) + r.logger.Debugf("checking %s", csv.GetName()) if csv.Spec.Replaces == in.GetName() { r.logger.Infof("%s replaced by %s", in.GetName(), csv.GetName()) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorstatus/status.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorstatus/status.go index cdfae9b7f3..003cb97e8e 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorstatus/status.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorstatus/status.go @@ -10,7 +10,7 @@ import ( configv1 "github.com/openshift/api/config/v1" configv1client "github.com/openshift/client-go/config/clientset/versioned/typed/config/v1" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned" - log "github.com/sirupsen/logrus" + "github.com/sirupsen/logrus" corev1 "k8s.io/api/core/v1" k8serrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -33,7 +33,8 @@ const ( installPlanResource = "installplans" ) -func MonitorClusterStatus(name string, syncCh <-chan error, stopCh <-chan struct{}, opClient operatorclient.ClientInterface, configClient configv1client.ConfigV1Interface, crClient versioned.Interface) { +func MonitorClusterStatus(name string, syncCh <-chan error, stopCh <-chan struct{}, opClient operatorclient.ClientInterface, + configClient configv1client.ConfigV1Interface, crClient versioned.Interface, log *logrus.Logger) { var ( syncs int successfulSyncs int @@ -123,7 +124,7 @@ func MonitorClusterStatus(name string, syncCh <-chan error, stopCh <-chan struct log.Errorf("Failed to create cluster operator: %v\n", createErr) return } - created.Status.RelatedObjects, err = relatedObjects(name, opClient, crClient) + created.Status.RelatedObjects, err = relatedObjects(name, opClient, crClient, log) if err != nil { log.Errorf("Failed to get related objects: %v", err) } @@ -208,7 +209,7 @@ func MonitorClusterStatus(name string, syncCh <-chan error, stopCh <-chan struct } // always update the related objects in case changes have occurred - existing.Status.RelatedObjects, err = relatedObjects(name, opClient, crClient) + existing.Status.RelatedObjects, err = relatedObjects(name, opClient, crClient, log) if err != nil { log.Errorf("Failed to get related objects: %v", err) } @@ -265,9 +266,9 @@ func findOperatorStatusCondition(conditions []configv1.ClusterOperatorStatusCond // relatedObjects returns RelatedObjects in the ClusterOperator.Status. // RelatedObjects are consumed by https://github.com/openshift/must-gather -func relatedObjects(name string, opClient operatorclient.ClientInterface, crClient versioned.Interface) ([]configv1.ObjectReference, error) { +func relatedObjects(name string, opClient operatorclient.ClientInterface, crClient versioned.Interface, log *logrus.Logger) ([]configv1.ObjectReference, error) { var objectReferences []configv1.ObjectReference - log.Infof("Adding related objects for %v", name) + log.Debugf("Adding related objects for %v", name) namespace := openshiftNamespace // hard-coded to constant switch name { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/experimental_declarations.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/experimental_declarations.go new file mode 100644 index 0000000000..30615c7ab6 --- /dev/null +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/experimental_declarations.go @@ -0,0 +1,42 @@ +package metrics + +import "github.com/prometheus/client_golang/prometheus" + +const ( + // Controller names + operatorController = "operator" + adoptionCSVController = "adoption_csv" + adoptionSubscriptionController = "adoption_subscription" + operatorConditionController = "operator_condition" + operatorConditionGeneratorController = "operator_condition_generator" +) + +var ( + reconcileMetrics = map[string]*prometheus.CounterVec{} +) + +func EmitOperatorReconcile(namespace, name string) { + emitReconcile(operatorController, namespace, name) +} + +func EmitAdoptionCSVReconcile(namespace, name string) { + emitReconcile(adoptionCSVController, namespace, name) +} + +func EmitAdoptionSubscriptionReconcile(namespace, name string) { + emitReconcile(adoptionSubscriptionController, namespace, name) +} + +func EmitOperatorConditionReconcile(namespace, name string) { + emitReconcile(operatorConditionController, namespace, name) +} + +func EmitOperatorConditionGeneratorReconcile(namespace, name string) { + emitReconcile(operatorConditionGeneratorController, namespace, name) +} + +func emitReconcile(controllerName, namespace, name string) { + if counter, ok := reconcileMetrics[controllerName]; ok { + counter.WithLabelValues(namespace, name).Inc() + } +} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/experimental_register.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/experimental_register.go new file mode 100644 index 0000000000..87d0e9bfee --- /dev/null +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/experimental_register.go @@ -0,0 +1,41 @@ +//go:build experimental_metrics +// +build experimental_metrics + +package metrics + +import ( + "fmt" + "strings" + + "github.com/prometheus/client_golang/prometheus" +) + +func init() { + // Register experimental metrics + reconcileMetrics = reconcileCounters(operatorController, adoptionCSVController, adoptionSubscriptionController, operatorConditionController, operatorConditionGeneratorController) + registerReconcileMetrics() +} + +func reconcileCounters(reconcilerNames ...string) map[string]*prometheus.CounterVec { + result := map[string]*prometheus.CounterVec{} + for _, s := range reconcilerNames { + result[s] = createReconcileCounterVec(s) + } + return result +} + +func createReconcileCounterVec(name string) *prometheus.CounterVec { + return prometheus.NewCounterVec( + prometheus.CounterOpts{ + Name: "controller_reconcile_" + name, + Help: fmt.Sprintf("Count of reconcile events by the %s controller", strings.Replace(name, "_", " ", -1)), + }, + []string{NamespaceLabel, NameLabel}, + ) +} + +func registerReconcileMetrics() { + for _, v := range reconcileMetrics { + prometheus.MustRegister(v) + } +} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/metrics.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/metrics.go index ec1a188846..bbb17b00b0 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/metrics.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/metrics.go @@ -13,20 +13,20 @@ import ( ) const ( - NAME_LABEL = "name" - INSTALLED_LABEL = "installed" - NAMESPACE_LABEL = "namespace" - CHANNEL_LABEL = "channel" - VERSION_LABEL = "version" - PHASE_LABEL = "phase" - REASON_LABEL = "reason" - PACKAGE_LABEL = "package" - Outcome = "outcome" - Succeeded = "succeeded" - Failed = "failed" - APPROVAL_LABEL = "approval" - WARNING_LABEL = "warning" - GVK_LABEL = "gvk" + NameLabel = "name" + InstalledLabel = "installed" + NamespaceLabel = "namespace" + ChannelLabel = "channel" + VersionLabel = "version" + PhaseLabel = "phase" + ReasonLabel = "reason" + PackageLabel = "package" + Outcome = "outcome" + Succeeded = "succeeded" + Failed = "failed" + ApprovalLabel = "approval" + WarningLabel = "warning" + GVKLabel = "gvk" ) type MetricsProvider interface { @@ -90,7 +90,6 @@ type metricsCatalogSource struct { func NewMetricsCatalogSource(lister v1alpha1.CatalogSourceLister) MetricsProvider { return &metricsCatalogSource{lister} - } func (m *metricsCatalogSource) HandleMetrics() error { @@ -149,7 +148,7 @@ var ( Name: "catalogsource_ready", Help: "State of a CatalogSource. 1 indicates that the CatalogSource is in a READY state. 0 indicates CatalogSource is in a Non READY state.", }, - []string{NAMESPACE_LABEL, NAME_LABEL}, + []string{NamespaceLabel, NameLabel}, ) // exported since it's not handled by HandleMetrics @@ -165,7 +164,7 @@ var ( Name: "subscription_sync_total", Help: "Monotonic count of subscription syncs", }, - []string{NAME_LABEL, INSTALLED_LABEL, CHANNEL_LABEL, PACKAGE_LABEL, APPROVAL_LABEL}, + []string{NameLabel, InstalledLabel, ChannelLabel, PackageLabel, ApprovalLabel}, ) csvSucceeded = prometheus.NewGaugeVec( @@ -173,7 +172,7 @@ var ( Name: "csv_succeeded", Help: "Successful CSV install", }, - []string{NAMESPACE_LABEL, NAME_LABEL, VERSION_LABEL}, + []string{NamespaceLabel, NameLabel, VersionLabel}, ) csvAbnormal = prometheus.NewGaugeVec( @@ -181,7 +180,7 @@ var ( Name: "csv_abnormal", Help: "CSV is not installed", }, - []string{NAMESPACE_LABEL, NAME_LABEL, VERSION_LABEL, PHASE_LABEL, REASON_LABEL}, + []string{NamespaceLabel, NameLabel, VersionLabel, PhaseLabel, ReasonLabel}, ) dependencyResolutionSummary = prometheus.NewSummaryVec( @@ -200,7 +199,7 @@ var ( }, ) - // subscriptionSyncCounters keeps a record of the promethues counters emitted by + // subscriptionSyncCounters keeps a record of the Prometheus counters emitted by // Subscription objects. The key of a record is the Subscription name, while the value // is struct containing label values used in the counter subscriptionSyncCounters = make(map[string]subscriptionSyncLabelValues) @@ -310,7 +309,6 @@ func UpdateSubsSyncCounterStorage(sub *olmv1alpha1.Subscription) { sub.Spec.Package != counterValues.pkg || sub.Status.InstalledCSV != counterValues.installedCSV || approvalStrategy != counterValues.approvalStrategy { - // Delete metric will label values of old Subscription first SubscriptionSyncCount.DeleteLabelValues(sub.GetName(), counterValues.installedCSV, counterValues.channel, counterValues.pkg, counterValues.approvalStrategy) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.conversion.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.conversion.go index bd1fa99a8c..b87fb8266c 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.conversion.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.deepcopy.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.deepcopy.go index d1358ae338..3949989895 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.deepcopy.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.defaults.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.defaults.go index 5c5a6e263e..698f41d0f7 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.defaults.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/zz_generated.deepcopy.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/zz_generated.deepcopy.go index d317823179..c7fd15e884 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/zz_generated.deepcopy.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/client/openapi/zz_generated.openapi.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/client/openapi/zz_generated.openapi.go index 61f851c92c..bd3a270edc 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/client/openapi/zz_generated.openapi.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/client/openapi/zz_generated.openapi.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -2719,6 +2720,13 @@ func schema_pkg_apis_meta_v1_CreateOptions(ref common.ReferenceCallback) common. Format: "", }, }, + "fieldValidation": { + SchemaProps: spec.SchemaProps{ + Description: "fieldValidation determines how the server should respond to unknown/duplicate fields in the object in the request. Introduced as alpha in 1.23, older servers or servers with the `ServerSideFieldValidation` feature disabled will discard valid values specified in this param and not perform any server side field validation. Valid values are: - Ignore: ignores unknown/duplicate fields. - Warn: responds with a warning for each unknown/duplicate field, but successfully serves the request. - Strict: fails the request on unknown/duplicate fields.", + Type: []string{"string"}, + Format: "", + }, + }, }, }, }, @@ -2971,7 +2979,7 @@ func schema_pkg_apis_meta_v1_GroupVersionKind(ref common.ReferenceCallback) comm return common.OpenAPIDefinition{ Schema: spec.Schema{ SchemaProps: spec.SchemaProps{ - Description: "GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling", + Description: "GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling", Type: []string{"object"}, Properties: map[string]spec.Schema{ "group": { @@ -3006,7 +3014,7 @@ func schema_pkg_apis_meta_v1_GroupVersionResource(ref common.ReferenceCallback) return common.OpenAPIDefinition{ Schema: spec.Schema{ SchemaProps: spec.SchemaProps{ - Description: "GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling", + Description: "GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling", Type: []string{"object"}, Properties: map[string]spec.Schema{ "group": { @@ -3813,6 +3821,13 @@ func schema_pkg_apis_meta_v1_PatchOptions(ref common.ReferenceCallback) common.O Format: "", }, }, + "fieldValidation": { + SchemaProps: spec.SchemaProps{ + Description: "fieldValidation determines how the server should respond to unknown/duplicate fields in the object in the request. Introduced as alpha in 1.23, older servers or servers with the `ServerSideFieldValidation` feature disabled will discard valid values specified in this param and not perform any server side field validation. Valid values are: - Ignore: ignores unknown/duplicate fields. - Warn: responds with a warning for each unknown/duplicate field, but successfully serves the request. - Strict: fails the request on unknown/duplicate fields.", + Type: []string{"string"}, + Format: "", + }, + }, }, }, }, @@ -4433,6 +4448,13 @@ func schema_pkg_apis_meta_v1_UpdateOptions(ref common.ReferenceCallback) common. Format: "", }, }, + "fieldValidation": { + SchemaProps: spec.SchemaProps{ + Description: "fieldValidation determines how the server should respond to unknown/duplicate fields in the object in the request. Introduced as alpha in 1.23, older servers or servers with the `ServerSideFieldValidation` feature disabled will discard valid values specified in this param and not perform any server side field validation. Valid values are: - Ignore: ignores unknown/duplicate fields. - Warn: responds with a warning for each unknown/duplicate field, but successfully serves the request. - Strict: fails the request on unknown/duplicate fields.", + Type: []string{"string"}, + Format: "", + }, + }, }, }, }, diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/provider/registry.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/provider/registry.go index a761eeb180..0a959b8c09 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/provider/registry.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/provider/registry.go @@ -61,7 +61,7 @@ func catalogIndexFunc(obj interface{}) ([]string, error) { func PackageManifestKeyFunc(obj interface{}) (string, error) { if key, ok := obj.(string); ok { - return string(key), nil + return key, nil } pkg, ok := obj.(*operators.PackageManifest) @@ -351,7 +351,7 @@ func (p *RegistryProvider) gcPackages(key registry.CatalogKey, keep map[string]s continue } } - if err := p.cache.Delete(string(storedPkgKey)); err != nil { + if err := p.cache.Delete(storedPkgKey); err != nil { logger.WithField("pkg", name).WithError(err).Warn("failed to delete cache entry") errs = append(errs, err) } @@ -363,18 +363,16 @@ func (p *RegistryProvider) gcPackages(key registry.CatalogKey, keep map[string]s func (p *RegistryProvider) catalogSourceDeleted(obj interface{}) { catsrc, ok := obj.(metav1.Object) if !ok { + tombstone, ok := obj.(cache.DeletedFinalStateUnknown) if !ok { - tombstone, ok := obj.(cache.DeletedFinalStateUnknown) - if !ok { - utilruntime.HandleError(fmt.Errorf("couldn't get object from tombstone %#v", obj)) - return - } + utilruntime.HandleError(fmt.Errorf("couldn't get object from tombstone %#v", obj)) + return + } - catsrc, ok = tombstone.Obj.(metav1.Object) - if !ok { - utilruntime.HandleError(fmt.Errorf("tombstone contained object that is not a Namespace %#v", obj)) - return - } + catsrc, ok = tombstone.Obj.(metav1.Object) + if !ok { + utilruntime.HandleError(fmt.Errorf("tombstone contained object that is not a Namespace %#v", obj)) + return } } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/printer.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/printer.go index dece00662e..a0eb2f8af8 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/printer.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/printer.go @@ -30,7 +30,6 @@ func addTableHandlers(h printers.PrintHandler) { } h.TableHandler(podColumnDefinitions, printPackage) h.TableHandler(podColumnDefinitions, printPackageList) - } func printPackage(manifest *operators.PackageManifest, options printers.GenerateOptions) ([]metav1beta1.TableRow, error) { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/util/cpb/main.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/util/cpb/main.go index f0bfbbe80a..ae9912bf97 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/util/cpb/main.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/util/cpb/main.go @@ -84,6 +84,13 @@ func getMetadata() (m *metadata, err error) { manifestDir: "/manifests", } + // Exclude device filesystems and pseudo filesystems from filesystems looking for metadata + excludeDir := []string{ + "/dev", + "/proc", + "/sys", + } + // Traverse the filesystem looking for metadata err = filepath.Walk(".", func(path string, info os.FileInfo, err error) error { if err != nil { @@ -91,7 +98,18 @@ func getMetadata() (m *metadata, err error) { return nil } if info.IsDir() { - fmt.Printf("skipping a dir without errors: %+v \n", info.Name()) + absPath, err := filepath.Abs(path) + if err != nil { + fmt.Printf("couldn't get the absolute path %q: %v\n", path, err) + return nil + } + for _, v := range excludeDir { + if v == absPath { + fmt.Printf("skipping all files in the dir: %+v \n", absPath) + return filepath.SkipDir + } + } + fmt.Printf("skipping a dir without errors: %+v \n", absPath) return nil } if info.Name() != bundle.AnnotationsFile { diff --git a/vendor/github.com/operator-framework/operator-registry/alpha/action/testdata/foo-index-v0.2.0-declcfg/foo/index.yaml b/vendor/github.com/operator-framework/operator-registry/alpha/action/testdata/foo-index-v0.2.0-declcfg/foo/index.yaml index 7a126ee502..933b108d2a 100644 --- a/vendor/github.com/operator-framework/operator-registry/alpha/action/testdata/foo-index-v0.2.0-declcfg/foo/index.yaml +++ b/vendor/github.com/operator-framework/operator-registry/alpha/action/testdata/foo-index-v0.2.0-declcfg/foo/index.yaml @@ -2,6 +2,11 @@ schema: olm.package name: foo defaultChannel: beta +properties: + - type: owner + value: + group: abc.com + name: admin --- schema: olm.channel package: foo @@ -15,6 +20,11 @@ entries: skips: - foo.v0.1.1 - foo.v0.1.2 +properties: + - type: user + value: + group: xyz.com + name: account --- schema: olm.channel package: foo diff --git a/vendor/github.com/operator-framework/operator-registry/alpha/declcfg/declcfg.go b/vendor/github.com/operator-framework/operator-registry/alpha/declcfg/declcfg.go index 688d5982a6..7579c97e31 100644 --- a/vendor/github.com/operator-framework/operator-registry/alpha/declcfg/declcfg.go +++ b/vendor/github.com/operator-framework/operator-registry/alpha/declcfg/declcfg.go @@ -20,11 +20,12 @@ type DeclarativeConfig struct { } type Package struct { - Schema string `json:"schema"` - Name string `json:"name"` - DefaultChannel string `json:"defaultChannel"` - Icon *Icon `json:"icon,omitempty"` - Description string `json:"description,omitempty"` + Schema string `json:"schema"` + Name string `json:"name"` + DefaultChannel string `json:"defaultChannel"` + Icon *Icon `json:"icon,omitempty"` + Description string `json:"description,omitempty"` + Properties []property.Property `json:"properties,omitempty" hash:"set"` } type Icon struct { @@ -33,10 +34,11 @@ type Icon struct { } type Channel struct { - Schema string `json:"schema"` - Name string `json:"name"` - Package string `json:"package"` - Entries []ChannelEntry `json:"entries"` + Schema string `json:"schema"` + Name string `json:"name"` + Package string `json:"package"` + Entries []ChannelEntry `json:"entries"` + Properties []property.Property `json:"properties,omitempty" hash:"set"` } type ChannelEntry struct { diff --git a/vendor/github.com/operator-framework/operator-registry/alpha/declcfg/diff.go b/vendor/github.com/operator-framework/operator-registry/alpha/declcfg/diff.go index 034aa02400..351eb95e58 100644 --- a/vendor/github.com/operator-framework/operator-registry/alpha/declcfg/diff.go +++ b/vendor/github.com/operator-framework/operator-registry/alpha/declcfg/diff.go @@ -101,7 +101,10 @@ func (g *DiffGenerator) Run(oldModel, newModel model.Model) (model.Model, error) if len(ch.Bundles) == 0 { delete(outputPkg.Channels, ch.Name) } - + } + if len(outputPkg.Channels) == 0 { + // Remove empty packages. + delete(outputModel, outputPkg.Name) } } } diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/extract.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/extract.go index d07273b3c4..3952a52b8c 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/extract.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/extract.go @@ -12,7 +12,7 @@ import ( var extractCmd = &cobra.Command{ Use: "extract", Short: "Extracts the data in a bundle directory via ConfigMap", - Long: "Extract takes as input a directory containing manifests and writes the per file contents to a ConfipMap", + Long: "Extract takes as input a directory containing manifests and writes the per file contents to a ConfigMap", PreRunE: func(cmd *cobra.Command, _ []string) error { if debug, _ := cmd.Flags().GetBool("debug"); debug { diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/unpack.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/unpack.go index 67f3b311a5..59ccab3799 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/unpack.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/unpack.go @@ -12,6 +12,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/image" "github.com/operator-framework/operator-registry/pkg/image/containerdregistry" "github.com/operator-framework/operator-registry/pkg/lib/bundle" @@ -28,11 +29,16 @@ func newBundleUnpackCmd() *cobra.Command { RunE: unpackBundle, } unpack.Flags().BoolP("debug", "d", false, "enable debug log output") - unpack.Flags().BoolP("skip-tls", "s", false, "disable TLS verification") + unpack.Flags().BoolP("skip-tls", "s", false, "use plain HTTP") + unpack.Flags().Bool("skip-tls-verify", false, "disable TLS verification") + unpack.Flags().Bool("use-http", false, "use plain HTTP") unpack.Flags().BoolP("skip-validation", "v", false, "disable bundle validation") unpack.Flags().StringP("root-ca", "c", "", "file path of a root CA to use when communicating with image registries") unpack.Flags().StringP("out", "o", "./", "directory in which to unpack operator bundle content") + if err := unpack.Flags().MarkDeprecated("skip-tls", "use --use-http and --skip-tls-verify instead"); err != nil { + logrus.Panic(err.Error()) + } return unpack } @@ -71,13 +77,14 @@ func unpackBundle(cmd *cobra.Command, args []string) error { var ( registryOpts []containerdregistry.RegistryOption - skipTLS bool ) - skipTLS, err = cmd.Flags().GetBool("skip-tls") + + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } - registryOpts = append(registryOpts, containerdregistry.SkipTLS(skipTLS)) + + registryOpts = append(registryOpts, containerdregistry.SkipTLSVerify(skipTLSVerify), containerdregistry.WithPlainHTTP(useHTTP)) var skipValidation bool skipValidation, err = cmd.Flags().GetBool("skip-validation") diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/cmd.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/cmd.go index 7afed8b098..da67833a4a 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/cmd.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/cmd.go @@ -5,7 +5,6 @@ import ( "github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle" "github.com/operator-framework/operator-registry/cmd/opm/alpha/diff" - "github.com/operator-framework/operator-registry/cmd/opm/alpha/generate" "github.com/operator-framework/operator-registry/cmd/opm/alpha/list" ) @@ -20,7 +19,6 @@ func NewCmd() *cobra.Command { runCmd.AddCommand( bundle.NewCmd(), list.NewCmd(), - generate.NewCmd(), diff.NewCmd(), ) return runCmd diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/diff/cmd.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/diff/cmd.go index 752e4d343a..54ed5aa54d 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/diff/cmd.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/diff/cmd.go @@ -14,6 +14,7 @@ import ( "github.com/operator-framework/operator-registry/alpha/action" "github.com/operator-framework/operator-registry/alpha/declcfg" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" containerd "github.com/operator-framework/operator-registry/pkg/image/containerdregistry" "github.com/operator-framework/operator-registry/pkg/lib/certs" ) @@ -154,15 +155,21 @@ func (a *diff) addFunc(cmd *cobra.Command, args []string) error { return fmt.Errorf("invalid --output value: %q", a.output) } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { - logrus.Panic(err) + return err } + rootCAs, err := certs.RootCAs(a.caFile) if err != nil { a.logger.Fatalf("error getting root CAs: %v", err) } - reg, err := containerd.NewRegistry(containerd.SkipTLS(skipTLS), containerd.WithLog(a.logger), containerd.WithRootCAs(rootCAs)) + reg, err := containerd.NewRegistry( + containerd.SkipTLSVerify(skipTLSVerify), + containerd.WithLog(a.logger), + containerd.WithRootCAs(rootCAs), + containerd.WithPlainHTTP(useHTTP), + ) if err != nil { a.logger.Fatalf("error creating containerd registry: %v", err) } diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/generate/cmd.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/generate/cmd.go similarity index 100% rename from vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/generate/cmd.go rename to vendor/github.com/operator-framework/operator-registry/cmd/opm/generate/cmd.go diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/add.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/add.go index ea218d6e04..0cb7c48016 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/add.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/add.go @@ -7,6 +7,7 @@ import ( "github.com/spf13/cobra" "k8s.io/kubectl/pkg/util/templates" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/registry" @@ -126,7 +127,7 @@ func runIndexAddCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -174,7 +175,8 @@ func runIndexAddCmdFunc(cmd *cobra.Command, _ []string) error { Bundles: bundles, Permissive: permissive, Mode: modeEnum, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, Overwrite: overwrite, EnableAlpha: enableAlpha, } diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/cmd.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/cmd.go index b7cdd14d15..3e3aeb4993 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/cmd.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/cmd.go @@ -33,6 +33,12 @@ func AddCommand(parent *cobra.Command) { parent.AddCommand(cmd) parent.PersistentFlags().Bool("skip-tls", false, "skip TLS certificate verification for container image registries while pulling bundles or index") + parent.PersistentFlags().Bool("skip-tls-verify", false, "skip TLS certificate verification for container image registries while pulling bundles") + parent.PersistentFlags().Bool("use-http", false, "use plain HTTP for container image registries while pulling bundles") + if err := parent.PersistentFlags().MarkDeprecated("skip-tls", "use --use-http and --skip-tls-verify instead"); err != nil { + logrus.Panic(err.Error()) + } + cmd.AddCommand(newIndexDeleteCmd()) addIndexAddCmd(cmd) cmd.AddCommand(newIndexExportCmd()) diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/delete.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/delete.go index c9472b8ed2..f7970676af 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/delete.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/delete.go @@ -4,6 +4,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -95,7 +96,7 @@ func runIndexDeleteCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -117,7 +118,8 @@ func runIndexDeleteCmdFunc(cmd *cobra.Command, _ []string) error { Operators: operators, Tag: tag, Permissive: permissive, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, } err = indexDeleter.DeleteFromIndex(request) diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/deprecatetruncate.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/deprecatetruncate.go index 9324d35b8e..33206e3235 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/deprecatetruncate.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/deprecatetruncate.go @@ -5,6 +5,7 @@ import ( "github.com/spf13/cobra" "k8s.io/kubectl/pkg/util/templates" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -110,7 +111,7 @@ func runIndexDeprecateTruncateCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -137,7 +138,8 @@ func runIndexDeprecateTruncateCmdFunc(cmd *cobra.Command, _ []string) error { Tag: tag, Bundles: bundles, Permissive: permissive, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, AllowPackageRemoval: allowPackageRemoval, } diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/export.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/export.go index f4e32672e7..2541cbba69 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/export.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/export.go @@ -7,6 +7,7 @@ import ( "github.com/spf13/cobra" "k8s.io/kubectl/pkg/util/templates" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -100,7 +101,7 @@ func runIndexExportCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -116,7 +117,8 @@ func runIndexExportCmdFunc(cmd *cobra.Command, _ []string) error { Packages: packages, DownloadPath: downloadPath, ContainerTool: containertools.NewContainerTool(containerTool, containertools.NoneTool), - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, } err = indexExporter.ExportFromIndex(request) diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/prune.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/prune.go index c80ebf6198..ec57174bb8 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/prune.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/prune.go @@ -6,6 +6,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -99,7 +100,7 @@ func runIndexPruneCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -118,7 +119,8 @@ func runIndexPruneCmdFunc(cmd *cobra.Command, _ []string) error { Packages: packages, Tag: tag, Permissive: permissive, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, } err = indexPruner.PruneFromIndex(request) diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/prunestranded.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/prunestranded.go index 03e739cff5..4ba306919f 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/prunestranded.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/index/prunestranded.go @@ -6,6 +6,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/indexer" "github.com/operator-framework/operator-registry/pkg/sqlite" @@ -84,7 +85,7 @@ func runIndexPruneStrandedCmdFunc(cmd *cobra.Command, _ []string) error { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) if err != nil { return err } @@ -101,7 +102,8 @@ func runIndexPruneStrandedCmdFunc(cmd *cobra.Command, _ []string) error { BinarySourceImage: binaryImage, OutDockerfile: outDockerfile, Tag: tag, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, } err = indexPruner.PruneStrandedFromIndex(request) diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/internal/util/util.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/internal/util/util.go new file mode 100644 index 0000000000..7d83cf66a8 --- /dev/null +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/internal/util/util.go @@ -0,0 +1,39 @@ +package util + +import ( + "errors" + + "github.com/spf13/cobra" +) + +// GetTLSOptions validates and returns TLS options set by opm flags +func GetTLSOptions(cmd *cobra.Command) (bool, bool, error) { + skipTLS, err := cmd.Flags().GetBool("skip-tls") + if err != nil { + return false, false, err + } + skipTLSVerify, err := cmd.Flags().GetBool("skip-tls-verify") + if err != nil { + return false, false, err + } + useHTTP, err := cmd.Flags().GetBool("use-http") + if err != nil { + return false, false, err + } + + switch { + case cmd.Flags().Changed("skip-tls") && cmd.Flags().Changed("use-http"): + return false, false, errors.New("invalid flag combination: cannot use --use-http with --skip-tls") + case cmd.Flags().Changed("skip-tls") && cmd.Flags().Changed("skip-tls-verify"): + return false, false, errors.New("invalid flag combination: cannot use --skip-tls-verify with --skip-tls") + case skipTLSVerify && useHTTP: + return false, false, errors.New("invalid flag combination: --use-http and --skip-tls-verify cannot both be true") + default: + // return use HTTP true if just skipTLS + // is set for functional parity with existing + if skipTLS { + return false, true, nil + } + return skipTLSVerify, useHTTP, nil + } +} diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/registry/add.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/registry/add.go index ceb3fcd1ad..dd7237e37d 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/registry/add.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/registry/add.go @@ -7,6 +7,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/lib/registry" reg "github.com/operator-framework/operator-registry/pkg/registry" @@ -36,7 +37,9 @@ func newRegistryAddCmd() *cobra.Command { rootCmd.Flags().StringP("database", "d", "bundles.db", "relative path to database file") rootCmd.Flags().StringSliceP("bundle-images", "b", []string{}, "comma separated list of links to bundle image") rootCmd.Flags().Bool("permissive", false, "allow registry load errors") - rootCmd.Flags().Bool("skip-tls", false, "skip TLS certificate verification for container image registries while pulling bundles") + rootCmd.Flags().Bool("skip-tls", false, "use Plain HTTP for container image registries while pulling bundles") + rootCmd.Flags().Bool("skip-tls-verify", false, "skip TLS certificate verification for container image registries while pulling bundles") + rootCmd.Flags().Bool("use-http", false, "use plain HTTP for container image registries while pulling bundles") rootCmd.Flags().String("ca-file", "", "the root certificates to use when --container-tool=none; see docker/podman docs for certificate loading instructions") rootCmd.Flags().StringP("mode", "", "replaces", "graph update mode that defines how channel graphs are updated. One of: [replaces, semver, semver-skippatch]") rootCmd.Flags().StringP("container-tool", "c", "none", "tool to interact with container images (save, build, etc.). One of: [none, docker, podman]") @@ -48,6 +51,9 @@ func newRegistryAddCmd() *cobra.Command { if err := rootCmd.Flags().MarkHidden("enable-alpha"); err != nil { logrus.Panic(err.Error()) } + if err := rootCmd.Flags().MarkDeprecated("skip-tls", "use --use-http and --skip-tls-verify instead"); err != nil { + logrus.Panic(err.Error()) + } return rootCmd } @@ -56,10 +62,6 @@ func addFunc(cmd *cobra.Command, _ []string) error { if err != nil { return err } - skipTLS, err := cmd.Flags().GetBool("skip-tls") - if err != nil { - return err - } caFile, err := cmd.Flags().GetString("ca-file") if err != nil { return err @@ -95,9 +97,14 @@ func addFunc(cmd *cobra.Command, _ []string) error { return err } + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) + if err != nil { + return err + } + if caFile != "" { - if skipTLS { - return errors.New("--skip-tls must be false when --ca-file is set") + if skipTLSVerify { + return errors.New("--skip-tls-verify must be false when --ca-file is set") } if containerTool != containertools.NoneTool { return fmt.Errorf("--ca-file cannot be set with --container-tool=%[1]s; "+ @@ -107,7 +114,8 @@ func addFunc(cmd *cobra.Command, _ []string) error { request := registry.AddToRegistryRequest{ Permissive: permissive, - SkipTLS: skipTLS, + SkipTLSVerify: skipTLSVerify, + PlainHTTP: useHTTP, CaFile: caFile, InputDatabase: fromFilename, Bundles: bundleImages, @@ -119,8 +127,12 @@ func addFunc(cmd *cobra.Command, _ []string) error { logger := logrus.WithFields(logrus.Fields{"bundles": bundleImages}) - if skipTLS { - logger.Warn("--skip-tls flag is set: this mode is insecure and meant for development purposes only.") + if skipTLSVerify { + logger.Warn("--skip-tls-verify flag is set: this mode is insecure and meant for development purposes only.") + } + + if useHTTP { + logger.Warn("--use-http flag is set: this mode is insecure and meant for development purposes only.") } logger.Info("adding to the registry") diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/render/cmd.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/render/cmd.go index 913eb21a08..228deab5a8 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/render/cmd.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/render/cmd.go @@ -11,6 +11,8 @@ import ( "github.com/operator-framework/operator-registry/alpha/action" "github.com/operator-framework/operator-registry/alpha/declcfg" + "github.com/operator-framework/operator-registry/cmd/opm/internal/util" + containerd "github.com/operator-framework/operator-registry/pkg/image/containerdregistry" "github.com/operator-framework/operator-registry/pkg/sqlite" ) @@ -44,6 +46,29 @@ func NewCmd() *cobra.Command { // returned from render.Run and logged as fatal errors. logrus.SetOutput(ioutil.Discard) + skipTLSVerify, useHTTP, err := util.GetTLSOptions(cmd) + if err != nil { + log.Fatal(err) + } + + cacheDir, err := os.MkdirTemp("", "render-registry-") + if err != nil { + log.Fatal(err) + } + + reg, err := containerd.NewRegistry( + containerd.WithCacheDir(cacheDir), + containerd.SkipTLSVerify(skipTLSVerify), + containerd.WithPlainHTTP(useHTTP), + containerd.WithLog(nullLogger()), + ) + if err != nil { + log.Fatalf("creating containerd registry: %v", err) + } + defer reg.Destroy() + + render.Registry = reg + cfg, err := render.Run(cmd.Context()) if err != nil { log.Fatal(err) @@ -55,5 +80,13 @@ func NewCmd() *cobra.Command { }, } cmd.Flags().StringVarP(&output, "output", "o", "json", "Output format (json|yaml)") + cmd.Flags().Bool("skip-tls-verify", false, "disable TLS verification") + cmd.Flags().Bool("use-http", false, "use plain HTTP") return cmd } + +func nullLogger() *logrus.Entry { + logger := logrus.New() + logger.SetOutput(ioutil.Discard) + return logrus.NewEntry(logger) +} diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/root/cmd.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/root/cmd.go index 1b00fecc01..8798aaf795 100644 --- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/root/cmd.go +++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/root/cmd.go @@ -5,6 +5,7 @@ import ( "github.com/spf13/cobra" "github.com/operator-framework/operator-registry/cmd/opm/alpha" + "github.com/operator-framework/operator-registry/cmd/opm/generate" "github.com/operator-framework/operator-registry/cmd/opm/index" initcmd "github.com/operator-framework/operator-registry/cmd/opm/init" "github.com/operator-framework/operator-registry/cmd/opm/migrate" @@ -29,7 +30,7 @@ func NewCmd() *cobra.Command { Args: cobra.NoArgs, } - cmd.AddCommand(registry.NewOpmRegistryCmd(), alpha.NewCmd(), initcmd.NewCmd(), migrate.NewCmd(), serve.NewCmd(), render.NewCmd(), validate.NewCmd()) + cmd.AddCommand(registry.NewOpmRegistryCmd(), alpha.NewCmd(), initcmd.NewCmd(), migrate.NewCmd(), serve.NewCmd(), render.NewCmd(), validate.NewCmd(), generate.NewCmd()) index.AddCommand(cmd) version.AddCommand(cmd) diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/containertools/runner.go b/vendor/github.com/operator-framework/operator-registry/pkg/containertools/runner.go index f178d8c5d6..660c92c6a6 100644 --- a/vendor/github.com/operator-framework/operator-registry/pkg/containertools/runner.go +++ b/vendor/github.com/operator-framework/operator-registry/pkg/containertools/runner.go @@ -130,10 +130,13 @@ func (r *ContainerCommandRunner) Unpack(image, src, dst string) error { r.logger.Infof("running %s create", r.containerTool) r.logger.Debugf("%s", command.Args) - out, err := command.CombinedOutput() + out, err := command.Output() if err != nil { - r.logger.Errorf(string(out)) - return fmt.Errorf("error creating container %s: %v", string(out), err) + msg := err.Error() + if exitErr, ok := err.(*exec.ExitError); ok { + msg = fmt.Sprintf("%s: %s", err, exitErr.Stderr) + } + return fmt.Errorf("error creating container %s: %s", string(out), msg) } id := strings.TrimSuffix(string(out), "\n") diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/image/containerdregistry/options.go b/vendor/github.com/operator-framework/operator-registry/pkg/image/containerdregistry/options.go index de0be2f70d..569395feb1 100644 --- a/vendor/github.com/operator-framework/operator-registry/pkg/image/containerdregistry/options.go +++ b/vendor/github.com/operator-framework/operator-registry/pkg/image/containerdregistry/options.go @@ -21,7 +21,8 @@ type RegistryConfig struct { DBPath string CacheDir string PreserveCache bool - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool Roots *x509.CertPool } @@ -90,7 +91,7 @@ func NewRegistry(options ...RegistryOption) (registry *Registry, err error) { } var resolver remotes.Resolver - resolver, err = NewResolver(config.ResolverConfigDir, config.SkipTLS, config.Roots) + resolver, err = NewResolver(config.ResolverConfigDir, config.SkipTLSVerify, config.PlainHTTP, config.Roots) if err != nil { return } @@ -140,8 +141,14 @@ func PreserveCache(preserve bool) RegistryOption { } } -func SkipTLS(skip bool) RegistryOption { +func SkipTLSVerify(skip bool) RegistryOption { return func(config *RegistryConfig) { - config.SkipTLS = skip + config.SkipTLSVerify = skip + } +} + +func WithPlainHTTP(insecure bool) RegistryOption { + return func(config *RegistryConfig) { + config.PlainHTTP = insecure } } diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/image/containerdregistry/resolver.go b/vendor/github.com/operator-framework/operator-registry/pkg/image/containerdregistry/resolver.go index 9ac771dde9..1f0698d2c7 100644 --- a/vendor/github.com/operator-framework/operator-registry/pkg/image/containerdregistry/resolver.go +++ b/vendor/github.com/operator-framework/operator-registry/pkg/image/containerdregistry/resolver.go @@ -5,8 +5,12 @@ import ( "crypto/x509" "net" "net/http" + "os" + "path/filepath" + "sync" "time" + "github.com/adrg/xdg" "github.com/containerd/containerd/remotes" "github.com/containerd/containerd/remotes/docker" "github.com/docker/cli/cli/config" @@ -15,7 +19,7 @@ import ( "github.com/docker/docker/registry" ) -func NewResolver(configDir string, insecure bool, roots *x509.CertPool) (remotes.Resolver, error) { +func NewResolver(configDir string, skipTlSVerify, plainHTTP bool, roots *x509.CertPool) (remotes.Resolver, error) { transport := &http.Transport{ Proxy: http.ProxyFromEnvironment, DialContext: (&net.Dialer{ @@ -32,9 +36,9 @@ func NewResolver(configDir string, insecure bool, roots *x509.CertPool) (remotes }, } - if insecure { + if plainHTTP || skipTlSVerify { transport.TLSClientConfig = &tls.Config{ - InsecureSkipVerify: insecure, + InsecureSkipVerify: true, } } headers := http.Header{} @@ -55,7 +59,7 @@ func NewResolver(configDir string, insecure bool, roots *x509.CertPool) (remotes )), docker.WithClient(client), } - if insecure { + if plainHTTP { regopts = append(regopts, docker.WithPlainHTTP(docker.MatchAllHosts)) } @@ -85,14 +89,39 @@ func credential(cfg *configfile.ConfigFile) func(string) (string, string, error) } } +// protects against a data race inside the docker CLI +// TODO: upstream issue for 20.10.x is tracked here https://github.com/docker/cli/pull/3410 +// newer versions already contain the fix +var configMutex sync.Mutex + func loadConfig(dir string) (*configfile.ConfigFile, error) { + configMutex.Lock() + defer configMutex.Unlock() + if dir == "" { dir = config.Dir() } - cfg, err := config.Load(dir) - if err != nil { - return nil, err + dockerConfigJSON := filepath.Join(dir, config.ConfigFileName) + cfg := configfile.New(dockerConfigJSON) + + switch _, err := os.Stat(dockerConfigJSON); { + case err == nil: + cfg, err = config.Load(dir) + if err != nil { + return cfg, err + } + case os.IsNotExist(err): + podmanConfig := filepath.Join(xdg.RuntimeDir, "containers/auth.json") + if file, err := os.Open(podmanConfig); err == nil { + defer file.Close() + cfg, err = config.LoadFromReader(file) + if err != nil { + return cfg, err + } + } else if !os.IsNotExist(err) { + return cfg, err + } } if !cfg.ContainsAuth() { diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/exporter.go b/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/exporter.go index 53469f8682..be9f363120 100644 --- a/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/exporter.go +++ b/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/exporter.go @@ -30,7 +30,7 @@ func NewExporterForBundle(image, directory string, containerTool containertools. } } -func (i *BundleExporter) Export(skipTLS bool) error { +func (i *BundleExporter) Export(skipTLSVerify, plainHTTP bool) error { log := logrus.WithField("img", i.image) @@ -44,11 +44,16 @@ func (i *BundleExporter) Export(skipTLS bool) error { var rerr error switch i.containerTool { case containertools.NoneTool: - reg, rerr = containerdregistry.NewRegistry(containerdregistry.SkipTLS(skipTLS), containerdregistry.WithLog(log), containerdregistry.WithCacheDir(filepath.Join(tmpDir, "cacheDir"))) + reg, rerr = containerdregistry.NewRegistry( + containerdregistry.SkipTLSVerify(skipTLSVerify), + containerdregistry.WithPlainHTTP(plainHTTP), + containerdregistry.WithLog(log), + containerdregistry.WithCacheDir(filepath.Join(tmpDir, "cacheDir")), + ) case containertools.PodmanTool: fallthrough case containertools.DockerTool: - reg, rerr = execregistry.NewRegistry(i.containerTool, log, containertools.SkipTLS(skipTLS)) + reg, rerr = execregistry.NewRegistry(i.containerTool, log, containertools.SkipTLS(plainHTTP)) } if rerr != nil { return rerr diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/validate.go b/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/validate.go index d7a96d11ca..fb8ca0368d 100644 --- a/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/validate.go +++ b/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/validate.go @@ -237,6 +237,8 @@ func validateDependencies(dependenciesFile *registry.DependenciesFile) []error { errs = dp.Validate() case registry.LabelDependency: errs = dp.Validate() + case registry.CelConstraint: + errs = dp.Validate() default: errs = append(errs, fmt.Errorf("unsupported dependency type %s", d.GetType())) } diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/lib/indexer/indexer.go b/vendor/github.com/operator-framework/operator-registry/pkg/lib/indexer/indexer.go index 54eae4db1a..09b7340fab 100644 --- a/vendor/github.com/operator-framework/operator-registry/pkg/lib/indexer/indexer.go +++ b/vendor/github.com/operator-framework/operator-registry/pkg/lib/indexer/indexer.go @@ -63,7 +63,8 @@ type AddToIndexRequest struct { Tag string Mode pregistry.Mode CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool Overwrite bool EnableAlpha bool } @@ -76,7 +77,7 @@ func (i ImageIndexer) AddToIndex(request AddToIndexRequest) error { return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -87,7 +88,8 @@ func (i ImageIndexer) AddToIndex(request AddToIndexRequest) error { InputDatabase: databasePath, Permissive: request.Permissive, Mode: request.Mode, - SkipTLS: request.SkipTLS, + SkipTLSVerify: request.SkipTLSVerify, + PlainHTTP: request.PlainHTTP, ContainerTool: i.PullTool, Overwrite: request.Overwrite, EnableAlpha: request.EnableAlpha, @@ -129,7 +131,8 @@ type DeleteFromIndexRequest struct { OutDockerfile string Tag string Operators []string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool CaFile string } @@ -142,7 +145,7 @@ func (i ImageIndexer) DeleteFromIndex(request DeleteFromIndexRequest) error { return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -188,7 +191,8 @@ type PruneStrandedFromIndexRequest struct { OutDockerfile string Tag string CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool } // PruneStrandedFromIndex is an aggregate API used to generate a registry index image @@ -200,7 +204,7 @@ func (i ImageIndexer) PruneStrandedFromIndex(request PruneStrandedFromIndexReque return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -245,7 +249,8 @@ type PruneFromIndexRequest struct { Tag string Packages []string CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool } func (i ImageIndexer) PruneFromIndex(request PruneFromIndexRequest) error { @@ -255,7 +260,7 @@ func (i ImageIndexer) PruneFromIndex(request PruneFromIndexRequest) error { return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -294,14 +299,14 @@ func (i ImageIndexer) PruneFromIndex(request PruneFromIndexRequest) error { } // ExtractDatabase sets a temp directory for unpacking an image -func (i ImageIndexer) ExtractDatabase(buildDir, fromIndex, caFile string, skipTLS bool) (string, error) { +func (i ImageIndexer) ExtractDatabase(buildDir, fromIndex, caFile string, skipTLSVerify, plainHTTP bool) (string, error) { tmpDir, err := ioutil.TempDir("./", tmpDirPrefix) if err != nil { return "", err } defer os.RemoveAll(tmpDir) - databaseFile, err := i.getDatabaseFile(tmpDir, fromIndex, caFile, skipTLS) + databaseFile, err := i.getDatabaseFile(tmpDir, fromIndex, caFile, skipTLSVerify, plainHTTP) if err != nil { return "", err } @@ -309,7 +314,7 @@ func (i ImageIndexer) ExtractDatabase(buildDir, fromIndex, caFile string, skipTL return copyDatabaseTo(databaseFile, filepath.Join(buildDir, defaultDatabaseFolder)) } -func (i ImageIndexer) getDatabaseFile(workingDir, fromIndex, caFile string, skipTLS bool) (string, error) { +func (i ImageIndexer) getDatabaseFile(workingDir, fromIndex, caFile string, skipTLSVerify, plainHTTP bool) (string, error) { if fromIndex == "" { return path.Join(workingDir, defaultDatabaseFile), nil } @@ -325,11 +330,15 @@ func (i ImageIndexer) getDatabaseFile(workingDir, fromIndex, caFile string, skip if err != nil { return "", fmt.Errorf("failed to get RootCAs: %v", err) } - reg, rerr = containerdregistry.NewRegistry(containerdregistry.SkipTLS(skipTLS), containerdregistry.WithLog(i.Logger), containerdregistry.WithRootCAs(rootCAs)) + reg, rerr = containerdregistry.NewRegistry( + containerdregistry.SkipTLSVerify(skipTLSVerify), + containerdregistry.WithPlainHTTP(plainHTTP), + containerdregistry.WithLog(i.Logger), + containerdregistry.WithRootCAs(rootCAs)) case containertools.PodmanTool: fallthrough case containertools.DockerTool: - reg, rerr = execregistry.NewRegistry(i.PullTool, i.Logger, containertools.SkipTLS(skipTLS)) + reg, rerr = execregistry.NewRegistry(i.PullTool, i.Logger, containertools.SkipTLS(plainHTTP)) } if rerr != nil { return "", rerr @@ -481,7 +490,8 @@ type ExportFromIndexRequest struct { DownloadPath string ContainerTool containertools.ContainerTool CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool } // ExportFromIndex is an aggregate API used to specify operators from @@ -495,7 +505,7 @@ func (i ImageIndexer) ExportFromIndex(request ExportFromIndexRequest) error { defer os.RemoveAll(workingDir) // extract the index database to the file - databaseFile, err := i.getDatabaseFile(workingDir, request.Index, request.CaFile, request.SkipTLS) + databaseFile, err := i.getDatabaseFile(workingDir, request.Index, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } @@ -549,7 +559,7 @@ func (i ImageIndexer) ExportFromIndex(request ExportFromIndexRequest) error { bundleDir.bundleVersion = strconv.Itoa(rand.Intn(10000)) } exporter := bundle.NewExporterForBundle(bundleImage, filepath.Join(request.DownloadPath, bundleDir.pkgName, bundleDir.bundleVersion), request.ContainerTool) - if err := exporter.Export(request.SkipTLS); err != nil { + if err := exporter.Export(request.SkipTLSVerify, request.PlainHTTP); err != nil { err = fmt.Errorf("exporting bundle image:%s failed with %s", bundleImage, err) mu.Lock() errs = append(errs, err) @@ -651,7 +661,8 @@ type DeprecateFromIndexRequest struct { Bundles []string Tag string CaFile string - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool AllowPackageRemoval bool } @@ -664,7 +675,7 @@ func (i ImageIndexer) DeprecateFromIndex(request DeprecateFromIndexRequest) erro return err } - databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLS) + databasePath, err := i.ExtractDatabase(buildDir, request.FromIndex, request.CaFile, request.SkipTLSVerify, request.PlainHTTP) if err != nil { return err } diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/lib/registry/registry.go b/vendor/github.com/operator-framework/operator-registry/pkg/lib/registry/registry.go index 9ed73940e1..5f73196308 100644 --- a/vendor/github.com/operator-framework/operator-registry/pkg/lib/registry/registry.go +++ b/vendor/github.com/operator-framework/operator-registry/pkg/lib/registry/registry.go @@ -24,7 +24,8 @@ type RegistryUpdater struct { type AddToRegistryRequest struct { Permissive bool - SkipTLS bool + SkipTLSVerify bool + PlainHTTP bool CaFile string InputDatabase string Bundles []string @@ -66,11 +67,15 @@ func (r RegistryUpdater) AddToRegistry(request AddToRegistryRequest) error { if err != nil { return fmt.Errorf("failed to get RootCAs: %v", err) } - reg, rerr = containerdregistry.NewRegistry(containerdregistry.SkipTLS(request.SkipTLS), containerdregistry.WithRootCAs(rootCAs)) + reg, rerr = containerdregistry.NewRegistry( + containerdregistry.SkipTLSVerify(request.SkipTLSVerify), + containerdregistry.WithPlainHTTP(request.PlainHTTP), + containerdregistry.WithRootCAs(rootCAs), + ) case containertools.PodmanTool: fallthrough case containertools.DockerTool: - reg, rerr = execregistry.NewRegistry(request.ContainerTool, r.Logger, containertools.SkipTLS(request.SkipTLS)) + reg, rerr = execregistry.NewRegistry(request.ContainerTool, r.Logger, containertools.SkipTLS(request.PlainHTTP)) } if rerr != nil { return rerr diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/registry/types.go b/vendor/github.com/operator-framework/operator-registry/pkg/registry/types.go index d7d2585520..cc44e55978 100644 --- a/vendor/github.com/operator-framework/operator-registry/pkg/registry/types.go +++ b/vendor/github.com/operator-framework/operator-registry/pkg/registry/types.go @@ -8,6 +8,7 @@ import ( "strings" "github.com/blang/semver/v4" + "github.com/operator-framework/api/pkg/constraints" ) var ( @@ -55,6 +56,7 @@ const ( DeprecatedType = "olm.deprecated" LabelType = "olm.label" PropertyKey = "olm.properties" + ConstraintType = "olm.constraint" ) // APIKey stores GroupVersionKind for use as map keys @@ -220,6 +222,16 @@ type LabelDependency struct { Label string `json:"label" yaml:"label"` } +type CelConstraint struct { + // Constraint failure message that surfaces in resolution + // This field is optional + FailureMessage string `json:"failureMessage" yaml:"failureMessage"` + + // The cel struct that contraints CEL expression + // This field is required + Cel *constraints.Cel `json:"cel" yaml:"cel"` +} + type GVKProperty struct { // The group of GVK based property Group string `json:"group" yaml:"group"` @@ -289,6 +301,25 @@ func (pd *PackageDependency) Validate() []error { return errs } +// Validate will validate constraint type and return error(s) +func (cc *CelConstraint) Validate() []error { + errs := []error{} + if cc.Cel == nil { + errs = append(errs, fmt.Errorf("The CEL field is missing")) + } else { + if cc.Cel.Rule == "" { + errs = append(errs, fmt.Errorf("The CEL expression is missing")) + return errs + } + validator := constraints.NewCelEnvironment() + _, err := validator.Validate(cc.Cel.Rule) + if err != nil { + errs = append(errs, fmt.Errorf("Invalid CEL expression: %s", err.Error())) + } + } + return errs +} + // GetDependencies returns the list of dependency func (d *DependenciesFile) GetDependencies() []*Dependency { var dependencies []*Dependency @@ -329,6 +360,13 @@ func (e *Dependency) GetTypeValue() interface{} { return nil } return dep + case ConstraintType: + dep := CelConstraint{} + err := json.Unmarshal([]byte(e.GetValue()), &dep) + if err != nil { + return nil + } + return dep } return nil } diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/sqlite/load.go b/vendor/github.com/operator-framework/operator-registry/pkg/sqlite/load.go index 47540b1811..197b5861ed 100644 --- a/vendor/github.com/operator-framework/operator-registry/pkg/sqlite/load.go +++ b/vendor/github.com/operator-framework/operator-registry/pkg/sqlite/load.go @@ -957,6 +957,9 @@ func (s *sqlLoader) RemovePackage(packageName string) error { if err != nil { return err } + if len(csvNames) == 0 { + return fmt.Errorf("no package found for packagename %s", packageName) + } for _, csvName := range csvNames { if err := s.rmBundle(tx, csvName); err != nil { return err diff --git a/vendor/go.uber.org/zap/CHANGELOG.md b/vendor/go.uber.org/zap/CHANGELOG.md index fdfef8808a..794ee303e1 100644 --- a/vendor/go.uber.org/zap/CHANGELOG.md +++ b/vendor/go.uber.org/zap/CHANGELOG.md @@ -1,4 +1,16 @@ # Changelog +All notable changes to this project will be documented in this file. + +This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). + +## 1.19.1 (8 Sep 2021) + +### Fixed +* [#1001][]: JSON: Fix complex number encoding with negative imaginary part. Thanks to @hemantjadon. +* [#1003][]: JSON: Fix inaccurate precision when encoding float32. + +[#1001]: https://github.com/uber-go/zap/pull/1001 +[#1003]: https://github.com/uber-go/zap/pull/1003 ## 1.19.0 (9 Aug 2021) diff --git a/vendor/go.uber.org/zap/go.mod b/vendor/go.uber.org/zap/go.mod index 9455c99cc9..3480ab4e14 100644 --- a/vendor/go.uber.org/zap/go.mod +++ b/vendor/go.uber.org/zap/go.mod @@ -7,7 +7,7 @@ require ( github.com/pkg/errors v0.8.1 github.com/stretchr/testify v1.7.0 go.uber.org/atomic v1.7.0 - go.uber.org/goleak v1.1.10 + go.uber.org/goleak v1.1.11-0.20210813005559-691160354723 go.uber.org/multierr v1.6.0 gopkg.in/yaml.v2 v2.2.8 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect diff --git a/vendor/go.uber.org/zap/go.sum b/vendor/go.uber.org/zap/go.sum index 9031a6131a..1658da4354 100644 --- a/vendor/go.uber.org/zap/go.sum +++ b/vendor/go.uber.org/zap/go.sum @@ -14,31 +14,48 @@ 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/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/goleak v1.1.10 h1:z+mqJhf6ss6BSfSM671tgKyZBFPTTJM+HLxnhPC3wu0= -go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/goleak v1.1.11-0.20210813005559-691160354723 h1:sHOAIxRGBp443oHZIPB+HsUGaksVCXVQENPxwTfQdH4= +go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs= golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20191108193012-7d206e10da11 h1:Yq9t9jnGoR+dBuitxdo9l6Q7xh/zOyNnYUtDKaQ3x0E= -golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.5 h1:ouewzE6p+/VEB31YYnTbEJdi8pFqKp4P4n85vwo3DHA= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/vendor/go.uber.org/zap/zapcore/json_encoder.go b/vendor/go.uber.org/zap/zapcore/json_encoder.go index 5cf7d917e9..af220d9b4d 100644 --- a/vendor/go.uber.org/zap/zapcore/json_encoder.go +++ b/vendor/go.uber.org/zap/zapcore/json_encoder.go @@ -128,6 +128,11 @@ func (enc *jsonEncoder) AddFloat64(key string, val float64) { enc.AppendFloat64(val) } +func (enc *jsonEncoder) AddFloat32(key string, val float32) { + enc.addKey(key) + enc.AppendFloat32(val) +} + func (enc *jsonEncoder) AddInt64(key string, val int64) { enc.addKey(key) enc.AppendInt64(val) @@ -228,7 +233,11 @@ func (enc *jsonEncoder) AppendComplex128(val complex128) { // Because we're always in a quoted string, we can use strconv without // special-casing NaN and +/-Inf. enc.buf.AppendFloat(r, 64) - enc.buf.AppendByte('+') + // If imaginary part is less than 0, minus (-) sign is added by default + // by AppendFloat. + if i >= 0 { + enc.buf.AppendByte('+') + } enc.buf.AppendFloat(i, 64) enc.buf.AppendByte('i') enc.buf.AppendByte('"') @@ -293,7 +302,6 @@ func (enc *jsonEncoder) AppendUint64(val uint64) { } func (enc *jsonEncoder) AddComplex64(k string, v complex64) { enc.AddComplex128(k, complex128(v)) } -func (enc *jsonEncoder) AddFloat32(k string, v float32) { enc.AddFloat64(k, float64(v)) } func (enc *jsonEncoder) AddInt(k string, v int) { enc.AddInt64(k, int64(v)) } func (enc *jsonEncoder) AddInt32(k string, v int32) { enc.AddInt64(k, int64(v)) } func (enc *jsonEncoder) AddInt16(k string, v int16) { enc.AddInt64(k, int64(v)) } diff --git a/vendor/golang.org/x/crypto/openpgp/armor/armor.go b/vendor/golang.org/x/crypto/openpgp/armor/armor.go index 36a6804364..ebc87876e6 100644 --- a/vendor/golang.org/x/crypto/openpgp/armor/armor.go +++ b/vendor/golang.org/x/crypto/openpgp/armor/armor.go @@ -4,6 +4,12 @@ // Package armor implements OpenPGP ASCII Armor, see RFC 4880. OpenPGP Armor is // very similar to PEM except that it has an additional CRC checksum. +// +// Deprecated: this package is unmaintained except for security fixes. New +// applications should consider a more focused, modern alternative to OpenPGP +// for their specific task. If you are required to interoperate with OpenPGP +// systems and need a maintained package, consider a community fork. +// See https://golang.org/issue/44226. package armor // import "golang.org/x/crypto/openpgp/armor" import ( diff --git a/vendor/golang.org/x/crypto/openpgp/clearsign/clearsign.go b/vendor/golang.org/x/crypto/openpgp/clearsign/clearsign.go index c360460219..644b2e078b 100644 --- a/vendor/golang.org/x/crypto/openpgp/clearsign/clearsign.go +++ b/vendor/golang.org/x/crypto/openpgp/clearsign/clearsign.go @@ -7,6 +7,12 @@ // // Clearsigned messages are cryptographically signed, but the contents of the // message are kept in plaintext so that it can be read without special tools. +// +// Deprecated: this package is unmaintained except for security fixes. New +// applications should consider a more focused, modern alternative to OpenPGP +// for their specific task. If you are required to interoperate with OpenPGP +// systems and need a maintained package, consider a community fork. +// See https://golang.org/issue/44226. package clearsign // import "golang.org/x/crypto/openpgp/clearsign" import ( diff --git a/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go b/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go index 72a6a73947..84396a0896 100644 --- a/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go +++ b/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go @@ -10,6 +10,12 @@ // This form of ElGamal embeds PKCS#1 v1.5 padding, which may make it // unsuitable for other protocols. RSA should be used in preference in any // case. +// +// Deprecated: this package was only provided to support ElGamal encryption in +// OpenPGP. The golang.org/x/crypto/openpgp package is now deprecated (see +// https://golang.org/issue/44226), and ElGamal in the OpenPGP ecosystem has +// compatibility and security issues (see https://eprint.iacr.org/2021/923). +// Moreover, this package doesn't protect against side-channel attacks. package elgamal // import "golang.org/x/crypto/openpgp/elgamal" import ( diff --git a/vendor/golang.org/x/crypto/openpgp/errors/errors.go b/vendor/golang.org/x/crypto/openpgp/errors/errors.go index eb0550b2d0..1d7a0ea05a 100644 --- a/vendor/golang.org/x/crypto/openpgp/errors/errors.go +++ b/vendor/golang.org/x/crypto/openpgp/errors/errors.go @@ -3,6 +3,12 @@ // license that can be found in the LICENSE file. // Package errors contains common error types for the OpenPGP packages. +// +// Deprecated: this package is unmaintained except for security fixes. New +// applications should consider a more focused, modern alternative to OpenPGP +// for their specific task. If you are required to interoperate with OpenPGP +// systems and need a maintained package, consider a community fork. +// See https://golang.org/issue/44226. package errors // import "golang.org/x/crypto/openpgp/errors" import ( diff --git a/vendor/golang.org/x/crypto/openpgp/packet/packet.go b/vendor/golang.org/x/crypto/openpgp/packet/packet.go index 9728d61d7a..0a19794a8e 100644 --- a/vendor/golang.org/x/crypto/openpgp/packet/packet.go +++ b/vendor/golang.org/x/crypto/openpgp/packet/packet.go @@ -4,6 +4,12 @@ // Package packet implements parsing and serialization of OpenPGP packets, as // specified in RFC 4880. +// +// Deprecated: this package is unmaintained except for security fixes. New +// applications should consider a more focused, modern alternative to OpenPGP +// for their specific task. If you are required to interoperate with OpenPGP +// systems and need a maintained package, consider a community fork. +// See https://golang.org/issue/44226. package packet // import "golang.org/x/crypto/openpgp/packet" import ( diff --git a/vendor/golang.org/x/crypto/openpgp/read.go b/vendor/golang.org/x/crypto/openpgp/read.go index 6ec664f44a..48a8931468 100644 --- a/vendor/golang.org/x/crypto/openpgp/read.go +++ b/vendor/golang.org/x/crypto/openpgp/read.go @@ -3,6 +3,12 @@ // license that can be found in the LICENSE file. // Package openpgp implements high level operations on OpenPGP messages. +// +// Deprecated: this package is unmaintained except for security fixes. New +// applications should consider a more focused, modern alternative to OpenPGP +// for their specific task. If you are required to interoperate with OpenPGP +// systems and need a maintained package, consider a community fork. +// See https://golang.org/issue/44226. package openpgp // import "golang.org/x/crypto/openpgp" import ( diff --git a/vendor/golang.org/x/crypto/openpgp/s2k/s2k.go b/vendor/golang.org/x/crypto/openpgp/s2k/s2k.go index 4b9a44ca26..9de04958ea 100644 --- a/vendor/golang.org/x/crypto/openpgp/s2k/s2k.go +++ b/vendor/golang.org/x/crypto/openpgp/s2k/s2k.go @@ -4,6 +4,12 @@ // Package s2k implements the various OpenPGP string-to-key transforms as // specified in RFC 4800 section 3.7.1. +// +// Deprecated: this package is unmaintained except for security fixes. New +// applications should consider a more focused, modern alternative to OpenPGP +// for their specific task. If you are required to interoperate with OpenPGP +// systems and need a maintained package, consider a community fork. +// See https://golang.org/issue/44226. package s2k // import "golang.org/x/crypto/openpgp/s2k" import ( diff --git a/vendor/golang.org/x/net/http/httpproxy/proxy.go b/vendor/golang.org/x/net/http/httpproxy/proxy.go index 1415b07791..d2c8c87eab 100644 --- a/vendor/golang.org/x/net/http/httpproxy/proxy.go +++ b/vendor/golang.org/x/net/http/httpproxy/proxy.go @@ -113,8 +113,8 @@ func getEnvAny(names ...string) string { // environment, or a proxy should not be used for the given request, as // defined by NO_PROXY. // -// As a special case, if req.URL.Host is "localhost" (with or without a -// port number), then a nil URL and nil error will be returned. +// As a special case, if req.URL.Host is "localhost" or a loopback address +// (with or without a port number), then a nil URL and nil error will be returned. func (cfg *Config) ProxyFunc() func(reqURL *url.URL) (*url.URL, error) { // Preprocess the Config settings for more efficient evaluation. cfg1 := &config{ diff --git a/vendor/golang.org/x/net/http2/client_conn_pool.go b/vendor/golang.org/x/net/http2/client_conn_pool.go index 652bc11a02..c936843eaf 100644 --- a/vendor/golang.org/x/net/http2/client_conn_pool.go +++ b/vendor/golang.org/x/net/http2/client_conn_pool.go @@ -16,6 +16,12 @@ import ( // ClientConnPool manages a pool of HTTP/2 client connections. type ClientConnPool interface { + // GetClientConn returns a specific HTTP/2 connection (usually + // a TLS-TCP connection) to an HTTP/2 server. On success, the + // returned ClientConn accounts for the upcoming RoundTrip + // call, so the caller should not omit it. If the caller needs + // to, ClientConn.RoundTrip can be called with a bogus + // new(http.Request) to release the stream reservation. GetClientConn(req *http.Request, addr string) (*ClientConn, error) MarkDead(*ClientConn) } @@ -42,7 +48,7 @@ type clientConnPool struct { conns map[string][]*ClientConn // key is host:port dialing map[string]*dialCall // currently in-flight dials keys map[*ClientConn][]string - addConnCalls map[string]*addConnCall // in-flight addConnIfNeede calls + addConnCalls map[string]*addConnCall // in-flight addConnIfNeeded calls } func (p *clientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) { @@ -54,28 +60,8 @@ const ( noDialOnMiss = false ) -// shouldTraceGetConn reports whether getClientConn should call any -// ClientTrace.GetConn hook associated with the http.Request. -// -// This complexity is needed to avoid double calls of the GetConn hook -// during the back-and-forth between net/http and x/net/http2 (when the -// net/http.Transport is upgraded to also speak http2), as well as support -// the case where x/net/http2 is being used directly. -func (p *clientConnPool) shouldTraceGetConn(st clientConnIdleState) bool { - // If our Transport wasn't made via ConfigureTransport, always - // trace the GetConn hook if provided, because that means the - // http2 package is being used directly and it's the one - // dialing, as opposed to net/http. - if _, ok := p.t.ConnPool.(noDialClientConnPool); !ok { - return true - } - // Otherwise, only use the GetConn hook if this connection has - // been used previously for other requests. For fresh - // connections, the net/http package does the dialing. - return !st.freshConn -} - func (p *clientConnPool) getClientConn(req *http.Request, addr string, dialOnMiss bool) (*ClientConn, error) { + // TODO(dneil): Dial a new connection when t.DisableKeepAlives is set? if isConnectionCloseRequest(req) && dialOnMiss { // It gets its own connection. traceGetConn(req, addr) @@ -89,10 +75,14 @@ func (p *clientConnPool) getClientConn(req *http.Request, addr string, dialOnMis for { p.mu.Lock() for _, cc := range p.conns[addr] { - if st := cc.idleState(); st.canTakeNewRequest { - if p.shouldTraceGetConn(st) { + if cc.ReserveNewRequest() { + // When a connection is presented to us by the net/http package, + // the GetConn hook has already been called. + // Don't call it a second time here. + if !cc.getConnCalled { traceGetConn(req, addr) } + cc.getConnCalled = false p.mu.Unlock() return cc, nil } @@ -108,7 +98,13 @@ func (p *clientConnPool) getClientConn(req *http.Request, addr string, dialOnMis if shouldRetryDial(call, req) { continue } - return call.res, call.err + cc, err := call.res, call.err + if err != nil { + return nil, err + } + if cc.ReserveNewRequest() { + return cc, nil + } } } @@ -205,6 +201,7 @@ func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) { if err != nil { c.err = err } else { + cc.getConnCalled = true // already called by the net/http package p.addConnLocked(key, cc) } delete(p.addConnCalls, key) diff --git a/vendor/golang.org/x/net/http2/errors.go b/vendor/golang.org/x/net/http2/errors.go index 71f2c46317..2663e5d287 100644 --- a/vendor/golang.org/x/net/http2/errors.go +++ b/vendor/golang.org/x/net/http2/errors.go @@ -53,6 +53,13 @@ func (e ErrCode) String() string { return fmt.Sprintf("unknown error code 0x%x", uint32(e)) } +func (e ErrCode) stringToken() string { + if s, ok := errCodeName[e]; ok { + return s + } + return fmt.Sprintf("ERR_UNKNOWN_%d", uint32(e)) +} + // ConnectionError is an error that results in the termination of the // entire connection. type ConnectionError ErrCode @@ -67,6 +74,11 @@ type StreamError struct { Cause error // optional additional detail } +// errFromPeer is a sentinel error value for StreamError.Cause to +// indicate that the StreamError was sent from the peer over the wire +// and wasn't locally generated in the Transport. +var errFromPeer = errors.New("received from peer") + func streamError(id uint32, code ErrCode) StreamError { return StreamError{StreamID: id, Code: code} } diff --git a/vendor/golang.org/x/net/http2/frame.go b/vendor/golang.org/x/net/http2/frame.go index 514c126c5f..96a7479052 100644 --- a/vendor/golang.org/x/net/http2/frame.go +++ b/vendor/golang.org/x/net/http2/frame.go @@ -122,7 +122,7 @@ var flagName = map[FrameType]map[Flags]string{ // a frameParser parses a frame given its FrameHeader and payload // bytes. The length of payload will always equal fh.Length (which // might be 0). -type frameParser func(fc *frameCache, fh FrameHeader, payload []byte) (Frame, error) +type frameParser func(fc *frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) var frameParsers = map[FrameType]frameParser{ FrameData: parseDataFrame, @@ -267,6 +267,11 @@ type Framer struct { lastFrame Frame errDetail error + // countError is a non-nil func that's called on a frame parse + // error with some unique error path token. It's initialized + // from Transport.CountError or Server.CountError. + countError func(errToken string) + // lastHeaderStream is non-zero if the last frame was an // unfinished HEADERS/CONTINUATION. lastHeaderStream uint32 @@ -426,6 +431,7 @@ func NewFramer(w io.Writer, r io.Reader) *Framer { fr := &Framer{ w: w, r: r, + countError: func(string) {}, logReads: logFrameReads, logWrites: logFrameWrites, debugReadLoggerf: log.Printf, @@ -500,7 +506,7 @@ func (fr *Framer) ReadFrame() (Frame, error) { if _, err := io.ReadFull(fr.r, payload); err != nil { return nil, err } - f, err := typeFrameParser(fh.Type)(fr.frameCache, fh, payload) + f, err := typeFrameParser(fh.Type)(fr.frameCache, fh, fr.countError, payload) if err != nil { if ce, ok := err.(connError); ok { return nil, fr.connError(ce.Code, ce.Reason) @@ -588,13 +594,14 @@ func (f *DataFrame) Data() []byte { return f.data } -func parseDataFrame(fc *frameCache, fh FrameHeader, payload []byte) (Frame, error) { +func parseDataFrame(fc *frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) { if fh.StreamID == 0 { // DATA frames MUST be associated with a stream. If a // DATA frame is received whose stream identifier // field is 0x0, the recipient MUST respond with a // connection error (Section 5.4.1) of type // PROTOCOL_ERROR. + countError("frame_data_stream_0") return nil, connError{ErrCodeProtocol, "DATA frame with stream ID 0"} } f := fc.getDataFrame() @@ -605,6 +612,7 @@ func parseDataFrame(fc *frameCache, fh FrameHeader, payload []byte) (Frame, erro var err error payload, padSize, err = readByte(payload) if err != nil { + countError("frame_data_pad_byte_short") return nil, err } } @@ -613,6 +621,7 @@ func parseDataFrame(fc *frameCache, fh FrameHeader, payload []byte) (Frame, erro // length of the frame payload, the recipient MUST // treat this as a connection error. // Filed: https://github.com/http2/http2-spec/issues/610 + countError("frame_data_pad_too_big") return nil, connError{ErrCodeProtocol, "pad size larger than data payload"} } f.data = payload[:len(payload)-int(padSize)] @@ -695,7 +704,7 @@ type SettingsFrame struct { p []byte } -func parseSettingsFrame(_ *frameCache, fh FrameHeader, p []byte) (Frame, error) { +func parseSettingsFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if fh.Flags.Has(FlagSettingsAck) && fh.Length > 0 { // When this (ACK 0x1) bit is set, the payload of the // SETTINGS frame MUST be empty. Receipt of a @@ -703,6 +712,7 @@ func parseSettingsFrame(_ *frameCache, fh FrameHeader, p []byte) (Frame, error) // field value other than 0 MUST be treated as a // connection error (Section 5.4.1) of type // FRAME_SIZE_ERROR. + countError("frame_settings_ack_with_length") return nil, ConnectionError(ErrCodeFrameSize) } if fh.StreamID != 0 { @@ -713,14 +723,17 @@ func parseSettingsFrame(_ *frameCache, fh FrameHeader, p []byte) (Frame, error) // field is anything other than 0x0, the endpoint MUST // respond with a connection error (Section 5.4.1) of // type PROTOCOL_ERROR. + countError("frame_settings_has_stream") return nil, ConnectionError(ErrCodeProtocol) } if len(p)%6 != 0 { + countError("frame_settings_mod_6") // Expecting even number of 6 byte settings. return nil, ConnectionError(ErrCodeFrameSize) } f := &SettingsFrame{FrameHeader: fh, p: p} if v, ok := f.Value(SettingInitialWindowSize); ok && v > (1<<31)-1 { + countError("frame_settings_window_size_too_big") // Values above the maximum flow control window size of 2^31 - 1 MUST // be treated as a connection error (Section 5.4.1) of type // FLOW_CONTROL_ERROR. @@ -832,11 +845,13 @@ type PingFrame struct { func (f *PingFrame) IsAck() bool { return f.Flags.Has(FlagPingAck) } -func parsePingFrame(_ *frameCache, fh FrameHeader, payload []byte) (Frame, error) { +func parsePingFrame(_ *frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) { if len(payload) != 8 { + countError("frame_ping_length") return nil, ConnectionError(ErrCodeFrameSize) } if fh.StreamID != 0 { + countError("frame_ping_has_stream") return nil, ConnectionError(ErrCodeProtocol) } f := &PingFrame{FrameHeader: fh} @@ -872,11 +887,13 @@ func (f *GoAwayFrame) DebugData() []byte { return f.debugData } -func parseGoAwayFrame(_ *frameCache, fh FrameHeader, p []byte) (Frame, error) { +func parseGoAwayFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if fh.StreamID != 0 { + countError("frame_goaway_has_stream") return nil, ConnectionError(ErrCodeProtocol) } if len(p) < 8 { + countError("frame_goaway_short") return nil, ConnectionError(ErrCodeFrameSize) } return &GoAwayFrame{ @@ -912,7 +929,7 @@ func (f *UnknownFrame) Payload() []byte { return f.p } -func parseUnknownFrame(_ *frameCache, fh FrameHeader, p []byte) (Frame, error) { +func parseUnknownFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { return &UnknownFrame{fh, p}, nil } @@ -923,8 +940,9 @@ type WindowUpdateFrame struct { Increment uint32 // never read with high bit set } -func parseWindowUpdateFrame(_ *frameCache, fh FrameHeader, p []byte) (Frame, error) { +func parseWindowUpdateFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if len(p) != 4 { + countError("frame_windowupdate_bad_len") return nil, ConnectionError(ErrCodeFrameSize) } inc := binary.BigEndian.Uint32(p[:4]) & 0x7fffffff // mask off high reserved bit @@ -936,8 +954,10 @@ func parseWindowUpdateFrame(_ *frameCache, fh FrameHeader, p []byte) (Frame, err // control window MUST be treated as a connection // error (Section 5.4.1). if fh.StreamID == 0 { + countError("frame_windowupdate_zero_inc_conn") return nil, ConnectionError(ErrCodeProtocol) } + countError("frame_windowupdate_zero_inc_stream") return nil, streamError(fh.StreamID, ErrCodeProtocol) } return &WindowUpdateFrame{ @@ -988,7 +1008,7 @@ func (f *HeadersFrame) HasPriority() bool { return f.FrameHeader.Flags.Has(FlagHeadersPriority) } -func parseHeadersFrame(_ *frameCache, fh FrameHeader, p []byte) (_ Frame, err error) { +func parseHeadersFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (_ Frame, err error) { hf := &HeadersFrame{ FrameHeader: fh, } @@ -997,11 +1017,13 @@ func parseHeadersFrame(_ *frameCache, fh FrameHeader, p []byte) (_ Frame, err er // is received whose stream identifier field is 0x0, the recipient MUST // respond with a connection error (Section 5.4.1) of type // PROTOCOL_ERROR. + countError("frame_headers_zero_stream") return nil, connError{ErrCodeProtocol, "HEADERS frame with stream ID 0"} } var padLength uint8 if fh.Flags.Has(FlagHeadersPadded) { if p, padLength, err = readByte(p); err != nil { + countError("frame_headers_pad_short") return } } @@ -1009,16 +1031,19 @@ func parseHeadersFrame(_ *frameCache, fh FrameHeader, p []byte) (_ Frame, err er var v uint32 p, v, err = readUint32(p) if err != nil { + countError("frame_headers_prio_short") return nil, err } hf.Priority.StreamDep = v & 0x7fffffff hf.Priority.Exclusive = (v != hf.Priority.StreamDep) // high bit was set p, hf.Priority.Weight, err = readByte(p) if err != nil { + countError("frame_headers_prio_weight_short") return nil, err } } - if len(p)-int(padLength) <= 0 { + if len(p)-int(padLength) < 0 { + countError("frame_headers_pad_too_big") return nil, streamError(fh.StreamID, ErrCodeProtocol) } hf.headerFragBuf = p[:len(p)-int(padLength)] @@ -1125,11 +1150,13 @@ func (p PriorityParam) IsZero() bool { return p == PriorityParam{} } -func parsePriorityFrame(_ *frameCache, fh FrameHeader, payload []byte) (Frame, error) { +func parsePriorityFrame(_ *frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) { if fh.StreamID == 0 { + countError("frame_priority_zero_stream") return nil, connError{ErrCodeProtocol, "PRIORITY frame with stream ID 0"} } if len(payload) != 5 { + countError("frame_priority_bad_length") return nil, connError{ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))} } v := binary.BigEndian.Uint32(payload[:4]) @@ -1172,11 +1199,13 @@ type RSTStreamFrame struct { ErrCode ErrCode } -func parseRSTStreamFrame(_ *frameCache, fh FrameHeader, p []byte) (Frame, error) { +func parseRSTStreamFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if len(p) != 4 { + countError("frame_rststream_bad_len") return nil, ConnectionError(ErrCodeFrameSize) } if fh.StreamID == 0 { + countError("frame_rststream_zero_stream") return nil, ConnectionError(ErrCodeProtocol) } return &RSTStreamFrame{fh, ErrCode(binary.BigEndian.Uint32(p[:4]))}, nil @@ -1202,8 +1231,9 @@ type ContinuationFrame struct { headerFragBuf []byte } -func parseContinuationFrame(_ *frameCache, fh FrameHeader, p []byte) (Frame, error) { +func parseContinuationFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if fh.StreamID == 0 { + countError("frame_continuation_zero_stream") return nil, connError{ErrCodeProtocol, "CONTINUATION frame with stream ID 0"} } return &ContinuationFrame{fh, p}, nil @@ -1252,7 +1282,7 @@ func (f *PushPromiseFrame) HeadersEnded() bool { return f.FrameHeader.Flags.Has(FlagPushPromiseEndHeaders) } -func parsePushPromise(_ *frameCache, fh FrameHeader, p []byte) (_ Frame, err error) { +func parsePushPromise(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (_ Frame, err error) { pp := &PushPromiseFrame{ FrameHeader: fh, } @@ -1263,6 +1293,7 @@ func parsePushPromise(_ *frameCache, fh FrameHeader, p []byte) (_ Frame, err err // with. If the stream identifier field specifies the value // 0x0, a recipient MUST respond with a connection error // (Section 5.4.1) of type PROTOCOL_ERROR. + countError("frame_pushpromise_zero_stream") return nil, ConnectionError(ErrCodeProtocol) } // The PUSH_PROMISE frame includes optional padding. @@ -1270,18 +1301,21 @@ func parsePushPromise(_ *frameCache, fh FrameHeader, p []byte) (_ Frame, err err var padLength uint8 if fh.Flags.Has(FlagPushPromisePadded) { if p, padLength, err = readByte(p); err != nil { + countError("frame_pushpromise_pad_short") return } } p, pp.PromiseID, err = readUint32(p) if err != nil { + countError("frame_pushpromise_promiseid_short") return } pp.PromiseID = pp.PromiseID & (1<<31 - 1) if int(padLength) > len(p) { // like the DATA frame, error out if padding is longer than the body. + countError("frame_pushpromise_pad_too_big") return nil, ConnectionError(ErrCodeProtocol) } pp.headerFragBuf = p[:len(p)-int(padLength)] diff --git a/vendor/golang.org/x/net/http2/hpack/huffman.go b/vendor/golang.org/x/net/http2/hpack/huffman.go index a1ab2f0567..fe0b84ccd4 100644 --- a/vendor/golang.org/x/net/http2/hpack/huffman.go +++ b/vendor/golang.org/x/net/http2/hpack/huffman.go @@ -140,25 +140,29 @@ func buildRootHuffmanNode() { panic("unexpected size") } lazyRootHuffmanNode = newInternalNode() - for i, code := range huffmanCodes { - addDecoderNode(byte(i), code, huffmanCodeLen[i]) - } -} + // allocate a leaf node for each of the 256 symbols + leaves := new([256]node) + + for sym, code := range huffmanCodes { + codeLen := huffmanCodeLen[sym] + + cur := lazyRootHuffmanNode + for codeLen > 8 { + codeLen -= 8 + i := uint8(code >> codeLen) + if cur.children[i] == nil { + cur.children[i] = newInternalNode() + } + cur = cur.children[i] + } + shift := 8 - codeLen + start, end := int(uint8(code< 8 { - codeLen -= 8 - i := uint8(code >> codeLen) - if cur.children[i] == nil { - cur.children[i] = newInternalNode() + leaves[sym].sym = byte(sym) + leaves[sym].codeLen = codeLen + for i := start; i < start+end; i++ { + cur.children[i] = &leaves[sym] } - cur = cur.children[i] - } - shift := 8 - codeLen - start, end := int(uint8(code< 0 { // Check whether the client has flow control quota. if st.inflow.available() < int32(f.Length) { - return streamError(id, ErrCodeFlowControl) + return sc.countError("flow_on_data_length", streamError(id, ErrCodeFlowControl)) } st.inflow.take(int32(f.Length)) @@ -1710,7 +1727,7 @@ func (sc *serverConn) processData(f *DataFrame) error { wrote, err := st.body.Write(data) if err != nil { sc.sendWindowUpdate(nil, int(f.Length)-wrote) - return streamError(id, ErrCodeStreamClosed) + return sc.countError("body_write_err", streamError(id, ErrCodeStreamClosed)) } if wrote != len(data) { panic("internal error: bad Writer") @@ -1796,7 +1813,7 @@ func (sc *serverConn) processHeaders(f *MetaHeadersFrame) error { // stream identifier MUST respond with a connection error // (Section 5.4.1) of type PROTOCOL_ERROR. if id%2 != 1 { - return ConnectionError(ErrCodeProtocol) + return sc.countError("headers_even", ConnectionError(ErrCodeProtocol)) } // A HEADERS frame can be used to create a new stream or // send a trailer for an open one. If we already have a stream @@ -1813,7 +1830,7 @@ func (sc *serverConn) processHeaders(f *MetaHeadersFrame) error { // this state, it MUST respond with a stream error (Section 5.4.2) of // type STREAM_CLOSED. if st.state == stateHalfClosedRemote { - return streamError(id, ErrCodeStreamClosed) + return sc.countError("headers_half_closed", streamError(id, ErrCodeStreamClosed)) } return st.processTrailerHeaders(f) } @@ -1824,7 +1841,7 @@ func (sc *serverConn) processHeaders(f *MetaHeadersFrame) error { // receives an unexpected stream identifier MUST respond with // a connection error (Section 5.4.1) of type PROTOCOL_ERROR. if id <= sc.maxClientStreamID { - return ConnectionError(ErrCodeProtocol) + return sc.countError("stream_went_down", ConnectionError(ErrCodeProtocol)) } sc.maxClientStreamID = id @@ -1841,14 +1858,14 @@ func (sc *serverConn) processHeaders(f *MetaHeadersFrame) error { if sc.curClientStreams+1 > sc.advMaxStreams { if sc.unackedSettings == 0 { // They should know better. - return streamError(id, ErrCodeProtocol) + return sc.countError("over_max_streams", streamError(id, ErrCodeProtocol)) } // Assume it's a network race, where they just haven't // received our last SETTINGS update. But actually // this can't happen yet, because we don't yet provide // a way for users to adjust server parameters at // runtime. - return streamError(id, ErrCodeRefusedStream) + return sc.countError("over_max_streams_race", streamError(id, ErrCodeRefusedStream)) } initialState := stateOpen @@ -1858,7 +1875,7 @@ func (sc *serverConn) processHeaders(f *MetaHeadersFrame) error { st := sc.newStream(id, 0, initialState) if f.HasPriority() { - if err := checkPriority(f.StreamID, f.Priority); err != nil { + if err := sc.checkPriority(f.StreamID, f.Priority); err != nil { return err } sc.writeSched.AdjustStream(st.id, f.Priority) @@ -1902,15 +1919,15 @@ func (st *stream) processTrailerHeaders(f *MetaHeadersFrame) error { sc := st.sc sc.serveG.check() if st.gotTrailerHeader { - return ConnectionError(ErrCodeProtocol) + return sc.countError("dup_trailers", ConnectionError(ErrCodeProtocol)) } st.gotTrailerHeader = true if !f.StreamEnded() { - return streamError(st.id, ErrCodeProtocol) + return sc.countError("trailers_not_ended", streamError(st.id, ErrCodeProtocol)) } if len(f.PseudoFields()) > 0 { - return streamError(st.id, ErrCodeProtocol) + return sc.countError("trailers_pseudo", streamError(st.id, ErrCodeProtocol)) } if st.trailer != nil { for _, hf := range f.RegularFields() { @@ -1919,7 +1936,7 @@ func (st *stream) processTrailerHeaders(f *MetaHeadersFrame) error { // TODO: send more details to the peer somehow. But http2 has // no way to send debug data at a stream level. Discuss with // HTTP folk. - return streamError(st.id, ErrCodeProtocol) + return sc.countError("trailers_bogus", streamError(st.id, ErrCodeProtocol)) } st.trailer[key] = append(st.trailer[key], hf.Value) } @@ -1928,13 +1945,13 @@ func (st *stream) processTrailerHeaders(f *MetaHeadersFrame) error { return nil } -func checkPriority(streamID uint32, p PriorityParam) error { +func (sc *serverConn) checkPriority(streamID uint32, p PriorityParam) error { if streamID == p.StreamDep { // Section 5.3.1: "A stream cannot depend on itself. An endpoint MUST treat // this as a stream error (Section 5.4.2) of type PROTOCOL_ERROR." // Section 5.3.3 says that a stream can depend on one of its dependencies, // so it's only self-dependencies that are forbidden. - return streamError(streamID, ErrCodeProtocol) + return sc.countError("priority", streamError(streamID, ErrCodeProtocol)) } return nil } @@ -1943,7 +1960,7 @@ func (sc *serverConn) processPriority(f *PriorityFrame) error { if sc.inGoAway { return nil } - if err := checkPriority(f.StreamID, f.PriorityParam); err != nil { + if err := sc.checkPriority(f.StreamID, f.PriorityParam); err != nil { return err } sc.writeSched.AdjustStream(f.StreamID, f.PriorityParam) @@ -2000,7 +2017,7 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res isConnect := rp.method == "CONNECT" if isConnect { if rp.path != "" || rp.scheme != "" || rp.authority == "" { - return nil, nil, streamError(f.StreamID, ErrCodeProtocol) + return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) } } else if rp.method == "" || rp.path == "" || (rp.scheme != "https" && rp.scheme != "http") { // See 8.1.2.6 Malformed Requests and Responses: @@ -2013,13 +2030,13 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res // "All HTTP/2 requests MUST include exactly one valid // value for the :method, :scheme, and :path // pseudo-header fields" - return nil, nil, streamError(f.StreamID, ErrCodeProtocol) + return nil, nil, sc.countError("bad_path_method", streamError(f.StreamID, ErrCodeProtocol)) } bodyOpen := !f.StreamEnded() if rp.method == "HEAD" && bodyOpen { // HEAD requests can't have bodies - return nil, nil, streamError(f.StreamID, ErrCodeProtocol) + return nil, nil, sc.countError("head_body", streamError(f.StreamID, ErrCodeProtocol)) } rp.header = make(http.Header) @@ -2102,7 +2119,7 @@ func (sc *serverConn) newWriterAndRequestNoBody(st *stream, rp requestParam) (*r var err error url_, err = url.ParseRequestURI(rp.path) if err != nil { - return nil, nil, streamError(st.id, ErrCodeProtocol) + return nil, nil, sc.countError("bad_path", streamError(st.id, ErrCodeProtocol)) } requestURI = rp.path } @@ -2985,3 +3002,31 @@ func h1ServerKeepAlivesDisabled(hs *http.Server) bool { } return false } + +func (sc *serverConn) countError(name string, err error) error { + if sc == nil || sc.srv == nil { + return err + } + f := sc.srv.CountError + if f == nil { + return err + } + var typ string + var code ErrCode + switch e := err.(type) { + case ConnectionError: + typ = "conn" + code = ErrCode(e) + case StreamError: + typ = "stream" + code = ErrCode(e.Code) + default: + return err + } + codeStr := errCodeName[code] + if codeStr == "" { + codeStr = strconv.Itoa(int(code)) + } + f(fmt.Sprintf("%s_%s_%s", typ, codeStr, name)) + return err +} diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go index b261beb1d0..f135b0f751 100644 --- a/vendor/golang.org/x/net/http2/transport.go +++ b/vendor/golang.org/x/net/http2/transport.go @@ -24,6 +24,7 @@ import ( "net/http" "net/http/httptrace" "net/textproto" + "os" "sort" "strconv" "strings" @@ -51,6 +52,15 @@ const ( transportDefaultStreamMinRefresh = 4 << 10 defaultUserAgent = "Go-http-client/2.0" + + // initialMaxConcurrentStreams is a connections maxConcurrentStreams until + // it's received servers initial SETTINGS frame, which corresponds with the + // spec's minimum recommended value. + initialMaxConcurrentStreams = 100 + + // defaultMaxConcurrentStreams is a connections default maxConcurrentStreams + // if the server doesn't include one in its initial SETTINGS frame. + defaultMaxConcurrentStreams = 1000 ) // Transport is an HTTP/2 Transport. @@ -121,6 +131,17 @@ type Transport struct { // Defaults to 15s. PingTimeout time.Duration + // WriteByteTimeout is the timeout after which the connection will be + // closed no data can be written to it. The timeout begins when data is + // available to write, and is extended whenever any bytes are written. + WriteByteTimeout time.Duration + + // CountError, if non-nil, is called on HTTP/2 transport errors. + // It's intended to increment a metric for monitoring, such + // as an expvar or Prometheus metric. + // The errType consists of only ASCII word characters. + CountError func(errType string) + // t1, if non-nil, is the standard library Transport using // this transport. Its settings are used (but not its // RoundTrip method, etc). @@ -227,11 +248,12 @@ func (t *Transport) initConnPool() { // ClientConn is the state of a single HTTP/2 client connection to an // HTTP/2 server. type ClientConn struct { - t *Transport - tconn net.Conn // usually *tls.Conn, except specialized impls - tlsState *tls.ConnectionState // nil only for specialized impls - reused uint32 // whether conn is being reused; atomic - singleUse bool // whether being used for a single http.Request + t *Transport + tconn net.Conn // usually *tls.Conn, except specialized impls + tlsState *tls.ConnectionState // nil only for specialized impls + reused uint32 // whether conn is being reused; atomic + singleUse bool // whether being used for a single http.Request + getConnCalled bool // used by clientConnPool // readLoop goroutine fields: readerDone chan struct{} // closed on error @@ -244,86 +266,94 @@ type ClientConn struct { cond *sync.Cond // hold mu; broadcast on flow/closed changes flow flow // our conn-level flow control quota (cs.flow is per stream) inflow flow // peer's conn-level flow control + doNotReuse bool // whether conn is marked to not be reused for any future requests closing bool closed bool + seenSettings bool // true if we've seen a settings frame, false otherwise wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received goAwayDebug string // goAway frame's debug data, retained as a string streams map[uint32]*clientStream // client-initiated + streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip nextStreamID uint32 pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams pings map[[8]byte]chan struct{} // in flight ping data to notification channel - bw *bufio.Writer br *bufio.Reader - fr *Framer lastActive time.Time lastIdle time.Time // time last idle - // Settings from peer: (also guarded by mu) + // Settings from peer: (also guarded by wmu) maxFrameSize uint32 maxConcurrentStreams uint32 peerMaxHeaderListSize uint64 initialWindowSize uint32 + // reqHeaderMu is a 1-element semaphore channel controlling access to sending new requests. + // Write to reqHeaderMu to lock it, read from it to unlock. + // Lock reqmu BEFORE mu or wmu. + reqHeaderMu chan struct{} + + // wmu is held while writing. + // Acquire BEFORE mu when holding both, to avoid blocking mu on network writes. + // Only acquire both at the same time when changing peer settings. + wmu sync.Mutex + bw *bufio.Writer + fr *Framer + werr error // first write error that has occurred hbuf bytes.Buffer // HPACK encoder writes into this henc *hpack.Encoder - - wmu sync.Mutex // held while writing; acquire AFTER mu if holding both - werr error // first write error that has occurred } // clientStream is the state for a single HTTP/2 stream. One of these // is created for each Transport.RoundTrip call. type clientStream struct { - cc *ClientConn - req *http.Request + cc *ClientConn + + // Fields of Request that we may access even after the response body is closed. + ctx context.Context + reqCancel <-chan struct{} + trace *httptrace.ClientTrace // or nil ID uint32 - resc chan resAndError bufPipe pipe // buffered pipe with the flow-controlled response payload - startedWrite bool // started request body write; guarded by cc.mu requestedGzip bool - on100 func() // optional code to run if get a 100 continue response + isHead bool + + abortOnce sync.Once + abort chan struct{} // closed to signal stream should end immediately + abortErr error // set if abort is closed + + peerClosed chan struct{} // closed when the peer sends an END_STREAM flag + donec chan struct{} // closed after the stream is in the closed state + on100 chan struct{} // buffered; written to if a 100 is received + + respHeaderRecv chan struct{} // closed when headers are received + res *http.Response // set if respHeaderRecv is closed flow flow // guarded by cc.mu inflow flow // guarded by cc.mu bytesRemain int64 // -1 means unknown; owned by transportResponseBody.Read readErr error // sticky read error; owned by transportResponseBody.Read - stopReqBody error // if non-nil, stop writing req body; guarded by cc.mu - didReset bool // whether we sent a RST_STREAM to the server; guarded by cc.mu - peerReset chan struct{} // closed on peer reset - resetErr error // populated before peerReset is closed + reqBody io.ReadCloser + reqBodyContentLength int64 // -1 means unknown + reqBodyClosed bool // body has been closed; guarded by cc.mu - done chan struct{} // closed when stream remove from cc.streams map; close calls guarded by cc.mu + // owned by writeRequest: + sentEndStream bool // sent an END_STREAM flag to the peer + sentHeaders bool // owned by clientConnReadLoop: firstByte bool // got the first response byte pastHeaders bool // got first MetaHeadersFrame (actual headers) pastTrailers bool // got optional second MetaHeadersFrame (trailers) num1xx uint8 // number of 1xx responses seen + readClosed bool // peer sent an END_STREAM flag + readAborted bool // read loop reset the stream trailer http.Header // accumulated trailers resTrailer *http.Header // client's Response.Trailer } -// awaitRequestCancel waits for the user to cancel a request or for the done -// channel to be signaled. A non-nil error is returned only if the request was -// canceled. -func awaitRequestCancel(req *http.Request, done <-chan struct{}) error { - ctx := req.Context() - if req.Cancel == nil && ctx.Done() == nil { - return nil - } - select { - case <-req.Cancel: - return errRequestCanceled - case <-ctx.Done(): - return ctx.Err() - case <-done: - return nil - } -} - var got1xxFuncForTests func(int, textproto.MIMEHeader) error // get1xxTraceFunc returns the value of request's httptrace.ClientTrace.Got1xxResponse func, @@ -335,78 +365,65 @@ func (cs *clientStream) get1xxTraceFunc() func(int, textproto.MIMEHeader) error return traceGot1xxResponseFunc(cs.trace) } -// awaitRequestCancel waits for the user to cancel a request, its context to -// expire, or for the request to be done (any way it might be removed from the -// cc.streams map: peer reset, successful completion, TCP connection breakage, -// etc). If the request is canceled, then cs will be canceled and closed. -func (cs *clientStream) awaitRequestCancel(req *http.Request) { - if err := awaitRequestCancel(req, cs.done); err != nil { - cs.cancelStream() - cs.bufPipe.CloseWithError(err) - } +func (cs *clientStream) abortStream(err error) { + cs.cc.mu.Lock() + defer cs.cc.mu.Unlock() + cs.abortStreamLocked(err) } -func (cs *clientStream) cancelStream() { - cc := cs.cc - cc.mu.Lock() - didReset := cs.didReset - cs.didReset = true - cc.mu.Unlock() - - if !didReset { - cc.writeStreamReset(cs.ID, ErrCodeCancel, nil) - cc.forgetStreamID(cs.ID) +func (cs *clientStream) abortStreamLocked(err error) { + cs.abortOnce.Do(func() { + cs.abortErr = err + close(cs.abort) + }) + if cs.reqBody != nil && !cs.reqBodyClosed { + cs.reqBody.Close() + cs.reqBodyClosed = true } -} - -// checkResetOrDone reports any error sent in a RST_STREAM frame by the -// server, or errStreamClosed if the stream is complete. -func (cs *clientStream) checkResetOrDone() error { - select { - case <-cs.peerReset: - return cs.resetErr - case <-cs.done: - return errStreamClosed - default: - return nil + // TODO(dneil): Clean up tests where cs.cc.cond is nil. + if cs.cc.cond != nil { + // Wake up writeRequestBody if it is waiting on flow control. + cs.cc.cond.Broadcast() } } -func (cs *clientStream) getStartedWrite() bool { +func (cs *clientStream) abortRequestBodyWrite() { cc := cs.cc cc.mu.Lock() defer cc.mu.Unlock() - return cs.startedWrite -} - -func (cs *clientStream) abortRequestBodyWrite(err error) { - if err == nil { - panic("nil error") - } - cc := cs.cc - cc.mu.Lock() - if cs.stopReqBody == nil { - cs.stopReqBody = err - if cs.req.Body != nil { - cs.req.Body.Close() - } + if cs.reqBody != nil && !cs.reqBodyClosed { + cs.reqBody.Close() + cs.reqBodyClosed = true cc.cond.Broadcast() } - cc.mu.Unlock() } type stickyErrWriter struct { - w io.Writer - err *error + conn net.Conn + timeout time.Duration + err *error } func (sew stickyErrWriter) Write(p []byte) (n int, err error) { if *sew.err != nil { return 0, *sew.err } - n, err = sew.w.Write(p) - *sew.err = err - return + for { + if sew.timeout != 0 { + sew.conn.SetWriteDeadline(time.Now().Add(sew.timeout)) + } + nn, err := sew.conn.Write(p[n:]) + n += nn + if n < len(p) && nn > 0 && errors.Is(err, os.ErrDeadlineExceeded) { + // Keep extending the deadline so long as we're making progress. + continue + } + if sew.timeout != 0 { + sew.conn.SetWriteDeadline(time.Time{}) + } + *sew.err = err + return n, err + } } // noCachedConnError is the concrete type of ErrNoCachedConn, which @@ -479,9 +496,9 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res } reused := !atomic.CompareAndSwapUint32(&cc.reused, 0, 1) traceGotConn(req, cc, reused) - res, gotErrAfterReqBodyWrite, err := cc.roundTrip(req) + res, err := cc.RoundTrip(req) if err != nil && retry <= 6 { - if req, err = shouldRetryRequest(req, err, gotErrAfterReqBodyWrite); err == nil { + if req, err = shouldRetryRequest(req, err); err == nil { // After the first retry, do exponential backoff with 10% jitter. if retry == 0 { continue @@ -492,7 +509,7 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res case <-time.After(time.Second * time.Duration(backoff)): continue case <-req.Context().Done(): - return nil, req.Context().Err() + err = req.Context().Err() } } } @@ -523,7 +540,7 @@ var ( // response headers. It is always called with a non-nil error. // It returns either a request to retry (either the same request, or a // modified clone), or an error if the request can't be replayed. -func shouldRetryRequest(req *http.Request, err error, afterBodyWrite bool) (*http.Request, error) { +func shouldRetryRequest(req *http.Request, err error) (*http.Request, error) { if !canRetryError(err) { return nil, err } @@ -536,7 +553,6 @@ func shouldRetryRequest(req *http.Request, err error, afterBodyWrite bool) (*htt // If the request body can be reset back to its original // state via the optional req.GetBody, do that. if req.GetBody != nil { - // TODO: consider a req.Body.Close here? or audit that all caller paths do? body, err := req.GetBody() if err != nil { return nil, err @@ -548,10 +564,8 @@ func shouldRetryRequest(req *http.Request, err error, afterBodyWrite bool) (*htt // The Request.Body can't reset back to the beginning, but we // don't seem to have started to read from it yet, so reuse - // the request directly. The "afterBodyWrite" means the - // bodyWrite process has started, which becomes true before - // the first Read. - if !afterBodyWrite { + // the request directly. + if err == errClientConnUnusable { return req, nil } @@ -563,6 +577,10 @@ func canRetryError(err error) bool { return true } if se, ok := err.(StreamError); ok { + if se.Code == ErrCodeProtocol && se.Cause == errFromPeer { + // See golang/go#47635, golang/go#42777 + return true + } return se.Code == ErrCodeRefusedStream } return false @@ -637,14 +655,15 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro tconn: c, readerDone: make(chan struct{}), nextStreamID: 1, - maxFrameSize: 16 << 10, // spec default - initialWindowSize: 65535, // spec default - maxConcurrentStreams: 1000, // "infinite", per spec. 1000 seems good enough. - peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. + maxFrameSize: 16 << 10, // spec default + initialWindowSize: 65535, // spec default + maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. + peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. streams: make(map[uint32]*clientStream), singleUse: singleUse, wantSettingsAck: true, pings: make(map[[8]byte]chan struct{}), + reqHeaderMu: make(chan struct{}, 1), } if d := t.idleConnTimeout(); d != 0 { cc.idleTimeout = d @@ -659,9 +678,16 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro // TODO: adjust this writer size to account for frame size + // MTU + crypto/tls record padding. - cc.bw = bufio.NewWriter(stickyErrWriter{c, &cc.werr}) + cc.bw = bufio.NewWriter(stickyErrWriter{ + conn: c, + timeout: t.WriteByteTimeout, + err: &cc.werr, + }) cc.br = bufio.NewReader(c) cc.fr = NewFramer(cc.bw, cc.br) + if t.CountError != nil { + cc.fr.countError = t.CountError + } cc.fr.ReadMetaHeaders = hpack.NewDecoder(initialHeaderTableSize, nil) cc.fr.MaxHeaderListSize = t.maxHeaderListSize() @@ -714,6 +740,13 @@ func (cc *ClientConn) healthCheck() { } } +// SetDoNotReuse marks cc as not reusable for future HTTP requests. +func (cc *ClientConn) SetDoNotReuse() { + cc.mu.Lock() + defer cc.mu.Unlock() + cc.doNotReuse = true +} + func (cc *ClientConn) setGoAway(f *GoAwayFrame) { cc.mu.Lock() defer cc.mu.Unlock() @@ -731,27 +764,94 @@ func (cc *ClientConn) setGoAway(f *GoAwayFrame) { last := f.LastStreamID for streamID, cs := range cc.streams { if streamID > last { - select { - case cs.resc <- resAndError{err: errClientConnGotGoAway}: - default: - } + cs.abortStreamLocked(errClientConnGotGoAway) } } } // CanTakeNewRequest reports whether the connection can take a new request, // meaning it has not been closed or received or sent a GOAWAY. +// +// If the caller is going to immediately make a new request on this +// connection, use ReserveNewRequest instead. func (cc *ClientConn) CanTakeNewRequest() bool { cc.mu.Lock() defer cc.mu.Unlock() return cc.canTakeNewRequestLocked() } +// ReserveNewRequest is like CanTakeNewRequest but also reserves a +// concurrent stream in cc. The reservation is decremented on the +// next call to RoundTrip. +func (cc *ClientConn) ReserveNewRequest() bool { + cc.mu.Lock() + defer cc.mu.Unlock() + if st := cc.idleStateLocked(); !st.canTakeNewRequest { + return false + } + cc.streamsReserved++ + return true +} + +// ClientConnState describes the state of a ClientConn. +type ClientConnState struct { + // Closed is whether the connection is closed. + Closed bool + + // Closing is whether the connection is in the process of + // closing. It may be closing due to shutdown, being a + // single-use connection, being marked as DoNotReuse, or + // having received a GOAWAY frame. + Closing bool + + // StreamsActive is how many streams are active. + StreamsActive int + + // StreamsReserved is how many streams have been reserved via + // ClientConn.ReserveNewRequest. + StreamsReserved int + + // StreamsPending is how many requests have been sent in excess + // of the peer's advertised MaxConcurrentStreams setting and + // are waiting for other streams to complete. + StreamsPending int + + // MaxConcurrentStreams is how many concurrent streams the + // peer advertised as acceptable. Zero means no SETTINGS + // frame has been received yet. + MaxConcurrentStreams uint32 + + // LastIdle, if non-zero, is when the connection last + // transitioned to idle state. + LastIdle time.Time +} + +// State returns a snapshot of cc's state. +func (cc *ClientConn) State() ClientConnState { + cc.wmu.Lock() + maxConcurrent := cc.maxConcurrentStreams + if !cc.seenSettings { + maxConcurrent = 0 + } + cc.wmu.Unlock() + + cc.mu.Lock() + defer cc.mu.Unlock() + return ClientConnState{ + Closed: cc.closed, + Closing: cc.closing || cc.singleUse || cc.doNotReuse || cc.goAway != nil, + StreamsActive: len(cc.streams), + StreamsReserved: cc.streamsReserved, + StreamsPending: cc.pendingRequests, + LastIdle: cc.lastIdle, + MaxConcurrentStreams: maxConcurrent, + } +} + // clientConnIdleState describes the suitability of a client // connection to initiate a new RoundTrip request. type clientConnIdleState struct { canTakeNewRequest bool - freshConn bool // whether it's unused by any previous request } func (cc *ClientConn) idleState() clientConnIdleState { @@ -772,13 +872,13 @@ func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) { // writing it. maxConcurrentOkay = true } else { - maxConcurrentOkay = int64(len(cc.streams)+1) < int64(cc.maxConcurrentStreams) + maxConcurrentOkay = int64(len(cc.streams)+cc.streamsReserved+1) <= int64(cc.maxConcurrentStreams) } st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay && + !cc.doNotReuse && int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 && !cc.tooIdleLocked() - st.freshConn = cc.nextStreamID == 1 && st.canTakeNewRequest return } @@ -809,7 +909,7 @@ func (cc *ClientConn) onIdleTimeout() { func (cc *ClientConn) closeIfIdle() { cc.mu.Lock() - if len(cc.streams) > 0 { + if len(cc.streams) > 0 || cc.streamsReserved > 0 { cc.mu.Unlock() return } @@ -824,9 +924,15 @@ func (cc *ClientConn) closeIfIdle() { cc.tconn.Close() } +func (cc *ClientConn) isDoNotReuseAndIdle() bool { + cc.mu.Lock() + defer cc.mu.Unlock() + return cc.doNotReuse && len(cc.streams) == 0 +} + var shutdownEnterWaitStateHook = func() {} -// Shutdown gracefully close the client connection, waiting for running streams to complete. +// Shutdown gracefully closes the client connection, waiting for running streams to complete. func (cc *ClientConn) Shutdown(ctx context.Context) error { if err := cc.sendGoAway(); err != nil { return err @@ -865,15 +971,18 @@ func (cc *ClientConn) Shutdown(ctx context.Context) error { func (cc *ClientConn) sendGoAway() error { cc.mu.Lock() - defer cc.mu.Unlock() - cc.wmu.Lock() - defer cc.wmu.Unlock() - if cc.closing { + closing := cc.closing + cc.closing = true + maxStreamID := cc.nextStreamID + cc.mu.Unlock() + if closing { // GOAWAY sent already return nil } + + cc.wmu.Lock() + defer cc.wmu.Unlock() // Send a graceful shutdown frame to server - maxStreamID := cc.nextStreamID if err := cc.fr.WriteGoAway(maxStreamID, ErrCodeNo, nil); err != nil { return err } @@ -881,7 +990,6 @@ func (cc *ClientConn) sendGoAway() error { return err } // Prevent new requests - cc.closing = true return nil } @@ -889,17 +997,12 @@ func (cc *ClientConn) sendGoAway() error { // err is sent to streams. func (cc *ClientConn) closeForError(err error) error { cc.mu.Lock() + cc.closed = true + for _, cs := range cc.streams { + cs.abortStreamLocked(err) + } defer cc.cond.Broadcast() defer cc.mu.Unlock() - for id, cs := range cc.streams { - select { - case cs.resc <- resAndError{err: err}: - default: - } - cs.bufPipe.CloseWithError(err) - delete(cc.streams, id) - } - cc.closed = true return cc.tconn.Close() } @@ -914,6 +1017,9 @@ func (cc *ClientConn) Close() error { // closes the client connection immediately. In-flight requests are interrupted. func (cc *ClientConn) closeForLostPing() error { err := errors.New("http2: client connection lost") + if f := cc.t.CountError; f != nil { + f("conn_close_lost_ping") + } return cc.closeForError(err) } @@ -978,41 +1084,158 @@ func actualContentLength(req *http.Request) int64 { return -1 } +func (cc *ClientConn) decrStreamReservations() { + cc.mu.Lock() + defer cc.mu.Unlock() + cc.decrStreamReservationsLocked() +} + +func (cc *ClientConn) decrStreamReservationsLocked() { + if cc.streamsReserved > 0 { + cc.streamsReserved-- + } +} + func (cc *ClientConn) RoundTrip(req *http.Request) (*http.Response, error) { - resp, _, err := cc.roundTrip(req) - return resp, err + ctx := req.Context() + cs := &clientStream{ + cc: cc, + ctx: ctx, + reqCancel: req.Cancel, + isHead: req.Method == "HEAD", + reqBody: req.Body, + reqBodyContentLength: actualContentLength(req), + trace: httptrace.ContextClientTrace(ctx), + peerClosed: make(chan struct{}), + abort: make(chan struct{}), + respHeaderRecv: make(chan struct{}), + donec: make(chan struct{}), + } + go cs.doRequest(req) + + waitDone := func() error { + select { + case <-cs.donec: + return nil + case <-ctx.Done(): + return ctx.Err() + case <-cs.reqCancel: + return errRequestCanceled + } + } + + handleResponseHeaders := func() (*http.Response, error) { + res := cs.res + if res.StatusCode > 299 { + // On error or status code 3xx, 4xx, 5xx, etc abort any + // ongoing write, assuming that the server doesn't care + // about our request body. If the server replied with 1xx or + // 2xx, however, then assume the server DOES potentially + // want our body (e.g. full-duplex streaming: + // golang.org/issue/13444). If it turns out the server + // doesn't, they'll RST_STREAM us soon enough. This is a + // heuristic to avoid adding knobs to Transport. Hopefully + // we can keep it. + cs.abortRequestBodyWrite() + } + res.Request = req + res.TLS = cc.tlsState + if res.Body == noBody && actualContentLength(req) == 0 { + // If there isn't a request or response body still being + // written, then wait for the stream to be closed before + // RoundTrip returns. + if err := waitDone(); err != nil { + return nil, err + } + } + return res, nil + } + + for { + select { + case <-cs.respHeaderRecv: + return handleResponseHeaders() + case <-cs.abort: + select { + case <-cs.respHeaderRecv: + // If both cs.respHeaderRecv and cs.abort are signaling, + // pick respHeaderRecv. The server probably wrote the + // response and immediately reset the stream. + // golang.org/issue/49645 + return handleResponseHeaders() + default: + waitDone() + return nil, cs.abortErr + } + case <-ctx.Done(): + err := ctx.Err() + cs.abortStream(err) + return nil, err + case <-cs.reqCancel: + cs.abortStream(errRequestCanceled) + return nil, errRequestCanceled + } + } } -func (cc *ClientConn) roundTrip(req *http.Request) (res *http.Response, gotErrAfterReqBodyWrite bool, err error) { +// doRequest runs for the duration of the request lifetime. +// +// It sends the request and performs post-request cleanup (closing Request.Body, etc.). +func (cs *clientStream) doRequest(req *http.Request) { + err := cs.writeRequest(req) + cs.cleanupWriteRequest(err) +} + +// writeRequest sends a request. +// +// It returns nil after the request is written, the response read, +// and the request stream is half-closed by the peer. +// +// It returns non-nil if the request ends otherwise. +// If the returned error is StreamError, the error Code may be used in resetting the stream. +func (cs *clientStream) writeRequest(req *http.Request) (err error) { + cc := cs.cc + ctx := cs.ctx + if err := checkConnHeaders(req); err != nil { - return nil, false, err - } - if cc.idleTimer != nil { - cc.idleTimer.Stop() + return err } - trailers, err := commaSeparatedTrailers(req) - if err != nil { - return nil, false, err + // Acquire the new-request lock by writing to reqHeaderMu. + // This lock guards the critical section covering allocating a new stream ID + // (requires mu) and creating the stream (requires wmu). + if cc.reqHeaderMu == nil { + panic("RoundTrip on uninitialized ClientConn") // for tests + } + select { + case cc.reqHeaderMu <- struct{}{}: + case <-cs.reqCancel: + return errRequestCanceled + case <-ctx.Done(): + return ctx.Err() } - hasTrailers := trailers != "" cc.mu.Lock() - if err := cc.awaitOpenSlotForRequest(req); err != nil { + if cc.idleTimer != nil { + cc.idleTimer.Stop() + } + cc.decrStreamReservationsLocked() + if err := cc.awaitOpenSlotForStreamLocked(cs); err != nil { cc.mu.Unlock() - return nil, false, err + <-cc.reqHeaderMu + return err } - - body := req.Body - contentLen := actualContentLength(req) - hasBody := contentLen != 0 + cc.addStreamLocked(cs) // assigns stream ID + if isConnectionCloseRequest(req) { + cc.doNotReuse = true + } + cc.mu.Unlock() // TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere? - var requestedGzip bool if !cc.t.disableCompression() && req.Header.Get("Accept-Encoding") == "" && req.Header.Get("Range") == "" && - req.Method != "HEAD" { + !cs.isHead { // Request gzip only, not deflate. Deflate is ambiguous and // not as universally supported anyway. // See: https://zlib.net/zlib_faq.html#faq39 @@ -1025,183 +1248,224 @@ func (cc *ClientConn) roundTrip(req *http.Request) (res *http.Response, gotErrAf // We don't request gzip if the request is for a range, since // auto-decoding a portion of a gzipped document will just fail // anyway. See https://golang.org/issue/8923 - requestedGzip = true + cs.requestedGzip = true } - // we send: HEADERS{1}, CONTINUATION{0,} + DATA{0,} (DATA is - // sent by writeRequestBody below, along with any Trailers, - // again in form HEADERS{1}, CONTINUATION{0,}) - hdrs, err := cc.encodeHeaders(req, requestedGzip, trailers, contentLen) + continueTimeout := cc.t.expectContinueTimeout() + if continueTimeout != 0 { + if !httpguts.HeaderValuesContainsToken(req.Header["Expect"], "100-continue") { + continueTimeout = 0 + } else { + cs.on100 = make(chan struct{}, 1) + } + } + + // Past this point (where we send request headers), it is possible for + // RoundTrip to return successfully. Since the RoundTrip contract permits + // the caller to "mutate or reuse" the Request after closing the Response's Body, + // we must take care when referencing the Request from here on. + err = cs.encodeAndWriteHeaders(req) + <-cc.reqHeaderMu if err != nil { - cc.mu.Unlock() - return nil, false, err + return err } - cs := cc.newStream() - cs.req = req - cs.trace = httptrace.ContextClientTrace(req.Context()) - cs.requestedGzip = requestedGzip - bodyWriter := cc.t.getBodyWriterState(cs, body) - cs.on100 = bodyWriter.on100 + hasBody := cs.reqBodyContentLength != 0 + if !hasBody { + cs.sentEndStream = true + } else { + if continueTimeout != 0 { + traceWait100Continue(cs.trace) + timer := time.NewTimer(continueTimeout) + select { + case <-timer.C: + err = nil + case <-cs.on100: + err = nil + case <-cs.abort: + err = cs.abortErr + case <-ctx.Done(): + err = ctx.Err() + case <-cs.reqCancel: + err = errRequestCanceled + } + timer.Stop() + if err != nil { + traceWroteRequest(cs.trace, err) + return err + } + } - defer func() { - cc.wmu.Lock() - werr := cc.werr - cc.wmu.Unlock() - if werr != nil { - cc.Close() + if err = cs.writeRequestBody(req); err != nil { + if err != errStopReqBodyWrite { + traceWroteRequest(cs.trace, err) + return err + } + } else { + cs.sentEndStream = true } - }() + } + + traceWroteRequest(cs.trace, err) + + var respHeaderTimer <-chan time.Time + var respHeaderRecv chan struct{} + if d := cc.responseHeaderTimeout(); d != 0 { + timer := time.NewTimer(d) + defer timer.Stop() + respHeaderTimer = timer.C + respHeaderRecv = cs.respHeaderRecv + } + // Wait until the peer half-closes its end of the stream, + // or until the request is aborted (via context, error, or otherwise), + // whichever comes first. + for { + select { + case <-cs.peerClosed: + return nil + case <-respHeaderTimer: + return errTimeout + case <-respHeaderRecv: + respHeaderRecv = nil + respHeaderTimer = nil // keep waiting for END_STREAM + case <-cs.abort: + return cs.abortErr + case <-ctx.Done(): + return ctx.Err() + case <-cs.reqCancel: + return errRequestCanceled + } + } +} + +func (cs *clientStream) encodeAndWriteHeaders(req *http.Request) error { + cc := cs.cc + ctx := cs.ctx cc.wmu.Lock() + defer cc.wmu.Unlock() + + // If the request was canceled while waiting for cc.mu, just quit. + select { + case <-cs.abort: + return cs.abortErr + case <-ctx.Done(): + return ctx.Err() + case <-cs.reqCancel: + return errRequestCanceled + default: + } + + // Encode headers. + // + // we send: HEADERS{1}, CONTINUATION{0,} + DATA{0,} (DATA is + // sent by writeRequestBody below, along with any Trailers, + // again in form HEADERS{1}, CONTINUATION{0,}) + trailers, err := commaSeparatedTrailers(req) + if err != nil { + return err + } + hasTrailers := trailers != "" + contentLen := actualContentLength(req) + hasBody := contentLen != 0 + hdrs, err := cc.encodeHeaders(req, cs.requestedGzip, trailers, contentLen) + if err != nil { + return err + } + + // Write the request. endStream := !hasBody && !hasTrailers - werr := cc.writeHeaders(cs.ID, endStream, int(cc.maxFrameSize), hdrs) - cc.wmu.Unlock() + cs.sentHeaders = true + err = cc.writeHeaders(cs.ID, endStream, int(cc.maxFrameSize), hdrs) traceWroteHeaders(cs.trace) - cc.mu.Unlock() + return err +} - if werr != nil { - if hasBody { - req.Body.Close() // per RoundTripper contract - bodyWriter.cancel() - } - cc.forgetStreamID(cs.ID) - // Don't bother sending a RST_STREAM (our write already failed; - // no need to keep writing) - traceWroteRequest(cs.trace, werr) - return nil, false, werr - } +// cleanupWriteRequest performs post-request tasks. +// +// If err (the result of writeRequest) is non-nil and the stream is not closed, +// cleanupWriteRequest will send a reset to the peer. +func (cs *clientStream) cleanupWriteRequest(err error) { + cc := cs.cc - var respHeaderTimer <-chan time.Time - if hasBody { - bodyWriter.scheduleBodyWrite() - } else { - traceWroteRequest(cs.trace, nil) - if d := cc.responseHeaderTimeout(); d != 0 { - timer := time.NewTimer(d) - defer timer.Stop() - respHeaderTimer = timer.C - } + if cs.ID == 0 { + // We were canceled before creating the stream, so return our reservation. + cc.decrStreamReservations() } - readLoopResCh := cs.resc - bodyWritten := false - ctx := req.Context() + // TODO: write h12Compare test showing whether + // Request.Body is closed by the Transport, + // and in multiple cases: server replies <=299 and >299 + // while still writing request body + cc.mu.Lock() + bodyClosed := cs.reqBodyClosed + cs.reqBodyClosed = true + cc.mu.Unlock() + if !bodyClosed && cs.reqBody != nil { + cs.reqBody.Close() + } - handleReadLoopResponse := func(re resAndError) (*http.Response, bool, error) { - res := re.res - if re.err != nil || res.StatusCode > 299 { - // On error or status code 3xx, 4xx, 5xx, etc abort any - // ongoing write, assuming that the server doesn't care - // about our request body. If the server replied with 1xx or - // 2xx, however, then assume the server DOES potentially - // want our body (e.g. full-duplex streaming: - // golang.org/issue/13444). If it turns out the server - // doesn't, they'll RST_STREAM us soon enough. This is a - // heuristic to avoid adding knobs to Transport. Hopefully - // we can keep it. - bodyWriter.cancel() - cs.abortRequestBodyWrite(errStopReqBodyWrite) - if hasBody && !bodyWritten { - <-bodyWriter.resc + if err != nil && cs.sentEndStream { + // If the connection is closed immediately after the response is read, + // we may be aborted before finishing up here. If the stream was closed + // cleanly on both sides, there is no error. + select { + case <-cs.peerClosed: + err = nil + default: + } + } + if err != nil { + cs.abortStream(err) // possibly redundant, but harmless + if cs.sentHeaders { + if se, ok := err.(StreamError); ok { + if se.Cause != errFromPeer { + cc.writeStreamReset(cs.ID, se.Code, err) + } + } else { + cc.writeStreamReset(cs.ID, ErrCodeCancel, err) } } - if re.err != nil { - cc.forgetStreamID(cs.ID) - return nil, cs.getStartedWrite(), re.err + cs.bufPipe.CloseWithError(err) // no-op if already closed + } else { + if cs.sentHeaders && !cs.sentEndStream { + cc.writeStreamReset(cs.ID, ErrCodeNo, nil) } - res.Request = req - res.TLS = cc.tlsState - return res, false, nil + cs.bufPipe.CloseWithError(errRequestCanceled) } - - handleError := func(err error) (*http.Response, bool, error) { - if !hasBody || bodyWritten { - cc.writeStreamReset(cs.ID, ErrCodeCancel, nil) - } else { - bodyWriter.cancel() - cs.abortRequestBodyWrite(errStopReqBodyWriteAndCancel) - <-bodyWriter.resc - } + if cs.ID != 0 { cc.forgetStreamID(cs.ID) - return nil, cs.getStartedWrite(), err } - for { - select { - case re := <-readLoopResCh: - return handleReadLoopResponse(re) - case <-respHeaderTimer: - return handleError(errTimeout) - case <-ctx.Done(): - return handleError(ctx.Err()) - case <-req.Cancel: - return handleError(errRequestCanceled) - case <-cs.peerReset: - // processResetStream already removed the - // stream from the streams map; no need for - // forgetStreamID. - return nil, cs.getStartedWrite(), cs.resetErr - case err := <-bodyWriter.resc: - bodyWritten = true - // Prefer the read loop's response, if available. Issue 16102. - select { - case re := <-readLoopResCh: - return handleReadLoopResponse(re) - default: - } - if err != nil { - cc.forgetStreamID(cs.ID) - return nil, cs.getStartedWrite(), err - } - if d := cc.responseHeaderTimeout(); d != 0 { - timer := time.NewTimer(d) - defer timer.Stop() - respHeaderTimer = timer.C - } - } + cc.wmu.Lock() + werr := cc.werr + cc.wmu.Unlock() + if werr != nil { + cc.Close() } + + close(cs.donec) } -// awaitOpenSlotForRequest waits until len(streams) < maxConcurrentStreams. +// awaitOpenSlotForStream waits until len(streams) < maxConcurrentStreams. // Must hold cc.mu. -func (cc *ClientConn) awaitOpenSlotForRequest(req *http.Request) error { - var waitingForConn chan struct{} - var waitingForConnErr error // guarded by cc.mu +func (cc *ClientConn) awaitOpenSlotForStreamLocked(cs *clientStream) error { for { cc.lastActive = time.Now() if cc.closed || !cc.canTakeNewRequestLocked() { - if waitingForConn != nil { - close(waitingForConn) - } return errClientConnUnusable } cc.lastIdle = time.Time{} - if int64(len(cc.streams))+1 <= int64(cc.maxConcurrentStreams) { - if waitingForConn != nil { - close(waitingForConn) - } + if int64(len(cc.streams)) < int64(cc.maxConcurrentStreams) { return nil } - // Unfortunately, we cannot wait on a condition variable and channel at - // the same time, so instead, we spin up a goroutine to check if the - // request is canceled while we wait for a slot to open in the connection. - if waitingForConn == nil { - waitingForConn = make(chan struct{}) - go func() { - if err := awaitRequestCancel(req, waitingForConn); err != nil { - cc.mu.Lock() - waitingForConnErr = err - cc.cond.Broadcast() - cc.mu.Unlock() - } - }() - } cc.pendingRequests++ cc.cond.Wait() cc.pendingRequests-- - if waitingForConnErr != nil { - return waitingForConnErr + select { + case <-cs.abort: + return cs.abortErr + default: } } } @@ -1228,10 +1492,6 @@ func (cc *ClientConn) writeHeaders(streamID uint32, endStream bool, maxFrameSize cc.fr.WriteContinuation(streamID, endHeaders, chunk) } } - // TODO(bradfitz): this Flush could potentially block (as - // could the WriteHeaders call(s) above), which means they - // wouldn't respond to Request.Cancel being readable. That's - // rare, but this should probably be in a goroutine. cc.bw.Flush() return cc.werr } @@ -1258,7 +1518,7 @@ func (cs *clientStream) frameScratchBufferLen(maxFrameSize int) int { if n > max { n = max } - if cl := actualContentLength(cs.req); cl != -1 && cl+1 < n { + if cl := cs.reqBodyContentLength; cl != -1 && cl+1 < n { // Add an extra byte past the declared content-length to // give the caller's Request.Body io.Reader a chance to // give us more bytes than they declared, so we can catch it @@ -1273,31 +1533,13 @@ func (cs *clientStream) frameScratchBufferLen(maxFrameSize int) int { var bufPool sync.Pool // of *[]byte -func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) (err error) { +func (cs *clientStream) writeRequestBody(req *http.Request) (err error) { cc := cs.cc + body := cs.reqBody sentEnd := false // whether we sent the final DATA frame w/ END_STREAM - defer func() { - traceWroteRequest(cs.trace, err) - // TODO: write h12Compare test showing whether - // Request.Body is closed by the Transport, - // and in multiple cases: server replies <=299 and >299 - // while still writing request body - var cerr error - cc.mu.Lock() - if cs.stopReqBody == nil { - cs.stopReqBody = errStopReqBodyWrite - cerr = bodyCloser.Close() - } - cc.mu.Unlock() - if err == nil { - err = cerr - } - }() - - req := cs.req hasTrailers := req.Trailer != nil - remainLen := actualContentLength(req) + remainLen := cs.reqBodyContentLength hasContentLen := remainLen != -1 cc.mu.Lock() @@ -1335,29 +1577,29 @@ func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) ( } if remainLen < 0 { err = errReqBodyTooLong - cc.writeStreamReset(cs.ID, ErrCodeCancel, err) return err } } - if err == io.EOF { - sawEOF = true - err = nil - } else if err != nil { - cc.writeStreamReset(cs.ID, ErrCodeCancel, err) - return err + if err != nil { + cc.mu.Lock() + bodyClosed := cs.reqBodyClosed + cc.mu.Unlock() + switch { + case bodyClosed: + return errStopReqBodyWrite + case err == io.EOF: + sawEOF = true + err = nil + default: + return err + } } remain := buf[:n] for len(remain) > 0 && err == nil { var allowed int32 allowed, err = cs.awaitFlowControl(len(remain)) - switch { - case err == errStopReqBodyWrite: - return err - case err == errStopReqBodyWriteAndCancel: - cc.writeStreamReset(cs.ID, ErrCodeCancel, nil) - return err - case err != nil: + if err != nil { return err } cc.wmu.Lock() @@ -1388,21 +1630,27 @@ func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) ( return nil } + // Since the RoundTrip contract permits the caller to "mutate or reuse" + // a request after the Response's Body is closed, verify that this hasn't + // happened before accessing the trailers. + cc.mu.Lock() + trailer := req.Trailer + err = cs.abortErr + cc.mu.Unlock() + if err != nil { + return err + } + + cc.wmu.Lock() + defer cc.wmu.Unlock() var trls []byte - if hasTrailers { - cc.mu.Lock() - trls, err = cc.encodeTrailers(req) - cc.mu.Unlock() + if len(trailer) > 0 { + trls, err = cc.encodeTrailers(trailer) if err != nil { - cc.writeStreamReset(cs.ID, ErrCodeInternal, err) - cc.forgetStreamID(cs.ID) return err } } - cc.wmu.Lock() - defer cc.wmu.Unlock() - // Two ways to send END_STREAM: either with trailers, or // with an empty DATA frame. if len(trls) > 0 { @@ -1422,17 +1670,24 @@ func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) ( // if the stream is dead. func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) { cc := cs.cc + ctx := cs.ctx cc.mu.Lock() defer cc.mu.Unlock() for { if cc.closed { return 0, errClientConnClosed } - if cs.stopReqBody != nil { - return 0, cs.stopReqBody + if cs.reqBodyClosed { + return 0, errStopReqBodyWrite } - if err := cs.checkResetOrDone(); err != nil { - return 0, err + select { + case <-cs.abort: + return 0, cs.abortErr + case <-ctx.Done(): + return 0, ctx.Err() + case <-cs.reqCancel: + return 0, errRequestCanceled + default: } if a := cs.flow.available(); a > 0 { take := a @@ -1450,9 +1705,14 @@ func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) } } -// requires cc.mu be held. +var errNilRequestURL = errors.New("http2: Request.URI is nil") + +// requires cc.wmu be held. func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) { cc.hbuf.Reset() + if req.URL == nil { + return nil, errNilRequestURL + } host := req.Host if host == "" { @@ -1638,12 +1898,12 @@ func shouldSendReqContentLength(method string, contentLength int64) bool { } } -// requires cc.mu be held. -func (cc *ClientConn) encodeTrailers(req *http.Request) ([]byte, error) { +// requires cc.wmu be held. +func (cc *ClientConn) encodeTrailers(trailer http.Header) ([]byte, error) { cc.hbuf.Reset() hlSize := uint64(0) - for k, vv := range req.Trailer { + for k, vv := range trailer { for _, v := range vv { hf := hpack.HeaderField{Name: k, Value: v} hlSize += uint64(hf.Size()) @@ -1653,7 +1913,7 @@ func (cc *ClientConn) encodeTrailers(req *http.Request) ([]byte, error) { return nil, errRequestHeaderListSize } - for k, vv := range req.Trailer { + for k, vv := range trailer { lowKey, ascii := asciiToLower(k) if !ascii { // Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header @@ -1683,51 +1943,51 @@ type resAndError struct { } // requires cc.mu be held. -func (cc *ClientConn) newStream() *clientStream { - cs := &clientStream{ - cc: cc, - ID: cc.nextStreamID, - resc: make(chan resAndError, 1), - peerReset: make(chan struct{}), - done: make(chan struct{}), - } +func (cc *ClientConn) addStreamLocked(cs *clientStream) { cs.flow.add(int32(cc.initialWindowSize)) cs.flow.setConnFlow(&cc.flow) cs.inflow.add(transportDefaultStreamFlow) cs.inflow.setConnFlow(&cc.inflow) + cs.ID = cc.nextStreamID cc.nextStreamID += 2 cc.streams[cs.ID] = cs - return cs + if cs.ID == 0 { + panic("assigned stream ID 0") + } } func (cc *ClientConn) forgetStreamID(id uint32) { - cc.streamByID(id, true) -} - -func (cc *ClientConn) streamByID(id uint32, andRemove bool) *clientStream { cc.mu.Lock() - defer cc.mu.Unlock() - cs := cc.streams[id] - if andRemove && cs != nil && !cc.closed { - cc.lastActive = time.Now() - delete(cc.streams, id) - if len(cc.streams) == 0 && cc.idleTimer != nil { - cc.idleTimer.Reset(cc.idleTimeout) - cc.lastIdle = time.Now() - } - close(cs.done) - // Wake up checkResetOrDone via clientStream.awaitFlowControl and - // wake up RoundTrip if there is a pending request. - cc.cond.Broadcast() + slen := len(cc.streams) + delete(cc.streams, id) + if len(cc.streams) != slen-1 { + panic("forgetting unknown stream id") + } + cc.lastActive = time.Now() + if len(cc.streams) == 0 && cc.idleTimer != nil { + cc.idleTimer.Reset(cc.idleTimeout) + cc.lastIdle = time.Now() + } + // Wake up writeRequestBody via clientStream.awaitFlowControl and + // wake up RoundTrip if there is a pending request. + cc.cond.Broadcast() + + closeOnIdle := cc.singleUse || cc.doNotReuse || cc.t.disableKeepAlives() + if closeOnIdle && cc.streamsReserved == 0 && len(cc.streams) == 0 { + if VerboseLogs { + cc.vlogf("http2: Transport closing idle conn %p (forSingleUse=%v, maxStream=%v)", cc, cc.singleUse, cc.nextStreamID-2) + } + cc.closed = true + defer cc.tconn.Close() } - return cs + + cc.mu.Unlock() } // clientConnReadLoop is the state owned by the clientConn's frame-reading readLoop. type clientConnReadLoop struct { - _ incomparable - cc *ClientConn - closeWhenIdle bool + _ incomparable + cc *ClientConn } // readLoop runs in its own goroutine and reads and dispatches frames. @@ -1787,23 +2047,49 @@ func (rl *clientConnReadLoop) cleanup() { } else if err == io.EOF { err = io.ErrUnexpectedEOF } + cc.closed = true for _, cs := range cc.streams { - cs.bufPipe.CloseWithError(err) // no-op if already closed select { - case cs.resc <- resAndError{err: err}: + case <-cs.peerClosed: + // The server closed the stream before closing the conn, + // so no need to interrupt it. default: + cs.abortStreamLocked(err) } - close(cs.done) } - cc.closed = true cc.cond.Broadcast() cc.mu.Unlock() } +// countReadFrameError calls Transport.CountError with a string +// representing err. +func (cc *ClientConn) countReadFrameError(err error) { + f := cc.t.CountError + if f == nil || err == nil { + return + } + if ce, ok := err.(ConnectionError); ok { + errCode := ErrCode(ce) + f(fmt.Sprintf("read_frame_conn_error_%s", errCode.stringToken())) + return + } + if errors.Is(err, io.EOF) { + f("read_frame_eof") + return + } + if errors.Is(err, io.ErrUnexpectedEOF) { + f("read_frame_unexpected_eof") + return + } + if errors.Is(err, ErrFrameTooLarge) { + f("read_frame_too_large") + return + } + f("read_frame_other") +} + func (rl *clientConnReadLoop) run() error { cc := rl.cc - rl.closeWhenIdle = cc.t.disableKeepAlives() || cc.singleUse - gotReply := false // ever saw a HEADERS reply gotSettings := false readIdleTimeout := cc.t.ReadIdleTimeout var t *time.Timer @@ -1820,9 +2106,7 @@ func (rl *clientConnReadLoop) run() error { cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err) } if se, ok := err.(StreamError); ok { - if cs := cc.streamByID(se.StreamID, false); cs != nil { - cs.cc.writeStreamReset(cs.ID, se.Code, err) - cs.cc.forgetStreamID(cs.ID) + if cs := rl.streamByID(se.StreamID); cs != nil { if se.Cause == nil { se.Cause = cc.fr.errDetail } @@ -1830,6 +2114,7 @@ func (rl *clientConnReadLoop) run() error { } continue } else if err != nil { + cc.countReadFrameError(err) return err } if VerboseLogs { @@ -1842,22 +2127,16 @@ func (rl *clientConnReadLoop) run() error { } gotSettings = true } - maybeIdle := false // whether frame might transition us to idle switch f := f.(type) { case *MetaHeadersFrame: err = rl.processHeaders(f) - maybeIdle = true - gotReply = true case *DataFrame: err = rl.processData(f) - maybeIdle = true case *GoAwayFrame: err = rl.processGoAway(f) - maybeIdle = true case *RSTStreamFrame: err = rl.processResetStream(f) - maybeIdle = true case *SettingsFrame: err = rl.processSettings(f) case *PushPromiseFrame: @@ -1875,38 +2154,24 @@ func (rl *clientConnReadLoop) run() error { } return err } - if rl.closeWhenIdle && gotReply && maybeIdle { - cc.closeIfIdle() - } } } func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error { - cc := rl.cc - cs := cc.streamByID(f.StreamID, false) + cs := rl.streamByID(f.StreamID) if cs == nil { // We'd get here if we canceled a request while the // server had its response still in flight. So if this // was just something we canceled, ignore it. return nil } - if f.StreamEnded() { - // Issue 20521: If the stream has ended, streamByID() causes - // clientStream.done to be closed, which causes the request's bodyWriter - // to be closed with an errStreamClosed, which may be received by - // clientConn.RoundTrip before the result of processing these headers. - // Deferring stream closure allows the header processing to occur first. - // clientConn.RoundTrip may still receive the bodyWriter error first, but - // the fix for issue 16102 prioritises any response. - // - // Issue 22413: If there is no request body, we should close the - // stream before writing to cs.resc so that the stream is closed - // immediately once RoundTrip returns. - if cs.req.Body != nil { - defer cc.forgetStreamID(f.StreamID) - } else { - cc.forgetStreamID(f.StreamID) - } + if cs.readClosed { + rl.endStreamError(cs, StreamError{ + StreamID: f.StreamID, + Code: ErrCodeProtocol, + Cause: errors.New("protocol error: headers after END_STREAM"), + }) + return nil } if !cs.firstByte { if cs.trace != nil { @@ -1930,9 +2195,11 @@ func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error { return err } // Any other error type is a stream error. - cs.cc.writeStreamReset(f.StreamID, ErrCodeProtocol, err) - cc.forgetStreamID(cs.ID) - cs.resc <- resAndError{err: err} + rl.endStreamError(cs, StreamError{ + StreamID: f.StreamID, + Code: ErrCodeProtocol, + Cause: err, + }) return nil // return nil from process* funcs to keep conn alive } if res == nil { @@ -1940,7 +2207,11 @@ func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error { return nil } cs.resTrailer = &res.Trailer - cs.resc <- resAndError{res: res} + cs.res = res + close(cs.respHeaderRecv) + if f.StreamEnded() { + rl.endStream(cs) + } return nil } @@ -2002,6 +2273,9 @@ func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFra } if statusCode >= 100 && statusCode <= 199 { + if f.StreamEnded() { + return nil, errors.New("1xx informational response with END_STREAM flag") + } cs.num1xx++ const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http if cs.num1xx > max1xxResponses { @@ -2014,42 +2288,49 @@ func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFra } if statusCode == 100 { traceGot100Continue(cs.trace) - if cs.on100 != nil { - cs.on100() // forces any write delay timer to fire + select { + case cs.on100 <- struct{}{}: + default: } } cs.pastHeaders = false // do it all again return nil, nil } - streamEnded := f.StreamEnded() - isHead := cs.req.Method == "HEAD" - if !streamEnded || isHead { - res.ContentLength = -1 - if clens := res.Header["Content-Length"]; len(clens) == 1 { - if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil { - res.ContentLength = int64(cl) - } else { - // TODO: care? unlike http/1, it won't mess up our framing, so it's - // more safe smuggling-wise to ignore. - } - } else if len(clens) > 1 { + res.ContentLength = -1 + if clens := res.Header["Content-Length"]; len(clens) == 1 { + if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil { + res.ContentLength = int64(cl) + } else { // TODO: care? unlike http/1, it won't mess up our framing, so it's // more safe smuggling-wise to ignore. } + } else if len(clens) > 1 { + // TODO: care? unlike http/1, it won't mess up our framing, so it's + // more safe smuggling-wise to ignore. + } else if f.StreamEnded() && !cs.isHead { + res.ContentLength = 0 } - if streamEnded || isHead { + if cs.isHead { res.Body = noBody return res, nil } - cs.bufPipe = pipe{b: &dataBuffer{expected: res.ContentLength}} + if f.StreamEnded() { + if res.ContentLength > 0 { + res.Body = missingBody{} + } else { + res.Body = noBody + } + return res, nil + } + + cs.bufPipe.setBuffer(&dataBuffer{expected: res.ContentLength}) cs.bytesRemain = res.ContentLength res.Body = transportResponseBody{cs} - go cs.awaitRequestCancel(cs.req) - if cs.requestedGzip && res.Header.Get("Content-Encoding") == "gzip" { + if cs.requestedGzip && asciiEqualFold(res.Header.Get("Content-Encoding"), "gzip") { res.Header.Del("Content-Encoding") res.Header.Del("Content-Length") res.ContentLength = -1 @@ -2088,8 +2369,7 @@ func (rl *clientConnReadLoop) processTrailers(cs *clientStream, f *MetaHeadersFr } // transportResponseBody is the concrete type of Transport.RoundTrip's -// Response.Body. It is an io.ReadCloser. On Read, it reads from cs.body. -// On Close it sends RST_STREAM if EOF wasn't already seen. +// Response.Body. It is an io.ReadCloser. type transportResponseBody struct { cs *clientStream } @@ -2107,7 +2387,7 @@ func (b transportResponseBody) Read(p []byte) (n int, err error) { n = int(cs.bytesRemain) if err == nil { err = errors.New("net/http: server replied with more than declared Content-Length; truncated") - cc.writeStreamReset(cs.ID, ErrCodeProtocol, err) + cs.abortStream(err) } cs.readErr = err return int(cs.bytesRemain), err @@ -2125,8 +2405,6 @@ func (b transportResponseBody) Read(p []byte) (n int, err error) { } cc.mu.Lock() - defer cc.mu.Unlock() - var connAdd, streamAdd int32 // Check the conn-level first, before the stream-level. if v := cc.inflow.available(); v < transportDefaultConnFlow/2 { @@ -2143,6 +2421,8 @@ func (b transportResponseBody) Read(p []byte) (n int, err error) { cs.inflow.add(streamAdd) } } + cc.mu.Unlock() + if connAdd != 0 || streamAdd != 0 { cc.wmu.Lock() defer cc.wmu.Unlock() @@ -2163,34 +2443,45 @@ func (b transportResponseBody) Close() error { cs := b.cs cc := cs.cc - serverSentStreamEnd := cs.bufPipe.Err() == io.EOF unread := cs.bufPipe.Len() - - if unread > 0 || !serverSentStreamEnd { + if unread > 0 { cc.mu.Lock() - cc.wmu.Lock() - if !serverSentStreamEnd { - cc.fr.WriteRSTStream(cs.ID, ErrCodeCancel) - cs.didReset = true - } // Return connection-level flow control. if unread > 0 { cc.inflow.add(int32(unread)) + } + cc.mu.Unlock() + + // TODO(dneil): Acquiring this mutex can block indefinitely. + // Move flow control return to a goroutine? + cc.wmu.Lock() + // Return connection-level flow control. + if unread > 0 { cc.fr.WriteWindowUpdate(0, uint32(unread)) } cc.bw.Flush() cc.wmu.Unlock() - cc.mu.Unlock() } cs.bufPipe.BreakWithError(errClosedResponseBody) - cc.forgetStreamID(cs.ID) + cs.abortStream(errClosedResponseBody) + + select { + case <-cs.donec: + case <-cs.ctx.Done(): + // See golang/go#49366: The net/http package can cancel the + // request context after the response body is fully read. + // Don't treat this as an error. + return nil + case <-cs.reqCancel: + return errRequestCanceled + } return nil } func (rl *clientConnReadLoop) processData(f *DataFrame) error { cc := rl.cc - cs := cc.streamByID(f.StreamID, f.StreamEnded()) + cs := rl.streamByID(f.StreamID) data := f.Data() if cs == nil { cc.mu.Lock() @@ -2219,6 +2510,14 @@ func (rl *clientConnReadLoop) processData(f *DataFrame) error { } return nil } + if cs.readClosed { + cc.logf("protocol error: received DATA after END_STREAM") + rl.endStreamError(cs, StreamError{ + StreamID: f.StreamID, + Code: ErrCodeProtocol, + }) + return nil + } if !cs.firstByte { cc.logf("protocol error: received DATA before a HEADERS frame") rl.endStreamError(cs, StreamError{ @@ -2228,7 +2527,7 @@ func (rl *clientConnReadLoop) processData(f *DataFrame) error { return nil } if f.Length > 0 { - if cs.req.Method == "HEAD" && len(data) > 0 { + if cs.isHead && len(data) > 0 { cc.logf("protocol error: received DATA on a HEAD request") rl.endStreamError(cs, StreamError{ StreamID: f.StreamID, @@ -2250,30 +2549,39 @@ func (rl *clientConnReadLoop) processData(f *DataFrame) error { if pad := int(f.Length) - len(data); pad > 0 { refund += pad } - // Return len(data) now if the stream is already closed, - // since data will never be read. - didReset := cs.didReset - if didReset { - refund += len(data) + + didReset := false + var err error + if len(data) > 0 { + if _, err = cs.bufPipe.Write(data); err != nil { + // Return len(data) now if the stream is already closed, + // since data will never be read. + didReset = true + refund += len(data) + } } + if refund > 0 { cc.inflow.add(int32(refund)) + if !didReset { + cs.inflow.add(int32(refund)) + } + } + cc.mu.Unlock() + + if refund > 0 { cc.wmu.Lock() cc.fr.WriteWindowUpdate(0, uint32(refund)) if !didReset { - cs.inflow.add(int32(refund)) cc.fr.WriteWindowUpdate(cs.ID, uint32(refund)) } cc.bw.Flush() cc.wmu.Unlock() } - cc.mu.Unlock() - if len(data) > 0 && !didReset { - if _, err := cs.bufPipe.Write(data); err != nil { - rl.endStreamError(cs, err) - return err - } + if err != nil { + rl.endStreamError(cs, err) + return nil } } @@ -2286,24 +2594,32 @@ func (rl *clientConnReadLoop) processData(f *DataFrame) error { func (rl *clientConnReadLoop) endStream(cs *clientStream) { // TODO: check that any declared content-length matches, like // server.go's (*stream).endStream method. - rl.endStreamError(cs, nil) + if !cs.readClosed { + cs.readClosed = true + // Close cs.bufPipe and cs.peerClosed with cc.mu held to avoid a + // race condition: The caller can read io.EOF from Response.Body + // and close the body before we close cs.peerClosed, causing + // cleanupWriteRequest to send a RST_STREAM. + rl.cc.mu.Lock() + defer rl.cc.mu.Unlock() + cs.bufPipe.closeWithErrorAndCode(io.EOF, cs.copyTrailers) + close(cs.peerClosed) + } } func (rl *clientConnReadLoop) endStreamError(cs *clientStream, err error) { - var code func() - if err == nil { - err = io.EOF - code = cs.copyTrailers - } - if isConnectionCloseRequest(cs.req) { - rl.closeWhenIdle = true - } - cs.bufPipe.closeWithErrorAndCode(err, code) + cs.readAborted = true + cs.abortStream(err) +} - select { - case cs.resc <- resAndError{err: err}: - default: +func (rl *clientConnReadLoop) streamByID(id uint32) *clientStream { + rl.cc.mu.Lock() + defer rl.cc.mu.Unlock() + cs := rl.cc.streams[id] + if cs != nil && !cs.readAborted { + return cs } + return nil } func (cs *clientStream) copyTrailers() { @@ -2322,12 +2638,33 @@ func (rl *clientConnReadLoop) processGoAway(f *GoAwayFrame) error { if f.ErrCode != 0 { // TODO: deal with GOAWAY more. particularly the error code cc.vlogf("transport got GOAWAY with error code = %v", f.ErrCode) + if fn := cc.t.CountError; fn != nil { + fn("recv_goaway_" + f.ErrCode.stringToken()) + } + } cc.setGoAway(f) return nil } func (rl *clientConnReadLoop) processSettings(f *SettingsFrame) error { + cc := rl.cc + // Locking both mu and wmu here allows frame encoding to read settings with only wmu held. + // Acquiring wmu when f.IsAck() is unnecessary, but convenient and mostly harmless. + cc.wmu.Lock() + defer cc.wmu.Unlock() + + if err := rl.processSettingsNoWrite(f); err != nil { + return err + } + if !f.IsAck() { + cc.fr.WriteSettingsAck() + cc.bw.Flush() + } + return nil +} + +func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { cc := rl.cc cc.mu.Lock() defer cc.mu.Unlock() @@ -2340,12 +2677,14 @@ func (rl *clientConnReadLoop) processSettings(f *SettingsFrame) error { return ConnectionError(ErrCodeProtocol) } + var seenMaxConcurrentStreams bool err := f.ForeachSetting(func(s Setting) error { switch s.ID { case SettingMaxFrameSize: cc.maxFrameSize = s.Val case SettingMaxConcurrentStreams: cc.maxConcurrentStreams = s.Val + seenMaxConcurrentStreams = true case SettingMaxHeaderListSize: cc.peerMaxHeaderListSize = uint64(s.Val) case SettingInitialWindowSize: @@ -2377,17 +2716,23 @@ func (rl *clientConnReadLoop) processSettings(f *SettingsFrame) error { return err } - cc.wmu.Lock() - defer cc.wmu.Unlock() + if !cc.seenSettings { + if !seenMaxConcurrentStreams { + // This was the servers initial SETTINGS frame and it + // didn't contain a MAX_CONCURRENT_STREAMS field so + // increase the number of concurrent streams this + // connection can establish to our default. + cc.maxConcurrentStreams = defaultMaxConcurrentStreams + } + cc.seenSettings = true + } - cc.fr.WriteSettingsAck() - cc.bw.Flush() - return cc.werr + return nil } func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { cc := rl.cc - cs := cc.streamByID(f.StreamID, false) + cs := rl.streamByID(f.StreamID) if f.StreamID != 0 && cs == nil { return nil } @@ -2407,24 +2752,22 @@ func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { } func (rl *clientConnReadLoop) processResetStream(f *RSTStreamFrame) error { - cs := rl.cc.streamByID(f.StreamID, true) + cs := rl.streamByID(f.StreamID) if cs == nil { - // TODO: return error if server tries to RST_STEAM an idle stream + // TODO: return error if server tries to RST_STREAM an idle stream return nil } - select { - case <-cs.peerReset: - // Already reset. - // This is the only goroutine - // which closes this, so there - // isn't a race. - default: - err := streamError(cs.ID, f.ErrCode) - cs.resetErr = err - close(cs.peerReset) - cs.bufPipe.CloseWithError(err) - cs.cc.cond.Broadcast() // wake up checkResetOrDone via clientStream.awaitFlowControl + serr := streamError(cs.ID, f.ErrCode) + serr.Cause = errFromPeer + if f.ErrCode == ErrCodeProtocol { + rl.cc.SetDoNotReuse() } + if fn := cs.cc.t.CountError; fn != nil { + fn("recv_rststream_" + f.ErrCode.stringToken()) + } + cs.abortStream(serr) + + cs.bufPipe.CloseWithError(serr) return nil } @@ -2446,19 +2789,24 @@ func (cc *ClientConn) Ping(ctx context.Context) error { } cc.mu.Unlock() } - cc.wmu.Lock() - if err := cc.fr.WritePing(false, p); err != nil { - cc.wmu.Unlock() - return err - } - if err := cc.bw.Flush(); err != nil { - cc.wmu.Unlock() - return err - } - cc.wmu.Unlock() + errc := make(chan error, 1) + go func() { + cc.wmu.Lock() + defer cc.wmu.Unlock() + if err := cc.fr.WritePing(false, p); err != nil { + errc <- err + return + } + if err := cc.bw.Flush(); err != nil { + errc <- err + return + } + }() select { case <-c: return nil + case err := <-errc: + return err case <-ctx.Done(): return ctx.Err() case <-cc.readerDone: @@ -2535,6 +2883,11 @@ func (t *Transport) logf(format string, args ...interface{}) { var noBody io.ReadCloser = ioutil.NopCloser(bytes.NewReader(nil)) +type missingBody struct{} + +func (missingBody) Close() error { return nil } +func (missingBody) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF } + func strSliceContains(ss []string, s string) bool { for _, v := range ss { if v == s { @@ -2580,87 +2933,6 @@ type errorReader struct{ err error } func (r errorReader) Read(p []byte) (int, error) { return 0, r.err } -// bodyWriterState encapsulates various state around the Transport's writing -// of the request body, particularly regarding doing delayed writes of the body -// when the request contains "Expect: 100-continue". -type bodyWriterState struct { - cs *clientStream - timer *time.Timer // if non-nil, we're doing a delayed write - fnonce *sync.Once // to call fn with - fn func() // the code to run in the goroutine, writing the body - resc chan error // result of fn's execution - delay time.Duration // how long we should delay a delayed write for -} - -func (t *Transport) getBodyWriterState(cs *clientStream, body io.Reader) (s bodyWriterState) { - s.cs = cs - if body == nil { - return - } - resc := make(chan error, 1) - s.resc = resc - s.fn = func() { - cs.cc.mu.Lock() - cs.startedWrite = true - cs.cc.mu.Unlock() - resc <- cs.writeRequestBody(body, cs.req.Body) - } - s.delay = t.expectContinueTimeout() - if s.delay == 0 || - !httpguts.HeaderValuesContainsToken( - cs.req.Header["Expect"], - "100-continue") { - return - } - s.fnonce = new(sync.Once) - - // Arm the timer with a very large duration, which we'll - // intentionally lower later. It has to be large now because - // we need a handle to it before writing the headers, but the - // s.delay value is defined to not start until after the - // request headers were written. - const hugeDuration = 365 * 24 * time.Hour - s.timer = time.AfterFunc(hugeDuration, func() { - s.fnonce.Do(s.fn) - }) - return -} - -func (s bodyWriterState) cancel() { - if s.timer != nil { - if s.timer.Stop() { - s.resc <- nil - } - } -} - -func (s bodyWriterState) on100() { - if s.timer == nil { - // If we didn't do a delayed write, ignore the server's - // bogus 100 continue response. - return - } - s.timer.Stop() - go func() { s.fnonce.Do(s.fn) }() -} - -// scheduleBodyWrite starts writing the body, either immediately (in -// the common case) or after the delay timeout. It should not be -// called until after the headers have been written. -func (s bodyWriterState) scheduleBodyWrite() { - if s.timer == nil { - // We're not doing a delayed write (see - // getBodyWriterState), so just start the writing - // goroutine immediately. - go s.fn() - return - } - traceWait100Continue(s.cs.trace) - if s.timer.Stop() { - s.timer.Reset(s.delay) - } -} - // isConnectionCloseRequest reports whether req should use its own // connection for a single request and then close the connection. func isConnectionCloseRequest(req *http.Request) bool { diff --git a/vendor/golang.org/x/net/http2/writesched.go b/vendor/golang.org/x/net/http2/writesched.go index f24d2b1e7d..c7cd001739 100644 --- a/vendor/golang.org/x/net/http2/writesched.go +++ b/vendor/golang.org/x/net/http2/writesched.go @@ -32,7 +32,8 @@ type WriteScheduler interface { // Pop dequeues the next frame to write. Returns false if no frames can // be written. Frames with a given wr.StreamID() are Pop'd in the same - // order they are Push'd. No frames should be discarded except by CloseStream. + // order they are Push'd, except RST_STREAM frames. No frames should be + // discarded except by CloseStream. Pop() (wr FrameWriteRequest, ok bool) } @@ -52,6 +53,7 @@ type FrameWriteRequest struct { // stream is the stream on which this frame will be written. // nil for non-stream frames like PING and SETTINGS. + // nil for RST_STREAM streams, which use the StreamError.StreamID field instead. stream *stream // done, if non-nil, must be a buffered channel with space for diff --git a/vendor/golang.org/x/net/http2/writesched_random.go b/vendor/golang.org/x/net/http2/writesched_random.go index 9a7b9e581c..f2e55e05ce 100644 --- a/vendor/golang.org/x/net/http2/writesched_random.go +++ b/vendor/golang.org/x/net/http2/writesched_random.go @@ -45,11 +45,11 @@ func (ws *randomWriteScheduler) AdjustStream(streamID uint32, priority PriorityP } func (ws *randomWriteScheduler) Push(wr FrameWriteRequest) { - id := wr.StreamID() - if id == 0 { + if wr.isControl() { ws.zero.push(wr) return } + id := wr.StreamID() q, ok := ws.sq[id] if !ok { q = ws.queuePool.get() @@ -59,7 +59,7 @@ func (ws *randomWriteScheduler) Push(wr FrameWriteRequest) { } func (ws *randomWriteScheduler) Pop() (FrameWriteRequest, bool) { - // Control frames first. + // Control and RST_STREAM frames first. if !ws.zero.empty() { return ws.zero.shift(), true } diff --git a/vendor/golang.org/x/net/idna/go118.go b/vendor/golang.org/x/net/idna/go118.go new file mode 100644 index 0000000000..c5c4338dbe --- /dev/null +++ b/vendor/golang.org/x/net/idna/go118.go @@ -0,0 +1,14 @@ +// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. + +// Copyright 2021 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.18 +// +build go1.18 + +package idna + +// Transitional processing is disabled by default in Go 1.18. +// https://golang.org/issue/47510 +const transitionalLookup = false diff --git a/vendor/golang.org/x/net/idna/idna10.0.0.go b/vendor/golang.org/x/net/idna/idna10.0.0.go index 5208ba6cb8..64ccf85feb 100644 --- a/vendor/golang.org/x/net/idna/idna10.0.0.go +++ b/vendor/golang.org/x/net/idna/idna10.0.0.go @@ -59,10 +59,10 @@ type Option func(*options) // Transitional sets a Profile to use the Transitional mapping as defined in UTS // #46. This will cause, for example, "ß" to be mapped to "ss". Using the // transitional mapping provides a compromise between IDNA2003 and IDNA2008 -// compatibility. It is used by most browsers when resolving domain names. This +// compatibility. It is used by some browsers when resolving domain names. This // option is only meaningful if combined with MapForLookup. func Transitional(transitional bool) Option { - return func(o *options) { o.transitional = true } + return func(o *options) { o.transitional = transitional } } // VerifyDNSLength sets whether a Profile should fail if any of the IDN parts @@ -284,7 +284,7 @@ var ( punycode = &Profile{} lookup = &Profile{options{ - transitional: true, + transitional: transitionalLookup, useSTD3Rules: true, checkHyphens: true, checkJoiners: true, diff --git a/vendor/golang.org/x/net/idna/idna9.0.0.go b/vendor/golang.org/x/net/idna/idna9.0.0.go index 55f718f127..aae6aac872 100644 --- a/vendor/golang.org/x/net/idna/idna9.0.0.go +++ b/vendor/golang.org/x/net/idna/idna9.0.0.go @@ -58,10 +58,10 @@ type Option func(*options) // Transitional sets a Profile to use the Transitional mapping as defined in UTS // #46. This will cause, for example, "ß" to be mapped to "ss". Using the // transitional mapping provides a compromise between IDNA2003 and IDNA2008 -// compatibility. It is used by most browsers when resolving domain names. This +// compatibility. It is used by some browsers when resolving domain names. This // option is only meaningful if combined with MapForLookup. func Transitional(transitional bool) Option { - return func(o *options) { o.transitional = true } + return func(o *options) { o.transitional = transitional } } // VerifyDNSLength sets whether a Profile should fail if any of the IDN parts diff --git a/vendor/golang.org/x/net/idna/pre_go118.go b/vendor/golang.org/x/net/idna/pre_go118.go new file mode 100644 index 0000000000..3aaccab1c5 --- /dev/null +++ b/vendor/golang.org/x/net/idna/pre_go118.go @@ -0,0 +1,12 @@ +// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. + +// Copyright 2021 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build !go1.18 +// +build !go1.18 + +package idna + +const transitionalLookup = true diff --git a/vendor/golang.org/x/net/idna/punycode.go b/vendor/golang.org/x/net/idna/punycode.go index 02c7d59af3..e8e3ac11a9 100644 --- a/vendor/golang.org/x/net/idna/punycode.go +++ b/vendor/golang.org/x/net/idna/punycode.go @@ -49,6 +49,7 @@ func decode(encoded string) (string, error) { } } i, n, bias := int32(0), initialN, initialBias + overflow := false for pos < len(encoded) { oldI, w := i, int32(1) for k := base; ; k += base { @@ -60,29 +61,32 @@ func decode(encoded string) (string, error) { return "", punyError(encoded) } pos++ - i += digit * w - if i < 0 { + i, overflow = madd(i, digit, w) + if overflow { return "", punyError(encoded) } t := k - bias - if t < tmin { + if k <= bias { t = tmin - } else if t > tmax { + } else if k >= bias+tmax { t = tmax } if digit < t { break } - w *= base - t - if w >= math.MaxInt32/base { + w, overflow = madd(0, w, base-t) + if overflow { return "", punyError(encoded) } } + if len(output) >= 1024 { + return "", punyError(encoded) + } x := int32(len(output) + 1) bias = adapt(i-oldI, x, oldI == 0) n += i / x i %= x - if n > utf8.MaxRune || len(output) >= 1024 { + if n < 0 || n > utf8.MaxRune { return "", punyError(encoded) } output = append(output, 0) @@ -115,6 +119,7 @@ func encode(prefix, s string) (string, error) { if b > 0 { output = append(output, '-') } + overflow := false for remaining != 0 { m := int32(0x7fffffff) for _, r := range s { @@ -122,8 +127,8 @@ func encode(prefix, s string) (string, error) { m = r } } - delta += (m - n) * (h + 1) - if delta < 0 { + delta, overflow = madd(delta, m-n, h+1) + if overflow { return "", punyError(s) } n = m @@ -141,9 +146,9 @@ func encode(prefix, s string) (string, error) { q := delta for k := base; ; k += base { t := k - bias - if t < tmin { + if k <= bias { t = tmin - } else if t > tmax { + } else if k >= bias+tmax { t = tmax } if q < t { @@ -164,6 +169,15 @@ func encode(prefix, s string) (string, error) { return string(output), nil } +// madd computes a + (b * c), detecting overflow. +func madd(a, b, c int32) (next int32, overflow bool) { + p := int64(b) * int64(c) + if p > math.MaxInt32-int64(a) { + return 0, true + } + return a + int32(p), false +} + func decodeDigit(x byte) (digit int32, ok bool) { switch { case '0' <= x && x <= '9': diff --git a/vendor/golang.org/x/oauth2/authhandler/authhandler.go b/vendor/golang.org/x/oauth2/authhandler/authhandler.go new file mode 100644 index 0000000000..69967cf87e --- /dev/null +++ b/vendor/golang.org/x/oauth2/authhandler/authhandler.go @@ -0,0 +1,56 @@ +// Copyright 2021 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package authhandler implements a TokenSource to support +// "three-legged OAuth 2.0" via a custom AuthorizationHandler. +package authhandler + +import ( + "context" + "errors" + + "golang.org/x/oauth2" +) + +// AuthorizationHandler is a 3-legged-OAuth helper that prompts +// the user for OAuth consent at the specified auth code URL +// and returns an auth code and state upon approval. +type AuthorizationHandler func(authCodeURL string) (code string, state string, err error) + +// TokenSource returns an oauth2.TokenSource that fetches access tokens +// using 3-legged-OAuth flow. +// +// The provided context.Context is used for oauth2 Exchange operation. +// +// The provided oauth2.Config should be a full configuration containing AuthURL, +// TokenURL, and Scope. +// +// An environment-specific AuthorizationHandler is used to obtain user consent. +// +// Per the OAuth protocol, a unique "state" string should be specified here. +// This token source will verify that the "state" is identical in the request +// and response before exchanging the auth code for OAuth token to prevent CSRF +// attacks. +func TokenSource(ctx context.Context, config *oauth2.Config, state string, authHandler AuthorizationHandler) oauth2.TokenSource { + return oauth2.ReuseTokenSource(nil, authHandlerSource{config: config, ctx: ctx, authHandler: authHandler, state: state}) +} + +type authHandlerSource struct { + ctx context.Context + config *oauth2.Config + authHandler AuthorizationHandler + state string +} + +func (source authHandlerSource) Token() (*oauth2.Token, error) { + url := source.config.AuthCodeURL(source.state) + code, state, err := source.authHandler(url) + if err != nil { + return nil, err + } + if state != source.state { + return nil, errors.New("state mismatch in 3-legged-OAuth flow") + } + return source.config.Exchange(source.ctx, code) +} diff --git a/vendor/golang.org/x/oauth2/google/default.go b/vendor/golang.org/x/oauth2/google/default.go index ae391313d2..880dd7b59f 100644 --- a/vendor/golang.org/x/oauth2/google/default.go +++ b/vendor/golang.org/x/oauth2/google/default.go @@ -16,6 +16,7 @@ import ( "cloud.google.com/go/compute/metadata" "golang.org/x/oauth2" + "golang.org/x/oauth2/authhandler" ) // Credentials holds Google credentials, including "Application Default Credentials". @@ -41,6 +42,32 @@ type Credentials struct { // Deprecated: use Credentials instead. type DefaultCredentials = Credentials +// CredentialsParams holds user supplied parameters that are used together +// with a credentials file for building a Credentials object. +type CredentialsParams struct { + // Scopes is the list OAuth scopes. Required. + // Example: https://www.googleapis.com/auth/cloud-platform + Scopes []string + + // Subject is the user email used for domain wide delegation (see + // https://developers.google.com/identity/protocols/oauth2/service-account#delegatingauthority). + // Optional. + Subject string + + // AuthHandler is the AuthorizationHandler used for 3-legged OAuth flow. Optional. + AuthHandler authhandler.AuthorizationHandler + + // State is a unique string used with AuthHandler. Optional. + State string +} + +func (params CredentialsParams) deepCopy() CredentialsParams { + paramsCopy := params + paramsCopy.Scopes = make([]string, len(params.Scopes)) + copy(paramsCopy.Scopes, params.Scopes) + return paramsCopy +} + // DefaultClient returns an HTTP Client that uses the // DefaultTokenSource to obtain authentication credentials. func DefaultClient(ctx context.Context, scope ...string) (*http.Client, error) { @@ -62,7 +89,7 @@ func DefaultTokenSource(ctx context.Context, scope ...string) (oauth2.TokenSourc return creds.TokenSource, nil } -// FindDefaultCredentials searches for "Application Default Credentials". +// FindDefaultCredentialsWithParams searches for "Application Default Credentials". // // It looks for credentials in the following places, // preferring the first location found: @@ -81,11 +108,14 @@ func DefaultTokenSource(ctx context.Context, scope ...string) (oauth2.TokenSourc // 4. On Google Compute Engine, Google App Engine standard second generation runtimes // (>= Go 1.11), and Google App Engine flexible environment, it fetches // credentials from the metadata server. -func FindDefaultCredentials(ctx context.Context, scopes ...string) (*Credentials, error) { +func FindDefaultCredentialsWithParams(ctx context.Context, params CredentialsParams) (*Credentials, error) { + // Make defensive copy of the slices in params. + params = params.deepCopy() + // First, try the environment variable. const envVar = "GOOGLE_APPLICATION_CREDENTIALS" if filename := os.Getenv(envVar); filename != "" { - creds, err := readCredentialsFile(ctx, filename, scopes) + creds, err := readCredentialsFile(ctx, filename, params) if err != nil { return nil, fmt.Errorf("google: error getting credentials using %v environment variable: %v", envVar, err) } @@ -94,7 +124,7 @@ func FindDefaultCredentials(ctx context.Context, scopes ...string) (*Credentials // Second, try a well-known file. filename := wellKnownFile() - if creds, err := readCredentialsFile(ctx, filename, scopes); err == nil { + if creds, err := readCredentialsFile(ctx, filename, params); err == nil { return creds, nil } else if !os.IsNotExist(err) { return nil, fmt.Errorf("google: error getting credentials using well-known file (%v): %v", filename, err) @@ -106,7 +136,7 @@ func FindDefaultCredentials(ctx context.Context, scopes ...string) (*Credentials if appengineTokenFunc != nil { return &DefaultCredentials{ ProjectID: appengineAppIDFunc(ctx), - TokenSource: AppEngineTokenSource(ctx, scopes...), + TokenSource: AppEngineTokenSource(ctx, params.Scopes...), }, nil } @@ -116,7 +146,7 @@ func FindDefaultCredentials(ctx context.Context, scopes ...string) (*Credentials id, _ := metadata.ProjectID() return &DefaultCredentials{ ProjectID: id, - TokenSource: ComputeTokenSource("", scopes...), + TokenSource: ComputeTokenSource("", params.Scopes...), }, nil } @@ -125,18 +155,38 @@ func FindDefaultCredentials(ctx context.Context, scopes ...string) (*Credentials return nil, fmt.Errorf("google: could not find default credentials. See %v for more information.", url) } -// CredentialsFromJSON obtains Google credentials from a JSON value. The JSON can -// represent either a Google Developers Console client_credentials.json file (as in -// ConfigFromJSON), a Google Developers service account key file (as in -// JWTConfigFromJSON) or the JSON configuration file for workload identity federation -// in non-Google cloud platforms (see -// https://cloud.google.com/iam/docs/how-to#using-workload-identity-federation). -func CredentialsFromJSON(ctx context.Context, jsonData []byte, scopes ...string) (*Credentials, error) { +// FindDefaultCredentials invokes FindDefaultCredentialsWithParams with the specified scopes. +func FindDefaultCredentials(ctx context.Context, scopes ...string) (*Credentials, error) { + var params CredentialsParams + params.Scopes = scopes + return FindDefaultCredentialsWithParams(ctx, params) +} + +// CredentialsFromJSONWithParams obtains Google credentials from a JSON value. The JSON can +// represent either a Google Developers Console client_credentials.json file (as in ConfigFromJSON), +// a Google Developers service account key file, a gcloud user credentials file (a.k.a. refresh +// token JSON), or the JSON configuration file for workload identity federation in non-Google cloud +// platforms (see https://cloud.google.com/iam/docs/how-to#using-workload-identity-federation). +func CredentialsFromJSONWithParams(ctx context.Context, jsonData []byte, params CredentialsParams) (*Credentials, error) { + // Make defensive copy of the slices in params. + params = params.deepCopy() + + // First, attempt to parse jsonData as a Google Developers Console client_credentials.json. + config, _ := ConfigFromJSON(jsonData, params.Scopes...) + if config != nil { + return &Credentials{ + ProjectID: "", + TokenSource: authhandler.TokenSource(ctx, config, params.State, params.AuthHandler), + JSON: jsonData, + }, nil + } + + // Otherwise, parse jsonData as one of the other supported credentials files. var f credentialsFile if err := json.Unmarshal(jsonData, &f); err != nil { return nil, err } - ts, err := f.tokenSource(ctx, append([]string(nil), scopes...)) + ts, err := f.tokenSource(ctx, params) if err != nil { return nil, err } @@ -147,6 +197,13 @@ func CredentialsFromJSON(ctx context.Context, jsonData []byte, scopes ...string) }, nil } +// CredentialsFromJSON invokes CredentialsFromJSONWithParams with the specified scopes. +func CredentialsFromJSON(ctx context.Context, jsonData []byte, scopes ...string) (*Credentials, error) { + var params CredentialsParams + params.Scopes = scopes + return CredentialsFromJSONWithParams(ctx, jsonData, params) +} + func wellKnownFile() string { const f = "application_default_credentials.json" if runtime.GOOS == "windows" { @@ -155,10 +212,10 @@ func wellKnownFile() string { return filepath.Join(guessUnixHomeDir(), ".config", "gcloud", f) } -func readCredentialsFile(ctx context.Context, filename string, scopes []string) (*DefaultCredentials, error) { +func readCredentialsFile(ctx context.Context, filename string, params CredentialsParams) (*DefaultCredentials, error) { b, err := ioutil.ReadFile(filename) if err != nil { return nil, err } - return CredentialsFromJSON(ctx, b, scopes...) + return CredentialsFromJSONWithParams(ctx, b, params) } diff --git a/vendor/golang.org/x/oauth2/google/doc.go b/vendor/golang.org/x/oauth2/google/doc.go index b241c728a6..8e6a57ce96 100644 --- a/vendor/golang.org/x/oauth2/google/doc.go +++ b/vendor/golang.org/x/oauth2/google/doc.go @@ -4,9 +4,9 @@ // Package google provides support for making OAuth2 authorized and authenticated // HTTP requests to Google APIs. It supports the Web server flow, client-side -// credentials, service accounts, Google Compute Engine service accounts, Google -// App Engine service accounts and workload identity federation from non-Google -// cloud platforms. +// credentials, service accounts, Google Compute Engine service accounts, +// Google App Engine service accounts and workload identity federation +// from non-Google cloud platforms. // // A brief overview of the package follows. For more information, please read // https://developers.google.com/accounts/docs/OAuth2 diff --git a/vendor/golang.org/x/oauth2/google/google.go b/vendor/golang.org/x/oauth2/google/google.go index 2c8f1bd5ad..422ff1fe34 100644 --- a/vendor/golang.org/x/oauth2/google/google.go +++ b/vendor/golang.org/x/oauth2/google/google.go @@ -19,7 +19,7 @@ import ( "golang.org/x/oauth2/jwt" ) -// Endpoint is Google's OAuth 2.0 endpoint. +// Endpoint is Google's OAuth 2.0 default endpoint. var Endpoint = oauth2.Endpoint{ AuthURL: "https://accounts.google.com/o/oauth2/auth", TokenURL: "https://oauth2.googleapis.com/token", @@ -87,7 +87,7 @@ func JWTConfigFromJSON(jsonKey []byte, scope ...string) (*jwt.Config, error) { return nil, fmt.Errorf("google: read JWT from JSON credentials: 'type' field is %q (expected %q)", f.Type, serviceAccountKey) } scope = append([]string(nil), scope...) // copy - return f.jwtConfig(scope), nil + return f.jwtConfig(scope, ""), nil } // JSON key file types. @@ -99,12 +99,13 @@ const ( // credentialsFile is the unmarshalled representation of a credentials file. type credentialsFile struct { - Type string `json:"type"` // serviceAccountKey or userCredentialsKey + Type string `json:"type"` // Service Account fields ClientEmail string `json:"client_email"` PrivateKeyID string `json:"private_key_id"` PrivateKey string `json:"private_key"` + AuthURL string `json:"auth_uri"` TokenURL string `json:"token_uri"` ProjectID string `json:"project_id"` @@ -124,13 +125,14 @@ type credentialsFile struct { QuotaProjectID string `json:"quota_project_id"` } -func (f *credentialsFile) jwtConfig(scopes []string) *jwt.Config { +func (f *credentialsFile) jwtConfig(scopes []string, subject string) *jwt.Config { cfg := &jwt.Config{ Email: f.ClientEmail, PrivateKey: []byte(f.PrivateKey), PrivateKeyID: f.PrivateKeyID, Scopes: scopes, TokenURL: f.TokenURL, + Subject: subject, // This is the user email to impersonate } if cfg.TokenURL == "" { cfg.TokenURL = JWTTokenURL @@ -138,17 +140,27 @@ func (f *credentialsFile) jwtConfig(scopes []string) *jwt.Config { return cfg } -func (f *credentialsFile) tokenSource(ctx context.Context, scopes []string) (oauth2.TokenSource, error) { +func (f *credentialsFile) tokenSource(ctx context.Context, params CredentialsParams) (oauth2.TokenSource, error) { switch f.Type { case serviceAccountKey: - cfg := f.jwtConfig(scopes) + cfg := f.jwtConfig(params.Scopes, params.Subject) return cfg.TokenSource(ctx), nil case userCredentialsKey: cfg := &oauth2.Config{ ClientID: f.ClientID, ClientSecret: f.ClientSecret, - Scopes: scopes, - Endpoint: Endpoint, + Scopes: params.Scopes, + Endpoint: oauth2.Endpoint{ + AuthURL: f.AuthURL, + TokenURL: f.TokenURL, + AuthStyle: oauth2.AuthStyleInParams, + }, + } + if cfg.Endpoint.AuthURL == "" { + cfg.Endpoint.AuthURL = Endpoint.AuthURL + } + if cfg.Endpoint.TokenURL == "" { + cfg.Endpoint.TokenURL = Endpoint.TokenURL } tok := &oauth2.Token{RefreshToken: f.RefreshToken} return cfg.TokenSource(ctx, tok), nil @@ -163,9 +175,9 @@ func (f *credentialsFile) tokenSource(ctx context.Context, scopes []string) (oau ClientID: f.ClientID, CredentialSource: f.CredentialSource, QuotaProjectID: f.QuotaProjectID, - Scopes: scopes, + Scopes: params.Scopes, } - return cfg.TokenSource(ctx), nil + return cfg.TokenSource(ctx) case "": return nil, errors.New("missing 'type' field in credentials") default: diff --git a/vendor/golang.org/x/oauth2/google/internal/externalaccount/aws.go b/vendor/golang.org/x/oauth2/google/internal/externalaccount/aws.go index fbcefb474e..a5a5423c65 100644 --- a/vendor/golang.org/x/oauth2/google/internal/externalaccount/aws.go +++ b/vendor/golang.org/x/oauth2/google/internal/externalaccount/aws.go @@ -13,7 +13,6 @@ import ( "encoding/json" "errors" "fmt" - "golang.org/x/oauth2" "io" "io/ioutil" "net/http" @@ -23,6 +22,8 @@ import ( "sort" "strings" "time" + + "golang.org/x/oauth2" ) type awsSecurityCredentials struct { @@ -343,6 +344,9 @@ func (cs *awsCredentialSource) getRegion() (string, error) { if envAwsRegion := getenv("AWS_REGION"); envAwsRegion != "" { return envAwsRegion, nil } + if envAwsRegion := getenv("AWS_DEFAULT_REGION"); envAwsRegion != "" { + return envAwsRegion, nil + } if cs.RegionURL == "" { return "", errors.New("oauth2/google: unable to determine AWS region") diff --git a/vendor/golang.org/x/oauth2/google/internal/externalaccount/basecredentials.go b/vendor/golang.org/x/oauth2/google/internal/externalaccount/basecredentials.go index 1a6e93cec7..dab917f39e 100644 --- a/vendor/golang.org/x/oauth2/google/internal/externalaccount/basecredentials.go +++ b/vendor/golang.org/x/oauth2/google/internal/externalaccount/basecredentials.go @@ -7,10 +7,14 @@ package externalaccount import ( "context" "fmt" - "golang.org/x/oauth2" "net/http" + "net/url" + "regexp" "strconv" + "strings" "time" + + "golang.org/x/oauth2" ) // now aliases time.Now for testing @@ -20,26 +24,103 @@ var now = func() time.Time { // Config stores the configuration for fetching tokens with external credentials. type Config struct { - Audience string - SubjectTokenType string - TokenURL string - TokenInfoURL string + // Audience is the Secure Token Service (STS) audience which contains the resource name for the workload + // identity pool or the workforce pool and the provider identifier in that pool. + Audience string + // SubjectTokenType is the STS token type based on the Oauth2.0 token exchange spec + // e.g. `urn:ietf:params:oauth:token-type:jwt`. + SubjectTokenType string + // TokenURL is the STS token exchange endpoint. + TokenURL string + // TokenInfoURL is the token_info endpoint used to retrieve the account related information ( + // user attributes like account identifier, eg. email, username, uid, etc). This is + // needed for gCloud session account identification. + TokenInfoURL string + // ServiceAccountImpersonationURL is the URL for the service account impersonation request. This is only + // required for workload identity pools when APIs to be accessed have not integrated with UberMint. ServiceAccountImpersonationURL string - ClientSecret string - ClientID string - CredentialSource CredentialSource - QuotaProjectID string - Scopes []string + // ClientSecret is currently only required if token_info endpoint also + // needs to be called with the generated GCP access token. When provided, STS will be + // called with additional basic authentication using client_id as username and client_secret as password. + ClientSecret string + // ClientID is only required in conjunction with ClientSecret, as described above. + ClientID string + // CredentialSource contains the necessary information to retrieve the token itself, as well + // as some environmental information. + CredentialSource CredentialSource + // QuotaProjectID is injected by gCloud. If the value is non-empty, the Auth libraries + // will set the x-goog-user-project which overrides the project associated with the credentials. + QuotaProjectID string + // Scopes contains the desired scopes for the returned access token. + Scopes []string +} + +// Each element consists of a list of patterns. validateURLs checks for matches +// that include all elements in a given list, in that order. + +var ( + validTokenURLPatterns = []*regexp.Regexp{ + // The complicated part in the middle matches any number of characters that + // aren't period, spaces, or slashes. + regexp.MustCompile(`(?i)^[^\.\s\/\\]+\.sts\.googleapis\.com$`), + regexp.MustCompile(`(?i)^sts\.googleapis\.com$`), + regexp.MustCompile(`(?i)^sts\.[^\.\s\/\\]+\.googleapis\.com$`), + regexp.MustCompile(`(?i)^[^\.\s\/\\]+-sts\.googleapis\.com$`), + } + validImpersonateURLPatterns = []*regexp.Regexp{ + regexp.MustCompile(`^[^\.\s\/\\]+\.iamcredentials\.googleapis\.com$`), + regexp.MustCompile(`^iamcredentials\.googleapis\.com$`), + regexp.MustCompile(`^iamcredentials\.[^\.\s\/\\]+\.googleapis\.com$`), + regexp.MustCompile(`^[^\.\s\/\\]+-iamcredentials\.googleapis\.com$`), + } +) + +func validateURL(input string, patterns []*regexp.Regexp, scheme string) bool { + parsed, err := url.Parse(input) + if err != nil { + return false + } + if !strings.EqualFold(parsed.Scheme, scheme) { + return false + } + toTest := parsed.Host + + for _, pattern := range patterns { + + if valid := pattern.MatchString(toTest); valid { + return true + } + } + return false } // TokenSource Returns an external account TokenSource struct. This is to be called by package google to construct a google.Credentials. -func (c *Config) TokenSource(ctx context.Context) oauth2.TokenSource { +func (c *Config) TokenSource(ctx context.Context) (oauth2.TokenSource, error) { + return c.tokenSource(ctx, validTokenURLPatterns, validImpersonateURLPatterns, "https") +} + +// tokenSource is a private function that's directly called by some of the tests, +// because the unit test URLs are mocked, and would otherwise fail the +// validity check. +func (c *Config) tokenSource(ctx context.Context, tokenURLValidPats []*regexp.Regexp, impersonateURLValidPats []*regexp.Regexp, scheme string) (oauth2.TokenSource, error) { + valid := validateURL(c.TokenURL, tokenURLValidPats, scheme) + if !valid { + return nil, fmt.Errorf("oauth2/google: invalid TokenURL provided while constructing tokenSource") + } + + if c.ServiceAccountImpersonationURL != "" { + valid := validateURL(c.ServiceAccountImpersonationURL, impersonateURLValidPats, scheme) + if !valid { + return nil, fmt.Errorf("oauth2/google: invalid ServiceAccountImpersonationURL provided while constructing tokenSource") + } + } + ts := tokenSource{ ctx: ctx, conf: c, } if c.ServiceAccountImpersonationURL == "" { - return oauth2.ReuseTokenSource(nil, ts) + return oauth2.ReuseTokenSource(nil, ts), nil } scopes := c.Scopes ts.conf.Scopes = []string{"https://www.googleapis.com/auth/cloud-platform"} @@ -49,7 +130,7 @@ func (c *Config) TokenSource(ctx context.Context) oauth2.TokenSource { scopes: scopes, ts: oauth2.ReuseTokenSource(nil, ts), } - return oauth2.ReuseTokenSource(nil, imp) + return oauth2.ReuseTokenSource(nil, imp), nil } // Subject token file types. @@ -59,13 +140,15 @@ const ( ) type format struct { - // Type is either "text" or "json". When not provided "text" type is assumed. + // Type is either "text" or "json". When not provided "text" type is assumed. Type string `json:"type"` - // SubjectTokenFieldName is only required for JSON format. This would be "access_token" for azure. + // SubjectTokenFieldName is only required for JSON format. This would be "access_token" for azure. SubjectTokenFieldName string `json:"subject_token_field_name"` } // CredentialSource stores the information necessary to retrieve the credentials for the STS exchange. +// Either the File or the URL field should be filled, depending on the kind of credential in question. +// The EnvironmentID should start with AWS if being used for an AWS credential. type CredentialSource struct { File string `json:"file"` @@ -107,7 +190,7 @@ type baseCredentialSource interface { subjectToken() (string, error) } -// tokenSource is the source that handles external credentials. +// tokenSource is the source that handles external credentials. It is used to retrieve Tokens. type tokenSource struct { ctx context.Context conf *Config diff --git a/vendor/golang.org/x/oauth2/google/internal/externalaccount/clientauth.go b/vendor/golang.org/x/oauth2/google/internal/externalaccount/clientauth.go index feccf8b68e..99987ce294 100644 --- a/vendor/golang.org/x/oauth2/google/internal/externalaccount/clientauth.go +++ b/vendor/golang.org/x/oauth2/google/internal/externalaccount/clientauth.go @@ -6,9 +6,10 @@ package externalaccount import ( "encoding/base64" - "golang.org/x/oauth2" "net/http" "net/url" + + "golang.org/x/oauth2" ) // clientAuthentication represents an OAuth client ID and secret and the mechanism for passing these credentials as stated in rfc6749#2.3.1. @@ -19,6 +20,9 @@ type clientAuthentication struct { ClientSecret string } +// InjectAuthentication is used to add authentication to a Secure Token Service exchange +// request. It modifies either the passed url.Values or http.Header depending on the desired +// authentication format. func (c *clientAuthentication) InjectAuthentication(values url.Values, headers http.Header) { if c.ClientID == "" || c.ClientSecret == "" || values == nil || headers == nil { return diff --git a/vendor/golang.org/x/oauth2/google/internal/externalaccount/impersonate.go b/vendor/golang.org/x/oauth2/google/internal/externalaccount/impersonate.go index 1d29c467f7..64edb56001 100644 --- a/vendor/golang.org/x/oauth2/google/internal/externalaccount/impersonate.go +++ b/vendor/golang.org/x/oauth2/google/internal/externalaccount/impersonate.go @@ -9,11 +9,12 @@ import ( "context" "encoding/json" "fmt" - "golang.org/x/oauth2" "io" "io/ioutil" "net/http" "time" + + "golang.org/x/oauth2" ) // generateAccesstokenReq is used for service account impersonation @@ -36,7 +37,7 @@ type impersonateTokenSource struct { scopes []string } -// Token performs the exchange to get a temporary service account +// Token performs the exchange to get a temporary service account token to allow access to GCP. func (its impersonateTokenSource) Token() (*oauth2.Token, error) { reqBody := generateAccessTokenReq{ Lifetime: "3600s", diff --git a/vendor/golang.org/x/oauth2/google/internal/externalaccount/sts_exchange.go b/vendor/golang.org/x/oauth2/google/internal/externalaccount/sts_exchange.go index a8a704bb41..e6fcae5fcb 100644 --- a/vendor/golang.org/x/oauth2/google/internal/externalaccount/sts_exchange.go +++ b/vendor/golang.org/x/oauth2/google/internal/externalaccount/sts_exchange.go @@ -65,6 +65,9 @@ func exchangeToken(ctx context.Context, endpoint string, request *stsTokenExchan defer resp.Body.Close() body, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1<<20)) + if err != nil { + return nil, err + } if c := resp.StatusCode; c < 200 || c > 299 { return nil, fmt.Errorf("oauth2/google: status code %d: %s", c, body) } diff --git a/vendor/golang.org/x/oauth2/google/internal/externalaccount/urlcredsource.go b/vendor/golang.org/x/oauth2/google/internal/externalaccount/urlcredsource.go index 91b8f2002a..16dca6541d 100644 --- a/vendor/golang.org/x/oauth2/google/internal/externalaccount/urlcredsource.go +++ b/vendor/golang.org/x/oauth2/google/internal/externalaccount/urlcredsource.go @@ -9,10 +9,11 @@ import ( "encoding/json" "errors" "fmt" - "golang.org/x/oauth2" "io" "io/ioutil" "net/http" + + "golang.org/x/oauth2" ) type urlCredentialSource struct { diff --git a/vendor/golang.org/x/oauth2/google/jwt.go b/vendor/golang.org/x/oauth2/google/jwt.go index b0fdb3a888..67d97b9904 100644 --- a/vendor/golang.org/x/oauth2/google/jwt.go +++ b/vendor/golang.org/x/oauth2/google/jwt.go @@ -7,6 +7,7 @@ package google import ( "crypto/rsa" "fmt" + "strings" "time" "golang.org/x/oauth2" @@ -24,6 +25,28 @@ import ( // optimization supported by a few Google services. // Unless you know otherwise, you should use JWTConfigFromJSON instead. func JWTAccessTokenSourceFromJSON(jsonKey []byte, audience string) (oauth2.TokenSource, error) { + return newJWTSource(jsonKey, audience, nil) +} + +// JWTAccessTokenSourceWithScope uses a Google Developers service account JSON +// key file to read the credentials that authorize and authenticate the +// requests, and returns a TokenSource that does not use any OAuth2 flow but +// instead creates a JWT and sends that as the access token. +// The scope is typically a list of URLs that specifies the scope of the +// credentials. +// +// Note that this is not a standard OAuth flow, but rather an +// optimization supported by a few Google services. +// Unless you know otherwise, you should use JWTConfigFromJSON instead. +func JWTAccessTokenSourceWithScope(jsonKey []byte, scope ...string) (oauth2.TokenSource, error) { + return newJWTSource(jsonKey, "", scope) +} + +func newJWTSource(jsonKey []byte, audience string, scopes []string) (oauth2.TokenSource, error) { + if len(scopes) == 0 && audience == "" { + return nil, fmt.Errorf("google: missing scope/audience for JWT access token") + } + cfg, err := JWTConfigFromJSON(jsonKey) if err != nil { return nil, fmt.Errorf("google: could not parse JSON key: %v", err) @@ -35,6 +58,7 @@ func JWTAccessTokenSourceFromJSON(jsonKey []byte, audience string) (oauth2.Token ts := &jwtAccessTokenSource{ email: cfg.Email, audience: audience, + scopes: scopes, pk: pk, pkID: cfg.PrivateKeyID, } @@ -47,6 +71,7 @@ func JWTAccessTokenSourceFromJSON(jsonKey []byte, audience string) (oauth2.Token type jwtAccessTokenSource struct { email, audience string + scopes []string pk *rsa.PrivateKey pkID string } @@ -54,12 +79,14 @@ type jwtAccessTokenSource struct { func (ts *jwtAccessTokenSource) Token() (*oauth2.Token, error) { iat := time.Now() exp := iat.Add(time.Hour) + scope := strings.Join(ts.scopes, " ") cs := &jws.ClaimSet{ - Iss: ts.email, - Sub: ts.email, - Aud: ts.audience, - Iat: iat.Unix(), - Exp: exp.Unix(), + Iss: ts.email, + Sub: ts.email, + Aud: ts.audience, + Scope: scope, + Iat: iat.Unix(), + Exp: exp.Unix(), } hdr := &jws.Header{ Algorithm: "RS256", diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh index 0bcb8c3226..a74ef58f8c 100644 --- a/vendor/golang.org/x/sys/unix/mkerrors.sh +++ b/vendor/golang.org/x/sys/unix/mkerrors.sh @@ -54,7 +54,7 @@ includes_AIX=' includes_Darwin=' #define _DARWIN_C_SOURCE -#define KERNEL +#define KERNEL 1 #define _DARWIN_USE_64_BIT_INODE #define __APPLE_USE_RFC_3542 #include @@ -75,6 +75,7 @@ includes_Darwin=' #include #include #include +#include #include #include #include @@ -82,6 +83,9 @@ includes_Darwin=' #include #include #include + +// for backwards compatibility because moved TIOCREMOTE to Kernel.framework after MacOSX12.0.sdk. +#define TIOCREMOTE 0x80047469 ' includes_DragonFly=' @@ -229,6 +233,7 @@ struct ltchars { #include #include #include +#include #include #include #include @@ -465,7 +470,6 @@ ccflags="$@" $2 !~ /^EQUIV_/ && $2 !~ /^EXPR_/ && $2 !~ /^EVIOC/ && - $2 !~ /^EV_/ && $2 ~ /^E[A-Z0-9_]+$/ || $2 ~ /^B[0-9_]+$/ || $2 ~ /^(OLD|NEW)DEV$/ || @@ -497,6 +501,7 @@ ccflags="$@" $2 ~ /^O?XTABS$/ || $2 ~ /^TC[IO](ON|OFF)$/ || $2 ~ /^IN_/ || + $2 ~ /^LANDLOCK_/ || $2 ~ /^LOCK_(SH|EX|NB|UN)$/ || $2 ~ /^LO_(KEY|NAME)_SIZE$/ || $2 ~ /^LOOP_(CLR|CTL|GET|SET)_/ || diff --git a/vendor/golang.org/x/sys/unix/sockcmsg_linux.go b/vendor/golang.org/x/sys/unix/sockcmsg_linux.go index 8bf4570594..326fb04a52 100644 --- a/vendor/golang.org/x/sys/unix/sockcmsg_linux.go +++ b/vendor/golang.org/x/sys/unix/sockcmsg_linux.go @@ -34,3 +34,56 @@ func ParseUnixCredentials(m *SocketControlMessage) (*Ucred, error) { ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0])) return &ucred, nil } + +// PktInfo4 encodes Inet4Pktinfo into a socket control message of type IP_PKTINFO. +func PktInfo4(info *Inet4Pktinfo) []byte { + b := make([]byte, CmsgSpace(SizeofInet4Pktinfo)) + h := (*Cmsghdr)(unsafe.Pointer(&b[0])) + h.Level = SOL_IP + h.Type = IP_PKTINFO + h.SetLen(CmsgLen(SizeofInet4Pktinfo)) + *(*Inet4Pktinfo)(h.data(0)) = *info + return b +} + +// PktInfo6 encodes Inet6Pktinfo into a socket control message of type IPV6_PKTINFO. +func PktInfo6(info *Inet6Pktinfo) []byte { + b := make([]byte, CmsgSpace(SizeofInet6Pktinfo)) + h := (*Cmsghdr)(unsafe.Pointer(&b[0])) + h.Level = SOL_IPV6 + h.Type = IPV6_PKTINFO + h.SetLen(CmsgLen(SizeofInet6Pktinfo)) + *(*Inet6Pktinfo)(h.data(0)) = *info + return b +} + +// ParseOrigDstAddr decodes a socket control message containing the original +// destination address. To receive such a message the IP_RECVORIGDSTADDR or +// IPV6_RECVORIGDSTADDR option must be enabled on the socket. +func ParseOrigDstAddr(m *SocketControlMessage) (Sockaddr, error) { + switch { + case m.Header.Level == SOL_IP && m.Header.Type == IP_ORIGDSTADDR: + pp := (*RawSockaddrInet4)(unsafe.Pointer(&m.Data[0])) + sa := new(SockaddrInet4) + p := (*[2]byte)(unsafe.Pointer(&pp.Port)) + sa.Port = int(p[0])<<8 + int(p[1]) + for i := 0; i < len(sa.Addr); i++ { + sa.Addr[i] = pp.Addr[i] + } + return sa, nil + + case m.Header.Level == SOL_IPV6 && m.Header.Type == IPV6_ORIGDSTADDR: + pp := (*RawSockaddrInet6)(unsafe.Pointer(&m.Data[0])) + sa := new(SockaddrInet6) + p := (*[2]byte)(unsafe.Pointer(&pp.Port)) + sa.Port = int(p[0])<<8 + int(p[1]) + sa.ZoneId = pp.Scope_id + for i := 0; i < len(sa.Addr); i++ { + sa.Addr[i] = pp.Addr[i] + } + return sa, nil + + default: + return nil, EINVAL + } +} diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go index 23f6b57606..a8c13317d7 100644 --- a/vendor/golang.org/x/sys/unix/syscall_darwin.go +++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go @@ -48,6 +48,30 @@ func (sa *SockaddrCtl) sockaddr() (unsafe.Pointer, _Socklen, error) { return unsafe.Pointer(&sa.raw), SizeofSockaddrCtl, nil } +// SockaddrVM implements the Sockaddr interface for AF_VSOCK type sockets. +// SockaddrVM provides access to Darwin VM sockets: a mechanism that enables +// bidirectional communication between a hypervisor and its guest virtual +// machines. +type SockaddrVM struct { + // CID and Port specify a context ID and port address for a VM socket. + // Guests have a unique CID, and hosts may have a well-known CID of: + // - VMADDR_CID_HYPERVISOR: refers to the hypervisor process. + // - VMADDR_CID_LOCAL: refers to local communication (loopback). + // - VMADDR_CID_HOST: refers to other processes on the host. + CID uint32 + Port uint32 + raw RawSockaddrVM +} + +func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) { + sa.raw.Len = SizeofSockaddrVM + sa.raw.Family = AF_VSOCK + sa.raw.Port = sa.Port + sa.raw.Cid = sa.CID + + return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil +} + func anyToSockaddrGOOS(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { switch rsa.Addr.Family { case AF_SYSTEM: @@ -58,6 +82,13 @@ func anyToSockaddrGOOS(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { sa.Unit = pp.Sc_unit return sa, nil } + case AF_VSOCK: + pp := (*RawSockaddrVM)(unsafe.Pointer(rsa)) + sa := &SockaddrVM{ + CID: pp.Cid, + Port: pp.Port, + } + return sa, nil } return nil, EAFNOSUPPORT } @@ -433,6 +464,11 @@ func SysctlKinfoProcSlice(name string) ([]KinfoProc, error) { //sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) +//sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) +//sys shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) +//sys shmdt(addr uintptr) (err error) +//sys shmget(key int, size int, flag int) (id int, err error) + /* * Exposed directly */ @@ -590,10 +626,6 @@ func SysctlKinfoProcSlice(name string) ([]KinfoProc, error) { // Msgget // Msgsnd // Msgrcv -// Shmat -// Shmctl -// Shmdt -// Shmget // Shm_open // Shm_unlink // Sem_open diff --git a/vendor/golang.org/x/sys/unix/syscall_illumos.go b/vendor/golang.org/x/sys/unix/syscall_illumos.go index 8c53576835..8d5f294c42 100644 --- a/vendor/golang.org/x/sys/unix/syscall_illumos.go +++ b/vendor/golang.org/x/sys/unix/syscall_illumos.go @@ -162,6 +162,14 @@ func (l *Lifreq) GetLifruInt() int { return *(*int)(unsafe.Pointer(&l.Lifru[0])) } +func (l *Lifreq) SetLifruUint(d uint) { + *(*uint)(unsafe.Pointer(&l.Lifru[0])) = d +} + +func (l *Lifreq) GetLifruUint() uint { + return *(*uint)(unsafe.Pointer(&l.Lifru[0])) +} + func IoctlLifreq(fd int, req uint, l *Lifreq) error { return ioctl(fd, req, uintptr(unsafe.Pointer(l))) } diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go index 2839435e3d..fff38a84c9 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux.go @@ -13,7 +13,6 @@ package unix import ( "encoding/binary" - "runtime" "syscall" "unsafe" ) @@ -38,6 +37,13 @@ func Creat(path string, mode uint32) (fd int, err error) { return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode) } +func EpollCreate(size int) (fd int, err error) { + if size <= 0 { + return -1, EINVAL + } + return EpollCreate1(0) +} + //sys FanotifyInit(flags uint, event_f_flags uint) (fd int, err error) //sys fanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname *byte) (err error) @@ -66,6 +72,10 @@ func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) { return fchmodat(dirfd, path, mode) } +func InotifyInit() (fd int, err error) { + return InotifyInit1(0) +} + //sys ioctl(fd int, req uint, arg uintptr) (err error) = SYS_IOCTL //sys ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) = SYS_IOCTL @@ -109,6 +119,23 @@ func Openat2(dirfd int, path string, how *OpenHow) (fd int, err error) { return openat2(dirfd, path, how, SizeofOpenHow) } +func Pipe(p []int) error { + return Pipe2(p, 0) +} + +//sysnb pipe2(p *[2]_C_int, flags int) (err error) + +func Pipe2(p []int, flags int) error { + if len(p) != 2 { + return EINVAL + } + var pp [2]_C_int + err := pipe2(&pp, flags) + p[0] = int(pp[0]) + p[1] = int(pp[1]) + return err +} + //sys ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error) func Ppoll(fds []PollFd, timeout *Timespec, sigmask *Sigset_t) (n int, err error) { @@ -118,6 +145,15 @@ func Ppoll(fds []PollFd, timeout *Timespec, sigmask *Sigset_t) (n int, err error return ppoll(&fds[0], len(fds), timeout, sigmask) } +func Poll(fds []PollFd, timeout int) (n int, err error) { + var ts *Timespec + if timeout >= 0 { + ts = new(Timespec) + *ts = NsecToTimespec(int64(timeout) * 1e6) + } + return Ppoll(fds, ts, nil) +} + //sys Readlinkat(dirfd int, path string, buf []byte) (n int, err error) func Readlink(path string, buf []byte) (n int, err error) { @@ -168,27 +204,7 @@ func Utimes(path string, tv []Timeval) error { //sys utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error) func UtimesNano(path string, ts []Timespec) error { - if ts == nil { - err := utimensat(AT_FDCWD, path, nil, 0) - if err != ENOSYS { - return err - } - return utimes(path, nil) - } - if len(ts) != 2 { - return EINVAL - } - err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) - if err != ENOSYS { - return err - } - // If the utimensat syscall isn't available (utimensat was added to Linux - // in 2.6.22, Released, 8 July 2007) then fall back to utimes - var tv [2]Timeval - for i := 0; i < 2; i++ { - tv[i] = NsecToTimeval(TimespecToNsec(ts[i])) - } - return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) + return UtimesNanoAt(AT_FDCWD, path, ts, 0) } func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { @@ -1229,11 +1245,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { func Accept(fd int) (nfd int, sa Sockaddr, err error) { var rsa RawSockaddrAny var len _Socklen = SizeofSockaddrAny - // Try accept4 first for Android, then try accept for kernel older than 2.6.28 nfd, err = accept4(fd, &rsa, &len, 0) - if err == ENOSYS { - nfd, err = accept(fd, &rsa, &len) - } if err != nil { return } @@ -1816,11 +1828,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e //sys Dup(oldfd int) (fd int, err error) func Dup2(oldfd, newfd int) error { - // Android O and newer blocks dup2; riscv and arm64 don't implement dup2. - if runtime.GOOS == "android" || runtime.GOARCH == "riscv64" || runtime.GOARCH == "arm64" { - return Dup3(oldfd, newfd, 0) - } - return dup2(oldfd, newfd) + return Dup3(oldfd, newfd, 0) } //sys Dup3(oldfd int, newfd int, flags int) (err error) @@ -2308,6 +2316,14 @@ type RemoteIovec struct { //sys ProcessVMReadv(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_READV //sys ProcessVMWritev(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_WRITEV +//sys PidfdOpen(pid int, flags int) (fd int, err error) = SYS_PIDFD_OPEN +//sys PidfdGetfd(pidfd int, targetfd int, flags int) (fd int, err error) = SYS_PIDFD_GETFD + +//sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) +//sys shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) +//sys shmdt(addr uintptr) (err error) +//sys shmget(key int, size int, flag int) (id int, err error) + /* * Unimplemented */ @@ -2389,10 +2405,6 @@ type RemoteIovec struct { // SetRobustList // SetThreadArea // SetTidAddress -// Shmat -// Shmctl -// Shmdt -// Shmget // Sigaltstack // Swapoff // Swapon diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_386.go b/vendor/golang.org/x/sys/unix/syscall_linux_386.go index 91317d749a..5f757e8aa7 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_386.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_386.go @@ -19,36 +19,8 @@ func setTimeval(sec, usec int64) Timeval { return Timeval{Sec: int32(sec), Usec: int32(usec)} } -//sysnb pipe(p *[2]_C_int) (err error) - -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe(&pp) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - // 64-bit file system and 32-bit uid calls // (386 default is 32-bit file system and 16-bit uid). -//sys dup2(oldfd int, newfd int) (err error) -//sysnb EpollCreate(size int) (fd int, err error) //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64_64 //sys Fchown(fd int, uid int, gid int) (err error) = SYS_FCHOWN32 @@ -59,7 +31,6 @@ func Pipe2(p []int, flags int) (err error) { //sysnb Geteuid() (euid int) = SYS_GETEUID32 //sysnb Getgid() (gid int) = SYS_GETGID32 //sysnb Getuid() (uid int) = SYS_GETUID32 -//sysnb InotifyInit() (fd int, err error) //sys Ioperm(from int, num int, on int) (err error) //sys Iopl(level int) (err error) //sys Lchown(path string, uid int, gid int) (err error) = SYS_LCHOWN32 @@ -381,12 +352,3 @@ func (cmsg *Cmsghdr) SetLen(length int) { func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint32(length) } - -//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) - -func Poll(fds []PollFd, timeout int) (n int, err error) { - if len(fds) == 0 { - return poll(nil, 0, timeout) - } - return poll(&fds[0], len(fds), timeout) -} diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go b/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go index 85cd97da09..4299125aa7 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go @@ -7,8 +7,6 @@ package unix -//sys dup2(oldfd int, newfd int) (err error) -//sysnb EpollCreate(size int) (fd int, err error) //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64 //sys Fchown(fd int, uid int, gid int) (err error) @@ -21,17 +19,6 @@ package unix //sysnb Getgid() (gid int) //sysnb Getrlimit(resource int, rlim *Rlimit) (err error) //sysnb Getuid() (uid int) -//sysnb inotifyInit() (fd int, err error) - -func InotifyInit() (fd int, err error) { - // First try inotify_init1, because Android's seccomp policy blocks the latter. - fd, err = InotifyInit1(0) - if err == ENOSYS { - fd, err = inotifyInit() - } - return -} - //sys Ioperm(from int, num int, on int) (err error) //sys Iopl(level int) (err error) //sys Lchown(path string, uid int, gid int) (err error) @@ -126,32 +113,6 @@ func setTimeval(sec, usec int64) Timeval { return Timeval{Sec: sec, Usec: usec} } -//sysnb pipe(p *[2]_C_int) (err error) - -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe(&pp) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - func (r *PtraceRegs) PC() uint64 { return r.Rip } func (r *PtraceRegs) SetPC(pc uint64) { r.Rip = pc } @@ -176,15 +137,6 @@ func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint64(length) } -//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) - -func Poll(fds []PollFd, timeout int) (n int, err error) { - if len(fds) == 0 { - return poll(nil, 0, timeout) - } - return poll(&fds[0], len(fds), timeout) -} - //sys kexecFileLoad(kernelFd int, initrdFd int, cmdlineLen int, cmdline string, flags int) (err error) func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error { diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_arm.go b/vendor/golang.org/x/sys/unix/syscall_linux_arm.go index b961a620e9..79edeb9cb1 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_arm.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_arm.go @@ -19,36 +19,6 @@ func setTimeval(sec, usec int64) Timeval { return Timeval{Sec: int32(sec), Usec: int32(usec)} } -//sysnb pipe(p *[2]_C_int) (err error) - -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - // Try pipe2 first for Android O, then try pipe for kernel 2.6.23. - err = pipe2(&pp, 0) - if err == ENOSYS { - err = pipe(&pp) - } - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - func Seek(fd int, offset int64, whence int) (newoffset int64, err error) { newoffset, errno := seek(fd, offset, whence) if errno != 0 { @@ -76,8 +46,6 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) { // 64-bit file system and 32-bit uid calls // (16-bit uid calls are not always supported in newer kernels) -//sys dup2(oldfd int, newfd int) (err error) -//sysnb EpollCreate(size int) (fd int, err error) //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fchown(fd int, uid int, gid int) (err error) = SYS_FCHOWN32 //sys Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64 @@ -86,7 +54,6 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) { //sysnb Geteuid() (euid int) = SYS_GETEUID32 //sysnb Getgid() (gid int) = SYS_GETGID32 //sysnb Getuid() (uid int) = SYS_GETUID32 -//sysnb InotifyInit() (fd int, err error) //sys Lchown(path string, uid int, gid int) (err error) = SYS_LCHOWN32 //sys Listen(s int, n int) (err error) //sys Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64 @@ -260,15 +227,6 @@ func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint32(length) } -//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) - -func Poll(fds []PollFd, timeout int) (n int, err error) { - if len(fds) == 0 { - return poll(nil, 0, timeout) - } - return poll(&fds[0], len(fds), timeout) -} - //sys armSyncFileRange(fd int, flags int, off int64, n int64) (err error) = SYS_ARM_SYNC_FILE_RANGE func SyncFileRange(fd int, off int64, n int64, flags int) error { diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go index 4b977ba44b..862890de29 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go @@ -9,13 +9,6 @@ package unix import "unsafe" -func EpollCreate(size int) (fd int, err error) { - if size <= 0 { - return -1, EINVAL - } - return EpollCreate1(0) -} - //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) = SYS_EPOLL_PWAIT //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64 //sys Fchown(fd int, uid int, gid int) (err error) @@ -145,30 +138,6 @@ func utimes(path string, tv *[2]Timeval) (err error) { return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) } -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, 0) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - // Getrlimit prefers the prlimit64 system call. See issue 38604. func Getrlimit(resource int, rlim *Rlimit) error { err := Prlimit(0, resource, nil, rlim) @@ -211,31 +180,11 @@ func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint64(length) } -func InotifyInit() (fd int, err error) { - return InotifyInit1(0) -} - -// dup2 exists because func Dup3 in syscall_linux.go references -// it in an unreachable path. dup2 isn't available on arm64. -func dup2(oldfd int, newfd int) error - func Pause() error { _, err := ppoll(nil, 0, nil, nil) return err } -func Poll(fds []PollFd, timeout int) (n int, err error) { - var ts *Timespec - if timeout >= 0 { - ts = new(Timespec) - *ts = NsecToTimespec(int64(timeout) * 1e6) - } - if len(fds) == 0 { - return ppoll(nil, 0, ts, nil) - } - return ppoll(&fds[0], len(fds), ts, nil) -} - //sys kexecFileLoad(kernelFd int, initrdFd int, cmdlineLen int, cmdline string, flags int) (err error) func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error { diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go b/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go index 27aee81d97..8932e34ad2 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go @@ -8,8 +8,6 @@ package unix -//sys dup2(oldfd int, newfd int) (err error) -//sysnb EpollCreate(size int) (fd int, err error) //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64 //sys Fchown(fd int, uid int, gid int) (err error) @@ -94,30 +92,6 @@ func setTimeval(sec, usec int64) Timeval { return Timeval{Sec: sec, Usec: usec} } -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, 0) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - func Ioperm(from int, num int, on int) (err error) { return ENOSYS } @@ -220,16 +194,3 @@ func (cmsg *Cmsghdr) SetLen(length int) { func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint64(length) } - -func InotifyInit() (fd int, err error) { - return InotifyInit1(0) -} - -//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) - -func Poll(fds []PollFd, timeout int) (n int, err error) { - if len(fds) == 0 { - return poll(nil, 0, timeout) - } - return poll(&fds[0], len(fds), timeout) -} diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go b/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go index 21d74e2fbe..7821c25d9f 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go @@ -15,8 +15,6 @@ import ( func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) -//sys dup2(oldfd int, newfd int) (err error) -//sysnb EpollCreate(size int) (fd int, err error) //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64 //sys Fchown(fd int, uid int, gid int) (err error) @@ -60,7 +58,6 @@ func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) -//sysnb InotifyInit() (fd int, err error) //sys Ioperm(from int, num int, on int) (err error) //sys Iopl(level int) (err error) @@ -113,29 +110,6 @@ func setTimeval(sec, usec int64) Timeval { return Timeval{Sec: int32(sec), Usec: int32(usec)} } -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe() (p1 int, p2 int, err error) - -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - p[0], p[1], err = pipe() - return -} - //sys mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error) func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) { @@ -232,12 +206,3 @@ func (cmsg *Cmsghdr) SetLen(length int) { func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint32(length) } - -//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) - -func Poll(fds []PollFd, timeout int) (n int, err error) { - if len(fds) == 0 { - return poll(nil, 0, timeout) - } - return poll(&fds[0], len(fds), timeout) -} diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_ppc.go b/vendor/golang.org/x/sys/unix/syscall_linux_ppc.go index 6f1fc581ed..c5053a0f03 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_ppc.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_ppc.go @@ -12,8 +12,6 @@ import ( "unsafe" ) -//sys dup2(oldfd int, newfd int) (err error) -//sysnb EpollCreate(size int) (fd int, err error) //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fchown(fd int, uid int, gid int) (err error) //sys Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64 @@ -23,7 +21,6 @@ import ( //sysnb Geteuid() (euid int) //sysnb Getgid() (gid int) //sysnb Getuid() (uid int) -//sysnb InotifyInit() (fd int, err error) //sys Ioperm(from int, num int, on int) (err error) //sys Iopl(level int) (err error) //sys Lchown(path string, uid int, gid int) (err error) @@ -218,41 +215,6 @@ func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint32(length) } -//sysnb pipe(p *[2]_C_int) (err error) - -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe(&pp) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) - -func Poll(fds []PollFd, timeout int) (n int, err error) { - if len(fds) == 0 { - return poll(nil, 0, timeout) - } - return poll(&fds[0], len(fds), timeout) -} - //sys syncFileRange2(fd int, flags int, off int64, n int64) (err error) = SYS_SYNC_FILE_RANGE2 func SyncFileRange(fd int, off int64, n int64, flags int) error { diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go b/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go index 5259a5feaf..25786c4216 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go @@ -8,8 +8,6 @@ package unix -//sys dup2(oldfd int, newfd int) (err error) -//sysnb EpollCreate(size int) (fd int, err error) //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64 //sys Fchown(fd int, uid int, gid int) (err error) @@ -22,7 +20,6 @@ package unix //sysnb Getgid() (gid int) //sysnb Getrlimit(resource int, rlim *Rlimit) (err error) = SYS_UGETRLIMIT //sysnb Getuid() (uid int) -//sysnb InotifyInit() (fd int, err error) //sys Ioperm(from int, num int, on int) (err error) //sys Iopl(level int) (err error) //sys Lchown(path string, uid int, gid int) (err error) @@ -104,41 +101,6 @@ func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint64(length) } -//sysnb pipe(p *[2]_C_int) (err error) - -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe(&pp) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) - -func Poll(fds []PollFd, timeout int) (n int, err error) { - if len(fds) == 0 { - return poll(nil, 0, timeout) - } - return poll(&fds[0], len(fds), timeout) -} - //sys syncFileRange2(fd int, flags int, off int64, n int64) (err error) = SYS_SYNC_FILE_RANGE2 func SyncFileRange(fd int, off int64, n int64, flags int) error { diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go index 8ef821e5da..6f9f710414 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go @@ -9,13 +9,6 @@ package unix import "unsafe" -func EpollCreate(size int) (fd int, err error) { - if size <= 0 { - return -1, EINVAL - } - return EpollCreate1(0) -} - //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) = SYS_EPOLL_PWAIT //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64 //sys Fchown(fd int, uid int, gid int) (err error) @@ -144,30 +137,6 @@ func utimes(path string, tv *[2]Timeval) (err error) { return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) } -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, 0) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - func (r *PtraceRegs) PC() uint64 { return r.Pc } func (r *PtraceRegs) SetPC(pc uint64) { r.Pc = pc } @@ -192,27 +161,11 @@ func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint64(length) } -func InotifyInit() (fd int, err error) { - return InotifyInit1(0) -} - func Pause() error { _, err := ppoll(nil, 0, nil, nil) return err } -func Poll(fds []PollFd, timeout int) (n int, err error) { - var ts *Timespec - if timeout >= 0 { - ts = new(Timespec) - *ts = NsecToTimespec(int64(timeout) * 1e6) - } - if len(fds) == 0 { - return ppoll(nil, 0, ts, nil) - } - return ppoll(&fds[0], len(fds), ts, nil) -} - func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) { return Renameat2(olddirfd, oldpath, newdirfd, newpath, 0) } @@ -229,7 +182,3 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error } return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags) } - -// dup2 exists because func Dup3 in syscall_linux.go references -// it in an unreachable path. dup2 isn't available on arm64. -func dup2(oldfd int, newfd int) error diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go b/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go index a1c0574b58..6aa59cb270 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go @@ -11,8 +11,6 @@ import ( "unsafe" ) -//sys dup2(oldfd int, newfd int) (err error) -//sysnb EpollCreate(size int) (fd int, err error) //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64 //sys Fchown(fd int, uid int, gid int) (err error) @@ -25,7 +23,6 @@ import ( //sysnb Getgid() (gid int) //sysnb Getrlimit(resource int, rlim *Rlimit) (err error) //sysnb Getuid() (uid int) -//sysnb InotifyInit() (fd int, err error) //sys Lchown(path string, uid int, gid int) (err error) //sys Lstat(path string, stat *Stat_t) (err error) //sys Pause() (err error) @@ -77,30 +74,6 @@ func setTimeval(sec, usec int64) Timeval { return Timeval{Sec: sec, Usec: usec} } -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, 0) // pipe2 is the same as pipe when flags are set to 0. - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - func Ioperm(from int, num int, on int) (err error) { return ENOSYS } @@ -324,15 +297,6 @@ func Shutdown(s, how int) error { return nil } -//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) - -func Poll(fds []PollFd, timeout int) (n int, err error) { - if len(fds) == 0 { - return poll(nil, 0, timeout) - } - return poll(&fds[0], len(fds), timeout) -} - //sys kexecFileLoad(kernelFd int, initrdFd int, cmdlineLen int, cmdline string, flags int) (err error) func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error { diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go b/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go index de14b88983..bbe8d174f8 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go @@ -9,7 +9,6 @@ package unix //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64 -//sys dup2(oldfd int, newfd int) (err error) //sys Fchown(fd int, uid int, gid int) (err error) //sys Fstat(fd int, stat *Stat_t) (err error) //sys Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64 @@ -20,7 +19,6 @@ package unix //sysnb Getgid() (gid int) //sysnb Getrlimit(resource int, rlim *Rlimit) (err error) //sysnb Getuid() (uid int) -//sysnb InotifyInit() (fd int, err error) //sys Lchown(path string, uid int, gid int) (err error) //sys Listen(s int, n int) (err error) //sys Lstat(path string, stat *Stat_t) (err error) @@ -119,38 +117,3 @@ func (cmsg *Cmsghdr) SetLen(length int) { func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { rsa.Service_name_len = uint64(length) } - -//sysnb pipe(p *[2]_C_int) (err error) - -func Pipe(p []int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe(&pp) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sysnb pipe2(p *[2]_C_int, flags int) (err error) - -func Pipe2(p []int, flags int) (err error) { - if len(p) != 2 { - return EINVAL - } - var pp [2]_C_int - err = pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) - return -} - -//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) - -func Poll(fds []PollFd, timeout int) (n int, err error) { - if len(fds) == 0 { - return poll(nil, 0, timeout) - } - return poll(&fds[0], len(fds), timeout) -} diff --git a/vendor/golang.org/x/sys/unix/sysvshm_linux.go b/vendor/golang.org/x/sys/unix/sysvshm_linux.go new file mode 100644 index 0000000000..2c3a4437f0 --- /dev/null +++ b/vendor/golang.org/x/sys/unix/sysvshm_linux.go @@ -0,0 +1,21 @@ +// Copyright 2021 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build linux +// +build linux + +package unix + +import "runtime" + +// SysvShmCtl performs control operations on the shared memory segment +// specified by id. +func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { + if runtime.GOARCH == "arm" || + runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le" { + cmd |= ipc_64 + } + + return shmctl(id, cmd, desc) +} diff --git a/vendor/golang.org/x/sys/unix/sysvshm_unix.go b/vendor/golang.org/x/sys/unix/sysvshm_unix.go new file mode 100644 index 0000000000..0bb4c8de55 --- /dev/null +++ b/vendor/golang.org/x/sys/unix/sysvshm_unix.go @@ -0,0 +1,61 @@ +// Copyright 2021 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build (darwin && !ios) || linux +// +build darwin,!ios linux + +package unix + +import ( + "unsafe" + + "golang.org/x/sys/internal/unsafeheader" +) + +// SysvShmAttach attaches the Sysv shared memory segment associated with the +// shared memory identifier id. +func SysvShmAttach(id int, addr uintptr, flag int) ([]byte, error) { + addr, errno := shmat(id, addr, flag) + if errno != nil { + return nil, errno + } + + // Retrieve the size of the shared memory to enable slice creation + var info SysvShmDesc + + _, err := SysvShmCtl(id, IPC_STAT, &info) + if err != nil { + // release the shared memory if we can't find the size + + // ignoring error from shmdt as there's nothing sensible to return here + shmdt(addr) + return nil, err + } + + // Use unsafe to convert addr into a []byte. + // TODO: convert to unsafe.Slice once we can assume Go 1.17 + var b []byte + hdr := (*unsafeheader.Slice)(unsafe.Pointer(&b)) + hdr.Data = unsafe.Pointer(addr) + hdr.Cap = int(info.Segsz) + hdr.Len = int(info.Segsz) + return b, nil +} + +// SysvShmDetach unmaps the shared memory slice returned from SysvShmAttach. +// +// It is not safe to use the slice after calling this function. +func SysvShmDetach(data []byte) error { + if len(data) == 0 { + return EINVAL + } + + return shmdt(uintptr(unsafe.Pointer(&data[0]))) +} + +// SysvShmGet returns the Sysv shared memory identifier associated with key. +// If the IPC_CREAT flag is specified a new segment is created. +func SysvShmGet(key, size, flag int) (id int, err error) { + return shmget(key, size, flag) +} diff --git a/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go b/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go new file mode 100644 index 0000000000..71bddefdb8 --- /dev/null +++ b/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go @@ -0,0 +1,14 @@ +// Copyright 2021 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build darwin && !ios +// +build darwin,!ios + +package unix + +// SysvShmCtl performs control operations on the shared memory segment +// specified by id. +func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { + return shmctl(id, cmd, desc) +} diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go index a3a45fec59..476a1c7e77 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go @@ -12,1556 +12,1582 @@ package unix import "syscall" const ( - AF_APPLETALK = 0x10 - AF_CCITT = 0xa - AF_CHAOS = 0x5 - AF_CNT = 0x15 - AF_COIP = 0x14 - AF_DATAKIT = 0x9 - AF_DECnet = 0xc - AF_DLI = 0xd - AF_E164 = 0x1c - AF_ECMA = 0x8 - AF_HYLINK = 0xf - AF_IEEE80211 = 0x25 - AF_IMPLINK = 0x3 - AF_INET = 0x2 - AF_INET6 = 0x1e - AF_IPX = 0x17 - AF_ISDN = 0x1c - AF_ISO = 0x7 - AF_LAT = 0xe - AF_LINK = 0x12 - AF_LOCAL = 0x1 - AF_MAX = 0x29 - AF_NATM = 0x1f - AF_NDRV = 0x1b - AF_NETBIOS = 0x21 - AF_NS = 0x6 - AF_OSI = 0x7 - AF_PPP = 0x22 - AF_PUP = 0x4 - AF_RESERVED_36 = 0x24 - AF_ROUTE = 0x11 - AF_SIP = 0x18 - AF_SNA = 0xb - AF_SYSTEM = 0x20 - AF_SYS_CONTROL = 0x2 - AF_UNIX = 0x1 - AF_UNSPEC = 0x0 - AF_UTUN = 0x26 - AF_VSOCK = 0x28 - ALTWERASE = 0x200 - ATTR_BIT_MAP_COUNT = 0x5 - ATTR_CMN_ACCESSMASK = 0x20000 - ATTR_CMN_ACCTIME = 0x1000 - ATTR_CMN_ADDEDTIME = 0x10000000 - ATTR_CMN_BKUPTIME = 0x2000 - ATTR_CMN_CHGTIME = 0x800 - ATTR_CMN_CRTIME = 0x200 - ATTR_CMN_DATA_PROTECT_FLAGS = 0x40000000 - ATTR_CMN_DEVID = 0x2 - ATTR_CMN_DOCUMENT_ID = 0x100000 - ATTR_CMN_ERROR = 0x20000000 - ATTR_CMN_EXTENDED_SECURITY = 0x400000 - ATTR_CMN_FILEID = 0x2000000 - ATTR_CMN_FLAGS = 0x40000 - ATTR_CMN_FNDRINFO = 0x4000 - ATTR_CMN_FSID = 0x4 - ATTR_CMN_FULLPATH = 0x8000000 - ATTR_CMN_GEN_COUNT = 0x80000 - ATTR_CMN_GRPID = 0x10000 - ATTR_CMN_GRPUUID = 0x1000000 - ATTR_CMN_MODTIME = 0x400 - ATTR_CMN_NAME = 0x1 - ATTR_CMN_NAMEDATTRCOUNT = 0x80000 - ATTR_CMN_NAMEDATTRLIST = 0x100000 - ATTR_CMN_OBJID = 0x20 - ATTR_CMN_OBJPERMANENTID = 0x40 - ATTR_CMN_OBJTAG = 0x10 - ATTR_CMN_OBJTYPE = 0x8 - ATTR_CMN_OWNERID = 0x8000 - ATTR_CMN_PARENTID = 0x4000000 - ATTR_CMN_PAROBJID = 0x80 - ATTR_CMN_RETURNED_ATTRS = 0x80000000 - ATTR_CMN_SCRIPT = 0x100 - ATTR_CMN_SETMASK = 0x51c7ff00 - ATTR_CMN_USERACCESS = 0x200000 - ATTR_CMN_UUID = 0x800000 - ATTR_CMN_VALIDMASK = 0xffffffff - ATTR_CMN_VOLSETMASK = 0x6700 - ATTR_FILE_ALLOCSIZE = 0x4 - ATTR_FILE_CLUMPSIZE = 0x10 - ATTR_FILE_DATAALLOCSIZE = 0x400 - ATTR_FILE_DATAEXTENTS = 0x800 - ATTR_FILE_DATALENGTH = 0x200 - ATTR_FILE_DEVTYPE = 0x20 - ATTR_FILE_FILETYPE = 0x40 - ATTR_FILE_FORKCOUNT = 0x80 - ATTR_FILE_FORKLIST = 0x100 - ATTR_FILE_IOBLOCKSIZE = 0x8 - ATTR_FILE_LINKCOUNT = 0x1 - ATTR_FILE_RSRCALLOCSIZE = 0x2000 - ATTR_FILE_RSRCEXTENTS = 0x4000 - ATTR_FILE_RSRCLENGTH = 0x1000 - ATTR_FILE_SETMASK = 0x20 - ATTR_FILE_TOTALSIZE = 0x2 - ATTR_FILE_VALIDMASK = 0x37ff - ATTR_VOL_ALLOCATIONCLUMP = 0x40 - ATTR_VOL_ATTRIBUTES = 0x40000000 - ATTR_VOL_CAPABILITIES = 0x20000 - ATTR_VOL_DIRCOUNT = 0x400 - ATTR_VOL_ENCODINGSUSED = 0x10000 - ATTR_VOL_FILECOUNT = 0x200 - ATTR_VOL_FSTYPE = 0x1 - ATTR_VOL_INFO = 0x80000000 - ATTR_VOL_IOBLOCKSIZE = 0x80 - ATTR_VOL_MAXOBJCOUNT = 0x800 - ATTR_VOL_MINALLOCATION = 0x20 - ATTR_VOL_MOUNTEDDEVICE = 0x8000 - ATTR_VOL_MOUNTFLAGS = 0x4000 - ATTR_VOL_MOUNTPOINT = 0x1000 - ATTR_VOL_NAME = 0x2000 - ATTR_VOL_OBJCOUNT = 0x100 - ATTR_VOL_QUOTA_SIZE = 0x10000000 - ATTR_VOL_RESERVED_SIZE = 0x20000000 - ATTR_VOL_SETMASK = 0x80002000 - ATTR_VOL_SIGNATURE = 0x2 - ATTR_VOL_SIZE = 0x4 - ATTR_VOL_SPACEAVAIL = 0x10 - ATTR_VOL_SPACEFREE = 0x8 - ATTR_VOL_UUID = 0x40000 - ATTR_VOL_VALIDMASK = 0xf007ffff - B0 = 0x0 - B110 = 0x6e - B115200 = 0x1c200 - B1200 = 0x4b0 - B134 = 0x86 - B14400 = 0x3840 - B150 = 0x96 - B1800 = 0x708 - B19200 = 0x4b00 - B200 = 0xc8 - B230400 = 0x38400 - B2400 = 0x960 - B28800 = 0x7080 - B300 = 0x12c - B38400 = 0x9600 - B4800 = 0x12c0 - B50 = 0x32 - B57600 = 0xe100 - B600 = 0x258 - B7200 = 0x1c20 - B75 = 0x4b - B76800 = 0x12c00 - B9600 = 0x2580 - BIOCFLUSH = 0x20004268 - BIOCGBLEN = 0x40044266 - BIOCGDLT = 0x4004426a - BIOCGDLTLIST = 0xc00c4279 - BIOCGETIF = 0x4020426b - BIOCGHDRCMPLT = 0x40044274 - BIOCGRSIG = 0x40044272 - BIOCGRTIMEOUT = 0x4010426e - BIOCGSEESENT = 0x40044276 - BIOCGSTATS = 0x4008426f - BIOCIMMEDIATE = 0x80044270 - BIOCPROMISC = 0x20004269 - BIOCSBLEN = 0xc0044266 - BIOCSDLT = 0x80044278 - BIOCSETF = 0x80104267 - BIOCSETFNR = 0x8010427e - BIOCSETIF = 0x8020426c - BIOCSHDRCMPLT = 0x80044275 - BIOCSRSIG = 0x80044273 - BIOCSRTIMEOUT = 0x8010426d - BIOCSSEESENT = 0x80044277 - BIOCVERSION = 0x40044271 - BPF_A = 0x10 - BPF_ABS = 0x20 - BPF_ADD = 0x0 - BPF_ALIGNMENT = 0x4 - BPF_ALU = 0x4 - BPF_AND = 0x50 - BPF_B = 0x10 - BPF_DIV = 0x30 - BPF_H = 0x8 - BPF_IMM = 0x0 - BPF_IND = 0x40 - BPF_JA = 0x0 - BPF_JEQ = 0x10 - BPF_JGE = 0x30 - BPF_JGT = 0x20 - BPF_JMP = 0x5 - BPF_JSET = 0x40 - BPF_K = 0x0 - BPF_LD = 0x0 - BPF_LDX = 0x1 - BPF_LEN = 0x80 - BPF_LSH = 0x60 - BPF_MAJOR_VERSION = 0x1 - BPF_MAXBUFSIZE = 0x80000 - BPF_MAXINSNS = 0x200 - BPF_MEM = 0x60 - BPF_MEMWORDS = 0x10 - BPF_MINBUFSIZE = 0x20 - BPF_MINOR_VERSION = 0x1 - BPF_MISC = 0x7 - BPF_MSH = 0xa0 - BPF_MUL = 0x20 - BPF_NEG = 0x80 - BPF_OR = 0x40 - BPF_RELEASE = 0x30bb6 - BPF_RET = 0x6 - BPF_RSH = 0x70 - BPF_ST = 0x2 - BPF_STX = 0x3 - BPF_SUB = 0x10 - BPF_TAX = 0x0 - BPF_TXA = 0x80 - BPF_W = 0x0 - BPF_X = 0x8 - BRKINT = 0x2 - BS0 = 0x0 - BS1 = 0x8000 - BSDLY = 0x8000 - CFLUSH = 0xf - CLOCAL = 0x8000 - CLOCK_MONOTONIC = 0x6 - CLOCK_MONOTONIC_RAW = 0x4 - CLOCK_MONOTONIC_RAW_APPROX = 0x5 - CLOCK_PROCESS_CPUTIME_ID = 0xc - CLOCK_REALTIME = 0x0 - CLOCK_THREAD_CPUTIME_ID = 0x10 - CLOCK_UPTIME_RAW = 0x8 - CLOCK_UPTIME_RAW_APPROX = 0x9 - CLONE_NOFOLLOW = 0x1 - CLONE_NOOWNERCOPY = 0x2 - CR0 = 0x0 - CR1 = 0x1000 - CR2 = 0x2000 - CR3 = 0x3000 - CRDLY = 0x3000 - CREAD = 0x800 - CRTSCTS = 0x30000 - CS5 = 0x0 - CS6 = 0x100 - CS7 = 0x200 - CS8 = 0x300 - CSIZE = 0x300 - CSTART = 0x11 - CSTATUS = 0x14 - CSTOP = 0x13 - CSTOPB = 0x400 - CSUSP = 0x1a - CTLIOCGINFO = 0xc0644e03 - CTL_HW = 0x6 - CTL_KERN = 0x1 - CTL_MAXNAME = 0xc - CTL_NET = 0x4 - DLT_A429 = 0xb8 - DLT_A653_ICM = 0xb9 - DLT_AIRONET_HEADER = 0x78 - DLT_AOS = 0xde - DLT_APPLE_IP_OVER_IEEE1394 = 0x8a - DLT_ARCNET = 0x7 - DLT_ARCNET_LINUX = 0x81 - DLT_ATM_CLIP = 0x13 - DLT_ATM_RFC1483 = 0xb - DLT_AURORA = 0x7e - DLT_AX25 = 0x3 - DLT_AX25_KISS = 0xca - DLT_BACNET_MS_TP = 0xa5 - DLT_BLUETOOTH_HCI_H4 = 0xbb - DLT_BLUETOOTH_HCI_H4_WITH_PHDR = 0xc9 - DLT_CAN20B = 0xbe - DLT_CAN_SOCKETCAN = 0xe3 - DLT_CHAOS = 0x5 - DLT_CHDLC = 0x68 - DLT_CISCO_IOS = 0x76 - DLT_C_HDLC = 0x68 - DLT_C_HDLC_WITH_DIR = 0xcd - DLT_DBUS = 0xe7 - DLT_DECT = 0xdd - DLT_DOCSIS = 0x8f - DLT_DVB_CI = 0xeb - DLT_ECONET = 0x73 - DLT_EN10MB = 0x1 - DLT_EN3MB = 0x2 - DLT_ENC = 0x6d - DLT_ERF = 0xc5 - DLT_ERF_ETH = 0xaf - DLT_ERF_POS = 0xb0 - DLT_FC_2 = 0xe0 - DLT_FC_2_WITH_FRAME_DELIMS = 0xe1 - DLT_FDDI = 0xa - DLT_FLEXRAY = 0xd2 - DLT_FRELAY = 0x6b - DLT_FRELAY_WITH_DIR = 0xce - DLT_GCOM_SERIAL = 0xad - DLT_GCOM_T1E1 = 0xac - DLT_GPF_F = 0xab - DLT_GPF_T = 0xaa - DLT_GPRS_LLC = 0xa9 - DLT_GSMTAP_ABIS = 0xda - DLT_GSMTAP_UM = 0xd9 - DLT_HHDLC = 0x79 - DLT_IBM_SN = 0x92 - DLT_IBM_SP = 0x91 - DLT_IEEE802 = 0x6 - DLT_IEEE802_11 = 0x69 - DLT_IEEE802_11_RADIO = 0x7f - DLT_IEEE802_11_RADIO_AVS = 0xa3 - DLT_IEEE802_15_4 = 0xc3 - DLT_IEEE802_15_4_LINUX = 0xbf - DLT_IEEE802_15_4_NOFCS = 0xe6 - DLT_IEEE802_15_4_NONASK_PHY = 0xd7 - DLT_IEEE802_16_MAC_CPS = 0xbc - DLT_IEEE802_16_MAC_CPS_RADIO = 0xc1 - DLT_IPFILTER = 0x74 - DLT_IPMB = 0xc7 - DLT_IPMB_LINUX = 0xd1 - DLT_IPNET = 0xe2 - DLT_IPOIB = 0xf2 - DLT_IPV4 = 0xe4 - DLT_IPV6 = 0xe5 - DLT_IP_OVER_FC = 0x7a - DLT_JUNIPER_ATM1 = 0x89 - DLT_JUNIPER_ATM2 = 0x87 - DLT_JUNIPER_ATM_CEMIC = 0xee - DLT_JUNIPER_CHDLC = 0xb5 - DLT_JUNIPER_ES = 0x84 - DLT_JUNIPER_ETHER = 0xb2 - DLT_JUNIPER_FIBRECHANNEL = 0xea - DLT_JUNIPER_FRELAY = 0xb4 - DLT_JUNIPER_GGSN = 0x85 - DLT_JUNIPER_ISM = 0xc2 - DLT_JUNIPER_MFR = 0x86 - DLT_JUNIPER_MLFR = 0x83 - DLT_JUNIPER_MLPPP = 0x82 - DLT_JUNIPER_MONITOR = 0xa4 - DLT_JUNIPER_PIC_PEER = 0xae - DLT_JUNIPER_PPP = 0xb3 - DLT_JUNIPER_PPPOE = 0xa7 - DLT_JUNIPER_PPPOE_ATM = 0xa8 - DLT_JUNIPER_SERVICES = 0x88 - DLT_JUNIPER_SRX_E2E = 0xe9 - DLT_JUNIPER_ST = 0xc8 - DLT_JUNIPER_VP = 0xb7 - DLT_JUNIPER_VS = 0xe8 - DLT_LAPB_WITH_DIR = 0xcf - DLT_LAPD = 0xcb - DLT_LIN = 0xd4 - DLT_LINUX_EVDEV = 0xd8 - DLT_LINUX_IRDA = 0x90 - DLT_LINUX_LAPD = 0xb1 - DLT_LINUX_PPP_WITHDIRECTION = 0xa6 - DLT_LINUX_SLL = 0x71 - DLT_LOOP = 0x6c - DLT_LTALK = 0x72 - DLT_MATCHING_MAX = 0x10a - DLT_MATCHING_MIN = 0x68 - DLT_MFR = 0xb6 - DLT_MOST = 0xd3 - DLT_MPEG_2_TS = 0xf3 - DLT_MPLS = 0xdb - DLT_MTP2 = 0x8c - DLT_MTP2_WITH_PHDR = 0x8b - DLT_MTP3 = 0x8d - DLT_MUX27010 = 0xec - DLT_NETANALYZER = 0xf0 - DLT_NETANALYZER_TRANSPARENT = 0xf1 - DLT_NFC_LLCP = 0xf5 - DLT_NFLOG = 0xef - DLT_NG40 = 0xf4 - DLT_NULL = 0x0 - DLT_PCI_EXP = 0x7d - DLT_PFLOG = 0x75 - DLT_PFSYNC = 0x12 - DLT_PPI = 0xc0 - DLT_PPP = 0x9 - DLT_PPP_BSDOS = 0x10 - DLT_PPP_ETHER = 0x33 - DLT_PPP_PPPD = 0xa6 - DLT_PPP_SERIAL = 0x32 - DLT_PPP_WITH_DIR = 0xcc - DLT_PPP_WITH_DIRECTION = 0xa6 - DLT_PRISM_HEADER = 0x77 - DLT_PRONET = 0x4 - DLT_RAIF1 = 0xc6 - DLT_RAW = 0xc - DLT_RIO = 0x7c - DLT_SCCP = 0x8e - DLT_SITA = 0xc4 - DLT_SLIP = 0x8 - DLT_SLIP_BSDOS = 0xf - DLT_STANAG_5066_D_PDU = 0xed - DLT_SUNATM = 0x7b - DLT_SYMANTEC_FIREWALL = 0x63 - DLT_TZSP = 0x80 - DLT_USB = 0xba - DLT_USB_DARWIN = 0x10a - DLT_USB_LINUX = 0xbd - DLT_USB_LINUX_MMAPPED = 0xdc - DLT_USER0 = 0x93 - DLT_USER1 = 0x94 - DLT_USER10 = 0x9d - DLT_USER11 = 0x9e - DLT_USER12 = 0x9f - DLT_USER13 = 0xa0 - DLT_USER14 = 0xa1 - DLT_USER15 = 0xa2 - DLT_USER2 = 0x95 - DLT_USER3 = 0x96 - DLT_USER4 = 0x97 - DLT_USER5 = 0x98 - DLT_USER6 = 0x99 - DLT_USER7 = 0x9a - DLT_USER8 = 0x9b - DLT_USER9 = 0x9c - DLT_WIHART = 0xdf - DLT_X2E_SERIAL = 0xd5 - DLT_X2E_XORAYA = 0xd6 - DT_BLK = 0x6 - DT_CHR = 0x2 - DT_DIR = 0x4 - DT_FIFO = 0x1 - DT_LNK = 0xa - DT_REG = 0x8 - DT_SOCK = 0xc - DT_UNKNOWN = 0x0 - DT_WHT = 0xe - ECHO = 0x8 - ECHOCTL = 0x40 - ECHOE = 0x2 - ECHOK = 0x4 - ECHOKE = 0x1 - ECHONL = 0x10 - ECHOPRT = 0x20 - EVFILT_AIO = -0x3 - EVFILT_EXCEPT = -0xf - EVFILT_FS = -0x9 - EVFILT_MACHPORT = -0x8 - EVFILT_PROC = -0x5 - EVFILT_READ = -0x1 - EVFILT_SIGNAL = -0x6 - EVFILT_SYSCOUNT = 0x11 - EVFILT_THREADMARKER = 0x11 - EVFILT_TIMER = -0x7 - EVFILT_USER = -0xa - EVFILT_VM = -0xc - EVFILT_VNODE = -0x4 - EVFILT_WRITE = -0x2 - EV_ADD = 0x1 - EV_CLEAR = 0x20 - EV_DELETE = 0x2 - EV_DISABLE = 0x8 - EV_DISPATCH = 0x80 - EV_DISPATCH2 = 0x180 - EV_ENABLE = 0x4 - EV_EOF = 0x8000 - EV_ERROR = 0x4000 - EV_FLAG0 = 0x1000 - EV_FLAG1 = 0x2000 - EV_ONESHOT = 0x10 - EV_OOBAND = 0x2000 - EV_POLL = 0x1000 - EV_RECEIPT = 0x40 - EV_SYSFLAGS = 0xf000 - EV_UDATA_SPECIFIC = 0x100 - EV_VANISHED = 0x200 - EXTA = 0x4b00 - EXTB = 0x9600 - EXTPROC = 0x800 - FD_CLOEXEC = 0x1 - FD_SETSIZE = 0x400 - FF0 = 0x0 - FF1 = 0x4000 - FFDLY = 0x4000 - FLUSHO = 0x800000 - FSOPT_ATTR_CMN_EXTENDED = 0x20 - FSOPT_NOFOLLOW = 0x1 - FSOPT_NOINMEMUPDATE = 0x2 - FSOPT_PACK_INVAL_ATTRS = 0x8 - FSOPT_REPORT_FULLSIZE = 0x4 - FSOPT_RETURN_REALDEV = 0x200 - F_ADDFILESIGS = 0x3d - F_ADDFILESIGS_FOR_DYLD_SIM = 0x53 - F_ADDFILESIGS_INFO = 0x67 - F_ADDFILESIGS_RETURN = 0x61 - F_ADDFILESUPPL = 0x68 - F_ADDSIGS = 0x3b - F_ALLOCATEALL = 0x4 - F_ALLOCATECONTIG = 0x2 - F_BARRIERFSYNC = 0x55 - F_CHECK_LV = 0x62 - F_CHKCLEAN = 0x29 - F_DUPFD = 0x0 - F_DUPFD_CLOEXEC = 0x43 - F_FINDSIGS = 0x4e - F_FLUSH_DATA = 0x28 - F_FREEZE_FS = 0x35 - F_FULLFSYNC = 0x33 - F_GETCODEDIR = 0x48 - F_GETFD = 0x1 - F_GETFL = 0x3 - F_GETLK = 0x7 - F_GETLKPID = 0x42 - F_GETNOSIGPIPE = 0x4a - F_GETOWN = 0x5 - F_GETPATH = 0x32 - F_GETPATH_MTMINFO = 0x47 - F_GETPATH_NOFIRMLINK = 0x66 - F_GETPROTECTIONCLASS = 0x3f - F_GETPROTECTIONLEVEL = 0x4d - F_GETSIGSINFO = 0x69 - F_GLOBAL_NOCACHE = 0x37 - F_LOG2PHYS = 0x31 - F_LOG2PHYS_EXT = 0x41 - F_NOCACHE = 0x30 - F_NODIRECT = 0x3e - F_OK = 0x0 - F_PATHPKG_CHECK = 0x34 - F_PEOFPOSMODE = 0x3 - F_PREALLOCATE = 0x2a - F_PUNCHHOLE = 0x63 - F_RDADVISE = 0x2c - F_RDAHEAD = 0x2d - F_RDLCK = 0x1 - F_SETBACKINGSTORE = 0x46 - F_SETFD = 0x2 - F_SETFL = 0x4 - F_SETLK = 0x8 - F_SETLKW = 0x9 - F_SETLKWTIMEOUT = 0xa - F_SETNOSIGPIPE = 0x49 - F_SETOWN = 0x6 - F_SETPROTECTIONCLASS = 0x40 - F_SETSIZE = 0x2b - F_SINGLE_WRITER = 0x4c - F_SPECULATIVE_READ = 0x65 - F_THAW_FS = 0x36 - F_TRANSCODEKEY = 0x4b - F_TRIM_ACTIVE_FILE = 0x64 - F_UNLCK = 0x2 - F_VOLPOSMODE = 0x4 - F_WRLCK = 0x3 - HUPCL = 0x4000 - HW_MACHINE = 0x1 - ICANON = 0x100 - ICMP6_FILTER = 0x12 - ICRNL = 0x100 - IEXTEN = 0x400 - IFF_ALLMULTI = 0x200 - IFF_ALTPHYS = 0x4000 - IFF_BROADCAST = 0x2 - IFF_DEBUG = 0x4 - IFF_LINK0 = 0x1000 - IFF_LINK1 = 0x2000 - IFF_LINK2 = 0x4000 - IFF_LOOPBACK = 0x8 - IFF_MULTICAST = 0x8000 - IFF_NOARP = 0x80 - IFF_NOTRAILERS = 0x20 - IFF_OACTIVE = 0x400 - IFF_POINTOPOINT = 0x10 - IFF_PROMISC = 0x100 - IFF_RUNNING = 0x40 - IFF_SIMPLEX = 0x800 - IFF_UP = 0x1 - IFNAMSIZ = 0x10 - IFT_1822 = 0x2 - IFT_6LOWPAN = 0x40 - IFT_AAL5 = 0x31 - IFT_ARCNET = 0x23 - IFT_ARCNETPLUS = 0x24 - IFT_ATM = 0x25 - IFT_BRIDGE = 0xd1 - IFT_CARP = 0xf8 - IFT_CELLULAR = 0xff - IFT_CEPT = 0x13 - IFT_DS3 = 0x1e - IFT_ENC = 0xf4 - IFT_EON = 0x19 - IFT_ETHER = 0x6 - IFT_FAITH = 0x38 - IFT_FDDI = 0xf - IFT_FRELAY = 0x20 - IFT_FRELAYDCE = 0x2c - IFT_GIF = 0x37 - IFT_HDH1822 = 0x3 - IFT_HIPPI = 0x2f - IFT_HSSI = 0x2e - IFT_HY = 0xe - IFT_IEEE1394 = 0x90 - IFT_IEEE8023ADLAG = 0x88 - IFT_ISDNBASIC = 0x14 - IFT_ISDNPRIMARY = 0x15 - IFT_ISO88022LLC = 0x29 - IFT_ISO88023 = 0x7 - IFT_ISO88024 = 0x8 - IFT_ISO88025 = 0x9 - IFT_ISO88026 = 0xa - IFT_L2VLAN = 0x87 - IFT_LAPB = 0x10 - IFT_LOCALTALK = 0x2a - IFT_LOOP = 0x18 - IFT_MIOX25 = 0x26 - IFT_MODEM = 0x30 - IFT_NSIP = 0x1b - IFT_OTHER = 0x1 - IFT_P10 = 0xc - IFT_P80 = 0xd - IFT_PARA = 0x22 - IFT_PDP = 0xff - IFT_PFLOG = 0xf5 - IFT_PFSYNC = 0xf6 - IFT_PKTAP = 0xfe - IFT_PPP = 0x17 - IFT_PROPMUX = 0x36 - IFT_PROPVIRTUAL = 0x35 - IFT_PTPSERIAL = 0x16 - IFT_RS232 = 0x21 - IFT_SDLC = 0x11 - IFT_SIP = 0x1f - IFT_SLIP = 0x1c - IFT_SMDSDXI = 0x2b - IFT_SMDSICIP = 0x34 - IFT_SONET = 0x27 - IFT_SONETPATH = 0x32 - IFT_SONETVT = 0x33 - IFT_STARLAN = 0xb - IFT_STF = 0x39 - IFT_T1 = 0x12 - IFT_ULTRA = 0x1d - IFT_V35 = 0x2d - IFT_X25 = 0x5 - IFT_X25DDN = 0x4 - IFT_X25PLE = 0x28 - IFT_XETHER = 0x1a - IGNBRK = 0x1 - IGNCR = 0x80 - IGNPAR = 0x4 - IMAXBEL = 0x2000 - INLCR = 0x40 - INPCK = 0x10 - IN_CLASSA_HOST = 0xffffff - IN_CLASSA_MAX = 0x80 - IN_CLASSA_NET = 0xff000000 - IN_CLASSA_NSHIFT = 0x18 - IN_CLASSB_HOST = 0xffff - IN_CLASSB_MAX = 0x10000 - IN_CLASSB_NET = 0xffff0000 - IN_CLASSB_NSHIFT = 0x10 - IN_CLASSC_HOST = 0xff - IN_CLASSC_NET = 0xffffff00 - IN_CLASSC_NSHIFT = 0x8 - IN_CLASSD_HOST = 0xfffffff - IN_CLASSD_NET = 0xf0000000 - IN_CLASSD_NSHIFT = 0x1c - IN_LINKLOCALNETNUM = 0xa9fe0000 - IN_LOOPBACKNET = 0x7f - IPPROTO_3PC = 0x22 - IPPROTO_ADFS = 0x44 - IPPROTO_AH = 0x33 - IPPROTO_AHIP = 0x3d - IPPROTO_APES = 0x63 - IPPROTO_ARGUS = 0xd - IPPROTO_AX25 = 0x5d - IPPROTO_BHA = 0x31 - IPPROTO_BLT = 0x1e - IPPROTO_BRSATMON = 0x4c - IPPROTO_CFTP = 0x3e - IPPROTO_CHAOS = 0x10 - IPPROTO_CMTP = 0x26 - IPPROTO_CPHB = 0x49 - IPPROTO_CPNX = 0x48 - IPPROTO_DDP = 0x25 - IPPROTO_DGP = 0x56 - IPPROTO_DIVERT = 0xfe - IPPROTO_DONE = 0x101 - IPPROTO_DSTOPTS = 0x3c - IPPROTO_EGP = 0x8 - IPPROTO_EMCON = 0xe - IPPROTO_ENCAP = 0x62 - IPPROTO_EON = 0x50 - IPPROTO_ESP = 0x32 - IPPROTO_ETHERIP = 0x61 - IPPROTO_FRAGMENT = 0x2c - IPPROTO_GGP = 0x3 - IPPROTO_GMTP = 0x64 - IPPROTO_GRE = 0x2f - IPPROTO_HELLO = 0x3f - IPPROTO_HMP = 0x14 - IPPROTO_HOPOPTS = 0x0 - IPPROTO_ICMP = 0x1 - IPPROTO_ICMPV6 = 0x3a - IPPROTO_IDP = 0x16 - IPPROTO_IDPR = 0x23 - IPPROTO_IDRP = 0x2d - IPPROTO_IGMP = 0x2 - IPPROTO_IGP = 0x55 - IPPROTO_IGRP = 0x58 - IPPROTO_IL = 0x28 - IPPROTO_INLSP = 0x34 - IPPROTO_INP = 0x20 - IPPROTO_IP = 0x0 - IPPROTO_IPCOMP = 0x6c - IPPROTO_IPCV = 0x47 - IPPROTO_IPEIP = 0x5e - IPPROTO_IPIP = 0x4 - IPPROTO_IPPC = 0x43 - IPPROTO_IPV4 = 0x4 - IPPROTO_IPV6 = 0x29 - IPPROTO_IRTP = 0x1c - IPPROTO_KRYPTOLAN = 0x41 - IPPROTO_LARP = 0x5b - IPPROTO_LEAF1 = 0x19 - IPPROTO_LEAF2 = 0x1a - IPPROTO_MAX = 0x100 - IPPROTO_MAXID = 0x34 - IPPROTO_MEAS = 0x13 - IPPROTO_MHRP = 0x30 - IPPROTO_MICP = 0x5f - IPPROTO_MTP = 0x5c - IPPROTO_MUX = 0x12 - IPPROTO_ND = 0x4d - IPPROTO_NHRP = 0x36 - IPPROTO_NONE = 0x3b - IPPROTO_NSP = 0x1f - IPPROTO_NVPII = 0xb - IPPROTO_OSPFIGP = 0x59 - IPPROTO_PGM = 0x71 - IPPROTO_PIGP = 0x9 - IPPROTO_PIM = 0x67 - IPPROTO_PRM = 0x15 - IPPROTO_PUP = 0xc - IPPROTO_PVP = 0x4b - IPPROTO_RAW = 0xff - IPPROTO_RCCMON = 0xa - IPPROTO_RDP = 0x1b - IPPROTO_ROUTING = 0x2b - IPPROTO_RSVP = 0x2e - IPPROTO_RVD = 0x42 - IPPROTO_SATEXPAK = 0x40 - IPPROTO_SATMON = 0x45 - IPPROTO_SCCSP = 0x60 - IPPROTO_SCTP = 0x84 - IPPROTO_SDRP = 0x2a - IPPROTO_SEP = 0x21 - IPPROTO_SRPC = 0x5a - IPPROTO_ST = 0x7 - IPPROTO_SVMTP = 0x52 - IPPROTO_SWIPE = 0x35 - IPPROTO_TCF = 0x57 - IPPROTO_TCP = 0x6 - IPPROTO_TP = 0x1d - IPPROTO_TPXX = 0x27 - IPPROTO_TRUNK1 = 0x17 - IPPROTO_TRUNK2 = 0x18 - IPPROTO_TTP = 0x54 - IPPROTO_UDP = 0x11 - IPPROTO_VINES = 0x53 - IPPROTO_VISA = 0x46 - IPPROTO_VMTP = 0x51 - IPPROTO_WBEXPAK = 0x4f - IPPROTO_WBMON = 0x4e - IPPROTO_WSN = 0x4a - IPPROTO_XNET = 0xf - IPPROTO_XTP = 0x24 - IPV6_2292DSTOPTS = 0x17 - IPV6_2292HOPLIMIT = 0x14 - IPV6_2292HOPOPTS = 0x16 - IPV6_2292NEXTHOP = 0x15 - IPV6_2292PKTINFO = 0x13 - IPV6_2292PKTOPTIONS = 0x19 - IPV6_2292RTHDR = 0x18 - IPV6_3542DSTOPTS = 0x32 - IPV6_3542HOPLIMIT = 0x2f - IPV6_3542HOPOPTS = 0x31 - IPV6_3542NEXTHOP = 0x30 - IPV6_3542PKTINFO = 0x2e - IPV6_3542RTHDR = 0x33 - IPV6_ADDR_MC_FLAGS_PREFIX = 0x20 - IPV6_ADDR_MC_FLAGS_TRANSIENT = 0x10 - IPV6_ADDR_MC_FLAGS_UNICAST_BASED = 0x30 - IPV6_AUTOFLOWLABEL = 0x3b - IPV6_BINDV6ONLY = 0x1b - IPV6_BOUND_IF = 0x7d - IPV6_CHECKSUM = 0x1a - IPV6_DEFAULT_MULTICAST_HOPS = 0x1 - IPV6_DEFAULT_MULTICAST_LOOP = 0x1 - IPV6_DEFHLIM = 0x40 - IPV6_DONTFRAG = 0x3e - IPV6_DSTOPTS = 0x32 - IPV6_FAITH = 0x1d - IPV6_FLOWINFO_MASK = 0xffffff0f - IPV6_FLOWLABEL_MASK = 0xffff0f00 - IPV6_FLOW_ECN_MASK = 0x3000 - IPV6_FRAGTTL = 0x3c - IPV6_FW_ADD = 0x1e - IPV6_FW_DEL = 0x1f - IPV6_FW_FLUSH = 0x20 - IPV6_FW_GET = 0x22 - IPV6_FW_ZERO = 0x21 - IPV6_HLIMDEC = 0x1 - IPV6_HOPLIMIT = 0x2f - IPV6_HOPOPTS = 0x31 - IPV6_IPSEC_POLICY = 0x1c - IPV6_JOIN_GROUP = 0xc - IPV6_LEAVE_GROUP = 0xd - IPV6_MAXHLIM = 0xff - IPV6_MAXOPTHDR = 0x800 - IPV6_MAXPACKET = 0xffff - IPV6_MAX_GROUP_SRC_FILTER = 0x200 - IPV6_MAX_MEMBERSHIPS = 0xfff - IPV6_MAX_SOCK_SRC_FILTER = 0x80 - IPV6_MIN_MEMBERSHIPS = 0x1f - IPV6_MMTU = 0x500 - IPV6_MSFILTER = 0x4a - IPV6_MULTICAST_HOPS = 0xa - IPV6_MULTICAST_IF = 0x9 - IPV6_MULTICAST_LOOP = 0xb - IPV6_NEXTHOP = 0x30 - IPV6_PATHMTU = 0x2c - IPV6_PKTINFO = 0x2e - IPV6_PORTRANGE = 0xe - IPV6_PORTRANGE_DEFAULT = 0x0 - IPV6_PORTRANGE_HIGH = 0x1 - IPV6_PORTRANGE_LOW = 0x2 - IPV6_PREFER_TEMPADDR = 0x3f - IPV6_RECVDSTOPTS = 0x28 - IPV6_RECVHOPLIMIT = 0x25 - IPV6_RECVHOPOPTS = 0x27 - IPV6_RECVPATHMTU = 0x2b - IPV6_RECVPKTINFO = 0x3d - IPV6_RECVRTHDR = 0x26 - IPV6_RECVTCLASS = 0x23 - IPV6_RTHDR = 0x33 - IPV6_RTHDRDSTOPTS = 0x39 - IPV6_RTHDR_LOOSE = 0x0 - IPV6_RTHDR_STRICT = 0x1 - IPV6_RTHDR_TYPE_0 = 0x0 - IPV6_SOCKOPT_RESERVED1 = 0x3 - IPV6_TCLASS = 0x24 - IPV6_UNICAST_HOPS = 0x4 - IPV6_USE_MIN_MTU = 0x2a - IPV6_V6ONLY = 0x1b - IPV6_VERSION = 0x60 - IPV6_VERSION_MASK = 0xf0 - IP_ADD_MEMBERSHIP = 0xc - IP_ADD_SOURCE_MEMBERSHIP = 0x46 - IP_BLOCK_SOURCE = 0x48 - IP_BOUND_IF = 0x19 - IP_DEFAULT_MULTICAST_LOOP = 0x1 - IP_DEFAULT_MULTICAST_TTL = 0x1 - IP_DF = 0x4000 - IP_DONTFRAG = 0x1c - IP_DROP_MEMBERSHIP = 0xd - IP_DROP_SOURCE_MEMBERSHIP = 0x47 - IP_DUMMYNET_CONFIGURE = 0x3c - IP_DUMMYNET_DEL = 0x3d - IP_DUMMYNET_FLUSH = 0x3e - IP_DUMMYNET_GET = 0x40 - IP_FAITH = 0x16 - IP_FW_ADD = 0x28 - IP_FW_DEL = 0x29 - IP_FW_FLUSH = 0x2a - IP_FW_GET = 0x2c - IP_FW_RESETLOG = 0x2d - IP_FW_ZERO = 0x2b - IP_HDRINCL = 0x2 - IP_IPSEC_POLICY = 0x15 - IP_MAXPACKET = 0xffff - IP_MAX_GROUP_SRC_FILTER = 0x200 - IP_MAX_MEMBERSHIPS = 0xfff - IP_MAX_SOCK_MUTE_FILTER = 0x80 - IP_MAX_SOCK_SRC_FILTER = 0x80 - IP_MF = 0x2000 - IP_MIN_MEMBERSHIPS = 0x1f - IP_MSFILTER = 0x4a - IP_MSS = 0x240 - IP_MULTICAST_IF = 0x9 - IP_MULTICAST_IFINDEX = 0x42 - IP_MULTICAST_LOOP = 0xb - IP_MULTICAST_TTL = 0xa - IP_MULTICAST_VIF = 0xe - IP_NAT__XXX = 0x37 - IP_OFFMASK = 0x1fff - IP_OLD_FW_ADD = 0x32 - IP_OLD_FW_DEL = 0x33 - IP_OLD_FW_FLUSH = 0x34 - IP_OLD_FW_GET = 0x36 - IP_OLD_FW_RESETLOG = 0x38 - IP_OLD_FW_ZERO = 0x35 - IP_OPTIONS = 0x1 - IP_PKTINFO = 0x1a - IP_PORTRANGE = 0x13 - IP_PORTRANGE_DEFAULT = 0x0 - IP_PORTRANGE_HIGH = 0x1 - IP_PORTRANGE_LOW = 0x2 - IP_RECVDSTADDR = 0x7 - IP_RECVIF = 0x14 - IP_RECVOPTS = 0x5 - IP_RECVPKTINFO = 0x1a - IP_RECVRETOPTS = 0x6 - IP_RECVTOS = 0x1b - IP_RECVTTL = 0x18 - IP_RETOPTS = 0x8 - IP_RF = 0x8000 - IP_RSVP_OFF = 0x10 - IP_RSVP_ON = 0xf - IP_RSVP_VIF_OFF = 0x12 - IP_RSVP_VIF_ON = 0x11 - IP_STRIPHDR = 0x17 - IP_TOS = 0x3 - IP_TRAFFIC_MGT_BACKGROUND = 0x41 - IP_TTL = 0x4 - IP_UNBLOCK_SOURCE = 0x49 - ISIG = 0x80 - ISTRIP = 0x20 - IUTF8 = 0x4000 - IXANY = 0x800 - IXOFF = 0x400 - IXON = 0x200 - KERN_HOSTNAME = 0xa - KERN_OSRELEASE = 0x2 - KERN_OSTYPE = 0x1 - KERN_VERSION = 0x4 - LOCAL_PEERCRED = 0x1 - LOCAL_PEEREPID = 0x3 - LOCAL_PEEREUUID = 0x5 - LOCAL_PEERPID = 0x2 - LOCAL_PEERTOKEN = 0x6 - LOCAL_PEERUUID = 0x4 - LOCK_EX = 0x2 - LOCK_NB = 0x4 - LOCK_SH = 0x1 - LOCK_UN = 0x8 - MADV_CAN_REUSE = 0x9 - MADV_DONTNEED = 0x4 - MADV_FREE = 0x5 - MADV_FREE_REUSABLE = 0x7 - MADV_FREE_REUSE = 0x8 - MADV_NORMAL = 0x0 - MADV_PAGEOUT = 0xa - MADV_RANDOM = 0x1 - MADV_SEQUENTIAL = 0x2 - MADV_WILLNEED = 0x3 - MADV_ZERO_WIRED_PAGES = 0x6 - MAP_32BIT = 0x8000 - MAP_ANON = 0x1000 - MAP_ANONYMOUS = 0x1000 - MAP_COPY = 0x2 - MAP_FILE = 0x0 - MAP_FIXED = 0x10 - MAP_HASSEMAPHORE = 0x200 - MAP_JIT = 0x800 - MAP_NOCACHE = 0x400 - MAP_NOEXTEND = 0x100 - MAP_NORESERVE = 0x40 - MAP_PRIVATE = 0x2 - MAP_RENAME = 0x20 - MAP_RESERVED0080 = 0x80 - MAP_RESILIENT_CODESIGN = 0x2000 - MAP_RESILIENT_MEDIA = 0x4000 - MAP_SHARED = 0x1 - MAP_TRANSLATED_ALLOW_EXECUTE = 0x20000 - MAP_UNIX03 = 0x40000 - MCAST_BLOCK_SOURCE = 0x54 - MCAST_EXCLUDE = 0x2 - MCAST_INCLUDE = 0x1 - MCAST_JOIN_GROUP = 0x50 - MCAST_JOIN_SOURCE_GROUP = 0x52 - MCAST_LEAVE_GROUP = 0x51 - MCAST_LEAVE_SOURCE_GROUP = 0x53 - MCAST_UNBLOCK_SOURCE = 0x55 - MCAST_UNDEFINED = 0x0 - MCL_CURRENT = 0x1 - MCL_FUTURE = 0x2 - MNT_ASYNC = 0x40 - MNT_AUTOMOUNTED = 0x400000 - MNT_CMDFLAGS = 0xf0000 - MNT_CPROTECT = 0x80 - MNT_DEFWRITE = 0x2000000 - MNT_DONTBROWSE = 0x100000 - MNT_DOVOLFS = 0x8000 - MNT_DWAIT = 0x4 - MNT_EXPORTED = 0x100 - MNT_EXT_ROOT_DATA_VOL = 0x1 - MNT_FORCE = 0x80000 - MNT_IGNORE_OWNERSHIP = 0x200000 - MNT_JOURNALED = 0x800000 - MNT_LOCAL = 0x1000 - MNT_MULTILABEL = 0x4000000 - MNT_NOATIME = 0x10000000 - MNT_NOBLOCK = 0x20000 - MNT_NODEV = 0x10 - MNT_NOEXEC = 0x4 - MNT_NOSUID = 0x8 - MNT_NOUSERXATTR = 0x1000000 - MNT_NOWAIT = 0x2 - MNT_QUARANTINE = 0x400 - MNT_QUOTA = 0x2000 - MNT_RDONLY = 0x1 - MNT_RELOAD = 0x40000 - MNT_REMOVABLE = 0x200 - MNT_ROOTFS = 0x4000 - MNT_SNAPSHOT = 0x40000000 - MNT_STRICTATIME = 0x80000000 - MNT_SYNCHRONOUS = 0x2 - MNT_UNION = 0x20 - MNT_UNKNOWNPERMISSIONS = 0x200000 - MNT_UPDATE = 0x10000 - MNT_VISFLAGMASK = 0xd7f0f7ff - MNT_WAIT = 0x1 - MSG_CTRUNC = 0x20 - MSG_DONTROUTE = 0x4 - MSG_DONTWAIT = 0x80 - MSG_EOF = 0x100 - MSG_EOR = 0x8 - MSG_FLUSH = 0x400 - MSG_HAVEMORE = 0x2000 - MSG_HOLD = 0x800 - MSG_NEEDSA = 0x10000 - MSG_NOSIGNAL = 0x80000 - MSG_OOB = 0x1 - MSG_PEEK = 0x2 - MSG_RCVMORE = 0x4000 - MSG_SEND = 0x1000 - MSG_TRUNC = 0x10 - MSG_WAITALL = 0x40 - MSG_WAITSTREAM = 0x200 - MS_ASYNC = 0x1 - MS_DEACTIVATE = 0x8 - MS_INVALIDATE = 0x2 - MS_KILLPAGES = 0x4 - MS_SYNC = 0x10 - NAME_MAX = 0xff - NET_RT_DUMP = 0x1 - NET_RT_DUMP2 = 0x7 - NET_RT_FLAGS = 0x2 - NET_RT_FLAGS_PRIV = 0xa - NET_RT_IFLIST = 0x3 - NET_RT_IFLIST2 = 0x6 - NET_RT_MAXID = 0xb - NET_RT_STAT = 0x4 - NET_RT_TRASH = 0x5 - NFDBITS = 0x20 - NL0 = 0x0 - NL1 = 0x100 - NL2 = 0x200 - NL3 = 0x300 - NLDLY = 0x300 - NOFLSH = 0x80000000 - NOKERNINFO = 0x2000000 - NOTE_ABSOLUTE = 0x8 - NOTE_ATTRIB = 0x8 - NOTE_BACKGROUND = 0x40 - NOTE_CHILD = 0x4 - NOTE_CRITICAL = 0x20 - NOTE_DELETE = 0x1 - NOTE_EXEC = 0x20000000 - NOTE_EXIT = 0x80000000 - NOTE_EXITSTATUS = 0x4000000 - NOTE_EXIT_CSERROR = 0x40000 - NOTE_EXIT_DECRYPTFAIL = 0x10000 - NOTE_EXIT_DETAIL = 0x2000000 - NOTE_EXIT_DETAIL_MASK = 0x70000 - NOTE_EXIT_MEMORY = 0x20000 - NOTE_EXIT_REPARENTED = 0x80000 - NOTE_EXTEND = 0x4 - NOTE_FFAND = 0x40000000 - NOTE_FFCOPY = 0xc0000000 - NOTE_FFCTRLMASK = 0xc0000000 - NOTE_FFLAGSMASK = 0xffffff - NOTE_FFNOP = 0x0 - NOTE_FFOR = 0x80000000 - NOTE_FORK = 0x40000000 - NOTE_FUNLOCK = 0x100 - NOTE_LEEWAY = 0x10 - NOTE_LINK = 0x10 - NOTE_LOWAT = 0x1 - NOTE_MACHTIME = 0x100 - NOTE_MACH_CONTINUOUS_TIME = 0x80 - NOTE_NONE = 0x80 - NOTE_NSECONDS = 0x4 - NOTE_OOB = 0x2 - NOTE_PCTRLMASK = -0x100000 - NOTE_PDATAMASK = 0xfffff - NOTE_REAP = 0x10000000 - NOTE_RENAME = 0x20 - NOTE_REVOKE = 0x40 - NOTE_SECONDS = 0x1 - NOTE_SIGNAL = 0x8000000 - NOTE_TRACK = 0x1 - NOTE_TRACKERR = 0x2 - NOTE_TRIGGER = 0x1000000 - NOTE_USECONDS = 0x2 - NOTE_VM_ERROR = 0x10000000 - NOTE_VM_PRESSURE = 0x80000000 - NOTE_VM_PRESSURE_SUDDEN_TERMINATE = 0x20000000 - NOTE_VM_PRESSURE_TERMINATE = 0x40000000 - NOTE_WRITE = 0x2 - OCRNL = 0x10 - OFDEL = 0x20000 - OFILL = 0x80 - ONLCR = 0x2 - ONLRET = 0x40 - ONOCR = 0x20 - ONOEOT = 0x8 - OPOST = 0x1 - OXTABS = 0x4 - O_ACCMODE = 0x3 - O_ALERT = 0x20000000 - O_APPEND = 0x8 - O_ASYNC = 0x40 - O_CLOEXEC = 0x1000000 - O_CREAT = 0x200 - O_DIRECTORY = 0x100000 - O_DP_GETRAWENCRYPTED = 0x1 - O_DP_GETRAWUNENCRYPTED = 0x2 - O_DSYNC = 0x400000 - O_EVTONLY = 0x8000 - O_EXCL = 0x800 - O_EXLOCK = 0x20 - O_FSYNC = 0x80 - O_NDELAY = 0x4 - O_NOCTTY = 0x20000 - O_NOFOLLOW = 0x100 - O_NOFOLLOW_ANY = 0x20000000 - O_NONBLOCK = 0x4 - O_POPUP = 0x80000000 - O_RDONLY = 0x0 - O_RDWR = 0x2 - O_SHLOCK = 0x10 - O_SYMLINK = 0x200000 - O_SYNC = 0x80 - O_TRUNC = 0x400 - O_WRONLY = 0x1 - PARENB = 0x1000 - PARMRK = 0x8 - PARODD = 0x2000 - PENDIN = 0x20000000 - PRIO_PGRP = 0x1 - PRIO_PROCESS = 0x0 - PRIO_USER = 0x2 - PROT_EXEC = 0x4 - PROT_NONE = 0x0 - PROT_READ = 0x1 - PROT_WRITE = 0x2 - PT_ATTACH = 0xa - PT_ATTACHEXC = 0xe - PT_CONTINUE = 0x7 - PT_DENY_ATTACH = 0x1f - PT_DETACH = 0xb - PT_FIRSTMACH = 0x20 - PT_FORCEQUOTA = 0x1e - PT_KILL = 0x8 - PT_READ_D = 0x2 - PT_READ_I = 0x1 - PT_READ_U = 0x3 - PT_SIGEXC = 0xc - PT_STEP = 0x9 - PT_THUPDATE = 0xd - PT_TRACE_ME = 0x0 - PT_WRITE_D = 0x5 - PT_WRITE_I = 0x4 - PT_WRITE_U = 0x6 - RLIMIT_AS = 0x5 - RLIMIT_CORE = 0x4 - RLIMIT_CPU = 0x0 - RLIMIT_CPU_USAGE_MONITOR = 0x2 - RLIMIT_DATA = 0x2 - RLIMIT_FSIZE = 0x1 - RLIMIT_MEMLOCK = 0x6 - RLIMIT_NOFILE = 0x8 - RLIMIT_NPROC = 0x7 - RLIMIT_RSS = 0x5 - RLIMIT_STACK = 0x3 - RLIM_INFINITY = 0x7fffffffffffffff - RTAX_AUTHOR = 0x6 - RTAX_BRD = 0x7 - RTAX_DST = 0x0 - RTAX_GATEWAY = 0x1 - RTAX_GENMASK = 0x3 - RTAX_IFA = 0x5 - RTAX_IFP = 0x4 - RTAX_MAX = 0x8 - RTAX_NETMASK = 0x2 - RTA_AUTHOR = 0x40 - RTA_BRD = 0x80 - RTA_DST = 0x1 - RTA_GATEWAY = 0x2 - RTA_GENMASK = 0x8 - RTA_IFA = 0x20 - RTA_IFP = 0x10 - RTA_NETMASK = 0x4 - RTF_BLACKHOLE = 0x1000 - RTF_BROADCAST = 0x400000 - RTF_CLONING = 0x100 - RTF_CONDEMNED = 0x2000000 - RTF_DEAD = 0x20000000 - RTF_DELCLONE = 0x80 - RTF_DONE = 0x40 - RTF_DYNAMIC = 0x10 - RTF_GATEWAY = 0x2 - RTF_GLOBAL = 0x40000000 - RTF_HOST = 0x4 - RTF_IFREF = 0x4000000 - RTF_IFSCOPE = 0x1000000 - RTF_LLDATA = 0x400 - RTF_LLINFO = 0x400 - RTF_LOCAL = 0x200000 - RTF_MODIFIED = 0x20 - RTF_MULTICAST = 0x800000 - RTF_NOIFREF = 0x2000 - RTF_PINNED = 0x100000 - RTF_PRCLONING = 0x10000 - RTF_PROTO1 = 0x8000 - RTF_PROTO2 = 0x4000 - RTF_PROTO3 = 0x40000 - RTF_PROXY = 0x8000000 - RTF_REJECT = 0x8 - RTF_ROUTER = 0x10000000 - RTF_STATIC = 0x800 - RTF_UP = 0x1 - RTF_WASCLONED = 0x20000 - RTF_XRESOLVE = 0x200 - RTM_ADD = 0x1 - RTM_CHANGE = 0x3 - RTM_DELADDR = 0xd - RTM_DELETE = 0x2 - RTM_DELMADDR = 0x10 - RTM_GET = 0x4 - RTM_GET2 = 0x14 - RTM_IFINFO = 0xe - RTM_IFINFO2 = 0x12 - RTM_LOCK = 0x8 - RTM_LOSING = 0x5 - RTM_MISS = 0x7 - RTM_NEWADDR = 0xc - RTM_NEWMADDR = 0xf - RTM_NEWMADDR2 = 0x13 - RTM_OLDADD = 0x9 - RTM_OLDDEL = 0xa - RTM_REDIRECT = 0x6 - RTM_RESOLVE = 0xb - RTM_RTTUNIT = 0xf4240 - RTM_VERSION = 0x5 - RTV_EXPIRE = 0x4 - RTV_HOPCOUNT = 0x2 - RTV_MTU = 0x1 - RTV_RPIPE = 0x8 - RTV_RTT = 0x40 - RTV_RTTVAR = 0x80 - RTV_SPIPE = 0x10 - RTV_SSTHRESH = 0x20 - RUSAGE_CHILDREN = -0x1 - RUSAGE_SELF = 0x0 - SCM_CREDS = 0x3 - SCM_RIGHTS = 0x1 - SCM_TIMESTAMP = 0x2 - SCM_TIMESTAMP_MONOTONIC = 0x4 - SEEK_CUR = 0x1 - SEEK_DATA = 0x4 - SEEK_END = 0x2 - SEEK_HOLE = 0x3 - SEEK_SET = 0x0 - SHUT_RD = 0x0 - SHUT_RDWR = 0x2 - SHUT_WR = 0x1 - SIOCADDMULTI = 0x80206931 - SIOCAIFADDR = 0x8040691a - SIOCARPIPLL = 0xc0206928 - SIOCATMARK = 0x40047307 - SIOCAUTOADDR = 0xc0206926 - SIOCAUTONETMASK = 0x80206927 - SIOCDELMULTI = 0x80206932 - SIOCDIFADDR = 0x80206919 - SIOCDIFPHYADDR = 0x80206941 - SIOCGDRVSPEC = 0xc028697b - SIOCGETVLAN = 0xc020697f - SIOCGHIWAT = 0x40047301 - SIOCGIF6LOWPAN = 0xc02069c5 - SIOCGIFADDR = 0xc0206921 - SIOCGIFALTMTU = 0xc0206948 - SIOCGIFASYNCMAP = 0xc020697c - SIOCGIFBOND = 0xc0206947 - SIOCGIFBRDADDR = 0xc0206923 - SIOCGIFCAP = 0xc020695b - SIOCGIFCONF = 0xc00c6924 - SIOCGIFDEVMTU = 0xc0206944 - SIOCGIFDSTADDR = 0xc0206922 - SIOCGIFFLAGS = 0xc0206911 - SIOCGIFFUNCTIONALTYPE = 0xc02069ad - SIOCGIFGENERIC = 0xc020693a - SIOCGIFKPI = 0xc0206987 - SIOCGIFMAC = 0xc0206982 - SIOCGIFMEDIA = 0xc02c6938 - SIOCGIFMETRIC = 0xc0206917 - SIOCGIFMTU = 0xc0206933 - SIOCGIFNETMASK = 0xc0206925 - SIOCGIFPDSTADDR = 0xc0206940 - SIOCGIFPHYS = 0xc0206935 - SIOCGIFPSRCADDR = 0xc020693f - SIOCGIFSTATUS = 0xc331693d - SIOCGIFVLAN = 0xc020697f - SIOCGIFWAKEFLAGS = 0xc0206988 - SIOCGIFXMEDIA = 0xc02c6948 - SIOCGLOWAT = 0x40047303 - SIOCGPGRP = 0x40047309 - SIOCIFCREATE = 0xc0206978 - SIOCIFCREATE2 = 0xc020697a - SIOCIFDESTROY = 0x80206979 - SIOCIFGCLONERS = 0xc0106981 - SIOCRSLVMULTI = 0xc010693b - SIOCSDRVSPEC = 0x8028697b - SIOCSETVLAN = 0x8020697e - SIOCSHIWAT = 0x80047300 - SIOCSIF6LOWPAN = 0x802069c4 - SIOCSIFADDR = 0x8020690c - SIOCSIFALTMTU = 0x80206945 - SIOCSIFASYNCMAP = 0x8020697d - SIOCSIFBOND = 0x80206946 - SIOCSIFBRDADDR = 0x80206913 - SIOCSIFCAP = 0x8020695a - SIOCSIFDSTADDR = 0x8020690e - SIOCSIFFLAGS = 0x80206910 - SIOCSIFGENERIC = 0x80206939 - SIOCSIFKPI = 0x80206986 - SIOCSIFLLADDR = 0x8020693c - SIOCSIFMAC = 0x80206983 - SIOCSIFMEDIA = 0xc0206937 - SIOCSIFMETRIC = 0x80206918 - SIOCSIFMTU = 0x80206934 - SIOCSIFNETMASK = 0x80206916 - SIOCSIFPHYADDR = 0x8040693e - SIOCSIFPHYS = 0x80206936 - SIOCSIFVLAN = 0x8020697e - SIOCSLOWAT = 0x80047302 - SIOCSPGRP = 0x80047308 - SOCK_DGRAM = 0x2 - SOCK_MAXADDRLEN = 0xff - SOCK_RAW = 0x3 - SOCK_RDM = 0x4 - SOCK_SEQPACKET = 0x5 - SOCK_STREAM = 0x1 - SOL_LOCAL = 0x0 - SOL_SOCKET = 0xffff - SOMAXCONN = 0x80 - SO_ACCEPTCONN = 0x2 - SO_BROADCAST = 0x20 - SO_DEBUG = 0x1 - SO_DONTROUTE = 0x10 - SO_DONTTRUNC = 0x2000 - SO_ERROR = 0x1007 - SO_KEEPALIVE = 0x8 - SO_LABEL = 0x1010 - SO_LINGER = 0x80 - SO_LINGER_SEC = 0x1080 - SO_NETSVC_MARKING_LEVEL = 0x1119 - SO_NET_SERVICE_TYPE = 0x1116 - SO_NKE = 0x1021 - SO_NOADDRERR = 0x1023 - SO_NOSIGPIPE = 0x1022 - SO_NOTIFYCONFLICT = 0x1026 - SO_NP_EXTENSIONS = 0x1083 - SO_NREAD = 0x1020 - SO_NUMRCVPKT = 0x1112 - SO_NWRITE = 0x1024 - SO_OOBINLINE = 0x100 - SO_PEERLABEL = 0x1011 - SO_RANDOMPORT = 0x1082 - SO_RCVBUF = 0x1002 - SO_RCVLOWAT = 0x1004 - SO_RCVTIMEO = 0x1006 - SO_REUSEADDR = 0x4 - SO_REUSEPORT = 0x200 - SO_REUSESHAREUID = 0x1025 - SO_SNDBUF = 0x1001 - SO_SNDLOWAT = 0x1003 - SO_SNDTIMEO = 0x1005 - SO_TIMESTAMP = 0x400 - SO_TIMESTAMP_MONOTONIC = 0x800 - SO_TYPE = 0x1008 - SO_UPCALLCLOSEWAIT = 0x1027 - SO_USELOOPBACK = 0x40 - SO_WANTMORE = 0x4000 - SO_WANTOOBFLAG = 0x8000 - S_IEXEC = 0x40 - S_IFBLK = 0x6000 - S_IFCHR = 0x2000 - S_IFDIR = 0x4000 - S_IFIFO = 0x1000 - S_IFLNK = 0xa000 - S_IFMT = 0xf000 - S_IFREG = 0x8000 - S_IFSOCK = 0xc000 - S_IFWHT = 0xe000 - S_IREAD = 0x100 - S_IRGRP = 0x20 - S_IROTH = 0x4 - S_IRUSR = 0x100 - S_IRWXG = 0x38 - S_IRWXO = 0x7 - S_IRWXU = 0x1c0 - S_ISGID = 0x400 - S_ISTXT = 0x200 - S_ISUID = 0x800 - S_ISVTX = 0x200 - S_IWGRP = 0x10 - S_IWOTH = 0x2 - S_IWRITE = 0x80 - S_IWUSR = 0x80 - S_IXGRP = 0x8 - S_IXOTH = 0x1 - S_IXUSR = 0x40 - TAB0 = 0x0 - TAB1 = 0x400 - TAB2 = 0x800 - TAB3 = 0x4 - TABDLY = 0xc04 - TCIFLUSH = 0x1 - TCIOFF = 0x3 - TCIOFLUSH = 0x3 - TCION = 0x4 - TCOFLUSH = 0x2 - TCOOFF = 0x1 - TCOON = 0x2 - TCP_CONNECTIONTIMEOUT = 0x20 - TCP_CONNECTION_INFO = 0x106 - TCP_ENABLE_ECN = 0x104 - TCP_FASTOPEN = 0x105 - TCP_KEEPALIVE = 0x10 - TCP_KEEPCNT = 0x102 - TCP_KEEPINTVL = 0x101 - TCP_MAXHLEN = 0x3c - TCP_MAXOLEN = 0x28 - TCP_MAXSEG = 0x2 - TCP_MAXWIN = 0xffff - TCP_MAX_SACK = 0x4 - TCP_MAX_WINSHIFT = 0xe - TCP_MINMSS = 0xd8 - TCP_MSS = 0x200 - TCP_NODELAY = 0x1 - TCP_NOOPT = 0x8 - TCP_NOPUSH = 0x4 - TCP_NOTSENT_LOWAT = 0x201 - TCP_RXT_CONNDROPTIME = 0x80 - TCP_RXT_FINDROP = 0x100 - TCP_SENDMOREACKS = 0x103 - TCSAFLUSH = 0x2 - TIOCCBRK = 0x2000747a - TIOCCDTR = 0x20007478 - TIOCCONS = 0x80047462 - TIOCDCDTIMESTAMP = 0x40107458 - TIOCDRAIN = 0x2000745e - TIOCDSIMICROCODE = 0x20007455 - TIOCEXCL = 0x2000740d - TIOCEXT = 0x80047460 - TIOCFLUSH = 0x80047410 - TIOCGDRAINWAIT = 0x40047456 - TIOCGETA = 0x40487413 - TIOCGETD = 0x4004741a - TIOCGPGRP = 0x40047477 - TIOCGWINSZ = 0x40087468 - TIOCIXOFF = 0x20007480 - TIOCIXON = 0x20007481 - TIOCMBIC = 0x8004746b - TIOCMBIS = 0x8004746c - TIOCMGDTRWAIT = 0x4004745a - TIOCMGET = 0x4004746a - TIOCMODG = 0x40047403 - TIOCMODS = 0x80047404 - TIOCMSDTRWAIT = 0x8004745b - TIOCMSET = 0x8004746d - TIOCM_CAR = 0x40 - TIOCM_CD = 0x40 - TIOCM_CTS = 0x20 - TIOCM_DSR = 0x100 - TIOCM_DTR = 0x2 - TIOCM_LE = 0x1 - TIOCM_RI = 0x80 - TIOCM_RNG = 0x80 - TIOCM_RTS = 0x4 - TIOCM_SR = 0x10 - TIOCM_ST = 0x8 - TIOCNOTTY = 0x20007471 - TIOCNXCL = 0x2000740e - TIOCOUTQ = 0x40047473 - TIOCPKT = 0x80047470 - TIOCPKT_DATA = 0x0 - TIOCPKT_DOSTOP = 0x20 - TIOCPKT_FLUSHREAD = 0x1 - TIOCPKT_FLUSHWRITE = 0x2 - TIOCPKT_IOCTL = 0x40 - TIOCPKT_NOSTOP = 0x10 - TIOCPKT_START = 0x8 - TIOCPKT_STOP = 0x4 - TIOCPTYGNAME = 0x40807453 - TIOCPTYGRANT = 0x20007454 - TIOCPTYUNLK = 0x20007452 - TIOCREMOTE = 0x80047469 - TIOCSBRK = 0x2000747b - TIOCSCONS = 0x20007463 - TIOCSCTTY = 0x20007461 - TIOCSDRAINWAIT = 0x80047457 - TIOCSDTR = 0x20007479 - TIOCSETA = 0x80487414 - TIOCSETAF = 0x80487416 - TIOCSETAW = 0x80487415 - TIOCSETD = 0x8004741b - TIOCSIG = 0x2000745f - TIOCSPGRP = 0x80047476 - TIOCSTART = 0x2000746e - TIOCSTAT = 0x20007465 - TIOCSTI = 0x80017472 - TIOCSTOP = 0x2000746f - TIOCSWINSZ = 0x80087467 - TIOCTIMESTAMP = 0x40107459 - TIOCUCNTL = 0x80047466 - TOSTOP = 0x400000 - VDISCARD = 0xf - VDSUSP = 0xb - VEOF = 0x0 - VEOL = 0x1 - VEOL2 = 0x2 - VERASE = 0x3 - VINTR = 0x8 - VKILL = 0x5 - VLNEXT = 0xe - VMIN = 0x10 - VM_LOADAVG = 0x2 - VM_MACHFACTOR = 0x4 - VM_MAXID = 0x6 - VM_METER = 0x1 - VM_SWAPUSAGE = 0x5 - VQUIT = 0x9 - VREPRINT = 0x6 - VSTART = 0xc - VSTATUS = 0x12 - VSTOP = 0xd - VSUSP = 0xa - VT0 = 0x0 - VT1 = 0x10000 - VTDLY = 0x10000 - VTIME = 0x11 - VWERASE = 0x4 - WCONTINUED = 0x10 - WCOREFLAG = 0x80 - WEXITED = 0x4 - WNOHANG = 0x1 - WNOWAIT = 0x20 - WORDSIZE = 0x40 - WSTOPPED = 0x8 - WUNTRACED = 0x2 - XATTR_CREATE = 0x2 - XATTR_NODEFAULT = 0x10 - XATTR_NOFOLLOW = 0x1 - XATTR_NOSECURITY = 0x8 - XATTR_REPLACE = 0x4 - XATTR_SHOWCOMPRESSION = 0x20 + AF_APPLETALK = 0x10 + AF_CCITT = 0xa + AF_CHAOS = 0x5 + AF_CNT = 0x15 + AF_COIP = 0x14 + AF_DATAKIT = 0x9 + AF_DECnet = 0xc + AF_DLI = 0xd + AF_E164 = 0x1c + AF_ECMA = 0x8 + AF_HYLINK = 0xf + AF_IEEE80211 = 0x25 + AF_IMPLINK = 0x3 + AF_INET = 0x2 + AF_INET6 = 0x1e + AF_IPX = 0x17 + AF_ISDN = 0x1c + AF_ISO = 0x7 + AF_LAT = 0xe + AF_LINK = 0x12 + AF_LOCAL = 0x1 + AF_MAX = 0x29 + AF_NATM = 0x1f + AF_NDRV = 0x1b + AF_NETBIOS = 0x21 + AF_NS = 0x6 + AF_OSI = 0x7 + AF_PPP = 0x22 + AF_PUP = 0x4 + AF_RESERVED_36 = 0x24 + AF_ROUTE = 0x11 + AF_SIP = 0x18 + AF_SNA = 0xb + AF_SYSTEM = 0x20 + AF_SYS_CONTROL = 0x2 + AF_UNIX = 0x1 + AF_UNSPEC = 0x0 + AF_UTUN = 0x26 + AF_VSOCK = 0x28 + ALTWERASE = 0x200 + ATTR_BIT_MAP_COUNT = 0x5 + ATTR_CMN_ACCESSMASK = 0x20000 + ATTR_CMN_ACCTIME = 0x1000 + ATTR_CMN_ADDEDTIME = 0x10000000 + ATTR_CMN_BKUPTIME = 0x2000 + ATTR_CMN_CHGTIME = 0x800 + ATTR_CMN_CRTIME = 0x200 + ATTR_CMN_DATA_PROTECT_FLAGS = 0x40000000 + ATTR_CMN_DEVID = 0x2 + ATTR_CMN_DOCUMENT_ID = 0x100000 + ATTR_CMN_ERROR = 0x20000000 + ATTR_CMN_EXTENDED_SECURITY = 0x400000 + ATTR_CMN_FILEID = 0x2000000 + ATTR_CMN_FLAGS = 0x40000 + ATTR_CMN_FNDRINFO = 0x4000 + ATTR_CMN_FSID = 0x4 + ATTR_CMN_FULLPATH = 0x8000000 + ATTR_CMN_GEN_COUNT = 0x80000 + ATTR_CMN_GRPID = 0x10000 + ATTR_CMN_GRPUUID = 0x1000000 + ATTR_CMN_MODTIME = 0x400 + ATTR_CMN_NAME = 0x1 + ATTR_CMN_NAMEDATTRCOUNT = 0x80000 + ATTR_CMN_NAMEDATTRLIST = 0x100000 + ATTR_CMN_OBJID = 0x20 + ATTR_CMN_OBJPERMANENTID = 0x40 + ATTR_CMN_OBJTAG = 0x10 + ATTR_CMN_OBJTYPE = 0x8 + ATTR_CMN_OWNERID = 0x8000 + ATTR_CMN_PARENTID = 0x4000000 + ATTR_CMN_PAROBJID = 0x80 + ATTR_CMN_RETURNED_ATTRS = 0x80000000 + ATTR_CMN_SCRIPT = 0x100 + ATTR_CMN_SETMASK = 0x51c7ff00 + ATTR_CMN_USERACCESS = 0x200000 + ATTR_CMN_UUID = 0x800000 + ATTR_CMN_VALIDMASK = 0xffffffff + ATTR_CMN_VOLSETMASK = 0x6700 + ATTR_FILE_ALLOCSIZE = 0x4 + ATTR_FILE_CLUMPSIZE = 0x10 + ATTR_FILE_DATAALLOCSIZE = 0x400 + ATTR_FILE_DATAEXTENTS = 0x800 + ATTR_FILE_DATALENGTH = 0x200 + ATTR_FILE_DEVTYPE = 0x20 + ATTR_FILE_FILETYPE = 0x40 + ATTR_FILE_FORKCOUNT = 0x80 + ATTR_FILE_FORKLIST = 0x100 + ATTR_FILE_IOBLOCKSIZE = 0x8 + ATTR_FILE_LINKCOUNT = 0x1 + ATTR_FILE_RSRCALLOCSIZE = 0x2000 + ATTR_FILE_RSRCEXTENTS = 0x4000 + ATTR_FILE_RSRCLENGTH = 0x1000 + ATTR_FILE_SETMASK = 0x20 + ATTR_FILE_TOTALSIZE = 0x2 + ATTR_FILE_VALIDMASK = 0x37ff + ATTR_VOL_ALLOCATIONCLUMP = 0x40 + ATTR_VOL_ATTRIBUTES = 0x40000000 + ATTR_VOL_CAPABILITIES = 0x20000 + ATTR_VOL_DIRCOUNT = 0x400 + ATTR_VOL_ENCODINGSUSED = 0x10000 + ATTR_VOL_FILECOUNT = 0x200 + ATTR_VOL_FSTYPE = 0x1 + ATTR_VOL_INFO = 0x80000000 + ATTR_VOL_IOBLOCKSIZE = 0x80 + ATTR_VOL_MAXOBJCOUNT = 0x800 + ATTR_VOL_MINALLOCATION = 0x20 + ATTR_VOL_MOUNTEDDEVICE = 0x8000 + ATTR_VOL_MOUNTFLAGS = 0x4000 + ATTR_VOL_MOUNTPOINT = 0x1000 + ATTR_VOL_NAME = 0x2000 + ATTR_VOL_OBJCOUNT = 0x100 + ATTR_VOL_QUOTA_SIZE = 0x10000000 + ATTR_VOL_RESERVED_SIZE = 0x20000000 + ATTR_VOL_SETMASK = 0x80002000 + ATTR_VOL_SIGNATURE = 0x2 + ATTR_VOL_SIZE = 0x4 + ATTR_VOL_SPACEAVAIL = 0x10 + ATTR_VOL_SPACEFREE = 0x8 + ATTR_VOL_SPACEUSED = 0x800000 + ATTR_VOL_UUID = 0x40000 + ATTR_VOL_VALIDMASK = 0xf087ffff + B0 = 0x0 + B110 = 0x6e + B115200 = 0x1c200 + B1200 = 0x4b0 + B134 = 0x86 + B14400 = 0x3840 + B150 = 0x96 + B1800 = 0x708 + B19200 = 0x4b00 + B200 = 0xc8 + B230400 = 0x38400 + B2400 = 0x960 + B28800 = 0x7080 + B300 = 0x12c + B38400 = 0x9600 + B4800 = 0x12c0 + B50 = 0x32 + B57600 = 0xe100 + B600 = 0x258 + B7200 = 0x1c20 + B75 = 0x4b + B76800 = 0x12c00 + B9600 = 0x2580 + BIOCFLUSH = 0x20004268 + BIOCGBLEN = 0x40044266 + BIOCGDLT = 0x4004426a + BIOCGDLTLIST = 0xc00c4279 + BIOCGETIF = 0x4020426b + BIOCGHDRCMPLT = 0x40044274 + BIOCGRSIG = 0x40044272 + BIOCGRTIMEOUT = 0x4010426e + BIOCGSEESENT = 0x40044276 + BIOCGSTATS = 0x4008426f + BIOCIMMEDIATE = 0x80044270 + BIOCPROMISC = 0x20004269 + BIOCSBLEN = 0xc0044266 + BIOCSDLT = 0x80044278 + BIOCSETF = 0x80104267 + BIOCSETFNR = 0x8010427e + BIOCSETIF = 0x8020426c + BIOCSHDRCMPLT = 0x80044275 + BIOCSRSIG = 0x80044273 + BIOCSRTIMEOUT = 0x8010426d + BIOCSSEESENT = 0x80044277 + BIOCVERSION = 0x40044271 + BPF_A = 0x10 + BPF_ABS = 0x20 + BPF_ADD = 0x0 + BPF_ALIGNMENT = 0x4 + BPF_ALU = 0x4 + BPF_AND = 0x50 + BPF_B = 0x10 + BPF_DIV = 0x30 + BPF_H = 0x8 + BPF_IMM = 0x0 + BPF_IND = 0x40 + BPF_JA = 0x0 + BPF_JEQ = 0x10 + BPF_JGE = 0x30 + BPF_JGT = 0x20 + BPF_JMP = 0x5 + BPF_JSET = 0x40 + BPF_K = 0x0 + BPF_LD = 0x0 + BPF_LDX = 0x1 + BPF_LEN = 0x80 + BPF_LSH = 0x60 + BPF_MAJOR_VERSION = 0x1 + BPF_MAXBUFSIZE = 0x80000 + BPF_MAXINSNS = 0x200 + BPF_MEM = 0x60 + BPF_MEMWORDS = 0x10 + BPF_MINBUFSIZE = 0x20 + BPF_MINOR_VERSION = 0x1 + BPF_MISC = 0x7 + BPF_MSH = 0xa0 + BPF_MUL = 0x20 + BPF_NEG = 0x80 + BPF_OR = 0x40 + BPF_RELEASE = 0x30bb6 + BPF_RET = 0x6 + BPF_RSH = 0x70 + BPF_ST = 0x2 + BPF_STX = 0x3 + BPF_SUB = 0x10 + BPF_TAX = 0x0 + BPF_TXA = 0x80 + BPF_W = 0x0 + BPF_X = 0x8 + BRKINT = 0x2 + BS0 = 0x0 + BS1 = 0x8000 + BSDLY = 0x8000 + CFLUSH = 0xf + CLOCAL = 0x8000 + CLOCK_MONOTONIC = 0x6 + CLOCK_MONOTONIC_RAW = 0x4 + CLOCK_MONOTONIC_RAW_APPROX = 0x5 + CLOCK_PROCESS_CPUTIME_ID = 0xc + CLOCK_REALTIME = 0x0 + CLOCK_THREAD_CPUTIME_ID = 0x10 + CLOCK_UPTIME_RAW = 0x8 + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 + CR3 = 0x3000 + CRDLY = 0x3000 + CREAD = 0x800 + CRTSCTS = 0x30000 + CS5 = 0x0 + CS6 = 0x100 + CS7 = 0x200 + CS8 = 0x300 + CSIZE = 0x300 + CSTART = 0x11 + CSTATUS = 0x14 + CSTOP = 0x13 + CSTOPB = 0x400 + CSUSP = 0x1a + CTLIOCGINFO = 0xc0644e03 + CTL_HW = 0x6 + CTL_KERN = 0x1 + CTL_MAXNAME = 0xc + CTL_NET = 0x4 + DLT_A429 = 0xb8 + DLT_A653_ICM = 0xb9 + DLT_AIRONET_HEADER = 0x78 + DLT_AOS = 0xde + DLT_APPLE_IP_OVER_IEEE1394 = 0x8a + DLT_ARCNET = 0x7 + DLT_ARCNET_LINUX = 0x81 + DLT_ATM_CLIP = 0x13 + DLT_ATM_RFC1483 = 0xb + DLT_AURORA = 0x7e + DLT_AX25 = 0x3 + DLT_AX25_KISS = 0xca + DLT_BACNET_MS_TP = 0xa5 + DLT_BLUETOOTH_HCI_H4 = 0xbb + DLT_BLUETOOTH_HCI_H4_WITH_PHDR = 0xc9 + DLT_CAN20B = 0xbe + DLT_CAN_SOCKETCAN = 0xe3 + DLT_CHAOS = 0x5 + DLT_CHDLC = 0x68 + DLT_CISCO_IOS = 0x76 + DLT_C_HDLC = 0x68 + DLT_C_HDLC_WITH_DIR = 0xcd + DLT_DBUS = 0xe7 + DLT_DECT = 0xdd + DLT_DOCSIS = 0x8f + DLT_DVB_CI = 0xeb + DLT_ECONET = 0x73 + DLT_EN10MB = 0x1 + DLT_EN3MB = 0x2 + DLT_ENC = 0x6d + DLT_ERF = 0xc5 + DLT_ERF_ETH = 0xaf + DLT_ERF_POS = 0xb0 + DLT_FC_2 = 0xe0 + DLT_FC_2_WITH_FRAME_DELIMS = 0xe1 + DLT_FDDI = 0xa + DLT_FLEXRAY = 0xd2 + DLT_FRELAY = 0x6b + DLT_FRELAY_WITH_DIR = 0xce + DLT_GCOM_SERIAL = 0xad + DLT_GCOM_T1E1 = 0xac + DLT_GPF_F = 0xab + DLT_GPF_T = 0xaa + DLT_GPRS_LLC = 0xa9 + DLT_GSMTAP_ABIS = 0xda + DLT_GSMTAP_UM = 0xd9 + DLT_HHDLC = 0x79 + DLT_IBM_SN = 0x92 + DLT_IBM_SP = 0x91 + DLT_IEEE802 = 0x6 + DLT_IEEE802_11 = 0x69 + DLT_IEEE802_11_RADIO = 0x7f + DLT_IEEE802_11_RADIO_AVS = 0xa3 + DLT_IEEE802_15_4 = 0xc3 + DLT_IEEE802_15_4_LINUX = 0xbf + DLT_IEEE802_15_4_NOFCS = 0xe6 + DLT_IEEE802_15_4_NONASK_PHY = 0xd7 + DLT_IEEE802_16_MAC_CPS = 0xbc + DLT_IEEE802_16_MAC_CPS_RADIO = 0xc1 + DLT_IPFILTER = 0x74 + DLT_IPMB = 0xc7 + DLT_IPMB_LINUX = 0xd1 + DLT_IPNET = 0xe2 + DLT_IPOIB = 0xf2 + DLT_IPV4 = 0xe4 + DLT_IPV6 = 0xe5 + DLT_IP_OVER_FC = 0x7a + DLT_JUNIPER_ATM1 = 0x89 + DLT_JUNIPER_ATM2 = 0x87 + DLT_JUNIPER_ATM_CEMIC = 0xee + DLT_JUNIPER_CHDLC = 0xb5 + DLT_JUNIPER_ES = 0x84 + DLT_JUNIPER_ETHER = 0xb2 + DLT_JUNIPER_FIBRECHANNEL = 0xea + DLT_JUNIPER_FRELAY = 0xb4 + DLT_JUNIPER_GGSN = 0x85 + DLT_JUNIPER_ISM = 0xc2 + DLT_JUNIPER_MFR = 0x86 + DLT_JUNIPER_MLFR = 0x83 + DLT_JUNIPER_MLPPP = 0x82 + DLT_JUNIPER_MONITOR = 0xa4 + DLT_JUNIPER_PIC_PEER = 0xae + DLT_JUNIPER_PPP = 0xb3 + DLT_JUNIPER_PPPOE = 0xa7 + DLT_JUNIPER_PPPOE_ATM = 0xa8 + DLT_JUNIPER_SERVICES = 0x88 + DLT_JUNIPER_SRX_E2E = 0xe9 + DLT_JUNIPER_ST = 0xc8 + DLT_JUNIPER_VP = 0xb7 + DLT_JUNIPER_VS = 0xe8 + DLT_LAPB_WITH_DIR = 0xcf + DLT_LAPD = 0xcb + DLT_LIN = 0xd4 + DLT_LINUX_EVDEV = 0xd8 + DLT_LINUX_IRDA = 0x90 + DLT_LINUX_LAPD = 0xb1 + DLT_LINUX_PPP_WITHDIRECTION = 0xa6 + DLT_LINUX_SLL = 0x71 + DLT_LOOP = 0x6c + DLT_LTALK = 0x72 + DLT_MATCHING_MAX = 0x10a + DLT_MATCHING_MIN = 0x68 + DLT_MFR = 0xb6 + DLT_MOST = 0xd3 + DLT_MPEG_2_TS = 0xf3 + DLT_MPLS = 0xdb + DLT_MTP2 = 0x8c + DLT_MTP2_WITH_PHDR = 0x8b + DLT_MTP3 = 0x8d + DLT_MUX27010 = 0xec + DLT_NETANALYZER = 0xf0 + DLT_NETANALYZER_TRANSPARENT = 0xf1 + DLT_NFC_LLCP = 0xf5 + DLT_NFLOG = 0xef + DLT_NG40 = 0xf4 + DLT_NULL = 0x0 + DLT_PCI_EXP = 0x7d + DLT_PFLOG = 0x75 + DLT_PFSYNC = 0x12 + DLT_PPI = 0xc0 + DLT_PPP = 0x9 + DLT_PPP_BSDOS = 0x10 + DLT_PPP_ETHER = 0x33 + DLT_PPP_PPPD = 0xa6 + DLT_PPP_SERIAL = 0x32 + DLT_PPP_WITH_DIR = 0xcc + DLT_PPP_WITH_DIRECTION = 0xa6 + DLT_PRISM_HEADER = 0x77 + DLT_PRONET = 0x4 + DLT_RAIF1 = 0xc6 + DLT_RAW = 0xc + DLT_RIO = 0x7c + DLT_SCCP = 0x8e + DLT_SITA = 0xc4 + DLT_SLIP = 0x8 + DLT_SLIP_BSDOS = 0xf + DLT_STANAG_5066_D_PDU = 0xed + DLT_SUNATM = 0x7b + DLT_SYMANTEC_FIREWALL = 0x63 + DLT_TZSP = 0x80 + DLT_USB = 0xba + DLT_USB_DARWIN = 0x10a + DLT_USB_LINUX = 0xbd + DLT_USB_LINUX_MMAPPED = 0xdc + DLT_USER0 = 0x93 + DLT_USER1 = 0x94 + DLT_USER10 = 0x9d + DLT_USER11 = 0x9e + DLT_USER12 = 0x9f + DLT_USER13 = 0xa0 + DLT_USER14 = 0xa1 + DLT_USER15 = 0xa2 + DLT_USER2 = 0x95 + DLT_USER3 = 0x96 + DLT_USER4 = 0x97 + DLT_USER5 = 0x98 + DLT_USER6 = 0x99 + DLT_USER7 = 0x9a + DLT_USER8 = 0x9b + DLT_USER9 = 0x9c + DLT_WIHART = 0xdf + DLT_X2E_SERIAL = 0xd5 + DLT_X2E_XORAYA = 0xd6 + DT_BLK = 0x6 + DT_CHR = 0x2 + DT_DIR = 0x4 + DT_FIFO = 0x1 + DT_LNK = 0xa + DT_REG = 0x8 + DT_SOCK = 0xc + DT_UNKNOWN = 0x0 + DT_WHT = 0xe + ECHO = 0x8 + ECHOCTL = 0x40 + ECHOE = 0x2 + ECHOK = 0x4 + ECHOKE = 0x1 + ECHONL = 0x10 + ECHOPRT = 0x20 + EVFILT_AIO = -0x3 + EVFILT_EXCEPT = -0xf + EVFILT_FS = -0x9 + EVFILT_MACHPORT = -0x8 + EVFILT_PROC = -0x5 + EVFILT_READ = -0x1 + EVFILT_SIGNAL = -0x6 + EVFILT_SYSCOUNT = 0x11 + EVFILT_THREADMARKER = 0x11 + EVFILT_TIMER = -0x7 + EVFILT_USER = -0xa + EVFILT_VM = -0xc + EVFILT_VNODE = -0x4 + EVFILT_WRITE = -0x2 + EV_ADD = 0x1 + EV_CLEAR = 0x20 + EV_DELETE = 0x2 + EV_DISABLE = 0x8 + EV_DISPATCH = 0x80 + EV_DISPATCH2 = 0x180 + EV_ENABLE = 0x4 + EV_EOF = 0x8000 + EV_ERROR = 0x4000 + EV_FLAG0 = 0x1000 + EV_FLAG1 = 0x2000 + EV_ONESHOT = 0x10 + EV_OOBAND = 0x2000 + EV_POLL = 0x1000 + EV_RECEIPT = 0x40 + EV_SYSFLAGS = 0xf000 + EV_UDATA_SPECIFIC = 0x100 + EV_VANISHED = 0x200 + EXTA = 0x4b00 + EXTB = 0x9600 + EXTPROC = 0x800 + FD_CLOEXEC = 0x1 + FD_SETSIZE = 0x400 + FF0 = 0x0 + FF1 = 0x4000 + FFDLY = 0x4000 + FLUSHO = 0x800000 + FSOPT_ATTR_CMN_EXTENDED = 0x20 + FSOPT_NOFOLLOW = 0x1 + FSOPT_NOINMEMUPDATE = 0x2 + FSOPT_PACK_INVAL_ATTRS = 0x8 + FSOPT_REPORT_FULLSIZE = 0x4 + FSOPT_RETURN_REALDEV = 0x200 + F_ADDFILESIGS = 0x3d + F_ADDFILESIGS_FOR_DYLD_SIM = 0x53 + F_ADDFILESIGS_INFO = 0x67 + F_ADDFILESIGS_RETURN = 0x61 + F_ADDFILESUPPL = 0x68 + F_ADDSIGS = 0x3b + F_ALLOCATEALL = 0x4 + F_ALLOCATECONTIG = 0x2 + F_BARRIERFSYNC = 0x55 + F_CHECK_LV = 0x62 + F_CHKCLEAN = 0x29 + F_DUPFD = 0x0 + F_DUPFD_CLOEXEC = 0x43 + F_FINDSIGS = 0x4e + F_FLUSH_DATA = 0x28 + F_FREEZE_FS = 0x35 + F_FULLFSYNC = 0x33 + F_GETCODEDIR = 0x48 + F_GETFD = 0x1 + F_GETFL = 0x3 + F_GETLK = 0x7 + F_GETLKPID = 0x42 + F_GETNOSIGPIPE = 0x4a + F_GETOWN = 0x5 + F_GETPATH = 0x32 + F_GETPATH_MTMINFO = 0x47 + F_GETPATH_NOFIRMLINK = 0x66 + F_GETPROTECTIONCLASS = 0x3f + F_GETPROTECTIONLEVEL = 0x4d + F_GETSIGSINFO = 0x69 + F_GLOBAL_NOCACHE = 0x37 + F_LOG2PHYS = 0x31 + F_LOG2PHYS_EXT = 0x41 + F_NOCACHE = 0x30 + F_NODIRECT = 0x3e + F_OK = 0x0 + F_PATHPKG_CHECK = 0x34 + F_PEOFPOSMODE = 0x3 + F_PREALLOCATE = 0x2a + F_PUNCHHOLE = 0x63 + F_RDADVISE = 0x2c + F_RDAHEAD = 0x2d + F_RDLCK = 0x1 + F_SETBACKINGSTORE = 0x46 + F_SETFD = 0x2 + F_SETFL = 0x4 + F_SETLK = 0x8 + F_SETLKW = 0x9 + F_SETLKWTIMEOUT = 0xa + F_SETNOSIGPIPE = 0x49 + F_SETOWN = 0x6 + F_SETPROTECTIONCLASS = 0x40 + F_SETSIZE = 0x2b + F_SINGLE_WRITER = 0x4c + F_SPECULATIVE_READ = 0x65 + F_THAW_FS = 0x36 + F_TRANSCODEKEY = 0x4b + F_TRIM_ACTIVE_FILE = 0x64 + F_UNLCK = 0x2 + F_VOLPOSMODE = 0x4 + F_WRLCK = 0x3 + HUPCL = 0x4000 + HW_MACHINE = 0x1 + ICANON = 0x100 + ICMP6_FILTER = 0x12 + ICRNL = 0x100 + IEXTEN = 0x400 + IFF_ALLMULTI = 0x200 + IFF_ALTPHYS = 0x4000 + IFF_BROADCAST = 0x2 + IFF_DEBUG = 0x4 + IFF_LINK0 = 0x1000 + IFF_LINK1 = 0x2000 + IFF_LINK2 = 0x4000 + IFF_LOOPBACK = 0x8 + IFF_MULTICAST = 0x8000 + IFF_NOARP = 0x80 + IFF_NOTRAILERS = 0x20 + IFF_OACTIVE = 0x400 + IFF_POINTOPOINT = 0x10 + IFF_PROMISC = 0x100 + IFF_RUNNING = 0x40 + IFF_SIMPLEX = 0x800 + IFF_UP = 0x1 + IFNAMSIZ = 0x10 + IFT_1822 = 0x2 + IFT_6LOWPAN = 0x40 + IFT_AAL5 = 0x31 + IFT_ARCNET = 0x23 + IFT_ARCNETPLUS = 0x24 + IFT_ATM = 0x25 + IFT_BRIDGE = 0xd1 + IFT_CARP = 0xf8 + IFT_CELLULAR = 0xff + IFT_CEPT = 0x13 + IFT_DS3 = 0x1e + IFT_ENC = 0xf4 + IFT_EON = 0x19 + IFT_ETHER = 0x6 + IFT_FAITH = 0x38 + IFT_FDDI = 0xf + IFT_FRELAY = 0x20 + IFT_FRELAYDCE = 0x2c + IFT_GIF = 0x37 + IFT_HDH1822 = 0x3 + IFT_HIPPI = 0x2f + IFT_HSSI = 0x2e + IFT_HY = 0xe + IFT_IEEE1394 = 0x90 + IFT_IEEE8023ADLAG = 0x88 + IFT_ISDNBASIC = 0x14 + IFT_ISDNPRIMARY = 0x15 + IFT_ISO88022LLC = 0x29 + IFT_ISO88023 = 0x7 + IFT_ISO88024 = 0x8 + IFT_ISO88025 = 0x9 + IFT_ISO88026 = 0xa + IFT_L2VLAN = 0x87 + IFT_LAPB = 0x10 + IFT_LOCALTALK = 0x2a + IFT_LOOP = 0x18 + IFT_MIOX25 = 0x26 + IFT_MODEM = 0x30 + IFT_NSIP = 0x1b + IFT_OTHER = 0x1 + IFT_P10 = 0xc + IFT_P80 = 0xd + IFT_PARA = 0x22 + IFT_PDP = 0xff + IFT_PFLOG = 0xf5 + IFT_PFSYNC = 0xf6 + IFT_PKTAP = 0xfe + IFT_PPP = 0x17 + IFT_PROPMUX = 0x36 + IFT_PROPVIRTUAL = 0x35 + IFT_PTPSERIAL = 0x16 + IFT_RS232 = 0x21 + IFT_SDLC = 0x11 + IFT_SIP = 0x1f + IFT_SLIP = 0x1c + IFT_SMDSDXI = 0x2b + IFT_SMDSICIP = 0x34 + IFT_SONET = 0x27 + IFT_SONETPATH = 0x32 + IFT_SONETVT = 0x33 + IFT_STARLAN = 0xb + IFT_STF = 0x39 + IFT_T1 = 0x12 + IFT_ULTRA = 0x1d + IFT_V35 = 0x2d + IFT_X25 = 0x5 + IFT_X25DDN = 0x4 + IFT_X25PLE = 0x28 + IFT_XETHER = 0x1a + IGNBRK = 0x1 + IGNCR = 0x80 + IGNPAR = 0x4 + IMAXBEL = 0x2000 + INLCR = 0x40 + INPCK = 0x10 + IN_CLASSA_HOST = 0xffffff + IN_CLASSA_MAX = 0x80 + IN_CLASSA_NET = 0xff000000 + IN_CLASSA_NSHIFT = 0x18 + IN_CLASSB_HOST = 0xffff + IN_CLASSB_MAX = 0x10000 + IN_CLASSB_NET = 0xffff0000 + IN_CLASSB_NSHIFT = 0x10 + IN_CLASSC_HOST = 0xff + IN_CLASSC_NET = 0xffffff00 + IN_CLASSC_NSHIFT = 0x8 + IN_CLASSD_HOST = 0xfffffff + IN_CLASSD_NET = 0xf0000000 + IN_CLASSD_NSHIFT = 0x1c + IN_LINKLOCALNETNUM = 0xa9fe0000 + IN_LOOPBACKNET = 0x7f + IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x400473d1 + IPPROTO_3PC = 0x22 + IPPROTO_ADFS = 0x44 + IPPROTO_AH = 0x33 + IPPROTO_AHIP = 0x3d + IPPROTO_APES = 0x63 + IPPROTO_ARGUS = 0xd + IPPROTO_AX25 = 0x5d + IPPROTO_BHA = 0x31 + IPPROTO_BLT = 0x1e + IPPROTO_BRSATMON = 0x4c + IPPROTO_CFTP = 0x3e + IPPROTO_CHAOS = 0x10 + IPPROTO_CMTP = 0x26 + IPPROTO_CPHB = 0x49 + IPPROTO_CPNX = 0x48 + IPPROTO_DDP = 0x25 + IPPROTO_DGP = 0x56 + IPPROTO_DIVERT = 0xfe + IPPROTO_DONE = 0x101 + IPPROTO_DSTOPTS = 0x3c + IPPROTO_EGP = 0x8 + IPPROTO_EMCON = 0xe + IPPROTO_ENCAP = 0x62 + IPPROTO_EON = 0x50 + IPPROTO_ESP = 0x32 + IPPROTO_ETHERIP = 0x61 + IPPROTO_FRAGMENT = 0x2c + IPPROTO_GGP = 0x3 + IPPROTO_GMTP = 0x64 + IPPROTO_GRE = 0x2f + IPPROTO_HELLO = 0x3f + IPPROTO_HMP = 0x14 + IPPROTO_HOPOPTS = 0x0 + IPPROTO_ICMP = 0x1 + IPPROTO_ICMPV6 = 0x3a + IPPROTO_IDP = 0x16 + IPPROTO_IDPR = 0x23 + IPPROTO_IDRP = 0x2d + IPPROTO_IGMP = 0x2 + IPPROTO_IGP = 0x55 + IPPROTO_IGRP = 0x58 + IPPROTO_IL = 0x28 + IPPROTO_INLSP = 0x34 + IPPROTO_INP = 0x20 + IPPROTO_IP = 0x0 + IPPROTO_IPCOMP = 0x6c + IPPROTO_IPCV = 0x47 + IPPROTO_IPEIP = 0x5e + IPPROTO_IPIP = 0x4 + IPPROTO_IPPC = 0x43 + IPPROTO_IPV4 = 0x4 + IPPROTO_IPV6 = 0x29 + IPPROTO_IRTP = 0x1c + IPPROTO_KRYPTOLAN = 0x41 + IPPROTO_LARP = 0x5b + IPPROTO_LEAF1 = 0x19 + IPPROTO_LEAF2 = 0x1a + IPPROTO_MAX = 0x100 + IPPROTO_MAXID = 0x34 + IPPROTO_MEAS = 0x13 + IPPROTO_MHRP = 0x30 + IPPROTO_MICP = 0x5f + IPPROTO_MTP = 0x5c + IPPROTO_MUX = 0x12 + IPPROTO_ND = 0x4d + IPPROTO_NHRP = 0x36 + IPPROTO_NONE = 0x3b + IPPROTO_NSP = 0x1f + IPPROTO_NVPII = 0xb + IPPROTO_OSPFIGP = 0x59 + IPPROTO_PGM = 0x71 + IPPROTO_PIGP = 0x9 + IPPROTO_PIM = 0x67 + IPPROTO_PRM = 0x15 + IPPROTO_PUP = 0xc + IPPROTO_PVP = 0x4b + IPPROTO_RAW = 0xff + IPPROTO_RCCMON = 0xa + IPPROTO_RDP = 0x1b + IPPROTO_ROUTING = 0x2b + IPPROTO_RSVP = 0x2e + IPPROTO_RVD = 0x42 + IPPROTO_SATEXPAK = 0x40 + IPPROTO_SATMON = 0x45 + IPPROTO_SCCSP = 0x60 + IPPROTO_SCTP = 0x84 + IPPROTO_SDRP = 0x2a + IPPROTO_SEP = 0x21 + IPPROTO_SRPC = 0x5a + IPPROTO_ST = 0x7 + IPPROTO_SVMTP = 0x52 + IPPROTO_SWIPE = 0x35 + IPPROTO_TCF = 0x57 + IPPROTO_TCP = 0x6 + IPPROTO_TP = 0x1d + IPPROTO_TPXX = 0x27 + IPPROTO_TRUNK1 = 0x17 + IPPROTO_TRUNK2 = 0x18 + IPPROTO_TTP = 0x54 + IPPROTO_UDP = 0x11 + IPPROTO_VINES = 0x53 + IPPROTO_VISA = 0x46 + IPPROTO_VMTP = 0x51 + IPPROTO_WBEXPAK = 0x4f + IPPROTO_WBMON = 0x4e + IPPROTO_WSN = 0x4a + IPPROTO_XNET = 0xf + IPPROTO_XTP = 0x24 + IPV6_2292DSTOPTS = 0x17 + IPV6_2292HOPLIMIT = 0x14 + IPV6_2292HOPOPTS = 0x16 + IPV6_2292NEXTHOP = 0x15 + IPV6_2292PKTINFO = 0x13 + IPV6_2292PKTOPTIONS = 0x19 + IPV6_2292RTHDR = 0x18 + IPV6_3542DSTOPTS = 0x32 + IPV6_3542HOPLIMIT = 0x2f + IPV6_3542HOPOPTS = 0x31 + IPV6_3542NEXTHOP = 0x30 + IPV6_3542PKTINFO = 0x2e + IPV6_3542RTHDR = 0x33 + IPV6_ADDR_MC_FLAGS_PREFIX = 0x20 + IPV6_ADDR_MC_FLAGS_TRANSIENT = 0x10 + IPV6_ADDR_MC_FLAGS_UNICAST_BASED = 0x30 + IPV6_AUTOFLOWLABEL = 0x3b + IPV6_BINDV6ONLY = 0x1b + IPV6_BOUND_IF = 0x7d + IPV6_CHECKSUM = 0x1a + IPV6_DEFAULT_MULTICAST_HOPS = 0x1 + IPV6_DEFAULT_MULTICAST_LOOP = 0x1 + IPV6_DEFHLIM = 0x40 + IPV6_DONTFRAG = 0x3e + IPV6_DSTOPTS = 0x32 + IPV6_FAITH = 0x1d + IPV6_FLOWINFO_MASK = 0xffffff0f + IPV6_FLOWLABEL_MASK = 0xffff0f00 + IPV6_FLOW_ECN_MASK = 0x3000 + IPV6_FRAGTTL = 0x3c + IPV6_FW_ADD = 0x1e + IPV6_FW_DEL = 0x1f + IPV6_FW_FLUSH = 0x20 + IPV6_FW_GET = 0x22 + IPV6_FW_ZERO = 0x21 + IPV6_HLIMDEC = 0x1 + IPV6_HOPLIMIT = 0x2f + IPV6_HOPOPTS = 0x31 + IPV6_IPSEC_POLICY = 0x1c + IPV6_JOIN_GROUP = 0xc + IPV6_LEAVE_GROUP = 0xd + IPV6_MAXHLIM = 0xff + IPV6_MAXOPTHDR = 0x800 + IPV6_MAXPACKET = 0xffff + IPV6_MAX_GROUP_SRC_FILTER = 0x200 + IPV6_MAX_MEMBERSHIPS = 0xfff + IPV6_MAX_SOCK_SRC_FILTER = 0x80 + IPV6_MIN_MEMBERSHIPS = 0x1f + IPV6_MMTU = 0x500 + IPV6_MSFILTER = 0x4a + IPV6_MULTICAST_HOPS = 0xa + IPV6_MULTICAST_IF = 0x9 + IPV6_MULTICAST_LOOP = 0xb + IPV6_NEXTHOP = 0x30 + IPV6_PATHMTU = 0x2c + IPV6_PKTINFO = 0x2e + IPV6_PORTRANGE = 0xe + IPV6_PORTRANGE_DEFAULT = 0x0 + IPV6_PORTRANGE_HIGH = 0x1 + IPV6_PORTRANGE_LOW = 0x2 + IPV6_PREFER_TEMPADDR = 0x3f + IPV6_RECVDSTOPTS = 0x28 + IPV6_RECVHOPLIMIT = 0x25 + IPV6_RECVHOPOPTS = 0x27 + IPV6_RECVPATHMTU = 0x2b + IPV6_RECVPKTINFO = 0x3d + IPV6_RECVRTHDR = 0x26 + IPV6_RECVTCLASS = 0x23 + IPV6_RTHDR = 0x33 + IPV6_RTHDRDSTOPTS = 0x39 + IPV6_RTHDR_LOOSE = 0x0 + IPV6_RTHDR_STRICT = 0x1 + IPV6_RTHDR_TYPE_0 = 0x0 + IPV6_SOCKOPT_RESERVED1 = 0x3 + IPV6_TCLASS = 0x24 + IPV6_UNICAST_HOPS = 0x4 + IPV6_USE_MIN_MTU = 0x2a + IPV6_V6ONLY = 0x1b + IPV6_VERSION = 0x60 + IPV6_VERSION_MASK = 0xf0 + IP_ADD_MEMBERSHIP = 0xc + IP_ADD_SOURCE_MEMBERSHIP = 0x46 + IP_BLOCK_SOURCE = 0x48 + IP_BOUND_IF = 0x19 + IP_DEFAULT_MULTICAST_LOOP = 0x1 + IP_DEFAULT_MULTICAST_TTL = 0x1 + IP_DF = 0x4000 + IP_DONTFRAG = 0x1c + IP_DROP_MEMBERSHIP = 0xd + IP_DROP_SOURCE_MEMBERSHIP = 0x47 + IP_DUMMYNET_CONFIGURE = 0x3c + IP_DUMMYNET_DEL = 0x3d + IP_DUMMYNET_FLUSH = 0x3e + IP_DUMMYNET_GET = 0x40 + IP_FAITH = 0x16 + IP_FW_ADD = 0x28 + IP_FW_DEL = 0x29 + IP_FW_FLUSH = 0x2a + IP_FW_GET = 0x2c + IP_FW_RESETLOG = 0x2d + IP_FW_ZERO = 0x2b + IP_HDRINCL = 0x2 + IP_IPSEC_POLICY = 0x15 + IP_MAXPACKET = 0xffff + IP_MAX_GROUP_SRC_FILTER = 0x200 + IP_MAX_MEMBERSHIPS = 0xfff + IP_MAX_SOCK_MUTE_FILTER = 0x80 + IP_MAX_SOCK_SRC_FILTER = 0x80 + IP_MF = 0x2000 + IP_MIN_MEMBERSHIPS = 0x1f + IP_MSFILTER = 0x4a + IP_MSS = 0x240 + IP_MULTICAST_IF = 0x9 + IP_MULTICAST_IFINDEX = 0x42 + IP_MULTICAST_LOOP = 0xb + IP_MULTICAST_TTL = 0xa + IP_MULTICAST_VIF = 0xe + IP_NAT__XXX = 0x37 + IP_OFFMASK = 0x1fff + IP_OLD_FW_ADD = 0x32 + IP_OLD_FW_DEL = 0x33 + IP_OLD_FW_FLUSH = 0x34 + IP_OLD_FW_GET = 0x36 + IP_OLD_FW_RESETLOG = 0x38 + IP_OLD_FW_ZERO = 0x35 + IP_OPTIONS = 0x1 + IP_PKTINFO = 0x1a + IP_PORTRANGE = 0x13 + IP_PORTRANGE_DEFAULT = 0x0 + IP_PORTRANGE_HIGH = 0x1 + IP_PORTRANGE_LOW = 0x2 + IP_RECVDSTADDR = 0x7 + IP_RECVIF = 0x14 + IP_RECVOPTS = 0x5 + IP_RECVPKTINFO = 0x1a + IP_RECVRETOPTS = 0x6 + IP_RECVTOS = 0x1b + IP_RECVTTL = 0x18 + IP_RETOPTS = 0x8 + IP_RF = 0x8000 + IP_RSVP_OFF = 0x10 + IP_RSVP_ON = 0xf + IP_RSVP_VIF_OFF = 0x12 + IP_RSVP_VIF_ON = 0x11 + IP_STRIPHDR = 0x17 + IP_TOS = 0x3 + IP_TRAFFIC_MGT_BACKGROUND = 0x41 + IP_TTL = 0x4 + IP_UNBLOCK_SOURCE = 0x49 + ISIG = 0x80 + ISTRIP = 0x20 + IUTF8 = 0x4000 + IXANY = 0x800 + IXOFF = 0x400 + IXON = 0x200 + KERN_HOSTNAME = 0xa + KERN_OSRELEASE = 0x2 + KERN_OSTYPE = 0x1 + KERN_VERSION = 0x4 + LOCAL_PEERCRED = 0x1 + LOCAL_PEEREPID = 0x3 + LOCAL_PEEREUUID = 0x5 + LOCAL_PEERPID = 0x2 + LOCAL_PEERTOKEN = 0x6 + LOCAL_PEERUUID = 0x4 + LOCK_EX = 0x2 + LOCK_NB = 0x4 + LOCK_SH = 0x1 + LOCK_UN = 0x8 + MADV_CAN_REUSE = 0x9 + MADV_DONTNEED = 0x4 + MADV_FREE = 0x5 + MADV_FREE_REUSABLE = 0x7 + MADV_FREE_REUSE = 0x8 + MADV_NORMAL = 0x0 + MADV_PAGEOUT = 0xa + MADV_RANDOM = 0x1 + MADV_SEQUENTIAL = 0x2 + MADV_WILLNEED = 0x3 + MADV_ZERO_WIRED_PAGES = 0x6 + MAP_32BIT = 0x8000 + MAP_ANON = 0x1000 + MAP_ANONYMOUS = 0x1000 + MAP_COPY = 0x2 + MAP_FILE = 0x0 + MAP_FIXED = 0x10 + MAP_HASSEMAPHORE = 0x200 + MAP_JIT = 0x800 + MAP_NOCACHE = 0x400 + MAP_NOEXTEND = 0x100 + MAP_NORESERVE = 0x40 + MAP_PRIVATE = 0x2 + MAP_RENAME = 0x20 + MAP_RESERVED0080 = 0x80 + MAP_RESILIENT_CODESIGN = 0x2000 + MAP_RESILIENT_MEDIA = 0x4000 + MAP_SHARED = 0x1 + MAP_TRANSLATED_ALLOW_EXECUTE = 0x20000 + MAP_UNIX03 = 0x40000 + MCAST_BLOCK_SOURCE = 0x54 + MCAST_EXCLUDE = 0x2 + MCAST_INCLUDE = 0x1 + MCAST_JOIN_GROUP = 0x50 + MCAST_JOIN_SOURCE_GROUP = 0x52 + MCAST_LEAVE_GROUP = 0x51 + MCAST_LEAVE_SOURCE_GROUP = 0x53 + MCAST_UNBLOCK_SOURCE = 0x55 + MCAST_UNDEFINED = 0x0 + MCL_CURRENT = 0x1 + MCL_FUTURE = 0x2 + MNT_ASYNC = 0x40 + MNT_AUTOMOUNTED = 0x400000 + MNT_CMDFLAGS = 0xf0000 + MNT_CPROTECT = 0x80 + MNT_DEFWRITE = 0x2000000 + MNT_DONTBROWSE = 0x100000 + MNT_DOVOLFS = 0x8000 + MNT_DWAIT = 0x4 + MNT_EXPORTED = 0x100 + MNT_EXT_ROOT_DATA_VOL = 0x1 + MNT_FORCE = 0x80000 + MNT_IGNORE_OWNERSHIP = 0x200000 + MNT_JOURNALED = 0x800000 + MNT_LOCAL = 0x1000 + MNT_MULTILABEL = 0x4000000 + MNT_NOATIME = 0x10000000 + MNT_NOBLOCK = 0x20000 + MNT_NODEV = 0x10 + MNT_NOEXEC = 0x4 + MNT_NOSUID = 0x8 + MNT_NOUSERXATTR = 0x1000000 + MNT_NOWAIT = 0x2 + MNT_QUARANTINE = 0x400 + MNT_QUOTA = 0x2000 + MNT_RDONLY = 0x1 + MNT_RELOAD = 0x40000 + MNT_REMOVABLE = 0x200 + MNT_ROOTFS = 0x4000 + MNT_SNAPSHOT = 0x40000000 + MNT_STRICTATIME = 0x80000000 + MNT_SYNCHRONOUS = 0x2 + MNT_UNION = 0x20 + MNT_UNKNOWNPERMISSIONS = 0x200000 + MNT_UPDATE = 0x10000 + MNT_VISFLAGMASK = 0xd7f0f7ff + MNT_WAIT = 0x1 + MSG_CTRUNC = 0x20 + MSG_DONTROUTE = 0x4 + MSG_DONTWAIT = 0x80 + MSG_EOF = 0x100 + MSG_EOR = 0x8 + MSG_FLUSH = 0x400 + MSG_HAVEMORE = 0x2000 + MSG_HOLD = 0x800 + MSG_NEEDSA = 0x10000 + MSG_NOSIGNAL = 0x80000 + MSG_OOB = 0x1 + MSG_PEEK = 0x2 + MSG_RCVMORE = 0x4000 + MSG_SEND = 0x1000 + MSG_TRUNC = 0x10 + MSG_WAITALL = 0x40 + MSG_WAITSTREAM = 0x200 + MS_ASYNC = 0x1 + MS_DEACTIVATE = 0x8 + MS_INVALIDATE = 0x2 + MS_KILLPAGES = 0x4 + MS_SYNC = 0x10 + NAME_MAX = 0xff + NET_RT_DUMP = 0x1 + NET_RT_DUMP2 = 0x7 + NET_RT_FLAGS = 0x2 + NET_RT_FLAGS_PRIV = 0xa + NET_RT_IFLIST = 0x3 + NET_RT_IFLIST2 = 0x6 + NET_RT_MAXID = 0xb + NET_RT_STAT = 0x4 + NET_RT_TRASH = 0x5 + NFDBITS = 0x20 + NL0 = 0x0 + NL1 = 0x100 + NL2 = 0x200 + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 + NOKERNINFO = 0x2000000 + NOTE_ABSOLUTE = 0x8 + NOTE_ATTRIB = 0x8 + NOTE_BACKGROUND = 0x40 + NOTE_CHILD = 0x4 + NOTE_CRITICAL = 0x20 + NOTE_DELETE = 0x1 + NOTE_EXEC = 0x20000000 + NOTE_EXIT = 0x80000000 + NOTE_EXITSTATUS = 0x4000000 + NOTE_EXIT_CSERROR = 0x40000 + NOTE_EXIT_DECRYPTFAIL = 0x10000 + NOTE_EXIT_DETAIL = 0x2000000 + NOTE_EXIT_DETAIL_MASK = 0x70000 + NOTE_EXIT_MEMORY = 0x20000 + NOTE_EXIT_REPARENTED = 0x80000 + NOTE_EXTEND = 0x4 + NOTE_FFAND = 0x40000000 + NOTE_FFCOPY = 0xc0000000 + NOTE_FFCTRLMASK = 0xc0000000 + NOTE_FFLAGSMASK = 0xffffff + NOTE_FFNOP = 0x0 + NOTE_FFOR = 0x80000000 + NOTE_FORK = 0x40000000 + NOTE_FUNLOCK = 0x100 + NOTE_LEEWAY = 0x10 + NOTE_LINK = 0x10 + NOTE_LOWAT = 0x1 + NOTE_MACHTIME = 0x100 + NOTE_MACH_CONTINUOUS_TIME = 0x80 + NOTE_NONE = 0x80 + NOTE_NSECONDS = 0x4 + NOTE_OOB = 0x2 + NOTE_PCTRLMASK = -0x100000 + NOTE_PDATAMASK = 0xfffff + NOTE_REAP = 0x10000000 + NOTE_RENAME = 0x20 + NOTE_REVOKE = 0x40 + NOTE_SECONDS = 0x1 + NOTE_SIGNAL = 0x8000000 + NOTE_TRACK = 0x1 + NOTE_TRACKERR = 0x2 + NOTE_TRIGGER = 0x1000000 + NOTE_USECONDS = 0x2 + NOTE_VM_ERROR = 0x10000000 + NOTE_VM_PRESSURE = 0x80000000 + NOTE_VM_PRESSURE_SUDDEN_TERMINATE = 0x20000000 + NOTE_VM_PRESSURE_TERMINATE = 0x40000000 + NOTE_WRITE = 0x2 + OCRNL = 0x10 + OFDEL = 0x20000 + OFILL = 0x80 + ONLCR = 0x2 + ONLRET = 0x40 + ONOCR = 0x20 + ONOEOT = 0x8 + OPOST = 0x1 + OXTABS = 0x4 + O_ACCMODE = 0x3 + O_ALERT = 0x20000000 + O_APPEND = 0x8 + O_ASYNC = 0x40 + O_CLOEXEC = 0x1000000 + O_CREAT = 0x200 + O_DIRECTORY = 0x100000 + O_DP_GETRAWENCRYPTED = 0x1 + O_DP_GETRAWUNENCRYPTED = 0x2 + O_DSYNC = 0x400000 + O_EVTONLY = 0x8000 + O_EXCL = 0x800 + O_EXLOCK = 0x20 + O_FSYNC = 0x80 + O_NDELAY = 0x4 + O_NOCTTY = 0x20000 + O_NOFOLLOW = 0x100 + O_NOFOLLOW_ANY = 0x20000000 + O_NONBLOCK = 0x4 + O_POPUP = 0x80000000 + O_RDONLY = 0x0 + O_RDWR = 0x2 + O_SHLOCK = 0x10 + O_SYMLINK = 0x200000 + O_SYNC = 0x80 + O_TRUNC = 0x400 + O_WRONLY = 0x1 + PARENB = 0x1000 + PARMRK = 0x8 + PARODD = 0x2000 + PENDIN = 0x20000000 + PRIO_PGRP = 0x1 + PRIO_PROCESS = 0x0 + PRIO_USER = 0x2 + PROT_EXEC = 0x4 + PROT_NONE = 0x0 + PROT_READ = 0x1 + PROT_WRITE = 0x2 + PT_ATTACH = 0xa + PT_ATTACHEXC = 0xe + PT_CONTINUE = 0x7 + PT_DENY_ATTACH = 0x1f + PT_DETACH = 0xb + PT_FIRSTMACH = 0x20 + PT_FORCEQUOTA = 0x1e + PT_KILL = 0x8 + PT_READ_D = 0x2 + PT_READ_I = 0x1 + PT_READ_U = 0x3 + PT_SIGEXC = 0xc + PT_STEP = 0x9 + PT_THUPDATE = 0xd + PT_TRACE_ME = 0x0 + PT_WRITE_D = 0x5 + PT_WRITE_I = 0x4 + PT_WRITE_U = 0x6 + RLIMIT_AS = 0x5 + RLIMIT_CORE = 0x4 + RLIMIT_CPU = 0x0 + RLIMIT_CPU_USAGE_MONITOR = 0x2 + RLIMIT_DATA = 0x2 + RLIMIT_FSIZE = 0x1 + RLIMIT_MEMLOCK = 0x6 + RLIMIT_NOFILE = 0x8 + RLIMIT_NPROC = 0x7 + RLIMIT_RSS = 0x5 + RLIMIT_STACK = 0x3 + RLIM_INFINITY = 0x7fffffffffffffff + RTAX_AUTHOR = 0x6 + RTAX_BRD = 0x7 + RTAX_DST = 0x0 + RTAX_GATEWAY = 0x1 + RTAX_GENMASK = 0x3 + RTAX_IFA = 0x5 + RTAX_IFP = 0x4 + RTAX_MAX = 0x8 + RTAX_NETMASK = 0x2 + RTA_AUTHOR = 0x40 + RTA_BRD = 0x80 + RTA_DST = 0x1 + RTA_GATEWAY = 0x2 + RTA_GENMASK = 0x8 + RTA_IFA = 0x20 + RTA_IFP = 0x10 + RTA_NETMASK = 0x4 + RTF_BLACKHOLE = 0x1000 + RTF_BROADCAST = 0x400000 + RTF_CLONING = 0x100 + RTF_CONDEMNED = 0x2000000 + RTF_DEAD = 0x20000000 + RTF_DELCLONE = 0x80 + RTF_DONE = 0x40 + RTF_DYNAMIC = 0x10 + RTF_GATEWAY = 0x2 + RTF_GLOBAL = 0x40000000 + RTF_HOST = 0x4 + RTF_IFREF = 0x4000000 + RTF_IFSCOPE = 0x1000000 + RTF_LLDATA = 0x400 + RTF_LLINFO = 0x400 + RTF_LOCAL = 0x200000 + RTF_MODIFIED = 0x20 + RTF_MULTICAST = 0x800000 + RTF_NOIFREF = 0x2000 + RTF_PINNED = 0x100000 + RTF_PRCLONING = 0x10000 + RTF_PROTO1 = 0x8000 + RTF_PROTO2 = 0x4000 + RTF_PROTO3 = 0x40000 + RTF_PROXY = 0x8000000 + RTF_REJECT = 0x8 + RTF_ROUTER = 0x10000000 + RTF_STATIC = 0x800 + RTF_UP = 0x1 + RTF_WASCLONED = 0x20000 + RTF_XRESOLVE = 0x200 + RTM_ADD = 0x1 + RTM_CHANGE = 0x3 + RTM_DELADDR = 0xd + RTM_DELETE = 0x2 + RTM_DELMADDR = 0x10 + RTM_GET = 0x4 + RTM_GET2 = 0x14 + RTM_IFINFO = 0xe + RTM_IFINFO2 = 0x12 + RTM_LOCK = 0x8 + RTM_LOSING = 0x5 + RTM_MISS = 0x7 + RTM_NEWADDR = 0xc + RTM_NEWMADDR = 0xf + RTM_NEWMADDR2 = 0x13 + RTM_OLDADD = 0x9 + RTM_OLDDEL = 0xa + RTM_REDIRECT = 0x6 + RTM_RESOLVE = 0xb + RTM_RTTUNIT = 0xf4240 + RTM_VERSION = 0x5 + RTV_EXPIRE = 0x4 + RTV_HOPCOUNT = 0x2 + RTV_MTU = 0x1 + RTV_RPIPE = 0x8 + RTV_RTT = 0x40 + RTV_RTTVAR = 0x80 + RTV_SPIPE = 0x10 + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 + SCM_TIMESTAMP_MONOTONIC = 0x4 + SEEK_CUR = 0x1 + SEEK_DATA = 0x4 + SEEK_END = 0x2 + SEEK_HOLE = 0x3 + SEEK_SET = 0x0 + SHUT_RD = 0x0 + SHUT_RDWR = 0x2 + SHUT_WR = 0x1 + SIOCADDMULTI = 0x80206931 + SIOCAIFADDR = 0x8040691a + SIOCARPIPLL = 0xc0206928 + SIOCATMARK = 0x40047307 + SIOCAUTOADDR = 0xc0206926 + SIOCAUTONETMASK = 0x80206927 + SIOCDELMULTI = 0x80206932 + SIOCDIFADDR = 0x80206919 + SIOCDIFPHYADDR = 0x80206941 + SIOCGDRVSPEC = 0xc028697b + SIOCGETVLAN = 0xc020697f + SIOCGHIWAT = 0x40047301 + SIOCGIF6LOWPAN = 0xc02069c5 + SIOCGIFADDR = 0xc0206921 + SIOCGIFALTMTU = 0xc0206948 + SIOCGIFASYNCMAP = 0xc020697c + SIOCGIFBOND = 0xc0206947 + SIOCGIFBRDADDR = 0xc0206923 + SIOCGIFCAP = 0xc020695b + SIOCGIFCONF = 0xc00c6924 + SIOCGIFDEVMTU = 0xc0206944 + SIOCGIFDSTADDR = 0xc0206922 + SIOCGIFFLAGS = 0xc0206911 + SIOCGIFFUNCTIONALTYPE = 0xc02069ad + SIOCGIFGENERIC = 0xc020693a + SIOCGIFKPI = 0xc0206987 + SIOCGIFMAC = 0xc0206982 + SIOCGIFMEDIA = 0xc02c6938 + SIOCGIFMETRIC = 0xc0206917 + SIOCGIFMTU = 0xc0206933 + SIOCGIFNETMASK = 0xc0206925 + SIOCGIFPDSTADDR = 0xc0206940 + SIOCGIFPHYS = 0xc0206935 + SIOCGIFPSRCADDR = 0xc020693f + SIOCGIFSTATUS = 0xc331693d + SIOCGIFVLAN = 0xc020697f + SIOCGIFWAKEFLAGS = 0xc0206988 + SIOCGIFXMEDIA = 0xc02c6948 + SIOCGLOWAT = 0x40047303 + SIOCGPGRP = 0x40047309 + SIOCIFCREATE = 0xc0206978 + SIOCIFCREATE2 = 0xc020697a + SIOCIFDESTROY = 0x80206979 + SIOCIFGCLONERS = 0xc0106981 + SIOCRSLVMULTI = 0xc010693b + SIOCSDRVSPEC = 0x8028697b + SIOCSETVLAN = 0x8020697e + SIOCSHIWAT = 0x80047300 + SIOCSIF6LOWPAN = 0x802069c4 + SIOCSIFADDR = 0x8020690c + SIOCSIFALTMTU = 0x80206945 + SIOCSIFASYNCMAP = 0x8020697d + SIOCSIFBOND = 0x80206946 + SIOCSIFBRDADDR = 0x80206913 + SIOCSIFCAP = 0x8020695a + SIOCSIFDSTADDR = 0x8020690e + SIOCSIFFLAGS = 0x80206910 + SIOCSIFGENERIC = 0x80206939 + SIOCSIFKPI = 0x80206986 + SIOCSIFLLADDR = 0x8020693c + SIOCSIFMAC = 0x80206983 + SIOCSIFMEDIA = 0xc0206937 + SIOCSIFMETRIC = 0x80206918 + SIOCSIFMTU = 0x80206934 + SIOCSIFNETMASK = 0x80206916 + SIOCSIFPHYADDR = 0x8040693e + SIOCSIFPHYS = 0x80206936 + SIOCSIFVLAN = 0x8020697e + SIOCSLOWAT = 0x80047302 + SIOCSPGRP = 0x80047308 + SOCK_DGRAM = 0x2 + SOCK_MAXADDRLEN = 0xff + SOCK_RAW = 0x3 + SOCK_RDM = 0x4 + SOCK_SEQPACKET = 0x5 + SOCK_STREAM = 0x1 + SOL_LOCAL = 0x0 + SOL_SOCKET = 0xffff + SOMAXCONN = 0x80 + SO_ACCEPTCONN = 0x2 + SO_BROADCAST = 0x20 + SO_DEBUG = 0x1 + SO_DONTROUTE = 0x10 + SO_DONTTRUNC = 0x2000 + SO_ERROR = 0x1007 + SO_KEEPALIVE = 0x8 + SO_LABEL = 0x1010 + SO_LINGER = 0x80 + SO_LINGER_SEC = 0x1080 + SO_NETSVC_MARKING_LEVEL = 0x1119 + SO_NET_SERVICE_TYPE = 0x1116 + SO_NKE = 0x1021 + SO_NOADDRERR = 0x1023 + SO_NOSIGPIPE = 0x1022 + SO_NOTIFYCONFLICT = 0x1026 + SO_NP_EXTENSIONS = 0x1083 + SO_NREAD = 0x1020 + SO_NUMRCVPKT = 0x1112 + SO_NWRITE = 0x1024 + SO_OOBINLINE = 0x100 + SO_PEERLABEL = 0x1011 + SO_RANDOMPORT = 0x1082 + SO_RCVBUF = 0x1002 + SO_RCVLOWAT = 0x1004 + SO_RCVTIMEO = 0x1006 + SO_REUSEADDR = 0x4 + SO_REUSEPORT = 0x200 + SO_REUSESHAREUID = 0x1025 + SO_SNDBUF = 0x1001 + SO_SNDLOWAT = 0x1003 + SO_SNDTIMEO = 0x1005 + SO_TIMESTAMP = 0x400 + SO_TIMESTAMP_MONOTONIC = 0x800 + SO_TRACKER_ATTRIBUTE_FLAGS_APP_APPROVED = 0x1 + SO_TRACKER_ATTRIBUTE_FLAGS_DOMAIN_SHORT = 0x4 + SO_TRACKER_ATTRIBUTE_FLAGS_TRACKER = 0x2 + SO_TRACKER_TRANSPARENCY_VERSION = 0x3 + SO_TYPE = 0x1008 + SO_UPCALLCLOSEWAIT = 0x1027 + SO_USELOOPBACK = 0x40 + SO_WANTMORE = 0x4000 + SO_WANTOOBFLAG = 0x8000 + S_IEXEC = 0x40 + S_IFBLK = 0x6000 + S_IFCHR = 0x2000 + S_IFDIR = 0x4000 + S_IFIFO = 0x1000 + S_IFLNK = 0xa000 + S_IFMT = 0xf000 + S_IFREG = 0x8000 + S_IFSOCK = 0xc000 + S_IFWHT = 0xe000 + S_IREAD = 0x100 + S_IRGRP = 0x20 + S_IROTH = 0x4 + S_IRUSR = 0x100 + S_IRWXG = 0x38 + S_IRWXO = 0x7 + S_IRWXU = 0x1c0 + S_ISGID = 0x400 + S_ISTXT = 0x200 + S_ISUID = 0x800 + S_ISVTX = 0x200 + S_IWGRP = 0x10 + S_IWOTH = 0x2 + S_IWRITE = 0x80 + S_IWUSR = 0x80 + S_IXGRP = 0x8 + S_IXOTH = 0x1 + S_IXUSR = 0x40 + TAB0 = 0x0 + TAB1 = 0x400 + TAB2 = 0x800 + TAB3 = 0x4 + TABDLY = 0xc04 + TCIFLUSH = 0x1 + TCIOFF = 0x3 + TCIOFLUSH = 0x3 + TCION = 0x4 + TCOFLUSH = 0x2 + TCOOFF = 0x1 + TCOON = 0x2 + TCPOPT_CC = 0xb + TCPOPT_CCECHO = 0xd + TCPOPT_CCNEW = 0xc + TCPOPT_EOL = 0x0 + TCPOPT_FASTOPEN = 0x22 + TCPOPT_MAXSEG = 0x2 + TCPOPT_NOP = 0x1 + TCPOPT_SACK = 0x5 + TCPOPT_SACK_HDR = 0x1010500 + TCPOPT_SACK_PERMITTED = 0x4 + TCPOPT_SACK_PERMIT_HDR = 0x1010402 + TCPOPT_SIGNATURE = 0x13 + TCPOPT_TIMESTAMP = 0x8 + TCPOPT_TSTAMP_HDR = 0x101080a + TCPOPT_WINDOW = 0x3 + TCP_CONNECTIONTIMEOUT = 0x20 + TCP_CONNECTION_INFO = 0x106 + TCP_ENABLE_ECN = 0x104 + TCP_FASTOPEN = 0x105 + TCP_KEEPALIVE = 0x10 + TCP_KEEPCNT = 0x102 + TCP_KEEPINTVL = 0x101 + TCP_MAXHLEN = 0x3c + TCP_MAXOLEN = 0x28 + TCP_MAXSEG = 0x2 + TCP_MAXWIN = 0xffff + TCP_MAX_SACK = 0x4 + TCP_MAX_WINSHIFT = 0xe + TCP_MINMSS = 0xd8 + TCP_MSS = 0x200 + TCP_NODELAY = 0x1 + TCP_NOOPT = 0x8 + TCP_NOPUSH = 0x4 + TCP_NOTSENT_LOWAT = 0x201 + TCP_RXT_CONNDROPTIME = 0x80 + TCP_RXT_FINDROP = 0x100 + TCP_SENDMOREACKS = 0x103 + TCSAFLUSH = 0x2 + TIOCCBRK = 0x2000747a + TIOCCDTR = 0x20007478 + TIOCCONS = 0x80047462 + TIOCDCDTIMESTAMP = 0x40107458 + TIOCDRAIN = 0x2000745e + TIOCDSIMICROCODE = 0x20007455 + TIOCEXCL = 0x2000740d + TIOCEXT = 0x80047460 + TIOCFLUSH = 0x80047410 + TIOCGDRAINWAIT = 0x40047456 + TIOCGETA = 0x40487413 + TIOCGETD = 0x4004741a + TIOCGPGRP = 0x40047477 + TIOCGWINSZ = 0x40087468 + TIOCIXOFF = 0x20007480 + TIOCIXON = 0x20007481 + TIOCMBIC = 0x8004746b + TIOCMBIS = 0x8004746c + TIOCMGDTRWAIT = 0x4004745a + TIOCMGET = 0x4004746a + TIOCMODG = 0x40047403 + TIOCMODS = 0x80047404 + TIOCMSDTRWAIT = 0x8004745b + TIOCMSET = 0x8004746d + TIOCM_CAR = 0x40 + TIOCM_CD = 0x40 + TIOCM_CTS = 0x20 + TIOCM_DSR = 0x100 + TIOCM_DTR = 0x2 + TIOCM_LE = 0x1 + TIOCM_RI = 0x80 + TIOCM_RNG = 0x80 + TIOCM_RTS = 0x4 + TIOCM_SR = 0x10 + TIOCM_ST = 0x8 + TIOCNOTTY = 0x20007471 + TIOCNXCL = 0x2000740e + TIOCOUTQ = 0x40047473 + TIOCPKT = 0x80047470 + TIOCPKT_DATA = 0x0 + TIOCPKT_DOSTOP = 0x20 + TIOCPKT_FLUSHREAD = 0x1 + TIOCPKT_FLUSHWRITE = 0x2 + TIOCPKT_IOCTL = 0x40 + TIOCPKT_NOSTOP = 0x10 + TIOCPKT_START = 0x8 + TIOCPKT_STOP = 0x4 + TIOCPTYGNAME = 0x40807453 + TIOCPTYGRANT = 0x20007454 + TIOCPTYUNLK = 0x20007452 + TIOCREMOTE = 0x80047469 + TIOCSBRK = 0x2000747b + TIOCSCONS = 0x20007463 + TIOCSCTTY = 0x20007461 + TIOCSDRAINWAIT = 0x80047457 + TIOCSDTR = 0x20007479 + TIOCSETA = 0x80487414 + TIOCSETAF = 0x80487416 + TIOCSETAW = 0x80487415 + TIOCSETD = 0x8004741b + TIOCSIG = 0x2000745f + TIOCSPGRP = 0x80047476 + TIOCSTART = 0x2000746e + TIOCSTAT = 0x20007465 + TIOCSTI = 0x80017472 + TIOCSTOP = 0x2000746f + TIOCSWINSZ = 0x80087467 + TIOCTIMESTAMP = 0x40107459 + TIOCUCNTL = 0x80047466 + TOSTOP = 0x400000 + VDISCARD = 0xf + VDSUSP = 0xb + VEOF = 0x0 + VEOL = 0x1 + VEOL2 = 0x2 + VERASE = 0x3 + VINTR = 0x8 + VKILL = 0x5 + VLNEXT = 0xe + VMADDR_CID_ANY = 0xffffffff + VMADDR_CID_HOST = 0x2 + VMADDR_CID_HYPERVISOR = 0x0 + VMADDR_CID_RESERVED = 0x1 + VMADDR_PORT_ANY = 0xffffffff + VMIN = 0x10 + VM_LOADAVG = 0x2 + VM_MACHFACTOR = 0x4 + VM_MAXID = 0x6 + VM_METER = 0x1 + VM_SWAPUSAGE = 0x5 + VQUIT = 0x9 + VREPRINT = 0x6 + VSTART = 0xc + VSTATUS = 0x12 + VSTOP = 0xd + VSUSP = 0xa + VT0 = 0x0 + VT1 = 0x10000 + VTDLY = 0x10000 + VTIME = 0x11 + VWERASE = 0x4 + WCONTINUED = 0x10 + WCOREFLAG = 0x80 + WEXITED = 0x4 + WNOHANG = 0x1 + WNOWAIT = 0x20 + WORDSIZE = 0x40 + WSTOPPED = 0x8 + WUNTRACED = 0x2 + XATTR_CREATE = 0x2 + XATTR_NODEFAULT = 0x10 + XATTR_NOFOLLOW = 0x1 + XATTR_NOSECURITY = 0x8 + XATTR_REPLACE = 0x4 + XATTR_SHOWCOMPRESSION = 0x20 ) // Errors diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go index 31009d7f05..e36f5178d6 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go @@ -12,1556 +12,1582 @@ package unix import "syscall" const ( - AF_APPLETALK = 0x10 - AF_CCITT = 0xa - AF_CHAOS = 0x5 - AF_CNT = 0x15 - AF_COIP = 0x14 - AF_DATAKIT = 0x9 - AF_DECnet = 0xc - AF_DLI = 0xd - AF_E164 = 0x1c - AF_ECMA = 0x8 - AF_HYLINK = 0xf - AF_IEEE80211 = 0x25 - AF_IMPLINK = 0x3 - AF_INET = 0x2 - AF_INET6 = 0x1e - AF_IPX = 0x17 - AF_ISDN = 0x1c - AF_ISO = 0x7 - AF_LAT = 0xe - AF_LINK = 0x12 - AF_LOCAL = 0x1 - AF_MAX = 0x29 - AF_NATM = 0x1f - AF_NDRV = 0x1b - AF_NETBIOS = 0x21 - AF_NS = 0x6 - AF_OSI = 0x7 - AF_PPP = 0x22 - AF_PUP = 0x4 - AF_RESERVED_36 = 0x24 - AF_ROUTE = 0x11 - AF_SIP = 0x18 - AF_SNA = 0xb - AF_SYSTEM = 0x20 - AF_SYS_CONTROL = 0x2 - AF_UNIX = 0x1 - AF_UNSPEC = 0x0 - AF_UTUN = 0x26 - AF_VSOCK = 0x28 - ALTWERASE = 0x200 - ATTR_BIT_MAP_COUNT = 0x5 - ATTR_CMN_ACCESSMASK = 0x20000 - ATTR_CMN_ACCTIME = 0x1000 - ATTR_CMN_ADDEDTIME = 0x10000000 - ATTR_CMN_BKUPTIME = 0x2000 - ATTR_CMN_CHGTIME = 0x800 - ATTR_CMN_CRTIME = 0x200 - ATTR_CMN_DATA_PROTECT_FLAGS = 0x40000000 - ATTR_CMN_DEVID = 0x2 - ATTR_CMN_DOCUMENT_ID = 0x100000 - ATTR_CMN_ERROR = 0x20000000 - ATTR_CMN_EXTENDED_SECURITY = 0x400000 - ATTR_CMN_FILEID = 0x2000000 - ATTR_CMN_FLAGS = 0x40000 - ATTR_CMN_FNDRINFO = 0x4000 - ATTR_CMN_FSID = 0x4 - ATTR_CMN_FULLPATH = 0x8000000 - ATTR_CMN_GEN_COUNT = 0x80000 - ATTR_CMN_GRPID = 0x10000 - ATTR_CMN_GRPUUID = 0x1000000 - ATTR_CMN_MODTIME = 0x400 - ATTR_CMN_NAME = 0x1 - ATTR_CMN_NAMEDATTRCOUNT = 0x80000 - ATTR_CMN_NAMEDATTRLIST = 0x100000 - ATTR_CMN_OBJID = 0x20 - ATTR_CMN_OBJPERMANENTID = 0x40 - ATTR_CMN_OBJTAG = 0x10 - ATTR_CMN_OBJTYPE = 0x8 - ATTR_CMN_OWNERID = 0x8000 - ATTR_CMN_PARENTID = 0x4000000 - ATTR_CMN_PAROBJID = 0x80 - ATTR_CMN_RETURNED_ATTRS = 0x80000000 - ATTR_CMN_SCRIPT = 0x100 - ATTR_CMN_SETMASK = 0x51c7ff00 - ATTR_CMN_USERACCESS = 0x200000 - ATTR_CMN_UUID = 0x800000 - ATTR_CMN_VALIDMASK = 0xffffffff - ATTR_CMN_VOLSETMASK = 0x6700 - ATTR_FILE_ALLOCSIZE = 0x4 - ATTR_FILE_CLUMPSIZE = 0x10 - ATTR_FILE_DATAALLOCSIZE = 0x400 - ATTR_FILE_DATAEXTENTS = 0x800 - ATTR_FILE_DATALENGTH = 0x200 - ATTR_FILE_DEVTYPE = 0x20 - ATTR_FILE_FILETYPE = 0x40 - ATTR_FILE_FORKCOUNT = 0x80 - ATTR_FILE_FORKLIST = 0x100 - ATTR_FILE_IOBLOCKSIZE = 0x8 - ATTR_FILE_LINKCOUNT = 0x1 - ATTR_FILE_RSRCALLOCSIZE = 0x2000 - ATTR_FILE_RSRCEXTENTS = 0x4000 - ATTR_FILE_RSRCLENGTH = 0x1000 - ATTR_FILE_SETMASK = 0x20 - ATTR_FILE_TOTALSIZE = 0x2 - ATTR_FILE_VALIDMASK = 0x37ff - ATTR_VOL_ALLOCATIONCLUMP = 0x40 - ATTR_VOL_ATTRIBUTES = 0x40000000 - ATTR_VOL_CAPABILITIES = 0x20000 - ATTR_VOL_DIRCOUNT = 0x400 - ATTR_VOL_ENCODINGSUSED = 0x10000 - ATTR_VOL_FILECOUNT = 0x200 - ATTR_VOL_FSTYPE = 0x1 - ATTR_VOL_INFO = 0x80000000 - ATTR_VOL_IOBLOCKSIZE = 0x80 - ATTR_VOL_MAXOBJCOUNT = 0x800 - ATTR_VOL_MINALLOCATION = 0x20 - ATTR_VOL_MOUNTEDDEVICE = 0x8000 - ATTR_VOL_MOUNTFLAGS = 0x4000 - ATTR_VOL_MOUNTPOINT = 0x1000 - ATTR_VOL_NAME = 0x2000 - ATTR_VOL_OBJCOUNT = 0x100 - ATTR_VOL_QUOTA_SIZE = 0x10000000 - ATTR_VOL_RESERVED_SIZE = 0x20000000 - ATTR_VOL_SETMASK = 0x80002000 - ATTR_VOL_SIGNATURE = 0x2 - ATTR_VOL_SIZE = 0x4 - ATTR_VOL_SPACEAVAIL = 0x10 - ATTR_VOL_SPACEFREE = 0x8 - ATTR_VOL_UUID = 0x40000 - ATTR_VOL_VALIDMASK = 0xf007ffff - B0 = 0x0 - B110 = 0x6e - B115200 = 0x1c200 - B1200 = 0x4b0 - B134 = 0x86 - B14400 = 0x3840 - B150 = 0x96 - B1800 = 0x708 - B19200 = 0x4b00 - B200 = 0xc8 - B230400 = 0x38400 - B2400 = 0x960 - B28800 = 0x7080 - B300 = 0x12c - B38400 = 0x9600 - B4800 = 0x12c0 - B50 = 0x32 - B57600 = 0xe100 - B600 = 0x258 - B7200 = 0x1c20 - B75 = 0x4b - B76800 = 0x12c00 - B9600 = 0x2580 - BIOCFLUSH = 0x20004268 - BIOCGBLEN = 0x40044266 - BIOCGDLT = 0x4004426a - BIOCGDLTLIST = 0xc00c4279 - BIOCGETIF = 0x4020426b - BIOCGHDRCMPLT = 0x40044274 - BIOCGRSIG = 0x40044272 - BIOCGRTIMEOUT = 0x4010426e - BIOCGSEESENT = 0x40044276 - BIOCGSTATS = 0x4008426f - BIOCIMMEDIATE = 0x80044270 - BIOCPROMISC = 0x20004269 - BIOCSBLEN = 0xc0044266 - BIOCSDLT = 0x80044278 - BIOCSETF = 0x80104267 - BIOCSETFNR = 0x8010427e - BIOCSETIF = 0x8020426c - BIOCSHDRCMPLT = 0x80044275 - BIOCSRSIG = 0x80044273 - BIOCSRTIMEOUT = 0x8010426d - BIOCSSEESENT = 0x80044277 - BIOCVERSION = 0x40044271 - BPF_A = 0x10 - BPF_ABS = 0x20 - BPF_ADD = 0x0 - BPF_ALIGNMENT = 0x4 - BPF_ALU = 0x4 - BPF_AND = 0x50 - BPF_B = 0x10 - BPF_DIV = 0x30 - BPF_H = 0x8 - BPF_IMM = 0x0 - BPF_IND = 0x40 - BPF_JA = 0x0 - BPF_JEQ = 0x10 - BPF_JGE = 0x30 - BPF_JGT = 0x20 - BPF_JMP = 0x5 - BPF_JSET = 0x40 - BPF_K = 0x0 - BPF_LD = 0x0 - BPF_LDX = 0x1 - BPF_LEN = 0x80 - BPF_LSH = 0x60 - BPF_MAJOR_VERSION = 0x1 - BPF_MAXBUFSIZE = 0x80000 - BPF_MAXINSNS = 0x200 - BPF_MEM = 0x60 - BPF_MEMWORDS = 0x10 - BPF_MINBUFSIZE = 0x20 - BPF_MINOR_VERSION = 0x1 - BPF_MISC = 0x7 - BPF_MSH = 0xa0 - BPF_MUL = 0x20 - BPF_NEG = 0x80 - BPF_OR = 0x40 - BPF_RELEASE = 0x30bb6 - BPF_RET = 0x6 - BPF_RSH = 0x70 - BPF_ST = 0x2 - BPF_STX = 0x3 - BPF_SUB = 0x10 - BPF_TAX = 0x0 - BPF_TXA = 0x80 - BPF_W = 0x0 - BPF_X = 0x8 - BRKINT = 0x2 - BS0 = 0x0 - BS1 = 0x8000 - BSDLY = 0x8000 - CFLUSH = 0xf - CLOCAL = 0x8000 - CLOCK_MONOTONIC = 0x6 - CLOCK_MONOTONIC_RAW = 0x4 - CLOCK_MONOTONIC_RAW_APPROX = 0x5 - CLOCK_PROCESS_CPUTIME_ID = 0xc - CLOCK_REALTIME = 0x0 - CLOCK_THREAD_CPUTIME_ID = 0x10 - CLOCK_UPTIME_RAW = 0x8 - CLOCK_UPTIME_RAW_APPROX = 0x9 - CLONE_NOFOLLOW = 0x1 - CLONE_NOOWNERCOPY = 0x2 - CR0 = 0x0 - CR1 = 0x1000 - CR2 = 0x2000 - CR3 = 0x3000 - CRDLY = 0x3000 - CREAD = 0x800 - CRTSCTS = 0x30000 - CS5 = 0x0 - CS6 = 0x100 - CS7 = 0x200 - CS8 = 0x300 - CSIZE = 0x300 - CSTART = 0x11 - CSTATUS = 0x14 - CSTOP = 0x13 - CSTOPB = 0x400 - CSUSP = 0x1a - CTLIOCGINFO = 0xc0644e03 - CTL_HW = 0x6 - CTL_KERN = 0x1 - CTL_MAXNAME = 0xc - CTL_NET = 0x4 - DLT_A429 = 0xb8 - DLT_A653_ICM = 0xb9 - DLT_AIRONET_HEADER = 0x78 - DLT_AOS = 0xde - DLT_APPLE_IP_OVER_IEEE1394 = 0x8a - DLT_ARCNET = 0x7 - DLT_ARCNET_LINUX = 0x81 - DLT_ATM_CLIP = 0x13 - DLT_ATM_RFC1483 = 0xb - DLT_AURORA = 0x7e - DLT_AX25 = 0x3 - DLT_AX25_KISS = 0xca - DLT_BACNET_MS_TP = 0xa5 - DLT_BLUETOOTH_HCI_H4 = 0xbb - DLT_BLUETOOTH_HCI_H4_WITH_PHDR = 0xc9 - DLT_CAN20B = 0xbe - DLT_CAN_SOCKETCAN = 0xe3 - DLT_CHAOS = 0x5 - DLT_CHDLC = 0x68 - DLT_CISCO_IOS = 0x76 - DLT_C_HDLC = 0x68 - DLT_C_HDLC_WITH_DIR = 0xcd - DLT_DBUS = 0xe7 - DLT_DECT = 0xdd - DLT_DOCSIS = 0x8f - DLT_DVB_CI = 0xeb - DLT_ECONET = 0x73 - DLT_EN10MB = 0x1 - DLT_EN3MB = 0x2 - DLT_ENC = 0x6d - DLT_ERF = 0xc5 - DLT_ERF_ETH = 0xaf - DLT_ERF_POS = 0xb0 - DLT_FC_2 = 0xe0 - DLT_FC_2_WITH_FRAME_DELIMS = 0xe1 - DLT_FDDI = 0xa - DLT_FLEXRAY = 0xd2 - DLT_FRELAY = 0x6b - DLT_FRELAY_WITH_DIR = 0xce - DLT_GCOM_SERIAL = 0xad - DLT_GCOM_T1E1 = 0xac - DLT_GPF_F = 0xab - DLT_GPF_T = 0xaa - DLT_GPRS_LLC = 0xa9 - DLT_GSMTAP_ABIS = 0xda - DLT_GSMTAP_UM = 0xd9 - DLT_HHDLC = 0x79 - DLT_IBM_SN = 0x92 - DLT_IBM_SP = 0x91 - DLT_IEEE802 = 0x6 - DLT_IEEE802_11 = 0x69 - DLT_IEEE802_11_RADIO = 0x7f - DLT_IEEE802_11_RADIO_AVS = 0xa3 - DLT_IEEE802_15_4 = 0xc3 - DLT_IEEE802_15_4_LINUX = 0xbf - DLT_IEEE802_15_4_NOFCS = 0xe6 - DLT_IEEE802_15_4_NONASK_PHY = 0xd7 - DLT_IEEE802_16_MAC_CPS = 0xbc - DLT_IEEE802_16_MAC_CPS_RADIO = 0xc1 - DLT_IPFILTER = 0x74 - DLT_IPMB = 0xc7 - DLT_IPMB_LINUX = 0xd1 - DLT_IPNET = 0xe2 - DLT_IPOIB = 0xf2 - DLT_IPV4 = 0xe4 - DLT_IPV6 = 0xe5 - DLT_IP_OVER_FC = 0x7a - DLT_JUNIPER_ATM1 = 0x89 - DLT_JUNIPER_ATM2 = 0x87 - DLT_JUNIPER_ATM_CEMIC = 0xee - DLT_JUNIPER_CHDLC = 0xb5 - DLT_JUNIPER_ES = 0x84 - DLT_JUNIPER_ETHER = 0xb2 - DLT_JUNIPER_FIBRECHANNEL = 0xea - DLT_JUNIPER_FRELAY = 0xb4 - DLT_JUNIPER_GGSN = 0x85 - DLT_JUNIPER_ISM = 0xc2 - DLT_JUNIPER_MFR = 0x86 - DLT_JUNIPER_MLFR = 0x83 - DLT_JUNIPER_MLPPP = 0x82 - DLT_JUNIPER_MONITOR = 0xa4 - DLT_JUNIPER_PIC_PEER = 0xae - DLT_JUNIPER_PPP = 0xb3 - DLT_JUNIPER_PPPOE = 0xa7 - DLT_JUNIPER_PPPOE_ATM = 0xa8 - DLT_JUNIPER_SERVICES = 0x88 - DLT_JUNIPER_SRX_E2E = 0xe9 - DLT_JUNIPER_ST = 0xc8 - DLT_JUNIPER_VP = 0xb7 - DLT_JUNIPER_VS = 0xe8 - DLT_LAPB_WITH_DIR = 0xcf - DLT_LAPD = 0xcb - DLT_LIN = 0xd4 - DLT_LINUX_EVDEV = 0xd8 - DLT_LINUX_IRDA = 0x90 - DLT_LINUX_LAPD = 0xb1 - DLT_LINUX_PPP_WITHDIRECTION = 0xa6 - DLT_LINUX_SLL = 0x71 - DLT_LOOP = 0x6c - DLT_LTALK = 0x72 - DLT_MATCHING_MAX = 0x10a - DLT_MATCHING_MIN = 0x68 - DLT_MFR = 0xb6 - DLT_MOST = 0xd3 - DLT_MPEG_2_TS = 0xf3 - DLT_MPLS = 0xdb - DLT_MTP2 = 0x8c - DLT_MTP2_WITH_PHDR = 0x8b - DLT_MTP3 = 0x8d - DLT_MUX27010 = 0xec - DLT_NETANALYZER = 0xf0 - DLT_NETANALYZER_TRANSPARENT = 0xf1 - DLT_NFC_LLCP = 0xf5 - DLT_NFLOG = 0xef - DLT_NG40 = 0xf4 - DLT_NULL = 0x0 - DLT_PCI_EXP = 0x7d - DLT_PFLOG = 0x75 - DLT_PFSYNC = 0x12 - DLT_PPI = 0xc0 - DLT_PPP = 0x9 - DLT_PPP_BSDOS = 0x10 - DLT_PPP_ETHER = 0x33 - DLT_PPP_PPPD = 0xa6 - DLT_PPP_SERIAL = 0x32 - DLT_PPP_WITH_DIR = 0xcc - DLT_PPP_WITH_DIRECTION = 0xa6 - DLT_PRISM_HEADER = 0x77 - DLT_PRONET = 0x4 - DLT_RAIF1 = 0xc6 - DLT_RAW = 0xc - DLT_RIO = 0x7c - DLT_SCCP = 0x8e - DLT_SITA = 0xc4 - DLT_SLIP = 0x8 - DLT_SLIP_BSDOS = 0xf - DLT_STANAG_5066_D_PDU = 0xed - DLT_SUNATM = 0x7b - DLT_SYMANTEC_FIREWALL = 0x63 - DLT_TZSP = 0x80 - DLT_USB = 0xba - DLT_USB_DARWIN = 0x10a - DLT_USB_LINUX = 0xbd - DLT_USB_LINUX_MMAPPED = 0xdc - DLT_USER0 = 0x93 - DLT_USER1 = 0x94 - DLT_USER10 = 0x9d - DLT_USER11 = 0x9e - DLT_USER12 = 0x9f - DLT_USER13 = 0xa0 - DLT_USER14 = 0xa1 - DLT_USER15 = 0xa2 - DLT_USER2 = 0x95 - DLT_USER3 = 0x96 - DLT_USER4 = 0x97 - DLT_USER5 = 0x98 - DLT_USER6 = 0x99 - DLT_USER7 = 0x9a - DLT_USER8 = 0x9b - DLT_USER9 = 0x9c - DLT_WIHART = 0xdf - DLT_X2E_SERIAL = 0xd5 - DLT_X2E_XORAYA = 0xd6 - DT_BLK = 0x6 - DT_CHR = 0x2 - DT_DIR = 0x4 - DT_FIFO = 0x1 - DT_LNK = 0xa - DT_REG = 0x8 - DT_SOCK = 0xc - DT_UNKNOWN = 0x0 - DT_WHT = 0xe - ECHO = 0x8 - ECHOCTL = 0x40 - ECHOE = 0x2 - ECHOK = 0x4 - ECHOKE = 0x1 - ECHONL = 0x10 - ECHOPRT = 0x20 - EVFILT_AIO = -0x3 - EVFILT_EXCEPT = -0xf - EVFILT_FS = -0x9 - EVFILT_MACHPORT = -0x8 - EVFILT_PROC = -0x5 - EVFILT_READ = -0x1 - EVFILT_SIGNAL = -0x6 - EVFILT_SYSCOUNT = 0x11 - EVFILT_THREADMARKER = 0x11 - EVFILT_TIMER = -0x7 - EVFILT_USER = -0xa - EVFILT_VM = -0xc - EVFILT_VNODE = -0x4 - EVFILT_WRITE = -0x2 - EV_ADD = 0x1 - EV_CLEAR = 0x20 - EV_DELETE = 0x2 - EV_DISABLE = 0x8 - EV_DISPATCH = 0x80 - EV_DISPATCH2 = 0x180 - EV_ENABLE = 0x4 - EV_EOF = 0x8000 - EV_ERROR = 0x4000 - EV_FLAG0 = 0x1000 - EV_FLAG1 = 0x2000 - EV_ONESHOT = 0x10 - EV_OOBAND = 0x2000 - EV_POLL = 0x1000 - EV_RECEIPT = 0x40 - EV_SYSFLAGS = 0xf000 - EV_UDATA_SPECIFIC = 0x100 - EV_VANISHED = 0x200 - EXTA = 0x4b00 - EXTB = 0x9600 - EXTPROC = 0x800 - FD_CLOEXEC = 0x1 - FD_SETSIZE = 0x400 - FF0 = 0x0 - FF1 = 0x4000 - FFDLY = 0x4000 - FLUSHO = 0x800000 - FSOPT_ATTR_CMN_EXTENDED = 0x20 - FSOPT_NOFOLLOW = 0x1 - FSOPT_NOINMEMUPDATE = 0x2 - FSOPT_PACK_INVAL_ATTRS = 0x8 - FSOPT_REPORT_FULLSIZE = 0x4 - FSOPT_RETURN_REALDEV = 0x200 - F_ADDFILESIGS = 0x3d - F_ADDFILESIGS_FOR_DYLD_SIM = 0x53 - F_ADDFILESIGS_INFO = 0x67 - F_ADDFILESIGS_RETURN = 0x61 - F_ADDFILESUPPL = 0x68 - F_ADDSIGS = 0x3b - F_ALLOCATEALL = 0x4 - F_ALLOCATECONTIG = 0x2 - F_BARRIERFSYNC = 0x55 - F_CHECK_LV = 0x62 - F_CHKCLEAN = 0x29 - F_DUPFD = 0x0 - F_DUPFD_CLOEXEC = 0x43 - F_FINDSIGS = 0x4e - F_FLUSH_DATA = 0x28 - F_FREEZE_FS = 0x35 - F_FULLFSYNC = 0x33 - F_GETCODEDIR = 0x48 - F_GETFD = 0x1 - F_GETFL = 0x3 - F_GETLK = 0x7 - F_GETLKPID = 0x42 - F_GETNOSIGPIPE = 0x4a - F_GETOWN = 0x5 - F_GETPATH = 0x32 - F_GETPATH_MTMINFO = 0x47 - F_GETPATH_NOFIRMLINK = 0x66 - F_GETPROTECTIONCLASS = 0x3f - F_GETPROTECTIONLEVEL = 0x4d - F_GETSIGSINFO = 0x69 - F_GLOBAL_NOCACHE = 0x37 - F_LOG2PHYS = 0x31 - F_LOG2PHYS_EXT = 0x41 - F_NOCACHE = 0x30 - F_NODIRECT = 0x3e - F_OK = 0x0 - F_PATHPKG_CHECK = 0x34 - F_PEOFPOSMODE = 0x3 - F_PREALLOCATE = 0x2a - F_PUNCHHOLE = 0x63 - F_RDADVISE = 0x2c - F_RDAHEAD = 0x2d - F_RDLCK = 0x1 - F_SETBACKINGSTORE = 0x46 - F_SETFD = 0x2 - F_SETFL = 0x4 - F_SETLK = 0x8 - F_SETLKW = 0x9 - F_SETLKWTIMEOUT = 0xa - F_SETNOSIGPIPE = 0x49 - F_SETOWN = 0x6 - F_SETPROTECTIONCLASS = 0x40 - F_SETSIZE = 0x2b - F_SINGLE_WRITER = 0x4c - F_SPECULATIVE_READ = 0x65 - F_THAW_FS = 0x36 - F_TRANSCODEKEY = 0x4b - F_TRIM_ACTIVE_FILE = 0x64 - F_UNLCK = 0x2 - F_VOLPOSMODE = 0x4 - F_WRLCK = 0x3 - HUPCL = 0x4000 - HW_MACHINE = 0x1 - ICANON = 0x100 - ICMP6_FILTER = 0x12 - ICRNL = 0x100 - IEXTEN = 0x400 - IFF_ALLMULTI = 0x200 - IFF_ALTPHYS = 0x4000 - IFF_BROADCAST = 0x2 - IFF_DEBUG = 0x4 - IFF_LINK0 = 0x1000 - IFF_LINK1 = 0x2000 - IFF_LINK2 = 0x4000 - IFF_LOOPBACK = 0x8 - IFF_MULTICAST = 0x8000 - IFF_NOARP = 0x80 - IFF_NOTRAILERS = 0x20 - IFF_OACTIVE = 0x400 - IFF_POINTOPOINT = 0x10 - IFF_PROMISC = 0x100 - IFF_RUNNING = 0x40 - IFF_SIMPLEX = 0x800 - IFF_UP = 0x1 - IFNAMSIZ = 0x10 - IFT_1822 = 0x2 - IFT_6LOWPAN = 0x40 - IFT_AAL5 = 0x31 - IFT_ARCNET = 0x23 - IFT_ARCNETPLUS = 0x24 - IFT_ATM = 0x25 - IFT_BRIDGE = 0xd1 - IFT_CARP = 0xf8 - IFT_CELLULAR = 0xff - IFT_CEPT = 0x13 - IFT_DS3 = 0x1e - IFT_ENC = 0xf4 - IFT_EON = 0x19 - IFT_ETHER = 0x6 - IFT_FAITH = 0x38 - IFT_FDDI = 0xf - IFT_FRELAY = 0x20 - IFT_FRELAYDCE = 0x2c - IFT_GIF = 0x37 - IFT_HDH1822 = 0x3 - IFT_HIPPI = 0x2f - IFT_HSSI = 0x2e - IFT_HY = 0xe - IFT_IEEE1394 = 0x90 - IFT_IEEE8023ADLAG = 0x88 - IFT_ISDNBASIC = 0x14 - IFT_ISDNPRIMARY = 0x15 - IFT_ISO88022LLC = 0x29 - IFT_ISO88023 = 0x7 - IFT_ISO88024 = 0x8 - IFT_ISO88025 = 0x9 - IFT_ISO88026 = 0xa - IFT_L2VLAN = 0x87 - IFT_LAPB = 0x10 - IFT_LOCALTALK = 0x2a - IFT_LOOP = 0x18 - IFT_MIOX25 = 0x26 - IFT_MODEM = 0x30 - IFT_NSIP = 0x1b - IFT_OTHER = 0x1 - IFT_P10 = 0xc - IFT_P80 = 0xd - IFT_PARA = 0x22 - IFT_PDP = 0xff - IFT_PFLOG = 0xf5 - IFT_PFSYNC = 0xf6 - IFT_PKTAP = 0xfe - IFT_PPP = 0x17 - IFT_PROPMUX = 0x36 - IFT_PROPVIRTUAL = 0x35 - IFT_PTPSERIAL = 0x16 - IFT_RS232 = 0x21 - IFT_SDLC = 0x11 - IFT_SIP = 0x1f - IFT_SLIP = 0x1c - IFT_SMDSDXI = 0x2b - IFT_SMDSICIP = 0x34 - IFT_SONET = 0x27 - IFT_SONETPATH = 0x32 - IFT_SONETVT = 0x33 - IFT_STARLAN = 0xb - IFT_STF = 0x39 - IFT_T1 = 0x12 - IFT_ULTRA = 0x1d - IFT_V35 = 0x2d - IFT_X25 = 0x5 - IFT_X25DDN = 0x4 - IFT_X25PLE = 0x28 - IFT_XETHER = 0x1a - IGNBRK = 0x1 - IGNCR = 0x80 - IGNPAR = 0x4 - IMAXBEL = 0x2000 - INLCR = 0x40 - INPCK = 0x10 - IN_CLASSA_HOST = 0xffffff - IN_CLASSA_MAX = 0x80 - IN_CLASSA_NET = 0xff000000 - IN_CLASSA_NSHIFT = 0x18 - IN_CLASSB_HOST = 0xffff - IN_CLASSB_MAX = 0x10000 - IN_CLASSB_NET = 0xffff0000 - IN_CLASSB_NSHIFT = 0x10 - IN_CLASSC_HOST = 0xff - IN_CLASSC_NET = 0xffffff00 - IN_CLASSC_NSHIFT = 0x8 - IN_CLASSD_HOST = 0xfffffff - IN_CLASSD_NET = 0xf0000000 - IN_CLASSD_NSHIFT = 0x1c - IN_LINKLOCALNETNUM = 0xa9fe0000 - IN_LOOPBACKNET = 0x7f - IPPROTO_3PC = 0x22 - IPPROTO_ADFS = 0x44 - IPPROTO_AH = 0x33 - IPPROTO_AHIP = 0x3d - IPPROTO_APES = 0x63 - IPPROTO_ARGUS = 0xd - IPPROTO_AX25 = 0x5d - IPPROTO_BHA = 0x31 - IPPROTO_BLT = 0x1e - IPPROTO_BRSATMON = 0x4c - IPPROTO_CFTP = 0x3e - IPPROTO_CHAOS = 0x10 - IPPROTO_CMTP = 0x26 - IPPROTO_CPHB = 0x49 - IPPROTO_CPNX = 0x48 - IPPROTO_DDP = 0x25 - IPPROTO_DGP = 0x56 - IPPROTO_DIVERT = 0xfe - IPPROTO_DONE = 0x101 - IPPROTO_DSTOPTS = 0x3c - IPPROTO_EGP = 0x8 - IPPROTO_EMCON = 0xe - IPPROTO_ENCAP = 0x62 - IPPROTO_EON = 0x50 - IPPROTO_ESP = 0x32 - IPPROTO_ETHERIP = 0x61 - IPPROTO_FRAGMENT = 0x2c - IPPROTO_GGP = 0x3 - IPPROTO_GMTP = 0x64 - IPPROTO_GRE = 0x2f - IPPROTO_HELLO = 0x3f - IPPROTO_HMP = 0x14 - IPPROTO_HOPOPTS = 0x0 - IPPROTO_ICMP = 0x1 - IPPROTO_ICMPV6 = 0x3a - IPPROTO_IDP = 0x16 - IPPROTO_IDPR = 0x23 - IPPROTO_IDRP = 0x2d - IPPROTO_IGMP = 0x2 - IPPROTO_IGP = 0x55 - IPPROTO_IGRP = 0x58 - IPPROTO_IL = 0x28 - IPPROTO_INLSP = 0x34 - IPPROTO_INP = 0x20 - IPPROTO_IP = 0x0 - IPPROTO_IPCOMP = 0x6c - IPPROTO_IPCV = 0x47 - IPPROTO_IPEIP = 0x5e - IPPROTO_IPIP = 0x4 - IPPROTO_IPPC = 0x43 - IPPROTO_IPV4 = 0x4 - IPPROTO_IPV6 = 0x29 - IPPROTO_IRTP = 0x1c - IPPROTO_KRYPTOLAN = 0x41 - IPPROTO_LARP = 0x5b - IPPROTO_LEAF1 = 0x19 - IPPROTO_LEAF2 = 0x1a - IPPROTO_MAX = 0x100 - IPPROTO_MAXID = 0x34 - IPPROTO_MEAS = 0x13 - IPPROTO_MHRP = 0x30 - IPPROTO_MICP = 0x5f - IPPROTO_MTP = 0x5c - IPPROTO_MUX = 0x12 - IPPROTO_ND = 0x4d - IPPROTO_NHRP = 0x36 - IPPROTO_NONE = 0x3b - IPPROTO_NSP = 0x1f - IPPROTO_NVPII = 0xb - IPPROTO_OSPFIGP = 0x59 - IPPROTO_PGM = 0x71 - IPPROTO_PIGP = 0x9 - IPPROTO_PIM = 0x67 - IPPROTO_PRM = 0x15 - IPPROTO_PUP = 0xc - IPPROTO_PVP = 0x4b - IPPROTO_RAW = 0xff - IPPROTO_RCCMON = 0xa - IPPROTO_RDP = 0x1b - IPPROTO_ROUTING = 0x2b - IPPROTO_RSVP = 0x2e - IPPROTO_RVD = 0x42 - IPPROTO_SATEXPAK = 0x40 - IPPROTO_SATMON = 0x45 - IPPROTO_SCCSP = 0x60 - IPPROTO_SCTP = 0x84 - IPPROTO_SDRP = 0x2a - IPPROTO_SEP = 0x21 - IPPROTO_SRPC = 0x5a - IPPROTO_ST = 0x7 - IPPROTO_SVMTP = 0x52 - IPPROTO_SWIPE = 0x35 - IPPROTO_TCF = 0x57 - IPPROTO_TCP = 0x6 - IPPROTO_TP = 0x1d - IPPROTO_TPXX = 0x27 - IPPROTO_TRUNK1 = 0x17 - IPPROTO_TRUNK2 = 0x18 - IPPROTO_TTP = 0x54 - IPPROTO_UDP = 0x11 - IPPROTO_VINES = 0x53 - IPPROTO_VISA = 0x46 - IPPROTO_VMTP = 0x51 - IPPROTO_WBEXPAK = 0x4f - IPPROTO_WBMON = 0x4e - IPPROTO_WSN = 0x4a - IPPROTO_XNET = 0xf - IPPROTO_XTP = 0x24 - IPV6_2292DSTOPTS = 0x17 - IPV6_2292HOPLIMIT = 0x14 - IPV6_2292HOPOPTS = 0x16 - IPV6_2292NEXTHOP = 0x15 - IPV6_2292PKTINFO = 0x13 - IPV6_2292PKTOPTIONS = 0x19 - IPV6_2292RTHDR = 0x18 - IPV6_3542DSTOPTS = 0x32 - IPV6_3542HOPLIMIT = 0x2f - IPV6_3542HOPOPTS = 0x31 - IPV6_3542NEXTHOP = 0x30 - IPV6_3542PKTINFO = 0x2e - IPV6_3542RTHDR = 0x33 - IPV6_ADDR_MC_FLAGS_PREFIX = 0x20 - IPV6_ADDR_MC_FLAGS_TRANSIENT = 0x10 - IPV6_ADDR_MC_FLAGS_UNICAST_BASED = 0x30 - IPV6_AUTOFLOWLABEL = 0x3b - IPV6_BINDV6ONLY = 0x1b - IPV6_BOUND_IF = 0x7d - IPV6_CHECKSUM = 0x1a - IPV6_DEFAULT_MULTICAST_HOPS = 0x1 - IPV6_DEFAULT_MULTICAST_LOOP = 0x1 - IPV6_DEFHLIM = 0x40 - IPV6_DONTFRAG = 0x3e - IPV6_DSTOPTS = 0x32 - IPV6_FAITH = 0x1d - IPV6_FLOWINFO_MASK = 0xffffff0f - IPV6_FLOWLABEL_MASK = 0xffff0f00 - IPV6_FLOW_ECN_MASK = 0x3000 - IPV6_FRAGTTL = 0x3c - IPV6_FW_ADD = 0x1e - IPV6_FW_DEL = 0x1f - IPV6_FW_FLUSH = 0x20 - IPV6_FW_GET = 0x22 - IPV6_FW_ZERO = 0x21 - IPV6_HLIMDEC = 0x1 - IPV6_HOPLIMIT = 0x2f - IPV6_HOPOPTS = 0x31 - IPV6_IPSEC_POLICY = 0x1c - IPV6_JOIN_GROUP = 0xc - IPV6_LEAVE_GROUP = 0xd - IPV6_MAXHLIM = 0xff - IPV6_MAXOPTHDR = 0x800 - IPV6_MAXPACKET = 0xffff - IPV6_MAX_GROUP_SRC_FILTER = 0x200 - IPV6_MAX_MEMBERSHIPS = 0xfff - IPV6_MAX_SOCK_SRC_FILTER = 0x80 - IPV6_MIN_MEMBERSHIPS = 0x1f - IPV6_MMTU = 0x500 - IPV6_MSFILTER = 0x4a - IPV6_MULTICAST_HOPS = 0xa - IPV6_MULTICAST_IF = 0x9 - IPV6_MULTICAST_LOOP = 0xb - IPV6_NEXTHOP = 0x30 - IPV6_PATHMTU = 0x2c - IPV6_PKTINFO = 0x2e - IPV6_PORTRANGE = 0xe - IPV6_PORTRANGE_DEFAULT = 0x0 - IPV6_PORTRANGE_HIGH = 0x1 - IPV6_PORTRANGE_LOW = 0x2 - IPV6_PREFER_TEMPADDR = 0x3f - IPV6_RECVDSTOPTS = 0x28 - IPV6_RECVHOPLIMIT = 0x25 - IPV6_RECVHOPOPTS = 0x27 - IPV6_RECVPATHMTU = 0x2b - IPV6_RECVPKTINFO = 0x3d - IPV6_RECVRTHDR = 0x26 - IPV6_RECVTCLASS = 0x23 - IPV6_RTHDR = 0x33 - IPV6_RTHDRDSTOPTS = 0x39 - IPV6_RTHDR_LOOSE = 0x0 - IPV6_RTHDR_STRICT = 0x1 - IPV6_RTHDR_TYPE_0 = 0x0 - IPV6_SOCKOPT_RESERVED1 = 0x3 - IPV6_TCLASS = 0x24 - IPV6_UNICAST_HOPS = 0x4 - IPV6_USE_MIN_MTU = 0x2a - IPV6_V6ONLY = 0x1b - IPV6_VERSION = 0x60 - IPV6_VERSION_MASK = 0xf0 - IP_ADD_MEMBERSHIP = 0xc - IP_ADD_SOURCE_MEMBERSHIP = 0x46 - IP_BLOCK_SOURCE = 0x48 - IP_BOUND_IF = 0x19 - IP_DEFAULT_MULTICAST_LOOP = 0x1 - IP_DEFAULT_MULTICAST_TTL = 0x1 - IP_DF = 0x4000 - IP_DONTFRAG = 0x1c - IP_DROP_MEMBERSHIP = 0xd - IP_DROP_SOURCE_MEMBERSHIP = 0x47 - IP_DUMMYNET_CONFIGURE = 0x3c - IP_DUMMYNET_DEL = 0x3d - IP_DUMMYNET_FLUSH = 0x3e - IP_DUMMYNET_GET = 0x40 - IP_FAITH = 0x16 - IP_FW_ADD = 0x28 - IP_FW_DEL = 0x29 - IP_FW_FLUSH = 0x2a - IP_FW_GET = 0x2c - IP_FW_RESETLOG = 0x2d - IP_FW_ZERO = 0x2b - IP_HDRINCL = 0x2 - IP_IPSEC_POLICY = 0x15 - IP_MAXPACKET = 0xffff - IP_MAX_GROUP_SRC_FILTER = 0x200 - IP_MAX_MEMBERSHIPS = 0xfff - IP_MAX_SOCK_MUTE_FILTER = 0x80 - IP_MAX_SOCK_SRC_FILTER = 0x80 - IP_MF = 0x2000 - IP_MIN_MEMBERSHIPS = 0x1f - IP_MSFILTER = 0x4a - IP_MSS = 0x240 - IP_MULTICAST_IF = 0x9 - IP_MULTICAST_IFINDEX = 0x42 - IP_MULTICAST_LOOP = 0xb - IP_MULTICAST_TTL = 0xa - IP_MULTICAST_VIF = 0xe - IP_NAT__XXX = 0x37 - IP_OFFMASK = 0x1fff - IP_OLD_FW_ADD = 0x32 - IP_OLD_FW_DEL = 0x33 - IP_OLD_FW_FLUSH = 0x34 - IP_OLD_FW_GET = 0x36 - IP_OLD_FW_RESETLOG = 0x38 - IP_OLD_FW_ZERO = 0x35 - IP_OPTIONS = 0x1 - IP_PKTINFO = 0x1a - IP_PORTRANGE = 0x13 - IP_PORTRANGE_DEFAULT = 0x0 - IP_PORTRANGE_HIGH = 0x1 - IP_PORTRANGE_LOW = 0x2 - IP_RECVDSTADDR = 0x7 - IP_RECVIF = 0x14 - IP_RECVOPTS = 0x5 - IP_RECVPKTINFO = 0x1a - IP_RECVRETOPTS = 0x6 - IP_RECVTOS = 0x1b - IP_RECVTTL = 0x18 - IP_RETOPTS = 0x8 - IP_RF = 0x8000 - IP_RSVP_OFF = 0x10 - IP_RSVP_ON = 0xf - IP_RSVP_VIF_OFF = 0x12 - IP_RSVP_VIF_ON = 0x11 - IP_STRIPHDR = 0x17 - IP_TOS = 0x3 - IP_TRAFFIC_MGT_BACKGROUND = 0x41 - IP_TTL = 0x4 - IP_UNBLOCK_SOURCE = 0x49 - ISIG = 0x80 - ISTRIP = 0x20 - IUTF8 = 0x4000 - IXANY = 0x800 - IXOFF = 0x400 - IXON = 0x200 - KERN_HOSTNAME = 0xa - KERN_OSRELEASE = 0x2 - KERN_OSTYPE = 0x1 - KERN_VERSION = 0x4 - LOCAL_PEERCRED = 0x1 - LOCAL_PEEREPID = 0x3 - LOCAL_PEEREUUID = 0x5 - LOCAL_PEERPID = 0x2 - LOCAL_PEERTOKEN = 0x6 - LOCAL_PEERUUID = 0x4 - LOCK_EX = 0x2 - LOCK_NB = 0x4 - LOCK_SH = 0x1 - LOCK_UN = 0x8 - MADV_CAN_REUSE = 0x9 - MADV_DONTNEED = 0x4 - MADV_FREE = 0x5 - MADV_FREE_REUSABLE = 0x7 - MADV_FREE_REUSE = 0x8 - MADV_NORMAL = 0x0 - MADV_PAGEOUT = 0xa - MADV_RANDOM = 0x1 - MADV_SEQUENTIAL = 0x2 - MADV_WILLNEED = 0x3 - MADV_ZERO_WIRED_PAGES = 0x6 - MAP_32BIT = 0x8000 - MAP_ANON = 0x1000 - MAP_ANONYMOUS = 0x1000 - MAP_COPY = 0x2 - MAP_FILE = 0x0 - MAP_FIXED = 0x10 - MAP_HASSEMAPHORE = 0x200 - MAP_JIT = 0x800 - MAP_NOCACHE = 0x400 - MAP_NOEXTEND = 0x100 - MAP_NORESERVE = 0x40 - MAP_PRIVATE = 0x2 - MAP_RENAME = 0x20 - MAP_RESERVED0080 = 0x80 - MAP_RESILIENT_CODESIGN = 0x2000 - MAP_RESILIENT_MEDIA = 0x4000 - MAP_SHARED = 0x1 - MAP_TRANSLATED_ALLOW_EXECUTE = 0x20000 - MAP_UNIX03 = 0x40000 - MCAST_BLOCK_SOURCE = 0x54 - MCAST_EXCLUDE = 0x2 - MCAST_INCLUDE = 0x1 - MCAST_JOIN_GROUP = 0x50 - MCAST_JOIN_SOURCE_GROUP = 0x52 - MCAST_LEAVE_GROUP = 0x51 - MCAST_LEAVE_SOURCE_GROUP = 0x53 - MCAST_UNBLOCK_SOURCE = 0x55 - MCAST_UNDEFINED = 0x0 - MCL_CURRENT = 0x1 - MCL_FUTURE = 0x2 - MNT_ASYNC = 0x40 - MNT_AUTOMOUNTED = 0x400000 - MNT_CMDFLAGS = 0xf0000 - MNT_CPROTECT = 0x80 - MNT_DEFWRITE = 0x2000000 - MNT_DONTBROWSE = 0x100000 - MNT_DOVOLFS = 0x8000 - MNT_DWAIT = 0x4 - MNT_EXPORTED = 0x100 - MNT_EXT_ROOT_DATA_VOL = 0x1 - MNT_FORCE = 0x80000 - MNT_IGNORE_OWNERSHIP = 0x200000 - MNT_JOURNALED = 0x800000 - MNT_LOCAL = 0x1000 - MNT_MULTILABEL = 0x4000000 - MNT_NOATIME = 0x10000000 - MNT_NOBLOCK = 0x20000 - MNT_NODEV = 0x10 - MNT_NOEXEC = 0x4 - MNT_NOSUID = 0x8 - MNT_NOUSERXATTR = 0x1000000 - MNT_NOWAIT = 0x2 - MNT_QUARANTINE = 0x400 - MNT_QUOTA = 0x2000 - MNT_RDONLY = 0x1 - MNT_RELOAD = 0x40000 - MNT_REMOVABLE = 0x200 - MNT_ROOTFS = 0x4000 - MNT_SNAPSHOT = 0x40000000 - MNT_STRICTATIME = 0x80000000 - MNT_SYNCHRONOUS = 0x2 - MNT_UNION = 0x20 - MNT_UNKNOWNPERMISSIONS = 0x200000 - MNT_UPDATE = 0x10000 - MNT_VISFLAGMASK = 0xd7f0f7ff - MNT_WAIT = 0x1 - MSG_CTRUNC = 0x20 - MSG_DONTROUTE = 0x4 - MSG_DONTWAIT = 0x80 - MSG_EOF = 0x100 - MSG_EOR = 0x8 - MSG_FLUSH = 0x400 - MSG_HAVEMORE = 0x2000 - MSG_HOLD = 0x800 - MSG_NEEDSA = 0x10000 - MSG_NOSIGNAL = 0x80000 - MSG_OOB = 0x1 - MSG_PEEK = 0x2 - MSG_RCVMORE = 0x4000 - MSG_SEND = 0x1000 - MSG_TRUNC = 0x10 - MSG_WAITALL = 0x40 - MSG_WAITSTREAM = 0x200 - MS_ASYNC = 0x1 - MS_DEACTIVATE = 0x8 - MS_INVALIDATE = 0x2 - MS_KILLPAGES = 0x4 - MS_SYNC = 0x10 - NAME_MAX = 0xff - NET_RT_DUMP = 0x1 - NET_RT_DUMP2 = 0x7 - NET_RT_FLAGS = 0x2 - NET_RT_FLAGS_PRIV = 0xa - NET_RT_IFLIST = 0x3 - NET_RT_IFLIST2 = 0x6 - NET_RT_MAXID = 0xb - NET_RT_STAT = 0x4 - NET_RT_TRASH = 0x5 - NFDBITS = 0x20 - NL0 = 0x0 - NL1 = 0x100 - NL2 = 0x200 - NL3 = 0x300 - NLDLY = 0x300 - NOFLSH = 0x80000000 - NOKERNINFO = 0x2000000 - NOTE_ABSOLUTE = 0x8 - NOTE_ATTRIB = 0x8 - NOTE_BACKGROUND = 0x40 - NOTE_CHILD = 0x4 - NOTE_CRITICAL = 0x20 - NOTE_DELETE = 0x1 - NOTE_EXEC = 0x20000000 - NOTE_EXIT = 0x80000000 - NOTE_EXITSTATUS = 0x4000000 - NOTE_EXIT_CSERROR = 0x40000 - NOTE_EXIT_DECRYPTFAIL = 0x10000 - NOTE_EXIT_DETAIL = 0x2000000 - NOTE_EXIT_DETAIL_MASK = 0x70000 - NOTE_EXIT_MEMORY = 0x20000 - NOTE_EXIT_REPARENTED = 0x80000 - NOTE_EXTEND = 0x4 - NOTE_FFAND = 0x40000000 - NOTE_FFCOPY = 0xc0000000 - NOTE_FFCTRLMASK = 0xc0000000 - NOTE_FFLAGSMASK = 0xffffff - NOTE_FFNOP = 0x0 - NOTE_FFOR = 0x80000000 - NOTE_FORK = 0x40000000 - NOTE_FUNLOCK = 0x100 - NOTE_LEEWAY = 0x10 - NOTE_LINK = 0x10 - NOTE_LOWAT = 0x1 - NOTE_MACHTIME = 0x100 - NOTE_MACH_CONTINUOUS_TIME = 0x80 - NOTE_NONE = 0x80 - NOTE_NSECONDS = 0x4 - NOTE_OOB = 0x2 - NOTE_PCTRLMASK = -0x100000 - NOTE_PDATAMASK = 0xfffff - NOTE_REAP = 0x10000000 - NOTE_RENAME = 0x20 - NOTE_REVOKE = 0x40 - NOTE_SECONDS = 0x1 - NOTE_SIGNAL = 0x8000000 - NOTE_TRACK = 0x1 - NOTE_TRACKERR = 0x2 - NOTE_TRIGGER = 0x1000000 - NOTE_USECONDS = 0x2 - NOTE_VM_ERROR = 0x10000000 - NOTE_VM_PRESSURE = 0x80000000 - NOTE_VM_PRESSURE_SUDDEN_TERMINATE = 0x20000000 - NOTE_VM_PRESSURE_TERMINATE = 0x40000000 - NOTE_WRITE = 0x2 - OCRNL = 0x10 - OFDEL = 0x20000 - OFILL = 0x80 - ONLCR = 0x2 - ONLRET = 0x40 - ONOCR = 0x20 - ONOEOT = 0x8 - OPOST = 0x1 - OXTABS = 0x4 - O_ACCMODE = 0x3 - O_ALERT = 0x20000000 - O_APPEND = 0x8 - O_ASYNC = 0x40 - O_CLOEXEC = 0x1000000 - O_CREAT = 0x200 - O_DIRECTORY = 0x100000 - O_DP_GETRAWENCRYPTED = 0x1 - O_DP_GETRAWUNENCRYPTED = 0x2 - O_DSYNC = 0x400000 - O_EVTONLY = 0x8000 - O_EXCL = 0x800 - O_EXLOCK = 0x20 - O_FSYNC = 0x80 - O_NDELAY = 0x4 - O_NOCTTY = 0x20000 - O_NOFOLLOW = 0x100 - O_NOFOLLOW_ANY = 0x20000000 - O_NONBLOCK = 0x4 - O_POPUP = 0x80000000 - O_RDONLY = 0x0 - O_RDWR = 0x2 - O_SHLOCK = 0x10 - O_SYMLINK = 0x200000 - O_SYNC = 0x80 - O_TRUNC = 0x400 - O_WRONLY = 0x1 - PARENB = 0x1000 - PARMRK = 0x8 - PARODD = 0x2000 - PENDIN = 0x20000000 - PRIO_PGRP = 0x1 - PRIO_PROCESS = 0x0 - PRIO_USER = 0x2 - PROT_EXEC = 0x4 - PROT_NONE = 0x0 - PROT_READ = 0x1 - PROT_WRITE = 0x2 - PT_ATTACH = 0xa - PT_ATTACHEXC = 0xe - PT_CONTINUE = 0x7 - PT_DENY_ATTACH = 0x1f - PT_DETACH = 0xb - PT_FIRSTMACH = 0x20 - PT_FORCEQUOTA = 0x1e - PT_KILL = 0x8 - PT_READ_D = 0x2 - PT_READ_I = 0x1 - PT_READ_U = 0x3 - PT_SIGEXC = 0xc - PT_STEP = 0x9 - PT_THUPDATE = 0xd - PT_TRACE_ME = 0x0 - PT_WRITE_D = 0x5 - PT_WRITE_I = 0x4 - PT_WRITE_U = 0x6 - RLIMIT_AS = 0x5 - RLIMIT_CORE = 0x4 - RLIMIT_CPU = 0x0 - RLIMIT_CPU_USAGE_MONITOR = 0x2 - RLIMIT_DATA = 0x2 - RLIMIT_FSIZE = 0x1 - RLIMIT_MEMLOCK = 0x6 - RLIMIT_NOFILE = 0x8 - RLIMIT_NPROC = 0x7 - RLIMIT_RSS = 0x5 - RLIMIT_STACK = 0x3 - RLIM_INFINITY = 0x7fffffffffffffff - RTAX_AUTHOR = 0x6 - RTAX_BRD = 0x7 - RTAX_DST = 0x0 - RTAX_GATEWAY = 0x1 - RTAX_GENMASK = 0x3 - RTAX_IFA = 0x5 - RTAX_IFP = 0x4 - RTAX_MAX = 0x8 - RTAX_NETMASK = 0x2 - RTA_AUTHOR = 0x40 - RTA_BRD = 0x80 - RTA_DST = 0x1 - RTA_GATEWAY = 0x2 - RTA_GENMASK = 0x8 - RTA_IFA = 0x20 - RTA_IFP = 0x10 - RTA_NETMASK = 0x4 - RTF_BLACKHOLE = 0x1000 - RTF_BROADCAST = 0x400000 - RTF_CLONING = 0x100 - RTF_CONDEMNED = 0x2000000 - RTF_DEAD = 0x20000000 - RTF_DELCLONE = 0x80 - RTF_DONE = 0x40 - RTF_DYNAMIC = 0x10 - RTF_GATEWAY = 0x2 - RTF_GLOBAL = 0x40000000 - RTF_HOST = 0x4 - RTF_IFREF = 0x4000000 - RTF_IFSCOPE = 0x1000000 - RTF_LLDATA = 0x400 - RTF_LLINFO = 0x400 - RTF_LOCAL = 0x200000 - RTF_MODIFIED = 0x20 - RTF_MULTICAST = 0x800000 - RTF_NOIFREF = 0x2000 - RTF_PINNED = 0x100000 - RTF_PRCLONING = 0x10000 - RTF_PROTO1 = 0x8000 - RTF_PROTO2 = 0x4000 - RTF_PROTO3 = 0x40000 - RTF_PROXY = 0x8000000 - RTF_REJECT = 0x8 - RTF_ROUTER = 0x10000000 - RTF_STATIC = 0x800 - RTF_UP = 0x1 - RTF_WASCLONED = 0x20000 - RTF_XRESOLVE = 0x200 - RTM_ADD = 0x1 - RTM_CHANGE = 0x3 - RTM_DELADDR = 0xd - RTM_DELETE = 0x2 - RTM_DELMADDR = 0x10 - RTM_GET = 0x4 - RTM_GET2 = 0x14 - RTM_IFINFO = 0xe - RTM_IFINFO2 = 0x12 - RTM_LOCK = 0x8 - RTM_LOSING = 0x5 - RTM_MISS = 0x7 - RTM_NEWADDR = 0xc - RTM_NEWMADDR = 0xf - RTM_NEWMADDR2 = 0x13 - RTM_OLDADD = 0x9 - RTM_OLDDEL = 0xa - RTM_REDIRECT = 0x6 - RTM_RESOLVE = 0xb - RTM_RTTUNIT = 0xf4240 - RTM_VERSION = 0x5 - RTV_EXPIRE = 0x4 - RTV_HOPCOUNT = 0x2 - RTV_MTU = 0x1 - RTV_RPIPE = 0x8 - RTV_RTT = 0x40 - RTV_RTTVAR = 0x80 - RTV_SPIPE = 0x10 - RTV_SSTHRESH = 0x20 - RUSAGE_CHILDREN = -0x1 - RUSAGE_SELF = 0x0 - SCM_CREDS = 0x3 - SCM_RIGHTS = 0x1 - SCM_TIMESTAMP = 0x2 - SCM_TIMESTAMP_MONOTONIC = 0x4 - SEEK_CUR = 0x1 - SEEK_DATA = 0x4 - SEEK_END = 0x2 - SEEK_HOLE = 0x3 - SEEK_SET = 0x0 - SHUT_RD = 0x0 - SHUT_RDWR = 0x2 - SHUT_WR = 0x1 - SIOCADDMULTI = 0x80206931 - SIOCAIFADDR = 0x8040691a - SIOCARPIPLL = 0xc0206928 - SIOCATMARK = 0x40047307 - SIOCAUTOADDR = 0xc0206926 - SIOCAUTONETMASK = 0x80206927 - SIOCDELMULTI = 0x80206932 - SIOCDIFADDR = 0x80206919 - SIOCDIFPHYADDR = 0x80206941 - SIOCGDRVSPEC = 0xc028697b - SIOCGETVLAN = 0xc020697f - SIOCGHIWAT = 0x40047301 - SIOCGIF6LOWPAN = 0xc02069c5 - SIOCGIFADDR = 0xc0206921 - SIOCGIFALTMTU = 0xc0206948 - SIOCGIFASYNCMAP = 0xc020697c - SIOCGIFBOND = 0xc0206947 - SIOCGIFBRDADDR = 0xc0206923 - SIOCGIFCAP = 0xc020695b - SIOCGIFCONF = 0xc00c6924 - SIOCGIFDEVMTU = 0xc0206944 - SIOCGIFDSTADDR = 0xc0206922 - SIOCGIFFLAGS = 0xc0206911 - SIOCGIFFUNCTIONALTYPE = 0xc02069ad - SIOCGIFGENERIC = 0xc020693a - SIOCGIFKPI = 0xc0206987 - SIOCGIFMAC = 0xc0206982 - SIOCGIFMEDIA = 0xc02c6938 - SIOCGIFMETRIC = 0xc0206917 - SIOCGIFMTU = 0xc0206933 - SIOCGIFNETMASK = 0xc0206925 - SIOCGIFPDSTADDR = 0xc0206940 - SIOCGIFPHYS = 0xc0206935 - SIOCGIFPSRCADDR = 0xc020693f - SIOCGIFSTATUS = 0xc331693d - SIOCGIFVLAN = 0xc020697f - SIOCGIFWAKEFLAGS = 0xc0206988 - SIOCGIFXMEDIA = 0xc02c6948 - SIOCGLOWAT = 0x40047303 - SIOCGPGRP = 0x40047309 - SIOCIFCREATE = 0xc0206978 - SIOCIFCREATE2 = 0xc020697a - SIOCIFDESTROY = 0x80206979 - SIOCIFGCLONERS = 0xc0106981 - SIOCRSLVMULTI = 0xc010693b - SIOCSDRVSPEC = 0x8028697b - SIOCSETVLAN = 0x8020697e - SIOCSHIWAT = 0x80047300 - SIOCSIF6LOWPAN = 0x802069c4 - SIOCSIFADDR = 0x8020690c - SIOCSIFALTMTU = 0x80206945 - SIOCSIFASYNCMAP = 0x8020697d - SIOCSIFBOND = 0x80206946 - SIOCSIFBRDADDR = 0x80206913 - SIOCSIFCAP = 0x8020695a - SIOCSIFDSTADDR = 0x8020690e - SIOCSIFFLAGS = 0x80206910 - SIOCSIFGENERIC = 0x80206939 - SIOCSIFKPI = 0x80206986 - SIOCSIFLLADDR = 0x8020693c - SIOCSIFMAC = 0x80206983 - SIOCSIFMEDIA = 0xc0206937 - SIOCSIFMETRIC = 0x80206918 - SIOCSIFMTU = 0x80206934 - SIOCSIFNETMASK = 0x80206916 - SIOCSIFPHYADDR = 0x8040693e - SIOCSIFPHYS = 0x80206936 - SIOCSIFVLAN = 0x8020697e - SIOCSLOWAT = 0x80047302 - SIOCSPGRP = 0x80047308 - SOCK_DGRAM = 0x2 - SOCK_MAXADDRLEN = 0xff - SOCK_RAW = 0x3 - SOCK_RDM = 0x4 - SOCK_SEQPACKET = 0x5 - SOCK_STREAM = 0x1 - SOL_LOCAL = 0x0 - SOL_SOCKET = 0xffff - SOMAXCONN = 0x80 - SO_ACCEPTCONN = 0x2 - SO_BROADCAST = 0x20 - SO_DEBUG = 0x1 - SO_DONTROUTE = 0x10 - SO_DONTTRUNC = 0x2000 - SO_ERROR = 0x1007 - SO_KEEPALIVE = 0x8 - SO_LABEL = 0x1010 - SO_LINGER = 0x80 - SO_LINGER_SEC = 0x1080 - SO_NETSVC_MARKING_LEVEL = 0x1119 - SO_NET_SERVICE_TYPE = 0x1116 - SO_NKE = 0x1021 - SO_NOADDRERR = 0x1023 - SO_NOSIGPIPE = 0x1022 - SO_NOTIFYCONFLICT = 0x1026 - SO_NP_EXTENSIONS = 0x1083 - SO_NREAD = 0x1020 - SO_NUMRCVPKT = 0x1112 - SO_NWRITE = 0x1024 - SO_OOBINLINE = 0x100 - SO_PEERLABEL = 0x1011 - SO_RANDOMPORT = 0x1082 - SO_RCVBUF = 0x1002 - SO_RCVLOWAT = 0x1004 - SO_RCVTIMEO = 0x1006 - SO_REUSEADDR = 0x4 - SO_REUSEPORT = 0x200 - SO_REUSESHAREUID = 0x1025 - SO_SNDBUF = 0x1001 - SO_SNDLOWAT = 0x1003 - SO_SNDTIMEO = 0x1005 - SO_TIMESTAMP = 0x400 - SO_TIMESTAMP_MONOTONIC = 0x800 - SO_TYPE = 0x1008 - SO_UPCALLCLOSEWAIT = 0x1027 - SO_USELOOPBACK = 0x40 - SO_WANTMORE = 0x4000 - SO_WANTOOBFLAG = 0x8000 - S_IEXEC = 0x40 - S_IFBLK = 0x6000 - S_IFCHR = 0x2000 - S_IFDIR = 0x4000 - S_IFIFO = 0x1000 - S_IFLNK = 0xa000 - S_IFMT = 0xf000 - S_IFREG = 0x8000 - S_IFSOCK = 0xc000 - S_IFWHT = 0xe000 - S_IREAD = 0x100 - S_IRGRP = 0x20 - S_IROTH = 0x4 - S_IRUSR = 0x100 - S_IRWXG = 0x38 - S_IRWXO = 0x7 - S_IRWXU = 0x1c0 - S_ISGID = 0x400 - S_ISTXT = 0x200 - S_ISUID = 0x800 - S_ISVTX = 0x200 - S_IWGRP = 0x10 - S_IWOTH = 0x2 - S_IWRITE = 0x80 - S_IWUSR = 0x80 - S_IXGRP = 0x8 - S_IXOTH = 0x1 - S_IXUSR = 0x40 - TAB0 = 0x0 - TAB1 = 0x400 - TAB2 = 0x800 - TAB3 = 0x4 - TABDLY = 0xc04 - TCIFLUSH = 0x1 - TCIOFF = 0x3 - TCIOFLUSH = 0x3 - TCION = 0x4 - TCOFLUSH = 0x2 - TCOOFF = 0x1 - TCOON = 0x2 - TCP_CONNECTIONTIMEOUT = 0x20 - TCP_CONNECTION_INFO = 0x106 - TCP_ENABLE_ECN = 0x104 - TCP_FASTOPEN = 0x105 - TCP_KEEPALIVE = 0x10 - TCP_KEEPCNT = 0x102 - TCP_KEEPINTVL = 0x101 - TCP_MAXHLEN = 0x3c - TCP_MAXOLEN = 0x28 - TCP_MAXSEG = 0x2 - TCP_MAXWIN = 0xffff - TCP_MAX_SACK = 0x4 - TCP_MAX_WINSHIFT = 0xe - TCP_MINMSS = 0xd8 - TCP_MSS = 0x200 - TCP_NODELAY = 0x1 - TCP_NOOPT = 0x8 - TCP_NOPUSH = 0x4 - TCP_NOTSENT_LOWAT = 0x201 - TCP_RXT_CONNDROPTIME = 0x80 - TCP_RXT_FINDROP = 0x100 - TCP_SENDMOREACKS = 0x103 - TCSAFLUSH = 0x2 - TIOCCBRK = 0x2000747a - TIOCCDTR = 0x20007478 - TIOCCONS = 0x80047462 - TIOCDCDTIMESTAMP = 0x40107458 - TIOCDRAIN = 0x2000745e - TIOCDSIMICROCODE = 0x20007455 - TIOCEXCL = 0x2000740d - TIOCEXT = 0x80047460 - TIOCFLUSH = 0x80047410 - TIOCGDRAINWAIT = 0x40047456 - TIOCGETA = 0x40487413 - TIOCGETD = 0x4004741a - TIOCGPGRP = 0x40047477 - TIOCGWINSZ = 0x40087468 - TIOCIXOFF = 0x20007480 - TIOCIXON = 0x20007481 - TIOCMBIC = 0x8004746b - TIOCMBIS = 0x8004746c - TIOCMGDTRWAIT = 0x4004745a - TIOCMGET = 0x4004746a - TIOCMODG = 0x40047403 - TIOCMODS = 0x80047404 - TIOCMSDTRWAIT = 0x8004745b - TIOCMSET = 0x8004746d - TIOCM_CAR = 0x40 - TIOCM_CD = 0x40 - TIOCM_CTS = 0x20 - TIOCM_DSR = 0x100 - TIOCM_DTR = 0x2 - TIOCM_LE = 0x1 - TIOCM_RI = 0x80 - TIOCM_RNG = 0x80 - TIOCM_RTS = 0x4 - TIOCM_SR = 0x10 - TIOCM_ST = 0x8 - TIOCNOTTY = 0x20007471 - TIOCNXCL = 0x2000740e - TIOCOUTQ = 0x40047473 - TIOCPKT = 0x80047470 - TIOCPKT_DATA = 0x0 - TIOCPKT_DOSTOP = 0x20 - TIOCPKT_FLUSHREAD = 0x1 - TIOCPKT_FLUSHWRITE = 0x2 - TIOCPKT_IOCTL = 0x40 - TIOCPKT_NOSTOP = 0x10 - TIOCPKT_START = 0x8 - TIOCPKT_STOP = 0x4 - TIOCPTYGNAME = 0x40807453 - TIOCPTYGRANT = 0x20007454 - TIOCPTYUNLK = 0x20007452 - TIOCREMOTE = 0x80047469 - TIOCSBRK = 0x2000747b - TIOCSCONS = 0x20007463 - TIOCSCTTY = 0x20007461 - TIOCSDRAINWAIT = 0x80047457 - TIOCSDTR = 0x20007479 - TIOCSETA = 0x80487414 - TIOCSETAF = 0x80487416 - TIOCSETAW = 0x80487415 - TIOCSETD = 0x8004741b - TIOCSIG = 0x2000745f - TIOCSPGRP = 0x80047476 - TIOCSTART = 0x2000746e - TIOCSTAT = 0x20007465 - TIOCSTI = 0x80017472 - TIOCSTOP = 0x2000746f - TIOCSWINSZ = 0x80087467 - TIOCTIMESTAMP = 0x40107459 - TIOCUCNTL = 0x80047466 - TOSTOP = 0x400000 - VDISCARD = 0xf - VDSUSP = 0xb - VEOF = 0x0 - VEOL = 0x1 - VEOL2 = 0x2 - VERASE = 0x3 - VINTR = 0x8 - VKILL = 0x5 - VLNEXT = 0xe - VMIN = 0x10 - VM_LOADAVG = 0x2 - VM_MACHFACTOR = 0x4 - VM_MAXID = 0x6 - VM_METER = 0x1 - VM_SWAPUSAGE = 0x5 - VQUIT = 0x9 - VREPRINT = 0x6 - VSTART = 0xc - VSTATUS = 0x12 - VSTOP = 0xd - VSUSP = 0xa - VT0 = 0x0 - VT1 = 0x10000 - VTDLY = 0x10000 - VTIME = 0x11 - VWERASE = 0x4 - WCONTINUED = 0x10 - WCOREFLAG = 0x80 - WEXITED = 0x4 - WNOHANG = 0x1 - WNOWAIT = 0x20 - WORDSIZE = 0x40 - WSTOPPED = 0x8 - WUNTRACED = 0x2 - XATTR_CREATE = 0x2 - XATTR_NODEFAULT = 0x10 - XATTR_NOFOLLOW = 0x1 - XATTR_NOSECURITY = 0x8 - XATTR_REPLACE = 0x4 - XATTR_SHOWCOMPRESSION = 0x20 + AF_APPLETALK = 0x10 + AF_CCITT = 0xa + AF_CHAOS = 0x5 + AF_CNT = 0x15 + AF_COIP = 0x14 + AF_DATAKIT = 0x9 + AF_DECnet = 0xc + AF_DLI = 0xd + AF_E164 = 0x1c + AF_ECMA = 0x8 + AF_HYLINK = 0xf + AF_IEEE80211 = 0x25 + AF_IMPLINK = 0x3 + AF_INET = 0x2 + AF_INET6 = 0x1e + AF_IPX = 0x17 + AF_ISDN = 0x1c + AF_ISO = 0x7 + AF_LAT = 0xe + AF_LINK = 0x12 + AF_LOCAL = 0x1 + AF_MAX = 0x29 + AF_NATM = 0x1f + AF_NDRV = 0x1b + AF_NETBIOS = 0x21 + AF_NS = 0x6 + AF_OSI = 0x7 + AF_PPP = 0x22 + AF_PUP = 0x4 + AF_RESERVED_36 = 0x24 + AF_ROUTE = 0x11 + AF_SIP = 0x18 + AF_SNA = 0xb + AF_SYSTEM = 0x20 + AF_SYS_CONTROL = 0x2 + AF_UNIX = 0x1 + AF_UNSPEC = 0x0 + AF_UTUN = 0x26 + AF_VSOCK = 0x28 + ALTWERASE = 0x200 + ATTR_BIT_MAP_COUNT = 0x5 + ATTR_CMN_ACCESSMASK = 0x20000 + ATTR_CMN_ACCTIME = 0x1000 + ATTR_CMN_ADDEDTIME = 0x10000000 + ATTR_CMN_BKUPTIME = 0x2000 + ATTR_CMN_CHGTIME = 0x800 + ATTR_CMN_CRTIME = 0x200 + ATTR_CMN_DATA_PROTECT_FLAGS = 0x40000000 + ATTR_CMN_DEVID = 0x2 + ATTR_CMN_DOCUMENT_ID = 0x100000 + ATTR_CMN_ERROR = 0x20000000 + ATTR_CMN_EXTENDED_SECURITY = 0x400000 + ATTR_CMN_FILEID = 0x2000000 + ATTR_CMN_FLAGS = 0x40000 + ATTR_CMN_FNDRINFO = 0x4000 + ATTR_CMN_FSID = 0x4 + ATTR_CMN_FULLPATH = 0x8000000 + ATTR_CMN_GEN_COUNT = 0x80000 + ATTR_CMN_GRPID = 0x10000 + ATTR_CMN_GRPUUID = 0x1000000 + ATTR_CMN_MODTIME = 0x400 + ATTR_CMN_NAME = 0x1 + ATTR_CMN_NAMEDATTRCOUNT = 0x80000 + ATTR_CMN_NAMEDATTRLIST = 0x100000 + ATTR_CMN_OBJID = 0x20 + ATTR_CMN_OBJPERMANENTID = 0x40 + ATTR_CMN_OBJTAG = 0x10 + ATTR_CMN_OBJTYPE = 0x8 + ATTR_CMN_OWNERID = 0x8000 + ATTR_CMN_PARENTID = 0x4000000 + ATTR_CMN_PAROBJID = 0x80 + ATTR_CMN_RETURNED_ATTRS = 0x80000000 + ATTR_CMN_SCRIPT = 0x100 + ATTR_CMN_SETMASK = 0x51c7ff00 + ATTR_CMN_USERACCESS = 0x200000 + ATTR_CMN_UUID = 0x800000 + ATTR_CMN_VALIDMASK = 0xffffffff + ATTR_CMN_VOLSETMASK = 0x6700 + ATTR_FILE_ALLOCSIZE = 0x4 + ATTR_FILE_CLUMPSIZE = 0x10 + ATTR_FILE_DATAALLOCSIZE = 0x400 + ATTR_FILE_DATAEXTENTS = 0x800 + ATTR_FILE_DATALENGTH = 0x200 + ATTR_FILE_DEVTYPE = 0x20 + ATTR_FILE_FILETYPE = 0x40 + ATTR_FILE_FORKCOUNT = 0x80 + ATTR_FILE_FORKLIST = 0x100 + ATTR_FILE_IOBLOCKSIZE = 0x8 + ATTR_FILE_LINKCOUNT = 0x1 + ATTR_FILE_RSRCALLOCSIZE = 0x2000 + ATTR_FILE_RSRCEXTENTS = 0x4000 + ATTR_FILE_RSRCLENGTH = 0x1000 + ATTR_FILE_SETMASK = 0x20 + ATTR_FILE_TOTALSIZE = 0x2 + ATTR_FILE_VALIDMASK = 0x37ff + ATTR_VOL_ALLOCATIONCLUMP = 0x40 + ATTR_VOL_ATTRIBUTES = 0x40000000 + ATTR_VOL_CAPABILITIES = 0x20000 + ATTR_VOL_DIRCOUNT = 0x400 + ATTR_VOL_ENCODINGSUSED = 0x10000 + ATTR_VOL_FILECOUNT = 0x200 + ATTR_VOL_FSTYPE = 0x1 + ATTR_VOL_INFO = 0x80000000 + ATTR_VOL_IOBLOCKSIZE = 0x80 + ATTR_VOL_MAXOBJCOUNT = 0x800 + ATTR_VOL_MINALLOCATION = 0x20 + ATTR_VOL_MOUNTEDDEVICE = 0x8000 + ATTR_VOL_MOUNTFLAGS = 0x4000 + ATTR_VOL_MOUNTPOINT = 0x1000 + ATTR_VOL_NAME = 0x2000 + ATTR_VOL_OBJCOUNT = 0x100 + ATTR_VOL_QUOTA_SIZE = 0x10000000 + ATTR_VOL_RESERVED_SIZE = 0x20000000 + ATTR_VOL_SETMASK = 0x80002000 + ATTR_VOL_SIGNATURE = 0x2 + ATTR_VOL_SIZE = 0x4 + ATTR_VOL_SPACEAVAIL = 0x10 + ATTR_VOL_SPACEFREE = 0x8 + ATTR_VOL_SPACEUSED = 0x800000 + ATTR_VOL_UUID = 0x40000 + ATTR_VOL_VALIDMASK = 0xf087ffff + B0 = 0x0 + B110 = 0x6e + B115200 = 0x1c200 + B1200 = 0x4b0 + B134 = 0x86 + B14400 = 0x3840 + B150 = 0x96 + B1800 = 0x708 + B19200 = 0x4b00 + B200 = 0xc8 + B230400 = 0x38400 + B2400 = 0x960 + B28800 = 0x7080 + B300 = 0x12c + B38400 = 0x9600 + B4800 = 0x12c0 + B50 = 0x32 + B57600 = 0xe100 + B600 = 0x258 + B7200 = 0x1c20 + B75 = 0x4b + B76800 = 0x12c00 + B9600 = 0x2580 + BIOCFLUSH = 0x20004268 + BIOCGBLEN = 0x40044266 + BIOCGDLT = 0x4004426a + BIOCGDLTLIST = 0xc00c4279 + BIOCGETIF = 0x4020426b + BIOCGHDRCMPLT = 0x40044274 + BIOCGRSIG = 0x40044272 + BIOCGRTIMEOUT = 0x4010426e + BIOCGSEESENT = 0x40044276 + BIOCGSTATS = 0x4008426f + BIOCIMMEDIATE = 0x80044270 + BIOCPROMISC = 0x20004269 + BIOCSBLEN = 0xc0044266 + BIOCSDLT = 0x80044278 + BIOCSETF = 0x80104267 + BIOCSETFNR = 0x8010427e + BIOCSETIF = 0x8020426c + BIOCSHDRCMPLT = 0x80044275 + BIOCSRSIG = 0x80044273 + BIOCSRTIMEOUT = 0x8010426d + BIOCSSEESENT = 0x80044277 + BIOCVERSION = 0x40044271 + BPF_A = 0x10 + BPF_ABS = 0x20 + BPF_ADD = 0x0 + BPF_ALIGNMENT = 0x4 + BPF_ALU = 0x4 + BPF_AND = 0x50 + BPF_B = 0x10 + BPF_DIV = 0x30 + BPF_H = 0x8 + BPF_IMM = 0x0 + BPF_IND = 0x40 + BPF_JA = 0x0 + BPF_JEQ = 0x10 + BPF_JGE = 0x30 + BPF_JGT = 0x20 + BPF_JMP = 0x5 + BPF_JSET = 0x40 + BPF_K = 0x0 + BPF_LD = 0x0 + BPF_LDX = 0x1 + BPF_LEN = 0x80 + BPF_LSH = 0x60 + BPF_MAJOR_VERSION = 0x1 + BPF_MAXBUFSIZE = 0x80000 + BPF_MAXINSNS = 0x200 + BPF_MEM = 0x60 + BPF_MEMWORDS = 0x10 + BPF_MINBUFSIZE = 0x20 + BPF_MINOR_VERSION = 0x1 + BPF_MISC = 0x7 + BPF_MSH = 0xa0 + BPF_MUL = 0x20 + BPF_NEG = 0x80 + BPF_OR = 0x40 + BPF_RELEASE = 0x30bb6 + BPF_RET = 0x6 + BPF_RSH = 0x70 + BPF_ST = 0x2 + BPF_STX = 0x3 + BPF_SUB = 0x10 + BPF_TAX = 0x0 + BPF_TXA = 0x80 + BPF_W = 0x0 + BPF_X = 0x8 + BRKINT = 0x2 + BS0 = 0x0 + BS1 = 0x8000 + BSDLY = 0x8000 + CFLUSH = 0xf + CLOCAL = 0x8000 + CLOCK_MONOTONIC = 0x6 + CLOCK_MONOTONIC_RAW = 0x4 + CLOCK_MONOTONIC_RAW_APPROX = 0x5 + CLOCK_PROCESS_CPUTIME_ID = 0xc + CLOCK_REALTIME = 0x0 + CLOCK_THREAD_CPUTIME_ID = 0x10 + CLOCK_UPTIME_RAW = 0x8 + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 + CR3 = 0x3000 + CRDLY = 0x3000 + CREAD = 0x800 + CRTSCTS = 0x30000 + CS5 = 0x0 + CS6 = 0x100 + CS7 = 0x200 + CS8 = 0x300 + CSIZE = 0x300 + CSTART = 0x11 + CSTATUS = 0x14 + CSTOP = 0x13 + CSTOPB = 0x400 + CSUSP = 0x1a + CTLIOCGINFO = 0xc0644e03 + CTL_HW = 0x6 + CTL_KERN = 0x1 + CTL_MAXNAME = 0xc + CTL_NET = 0x4 + DLT_A429 = 0xb8 + DLT_A653_ICM = 0xb9 + DLT_AIRONET_HEADER = 0x78 + DLT_AOS = 0xde + DLT_APPLE_IP_OVER_IEEE1394 = 0x8a + DLT_ARCNET = 0x7 + DLT_ARCNET_LINUX = 0x81 + DLT_ATM_CLIP = 0x13 + DLT_ATM_RFC1483 = 0xb + DLT_AURORA = 0x7e + DLT_AX25 = 0x3 + DLT_AX25_KISS = 0xca + DLT_BACNET_MS_TP = 0xa5 + DLT_BLUETOOTH_HCI_H4 = 0xbb + DLT_BLUETOOTH_HCI_H4_WITH_PHDR = 0xc9 + DLT_CAN20B = 0xbe + DLT_CAN_SOCKETCAN = 0xe3 + DLT_CHAOS = 0x5 + DLT_CHDLC = 0x68 + DLT_CISCO_IOS = 0x76 + DLT_C_HDLC = 0x68 + DLT_C_HDLC_WITH_DIR = 0xcd + DLT_DBUS = 0xe7 + DLT_DECT = 0xdd + DLT_DOCSIS = 0x8f + DLT_DVB_CI = 0xeb + DLT_ECONET = 0x73 + DLT_EN10MB = 0x1 + DLT_EN3MB = 0x2 + DLT_ENC = 0x6d + DLT_ERF = 0xc5 + DLT_ERF_ETH = 0xaf + DLT_ERF_POS = 0xb0 + DLT_FC_2 = 0xe0 + DLT_FC_2_WITH_FRAME_DELIMS = 0xe1 + DLT_FDDI = 0xa + DLT_FLEXRAY = 0xd2 + DLT_FRELAY = 0x6b + DLT_FRELAY_WITH_DIR = 0xce + DLT_GCOM_SERIAL = 0xad + DLT_GCOM_T1E1 = 0xac + DLT_GPF_F = 0xab + DLT_GPF_T = 0xaa + DLT_GPRS_LLC = 0xa9 + DLT_GSMTAP_ABIS = 0xda + DLT_GSMTAP_UM = 0xd9 + DLT_HHDLC = 0x79 + DLT_IBM_SN = 0x92 + DLT_IBM_SP = 0x91 + DLT_IEEE802 = 0x6 + DLT_IEEE802_11 = 0x69 + DLT_IEEE802_11_RADIO = 0x7f + DLT_IEEE802_11_RADIO_AVS = 0xa3 + DLT_IEEE802_15_4 = 0xc3 + DLT_IEEE802_15_4_LINUX = 0xbf + DLT_IEEE802_15_4_NOFCS = 0xe6 + DLT_IEEE802_15_4_NONASK_PHY = 0xd7 + DLT_IEEE802_16_MAC_CPS = 0xbc + DLT_IEEE802_16_MAC_CPS_RADIO = 0xc1 + DLT_IPFILTER = 0x74 + DLT_IPMB = 0xc7 + DLT_IPMB_LINUX = 0xd1 + DLT_IPNET = 0xe2 + DLT_IPOIB = 0xf2 + DLT_IPV4 = 0xe4 + DLT_IPV6 = 0xe5 + DLT_IP_OVER_FC = 0x7a + DLT_JUNIPER_ATM1 = 0x89 + DLT_JUNIPER_ATM2 = 0x87 + DLT_JUNIPER_ATM_CEMIC = 0xee + DLT_JUNIPER_CHDLC = 0xb5 + DLT_JUNIPER_ES = 0x84 + DLT_JUNIPER_ETHER = 0xb2 + DLT_JUNIPER_FIBRECHANNEL = 0xea + DLT_JUNIPER_FRELAY = 0xb4 + DLT_JUNIPER_GGSN = 0x85 + DLT_JUNIPER_ISM = 0xc2 + DLT_JUNIPER_MFR = 0x86 + DLT_JUNIPER_MLFR = 0x83 + DLT_JUNIPER_MLPPP = 0x82 + DLT_JUNIPER_MONITOR = 0xa4 + DLT_JUNIPER_PIC_PEER = 0xae + DLT_JUNIPER_PPP = 0xb3 + DLT_JUNIPER_PPPOE = 0xa7 + DLT_JUNIPER_PPPOE_ATM = 0xa8 + DLT_JUNIPER_SERVICES = 0x88 + DLT_JUNIPER_SRX_E2E = 0xe9 + DLT_JUNIPER_ST = 0xc8 + DLT_JUNIPER_VP = 0xb7 + DLT_JUNIPER_VS = 0xe8 + DLT_LAPB_WITH_DIR = 0xcf + DLT_LAPD = 0xcb + DLT_LIN = 0xd4 + DLT_LINUX_EVDEV = 0xd8 + DLT_LINUX_IRDA = 0x90 + DLT_LINUX_LAPD = 0xb1 + DLT_LINUX_PPP_WITHDIRECTION = 0xa6 + DLT_LINUX_SLL = 0x71 + DLT_LOOP = 0x6c + DLT_LTALK = 0x72 + DLT_MATCHING_MAX = 0x10a + DLT_MATCHING_MIN = 0x68 + DLT_MFR = 0xb6 + DLT_MOST = 0xd3 + DLT_MPEG_2_TS = 0xf3 + DLT_MPLS = 0xdb + DLT_MTP2 = 0x8c + DLT_MTP2_WITH_PHDR = 0x8b + DLT_MTP3 = 0x8d + DLT_MUX27010 = 0xec + DLT_NETANALYZER = 0xf0 + DLT_NETANALYZER_TRANSPARENT = 0xf1 + DLT_NFC_LLCP = 0xf5 + DLT_NFLOG = 0xef + DLT_NG40 = 0xf4 + DLT_NULL = 0x0 + DLT_PCI_EXP = 0x7d + DLT_PFLOG = 0x75 + DLT_PFSYNC = 0x12 + DLT_PPI = 0xc0 + DLT_PPP = 0x9 + DLT_PPP_BSDOS = 0x10 + DLT_PPP_ETHER = 0x33 + DLT_PPP_PPPD = 0xa6 + DLT_PPP_SERIAL = 0x32 + DLT_PPP_WITH_DIR = 0xcc + DLT_PPP_WITH_DIRECTION = 0xa6 + DLT_PRISM_HEADER = 0x77 + DLT_PRONET = 0x4 + DLT_RAIF1 = 0xc6 + DLT_RAW = 0xc + DLT_RIO = 0x7c + DLT_SCCP = 0x8e + DLT_SITA = 0xc4 + DLT_SLIP = 0x8 + DLT_SLIP_BSDOS = 0xf + DLT_STANAG_5066_D_PDU = 0xed + DLT_SUNATM = 0x7b + DLT_SYMANTEC_FIREWALL = 0x63 + DLT_TZSP = 0x80 + DLT_USB = 0xba + DLT_USB_DARWIN = 0x10a + DLT_USB_LINUX = 0xbd + DLT_USB_LINUX_MMAPPED = 0xdc + DLT_USER0 = 0x93 + DLT_USER1 = 0x94 + DLT_USER10 = 0x9d + DLT_USER11 = 0x9e + DLT_USER12 = 0x9f + DLT_USER13 = 0xa0 + DLT_USER14 = 0xa1 + DLT_USER15 = 0xa2 + DLT_USER2 = 0x95 + DLT_USER3 = 0x96 + DLT_USER4 = 0x97 + DLT_USER5 = 0x98 + DLT_USER6 = 0x99 + DLT_USER7 = 0x9a + DLT_USER8 = 0x9b + DLT_USER9 = 0x9c + DLT_WIHART = 0xdf + DLT_X2E_SERIAL = 0xd5 + DLT_X2E_XORAYA = 0xd6 + DT_BLK = 0x6 + DT_CHR = 0x2 + DT_DIR = 0x4 + DT_FIFO = 0x1 + DT_LNK = 0xa + DT_REG = 0x8 + DT_SOCK = 0xc + DT_UNKNOWN = 0x0 + DT_WHT = 0xe + ECHO = 0x8 + ECHOCTL = 0x40 + ECHOE = 0x2 + ECHOK = 0x4 + ECHOKE = 0x1 + ECHONL = 0x10 + ECHOPRT = 0x20 + EVFILT_AIO = -0x3 + EVFILT_EXCEPT = -0xf + EVFILT_FS = -0x9 + EVFILT_MACHPORT = -0x8 + EVFILT_PROC = -0x5 + EVFILT_READ = -0x1 + EVFILT_SIGNAL = -0x6 + EVFILT_SYSCOUNT = 0x11 + EVFILT_THREADMARKER = 0x11 + EVFILT_TIMER = -0x7 + EVFILT_USER = -0xa + EVFILT_VM = -0xc + EVFILT_VNODE = -0x4 + EVFILT_WRITE = -0x2 + EV_ADD = 0x1 + EV_CLEAR = 0x20 + EV_DELETE = 0x2 + EV_DISABLE = 0x8 + EV_DISPATCH = 0x80 + EV_DISPATCH2 = 0x180 + EV_ENABLE = 0x4 + EV_EOF = 0x8000 + EV_ERROR = 0x4000 + EV_FLAG0 = 0x1000 + EV_FLAG1 = 0x2000 + EV_ONESHOT = 0x10 + EV_OOBAND = 0x2000 + EV_POLL = 0x1000 + EV_RECEIPT = 0x40 + EV_SYSFLAGS = 0xf000 + EV_UDATA_SPECIFIC = 0x100 + EV_VANISHED = 0x200 + EXTA = 0x4b00 + EXTB = 0x9600 + EXTPROC = 0x800 + FD_CLOEXEC = 0x1 + FD_SETSIZE = 0x400 + FF0 = 0x0 + FF1 = 0x4000 + FFDLY = 0x4000 + FLUSHO = 0x800000 + FSOPT_ATTR_CMN_EXTENDED = 0x20 + FSOPT_NOFOLLOW = 0x1 + FSOPT_NOINMEMUPDATE = 0x2 + FSOPT_PACK_INVAL_ATTRS = 0x8 + FSOPT_REPORT_FULLSIZE = 0x4 + FSOPT_RETURN_REALDEV = 0x200 + F_ADDFILESIGS = 0x3d + F_ADDFILESIGS_FOR_DYLD_SIM = 0x53 + F_ADDFILESIGS_INFO = 0x67 + F_ADDFILESIGS_RETURN = 0x61 + F_ADDFILESUPPL = 0x68 + F_ADDSIGS = 0x3b + F_ALLOCATEALL = 0x4 + F_ALLOCATECONTIG = 0x2 + F_BARRIERFSYNC = 0x55 + F_CHECK_LV = 0x62 + F_CHKCLEAN = 0x29 + F_DUPFD = 0x0 + F_DUPFD_CLOEXEC = 0x43 + F_FINDSIGS = 0x4e + F_FLUSH_DATA = 0x28 + F_FREEZE_FS = 0x35 + F_FULLFSYNC = 0x33 + F_GETCODEDIR = 0x48 + F_GETFD = 0x1 + F_GETFL = 0x3 + F_GETLK = 0x7 + F_GETLKPID = 0x42 + F_GETNOSIGPIPE = 0x4a + F_GETOWN = 0x5 + F_GETPATH = 0x32 + F_GETPATH_MTMINFO = 0x47 + F_GETPATH_NOFIRMLINK = 0x66 + F_GETPROTECTIONCLASS = 0x3f + F_GETPROTECTIONLEVEL = 0x4d + F_GETSIGSINFO = 0x69 + F_GLOBAL_NOCACHE = 0x37 + F_LOG2PHYS = 0x31 + F_LOG2PHYS_EXT = 0x41 + F_NOCACHE = 0x30 + F_NODIRECT = 0x3e + F_OK = 0x0 + F_PATHPKG_CHECK = 0x34 + F_PEOFPOSMODE = 0x3 + F_PREALLOCATE = 0x2a + F_PUNCHHOLE = 0x63 + F_RDADVISE = 0x2c + F_RDAHEAD = 0x2d + F_RDLCK = 0x1 + F_SETBACKINGSTORE = 0x46 + F_SETFD = 0x2 + F_SETFL = 0x4 + F_SETLK = 0x8 + F_SETLKW = 0x9 + F_SETLKWTIMEOUT = 0xa + F_SETNOSIGPIPE = 0x49 + F_SETOWN = 0x6 + F_SETPROTECTIONCLASS = 0x40 + F_SETSIZE = 0x2b + F_SINGLE_WRITER = 0x4c + F_SPECULATIVE_READ = 0x65 + F_THAW_FS = 0x36 + F_TRANSCODEKEY = 0x4b + F_TRIM_ACTIVE_FILE = 0x64 + F_UNLCK = 0x2 + F_VOLPOSMODE = 0x4 + F_WRLCK = 0x3 + HUPCL = 0x4000 + HW_MACHINE = 0x1 + ICANON = 0x100 + ICMP6_FILTER = 0x12 + ICRNL = 0x100 + IEXTEN = 0x400 + IFF_ALLMULTI = 0x200 + IFF_ALTPHYS = 0x4000 + IFF_BROADCAST = 0x2 + IFF_DEBUG = 0x4 + IFF_LINK0 = 0x1000 + IFF_LINK1 = 0x2000 + IFF_LINK2 = 0x4000 + IFF_LOOPBACK = 0x8 + IFF_MULTICAST = 0x8000 + IFF_NOARP = 0x80 + IFF_NOTRAILERS = 0x20 + IFF_OACTIVE = 0x400 + IFF_POINTOPOINT = 0x10 + IFF_PROMISC = 0x100 + IFF_RUNNING = 0x40 + IFF_SIMPLEX = 0x800 + IFF_UP = 0x1 + IFNAMSIZ = 0x10 + IFT_1822 = 0x2 + IFT_6LOWPAN = 0x40 + IFT_AAL5 = 0x31 + IFT_ARCNET = 0x23 + IFT_ARCNETPLUS = 0x24 + IFT_ATM = 0x25 + IFT_BRIDGE = 0xd1 + IFT_CARP = 0xf8 + IFT_CELLULAR = 0xff + IFT_CEPT = 0x13 + IFT_DS3 = 0x1e + IFT_ENC = 0xf4 + IFT_EON = 0x19 + IFT_ETHER = 0x6 + IFT_FAITH = 0x38 + IFT_FDDI = 0xf + IFT_FRELAY = 0x20 + IFT_FRELAYDCE = 0x2c + IFT_GIF = 0x37 + IFT_HDH1822 = 0x3 + IFT_HIPPI = 0x2f + IFT_HSSI = 0x2e + IFT_HY = 0xe + IFT_IEEE1394 = 0x90 + IFT_IEEE8023ADLAG = 0x88 + IFT_ISDNBASIC = 0x14 + IFT_ISDNPRIMARY = 0x15 + IFT_ISO88022LLC = 0x29 + IFT_ISO88023 = 0x7 + IFT_ISO88024 = 0x8 + IFT_ISO88025 = 0x9 + IFT_ISO88026 = 0xa + IFT_L2VLAN = 0x87 + IFT_LAPB = 0x10 + IFT_LOCALTALK = 0x2a + IFT_LOOP = 0x18 + IFT_MIOX25 = 0x26 + IFT_MODEM = 0x30 + IFT_NSIP = 0x1b + IFT_OTHER = 0x1 + IFT_P10 = 0xc + IFT_P80 = 0xd + IFT_PARA = 0x22 + IFT_PDP = 0xff + IFT_PFLOG = 0xf5 + IFT_PFSYNC = 0xf6 + IFT_PKTAP = 0xfe + IFT_PPP = 0x17 + IFT_PROPMUX = 0x36 + IFT_PROPVIRTUAL = 0x35 + IFT_PTPSERIAL = 0x16 + IFT_RS232 = 0x21 + IFT_SDLC = 0x11 + IFT_SIP = 0x1f + IFT_SLIP = 0x1c + IFT_SMDSDXI = 0x2b + IFT_SMDSICIP = 0x34 + IFT_SONET = 0x27 + IFT_SONETPATH = 0x32 + IFT_SONETVT = 0x33 + IFT_STARLAN = 0xb + IFT_STF = 0x39 + IFT_T1 = 0x12 + IFT_ULTRA = 0x1d + IFT_V35 = 0x2d + IFT_X25 = 0x5 + IFT_X25DDN = 0x4 + IFT_X25PLE = 0x28 + IFT_XETHER = 0x1a + IGNBRK = 0x1 + IGNCR = 0x80 + IGNPAR = 0x4 + IMAXBEL = 0x2000 + INLCR = 0x40 + INPCK = 0x10 + IN_CLASSA_HOST = 0xffffff + IN_CLASSA_MAX = 0x80 + IN_CLASSA_NET = 0xff000000 + IN_CLASSA_NSHIFT = 0x18 + IN_CLASSB_HOST = 0xffff + IN_CLASSB_MAX = 0x10000 + IN_CLASSB_NET = 0xffff0000 + IN_CLASSB_NSHIFT = 0x10 + IN_CLASSC_HOST = 0xff + IN_CLASSC_NET = 0xffffff00 + IN_CLASSC_NSHIFT = 0x8 + IN_CLASSD_HOST = 0xfffffff + IN_CLASSD_NET = 0xf0000000 + IN_CLASSD_NSHIFT = 0x1c + IN_LINKLOCALNETNUM = 0xa9fe0000 + IN_LOOPBACKNET = 0x7f + IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x400473d1 + IPPROTO_3PC = 0x22 + IPPROTO_ADFS = 0x44 + IPPROTO_AH = 0x33 + IPPROTO_AHIP = 0x3d + IPPROTO_APES = 0x63 + IPPROTO_ARGUS = 0xd + IPPROTO_AX25 = 0x5d + IPPROTO_BHA = 0x31 + IPPROTO_BLT = 0x1e + IPPROTO_BRSATMON = 0x4c + IPPROTO_CFTP = 0x3e + IPPROTO_CHAOS = 0x10 + IPPROTO_CMTP = 0x26 + IPPROTO_CPHB = 0x49 + IPPROTO_CPNX = 0x48 + IPPROTO_DDP = 0x25 + IPPROTO_DGP = 0x56 + IPPROTO_DIVERT = 0xfe + IPPROTO_DONE = 0x101 + IPPROTO_DSTOPTS = 0x3c + IPPROTO_EGP = 0x8 + IPPROTO_EMCON = 0xe + IPPROTO_ENCAP = 0x62 + IPPROTO_EON = 0x50 + IPPROTO_ESP = 0x32 + IPPROTO_ETHERIP = 0x61 + IPPROTO_FRAGMENT = 0x2c + IPPROTO_GGP = 0x3 + IPPROTO_GMTP = 0x64 + IPPROTO_GRE = 0x2f + IPPROTO_HELLO = 0x3f + IPPROTO_HMP = 0x14 + IPPROTO_HOPOPTS = 0x0 + IPPROTO_ICMP = 0x1 + IPPROTO_ICMPV6 = 0x3a + IPPROTO_IDP = 0x16 + IPPROTO_IDPR = 0x23 + IPPROTO_IDRP = 0x2d + IPPROTO_IGMP = 0x2 + IPPROTO_IGP = 0x55 + IPPROTO_IGRP = 0x58 + IPPROTO_IL = 0x28 + IPPROTO_INLSP = 0x34 + IPPROTO_INP = 0x20 + IPPROTO_IP = 0x0 + IPPROTO_IPCOMP = 0x6c + IPPROTO_IPCV = 0x47 + IPPROTO_IPEIP = 0x5e + IPPROTO_IPIP = 0x4 + IPPROTO_IPPC = 0x43 + IPPROTO_IPV4 = 0x4 + IPPROTO_IPV6 = 0x29 + IPPROTO_IRTP = 0x1c + IPPROTO_KRYPTOLAN = 0x41 + IPPROTO_LARP = 0x5b + IPPROTO_LEAF1 = 0x19 + IPPROTO_LEAF2 = 0x1a + IPPROTO_MAX = 0x100 + IPPROTO_MAXID = 0x34 + IPPROTO_MEAS = 0x13 + IPPROTO_MHRP = 0x30 + IPPROTO_MICP = 0x5f + IPPROTO_MTP = 0x5c + IPPROTO_MUX = 0x12 + IPPROTO_ND = 0x4d + IPPROTO_NHRP = 0x36 + IPPROTO_NONE = 0x3b + IPPROTO_NSP = 0x1f + IPPROTO_NVPII = 0xb + IPPROTO_OSPFIGP = 0x59 + IPPROTO_PGM = 0x71 + IPPROTO_PIGP = 0x9 + IPPROTO_PIM = 0x67 + IPPROTO_PRM = 0x15 + IPPROTO_PUP = 0xc + IPPROTO_PVP = 0x4b + IPPROTO_RAW = 0xff + IPPROTO_RCCMON = 0xa + IPPROTO_RDP = 0x1b + IPPROTO_ROUTING = 0x2b + IPPROTO_RSVP = 0x2e + IPPROTO_RVD = 0x42 + IPPROTO_SATEXPAK = 0x40 + IPPROTO_SATMON = 0x45 + IPPROTO_SCCSP = 0x60 + IPPROTO_SCTP = 0x84 + IPPROTO_SDRP = 0x2a + IPPROTO_SEP = 0x21 + IPPROTO_SRPC = 0x5a + IPPROTO_ST = 0x7 + IPPROTO_SVMTP = 0x52 + IPPROTO_SWIPE = 0x35 + IPPROTO_TCF = 0x57 + IPPROTO_TCP = 0x6 + IPPROTO_TP = 0x1d + IPPROTO_TPXX = 0x27 + IPPROTO_TRUNK1 = 0x17 + IPPROTO_TRUNK2 = 0x18 + IPPROTO_TTP = 0x54 + IPPROTO_UDP = 0x11 + IPPROTO_VINES = 0x53 + IPPROTO_VISA = 0x46 + IPPROTO_VMTP = 0x51 + IPPROTO_WBEXPAK = 0x4f + IPPROTO_WBMON = 0x4e + IPPROTO_WSN = 0x4a + IPPROTO_XNET = 0xf + IPPROTO_XTP = 0x24 + IPV6_2292DSTOPTS = 0x17 + IPV6_2292HOPLIMIT = 0x14 + IPV6_2292HOPOPTS = 0x16 + IPV6_2292NEXTHOP = 0x15 + IPV6_2292PKTINFO = 0x13 + IPV6_2292PKTOPTIONS = 0x19 + IPV6_2292RTHDR = 0x18 + IPV6_3542DSTOPTS = 0x32 + IPV6_3542HOPLIMIT = 0x2f + IPV6_3542HOPOPTS = 0x31 + IPV6_3542NEXTHOP = 0x30 + IPV6_3542PKTINFO = 0x2e + IPV6_3542RTHDR = 0x33 + IPV6_ADDR_MC_FLAGS_PREFIX = 0x20 + IPV6_ADDR_MC_FLAGS_TRANSIENT = 0x10 + IPV6_ADDR_MC_FLAGS_UNICAST_BASED = 0x30 + IPV6_AUTOFLOWLABEL = 0x3b + IPV6_BINDV6ONLY = 0x1b + IPV6_BOUND_IF = 0x7d + IPV6_CHECKSUM = 0x1a + IPV6_DEFAULT_MULTICAST_HOPS = 0x1 + IPV6_DEFAULT_MULTICAST_LOOP = 0x1 + IPV6_DEFHLIM = 0x40 + IPV6_DONTFRAG = 0x3e + IPV6_DSTOPTS = 0x32 + IPV6_FAITH = 0x1d + IPV6_FLOWINFO_MASK = 0xffffff0f + IPV6_FLOWLABEL_MASK = 0xffff0f00 + IPV6_FLOW_ECN_MASK = 0x3000 + IPV6_FRAGTTL = 0x3c + IPV6_FW_ADD = 0x1e + IPV6_FW_DEL = 0x1f + IPV6_FW_FLUSH = 0x20 + IPV6_FW_GET = 0x22 + IPV6_FW_ZERO = 0x21 + IPV6_HLIMDEC = 0x1 + IPV6_HOPLIMIT = 0x2f + IPV6_HOPOPTS = 0x31 + IPV6_IPSEC_POLICY = 0x1c + IPV6_JOIN_GROUP = 0xc + IPV6_LEAVE_GROUP = 0xd + IPV6_MAXHLIM = 0xff + IPV6_MAXOPTHDR = 0x800 + IPV6_MAXPACKET = 0xffff + IPV6_MAX_GROUP_SRC_FILTER = 0x200 + IPV6_MAX_MEMBERSHIPS = 0xfff + IPV6_MAX_SOCK_SRC_FILTER = 0x80 + IPV6_MIN_MEMBERSHIPS = 0x1f + IPV6_MMTU = 0x500 + IPV6_MSFILTER = 0x4a + IPV6_MULTICAST_HOPS = 0xa + IPV6_MULTICAST_IF = 0x9 + IPV6_MULTICAST_LOOP = 0xb + IPV6_NEXTHOP = 0x30 + IPV6_PATHMTU = 0x2c + IPV6_PKTINFO = 0x2e + IPV6_PORTRANGE = 0xe + IPV6_PORTRANGE_DEFAULT = 0x0 + IPV6_PORTRANGE_HIGH = 0x1 + IPV6_PORTRANGE_LOW = 0x2 + IPV6_PREFER_TEMPADDR = 0x3f + IPV6_RECVDSTOPTS = 0x28 + IPV6_RECVHOPLIMIT = 0x25 + IPV6_RECVHOPOPTS = 0x27 + IPV6_RECVPATHMTU = 0x2b + IPV6_RECVPKTINFO = 0x3d + IPV6_RECVRTHDR = 0x26 + IPV6_RECVTCLASS = 0x23 + IPV6_RTHDR = 0x33 + IPV6_RTHDRDSTOPTS = 0x39 + IPV6_RTHDR_LOOSE = 0x0 + IPV6_RTHDR_STRICT = 0x1 + IPV6_RTHDR_TYPE_0 = 0x0 + IPV6_SOCKOPT_RESERVED1 = 0x3 + IPV6_TCLASS = 0x24 + IPV6_UNICAST_HOPS = 0x4 + IPV6_USE_MIN_MTU = 0x2a + IPV6_V6ONLY = 0x1b + IPV6_VERSION = 0x60 + IPV6_VERSION_MASK = 0xf0 + IP_ADD_MEMBERSHIP = 0xc + IP_ADD_SOURCE_MEMBERSHIP = 0x46 + IP_BLOCK_SOURCE = 0x48 + IP_BOUND_IF = 0x19 + IP_DEFAULT_MULTICAST_LOOP = 0x1 + IP_DEFAULT_MULTICAST_TTL = 0x1 + IP_DF = 0x4000 + IP_DONTFRAG = 0x1c + IP_DROP_MEMBERSHIP = 0xd + IP_DROP_SOURCE_MEMBERSHIP = 0x47 + IP_DUMMYNET_CONFIGURE = 0x3c + IP_DUMMYNET_DEL = 0x3d + IP_DUMMYNET_FLUSH = 0x3e + IP_DUMMYNET_GET = 0x40 + IP_FAITH = 0x16 + IP_FW_ADD = 0x28 + IP_FW_DEL = 0x29 + IP_FW_FLUSH = 0x2a + IP_FW_GET = 0x2c + IP_FW_RESETLOG = 0x2d + IP_FW_ZERO = 0x2b + IP_HDRINCL = 0x2 + IP_IPSEC_POLICY = 0x15 + IP_MAXPACKET = 0xffff + IP_MAX_GROUP_SRC_FILTER = 0x200 + IP_MAX_MEMBERSHIPS = 0xfff + IP_MAX_SOCK_MUTE_FILTER = 0x80 + IP_MAX_SOCK_SRC_FILTER = 0x80 + IP_MF = 0x2000 + IP_MIN_MEMBERSHIPS = 0x1f + IP_MSFILTER = 0x4a + IP_MSS = 0x240 + IP_MULTICAST_IF = 0x9 + IP_MULTICAST_IFINDEX = 0x42 + IP_MULTICAST_LOOP = 0xb + IP_MULTICAST_TTL = 0xa + IP_MULTICAST_VIF = 0xe + IP_NAT__XXX = 0x37 + IP_OFFMASK = 0x1fff + IP_OLD_FW_ADD = 0x32 + IP_OLD_FW_DEL = 0x33 + IP_OLD_FW_FLUSH = 0x34 + IP_OLD_FW_GET = 0x36 + IP_OLD_FW_RESETLOG = 0x38 + IP_OLD_FW_ZERO = 0x35 + IP_OPTIONS = 0x1 + IP_PKTINFO = 0x1a + IP_PORTRANGE = 0x13 + IP_PORTRANGE_DEFAULT = 0x0 + IP_PORTRANGE_HIGH = 0x1 + IP_PORTRANGE_LOW = 0x2 + IP_RECVDSTADDR = 0x7 + IP_RECVIF = 0x14 + IP_RECVOPTS = 0x5 + IP_RECVPKTINFO = 0x1a + IP_RECVRETOPTS = 0x6 + IP_RECVTOS = 0x1b + IP_RECVTTL = 0x18 + IP_RETOPTS = 0x8 + IP_RF = 0x8000 + IP_RSVP_OFF = 0x10 + IP_RSVP_ON = 0xf + IP_RSVP_VIF_OFF = 0x12 + IP_RSVP_VIF_ON = 0x11 + IP_STRIPHDR = 0x17 + IP_TOS = 0x3 + IP_TRAFFIC_MGT_BACKGROUND = 0x41 + IP_TTL = 0x4 + IP_UNBLOCK_SOURCE = 0x49 + ISIG = 0x80 + ISTRIP = 0x20 + IUTF8 = 0x4000 + IXANY = 0x800 + IXOFF = 0x400 + IXON = 0x200 + KERN_HOSTNAME = 0xa + KERN_OSRELEASE = 0x2 + KERN_OSTYPE = 0x1 + KERN_VERSION = 0x4 + LOCAL_PEERCRED = 0x1 + LOCAL_PEEREPID = 0x3 + LOCAL_PEEREUUID = 0x5 + LOCAL_PEERPID = 0x2 + LOCAL_PEERTOKEN = 0x6 + LOCAL_PEERUUID = 0x4 + LOCK_EX = 0x2 + LOCK_NB = 0x4 + LOCK_SH = 0x1 + LOCK_UN = 0x8 + MADV_CAN_REUSE = 0x9 + MADV_DONTNEED = 0x4 + MADV_FREE = 0x5 + MADV_FREE_REUSABLE = 0x7 + MADV_FREE_REUSE = 0x8 + MADV_NORMAL = 0x0 + MADV_PAGEOUT = 0xa + MADV_RANDOM = 0x1 + MADV_SEQUENTIAL = 0x2 + MADV_WILLNEED = 0x3 + MADV_ZERO_WIRED_PAGES = 0x6 + MAP_32BIT = 0x8000 + MAP_ANON = 0x1000 + MAP_ANONYMOUS = 0x1000 + MAP_COPY = 0x2 + MAP_FILE = 0x0 + MAP_FIXED = 0x10 + MAP_HASSEMAPHORE = 0x200 + MAP_JIT = 0x800 + MAP_NOCACHE = 0x400 + MAP_NOEXTEND = 0x100 + MAP_NORESERVE = 0x40 + MAP_PRIVATE = 0x2 + MAP_RENAME = 0x20 + MAP_RESERVED0080 = 0x80 + MAP_RESILIENT_CODESIGN = 0x2000 + MAP_RESILIENT_MEDIA = 0x4000 + MAP_SHARED = 0x1 + MAP_TRANSLATED_ALLOW_EXECUTE = 0x20000 + MAP_UNIX03 = 0x40000 + MCAST_BLOCK_SOURCE = 0x54 + MCAST_EXCLUDE = 0x2 + MCAST_INCLUDE = 0x1 + MCAST_JOIN_GROUP = 0x50 + MCAST_JOIN_SOURCE_GROUP = 0x52 + MCAST_LEAVE_GROUP = 0x51 + MCAST_LEAVE_SOURCE_GROUP = 0x53 + MCAST_UNBLOCK_SOURCE = 0x55 + MCAST_UNDEFINED = 0x0 + MCL_CURRENT = 0x1 + MCL_FUTURE = 0x2 + MNT_ASYNC = 0x40 + MNT_AUTOMOUNTED = 0x400000 + MNT_CMDFLAGS = 0xf0000 + MNT_CPROTECT = 0x80 + MNT_DEFWRITE = 0x2000000 + MNT_DONTBROWSE = 0x100000 + MNT_DOVOLFS = 0x8000 + MNT_DWAIT = 0x4 + MNT_EXPORTED = 0x100 + MNT_EXT_ROOT_DATA_VOL = 0x1 + MNT_FORCE = 0x80000 + MNT_IGNORE_OWNERSHIP = 0x200000 + MNT_JOURNALED = 0x800000 + MNT_LOCAL = 0x1000 + MNT_MULTILABEL = 0x4000000 + MNT_NOATIME = 0x10000000 + MNT_NOBLOCK = 0x20000 + MNT_NODEV = 0x10 + MNT_NOEXEC = 0x4 + MNT_NOSUID = 0x8 + MNT_NOUSERXATTR = 0x1000000 + MNT_NOWAIT = 0x2 + MNT_QUARANTINE = 0x400 + MNT_QUOTA = 0x2000 + MNT_RDONLY = 0x1 + MNT_RELOAD = 0x40000 + MNT_REMOVABLE = 0x200 + MNT_ROOTFS = 0x4000 + MNT_SNAPSHOT = 0x40000000 + MNT_STRICTATIME = 0x80000000 + MNT_SYNCHRONOUS = 0x2 + MNT_UNION = 0x20 + MNT_UNKNOWNPERMISSIONS = 0x200000 + MNT_UPDATE = 0x10000 + MNT_VISFLAGMASK = 0xd7f0f7ff + MNT_WAIT = 0x1 + MSG_CTRUNC = 0x20 + MSG_DONTROUTE = 0x4 + MSG_DONTWAIT = 0x80 + MSG_EOF = 0x100 + MSG_EOR = 0x8 + MSG_FLUSH = 0x400 + MSG_HAVEMORE = 0x2000 + MSG_HOLD = 0x800 + MSG_NEEDSA = 0x10000 + MSG_NOSIGNAL = 0x80000 + MSG_OOB = 0x1 + MSG_PEEK = 0x2 + MSG_RCVMORE = 0x4000 + MSG_SEND = 0x1000 + MSG_TRUNC = 0x10 + MSG_WAITALL = 0x40 + MSG_WAITSTREAM = 0x200 + MS_ASYNC = 0x1 + MS_DEACTIVATE = 0x8 + MS_INVALIDATE = 0x2 + MS_KILLPAGES = 0x4 + MS_SYNC = 0x10 + NAME_MAX = 0xff + NET_RT_DUMP = 0x1 + NET_RT_DUMP2 = 0x7 + NET_RT_FLAGS = 0x2 + NET_RT_FLAGS_PRIV = 0xa + NET_RT_IFLIST = 0x3 + NET_RT_IFLIST2 = 0x6 + NET_RT_MAXID = 0xb + NET_RT_STAT = 0x4 + NET_RT_TRASH = 0x5 + NFDBITS = 0x20 + NL0 = 0x0 + NL1 = 0x100 + NL2 = 0x200 + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 + NOKERNINFO = 0x2000000 + NOTE_ABSOLUTE = 0x8 + NOTE_ATTRIB = 0x8 + NOTE_BACKGROUND = 0x40 + NOTE_CHILD = 0x4 + NOTE_CRITICAL = 0x20 + NOTE_DELETE = 0x1 + NOTE_EXEC = 0x20000000 + NOTE_EXIT = 0x80000000 + NOTE_EXITSTATUS = 0x4000000 + NOTE_EXIT_CSERROR = 0x40000 + NOTE_EXIT_DECRYPTFAIL = 0x10000 + NOTE_EXIT_DETAIL = 0x2000000 + NOTE_EXIT_DETAIL_MASK = 0x70000 + NOTE_EXIT_MEMORY = 0x20000 + NOTE_EXIT_REPARENTED = 0x80000 + NOTE_EXTEND = 0x4 + NOTE_FFAND = 0x40000000 + NOTE_FFCOPY = 0xc0000000 + NOTE_FFCTRLMASK = 0xc0000000 + NOTE_FFLAGSMASK = 0xffffff + NOTE_FFNOP = 0x0 + NOTE_FFOR = 0x80000000 + NOTE_FORK = 0x40000000 + NOTE_FUNLOCK = 0x100 + NOTE_LEEWAY = 0x10 + NOTE_LINK = 0x10 + NOTE_LOWAT = 0x1 + NOTE_MACHTIME = 0x100 + NOTE_MACH_CONTINUOUS_TIME = 0x80 + NOTE_NONE = 0x80 + NOTE_NSECONDS = 0x4 + NOTE_OOB = 0x2 + NOTE_PCTRLMASK = -0x100000 + NOTE_PDATAMASK = 0xfffff + NOTE_REAP = 0x10000000 + NOTE_RENAME = 0x20 + NOTE_REVOKE = 0x40 + NOTE_SECONDS = 0x1 + NOTE_SIGNAL = 0x8000000 + NOTE_TRACK = 0x1 + NOTE_TRACKERR = 0x2 + NOTE_TRIGGER = 0x1000000 + NOTE_USECONDS = 0x2 + NOTE_VM_ERROR = 0x10000000 + NOTE_VM_PRESSURE = 0x80000000 + NOTE_VM_PRESSURE_SUDDEN_TERMINATE = 0x20000000 + NOTE_VM_PRESSURE_TERMINATE = 0x40000000 + NOTE_WRITE = 0x2 + OCRNL = 0x10 + OFDEL = 0x20000 + OFILL = 0x80 + ONLCR = 0x2 + ONLRET = 0x40 + ONOCR = 0x20 + ONOEOT = 0x8 + OPOST = 0x1 + OXTABS = 0x4 + O_ACCMODE = 0x3 + O_ALERT = 0x20000000 + O_APPEND = 0x8 + O_ASYNC = 0x40 + O_CLOEXEC = 0x1000000 + O_CREAT = 0x200 + O_DIRECTORY = 0x100000 + O_DP_GETRAWENCRYPTED = 0x1 + O_DP_GETRAWUNENCRYPTED = 0x2 + O_DSYNC = 0x400000 + O_EVTONLY = 0x8000 + O_EXCL = 0x800 + O_EXLOCK = 0x20 + O_FSYNC = 0x80 + O_NDELAY = 0x4 + O_NOCTTY = 0x20000 + O_NOFOLLOW = 0x100 + O_NOFOLLOW_ANY = 0x20000000 + O_NONBLOCK = 0x4 + O_POPUP = 0x80000000 + O_RDONLY = 0x0 + O_RDWR = 0x2 + O_SHLOCK = 0x10 + O_SYMLINK = 0x200000 + O_SYNC = 0x80 + O_TRUNC = 0x400 + O_WRONLY = 0x1 + PARENB = 0x1000 + PARMRK = 0x8 + PARODD = 0x2000 + PENDIN = 0x20000000 + PRIO_PGRP = 0x1 + PRIO_PROCESS = 0x0 + PRIO_USER = 0x2 + PROT_EXEC = 0x4 + PROT_NONE = 0x0 + PROT_READ = 0x1 + PROT_WRITE = 0x2 + PT_ATTACH = 0xa + PT_ATTACHEXC = 0xe + PT_CONTINUE = 0x7 + PT_DENY_ATTACH = 0x1f + PT_DETACH = 0xb + PT_FIRSTMACH = 0x20 + PT_FORCEQUOTA = 0x1e + PT_KILL = 0x8 + PT_READ_D = 0x2 + PT_READ_I = 0x1 + PT_READ_U = 0x3 + PT_SIGEXC = 0xc + PT_STEP = 0x9 + PT_THUPDATE = 0xd + PT_TRACE_ME = 0x0 + PT_WRITE_D = 0x5 + PT_WRITE_I = 0x4 + PT_WRITE_U = 0x6 + RLIMIT_AS = 0x5 + RLIMIT_CORE = 0x4 + RLIMIT_CPU = 0x0 + RLIMIT_CPU_USAGE_MONITOR = 0x2 + RLIMIT_DATA = 0x2 + RLIMIT_FSIZE = 0x1 + RLIMIT_MEMLOCK = 0x6 + RLIMIT_NOFILE = 0x8 + RLIMIT_NPROC = 0x7 + RLIMIT_RSS = 0x5 + RLIMIT_STACK = 0x3 + RLIM_INFINITY = 0x7fffffffffffffff + RTAX_AUTHOR = 0x6 + RTAX_BRD = 0x7 + RTAX_DST = 0x0 + RTAX_GATEWAY = 0x1 + RTAX_GENMASK = 0x3 + RTAX_IFA = 0x5 + RTAX_IFP = 0x4 + RTAX_MAX = 0x8 + RTAX_NETMASK = 0x2 + RTA_AUTHOR = 0x40 + RTA_BRD = 0x80 + RTA_DST = 0x1 + RTA_GATEWAY = 0x2 + RTA_GENMASK = 0x8 + RTA_IFA = 0x20 + RTA_IFP = 0x10 + RTA_NETMASK = 0x4 + RTF_BLACKHOLE = 0x1000 + RTF_BROADCAST = 0x400000 + RTF_CLONING = 0x100 + RTF_CONDEMNED = 0x2000000 + RTF_DEAD = 0x20000000 + RTF_DELCLONE = 0x80 + RTF_DONE = 0x40 + RTF_DYNAMIC = 0x10 + RTF_GATEWAY = 0x2 + RTF_GLOBAL = 0x40000000 + RTF_HOST = 0x4 + RTF_IFREF = 0x4000000 + RTF_IFSCOPE = 0x1000000 + RTF_LLDATA = 0x400 + RTF_LLINFO = 0x400 + RTF_LOCAL = 0x200000 + RTF_MODIFIED = 0x20 + RTF_MULTICAST = 0x800000 + RTF_NOIFREF = 0x2000 + RTF_PINNED = 0x100000 + RTF_PRCLONING = 0x10000 + RTF_PROTO1 = 0x8000 + RTF_PROTO2 = 0x4000 + RTF_PROTO3 = 0x40000 + RTF_PROXY = 0x8000000 + RTF_REJECT = 0x8 + RTF_ROUTER = 0x10000000 + RTF_STATIC = 0x800 + RTF_UP = 0x1 + RTF_WASCLONED = 0x20000 + RTF_XRESOLVE = 0x200 + RTM_ADD = 0x1 + RTM_CHANGE = 0x3 + RTM_DELADDR = 0xd + RTM_DELETE = 0x2 + RTM_DELMADDR = 0x10 + RTM_GET = 0x4 + RTM_GET2 = 0x14 + RTM_IFINFO = 0xe + RTM_IFINFO2 = 0x12 + RTM_LOCK = 0x8 + RTM_LOSING = 0x5 + RTM_MISS = 0x7 + RTM_NEWADDR = 0xc + RTM_NEWMADDR = 0xf + RTM_NEWMADDR2 = 0x13 + RTM_OLDADD = 0x9 + RTM_OLDDEL = 0xa + RTM_REDIRECT = 0x6 + RTM_RESOLVE = 0xb + RTM_RTTUNIT = 0xf4240 + RTM_VERSION = 0x5 + RTV_EXPIRE = 0x4 + RTV_HOPCOUNT = 0x2 + RTV_MTU = 0x1 + RTV_RPIPE = 0x8 + RTV_RTT = 0x40 + RTV_RTTVAR = 0x80 + RTV_SPIPE = 0x10 + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 + SCM_TIMESTAMP_MONOTONIC = 0x4 + SEEK_CUR = 0x1 + SEEK_DATA = 0x4 + SEEK_END = 0x2 + SEEK_HOLE = 0x3 + SEEK_SET = 0x0 + SHUT_RD = 0x0 + SHUT_RDWR = 0x2 + SHUT_WR = 0x1 + SIOCADDMULTI = 0x80206931 + SIOCAIFADDR = 0x8040691a + SIOCARPIPLL = 0xc0206928 + SIOCATMARK = 0x40047307 + SIOCAUTOADDR = 0xc0206926 + SIOCAUTONETMASK = 0x80206927 + SIOCDELMULTI = 0x80206932 + SIOCDIFADDR = 0x80206919 + SIOCDIFPHYADDR = 0x80206941 + SIOCGDRVSPEC = 0xc028697b + SIOCGETVLAN = 0xc020697f + SIOCGHIWAT = 0x40047301 + SIOCGIF6LOWPAN = 0xc02069c5 + SIOCGIFADDR = 0xc0206921 + SIOCGIFALTMTU = 0xc0206948 + SIOCGIFASYNCMAP = 0xc020697c + SIOCGIFBOND = 0xc0206947 + SIOCGIFBRDADDR = 0xc0206923 + SIOCGIFCAP = 0xc020695b + SIOCGIFCONF = 0xc00c6924 + SIOCGIFDEVMTU = 0xc0206944 + SIOCGIFDSTADDR = 0xc0206922 + SIOCGIFFLAGS = 0xc0206911 + SIOCGIFFUNCTIONALTYPE = 0xc02069ad + SIOCGIFGENERIC = 0xc020693a + SIOCGIFKPI = 0xc0206987 + SIOCGIFMAC = 0xc0206982 + SIOCGIFMEDIA = 0xc02c6938 + SIOCGIFMETRIC = 0xc0206917 + SIOCGIFMTU = 0xc0206933 + SIOCGIFNETMASK = 0xc0206925 + SIOCGIFPDSTADDR = 0xc0206940 + SIOCGIFPHYS = 0xc0206935 + SIOCGIFPSRCADDR = 0xc020693f + SIOCGIFSTATUS = 0xc331693d + SIOCGIFVLAN = 0xc020697f + SIOCGIFWAKEFLAGS = 0xc0206988 + SIOCGIFXMEDIA = 0xc02c6948 + SIOCGLOWAT = 0x40047303 + SIOCGPGRP = 0x40047309 + SIOCIFCREATE = 0xc0206978 + SIOCIFCREATE2 = 0xc020697a + SIOCIFDESTROY = 0x80206979 + SIOCIFGCLONERS = 0xc0106981 + SIOCRSLVMULTI = 0xc010693b + SIOCSDRVSPEC = 0x8028697b + SIOCSETVLAN = 0x8020697e + SIOCSHIWAT = 0x80047300 + SIOCSIF6LOWPAN = 0x802069c4 + SIOCSIFADDR = 0x8020690c + SIOCSIFALTMTU = 0x80206945 + SIOCSIFASYNCMAP = 0x8020697d + SIOCSIFBOND = 0x80206946 + SIOCSIFBRDADDR = 0x80206913 + SIOCSIFCAP = 0x8020695a + SIOCSIFDSTADDR = 0x8020690e + SIOCSIFFLAGS = 0x80206910 + SIOCSIFGENERIC = 0x80206939 + SIOCSIFKPI = 0x80206986 + SIOCSIFLLADDR = 0x8020693c + SIOCSIFMAC = 0x80206983 + SIOCSIFMEDIA = 0xc0206937 + SIOCSIFMETRIC = 0x80206918 + SIOCSIFMTU = 0x80206934 + SIOCSIFNETMASK = 0x80206916 + SIOCSIFPHYADDR = 0x8040693e + SIOCSIFPHYS = 0x80206936 + SIOCSIFVLAN = 0x8020697e + SIOCSLOWAT = 0x80047302 + SIOCSPGRP = 0x80047308 + SOCK_DGRAM = 0x2 + SOCK_MAXADDRLEN = 0xff + SOCK_RAW = 0x3 + SOCK_RDM = 0x4 + SOCK_SEQPACKET = 0x5 + SOCK_STREAM = 0x1 + SOL_LOCAL = 0x0 + SOL_SOCKET = 0xffff + SOMAXCONN = 0x80 + SO_ACCEPTCONN = 0x2 + SO_BROADCAST = 0x20 + SO_DEBUG = 0x1 + SO_DONTROUTE = 0x10 + SO_DONTTRUNC = 0x2000 + SO_ERROR = 0x1007 + SO_KEEPALIVE = 0x8 + SO_LABEL = 0x1010 + SO_LINGER = 0x80 + SO_LINGER_SEC = 0x1080 + SO_NETSVC_MARKING_LEVEL = 0x1119 + SO_NET_SERVICE_TYPE = 0x1116 + SO_NKE = 0x1021 + SO_NOADDRERR = 0x1023 + SO_NOSIGPIPE = 0x1022 + SO_NOTIFYCONFLICT = 0x1026 + SO_NP_EXTENSIONS = 0x1083 + SO_NREAD = 0x1020 + SO_NUMRCVPKT = 0x1112 + SO_NWRITE = 0x1024 + SO_OOBINLINE = 0x100 + SO_PEERLABEL = 0x1011 + SO_RANDOMPORT = 0x1082 + SO_RCVBUF = 0x1002 + SO_RCVLOWAT = 0x1004 + SO_RCVTIMEO = 0x1006 + SO_REUSEADDR = 0x4 + SO_REUSEPORT = 0x200 + SO_REUSESHAREUID = 0x1025 + SO_SNDBUF = 0x1001 + SO_SNDLOWAT = 0x1003 + SO_SNDTIMEO = 0x1005 + SO_TIMESTAMP = 0x400 + SO_TIMESTAMP_MONOTONIC = 0x800 + SO_TRACKER_ATTRIBUTE_FLAGS_APP_APPROVED = 0x1 + SO_TRACKER_ATTRIBUTE_FLAGS_DOMAIN_SHORT = 0x4 + SO_TRACKER_ATTRIBUTE_FLAGS_TRACKER = 0x2 + SO_TRACKER_TRANSPARENCY_VERSION = 0x3 + SO_TYPE = 0x1008 + SO_UPCALLCLOSEWAIT = 0x1027 + SO_USELOOPBACK = 0x40 + SO_WANTMORE = 0x4000 + SO_WANTOOBFLAG = 0x8000 + S_IEXEC = 0x40 + S_IFBLK = 0x6000 + S_IFCHR = 0x2000 + S_IFDIR = 0x4000 + S_IFIFO = 0x1000 + S_IFLNK = 0xa000 + S_IFMT = 0xf000 + S_IFREG = 0x8000 + S_IFSOCK = 0xc000 + S_IFWHT = 0xe000 + S_IREAD = 0x100 + S_IRGRP = 0x20 + S_IROTH = 0x4 + S_IRUSR = 0x100 + S_IRWXG = 0x38 + S_IRWXO = 0x7 + S_IRWXU = 0x1c0 + S_ISGID = 0x400 + S_ISTXT = 0x200 + S_ISUID = 0x800 + S_ISVTX = 0x200 + S_IWGRP = 0x10 + S_IWOTH = 0x2 + S_IWRITE = 0x80 + S_IWUSR = 0x80 + S_IXGRP = 0x8 + S_IXOTH = 0x1 + S_IXUSR = 0x40 + TAB0 = 0x0 + TAB1 = 0x400 + TAB2 = 0x800 + TAB3 = 0x4 + TABDLY = 0xc04 + TCIFLUSH = 0x1 + TCIOFF = 0x3 + TCIOFLUSH = 0x3 + TCION = 0x4 + TCOFLUSH = 0x2 + TCOOFF = 0x1 + TCOON = 0x2 + TCPOPT_CC = 0xb + TCPOPT_CCECHO = 0xd + TCPOPT_CCNEW = 0xc + TCPOPT_EOL = 0x0 + TCPOPT_FASTOPEN = 0x22 + TCPOPT_MAXSEG = 0x2 + TCPOPT_NOP = 0x1 + TCPOPT_SACK = 0x5 + TCPOPT_SACK_HDR = 0x1010500 + TCPOPT_SACK_PERMITTED = 0x4 + TCPOPT_SACK_PERMIT_HDR = 0x1010402 + TCPOPT_SIGNATURE = 0x13 + TCPOPT_TIMESTAMP = 0x8 + TCPOPT_TSTAMP_HDR = 0x101080a + TCPOPT_WINDOW = 0x3 + TCP_CONNECTIONTIMEOUT = 0x20 + TCP_CONNECTION_INFO = 0x106 + TCP_ENABLE_ECN = 0x104 + TCP_FASTOPEN = 0x105 + TCP_KEEPALIVE = 0x10 + TCP_KEEPCNT = 0x102 + TCP_KEEPINTVL = 0x101 + TCP_MAXHLEN = 0x3c + TCP_MAXOLEN = 0x28 + TCP_MAXSEG = 0x2 + TCP_MAXWIN = 0xffff + TCP_MAX_SACK = 0x4 + TCP_MAX_WINSHIFT = 0xe + TCP_MINMSS = 0xd8 + TCP_MSS = 0x200 + TCP_NODELAY = 0x1 + TCP_NOOPT = 0x8 + TCP_NOPUSH = 0x4 + TCP_NOTSENT_LOWAT = 0x201 + TCP_RXT_CONNDROPTIME = 0x80 + TCP_RXT_FINDROP = 0x100 + TCP_SENDMOREACKS = 0x103 + TCSAFLUSH = 0x2 + TIOCCBRK = 0x2000747a + TIOCCDTR = 0x20007478 + TIOCCONS = 0x80047462 + TIOCDCDTIMESTAMP = 0x40107458 + TIOCDRAIN = 0x2000745e + TIOCDSIMICROCODE = 0x20007455 + TIOCEXCL = 0x2000740d + TIOCEXT = 0x80047460 + TIOCFLUSH = 0x80047410 + TIOCGDRAINWAIT = 0x40047456 + TIOCGETA = 0x40487413 + TIOCGETD = 0x4004741a + TIOCGPGRP = 0x40047477 + TIOCGWINSZ = 0x40087468 + TIOCIXOFF = 0x20007480 + TIOCIXON = 0x20007481 + TIOCMBIC = 0x8004746b + TIOCMBIS = 0x8004746c + TIOCMGDTRWAIT = 0x4004745a + TIOCMGET = 0x4004746a + TIOCMODG = 0x40047403 + TIOCMODS = 0x80047404 + TIOCMSDTRWAIT = 0x8004745b + TIOCMSET = 0x8004746d + TIOCM_CAR = 0x40 + TIOCM_CD = 0x40 + TIOCM_CTS = 0x20 + TIOCM_DSR = 0x100 + TIOCM_DTR = 0x2 + TIOCM_LE = 0x1 + TIOCM_RI = 0x80 + TIOCM_RNG = 0x80 + TIOCM_RTS = 0x4 + TIOCM_SR = 0x10 + TIOCM_ST = 0x8 + TIOCNOTTY = 0x20007471 + TIOCNXCL = 0x2000740e + TIOCOUTQ = 0x40047473 + TIOCPKT = 0x80047470 + TIOCPKT_DATA = 0x0 + TIOCPKT_DOSTOP = 0x20 + TIOCPKT_FLUSHREAD = 0x1 + TIOCPKT_FLUSHWRITE = 0x2 + TIOCPKT_IOCTL = 0x40 + TIOCPKT_NOSTOP = 0x10 + TIOCPKT_START = 0x8 + TIOCPKT_STOP = 0x4 + TIOCPTYGNAME = 0x40807453 + TIOCPTYGRANT = 0x20007454 + TIOCPTYUNLK = 0x20007452 + TIOCREMOTE = 0x80047469 + TIOCSBRK = 0x2000747b + TIOCSCONS = 0x20007463 + TIOCSCTTY = 0x20007461 + TIOCSDRAINWAIT = 0x80047457 + TIOCSDTR = 0x20007479 + TIOCSETA = 0x80487414 + TIOCSETAF = 0x80487416 + TIOCSETAW = 0x80487415 + TIOCSETD = 0x8004741b + TIOCSIG = 0x2000745f + TIOCSPGRP = 0x80047476 + TIOCSTART = 0x2000746e + TIOCSTAT = 0x20007465 + TIOCSTI = 0x80017472 + TIOCSTOP = 0x2000746f + TIOCSWINSZ = 0x80087467 + TIOCTIMESTAMP = 0x40107459 + TIOCUCNTL = 0x80047466 + TOSTOP = 0x400000 + VDISCARD = 0xf + VDSUSP = 0xb + VEOF = 0x0 + VEOL = 0x1 + VEOL2 = 0x2 + VERASE = 0x3 + VINTR = 0x8 + VKILL = 0x5 + VLNEXT = 0xe + VMADDR_CID_ANY = 0xffffffff + VMADDR_CID_HOST = 0x2 + VMADDR_CID_HYPERVISOR = 0x0 + VMADDR_CID_RESERVED = 0x1 + VMADDR_PORT_ANY = 0xffffffff + VMIN = 0x10 + VM_LOADAVG = 0x2 + VM_MACHFACTOR = 0x4 + VM_MAXID = 0x6 + VM_METER = 0x1 + VM_SWAPUSAGE = 0x5 + VQUIT = 0x9 + VREPRINT = 0x6 + VSTART = 0xc + VSTATUS = 0x12 + VSTOP = 0xd + VSUSP = 0xa + VT0 = 0x0 + VT1 = 0x10000 + VTDLY = 0x10000 + VTIME = 0x11 + VWERASE = 0x4 + WCONTINUED = 0x10 + WCOREFLAG = 0x80 + WEXITED = 0x4 + WNOHANG = 0x1 + WNOWAIT = 0x20 + WORDSIZE = 0x40 + WSTOPPED = 0x8 + WUNTRACED = 0x2 + XATTR_CREATE = 0x2 + XATTR_NODEFAULT = 0x10 + XATTR_NOFOLLOW = 0x1 + XATTR_NOSECURITY = 0x8 + XATTR_REPLACE = 0x4 + XATTR_SHOWCOMPRESSION = 0x20 ) // Errors diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go index 8894c4af44..78d4b85ece 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go @@ -1333,6 +1333,20 @@ const ( KEY_SPEC_THREAD_KEYRING = -0x1 KEY_SPEC_USER_KEYRING = -0x4 KEY_SPEC_USER_SESSION_KEYRING = -0x5 + LANDLOCK_ACCESS_FS_EXECUTE = 0x1 + LANDLOCK_ACCESS_FS_MAKE_BLOCK = 0x800 + LANDLOCK_ACCESS_FS_MAKE_CHAR = 0x40 + LANDLOCK_ACCESS_FS_MAKE_DIR = 0x80 + LANDLOCK_ACCESS_FS_MAKE_FIFO = 0x400 + LANDLOCK_ACCESS_FS_MAKE_REG = 0x100 + LANDLOCK_ACCESS_FS_MAKE_SOCK = 0x200 + LANDLOCK_ACCESS_FS_MAKE_SYM = 0x1000 + LANDLOCK_ACCESS_FS_READ_DIR = 0x8 + LANDLOCK_ACCESS_FS_READ_FILE = 0x4 + LANDLOCK_ACCESS_FS_REMOVE_DIR = 0x10 + LANDLOCK_ACCESS_FS_REMOVE_FILE = 0x20 + LANDLOCK_ACCESS_FS_WRITE_FILE = 0x2 + LANDLOCK_CREATE_RULESET_VERSION = 0x1 LINUX_REBOOT_CMD_CAD_OFF = 0x0 LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef LINUX_REBOOT_CMD_HALT = 0xcdef0123 @@ -1383,6 +1397,8 @@ const ( MADV_NOHUGEPAGE = 0xf MADV_NORMAL = 0x0 MADV_PAGEOUT = 0x15 + MADV_POPULATE_READ = 0x16 + MADV_POPULATE_WRITE = 0x17 MADV_RANDOM = 0x1 MADV_REMOVE = 0x9 MADV_SEQUENTIAL = 0x2 diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go index d4efe8d457..0ae0ed4cb8 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go @@ -734,6 +734,65 @@ var libc_sendfile_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func shmat(id int, addr uintptr, flag int) (ret uintptr, err error) { + r0, _, e1 := syscall_syscall(libc_shmat_trampoline_addr, uintptr(id), uintptr(addr), uintptr(flag)) + ret = uintptr(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_shmat_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_shmat shmat "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) { + r0, _, e1 := syscall_syscall(libc_shmctl_trampoline_addr, uintptr(id), uintptr(cmd), uintptr(unsafe.Pointer(buf))) + result = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_shmctl_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_shmctl shmctl "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmdt(addr uintptr) (err error) { + _, _, e1 := syscall_syscall(libc_shmdt_trampoline_addr, uintptr(addr), 0, 0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_shmdt_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_shmdt shmdt "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmget(key int, size int, flag int) (id int, err error) { + r0, _, e1 := syscall_syscall(libc_shmget_trampoline_addr, uintptr(key), uintptr(size), uintptr(flag)) + id = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_shmget_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_shmget shmget "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func Access(path string, mode uint32) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s index bc169c2ab9..eac6ca806f 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s @@ -264,6 +264,30 @@ TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 DATA ·libc_sendfile_trampoline_addr(SB)/8, $libc_sendfile_trampoline<>(SB) +TEXT libc_shmat_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_shmat(SB) + +GLOBL ·libc_shmat_trampoline_addr(SB), RODATA, $8 +DATA ·libc_shmat_trampoline_addr(SB)/8, $libc_shmat_trampoline<>(SB) + +TEXT libc_shmctl_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_shmctl(SB) + +GLOBL ·libc_shmctl_trampoline_addr(SB), RODATA, $8 +DATA ·libc_shmctl_trampoline_addr(SB)/8, $libc_shmctl_trampoline<>(SB) + +TEXT libc_shmdt_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_shmdt(SB) + +GLOBL ·libc_shmdt_trampoline_addr(SB), RODATA, $8 +DATA ·libc_shmdt_trampoline_addr(SB)/8, $libc_shmdt_trampoline<>(SB) + +TEXT libc_shmget_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_shmget(SB) + +GLOBL ·libc_shmget_trampoline_addr(SB), RODATA, $8 +DATA ·libc_shmget_trampoline_addr(SB)/8, $libc_shmget_trampoline<>(SB) + TEXT libc_access_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_access(SB) diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go index f2ee2bd33b..cf71be3edb 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go @@ -734,6 +734,65 @@ var libc_sendfile_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func shmat(id int, addr uintptr, flag int) (ret uintptr, err error) { + r0, _, e1 := syscall_syscall(libc_shmat_trampoline_addr, uintptr(id), uintptr(addr), uintptr(flag)) + ret = uintptr(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_shmat_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_shmat shmat "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) { + r0, _, e1 := syscall_syscall(libc_shmctl_trampoline_addr, uintptr(id), uintptr(cmd), uintptr(unsafe.Pointer(buf))) + result = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_shmctl_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_shmctl shmctl "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmdt(addr uintptr) (err error) { + _, _, e1 := syscall_syscall(libc_shmdt_trampoline_addr, uintptr(addr), 0, 0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_shmdt_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_shmdt shmdt "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmget(key int, size int, flag int) (id int, err error) { + r0, _, e1 := syscall_syscall(libc_shmget_trampoline_addr, uintptr(key), uintptr(size), uintptr(flag)) + id = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_shmget_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_shmget shmget "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func Access(path string, mode uint32) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s index 33e19776db..4ebcf21758 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s @@ -264,6 +264,30 @@ TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 DATA ·libc_sendfile_trampoline_addr(SB)/8, $libc_sendfile_trampoline<>(SB) +TEXT libc_shmat_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_shmat(SB) + +GLOBL ·libc_shmat_trampoline_addr(SB), RODATA, $8 +DATA ·libc_shmat_trampoline_addr(SB)/8, $libc_shmat_trampoline<>(SB) + +TEXT libc_shmctl_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_shmctl(SB) + +GLOBL ·libc_shmctl_trampoline_addr(SB), RODATA, $8 +DATA ·libc_shmctl_trampoline_addr(SB)/8, $libc_shmctl_trampoline<>(SB) + +TEXT libc_shmdt_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_shmdt(SB) + +GLOBL ·libc_shmdt_trampoline_addr(SB), RODATA, $8 +DATA ·libc_shmdt_trampoline_addr(SB)/8, $libc_shmdt_trampoline<>(SB) + +TEXT libc_shmget_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_shmget(SB) + +GLOBL ·libc_shmget_trampoline_addr(SB), RODATA, $8 +DATA ·libc_shmget_trampoline_addr(SB)/8, $libc_shmget_trampoline<>(SB) + TEXT libc_access_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_access(SB) diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go index 2dbe3da7a0..4f5da1f54f 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go @@ -110,6 +110,16 @@ func openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err e // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func pipe2(p *[2]_C_int, flags int) (err error) { + _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error) { r0, _, e1 := Syscall6(SYS_PPOLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)), 0, 0) n = int(r0) @@ -1945,8 +1955,63 @@ func ProcessVMWritev(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags u // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pipe2(p *[2]_C_int, flags int) (err error) { - _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0) +func PidfdOpen(pid int, flags int) (fd int, err error) { + r0, _, e1 := Syscall(SYS_PIDFD_OPEN, uintptr(pid), uintptr(flags), 0) + fd = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func PidfdGetfd(pidfd int, targetfd int, flags int) (fd int, err error) { + r0, _, e1 := Syscall(SYS_PIDFD_GETFD, uintptr(pidfd), uintptr(targetfd), uintptr(flags)) + fd = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmat(id int, addr uintptr, flag int) (ret uintptr, err error) { + r0, _, e1 := Syscall(SYS_SHMAT, uintptr(id), uintptr(addr), uintptr(flag)) + ret = uintptr(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) { + r0, _, e1 := Syscall(SYS_SHMCTL, uintptr(id), uintptr(cmd), uintptr(unsafe.Pointer(buf))) + result = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmdt(addr uintptr) (err error) { + _, _, e1 := Syscall(SYS_SHMDT, uintptr(addr), 0, 0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func shmget(key int, size int, flag int) (id int, err error) { + r0, _, e1 := Syscall(SYS_SHMGET, uintptr(key), uintptr(size), uintptr(flag)) + id = int(r0) if e1 != 0 { err = errnoErr(e1) } diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_386.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_386.go index e37096e4de..ff90c81e73 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_386.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_386.go @@ -46,37 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pipe(p *[2]_C_int) (err error) { - _, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -181,17 +150,6 @@ func Getuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func InotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Ioperm(from int, num int, on int) (err error) { _, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on)) if e1 != 0 { @@ -566,14 +524,3 @@ func utimes(path string, times *[2]Timeval) (err error) { } return } - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_amd64.go index 9919d8486d..fa7d3dbe4e 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_amd64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_amd64.go @@ -46,27 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -191,17 +170,6 @@ func Getuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func inotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Ioperm(from int, num int, on int) (err error) { _, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on)) if e1 != 0 { @@ -711,27 +679,6 @@ func utimes(path string, times *[2]Timeval) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pipe(p *[2]_C_int) (err error) { - _, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func kexecFileLoad(kernelFd int, initrdFd int, cmdlineLen int, cmdline string, flags int) (err error) { var _p0 *byte _p0, err = BytePtrFromString(cmdline) diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_arm.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_arm.go index 076754d48d..654f91530f 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_arm.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_arm.go @@ -46,16 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pipe(p *[2]_C_int) (err error) { - _, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) fd = int(r0) @@ -235,27 +225,6 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -340,17 +309,6 @@ func Getuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func InotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Lchown(path string, uid int, gid int) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) @@ -681,17 +639,6 @@ func setrlimit(resource int, rlim *rlimit32) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func armSyncFileRange(fd int, flags int, off int64, n int64) (err error) { _, _, e1 := Syscall6(SYS_ARM_SYNC_FILE_RANGE, uintptr(fd), uintptr(flags), uintptr(off), uintptr(off>>32), uintptr(n), uintptr(n>>32)) if e1 != 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_mips.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_mips.go index 4703cf3c33..6d15528853 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_mips.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_mips.go @@ -46,27 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -544,17 +523,6 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func InotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Ioperm(from int, num int, on int) (err error) { _, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on)) if e1 != 0 { @@ -706,18 +674,6 @@ func Pause() (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pipe() (p1 int, p2 int, err error) { - r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0) - p1 = int(r0) - p2 = int(r1) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error) { r0, _, e1 := Syscall6(SYS_MMAP2, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flags), uintptr(fd), uintptr(pageOffset)) xaddr = uintptr(r0) @@ -746,14 +702,3 @@ func setrlimit(resource int, rlim *rlimit32) (err error) { } return } - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64.go index a134f9a4d2..1e20d72df2 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64.go @@ -46,27 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -717,14 +696,3 @@ func stat(path string, st *stat_t) (err error) { } return } - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64le.go index b1fff2d946..82b5e2d9ed 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64le.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64le.go @@ -46,27 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -717,14 +696,3 @@ func stat(path string, st *stat_t) (err error) { } return } - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_mipsle.go index d13d6da01e..a0440c1d43 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_mipsle.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_mipsle.go @@ -46,27 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -544,17 +523,6 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func InotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Ioperm(from int, num int, on int) (err error) { _, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on)) if e1 != 0 { @@ -706,18 +674,6 @@ func Pause() (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pipe() (p1 int, p2 int, err error) { - r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0) - p1 = int(r0) - p2 = int(r1) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error) { r0, _, e1 := Syscall6(SYS_MMAP2, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flags), uintptr(fd), uintptr(pageOffset)) xaddr = uintptr(r0) @@ -746,14 +702,3 @@ func setrlimit(resource int, rlim *rlimit32) (err error) { } return } - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc.go index 927cf1a00f..5864b9ca64 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc.go @@ -46,27 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -161,17 +140,6 @@ func Getuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func InotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Ioperm(from int, num int, on int) (err error) { _, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on)) if e1 != 0 { @@ -717,27 +685,6 @@ func setrlimit(resource int, rlim *rlimit32) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pipe(p *[2]_C_int) (err error) { - _, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func syncFileRange2(fd int, flags int, off int64, n int64) (err error) { _, _, e1 := Syscall6(SYS_SYNC_FILE_RANGE2, uintptr(fd), uintptr(flags), uintptr(off>>32), uintptr(off), uintptr(n>>32), uintptr(n)) if e1 != 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go index da8ec03966..beeb49e342 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go @@ -46,27 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -191,17 +170,6 @@ func Getuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func InotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Ioperm(from int, num int, on int) (err error) { _, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on)) if e1 != 0 { @@ -763,27 +731,6 @@ func utimes(path string, times *[2]Timeval) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pipe(p *[2]_C_int) (err error) { - _, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func syncFileRange2(fd int, flags int, off int64, n int64) (err error) { _, _, e1 := Syscall6(SYS_SYNC_FILE_RANGE2, uintptr(fd), uintptr(flags), uintptr(off), uintptr(n), 0, 0) if e1 != 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go index 083f493bb6..53139b82c7 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go @@ -46,27 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -191,17 +170,6 @@ func Getuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func InotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Ioperm(from int, num int, on int) (err error) { _, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on)) if e1 != 0 { @@ -763,27 +731,6 @@ func utimes(path string, times *[2]Timeval) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pipe(p *[2]_C_int) (err error) { - _, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func syncFileRange2(fd int, flags int, off int64, n int64) (err error) { _, _, e1 := Syscall6(SYS_SYNC_FILE_RANGE2, uintptr(fd), uintptr(flags), uintptr(off), uintptr(n), 0, 0) if e1 != 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_s390x.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_s390x.go index bb347407d3..202add37d1 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_s390x.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_s390x.go @@ -46,27 +46,6 @@ func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func EpollCreate(size int) (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { var _p0 unsafe.Pointer if len(events) > 0 { @@ -191,17 +170,6 @@ func Getuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func InotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Lchown(path string, uid int, gid int) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) @@ -553,17 +521,6 @@ func utimes(path string, times *[2]Timeval) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func kexecFileLoad(kernelFd int, initrdFd int, cmdlineLen int, cmdline string, flags int) (err error) { var _p0 *byte _p0, err = BytePtrFromString(cmdline) diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go index 8edc517e1e..2ab268c343 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go @@ -73,16 +73,6 @@ func Fadvise(fd int, offset int64, length int64, advice int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func dup2(oldfd int, newfd int) (err error) { - _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Fchown(fd int, uid int, gid int) (err error) { _, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid)) if e1 != 0 { @@ -180,17 +170,6 @@ func Getuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func InotifyInit() (fd int, err error) { - r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0) - fd = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Lchown(path string, uid int, gid int) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) @@ -718,24 +697,3 @@ func utimes(path string, times *[2]Timeval) (err error) { } return } - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func pipe(p *[2]_C_int) (err error) { - _, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { - r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) - n = int(r0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go index 4c8dc0ba2e..7efe5ccba3 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go @@ -209,6 +209,92 @@ type RawSockaddrCtl struct { Sc_reserved [5]uint32 } +type RawSockaddrVM struct { + Len uint8 + Family uint8 + Reserved1 uint16 + Port uint32 + Cid uint32 +} + +type XVSockPCB struct { + Xv_len uint32 + Xv_vsockpp uint64 + Xvp_local_cid uint32 + Xvp_local_port uint32 + Xvp_remote_cid uint32 + Xvp_remote_port uint32 + Xvp_rxcnt uint32 + Xvp_txcnt uint32 + Xvp_peer_rxhiwat uint32 + Xvp_peer_rxcnt uint32 + Xvp_last_pid int32 + Xvp_gencnt uint64 + Xv_socket XSocket + _ [4]byte +} + +type XSocket struct { + Xso_len uint32 + Xso_so uint32 + So_type int16 + So_options int16 + So_linger int16 + So_state int16 + So_pcb uint32 + Xso_protocol int32 + Xso_family int32 + So_qlen int16 + So_incqlen int16 + So_qlimit int16 + So_timeo int16 + So_error uint16 + So_pgid int32 + So_oobmark uint32 + So_rcv XSockbuf + So_snd XSockbuf + So_uid uint32 +} + +type XSocket64 struct { + Xso_len uint32 + _ [8]byte + So_type int16 + So_options int16 + So_linger int16 + So_state int16 + _ [8]byte + Xso_protocol int32 + Xso_family int32 + So_qlen int16 + So_incqlen int16 + So_qlimit int16 + So_timeo int16 + So_error uint16 + So_pgid int32 + So_oobmark uint32 + So_rcv XSockbuf + So_snd XSockbuf + So_uid uint32 +} + +type XSockbuf struct { + Cc uint32 + Hiwat uint32 + Mbcnt uint32 + Mbmax uint32 + Lowat int32 + Flags int16 + Timeo int16 +} + +type XVSockPgen struct { + Len uint32 + Count uint64 + Gen uint64 + Sogen uint64 +} + type _Socklen uint32 type Xucred struct { @@ -287,6 +373,11 @@ const ( SizeofSockaddrUnix = 0x6a SizeofSockaddrDatalink = 0x14 SizeofSockaddrCtl = 0x20 + SizeofSockaddrVM = 0xc + SizeofXvsockpcb = 0xa8 + SizeofXSocket = 0x64 + SizeofXSockbuf = 0x18 + SizeofXVSockPgen = 0x20 SizeofXucred = 0x4c SizeofLinger = 0x8 SizeofIovec = 0x10 @@ -639,3 +730,39 @@ type Ucred struct { Ngroups int16 Groups [16]uint32 } + +type SysvIpcPerm struct { + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint16 + _ uint16 + _ int32 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint64 + Lpid int32 + Cpid int32 + Nattch uint16 + _ [34]byte +} + +const ( + IPC_CREAT = 0x200 + IPC_EXCL = 0x400 + IPC_NOWAIT = 0x800 + IPC_PRIVATE = 0x0 +) + +const ( + IPC_RMID = 0x0 + IPC_SET = 0x1 + IPC_STAT = 0x2 +) + +const ( + SHM_RDONLY = 0x1000 + SHM_RND = 0x2000 +) diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go index 96f0e6ae2a..b23a2efe81 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go @@ -209,6 +209,92 @@ type RawSockaddrCtl struct { Sc_reserved [5]uint32 } +type RawSockaddrVM struct { + Len uint8 + Family uint8 + Reserved1 uint16 + Port uint32 + Cid uint32 +} + +type XVSockPCB struct { + Xv_len uint32 + Xv_vsockpp uint64 + Xvp_local_cid uint32 + Xvp_local_port uint32 + Xvp_remote_cid uint32 + Xvp_remote_port uint32 + Xvp_rxcnt uint32 + Xvp_txcnt uint32 + Xvp_peer_rxhiwat uint32 + Xvp_peer_rxcnt uint32 + Xvp_last_pid int32 + Xvp_gencnt uint64 + Xv_socket XSocket + _ [4]byte +} + +type XSocket struct { + Xso_len uint32 + Xso_so uint32 + So_type int16 + So_options int16 + So_linger int16 + So_state int16 + So_pcb uint32 + Xso_protocol int32 + Xso_family int32 + So_qlen int16 + So_incqlen int16 + So_qlimit int16 + So_timeo int16 + So_error uint16 + So_pgid int32 + So_oobmark uint32 + So_rcv XSockbuf + So_snd XSockbuf + So_uid uint32 +} + +type XSocket64 struct { + Xso_len uint32 + _ [8]byte + So_type int16 + So_options int16 + So_linger int16 + So_state int16 + _ [8]byte + Xso_protocol int32 + Xso_family int32 + So_qlen int16 + So_incqlen int16 + So_qlimit int16 + So_timeo int16 + So_error uint16 + So_pgid int32 + So_oobmark uint32 + So_rcv XSockbuf + So_snd XSockbuf + So_uid uint32 +} + +type XSockbuf struct { + Cc uint32 + Hiwat uint32 + Mbcnt uint32 + Mbmax uint32 + Lowat int32 + Flags int16 + Timeo int16 +} + +type XVSockPgen struct { + Len uint32 + Count uint64 + Gen uint64 + Sogen uint64 +} + type _Socklen uint32 type Xucred struct { @@ -287,6 +373,11 @@ const ( SizeofSockaddrUnix = 0x6a SizeofSockaddrDatalink = 0x14 SizeofSockaddrCtl = 0x20 + SizeofSockaddrVM = 0xc + SizeofXvsockpcb = 0xa8 + SizeofXSocket = 0x64 + SizeofXSockbuf = 0x18 + SizeofXVSockPgen = 0x20 SizeofXucred = 0x4c SizeofLinger = 0x8 SizeofIovec = 0x10 @@ -639,3 +730,39 @@ type Ucred struct { Ngroups int16 Groups [16]uint32 } + +type SysvIpcPerm struct { + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint16 + _ uint16 + _ int32 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint64 + Lpid int32 + Cpid int32 + Nattch uint16 + _ [34]byte +} + +const ( + IPC_CREAT = 0x200 + IPC_EXCL = 0x400 + IPC_NOWAIT = 0x800 + IPC_PRIVATE = 0x0 +) + +const ( + IPC_RMID = 0x0 + IPC_SET = 0x1 + IPC_STAT = 0x2 +) + +const ( + SHM_RDONLY = 0x1000 + SHM_RND = 0x2000 +) diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go index 1f99c024af..4eec078e52 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go +++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go @@ -31,6 +31,8 @@ type Timeval struct { Usec int32 } +type Time_t int32 + type Rusage struct { Utime Timeval Stime Timeval diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go index ddf0305a5d..7622904a53 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go @@ -31,6 +31,8 @@ type Timeval struct { Usec int64 } +type Time_t int64 + type Rusage struct { Utime Timeval Stime Timeval diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go index dce0a5c80c..19223ce8ec 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go +++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go @@ -33,6 +33,8 @@ type Timeval struct { _ [4]byte } +type Time_t int32 + type Rusage struct { Utime Timeval Stime Timeval diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go index e232447025..8e3e33f679 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go @@ -31,6 +31,8 @@ type Timeval struct { Usec int64 } +type Time_t int64 + type Rusage struct { Utime Timeval Stime Timeval diff --git a/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go index 236f37ef6f..4c485261d6 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go @@ -13,6 +13,8 @@ const ( I_STR = 0x5308 I_POP = 0x5303 I_PUSH = 0x5302 + I_LINK = 0x530c + I_UNLINK = 0x530d I_PLINK = 0x5316 I_PUNLINK = 0x5317 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go index 4b73bb3b63..249ecfcd4c 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go @@ -3923,3 +3923,36 @@ const ( NFC_SDP_ATTR_URI = 0x1 NFC_SDP_ATTR_SAP = 0x2 ) + +type LandlockRulesetAttr struct { + Access_fs uint64 +} + +type LandlockPathBeneathAttr struct { + Allowed_access uint64 + Parent_fd int32 +} + +const ( + LANDLOCK_RULE_PATH_BENEATH = 0x1 +) + +const ( + IPC_CREAT = 0x200 + IPC_EXCL = 0x400 + IPC_NOWAIT = 0x800 + IPC_PRIVATE = 0x0 + + ipc_64 = 0x100 +) + +const ( + IPC_RMID = 0x0 + IPC_SET = 0x1 + IPC_STAT = 0x2 +) + +const ( + SHM_RDONLY = 0x1000 + SHM_RND = 0x2000 +) diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go index 72f2e96f32..eeeb9aa39a 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go @@ -635,3 +635,36 @@ const ( PPS_GETCAP = 0x800470a3 PPS_FETCH = 0xc00470a4 ) + +const ( + PIDFD_NONBLOCK = 0x800 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint16 + _ [2]uint8 + Seq uint16 + _ uint16 + _ uint32 + _ uint32 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint32 + Atime uint32 + Atime_high uint32 + Dtime uint32 + Dtime_high uint32 + Ctime uint32 + Ctime_high uint32 + Cpid int32 + Lpid int32 + Nattch uint32 + _ uint32 + _ uint32 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go index d5f018d13d..d30e1155cc 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go @@ -653,3 +653,33 @@ const ( PPS_GETCAP = 0x800870a3 PPS_FETCH = 0xc00870a4 ) + +const ( + PIDFD_NONBLOCK = 0x800 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + _ [0]uint8 + Seq uint16 + _ uint16 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint64 + Atime int64 + Dtime int64 + Ctime int64 + Cpid int32 + Lpid int32 + Nattch uint64 + _ uint64 + _ uint64 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go index 675446d936..69d0297520 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go @@ -630,3 +630,36 @@ const ( PPS_GETCAP = 0x800470a3 PPS_FETCH = 0xc00470a4 ) + +const ( + PIDFD_NONBLOCK = 0x800 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint16 + _ [2]uint8 + Seq uint16 + _ uint16 + _ uint32 + _ uint32 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint32 + Atime uint32 + Atime_high uint32 + Dtime uint32 + Dtime_high uint32 + Ctime uint32 + Ctime_high uint32 + Cpid int32 + Lpid int32 + Nattch uint32 + _ uint32 + _ uint32 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go index 711d0711cd..28a0455bc9 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go @@ -632,3 +632,33 @@ const ( PPS_GETCAP = 0x800870a3 PPS_FETCH = 0xc00870a4 ) + +const ( + PIDFD_NONBLOCK = 0x800 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + _ [0]uint8 + Seq uint16 + _ uint16 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint64 + Atime int64 + Dtime int64 + Ctime int64 + Cpid int32 + Lpid int32 + Nattch uint64 + _ uint64 + _ uint64 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go index c1131c7411..64a845483d 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go @@ -636,3 +636,35 @@ const ( PPS_GETCAP = 0x400470a3 PPS_FETCH = 0xc00470a4 ) + +const ( + PIDFD_NONBLOCK = 0x80 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + _ [0]uint8 + Seq uint16 + _ uint16 + _ uint32 + _ uint32 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint32 + Atime uint32 + Dtime uint32 + Ctime uint32 + Cpid int32 + Lpid int32 + Nattch uint32 + Atime_high uint16 + Dtime_high uint16 + Ctime_high uint16 + _ uint16 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go index 91d5574ff9..a1b7dee412 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go @@ -635,3 +635,33 @@ const ( PPS_GETCAP = 0x400870a3 PPS_FETCH = 0xc00870a4 ) + +const ( + PIDFD_NONBLOCK = 0x80 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + _ [0]uint8 + Seq uint16 + _ uint16 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint64 + Atime int64 + Dtime int64 + Ctime int64 + Cpid int32 + Lpid int32 + Nattch uint64 + _ uint64 + _ uint64 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go index 5d721497b7..936fa6a266 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go @@ -635,3 +635,33 @@ const ( PPS_GETCAP = 0x400870a3 PPS_FETCH = 0xc00870a4 ) + +const ( + PIDFD_NONBLOCK = 0x80 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + _ [0]uint8 + Seq uint16 + _ uint16 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint64 + Atime int64 + Dtime int64 + Ctime int64 + Cpid int32 + Lpid int32 + Nattch uint64 + _ uint64 + _ uint64 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go index a5addd06aa..5dd546fbf0 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go @@ -636,3 +636,35 @@ const ( PPS_GETCAP = 0x400470a3 PPS_FETCH = 0xc00470a4 ) + +const ( + PIDFD_NONBLOCK = 0x80 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + _ [0]uint8 + Seq uint16 + _ uint16 + _ uint32 + _ uint32 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint32 + Atime uint32 + Dtime uint32 + Ctime uint32 + Cpid int32 + Lpid int32 + Nattch uint32 + Atime_high uint16 + Dtime_high uint16 + Ctime_high uint16 + _ uint16 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go index bb6b03dfcb..947b32e434 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go @@ -642,3 +642,37 @@ const ( PPS_GETCAP = 0x400470a3 PPS_FETCH = 0xc00470a4 ) + +const ( + PIDFD_NONBLOCK = 0x800 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + Seq uint32 + _ uint32 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Atime_high uint32 + Atime uint32 + Dtime_high uint32 + Dtime uint32 + Ctime_high uint32 + Ctime uint32 + _ uint32 + Segsz uint32 + Cpid int32 + Lpid int32 + Nattch uint32 + _ uint32 + _ uint32 + _ [4]byte +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go index 7637243b7b..2a606151b0 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go @@ -642,3 +642,32 @@ const ( PPS_GETCAP = 0x400870a3 PPS_FETCH = 0xc00870a4 ) + +const ( + PIDFD_NONBLOCK = 0x800 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + Seq uint32 + _ uint32 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Atime int64 + Dtime int64 + Ctime int64 + Segsz uint64 + Cpid int32 + Lpid int32 + Nattch uint64 + _ uint64 + _ uint64 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go index a1a28e525f..d0d735d02c 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go @@ -642,3 +642,32 @@ const ( PPS_GETCAP = 0x400870a3 PPS_FETCH = 0xc00870a4 ) + +const ( + PIDFD_NONBLOCK = 0x800 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + Seq uint32 + _ uint32 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Atime int64 + Dtime int64 + Ctime int64 + Segsz uint64 + Cpid int32 + Lpid int32 + Nattch uint64 + _ uint64 + _ uint64 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go index e0a8a13622..95e3d6d06f 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go @@ -660,3 +660,33 @@ const ( PPS_GETCAP = 0x800870a3 PPS_FETCH = 0xc00870a4 ) + +const ( + PIDFD_NONBLOCK = 0x800 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + _ [0]uint8 + Seq uint16 + _ uint16 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint64 + Atime int64 + Dtime int64 + Ctime int64 + Cpid int32 + Lpid int32 + Nattch uint64 + _ uint64 + _ uint64 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go index 21d6e56c70..cccf1ef26a 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go @@ -656,3 +656,32 @@ const ( PPS_GETCAP = 0x800870a3 PPS_FETCH = 0xc00870a4 ) + +const ( + PIDFD_NONBLOCK = 0x800 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + _ uint16 + Seq uint16 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Segsz uint64 + Atime int64 + Dtime int64 + Ctime int64 + Cpid int32 + Lpid int32 + Nattch uint64 + _ uint64 + _ uint64 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go index 0531e98f64..44fcbe4e9a 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go @@ -637,3 +637,32 @@ const ( PPS_GETCAP = 0x400870a3 PPS_FETCH = 0xc00870a4 ) + +const ( + PIDFD_NONBLOCK = 0x4000 +) + +type SysvIpcPerm struct { + Key int32 + Uid uint32 + Gid uint32 + Cuid uint32 + Cgid uint32 + Mode uint32 + _ uint16 + Seq uint16 + _ uint64 + _ uint64 +} +type SysvShmDesc struct { + Perm SysvIpcPerm + Atime int64 + Dtime int64 + Ctime int64 + Segsz uint64 + Cpid int32 + Lpid int32 + Nattch uint64 + _ uint64 + _ uint64 +} diff --git a/vendor/golang.org/x/sys/windows/aliases.go b/vendor/golang.org/x/sys/windows/aliases.go index af3af60db9..a20ebea633 100644 --- a/vendor/golang.org/x/sys/windows/aliases.go +++ b/vendor/golang.org/x/sys/windows/aliases.go @@ -2,8 +2,8 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// +build windows -// +build go1.9 +//go:build windows && go1.9 +// +build windows,go1.9 package windows diff --git a/vendor/golang.org/x/sys/windows/eventlog.go b/vendor/golang.org/x/sys/windows/eventlog.go index 40af946e16..2cd60645ee 100644 --- a/vendor/golang.org/x/sys/windows/eventlog.go +++ b/vendor/golang.org/x/sys/windows/eventlog.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows // +build windows package windows diff --git a/vendor/golang.org/x/sys/windows/memory_windows.go b/vendor/golang.org/x/sys/windows/memory_windows.go index 1adb60739a..6dc0920a84 100644 --- a/vendor/golang.org/x/sys/windows/memory_windows.go +++ b/vendor/golang.org/x/sys/windows/memory_windows.go @@ -35,3 +35,14 @@ const ( QUOTA_LIMITS_HARDWS_MAX_DISABLE = 0x00000008 QUOTA_LIMITS_HARDWS_MAX_ENABLE = 0x00000004 ) + +type MemoryBasicInformation struct { + BaseAddress uintptr + AllocationBase uintptr + AllocationProtect uint32 + PartitionId uint16 + RegionSize uintptr + State uint32 + Protect uint32 + Type uint32 +} diff --git a/vendor/golang.org/x/sys/windows/mksyscall.go b/vendor/golang.org/x/sys/windows/mksyscall.go index 328e3b2ace..6102910989 100644 --- a/vendor/golang.org/x/sys/windows/mksyscall.go +++ b/vendor/golang.org/x/sys/windows/mksyscall.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build generate // +build generate package windows diff --git a/vendor/golang.org/x/sys/windows/race.go b/vendor/golang.org/x/sys/windows/race.go index a74e3e24b5..9196b089ca 100644 --- a/vendor/golang.org/x/sys/windows/race.go +++ b/vendor/golang.org/x/sys/windows/race.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows && race // +build windows,race package windows diff --git a/vendor/golang.org/x/sys/windows/race0.go b/vendor/golang.org/x/sys/windows/race0.go index e44a3cbf67..7bae4817a0 100644 --- a/vendor/golang.org/x/sys/windows/race0.go +++ b/vendor/golang.org/x/sys/windows/race0.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows && !race // +build windows,!race package windows diff --git a/vendor/golang.org/x/sys/windows/service.go b/vendor/golang.org/x/sys/windows/service.go index b269850d06..f8deca8397 100644 --- a/vendor/golang.org/x/sys/windows/service.go +++ b/vendor/golang.org/x/sys/windows/service.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows // +build windows package windows @@ -16,8 +17,6 @@ const ( SC_MANAGER_ALL_ACCESS = 0xf003f ) -//sys OpenSCManager(machineName *uint16, databaseName *uint16, access uint32) (handle Handle, err error) [failretval==0] = advapi32.OpenSCManagerW - const ( SERVICE_KERNEL_DRIVER = 1 SERVICE_FILE_SYSTEM_DRIVER = 2 @@ -132,6 +131,14 @@ const ( SC_EVENT_DATABASE_CHANGE = 0 SC_EVENT_PROPERTY_CHANGE = 1 SC_EVENT_STATUS_CHANGE = 2 + + SERVICE_START_REASON_DEMAND = 0x00000001 + SERVICE_START_REASON_AUTO = 0x00000002 + SERVICE_START_REASON_TRIGGER = 0x00000004 + SERVICE_START_REASON_RESTART_ON_FAILURE = 0x00000008 + SERVICE_START_REASON_DELAYEDAUTO = 0x00000010 + + SERVICE_DYNAMIC_INFORMATION_LEVEL_START_REASON = 1 ) type SERVICE_STATUS struct { @@ -216,6 +223,7 @@ type QUERY_SERVICE_LOCK_STATUS struct { LockDuration uint32 } +//sys OpenSCManager(machineName *uint16, databaseName *uint16, access uint32) (handle Handle, err error) [failretval==0] = advapi32.OpenSCManagerW //sys CloseServiceHandle(handle Handle) (err error) = advapi32.CloseServiceHandle //sys CreateService(mgr Handle, serviceName *uint16, displayName *uint16, access uint32, srvType uint32, startType uint32, errCtl uint32, pathName *uint16, loadOrderGroup *uint16, tagId *uint32, dependencies *uint16, serviceStartName *uint16, password *uint16) (handle Handle, err error) [failretval==0] = advapi32.CreateServiceW //sys OpenService(mgr Handle, serviceName *uint16, access uint32) (handle Handle, err error) [failretval==0] = advapi32.OpenServiceW @@ -235,3 +243,5 @@ type QUERY_SERVICE_LOCK_STATUS struct { //sys NotifyServiceStatusChange(service Handle, notifyMask uint32, notifier *SERVICE_NOTIFY) (ret error) = advapi32.NotifyServiceStatusChangeW //sys SubscribeServiceChangeNotifications(service Handle, eventType uint32, callback uintptr, callbackCtx uintptr, subscription *uintptr) (ret error) = sechost.SubscribeServiceChangeNotifications? //sys UnsubscribeServiceChangeNotifications(subscription uintptr) = sechost.UnsubscribeServiceChangeNotifications? +//sys RegisterServiceCtrlHandlerEx(serviceName *uint16, handlerProc uintptr, context uintptr) (handle Handle, err error) = advapi32.RegisterServiceCtrlHandlerExW +//sys QueryServiceDynamicInformation(service Handle, infoLevel uint32, dynamicInfo unsafe.Pointer) (err error) = advapi32.QueryServiceDynamicInformation? diff --git a/vendor/golang.org/x/sys/windows/str.go b/vendor/golang.org/x/sys/windows/str.go index 917cc2aae4..4fc01434e4 100644 --- a/vendor/golang.org/x/sys/windows/str.go +++ b/vendor/golang.org/x/sys/windows/str.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows // +build windows package windows diff --git a/vendor/golang.org/x/sys/windows/syscall.go b/vendor/golang.org/x/sys/windows/syscall.go index 6122f557a0..72074d582f 100644 --- a/vendor/golang.org/x/sys/windows/syscall.go +++ b/vendor/golang.org/x/sys/windows/syscall.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows // +build windows // Package windows contains an interface to the low-level operating system diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go index 1215b2ae20..53ee74e08b 100644 --- a/vendor/golang.org/x/sys/windows/syscall_windows.go +++ b/vendor/golang.org/x/sys/windows/syscall_windows.go @@ -274,6 +274,11 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys VirtualAlloc(address uintptr, size uintptr, alloctype uint32, protect uint32) (value uintptr, err error) = kernel32.VirtualAlloc //sys VirtualFree(address uintptr, size uintptr, freetype uint32) (err error) = kernel32.VirtualFree //sys VirtualProtect(address uintptr, size uintptr, newprotect uint32, oldprotect *uint32) (err error) = kernel32.VirtualProtect +//sys VirtualProtectEx(process Handle, address uintptr, size uintptr, newProtect uint32, oldProtect *uint32) (err error) = kernel32.VirtualProtectEx +//sys VirtualQuery(address uintptr, buffer *MemoryBasicInformation, length uintptr) (err error) = kernel32.VirtualQuery +//sys VirtualQueryEx(process Handle, address uintptr, buffer *MemoryBasicInformation, length uintptr) (err error) = kernel32.VirtualQueryEx +//sys ReadProcessMemory(process Handle, baseAddress uintptr, buffer *byte, size uintptr, numberOfBytesRead *uintptr) (err error) = kernel32.ReadProcessMemory +//sys WriteProcessMemory(process Handle, baseAddress uintptr, buffer *byte, size uintptr, numberOfBytesWritten *uintptr) (err error) = kernel32.WriteProcessMemory //sys TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (err error) = mswsock.TransmitFile //sys ReadDirectoryChanges(handle Handle, buf *byte, buflen uint32, watchSubTree bool, mask uint32, retlen *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) = kernel32.ReadDirectoryChangesW //sys FindFirstChangeNotification(path string, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) [failretval==InvalidHandle] = kernel32.FindFirstChangeNotificationW @@ -396,8 +401,18 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys LoadResource(module Handle, resInfo Handle) (resData Handle, err error) = kernel32.LoadResource //sys LockResource(resData Handle) (addr uintptr, err error) = kernel32.LockResource +// Version APIs +//sys GetFileVersionInfoSize(filename string, zeroHandle *Handle) (bufSize uint32, err error) = version.GetFileVersionInfoSizeW +//sys GetFileVersionInfo(filename string, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) = version.GetFileVersionInfoW +//sys VerQueryValue(block unsafe.Pointer, subBlock string, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) = version.VerQueryValueW + // Process Status API (PSAPI) //sys EnumProcesses(processIds []uint32, bytesReturned *uint32) (err error) = psapi.EnumProcesses +//sys EnumProcessModules(process Handle, module *Handle, cb uint32, cbNeeded *uint32) (err error) = psapi.EnumProcessModules +//sys EnumProcessModulesEx(process Handle, module *Handle, cb uint32, cbNeeded *uint32, filterFlag uint32) (err error) = psapi.EnumProcessModulesEx +//sys GetModuleInformation(process Handle, module Handle, modinfo *ModuleInfo, cb uint32) (err error) = psapi.GetModuleInformation +//sys GetModuleFileNameEx(process Handle, module Handle, filename *uint16, size uint32) (err error) = psapi.GetModuleFileNameExW +//sys GetModuleBaseName(process Handle, module Handle, baseName *uint16, size uint32) (err error) = psapi.GetModuleBaseNameW // NT Native APIs //sys rtlNtStatusToDosErrorNoTeb(ntstatus NTStatus) (ret syscall.Errno) = ntdll.RtlNtStatusToDosErrorNoTeb @@ -408,11 +423,16 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys RtlInitString(destinationString *NTString, sourceString *byte) = ntdll.RtlInitString //sys NtCreateFile(handle *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, allocationSize *int64, attributes uint32, share uint32, disposition uint32, options uint32, eabuffer uintptr, ealength uint32) (ntstatus error) = ntdll.NtCreateFile //sys NtCreateNamedPipeFile(pipe *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (ntstatus error) = ntdll.NtCreateNamedPipeFile +//sys NtSetInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32, class uint32) (ntstatus error) = ntdll.NtSetInformationFile //sys RtlDosPathNameToNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) = ntdll.RtlDosPathNameToNtPathName_U_WithStatus //sys RtlDosPathNameToRelativeNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) = ntdll.RtlDosPathNameToRelativeNtPathName_U_WithStatus //sys RtlDefaultNpAcl(acl **ACL) (ntstatus error) = ntdll.RtlDefaultNpAcl //sys NtQueryInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32, retLen *uint32) (ntstatus error) = ntdll.NtQueryInformationProcess //sys NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32) (ntstatus error) = ntdll.NtSetInformationProcess +//sys NtQuerySystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32, retLen *uint32) (ntstatus error) = ntdll.NtQuerySystemInformation +//sys NtSetSystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32) (ntstatus error) = ntdll.NtSetSystemInformation +//sys RtlAddFunctionTable(functionTable *RUNTIME_FUNCTION, entryCount uint32, baseAddress uintptr) (ret bool) = ntdll.RtlAddFunctionTable +//sys RtlDeleteFunctionTable(functionTable *RUNTIME_FUNCTION) (ret bool) = ntdll.RtlDeleteFunctionTable // syscall interface implementation for other packages diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go index 17f03312df..286dd1eab9 100644 --- a/vendor/golang.org/x/sys/windows/types_windows.go +++ b/vendor/golang.org/x/sys/windows/types_windows.go @@ -66,9 +66,21 @@ var signals = [...]string{ } const ( - FILE_LIST_DIRECTORY = 0x00000001 - FILE_APPEND_DATA = 0x00000004 + FILE_READ_DATA = 0x00000001 + FILE_READ_ATTRIBUTES = 0x00000080 + FILE_READ_EA = 0x00000008 + FILE_WRITE_DATA = 0x00000002 FILE_WRITE_ATTRIBUTES = 0x00000100 + FILE_WRITE_EA = 0x00000010 + FILE_APPEND_DATA = 0x00000004 + FILE_EXECUTE = 0x00000020 + + FILE_GENERIC_READ = STANDARD_RIGHTS_READ | FILE_READ_DATA | FILE_READ_ATTRIBUTES | FILE_READ_EA | SYNCHRONIZE + FILE_GENERIC_WRITE = STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE + FILE_GENERIC_EXECUTE = STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES | FILE_EXECUTE | SYNCHRONIZE + + FILE_LIST_DIRECTORY = 0x00000001 + FILE_TRAVERSE = 0x00000020 FILE_SHARE_READ = 0x00000001 FILE_SHARE_WRITE = 0x00000002 @@ -242,6 +254,14 @@ const ( TH32CS_INHERIT = 0x80000000 ) +const ( + // flags for EnumProcessModulesEx + LIST_MODULES_32BIT = 0x01 + LIST_MODULES_64BIT = 0x02 + LIST_MODULES_ALL = 0x03 + LIST_MODULES_DEFAULT = 0x00 +) + const ( // filters for ReadDirectoryChangesW and FindFirstChangeNotificationW FILE_NOTIFY_CHANGE_FILE_NAME = 0x001 @@ -1781,7 +1801,53 @@ type reparseDataBuffer struct { } const ( - FSCTL_GET_REPARSE_POINT = 0x900A8 + FSCTL_CREATE_OR_GET_OBJECT_ID = 0x0900C0 + FSCTL_DELETE_OBJECT_ID = 0x0900A0 + FSCTL_DELETE_REPARSE_POINT = 0x0900AC + FSCTL_DUPLICATE_EXTENTS_TO_FILE = 0x098344 + FSCTL_DUPLICATE_EXTENTS_TO_FILE_EX = 0x0983E8 + FSCTL_FILESYSTEM_GET_STATISTICS = 0x090060 + FSCTL_FILE_LEVEL_TRIM = 0x098208 + FSCTL_FIND_FILES_BY_SID = 0x09008F + FSCTL_GET_COMPRESSION = 0x09003C + FSCTL_GET_INTEGRITY_INFORMATION = 0x09027C + FSCTL_GET_NTFS_VOLUME_DATA = 0x090064 + FSCTL_GET_REFS_VOLUME_DATA = 0x0902D8 + FSCTL_GET_OBJECT_ID = 0x09009C + FSCTL_GET_REPARSE_POINT = 0x0900A8 + FSCTL_GET_RETRIEVAL_POINTER_COUNT = 0x09042B + FSCTL_GET_RETRIEVAL_POINTERS = 0x090073 + FSCTL_GET_RETRIEVAL_POINTERS_AND_REFCOUNT = 0x0903D3 + FSCTL_IS_PATHNAME_VALID = 0x09002C + FSCTL_LMR_SET_LINK_TRACKING_INFORMATION = 0x1400EC + FSCTL_MARK_HANDLE = 0x0900FC + FSCTL_OFFLOAD_READ = 0x094264 + FSCTL_OFFLOAD_WRITE = 0x098268 + FSCTL_PIPE_PEEK = 0x11400C + FSCTL_PIPE_TRANSCEIVE = 0x11C017 + FSCTL_PIPE_WAIT = 0x110018 + FSCTL_QUERY_ALLOCATED_RANGES = 0x0940CF + FSCTL_QUERY_FAT_BPB = 0x090058 + FSCTL_QUERY_FILE_REGIONS = 0x090284 + FSCTL_QUERY_ON_DISK_VOLUME_INFO = 0x09013C + FSCTL_QUERY_SPARING_INFO = 0x090138 + FSCTL_READ_FILE_USN_DATA = 0x0900EB + FSCTL_RECALL_FILE = 0x090117 + FSCTL_REFS_STREAM_SNAPSHOT_MANAGEMENT = 0x090440 + FSCTL_SET_COMPRESSION = 0x09C040 + FSCTL_SET_DEFECT_MANAGEMENT = 0x098134 + FSCTL_SET_ENCRYPTION = 0x0900D7 + FSCTL_SET_INTEGRITY_INFORMATION = 0x09C280 + FSCTL_SET_INTEGRITY_INFORMATION_EX = 0x090380 + FSCTL_SET_OBJECT_ID = 0x090098 + FSCTL_SET_OBJECT_ID_EXTENDED = 0x0900BC + FSCTL_SET_REPARSE_POINT = 0x0900A4 + FSCTL_SET_SPARSE = 0x0900C4 + FSCTL_SET_ZERO_DATA = 0x0980C8 + FSCTL_SET_ZERO_ON_DEALLOCATION = 0x090194 + FSCTL_SIS_COPYFILE = 0x090100 + FSCTL_WRITE_USN_CLOSE_RECORD = 0x0900EF + MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16 * 1024 IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003 IO_REPARSE_TAG_SYMLINK = 0xA000000C @@ -2300,6 +2366,12 @@ type LIST_ENTRY struct { Blink *LIST_ENTRY } +type RUNTIME_FUNCTION struct { + BeginAddress uint32 + EndAddress uint32 + UnwindData uint32 +} + type LDR_DATA_TABLE_ENTRY struct { reserved1 [2]uintptr InMemoryOrderLinks LIST_ENTRY @@ -2490,6 +2562,60 @@ const ( FILE_PIPE_SERVER_END = 0x00000001 ) +const ( + // FileInformationClass for NtSetInformationFile + FileBasicInformation = 4 + FileRenameInformation = 10 + FileDispositionInformation = 13 + FilePositionInformation = 14 + FileEndOfFileInformation = 20 + FileValidDataLengthInformation = 39 + FileShortNameInformation = 40 + FileIoPriorityHintInformation = 43 + FileReplaceCompletionInformation = 61 + FileDispositionInformationEx = 64 + FileCaseSensitiveInformation = 71 + FileLinkInformation = 72 + FileCaseSensitiveInformationForceAccessCheck = 75 + FileKnownFolderInformation = 76 + + // Flags for FILE_RENAME_INFORMATION + FILE_RENAME_REPLACE_IF_EXISTS = 0x00000001 + FILE_RENAME_POSIX_SEMANTICS = 0x00000002 + FILE_RENAME_SUPPRESS_PIN_STATE_INHERITANCE = 0x00000004 + FILE_RENAME_SUPPRESS_STORAGE_RESERVE_INHERITANCE = 0x00000008 + FILE_RENAME_NO_INCREASE_AVAILABLE_SPACE = 0x00000010 + FILE_RENAME_NO_DECREASE_AVAILABLE_SPACE = 0x00000020 + FILE_RENAME_PRESERVE_AVAILABLE_SPACE = 0x00000030 + FILE_RENAME_IGNORE_READONLY_ATTRIBUTE = 0x00000040 + FILE_RENAME_FORCE_RESIZE_TARGET_SR = 0x00000080 + FILE_RENAME_FORCE_RESIZE_SOURCE_SR = 0x00000100 + FILE_RENAME_FORCE_RESIZE_SR = 0x00000180 + + // Flags for FILE_DISPOSITION_INFORMATION_EX + FILE_DISPOSITION_DO_NOT_DELETE = 0x00000000 + FILE_DISPOSITION_DELETE = 0x00000001 + FILE_DISPOSITION_POSIX_SEMANTICS = 0x00000002 + FILE_DISPOSITION_FORCE_IMAGE_SECTION_CHECK = 0x00000004 + FILE_DISPOSITION_ON_CLOSE = 0x00000008 + FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE = 0x00000010 + + // Flags for FILE_CASE_SENSITIVE_INFORMATION + FILE_CS_FLAG_CASE_SENSITIVE_DIR = 0x00000001 + + // Flags for FILE_LINK_INFORMATION + FILE_LINK_REPLACE_IF_EXISTS = 0x00000001 + FILE_LINK_POSIX_SEMANTICS = 0x00000002 + FILE_LINK_SUPPRESS_STORAGE_RESERVE_INHERITANCE = 0x00000008 + FILE_LINK_NO_INCREASE_AVAILABLE_SPACE = 0x00000010 + FILE_LINK_NO_DECREASE_AVAILABLE_SPACE = 0x00000020 + FILE_LINK_PRESERVE_AVAILABLE_SPACE = 0x00000030 + FILE_LINK_IGNORE_READONLY_ATTRIBUTE = 0x00000040 + FILE_LINK_FORCE_RESIZE_TARGET_SR = 0x00000080 + FILE_LINK_FORCE_RESIZE_SOURCE_SR = 0x00000100 + FILE_LINK_FORCE_RESIZE_SR = 0x00000180 +) + // ProcessInformationClasses for NtQueryInformationProcess and NtSetInformationProcess. const ( ProcessBasicInformation = iota @@ -2606,6 +2732,203 @@ type PROCESS_BASIC_INFORMATION struct { InheritedFromUniqueProcessId uintptr } +// SystemInformationClasses for NtQuerySystemInformation and NtSetSystemInformation +const ( + SystemBasicInformation = iota + SystemProcessorInformation + SystemPerformanceInformation + SystemTimeOfDayInformation + SystemPathInformation + SystemProcessInformation + SystemCallCountInformation + SystemDeviceInformation + SystemProcessorPerformanceInformation + SystemFlagsInformation + SystemCallTimeInformation + SystemModuleInformation + SystemLocksInformation + SystemStackTraceInformation + SystemPagedPoolInformation + SystemNonPagedPoolInformation + SystemHandleInformation + SystemObjectInformation + SystemPageFileInformation + SystemVdmInstemulInformation + SystemVdmBopInformation + SystemFileCacheInformation + SystemPoolTagInformation + SystemInterruptInformation + SystemDpcBehaviorInformation + SystemFullMemoryInformation + SystemLoadGdiDriverInformation + SystemUnloadGdiDriverInformation + SystemTimeAdjustmentInformation + SystemSummaryMemoryInformation + SystemMirrorMemoryInformation + SystemPerformanceTraceInformation + systemObsolete0 + SystemExceptionInformation + SystemCrashDumpStateInformation + SystemKernelDebuggerInformation + SystemContextSwitchInformation + SystemRegistryQuotaInformation + SystemExtendServiceTableInformation + SystemPrioritySeperation + SystemVerifierAddDriverInformation + SystemVerifierRemoveDriverInformation + SystemProcessorIdleInformation + SystemLegacyDriverInformation + SystemCurrentTimeZoneInformation + SystemLookasideInformation + SystemTimeSlipNotification + SystemSessionCreate + SystemSessionDetach + SystemSessionInformation + SystemRangeStartInformation + SystemVerifierInformation + SystemVerifierThunkExtend + SystemSessionProcessInformation + SystemLoadGdiDriverInSystemSpace + SystemNumaProcessorMap + SystemPrefetcherInformation + SystemExtendedProcessInformation + SystemRecommendedSharedDataAlignment + SystemComPlusPackage + SystemNumaAvailableMemory + SystemProcessorPowerInformation + SystemEmulationBasicInformation + SystemEmulationProcessorInformation + SystemExtendedHandleInformation + SystemLostDelayedWriteInformation + SystemBigPoolInformation + SystemSessionPoolTagInformation + SystemSessionMappedViewInformation + SystemHotpatchInformation + SystemObjectSecurityMode + SystemWatchdogTimerHandler + SystemWatchdogTimerInformation + SystemLogicalProcessorInformation + SystemWow64SharedInformationObsolete + SystemRegisterFirmwareTableInformationHandler + SystemFirmwareTableInformation + SystemModuleInformationEx + SystemVerifierTriageInformation + SystemSuperfetchInformation + SystemMemoryListInformation + SystemFileCacheInformationEx + SystemThreadPriorityClientIdInformation + SystemProcessorIdleCycleTimeInformation + SystemVerifierCancellationInformation + SystemProcessorPowerInformationEx + SystemRefTraceInformation + SystemSpecialPoolInformation + SystemProcessIdInformation + SystemErrorPortInformation + SystemBootEnvironmentInformation + SystemHypervisorInformation + SystemVerifierInformationEx + SystemTimeZoneInformation + SystemImageFileExecutionOptionsInformation + SystemCoverageInformation + SystemPrefetchPatchInformation + SystemVerifierFaultsInformation + SystemSystemPartitionInformation + SystemSystemDiskInformation + SystemProcessorPerformanceDistribution + SystemNumaProximityNodeInformation + SystemDynamicTimeZoneInformation + SystemCodeIntegrityInformation + SystemProcessorMicrocodeUpdateInformation + SystemProcessorBrandString + SystemVirtualAddressInformation + SystemLogicalProcessorAndGroupInformation + SystemProcessorCycleTimeInformation + SystemStoreInformation + SystemRegistryAppendString + SystemAitSamplingValue + SystemVhdBootInformation + SystemCpuQuotaInformation + SystemNativeBasicInformation + systemSpare1 + SystemLowPriorityIoInformation + SystemTpmBootEntropyInformation + SystemVerifierCountersInformation + SystemPagedPoolInformationEx + SystemSystemPtesInformationEx + SystemNodeDistanceInformation + SystemAcpiAuditInformation + SystemBasicPerformanceInformation + SystemQueryPerformanceCounterInformation + SystemSessionBigPoolInformation + SystemBootGraphicsInformation + SystemScrubPhysicalMemoryInformation + SystemBadPageInformation + SystemProcessorProfileControlArea + SystemCombinePhysicalMemoryInformation + SystemEntropyInterruptTimingCallback + SystemConsoleInformation + SystemPlatformBinaryInformation + SystemThrottleNotificationInformation + SystemHypervisorProcessorCountInformation + SystemDeviceDataInformation + SystemDeviceDataEnumerationInformation + SystemMemoryTopologyInformation + SystemMemoryChannelInformation + SystemBootLogoInformation + SystemProcessorPerformanceInformationEx + systemSpare0 + SystemSecureBootPolicyInformation + SystemPageFileInformationEx + SystemSecureBootInformation + SystemEntropyInterruptTimingRawInformation + SystemPortableWorkspaceEfiLauncherInformation + SystemFullProcessInformation + SystemKernelDebuggerInformationEx + SystemBootMetadataInformation + SystemSoftRebootInformation + SystemElamCertificateInformation + SystemOfflineDumpConfigInformation + SystemProcessorFeaturesInformation + SystemRegistryReconciliationInformation + SystemEdidInformation + SystemManufacturingInformation + SystemEnergyEstimationConfigInformation + SystemHypervisorDetailInformation + SystemProcessorCycleStatsInformation + SystemVmGenerationCountInformation + SystemTrustedPlatformModuleInformation + SystemKernelDebuggerFlags + SystemCodeIntegrityPolicyInformation + SystemIsolatedUserModeInformation + SystemHardwareSecurityTestInterfaceResultsInformation + SystemSingleModuleInformation + SystemAllowedCpuSetsInformation + SystemDmaProtectionInformation + SystemInterruptCpuSetsInformation + SystemSecureBootPolicyFullInformation + SystemCodeIntegrityPolicyFullInformation + SystemAffinitizedInterruptProcessorInformation + SystemRootSiloInformation +) + +type RTL_PROCESS_MODULE_INFORMATION struct { + Section Handle + MappedBase uintptr + ImageBase uintptr + ImageSize uint32 + Flags uint32 + LoadOrderIndex uint16 + InitOrderIndex uint16 + LoadCount uint16 + OffsetToFileName uint16 + FullPathName [256]byte +} + +type RTL_PROCESS_MODULES struct { + NumberOfModules uint32 + Modules [1]RTL_PROCESS_MODULE_INFORMATION +} + // Constants for LocalAlloc flags. const ( LMEM_FIXED = 0x0 @@ -2700,6 +3023,22 @@ var ( RT_MANIFEST ResourceID = 24 ) +type VS_FIXEDFILEINFO struct { + Signature uint32 + StrucVersion uint32 + FileVersionMS uint32 + FileVersionLS uint32 + ProductVersionMS uint32 + ProductVersionLS uint32 + FileFlagsMask uint32 + FileFlags uint32 + FileOS uint32 + FileType uint32 + FileSubtype uint32 + FileDateMS uint32 + FileDateLS uint32 +} + type COAUTHIDENTITY struct { User *uint16 UserLength uint32 @@ -2773,3 +3112,9 @@ const ( // Flag for QueryFullProcessImageName. const PROCESS_NAME_NATIVE = 1 + +type ModuleInfo struct { + BaseOfDll uintptr + SizeOfImage uint32 + EntryPoint uintptr +} diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go index 2083ec376e..91817d6dcb 100644 --- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go +++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go @@ -51,6 +51,7 @@ var ( modshell32 = NewLazySystemDLL("shell32.dll") moduser32 = NewLazySystemDLL("user32.dll") moduserenv = NewLazySystemDLL("userenv.dll") + modversion = NewLazySystemDLL("version.dll") modwintrust = NewLazySystemDLL("wintrust.dll") modws2_32 = NewLazySystemDLL("ws2_32.dll") modwtsapi32 = NewLazySystemDLL("wtsapi32.dll") @@ -114,6 +115,7 @@ var ( procOpenThreadToken = modadvapi32.NewProc("OpenThreadToken") procQueryServiceConfig2W = modadvapi32.NewProc("QueryServiceConfig2W") procQueryServiceConfigW = modadvapi32.NewProc("QueryServiceConfigW") + procQueryServiceDynamicInformation = modadvapi32.NewProc("QueryServiceDynamicInformation") procQueryServiceLockStatusW = modadvapi32.NewProc("QueryServiceLockStatusW") procQueryServiceStatus = modadvapi32.NewProc("QueryServiceStatus") procQueryServiceStatusEx = modadvapi32.NewProc("QueryServiceStatusEx") @@ -124,6 +126,7 @@ var ( procRegQueryInfoKeyW = modadvapi32.NewProc("RegQueryInfoKeyW") procRegQueryValueExW = modadvapi32.NewProc("RegQueryValueExW") procRegisterEventSourceW = modadvapi32.NewProc("RegisterEventSourceW") + procRegisterServiceCtrlHandlerExW = modadvapi32.NewProc("RegisterServiceCtrlHandlerExW") procReportEventW = modadvapi32.NewProc("ReportEventW") procRevertToSelf = modadvapi32.NewProc("RevertToSelf") procSetEntriesInAclW = modadvapi32.NewProc("SetEntriesInAclW") @@ -303,6 +306,7 @@ var ( procReadConsoleW = modkernel32.NewProc("ReadConsoleW") procReadDirectoryChangesW = modkernel32.NewProc("ReadDirectoryChangesW") procReadFile = modkernel32.NewProc("ReadFile") + procReadProcessMemory = modkernel32.NewProc("ReadProcessMemory") procReleaseMutex = modkernel32.NewProc("ReleaseMutex") procRemoveDirectoryW = modkernel32.NewProc("RemoveDirectoryW") procResetEvent = modkernel32.NewProc("ResetEvent") @@ -345,12 +349,16 @@ var ( procVirtualFree = modkernel32.NewProc("VirtualFree") procVirtualLock = modkernel32.NewProc("VirtualLock") procVirtualProtect = modkernel32.NewProc("VirtualProtect") + procVirtualProtectEx = modkernel32.NewProc("VirtualProtectEx") + procVirtualQuery = modkernel32.NewProc("VirtualQuery") + procVirtualQueryEx = modkernel32.NewProc("VirtualQueryEx") procVirtualUnlock = modkernel32.NewProc("VirtualUnlock") procWTSGetActiveConsoleSessionId = modkernel32.NewProc("WTSGetActiveConsoleSessionId") procWaitForMultipleObjects = modkernel32.NewProc("WaitForMultipleObjects") procWaitForSingleObject = modkernel32.NewProc("WaitForSingleObject") procWriteConsoleW = modkernel32.NewProc("WriteConsoleW") procWriteFile = modkernel32.NewProc("WriteFile") + procWriteProcessMemory = modkernel32.NewProc("WriteProcessMemory") procAcceptEx = modmswsock.NewProc("AcceptEx") procGetAcceptExSockaddrs = modmswsock.NewProc("GetAcceptExSockaddrs") procTransmitFile = modmswsock.NewProc("TransmitFile") @@ -360,8 +368,13 @@ var ( procNtCreateFile = modntdll.NewProc("NtCreateFile") procNtCreateNamedPipeFile = modntdll.NewProc("NtCreateNamedPipeFile") procNtQueryInformationProcess = modntdll.NewProc("NtQueryInformationProcess") + procNtQuerySystemInformation = modntdll.NewProc("NtQuerySystemInformation") + procNtSetInformationFile = modntdll.NewProc("NtSetInformationFile") procNtSetInformationProcess = modntdll.NewProc("NtSetInformationProcess") + procNtSetSystemInformation = modntdll.NewProc("NtSetSystemInformation") + procRtlAddFunctionTable = modntdll.NewProc("RtlAddFunctionTable") procRtlDefaultNpAcl = modntdll.NewProc("RtlDefaultNpAcl") + procRtlDeleteFunctionTable = modntdll.NewProc("RtlDeleteFunctionTable") procRtlDosPathNameToNtPathName_U_WithStatus = modntdll.NewProc("RtlDosPathNameToNtPathName_U_WithStatus") procRtlDosPathNameToRelativeNtPathName_U_WithStatus = modntdll.NewProc("RtlDosPathNameToRelativeNtPathName_U_WithStatus") procRtlGetCurrentPeb = modntdll.NewProc("RtlGetCurrentPeb") @@ -377,7 +390,12 @@ var ( procCoTaskMemFree = modole32.NewProc("CoTaskMemFree") procCoUninitialize = modole32.NewProc("CoUninitialize") procStringFromGUID2 = modole32.NewProc("StringFromGUID2") + procEnumProcessModules = modpsapi.NewProc("EnumProcessModules") + procEnumProcessModulesEx = modpsapi.NewProc("EnumProcessModulesEx") procEnumProcesses = modpsapi.NewProc("EnumProcesses") + procGetModuleBaseNameW = modpsapi.NewProc("GetModuleBaseNameW") + procGetModuleFileNameExW = modpsapi.NewProc("GetModuleFileNameExW") + procGetModuleInformation = modpsapi.NewProc("GetModuleInformation") procSubscribeServiceChangeNotifications = modsechost.NewProc("SubscribeServiceChangeNotifications") procUnsubscribeServiceChangeNotifications = modsechost.NewProc("UnsubscribeServiceChangeNotifications") procGetUserNameExW = modsecur32.NewProc("GetUserNameExW") @@ -392,6 +410,9 @@ var ( procCreateEnvironmentBlock = moduserenv.NewProc("CreateEnvironmentBlock") procDestroyEnvironmentBlock = moduserenv.NewProc("DestroyEnvironmentBlock") procGetUserProfileDirectoryW = moduserenv.NewProc("GetUserProfileDirectoryW") + procGetFileVersionInfoSizeW = modversion.NewProc("GetFileVersionInfoSizeW") + procGetFileVersionInfoW = modversion.NewProc("GetFileVersionInfoW") + procVerQueryValueW = modversion.NewProc("VerQueryValueW") procWinVerifyTrustEx = modwintrust.NewProc("WinVerifyTrustEx") procFreeAddrInfoW = modws2_32.NewProc("FreeAddrInfoW") procGetAddrInfoW = modws2_32.NewProc("GetAddrInfoW") @@ -956,6 +977,18 @@ func QueryServiceConfig(service Handle, serviceConfig *QUERY_SERVICE_CONFIG, buf return } +func QueryServiceDynamicInformation(service Handle, infoLevel uint32, dynamicInfo unsafe.Pointer) (err error) { + err = procQueryServiceDynamicInformation.Find() + if err != nil { + return + } + r1, _, e1 := syscall.Syscall(procQueryServiceDynamicInformation.Addr(), 3, uintptr(service), uintptr(infoLevel), uintptr(dynamicInfo)) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func QueryServiceLockStatus(mgr Handle, lockStatus *QUERY_SERVICE_LOCK_STATUS, bufSize uint32, bytesNeeded *uint32) (err error) { r1, _, e1 := syscall.Syscall6(procQueryServiceLockStatusW.Addr(), 4, uintptr(mgr), uintptr(unsafe.Pointer(lockStatus)), uintptr(bufSize), uintptr(unsafe.Pointer(bytesNeeded)), 0, 0) if r1 == 0 { @@ -1045,6 +1078,15 @@ func RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Hand return } +func RegisterServiceCtrlHandlerEx(serviceName *uint16, handlerProc uintptr, context uintptr) (handle Handle, err error) { + r0, _, e1 := syscall.Syscall(procRegisterServiceCtrlHandlerExW.Addr(), 3, uintptr(unsafe.Pointer(serviceName)), uintptr(handlerProc), uintptr(context)) + handle = Handle(r0) + if handle == 0 { + err = errnoErr(e1) + } + return +} + func ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) { r1, _, e1 := syscall.Syscall9(procReportEventW.Addr(), 9, uintptr(log), uintptr(etype), uintptr(category), uintptr(eventId), uintptr(usrSId), uintptr(numStrings), uintptr(dataSize), uintptr(unsafe.Pointer(strings)), uintptr(unsafe.Pointer(rawData))) if r1 == 0 { @@ -2631,6 +2673,14 @@ func ReadFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) ( return } +func ReadProcessMemory(process Handle, baseAddress uintptr, buffer *byte, size uintptr, numberOfBytesRead *uintptr) (err error) { + r1, _, e1 := syscall.Syscall6(procReadProcessMemory.Addr(), 5, uintptr(process), uintptr(baseAddress), uintptr(unsafe.Pointer(buffer)), uintptr(size), uintptr(unsafe.Pointer(numberOfBytesRead)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func ReleaseMutex(mutex Handle) (err error) { r1, _, e1 := syscall.Syscall(procReleaseMutex.Addr(), 1, uintptr(mutex), 0, 0) if r1 == 0 { @@ -2985,6 +3035,30 @@ func VirtualProtect(address uintptr, size uintptr, newprotect uint32, oldprotect return } +func VirtualProtectEx(process Handle, address uintptr, size uintptr, newProtect uint32, oldProtect *uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procVirtualProtectEx.Addr(), 5, uintptr(process), uintptr(address), uintptr(size), uintptr(newProtect), uintptr(unsafe.Pointer(oldProtect)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func VirtualQuery(address uintptr, buffer *MemoryBasicInformation, length uintptr) (err error) { + r1, _, e1 := syscall.Syscall(procVirtualQuery.Addr(), 3, uintptr(address), uintptr(unsafe.Pointer(buffer)), uintptr(length)) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func VirtualQueryEx(process Handle, address uintptr, buffer *MemoryBasicInformation, length uintptr) (err error) { + r1, _, e1 := syscall.Syscall6(procVirtualQueryEx.Addr(), 4, uintptr(process), uintptr(address), uintptr(unsafe.Pointer(buffer)), uintptr(length), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func VirtualUnlock(addr uintptr, length uintptr) (err error) { r1, _, e1 := syscall.Syscall(procVirtualUnlock.Addr(), 2, uintptr(addr), uintptr(length), 0) if r1 == 0 { @@ -3041,6 +3115,14 @@ func WriteFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) return } +func WriteProcessMemory(process Handle, baseAddress uintptr, buffer *byte, size uintptr, numberOfBytesWritten *uintptr) (err error) { + r1, _, e1 := syscall.Syscall6(procWriteProcessMemory.Addr(), 5, uintptr(process), uintptr(baseAddress), uintptr(unsafe.Pointer(buffer)), uintptr(size), uintptr(unsafe.Pointer(numberOfBytesWritten)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func AcceptEx(ls Handle, as Handle, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (err error) { r1, _, e1 := syscall.Syscall9(procAcceptEx.Addr(), 8, uintptr(ls), uintptr(as), uintptr(unsafe.Pointer(buf)), uintptr(rxdatalen), uintptr(laddrlen), uintptr(raddrlen), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(overlapped)), 0) if r1 == 0 { @@ -3110,6 +3192,22 @@ func NtQueryInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe return } +func NtQuerySystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32, retLen *uint32) (ntstatus error) { + r0, _, _ := syscall.Syscall6(procNtQuerySystemInformation.Addr(), 4, uintptr(sysInfoClass), uintptr(sysInfo), uintptr(sysInfoLen), uintptr(unsafe.Pointer(retLen)), 0, 0) + if r0 != 0 { + ntstatus = NTStatus(r0) + } + return +} + +func NtSetInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32, class uint32) (ntstatus error) { + r0, _, _ := syscall.Syscall6(procNtSetInformationFile.Addr(), 5, uintptr(handle), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferLen), uintptr(class), 0) + if r0 != 0 { + ntstatus = NTStatus(r0) + } + return +} + func NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32) (ntstatus error) { r0, _, _ := syscall.Syscall6(procNtSetInformationProcess.Addr(), 4, uintptr(proc), uintptr(procInfoClass), uintptr(procInfo), uintptr(procInfoLen), 0, 0) if r0 != 0 { @@ -3118,6 +3216,20 @@ func NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.P return } +func NtSetSystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32) (ntstatus error) { + r0, _, _ := syscall.Syscall(procNtSetSystemInformation.Addr(), 3, uintptr(sysInfoClass), uintptr(sysInfo), uintptr(sysInfoLen)) + if r0 != 0 { + ntstatus = NTStatus(r0) + } + return +} + +func RtlAddFunctionTable(functionTable *RUNTIME_FUNCTION, entryCount uint32, baseAddress uintptr) (ret bool) { + r0, _, _ := syscall.Syscall(procRtlAddFunctionTable.Addr(), 3, uintptr(unsafe.Pointer(functionTable)), uintptr(entryCount), uintptr(baseAddress)) + ret = r0 != 0 + return +} + func RtlDefaultNpAcl(acl **ACL) (ntstatus error) { r0, _, _ := syscall.Syscall(procRtlDefaultNpAcl.Addr(), 1, uintptr(unsafe.Pointer(acl)), 0, 0) if r0 != 0 { @@ -3126,6 +3238,12 @@ func RtlDefaultNpAcl(acl **ACL) (ntstatus error) { return } +func RtlDeleteFunctionTable(functionTable *RUNTIME_FUNCTION) (ret bool) { + r0, _, _ := syscall.Syscall(procRtlDeleteFunctionTable.Addr(), 1, uintptr(unsafe.Pointer(functionTable)), 0, 0) + ret = r0 != 0 + return +} + func RtlDosPathNameToNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) { r0, _, _ := syscall.Syscall6(procRtlDosPathNameToNtPathName_U_WithStatus.Addr(), 4, uintptr(unsafe.Pointer(dosName)), uintptr(unsafe.Pointer(ntName)), uintptr(unsafe.Pointer(ntFileNamePart)), uintptr(unsafe.Pointer(relativeName)), 0, 0) if r0 != 0 { @@ -3225,6 +3343,22 @@ func stringFromGUID2(rguid *GUID, lpsz *uint16, cchMax int32) (chars int32) { return } +func EnumProcessModules(process Handle, module *Handle, cb uint32, cbNeeded *uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procEnumProcessModules.Addr(), 4, uintptr(process), uintptr(unsafe.Pointer(module)), uintptr(cb), uintptr(unsafe.Pointer(cbNeeded)), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func EnumProcessModulesEx(process Handle, module *Handle, cb uint32, cbNeeded *uint32, filterFlag uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procEnumProcessModulesEx.Addr(), 5, uintptr(process), uintptr(unsafe.Pointer(module)), uintptr(cb), uintptr(unsafe.Pointer(cbNeeded)), uintptr(filterFlag), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func EnumProcesses(processIds []uint32, bytesReturned *uint32) (err error) { var _p0 *uint32 if len(processIds) > 0 { @@ -3237,6 +3371,30 @@ func EnumProcesses(processIds []uint32, bytesReturned *uint32) (err error) { return } +func GetModuleBaseName(process Handle, module Handle, baseName *uint16, size uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procGetModuleBaseNameW.Addr(), 4, uintptr(process), uintptr(module), uintptr(unsafe.Pointer(baseName)), uintptr(size), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func GetModuleFileNameEx(process Handle, module Handle, filename *uint16, size uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procGetModuleFileNameExW.Addr(), 4, uintptr(process), uintptr(module), uintptr(unsafe.Pointer(filename)), uintptr(size), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func GetModuleInformation(process Handle, module Handle, modinfo *ModuleInfo, cb uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procGetModuleInformation.Addr(), 4, uintptr(process), uintptr(module), uintptr(unsafe.Pointer(modinfo)), uintptr(cb), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func SubscribeServiceChangeNotifications(service Handle, eventType uint32, callback uintptr, callbackCtx uintptr, subscription *uintptr) (ret error) { ret = procSubscribeServiceChangeNotifications.Find() if ret != nil { @@ -3359,6 +3517,58 @@ func GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) { return } +func GetFileVersionInfoSize(filename string, zeroHandle *Handle) (bufSize uint32, err error) { + var _p0 *uint16 + _p0, err = syscall.UTF16PtrFromString(filename) + if err != nil { + return + } + return _GetFileVersionInfoSize(_p0, zeroHandle) +} + +func _GetFileVersionInfoSize(filename *uint16, zeroHandle *Handle) (bufSize uint32, err error) { + r0, _, e1 := syscall.Syscall(procGetFileVersionInfoSizeW.Addr(), 2, uintptr(unsafe.Pointer(filename)), uintptr(unsafe.Pointer(zeroHandle)), 0) + bufSize = uint32(r0) + if bufSize == 0 { + err = errnoErr(e1) + } + return +} + +func GetFileVersionInfo(filename string, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) { + var _p0 *uint16 + _p0, err = syscall.UTF16PtrFromString(filename) + if err != nil { + return + } + return _GetFileVersionInfo(_p0, handle, bufSize, buffer) +} + +func _GetFileVersionInfo(filename *uint16, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) { + r1, _, e1 := syscall.Syscall6(procGetFileVersionInfoW.Addr(), 4, uintptr(unsafe.Pointer(filename)), uintptr(handle), uintptr(bufSize), uintptr(buffer), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func VerQueryValue(block unsafe.Pointer, subBlock string, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) { + var _p0 *uint16 + _p0, err = syscall.UTF16PtrFromString(subBlock) + if err != nil { + return + } + return _VerQueryValue(block, _p0, pointerToBufferPointer, bufSize) +} + +func _VerQueryValue(block unsafe.Pointer, subBlock *uint16, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procVerQueryValueW.Addr(), 4, uintptr(block), uintptr(unsafe.Pointer(subBlock)), uintptr(pointerToBufferPointer), uintptr(unsafe.Pointer(bufSize)), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func WinVerifyTrustEx(hwnd HWND, actionId *GUID, data *WinTrustData) (ret error) { r0, _, _ := syscall.Syscall(procWinVerifyTrustEx.Addr(), 3, uintptr(hwnd), uintptr(unsafe.Pointer(actionId)), uintptr(unsafe.Pointer(data))) if r0 != 0 { diff --git a/vendor/golang.org/x/term/go.mod b/vendor/golang.org/x/term/go.mod index d45f52851e..edf0e5b1db 100644 --- a/vendor/golang.org/x/term/go.mod +++ b/vendor/golang.org/x/term/go.mod @@ -1,5 +1,5 @@ module golang.org/x/term -go 1.11 +go 1.17 -require golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 +require golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1 diff --git a/vendor/golang.org/x/term/go.sum b/vendor/golang.org/x/term/go.sum index de9e09c654..ff132135ec 100644 --- a/vendor/golang.org/x/term/go.sum +++ b/vendor/golang.org/x/term/go.sum @@ -1,2 +1,2 @@ -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuFiOQWj1Fs7T3VrH4Pjw= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1 h1:SrN+KX8Art/Sf4HNj6Zcz06G7VEz+7w9tdXTPOZ7+l4= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= diff --git a/vendor/golang.org/x/term/term.go b/vendor/golang.org/x/term/term.go index 2a4ccf8012..1f6a38fad2 100644 --- a/vendor/golang.org/x/term/term.go +++ b/vendor/golang.org/x/term/term.go @@ -7,11 +7,11 @@ // // Putting a terminal into raw mode is the most common requirement: // -// oldState, err := term.MakeRaw(0) +// oldState, err := term.MakeRaw(int(os.Stdin.Fd())) // if err != nil { // panic(err) // } -// defer term.Restore(0, oldState) +// defer term.Restore(int(os.Stdin.Fd()), oldState) package term // State contains the state of a terminal. diff --git a/vendor/golang.org/x/term/term_solaris.go b/vendor/golang.org/x/term/term_solaris.go deleted file mode 100644 index b9da29744b..0000000000 --- a/vendor/golang.org/x/term/term_solaris.go +++ /dev/null @@ -1,111 +0,0 @@ -// Copyright 2019 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package term - -import ( - "io" - "syscall" - - "golang.org/x/sys/unix" -) - -// State contains the state of a terminal. -type state struct { - termios unix.Termios -} - -func isTerminal(fd int) bool { - _, err := unix.IoctlGetTermio(fd, unix.TCGETA) - return err == nil -} - -func readPassword(fd int) ([]byte, error) { - // see also: http://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libast/common/uwin/getpass.c - val, err := unix.IoctlGetTermios(fd, unix.TCGETS) - if err != nil { - return nil, err - } - oldState := *val - - newState := oldState - newState.Lflag &^= syscall.ECHO - newState.Lflag |= syscall.ICANON | syscall.ISIG - newState.Iflag |= syscall.ICRNL - err = unix.IoctlSetTermios(fd, unix.TCSETS, &newState) - if err != nil { - return nil, err - } - - defer unix.IoctlSetTermios(fd, unix.TCSETS, &oldState) - - var buf [16]byte - var ret []byte - for { - n, err := syscall.Read(fd, buf[:]) - if err != nil { - return nil, err - } - if n == 0 { - if len(ret) == 0 { - return nil, io.EOF - } - break - } - if buf[n-1] == '\n' { - n-- - } - ret = append(ret, buf[:n]...) - if n < len(buf) { - break - } - } - - return ret, nil -} - -func makeRaw(fd int) (*State, error) { - // see http://cr.illumos.org/~webrev/andy_js/1060/ - termios, err := unix.IoctlGetTermios(fd, unix.TCGETS) - if err != nil { - return nil, err - } - - oldState := State{state{termios: *termios}} - - termios.Iflag &^= unix.IGNBRK | unix.BRKINT | unix.PARMRK | unix.ISTRIP | unix.INLCR | unix.IGNCR | unix.ICRNL | unix.IXON - termios.Oflag &^= unix.OPOST - termios.Lflag &^= unix.ECHO | unix.ECHONL | unix.ICANON | unix.ISIG | unix.IEXTEN - termios.Cflag &^= unix.CSIZE | unix.PARENB - termios.Cflag |= unix.CS8 - termios.Cc[unix.VMIN] = 1 - termios.Cc[unix.VTIME] = 0 - - if err := unix.IoctlSetTermios(fd, unix.TCSETS, termios); err != nil { - return nil, err - } - - return &oldState, nil -} - -func restore(fd int, oldState *State) error { - return unix.IoctlSetTermios(fd, unix.TCSETS, &oldState.termios) -} - -func getState(fd int) (*State, error) { - termios, err := unix.IoctlGetTermios(fd, unix.TCGETS) - if err != nil { - return nil, err - } - - return &State{state{termios: *termios}}, nil -} - -func getSize(fd int) (width, height int, err error) { - ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ) - if err != nil { - return 0, 0, err - } - return int(ws.Col), int(ws.Row), nil -} diff --git a/vendor/golang.org/x/term/term_unix.go b/vendor/golang.org/x/term/term_unix.go index 6849b6ee5b..a4e31ab1b2 100644 --- a/vendor/golang.org/x/term/term_unix.go +++ b/vendor/golang.org/x/term/term_unix.go @@ -2,8 +2,8 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || zos -// +build aix darwin dragonfly freebsd linux netbsd openbsd zos +//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos +// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos package term diff --git a/vendor/golang.org/x/term/term_unix_aix.go b/vendor/golang.org/x/term/term_unix_aix.go deleted file mode 100644 index 2d5efd26ad..0000000000 --- a/vendor/golang.org/x/term/term_unix_aix.go +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2019 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package term - -import "golang.org/x/sys/unix" - -const ioctlReadTermios = unix.TCGETS -const ioctlWriteTermios = unix.TCSETS diff --git a/vendor/golang.org/x/term/term_unix_linux.go b/vendor/golang.org/x/term/term_unix_other.go similarity index 63% rename from vendor/golang.org/x/term/term_unix_linux.go rename to vendor/golang.org/x/term/term_unix_other.go index 2d5efd26ad..1e8955c934 100644 --- a/vendor/golang.org/x/term/term_unix_linux.go +++ b/vendor/golang.org/x/term/term_unix_other.go @@ -1,7 +1,10 @@ -// Copyright 2019 The Go Authors. All rights reserved. +// Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build aix || linux || solaris || zos +// +build aix linux solaris zos + package term import "golang.org/x/sys/unix" diff --git a/vendor/golang.org/x/term/term_unix_zos.go b/vendor/golang.org/x/term/term_unix_zos.go deleted file mode 100644 index b85ab89989..0000000000 --- a/vendor/golang.org/x/term/term_unix_zos.go +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2020 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package term - -import "golang.org/x/sys/unix" - -const ioctlReadTermios = unix.TCGETS -const ioctlWriteTermios = unix.TCSETS diff --git a/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go b/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go index b949fc8407..5fe75b14c7 100644 --- a/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go +++ b/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go @@ -439,8 +439,10 @@ func (a *application) apply(parent ast.Node, name string, iter *iterator, n ast. } default: - if typeparams.IsListExpr(n) { - a.applyList(n, "ElemList") + if ix := typeparams.GetIndexExprData(n); ix != nil { + a.apply(n, "X", nil, ix.X) + // *ast.IndexExpr was handled above, so n must be an *ast.MultiIndexExpr. + a.applyList(n, "Indices") } else { panic(fmt.Sprintf("Apply: unexpected node type %T", n)) } diff --git a/vendor/golang.org/x/tools/internal/typeparams/doc.go b/vendor/golang.org/x/tools/internal/typeparams/common.go similarity index 59% rename from vendor/golang.org/x/tools/internal/typeparams/doc.go rename to vendor/golang.org/x/tools/internal/typeparams/common.go index 5583947e21..9fc6b4beb8 100644 --- a/vendor/golang.org/x/tools/internal/typeparams/doc.go +++ b/vendor/golang.org/x/tools/internal/typeparams/common.go @@ -9,3 +9,17 @@ // This package exists to make it easier for tools to work with generic code, // while also compiling against older Go versions. package typeparams + +import ( + "go/ast" + "go/token" +) + +// A IndexExprData holds data from both ast.IndexExpr and the new +// ast.MultiIndexExpr, which was introduced in Go 1.18. +type IndexExprData struct { + X ast.Expr // expression + Lbrack token.Pos // position of "[" + Indices []ast.Expr // index expressions + Rbrack token.Pos // position of "]" +} diff --git a/vendor/golang.org/x/tools/internal/typeparams/notypeparams.go b/vendor/golang.org/x/tools/internal/typeparams/notypeparams.go index 3a0abc7c18..e975e476f6 100644 --- a/vendor/golang.org/x/tools/internal/typeparams/notypeparams.go +++ b/vendor/golang.org/x/tools/internal/typeparams/notypeparams.go @@ -2,8 +2,8 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build !typeparams || !go1.17 -// +build !typeparams !go1.17 +//go:build !typeparams || !go1.18 +// +build !typeparams !go1.18 package typeparams @@ -18,17 +18,25 @@ import ( // environment. const Enabled = false -// UnpackIndex extracts all index expressions from e. For non-generic code this -// is always one expression: e.Index, but may be more than one expression for -// generic type instantiation. -func UnpackIndex(e *ast.IndexExpr) []ast.Expr { - return []ast.Expr{e.Index} -} - -// IsListExpr reports whether n is an *ast.ListExpr, which is a new node type -// introduced to hold type arguments for generic type instantiation. -func IsListExpr(n ast.Node) bool { - return false +// GetIndexExprData extracts data from AST nodes that represent index +// expressions. +// +// For an ast.IndexExpr, the resulting IndexExprData will have exactly one +// index expression. For an ast.MultiIndexExpr (go1.18+), it may have a +// variable number of index expressions. +// +// For nodes that don't represent index expressions, GetIndexExprData returns +// nil. +func GetIndexExprData(n ast.Node) *IndexExprData { + if e, _ := n.(*ast.IndexExpr); e != nil { + return &IndexExprData{ + X: e.X, + Lbrack: e.Lbrack, + Indices: []ast.Expr{e.Index}, + Rbrack: e.Rbrack, + } + } + return nil } // ForTypeDecl extracts the (possibly nil) type parameter node list from n. @@ -47,11 +55,6 @@ func ForSignature(*types.Signature) []*types.TypeName { return nil } -// HasTypeSet reports if iface has a type set. -func HasTypeSet(*types.Interface) bool { - return false -} - // IsComparable reports if iface is the comparable interface. func IsComparable(*types.Interface) bool { return false diff --git a/vendor/golang.org/x/tools/internal/typeparams/typeparams.go b/vendor/golang.org/x/tools/internal/typeparams/typeparams.go index 6b7958af06..2e94210246 100644 --- a/vendor/golang.org/x/tools/internal/typeparams/typeparams.go +++ b/vendor/golang.org/x/tools/internal/typeparams/typeparams.go @@ -2,8 +2,8 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build typeparams && go1.17 -// +build typeparams,go1.17 +//go:build typeparams && go1.18 +// +build typeparams,go1.18 package typeparams @@ -18,26 +18,30 @@ import ( // environment. const Enabled = true -// UnpackIndex extracts all index expressions from e. For non-generic code this -// is always one expression: e.Index, but may be more than one expression for -// generic type instantiation. -func UnpackIndex(e *ast.IndexExpr) []ast.Expr { - if x, _ := e.Index.(*ast.ListExpr); x != nil { - return x.ElemList - } - if e.Index != nil { - return []ast.Expr{e.Index} +// GetIndexExprData extracts data from AST nodes that represent index +// expressions. +// +// For an ast.IndexExpr, the resulting IndexExprData will have exactly one +// index expression. For an ast.MultiIndexExpr (go1.18+), it may have a +// variable number of index expressions. +// +// For nodes that don't represent index expressions, GetIndexExprData returns +// nil. +func GetIndexExprData(n ast.Node) *IndexExprData { + switch e := n.(type) { + case *ast.IndexExpr: + return &IndexExprData{ + X: e.X, + Lbrack: e.Lbrack, + Indices: []ast.Expr{e.Index}, + Rbrack: e.Rbrack, + } + case *ast.MultiIndexExpr: + return (*IndexExprData)(e) } return nil } -// IsListExpr reports whether n is an *ast.ListExpr, which is a new node type -// introduced to hold type arguments for generic type instantiation. -func IsListExpr(n ast.Node) bool { - _, ok := n.(*ast.ListExpr) - return ok -} - // ForTypeDecl extracts the (possibly nil) type parameter node list from n. func ForTypeDecl(n *ast.TypeSpec) *ast.FieldList { return n.TParams @@ -54,12 +58,7 @@ func ForFuncDecl(n *ast.FuncDecl) *ast.FieldList { // ForSignature extracts the (possibly empty) type parameter object list from // sig. func ForSignature(sig *types.Signature) []*types.TypeName { - return sig.TParams() -} - -// HasTypeSet reports if iface has a type set. -func HasTypeSet(iface *types.Interface) bool { - return iface.HasTypeList() + return tparamsSlice(sig.TParams()) } // IsComparable reports if iface is the comparable interface. @@ -76,12 +75,33 @@ func IsConstraint(iface *types.Interface) bool { // ForNamed extracts the (possibly empty) type parameter object list from // named. func ForNamed(named *types.Named) []*types.TypeName { - return named.TParams() + return tparamsSlice(named.TParams()) +} + +func tparamsSlice(tparams *types.TypeParams) []*types.TypeName { + if tparams.Len() == 0 { + return nil + } + result := make([]*types.TypeName, tparams.Len()) + for i := 0; i < tparams.Len(); i++ { + result[i] = tparams.At(i) + } + return result } // NamedTArgs extracts the (possibly empty) type argument list from named. func NamedTArgs(named *types.Named) []types.Type { - return named.TArgs() + ntargs := named.NumTArgs() + if ntargs == 0 { + return nil + } + + targs := make([]types.Type, ntargs) + for i := 0; i < ntargs; i++ { + targs[i] = named.TArg(i) + } + + return targs } // InitInferred initializes info to record inferred type information. diff --git a/vendor/k8s.io/api/admission/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/admission/v1/zz_generated.deepcopy.go index f7369471a8..d356882851 100644 --- a/vendor/k8s.io/api/admission/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/admission/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/admission/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/admission/v1beta1/zz_generated.deepcopy.go index 4f3dd45bea..8234b322f9 100644 --- a/vendor/k8s.io/api/admission/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/admission/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/admission/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/admission/v1beta1/zz_generated.prerelease-lifecycle.go index 8fc1cde0a6..f96e8a4433 100644 --- a/vendor/k8s.io/api/admission/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/admission/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/admissionregistration/v1/types.go b/vendor/k8s.io/api/admissionregistration/v1/types.go index ff544c3a3c..29873b796b 100644 --- a/vendor/k8s.io/api/admissionregistration/v1/types.go +++ b/vendor/k8s.io/api/admissionregistration/v1/types.go @@ -64,6 +64,7 @@ type Rule struct { } // ScopeType specifies a scope for a Rule. +// +enum type ScopeType string const ( @@ -77,6 +78,7 @@ const ( ) // FailurePolicyType specifies a failure policy that defines how unrecognized errors from the admission endpoint are handled. +// +enum type FailurePolicyType string const ( @@ -87,6 +89,7 @@ const ( ) // MatchPolicyType specifies the type of match policy. +// +enum type MatchPolicyType string const ( @@ -97,6 +100,7 @@ const ( ) // SideEffectClass specifies the types of side effects a webhook may have. +// +enum type SideEffectClass string const ( @@ -450,6 +454,7 @@ type MutatingWebhook struct { } // ReinvocationPolicyType specifies what type of policy the admission hook uses. +// +enum type ReinvocationPolicyType string const ( @@ -476,6 +481,7 @@ type RuleWithOperations struct { } // OperationType specifies an operation for a request. +// +enum type OperationType string // The constants should be kept in sync with those defined in k8s.io/kubernetes/pkg/admission/interface.go. diff --git a/vendor/k8s.io/api/admissionregistration/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/admissionregistration/v1/zz_generated.deepcopy.go index 3afb746737..cff7377a55 100644 --- a/vendor/k8s.io/api/admissionregistration/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/admissionregistration/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/admissionregistration/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/admissionregistration/v1beta1/zz_generated.deepcopy.go index c4570d0311..23ddb1fa2c 100644 --- a/vendor/k8s.io/api/admissionregistration/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/admissionregistration/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/admissionregistration/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/admissionregistration/v1beta1/zz_generated.prerelease-lifecycle.go index bfd93a05ad..09a92f4768 100644 --- a/vendor/k8s.io/api/admissionregistration/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/admissionregistration/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/apiserverinternal/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/api/apiserverinternal/v1alpha1/zz_generated.deepcopy.go index 7e82a9070f..44dffa7512 100644 --- a/vendor/k8s.io/api/apiserverinternal/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/apiserverinternal/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/apps/v1/generated.pb.go b/vendor/k8s.io/api/apps/v1/generated.pb.go index 0a15aff4d8..81d51bd58f 100644 --- a/vendor/k8s.io/api/apps/v1/generated.pb.go +++ b/vendor/k8s.io/api/apps/v1/generated.pb.go @@ -748,10 +748,40 @@ func (m *StatefulSetList) XXX_DiscardUnknown() { var xxx_messageInfo_StatefulSetList proto.InternalMessageInfo +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Reset() { + *m = StatefulSetPersistentVolumeClaimRetentionPolicy{} +} +func (*StatefulSetPersistentVolumeClaimRetentionPolicy) ProtoMessage() {} +func (*StatefulSetPersistentVolumeClaimRetentionPolicy) Descriptor() ([]byte, []int) { + return fileDescriptor_e1014cab6f31e43b, []int{25} +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.Merge(m, src) +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Size() int { + return m.Size() +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_DiscardUnknown() { + xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.DiscardUnknown(m) +} + +var xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy proto.InternalMessageInfo + func (m *StatefulSetSpec) Reset() { *m = StatefulSetSpec{} } func (*StatefulSetSpec) ProtoMessage() {} func (*StatefulSetSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_e1014cab6f31e43b, []int{25} + return fileDescriptor_e1014cab6f31e43b, []int{26} } func (m *StatefulSetSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -779,7 +809,7 @@ var xxx_messageInfo_StatefulSetSpec proto.InternalMessageInfo func (m *StatefulSetStatus) Reset() { *m = StatefulSetStatus{} } func (*StatefulSetStatus) ProtoMessage() {} func (*StatefulSetStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_e1014cab6f31e43b, []int{26} + return fileDescriptor_e1014cab6f31e43b, []int{27} } func (m *StatefulSetStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -807,7 +837,7 @@ var xxx_messageInfo_StatefulSetStatus proto.InternalMessageInfo func (m *StatefulSetUpdateStrategy) Reset() { *m = StatefulSetUpdateStrategy{} } func (*StatefulSetUpdateStrategy) ProtoMessage() {} func (*StatefulSetUpdateStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_e1014cab6f31e43b, []int{27} + return fileDescriptor_e1014cab6f31e43b, []int{28} } func (m *StatefulSetUpdateStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -858,6 +888,7 @@ func init() { proto.RegisterType((*StatefulSet)(nil), "k8s.io.api.apps.v1.StatefulSet") proto.RegisterType((*StatefulSetCondition)(nil), "k8s.io.api.apps.v1.StatefulSetCondition") proto.RegisterType((*StatefulSetList)(nil), "k8s.io.api.apps.v1.StatefulSetList") + proto.RegisterType((*StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), "k8s.io.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy") proto.RegisterType((*StatefulSetSpec)(nil), "k8s.io.api.apps.v1.StatefulSetSpec") proto.RegisterType((*StatefulSetStatus)(nil), "k8s.io.api.apps.v1.StatefulSetStatus") proto.RegisterType((*StatefulSetUpdateStrategy)(nil), "k8s.io.api.apps.v1.StatefulSetUpdateStrategy") @@ -868,135 +899,142 @@ func init() { } var fileDescriptor_e1014cab6f31e43b = []byte{ - // 2047 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcd, 0x6f, 0x24, 0x47, - 0x15, 0x77, 0xcf, 0x87, 0x3d, 0x2e, 0xaf, 0xed, 0xdd, 0xb2, 0xb1, 0x27, 0xbb, 0x64, 0x66, 0x19, - 0x60, 0xe3, 0x64, 0xb3, 0x3d, 0xec, 0x66, 0x13, 0xa1, 0x2c, 0x02, 0x79, 0xc6, 0x21, 0x84, 0x78, - 0x6c, 0x53, 0x5e, 0xef, 0x61, 0x09, 0x12, 0xe5, 0xe9, 0xda, 0x71, 0xc7, 0xfd, 0xa5, 0xee, 0xea, - 0x61, 0x47, 0x5c, 0x10, 0x12, 0x27, 0x38, 0xf0, 0x9f, 0x20, 0x84, 0xc8, 0x0d, 0x45, 0x88, 0xcb, - 0x5e, 0x90, 0x22, 0x2e, 0xe4, 0x64, 0xb1, 0x93, 0x13, 0x42, 0x1c, 0xb9, 0xe4, 0x02, 0xaa, 0xea, - 0xea, 0xef, 0x6a, 0xcf, 0xd8, 0x9b, 0x38, 0x24, 0xca, 0x6d, 0xba, 0xea, 0xf7, 0x7e, 0xf5, 0x5e, - 0xd5, 0xab, 0x7a, 0xbf, 0xae, 0x1e, 0x70, 0xef, 0xf8, 0xdb, 0x9e, 0xaa, 0xdb, 0xed, 0x63, 0xff, - 0x90, 0xb8, 0x16, 0xa1, 0xc4, 0x6b, 0x0f, 0x89, 0xa5, 0xd9, 0x6e, 0x5b, 0x74, 0x60, 0x47, 0x6f, - 0x63, 0xc7, 0xf1, 0xda, 0xc3, 0xdb, 0xed, 0x01, 0xb1, 0x88, 0x8b, 0x29, 0xd1, 0x54, 0xc7, 0xb5, - 0xa9, 0x0d, 0x61, 0x80, 0x51, 0xb1, 0xa3, 0xab, 0x0c, 0xa3, 0x0e, 0x6f, 0x5f, 0xbd, 0x35, 0xd0, - 0xe9, 0x91, 0x7f, 0xa8, 0xf6, 0x6d, 0xb3, 0x3d, 0xb0, 0x07, 0x76, 0x9b, 0x43, 0x0f, 0xfd, 0x47, - 0xfc, 0x89, 0x3f, 0xf0, 0x5f, 0x01, 0xc5, 0xd5, 0x56, 0x62, 0x98, 0xbe, 0xed, 0x12, 0xc9, 0x30, - 0x57, 0xef, 0xc6, 0x18, 0x13, 0xf7, 0x8f, 0x74, 0x8b, 0xb8, 0xa3, 0xb6, 0x73, 0x3c, 0x60, 0x0d, - 0x5e, 0xdb, 0x24, 0x14, 0xcb, 0xac, 0xda, 0x45, 0x56, 0xae, 0x6f, 0x51, 0xdd, 0x24, 0x39, 0x83, - 0xd7, 0x26, 0x19, 0x78, 0xfd, 0x23, 0x62, 0xe2, 0x9c, 0xdd, 0x2b, 0x45, 0x76, 0x3e, 0xd5, 0x8d, - 0xb6, 0x6e, 0x51, 0x8f, 0xba, 0x59, 0xa3, 0xd6, 0x7f, 0x14, 0x00, 0xbb, 0xb6, 0x45, 0x5d, 0xdb, - 0x30, 0x88, 0x8b, 0xc8, 0x50, 0xf7, 0x74, 0xdb, 0x82, 0x3f, 0x05, 0x35, 0x16, 0x8f, 0x86, 0x29, - 0xae, 0x2b, 0xd7, 0x95, 0x8d, 0x85, 0x3b, 0xdf, 0x52, 0xe3, 0x49, 0x8e, 0xe8, 0x55, 0xe7, 0x78, - 0xc0, 0x1a, 0x3c, 0x95, 0xa1, 0xd5, 0xe1, 0x6d, 0x75, 0xf7, 0xf0, 0x5d, 0xd2, 0xa7, 0x3d, 0x42, - 0x71, 0x07, 0x3e, 0x39, 0x69, 0xce, 0x8c, 0x4f, 0x9a, 0x20, 0x6e, 0x43, 0x11, 0x2b, 0xdc, 0x05, - 0x15, 0xce, 0x5e, 0xe2, 0xec, 0xb7, 0x0a, 0xd9, 0x45, 0xd0, 0x2a, 0xc2, 0x3f, 0x7b, 0xe3, 0x31, - 0x25, 0x16, 0x73, 0xaf, 0x73, 0x49, 0x50, 0x57, 0xb6, 0x30, 0xc5, 0x88, 0x13, 0xc1, 0x97, 0x41, - 0xcd, 0x15, 0xee, 0xd7, 0xcb, 0xd7, 0x95, 0x8d, 0x72, 0xe7, 0xb2, 0x40, 0xd5, 0xc2, 0xb0, 0x50, - 0x84, 0x68, 0xfd, 0x45, 0x01, 0x6b, 0xf9, 0xb8, 0xb7, 0x75, 0x8f, 0xc2, 0x77, 0x72, 0xb1, 0xab, - 0xd3, 0xc5, 0xce, 0xac, 0x79, 0xe4, 0xd1, 0xc0, 0x61, 0x4b, 0x22, 0xee, 0xb7, 0x41, 0x55, 0xa7, - 0xc4, 0xf4, 0xea, 0xa5, 0xeb, 0xe5, 0x8d, 0x85, 0x3b, 0x37, 0xd4, 0x7c, 0xee, 0xaa, 0x79, 0xc7, - 0x3a, 0x8b, 0x82, 0xb2, 0xfa, 0x16, 0x33, 0x46, 0x01, 0x47, 0xeb, 0xbf, 0x0a, 0x98, 0xdf, 0xc2, - 0xc4, 0xb4, 0xad, 0x7d, 0x42, 0x2f, 0x60, 0xd1, 0xba, 0xa0, 0xe2, 0x39, 0xa4, 0x2f, 0x16, 0xed, - 0x6b, 0x32, 0xdf, 0x23, 0x77, 0xf6, 0x1d, 0xd2, 0x8f, 0x17, 0x8a, 0x3d, 0x21, 0x6e, 0x0c, 0xdf, - 0x06, 0xb3, 0x1e, 0xc5, 0xd4, 0xf7, 0xf8, 0x32, 0x2d, 0xdc, 0xf9, 0xfa, 0xe9, 0x34, 0x1c, 0xda, - 0x59, 0x12, 0x44, 0xb3, 0xc1, 0x33, 0x12, 0x14, 0xad, 0x7f, 0x96, 0x00, 0x8c, 0xb0, 0x5d, 0xdb, - 0xd2, 0x74, 0xca, 0xf2, 0xf7, 0x75, 0x50, 0xa1, 0x23, 0x87, 0xf0, 0x69, 0x98, 0xef, 0xdc, 0x08, - 0xbd, 0xb8, 0x3f, 0x72, 0xc8, 0xc7, 0x27, 0xcd, 0xb5, 0xbc, 0x05, 0xeb, 0x41, 0xdc, 0x06, 0x6e, - 0x47, 0xfe, 0x95, 0xb8, 0xf5, 0xdd, 0xf4, 0xd0, 0x1f, 0x9f, 0x34, 0x25, 0x87, 0x85, 0x1a, 0x31, - 0xa5, 0x1d, 0x84, 0x43, 0x00, 0x0d, 0xec, 0xd1, 0xfb, 0x2e, 0xb6, 0xbc, 0x60, 0x24, 0xdd, 0x24, - 0x22, 0xf2, 0x97, 0xa6, 0x5b, 0x1e, 0x66, 0xd1, 0xb9, 0x2a, 0xbc, 0x80, 0xdb, 0x39, 0x36, 0x24, - 0x19, 0x01, 0xde, 0x00, 0xb3, 0x2e, 0xc1, 0x9e, 0x6d, 0xd5, 0x2b, 0x3c, 0x8a, 0x68, 0x02, 0x11, - 0x6f, 0x45, 0xa2, 0x17, 0xbe, 0x08, 0xe6, 0x4c, 0xe2, 0x79, 0x78, 0x40, 0xea, 0x55, 0x0e, 0x5c, - 0x16, 0xc0, 0xb9, 0x5e, 0xd0, 0x8c, 0xc2, 0xfe, 0xd6, 0xef, 0x15, 0xb0, 0x18, 0xcd, 0xdc, 0x05, - 0x6c, 0x95, 0x4e, 0x7a, 0xab, 0x3c, 0x7f, 0x6a, 0x9e, 0x14, 0xec, 0x90, 0xf7, 0xcb, 0x09, 0x9f, - 0x59, 0x12, 0xc2, 0x9f, 0x80, 0x9a, 0x47, 0x0c, 0xd2, 0xa7, 0xb6, 0x2b, 0x7c, 0x7e, 0x65, 0x4a, - 0x9f, 0xf1, 0x21, 0x31, 0xf6, 0x85, 0x69, 0xe7, 0x12, 0x73, 0x3a, 0x7c, 0x42, 0x11, 0x25, 0xfc, - 0x11, 0xa8, 0x51, 0x62, 0x3a, 0x06, 0xa6, 0x44, 0x6c, 0x93, 0x54, 0x7e, 0xb3, 0x74, 0x61, 0x64, - 0x7b, 0xb6, 0x76, 0x5f, 0xc0, 0xf8, 0x46, 0x89, 0xe6, 0x21, 0x6c, 0x45, 0x11, 0x0d, 0x3c, 0x06, - 0x4b, 0xbe, 0xa3, 0x31, 0x24, 0x65, 0x47, 0xf7, 0x60, 0x24, 0xd2, 0xe7, 0xe6, 0xa9, 0x13, 0x72, - 0x90, 0x32, 0xe9, 0xac, 0x89, 0x01, 0x96, 0xd2, 0xed, 0x28, 0x43, 0x0d, 0x37, 0xc1, 0xb2, 0xa9, - 0x5b, 0x88, 0x60, 0x6d, 0xb4, 0x4f, 0xfa, 0xb6, 0xa5, 0x79, 0x3c, 0x81, 0xaa, 0x9d, 0x75, 0x41, - 0xb0, 0xdc, 0x4b, 0x77, 0xa3, 0x2c, 0x1e, 0x6e, 0x83, 0xd5, 0xf0, 0x9c, 0xfd, 0x81, 0xee, 0x51, - 0xdb, 0x1d, 0x6d, 0xeb, 0xa6, 0x4e, 0xeb, 0xb3, 0x9c, 0xa7, 0x3e, 0x3e, 0x69, 0xae, 0x22, 0x49, - 0x3f, 0x92, 0x5a, 0xb5, 0x7e, 0x33, 0x0b, 0x96, 0x33, 0xa7, 0x01, 0x7c, 0x00, 0xd6, 0xfa, 0xbe, - 0xeb, 0x12, 0x8b, 0xee, 0xf8, 0xe6, 0x21, 0x71, 0xf7, 0xfb, 0x47, 0x44, 0xf3, 0x0d, 0xa2, 0xf1, - 0x15, 0xad, 0x76, 0x1a, 0xc2, 0xd7, 0xb5, 0xae, 0x14, 0x85, 0x0a, 0xac, 0xe1, 0x0f, 0x01, 0xb4, - 0x78, 0x53, 0x4f, 0xf7, 0xbc, 0x88, 0xb3, 0xc4, 0x39, 0xa3, 0x0d, 0xb8, 0x93, 0x43, 0x20, 0x89, - 0x15, 0xf3, 0x51, 0x23, 0x9e, 0xee, 0x12, 0x2d, 0xeb, 0x63, 0x39, 0xed, 0xe3, 0x96, 0x14, 0x85, - 0x0a, 0xac, 0xe1, 0xab, 0x60, 0x21, 0x18, 0x8d, 0xcf, 0xb9, 0x58, 0x9c, 0x15, 0x41, 0xb6, 0xb0, - 0x13, 0x77, 0xa1, 0x24, 0x8e, 0x85, 0x66, 0x1f, 0x7a, 0xc4, 0x1d, 0x12, 0xed, 0xcd, 0x40, 0x03, - 0xb0, 0x42, 0x59, 0xe5, 0x85, 0x32, 0x0a, 0x6d, 0x37, 0x87, 0x40, 0x12, 0x2b, 0x16, 0x5a, 0x90, - 0x35, 0xb9, 0xd0, 0x66, 0xd3, 0xa1, 0x1d, 0x48, 0x51, 0xa8, 0xc0, 0x9a, 0xe5, 0x5e, 0xe0, 0xf2, - 0xe6, 0x10, 0xeb, 0x06, 0x3e, 0x34, 0x48, 0x7d, 0x2e, 0x9d, 0x7b, 0x3b, 0xe9, 0x6e, 0x94, 0xc5, - 0xc3, 0x37, 0xc1, 0x95, 0xa0, 0xe9, 0xc0, 0xc2, 0x11, 0x49, 0x8d, 0x93, 0x3c, 0x27, 0x48, 0xae, - 0xec, 0x64, 0x01, 0x28, 0x6f, 0x03, 0x5f, 0x07, 0x4b, 0x7d, 0xdb, 0x30, 0x78, 0x3e, 0x76, 0x6d, - 0xdf, 0xa2, 0xf5, 0x79, 0xce, 0x02, 0xd9, 0x1e, 0xea, 0xa6, 0x7a, 0x50, 0x06, 0x09, 0x1f, 0x02, - 0xd0, 0x0f, 0xcb, 0x81, 0x57, 0x07, 0xc5, 0x85, 0x3e, 0x5f, 0x87, 0xe2, 0x02, 0x1c, 0x35, 0x79, - 0x28, 0xc1, 0xd6, 0x7a, 0x5f, 0x01, 0xeb, 0x05, 0x7b, 0x1c, 0x7e, 0x2f, 0x55, 0xf5, 0x6e, 0x66, - 0xaa, 0xde, 0xb5, 0x02, 0xb3, 0x44, 0xe9, 0xeb, 0x83, 0x45, 0xa6, 0x3b, 0x74, 0x6b, 0x10, 0x40, - 0xc4, 0x09, 0xf6, 0x92, 0xcc, 0x77, 0x94, 0x04, 0xc6, 0xc7, 0xf0, 0x95, 0xf1, 0x49, 0x73, 0x31, - 0xd5, 0x87, 0xd2, 0x9c, 0xad, 0x5f, 0x96, 0x00, 0xd8, 0x22, 0x8e, 0x61, 0x8f, 0x4c, 0x62, 0x5d, - 0x84, 0x6a, 0xd9, 0x4a, 0xa9, 0x96, 0x96, 0x74, 0x21, 0x22, 0x7f, 0x0a, 0x65, 0xcb, 0x76, 0x46, - 0xb6, 0x7c, 0x63, 0x02, 0xcf, 0xe9, 0xba, 0xe5, 0xef, 0x65, 0xb0, 0x12, 0x83, 0x63, 0xe1, 0x72, - 0x2f, 0xb5, 0x84, 0x2f, 0x64, 0x96, 0x70, 0x5d, 0x62, 0xf2, 0xa9, 0x29, 0x97, 0x77, 0xc1, 0x12, - 0xd3, 0x15, 0xc1, 0xaa, 0x71, 0xd5, 0x32, 0x7b, 0x66, 0xd5, 0x12, 0x55, 0x9d, 0xed, 0x14, 0x13, - 0xca, 0x30, 0x17, 0xa8, 0xa4, 0xb9, 0xcf, 0xa3, 0x4a, 0xfa, 0x83, 0x02, 0x96, 0xe2, 0x65, 0xba, - 0x00, 0x99, 0xd4, 0x4d, 0xcb, 0xa4, 0xc6, 0xe9, 0x79, 0x59, 0xa0, 0x93, 0xfe, 0x56, 0x49, 0x7a, - 0xcd, 0x85, 0xd2, 0x06, 0x7b, 0xa1, 0x72, 0x0c, 0xbd, 0x8f, 0x3d, 0x51, 0x56, 0x2f, 0x05, 0x2f, - 0x53, 0x41, 0x1b, 0x8a, 0x7a, 0x53, 0x92, 0xaa, 0xf4, 0xe9, 0x4a, 0xaa, 0xf2, 0x27, 0x23, 0xa9, - 0xee, 0x83, 0x9a, 0x17, 0x8a, 0xa9, 0x0a, 0xa7, 0xbc, 0x31, 0x69, 0x3b, 0x0b, 0x1d, 0x15, 0xb1, - 0x46, 0x0a, 0x2a, 0x62, 0x92, 0x69, 0xa7, 0xea, 0x67, 0xa9, 0x9d, 0x58, 0x7a, 0x3b, 0xd8, 0xf7, - 0x88, 0xc6, 0xb7, 0x52, 0x2d, 0x4e, 0xef, 0x3d, 0xde, 0x8a, 0x44, 0x2f, 0x3c, 0x00, 0xeb, 0x8e, - 0x6b, 0x0f, 0x5c, 0xe2, 0x79, 0x5b, 0x04, 0x6b, 0x86, 0x6e, 0x91, 0x30, 0x80, 0xa0, 0xea, 0x5d, - 0x1b, 0x9f, 0x34, 0xd7, 0xf7, 0xe4, 0x10, 0x54, 0x64, 0xdb, 0xfa, 0x53, 0x05, 0x5c, 0xce, 0x9e, - 0x88, 0x05, 0x42, 0x44, 0x39, 0x97, 0x10, 0x79, 0x39, 0x91, 0xa2, 0x81, 0x4a, 0x4b, 0xbc, 0xf3, - 0xe7, 0xd2, 0x74, 0x13, 0x2c, 0x0b, 0xe1, 0x11, 0x76, 0x0a, 0x29, 0x16, 0x2d, 0xcf, 0x41, 0xba, - 0x1b, 0x65, 0xf1, 0xf0, 0x1e, 0x58, 0x74, 0xb9, 0xb6, 0x0a, 0x09, 0x02, 0x7d, 0xf2, 0x15, 0x41, - 0xb0, 0x88, 0x92, 0x9d, 0x28, 0x8d, 0x65, 0xda, 0x24, 0x96, 0x1c, 0x21, 0x41, 0x25, 0xad, 0x4d, - 0x36, 0xb3, 0x00, 0x94, 0xb7, 0x81, 0x3d, 0xb0, 0xe2, 0x5b, 0x79, 0xaa, 0x20, 0xd7, 0xae, 0x09, - 0xaa, 0x95, 0x83, 0x3c, 0x04, 0xc9, 0xec, 0xe0, 0x8f, 0x53, 0x72, 0x65, 0x96, 0x9f, 0x22, 0x2f, - 0x9c, 0xbe, 0x1d, 0xa6, 0xd6, 0x2b, 0x12, 0x1d, 0x55, 0x9b, 0x56, 0x47, 0xb5, 0xde, 0x53, 0x00, - 0xcc, 0x6f, 0xc1, 0x89, 0x2f, 0xf7, 0x39, 0x8b, 0x44, 0x89, 0xd4, 0xe4, 0x0a, 0xe7, 0xe6, 0x64, - 0x85, 0x13, 0x9f, 0xa0, 0xd3, 0x49, 0x1c, 0x31, 0xbd, 0x17, 0x73, 0x31, 0x33, 0x85, 0xc4, 0x89, - 0xfd, 0x79, 0x36, 0x89, 0x93, 0xe0, 0x39, 0x5d, 0xe2, 0xfc, 0xab, 0x04, 0x56, 0x62, 0xf0, 0xd4, - 0x12, 0x47, 0x62, 0xf2, 0xe5, 0xe5, 0xcc, 0x74, 0xb2, 0x23, 0x9e, 0xba, 0xff, 0x13, 0xd9, 0x11, - 0x3b, 0x54, 0x20, 0x3b, 0x7e, 0x57, 0x4a, 0x7a, 0x7d, 0x46, 0xd9, 0xf1, 0x09, 0x5c, 0x55, 0x7c, - 0xee, 0x94, 0x4b, 0xeb, 0xcf, 0x65, 0x70, 0x39, 0xbb, 0x05, 0x53, 0x75, 0x50, 0x99, 0x58, 0x07, - 0xf7, 0xc0, 0xea, 0x23, 0xdf, 0x30, 0x46, 0x3c, 0x86, 0x44, 0x31, 0x0c, 0x2a, 0xe8, 0x57, 0x85, - 0xe5, 0xea, 0xf7, 0x25, 0x18, 0x24, 0xb5, 0xcc, 0x97, 0xc5, 0xca, 0xb3, 0x96, 0xc5, 0xea, 0x39, - 0xca, 0xa2, 0x5c, 0x59, 0x94, 0xcf, 0xa5, 0x2c, 0xa6, 0xae, 0x89, 0x92, 0xe3, 0x6a, 0xe2, 0x3b, - 0xfc, 0x58, 0x01, 0x6b, 0xf2, 0xd7, 0x67, 0x68, 0x80, 0x25, 0x13, 0x3f, 0x4e, 0x5e, 0x5e, 0x4c, - 0x2a, 0x18, 0x3e, 0xd5, 0x0d, 0x35, 0xf8, 0xba, 0xa3, 0xbe, 0x65, 0xd1, 0x5d, 0x77, 0x9f, 0xba, - 0xba, 0x35, 0x08, 0x0a, 0x6c, 0x2f, 0xc5, 0x85, 0x32, 0xdc, 0xf0, 0x21, 0xa8, 0x99, 0xf8, 0xf1, - 0xbe, 0xef, 0x0e, 0xc2, 0x42, 0x78, 0xf6, 0x71, 0x78, 0xee, 0xf7, 0x04, 0x0b, 0x8a, 0xf8, 0x5a, - 0x1f, 0x29, 0x60, 0xbd, 0xa0, 0x82, 0x7e, 0x81, 0xa2, 0xdc, 0x05, 0xd7, 0x53, 0x41, 0xb2, 0x0d, - 0x49, 0x1e, 0xf9, 0x06, 0xdf, 0x9b, 0x42, 0xaf, 0xdc, 0x04, 0xf3, 0x0e, 0x76, 0xa9, 0x1e, 0x09, - 0xdd, 0x6a, 0x67, 0x71, 0x7c, 0xd2, 0x9c, 0xdf, 0x0b, 0x1b, 0x51, 0xdc, 0xdf, 0xfa, 0x55, 0x09, - 0x2c, 0x24, 0x48, 0x2e, 0x40, 0x3b, 0xbc, 0x91, 0xd2, 0x0e, 0xd2, 0xaf, 0x31, 0xc9, 0xa8, 0x8a, - 0xc4, 0x43, 0x2f, 0x23, 0x1e, 0xbe, 0x39, 0x89, 0xe8, 0x74, 0xf5, 0xf0, 0xef, 0x12, 0x58, 0x4d, - 0xa0, 0x63, 0xf9, 0xf0, 0x9d, 0x94, 0x7c, 0xd8, 0xc8, 0xc8, 0x87, 0xba, 0xcc, 0xe6, 0x4b, 0xfd, - 0x30, 0x59, 0x3f, 0xfc, 0x51, 0x01, 0xcb, 0x89, 0xb9, 0xbb, 0x00, 0x01, 0xb1, 0x95, 0x16, 0x10, - 0xcd, 0x09, 0xf9, 0x52, 0xa0, 0x20, 0x7e, 0x3d, 0x9b, 0xf2, 0xfb, 0x0b, 0x7f, 0x73, 0xf1, 0x73, - 0xb0, 0x3a, 0xb4, 0x0d, 0xdf, 0x24, 0x5d, 0x03, 0xeb, 0x66, 0x08, 0x60, 0x15, 0x97, 0x4d, 0xe2, - 0x8b, 0x52, 0x7a, 0xe2, 0x7a, 0xba, 0x47, 0x89, 0x45, 0x1f, 0xc4, 0x96, 0x71, 0x9d, 0x7f, 0x20, - 0xa1, 0x43, 0xd2, 0x41, 0xe0, 0xab, 0x60, 0x81, 0x55, 0x4a, 0xbd, 0x4f, 0x76, 0xb0, 0x19, 0xe6, - 0x54, 0xf4, 0xed, 0x61, 0x3f, 0xee, 0x42, 0x49, 0x1c, 0x3c, 0x02, 0x2b, 0x8e, 0xad, 0xf5, 0xb0, - 0x85, 0x07, 0x84, 0x9d, 0xff, 0x7b, 0xb6, 0xa1, 0xf7, 0x47, 0xfc, 0x4e, 0x63, 0xbe, 0xf3, 0x5a, - 0xf8, 0xbe, 0xba, 0x97, 0x87, 0xb0, 0xf7, 0x01, 0x49, 0x33, 0xdf, 0xcf, 0x32, 0x4a, 0x68, 0xe6, - 0x3e, 0x95, 0xcd, 0xe5, 0xfe, 0x5f, 0x20, 0x4b, 0xae, 0x73, 0x7e, 0x2c, 0x2b, 0xba, 0xad, 0xa9, - 0x9d, 0xeb, 0xb6, 0x46, 0xa2, 0x67, 0xe7, 0xcf, 0xa6, 0x67, 0x5b, 0xef, 0x55, 0xc1, 0x95, 0xdc, - 0x19, 0xfb, 0x19, 0x5e, 0xb9, 0xe4, 0x84, 0x61, 0xf9, 0x0c, 0xc2, 0x70, 0x13, 0x2c, 0x8b, 0xef, - 0x74, 0x19, 0x5d, 0x19, 0xcd, 0x47, 0x37, 0xdd, 0x8d, 0xb2, 0x78, 0xd9, 0x95, 0x4f, 0xf5, 0x8c, - 0x57, 0x3e, 0x49, 0x2f, 0xc4, 0xdf, 0x4b, 0x82, 0xc4, 0xcd, 0x7b, 0x21, 0xfe, 0x65, 0x92, 0xc5, - 0xc3, 0xef, 0x86, 0x59, 0x19, 0x31, 0xcc, 0x71, 0x86, 0x4c, 0x9a, 0x45, 0x04, 0x19, 0xf4, 0x33, - 0x7d, 0x8b, 0x7a, 0x47, 0xf2, 0x2d, 0x6a, 0x63, 0xc2, 0x6e, 0x98, 0xfe, 0x76, 0x47, 0xaa, 0xdd, - 0x17, 0xce, 0xae, 0xdd, 0x5b, 0x7f, 0x55, 0xc0, 0x73, 0x85, 0xfb, 0x11, 0x6e, 0xa6, 0x6a, 0xfe, - 0xad, 0x4c, 0xcd, 0x7f, 0xbe, 0xd0, 0x30, 0x51, 0xf8, 0x4d, 0xf9, 0xc5, 0xcf, 0xdd, 0x89, 0x17, - 0x3f, 0x12, 0x45, 0x37, 0xf9, 0x06, 0xa8, 0xb3, 0xf1, 0xe4, 0x69, 0x63, 0xe6, 0x83, 0xa7, 0x8d, - 0x99, 0x0f, 0x9f, 0x36, 0x66, 0x7e, 0x31, 0x6e, 0x28, 0x4f, 0xc6, 0x0d, 0xe5, 0x83, 0x71, 0x43, - 0xf9, 0x70, 0xdc, 0x50, 0xfe, 0x31, 0x6e, 0x28, 0xbf, 0xfd, 0xa8, 0x31, 0xf3, 0xb0, 0x34, 0xbc, - 0xfd, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0x69, 0x8a, 0x39, 0xfa, 0x26, 0x00, 0x00, + // 2149 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcb, 0x6f, 0x1b, 0xc7, + 0x19, 0xd7, 0xf2, 0x21, 0x51, 0x23, 0x4b, 0xb2, 0x47, 0xaa, 0xc4, 0xd8, 0x0d, 0xe9, 0xb2, 0xae, + 0xa3, 0xc4, 0x31, 0x59, 0x3b, 0x4e, 0x50, 0xc4, 0x45, 0x02, 0x91, 0x4a, 0xd3, 0x34, 0x7a, 0x75, + 0x64, 0x39, 0x80, 0x9b, 0x16, 0x1d, 0x2d, 0xc7, 0xd4, 0x46, 0xfb, 0xc2, 0xee, 0x2c, 0x63, 0xa2, + 0x97, 0xa2, 0x40, 0x6f, 0x3d, 0xf4, 0x3f, 0x29, 0x8a, 0xa2, 0xb9, 0x15, 0x41, 0xd0, 0x8b, 0x2f, + 0x45, 0x83, 0x5e, 0x9a, 0x13, 0x51, 0x33, 0xa7, 0xa2, 0xe8, 0xad, 0xbd, 0xf8, 0xd2, 0x62, 0x66, + 0x67, 0xdf, 0xb3, 0x22, 0x25, 0x27, 0xca, 0x03, 0xbe, 0x89, 0x33, 0xbf, 0xef, 0x37, 0xdf, 0xcc, + 0x7c, 0xdf, 0x7c, 0xbf, 0x99, 0x15, 0xb8, 0x7d, 0xf4, 0x3d, 0xb7, 0xa9, 0x59, 0xad, 0x23, 0xef, + 0x80, 0x38, 0x26, 0xa1, 0xc4, 0x6d, 0xf5, 0x89, 0xd9, 0xb5, 0x9c, 0x96, 0xe8, 0xc0, 0xb6, 0xd6, + 0xc2, 0xb6, 0xed, 0xb6, 0xfa, 0x37, 0x5a, 0x3d, 0x62, 0x12, 0x07, 0x53, 0xd2, 0x6d, 0xda, 0x8e, + 0x45, 0x2d, 0x08, 0x7d, 0x4c, 0x13, 0xdb, 0x5a, 0x93, 0x61, 0x9a, 0xfd, 0x1b, 0x17, 0xaf, 0xf7, + 0x34, 0x7a, 0xe8, 0x1d, 0x34, 0x55, 0xcb, 0x68, 0xf5, 0xac, 0x9e, 0xd5, 0xe2, 0xd0, 0x03, 0xef, + 0x3e, 0xff, 0xc5, 0x7f, 0xf0, 0xbf, 0x7c, 0x8a, 0x8b, 0x8d, 0xd8, 0x30, 0xaa, 0xe5, 0x10, 0xc9, + 0x30, 0x17, 0x6f, 0x45, 0x18, 0x03, 0xab, 0x87, 0x9a, 0x49, 0x9c, 0x41, 0xcb, 0x3e, 0xea, 0xb1, + 0x06, 0xb7, 0x65, 0x10, 0x8a, 0x65, 0x56, 0xad, 0x3c, 0x2b, 0xc7, 0x33, 0xa9, 0x66, 0x90, 0x8c, + 0xc1, 0x2b, 0xe3, 0x0c, 0x5c, 0xf5, 0x90, 0x18, 0x38, 0x63, 0xf7, 0x52, 0x9e, 0x9d, 0x47, 0x35, + 0xbd, 0xa5, 0x99, 0xd4, 0xa5, 0x4e, 0xda, 0xa8, 0xf1, 0x5f, 0x05, 0xc0, 0x8e, 0x65, 0x52, 0xc7, + 0xd2, 0x75, 0xe2, 0x20, 0xd2, 0xd7, 0x5c, 0xcd, 0x32, 0xe1, 0xcf, 0x41, 0x85, 0xcd, 0xa7, 0x8b, + 0x29, 0xae, 0x2a, 0x97, 0x95, 0xb5, 0xb9, 0x9b, 0xdf, 0x6d, 0x46, 0x8b, 0x1c, 0xd2, 0x37, 0xed, + 0xa3, 0x1e, 0x6b, 0x70, 0x9b, 0x0c, 0xdd, 0xec, 0xdf, 0x68, 0xee, 0x1c, 0xbc, 0x47, 0x54, 0xba, + 0x45, 0x28, 0x6e, 0xc3, 0x87, 0xc3, 0xfa, 0xd4, 0x68, 0x58, 0x07, 0x51, 0x1b, 0x0a, 0x59, 0xe1, + 0x0e, 0x28, 0x71, 0xf6, 0x02, 0x67, 0xbf, 0x9e, 0xcb, 0x2e, 0x26, 0xdd, 0x44, 0xf8, 0xfd, 0x37, + 0x1e, 0x50, 0x62, 0x32, 0xf7, 0xda, 0xe7, 0x04, 0x75, 0x69, 0x03, 0x53, 0x8c, 0x38, 0x11, 0x7c, + 0x11, 0x54, 0x1c, 0xe1, 0x7e, 0xb5, 0x78, 0x59, 0x59, 0x2b, 0xb6, 0xcf, 0x0b, 0x54, 0x25, 0x98, + 0x16, 0x0a, 0x11, 0x8d, 0x3f, 0x2b, 0x60, 0x25, 0x3b, 0xef, 0x4d, 0xcd, 0xa5, 0xf0, 0xdd, 0xcc, + 0xdc, 0x9b, 0x93, 0xcd, 0x9d, 0x59, 0xf3, 0x99, 0x87, 0x03, 0x07, 0x2d, 0xb1, 0x79, 0xbf, 0x0d, + 0xca, 0x1a, 0x25, 0x86, 0x5b, 0x2d, 0x5c, 0x2e, 0xae, 0xcd, 0xdd, 0xbc, 0xda, 0xcc, 0xc6, 0x6e, + 0x33, 0xeb, 0x58, 0x7b, 0x5e, 0x50, 0x96, 0xdf, 0x62, 0xc6, 0xc8, 0xe7, 0x68, 0xfc, 0x4f, 0x01, + 0xb3, 0x1b, 0x98, 0x18, 0x96, 0xb9, 0x47, 0xe8, 0x19, 0x6c, 0x5a, 0x07, 0x94, 0x5c, 0x9b, 0xa8, + 0x62, 0xd3, 0xbe, 0x25, 0xf3, 0x3d, 0x74, 0x67, 0xcf, 0x26, 0x6a, 0xb4, 0x51, 0xec, 0x17, 0xe2, + 0xc6, 0xf0, 0x6d, 0x30, 0xed, 0x52, 0x4c, 0x3d, 0x97, 0x6f, 0xd3, 0xdc, 0xcd, 0x6f, 0x1f, 0x4f, + 0xc3, 0xa1, 0xed, 0x05, 0x41, 0x34, 0xed, 0xff, 0x46, 0x82, 0xa2, 0xf1, 0xcf, 0x02, 0x80, 0x21, + 0xb6, 0x63, 0x99, 0x5d, 0x8d, 0xb2, 0xf8, 0x7d, 0x15, 0x94, 0xe8, 0xc0, 0x26, 0x7c, 0x19, 0x66, + 0xdb, 0x57, 0x03, 0x2f, 0xee, 0x0c, 0x6c, 0xf2, 0x78, 0x58, 0x5f, 0xc9, 0x5a, 0xb0, 0x1e, 0xc4, + 0x6d, 0xe0, 0x66, 0xe8, 0x5f, 0x81, 0x5b, 0xdf, 0x4a, 0x0e, 0xfd, 0x78, 0x58, 0x97, 0x1c, 0x16, + 0xcd, 0x90, 0x29, 0xe9, 0x20, 0xec, 0x03, 0xa8, 0x63, 0x97, 0xde, 0x71, 0xb0, 0xe9, 0xfa, 0x23, + 0x69, 0x06, 0x11, 0x33, 0x7f, 0x61, 0xb2, 0xed, 0x61, 0x16, 0xed, 0x8b, 0xc2, 0x0b, 0xb8, 0x99, + 0x61, 0x43, 0x92, 0x11, 0xe0, 0x55, 0x30, 0xed, 0x10, 0xec, 0x5a, 0x66, 0xb5, 0xc4, 0x67, 0x11, + 0x2e, 0x20, 0xe2, 0xad, 0x48, 0xf4, 0xc2, 0xe7, 0xc1, 0x8c, 0x41, 0x5c, 0x17, 0xf7, 0x48, 0xb5, + 0xcc, 0x81, 0x8b, 0x02, 0x38, 0xb3, 0xe5, 0x37, 0xa3, 0xa0, 0xbf, 0xf1, 0x7b, 0x05, 0xcc, 0x87, + 0x2b, 0x77, 0x06, 0xa9, 0xd2, 0x4e, 0xa6, 0xca, 0xb3, 0xc7, 0xc6, 0x49, 0x4e, 0x86, 0x7c, 0x58, + 0x8c, 0xf9, 0xcc, 0x82, 0x10, 0xfe, 0x14, 0x54, 0x5c, 0xa2, 0x13, 0x95, 0x5a, 0x8e, 0xf0, 0xf9, + 0xa5, 0x09, 0x7d, 0xc6, 0x07, 0x44, 0xdf, 0x13, 0xa6, 0xed, 0x73, 0xcc, 0xe9, 0xe0, 0x17, 0x0a, + 0x29, 0xe1, 0x8f, 0x41, 0x85, 0x12, 0xc3, 0xd6, 0x31, 0x25, 0x22, 0x4d, 0x12, 0xf1, 0xcd, 0xc2, + 0x85, 0x91, 0xed, 0x5a, 0xdd, 0x3b, 0x02, 0xc6, 0x13, 0x25, 0x5c, 0x87, 0xa0, 0x15, 0x85, 0x34, + 0xf0, 0x08, 0x2c, 0x78, 0x76, 0x97, 0x21, 0x29, 0x3b, 0xba, 0x7b, 0x03, 0x11, 0x3e, 0xd7, 0x8e, + 0x5d, 0x90, 0xfd, 0x84, 0x49, 0x7b, 0x45, 0x0c, 0xb0, 0x90, 0x6c, 0x47, 0x29, 0x6a, 0xb8, 0x0e, + 0x16, 0x0d, 0xcd, 0x44, 0x04, 0x77, 0x07, 0x7b, 0x44, 0xb5, 0xcc, 0xae, 0xcb, 0x03, 0xa8, 0xdc, + 0x5e, 0x15, 0x04, 0x8b, 0x5b, 0xc9, 0x6e, 0x94, 0xc6, 0xc3, 0x4d, 0xb0, 0x1c, 0x9c, 0xb3, 0x3f, + 0xd4, 0x5c, 0x6a, 0x39, 0x83, 0x4d, 0xcd, 0xd0, 0x68, 0x75, 0x9a, 0xf3, 0x54, 0x47, 0xc3, 0xfa, + 0x32, 0x92, 0xf4, 0x23, 0xa9, 0x55, 0xe3, 0x37, 0xd3, 0x60, 0x31, 0x75, 0x1a, 0xc0, 0xbb, 0x60, + 0x45, 0xf5, 0x1c, 0x87, 0x98, 0x74, 0xdb, 0x33, 0x0e, 0x88, 0xb3, 0xa7, 0x1e, 0x92, 0xae, 0xa7, + 0x93, 0x2e, 0xdf, 0xd1, 0x72, 0xbb, 0x26, 0x7c, 0x5d, 0xe9, 0x48, 0x51, 0x28, 0xc7, 0x1a, 0xfe, + 0x08, 0x40, 0x93, 0x37, 0x6d, 0x69, 0xae, 0x1b, 0x72, 0x16, 0x38, 0x67, 0x98, 0x80, 0xdb, 0x19, + 0x04, 0x92, 0x58, 0x31, 0x1f, 0xbb, 0xc4, 0xd5, 0x1c, 0xd2, 0x4d, 0xfb, 0x58, 0x4c, 0xfa, 0xb8, + 0x21, 0x45, 0xa1, 0x1c, 0x6b, 0xf8, 0x32, 0x98, 0xf3, 0x47, 0xe3, 0x6b, 0x2e, 0x36, 0x67, 0x49, + 0x90, 0xcd, 0x6d, 0x47, 0x5d, 0x28, 0x8e, 0x63, 0x53, 0xb3, 0x0e, 0x5c, 0xe2, 0xf4, 0x49, 0xf7, + 0x4d, 0x5f, 0x03, 0xb0, 0x42, 0x59, 0xe6, 0x85, 0x32, 0x9c, 0xda, 0x4e, 0x06, 0x81, 0x24, 0x56, + 0x6c, 0x6a, 0x7e, 0xd4, 0x64, 0xa6, 0x36, 0x9d, 0x9c, 0xda, 0xbe, 0x14, 0x85, 0x72, 0xac, 0x59, + 0xec, 0xf9, 0x2e, 0xaf, 0xf7, 0xb1, 0xa6, 0xe3, 0x03, 0x9d, 0x54, 0x67, 0x92, 0xb1, 0xb7, 0x9d, + 0xec, 0x46, 0x69, 0x3c, 0x7c, 0x13, 0x5c, 0xf0, 0x9b, 0xf6, 0x4d, 0x1c, 0x92, 0x54, 0x38, 0xc9, + 0x33, 0x82, 0xe4, 0xc2, 0x76, 0x1a, 0x80, 0xb2, 0x36, 0xf0, 0x55, 0xb0, 0xa0, 0x5a, 0xba, 0xce, + 0xe3, 0xb1, 0x63, 0x79, 0x26, 0xad, 0xce, 0x72, 0x16, 0xc8, 0x72, 0xa8, 0x93, 0xe8, 0x41, 0x29, + 0x24, 0xbc, 0x07, 0x80, 0x1a, 0x94, 0x03, 0xb7, 0x0a, 0xf2, 0x0b, 0x7d, 0xb6, 0x0e, 0x45, 0x05, + 0x38, 0x6c, 0x72, 0x51, 0x8c, 0xad, 0xf1, 0xa1, 0x02, 0x56, 0x73, 0x72, 0x1c, 0xbe, 0x9e, 0xa8, + 0x7a, 0xd7, 0x52, 0x55, 0xef, 0x52, 0x8e, 0x59, 0xac, 0xf4, 0xa9, 0x60, 0x9e, 0xe9, 0x0e, 0xcd, + 0xec, 0xf9, 0x10, 0x71, 0x82, 0xbd, 0x20, 0xf3, 0x1d, 0xc5, 0x81, 0xd1, 0x31, 0x7c, 0x61, 0x34, + 0xac, 0xcf, 0x27, 0xfa, 0x50, 0x92, 0xb3, 0xf1, 0xab, 0x02, 0x00, 0x1b, 0xc4, 0xd6, 0xad, 0x81, + 0x41, 0xcc, 0xb3, 0x50, 0x2d, 0x1b, 0x09, 0xd5, 0xd2, 0x90, 0x6e, 0x44, 0xe8, 0x4f, 0xae, 0x6c, + 0xd9, 0x4c, 0xc9, 0x96, 0x2b, 0x63, 0x78, 0x8e, 0xd7, 0x2d, 0x7f, 0x2f, 0x82, 0xa5, 0x08, 0x1c, + 0x09, 0x97, 0xdb, 0x89, 0x2d, 0x7c, 0x2e, 0xb5, 0x85, 0xab, 0x12, 0x93, 0xcf, 0x4d, 0xb9, 0xbc, + 0x07, 0x16, 0x98, 0xae, 0xf0, 0x77, 0x8d, 0xab, 0x96, 0xe9, 0x13, 0xab, 0x96, 0xb0, 0xea, 0x6c, + 0x26, 0x98, 0x50, 0x8a, 0x39, 0x47, 0x25, 0xcd, 0x7c, 0x15, 0x55, 0xd2, 0x1f, 0x14, 0xb0, 0x10, + 0x6d, 0xd3, 0x19, 0xc8, 0xa4, 0x4e, 0x52, 0x26, 0xd5, 0x8e, 0x8f, 0xcb, 0x1c, 0x9d, 0xf4, 0xb7, + 0x52, 0xdc, 0x6b, 0x2e, 0x94, 0xd6, 0xd8, 0x85, 0xca, 0xd6, 0x35, 0x15, 0xbb, 0xa2, 0xac, 0x9e, + 0xf3, 0x2f, 0x53, 0x7e, 0x1b, 0x0a, 0x7b, 0x13, 0x92, 0xaa, 0xf0, 0xf9, 0x4a, 0xaa, 0xe2, 0x67, + 0x23, 0xa9, 0xee, 0x80, 0x8a, 0x1b, 0x88, 0xa9, 0x12, 0xa7, 0xbc, 0x3a, 0x2e, 0x9d, 0x85, 0x8e, + 0x0a, 0x59, 0x43, 0x05, 0x15, 0x32, 0xc9, 0xb4, 0x53, 0xf9, 0x8b, 0xd4, 0x4e, 0x2c, 0xbc, 0x6d, + 0xec, 0xb9, 0xa4, 0xcb, 0x53, 0xa9, 0x12, 0x85, 0xf7, 0x2e, 0x6f, 0x45, 0xa2, 0x17, 0xee, 0x83, + 0x55, 0xdb, 0xb1, 0x7a, 0x0e, 0x71, 0xdd, 0x0d, 0x82, 0xbb, 0xba, 0x66, 0x92, 0x60, 0x02, 0x7e, + 0xd5, 0xbb, 0x34, 0x1a, 0xd6, 0x57, 0x77, 0xe5, 0x10, 0x94, 0x67, 0xdb, 0xf8, 0x53, 0x09, 0x9c, + 0x4f, 0x9f, 0x88, 0x39, 0x42, 0x44, 0x39, 0x95, 0x10, 0x79, 0x31, 0x16, 0xa2, 0xbe, 0x4a, 0x8b, + 0xdd, 0xf9, 0x33, 0x61, 0xba, 0x0e, 0x16, 0x85, 0xf0, 0x08, 0x3a, 0x85, 0x14, 0x0b, 0xb7, 0x67, + 0x3f, 0xd9, 0x8d, 0xd2, 0x78, 0x78, 0x1b, 0xcc, 0x3b, 0x5c, 0x5b, 0x05, 0x04, 0xbe, 0x3e, 0xf9, + 0x86, 0x20, 0x98, 0x47, 0xf1, 0x4e, 0x94, 0xc4, 0x32, 0x6d, 0x12, 0x49, 0x8e, 0x80, 0xa0, 0x94, + 0xd4, 0x26, 0xeb, 0x69, 0x00, 0xca, 0xda, 0xc0, 0x2d, 0xb0, 0xe4, 0x99, 0x59, 0x2a, 0x3f, 0xd6, + 0x2e, 0x09, 0xaa, 0xa5, 0xfd, 0x2c, 0x04, 0xc9, 0xec, 0xe0, 0x4f, 0x12, 0x72, 0x65, 0x9a, 0x9f, + 0x22, 0xcf, 0x1d, 0x9f, 0x0e, 0x13, 0xeb, 0x15, 0x89, 0x8e, 0xaa, 0x4c, 0xaa, 0xa3, 0x1a, 0x1f, + 0x28, 0x00, 0x66, 0x53, 0x70, 0xec, 0xe5, 0x3e, 0x63, 0x11, 0x2b, 0x91, 0x5d, 0xb9, 0xc2, 0xb9, + 0x36, 0x5e, 0xe1, 0x44, 0x27, 0xe8, 0x64, 0x12, 0x47, 0x2c, 0xef, 0xd9, 0x3c, 0xcc, 0x4c, 0x20, + 0x71, 0x22, 0x7f, 0x9e, 0x4c, 0xe2, 0xc4, 0x78, 0x8e, 0x97, 0x38, 0xff, 0x2a, 0x80, 0xa5, 0x08, + 0x3c, 0xb1, 0xc4, 0x91, 0x98, 0x3c, 0x7d, 0x9c, 0x99, 0x4c, 0x76, 0x44, 0x4b, 0xf7, 0x25, 0x91, + 0x1d, 0x91, 0x43, 0x39, 0xb2, 0xe3, 0x77, 0x85, 0xb8, 0xd7, 0x27, 0x94, 0x1d, 0x9f, 0xc1, 0x53, + 0xc5, 0x57, 0x4e, 0xb9, 0x34, 0x3e, 0x2a, 0x82, 0xf3, 0xe9, 0x14, 0x4c, 0xd4, 0x41, 0x65, 0x6c, + 0x1d, 0xdc, 0x05, 0xcb, 0xf7, 0x3d, 0x5d, 0x1f, 0xf0, 0x39, 0xc4, 0x8a, 0xa1, 0x5f, 0x41, 0xbf, + 0x29, 0x2c, 0x97, 0x7f, 0x20, 0xc1, 0x20, 0xa9, 0x65, 0xb6, 0x2c, 0x96, 0x9e, 0xb4, 0x2c, 0x96, + 0x4f, 0x51, 0x16, 0xe5, 0xca, 0xa2, 0x78, 0x2a, 0x65, 0x31, 0x71, 0x4d, 0x94, 0x1c, 0x57, 0x63, + 0xef, 0xf0, 0x23, 0x05, 0xac, 0xc8, 0xaf, 0xcf, 0x50, 0x07, 0x0b, 0x06, 0x7e, 0x10, 0x7f, 0xbc, + 0x18, 0x57, 0x30, 0x3c, 0xaa, 0xe9, 0x4d, 0xff, 0xeb, 0x4e, 0xf3, 0x2d, 0x93, 0xee, 0x38, 0x7b, + 0xd4, 0xd1, 0xcc, 0x9e, 0x5f, 0x60, 0xb7, 0x12, 0x5c, 0x28, 0xc5, 0x0d, 0xef, 0x81, 0x8a, 0x81, + 0x1f, 0xec, 0x79, 0x4e, 0x2f, 0x28, 0x84, 0x27, 0x1f, 0x87, 0xc7, 0xfe, 0x96, 0x60, 0x41, 0x21, + 0x5f, 0xe3, 0x53, 0x05, 0xac, 0xe6, 0x54, 0xd0, 0xaf, 0xd1, 0x2c, 0x77, 0xc0, 0xe5, 0xc4, 0x24, + 0x59, 0x42, 0x92, 0xfb, 0x9e, 0xce, 0x73, 0x53, 0xe8, 0x95, 0x6b, 0x60, 0xd6, 0xc6, 0x0e, 0xd5, + 0x42, 0xa1, 0x5b, 0x6e, 0xcf, 0x8f, 0x86, 0xf5, 0xd9, 0xdd, 0xa0, 0x11, 0x45, 0xfd, 0x8d, 0x5f, + 0x17, 0xc0, 0x5c, 0x8c, 0xe4, 0x0c, 0xb4, 0xc3, 0x1b, 0x09, 0xed, 0x20, 0xfd, 0x1a, 0x13, 0x9f, + 0x55, 0x9e, 0x78, 0xd8, 0x4a, 0x89, 0x87, 0xef, 0x8c, 0x23, 0x3a, 0x5e, 0x3d, 0xfc, 0xbb, 0x00, + 0x96, 0x63, 0xe8, 0x48, 0x3e, 0x7c, 0x3f, 0x21, 0x1f, 0xd6, 0x52, 0xf2, 0xa1, 0x2a, 0xb3, 0x79, + 0xaa, 0x1f, 0xc6, 0xeb, 0x87, 0x3f, 0x2a, 0x60, 0x31, 0xb6, 0x76, 0x67, 0x20, 0x20, 0x36, 0x92, + 0x02, 0xa2, 0x3e, 0x26, 0x5e, 0x72, 0x14, 0xc4, 0x7f, 0x14, 0xd0, 0x8a, 0xa1, 0x76, 0x89, 0xe3, + 0x6a, 0x2e, 0x25, 0x26, 0xbd, 0x6b, 0xe9, 0x9e, 0x41, 0x3a, 0x3a, 0xd6, 0x0c, 0x44, 0x58, 0x83, + 0x66, 0x99, 0xbb, 0x96, 0xae, 0xa9, 0x03, 0x88, 0xc1, 0xdc, 0xfb, 0x87, 0xc4, 0xdc, 0x20, 0x3a, + 0xa1, 0xe2, 0x9b, 0xc1, 0x6c, 0xfb, 0xf5, 0xe0, 0x09, 0xfd, 0x9d, 0xa8, 0xeb, 0xf1, 0xb0, 0xbe, + 0x36, 0x09, 0x23, 0x0f, 0xb0, 0x38, 0x27, 0xfc, 0x19, 0x00, 0xec, 0xe7, 0x9e, 0x8a, 0x83, 0x2f, + 0x08, 0xb3, 0xed, 0xd7, 0x82, 0x34, 0x7c, 0x27, 0xec, 0x39, 0xd1, 0x00, 0x31, 0xc6, 0xc6, 0x5f, + 0x67, 0x12, 0xdb, 0xf5, 0xb5, 0x7f, 0xb0, 0xf9, 0x05, 0x58, 0xee, 0x47, 0xab, 0x13, 0x00, 0x98, + 0xd0, 0x60, 0xb1, 0xf3, 0xbc, 0x94, 0x5e, 0xb6, 0xae, 0x91, 0xbc, 0xb9, 0x2b, 0xa1, 0x43, 0xd2, + 0x41, 0xe0, 0xcb, 0x60, 0x8e, 0x09, 0x04, 0x4d, 0x25, 0xdb, 0xd8, 0x08, 0x52, 0x29, 0xfc, 0xe4, + 0xb2, 0x17, 0x75, 0xa1, 0x38, 0x0e, 0x1e, 0x82, 0x25, 0xdb, 0xea, 0x6e, 0x61, 0x13, 0xf7, 0x08, + 0x2b, 0x7b, 0xfe, 0x56, 0xf2, 0xa7, 0x9c, 0xd9, 0xf6, 0x2b, 0xc1, 0x35, 0x7d, 0x37, 0x0b, 0x61, + 0xd7, 0x20, 0x49, 0x33, 0x0f, 0x02, 0x19, 0x25, 0x34, 0x32, 0x5f, 0x08, 0x67, 0x32, 0xff, 0x56, + 0x21, 0xcb, 0xa9, 0x53, 0x7e, 0x23, 0xcc, 0x7b, 0xa4, 0xaa, 0x9c, 0xea, 0x91, 0x4a, 0x22, 0xe3, + 0x67, 0x4f, 0x28, 0xe3, 0x3f, 0x52, 0xc0, 0x15, 0x7b, 0x82, 0x34, 0xaa, 0x02, 0xbe, 0x2c, 0x9d, + 0x31, 0xcb, 0x32, 0x49, 0x46, 0xb6, 0xd7, 0x46, 0xc3, 0xfa, 0x95, 0x49, 0x90, 0x68, 0x22, 0xd7, + 0x1a, 0x1f, 0x94, 0xc1, 0x85, 0x4c, 0x79, 0xfc, 0x02, 0x5f, 0xcb, 0x32, 0x9a, 0xbe, 0x78, 0x02, + 0x4d, 0xbf, 0x0e, 0x16, 0xc5, 0x27, 0xd6, 0xd4, 0x95, 0x20, 0xdc, 0xd3, 0x4e, 0xb2, 0x1b, 0xa5, + 0xf1, 0xb2, 0xd7, 0xba, 0xf2, 0x09, 0x5f, 0xeb, 0xe2, 0x5e, 0x88, 0xff, 0x0c, 0xf2, 0x93, 0x2f, + 0xeb, 0x85, 0xf8, 0x07, 0xa1, 0x34, 0x1e, 0xbe, 0x16, 0x64, 0x56, 0xc8, 0x30, 0xc3, 0x19, 0x52, + 0xa9, 0x12, 0x12, 0xa4, 0xd0, 0x4f, 0xf4, 0x19, 0xf1, 0x5d, 0xc9, 0x67, 0xc4, 0xb5, 0x31, 0xa1, + 0x3b, 0xf9, 0xc3, 0x9c, 0xf4, 0xda, 0x35, 0x77, 0xf2, 0x6b, 0x57, 0xe3, 0x2f, 0x0a, 0x78, 0x26, + 0xf7, 0x4c, 0x81, 0xeb, 0x09, 0xb9, 0x76, 0x3d, 0x25, 0xd7, 0x9e, 0xcd, 0x35, 0x8c, 0x69, 0x36, + 0x43, 0xfe, 0x66, 0x77, 0x6b, 0xec, 0x9b, 0x9d, 0x44, 0x8c, 0x8f, 0x7f, 0xbc, 0x6b, 0xaf, 0x3d, + 0x7c, 0x54, 0x9b, 0xfa, 0xf8, 0x51, 0x6d, 0xea, 0x93, 0x47, 0xb5, 0xa9, 0x5f, 0x8e, 0x6a, 0xca, + 0xc3, 0x51, 0x4d, 0xf9, 0x78, 0x54, 0x53, 0x3e, 0x19, 0xd5, 0x94, 0x7f, 0x8c, 0x6a, 0xca, 0x6f, + 0x3f, 0xad, 0x4d, 0xdd, 0x2b, 0xf4, 0x6f, 0xfc, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xc5, 0x7f, 0x6b, + 0xc0, 0xb5, 0x28, 0x00, 0x00, } func (m *ControllerRevision) Marshal() (dAtA []byte, err error) { @@ -2291,6 +2329,39 @@ func (m *StatefulSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.WhenScaled) + copy(dAtA[i:], m.WhenScaled) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenScaled))) + i-- + dAtA[i] = 0x12 + i -= len(m.WhenDeleted) + copy(dAtA[i:], m.WhenDeleted) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenDeleted))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *StatefulSetSpec) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2311,6 +2382,18 @@ func (m *StatefulSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.PersistentVolumeClaimRetentionPolicy != nil { + { + size, err := m.PersistentVolumeClaimRetentionPolicy.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) i-- dAtA[i] = 0x48 @@ -2955,6 +3038,19 @@ func (m *StatefulSetList) Size() (n int) { return n } +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.WhenDeleted) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.WhenScaled) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *StatefulSetSpec) Size() (n int) { if m == nil { return 0 @@ -2986,6 +3082,10 @@ func (m *StatefulSetSpec) Size() (n int) { n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) } n += 1 + sovGenerated(uint64(m.MinReadySeconds)) + if m.PersistentVolumeClaimRetentionPolicy != nil { + l = m.PersistentVolumeClaimRetentionPolicy.Size() + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -3399,6 +3499,17 @@ func (this *StatefulSetList) String() string { }, "") return s } +func (this *StatefulSetPersistentVolumeClaimRetentionPolicy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StatefulSetPersistentVolumeClaimRetentionPolicy{`, + `WhenDeleted:` + fmt.Sprintf("%v", this.WhenDeleted) + `,`, + `WhenScaled:` + fmt.Sprintf("%v", this.WhenScaled) + `,`, + `}`, + }, "") + return s +} func (this *StatefulSetSpec) String() string { if this == nil { return "nil" @@ -3418,6 +3529,7 @@ func (this *StatefulSetSpec) String() string { `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "StatefulSetUpdateStrategy", "StatefulSetUpdateStrategy", 1), `&`, ``, 1) + `,`, `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, + `PersistentVolumeClaimRetentionPolicy:` + strings.Replace(this.PersistentVolumeClaimRetentionPolicy.String(), "StatefulSetPersistentVolumeClaimRetentionPolicy", "StatefulSetPersistentVolumeClaimRetentionPolicy", 1) + `,`, `}`, }, "") return s @@ -7461,6 +7573,120 @@ func (m *StatefulSetList) Unmarshal(dAtA []byte) error { } return nil } +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WhenDeleted", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WhenDeleted = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WhenScaled", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WhenScaled = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -7749,6 +7975,42 @@ func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error { break } } + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeClaimRetentionPolicy", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PersistentVolumeClaimRetentionPolicy == nil { + m.PersistentVolumeClaimRetentionPolicy = &StatefulSetPersistentVolumeClaimRetentionPolicy{} + } + if err := m.PersistentVolumeClaimRetentionPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/vendor/k8s.io/api/apps/v1/generated.proto b/vendor/k8s.io/api/apps/v1/generated.proto index 6e593a3799..6e5517d81f 100644 --- a/vendor/k8s.io/api/apps/v1/generated.proto +++ b/vendor/k8s.io/api/apps/v1/generated.proto @@ -165,8 +165,8 @@ message DaemonSetStatus { // More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ optional int32 desiredNumberScheduled = 3; - // The number of nodes that should be running the daemon pod and have one - // or more of the daemon pod running and ready. + // numberReady is the number of nodes that should be running the daemon pod and have one + // or more of the daemon pod running with a Ready Condition. optional int32 numberReady = 4; // The most recent generation observed by the daemon set controller. @@ -322,7 +322,7 @@ message DeploymentStatus { // +optional optional int32 updatedReplicas = 3; - // Total number of ready pods targeted by this deployment. + // readyReplicas is the number of pods targeted by this Deployment with a Ready Condition. // +optional optional int32 readyReplicas = 7; @@ -457,7 +457,7 @@ message ReplicaSetStatus { // +optional optional int32 fullyLabeledReplicas = 2; - // The number of ready replicas for this replica set. + // readyReplicas is the number of pods targeted by this ReplicaSet with a Ready Condition. // +optional optional int32 readyReplicas = 4; @@ -611,6 +611,23 @@ message StatefulSetList { repeated StatefulSet items = 2; } +// StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs +// created from the StatefulSet VolumeClaimTemplates. +message StatefulSetPersistentVolumeClaimRetentionPolicy { + // WhenDeleted specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is deleted. The default policy + // of `Retain` causes PVCs to not be affected by StatefulSet deletion. The + // `Delete` policy causes those PVCs to be deleted. + optional string whenDeleted = 1; + + // WhenScaled specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is scaled down. The default + // policy of `Retain` causes PVCs to not be affected by a scaledown. The + // `Delete` policy causes the associated PVCs for any excess pods above + // the replica count to be deleted. + optional string whenScaled = 2; +} + // A StatefulSetSpec is the specification of a StatefulSet. message StatefulSetSpec { // replicas is the desired number of replicas of the given Template. @@ -677,6 +694,15 @@ message StatefulSetSpec { // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. // +optional optional int32 minReadySeconds = 9; + + // persistentVolumeClaimRetentionPolicy describes the lifecycle of persistent + // volume claims created from volumeClaimTemplates. By default, all persistent + // volume claims are created as needed and retained until manually deleted. This + // policy allows the lifecycle to be altered, for example by deleting persistent + // volume claims when their stateful set is deleted, or when their pod is scaled + // down. This requires the StatefulSetAutoDeletePVC feature gate to be enabled, + // which is alpha. +optional + optional StatefulSetPersistentVolumeClaimRetentionPolicy persistentVolumeClaimRetentionPolicy = 10; } // StatefulSetStatus represents the current state of a StatefulSet. @@ -689,7 +715,7 @@ message StatefulSetStatus { // replicas is the number of Pods created by the StatefulSet controller. optional int32 replicas = 2; - // readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. + // readyReplicas is the number of pods created for this StatefulSet with a Ready Condition. optional int32 readyReplicas = 3; // currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version @@ -721,9 +747,7 @@ message StatefulSetStatus { repeated StatefulSetCondition conditions = 10; // Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset. - // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. - // Remove omitempty when graduating to beta - // +optional + // This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate. optional int32 availableReplicas = 11; } diff --git a/vendor/k8s.io/api/apps/v1/types.go b/vendor/k8s.io/api/apps/v1/types.go index 51c9fa43d5..469b47297f 100644 --- a/vendor/k8s.io/api/apps/v1/types.go +++ b/vendor/k8s.io/api/apps/v1/types.go @@ -61,6 +61,7 @@ type StatefulSet struct { } // PodManagementPolicyType defines the policy for creating pods under a stateful set. +// +enum type PodManagementPolicyType string const ( @@ -90,6 +91,7 @@ type StatefulSetUpdateStrategy struct { // StatefulSetUpdateStrategyType is a string enumeration type that enumerates // all possible update strategies for the StatefulSet controller. +// +enum type StatefulSetUpdateStrategyType string const ( @@ -116,6 +118,40 @@ type RollingUpdateStatefulSetStrategy struct { Partition *int32 `json:"partition,omitempty" protobuf:"varint,1,opt,name=partition"` } +// PersistentVolumeClaimRetentionPolicyType is a string enumeration of the policies that will determine +// when volumes from the VolumeClaimTemplates will be deleted when the controlling StatefulSet is +// deleted or scaled down. +type PersistentVolumeClaimRetentionPolicyType string + +const ( + // RetainPersistentVolumeClaimRetentionPolicyType is the default + // PersistentVolumeClaimRetentionPolicy and specifies that + // PersistentVolumeClaims associated with StatefulSet VolumeClaimTemplates + // will not be deleted. + RetainPersistentVolumeClaimRetentionPolicyType PersistentVolumeClaimRetentionPolicyType = "Retain" + // RetentionPersistentVolumeClaimRetentionPolicyType specifies that + // PersistentVolumeClaims associated with StatefulSet VolumeClaimTemplates + // will be deleted in the scenario specified in + // StatefulSetPersistentVolumeClaimRetentionPolicy. + DeletePersistentVolumeClaimRetentionPolicyType PersistentVolumeClaimRetentionPolicyType = "Delete" +) + +// StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs +// created from the StatefulSet VolumeClaimTemplates. +type StatefulSetPersistentVolumeClaimRetentionPolicy struct { + // WhenDeleted specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is deleted. The default policy + // of `Retain` causes PVCs to not be affected by StatefulSet deletion. The + // `Delete` policy causes those PVCs to be deleted. + WhenDeleted PersistentVolumeClaimRetentionPolicyType `json:"whenDeleted,omitempty" protobuf:"bytes,1,opt,name=whenDeleted,casttype=PersistentVolumeClaimRetentionPolicyType"` + // WhenScaled specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is scaled down. The default + // policy of `Retain` causes PVCs to not be affected by a scaledown. The + // `Delete` policy causes the associated PVCs for any excess pods above + // the replica count to be deleted. + WhenScaled PersistentVolumeClaimRetentionPolicyType `json:"whenScaled,omitempty" protobuf:"bytes,2,opt,name=whenScaled,casttype=PersistentVolumeClaimRetentionPolicyType"` +} + // A StatefulSetSpec is the specification of a StatefulSet. type StatefulSetSpec struct { // replicas is the desired number of replicas of the given Template. @@ -182,6 +218,15 @@ type StatefulSetSpec struct { // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. // +optional MinReadySeconds int32 `json:"minReadySeconds,omitempty" protobuf:"varint,9,opt,name=minReadySeconds"` + + // persistentVolumeClaimRetentionPolicy describes the lifecycle of persistent + // volume claims created from volumeClaimTemplates. By default, all persistent + // volume claims are created as needed and retained until manually deleted. This + // policy allows the lifecycle to be altered, for example by deleting persistent + // volume claims when their stateful set is deleted, or when their pod is scaled + // down. This requires the StatefulSetAutoDeletePVC feature gate to be enabled, + // which is alpha. +optional + PersistentVolumeClaimRetentionPolicy *StatefulSetPersistentVolumeClaimRetentionPolicy `json:"persistentVolumeClaimRetentionPolicy,omitempty" protobuf:"bytes,10,opt,name=persistentVolumeClaimRetentionPolicy"` } // StatefulSetStatus represents the current state of a StatefulSet. @@ -194,7 +239,7 @@ type StatefulSetStatus struct { // replicas is the number of Pods created by the StatefulSet controller. Replicas int32 `json:"replicas" protobuf:"varint,2,opt,name=replicas"` - // readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. + // readyReplicas is the number of pods created for this StatefulSet with a Ready Condition. ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,3,opt,name=readyReplicas"` // currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version @@ -226,10 +271,8 @@ type StatefulSetStatus struct { Conditions []StatefulSetCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,10,rep,name=conditions"` // Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset. - // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. - // Remove omitempty when graduating to beta - // +optional - AvailableReplicas int32 `json:"availableReplicas,omitempty" protobuf:"varint,11,opt,name=availableReplicas"` + // This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate. + AvailableReplicas int32 `json:"availableReplicas" protobuf:"varint,11,opt,name=availableReplicas"` } type StatefulSetConditionType string @@ -354,6 +397,7 @@ type DeploymentStrategy struct { RollingUpdate *RollingUpdateDeployment `json:"rollingUpdate,omitempty" protobuf:"bytes,2,opt,name=rollingUpdate"` } +// +enum type DeploymentStrategyType string const ( @@ -408,7 +452,7 @@ type DeploymentStatus struct { // +optional UpdatedReplicas int32 `json:"updatedReplicas,omitempty" protobuf:"varint,3,opt,name=updatedReplicas"` - // Total number of ready pods targeted by this deployment. + // readyReplicas is the number of pods targeted by this Deployment with a Ready Condition. // +optional ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,7,opt,name=readyReplicas"` @@ -495,6 +539,7 @@ type DaemonSetUpdateStrategy struct { RollingUpdate *RollingUpdateDaemonSet `json:"rollingUpdate,omitempty" protobuf:"bytes,2,opt,name=rollingUpdate"` } +// +enum type DaemonSetUpdateStrategyType string const ( @@ -597,8 +642,8 @@ type DaemonSetStatus struct { // More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ DesiredNumberScheduled int32 `json:"desiredNumberScheduled" protobuf:"varint,3,opt,name=desiredNumberScheduled"` - // The number of nodes that should be running the daemon pod and have one - // or more of the daemon pod running and ready. + // numberReady is the number of nodes that should be running the daemon pod and have one + // or more of the daemon pod running with a Ready Condition. NumberReady int32 `json:"numberReady" protobuf:"varint,4,opt,name=numberReady"` // The most recent generation observed by the daemon set controller. @@ -785,7 +830,7 @@ type ReplicaSetStatus struct { // +optional FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty" protobuf:"varint,2,opt,name=fullyLabeledReplicas"` - // The number of ready replicas for this replica set. + // readyReplicas is the number of pods targeted by this ReplicaSet with a Ready Condition. // +optional ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,4,opt,name=readyReplicas"` diff --git a/vendor/k8s.io/api/apps/v1/types_swagger_doc_generated.go b/vendor/k8s.io/api/apps/v1/types_swagger_doc_generated.go index 39c733adb5..f640f9cdd6 100644 --- a/vendor/k8s.io/api/apps/v1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/apps/v1/types_swagger_doc_generated.go @@ -100,7 +100,7 @@ var map_DaemonSetStatus = map[string]string{ "currentNumberScheduled": "The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", "numberMisscheduled": "The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", "desiredNumberScheduled": "The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", - "numberReady": "The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready.", + "numberReady": "numberReady is the number of nodes that should be running the daemon pod and have one or more of the daemon pod running with a Ready Condition.", "observedGeneration": "The most recent generation observed by the daemon set controller.", "updatedNumberScheduled": "The total number of nodes that are running updated daemon pod", "numberAvailable": "The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds)", @@ -179,7 +179,7 @@ var map_DeploymentStatus = map[string]string{ "observedGeneration": "The generation observed by the deployment controller.", "replicas": "Total number of non-terminated pods targeted by this deployment (their labels match the selector).", "updatedReplicas": "Total number of non-terminated pods targeted by this deployment that have the desired template spec.", - "readyReplicas": "Total number of ready pods targeted by this deployment.", + "readyReplicas": "readyReplicas is the number of pods targeted by this Deployment with a Ready Condition.", "availableReplicas": "Total number of available pods (ready for at least minReadySeconds) targeted by this deployment.", "unavailableReplicas": "Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created.", "conditions": "Represents the latest available observations of a deployment's current state.", @@ -250,7 +250,7 @@ var map_ReplicaSetStatus = map[string]string{ "": "ReplicaSetStatus represents the current status of a ReplicaSet.", "replicas": "Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller", "fullyLabeledReplicas": "The number of pods that have labels matching the labels of the pod template of the replicaset.", - "readyReplicas": "The number of ready replicas for this replica set.", + "readyReplicas": "readyReplicas is the number of pods targeted by this ReplicaSet with a Ready Condition.", "availableReplicas": "The number of available replicas (ready for at least minReadySeconds) for this replica set.", "observedGeneration": "ObservedGeneration reflects the generation of the most recently observed ReplicaSet.", "conditions": "Represents the latest available observations of a replica set's current state.", @@ -323,17 +323,28 @@ func (StatefulSetList) SwaggerDoc() map[string]string { return map_StatefulSetList } +var map_StatefulSetPersistentVolumeClaimRetentionPolicy = map[string]string{ + "": "StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates.", + "whenDeleted": "WhenDeleted specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is deleted. The default policy of `Retain` causes PVCs to not be affected by StatefulSet deletion. The `Delete` policy causes those PVCs to be deleted.", + "whenScaled": "WhenScaled specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is scaled down. The default policy of `Retain` causes PVCs to not be affected by a scaledown. The `Delete` policy causes the associated PVCs for any excess pods above the replica count to be deleted.", +} + +func (StatefulSetPersistentVolumeClaimRetentionPolicy) SwaggerDoc() map[string]string { + return map_StatefulSetPersistentVolumeClaimRetentionPolicy +} + var map_StatefulSetSpec = map[string]string{ - "": "A StatefulSetSpec is the specification of a StatefulSet.", - "replicas": "replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.", - "selector": "selector is a label query over pods that should match the replica count. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors", - "template": "template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet.", - "volumeClaimTemplates": "volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.", - "serviceName": "serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller.", - "podManagementPolicy": "podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once.", - "updateStrategy": "updateStrategy indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template.", - "revisionHistoryLimit": "revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10.", - "minReadySeconds": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate.", + "": "A StatefulSetSpec is the specification of a StatefulSet.", + "replicas": "replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.", + "selector": "selector is a label query over pods that should match the replica count. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors", + "template": "template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet.", + "volumeClaimTemplates": "volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.", + "serviceName": "serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller.", + "podManagementPolicy": "podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once.", + "updateStrategy": "updateStrategy indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template.", + "revisionHistoryLimit": "revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10.", + "minReadySeconds": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate.", + "persistentVolumeClaimRetentionPolicy": "persistentVolumeClaimRetentionPolicy describes the lifecycle of persistent volume claims created from volumeClaimTemplates. By default, all persistent volume claims are created as needed and retained until manually deleted. This policy allows the lifecycle to be altered, for example by deleting persistent volume claims when their stateful set is deleted, or when their pod is scaled down. This requires the StatefulSetAutoDeletePVC feature gate to be enabled, which is alpha. +optional", } func (StatefulSetSpec) SwaggerDoc() map[string]string { @@ -344,14 +355,14 @@ var map_StatefulSetStatus = map[string]string{ "": "StatefulSetStatus represents the current state of a StatefulSet.", "observedGeneration": "observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server.", "replicas": "replicas is the number of Pods created by the StatefulSet controller.", - "readyReplicas": "readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition.", + "readyReplicas": "readyReplicas is the number of pods created for this StatefulSet with a Ready Condition.", "currentReplicas": "currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision.", "updatedReplicas": "updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision.", "currentRevision": "currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas).", "updateRevision": "updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas)", "collisionCount": "collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.", "conditions": "Represents the latest available observations of a statefulset's current state.", - "availableReplicas": "Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset. This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. Remove omitempty when graduating to beta", + "availableReplicas": "Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset. This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate.", } func (StatefulSetStatus) SwaggerDoc() map[string]string { diff --git a/vendor/k8s.io/api/apps/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/apps/v1/zz_generated.deepcopy.go index 0c80548521..8e4d4261a2 100644 --- a/vendor/k8s.io/api/apps/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/apps/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -687,6 +688,22 @@ func (in *StatefulSetList) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *StatefulSetPersistentVolumeClaimRetentionPolicy) DeepCopyInto(out *StatefulSetPersistentVolumeClaimRetentionPolicy) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetPersistentVolumeClaimRetentionPolicy. +func (in *StatefulSetPersistentVolumeClaimRetentionPolicy) DeepCopy() *StatefulSetPersistentVolumeClaimRetentionPolicy { + if in == nil { + return nil + } + out := new(StatefulSetPersistentVolumeClaimRetentionPolicy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *StatefulSetSpec) DeepCopyInto(out *StatefulSetSpec) { *out = *in @@ -714,6 +731,11 @@ func (in *StatefulSetSpec) DeepCopyInto(out *StatefulSetSpec) { *out = new(int32) **out = **in } + if in.PersistentVolumeClaimRetentionPolicy != nil { + in, out := &in.PersistentVolumeClaimRetentionPolicy, &out.PersistentVolumeClaimRetentionPolicy + *out = new(StatefulSetPersistentVolumeClaimRetentionPolicy) + **out = **in + } return } diff --git a/vendor/k8s.io/api/apps/v1beta1/generated.pb.go b/vendor/k8s.io/api/apps/v1beta1/generated.pb.go index 79e39e582f..74584223c9 100644 --- a/vendor/k8s.io/api/apps/v1beta1/generated.pb.go +++ b/vendor/k8s.io/api/apps/v1beta1/generated.pb.go @@ -553,10 +553,40 @@ func (m *StatefulSetList) XXX_DiscardUnknown() { var xxx_messageInfo_StatefulSetList proto.InternalMessageInfo +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Reset() { + *m = StatefulSetPersistentVolumeClaimRetentionPolicy{} +} +func (*StatefulSetPersistentVolumeClaimRetentionPolicy) ProtoMessage() {} +func (*StatefulSetPersistentVolumeClaimRetentionPolicy) Descriptor() ([]byte, []int) { + return fileDescriptor_2a07313e8f66e805, []int{18} +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.Merge(m, src) +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Size() int { + return m.Size() +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_DiscardUnknown() { + xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.DiscardUnknown(m) +} + +var xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy proto.InternalMessageInfo + func (m *StatefulSetSpec) Reset() { *m = StatefulSetSpec{} } func (*StatefulSetSpec) ProtoMessage() {} func (*StatefulSetSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_2a07313e8f66e805, []int{18} + return fileDescriptor_2a07313e8f66e805, []int{19} } func (m *StatefulSetSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -584,7 +614,7 @@ var xxx_messageInfo_StatefulSetSpec proto.InternalMessageInfo func (m *StatefulSetStatus) Reset() { *m = StatefulSetStatus{} } func (*StatefulSetStatus) ProtoMessage() {} func (*StatefulSetStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_2a07313e8f66e805, []int{19} + return fileDescriptor_2a07313e8f66e805, []int{20} } func (m *StatefulSetStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -612,7 +642,7 @@ var xxx_messageInfo_StatefulSetStatus proto.InternalMessageInfo func (m *StatefulSetUpdateStrategy) Reset() { *m = StatefulSetUpdateStrategy{} } func (*StatefulSetUpdateStrategy) ProtoMessage() {} func (*StatefulSetUpdateStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_2a07313e8f66e805, []int{20} + return fileDescriptor_2a07313e8f66e805, []int{21} } func (m *StatefulSetUpdateStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -658,6 +688,7 @@ func init() { proto.RegisterType((*StatefulSet)(nil), "k8s.io.api.apps.v1beta1.StatefulSet") proto.RegisterType((*StatefulSetCondition)(nil), "k8s.io.api.apps.v1beta1.StatefulSetCondition") proto.RegisterType((*StatefulSetList)(nil), "k8s.io.api.apps.v1beta1.StatefulSetList") + proto.RegisterType((*StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), "k8s.io.api.apps.v1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy") proto.RegisterType((*StatefulSetSpec)(nil), "k8s.io.api.apps.v1beta1.StatefulSetSpec") proto.RegisterType((*StatefulSetStatus)(nil), "k8s.io.api.apps.v1beta1.StatefulSetStatus") proto.RegisterType((*StatefulSetUpdateStrategy)(nil), "k8s.io.api.apps.v1beta1.StatefulSetUpdateStrategy") @@ -668,124 +699,130 @@ func init() { } var fileDescriptor_2a07313e8f66e805 = []byte{ - // 1869 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcd, 0x6f, 0x24, 0x47, - 0x15, 0x77, 0x8f, 0x3d, 0xf6, 0xcc, 0x73, 0x3c, 0xde, 0x2d, 0x9b, 0xf5, 0xc4, 0x81, 0xb1, 0x35, - 0x44, 0x89, 0xf3, 0xe1, 0x9e, 0xac, 0x13, 0xa2, 0x64, 0x17, 0x45, 0x78, 0xbc, 0x4b, 0xb2, 0x91, - 0x8d, 0x9d, 0xb2, 0x1d, 0x44, 0x00, 0x29, 0x35, 0x3d, 0xb5, 0xb3, 0x1d, 0xf7, 0x97, 0xba, 0xab, - 0x87, 0x1d, 0x71, 0xe1, 0x0f, 0x40, 0x4a, 0xce, 0xfc, 0x15, 0xdc, 0x40, 0x70, 0xe3, 0xb4, 0xc7, - 0x88, 0x0b, 0x39, 0x59, 0xec, 0xe4, 0x0a, 0x47, 0x2e, 0x2b, 0x21, 0xa1, 0xaa, 0xae, 0xfe, 0xee, - 0xb6, 0xdb, 0x48, 0x6b, 0x09, 0x6e, 0xd3, 0xf5, 0xde, 0xfb, 0xbd, 0x57, 0x55, 0xef, 0xbd, 0x7a, - 0xbf, 0x81, 0x1f, 0x9d, 0xbd, 0xe7, 0xa9, 0xba, 0xdd, 0x3b, 0xf3, 0x07, 0xd4, 0xb5, 0x28, 0xa3, - 0x5e, 0x6f, 0x4c, 0xad, 0xa1, 0xed, 0xf6, 0xa4, 0x80, 0x38, 0x7a, 0x8f, 0x38, 0x8e, 0xd7, 0x1b, - 0xdf, 0x1e, 0x50, 0x46, 0x6e, 0xf7, 0x46, 0xd4, 0xa2, 0x2e, 0x61, 0x74, 0xa8, 0x3a, 0xae, 0xcd, - 0x6c, 0xb4, 0x16, 0x28, 0xaa, 0xc4, 0xd1, 0x55, 0xae, 0xa8, 0x4a, 0xc5, 0xf5, 0xed, 0x91, 0xce, - 0x1e, 0xf9, 0x03, 0x55, 0xb3, 0xcd, 0xde, 0xc8, 0x1e, 0xd9, 0x3d, 0xa1, 0x3f, 0xf0, 0x1f, 0x8a, - 0x2f, 0xf1, 0x21, 0x7e, 0x05, 0x38, 0xeb, 0xdd, 0x84, 0x43, 0xcd, 0x76, 0x69, 0x6f, 0x9c, 0xf3, - 0xb5, 0xfe, 0x4e, 0xac, 0x63, 0x12, 0xed, 0x91, 0x6e, 0x51, 0x77, 0xd2, 0x73, 0xce, 0x46, 0x7c, - 0xc1, 0xeb, 0x99, 0x94, 0x91, 0x22, 0xab, 0x5e, 0x99, 0x95, 0xeb, 0x5b, 0x4c, 0x37, 0x69, 0xce, - 0xe0, 0xdd, 0xcb, 0x0c, 0x3c, 0xed, 0x11, 0x35, 0x49, 0xce, 0xee, 0xed, 0x32, 0x3b, 0x9f, 0xe9, - 0x46, 0x4f, 0xb7, 0x98, 0xc7, 0xdc, 0xac, 0x51, 0xf7, 0x5f, 0x0a, 0xa0, 0x3d, 0xdb, 0x62, 0xae, - 0x6d, 0x18, 0xd4, 0xc5, 0x74, 0xac, 0x7b, 0xba, 0x6d, 0xa1, 0xcf, 0xa1, 0xc1, 0xf7, 0x33, 0x24, - 0x8c, 0xb4, 0x95, 0x4d, 0x65, 0x6b, 0x71, 0xe7, 0x2d, 0x35, 0x3e, 0xe9, 0x08, 0x5e, 0x75, 0xce, - 0x46, 0x7c, 0xc1, 0x53, 0xb9, 0xb6, 0x3a, 0xbe, 0xad, 0x1e, 0x0e, 0xbe, 0xa0, 0x1a, 0x3b, 0xa0, - 0x8c, 0xf4, 0xd1, 0x93, 0xf3, 0x8d, 0x99, 0xe9, 0xf9, 0x06, 0xc4, 0x6b, 0x38, 0x42, 0x45, 0x87, - 0x30, 0x27, 0xd0, 0x6b, 0x02, 0x7d, 0xbb, 0x14, 0x5d, 0x6e, 0x5a, 0xc5, 0xe4, 0x57, 0xf7, 0x1f, - 0x33, 0x6a, 0xf1, 0xf0, 0xfa, 0x2f, 0x48, 0xe8, 0xb9, 0x7b, 0x84, 0x11, 0x2c, 0x80, 0xd0, 0x9b, - 0xd0, 0x70, 0x65, 0xf8, 0xed, 0xd9, 0x4d, 0x65, 0x6b, 0xb6, 0x7f, 0x43, 0x6a, 0x35, 0xc2, 0x6d, - 0xe1, 0x48, 0xa3, 0xfb, 0x44, 0x81, 0x5b, 0xf9, 0x7d, 0xef, 0xeb, 0x1e, 0x43, 0xbf, 0xc8, 0xed, - 0x5d, 0xad, 0xb6, 0x77, 0x6e, 0x2d, 0x76, 0x1e, 0x39, 0x0e, 0x57, 0x12, 0xfb, 0x3e, 0x82, 0xba, - 0xce, 0xa8, 0xe9, 0xb5, 0x6b, 0x9b, 0xb3, 0x5b, 0x8b, 0x3b, 0x6f, 0xa8, 0x25, 0x09, 0xac, 0xe6, - 0xa3, 0xeb, 0x2f, 0x49, 0xdc, 0xfa, 0x03, 0x8e, 0x80, 0x03, 0xa0, 0xee, 0x6f, 0x6b, 0x00, 0xf7, - 0xa8, 0x63, 0xd8, 0x13, 0x93, 0x5a, 0xec, 0x1a, 0xae, 0xee, 0x01, 0xcc, 0x79, 0x0e, 0xd5, 0xe4, - 0xd5, 0xbd, 0x5a, 0xba, 0x83, 0x38, 0xa8, 0x63, 0x87, 0x6a, 0xf1, 0xa5, 0xf1, 0x2f, 0x2c, 0x20, - 0xd0, 0x27, 0x30, 0xef, 0x31, 0xc2, 0x7c, 0x4f, 0x5c, 0xd9, 0xe2, 0xce, 0x6b, 0x55, 0xc0, 0x84, - 0x41, 0xbf, 0x25, 0xe1, 0xe6, 0x83, 0x6f, 0x2c, 0x81, 0xba, 0x7f, 0x9b, 0x85, 0x95, 0x58, 0x79, - 0xcf, 0xb6, 0x86, 0x3a, 0xe3, 0x29, 0x7d, 0x17, 0xe6, 0xd8, 0xc4, 0xa1, 0xe2, 0x4c, 0x9a, 0xfd, - 0x57, 0xc3, 0x60, 0x4e, 0x26, 0x0e, 0x7d, 0x76, 0xbe, 0xb1, 0x56, 0x60, 0xc2, 0x45, 0x58, 0x18, - 0xa1, 0xfd, 0x28, 0xce, 0x9a, 0x30, 0x7f, 0x27, 0xed, 0xfc, 0xd9, 0xf9, 0x46, 0x41, 0x03, 0x51, - 0x23, 0xa4, 0x74, 0x88, 0xe8, 0x0b, 0x68, 0x19, 0xc4, 0x63, 0xa7, 0xce, 0x90, 0x30, 0x7a, 0xa2, - 0x9b, 0xb4, 0x3d, 0x2f, 0x76, 0xff, 0x7a, 0xb5, 0x8b, 0xe2, 0x16, 0xfd, 0x5b, 0x32, 0x82, 0xd6, - 0x7e, 0x0a, 0x09, 0x67, 0x90, 0xd1, 0x18, 0x10, 0x5f, 0x39, 0x71, 0x89, 0xe5, 0x05, 0xbb, 0xe2, - 0xfe, 0x16, 0xae, 0xec, 0x6f, 0x5d, 0xfa, 0x43, 0xfb, 0x39, 0x34, 0x5c, 0xe0, 0x01, 0xbd, 0x02, - 0xf3, 0x2e, 0x25, 0x9e, 0x6d, 0xb5, 0xe7, 0xc4, 0x89, 0x45, 0xd7, 0x85, 0xc5, 0x2a, 0x96, 0x52, - 0xf4, 0x1a, 0x2c, 0x98, 0xd4, 0xf3, 0xc8, 0x88, 0xb6, 0xeb, 0x42, 0x71, 0x59, 0x2a, 0x2e, 0x1c, - 0x04, 0xcb, 0x38, 0x94, 0x77, 0xff, 0xa8, 0x40, 0x2b, 0xbe, 0xa6, 0x6b, 0xa8, 0xd5, 0x8f, 0xd2, - 0xb5, 0xfa, 0xfd, 0x0a, 0xc9, 0x59, 0x52, 0xa3, 0xff, 0xa8, 0x01, 0x8a, 0x95, 0xb0, 0x6d, 0x18, - 0x03, 0xa2, 0x9d, 0xa1, 0x4d, 0x98, 0xb3, 0x88, 0x19, 0xe6, 0x64, 0x54, 0x20, 0x3f, 0x21, 0x26, - 0xc5, 0x42, 0x82, 0xbe, 0x54, 0x00, 0xf9, 0xe2, 0x36, 0x87, 0xbb, 0x96, 0x65, 0x33, 0xc2, 0x0f, - 0x38, 0x0c, 0x68, 0xaf, 0x42, 0x40, 0xa1, 0x2f, 0xf5, 0x34, 0x87, 0x72, 0xdf, 0x62, 0xee, 0x24, - 0xbe, 0xd8, 0xbc, 0x02, 0x2e, 0x70, 0x8d, 0x7e, 0x0e, 0xe0, 0x4a, 0xcc, 0x13, 0x5b, 0x96, 0x6d, - 0x79, 0x0f, 0x08, 0xdd, 0xef, 0xd9, 0xd6, 0x43, 0x7d, 0x14, 0x37, 0x16, 0x1c, 0x41, 0xe0, 0x04, - 0xdc, 0xfa, 0x7d, 0x58, 0x2b, 0x89, 0x13, 0xdd, 0x80, 0xd9, 0x33, 0x3a, 0x09, 0x8e, 0x0a, 0xf3, - 0x9f, 0x68, 0x15, 0xea, 0x63, 0x62, 0xf8, 0x34, 0xa8, 0x49, 0x1c, 0x7c, 0xdc, 0xa9, 0xbd, 0xa7, - 0x74, 0x7f, 0x5f, 0x4f, 0x66, 0x0a, 0xef, 0x37, 0x68, 0x8b, 0x3f, 0x0f, 0x8e, 0xa1, 0x6b, 0xc4, - 0x13, 0x18, 0xf5, 0xfe, 0x0b, 0xc1, 0xd3, 0x10, 0xac, 0xe1, 0x48, 0x8a, 0x7e, 0x09, 0x0d, 0x8f, - 0x1a, 0x54, 0x63, 0xb6, 0x2b, 0x5b, 0xdc, 0xdb, 0x15, 0x73, 0x8a, 0x0c, 0xa8, 0x71, 0x2c, 0x4d, - 0x03, 0xf8, 0xf0, 0x0b, 0x47, 0x90, 0xe8, 0x13, 0x68, 0x30, 0x6a, 0x3a, 0x06, 0x61, 0x54, 0x9e, - 0x5e, 0x2a, 0xaf, 0x78, 0xef, 0xe0, 0x60, 0x47, 0xf6, 0xf0, 0x44, 0xaa, 0x89, 0xee, 0x19, 0xe5, - 0x69, 0xb8, 0x8a, 0x23, 0x18, 0xf4, 0x33, 0x68, 0x78, 0x8c, 0xbf, 0xea, 0xa3, 0x89, 0xa8, 0xb6, - 0x8b, 0x9e, 0x95, 0x64, 0x1f, 0x0d, 0x4c, 0x62, 0xe8, 0x70, 0x05, 0x47, 0x70, 0x68, 0x17, 0x96, - 0x4d, 0xdd, 0xc2, 0x94, 0x0c, 0x27, 0xc7, 0x54, 0xb3, 0xad, 0xa1, 0x27, 0xca, 0xb4, 0xde, 0x5f, - 0x93, 0x46, 0xcb, 0x07, 0x69, 0x31, 0xce, 0xea, 0xa3, 0x7d, 0x58, 0x0d, 0x9f, 0xdd, 0x8f, 0x74, - 0x8f, 0xd9, 0xee, 0x64, 0x5f, 0x37, 0x75, 0x26, 0x7a, 0x5e, 0xbd, 0xdf, 0x9e, 0x9e, 0x6f, 0xac, - 0xe2, 0x02, 0x39, 0x2e, 0xb4, 0xe2, 0x7d, 0xc5, 0x21, 0xbe, 0x47, 0x87, 0xa2, 0x87, 0x35, 0xe2, - 0xbe, 0x72, 0x24, 0x56, 0xb1, 0x94, 0xa2, 0x9f, 0xa6, 0xd2, 0xb4, 0x71, 0xb5, 0x34, 0x6d, 0x95, - 0xa7, 0x28, 0x3a, 0x85, 0x35, 0xc7, 0xb5, 0x47, 0x2e, 0xf5, 0xbc, 0x7b, 0x94, 0x0c, 0x0d, 0xdd, - 0xa2, 0xe1, 0xc9, 0x34, 0xc5, 0x8e, 0x5e, 0x9a, 0x9e, 0x6f, 0xac, 0x1d, 0x15, 0xab, 0xe0, 0x32, - 0xdb, 0xee, 0x5f, 0xe6, 0xe0, 0x46, 0xf6, 0x8d, 0x43, 0x1f, 0x03, 0xb2, 0x07, 0x1e, 0x75, 0xc7, - 0x74, 0xf8, 0x61, 0x30, 0xb8, 0xf1, 0xe9, 0x46, 0x11, 0xd3, 0x4d, 0x54, 0xb7, 0x87, 0x39, 0x0d, - 0x5c, 0x60, 0x15, 0xcc, 0x47, 0xb2, 0x00, 0x6a, 0x22, 0xd0, 0xc4, 0x7c, 0x94, 0x2b, 0x82, 0x5d, - 0x58, 0x96, 0xb5, 0x1f, 0x0a, 0x45, 0xb2, 0x26, 0xee, 0xfd, 0x34, 0x2d, 0xc6, 0x59, 0x7d, 0x74, - 0x17, 0x96, 0x5c, 0x9e, 0x07, 0x11, 0xc0, 0x82, 0x00, 0xf8, 0x8e, 0x04, 0x58, 0xc2, 0x49, 0x21, - 0x4e, 0xeb, 0xa2, 0x0f, 0xe1, 0x26, 0x19, 0x13, 0xdd, 0x20, 0x03, 0x83, 0x46, 0x00, 0x73, 0x02, - 0xe0, 0x45, 0x09, 0x70, 0x73, 0x37, 0xab, 0x80, 0xf3, 0x36, 0xe8, 0x00, 0x56, 0x7c, 0x2b, 0x0f, - 0x15, 0x24, 0xf1, 0x4b, 0x12, 0x6a, 0xe5, 0x34, 0xaf, 0x82, 0x8b, 0xec, 0xd0, 0xe7, 0x00, 0x5a, - 0xf8, 0xaa, 0x7b, 0xed, 0x79, 0xd1, 0x86, 0xdf, 0xac, 0x50, 0x6c, 0xd1, 0x28, 0x10, 0xb7, 0xc0, - 0x68, 0xc9, 0xc3, 0x09, 0x4c, 0x74, 0x07, 0x5a, 0x9a, 0x6d, 0x18, 0x22, 0xf3, 0xf7, 0x6c, 0xdf, - 0x62, 0x22, 0x79, 0xeb, 0x7d, 0xc4, 0x1f, 0xfb, 0xbd, 0x94, 0x04, 0x67, 0x34, 0xbb, 0x7f, 0x56, - 0x92, 0xcf, 0x4c, 0x58, 0xce, 0xe8, 0x4e, 0x6a, 0xf4, 0x79, 0x25, 0x33, 0xfa, 0xdc, 0xca, 0x5b, - 0x24, 0x26, 0x1f, 0x1d, 0x96, 0x78, 0xf2, 0xeb, 0xd6, 0x28, 0xb8, 0x70, 0xd9, 0x12, 0xdf, 0xba, - 0xb0, 0x94, 0x22, 0xed, 0xc4, 0xc3, 0x78, 0x53, 0xdc, 0x79, 0x52, 0x88, 0xd3, 0xc8, 0xdd, 0x0f, - 0xa0, 0x95, 0xae, 0xc3, 0xd4, 0x4c, 0xaf, 0x5c, 0x3a, 0xd3, 0x7f, 0xab, 0xc0, 0x5a, 0x89, 0x77, - 0x64, 0x40, 0xcb, 0x24, 0x8f, 0x13, 0xd7, 0x7c, 0xe9, 0x6c, 0xcc, 0x59, 0x93, 0x1a, 0xb0, 0x26, - 0xf5, 0x81, 0xc5, 0x0e, 0xdd, 0x63, 0xe6, 0xea, 0xd6, 0x28, 0xb8, 0x87, 0x83, 0x14, 0x16, 0xce, - 0x60, 0xa3, 0xcf, 0xa0, 0x61, 0x92, 0xc7, 0xc7, 0xbe, 0x3b, 0x2a, 0x3a, 0xaf, 0x6a, 0x7e, 0xc4, - 0xfb, 0x71, 0x20, 0x51, 0x70, 0x84, 0xd7, 0x3d, 0x84, 0xcd, 0xd4, 0x26, 0x79, 0xab, 0xa0, 0x0f, - 0x7d, 0xe3, 0x98, 0xc6, 0x17, 0xfe, 0x06, 0x34, 0x1d, 0xe2, 0x32, 0x3d, 0x6a, 0x17, 0xf5, 0xfe, - 0xd2, 0xf4, 0x7c, 0xa3, 0x79, 0x14, 0x2e, 0xe2, 0x58, 0xde, 0xfd, 0xb7, 0x02, 0xf5, 0x63, 0x8d, - 0x18, 0xf4, 0x1a, 0xa8, 0xc3, 0xbd, 0x14, 0x75, 0xe8, 0x96, 0x26, 0x91, 0x88, 0xa7, 0x94, 0x35, - 0xec, 0x67, 0x58, 0xc3, 0xcb, 0x97, 0xe0, 0x5c, 0x4c, 0x18, 0xde, 0x87, 0x66, 0xe4, 0x2e, 0xd5, - 0x25, 0x95, 0xcb, 0xba, 0x64, 0xf7, 0x77, 0x35, 0x58, 0x4c, 0xb8, 0xb8, 0x9a, 0x35, 0x3f, 0xee, - 0xc4, 0xa0, 0xc1, 0x3b, 0xc9, 0x4e, 0x95, 0x8d, 0xa8, 0xe1, 0x50, 0x11, 0xcc, 0x6f, 0xf1, 0xeb, - 0x9d, 0x9f, 0x35, 0x3e, 0x80, 0x16, 0x23, 0xee, 0x88, 0xb2, 0x50, 0x26, 0x0e, 0xac, 0x19, 0x93, - 0x87, 0x93, 0x94, 0x14, 0x67, 0xb4, 0xd7, 0xef, 0xc2, 0x52, 0xca, 0xd9, 0x95, 0x86, 0xb0, 0x2f, - 0xf9, 0xe1, 0xc4, 0xc9, 0x79, 0x0d, 0xd9, 0xf5, 0x71, 0x2a, 0xbb, 0xb6, 0xca, 0x0f, 0x33, 0x51, - 0x32, 0x65, 0x39, 0x86, 0x33, 0x39, 0xf6, 0x7a, 0x25, 0xb4, 0x8b, 0x33, 0xed, 0x9f, 0x35, 0x58, - 0x4d, 0x68, 0xc7, 0xdc, 0xf4, 0x87, 0xa9, 0x06, 0xbd, 0x95, 0x69, 0xd0, 0xed, 0x22, 0x9b, 0xe7, - 0x46, 0x4e, 0x8b, 0x09, 0xe3, 0xec, 0xff, 0x22, 0x61, 0xfc, 0x93, 0x02, 0xcb, 0x89, 0xb3, 0xbb, - 0x06, 0xc6, 0xf8, 0x20, 0xcd, 0x18, 0x5f, 0xae, 0x92, 0x34, 0x25, 0x94, 0xf1, 0xab, 0xf9, 0x54, - 0xf0, 0xff, 0xf7, 0x24, 0xe6, 0xd7, 0xb0, 0x3a, 0xb6, 0x0d, 0xdf, 0xa4, 0x7b, 0x06, 0xd1, 0xcd, - 0x50, 0x81, 0x0f, 0x7d, 0xb3, 0xd9, 0x3f, 0x86, 0x22, 0x78, 0xea, 0x7a, 0xba, 0xc7, 0xa8, 0xc5, - 0x3e, 0x8d, 0x2d, 0xfb, 0xdf, 0x95, 0x4e, 0x56, 0x3f, 0x2d, 0x80, 0xc3, 0x85, 0x4e, 0xd0, 0x0f, - 0x60, 0x91, 0x0f, 0xcc, 0xba, 0x46, 0x39, 0xf7, 0x96, 0x89, 0xb5, 0x22, 0x81, 0x16, 0x8f, 0x63, - 0x11, 0x4e, 0xea, 0xa1, 0x47, 0xb0, 0xe2, 0xd8, 0xc3, 0x03, 0x62, 0x91, 0x11, 0xe5, 0x63, 0xc6, - 0x91, 0x6d, 0xe8, 0xda, 0x44, 0x30, 0x9b, 0x66, 0xff, 0xdd, 0x70, 0xb8, 0x3c, 0xca, 0xab, 0x3c, - 0xe3, 0x14, 0x21, 0xbf, 0x2c, 0x8a, 0xba, 0x08, 0x12, 0xb9, 0xd0, 0xf2, 0xe5, 0x73, 0x2f, 0x89, - 0x5e, 0xf0, 0x17, 0xce, 0x4e, 0x95, 0x0c, 0x3b, 0x4d, 0x59, 0xc6, 0xdd, 0x3f, 0xbd, 0x8e, 0x33, - 0x1e, 0x4a, 0x89, 0x5b, 0xe3, 0xbf, 0x22, 0x6e, 0x05, 0x4c, 0xb2, 0x79, 0x35, 0x26, 0xd9, 0xfd, - 0x43, 0x1d, 0x6e, 0xe6, 0xba, 0x2d, 0xfa, 0xf1, 0x05, 0x24, 0xe9, 0xd6, 0x73, 0x23, 0x48, 0x39, - 0x76, 0x33, 0x7b, 0x05, 0x76, 0xb3, 0x0b, 0xcb, 0x9a, 0xef, 0xba, 0xd4, 0x62, 0x19, 0x6e, 0x13, - 0x9d, 0xc5, 0x5e, 0x5a, 0x8c, 0xb3, 0xfa, 0x45, 0x04, 0xad, 0x7e, 0x45, 0x82, 0x96, 0x8c, 0x42, - 0x0e, 0xd9, 0x41, 0xe6, 0xe6, 0xa3, 0x90, 0xb3, 0x76, 0x56, 0x9f, 0x0f, 0x18, 0x01, 0x6a, 0x84, - 0xb0, 0x90, 0x1e, 0x30, 0x4e, 0x53, 0x52, 0x9c, 0xd1, 0x2e, 0x20, 0x3b, 0xcd, 0xaa, 0x64, 0x07, - 0x91, 0x14, 0x15, 0x03, 0xd1, 0x26, 0xb6, 0xab, 0x94, 0x43, 0x75, 0x2e, 0x56, 0xc8, 0x42, 0x17, - 0xaf, 0xce, 0x42, 0xbb, 0x7f, 0x55, 0xe0, 0xc5, 0xd2, 0x82, 0x44, 0xbb, 0xa9, 0xe7, 0x7f, 0x3b, - 0xf3, 0xfc, 0x7f, 0xaf, 0xd4, 0x30, 0x31, 0x03, 0xb8, 0xc5, 0x34, 0xed, 0xfd, 0x6a, 0x34, 0xad, - 0x80, 0x43, 0x5c, 0xce, 0xd7, 0xfa, 0xdb, 0x4f, 0x9e, 0x76, 0x66, 0xbe, 0x7e, 0xda, 0x99, 0xf9, - 0xe6, 0x69, 0x67, 0xe6, 0x37, 0xd3, 0x8e, 0xf2, 0x64, 0xda, 0x51, 0xbe, 0x9e, 0x76, 0x94, 0x6f, - 0xa6, 0x1d, 0xe5, 0xef, 0xd3, 0x8e, 0xf2, 0xd5, 0xb7, 0x9d, 0x99, 0xcf, 0x16, 0xa4, 0xc7, 0xff, - 0x04, 0x00, 0x00, 0xff, 0xff, 0xbd, 0x02, 0xfa, 0x27, 0xed, 0x1b, 0x00, 0x00, + // 1968 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcd, 0x6f, 0x1b, 0xc7, + 0x15, 0xd7, 0x4a, 0xa2, 0x44, 0x3d, 0x45, 0x94, 0x3d, 0x52, 0x2d, 0x46, 0x69, 0x49, 0x81, 0x35, + 0x12, 0xe5, 0x43, 0xcb, 0x58, 0x49, 0x83, 0xc4, 0x2e, 0xdc, 0x8a, 0x92, 0x1b, 0x3b, 0x90, 0x22, + 0x65, 0x24, 0xc5, 0x68, 0xfa, 0x81, 0x0c, 0xc9, 0x31, 0xb5, 0xd1, 0x7e, 0x61, 0x77, 0xc8, 0x98, + 0xe8, 0xa5, 0x7f, 0x40, 0x81, 0xf4, 0xdc, 0xbf, 0xa2, 0xb7, 0x16, 0xed, 0xad, 0x87, 0xc2, 0xc7, + 0xa0, 0x97, 0xa6, 0x17, 0xa2, 0x66, 0xae, 0xed, 0xad, 0xbd, 0x18, 0x28, 0x50, 0xcc, 0xec, 0xec, + 0xf7, 0xae, 0xb4, 0x2c, 0x60, 0x01, 0xcd, 0x8d, 0x3b, 0xef, 0xbd, 0xdf, 0x9b, 0x99, 0xf7, 0x31, + 0xef, 0x47, 0xf8, 0xe1, 0xf9, 0xbb, 0xae, 0xaa, 0x59, 0xcd, 0xf3, 0x7e, 0x9b, 0x3a, 0x26, 0x65, + 0xd4, 0x6d, 0x0e, 0xa8, 0xd9, 0xb5, 0x9c, 0xa6, 0x14, 0x10, 0x5b, 0x6b, 0x12, 0xdb, 0x76, 0x9b, + 0x83, 0x5b, 0x6d, 0xca, 0xc8, 0xad, 0x66, 0x8f, 0x9a, 0xd4, 0x21, 0x8c, 0x76, 0x55, 0xdb, 0xb1, + 0x98, 0x85, 0xd6, 0x3c, 0x45, 0x95, 0xd8, 0x9a, 0xca, 0x15, 0x55, 0xa9, 0xb8, 0xbe, 0xd5, 0xd3, + 0xd8, 0x59, 0xbf, 0xad, 0x76, 0x2c, 0xa3, 0xd9, 0xb3, 0x7a, 0x56, 0x53, 0xe8, 0xb7, 0xfb, 0x8f, + 0xc4, 0x97, 0xf8, 0x10, 0xbf, 0x3c, 0x9c, 0xf5, 0x46, 0xc4, 0x61, 0xc7, 0x72, 0x68, 0x73, 0x90, + 0xf2, 0xb5, 0xfe, 0x76, 0xa8, 0x63, 0x90, 0xce, 0x99, 0x66, 0x52, 0x67, 0xd8, 0xb4, 0xcf, 0x7b, + 0x7c, 0xc1, 0x6d, 0x1a, 0x94, 0x91, 0x2c, 0xab, 0x66, 0x9e, 0x95, 0xd3, 0x37, 0x99, 0x66, 0xd0, + 0x94, 0xc1, 0x3b, 0x97, 0x19, 0xb8, 0x9d, 0x33, 0x6a, 0x90, 0x94, 0xdd, 0x5b, 0x79, 0x76, 0x7d, + 0xa6, 0xe9, 0x4d, 0xcd, 0x64, 0x2e, 0x73, 0x92, 0x46, 0x8d, 0x7f, 0x2b, 0x80, 0x76, 0x2d, 0x93, + 0x39, 0x96, 0xae, 0x53, 0x07, 0xd3, 0x81, 0xe6, 0x6a, 0x96, 0x89, 0x3e, 0x85, 0x32, 0x3f, 0x4f, + 0x97, 0x30, 0x52, 0x55, 0x36, 0x94, 0xcd, 0xc5, 0xed, 0x37, 0xd5, 0xf0, 0xa6, 0x03, 0x78, 0xd5, + 0x3e, 0xef, 0xf1, 0x05, 0x57, 0xe5, 0xda, 0xea, 0xe0, 0x96, 0x7a, 0xd8, 0xfe, 0x8c, 0x76, 0xd8, + 0x01, 0x65, 0xa4, 0x85, 0x9e, 0x8c, 0xea, 0x53, 0xe3, 0x51, 0x1d, 0xc2, 0x35, 0x1c, 0xa0, 0xa2, + 0x43, 0x98, 0x15, 0xe8, 0xd3, 0x02, 0x7d, 0x2b, 0x17, 0x5d, 0x1e, 0x5a, 0xc5, 0xe4, 0xf3, 0x7b, + 0x8f, 0x19, 0x35, 0xf9, 0xf6, 0x5a, 0x2f, 0x48, 0xe8, 0xd9, 0x3d, 0xc2, 0x08, 0x16, 0x40, 0xe8, + 0x0d, 0x28, 0x3b, 0x72, 0xfb, 0xd5, 0x99, 0x0d, 0x65, 0x73, 0xa6, 0x75, 0x4d, 0x6a, 0x95, 0xfd, + 0x63, 0xe1, 0x40, 0xa3, 0xf1, 0x44, 0x81, 0x1b, 0xe9, 0x73, 0xef, 0x6b, 0x2e, 0x43, 0x3f, 0x4d, + 0x9d, 0x5d, 0x2d, 0x76, 0x76, 0x6e, 0x2d, 0x4e, 0x1e, 0x38, 0xf6, 0x57, 0x22, 0xe7, 0x3e, 0x82, + 0x92, 0xc6, 0xa8, 0xe1, 0x56, 0xa7, 0x37, 0x66, 0x36, 0x17, 0xb7, 0x5f, 0x57, 0x73, 0x12, 0x58, + 0x4d, 0xef, 0xae, 0xb5, 0x24, 0x71, 0x4b, 0x0f, 0x38, 0x02, 0xf6, 0x80, 0x1a, 0xbf, 0x9a, 0x06, + 0xd8, 0xa3, 0xb6, 0x6e, 0x0d, 0x0d, 0x6a, 0xb2, 0x2b, 0x08, 0xdd, 0x03, 0x98, 0x75, 0x6d, 0xda, + 0x91, 0xa1, 0x7b, 0x25, 0xf7, 0x04, 0xe1, 0xa6, 0x8e, 0x6d, 0xda, 0x09, 0x83, 0xc6, 0xbf, 0xb0, + 0x80, 0x40, 0x1f, 0xc1, 0x9c, 0xcb, 0x08, 0xeb, 0xbb, 0x22, 0x64, 0x8b, 0xdb, 0xaf, 0x16, 0x01, + 0x13, 0x06, 0xad, 0x8a, 0x84, 0x9b, 0xf3, 0xbe, 0xb1, 0x04, 0x6a, 0xfc, 0x75, 0x06, 0x56, 0x42, + 0xe5, 0x5d, 0xcb, 0xec, 0x6a, 0x8c, 0xa7, 0xf4, 0x1d, 0x98, 0x65, 0x43, 0x9b, 0x8a, 0x3b, 0x59, + 0x68, 0xbd, 0xe2, 0x6f, 0xe6, 0x64, 0x68, 0xd3, 0x67, 0xa3, 0xfa, 0x5a, 0x86, 0x09, 0x17, 0x61, + 0x61, 0x84, 0xf6, 0x83, 0x7d, 0x4e, 0x0b, 0xf3, 0xb7, 0xe3, 0xce, 0x9f, 0x8d, 0xea, 0x19, 0x0d, + 0x44, 0x0d, 0x90, 0xe2, 0x5b, 0x44, 0x9f, 0x41, 0x45, 0x27, 0x2e, 0x3b, 0xb5, 0xbb, 0x84, 0xd1, + 0x13, 0xcd, 0xa0, 0xd5, 0x39, 0x71, 0xfa, 0xd7, 0x8a, 0x05, 0x8a, 0x5b, 0xb4, 0x6e, 0xc8, 0x1d, + 0x54, 0xf6, 0x63, 0x48, 0x38, 0x81, 0x8c, 0x06, 0x80, 0xf8, 0xca, 0x89, 0x43, 0x4c, 0xd7, 0x3b, + 0x15, 0xf7, 0x37, 0x3f, 0xb1, 0xbf, 0x75, 0xe9, 0x0f, 0xed, 0xa7, 0xd0, 0x70, 0x86, 0x07, 0xf4, + 0x32, 0xcc, 0x39, 0x94, 0xb8, 0x96, 0x59, 0x9d, 0x15, 0x37, 0x16, 0x84, 0x0b, 0x8b, 0x55, 0x2c, + 0xa5, 0xe8, 0x55, 0x98, 0x37, 0xa8, 0xeb, 0x92, 0x1e, 0xad, 0x96, 0x84, 0xe2, 0xb2, 0x54, 0x9c, + 0x3f, 0xf0, 0x96, 0xb1, 0x2f, 0x6f, 0xfc, 0x5e, 0x81, 0x4a, 0x18, 0xa6, 0x2b, 0xa8, 0xd5, 0xfb, + 0xf1, 0x5a, 0xfd, 0x6e, 0x81, 0xe4, 0xcc, 0xa9, 0xd1, 0x7f, 0x4c, 0x03, 0x0a, 0x95, 0xb0, 0xa5, + 0xeb, 0x6d, 0xd2, 0x39, 0x47, 0x1b, 0x30, 0x6b, 0x12, 0xc3, 0xcf, 0xc9, 0xa0, 0x40, 0x3e, 0x24, + 0x06, 0xc5, 0x42, 0x82, 0xbe, 0x50, 0x00, 0xf5, 0x45, 0x34, 0xbb, 0x3b, 0xa6, 0x69, 0x31, 0xc2, + 0x2f, 0xd8, 0xdf, 0xd0, 0x6e, 0x81, 0x0d, 0xf9, 0xbe, 0xd4, 0xd3, 0x14, 0xca, 0x3d, 0x93, 0x39, + 0xc3, 0x30, 0xb0, 0x69, 0x05, 0x9c, 0xe1, 0x1a, 0xfd, 0x04, 0xc0, 0x91, 0x98, 0x27, 0x96, 0x2c, + 0xdb, 0xfc, 0x1e, 0xe0, 0xbb, 0xdf, 0xb5, 0xcc, 0x47, 0x5a, 0x2f, 0x6c, 0x2c, 0x38, 0x80, 0xc0, + 0x11, 0xb8, 0xf5, 0x7b, 0xb0, 0x96, 0xb3, 0x4f, 0x74, 0x0d, 0x66, 0xce, 0xe9, 0xd0, 0xbb, 0x2a, + 0xcc, 0x7f, 0xa2, 0x55, 0x28, 0x0d, 0x88, 0xde, 0xa7, 0x5e, 0x4d, 0x62, 0xef, 0xe3, 0xf6, 0xf4, + 0xbb, 0x4a, 0xe3, 0xb7, 0xa5, 0x68, 0xa6, 0xf0, 0x7e, 0x83, 0x36, 0xf9, 0xf3, 0x60, 0xeb, 0x5a, + 0x87, 0xb8, 0x02, 0xa3, 0xd4, 0x7a, 0xc1, 0x7b, 0x1a, 0xbc, 0x35, 0x1c, 0x48, 0xd1, 0xcf, 0xa0, + 0xec, 0x52, 0x9d, 0x76, 0x98, 0xe5, 0xc8, 0x16, 0xf7, 0x56, 0xc1, 0x9c, 0x22, 0x6d, 0xaa, 0x1f, + 0x4b, 0x53, 0x0f, 0xde, 0xff, 0xc2, 0x01, 0x24, 0xfa, 0x08, 0xca, 0x8c, 0x1a, 0xb6, 0x4e, 0x18, + 0x95, 0xb7, 0x17, 0xcb, 0x2b, 0xde, 0x3b, 0x38, 0xd8, 0x91, 0xd5, 0x3d, 0x91, 0x6a, 0xa2, 0x7b, + 0x06, 0x79, 0xea, 0xaf, 0xe2, 0x00, 0x06, 0xfd, 0x18, 0xca, 0x2e, 0xe3, 0xaf, 0x7a, 0x6f, 0x28, + 0xaa, 0xed, 0xa2, 0x67, 0x25, 0xda, 0x47, 0x3d, 0x93, 0x10, 0xda, 0x5f, 0xc1, 0x01, 0x1c, 0xda, + 0x81, 0x65, 0x43, 0x33, 0x31, 0x25, 0xdd, 0xe1, 0x31, 0xed, 0x58, 0x66, 0xd7, 0x15, 0x65, 0x5a, + 0x6a, 0xad, 0x49, 0xa3, 0xe5, 0x83, 0xb8, 0x18, 0x27, 0xf5, 0xd1, 0x3e, 0xac, 0xfa, 0xcf, 0xee, + 0x7d, 0xcd, 0x65, 0x96, 0x33, 0xdc, 0xd7, 0x0c, 0x8d, 0x89, 0x9e, 0x57, 0x6a, 0x55, 0xc7, 0xa3, + 0xfa, 0x2a, 0xce, 0x90, 0xe3, 0x4c, 0x2b, 0xde, 0x57, 0x6c, 0xd2, 0x77, 0x69, 0x57, 0xf4, 0xb0, + 0x72, 0xd8, 0x57, 0x8e, 0xc4, 0x2a, 0x96, 0x52, 0xf4, 0x30, 0x96, 0xa6, 0xe5, 0xc9, 0xd2, 0xb4, + 0x92, 0x9f, 0xa2, 0xe8, 0x14, 0xd6, 0x6c, 0xc7, 0xea, 0x39, 0xd4, 0x75, 0xf7, 0x28, 0xe9, 0xea, + 0x9a, 0x49, 0xfd, 0x9b, 0x59, 0x10, 0x27, 0x7a, 0x69, 0x3c, 0xaa, 0xaf, 0x1d, 0x65, 0xab, 0xe0, + 0x3c, 0xdb, 0xc6, 0x9f, 0x66, 0xe1, 0x5a, 0xf2, 0x8d, 0x43, 0x1f, 0x00, 0xb2, 0xda, 0x2e, 0x75, + 0x06, 0xb4, 0xfb, 0xbe, 0x37, 0xb8, 0xf1, 0xe9, 0x46, 0x11, 0xd3, 0x4d, 0x50, 0xb7, 0x87, 0x29, + 0x0d, 0x9c, 0x61, 0xe5, 0xcd, 0x47, 0xb2, 0x00, 0xa6, 0xc5, 0x46, 0x23, 0xf3, 0x51, 0xaa, 0x08, + 0x76, 0x60, 0x59, 0xd6, 0xbe, 0x2f, 0x14, 0xc9, 0x1a, 0x89, 0xfb, 0x69, 0x5c, 0x8c, 0x93, 0xfa, + 0xe8, 0x0e, 0x2c, 0x39, 0x3c, 0x0f, 0x02, 0x80, 0x79, 0x01, 0xf0, 0x2d, 0x09, 0xb0, 0x84, 0xa3, + 0x42, 0x1c, 0xd7, 0x45, 0xef, 0xc3, 0x75, 0x32, 0x20, 0x9a, 0x4e, 0xda, 0x3a, 0x0d, 0x00, 0x66, + 0x05, 0xc0, 0x8b, 0x12, 0xe0, 0xfa, 0x4e, 0x52, 0x01, 0xa7, 0x6d, 0xd0, 0x01, 0xac, 0xf4, 0xcd, + 0x34, 0x94, 0x97, 0xc4, 0x2f, 0x49, 0xa8, 0x95, 0xd3, 0xb4, 0x0a, 0xce, 0xb2, 0x43, 0x9f, 0x02, + 0x74, 0xfc, 0x57, 0xdd, 0xad, 0xce, 0x89, 0x36, 0xfc, 0x46, 0x81, 0x62, 0x0b, 0x46, 0x81, 0xb0, + 0x05, 0x06, 0x4b, 0x2e, 0x8e, 0x60, 0xa2, 0xdb, 0x50, 0xe9, 0x58, 0xba, 0x2e, 0x32, 0x7f, 0xd7, + 0xea, 0x9b, 0x4c, 0x24, 0x6f, 0xa9, 0x85, 0xf8, 0x63, 0xbf, 0x1b, 0x93, 0xe0, 0x84, 0x66, 0xe3, + 0x8f, 0x4a, 0xf4, 0x99, 0xf1, 0xcb, 0x19, 0xdd, 0x8e, 0x8d, 0x3e, 0x2f, 0x27, 0x46, 0x9f, 0x1b, + 0x69, 0x8b, 0xc8, 0xe4, 0xa3, 0xc1, 0x12, 0x4f, 0x7e, 0xcd, 0xec, 0x79, 0x01, 0x97, 0x2d, 0xf1, + 0xcd, 0x0b, 0x4b, 0x29, 0xd0, 0x8e, 0x3c, 0x8c, 0xd7, 0x45, 0xcc, 0xa3, 0x42, 0x1c, 0x47, 0x6e, + 0xdc, 0x85, 0x4a, 0xbc, 0x0e, 0x63, 0x33, 0xbd, 0x72, 0xe9, 0x4c, 0xff, 0xb5, 0x02, 0x6b, 0x39, + 0xde, 0x91, 0x0e, 0x15, 0x83, 0x3c, 0x8e, 0x84, 0xf9, 0xd2, 0xd9, 0x98, 0xb3, 0x26, 0xd5, 0x63, + 0x4d, 0xea, 0x03, 0x93, 0x1d, 0x3a, 0xc7, 0xcc, 0xd1, 0xcc, 0x9e, 0x17, 0x87, 0x83, 0x18, 0x16, + 0x4e, 0x60, 0xa3, 0x4f, 0xa0, 0x6c, 0x90, 0xc7, 0xc7, 0x7d, 0xa7, 0x97, 0x75, 0x5f, 0xc5, 0xfc, + 0x88, 0xf7, 0xe3, 0x40, 0xa2, 0xe0, 0x00, 0xaf, 0x71, 0x08, 0x1b, 0xb1, 0x43, 0xf2, 0x56, 0x41, + 0x1f, 0xf5, 0xf5, 0x63, 0x1a, 0x06, 0xfc, 0x75, 0x58, 0xb0, 0x89, 0xc3, 0xb4, 0xa0, 0x5d, 0x94, + 0x5a, 0x4b, 0xe3, 0x51, 0x7d, 0xe1, 0xc8, 0x5f, 0xc4, 0xa1, 0xbc, 0xf1, 0x1f, 0x05, 0x4a, 0xc7, + 0x1d, 0xa2, 0xd3, 0x2b, 0xa0, 0x0e, 0x7b, 0x31, 0xea, 0xd0, 0xc8, 0x4d, 0x22, 0xb1, 0x9f, 0x5c, + 0xd6, 0xb0, 0x9f, 0x60, 0x0d, 0x37, 0x2f, 0xc1, 0xb9, 0x98, 0x30, 0xbc, 0x07, 0x0b, 0x81, 0xbb, + 0x58, 0x97, 0x54, 0x2e, 0xeb, 0x92, 0x8d, 0xdf, 0x4c, 0xc3, 0x62, 0xc4, 0xc5, 0x64, 0xd6, 0xfc, + 0xba, 0x23, 0x83, 0x06, 0xef, 0x24, 0xdb, 0x45, 0x0e, 0xa2, 0xfa, 0x43, 0x85, 0x37, 0xbf, 0x85, + 0xaf, 0x77, 0x7a, 0xd6, 0xb8, 0x0b, 0x15, 0x46, 0x9c, 0x1e, 0x65, 0xbe, 0x4c, 0x5c, 0xd8, 0x42, + 0x48, 0x1e, 0x4e, 0x62, 0x52, 0x9c, 0xd0, 0x5e, 0xbf, 0x03, 0x4b, 0x31, 0x67, 0x13, 0x0d, 0x61, + 0x5f, 0xf0, 0xcb, 0x09, 0x93, 0xf3, 0x0a, 0xb2, 0xeb, 0x83, 0x58, 0x76, 0x6d, 0xe6, 0x5f, 0x66, + 0xa4, 0x64, 0xf2, 0x72, 0x0c, 0x27, 0x72, 0xec, 0xb5, 0x42, 0x68, 0x17, 0x67, 0xda, 0x3f, 0xa7, + 0x61, 0x35, 0xa2, 0x1d, 0x72, 0xd3, 0xef, 0xc7, 0x1a, 0xf4, 0x66, 0xa2, 0x41, 0x57, 0xb3, 0x6c, + 0x9e, 0x1b, 0x39, 0xcd, 0x26, 0x8c, 0x33, 0xff, 0x8f, 0x84, 0xf1, 0x0f, 0x0a, 0x2c, 0x47, 0xee, + 0xee, 0x0a, 0x18, 0xe3, 0x83, 0x38, 0x63, 0xbc, 0x59, 0x24, 0x69, 0x72, 0x28, 0xe3, 0xbf, 0x14, + 0x68, 0x46, 0xb4, 0x8e, 0xa8, 0xe3, 0x6a, 0x2e, 0xa3, 0x26, 0xfb, 0xd8, 0xd2, 0xfb, 0x06, 0xdd, + 0xd5, 0x89, 0x66, 0x60, 0xca, 0x17, 0x34, 0xcb, 0x3c, 0xb2, 0x74, 0xad, 0x33, 0x44, 0x04, 0x16, + 0x3f, 0x3f, 0xa3, 0xe6, 0x1e, 0xd5, 0x29, 0xa3, 0x5d, 0x99, 0x4e, 0x3f, 0x90, 0xf0, 0x8b, 0x0f, + 0x43, 0xd1, 0xb3, 0x51, 0x7d, 0xb3, 0x08, 0xa2, 0xc8, 0xb2, 0x28, 0x26, 0xfa, 0x39, 0x00, 0xff, + 0x14, 0xfd, 0xa8, 0x2b, 0x13, 0xee, 0xae, 0x5f, 0x95, 0x0f, 0x03, 0xc9, 0x44, 0x0e, 0x22, 0x88, + 0x8d, 0xbf, 0xcd, 0xc7, 0x62, 0xf6, 0x8d, 0xe7, 0x6e, 0xbf, 0x80, 0xd5, 0x41, 0x78, 0x3b, 0xbe, + 0x02, 0x9f, 0x75, 0x67, 0x92, 0xff, 0x87, 0x05, 0xf0, 0x59, 0xf7, 0xda, 0xfa, 0xb6, 0x74, 0xb2, + 0xfa, 0x71, 0x06, 0x1c, 0xce, 0x74, 0x82, 0xbe, 0x07, 0x8b, 0x9c, 0x27, 0x68, 0x1d, 0xfa, 0x21, + 0x31, 0xfc, 0x7a, 0x5a, 0xf1, 0xf3, 0xe5, 0x38, 0x14, 0xe1, 0xa8, 0x1e, 0x3a, 0x83, 0x15, 0xdb, + 0xea, 0x1e, 0x10, 0x93, 0xf4, 0x28, 0x9f, 0xae, 0xbc, 0x50, 0x0a, 0x42, 0xb7, 0xd0, 0x7a, 0xc7, + 0x9f, 0xa9, 0x8f, 0xd2, 0x2a, 0xcf, 0x38, 0x33, 0x4a, 0x2f, 0x8b, 0x24, 0xc8, 0x82, 0x44, 0x0e, + 0x54, 0xfa, 0x72, 0xca, 0x91, 0xfc, 0xd6, 0xfb, 0xe7, 0x6a, 0xbb, 0x48, 0x61, 0x9d, 0xc6, 0x2c, + 0xc3, 0x47, 0x2f, 0xbe, 0x8e, 0x13, 0x1e, 0x72, 0xf9, 0x6a, 0xf9, 0x7f, 0xe2, 0xab, 0x19, 0x04, + 0x7a, 0x61, 0x42, 0x02, 0xfd, 0x67, 0x05, 0x6e, 0xda, 0x05, 0x6a, 0xa9, 0x0a, 0xe2, 0x6e, 0xee, + 0x17, 0xb9, 0x9b, 0x22, 0xb5, 0xd9, 0xda, 0x1c, 0x8f, 0xea, 0x37, 0x8b, 0x68, 0xe2, 0x42, 0xfb, + 0x6b, 0xfc, 0xae, 0x04, 0xd7, 0x53, 0xaf, 0x25, 0xfa, 0xd1, 0x05, 0x24, 0xf7, 0xc6, 0x73, 0x23, + 0xb8, 0x29, 0x76, 0x3a, 0x33, 0x01, 0x3b, 0xdd, 0x81, 0xe5, 0x4e, 0xdf, 0x71, 0xa8, 0xc9, 0x12, + 0xdc, 0x34, 0x08, 0xea, 0x6e, 0x5c, 0x8c, 0x93, 0xfa, 0x59, 0x04, 0xbb, 0x34, 0x21, 0xc1, 0x8e, + 0xee, 0x42, 0x92, 0x24, 0xaf, 0x04, 0xd3, 0xbb, 0x90, 0x5c, 0x29, 0xa9, 0xcf, 0x07, 0x44, 0x0f, + 0x35, 0x40, 0x98, 0x8f, 0x0f, 0x88, 0xa7, 0x31, 0x29, 0x4e, 0x68, 0x67, 0x90, 0xd5, 0x85, 0xa2, + 0x64, 0x15, 0x91, 0x18, 0x95, 0x06, 0xd1, 0xef, 0xb6, 0x8a, 0xe4, 0x6e, 0x71, 0x2e, 0x9d, 0xf9, + 0x2f, 0xc2, 0xe2, 0xe4, 0xff, 0x22, 0x34, 0xfe, 0xa2, 0xc0, 0x8b, 0xb9, 0x9d, 0x05, 0xed, 0xc4, + 0xc6, 0xb7, 0xad, 0xc4, 0xf8, 0xf6, 0x9d, 0x5c, 0xc3, 0xc8, 0x0c, 0xe7, 0x64, 0xd3, 0xec, 0xf7, + 0x8a, 0xd1, 0xec, 0x0c, 0x0e, 0x78, 0x39, 0xdf, 0x6e, 0x6d, 0x3d, 0x79, 0x5a, 0x9b, 0xfa, 0xf2, + 0x69, 0x6d, 0xea, 0xab, 0xa7, 0xb5, 0xa9, 0x5f, 0x8e, 0x6b, 0xca, 0x93, 0x71, 0x4d, 0xf9, 0x72, + 0x5c, 0x53, 0xbe, 0x1a, 0xd7, 0x94, 0xbf, 0x8f, 0x6b, 0xca, 0xaf, 0xbf, 0xae, 0x4d, 0x7d, 0x32, + 0x2f, 0x3d, 0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0x3d, 0xfc, 0xe0, 0xc3, 0xad, 0x1d, 0x00, 0x00, } func (m *ControllerRevision) Marshal() (dAtA []byte, err error) { @@ -1687,6 +1724,39 @@ func (m *StatefulSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.WhenScaled) + copy(dAtA[i:], m.WhenScaled) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenScaled))) + i-- + dAtA[i] = 0x12 + i -= len(m.WhenDeleted) + copy(dAtA[i:], m.WhenDeleted) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenDeleted))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *StatefulSetSpec) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1707,6 +1777,18 @@ func (m *StatefulSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.PersistentVolumeClaimRetentionPolicy != nil { + { + size, err := m.PersistentVolumeClaimRetentionPolicy.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) i-- dAtA[i] = 0x48 @@ -2213,6 +2295,19 @@ func (m *StatefulSetList) Size() (n int) { return n } +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.WhenDeleted) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.WhenScaled) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *StatefulSetSpec) Size() (n int) { if m == nil { return 0 @@ -2244,6 +2339,10 @@ func (m *StatefulSetSpec) Size() (n int) { n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) } n += 1 + sovGenerated(uint64(m.MinReadySeconds)) + if m.PersistentVolumeClaimRetentionPolicy != nil { + l = m.PersistentVolumeClaimRetentionPolicy.Size() + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -2559,6 +2658,17 @@ func (this *StatefulSetList) String() string { }, "") return s } +func (this *StatefulSetPersistentVolumeClaimRetentionPolicy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StatefulSetPersistentVolumeClaimRetentionPolicy{`, + `WhenDeleted:` + fmt.Sprintf("%v", this.WhenDeleted) + `,`, + `WhenScaled:` + fmt.Sprintf("%v", this.WhenScaled) + `,`, + `}`, + }, "") + return s +} func (this *StatefulSetSpec) String() string { if this == nil { return "nil" @@ -2578,6 +2688,7 @@ func (this *StatefulSetSpec) String() string { `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "StatefulSetUpdateStrategy", "StatefulSetUpdateStrategy", 1), `&`, ``, 1) + `,`, `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, + `PersistentVolumeClaimRetentionPolicy:` + strings.Replace(this.PersistentVolumeClaimRetentionPolicy.String(), "StatefulSetPersistentVolumeClaimRetentionPolicy", "StatefulSetPersistentVolumeClaimRetentionPolicy", 1) + `,`, `}`, }, "") return s @@ -5436,6 +5547,120 @@ func (m *StatefulSetList) Unmarshal(dAtA []byte) error { } return nil } +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WhenDeleted", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WhenDeleted = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WhenScaled", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WhenScaled = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5724,6 +5949,42 @@ func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error { break } } + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeClaimRetentionPolicy", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PersistentVolumeClaimRetentionPolicy == nil { + m.PersistentVolumeClaimRetentionPolicy = &StatefulSetPersistentVolumeClaimRetentionPolicy{} + } + if err := m.PersistentVolumeClaimRetentionPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/vendor/k8s.io/api/apps/v1beta1/generated.proto b/vendor/k8s.io/api/apps/v1beta1/generated.proto index 128efa9ca9..9f9df98fce 100644 --- a/vendor/k8s.io/api/apps/v1beta1/generated.proto +++ b/vendor/k8s.io/api/apps/v1beta1/generated.proto @@ -190,7 +190,7 @@ message DeploymentStatus { // +optional optional int32 updatedReplicas = 3; - // Total number of ready pods targeted by this deployment. + // readyReplicas is the number of pods targeted by this Deployment controller with a Ready Condition. // +optional optional int32 readyReplicas = 7; @@ -367,6 +367,23 @@ message StatefulSetList { repeated StatefulSet items = 2; } +// StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs +// created from the StatefulSet VolumeClaimTemplates. +message StatefulSetPersistentVolumeClaimRetentionPolicy { + // WhenDeleted specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is deleted. The default policy + // of `Retain` causes PVCs to not be affected by StatefulSet deletion. The + // `Delete` policy causes those PVCs to be deleted. + optional string whenDeleted = 1; + + // WhenScaled specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is scaled down. The default + // policy of `Retain` causes PVCs to not be affected by a scaledown. The + // `Delete` policy causes the associated PVCs for any excess pods above + // the replica count to be deleted. + optional string whenScaled = 2; +} + // A StatefulSetSpec is the specification of a StatefulSet. message StatefulSetSpec { // replicas is the desired number of replicas of the given Template. @@ -434,6 +451,12 @@ message StatefulSetSpec { // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. // +optional optional int32 minReadySeconds = 9; + + // PersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from + // the StatefulSet VolumeClaimTemplates. This requires the + // StatefulSetAutoDeletePVC feature gate to be enabled, which is alpha. + // +optional + optional StatefulSetPersistentVolumeClaimRetentionPolicy persistentVolumeClaimRetentionPolicy = 10; } // StatefulSetStatus represents the current state of a StatefulSet. @@ -446,7 +469,7 @@ message StatefulSetStatus { // replicas is the number of Pods created by the StatefulSet controller. optional int32 replicas = 2; - // readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. + // readyReplicas is the number of pods created by this StatefulSet controller with a Ready Condition. optional int32 readyReplicas = 3; // currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version @@ -478,9 +501,7 @@ message StatefulSetStatus { repeated StatefulSetCondition conditions = 10; // Total number of available pods (ready for at least minReadySeconds) targeted by this StatefulSet. - // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. - // Remove omitempty when graduating to beta - // +optional + // This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate. optional int32 availableReplicas = 11; } diff --git a/vendor/k8s.io/api/apps/v1beta1/types.go b/vendor/k8s.io/api/apps/v1beta1/types.go index be638bb0f9..832ef34f45 100644 --- a/vendor/k8s.io/api/apps/v1beta1/types.go +++ b/vendor/k8s.io/api/apps/v1beta1/types.go @@ -158,6 +158,40 @@ type RollingUpdateStatefulSetStrategy struct { Partition *int32 `json:"partition,omitempty" protobuf:"varint,1,opt,name=partition"` } +// PersistentVolumeClaimRetentionPolicyType is a string enumeration of the policies that will determine +// when volumes from the VolumeClaimTemplates will be deleted when the controlling StatefulSet is +// deleted or scaled down. +type PersistentVolumeClaimRetentionPolicyType string + +const ( + // RetainPersistentVolumeClaimRetentionPolicyType is the default + // PersistentVolumeClaimRetentionPolicy and specifies that + // PersistentVolumeClaims associated with StatefulSet VolumeClaimTemplates + // will not be deleted. + RetainPersistentVolumeClaimRetentionPolicyType PersistentVolumeClaimRetentionPolicyType = "Retain" + // RetentionPersistentVolumeClaimRetentionPolicyType specifies that + // PersistentVolumeClaims associated with StatefulSet VolumeClaimTemplates + // will be deleted in the scenario specified in + // StatefulSetPersistentVolumeClaimRetentionPolicy. + RetentionPersistentVolumeClaimRetentionPolicyType PersistentVolumeClaimRetentionPolicyType = "Delete" +) + +// StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs +// created from the StatefulSet VolumeClaimTemplates. +type StatefulSetPersistentVolumeClaimRetentionPolicy struct { + // WhenDeleted specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is deleted. The default policy + // of `Retain` causes PVCs to not be affected by StatefulSet deletion. The + // `Delete` policy causes those PVCs to be deleted. + WhenDeleted PersistentVolumeClaimRetentionPolicyType `json:"whenDeleted,omitempty" protobuf:"bytes,1,opt,name=whenDeleted,casttype=PersistentVolumeClaimRetentionPolicyType"` + // WhenScaled specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is scaled down. The default + // policy of `Retain` causes PVCs to not be affected by a scaledown. The + // `Delete` policy causes the associated PVCs for any excess pods above + // the replica count to be deleted. + WhenScaled PersistentVolumeClaimRetentionPolicyType `json:"whenScaled,omitempty" protobuf:"bytes,2,opt,name=whenScaled,casttype=PersistentVolumeClaimRetentionPolicyType"` +} + // A StatefulSetSpec is the specification of a StatefulSet. type StatefulSetSpec struct { // replicas is the desired number of replicas of the given Template. @@ -225,6 +259,12 @@ type StatefulSetSpec struct { // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. // +optional MinReadySeconds int32 `json:"minReadySeconds,omitempty" protobuf:"varint,9,opt,name=minReadySeconds"` + + // PersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from + // the StatefulSet VolumeClaimTemplates. This requires the + // StatefulSetAutoDeletePVC feature gate to be enabled, which is alpha. + // +optional + PersistentVolumeClaimRetentionPolicy *StatefulSetPersistentVolumeClaimRetentionPolicy `json:"persistentVolumeClaimRetentionPolicy,omitempty" protobuf:"bytes,10,opt,name=persistentVolumeClaimRetentionPolicy"` } // StatefulSetStatus represents the current state of a StatefulSet. @@ -237,7 +277,7 @@ type StatefulSetStatus struct { // replicas is the number of Pods created by the StatefulSet controller. Replicas int32 `json:"replicas" protobuf:"varint,2,opt,name=replicas"` - // readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. + // readyReplicas is the number of pods created by this StatefulSet controller with a Ready Condition. ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,3,opt,name=readyReplicas"` // currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version @@ -269,10 +309,8 @@ type StatefulSetStatus struct { Conditions []StatefulSetCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,10,rep,name=conditions"` // Total number of available pods (ready for at least minReadySeconds) targeted by this StatefulSet. - // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. - // Remove omitempty when graduating to beta - // +optional - AvailableReplicas int32 `json:"availableReplicas,omitempty" protobuf:"varint,11,opt,name=availableReplicas"` + // This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate. + AvailableReplicas int32 `json:"availableReplicas" protobuf:"varint,11,opt,name=availableReplicas"` } type StatefulSetConditionType string @@ -485,7 +523,7 @@ type DeploymentStatus struct { // +optional UpdatedReplicas int32 `json:"updatedReplicas,omitempty" protobuf:"varint,3,opt,name=updatedReplicas"` - // Total number of ready pods targeted by this deployment. + // readyReplicas is the number of pods targeted by this Deployment controller with a Ready Condition. // +optional ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,7,opt,name=readyReplicas"` diff --git a/vendor/k8s.io/api/apps/v1beta1/types_swagger_doc_generated.go b/vendor/k8s.io/api/apps/v1beta1/types_swagger_doc_generated.go index 51e08b575e..e92881a35d 100644 --- a/vendor/k8s.io/api/apps/v1beta1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/apps/v1beta1/types_swagger_doc_generated.go @@ -116,7 +116,7 @@ var map_DeploymentStatus = map[string]string{ "observedGeneration": "The generation observed by the deployment controller.", "replicas": "Total number of non-terminated pods targeted by this deployment (their labels match the selector).", "updatedReplicas": "Total number of non-terminated pods targeted by this deployment that have the desired template spec.", - "readyReplicas": "Total number of ready pods targeted by this deployment.", + "readyReplicas": "readyReplicas is the number of pods targeted by this Deployment controller with a Ready Condition.", "availableReplicas": "Total number of available pods (ready for at least minReadySeconds) targeted by this deployment.", "unavailableReplicas": "Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created.", "conditions": "Represents the latest available observations of a deployment's current state.", @@ -227,17 +227,28 @@ func (StatefulSetList) SwaggerDoc() map[string]string { return map_StatefulSetList } +var map_StatefulSetPersistentVolumeClaimRetentionPolicy = map[string]string{ + "": "StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates.", + "whenDeleted": "WhenDeleted specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is deleted. The default policy of `Retain` causes PVCs to not be affected by StatefulSet deletion. The `Delete` policy causes those PVCs to be deleted.", + "whenScaled": "WhenScaled specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is scaled down. The default policy of `Retain` causes PVCs to not be affected by a scaledown. The `Delete` policy causes the associated PVCs for any excess pods above the replica count to be deleted.", +} + +func (StatefulSetPersistentVolumeClaimRetentionPolicy) SwaggerDoc() map[string]string { + return map_StatefulSetPersistentVolumeClaimRetentionPolicy +} + var map_StatefulSetSpec = map[string]string{ - "": "A StatefulSetSpec is the specification of a StatefulSet.", - "replicas": "replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.", - "selector": "selector is a label query over pods that should match the replica count. If empty, defaulted to labels on the pod template. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors", - "template": "template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet.", - "volumeClaimTemplates": "volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.", - "serviceName": "serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller.", - "podManagementPolicy": "podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once.", - "updateStrategy": "updateStrategy indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template.", - "revisionHistoryLimit": "revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10.", - "minReadySeconds": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate.", + "": "A StatefulSetSpec is the specification of a StatefulSet.", + "replicas": "replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.", + "selector": "selector is a label query over pods that should match the replica count. If empty, defaulted to labels on the pod template. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors", + "template": "template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet.", + "volumeClaimTemplates": "volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.", + "serviceName": "serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller.", + "podManagementPolicy": "podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once.", + "updateStrategy": "updateStrategy indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template.", + "revisionHistoryLimit": "revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10.", + "minReadySeconds": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate.", + "persistentVolumeClaimRetentionPolicy": "PersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates. This requires the StatefulSetAutoDeletePVC feature gate to be enabled, which is alpha.", } func (StatefulSetSpec) SwaggerDoc() map[string]string { @@ -248,14 +259,14 @@ var map_StatefulSetStatus = map[string]string{ "": "StatefulSetStatus represents the current state of a StatefulSet.", "observedGeneration": "observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server.", "replicas": "replicas is the number of Pods created by the StatefulSet controller.", - "readyReplicas": "readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition.", + "readyReplicas": "readyReplicas is the number of pods created by this StatefulSet controller with a Ready Condition.", "currentReplicas": "currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision.", "updatedReplicas": "updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision.", "currentRevision": "currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas).", "updateRevision": "updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas)", "collisionCount": "collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.", "conditions": "Represents the latest available observations of a statefulset's current state.", - "availableReplicas": "Total number of available pods (ready for at least minReadySeconds) targeted by this StatefulSet. This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. Remove omitempty when graduating to beta", + "availableReplicas": "Total number of available pods (ready for at least minReadySeconds) targeted by this StatefulSet. This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate.", } func (StatefulSetStatus) SwaggerDoc() map[string]string { diff --git a/vendor/k8s.io/api/apps/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/apps/v1beta1/zz_generated.deepcopy.go index fb27612419..be3fcc75b6 100644 --- a/vendor/k8s.io/api/apps/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/apps/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -499,6 +500,22 @@ func (in *StatefulSetList) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *StatefulSetPersistentVolumeClaimRetentionPolicy) DeepCopyInto(out *StatefulSetPersistentVolumeClaimRetentionPolicy) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetPersistentVolumeClaimRetentionPolicy. +func (in *StatefulSetPersistentVolumeClaimRetentionPolicy) DeepCopy() *StatefulSetPersistentVolumeClaimRetentionPolicy { + if in == nil { + return nil + } + out := new(StatefulSetPersistentVolumeClaimRetentionPolicy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *StatefulSetSpec) DeepCopyInto(out *StatefulSetSpec) { *out = *in @@ -526,6 +543,11 @@ func (in *StatefulSetSpec) DeepCopyInto(out *StatefulSetSpec) { *out = new(int32) **out = **in } + if in.PersistentVolumeClaimRetentionPolicy != nil { + in, out := &in.PersistentVolumeClaimRetentionPolicy, &out.PersistentVolumeClaimRetentionPolicy + *out = new(StatefulSetPersistentVolumeClaimRetentionPolicy) + **out = **in + } return } diff --git a/vendor/k8s.io/api/apps/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/apps/v1beta1/zz_generated.prerelease-lifecycle.go index f3850fc90c..1e2233e317 100644 --- a/vendor/k8s.io/api/apps/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/apps/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/apps/v1beta2/generated.pb.go b/vendor/k8s.io/api/apps/v1beta2/generated.pb.go index e03a95acd4..cd1a06e25f 100644 --- a/vendor/k8s.io/api/apps/v1beta2/generated.pb.go +++ b/vendor/k8s.io/api/apps/v1beta2/generated.pb.go @@ -833,10 +833,40 @@ func (m *StatefulSetList) XXX_DiscardUnknown() { var xxx_messageInfo_StatefulSetList proto.InternalMessageInfo +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Reset() { + *m = StatefulSetPersistentVolumeClaimRetentionPolicy{} +} +func (*StatefulSetPersistentVolumeClaimRetentionPolicy) ProtoMessage() {} +func (*StatefulSetPersistentVolumeClaimRetentionPolicy) Descriptor() ([]byte, []int) { + return fileDescriptor_42fe616264472f7e, []int{28} +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.Merge(m, src) +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Size() int { + return m.Size() +} +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_DiscardUnknown() { + xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.DiscardUnknown(m) +} + +var xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy proto.InternalMessageInfo + func (m *StatefulSetSpec) Reset() { *m = StatefulSetSpec{} } func (*StatefulSetSpec) ProtoMessage() {} func (*StatefulSetSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_42fe616264472f7e, []int{28} + return fileDescriptor_42fe616264472f7e, []int{29} } func (m *StatefulSetSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -864,7 +894,7 @@ var xxx_messageInfo_StatefulSetSpec proto.InternalMessageInfo func (m *StatefulSetStatus) Reset() { *m = StatefulSetStatus{} } func (*StatefulSetStatus) ProtoMessage() {} func (*StatefulSetStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_42fe616264472f7e, []int{29} + return fileDescriptor_42fe616264472f7e, []int{30} } func (m *StatefulSetStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -892,7 +922,7 @@ var xxx_messageInfo_StatefulSetStatus proto.InternalMessageInfo func (m *StatefulSetUpdateStrategy) Reset() { *m = StatefulSetUpdateStrategy{} } func (*StatefulSetUpdateStrategy) ProtoMessage() {} func (*StatefulSetUpdateStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_42fe616264472f7e, []int{30} + return fileDescriptor_42fe616264472f7e, []int{31} } func (m *StatefulSetUpdateStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -947,6 +977,7 @@ func init() { proto.RegisterType((*StatefulSet)(nil), "k8s.io.api.apps.v1beta2.StatefulSet") proto.RegisterType((*StatefulSetCondition)(nil), "k8s.io.api.apps.v1beta2.StatefulSetCondition") proto.RegisterType((*StatefulSetList)(nil), "k8s.io.api.apps.v1beta2.StatefulSetList") + proto.RegisterType((*StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), "k8s.io.api.apps.v1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy") proto.RegisterType((*StatefulSetSpec)(nil), "k8s.io.api.apps.v1beta2.StatefulSetSpec") proto.RegisterType((*StatefulSetStatus)(nil), "k8s.io.api.apps.v1beta2.StatefulSetStatus") proto.RegisterType((*StatefulSetUpdateStrategy)(nil), "k8s.io.api.apps.v1beta2.StatefulSetUpdateStrategy") @@ -957,144 +988,150 @@ func init() { } var fileDescriptor_42fe616264472f7e = []byte{ - // 2182 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcd, 0x6f, 0x1c, 0xb7, - 0xf9, 0xf6, 0xec, 0x87, 0xb4, 0x4b, 0x59, 0x92, 0x4d, 0xe9, 0x27, 0x6d, 0xec, 0x5f, 0x57, 0xc6, - 0x26, 0x70, 0x94, 0xd8, 0x9a, 0xb5, 0x95, 0x0f, 0x24, 0x76, 0xd1, 0x56, 0x2b, 0xa5, 0xb6, 0x03, - 0x7d, 0x85, 0xb2, 0x0c, 0x34, 0x68, 0x51, 0x53, 0xbb, 0xf4, 0x6a, 0xa2, 0xf9, 0xc2, 0x0c, 0x67, - 0xeb, 0x45, 0x2f, 0xbd, 0x16, 0x28, 0xd0, 0xf4, 0xda, 0x7f, 0xa2, 0xb7, 0xa2, 0x68, 0x6e, 0x45, - 0x50, 0xf8, 0x18, 0xf4, 0x92, 0x9c, 0x84, 0x7a, 0x73, 0x2a, 0x8a, 0x1e, 0x7b, 0x09, 0x50, 0xa0, - 0x20, 0x87, 0xf3, 0xc1, 0xf9, 0xf0, 0x8e, 0x14, 0x47, 0x69, 0x82, 0xdc, 0xb4, 0xe4, 0xf3, 0x3e, - 0x7c, 0x5f, 0xf2, 0x25, 0xdf, 0x87, 0x1c, 0x81, 0x1f, 0x1d, 0xbd, 0xe5, 0xaa, 0x9a, 0xd5, 0x3e, - 0xf2, 0x0e, 0x88, 0x63, 0x12, 0x4a, 0xdc, 0xf6, 0x80, 0x98, 0x3d, 0xcb, 0x69, 0x8b, 0x0e, 0x6c, - 0x6b, 0x6d, 0x6c, 0xdb, 0x6e, 0x7b, 0x70, 0xf3, 0x80, 0x50, 0xbc, 0xda, 0xee, 0x13, 0x93, 0x38, - 0x98, 0x92, 0x9e, 0x6a, 0x3b, 0x16, 0xb5, 0xe0, 0xa2, 0x0f, 0x54, 0xb1, 0xad, 0xa9, 0x0c, 0xa8, - 0x0a, 0xe0, 0xa5, 0x95, 0xbe, 0x46, 0x0f, 0xbd, 0x03, 0xb5, 0x6b, 0x19, 0xed, 0xbe, 0xd5, 0xb7, - 0xda, 0x1c, 0x7f, 0xe0, 0x3d, 0xe2, 0xbf, 0xf8, 0x0f, 0xfe, 0x97, 0xcf, 0x73, 0xa9, 0x15, 0x1b, - 0xb0, 0x6b, 0x39, 0xa4, 0x3d, 0xb8, 0x99, 0x1c, 0xeb, 0xd2, 0xeb, 0x11, 0xc6, 0xc0, 0xdd, 0x43, - 0xcd, 0x24, 0xce, 0xb0, 0x6d, 0x1f, 0xf5, 0x59, 0x83, 0xdb, 0x36, 0x08, 0xc5, 0x59, 0x56, 0xed, - 0x3c, 0x2b, 0xc7, 0x33, 0xa9, 0x66, 0x90, 0x94, 0xc1, 0x9b, 0xe3, 0x0c, 0xdc, 0xee, 0x21, 0x31, - 0x70, 0xca, 0xee, 0xb5, 0x3c, 0x3b, 0x8f, 0x6a, 0x7a, 0x5b, 0x33, 0xa9, 0x4b, 0x9d, 0xa4, 0x51, - 0xeb, 0xdf, 0x0a, 0x80, 0xeb, 0x96, 0x49, 0x1d, 0x4b, 0xd7, 0x89, 0x83, 0xc8, 0x40, 0x73, 0x35, - 0xcb, 0x84, 0x0f, 0x41, 0x8d, 0xc5, 0xd3, 0xc3, 0x14, 0x37, 0x94, 0x2b, 0xca, 0xf2, 0xd4, 0xea, - 0x0d, 0x35, 0x9a, 0xe9, 0x90, 0x5e, 0xb5, 0x8f, 0xfa, 0xac, 0xc1, 0x55, 0x19, 0x5a, 0x1d, 0xdc, - 0x54, 0x77, 0x0e, 0x3e, 0x20, 0x5d, 0xba, 0x45, 0x28, 0xee, 0xc0, 0x27, 0xc7, 0x4b, 0xe7, 0x46, - 0xc7, 0x4b, 0x20, 0x6a, 0x43, 0x21, 0x2b, 0xdc, 0x01, 0x15, 0xce, 0x5e, 0xe2, 0xec, 0x2b, 0xb9, - 0xec, 0x22, 0x68, 0x15, 0xe1, 0x5f, 0xbc, 0xf3, 0x98, 0x12, 0x93, 0xb9, 0xd7, 0x39, 0x2f, 0xa8, - 0x2b, 0x1b, 0x98, 0x62, 0xc4, 0x89, 0xe0, 0x75, 0x50, 0x73, 0x84, 0xfb, 0x8d, 0xf2, 0x15, 0x65, - 0xb9, 0xdc, 0xb9, 0x20, 0x50, 0xb5, 0x20, 0x2c, 0x14, 0x22, 0x5a, 0x4f, 0x14, 0xb0, 0x90, 0x8e, - 0x7b, 0x53, 0x73, 0x29, 0xfc, 0x69, 0x2a, 0x76, 0xb5, 0x58, 0xec, 0xcc, 0x9a, 0x47, 0x1e, 0x0e, - 0x1c, 0xb4, 0xc4, 0xe2, 0xde, 0x05, 0x55, 0x8d, 0x12, 0xc3, 0x6d, 0x94, 0xae, 0x94, 0x97, 0xa7, - 0x56, 0xaf, 0xa9, 0x39, 0x09, 0xac, 0xa6, 0xbd, 0xeb, 0x4c, 0x0b, 0xde, 0xea, 0x3d, 0xc6, 0x80, - 0x7c, 0xa2, 0xd6, 0xaf, 0x4b, 0xa0, 0xbe, 0x81, 0x89, 0x61, 0x99, 0x7b, 0x84, 0x9e, 0xc1, 0xca, - 0xdd, 0x05, 0x15, 0xd7, 0x26, 0x5d, 0xb1, 0x72, 0x57, 0x73, 0x03, 0x08, 0x7d, 0xda, 0xb3, 0x49, - 0x37, 0x5a, 0x32, 0xf6, 0x0b, 0x71, 0x06, 0xb8, 0x0b, 0x26, 0x5c, 0x8a, 0xa9, 0xe7, 0xf2, 0x05, - 0x9b, 0x5a, 0x5d, 0x2e, 0xc0, 0xc5, 0xf1, 0x9d, 0x19, 0xc1, 0x36, 0xe1, 0xff, 0x46, 0x82, 0xa7, - 0xf5, 0x8f, 0x12, 0x80, 0x21, 0x76, 0xdd, 0x32, 0x7b, 0x1a, 0x65, 0xe9, 0x7c, 0x0b, 0x54, 0xe8, - 0xd0, 0x26, 0x7c, 0x42, 0xea, 0x9d, 0xab, 0x81, 0x2b, 0xf7, 0x87, 0x36, 0xf9, 0xe2, 0x78, 0x69, - 0x21, 0x6d, 0xc1, 0x7a, 0x10, 0xb7, 0x81, 0x9b, 0xa1, 0x93, 0x25, 0x6e, 0xfd, 0xba, 0x3c, 0xf4, - 0x17, 0xc7, 0x4b, 0x19, 0x67, 0x87, 0x1a, 0x32, 0xc9, 0x0e, 0xc2, 0x01, 0x80, 0x3a, 0x76, 0xe9, - 0x7d, 0x07, 0x9b, 0xae, 0x3f, 0x92, 0x66, 0x10, 0x11, 0xfe, 0xab, 0xc5, 0x16, 0x8a, 0x59, 0x74, - 0x2e, 0x09, 0x2f, 0xe0, 0x66, 0x8a, 0x0d, 0x65, 0x8c, 0x00, 0xaf, 0x82, 0x09, 0x87, 0x60, 0xd7, - 0x32, 0x1b, 0x15, 0x1e, 0x45, 0x38, 0x81, 0x88, 0xb7, 0x22, 0xd1, 0x0b, 0x5f, 0x01, 0x93, 0x06, - 0x71, 0x5d, 0xdc, 0x27, 0x8d, 0x2a, 0x07, 0xce, 0x0a, 0xe0, 0xe4, 0x96, 0xdf, 0x8c, 0x82, 0xfe, - 0xd6, 0x1f, 0x15, 0x30, 0x1d, 0xce, 0xdc, 0x19, 0xec, 0x9c, 0x3b, 0xf2, 0xce, 0x69, 0x8d, 0x4f, - 0x96, 0x9c, 0x0d, 0xf3, 0x71, 0x39, 0xe6, 0x38, 0x4b, 0x47, 0xf8, 0x33, 0x50, 0x73, 0x89, 0x4e, - 0xba, 0xd4, 0x72, 0x84, 0xe3, 0xaf, 0x15, 0x74, 0x1c, 0x1f, 0x10, 0x7d, 0x4f, 0x98, 0x76, 0xce, - 0x33, 0xcf, 0x83, 0x5f, 0x28, 0xa4, 0x84, 0xef, 0x81, 0x1a, 0x25, 0x86, 0xad, 0x63, 0x4a, 0xc4, - 0xae, 0x79, 0x31, 0xee, 0x3c, 0xcb, 0x19, 0x46, 0xb6, 0x6b, 0xf5, 0xee, 0x0b, 0x18, 0xdf, 0x32, - 0xe1, 0x64, 0x04, 0xad, 0x28, 0xa4, 0x81, 0x36, 0x98, 0xf1, 0xec, 0x1e, 0x43, 0x52, 0x76, 0x9c, - 0xf7, 0x87, 0x22, 0x87, 0x6e, 0x8c, 0x9f, 0x95, 0x7d, 0xc9, 0xae, 0xb3, 0x20, 0x46, 0x99, 0x91, - 0xdb, 0x51, 0x82, 0x1f, 0xae, 0x81, 0x59, 0x43, 0x33, 0x11, 0xc1, 0xbd, 0xe1, 0x1e, 0xe9, 0x5a, - 0x66, 0xcf, 0xe5, 0xa9, 0x54, 0xed, 0x2c, 0x0a, 0x82, 0xd9, 0x2d, 0xb9, 0x1b, 0x25, 0xf1, 0x70, - 0x13, 0xcc, 0x07, 0x07, 0xf0, 0x5d, 0xcd, 0xa5, 0x96, 0x33, 0xdc, 0xd4, 0x0c, 0x8d, 0x36, 0x26, - 0x38, 0x4f, 0x63, 0x74, 0xbc, 0x34, 0x8f, 0x32, 0xfa, 0x51, 0xa6, 0x55, 0xeb, 0x77, 0x13, 0x60, - 0x36, 0x71, 0x2e, 0xc0, 0x07, 0x60, 0xa1, 0xeb, 0x39, 0x0e, 0x31, 0xe9, 0xb6, 0x67, 0x1c, 0x10, - 0x67, 0xaf, 0x7b, 0x48, 0x7a, 0x9e, 0x4e, 0x7a, 0x7c, 0x59, 0xab, 0x9d, 0xa6, 0xf0, 0x75, 0x61, - 0x3d, 0x13, 0x85, 0x72, 0xac, 0xe1, 0xbb, 0x00, 0x9a, 0xbc, 0x69, 0x4b, 0x73, 0xdd, 0x90, 0xb3, - 0xc4, 0x39, 0xc3, 0xad, 0xb8, 0x9d, 0x42, 0xa0, 0x0c, 0x2b, 0xe6, 0x63, 0x8f, 0xb8, 0x9a, 0x43, - 0x7a, 0x49, 0x1f, 0xcb, 0xb2, 0x8f, 0x1b, 0x99, 0x28, 0x94, 0x63, 0x0d, 0xdf, 0x00, 0x53, 0xfe, - 0x68, 0x7c, 0xce, 0xc5, 0xe2, 0xcc, 0x09, 0xb2, 0xa9, 0xed, 0xa8, 0x0b, 0xc5, 0x71, 0x2c, 0x34, - 0xeb, 0xc0, 0x25, 0xce, 0x80, 0xf4, 0xee, 0xf8, 0xe2, 0x80, 0x55, 0xd0, 0x2a, 0xaf, 0xa0, 0x61, - 0x68, 0x3b, 0x29, 0x04, 0xca, 0xb0, 0x62, 0xa1, 0xf9, 0x59, 0x93, 0x0a, 0x6d, 0x42, 0x0e, 0x6d, - 0x3f, 0x13, 0x85, 0x72, 0xac, 0x59, 0xee, 0xf9, 0x2e, 0xaf, 0x0d, 0xb0, 0xa6, 0xe3, 0x03, 0x9d, - 0x34, 0x26, 0xe5, 0xdc, 0xdb, 0x96, 0xbb, 0x51, 0x12, 0x0f, 0xef, 0x80, 0x8b, 0x7e, 0xd3, 0xbe, - 0x89, 0x43, 0x92, 0x1a, 0x27, 0x79, 0x41, 0x90, 0x5c, 0xdc, 0x4e, 0x02, 0x50, 0xda, 0x06, 0xde, - 0x02, 0x33, 0x5d, 0x4b, 0xd7, 0x79, 0x3e, 0xae, 0x5b, 0x9e, 0x49, 0x1b, 0x75, 0xce, 0x02, 0xd9, - 0x1e, 0x5a, 0x97, 0x7a, 0x50, 0x02, 0x09, 0x7f, 0x0e, 0x40, 0x37, 0x28, 0x0c, 0x6e, 0x03, 0x8c, - 0x51, 0x00, 0xe9, 0xb2, 0x14, 0x55, 0xe6, 0xb0, 0xc9, 0x45, 0x31, 0xca, 0xd6, 0xc7, 0x0a, 0x58, - 0xcc, 0xd9, 0xe8, 0xf0, 0x87, 0x52, 0x11, 0xbc, 0x96, 0x28, 0x82, 0x97, 0x73, 0xcc, 0x62, 0x95, - 0xf0, 0x10, 0x4c, 0x33, 0x41, 0xa2, 0x99, 0x7d, 0x1f, 0x22, 0xce, 0xb2, 0x76, 0x6e, 0x00, 0x28, - 0x8e, 0x8e, 0x4e, 0xe5, 0x8b, 0xa3, 0xe3, 0xa5, 0x69, 0xa9, 0x0f, 0xc9, 0xc4, 0xad, 0xdf, 0x94, - 0x00, 0xd8, 0x20, 0xb6, 0x6e, 0x0d, 0x0d, 0x62, 0x9e, 0x85, 0xa6, 0xb9, 0x27, 0x69, 0x9a, 0x97, - 0xf3, 0x97, 0x24, 0x74, 0x2a, 0x57, 0xd4, 0xbc, 0x97, 0x10, 0x35, 0xaf, 0x14, 0x21, 0x7b, 0xb6, - 0xaa, 0xf9, 0xb4, 0x0c, 0xe6, 0x22, 0x70, 0x24, 0x6b, 0x6e, 0x4b, 0x2b, 0xfa, 0x72, 0x62, 0x45, - 0x17, 0x33, 0x4c, 0xbe, 0x32, 0x5d, 0xf3, 0x01, 0x98, 0x61, 0xaa, 0xc3, 0x5f, 0x3f, 0xae, 0x69, - 0x26, 0x4e, 0xac, 0x69, 0xc2, 0x4a, 0xb4, 0x29, 0x31, 0xa1, 0x04, 0x73, 0x8e, 0x86, 0x9a, 0xfc, - 0x26, 0x6a, 0xa8, 0x3f, 0x29, 0x60, 0x26, 0x5a, 0xa6, 0x33, 0x10, 0x51, 0x77, 0x65, 0x11, 0xf5, - 0x62, 0x81, 0xe4, 0xcc, 0x51, 0x51, 0x9f, 0x56, 0xe2, 0xae, 0x73, 0x19, 0xb5, 0xcc, 0xae, 0x60, - 0xb6, 0xae, 0x75, 0xb1, 0x2b, 0xea, 0xed, 0x79, 0xff, 0xfa, 0xe5, 0xb7, 0xa1, 0xb0, 0x57, 0x12, - 0x5c, 0xa5, 0xaf, 0x56, 0x70, 0x95, 0x9f, 0x8f, 0xe0, 0xfa, 0x09, 0xa8, 0xb9, 0x81, 0xd4, 0xaa, - 0x70, 0xca, 0x6b, 0x85, 0x36, 0xb6, 0x50, 0x59, 0x21, 0x75, 0xa8, 0xaf, 0x42, 0xba, 0x2c, 0x65, - 0x55, 0xfd, 0x3a, 0x95, 0x15, 0x4b, 0x74, 0x1b, 0x7b, 0x2e, 0xe9, 0xf1, 0x4d, 0x55, 0x8b, 0x12, - 0x7d, 0x97, 0xb7, 0x22, 0xd1, 0x0b, 0xf7, 0xc1, 0xa2, 0xed, 0x58, 0x7d, 0x87, 0xb8, 0xee, 0x06, - 0xc1, 0x3d, 0x5d, 0x33, 0x49, 0x10, 0x80, 0x5f, 0x13, 0x2f, 0x8f, 0x8e, 0x97, 0x16, 0x77, 0xb3, - 0x21, 0x28, 0xcf, 0xb6, 0xf5, 0x97, 0x0a, 0xb8, 0x90, 0x3c, 0x1b, 0x73, 0x64, 0x8a, 0x72, 0x2a, - 0x99, 0x72, 0x3d, 0x96, 0xa7, 0xbe, 0x86, 0x8b, 0x3d, 0x15, 0xa4, 0x72, 0x75, 0x0d, 0xcc, 0x0a, - 0x59, 0x12, 0x74, 0x0a, 0xa1, 0x16, 0x2e, 0xcf, 0xbe, 0xdc, 0x8d, 0x92, 0x78, 0x78, 0x1b, 0x4c, - 0x3b, 0x5c, 0x79, 0x05, 0x04, 0xbe, 0x7a, 0xf9, 0x3f, 0x41, 0x30, 0x8d, 0xe2, 0x9d, 0x48, 0xc6, - 0x32, 0xe5, 0x12, 0x09, 0x92, 0x80, 0xa0, 0x22, 0x2b, 0x97, 0xb5, 0x24, 0x00, 0xa5, 0x6d, 0xe0, - 0x16, 0x98, 0xf3, 0xcc, 0x34, 0x95, 0x9f, 0x6b, 0x97, 0x05, 0xd5, 0xdc, 0x7e, 0x1a, 0x82, 0xb2, - 0xec, 0xe0, 0x43, 0x49, 0xcc, 0x4c, 0xf0, 0xf3, 0xe4, 0x7a, 0x81, 0x3d, 0x51, 0x58, 0xcd, 0x64, - 0x48, 0xad, 0x5a, 0x51, 0xa9, 0xd5, 0xfa, 0x48, 0x01, 0x30, 0xbd, 0x0f, 0xc7, 0xbe, 0x04, 0xa4, - 0x2c, 0x62, 0x15, 0x53, 0xcb, 0xd6, 0x3f, 0x37, 0x0a, 0xea, 0x9f, 0xe8, 0x40, 0x2d, 0x26, 0x80, - 0xc4, 0x44, 0x9f, 0xcd, 0xa3, 0x4e, 0x51, 0x01, 0x14, 0x39, 0xf5, 0x1c, 0x04, 0x50, 0x8c, 0xec, - 0xd9, 0x02, 0xe8, 0x9f, 0x25, 0x30, 0x17, 0x81, 0x0b, 0x0b, 0xa0, 0x0c, 0x93, 0xef, 0x1e, 0x76, - 0x8a, 0x89, 0x92, 0x68, 0xea, 0xfe, 0x97, 0x44, 0x49, 0xe4, 0x55, 0x8e, 0x28, 0xf9, 0x43, 0x29, - 0xee, 0xfa, 0x09, 0x45, 0xc9, 0x73, 0x78, 0xe1, 0xf8, 0xc6, 0xe9, 0x9a, 0xd6, 0x5f, 0xcb, 0xe0, - 0x42, 0x72, 0x1f, 0x4a, 0x05, 0x52, 0x19, 0x5b, 0x20, 0x77, 0xc1, 0xfc, 0x23, 0x4f, 0xd7, 0x87, - 0x3c, 0x86, 0x58, 0x95, 0xf4, 0x4b, 0xeb, 0xff, 0x0b, 0xcb, 0xf9, 0x1f, 0x67, 0x60, 0x50, 0xa6, - 0x65, 0xba, 0x5e, 0x56, 0xbe, 0x6c, 0xbd, 0xac, 0x9e, 0xa2, 0x5e, 0x66, 0x4b, 0x8e, 0xf2, 0xa9, - 0x24, 0xc7, 0xc9, 0x8a, 0x65, 0xc6, 0xc1, 0x35, 0xf6, 0xea, 0x3f, 0x52, 0xc0, 0x42, 0xf6, 0x85, - 0x1b, 0xea, 0x60, 0xc6, 0xc0, 0x8f, 0xe3, 0x0f, 0x1f, 0xe3, 0x8a, 0x88, 0x47, 0x35, 0x5d, 0xf5, - 0x3f, 0x19, 0xa9, 0xf7, 0x4c, 0xba, 0xe3, 0xec, 0x51, 0x47, 0x33, 0xfb, 0x7e, 0xe5, 0xdd, 0x92, - 0xb8, 0x50, 0x82, 0x1b, 0xbe, 0x0f, 0x6a, 0x06, 0x7e, 0xbc, 0xe7, 0x39, 0xfd, 0xac, 0x0a, 0x59, - 0x6c, 0x1c, 0xbe, 0x01, 0xb6, 0x04, 0x0b, 0x0a, 0xf9, 0x5a, 0x9f, 0x2b, 0x60, 0x31, 0xa7, 0xaa, - 0x7e, 0x8b, 0xa2, 0xdc, 0x01, 0x57, 0xa4, 0x20, 0xd9, 0xae, 0x24, 0x8f, 0x3c, 0x9d, 0x6f, 0x50, - 0x21, 0x64, 0xae, 0x81, 0xba, 0x8d, 0x1d, 0xaa, 0x85, 0x32, 0xb8, 0xda, 0x99, 0x1e, 0x1d, 0x2f, - 0xd5, 0x77, 0x83, 0x46, 0x14, 0xf5, 0xb7, 0xfe, 0xa3, 0x80, 0xea, 0x5e, 0x17, 0xeb, 0xe4, 0x0c, - 0x94, 0xc4, 0x86, 0xa4, 0x24, 0xf2, 0x5f, 0xe9, 0xb9, 0x3f, 0xb9, 0x22, 0x62, 0x33, 0x21, 0x22, - 0x5e, 0x1a, 0xc3, 0xf3, 0x6c, 0xfd, 0xf0, 0x36, 0xa8, 0x87, 0xc3, 0x9d, 0xec, 0x70, 0x6b, 0xfd, - 0xbe, 0x04, 0xa6, 0x62, 0x43, 0x9c, 0xf0, 0x68, 0x7c, 0x28, 0xd5, 0x03, 0xb6, 0xe9, 0x57, 0x8b, - 0x04, 0xa2, 0x06, 0x67, 0xff, 0x3b, 0x26, 0x75, 0xe2, 0x97, 0xc7, 0x74, 0x49, 0xf8, 0x01, 0x98, - 0xa1, 0xd8, 0xe9, 0x13, 0x1a, 0xf4, 0xf1, 0x09, 0xab, 0x47, 0x8f, 0x29, 0xf7, 0xa5, 0x5e, 0x94, - 0x40, 0x5f, 0xba, 0x0d, 0xa6, 0xa5, 0xc1, 0xe0, 0x05, 0x50, 0x3e, 0x22, 0x43, 0x5f, 0x52, 0x21, - 0xf6, 0x27, 0x9c, 0x07, 0xd5, 0x01, 0xd6, 0x3d, 0x3f, 0xcf, 0xeb, 0xc8, 0xff, 0x71, 0xab, 0xf4, - 0x96, 0xd2, 0xfa, 0x2d, 0x9b, 0x9c, 0x28, 0x39, 0xcf, 0x20, 0xbb, 0xde, 0x95, 0xb2, 0x2b, 0xff, - 0x83, 0x61, 0x7c, 0xcb, 0xe4, 0xe5, 0x18, 0x4a, 0xe4, 0xd8, 0xab, 0x85, 0xd8, 0x9e, 0x9d, 0x69, - 0xff, 0x2a, 0x81, 0xf9, 0x18, 0x3a, 0x92, 0xaa, 0xdf, 0x97, 0xa4, 0xea, 0x72, 0x42, 0xaa, 0x36, - 0xb2, 0x6c, 0xbe, 0xd3, 0xaa, 0xe3, 0xb5, 0xea, 0x9f, 0x15, 0x30, 0x1b, 0x9b, 0xbb, 0x33, 0x10, - 0xab, 0xf7, 0x64, 0xb1, 0xfa, 0x52, 0x91, 0xa4, 0xc9, 0x51, 0xab, 0x1f, 0x4e, 0x48, 0xce, 0x7f, - 0xeb, 0xdf, 0xd0, 0x7e, 0x09, 0xe6, 0x07, 0x96, 0xee, 0x19, 0x64, 0x5d, 0xc7, 0x9a, 0x11, 0x00, - 0x98, 0xba, 0x2b, 0x27, 0xef, 0x89, 0x21, 0x3d, 0x71, 0x5c, 0xcd, 0xa5, 0xc4, 0xa4, 0x0f, 0x22, - 0xcb, 0x48, 0x53, 0x3e, 0xc8, 0xa0, 0x43, 0x99, 0x83, 0xc0, 0x37, 0xc0, 0x14, 0x53, 0x65, 0x5a, - 0x97, 0x6c, 0x63, 0x23, 0x48, 0xac, 0xf0, 0xf3, 0xd8, 0x5e, 0xd4, 0x85, 0xe2, 0x38, 0x78, 0x08, - 0xe6, 0x6c, 0xab, 0xb7, 0x85, 0x4d, 0xdc, 0x27, 0x4c, 0x66, 0xec, 0x5a, 0xba, 0xd6, 0x1d, 0xf2, - 0x87, 0xb5, 0x7a, 0xe7, 0xcd, 0xe0, 0xd1, 0x64, 0x37, 0x0d, 0x61, 0x17, 0xd0, 0x8c, 0x66, 0xbe, - 0xa9, 0xb3, 0x28, 0xa1, 0x93, 0xfa, 0xa4, 0xeb, 0x3f, 0x69, 0xaf, 0x16, 0xc9, 0xb0, 0x53, 0x7e, - 0xd4, 0xcd, 0x7b, 0x37, 0xac, 0x9d, 0xea, 0xdd, 0x30, 0xe3, 0x02, 0x55, 0x3f, 0xd9, 0x05, 0xaa, - 0xf5, 0x51, 0x15, 0x5c, 0x4c, 0x9d, 0xb6, 0x5f, 0xe3, 0xe3, 0x5f, 0xea, 0x26, 0x52, 0x3e, 0xc1, - 0x4d, 0x64, 0x0d, 0xcc, 0x8a, 0xef, 0xc9, 0x89, 0x8b, 0x4c, 0x38, 0x1f, 0xeb, 0x72, 0x37, 0x4a, - 0xe2, 0xb3, 0x1e, 0x1f, 0xab, 0x27, 0x7c, 0x7c, 0x8c, 0x7b, 0x21, 0xfe, 0x3f, 0xca, 0xcf, 0xde, - 0xb4, 0x17, 0xe2, 0xdf, 0xa4, 0x92, 0x78, 0x26, 0x32, 0x7c, 0xd6, 0x90, 0x61, 0x52, 0x16, 0x19, - 0xfb, 0x52, 0x2f, 0x4a, 0xa0, 0xbf, 0xd4, 0x37, 0x53, 0x9c, 0xf1, 0xcd, 0x74, 0xa5, 0xc8, 0x96, - 0x28, 0xfe, 0xce, 0x98, 0x79, 0x63, 0x9c, 0x3a, 0xf9, 0x8d, 0xb1, 0xf5, 0x37, 0x05, 0xbc, 0x90, - 0xbb, 0x29, 0xe1, 0x9a, 0x24, 0x01, 0x56, 0x12, 0x12, 0xe0, 0x7b, 0xb9, 0x86, 0x31, 0x1d, 0xe0, - 0x64, 0x3f, 0x41, 0xbe, 0x5d, 0xec, 0x09, 0x32, 0xe3, 0x1e, 0x31, 0xfe, 0x2d, 0xb2, 0xb3, 0xf2, - 0xe4, 0x69, 0xf3, 0xdc, 0x27, 0x4f, 0x9b, 0xe7, 0x3e, 0x7b, 0xda, 0x3c, 0xf7, 0xab, 0x51, 0x53, - 0x79, 0x32, 0x6a, 0x2a, 0x9f, 0x8c, 0x9a, 0xca, 0x67, 0xa3, 0xa6, 0xf2, 0xf7, 0x51, 0x53, 0xf9, - 0xf0, 0xf3, 0xe6, 0xb9, 0xf7, 0x27, 0xc5, 0x88, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xda, 0x5d, - 0xee, 0xc9, 0xd4, 0x29, 0x00, 0x00, + // 2284 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcf, 0x6f, 0x1b, 0xc7, + 0xf5, 0xf7, 0xf2, 0x87, 0x44, 0x8e, 0x2c, 0xc9, 0x1e, 0xe9, 0x2b, 0x31, 0xf2, 0xb7, 0xa4, 0xb1, + 0x31, 0x1c, 0x25, 0xb6, 0x48, 0x5b, 0xf9, 0x81, 0xc4, 0x2e, 0x92, 0x8a, 0x52, 0x6a, 0x3b, 0xd0, + 0x0f, 0x66, 0x64, 0x39, 0x68, 0xd0, 0x1f, 0x1e, 0x91, 0x63, 0x6a, 0xa3, 0xe5, 0xee, 0x62, 0x77, + 0x96, 0x31, 0xd1, 0x4b, 0xaf, 0x05, 0x0a, 0xb4, 0xbd, 0xf6, 0x9f, 0xe8, 0xad, 0x28, 0x9a, 0x5b, + 0x11, 0x04, 0x3e, 0x06, 0xbd, 0x24, 0xbd, 0x10, 0x35, 0x73, 0x2a, 0x8a, 0xde, 0xda, 0x8b, 0x81, + 0x02, 0xc5, 0xcc, 0xce, 0xfe, 0xde, 0x35, 0x97, 0x8a, 0xa3, 0x34, 0x41, 0x6e, 0xe2, 0xbc, 0xf7, + 0x3e, 0xf3, 0xde, 0xcc, 0x7b, 0xf3, 0x3e, 0x33, 0x2b, 0xf0, 0x83, 0xe3, 0xd7, 0xad, 0xba, 0xa2, + 0x37, 0x8e, 0xed, 0x43, 0x62, 0x6a, 0x84, 0x12, 0xab, 0xd1, 0x27, 0x5a, 0x47, 0x37, 0x1b, 0x42, + 0x80, 0x0d, 0xa5, 0x81, 0x0d, 0xc3, 0x6a, 0xf4, 0xaf, 0x1f, 0x12, 0x8a, 0xd7, 0x1b, 0x5d, 0xa2, + 0x11, 0x13, 0x53, 0xd2, 0xa9, 0x1b, 0xa6, 0x4e, 0x75, 0xb8, 0xec, 0x28, 0xd6, 0xb1, 0xa1, 0xd4, + 0x99, 0x62, 0x5d, 0x28, 0xae, 0xac, 0x75, 0x15, 0x7a, 0x64, 0x1f, 0xd6, 0xdb, 0x7a, 0xaf, 0xd1, + 0xd5, 0xbb, 0x7a, 0x83, 0xeb, 0x1f, 0xda, 0x0f, 0xf8, 0x2f, 0xfe, 0x83, 0xff, 0xe5, 0xe0, 0xac, + 0xc8, 0x81, 0x09, 0xdb, 0xba, 0x49, 0x1a, 0xfd, 0xeb, 0xd1, 0xb9, 0x56, 0x5e, 0xf1, 0x75, 0x7a, + 0xb8, 0x7d, 0xa4, 0x68, 0xc4, 0x1c, 0x34, 0x8c, 0xe3, 0x2e, 0x1b, 0xb0, 0x1a, 0x3d, 0x42, 0x71, + 0x92, 0x55, 0x23, 0xcd, 0xca, 0xb4, 0x35, 0xaa, 0xf4, 0x48, 0xcc, 0xe0, 0xb5, 0x71, 0x06, 0x56, + 0xfb, 0x88, 0xf4, 0x70, 0xcc, 0xee, 0xe5, 0x34, 0x3b, 0x9b, 0x2a, 0x6a, 0x43, 0xd1, 0xa8, 0x45, + 0xcd, 0xa8, 0x91, 0xfc, 0x6f, 0x09, 0xc0, 0x4d, 0x5d, 0xa3, 0xa6, 0xae, 0xaa, 0xc4, 0x44, 0xa4, + 0xaf, 0x58, 0x8a, 0xae, 0xc1, 0xfb, 0xa0, 0xc4, 0xe2, 0xe9, 0x60, 0x8a, 0x2b, 0xd2, 0x45, 0x69, + 0x75, 0x66, 0xfd, 0x5a, 0xdd, 0x5f, 0x69, 0x0f, 0xbe, 0x6e, 0x1c, 0x77, 0xd9, 0x80, 0x55, 0x67, + 0xda, 0xf5, 0xfe, 0xf5, 0xfa, 0xde, 0xe1, 0x07, 0xa4, 0x4d, 0x77, 0x08, 0xc5, 0x4d, 0xf8, 0x68, + 0x58, 0x3b, 0x33, 0x1a, 0xd6, 0x80, 0x3f, 0x86, 0x3c, 0x54, 0xb8, 0x07, 0x0a, 0x1c, 0x3d, 0xc7, + 0xd1, 0xd7, 0x52, 0xd1, 0x45, 0xd0, 0x75, 0x84, 0x3f, 0x7c, 0xfb, 0x21, 0x25, 0x1a, 0x73, 0xaf, + 0x79, 0x56, 0x40, 0x17, 0xb6, 0x30, 0xc5, 0x88, 0x03, 0xc1, 0xab, 0xa0, 0x64, 0x0a, 0xf7, 0x2b, + 0xf9, 0x8b, 0xd2, 0x6a, 0xbe, 0x79, 0x4e, 0x68, 0x95, 0xdc, 0xb0, 0x90, 0xa7, 0x21, 0x3f, 0x92, + 0xc0, 0x52, 0x3c, 0xee, 0x6d, 0xc5, 0xa2, 0xf0, 0xc7, 0xb1, 0xd8, 0xeb, 0xd9, 0x62, 0x67, 0xd6, + 0x3c, 0x72, 0x6f, 0x62, 0x77, 0x24, 0x10, 0x77, 0x0b, 0x14, 0x15, 0x4a, 0x7a, 0x56, 0x25, 0x77, + 0x31, 0xbf, 0x3a, 0xb3, 0x7e, 0xa5, 0x9e, 0x92, 0xc0, 0xf5, 0xb8, 0x77, 0xcd, 0x59, 0x81, 0x5b, + 0xbc, 0xc3, 0x10, 0x90, 0x03, 0x24, 0xff, 0x32, 0x07, 0xca, 0x5b, 0x98, 0xf4, 0x74, 0x6d, 0x9f, + 0xd0, 0x53, 0xd8, 0xb9, 0xdb, 0xa0, 0x60, 0x19, 0xa4, 0x2d, 0x76, 0xee, 0x72, 0x6a, 0x00, 0x9e, + 0x4f, 0xfb, 0x06, 0x69, 0xfb, 0x5b, 0xc6, 0x7e, 0x21, 0x8e, 0x00, 0x5b, 0x60, 0xca, 0xa2, 0x98, + 0xda, 0x16, 0xdf, 0xb0, 0x99, 0xf5, 0xd5, 0x0c, 0x58, 0x5c, 0xbf, 0x39, 0x27, 0xd0, 0xa6, 0x9c, + 0xdf, 0x48, 0xe0, 0xc8, 0x7f, 0xcf, 0x01, 0xe8, 0xe9, 0x6e, 0xea, 0x5a, 0x47, 0xa1, 0x2c, 0x9d, + 0x6f, 0x80, 0x02, 0x1d, 0x18, 0x84, 0x2f, 0x48, 0xb9, 0x79, 0xd9, 0x75, 0xe5, 0xee, 0xc0, 0x20, + 0x4f, 0x86, 0xb5, 0xa5, 0xb8, 0x05, 0x93, 0x20, 0x6e, 0x03, 0xb7, 0x3d, 0x27, 0x73, 0xdc, 0xfa, + 0x95, 0xf0, 0xd4, 0x4f, 0x86, 0xb5, 0x84, 0xb3, 0xa3, 0xee, 0x21, 0x85, 0x1d, 0x84, 0x7d, 0x00, + 0x55, 0x6c, 0xd1, 0xbb, 0x26, 0xd6, 0x2c, 0x67, 0x26, 0xa5, 0x47, 0x44, 0xf8, 0x2f, 0x65, 0xdb, + 0x28, 0x66, 0xd1, 0x5c, 0x11, 0x5e, 0xc0, 0xed, 0x18, 0x1a, 0x4a, 0x98, 0x01, 0x5e, 0x06, 0x53, + 0x26, 0xc1, 0x96, 0xae, 0x55, 0x0a, 0x3c, 0x0a, 0x6f, 0x01, 0x11, 0x1f, 0x45, 0x42, 0x0a, 0x5f, + 0x04, 0xd3, 0x3d, 0x62, 0x59, 0xb8, 0x4b, 0x2a, 0x45, 0xae, 0x38, 0x2f, 0x14, 0xa7, 0x77, 0x9c, + 0x61, 0xe4, 0xca, 0xe5, 0x3f, 0x48, 0x60, 0xd6, 0x5b, 0xb9, 0x53, 0xa8, 0x9c, 0x5b, 0xe1, 0xca, + 0x91, 0xc7, 0x27, 0x4b, 0x4a, 0xc1, 0x7c, 0x9c, 0x0f, 0x38, 0xce, 0xd2, 0x11, 0xfe, 0x04, 0x94, + 0x2c, 0xa2, 0x92, 0x36, 0xd5, 0x4d, 0xe1, 0xf8, 0xcb, 0x19, 0x1d, 0xc7, 0x87, 0x44, 0xdd, 0x17, + 0xa6, 0xcd, 0xb3, 0xcc, 0x73, 0xf7, 0x17, 0xf2, 0x20, 0xe1, 0xbb, 0xa0, 0x44, 0x49, 0xcf, 0x50, + 0x31, 0x25, 0xa2, 0x6a, 0x9e, 0x0f, 0x3a, 0xcf, 0x72, 0x86, 0x81, 0xb5, 0xf4, 0xce, 0x5d, 0xa1, + 0xc6, 0x4b, 0xc6, 0x5b, 0x0c, 0x77, 0x14, 0x79, 0x30, 0xd0, 0x00, 0x73, 0xb6, 0xd1, 0x61, 0x9a, + 0x94, 0x1d, 0xe7, 0xdd, 0x81, 0xc8, 0xa1, 0x6b, 0xe3, 0x57, 0xe5, 0x20, 0x64, 0xd7, 0x5c, 0x12, + 0xb3, 0xcc, 0x85, 0xc7, 0x51, 0x04, 0x1f, 0x6e, 0x80, 0xf9, 0x9e, 0xa2, 0x21, 0x82, 0x3b, 0x83, + 0x7d, 0xd2, 0xd6, 0xb5, 0x8e, 0xc5, 0x53, 0xa9, 0xd8, 0x5c, 0x16, 0x00, 0xf3, 0x3b, 0x61, 0x31, + 0x8a, 0xea, 0xc3, 0x6d, 0xb0, 0xe8, 0x1e, 0xc0, 0xb7, 0x15, 0x8b, 0xea, 0xe6, 0x60, 0x5b, 0xe9, + 0x29, 0xb4, 0x32, 0xc5, 0x71, 0x2a, 0xa3, 0x61, 0x6d, 0x11, 0x25, 0xc8, 0x51, 0xa2, 0x95, 0xfc, + 0xdb, 0x29, 0x30, 0x1f, 0x39, 0x17, 0xe0, 0x3d, 0xb0, 0xd4, 0xb6, 0x4d, 0x93, 0x68, 0x74, 0xd7, + 0xee, 0x1d, 0x12, 0x73, 0xbf, 0x7d, 0x44, 0x3a, 0xb6, 0x4a, 0x3a, 0x7c, 0x5b, 0x8b, 0xcd, 0xaa, + 0xf0, 0x75, 0x69, 0x33, 0x51, 0x0b, 0xa5, 0x58, 0xc3, 0x77, 0x00, 0xd4, 0xf8, 0xd0, 0x8e, 0x62, + 0x59, 0x1e, 0x66, 0x8e, 0x63, 0x7a, 0xa5, 0xb8, 0x1b, 0xd3, 0x40, 0x09, 0x56, 0xcc, 0xc7, 0x0e, + 0xb1, 0x14, 0x93, 0x74, 0xa2, 0x3e, 0xe6, 0xc3, 0x3e, 0x6e, 0x25, 0x6a, 0xa1, 0x14, 0x6b, 0xf8, + 0x2a, 0x98, 0x71, 0x66, 0xe3, 0x6b, 0x2e, 0x36, 0x67, 0x41, 0x80, 0xcd, 0xec, 0xfa, 0x22, 0x14, + 0xd4, 0x63, 0xa1, 0xe9, 0x87, 0x16, 0x31, 0xfb, 0xa4, 0x73, 0xcb, 0x21, 0x07, 0xac, 0x83, 0x16, + 0x79, 0x07, 0xf5, 0x42, 0xdb, 0x8b, 0x69, 0xa0, 0x04, 0x2b, 0x16, 0x9a, 0x93, 0x35, 0xb1, 0xd0, + 0xa6, 0xc2, 0xa1, 0x1d, 0x24, 0x6a, 0xa1, 0x14, 0x6b, 0x96, 0x7b, 0x8e, 0xcb, 0x1b, 0x7d, 0xac, + 0xa8, 0xf8, 0x50, 0x25, 0x95, 0xe9, 0x70, 0xee, 0xed, 0x86, 0xc5, 0x28, 0xaa, 0x0f, 0x6f, 0x81, + 0xf3, 0xce, 0xd0, 0x81, 0x86, 0x3d, 0x90, 0x12, 0x07, 0x79, 0x4e, 0x80, 0x9c, 0xdf, 0x8d, 0x2a, + 0xa0, 0xb8, 0x0d, 0xbc, 0x01, 0xe6, 0xda, 0xba, 0xaa, 0xf2, 0x7c, 0xdc, 0xd4, 0x6d, 0x8d, 0x56, + 0xca, 0x1c, 0x05, 0xb2, 0x1a, 0xda, 0x0c, 0x49, 0x50, 0x44, 0x13, 0xfe, 0x0c, 0x80, 0xb6, 0xdb, + 0x18, 0xac, 0x0a, 0x18, 0xc3, 0x00, 0xe2, 0x6d, 0xc9, 0xef, 0xcc, 0xde, 0x90, 0x85, 0x02, 0x90, + 0xf2, 0xc7, 0x12, 0x58, 0x4e, 0x29, 0x74, 0xf8, 0x56, 0xa8, 0x09, 0x5e, 0x89, 0x34, 0xc1, 0x0b, + 0x29, 0x66, 0x81, 0x4e, 0x78, 0x04, 0x66, 0x19, 0x21, 0x51, 0xb4, 0xae, 0xa3, 0x22, 0xce, 0xb2, + 0x46, 0x6a, 0x00, 0x28, 0xa8, 0xed, 0x9f, 0xca, 0xe7, 0x47, 0xc3, 0xda, 0x6c, 0x48, 0x86, 0xc2, + 0xc0, 0xf2, 0xaf, 0x72, 0x00, 0x6c, 0x11, 0x43, 0xd5, 0x07, 0x3d, 0xa2, 0x9d, 0x06, 0xa7, 0xb9, + 0x13, 0xe2, 0x34, 0x2f, 0xa4, 0x6f, 0x89, 0xe7, 0x54, 0x2a, 0xa9, 0x79, 0x37, 0x42, 0x6a, 0x5e, + 0xcc, 0x02, 0xf6, 0x74, 0x56, 0xf3, 0x59, 0x1e, 0x2c, 0xf8, 0xca, 0x3e, 0xad, 0xb9, 0x19, 0xda, + 0xd1, 0x17, 0x22, 0x3b, 0xba, 0x9c, 0x60, 0xf2, 0x95, 0xf1, 0x9a, 0x0f, 0xc0, 0x1c, 0x63, 0x1d, + 0xce, 0xfe, 0x71, 0x4e, 0x33, 0x35, 0x31, 0xa7, 0xf1, 0x3a, 0xd1, 0x76, 0x08, 0x09, 0x45, 0x90, + 0x53, 0x38, 0xd4, 0xf4, 0x37, 0x91, 0x43, 0xfd, 0x51, 0x02, 0x73, 0xfe, 0x36, 0x9d, 0x02, 0x89, + 0xba, 0x1d, 0x26, 0x51, 0xcf, 0x67, 0x48, 0xce, 0x14, 0x16, 0xf5, 0x59, 0x21, 0xe8, 0x3a, 0xa7, + 0x51, 0xab, 0xec, 0x0a, 0x66, 0xa8, 0x4a, 0x1b, 0x5b, 0xa2, 0xdf, 0x9e, 0x75, 0xae, 0x5f, 0xce, + 0x18, 0xf2, 0xa4, 0x21, 0xc2, 0x95, 0xfb, 0x6a, 0x09, 0x57, 0xfe, 0xd9, 0x10, 0xae, 0x1f, 0x81, + 0x92, 0xe5, 0x52, 0xad, 0x02, 0x87, 0xbc, 0x92, 0xa9, 0xb0, 0x05, 0xcb, 0xf2, 0xa0, 0x3d, 0x7e, + 0xe5, 0xc1, 0x25, 0x31, 0xab, 0xe2, 0xd7, 0xc9, 0xac, 0x58, 0xa2, 0x1b, 0xd8, 0xb6, 0x48, 0x87, + 0x17, 0x55, 0xc9, 0x4f, 0xf4, 0x16, 0x1f, 0x45, 0x42, 0x0a, 0x0f, 0xc0, 0xb2, 0x61, 0xea, 0x5d, + 0x93, 0x58, 0xd6, 0x16, 0xc1, 0x1d, 0x55, 0xd1, 0x88, 0x1b, 0x80, 0xd3, 0x13, 0x2f, 0x8c, 0x86, + 0xb5, 0xe5, 0x56, 0xb2, 0x0a, 0x4a, 0xb3, 0x95, 0xff, 0x5c, 0x00, 0xe7, 0xa2, 0x67, 0x63, 0x0a, + 0x4d, 0x91, 0x4e, 0x44, 0x53, 0xae, 0x06, 0xf2, 0xd4, 0xe1, 0x70, 0x81, 0xa7, 0x82, 0x58, 0xae, + 0x6e, 0x80, 0x79, 0x41, 0x4b, 0x5c, 0xa1, 0x20, 0x6a, 0xde, 0xf6, 0x1c, 0x84, 0xc5, 0x28, 0xaa, + 0x0f, 0x6f, 0x82, 0x59, 0x93, 0x33, 0x2f, 0x17, 0xc0, 0x61, 0x2f, 0xff, 0x27, 0x00, 0x66, 0x51, + 0x50, 0x88, 0xc2, 0xba, 0x8c, 0xb9, 0xf8, 0x84, 0xc4, 0x05, 0x28, 0x84, 0x99, 0xcb, 0x46, 0x54, + 0x01, 0xc5, 0x6d, 0xe0, 0x0e, 0x58, 0xb0, 0xb5, 0x38, 0x94, 0x93, 0x6b, 0x17, 0x04, 0xd4, 0xc2, + 0x41, 0x5c, 0x05, 0x25, 0xd9, 0xc1, 0xfb, 0x21, 0x32, 0x33, 0xc5, 0xcf, 0x93, 0xab, 0x19, 0x6a, + 0x22, 0x33, 0x9b, 0x49, 0xa0, 0x5a, 0xa5, 0xac, 0x54, 0x4b, 0xfe, 0x48, 0x02, 0x30, 0x5e, 0x87, + 0x63, 0x5f, 0x02, 0x62, 0x16, 0x81, 0x8e, 0xa9, 0x24, 0xf3, 0x9f, 0x6b, 0x19, 0xf9, 0x8f, 0x7f, + 0xa0, 0x66, 0x23, 0x40, 0x62, 0xa1, 0x4f, 0xe7, 0x51, 0x27, 0x2b, 0x01, 0xf2, 0x9d, 0x7a, 0x06, + 0x04, 0x28, 0x00, 0xf6, 0x74, 0x02, 0xf4, 0x8f, 0x1c, 0x58, 0xf0, 0x95, 0x33, 0x13, 0xa0, 0x04, + 0x93, 0xef, 0x1e, 0x76, 0xb2, 0x91, 0x12, 0x7f, 0xe9, 0xfe, 0x97, 0x48, 0x89, 0xef, 0x55, 0x0a, + 0x29, 0xf9, 0x7d, 0x2e, 0xe8, 0xfa, 0x84, 0xa4, 0xe4, 0x19, 0xbc, 0x70, 0x7c, 0xe3, 0x78, 0x8d, + 0xfc, 0x49, 0x1e, 0x9c, 0x8b, 0xd6, 0x61, 0xa8, 0x41, 0x4a, 0x63, 0x1b, 0x64, 0x0b, 0x2c, 0x3e, + 0xb0, 0x55, 0x75, 0xc0, 0x63, 0x08, 0x74, 0x49, 0xa7, 0xb5, 0xfe, 0xbf, 0xb0, 0x5c, 0xfc, 0x61, + 0x82, 0x0e, 0x4a, 0xb4, 0x8c, 0xf7, 0xcb, 0xc2, 0x97, 0xed, 0x97, 0xc5, 0x13, 0xf4, 0xcb, 0x64, + 0xca, 0x91, 0x3f, 0x11, 0xe5, 0x98, 0xac, 0x59, 0x26, 0x1c, 0x5c, 0x63, 0xaf, 0xfe, 0x23, 0x09, + 0x2c, 0x25, 0x5f, 0xb8, 0xa1, 0x0a, 0xe6, 0x7a, 0xf8, 0x61, 0xf0, 0xe1, 0x63, 0x5c, 0x13, 0xb1, + 0xa9, 0xa2, 0xd6, 0x9d, 0x4f, 0x46, 0xf5, 0x3b, 0x1a, 0xdd, 0x33, 0xf7, 0xa9, 0xa9, 0x68, 0x5d, + 0xa7, 0xf3, 0xee, 0x84, 0xb0, 0x50, 0x04, 0x1b, 0xbe, 0x0f, 0x4a, 0x3d, 0xfc, 0x70, 0xdf, 0x36, + 0xbb, 0x49, 0x1d, 0x32, 0xdb, 0x3c, 0xbc, 0x00, 0x76, 0x04, 0x0a, 0xf2, 0xf0, 0xe4, 0x2f, 0x24, + 0xb0, 0x9c, 0xd2, 0x55, 0xbf, 0x45, 0x51, 0xee, 0x81, 0x8b, 0xa1, 0x20, 0x59, 0x55, 0x92, 0x07, + 0xb6, 0xca, 0x0b, 0x54, 0x10, 0x99, 0x2b, 0xa0, 0x6c, 0x60, 0x93, 0x2a, 0x1e, 0x0d, 0x2e, 0x36, + 0x67, 0x47, 0xc3, 0x5a, 0xb9, 0xe5, 0x0e, 0x22, 0x5f, 0x2e, 0xff, 0x47, 0x02, 0xc5, 0xfd, 0x36, + 0x56, 0xc9, 0x29, 0x30, 0x89, 0xad, 0x10, 0x93, 0x48, 0x7f, 0xa5, 0xe7, 0xfe, 0xa4, 0x92, 0x88, + 0xed, 0x08, 0x89, 0xb8, 0x34, 0x06, 0xe7, 0xe9, 0xfc, 0xe1, 0x0d, 0x50, 0xf6, 0xa6, 0x9b, 0xec, + 0x70, 0x93, 0x7f, 0x97, 0x03, 0x33, 0x81, 0x29, 0x26, 0x3c, 0x1a, 0xef, 0x87, 0xfa, 0x01, 0x2b, + 0xfa, 0xf5, 0x2c, 0x81, 0xd4, 0xdd, 0xb3, 0xff, 0x6d, 0x8d, 0x9a, 0xc1, 0xcb, 0x63, 0xbc, 0x25, + 0xbc, 0x09, 0xe6, 0x28, 0x36, 0xbb, 0x84, 0xba, 0x32, 0xbe, 0x60, 0x65, 0xff, 0x31, 0xe5, 0x6e, + 0x48, 0x8a, 0x22, 0xda, 0x2b, 0x37, 0xc1, 0x6c, 0x68, 0x32, 0x78, 0x0e, 0xe4, 0x8f, 0xc9, 0xc0, + 0xa1, 0x54, 0x88, 0xfd, 0x09, 0x17, 0x41, 0xb1, 0x8f, 0x55, 0xdb, 0xc9, 0xf3, 0x32, 0x72, 0x7e, + 0xdc, 0xc8, 0xbd, 0x2e, 0xc9, 0xbf, 0x66, 0x8b, 0xe3, 0x27, 0xe7, 0x29, 0x64, 0xd7, 0x3b, 0xa1, + 0xec, 0x4a, 0xff, 0x60, 0x18, 0x2c, 0x99, 0xb4, 0x1c, 0x43, 0x91, 0x1c, 0x7b, 0x29, 0x13, 0xda, + 0xd3, 0x33, 0xed, 0x9f, 0x39, 0xb0, 0x18, 0xd0, 0xf6, 0xa9, 0xea, 0xf7, 0x43, 0x54, 0x75, 0x35, + 0x42, 0x55, 0x2b, 0x49, 0x36, 0xdf, 0x71, 0xd5, 0xf1, 0x5c, 0xf5, 0x4f, 0x12, 0x98, 0x0f, 0xac, + 0xdd, 0x29, 0x90, 0xd5, 0x3b, 0x61, 0xb2, 0x7a, 0x29, 0x4b, 0xd2, 0xa4, 0xb0, 0xd5, 0x7f, 0x49, + 0xa0, 0x11, 0xd0, 0x6a, 0x11, 0xd3, 0x52, 0x2c, 0x4a, 0x34, 0x7a, 0x4f, 0x57, 0xed, 0x1e, 0xd9, + 0x54, 0xb1, 0xd2, 0x43, 0x84, 0x0d, 0x28, 0xba, 0xd6, 0xd2, 0x55, 0xa5, 0x3d, 0x80, 0x18, 0xcc, + 0x7c, 0x78, 0x44, 0xb4, 0x2d, 0xa2, 0x12, 0x2a, 0x3e, 0x6b, 0x95, 0x9b, 0x6f, 0xb9, 0x5f, 0x79, + 0xde, 0xf3, 0x45, 0x4f, 0x86, 0xb5, 0xd5, 0x2c, 0x88, 0x3c, 0xcb, 0x82, 0x98, 0xf0, 0xa7, 0x00, + 0xb0, 0x9f, 0xfc, 0x3c, 0xea, 0x88, 0x84, 0x7b, 0xd3, 0xad, 0xca, 0xf7, 0x3c, 0xc9, 0x44, 0x13, + 0x04, 0x10, 0xe5, 0xbf, 0x4e, 0x87, 0xf6, 0xec, 0x5b, 0xff, 0x74, 0xf8, 0x73, 0xb0, 0xd8, 0xf7, + 0x57, 0xc7, 0x55, 0x60, 0xa4, 0x36, 0x1f, 0xbd, 0x1e, 0x7b, 0xf0, 0x49, 0xeb, 0xea, 0x53, 0xe9, + 0x7b, 0x09, 0x70, 0x28, 0x71, 0x12, 0xf8, 0x2a, 0x98, 0x61, 0x64, 0x54, 0x69, 0x93, 0x5d, 0xdc, + 0x73, 0xeb, 0xc9, 0xfb, 0x2a, 0xb8, 0xef, 0x8b, 0x50, 0x50, 0x0f, 0x1e, 0x81, 0x05, 0x43, 0xef, + 0xec, 0x60, 0x0d, 0x77, 0x09, 0x63, 0x57, 0xce, 0x56, 0xf2, 0xf7, 0xc4, 0x72, 0xf3, 0x35, 0xf7, + 0xad, 0xa8, 0x15, 0x57, 0x61, 0xf7, 0xee, 0x84, 0x61, 0x9e, 0x04, 0x49, 0x90, 0xd0, 0x8c, 0x7d, + 0xc9, 0x76, 0x5e, 0xf2, 0xd7, 0xb3, 0x14, 0xd6, 0x09, 0xbf, 0x65, 0xa7, 0x3d, 0x97, 0x96, 0x4e, + 0xf4, 0x5c, 0x9a, 0x70, 0x6f, 0x2c, 0x4f, 0x78, 0x6f, 0xfc, 0x44, 0x02, 0x97, 0x8c, 0x0c, 0xb5, + 0x54, 0x01, 0x7c, 0x6d, 0x6e, 0x67, 0x59, 0x9b, 0x2c, 0xb5, 0xd9, 0x5c, 0x1d, 0x0d, 0x6b, 0x97, + 0xb2, 0x68, 0xa2, 0x4c, 0xfe, 0xc9, 0x1f, 0x15, 0xc1, 0xf9, 0x58, 0xb7, 0xfc, 0x1a, 0x1f, 0x6f, + 0x63, 0x37, 0xc9, 0xfc, 0x04, 0x37, 0xc9, 0x0d, 0x30, 0x2f, 0xfe, 0x1f, 0x20, 0x72, 0x11, 0xf5, + 0x36, 0x76, 0x33, 0x2c, 0x46, 0x51, 0xfd, 0xa4, 0xc7, 0xe3, 0xe2, 0x84, 0x8f, 0xc7, 0x41, 0x2f, + 0xc4, 0xff, 0xb7, 0x39, 0x65, 0x18, 0xf7, 0x42, 0xfc, 0x9b, 0x5b, 0x54, 0x9f, 0x91, 0x44, 0x07, + 0xd5, 0x43, 0x98, 0x0e, 0x93, 0xc4, 0x83, 0x90, 0x14, 0x45, 0xb4, 0xbf, 0xd4, 0x37, 0x6f, 0x9c, + 0xf0, 0xcd, 0x7b, 0x2d, 0x4b, 0xfe, 0x66, 0x7f, 0x27, 0x4e, 0xbc, 0xf1, 0xcf, 0x4c, 0x7e, 0xe3, + 0x97, 0xff, 0x22, 0x81, 0xe7, 0x52, 0x4f, 0x17, 0xb8, 0x11, 0xa2, 0x70, 0x6b, 0x11, 0x0a, 0xf7, + 0xbd, 0x54, 0xc3, 0x00, 0x8f, 0x33, 0x93, 0x9f, 0x90, 0xdf, 0xc8, 0xf6, 0x84, 0x9c, 0x70, 0x0f, + 0x1c, 0xff, 0x96, 0xdc, 0x5c, 0x7b, 0xf4, 0xb8, 0x7a, 0xe6, 0xd3, 0xc7, 0xd5, 0x33, 0x9f, 0x3f, + 0xae, 0x9e, 0xf9, 0xc5, 0xa8, 0x2a, 0x3d, 0x1a, 0x55, 0xa5, 0x4f, 0x47, 0x55, 0xe9, 0xf3, 0x51, + 0x55, 0xfa, 0xdb, 0xa8, 0x2a, 0xfd, 0xe6, 0x8b, 0xea, 0x99, 0xf7, 0xa7, 0xc5, 0x8c, 0xff, 0x0d, + 0x00, 0x00, 0xff, 0xff, 0x3e, 0x13, 0x3b, 0xc7, 0x94, 0x2b, 0x00, 0x00, } func (m *ControllerRevision) Marshal() (dAtA []byte, err error) { @@ -2523,6 +2560,39 @@ func (m *StatefulSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.WhenScaled) + copy(dAtA[i:], m.WhenScaled) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenScaled))) + i-- + dAtA[i] = 0x12 + i -= len(m.WhenDeleted) + copy(dAtA[i:], m.WhenDeleted) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenDeleted))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *StatefulSetSpec) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2543,6 +2613,18 @@ func (m *StatefulSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.PersistentVolumeClaimRetentionPolicy != nil { + { + size, err := m.PersistentVolumeClaimRetentionPolicy.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) i-- dAtA[i] = 0x48 @@ -3232,6 +3314,19 @@ func (m *StatefulSetList) Size() (n int) { return n } +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.WhenDeleted) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.WhenScaled) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *StatefulSetSpec) Size() (n int) { if m == nil { return 0 @@ -3263,6 +3358,10 @@ func (m *StatefulSetSpec) Size() (n int) { n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) } n += 1 + sovGenerated(uint64(m.MinReadySeconds)) + if m.PersistentVolumeClaimRetentionPolicy != nil { + l = m.PersistentVolumeClaimRetentionPolicy.Size() + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -3720,6 +3819,17 @@ func (this *StatefulSetList) String() string { }, "") return s } +func (this *StatefulSetPersistentVolumeClaimRetentionPolicy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StatefulSetPersistentVolumeClaimRetentionPolicy{`, + `WhenDeleted:` + fmt.Sprintf("%v", this.WhenDeleted) + `,`, + `WhenScaled:` + fmt.Sprintf("%v", this.WhenScaled) + `,`, + `}`, + }, "") + return s +} func (this *StatefulSetSpec) String() string { if this == nil { return "nil" @@ -3739,6 +3849,7 @@ func (this *StatefulSetSpec) String() string { `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "StatefulSetUpdateStrategy", "StatefulSetUpdateStrategy", 1), `&`, ``, 1) + `,`, `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, + `PersistentVolumeClaimRetentionPolicy:` + strings.Replace(this.PersistentVolumeClaimRetentionPolicy.String(), "StatefulSetPersistentVolumeClaimRetentionPolicy", "StatefulSetPersistentVolumeClaimRetentionPolicy", 1) + `,`, `}`, }, "") return s @@ -8228,6 +8339,120 @@ func (m *StatefulSetList) Unmarshal(dAtA []byte) error { } return nil } +func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WhenDeleted", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WhenDeleted = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WhenScaled", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WhenScaled = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -8516,6 +8741,42 @@ func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error { break } } + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeClaimRetentionPolicy", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PersistentVolumeClaimRetentionPolicy == nil { + m.PersistentVolumeClaimRetentionPolicy = &StatefulSetPersistentVolumeClaimRetentionPolicy{} + } + if err := m.PersistentVolumeClaimRetentionPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/vendor/k8s.io/api/apps/v1beta2/generated.proto b/vendor/k8s.io/api/apps/v1beta2/generated.proto index fb3f05ea29..6d9505865a 100644 --- a/vendor/k8s.io/api/apps/v1beta2/generated.proto +++ b/vendor/k8s.io/api/apps/v1beta2/generated.proto @@ -169,8 +169,8 @@ message DaemonSetStatus { // More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ optional int32 desiredNumberScheduled = 3; - // The number of nodes that should be running the daemon pod and have one - // or more of the daemon pod running and ready. + // Total number of nodes that should be running the daemon pod and have one + // or more of the daemon pod running with a Ready Condition by passing the readinessProbe. optional int32 numberReady = 4; // The most recent generation observed by the daemon set controller. @@ -327,7 +327,7 @@ message DeploymentStatus { // +optional optional int32 updatedReplicas = 3; - // Total number of ready pods targeted by this deployment. + // readyReplicas is the number of pods targeted by this Deployment controller with a Ready Condition. // +optional optional int32 readyReplicas = 7; @@ -463,7 +463,7 @@ message ReplicaSetStatus { // +optional optional int32 fullyLabeledReplicas = 2; - // The number of ready replicas for this replica set. + // readyReplicas is the number of pods targeted by this ReplicaSet controller with a Ready Condition. // +optional optional int32 readyReplicas = 4; @@ -656,6 +656,23 @@ message StatefulSetList { repeated StatefulSet items = 2; } +// StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs +// created from the StatefulSet VolumeClaimTemplates. +message StatefulSetPersistentVolumeClaimRetentionPolicy { + // WhenDeleted specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is deleted. The default policy + // of `Retain` causes PVCs to not be affected by StatefulSet deletion. The + // `Delete` policy causes those PVCs to be deleted. + optional string whenDeleted = 1; + + // WhenScaled specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is scaled down. The default + // policy of `Retain` causes PVCs to not be affected by a scaledown. The + // `Delete` policy causes the associated PVCs for any excess pods above + // the replica count to be deleted. + optional string whenScaled = 2; +} + // A StatefulSetSpec is the specification of a StatefulSet. message StatefulSetSpec { // replicas is the desired number of replicas of the given Template. @@ -722,6 +739,12 @@ message StatefulSetSpec { // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. // +optional optional int32 minReadySeconds = 9; + + // PersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from + // the StatefulSet VolumeClaimTemplates. This requires the + // StatefulSetAutoDeletePVC feature gate to be enabled, which is alpha. + // +optional + optional StatefulSetPersistentVolumeClaimRetentionPolicy persistentVolumeClaimRetentionPolicy = 10; } // StatefulSetStatus represents the current state of a StatefulSet. @@ -734,7 +757,7 @@ message StatefulSetStatus { // replicas is the number of Pods created by the StatefulSet controller. optional int32 replicas = 2; - // readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. + // readyReplicas is the number of pods created by this StatefulSet controller with a Ready Condition. optional int32 readyReplicas = 3; // currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version @@ -766,9 +789,7 @@ message StatefulSetStatus { repeated StatefulSetCondition conditions = 10; // Total number of available pods (ready for at least minReadySeconds) targeted by this StatefulSet. - // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. - // Remove omitempty when graduating to beta - // +optional + // This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate. optional int32 availableReplicas = 11; } diff --git a/vendor/k8s.io/api/apps/v1beta2/types.go b/vendor/k8s.io/api/apps/v1beta2/types.go index 67e10b9714..332bc7ed82 100644 --- a/vendor/k8s.io/api/apps/v1beta2/types.go +++ b/vendor/k8s.io/api/apps/v1beta2/types.go @@ -169,6 +169,40 @@ type RollingUpdateStatefulSetStrategy struct { Partition *int32 `json:"partition,omitempty" protobuf:"varint,1,opt,name=partition"` } +// PersistentVolumeClaimRetentionPolicyType is a string enumeration of the policies that will determine +// when volumes from the VolumeClaimTemplates will be deleted when the controlling StatefulSet is +// deleted or scaled down. +type PersistentVolumeClaimRetentionPolicyType string + +const ( + // RetainPersistentVolumeClaimRetentionPolicyType is the default + // PersistentVolumeClaimRetentionPolicy and specifies that + // PersistentVolumeClaims associated with StatefulSet VolumeClaimTemplates + // will not be deleted. + RetainPersistentVolumeClaimRetentionPolicyType PersistentVolumeClaimRetentionPolicyType = "Retain" + // RetentionPersistentVolumeClaimRetentionPolicyType specifies that + // PersistentVolumeClaims associated with StatefulSet VolumeClaimTemplates + // will be deleted in the scenario specified in + // StatefulSetPersistentVolumeClaimRetentionPolicy. + RetentionPersistentVolumeClaimRetentionPolicyType PersistentVolumeClaimRetentionPolicyType = "Delete" +) + +// StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs +// created from the StatefulSet VolumeClaimTemplates. +type StatefulSetPersistentVolumeClaimRetentionPolicy struct { + // WhenDeleted specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is deleted. The default policy + // of `Retain` causes PVCs to not be affected by StatefulSet deletion. The + // `Delete` policy causes those PVCs to be deleted. + WhenDeleted PersistentVolumeClaimRetentionPolicyType `json:"whenDeleted,omitempty" protobuf:"bytes,1,opt,name=whenDeleted,casttype=PersistentVolumeClaimRetentionPolicyType"` + // WhenScaled specifies what happens to PVCs created from StatefulSet + // VolumeClaimTemplates when the StatefulSet is scaled down. The default + // policy of `Retain` causes PVCs to not be affected by a scaledown. The + // `Delete` policy causes the associated PVCs for any excess pods above + // the replica count to be deleted. + WhenScaled PersistentVolumeClaimRetentionPolicyType `json:"whenScaled,omitempty" protobuf:"bytes,2,opt,name=whenScaled,casttype=PersistentVolumeClaimRetentionPolicyType"` +} + // A StatefulSetSpec is the specification of a StatefulSet. type StatefulSetSpec struct { // replicas is the desired number of replicas of the given Template. @@ -235,6 +269,12 @@ type StatefulSetSpec struct { // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. // +optional MinReadySeconds int32 `json:"minReadySeconds,omitempty" protobuf:"varint,9,opt,name=minReadySeconds"` + + // PersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from + // the StatefulSet VolumeClaimTemplates. This requires the + // StatefulSetAutoDeletePVC feature gate to be enabled, which is alpha. + // +optional + PersistentVolumeClaimRetentionPolicy *StatefulSetPersistentVolumeClaimRetentionPolicy `json:"persistentVolumeClaimRetentionPolicy,omitempty" protobuf:"bytes,10,opt,name=persistentVolumeClaimRetentionPolicy"` } // StatefulSetStatus represents the current state of a StatefulSet. @@ -247,7 +287,7 @@ type StatefulSetStatus struct { // replicas is the number of Pods created by the StatefulSet controller. Replicas int32 `json:"replicas" protobuf:"varint,2,opt,name=replicas"` - // readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. + // readyReplicas is the number of pods created by this StatefulSet controller with a Ready Condition. ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,3,opt,name=readyReplicas"` // currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version @@ -279,10 +319,8 @@ type StatefulSetStatus struct { Conditions []StatefulSetCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,10,rep,name=conditions"` // Total number of available pods (ready for at least minReadySeconds) targeted by this StatefulSet. - // This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. - // Remove omitempty when graduating to beta - // +optional - AvailableReplicas int32 `json:"availableReplicas,omitempty" protobuf:"varint,11,opt,name=availableReplicas"` + // This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate. + AvailableReplicas int32 `json:"availableReplicas" protobuf:"varint,11,opt,name=availableReplicas"` } type StatefulSetConditionType string @@ -463,7 +501,7 @@ type DeploymentStatus struct { // +optional UpdatedReplicas int32 `json:"updatedReplicas,omitempty" protobuf:"varint,3,opt,name=updatedReplicas"` - // Total number of ready pods targeted by this deployment. + // readyReplicas is the number of pods targeted by this Deployment controller with a Ready Condition. // +optional ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,7,opt,name=readyReplicas"` @@ -656,8 +694,8 @@ type DaemonSetStatus struct { // More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ DesiredNumberScheduled int32 `json:"desiredNumberScheduled" protobuf:"varint,3,opt,name=desiredNumberScheduled"` - // The number of nodes that should be running the daemon pod and have one - // or more of the daemon pod running and ready. + // Total number of nodes that should be running the daemon pod and have one + // or more of the daemon pod running with a Ready Condition by passing the readinessProbe. NumberReady int32 `json:"numberReady" protobuf:"varint,4,opt,name=numberReady"` // The most recent generation observed by the daemon set controller. @@ -860,7 +898,7 @@ type ReplicaSetStatus struct { // +optional FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty" protobuf:"varint,2,opt,name=fullyLabeledReplicas"` - // The number of ready replicas for this replica set. + // readyReplicas is the number of pods targeted by this ReplicaSet controller with a Ready Condition. // +optional ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,4,opt,name=readyReplicas"` diff --git a/vendor/k8s.io/api/apps/v1beta2/types_swagger_doc_generated.go b/vendor/k8s.io/api/apps/v1beta2/types_swagger_doc_generated.go index 1f9912203d..454c632dc2 100644 --- a/vendor/k8s.io/api/apps/v1beta2/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/apps/v1beta2/types_swagger_doc_generated.go @@ -100,7 +100,7 @@ var map_DaemonSetStatus = map[string]string{ "currentNumberScheduled": "The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", "numberMisscheduled": "The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", "desiredNumberScheduled": "The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/", - "numberReady": "The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready.", + "numberReady": "Total number of nodes that should be running the daemon pod and have one or more of the daemon pod running with a Ready Condition by passing the readinessProbe.", "observedGeneration": "The most recent generation observed by the daemon set controller.", "updatedNumberScheduled": "The total number of nodes that are running updated daemon pod", "numberAvailable": "The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds)", @@ -179,7 +179,7 @@ var map_DeploymentStatus = map[string]string{ "observedGeneration": "The generation observed by the deployment controller.", "replicas": "Total number of non-terminated pods targeted by this deployment (their labels match the selector).", "updatedReplicas": "Total number of non-terminated pods targeted by this deployment that have the desired template spec.", - "readyReplicas": "Total number of ready pods targeted by this deployment.", + "readyReplicas": "readyReplicas is the number of pods targeted by this Deployment controller with a Ready Condition.", "availableReplicas": "Total number of available pods (ready for at least minReadySeconds) targeted by this deployment.", "unavailableReplicas": "Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created.", "conditions": "Represents the latest available observations of a deployment's current state.", @@ -250,7 +250,7 @@ var map_ReplicaSetStatus = map[string]string{ "": "ReplicaSetStatus represents the current status of a ReplicaSet.", "replicas": "Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller", "fullyLabeledReplicas": "The number of pods that have labels matching the labels of the pod template of the replicaset.", - "readyReplicas": "The number of ready replicas for this replica set.", + "readyReplicas": "readyReplicas is the number of pods targeted by this ReplicaSet controller with a Ready Condition.", "availableReplicas": "The number of available replicas (ready for at least minReadySeconds) for this replica set.", "observedGeneration": "ObservedGeneration reflects the generation of the most recently observed ReplicaSet.", "conditions": "Represents the latest available observations of a replica set's current state.", @@ -351,17 +351,28 @@ func (StatefulSetList) SwaggerDoc() map[string]string { return map_StatefulSetList } +var map_StatefulSetPersistentVolumeClaimRetentionPolicy = map[string]string{ + "": "StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates.", + "whenDeleted": "WhenDeleted specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is deleted. The default policy of `Retain` causes PVCs to not be affected by StatefulSet deletion. The `Delete` policy causes those PVCs to be deleted.", + "whenScaled": "WhenScaled specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is scaled down. The default policy of `Retain` causes PVCs to not be affected by a scaledown. The `Delete` policy causes the associated PVCs for any excess pods above the replica count to be deleted.", +} + +func (StatefulSetPersistentVolumeClaimRetentionPolicy) SwaggerDoc() map[string]string { + return map_StatefulSetPersistentVolumeClaimRetentionPolicy +} + var map_StatefulSetSpec = map[string]string{ - "": "A StatefulSetSpec is the specification of a StatefulSet.", - "replicas": "replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.", - "selector": "selector is a label query over pods that should match the replica count. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors", - "template": "template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet.", - "volumeClaimTemplates": "volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.", - "serviceName": "serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller.", - "podManagementPolicy": "podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once.", - "updateStrategy": "updateStrategy indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template.", - "revisionHistoryLimit": "revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10.", - "minReadySeconds": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate.", + "": "A StatefulSetSpec is the specification of a StatefulSet.", + "replicas": "replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1.", + "selector": "selector is a label query over pods that should match the replica count. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors", + "template": "template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet.", + "volumeClaimTemplates": "volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name.", + "serviceName": "serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller.", + "podManagementPolicy": "podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once.", + "updateStrategy": "updateStrategy indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template.", + "revisionHistoryLimit": "revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10.", + "minReadySeconds": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate.", + "persistentVolumeClaimRetentionPolicy": "PersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates. This requires the StatefulSetAutoDeletePVC feature gate to be enabled, which is alpha.", } func (StatefulSetSpec) SwaggerDoc() map[string]string { @@ -372,14 +383,14 @@ var map_StatefulSetStatus = map[string]string{ "": "StatefulSetStatus represents the current state of a StatefulSet.", "observedGeneration": "observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server.", "replicas": "replicas is the number of Pods created by the StatefulSet controller.", - "readyReplicas": "readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition.", + "readyReplicas": "readyReplicas is the number of pods created by this StatefulSet controller with a Ready Condition.", "currentReplicas": "currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision.", "updatedReplicas": "updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision.", "currentRevision": "currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas).", "updateRevision": "updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas)", "collisionCount": "collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.", "conditions": "Represents the latest available observations of a statefulset's current state.", - "availableReplicas": "Total number of available pods (ready for at least minReadySeconds) targeted by this StatefulSet. This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. Remove omitempty when graduating to beta", + "availableReplicas": "Total number of available pods (ready for at least minReadySeconds) targeted by this StatefulSet. This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate.", } func (StatefulSetStatus) SwaggerDoc() map[string]string { diff --git a/vendor/k8s.io/api/apps/v1beta2/zz_generated.deepcopy.go b/vendor/k8s.io/api/apps/v1beta2/zz_generated.deepcopy.go index 0a84d1b08a..8293b9886b 100644 --- a/vendor/k8s.io/api/apps/v1beta2/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/apps/v1beta2/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -754,6 +755,22 @@ func (in *StatefulSetList) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *StatefulSetPersistentVolumeClaimRetentionPolicy) DeepCopyInto(out *StatefulSetPersistentVolumeClaimRetentionPolicy) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetPersistentVolumeClaimRetentionPolicy. +func (in *StatefulSetPersistentVolumeClaimRetentionPolicy) DeepCopy() *StatefulSetPersistentVolumeClaimRetentionPolicy { + if in == nil { + return nil + } + out := new(StatefulSetPersistentVolumeClaimRetentionPolicy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *StatefulSetSpec) DeepCopyInto(out *StatefulSetSpec) { *out = *in @@ -781,6 +798,11 @@ func (in *StatefulSetSpec) DeepCopyInto(out *StatefulSetSpec) { *out = new(int32) **out = **in } + if in.PersistentVolumeClaimRetentionPolicy != nil { + in, out := &in.PersistentVolumeClaimRetentionPolicy, &out.PersistentVolumeClaimRetentionPolicy + *out = new(StatefulSetPersistentVolumeClaimRetentionPolicy) + **out = **in + } return } diff --git a/vendor/k8s.io/api/apps/v1beta2/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/apps/v1beta2/zz_generated.prerelease-lifecycle.go index 3368a18964..1ead8a4c13 100644 --- a/vendor/k8s.io/api/apps/v1beta2/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/apps/v1beta2/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/authentication/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/authentication/v1/zz_generated.deepcopy.go index aca99c42b7..2af533191b 100644 --- a/vendor/k8s.io/api/authentication/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/authentication/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/authentication/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/authentication/v1beta1/zz_generated.deepcopy.go index a5d82a8100..059ec1a864 100644 --- a/vendor/k8s.io/api/authentication/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/authentication/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/authentication/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/authentication/v1beta1/zz_generated.prerelease-lifecycle.go index 9b5744db78..e448106e41 100644 --- a/vendor/k8s.io/api/authentication/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/authentication/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/authorization/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/authorization/v1/zz_generated.deepcopy.go index 1d11b38b08..f1d49eb386 100644 --- a/vendor/k8s.io/api/authorization/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/authorization/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/authorization/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/authorization/v1beta1/zz_generated.deepcopy.go index 58b2dfe753..13f09cf2d2 100644 --- a/vendor/k8s.io/api/authorization/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/authorization/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/authorization/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/authorization/v1beta1/zz_generated.prerelease-lifecycle.go index fcb75dd914..f9817df583 100644 --- a/vendor/k8s.io/api/authorization/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/authorization/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/autoscaling/v1/types.go b/vendor/k8s.io/api/autoscaling/v1/types.go index 93b1efb51c..8e0a46525e 100644 --- a/vendor/k8s.io/api/autoscaling/v1/types.go +++ b/vendor/k8s.io/api/autoscaling/v1/types.go @@ -150,6 +150,7 @@ type ScaleStatus struct { // the types below are used in the alpha metrics annotation // MetricSourceType indicates the type of metric. +// +enum type MetricSourceType string const ( diff --git a/vendor/k8s.io/api/autoscaling/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/autoscaling/v1/zz_generated.deepcopy.go index 05ae6ebda7..603e6aa8cb 100644 --- a/vendor/k8s.io/api/autoscaling/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/autoscaling/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/autoscaling/v2/doc.go b/vendor/k8s.io/api/autoscaling/v2/doc.go new file mode 100644 index 0000000000..f96a059b6c --- /dev/null +++ b/vendor/k8s.io/api/autoscaling/v2/doc.go @@ -0,0 +1,21 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// +k8s:deepcopy-gen=package +// +k8s:protobuf-gen=package +// +k8s:openapi-gen=true + +package v2 // import "k8s.io/api/autoscaling/v2" diff --git a/vendor/k8s.io/api/autoscaling/v2/generated.pb.go b/vendor/k8s.io/api/autoscaling/v2/generated.pb.go new file mode 100644 index 0000000000..408413a78c --- /dev/null +++ b/vendor/k8s.io/api/autoscaling/v2/generated.pb.go @@ -0,0 +1,6599 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: k8s.io/kubernetes/vendor/k8s.io/api/autoscaling/v2/generated.proto + +package v2 + +import ( + fmt "fmt" + + io "io" + + proto "github.com/gogo/protobuf/proto" + + k8s_io_api_core_v1 "k8s.io/api/core/v1" + resource "k8s.io/apimachinery/pkg/api/resource" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + math "math" + math_bits "math/bits" + reflect "reflect" + strings "strings" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +func (m *ContainerResourceMetricSource) Reset() { *m = ContainerResourceMetricSource{} } +func (*ContainerResourceMetricSource) ProtoMessage() {} +func (*ContainerResourceMetricSource) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{0} +} +func (m *ContainerResourceMetricSource) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ContainerResourceMetricSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ContainerResourceMetricSource) XXX_Merge(src proto.Message) { + xxx_messageInfo_ContainerResourceMetricSource.Merge(m, src) +} +func (m *ContainerResourceMetricSource) XXX_Size() int { + return m.Size() +} +func (m *ContainerResourceMetricSource) XXX_DiscardUnknown() { + xxx_messageInfo_ContainerResourceMetricSource.DiscardUnknown(m) +} + +var xxx_messageInfo_ContainerResourceMetricSource proto.InternalMessageInfo + +func (m *ContainerResourceMetricStatus) Reset() { *m = ContainerResourceMetricStatus{} } +func (*ContainerResourceMetricStatus) ProtoMessage() {} +func (*ContainerResourceMetricStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{1} +} +func (m *ContainerResourceMetricStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ContainerResourceMetricStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ContainerResourceMetricStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ContainerResourceMetricStatus.Merge(m, src) +} +func (m *ContainerResourceMetricStatus) XXX_Size() int { + return m.Size() +} +func (m *ContainerResourceMetricStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ContainerResourceMetricStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ContainerResourceMetricStatus proto.InternalMessageInfo + +func (m *CrossVersionObjectReference) Reset() { *m = CrossVersionObjectReference{} } +func (*CrossVersionObjectReference) ProtoMessage() {} +func (*CrossVersionObjectReference) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{2} +} +func (m *CrossVersionObjectReference) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CrossVersionObjectReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *CrossVersionObjectReference) XXX_Merge(src proto.Message) { + xxx_messageInfo_CrossVersionObjectReference.Merge(m, src) +} +func (m *CrossVersionObjectReference) XXX_Size() int { + return m.Size() +} +func (m *CrossVersionObjectReference) XXX_DiscardUnknown() { + xxx_messageInfo_CrossVersionObjectReference.DiscardUnknown(m) +} + +var xxx_messageInfo_CrossVersionObjectReference proto.InternalMessageInfo + +func (m *ExternalMetricSource) Reset() { *m = ExternalMetricSource{} } +func (*ExternalMetricSource) ProtoMessage() {} +func (*ExternalMetricSource) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{3} +} +func (m *ExternalMetricSource) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExternalMetricSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ExternalMetricSource) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExternalMetricSource.Merge(m, src) +} +func (m *ExternalMetricSource) XXX_Size() int { + return m.Size() +} +func (m *ExternalMetricSource) XXX_DiscardUnknown() { + xxx_messageInfo_ExternalMetricSource.DiscardUnknown(m) +} + +var xxx_messageInfo_ExternalMetricSource proto.InternalMessageInfo + +func (m *ExternalMetricStatus) Reset() { *m = ExternalMetricStatus{} } +func (*ExternalMetricStatus) ProtoMessage() {} +func (*ExternalMetricStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{4} +} +func (m *ExternalMetricStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExternalMetricStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ExternalMetricStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExternalMetricStatus.Merge(m, src) +} +func (m *ExternalMetricStatus) XXX_Size() int { + return m.Size() +} +func (m *ExternalMetricStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ExternalMetricStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ExternalMetricStatus proto.InternalMessageInfo + +func (m *HPAScalingPolicy) Reset() { *m = HPAScalingPolicy{} } +func (*HPAScalingPolicy) ProtoMessage() {} +func (*HPAScalingPolicy) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{5} +} +func (m *HPAScalingPolicy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HPAScalingPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *HPAScalingPolicy) XXX_Merge(src proto.Message) { + xxx_messageInfo_HPAScalingPolicy.Merge(m, src) +} +func (m *HPAScalingPolicy) XXX_Size() int { + return m.Size() +} +func (m *HPAScalingPolicy) XXX_DiscardUnknown() { + xxx_messageInfo_HPAScalingPolicy.DiscardUnknown(m) +} + +var xxx_messageInfo_HPAScalingPolicy proto.InternalMessageInfo + +func (m *HPAScalingRules) Reset() { *m = HPAScalingRules{} } +func (*HPAScalingRules) ProtoMessage() {} +func (*HPAScalingRules) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{6} +} +func (m *HPAScalingRules) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HPAScalingRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *HPAScalingRules) XXX_Merge(src proto.Message) { + xxx_messageInfo_HPAScalingRules.Merge(m, src) +} +func (m *HPAScalingRules) XXX_Size() int { + return m.Size() +} +func (m *HPAScalingRules) XXX_DiscardUnknown() { + xxx_messageInfo_HPAScalingRules.DiscardUnknown(m) +} + +var xxx_messageInfo_HPAScalingRules proto.InternalMessageInfo + +func (m *HorizontalPodAutoscaler) Reset() { *m = HorizontalPodAutoscaler{} } +func (*HorizontalPodAutoscaler) ProtoMessage() {} +func (*HorizontalPodAutoscaler) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{7} +} +func (m *HorizontalPodAutoscaler) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HorizontalPodAutoscaler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *HorizontalPodAutoscaler) XXX_Merge(src proto.Message) { + xxx_messageInfo_HorizontalPodAutoscaler.Merge(m, src) +} +func (m *HorizontalPodAutoscaler) XXX_Size() int { + return m.Size() +} +func (m *HorizontalPodAutoscaler) XXX_DiscardUnknown() { + xxx_messageInfo_HorizontalPodAutoscaler.DiscardUnknown(m) +} + +var xxx_messageInfo_HorizontalPodAutoscaler proto.InternalMessageInfo + +func (m *HorizontalPodAutoscalerBehavior) Reset() { *m = HorizontalPodAutoscalerBehavior{} } +func (*HorizontalPodAutoscalerBehavior) ProtoMessage() {} +func (*HorizontalPodAutoscalerBehavior) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{8} +} +func (m *HorizontalPodAutoscalerBehavior) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HorizontalPodAutoscalerBehavior) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *HorizontalPodAutoscalerBehavior) XXX_Merge(src proto.Message) { + xxx_messageInfo_HorizontalPodAutoscalerBehavior.Merge(m, src) +} +func (m *HorizontalPodAutoscalerBehavior) XXX_Size() int { + return m.Size() +} +func (m *HorizontalPodAutoscalerBehavior) XXX_DiscardUnknown() { + xxx_messageInfo_HorizontalPodAutoscalerBehavior.DiscardUnknown(m) +} + +var xxx_messageInfo_HorizontalPodAutoscalerBehavior proto.InternalMessageInfo + +func (m *HorizontalPodAutoscalerCondition) Reset() { *m = HorizontalPodAutoscalerCondition{} } +func (*HorizontalPodAutoscalerCondition) ProtoMessage() {} +func (*HorizontalPodAutoscalerCondition) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{9} +} +func (m *HorizontalPodAutoscalerCondition) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HorizontalPodAutoscalerCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *HorizontalPodAutoscalerCondition) XXX_Merge(src proto.Message) { + xxx_messageInfo_HorizontalPodAutoscalerCondition.Merge(m, src) +} +func (m *HorizontalPodAutoscalerCondition) XXX_Size() int { + return m.Size() +} +func (m *HorizontalPodAutoscalerCondition) XXX_DiscardUnknown() { + xxx_messageInfo_HorizontalPodAutoscalerCondition.DiscardUnknown(m) +} + +var xxx_messageInfo_HorizontalPodAutoscalerCondition proto.InternalMessageInfo + +func (m *HorizontalPodAutoscalerList) Reset() { *m = HorizontalPodAutoscalerList{} } +func (*HorizontalPodAutoscalerList) ProtoMessage() {} +func (*HorizontalPodAutoscalerList) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{10} +} +func (m *HorizontalPodAutoscalerList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HorizontalPodAutoscalerList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *HorizontalPodAutoscalerList) XXX_Merge(src proto.Message) { + xxx_messageInfo_HorizontalPodAutoscalerList.Merge(m, src) +} +func (m *HorizontalPodAutoscalerList) XXX_Size() int { + return m.Size() +} +func (m *HorizontalPodAutoscalerList) XXX_DiscardUnknown() { + xxx_messageInfo_HorizontalPodAutoscalerList.DiscardUnknown(m) +} + +var xxx_messageInfo_HorizontalPodAutoscalerList proto.InternalMessageInfo + +func (m *HorizontalPodAutoscalerSpec) Reset() { *m = HorizontalPodAutoscalerSpec{} } +func (*HorizontalPodAutoscalerSpec) ProtoMessage() {} +func (*HorizontalPodAutoscalerSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{11} +} +func (m *HorizontalPodAutoscalerSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HorizontalPodAutoscalerSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *HorizontalPodAutoscalerSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_HorizontalPodAutoscalerSpec.Merge(m, src) +} +func (m *HorizontalPodAutoscalerSpec) XXX_Size() int { + return m.Size() +} +func (m *HorizontalPodAutoscalerSpec) XXX_DiscardUnknown() { + xxx_messageInfo_HorizontalPodAutoscalerSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_HorizontalPodAutoscalerSpec proto.InternalMessageInfo + +func (m *HorizontalPodAutoscalerStatus) Reset() { *m = HorizontalPodAutoscalerStatus{} } +func (*HorizontalPodAutoscalerStatus) ProtoMessage() {} +func (*HorizontalPodAutoscalerStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{12} +} +func (m *HorizontalPodAutoscalerStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HorizontalPodAutoscalerStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *HorizontalPodAutoscalerStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_HorizontalPodAutoscalerStatus.Merge(m, src) +} +func (m *HorizontalPodAutoscalerStatus) XXX_Size() int { + return m.Size() +} +func (m *HorizontalPodAutoscalerStatus) XXX_DiscardUnknown() { + xxx_messageInfo_HorizontalPodAutoscalerStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_HorizontalPodAutoscalerStatus proto.InternalMessageInfo + +func (m *MetricIdentifier) Reset() { *m = MetricIdentifier{} } +func (*MetricIdentifier) ProtoMessage() {} +func (*MetricIdentifier) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{13} +} +func (m *MetricIdentifier) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MetricIdentifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *MetricIdentifier) XXX_Merge(src proto.Message) { + xxx_messageInfo_MetricIdentifier.Merge(m, src) +} +func (m *MetricIdentifier) XXX_Size() int { + return m.Size() +} +func (m *MetricIdentifier) XXX_DiscardUnknown() { + xxx_messageInfo_MetricIdentifier.DiscardUnknown(m) +} + +var xxx_messageInfo_MetricIdentifier proto.InternalMessageInfo + +func (m *MetricSpec) Reset() { *m = MetricSpec{} } +func (*MetricSpec) ProtoMessage() {} +func (*MetricSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{14} +} +func (m *MetricSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MetricSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *MetricSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_MetricSpec.Merge(m, src) +} +func (m *MetricSpec) XXX_Size() int { + return m.Size() +} +func (m *MetricSpec) XXX_DiscardUnknown() { + xxx_messageInfo_MetricSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_MetricSpec proto.InternalMessageInfo + +func (m *MetricStatus) Reset() { *m = MetricStatus{} } +func (*MetricStatus) ProtoMessage() {} +func (*MetricStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{15} +} +func (m *MetricStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MetricStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *MetricStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_MetricStatus.Merge(m, src) +} +func (m *MetricStatus) XXX_Size() int { + return m.Size() +} +func (m *MetricStatus) XXX_DiscardUnknown() { + xxx_messageInfo_MetricStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_MetricStatus proto.InternalMessageInfo + +func (m *MetricTarget) Reset() { *m = MetricTarget{} } +func (*MetricTarget) ProtoMessage() {} +func (*MetricTarget) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{16} +} +func (m *MetricTarget) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MetricTarget) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *MetricTarget) XXX_Merge(src proto.Message) { + xxx_messageInfo_MetricTarget.Merge(m, src) +} +func (m *MetricTarget) XXX_Size() int { + return m.Size() +} +func (m *MetricTarget) XXX_DiscardUnknown() { + xxx_messageInfo_MetricTarget.DiscardUnknown(m) +} + +var xxx_messageInfo_MetricTarget proto.InternalMessageInfo + +func (m *MetricValueStatus) Reset() { *m = MetricValueStatus{} } +func (*MetricValueStatus) ProtoMessage() {} +func (*MetricValueStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{17} +} +func (m *MetricValueStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MetricValueStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *MetricValueStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_MetricValueStatus.Merge(m, src) +} +func (m *MetricValueStatus) XXX_Size() int { + return m.Size() +} +func (m *MetricValueStatus) XXX_DiscardUnknown() { + xxx_messageInfo_MetricValueStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_MetricValueStatus proto.InternalMessageInfo + +func (m *ObjectMetricSource) Reset() { *m = ObjectMetricSource{} } +func (*ObjectMetricSource) ProtoMessage() {} +func (*ObjectMetricSource) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{18} +} +func (m *ObjectMetricSource) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ObjectMetricSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ObjectMetricSource) XXX_Merge(src proto.Message) { + xxx_messageInfo_ObjectMetricSource.Merge(m, src) +} +func (m *ObjectMetricSource) XXX_Size() int { + return m.Size() +} +func (m *ObjectMetricSource) XXX_DiscardUnknown() { + xxx_messageInfo_ObjectMetricSource.DiscardUnknown(m) +} + +var xxx_messageInfo_ObjectMetricSource proto.InternalMessageInfo + +func (m *ObjectMetricStatus) Reset() { *m = ObjectMetricStatus{} } +func (*ObjectMetricStatus) ProtoMessage() {} +func (*ObjectMetricStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{19} +} +func (m *ObjectMetricStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ObjectMetricStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ObjectMetricStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ObjectMetricStatus.Merge(m, src) +} +func (m *ObjectMetricStatus) XXX_Size() int { + return m.Size() +} +func (m *ObjectMetricStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ObjectMetricStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ObjectMetricStatus proto.InternalMessageInfo + +func (m *PodsMetricSource) Reset() { *m = PodsMetricSource{} } +func (*PodsMetricSource) ProtoMessage() {} +func (*PodsMetricSource) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{20} +} +func (m *PodsMetricSource) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PodsMetricSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PodsMetricSource) XXX_Merge(src proto.Message) { + xxx_messageInfo_PodsMetricSource.Merge(m, src) +} +func (m *PodsMetricSource) XXX_Size() int { + return m.Size() +} +func (m *PodsMetricSource) XXX_DiscardUnknown() { + xxx_messageInfo_PodsMetricSource.DiscardUnknown(m) +} + +var xxx_messageInfo_PodsMetricSource proto.InternalMessageInfo + +func (m *PodsMetricStatus) Reset() { *m = PodsMetricStatus{} } +func (*PodsMetricStatus) ProtoMessage() {} +func (*PodsMetricStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{21} +} +func (m *PodsMetricStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PodsMetricStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PodsMetricStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_PodsMetricStatus.Merge(m, src) +} +func (m *PodsMetricStatus) XXX_Size() int { + return m.Size() +} +func (m *PodsMetricStatus) XXX_DiscardUnknown() { + xxx_messageInfo_PodsMetricStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_PodsMetricStatus proto.InternalMessageInfo + +func (m *ResourceMetricSource) Reset() { *m = ResourceMetricSource{} } +func (*ResourceMetricSource) ProtoMessage() {} +func (*ResourceMetricSource) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{22} +} +func (m *ResourceMetricSource) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResourceMetricSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ResourceMetricSource) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResourceMetricSource.Merge(m, src) +} +func (m *ResourceMetricSource) XXX_Size() int { + return m.Size() +} +func (m *ResourceMetricSource) XXX_DiscardUnknown() { + xxx_messageInfo_ResourceMetricSource.DiscardUnknown(m) +} + +var xxx_messageInfo_ResourceMetricSource proto.InternalMessageInfo + +func (m *ResourceMetricStatus) Reset() { *m = ResourceMetricStatus{} } +func (*ResourceMetricStatus) ProtoMessage() {} +func (*ResourceMetricStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_b14d4df4b5f3935e, []int{23} +} +func (m *ResourceMetricStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResourceMetricStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ResourceMetricStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResourceMetricStatus.Merge(m, src) +} +func (m *ResourceMetricStatus) XXX_Size() int { + return m.Size() +} +func (m *ResourceMetricStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ResourceMetricStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ResourceMetricStatus proto.InternalMessageInfo + +func init() { + proto.RegisterType((*ContainerResourceMetricSource)(nil), "k8s.io.api.autoscaling.v2.ContainerResourceMetricSource") + proto.RegisterType((*ContainerResourceMetricStatus)(nil), "k8s.io.api.autoscaling.v2.ContainerResourceMetricStatus") + proto.RegisterType((*CrossVersionObjectReference)(nil), "k8s.io.api.autoscaling.v2.CrossVersionObjectReference") + proto.RegisterType((*ExternalMetricSource)(nil), "k8s.io.api.autoscaling.v2.ExternalMetricSource") + proto.RegisterType((*ExternalMetricStatus)(nil), "k8s.io.api.autoscaling.v2.ExternalMetricStatus") + proto.RegisterType((*HPAScalingPolicy)(nil), "k8s.io.api.autoscaling.v2.HPAScalingPolicy") + proto.RegisterType((*HPAScalingRules)(nil), "k8s.io.api.autoscaling.v2.HPAScalingRules") + proto.RegisterType((*HorizontalPodAutoscaler)(nil), "k8s.io.api.autoscaling.v2.HorizontalPodAutoscaler") + proto.RegisterType((*HorizontalPodAutoscalerBehavior)(nil), "k8s.io.api.autoscaling.v2.HorizontalPodAutoscalerBehavior") + proto.RegisterType((*HorizontalPodAutoscalerCondition)(nil), "k8s.io.api.autoscaling.v2.HorizontalPodAutoscalerCondition") + proto.RegisterType((*HorizontalPodAutoscalerList)(nil), "k8s.io.api.autoscaling.v2.HorizontalPodAutoscalerList") + proto.RegisterType((*HorizontalPodAutoscalerSpec)(nil), "k8s.io.api.autoscaling.v2.HorizontalPodAutoscalerSpec") + proto.RegisterType((*HorizontalPodAutoscalerStatus)(nil), "k8s.io.api.autoscaling.v2.HorizontalPodAutoscalerStatus") + proto.RegisterType((*MetricIdentifier)(nil), "k8s.io.api.autoscaling.v2.MetricIdentifier") + proto.RegisterType((*MetricSpec)(nil), "k8s.io.api.autoscaling.v2.MetricSpec") + proto.RegisterType((*MetricStatus)(nil), "k8s.io.api.autoscaling.v2.MetricStatus") + proto.RegisterType((*MetricTarget)(nil), "k8s.io.api.autoscaling.v2.MetricTarget") + proto.RegisterType((*MetricValueStatus)(nil), "k8s.io.api.autoscaling.v2.MetricValueStatus") + proto.RegisterType((*ObjectMetricSource)(nil), "k8s.io.api.autoscaling.v2.ObjectMetricSource") + proto.RegisterType((*ObjectMetricStatus)(nil), "k8s.io.api.autoscaling.v2.ObjectMetricStatus") + proto.RegisterType((*PodsMetricSource)(nil), "k8s.io.api.autoscaling.v2.PodsMetricSource") + proto.RegisterType((*PodsMetricStatus)(nil), "k8s.io.api.autoscaling.v2.PodsMetricStatus") + proto.RegisterType((*ResourceMetricSource)(nil), "k8s.io.api.autoscaling.v2.ResourceMetricSource") + proto.RegisterType((*ResourceMetricStatus)(nil), "k8s.io.api.autoscaling.v2.ResourceMetricStatus") +} + +func init() { + proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/autoscaling/v2/generated.proto", fileDescriptor_b14d4df4b5f3935e) +} + +var fileDescriptor_b14d4df4b5f3935e = []byte{ + // 1735 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcb, 0x6f, 0x1b, 0xc7, + 0x19, 0xd7, 0x92, 0xd4, 0x6b, 0xa8, 0xe7, 0xf8, 0xc5, 0xca, 0x30, 0x29, 0x6c, 0xdd, 0xda, 0x75, + 0xeb, 0x65, 0xcd, 0xba, 0x86, 0x51, 0x9f, 0xb4, 0x72, 0x5b, 0x0b, 0x96, 0x2a, 0x7a, 0x68, 0x5b, + 0x6d, 0xd1, 0x16, 0x1e, 0xee, 0x8e, 0xa8, 0xa9, 0xc8, 0x5d, 0x62, 0x77, 0x49, 0x5b, 0x06, 0x0a, + 0xf4, 0xd2, 0x7b, 0xd1, 0xc2, 0x28, 0xfa, 0x3f, 0x18, 0x39, 0x25, 0x70, 0x0e, 0x09, 0x10, 0x20, + 0x39, 0xf8, 0x12, 0xc0, 0x87, 0x1c, 0x7c, 0x22, 0x62, 0x06, 0xc8, 0x31, 0x7f, 0x80, 0x4f, 0xc1, + 0x3c, 0xf6, 0xc9, 0x97, 0xe8, 0xc8, 0x02, 0x74, 0xe3, 0xcc, 0x7c, 0xdf, 0xef, 0x7b, 0xcc, 0xf7, + 0x9a, 0x25, 0xd0, 0xf7, 0x6f, 0xba, 0x1a, 0xb5, 0x8b, 0xfb, 0xad, 0x2a, 0x71, 0x2c, 0xe2, 0x11, + 0xb7, 0xd8, 0x26, 0x96, 0x69, 0x3b, 0x45, 0x79, 0x80, 0x9b, 0xb4, 0x88, 0x5b, 0x9e, 0xed, 0x1a, + 0xb8, 0x4e, 0xad, 0x5a, 0xb1, 0x5d, 0x2a, 0xd6, 0x88, 0x45, 0x1c, 0xec, 0x11, 0x53, 0x6b, 0x3a, + 0xb6, 0x67, 0xc3, 0x1f, 0x09, 0x52, 0x0d, 0x37, 0xa9, 0x16, 0x21, 0xd5, 0xda, 0xa5, 0x95, 0xab, + 0x35, 0xea, 0xed, 0xb5, 0xaa, 0x9a, 0x61, 0x37, 0x8a, 0x35, 0xbb, 0x66, 0x17, 0x39, 0x47, 0xb5, + 0xb5, 0xcb, 0x57, 0x7c, 0xc1, 0x7f, 0x09, 0xa4, 0x15, 0x35, 0x22, 0xd4, 0xb0, 0x1d, 0x52, 0x6c, + 0x5f, 0x4b, 0x4a, 0x5b, 0xb9, 0x1e, 0xd2, 0x34, 0xb0, 0xb1, 0x47, 0x2d, 0xe2, 0x1c, 0x14, 0x9b, + 0xfb, 0x35, 0xce, 0xe4, 0x10, 0xd7, 0x6e, 0x39, 0x06, 0x19, 0x8b, 0xcb, 0x2d, 0x36, 0x88, 0x87, + 0xfb, 0xc9, 0x2a, 0x0e, 0xe2, 0x72, 0x5a, 0x96, 0x47, 0x1b, 0xbd, 0x62, 0x6e, 0x8c, 0x62, 0x70, + 0x8d, 0x3d, 0xd2, 0xc0, 0x49, 0x3e, 0xf5, 0x5b, 0x05, 0x5c, 0x58, 0xb7, 0x2d, 0x0f, 0x33, 0x0e, + 0x24, 0x8d, 0xd8, 0x22, 0x9e, 0x43, 0x8d, 0x0a, 0xff, 0x0d, 0xd7, 0x41, 0xc6, 0xc2, 0x0d, 0x92, + 0x53, 0x56, 0x95, 0xcb, 0xb3, 0x7a, 0xf1, 0x65, 0xa7, 0x30, 0xd1, 0xed, 0x14, 0x32, 0x7f, 0xc0, + 0x0d, 0xf2, 0xb6, 0x53, 0x28, 0xf4, 0x3a, 0x4e, 0xf3, 0x61, 0x18, 0x09, 0xe2, 0xcc, 0x70, 0x1b, + 0x4c, 0x79, 0xd8, 0xa9, 0x11, 0x2f, 0x97, 0x5a, 0x55, 0x2e, 0x67, 0x4b, 0x97, 0xb4, 0x81, 0x57, + 0xa7, 0x09, 0xe9, 0xf7, 0x39, 0xb9, 0xbe, 0x20, 0xe5, 0x4d, 0x89, 0x35, 0x92, 0x30, 0xb0, 0x08, + 0x66, 0x0d, 0x5f, 0xed, 0x5c, 0x9a, 0xab, 0xb6, 0x2c, 0x49, 0x67, 0x43, 0x7b, 0x42, 0x1a, 0xf5, + 0xbb, 0x21, 0x86, 0x7a, 0xd8, 0x6b, 0xb9, 0x47, 0x63, 0xe8, 0x0e, 0x98, 0x36, 0x5a, 0x8e, 0x43, + 0x2c, 0xdf, 0xd2, 0x5f, 0x8c, 0xb4, 0xf4, 0x21, 0xae, 0xb7, 0x88, 0xd0, 0x41, 0x5f, 0x94, 0x52, + 0xa7, 0xd7, 0x05, 0x08, 0xf2, 0xd1, 0xc6, 0x37, 0xf8, 0x99, 0x02, 0xce, 0xaf, 0x3b, 0xb6, 0xeb, + 0x3e, 0x24, 0x8e, 0x4b, 0x6d, 0x6b, 0xbb, 0xfa, 0x77, 0x62, 0x78, 0x88, 0xec, 0x12, 0x87, 0x58, + 0x06, 0x81, 0xab, 0x20, 0xb3, 0x4f, 0x2d, 0x53, 0x9a, 0x3b, 0xe7, 0x9b, 0x7b, 0x97, 0x5a, 0x26, + 0xe2, 0x27, 0x8c, 0x82, 0x3b, 0x24, 0x15, 0xa7, 0x88, 0x58, 0x5b, 0x02, 0x00, 0x37, 0xa9, 0x14, + 0x20, 0xb5, 0x82, 0x92, 0x0e, 0xac, 0x95, 0x37, 0xe4, 0x09, 0x8a, 0x50, 0xa9, 0x9f, 0x28, 0xe0, + 0xf4, 0x6f, 0x9f, 0x78, 0xc4, 0xb1, 0x70, 0x3d, 0x16, 0x68, 0x15, 0x30, 0xd5, 0xe0, 0x6b, 0xae, + 0x52, 0xb6, 0xf4, 0xf3, 0x91, 0x9e, 0xdb, 0x30, 0x89, 0xe5, 0xd1, 0x5d, 0x4a, 0x9c, 0x30, 0x4e, + 0xc4, 0x09, 0x92, 0x50, 0x47, 0x1e, 0x78, 0xea, 0x17, 0xbd, 0xea, 0x8b, 0xf0, 0x79, 0x2f, 0xea, + 0xbf, 0xaf, 0x70, 0x52, 0x3f, 0x50, 0xc0, 0xd2, 0x9d, 0xf2, 0x5a, 0x45, 0x70, 0x97, 0xed, 0x3a, + 0x35, 0x0e, 0xe0, 0x4d, 0x90, 0xf1, 0x0e, 0x9a, 0x7e, 0x06, 0x5c, 0xf4, 0x2f, 0xfc, 0xfe, 0x41, + 0x93, 0x65, 0xc0, 0xe9, 0x24, 0x3d, 0xdb, 0x47, 0x9c, 0x03, 0xfe, 0x18, 0x4c, 0xb6, 0x99, 0x5c, + 0xae, 0xe5, 0xa4, 0x3e, 0x2f, 0x59, 0x27, 0xb9, 0x32, 0x48, 0x9c, 0xc1, 0x5b, 0x60, 0xbe, 0x49, + 0x1c, 0x6a, 0x9b, 0x15, 0x62, 0xd8, 0x96, 0xe9, 0xf2, 0x80, 0x99, 0xd4, 0xcf, 0x48, 0xe2, 0xf9, + 0x72, 0xf4, 0x10, 0xc5, 0x69, 0xd5, 0xff, 0xa7, 0xc0, 0x62, 0xa8, 0x00, 0x6a, 0xd5, 0x89, 0x0b, + 0xff, 0x06, 0x56, 0x5c, 0x0f, 0x57, 0x69, 0x9d, 0x3e, 0xc5, 0x1e, 0xb5, 0xad, 0x1d, 0x6a, 0x99, + 0xf6, 0xe3, 0x38, 0x7a, 0xbe, 0xdb, 0x29, 0xac, 0x54, 0x06, 0x52, 0xa1, 0x21, 0x08, 0xf0, 0x2e, + 0x98, 0x73, 0x49, 0x9d, 0x18, 0x9e, 0xb0, 0x57, 0xfa, 0xe5, 0x52, 0xb7, 0x53, 0x98, 0xab, 0x44, + 0xf6, 0xdf, 0x76, 0x0a, 0xa7, 0x62, 0x8e, 0x11, 0x87, 0x28, 0xc6, 0x0c, 0xff, 0x04, 0x66, 0x9a, + 0xec, 0x17, 0x25, 0x6e, 0x2e, 0xb5, 0x9a, 0x1e, 0x11, 0x21, 0x49, 0x5f, 0xeb, 0x4b, 0xd2, 0x4b, + 0x33, 0x65, 0x09, 0x82, 0x02, 0x38, 0xf5, 0x45, 0x0a, 0x9c, 0xbb, 0x63, 0x3b, 0xf4, 0x29, 0x4b, + 0xfe, 0x7a, 0xd9, 0x36, 0xd7, 0x24, 0x18, 0x71, 0xe0, 0x23, 0x30, 0xc3, 0x9a, 0x8c, 0x89, 0x3d, + 0x2c, 0x03, 0xf3, 0x97, 0x11, 0xb1, 0x41, 0xaf, 0xd0, 0x9a, 0xfb, 0x35, 0xb6, 0xe1, 0x6a, 0x8c, + 0x5a, 0x6b, 0x5f, 0xd3, 0x44, 0xbd, 0xd8, 0x22, 0x1e, 0x0e, 0x53, 0x3a, 0xdc, 0x43, 0x01, 0x2a, + 0xfc, 0x23, 0xc8, 0xb8, 0x4d, 0x62, 0xc8, 0x00, 0xbd, 0x31, 0xcc, 0xa8, 0xfe, 0x3a, 0x56, 0x9a, + 0xc4, 0x08, 0xcb, 0x0b, 0x5b, 0x21, 0x8e, 0x08, 0x1f, 0x81, 0x29, 0x97, 0x07, 0x32, 0xbf, 0xcb, + 0x6c, 0xe9, 0xe6, 0x3b, 0x60, 0x8b, 0x44, 0x08, 0xf2, 0x4b, 0xac, 0x91, 0xc4, 0x55, 0xbf, 0x54, + 0x40, 0x61, 0x00, 0xa7, 0x4e, 0xf6, 0x70, 0x9b, 0xda, 0x0e, 0xbc, 0x07, 0xa6, 0xf9, 0xce, 0x83, + 0xa6, 0x74, 0xe0, 0x95, 0x43, 0xdd, 0x1b, 0x0f, 0x51, 0x3d, 0xcb, 0xb2, 0xaf, 0x22, 0xd8, 0x91, + 0x8f, 0x03, 0x77, 0xc0, 0x2c, 0xff, 0x79, 0xdb, 0x7e, 0x6c, 0x49, 0xbf, 0x8d, 0x03, 0x3a, 0xcf, + 0x8a, 0x7e, 0xc5, 0x07, 0x40, 0x21, 0x96, 0xfa, 0xaf, 0x34, 0x58, 0x1d, 0x60, 0xcf, 0xba, 0x6d, + 0x99, 0x94, 0xc5, 0x38, 0xbc, 0x13, 0x4b, 0xf3, 0xeb, 0x89, 0x34, 0xbf, 0x38, 0x8a, 0x3f, 0x92, + 0xf6, 0x9b, 0xc1, 0x05, 0xa5, 0x62, 0x58, 0xd2, 0xcd, 0x6f, 0x3b, 0x85, 0x3e, 0x83, 0x95, 0x16, + 0x20, 0xc5, 0x2f, 0x03, 0xb6, 0x01, 0xac, 0x63, 0xd7, 0xbb, 0xef, 0x60, 0xcb, 0x15, 0x92, 0x68, + 0x83, 0xc8, 0xab, 0xbf, 0x72, 0xb8, 0xa0, 0x65, 0x1c, 0xfa, 0x8a, 0xd4, 0x02, 0x6e, 0xf6, 0xa0, + 0xa1, 0x3e, 0x12, 0xe0, 0x4f, 0xc1, 0x94, 0x43, 0xb0, 0x6b, 0x5b, 0xb9, 0x0c, 0xb7, 0x22, 0x08, + 0x16, 0xc4, 0x77, 0x91, 0x3c, 0x85, 0x3f, 0x03, 0xd3, 0x0d, 0xe2, 0xba, 0xb8, 0x46, 0x72, 0x93, + 0x9c, 0x30, 0x28, 0xaf, 0x5b, 0x62, 0x1b, 0xf9, 0xe7, 0xea, 0x57, 0x0a, 0x38, 0x3f, 0xc0, 0x8f, + 0x9b, 0xd4, 0xf5, 0xe0, 0x5f, 0x7a, 0xb2, 0x52, 0x3b, 0x9c, 0x81, 0x8c, 0x9b, 0xe7, 0x64, 0x50, + 0x0f, 0xfc, 0x9d, 0x48, 0x46, 0xee, 0x80, 0x49, 0xea, 0x91, 0x86, 0x5f, 0x67, 0x4a, 0xe3, 0xa7, + 0x4d, 0x58, 0xc1, 0x37, 0x18, 0x10, 0x12, 0x78, 0xea, 0x8b, 0xf4, 0x40, 0xb3, 0x58, 0xda, 0xc2, + 0x36, 0x58, 0xe0, 0x2b, 0xd9, 0x33, 0xc9, 0xae, 0x34, 0x6e, 0x58, 0x51, 0x18, 0x32, 0xa3, 0xe8, + 0x67, 0xa5, 0x16, 0x0b, 0x95, 0x18, 0x2a, 0x4a, 0x48, 0x81, 0xd7, 0x40, 0xb6, 0x41, 0x2d, 0x44, + 0x9a, 0x75, 0x6a, 0x60, 0x57, 0x36, 0xa1, 0xc5, 0x6e, 0xa7, 0x90, 0xdd, 0x0a, 0xb7, 0x51, 0x94, + 0x06, 0xfe, 0x1a, 0x64, 0x1b, 0xf8, 0x49, 0xc0, 0x22, 0x9a, 0xc5, 0x29, 0x29, 0x2f, 0xbb, 0x15, + 0x1e, 0xa1, 0x28, 0x1d, 0x2c, 0xb3, 0x18, 0x60, 0x6d, 0xd6, 0xcd, 0x65, 0xb8, 0x73, 0x7f, 0x32, + 0xb2, 0x21, 0xf3, 0xf2, 0x16, 0x09, 0x15, 0xce, 0x8d, 0x7c, 0x18, 0x68, 0x82, 0x99, 0xaa, 0x2c, + 0x35, 0x3c, 0xac, 0xb2, 0xa5, 0xdf, 0xbc, 0xc3, 0x7d, 0x49, 0x04, 0x7d, 0x8e, 0x85, 0x84, 0xbf, + 0x42, 0x01, 0xb2, 0xfa, 0x3c, 0x03, 0x2e, 0x0c, 0x2d, 0x91, 0xf0, 0x77, 0x00, 0xda, 0x55, 0x97, + 0x38, 0x6d, 0x62, 0xfe, 0x5e, 0x3c, 0x12, 0xd8, 0x4c, 0xc7, 0xee, 0x2f, 0xad, 0x9f, 0x65, 0xd9, + 0xb4, 0xdd, 0x73, 0x8a, 0xfa, 0x70, 0x40, 0x03, 0xcc, 0xb3, 0x1c, 0x13, 0x37, 0x46, 0xe5, 0xf8, + 0x38, 0x5e, 0x02, 0x2f, 0xb3, 0x69, 0x60, 0x33, 0x0a, 0x82, 0xe2, 0x98, 0x70, 0x0d, 0x2c, 0xca, + 0x49, 0x26, 0x71, 0x83, 0xe7, 0xa4, 0x9f, 0x17, 0xd7, 0xe3, 0xc7, 0x28, 0x49, 0xcf, 0x20, 0x4c, + 0xe2, 0x52, 0x87, 0x98, 0x01, 0x44, 0x26, 0x0e, 0x71, 0x3b, 0x7e, 0x8c, 0x92, 0xf4, 0xb0, 0x06, + 0x16, 0x24, 0xaa, 0xbc, 0xd5, 0xdc, 0x24, 0x8f, 0x89, 0xd1, 0x43, 0xa6, 0x6c, 0x4b, 0x41, 0x7c, + 0xaf, 0xc7, 0x60, 0x50, 0x02, 0x16, 0xda, 0x00, 0x18, 0x7e, 0xd1, 0x74, 0x73, 0x53, 0x5c, 0xc8, + 0xad, 0xf1, 0xa3, 0x24, 0x28, 0xbc, 0x61, 0x47, 0x0f, 0xb6, 0x5c, 0x14, 0x11, 0xa1, 0xfe, 0x57, + 0x01, 0x4b, 0xc9, 0x21, 0x35, 0x78, 0x0f, 0x28, 0x03, 0xdf, 0x03, 0x7f, 0x05, 0x33, 0x62, 0xe6, + 0xb1, 0x1d, 0x79, 0xed, 0xbf, 0x3a, 0x64, 0x59, 0xc3, 0x55, 0x52, 0xaf, 0x48, 0x56, 0x11, 0xc4, + 0xfe, 0x0a, 0x05, 0x90, 0xea, 0xb3, 0x0c, 0x00, 0x61, 0x4e, 0xc1, 0xeb, 0xb1, 0x3e, 0xb6, 0x9a, + 0xe8, 0x63, 0x4b, 0xd1, 0xc7, 0x45, 0xa4, 0x67, 0xdd, 0x03, 0x53, 0x36, 0x2f, 0x33, 0x52, 0xc3, + 0xab, 0x43, 0xfc, 0x18, 0xcc, 0x3b, 0x01, 0x90, 0x0e, 0x58, 0x63, 0x90, 0x75, 0x4a, 0x02, 0xc1, + 0x0d, 0x90, 0x69, 0xda, 0xa6, 0x3f, 0xa5, 0x0c, 0x1b, 0xeb, 0xca, 0xb6, 0xe9, 0xc6, 0xe0, 0x66, + 0x98, 0xc6, 0x6c, 0x17, 0x71, 0x08, 0x36, 0x25, 0xfa, 0x9f, 0x12, 0x78, 0x38, 0x66, 0x4b, 0xc5, + 0x21, 0x70, 0xfd, 0x1e, 0xec, 0xc2, 0x7b, 0xfe, 0x09, 0x0a, 0xe0, 0xe0, 0x3f, 0xc0, 0xb2, 0x91, + 0x7c, 0x00, 0xe7, 0xa6, 0x47, 0x0e, 0x56, 0x43, 0xbf, 0x0e, 0xe8, 0x67, 0xba, 0x9d, 0xc2, 0x72, + 0x0f, 0x09, 0xea, 0x95, 0xc4, 0x2c, 0x23, 0xf2, 0xdd, 0x24, 0xeb, 0xdc, 0x30, 0xcb, 0xfa, 0xbd, + 0x10, 0x85, 0x65, 0xfe, 0x09, 0x0a, 0xe0, 0xd4, 0xff, 0x65, 0xc0, 0x5c, 0xec, 0x2d, 0x76, 0xcc, + 0x91, 0x21, 0x92, 0xf9, 0xc8, 0x22, 0x43, 0xc0, 0x1d, 0x69, 0x64, 0x08, 0xc8, 0x63, 0x8a, 0x0c, + 0x21, 0xec, 0x98, 0x22, 0x23, 0x62, 0x59, 0x9f, 0xc8, 0xf8, 0x3c, 0xe5, 0x47, 0x86, 0x18, 0x16, + 0x0e, 0x17, 0x19, 0x82, 0x36, 0x12, 0x19, 0xdb, 0xd1, 0xe7, 0xed, 0x88, 0x59, 0x4d, 0xf3, 0xdd, + 0xaa, 0xdd, 0x6b, 0x61, 0xcb, 0xa3, 0xde, 0x81, 0x3e, 0xdb, 0xf3, 0x14, 0x36, 0xc1, 0x1c, 0x6e, + 0x13, 0x07, 0xd7, 0x08, 0xdf, 0x96, 0xf1, 0x31, 0x2e, 0xee, 0x12, 0x7b, 0x89, 0xae, 0x45, 0x70, + 0x50, 0x0c, 0x95, 0xb5, 0x74, 0xb9, 0x7e, 0xe0, 0x05, 0x4f, 0x5c, 0xd9, 0xe5, 0x78, 0x4b, 0x5f, + 0xeb, 0x39, 0x45, 0x7d, 0x38, 0xd4, 0xff, 0xa4, 0xc0, 0x72, 0xcf, 0xc7, 0x85, 0xd0, 0x29, 0xca, + 0x7b, 0x72, 0x4a, 0xea, 0x18, 0x9d, 0x92, 0x1e, 0xdb, 0x29, 0x1f, 0xa5, 0x00, 0xec, 0xed, 0x0f, + 0xf0, 0x80, 0x8f, 0x15, 0x86, 0x43, 0xab, 0xc4, 0x14, 0xc7, 0x3f, 0x70, 0x06, 0x8e, 0x8e, 0x23, + 0x51, 0x58, 0x94, 0x94, 0x73, 0xf4, 0x1f, 0x59, 0xc3, 0x4f, 0x5a, 0xe9, 0x23, 0xfb, 0xa4, 0xa5, + 0x7e, 0x9a, 0xf4, 0xdb, 0x09, 0xfc, 0x7c, 0xd6, 0xef, 0x96, 0xd3, 0xc7, 0x73, 0xcb, 0xea, 0xc7, + 0x0a, 0x58, 0x4a, 0x8e, 0x11, 0x27, 0xe4, 0xdb, 0xe9, 0x67, 0x71, 0xd5, 0x4f, 0xe2, 0x77, 0xd3, + 0xe7, 0x0a, 0x38, 0x7d, 0x72, 0xfe, 0x26, 0x51, 0x3f, 0xec, 0x55, 0xf7, 0x04, 0xfc, 0xd9, 0xa1, + 0x5f, 0x7e, 0xf9, 0x26, 0x3f, 0xf1, 0xea, 0x4d, 0x7e, 0xe2, 0xf5, 0x9b, 0xfc, 0xc4, 0x3f, 0xbb, + 0x79, 0xe5, 0x65, 0x37, 0xaf, 0xbc, 0xea, 0xe6, 0x95, 0xd7, 0xdd, 0xbc, 0xf2, 0x75, 0x37, 0xaf, + 0xfc, 0xfb, 0x9b, 0xfc, 0xc4, 0x9f, 0x53, 0xed, 0xd2, 0xf7, 0x01, 0x00, 0x00, 0xff, 0xff, 0x72, + 0xba, 0x02, 0x95, 0x47, 0x1c, 0x00, 0x00, +} + +func (m *ContainerResourceMetricSource) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ContainerResourceMetricSource) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ContainerResourceMetricSource) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Container) + copy(dAtA[i:], m.Container) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Container))) + i-- + dAtA[i] = 0x1a + { + size, err := m.Target.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ContainerResourceMetricStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ContainerResourceMetricStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ContainerResourceMetricStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Container) + copy(dAtA[i:], m.Container) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Container))) + i-- + dAtA[i] = 0x1a + { + size, err := m.Current.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *CrossVersionObjectReference) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CrossVersionObjectReference) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CrossVersionObjectReference) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.APIVersion) + copy(dAtA[i:], m.APIVersion) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion))) + i-- + dAtA[i] = 0x1a + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + i -= len(m.Kind) + copy(dAtA[i:], m.Kind) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ExternalMetricSource) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExternalMetricSource) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExternalMetricSource) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Target.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metric.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ExternalMetricStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExternalMetricStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExternalMetricStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Current.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metric.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *HPAScalingPolicy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HPAScalingPolicy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HPAScalingPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i = encodeVarintGenerated(dAtA, i, uint64(m.PeriodSeconds)) + i-- + dAtA[i] = 0x18 + i = encodeVarintGenerated(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x10 + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *HPAScalingRules) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HPAScalingRules) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HPAScalingRules) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.StabilizationWindowSeconds != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.StabilizationWindowSeconds)) + i-- + dAtA[i] = 0x18 + } + if len(m.Policies) > 0 { + for iNdEx := len(m.Policies) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Policies[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.SelectPolicy != nil { + i -= len(*m.SelectPolicy) + copy(dAtA[i:], *m.SelectPolicy) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.SelectPolicy))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *HorizontalPodAutoscaler) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HorizontalPodAutoscaler) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HorizontalPodAutoscaler) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *HorizontalPodAutoscalerBehavior) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HorizontalPodAutoscalerBehavior) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HorizontalPodAutoscalerBehavior) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ScaleDown != nil { + { + size, err := m.ScaleDown.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.ScaleUp != nil { + { + size, err := m.ScaleUp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *HorizontalPodAutoscalerCondition) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HorizontalPodAutoscalerCondition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HorizontalPodAutoscalerCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x2a + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x22 + { + size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x12 + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *HorizontalPodAutoscalerList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HorizontalPodAutoscalerList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HorizontalPodAutoscalerList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *HorizontalPodAutoscalerSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HorizontalPodAutoscalerSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HorizontalPodAutoscalerSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Behavior != nil { + { + size, err := m.Behavior.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if len(m.Metrics) > 0 { + for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Metrics[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + i = encodeVarintGenerated(dAtA, i, uint64(m.MaxReplicas)) + i-- + dAtA[i] = 0x18 + if m.MinReplicas != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.MinReplicas)) + i-- + dAtA[i] = 0x10 + } + { + size, err := m.ScaleTargetRef.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *HorizontalPodAutoscalerStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HorizontalPodAutoscalerStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HorizontalPodAutoscalerStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Conditions) > 0 { + for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + } + if len(m.CurrentMetrics) > 0 { + for iNdEx := len(m.CurrentMetrics) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.CurrentMetrics[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredReplicas)) + i-- + dAtA[i] = 0x20 + i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentReplicas)) + i-- + dAtA[i] = 0x18 + if m.LastScaleTime != nil { + { + size, err := m.LastScaleTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.ObservedGeneration != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.ObservedGeneration)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MetricIdentifier) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MetricIdentifier) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MetricIdentifier) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Selector != nil { + { + size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MetricSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MetricSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MetricSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ContainerResource != nil { + { + size, err := m.ContainerResource.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.External != nil { + { + size, err := m.External.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.Resource != nil { + { + size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Pods != nil { + { + size, err := m.Pods.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Object != nil { + { + size, err := m.Object.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MetricStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MetricStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MetricStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ContainerResource != nil { + { + size, err := m.ContainerResource.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.External != nil { + { + size, err := m.External.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.Resource != nil { + { + size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Pods != nil { + { + size, err := m.Pods.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Object != nil { + { + size, err := m.Object.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MetricTarget) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MetricTarget) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MetricTarget) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AverageUtilization != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.AverageUtilization)) + i-- + dAtA[i] = 0x20 + } + if m.AverageValue != nil { + { + size, err := m.AverageValue.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MetricValueStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MetricValueStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MetricValueStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AverageUtilization != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.AverageUtilization)) + i-- + dAtA[i] = 0x18 + } + if m.AverageValue != nil { + { + size, err := m.AverageValue.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ObjectMetricSource) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ObjectMetricSource) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ObjectMetricSource) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Metric.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Target.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.DescribedObject.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ObjectMetricStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ObjectMetricStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ObjectMetricStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.DescribedObject.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Current.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metric.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PodsMetricSource) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PodsMetricSource) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PodsMetricSource) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Target.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metric.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PodsMetricStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PodsMetricStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PodsMetricStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Current.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metric.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ResourceMetricSource) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResourceMetricSource) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResourceMetricSource) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Target.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ResourceMetricStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResourceMetricStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResourceMetricStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Current.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { + offset -= sovGenerated(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ContainerResourceMetricSource) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = m.Target.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Container) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ContainerResourceMetricStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = m.Current.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Container) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *CrossVersionObjectReference) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Kind) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.APIVersion) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ExternalMetricSource) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metric.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Target.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ExternalMetricStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metric.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Current.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *HPAScalingPolicy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.Value)) + n += 1 + sovGenerated(uint64(m.PeriodSeconds)) + return n +} + +func (m *HPAScalingRules) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SelectPolicy != nil { + l = len(*m.SelectPolicy) + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.Policies) > 0 { + for _, e := range m.Policies { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.StabilizationWindowSeconds != nil { + n += 1 + sovGenerated(uint64(*m.StabilizationWindowSeconds)) + } + return n +} + +func (m *HorizontalPodAutoscaler) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Status.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *HorizontalPodAutoscalerBehavior) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ScaleUp != nil { + l = m.ScaleUp.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ScaleDown != nil { + l = m.ScaleDown.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *HorizontalPodAutoscalerCondition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Status) + n += 1 + l + sovGenerated(uint64(l)) + l = m.LastTransitionTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Reason) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *HorizontalPodAutoscalerList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ListMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *HorizontalPodAutoscalerSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ScaleTargetRef.Size() + n += 1 + l + sovGenerated(uint64(l)) + if m.MinReplicas != nil { + n += 1 + sovGenerated(uint64(*m.MinReplicas)) + } + n += 1 + sovGenerated(uint64(m.MaxReplicas)) + if len(m.Metrics) > 0 { + for _, e := range m.Metrics { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.Behavior != nil { + l = m.Behavior.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *HorizontalPodAutoscalerStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ObservedGeneration != nil { + n += 1 + sovGenerated(uint64(*m.ObservedGeneration)) + } + if m.LastScaleTime != nil { + l = m.LastScaleTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + n += 1 + sovGenerated(uint64(m.CurrentReplicas)) + n += 1 + sovGenerated(uint64(m.DesiredReplicas)) + if len(m.CurrentMetrics) > 0 { + for _, e := range m.CurrentMetrics { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.Conditions) > 0 { + for _, e := range m.Conditions { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *MetricIdentifier) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + if m.Selector != nil { + l = m.Selector.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *MetricSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + if m.Object != nil { + l = m.Object.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Pods != nil { + l = m.Pods.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Resource != nil { + l = m.Resource.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.External != nil { + l = m.External.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ContainerResource != nil { + l = m.ContainerResource.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *MetricStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + if m.Object != nil { + l = m.Object.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Pods != nil { + l = m.Pods.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Resource != nil { + l = m.Resource.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.External != nil { + l = m.External.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ContainerResource != nil { + l = m.ContainerResource.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *MetricTarget) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.AverageValue != nil { + l = m.AverageValue.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.AverageUtilization != nil { + n += 1 + sovGenerated(uint64(*m.AverageUtilization)) + } + return n +} + +func (m *MetricValueStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.AverageValue != nil { + l = m.AverageValue.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.AverageUtilization != nil { + n += 1 + sovGenerated(uint64(*m.AverageUtilization)) + } + return n +} + +func (m *ObjectMetricSource) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.DescribedObject.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Target.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Metric.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ObjectMetricStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metric.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Current.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.DescribedObject.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *PodsMetricSource) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metric.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Target.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *PodsMetricStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metric.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Current.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ResourceMetricSource) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = m.Target.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ResourceMetricStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + l = m.Current.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func sovGenerated(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenerated(x uint64) (n int) { + return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *ContainerResourceMetricSource) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ContainerResourceMetricSource{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Target:` + strings.Replace(strings.Replace(this.Target.String(), "MetricTarget", "MetricTarget", 1), `&`, ``, 1) + `,`, + `Container:` + fmt.Sprintf("%v", this.Container) + `,`, + `}`, + }, "") + return s +} +func (this *ContainerResourceMetricStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ContainerResourceMetricStatus{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Current:` + strings.Replace(strings.Replace(this.Current.String(), "MetricValueStatus", "MetricValueStatus", 1), `&`, ``, 1) + `,`, + `Container:` + fmt.Sprintf("%v", this.Container) + `,`, + `}`, + }, "") + return s +} +func (this *CrossVersionObjectReference) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CrossVersionObjectReference{`, + `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`, + `}`, + }, "") + return s +} +func (this *ExternalMetricSource) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ExternalMetricSource{`, + `Metric:` + strings.Replace(strings.Replace(this.Metric.String(), "MetricIdentifier", "MetricIdentifier", 1), `&`, ``, 1) + `,`, + `Target:` + strings.Replace(strings.Replace(this.Target.String(), "MetricTarget", "MetricTarget", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *ExternalMetricStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ExternalMetricStatus{`, + `Metric:` + strings.Replace(strings.Replace(this.Metric.String(), "MetricIdentifier", "MetricIdentifier", 1), `&`, ``, 1) + `,`, + `Current:` + strings.Replace(strings.Replace(this.Current.String(), "MetricValueStatus", "MetricValueStatus", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *HPAScalingPolicy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&HPAScalingPolicy{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `PeriodSeconds:` + fmt.Sprintf("%v", this.PeriodSeconds) + `,`, + `}`, + }, "") + return s +} +func (this *HPAScalingRules) String() string { + if this == nil { + return "nil" + } + repeatedStringForPolicies := "[]HPAScalingPolicy{" + for _, f := range this.Policies { + repeatedStringForPolicies += strings.Replace(strings.Replace(f.String(), "HPAScalingPolicy", "HPAScalingPolicy", 1), `&`, ``, 1) + "," + } + repeatedStringForPolicies += "}" + s := strings.Join([]string{`&HPAScalingRules{`, + `SelectPolicy:` + valueToStringGenerated(this.SelectPolicy) + `,`, + `Policies:` + repeatedStringForPolicies + `,`, + `StabilizationWindowSeconds:` + valueToStringGenerated(this.StabilizationWindowSeconds) + `,`, + `}`, + }, "") + return s +} +func (this *HorizontalPodAutoscaler) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&HorizontalPodAutoscaler{`, + `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "HorizontalPodAutoscalerSpec", "HorizontalPodAutoscalerSpec", 1), `&`, ``, 1) + `,`, + `Status:` + strings.Replace(strings.Replace(this.Status.String(), "HorizontalPodAutoscalerStatus", "HorizontalPodAutoscalerStatus", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *HorizontalPodAutoscalerBehavior) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&HorizontalPodAutoscalerBehavior{`, + `ScaleUp:` + strings.Replace(this.ScaleUp.String(), "HPAScalingRules", "HPAScalingRules", 1) + `,`, + `ScaleDown:` + strings.Replace(this.ScaleDown.String(), "HPAScalingRules", "HPAScalingRules", 1) + `,`, + `}`, + }, "") + return s +} +func (this *HorizontalPodAutoscalerCondition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&HorizontalPodAutoscalerCondition{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Status:` + fmt.Sprintf("%v", this.Status) + `,`, + `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, + `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `}`, + }, "") + return s +} +func (this *HorizontalPodAutoscalerList) String() string { + if this == nil { + return "nil" + } + repeatedStringForItems := "[]HorizontalPodAutoscaler{" + for _, f := range this.Items { + repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "HorizontalPodAutoscaler", "HorizontalPodAutoscaler", 1), `&`, ``, 1) + "," + } + repeatedStringForItems += "}" + s := strings.Join([]string{`&HorizontalPodAutoscalerList{`, + `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, + `Items:` + repeatedStringForItems + `,`, + `}`, + }, "") + return s +} +func (this *HorizontalPodAutoscalerSpec) String() string { + if this == nil { + return "nil" + } + repeatedStringForMetrics := "[]MetricSpec{" + for _, f := range this.Metrics { + repeatedStringForMetrics += strings.Replace(strings.Replace(f.String(), "MetricSpec", "MetricSpec", 1), `&`, ``, 1) + "," + } + repeatedStringForMetrics += "}" + s := strings.Join([]string{`&HorizontalPodAutoscalerSpec{`, + `ScaleTargetRef:` + strings.Replace(strings.Replace(this.ScaleTargetRef.String(), "CrossVersionObjectReference", "CrossVersionObjectReference", 1), `&`, ``, 1) + `,`, + `MinReplicas:` + valueToStringGenerated(this.MinReplicas) + `,`, + `MaxReplicas:` + fmt.Sprintf("%v", this.MaxReplicas) + `,`, + `Metrics:` + repeatedStringForMetrics + `,`, + `Behavior:` + strings.Replace(this.Behavior.String(), "HorizontalPodAutoscalerBehavior", "HorizontalPodAutoscalerBehavior", 1) + `,`, + `}`, + }, "") + return s +} +func (this *HorizontalPodAutoscalerStatus) String() string { + if this == nil { + return "nil" + } + repeatedStringForCurrentMetrics := "[]MetricStatus{" + for _, f := range this.CurrentMetrics { + repeatedStringForCurrentMetrics += strings.Replace(strings.Replace(f.String(), "MetricStatus", "MetricStatus", 1), `&`, ``, 1) + "," + } + repeatedStringForCurrentMetrics += "}" + repeatedStringForConditions := "[]HorizontalPodAutoscalerCondition{" + for _, f := range this.Conditions { + repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "HorizontalPodAutoscalerCondition", "HorizontalPodAutoscalerCondition", 1), `&`, ``, 1) + "," + } + repeatedStringForConditions += "}" + s := strings.Join([]string{`&HorizontalPodAutoscalerStatus{`, + `ObservedGeneration:` + valueToStringGenerated(this.ObservedGeneration) + `,`, + `LastScaleTime:` + strings.Replace(fmt.Sprintf("%v", this.LastScaleTime), "Time", "v1.Time", 1) + `,`, + `CurrentReplicas:` + fmt.Sprintf("%v", this.CurrentReplicas) + `,`, + `DesiredReplicas:` + fmt.Sprintf("%v", this.DesiredReplicas) + `,`, + `CurrentMetrics:` + repeatedStringForCurrentMetrics + `,`, + `Conditions:` + repeatedStringForConditions + `,`, + `}`, + }, "") + return s +} +func (this *MetricIdentifier) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MetricIdentifier{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`, + `}`, + }, "") + return s +} +func (this *MetricSpec) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MetricSpec{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Object:` + strings.Replace(this.Object.String(), "ObjectMetricSource", "ObjectMetricSource", 1) + `,`, + `Pods:` + strings.Replace(this.Pods.String(), "PodsMetricSource", "PodsMetricSource", 1) + `,`, + `Resource:` + strings.Replace(this.Resource.String(), "ResourceMetricSource", "ResourceMetricSource", 1) + `,`, + `External:` + strings.Replace(this.External.String(), "ExternalMetricSource", "ExternalMetricSource", 1) + `,`, + `ContainerResource:` + strings.Replace(this.ContainerResource.String(), "ContainerResourceMetricSource", "ContainerResourceMetricSource", 1) + `,`, + `}`, + }, "") + return s +} +func (this *MetricStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MetricStatus{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Object:` + strings.Replace(this.Object.String(), "ObjectMetricStatus", "ObjectMetricStatus", 1) + `,`, + `Pods:` + strings.Replace(this.Pods.String(), "PodsMetricStatus", "PodsMetricStatus", 1) + `,`, + `Resource:` + strings.Replace(this.Resource.String(), "ResourceMetricStatus", "ResourceMetricStatus", 1) + `,`, + `External:` + strings.Replace(this.External.String(), "ExternalMetricStatus", "ExternalMetricStatus", 1) + `,`, + `ContainerResource:` + strings.Replace(this.ContainerResource.String(), "ContainerResourceMetricStatus", "ContainerResourceMetricStatus", 1) + `,`, + `}`, + }, "") + return s +} +func (this *MetricTarget) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MetricTarget{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Value:` + strings.Replace(fmt.Sprintf("%v", this.Value), "Quantity", "resource.Quantity", 1) + `,`, + `AverageValue:` + strings.Replace(fmt.Sprintf("%v", this.AverageValue), "Quantity", "resource.Quantity", 1) + `,`, + `AverageUtilization:` + valueToStringGenerated(this.AverageUtilization) + `,`, + `}`, + }, "") + return s +} +func (this *MetricValueStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MetricValueStatus{`, + `Value:` + strings.Replace(fmt.Sprintf("%v", this.Value), "Quantity", "resource.Quantity", 1) + `,`, + `AverageValue:` + strings.Replace(fmt.Sprintf("%v", this.AverageValue), "Quantity", "resource.Quantity", 1) + `,`, + `AverageUtilization:` + valueToStringGenerated(this.AverageUtilization) + `,`, + `}`, + }, "") + return s +} +func (this *ObjectMetricSource) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ObjectMetricSource{`, + `DescribedObject:` + strings.Replace(strings.Replace(this.DescribedObject.String(), "CrossVersionObjectReference", "CrossVersionObjectReference", 1), `&`, ``, 1) + `,`, + `Target:` + strings.Replace(strings.Replace(this.Target.String(), "MetricTarget", "MetricTarget", 1), `&`, ``, 1) + `,`, + `Metric:` + strings.Replace(strings.Replace(this.Metric.String(), "MetricIdentifier", "MetricIdentifier", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *ObjectMetricStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ObjectMetricStatus{`, + `Metric:` + strings.Replace(strings.Replace(this.Metric.String(), "MetricIdentifier", "MetricIdentifier", 1), `&`, ``, 1) + `,`, + `Current:` + strings.Replace(strings.Replace(this.Current.String(), "MetricValueStatus", "MetricValueStatus", 1), `&`, ``, 1) + `,`, + `DescribedObject:` + strings.Replace(strings.Replace(this.DescribedObject.String(), "CrossVersionObjectReference", "CrossVersionObjectReference", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *PodsMetricSource) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PodsMetricSource{`, + `Metric:` + strings.Replace(strings.Replace(this.Metric.String(), "MetricIdentifier", "MetricIdentifier", 1), `&`, ``, 1) + `,`, + `Target:` + strings.Replace(strings.Replace(this.Target.String(), "MetricTarget", "MetricTarget", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *PodsMetricStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PodsMetricStatus{`, + `Metric:` + strings.Replace(strings.Replace(this.Metric.String(), "MetricIdentifier", "MetricIdentifier", 1), `&`, ``, 1) + `,`, + `Current:` + strings.Replace(strings.Replace(this.Current.String(), "MetricValueStatus", "MetricValueStatus", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *ResourceMetricSource) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ResourceMetricSource{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Target:` + strings.Replace(strings.Replace(this.Target.String(), "MetricTarget", "MetricTarget", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *ResourceMetricStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ResourceMetricStatus{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Current:` + strings.Replace(strings.Replace(this.Current.String(), "MetricValueStatus", "MetricValueStatus", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringGenerated(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *ContainerResourceMetricSource) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ContainerResourceMetricSource: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContainerResourceMetricSource: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Container = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ContainerResourceMetricStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ContainerResourceMetricStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContainerResourceMetricStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Current.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Container = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CrossVersionObjectReference) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CrossVersionObjectReference: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CrossVersionObjectReference: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Kind = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.APIVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExternalMetricSource) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExternalMetricSource: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExternalMetricSource: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metric.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExternalMetricStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExternalMetricStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExternalMetricStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metric.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Current.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HPAScalingPolicy) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HPAScalingPolicy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HPAScalingPolicy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = HPAScalingPolicyType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + m.Value = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Value |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PeriodSeconds", wireType) + } + m.PeriodSeconds = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PeriodSeconds |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HPAScalingRules) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HPAScalingRules: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HPAScalingRules: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SelectPolicy", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := ScalingPolicySelect(dAtA[iNdEx:postIndex]) + m.SelectPolicy = &s + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Policies", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Policies = append(m.Policies, HPAScalingPolicy{}) + if err := m.Policies[len(m.Policies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StabilizationWindowSeconds", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.StabilizationWindowSeconds = &v + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HorizontalPodAutoscaler) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HorizontalPodAutoscaler: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HorizontalPodAutoscaler: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HorizontalPodAutoscalerBehavior) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HorizontalPodAutoscalerBehavior: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HorizontalPodAutoscalerBehavior: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ScaleUp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ScaleUp == nil { + m.ScaleUp = &HPAScalingRules{} + } + if err := m.ScaleUp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ScaleDown", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ScaleDown == nil { + m.ScaleDown = &HPAScalingRules{} + } + if err := m.ScaleDown.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HorizontalPodAutoscalerCondition) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HorizontalPodAutoscalerCondition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HorizontalPodAutoscalerCondition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = HorizontalPodAutoscalerConditionType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HorizontalPodAutoscalerList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HorizontalPodAutoscalerList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HorizontalPodAutoscalerList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, HorizontalPodAutoscaler{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HorizontalPodAutoscalerSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HorizontalPodAutoscalerSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HorizontalPodAutoscalerSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ScaleTargetRef", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ScaleTargetRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinReplicas", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.MinReplicas = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxReplicas", wireType) + } + m.MaxReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Metrics = append(m.Metrics, MetricSpec{}) + if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Behavior", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Behavior == nil { + m.Behavior = &HorizontalPodAutoscalerBehavior{} + } + if err := m.Behavior.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HorizontalPodAutoscalerStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HorizontalPodAutoscalerStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HorizontalPodAutoscalerStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ObservedGeneration = &v + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastScaleTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LastScaleTime == nil { + m.LastScaleTime = &v1.Time{} + } + if err := m.LastScaleTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentReplicas", wireType) + } + m.CurrentReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CurrentReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DesiredReplicas", wireType) + } + m.DesiredReplicas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DesiredReplicas |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentMetrics", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CurrentMetrics = append(m.CurrentMetrics, MetricStatus{}) + if err := m.CurrentMetrics[len(m.CurrentMetrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Conditions = append(m.Conditions, HorizontalPodAutoscalerCondition{}) + if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MetricIdentifier) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MetricIdentifier: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MetricIdentifier: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Selector == nil { + m.Selector = &v1.LabelSelector{} + } + if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MetricSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MetricSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MetricSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = MetricSourceType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Object == nil { + m.Object = &ObjectMetricSource{} + } + if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pods == nil { + m.Pods = &PodsMetricSource{} + } + if err := m.Pods.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Resource == nil { + m.Resource = &ResourceMetricSource{} + } + if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field External", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.External == nil { + m.External = &ExternalMetricSource{} + } + if err := m.External.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContainerResource", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ContainerResource == nil { + m.ContainerResource = &ContainerResourceMetricSource{} + } + if err := m.ContainerResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MetricStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MetricStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MetricStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = MetricSourceType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Object == nil { + m.Object = &ObjectMetricStatus{} + } + if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pods == nil { + m.Pods = &PodsMetricStatus{} + } + if err := m.Pods.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Resource == nil { + m.Resource = &ResourceMetricStatus{} + } + if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field External", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.External == nil { + m.External = &ExternalMetricStatus{} + } + if err := m.External.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContainerResource", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ContainerResource == nil { + m.ContainerResource = &ContainerResourceMetricStatus{} + } + if err := m.ContainerResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MetricTarget) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MetricTarget: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MetricTarget: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = MetricTargetType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &resource.Quantity{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AverageValue", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AverageValue == nil { + m.AverageValue = &resource.Quantity{} + } + if err := m.AverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AverageUtilization", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AverageUtilization = &v + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MetricValueStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MetricValueStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MetricValueStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &resource.Quantity{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AverageValue", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AverageValue == nil { + m.AverageValue = &resource.Quantity{} + } + if err := m.AverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AverageUtilization", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AverageUtilization = &v + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ObjectMetricSource) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ObjectMetricSource: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ObjectMetricSource: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DescribedObject", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DescribedObject.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metric.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ObjectMetricStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ObjectMetricStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ObjectMetricStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metric.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Current.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DescribedObject", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DescribedObject.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PodsMetricSource) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PodsMetricSource: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PodsMetricSource: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metric.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PodsMetricStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PodsMetricStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PodsMetricStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metric.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Current.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResourceMetricSource) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResourceMetricSource: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResourceMetricSource: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResourceMetricStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResourceMetricStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResourceMetricStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Current.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenerated(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenerated + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenerated + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenerated + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group") +) diff --git a/vendor/k8s.io/api/autoscaling/v2/generated.proto b/vendor/k8s.io/api/autoscaling/v2/generated.proto new file mode 100644 index 0000000000..e47d94a476 --- /dev/null +++ b/vendor/k8s.io/api/autoscaling/v2/generated.proto @@ -0,0 +1,504 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + + +// This file was autogenerated by go-to-protobuf. Do not edit it manually! + +syntax = "proto2"; + +package k8s.io.api.autoscaling.v2; + +import "k8s.io/api/core/v1/generated.proto"; +import "k8s.io/apimachinery/pkg/api/resource/generated.proto"; +import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; +import "k8s.io/apimachinery/pkg/runtime/generated.proto"; +import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; + +// Package-wide variables from generator "generated". +option go_package = "v2"; + +// ContainerResourceMetricSource indicates how to scale on a resource metric known to +// Kubernetes, as specified in requests and limits, describing each pod in the +// current scale target (e.g. CPU or memory). The values will be averaged +// together before being compared to the target. Such metrics are built in to +// Kubernetes, and have special scaling options on top of those available to +// normal per-pod metrics using the "pods" source. Only one "target" type +// should be set. +message ContainerResourceMetricSource { + // name is the name of the resource in question. + optional string name = 1; + + // target specifies the target value for the given metric + optional MetricTarget target = 2; + + // container is the name of the container in the pods of the scaling target + optional string container = 3; +} + +// ContainerResourceMetricStatus indicates the current value of a resource metric known to +// Kubernetes, as specified in requests and limits, describing a single container in each pod in the +// current scale target (e.g. CPU or memory). Such metrics are built in to +// Kubernetes, and have special scaling options on top of those available to +// normal per-pod metrics using the "pods" source. +message ContainerResourceMetricStatus { + // Name is the name of the resource in question. + optional string name = 1; + + // current contains the current value for the given metric + optional MetricValueStatus current = 2; + + // Container is the name of the container in the pods of the scaling target + optional string container = 3; +} + +// CrossVersionObjectReference contains enough information to let you identify the referred resource. +message CrossVersionObjectReference { + // Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + optional string kind = 1; + + // Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names + optional string name = 2; + + // API version of the referent + // +optional + optional string apiVersion = 3; +} + +// ExternalMetricSource indicates how to scale on a metric not associated with +// any Kubernetes object (for example length of queue in cloud +// messaging service, or QPS from loadbalancer running outside of cluster). +message ExternalMetricSource { + // metric identifies the target metric by name and selector + optional MetricIdentifier metric = 1; + + // target specifies the target value for the given metric + optional MetricTarget target = 2; +} + +// ExternalMetricStatus indicates the current value of a global metric +// not associated with any Kubernetes object. +message ExternalMetricStatus { + // metric identifies the target metric by name and selector + optional MetricIdentifier metric = 1; + + // current contains the current value for the given metric + optional MetricValueStatus current = 2; +} + +// HPAScalingPolicy is a single policy which must hold true for a specified past interval. +message HPAScalingPolicy { + // Type is used to specify the scaling policy. + optional string type = 1; + + // Value contains the amount of change which is permitted by the policy. + // It must be greater than zero + optional int32 value = 2; + + // PeriodSeconds specifies the window of time for which the policy should hold true. + // PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). + optional int32 periodSeconds = 3; +} + +// HPAScalingRules configures the scaling behavior for one direction. +// These Rules are applied after calculating DesiredReplicas from metrics for the HPA. +// They can limit the scaling velocity by specifying scaling policies. +// They can prevent flapping by specifying the stabilization window, so that the +// number of replicas is not set instantly, instead, the safest value from the stabilization +// window is chosen. +message HPAScalingRules { + // StabilizationWindowSeconds is the number of seconds for which past recommendations should be + // considered while scaling up or scaling down. + // StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). + // If not set, use the default values: + // - For scale up: 0 (i.e. no stabilization is done). + // - For scale down: 300 (i.e. the stabilization window is 300 seconds long). + // +optional + optional int32 stabilizationWindowSeconds = 3; + + // selectPolicy is used to specify which policy should be used. + // If not set, the default value Max is used. + // +optional + optional string selectPolicy = 1; + + // policies is a list of potential scaling polices which can be used during scaling. + // At least one policy must be specified, otherwise the HPAScalingRules will be discarded as invalid + // +listType=atomic + // +optional + repeated HPAScalingPolicy policies = 2; +} + +// HorizontalPodAutoscaler is the configuration for a horizontal pod +// autoscaler, which automatically manages the replica count of any resource +// implementing the scale subresource based on the metrics specified. +message HorizontalPodAutoscaler { + // metadata is the standard object metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + + // spec is the specification for the behaviour of the autoscaler. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. + // +optional + optional HorizontalPodAutoscalerSpec spec = 2; + + // status is the current information about the autoscaler. + // +optional + optional HorizontalPodAutoscalerStatus status = 3; +} + +// HorizontalPodAutoscalerBehavior configures the scaling behavior of the target +// in both Up and Down directions (scaleUp and scaleDown fields respectively). +message HorizontalPodAutoscalerBehavior { + // scaleUp is scaling policy for scaling Up. + // If not set, the default value is the higher of: + // * increase no more than 4 pods per 60 seconds + // * double the number of pods per 60 seconds + // No stabilization is used. + // +optional + optional HPAScalingRules scaleUp = 1; + + // scaleDown is scaling policy for scaling Down. + // If not set, the default value is to allow to scale down to minReplicas pods, with a + // 300 second stabilization window (i.e., the highest recommendation for + // the last 300sec is used). + // +optional + optional HPAScalingRules scaleDown = 2; +} + +// HorizontalPodAutoscalerCondition describes the state of +// a HorizontalPodAutoscaler at a certain point. +message HorizontalPodAutoscalerCondition { + // type describes the current condition + optional string type = 1; + + // status is the status of the condition (True, False, Unknown) + optional string status = 2; + + // lastTransitionTime is the last time the condition transitioned from + // one status to another + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 3; + + // reason is the reason for the condition's last transition. + // +optional + optional string reason = 4; + + // message is a human-readable explanation containing details about + // the transition + // +optional + optional string message = 5; +} + +// HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects. +message HorizontalPodAutoscalerList { + // metadata is the standard list metadata. + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + + // items is the list of horizontal pod autoscaler objects. + repeated HorizontalPodAutoscaler items = 2; +} + +// HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. +message HorizontalPodAutoscalerSpec { + // scaleTargetRef points to the target resource to scale, and is used to the pods for which metrics + // should be collected, as well as to actually change the replica count. + optional CrossVersionObjectReference scaleTargetRef = 1; + + // minReplicas is the lower limit for the number of replicas to which the autoscaler + // can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the + // alpha feature gate HPAScaleToZero is enabled and at least one Object or External + // metric is configured. Scaling is active as long as at least one metric value is + // available. + // +optional + optional int32 minReplicas = 2; + + // maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. + // It cannot be less that minReplicas. + optional int32 maxReplicas = 3; + + // metrics contains the specifications for which to use to calculate the + // desired replica count (the maximum replica count across all metrics will + // be used). The desired replica count is calculated multiplying the + // ratio between the target value and the current value by the current + // number of pods. Ergo, metrics used must decrease as the pod count is + // increased, and vice-versa. See the individual metric source types for + // more information about how each type of metric must respond. + // If not set, the default metric will be set to 80% average CPU utilization. + // +listType=atomic + // +optional + repeated MetricSpec metrics = 4; + + // behavior configures the scaling behavior of the target + // in both Up and Down directions (scaleUp and scaleDown fields respectively). + // If not set, the default HPAScalingRules for scale up and scale down are used. + // +optional + optional HorizontalPodAutoscalerBehavior behavior = 5; +} + +// HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. +message HorizontalPodAutoscalerStatus { + // observedGeneration is the most recent generation observed by this autoscaler. + // +optional + optional int64 observedGeneration = 1; + + // lastScaleTime is the last time the HorizontalPodAutoscaler scaled the number of pods, + // used by the autoscaler to control how often the number of pods is changed. + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastScaleTime = 2; + + // currentReplicas is current number of replicas of pods managed by this autoscaler, + // as last seen by the autoscaler. + // +optional + optional int32 currentReplicas = 3; + + // desiredReplicas is the desired number of replicas of pods managed by this autoscaler, + // as last calculated by the autoscaler. + optional int32 desiredReplicas = 4; + + // currentMetrics is the last read state of the metrics used by this autoscaler. + // +listType=atomic + // +optional + repeated MetricStatus currentMetrics = 5; + + // conditions is the set of conditions required for this autoscaler to scale its target, + // and indicates whether or not those conditions are met. + // +patchMergeKey=type + // +patchStrategy=merge + // +listType=map + // +listMapKey=type + // +optional + repeated HorizontalPodAutoscalerCondition conditions = 6; +} + +// MetricIdentifier defines the name and optionally selector for a metric +message MetricIdentifier { + // name is the name of the given metric + optional string name = 1; + + // selector is the string-encoded form of a standard kubernetes label selector for the given metric + // When set, it is passed as an additional parameter to the metrics server for more specific metrics scoping. + // When unset, just the metricName will be used to gather metrics. + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 2; +} + +// MetricSpec specifies how to scale based on a single metric +// (only `type` and one other matching field should be set at once). +message MetricSpec { + // type is the type of metric source. It should be one of "ContainerResource", "External", + // "Object", "Pods" or "Resource", each mapping to a matching field in the object. + // Note: "ContainerResource" type is available on when the feature-gate + // HPAContainerMetrics is enabled + optional string type = 1; + + // object refers to a metric describing a single kubernetes object + // (for example, hits-per-second on an Ingress object). + // +optional + optional ObjectMetricSource object = 2; + + // pods refers to a metric describing each pod in the current scale target + // (for example, transactions-processed-per-second). The values will be + // averaged together before being compared to the target value. + // +optional + optional PodsMetricSource pods = 3; + + // resource refers to a resource metric (such as those specified in + // requests and limits) known to Kubernetes describing each pod in the + // current scale target (e.g. CPU or memory). Such metrics are built in to + // Kubernetes, and have special scaling options on top of those available + // to normal per-pod metrics using the "pods" source. + // +optional + optional ResourceMetricSource resource = 4; + + // containerResource refers to a resource metric (such as those specified in + // requests and limits) known to Kubernetes describing a single container in + // each pod of the current scale target (e.g. CPU or memory). Such metrics are + // built in to Kubernetes, and have special scaling options on top of those + // available to normal per-pod metrics using the "pods" source. + // This is an alpha feature and can be enabled by the HPAContainerMetrics feature flag. + // +optional + optional ContainerResourceMetricSource containerResource = 7; + + // external refers to a global metric that is not associated + // with any Kubernetes object. It allows autoscaling based on information + // coming from components running outside of cluster + // (for example length of queue in cloud messaging service, or + // QPS from loadbalancer running outside of cluster). + // +optional + optional ExternalMetricSource external = 5; +} + +// MetricStatus describes the last-read state of a single metric. +message MetricStatus { + // type is the type of metric source. It will be one of "ContainerResource", "External", + // "Object", "Pods" or "Resource", each corresponds to a matching field in the object. + // Note: "ContainerResource" type is available on when the feature-gate + // HPAContainerMetrics is enabled + optional string type = 1; + + // object refers to a metric describing a single kubernetes object + // (for example, hits-per-second on an Ingress object). + // +optional + optional ObjectMetricStatus object = 2; + + // pods refers to a metric describing each pod in the current scale target + // (for example, transactions-processed-per-second). The values will be + // averaged together before being compared to the target value. + // +optional + optional PodsMetricStatus pods = 3; + + // resource refers to a resource metric (such as those specified in + // requests and limits) known to Kubernetes describing each pod in the + // current scale target (e.g. CPU or memory). Such metrics are built in to + // Kubernetes, and have special scaling options on top of those available + // to normal per-pod metrics using the "pods" source. + // +optional + optional ResourceMetricStatus resource = 4; + + // container resource refers to a resource metric (such as those specified in + // requests and limits) known to Kubernetes describing a single container in each pod in the + // current scale target (e.g. CPU or memory). Such metrics are built in to + // Kubernetes, and have special scaling options on top of those available + // to normal per-pod metrics using the "pods" source. + // +optional + optional ContainerResourceMetricStatus containerResource = 7; + + // external refers to a global metric that is not associated + // with any Kubernetes object. It allows autoscaling based on information + // coming from components running outside of cluster + // (for example length of queue in cloud messaging service, or + // QPS from loadbalancer running outside of cluster). + // +optional + optional ExternalMetricStatus external = 5; +} + +// MetricTarget defines the target value, average value, or average utilization of a specific metric +message MetricTarget { + // type represents whether the metric type is Utilization, Value, or AverageValue + optional string type = 1; + + // value is the target value of the metric (as a quantity). + // +optional + optional k8s.io.apimachinery.pkg.api.resource.Quantity value = 2; + + // averageValue is the target value of the average of the + // metric across all relevant pods (as a quantity) + // +optional + optional k8s.io.apimachinery.pkg.api.resource.Quantity averageValue = 3; + + // averageUtilization is the target value of the average of the + // resource metric across all relevant pods, represented as a percentage of + // the requested value of the resource for the pods. + // Currently only valid for Resource metric source type + // +optional + optional int32 averageUtilization = 4; +} + +// MetricValueStatus holds the current value for a metric +message MetricValueStatus { + // value is the current value of the metric (as a quantity). + // +optional + optional k8s.io.apimachinery.pkg.api.resource.Quantity value = 1; + + // averageValue is the current value of the average of the + // metric across all relevant pods (as a quantity) + // +optional + optional k8s.io.apimachinery.pkg.api.resource.Quantity averageValue = 2; + + // currentAverageUtilization is the current value of the average of the + // resource metric across all relevant pods, represented as a percentage of + // the requested value of the resource for the pods. + // +optional + optional int32 averageUtilization = 3; +} + +// ObjectMetricSource indicates how to scale on a metric describing a +// kubernetes object (for example, hits-per-second on an Ingress object). +message ObjectMetricSource { + // describedObject specifies the descriptions of a object,such as kind,name apiVersion + optional CrossVersionObjectReference describedObject = 1; + + // target specifies the target value for the given metric + optional MetricTarget target = 2; + + // metric identifies the target metric by name and selector + optional MetricIdentifier metric = 3; +} + +// ObjectMetricStatus indicates the current value of a metric describing a +// kubernetes object (for example, hits-per-second on an Ingress object). +message ObjectMetricStatus { + // metric identifies the target metric by name and selector + optional MetricIdentifier metric = 1; + + // current contains the current value for the given metric + optional MetricValueStatus current = 2; + + // DescribedObject specifies the descriptions of a object,such as kind,name apiVersion + optional CrossVersionObjectReference describedObject = 3; +} + +// PodsMetricSource indicates how to scale on a metric describing each pod in +// the current scale target (for example, transactions-processed-per-second). +// The values will be averaged together before being compared to the target +// value. +message PodsMetricSource { + // metric identifies the target metric by name and selector + optional MetricIdentifier metric = 1; + + // target specifies the target value for the given metric + optional MetricTarget target = 2; +} + +// PodsMetricStatus indicates the current value of a metric describing each pod in +// the current scale target (for example, transactions-processed-per-second). +message PodsMetricStatus { + // metric identifies the target metric by name and selector + optional MetricIdentifier metric = 1; + + // current contains the current value for the given metric + optional MetricValueStatus current = 2; +} + +// ResourceMetricSource indicates how to scale on a resource metric known to +// Kubernetes, as specified in requests and limits, describing each pod in the +// current scale target (e.g. CPU or memory). The values will be averaged +// together before being compared to the target. Such metrics are built in to +// Kubernetes, and have special scaling options on top of those available to +// normal per-pod metrics using the "pods" source. Only one "target" type +// should be set. +message ResourceMetricSource { + // name is the name of the resource in question. + optional string name = 1; + + // target specifies the target value for the given metric + optional MetricTarget target = 2; +} + +// ResourceMetricStatus indicates the current value of a resource metric known to +// Kubernetes, as specified in requests and limits, describing each pod in the +// current scale target (e.g. CPU or memory). Such metrics are built in to +// Kubernetes, and have special scaling options on top of those available to +// normal per-pod metrics using the "pods" source. +message ResourceMetricStatus { + // Name is the name of the resource in question. + optional string name = 1; + + // current contains the current value for the given metric + optional MetricValueStatus current = 2; +} + diff --git a/vendor/k8s.io/api/autoscaling/v2/register.go b/vendor/k8s.io/api/autoscaling/v2/register.go new file mode 100644 index 0000000000..20f9ea5bb8 --- /dev/null +++ b/vendor/k8s.io/api/autoscaling/v2/register.go @@ -0,0 +1,50 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v2 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +// GroupName is the group name use in this package +const GroupName = "autoscaling" + +// SchemeGroupVersion is group version used to register these objects +var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v2"} + +// Resource takes an unqualified resource and returns a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +var ( + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + localSchemeBuilder = &SchemeBuilder + AddToScheme = localSchemeBuilder.AddToScheme +) + +// Adds the list of known types to the given scheme. +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &HorizontalPodAutoscaler{}, + &HorizontalPodAutoscalerList{}, + ) + metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/vendor/k8s.io/api/autoscaling/v2/types.go b/vendor/k8s.io/api/autoscaling/v2/types.go new file mode 100644 index 0000000000..9931f6146b --- /dev/null +++ b/vendor/k8s.io/api/autoscaling/v2/types.go @@ -0,0 +1,545 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// +k8s:openapi-gen=true + +package v2 + +import ( + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// HorizontalPodAutoscaler is the configuration for a horizontal pod +// autoscaler, which automatically manages the replica count of any resource +// implementing the scale subresource based on the metrics specified. +type HorizontalPodAutoscaler struct { + metav1.TypeMeta `json:",inline"` + // metadata is the standard object metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // spec is the specification for the behaviour of the autoscaler. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. + // +optional + Spec HorizontalPodAutoscalerSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` + + // status is the current information about the autoscaler. + // +optional + Status HorizontalPodAutoscalerStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"` +} + +// HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. +type HorizontalPodAutoscalerSpec struct { + // scaleTargetRef points to the target resource to scale, and is used to the pods for which metrics + // should be collected, as well as to actually change the replica count. + ScaleTargetRef CrossVersionObjectReference `json:"scaleTargetRef" protobuf:"bytes,1,opt,name=scaleTargetRef"` + // minReplicas is the lower limit for the number of replicas to which the autoscaler + // can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the + // alpha feature gate HPAScaleToZero is enabled and at least one Object or External + // metric is configured. Scaling is active as long as at least one metric value is + // available. + // +optional + MinReplicas *int32 `json:"minReplicas,omitempty" protobuf:"varint,2,opt,name=minReplicas"` + // maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. + // It cannot be less that minReplicas. + MaxReplicas int32 `json:"maxReplicas" protobuf:"varint,3,opt,name=maxReplicas"` + // metrics contains the specifications for which to use to calculate the + // desired replica count (the maximum replica count across all metrics will + // be used). The desired replica count is calculated multiplying the + // ratio between the target value and the current value by the current + // number of pods. Ergo, metrics used must decrease as the pod count is + // increased, and vice-versa. See the individual metric source types for + // more information about how each type of metric must respond. + // If not set, the default metric will be set to 80% average CPU utilization. + // +listType=atomic + // +optional + Metrics []MetricSpec `json:"metrics,omitempty" protobuf:"bytes,4,rep,name=metrics"` + + // behavior configures the scaling behavior of the target + // in both Up and Down directions (scaleUp and scaleDown fields respectively). + // If not set, the default HPAScalingRules for scale up and scale down are used. + // +optional + Behavior *HorizontalPodAutoscalerBehavior `json:"behavior,omitempty" protobuf:"bytes,5,opt,name=behavior"` +} + +// CrossVersionObjectReference contains enough information to let you identify the referred resource. +type CrossVersionObjectReference struct { + // Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" + Kind string `json:"kind" protobuf:"bytes,1,opt,name=kind"` + // Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names + Name string `json:"name" protobuf:"bytes,2,opt,name=name"` + // API version of the referent + // +optional + APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,3,opt,name=apiVersion"` +} + +// MetricSpec specifies how to scale based on a single metric +// (only `type` and one other matching field should be set at once). +type MetricSpec struct { + // type is the type of metric source. It should be one of "ContainerResource", "External", + // "Object", "Pods" or "Resource", each mapping to a matching field in the object. + // Note: "ContainerResource" type is available on when the feature-gate + // HPAContainerMetrics is enabled + Type MetricSourceType `json:"type" protobuf:"bytes,1,name=type"` + + // object refers to a metric describing a single kubernetes object + // (for example, hits-per-second on an Ingress object). + // +optional + Object *ObjectMetricSource `json:"object,omitempty" protobuf:"bytes,2,opt,name=object"` + // pods refers to a metric describing each pod in the current scale target + // (for example, transactions-processed-per-second). The values will be + // averaged together before being compared to the target value. + // +optional + Pods *PodsMetricSource `json:"pods,omitempty" protobuf:"bytes,3,opt,name=pods"` + // resource refers to a resource metric (such as those specified in + // requests and limits) known to Kubernetes describing each pod in the + // current scale target (e.g. CPU or memory). Such metrics are built in to + // Kubernetes, and have special scaling options on top of those available + // to normal per-pod metrics using the "pods" source. + // +optional + Resource *ResourceMetricSource `json:"resource,omitempty" protobuf:"bytes,4,opt,name=resource"` + // containerResource refers to a resource metric (such as those specified in + // requests and limits) known to Kubernetes describing a single container in + // each pod of the current scale target (e.g. CPU or memory). Such metrics are + // built in to Kubernetes, and have special scaling options on top of those + // available to normal per-pod metrics using the "pods" source. + // This is an alpha feature and can be enabled by the HPAContainerMetrics feature flag. + // +optional + ContainerResource *ContainerResourceMetricSource `json:"containerResource,omitempty" protobuf:"bytes,7,opt,name=containerResource"` + // external refers to a global metric that is not associated + // with any Kubernetes object. It allows autoscaling based on information + // coming from components running outside of cluster + // (for example length of queue in cloud messaging service, or + // QPS from loadbalancer running outside of cluster). + // +optional + External *ExternalMetricSource `json:"external,omitempty" protobuf:"bytes,5,opt,name=external"` +} + +// HorizontalPodAutoscalerBehavior configures the scaling behavior of the target +// in both Up and Down directions (scaleUp and scaleDown fields respectively). +type HorizontalPodAutoscalerBehavior struct { + // scaleUp is scaling policy for scaling Up. + // If not set, the default value is the higher of: + // * increase no more than 4 pods per 60 seconds + // * double the number of pods per 60 seconds + // No stabilization is used. + // +optional + ScaleUp *HPAScalingRules `json:"scaleUp,omitempty" protobuf:"bytes,1,opt,name=scaleUp"` + // scaleDown is scaling policy for scaling Down. + // If not set, the default value is to allow to scale down to minReplicas pods, with a + // 300 second stabilization window (i.e., the highest recommendation for + // the last 300sec is used). + // +optional + ScaleDown *HPAScalingRules `json:"scaleDown,omitempty" protobuf:"bytes,2,opt,name=scaleDown"` +} + +// ScalingPolicySelect is used to specify which policy should be used while scaling in a certain direction +type ScalingPolicySelect string + +const ( + // MaxChangePolicySelect selects the policy with the highest possible change. + MaxChangePolicySelect ScalingPolicySelect = "Max" + // MinChangePolicySelect selects the policy with the lowest possible change. + MinChangePolicySelect ScalingPolicySelect = "Min" + // DisabledPolicySelect disables the scaling in this direction. + DisabledPolicySelect ScalingPolicySelect = "Disabled" +) + +// HPAScalingRules configures the scaling behavior for one direction. +// These Rules are applied after calculating DesiredReplicas from metrics for the HPA. +// They can limit the scaling velocity by specifying scaling policies. +// They can prevent flapping by specifying the stabilization window, so that the +// number of replicas is not set instantly, instead, the safest value from the stabilization +// window is chosen. +type HPAScalingRules struct { + // StabilizationWindowSeconds is the number of seconds for which past recommendations should be + // considered while scaling up or scaling down. + // StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). + // If not set, use the default values: + // - For scale up: 0 (i.e. no stabilization is done). + // - For scale down: 300 (i.e. the stabilization window is 300 seconds long). + // +optional + StabilizationWindowSeconds *int32 `json:"stabilizationWindowSeconds,omitempty" protobuf:"varint,3,opt,name=stabilizationWindowSeconds"` + // selectPolicy is used to specify which policy should be used. + // If not set, the default value Max is used. + // +optional + SelectPolicy *ScalingPolicySelect `json:"selectPolicy,omitempty" protobuf:"bytes,1,opt,name=selectPolicy"` + // policies is a list of potential scaling polices which can be used during scaling. + // At least one policy must be specified, otherwise the HPAScalingRules will be discarded as invalid + // +listType=atomic + // +optional + Policies []HPAScalingPolicy `json:"policies,omitempty" listType:"atomic" protobuf:"bytes,2,rep,name=policies"` +} + +// HPAScalingPolicyType is the type of the policy which could be used while making scaling decisions. +type HPAScalingPolicyType string + +const ( + // PodsScalingPolicy is a policy used to specify a change in absolute number of pods. + PodsScalingPolicy HPAScalingPolicyType = "Pods" + // PercentScalingPolicy is a policy used to specify a relative amount of change with respect to + // the current number of pods. + PercentScalingPolicy HPAScalingPolicyType = "Percent" +) + +// HPAScalingPolicy is a single policy which must hold true for a specified past interval. +type HPAScalingPolicy struct { + // Type is used to specify the scaling policy. + Type HPAScalingPolicyType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=HPAScalingPolicyType"` + // Value contains the amount of change which is permitted by the policy. + // It must be greater than zero + Value int32 `json:"value" protobuf:"varint,2,opt,name=value"` + // PeriodSeconds specifies the window of time for which the policy should hold true. + // PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). + PeriodSeconds int32 `json:"periodSeconds" protobuf:"varint,3,opt,name=periodSeconds"` +} + +// MetricSourceType indicates the type of metric. +type MetricSourceType string + +const ( + // ObjectMetricSourceType is a metric describing a kubernetes object + // (for example, hits-per-second on an Ingress object). + ObjectMetricSourceType MetricSourceType = "Object" + // PodsMetricSourceType is a metric describing each pod in the current scale + // target (for example, transactions-processed-per-second). The values + // will be averaged together before being compared to the target value. + PodsMetricSourceType MetricSourceType = "Pods" + // ResourceMetricSourceType is a resource metric known to Kubernetes, as + // specified in requests and limits, describing each pod in the current + // scale target (e.g. CPU or memory). Such metrics are built in to + // Kubernetes, and have special scaling options on top of those available + // to normal per-pod metrics (the "pods" source). + ResourceMetricSourceType MetricSourceType = "Resource" + // ContainerResourceMetricSourceType is a resource metric known to Kubernetes, as + // specified in requests and limits, describing a single container in each pod in the current + // scale target (e.g. CPU or memory). Such metrics are built in to + // Kubernetes, and have special scaling options on top of those available + // to normal per-pod metrics (the "pods" source). + ContainerResourceMetricSourceType MetricSourceType = "ContainerResource" + // ExternalMetricSourceType is a global metric that is not associated + // with any Kubernetes object. It allows autoscaling based on information + // coming from components running outside of cluster + // (for example length of queue in cloud messaging service, or + // QPS from loadbalancer running outside of cluster). + ExternalMetricSourceType MetricSourceType = "External" +) + +// ObjectMetricSource indicates how to scale on a metric describing a +// kubernetes object (for example, hits-per-second on an Ingress object). +type ObjectMetricSource struct { + // describedObject specifies the descriptions of a object,such as kind,name apiVersion + DescribedObject CrossVersionObjectReference `json:"describedObject" protobuf:"bytes,1,name=describedObject"` + // target specifies the target value for the given metric + Target MetricTarget `json:"target" protobuf:"bytes,2,name=target"` + // metric identifies the target metric by name and selector + Metric MetricIdentifier `json:"metric" protobuf:"bytes,3,name=metric"` +} + +// PodsMetricSource indicates how to scale on a metric describing each pod in +// the current scale target (for example, transactions-processed-per-second). +// The values will be averaged together before being compared to the target +// value. +type PodsMetricSource struct { + // metric identifies the target metric by name and selector + Metric MetricIdentifier `json:"metric" protobuf:"bytes,1,name=metric"` + // target specifies the target value for the given metric + Target MetricTarget `json:"target" protobuf:"bytes,2,name=target"` +} + +// ResourceMetricSource indicates how to scale on a resource metric known to +// Kubernetes, as specified in requests and limits, describing each pod in the +// current scale target (e.g. CPU or memory). The values will be averaged +// together before being compared to the target. Such metrics are built in to +// Kubernetes, and have special scaling options on top of those available to +// normal per-pod metrics using the "pods" source. Only one "target" type +// should be set. +type ResourceMetricSource struct { + // name is the name of the resource in question. + Name v1.ResourceName `json:"name" protobuf:"bytes,1,name=name"` + // target specifies the target value for the given metric + Target MetricTarget `json:"target" protobuf:"bytes,2,name=target"` +} + +// ContainerResourceMetricSource indicates how to scale on a resource metric known to +// Kubernetes, as specified in requests and limits, describing each pod in the +// current scale target (e.g. CPU or memory). The values will be averaged +// together before being compared to the target. Such metrics are built in to +// Kubernetes, and have special scaling options on top of those available to +// normal per-pod metrics using the "pods" source. Only one "target" type +// should be set. +type ContainerResourceMetricSource struct { + // name is the name of the resource in question. + Name v1.ResourceName `json:"name" protobuf:"bytes,1,name=name"` + // target specifies the target value for the given metric + Target MetricTarget `json:"target" protobuf:"bytes,2,name=target"` + // container is the name of the container in the pods of the scaling target + Container string `json:"container" protobuf:"bytes,3,opt,name=container"` +} + +// ExternalMetricSource indicates how to scale on a metric not associated with +// any Kubernetes object (for example length of queue in cloud +// messaging service, or QPS from loadbalancer running outside of cluster). +type ExternalMetricSource struct { + // metric identifies the target metric by name and selector + Metric MetricIdentifier `json:"metric" protobuf:"bytes,1,name=metric"` + // target specifies the target value for the given metric + Target MetricTarget `json:"target" protobuf:"bytes,2,name=target"` +} + +// MetricIdentifier defines the name and optionally selector for a metric +type MetricIdentifier struct { + // name is the name of the given metric + Name string `json:"name" protobuf:"bytes,1,name=name"` + // selector is the string-encoded form of a standard kubernetes label selector for the given metric + // When set, it is passed as an additional parameter to the metrics server for more specific metrics scoping. + // When unset, just the metricName will be used to gather metrics. + // +optional + Selector *metav1.LabelSelector `json:"selector,omitempty" protobuf:"bytes,2,name=selector"` +} + +// MetricTarget defines the target value, average value, or average utilization of a specific metric +type MetricTarget struct { + // type represents whether the metric type is Utilization, Value, or AverageValue + Type MetricTargetType `json:"type" protobuf:"bytes,1,name=type"` + // value is the target value of the metric (as a quantity). + // +optional + Value *resource.Quantity `json:"value,omitempty" protobuf:"bytes,2,opt,name=value"` + // averageValue is the target value of the average of the + // metric across all relevant pods (as a quantity) + // +optional + AverageValue *resource.Quantity `json:"averageValue,omitempty" protobuf:"bytes,3,opt,name=averageValue"` + // averageUtilization is the target value of the average of the + // resource metric across all relevant pods, represented as a percentage of + // the requested value of the resource for the pods. + // Currently only valid for Resource metric source type + // +optional + AverageUtilization *int32 `json:"averageUtilization,omitempty" protobuf:"bytes,4,opt,name=averageUtilization"` +} + +// MetricTargetType specifies the type of metric being targeted, and should be either +// "Value", "AverageValue", or "Utilization" +type MetricTargetType string + +const ( + // UtilizationMetricType declares a MetricTarget is an AverageUtilization value + UtilizationMetricType MetricTargetType = "Utilization" + // ValueMetricType declares a MetricTarget is a raw value + ValueMetricType MetricTargetType = "Value" + // AverageValueMetricType declares a MetricTarget is an + AverageValueMetricType MetricTargetType = "AverageValue" +) + +// HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. +type HorizontalPodAutoscalerStatus struct { + // observedGeneration is the most recent generation observed by this autoscaler. + // +optional + ObservedGeneration *int64 `json:"observedGeneration,omitempty" protobuf:"varint,1,opt,name=observedGeneration"` + + // lastScaleTime is the last time the HorizontalPodAutoscaler scaled the number of pods, + // used by the autoscaler to control how often the number of pods is changed. + // +optional + LastScaleTime *metav1.Time `json:"lastScaleTime,omitempty" protobuf:"bytes,2,opt,name=lastScaleTime"` + + // currentReplicas is current number of replicas of pods managed by this autoscaler, + // as last seen by the autoscaler. + // +optional + CurrentReplicas int32 `json:"currentReplicas,omitempty" protobuf:"varint,3,opt,name=currentReplicas"` + + // desiredReplicas is the desired number of replicas of pods managed by this autoscaler, + // as last calculated by the autoscaler. + DesiredReplicas int32 `json:"desiredReplicas" protobuf:"varint,4,opt,name=desiredReplicas"` + + // currentMetrics is the last read state of the metrics used by this autoscaler. + // +listType=atomic + // +optional + CurrentMetrics []MetricStatus `json:"currentMetrics" protobuf:"bytes,5,rep,name=currentMetrics"` + + // conditions is the set of conditions required for this autoscaler to scale its target, + // and indicates whether or not those conditions are met. + // +patchMergeKey=type + // +patchStrategy=merge + // +listType=map + // +listMapKey=type + // +optional + Conditions []HorizontalPodAutoscalerCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" listType:"map" protobuf:"bytes,6,rep,name=conditions"` +} + +// HorizontalPodAutoscalerConditionType are the valid conditions of +// a HorizontalPodAutoscaler. +type HorizontalPodAutoscalerConditionType string + +const ( + // ScalingActive indicates that the HPA controller is able to scale if necessary: + // it's correctly configured, can fetch the desired metrics, and isn't disabled. + ScalingActive HorizontalPodAutoscalerConditionType = "ScalingActive" + // AbleToScale indicates a lack of transient issues which prevent scaling from occurring, + // such as being in a backoff window, or being unable to access/update the target scale. + AbleToScale HorizontalPodAutoscalerConditionType = "AbleToScale" + // ScalingLimited indicates that the calculated scale based on metrics would be above or + // below the range for the HPA, and has thus been capped. + ScalingLimited HorizontalPodAutoscalerConditionType = "ScalingLimited" +) + +// HorizontalPodAutoscalerCondition describes the state of +// a HorizontalPodAutoscaler at a certain point. +type HorizontalPodAutoscalerCondition struct { + // type describes the current condition + Type HorizontalPodAutoscalerConditionType `json:"type" protobuf:"bytes,1,name=type"` + // status is the status of the condition (True, False, Unknown) + Status v1.ConditionStatus `json:"status" protobuf:"bytes,2,name=status"` + // lastTransitionTime is the last time the condition transitioned from + // one status to another + // +optional + LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,3,opt,name=lastTransitionTime"` + // reason is the reason for the condition's last transition. + // +optional + Reason string `json:"reason,omitempty" protobuf:"bytes,4,opt,name=reason"` + // message is a human-readable explanation containing details about + // the transition + // +optional + Message string `json:"message,omitempty" protobuf:"bytes,5,opt,name=message"` +} + +// MetricStatus describes the last-read state of a single metric. +type MetricStatus struct { + // type is the type of metric source. It will be one of "ContainerResource", "External", + // "Object", "Pods" or "Resource", each corresponds to a matching field in the object. + // Note: "ContainerResource" type is available on when the feature-gate + // HPAContainerMetrics is enabled + Type MetricSourceType `json:"type" protobuf:"bytes,1,name=type"` + + // object refers to a metric describing a single kubernetes object + // (for example, hits-per-second on an Ingress object). + // +optional + Object *ObjectMetricStatus `json:"object,omitempty" protobuf:"bytes,2,opt,name=object"` + // pods refers to a metric describing each pod in the current scale target + // (for example, transactions-processed-per-second). The values will be + // averaged together before being compared to the target value. + // +optional + Pods *PodsMetricStatus `json:"pods,omitempty" protobuf:"bytes,3,opt,name=pods"` + // resource refers to a resource metric (such as those specified in + // requests and limits) known to Kubernetes describing each pod in the + // current scale target (e.g. CPU or memory). Such metrics are built in to + // Kubernetes, and have special scaling options on top of those available + // to normal per-pod metrics using the "pods" source. + // +optional + Resource *ResourceMetricStatus `json:"resource,omitempty" protobuf:"bytes,4,opt,name=resource"` + // container resource refers to a resource metric (such as those specified in + // requests and limits) known to Kubernetes describing a single container in each pod in the + // current scale target (e.g. CPU or memory). Such metrics are built in to + // Kubernetes, and have special scaling options on top of those available + // to normal per-pod metrics using the "pods" source. + // +optional + ContainerResource *ContainerResourceMetricStatus `json:"containerResource,omitempty" protobuf:"bytes,7,opt,name=containerResource"` + // external refers to a global metric that is not associated + // with any Kubernetes object. It allows autoscaling based on information + // coming from components running outside of cluster + // (for example length of queue in cloud messaging service, or + // QPS from loadbalancer running outside of cluster). + // +optional + External *ExternalMetricStatus `json:"external,omitempty" protobuf:"bytes,5,opt,name=external"` +} + +// ObjectMetricStatus indicates the current value of a metric describing a +// kubernetes object (for example, hits-per-second on an Ingress object). +type ObjectMetricStatus struct { + // metric identifies the target metric by name and selector + Metric MetricIdentifier `json:"metric" protobuf:"bytes,1,name=metric"` + // current contains the current value for the given metric + Current MetricValueStatus `json:"current" protobuf:"bytes,2,name=current"` + // DescribedObject specifies the descriptions of a object,such as kind,name apiVersion + DescribedObject CrossVersionObjectReference `json:"describedObject" protobuf:"bytes,3,name=describedObject"` +} + +// PodsMetricStatus indicates the current value of a metric describing each pod in +// the current scale target (for example, transactions-processed-per-second). +type PodsMetricStatus struct { + // metric identifies the target metric by name and selector + Metric MetricIdentifier `json:"metric" protobuf:"bytes,1,name=metric"` + // current contains the current value for the given metric + Current MetricValueStatus `json:"current" protobuf:"bytes,2,name=current"` +} + +// ResourceMetricStatus indicates the current value of a resource metric known to +// Kubernetes, as specified in requests and limits, describing each pod in the +// current scale target (e.g. CPU or memory). Such metrics are built in to +// Kubernetes, and have special scaling options on top of those available to +// normal per-pod metrics using the "pods" source. +type ResourceMetricStatus struct { + // Name is the name of the resource in question. + Name v1.ResourceName `json:"name" protobuf:"bytes,1,name=name"` + // current contains the current value for the given metric + Current MetricValueStatus `json:"current" protobuf:"bytes,2,name=current"` +} + +// ContainerResourceMetricStatus indicates the current value of a resource metric known to +// Kubernetes, as specified in requests and limits, describing a single container in each pod in the +// current scale target (e.g. CPU or memory). Such metrics are built in to +// Kubernetes, and have special scaling options on top of those available to +// normal per-pod metrics using the "pods" source. +type ContainerResourceMetricStatus struct { + // Name is the name of the resource in question. + Name v1.ResourceName `json:"name" protobuf:"bytes,1,name=name"` + // current contains the current value for the given metric + Current MetricValueStatus `json:"current" protobuf:"bytes,2,name=current"` + // Container is the name of the container in the pods of the scaling target + Container string `json:"container" protobuf:"bytes,3,opt,name=container"` +} + +// ExternalMetricStatus indicates the current value of a global metric +// not associated with any Kubernetes object. +type ExternalMetricStatus struct { + // metric identifies the target metric by name and selector + Metric MetricIdentifier `json:"metric" protobuf:"bytes,1,name=metric"` + // current contains the current value for the given metric + Current MetricValueStatus `json:"current" protobuf:"bytes,2,name=current"` +} + +// MetricValueStatus holds the current value for a metric +type MetricValueStatus struct { + // value is the current value of the metric (as a quantity). + // +optional + Value *resource.Quantity `json:"value,omitempty" protobuf:"bytes,1,opt,name=value"` + // averageValue is the current value of the average of the + // metric across all relevant pods (as a quantity) + // +optional + AverageValue *resource.Quantity `json:"averageValue,omitempty" protobuf:"bytes,2,opt,name=averageValue"` + // currentAverageUtilization is the current value of the average of the + // resource metric across all relevant pods, represented as a percentage of + // the requested value of the resource for the pods. + // +optional + AverageUtilization *int32 `json:"averageUtilization,omitempty" protobuf:"bytes,3,opt,name=averageUtilization"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects. +type HorizontalPodAutoscalerList struct { + metav1.TypeMeta `json:",inline"` + // metadata is the standard list metadata. + // +optional + metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // items is the list of horizontal pod autoscaler objects. + Items []HorizontalPodAutoscaler `json:"items" protobuf:"bytes,2,rep,name=items"` +} diff --git a/vendor/k8s.io/api/autoscaling/v2/types_swagger_doc_generated.go b/vendor/k8s.io/api/autoscaling/v2/types_swagger_doc_generated.go new file mode 100644 index 0000000000..05355a5523 --- /dev/null +++ b/vendor/k8s.io/api/autoscaling/v2/types_swagger_doc_generated.go @@ -0,0 +1,299 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v2 + +// This file contains a collection of methods that can be used from go-restful to +// generate Swagger API documentation for its models. Please read this PR for more +// information on the implementation: https://github.com/emicklei/go-restful/pull/215 +// +// TODOs are ignored from the parser (e.g. TODO(andronat):... || TODO:...) if and only if +// they are on one line! For multiple line or blocks that you want to ignore use ---. +// Any context after a --- is ignored. +// +// Those methods can be generated by using hack/update-generated-swagger-docs.sh + +// AUTO-GENERATED FUNCTIONS START HERE. DO NOT EDIT. +var map_ContainerResourceMetricSource = map[string]string{ + "": "ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. Only one \"target\" type should be set.", + "name": "name is the name of the resource in question.", + "target": "target specifies the target value for the given metric", + "container": "container is the name of the container in the pods of the scaling target", +} + +func (ContainerResourceMetricSource) SwaggerDoc() map[string]string { + return map_ContainerResourceMetricSource +} + +var map_ContainerResourceMetricStatus = map[string]string{ + "": "ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source.", + "name": "Name is the name of the resource in question.", + "current": "current contains the current value for the given metric", + "container": "Container is the name of the container in the pods of the scaling target", +} + +func (ContainerResourceMetricStatus) SwaggerDoc() map[string]string { + return map_ContainerResourceMetricStatus +} + +var map_CrossVersionObjectReference = map[string]string{ + "": "CrossVersionObjectReference contains enough information to let you identify the referred resource.", + "kind": "Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\"", + "name": "Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names", + "apiVersion": "API version of the referent", +} + +func (CrossVersionObjectReference) SwaggerDoc() map[string]string { + return map_CrossVersionObjectReference +} + +var map_ExternalMetricSource = map[string]string{ + "": "ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster).", + "metric": "metric identifies the target metric by name and selector", + "target": "target specifies the target value for the given metric", +} + +func (ExternalMetricSource) SwaggerDoc() map[string]string { + return map_ExternalMetricSource +} + +var map_ExternalMetricStatus = map[string]string{ + "": "ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object.", + "metric": "metric identifies the target metric by name and selector", + "current": "current contains the current value for the given metric", +} + +func (ExternalMetricStatus) SwaggerDoc() map[string]string { + return map_ExternalMetricStatus +} + +var map_HPAScalingPolicy = map[string]string{ + "": "HPAScalingPolicy is a single policy which must hold true for a specified past interval.", + "type": "Type is used to specify the scaling policy.", + "value": "Value contains the amount of change which is permitted by the policy. It must be greater than zero", + "periodSeconds": "PeriodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min).", +} + +func (HPAScalingPolicy) SwaggerDoc() map[string]string { + return map_HPAScalingPolicy +} + +var map_HPAScalingRules = map[string]string{ + "": "HPAScalingRules configures the scaling behavior for one direction. These Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen.", + "stabilizationWindowSeconds": "StabilizationWindowSeconds is the number of seconds for which past recommendations should be considered while scaling up or scaling down. StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). If not set, use the default values: - For scale up: 0 (i.e. no stabilization is done). - For scale down: 300 (i.e. the stabilization window is 300 seconds long).", + "selectPolicy": "selectPolicy is used to specify which policy should be used. If not set, the default value Max is used.", + "policies": "policies is a list of potential scaling polices which can be used during scaling. At least one policy must be specified, otherwise the HPAScalingRules will be discarded as invalid", +} + +func (HPAScalingRules) SwaggerDoc() map[string]string { + return map_HPAScalingRules +} + +var map_HorizontalPodAutoscaler = map[string]string{ + "": "HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified.", + "metadata": "metadata is the standard object metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "spec": "spec is the specification for the behaviour of the autoscaler. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status.", + "status": "status is the current information about the autoscaler.", +} + +func (HorizontalPodAutoscaler) SwaggerDoc() map[string]string { + return map_HorizontalPodAutoscaler +} + +var map_HorizontalPodAutoscalerBehavior = map[string]string{ + "": "HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively).", + "scaleUp": "scaleUp is scaling policy for scaling Up. If not set, the default value is the higher of:\n * increase no more than 4 pods per 60 seconds\n * double the number of pods per 60 seconds\nNo stabilization is used.", + "scaleDown": "scaleDown is scaling policy for scaling Down. If not set, the default value is to allow to scale down to minReplicas pods, with a 300 second stabilization window (i.e., the highest recommendation for the last 300sec is used).", +} + +func (HorizontalPodAutoscalerBehavior) SwaggerDoc() map[string]string { + return map_HorizontalPodAutoscalerBehavior +} + +var map_HorizontalPodAutoscalerCondition = map[string]string{ + "": "HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point.", + "type": "type describes the current condition", + "status": "status is the status of the condition (True, False, Unknown)", + "lastTransitionTime": "lastTransitionTime is the last time the condition transitioned from one status to another", + "reason": "reason is the reason for the condition's last transition.", + "message": "message is a human-readable explanation containing details about the transition", +} + +func (HorizontalPodAutoscalerCondition) SwaggerDoc() map[string]string { + return map_HorizontalPodAutoscalerCondition +} + +var map_HorizontalPodAutoscalerList = map[string]string{ + "": "HorizontalPodAutoscalerList is a list of horizontal pod autoscaler objects.", + "metadata": "metadata is the standard list metadata.", + "items": "items is the list of horizontal pod autoscaler objects.", +} + +func (HorizontalPodAutoscalerList) SwaggerDoc() map[string]string { + return map_HorizontalPodAutoscalerList +} + +var map_HorizontalPodAutoscalerSpec = map[string]string{ + "": "HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler.", + "scaleTargetRef": "scaleTargetRef points to the target resource to scale, and is used to the pods for which metrics should be collected, as well as to actually change the replica count.", + "minReplicas": "minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available.", + "maxReplicas": "maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas.", + "metrics": "metrics contains the specifications for which to use to calculate the desired replica count (the maximum replica count across all metrics will be used). The desired replica count is calculated multiplying the ratio between the target value and the current value by the current number of pods. Ergo, metrics used must decrease as the pod count is increased, and vice-versa. See the individual metric source types for more information about how each type of metric must respond. If not set, the default metric will be set to 80% average CPU utilization.", + "behavior": "behavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). If not set, the default HPAScalingRules for scale up and scale down are used.", +} + +func (HorizontalPodAutoscalerSpec) SwaggerDoc() map[string]string { + return map_HorizontalPodAutoscalerSpec +} + +var map_HorizontalPodAutoscalerStatus = map[string]string{ + "": "HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler.", + "observedGeneration": "observedGeneration is the most recent generation observed by this autoscaler.", + "lastScaleTime": "lastScaleTime is the last time the HorizontalPodAutoscaler scaled the number of pods, used by the autoscaler to control how often the number of pods is changed.", + "currentReplicas": "currentReplicas is current number of replicas of pods managed by this autoscaler, as last seen by the autoscaler.", + "desiredReplicas": "desiredReplicas is the desired number of replicas of pods managed by this autoscaler, as last calculated by the autoscaler.", + "currentMetrics": "currentMetrics is the last read state of the metrics used by this autoscaler.", + "conditions": "conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met.", +} + +func (HorizontalPodAutoscalerStatus) SwaggerDoc() map[string]string { + return map_HorizontalPodAutoscalerStatus +} + +var map_MetricIdentifier = map[string]string{ + "": "MetricIdentifier defines the name and optionally selector for a metric", + "name": "name is the name of the given metric", + "selector": "selector is the string-encoded form of a standard kubernetes label selector for the given metric When set, it is passed as an additional parameter to the metrics server for more specific metrics scoping. When unset, just the metricName will be used to gather metrics.", +} + +func (MetricIdentifier) SwaggerDoc() map[string]string { + return map_MetricIdentifier +} + +var map_MetricSpec = map[string]string{ + "": "MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once).", + "type": "type is the type of metric source. It should be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each mapping to a matching field in the object. Note: \"ContainerResource\" type is available on when the feature-gate HPAContainerMetrics is enabled", + "object": "object refers to a metric describing a single kubernetes object (for example, hits-per-second on an Ingress object).", + "pods": "pods refers to a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value.", + "resource": "resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source.", + "containerResource": "containerResource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod of the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. This is an alpha feature and can be enabled by the HPAContainerMetrics feature flag.", + "external": "external refers to a global metric that is not associated with any Kubernetes object. It allows autoscaling based on information coming from components running outside of cluster (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster).", +} + +func (MetricSpec) SwaggerDoc() map[string]string { + return map_MetricSpec +} + +var map_MetricStatus = map[string]string{ + "": "MetricStatus describes the last-read state of a single metric.", + "type": "type is the type of metric source. It will be one of \"ContainerResource\", \"External\", \"Object\", \"Pods\" or \"Resource\", each corresponds to a matching field in the object. Note: \"ContainerResource\" type is available on when the feature-gate HPAContainerMetrics is enabled", + "object": "object refers to a metric describing a single kubernetes object (for example, hits-per-second on an Ingress object).", + "pods": "pods refers to a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value.", + "resource": "resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source.", + "containerResource": "container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source.", + "external": "external refers to a global metric that is not associated with any Kubernetes object. It allows autoscaling based on information coming from components running outside of cluster (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster).", +} + +func (MetricStatus) SwaggerDoc() map[string]string { + return map_MetricStatus +} + +var map_MetricTarget = map[string]string{ + "": "MetricTarget defines the target value, average value, or average utilization of a specific metric", + "type": "type represents whether the metric type is Utilization, Value, or AverageValue", + "value": "value is the target value of the metric (as a quantity).", + "averageValue": "averageValue is the target value of the average of the metric across all relevant pods (as a quantity)", + "averageUtilization": "averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type", +} + +func (MetricTarget) SwaggerDoc() map[string]string { + return map_MetricTarget +} + +var map_MetricValueStatus = map[string]string{ + "": "MetricValueStatus holds the current value for a metric", + "value": "value is the current value of the metric (as a quantity).", + "averageValue": "averageValue is the current value of the average of the metric across all relevant pods (as a quantity)", + "averageUtilization": "currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods.", +} + +func (MetricValueStatus) SwaggerDoc() map[string]string { + return map_MetricValueStatus +} + +var map_ObjectMetricSource = map[string]string{ + "": "ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).", + "describedObject": "describedObject specifies the descriptions of a object,such as kind,name apiVersion", + "target": "target specifies the target value for the given metric", + "metric": "metric identifies the target metric by name and selector", +} + +func (ObjectMetricSource) SwaggerDoc() map[string]string { + return map_ObjectMetricSource +} + +var map_ObjectMetricStatus = map[string]string{ + "": "ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).", + "metric": "metric identifies the target metric by name and selector", + "current": "current contains the current value for the given metric", + "describedObject": "DescribedObject specifies the descriptions of a object,such as kind,name apiVersion", +} + +func (ObjectMetricStatus) SwaggerDoc() map[string]string { + return map_ObjectMetricStatus +} + +var map_PodsMetricSource = map[string]string{ + "": "PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value.", + "metric": "metric identifies the target metric by name and selector", + "target": "target specifies the target value for the given metric", +} + +func (PodsMetricSource) SwaggerDoc() map[string]string { + return map_PodsMetricSource +} + +var map_PodsMetricStatus = map[string]string{ + "": "PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second).", + "metric": "metric identifies the target metric by name and selector", + "current": "current contains the current value for the given metric", +} + +func (PodsMetricStatus) SwaggerDoc() map[string]string { + return map_PodsMetricStatus +} + +var map_ResourceMetricSource = map[string]string{ + "": "ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. Only one \"target\" type should be set.", + "name": "name is the name of the resource in question.", + "target": "target specifies the target value for the given metric", +} + +func (ResourceMetricSource) SwaggerDoc() map[string]string { + return map_ResourceMetricSource +} + +var map_ResourceMetricStatus = map[string]string{ + "": "ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source.", + "name": "Name is the name of the resource in question.", + "current": "current contains the current value for the given metric", +} + +func (ResourceMetricStatus) SwaggerDoc() map[string]string { + return map_ResourceMetricStatus +} + +// AUTO-GENERATED FUNCTIONS END HERE diff --git a/vendor/k8s.io/api/autoscaling/v2/zz_generated.deepcopy.go b/vendor/k8s.io/api/autoscaling/v2/zz_generated.deepcopy.go new file mode 100644 index 0000000000..125708d6fd --- /dev/null +++ b/vendor/k8s.io/api/autoscaling/v2/zz_generated.deepcopy.go @@ -0,0 +1,610 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package v2 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ContainerResourceMetricSource) DeepCopyInto(out *ContainerResourceMetricSource) { + *out = *in + in.Target.DeepCopyInto(&out.Target) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerResourceMetricSource. +func (in *ContainerResourceMetricSource) DeepCopy() *ContainerResourceMetricSource { + if in == nil { + return nil + } + out := new(ContainerResourceMetricSource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ContainerResourceMetricStatus) DeepCopyInto(out *ContainerResourceMetricStatus) { + *out = *in + in.Current.DeepCopyInto(&out.Current) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerResourceMetricStatus. +func (in *ContainerResourceMetricStatus) DeepCopy() *ContainerResourceMetricStatus { + if in == nil { + return nil + } + out := new(ContainerResourceMetricStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CrossVersionObjectReference) DeepCopyInto(out *CrossVersionObjectReference) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CrossVersionObjectReference. +func (in *CrossVersionObjectReference) DeepCopy() *CrossVersionObjectReference { + if in == nil { + return nil + } + out := new(CrossVersionObjectReference) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExternalMetricSource) DeepCopyInto(out *ExternalMetricSource) { + *out = *in + in.Metric.DeepCopyInto(&out.Metric) + in.Target.DeepCopyInto(&out.Target) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalMetricSource. +func (in *ExternalMetricSource) DeepCopy() *ExternalMetricSource { + if in == nil { + return nil + } + out := new(ExternalMetricSource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExternalMetricStatus) DeepCopyInto(out *ExternalMetricStatus) { + *out = *in + in.Metric.DeepCopyInto(&out.Metric) + in.Current.DeepCopyInto(&out.Current) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalMetricStatus. +func (in *ExternalMetricStatus) DeepCopy() *ExternalMetricStatus { + if in == nil { + return nil + } + out := new(ExternalMetricStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HPAScalingPolicy) DeepCopyInto(out *HPAScalingPolicy) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HPAScalingPolicy. +func (in *HPAScalingPolicy) DeepCopy() *HPAScalingPolicy { + if in == nil { + return nil + } + out := new(HPAScalingPolicy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HPAScalingRules) DeepCopyInto(out *HPAScalingRules) { + *out = *in + if in.StabilizationWindowSeconds != nil { + in, out := &in.StabilizationWindowSeconds, &out.StabilizationWindowSeconds + *out = new(int32) + **out = **in + } + if in.SelectPolicy != nil { + in, out := &in.SelectPolicy, &out.SelectPolicy + *out = new(ScalingPolicySelect) + **out = **in + } + if in.Policies != nil { + in, out := &in.Policies, &out.Policies + *out = make([]HPAScalingPolicy, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HPAScalingRules. +func (in *HPAScalingRules) DeepCopy() *HPAScalingRules { + if in == nil { + return nil + } + out := new(HPAScalingRules) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HorizontalPodAutoscaler) DeepCopyInto(out *HorizontalPodAutoscaler) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscaler. +func (in *HorizontalPodAutoscaler) DeepCopy() *HorizontalPodAutoscaler { + if in == nil { + return nil + } + out := new(HorizontalPodAutoscaler) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *HorizontalPodAutoscaler) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HorizontalPodAutoscalerBehavior) DeepCopyInto(out *HorizontalPodAutoscalerBehavior) { + *out = *in + if in.ScaleUp != nil { + in, out := &in.ScaleUp, &out.ScaleUp + *out = new(HPAScalingRules) + (*in).DeepCopyInto(*out) + } + if in.ScaleDown != nil { + in, out := &in.ScaleDown, &out.ScaleDown + *out = new(HPAScalingRules) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerBehavior. +func (in *HorizontalPodAutoscalerBehavior) DeepCopy() *HorizontalPodAutoscalerBehavior { + if in == nil { + return nil + } + out := new(HorizontalPodAutoscalerBehavior) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HorizontalPodAutoscalerCondition) DeepCopyInto(out *HorizontalPodAutoscalerCondition) { + *out = *in + in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerCondition. +func (in *HorizontalPodAutoscalerCondition) DeepCopy() *HorizontalPodAutoscalerCondition { + if in == nil { + return nil + } + out := new(HorizontalPodAutoscalerCondition) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HorizontalPodAutoscalerList) DeepCopyInto(out *HorizontalPodAutoscalerList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]HorizontalPodAutoscaler, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerList. +func (in *HorizontalPodAutoscalerList) DeepCopy() *HorizontalPodAutoscalerList { + if in == nil { + return nil + } + out := new(HorizontalPodAutoscalerList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *HorizontalPodAutoscalerList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HorizontalPodAutoscalerSpec) DeepCopyInto(out *HorizontalPodAutoscalerSpec) { + *out = *in + out.ScaleTargetRef = in.ScaleTargetRef + if in.MinReplicas != nil { + in, out := &in.MinReplicas, &out.MinReplicas + *out = new(int32) + **out = **in + } + if in.Metrics != nil { + in, out := &in.Metrics, &out.Metrics + *out = make([]MetricSpec, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Behavior != nil { + in, out := &in.Behavior, &out.Behavior + *out = new(HorizontalPodAutoscalerBehavior) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerSpec. +func (in *HorizontalPodAutoscalerSpec) DeepCopy() *HorizontalPodAutoscalerSpec { + if in == nil { + return nil + } + out := new(HorizontalPodAutoscalerSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HorizontalPodAutoscalerStatus) DeepCopyInto(out *HorizontalPodAutoscalerStatus) { + *out = *in + if in.ObservedGeneration != nil { + in, out := &in.ObservedGeneration, &out.ObservedGeneration + *out = new(int64) + **out = **in + } + if in.LastScaleTime != nil { + in, out := &in.LastScaleTime, &out.LastScaleTime + *out = (*in).DeepCopy() + } + if in.CurrentMetrics != nil { + in, out := &in.CurrentMetrics, &out.CurrentMetrics + *out = make([]MetricStatus, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]HorizontalPodAutoscalerCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerStatus. +func (in *HorizontalPodAutoscalerStatus) DeepCopy() *HorizontalPodAutoscalerStatus { + if in == nil { + return nil + } + out := new(HorizontalPodAutoscalerStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricIdentifier) DeepCopyInto(out *MetricIdentifier) { + *out = *in + if in.Selector != nil { + in, out := &in.Selector, &out.Selector + *out = new(v1.LabelSelector) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricIdentifier. +func (in *MetricIdentifier) DeepCopy() *MetricIdentifier { + if in == nil { + return nil + } + out := new(MetricIdentifier) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricSpec) DeepCopyInto(out *MetricSpec) { + *out = *in + if in.Object != nil { + in, out := &in.Object, &out.Object + *out = new(ObjectMetricSource) + (*in).DeepCopyInto(*out) + } + if in.Pods != nil { + in, out := &in.Pods, &out.Pods + *out = new(PodsMetricSource) + (*in).DeepCopyInto(*out) + } + if in.Resource != nil { + in, out := &in.Resource, &out.Resource + *out = new(ResourceMetricSource) + (*in).DeepCopyInto(*out) + } + if in.ContainerResource != nil { + in, out := &in.ContainerResource, &out.ContainerResource + *out = new(ContainerResourceMetricSource) + (*in).DeepCopyInto(*out) + } + if in.External != nil { + in, out := &in.External, &out.External + *out = new(ExternalMetricSource) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricSpec. +func (in *MetricSpec) DeepCopy() *MetricSpec { + if in == nil { + return nil + } + out := new(MetricSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricStatus) DeepCopyInto(out *MetricStatus) { + *out = *in + if in.Object != nil { + in, out := &in.Object, &out.Object + *out = new(ObjectMetricStatus) + (*in).DeepCopyInto(*out) + } + if in.Pods != nil { + in, out := &in.Pods, &out.Pods + *out = new(PodsMetricStatus) + (*in).DeepCopyInto(*out) + } + if in.Resource != nil { + in, out := &in.Resource, &out.Resource + *out = new(ResourceMetricStatus) + (*in).DeepCopyInto(*out) + } + if in.ContainerResource != nil { + in, out := &in.ContainerResource, &out.ContainerResource + *out = new(ContainerResourceMetricStatus) + (*in).DeepCopyInto(*out) + } + if in.External != nil { + in, out := &in.External, &out.External + *out = new(ExternalMetricStatus) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricStatus. +func (in *MetricStatus) DeepCopy() *MetricStatus { + if in == nil { + return nil + } + out := new(MetricStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricTarget) DeepCopyInto(out *MetricTarget) { + *out = *in + if in.Value != nil { + in, out := &in.Value, &out.Value + x := (*in).DeepCopy() + *out = &x + } + if in.AverageValue != nil { + in, out := &in.AverageValue, &out.AverageValue + x := (*in).DeepCopy() + *out = &x + } + if in.AverageUtilization != nil { + in, out := &in.AverageUtilization, &out.AverageUtilization + *out = new(int32) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricTarget. +func (in *MetricTarget) DeepCopy() *MetricTarget { + if in == nil { + return nil + } + out := new(MetricTarget) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricValueStatus) DeepCopyInto(out *MetricValueStatus) { + *out = *in + if in.Value != nil { + in, out := &in.Value, &out.Value + x := (*in).DeepCopy() + *out = &x + } + if in.AverageValue != nil { + in, out := &in.AverageValue, &out.AverageValue + x := (*in).DeepCopy() + *out = &x + } + if in.AverageUtilization != nil { + in, out := &in.AverageUtilization, &out.AverageUtilization + *out = new(int32) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricValueStatus. +func (in *MetricValueStatus) DeepCopy() *MetricValueStatus { + if in == nil { + return nil + } + out := new(MetricValueStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ObjectMetricSource) DeepCopyInto(out *ObjectMetricSource) { + *out = *in + out.DescribedObject = in.DescribedObject + in.Target.DeepCopyInto(&out.Target) + in.Metric.DeepCopyInto(&out.Metric) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectMetricSource. +func (in *ObjectMetricSource) DeepCopy() *ObjectMetricSource { + if in == nil { + return nil + } + out := new(ObjectMetricSource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ObjectMetricStatus) DeepCopyInto(out *ObjectMetricStatus) { + *out = *in + in.Metric.DeepCopyInto(&out.Metric) + in.Current.DeepCopyInto(&out.Current) + out.DescribedObject = in.DescribedObject + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectMetricStatus. +func (in *ObjectMetricStatus) DeepCopy() *ObjectMetricStatus { + if in == nil { + return nil + } + out := new(ObjectMetricStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PodsMetricSource) DeepCopyInto(out *PodsMetricSource) { + *out = *in + in.Metric.DeepCopyInto(&out.Metric) + in.Target.DeepCopyInto(&out.Target) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodsMetricSource. +func (in *PodsMetricSource) DeepCopy() *PodsMetricSource { + if in == nil { + return nil + } + out := new(PodsMetricSource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PodsMetricStatus) DeepCopyInto(out *PodsMetricStatus) { + *out = *in + in.Metric.DeepCopyInto(&out.Metric) + in.Current.DeepCopyInto(&out.Current) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodsMetricStatus. +func (in *PodsMetricStatus) DeepCopy() *PodsMetricStatus { + if in == nil { + return nil + } + out := new(PodsMetricStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourceMetricSource) DeepCopyInto(out *ResourceMetricSource) { + *out = *in + in.Target.DeepCopyInto(&out.Target) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceMetricSource. +func (in *ResourceMetricSource) DeepCopy() *ResourceMetricSource { + if in == nil { + return nil + } + out := new(ResourceMetricSource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourceMetricStatus) DeepCopyInto(out *ResourceMetricStatus) { + *out = *in + in.Current.DeepCopyInto(&out.Current) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceMetricStatus. +func (in *ResourceMetricStatus) DeepCopy() *ResourceMetricStatus { + if in == nil { + return nil + } + out := new(ResourceMetricStatus) + in.DeepCopyInto(out) + return out +} diff --git a/vendor/k8s.io/api/autoscaling/v2beta1/generated.proto b/vendor/k8s.io/api/autoscaling/v2beta1/generated.proto index 5ad55fa727..27f9ab45c4 100644 --- a/vendor/k8s.io/api/autoscaling/v2beta1/generated.proto +++ b/vendor/k8s.io/api/autoscaling/v2beta1/generated.proto @@ -248,6 +248,7 @@ message HorizontalPodAutoscalerStatus { // conditions is the set of conditions required for this autoscaler to scale its target, // and indicates whether or not those conditions are met. + // +optional repeated HorizontalPodAutoscalerCondition conditions = 6; } diff --git a/vendor/k8s.io/api/autoscaling/v2beta1/types.go b/vendor/k8s.io/api/autoscaling/v2beta1/types.go index 05023d9bcf..22bb7699e9 100644 --- a/vendor/k8s.io/api/autoscaling/v2beta1/types.go +++ b/vendor/k8s.io/api/autoscaling/v2beta1/types.go @@ -264,6 +264,7 @@ type HorizontalPodAutoscalerStatus struct { // conditions is the set of conditions required for this autoscaler to scale its target, // and indicates whether or not those conditions are met. + // +optional Conditions []HorizontalPodAutoscalerCondition `json:"conditions" protobuf:"bytes,6,rep,name=conditions"` } @@ -448,7 +449,7 @@ type ExternalMetricStatus struct { // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object // +k8s:prerelease-lifecycle-gen:introduced=1.8 // +k8s:prerelease-lifecycle-gen:deprecated=1.22 -// +k8s:prerelease-lifecycle-gen:replacement=autoscaling,v2beta2,HorizontalPodAutoscaler +// +k8s:prerelease-lifecycle-gen:replacement=autoscaling,v2,HorizontalPodAutoscaler // HorizontalPodAutoscaler is the configuration for a horizontal pod // autoscaler, which automatically manages the replica count of any resource diff --git a/vendor/k8s.io/api/autoscaling/v2beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/autoscaling/v2beta1/zz_generated.deepcopy.go index f10c7884d0..610e81f81a 100644 --- a/vendor/k8s.io/api/autoscaling/v2beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/autoscaling/v2beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/autoscaling/v2beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/autoscaling/v2beta1/zz_generated.prerelease-lifecycle.go index f6baef6997..3437454ee3 100644 --- a/vendor/k8s.io/api/autoscaling/v2beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/autoscaling/v2beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -39,7 +40,7 @@ func (in *HorizontalPodAutoscaler) APILifecycleDeprecated() (major, minor int) { // APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. // It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. func (in *HorizontalPodAutoscaler) APILifecycleReplacement() schema.GroupVersionKind { - return schema.GroupVersionKind{Group: "autoscaling", Version: "v2beta2", Kind: "HorizontalPodAutoscaler"} + return schema.GroupVersionKind{Group: "autoscaling", Version: "v2", Kind: "HorizontalPodAutoscaler"} } // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. diff --git a/vendor/k8s.io/api/autoscaling/v2beta2/generated.proto b/vendor/k8s.io/api/autoscaling/v2beta2/generated.proto index 77a6cb379e..7dee144704 100644 --- a/vendor/k8s.io/api/autoscaling/v2beta2/generated.proto +++ b/vendor/k8s.io/api/autoscaling/v2beta2/generated.proto @@ -272,6 +272,7 @@ message HorizontalPodAutoscalerStatus { // conditions is the set of conditions required for this autoscaler to scale its target, // and indicates whether or not those conditions are met. + // +optional repeated HorizontalPodAutoscalerCondition conditions = 6; } diff --git a/vendor/k8s.io/api/autoscaling/v2beta2/types.go b/vendor/k8s.io/api/autoscaling/v2beta2/types.go index 1be548d0af..10bdec5b94 100644 --- a/vendor/k8s.io/api/autoscaling/v2beta2/types.go +++ b/vendor/k8s.io/api/autoscaling/v2beta2/types.go @@ -28,6 +28,7 @@ import ( // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object // +k8s:prerelease-lifecycle-gen:introduced=1.12 // +k8s:prerelease-lifecycle-gen:deprecated=1.23 +// +k8s:prerelease-lifecycle-gen:replacement=autoscaling,v2,HorizontalPodAutoscaler // HorizontalPodAutoscaler is the configuration for a horizontal pod // autoscaler, which automatically manages the replica count of any resource @@ -373,6 +374,7 @@ type HorizontalPodAutoscalerStatus struct { // conditions is the set of conditions required for this autoscaler to scale its target, // and indicates whether or not those conditions are met. + // +optional Conditions []HorizontalPodAutoscalerCondition `json:"conditions" protobuf:"bytes,6,rep,name=conditions"` } diff --git a/vendor/k8s.io/api/autoscaling/v2beta2/zz_generated.deepcopy.go b/vendor/k8s.io/api/autoscaling/v2beta2/zz_generated.deepcopy.go index 81642822a6..49838843c0 100644 --- a/vendor/k8s.io/api/autoscaling/v2beta2/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/autoscaling/v2beta2/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/autoscaling/v2beta2/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/autoscaling/v2beta2/zz_generated.prerelease-lifecycle.go index c77892c992..6d1c2504ab 100644 --- a/vendor/k8s.io/api/autoscaling/v2beta2/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/autoscaling/v2beta2/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -20,6 +21,10 @@ limitations under the License. package v2beta2 +import ( + schema "k8s.io/apimachinery/pkg/runtime/schema" +) + // APILifecycleIntroduced is an autogenerated function, returning the release in which the API struct was introduced as int versions of major and minor for comparison. // It is controlled by "k8s:prerelease-lifecycle-gen:introduced" tags in types.go. func (in *HorizontalPodAutoscaler) APILifecycleIntroduced() (major, minor int) { @@ -32,6 +37,12 @@ func (in *HorizontalPodAutoscaler) APILifecycleDeprecated() (major, minor int) { return 1, 23 } +// APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. +// It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. +func (in *HorizontalPodAutoscaler) APILifecycleReplacement() schema.GroupVersionKind { + return schema.GroupVersionKind{Group: "autoscaling", Version: "v2", Kind: "HorizontalPodAutoscaler"} +} + // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. // It is controlled by "k8s:prerelease-lifecycle-gen:removed" tags in types.go or "k8s:prerelease-lifecycle-gen:deprecated" plus three minor. func (in *HorizontalPodAutoscaler) APILifecycleRemoved() (major, minor int) { diff --git a/vendor/k8s.io/api/batch/v1/generated.pb.go b/vendor/k8s.io/api/batch/v1/generated.pb.go index b8a1028317..a33edf5b7f 100644 --- a/vendor/k8s.io/api/batch/v1/generated.pb.go +++ b/vendor/k8s.io/api/batch/v1/generated.pb.go @@ -375,95 +375,96 @@ func init() { } var fileDescriptor_3b52da57c93de713 = []byte{ - // 1395 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xcf, 0x6f, 0x1b, 0xc5, - 0x17, 0xcf, 0xc6, 0x76, 0x6c, 0x8f, 0x93, 0xd4, 0x9d, 0x7e, 0xdb, 0xfa, 0x6b, 0x2a, 0x6f, 0x6a, + // 1413 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0x41, 0x6f, 0x1b, 0xc5, + 0x17, 0xcf, 0x26, 0x71, 0x62, 0x8f, 0x93, 0xd4, 0x9d, 0xfe, 0xdb, 0xfa, 0x6f, 0x2a, 0x6f, 0x6a, 0x0a, 0x0a, 0xa8, 0xac, 0x49, 0x88, 0x10, 0x42, 0x80, 0x94, 0x4d, 0x55, 0x68, 0x70, 0xd4, 0x30, - 0x76, 0x84, 0x04, 0x05, 0xb1, 0xde, 0x1d, 0x3b, 0xdb, 0xec, 0xee, 0x58, 0x3b, 0x63, 0x8b, 0xdc, - 0x90, 0xf8, 0x07, 0xf8, 0x2b, 0x10, 0x27, 0x84, 0x04, 0x67, 0x8e, 0xa8, 0xc7, 0x1e, 0x7b, 0x5a, - 0xd1, 0xe5, 0x0f, 0x80, 0x73, 0xb8, 0xa0, 0x9d, 0x1d, 0xef, 0x0f, 0x7b, 0x37, 0xa4, 0x3d, 0x54, - 0xdc, 0xbc, 0x6f, 0x3e, 0x9f, 0xcf, 0xbc, 0x99, 0xf7, 0xe6, 0xbd, 0x67, 0xf0, 0xde, 0xc9, 0x3b, - 0x54, 0x31, 0x49, 0xe7, 0x64, 0x32, 0xc0, 0xae, 0x83, 0x19, 0xa6, 0x9d, 0x29, 0x76, 0x0c, 0xe2, - 0x76, 0xc4, 0x82, 0x36, 0x36, 0x3b, 0x03, 0x8d, 0xe9, 0xc7, 0x9d, 0xe9, 0x56, 0x67, 0x84, 0x1d, - 0xec, 0x6a, 0x0c, 0x1b, 0xca, 0xd8, 0x25, 0x8c, 0xc0, 0x2b, 0x21, 0x48, 0xd1, 0xc6, 0xa6, 0xc2, - 0x41, 0xca, 0x74, 0xab, 0xf9, 0xc6, 0xc8, 0x64, 0xc7, 0x93, 0x81, 0xa2, 0x13, 0xbb, 0x33, 0x22, - 0x23, 0xd2, 0xe1, 0xd8, 0xc1, 0x64, 0xc8, 0xbf, 0xf8, 0x07, 0xff, 0x15, 0x6a, 0x34, 0xdb, 0x89, - 0x8d, 0x74, 0xe2, 0xe2, 0x8c, 0x7d, 0x9a, 0x3b, 0x31, 0xc6, 0xd6, 0xf4, 0x63, 0xd3, 0xc1, 0xee, - 0x69, 0x67, 0x7c, 0x32, 0x0a, 0x0c, 0xb4, 0x63, 0x63, 0xa6, 0x65, 0xb1, 0x3a, 0x79, 0x2c, 0x77, - 0xe2, 0x30, 0xd3, 0xc6, 0x0b, 0x84, 0xb7, 0xff, 0x8d, 0x40, 0xf5, 0x63, 0x6c, 0x6b, 0xf3, 0xbc, - 0xf6, 0xdf, 0x12, 0x28, 0xef, 0xb9, 0xc4, 0xd9, 0x27, 0x03, 0xf8, 0x15, 0xa8, 0x04, 0xfe, 0x18, - 0x1a, 0xd3, 0x1a, 0xd2, 0x86, 0xb4, 0x59, 0xdb, 0x7e, 0x53, 0x89, 0x6f, 0x29, 0x92, 0x55, 0xc6, - 0x27, 0xa3, 0xc0, 0x40, 0x95, 0x00, 0xad, 0x4c, 0xb7, 0x94, 0xfb, 0x83, 0x87, 0x58, 0x67, 0x07, - 0x98, 0x69, 0x2a, 0x7c, 0xe4, 0xc9, 0x4b, 0xbe, 0x27, 0x83, 0xd8, 0x86, 0x22, 0x55, 0xa8, 0x82, - 0x22, 0x1d, 0x63, 0xbd, 0xb1, 0xcc, 0xd5, 0x37, 0x94, 0x8c, 0x18, 0x28, 0xc2, 0x9b, 0xde, 0x18, - 0xeb, 0xea, 0xaa, 0x50, 0x2b, 0x06, 0x5f, 0x88, 0x73, 0xe1, 0x3e, 0x58, 0xa1, 0x4c, 0x63, 0x13, - 0xda, 0x28, 0x70, 0x95, 0xf6, 0xb9, 0x2a, 0x1c, 0xa9, 0xae, 0x0b, 0x9d, 0x95, 0xf0, 0x1b, 0x09, - 0x85, 0xf6, 0x8f, 0x12, 0xa8, 0x09, 0x64, 0xd7, 0xa4, 0x0c, 0x3e, 0x58, 0xb8, 0x01, 0xe5, 0x62, - 0x37, 0x10, 0xb0, 0xf9, 0xf9, 0xeb, 0x62, 0xa7, 0xca, 0xcc, 0x92, 0x38, 0xfd, 0x2e, 0x28, 0x99, - 0x0c, 0xdb, 0xb4, 0xb1, 0xbc, 0x51, 0xd8, 0xac, 0x6d, 0xdf, 0x38, 0xcf, 0x71, 0x75, 0x4d, 0x08, - 0x95, 0xee, 0x05, 0x14, 0x14, 0x32, 0xdb, 0x3f, 0x14, 0x23, 0x87, 0x83, 0x2b, 0x81, 0xb7, 0x41, - 0x25, 0x08, 0xac, 0x31, 0xb1, 0x30, 0x77, 0xb8, 0x1a, 0x3b, 0xd0, 0x13, 0x76, 0x14, 0x21, 0xe0, - 0x11, 0xb8, 0x4e, 0x99, 0xe6, 0x32, 0xd3, 0x19, 0xdd, 0xc1, 0x9a, 0x61, 0x99, 0x0e, 0xee, 0x61, - 0x9d, 0x38, 0x06, 0xe5, 0x11, 0x29, 0xa8, 0x2f, 0xf9, 0x9e, 0x7c, 0xbd, 0x97, 0x0d, 0x41, 0x79, - 0x5c, 0xf8, 0x00, 0x5c, 0xd6, 0x89, 0xa3, 0x4f, 0x5c, 0x17, 0x3b, 0xfa, 0xe9, 0x21, 0xb1, 0x4c, - 0xfd, 0x94, 0x07, 0xa7, 0xaa, 0x2a, 0xc2, 0x9b, 0xcb, 0x7b, 0xf3, 0x80, 0xb3, 0x2c, 0x23, 0x5a, - 0x14, 0x82, 0xaf, 0x80, 0x32, 0x9d, 0xd0, 0x31, 0x76, 0x8c, 0x46, 0x71, 0x43, 0xda, 0xac, 0xa8, - 0x35, 0xdf, 0x93, 0xcb, 0xbd, 0xd0, 0x84, 0x66, 0x6b, 0xf0, 0x73, 0x50, 0x7b, 0x48, 0x06, 0x7d, - 0x6c, 0x8f, 0x2d, 0x8d, 0xe1, 0x46, 0x89, 0x47, 0xef, 0x56, 0xe6, 0x15, 0xef, 0xc7, 0x38, 0x9e, - 0x65, 0x57, 0x84, 0x93, 0xb5, 0xc4, 0x02, 0x4a, 0xaa, 0xc1, 0x2f, 0x41, 0x93, 0x4e, 0x74, 0x1d, - 0x53, 0x3a, 0x9c, 0x58, 0xfb, 0x64, 0x40, 0x3f, 0x32, 0x29, 0x23, 0xee, 0x69, 0xd7, 0xb4, 0x4d, - 0xd6, 0x58, 0xd9, 0x90, 0x36, 0x4b, 0x6a, 0xcb, 0xf7, 0xe4, 0x66, 0x2f, 0x17, 0x85, 0xce, 0x51, - 0x80, 0x08, 0x5c, 0x1b, 0x6a, 0xa6, 0x85, 0x8d, 0x05, 0xed, 0x32, 0xd7, 0x6e, 0xfa, 0x9e, 0x7c, - 0xed, 0x6e, 0x26, 0x02, 0xe5, 0x30, 0xdb, 0xbf, 0x2e, 0x83, 0xb5, 0xd4, 0x2b, 0x80, 0x1f, 0x83, - 0x15, 0x4d, 0x67, 0xe6, 0x34, 0x48, 0x95, 0x20, 0x01, 0x5f, 0x4e, 0xde, 0x4e, 0x50, 0xbf, 0xe2, - 0xb7, 0x8c, 0xf0, 0x10, 0x07, 0x41, 0xc0, 0xf1, 0xd3, 0xd9, 0xe5, 0x54, 0x24, 0x24, 0xa0, 0x05, - 0xea, 0x96, 0x46, 0xd9, 0x2c, 0xcb, 0xfa, 0xa6, 0x8d, 0x79, 0x7c, 0x6a, 0xdb, 0xaf, 0x5f, 0xec, - 0xc9, 0x04, 0x0c, 0xf5, 0x7f, 0xbe, 0x27, 0xd7, 0xbb, 0x73, 0x3a, 0x68, 0x41, 0x19, 0xba, 0x00, - 0x72, 0x5b, 0x74, 0x85, 0x7c, 0xbf, 0xd2, 0x33, 0xef, 0x77, 0xcd, 0xf7, 0x64, 0xd8, 0x5d, 0x50, - 0x42, 0x19, 0xea, 0xed, 0x3f, 0x25, 0x50, 0x78, 0x31, 0x65, 0xf1, 0x83, 0x54, 0x59, 0xbc, 0x91, - 0x97, 0xb4, 0xb9, 0x25, 0xf1, 0xee, 0x5c, 0x49, 0x6c, 0xe5, 0x2a, 0x9c, 0x5f, 0x0e, 0x7f, 0x2b, - 0x80, 0xd5, 0x7d, 0x32, 0xd8, 0x23, 0x8e, 0x61, 0x32, 0x93, 0x38, 0x70, 0x07, 0x14, 0xd9, 0xe9, - 0x78, 0x56, 0x5a, 0x36, 0x66, 0x5b, 0xf7, 0x4f, 0xc7, 0xf8, 0xcc, 0x93, 0xeb, 0x49, 0x6c, 0x60, - 0x43, 0x1c, 0x0d, 0xbb, 0x91, 0x3b, 0xcb, 0x9c, 0xb7, 0x93, 0xde, 0xee, 0xcc, 0x93, 0x33, 0x1a, - 0xa7, 0x12, 0x29, 0xa5, 0x9d, 0x82, 0x23, 0xb0, 0x16, 0x04, 0xe7, 0xd0, 0x25, 0x83, 0x30, 0xcb, - 0x0a, 0xcf, 0x1c, 0xf5, 0xab, 0xc2, 0x81, 0xb5, 0x6e, 0x52, 0x08, 0xa5, 0x75, 0xe1, 0x34, 0xcc, - 0xb1, 0xbe, 0xab, 0x39, 0x34, 0x3c, 0xd2, 0xf3, 0xe5, 0x74, 0x53, 0xec, 0xc6, 0xf3, 0x2c, 0xad, - 0x86, 0x32, 0x76, 0x80, 0xaf, 0x82, 0x15, 0x17, 0x6b, 0x94, 0x38, 0x3c, 0x9f, 0xab, 0x71, 0x74, - 0x10, 0xb7, 0x22, 0xb1, 0x0a, 0x5f, 0x03, 0x65, 0x1b, 0x53, 0xaa, 0x8d, 0x30, 0xaf, 0x38, 0x55, - 0xf5, 0x92, 0x00, 0x96, 0x0f, 0x42, 0x33, 0x9a, 0xad, 0xb7, 0xbf, 0x97, 0x40, 0xf9, 0xc5, 0xf4, - 0xb4, 0xf7, 0xd3, 0x3d, 0xad, 0x91, 0x97, 0x79, 0x39, 0xfd, 0xec, 0xa7, 0x12, 0x77, 0x94, 0xf7, - 0xb2, 0x2d, 0x50, 0x1b, 0x6b, 0xae, 0x66, 0x59, 0xd8, 0x32, 0xa9, 0xcd, 0x7d, 0x2d, 0xa9, 0x97, - 0x82, 0xba, 0x7c, 0x18, 0x9b, 0x51, 0x12, 0x13, 0x50, 0x74, 0x62, 0x8f, 0x2d, 0x1c, 0x5c, 0x66, - 0x98, 0x6e, 0x82, 0xb2, 0x17, 0x9b, 0x51, 0x12, 0x03, 0xef, 0x83, 0xab, 0x61, 0x05, 0x9b, 0xef, - 0x80, 0x05, 0xde, 0x01, 0xff, 0xef, 0x7b, 0xf2, 0xd5, 0xdd, 0x2c, 0x00, 0xca, 0xe6, 0xc1, 0x1d, - 0xb0, 0x3a, 0xd0, 0xf4, 0x13, 0x32, 0x1c, 0x26, 0x2b, 0x76, 0xdd, 0xf7, 0xe4, 0x55, 0x35, 0x61, - 0x47, 0x29, 0x14, 0xfc, 0x02, 0x54, 0x28, 0xb6, 0xb0, 0xce, 0x88, 0x2b, 0x52, 0xec, 0xad, 0x0b, - 0x46, 0x45, 0x1b, 0x60, 0xab, 0x27, 0xa8, 0xea, 0x2a, 0xef, 0xf4, 0xe2, 0x0b, 0x45, 0x92, 0xf0, - 0x5d, 0xb0, 0x6e, 0x6b, 0xce, 0x44, 0x8b, 0x90, 0x3c, 0xb7, 0x2a, 0x2a, 0xf4, 0x3d, 0x79, 0xfd, - 0x20, 0xb5, 0x82, 0xe6, 0x90, 0xf0, 0x13, 0x50, 0x61, 0xb3, 0x36, 0xba, 0xc2, 0x5d, 0xcb, 0x6c, - 0x14, 0x87, 0xc4, 0x48, 0x75, 0xd1, 0x28, 0x4b, 0xa2, 0x16, 0x1a, 0xc9, 0x04, 0x83, 0x07, 0x63, - 0x96, 0xb8, 0xb1, 0xdd, 0x21, 0xc3, 0xee, 0x5d, 0xd3, 0x31, 0xe9, 0x31, 0x36, 0x1a, 0x15, 0x7e, - 0x5d, 0x7c, 0xf0, 0xe8, 0xf7, 0xbb, 0x59, 0x10, 0x94, 0xc7, 0x85, 0x5d, 0xb0, 0x1e, 0x87, 0xf6, - 0x80, 0x18, 0xb8, 0x51, 0xe5, 0x0f, 0xe3, 0x56, 0x70, 0xca, 0xbd, 0xd4, 0xca, 0xd9, 0x82, 0x05, - 0xcd, 0x71, 0x93, 0x83, 0x06, 0xc8, 0x1f, 0x34, 0xda, 0x7f, 0x15, 0x41, 0x35, 0xee, 0xa9, 0x47, - 0x00, 0xe8, 0xb3, 0xc2, 0x45, 0x45, 0x5f, 0xbd, 0x99, 0xf7, 0x08, 0xa2, 0x12, 0x17, 0xf7, 0x83, - 0xc8, 0x44, 0x51, 0x42, 0x08, 0x7e, 0x0a, 0xaa, 0x7c, 0xda, 0xe2, 0x25, 0x68, 0xf9, 0x99, 0x4b, - 0xd0, 0x9a, 0xef, 0xc9, 0xd5, 0xde, 0x4c, 0x00, 0xc5, 0x5a, 0x70, 0x98, 0xbc, 0xb2, 0xe7, 0x2c, - 0xa7, 0x30, 0x7d, 0xbd, 0x7c, 0x8b, 0x39, 0xd5, 0xa0, 0xa8, 0x89, 0x59, 0xa3, 0xc8, 0x03, 0x9c, - 0x37, 0x46, 0x74, 0x40, 0x95, 0xcf, 0x45, 0xd8, 0xc0, 0x06, 0xcf, 0xd1, 0x92, 0x7a, 0x59, 0x40, - 0xab, 0xbd, 0xd9, 0x02, 0x8a, 0x31, 0x81, 0x70, 0x38, 0xf0, 0x88, 0xb1, 0x2b, 0x12, 0x0e, 0xc7, - 0x23, 0x24, 0x56, 0xe1, 0x1d, 0x50, 0x17, 0x2e, 0x61, 0xe3, 0x9e, 0x63, 0xe0, 0xaf, 0x31, 0xe5, - 0x4f, 0xb3, 0xaa, 0x36, 0x04, 0xa3, 0xbe, 0x37, 0xb7, 0x8e, 0x16, 0x18, 0xf0, 0x5b, 0x09, 0x5c, - 0x9f, 0x38, 0x3a, 0x99, 0x38, 0x0c, 0x1b, 0x7d, 0xec, 0xda, 0xa6, 0x13, 0xfc, 0x79, 0x3a, 0x24, - 0x06, 0xe5, 0x99, 0x5b, 0xdb, 0xbe, 0x9d, 0x19, 0xec, 0xa3, 0x6c, 0x4e, 0x98, 0xe7, 0x39, 0x8b, - 0x28, 0x6f, 0xa7, 0xf6, 0xcf, 0x12, 0xb8, 0x34, 0x37, 0xb4, 0xfe, 0xf7, 0xa7, 0x92, 0xf6, 0x2f, - 0x12, 0xc8, 0x3b, 0x2a, 0x3c, 0x4c, 0x86, 0x3d, 0x78, 0x35, 0x55, 0x75, 0x3b, 0x15, 0xf2, 0x33, - 0x4f, 0xbe, 0x99, 0xf7, 0x97, 0x36, 0x18, 0x32, 0xa8, 0x72, 0x74, 0xef, 0x4e, 0x32, 0x2f, 0x3e, - 0x8c, 0xf2, 0x62, 0x99, 0xcb, 0x75, 0xe2, 0x9c, 0xb8, 0x98, 0x96, 0xa0, 0xab, 0x9b, 0x8f, 0x9e, - 0xb6, 0x96, 0x1e, 0x3f, 0x6d, 0x2d, 0x3d, 0x79, 0xda, 0x5a, 0xfa, 0xc6, 0x6f, 0x49, 0x8f, 0xfc, - 0x96, 0xf4, 0xd8, 0x6f, 0x49, 0x4f, 0xfc, 0x96, 0xf4, 0xbb, 0xdf, 0x92, 0xbe, 0xfb, 0xa3, 0xb5, - 0xf4, 0xd9, 0xf2, 0x74, 0xeb, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa8, 0xfc, 0x0b, 0x48, 0x81, - 0x10, 0x00, 0x00, + 0x76, 0x84, 0x04, 0x05, 0xb1, 0xde, 0x1d, 0x3b, 0xdb, 0xec, 0xee, 0x58, 0x3b, 0x63, 0x0b, 0xdf, + 0x90, 0xf8, 0x02, 0xf0, 0x25, 0x10, 0x27, 0x84, 0x04, 0x67, 0x8e, 0xa8, 0xc7, 0x1e, 0x7b, 0x5a, + 0xd1, 0xe5, 0x03, 0x70, 0x0f, 0x17, 0x34, 0xb3, 0xe3, 0xdd, 0xb5, 0xbd, 0x1b, 0xd2, 0x1e, 0x2a, + 0x6e, 0xd9, 0x37, 0xbf, 0xf7, 0x9b, 0xe7, 0xf7, 0x7e, 0xf3, 0xde, 0x0b, 0x78, 0xef, 0xf4, 0x1d, + 0xaa, 0xd9, 0xa4, 0x79, 0x3a, 0xec, 0x62, 0xdf, 0xc3, 0x0c, 0xd3, 0xe6, 0x08, 0x7b, 0x16, 0xf1, + 0x9b, 0xf2, 0xc0, 0x18, 0xd8, 0xcd, 0xae, 0xc1, 0xcc, 0x93, 0xe6, 0x68, 0xbb, 0xd9, 0xc7, 0x1e, + 0xf6, 0x0d, 0x86, 0x2d, 0x6d, 0xe0, 0x13, 0x46, 0xe0, 0x95, 0x08, 0xa4, 0x19, 0x03, 0x5b, 0x13, + 0x20, 0x6d, 0xb4, 0x5d, 0x7b, 0xa3, 0x6f, 0xb3, 0x93, 0x61, 0x57, 0x33, 0x89, 0xdb, 0xec, 0x93, + 0x3e, 0x69, 0x0a, 0x6c, 0x77, 0xd8, 0x13, 0x5f, 0xe2, 0x43, 0xfc, 0x15, 0x71, 0xd4, 0x1a, 0xa9, + 0x8b, 0x4c, 0xe2, 0xe3, 0x8c, 0x7b, 0x6a, 0xbb, 0x09, 0xc6, 0x35, 0xcc, 0x13, 0xdb, 0xc3, 0xfe, + 0xb8, 0x39, 0x38, 0xed, 0x73, 0x03, 0x6d, 0xba, 0x98, 0x19, 0x59, 0x5e, 0xcd, 0x3c, 0x2f, 0x7f, + 0xe8, 0x31, 0xdb, 0xc5, 0x73, 0x0e, 0x6f, 0xff, 0x9b, 0x03, 0x35, 0x4f, 0xb0, 0x6b, 0xcc, 0xfa, + 0x35, 0xfe, 0x56, 0xc0, 0xea, 0xbe, 0x4f, 0xbc, 0x03, 0xd2, 0x85, 0x5f, 0x81, 0x22, 0x8f, 0xc7, + 0x32, 0x98, 0x51, 0x55, 0x36, 0x95, 0xad, 0xf2, 0xce, 0x9b, 0x5a, 0x92, 0xa5, 0x98, 0x56, 0x1b, + 0x9c, 0xf6, 0xb9, 0x81, 0x6a, 0x1c, 0xad, 0x8d, 0xb6, 0xb5, 0xfb, 0xdd, 0x87, 0xd8, 0x64, 0x87, + 0x98, 0x19, 0x3a, 0x7c, 0x14, 0xa8, 0x0b, 0x61, 0xa0, 0x82, 0xc4, 0x86, 0x62, 0x56, 0xa8, 0x83, + 0x65, 0x3a, 0xc0, 0x66, 0x75, 0x51, 0xb0, 0x6f, 0x6a, 0x19, 0x35, 0xd0, 0x64, 0x34, 0xed, 0x01, + 0x36, 0xf5, 0x35, 0xc9, 0xb6, 0xcc, 0xbf, 0x90, 0xf0, 0x85, 0x07, 0x60, 0x85, 0x32, 0x83, 0x0d, + 0x69, 0x75, 0x49, 0xb0, 0x34, 0xce, 0x65, 0x11, 0x48, 0x7d, 0x43, 0xf2, 0xac, 0x44, 0xdf, 0x48, + 0x32, 0x34, 0x7e, 0x52, 0x40, 0x59, 0x22, 0x5b, 0x36, 0x65, 0xf0, 0xc1, 0x5c, 0x06, 0xb4, 0x8b, + 0x65, 0x80, 0x7b, 0x8b, 0xdf, 0x5f, 0x91, 0x37, 0x15, 0x27, 0x96, 0xd4, 0xaf, 0xdf, 0x03, 0x05, + 0x9b, 0x61, 0x97, 0x56, 0x17, 0x37, 0x97, 0xb6, 0xca, 0x3b, 0x37, 0xce, 0x0b, 0x5c, 0x5f, 0x97, + 0x44, 0x85, 0x7b, 0xdc, 0x05, 0x45, 0x9e, 0x8d, 0x1f, 0x97, 0xe3, 0x80, 0x79, 0x4a, 0xe0, 0x6d, + 0x50, 0xe4, 0x85, 0xb5, 0x86, 0x0e, 0x16, 0x01, 0x97, 0x92, 0x00, 0xda, 0xd2, 0x8e, 0x62, 0x04, + 0x3c, 0x06, 0xd7, 0x29, 0x33, 0x7c, 0x66, 0x7b, 0xfd, 0x3b, 0xd8, 0xb0, 0x1c, 0xdb, 0xc3, 0x6d, + 0x6c, 0x12, 0xcf, 0xa2, 0xa2, 0x22, 0x4b, 0xfa, 0x4b, 0x61, 0xa0, 0x5e, 0x6f, 0x67, 0x43, 0x50, + 0x9e, 0x2f, 0x7c, 0x00, 0x2e, 0x9b, 0xc4, 0x33, 0x87, 0xbe, 0x8f, 0x3d, 0x73, 0x7c, 0x44, 0x1c, + 0xdb, 0x1c, 0x8b, 0xe2, 0x94, 0x74, 0x4d, 0x46, 0x73, 0x79, 0x7f, 0x16, 0x70, 0x96, 0x65, 0x44, + 0xf3, 0x44, 0xf0, 0x15, 0xb0, 0x4a, 0x87, 0x74, 0x80, 0x3d, 0xab, 0xba, 0xbc, 0xa9, 0x6c, 0x15, + 0xf5, 0x72, 0x18, 0xa8, 0xab, 0xed, 0xc8, 0x84, 0x26, 0x67, 0xf0, 0x73, 0x50, 0x7e, 0x48, 0xba, + 0x1d, 0xec, 0x0e, 0x1c, 0x83, 0xe1, 0x6a, 0x41, 0x54, 0xef, 0x56, 0x66, 0x8a, 0x0f, 0x12, 0x9c, + 0x50, 0xd9, 0x15, 0x19, 0x64, 0x39, 0x75, 0x80, 0xd2, 0x6c, 0xf0, 0x4b, 0x50, 0xa3, 0x43, 0xd3, + 0xc4, 0x94, 0xf6, 0x86, 0xce, 0x01, 0xe9, 0xd2, 0x8f, 0x6c, 0xca, 0x88, 0x3f, 0x6e, 0xd9, 0xae, + 0xcd, 0xaa, 0x2b, 0x9b, 0xca, 0x56, 0x41, 0xaf, 0x87, 0x81, 0x5a, 0x6b, 0xe7, 0xa2, 0xd0, 0x39, + 0x0c, 0x10, 0x81, 0x6b, 0x3d, 0xc3, 0x76, 0xb0, 0x35, 0xc7, 0xbd, 0x2a, 0xb8, 0x6b, 0x61, 0xa0, + 0x5e, 0xbb, 0x9b, 0x89, 0x40, 0x39, 0x9e, 0x8d, 0xdf, 0x16, 0xc1, 0xfa, 0xd4, 0x2b, 0x80, 0x1f, + 0x83, 0x15, 0xc3, 0x64, 0xf6, 0x88, 0x4b, 0x85, 0x0b, 0xf0, 0xe5, 0x74, 0x76, 0x78, 0xff, 0x4a, + 0xde, 0x32, 0xc2, 0x3d, 0xcc, 0x8b, 0x80, 0x93, 0xa7, 0xb3, 0x27, 0x5c, 0x91, 0xa4, 0x80, 0x0e, + 0xa8, 0x38, 0x06, 0x65, 0x13, 0x95, 0x75, 0x6c, 0x17, 0x8b, 0xfa, 0x94, 0x77, 0x5e, 0xbf, 0xd8, + 0x93, 0xe1, 0x1e, 0xfa, 0xff, 0xc2, 0x40, 0xad, 0xb4, 0x66, 0x78, 0xd0, 0x1c, 0x33, 0xf4, 0x01, + 0x14, 0xb6, 0x38, 0x85, 0xe2, 0xbe, 0xc2, 0x33, 0xdf, 0x77, 0x2d, 0x0c, 0x54, 0xd8, 0x9a, 0x63, + 0x42, 0x19, 0xec, 0x8d, 0xbf, 0x14, 0xb0, 0xf4, 0x62, 0xda, 0xe2, 0x07, 0x53, 0x6d, 0xf1, 0x46, + 0x9e, 0x68, 0x73, 0x5b, 0xe2, 0xdd, 0x99, 0x96, 0x58, 0xcf, 0x65, 0x38, 0xbf, 0x1d, 0xfe, 0xbe, + 0x04, 0xd6, 0x0e, 0x48, 0x77, 0x9f, 0x78, 0x96, 0xcd, 0x6c, 0xe2, 0xc1, 0x5d, 0xb0, 0xcc, 0xc6, + 0x83, 0x49, 0x6b, 0xd9, 0x9c, 0x5c, 0xdd, 0x19, 0x0f, 0xf0, 0x59, 0xa0, 0x56, 0xd2, 0x58, 0x6e, + 0x43, 0x02, 0x0d, 0x5b, 0x71, 0x38, 0x8b, 0xc2, 0x6f, 0x77, 0xfa, 0xba, 0xb3, 0x40, 0xcd, 0x18, + 0x9c, 0x5a, 0xcc, 0x34, 0x1d, 0x14, 0xec, 0x83, 0x75, 0x5e, 0x9c, 0x23, 0x9f, 0x74, 0x23, 0x95, + 0x2d, 0x3d, 0x73, 0xd5, 0xaf, 0xca, 0x00, 0xd6, 0x5b, 0x69, 0x22, 0x34, 0xcd, 0x0b, 0x47, 0x91, + 0xc6, 0x3a, 0xbe, 0xe1, 0xd1, 0xe8, 0x27, 0x3d, 0x9f, 0xa6, 0x6b, 0xf2, 0x36, 0xa1, 0xb3, 0x69, + 0x36, 0x94, 0x71, 0x03, 0x7c, 0x15, 0xac, 0xf8, 0xd8, 0xa0, 0xc4, 0x13, 0x7a, 0x2e, 0x25, 0xd5, + 0x41, 0xc2, 0x8a, 0xe4, 0x29, 0x7c, 0x0d, 0xac, 0xba, 0x98, 0x52, 0xa3, 0x8f, 0x45, 0xc7, 0x29, + 0xe9, 0x97, 0x24, 0x70, 0xf5, 0x30, 0x32, 0xa3, 0xc9, 0x79, 0xe3, 0x07, 0x05, 0xac, 0xbe, 0x98, + 0x99, 0xf6, 0xfe, 0xf4, 0x4c, 0xab, 0xe6, 0x29, 0x2f, 0x67, 0x9e, 0xfd, 0x5c, 0x10, 0x81, 0x8a, + 0x59, 0xb6, 0x0d, 0xca, 0x03, 0xc3, 0x37, 0x1c, 0x07, 0x3b, 0x36, 0x75, 0x45, 0xac, 0x05, 0xfd, + 0x12, 0xef, 0xcb, 0x47, 0x89, 0x19, 0xa5, 0x31, 0xdc, 0xc5, 0x24, 0xee, 0xc0, 0xc1, 0x3c, 0x99, + 0x91, 0xdc, 0xa4, 0xcb, 0x7e, 0x62, 0x46, 0x69, 0x0c, 0xbc, 0x0f, 0xae, 0x46, 0x1d, 0x6c, 0x76, + 0x02, 0x2e, 0x89, 0x09, 0xf8, 0xff, 0x30, 0x50, 0xaf, 0xee, 0x65, 0x01, 0x50, 0xb6, 0x1f, 0xdc, + 0x05, 0x6b, 0x5d, 0xc3, 0x3c, 0x25, 0xbd, 0x5e, 0xba, 0x63, 0x57, 0xc2, 0x40, 0x5d, 0xd3, 0x53, + 0x76, 0x34, 0x85, 0x82, 0x5f, 0x80, 0x22, 0xc5, 0x0e, 0x36, 0x19, 0xf1, 0xa5, 0xc4, 0xde, 0xba, + 0x60, 0x55, 0x8c, 0x2e, 0x76, 0xda, 0xd2, 0x55, 0x5f, 0x13, 0x93, 0x5e, 0x7e, 0xa1, 0x98, 0x12, + 0xbe, 0x0b, 0x36, 0x5c, 0xc3, 0x1b, 0x1a, 0x31, 0x52, 0x68, 0xab, 0xa8, 0xc3, 0x30, 0x50, 0x37, + 0x0e, 0xa7, 0x4e, 0xd0, 0x0c, 0x12, 0x7e, 0x02, 0x8a, 0x6c, 0x32, 0x46, 0x57, 0x44, 0x68, 0x99, + 0x83, 0xe2, 0x88, 0x58, 0x53, 0x53, 0x34, 0x56, 0x49, 0x3c, 0x42, 0x63, 0x1a, 0xbe, 0x78, 0x30, + 0xe6, 0xc8, 0x8c, 0xed, 0xf5, 0x18, 0xf6, 0xef, 0xda, 0x9e, 0x4d, 0x4f, 0xb0, 0x55, 0x2d, 0x8a, + 0x74, 0x89, 0xc5, 0xa3, 0xd3, 0x69, 0x65, 0x41, 0x50, 0x9e, 0x2f, 0x6c, 0x81, 0x8d, 0xa4, 0xb4, + 0x87, 0xc4, 0xc2, 0xd5, 0x92, 0x78, 0x18, 0xb7, 0xf8, 0xaf, 0xdc, 0x9f, 0x3a, 0x39, 0x9b, 0xb3, + 0xa0, 0x19, 0xdf, 0xf4, 0xa2, 0x01, 0xf2, 0x17, 0x8d, 0xc6, 0xf7, 0x05, 0x50, 0x4a, 0x66, 0xea, + 0x31, 0x00, 0xe6, 0xa4, 0x71, 0x51, 0x39, 0x57, 0x6f, 0xe6, 0x3d, 0x82, 0xb8, 0xc5, 0x25, 0xf3, + 0x20, 0x36, 0x51, 0x94, 0x22, 0x82, 0x9f, 0x82, 0x92, 0xd8, 0xb6, 0x44, 0x0b, 0x5a, 0x7c, 0xe6, + 0x16, 0xb4, 0x1e, 0x06, 0x6a, 0xa9, 0x3d, 0x21, 0x40, 0x09, 0x17, 0xec, 0xa5, 0x53, 0xf6, 0x9c, + 0xed, 0x14, 0x4e, 0xa7, 0x57, 0x5c, 0x31, 0xc3, 0xca, 0x9b, 0x9a, 0xdc, 0x35, 0x96, 0x45, 0x81, + 0xf3, 0xd6, 0x88, 0x26, 0x28, 0x89, 0xbd, 0x08, 0x5b, 0xd8, 0x12, 0x1a, 0x2d, 0xe8, 0x97, 0x25, + 0xb4, 0xd4, 0x9e, 0x1c, 0xa0, 0x04, 0xc3, 0x89, 0xa3, 0x85, 0x47, 0xae, 0x5d, 0x31, 0x71, 0xb4, + 0x1e, 0x21, 0x79, 0x0a, 0xef, 0x80, 0x8a, 0x0c, 0x09, 0x5b, 0xf7, 0x3c, 0x0b, 0x7f, 0x8d, 0xa9, + 0x78, 0x9a, 0x25, 0xbd, 0x2a, 0x3d, 0x2a, 0xfb, 0x33, 0xe7, 0x68, 0xce, 0x03, 0x7e, 0xab, 0x80, + 0xeb, 0x43, 0xcf, 0x24, 0x43, 0x8f, 0x61, 0xab, 0x83, 0x7d, 0xd7, 0xf6, 0xf8, 0x3f, 0x4f, 0x47, + 0xc4, 0xa2, 0x42, 0xb9, 0xe5, 0x9d, 0xdb, 0x99, 0xc5, 0x3e, 0xce, 0xf6, 0x89, 0x74, 0x9e, 0x73, + 0x88, 0xf2, 0x6e, 0x82, 0x2a, 0x28, 0xf8, 0xd8, 0xb0, 0xc6, 0x42, 0xde, 0x05, 0xbd, 0xc4, 0xdb, + 0x28, 0xe2, 0x06, 0x14, 0xd9, 0x1b, 0xbf, 0x28, 0xe0, 0xd2, 0xcc, 0x56, 0xfb, 0xdf, 0x5f, 0x5b, + 0x1a, 0xbf, 0x2a, 0x20, 0x2f, 0x17, 0xf0, 0x28, 0xad, 0x0b, 0xfe, 0xac, 0x4a, 0xfa, 0xce, 0x94, + 0x26, 0xce, 0x02, 0xf5, 0x66, 0xde, 0xff, 0xbc, 0x7c, 0x0b, 0xa1, 0xda, 0xf1, 0xbd, 0x3b, 0x69, + 0xe1, 0x7c, 0x18, 0x0b, 0x67, 0x51, 0xd0, 0x35, 0x13, 0xd1, 0x5c, 0x8c, 0x4b, 0xba, 0xeb, 0x5b, + 0x8f, 0x9e, 0xd6, 0x17, 0x1e, 0x3f, 0xad, 0x2f, 0x3c, 0x79, 0x5a, 0x5f, 0xf8, 0x26, 0xac, 0x2b, + 0x8f, 0xc2, 0xba, 0xf2, 0x38, 0xac, 0x2b, 0x4f, 0xc2, 0xba, 0xf2, 0x47, 0x58, 0x57, 0xbe, 0xfb, + 0xb3, 0xbe, 0xf0, 0xd9, 0xe2, 0x68, 0xfb, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x54, 0x31, 0x16, + 0xcf, 0xa2, 0x10, 0x00, 0x00, } func (m *CronJob) Marshal() (dAtA []byte, err error) { @@ -975,6 +976,11 @@ func (m *JobStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Ready != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.Ready)) + i-- + dAtA[i] = 0x48 + } if m.UncountedTerminatedPods != nil { { size, err := m.UncountedTerminatedPods.MarshalToSizedBuffer(dAtA[:i]) @@ -1341,6 +1347,9 @@ func (m *JobStatus) Size() (n int) { l = m.UncountedTerminatedPods.Size() n += 1 + l + sovGenerated(uint64(l)) } + if m.Ready != nil { + n += 1 + sovGenerated(uint64(*m.Ready)) + } return n } @@ -1525,6 +1534,7 @@ func (this *JobStatus) String() string { `Failed:` + fmt.Sprintf("%v", this.Failed) + `,`, `CompletedIndexes:` + fmt.Sprintf("%v", this.CompletedIndexes) + `,`, `UncountedTerminatedPods:` + strings.Replace(this.UncountedTerminatedPods.String(), "UncountedTerminatedPods", "UncountedTerminatedPods", 1) + `,`, + `Ready:` + valueToStringGenerated(this.Ready) + `,`, `}`, }, "") return s @@ -3273,6 +3283,26 @@ func (m *JobStatus) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Ready", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Ready = &v default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/vendor/k8s.io/api/batch/v1/generated.proto b/vendor/k8s.io/api/batch/v1/generated.proto index 1aefe05269..161886029b 100644 --- a/vendor/k8s.io/api/batch/v1/generated.proto +++ b/vendor/k8s.io/api/batch/v1/generated.proto @@ -227,8 +227,6 @@ message JobSpec { // guarantees (e.g. finalizers) will be honored. If this field is unset, // the Job won't be automatically deleted. If this field is set to zero, // the Job becomes eligible to be deleted immediately after it finishes. - // This field is alpha-level and is only honored by servers that enable the - // TTLAfterFinished feature. // +optional optional int32 ttlSecondsAfterFinished = 8; @@ -300,7 +298,7 @@ message JobStatus { // +optional optional k8s.io.apimachinery.pkg.apis.meta.v1.Time completionTime = 3; - // The number of actively running pods. + // The number of pending and running pods. // +optional optional int32 active = 4; @@ -333,12 +331,20 @@ message JobStatus { // (3) Remove the pod UID from the arrays while increasing the corresponding // counter. // - // This field is alpha-level. The job controller only makes use of this field - // when the feature gate PodTrackingWithFinalizers is enabled. + // This field is beta-level. The job controller only makes use of this field + // when the feature gate JobTrackingWithFinalizers is enabled (enabled + // by default). // Old jobs might not be tracked using this field, in which case the field // remains null. // +optional optional UncountedTerminatedPods uncountedTerminatedPods = 8; + + // The number of pods which have a Ready condition. + // + // This field is alpha-level. The job controller populates the field when + // the feature gate JobReadyPods is enabled (disabled by default). + // +optional + optional int32 ready = 9; } // JobTemplateSpec describes the data a Job should have when created from a template diff --git a/vendor/k8s.io/api/batch/v1/types.go b/vendor/k8s.io/api/batch/v1/types.go index 77742e5f8c..aec1cad8e2 100644 --- a/vendor/k8s.io/api/batch/v1/types.go +++ b/vendor/k8s.io/api/batch/v1/types.go @@ -71,6 +71,7 @@ type JobList struct { } // CompletionMode specifies how Pod completions of a Job are tracked. +// +enum type CompletionMode string const ( @@ -154,8 +155,6 @@ type JobSpec struct { // guarantees (e.g. finalizers) will be honored. If this field is unset, // the Job won't be automatically deleted. If this field is set to zero, // the Job becomes eligible to be deleted immediately after it finishes. - // This field is alpha-level and is only honored by servers that enable the - // TTLAfterFinished feature. // +optional TTLSecondsAfterFinished *int32 `json:"ttlSecondsAfterFinished,omitempty" protobuf:"varint,8,opt,name=ttlSecondsAfterFinished"` @@ -227,7 +226,7 @@ type JobStatus struct { // +optional CompletionTime *metav1.Time `json:"completionTime,omitempty" protobuf:"bytes,3,opt,name=completionTime"` - // The number of actively running pods. + // The number of pending and running pods. // +optional Active int32 `json:"active,omitempty" protobuf:"varint,4,opt,name=active"` @@ -260,12 +259,20 @@ type JobStatus struct { // (3) Remove the pod UID from the arrays while increasing the corresponding // counter. // - // This field is alpha-level. The job controller only makes use of this field - // when the feature gate PodTrackingWithFinalizers is enabled. + // This field is beta-level. The job controller only makes use of this field + // when the feature gate JobTrackingWithFinalizers is enabled (enabled + // by default). // Old jobs might not be tracked using this field, in which case the field // remains null. // +optional UncountedTerminatedPods *UncountedTerminatedPods `json:"uncountedTerminatedPods,omitempty" protobuf:"bytes,8,opt,name=uncountedTerminatedPods"` + + // The number of pods which have a Ready condition. + // + // This field is alpha-level. The job controller populates the field when + // the feature gate JobReadyPods is enabled (disabled by default). + // +optional + Ready *int32 `json:"ready,omitempty" protobuf:"varint,9,opt,name=ready"` } // UncountedTerminatedPods holds UIDs of Pods that have terminated but haven't @@ -282,6 +289,7 @@ type UncountedTerminatedPods struct { Failed []types.UID `json:"failed,omitempty" protobuf:"bytes,2,rep,name=failed,casttype=k8s.io/apimachinery/pkg/types.UID"` } +// +enum type JobConditionType string // These are valid conditions of a job. @@ -406,6 +414,7 @@ type CronJobSpec struct { // Only one of the following concurrent policies may be specified. // If none of the following policies is specified, the default one // is AllowConcurrent. +// +enum type ConcurrencyPolicy string const ( diff --git a/vendor/k8s.io/api/batch/v1/types_swagger_doc_generated.go b/vendor/k8s.io/api/batch/v1/types_swagger_doc_generated.go index f6e01000da..269021a9c0 100644 --- a/vendor/k8s.io/api/batch/v1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/batch/v1/types_swagger_doc_generated.go @@ -118,7 +118,7 @@ var map_JobSpec = map[string]string{ "selector": "A label query over pods that should match the pod count. Normally, the system sets this field for you. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors", "manualSelector": "manualSelector controls generation of pod labels and pod selectors. Leave `manualSelector` unset unless you are certain what you are doing. When false or unset, the system pick labels unique to this job and appends those labels to the pod template. When true, the user is responsible for picking unique labels and specifying the selector. Failure to pick a unique label may cause this and other jobs to not function correctly. However, You may see `manualSelector=true` in jobs that were created with the old `extensions/v1beta1` API. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector", "template": "Describes the pod that will be created when executing a job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/", - "ttlSecondsAfterFinished": "ttlSecondsAfterFinished limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted. When the Job is being deleted, its lifecycle guarantees (e.g. finalizers) will be honored. If this field is unset, the Job won't be automatically deleted. If this field is set to zero, the Job becomes eligible to be deleted immediately after it finishes. This field is alpha-level and is only honored by servers that enable the TTLAfterFinished feature.", + "ttlSecondsAfterFinished": "ttlSecondsAfterFinished limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted. When the Job is being deleted, its lifecycle guarantees (e.g. finalizers) will be honored. If this field is unset, the Job won't be automatically deleted. If this field is set to zero, the Job becomes eligible to be deleted immediately after it finishes.", "completionMode": "CompletionMode specifies how Pod completions are tracked. It can be `NonIndexed` (default) or `Indexed`.\n\n`NonIndexed` means that the Job is considered complete when there have been .spec.completions successfully completed Pods. Each Pod completion is homologous to each other.\n\n`Indexed` means that the Pods of a Job get an associated completion index from 0 to (.spec.completions - 1), available in the annotation batch.kubernetes.io/job-completion-index. The Job is considered complete when there is one successfully completed Pod for each index. When value is `Indexed`, .spec.completions must be specified and `.spec.parallelism` must be less than or equal to 10^5. In addition, The Pod name takes the form `$(job-name)-$(index)-$(random-string)`, the Pod hostname takes the form `$(job-name)-$(index)`.\n\nThis field is beta-level. More completion modes can be added in the future. If the Job controller observes a mode that it doesn't recognize, the controller skips updates for the Job.", "suspend": "Suspend specifies whether the Job controller should create Pods or not. If a Job is created with suspend set to true, no Pods are created by the Job controller. If a Job is suspended after creation (i.e. the flag goes from false to true), the Job controller will delete all active Pods associated with this Job. Users must design their workload to gracefully handle this. Suspending a Job will reset the StartTime field of the Job, effectively resetting the ActiveDeadlineSeconds timer too. Defaults to false.\n\nThis field is beta-level, gated by SuspendJob feature flag (enabled by default).", } @@ -132,11 +132,12 @@ var map_JobStatus = map[string]string{ "conditions": "The latest available observations of an object's current state. When a Job fails, one of the conditions will have type \"Failed\" and status true. When a Job is suspended, one of the conditions will have type \"Suspended\" and status true; when the Job is resumed, the status of this condition will become false. When a Job is completed, one of the conditions will have type \"Complete\" and status true. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/", "startTime": "Represents time when the job controller started processing a job. When a Job is created in the suspended state, this field is not set until the first time it is resumed. This field is reset every time a Job is resumed from suspension. It is represented in RFC3339 form and is in UTC.", "completionTime": "Represents time when the job was completed. It is not guaranteed to be set in happens-before order across separate operations. It is represented in RFC3339 form and is in UTC. The completion time is only set when the job finishes successfully.", - "active": "The number of actively running pods.", + "active": "The number of pending and running pods.", "succeeded": "The number of pods which reached phase Succeeded.", "failed": "The number of pods which reached phase Failed.", "completedIndexes": "CompletedIndexes holds the completed indexes when .spec.completionMode = \"Indexed\" in a text format. The indexes are represented as decimal integers separated by commas. The numbers are listed in increasing order. Three or more consecutive numbers are compressed and represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as \"1,3-5,7\".", - "uncountedTerminatedPods": "UncountedTerminatedPods holds the UIDs of Pods that have terminated but the job controller hasn't yet accounted for in the status counters.\n\nThe job controller creates pods with a finalizer. When a pod terminates (succeeded or failed), the controller does three steps to account for it in the job status: (1) Add the pod UID to the arrays in this field. (2) Remove the pod finalizer. (3) Remove the pod UID from the arrays while increasing the corresponding\n counter.\n\nThis field is alpha-level. The job controller only makes use of this field when the feature gate PodTrackingWithFinalizers is enabled. Old jobs might not be tracked using this field, in which case the field remains null.", + "uncountedTerminatedPods": "UncountedTerminatedPods holds the UIDs of Pods that have terminated but the job controller hasn't yet accounted for in the status counters.\n\nThe job controller creates pods with a finalizer. When a pod terminates (succeeded or failed), the controller does three steps to account for it in the job status: (1) Add the pod UID to the arrays in this field. (2) Remove the pod finalizer. (3) Remove the pod UID from the arrays while increasing the corresponding\n counter.\n\nThis field is beta-level. The job controller only makes use of this field when the feature gate JobTrackingWithFinalizers is enabled (enabled by default). Old jobs might not be tracked using this field, in which case the field remains null.", + "ready": "The number of pods which have a Ready condition.\n\nThis field is alpha-level. The job controller populates the field when the feature gate JobReadyPods is enabled (disabled by default).", } func (JobStatus) SwaggerDoc() map[string]string { diff --git a/vendor/k8s.io/api/batch/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/batch/v1/zz_generated.deepcopy.go index fe60aaf379..a9806a5024 100644 --- a/vendor/k8s.io/api/batch/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/batch/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -318,6 +319,11 @@ func (in *JobStatus) DeepCopyInto(out *JobStatus) { *out = new(UncountedTerminatedPods) (*in).DeepCopyInto(*out) } + if in.Ready != nil { + in, out := &in.Ready, &out.Ready + *out = new(int32) + **out = **in + } return } diff --git a/vendor/k8s.io/api/batch/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/batch/v1beta1/zz_generated.deepcopy.go index 77244485ba..8c256848dc 100644 --- a/vendor/k8s.io/api/batch/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/batch/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/batch/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/batch/v1beta1/zz_generated.prerelease-lifecycle.go index 5379f896c1..2836b3b014 100644 --- a/vendor/k8s.io/api/batch/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/batch/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/certificates/v1/types.go b/vendor/k8s.io/api/certificates/v1/types.go index 4bfd1fb613..a3900e1dca 100644 --- a/vendor/k8s.io/api/certificates/v1/types.go +++ b/vendor/k8s.io/api/certificates/v1/types.go @@ -214,6 +214,7 @@ type CertificateSigningRequestStatus struct { } // RequestConditionType is the type of a CertificateSigningRequestCondition +// +enum type RequestConditionType string // Well-known condition types for certificate requests. @@ -278,6 +279,7 @@ type CertificateSigningRequestList struct { // KeyUsage specifies valid usage contexts for keys. // See: https://tools.ietf.org/html/rfc5280#section-4.2.1.3 // https://tools.ietf.org/html/rfc5280#section-4.2.1.12 +// +enum type KeyUsage string // Valid key usages diff --git a/vendor/k8s.io/api/certificates/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/certificates/v1/zz_generated.deepcopy.go index af591b46f7..aefa604117 100644 --- a/vendor/k8s.io/api/certificates/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/certificates/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/certificates/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/certificates/v1beta1/zz_generated.deepcopy.go index 48e460aac3..a315e2ac60 100644 --- a/vendor/k8s.io/api/certificates/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/certificates/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/certificates/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/certificates/v1beta1/zz_generated.prerelease-lifecycle.go index 6ccebfe6fb..480a329361 100644 --- a/vendor/k8s.io/api/certificates/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/certificates/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/coordination/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/coordination/v1/zz_generated.deepcopy.go index 2dd7eddbcd..99f6b0be7a 100644 --- a/vendor/k8s.io/api/coordination/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/coordination/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/coordination/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/coordination/v1beta1/zz_generated.deepcopy.go index de6962137e..3adfd87203 100644 --- a/vendor/k8s.io/api/coordination/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/coordination/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/coordination/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/coordination/v1beta1/zz_generated.prerelease-lifecycle.go index 9d18b9225a..18926aa108 100644 --- a/vendor/k8s.io/api/coordination/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/coordination/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/core/v1/annotation_key_constants.go b/vendor/k8s.io/api/core/v1/annotation_key_constants.go index 7fde09126c..eb9517e1dd 100644 --- a/vendor/k8s.io/api/core/v1/annotation_key_constants.go +++ b/vendor/k8s.io/api/core/v1/annotation_key_constants.go @@ -121,7 +121,7 @@ const ( EndpointsLastChangeTriggerTime = "endpoints.kubernetes.io/last-change-trigger-time" // EndpointsOverCapacity will be set on an Endpoints resource when it - // exceeds the maximum capacity of 1000 addresses. Inititially the Endpoints + // exceeds the maximum capacity of 1000 addresses. Initially the Endpoints // controller will set this annotation with a value of "warning". In a // future release, the controller may set this annotation with a value of // "truncated" to indicate that any addresses exceeding the limit of 1000 diff --git a/vendor/k8s.io/api/core/v1/generated.pb.go b/vendor/k8s.io/api/core/v1/generated.pb.go index 2594443719..0418699e63 100644 --- a/vendor/k8s.io/api/core/v1/generated.pb.go +++ b/vendor/k8s.io/api/core/v1/generated.pb.go @@ -1729,10 +1729,38 @@ func (m *GCEPersistentDiskVolumeSource) XXX_DiscardUnknown() { var xxx_messageInfo_GCEPersistentDiskVolumeSource proto.InternalMessageInfo +func (m *GRPCAction) Reset() { *m = GRPCAction{} } +func (*GRPCAction) ProtoMessage() {} +func (*GRPCAction) Descriptor() ([]byte, []int) { + return fileDescriptor_83c10c24ec417dc9, []int{60} +} +func (m *GRPCAction) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GRPCAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *GRPCAction) XXX_Merge(src proto.Message) { + xxx_messageInfo_GRPCAction.Merge(m, src) +} +func (m *GRPCAction) XXX_Size() int { + return m.Size() +} +func (m *GRPCAction) XXX_DiscardUnknown() { + xxx_messageInfo_GRPCAction.DiscardUnknown(m) +} + +var xxx_messageInfo_GRPCAction proto.InternalMessageInfo + func (m *GitRepoVolumeSource) Reset() { *m = GitRepoVolumeSource{} } func (*GitRepoVolumeSource) ProtoMessage() {} func (*GitRepoVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{60} + return fileDescriptor_83c10c24ec417dc9, []int{61} } func (m *GitRepoVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1760,7 +1788,7 @@ var xxx_messageInfo_GitRepoVolumeSource proto.InternalMessageInfo func (m *GlusterfsPersistentVolumeSource) Reset() { *m = GlusterfsPersistentVolumeSource{} } func (*GlusterfsPersistentVolumeSource) ProtoMessage() {} func (*GlusterfsPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{61} + return fileDescriptor_83c10c24ec417dc9, []int{62} } func (m *GlusterfsPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1788,7 +1816,7 @@ var xxx_messageInfo_GlusterfsPersistentVolumeSource proto.InternalMessageInfo func (m *GlusterfsVolumeSource) Reset() { *m = GlusterfsVolumeSource{} } func (*GlusterfsVolumeSource) ProtoMessage() {} func (*GlusterfsVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{62} + return fileDescriptor_83c10c24ec417dc9, []int{63} } func (m *GlusterfsVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1816,7 +1844,7 @@ var xxx_messageInfo_GlusterfsVolumeSource proto.InternalMessageInfo func (m *HTTPGetAction) Reset() { *m = HTTPGetAction{} } func (*HTTPGetAction) ProtoMessage() {} func (*HTTPGetAction) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{63} + return fileDescriptor_83c10c24ec417dc9, []int{64} } func (m *HTTPGetAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1844,7 +1872,7 @@ var xxx_messageInfo_HTTPGetAction proto.InternalMessageInfo func (m *HTTPHeader) Reset() { *m = HTTPHeader{} } func (*HTTPHeader) ProtoMessage() {} func (*HTTPHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{64} + return fileDescriptor_83c10c24ec417dc9, []int{65} } func (m *HTTPHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1869,34 +1897,6 @@ func (m *HTTPHeader) XXX_DiscardUnknown() { var xxx_messageInfo_HTTPHeader proto.InternalMessageInfo -func (m *Handler) Reset() { *m = Handler{} } -func (*Handler) ProtoMessage() {} -func (*Handler) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{65} -} -func (m *Handler) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Handler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil -} -func (m *Handler) XXX_Merge(src proto.Message) { - xxx_messageInfo_Handler.Merge(m, src) -} -func (m *Handler) XXX_Size() int { - return m.Size() -} -func (m *Handler) XXX_DiscardUnknown() { - xxx_messageInfo_Handler.DiscardUnknown(m) -} - -var xxx_messageInfo_Handler proto.InternalMessageInfo - func (m *HostAlias) Reset() { *m = HostAlias{} } func (*HostAlias) ProtoMessage() {} func (*HostAlias) Descriptor() ([]byte, []int) { @@ -2065,10 +2065,38 @@ func (m *Lifecycle) XXX_DiscardUnknown() { var xxx_messageInfo_Lifecycle proto.InternalMessageInfo +func (m *LifecycleHandler) Reset() { *m = LifecycleHandler{} } +func (*LifecycleHandler) ProtoMessage() {} +func (*LifecycleHandler) Descriptor() ([]byte, []int) { + return fileDescriptor_83c10c24ec417dc9, []int{72} +} +func (m *LifecycleHandler) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LifecycleHandler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *LifecycleHandler) XXX_Merge(src proto.Message) { + xxx_messageInfo_LifecycleHandler.Merge(m, src) +} +func (m *LifecycleHandler) XXX_Size() int { + return m.Size() +} +func (m *LifecycleHandler) XXX_DiscardUnknown() { + xxx_messageInfo_LifecycleHandler.DiscardUnknown(m) +} + +var xxx_messageInfo_LifecycleHandler proto.InternalMessageInfo + func (m *LimitRange) Reset() { *m = LimitRange{} } func (*LimitRange) ProtoMessage() {} func (*LimitRange) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{72} + return fileDescriptor_83c10c24ec417dc9, []int{73} } func (m *LimitRange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2096,7 +2124,7 @@ var xxx_messageInfo_LimitRange proto.InternalMessageInfo func (m *LimitRangeItem) Reset() { *m = LimitRangeItem{} } func (*LimitRangeItem) ProtoMessage() {} func (*LimitRangeItem) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{73} + return fileDescriptor_83c10c24ec417dc9, []int{74} } func (m *LimitRangeItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2124,7 +2152,7 @@ var xxx_messageInfo_LimitRangeItem proto.InternalMessageInfo func (m *LimitRangeList) Reset() { *m = LimitRangeList{} } func (*LimitRangeList) ProtoMessage() {} func (*LimitRangeList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{74} + return fileDescriptor_83c10c24ec417dc9, []int{75} } func (m *LimitRangeList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2152,7 +2180,7 @@ var xxx_messageInfo_LimitRangeList proto.InternalMessageInfo func (m *LimitRangeSpec) Reset() { *m = LimitRangeSpec{} } func (*LimitRangeSpec) ProtoMessage() {} func (*LimitRangeSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{75} + return fileDescriptor_83c10c24ec417dc9, []int{76} } func (m *LimitRangeSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2180,7 +2208,7 @@ var xxx_messageInfo_LimitRangeSpec proto.InternalMessageInfo func (m *List) Reset() { *m = List{} } func (*List) ProtoMessage() {} func (*List) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{76} + return fileDescriptor_83c10c24ec417dc9, []int{77} } func (m *List) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2208,7 +2236,7 @@ var xxx_messageInfo_List proto.InternalMessageInfo func (m *LoadBalancerIngress) Reset() { *m = LoadBalancerIngress{} } func (*LoadBalancerIngress) ProtoMessage() {} func (*LoadBalancerIngress) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{77} + return fileDescriptor_83c10c24ec417dc9, []int{78} } func (m *LoadBalancerIngress) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2236,7 +2264,7 @@ var xxx_messageInfo_LoadBalancerIngress proto.InternalMessageInfo func (m *LoadBalancerStatus) Reset() { *m = LoadBalancerStatus{} } func (*LoadBalancerStatus) ProtoMessage() {} func (*LoadBalancerStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{78} + return fileDescriptor_83c10c24ec417dc9, []int{79} } func (m *LoadBalancerStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2264,7 +2292,7 @@ var xxx_messageInfo_LoadBalancerStatus proto.InternalMessageInfo func (m *LocalObjectReference) Reset() { *m = LocalObjectReference{} } func (*LocalObjectReference) ProtoMessage() {} func (*LocalObjectReference) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{79} + return fileDescriptor_83c10c24ec417dc9, []int{80} } func (m *LocalObjectReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2292,7 +2320,7 @@ var xxx_messageInfo_LocalObjectReference proto.InternalMessageInfo func (m *LocalVolumeSource) Reset() { *m = LocalVolumeSource{} } func (*LocalVolumeSource) ProtoMessage() {} func (*LocalVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{80} + return fileDescriptor_83c10c24ec417dc9, []int{81} } func (m *LocalVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2320,7 +2348,7 @@ var xxx_messageInfo_LocalVolumeSource proto.InternalMessageInfo func (m *NFSVolumeSource) Reset() { *m = NFSVolumeSource{} } func (*NFSVolumeSource) ProtoMessage() {} func (*NFSVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{81} + return fileDescriptor_83c10c24ec417dc9, []int{82} } func (m *NFSVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2348,7 +2376,7 @@ var xxx_messageInfo_NFSVolumeSource proto.InternalMessageInfo func (m *Namespace) Reset() { *m = Namespace{} } func (*Namespace) ProtoMessage() {} func (*Namespace) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{82} + return fileDescriptor_83c10c24ec417dc9, []int{83} } func (m *Namespace) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2376,7 +2404,7 @@ var xxx_messageInfo_Namespace proto.InternalMessageInfo func (m *NamespaceCondition) Reset() { *m = NamespaceCondition{} } func (*NamespaceCondition) ProtoMessage() {} func (*NamespaceCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{83} + return fileDescriptor_83c10c24ec417dc9, []int{84} } func (m *NamespaceCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2404,7 +2432,7 @@ var xxx_messageInfo_NamespaceCondition proto.InternalMessageInfo func (m *NamespaceList) Reset() { *m = NamespaceList{} } func (*NamespaceList) ProtoMessage() {} func (*NamespaceList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{84} + return fileDescriptor_83c10c24ec417dc9, []int{85} } func (m *NamespaceList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2432,7 +2460,7 @@ var xxx_messageInfo_NamespaceList proto.InternalMessageInfo func (m *NamespaceSpec) Reset() { *m = NamespaceSpec{} } func (*NamespaceSpec) ProtoMessage() {} func (*NamespaceSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{85} + return fileDescriptor_83c10c24ec417dc9, []int{86} } func (m *NamespaceSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2460,7 +2488,7 @@ var xxx_messageInfo_NamespaceSpec proto.InternalMessageInfo func (m *NamespaceStatus) Reset() { *m = NamespaceStatus{} } func (*NamespaceStatus) ProtoMessage() {} func (*NamespaceStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{86} + return fileDescriptor_83c10c24ec417dc9, []int{87} } func (m *NamespaceStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2488,7 +2516,7 @@ var xxx_messageInfo_NamespaceStatus proto.InternalMessageInfo func (m *Node) Reset() { *m = Node{} } func (*Node) ProtoMessage() {} func (*Node) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{87} + return fileDescriptor_83c10c24ec417dc9, []int{88} } func (m *Node) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2516,7 +2544,7 @@ var xxx_messageInfo_Node proto.InternalMessageInfo func (m *NodeAddress) Reset() { *m = NodeAddress{} } func (*NodeAddress) ProtoMessage() {} func (*NodeAddress) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{88} + return fileDescriptor_83c10c24ec417dc9, []int{89} } func (m *NodeAddress) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2544,7 +2572,7 @@ var xxx_messageInfo_NodeAddress proto.InternalMessageInfo func (m *NodeAffinity) Reset() { *m = NodeAffinity{} } func (*NodeAffinity) ProtoMessage() {} func (*NodeAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{89} + return fileDescriptor_83c10c24ec417dc9, []int{90} } func (m *NodeAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2572,7 +2600,7 @@ var xxx_messageInfo_NodeAffinity proto.InternalMessageInfo func (m *NodeCondition) Reset() { *m = NodeCondition{} } func (*NodeCondition) ProtoMessage() {} func (*NodeCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{90} + return fileDescriptor_83c10c24ec417dc9, []int{91} } func (m *NodeCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2600,7 +2628,7 @@ var xxx_messageInfo_NodeCondition proto.InternalMessageInfo func (m *NodeConfigSource) Reset() { *m = NodeConfigSource{} } func (*NodeConfigSource) ProtoMessage() {} func (*NodeConfigSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{91} + return fileDescriptor_83c10c24ec417dc9, []int{92} } func (m *NodeConfigSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2628,7 +2656,7 @@ var xxx_messageInfo_NodeConfigSource proto.InternalMessageInfo func (m *NodeConfigStatus) Reset() { *m = NodeConfigStatus{} } func (*NodeConfigStatus) ProtoMessage() {} func (*NodeConfigStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{92} + return fileDescriptor_83c10c24ec417dc9, []int{93} } func (m *NodeConfigStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2656,7 +2684,7 @@ var xxx_messageInfo_NodeConfigStatus proto.InternalMessageInfo func (m *NodeDaemonEndpoints) Reset() { *m = NodeDaemonEndpoints{} } func (*NodeDaemonEndpoints) ProtoMessage() {} func (*NodeDaemonEndpoints) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{93} + return fileDescriptor_83c10c24ec417dc9, []int{94} } func (m *NodeDaemonEndpoints) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2684,7 +2712,7 @@ var xxx_messageInfo_NodeDaemonEndpoints proto.InternalMessageInfo func (m *NodeList) Reset() { *m = NodeList{} } func (*NodeList) ProtoMessage() {} func (*NodeList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{94} + return fileDescriptor_83c10c24ec417dc9, []int{95} } func (m *NodeList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2712,7 +2740,7 @@ var xxx_messageInfo_NodeList proto.InternalMessageInfo func (m *NodeProxyOptions) Reset() { *m = NodeProxyOptions{} } func (*NodeProxyOptions) ProtoMessage() {} func (*NodeProxyOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{95} + return fileDescriptor_83c10c24ec417dc9, []int{96} } func (m *NodeProxyOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2740,7 +2768,7 @@ var xxx_messageInfo_NodeProxyOptions proto.InternalMessageInfo func (m *NodeResources) Reset() { *m = NodeResources{} } func (*NodeResources) ProtoMessage() {} func (*NodeResources) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{96} + return fileDescriptor_83c10c24ec417dc9, []int{97} } func (m *NodeResources) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2768,7 +2796,7 @@ var xxx_messageInfo_NodeResources proto.InternalMessageInfo func (m *NodeSelector) Reset() { *m = NodeSelector{} } func (*NodeSelector) ProtoMessage() {} func (*NodeSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{97} + return fileDescriptor_83c10c24ec417dc9, []int{98} } func (m *NodeSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2796,7 +2824,7 @@ var xxx_messageInfo_NodeSelector proto.InternalMessageInfo func (m *NodeSelectorRequirement) Reset() { *m = NodeSelectorRequirement{} } func (*NodeSelectorRequirement) ProtoMessage() {} func (*NodeSelectorRequirement) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{98} + return fileDescriptor_83c10c24ec417dc9, []int{99} } func (m *NodeSelectorRequirement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2824,7 +2852,7 @@ var xxx_messageInfo_NodeSelectorRequirement proto.InternalMessageInfo func (m *NodeSelectorTerm) Reset() { *m = NodeSelectorTerm{} } func (*NodeSelectorTerm) ProtoMessage() {} func (*NodeSelectorTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{99} + return fileDescriptor_83c10c24ec417dc9, []int{100} } func (m *NodeSelectorTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2852,7 +2880,7 @@ var xxx_messageInfo_NodeSelectorTerm proto.InternalMessageInfo func (m *NodeSpec) Reset() { *m = NodeSpec{} } func (*NodeSpec) ProtoMessage() {} func (*NodeSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{100} + return fileDescriptor_83c10c24ec417dc9, []int{101} } func (m *NodeSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2880,7 +2908,7 @@ var xxx_messageInfo_NodeSpec proto.InternalMessageInfo func (m *NodeStatus) Reset() { *m = NodeStatus{} } func (*NodeStatus) ProtoMessage() {} func (*NodeStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{101} + return fileDescriptor_83c10c24ec417dc9, []int{102} } func (m *NodeStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2908,7 +2936,7 @@ var xxx_messageInfo_NodeStatus proto.InternalMessageInfo func (m *NodeSystemInfo) Reset() { *m = NodeSystemInfo{} } func (*NodeSystemInfo) ProtoMessage() {} func (*NodeSystemInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{102} + return fileDescriptor_83c10c24ec417dc9, []int{103} } func (m *NodeSystemInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2936,7 +2964,7 @@ var xxx_messageInfo_NodeSystemInfo proto.InternalMessageInfo func (m *ObjectFieldSelector) Reset() { *m = ObjectFieldSelector{} } func (*ObjectFieldSelector) ProtoMessage() {} func (*ObjectFieldSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{103} + return fileDescriptor_83c10c24ec417dc9, []int{104} } func (m *ObjectFieldSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2964,7 +2992,7 @@ var xxx_messageInfo_ObjectFieldSelector proto.InternalMessageInfo func (m *ObjectReference) Reset() { *m = ObjectReference{} } func (*ObjectReference) ProtoMessage() {} func (*ObjectReference) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{104} + return fileDescriptor_83c10c24ec417dc9, []int{105} } func (m *ObjectReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2992,7 +3020,7 @@ var xxx_messageInfo_ObjectReference proto.InternalMessageInfo func (m *PersistentVolume) Reset() { *m = PersistentVolume{} } func (*PersistentVolume) ProtoMessage() {} func (*PersistentVolume) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{105} + return fileDescriptor_83c10c24ec417dc9, []int{106} } func (m *PersistentVolume) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3020,7 +3048,7 @@ var xxx_messageInfo_PersistentVolume proto.InternalMessageInfo func (m *PersistentVolumeClaim) Reset() { *m = PersistentVolumeClaim{} } func (*PersistentVolumeClaim) ProtoMessage() {} func (*PersistentVolumeClaim) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{106} + return fileDescriptor_83c10c24ec417dc9, []int{107} } func (m *PersistentVolumeClaim) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3048,7 +3076,7 @@ var xxx_messageInfo_PersistentVolumeClaim proto.InternalMessageInfo func (m *PersistentVolumeClaimCondition) Reset() { *m = PersistentVolumeClaimCondition{} } func (*PersistentVolumeClaimCondition) ProtoMessage() {} func (*PersistentVolumeClaimCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{107} + return fileDescriptor_83c10c24ec417dc9, []int{108} } func (m *PersistentVolumeClaimCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3076,7 +3104,7 @@ var xxx_messageInfo_PersistentVolumeClaimCondition proto.InternalMessageInfo func (m *PersistentVolumeClaimList) Reset() { *m = PersistentVolumeClaimList{} } func (*PersistentVolumeClaimList) ProtoMessage() {} func (*PersistentVolumeClaimList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{108} + return fileDescriptor_83c10c24ec417dc9, []int{109} } func (m *PersistentVolumeClaimList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3104,7 +3132,7 @@ var xxx_messageInfo_PersistentVolumeClaimList proto.InternalMessageInfo func (m *PersistentVolumeClaimSpec) Reset() { *m = PersistentVolumeClaimSpec{} } func (*PersistentVolumeClaimSpec) ProtoMessage() {} func (*PersistentVolumeClaimSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{109} + return fileDescriptor_83c10c24ec417dc9, []int{110} } func (m *PersistentVolumeClaimSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3132,7 +3160,7 @@ var xxx_messageInfo_PersistentVolumeClaimSpec proto.InternalMessageInfo func (m *PersistentVolumeClaimStatus) Reset() { *m = PersistentVolumeClaimStatus{} } func (*PersistentVolumeClaimStatus) ProtoMessage() {} func (*PersistentVolumeClaimStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{110} + return fileDescriptor_83c10c24ec417dc9, []int{111} } func (m *PersistentVolumeClaimStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3160,7 +3188,7 @@ var xxx_messageInfo_PersistentVolumeClaimStatus proto.InternalMessageInfo func (m *PersistentVolumeClaimTemplate) Reset() { *m = PersistentVolumeClaimTemplate{} } func (*PersistentVolumeClaimTemplate) ProtoMessage() {} func (*PersistentVolumeClaimTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{111} + return fileDescriptor_83c10c24ec417dc9, []int{112} } func (m *PersistentVolumeClaimTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3188,7 +3216,7 @@ var xxx_messageInfo_PersistentVolumeClaimTemplate proto.InternalMessageInfo func (m *PersistentVolumeClaimVolumeSource) Reset() { *m = PersistentVolumeClaimVolumeSource{} } func (*PersistentVolumeClaimVolumeSource) ProtoMessage() {} func (*PersistentVolumeClaimVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{112} + return fileDescriptor_83c10c24ec417dc9, []int{113} } func (m *PersistentVolumeClaimVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3216,7 +3244,7 @@ var xxx_messageInfo_PersistentVolumeClaimVolumeSource proto.InternalMessageInfo func (m *PersistentVolumeList) Reset() { *m = PersistentVolumeList{} } func (*PersistentVolumeList) ProtoMessage() {} func (*PersistentVolumeList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{113} + return fileDescriptor_83c10c24ec417dc9, []int{114} } func (m *PersistentVolumeList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3244,7 +3272,7 @@ var xxx_messageInfo_PersistentVolumeList proto.InternalMessageInfo func (m *PersistentVolumeSource) Reset() { *m = PersistentVolumeSource{} } func (*PersistentVolumeSource) ProtoMessage() {} func (*PersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{114} + return fileDescriptor_83c10c24ec417dc9, []int{115} } func (m *PersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3272,7 +3300,7 @@ var xxx_messageInfo_PersistentVolumeSource proto.InternalMessageInfo func (m *PersistentVolumeSpec) Reset() { *m = PersistentVolumeSpec{} } func (*PersistentVolumeSpec) ProtoMessage() {} func (*PersistentVolumeSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{115} + return fileDescriptor_83c10c24ec417dc9, []int{116} } func (m *PersistentVolumeSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3300,7 +3328,7 @@ var xxx_messageInfo_PersistentVolumeSpec proto.InternalMessageInfo func (m *PersistentVolumeStatus) Reset() { *m = PersistentVolumeStatus{} } func (*PersistentVolumeStatus) ProtoMessage() {} func (*PersistentVolumeStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{116} + return fileDescriptor_83c10c24ec417dc9, []int{117} } func (m *PersistentVolumeStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3328,7 +3356,7 @@ var xxx_messageInfo_PersistentVolumeStatus proto.InternalMessageInfo func (m *PhotonPersistentDiskVolumeSource) Reset() { *m = PhotonPersistentDiskVolumeSource{} } func (*PhotonPersistentDiskVolumeSource) ProtoMessage() {} func (*PhotonPersistentDiskVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{117} + return fileDescriptor_83c10c24ec417dc9, []int{118} } func (m *PhotonPersistentDiskVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3356,7 +3384,7 @@ var xxx_messageInfo_PhotonPersistentDiskVolumeSource proto.InternalMessageInfo func (m *Pod) Reset() { *m = Pod{} } func (*Pod) ProtoMessage() {} func (*Pod) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{118} + return fileDescriptor_83c10c24ec417dc9, []int{119} } func (m *Pod) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3384,7 +3412,7 @@ var xxx_messageInfo_Pod proto.InternalMessageInfo func (m *PodAffinity) Reset() { *m = PodAffinity{} } func (*PodAffinity) ProtoMessage() {} func (*PodAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{119} + return fileDescriptor_83c10c24ec417dc9, []int{120} } func (m *PodAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3412,7 +3440,7 @@ var xxx_messageInfo_PodAffinity proto.InternalMessageInfo func (m *PodAffinityTerm) Reset() { *m = PodAffinityTerm{} } func (*PodAffinityTerm) ProtoMessage() {} func (*PodAffinityTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{120} + return fileDescriptor_83c10c24ec417dc9, []int{121} } func (m *PodAffinityTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3440,7 +3468,7 @@ var xxx_messageInfo_PodAffinityTerm proto.InternalMessageInfo func (m *PodAntiAffinity) Reset() { *m = PodAntiAffinity{} } func (*PodAntiAffinity) ProtoMessage() {} func (*PodAntiAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{121} + return fileDescriptor_83c10c24ec417dc9, []int{122} } func (m *PodAntiAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3468,7 +3496,7 @@ var xxx_messageInfo_PodAntiAffinity proto.InternalMessageInfo func (m *PodAttachOptions) Reset() { *m = PodAttachOptions{} } func (*PodAttachOptions) ProtoMessage() {} func (*PodAttachOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{122} + return fileDescriptor_83c10c24ec417dc9, []int{123} } func (m *PodAttachOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3496,7 +3524,7 @@ var xxx_messageInfo_PodAttachOptions proto.InternalMessageInfo func (m *PodCondition) Reset() { *m = PodCondition{} } func (*PodCondition) ProtoMessage() {} func (*PodCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{123} + return fileDescriptor_83c10c24ec417dc9, []int{124} } func (m *PodCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3524,7 +3552,7 @@ var xxx_messageInfo_PodCondition proto.InternalMessageInfo func (m *PodDNSConfig) Reset() { *m = PodDNSConfig{} } func (*PodDNSConfig) ProtoMessage() {} func (*PodDNSConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{124} + return fileDescriptor_83c10c24ec417dc9, []int{125} } func (m *PodDNSConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3552,7 +3580,7 @@ var xxx_messageInfo_PodDNSConfig proto.InternalMessageInfo func (m *PodDNSConfigOption) Reset() { *m = PodDNSConfigOption{} } func (*PodDNSConfigOption) ProtoMessage() {} func (*PodDNSConfigOption) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{125} + return fileDescriptor_83c10c24ec417dc9, []int{126} } func (m *PodDNSConfigOption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3580,7 +3608,7 @@ var xxx_messageInfo_PodDNSConfigOption proto.InternalMessageInfo func (m *PodExecOptions) Reset() { *m = PodExecOptions{} } func (*PodExecOptions) ProtoMessage() {} func (*PodExecOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{126} + return fileDescriptor_83c10c24ec417dc9, []int{127} } func (m *PodExecOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3608,7 +3636,7 @@ var xxx_messageInfo_PodExecOptions proto.InternalMessageInfo func (m *PodIP) Reset() { *m = PodIP{} } func (*PodIP) ProtoMessage() {} func (*PodIP) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{127} + return fileDescriptor_83c10c24ec417dc9, []int{128} } func (m *PodIP) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3636,7 +3664,7 @@ var xxx_messageInfo_PodIP proto.InternalMessageInfo func (m *PodList) Reset() { *m = PodList{} } func (*PodList) ProtoMessage() {} func (*PodList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{128} + return fileDescriptor_83c10c24ec417dc9, []int{129} } func (m *PodList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3664,7 +3692,7 @@ var xxx_messageInfo_PodList proto.InternalMessageInfo func (m *PodLogOptions) Reset() { *m = PodLogOptions{} } func (*PodLogOptions) ProtoMessage() {} func (*PodLogOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{129} + return fileDescriptor_83c10c24ec417dc9, []int{130} } func (m *PodLogOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3689,10 +3717,38 @@ func (m *PodLogOptions) XXX_DiscardUnknown() { var xxx_messageInfo_PodLogOptions proto.InternalMessageInfo +func (m *PodOS) Reset() { *m = PodOS{} } +func (*PodOS) ProtoMessage() {} +func (*PodOS) Descriptor() ([]byte, []int) { + return fileDescriptor_83c10c24ec417dc9, []int{131} +} +func (m *PodOS) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PodOS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PodOS) XXX_Merge(src proto.Message) { + xxx_messageInfo_PodOS.Merge(m, src) +} +func (m *PodOS) XXX_Size() int { + return m.Size() +} +func (m *PodOS) XXX_DiscardUnknown() { + xxx_messageInfo_PodOS.DiscardUnknown(m) +} + +var xxx_messageInfo_PodOS proto.InternalMessageInfo + func (m *PodPortForwardOptions) Reset() { *m = PodPortForwardOptions{} } func (*PodPortForwardOptions) ProtoMessage() {} func (*PodPortForwardOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{130} + return fileDescriptor_83c10c24ec417dc9, []int{132} } func (m *PodPortForwardOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3720,7 +3776,7 @@ var xxx_messageInfo_PodPortForwardOptions proto.InternalMessageInfo func (m *PodProxyOptions) Reset() { *m = PodProxyOptions{} } func (*PodProxyOptions) ProtoMessage() {} func (*PodProxyOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{131} + return fileDescriptor_83c10c24ec417dc9, []int{133} } func (m *PodProxyOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3748,7 +3804,7 @@ var xxx_messageInfo_PodProxyOptions proto.InternalMessageInfo func (m *PodReadinessGate) Reset() { *m = PodReadinessGate{} } func (*PodReadinessGate) ProtoMessage() {} func (*PodReadinessGate) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{132} + return fileDescriptor_83c10c24ec417dc9, []int{134} } func (m *PodReadinessGate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3776,7 +3832,7 @@ var xxx_messageInfo_PodReadinessGate proto.InternalMessageInfo func (m *PodSecurityContext) Reset() { *m = PodSecurityContext{} } func (*PodSecurityContext) ProtoMessage() {} func (*PodSecurityContext) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{133} + return fileDescriptor_83c10c24ec417dc9, []int{135} } func (m *PodSecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3804,7 +3860,7 @@ var xxx_messageInfo_PodSecurityContext proto.InternalMessageInfo func (m *PodSignature) Reset() { *m = PodSignature{} } func (*PodSignature) ProtoMessage() {} func (*PodSignature) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{134} + return fileDescriptor_83c10c24ec417dc9, []int{136} } func (m *PodSignature) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3832,7 +3888,7 @@ var xxx_messageInfo_PodSignature proto.InternalMessageInfo func (m *PodSpec) Reset() { *m = PodSpec{} } func (*PodSpec) ProtoMessage() {} func (*PodSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{135} + return fileDescriptor_83c10c24ec417dc9, []int{137} } func (m *PodSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3860,7 +3916,7 @@ var xxx_messageInfo_PodSpec proto.InternalMessageInfo func (m *PodStatus) Reset() { *m = PodStatus{} } func (*PodStatus) ProtoMessage() {} func (*PodStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{136} + return fileDescriptor_83c10c24ec417dc9, []int{138} } func (m *PodStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3888,7 +3944,7 @@ var xxx_messageInfo_PodStatus proto.InternalMessageInfo func (m *PodStatusResult) Reset() { *m = PodStatusResult{} } func (*PodStatusResult) ProtoMessage() {} func (*PodStatusResult) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{137} + return fileDescriptor_83c10c24ec417dc9, []int{139} } func (m *PodStatusResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3916,7 +3972,7 @@ var xxx_messageInfo_PodStatusResult proto.InternalMessageInfo func (m *PodTemplate) Reset() { *m = PodTemplate{} } func (*PodTemplate) ProtoMessage() {} func (*PodTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{138} + return fileDescriptor_83c10c24ec417dc9, []int{140} } func (m *PodTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3944,7 +4000,7 @@ var xxx_messageInfo_PodTemplate proto.InternalMessageInfo func (m *PodTemplateList) Reset() { *m = PodTemplateList{} } func (*PodTemplateList) ProtoMessage() {} func (*PodTemplateList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{139} + return fileDescriptor_83c10c24ec417dc9, []int{141} } func (m *PodTemplateList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3972,7 +4028,7 @@ var xxx_messageInfo_PodTemplateList proto.InternalMessageInfo func (m *PodTemplateSpec) Reset() { *m = PodTemplateSpec{} } func (*PodTemplateSpec) ProtoMessage() {} func (*PodTemplateSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{140} + return fileDescriptor_83c10c24ec417dc9, []int{142} } func (m *PodTemplateSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4000,7 +4056,7 @@ var xxx_messageInfo_PodTemplateSpec proto.InternalMessageInfo func (m *PortStatus) Reset() { *m = PortStatus{} } func (*PortStatus) ProtoMessage() {} func (*PortStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{141} + return fileDescriptor_83c10c24ec417dc9, []int{143} } func (m *PortStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4028,7 +4084,7 @@ var xxx_messageInfo_PortStatus proto.InternalMessageInfo func (m *PortworxVolumeSource) Reset() { *m = PortworxVolumeSource{} } func (*PortworxVolumeSource) ProtoMessage() {} func (*PortworxVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{142} + return fileDescriptor_83c10c24ec417dc9, []int{144} } func (m *PortworxVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4056,7 +4112,7 @@ var xxx_messageInfo_PortworxVolumeSource proto.InternalMessageInfo func (m *Preconditions) Reset() { *m = Preconditions{} } func (*Preconditions) ProtoMessage() {} func (*Preconditions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{143} + return fileDescriptor_83c10c24ec417dc9, []int{145} } func (m *Preconditions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4084,7 +4140,7 @@ var xxx_messageInfo_Preconditions proto.InternalMessageInfo func (m *PreferAvoidPodsEntry) Reset() { *m = PreferAvoidPodsEntry{} } func (*PreferAvoidPodsEntry) ProtoMessage() {} func (*PreferAvoidPodsEntry) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{144} + return fileDescriptor_83c10c24ec417dc9, []int{146} } func (m *PreferAvoidPodsEntry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4112,7 +4168,7 @@ var xxx_messageInfo_PreferAvoidPodsEntry proto.InternalMessageInfo func (m *PreferredSchedulingTerm) Reset() { *m = PreferredSchedulingTerm{} } func (*PreferredSchedulingTerm) ProtoMessage() {} func (*PreferredSchedulingTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{145} + return fileDescriptor_83c10c24ec417dc9, []int{147} } func (m *PreferredSchedulingTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4140,7 +4196,7 @@ var xxx_messageInfo_PreferredSchedulingTerm proto.InternalMessageInfo func (m *Probe) Reset() { *m = Probe{} } func (*Probe) ProtoMessage() {} func (*Probe) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{146} + return fileDescriptor_83c10c24ec417dc9, []int{148} } func (m *Probe) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4165,10 +4221,38 @@ func (m *Probe) XXX_DiscardUnknown() { var xxx_messageInfo_Probe proto.InternalMessageInfo +func (m *ProbeHandler) Reset() { *m = ProbeHandler{} } +func (*ProbeHandler) ProtoMessage() {} +func (*ProbeHandler) Descriptor() ([]byte, []int) { + return fileDescriptor_83c10c24ec417dc9, []int{149} +} +func (m *ProbeHandler) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProbeHandler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ProbeHandler) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProbeHandler.Merge(m, src) +} +func (m *ProbeHandler) XXX_Size() int { + return m.Size() +} +func (m *ProbeHandler) XXX_DiscardUnknown() { + xxx_messageInfo_ProbeHandler.DiscardUnknown(m) +} + +var xxx_messageInfo_ProbeHandler proto.InternalMessageInfo + func (m *ProjectedVolumeSource) Reset() { *m = ProjectedVolumeSource{} } func (*ProjectedVolumeSource) ProtoMessage() {} func (*ProjectedVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{147} + return fileDescriptor_83c10c24ec417dc9, []int{150} } func (m *ProjectedVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4196,7 +4280,7 @@ var xxx_messageInfo_ProjectedVolumeSource proto.InternalMessageInfo func (m *QuobyteVolumeSource) Reset() { *m = QuobyteVolumeSource{} } func (*QuobyteVolumeSource) ProtoMessage() {} func (*QuobyteVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{148} + return fileDescriptor_83c10c24ec417dc9, []int{151} } func (m *QuobyteVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4224,7 +4308,7 @@ var xxx_messageInfo_QuobyteVolumeSource proto.InternalMessageInfo func (m *RBDPersistentVolumeSource) Reset() { *m = RBDPersistentVolumeSource{} } func (*RBDPersistentVolumeSource) ProtoMessage() {} func (*RBDPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{149} + return fileDescriptor_83c10c24ec417dc9, []int{152} } func (m *RBDPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4252,7 +4336,7 @@ var xxx_messageInfo_RBDPersistentVolumeSource proto.InternalMessageInfo func (m *RBDVolumeSource) Reset() { *m = RBDVolumeSource{} } func (*RBDVolumeSource) ProtoMessage() {} func (*RBDVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{150} + return fileDescriptor_83c10c24ec417dc9, []int{153} } func (m *RBDVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4280,7 +4364,7 @@ var xxx_messageInfo_RBDVolumeSource proto.InternalMessageInfo func (m *RangeAllocation) Reset() { *m = RangeAllocation{} } func (*RangeAllocation) ProtoMessage() {} func (*RangeAllocation) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{151} + return fileDescriptor_83c10c24ec417dc9, []int{154} } func (m *RangeAllocation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4308,7 +4392,7 @@ var xxx_messageInfo_RangeAllocation proto.InternalMessageInfo func (m *ReplicationController) Reset() { *m = ReplicationController{} } func (*ReplicationController) ProtoMessage() {} func (*ReplicationController) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{152} + return fileDescriptor_83c10c24ec417dc9, []int{155} } func (m *ReplicationController) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4336,7 +4420,7 @@ var xxx_messageInfo_ReplicationController proto.InternalMessageInfo func (m *ReplicationControllerCondition) Reset() { *m = ReplicationControllerCondition{} } func (*ReplicationControllerCondition) ProtoMessage() {} func (*ReplicationControllerCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{153} + return fileDescriptor_83c10c24ec417dc9, []int{156} } func (m *ReplicationControllerCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4364,7 +4448,7 @@ var xxx_messageInfo_ReplicationControllerCondition proto.InternalMessageInfo func (m *ReplicationControllerList) Reset() { *m = ReplicationControllerList{} } func (*ReplicationControllerList) ProtoMessage() {} func (*ReplicationControllerList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{154} + return fileDescriptor_83c10c24ec417dc9, []int{157} } func (m *ReplicationControllerList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4392,7 +4476,7 @@ var xxx_messageInfo_ReplicationControllerList proto.InternalMessageInfo func (m *ReplicationControllerSpec) Reset() { *m = ReplicationControllerSpec{} } func (*ReplicationControllerSpec) ProtoMessage() {} func (*ReplicationControllerSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{155} + return fileDescriptor_83c10c24ec417dc9, []int{158} } func (m *ReplicationControllerSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4420,7 +4504,7 @@ var xxx_messageInfo_ReplicationControllerSpec proto.InternalMessageInfo func (m *ReplicationControllerStatus) Reset() { *m = ReplicationControllerStatus{} } func (*ReplicationControllerStatus) ProtoMessage() {} func (*ReplicationControllerStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{156} + return fileDescriptor_83c10c24ec417dc9, []int{159} } func (m *ReplicationControllerStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4448,7 +4532,7 @@ var xxx_messageInfo_ReplicationControllerStatus proto.InternalMessageInfo func (m *ResourceFieldSelector) Reset() { *m = ResourceFieldSelector{} } func (*ResourceFieldSelector) ProtoMessage() {} func (*ResourceFieldSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{157} + return fileDescriptor_83c10c24ec417dc9, []int{160} } func (m *ResourceFieldSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4476,7 +4560,7 @@ var xxx_messageInfo_ResourceFieldSelector proto.InternalMessageInfo func (m *ResourceQuota) Reset() { *m = ResourceQuota{} } func (*ResourceQuota) ProtoMessage() {} func (*ResourceQuota) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{158} + return fileDescriptor_83c10c24ec417dc9, []int{161} } func (m *ResourceQuota) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4504,7 +4588,7 @@ var xxx_messageInfo_ResourceQuota proto.InternalMessageInfo func (m *ResourceQuotaList) Reset() { *m = ResourceQuotaList{} } func (*ResourceQuotaList) ProtoMessage() {} func (*ResourceQuotaList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{159} + return fileDescriptor_83c10c24ec417dc9, []int{162} } func (m *ResourceQuotaList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4532,7 +4616,7 @@ var xxx_messageInfo_ResourceQuotaList proto.InternalMessageInfo func (m *ResourceQuotaSpec) Reset() { *m = ResourceQuotaSpec{} } func (*ResourceQuotaSpec) ProtoMessage() {} func (*ResourceQuotaSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{160} + return fileDescriptor_83c10c24ec417dc9, []int{163} } func (m *ResourceQuotaSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4560,7 +4644,7 @@ var xxx_messageInfo_ResourceQuotaSpec proto.InternalMessageInfo func (m *ResourceQuotaStatus) Reset() { *m = ResourceQuotaStatus{} } func (*ResourceQuotaStatus) ProtoMessage() {} func (*ResourceQuotaStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{161} + return fileDescriptor_83c10c24ec417dc9, []int{164} } func (m *ResourceQuotaStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4588,7 +4672,7 @@ var xxx_messageInfo_ResourceQuotaStatus proto.InternalMessageInfo func (m *ResourceRequirements) Reset() { *m = ResourceRequirements{} } func (*ResourceRequirements) ProtoMessage() {} func (*ResourceRequirements) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{162} + return fileDescriptor_83c10c24ec417dc9, []int{165} } func (m *ResourceRequirements) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4616,7 +4700,7 @@ var xxx_messageInfo_ResourceRequirements proto.InternalMessageInfo func (m *SELinuxOptions) Reset() { *m = SELinuxOptions{} } func (*SELinuxOptions) ProtoMessage() {} func (*SELinuxOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{163} + return fileDescriptor_83c10c24ec417dc9, []int{166} } func (m *SELinuxOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4644,7 +4728,7 @@ var xxx_messageInfo_SELinuxOptions proto.InternalMessageInfo func (m *ScaleIOPersistentVolumeSource) Reset() { *m = ScaleIOPersistentVolumeSource{} } func (*ScaleIOPersistentVolumeSource) ProtoMessage() {} func (*ScaleIOPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{164} + return fileDescriptor_83c10c24ec417dc9, []int{167} } func (m *ScaleIOPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4672,7 +4756,7 @@ var xxx_messageInfo_ScaleIOPersistentVolumeSource proto.InternalMessageInfo func (m *ScaleIOVolumeSource) Reset() { *m = ScaleIOVolumeSource{} } func (*ScaleIOVolumeSource) ProtoMessage() {} func (*ScaleIOVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{165} + return fileDescriptor_83c10c24ec417dc9, []int{168} } func (m *ScaleIOVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4700,7 +4784,7 @@ var xxx_messageInfo_ScaleIOVolumeSource proto.InternalMessageInfo func (m *ScopeSelector) Reset() { *m = ScopeSelector{} } func (*ScopeSelector) ProtoMessage() {} func (*ScopeSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{166} + return fileDescriptor_83c10c24ec417dc9, []int{169} } func (m *ScopeSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4728,7 +4812,7 @@ var xxx_messageInfo_ScopeSelector proto.InternalMessageInfo func (m *ScopedResourceSelectorRequirement) Reset() { *m = ScopedResourceSelectorRequirement{} } func (*ScopedResourceSelectorRequirement) ProtoMessage() {} func (*ScopedResourceSelectorRequirement) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{167} + return fileDescriptor_83c10c24ec417dc9, []int{170} } func (m *ScopedResourceSelectorRequirement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4756,7 +4840,7 @@ var xxx_messageInfo_ScopedResourceSelectorRequirement proto.InternalMessageInfo func (m *SeccompProfile) Reset() { *m = SeccompProfile{} } func (*SeccompProfile) ProtoMessage() {} func (*SeccompProfile) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{168} + return fileDescriptor_83c10c24ec417dc9, []int{171} } func (m *SeccompProfile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4784,7 +4868,7 @@ var xxx_messageInfo_SeccompProfile proto.InternalMessageInfo func (m *Secret) Reset() { *m = Secret{} } func (*Secret) ProtoMessage() {} func (*Secret) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{169} + return fileDescriptor_83c10c24ec417dc9, []int{172} } func (m *Secret) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4812,7 +4896,7 @@ var xxx_messageInfo_Secret proto.InternalMessageInfo func (m *SecretEnvSource) Reset() { *m = SecretEnvSource{} } func (*SecretEnvSource) ProtoMessage() {} func (*SecretEnvSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{170} + return fileDescriptor_83c10c24ec417dc9, []int{173} } func (m *SecretEnvSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4840,7 +4924,7 @@ var xxx_messageInfo_SecretEnvSource proto.InternalMessageInfo func (m *SecretKeySelector) Reset() { *m = SecretKeySelector{} } func (*SecretKeySelector) ProtoMessage() {} func (*SecretKeySelector) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{171} + return fileDescriptor_83c10c24ec417dc9, []int{174} } func (m *SecretKeySelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4868,7 +4952,7 @@ var xxx_messageInfo_SecretKeySelector proto.InternalMessageInfo func (m *SecretList) Reset() { *m = SecretList{} } func (*SecretList) ProtoMessage() {} func (*SecretList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{172} + return fileDescriptor_83c10c24ec417dc9, []int{175} } func (m *SecretList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4896,7 +4980,7 @@ var xxx_messageInfo_SecretList proto.InternalMessageInfo func (m *SecretProjection) Reset() { *m = SecretProjection{} } func (*SecretProjection) ProtoMessage() {} func (*SecretProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{173} + return fileDescriptor_83c10c24ec417dc9, []int{176} } func (m *SecretProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4924,7 +5008,7 @@ var xxx_messageInfo_SecretProjection proto.InternalMessageInfo func (m *SecretReference) Reset() { *m = SecretReference{} } func (*SecretReference) ProtoMessage() {} func (*SecretReference) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{174} + return fileDescriptor_83c10c24ec417dc9, []int{177} } func (m *SecretReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4952,7 +5036,7 @@ var xxx_messageInfo_SecretReference proto.InternalMessageInfo func (m *SecretVolumeSource) Reset() { *m = SecretVolumeSource{} } func (*SecretVolumeSource) ProtoMessage() {} func (*SecretVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{175} + return fileDescriptor_83c10c24ec417dc9, []int{178} } func (m *SecretVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4980,7 +5064,7 @@ var xxx_messageInfo_SecretVolumeSource proto.InternalMessageInfo func (m *SecurityContext) Reset() { *m = SecurityContext{} } func (*SecurityContext) ProtoMessage() {} func (*SecurityContext) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{176} + return fileDescriptor_83c10c24ec417dc9, []int{179} } func (m *SecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5008,7 +5092,7 @@ var xxx_messageInfo_SecurityContext proto.InternalMessageInfo func (m *SerializedReference) Reset() { *m = SerializedReference{} } func (*SerializedReference) ProtoMessage() {} func (*SerializedReference) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{177} + return fileDescriptor_83c10c24ec417dc9, []int{180} } func (m *SerializedReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5036,7 +5120,7 @@ var xxx_messageInfo_SerializedReference proto.InternalMessageInfo func (m *Service) Reset() { *m = Service{} } func (*Service) ProtoMessage() {} func (*Service) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{178} + return fileDescriptor_83c10c24ec417dc9, []int{181} } func (m *Service) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5064,7 +5148,7 @@ var xxx_messageInfo_Service proto.InternalMessageInfo func (m *ServiceAccount) Reset() { *m = ServiceAccount{} } func (*ServiceAccount) ProtoMessage() {} func (*ServiceAccount) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{179} + return fileDescriptor_83c10c24ec417dc9, []int{182} } func (m *ServiceAccount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5092,7 +5176,7 @@ var xxx_messageInfo_ServiceAccount proto.InternalMessageInfo func (m *ServiceAccountList) Reset() { *m = ServiceAccountList{} } func (*ServiceAccountList) ProtoMessage() {} func (*ServiceAccountList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{180} + return fileDescriptor_83c10c24ec417dc9, []int{183} } func (m *ServiceAccountList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5120,7 +5204,7 @@ var xxx_messageInfo_ServiceAccountList proto.InternalMessageInfo func (m *ServiceAccountTokenProjection) Reset() { *m = ServiceAccountTokenProjection{} } func (*ServiceAccountTokenProjection) ProtoMessage() {} func (*ServiceAccountTokenProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{181} + return fileDescriptor_83c10c24ec417dc9, []int{184} } func (m *ServiceAccountTokenProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5148,7 +5232,7 @@ var xxx_messageInfo_ServiceAccountTokenProjection proto.InternalMessageInfo func (m *ServiceList) Reset() { *m = ServiceList{} } func (*ServiceList) ProtoMessage() {} func (*ServiceList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{182} + return fileDescriptor_83c10c24ec417dc9, []int{185} } func (m *ServiceList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5176,7 +5260,7 @@ var xxx_messageInfo_ServiceList proto.InternalMessageInfo func (m *ServicePort) Reset() { *m = ServicePort{} } func (*ServicePort) ProtoMessage() {} func (*ServicePort) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{183} + return fileDescriptor_83c10c24ec417dc9, []int{186} } func (m *ServicePort) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5204,7 +5288,7 @@ var xxx_messageInfo_ServicePort proto.InternalMessageInfo func (m *ServiceProxyOptions) Reset() { *m = ServiceProxyOptions{} } func (*ServiceProxyOptions) ProtoMessage() {} func (*ServiceProxyOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{184} + return fileDescriptor_83c10c24ec417dc9, []int{187} } func (m *ServiceProxyOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5232,7 +5316,7 @@ var xxx_messageInfo_ServiceProxyOptions proto.InternalMessageInfo func (m *ServiceSpec) Reset() { *m = ServiceSpec{} } func (*ServiceSpec) ProtoMessage() {} func (*ServiceSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{185} + return fileDescriptor_83c10c24ec417dc9, []int{188} } func (m *ServiceSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5260,7 +5344,7 @@ var xxx_messageInfo_ServiceSpec proto.InternalMessageInfo func (m *ServiceStatus) Reset() { *m = ServiceStatus{} } func (*ServiceStatus) ProtoMessage() {} func (*ServiceStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{186} + return fileDescriptor_83c10c24ec417dc9, []int{189} } func (m *ServiceStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5288,7 +5372,7 @@ var xxx_messageInfo_ServiceStatus proto.InternalMessageInfo func (m *SessionAffinityConfig) Reset() { *m = SessionAffinityConfig{} } func (*SessionAffinityConfig) ProtoMessage() {} func (*SessionAffinityConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{187} + return fileDescriptor_83c10c24ec417dc9, []int{190} } func (m *SessionAffinityConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5316,7 +5400,7 @@ var xxx_messageInfo_SessionAffinityConfig proto.InternalMessageInfo func (m *StorageOSPersistentVolumeSource) Reset() { *m = StorageOSPersistentVolumeSource{} } func (*StorageOSPersistentVolumeSource) ProtoMessage() {} func (*StorageOSPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{188} + return fileDescriptor_83c10c24ec417dc9, []int{191} } func (m *StorageOSPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5344,7 +5428,7 @@ var xxx_messageInfo_StorageOSPersistentVolumeSource proto.InternalMessageInfo func (m *StorageOSVolumeSource) Reset() { *m = StorageOSVolumeSource{} } func (*StorageOSVolumeSource) ProtoMessage() {} func (*StorageOSVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{189} + return fileDescriptor_83c10c24ec417dc9, []int{192} } func (m *StorageOSVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5372,7 +5456,7 @@ var xxx_messageInfo_StorageOSVolumeSource proto.InternalMessageInfo func (m *Sysctl) Reset() { *m = Sysctl{} } func (*Sysctl) ProtoMessage() {} func (*Sysctl) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{190} + return fileDescriptor_83c10c24ec417dc9, []int{193} } func (m *Sysctl) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5400,7 +5484,7 @@ var xxx_messageInfo_Sysctl proto.InternalMessageInfo func (m *TCPSocketAction) Reset() { *m = TCPSocketAction{} } func (*TCPSocketAction) ProtoMessage() {} func (*TCPSocketAction) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{191} + return fileDescriptor_83c10c24ec417dc9, []int{194} } func (m *TCPSocketAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5428,7 +5512,7 @@ var xxx_messageInfo_TCPSocketAction proto.InternalMessageInfo func (m *Taint) Reset() { *m = Taint{} } func (*Taint) ProtoMessage() {} func (*Taint) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{192} + return fileDescriptor_83c10c24ec417dc9, []int{195} } func (m *Taint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5456,7 +5540,7 @@ var xxx_messageInfo_Taint proto.InternalMessageInfo func (m *Toleration) Reset() { *m = Toleration{} } func (*Toleration) ProtoMessage() {} func (*Toleration) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{193} + return fileDescriptor_83c10c24ec417dc9, []int{196} } func (m *Toleration) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5484,7 +5568,7 @@ var xxx_messageInfo_Toleration proto.InternalMessageInfo func (m *TopologySelectorLabelRequirement) Reset() { *m = TopologySelectorLabelRequirement{} } func (*TopologySelectorLabelRequirement) ProtoMessage() {} func (*TopologySelectorLabelRequirement) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{194} + return fileDescriptor_83c10c24ec417dc9, []int{197} } func (m *TopologySelectorLabelRequirement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5512,7 +5596,7 @@ var xxx_messageInfo_TopologySelectorLabelRequirement proto.InternalMessageInfo func (m *TopologySelectorTerm) Reset() { *m = TopologySelectorTerm{} } func (*TopologySelectorTerm) ProtoMessage() {} func (*TopologySelectorTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{195} + return fileDescriptor_83c10c24ec417dc9, []int{198} } func (m *TopologySelectorTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5540,7 +5624,7 @@ var xxx_messageInfo_TopologySelectorTerm proto.InternalMessageInfo func (m *TopologySpreadConstraint) Reset() { *m = TopologySpreadConstraint{} } func (*TopologySpreadConstraint) ProtoMessage() {} func (*TopologySpreadConstraint) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{196} + return fileDescriptor_83c10c24ec417dc9, []int{199} } func (m *TopologySpreadConstraint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5568,7 +5652,7 @@ var xxx_messageInfo_TopologySpreadConstraint proto.InternalMessageInfo func (m *TypedLocalObjectReference) Reset() { *m = TypedLocalObjectReference{} } func (*TypedLocalObjectReference) ProtoMessage() {} func (*TypedLocalObjectReference) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{197} + return fileDescriptor_83c10c24ec417dc9, []int{200} } func (m *TypedLocalObjectReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5596,7 +5680,7 @@ var xxx_messageInfo_TypedLocalObjectReference proto.InternalMessageInfo func (m *Volume) Reset() { *m = Volume{} } func (*Volume) ProtoMessage() {} func (*Volume) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{198} + return fileDescriptor_83c10c24ec417dc9, []int{201} } func (m *Volume) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5624,7 +5708,7 @@ var xxx_messageInfo_Volume proto.InternalMessageInfo func (m *VolumeDevice) Reset() { *m = VolumeDevice{} } func (*VolumeDevice) ProtoMessage() {} func (*VolumeDevice) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{199} + return fileDescriptor_83c10c24ec417dc9, []int{202} } func (m *VolumeDevice) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5652,7 +5736,7 @@ var xxx_messageInfo_VolumeDevice proto.InternalMessageInfo func (m *VolumeMount) Reset() { *m = VolumeMount{} } func (*VolumeMount) ProtoMessage() {} func (*VolumeMount) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{200} + return fileDescriptor_83c10c24ec417dc9, []int{203} } func (m *VolumeMount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5680,7 +5764,7 @@ var xxx_messageInfo_VolumeMount proto.InternalMessageInfo func (m *VolumeNodeAffinity) Reset() { *m = VolumeNodeAffinity{} } func (*VolumeNodeAffinity) ProtoMessage() {} func (*VolumeNodeAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{201} + return fileDescriptor_83c10c24ec417dc9, []int{204} } func (m *VolumeNodeAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5708,7 +5792,7 @@ var xxx_messageInfo_VolumeNodeAffinity proto.InternalMessageInfo func (m *VolumeProjection) Reset() { *m = VolumeProjection{} } func (*VolumeProjection) ProtoMessage() {} func (*VolumeProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{202} + return fileDescriptor_83c10c24ec417dc9, []int{205} } func (m *VolumeProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5736,7 +5820,7 @@ var xxx_messageInfo_VolumeProjection proto.InternalMessageInfo func (m *VolumeSource) Reset() { *m = VolumeSource{} } func (*VolumeSource) ProtoMessage() {} func (*VolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{203} + return fileDescriptor_83c10c24ec417dc9, []int{206} } func (m *VolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5764,7 +5848,7 @@ var xxx_messageInfo_VolumeSource proto.InternalMessageInfo func (m *VsphereVirtualDiskVolumeSource) Reset() { *m = VsphereVirtualDiskVolumeSource{} } func (*VsphereVirtualDiskVolumeSource) ProtoMessage() {} func (*VsphereVirtualDiskVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{204} + return fileDescriptor_83c10c24ec417dc9, []int{207} } func (m *VsphereVirtualDiskVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5792,7 +5876,7 @@ var xxx_messageInfo_VsphereVirtualDiskVolumeSource proto.InternalMessageInfo func (m *WeightedPodAffinityTerm) Reset() { *m = WeightedPodAffinityTerm{} } func (*WeightedPodAffinityTerm) ProtoMessage() {} func (*WeightedPodAffinityTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{205} + return fileDescriptor_83c10c24ec417dc9, []int{208} } func (m *WeightedPodAffinityTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5820,7 +5904,7 @@ var xxx_messageInfo_WeightedPodAffinityTerm proto.InternalMessageInfo func (m *WindowsSecurityContextOptions) Reset() { *m = WindowsSecurityContextOptions{} } func (*WindowsSecurityContextOptions) ProtoMessage() {} func (*WindowsSecurityContextOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{206} + return fileDescriptor_83c10c24ec417dc9, []int{209} } func (m *WindowsSecurityContextOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5912,18 +5996,19 @@ func init() { proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.core.v1.FlexVolumeSource.OptionsEntry") proto.RegisterType((*FlockerVolumeSource)(nil), "k8s.io.api.core.v1.FlockerVolumeSource") proto.RegisterType((*GCEPersistentDiskVolumeSource)(nil), "k8s.io.api.core.v1.GCEPersistentDiskVolumeSource") + proto.RegisterType((*GRPCAction)(nil), "k8s.io.api.core.v1.GRPCAction") proto.RegisterType((*GitRepoVolumeSource)(nil), "k8s.io.api.core.v1.GitRepoVolumeSource") proto.RegisterType((*GlusterfsPersistentVolumeSource)(nil), "k8s.io.api.core.v1.GlusterfsPersistentVolumeSource") proto.RegisterType((*GlusterfsVolumeSource)(nil), "k8s.io.api.core.v1.GlusterfsVolumeSource") proto.RegisterType((*HTTPGetAction)(nil), "k8s.io.api.core.v1.HTTPGetAction") proto.RegisterType((*HTTPHeader)(nil), "k8s.io.api.core.v1.HTTPHeader") - proto.RegisterType((*Handler)(nil), "k8s.io.api.core.v1.Handler") proto.RegisterType((*HostAlias)(nil), "k8s.io.api.core.v1.HostAlias") proto.RegisterType((*HostPathVolumeSource)(nil), "k8s.io.api.core.v1.HostPathVolumeSource") proto.RegisterType((*ISCSIPersistentVolumeSource)(nil), "k8s.io.api.core.v1.ISCSIPersistentVolumeSource") proto.RegisterType((*ISCSIVolumeSource)(nil), "k8s.io.api.core.v1.ISCSIVolumeSource") proto.RegisterType((*KeyToPath)(nil), "k8s.io.api.core.v1.KeyToPath") proto.RegisterType((*Lifecycle)(nil), "k8s.io.api.core.v1.Lifecycle") + proto.RegisterType((*LifecycleHandler)(nil), "k8s.io.api.core.v1.LifecycleHandler") proto.RegisterType((*LimitRange)(nil), "k8s.io.api.core.v1.LimitRange") proto.RegisterType((*LimitRangeItem)(nil), "k8s.io.api.core.v1.LimitRangeItem") proto.RegisterMapType((ResourceList)(nil), "k8s.io.api.core.v1.LimitRangeItem.DefaultEntry") @@ -5971,6 +6056,7 @@ func init() { proto.RegisterType((*PersistentVolumeClaimList)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimList") proto.RegisterType((*PersistentVolumeClaimSpec)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimSpec") proto.RegisterType((*PersistentVolumeClaimStatus)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimStatus") + proto.RegisterMapType((ResourceList)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimStatus.AllocatedResourcesEntry") proto.RegisterMapType((ResourceList)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimStatus.CapacityEntry") proto.RegisterType((*PersistentVolumeClaimTemplate)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimTemplate") proto.RegisterType((*PersistentVolumeClaimVolumeSource)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimVolumeSource") @@ -5992,6 +6078,7 @@ func init() { proto.RegisterType((*PodIP)(nil), "k8s.io.api.core.v1.PodIP") proto.RegisterType((*PodList)(nil), "k8s.io.api.core.v1.PodList") proto.RegisterType((*PodLogOptions)(nil), "k8s.io.api.core.v1.PodLogOptions") + proto.RegisterType((*PodOS)(nil), "k8s.io.api.core.v1.PodOS") proto.RegisterType((*PodPortForwardOptions)(nil), "k8s.io.api.core.v1.PodPortForwardOptions") proto.RegisterType((*PodProxyOptions)(nil), "k8s.io.api.core.v1.PodProxyOptions") proto.RegisterType((*PodReadinessGate)(nil), "k8s.io.api.core.v1.PodReadinessGate") @@ -6011,6 +6098,7 @@ func init() { proto.RegisterType((*PreferAvoidPodsEntry)(nil), "k8s.io.api.core.v1.PreferAvoidPodsEntry") proto.RegisterType((*PreferredSchedulingTerm)(nil), "k8s.io.api.core.v1.PreferredSchedulingTerm") proto.RegisterType((*Probe)(nil), "k8s.io.api.core.v1.Probe") + proto.RegisterType((*ProbeHandler)(nil), "k8s.io.api.core.v1.ProbeHandler") proto.RegisterType((*ProjectedVolumeSource)(nil), "k8s.io.api.core.v1.ProjectedVolumeSource") proto.RegisterType((*QuobyteVolumeSource)(nil), "k8s.io.api.core.v1.QuobyteVolumeSource") proto.RegisterType((*RBDPersistentVolumeSource)(nil), "k8s.io.api.core.v1.RBDPersistentVolumeSource") @@ -6087,887 +6175,897 @@ func init() { } var fileDescriptor_83c10c24ec417dc9 = []byte{ - // 14068 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x69, 0x70, 0x5c, 0xd9, - 0x79, 0x18, 0xaa, 0xdb, 0x8d, 0xad, 0x3f, 0xec, 0x07, 0x24, 0x07, 0xc4, 0x0c, 0x09, 0xce, 0xa5, - 0xc4, 0xe1, 0x68, 0x66, 0x40, 0x71, 0x16, 0x69, 0x3c, 0x23, 0x8d, 0x05, 0xa0, 0x01, 0xb2, 0x87, - 0x04, 0xd8, 0x73, 0x1a, 0x24, 0x25, 0x79, 0xa4, 0xd2, 0x45, 0xf7, 0x01, 0x70, 0x85, 0xee, 0x7b, - 0x7b, 0xee, 0xbd, 0x0d, 0x12, 0xf3, 0xe4, 0x7a, 0x7e, 0xf2, 0x2a, 0x2f, 0xaf, 0x54, 0xaf, 0xfc, - 0xb2, 0xd8, 0x2e, 0x57, 0xca, 0x71, 0xca, 0x56, 0x94, 0xcd, 0xb1, 0x63, 0x3b, 0x96, 0x13, 0x3b, - 0xbb, 0x93, 0x1f, 0x8e, 0xe3, 0x4a, 0x2c, 0x57, 0xb9, 0x82, 0xd8, 0x74, 0xaa, 0x5c, 0xfa, 0x11, - 0xdb, 0x89, 0x93, 0x1f, 0x41, 0x5c, 0x71, 0xea, 0xac, 0xf7, 0x9c, 0xbb, 0x74, 0x37, 0x38, 0x20, - 0x34, 0x52, 0xcd, 0xbf, 0xee, 0xf3, 0x7d, 0xe7, 0x3b, 0xe7, 0x9e, 0xf5, 0x3b, 0xdf, 0x0a, 0xaf, - 0xee, 0xbe, 0x1c, 0x2e, 0xb8, 0xfe, 0x95, 0xdd, 0xce, 0x26, 0x09, 0x3c, 0x12, 0x91, 0xf0, 0xca, - 0x1e, 0xf1, 0x1a, 0x7e, 0x70, 0x45, 0x00, 0x9c, 0xb6, 0x7b, 0xa5, 0xee, 0x07, 0xe4, 0xca, 0xde, - 0xd5, 0x2b, 0xdb, 0xc4, 0x23, 0x81, 0x13, 0x91, 0xc6, 0x42, 0x3b, 0xf0, 0x23, 0x1f, 0x21, 0x8e, - 0xb3, 0xe0, 0xb4, 0xdd, 0x05, 0x8a, 0xb3, 0xb0, 0x77, 0x75, 0xee, 0xb9, 0x6d, 0x37, 0xda, 0xe9, - 0x6c, 0x2e, 0xd4, 0xfd, 0xd6, 0x95, 0x6d, 0x7f, 0xdb, 0xbf, 0xc2, 0x50, 0x37, 0x3b, 0x5b, 0xec, - 0x1f, 0xfb, 0xc3, 0x7e, 0x71, 0x12, 0x73, 0x2f, 0xc6, 0xcd, 0xb4, 0x9c, 0xfa, 0x8e, 0xeb, 0x91, - 0x60, 0xff, 0x4a, 0x7b, 0x77, 0x9b, 0xb5, 0x1b, 0x90, 0xd0, 0xef, 0x04, 0x75, 0x92, 0x6c, 0xb8, - 0x6b, 0xad, 0xf0, 0x4a, 0x8b, 0x44, 0x4e, 0x46, 0x77, 0xe7, 0xae, 0xe4, 0xd5, 0x0a, 0x3a, 0x5e, - 0xe4, 0xb6, 0xd2, 0xcd, 0x7c, 0xb8, 0x57, 0x85, 0xb0, 0xbe, 0x43, 0x5a, 0x4e, 0xaa, 0xde, 0x0b, - 0x79, 0xf5, 0x3a, 0x91, 0xdb, 0xbc, 0xe2, 0x7a, 0x51, 0x18, 0x05, 0xc9, 0x4a, 0xf6, 0xd7, 0x2c, - 0xb8, 0xb0, 0x78, 0xb7, 0xb6, 0xd2, 0x74, 0xc2, 0xc8, 0xad, 0x2f, 0x35, 0xfd, 0xfa, 0x6e, 0x2d, - 0xf2, 0x03, 0x72, 0xc7, 0x6f, 0x76, 0x5a, 0xa4, 0xc6, 0x06, 0x02, 0x3d, 0x0b, 0x23, 0x7b, 0xec, - 0x7f, 0xa5, 0x3c, 0x6b, 0x5d, 0xb0, 0x2e, 0x97, 0x96, 0xa6, 0x7e, 0xe3, 0x60, 0xfe, 0x7d, 0x0f, - 0x0e, 0xe6, 0x47, 0xee, 0x88, 0x72, 0xac, 0x30, 0xd0, 0x25, 0x18, 0xda, 0x0a, 0x37, 0xf6, 0xdb, - 0x64, 0xb6, 0xc0, 0x70, 0x27, 0x04, 0xee, 0xd0, 0x6a, 0x8d, 0x96, 0x62, 0x01, 0x45, 0x57, 0xa0, - 0xd4, 0x76, 0x82, 0xc8, 0x8d, 0x5c, 0xdf, 0x9b, 0x2d, 0x5e, 0xb0, 0x2e, 0x0f, 0x2e, 0x4d, 0x0b, - 0xd4, 0x52, 0x55, 0x02, 0x70, 0x8c, 0x43, 0xbb, 0x11, 0x10, 0xa7, 0x71, 0xcb, 0x6b, 0xee, 0xcf, - 0x0e, 0x5c, 0xb0, 0x2e, 0x8f, 0xc4, 0xdd, 0xc0, 0xa2, 0x1c, 0x2b, 0x0c, 0xfb, 0xc7, 0x0a, 0x30, - 0xb2, 0xb8, 0xb5, 0xe5, 0x7a, 0x6e, 0xb4, 0x8f, 0xee, 0xc0, 0x98, 0xe7, 0x37, 0x88, 0xfc, 0xcf, - 0xbe, 0x62, 0xf4, 0xf9, 0x0b, 0x0b, 0xe9, 0xa5, 0xb4, 0xb0, 0xae, 0xe1, 0x2d, 0x4d, 0x3d, 0x38, - 0x98, 0x1f, 0xd3, 0x4b, 0xb0, 0x41, 0x07, 0x61, 0x18, 0x6d, 0xfb, 0x0d, 0x45, 0xb6, 0xc0, 0xc8, - 0xce, 0x67, 0x91, 0xad, 0xc6, 0x68, 0x4b, 0x93, 0x0f, 0x0e, 0xe6, 0x47, 0xb5, 0x02, 0xac, 0x13, - 0x41, 0x9b, 0x30, 0x49, 0xff, 0x7a, 0x91, 0xab, 0xe8, 0x16, 0x19, 0xdd, 0x8b, 0x79, 0x74, 0x35, - 0xd4, 0xa5, 0x99, 0x07, 0x07, 0xf3, 0x93, 0x89, 0x42, 0x9c, 0x24, 0x68, 0xbf, 0x0d, 0x13, 0x8b, - 0x51, 0xe4, 0xd4, 0x77, 0x48, 0x83, 0xcf, 0x20, 0x7a, 0x11, 0x06, 0x3c, 0xa7, 0x45, 0xc4, 0xfc, - 0x5e, 0x10, 0x03, 0x3b, 0xb0, 0xee, 0xb4, 0xc8, 0xe1, 0xc1, 0xfc, 0xd4, 0x6d, 0xcf, 0x7d, 0xab, - 0x23, 0x56, 0x05, 0x2d, 0xc3, 0x0c, 0x1b, 0x3d, 0x0f, 0xd0, 0x20, 0x7b, 0x6e, 0x9d, 0x54, 0x9d, - 0x68, 0x47, 0xcc, 0x37, 0x12, 0x75, 0xa1, 0xac, 0x20, 0x58, 0xc3, 0xb2, 0xef, 0x43, 0x69, 0x71, - 0xcf, 0x77, 0x1b, 0x55, 0xbf, 0x11, 0xa2, 0x5d, 0x98, 0x6c, 0x07, 0x64, 0x8b, 0x04, 0xaa, 0x68, - 0xd6, 0xba, 0x50, 0xbc, 0x3c, 0xfa, 0xfc, 0xe5, 0xcc, 0x8f, 0x35, 0x51, 0x57, 0xbc, 0x28, 0xd8, - 0x5f, 0x7a, 0x4c, 0xb4, 0x37, 0x99, 0x80, 0xe2, 0x24, 0x65, 0xfb, 0x9f, 0x17, 0xe0, 0xf4, 0xe2, - 0xdb, 0x9d, 0x80, 0x94, 0xdd, 0x70, 0x37, 0xb9, 0xc2, 0x1b, 0x6e, 0xb8, 0xbb, 0x1e, 0x8f, 0x80, - 0x5a, 0x5a, 0x65, 0x51, 0x8e, 0x15, 0x06, 0x7a, 0x0e, 0x86, 0xe9, 0xef, 0xdb, 0xb8, 0x22, 0x3e, - 0x79, 0x46, 0x20, 0x8f, 0x96, 0x9d, 0xc8, 0x29, 0x73, 0x10, 0x96, 0x38, 0x68, 0x0d, 0x46, 0xeb, - 0x6c, 0x43, 0x6e, 0xaf, 0xf9, 0x0d, 0xc2, 0x26, 0xb3, 0xb4, 0xf4, 0x0c, 0x45, 0x5f, 0x8e, 0x8b, - 0x0f, 0x0f, 0xe6, 0x67, 0x79, 0xdf, 0x04, 0x09, 0x0d, 0x86, 0xf5, 0xfa, 0xc8, 0x56, 0xfb, 0x6b, - 0x80, 0x51, 0x82, 0x8c, 0xbd, 0x75, 0x59, 0xdb, 0x2a, 0x83, 0x6c, 0xab, 0x8c, 0x65, 0x6f, 0x13, - 0x74, 0x15, 0x06, 0x76, 0x5d, 0xaf, 0x31, 0x3b, 0xc4, 0x68, 0x9d, 0xa3, 0x73, 0x7e, 0xc3, 0xf5, - 0x1a, 0x87, 0x07, 0xf3, 0xd3, 0x46, 0x77, 0x68, 0x21, 0x66, 0xa8, 0xf6, 0x9f, 0x59, 0x30, 0xcf, - 0x60, 0xab, 0x6e, 0x93, 0x54, 0x49, 0x10, 0xba, 0x61, 0x44, 0xbc, 0xc8, 0x18, 0xd0, 0xe7, 0x01, - 0x42, 0x52, 0x0f, 0x48, 0xa4, 0x0d, 0xa9, 0x5a, 0x18, 0x35, 0x05, 0xc1, 0x1a, 0x16, 0x3d, 0x10, - 0xc2, 0x1d, 0x27, 0x60, 0xeb, 0x4b, 0x0c, 0xac, 0x3a, 0x10, 0x6a, 0x12, 0x80, 0x63, 0x1c, 0xe3, - 0x40, 0x28, 0xf6, 0x3a, 0x10, 0xd0, 0xc7, 0x60, 0x32, 0x6e, 0x2c, 0x6c, 0x3b, 0x75, 0x39, 0x80, - 0x6c, 0xcb, 0xd4, 0x4c, 0x10, 0x4e, 0xe2, 0xda, 0x7f, 0xd3, 0x12, 0x8b, 0x87, 0x7e, 0xf5, 0xbb, - 0xfc, 0x5b, 0xed, 0x5f, 0xb6, 0x60, 0x78, 0xc9, 0xf5, 0x1a, 0xae, 0xb7, 0x8d, 0x3e, 0x0b, 0x23, - 0xf4, 0x6e, 0x6a, 0x38, 0x91, 0x23, 0xce, 0xbd, 0x0f, 0x69, 0x7b, 0x4b, 0x5d, 0x15, 0x0b, 0xed, - 0xdd, 0x6d, 0x5a, 0x10, 0x2e, 0x50, 0x6c, 0xba, 0xdb, 0x6e, 0x6d, 0x7e, 0x8e, 0xd4, 0xa3, 0x35, - 0x12, 0x39, 0xf1, 0xe7, 0xc4, 0x65, 0x58, 0x51, 0x45, 0x37, 0x60, 0x28, 0x72, 0x82, 0x6d, 0x12, - 0x89, 0x03, 0x30, 0xf3, 0xa0, 0xe2, 0x35, 0x31, 0xdd, 0x91, 0xc4, 0xab, 0x93, 0xf8, 0x5a, 0xd8, - 0x60, 0x55, 0xb1, 0x20, 0x61, 0xff, 0xc8, 0x30, 0x9c, 0x5d, 0xae, 0x55, 0x72, 0xd6, 0xd5, 0x25, - 0x18, 0x6a, 0x04, 0xee, 0x1e, 0x09, 0xc4, 0x38, 0x2b, 0x2a, 0x65, 0x56, 0x8a, 0x05, 0x14, 0xbd, - 0x0c, 0x63, 0xfc, 0x42, 0xba, 0xee, 0x78, 0x8d, 0xa6, 0x1c, 0xe2, 0x53, 0x02, 0x7b, 0xec, 0x8e, - 0x06, 0xc3, 0x06, 0xe6, 0x11, 0x17, 0xd5, 0xa5, 0xc4, 0x66, 0xcc, 0xbb, 0xec, 0xbe, 0x68, 0xc1, - 0x14, 0x6f, 0x66, 0x31, 0x8a, 0x02, 0x77, 0xb3, 0x13, 0x91, 0x70, 0x76, 0x90, 0x9d, 0x74, 0xcb, - 0x59, 0xa3, 0x95, 0x3b, 0x02, 0x0b, 0x77, 0x12, 0x54, 0xf8, 0x21, 0x38, 0x2b, 0xda, 0x9d, 0x4a, - 0x82, 0x71, 0xaa, 0x59, 0xf4, 0xdd, 0x16, 0xcc, 0xd5, 0x7d, 0x2f, 0x0a, 0xfc, 0x66, 0x93, 0x04, - 0xd5, 0xce, 0x66, 0xd3, 0x0d, 0x77, 0xf8, 0x3a, 0xc5, 0x64, 0x8b, 0x9d, 0x04, 0x39, 0x73, 0xa8, - 0x90, 0xc4, 0x1c, 0x9e, 0x7f, 0x70, 0x30, 0x3f, 0xb7, 0x9c, 0x4b, 0x0a, 0x77, 0x69, 0x06, 0xed, - 0x02, 0xa2, 0x57, 0x69, 0x2d, 0x72, 0xb6, 0x49, 0xdc, 0xf8, 0x70, 0xff, 0x8d, 0x9f, 0x79, 0x70, - 0x30, 0x8f, 0xd6, 0x53, 0x24, 0x70, 0x06, 0x59, 0xf4, 0x16, 0x9c, 0xa2, 0xa5, 0xa9, 0x6f, 0x1d, - 0xe9, 0xbf, 0xb9, 0xd9, 0x07, 0x07, 0xf3, 0xa7, 0xd6, 0x33, 0x88, 0xe0, 0x4c, 0xd2, 0xe8, 0xbb, - 0x2c, 0x38, 0x1b, 0x7f, 0xfe, 0xca, 0xfd, 0xb6, 0xe3, 0x35, 0xe2, 0x86, 0x4b, 0xfd, 0x37, 0x4c, - 0xcf, 0xe4, 0xb3, 0xcb, 0x79, 0x94, 0x70, 0x7e, 0x23, 0x73, 0xcb, 0x70, 0x3a, 0x73, 0xb5, 0xa0, - 0x29, 0x28, 0xee, 0x12, 0xce, 0x05, 0x95, 0x30, 0xfd, 0x89, 0x4e, 0xc1, 0xe0, 0x9e, 0xd3, 0xec, - 0x88, 0x8d, 0x82, 0xf9, 0x9f, 0x57, 0x0a, 0x2f, 0x5b, 0xf6, 0xbf, 0x28, 0xc2, 0xe4, 0x72, 0xad, - 0xf2, 0x50, 0xbb, 0x50, 0xbf, 0x86, 0x0a, 0x5d, 0xaf, 0xa1, 0xf8, 0x52, 0x2b, 0xe6, 0x5e, 0x6a, - 0xff, 0x77, 0xc6, 0x16, 0x1a, 0x60, 0x5b, 0xe8, 0xdb, 0x72, 0xb6, 0xd0, 0x31, 0x6f, 0x9c, 0xbd, - 0x9c, 0x55, 0x34, 0xc8, 0x26, 0x33, 0x93, 0x63, 0xb9, 0xe9, 0xd7, 0x9d, 0x66, 0xf2, 0xe8, 0x3b, - 0xe2, 0x52, 0x3a, 0x9e, 0x79, 0xac, 0xc3, 0xd8, 0xb2, 0xd3, 0x76, 0x36, 0xdd, 0xa6, 0x1b, 0xb9, - 0x24, 0x44, 0x4f, 0x41, 0xd1, 0x69, 0x34, 0x18, 0xb7, 0x55, 0x5a, 0x3a, 0xfd, 0xe0, 0x60, 0xbe, - 0xb8, 0xd8, 0xa0, 0xd7, 0x3e, 0x28, 0xac, 0x7d, 0x4c, 0x31, 0xd0, 0x07, 0x61, 0xa0, 0x11, 0xf8, - 0xed, 0xd9, 0x02, 0xc3, 0xa4, 0xbb, 0x6e, 0xa0, 0x1c, 0xf8, 0xed, 0x04, 0x2a, 0xc3, 0xb1, 0x7f, - 0xbd, 0x00, 0x4f, 0x2c, 0x93, 0xf6, 0xce, 0x6a, 0x2d, 0xe7, 0xfc, 0xbe, 0x0c, 0x23, 0x2d, 0xdf, - 0x73, 0x23, 0x3f, 0x08, 0x45, 0xd3, 0x6c, 0x45, 0xac, 0x89, 0x32, 0xac, 0xa0, 0xe8, 0x02, 0x0c, - 0xb4, 0x63, 0xa6, 0x72, 0x4c, 0x32, 0xa4, 0x8c, 0x9d, 0x64, 0x10, 0x8a, 0xd1, 0x09, 0x49, 0x20, - 0x56, 0x8c, 0xc2, 0xb8, 0x1d, 0x92, 0x00, 0x33, 0x48, 0x7c, 0x33, 0xd3, 0x3b, 0x5b, 0x9c, 0xd0, - 0x89, 0x9b, 0x99, 0x42, 0xb0, 0x86, 0x85, 0xaa, 0x50, 0x0a, 0x13, 0x33, 0xdb, 0xd7, 0x36, 0x1d, - 0x67, 0x57, 0xb7, 0x9a, 0xc9, 0x98, 0x88, 0x71, 0xa3, 0x0c, 0xf5, 0xbc, 0xba, 0xbf, 0x5a, 0x00, - 0xc4, 0x87, 0xf0, 0x9b, 0x6c, 0xe0, 0x6e, 0xa7, 0x07, 0xae, 0xff, 0x2d, 0x71, 0x5c, 0xa3, 0xf7, - 0xdf, 0x2d, 0x78, 0x62, 0xd9, 0xf5, 0x1a, 0x24, 0xc8, 0x59, 0x80, 0x8f, 0xe6, 0x2d, 0x7b, 0x34, - 0xa6, 0xc1, 0x58, 0x62, 0x03, 0xc7, 0xb0, 0xc4, 0xec, 0x3f, 0xb1, 0x00, 0xf1, 0xcf, 0x7e, 0xd7, - 0x7d, 0xec, 0xed, 0xf4, 0xc7, 0x1e, 0xc3, 0xb2, 0xb0, 0x6f, 0xc2, 0xc4, 0x72, 0xd3, 0x25, 0x5e, - 0x54, 0xa9, 0x2e, 0xfb, 0xde, 0x96, 0xbb, 0x8d, 0x5e, 0x81, 0x89, 0xc8, 0x6d, 0x11, 0xbf, 0x13, - 0xd5, 0x48, 0xdd, 0xf7, 0xd8, 0x4b, 0xd2, 0xba, 0x3c, 0xb8, 0x84, 0x1e, 0x1c, 0xcc, 0x4f, 0x6c, - 0x18, 0x10, 0x9c, 0xc0, 0xb4, 0x7f, 0x8f, 0x8e, 0x9f, 0xdf, 0x6a, 0xfb, 0x1e, 0xf1, 0xa2, 0x65, - 0xdf, 0x6b, 0x70, 0x89, 0xc3, 0x2b, 0x30, 0x10, 0xd1, 0xf1, 0xe0, 0x63, 0x77, 0x49, 0x6e, 0x14, - 0x3a, 0x0a, 0x87, 0x07, 0xf3, 0x67, 0xd2, 0x35, 0xd8, 0x38, 0xb1, 0x3a, 0xe8, 0xdb, 0x60, 0x28, - 0x8c, 0x9c, 0xa8, 0x13, 0x8a, 0xd1, 0x7c, 0x52, 0x8e, 0x66, 0x8d, 0x95, 0x1e, 0x1e, 0xcc, 0x4f, - 0xaa, 0x6a, 0xbc, 0x08, 0x8b, 0x0a, 0xe8, 0x69, 0x18, 0x6e, 0x91, 0x30, 0x74, 0xb6, 0xe5, 0x6d, - 0x38, 0x29, 0xea, 0x0e, 0xaf, 0xf1, 0x62, 0x2c, 0xe1, 0xe8, 0x22, 0x0c, 0x92, 0x20, 0xf0, 0x03, - 0xb1, 0x47, 0xc7, 0x05, 0xe2, 0xe0, 0x0a, 0x2d, 0xc4, 0x1c, 0x66, 0xff, 0x5b, 0x0b, 0x26, 0x55, - 0x5f, 0x79, 0x5b, 0x27, 0xf0, 0x2a, 0xf8, 0x14, 0x40, 0x5d, 0x7e, 0x60, 0xc8, 0x6e, 0x8f, 0xd1, - 0xe7, 0x2f, 0x65, 0x5e, 0xd4, 0xa9, 0x61, 0x8c, 0x29, 0xab, 0xa2, 0x10, 0x6b, 0xd4, 0xec, 0x7f, - 0x64, 0xc1, 0x4c, 0xe2, 0x8b, 0x6e, 0xba, 0x61, 0x84, 0xde, 0x4c, 0x7d, 0xd5, 0x42, 0x7f, 0x5f, - 0x45, 0x6b, 0xb3, 0x6f, 0x52, 0x4b, 0x59, 0x96, 0x68, 0x5f, 0x74, 0x1d, 0x06, 0xdd, 0x88, 0xb4, - 0xe4, 0xc7, 0x5c, 0xec, 0xfa, 0x31, 0xbc, 0x57, 0xf1, 0x8c, 0x54, 0x68, 0x4d, 0xcc, 0x09, 0xd8, - 0xbf, 0x5e, 0x84, 0x12, 0x5f, 0xb6, 0x6b, 0x4e, 0xfb, 0x04, 0xe6, 0xe2, 0x19, 0x28, 0xb9, 0xad, - 0x56, 0x27, 0x72, 0x36, 0xc5, 0x71, 0x3e, 0xc2, 0xb7, 0x56, 0x45, 0x16, 0xe2, 0x18, 0x8e, 0x2a, - 0x30, 0xc0, 0xba, 0xc2, 0xbf, 0xf2, 0xa9, 0xec, 0xaf, 0x14, 0x7d, 0x5f, 0x28, 0x3b, 0x91, 0xc3, - 0x39, 0x29, 0x75, 0x8f, 0xd0, 0x22, 0xcc, 0x48, 0x20, 0x07, 0x60, 0xd3, 0xf5, 0x9c, 0x60, 0x9f, - 0x96, 0xcd, 0x16, 0x19, 0xc1, 0xe7, 0xba, 0x13, 0x5c, 0x52, 0xf8, 0x9c, 0xac, 0xfa, 0xb0, 0x18, - 0x80, 0x35, 0xa2, 0x73, 0x1f, 0x81, 0x92, 0x42, 0x3e, 0x0a, 0x43, 0x34, 0xf7, 0x31, 0x98, 0x4c, - 0xb4, 0xd5, 0xab, 0xfa, 0x98, 0xce, 0x4f, 0xfd, 0x0a, 0x3b, 0x32, 0x44, 0xaf, 0x57, 0xbc, 0x3d, - 0x71, 0xe4, 0xbe, 0x0d, 0xa7, 0x9a, 0x19, 0x27, 0x99, 0x98, 0xd7, 0xfe, 0x4f, 0xbe, 0x27, 0xc4, - 0x67, 0x9f, 0xca, 0x82, 0xe2, 0xcc, 0x36, 0x28, 0x8f, 0xe0, 0xb7, 0xe9, 0x06, 0x71, 0x9a, 0x3a, - 0xbb, 0x7d, 0x4b, 0x94, 0x61, 0x05, 0xa5, 0xe7, 0xdd, 0x29, 0xd5, 0xf9, 0x1b, 0x64, 0xbf, 0x46, - 0x9a, 0xa4, 0x1e, 0xf9, 0xc1, 0x37, 0xb4, 0xfb, 0xe7, 0xf8, 0xe8, 0xf3, 0xe3, 0x72, 0x54, 0x10, - 0x28, 0xde, 0x20, 0xfb, 0x7c, 0x2a, 0xf4, 0xaf, 0x2b, 0x76, 0xfd, 0xba, 0x9f, 0xb3, 0x60, 0x5c, - 0x7d, 0xdd, 0x09, 0x9c, 0x0b, 0x4b, 0xe6, 0xb9, 0x70, 0xae, 0xeb, 0x02, 0xcf, 0x39, 0x11, 0xbe, - 0x5a, 0x80, 0xb3, 0x0a, 0x87, 0xbe, 0x0d, 0xf8, 0x1f, 0xb1, 0xaa, 0xae, 0x40, 0xc9, 0x53, 0x52, - 0x2b, 0xcb, 0x14, 0x17, 0xc5, 0x32, 0xab, 0x18, 0x87, 0xb2, 0x78, 0x5e, 0x2c, 0x5a, 0x1a, 0xd3, - 0xc5, 0xb9, 0x42, 0x74, 0xbb, 0x04, 0xc5, 0x8e, 0xdb, 0x10, 0x17, 0xcc, 0x87, 0xe4, 0x68, 0xdf, - 0xae, 0x94, 0x0f, 0x0f, 0xe6, 0x9f, 0xcc, 0x53, 0x25, 0xd0, 0x9b, 0x2d, 0x5c, 0xb8, 0x5d, 0x29, - 0x63, 0x5a, 0x19, 0x2d, 0xc2, 0xa4, 0xd4, 0x96, 0xdc, 0xa1, 0xec, 0x96, 0xef, 0x89, 0x7b, 0x48, - 0xc9, 0x64, 0xb1, 0x09, 0xc6, 0x49, 0x7c, 0x54, 0x86, 0xa9, 0xdd, 0xce, 0x26, 0x69, 0x92, 0x88, - 0x7f, 0xf0, 0x0d, 0xc2, 0x25, 0x96, 0xa5, 0xf8, 0x65, 0x76, 0x23, 0x01, 0xc7, 0xa9, 0x1a, 0xf6, - 0x5f, 0xb0, 0xfb, 0x40, 0x8c, 0x5e, 0x35, 0xf0, 0xe9, 0xc2, 0xa2, 0xd4, 0xbf, 0x91, 0xcb, 0xb9, - 0x9f, 0x55, 0x71, 0x83, 0xec, 0x6f, 0xf8, 0x94, 0x33, 0xcf, 0x5e, 0x15, 0xc6, 0x9a, 0x1f, 0xe8, - 0xba, 0xe6, 0x7f, 0xa1, 0x00, 0xa7, 0xd5, 0x08, 0x18, 0x4c, 0xe0, 0x37, 0xfb, 0x18, 0x5c, 0x85, - 0xd1, 0x06, 0xd9, 0x72, 0x3a, 0xcd, 0x48, 0x89, 0xcf, 0x07, 0xb9, 0x0a, 0xa5, 0x1c, 0x17, 0x63, - 0x1d, 0xe7, 0x08, 0xc3, 0xf6, 0x3f, 0x46, 0xd9, 0x45, 0x1c, 0x39, 0x74, 0x8d, 0xab, 0x5d, 0x63, - 0xe5, 0xee, 0x9a, 0x8b, 0x30, 0xe8, 0xb6, 0x28, 0x63, 0x56, 0x30, 0xf9, 0xad, 0x0a, 0x2d, 0xc4, - 0x1c, 0x86, 0x3e, 0x00, 0xc3, 0x75, 0xbf, 0xd5, 0x72, 0xbc, 0x06, 0xbb, 0xf2, 0x4a, 0x4b, 0xa3, - 0x94, 0x77, 0x5b, 0xe6, 0x45, 0x58, 0xc2, 0xd0, 0x13, 0x30, 0xe0, 0x04, 0xdb, 0x5c, 0x86, 0x51, - 0x5a, 0x1a, 0xa1, 0x2d, 0x2d, 0x06, 0xdb, 0x21, 0x66, 0xa5, 0xf4, 0x09, 0x76, 0xcf, 0x0f, 0x76, - 0x5d, 0x6f, 0xbb, 0xec, 0x06, 0x62, 0x4b, 0xa8, 0xbb, 0xf0, 0xae, 0x82, 0x60, 0x0d, 0x0b, 0xad, - 0xc2, 0x60, 0xdb, 0x0f, 0xa2, 0x70, 0x76, 0x88, 0x0d, 0xf7, 0x93, 0x39, 0x07, 0x11, 0xff, 0xda, - 0xaa, 0x1f, 0x44, 0xf1, 0x07, 0xd0, 0x7f, 0x21, 0xe6, 0xd5, 0xd1, 0x4d, 0x18, 0x26, 0xde, 0xde, - 0x6a, 0xe0, 0xb7, 0x66, 0x67, 0xf2, 0x29, 0xad, 0x70, 0x14, 0xbe, 0xcc, 0x62, 0x1e, 0x55, 0x14, - 0x63, 0x49, 0x02, 0x7d, 0x1b, 0x14, 0x89, 0xb7, 0x37, 0x3b, 0xcc, 0x28, 0xcd, 0xe5, 0x50, 0xba, - 0xe3, 0x04, 0xf1, 0x99, 0xbf, 0xe2, 0xed, 0x61, 0x5a, 0x07, 0x7d, 0x12, 0x4a, 0xf2, 0xc0, 0x08, - 0x85, 0xb0, 0x2e, 0x73, 0xc1, 0xca, 0x63, 0x06, 0x93, 0xb7, 0x3a, 0x6e, 0x40, 0x5a, 0xc4, 0x8b, - 0xc2, 0xf8, 0x84, 0x94, 0xd0, 0x10, 0xc7, 0xd4, 0xd0, 0x27, 0xa5, 0x84, 0x78, 0xcd, 0xef, 0x78, - 0x51, 0x38, 0x5b, 0x62, 0xdd, 0xcb, 0xd4, 0xdd, 0xdd, 0x89, 0xf1, 0x92, 0x22, 0x64, 0x5e, 0x19, - 0x1b, 0xa4, 0xd0, 0xa7, 0x61, 0x9c, 0xff, 0xe7, 0x1a, 0xb0, 0x70, 0xf6, 0x34, 0xa3, 0x7d, 0x21, - 0x9f, 0x36, 0x47, 0x5c, 0x3a, 0x2d, 0x88, 0x8f, 0xeb, 0xa5, 0x21, 0x36, 0xa9, 0x21, 0x0c, 0xe3, - 0x4d, 0x77, 0x8f, 0x78, 0x24, 0x0c, 0xab, 0x81, 0xbf, 0x49, 0x66, 0x81, 0x0d, 0xcc, 0xd9, 0x6c, - 0x8d, 0x99, 0xbf, 0x49, 0x96, 0xa6, 0x29, 0xcd, 0x9b, 0x7a, 0x1d, 0x6c, 0x92, 0x40, 0xb7, 0x61, - 0x82, 0xbe, 0xd8, 0xdc, 0x98, 0xe8, 0x68, 0x2f, 0xa2, 0xec, 0x5d, 0x85, 0x8d, 0x4a, 0x38, 0x41, - 0x04, 0xdd, 0x82, 0xb1, 0x30, 0x72, 0x82, 0xa8, 0xd3, 0xe6, 0x44, 0xcf, 0xf4, 0x22, 0xca, 0x14, - 0xae, 0x35, 0xad, 0x0a, 0x36, 0x08, 0xa0, 0xd7, 0xa1, 0xd4, 0x74, 0xb7, 0x48, 0x7d, 0xbf, 0xde, - 0x24, 0xb3, 0x63, 0x8c, 0x5a, 0xe6, 0xa1, 0x72, 0x53, 0x22, 0x71, 0x3e, 0x57, 0xfd, 0xc5, 0x71, - 0x75, 0x74, 0x07, 0xce, 0x44, 0x24, 0x68, 0xb9, 0x9e, 0x43, 0x0f, 0x03, 0xf1, 0xb4, 0x62, 0x8a, - 0xcc, 0x71, 0xb6, 0xdb, 0xce, 0x8b, 0xd9, 0x38, 0xb3, 0x91, 0x89, 0x85, 0x73, 0x6a, 0xa3, 0xfb, - 0x30, 0x9b, 0x01, 0xf1, 0x9b, 0x6e, 0x7d, 0x7f, 0xf6, 0x14, 0xa3, 0xfc, 0x51, 0x41, 0x79, 0x76, - 0x23, 0x07, 0xef, 0xb0, 0x0b, 0x0c, 0xe7, 0x52, 0x47, 0xb7, 0x60, 0x92, 0x9d, 0x40, 0xd5, 0x4e, - 0xb3, 0x29, 0x1a, 0x9c, 0x60, 0x0d, 0x7e, 0x40, 0xde, 0xc7, 0x15, 0x13, 0x7c, 0x78, 0x30, 0x0f, - 0xf1, 0x3f, 0x9c, 0xac, 0x8d, 0x36, 0x99, 0xce, 0xac, 0x13, 0xb8, 0xd1, 0x3e, 0x3d, 0x37, 0xc8, - 0xfd, 0x68, 0x76, 0xb2, 0xab, 0xbc, 0x42, 0x47, 0x55, 0x8a, 0x35, 0xbd, 0x10, 0x27, 0x09, 0xd2, - 0x23, 0x35, 0x8c, 0x1a, 0xae, 0x37, 0x3b, 0xc5, 0xdf, 0x25, 0xf2, 0x44, 0xaa, 0xd1, 0x42, 0xcc, - 0x61, 0x4c, 0x5f, 0x46, 0x7f, 0xdc, 0xa2, 0x37, 0xd7, 0x34, 0x43, 0x8c, 0xf5, 0x65, 0x12, 0x80, - 0x63, 0x1c, 0xca, 0x4c, 0x46, 0xd1, 0xfe, 0x2c, 0x62, 0xa8, 0xea, 0x60, 0xd9, 0xd8, 0xf8, 0x24, - 0xa6, 0xe5, 0xf6, 0x26, 0x4c, 0xa8, 0x83, 0x90, 0x8d, 0x09, 0x9a, 0x87, 0x41, 0xc6, 0x3e, 0x09, - 0xe9, 0x5a, 0x89, 0x76, 0x81, 0xb1, 0x56, 0x98, 0x97, 0xb3, 0x2e, 0xb8, 0x6f, 0x93, 0xa5, 0xfd, - 0x88, 0xf0, 0x37, 0x7d, 0x51, 0xeb, 0x82, 0x04, 0xe0, 0x18, 0xc7, 0xfe, 0xdf, 0x9c, 0x0d, 0x8d, - 0x4f, 0xdb, 0x3e, 0xee, 0x97, 0x67, 0x61, 0x64, 0xc7, 0x0f, 0x23, 0x8a, 0xcd, 0xda, 0x18, 0x8c, - 0x19, 0xcf, 0xeb, 0xa2, 0x1c, 0x2b, 0x0c, 0xf4, 0x2a, 0x8c, 0xd7, 0xf5, 0x06, 0xc4, 0xe5, 0xa8, - 0x8e, 0x11, 0xa3, 0x75, 0x6c, 0xe2, 0xa2, 0x97, 0x61, 0x84, 0xd9, 0x80, 0xd4, 0xfd, 0xa6, 0xe0, - 0xda, 0xe4, 0x0d, 0x3f, 0x52, 0x15, 0xe5, 0x87, 0xda, 0x6f, 0xac, 0xb0, 0xd1, 0x25, 0x18, 0xa2, - 0x5d, 0xa8, 0x54, 0xc5, 0xb5, 0xa4, 0x04, 0x45, 0xd7, 0x59, 0x29, 0x16, 0x50, 0xfb, 0xff, 0x2b, - 0x68, 0xa3, 0x4c, 0xdf, 0xc3, 0x04, 0x55, 0x61, 0xf8, 0x9e, 0xe3, 0x46, 0xae, 0xb7, 0x2d, 0xf8, - 0x8f, 0xa7, 0xbb, 0xde, 0x51, 0xac, 0xd2, 0x5d, 0x5e, 0x81, 0xdf, 0xa2, 0xe2, 0x0f, 0x96, 0x64, - 0x28, 0xc5, 0xa0, 0xe3, 0x79, 0x94, 0x62, 0xa1, 0x5f, 0x8a, 0x98, 0x57, 0xe0, 0x14, 0xc5, 0x1f, - 0x2c, 0xc9, 0xa0, 0x37, 0x01, 0xe4, 0x0e, 0x23, 0x0d, 0x61, 0x7b, 0xf1, 0x6c, 0x6f, 0xa2, 0x1b, - 0xaa, 0xce, 0xd2, 0x04, 0xbd, 0xa3, 0xe3, 0xff, 0x58, 0xa3, 0x67, 0x47, 0x8c, 0x4f, 0x4b, 0x77, - 0x06, 0x7d, 0x07, 0x5d, 0xe2, 0x4e, 0x10, 0x91, 0xc6, 0x62, 0x24, 0x06, 0xe7, 0x83, 0xfd, 0x3d, - 0x52, 0x36, 0xdc, 0x16, 0xd1, 0xb7, 0x83, 0x20, 0x82, 0x63, 0x7a, 0xf6, 0x2f, 0x15, 0x61, 0x36, - 0xaf, 0xbb, 0x74, 0xd1, 0x91, 0xfb, 0x6e, 0xb4, 0x4c, 0xd9, 0x2b, 0xcb, 0x5c, 0x74, 0x2b, 0xa2, - 0x1c, 0x2b, 0x0c, 0x3a, 0xfb, 0xa1, 0xbb, 0x2d, 0xdf, 0x98, 0x83, 0xf1, 0xec, 0xd7, 0x58, 0x29, - 0x16, 0x50, 0x8a, 0x17, 0x10, 0x27, 0x14, 0xc6, 0x3d, 0xda, 0x2a, 0xc1, 0xac, 0x14, 0x0b, 0xa8, - 0x2e, 0xed, 0x1a, 0xe8, 0x21, 0xed, 0x32, 0x86, 0x68, 0xf0, 0x78, 0x87, 0x08, 0x7d, 0x06, 0x60, - 0xcb, 0xf5, 0xdc, 0x70, 0x87, 0x51, 0x1f, 0x3a, 0x32, 0x75, 0xc5, 0x9c, 0xad, 0x2a, 0x2a, 0x58, - 0xa3, 0x88, 0x5e, 0x82, 0x51, 0xb5, 0x01, 0x2b, 0x65, 0xa6, 0xe9, 0xd4, 0x2c, 0x47, 0xe2, 0xd3, - 0xa8, 0x8c, 0x75, 0x3c, 0xfb, 0x73, 0xc9, 0xf5, 0x22, 0x76, 0x80, 0x36, 0xbe, 0x56, 0xbf, 0xe3, - 0x5b, 0xe8, 0x3e, 0xbe, 0xf6, 0xd7, 0x8b, 0x30, 0x69, 0x34, 0xd6, 0x09, 0xfb, 0x38, 0xb3, 0xae, - 0xd1, 0x03, 0xdc, 0x89, 0x88, 0xd8, 0x7f, 0x76, 0xef, 0xad, 0xa2, 0x1f, 0xf2, 0x74, 0x07, 0xf0, - 0xfa, 0xe8, 0x33, 0x50, 0x6a, 0x3a, 0x21, 0x93, 0x9c, 0x11, 0xb1, 0xef, 0xfa, 0x21, 0x16, 0x3f, - 0x4c, 0x9c, 0x30, 0xd2, 0x6e, 0x4d, 0x4e, 0x3b, 0x26, 0x49, 0x6f, 0x1a, 0xca, 0x9f, 0x48, 0xeb, - 0x31, 0xd5, 0x09, 0xca, 0xc4, 0xec, 0x63, 0x0e, 0x43, 0x2f, 0xc3, 0x58, 0x40, 0xd8, 0xaa, 0x58, - 0xa6, 0xdc, 0x1c, 0x5b, 0x66, 0x83, 0x31, 0xdb, 0x87, 0x35, 0x18, 0x36, 0x30, 0xe3, 0xb7, 0xc1, - 0x50, 0x97, 0xb7, 0xc1, 0xd3, 0x30, 0xcc, 0x7e, 0xa8, 0x15, 0xa0, 0x66, 0xa3, 0xc2, 0x8b, 0xb1, - 0x84, 0x27, 0x17, 0xcc, 0x48, 0x7f, 0x0b, 0x86, 0xbe, 0x3e, 0xc4, 0xa2, 0x66, 0x5a, 0xe6, 0x11, - 0x7e, 0xca, 0x89, 0x25, 0x8f, 0x25, 0xcc, 0xfe, 0x20, 0x4c, 0x94, 0x1d, 0xd2, 0xf2, 0xbd, 0x15, - 0xaf, 0xd1, 0xf6, 0x5d, 0x2f, 0x42, 0xb3, 0x30, 0xc0, 0x2e, 0x11, 0x7e, 0x04, 0x0c, 0xd0, 0x86, - 0x30, 0x2b, 0xb1, 0xb7, 0xe1, 0x74, 0xd9, 0xbf, 0xe7, 0xdd, 0x73, 0x82, 0xc6, 0x62, 0xb5, 0xa2, - 0xbd, 0xaf, 0xd7, 0xe5, 0xfb, 0x8e, 0x1b, 0x6d, 0x65, 0x1e, 0xbd, 0x5a, 0x4d, 0xce, 0xd6, 0xae, - 0xba, 0x4d, 0x92, 0x23, 0x05, 0xf9, 0xcb, 0x05, 0xa3, 0xa5, 0x18, 0x5f, 0x69, 0xb5, 0xac, 0x5c, - 0xad, 0xd6, 0x1b, 0x30, 0xb2, 0xe5, 0x92, 0x66, 0x03, 0x93, 0x2d, 0xb1, 0x12, 0x9f, 0xca, 0xb7, - 0x43, 0x59, 0xa5, 0x98, 0x52, 0xea, 0xc5, 0x5f, 0x87, 0xab, 0xa2, 0x32, 0x56, 0x64, 0xd0, 0x2e, - 0x4c, 0xc9, 0x07, 0x83, 0x84, 0x8a, 0x75, 0xf9, 0x74, 0xb7, 0x57, 0x88, 0x49, 0xfc, 0xd4, 0x83, - 0x83, 0xf9, 0x29, 0x9c, 0x20, 0x83, 0x53, 0x84, 0xe9, 0x73, 0xb0, 0x45, 0x4f, 0xe0, 0x01, 0x36, - 0xfc, 0xec, 0x39, 0xc8, 0x5e, 0xb6, 0xac, 0xd4, 0xfe, 0x09, 0x0b, 0x1e, 0x4b, 0x8d, 0x8c, 0x78, - 0xe1, 0x1f, 0xf3, 0x2c, 0x24, 0x5f, 0xdc, 0x85, 0xde, 0x2f, 0x6e, 0xfb, 0x6f, 0x59, 0x70, 0x6a, - 0xa5, 0xd5, 0x8e, 0xf6, 0xcb, 0xae, 0xa9, 0x82, 0xfa, 0x08, 0x0c, 0xb5, 0x48, 0xc3, 0xed, 0xb4, - 0xc4, 0xcc, 0xcd, 0xcb, 0x53, 0x6a, 0x8d, 0x95, 0x1e, 0x1e, 0xcc, 0x8f, 0xd7, 0x22, 0x3f, 0x70, - 0xb6, 0x09, 0x2f, 0xc0, 0x02, 0x9d, 0x9d, 0xf5, 0xee, 0xdb, 0xe4, 0xa6, 0xdb, 0x72, 0xa5, 0x5d, - 0x51, 0x57, 0x99, 0xdd, 0x82, 0x1c, 0xd0, 0x85, 0x37, 0x3a, 0x8e, 0x17, 0xb9, 0xd1, 0xbe, 0xd0, - 0x1e, 0x49, 0x22, 0x38, 0xa6, 0x67, 0x7f, 0xcd, 0x82, 0x49, 0xb9, 0xee, 0x17, 0x1b, 0x8d, 0x80, - 0x84, 0x21, 0x9a, 0x83, 0x82, 0xdb, 0x16, 0xbd, 0x04, 0xd1, 0xcb, 0x42, 0xa5, 0x8a, 0x0b, 0x6e, - 0x5b, 0xb2, 0x65, 0xec, 0x20, 0x2c, 0x9a, 0x8a, 0xb4, 0xeb, 0xa2, 0x1c, 0x2b, 0x0c, 0x74, 0x19, - 0x46, 0x3c, 0xbf, 0xc1, 0x6d, 0xbb, 0xf8, 0x95, 0xc6, 0x16, 0xd8, 0xba, 0x28, 0xc3, 0x0a, 0x8a, - 0xaa, 0x50, 0xe2, 0x66, 0x4f, 0xf1, 0xa2, 0xed, 0xcb, 0x78, 0x8a, 0x7d, 0xd9, 0x86, 0xac, 0x89, - 0x63, 0x22, 0xf6, 0xaf, 0x59, 0x30, 0x26, 0xbf, 0xac, 0x4f, 0x9e, 0x93, 0x6e, 0xad, 0x98, 0xdf, - 0x8c, 0xb7, 0x16, 0xe5, 0x19, 0x19, 0xc4, 0x60, 0x15, 0x8b, 0x47, 0x62, 0x15, 0xaf, 0xc2, 0xa8, - 0xd3, 0x6e, 0x57, 0x4d, 0x3e, 0x93, 0x2d, 0xa5, 0xc5, 0xb8, 0x18, 0xeb, 0x38, 0xf6, 0x8f, 0x17, - 0x60, 0x42, 0x7e, 0x41, 0xad, 0xb3, 0x19, 0x92, 0x08, 0x6d, 0x40, 0xc9, 0xe1, 0xb3, 0x44, 0xe4, - 0x22, 0xbf, 0x98, 0x2d, 0x47, 0x30, 0xa6, 0x34, 0xbe, 0xf0, 0x17, 0x65, 0x6d, 0x1c, 0x13, 0x42, - 0x4d, 0x98, 0xf6, 0xfc, 0x88, 0x1d, 0xfe, 0x0a, 0xde, 0x4d, 0xb5, 0x93, 0xa4, 0x7e, 0x56, 0x50, - 0x9f, 0x5e, 0x4f, 0x52, 0xc1, 0x69, 0xc2, 0x68, 0x45, 0xca, 0x66, 0x8a, 0xf9, 0xc2, 0x00, 0x7d, - 0xe2, 0xb2, 0x45, 0x33, 0xf6, 0xaf, 0x5a, 0x50, 0x92, 0x68, 0x27, 0xa1, 0xc5, 0x5b, 0x83, 0xe1, - 0x90, 0x4d, 0x82, 0x1c, 0x1a, 0xbb, 0x5b, 0xc7, 0xf9, 0x7c, 0xc5, 0x77, 0x1a, 0xff, 0x1f, 0x62, - 0x49, 0x83, 0x89, 0xe6, 0x55, 0xf7, 0xdf, 0x25, 0xa2, 0x79, 0xd5, 0x9f, 0x9c, 0x4b, 0xe9, 0x8f, - 0x58, 0x9f, 0x35, 0x59, 0x17, 0x65, 0xbd, 0xda, 0x01, 0xd9, 0x72, 0xef, 0x27, 0x59, 0xaf, 0x2a, - 0x2b, 0xc5, 0x02, 0x8a, 0xde, 0x84, 0xb1, 0xba, 0x94, 0xc9, 0xc6, 0x3b, 0xfc, 0x52, 0x57, 0xfd, - 0x80, 0x52, 0x25, 0x71, 0x59, 0xc8, 0xb2, 0x56, 0x1f, 0x1b, 0xd4, 0x4c, 0x33, 0x82, 0x62, 0x2f, - 0x33, 0x82, 0x98, 0x6e, 0xbe, 0x52, 0xfd, 0x27, 0x2d, 0x18, 0xe2, 0xb2, 0xb8, 0xfe, 0x44, 0xa1, - 0x9a, 0x66, 0x2d, 0x1e, 0xbb, 0x3b, 0xb4, 0x50, 0x68, 0xca, 0xd0, 0x1a, 0x94, 0xd8, 0x0f, 0x26, - 0x4b, 0x2c, 0xe6, 0x5b, 0xdd, 0xf3, 0x56, 0xf5, 0x0e, 0xde, 0x91, 0xd5, 0x70, 0x4c, 0xc1, 0xfe, - 0xd1, 0x22, 0x3d, 0xdd, 0x62, 0x54, 0xe3, 0xd2, 0xb7, 0x1e, 0xdd, 0xa5, 0x5f, 0x78, 0x54, 0x97, - 0xfe, 0x36, 0x4c, 0xd6, 0x35, 0x3d, 0x5c, 0x3c, 0x93, 0x97, 0xbb, 0x2e, 0x12, 0x4d, 0x65, 0xc7, - 0xa5, 0x2c, 0xcb, 0x26, 0x11, 0x9c, 0xa4, 0x8a, 0xbe, 0x03, 0xc6, 0xf8, 0x3c, 0x8b, 0x56, 0xb8, - 0x25, 0xc6, 0x07, 0xf2, 0xd7, 0x8b, 0xde, 0x04, 0x97, 0xca, 0x69, 0xd5, 0xb1, 0x41, 0xcc, 0xfe, - 0x53, 0x0b, 0xd0, 0x4a, 0x7b, 0x87, 0xb4, 0x48, 0xe0, 0x34, 0x63, 0x71, 0xfa, 0x0f, 0x5a, 0x30, - 0x4b, 0x52, 0xc5, 0xcb, 0x7e, 0xab, 0x25, 0x1e, 0x2d, 0x39, 0xef, 0xea, 0x95, 0x9c, 0x3a, 0xca, - 0x2d, 0x61, 0x36, 0x0f, 0x03, 0xe7, 0xb6, 0x87, 0xd6, 0x60, 0x86, 0xdf, 0x92, 0x0a, 0xa0, 0xd9, - 0x5e, 0x3f, 0x2e, 0x08, 0xcf, 0x6c, 0xa4, 0x51, 0x70, 0x56, 0x3d, 0xfb, 0x7b, 0xc6, 0x20, 0xb7, - 0x17, 0xef, 0xe9, 0x11, 0xde, 0xd3, 0x23, 0xbc, 0xa7, 0x47, 0x78, 0x4f, 0x8f, 0xf0, 0x9e, 0x1e, - 0xe1, 0x5b, 0x5e, 0x8f, 0xf0, 0xff, 0x5b, 0x70, 0x5a, 0x5d, 0x03, 0xc6, 0xc3, 0xf7, 0xf3, 0x30, - 0xc3, 0xb7, 0xdb, 0x72, 0xd3, 0x71, 0x5b, 0x1b, 0xa4, 0xd5, 0x6e, 0x3a, 0x91, 0xd4, 0xba, 0x5f, - 0xcd, 0x5c, 0xb9, 0x09, 0x8b, 0x55, 0xa3, 0xe2, 0xd2, 0x63, 0xf4, 0x7a, 0xca, 0x00, 0xe0, 0xac, - 0x66, 0xec, 0x5f, 0x1a, 0x81, 0xc1, 0x95, 0x3d, 0xe2, 0x45, 0x27, 0xf0, 0x44, 0xa8, 0xc3, 0x84, - 0xeb, 0xed, 0xf9, 0xcd, 0x3d, 0xd2, 0xe0, 0xf0, 0xa3, 0xbc, 0x64, 0xcf, 0x08, 0xd2, 0x13, 0x15, - 0x83, 0x04, 0x4e, 0x90, 0x7c, 0x14, 0xd2, 0xe4, 0x6b, 0x30, 0xc4, 0x0f, 0x71, 0x21, 0x4a, 0xce, - 0x3c, 0xb3, 0xd9, 0x20, 0x8a, 0xab, 0x29, 0x96, 0x74, 0xf3, 0x4b, 0x42, 0x54, 0x47, 0x9f, 0x83, - 0x89, 0x2d, 0x37, 0x08, 0xa3, 0x0d, 0xb7, 0x45, 0xc2, 0xc8, 0x69, 0xb5, 0x1f, 0x42, 0x7a, 0xac, - 0xc6, 0x61, 0xd5, 0xa0, 0x84, 0x13, 0x94, 0xd1, 0x36, 0x8c, 0x37, 0x1d, 0xbd, 0xa9, 0xe1, 0x23, - 0x37, 0xa5, 0x6e, 0x87, 0x9b, 0x3a, 0x21, 0x6c, 0xd2, 0xa5, 0xdb, 0xa9, 0xce, 0x04, 0xa0, 0x23, - 0x4c, 0x2c, 0xa0, 0xb6, 0x13, 0x97, 0x7c, 0x72, 0x18, 0x65, 0x74, 0x98, 0x81, 0x6c, 0xc9, 0x64, - 0x74, 0x34, 0x33, 0xd8, 0xcf, 0x42, 0x89, 0xd0, 0x21, 0xa4, 0x84, 0xc5, 0x05, 0x73, 0xa5, 0xbf, - 0xbe, 0xae, 0xb9, 0xf5, 0xc0, 0x37, 0xe5, 0xf6, 0x2b, 0x92, 0x12, 0x8e, 0x89, 0xa2, 0x65, 0x18, - 0x0a, 0x49, 0xe0, 0x92, 0x50, 0x5c, 0x35, 0x5d, 0xa6, 0x91, 0xa1, 0x71, 0xdf, 0x12, 0xfe, 0x1b, - 0x8b, 0xaa, 0x74, 0x79, 0x39, 0x4c, 0xa4, 0xc9, 0x2e, 0x03, 0x6d, 0x79, 0x2d, 0xb2, 0x52, 0x2c, - 0xa0, 0xe8, 0x75, 0x18, 0x0e, 0x48, 0x93, 0x29, 0x86, 0xc6, 0xfb, 0x5f, 0xe4, 0x5c, 0xcf, 0xc4, - 0xeb, 0x61, 0x49, 0x00, 0xdd, 0x00, 0x14, 0x10, 0xca, 0x28, 0xb9, 0xde, 0xb6, 0x32, 0x1b, 0x15, - 0x07, 0xad, 0x62, 0x48, 0x71, 0x8c, 0x21, 0xdd, 0x7c, 0x70, 0x46, 0x35, 0x74, 0x0d, 0xa6, 0x55, - 0x69, 0xc5, 0x0b, 0x23, 0x87, 0x1e, 0x70, 0x93, 0x8c, 0x96, 0x92, 0x53, 0xe0, 0x24, 0x02, 0x4e, - 0xd7, 0xb1, 0xbf, 0x6c, 0x01, 0x1f, 0xe7, 0x13, 0x78, 0x9d, 0xbf, 0x66, 0xbe, 0xce, 0xcf, 0xe6, - 0xce, 0x5c, 0xce, 0xcb, 0xfc, 0xcb, 0x16, 0x8c, 0x6a, 0x33, 0x1b, 0xaf, 0x59, 0xab, 0xcb, 0x9a, - 0xed, 0xc0, 0x14, 0x5d, 0xe9, 0xb7, 0x36, 0x43, 0x12, 0xec, 0x91, 0x06, 0x5b, 0x98, 0x85, 0x87, - 0x5b, 0x98, 0xca, 0x44, 0xed, 0x66, 0x82, 0x20, 0x4e, 0x35, 0x61, 0x7f, 0x56, 0x76, 0x55, 0x59, - 0xf4, 0xd5, 0xd5, 0x9c, 0x27, 0x2c, 0xfa, 0xd4, 0xac, 0xe2, 0x18, 0x87, 0x6e, 0xb5, 0x1d, 0x3f, - 0x8c, 0x92, 0x16, 0x7d, 0xd7, 0xfd, 0x30, 0xc2, 0x0c, 0x62, 0xbf, 0x00, 0xb0, 0x72, 0x9f, 0xd4, - 0xf9, 0x8a, 0xd5, 0x1f, 0x0f, 0x56, 0xfe, 0xe3, 0xc1, 0xfe, 0x6d, 0x0b, 0x26, 0x56, 0x97, 0x8d, - 0x9b, 0x6b, 0x01, 0x80, 0xbf, 0x78, 0xee, 0xde, 0x5d, 0x97, 0xea, 0x70, 0xae, 0xd1, 0x54, 0xa5, - 0x58, 0xc3, 0x40, 0x67, 0xa1, 0xd8, 0xec, 0x78, 0x42, 0x7c, 0x38, 0x4c, 0xaf, 0xc7, 0x9b, 0x1d, - 0x0f, 0xd3, 0x32, 0xcd, 0xa5, 0xa0, 0xd8, 0xb7, 0x4b, 0x41, 0x4f, 0xd7, 0x7e, 0x34, 0x0f, 0x83, - 0xf7, 0xee, 0xb9, 0x0d, 0xee, 0x40, 0x29, 0x54, 0xf5, 0x77, 0xef, 0x56, 0xca, 0x21, 0xe6, 0xe5, - 0xf6, 0x97, 0x8a, 0x30, 0xb7, 0xda, 0x24, 0xf7, 0xdf, 0xa1, 0x13, 0x69, 0xbf, 0x0e, 0x11, 0x47, - 0x13, 0xc4, 0x1c, 0xd5, 0xe9, 0xa5, 0xf7, 0x78, 0x6c, 0xc1, 0x30, 0x37, 0x68, 0x93, 0x2e, 0xa5, - 0xaf, 0x66, 0xb5, 0x9e, 0x3f, 0x20, 0x0b, 0xdc, 0x30, 0x4e, 0x78, 0xc4, 0xa9, 0x0b, 0x53, 0x94, - 0x62, 0x49, 0x7c, 0xee, 0x15, 0x18, 0xd3, 0x31, 0x8f, 0xe4, 0x7e, 0xf6, 0xff, 0x14, 0x61, 0x8a, - 0xf6, 0xe0, 0x91, 0x4e, 0xc4, 0xed, 0xf4, 0x44, 0x1c, 0xb7, 0x0b, 0x52, 0xef, 0xd9, 0x78, 0x33, - 0x39, 0x1b, 0x57, 0xf3, 0x66, 0xe3, 0xa4, 0xe7, 0xe0, 0xbb, 0x2d, 0x98, 0x59, 0x6d, 0xfa, 0xf5, - 0xdd, 0x84, 0x9b, 0xd0, 0x4b, 0x30, 0x4a, 0x8f, 0xe3, 0xd0, 0xf0, 0x60, 0x37, 0x62, 0x1a, 0x08, - 0x10, 0xd6, 0xf1, 0xb4, 0x6a, 0xb7, 0x6f, 0x57, 0xca, 0x59, 0xa1, 0x10, 0x04, 0x08, 0xeb, 0x78, - 0xf6, 0x6f, 0x5a, 0x70, 0xee, 0xda, 0xf2, 0x4a, 0xbc, 0x14, 0x53, 0xd1, 0x18, 0x2e, 0xc1, 0x50, - 0xbb, 0xa1, 0x75, 0x25, 0x16, 0xaf, 0x96, 0x59, 0x2f, 0x04, 0xf4, 0xdd, 0x12, 0x69, 0xe4, 0x67, - 0x2d, 0x98, 0xb9, 0xe6, 0x46, 0xf4, 0x76, 0x4d, 0xc6, 0x05, 0xa0, 0xd7, 0x6b, 0xe8, 0x46, 0x7e, - 0xb0, 0x9f, 0x8c, 0x0b, 0x80, 0x15, 0x04, 0x6b, 0x58, 0xbc, 0xe5, 0x3d, 0x97, 0x99, 0x52, 0x17, - 0x4c, 0x45, 0x13, 0x16, 0xe5, 0x58, 0x61, 0xd0, 0x0f, 0x6b, 0xb8, 0x01, 0x93, 0xd1, 0xed, 0x8b, - 0x13, 0x56, 0x7d, 0x58, 0x59, 0x02, 0x70, 0x8c, 0x63, 0xff, 0xb1, 0x05, 0xf3, 0xd7, 0x9a, 0x9d, - 0x30, 0x22, 0xc1, 0x56, 0x98, 0x73, 0x3a, 0xbe, 0x00, 0x25, 0x22, 0x25, 0xe2, 0xa2, 0xd7, 0x8a, - 0x63, 0x54, 0xa2, 0x72, 0x1e, 0x9e, 0x40, 0xe1, 0xf5, 0xe1, 0x74, 0x78, 0x34, 0xaf, 0xb1, 0x55, - 0x40, 0x44, 0x6f, 0x4b, 0x8f, 0xd7, 0xc0, 0x1c, 0xbf, 0x57, 0x52, 0x50, 0x9c, 0x51, 0xc3, 0xfe, - 0x09, 0x0b, 0x4e, 0xab, 0x0f, 0x7e, 0xd7, 0x7d, 0xa6, 0xfd, 0xf3, 0x05, 0x18, 0xbf, 0xbe, 0xb1, - 0x51, 0xbd, 0x46, 0x22, 0x71, 0x6d, 0xf7, 0xd6, 0x73, 0x63, 0x4d, 0x5d, 0xd7, 0xed, 0x31, 0xd7, - 0x89, 0xdc, 0xe6, 0x02, 0x0f, 0xfb, 0xb3, 0x50, 0xf1, 0xa2, 0x5b, 0x41, 0x2d, 0x0a, 0x5c, 0x6f, - 0x3b, 0x53, 0xc1, 0x27, 0x99, 0x8b, 0x62, 0x1e, 0x73, 0x81, 0x5e, 0x80, 0x21, 0x16, 0x77, 0x48, - 0x4e, 0xc2, 0xe3, 0xea, 0x2d, 0xc4, 0x4a, 0x0f, 0x0f, 0xe6, 0x4b, 0xb7, 0x71, 0x85, 0xff, 0xc1, - 0x02, 0x15, 0xdd, 0x86, 0xd1, 0x9d, 0x28, 0x6a, 0x5f, 0x27, 0x4e, 0x83, 0x04, 0xf2, 0x38, 0x3c, - 0x9f, 0x75, 0x1c, 0xd2, 0x41, 0xe0, 0x68, 0xf1, 0x09, 0x12, 0x97, 0x85, 0x58, 0xa7, 0x63, 0xd7, - 0x00, 0x62, 0xd8, 0x31, 0x69, 0x2a, 0xec, 0x3f, 0xb4, 0x60, 0x98, 0x87, 0x80, 0x08, 0xd0, 0x47, - 0x61, 0x80, 0xdc, 0x27, 0x75, 0xc1, 0xf1, 0x66, 0x76, 0x38, 0xe6, 0xb4, 0xb8, 0xc4, 0x95, 0xfe, - 0xc7, 0xac, 0x16, 0xba, 0x0e, 0xc3, 0xb4, 0xb7, 0xd7, 0x54, 0x3c, 0x8c, 0x27, 0xf3, 0xbe, 0x58, - 0x4d, 0x3b, 0x67, 0xce, 0x44, 0x11, 0x96, 0xd5, 0x99, 0x7a, 0xb8, 0xde, 0xae, 0xd1, 0x13, 0x3b, - 0xea, 0xc6, 0x58, 0x6c, 0x2c, 0x57, 0x39, 0x92, 0xa0, 0xc6, 0xd5, 0xc3, 0xb2, 0x10, 0xc7, 0x44, - 0xec, 0x0d, 0x28, 0xd1, 0x49, 0x5d, 0x6c, 0xba, 0x4e, 0x77, 0x8d, 0xf7, 0x33, 0x50, 0x92, 0xfa, - 0xec, 0x50, 0xb8, 0x7e, 0x33, 0xaa, 0x52, 0xdd, 0x1d, 0xe2, 0x18, 0x6e, 0x6f, 0xc1, 0x29, 0x66, - 0x9d, 0xe8, 0x44, 0x3b, 0xc6, 0x1e, 0xeb, 0xbd, 0x98, 0x9f, 0x15, 0x0f, 0x48, 0x3e, 0x33, 0xb3, - 0x9a, 0x77, 0xe5, 0x98, 0xa4, 0x18, 0x3f, 0x26, 0xed, 0xaf, 0x0f, 0xc0, 0xe3, 0x95, 0x5a, 0x7e, - 0x74, 0x90, 0x97, 0x61, 0x8c, 0xf3, 0xa5, 0x74, 0x69, 0x3b, 0x4d, 0xd1, 0xae, 0x12, 0xb5, 0x6e, - 0x68, 0x30, 0x6c, 0x60, 0xa2, 0x73, 0x50, 0x74, 0xdf, 0xf2, 0x92, 0xbe, 0x47, 0x95, 0x37, 0xd6, - 0x31, 0x2d, 0xa7, 0x60, 0xca, 0xe2, 0xf2, 0xbb, 0x43, 0x81, 0x15, 0x9b, 0xfb, 0x1a, 0x4c, 0xb8, - 0x61, 0x3d, 0x74, 0x2b, 0x1e, 0x3d, 0x67, 0xb4, 0x93, 0x4a, 0x09, 0x37, 0x68, 0xa7, 0x15, 0x14, - 0x27, 0xb0, 0xb5, 0x8b, 0x6c, 0xb0, 0x6f, 0x36, 0xb9, 0xa7, 0x2f, 0x34, 0x7d, 0x01, 0xb4, 0xd9, - 0xd7, 0x85, 0x4c, 0x66, 0x2e, 0x5e, 0x00, 0xfc, 0x83, 0x43, 0x2c, 0x61, 0xf4, 0xe5, 0x58, 0xdf, - 0x71, 0xda, 0x8b, 0x9d, 0x68, 0xa7, 0xec, 0x86, 0x75, 0x7f, 0x8f, 0x04, 0xfb, 0xec, 0xd1, 0x3f, - 0x12, 0xbf, 0x1c, 0x15, 0x60, 0xf9, 0xfa, 0x62, 0x95, 0x62, 0xe2, 0x74, 0x1d, 0xb4, 0x08, 0x93, - 0xb2, 0xb0, 0x46, 0x42, 0x76, 0x85, 0x8d, 0x32, 0x32, 0xca, 0x1b, 0x48, 0x14, 0x2b, 0x22, 0x49, - 0x7c, 0x93, 0x93, 0x86, 0xe3, 0xe0, 0xa4, 0x3f, 0x02, 0xe3, 0xae, 0xe7, 0x46, 0xae, 0x13, 0xf9, - 0x5c, 0xe1, 0xc3, 0xdf, 0xf7, 0x4c, 0x92, 0x5d, 0xd1, 0x01, 0xd8, 0xc4, 0xb3, 0xff, 0xf3, 0x00, - 0x4c, 0xb3, 0x69, 0x7b, 0x6f, 0x85, 0x7d, 0x2b, 0xad, 0xb0, 0xdb, 0xe9, 0x15, 0x76, 0x1c, 0x4f, - 0x84, 0x87, 0x5e, 0x66, 0x9f, 0x83, 0x92, 0x72, 0x80, 0x92, 0x1e, 0x90, 0x56, 0x8e, 0x07, 0x64, - 0x6f, 0xee, 0x43, 0xda, 0x90, 0x15, 0x33, 0x6d, 0xc8, 0xfe, 0xaa, 0x05, 0xb1, 0x06, 0x03, 0x5d, - 0x87, 0x52, 0xdb, 0x67, 0xa6, 0x91, 0x81, 0xb4, 0x37, 0x7e, 0x3c, 0xf3, 0xa2, 0xe2, 0x97, 0x22, - 0xff, 0xf8, 0xaa, 0xac, 0x81, 0xe3, 0xca, 0x68, 0x09, 0x86, 0xdb, 0x01, 0xa9, 0x45, 0x2c, 0x48, - 0x48, 0x4f, 0x3a, 0x7c, 0x8d, 0x70, 0x7c, 0x2c, 0x2b, 0xda, 0xbf, 0x60, 0x01, 0x70, 0x33, 0x2d, - 0xc7, 0xdb, 0x26, 0x27, 0x20, 0xb5, 0x2e, 0xc3, 0x40, 0xd8, 0x26, 0xf5, 0x6e, 0x46, 0xab, 0x71, - 0x7f, 0x6a, 0x6d, 0x52, 0x8f, 0x07, 0x9c, 0xfe, 0xc3, 0xac, 0xb6, 0xfd, 0xbd, 0x00, 0x13, 0x31, - 0x5a, 0x25, 0x22, 0x2d, 0xf4, 0x9c, 0x11, 0x34, 0xe0, 0x6c, 0x22, 0x68, 0x40, 0x89, 0x61, 0x6b, - 0x02, 0xd2, 0xcf, 0x41, 0xb1, 0xe5, 0xdc, 0x17, 0x12, 0xb0, 0x67, 0xba, 0x77, 0x83, 0xd2, 0x5f, - 0x58, 0x73, 0xee, 0xf3, 0x47, 0xe2, 0x33, 0x72, 0x81, 0xac, 0x39, 0xf7, 0x0f, 0xb9, 0x69, 0x2a, - 0x3b, 0xa4, 0x6e, 0xba, 0x61, 0xf4, 0x85, 0xff, 0x14, 0xff, 0x67, 0xcb, 0x8e, 0x36, 0xc2, 0xda, - 0x72, 0x3d, 0x61, 0x81, 0xd4, 0x57, 0x5b, 0xae, 0x97, 0x6c, 0xcb, 0xf5, 0xfa, 0x68, 0xcb, 0xf5, - 0xd0, 0xdb, 0x30, 0x2c, 0x0c, 0x04, 0x45, 0x90, 0x9e, 0x2b, 0x7d, 0xb4, 0x27, 0xec, 0x0b, 0x79, - 0x9b, 0x57, 0xe4, 0x23, 0x58, 0x94, 0xf6, 0x6c, 0x57, 0x36, 0x88, 0xfe, 0x92, 0x05, 0x13, 0xe2, - 0x37, 0x26, 0x6f, 0x75, 0x48, 0x18, 0x09, 0xde, 0xf3, 0xc3, 0xfd, 0xf7, 0x41, 0x54, 0xe4, 0x5d, - 0xf9, 0xb0, 0x3c, 0x66, 0x4d, 0x60, 0xcf, 0x1e, 0x25, 0x7a, 0x81, 0xfe, 0x8e, 0x05, 0xa7, 0x5a, - 0xce, 0x7d, 0xde, 0x22, 0x2f, 0xc3, 0x4e, 0xe4, 0xfa, 0x42, 0xd1, 0xfe, 0xd1, 0xfe, 0xa6, 0x3f, - 0x55, 0x9d, 0x77, 0x52, 0x6a, 0x03, 0x4f, 0x65, 0xa1, 0xf4, 0xec, 0x6a, 0x66, 0xbf, 0xe6, 0xb6, - 0x60, 0x44, 0xae, 0xb7, 0x0c, 0x51, 0x43, 0x59, 0x67, 0xac, 0x8f, 0x6c, 0x9f, 0xa9, 0x3b, 0xe3, - 0xd3, 0x76, 0xc4, 0x5a, 0x7b, 0xa4, 0xed, 0x7c, 0x0e, 0xc6, 0xf4, 0x35, 0xf6, 0x48, 0xdb, 0x7a, - 0x0b, 0x66, 0x32, 0xd6, 0xd2, 0x23, 0x6d, 0xf2, 0x1e, 0x9c, 0xcd, 0x5d, 0x1f, 0x8f, 0xb2, 0x61, - 0xfb, 0xe7, 0x2d, 0xfd, 0x1c, 0x3c, 0x01, 0xd5, 0xc1, 0xb2, 0xa9, 0x3a, 0x38, 0xdf, 0x7d, 0xe7, - 0xe4, 0xe8, 0x0f, 0xde, 0xd4, 0x3b, 0x4d, 0x4f, 0x75, 0xf4, 0x3a, 0x0c, 0x35, 0x69, 0x89, 0x34, - 0x33, 0xb5, 0x7b, 0xef, 0xc8, 0x98, 0x97, 0x62, 0xe5, 0x21, 0x16, 0x14, 0xec, 0x5f, 0xb6, 0x60, - 0xe0, 0x04, 0x46, 0x02, 0x9b, 0x23, 0xf1, 0x5c, 0x2e, 0x69, 0x11, 0x3f, 0x78, 0x01, 0x3b, 0xf7, - 0x56, 0xee, 0x47, 0xc4, 0x0b, 0xd9, 0x53, 0x31, 0x73, 0x60, 0x7e, 0xda, 0x82, 0x99, 0x9b, 0xbe, - 0xd3, 0x58, 0x72, 0x9a, 0x8e, 0x57, 0x27, 0x41, 0xc5, 0xdb, 0x3e, 0x92, 0x8d, 0x74, 0xa1, 0xa7, - 0x8d, 0xf4, 0xb2, 0x34, 0x31, 0x1a, 0xc8, 0x9f, 0x3f, 0xca, 0x48, 0x26, 0xc3, 0xa8, 0x18, 0xc6, - 0xb0, 0x3b, 0x80, 0xf4, 0x5e, 0x0a, 0x8f, 0x15, 0x0c, 0xc3, 0x2e, 0xef, 0xaf, 0x98, 0xc4, 0xa7, - 0xb2, 0x19, 0xbc, 0xd4, 0xe7, 0x69, 0xbe, 0x18, 0xbc, 0x00, 0x4b, 0x42, 0xf6, 0xcb, 0x90, 0xe9, - 0xf6, 0xde, 0x5b, 0xf8, 0x60, 0x7f, 0x12, 0xa6, 0x59, 0xcd, 0x23, 0x3e, 0x8c, 0xed, 0x84, 0x6c, - 0x33, 0x23, 0x20, 0x9e, 0xfd, 0x45, 0x0b, 0x26, 0xd7, 0x13, 0x71, 0xc2, 0x2e, 0x31, 0x6d, 0x68, - 0x86, 0x48, 0xbd, 0xc6, 0x4a, 0xb1, 0x80, 0x1e, 0xbb, 0x24, 0xeb, 0x2f, 0x2c, 0x88, 0x23, 0x51, - 0x9c, 0x00, 0xfb, 0xb6, 0x6c, 0xb0, 0x6f, 0x99, 0x12, 0x16, 0xd5, 0x9d, 0x3c, 0xee, 0x0d, 0xdd, - 0x50, 0x31, 0x9a, 0xba, 0x08, 0x57, 0x62, 0x32, 0x7c, 0x29, 0x4e, 0x98, 0x81, 0x9c, 0x64, 0xd4, - 0x26, 0xfb, 0x77, 0x0a, 0x80, 0x14, 0x6e, 0xdf, 0x31, 0xa4, 0xd2, 0x35, 0x8e, 0x27, 0x86, 0xd4, - 0x1e, 0x20, 0xa6, 0xcf, 0x0f, 0x1c, 0x2f, 0xe4, 0x64, 0x5d, 0x21, 0xbb, 0x3b, 0x9a, 0xb1, 0xc0, - 0x9c, 0x68, 0x12, 0xdd, 0x4c, 0x51, 0xc3, 0x19, 0x2d, 0x68, 0x76, 0x1a, 0x83, 0xfd, 0xda, 0x69, - 0x0c, 0xf5, 0xf0, 0x4a, 0xfb, 0x39, 0x0b, 0xc6, 0xd5, 0x30, 0xbd, 0x4b, 0x6c, 0xc6, 0x55, 0x7f, - 0x72, 0x0e, 0xd0, 0xaa, 0xd6, 0x65, 0x76, 0xb1, 0x7c, 0x3b, 0xf3, 0x2e, 0x74, 0x9a, 0xee, 0xdb, - 0x44, 0x45, 0xf0, 0x9b, 0x17, 0xde, 0x82, 0xa2, 0xf4, 0xf0, 0x60, 0x7e, 0x5c, 0xfd, 0xe3, 0x11, - 0x83, 0xe3, 0x2a, 0xf4, 0x48, 0x9e, 0x4c, 0x2c, 0x45, 0xf4, 0x12, 0x0c, 0xb6, 0x77, 0x9c, 0x90, - 0x24, 0x7c, 0x6b, 0x06, 0xab, 0xb4, 0xf0, 0xf0, 0x60, 0x7e, 0x42, 0x55, 0x60, 0x25, 0x98, 0x63, - 0xf7, 0x1f, 0x99, 0x2b, 0xbd, 0x38, 0x7b, 0x46, 0xe6, 0xfa, 0x53, 0x0b, 0x06, 0xd6, 0xfd, 0xc6, - 0x49, 0x1c, 0x01, 0xaf, 0x19, 0x47, 0xc0, 0x13, 0x79, 0xc1, 0xdc, 0x73, 0x77, 0xff, 0x6a, 0x62, - 0xf7, 0x9f, 0xcf, 0xa5, 0xd0, 0x7d, 0xe3, 0xb7, 0x60, 0x94, 0x85, 0x88, 0x17, 0x7e, 0x44, 0x2f, - 0x18, 0x1b, 0x7e, 0x3e, 0xb1, 0xe1, 0x27, 0x35, 0x54, 0x6d, 0xa7, 0x3f, 0x0d, 0xc3, 0xc2, 0x31, - 0x25, 0xe9, 0xa4, 0x29, 0x70, 0xb1, 0x84, 0xdb, 0x3f, 0x59, 0x04, 0x23, 0x24, 0x3d, 0xfa, 0x55, - 0x0b, 0x16, 0x02, 0x6e, 0xb0, 0xda, 0x28, 0x77, 0x02, 0xd7, 0xdb, 0xae, 0xd5, 0x77, 0x48, 0xa3, - 0xd3, 0x74, 0xbd, 0xed, 0xca, 0xb6, 0xe7, 0xab, 0xe2, 0x95, 0xfb, 0xa4, 0xde, 0x61, 0x4a, 0xb0, - 0x1e, 0xf1, 0xef, 0x95, 0xe1, 0xf7, 0xf3, 0x0f, 0x0e, 0xe6, 0x17, 0xf0, 0x91, 0x68, 0xe3, 0x23, - 0xf6, 0x05, 0xfd, 0xa6, 0x05, 0x57, 0x78, 0xa4, 0xf6, 0xfe, 0xfb, 0xdf, 0xe5, 0xb5, 0x5c, 0x95, - 0xa4, 0x62, 0x22, 0x1b, 0x24, 0x68, 0x2d, 0x7d, 0x44, 0x0c, 0xe8, 0x95, 0xea, 0xd1, 0xda, 0xc2, - 0x47, 0xed, 0x9c, 0xfd, 0x4f, 0x8a, 0x30, 0x2e, 0x22, 0x38, 0x89, 0x3b, 0xe0, 0x25, 0x63, 0x49, - 0x3c, 0x99, 0x58, 0x12, 0xd3, 0x06, 0xf2, 0xf1, 0x1c, 0xff, 0x21, 0x4c, 0xd3, 0xc3, 0xf9, 0x3a, - 0x71, 0x82, 0x68, 0x93, 0x38, 0xdc, 0xfc, 0xaa, 0x78, 0xe4, 0xd3, 0x5f, 0x89, 0xe7, 0x6e, 0x26, - 0x89, 0xe1, 0x34, 0xfd, 0x6f, 0xa5, 0x3b, 0xc7, 0x83, 0xa9, 0x54, 0x10, 0xae, 0x4f, 0x41, 0x49, - 0x79, 0x55, 0x88, 0x43, 0xa7, 0x7b, 0x2c, 0xbb, 0x24, 0x05, 0x2e, 0x42, 0x8b, 0x3d, 0x7a, 0x62, - 0x72, 0xf6, 0xdf, 0x2b, 0x18, 0x0d, 0xf2, 0x49, 0x5c, 0x87, 0x11, 0x27, 0x0c, 0xdd, 0x6d, 0x8f, - 0x34, 0xc4, 0x8e, 0x7d, 0x7f, 0xde, 0x8e, 0x35, 0x9a, 0x61, 0x9e, 0x2d, 0x8b, 0xa2, 0x26, 0x56, - 0x34, 0xd0, 0x75, 0x6e, 0xe4, 0xb6, 0x27, 0xdf, 0x7b, 0xfd, 0x51, 0x03, 0x69, 0x06, 0xb7, 0x47, - 0xb0, 0xa8, 0x8f, 0x3e, 0xcd, 0xad, 0x10, 0x6f, 0x78, 0xfe, 0x3d, 0xef, 0x9a, 0xef, 0xcb, 0x28, - 0x09, 0xfd, 0x11, 0x9c, 0x96, 0xb6, 0x87, 0xaa, 0x3a, 0x36, 0xa9, 0xf5, 0x17, 0xd5, 0xf2, 0xf3, - 0x30, 0x43, 0x49, 0x9b, 0x4e, 0xcc, 0x21, 0x22, 0x30, 0x29, 0xc2, 0x83, 0xc9, 0x32, 0x31, 0x76, - 0x99, 0x4f, 0x39, 0xb3, 0x76, 0x2c, 0x47, 0xbe, 0x61, 0x92, 0xc0, 0x49, 0x9a, 0xf6, 0xcf, 0x58, - 0xc0, 0x1c, 0x3a, 0x4f, 0x80, 0x1f, 0xf9, 0x98, 0xc9, 0x8f, 0xcc, 0xe6, 0x0d, 0x72, 0x0e, 0x2b, - 0xf2, 0x22, 0x5f, 0x59, 0xd5, 0xc0, 0xbf, 0xbf, 0x2f, 0x4c, 0x47, 0x7a, 0xbf, 0x3f, 0xec, 0xff, - 0x65, 0xf1, 0x43, 0x4c, 0xf9, 0x3c, 0xa0, 0xef, 0x84, 0x91, 0xba, 0xd3, 0x76, 0xea, 0x3c, 0x7f, - 0x4a, 0xae, 0x44, 0xcf, 0xa8, 0xb4, 0xb0, 0x2c, 0x6a, 0x70, 0x09, 0x95, 0x0c, 0x33, 0x37, 0x22, - 0x8b, 0x7b, 0x4a, 0xa5, 0x54, 0x93, 0x73, 0xbb, 0x30, 0x6e, 0x10, 0x7b, 0xa4, 0xe2, 0x8c, 0xef, - 0xe4, 0x57, 0xac, 0x0a, 0x8b, 0xd8, 0x82, 0x69, 0x4f, 0xfb, 0x4f, 0x2f, 0x14, 0xf9, 0xb8, 0x7c, - 0x7f, 0xaf, 0x4b, 0x94, 0xdd, 0x3e, 0x9a, 0xaf, 0x68, 0x82, 0x0c, 0x4e, 0x53, 0xb6, 0x7f, 0xca, - 0x82, 0xc7, 0x74, 0x44, 0xcd, 0x1d, 0xa5, 0x97, 0x8e, 0xa0, 0x0c, 0x23, 0x7e, 0x9b, 0x04, 0x4e, - 0xe4, 0x07, 0xe2, 0xd6, 0xb8, 0x2c, 0x07, 0xfd, 0x96, 0x28, 0x3f, 0x14, 0xd1, 0xc7, 0x25, 0x75, - 0x59, 0x8e, 0x55, 0x4d, 0xfa, 0xfa, 0x64, 0x83, 0x11, 0x0a, 0xc7, 0x23, 0x76, 0x06, 0x30, 0x75, - 0x79, 0x88, 0x05, 0xc4, 0xfe, 0xba, 0xc5, 0x17, 0x96, 0xde, 0x75, 0xf4, 0x16, 0x4c, 0xb5, 0x9c, - 0xa8, 0xbe, 0xb3, 0x72, 0xbf, 0x1d, 0x70, 0x8d, 0x8b, 0x1c, 0xa7, 0x67, 0x7a, 0x8d, 0x93, 0xf6, - 0x91, 0xb1, 0x61, 0xe5, 0x5a, 0x82, 0x18, 0x4e, 0x91, 0x47, 0x9b, 0x30, 0xca, 0xca, 0x98, 0x4f, - 0x5d, 0xd8, 0x8d, 0x35, 0xc8, 0x6b, 0x4d, 0x59, 0x1c, 0xac, 0xc5, 0x74, 0xb0, 0x4e, 0xd4, 0xfe, - 0x4a, 0x91, 0xef, 0x76, 0xc6, 0xca, 0x3f, 0x0d, 0xc3, 0x6d, 0xbf, 0xb1, 0x5c, 0x29, 0x63, 0x31, - 0x0b, 0xea, 0x1a, 0xa9, 0xf2, 0x62, 0x2c, 0xe1, 0xe8, 0x32, 0x8c, 0x88, 0x9f, 0x52, 0x43, 0xc6, - 0xce, 0x66, 0x81, 0x17, 0x62, 0x05, 0x45, 0xcf, 0x03, 0xb4, 0x03, 0x7f, 0xcf, 0x6d, 0xb0, 0x58, - 0x0f, 0x45, 0xd3, 0x58, 0xa8, 0xaa, 0x20, 0x58, 0xc3, 0x42, 0xaf, 0xc2, 0x78, 0xc7, 0x0b, 0x39, - 0x3b, 0xa2, 0x45, 0x76, 0x55, 0x66, 0x2c, 0xb7, 0x75, 0x20, 0x36, 0x71, 0xd1, 0x22, 0x0c, 0x45, - 0x0e, 0x33, 0x7e, 0x19, 0xcc, 0x37, 0xbe, 0xdd, 0xa0, 0x18, 0x7a, 0xaa, 0x0e, 0x5a, 0x01, 0x8b, - 0x8a, 0xe8, 0x53, 0xd2, 0xbd, 0x95, 0x1f, 0xec, 0xc2, 0xea, 0xbd, 0xbf, 0x4b, 0x40, 0x73, 0x6e, - 0x15, 0xd6, 0xf4, 0x06, 0x2d, 0xf4, 0x0a, 0x00, 0xb9, 0x1f, 0x91, 0xc0, 0x73, 0x9a, 0xca, 0xb6, - 0x4c, 0xf1, 0x05, 0x65, 0x7f, 0xdd, 0x8f, 0x6e, 0x87, 0x64, 0x45, 0x61, 0x60, 0x0d, 0xdb, 0xfe, - 0xcd, 0x12, 0x40, 0xcc, 0xb7, 0xa3, 0xb7, 0x53, 0x07, 0xd7, 0xb3, 0xdd, 0x39, 0xfd, 0xe3, 0x3b, - 0xb5, 0xd0, 0xf7, 0x59, 0x30, 0xea, 0x34, 0x9b, 0x7e, 0xdd, 0xe1, 0xb1, 0x77, 0x0b, 0xdd, 0x0f, - 0x4e, 0xd1, 0xfe, 0x62, 0x5c, 0x83, 0x77, 0xe1, 0x05, 0xb9, 0x42, 0x35, 0x48, 0xcf, 0x5e, 0xe8, - 0x0d, 0xa3, 0x0f, 0xc9, 0xa7, 0x62, 0xd1, 0x18, 0x4a, 0xf5, 0x54, 0x2c, 0xb1, 0x3b, 0x42, 0x7f, - 0x25, 0xde, 0x36, 0x5e, 0x89, 0x03, 0xf9, 0xfe, 0x7b, 0x06, 0xfb, 0xda, 0xeb, 0x81, 0x88, 0xaa, - 0xba, 0x2f, 0xff, 0x60, 0xbe, 0xb3, 0x9c, 0xf6, 0x4e, 0xea, 0xe1, 0xc7, 0xff, 0x39, 0x98, 0x6c, - 0x98, 0x4c, 0x80, 0x58, 0x89, 0x4f, 0xe5, 0xd1, 0x4d, 0xf0, 0x0c, 0xf1, 0xb5, 0x9f, 0x00, 0xe0, - 0x24, 0x61, 0x54, 0xe5, 0xa1, 0x1d, 0x2a, 0xde, 0x96, 0x2f, 0x3c, 0x2f, 0xec, 0xdc, 0xb9, 0xdc, - 0x0f, 0x23, 0xd2, 0xa2, 0x98, 0xf1, 0xed, 0xbe, 0x2e, 0xea, 0x62, 0x45, 0x05, 0xbd, 0x0e, 0x43, - 0xcc, 0x5b, 0x2a, 0x9c, 0x1d, 0xc9, 0x97, 0x38, 0x9b, 0xb1, 0xca, 0xe2, 0x0d, 0xc9, 0xfe, 0x86, - 0x58, 0x50, 0x40, 0xd7, 0xa5, 0x2f, 0x62, 0x58, 0xf1, 0x6e, 0x87, 0x84, 0xf9, 0x22, 0x96, 0x96, - 0xde, 0x1f, 0xbb, 0x19, 0xf2, 0xf2, 0xcc, 0x84, 0x5e, 0x46, 0x4d, 0xca, 0x45, 0x89, 0xff, 0x32, - 0x4f, 0xd8, 0x2c, 0xe4, 0x77, 0xcf, 0xcc, 0x25, 0x16, 0x0f, 0xe7, 0x1d, 0x93, 0x04, 0x4e, 0xd2, - 0xa4, 0x1c, 0x29, 0xdf, 0xf5, 0xc2, 0x77, 0xa3, 0xd7, 0xd9, 0xc1, 0x1f, 0xe2, 0xec, 0x36, 0xe2, - 0x25, 0x58, 0xd4, 0x3f, 0x51, 0xf6, 0x60, 0xce, 0x83, 0xa9, 0xe4, 0x16, 0x7d, 0xa4, 0xec, 0xc8, - 0x1f, 0x0e, 0xc0, 0x84, 0xb9, 0xa4, 0xd0, 0x15, 0x28, 0x09, 0x22, 0x2a, 0xb6, 0xbf, 0xda, 0x25, - 0x6b, 0x12, 0x80, 0x63, 0x1c, 0x96, 0xd2, 0x81, 0x55, 0xd7, 0x8c, 0x75, 0xe3, 0x94, 0x0e, 0x0a, - 0x82, 0x35, 0x2c, 0xfa, 0xb0, 0xda, 0xf4, 0xfd, 0x48, 0x5d, 0x48, 0x6a, 0xdd, 0x2d, 0xb1, 0x52, - 0x2c, 0xa0, 0xf4, 0x22, 0xda, 0x25, 0x81, 0x47, 0x9a, 0x66, 0x14, 0x60, 0x75, 0x11, 0xdd, 0xd0, - 0x81, 0xd8, 0xc4, 0xa5, 0xd7, 0xa9, 0x1f, 0xb2, 0x85, 0x2c, 0x9e, 0x6f, 0xb1, 0xf1, 0x73, 0x8d, - 0xbb, 0x43, 0x4b, 0x38, 0xfa, 0x24, 0x3c, 0xa6, 0x22, 0x1d, 0x61, 0xae, 0xcd, 0x90, 0x2d, 0x0e, - 0x19, 0xd2, 0x96, 0xc7, 0x96, 0xb3, 0xd1, 0x70, 0x5e, 0x7d, 0xf4, 0x1a, 0x4c, 0x08, 0x16, 0x5f, - 0x52, 0x1c, 0x36, 0x0d, 0x6c, 0x6e, 0x18, 0x50, 0x9c, 0xc0, 0x96, 0x71, 0x8c, 0x19, 0x97, 0x2d, - 0x29, 0x8c, 0xa4, 0xe3, 0x18, 0xeb, 0x70, 0x9c, 0xaa, 0x81, 0x16, 0x61, 0x92, 0xf3, 0x60, 0xae, - 0xb7, 0xcd, 0xe7, 0x44, 0xb8, 0x56, 0xa9, 0x2d, 0x75, 0xcb, 0x04, 0xe3, 0x24, 0x3e, 0x7a, 0x19, - 0xc6, 0x9c, 0xa0, 0xbe, 0xe3, 0x46, 0xa4, 0x1e, 0x75, 0x02, 0xee, 0x73, 0xa5, 0x59, 0x28, 0x2d, - 0x6a, 0x30, 0x6c, 0x60, 0xda, 0x6f, 0xc3, 0x4c, 0x46, 0x9c, 0x04, 0xba, 0x70, 0x9c, 0xb6, 0x2b, - 0xbf, 0x29, 0x61, 0xc6, 0xbc, 0x58, 0xad, 0xc8, 0xaf, 0xd1, 0xb0, 0xe8, 0xea, 0x64, 0xf1, 0x14, - 0xb4, 0xb4, 0x80, 0x6a, 0x75, 0xae, 0x4a, 0x00, 0x8e, 0x71, 0xec, 0xff, 0x56, 0x80, 0xc9, 0x0c, - 0xdd, 0x0a, 0x4b, 0x4d, 0x97, 0x78, 0xa4, 0xc4, 0x99, 0xe8, 0xcc, 0xb0, 0xd8, 0x85, 0x23, 0x84, - 0xc5, 0x2e, 0xf6, 0x0a, 0x8b, 0x3d, 0xf0, 0x4e, 0xc2, 0x62, 0x9b, 0x23, 0x36, 0xd8, 0xd7, 0x88, - 0x65, 0x84, 0xd2, 0x1e, 0x3a, 0x62, 0x28, 0x6d, 0x63, 0xd0, 0x87, 0xfb, 0x18, 0xf4, 0x1f, 0x2d, - 0xc0, 0x54, 0xd2, 0x92, 0xf2, 0x04, 0xe4, 0xb6, 0xaf, 0x1b, 0x72, 0xdb, 0xcb, 0xfd, 0xb8, 0xc2, - 0xe6, 0xca, 0x70, 0x71, 0x42, 0x86, 0xfb, 0xc1, 0xbe, 0xa8, 0x75, 0x97, 0xe7, 0xfe, 0xf5, 0x02, - 0x9c, 0xce, 0xf4, 0xc5, 0x3d, 0x81, 0xb1, 0xb9, 0x65, 0x8c, 0xcd, 0x73, 0x7d, 0xbb, 0x09, 0xe7, - 0x0e, 0xd0, 0xdd, 0xc4, 0x00, 0x5d, 0xe9, 0x9f, 0x64, 0xf7, 0x51, 0xfa, 0x5a, 0x11, 0xce, 0x67, - 0xd6, 0x8b, 0xc5, 0x9e, 0xab, 0x86, 0xd8, 0xf3, 0xf9, 0x84, 0xd8, 0xd3, 0xee, 0x5e, 0xfb, 0x78, - 0xe4, 0xa0, 0xc2, 0x5d, 0x96, 0x39, 0xfd, 0x3f, 0xa4, 0x0c, 0xd4, 0x70, 0x97, 0x55, 0x84, 0xb0, - 0x49, 0xf7, 0x5b, 0x49, 0xf6, 0xf9, 0xaf, 0x2d, 0x38, 0x9b, 0x39, 0x37, 0x27, 0x20, 0xeb, 0x5a, - 0x37, 0x65, 0x5d, 0x4f, 0xf7, 0xbd, 0x5a, 0x73, 0x84, 0x5f, 0x5f, 0x19, 0xcc, 0xf9, 0x16, 0xf6, - 0x92, 0xbf, 0x05, 0xa3, 0x4e, 0xbd, 0x4e, 0xc2, 0x70, 0xcd, 0x6f, 0xa8, 0xc8, 0xbf, 0xcf, 0xb1, - 0x77, 0x56, 0x5c, 0x7c, 0x78, 0x30, 0x3f, 0x97, 0x24, 0x11, 0x83, 0xb1, 0x4e, 0x01, 0x7d, 0x1a, - 0x46, 0x42, 0x71, 0x6f, 0x8a, 0xb9, 0x7f, 0xa1, 0xcf, 0xc1, 0x71, 0x36, 0x49, 0xd3, 0x0c, 0x4d, - 0xa4, 0x24, 0x15, 0x8a, 0xa4, 0x19, 0xc6, 0xa4, 0x70, 0xac, 0x61, 0x4c, 0x9e, 0x07, 0xd8, 0x53, - 0x8f, 0x81, 0xa4, 0xfc, 0x41, 0x7b, 0x26, 0x68, 0x58, 0xe8, 0xe3, 0x30, 0x15, 0xf2, 0xd8, 0x7d, - 0xcb, 0x4d, 0x27, 0x64, 0xce, 0x32, 0x62, 0x15, 0xb2, 0xf0, 0x47, 0xb5, 0x04, 0x0c, 0xa7, 0xb0, - 0xd1, 0xaa, 0x6c, 0x95, 0x05, 0x1a, 0xe4, 0x0b, 0xf3, 0x52, 0xdc, 0xa2, 0x48, 0x8c, 0x7b, 0x2a, - 0x39, 0xfc, 0x6c, 0xe0, 0xb5, 0x9a, 0xe8, 0xd3, 0x00, 0x74, 0xf9, 0x08, 0x39, 0xc4, 0x70, 0xfe, - 0xe1, 0x49, 0x4f, 0x95, 0x46, 0xa6, 0x6d, 0x2f, 0xf3, 0x70, 0x2d, 0x2b, 0x22, 0x58, 0x23, 0x88, - 0xb6, 0x60, 0x3c, 0xfe, 0x17, 0xe7, 0x8d, 0x3c, 0x62, 0x0b, 0x4c, 0xee, 0x5d, 0xd6, 0xe9, 0x60, - 0x93, 0xac, 0xfd, 0xa3, 0x03, 0xf0, 0x78, 0x97, 0xb3, 0x18, 0x2d, 0x9a, 0xfa, 0xde, 0x67, 0x92, - 0x8f, 0xf8, 0xb9, 0xcc, 0xca, 0xc6, 0xab, 0x3e, 0xb1, 0xe4, 0x0b, 0xef, 0x78, 0xc9, 0xff, 0x90, - 0xa5, 0x89, 0x57, 0xb8, 0x65, 0xe9, 0xc7, 0x8e, 0x78, 0xc7, 0x1c, 0xa3, 0xbc, 0x65, 0x2b, 0x43, - 0x68, 0xf1, 0x7c, 0xdf, 0xdd, 0xe9, 0x5b, 0x8a, 0x71, 0xb2, 0xd2, 0xe8, 0xdf, 0xb6, 0xe0, 0x5c, - 0xd7, 0xe0, 0x20, 0xdf, 0x84, 0x8c, 0x89, 0xfd, 0x05, 0x0b, 0x9e, 0xcc, 0xac, 0x61, 0x98, 0x33, - 0x5d, 0x81, 0x52, 0x9d, 0x16, 0x6a, 0xde, 0xa0, 0xb1, 0x9b, 0xbc, 0x04, 0xe0, 0x18, 0xc7, 0xb0, - 0x5a, 0x2a, 0xf4, 0xb4, 0x5a, 0xfa, 0x35, 0x0b, 0x52, 0x87, 0xcb, 0x09, 0xdc, 0x72, 0x15, 0xf3, - 0x96, 0x7b, 0x7f, 0x3f, 0xa3, 0x99, 0x73, 0xc1, 0xfd, 0xc9, 0x24, 0x9c, 0xc9, 0xf1, 0x86, 0xda, - 0x83, 0xe9, 0xed, 0x3a, 0x31, 0xfd, 0x6c, 0xbb, 0xc5, 0x9f, 0xe9, 0xea, 0x94, 0xcb, 0x52, 0x84, - 0x4e, 0xa7, 0x50, 0x70, 0xba, 0x09, 0xf4, 0x05, 0x0b, 0x4e, 0x39, 0xf7, 0xc2, 0x15, 0xca, 0xad, - 0xb8, 0xf5, 0xa5, 0xa6, 0x5f, 0xdf, 0xa5, 0x57, 0x81, 0xdc, 0x08, 0x2f, 0x66, 0x4a, 0x90, 0xee, - 0xd6, 0x52, 0xf8, 0x46, 0xf3, 0x2c, 0x67, 0x6a, 0x16, 0x16, 0xce, 0x6c, 0x0b, 0x61, 0x11, 0x48, - 0x9f, 0xbe, 0x85, 0xba, 0x78, 0x82, 0x67, 0xb9, 0xad, 0xf1, 0xeb, 0x57, 0x42, 0xb0, 0xa2, 0x83, - 0x3e, 0x0b, 0xa5, 0x6d, 0xe9, 0x4b, 0x9a, 0x71, 0xbd, 0xc7, 0x03, 0xd9, 0xdd, 0xc3, 0x96, 0xab, - 0x81, 0x15, 0x12, 0x8e, 0x89, 0xa2, 0xd7, 0xa0, 0xe8, 0x6d, 0x85, 0xdd, 0xd2, 0x8e, 0x26, 0xec, - 0xfd, 0x78, 0xbc, 0x85, 0xf5, 0xd5, 0x1a, 0xa6, 0x15, 0xd1, 0x75, 0x28, 0x06, 0x9b, 0x0d, 0x21, - 0xfe, 0xcc, 0xdc, 0xa4, 0x78, 0xa9, 0x9c, 0xd3, 0x2b, 0x46, 0x09, 0x2f, 0x95, 0x31, 0x25, 0x81, - 0xaa, 0x30, 0xc8, 0x5c, 0x88, 0xc4, 0x65, 0x9a, 0xf9, 0x6c, 0xe8, 0xe2, 0x8a, 0xc7, 0x83, 0x32, - 0x30, 0x04, 0xcc, 0x09, 0xa1, 0x0d, 0x18, 0xaa, 0xb3, 0x14, 0x95, 0xe2, 0xf6, 0xfc, 0x50, 0xa6, - 0xa0, 0xb3, 0x4b, 0xee, 0x4e, 0x21, 0xf7, 0x63, 0x18, 0x58, 0xd0, 0x62, 0x54, 0x49, 0x7b, 0x67, - 0x2b, 0x14, 0x29, 0x95, 0xb3, 0xa9, 0x76, 0x49, 0x49, 0x2b, 0xa8, 0x32, 0x0c, 0x2c, 0x68, 0xa1, - 0x57, 0xa0, 0xb0, 0x55, 0x17, 0xee, 0x41, 0x99, 0x12, 0x4f, 0x33, 0x64, 0xc6, 0xd2, 0xd0, 0x83, - 0x83, 0xf9, 0xc2, 0xea, 0x32, 0x2e, 0x6c, 0xd5, 0xd1, 0x3a, 0x0c, 0x6f, 0x71, 0x27, 0x7b, 0x21, - 0xd4, 0x7c, 0x2a, 0xdb, 0xff, 0x3f, 0xe5, 0x87, 0xcf, 0x3d, 0x63, 0x04, 0x00, 0x4b, 0x22, 0x2c, - 0x2e, 0xbd, 0x0a, 0x16, 0x20, 0x62, 0x95, 0x2d, 0x1c, 0x2d, 0xc0, 0x03, 0x67, 0x6e, 0xe2, 0x90, - 0x03, 0x58, 0xa3, 0x48, 0x57, 0xb5, 0x23, 0xf3, 0xda, 0x8b, 0xa0, 0x36, 0x99, 0xab, 0xba, 0x47, - 0xca, 0x7f, 0xbe, 0xaa, 0x15, 0x12, 0x8e, 0x89, 0xa2, 0x5d, 0x18, 0xdf, 0x0b, 0xdb, 0x3b, 0x44, - 0x6e, 0x69, 0x16, 0xe3, 0x26, 0xe7, 0x5e, 0xbe, 0x23, 0x10, 0xdd, 0x20, 0xea, 0x38, 0xcd, 0xd4, - 0x29, 0xc4, 0x78, 0xa8, 0x3b, 0x3a, 0x31, 0x6c, 0xd2, 0xa6, 0xc3, 0xff, 0x56, 0xc7, 0xdf, 0xdc, - 0x8f, 0x88, 0x08, 0x31, 0x96, 0x39, 0xfc, 0x6f, 0x70, 0x94, 0xf4, 0xf0, 0x0b, 0x00, 0x96, 0x44, - 0xd0, 0x1d, 0x31, 0x3c, 0xec, 0xf4, 0x9c, 0xca, 0x8f, 0x03, 0xba, 0x28, 0x91, 0x72, 0x06, 0x85, - 0x9d, 0x96, 0x31, 0x29, 0x76, 0x4a, 0xb6, 0x77, 0xfc, 0xc8, 0xf7, 0x12, 0x27, 0xf4, 0x74, 0xfe, - 0x29, 0x59, 0xcd, 0xc0, 0x4f, 0x9f, 0x92, 0x59, 0x58, 0x38, 0xb3, 0x2d, 0xd4, 0x80, 0x89, 0xb6, - 0x1f, 0x44, 0xf7, 0xfc, 0x40, 0xae, 0x2f, 0xd4, 0x45, 0x28, 0x63, 0x60, 0x8a, 0x16, 0x59, 0xf4, - 0x3e, 0x13, 0x82, 0x13, 0x34, 0xd1, 0x27, 0x60, 0x38, 0xac, 0x3b, 0x4d, 0x52, 0xb9, 0x35, 0x3b, - 0x93, 0x7f, 0xfd, 0xd4, 0x38, 0x4a, 0xce, 0xea, 0xe2, 0x41, 0xec, 0x39, 0x0a, 0x96, 0xe4, 0xd0, - 0x2a, 0x0c, 0xb2, 0xbc, 0x63, 0x2c, 0x1e, 0x5e, 0x4e, 0x38, 0xd3, 0x94, 0xf5, 0x35, 0x3f, 0x9b, - 0x58, 0x31, 0xe6, 0xd5, 0xe9, 0x1e, 0x10, 0x6f, 0x13, 0x3f, 0x9c, 0x3d, 0x9d, 0xbf, 0x07, 0xc4, - 0x93, 0xe6, 0x56, 0xad, 0xdb, 0x1e, 0x50, 0x48, 0x38, 0x26, 0x4a, 0x4f, 0x66, 0x7a, 0x9a, 0x9e, - 0xe9, 0x62, 0x36, 0x94, 0x7b, 0x96, 0xb2, 0x93, 0x99, 0x9e, 0xa4, 0x94, 0x84, 0xfd, 0xfb, 0xc3, - 0x69, 0x9e, 0x85, 0xbd, 0x66, 0xbf, 0xc7, 0x4a, 0x29, 0x3a, 0x3f, 0xdc, 0xaf, 0x70, 0xed, 0x18, - 0x59, 0xf0, 0x2f, 0x58, 0x70, 0xa6, 0x9d, 0xf9, 0x21, 0x82, 0x01, 0xe8, 0x4f, 0x46, 0xc7, 0x3f, - 0x5d, 0xc5, 0x4e, 0xcc, 0x86, 0xe3, 0x9c, 0x96, 0x92, 0xcf, 0x9c, 0xe2, 0x3b, 0x7e, 0xe6, 0xac, - 0xc1, 0x08, 0x63, 0x32, 0x7b, 0xa4, 0x6c, 0x4e, 0xbe, 0xf9, 0x18, 0x2b, 0xb1, 0x2c, 0x2a, 0x62, - 0x45, 0x02, 0xfd, 0xb0, 0x05, 0xe7, 0x92, 0x5d, 0xc7, 0x84, 0x81, 0x45, 0xc0, 0x45, 0xfe, 0x90, - 0x5e, 0x15, 0xdf, 0x9f, 0xe2, 0xff, 0x0d, 0xe4, 0xc3, 0x5e, 0x08, 0xb8, 0x7b, 0x63, 0xa8, 0x9c, - 0xf1, 0x92, 0x1f, 0x32, 0xb5, 0x17, 0x7d, 0xbc, 0xe6, 0x5f, 0x84, 0xb1, 0x96, 0xdf, 0xf1, 0x22, - 0x61, 0x65, 0x24, 0x2c, 0x1e, 0x98, 0xa6, 0x7f, 0x4d, 0x2b, 0xc7, 0x06, 0x56, 0x42, 0x06, 0x30, - 0xf2, 0xd0, 0x32, 0x80, 0x37, 0x61, 0xcc, 0xd3, 0xcc, 0x62, 0x05, 0x3f, 0x70, 0x29, 0x3f, 0x58, - 0xaa, 0x6e, 0x44, 0xcb, 0x7b, 0xa9, 0x97, 0x60, 0x83, 0xda, 0xc9, 0x3e, 0xf8, 0xbe, 0x6c, 0x65, - 0x30, 0xf5, 0x5c, 0x04, 0xf0, 0x51, 0x53, 0x04, 0x70, 0x29, 0x29, 0x02, 0x48, 0x49, 0xae, 0x8d, - 0xd7, 0x7f, 0xff, 0xb9, 0x60, 0xfa, 0x0d, 0xb8, 0x68, 0x37, 0xe1, 0x42, 0xaf, 0x6b, 0x89, 0x99, - 0x9b, 0x35, 0x94, 0x9e, 0x32, 0x36, 0x37, 0x6b, 0x54, 0xca, 0x98, 0x41, 0xfa, 0x0d, 0xe5, 0x63, - 0xff, 0x17, 0x0b, 0x8a, 0x55, 0xbf, 0x71, 0x02, 0x0f, 0xde, 0x8f, 0x19, 0x0f, 0xde, 0xc7, 0xb3, - 0x2f, 0xc4, 0x46, 0xae, 0xdc, 0x7d, 0x25, 0x21, 0x77, 0x3f, 0x97, 0x47, 0xa0, 0xbb, 0x94, 0xfd, - 0xa7, 0x8b, 0x30, 0x5a, 0xf5, 0x1b, 0xca, 0xd6, 0xfb, 0x9f, 0x3d, 0x8c, 0xad, 0x77, 0x6e, 0x46, - 0x03, 0x8d, 0x32, 0xb3, 0x52, 0x93, 0x6e, 0xae, 0xdf, 0x64, 0x26, 0xdf, 0x77, 0x89, 0xbb, 0xbd, - 0x13, 0x91, 0x46, 0xf2, 0x73, 0x4e, 0xce, 0xe4, 0xfb, 0xf7, 0x0b, 0x30, 0x99, 0x68, 0x1d, 0x35, - 0x61, 0xbc, 0xa9, 0x4b, 0x75, 0xc5, 0x3a, 0x7d, 0x28, 0x81, 0xb0, 0x30, 0x99, 0xd5, 0x8a, 0xb0, - 0x49, 0x1c, 0x2d, 0x00, 0x28, 0x35, 0xa7, 0x14, 0xeb, 0x31, 0xae, 0x5f, 0xe9, 0x41, 0x43, 0xac, - 0x61, 0xa0, 0x97, 0x60, 0x34, 0xf2, 0xdb, 0x7e, 0xd3, 0xdf, 0xde, 0xbf, 0x41, 0x64, 0xf0, 0x28, - 0x65, 0x08, 0xb7, 0x11, 0x83, 0xb0, 0x8e, 0x87, 0xee, 0xc3, 0xb4, 0x22, 0x52, 0x3b, 0x06, 0x49, - 0x37, 0x93, 0x2a, 0xac, 0x27, 0x29, 0xe2, 0x74, 0x23, 0xf6, 0xcf, 0x16, 0xf9, 0x10, 0x7b, 0x91, - 0xfb, 0xde, 0x6e, 0x78, 0x77, 0xef, 0x86, 0xaf, 0x59, 0x30, 0x45, 0x5b, 0x67, 0x56, 0x3e, 0xf2, - 0x9a, 0x57, 0xe1, 0x99, 0xad, 0x2e, 0xe1, 0x99, 0x2f, 0xd1, 0x53, 0xb3, 0xe1, 0x77, 0x22, 0x21, - 0xbb, 0xd3, 0x8e, 0x45, 0x5a, 0x8a, 0x05, 0x54, 0xe0, 0x91, 0x20, 0x10, 0x9e, 0x89, 0x3a, 0x1e, - 0x09, 0x02, 0x2c, 0xa0, 0x32, 0x7a, 0xf3, 0x40, 0x76, 0xf4, 0x66, 0x1e, 0x84, 0x53, 0xd8, 0x83, - 0x08, 0x86, 0x4b, 0x0b, 0xc2, 0x29, 0x0d, 0x45, 0x62, 0x1c, 0xfb, 0xe7, 0x8b, 0x30, 0x56, 0xf5, - 0x1b, 0xb1, 0x8a, 0xf3, 0x45, 0x43, 0xc5, 0x79, 0x21, 0xa1, 0xe2, 0x9c, 0xd2, 0x71, 0xdf, 0x53, - 0x68, 0x7e, 0xa3, 0x14, 0x9a, 0xff, 0xd8, 0x62, 0xb3, 0x56, 0x5e, 0xaf, 0x71, 0xa3, 0x31, 0x74, - 0x15, 0x46, 0xd9, 0x01, 0xc3, 0x5c, 0x61, 0xa5, 0xde, 0x8f, 0x65, 0x25, 0x5a, 0x8f, 0x8b, 0xb1, - 0x8e, 0x83, 0x2e, 0xc3, 0x48, 0x48, 0x9c, 0xa0, 0xbe, 0xa3, 0x4e, 0x57, 0xa1, 0xa4, 0xe3, 0x65, - 0x58, 0x41, 0xd1, 0x1b, 0x71, 0xfc, 0xc7, 0x62, 0xbe, 0x6b, 0x9d, 0xde, 0x1f, 0xbe, 0x45, 0xf2, - 0x83, 0x3e, 0xda, 0x77, 0x01, 0xa5, 0xf1, 0xfb, 0x08, 0x7c, 0x36, 0x6f, 0x06, 0x3e, 0x2b, 0xa5, - 0x82, 0x9e, 0xfd, 0xb9, 0x05, 0x13, 0x55, 0xbf, 0x41, 0xb7, 0xee, 0xb7, 0xd2, 0x3e, 0xd5, 0x83, - 0xdf, 0x0e, 0x75, 0x09, 0x7e, 0x7b, 0x11, 0x06, 0xab, 0x7e, 0xa3, 0x52, 0xed, 0xe6, 0xd7, 0x6e, - 0xff, 0x0d, 0x0b, 0x86, 0xab, 0x7e, 0xe3, 0x04, 0xd4, 0x02, 0x1f, 0x35, 0xd5, 0x02, 0x8f, 0xe5, - 0xac, 0x9b, 0x1c, 0x4d, 0xc0, 0x5f, 0x1b, 0x80, 0x71, 0xda, 0x4f, 0x7f, 0x5b, 0x4e, 0xa5, 0x31, - 0x6c, 0x56, 0x1f, 0xc3, 0x46, 0xb9, 0x70, 0xbf, 0xd9, 0xf4, 0xef, 0x25, 0xa7, 0x75, 0x95, 0x95, - 0x62, 0x01, 0x45, 0xcf, 0xc2, 0x48, 0x3b, 0x20, 0x7b, 0xae, 0x2f, 0xd8, 0x5b, 0x4d, 0xc9, 0x52, - 0x15, 0xe5, 0x58, 0x61, 0xd0, 0x67, 0x61, 0xe8, 0x7a, 0xf4, 0x2a, 0xaf, 0xfb, 0x5e, 0x83, 0x4b, - 0xce, 0x8b, 0x22, 0x43, 0x83, 0x56, 0x8e, 0x0d, 0x2c, 0x74, 0x17, 0x4a, 0xec, 0x3f, 0x3b, 0x76, - 0x8e, 0x9e, 0xeb, 0x53, 0xe4, 0x7e, 0x13, 0x04, 0x70, 0x4c, 0x0b, 0x3d, 0x0f, 0x10, 0xc9, 0x28, - 0xe7, 0xa1, 0x08, 0x72, 0xa5, 0x9e, 0x02, 0x2a, 0xfe, 0x79, 0x88, 0x35, 0x2c, 0xf4, 0x0c, 0x94, - 0x22, 0xc7, 0x6d, 0xde, 0x74, 0x3d, 0x12, 0x32, 0x89, 0x78, 0x51, 0xa6, 0x60, 0x13, 0x85, 0x38, - 0x86, 0x53, 0x56, 0x8c, 0x45, 0x80, 0xe0, 0x99, 0x82, 0x47, 0x18, 0x36, 0x63, 0xc5, 0x6e, 0xaa, - 0x52, 0xac, 0x61, 0xa0, 0x1d, 0x78, 0xc2, 0xf5, 0x58, 0x36, 0x03, 0x52, 0xdb, 0x75, 0xdb, 0x1b, - 0x37, 0x6b, 0x77, 0x48, 0xe0, 0x6e, 0xed, 0x2f, 0x39, 0xf5, 0x5d, 0xe2, 0xc9, 0x2c, 0x8e, 0xef, - 0x17, 0x5d, 0x7c, 0xa2, 0xd2, 0x05, 0x17, 0x77, 0xa5, 0x64, 0xbf, 0x0c, 0xa7, 0xab, 0x7e, 0xa3, - 0xea, 0x07, 0xd1, 0xaa, 0x1f, 0xdc, 0x73, 0x82, 0x86, 0x5c, 0x29, 0xf3, 0x32, 0x1a, 0x03, 0x3d, - 0x0a, 0x07, 0xf9, 0x41, 0x61, 0x44, 0x5a, 0x78, 0x81, 0x31, 0x5f, 0x47, 0xf4, 0x21, 0xaa, 0x33, - 0x36, 0x40, 0xa5, 0xf6, 0xb8, 0xe6, 0x44, 0x04, 0xdd, 0x62, 0x29, 0x8b, 0xe3, 0x1b, 0x51, 0x54, - 0x7f, 0x5a, 0x4b, 0x59, 0x1c, 0x03, 0x33, 0xaf, 0x50, 0xb3, 0xbe, 0xfd, 0x5f, 0x07, 0xd9, 0xe1, - 0x98, 0x48, 0x0f, 0x81, 0x3e, 0x03, 0x13, 0x21, 0xb9, 0xe9, 0x7a, 0x9d, 0xfb, 0x52, 0x1a, 0xd1, - 0xc5, 0x0b, 0xac, 0xb6, 0xa2, 0x63, 0x72, 0x99, 0xa6, 0x59, 0x86, 0x13, 0xd4, 0x50, 0x0b, 0x26, - 0xee, 0xb9, 0x5e, 0xc3, 0xbf, 0x17, 0x4a, 0xfa, 0x23, 0xf9, 0xa2, 0xcd, 0xbb, 0x1c, 0x33, 0xd1, - 0x47, 0xa3, 0xb9, 0xbb, 0x06, 0x31, 0x9c, 0x20, 0x4e, 0x17, 0x60, 0xd0, 0xf1, 0x16, 0xc3, 0xdb, - 0x21, 0x09, 0x44, 0xf2, 0x69, 0xb6, 0x00, 0xb1, 0x2c, 0xc4, 0x31, 0x9c, 0x2e, 0x40, 0xf6, 0xe7, - 0x5a, 0xe0, 0x77, 0x78, 0x2e, 0x02, 0xb1, 0x00, 0xb1, 0x2a, 0xc5, 0x1a, 0x06, 0xdd, 0xa0, 0xec, - 0xdf, 0xba, 0xef, 0x61, 0xdf, 0x8f, 0xe4, 0x96, 0x66, 0xe9, 0x4e, 0xb5, 0x72, 0x6c, 0x60, 0xa1, - 0x55, 0x40, 0x61, 0xa7, 0xdd, 0x6e, 0x32, 0xf3, 0x12, 0xa7, 0xc9, 0x48, 0x71, 0x95, 0x7b, 0x91, - 0x87, 0x68, 0xad, 0xa5, 0xa0, 0x38, 0xa3, 0x06, 0x3d, 0xab, 0xb7, 0x44, 0x57, 0x07, 0x59, 0x57, - 0xb9, 0x1a, 0xa4, 0xc6, 0xfb, 0x29, 0x61, 0x68, 0x05, 0x86, 0xc3, 0xfd, 0xb0, 0x1e, 0x89, 0x58, - 0x73, 0x39, 0x19, 0x80, 0x6a, 0x0c, 0x45, 0x4b, 0x40, 0xc7, 0xab, 0x60, 0x59, 0x17, 0xd5, 0x61, - 0x46, 0x50, 0x5c, 0xde, 0x71, 0x3c, 0x95, 0x4f, 0x85, 0x5b, 0xd9, 0x5e, 0x7d, 0x70, 0x30, 0x3f, - 0x23, 0x5a, 0xd6, 0xc1, 0x87, 0x07, 0xf3, 0x67, 0xaa, 0x7e, 0x23, 0x03, 0x82, 0xb3, 0xa8, 0xf1, - 0xc5, 0x57, 0xaf, 0xfb, 0xad, 0x76, 0x35, 0xf0, 0xb7, 0xdc, 0x26, 0xe9, 0xa6, 0x4a, 0xaa, 0x19, - 0x98, 0x62, 0xf1, 0x19, 0x65, 0x38, 0x41, 0xcd, 0xfe, 0x4e, 0xc6, 0xcf, 0xb0, 0x7c, 0xcb, 0x51, - 0x27, 0x20, 0xa8, 0x05, 0xe3, 0x6d, 0xb6, 0x4d, 0x44, 0x86, 0x00, 0xb1, 0xd6, 0x5f, 0xec, 0x53, - 0x24, 0x72, 0x8f, 0x5e, 0x03, 0xa6, 0x99, 0x4a, 0x55, 0x27, 0x87, 0x4d, 0xea, 0xf6, 0x4f, 0x3c, - 0xc6, 0x6e, 0xc4, 0x1a, 0x97, 0x73, 0x0c, 0x0b, 0xa3, 0x7e, 0xf1, 0xb4, 0x9a, 0xcb, 0x17, 0xb8, - 0xc5, 0xd3, 0x22, 0x1c, 0x03, 0xb0, 0xac, 0x8b, 0x3e, 0x0d, 0x13, 0xf4, 0xa5, 0xa2, 0x6e, 0xa5, - 0x70, 0xf6, 0x54, 0x7e, 0xf0, 0x05, 0x85, 0xa5, 0x67, 0x0f, 0xd1, 0x2b, 0xe3, 0x04, 0x31, 0xf4, - 0x06, 0x33, 0x0b, 0x91, 0xa4, 0x0b, 0xfd, 0x90, 0xd6, 0x2d, 0x40, 0x24, 0x59, 0x8d, 0x08, 0xea, - 0xc0, 0x4c, 0x3a, 0xd7, 0x58, 0x38, 0x6b, 0xe7, 0xb3, 0x7c, 0xe9, 0x74, 0x61, 0x71, 0x9a, 0x87, - 0x34, 0x2c, 0xc4, 0x59, 0xf4, 0xd1, 0x4d, 0x18, 0x17, 0x49, 0x87, 0xc5, 0xca, 0x2d, 0x1a, 0x72, - 0xc0, 0x71, 0xac, 0x03, 0x0f, 0x93, 0x05, 0xd8, 0xac, 0x8c, 0xb6, 0xe1, 0x9c, 0x96, 0x04, 0xe8, - 0x5a, 0xe0, 0x30, 0x65, 0xbe, 0xcb, 0x8e, 0x53, 0xed, 0xae, 0x7e, 0xf2, 0xc1, 0xc1, 0xfc, 0xb9, - 0x8d, 0x6e, 0x88, 0xb8, 0x3b, 0x1d, 0x74, 0x0b, 0x4e, 0x73, 0xd7, 0xe1, 0x32, 0x71, 0x1a, 0x4d, - 0xd7, 0x53, 0xcc, 0x00, 0xdf, 0xf2, 0x67, 0x1f, 0x1c, 0xcc, 0x9f, 0x5e, 0xcc, 0x42, 0xc0, 0xd9, - 0xf5, 0xd0, 0x47, 0xa1, 0xd4, 0xf0, 0x42, 0x31, 0x06, 0x43, 0x46, 0x9e, 0xa5, 0x52, 0x79, 0xbd, - 0xa6, 0xbe, 0x3f, 0xfe, 0x83, 0xe3, 0x0a, 0x68, 0x9b, 0xcb, 0x8a, 0x95, 0x04, 0x63, 0x38, 0x15, - 0x3a, 0x29, 0x29, 0xe4, 0x33, 0x9c, 0x07, 0xb9, 0x92, 0x44, 0xd9, 0xd4, 0x1b, 0x7e, 0x85, 0x06, - 0x61, 0xf4, 0x3a, 0x20, 0xfa, 0x82, 0x70, 0xeb, 0x64, 0xb1, 0xce, 0xd2, 0x4f, 0x30, 0xd1, 0xfa, - 0x88, 0xe9, 0xce, 0x56, 0x4b, 0x61, 0xe0, 0x8c, 0x5a, 0xe8, 0x3a, 0x3d, 0x55, 0xf4, 0x52, 0x71, - 0x6a, 0xa9, 0xac, 0x78, 0x65, 0xd2, 0x0e, 0x48, 0xdd, 0x89, 0x48, 0xc3, 0xa4, 0x88, 0x13, 0xf5, - 0x50, 0x03, 0x9e, 0x70, 0x3a, 0x91, 0xcf, 0xc4, 0xf0, 0x26, 0xea, 0x86, 0xbf, 0x4b, 0x3c, 0xa6, - 0x01, 0x1b, 0x59, 0xba, 0x40, 0xb9, 0x8d, 0xc5, 0x2e, 0x78, 0xb8, 0x2b, 0x15, 0xca, 0x25, 0xaa, - 0x34, 0xb8, 0x60, 0x06, 0x84, 0xca, 0x48, 0x85, 0xfb, 0x12, 0x8c, 0xee, 0xf8, 0x61, 0xb4, 0x4e, - 0xa2, 0x7b, 0x7e, 0xb0, 0x2b, 0xe2, 0x7a, 0xc6, 0xb1, 0xa0, 0x63, 0x10, 0xd6, 0xf1, 0xe8, 0x33, - 0x90, 0xd9, 0x67, 0x54, 0xca, 0x4c, 0x35, 0x3e, 0x12, 0x9f, 0x31, 0xd7, 0x79, 0x31, 0x96, 0x70, - 0x89, 0x5a, 0xa9, 0x2e, 0x33, 0x35, 0x77, 0x02, 0xb5, 0x52, 0x5d, 0xc6, 0x12, 0x4e, 0x97, 0x6b, - 0xb8, 0xe3, 0x04, 0xa4, 0x1a, 0xf8, 0x75, 0x12, 0x6a, 0x11, 0xc8, 0x1f, 0xe7, 0x51, 0x4b, 0xe9, - 0x72, 0xad, 0x65, 0x21, 0xe0, 0xec, 0x7a, 0x88, 0xa4, 0x13, 0x60, 0x4d, 0xe4, 0xeb, 0x27, 0xd2, - 0xfc, 0x4c, 0x9f, 0x39, 0xb0, 0x3c, 0x98, 0x52, 0xa9, 0xb7, 0x78, 0x9c, 0xd2, 0x70, 0x76, 0x92, - 0xad, 0xed, 0xfe, 0x83, 0x9c, 0x2a, 0x8d, 0x4f, 0x25, 0x41, 0x09, 0xa7, 0x68, 0x1b, 0x31, 0xbf, - 0xa6, 0x7a, 0xc6, 0xfc, 0xba, 0x02, 0xa5, 0xb0, 0xb3, 0xd9, 0xf0, 0x5b, 0x8e, 0xeb, 0x31, 0x35, - 0xb7, 0xf6, 0x1e, 0xa9, 0x49, 0x00, 0x8e, 0x71, 0xd0, 0x2a, 0x8c, 0x38, 0x52, 0x9d, 0x83, 0xf2, - 0xa3, 0xbc, 0x28, 0x25, 0x0e, 0x0f, 0x7c, 0x20, 0x15, 0x38, 0xaa, 0x2e, 0x7a, 0x15, 0xc6, 0x85, - 0xeb, 0xab, 0xc8, 0xfa, 0x38, 0x63, 0xfa, 0x27, 0xd5, 0x74, 0x20, 0x36, 0x71, 0xd1, 0x6d, 0x18, - 0x8d, 0xfc, 0x26, 0x73, 0xb2, 0xa1, 0x6c, 0xde, 0x99, 0xfc, 0x78, 0x65, 0x1b, 0x0a, 0x4d, 0x97, - 0xa4, 0xaa, 0xaa, 0x58, 0xa7, 0x83, 0x36, 0xf8, 0x7a, 0x67, 0x91, 0xb8, 0x49, 0x38, 0xfb, 0x58, - 0xfe, 0x9d, 0xa4, 0x02, 0x76, 0x9b, 0xdb, 0x41, 0xd4, 0xc4, 0x3a, 0x19, 0x74, 0x0d, 0xa6, 0xdb, - 0x81, 0xeb, 0xb3, 0x35, 0xa1, 0x34, 0x79, 0xb3, 0x66, 0x1a, 0xa0, 0x6a, 0x12, 0x01, 0xa7, 0xeb, - 0x30, 0xcf, 0x65, 0x51, 0x38, 0x7b, 0x96, 0x27, 0x86, 0xe6, 0xcf, 0x3b, 0x5e, 0x86, 0x15, 0x14, - 0xad, 0xb1, 0x93, 0x98, 0x4b, 0x26, 0x66, 0xe7, 0xf2, 0x03, 0xcb, 0xe8, 0x12, 0x0c, 0xce, 0xbc, - 0xaa, 0xbf, 0x38, 0xa6, 0x80, 0x1a, 0x5a, 0x06, 0x41, 0xfa, 0x62, 0x08, 0x67, 0x9f, 0xe8, 0x62, - 0x24, 0x97, 0x78, 0x5e, 0xc4, 0x0c, 0x81, 0x51, 0x1c, 0xe2, 0x04, 0x4d, 0xf4, 0x71, 0x98, 0x12, - 0xe1, 0xf0, 0xe2, 0x61, 0x3a, 0x17, 0x9b, 0x2e, 0xe3, 0x04, 0x0c, 0xa7, 0xb0, 0x79, 0x86, 0x02, - 0x67, 0xb3, 0x49, 0xc4, 0xd1, 0x77, 0xd3, 0xf5, 0x76, 0xc3, 0xd9, 0xf3, 0xec, 0x7c, 0x10, 0x19, - 0x0a, 0x92, 0x50, 0x9c, 0x51, 0x03, 0x6d, 0xc0, 0x54, 0x3b, 0x20, 0xa4, 0xc5, 0x18, 0x7d, 0x71, - 0x9f, 0xcd, 0x73, 0xc7, 0x7d, 0xda, 0x93, 0x6a, 0x02, 0x76, 0x98, 0x51, 0x86, 0x53, 0x14, 0xd0, - 0x3d, 0x18, 0xf1, 0xf7, 0x48, 0xb0, 0x43, 0x9c, 0xc6, 0xec, 0x85, 0x2e, 0xa6, 0xf4, 0xe2, 0x72, - 0xbb, 0x25, 0x70, 0x13, 0xda, 0x7f, 0x59, 0xdc, 0x5b, 0xfb, 0x2f, 0x1b, 0x43, 0x3f, 0x62, 0xc1, - 0x59, 0xa9, 0x30, 0xa8, 0xb5, 0xe9, 0xa8, 0x2f, 0xfb, 0x5e, 0x18, 0x05, 0xdc, 0xd5, 0xfc, 0xc9, - 0x7c, 0xf7, 0xeb, 0x8d, 0x9c, 0x4a, 0x4a, 0x38, 0x7a, 0x36, 0x0f, 0x23, 0xc4, 0xf9, 0x2d, 0xa2, - 0x65, 0x98, 0x0e, 0x49, 0x24, 0x0f, 0xa3, 0xc5, 0x70, 0xf5, 0x8d, 0xf2, 0xfa, 0xec, 0x45, 0xee, - 0x27, 0x4f, 0x37, 0x43, 0x2d, 0x09, 0xc4, 0x69, 0xfc, 0xb9, 0x6f, 0x87, 0xe9, 0xd4, 0xf5, 0x7f, - 0x94, 0xcc, 0x2b, 0x73, 0xbb, 0x30, 0x6e, 0x0c, 0xf1, 0x23, 0xd5, 0x1e, 0xff, 0xcb, 0x61, 0x28, - 0x29, 0xcd, 0x22, 0xba, 0x62, 0x2a, 0x8c, 0xcf, 0x26, 0x15, 0xc6, 0x23, 0xf4, 0x5d, 0xaf, 0xeb, - 0x88, 0x37, 0x32, 0xa2, 0x83, 0xe5, 0x6d, 0xe8, 0xfe, 0xdd, 0xbe, 0x35, 0x71, 0x6d, 0xb1, 0x6f, - 0xcd, 0xf3, 0x40, 0x57, 0x09, 0xf0, 0x35, 0x98, 0xf6, 0x7c, 0xc6, 0x73, 0x92, 0x86, 0x64, 0x28, - 0x18, 0xdf, 0x50, 0xd2, 0xc3, 0x6d, 0x24, 0x10, 0x70, 0xba, 0x0e, 0x6d, 0x90, 0x5f, 0xfc, 0x49, - 0x91, 0x33, 0xe7, 0x0b, 0xb0, 0x80, 0xa2, 0x8b, 0x30, 0xd8, 0xf6, 0x1b, 0x95, 0xaa, 0xe0, 0x37, - 0xb5, 0x98, 0x94, 0x8d, 0x4a, 0x15, 0x73, 0x18, 0x5a, 0x84, 0x21, 0xf6, 0x23, 0x9c, 0x1d, 0xcb, - 0x8f, 0xab, 0xc0, 0x6a, 0x68, 0x79, 0x6d, 0x58, 0x05, 0x2c, 0x2a, 0x32, 0xd1, 0x17, 0x65, 0xd2, - 0x99, 0xe8, 0x6b, 0xf8, 0x21, 0x45, 0x5f, 0x92, 0x00, 0x8e, 0x69, 0xa1, 0xfb, 0x70, 0xda, 0x78, - 0x18, 0xf1, 0x25, 0x42, 0x42, 0xe1, 0xdb, 0x7d, 0xb1, 0xeb, 0x8b, 0x48, 0x68, 0xaa, 0xcf, 0x89, - 0x4e, 0x9f, 0xae, 0x64, 0x51, 0xc2, 0xd9, 0x0d, 0xa0, 0x26, 0x4c, 0xd7, 0x53, 0xad, 0x8e, 0xf4, - 0xdf, 0xaa, 0x9a, 0xd0, 0x74, 0x8b, 0x69, 0xc2, 0xe8, 0x55, 0x18, 0x79, 0xcb, 0x0f, 0xd9, 0x59, - 0x2d, 0x78, 0x64, 0xe9, 0x18, 0x3c, 0xf2, 0xc6, 0xad, 0x1a, 0x2b, 0x3f, 0x3c, 0x98, 0x1f, 0xad, - 0xfa, 0x0d, 0xf9, 0x17, 0xab, 0x0a, 0xe8, 0xfb, 0x2d, 0x98, 0x4b, 0xbf, 0xbc, 0x54, 0xa7, 0xc7, - 0xfb, 0xef, 0xb4, 0x2d, 0x1a, 0x9d, 0x5b, 0xc9, 0x25, 0x87, 0xbb, 0x34, 0x65, 0xff, 0x8a, 0xc5, - 0xa4, 0x6e, 0x42, 0x03, 0x44, 0xc2, 0x4e, 0xf3, 0x24, 0xd2, 0x79, 0xae, 0x18, 0xca, 0xa9, 0x87, - 0xb6, 0x5c, 0xf8, 0xa7, 0x16, 0xb3, 0x5c, 0x38, 0x41, 0x17, 0x85, 0x37, 0x60, 0x24, 0x92, 0x69, - 0x56, 0xbb, 0x64, 0x20, 0xd5, 0x3a, 0xc5, 0xac, 0x37, 0x14, 0xc7, 0xaa, 0x32, 0xaa, 0x2a, 0x32, - 0xf6, 0x3f, 0xe0, 0x33, 0x20, 0x21, 0x27, 0xa0, 0x03, 0x28, 0x9b, 0x3a, 0x80, 0xf9, 0x1e, 0x5f, - 0x90, 0xa3, 0x0b, 0xf8, 0xfb, 0x66, 0xbf, 0x99, 0xa4, 0xe6, 0xdd, 0x6e, 0x32, 0x63, 0x7f, 0xd1, - 0x02, 0x88, 0x43, 0xfe, 0x32, 0xf9, 0xb2, 0x1f, 0xc8, 0x5c, 0x8e, 0x59, 0x59, 0x8b, 0x5e, 0xa6, - 0x3c, 0xaa, 0x1f, 0xf9, 0x75, 0xbf, 0x29, 0x34, 0x5c, 0x4f, 0xc4, 0x6a, 0x08, 0x5e, 0x7e, 0xa8, - 0xfd, 0xc6, 0x0a, 0x1b, 0xcd, 0xcb, 0x00, 0x63, 0xc5, 0x58, 0x31, 0x66, 0x04, 0x17, 0xfb, 0x31, - 0x0b, 0x4e, 0x65, 0xd9, 0xbb, 0xd2, 0x17, 0x0f, 0x97, 0x59, 0x29, 0x73, 0x26, 0x35, 0x9b, 0x77, - 0x44, 0x39, 0x56, 0x18, 0x7d, 0x67, 0x28, 0x3b, 0x5a, 0xac, 0xdd, 0x5b, 0x30, 0x5e, 0x0d, 0x88, - 0x76, 0xb9, 0xbe, 0xc6, 0x9d, 0xd6, 0x79, 0x7f, 0x9e, 0x3d, 0xb2, 0xc3, 0xba, 0xfd, 0x95, 0x02, - 0x9c, 0xe2, 0x56, 0x01, 0x8b, 0x7b, 0xbe, 0xdb, 0xa8, 0xfa, 0x0d, 0x91, 0x5d, 0xee, 0x53, 0x30, - 0xd6, 0xd6, 0x04, 0x8d, 0xdd, 0xe2, 0x46, 0xea, 0x02, 0xc9, 0x58, 0x34, 0xa2, 0x97, 0x62, 0x83, - 0x16, 0x6a, 0xc0, 0x18, 0xd9, 0x73, 0xeb, 0x4a, 0xb5, 0x5c, 0x38, 0xf2, 0x45, 0xa7, 0x5a, 0x59, - 0xd1, 0xe8, 0x60, 0x83, 0xea, 0x23, 0xc8, 0x1b, 0x6c, 0xff, 0xb8, 0x05, 0x8f, 0xe5, 0x44, 0x99, - 0xa4, 0xcd, 0xdd, 0x63, 0xf6, 0x17, 0x62, 0xd9, 0xaa, 0xe6, 0xb8, 0x55, 0x06, 0x16, 0x50, 0xf4, - 0x09, 0x00, 0x6e, 0x55, 0x41, 0x9f, 0xdc, 0xbd, 0xc2, 0xf1, 0x19, 0x91, 0xc4, 0xb4, 0xa0, 0x50, - 0xb2, 0x3e, 0xd6, 0x68, 0xd9, 0x5f, 0x1a, 0x80, 0x41, 0x9e, 0xe3, 0x7c, 0x15, 0x86, 0x77, 0x78, - 0xce, 0x8d, 0x7e, 0xd2, 0x7b, 0xc4, 0xc2, 0x10, 0x5e, 0x80, 0x65, 0x65, 0xb4, 0x06, 0x33, 0x3c, - 0x67, 0x49, 0xb3, 0x4c, 0x9a, 0xce, 0xbe, 0x94, 0xdc, 0xf1, 0x7c, 0x9f, 0x4a, 0x82, 0x59, 0x49, - 0xa3, 0xe0, 0xac, 0x7a, 0xe8, 0x35, 0x98, 0xa0, 0x2f, 0x29, 0xbf, 0x13, 0x49, 0x4a, 0x3c, 0x5b, - 0x89, 0x7a, 0xba, 0x6d, 0x18, 0x50, 0x9c, 0xc0, 0xa6, 0x8f, 0xf9, 0x76, 0x4a, 0x46, 0x39, 0x18, - 0x3f, 0xe6, 0x4d, 0xb9, 0xa4, 0x89, 0xcb, 0x0c, 0x5d, 0x3b, 0xcc, 0xac, 0x77, 0x63, 0x27, 0x20, - 0xe1, 0x8e, 0xdf, 0x6c, 0x30, 0xa6, 0x6f, 0x50, 0x33, 0x74, 0x4d, 0xc0, 0x71, 0xaa, 0x06, 0xa5, - 0xb2, 0xe5, 0xb8, 0xcd, 0x4e, 0x40, 0x62, 0x2a, 0x43, 0x26, 0x95, 0xd5, 0x04, 0x1c, 0xa7, 0x6a, - 0xf4, 0x16, 0xbe, 0x0e, 0x1f, 0x8f, 0xf0, 0x95, 0x2e, 0xd8, 0xd3, 0xd5, 0xc0, 0xa7, 0x27, 0xb6, - 0x8c, 0xd1, 0xa3, 0xcc, 0xa4, 0x87, 0xa5, 0x3b, 0x71, 0x97, 0x68, 0x76, 0xc2, 0x90, 0x94, 0x53, - 0x30, 0x2c, 0x15, 0x6a, 0xc2, 0x91, 0x58, 0x52, 0x41, 0x57, 0x61, 0x54, 0xa4, 0xbc, 0x60, 0xd6, - 0xbc, 0x7c, 0x8d, 0x30, 0xcb, 0x8a, 0x72, 0x5c, 0x8c, 0x75, 0x1c, 0xfb, 0x07, 0x0a, 0x30, 0x93, - 0xe1, 0x8e, 0xc1, 0xcf, 0xc4, 0x6d, 0x37, 0x8c, 0x54, 0xf2, 0x44, 0xed, 0x4c, 0xe4, 0xe5, 0x58, - 0x61, 0xd0, 0x8d, 0xc7, 0x4f, 0xdd, 0xe4, 0x49, 0x2b, 0xcc, 0x9d, 0x05, 0xf4, 0x88, 0x69, 0x08, - 0x2f, 0xc0, 0x40, 0x27, 0x24, 0x32, 0x0e, 0xa5, 0xba, 0x83, 0x98, 0xc2, 0x8d, 0x41, 0xe8, 0x9b, - 0x60, 0x5b, 0xe9, 0xae, 0xb4, 0x37, 0x01, 0xd7, 0x5e, 0x71, 0x18, 0xed, 0x5c, 0x44, 0x3c, 0xc7, - 0x8b, 0xc4, 0xcb, 0x21, 0x0e, 0xa8, 0xc6, 0x4a, 0xb1, 0x80, 0xda, 0x5f, 0x2a, 0xc2, 0xd9, 0x5c, - 0x07, 0x2d, 0xda, 0xf5, 0x96, 0xef, 0xb9, 0x91, 0xaf, 0x4c, 0x56, 0x78, 0x10, 0x35, 0xd2, 0xde, - 0x59, 0x13, 0xe5, 0x58, 0x61, 0xa0, 0x4b, 0x30, 0xc8, 0xc4, 0x75, 0xa9, 0x34, 0x92, 0x4b, 0x65, - 0x1e, 0x55, 0x87, 0x83, 0xfb, 0x4e, 0xd1, 0x7b, 0x91, 0x5e, 0xc7, 0x7e, 0x33, 0x79, 0x3a, 0xd2, - 0xee, 0xfa, 0x7e, 0x13, 0x33, 0x20, 0xfa, 0x80, 0x18, 0xaf, 0x84, 0x8d, 0x06, 0x76, 0x1a, 0x7e, - 0xa8, 0x0d, 0xda, 0xd3, 0x30, 0xbc, 0x4b, 0xf6, 0x03, 0xd7, 0xdb, 0x4e, 0xda, 0xee, 0xdc, 0xe0, - 0xc5, 0x58, 0xc2, 0xcd, 0x8c, 0x60, 0xc3, 0xc7, 0x9d, 0x5b, 0x77, 0xa4, 0xe7, 0x5d, 0xfb, 0x43, - 0x45, 0x98, 0xc4, 0x4b, 0xe5, 0xf7, 0x26, 0xe2, 0x76, 0x7a, 0x22, 0x8e, 0x3b, 0xb7, 0x6e, 0xef, - 0xd9, 0xf8, 0x45, 0x0b, 0x26, 0x59, 0xe2, 0x0d, 0x11, 0x7e, 0xcb, 0xf5, 0xbd, 0x13, 0xe0, 0x6b, - 0x2f, 0xc2, 0x60, 0x40, 0x1b, 0x4d, 0xe6, 0x8f, 0x64, 0x3d, 0xc1, 0x1c, 0x86, 0x9e, 0x80, 0x01, - 0xd6, 0x05, 0x3a, 0x79, 0x63, 0x3c, 0xf5, 0x56, 0xd9, 0x89, 0x1c, 0xcc, 0x4a, 0x59, 0x4c, 0x19, - 0x4c, 0xda, 0x4d, 0x97, 0x77, 0x3a, 0x56, 0xa6, 0xbe, 0x3b, 0x5c, 0xb7, 0x33, 0xbb, 0xf6, 0xce, - 0x62, 0xca, 0x64, 0x93, 0xec, 0xfe, 0x66, 0xfc, 0xe3, 0x02, 0x9c, 0xcf, 0xac, 0xd7, 0x77, 0x4c, - 0x99, 0xee, 0xb5, 0x1f, 0x65, 0x6a, 0x85, 0xe2, 0x09, 0x5a, 0x46, 0x0e, 0xf4, 0xcb, 0xca, 0x0e, - 0xf6, 0x11, 0xea, 0x25, 0x73, 0xc8, 0xde, 0x25, 0xa1, 0x5e, 0x32, 0xfb, 0x96, 0xf3, 0xe6, 0xfd, - 0x8b, 0x42, 0xce, 0xb7, 0xb0, 0xd7, 0xef, 0x65, 0x7a, 0xce, 0x30, 0x60, 0x28, 0x5f, 0x94, 0xfc, - 0x8c, 0xe1, 0x65, 0x58, 0x41, 0xd1, 0x22, 0x4c, 0xb6, 0x5c, 0x8f, 0x1e, 0x3e, 0xfb, 0x26, 0x87, - 0xa9, 0x22, 0x71, 0xad, 0x99, 0x60, 0x9c, 0xc4, 0x47, 0xae, 0x16, 0x06, 0xa6, 0x90, 0x9f, 0x91, - 0x3d, 0xb7, 0xb7, 0x0b, 0xa6, 0xa2, 0x59, 0x8d, 0x62, 0x46, 0x48, 0x98, 0x35, 0x4d, 0xe8, 0x51, - 0xec, 0x5f, 0xe8, 0x31, 0x96, 0x2d, 0xf0, 0x98, 0x7b, 0x15, 0xc6, 0x1f, 0x5a, 0xca, 0x6d, 0x7f, - 0xad, 0x08, 0x8f, 0x77, 0xd9, 0xf6, 0xfc, 0xac, 0x37, 0xe6, 0x40, 0x3b, 0xeb, 0x53, 0xf3, 0x50, - 0x85, 0x53, 0x5b, 0x9d, 0x66, 0x73, 0x9f, 0x39, 0x0c, 0x90, 0x86, 0xc4, 0x10, 0x3c, 0xa5, 0x7c, - 0xe9, 0x9f, 0x5a, 0xcd, 0xc0, 0xc1, 0x99, 0x35, 0xe9, 0xcb, 0x81, 0xde, 0x24, 0xfb, 0x8a, 0x54, - 0xe2, 0xe5, 0x80, 0x75, 0x20, 0x36, 0x71, 0xd1, 0x35, 0x98, 0x76, 0xf6, 0x1c, 0x97, 0xc7, 0xd2, - 0x95, 0x04, 0xf8, 0xd3, 0x41, 0x09, 0x27, 0x17, 0x93, 0x08, 0x38, 0x5d, 0x07, 0xbd, 0x0e, 0xc8, - 0xdf, 0x64, 0x66, 0xc5, 0x8d, 0x6b, 0xc4, 0x13, 0xfa, 0x40, 0x36, 0x77, 0xc5, 0xf8, 0x48, 0xb8, - 0x95, 0xc2, 0xc0, 0x19, 0xb5, 0x12, 0xe1, 0x4e, 0x86, 0xf2, 0xc3, 0x9d, 0x74, 0x3f, 0x17, 0x7b, - 0x66, 0xf5, 0xf8, 0x8f, 0x16, 0xbd, 0xbe, 0x38, 0x93, 0x6f, 0x46, 0x07, 0x7c, 0x95, 0xd9, 0xf3, - 0x71, 0xc1, 0xa5, 0x16, 0xa4, 0xe3, 0xb4, 0x66, 0xcf, 0x17, 0x03, 0xb1, 0x89, 0xcb, 0x17, 0x44, - 0x18, 0xfb, 0x86, 0x1a, 0x2c, 0xbe, 0x08, 0x61, 0xa4, 0x30, 0xd0, 0x27, 0x61, 0xb8, 0xe1, 0xee, - 0xb9, 0xa1, 0x10, 0xdb, 0x1c, 0x59, 0x47, 0x12, 0x9f, 0x83, 0x65, 0x4e, 0x06, 0x4b, 0x7a, 0xf6, - 0x0f, 0x15, 0x60, 0x5c, 0xb6, 0xf8, 0x46, 0xc7, 0x8f, 0x9c, 0x13, 0xb8, 0x96, 0xaf, 0x19, 0xd7, - 0xf2, 0x07, 0xba, 0xc5, 0x71, 0x62, 0x5d, 0xca, 0xbd, 0x8e, 0x6f, 0x25, 0xae, 0xe3, 0xa7, 0x7a, - 0x93, 0xea, 0x7e, 0x0d, 0xff, 0x43, 0x0b, 0xa6, 0x0d, 0xfc, 0x13, 0xb8, 0x0d, 0x56, 0xcd, 0xdb, - 0xe0, 0xc9, 0x9e, 0xdf, 0x90, 0x73, 0x0b, 0x7c, 0x6f, 0x31, 0xd1, 0x77, 0x76, 0xfa, 0xbf, 0x05, - 0x03, 0x3b, 0x4e, 0xd0, 0xe8, 0x16, 0xb7, 0x3e, 0x55, 0x69, 0xe1, 0xba, 0x13, 0x08, 0x85, 0xe8, - 0xb3, 0x2a, 0x21, 0xba, 0x13, 0xf4, 0x56, 0x86, 0xb2, 0xa6, 0xd0, 0xcb, 0x30, 0x14, 0xd6, 0xfd, - 0xb6, 0x72, 0x17, 0xb8, 0xc0, 0x93, 0xa5, 0xd3, 0x92, 0xc3, 0x83, 0x79, 0x64, 0x36, 0x47, 0x8b, - 0xb1, 0xc0, 0x47, 0x9f, 0x82, 0x71, 0xf6, 0x4b, 0x59, 0x27, 0x15, 0xf3, 0x73, 0x5c, 0xd5, 0x74, - 0x44, 0x6e, 0xba, 0x67, 0x14, 0x61, 0x93, 0xd4, 0xdc, 0x36, 0x94, 0xd4, 0x67, 0x3d, 0x52, 0x25, - 0xe4, 0xbf, 0x2b, 0xc2, 0x4c, 0xc6, 0x9a, 0x43, 0xa1, 0x31, 0x13, 0x57, 0xfb, 0x5c, 0xaa, 0xef, - 0x70, 0x2e, 0x42, 0xf6, 0x1a, 0x6a, 0x88, 0xb5, 0xd5, 0x77, 0xa3, 0xb7, 0x43, 0x92, 0x6c, 0x94, - 0x16, 0xf5, 0x6e, 0x94, 0x36, 0x76, 0x62, 0x43, 0x4d, 0x1b, 0x52, 0x3d, 0x7d, 0xa4, 0x73, 0xfa, - 0x67, 0x45, 0x38, 0x95, 0x15, 0x5a, 0x0e, 0x7d, 0x3e, 0x91, 0x35, 0xf1, 0xc5, 0x7e, 0x83, 0xd2, - 0xf1, 0x54, 0x8a, 0x5c, 0xd8, 0xbc, 0xb4, 0x60, 0xe6, 0x51, 0xec, 0x39, 0xcc, 0xa2, 0x4d, 0x16, - 0xf7, 0x20, 0xe0, 0xd9, 0x2e, 0xe5, 0xf1, 0xf1, 0xe1, 0xbe, 0x3b, 0x20, 0xd2, 0x64, 0x86, 0x09, - 0xcb, 0x07, 0x59, 0xdc, 0xdb, 0xf2, 0x41, 0xb6, 0x3c, 0xe7, 0xc2, 0xa8, 0xf6, 0x35, 0x8f, 0x74, - 0xc6, 0x77, 0xe9, 0x6d, 0xa5, 0xf5, 0xfb, 0x91, 0xce, 0xfa, 0x8f, 0x5b, 0x90, 0x30, 0x86, 0x57, - 0x62, 0x31, 0x2b, 0x57, 0x2c, 0x76, 0x01, 0x06, 0x02, 0xbf, 0x49, 0x92, 0xe9, 0x05, 0xb1, 0xdf, - 0x24, 0x98, 0x41, 0x28, 0x46, 0x14, 0x0b, 0x3b, 0xc6, 0xf4, 0x87, 0x9c, 0x78, 0xa2, 0x5d, 0x84, - 0xc1, 0x26, 0xd9, 0x23, 0xcd, 0x64, 0x16, 0x98, 0x9b, 0xb4, 0x10, 0x73, 0x98, 0xfd, 0x8b, 0x03, - 0x70, 0xae, 0x6b, 0xe4, 0x10, 0xfa, 0x1c, 0xda, 0x76, 0x22, 0x72, 0xcf, 0xd9, 0x4f, 0xa6, 0x6b, - 0xb8, 0xc6, 0x8b, 0xb1, 0x84, 0x33, 0x77, 0x25, 0x1e, 0x75, 0x39, 0x21, 0x44, 0x14, 0xc1, 0x96, - 0x05, 0xd4, 0x14, 0x4a, 0x15, 0x8f, 0x43, 0x28, 0xf5, 0x3c, 0x40, 0x18, 0x36, 0xb9, 0xc9, 0x50, - 0x43, 0xf8, 0x41, 0xc5, 0xd1, 0xb9, 0x6b, 0x37, 0x05, 0x04, 0x6b, 0x58, 0xa8, 0x0c, 0x53, 0xed, - 0xc0, 0x8f, 0xb8, 0x4c, 0xb6, 0xcc, 0xad, 0xea, 0x06, 0xcd, 0xa0, 0x0d, 0xd5, 0x04, 0x1c, 0xa7, - 0x6a, 0xa0, 0x97, 0x60, 0x54, 0x04, 0x72, 0xa8, 0xfa, 0x7e, 0x53, 0x88, 0x81, 0x94, 0xa1, 0x59, - 0x2d, 0x06, 0x61, 0x1d, 0x4f, 0xab, 0xc6, 0x04, 0xbd, 0xc3, 0x99, 0xd5, 0xb8, 0xb0, 0x57, 0xc3, - 0x4b, 0x84, 0x99, 0x1c, 0xe9, 0x2b, 0xcc, 0x64, 0x2c, 0x18, 0x2b, 0xf5, 0xad, 0x44, 0x83, 0x9e, - 0xa2, 0xa4, 0x9f, 0x1b, 0x80, 0x19, 0xb1, 0x70, 0x1e, 0xf5, 0x72, 0xb9, 0x9d, 0x5e, 0x2e, 0xc7, - 0x21, 0x3a, 0x7b, 0x6f, 0xcd, 0x9c, 0xf4, 0x9a, 0xf9, 0x61, 0x0b, 0x4c, 0xf6, 0x0a, 0xfd, 0x5f, - 0xb9, 0xf9, 0x6e, 0x5e, 0xca, 0x65, 0xd7, 0x1a, 0xf2, 0x02, 0x79, 0x87, 0x99, 0x6f, 0xec, 0xff, - 0x60, 0xc1, 0x93, 0x3d, 0x29, 0xa2, 0x15, 0x28, 0x31, 0x1e, 0x50, 0x7b, 0x9d, 0x3d, 0xa5, 0xac, - 0x6e, 0x25, 0x20, 0x87, 0x25, 0x8d, 0x6b, 0xa2, 0x95, 0x54, 0x62, 0xa1, 0xa7, 0x33, 0x12, 0x0b, - 0x9d, 0x36, 0x86, 0xe7, 0x21, 0x33, 0x0b, 0xfd, 0x20, 0xbd, 0x71, 0x0c, 0x8f, 0x17, 0xf4, 0x61, - 0x43, 0xec, 0x67, 0x27, 0xc4, 0x7e, 0xc8, 0xc4, 0xd6, 0xee, 0x90, 0x8f, 0xc3, 0x14, 0x8b, 0xf0, - 0xc4, 0x6c, 0xc0, 0x85, 0x2f, 0x4e, 0x21, 0xb6, 0xf3, 0xbc, 0x99, 0x80, 0xe1, 0x14, 0xb6, 0xfd, - 0x47, 0x45, 0x18, 0xe2, 0xdb, 0xef, 0x04, 0xde, 0x84, 0xcf, 0x40, 0xc9, 0x6d, 0xb5, 0x3a, 0x3c, - 0x57, 0xcc, 0x20, 0x77, 0xc0, 0xa5, 0xf3, 0x54, 0x91, 0x85, 0x38, 0x86, 0xa3, 0x55, 0x21, 0x71, - 0xee, 0x12, 0x44, 0x92, 0x77, 0x7c, 0xa1, 0xec, 0x44, 0x0e, 0x67, 0x70, 0xd4, 0x3d, 0x1b, 0xcb, - 0xa6, 0xd1, 0x67, 0x00, 0xc2, 0x28, 0x70, 0xbd, 0x6d, 0x5a, 0x26, 0x62, 0xa6, 0x7e, 0xb0, 0x0b, - 0xb5, 0x9a, 0x42, 0xe6, 0x34, 0xe3, 0x33, 0x47, 0x01, 0xb0, 0x46, 0x11, 0x2d, 0x18, 0x37, 0xfd, - 0x5c, 0x62, 0xee, 0x80, 0x53, 0x8d, 0xe7, 0x6c, 0xee, 0x23, 0x50, 0x52, 0xc4, 0x7b, 0xc9, 0x9f, - 0xc6, 0x74, 0xb6, 0xe8, 0x63, 0x30, 0x99, 0xe8, 0xdb, 0x91, 0xc4, 0x57, 0xbf, 0x64, 0xc1, 0x24, - 0xef, 0xcc, 0x8a, 0xb7, 0x27, 0x6e, 0x83, 0xb7, 0xe1, 0x54, 0x33, 0xe3, 0x54, 0x16, 0xd3, 0xdf, - 0xff, 0x29, 0xae, 0xc4, 0x55, 0x59, 0x50, 0x9c, 0xd9, 0x06, 0xba, 0x4c, 0x77, 0x1c, 0x3d, 0x75, - 0x9d, 0xa6, 0xf0, 0xc7, 0x1d, 0xe3, 0xbb, 0x8d, 0x97, 0x61, 0x05, 0xb5, 0x7f, 0xd7, 0x82, 0x69, - 0xde, 0xf3, 0x1b, 0x64, 0x5f, 0x9d, 0x4d, 0xdf, 0xc8, 0xbe, 0x8b, 0x2c, 0x65, 0x85, 0x9c, 0x2c, - 0x65, 0xfa, 0xa7, 0x15, 0xbb, 0x7e, 0xda, 0x57, 0x2c, 0x10, 0x2b, 0xe4, 0x04, 0x84, 0x10, 0xdf, - 0x6e, 0x0a, 0x21, 0xe6, 0xf2, 0x37, 0x41, 0x8e, 0xf4, 0xe1, 0xcf, 0x2d, 0x98, 0xe2, 0x08, 0xb1, - 0xb6, 0xfc, 0x1b, 0x3a, 0x0f, 0xfd, 0xe4, 0x32, 0xbe, 0x41, 0xf6, 0x37, 0xfc, 0xaa, 0x13, 0xed, - 0x64, 0x7f, 0x94, 0x31, 0x59, 0x03, 0x5d, 0x27, 0xab, 0x21, 0x37, 0xd0, 0x11, 0x12, 0xa4, 0x1f, - 0x39, 0x89, 0x87, 0xfd, 0x75, 0x0b, 0x10, 0x6f, 0xc6, 0x60, 0xdc, 0x28, 0x3b, 0xc4, 0x4a, 0xb5, - 0x8b, 0x2e, 0x3e, 0x9a, 0x14, 0x04, 0x6b, 0x58, 0xc7, 0x32, 0x3c, 0x09, 0x93, 0x87, 0x62, 0x6f, - 0x93, 0x87, 0x23, 0x8c, 0xe8, 0xbf, 0x1a, 0x82, 0xa4, 0xd7, 0x0f, 0xba, 0x03, 0x63, 0x75, 0xa7, - 0xed, 0x6c, 0xba, 0x4d, 0x37, 0x72, 0x49, 0xd8, 0xcd, 0x28, 0x6b, 0x59, 0xc3, 0x13, 0x4a, 0x6a, - 0xad, 0x04, 0x1b, 0x74, 0xd0, 0x02, 0x40, 0x3b, 0x70, 0xf7, 0xdc, 0x26, 0xd9, 0x66, 0xb2, 0x12, - 0x16, 0x01, 0x80, 0x5b, 0x1a, 0xc9, 0x52, 0xac, 0x61, 0x64, 0xb8, 0x58, 0x17, 0x1f, 0xb1, 0x8b, - 0x35, 0x9c, 0x98, 0x8b, 0xf5, 0xc0, 0x91, 0x5c, 0xac, 0x47, 0x8e, 0xec, 0x62, 0x3d, 0xd8, 0x97, - 0x8b, 0x35, 0x86, 0x33, 0x92, 0xf7, 0xa4, 0xff, 0x57, 0xdd, 0x26, 0x11, 0x0f, 0x0e, 0x1e, 0xb6, - 0x60, 0xee, 0xc1, 0xc1, 0xfc, 0x19, 0x9c, 0x89, 0x81, 0x73, 0x6a, 0xa2, 0x4f, 0xc0, 0xac, 0xd3, - 0x6c, 0xfa, 0xf7, 0xd4, 0xa4, 0xae, 0x84, 0x75, 0xa7, 0xc9, 0x95, 0x10, 0xc3, 0x8c, 0xea, 0x13, - 0x0f, 0x0e, 0xe6, 0x67, 0x17, 0x73, 0x70, 0x70, 0x6e, 0x6d, 0xf4, 0x51, 0x28, 0xb5, 0x03, 0xbf, - 0xbe, 0xa6, 0xb9, 0x26, 0x9e, 0xa7, 0x03, 0x58, 0x95, 0x85, 0x87, 0x07, 0xf3, 0xe3, 0xea, 0x0f, - 0xbb, 0xf0, 0xe3, 0x0a, 0x19, 0x3e, 0xd3, 0xa3, 0xc7, 0xea, 0x33, 0xbd, 0x0b, 0x33, 0x35, 0x12, - 0xb8, 0x2c, 0x9d, 0x7a, 0x23, 0x3e, 0x9f, 0x36, 0xa0, 0x14, 0x24, 0x4e, 0xe4, 0xbe, 0x02, 0x3b, - 0x6a, 0xd9, 0x14, 0xe4, 0x09, 0x1c, 0x13, 0xb2, 0xff, 0xa7, 0x05, 0xc3, 0xc2, 0xcb, 0xe7, 0x04, - 0xb8, 0xc6, 0x45, 0x43, 0x93, 0x30, 0x9f, 0x3d, 0x60, 0xac, 0x33, 0xb9, 0x3a, 0x84, 0x4a, 0x42, - 0x87, 0xf0, 0x64, 0x37, 0x22, 0xdd, 0xb5, 0x07, 0x7f, 0xa5, 0x48, 0xb9, 0x77, 0xc3, 0xdf, 0xf4, - 0xd1, 0x0f, 0xc1, 0x3a, 0x0c, 0x87, 0xc2, 0xdf, 0xb1, 0x90, 0x6f, 0xa0, 0x9f, 0x9c, 0xc4, 0xd8, - 0x8e, 0x4d, 0x78, 0x38, 0x4a, 0x22, 0x99, 0x8e, 0x94, 0xc5, 0x47, 0xe8, 0x48, 0xd9, 0xcb, 0x23, - 0x77, 0xe0, 0x38, 0x3c, 0x72, 0xed, 0xaf, 0xb2, 0x9b, 0x53, 0x2f, 0x3f, 0x01, 0xa6, 0xea, 0x9a, - 0x79, 0xc7, 0xda, 0x5d, 0x56, 0x96, 0xe8, 0x54, 0x0e, 0x73, 0xf5, 0x0b, 0x16, 0x9c, 0xcb, 0xf8, - 0x2a, 0x8d, 0xd3, 0x7a, 0x16, 0x46, 0x9c, 0x4e, 0xc3, 0x55, 0x7b, 0x59, 0xd3, 0x27, 0x2e, 0x8a, - 0x72, 0xac, 0x30, 0xd0, 0x32, 0x4c, 0x93, 0xfb, 0x6d, 0x97, 0xab, 0x52, 0x75, 0xab, 0xd6, 0x22, - 0x77, 0x0d, 0x5b, 0x49, 0x02, 0x71, 0x1a, 0x5f, 0x45, 0x41, 0x29, 0xe6, 0x46, 0x41, 0xf9, 0xdb, - 0x16, 0x8c, 0x2a, 0x8f, 0xbf, 0x47, 0x3e, 0xda, 0x1f, 0x37, 0x47, 0xfb, 0xf1, 0x2e, 0xa3, 0x9d, - 0x33, 0xcc, 0xbf, 0x5d, 0x50, 0xfd, 0xad, 0xfa, 0x41, 0xd4, 0x07, 0x07, 0xf7, 0xf0, 0x76, 0xf8, - 0x57, 0x61, 0xd4, 0x69, 0xb7, 0x25, 0x40, 0xda, 0xa0, 0xb1, 0x30, 0xbd, 0x71, 0x31, 0xd6, 0x71, - 0x94, 0x5b, 0x40, 0x31, 0xd7, 0x2d, 0xa0, 0x01, 0x10, 0x39, 0xc1, 0x36, 0x89, 0x68, 0x99, 0x88, - 0x58, 0x96, 0x7f, 0xde, 0x74, 0x22, 0xb7, 0xb9, 0xe0, 0x7a, 0x51, 0x18, 0x05, 0x0b, 0x15, 0x2f, - 0xba, 0x15, 0xf0, 0x27, 0xa4, 0x16, 0x12, 0x48, 0xd1, 0xc2, 0x1a, 0x5d, 0xe9, 0xdd, 0xce, 0xda, - 0x18, 0x34, 0x8d, 0x19, 0xd6, 0x45, 0x39, 0x56, 0x18, 0xf6, 0x47, 0xd8, 0xed, 0xc3, 0xc6, 0xf4, - 0x68, 0x31, 0x74, 0xfe, 0xee, 0x98, 0x9a, 0x0d, 0xa6, 0xc9, 0x2c, 0xeb, 0x91, 0x7a, 0xba, 0x1f, - 0xf6, 0xb4, 0x61, 0xdd, 0x49, 0x2d, 0x0e, 0xe7, 0x83, 0xbe, 0x23, 0x65, 0xa0, 0xf2, 0x5c, 0x8f, - 0x5b, 0xe3, 0x08, 0x26, 0x29, 0x2c, 0x67, 0x07, 0xcb, 0x68, 0x50, 0xa9, 0x8a, 0x7d, 0xa1, 0xe5, - 0xec, 0x10, 0x00, 0x1c, 0xe3, 0x50, 0x66, 0x4a, 0xfd, 0x09, 0x67, 0x51, 0x1c, 0xbb, 0x52, 0x61, - 0x87, 0x58, 0xc3, 0x40, 0x57, 0x84, 0x40, 0x81, 0xeb, 0x05, 0x1e, 0x4f, 0x08, 0x14, 0xe4, 0x70, - 0x69, 0x52, 0xa0, 0xab, 0x30, 0xaa, 0xd2, 0x03, 0x57, 0x79, 0xd6, 0x59, 0xb1, 0xcc, 0x56, 0xe2, - 0x62, 0xac, 0xe3, 0xa0, 0x0d, 0x98, 0x0c, 0xb9, 0x9c, 0x4d, 0x05, 0x14, 0xe6, 0xf2, 0xca, 0x0f, - 0x4a, 0x2b, 0xa0, 0x9a, 0x09, 0x3e, 0x64, 0x45, 0xfc, 0x74, 0x92, 0x1e, 0xe8, 0x49, 0x12, 0xe8, - 0x35, 0x98, 0x68, 0xfa, 0x4e, 0x63, 0xc9, 0x69, 0x3a, 0x5e, 0x9d, 0x8d, 0xcf, 0x88, 0x99, 0x65, - 0xf2, 0xa6, 0x01, 0xc5, 0x09, 0x6c, 0xca, 0xbc, 0xe9, 0x25, 0x22, 0x08, 0xb6, 0xe3, 0x6d, 0x93, - 0x50, 0x24, 0x7b, 0x65, 0xcc, 0xdb, 0xcd, 0x1c, 0x1c, 0x9c, 0x5b, 0x1b, 0xbd, 0x0c, 0x63, 0xf2, - 0xf3, 0xb5, 0x80, 0x0d, 0xb1, 0x87, 0x85, 0x06, 0xc3, 0x06, 0x26, 0xba, 0x07, 0xa7, 0xe5, 0xff, - 0x8d, 0xc0, 0xd9, 0xda, 0x72, 0xeb, 0xc2, 0x8b, 0x99, 0xbb, 0x62, 0x2e, 0x4a, 0x7f, 0xc1, 0x95, - 0x2c, 0xa4, 0xc3, 0x83, 0xf9, 0x0b, 0x62, 0xd4, 0x32, 0xe1, 0x6c, 0x12, 0xb3, 0xe9, 0xa3, 0x35, - 0x98, 0xd9, 0x21, 0x4e, 0x33, 0xda, 0x59, 0xde, 0x21, 0xf5, 0x5d, 0xb9, 0xe9, 0x58, 0x18, 0x08, - 0xcd, 0x2f, 0xe1, 0x7a, 0x1a, 0x05, 0x67, 0xd5, 0x43, 0x6f, 0xc2, 0x6c, 0xbb, 0xb3, 0xd9, 0x74, - 0xc3, 0x9d, 0x75, 0x3f, 0x62, 0xa6, 0x40, 0x2a, 0xdb, 0xb0, 0x88, 0x17, 0xa1, 0x02, 0x6d, 0x54, - 0x73, 0xf0, 0x70, 0x2e, 0x05, 0xf4, 0x36, 0x9c, 0x4e, 0x2c, 0x06, 0xe1, 0x31, 0x3f, 0x91, 0x9f, - 0x52, 0xa0, 0x96, 0x55, 0x41, 0x04, 0x9f, 0xc8, 0x02, 0xe1, 0xec, 0x26, 0xd0, 0x2b, 0x00, 0x6e, - 0x7b, 0xd5, 0x69, 0xb9, 0x4d, 0xfa, 0x5c, 0x9c, 0x61, 0xeb, 0x84, 0x3e, 0x1d, 0xa0, 0x52, 0x95, - 0xa5, 0xf4, 0x7c, 0x16, 0xff, 0xf6, 0xb1, 0x86, 0x8d, 0xaa, 0x30, 0x21, 0xfe, 0xed, 0x8b, 0x69, - 0x9d, 0x56, 0xce, 0xe9, 0x13, 0xb2, 0x86, 0x9a, 0x4b, 0x64, 0x96, 0xb0, 0xd9, 0x4b, 0xd4, 0x47, - 0xdb, 0x70, 0x4e, 0x24, 0xa6, 0x26, 0xfa, 0x3a, 0x95, 0xf3, 0x10, 0xb2, 0x58, 0xfe, 0x23, 0xdc, - 0xed, 0x61, 0xb1, 0x1b, 0x22, 0xee, 0x4e, 0x87, 0xde, 0xef, 0xfa, 0x72, 0xe7, 0xee, 0xa0, 0xa7, - 0xb9, 0x79, 0x12, 0xbd, 0xdf, 0x6f, 0x26, 0x81, 0x38, 0x8d, 0x8f, 0x42, 0x38, 0xed, 0x7a, 0x59, - 0xab, 0xfb, 0x0c, 0x23, 0xf4, 0x31, 0xee, 0x09, 0xdb, 0x7d, 0x65, 0x67, 0xc2, 0xf9, 0xca, 0xce, - 0xa4, 0xfd, 0xce, 0xac, 0xf0, 0x7e, 0xc7, 0xa2, 0xb5, 0x35, 0x4e, 0x1d, 0x7d, 0x16, 0xc6, 0xf4, - 0x0f, 0x13, 0x5c, 0xc7, 0xa5, 0x6c, 0x46, 0x56, 0x3b, 0x1f, 0x38, 0x9f, 0xaf, 0xce, 0x00, 0x1d, - 0x86, 0x0d, 0x8a, 0xa8, 0x9e, 0xe1, 0x33, 0x7e, 0xa5, 0x3f, 0xae, 0xa6, 0x7f, 0x23, 0x34, 0x02, - 0xd9, 0xcb, 0x1e, 0xdd, 0x84, 0x91, 0x7a, 0xd3, 0x25, 0x5e, 0x54, 0xa9, 0x76, 0x8b, 0xf2, 0xb6, - 0x2c, 0x70, 0xc4, 0x3e, 0x12, 0xa1, 0xf9, 0x79, 0x19, 0x56, 0x14, 0xec, 0x5f, 0x2f, 0xc0, 0x7c, - 0x8f, 0x3c, 0x0f, 0x09, 0x95, 0x94, 0xd5, 0x97, 0x4a, 0x6a, 0x51, 0xa6, 0xd4, 0x5e, 0x4f, 0x48, - 0xbb, 0x12, 0xe9, 0xb2, 0x63, 0x99, 0x57, 0x12, 0xbf, 0x6f, 0x17, 0x01, 0x5d, 0xab, 0x35, 0xd0, - 0xd3, 0xc9, 0xc5, 0xd0, 0x66, 0x0f, 0xf6, 0xff, 0x04, 0xce, 0xd5, 0x4c, 0xda, 0x5f, 0x2d, 0xc0, - 0x69, 0x35, 0x84, 0xdf, 0xba, 0x03, 0x77, 0x3b, 0x3d, 0x70, 0xc7, 0xa0, 0xd7, 0xb5, 0x6f, 0xc1, - 0x10, 0x0f, 0x5b, 0xd7, 0x07, 0xeb, 0x7d, 0xd1, 0x8c, 0xf0, 0xaa, 0xb8, 0x3d, 0x23, 0xca, 0xeb, - 0xf7, 0x5b, 0x30, 0xb9, 0xb1, 0x5c, 0xad, 0xf9, 0xf5, 0x5d, 0x12, 0x2d, 0xf2, 0xa7, 0x12, 0xd6, - 0xbc, 0x6b, 0x1f, 0x86, 0x3d, 0xce, 0x62, 0xbc, 0x2f, 0xc0, 0xc0, 0x8e, 0x1f, 0x46, 0x49, 0xa3, - 0x8f, 0xeb, 0x7e, 0x18, 0x61, 0x06, 0xb1, 0x7f, 0xcf, 0x82, 0xc1, 0x0d, 0xc7, 0xf5, 0x22, 0xa9, - 0x20, 0xb0, 0x72, 0x14, 0x04, 0xfd, 0x7c, 0x17, 0x7a, 0x09, 0x86, 0xc8, 0xd6, 0x16, 0xa9, 0x47, - 0x62, 0x56, 0x65, 0x68, 0x82, 0xa1, 0x15, 0x56, 0x4a, 0x79, 0x41, 0xd6, 0x18, 0xff, 0x8b, 0x05, - 0x32, 0xba, 0x0b, 0xa5, 0xc8, 0x6d, 0x91, 0xc5, 0x46, 0x43, 0xa8, 0xcd, 0x1f, 0x22, 0xbc, 0xc2, - 0x86, 0x24, 0x80, 0x63, 0x5a, 0xf6, 0x97, 0x0a, 0x00, 0x71, 0xbc, 0x9f, 0x5e, 0x9f, 0xb8, 0x94, - 0x52, 0xa8, 0x5e, 0xca, 0x50, 0xa8, 0xa2, 0x98, 0x60, 0x86, 0x36, 0x55, 0x0d, 0x53, 0xb1, 0xaf, - 0x61, 0x1a, 0x38, 0xca, 0x30, 0x2d, 0xc3, 0x74, 0x1c, 0xaf, 0xc8, 0x0c, 0xd7, 0xc6, 0xae, 0xcf, - 0x8d, 0x24, 0x10, 0xa7, 0xf1, 0x6d, 0x02, 0x17, 0x54, 0xd8, 0x16, 0x71, 0xa3, 0x31, 0xab, 0x6c, - 0x5d, 0x41, 0xdd, 0x63, 0x9c, 0x62, 0x8d, 0x71, 0x21, 0x57, 0x63, 0xfc, 0x53, 0x16, 0x9c, 0x4a, - 0xb6, 0xc3, 0xfc, 0x71, 0xbf, 0x68, 0xc1, 0x69, 0xa6, 0x37, 0x67, 0xad, 0xa6, 0xb5, 0xf4, 0x2f, - 0x76, 0x0d, 0x45, 0x93, 0xd3, 0xe3, 0x38, 0x06, 0xc6, 0x5a, 0x16, 0x69, 0x9c, 0xdd, 0xa2, 0xfd, - 0xef, 0x0b, 0x30, 0x9b, 0x17, 0xc3, 0x86, 0x39, 0x6d, 0x38, 0xf7, 0x6b, 0xbb, 0xe4, 0x9e, 0x30, - 0x8d, 0x8f, 0x9d, 0x36, 0x78, 0x31, 0x96, 0xf0, 0x64, 0xe8, 0xfe, 0x42, 0x9f, 0xa1, 0xfb, 0x77, - 0x60, 0xfa, 0xde, 0x0e, 0xf1, 0x6e, 0x7b, 0xa1, 0x13, 0xb9, 0xe1, 0x96, 0xcb, 0x74, 0xcc, 0x7c, - 0xdd, 0xbc, 0x22, 0x0d, 0xd8, 0xef, 0x26, 0x11, 0x0e, 0x0f, 0xe6, 0xcf, 0x19, 0x05, 0x71, 0x97, - 0xf9, 0x41, 0x82, 0xd3, 0x44, 0xd3, 0x99, 0x0f, 0x06, 0x1e, 0x61, 0xe6, 0x03, 0xfb, 0x8b, 0x16, - 0x9c, 0xcd, 0x4d, 0xba, 0x8a, 0x2e, 0xc3, 0x88, 0xd3, 0x76, 0xb9, 0x98, 0x5e, 0x1c, 0xa3, 0x4c, - 0x1c, 0x54, 0xad, 0x70, 0x21, 0xbd, 0x82, 0xaa, 0x74, 0xf3, 0x85, 0xdc, 0x74, 0xf3, 0x3d, 0xb3, - 0xc7, 0xdb, 0xdf, 0x67, 0x81, 0x70, 0x38, 0xed, 0xe3, 0xec, 0xfe, 0x14, 0x8c, 0xed, 0xa5, 0xb3, - 0x23, 0x5d, 0xc8, 0xf7, 0xc0, 0x15, 0x39, 0x91, 0x14, 0x43, 0x66, 0x64, 0x42, 0x32, 0x68, 0xd9, - 0x0d, 0x10, 0xd0, 0x32, 0x61, 0x42, 0xe8, 0xde, 0xbd, 0x79, 0x1e, 0xa0, 0xc1, 0x70, 0xb5, 0x9c, - 0xfd, 0xea, 0x66, 0x2e, 0x2b, 0x08, 0xd6, 0xb0, 0xec, 0x7f, 0x53, 0x80, 0x51, 0x99, 0x8d, 0xa7, - 0xe3, 0xf5, 0x23, 0x2a, 0x3a, 0x52, 0x7a, 0x4e, 0x74, 0x05, 0x4a, 0x4c, 0x96, 0x59, 0x8d, 0x25, - 0x6c, 0x4a, 0x92, 0xb0, 0x26, 0x01, 0x38, 0xc6, 0xa1, 0xbb, 0x28, 0xec, 0x6c, 0x32, 0xf4, 0x84, - 0x7b, 0x64, 0x8d, 0x17, 0x63, 0x09, 0x47, 0x9f, 0x80, 0x29, 0x5e, 0x2f, 0xf0, 0xdb, 0xce, 0x36, - 0xd7, 0x7f, 0x0c, 0xaa, 0x00, 0x0a, 0x53, 0x6b, 0x09, 0xd8, 0xe1, 0xc1, 0xfc, 0xa9, 0x64, 0x19, - 0x53, 0xec, 0xa5, 0xa8, 0x30, 0x33, 0x27, 0xde, 0x08, 0xdd, 0xfd, 0x29, 0xeb, 0xa8, 0x18, 0x84, - 0x75, 0x3c, 0xfb, 0xb3, 0x80, 0xd2, 0x79, 0x89, 0xd0, 0xeb, 0xdc, 0xb6, 0xd5, 0x0d, 0x48, 0xa3, - 0x9b, 0xa2, 0x4f, 0x0f, 0x13, 0x20, 0x3d, 0x9b, 0x78, 0x2d, 0xac, 0xea, 0xdb, 0xff, 0x6f, 0x11, - 0xa6, 0x92, 0xbe, 0xdc, 0xe8, 0x3a, 0x0c, 0x71, 0xd6, 0x43, 0x90, 0xef, 0x62, 0x47, 0xa2, 0x79, - 0x80, 0xb3, 0x43, 0x58, 0x70, 0x2f, 0xa2, 0x3e, 0x7a, 0x13, 0x46, 0x1b, 0xfe, 0x3d, 0xef, 0x9e, - 0x13, 0x34, 0x16, 0xab, 0x15, 0xb1, 0x9c, 0x33, 0x1f, 0xb6, 0xe5, 0x18, 0x4d, 0xf7, 0x2a, 0x67, - 0x3a, 0xd3, 0x18, 0x84, 0x75, 0x72, 0x68, 0x83, 0x05, 0x33, 0xdf, 0x72, 0xb7, 0xd7, 0x9c, 0x76, - 0x37, 0x47, 0x87, 0x65, 0x89, 0xa4, 0x51, 0x1e, 0x17, 0x11, 0xcf, 0x39, 0x00, 0xc7, 0x84, 0xd0, - 0xe7, 0x61, 0x26, 0xcc, 0x11, 0xb7, 0xe7, 0xa5, 0xa9, 0xeb, 0x26, 0x81, 0x5e, 0x7a, 0xec, 0xc1, - 0xc1, 0xfc, 0x4c, 0x96, 0x60, 0x3e, 0xab, 0x19, 0xfb, 0xc7, 0x4e, 0x81, 0xb1, 0x89, 0x8d, 0xac, - 0xa5, 0xd6, 0x31, 0x65, 0x2d, 0xc5, 0x30, 0x42, 0x5a, 0xed, 0x68, 0xbf, 0xec, 0x06, 0xdd, 0x72, - 0x86, 0xaf, 0x08, 0x9c, 0x34, 0x4d, 0x09, 0xc1, 0x8a, 0x4e, 0x76, 0x6a, 0xd9, 0xe2, 0x37, 0x30, - 0xb5, 0xec, 0xc0, 0x09, 0xa6, 0x96, 0x5d, 0x87, 0xe1, 0x6d, 0x37, 0xc2, 0xa4, 0xed, 0x0b, 0xa6, - 0x3f, 0x73, 0x1d, 0x5e, 0xe3, 0x28, 0xe9, 0x24, 0x86, 0x02, 0x80, 0x25, 0x11, 0xf4, 0xba, 0xda, - 0x81, 0x43, 0xf9, 0x0f, 0xf3, 0xb4, 0xc1, 0x43, 0xe6, 0x1e, 0x14, 0x09, 0x64, 0x87, 0x1f, 0x36, - 0x81, 0xec, 0xaa, 0x4c, 0xfb, 0x3a, 0x92, 0xef, 0x95, 0xc4, 0xb2, 0xba, 0xf6, 0x48, 0xf6, 0x7a, - 0x47, 0x4f, 0x95, 0x5b, 0xca, 0x3f, 0x09, 0x54, 0x16, 0xdc, 0x3e, 0x13, 0xe4, 0x7e, 0x9f, 0x05, - 0xa7, 0xdb, 0x59, 0x59, 0xa3, 0x85, 0x6d, 0xc0, 0x4b, 0x7d, 0x27, 0xa6, 0x36, 0x1a, 0x64, 0x32, - 0xb5, 0x4c, 0x34, 0x9c, 0xdd, 0x1c, 0x1d, 0xe8, 0x60, 0xb3, 0x21, 0x74, 0xd4, 0x17, 0x73, 0x32, - 0xed, 0x76, 0xc9, 0xaf, 0xbb, 0x91, 0x91, 0xd5, 0xf5, 0xfd, 0x79, 0x59, 0x5d, 0xfb, 0xce, 0xe5, - 0xfa, 0xba, 0xca, 0xb1, 0x3b, 0x9e, 0xbf, 0x94, 0x78, 0x06, 0xdd, 0x9e, 0x99, 0x75, 0x5f, 0x57, - 0x99, 0x75, 0xbb, 0x44, 0xaa, 0xe5, 0x79, 0x73, 0x7b, 0xe6, 0xd3, 0xd5, 0x72, 0xe2, 0x4e, 0x1e, - 0x4f, 0x4e, 0x5c, 0xe3, 0xaa, 0xe1, 0x69, 0x59, 0x9f, 0xe9, 0x71, 0xd5, 0x18, 0x74, 0xbb, 0x5f, - 0x36, 0x3c, 0xff, 0xef, 0xf4, 0x43, 0xe5, 0xff, 0xbd, 0xa3, 0xe7, 0xd3, 0x45, 0x3d, 0x12, 0xc6, - 0x52, 0xa4, 0x3e, 0xb3, 0xe8, 0xde, 0xd1, 0x2f, 0xc0, 0x99, 0x7c, 0xba, 0xea, 0x9e, 0x4b, 0xd3, - 0xcd, 0xbc, 0x02, 0x53, 0xd9, 0x79, 0x4f, 0x9d, 0x4c, 0x76, 0xde, 0xd3, 0xc7, 0x9e, 0x9d, 0xf7, - 0xcc, 0x09, 0x64, 0xe7, 0x7d, 0xec, 0x04, 0xb3, 0xf3, 0xde, 0x61, 0x06, 0x35, 0x3c, 0x6c, 0x8f, - 0x88, 0xac, 0x9b, 0x1d, 0xc5, 0x35, 0x2b, 0xb6, 0x0f, 0xff, 0x38, 0x05, 0xc2, 0x31, 0xa9, 0x8c, - 0xac, 0xbf, 0xb3, 0x8f, 0x20, 0xeb, 0xef, 0x7a, 0x9c, 0xf5, 0xf7, 0x6c, 0xfe, 0x54, 0x67, 0xb8, - 0x60, 0xe4, 0xe4, 0xfa, 0xbd, 0xa3, 0xe7, 0xe8, 0x7d, 0xbc, 0x8b, 0xd6, 0x24, 0x4b, 0xf0, 0xd8, - 0x25, 0x33, 0xef, 0x6b, 0x3c, 0x33, 0xef, 0x13, 0xf9, 0x27, 0x79, 0xf2, 0xba, 0x33, 0xf2, 0xf1, - 0xd2, 0x7e, 0xa9, 0x18, 0x8e, 0x2c, 0x86, 0x70, 0x4e, 0xbf, 0x54, 0x10, 0xc8, 0x74, 0xbf, 0x14, - 0x08, 0xc7, 0xa4, 0xec, 0x1f, 0x28, 0xc0, 0xf9, 0xee, 0xfb, 0x2d, 0x96, 0xa6, 0x56, 0x63, 0x25, - 0x72, 0x42, 0x9a, 0xca, 0xdf, 0x6c, 0x31, 0x56, 0xdf, 0x21, 0xe9, 0xae, 0xc1, 0xb4, 0xf2, 0xdd, - 0x68, 0xba, 0xf5, 0xfd, 0xf5, 0xf8, 0xe5, 0xab, 0xfc, 0xdd, 0x6b, 0x49, 0x04, 0x9c, 0xae, 0x83, - 0x16, 0x61, 0xd2, 0x28, 0xac, 0x94, 0xc5, 0xdb, 0x4c, 0x89, 0x6f, 0x6b, 0x26, 0x18, 0x27, 0xf1, - 0xed, 0x2f, 0x5b, 0xf0, 0x58, 0x4e, 0x5a, 0xbb, 0xbe, 0x23, 0xae, 0x6d, 0xc1, 0x64, 0xdb, 0xac, - 0xda, 0x23, 0x48, 0xa4, 0x91, 0x3c, 0x4f, 0xf5, 0x35, 0x01, 0xc0, 0x49, 0xa2, 0xf6, 0xcf, 0x14, - 0xe0, 0x5c, 0x57, 0x63, 0x44, 0x84, 0xe1, 0xcc, 0x76, 0x2b, 0x74, 0x96, 0x03, 0xd2, 0x20, 0x5e, - 0xe4, 0x3a, 0xcd, 0x5a, 0x9b, 0xd4, 0x35, 0x79, 0x38, 0xb3, 0xea, 0xbb, 0xb6, 0x56, 0x5b, 0x4c, - 0x63, 0xe0, 0x9c, 0x9a, 0x68, 0x15, 0x50, 0x1a, 0x22, 0x66, 0x98, 0x45, 0xa3, 0x4e, 0xd3, 0xc3, - 0x19, 0x35, 0xd0, 0x47, 0x60, 0x5c, 0x19, 0x39, 0x6a, 0x33, 0xce, 0x0e, 0x76, 0xac, 0x03, 0xb0, - 0x89, 0x87, 0xae, 0xf2, 0x70, 0xe6, 0x22, 0xf0, 0xbd, 0x10, 0x9e, 0x4f, 0xca, 0x58, 0xe5, 0xa2, - 0x18, 0xeb, 0x38, 0x4b, 0x97, 0x7f, 0xe3, 0x0f, 0xce, 0xbf, 0xef, 0xb7, 0xfe, 0xe0, 0xfc, 0xfb, - 0x7e, 0xf7, 0x0f, 0xce, 0xbf, 0xef, 0xbb, 0x1e, 0x9c, 0xb7, 0x7e, 0xe3, 0xc1, 0x79, 0xeb, 0xb7, - 0x1e, 0x9c, 0xb7, 0x7e, 0xf7, 0xc1, 0x79, 0xeb, 0xf7, 0x1f, 0x9c, 0xb7, 0xbe, 0xf4, 0x87, 0xe7, - 0xdf, 0xf7, 0xa9, 0xc2, 0xde, 0xd5, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0x11, 0xbd, 0x2b, 0x2b, - 0x30, 0x04, 0x01, 0x00, + // 14240 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x79, 0x70, 0x24, 0xd7, + 0x79, 0x18, 0xae, 0x9e, 0xc1, 0x35, 0x1f, 0xee, 0xb7, 0x07, 0xb1, 0x20, 0x77, 0xb1, 0x6c, 0x4a, + 0xcb, 0xa5, 0x48, 0x62, 0xb5, 0x3c, 0x24, 0x9a, 0x94, 0x68, 0x01, 0x18, 0x60, 0x17, 0xdc, 0x05, + 0x76, 0xf8, 0x06, 0xbb, 0x2b, 0xc9, 0x94, 0x4a, 0x8d, 0x99, 0x07, 0xa0, 0x85, 0x99, 0xee, 0x61, + 0x77, 0x0f, 0x76, 0xc1, 0x9f, 0x5c, 0x3f, 0x47, 0x3e, 0xe5, 0x23, 0xa5, 0x4a, 0x39, 0x47, 0xc9, + 0x2e, 0x57, 0xca, 0x71, 0x62, 0x2b, 0xca, 0xe5, 0xc8, 0xb1, 0x1d, 0xcb, 0x89, 0x9d, 0xdb, 0xc9, + 0x1f, 0xb6, 0xe3, 0x4a, 0x2c, 0x57, 0xb9, 0x82, 0xd8, 0xeb, 0x54, 0xb9, 0x54, 0x95, 0xd8, 0x4e, + 0x9c, 0xfc, 0x91, 0x8d, 0x2b, 0x4e, 0xbd, 0xb3, 0xdf, 0xeb, 0x6b, 0x06, 0x4b, 0x2c, 0x44, 0xa9, + 0xf8, 0xdf, 0xcc, 0xfb, 0xbe, 0xf7, 0xbd, 0xd7, 0xef, 0xfc, 0xde, 0x77, 0xc2, 0x2b, 0xbb, 0x2f, + 0x85, 0xf3, 0xae, 0x7f, 0x69, 0xb7, 0xbb, 0x49, 0x02, 0x8f, 0x44, 0x24, 0xbc, 0xb4, 0x47, 0xbc, + 0xa6, 0x1f, 0x5c, 0x12, 0x00, 0xa7, 0xe3, 0x5e, 0x6a, 0xf8, 0x01, 0xb9, 0xb4, 0x77, 0xf9, 0xd2, + 0x36, 0xf1, 0x48, 0xe0, 0x44, 0xa4, 0x39, 0xdf, 0x09, 0xfc, 0xc8, 0x47, 0x88, 0xe3, 0xcc, 0x3b, + 0x1d, 0x77, 0x9e, 0xe2, 0xcc, 0xef, 0x5d, 0x9e, 0x7d, 0x76, 0xdb, 0x8d, 0x76, 0xba, 0x9b, 0xf3, + 0x0d, 0xbf, 0x7d, 0x69, 0xdb, 0xdf, 0xf6, 0x2f, 0x31, 0xd4, 0xcd, 0xee, 0x16, 0xfb, 0xc7, 0xfe, + 0xb0, 0x5f, 0x9c, 0xc4, 0xec, 0x0b, 0x71, 0x33, 0x6d, 0xa7, 0xb1, 0xe3, 0x7a, 0x24, 0xd8, 0xbf, + 0xd4, 0xd9, 0xdd, 0x66, 0xed, 0x06, 0x24, 0xf4, 0xbb, 0x41, 0x83, 0x24, 0x1b, 0x2e, 0xac, 0x15, + 0x5e, 0x6a, 0x93, 0xc8, 0xc9, 0xe8, 0xee, 0xec, 0xa5, 0xbc, 0x5a, 0x41, 0xd7, 0x8b, 0xdc, 0x76, + 0xba, 0x99, 0x0f, 0xf6, 0xaa, 0x10, 0x36, 0x76, 0x48, 0xdb, 0x49, 0xd5, 0x7b, 0x3e, 0xaf, 0x5e, + 0x37, 0x72, 0x5b, 0x97, 0x5c, 0x2f, 0x0a, 0xa3, 0x20, 0x59, 0xc9, 0xfe, 0x9a, 0x05, 0xe7, 0x17, + 0x6e, 0xd7, 0x97, 0x5b, 0x4e, 0x18, 0xb9, 0x8d, 0xc5, 0x96, 0xdf, 0xd8, 0xad, 0x47, 0x7e, 0x40, + 0x6e, 0xf9, 0xad, 0x6e, 0x9b, 0xd4, 0xd9, 0x40, 0xa0, 0x67, 0x60, 0x64, 0x8f, 0xfd, 0x5f, 0xad, + 0xce, 0x58, 0xe7, 0xad, 0x8b, 0x95, 0xc5, 0xa9, 0x5f, 0x3b, 0x98, 0x7b, 0xcf, 0xbd, 0x83, 0xb9, + 0x91, 0x5b, 0xa2, 0x1c, 0x2b, 0x0c, 0x74, 0x01, 0x86, 0xb6, 0xc2, 0x8d, 0xfd, 0x0e, 0x99, 0x29, + 0x31, 0xdc, 0x09, 0x81, 0x3b, 0xb4, 0x52, 0xa7, 0xa5, 0x58, 0x40, 0xd1, 0x25, 0xa8, 0x74, 0x9c, + 0x20, 0x72, 0x23, 0xd7, 0xf7, 0x66, 0xca, 0xe7, 0xad, 0x8b, 0x83, 0x8b, 0xd3, 0x02, 0xb5, 0x52, + 0x93, 0x00, 0x1c, 0xe3, 0xd0, 0x6e, 0x04, 0xc4, 0x69, 0xde, 0xf0, 0x5a, 0xfb, 0x33, 0x03, 0xe7, + 0xad, 0x8b, 0x23, 0x71, 0x37, 0xb0, 0x28, 0xc7, 0x0a, 0xc3, 0xfe, 0x62, 0x09, 0x46, 0x16, 0xb6, + 0xb6, 0x5c, 0xcf, 0x8d, 0xf6, 0xd1, 0x2d, 0x18, 0xf3, 0xfc, 0x26, 0x91, 0xff, 0xd9, 0x57, 0x8c, + 0x3e, 0x77, 0x7e, 0x3e, 0xbd, 0x94, 0xe6, 0xd7, 0x35, 0xbc, 0xc5, 0xa9, 0x7b, 0x07, 0x73, 0x63, + 0x7a, 0x09, 0x36, 0xe8, 0x20, 0x0c, 0xa3, 0x1d, 0xbf, 0xa9, 0xc8, 0x96, 0x18, 0xd9, 0xb9, 0x2c, + 0xb2, 0xb5, 0x18, 0x6d, 0x71, 0xf2, 0xde, 0xc1, 0xdc, 0xa8, 0x56, 0x80, 0x75, 0x22, 0x68, 0x13, + 0x26, 0xe9, 0x5f, 0x2f, 0x72, 0x15, 0xdd, 0x32, 0xa3, 0xfb, 0x44, 0x1e, 0x5d, 0x0d, 0x75, 0xf1, + 0xc4, 0xbd, 0x83, 0xb9, 0xc9, 0x44, 0x21, 0x4e, 0x12, 0xb4, 0xdf, 0x82, 0x89, 0x85, 0x28, 0x72, + 0x1a, 0x3b, 0xa4, 0xc9, 0x67, 0x10, 0xbd, 0x00, 0x03, 0x9e, 0xd3, 0x26, 0x62, 0x7e, 0xcf, 0x8b, + 0x81, 0x1d, 0x58, 0x77, 0xda, 0xe4, 0xfe, 0xc1, 0xdc, 0xd4, 0x4d, 0xcf, 0x7d, 0xb3, 0x2b, 0x56, + 0x05, 0x2d, 0xc3, 0x0c, 0x1b, 0x3d, 0x07, 0xd0, 0x24, 0x7b, 0x6e, 0x83, 0xd4, 0x9c, 0x68, 0x47, + 0xcc, 0x37, 0x12, 0x75, 0xa1, 0xaa, 0x20, 0x58, 0xc3, 0xb2, 0xef, 0x42, 0x65, 0x61, 0xcf, 0x77, + 0x9b, 0x35, 0xbf, 0x19, 0xa2, 0x5d, 0x98, 0xec, 0x04, 0x64, 0x8b, 0x04, 0xaa, 0x68, 0xc6, 0x3a, + 0x5f, 0xbe, 0x38, 0xfa, 0xdc, 0xc5, 0xcc, 0x8f, 0x35, 0x51, 0x97, 0xbd, 0x28, 0xd8, 0x5f, 0x7c, + 0x44, 0xb4, 0x37, 0x99, 0x80, 0xe2, 0x24, 0x65, 0xfb, 0x5f, 0x96, 0xe0, 0xd4, 0xc2, 0x5b, 0xdd, + 0x80, 0x54, 0xdd, 0x70, 0x37, 0xb9, 0xc2, 0x9b, 0x6e, 0xb8, 0xbb, 0x1e, 0x8f, 0x80, 0x5a, 0x5a, + 0x55, 0x51, 0x8e, 0x15, 0x06, 0x7a, 0x16, 0x86, 0xe9, 0xef, 0x9b, 0x78, 0x55, 0x7c, 0xf2, 0x09, + 0x81, 0x3c, 0x5a, 0x75, 0x22, 0xa7, 0xca, 0x41, 0x58, 0xe2, 0xa0, 0x35, 0x18, 0x6d, 0xb0, 0x0d, + 0xb9, 0xbd, 0xe6, 0x37, 0x09, 0x9b, 0xcc, 0xca, 0xe2, 0xd3, 0x14, 0x7d, 0x29, 0x2e, 0xbe, 0x7f, + 0x30, 0x37, 0xc3, 0xfb, 0x26, 0x48, 0x68, 0x30, 0xac, 0xd7, 0x47, 0xb6, 0xda, 0x5f, 0x03, 0x8c, + 0x12, 0x64, 0xec, 0xad, 0x8b, 0xda, 0x56, 0x19, 0x64, 0x5b, 0x65, 0x2c, 0x7b, 0x9b, 0xa0, 0xcb, + 0x30, 0xb0, 0xeb, 0x7a, 0xcd, 0x99, 0x21, 0x46, 0xeb, 0x2c, 0x9d, 0xf3, 0x6b, 0xae, 0xd7, 0xbc, + 0x7f, 0x30, 0x37, 0x6d, 0x74, 0x87, 0x16, 0x62, 0x86, 0x6a, 0xff, 0xa9, 0x05, 0x73, 0x0c, 0xb6, + 0xe2, 0xb6, 0x48, 0x8d, 0x04, 0xa1, 0x1b, 0x46, 0xc4, 0x8b, 0x8c, 0x01, 0x7d, 0x0e, 0x20, 0x24, + 0x8d, 0x80, 0x44, 0xda, 0x90, 0xaa, 0x85, 0x51, 0x57, 0x10, 0xac, 0x61, 0xd1, 0x03, 0x21, 0xdc, + 0x71, 0x02, 0xb6, 0xbe, 0xc4, 0xc0, 0xaa, 0x03, 0xa1, 0x2e, 0x01, 0x38, 0xc6, 0x31, 0x0e, 0x84, + 0x72, 0xaf, 0x03, 0x01, 0x7d, 0x04, 0x26, 0xe3, 0xc6, 0xc2, 0x8e, 0xd3, 0x90, 0x03, 0xc8, 0xb6, + 0x4c, 0xdd, 0x04, 0xe1, 0x24, 0xae, 0xfd, 0xb7, 0x2d, 0xb1, 0x78, 0xe8, 0x57, 0xbf, 0xc3, 0xbf, + 0xd5, 0xfe, 0x45, 0x0b, 0x86, 0x17, 0x5d, 0xaf, 0xe9, 0x7a, 0xdb, 0xe8, 0xd3, 0x30, 0x42, 0xef, + 0xa6, 0xa6, 0x13, 0x39, 0xe2, 0xdc, 0xfb, 0x80, 0xb6, 0xb7, 0xd4, 0x55, 0x31, 0xdf, 0xd9, 0xdd, + 0xa6, 0x05, 0xe1, 0x3c, 0xc5, 0xa6, 0xbb, 0xed, 0xc6, 0xe6, 0x67, 0x48, 0x23, 0x5a, 0x23, 0x91, + 0x13, 0x7f, 0x4e, 0x5c, 0x86, 0x15, 0x55, 0x74, 0x0d, 0x86, 0x22, 0x27, 0xd8, 0x26, 0x91, 0x38, + 0x00, 0x33, 0x0f, 0x2a, 0x5e, 0x13, 0xd3, 0x1d, 0x49, 0xbc, 0x06, 0x89, 0xaf, 0x85, 0x0d, 0x56, + 0x15, 0x0b, 0x12, 0xf6, 0x8f, 0x0c, 0xc3, 0x99, 0xa5, 0xfa, 0x6a, 0xce, 0xba, 0xba, 0x00, 0x43, + 0xcd, 0xc0, 0xdd, 0x23, 0x81, 0x18, 0x67, 0x45, 0xa5, 0xca, 0x4a, 0xb1, 0x80, 0xa2, 0x97, 0x60, + 0x8c, 0x5f, 0x48, 0x57, 0x1d, 0xaf, 0xd9, 0x92, 0x43, 0x7c, 0x52, 0x60, 0x8f, 0xdd, 0xd2, 0x60, + 0xd8, 0xc0, 0x3c, 0xe4, 0xa2, 0xba, 0x90, 0xd8, 0x8c, 0x79, 0x97, 0xdd, 0xe7, 0x2d, 0x98, 0xe2, + 0xcd, 0x2c, 0x44, 0x51, 0xe0, 0x6e, 0x76, 0x23, 0x12, 0xce, 0x0c, 0xb2, 0x93, 0x6e, 0x29, 0x6b, + 0xb4, 0x72, 0x47, 0x60, 0xfe, 0x56, 0x82, 0x0a, 0x3f, 0x04, 0x67, 0x44, 0xbb, 0x53, 0x49, 0x30, + 0x4e, 0x35, 0x8b, 0xbe, 0xdb, 0x82, 0xd9, 0x86, 0xef, 0x45, 0x81, 0xdf, 0x6a, 0x91, 0xa0, 0xd6, + 0xdd, 0x6c, 0xb9, 0xe1, 0x0e, 0x5f, 0xa7, 0x98, 0x6c, 0xb1, 0x93, 0x20, 0x67, 0x0e, 0x15, 0x92, + 0x98, 0xc3, 0x73, 0xf7, 0x0e, 0xe6, 0x66, 0x97, 0x72, 0x49, 0xe1, 0x82, 0x66, 0xd0, 0x2e, 0x20, + 0x7a, 0x95, 0xd6, 0x23, 0x67, 0x9b, 0xc4, 0x8d, 0x0f, 0xf7, 0xdf, 0xf8, 0xe9, 0x7b, 0x07, 0x73, + 0x68, 0x3d, 0x45, 0x02, 0x67, 0x90, 0x45, 0x6f, 0xc2, 0x49, 0x5a, 0x9a, 0xfa, 0xd6, 0x91, 0xfe, + 0x9b, 0x9b, 0xb9, 0x77, 0x30, 0x77, 0x72, 0x3d, 0x83, 0x08, 0xce, 0x24, 0x8d, 0xbe, 0xcb, 0x82, + 0x33, 0xf1, 0xe7, 0x2f, 0xdf, 0xed, 0x38, 0x5e, 0x33, 0x6e, 0xb8, 0xd2, 0x7f, 0xc3, 0xf4, 0x4c, + 0x3e, 0xb3, 0x94, 0x47, 0x09, 0xe7, 0x37, 0x32, 0xbb, 0x04, 0xa7, 0x32, 0x57, 0x0b, 0x9a, 0x82, + 0xf2, 0x2e, 0xe1, 0x5c, 0x50, 0x05, 0xd3, 0x9f, 0xe8, 0x24, 0x0c, 0xee, 0x39, 0xad, 0xae, 0xd8, + 0x28, 0x98, 0xff, 0x79, 0xb9, 0xf4, 0x92, 0x65, 0xff, 0xab, 0x32, 0x4c, 0x2e, 0xd5, 0x57, 0x1f, + 0x68, 0x17, 0xea, 0xd7, 0x50, 0xa9, 0xf0, 0x1a, 0x8a, 0x2f, 0xb5, 0x72, 0xee, 0xa5, 0xf6, 0xff, + 0x67, 0x6c, 0xa1, 0x01, 0xb6, 0x85, 0xbe, 0x2d, 0x67, 0x0b, 0x1d, 0xf1, 0xc6, 0xd9, 0xcb, 0x59, + 0x45, 0x83, 0x6c, 0x32, 0x33, 0x39, 0x96, 0xeb, 0x7e, 0xc3, 0x69, 0x25, 0x8f, 0xbe, 0x43, 0x2e, + 0xa5, 0xa3, 0x99, 0xc7, 0x06, 0x8c, 0x2d, 0x39, 0x1d, 0x67, 0xd3, 0x6d, 0xb9, 0x91, 0x4b, 0x42, + 0xf4, 0x24, 0x94, 0x9d, 0x66, 0x93, 0x71, 0x5b, 0x95, 0xc5, 0x53, 0xf7, 0x0e, 0xe6, 0xca, 0x0b, + 0x4d, 0x7a, 0xed, 0x83, 0xc2, 0xda, 0xc7, 0x14, 0x03, 0xbd, 0x1f, 0x06, 0x9a, 0x81, 0xdf, 0x99, + 0x29, 0x31, 0x4c, 0xba, 0xeb, 0x06, 0xaa, 0x81, 0xdf, 0x49, 0xa0, 0x32, 0x1c, 0xfb, 0x57, 0x4b, + 0xf0, 0xd8, 0x12, 0xe9, 0xec, 0xac, 0xd4, 0x73, 0xce, 0xef, 0x8b, 0x30, 0xd2, 0xf6, 0x3d, 0x37, + 0xf2, 0x83, 0x50, 0x34, 0xcd, 0x56, 0xc4, 0x9a, 0x28, 0xc3, 0x0a, 0x8a, 0xce, 0xc3, 0x40, 0x27, + 0x66, 0x2a, 0xc7, 0x24, 0x43, 0xca, 0xd8, 0x49, 0x06, 0xa1, 0x18, 0xdd, 0x90, 0x04, 0x62, 0xc5, + 0x28, 0x8c, 0x9b, 0x21, 0x09, 0x30, 0x83, 0xc4, 0x37, 0x33, 0xbd, 0xb3, 0xc5, 0x09, 0x9d, 0xb8, + 0x99, 0x29, 0x04, 0x6b, 0x58, 0xa8, 0x06, 0x95, 0x30, 0x31, 0xb3, 0x7d, 0x6d, 0xd3, 0x71, 0x76, + 0x75, 0xab, 0x99, 0x8c, 0x89, 0x18, 0x37, 0xca, 0x50, 0xcf, 0xab, 0xfb, 0xab, 0x25, 0x40, 0x7c, + 0x08, 0xbf, 0xc9, 0x06, 0xee, 0x66, 0x7a, 0xe0, 0xfa, 0xdf, 0x12, 0x47, 0x35, 0x7a, 0xff, 0xd3, + 0x82, 0xc7, 0x96, 0x5c, 0xaf, 0x49, 0x82, 0x9c, 0x05, 0xf8, 0x70, 0xde, 0xb2, 0x87, 0x63, 0x1a, + 0x8c, 0x25, 0x36, 0x70, 0x04, 0x4b, 0xcc, 0xfe, 0x63, 0x0b, 0x10, 0xff, 0xec, 0x77, 0xdc, 0xc7, + 0xde, 0x4c, 0x7f, 0xec, 0x11, 0x2c, 0x0b, 0xfb, 0x3a, 0x4c, 0x2c, 0xb5, 0x5c, 0xe2, 0x45, 0xab, + 0xb5, 0x25, 0xdf, 0xdb, 0x72, 0xb7, 0xd1, 0xcb, 0x30, 0x11, 0xb9, 0x6d, 0xe2, 0x77, 0xa3, 0x3a, + 0x69, 0xf8, 0x1e, 0x7b, 0x49, 0x5a, 0x17, 0x07, 0x17, 0xd1, 0xbd, 0x83, 0xb9, 0x89, 0x0d, 0x03, + 0x82, 0x13, 0x98, 0xf6, 0xef, 0xd2, 0xf1, 0xf3, 0xdb, 0x1d, 0xdf, 0x23, 0x5e, 0xb4, 0xe4, 0x7b, + 0x4d, 0x2e, 0x71, 0x78, 0x19, 0x06, 0x22, 0x3a, 0x1e, 0x7c, 0xec, 0x2e, 0xc8, 0x8d, 0x42, 0x47, + 0xe1, 0xfe, 0xc1, 0xdc, 0xe9, 0x74, 0x0d, 0x36, 0x4e, 0xac, 0x0e, 0xfa, 0x36, 0x18, 0x0a, 0x23, + 0x27, 0xea, 0x86, 0x62, 0x34, 0x1f, 0x97, 0xa3, 0x59, 0x67, 0xa5, 0xf7, 0x0f, 0xe6, 0x26, 0x55, + 0x35, 0x5e, 0x84, 0x45, 0x05, 0xf4, 0x14, 0x0c, 0xb7, 0x49, 0x18, 0x3a, 0xdb, 0xf2, 0x36, 0x9c, + 0x14, 0x75, 0x87, 0xd7, 0x78, 0x31, 0x96, 0x70, 0xf4, 0x04, 0x0c, 0x92, 0x20, 0xf0, 0x03, 0xb1, + 0x47, 0xc7, 0x05, 0xe2, 0xe0, 0x32, 0x2d, 0xc4, 0x1c, 0x66, 0xff, 0x86, 0x05, 0x93, 0xaa, 0xaf, + 0xbc, 0xad, 0x63, 0x78, 0x15, 0x7c, 0x02, 0xa0, 0x21, 0x3f, 0x30, 0x64, 0xb7, 0xc7, 0xe8, 0x73, + 0x17, 0x32, 0x2f, 0xea, 0xd4, 0x30, 0xc6, 0x94, 0x55, 0x51, 0x88, 0x35, 0x6a, 0xf6, 0x3f, 0xb1, + 0xe0, 0x44, 0xe2, 0x8b, 0xae, 0xbb, 0x61, 0x84, 0xde, 0x48, 0x7d, 0xd5, 0x7c, 0x7f, 0x5f, 0x45, + 0x6b, 0xb3, 0x6f, 0x52, 0x4b, 0x59, 0x96, 0x68, 0x5f, 0x74, 0x15, 0x06, 0xdd, 0x88, 0xb4, 0xe5, + 0xc7, 0x3c, 0x51, 0xf8, 0x31, 0xbc, 0x57, 0xf1, 0x8c, 0xac, 0xd2, 0x9a, 0x98, 0x13, 0xb0, 0x7f, + 0xb5, 0x0c, 0x15, 0xbe, 0x6c, 0xd7, 0x9c, 0xce, 0x31, 0xcc, 0xc5, 0xd3, 0x50, 0x71, 0xdb, 0xed, + 0x6e, 0xe4, 0x6c, 0x8a, 0xe3, 0x7c, 0x84, 0x6f, 0xad, 0x55, 0x59, 0x88, 0x63, 0x38, 0x5a, 0x85, + 0x01, 0xd6, 0x15, 0xfe, 0x95, 0x4f, 0x66, 0x7f, 0xa5, 0xe8, 0xfb, 0x7c, 0xd5, 0x89, 0x1c, 0xce, + 0x49, 0xa9, 0x7b, 0x84, 0x16, 0x61, 0x46, 0x02, 0x39, 0x00, 0x9b, 0xae, 0xe7, 0x04, 0xfb, 0xb4, + 0x6c, 0xa6, 0xcc, 0x08, 0x3e, 0x5b, 0x4c, 0x70, 0x51, 0xe1, 0x73, 0xb2, 0xea, 0xc3, 0x62, 0x00, + 0xd6, 0x88, 0xce, 0x7e, 0x08, 0x2a, 0x0a, 0xf9, 0x30, 0x0c, 0xd1, 0xec, 0x47, 0x60, 0x32, 0xd1, + 0x56, 0xaf, 0xea, 0x63, 0x3a, 0x3f, 0xf5, 0x4b, 0xec, 0xc8, 0x10, 0xbd, 0x5e, 0xf6, 0xf6, 0xc4, + 0x91, 0xfb, 0x16, 0x9c, 0x6c, 0x65, 0x9c, 0x64, 0x62, 0x5e, 0xfb, 0x3f, 0xf9, 0x1e, 0x13, 0x9f, + 0x7d, 0x32, 0x0b, 0x8a, 0x33, 0xdb, 0xa0, 0x3c, 0x82, 0xdf, 0xa1, 0x1b, 0xc4, 0x69, 0xe9, 0xec, + 0xf6, 0x0d, 0x51, 0x86, 0x15, 0x94, 0x9e, 0x77, 0x27, 0x55, 0xe7, 0xaf, 0x91, 0xfd, 0x3a, 0x69, + 0x91, 0x46, 0xe4, 0x07, 0xdf, 0xd0, 0xee, 0x9f, 0xe5, 0xa3, 0xcf, 0x8f, 0xcb, 0x51, 0x41, 0xa0, + 0x7c, 0x8d, 0xec, 0xf3, 0xa9, 0xd0, 0xbf, 0xae, 0x5c, 0xf8, 0x75, 0x3f, 0x6b, 0xc1, 0xb8, 0xfa, + 0xba, 0x63, 0x38, 0x17, 0x16, 0xcd, 0x73, 0xe1, 0x6c, 0xe1, 0x02, 0xcf, 0x39, 0x11, 0xbe, 0x5a, + 0x82, 0x33, 0x0a, 0x87, 0xbe, 0x0d, 0xf8, 0x1f, 0xb1, 0xaa, 0x2e, 0x41, 0xc5, 0x53, 0x52, 0x2b, + 0xcb, 0x14, 0x17, 0xc5, 0x32, 0xab, 0x18, 0x87, 0xb2, 0x78, 0x5e, 0x2c, 0x5a, 0x1a, 0xd3, 0xc5, + 0xb9, 0x42, 0x74, 0xbb, 0x08, 0xe5, 0xae, 0xdb, 0x14, 0x17, 0xcc, 0x07, 0xe4, 0x68, 0xdf, 0x5c, + 0xad, 0xde, 0x3f, 0x98, 0x7b, 0x3c, 0x4f, 0x95, 0x40, 0x6f, 0xb6, 0x70, 0xfe, 0xe6, 0x6a, 0x15, + 0xd3, 0xca, 0x68, 0x01, 0x26, 0xa5, 0xb6, 0xe4, 0x16, 0x65, 0xb7, 0x7c, 0x4f, 0xdc, 0x43, 0x4a, + 0x26, 0x8b, 0x4d, 0x30, 0x4e, 0xe2, 0xa3, 0x2a, 0x4c, 0xed, 0x76, 0x37, 0x49, 0x8b, 0x44, 0xfc, + 0x83, 0xaf, 0x11, 0x2e, 0xb1, 0xac, 0xc4, 0x2f, 0xb3, 0x6b, 0x09, 0x38, 0x4e, 0xd5, 0xb0, 0xff, + 0x9c, 0xdd, 0x07, 0x62, 0xf4, 0x6a, 0x81, 0x4f, 0x17, 0x16, 0xa5, 0xfe, 0x8d, 0x5c, 0xce, 0xfd, + 0xac, 0x8a, 0x6b, 0x64, 0x7f, 0xc3, 0xa7, 0x9c, 0x79, 0xf6, 0xaa, 0x30, 0xd6, 0xfc, 0x40, 0xe1, + 0x9a, 0xff, 0xb9, 0x12, 0x9c, 0x52, 0x23, 0x60, 0x30, 0x81, 0xdf, 0xec, 0x63, 0x70, 0x19, 0x46, + 0x9b, 0x64, 0xcb, 0xe9, 0xb6, 0x22, 0x25, 0x3e, 0x1f, 0xe4, 0x2a, 0x94, 0x6a, 0x5c, 0x8c, 0x75, + 0x9c, 0x43, 0x0c, 0xdb, 0xff, 0x1a, 0x65, 0x17, 0x71, 0xe4, 0xd0, 0x35, 0xae, 0x76, 0x8d, 0x95, + 0xbb, 0x6b, 0x9e, 0x80, 0x41, 0xb7, 0x4d, 0x19, 0xb3, 0x92, 0xc9, 0x6f, 0xad, 0xd2, 0x42, 0xcc, + 0x61, 0xe8, 0x7d, 0x30, 0xdc, 0xf0, 0xdb, 0x6d, 0xc7, 0x6b, 0xb2, 0x2b, 0xaf, 0xb2, 0x38, 0x4a, + 0x79, 0xb7, 0x25, 0x5e, 0x84, 0x25, 0x0c, 0x3d, 0x06, 0x03, 0x4e, 0xb0, 0xcd, 0x65, 0x18, 0x95, + 0xc5, 0x11, 0xda, 0xd2, 0x42, 0xb0, 0x1d, 0x62, 0x56, 0x4a, 0x9f, 0x60, 0x77, 0xfc, 0x60, 0xd7, + 0xf5, 0xb6, 0xab, 0x6e, 0x20, 0xb6, 0x84, 0xba, 0x0b, 0x6f, 0x2b, 0x08, 0xd6, 0xb0, 0xd0, 0x0a, + 0x0c, 0x76, 0xfc, 0x20, 0x0a, 0x67, 0x86, 0xd8, 0x70, 0x3f, 0x9e, 0x73, 0x10, 0xf1, 0xaf, 0xad, + 0xf9, 0x41, 0x14, 0x7f, 0x00, 0xfd, 0x17, 0x62, 0x5e, 0x1d, 0x5d, 0x87, 0x61, 0xe2, 0xed, 0xad, + 0x04, 0x7e, 0x7b, 0xe6, 0x44, 0x3e, 0xa5, 0x65, 0x8e, 0xc2, 0x97, 0x59, 0xcc, 0xa3, 0x8a, 0x62, + 0x2c, 0x49, 0xa0, 0x6f, 0x83, 0x32, 0xf1, 0xf6, 0x66, 0x86, 0x19, 0xa5, 0xd9, 0x1c, 0x4a, 0xb7, + 0x9c, 0x20, 0x3e, 0xf3, 0x97, 0xbd, 0x3d, 0x4c, 0xeb, 0xa0, 0x8f, 0x43, 0x45, 0x1e, 0x18, 0xa1, + 0x10, 0xd6, 0x65, 0x2e, 0x58, 0x79, 0xcc, 0x60, 0xf2, 0x66, 0xd7, 0x0d, 0x48, 0x9b, 0x78, 0x51, + 0x18, 0x9f, 0x90, 0x12, 0x1a, 0xe2, 0x98, 0x1a, 0xfa, 0xb8, 0x94, 0x10, 0xaf, 0xf9, 0x5d, 0x2f, + 0x0a, 0x67, 0x2a, 0xac, 0x7b, 0x99, 0xba, 0xbb, 0x5b, 0x31, 0x5e, 0x52, 0x84, 0xcc, 0x2b, 0x63, + 0x83, 0x14, 0xfa, 0x24, 0x8c, 0xf3, 0xff, 0x5c, 0x03, 0x16, 0xce, 0x9c, 0x62, 0xb4, 0xcf, 0xe7, + 0xd3, 0xe6, 0x88, 0x8b, 0xa7, 0x04, 0xf1, 0x71, 0xbd, 0x34, 0xc4, 0x26, 0x35, 0x84, 0x61, 0xbc, + 0xe5, 0xee, 0x11, 0x8f, 0x84, 0x61, 0x2d, 0xf0, 0x37, 0xc9, 0x0c, 0xb0, 0x81, 0x39, 0x93, 0xad, + 0x31, 0xf3, 0x37, 0xc9, 0xe2, 0x34, 0xa5, 0x79, 0x5d, 0xaf, 0x83, 0x4d, 0x12, 0xe8, 0x26, 0x4c, + 0xd0, 0x17, 0x9b, 0x1b, 0x13, 0x1d, 0xed, 0x45, 0x94, 0xbd, 0xab, 0xb0, 0x51, 0x09, 0x27, 0x88, + 0xa0, 0x1b, 0x30, 0x16, 0x46, 0x4e, 0x10, 0x75, 0x3b, 0x9c, 0xe8, 0xe9, 0x5e, 0x44, 0x99, 0xc2, + 0xb5, 0xae, 0x55, 0xc1, 0x06, 0x01, 0xf4, 0x1a, 0x54, 0x5a, 0xee, 0x16, 0x69, 0xec, 0x37, 0x5a, + 0x64, 0x66, 0x8c, 0x51, 0xcb, 0x3c, 0x54, 0xae, 0x4b, 0x24, 0xce, 0xe7, 0xaa, 0xbf, 0x38, 0xae, + 0x8e, 0x6e, 0xc1, 0xe9, 0x88, 0x04, 0x6d, 0xd7, 0x73, 0xe8, 0x61, 0x20, 0x9e, 0x56, 0x4c, 0x91, + 0x39, 0xce, 0x76, 0xdb, 0x39, 0x31, 0x1b, 0xa7, 0x37, 0x32, 0xb1, 0x70, 0x4e, 0x6d, 0x74, 0x17, + 0x66, 0x32, 0x20, 0x7e, 0xcb, 0x6d, 0xec, 0xcf, 0x9c, 0x64, 0x94, 0x3f, 0x2c, 0x28, 0xcf, 0x6c, + 0xe4, 0xe0, 0xdd, 0x2f, 0x80, 0xe1, 0x5c, 0xea, 0xe8, 0x06, 0x4c, 0xb2, 0x13, 0xa8, 0xd6, 0x6d, + 0xb5, 0x44, 0x83, 0x13, 0xac, 0xc1, 0xf7, 0xc9, 0xfb, 0x78, 0xd5, 0x04, 0xdf, 0x3f, 0x98, 0x83, + 0xf8, 0x1f, 0x4e, 0xd6, 0x46, 0x9b, 0x4c, 0x67, 0xd6, 0x0d, 0xdc, 0x68, 0x9f, 0x9e, 0x1b, 0xe4, + 0x6e, 0x34, 0x33, 0x59, 0x28, 0xaf, 0xd0, 0x51, 0x95, 0x62, 0x4d, 0x2f, 0xc4, 0x49, 0x82, 0xf4, + 0x48, 0x0d, 0xa3, 0xa6, 0xeb, 0xcd, 0x4c, 0xf1, 0x77, 0x89, 0x3c, 0x91, 0xea, 0xb4, 0x10, 0x73, + 0x18, 0xd3, 0x97, 0xd1, 0x1f, 0x37, 0xe8, 0xcd, 0x35, 0xcd, 0x10, 0x63, 0x7d, 0x99, 0x04, 0xe0, + 0x18, 0x87, 0x32, 0x93, 0x51, 0xb4, 0x3f, 0x83, 0x18, 0xaa, 0x3a, 0x58, 0x36, 0x36, 0x3e, 0x8e, + 0x69, 0xb9, 0xbd, 0x09, 0x13, 0xea, 0x20, 0x64, 0x63, 0x82, 0xe6, 0x60, 0x90, 0xb1, 0x4f, 0x42, + 0xba, 0x56, 0xa1, 0x5d, 0x60, 0xac, 0x15, 0xe6, 0xe5, 0xac, 0x0b, 0xee, 0x5b, 0x64, 0x71, 0x3f, + 0x22, 0xfc, 0x4d, 0x5f, 0xd6, 0xba, 0x20, 0x01, 0x38, 0xc6, 0xb1, 0xff, 0x2f, 0x67, 0x43, 0xe3, + 0xd3, 0xb6, 0x8f, 0xfb, 0xe5, 0x19, 0x18, 0xd9, 0xf1, 0xc3, 0x88, 0x62, 0xb3, 0x36, 0x06, 0x63, + 0xc6, 0xf3, 0xaa, 0x28, 0xc7, 0x0a, 0x03, 0xbd, 0x02, 0xe3, 0x0d, 0xbd, 0x01, 0x71, 0x39, 0xaa, + 0x63, 0xc4, 0x68, 0x1d, 0x9b, 0xb8, 0xe8, 0x25, 0x18, 0x61, 0x36, 0x20, 0x0d, 0xbf, 0x25, 0xb8, + 0x36, 0x79, 0xc3, 0x8f, 0xd4, 0x44, 0xf9, 0x7d, 0xed, 0x37, 0x56, 0xd8, 0xe8, 0x02, 0x0c, 0xd1, + 0x2e, 0xac, 0xd6, 0xc4, 0xb5, 0xa4, 0x04, 0x45, 0x57, 0x59, 0x29, 0x16, 0x50, 0xfb, 0x2f, 0x95, + 0xb4, 0x51, 0xa6, 0xef, 0x61, 0x82, 0x6a, 0x30, 0x7c, 0xc7, 0x71, 0x23, 0xd7, 0xdb, 0x16, 0xfc, + 0xc7, 0x53, 0x85, 0x77, 0x14, 0xab, 0x74, 0x9b, 0x57, 0xe0, 0xb7, 0xa8, 0xf8, 0x83, 0x25, 0x19, + 0x4a, 0x31, 0xe8, 0x7a, 0x1e, 0xa5, 0x58, 0xea, 0x97, 0x22, 0xe6, 0x15, 0x38, 0x45, 0xf1, 0x07, + 0x4b, 0x32, 0xe8, 0x0d, 0x00, 0xb9, 0xc3, 0x48, 0x53, 0xd8, 0x5e, 0x3c, 0xd3, 0x9b, 0xe8, 0x86, + 0xaa, 0xb3, 0x38, 0x41, 0xef, 0xe8, 0xf8, 0x3f, 0xd6, 0xe8, 0xd9, 0x11, 0xe3, 0xd3, 0xd2, 0x9d, + 0x41, 0xdf, 0x41, 0x97, 0xb8, 0x13, 0x44, 0xa4, 0xb9, 0x10, 0x89, 0xc1, 0x79, 0x7f, 0x7f, 0x8f, + 0x94, 0x0d, 0xb7, 0x4d, 0xf4, 0xed, 0x20, 0x88, 0xe0, 0x98, 0x9e, 0xfd, 0x0b, 0x65, 0x98, 0xc9, + 0xeb, 0x2e, 0x5d, 0x74, 0xe4, 0xae, 0x1b, 0x2d, 0x51, 0xf6, 0xca, 0x32, 0x17, 0xdd, 0xb2, 0x28, + 0xc7, 0x0a, 0x83, 0xce, 0x7e, 0xe8, 0x6e, 0xcb, 0x37, 0xe6, 0x60, 0x3c, 0xfb, 0x75, 0x56, 0x8a, + 0x05, 0x94, 0xe2, 0x05, 0xc4, 0x09, 0x85, 0x71, 0x8f, 0xb6, 0x4a, 0x30, 0x2b, 0xc5, 0x02, 0xaa, + 0x4b, 0xbb, 0x06, 0x7a, 0x48, 0xbb, 0x8c, 0x21, 0x1a, 0x3c, 0xda, 0x21, 0x42, 0x9f, 0x02, 0xd8, + 0x72, 0x3d, 0x37, 0xdc, 0x61, 0xd4, 0x87, 0x0e, 0x4d, 0x5d, 0x31, 0x67, 0x2b, 0x8a, 0x0a, 0xd6, + 0x28, 0xa2, 0x17, 0x61, 0x54, 0x6d, 0xc0, 0xd5, 0x2a, 0xd3, 0x74, 0x6a, 0x96, 0x23, 0xf1, 0x69, + 0x54, 0xc5, 0x3a, 0x9e, 0xfd, 0x99, 0xe4, 0x7a, 0x11, 0x3b, 0x40, 0x1b, 0x5f, 0xab, 0xdf, 0xf1, + 0x2d, 0x15, 0x8f, 0xaf, 0xfd, 0xf5, 0x32, 0x4c, 0x1a, 0x8d, 0x75, 0xc3, 0x3e, 0xce, 0xac, 0x2b, + 0xf4, 0x00, 0x77, 0x22, 0x22, 0xf6, 0x9f, 0xdd, 0x7b, 0xab, 0xe8, 0x87, 0x3c, 0xdd, 0x01, 0xbc, + 0x3e, 0xfa, 0x14, 0x54, 0x5a, 0x4e, 0xc8, 0x24, 0x67, 0x44, 0xec, 0xbb, 0x7e, 0x88, 0xc5, 0x0f, + 0x13, 0x27, 0x8c, 0xb4, 0x5b, 0x93, 0xd3, 0x8e, 0x49, 0xd2, 0x9b, 0x86, 0xf2, 0x27, 0xd2, 0x7a, + 0x4c, 0x75, 0x82, 0x32, 0x31, 0xfb, 0x98, 0xc3, 0xd0, 0x4b, 0x30, 0x16, 0x10, 0xb6, 0x2a, 0x96, + 0x28, 0x37, 0xc7, 0x96, 0xd9, 0x60, 0xcc, 0xf6, 0x61, 0x0d, 0x86, 0x0d, 0xcc, 0xf8, 0x6d, 0x30, + 0x54, 0xf0, 0x36, 0x78, 0x0a, 0x86, 0xd9, 0x0f, 0xb5, 0x02, 0xd4, 0x6c, 0xac, 0xf2, 0x62, 0x2c, + 0xe1, 0xc9, 0x05, 0x33, 0xd2, 0xdf, 0x82, 0xa1, 0xaf, 0x0f, 0xb1, 0xa8, 0x99, 0x96, 0x79, 0x84, + 0x9f, 0x72, 0x62, 0xc9, 0x63, 0x09, 0xb3, 0xdf, 0x0f, 0x13, 0x55, 0x87, 0xb4, 0x7d, 0x6f, 0xd9, + 0x6b, 0x76, 0x7c, 0xd7, 0x8b, 0xd0, 0x0c, 0x0c, 0xb0, 0x4b, 0x84, 0x1f, 0x01, 0x03, 0xb4, 0x21, + 0xcc, 0x4a, 0xec, 0x6d, 0x38, 0x55, 0xf5, 0xef, 0x78, 0x77, 0x9c, 0xa0, 0xb9, 0x50, 0x5b, 0xd5, + 0xde, 0xd7, 0xeb, 0xf2, 0x7d, 0xc7, 0x8d, 0xb6, 0x32, 0x8f, 0x5e, 0xad, 0x26, 0x67, 0x6b, 0x57, + 0xdc, 0x16, 0xc9, 0x91, 0x82, 0xfc, 0xd5, 0x92, 0xd1, 0x52, 0x8c, 0xaf, 0xb4, 0x5a, 0x56, 0xae, + 0x56, 0xeb, 0x75, 0x18, 0xd9, 0x72, 0x49, 0xab, 0x89, 0xc9, 0x96, 0x58, 0x89, 0x4f, 0xe6, 0xdb, + 0xa1, 0xac, 0x50, 0x4c, 0x29, 0xf5, 0xe2, 0xaf, 0xc3, 0x15, 0x51, 0x19, 0x2b, 0x32, 0x68, 0x17, + 0xa6, 0xe4, 0x83, 0x41, 0x42, 0xc5, 0xba, 0x7c, 0xaa, 0xe8, 0x15, 0x62, 0x12, 0x3f, 0x79, 0xef, + 0x60, 0x6e, 0x0a, 0x27, 0xc8, 0xe0, 0x14, 0x61, 0xfa, 0x1c, 0x6c, 0xd3, 0x13, 0x78, 0x80, 0x0d, + 0x3f, 0x7b, 0x0e, 0xb2, 0x97, 0x2d, 0x2b, 0xb5, 0x7f, 0xdc, 0x82, 0x47, 0x52, 0x23, 0x23, 0x5e, + 0xf8, 0x47, 0x3c, 0x0b, 0xc9, 0x17, 0x77, 0xa9, 0xf7, 0x8b, 0xdb, 0xfe, 0x3b, 0x16, 0x9c, 0x5c, + 0x6e, 0x77, 0xa2, 0xfd, 0xaa, 0x6b, 0xaa, 0xa0, 0x3e, 0x04, 0x43, 0x6d, 0xd2, 0x74, 0xbb, 0x6d, + 0x31, 0x73, 0x73, 0xf2, 0x94, 0x5a, 0x63, 0xa5, 0xf7, 0x0f, 0xe6, 0xc6, 0xeb, 0x91, 0x1f, 0x38, + 0xdb, 0x84, 0x17, 0x60, 0x81, 0xce, 0xce, 0x7a, 0xf7, 0x2d, 0x72, 0xdd, 0x6d, 0xbb, 0xd2, 0xae, + 0xa8, 0x50, 0x66, 0x37, 0x2f, 0x07, 0x74, 0xfe, 0xf5, 0xae, 0xe3, 0x45, 0x6e, 0xb4, 0x2f, 0xb4, + 0x47, 0x92, 0x08, 0x8e, 0xe9, 0xd9, 0x5f, 0xb3, 0x60, 0x52, 0xae, 0xfb, 0x85, 0x66, 0x33, 0x20, + 0x61, 0x88, 0x66, 0xa1, 0xe4, 0x76, 0x44, 0x2f, 0x41, 0xf4, 0xb2, 0xb4, 0x5a, 0xc3, 0x25, 0xb7, + 0x23, 0xd9, 0x32, 0x76, 0x10, 0x96, 0x4d, 0x45, 0xda, 0x55, 0x51, 0x8e, 0x15, 0x06, 0xba, 0x08, + 0x23, 0x9e, 0xdf, 0xe4, 0xb6, 0x5d, 0xfc, 0x4a, 0x63, 0x0b, 0x6c, 0x5d, 0x94, 0x61, 0x05, 0x45, + 0x35, 0xa8, 0x70, 0xb3, 0xa7, 0x78, 0xd1, 0xf6, 0x65, 0x3c, 0xc5, 0xbe, 0x6c, 0x43, 0xd6, 0xc4, + 0x31, 0x11, 0xfb, 0x57, 0x2c, 0x18, 0x93, 0x5f, 0xd6, 0x27, 0xcf, 0x49, 0xb7, 0x56, 0xcc, 0x6f, + 0xc6, 0x5b, 0x8b, 0xf2, 0x8c, 0x0c, 0x62, 0xb0, 0x8a, 0xe5, 0x43, 0xb1, 0x8a, 0x97, 0x61, 0xd4, + 0xe9, 0x74, 0x6a, 0x26, 0x9f, 0xc9, 0x96, 0xd2, 0x42, 0x5c, 0x8c, 0x75, 0x1c, 0xfb, 0xc7, 0x4a, + 0x30, 0x21, 0xbf, 0xa0, 0xde, 0xdd, 0x0c, 0x49, 0x84, 0x36, 0xa0, 0xe2, 0xf0, 0x59, 0x22, 0x72, + 0x91, 0x3f, 0x91, 0x2d, 0x47, 0x30, 0xa6, 0x34, 0xbe, 0xf0, 0x17, 0x64, 0x6d, 0x1c, 0x13, 0x42, + 0x2d, 0x98, 0xf6, 0xfc, 0x88, 0x1d, 0xfe, 0x0a, 0x5e, 0xa4, 0xda, 0x49, 0x52, 0x3f, 0x23, 0xa8, + 0x4f, 0xaf, 0x27, 0xa9, 0xe0, 0x34, 0x61, 0xb4, 0x2c, 0x65, 0x33, 0xe5, 0x7c, 0x61, 0x80, 0x3e, + 0x71, 0xd9, 0xa2, 0x19, 0xfb, 0x97, 0x2d, 0xa8, 0x48, 0xb4, 0xe3, 0xd0, 0xe2, 0xad, 0xc1, 0x70, + 0xc8, 0x26, 0x41, 0x0e, 0x8d, 0x5d, 0xd4, 0x71, 0x3e, 0x5f, 0xf1, 0x9d, 0xc6, 0xff, 0x87, 0x58, + 0xd2, 0x60, 0xa2, 0x79, 0xd5, 0xfd, 0x77, 0x88, 0x68, 0x5e, 0xf5, 0x27, 0xe7, 0x52, 0xfa, 0x43, + 0xd6, 0x67, 0x4d, 0xd6, 0x45, 0x59, 0xaf, 0x4e, 0x40, 0xb6, 0xdc, 0xbb, 0x49, 0xd6, 0xab, 0xc6, + 0x4a, 0xb1, 0x80, 0xa2, 0x37, 0x60, 0xac, 0x21, 0x65, 0xb2, 0xf1, 0x0e, 0xbf, 0x50, 0xa8, 0x1f, + 0x50, 0xaa, 0x24, 0x2e, 0x0b, 0x59, 0xd2, 0xea, 0x63, 0x83, 0x9a, 0x69, 0x46, 0x50, 0xee, 0x65, + 0x46, 0x10, 0xd3, 0xcd, 0x57, 0xaa, 0xff, 0x84, 0x05, 0x43, 0x5c, 0x16, 0xd7, 0x9f, 0x28, 0x54, + 0xd3, 0xac, 0xc5, 0x63, 0x77, 0x8b, 0x16, 0x0a, 0x4d, 0x19, 0x5a, 0x83, 0x0a, 0xfb, 0xc1, 0x64, + 0x89, 0xe5, 0x7c, 0xab, 0x7b, 0xde, 0xaa, 0xde, 0xc1, 0x5b, 0xb2, 0x1a, 0x8e, 0x29, 0xd8, 0x3f, + 0x5a, 0xa6, 0xa7, 0x5b, 0x8c, 0x6a, 0x5c, 0xfa, 0xd6, 0xc3, 0xbb, 0xf4, 0x4b, 0x0f, 0xeb, 0xd2, + 0xdf, 0x86, 0xc9, 0x86, 0xa6, 0x87, 0x8b, 0x67, 0xf2, 0x62, 0xe1, 0x22, 0xd1, 0x54, 0x76, 0x5c, + 0xca, 0xb2, 0x64, 0x12, 0xc1, 0x49, 0xaa, 0xe8, 0x3b, 0x60, 0x8c, 0xcf, 0xb3, 0x68, 0x85, 0x5b, + 0x62, 0xbc, 0x2f, 0x7f, 0xbd, 0xe8, 0x4d, 0x70, 0xa9, 0x9c, 0x56, 0x1d, 0x1b, 0xc4, 0xec, 0x3f, + 0xb1, 0x00, 0x2d, 0x77, 0x76, 0x48, 0x9b, 0x04, 0x4e, 0x2b, 0x16, 0xa7, 0xff, 0xa0, 0x05, 0x33, + 0x24, 0x55, 0xbc, 0xe4, 0xb7, 0xdb, 0xe2, 0xd1, 0x92, 0xf3, 0xae, 0x5e, 0xce, 0xa9, 0xa3, 0xdc, + 0x12, 0x66, 0xf2, 0x30, 0x70, 0x6e, 0x7b, 0x68, 0x0d, 0x4e, 0xf0, 0x5b, 0x52, 0x01, 0x34, 0xdb, + 0xeb, 0x47, 0x05, 0xe1, 0x13, 0x1b, 0x69, 0x14, 0x9c, 0x55, 0xcf, 0xfe, 0x9e, 0x31, 0xc8, 0xed, + 0xc5, 0xbb, 0x7a, 0x84, 0x77, 0xf5, 0x08, 0xef, 0xea, 0x11, 0xde, 0xd5, 0x23, 0xbc, 0xab, 0x47, + 0xf8, 0x96, 0xd7, 0x23, 0xfc, 0x65, 0x0b, 0x4e, 0xa9, 0x6b, 0xc0, 0x78, 0xf8, 0x7e, 0x16, 0x4e, + 0xf0, 0xed, 0xb6, 0xd4, 0x72, 0xdc, 0xf6, 0x06, 0x69, 0x77, 0x5a, 0x4e, 0x24, 0xb5, 0xee, 0x97, + 0x33, 0x57, 0x6e, 0xc2, 0x62, 0xd5, 0xa8, 0xb8, 0xf8, 0x08, 0xbd, 0x9e, 0x32, 0x00, 0x38, 0xab, + 0x19, 0xfb, 0x17, 0x46, 0x60, 0x70, 0x79, 0x8f, 0x78, 0xd1, 0x31, 0x3c, 0x11, 0x1a, 0x30, 0xe1, + 0x7a, 0x7b, 0x7e, 0x6b, 0x8f, 0x34, 0x39, 0xfc, 0x30, 0x2f, 0xd9, 0xd3, 0x82, 0xf4, 0xc4, 0xaa, + 0x41, 0x02, 0x27, 0x48, 0x3e, 0x0c, 0x69, 0xf2, 0x15, 0x18, 0xe2, 0x87, 0xb8, 0x10, 0x25, 0x67, + 0x9e, 0xd9, 0x6c, 0x10, 0xc5, 0xd5, 0x14, 0x4b, 0xba, 0xf9, 0x25, 0x21, 0xaa, 0xa3, 0xcf, 0xc0, + 0xc4, 0x96, 0x1b, 0x84, 0xd1, 0x86, 0xdb, 0x26, 0x61, 0xe4, 0xb4, 0x3b, 0x0f, 0x20, 0x3d, 0x56, + 0xe3, 0xb0, 0x62, 0x50, 0xc2, 0x09, 0xca, 0x68, 0x1b, 0xc6, 0x5b, 0x8e, 0xde, 0xd4, 0xf0, 0xa1, + 0x9b, 0x52, 0xb7, 0xc3, 0x75, 0x9d, 0x10, 0x36, 0xe9, 0xd2, 0xed, 0xd4, 0x60, 0x02, 0xd0, 0x11, + 0x26, 0x16, 0x50, 0xdb, 0x89, 0x4b, 0x3e, 0x39, 0x8c, 0x32, 0x3a, 0xcc, 0x40, 0xb6, 0x62, 0x32, + 0x3a, 0x9a, 0x19, 0xec, 0xa7, 0xa1, 0x42, 0xe8, 0x10, 0x52, 0xc2, 0xe2, 0x82, 0xb9, 0xd4, 0x5f, + 0x5f, 0xd7, 0xdc, 0x46, 0xe0, 0x9b, 0x72, 0xfb, 0x65, 0x49, 0x09, 0xc7, 0x44, 0xd1, 0x12, 0x0c, + 0x85, 0x24, 0x70, 0x49, 0x28, 0xae, 0x9a, 0x82, 0x69, 0x64, 0x68, 0xdc, 0xb7, 0x84, 0xff, 0xc6, + 0xa2, 0x2a, 0x5d, 0x5e, 0x0e, 0x13, 0x69, 0xb2, 0xcb, 0x40, 0x5b, 0x5e, 0x0b, 0xac, 0x14, 0x0b, + 0x28, 0x7a, 0x0d, 0x86, 0x03, 0xd2, 0x62, 0x8a, 0xa1, 0xf1, 0xfe, 0x17, 0x39, 0xd7, 0x33, 0xf1, + 0x7a, 0x58, 0x12, 0x40, 0xd7, 0x00, 0x05, 0x84, 0x32, 0x4a, 0xae, 0xb7, 0xad, 0xcc, 0x46, 0xc5, + 0x41, 0xab, 0x18, 0x52, 0x1c, 0x63, 0x48, 0x37, 0x1f, 0x9c, 0x51, 0x0d, 0x5d, 0x81, 0x69, 0x55, + 0xba, 0xea, 0x85, 0x91, 0x43, 0x0f, 0xb8, 0x49, 0x46, 0x4b, 0xc9, 0x29, 0x70, 0x12, 0x01, 0xa7, + 0xeb, 0xd8, 0x5f, 0xb2, 0x80, 0x8f, 0xf3, 0x31, 0xbc, 0xce, 0x5f, 0x35, 0x5f, 0xe7, 0x67, 0x72, + 0x67, 0x2e, 0xe7, 0x65, 0xfe, 0x25, 0x0b, 0x46, 0xb5, 0x99, 0x8d, 0xd7, 0xac, 0x55, 0xb0, 0x66, + 0xbb, 0x30, 0x45, 0x57, 0xfa, 0x8d, 0xcd, 0x90, 0x04, 0x7b, 0xa4, 0xc9, 0x16, 0x66, 0xe9, 0xc1, + 0x16, 0xa6, 0x32, 0x51, 0xbb, 0x9e, 0x20, 0x88, 0x53, 0x4d, 0xd8, 0x9f, 0x96, 0x5d, 0x55, 0x16, + 0x7d, 0x0d, 0x35, 0xe7, 0x09, 0x8b, 0x3e, 0x35, 0xab, 0x38, 0xc6, 0xa1, 0x5b, 0x6d, 0xc7, 0x0f, + 0xa3, 0xa4, 0x45, 0xdf, 0x55, 0x3f, 0x8c, 0x30, 0x83, 0xd8, 0xcf, 0x03, 0x2c, 0xdf, 0x25, 0x0d, + 0xbe, 0x62, 0xf5, 0xc7, 0x83, 0x95, 0xff, 0x78, 0xb0, 0x7f, 0xcb, 0x82, 0x89, 0x95, 0x25, 0xe3, + 0xe6, 0x9a, 0x07, 0xe0, 0x2f, 0x9e, 0xdb, 0xb7, 0xd7, 0xa5, 0x3a, 0x9c, 0x6b, 0x34, 0x55, 0x29, + 0xd6, 0x30, 0xd0, 0x19, 0x28, 0xb7, 0xba, 0x9e, 0x10, 0x1f, 0x0e, 0xd3, 0xeb, 0xf1, 0x7a, 0xd7, + 0xc3, 0xb4, 0x4c, 0x73, 0x29, 0x28, 0xf7, 0xed, 0x52, 0xd0, 0xd3, 0xb5, 0x1f, 0xcd, 0xc1, 0xe0, + 0x9d, 0x3b, 0x6e, 0x93, 0x3b, 0x50, 0x0a, 0x55, 0xfd, 0xed, 0xdb, 0xab, 0xd5, 0x10, 0xf3, 0x72, + 0xfb, 0x0b, 0x65, 0x98, 0x5d, 0x69, 0x91, 0xbb, 0x6f, 0xd3, 0x89, 0xb4, 0x5f, 0x87, 0x88, 0xc3, + 0x09, 0x62, 0x0e, 0xeb, 0xf4, 0xd2, 0x7b, 0x3c, 0xb6, 0x60, 0x98, 0x1b, 0xb4, 0x49, 0x97, 0xd2, + 0x57, 0xb2, 0x5a, 0xcf, 0x1f, 0x90, 0x79, 0x6e, 0x18, 0x27, 0x3c, 0xe2, 0xd4, 0x85, 0x29, 0x4a, + 0xb1, 0x24, 0x3e, 0xfb, 0x32, 0x8c, 0xe9, 0x98, 0x87, 0x72, 0x3f, 0xfb, 0x0b, 0x65, 0x98, 0xa2, + 0x3d, 0x78, 0xa8, 0x13, 0x71, 0x33, 0x3d, 0x11, 0x47, 0xed, 0x82, 0xd4, 0x7b, 0x36, 0xde, 0x48, + 0xce, 0xc6, 0xe5, 0xbc, 0xd9, 0x38, 0xee, 0x39, 0xf8, 0x6e, 0x0b, 0x4e, 0xac, 0xb4, 0xfc, 0xc6, + 0x6e, 0xc2, 0x4d, 0xe8, 0x45, 0x18, 0xa5, 0xc7, 0x71, 0x68, 0x78, 0xb0, 0x1b, 0x31, 0x0d, 0x04, + 0x08, 0xeb, 0x78, 0x5a, 0xb5, 0x9b, 0x37, 0x57, 0xab, 0x59, 0xa1, 0x10, 0x04, 0x08, 0xeb, 0x78, + 0xf6, 0xaf, 0x5b, 0x70, 0xf6, 0xca, 0xd2, 0x72, 0xbc, 0x14, 0x53, 0xd1, 0x18, 0x2e, 0xc0, 0x50, + 0xa7, 0xa9, 0x75, 0x25, 0x16, 0xaf, 0x56, 0x59, 0x2f, 0x04, 0xf4, 0x9d, 0x12, 0x69, 0xe4, 0x26, + 0xc0, 0x15, 0x5c, 0x5b, 0x12, 0xe7, 0xae, 0xd4, 0xa6, 0x58, 0xb9, 0xda, 0x94, 0xf7, 0xc1, 0x30, + 0xbd, 0x17, 0xdc, 0x86, 0xec, 0x37, 0x57, 0xd0, 0xf2, 0x22, 0x2c, 0x61, 0xf6, 0xcf, 0x58, 0x70, + 0xe2, 0x8a, 0x1b, 0xd1, 0x4b, 0x3b, 0x19, 0x6e, 0x80, 0xde, 0xda, 0xa1, 0x1b, 0xf9, 0xc1, 0x7e, + 0x32, 0xdc, 0x00, 0x56, 0x10, 0xac, 0x61, 0xf1, 0x0f, 0xda, 0x73, 0x99, 0x85, 0x76, 0xc9, 0xd4, + 0x5f, 0x61, 0x51, 0x8e, 0x15, 0x06, 0x1d, 0xaf, 0xa6, 0x1b, 0x30, 0xd1, 0xdf, 0xbe, 0x38, 0xb8, + 0xd5, 0x78, 0x55, 0x25, 0x00, 0xc7, 0x38, 0xf6, 0x1f, 0x59, 0x30, 0x77, 0xa5, 0xd5, 0x0d, 0x23, + 0x12, 0x6c, 0x85, 0x39, 0x87, 0xee, 0xf3, 0x50, 0x21, 0x52, 0xd0, 0x2e, 0x7a, 0xad, 0x18, 0x51, + 0x25, 0x81, 0xe7, 0x51, 0x0f, 0x14, 0x5e, 0x1f, 0xbe, 0x8c, 0x87, 0x73, 0x46, 0x5b, 0x01, 0x44, + 0xf4, 0xb6, 0xf4, 0x30, 0x10, 0xcc, 0x9f, 0x7c, 0x39, 0x05, 0xc5, 0x19, 0x35, 0xec, 0x1f, 0xb7, + 0xe0, 0x94, 0xfa, 0xe0, 0x77, 0xdc, 0x67, 0xda, 0x5f, 0x29, 0xc1, 0xf8, 0xd5, 0x8d, 0x8d, 0xda, + 0x15, 0x12, 0x69, 0xab, 0xb2, 0x58, 0x7d, 0x8e, 0x35, 0x2d, 0x60, 0xd1, 0x1b, 0xb1, 0x1b, 0xb9, + 0xad, 0x79, 0x1e, 0x4d, 0x68, 0x7e, 0xd5, 0x8b, 0x6e, 0x04, 0xf5, 0x28, 0x70, 0xbd, 0xed, 0xcc, + 0x95, 0x2e, 0x79, 0x96, 0x72, 0x1e, 0xcf, 0x82, 0x9e, 0x87, 0x21, 0x16, 0xce, 0x48, 0x4e, 0xc2, + 0xa3, 0xea, 0x89, 0xc5, 0x4a, 0xef, 0x1f, 0xcc, 0x55, 0x6e, 0xe2, 0x55, 0xfe, 0x07, 0x0b, 0x54, + 0x74, 0x13, 0x46, 0x77, 0xa2, 0xa8, 0x73, 0x95, 0x38, 0x4d, 0x12, 0xc8, 0x53, 0xf6, 0x5c, 0xd6, + 0x29, 0x4b, 0x07, 0x81, 0xa3, 0xc5, 0x07, 0x53, 0x5c, 0x16, 0x62, 0x9d, 0x8e, 0x5d, 0x07, 0x88, + 0x61, 0x47, 0xa4, 0x00, 0xb1, 0x37, 0xa0, 0x42, 0x3f, 0x77, 0xa1, 0xe5, 0x3a, 0xc5, 0x2a, 0xe6, + 0xa7, 0xa1, 0x22, 0x15, 0xc8, 0xa1, 0xf0, 0xb5, 0x66, 0x37, 0x92, 0xd4, 0x2f, 0x87, 0x38, 0x86, + 0xdb, 0x5b, 0x70, 0x92, 0x99, 0x03, 0x3a, 0xd1, 0x8e, 0xb1, 0xfa, 0x7a, 0x4f, 0xf3, 0x33, 0xe2, + 0xc5, 0xc6, 0xfb, 0x3c, 0xa3, 0xb9, 0x33, 0x8e, 0x49, 0x8a, 0xf1, 0xeb, 0xcd, 0xfe, 0xfa, 0x00, + 0x3c, 0xba, 0x5a, 0xcf, 0x0f, 0xc7, 0xf1, 0x12, 0x8c, 0x71, 0x46, 0x90, 0x4e, 0xba, 0xd3, 0x12, + 0xed, 0x2a, 0xd9, 0xe6, 0x86, 0x06, 0xc3, 0x06, 0x26, 0x3a, 0x0b, 0x65, 0xf7, 0x4d, 0x2f, 0xe9, + 0xec, 0xb3, 0xfa, 0xfa, 0x3a, 0xa6, 0xe5, 0x14, 0x4c, 0x79, 0x4a, 0x7e, 0x58, 0x2b, 0xb0, 0xe2, + 0x2b, 0x5f, 0x85, 0x09, 0x37, 0x6c, 0x84, 0xee, 0xaa, 0x47, 0x77, 0xa0, 0xb6, 0x87, 0x95, 0x34, + 0x81, 0x76, 0x5a, 0x41, 0x71, 0x02, 0x5b, 0xbb, 0x39, 0x06, 0xfb, 0xe6, 0x4b, 0x7b, 0x3a, 0x1f, + 0xd3, 0x83, 0xbd, 0xc3, 0xbe, 0x2e, 0x64, 0x42, 0x6a, 0x71, 0xb0, 0xf3, 0x0f, 0x0e, 0xb1, 0x84, + 0xd1, 0xa7, 0x5a, 0x63, 0xc7, 0xe9, 0x2c, 0x74, 0xa3, 0x9d, 0xaa, 0x1b, 0x36, 0xfc, 0x3d, 0x12, + 0xec, 0xb3, 0x57, 0xf6, 0x48, 0xfc, 0x54, 0x53, 0x80, 0xa5, 0xab, 0x0b, 0x35, 0x8a, 0x89, 0xd3, + 0x75, 0xd0, 0x02, 0x4c, 0xca, 0xc2, 0x3a, 0x09, 0xd9, 0xe1, 0x3e, 0xca, 0xc8, 0x28, 0xf7, 0x1b, + 0x51, 0xac, 0x88, 0x24, 0xf1, 0x4d, 0xd6, 0x15, 0x8e, 0x82, 0x75, 0xfd, 0x10, 0x8c, 0xbb, 0x9e, + 0x1b, 0xb9, 0x4e, 0xe4, 0x73, 0x0d, 0x0b, 0x7f, 0x50, 0x33, 0xd1, 0xf1, 0xaa, 0x0e, 0xc0, 0x26, + 0x9e, 0xfd, 0x5f, 0x06, 0x60, 0x9a, 0x4d, 0xdb, 0xbb, 0x2b, 0xec, 0x5b, 0x69, 0x85, 0xdd, 0x4c, + 0xaf, 0xb0, 0xa3, 0xe0, 0xc9, 0x1f, 0x78, 0x99, 0x7d, 0x06, 0x2a, 0xca, 0xe3, 0x48, 0xba, 0x1c, + 0x5a, 0x39, 0x2e, 0x87, 0xbd, 0xef, 0x65, 0x69, 0xb4, 0x55, 0xce, 0x34, 0xda, 0xfa, 0xb2, 0x05, + 0xb1, 0xca, 0x00, 0xbd, 0x0e, 0x95, 0x8e, 0xcf, 0x6c, 0x11, 0x03, 0x69, 0xe0, 0xfb, 0xde, 0x42, + 0x9d, 0x03, 0x8f, 0x48, 0x14, 0xf0, 0x51, 0xa8, 0xc9, 0xaa, 0x38, 0xa6, 0x82, 0xae, 0xc1, 0x70, + 0x27, 0x20, 0xf5, 0x88, 0x85, 0xe7, 0xe8, 0x9f, 0x20, 0x5f, 0x35, 0xbc, 0x22, 0x96, 0x14, 0xec, + 0xff, 0x6a, 0xc1, 0x54, 0x12, 0x15, 0x7d, 0x18, 0x06, 0xc8, 0x5d, 0xd2, 0x10, 0xfd, 0xcd, 0xbc, + 0x64, 0x63, 0xa1, 0x03, 0x1f, 0x00, 0xfa, 0x1f, 0xb3, 0x5a, 0xe8, 0x2a, 0x0c, 0xd3, 0x1b, 0xf6, + 0x8a, 0x0a, 0x0d, 0xf5, 0x78, 0xde, 0x2d, 0xad, 0x58, 0x15, 0xde, 0x39, 0x51, 0x84, 0x65, 0x75, + 0x66, 0x29, 0xd5, 0xe8, 0xd4, 0xe9, 0xe3, 0x25, 0x2a, 0x7a, 0x63, 0x6f, 0x2c, 0xd5, 0x38, 0x92, + 0xa0, 0xc6, 0x2d, 0xa5, 0x64, 0x21, 0x8e, 0x89, 0xd8, 0x3f, 0x67, 0x01, 0x70, 0xc3, 0x30, 0xc7, + 0xdb, 0x26, 0xc7, 0x20, 0x27, 0xaf, 0xc2, 0x40, 0xd8, 0x21, 0x8d, 0x22, 0x33, 0xd9, 0xb8, 0x3f, + 0xf5, 0x0e, 0x69, 0xc4, 0x2b, 0x8e, 0xfe, 0xc3, 0xac, 0xb6, 0xfd, 0xbd, 0x00, 0x13, 0x31, 0xda, + 0x6a, 0x44, 0xda, 0xe8, 0x59, 0x23, 0x4c, 0xc1, 0x99, 0x44, 0x98, 0x82, 0x0a, 0xc3, 0xd6, 0x44, + 0xb2, 0x9f, 0x81, 0x72, 0xdb, 0xb9, 0x2b, 0x64, 0x6e, 0x4f, 0x17, 0x77, 0x83, 0xd2, 0x9f, 0x5f, + 0x73, 0xee, 0xf2, 0x67, 0xe9, 0xd3, 0x72, 0x87, 0xac, 0x39, 0x77, 0xef, 0x73, 0x63, 0x58, 0x76, + 0x4a, 0x5f, 0x77, 0xc3, 0xe8, 0x73, 0xff, 0x39, 0xfe, 0xcf, 0xf6, 0x1d, 0x6d, 0x84, 0xb5, 0xe5, + 0x7a, 0xc2, 0xe6, 0xa9, 0xaf, 0xb6, 0x5c, 0x2f, 0xd9, 0x96, 0xeb, 0xf5, 0xd1, 0x96, 0xeb, 0xa1, + 0xb7, 0x60, 0x58, 0x98, 0x24, 0x8a, 0xb0, 0x40, 0x97, 0xfa, 0x68, 0x4f, 0x58, 0x34, 0xf2, 0x36, + 0x2f, 0xc9, 0x67, 0xb7, 0x28, 0xed, 0xd9, 0xae, 0x6c, 0x10, 0xfd, 0x15, 0x0b, 0x26, 0xc4, 0x6f, + 0x4c, 0xde, 0xec, 0x92, 0x30, 0x12, 0x6c, 0xe9, 0x07, 0xfb, 0xef, 0x83, 0xa8, 0xc8, 0xbb, 0xf2, + 0x41, 0x79, 0xcf, 0x98, 0xc0, 0x9e, 0x3d, 0x4a, 0xf4, 0x02, 0xfd, 0x3d, 0x0b, 0x4e, 0xb6, 0x9d, + 0xbb, 0xbc, 0x45, 0x5e, 0x86, 0x9d, 0xc8, 0xf5, 0x85, 0x6a, 0xff, 0xc3, 0xfd, 0x4d, 0x7f, 0xaa, + 0x3a, 0xef, 0xa4, 0xd4, 0x3f, 0x9e, 0xcc, 0x42, 0xe9, 0xd9, 0xd5, 0xcc, 0x7e, 0xcd, 0x6e, 0xc1, + 0x88, 0x5c, 0x6f, 0x19, 0xc2, 0x8d, 0xaa, 0xce, 0x73, 0x1f, 0xda, 0x22, 0x54, 0x77, 0xff, 0xa7, + 0xed, 0x88, 0xb5, 0xf6, 0x50, 0xdb, 0xf9, 0x0c, 0x8c, 0xe9, 0x6b, 0xec, 0xa1, 0xb6, 0xf5, 0x26, + 0x9c, 0xc8, 0x58, 0x4b, 0x0f, 0xb5, 0xc9, 0x3b, 0x70, 0x26, 0x77, 0x7d, 0x3c, 0xcc, 0x86, 0xed, + 0xaf, 0x58, 0xfa, 0x39, 0x78, 0x0c, 0xca, 0x8a, 0x25, 0x53, 0x59, 0x71, 0xae, 0x78, 0xe7, 0xe4, + 0x68, 0x2c, 0xde, 0xd0, 0x3b, 0x4d, 0x4f, 0x75, 0xf4, 0x1a, 0x0c, 0xb5, 0x68, 0x89, 0x34, 0x6c, + 0xb5, 0x7b, 0xef, 0xc8, 0x98, 0x99, 0x64, 0xe5, 0x21, 0x16, 0x14, 0xec, 0x5f, 0xb4, 0x60, 0xe0, + 0x18, 0x46, 0x02, 0x9b, 0x23, 0xf1, 0x6c, 0x2e, 0x69, 0x11, 0xb1, 0x78, 0x1e, 0x3b, 0x77, 0x96, + 0xef, 0x46, 0xc4, 0x0b, 0xd9, 0x8d, 0x9c, 0x39, 0x30, 0x3f, 0x65, 0xc1, 0x89, 0xeb, 0xbe, 0xd3, + 0x5c, 0x74, 0x5a, 0x8e, 0xd7, 0x20, 0xc1, 0xaa, 0xb7, 0x7d, 0x28, 0xab, 0xec, 0x52, 0x4f, 0xab, + 0xec, 0x25, 0x69, 0xd4, 0x34, 0x90, 0x3f, 0x7f, 0x94, 0x93, 0x4e, 0x06, 0x6e, 0x31, 0xcc, 0x6f, + 0x77, 0x00, 0xe9, 0xbd, 0x14, 0x3e, 0x32, 0x18, 0x86, 0x5d, 0xde, 0x5f, 0x31, 0x89, 0x4f, 0x66, + 0x73, 0xb8, 0xa9, 0xcf, 0xd3, 0xbc, 0x3f, 0x78, 0x01, 0x96, 0x84, 0xec, 0x97, 0x20, 0xd3, 0xd1, + 0xbe, 0xb7, 0x5c, 0xc2, 0xfe, 0x38, 0x4c, 0xb3, 0x9a, 0x87, 0x94, 0x0c, 0xd8, 0x09, 0x69, 0x6a, + 0x46, 0x08, 0x3e, 0xfb, 0xf3, 0x16, 0x4c, 0xae, 0x27, 0x22, 0x93, 0x5d, 0x60, 0xfa, 0xd7, 0x0c, + 0x21, 0x7e, 0x9d, 0x95, 0x62, 0x01, 0x3d, 0x72, 0x21, 0xd7, 0x9f, 0x5b, 0x10, 0xc7, 0xbe, 0x38, + 0x06, 0xf6, 0x6d, 0xc9, 0x60, 0xdf, 0x32, 0x19, 0x59, 0xd5, 0x9d, 0x3c, 0xee, 0x0d, 0x5d, 0x53, + 0x51, 0xa1, 0x0a, 0x78, 0xd8, 0x98, 0x0c, 0x5f, 0x8a, 0x13, 0x66, 0xe8, 0x28, 0x19, 0x27, 0xca, + 0xfe, 0xed, 0x12, 0x20, 0x85, 0xdb, 0x77, 0xd4, 0xaa, 0x74, 0x8d, 0xa3, 0x89, 0x5a, 0xb5, 0x07, + 0x88, 0x59, 0x10, 0x04, 0x8e, 0x17, 0x72, 0xb2, 0xae, 0x10, 0xeb, 0x1d, 0xce, 0x3c, 0x61, 0x56, + 0x34, 0x89, 0xae, 0xa7, 0xa8, 0xe1, 0x8c, 0x16, 0x34, 0xcb, 0x90, 0xc1, 0x7e, 0x2d, 0x43, 0x86, + 0x7a, 0xf8, 0xc1, 0xfd, 0xac, 0x05, 0xe3, 0x6a, 0x98, 0xde, 0x21, 0x56, 0xea, 0xaa, 0x3f, 0x39, + 0x07, 0x68, 0x4d, 0xeb, 0x32, 0xbb, 0x58, 0xbe, 0x9d, 0xf9, 0x33, 0x3a, 0x2d, 0xf7, 0x2d, 0xa2, + 0x62, 0x06, 0xce, 0x09, 0xff, 0x44, 0x51, 0x7a, 0xff, 0x60, 0x6e, 0x5c, 0xfd, 0xe3, 0x31, 0x8a, + 0xe3, 0x2a, 0xf4, 0x48, 0x9e, 0x4c, 0x2c, 0x45, 0xf4, 0x22, 0x0c, 0x76, 0x76, 0x9c, 0x90, 0x24, + 0xbc, 0x79, 0x06, 0x6b, 0xb4, 0xf0, 0xfe, 0xc1, 0xdc, 0x84, 0xaa, 0xc0, 0x4a, 0x30, 0xc7, 0xee, + 0x3f, 0x16, 0x58, 0x7a, 0x71, 0xf6, 0x8c, 0x05, 0xf6, 0x27, 0x16, 0x0c, 0xac, 0xfb, 0xcd, 0xe3, + 0x38, 0x02, 0x5e, 0x35, 0x8e, 0x80, 0xc7, 0xf2, 0xc2, 0xc7, 0xe7, 0xee, 0xfe, 0x95, 0xc4, 0xee, + 0x3f, 0x97, 0x4b, 0xa1, 0x78, 0xe3, 0xb7, 0x61, 0x94, 0x05, 0xa5, 0x17, 0x9e, 0x4b, 0xcf, 0x1b, + 0x1b, 0x7e, 0x2e, 0xb1, 0xe1, 0x27, 0x35, 0x54, 0x6d, 0xa7, 0x3f, 0x05, 0xc3, 0xc2, 0x15, 0x26, + 0xe9, 0x16, 0x2a, 0x70, 0xb1, 0x84, 0xdb, 0x3f, 0x51, 0x06, 0x23, 0x08, 0x3e, 0xfa, 0x65, 0x0b, + 0xe6, 0x03, 0x6e, 0x22, 0xdb, 0xac, 0x76, 0x03, 0xd7, 0xdb, 0xae, 0x37, 0x76, 0x48, 0xb3, 0xdb, + 0x72, 0xbd, 0xed, 0xd5, 0x6d, 0xcf, 0x57, 0xc5, 0xcb, 0x77, 0x49, 0xa3, 0xcb, 0xd4, 0x6e, 0x3d, + 0x22, 0xee, 0x2b, 0x53, 0xf3, 0xe7, 0xee, 0x1d, 0xcc, 0xcd, 0xe3, 0x43, 0xd1, 0xc6, 0x87, 0xec, + 0x0b, 0xfa, 0x75, 0x0b, 0x2e, 0xf1, 0xd8, 0xf0, 0xfd, 0xf7, 0xbf, 0xe0, 0xb5, 0x5c, 0x93, 0xa4, + 0x62, 0x22, 0x1b, 0x24, 0x68, 0x2f, 0x7e, 0x48, 0x0c, 0xe8, 0xa5, 0xda, 0xe1, 0xda, 0xc2, 0x87, + 0xed, 0x9c, 0xfd, 0xcf, 0xca, 0x30, 0x2e, 0x62, 0x46, 0x89, 0x3b, 0xe0, 0x45, 0x63, 0x49, 0x3c, + 0x9e, 0x58, 0x12, 0xd3, 0x06, 0xf2, 0xd1, 0x1c, 0xff, 0x21, 0x4c, 0xd3, 0xc3, 0xf9, 0x2a, 0x71, + 0x82, 0x68, 0x93, 0x38, 0xdc, 0xe0, 0xab, 0x7c, 0xe8, 0xd3, 0x5f, 0xc9, 0x27, 0xaf, 0x27, 0x89, + 0xe1, 0x34, 0xfd, 0x6f, 0xa5, 0x3b, 0xc7, 0x83, 0xa9, 0x54, 0xd8, 0xaf, 0x4f, 0x40, 0x45, 0xf9, + 0x71, 0x88, 0x43, 0xa7, 0x38, 0x7a, 0x5e, 0x92, 0x02, 0x17, 0x7f, 0xc5, 0x3e, 0x44, 0x31, 0x39, + 0xfb, 0x1f, 0x94, 0x8c, 0x06, 0xf9, 0x24, 0xae, 0xc3, 0x88, 0x13, 0x86, 0xee, 0xb6, 0x47, 0x9a, + 0x45, 0x12, 0xca, 0x54, 0x33, 0xcc, 0x97, 0x66, 0x41, 0xd4, 0xc4, 0x8a, 0x06, 0xba, 0xca, 0xcd, + 0xea, 0xf6, 0x48, 0x91, 0x78, 0x32, 0x45, 0x0d, 0xa4, 0xe1, 0xdd, 0x1e, 0xc1, 0xa2, 0x3e, 0xfa, + 0x24, 0xb7, 0x7b, 0xbc, 0xe6, 0xf9, 0x77, 0xbc, 0x2b, 0xbe, 0x2f, 0xe3, 0x32, 0xf4, 0x47, 0x70, + 0x5a, 0x5a, 0x3b, 0xaa, 0xea, 0xd8, 0xa4, 0xd6, 0x5f, 0x1c, 0xcd, 0xcf, 0xc2, 0x09, 0x4a, 0xda, + 0x74, 0x9b, 0x0e, 0x11, 0x81, 0x49, 0x11, 0x90, 0x4c, 0x96, 0x89, 0xb1, 0xcb, 0x7c, 0xca, 0x99, + 0xb5, 0x63, 0x41, 0xfa, 0x35, 0x93, 0x04, 0x4e, 0xd2, 0xb4, 0x7f, 0xda, 0x02, 0xe6, 0x42, 0x7a, + 0x0c, 0xfc, 0xc8, 0x47, 0x4c, 0x7e, 0x64, 0x26, 0x6f, 0x90, 0x73, 0x58, 0x91, 0x17, 0xf8, 0xca, + 0xaa, 0x05, 0xfe, 0xdd, 0x7d, 0x61, 0xac, 0xd2, 0xfb, 0xfd, 0x61, 0xff, 0x1f, 0x8b, 0x1f, 0x62, + 0xca, 0xcb, 0x02, 0x7d, 0x27, 0x8c, 0x34, 0x9c, 0x8e, 0xd3, 0xe0, 0x19, 0x5b, 0x72, 0x25, 0x7a, + 0x46, 0xa5, 0xf9, 0x25, 0x51, 0x83, 0x4b, 0xa8, 0x64, 0x60, 0xbb, 0x11, 0x59, 0xdc, 0x53, 0x2a, + 0xa5, 0x9a, 0x9c, 0xdd, 0x85, 0x71, 0x83, 0xd8, 0x43, 0x15, 0x67, 0x7c, 0x27, 0xbf, 0x62, 0x55, + 0x20, 0xc6, 0x36, 0x4c, 0x7b, 0xda, 0x7f, 0x7a, 0xa1, 0xc8, 0xc7, 0xe5, 0x7b, 0x7b, 0x5d, 0xa2, + 0xec, 0xf6, 0xd1, 0xbc, 0x53, 0x13, 0x64, 0x70, 0x9a, 0xb2, 0xfd, 0x93, 0x16, 0x3c, 0xa2, 0x23, + 0x6a, 0x0e, 0x30, 0xbd, 0x94, 0x24, 0x55, 0x18, 0xf1, 0x3b, 0x24, 0x70, 0x22, 0x3f, 0x10, 0xb7, + 0xc6, 0x45, 0x39, 0xe8, 0x37, 0x44, 0xf9, 0x7d, 0x11, 0xef, 0x5c, 0x52, 0x97, 0xe5, 0x58, 0xd5, + 0xa4, 0xaf, 0x4f, 0x36, 0x18, 0xa1, 0x70, 0x75, 0x62, 0x67, 0x00, 0xd3, 0xa4, 0x87, 0x58, 0x40, + 0xec, 0xaf, 0x5b, 0x7c, 0x61, 0xe9, 0x5d, 0x47, 0x6f, 0xc2, 0x54, 0xdb, 0x89, 0x1a, 0x3b, 0xcb, + 0x77, 0x3b, 0x01, 0x57, 0x39, 0xc9, 0x71, 0x7a, 0xba, 0xd7, 0x38, 0x69, 0x1f, 0x19, 0x9b, 0x72, + 0xae, 0x25, 0x88, 0xe1, 0x14, 0x79, 0xb4, 0x09, 0xa3, 0xac, 0x8c, 0x79, 0xf1, 0x85, 0x45, 0xac, + 0x41, 0x5e, 0x6b, 0xca, 0x18, 0x61, 0x2d, 0xa6, 0x83, 0x75, 0xa2, 0xf6, 0x97, 0xcb, 0x7c, 0xb7, + 0x33, 0x56, 0xfe, 0x29, 0x18, 0xee, 0xf8, 0xcd, 0xa5, 0xd5, 0x2a, 0x16, 0xb3, 0xa0, 0xae, 0x91, + 0x1a, 0x2f, 0xc6, 0x12, 0x8e, 0x2e, 0xc2, 0x88, 0xf8, 0x29, 0x55, 0x84, 0xec, 0x6c, 0x16, 0x78, + 0x21, 0x56, 0x50, 0xf4, 0x1c, 0x40, 0x27, 0xf0, 0xf7, 0xdc, 0x26, 0x8b, 0x2e, 0x51, 0x36, 0xed, + 0x88, 0x6a, 0x0a, 0x82, 0x35, 0x2c, 0xf4, 0x0a, 0x8c, 0x77, 0xbd, 0x90, 0xb3, 0x23, 0x5a, 0x2c, + 0x59, 0x65, 0xe1, 0x72, 0x53, 0x07, 0x62, 0x13, 0x17, 0x2d, 0xc0, 0x50, 0xe4, 0x30, 0xbb, 0x98, + 0xc1, 0x7c, 0x73, 0xdf, 0x0d, 0x8a, 0xa1, 0x27, 0x07, 0xa1, 0x15, 0xb0, 0xa8, 0x88, 0x3e, 0x21, + 0x1d, 0x6a, 0xf9, 0xc1, 0x2e, 0xec, 0xec, 0xfb, 0xbb, 0x04, 0x34, 0x77, 0x5a, 0x61, 0xbf, 0x6f, + 0xd0, 0x42, 0x2f, 0x03, 0x90, 0xbb, 0x11, 0x09, 0x3c, 0xa7, 0xa5, 0xac, 0xd9, 0x14, 0x5f, 0x50, + 0xf5, 0xd7, 0xfd, 0xe8, 0x66, 0x48, 0x96, 0x15, 0x06, 0xd6, 0xb0, 0xed, 0x5f, 0xaf, 0x00, 0xc4, + 0x7c, 0x3b, 0x7a, 0x2b, 0x75, 0x70, 0x3d, 0x53, 0xcc, 0xe9, 0x1f, 0xdd, 0xa9, 0x85, 0xbe, 0xcf, + 0x82, 0x51, 0xa7, 0xd5, 0xf2, 0x1b, 0x0e, 0x8f, 0xf6, 0x5b, 0x2a, 0x3e, 0x38, 0x45, 0xfb, 0x0b, + 0x71, 0x0d, 0xde, 0x85, 0xe7, 0xe5, 0x0a, 0xd5, 0x20, 0x3d, 0x7b, 0xa1, 0x37, 0x8c, 0x3e, 0x20, + 0x9f, 0x8a, 0x65, 0x63, 0x28, 0xd5, 0x53, 0xb1, 0xc2, 0xee, 0x08, 0xfd, 0x95, 0x78, 0xd3, 0x78, + 0x25, 0x0e, 0xe4, 0x7b, 0x0c, 0x1a, 0xec, 0x6b, 0xaf, 0x07, 0x22, 0xaa, 0xe9, 0xd1, 0x03, 0x06, + 0xf3, 0xdd, 0xf3, 0xb4, 0x77, 0x52, 0x8f, 0xc8, 0x01, 0x9f, 0x81, 0xc9, 0xa6, 0xc9, 0x04, 0x88, + 0x95, 0xf8, 0x64, 0x1e, 0xdd, 0x04, 0xcf, 0x10, 0x5f, 0xfb, 0x09, 0x00, 0x4e, 0x12, 0x46, 0x35, + 0x1e, 0x4c, 0x62, 0xd5, 0xdb, 0xf2, 0x85, 0xaf, 0x87, 0x9d, 0x3b, 0x97, 0xfb, 0x61, 0x44, 0xda, + 0x14, 0x33, 0xbe, 0xdd, 0xd7, 0x45, 0x5d, 0xac, 0xa8, 0xa0, 0xd7, 0x60, 0x88, 0xf9, 0x67, 0x85, + 0x33, 0x23, 0xf9, 0x12, 0x67, 0x33, 0x3a, 0x5a, 0xbc, 0x21, 0xd9, 0xdf, 0x10, 0x0b, 0x0a, 0xe8, + 0xaa, 0xf4, 0x7e, 0x0c, 0x57, 0xbd, 0x9b, 0x21, 0x61, 0xde, 0x8f, 0x95, 0xc5, 0xf7, 0xc6, 0x8e, + 0x8d, 0xbc, 0x3c, 0x33, 0x85, 0x98, 0x51, 0x93, 0x72, 0x51, 0xe2, 0xbf, 0xcc, 0x4c, 0x36, 0x03, + 0xf9, 0xdd, 0x33, 0xb3, 0x97, 0xc5, 0xc3, 0x79, 0xcb, 0x24, 0x81, 0x93, 0x34, 0x29, 0x47, 0xca, + 0x77, 0xbd, 0xf0, 0x16, 0xe9, 0x75, 0x76, 0xf0, 0x87, 0x38, 0xbb, 0x8d, 0x78, 0x09, 0x16, 0xf5, + 0x8f, 0x95, 0x3d, 0x98, 0xf5, 0x60, 0x2a, 0xb9, 0x45, 0x1f, 0x2a, 0x3b, 0xf2, 0x07, 0x03, 0x30, + 0x61, 0x2e, 0x29, 0x74, 0x09, 0x2a, 0x82, 0x88, 0xca, 0x26, 0xa0, 0x76, 0xc9, 0x9a, 0x04, 0xe0, + 0x18, 0x87, 0x25, 0x91, 0x60, 0xd5, 0x35, 0xf3, 0xe0, 0x38, 0x89, 0x84, 0x82, 0x60, 0x0d, 0x8b, + 0x3e, 0xac, 0x36, 0x7d, 0x3f, 0x52, 0x17, 0x92, 0x5a, 0x77, 0x8b, 0xac, 0x14, 0x0b, 0x28, 0xbd, + 0x88, 0x76, 0x49, 0xe0, 0x91, 0x96, 0x19, 0x77, 0x58, 0x5d, 0x44, 0xd7, 0x74, 0x20, 0x36, 0x71, + 0xe9, 0x75, 0xea, 0x87, 0x6c, 0x21, 0x8b, 0xe7, 0x5b, 0x6c, 0x6e, 0x5d, 0xe7, 0x0e, 0xd8, 0x12, + 0x8e, 0x3e, 0x0e, 0x8f, 0xa8, 0xd8, 0x4a, 0x98, 0x6b, 0x33, 0x64, 0x8b, 0x43, 0x86, 0xb4, 0xe5, + 0x91, 0xa5, 0x6c, 0x34, 0x9c, 0x57, 0x1f, 0xbd, 0x0a, 0x13, 0x82, 0xc5, 0x97, 0x14, 0x87, 0x4d, + 0x0b, 0xa3, 0x6b, 0x06, 0x14, 0x27, 0xb0, 0x65, 0xe4, 0x64, 0xc6, 0x65, 0x4b, 0x0a, 0x23, 0xe9, + 0xc8, 0xc9, 0x3a, 0x1c, 0xa7, 0x6a, 0xa0, 0x05, 0x98, 0xe4, 0x3c, 0x98, 0xeb, 0x6d, 0xf3, 0x39, + 0x11, 0xce, 0x5c, 0x6a, 0x4b, 0xdd, 0x30, 0xc1, 0x38, 0x89, 0x8f, 0x5e, 0x82, 0x31, 0x27, 0x68, + 0xec, 0xb8, 0x11, 0x69, 0x44, 0xdd, 0x80, 0x7b, 0x79, 0x69, 0x26, 0x5a, 0x0b, 0x1a, 0x0c, 0x1b, + 0x98, 0xf6, 0x5b, 0x70, 0x22, 0x23, 0x32, 0x03, 0x5d, 0x38, 0x4e, 0xc7, 0x95, 0xdf, 0x94, 0xb0, + 0x70, 0x5e, 0xa8, 0xad, 0xca, 0xaf, 0xd1, 0xb0, 0xe8, 0xea, 0x64, 0x11, 0x1c, 0xb4, 0x44, 0x84, + 0x6a, 0x75, 0xae, 0x48, 0x00, 0x8e, 0x71, 0xec, 0xff, 0x51, 0x82, 0xc9, 0x0c, 0xdd, 0x0a, 0x4b, + 0x86, 0x97, 0x78, 0xa4, 0xc4, 0xb9, 0xef, 0xcc, 0x40, 0xdc, 0xa5, 0x43, 0x04, 0xe2, 0x2e, 0xf7, + 0x0a, 0xc4, 0x3d, 0xf0, 0x76, 0x02, 0x71, 0x9b, 0x23, 0x36, 0xd8, 0xd7, 0x88, 0x65, 0x04, 0xef, + 0x1e, 0x3a, 0x64, 0xf0, 0x6e, 0x63, 0xd0, 0x87, 0xfb, 0x18, 0xf4, 0x1f, 0x2d, 0xc1, 0x54, 0xd2, + 0x94, 0xf4, 0x18, 0xe4, 0xb6, 0xaf, 0x19, 0x72, 0xdb, 0x8b, 0xfd, 0x38, 0xdf, 0xe6, 0xca, 0x70, + 0x71, 0x42, 0x86, 0xfb, 0xfe, 0xbe, 0xa8, 0x15, 0xcb, 0x73, 0xff, 0x46, 0x09, 0x4e, 0x65, 0x7a, + 0xff, 0x1e, 0xc3, 0xd8, 0xdc, 0x30, 0xc6, 0xe6, 0xd9, 0xbe, 0x1d, 0x93, 0x73, 0x07, 0xe8, 0x76, + 0x62, 0x80, 0x2e, 0xf5, 0x4f, 0xb2, 0x78, 0x94, 0xbe, 0x56, 0x86, 0x73, 0x99, 0xf5, 0x62, 0xb1, + 0xe7, 0x8a, 0x21, 0xf6, 0x7c, 0x2e, 0x21, 0xf6, 0xb4, 0x8b, 0x6b, 0x1f, 0x8d, 0x1c, 0x54, 0x38, + 0xe8, 0xb2, 0x30, 0x03, 0x0f, 0x28, 0x03, 0x35, 0x1c, 0x74, 0x15, 0x21, 0x6c, 0xd2, 0xfd, 0x56, + 0x92, 0x7d, 0xfe, 0x5b, 0x0b, 0xce, 0x64, 0xce, 0xcd, 0x31, 0xc8, 0xba, 0xd6, 0x4d, 0x59, 0xd7, + 0x53, 0x7d, 0xaf, 0xd6, 0x1c, 0xe1, 0xd7, 0x97, 0x07, 0x73, 0xbe, 0x85, 0xbd, 0xe4, 0x6f, 0xc0, + 0xa8, 0xd3, 0x68, 0x90, 0x30, 0x5c, 0xf3, 0x9b, 0x2a, 0xd6, 0xf0, 0xb3, 0xec, 0x9d, 0x15, 0x17, + 0xdf, 0x3f, 0x98, 0x9b, 0x4d, 0x92, 0x88, 0xc1, 0x58, 0xa7, 0x80, 0x3e, 0x09, 0x23, 0xa1, 0xb8, + 0x37, 0xc5, 0xdc, 0x3f, 0xdf, 0xe7, 0xe0, 0x38, 0x9b, 0xa4, 0x65, 0x06, 0x43, 0x52, 0x92, 0x0a, + 0x45, 0xd2, 0x0c, 0x9c, 0x52, 0x3a, 0xd2, 0xc0, 0x29, 0xcf, 0x01, 0xec, 0xa9, 0xc7, 0x40, 0x52, + 0xfe, 0xa0, 0x3d, 0x13, 0x34, 0x2c, 0xf4, 0x51, 0x98, 0x0a, 0x79, 0xb4, 0xc0, 0xa5, 0x96, 0x13, + 0x32, 0x3f, 0x1a, 0xb1, 0x0a, 0x59, 0xc0, 0xa5, 0x7a, 0x02, 0x86, 0x53, 0xd8, 0x68, 0x45, 0xb6, + 0xca, 0x42, 0x1b, 0xf2, 0x85, 0x79, 0x21, 0x6e, 0x51, 0xa4, 0xe2, 0x3d, 0x99, 0x1c, 0x7e, 0x36, + 0xf0, 0x5a, 0x4d, 0xf4, 0x49, 0x00, 0xba, 0x7c, 0x84, 0x1c, 0x62, 0x38, 0xff, 0xf0, 0xa4, 0xa7, + 0x4a, 0x33, 0xd3, 0xb8, 0x99, 0xf9, 0xd4, 0x56, 0x15, 0x11, 0xac, 0x11, 0x44, 0x5b, 0x30, 0x1e, + 0xff, 0x8b, 0x33, 0x55, 0x1e, 0xb2, 0x05, 0x26, 0xf7, 0xae, 0xea, 0x74, 0xb0, 0x49, 0xd6, 0xfe, + 0xf1, 0x61, 0x78, 0xb4, 0xe0, 0x2c, 0x46, 0x0b, 0xa6, 0xbe, 0xf7, 0xe9, 0xe4, 0x23, 0x7e, 0x36, + 0xb3, 0xb2, 0xf1, 0xaa, 0x4f, 0x2c, 0xf9, 0xd2, 0xdb, 0x5e, 0xf2, 0x3f, 0x64, 0x69, 0xe2, 0x15, + 0x6e, 0x59, 0xfa, 0x91, 0x43, 0xde, 0x31, 0x47, 0x28, 0x6f, 0xd9, 0xca, 0x10, 0x5a, 0x3c, 0xd7, + 0x77, 0x77, 0xfa, 0x97, 0x62, 0x7c, 0xc5, 0x02, 0x24, 0xc4, 0x2b, 0xa4, 0xa9, 0x36, 0x94, 0x90, + 0x67, 0x5c, 0x39, 0xec, 0xf7, 0x2f, 0xa4, 0x28, 0xf1, 0x91, 0x78, 0x59, 0x5e, 0x06, 0x69, 0x84, + 0x9e, 0x63, 0x92, 0xd1, 0x3d, 0xf4, 0x71, 0x16, 0x4d, 0xd7, 0x7d, 0x4b, 0x70, 0x40, 0x62, 0xc3, + 0xbd, 0x28, 0x22, 0xe9, 0xaa, 0x72, 0xca, 0xea, 0x66, 0x76, 0x57, 0x47, 0xc2, 0x06, 0xa9, 0xe3, + 0x7d, 0x7f, 0x77, 0xe1, 0x91, 0x9c, 0x21, 0x7b, 0xa8, 0xcf, 0xf0, 0xdf, 0xb2, 0xe0, 0x6c, 0x61, + 0x58, 0x98, 0x6f, 0x42, 0x06, 0xd1, 0xfe, 0x9c, 0x05, 0xd9, 0x93, 0x6d, 0x98, 0x95, 0x5d, 0x82, + 0x4a, 0x83, 0x16, 0x6a, 0x7e, 0xc0, 0x71, 0x80, 0x04, 0x09, 0xc0, 0x31, 0x8e, 0x61, 0x3d, 0x56, + 0xea, 0x69, 0x3d, 0xf6, 0x2b, 0x16, 0xa4, 0x0e, 0xf9, 0x63, 0xe0, 0x36, 0x56, 0x4d, 0x6e, 0xe3, + 0xbd, 0xfd, 0x8c, 0x66, 0x0e, 0xa3, 0xf1, 0xc7, 0x93, 0x70, 0x3a, 0xc7, 0x2d, 0x6f, 0x0f, 0xa6, + 0xb7, 0x1b, 0xc4, 0xf4, 0xb0, 0x2e, 0x8a, 0x3c, 0x54, 0xe8, 0x8e, 0xcd, 0x92, 0xc3, 0x4e, 0xa7, + 0x50, 0x70, 0xba, 0x09, 0xf4, 0x39, 0x0b, 0x4e, 0x3a, 0x77, 0xc2, 0x65, 0xca, 0x35, 0xba, 0x8d, + 0xc5, 0x96, 0xdf, 0xd8, 0xa5, 0x57, 0xb2, 0xdc, 0x08, 0x2f, 0x64, 0x4a, 0xf2, 0x6e, 0xd7, 0x53, + 0xf8, 0x46, 0xf3, 0x2c, 0x5b, 0x6e, 0x16, 0x16, 0xce, 0x6c, 0x0b, 0x61, 0x91, 0x42, 0x81, 0xbe, + 0x49, 0x0b, 0x62, 0x00, 0x64, 0xf9, 0x4f, 0x72, 0x36, 0x48, 0x42, 0xb0, 0xa2, 0x83, 0x3e, 0x0d, + 0x95, 0x6d, 0xe9, 0xee, 0x9b, 0xc1, 0x66, 0xc5, 0x03, 0x59, 0xec, 0x04, 0xcd, 0xd5, 0xf1, 0x0a, + 0x09, 0xc7, 0x44, 0xd1, 0xab, 0x50, 0xf6, 0xb6, 0xc2, 0xa2, 0x84, 0xb3, 0x09, 0xbb, 0x4b, 0x1e, + 0x69, 0x63, 0x7d, 0xa5, 0x8e, 0x69, 0x45, 0x74, 0x15, 0xca, 0xc1, 0x66, 0x53, 0x88, 0xa1, 0x33, + 0x37, 0x29, 0x5e, 0xac, 0xe6, 0xf4, 0x8a, 0x51, 0xc2, 0x8b, 0x55, 0x4c, 0x49, 0xa0, 0x1a, 0x0c, + 0x32, 0x5f, 0x36, 0xc1, 0xd4, 0x64, 0x3e, 0xdf, 0x0a, 0x7c, 0x42, 0x79, 0x38, 0x0e, 0x86, 0x80, + 0x39, 0x21, 0xb4, 0x01, 0x43, 0x0d, 0x96, 0x9c, 0x54, 0x70, 0x31, 0x1f, 0xc8, 0x14, 0x38, 0x17, + 0x64, 0x6d, 0x15, 0xf2, 0x57, 0x86, 0x81, 0x05, 0x2d, 0x46, 0x95, 0x74, 0x76, 0xb6, 0x42, 0x91, + 0x4c, 0x3b, 0x9b, 0x6a, 0x41, 0x32, 0x62, 0x41, 0x95, 0x61, 0x60, 0x41, 0x0b, 0xbd, 0x0c, 0xa5, + 0xad, 0x86, 0xf0, 0x53, 0xcb, 0x94, 0x3c, 0x9b, 0xc1, 0x52, 0x16, 0x87, 0xee, 0x1d, 0xcc, 0x95, + 0x56, 0x96, 0x70, 0x69, 0xab, 0x81, 0xd6, 0x61, 0x78, 0x8b, 0x87, 0x57, 0x10, 0xc2, 0xe5, 0x27, + 0xb3, 0x23, 0x3f, 0xa4, 0x22, 0x30, 0x70, 0x9f, 0x27, 0x01, 0xc0, 0x92, 0x08, 0xcb, 0x48, 0xa0, + 0xc2, 0x44, 0x88, 0x28, 0x75, 0xf3, 0x87, 0x0b, 0xed, 0xc1, 0x99, 0xcc, 0x38, 0xd8, 0x04, 0xd6, + 0x28, 0xd2, 0x55, 0xed, 0xbc, 0xd5, 0x0d, 0x58, 0x28, 0x70, 0x11, 0xce, 0x28, 0x73, 0x55, 0x2f, + 0x48, 0xa4, 0xa2, 0x55, 0xad, 0x90, 0x70, 0x4c, 0x14, 0xed, 0xc2, 0xf8, 0x5e, 0xd8, 0xd9, 0x21, + 0x72, 0x4b, 0xb3, 0xe8, 0x46, 0x39, 0xfc, 0xd1, 0x2d, 0x81, 0xe8, 0x06, 0x51, 0xd7, 0x69, 0xa5, + 0x4e, 0x21, 0xc6, 0xcb, 0xde, 0xd2, 0x89, 0x61, 0x93, 0x36, 0x1d, 0xfe, 0x37, 0xbb, 0xfe, 0xe6, + 0x7e, 0x44, 0x44, 0x70, 0xb9, 0xcc, 0xe1, 0x7f, 0x9d, 0xa3, 0xa4, 0x87, 0x5f, 0x00, 0xb0, 0x24, + 0x82, 0x6e, 0x89, 0xe1, 0x61, 0xa7, 0xe7, 0x54, 0x7e, 0x04, 0xd8, 0x05, 0x89, 0x94, 0x33, 0x28, + 0xec, 0xb4, 0x8c, 0x49, 0xb1, 0x53, 0xb2, 0xb3, 0xe3, 0x47, 0xbe, 0x97, 0x38, 0xa1, 0xa7, 0xf3, + 0x4f, 0xc9, 0x5a, 0x06, 0x7e, 0xfa, 0x94, 0xcc, 0xc2, 0xc2, 0x99, 0x6d, 0xa1, 0x26, 0x4c, 0x74, + 0xfc, 0x20, 0xba, 0xe3, 0x07, 0x72, 0x7d, 0xa1, 0x02, 0xe1, 0x98, 0x81, 0x29, 0x5a, 0x64, 0x71, + 0x1b, 0x4d, 0x08, 0x4e, 0xd0, 0x44, 0x1f, 0x83, 0xe1, 0xb0, 0xe1, 0xb4, 0xc8, 0xea, 0x8d, 0x99, + 0x13, 0xf9, 0xd7, 0x4f, 0x9d, 0xa3, 0xe4, 0xac, 0x2e, 0x1e, 0x1d, 0x83, 0xa3, 0x60, 0x49, 0x0e, + 0xad, 0xc0, 0x20, 0xcb, 0x38, 0xc7, 0x22, 0x21, 0xe6, 0x04, 0xb2, 0x4d, 0x59, 0xc1, 0xf3, 0xb3, + 0x89, 0x15, 0x63, 0x5e, 0x9d, 0xee, 0x01, 0xf1, 0x46, 0xf4, 0xc3, 0x99, 0x53, 0xf9, 0x7b, 0x40, + 0x3c, 0x2d, 0x6f, 0xd4, 0x8b, 0xf6, 0x80, 0x42, 0xc2, 0x31, 0x51, 0x7a, 0x32, 0xd3, 0xd3, 0xf4, + 0x74, 0x81, 0xf9, 0x56, 0xee, 0x59, 0xca, 0x4e, 0x66, 0x7a, 0x92, 0x52, 0x12, 0xf6, 0xef, 0x0d, + 0xa7, 0x79, 0x16, 0x26, 0x55, 0xf8, 0x1e, 0x2b, 0xa5, 0x70, 0xfe, 0x60, 0xbf, 0x42, 0xce, 0x23, + 0x7c, 0x0a, 0x7d, 0xce, 0x82, 0xd3, 0x9d, 0xcc, 0x0f, 0x11, 0x0c, 0x40, 0x7f, 0xb2, 0x52, 0xfe, + 0xe9, 0x2a, 0x6a, 0x66, 0x36, 0x1c, 0xe7, 0xb4, 0x94, 0x7c, 0x6e, 0x96, 0xdf, 0xf6, 0x73, 0x73, + 0x0d, 0x46, 0x1a, 0xfc, 0x29, 0x52, 0x98, 0xac, 0x3b, 0xf9, 0xf6, 0x66, 0xac, 0x84, 0x78, 0xc3, + 0x6c, 0x61, 0x45, 0x02, 0xfd, 0xb0, 0x05, 0x67, 0x93, 0x5d, 0xc7, 0x84, 0x81, 0x45, 0xa8, 0x4d, + 0x2e, 0xd0, 0x58, 0x11, 0xdf, 0x9f, 0xe2, 0xff, 0x0d, 0xe4, 0xfb, 0xbd, 0x10, 0x70, 0x71, 0x63, + 0xa8, 0x9a, 0x21, 0x51, 0x19, 0x32, 0xb5, 0x48, 0x7d, 0x48, 0x55, 0x5e, 0x80, 0xb1, 0xb6, 0xdf, + 0xf5, 0x22, 0x61, 0xed, 0x25, 0x2c, 0x4f, 0x98, 0xc5, 0xc5, 0x9a, 0x56, 0x8e, 0x0d, 0xac, 0x84, + 0x2c, 0x66, 0xe4, 0x81, 0x65, 0x31, 0x6f, 0xc0, 0x98, 0xa7, 0x99, 0x27, 0x0b, 0x7e, 0xe0, 0x42, + 0x7e, 0x98, 0x5c, 0xdd, 0x98, 0x99, 0xf7, 0x52, 0x2f, 0xc1, 0x06, 0xb5, 0xe3, 0x35, 0x03, 0xfb, + 0x92, 0x95, 0xc1, 0xd4, 0x73, 0x51, 0xcc, 0x87, 0x4d, 0x51, 0xcc, 0x85, 0xa4, 0x28, 0x26, 0xa5, + 0x41, 0x30, 0xa4, 0x30, 0xfd, 0x67, 0x01, 0xea, 0x37, 0xd4, 0xa6, 0xdd, 0x82, 0xf3, 0xbd, 0xae, + 0x25, 0x66, 0xf6, 0xd7, 0x54, 0xfa, 0xe2, 0xd8, 0xec, 0xaf, 0xb9, 0x5a, 0xc5, 0x0c, 0xd2, 0x6f, + 0x10, 0x27, 0xfb, 0xbf, 0x59, 0x50, 0xae, 0xf9, 0xcd, 0x63, 0x78, 0xf0, 0x7e, 0xc4, 0x78, 0xf0, + 0x3e, 0x9a, 0x7d, 0x21, 0x36, 0x73, 0xf5, 0x1f, 0xcb, 0x09, 0xfd, 0xc7, 0xd9, 0x3c, 0x02, 0xc5, + 0xda, 0x8e, 0x9f, 0x2a, 0xc3, 0x68, 0xcd, 0x6f, 0x2a, 0x9b, 0xfb, 0x7f, 0xf1, 0x20, 0x36, 0xf7, + 0xb9, 0xb9, 0x2c, 0x34, 0xca, 0xcc, 0x5a, 0x50, 0xba, 0x1b, 0x7f, 0x93, 0x99, 0xde, 0xdf, 0x26, + 0xee, 0xf6, 0x4e, 0x44, 0x9a, 0xc9, 0xcf, 0x39, 0x3e, 0xd3, 0xfb, 0xdf, 0x2b, 0xc1, 0x64, 0xa2, + 0x75, 0xd4, 0x82, 0xf1, 0x96, 0x2e, 0x5d, 0x17, 0xeb, 0xf4, 0x81, 0x04, 0xf3, 0xc2, 0x74, 0x59, + 0x2b, 0xc2, 0x26, 0x71, 0x34, 0x0f, 0xa0, 0xd4, 0xcd, 0x52, 0xbc, 0xca, 0xb8, 0x7e, 0xa5, 0x8f, + 0x0e, 0xb1, 0x86, 0x81, 0x5e, 0x84, 0xd1, 0xc8, 0xef, 0xf8, 0x2d, 0x7f, 0x7b, 0xff, 0x1a, 0x91, + 0xf1, 0xbd, 0x94, 0x41, 0xe2, 0x46, 0x0c, 0xc2, 0x3a, 0x1e, 0xba, 0x0b, 0xd3, 0x8a, 0x48, 0xfd, + 0x08, 0x34, 0x0e, 0x4c, 0xaa, 0xb0, 0x9e, 0xa4, 0x88, 0xd3, 0x8d, 0xd8, 0x3f, 0x53, 0xe6, 0x43, + 0xec, 0x45, 0xee, 0xbb, 0xbb, 0xe1, 0x9d, 0xbd, 0x1b, 0xbe, 0x66, 0xc1, 0x14, 0x6d, 0x9d, 0x59, + 0x5b, 0xc9, 0x6b, 0x5e, 0x05, 0xe6, 0xb6, 0x0a, 0x02, 0x73, 0x5f, 0xa0, 0xa7, 0x66, 0xd3, 0xef, + 0x46, 0x42, 0x76, 0xa7, 0x1d, 0x8b, 0xb4, 0x14, 0x0b, 0xa8, 0xc0, 0x23, 0x41, 0x20, 0x3c, 0x44, + 0x75, 0x3c, 0x12, 0x04, 0x58, 0x40, 0x65, 0xdc, 0xee, 0x81, 0xec, 0xb8, 0xdd, 0x3c, 0xfc, 0xaa, + 0xb0, 0xcb, 0x11, 0x0c, 0x97, 0x16, 0x7e, 0x55, 0x1a, 0xec, 0xc4, 0x38, 0xf6, 0x57, 0xca, 0x30, + 0x56, 0xf3, 0x9b, 0xb1, 0xaa, 0xf9, 0x05, 0x43, 0xd5, 0x7c, 0x3e, 0xa1, 0x6a, 0x9e, 0xd2, 0x71, + 0xdf, 0x55, 0x2c, 0x7f, 0xa3, 0x14, 0xcb, 0xff, 0xd4, 0x62, 0xb3, 0x56, 0x5d, 0xaf, 0x73, 0xe3, + 0x3d, 0x74, 0x19, 0x46, 0xd9, 0x01, 0xc3, 0x5c, 0x92, 0xa5, 0xfe, 0x95, 0xe5, 0xa3, 0x5a, 0x8f, + 0x8b, 0xb1, 0x8e, 0x83, 0x2e, 0xc2, 0x48, 0x48, 0x9c, 0xa0, 0xb1, 0xa3, 0x4e, 0x57, 0xa1, 0x2c, + 0xe5, 0x65, 0x58, 0x41, 0xd1, 0xeb, 0x71, 0xe4, 0xcf, 0x72, 0xbe, 0x8b, 0xa3, 0xde, 0x1f, 0xbe, + 0x45, 0xf2, 0xc3, 0x7d, 0xda, 0xb7, 0x01, 0xa5, 0xf1, 0xfb, 0x88, 0x4d, 0x37, 0x67, 0xc6, 0xa6, + 0xab, 0xa4, 0xe2, 0xd2, 0xfd, 0x99, 0x05, 0x13, 0x35, 0xbf, 0x49, 0xb7, 0xee, 0xb7, 0xd2, 0x3e, + 0xd5, 0xc3, 0x1e, 0x0f, 0x15, 0x84, 0x3d, 0x7e, 0x02, 0x06, 0x6b, 0x7e, 0x73, 0xb5, 0x56, 0x14, + 0x5f, 0xc0, 0xfe, 0x9b, 0x16, 0x0c, 0xd7, 0xfc, 0xe6, 0x31, 0xa8, 0x05, 0x3e, 0x6c, 0xaa, 0x05, + 0x1e, 0xc9, 0x59, 0x37, 0x39, 0x9a, 0x80, 0xbf, 0x3e, 0x00, 0xe3, 0xb4, 0x9f, 0xfe, 0xb6, 0x9c, + 0x4a, 0x63, 0xd8, 0xac, 0x3e, 0x86, 0x8d, 0x72, 0xe1, 0x7e, 0xab, 0xe5, 0xdf, 0x49, 0x4e, 0xeb, + 0x0a, 0x2b, 0xc5, 0x02, 0x8a, 0x9e, 0x81, 0x91, 0x4e, 0x40, 0xf6, 0x5c, 0x5f, 0xb0, 0xb7, 0x9a, + 0x92, 0xa5, 0x26, 0xca, 0xb1, 0xc2, 0xa0, 0xcf, 0xc2, 0xd0, 0xf5, 0xe8, 0x55, 0xde, 0xf0, 0xbd, + 0x26, 0x97, 0x9c, 0x97, 0x45, 0x6e, 0x0e, 0xad, 0x1c, 0x1b, 0x58, 0xe8, 0x36, 0x54, 0xd8, 0x7f, + 0x76, 0xec, 0x1c, 0x3e, 0xcb, 0xab, 0xc8, 0xfa, 0x27, 0x08, 0xe0, 0x98, 0x16, 0x7a, 0x0e, 0x20, + 0x92, 0xf1, 0xed, 0x43, 0x11, 0x6d, 0x4d, 0x3d, 0x05, 0x54, 0xe4, 0xfb, 0x10, 0x6b, 0x58, 0xe8, + 0x69, 0xa8, 0x44, 0x8e, 0xdb, 0xba, 0xee, 0x7a, 0x24, 0x64, 0x12, 0xf1, 0xb2, 0x4c, 0xbe, 0x27, + 0x0a, 0x71, 0x0c, 0xa7, 0xac, 0x18, 0x8b, 0xc4, 0xc1, 0x73, 0x44, 0x8f, 0x30, 0x6c, 0xc6, 0x8a, + 0x5d, 0x57, 0xa5, 0x58, 0xc3, 0x40, 0x3b, 0xf0, 0x98, 0xeb, 0xb1, 0x3c, 0x16, 0xa4, 0xbe, 0xeb, + 0x76, 0x36, 0xae, 0xd7, 0x6f, 0x91, 0xc0, 0xdd, 0xda, 0x5f, 0x74, 0x1a, 0xbb, 0xc4, 0x93, 0xf9, + 0x3b, 0xdf, 0x2b, 0xba, 0xf8, 0xd8, 0x6a, 0x01, 0x2e, 0x2e, 0xa4, 0x64, 0x3f, 0xcf, 0xd6, 0xfb, + 0x8d, 0x3a, 0x7a, 0xbf, 0x71, 0x74, 0x9c, 0xd6, 0x8f, 0x8e, 0xfb, 0x07, 0x73, 0x43, 0x37, 0xea, + 0x5a, 0x20, 0x89, 0x97, 0xe0, 0x54, 0xcd, 0x6f, 0xd6, 0xfc, 0x20, 0x5a, 0xf1, 0x83, 0x3b, 0x4e, + 0xd0, 0x94, 0xcb, 0x6b, 0x4e, 0x86, 0xd2, 0xa0, 0xe7, 0xe7, 0x20, 0x3f, 0x5d, 0x8c, 0x30, 0x19, + 0xcf, 0x33, 0x8e, 0xed, 0x90, 0x0e, 0x60, 0x0d, 0xc6, 0x3b, 0xa8, 0x4c, 0x30, 0x57, 0x9c, 0x88, + 0xa0, 0x1b, 0x2c, 0xc3, 0x75, 0x7c, 0x8d, 0x8a, 0xea, 0x4f, 0x69, 0x19, 0xae, 0x63, 0x60, 0xe6, + 0xbd, 0x6b, 0xd6, 0xb7, 0xff, 0xfb, 0x20, 0x3b, 0x51, 0x13, 0xd9, 0x44, 0xd0, 0xa7, 0x60, 0x22, + 0x24, 0xd7, 0x5d, 0xaf, 0x7b, 0x57, 0x8a, 0x30, 0x0a, 0x5c, 0xf8, 0xea, 0xcb, 0x3a, 0x26, 0x17, + 0x84, 0x9a, 0x65, 0x38, 0x41, 0x0d, 0xb5, 0x61, 0xe2, 0x8e, 0xeb, 0x35, 0xfd, 0x3b, 0xa1, 0xa4, + 0x3f, 0x92, 0x2f, 0x0f, 0xbd, 0xcd, 0x31, 0x13, 0x7d, 0x34, 0x9a, 0xbb, 0x6d, 0x10, 0xc3, 0x09, + 0xe2, 0x74, 0xd5, 0x06, 0x5d, 0x6f, 0x21, 0xbc, 0x19, 0x92, 0x40, 0xe4, 0x2a, 0x67, 0xab, 0x16, + 0xcb, 0x42, 0x1c, 0xc3, 0xe9, 0xaa, 0x65, 0x7f, 0xae, 0x04, 0x7e, 0x97, 0xa7, 0xae, 0x10, 0xab, + 0x16, 0xab, 0x52, 0xac, 0x61, 0xd0, 0x5d, 0xcd, 0xfe, 0xad, 0xfb, 0x1e, 0xf6, 0xfd, 0x48, 0x9e, + 0x03, 0x4c, 0xa7, 0xaf, 0x95, 0x63, 0x03, 0x0b, 0xad, 0x00, 0x0a, 0xbb, 0x9d, 0x4e, 0x8b, 0xd9, + 0x06, 0x39, 0x2d, 0x46, 0x8a, 0xdb, 0x4b, 0x94, 0x79, 0xe8, 0xdd, 0x7a, 0x0a, 0x8a, 0x33, 0x6a, + 0xd0, 0x03, 0x7e, 0x4b, 0x74, 0x75, 0x90, 0x75, 0x95, 0xeb, 0x4e, 0xea, 0xbc, 0x9f, 0x12, 0x86, + 0x96, 0x61, 0x38, 0xdc, 0x0f, 0x1b, 0x91, 0x88, 0x94, 0x98, 0x93, 0x30, 0xaa, 0xce, 0x50, 0xb4, + 0x7c, 0x85, 0xbc, 0x0a, 0x96, 0x75, 0x51, 0x03, 0x4e, 0x08, 0x8a, 0x4b, 0x3b, 0x8e, 0xa7, 0xd2, + 0xef, 0x70, 0x13, 0xe9, 0xcb, 0xf7, 0x0e, 0xe6, 0x4e, 0x88, 0x96, 0x75, 0xf0, 0xfd, 0x83, 0xb9, + 0xd3, 0x35, 0xbf, 0x99, 0x01, 0xc1, 0x59, 0xd4, 0xf8, 0xe2, 0x6b, 0x34, 0xfc, 0x76, 0xa7, 0x16, + 0xf8, 0x5b, 0x6e, 0x8b, 0x14, 0xe9, 0x9f, 0xea, 0x06, 0xa6, 0x58, 0x7c, 0x46, 0x19, 0x4e, 0x50, + 0xb3, 0xbf, 0x93, 0x31, 0x41, 0x2c, 0x3d, 0x77, 0xd4, 0x0d, 0x08, 0x6a, 0xc3, 0x78, 0x87, 0x6d, + 0x13, 0x91, 0x50, 0x42, 0xac, 0xf5, 0x17, 0xfa, 0x94, 0xa3, 0xdc, 0xa1, 0x77, 0x87, 0x69, 0x63, + 0x54, 0xd3, 0xc9, 0x61, 0x93, 0xba, 0xfd, 0x1b, 0x8f, 0xb0, 0x6b, 0xb4, 0xce, 0x85, 0x23, 0xc3, + 0xc2, 0x23, 0x43, 0xbc, 0xc7, 0x66, 0xf3, 0xa5, 0x74, 0xf1, 0xb4, 0x08, 0xaf, 0x0e, 0x2c, 0xeb, + 0xa2, 0x4f, 0xc2, 0x04, 0x7d, 0xde, 0xa8, 0xab, 0x2c, 0x9c, 0x39, 0x99, 0x1f, 0x39, 0x43, 0x61, + 0xe9, 0xc9, 0x66, 0xf4, 0xca, 0x38, 0x41, 0x0c, 0xbd, 0xce, 0x6c, 0x7a, 0x24, 0xe9, 0x52, 0x3f, + 0xa4, 0x75, 0xf3, 0x1d, 0x49, 0x56, 0x23, 0x82, 0xba, 0x70, 0x22, 0x9d, 0x9a, 0x2e, 0x9c, 0xb1, + 0xf3, 0xf9, 0xc4, 0x74, 0x76, 0xb9, 0x38, 0x2b, 0x48, 0x1a, 0x16, 0xe2, 0x2c, 0xfa, 0xe8, 0x3a, + 0x8c, 0x8b, 0x1c, 0xd5, 0x62, 0xe5, 0x96, 0x0d, 0xe1, 0xe1, 0x38, 0xd6, 0x81, 0xf7, 0x93, 0x05, + 0xd8, 0xac, 0x8c, 0xb6, 0xe1, 0xac, 0x96, 0x33, 0xea, 0x4a, 0xe0, 0x30, 0x0b, 0x00, 0x97, 0x1d, + 0xa7, 0xda, 0x05, 0xff, 0xf8, 0xbd, 0x83, 0xb9, 0xb3, 0x1b, 0x45, 0x88, 0xb8, 0x98, 0x0e, 0xba, + 0x01, 0xa7, 0xb8, 0xdf, 0x77, 0x95, 0x38, 0xcd, 0x96, 0xeb, 0x29, 0x0e, 0x82, 0x6f, 0xf9, 0x33, + 0xf7, 0x0e, 0xe6, 0x4e, 0x2d, 0x64, 0x21, 0xe0, 0xec, 0x7a, 0xe8, 0xc3, 0x50, 0x69, 0x7a, 0xa1, + 0x18, 0x83, 0x21, 0x23, 0x2d, 0x57, 0xa5, 0xba, 0x5e, 0x57, 0xdf, 0x1f, 0xff, 0xc1, 0x71, 0x05, + 0xb4, 0xcd, 0x05, 0xcc, 0x4a, 0xec, 0x31, 0x9c, 0x8a, 0x7b, 0x95, 0x94, 0x0c, 0x1a, 0x9e, 0x9f, + 0x5c, 0xb3, 0xa2, 0x1c, 0x22, 0x0c, 0xa7, 0x50, 0x83, 0x30, 0x7a, 0x0d, 0x90, 0x08, 0xff, 0xbe, + 0xd0, 0x60, 0xd9, 0x4a, 0x98, 0x3c, 0x7e, 0xc4, 0xf4, 0x45, 0xac, 0xa7, 0x30, 0x70, 0x46, 0x2d, + 0x74, 0x95, 0x9e, 0x2a, 0x7a, 0xa9, 0x38, 0xb5, 0x54, 0x12, 0xc5, 0x2a, 0xe9, 0x04, 0x84, 0x59, + 0x34, 0x99, 0x14, 0x71, 0xa2, 0x1e, 0x6a, 0xc2, 0x63, 0x4e, 0x37, 0xf2, 0x99, 0xec, 0xde, 0x44, + 0xdd, 0xf0, 0x77, 0x89, 0xc7, 0xd4, 0x66, 0x23, 0x8b, 0xe7, 0x29, 0x8b, 0xb2, 0x50, 0x80, 0x87, + 0x0b, 0xa9, 0x50, 0xd6, 0x52, 0x65, 0x4d, 0x06, 0x33, 0x9a, 0x57, 0x46, 0xe6, 0xe4, 0x17, 0x61, + 0x74, 0xc7, 0x0f, 0xa3, 0x75, 0x12, 0xdd, 0xf1, 0x83, 0x5d, 0x11, 0x95, 0x36, 0x8e, 0xf1, 0x1d, + 0x83, 0xb0, 0x8e, 0x47, 0xdf, 0x8e, 0xcc, 0xa8, 0x63, 0xb5, 0xca, 0xf4, 0xe9, 0x23, 0xf1, 0x19, + 0x73, 0x95, 0x17, 0x63, 0x09, 0x97, 0xa8, 0xab, 0xb5, 0x25, 0xa6, 0x1b, 0x4f, 0xa0, 0xae, 0xd6, + 0x96, 0xb0, 0x84, 0xd3, 0xe5, 0x1a, 0xee, 0x38, 0x01, 0xa9, 0x05, 0x7e, 0x83, 0x84, 0x5a, 0x64, + 0xf9, 0x47, 0x79, 0xcc, 0x5d, 0xba, 0x5c, 0xeb, 0x59, 0x08, 0x38, 0xbb, 0x1e, 0x22, 0xe9, 0x7c, + 0x69, 0x13, 0xf9, 0x4a, 0x8d, 0x34, 0x3f, 0xd3, 0x67, 0xca, 0x34, 0x0f, 0xa6, 0x54, 0xa6, 0x36, + 0x1e, 0x65, 0x37, 0x9c, 0x99, 0x64, 0x6b, 0xbb, 0xff, 0x10, 0xbd, 0x4a, 0x4d, 0xb4, 0x9a, 0xa0, + 0x84, 0x53, 0xb4, 0x8d, 0x80, 0x6d, 0x53, 0x3d, 0x03, 0xb6, 0x5d, 0x82, 0x4a, 0xd8, 0xdd, 0x6c, + 0xfa, 0x6d, 0xc7, 0xf5, 0x98, 0x6e, 0x5c, 0x7b, 0xc4, 0xd4, 0x25, 0x00, 0xc7, 0x38, 0x68, 0x05, + 0x46, 0x1c, 0xa9, 0x03, 0x42, 0xf9, 0x21, 0x7a, 0x94, 0xe6, 0x87, 0x47, 0xad, 0x90, 0x5a, 0x1f, + 0x55, 0x17, 0xbd, 0x02, 0xe3, 0xc2, 0x6f, 0x59, 0x24, 0x09, 0x3d, 0x61, 0x3a, 0x97, 0xd5, 0x75, + 0x20, 0x36, 0x71, 0xd1, 0x4d, 0x18, 0x8d, 0xfc, 0x16, 0xf3, 0x90, 0xa2, 0x6c, 0xde, 0xe9, 0xfc, + 0x60, 0x73, 0x1b, 0x0a, 0x4d, 0x17, 0xbf, 0xaa, 0xaa, 0x58, 0xa7, 0x83, 0x36, 0xf8, 0x7a, 0x67, + 0x71, 0xe4, 0x49, 0x38, 0xf3, 0x48, 0xfe, 0x9d, 0xa4, 0xc2, 0xcd, 0x9b, 0xdb, 0x41, 0xd4, 0xc4, + 0x3a, 0x19, 0x74, 0x05, 0xa6, 0x3b, 0x81, 0xeb, 0xb3, 0x35, 0xa1, 0xd4, 0x7f, 0x33, 0x66, 0xd6, + 0xa8, 0x5a, 0x12, 0x01, 0xa7, 0xeb, 0x30, 0xb7, 0x73, 0x51, 0x38, 0x73, 0x86, 0x67, 0xbe, 0xe0, + 0x6f, 0x42, 0x5e, 0x86, 0x15, 0x14, 0xad, 0xb1, 0x93, 0x98, 0x8b, 0x33, 0x66, 0x66, 0xf3, 0xa3, + 0x02, 0xe9, 0x62, 0x0f, 0xce, 0xbc, 0xaa, 0xbf, 0x38, 0xa6, 0x80, 0x9a, 0x5a, 0xc2, 0x49, 0xfa, + 0x62, 0x08, 0x67, 0x1e, 0x2b, 0xb0, 0xac, 0x4b, 0x3c, 0x2f, 0x62, 0x86, 0xc0, 0x28, 0x0e, 0x71, + 0x82, 0x26, 0xfa, 0x28, 0x4c, 0x89, 0x58, 0x86, 0xf1, 0x30, 0x9d, 0x8d, 0xed, 0xce, 0x71, 0x02, + 0x86, 0x53, 0xd8, 0x3c, 0xf3, 0x84, 0xb3, 0xd9, 0x22, 0xe2, 0xe8, 0xbb, 0xee, 0x7a, 0xbb, 0xe1, + 0xcc, 0x39, 0x76, 0x3e, 0x88, 0xcc, 0x13, 0x49, 0x28, 0xce, 0xa8, 0x81, 0x36, 0x60, 0xaa, 0x13, + 0x10, 0xd2, 0x66, 0x8c, 0xbe, 0xb8, 0xcf, 0xe6, 0x78, 0xd4, 0x05, 0xda, 0x93, 0x5a, 0x02, 0x76, + 0x3f, 0xa3, 0x0c, 0xa7, 0x28, 0xa0, 0x3b, 0x30, 0xe2, 0xef, 0x91, 0x60, 0x87, 0x38, 0xcd, 0x99, + 0xf3, 0x05, 0x7e, 0x10, 0xe2, 0x72, 0xbb, 0x21, 0x70, 0x13, 0x26, 0x03, 0xb2, 0xb8, 0xb7, 0xc9, + 0x80, 0x6c, 0x0c, 0xfd, 0x88, 0x05, 0x67, 0xa4, 0x96, 0xa1, 0xde, 0xa1, 0xa3, 0xbe, 0xe4, 0x7b, + 0x61, 0x14, 0xf0, 0x38, 0x01, 0x8f, 0xe7, 0xfb, 0xce, 0x6f, 0xe4, 0x54, 0x52, 0x12, 0xd5, 0x33, + 0x79, 0x18, 0x21, 0xce, 0x6f, 0x11, 0x2d, 0xc1, 0x74, 0x48, 0x22, 0x79, 0x18, 0x2d, 0x84, 0x2b, + 0xaf, 0x57, 0xd7, 0x67, 0x9e, 0xe0, 0x41, 0x0e, 0xe8, 0x66, 0xa8, 0x27, 0x81, 0x38, 0x8d, 0x8f, + 0x2e, 0x43, 0xc9, 0x0f, 0x67, 0xde, 0x5b, 0x90, 0xa3, 0x94, 0x3e, 0xc5, 0xb9, 0xe9, 0xd8, 0x8d, + 0x3a, 0x2e, 0xf9, 0xe1, 0xec, 0xb7, 0xc3, 0x74, 0x8a, 0x63, 0x38, 0x4c, 0x6e, 0x9f, 0xd9, 0x5d, + 0x18, 0x37, 0x66, 0xe5, 0xa1, 0x6a, 0xa9, 0xff, 0xf5, 0x30, 0x54, 0x94, 0x06, 0x13, 0x5d, 0x32, + 0x15, 0xd3, 0x67, 0x92, 0x8a, 0xe9, 0x91, 0x9a, 0xdf, 0x34, 0x74, 0xd1, 0x1b, 0x19, 0xd1, 0xe0, + 0xf2, 0xce, 0x80, 0xfe, 0x0d, 0xe4, 0x35, 0xb1, 0x70, 0xb9, 0x6f, 0x0d, 0xf7, 0x40, 0xa1, 0xa4, + 0xf9, 0x0a, 0x4c, 0x7b, 0x3e, 0x63, 0x53, 0x49, 0x53, 0xf2, 0x20, 0x8c, 0xd5, 0xa8, 0xe8, 0xe1, + 0x55, 0x12, 0x08, 0x38, 0x5d, 0x87, 0x36, 0xc8, 0x79, 0x85, 0xa4, 0x68, 0x9b, 0xb3, 0x12, 0x58, + 0x40, 0xd1, 0x13, 0x30, 0xd8, 0xf1, 0x9b, 0xab, 0x35, 0xc1, 0xa2, 0x6a, 0x31, 0x48, 0x9b, 0xab, + 0x35, 0xcc, 0x61, 0x68, 0x01, 0x86, 0xd8, 0x8f, 0x70, 0x66, 0x2c, 0x3f, 0x8e, 0x06, 0xab, 0xa1, + 0x65, 0x4e, 0x62, 0x15, 0xb0, 0xa8, 0xc8, 0x44, 0x6c, 0x94, 0xaf, 0x67, 0x22, 0xb6, 0xe1, 0x07, + 0x14, 0xb1, 0x49, 0x02, 0x38, 0xa6, 0x85, 0xee, 0xc2, 0x29, 0xe3, 0x2d, 0xc5, 0x97, 0x08, 0x09, + 0x85, 0x2f, 0xff, 0x13, 0x85, 0x8f, 0x28, 0xa1, 0x11, 0x3f, 0x2b, 0x3a, 0x7d, 0x6a, 0x35, 0x8b, + 0x12, 0xce, 0x6e, 0x00, 0xb5, 0x60, 0xba, 0x91, 0x6a, 0x75, 0xa4, 0xff, 0x56, 0xd5, 0x84, 0xa6, + 0x5b, 0x4c, 0x13, 0x46, 0xaf, 0xc0, 0xc8, 0x9b, 0x7e, 0xc8, 0x8e, 0x77, 0xc1, 0x56, 0x4b, 0x47, + 0xf0, 0x91, 0xd7, 0x6f, 0xd4, 0x59, 0xf9, 0xfd, 0x83, 0xb9, 0xd1, 0x9a, 0xdf, 0x94, 0x7f, 0xb1, + 0xaa, 0x80, 0xbe, 0xdf, 0x82, 0xd9, 0xf4, 0x63, 0x4d, 0x75, 0x7a, 0xbc, 0xff, 0x4e, 0xdb, 0xa2, + 0xd1, 0xd9, 0xe5, 0x5c, 0x72, 0xb8, 0xa0, 0x29, 0xfb, 0x97, 0x2c, 0x26, 0xa8, 0x13, 0x9a, 0x26, + 0x12, 0x76, 0x5b, 0xc7, 0x91, 0x30, 0x76, 0xd9, 0x50, 0x82, 0x3d, 0xb0, 0x85, 0xc4, 0x3f, 0xb7, + 0x98, 0x85, 0xc4, 0x31, 0xba, 0x42, 0xbc, 0x0e, 0x23, 0x91, 0x4c, 0xe4, 0x5b, 0x90, 0xe3, 0x56, + 0xeb, 0x14, 0xb3, 0x12, 0x51, 0x4c, 0xae, 0xca, 0xd9, 0xab, 0xc8, 0xd8, 0xff, 0x88, 0xcf, 0x80, + 0x84, 0x1c, 0x83, 0xae, 0xa1, 0x6a, 0xea, 0x1a, 0xe6, 0x7a, 0x7c, 0x41, 0x8e, 0xce, 0xe1, 0x1f, + 0x9a, 0xfd, 0x66, 0xc2, 0x9d, 0x77, 0xba, 0x69, 0x8e, 0xfd, 0x79, 0x0b, 0x20, 0x0e, 0xf1, 0xdc, + 0x47, 0xaa, 0xb6, 0x97, 0x28, 0x5b, 0xeb, 0x47, 0x7e, 0xc3, 0x6f, 0x09, 0x4d, 0xda, 0x63, 0xb1, + 0xba, 0x83, 0x97, 0xdf, 0xd7, 0x7e, 0x63, 0x85, 0x8d, 0xe6, 0x64, 0x40, 0xb9, 0x72, 0xac, 0x80, + 0x33, 0x82, 0xc9, 0x7d, 0xd1, 0x82, 0x93, 0x59, 0x76, 0xb5, 0xf4, 0x91, 0xc4, 0xc5, 0x5c, 0xca, + 0x6c, 0x4a, 0xcd, 0xe6, 0x2d, 0x51, 0x8e, 0x15, 0x46, 0xdf, 0x39, 0xf0, 0x0e, 0x17, 0x5b, 0xf9, + 0x06, 0x8c, 0xd7, 0x02, 0xa2, 0x5d, 0xae, 0xaf, 0xf2, 0x20, 0x05, 0xbc, 0x3f, 0xcf, 0x1c, 0x3a, + 0x40, 0x81, 0xfd, 0xe5, 0x12, 0x9c, 0xe4, 0xd6, 0x07, 0x0b, 0x7b, 0xbe, 0xdb, 0xac, 0xf9, 0x4d, + 0xe1, 0x3d, 0xf5, 0x09, 0x18, 0xeb, 0x68, 0xb2, 0xc9, 0xa2, 0x38, 0xa1, 0xba, 0x0c, 0x33, 0x96, + 0xa6, 0xe8, 0xa5, 0xd8, 0xa0, 0x85, 0x9a, 0x30, 0x46, 0xf6, 0xdc, 0x86, 0x52, 0x61, 0x97, 0x0e, + 0x7d, 0xd1, 0xa9, 0x56, 0x96, 0x35, 0x3a, 0xd8, 0xa0, 0xfa, 0x10, 0x32, 0x53, 0xdb, 0x3f, 0x66, + 0xc1, 0x23, 0x39, 0x51, 0x45, 0x69, 0x73, 0x77, 0x98, 0x9d, 0x87, 0x58, 0xb6, 0xaa, 0x39, 0x6e, + 0xfd, 0x81, 0x05, 0x14, 0x7d, 0x0c, 0x80, 0x5b, 0x6f, 0xd0, 0x57, 0x7a, 0xaf, 0xf0, 0x8b, 0x46, + 0xe4, 0x38, 0x2d, 0x08, 0x98, 0xac, 0x8f, 0x35, 0x5a, 0xf6, 0x17, 0x07, 0x60, 0x90, 0x67, 0xd1, + 0xaf, 0xc1, 0xf0, 0x0e, 0xcf, 0x13, 0x53, 0x38, 0x6f, 0x14, 0x57, 0xa6, 0x9e, 0x89, 0xe7, 0x4d, + 0x2b, 0xc5, 0x92, 0x0c, 0x5a, 0x83, 0x13, 0x3c, 0x5d, 0x4f, 0xab, 0x4a, 0x5a, 0xce, 0xbe, 0x14, + 0xfb, 0xf1, 0xdc, 0xb2, 0x4a, 0xfc, 0xb9, 0x9a, 0x46, 0xc1, 0x59, 0xf5, 0xd0, 0xab, 0x30, 0x41, + 0x9f, 0x61, 0x7e, 0x37, 0x92, 0x94, 0x78, 0xa2, 0x1e, 0xf5, 0xee, 0xdb, 0x30, 0xa0, 0x38, 0x81, + 0x8d, 0x5e, 0x81, 0xf1, 0x4e, 0x4a, 0xc0, 0x39, 0x18, 0x4b, 0x02, 0x4c, 0xa1, 0xa6, 0x89, 0xcb, + 0x4c, 0x6b, 0xbb, 0xcc, 0x90, 0x78, 0x63, 0x27, 0x20, 0xe1, 0x8e, 0xdf, 0x6a, 0x32, 0xf6, 0x6f, + 0x50, 0x33, 0xad, 0x4d, 0xc0, 0x71, 0xaa, 0x06, 0xa5, 0xb2, 0xe5, 0xb8, 0xad, 0x6e, 0x40, 0x62, + 0x2a, 0x43, 0x26, 0x95, 0x95, 0x04, 0x1c, 0xa7, 0x6a, 0xf4, 0x96, 0xdc, 0x0e, 0x1f, 0x8d, 0xe4, + 0xd6, 0xfe, 0x5b, 0x25, 0x30, 0xa6, 0xf6, 0x5b, 0x37, 0x81, 0x10, 0xfd, 0xb2, 0xed, 0xa0, 0xd3, + 0x10, 0x96, 0x31, 0x99, 0x5f, 0x16, 0xe7, 0x05, 0xe5, 0x5f, 0x46, 0xff, 0x63, 0x56, 0x8b, 0xee, + 0xf1, 0x53, 0xb5, 0xc0, 0xa7, 0x97, 0x9c, 0x0c, 0x63, 0xa5, 0x2c, 0xd8, 0x87, 0xa5, 0x77, 0x6f, + 0x41, 0xc0, 0x47, 0x61, 0xe3, 0xcb, 0x29, 0x18, 0x46, 0x24, 0x75, 0xe1, 0x6b, 0x2f, 0xa9, 0xa0, + 0xcb, 0x30, 0x2a, 0xb2, 0xc2, 0x30, 0x43, 0x6b, 0xbe, 0x99, 0x98, 0xd1, 0x4b, 0x35, 0x2e, 0xc6, + 0x3a, 0x8e, 0xfd, 0x03, 0x25, 0x38, 0x91, 0xe1, 0x29, 0xc3, 0xaf, 0x91, 0x6d, 0x37, 0x8c, 0x54, + 0xea, 0x51, 0xed, 0x1a, 0xe1, 0xe5, 0x58, 0x61, 0xd0, 0xb3, 0x8a, 0x5f, 0x54, 0xc9, 0xcb, 0x49, + 0x58, 0xa2, 0x0b, 0xe8, 0x21, 0x93, 0x78, 0x9e, 0x87, 0x81, 0x6e, 0x48, 0x64, 0xa8, 0x56, 0x75, + 0x6d, 0x33, 0xb5, 0x26, 0x83, 0xd0, 0x67, 0xd4, 0xb6, 0xd2, 0x10, 0x6a, 0xcf, 0x28, 0xae, 0x23, + 0xe4, 0x30, 0xda, 0xb9, 0x88, 0x78, 0x8e, 0x17, 0x89, 0xc7, 0x56, 0x1c, 0x73, 0x90, 0x95, 0x62, + 0x01, 0xb5, 0xbf, 0x50, 0x86, 0x33, 0xb9, 0xbe, 0x73, 0xb4, 0xeb, 0x6d, 0xdf, 0x73, 0x23, 0x5f, + 0x59, 0x13, 0xf1, 0x38, 0x83, 0xa4, 0xb3, 0xb3, 0x26, 0xca, 0xb1, 0xc2, 0x40, 0x17, 0x60, 0x90, + 0x09, 0x45, 0x53, 0x49, 0x58, 0x17, 0xab, 0x3c, 0xf0, 0x14, 0x07, 0xf7, 0x9d, 0x37, 0xfb, 0x09, + 0xca, 0xc1, 0xf8, 0xad, 0xe4, 0x85, 0x42, 0xbb, 0xeb, 0xfb, 0x2d, 0xcc, 0x80, 0xe8, 0x7d, 0x62, + 0xbc, 0x12, 0xe6, 0x33, 0xd8, 0x69, 0xfa, 0xa1, 0x36, 0x68, 0x4f, 0xc1, 0xf0, 0x2e, 0xd9, 0x0f, + 0x5c, 0x6f, 0x3b, 0x69, 0x56, 0x75, 0x8d, 0x17, 0x63, 0x09, 0x37, 0xb3, 0x06, 0x0e, 0x1f, 0x75, + 0xc2, 0xeb, 0x91, 0x9e, 0xec, 0xc9, 0x0f, 0x95, 0x61, 0x12, 0x2f, 0x56, 0xdf, 0x9d, 0x88, 0x9b, + 0xe9, 0x89, 0x38, 0xea, 0x84, 0xd7, 0xbd, 0x67, 0xe3, 0xe7, 0x2d, 0x98, 0x64, 0xb9, 0x69, 0x84, + 0x87, 0xbc, 0xeb, 0x7b, 0xc7, 0xf0, 0x14, 0x78, 0x02, 0x06, 0x03, 0xda, 0x68, 0x32, 0xfb, 0x2a, + 0xeb, 0x09, 0xe6, 0x30, 0xf4, 0x18, 0x0c, 0xb0, 0x2e, 0xd0, 0xc9, 0x1b, 0xe3, 0x47, 0x70, 0xd5, + 0x89, 0x1c, 0xcc, 0x4a, 0x59, 0xd8, 0x25, 0x4c, 0x3a, 0x2d, 0x97, 0x77, 0x3a, 0x56, 0x59, 0xbf, + 0x33, 0xbc, 0xea, 0x33, 0xbb, 0xf6, 0xf6, 0xc2, 0x2e, 0x65, 0x93, 0x2c, 0x7e, 0x66, 0xff, 0x51, + 0x09, 0xce, 0x65, 0xd6, 0xeb, 0x3b, 0xec, 0x52, 0x71, 0xed, 0x87, 0x99, 0x7d, 0xa4, 0x7c, 0x8c, + 0x46, 0xab, 0x03, 0xfd, 0x72, 0xff, 0x83, 0x7d, 0x44, 0x43, 0xca, 0x1c, 0xb2, 0x77, 0x48, 0x34, + 0xa4, 0xcc, 0xbe, 0xe5, 0x88, 0x09, 0xfe, 0xbc, 0x94, 0xf3, 0x2d, 0x4c, 0x60, 0x70, 0x91, 0x9e, + 0x33, 0x0c, 0x18, 0xca, 0x47, 0x38, 0x3f, 0x63, 0x78, 0x19, 0x56, 0x50, 0xb4, 0x00, 0x93, 0x6d, + 0xd7, 0xa3, 0x87, 0xcf, 0xbe, 0xc9, 0x8a, 0xab, 0x60, 0x75, 0x6b, 0x26, 0x18, 0x27, 0xf1, 0x91, + 0xab, 0x45, 0x4a, 0xe2, 0x5f, 0xf7, 0xca, 0xa1, 0x76, 0xdd, 0xbc, 0xa9, 0xce, 0x57, 0xa3, 0x98, + 0x11, 0x35, 0x69, 0x4d, 0x93, 0x13, 0x95, 0xfb, 0x97, 0x13, 0x8d, 0x65, 0xcb, 0x88, 0x66, 0x5f, + 0x81, 0xf1, 0x07, 0x56, 0x0c, 0xd8, 0x5f, 0x2b, 0xc3, 0xa3, 0x05, 0xdb, 0x9e, 0x9f, 0xf5, 0xc6, + 0x1c, 0x68, 0x67, 0x7d, 0x6a, 0x1e, 0x6a, 0x70, 0x72, 0xab, 0xdb, 0x6a, 0xed, 0x33, 0x5f, 0x0e, + 0xd2, 0x94, 0x18, 0x82, 0xa7, 0x94, 0xc2, 0x91, 0x93, 0x2b, 0x19, 0x38, 0x38, 0xb3, 0x26, 0x7d, + 0x62, 0xd1, 0x9b, 0x64, 0x5f, 0x91, 0x4a, 0x3c, 0xb1, 0xb0, 0x0e, 0xc4, 0x26, 0x2e, 0xba, 0x02, + 0xd3, 0xce, 0x9e, 0xe3, 0xf2, 0x70, 0xd3, 0x92, 0x00, 0x7f, 0x63, 0x29, 0x79, 0xee, 0x42, 0x12, + 0x01, 0xa7, 0xeb, 0xa0, 0xd7, 0x00, 0xf9, 0x9b, 0xcc, 0xe2, 0xbb, 0x79, 0x85, 0x78, 0x42, 0xeb, + 0xca, 0xe6, 0xae, 0x1c, 0x1f, 0x09, 0x37, 0x52, 0x18, 0x38, 0xa3, 0x56, 0x22, 0x22, 0xd0, 0x50, + 0x7e, 0x44, 0xa0, 0xe2, 0x73, 0xb1, 0x67, 0xe2, 0x9b, 0xff, 0x64, 0xd1, 0xeb, 0x8b, 0x33, 0xf9, + 0x66, 0x00, 0xcd, 0x57, 0x98, 0xd5, 0x24, 0x97, 0xf5, 0x6a, 0xf1, 0x53, 0x4e, 0x69, 0x56, 0x93, + 0x31, 0x10, 0x9b, 0xb8, 0x7c, 0x41, 0x84, 0xb1, 0xdb, 0xae, 0xc1, 0xe2, 0x8b, 0x28, 0x5f, 0x0a, + 0x03, 0x7d, 0x1c, 0x86, 0x9b, 0xee, 0x9e, 0x1b, 0x0a, 0x49, 0xd7, 0xa1, 0xd5, 0x4a, 0xf1, 0x39, + 0x58, 0xe5, 0x64, 0xb0, 0xa4, 0x67, 0xff, 0x50, 0x09, 0xc6, 0x65, 0x8b, 0xaf, 0x77, 0xfd, 0xc8, + 0x39, 0x86, 0x6b, 0xf9, 0x8a, 0x71, 0x2d, 0xbf, 0xaf, 0x28, 0xd4, 0x19, 0xeb, 0x52, 0xee, 0x75, + 0x7c, 0x23, 0x71, 0x1d, 0x3f, 0xd9, 0x9b, 0x54, 0xf1, 0x35, 0xfc, 0x8f, 0x2d, 0x98, 0x36, 0xf0, + 0x8f, 0xe1, 0x36, 0x58, 0x31, 0x6f, 0x83, 0xc7, 0x7b, 0x7e, 0x43, 0xce, 0x2d, 0xf0, 0xbd, 0xe5, + 0x44, 0xdf, 0xd9, 0xe9, 0xff, 0x26, 0x0c, 0xec, 0x38, 0x41, 0xb3, 0x28, 0xb5, 0x43, 0xaa, 0xd2, + 0xfc, 0x55, 0x27, 0x10, 0x6a, 0xe7, 0x67, 0xe4, 0xa8, 0xd3, 0xa2, 0x9e, 0x2a, 0x67, 0xd6, 0x14, + 0x7a, 0x09, 0x86, 0xc2, 0x86, 0xdf, 0x51, 0x9e, 0x1c, 0xe7, 0xd9, 0x40, 0xb3, 0x92, 0xfb, 0x07, + 0x73, 0xc8, 0x6c, 0x8e, 0x16, 0x63, 0x81, 0x8f, 0x3e, 0x01, 0xe3, 0xec, 0x97, 0xb2, 0x01, 0x2b, + 0xe7, 0x8b, 0x23, 0xea, 0x3a, 0x22, 0x37, 0x90, 0x34, 0x8a, 0xb0, 0x49, 0x6a, 0x76, 0x1b, 0x2a, + 0xea, 0xb3, 0x1e, 0xaa, 0xde, 0xf6, 0xdf, 0x97, 0xe1, 0x44, 0xc6, 0x9a, 0x43, 0xa1, 0x31, 0x13, + 0x97, 0xfb, 0x5c, 0xaa, 0x6f, 0x73, 0x2e, 0x42, 0xf6, 0x1a, 0x6a, 0x8a, 0xb5, 0xd5, 0x77, 0xa3, + 0x37, 0x43, 0x92, 0x6c, 0x94, 0x16, 0xf5, 0x6e, 0x94, 0x36, 0x76, 0x6c, 0x43, 0x4d, 0x1b, 0x52, + 0x3d, 0x7d, 0xa8, 0x73, 0xfa, 0xa7, 0x65, 0x38, 0x99, 0x15, 0x7d, 0x11, 0x7d, 0x36, 0x91, 0x58, + 0xf4, 0x85, 0x7e, 0xe3, 0x36, 0xf2, 0x6c, 0xa3, 0x22, 0x20, 0xdc, 0xbc, 0x99, 0x6a, 0xb4, 0xe7, + 0x30, 0x8b, 0x36, 0x59, 0x48, 0x8a, 0x80, 0x27, 0x84, 0x95, 0xc7, 0xc7, 0x07, 0xfb, 0xee, 0x80, + 0xc8, 0x24, 0x1b, 0x26, 0xec, 0x4b, 0x64, 0x71, 0x6f, 0xfb, 0x12, 0xd9, 0xf2, 0xac, 0x0b, 0xa3, + 0xda, 0xd7, 0x3c, 0xd4, 0x19, 0xdf, 0xa5, 0xb7, 0x95, 0xd6, 0xef, 0x87, 0x3a, 0xeb, 0x3f, 0x66, + 0x41, 0xc2, 0xe5, 0x40, 0x89, 0xc5, 0xac, 0x5c, 0xb1, 0xd8, 0x79, 0x18, 0x08, 0xfc, 0x16, 0x49, + 0x66, 0xe0, 0xc4, 0x7e, 0x8b, 0x60, 0x06, 0xa1, 0x18, 0x51, 0x2c, 0xec, 0x18, 0xd3, 0x1f, 0x72, + 0xe2, 0x89, 0xf6, 0x04, 0x0c, 0xb6, 0xc8, 0x1e, 0x69, 0x25, 0x13, 0x25, 0x5d, 0xa7, 0x85, 0x98, + 0xc3, 0xec, 0x9f, 0x1f, 0x80, 0xb3, 0x85, 0x41, 0x5d, 0xe8, 0x73, 0x68, 0xdb, 0x89, 0xc8, 0x1d, + 0x67, 0x3f, 0x99, 0xd1, 0xe4, 0x0a, 0x2f, 0xc6, 0x12, 0xce, 0x3c, 0xc9, 0x78, 0x60, 0xf2, 0x84, + 0x10, 0x51, 0xc4, 0x23, 0x17, 0x50, 0x53, 0x28, 0x55, 0x3e, 0x0a, 0xa1, 0xd4, 0x73, 0x00, 0x61, + 0xd8, 0xe2, 0x86, 0x59, 0x4d, 0xe1, 0xa2, 0x16, 0x07, 0xb0, 0xaf, 0x5f, 0x17, 0x10, 0xac, 0x61, + 0xa1, 0x2a, 0x4c, 0x75, 0x02, 0x3f, 0xe2, 0x32, 0xd9, 0x2a, 0xb7, 0x5d, 0x1c, 0x34, 0xe3, 0x69, + 0xd4, 0x12, 0x70, 0x9c, 0xaa, 0x81, 0x5e, 0x84, 0x51, 0x11, 0x63, 0xa3, 0xe6, 0xfb, 0x2d, 0x21, + 0x06, 0x52, 0xe6, 0x7c, 0xf5, 0x18, 0x84, 0x75, 0x3c, 0xad, 0x1a, 0x13, 0xf4, 0x0e, 0x67, 0x56, + 0xe3, 0xc2, 0x5e, 0x0d, 0x2f, 0x11, 0x89, 0x75, 0xa4, 0xaf, 0x48, 0xac, 0xb1, 0x60, 0xac, 0xd2, + 0xb7, 0xde, 0x11, 0x7a, 0x8a, 0x92, 0x7e, 0x76, 0x00, 0x4e, 0x88, 0x85, 0xf3, 0xb0, 0x97, 0xcb, + 0xcd, 0xf4, 0x72, 0x39, 0x0a, 0xd1, 0xd9, 0xbb, 0x6b, 0xe6, 0xb8, 0xd7, 0xcc, 0x0f, 0x5b, 0x60, + 0xb2, 0x57, 0xe8, 0xff, 0xcb, 0x4d, 0x09, 0xf5, 0x62, 0x2e, 0xbb, 0xa6, 0xa2, 0x7a, 0xbe, 0xcd, + 0xe4, 0x50, 0xf6, 0x7f, 0xb4, 0xe0, 0xf1, 0x9e, 0x14, 0xd1, 0x32, 0x54, 0x18, 0x0f, 0xa8, 0xbd, + 0xce, 0x9e, 0x54, 0xb6, 0xcd, 0x12, 0x90, 0xc3, 0x92, 0xc6, 0x35, 0xd1, 0x72, 0x2a, 0xf7, 0xd6, + 0x53, 0x19, 0xb9, 0xb7, 0x4e, 0x19, 0xc3, 0xf3, 0x80, 0xc9, 0xb7, 0x7e, 0x90, 0xde, 0x38, 0x86, + 0x5f, 0x11, 0xfa, 0xa0, 0x21, 0xf6, 0xb3, 0x13, 0x62, 0x3f, 0x64, 0x62, 0x6b, 0x77, 0xc8, 0x47, + 0x61, 0x8a, 0x05, 0xdf, 0x62, 0x96, 0xf6, 0xc2, 0xe3, 0xa9, 0x14, 0x5b, 0xd3, 0x5e, 0x4f, 0xc0, + 0x70, 0x0a, 0xdb, 0xfe, 0xc3, 0x32, 0x0c, 0xf1, 0xed, 0x77, 0x0c, 0x6f, 0xc2, 0xa7, 0xa1, 0xe2, + 0xb6, 0xdb, 0x5d, 0x9e, 0x4e, 0x69, 0x90, 0xfb, 0x46, 0xd3, 0x79, 0x5a, 0x95, 0x85, 0x38, 0x86, + 0xa3, 0x15, 0x21, 0x71, 0x2e, 0x88, 0xef, 0xc9, 0x3b, 0x3e, 0x5f, 0x75, 0x22, 0x87, 0x33, 0x38, + 0xea, 0x9e, 0x8d, 0x65, 0xd3, 0xe8, 0x53, 0x00, 0x61, 0x14, 0xb8, 0xde, 0x36, 0x2d, 0x13, 0x61, + 0x85, 0xdf, 0x5f, 0x40, 0xad, 0xae, 0x90, 0x39, 0xcd, 0xf8, 0xcc, 0x51, 0x00, 0xac, 0x51, 0x44, + 0xf3, 0xc6, 0x4d, 0x3f, 0x9b, 0x98, 0x3b, 0xe0, 0x54, 0xe3, 0x39, 0x9b, 0xfd, 0x10, 0x54, 0x14, + 0xf1, 0x5e, 0xf2, 0xa7, 0x31, 0x9d, 0x2d, 0xfa, 0x08, 0x4c, 0x26, 0xfa, 0x76, 0x28, 0xf1, 0xd5, + 0x2f, 0x58, 0x30, 0xc9, 0x3b, 0xb3, 0xec, 0xed, 0x89, 0xdb, 0xe0, 0x2d, 0x38, 0xd9, 0xca, 0x38, + 0x95, 0xc5, 0xf4, 0xf7, 0x7f, 0x8a, 0x2b, 0x71, 0x55, 0x16, 0x14, 0x67, 0xb6, 0x81, 0x2e, 0xd2, + 0x1d, 0x47, 0x4f, 0x5d, 0xa7, 0x25, 0x5c, 0xa5, 0xc7, 0xf8, 0x6e, 0xe3, 0x65, 0x58, 0x41, 0xed, + 0xdf, 0xb1, 0x60, 0x9a, 0xf7, 0xfc, 0x1a, 0xd9, 0x57, 0x67, 0xd3, 0x37, 0xb2, 0xef, 0x22, 0x91, + 0x5f, 0x29, 0x27, 0x91, 0x9f, 0xfe, 0x69, 0xe5, 0xc2, 0x4f, 0xfb, 0xb2, 0x05, 0x62, 0x85, 0x1c, + 0x83, 0x10, 0xe2, 0xdb, 0x4d, 0x21, 0xc4, 0x6c, 0xfe, 0x26, 0xc8, 0x91, 0x3e, 0xfc, 0x99, 0x05, + 0x53, 0x1c, 0x21, 0xd6, 0x96, 0x7f, 0x43, 0xe7, 0xa1, 0x9f, 0x74, 0xdf, 0xd7, 0xc8, 0xfe, 0x86, + 0x5f, 0x73, 0xa2, 0x9d, 0xec, 0x8f, 0x32, 0x26, 0x6b, 0xa0, 0x70, 0xb2, 0x9a, 0x72, 0x03, 0x19, + 0x79, 0x6e, 0x7a, 0xc4, 0x8f, 0x38, 0x6c, 0x9e, 0x1b, 0xfb, 0xeb, 0x16, 0x20, 0xde, 0x8c, 0xc1, + 0xb8, 0x51, 0x76, 0x88, 0x95, 0x6a, 0x17, 0x5d, 0x7c, 0x34, 0x29, 0x08, 0xd6, 0xb0, 0x8e, 0x64, + 0x78, 0x12, 0x26, 0x0f, 0xe5, 0xde, 0x26, 0x0f, 0x87, 0x18, 0xd1, 0x7f, 0x33, 0x04, 0x49, 0xdf, + 0x2a, 0x74, 0x0b, 0xc6, 0x1a, 0x4e, 0xc7, 0xd9, 0x74, 0x5b, 0x6e, 0xe4, 0x92, 0xb0, 0xc8, 0x1e, + 0x6a, 0x49, 0xc3, 0x13, 0x4a, 0x6a, 0xad, 0x04, 0x1b, 0x74, 0xd0, 0x3c, 0x40, 0x27, 0x70, 0xf7, + 0xdc, 0x16, 0xd9, 0x66, 0xb2, 0x12, 0x16, 0x9c, 0x81, 0x1b, 0x67, 0xc9, 0x52, 0xac, 0x61, 0x64, + 0x38, 0xb2, 0x97, 0x1f, 0xb2, 0x23, 0x3b, 0x1c, 0x9b, 0x23, 0xfb, 0xc0, 0xa1, 0x1c, 0xd9, 0x47, + 0x0e, 0xed, 0xc8, 0x3e, 0xd8, 0x97, 0x23, 0x3b, 0x86, 0xd3, 0x92, 0xf7, 0xa4, 0xff, 0x57, 0xdc, + 0x16, 0x11, 0x0f, 0x0e, 0x1e, 0x51, 0x62, 0xf6, 0xde, 0xc1, 0xdc, 0x69, 0x9c, 0x89, 0x81, 0x73, + 0x6a, 0xa2, 0x8f, 0xc1, 0x8c, 0xd3, 0x6a, 0xf9, 0x77, 0xd4, 0xa4, 0x2e, 0x87, 0x0d, 0xa7, 0xc5, + 0x95, 0x10, 0xc3, 0x8c, 0xea, 0x63, 0xf7, 0x0e, 0xe6, 0x66, 0x16, 0x72, 0x70, 0x70, 0x6e, 0x6d, + 0xf4, 0x61, 0xa8, 0x74, 0x02, 0xbf, 0xb1, 0xa6, 0x39, 0x80, 0x9e, 0xa3, 0x03, 0x58, 0x93, 0x85, + 0xf7, 0x0f, 0xe6, 0xc6, 0xd5, 0x1f, 0x76, 0xe1, 0xc7, 0x15, 0x32, 0x3c, 0xd3, 0x47, 0x8f, 0xd4, + 0x33, 0x7d, 0x17, 0x4e, 0xd4, 0x49, 0xe0, 0x3a, 0x2d, 0xf7, 0x2d, 0xca, 0x2f, 0xcb, 0xf3, 0x69, + 0x03, 0x2a, 0x41, 0xe2, 0x44, 0xee, 0x2b, 0xe6, 0xa6, 0x96, 0x70, 0x44, 0x9e, 0xc0, 0x31, 0x21, + 0xfb, 0x7f, 0x5b, 0x30, 0x2c, 0x7c, 0xa9, 0x8e, 0x81, 0x6b, 0x5c, 0x30, 0x34, 0x09, 0x73, 0xd9, + 0x03, 0xc6, 0x3a, 0x93, 0xab, 0x43, 0x58, 0x4d, 0xe8, 0x10, 0x1e, 0x2f, 0x22, 0x52, 0xac, 0x3d, + 0xf8, 0x6b, 0x65, 0xca, 0xbd, 0x1b, 0x5e, 0xbd, 0x0f, 0x7f, 0x08, 0xd6, 0x61, 0x38, 0x14, 0x5e, + 0xa5, 0xa5, 0x7c, 0x9f, 0x86, 0xe4, 0x24, 0xc6, 0x76, 0x6c, 0xc2, 0x8f, 0x54, 0x12, 0xc9, 0x74, + 0x57, 0x2d, 0x3f, 0x44, 0x77, 0xd5, 0x5e, 0x7e, 0xcf, 0x03, 0x47, 0xe1, 0xf7, 0x6c, 0x7f, 0x95, + 0xdd, 0x9c, 0x7a, 0xf9, 0x31, 0x30, 0x55, 0x57, 0xcc, 0x3b, 0xd6, 0x2e, 0x58, 0x59, 0xa2, 0x53, + 0x39, 0xcc, 0xd5, 0xcf, 0x59, 0x70, 0x36, 0xe3, 0xab, 0x34, 0x4e, 0xeb, 0x19, 0x18, 0x71, 0xba, + 0x4d, 0x57, 0xed, 0x65, 0x4d, 0x9f, 0xb8, 0x20, 0xca, 0xb1, 0xc2, 0x40, 0x4b, 0x30, 0x4d, 0xee, + 0x76, 0x5c, 0xae, 0x4a, 0xd5, 0xcd, 0x7f, 0xcb, 0xdc, 0x01, 0x6f, 0x39, 0x09, 0xc4, 0x69, 0x7c, + 0x15, 0x6b, 0xa6, 0x9c, 0x1b, 0x6b, 0xe6, 0xef, 0x5a, 0x30, 0xaa, 0xfc, 0x2a, 0x1f, 0xfa, 0x68, + 0x7f, 0xd4, 0x1c, 0xed, 0x47, 0x0b, 0x46, 0x3b, 0x67, 0x98, 0x7f, 0xab, 0xa4, 0xfa, 0x5b, 0xf3, + 0x83, 0xa8, 0x0f, 0x0e, 0xee, 0xc1, 0x5d, 0x17, 0x2e, 0xc3, 0xa8, 0xd3, 0xe9, 0x48, 0x80, 0xb4, + 0x41, 0x63, 0x11, 0x94, 0xe3, 0x62, 0xac, 0xe3, 0x28, 0x4f, 0x8a, 0x72, 0xae, 0x27, 0x45, 0x13, + 0x20, 0x72, 0x82, 0x6d, 0x12, 0xd1, 0x32, 0x61, 0x32, 0x9b, 0x7f, 0xde, 0x74, 0x23, 0xb7, 0x35, + 0xef, 0x7a, 0x51, 0x18, 0x05, 0xf3, 0xab, 0x5e, 0x74, 0x23, 0xe0, 0x4f, 0x48, 0x2d, 0x5a, 0x93, + 0xa2, 0x85, 0x35, 0xba, 0x32, 0x86, 0x00, 0x6b, 0x63, 0xd0, 0x34, 0x66, 0x58, 0x17, 0xe5, 0x58, + 0x61, 0xd8, 0x1f, 0x62, 0xb7, 0x0f, 0x1b, 0xd3, 0xc3, 0x45, 0x2a, 0xfa, 0xfb, 0x63, 0x6a, 0x36, + 0x98, 0x26, 0xb3, 0xaa, 0xc7, 0x43, 0x2a, 0x3e, 0xec, 0x69, 0xc3, 0xba, 0x5f, 0x5f, 0x1c, 0x34, + 0x09, 0x7d, 0x47, 0xca, 0x40, 0xe5, 0xd9, 0x1e, 0xb7, 0xc6, 0x21, 0x4c, 0x52, 0x58, 0x3a, 0x15, + 0x96, 0x6c, 0x62, 0xb5, 0x26, 0xf6, 0x85, 0x96, 0x4e, 0x45, 0x00, 0x70, 0x8c, 0x43, 0x99, 0x29, + 0xf5, 0x27, 0x9c, 0x41, 0x71, 0x58, 0x51, 0x85, 0x1d, 0x62, 0x0d, 0x03, 0x5d, 0x12, 0x02, 0x05, + 0xae, 0x17, 0x78, 0x34, 0x21, 0x50, 0x90, 0xc3, 0xa5, 0x49, 0x81, 0x2e, 0xc3, 0xa8, 0xca, 0xa0, + 0x5d, 0xe3, 0x89, 0x8c, 0xc4, 0x32, 0x5b, 0x8e, 0x8b, 0xb1, 0x8e, 0x83, 0x36, 0x60, 0x32, 0xe4, + 0x72, 0x36, 0x15, 0xeb, 0x99, 0xcb, 0x2b, 0xdf, 0x2f, 0xad, 0x80, 0xea, 0x26, 0xf8, 0x3e, 0x2b, + 0xe2, 0xa7, 0x93, 0xf4, 0xf3, 0x4f, 0x92, 0x40, 0xaf, 0xc2, 0x44, 0xcb, 0x77, 0x9a, 0x8b, 0x4e, + 0xcb, 0xf1, 0x1a, 0x6c, 0x7c, 0x46, 0xcc, 0x44, 0xac, 0xd7, 0x0d, 0x28, 0x4e, 0x60, 0x53, 0xe6, + 0x4d, 0x2f, 0x11, 0xf1, 0xc9, 0x1d, 0x6f, 0x9b, 0x84, 0x22, 0x1f, 0x32, 0x63, 0xde, 0xae, 0xe7, + 0xe0, 0xe0, 0xdc, 0xda, 0xe8, 0x25, 0x18, 0x93, 0x9f, 0xaf, 0x85, 0xc5, 0x88, 0x9d, 0x52, 0x34, + 0x18, 0x36, 0x30, 0xd1, 0x1d, 0x38, 0x25, 0xff, 0x6f, 0x04, 0xce, 0xd6, 0x96, 0xdb, 0x10, 0xbe, + 0xe2, 0xdc, 0x7b, 0x75, 0x41, 0xba, 0x58, 0x2e, 0x67, 0x21, 0xdd, 0x3f, 0x98, 0x3b, 0x2f, 0x46, + 0x2d, 0x13, 0xce, 0x26, 0x31, 0x9b, 0x3e, 0x5a, 0x83, 0x13, 0x3b, 0xc4, 0x69, 0x45, 0x3b, 0x4b, + 0x3b, 0xa4, 0xb1, 0x2b, 0x37, 0x1d, 0x0b, 0xb6, 0xa1, 0x39, 0x70, 0x5c, 0x4d, 0xa3, 0xe0, 0xac, + 0x7a, 0xe8, 0x0d, 0x98, 0xe9, 0x74, 0x37, 0x5b, 0x6e, 0xb8, 0xb3, 0xee, 0x47, 0xcc, 0x14, 0x48, + 0x25, 0xe4, 0x16, 0x51, 0x39, 0x54, 0x38, 0x93, 0x5a, 0x0e, 0x1e, 0xce, 0xa5, 0x80, 0xde, 0x82, + 0x53, 0x89, 0xc5, 0x20, 0xe2, 0x12, 0x4c, 0xe4, 0x67, 0x7b, 0xa8, 0x67, 0x55, 0x10, 0x21, 0x3e, + 0xb2, 0x40, 0x38, 0xbb, 0x09, 0xf4, 0x32, 0x80, 0xdb, 0x59, 0x71, 0xda, 0x6e, 0x8b, 0x3e, 0x17, + 0x4f, 0xb0, 0x75, 0x42, 0x9f, 0x0e, 0xb0, 0x5a, 0x93, 0xa5, 0xf4, 0x7c, 0x16, 0xff, 0xf6, 0xb1, + 0x86, 0x8d, 0x6a, 0x30, 0x21, 0xfe, 0xed, 0x8b, 0x69, 0x9d, 0x56, 0x21, 0x00, 0x26, 0x64, 0x0d, + 0x35, 0x97, 0xc8, 0x2c, 0x61, 0xb3, 0x97, 0xa8, 0x8f, 0xb6, 0xe1, 0xac, 0xcc, 0xde, 0xa5, 0xaf, + 0x53, 0x39, 0x0f, 0x21, 0x4b, 0xb3, 0x30, 0xc2, 0xfd, 0x43, 0x16, 0x8a, 0x10, 0x71, 0x31, 0x1d, + 0x7a, 0xbf, 0xeb, 0xcb, 0x9d, 0x7b, 0xd0, 0x9e, 0xe2, 0xe6, 0x49, 0xf4, 0x7e, 0xbf, 0x9e, 0x04, + 0xe2, 0x34, 0x3e, 0x0a, 0xe1, 0x94, 0xeb, 0x65, 0xad, 0xee, 0xd3, 0x8c, 0xd0, 0x47, 0xb8, 0xf3, + 0x70, 0xf1, 0xca, 0xce, 0x84, 0xf3, 0x95, 0x9d, 0x49, 0xfb, 0xed, 0x59, 0xe1, 0xfd, 0xb6, 0x45, + 0x6b, 0x6b, 0x9c, 0x3a, 0xfa, 0x34, 0x8c, 0xe9, 0x1f, 0x26, 0xb8, 0x8e, 0x0b, 0xd9, 0x8c, 0xac, + 0x76, 0x3e, 0x70, 0x3e, 0x5f, 0x9d, 0x01, 0x3a, 0x0c, 0x1b, 0x14, 0x51, 0x23, 0xc3, 0xcd, 0xfe, + 0x52, 0x7f, 0x5c, 0x4d, 0xff, 0x46, 0x68, 0x04, 0xb2, 0x97, 0x3d, 0xba, 0x0e, 0x23, 0x8d, 0x96, + 0x4b, 0xbc, 0x68, 0xb5, 0x56, 0x14, 0x4b, 0x6f, 0x49, 0xe0, 0x88, 0x7d, 0x24, 0xb2, 0x26, 0xf0, + 0x32, 0xac, 0x28, 0xd8, 0xbf, 0x5a, 0x82, 0xb9, 0x1e, 0x29, 0x38, 0x12, 0x2a, 0x29, 0xab, 0x2f, + 0x95, 0xd4, 0x82, 0xcc, 0x3a, 0xbf, 0x9e, 0x90, 0x76, 0x25, 0x32, 0xca, 0xc7, 0x32, 0xaf, 0x24, + 0x7e, 0xdf, 0x2e, 0x02, 0xba, 0x56, 0x6b, 0xa0, 0xa7, 0x93, 0x8b, 0xa1, 0xcd, 0x1e, 0xec, 0xff, + 0x09, 0x9c, 0xab, 0x99, 0xb4, 0xbf, 0x5a, 0x82, 0x53, 0x6a, 0x08, 0xbf, 0x75, 0x07, 0xee, 0x66, + 0x7a, 0xe0, 0x8e, 0x40, 0xaf, 0x6b, 0xdf, 0x80, 0x21, 0x1e, 0x1c, 0xb0, 0x0f, 0xd6, 0xfb, 0x09, + 0x33, 0xf8, 0xae, 0xe2, 0xf6, 0x8c, 0x00, 0xbc, 0xdf, 0x6f, 0xc1, 0x64, 0xc2, 0xd7, 0x0c, 0x61, + 0xcd, 0x21, 0xf9, 0x41, 0xd8, 0xe3, 0x2c, 0xc6, 0xfb, 0x3c, 0x0c, 0xec, 0xf8, 0x61, 0x94, 0x34, + 0xfa, 0xb8, 0xea, 0x87, 0x11, 0x66, 0x10, 0xfb, 0x77, 0x2d, 0x18, 0xdc, 0x70, 0x5c, 0x2f, 0x92, + 0x0a, 0x02, 0x2b, 0x47, 0x41, 0xd0, 0xcf, 0x77, 0xa1, 0x17, 0x61, 0x88, 0x6c, 0x6d, 0x91, 0x46, + 0x24, 0x66, 0x55, 0x46, 0x73, 0x18, 0x5a, 0x66, 0xa5, 0x94, 0x17, 0x64, 0x8d, 0xf1, 0xbf, 0x58, + 0x20, 0xa3, 0xdb, 0x50, 0x89, 0xdc, 0x36, 0x59, 0x68, 0x36, 0x85, 0xda, 0xfc, 0x01, 0x22, 0x52, + 0x6c, 0x48, 0x02, 0x38, 0xa6, 0x65, 0x7f, 0xa1, 0x04, 0x10, 0x47, 0x55, 0xea, 0xf5, 0x89, 0x8b, + 0x29, 0x85, 0xea, 0x85, 0x0c, 0x85, 0x2a, 0x8a, 0x09, 0x66, 0x68, 0x53, 0xd5, 0x30, 0x95, 0xfb, + 0x1a, 0xa6, 0x81, 0xc3, 0x0c, 0xd3, 0x12, 0x4c, 0xc7, 0x51, 0xa1, 0xcc, 0xa0, 0x78, 0xec, 0xfa, + 0xdc, 0x48, 0x02, 0x71, 0x1a, 0xdf, 0x26, 0x70, 0x5e, 0x05, 0xc7, 0x11, 0x37, 0x1a, 0xb3, 0xca, + 0xd6, 0x15, 0xd4, 0x3d, 0xc6, 0x29, 0xd6, 0x18, 0x97, 0x72, 0x35, 0xc6, 0x3f, 0x69, 0xc1, 0xc9, + 0x64, 0x3b, 0xcc, 0x85, 0xf9, 0xf3, 0x16, 0x9c, 0x62, 0x7a, 0x73, 0xd6, 0x6a, 0x5a, 0x4b, 0xff, + 0x42, 0x61, 0xc0, 0x9f, 0x9c, 0x1e, 0xc7, 0x61, 0x43, 0xd6, 0xb2, 0x48, 0xe3, 0xec, 0x16, 0xed, + 0xff, 0x50, 0x82, 0x99, 0xbc, 0x48, 0x41, 0xcc, 0x69, 0xc3, 0xb9, 0x5b, 0xdf, 0x25, 0x77, 0x84, + 0x69, 0x7c, 0xec, 0xb4, 0xc1, 0x8b, 0xb1, 0x84, 0x27, 0xb3, 0x2a, 0x94, 0xfa, 0xcc, 0xaa, 0xb0, + 0x03, 0xd3, 0x77, 0x76, 0x88, 0x77, 0xd3, 0x0b, 0x9d, 0xc8, 0x0d, 0xb7, 0x5c, 0xa6, 0x63, 0xe6, + 0xeb, 0x46, 0xa6, 0x62, 0x9d, 0xbe, 0x9d, 0x44, 0xb8, 0x7f, 0x30, 0x77, 0xd6, 0x28, 0x88, 0xbb, + 0xcc, 0x0f, 0x12, 0x9c, 0x26, 0x9a, 0x4e, 0x4a, 0x31, 0xf0, 0x10, 0x93, 0x52, 0xd8, 0x9f, 0xb7, + 0xe0, 0x4c, 0x6e, 0x5e, 0x62, 0x74, 0x11, 0x46, 0x9c, 0x8e, 0xcb, 0xc5, 0xf4, 0xe2, 0x18, 0x65, + 0xe2, 0xa0, 0xda, 0x2a, 0x17, 0xd2, 0x2b, 0x28, 0x3d, 0xbd, 0x76, 0x5d, 0xaf, 0x99, 0x3c, 0xbd, + 0xae, 0xb9, 0x5e, 0x13, 0x33, 0x88, 0x3a, 0x8e, 0xcb, 0x79, 0xc7, 0xb1, 0xfd, 0x7d, 0x16, 0x08, + 0x87, 0xd3, 0x3e, 0xce, 0xee, 0x4f, 0xc0, 0xd8, 0x5e, 0x3a, 0x71, 0xd5, 0xf9, 0x7c, 0x0f, 0x5c, + 0x91, 0xae, 0x4a, 0x31, 0x64, 0x46, 0x92, 0x2a, 0x83, 0x96, 0xdd, 0x04, 0x01, 0xad, 0x12, 0x26, + 0x84, 0xee, 0xdd, 0x9b, 0xe7, 0x00, 0x9a, 0x0c, 0x97, 0x65, 0xb3, 0x2c, 0x99, 0x37, 0x73, 0x55, + 0x41, 0xb0, 0x86, 0x65, 0xff, 0xbb, 0x12, 0x8c, 0xca, 0x44, 0x49, 0x5d, 0xaf, 0x1f, 0x51, 0xd1, + 0xa1, 0x32, 0xa7, 0xa2, 0x4b, 0x50, 0x61, 0xb2, 0xcc, 0x5a, 0x2c, 0x61, 0x53, 0x92, 0x84, 0x35, + 0x09, 0xc0, 0x31, 0x0e, 0xdd, 0x45, 0x61, 0x77, 0x93, 0xa1, 0x27, 0xdc, 0x23, 0xeb, 0xbc, 0x18, + 0x4b, 0x38, 0xfa, 0x18, 0x4c, 0xf1, 0x7a, 0x81, 0xdf, 0x71, 0xb6, 0xb9, 0xfe, 0x63, 0x50, 0xc5, + 0x9c, 0x98, 0x5a, 0x4b, 0xc0, 0xee, 0x1f, 0xcc, 0x9d, 0x4c, 0x96, 0x31, 0xc5, 0x5e, 0x8a, 0x0a, + 0x33, 0x73, 0xe2, 0x8d, 0xd0, 0xdd, 0x9f, 0xb2, 0x8e, 0x8a, 0x41, 0x58, 0xc7, 0xb3, 0x3f, 0x0d, + 0x28, 0x9d, 0x32, 0x0a, 0xbd, 0xc6, 0x6d, 0x5b, 0xdd, 0x80, 0x34, 0x8b, 0x14, 0x7d, 0x7a, 0x64, + 0x05, 0xe9, 0xd9, 0xc4, 0x6b, 0x61, 0x55, 0xdf, 0xfe, 0x8b, 0x65, 0x98, 0x4a, 0xfa, 0x72, 0xa3, + 0xab, 0x30, 0xc4, 0x59, 0x0f, 0x41, 0xbe, 0xc0, 0x8e, 0x44, 0xf3, 0x00, 0x67, 0x87, 0xb0, 0xe0, + 0x5e, 0x44, 0x7d, 0xf4, 0x06, 0x8c, 0x36, 0xfd, 0x3b, 0xde, 0x1d, 0x27, 0x68, 0x2e, 0xd4, 0x56, + 0xc5, 0x72, 0xce, 0x7c, 0xd8, 0x56, 0x63, 0x34, 0xdd, 0xab, 0x9c, 0xe9, 0x4c, 0x63, 0x10, 0xd6, + 0xc9, 0xa1, 0x0d, 0x16, 0x67, 0x7e, 0xcb, 0xdd, 0x5e, 0x73, 0x3a, 0x45, 0x8e, 0x0e, 0x4b, 0x12, + 0x49, 0xa3, 0x3c, 0x2e, 0x82, 0xd1, 0x73, 0x00, 0x8e, 0x09, 0xa1, 0xcf, 0xc2, 0x89, 0x30, 0x47, + 0xdc, 0x9e, 0x97, 0x41, 0xb0, 0x48, 0x02, 0xbd, 0xf8, 0xc8, 0xbd, 0x83, 0xb9, 0x13, 0x59, 0x82, + 0xf9, 0xac, 0x66, 0xec, 0x2f, 0x9e, 0x04, 0x63, 0x13, 0x1b, 0x09, 0x65, 0xad, 0x23, 0x4a, 0x28, + 0x8b, 0x61, 0x84, 0xb4, 0x3b, 0xd1, 0x7e, 0xd5, 0x0d, 0x8a, 0xd2, 0xea, 0x2f, 0x0b, 0x9c, 0x34, + 0x4d, 0x09, 0xc1, 0x8a, 0x4e, 0x76, 0xd6, 0xdf, 0xf2, 0x37, 0x30, 0xeb, 0xef, 0xc0, 0x31, 0x66, + 0xfd, 0x5d, 0x87, 0xe1, 0x6d, 0x37, 0xc2, 0xa4, 0xe3, 0x0b, 0xa6, 0x3f, 0x73, 0x1d, 0x5e, 0xe1, + 0x28, 0xe9, 0xfc, 0x92, 0x02, 0x80, 0x25, 0x11, 0xf4, 0x9a, 0xda, 0x81, 0x43, 0xf9, 0x0f, 0xf3, + 0xb4, 0xc1, 0x43, 0xe6, 0x1e, 0x14, 0xb9, 0x7d, 0x87, 0x1f, 0x34, 0xb7, 0xef, 0x8a, 0xcc, 0xc8, + 0x3b, 0x92, 0xef, 0x95, 0xc4, 0x12, 0xee, 0xf6, 0xc8, 0xc3, 0x7b, 0x4b, 0xcf, 0x62, 0x5c, 0xc9, + 0x3f, 0x09, 0x54, 0x82, 0xe2, 0x3e, 0x73, 0x17, 0x7f, 0x9f, 0x05, 0xa7, 0x3a, 0x59, 0x09, 0xbd, + 0x85, 0x6d, 0xc0, 0x8b, 0x7d, 0xe7, 0x0c, 0x37, 0x1a, 0x64, 0x32, 0xb5, 0xec, 0xac, 0xf0, 0xd9, + 0xcd, 0xd1, 0x81, 0x0e, 0x36, 0x9b, 0x42, 0x47, 0xfd, 0x44, 0x4e, 0x12, 0xe4, 0x82, 0xd4, 0xc7, + 0x1b, 0x19, 0x09, 0x77, 0xdf, 0x9b, 0x97, 0x70, 0xb7, 0xef, 0x34, 0xbb, 0xaf, 0xa9, 0xf4, 0xc7, + 0xe3, 0xf9, 0x4b, 0x89, 0x27, 0x37, 0xee, 0x99, 0xf4, 0xf8, 0x35, 0x95, 0xf4, 0xb8, 0x20, 0x1e, + 0x30, 0x4f, 0x69, 0xdc, 0x33, 0xd5, 0xb1, 0x96, 0xae, 0x78, 0xf2, 0x68, 0xd2, 0x15, 0x1b, 0x57, + 0x0d, 0xcf, 0x98, 0xfb, 0x74, 0x8f, 0xab, 0xc6, 0xa0, 0x5b, 0x7c, 0xd9, 0xf0, 0xd4, 0xcc, 0xd3, + 0x0f, 0x94, 0x9a, 0xf9, 0x96, 0x9e, 0xea, 0x18, 0xf5, 0xc8, 0xe5, 0x4b, 0x91, 0xfa, 0x4c, 0x70, + 0x7c, 0x4b, 0xbf, 0x00, 0x4f, 0xe4, 0xd3, 0x55, 0xf7, 0x5c, 0x9a, 0x6e, 0xe6, 0x15, 0x98, 0x4a, + 0x9c, 0x7c, 0xf2, 0x78, 0x12, 0x27, 0x9f, 0x3a, 0xf2, 0xc4, 0xc9, 0xa7, 0x8f, 0x21, 0x71, 0xf2, + 0x23, 0xc7, 0x98, 0x38, 0xf9, 0x16, 0x33, 0xa8, 0xe1, 0x61, 0x7b, 0x44, 0xfc, 0xe2, 0xa7, 0x72, + 0xa2, 0x5e, 0xa5, 0x63, 0xfb, 0xf0, 0x8f, 0x53, 0x20, 0x1c, 0x93, 0xca, 0x48, 0xc8, 0x3c, 0xf3, + 0x10, 0x12, 0x32, 0xaf, 0xc7, 0x09, 0x99, 0xcf, 0xe4, 0x4f, 0x75, 0x86, 0x0b, 0x46, 0x4e, 0x1a, + 0xe6, 0x5b, 0x7a, 0xfa, 0xe4, 0x47, 0x0b, 0xb4, 0x26, 0x59, 0x82, 0xc7, 0x82, 0xa4, 0xc9, 0xaf, + 0xf2, 0xa4, 0xc9, 0x8f, 0xe5, 0x9f, 0xe4, 0xc9, 0xeb, 0xce, 0x48, 0x95, 0x4c, 0xfb, 0xa5, 0xc2, + 0x5e, 0xb2, 0x48, 0xcd, 0x39, 0xfd, 0x52, 0x71, 0x33, 0xd3, 0xfd, 0x52, 0x20, 0x1c, 0x93, 0xb2, + 0x7f, 0xa0, 0x04, 0xe7, 0x8a, 0xf7, 0x5b, 0x2c, 0x4d, 0xad, 0xc5, 0x4a, 0xe4, 0x84, 0x34, 0x95, + 0xbf, 0xd9, 0x62, 0xac, 0xbe, 0xa3, 0xf8, 0x5d, 0x81, 0x69, 0xe5, 0xbb, 0xd1, 0x72, 0x1b, 0xfb, + 0xeb, 0xf1, 0xcb, 0x57, 0xf9, 0xbb, 0xd7, 0x93, 0x08, 0x38, 0x5d, 0x07, 0x2d, 0xc0, 0xa4, 0x51, + 0xb8, 0x5a, 0x15, 0x6f, 0x33, 0x25, 0xbe, 0xad, 0x9b, 0x60, 0x9c, 0xc4, 0xb7, 0xbf, 0x64, 0xc1, + 0x23, 0x39, 0x19, 0x07, 0xfb, 0x0e, 0x52, 0xb7, 0x05, 0x93, 0x1d, 0xb3, 0x6a, 0x8f, 0xb8, 0x9a, + 0x46, 0x5e, 0x43, 0xd5, 0xd7, 0x04, 0x00, 0x27, 0x89, 0xda, 0x3f, 0x5d, 0x82, 0xb3, 0x85, 0xc6, + 0x88, 0x08, 0xc3, 0xe9, 0xed, 0x76, 0xe8, 0x2c, 0x05, 0xa4, 0x49, 0xbc, 0xc8, 0x75, 0x5a, 0xf5, + 0x0e, 0x69, 0x68, 0xf2, 0x70, 0x66, 0xd5, 0x77, 0x65, 0xad, 0xbe, 0x90, 0xc6, 0xc0, 0x39, 0x35, + 0xd1, 0x0a, 0xa0, 0x34, 0x44, 0xcc, 0x30, 0x8b, 0xf9, 0x9d, 0xa6, 0x87, 0x33, 0x6a, 0xa0, 0x0f, + 0xc1, 0xb8, 0x32, 0x72, 0xd4, 0x66, 0x9c, 0x1d, 0xec, 0x58, 0x07, 0x60, 0x13, 0x0f, 0x5d, 0xe6, + 0x41, 0xe3, 0x45, 0x7a, 0x01, 0x21, 0x3c, 0x9f, 0x94, 0x11, 0xe1, 0x45, 0x31, 0xd6, 0x71, 0x16, + 0x2f, 0xfe, 0xda, 0xef, 0x9f, 0x7b, 0xcf, 0x6f, 0xfe, 0xfe, 0xb9, 0xf7, 0xfc, 0xce, 0xef, 0x9f, + 0x7b, 0xcf, 0x77, 0xdd, 0x3b, 0x67, 0xfd, 0xda, 0xbd, 0x73, 0xd6, 0x6f, 0xde, 0x3b, 0x67, 0xfd, + 0xce, 0xbd, 0x73, 0xd6, 0xef, 0xdd, 0x3b, 0x67, 0x7d, 0xe1, 0x0f, 0xce, 0xbd, 0xe7, 0x13, 0xa5, + 0xbd, 0xcb, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x4d, 0xc9, 0x26, 0x9f, 0xc5, 0x07, 0x01, 0x00, } func (m *AWSElasticBlockStoreVolumeSource) Marshal() (dAtA []byte, err error) { @@ -10507,6 +10605,39 @@ func (m *GCEPersistentDiskVolumeSource) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } +func (m *GRPCAction) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GRPCAction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GRPCAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Service != nil { + i -= len(*m.Service) + copy(dAtA[i:], *m.Service) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Service))) + i-- + dAtA[i] = 0x12 + } + i = encodeVarintGenerated(dAtA, i, uint64(m.Port)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + func (m *GitRepoVolumeSource) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -10729,65 +10860,6 @@ func (m *HTTPHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Handler) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *Handler) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Handler) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.TCPSocket != nil { - { - size, err := m.TCPSocket.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGenerated(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.HTTPGet != nil { - { - size, err := m.HTTPGet.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGenerated(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Exec != nil { - { - size, err := m.Exec.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGenerated(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - func (m *HostAlias) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -11141,6 +11213,65 @@ func (m *Lifecycle) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *LifecycleHandler) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LifecycleHandler) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LifecycleHandler) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TCPSocket != nil { + { + size, err := m.TCPSocket.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.HTTPGet != nil { + { + size, err := m.HTTPGet.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Exec != nil { + { + size, err := m.Exec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *LimitRange) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -13251,6 +13382,42 @@ func (m *PersistentVolumeClaimStatus) MarshalToSizedBuffer(dAtA []byte) (int, er _ = i var l int _ = l + if m.ResizeStatus != nil { + i -= len(*m.ResizeStatus) + copy(dAtA[i:], *m.ResizeStatus) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ResizeStatus))) + i-- + dAtA[i] = 0x32 + } + if len(m.AllocatedResources) > 0 { + keysForAllocatedResources := make([]string, 0, len(m.AllocatedResources)) + for k := range m.AllocatedResources { + keysForAllocatedResources = append(keysForAllocatedResources, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAllocatedResources) + for iNdEx := len(keysForAllocatedResources) - 1; iNdEx >= 0; iNdEx-- { + v := m.AllocatedResources[ResourceName(keysForAllocatedResources[iNdEx])] + baseI := i + { + size, err := (&v).MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(keysForAllocatedResources[iNdEx]) + copy(dAtA[i:], keysForAllocatedResources[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAllocatedResources[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x2a + } + } if len(m.Conditions) > 0 { for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { { @@ -14590,6 +14757,34 @@ func (m *PodLogOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *PodOS) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PodOS) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PodOS) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *PodPortForwardOptions) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -14843,6 +15038,20 @@ func (m *PodSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.OS != nil { + { + size, err := m.OS.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xa2 + } if m.SetHostnameAsFQDN != nil { i-- if *m.SetHostnameAsFQDN { @@ -15794,7 +16003,7 @@ func (m *Probe) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x10 { - size, err := m.Handler.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ProbeHandler.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -15806,6 +16015,77 @@ func (m *Probe) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ProbeHandler) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProbeHandler) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProbeHandler) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.GRPC != nil { + { + size, err := m.GRPC.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.TCPSocket != nil { + { + size, err := m.TCPSocket.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.HTTPGet != nil { + { + size, err := m.HTTPGet.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Exec != nil { + { + size, err := m.Exec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *ProjectedVolumeSource) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -20762,6 +21042,20 @@ func (m *GCEPersistentDiskVolumeSource) Size() (n int) { return n } +func (m *GRPCAction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.Port)) + if m.Service != nil { + l = len(*m.Service) + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + func (m *GitRepoVolumeSource) Size() (n int) { if m == nil { return 0 @@ -20845,27 +21139,6 @@ func (m *HTTPHeader) Size() (n int) { return n } -func (m *Handler) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Exec != nil { - l = m.Exec.Size() - n += 1 + l + sovGenerated(uint64(l)) - } - if m.HTTPGet != nil { - l = m.HTTPGet.Size() - n += 1 + l + sovGenerated(uint64(l)) - } - if m.TCPSocket != nil { - l = m.TCPSocket.Size() - n += 1 + l + sovGenerated(uint64(l)) - } - return n -} - func (m *HostAlias) Size() (n int) { if m == nil { return 0 @@ -21001,6 +21274,27 @@ func (m *Lifecycle) Size() (n int) { return n } +func (m *LifecycleHandler) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Exec != nil { + l = m.Exec.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.HTTPGet != nil { + l = m.HTTPGet.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.TCPSocket != nil { + l = m.TCPSocket.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + func (m *LimitRange) Size() (n int) { if m == nil { return 0 @@ -21792,6 +22086,19 @@ func (m *PersistentVolumeClaimStatus) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + if len(m.AllocatedResources) > 0 { + for k, v := range m.AllocatedResources { + _ = k + _ = v + l = v.Size() + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l)) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + if m.ResizeStatus != nil { + l = len(*m.ResizeStatus) + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -22247,6 +22554,17 @@ func (m *PodLogOptions) Size() (n int) { return n } +func (m *PodOS) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *PodPortForwardOptions) Size() (n int) { if m == nil { return 0 @@ -22483,6 +22801,10 @@ func (m *PodSpec) Size() (n int) { if m.SetHostnameAsFQDN != nil { n += 3 } + if m.OS != nil { + l = m.OS.Size() + n += 2 + l + sovGenerated(uint64(l)) + } return n } @@ -22677,7 +22999,7 @@ func (m *Probe) Size() (n int) { } var l int _ = l - l = m.Handler.Size() + l = m.ProbeHandler.Size() n += 1 + l + sovGenerated(uint64(l)) n += 1 + sovGenerated(uint64(m.InitialDelaySeconds)) n += 1 + sovGenerated(uint64(m.TimeoutSeconds)) @@ -22690,6 +23012,31 @@ func (m *Probe) Size() (n int) { return n } +func (m *ProbeHandler) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Exec != nil { + l = m.Exec.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.HTTPGet != nil { + l = m.HTTPGet.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.TCPSocket != nil { + l = m.TCPSocket.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.GRPC != nil { + l = m.GRPC.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + func (m *ProjectedVolumeSource) Size() (n int) { if m == nil { return 0 @@ -24993,6 +25340,17 @@ func (this *GCEPersistentDiskVolumeSource) String() string { }, "") return s } +func (this *GRPCAction) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&GRPCAction{`, + `Port:` + fmt.Sprintf("%v", this.Port) + `,`, + `Service:` + valueToStringGenerated(this.Service) + `,`, + `}`, + }, "") + return s +} func (this *GitRepoVolumeSource) String() string { if this == nil { return "nil" @@ -25060,18 +25418,6 @@ func (this *HTTPHeader) String() string { }, "") return s } -func (this *Handler) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&Handler{`, - `Exec:` + strings.Replace(this.Exec.String(), "ExecAction", "ExecAction", 1) + `,`, - `HTTPGet:` + strings.Replace(this.HTTPGet.String(), "HTTPGetAction", "HTTPGetAction", 1) + `,`, - `TCPSocket:` + strings.Replace(this.TCPSocket.String(), "TCPSocketAction", "TCPSocketAction", 1) + `,`, - `}`, - }, "") - return s -} func (this *HostAlias) String() string { if this == nil { return "nil" @@ -25151,8 +25497,20 @@ func (this *Lifecycle) String() string { return "nil" } s := strings.Join([]string{`&Lifecycle{`, - `PostStart:` + strings.Replace(this.PostStart.String(), "Handler", "Handler", 1) + `,`, - `PreStop:` + strings.Replace(this.PreStop.String(), "Handler", "Handler", 1) + `,`, + `PostStart:` + strings.Replace(this.PostStart.String(), "LifecycleHandler", "LifecycleHandler", 1) + `,`, + `PreStop:` + strings.Replace(this.PreStop.String(), "LifecycleHandler", "LifecycleHandler", 1) + `,`, + `}`, + }, "") + return s +} +func (this *LifecycleHandler) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&LifecycleHandler{`, + `Exec:` + strings.Replace(this.Exec.String(), "ExecAction", "ExecAction", 1) + `,`, + `HTTPGet:` + strings.Replace(this.HTTPGet.String(), "HTTPGetAction", "HTTPGetAction", 1) + `,`, + `TCPSocket:` + strings.Replace(this.TCPSocket.String(), "TCPSocketAction", "TCPSocketAction", 1) + `,`, `}`, }, "") return s @@ -25812,11 +26170,23 @@ func (this *PersistentVolumeClaimStatus) String() string { mapStringForCapacity += fmt.Sprintf("%v: %v,", k, this.Capacity[ResourceName(k)]) } mapStringForCapacity += "}" + keysForAllocatedResources := make([]string, 0, len(this.AllocatedResources)) + for k := range this.AllocatedResources { + keysForAllocatedResources = append(keysForAllocatedResources, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAllocatedResources) + mapStringForAllocatedResources := "ResourceList{" + for _, k := range keysForAllocatedResources { + mapStringForAllocatedResources += fmt.Sprintf("%v: %v,", k, this.AllocatedResources[ResourceName(k)]) + } + mapStringForAllocatedResources += "}" s := strings.Join([]string{`&PersistentVolumeClaimStatus{`, `Phase:` + fmt.Sprintf("%v", this.Phase) + `,`, `AccessModes:` + fmt.Sprintf("%v", this.AccessModes) + `,`, `Capacity:` + mapStringForCapacity + `,`, `Conditions:` + repeatedStringForConditions + `,`, + `AllocatedResources:` + mapStringForAllocatedResources + `,`, + `ResizeStatus:` + valueToStringGenerated(this.ResizeStatus) + `,`, `}`, }, "") return s @@ -26124,6 +26494,16 @@ func (this *PodLogOptions) String() string { }, "") return s } +func (this *PodOS) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PodOS{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} func (this *PodPortForwardOptions) String() string { if this == nil { return "nil" @@ -26293,6 +26673,7 @@ func (this *PodSpec) String() string { `TopologySpreadConstraints:` + repeatedStringForTopologySpreadConstraints + `,`, `EphemeralContainers:` + repeatedStringForEphemeralContainers + `,`, `SetHostnameAsFQDN:` + valueToStringGenerated(this.SetHostnameAsFQDN) + `,`, + `OS:` + strings.Replace(this.OS.String(), "PodOS", "PodOS", 1) + `,`, `}`, }, "") return s @@ -26456,7 +26837,7 @@ func (this *Probe) String() string { return "nil" } s := strings.Join([]string{`&Probe{`, - `Handler:` + strings.Replace(strings.Replace(this.Handler.String(), "Handler", "Handler", 1), `&`, ``, 1) + `,`, + `ProbeHandler:` + strings.Replace(strings.Replace(this.ProbeHandler.String(), "ProbeHandler", "ProbeHandler", 1), `&`, ``, 1) + `,`, `InitialDelaySeconds:` + fmt.Sprintf("%v", this.InitialDelaySeconds) + `,`, `TimeoutSeconds:` + fmt.Sprintf("%v", this.TimeoutSeconds) + `,`, `PeriodSeconds:` + fmt.Sprintf("%v", this.PeriodSeconds) + `,`, @@ -26467,6 +26848,19 @@ func (this *Probe) String() string { }, "") return s } +func (this *ProbeHandler) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ProbeHandler{`, + `Exec:` + strings.Replace(this.Exec.String(), "ExecAction", "ExecAction", 1) + `,`, + `HTTPGet:` + strings.Replace(this.HTTPGet.String(), "HTTPGetAction", "HTTPGetAction", 1) + `,`, + `TCPSocket:` + strings.Replace(this.TCPSocket.String(), "TCPSocketAction", "TCPSocketAction", 1) + `,`, + `GRPC:` + strings.Replace(this.GRPC.String(), "GRPCAction", "GRPCAction", 1) + `,`, + `}`, + }, "") + return s +} func (this *ProjectedVolumeSource) String() string { if this == nil { return "nil" @@ -38625,7 +39019,7 @@ func (m *GCEPersistentDiskVolumeSource) Unmarshal(dAtA []byte) error { } return nil } -func (m *GitRepoVolumeSource) Unmarshal(dAtA []byte) error { +func (m *GRPCAction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -38648,15 +39042,34 @@ func (m *GitRepoVolumeSource) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GitRepoVolumeSource: wiretype end group for non-group") + return fmt.Errorf("proto: GRPCAction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GitRepoVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GRPCAction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + m.Port = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Port |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Repository", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -38684,71 +39097,8 @@ func (m *GitRepoVolumeSource) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Repository = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Revision = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Directory = string(dAtA[iNdEx:postIndex]) + s := string(dAtA[iNdEx:postIndex]) + m.Service = &s iNdEx = postIndex default: iNdEx = preIndex @@ -38771,7 +39121,7 @@ func (m *GitRepoVolumeSource) Unmarshal(dAtA []byte) error { } return nil } -func (m *GlusterfsPersistentVolumeSource) Unmarshal(dAtA []byte) error { +func (m *GitRepoVolumeSource) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -38794,15 +39144,15 @@ func (m *GlusterfsPersistentVolumeSource) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GlusterfsPersistentVolumeSource: wiretype end group for non-group") + return fmt.Errorf("proto: GitRepoVolumeSource: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GlusterfsPersistentVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GitRepoVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndpointsName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Repository", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -38830,11 +39180,11 @@ func (m *GlusterfsPersistentVolumeSource) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.EndpointsName = string(dAtA[iNdEx:postIndex]) + m.Repository = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -38862,31 +39212,11 @@ func (m *GlusterfsPersistentVolumeSource) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Path = string(dAtA[iNdEx:postIndex]) + m.Revision = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.ReadOnly = bool(v != 0) - case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndpointsNamespace", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -38914,8 +39244,7 @@ func (m *GlusterfsPersistentVolumeSource) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - s := string(dAtA[iNdEx:postIndex]) - m.EndpointsNamespace = &s + m.Directory = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -38938,7 +39267,7 @@ func (m *GlusterfsPersistentVolumeSource) Unmarshal(dAtA []byte) error { } return nil } -func (m *GlusterfsVolumeSource) Unmarshal(dAtA []byte) error { +func (m *GlusterfsPersistentVolumeSource) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -38961,10 +39290,10 @@ func (m *GlusterfsVolumeSource) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GlusterfsVolumeSource: wiretype end group for non-group") + return fmt.Errorf("proto: GlusterfsPersistentVolumeSource: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GlusterfsVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GlusterfsPersistentVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -39051,6 +39380,39 @@ func (m *GlusterfsVolumeSource) Unmarshal(dAtA []byte) error { } } m.ReadOnly = bool(v != 0) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndpointsNamespace", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.EndpointsNamespace = &s + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -39072,7 +39434,7 @@ func (m *GlusterfsVolumeSource) Unmarshal(dAtA []byte) error { } return nil } -func (m *HTTPGetAction) Unmarshal(dAtA []byte) error { +func (m *GlusterfsVolumeSource) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -39095,15 +39457,15 @@ func (m *HTTPGetAction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: HTTPGetAction: wiretype end group for non-group") + return fmt.Errorf("proto: GlusterfsVolumeSource: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: HTTPGetAction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GlusterfsVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EndpointsName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -39131,76 +39493,11 @@ func (m *HTTPGetAction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Path = string(dAtA[iNdEx:postIndex]) + m.EndpointsName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Host = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Scheme", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -39228,13 +39525,13 @@ func (m *HTTPGetAction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Scheme = URIScheme(dAtA[iNdEx:postIndex]) + m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field HTTPHeaders", wireType) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType) } - var msglen int + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -39244,26 +39541,12 @@ func (m *HTTPGetAction) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.HTTPHeaders = append(m.HTTPHeaders, HTTPHeader{}) - if err := m.HTTPHeaders[len(m.HTTPHeaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex + m.ReadOnly = bool(v != 0) default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -39285,7 +39568,7 @@ func (m *HTTPGetAction) Unmarshal(dAtA []byte) error { } return nil } -func (m *HTTPHeader) Unmarshal(dAtA []byte) error { +func (m *HTTPGetAction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -39308,15 +39591,15 @@ func (m *HTTPHeader) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: HTTPHeader: wiretype end group for non-group") + return fmt.Errorf("proto: HTTPGetAction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: HTTPHeader: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: HTTPGetAction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -39344,11 +39627,44 @@ func (m *HTTPHeader) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -39376,7 +39692,73 @@ func (m *HTTPHeader) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Value = string(dAtA[iNdEx:postIndex]) + m.Host = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Scheme", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Scheme = URIScheme(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HTTPHeaders", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.HTTPHeaders = append(m.HTTPHeaders, HTTPHeader{}) + if err := m.HTTPHeaders[len(m.HTTPHeaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -39399,7 +39781,7 @@ func (m *HTTPHeader) Unmarshal(dAtA []byte) error { } return nil } -func (m *Handler) Unmarshal(dAtA []byte) error { +func (m *HTTPHeader) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -39422,17 +39804,17 @@ func (m *Handler) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Handler: wiretype end group for non-group") + return fmt.Errorf("proto: HTTPHeader: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Handler: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: HTTPHeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Exec", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -39442,69 +39824,29 @@ func (m *Handler) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Exec == nil { - m.Exec = &ExecAction{} - } - if err := m.Exec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field HTTPGet", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.HTTPGet == nil { - m.HTTPGet = &HTTPGetAction{} - } - if err := m.HTTPGet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TCPSocket", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -39514,27 +39856,23 @@ func (m *Handler) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - if m.TCPSocket == nil { - m.TCPSocket = &TCPSocketAction{} - } - if err := m.TCPSocket.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Value = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -40695,7 +41033,7 @@ func (m *Lifecycle) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.PostStart == nil { - m.PostStart = &Handler{} + m.PostStart = &LifecycleHandler{} } if err := m.PostStart.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -40731,7 +41069,7 @@ func (m *Lifecycle) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.PreStop == nil { - m.PreStop = &Handler{} + m.PreStop = &LifecycleHandler{} } if err := m.PreStop.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -40758,7 +41096,7 @@ func (m *Lifecycle) Unmarshal(dAtA []byte) error { } return nil } -func (m *LimitRange) Unmarshal(dAtA []byte) error { +func (m *LifecycleHandler) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -40781,15 +41119,173 @@ func (m *LimitRange) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: LimitRange: wiretype end group for non-group") + return fmt.Errorf("proto: LifecycleHandler: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: LimitRange: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LifecycleHandler: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Exec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Exec == nil { + m.Exec = &ExecAction{} + } + if err := m.Exec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HTTPGet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HTTPGet == nil { + m.HTTPGet = &HTTPGetAction{} + } + if err := m.HTTPGet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TCPSocket", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TCPSocket == nil { + m.TCPSocket = &TCPSocketAction{} + } + if err := m.TCPSocket.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LimitRange) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LimitRange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LimitRange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -47741,6 +48237,168 @@ func (m *PersistentVolumeClaimStatus) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllocatedResources", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AllocatedResources == nil { + m.AllocatedResources = make(ResourceList) + } + var mapkey ResourceName + mapvalue := &resource.Quantity{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthGenerated + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &resource.Quantity{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.AllocatedResources[ResourceName(mapkey)] = *mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResizeStatus", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := PersistentVolumeClaimResizeStatus(dAtA[iNdEx:postIndex]) + m.ResizeStatus = &s + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -51535,6 +52193,88 @@ func (m *PodLogOptions) Unmarshal(dAtA []byte) error { } return nil } +func (m *PodOS) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PodOS: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PodOS: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = OSName(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *PodPortForwardOptions) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -53550,6 +54290,42 @@ func (m *PodSpec) Unmarshal(dAtA []byte) error { } b := bool(v != 0) m.SetHostnameAsFQDN = &b + case 36: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OS", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.OS == nil { + m.OS = &PodOS{} + } + if err := m.OS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -55180,7 +55956,7 @@ func (m *Probe) Unmarshal(dAtA []byte) error { switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Handler", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ProbeHandler", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -55207,7 +55983,7 @@ func (m *Probe) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Handler.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ProbeHandler.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -55347,6 +56123,200 @@ func (m *Probe) Unmarshal(dAtA []byte) error { } return nil } +func (m *ProbeHandler) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ProbeHandler: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProbeHandler: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Exec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Exec == nil { + m.Exec = &ExecAction{} + } + if err := m.Exec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HTTPGet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HTTPGet == nil { + m.HTTPGet = &HTTPGetAction{} + } + if err := m.HTTPGet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TCPSocket", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TCPSocket == nil { + m.TCPSocket = &TCPSocketAction{} + } + if err := m.TCPSocket.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GRPC", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GRPC == nil { + m.GRPC = &GRPCAction{} + } + if err := m.GRPC.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *ProjectedVolumeSource) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/vendor/k8s.io/api/core/v1/generated.proto b/vendor/k8s.io/api/core/v1/generated.proto index ff63fd29f3..b5b44781f0 100644 --- a/vendor/k8s.io/api/core/v1/generated.proto +++ b/vendor/k8s.io/api/core/v1/generated.proto @@ -908,15 +908,11 @@ message ContainerStatus { // Specifies whether the container has passed its readiness probe. optional bool ready = 4; - // The number of times the container has been restarted, currently based on - // the number of dead containers that have not yet been removed. - // Note that this is calculated from dead containers. But those containers are subject to - // garbage collection. This value will get capped at 5 by GC. + // The number of times the container has been restarted. optional int32 restartCount = 5; // The image the container is running. - // More info: https://kubernetes.io/docs/concepts/containers/images - // TODO(dchen1107): Which image the container is running with? + // More info: https://kubernetes.io/docs/concepts/containers/images. optional string image = 6; // ImageID of the container's image. @@ -1190,15 +1186,16 @@ message EnvVarSource { optional SecretKeySelector secretKeyRef = 4; } -// An EphemeralContainer is a container that may be added temporarily to an existing pod for +// An EphemeralContainer is a temporary container that you may add to an existing Pod for // user-initiated activities such as debugging. Ephemeral containers have no resource or -// scheduling guarantees, and they will not be restarted when they exit or when a pod is -// removed or restarted. If an ephemeral container causes a pod to exceed its resource -// allocation, the pod may be evicted. -// Ephemeral containers may not be added by directly updating the pod spec. They must be added -// via the pod's ephemeralcontainers subresource, and they will appear in the pod spec -// once added. -// This is an alpha feature enabled by the EphemeralContainers feature flag. +// scheduling guarantees, and they will not be restarted when they exit or when a Pod is +// removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the +// Pod to exceed its resource allocation. +// +// To add an ephemeral container, use the ephemeralcontainers subresource of an existing +// Pod. Ephemeral containers may not be removed or restarted. +// +// This is a beta feature available on clusters that haven't disabled the EphemeralContainers feature gate. message EphemeralContainer { // Ephemeral containers have all of the fields of Container, plus additional fields // specific to ephemeral containers. Fields in common with Container are in the @@ -1208,8 +1205,10 @@ message EphemeralContainer { // If set, the name of the container from PodSpec that this ephemeral container targets. // The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. - // If not set then the ephemeral container is run in whatever namespaces are shared - // for the pod. Note that the container runtime must support this feature. + // If not set then the ephemeral container uses the namespaces configured in the Pod spec. + // + // The container runtime must implement support for this feature. If the runtime does not + // support namespace targeting then the result of setting this field is undefined. // +optional optional string targetContainerName = 2; } @@ -1257,6 +1256,12 @@ message EphemeralContainerCommon { optional string workingDir = 5; // Ports are not allowed for ephemeral containers. + // +optional + // +patchMergeKey=containerPort + // +patchStrategy=merge + // +listType=map + // +listMapKey=containerPort + // +listMapKey=protocol repeated ContainerPort ports = 6; // List of sources to populate environment variables in the container. @@ -1280,7 +1285,7 @@ message EphemeralContainerCommon { // +optional optional ResourceRequirements resources = 8; - // Pod volumes to mount into the container's filesystem. + // Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. // Cannot be updated. // +optional // +patchMergeKey=mountPath @@ -1641,6 +1646,19 @@ message GCEPersistentDiskVolumeSource { optional bool readOnly = 4; } +message GRPCAction { + // Port number of the gRPC service. Number must be in the range 1 to 65535. + optional int32 port = 1; + + // Service is the name of the service to place in the gRPC HealthCheckRequest + // (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + // + // If this is not specified, the default behavior is defined by gRPC. + // +optional + // +default="" + optional string service = 2; +} + // Represents a volume that is populated with the contents of a git repository. // Git repo volumes do not support ownership management. // Git repo volumes support SELinux relabeling. @@ -1741,25 +1759,6 @@ message HTTPHeader { optional string value = 2; } -// Handler defines a specific action that should be taken -// TODO: pass structured data to these actions, and document that data here. -message Handler { - // One and only one of the following should be specified. - // Exec specifies the action to take. - // +optional - optional ExecAction exec = 1; - - // HTTPGet specifies the http request to perform. - // +optional - optional HTTPGetAction httpGet = 2; - - // TCPSocket specifies an action involving a TCP port. - // TCP hooks not yet supported - // TODO: implement a realistic TCP lifecycle hook - // +optional - optional TCPSocketAction tcpSocket = 3; -} - // HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the // pod's hosts file. message HostAlias { @@ -1927,20 +1926,37 @@ message Lifecycle { // Other management of the container blocks until the hook completes. // More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks // +optional - optional Handler postStart = 1; + optional LifecycleHandler postStart = 1; // PreStop is called immediately before a container is terminated due to an // API request or management event such as liveness/startup probe failure, // preemption, resource contention, etc. The handler is not called if the - // container crashes or exits. The reason for termination is passed to the - // handler. The Pod's termination grace period countdown begins before the - // PreStop hooked is executed. Regardless of the outcome of the handler, the + // container crashes or exits. The Pod's termination grace period countdown begins before the + // PreStop hook is executed. Regardless of the outcome of the handler, the // container will eventually terminate within the Pod's termination grace - // period. Other management of the container blocks until the hook completes + // period (unless delayed by finalizers). Other management of the container blocks until the hook completes // or until the termination grace period is reached. // More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks // +optional - optional Handler preStop = 2; + optional LifecycleHandler preStop = 2; +} + +// LifecycleHandler defines a specific action that should be taken in a lifecycle +// hook. One and only one of the fields, except TCPSocket must be specified. +message LifecycleHandler { + // Exec specifies the action to take. + // +optional + optional ExecAction exec = 1; + + // HTTPGet specifies the http request to perform. + // +optional + optional HTTPGetAction httpGet = 2; + + // Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept + // for the backward compatibility. There are no validation of this field and + // lifecycle hooks will fail in runtime when tcp handler is specified. + // +optional + optional TCPSocketAction tcpSocket = 3; } // LimitRange sets resource usage limits for each kind of resource in a Namespace. @@ -2059,7 +2075,7 @@ message LocalVolumeSource { // Filesystem type to mount. // It applies only when the Path is a block device. // Must be a filesystem type supported by the host operating system. - // Ex. "ext4", "xfs", "ntfs". The default value is to auto-select a fileystem if unspecified. + // Ex. "ext4", "xfs", "ntfs". The default value is to auto-select a filesystem if unspecified. // +optional optional string fsType = 2; } @@ -2662,6 +2678,9 @@ message PersistentVolumeClaimSpec { optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 4; // Resources represents the minimum resources the volume should have. + // If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements + // that are lower than previous value but must still be higher than capacity recorded in the + // status field of the claim. // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources // +optional optional ResourceRequirements resources = 2; @@ -2732,6 +2751,26 @@ message PersistentVolumeClaimStatus { // +patchMergeKey=type // +patchStrategy=merge repeated PersistentVolumeClaimCondition conditions = 4; + + // The storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may + // be larger than the actual capacity when a volume expansion operation is requested. + // For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. + // If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. + // If a volume expansion capacity request is lowered, allocatedResources is only + // lowered if there are no expansion operations in progress and if the actual volume capacity + // is equal or lower than the requested capacity. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + map allocatedResources = 5; + + // ResizeStatus stores status of resize operation. + // ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty + // string by resize controller or kubelet. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + optional string resizeStatus = 6; } // PersistentVolumeClaimTemplate is used to produce @@ -3176,12 +3215,10 @@ message PodExecOptions { optional bool stdin = 1; // Redirect the standard output stream of the pod for this call. - // Defaults to true. // +optional optional bool stdout = 2; // Redirect the standard error stream of the pod for this call. - // Defaults to true. // +optional optional bool stderr = 3; @@ -3273,6 +3310,15 @@ message PodLogOptions { optional bool insecureSkipTLSVerifyBackend = 9; } +// PodOS defines the OS parameters of a pod. +message PodOS { + // Name is the name of the operating system. The currently supported values are linux and windows. + // Additional value may be defined in future and can be one of: + // https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration + // Clients should expect to handle additional values and treat unrecognized values in this field as os: null + optional string name = 1; +} + // PodPortForwardOptions is the query options to a Pod's port forward call // when using WebSockets. // The `port` query parameter must specify the port or @@ -3308,12 +3354,14 @@ message PodSecurityContext { // container. May also be set in SecurityContext. If set in // both SecurityContext and PodSecurityContext, the value specified in SecurityContext // takes precedence for that container. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional SELinuxOptions seLinuxOptions = 1; // The Windows specific settings applied to all containers. // If unspecified, the options within a container's SecurityContext will be used. // If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is linux. // +optional optional WindowsSecurityContextOptions windowsOptions = 8; @@ -3322,6 +3370,7 @@ message PodSecurityContext { // May also be set in SecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence // for that container. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional int64 runAsUser = 2; @@ -3330,6 +3379,7 @@ message PodSecurityContext { // May also be set in SecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence // for that container. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional int64 runAsGroup = 6; @@ -3345,6 +3395,7 @@ message PodSecurityContext { // A list of groups applied to the first process run in each container, in addition // to the container's primary GID. If unspecified, no groups will be added to // any container. + // Note that this field cannot be set when spec.os.name is windows. // +optional repeated int64 supplementalGroups = 4; @@ -3357,11 +3408,13 @@ message PodSecurityContext { // 3. The permission bits are OR'd with rw-rw---- // // If unset, the Kubelet will not modify the ownership and permissions of any volume. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional int64 fsGroup = 5; // Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported // sysctls (by the container runtime) might fail to launch. + // Note that this field cannot be set when spec.os.name is windows. // +optional repeated Sysctl sysctls = 7; @@ -3371,10 +3424,12 @@ message PodSecurityContext { // It will have no effect on ephemeral volume types such as: secret, configmaps // and emptydir. // Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional string fsGroupChangePolicy = 9; // The seccomp options to use by the containers in this pod. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional SeccompProfile seccompProfile = 10; } @@ -3425,7 +3480,7 @@ message PodSpec { // pod to perform user-initiated actions such as debugging. This list cannot be specified when // creating a pod, and it cannot be modified by updating the pod spec. In order to add an // ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. - // This field is alpha-level and is only honored by servers that enable the EphemeralContainers feature. + // This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate. // +optional // +patchMergeKey=name // +patchStrategy=merge @@ -3645,6 +3700,37 @@ message PodSpec { // Default to false. // +optional optional bool setHostnameAsFQDN = 35; + + // Specifies the OS of the containers in the pod. + // Some pod and container fields are restricted if this is set. + // + // If the OS field is set to linux, the following fields must be unset: + // -securityContext.windowsOptions + // + // If the OS field is set to windows, following fields must be unset: + // - spec.hostPID + // - spec.hostIPC + // - spec.securityContext.seLinuxOptions + // - spec.securityContext.seccompProfile + // - spec.securityContext.fsGroup + // - spec.securityContext.fsGroupChangePolicy + // - spec.securityContext.sysctls + // - spec.shareProcessNamespace + // - spec.securityContext.runAsUser + // - spec.securityContext.runAsGroup + // - spec.securityContext.supplementalGroups + // - spec.containers[*].securityContext.seLinuxOptions + // - spec.containers[*].securityContext.seccompProfile + // - spec.containers[*].securityContext.capabilities + // - spec.containers[*].securityContext.readOnlyRootFilesystem + // - spec.containers[*].securityContext.privileged + // - spec.containers[*].securityContext.allowPrivilegeEscalation + // - spec.containers[*].securityContext.procMount + // - spec.containers[*].securityContext.runAsUser + // - spec.containers[*].securityContext.runAsGroup + // +optional + // This is an alpha field and requires the IdentifyPodOS feature + optional PodOS os = 36; } // PodStatus represents information about the status of a pod. Status may trail the actual @@ -3739,7 +3825,7 @@ message PodStatus { optional string qosClass = 9; // Status for any ephemeral containers that have run in this pod. - // This field is alpha-level and is only populated by servers that enable the EphemeralContainers feature. + // This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate. // +optional repeated ContainerStatus ephemeralContainerStatuses = 13; } @@ -3876,7 +3962,7 @@ message PreferredSchedulingTerm { // alive or ready to receive traffic. message Probe { // The action taken to determine the health of a container - optional Handler handler = 1; + optional ProbeHandler handler = 1; // Number of seconds after the container has started before liveness probes are initiated. // More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes @@ -3918,6 +4004,28 @@ message Probe { optional int64 terminationGracePeriodSeconds = 7; } +// ProbeHandler defines a specific action that should be taken in a probe. +// One and only one of the fields must be specified. +message ProbeHandler { + // Exec specifies the action to take. + // +optional + optional ExecAction exec = 1; + + // HTTPGet specifies the http request to perform. + // +optional + optional HTTPGetAction httpGet = 2; + + // TCPSocket specifies an action involving a TCP port. + // +optional + optional TCPSocketAction tcpSocket = 3; + + // GRPC specifies an action involving a GRPC port. + // This is an alpha field and requires enabling GRPCContainerProbe feature gate. + // +featureGate=GRPCContainerProbe + // +optional + optional GRPCAction grpc = 4; +} + // Represents a projected volume source message ProjectedVolumeSource { // list of volume projections @@ -4479,6 +4587,7 @@ message Secret { map stringData = 4; // Used to facilitate programmatic handling of secret data. + // More info: https://kubernetes.io/docs/concepts/configuration/secret/#secret-types // +optional optional string type = 3; } @@ -4602,12 +4711,14 @@ message SecretVolumeSource { message SecurityContext { // The capabilities to add/drop when running containers. // Defaults to the default set of capabilities granted by the container runtime. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional Capabilities capabilities = 1; // Run container in privileged mode. // Processes in privileged containers are essentially equivalent to root on the host. // Defaults to false. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional bool privileged = 2; @@ -4615,12 +4726,14 @@ message SecurityContext { // If unspecified, the container runtime will allocate a random SELinux context for each // container. May also be set in PodSecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional SELinuxOptions seLinuxOptions = 3; // The Windows specific settings applied to all containers. // If unspecified, the options from the PodSecurityContext will be used. // If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is linux. // +optional optional WindowsSecurityContextOptions windowsOptions = 10; @@ -4628,6 +4741,7 @@ message SecurityContext { // Defaults to user specified in image metadata if unspecified. // May also be set in PodSecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional int64 runAsUser = 4; @@ -4635,6 +4749,7 @@ message SecurityContext { // Uses runtime default if unset. // May also be set in PodSecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional int64 runAsGroup = 8; @@ -4649,6 +4764,7 @@ message SecurityContext { // Whether this container has a read-only root filesystem. // Default is false. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional bool readOnlyRootFilesystem = 6; @@ -4658,6 +4774,7 @@ message SecurityContext { // AllowPrivilegeEscalation is true always when the container is: // 1) run as Privileged // 2) has CAP_SYS_ADMIN + // Note that this field cannot be set when spec.os.name is windows. // +optional optional bool allowPrivilegeEscalation = 7; @@ -4665,12 +4782,14 @@ message SecurityContext { // The default is DefaultProcMount which uses the container runtime defaults for // readonly paths and masked paths. // This requires the ProcMountType feature flag to be enabled. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional string procMount = 9; // The seccomp options to use by this container. If seccomp options are // provided at both the pod & container level, the container options // override the pod options. + // Note that this field cannot be set when spec.os.name is windows. // +optional optional SeccompProfile seccompProfile = 11; } @@ -4904,12 +5023,9 @@ message ServiceSpec { // clients must ensure that clusterIPs[0] and clusterIP have the same // value. // - // Unless the "IPv6DualStack" feature gate is enabled, this field is - // limited to one value, which must be the same as the clusterIP field. If - // the feature gate is enabled, this field may hold a maximum of two - // entries (dual-stack IPs, in either order). These IPs must correspond to - // the values of the ipFamilies field. Both clusterIPs and ipFamilies are - // governed by the ipFamilyPolicy field. + // This field may hold a maximum of two entries (dual-stack IPs, in either order). + // These IPs must correspond to the values of the ipFamilies field. Both + // clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. // More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies // +listType=atomic // +optional @@ -5009,17 +5125,16 @@ message ServiceSpec { optional SessionAffinityConfig sessionAffinityConfig = 14; // IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this - // service, and is gated by the "IPv6DualStack" feature gate. This field - // is usually assigned automatically based on cluster configuration and the - // ipFamilyPolicy field. If this field is specified manually, the requested - // family is available in the cluster, and ipFamilyPolicy allows it, it - // will be used; otherwise creation of the service will fail. This field - // is conditionally mutable: it allows for adding or removing a secondary - // IP family, but it does not allow changing the primary IP family of the - // Service. Valid values are "IPv4" and "IPv6". This field only applies - // to Services of types ClusterIP, NodePort, and LoadBalancer, and does - // apply to "headless" services. This field will be wiped when updating a - // Service to type ExternalName. + // service. This field is usually assigned automatically based on cluster + // configuration and the ipFamilyPolicy field. If this field is specified + // manually, the requested family is available in the cluster, + // and ipFamilyPolicy allows it, it will be used; otherwise creation of + // the service will fail. This field is conditionally mutable: it allows + // for adding or removing a secondary IP family, but it does not allow + // changing the primary IP family of the Service. Valid values are "IPv4" + // and "IPv6". This field only applies to Services of types ClusterIP, + // NodePort, and LoadBalancer, and does apply to "headless" services. + // This field will be wiped when updating a Service to type ExternalName. // // This field may hold a maximum of two entries (dual-stack families, in // either order). These families must correspond to the values of the @@ -5030,14 +5145,13 @@ message ServiceSpec { repeated string ipFamilies = 19; // IPFamilyPolicy represents the dual-stack-ness requested or required by - // this Service, and is gated by the "IPv6DualStack" feature gate. If - // there is no value provided, then this field will be set to SingleStack. - // Services can be "SingleStack" (a single IP family), "PreferDualStack" - // (two IP families on dual-stack configured clusters or a single IP family - // on single-stack clusters), or "RequireDualStack" (two IP families on - // dual-stack configured clusters, otherwise fail). The ipFamilies and - // clusterIPs fields depend on the value of this field. This field will be - // wiped when updating a service to type ExternalName. + // this Service. If there is no value provided, then this field will be set + // to SingleStack. Services can be "SingleStack" (a single IP family), + // "PreferDualStack" (two IP families on dual-stack configured clusters or + // a single IP family on single-stack clusters), or "RequireDualStack" + // (two IP families on dual-stack configured clusters, otherwise fail). The + // ipFamilies and clusterIPs fields depend on the value of this field. This + // field will be wiped when updating a service to type ExternalName. // +optional optional string ipFamilyPolicy = 17; @@ -5298,7 +5412,7 @@ message TopologySpreadConstraint { // but giving higher precedence to topologies that would help reduce the // skew. // A constraint is considered "Unsatisfiable" for an incoming pod - // if and only if every possible node assigment for that pod would violate + // if and only if every possible node assignment for that pod would violate // "MaxSkew" on some topology. // For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same // labelSelector spread as 3/1/1: @@ -5582,9 +5696,6 @@ message VolumeSource { // A pod can use both types of ephemeral volumes and // persistent volumes at the same time. // - // This is a beta feature and only available when the GenericEphemeralVolume - // feature gate is enabled. - // // +optional optional EphemeralVolumeSource ephemeral = 29; } diff --git a/vendor/k8s.io/api/core/v1/types.go b/vendor/k8s.io/api/core/v1/types.go index 027d73edd1..80c5dd744c 100644 --- a/vendor/k8s.io/api/core/v1/types.go +++ b/vendor/k8s.io/api/core/v1/types.go @@ -179,9 +179,6 @@ type VolumeSource struct { // A pod can use both types of ephemeral volumes and // persistent volumes at the same time. // - // This is a beta feature and only available when the GenericEphemeralVolume - // feature gate is enabled. - // // +optional Ephemeral *EphemeralVolumeSource `json:"ephemeral,omitempty" protobuf:"bytes,29,opt,name=ephemeral"` } @@ -374,6 +371,7 @@ type VolumeNodeAffinity struct { } // PersistentVolumeReclaimPolicy describes a policy for end-of-life maintenance of persistent volumes. +// +enum type PersistentVolumeReclaimPolicy string const ( @@ -389,6 +387,7 @@ const ( ) // PersistentVolumeMode describes how a volume is intended to be consumed, either Block or Filesystem. +// +enum type PersistentVolumeMode string const ( @@ -475,6 +474,9 @@ type PersistentVolumeClaimSpec struct { // +optional Selector *metav1.LabelSelector `json:"selector,omitempty" protobuf:"bytes,4,opt,name=selector"` // Resources represents the minimum resources the volume should have. + // If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements + // that are lower than previous value but must still be higher than capacity recorded in the + // status field of the claim. // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources // +optional Resources ResourceRequirements `json:"resources,omitempty" protobuf:"bytes,2,opt,name=resources"` @@ -520,6 +522,7 @@ type PersistentVolumeClaimSpec struct { } // PersistentVolumeClaimConditionType is a valid value of PersistentVolumeClaimCondition.Type +// +enum type PersistentVolumeClaimConditionType string const ( @@ -529,6 +532,26 @@ const ( PersistentVolumeClaimFileSystemResizePending PersistentVolumeClaimConditionType = "FileSystemResizePending" ) +// +enum +type PersistentVolumeClaimResizeStatus string + +const ( + // When expansion is complete, the empty string is set by resize controller or kubelet. + PersistentVolumeClaimNoExpansionInProgress PersistentVolumeClaimResizeStatus = "" + // State set when resize controller starts expanding the volume in control-plane + PersistentVolumeClaimControllerExpansionInProgress PersistentVolumeClaimResizeStatus = "ControllerExpansionInProgress" + // State set when expansion has failed in resize controller with a terminal error. + // Transient errors such as timeout should not set this status and should leave ResizeStatus + // unmodified, so as resize controller can resume the volume expansion. + PersistentVolumeClaimControllerExpansionFailed PersistentVolumeClaimResizeStatus = "ControllerExpansionFailed" + // State set when resize controller has finished expanding the volume but further expansion is needed on the node. + PersistentVolumeClaimNodeExpansionPending PersistentVolumeClaimResizeStatus = "NodeExpansionPending" + // State set when kubelet starts expanding the volume. + PersistentVolumeClaimNodeExpansionInProgress PersistentVolumeClaimResizeStatus = "NodeExpansionInProgress" + // State set when expansion has failed in kubelet with a terminal error. Transient errors don't set NodeExpansionFailed. + PersistentVolumeClaimNodeExpansionFailed PersistentVolumeClaimResizeStatus = "NodeExpansionFailed" +) + // PersistentVolumeClaimCondition contails details about state of pvc type PersistentVolumeClaimCondition struct { Type PersistentVolumeClaimConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=PersistentVolumeClaimConditionType"` @@ -567,8 +590,27 @@ type PersistentVolumeClaimStatus struct { // +patchMergeKey=type // +patchStrategy=merge Conditions []PersistentVolumeClaimCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,4,rep,name=conditions"` -} - + // The storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may + // be larger than the actual capacity when a volume expansion operation is requested. + // For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. + // If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. + // If a volume expansion capacity request is lowered, allocatedResources is only + // lowered if there are no expansion operations in progress and if the actual volume capacity + // is equal or lower than the requested capacity. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + AllocatedResources ResourceList `json:"allocatedResources,omitempty" protobuf:"bytes,5,rep,name=allocatedResources,casttype=ResourceList,castkey=ResourceName"` + // ResizeStatus stores status of resize operation. + // ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty + // string by resize controller or kubelet. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + ResizeStatus *PersistentVolumeClaimResizeStatus `json:"resizeStatus,omitempty" protobuf:"bytes,6,opt,name=resizeStatus,casttype=PersistentVolumeClaimResizeStatus"` +} + +// +enum type PersistentVolumeAccessMode string const ( @@ -583,6 +625,7 @@ const ( ReadWriteOncePod PersistentVolumeAccessMode = "ReadWriteOncePod" ) +// +enum type PersistentVolumePhase string const ( @@ -601,6 +644,7 @@ const ( VolumeFailed PersistentVolumePhase = "Failed" ) +// +enum type PersistentVolumeClaimPhase string const ( @@ -614,6 +658,7 @@ const ( ClaimLost PersistentVolumeClaimPhase = "Lost" ) +// +enum type HostPathType string const ( @@ -942,6 +987,7 @@ const ( ) // Protocol defines network protocols supported for things like container ports. +// +enum type Protocol string const ( @@ -1370,7 +1416,10 @@ type PhotonPersistentDiskVolumeSource struct { FSType string `json:"fsType,omitempty" protobuf:"bytes,2,opt,name=fsType"` } +// +enum type AzureDataDiskCachingMode string + +// +enum type AzureDataDiskKind string const ( @@ -1697,7 +1746,7 @@ type LocalVolumeSource struct { // Filesystem type to mount. // It applies only when the Path is a block device. // Must be a filesystem type supported by the host operating system. - // Ex. "ext4", "xfs", "ntfs". The default value is to auto-select a fileystem if unspecified. + // Ex. "ext4", "xfs", "ntfs". The default value is to auto-select a filesystem if unspecified. // +optional FSType *string `json:"fsType,omitempty" protobuf:"bytes,2,opt,name=fsType"` } @@ -1895,6 +1944,7 @@ type VolumeMount struct { } // MountPropagationMode describes mount propagation. +// +enum type MountPropagationMode string const ( @@ -2085,6 +2135,7 @@ type HTTPGetAction struct { } // URIScheme identifies the scheme used for connection to a host for Get actions +// +enum type URIScheme string const ( @@ -2105,6 +2156,19 @@ type TCPSocketAction struct { Host string `json:"host,omitempty" protobuf:"bytes,2,opt,name=host"` } +type GRPCAction struct { + // Port number of the gRPC service. Number must be in the range 1 to 65535. + Port int32 `json:"port" protobuf:"bytes,1,opt,name=port"` + + // Service is the name of the service to place in the gRPC HealthCheckRequest + // (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + // + // If this is not specified, the default behavior is defined by gRPC. + // +optional + // +default="" + Service *string `json:"service" protobuf:"bytes,2,opt,name=service"` +} + // ExecAction describes a "run in container" action. type ExecAction struct { // Command is the command line to execute inside the container, the working directory for the @@ -2120,7 +2184,7 @@ type ExecAction struct { // alive or ready to receive traffic. type Probe struct { // The action taken to determine the health of a container - Handler `json:",inline" protobuf:"bytes,1,opt,name=handler"` + ProbeHandler `json:",inline" protobuf:"bytes,1,opt,name=handler"` // Number of seconds after the container has started before liveness probes are initiated. // More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes // +optional @@ -2157,6 +2221,7 @@ type Probe struct { } // PullPolicy describes a policy for if/when to pull a container image +// +enum type PullPolicy string const ( @@ -2169,6 +2234,7 @@ const ( ) // PreemptionPolicy describes a policy for if/when to preempt a pod. +// +enum type PreemptionPolicy string const ( @@ -2179,6 +2245,7 @@ const ( ) // TerminationMessagePolicy describes how termination messages are retrieved from a container. +// +enum type TerminationMessagePolicy string const ( @@ -2384,10 +2451,9 @@ type Container struct { TTY bool `json:"tty,omitempty" protobuf:"varint,18,opt,name=tty"` } -// Handler defines a specific action that should be taken -// TODO: pass structured data to these actions, and document that data here. -type Handler struct { - // One and only one of the following should be specified. +// ProbeHandler defines a specific action that should be taken in a probe. +// One and only one of the fields must be specified. +type ProbeHandler struct { // Exec specifies the action to take. // +optional Exec *ExecAction `json:"exec,omitempty" protobuf:"bytes,1,opt,name=exec"` @@ -2395,8 +2461,28 @@ type Handler struct { // +optional HTTPGet *HTTPGetAction `json:"httpGet,omitempty" protobuf:"bytes,2,opt,name=httpGet"` // TCPSocket specifies an action involving a TCP port. - // TCP hooks not yet supported - // TODO: implement a realistic TCP lifecycle hook + // +optional + TCPSocket *TCPSocketAction `json:"tcpSocket,omitempty" protobuf:"bytes,3,opt,name=tcpSocket"` + + // GRPC specifies an action involving a GRPC port. + // This is an alpha field and requires enabling GRPCContainerProbe feature gate. + // +featureGate=GRPCContainerProbe + // +optional + GRPC *GRPCAction `json:"grpc,omitempty" protobuf:"bytes,4,opt,name=grpc"` +} + +// LifecycleHandler defines a specific action that should be taken in a lifecycle +// hook. One and only one of the fields, except TCPSocket must be specified. +type LifecycleHandler struct { + // Exec specifies the action to take. + // +optional + Exec *ExecAction `json:"exec,omitempty" protobuf:"bytes,1,opt,name=exec"` + // HTTPGet specifies the http request to perform. + // +optional + HTTPGet *HTTPGetAction `json:"httpGet,omitempty" protobuf:"bytes,2,opt,name=httpGet"` + // Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept + // for the backward compatibility. There are no validation of this field and + // lifecycle hooks will fail in runtime when tcp handler is specified. // +optional TCPSocket *TCPSocketAction `json:"tcpSocket,omitempty" protobuf:"bytes,3,opt,name=tcpSocket"` } @@ -2410,19 +2496,18 @@ type Lifecycle struct { // Other management of the container blocks until the hook completes. // More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks // +optional - PostStart *Handler `json:"postStart,omitempty" protobuf:"bytes,1,opt,name=postStart"` + PostStart *LifecycleHandler `json:"postStart,omitempty" protobuf:"bytes,1,opt,name=postStart"` // PreStop is called immediately before a container is terminated due to an // API request or management event such as liveness/startup probe failure, // preemption, resource contention, etc. The handler is not called if the - // container crashes or exits. The reason for termination is passed to the - // handler. The Pod's termination grace period countdown begins before the - // PreStop hooked is executed. Regardless of the outcome of the handler, the + // container crashes or exits. The Pod's termination grace period countdown begins before the + // PreStop hook is executed. Regardless of the outcome of the handler, the // container will eventually terminate within the Pod's termination grace - // period. Other management of the container blocks until the hook completes + // period (unless delayed by finalizers). Other management of the container blocks until the hook completes // or until the termination grace period is reached. // More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks // +optional - PreStop *Handler `json:"preStop,omitempty" protobuf:"bytes,2,opt,name=preStop"` + PreStop *LifecycleHandler `json:"preStop,omitempty" protobuf:"bytes,2,opt,name=preStop"` } type ConditionStatus string @@ -2506,14 +2591,10 @@ type ContainerStatus struct { LastTerminationState ContainerState `json:"lastState,omitempty" protobuf:"bytes,3,opt,name=lastState"` // Specifies whether the container has passed its readiness probe. Ready bool `json:"ready" protobuf:"varint,4,opt,name=ready"` - // The number of times the container has been restarted, currently based on - // the number of dead containers that have not yet been removed. - // Note that this is calculated from dead containers. But those containers are subject to - // garbage collection. This value will get capped at 5 by GC. + // The number of times the container has been restarted. RestartCount int32 `json:"restartCount" protobuf:"varint,5,opt,name=restartCount"` // The image the container is running. - // More info: https://kubernetes.io/docs/concepts/containers/images - // TODO(dchen1107): Which image the container is running with? + // More info: https://kubernetes.io/docs/concepts/containers/images. Image string `json:"image" protobuf:"bytes,6,opt,name=image"` // ImageID of the container's image. ImageID string `json:"imageID" protobuf:"bytes,7,opt,name=imageID"` @@ -2529,6 +2610,7 @@ type ContainerStatus struct { } // PodPhase is a label for the condition of a pod at the current time. +// +enum type PodPhase string // These are the valid statuses of pods. @@ -2553,6 +2635,7 @@ const ( ) // PodConditionType is a valid value for PodCondition.Type +// +enum type PodConditionType string // These are valid conditions of pod. @@ -2602,6 +2685,7 @@ type PodCondition struct { // Only one of the following restart policies may be specified. // If none of the following policies is specified, the default one // is RestartPolicyAlways. +// +enum type RestartPolicy string const ( @@ -2611,6 +2695,7 @@ const ( ) // DNSPolicy defines how a pod's DNS will be configured. +// +enum type DNSPolicy string const ( @@ -2681,6 +2766,7 @@ type NodeSelectorRequirement struct { // A node selector operator is the set of operators that can be used in // a node selector requirement. +// +enum type NodeSelectorOperator string const ( @@ -2898,6 +2984,7 @@ type Taint struct { TimeAdded *metav1.Time `json:"timeAdded,omitempty" protobuf:"bytes,4,opt,name=timeAdded"` } +// +enum type TaintEffect string const ( @@ -2951,6 +3038,7 @@ type Toleration struct { } // A toleration operator is the set of operators that can be used in a toleration. +// +enum type TolerationOperator string const ( @@ -2999,7 +3087,7 @@ type PodSpec struct { // pod to perform user-initiated actions such as debugging. This list cannot be specified when // creating a pod, and it cannot be modified by updating the pod spec. In order to add an // ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. - // This field is alpha-level and is only honored by servers that enable the EphemeralContainers feature. + // This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate. // +optional // +patchMergeKey=name // +patchStrategy=merge @@ -3190,8 +3278,57 @@ type PodSpec struct { // Default to false. // +optional SetHostnameAsFQDN *bool `json:"setHostnameAsFQDN,omitempty" protobuf:"varint,35,opt,name=setHostnameAsFQDN"` + // Specifies the OS of the containers in the pod. + // Some pod and container fields are restricted if this is set. + // + // If the OS field is set to linux, the following fields must be unset: + // -securityContext.windowsOptions + // + // If the OS field is set to windows, following fields must be unset: + // - spec.hostPID + // - spec.hostIPC + // - spec.securityContext.seLinuxOptions + // - spec.securityContext.seccompProfile + // - spec.securityContext.fsGroup + // - spec.securityContext.fsGroupChangePolicy + // - spec.securityContext.sysctls + // - spec.shareProcessNamespace + // - spec.securityContext.runAsUser + // - spec.securityContext.runAsGroup + // - spec.securityContext.supplementalGroups + // - spec.containers[*].securityContext.seLinuxOptions + // - spec.containers[*].securityContext.seccompProfile + // - spec.containers[*].securityContext.capabilities + // - spec.containers[*].securityContext.readOnlyRootFilesystem + // - spec.containers[*].securityContext.privileged + // - spec.containers[*].securityContext.allowPrivilegeEscalation + // - spec.containers[*].securityContext.procMount + // - spec.containers[*].securityContext.runAsUser + // - spec.containers[*].securityContext.runAsGroup + // +optional + // This is an alpha field and requires the IdentifyPodOS feature + OS *PodOS `json:"os,omitempty" protobuf:"bytes,36,opt,name=os"` +} + +// OSName is the set of OS'es that can be used in OS. +type OSName string + +// These are valid values for OSName +const ( + Linux OSName = "linux" + Windows OSName = "windows" +) + +// PodOS defines the OS parameters of a pod. +type PodOS struct { + // Name is the name of the operating system. The currently supported values are linux and windows. + // Additional value may be defined in future and can be one of: + // https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration + // Clients should expect to handle additional values and treat unrecognized values in this field as os: null + Name OSName `json:"name" protobuf:"bytes,1,opt,name=name"` } +// +enum type UnsatisfiableConstraintAction string const ( @@ -3236,7 +3373,7 @@ type TopologySpreadConstraint struct { // but giving higher precedence to topologies that would help reduce the // skew. // A constraint is considered "Unsatisfiable" for an incoming pod - // if and only if every possible node assigment for that pod would violate + // if and only if every possible node assignment for that pod would violate // "MaxSkew" on some topology. // For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same // labelSelector spread as 3/1/1: @@ -3274,6 +3411,7 @@ type HostAlias struct { // PodFSGroupChangePolicy holds policies that will be used for applying fsGroup to a volume // when volume is mounted. +// +enum type PodFSGroupChangePolicy string const ( @@ -3297,11 +3435,13 @@ type PodSecurityContext struct { // container. May also be set in SecurityContext. If set in // both SecurityContext and PodSecurityContext, the value specified in SecurityContext // takes precedence for that container. + // Note that this field cannot be set when spec.os.name is windows. // +optional SELinuxOptions *SELinuxOptions `json:"seLinuxOptions,omitempty" protobuf:"bytes,1,opt,name=seLinuxOptions"` // The Windows specific settings applied to all containers. // If unspecified, the options within a container's SecurityContext will be used. // If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is linux. // +optional WindowsOptions *WindowsSecurityContextOptions `json:"windowsOptions,omitempty" protobuf:"bytes,8,opt,name=windowsOptions"` // The UID to run the entrypoint of the container process. @@ -3309,6 +3449,7 @@ type PodSecurityContext struct { // May also be set in SecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence // for that container. + // Note that this field cannot be set when spec.os.name is windows. // +optional RunAsUser *int64 `json:"runAsUser,omitempty" protobuf:"varint,2,opt,name=runAsUser"` // The GID to run the entrypoint of the container process. @@ -3316,6 +3457,7 @@ type PodSecurityContext struct { // May also be set in SecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence // for that container. + // Note that this field cannot be set when spec.os.name is windows. // +optional RunAsGroup *int64 `json:"runAsGroup,omitempty" protobuf:"varint,6,opt,name=runAsGroup"` // Indicates that the container must run as a non-root user. @@ -3329,6 +3471,7 @@ type PodSecurityContext struct { // A list of groups applied to the first process run in each container, in addition // to the container's primary GID. If unspecified, no groups will be added to // any container. + // Note that this field cannot be set when spec.os.name is windows. // +optional SupplementalGroups []int64 `json:"supplementalGroups,omitempty" protobuf:"varint,4,rep,name=supplementalGroups"` // A special supplemental group that applies to all containers in a pod. @@ -3340,10 +3483,12 @@ type PodSecurityContext struct { // 3. The permission bits are OR'd with rw-rw---- // // If unset, the Kubelet will not modify the ownership and permissions of any volume. + // Note that this field cannot be set when spec.os.name is windows. // +optional FSGroup *int64 `json:"fsGroup,omitempty" protobuf:"varint,5,opt,name=fsGroup"` // Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported // sysctls (by the container runtime) might fail to launch. + // Note that this field cannot be set when spec.os.name is windows. // +optional Sysctls []Sysctl `json:"sysctls,omitempty" protobuf:"bytes,7,rep,name=sysctls"` // fsGroupChangePolicy defines behavior of changing ownership and permission of the volume @@ -3352,9 +3497,11 @@ type PodSecurityContext struct { // It will have no effect on ephemeral volume types such as: secret, configmaps // and emptydir. // Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used. + // Note that this field cannot be set when spec.os.name is windows. // +optional FSGroupChangePolicy *PodFSGroupChangePolicy `json:"fsGroupChangePolicy,omitempty" protobuf:"bytes,9,opt,name=fsGroupChangePolicy"` // The seccomp options to use by the containers in this pod. + // Note that this field cannot be set when spec.os.name is windows. // +optional SeccompProfile *SeccompProfile `json:"seccompProfile,omitempty" protobuf:"bytes,10,opt,name=seccompProfile"` } @@ -3380,6 +3527,7 @@ type SeccompProfile struct { } // SeccompProfileType defines the supported seccomp profile types. +// +enum type SeccompProfileType string const ( @@ -3388,12 +3536,12 @@ const ( // SeccompProfileTypeRuntimeDefault represents the default container runtime seccomp profile. SeccompProfileTypeRuntimeDefault SeccompProfileType = "RuntimeDefault" // SeccompProfileTypeLocalhost indicates a profile defined in a file on the node should be used. - // The file's location is based off the kubelet's deprecated flag --seccomp-profile-root. - // Once the flag support is removed the location will be /seccomp. + // The file's location relative to /seccomp. SeccompProfileTypeLocalhost SeccompProfileType = "Localhost" ) // PodQOSClass defines the supported qos classes of Pods. +// +enum type PodQOSClass string const ( @@ -3480,7 +3628,13 @@ type EphemeralContainerCommon struct { // +optional WorkingDir string `json:"workingDir,omitempty" protobuf:"bytes,5,opt,name=workingDir"` // Ports are not allowed for ephemeral containers. - Ports []ContainerPort `json:"ports,omitempty" protobuf:"bytes,6,rep,name=ports"` + // +optional + // +patchMergeKey=containerPort + // +patchStrategy=merge + // +listType=map + // +listMapKey=containerPort + // +listMapKey=protocol + Ports []ContainerPort `json:"ports,omitempty" patchStrategy:"merge" patchMergeKey:"containerPort" protobuf:"bytes,6,rep,name=ports"` // List of sources to populate environment variables in the container. // The keys defined within a source must be a C_IDENTIFIER. All invalid keys // will be reported as an event when the container is starting. When a key exists in multiple @@ -3499,7 +3653,7 @@ type EphemeralContainerCommon struct { // already allocated to the pod. // +optional Resources ResourceRequirements `json:"resources,omitempty" protobuf:"bytes,8,opt,name=resources"` - // Pod volumes to mount into the container's filesystem. + // Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. // Cannot be updated. // +optional // +patchMergeKey=mountPath @@ -3579,15 +3733,16 @@ type EphemeralContainerCommon struct { // these two types. var _ = Container(EphemeralContainerCommon{}) -// An EphemeralContainer is a container that may be added temporarily to an existing pod for +// An EphemeralContainer is a temporary container that you may add to an existing Pod for // user-initiated activities such as debugging. Ephemeral containers have no resource or -// scheduling guarantees, and they will not be restarted when they exit or when a pod is -// removed or restarted. If an ephemeral container causes a pod to exceed its resource -// allocation, the pod may be evicted. -// Ephemeral containers may not be added by directly updating the pod spec. They must be added -// via the pod's ephemeralcontainers subresource, and they will appear in the pod spec -// once added. -// This is an alpha feature enabled by the EphemeralContainers feature flag. +// scheduling guarantees, and they will not be restarted when they exit or when a Pod is +// removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the +// Pod to exceed its resource allocation. +// +// To add an ephemeral container, use the ephemeralcontainers subresource of an existing +// Pod. Ephemeral containers may not be removed or restarted. +// +// This is a beta feature available on clusters that haven't disabled the EphemeralContainers feature gate. type EphemeralContainer struct { // Ephemeral containers have all of the fields of Container, plus additional fields // specific to ephemeral containers. Fields in common with Container are in the @@ -3597,8 +3752,10 @@ type EphemeralContainer struct { // If set, the name of the container from PodSpec that this ephemeral container targets. // The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. - // If not set then the ephemeral container is run in whatever namespaces are shared - // for the pod. Note that the container runtime must support this feature. + // If not set then the ephemeral container uses the namespaces configured in the Pod spec. + // + // The container runtime must implement support for this feature. If the runtime does not + // support namespace targeting then the result of setting this field is undefined. // +optional TargetContainerName string `json:"targetContainerName,omitempty" protobuf:"bytes,2,opt,name=targetContainerName"` } @@ -3688,7 +3845,7 @@ type PodStatus struct { // +optional QOSClass PodQOSClass `json:"qosClass,omitempty" protobuf:"bytes,9,rep,name=qosClass"` // Status for any ephemeral containers that have run in this pod. - // This field is alpha-level and is only populated by servers that enable the EphemeralContainers feature. + // This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate. // +optional EphemeralContainerStatuses []ContainerStatus `json:"ephemeralContainerStatuses,omitempty" protobuf:"bytes,13,rep,name=ephemeralContainerStatuses"` } @@ -3936,6 +4093,7 @@ type ReplicationControllerList struct { } // Session Affinity Type string +// +enum type ServiceAffinity string const ( @@ -3965,6 +4123,7 @@ type ClientIPConfig struct { } // Service Type string describes ingress methods for a service +// +enum type ServiceType string const ( @@ -3989,6 +4148,7 @@ const ( // ServiceInternalTrafficPolicyType describes the type of traffic routing for // internal traffic +// +enum type ServiceInternalTrafficPolicyType string const ( @@ -4001,6 +4161,7 @@ const ( ) // Service External Traffic Policy Type string +// +enum type ServiceExternalTrafficPolicyType string const ( @@ -4062,6 +4223,7 @@ type LoadBalancerIngress struct { // IPFamily represents the IP Family (IPv4 or IPv6). This type is used // to express the family of an IP expressed by a type (e.g. service.spec.ipFamilies). +// +enum type IPFamily string const ( @@ -4072,6 +4234,7 @@ const ( ) // IPFamilyPolicyType represents the dual-stack-ness requested or required by a Service +// +enum type IPFamilyPolicyType string const ( @@ -4152,12 +4315,9 @@ type ServiceSpec struct { // clients must ensure that clusterIPs[0] and clusterIP have the same // value. // - // Unless the "IPv6DualStack" feature gate is enabled, this field is - // limited to one value, which must be the same as the clusterIP field. If - // the feature gate is enabled, this field may hold a maximum of two - // entries (dual-stack IPs, in either order). These IPs must correspond to - // the values of the ipFamilies field. Both clusterIPs and ipFamilies are - // governed by the ipFamilyPolicy field. + // This field may hold a maximum of two entries (dual-stack IPs, in either order). + // These IPs must correspond to the values of the ipFamilies field. Both + // clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. // More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies // +listType=atomic // +optional @@ -4263,17 +4423,16 @@ type ServiceSpec struct { // IPFamily *IPFamily `json:"ipFamily,omitempty" protobuf:"bytes,15,opt,name=ipFamily,Configcasttype=IPFamily"` // IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this - // service, and is gated by the "IPv6DualStack" feature gate. This field - // is usually assigned automatically based on cluster configuration and the - // ipFamilyPolicy field. If this field is specified manually, the requested - // family is available in the cluster, and ipFamilyPolicy allows it, it - // will be used; otherwise creation of the service will fail. This field - // is conditionally mutable: it allows for adding or removing a secondary - // IP family, but it does not allow changing the primary IP family of the - // Service. Valid values are "IPv4" and "IPv6". This field only applies - // to Services of types ClusterIP, NodePort, and LoadBalancer, and does - // apply to "headless" services. This field will be wiped when updating a - // Service to type ExternalName. + // service. This field is usually assigned automatically based on cluster + // configuration and the ipFamilyPolicy field. If this field is specified + // manually, the requested family is available in the cluster, + // and ipFamilyPolicy allows it, it will be used; otherwise creation of + // the service will fail. This field is conditionally mutable: it allows + // for adding or removing a secondary IP family, but it does not allow + // changing the primary IP family of the Service. Valid values are "IPv4" + // and "IPv6". This field only applies to Services of types ClusterIP, + // NodePort, and LoadBalancer, and does apply to "headless" services. + // This field will be wiped when updating a Service to type ExternalName. // // This field may hold a maximum of two entries (dual-stack families, in // either order). These families must correspond to the values of the @@ -4284,14 +4443,13 @@ type ServiceSpec struct { IPFamilies []IPFamily `json:"ipFamilies,omitempty" protobuf:"bytes,19,opt,name=ipFamilies,casttype=IPFamily"` // IPFamilyPolicy represents the dual-stack-ness requested or required by - // this Service, and is gated by the "IPv6DualStack" feature gate. If - // there is no value provided, then this field will be set to SingleStack. - // Services can be "SingleStack" (a single IP family), "PreferDualStack" - // (two IP families on dual-stack configured clusters or a single IP family - // on single-stack clusters), or "RequireDualStack" (two IP families on - // dual-stack configured clusters, otherwise fail). The ipFamilies and - // clusterIPs fields depend on the value of this field. This field will be - // wiped when updating a service to type ExternalName. + // this Service. If there is no value provided, then this field will be set + // to SingleStack. Services can be "SingleStack" (a single IP family), + // "PreferDualStack" (two IP families on dual-stack configured clusters or + // a single IP family on single-stack clusters), or "RequireDualStack" + // (two IP families on dual-stack configured clusters, otherwise fail). The + // ipFamilies and clusterIPs fields depend on the value of this field. This + // field will be wiped when updating a service to type ExternalName. // +optional IPFamilyPolicy *IPFamilyPolicyType `json:"ipFamilyPolicy,omitempty" protobuf:"bytes,17,opt,name=ipFamilyPolicy,casttype=IPFamilyPolicyType"` @@ -4884,6 +5042,7 @@ type ContainerImage struct { SizeBytes int64 `json:"sizeBytes,omitempty" protobuf:"varint,2,opt,name=sizeBytes"` } +// +enum type NodePhase string // These are the valid phases of node. @@ -4896,6 +5055,7 @@ const ( NodeTerminated NodePhase = "Terminated" ) +// +enum type NodeConditionType string // These are valid conditions of node. Currently, we don't have enough information to decide @@ -4934,6 +5094,7 @@ type NodeCondition struct { Message string `json:"message,omitempty" protobuf:"bytes,6,opt,name=message"` } +// +enum type NodeAddressType string // These are valid address type of node. @@ -5089,6 +5250,7 @@ type NamespaceStatus struct { Conditions []NamespaceCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,2,rep,name=conditions"` } +// +enum type NamespacePhase string // These are the valid phases of a namespace. @@ -5105,6 +5267,7 @@ const ( NamespaceTerminatingCause metav1.CauseType = "NamespaceTerminating" ) +// +enum type NamespaceConditionType string // These are valid conditions of a namespace. @@ -5304,12 +5467,10 @@ type PodExecOptions struct { Stdin bool `json:"stdin,omitempty" protobuf:"varint,1,opt,name=stdin"` // Redirect the standard output stream of the pod for this call. - // Defaults to true. // +optional Stdout bool `json:"stdout,omitempty" protobuf:"varint,2,opt,name=stdout"` // Redirect the standard error stream of the pod for this call. - // Defaults to true. // +optional Stderr bool `json:"stderr,omitempty" protobuf:"varint,3,opt,name=stderr"` @@ -5598,6 +5759,7 @@ type EventList struct { type List metav1.List // LimitType is a type of object that is limited +// +enum type LimitType string const ( @@ -5714,6 +5876,7 @@ const ( ) // A ResourceQuotaScope defines a filter that must match each object tracked by a quota +// +enum type ResourceQuotaScope string const ( @@ -5776,6 +5939,7 @@ type ScopedResourceSelectorRequirement struct { // A scope selector operator is the set of operators that can be used in // a scope selector requirement. +// +enum type ScopeSelectorOperator string const ( @@ -5868,6 +6032,7 @@ type Secret struct { StringData map[string]string `json:"stringData,omitempty" protobuf:"bytes,4,rep,name=stringData"` // Used to facilitate programmatic handling of secret data. + // More info: https://kubernetes.io/docs/concepts/configuration/secret/#secret-types // +optional Type SecretType `json:"type,omitempty" protobuf:"bytes,3,opt,name=type,casttype=SecretType"` } @@ -6144,34 +6309,40 @@ type DownwardAPIProjection struct { type SecurityContext struct { // The capabilities to add/drop when running containers. // Defaults to the default set of capabilities granted by the container runtime. + // Note that this field cannot be set when spec.os.name is windows. // +optional Capabilities *Capabilities `json:"capabilities,omitempty" protobuf:"bytes,1,opt,name=capabilities"` // Run container in privileged mode. // Processes in privileged containers are essentially equivalent to root on the host. // Defaults to false. + // Note that this field cannot be set when spec.os.name is windows. // +optional Privileged *bool `json:"privileged,omitempty" protobuf:"varint,2,opt,name=privileged"` // The SELinux context to be applied to the container. // If unspecified, the container runtime will allocate a random SELinux context for each // container. May also be set in PodSecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is windows. // +optional SELinuxOptions *SELinuxOptions `json:"seLinuxOptions,omitempty" protobuf:"bytes,3,opt,name=seLinuxOptions"` // The Windows specific settings applied to all containers. // If unspecified, the options from the PodSecurityContext will be used. // If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is linux. // +optional WindowsOptions *WindowsSecurityContextOptions `json:"windowsOptions,omitempty" protobuf:"bytes,10,opt,name=windowsOptions"` // The UID to run the entrypoint of the container process. // Defaults to user specified in image metadata if unspecified. // May also be set in PodSecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is windows. // +optional RunAsUser *int64 `json:"runAsUser,omitempty" protobuf:"varint,4,opt,name=runAsUser"` // The GID to run the entrypoint of the container process. // Uses runtime default if unset. // May also be set in PodSecurityContext. If set in both SecurityContext and // PodSecurityContext, the value specified in SecurityContext takes precedence. + // Note that this field cannot be set when spec.os.name is windows. // +optional RunAsGroup *int64 `json:"runAsGroup,omitempty" protobuf:"varint,8,opt,name=runAsGroup"` // Indicates that the container must run as a non-root user. @@ -6184,6 +6355,7 @@ type SecurityContext struct { RunAsNonRoot *bool `json:"runAsNonRoot,omitempty" protobuf:"varint,5,opt,name=runAsNonRoot"` // Whether this container has a read-only root filesystem. // Default is false. + // Note that this field cannot be set when spec.os.name is windows. // +optional ReadOnlyRootFilesystem *bool `json:"readOnlyRootFilesystem,omitempty" protobuf:"varint,6,opt,name=readOnlyRootFilesystem"` // AllowPrivilegeEscalation controls whether a process can gain more @@ -6192,21 +6364,25 @@ type SecurityContext struct { // AllowPrivilegeEscalation is true always when the container is: // 1) run as Privileged // 2) has CAP_SYS_ADMIN + // Note that this field cannot be set when spec.os.name is windows. // +optional AllowPrivilegeEscalation *bool `json:"allowPrivilegeEscalation,omitempty" protobuf:"varint,7,opt,name=allowPrivilegeEscalation"` // procMount denotes the type of proc mount to use for the containers. // The default is DefaultProcMount which uses the container runtime defaults for // readonly paths and masked paths. // This requires the ProcMountType feature flag to be enabled. + // Note that this field cannot be set when spec.os.name is windows. // +optional ProcMount *ProcMountType `json:"procMount,omitempty" protobuf:"bytes,9,opt,name=procMount"` // The seccomp options to use by this container. If seccomp options are // provided at both the pod & container level, the container options // override the pod options. + // Note that this field cannot be set when spec.os.name is windows. // +optional SeccompProfile *SeccompProfile `json:"seccompProfile,omitempty" protobuf:"bytes,11,opt,name=seccompProfile"` } +// +enum type ProcMountType string const ( diff --git a/vendor/k8s.io/api/core/v1/types_swagger_doc_generated.go b/vendor/k8s.io/api/core/v1/types_swagger_doc_generated.go index 8d6327375b..0a60e7008a 100644 --- a/vendor/k8s.io/api/core/v1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/core/v1/types_swagger_doc_generated.go @@ -428,8 +428,8 @@ var map_ContainerStatus = map[string]string{ "state": "Details about the container's current condition.", "lastState": "Details about the container's last termination condition.", "ready": "Specifies whether the container has passed its readiness probe.", - "restartCount": "The number of times the container has been restarted, currently based on the number of dead containers that have not yet been removed. Note that this is calculated from dead containers. But those containers are subject to garbage collection. This value will get capped at 5 by GC.", - "image": "The image the container is running. More info: https://kubernetes.io/docs/concepts/containers/images", + "restartCount": "The number of times the container has been restarted.", + "image": "The image the container is running. More info: https://kubernetes.io/docs/concepts/containers/images.", "imageID": "ImageID of the container's image.", "containerID": "Container's ID in the format 'docker://'.", "started": "Specifies whether the container has passed its startup probe. Initialized as false, becomes true after startupProbe is considered successful. Resets to false when the container is restarted, or if kubelet loses state temporarily. Is always true when no startupProbe is defined.", @@ -579,8 +579,8 @@ func (EnvVarSource) SwaggerDoc() map[string]string { } var map_EphemeralContainer = map[string]string{ - "": "An EphemeralContainer is a container that may be added temporarily to an existing pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a pod is removed or restarted. If an ephemeral container causes a pod to exceed its resource allocation, the pod may be evicted. Ephemeral containers may not be added by directly updating the pod spec. They must be added via the pod's ephemeralcontainers subresource, and they will appear in the pod spec once added. This is an alpha feature enabled by the EphemeralContainers feature flag.", - "targetContainerName": "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container is run in whatever namespaces are shared for the pod. Note that the container runtime must support this feature.", + "": "An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation.\n\nTo add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted.\n\nThis is a beta feature available on clusters that haven't disabled the EphemeralContainers feature gate.", + "targetContainerName": "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec.\n\nThe container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined.", } func (EphemeralContainer) SwaggerDoc() map[string]string { @@ -598,7 +598,7 @@ var map_EphemeralContainerCommon = map[string]string{ "envFrom": "List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.", "env": "List of environment variables to set in the container. Cannot be updated.", "resources": "Resources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod.", - "volumeMounts": "Pod volumes to mount into the container's filesystem. Cannot be updated.", + "volumeMounts": "Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.", "volumeDevices": "volumeDevices is the list of block devices to be used by the container.", "livenessProbe": "Probes are not allowed for ephemeral containers.", "readinessProbe": "Probes are not allowed for ephemeral containers.", @@ -749,6 +749,15 @@ func (GCEPersistentDiskVolumeSource) SwaggerDoc() map[string]string { return map_GCEPersistentDiskVolumeSource } +var map_GRPCAction = map[string]string{ + "port": "Port number of the gRPC service. Number must be in the range 1 to 65535.", + "service": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.", +} + +func (GRPCAction) SwaggerDoc() map[string]string { + return map_GRPCAction +} + var map_GitRepoVolumeSource = map[string]string{ "": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.", "repository": "Repository URL", @@ -806,17 +815,6 @@ func (HTTPHeader) SwaggerDoc() map[string]string { return map_HTTPHeader } -var map_Handler = map[string]string{ - "": "Handler defines a specific action that should be taken", - "exec": "One and only one of the following should be specified. Exec specifies the action to take.", - "httpGet": "HTTPGet specifies the http request to perform.", - "tcpSocket": "TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported", -} - -func (Handler) SwaggerDoc() map[string]string { - return map_Handler -} - var map_HostAlias = map[string]string{ "": "HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.", "ip": "IP address of the host file entry.", @@ -889,13 +887,24 @@ func (KeyToPath) SwaggerDoc() map[string]string { var map_Lifecycle = map[string]string{ "": "Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.", "postStart": "PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks", - "preStop": "PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The reason for termination is passed to the handler. The Pod's termination grace period countdown begins before the PreStop hooked is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period. Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks", + "preStop": "PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks", } func (Lifecycle) SwaggerDoc() map[string]string { return map_Lifecycle } +var map_LifecycleHandler = map[string]string{ + "": "LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.", + "exec": "Exec specifies the action to take.", + "httpGet": "HTTPGet specifies the http request to perform.", + "tcpSocket": "Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.", +} + +func (LifecycleHandler) SwaggerDoc() map[string]string { + return map_LifecycleHandler +} + var map_LimitRange = map[string]string{ "": "LimitRange sets resource usage limits for each kind of resource in a Namespace.", "metadata": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", @@ -971,7 +980,7 @@ func (LocalObjectReference) SwaggerDoc() map[string]string { var map_LocalVolumeSource = map[string]string{ "": "Local represents directly-attached storage with node affinity (Beta feature)", "path": "The full path to the volume on the node. It can be either a directory or block device (disk, partition, ...).", - "fsType": "Filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default value is to auto-select a fileystem if unspecified.", + "fsType": "Filesystem type to mount. It applies only when the Path is a block device. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default value is to auto-select a filesystem if unspecified.", } func (LocalVolumeSource) SwaggerDoc() map[string]string { @@ -1297,7 +1306,7 @@ var map_PersistentVolumeClaimSpec = map[string]string{ "": "PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes", "accessModes": "AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", "selector": "A label query over volumes to consider for binding.", - "resources": "Resources represents the minimum resources the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources", + "resources": "Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources", "volumeName": "VolumeName is the binding reference to the PersistentVolume backing this claim.", "storageClassName": "Name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1", "volumeMode": "volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.", @@ -1310,11 +1319,13 @@ func (PersistentVolumeClaimSpec) SwaggerDoc() map[string]string { } var map_PersistentVolumeClaimStatus = map[string]string{ - "": "PersistentVolumeClaimStatus is the current status of a persistent volume claim.", - "phase": "Phase represents the current phase of PersistentVolumeClaim.", - "accessModes": "AccessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", - "capacity": "Represents the actual resources of the underlying volume.", - "conditions": "Current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.", + "": "PersistentVolumeClaimStatus is the current status of a persistent volume claim.", + "phase": "Phase represents the current phase of PersistentVolumeClaim.", + "accessModes": "AccessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "capacity": "Represents the actual resources of the underlying volume.", + "conditions": "Current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.", + "allocatedResources": "The storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.", + "resizeStatus": "ResizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.", } func (PersistentVolumeClaimStatus) SwaggerDoc() map[string]string { @@ -1511,8 +1522,8 @@ func (PodDNSConfigOption) SwaggerDoc() map[string]string { var map_PodExecOptions = map[string]string{ "": "PodExecOptions is the query options to a Pod's remote exec call.", "stdin": "Redirect the standard input stream of the pod for this call. Defaults to false.", - "stdout": "Redirect the standard output stream of the pod for this call. Defaults to true.", - "stderr": "Redirect the standard error stream of the pod for this call. Defaults to true.", + "stdout": "Redirect the standard output stream of the pod for this call.", + "stderr": "Redirect the standard error stream of the pod for this call.", "tty": "TTY if true indicates that a tty will be allocated for the exec call. Defaults to false.", "container": "Container in which to execute the command. Defaults to only container if there is only one container in the pod.", "command": "Command is the remote command to execute. argv array. Not executed within a shell.", @@ -1558,6 +1569,15 @@ func (PodLogOptions) SwaggerDoc() map[string]string { return map_PodLogOptions } +var map_PodOS = map[string]string{ + "": "PodOS defines the OS parameters of a pod.", + "name": "Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null", +} + +func (PodOS) SwaggerDoc() map[string]string { + return map_PodOS +} + var map_PodPortForwardOptions = map[string]string{ "": "PodPortForwardOptions is the query options to a Pod's port forward call when using WebSockets. The `port` query parameter must specify the port or ports (comma separated) to forward over. Port forwarding over SPDY does not use these options. It requires the port to be passed in the `port` header as part of request.", "ports": "List of ports to forward Required when using WebSockets", @@ -1587,16 +1607,16 @@ func (PodReadinessGate) SwaggerDoc() map[string]string { var map_PodSecurityContext = map[string]string{ "": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", - "seLinuxOptions": "The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container.", - "windowsOptions": "The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", - "runAsUser": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container.", - "runAsGroup": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container.", + "seLinuxOptions": "The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "windowsOptions": "The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.", + "runAsUser": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", + "runAsGroup": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", "runAsNonRoot": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", - "supplementalGroups": "A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container.", + "supplementalGroups": "A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.", "fsGroup": "A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ", - "sysctls": "Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch.", - "fsGroupChangePolicy": "fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used.", - "seccompProfile": "The seccomp options to use by the containers in this pod.", + "sysctls": "Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.", + "fsGroupChangePolicy": "fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.", + "seccompProfile": "The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.", } func (PodSecurityContext) SwaggerDoc() map[string]string { @@ -1617,7 +1637,7 @@ var map_PodSpec = map[string]string{ "volumes": "List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes", "initContainers": "List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/", "containers": "List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated.", - "ephemeralContainers": "List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is alpha-level and is only honored by servers that enable the EphemeralContainers feature.", + "ephemeralContainers": "List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate.", "restartPolicy": "Restart policy for all containers within the pod. One of Always, OnFailure, Never. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy", "terminationGracePeriodSeconds": "Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.", "activeDeadlineSeconds": "Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.", @@ -1649,6 +1669,7 @@ var map_PodSpec = map[string]string{ "overhead": "Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md This field is beta-level as of Kubernetes v1.18, and is only honored by servers that enable the PodOverhead feature.", "topologySpreadConstraints": "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.", "setHostnameAsFQDN": "If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.", + "os": "Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set.\n\nIf the OS field is set to linux, the following fields must be unset: -securityContext.windowsOptions\n\nIf the OS field is set to windows, following fields must be unset: - spec.hostPID - spec.hostIPC - spec.securityContext.seLinuxOptions - spec.securityContext.seccompProfile - spec.securityContext.fsGroup - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls - spec.shareProcessNamespace - spec.securityContext.runAsUser - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups - spec.containers[*].securityContext.seLinuxOptions - spec.containers[*].securityContext.seccompProfile - spec.containers[*].securityContext.capabilities - spec.containers[*].securityContext.readOnlyRootFilesystem - spec.containers[*].securityContext.privileged - spec.containers[*].securityContext.allowPrivilegeEscalation - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser - spec.containers[*].securityContext.runAsGroup This is an alpha field and requires the IdentifyPodOS feature", } func (PodSpec) SwaggerDoc() map[string]string { @@ -1669,7 +1690,7 @@ var map_PodStatus = map[string]string{ "initContainerStatuses": "The list has one entry per init container in the manifest. The most recent successful init container will have ready = true, the most recently started container will have startTime set. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status", "containerStatuses": "The list has one entry per container in the manifest. Each entry is currently the output of `docker inspect`. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status", "qosClass": "The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://git.k8s.io/community/contributors/design-proposals/node/resource-qos.md", - "ephemeralContainerStatuses": "Status for any ephemeral containers that have run in this pod. This field is alpha-level and is only populated by servers that enable the EphemeralContainers feature.", + "ephemeralContainerStatuses": "Status for any ephemeral containers that have run in this pod. This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate.", } func (PodStatus) SwaggerDoc() map[string]string { @@ -1782,6 +1803,18 @@ func (Probe) SwaggerDoc() map[string]string { return map_Probe } +var map_ProbeHandler = map[string]string{ + "": "ProbeHandler defines a specific action that should be taken in a probe. One and only one of the fields must be specified.", + "exec": "Exec specifies the action to take.", + "httpGet": "HTTPGet specifies the http request to perform.", + "tcpSocket": "TCPSocket specifies an action involving a TCP port.", + "grpc": "GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.", +} + +func (ProbeHandler) SwaggerDoc() map[string]string { + return map_ProbeHandler +} + var map_ProjectedVolumeSource = map[string]string{ "": "Represents a projected volume source", "sources": "list of volume projections", @@ -2056,7 +2089,7 @@ var map_Secret = map[string]string{ "immutable": "Immutable, if set to true, ensures that data stored in the Secret cannot be updated (only object metadata can be modified). If not set to true, the field can be modified at any time. Defaulted to nil.", "data": "Data contains the secret data. Each key must consist of alphanumeric characters, '-', '_' or '.'. The serialized form of the secret data is a base64 encoded string, representing the arbitrary (possibly non-string) data value here. Described in https://tools.ietf.org/html/rfc4648#section-4", "stringData": "stringData allows specifying non-binary secret data in string form. It is provided as a write-only input field for convenience. All keys and values are merged into the data field on write, overwriting any existing values. The stringData field is never output when reading from the API.", - "type": "Used to facilitate programmatic handling of secret data.", + "type": "Used to facilitate programmatic handling of secret data. More info: https://kubernetes.io/docs/concepts/configuration/secret/#secret-types", } func (Secret) SwaggerDoc() map[string]string { @@ -2126,17 +2159,17 @@ func (SecretVolumeSource) SwaggerDoc() map[string]string { var map_SecurityContext = map[string]string{ "": "SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.", - "capabilities": "The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime.", - "privileged": "Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false.", - "seLinuxOptions": "The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", - "windowsOptions": "The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", - "runAsUser": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", - "runAsGroup": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", + "capabilities": "The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.", + "privileged": "Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.", + "seLinuxOptions": "The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "windowsOptions": "The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.", + "runAsUser": "The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", + "runAsGroup": "The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.", "runAsNonRoot": "Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.", - "readOnlyRootFilesystem": "Whether this container has a read-only root filesystem. Default is false.", - "allowPrivilegeEscalation": "AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN", - "procMount": "procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled.", - "seccompProfile": "The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options.", + "readOnlyRootFilesystem": "Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.", + "allowPrivilegeEscalation": "AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.", + "procMount": "procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.", + "seccompProfile": "The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.", } func (SecurityContext) SwaggerDoc() map[string]string { @@ -2234,7 +2267,7 @@ var map_ServiceSpec = map[string]string{ "ports": "The list of ports that are exposed by this service. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", "selector": "Route service traffic to pods with label keys and values matching this selector. If empty or not present, the service is assumed to have an external process managing its endpoints, which Kubernetes will not modify. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/", "clusterIP": "clusterIP is the IP address of the service and is usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be blank) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \"None\", empty string (\"\"), or a valid IP address. Setting this to \"None\" makes a \"headless service\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", - "clusterIPs": "ClusterIPs is a list of IP addresses assigned to this service, and are usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be empty) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \"None\", empty string (\"\"), or a valid IP address. Setting this to \"None\" makes a \"headless service\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. If this field is not specified, it will be initialized from the clusterIP field. If this field is specified, clients must ensure that clusterIPs[0] and clusterIP have the same value.\n\nUnless the \"IPv6DualStack\" feature gate is enabled, this field is limited to one value, which must be the same as the clusterIP field. If the feature gate is enabled, this field may hold a maximum of two entries (dual-stack IPs, in either order). These IPs must correspond to the values of the ipFamilies field. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", + "clusterIPs": "ClusterIPs is a list of IP addresses assigned to this service, and are usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be empty) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \"None\", empty string (\"\"), or a valid IP address. Setting this to \"None\" makes a \"headless service\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. If this field is not specified, it will be initialized from the clusterIP field. If this field is specified, clients must ensure that clusterIPs[0] and clusterIP have the same value.\n\nThis field may hold a maximum of two entries (dual-stack IPs, in either order). These IPs must correspond to the values of the ipFamilies field. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", "type": "type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. \"ClusterIP\" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object or EndpointSlice objects. If clusterIP is \"None\", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a virtual IP. \"NodePort\" builds on ClusterIP and allocates a port on every node which routes to the same endpoints as the clusterIP. \"LoadBalancer\" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the same endpoints as the clusterIP. \"ExternalName\" aliases this service to the specified externalName. Several other fields do not apply to ExternalName services. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types", "externalIPs": "externalIPs is a list of IP addresses for which nodes in the cluster will also accept traffic for this service. These IPs are not managed by Kubernetes. The user is responsible for ensuring that traffic arrives at a node with this IP. A common example is external load-balancers that are not part of the Kubernetes system.", "sessionAffinity": "Supports \"ClientIP\" and \"None\". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies", @@ -2245,8 +2278,8 @@ var map_ServiceSpec = map[string]string{ "healthCheckNodePort": "healthCheckNodePort specifies the healthcheck nodePort for the service. This only applies when type is set to LoadBalancer and externalTrafficPolicy is set to Local. If a value is specified, is in-range, and is not in use, it will be used. If not specified, a value will be automatically allocated. External systems (e.g. load-balancers) can use this port to determine if a given node holds endpoints for this service or not. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type).", "publishNotReadyAddresses": "publishNotReadyAddresses indicates that any agent which deals with endpoints for this Service should disregard any indications of ready/not-ready. The primary use case for setting this field is for a StatefulSet's Headless Service to propagate SRV DNS records for its Pods for the purpose of peer discovery. The Kubernetes controllers that generate Endpoints and EndpointSlice resources for Services interpret this to mean that all endpoints are considered \"ready\" even if the Pods themselves are not. Agents which consume only Kubernetes generated endpoints through the Endpoints or EndpointSlice resources can safely assume this behavior.", "sessionAffinityConfig": "sessionAffinityConfig contains the configurations of session affinity.", - "ipFamilies": "IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this service, and is gated by the \"IPv6DualStack\" feature gate. This field is usually assigned automatically based on cluster configuration and the ipFamilyPolicy field. If this field is specified manually, the requested family is available in the cluster, and ipFamilyPolicy allows it, it will be used; otherwise creation of the service will fail. This field is conditionally mutable: it allows for adding or removing a secondary IP family, but it does not allow changing the primary IP family of the Service. Valid values are \"IPv4\" and \"IPv6\". This field only applies to Services of types ClusterIP, NodePort, and LoadBalancer, and does apply to \"headless\" services. This field will be wiped when updating a Service to type ExternalName.\n\nThis field may hold a maximum of two entries (dual-stack families, in either order). These families must correspond to the values of the clusterIPs field, if specified. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field.", - "ipFamilyPolicy": "IPFamilyPolicy represents the dual-stack-ness requested or required by this Service, and is gated by the \"IPv6DualStack\" feature gate. If there is no value provided, then this field will be set to SingleStack. Services can be \"SingleStack\" (a single IP family), \"PreferDualStack\" (two IP families on dual-stack configured clusters or a single IP family on single-stack clusters), or \"RequireDualStack\" (two IP families on dual-stack configured clusters, otherwise fail). The ipFamilies and clusterIPs fields depend on the value of this field. This field will be wiped when updating a service to type ExternalName.", + "ipFamilies": "IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this service. This field is usually assigned automatically based on cluster configuration and the ipFamilyPolicy field. If this field is specified manually, the requested family is available in the cluster, and ipFamilyPolicy allows it, it will be used; otherwise creation of the service will fail. This field is conditionally mutable: it allows for adding or removing a secondary IP family, but it does not allow changing the primary IP family of the Service. Valid values are \"IPv4\" and \"IPv6\". This field only applies to Services of types ClusterIP, NodePort, and LoadBalancer, and does apply to \"headless\" services. This field will be wiped when updating a Service to type ExternalName.\n\nThis field may hold a maximum of two entries (dual-stack families, in either order). These families must correspond to the values of the clusterIPs field, if specified. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field.", + "ipFamilyPolicy": "IPFamilyPolicy represents the dual-stack-ness requested or required by this Service. If there is no value provided, then this field will be set to SingleStack. Services can be \"SingleStack\" (a single IP family), \"PreferDualStack\" (two IP families on dual-stack configured clusters or a single IP family on single-stack clusters), or \"RequireDualStack\" (two IP families on dual-stack configured clusters, otherwise fail). The ipFamilies and clusterIPs fields depend on the value of this field. This field will be wiped when updating a service to type ExternalName.", "allocateLoadBalancerNodePorts": "allocateLoadBalancerNodePorts defines if NodePorts will be automatically allocated for services with type LoadBalancer. Default is \"true\". It may be set to \"false\" if the cluster load-balancer does not rely on NodePorts. If the caller requests specific NodePorts (by specifying a value), those requests will be respected, regardless of this field. This field may only be set for services with type LoadBalancer and will be cleared if the type is changed to any other type. This field is beta-level and is only honored by servers that enable the ServiceLBNodePortControl feature.", "loadBalancerClass": "loadBalancerClass is the class of the load balancer implementation this Service belongs to. If specified, the value of this field must be a label-style identifier, with an optional prefix, e.g. \"internal-vip\" or \"example.com/internal-vip\". Unprefixed names are reserved for end-users. This field can only be set when the Service type is 'LoadBalancer'. If not set, the default load balancer implementation is used, today this is typically done through the cloud provider integration, but should apply for any default implementation. If set, it is assumed that a load balancer implementation is watching for Services with a matching class. Any default load balancer implementation (e.g. cloud providers) should ignore Services that set this field. This field can only be set when creating or updating a Service to type 'LoadBalancer'. Once set, it can not be changed. This field will be wiped when a service is updated to a non 'LoadBalancer' type.", "internalTrafficPolicy": "InternalTrafficPolicy specifies if the cluster internal traffic should be routed to all endpoints or node-local endpoints only. \"Cluster\" routes internal traffic to a Service to all endpoints. \"Local\" routes traffic to node-local endpoints only, traffic is dropped if no node-local endpoints are ready. The default value is \"Cluster\".", @@ -2369,7 +2402,7 @@ var map_TopologySpreadConstraint = map[string]string{ "": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.", "maxSkew": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: ", "topologyKey": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. It's a required field.", - "whenUnsatisfiable": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\n but giving higher precedence to topologies that would help reduce the\n skew.\nA constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assigment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: ", + "whenUnsatisfiable": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\n but giving higher precedence to topologies that would help reduce the\n skew.\nA constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: ", "labelSelector": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.", } @@ -2472,7 +2505,7 @@ var map_VolumeSource = map[string]string{ "scaleIO": "ScaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.", "storageos": "StorageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.", "csi": "CSI (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).", - "ephemeral": "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.\n\nThis is a beta feature and only available when the GenericEphemeralVolume feature gate is enabled.", + "ephemeral": "Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.", } func (VolumeSource) SwaggerDoc() map[string]string { diff --git a/vendor/k8s.io/api/core/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/core/v1/zz_generated.deepcopy.go index ff660ae275..fc951ad44d 100644 --- a/vendor/k8s.io/api/core/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/core/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -1668,6 +1669,27 @@ func (in *GCEPersistentDiskVolumeSource) DeepCopy() *GCEPersistentDiskVolumeSour return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *GRPCAction) DeepCopyInto(out *GRPCAction) { + *out = *in + if in.Service != nil { + in, out := &in.Service, &out.Service + *out = new(string) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GRPCAction. +func (in *GRPCAction) DeepCopy() *GRPCAction { + if in == nil { + return nil + } + out := new(GRPCAction) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *GitRepoVolumeSource) DeepCopyInto(out *GitRepoVolumeSource) { *out = *in @@ -1759,37 +1781,6 @@ func (in *HTTPHeader) DeepCopy() *HTTPHeader { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *Handler) DeepCopyInto(out *Handler) { - *out = *in - if in.Exec != nil { - in, out := &in.Exec, &out.Exec - *out = new(ExecAction) - (*in).DeepCopyInto(*out) - } - if in.HTTPGet != nil { - in, out := &in.HTTPGet, &out.HTTPGet - *out = new(HTTPGetAction) - (*in).DeepCopyInto(*out) - } - if in.TCPSocket != nil { - in, out := &in.TCPSocket, &out.TCPSocket - *out = new(TCPSocketAction) - **out = **in - } - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Handler. -func (in *Handler) DeepCopy() *Handler { - if in == nil { - return nil - } - out := new(Handler) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *HostAlias) DeepCopyInto(out *HostAlias) { *out = *in @@ -1920,12 +1911,12 @@ func (in *Lifecycle) DeepCopyInto(out *Lifecycle) { *out = *in if in.PostStart != nil { in, out := &in.PostStart, &out.PostStart - *out = new(Handler) + *out = new(LifecycleHandler) (*in).DeepCopyInto(*out) } if in.PreStop != nil { in, out := &in.PreStop, &out.PreStop - *out = new(Handler) + *out = new(LifecycleHandler) (*in).DeepCopyInto(*out) } return @@ -1941,6 +1932,37 @@ func (in *Lifecycle) DeepCopy() *Lifecycle { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *LifecycleHandler) DeepCopyInto(out *LifecycleHandler) { + *out = *in + if in.Exec != nil { + in, out := &in.Exec, &out.Exec + *out = new(ExecAction) + (*in).DeepCopyInto(*out) + } + if in.HTTPGet != nil { + in, out := &in.HTTPGet, &out.HTTPGet + *out = new(HTTPGetAction) + (*in).DeepCopyInto(*out) + } + if in.TCPSocket != nil { + in, out := &in.TCPSocket, &out.TCPSocket + *out = new(TCPSocketAction) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LifecycleHandler. +func (in *LifecycleHandler) DeepCopy() *LifecycleHandler { + if in == nil { + return nil + } + out := new(LifecycleHandler) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *LimitRange) DeepCopyInto(out *LimitRange) { *out = *in @@ -2974,6 +2996,18 @@ func (in *PersistentVolumeClaimStatus) DeepCopyInto(out *PersistentVolumeClaimSt (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.AllocatedResources != nil { + in, out := &in.AllocatedResources, &out.AllocatedResources + *out = make(ResourceList, len(*in)) + for key, val := range *in { + (*out)[key] = val.DeepCopy() + } + } + if in.ResizeStatus != nil { + in, out := &in.ResizeStatus, &out.ResizeStatus + *out = new(PersistentVolumeClaimResizeStatus) + **out = **in + } return } @@ -3600,6 +3634,22 @@ func (in *PodLogOptions) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PodOS) DeepCopyInto(out *PodOS) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodOS. +func (in *PodOS) DeepCopy() *PodOS { + if in == nil { + return nil + } + out := new(PodOS) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *PodPortForwardOptions) DeepCopyInto(out *PodPortForwardOptions) { *out = *in @@ -3894,6 +3944,11 @@ func (in *PodSpec) DeepCopyInto(out *PodSpec) { *out = new(bool) **out = **in } + if in.OS != nil { + in, out := &in.OS, &out.OS + *out = new(PodOS) + **out = **in + } return } @@ -4161,7 +4216,7 @@ func (in *PreferredSchedulingTerm) DeepCopy() *PreferredSchedulingTerm { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *Probe) DeepCopyInto(out *Probe) { *out = *in - in.Handler.DeepCopyInto(&out.Handler) + in.ProbeHandler.DeepCopyInto(&out.ProbeHandler) if in.TerminationGracePeriodSeconds != nil { in, out := &in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds *out = new(int64) @@ -4180,6 +4235,42 @@ func (in *Probe) DeepCopy() *Probe { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ProbeHandler) DeepCopyInto(out *ProbeHandler) { + *out = *in + if in.Exec != nil { + in, out := &in.Exec, &out.Exec + *out = new(ExecAction) + (*in).DeepCopyInto(*out) + } + if in.HTTPGet != nil { + in, out := &in.HTTPGet, &out.HTTPGet + *out = new(HTTPGetAction) + (*in).DeepCopyInto(*out) + } + if in.TCPSocket != nil { + in, out := &in.TCPSocket, &out.TCPSocket + *out = new(TCPSocketAction) + **out = **in + } + if in.GRPC != nil { + in, out := &in.GRPC, &out.GRPC + *out = new(GRPCAction) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProbeHandler. +func (in *ProbeHandler) DeepCopy() *ProbeHandler { + if in == nil { + return nil + } + out := new(ProbeHandler) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ProjectedVolumeSource) DeepCopyInto(out *ProjectedVolumeSource) { *out = *in diff --git a/vendor/k8s.io/api/discovery/v1/types.go b/vendor/k8s.io/api/discovery/v1/types.go index b66fdd8849..3c45ba3e7f 100644 --- a/vendor/k8s.io/api/discovery/v1/types.go +++ b/vendor/k8s.io/api/discovery/v1/types.go @@ -55,6 +55,7 @@ type EndpointSlice struct { } // AddressType represents the type of address referred to by an endpoint. +// +enum type AddressType string const ( diff --git a/vendor/k8s.io/api/discovery/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/discovery/v1/zz_generated.deepcopy.go index 31a912386f..caa872af00 100644 --- a/vendor/k8s.io/api/discovery/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/discovery/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/discovery/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/discovery/v1beta1/zz_generated.deepcopy.go index f13536b4bc..13b9544b0c 100644 --- a/vendor/k8s.io/api/discovery/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/discovery/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/discovery/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/discovery/v1beta1/zz_generated.prerelease-lifecycle.go index c0f2c63f09..ebca424776 100644 --- a/vendor/k8s.io/api/discovery/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/discovery/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/events/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/events/v1/zz_generated.deepcopy.go index 19a3c5f776..738f0163d3 100644 --- a/vendor/k8s.io/api/events/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/events/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/events/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/events/v1beta1/zz_generated.deepcopy.go index 779ebaf6e9..1e073ae9c9 100644 --- a/vendor/k8s.io/api/events/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/events/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/events/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/events/v1beta1/zz_generated.prerelease-lifecycle.go index 2ab7b412b9..227ca4b7de 100644 --- a/vendor/k8s.io/api/events/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/events/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/extensions/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/extensions/v1beta1/zz_generated.deepcopy.go index 8383156109..e0961588e0 100644 --- a/vendor/k8s.io/api/extensions/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/extensions/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/extensions/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/extensions/v1beta1/zz_generated.prerelease-lifecycle.go index 5023dd31a5..963aaffba3 100644 --- a/vendor/k8s.io/api/extensions/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/extensions/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/flowcontrol/v1alpha1/generated.proto b/vendor/k8s.io/api/flowcontrol/v1alpha1/generated.proto index 2e0d0eae2a..6c0cf93420 100644 --- a/vendor/k8s.io/api/flowcontrol/v1alpha1/generated.proto +++ b/vendor/k8s.io/api/flowcontrol/v1alpha1/generated.proto @@ -352,8 +352,10 @@ message QueuingConfiguration { // ResourcePolicyRule matches a resource request if and only if: (a) // at least one member of verbs matches the request, (b) at least one // member of apiGroups matches the request, (c) at least one member of -// resources matches the request, and (d) least one member of -// namespaces matches the request. +// resources matches the request, and (d) either (d1) the request does +// not specify a namespace (i.e., `Namespace==""`) and clusterScope is +// true or (d2) the request specifies a namespace and least one member +// of namespaces matches the request's namespace. message ResourcePolicyRule { // `verbs` is a list of matching verbs and may not be empty. // "*" matches all verbs and, if present, must be the only entry. diff --git a/vendor/k8s.io/api/flowcontrol/v1alpha1/types.go b/vendor/k8s.io/api/flowcontrol/v1alpha1/types.go index afcc6fa34e..5af677e2f5 100644 --- a/vendor/k8s.io/api/flowcontrol/v1alpha1/types.go +++ b/vendor/k8s.io/api/flowcontrol/v1alpha1/types.go @@ -63,7 +63,7 @@ const ( // +k8s:prerelease-lifecycle-gen:introduced=1.18 // +k8s:prerelease-lifecycle-gen:deprecated=1.20 // +k8s:prerelease-lifecycle-gen:removed=1.21 -// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta1,FlowSchema +// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta2,FlowSchema // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with // similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". @@ -87,7 +87,7 @@ type FlowSchema struct { // +k8s:prerelease-lifecycle-gen:introduced=1.18 // +k8s:prerelease-lifecycle-gen:deprecated=1.20 // +k8s:prerelease-lifecycle-gen:removed=1.21 -// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta1,FlowSchemaList +// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta2,FlowSchemaList // FlowSchemaList is a list of FlowSchema objects. type FlowSchemaList struct { @@ -241,8 +241,10 @@ type ServiceAccountSubject struct { // ResourcePolicyRule matches a resource request if and only if: (a) // at least one member of verbs matches the request, (b) at least one // member of apiGroups matches the request, (c) at least one member of -// resources matches the request, and (d) least one member of -// namespaces matches the request. +// resources matches the request, and (d) either (d1) the request does +// not specify a namespace (i.e., `Namespace==""`) and clusterScope is +// true or (d2) the request specifies a namespace and least one member +// of namespaces matches the request's namespace. type ResourcePolicyRule struct { // `verbs` is a list of matching verbs and may not be empty. // "*" matches all verbs and, if present, must be the only entry. @@ -342,7 +344,7 @@ type FlowSchemaConditionType string // +k8s:prerelease-lifecycle-gen:introduced=1.18 // +k8s:prerelease-lifecycle-gen:deprecated=1.20 // +k8s:prerelease-lifecycle-gen:removed=1.21 -// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta1,PriorityLevelConfiguration +// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta2,PriorityLevelConfiguration // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfiguration struct { @@ -365,7 +367,7 @@ type PriorityLevelConfiguration struct { // +k8s:prerelease-lifecycle-gen:introduced=1.18 // +k8s:prerelease-lifecycle-gen:deprecated=1.20 // +k8s:prerelease-lifecycle-gen:removed=1.21 -// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta1,PriorityLevelConfigurationList +// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta2,PriorityLevelConfigurationList // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. type PriorityLevelConfigurationList struct { diff --git a/vendor/k8s.io/api/flowcontrol/v1alpha1/types_swagger_doc_generated.go b/vendor/k8s.io/api/flowcontrol/v1alpha1/types_swagger_doc_generated.go index 8171360bbd..1827be02d7 100644 --- a/vendor/k8s.io/api/flowcontrol/v1alpha1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/flowcontrol/v1alpha1/types_swagger_doc_generated.go @@ -215,7 +215,7 @@ func (QueuingConfiguration) SwaggerDoc() map[string]string { } var map_ResourcePolicyRule = map[string]string{ - "": "ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) least one member of namespaces matches the request.", + "": "ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) either (d1) the request does not specify a namespace (i.e., `Namespace==\"\"`) and clusterScope is true or (d2) the request specifies a namespace and least one member of namespaces matches the request's namespace.", "verbs": "`verbs` is a list of matching verbs and may not be empty. \"*\" matches all verbs and, if present, must be the only entry. Required.", "apiGroups": "`apiGroups` is a list of matching API groups and may not be empty. \"*\" matches all API groups and, if present, must be the only entry. Required.", "resources": "`resources` is a list of matching resources (i.e., lowercase and plural) with, if desired, subresource. For example, [ \"services\", \"nodes/status\" ]. This list may not be empty. \"*\" matches all resources and, if present, must be the only entry. Required.", diff --git a/vendor/k8s.io/api/flowcontrol/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/api/flowcontrol/v1alpha1/zz_generated.deepcopy.go index f5d37954b1..7f73f46061 100644 --- a/vendor/k8s.io/api/flowcontrol/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/flowcontrol/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/flowcontrol/v1alpha1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/flowcontrol/v1alpha1/zz_generated.prerelease-lifecycle.go index 4152aa2a91..2260141609 100644 --- a/vendor/k8s.io/api/flowcontrol/v1alpha1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/flowcontrol/v1alpha1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -39,7 +40,7 @@ func (in *FlowSchema) APILifecycleDeprecated() (major, minor int) { // APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. // It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. func (in *FlowSchema) APILifecycleReplacement() schema.GroupVersionKind { - return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta1", Kind: "FlowSchema"} + return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta2", Kind: "FlowSchema"} } // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. @@ -63,7 +64,7 @@ func (in *FlowSchemaList) APILifecycleDeprecated() (major, minor int) { // APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. // It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. func (in *FlowSchemaList) APILifecycleReplacement() schema.GroupVersionKind { - return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta1", Kind: "FlowSchemaList"} + return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta2", Kind: "FlowSchemaList"} } // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. @@ -87,7 +88,7 @@ func (in *PriorityLevelConfiguration) APILifecycleDeprecated() (major, minor int // APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. // It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. func (in *PriorityLevelConfiguration) APILifecycleReplacement() schema.GroupVersionKind { - return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta1", Kind: "PriorityLevelConfiguration"} + return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta2", Kind: "PriorityLevelConfiguration"} } // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. @@ -111,7 +112,7 @@ func (in *PriorityLevelConfigurationList) APILifecycleDeprecated() (major, minor // APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. // It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. func (in *PriorityLevelConfigurationList) APILifecycleReplacement() schema.GroupVersionKind { - return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta1", Kind: "PriorityLevelConfigurationList"} + return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta2", Kind: "PriorityLevelConfigurationList"} } // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. diff --git a/vendor/k8s.io/api/flowcontrol/v1beta1/generated.proto b/vendor/k8s.io/api/flowcontrol/v1beta1/generated.proto index 40f441c5c2..309d397ff2 100644 --- a/vendor/k8s.io/api/flowcontrol/v1beta1/generated.proto +++ b/vendor/k8s.io/api/flowcontrol/v1beta1/generated.proto @@ -352,8 +352,10 @@ message QueuingConfiguration { // ResourcePolicyRule matches a resource request if and only if: (a) // at least one member of verbs matches the request, (b) at least one // member of apiGroups matches the request, (c) at least one member of -// resources matches the request, and (d) least one member of -// namespaces matches the request. +// resources matches the request, and (d) either (d1) the request does +// not specify a namespace (i.e., `Namespace==""`) and clusterScope is +// true or (d2) the request specifies a namespace and least one member +// of namespaces matches the request's namespace. message ResourcePolicyRule { // `verbs` is a list of matching verbs and may not be empty. // "*" matches all verbs and, if present, must be the only entry. diff --git a/vendor/k8s.io/api/flowcontrol/v1beta1/types.go b/vendor/k8s.io/api/flowcontrol/v1beta1/types.go index c38021d697..b457326429 100644 --- a/vendor/k8s.io/api/flowcontrol/v1beta1/types.go +++ b/vendor/k8s.io/api/flowcontrol/v1beta1/types.go @@ -105,6 +105,7 @@ const ( // +genclient:nonNamespaced // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object // +k8s:prerelease-lifecycle-gen:introduced=1.20 +// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta2,FlowSchema // FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with // similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". @@ -126,6 +127,7 @@ type FlowSchema struct { // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object // +k8s:prerelease-lifecycle-gen:introduced=1.20 +// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta2,FlowSchemaList // FlowSchemaList is a list of FlowSchema objects. type FlowSchemaList struct { @@ -279,8 +281,10 @@ type ServiceAccountSubject struct { // ResourcePolicyRule matches a resource request if and only if: (a) // at least one member of verbs matches the request, (b) at least one // member of apiGroups matches the request, (c) at least one member of -// resources matches the request, and (d) least one member of -// namespaces matches the request. +// resources matches the request, and (d) either (d1) the request does +// not specify a namespace (i.e., `Namespace==""`) and clusterScope is +// true or (d2) the request specifies a namespace and least one member +// of namespaces matches the request's namespace. type ResourcePolicyRule struct { // `verbs` is a list of matching verbs and may not be empty. // "*" matches all verbs and, if present, must be the only entry. @@ -378,6 +382,7 @@ type FlowSchemaConditionType string // +genclient:nonNamespaced // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object // +k8s:prerelease-lifecycle-gen:introduced=1.20 +// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta2,PriorityLevelConfiguration // PriorityLevelConfiguration represents the configuration of a priority level. type PriorityLevelConfiguration struct { @@ -398,6 +403,7 @@ type PriorityLevelConfiguration struct { // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object // +k8s:prerelease-lifecycle-gen:introduced=1.20 +// +k8s:prerelease-lifecycle-gen:replacement=flowcontrol.apiserver.k8s.io,v1beta2,PriorityLevelConfigurationList // PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. type PriorityLevelConfigurationList struct { diff --git a/vendor/k8s.io/api/flowcontrol/v1beta1/types_swagger_doc_generated.go b/vendor/k8s.io/api/flowcontrol/v1beta1/types_swagger_doc_generated.go index 0f2f05e3a1..b3752b6fb7 100644 --- a/vendor/k8s.io/api/flowcontrol/v1beta1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/flowcontrol/v1beta1/types_swagger_doc_generated.go @@ -215,7 +215,7 @@ func (QueuingConfiguration) SwaggerDoc() map[string]string { } var map_ResourcePolicyRule = map[string]string{ - "": "ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) least one member of namespaces matches the request.", + "": "ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) either (d1) the request does not specify a namespace (i.e., `Namespace==\"\"`) and clusterScope is true or (d2) the request specifies a namespace and least one member of namespaces matches the request's namespace.", "verbs": "`verbs` is a list of matching verbs and may not be empty. \"*\" matches all verbs and, if present, must be the only entry. Required.", "apiGroups": "`apiGroups` is a list of matching API groups and may not be empty. \"*\" matches all API groups and, if present, must be the only entry. Required.", "resources": "`resources` is a list of matching resources (i.e., lowercase and plural) with, if desired, subresource. For example, [ \"services\", \"nodes/status\" ]. This list may not be empty. \"*\" matches all resources and, if present, must be the only entry. Required.", diff --git a/vendor/k8s.io/api/flowcontrol/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/flowcontrol/v1beta1/zz_generated.deepcopy.go index c8f6e23060..b7b84634ac 100644 --- a/vendor/k8s.io/api/flowcontrol/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/flowcontrol/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/flowcontrol/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/flowcontrol/v1beta1/zz_generated.prerelease-lifecycle.go index d0f2297181..ed1e16c26a 100644 --- a/vendor/k8s.io/api/flowcontrol/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/flowcontrol/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -20,6 +21,10 @@ limitations under the License. package v1beta1 +import ( + schema "k8s.io/apimachinery/pkg/runtime/schema" +) + // APILifecycleIntroduced is an autogenerated function, returning the release in which the API struct was introduced as int versions of major and minor for comparison. // It is controlled by "k8s:prerelease-lifecycle-gen:introduced" tags in types.go. func (in *FlowSchema) APILifecycleIntroduced() (major, minor int) { @@ -32,6 +37,12 @@ func (in *FlowSchema) APILifecycleDeprecated() (major, minor int) { return 1, 23 } +// APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. +// It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. +func (in *FlowSchema) APILifecycleReplacement() schema.GroupVersionKind { + return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta2", Kind: "FlowSchema"} +} + // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. // It is controlled by "k8s:prerelease-lifecycle-gen:removed" tags in types.go or "k8s:prerelease-lifecycle-gen:deprecated" plus three minor. func (in *FlowSchema) APILifecycleRemoved() (major, minor int) { @@ -50,6 +61,12 @@ func (in *FlowSchemaList) APILifecycleDeprecated() (major, minor int) { return 1, 23 } +// APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. +// It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. +func (in *FlowSchemaList) APILifecycleReplacement() schema.GroupVersionKind { + return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta2", Kind: "FlowSchemaList"} +} + // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. // It is controlled by "k8s:prerelease-lifecycle-gen:removed" tags in types.go or "k8s:prerelease-lifecycle-gen:deprecated" plus three minor. func (in *FlowSchemaList) APILifecycleRemoved() (major, minor int) { @@ -68,6 +85,12 @@ func (in *PriorityLevelConfiguration) APILifecycleDeprecated() (major, minor int return 1, 23 } +// APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. +// It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. +func (in *PriorityLevelConfiguration) APILifecycleReplacement() schema.GroupVersionKind { + return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta2", Kind: "PriorityLevelConfiguration"} +} + // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. // It is controlled by "k8s:prerelease-lifecycle-gen:removed" tags in types.go or "k8s:prerelease-lifecycle-gen:deprecated" plus three minor. func (in *PriorityLevelConfiguration) APILifecycleRemoved() (major, minor int) { @@ -86,6 +109,12 @@ func (in *PriorityLevelConfigurationList) APILifecycleDeprecated() (major, minor return 1, 23 } +// APILifecycleReplacement is an autogenerated function, returning the group, version, and kind that should be used instead of this deprecated type. +// It is controlled by "k8s:prerelease-lifecycle-gen:replacement=,," tags in types.go. +func (in *PriorityLevelConfigurationList) APILifecycleReplacement() schema.GroupVersionKind { + return schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1beta2", Kind: "PriorityLevelConfigurationList"} +} + // APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. // It is controlled by "k8s:prerelease-lifecycle-gen:removed" tags in types.go or "k8s:prerelease-lifecycle-gen:deprecated" plus three minor. func (in *PriorityLevelConfigurationList) APILifecycleRemoved() (major, minor int) { diff --git a/vendor/k8s.io/component-base/cli/flag/ciphersuites_flag_114.go b/vendor/k8s.io/api/flowcontrol/v1beta2/doc.go similarity index 58% rename from vendor/k8s.io/component-base/cli/flag/ciphersuites_flag_114.go rename to vendor/k8s.io/api/flowcontrol/v1beta2/doc.go index 45b39eb0f0..53b460d374 100644 --- a/vendor/k8s.io/component-base/cli/flag/ciphersuites_flag_114.go +++ b/vendor/k8s.io/api/flowcontrol/v1beta2/doc.go @@ -1,7 +1,5 @@ -// +build go1.14 - /* -Copyright 2020 The Kubernetes Authors. +Copyright 2019 The Kubernetes Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -16,14 +14,12 @@ See the License for the specific language governing permissions and limitations under the License. */ -package flag +// +k8s:deepcopy-gen=package +// +k8s:protobuf-gen=package +// +k8s:openapi-gen=true +// +k8s:prerelease-lifecycle-gen=true -import ( - "crypto/tls" -) +// +groupName=flowcontrol.apiserver.k8s.io -func init() { - // support official IANA names as well on go1.14 - ciphers["TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"] = tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 - ciphers["TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"] = tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 -} +// Package v1beta2 holds api types of version v1alpha1 for group "flowcontrol.apiserver.k8s.io". +package v1beta2 // import "k8s.io/api/flowcontrol/v1beta2" diff --git a/vendor/k8s.io/api/flowcontrol/v1beta2/generated.pb.go b/vendor/k8s.io/api/flowcontrol/v1beta2/generated.pb.go new file mode 100644 index 0000000000..fe550271b1 --- /dev/null +++ b/vendor/k8s.io/api/flowcontrol/v1beta2/generated.pb.go @@ -0,0 +1,5367 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: k8s.io/kubernetes/vendor/k8s.io/api/flowcontrol/v1beta2/generated.proto + +package v1beta2 + +import ( + fmt "fmt" + + io "io" + + proto "github.com/gogo/protobuf/proto" + + math "math" + math_bits "math/bits" + reflect "reflect" + strings "strings" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +func (m *FlowDistinguisherMethod) Reset() { *m = FlowDistinguisherMethod{} } +func (*FlowDistinguisherMethod) ProtoMessage() {} +func (*FlowDistinguisherMethod) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{0} +} +func (m *FlowDistinguisherMethod) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FlowDistinguisherMethod) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *FlowDistinguisherMethod) XXX_Merge(src proto.Message) { + xxx_messageInfo_FlowDistinguisherMethod.Merge(m, src) +} +func (m *FlowDistinguisherMethod) XXX_Size() int { + return m.Size() +} +func (m *FlowDistinguisherMethod) XXX_DiscardUnknown() { + xxx_messageInfo_FlowDistinguisherMethod.DiscardUnknown(m) +} + +var xxx_messageInfo_FlowDistinguisherMethod proto.InternalMessageInfo + +func (m *FlowSchema) Reset() { *m = FlowSchema{} } +func (*FlowSchema) ProtoMessage() {} +func (*FlowSchema) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{1} +} +func (m *FlowSchema) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FlowSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *FlowSchema) XXX_Merge(src proto.Message) { + xxx_messageInfo_FlowSchema.Merge(m, src) +} +func (m *FlowSchema) XXX_Size() int { + return m.Size() +} +func (m *FlowSchema) XXX_DiscardUnknown() { + xxx_messageInfo_FlowSchema.DiscardUnknown(m) +} + +var xxx_messageInfo_FlowSchema proto.InternalMessageInfo + +func (m *FlowSchemaCondition) Reset() { *m = FlowSchemaCondition{} } +func (*FlowSchemaCondition) ProtoMessage() {} +func (*FlowSchemaCondition) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{2} +} +func (m *FlowSchemaCondition) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FlowSchemaCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *FlowSchemaCondition) XXX_Merge(src proto.Message) { + xxx_messageInfo_FlowSchemaCondition.Merge(m, src) +} +func (m *FlowSchemaCondition) XXX_Size() int { + return m.Size() +} +func (m *FlowSchemaCondition) XXX_DiscardUnknown() { + xxx_messageInfo_FlowSchemaCondition.DiscardUnknown(m) +} + +var xxx_messageInfo_FlowSchemaCondition proto.InternalMessageInfo + +func (m *FlowSchemaList) Reset() { *m = FlowSchemaList{} } +func (*FlowSchemaList) ProtoMessage() {} +func (*FlowSchemaList) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{3} +} +func (m *FlowSchemaList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FlowSchemaList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *FlowSchemaList) XXX_Merge(src proto.Message) { + xxx_messageInfo_FlowSchemaList.Merge(m, src) +} +func (m *FlowSchemaList) XXX_Size() int { + return m.Size() +} +func (m *FlowSchemaList) XXX_DiscardUnknown() { + xxx_messageInfo_FlowSchemaList.DiscardUnknown(m) +} + +var xxx_messageInfo_FlowSchemaList proto.InternalMessageInfo + +func (m *FlowSchemaSpec) Reset() { *m = FlowSchemaSpec{} } +func (*FlowSchemaSpec) ProtoMessage() {} +func (*FlowSchemaSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{4} +} +func (m *FlowSchemaSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FlowSchemaSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *FlowSchemaSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_FlowSchemaSpec.Merge(m, src) +} +func (m *FlowSchemaSpec) XXX_Size() int { + return m.Size() +} +func (m *FlowSchemaSpec) XXX_DiscardUnknown() { + xxx_messageInfo_FlowSchemaSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_FlowSchemaSpec proto.InternalMessageInfo + +func (m *FlowSchemaStatus) Reset() { *m = FlowSchemaStatus{} } +func (*FlowSchemaStatus) ProtoMessage() {} +func (*FlowSchemaStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{5} +} +func (m *FlowSchemaStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FlowSchemaStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *FlowSchemaStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_FlowSchemaStatus.Merge(m, src) +} +func (m *FlowSchemaStatus) XXX_Size() int { + return m.Size() +} +func (m *FlowSchemaStatus) XXX_DiscardUnknown() { + xxx_messageInfo_FlowSchemaStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_FlowSchemaStatus proto.InternalMessageInfo + +func (m *GroupSubject) Reset() { *m = GroupSubject{} } +func (*GroupSubject) ProtoMessage() {} +func (*GroupSubject) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{6} +} +func (m *GroupSubject) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GroupSubject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *GroupSubject) XXX_Merge(src proto.Message) { + xxx_messageInfo_GroupSubject.Merge(m, src) +} +func (m *GroupSubject) XXX_Size() int { + return m.Size() +} +func (m *GroupSubject) XXX_DiscardUnknown() { + xxx_messageInfo_GroupSubject.DiscardUnknown(m) +} + +var xxx_messageInfo_GroupSubject proto.InternalMessageInfo + +func (m *LimitResponse) Reset() { *m = LimitResponse{} } +func (*LimitResponse) ProtoMessage() {} +func (*LimitResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{7} +} +func (m *LimitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LimitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *LimitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_LimitResponse.Merge(m, src) +} +func (m *LimitResponse) XXX_Size() int { + return m.Size() +} +func (m *LimitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_LimitResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_LimitResponse proto.InternalMessageInfo + +func (m *LimitedPriorityLevelConfiguration) Reset() { *m = LimitedPriorityLevelConfiguration{} } +func (*LimitedPriorityLevelConfiguration) ProtoMessage() {} +func (*LimitedPriorityLevelConfiguration) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{8} +} +func (m *LimitedPriorityLevelConfiguration) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LimitedPriorityLevelConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *LimitedPriorityLevelConfiguration) XXX_Merge(src proto.Message) { + xxx_messageInfo_LimitedPriorityLevelConfiguration.Merge(m, src) +} +func (m *LimitedPriorityLevelConfiguration) XXX_Size() int { + return m.Size() +} +func (m *LimitedPriorityLevelConfiguration) XXX_DiscardUnknown() { + xxx_messageInfo_LimitedPriorityLevelConfiguration.DiscardUnknown(m) +} + +var xxx_messageInfo_LimitedPriorityLevelConfiguration proto.InternalMessageInfo + +func (m *NonResourcePolicyRule) Reset() { *m = NonResourcePolicyRule{} } +func (*NonResourcePolicyRule) ProtoMessage() {} +func (*NonResourcePolicyRule) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{9} +} +func (m *NonResourcePolicyRule) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NonResourcePolicyRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *NonResourcePolicyRule) XXX_Merge(src proto.Message) { + xxx_messageInfo_NonResourcePolicyRule.Merge(m, src) +} +func (m *NonResourcePolicyRule) XXX_Size() int { + return m.Size() +} +func (m *NonResourcePolicyRule) XXX_DiscardUnknown() { + xxx_messageInfo_NonResourcePolicyRule.DiscardUnknown(m) +} + +var xxx_messageInfo_NonResourcePolicyRule proto.InternalMessageInfo + +func (m *PolicyRulesWithSubjects) Reset() { *m = PolicyRulesWithSubjects{} } +func (*PolicyRulesWithSubjects) ProtoMessage() {} +func (*PolicyRulesWithSubjects) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{10} +} +func (m *PolicyRulesWithSubjects) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PolicyRulesWithSubjects) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PolicyRulesWithSubjects) XXX_Merge(src proto.Message) { + xxx_messageInfo_PolicyRulesWithSubjects.Merge(m, src) +} +func (m *PolicyRulesWithSubjects) XXX_Size() int { + return m.Size() +} +func (m *PolicyRulesWithSubjects) XXX_DiscardUnknown() { + xxx_messageInfo_PolicyRulesWithSubjects.DiscardUnknown(m) +} + +var xxx_messageInfo_PolicyRulesWithSubjects proto.InternalMessageInfo + +func (m *PriorityLevelConfiguration) Reset() { *m = PriorityLevelConfiguration{} } +func (*PriorityLevelConfiguration) ProtoMessage() {} +func (*PriorityLevelConfiguration) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{11} +} +func (m *PriorityLevelConfiguration) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PriorityLevelConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PriorityLevelConfiguration) XXX_Merge(src proto.Message) { + xxx_messageInfo_PriorityLevelConfiguration.Merge(m, src) +} +func (m *PriorityLevelConfiguration) XXX_Size() int { + return m.Size() +} +func (m *PriorityLevelConfiguration) XXX_DiscardUnknown() { + xxx_messageInfo_PriorityLevelConfiguration.DiscardUnknown(m) +} + +var xxx_messageInfo_PriorityLevelConfiguration proto.InternalMessageInfo + +func (m *PriorityLevelConfigurationCondition) Reset() { *m = PriorityLevelConfigurationCondition{} } +func (*PriorityLevelConfigurationCondition) ProtoMessage() {} +func (*PriorityLevelConfigurationCondition) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{12} +} +func (m *PriorityLevelConfigurationCondition) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PriorityLevelConfigurationCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PriorityLevelConfigurationCondition) XXX_Merge(src proto.Message) { + xxx_messageInfo_PriorityLevelConfigurationCondition.Merge(m, src) +} +func (m *PriorityLevelConfigurationCondition) XXX_Size() int { + return m.Size() +} +func (m *PriorityLevelConfigurationCondition) XXX_DiscardUnknown() { + xxx_messageInfo_PriorityLevelConfigurationCondition.DiscardUnknown(m) +} + +var xxx_messageInfo_PriorityLevelConfigurationCondition proto.InternalMessageInfo + +func (m *PriorityLevelConfigurationList) Reset() { *m = PriorityLevelConfigurationList{} } +func (*PriorityLevelConfigurationList) ProtoMessage() {} +func (*PriorityLevelConfigurationList) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{13} +} +func (m *PriorityLevelConfigurationList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PriorityLevelConfigurationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PriorityLevelConfigurationList) XXX_Merge(src proto.Message) { + xxx_messageInfo_PriorityLevelConfigurationList.Merge(m, src) +} +func (m *PriorityLevelConfigurationList) XXX_Size() int { + return m.Size() +} +func (m *PriorityLevelConfigurationList) XXX_DiscardUnknown() { + xxx_messageInfo_PriorityLevelConfigurationList.DiscardUnknown(m) +} + +var xxx_messageInfo_PriorityLevelConfigurationList proto.InternalMessageInfo + +func (m *PriorityLevelConfigurationReference) Reset() { *m = PriorityLevelConfigurationReference{} } +func (*PriorityLevelConfigurationReference) ProtoMessage() {} +func (*PriorityLevelConfigurationReference) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{14} +} +func (m *PriorityLevelConfigurationReference) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PriorityLevelConfigurationReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PriorityLevelConfigurationReference) XXX_Merge(src proto.Message) { + xxx_messageInfo_PriorityLevelConfigurationReference.Merge(m, src) +} +func (m *PriorityLevelConfigurationReference) XXX_Size() int { + return m.Size() +} +func (m *PriorityLevelConfigurationReference) XXX_DiscardUnknown() { + xxx_messageInfo_PriorityLevelConfigurationReference.DiscardUnknown(m) +} + +var xxx_messageInfo_PriorityLevelConfigurationReference proto.InternalMessageInfo + +func (m *PriorityLevelConfigurationSpec) Reset() { *m = PriorityLevelConfigurationSpec{} } +func (*PriorityLevelConfigurationSpec) ProtoMessage() {} +func (*PriorityLevelConfigurationSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{15} +} +func (m *PriorityLevelConfigurationSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PriorityLevelConfigurationSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PriorityLevelConfigurationSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_PriorityLevelConfigurationSpec.Merge(m, src) +} +func (m *PriorityLevelConfigurationSpec) XXX_Size() int { + return m.Size() +} +func (m *PriorityLevelConfigurationSpec) XXX_DiscardUnknown() { + xxx_messageInfo_PriorityLevelConfigurationSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_PriorityLevelConfigurationSpec proto.InternalMessageInfo + +func (m *PriorityLevelConfigurationStatus) Reset() { *m = PriorityLevelConfigurationStatus{} } +func (*PriorityLevelConfigurationStatus) ProtoMessage() {} +func (*PriorityLevelConfigurationStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{16} +} +func (m *PriorityLevelConfigurationStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PriorityLevelConfigurationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PriorityLevelConfigurationStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_PriorityLevelConfigurationStatus.Merge(m, src) +} +func (m *PriorityLevelConfigurationStatus) XXX_Size() int { + return m.Size() +} +func (m *PriorityLevelConfigurationStatus) XXX_DiscardUnknown() { + xxx_messageInfo_PriorityLevelConfigurationStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_PriorityLevelConfigurationStatus proto.InternalMessageInfo + +func (m *QueuingConfiguration) Reset() { *m = QueuingConfiguration{} } +func (*QueuingConfiguration) ProtoMessage() {} +func (*QueuingConfiguration) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{17} +} +func (m *QueuingConfiguration) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueuingConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *QueuingConfiguration) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueuingConfiguration.Merge(m, src) +} +func (m *QueuingConfiguration) XXX_Size() int { + return m.Size() +} +func (m *QueuingConfiguration) XXX_DiscardUnknown() { + xxx_messageInfo_QueuingConfiguration.DiscardUnknown(m) +} + +var xxx_messageInfo_QueuingConfiguration proto.InternalMessageInfo + +func (m *ResourcePolicyRule) Reset() { *m = ResourcePolicyRule{} } +func (*ResourcePolicyRule) ProtoMessage() {} +func (*ResourcePolicyRule) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{18} +} +func (m *ResourcePolicyRule) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResourcePolicyRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ResourcePolicyRule) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResourcePolicyRule.Merge(m, src) +} +func (m *ResourcePolicyRule) XXX_Size() int { + return m.Size() +} +func (m *ResourcePolicyRule) XXX_DiscardUnknown() { + xxx_messageInfo_ResourcePolicyRule.DiscardUnknown(m) +} + +var xxx_messageInfo_ResourcePolicyRule proto.InternalMessageInfo + +func (m *ServiceAccountSubject) Reset() { *m = ServiceAccountSubject{} } +func (*ServiceAccountSubject) ProtoMessage() {} +func (*ServiceAccountSubject) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{19} +} +func (m *ServiceAccountSubject) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ServiceAccountSubject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ServiceAccountSubject) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServiceAccountSubject.Merge(m, src) +} +func (m *ServiceAccountSubject) XXX_Size() int { + return m.Size() +} +func (m *ServiceAccountSubject) XXX_DiscardUnknown() { + xxx_messageInfo_ServiceAccountSubject.DiscardUnknown(m) +} + +var xxx_messageInfo_ServiceAccountSubject proto.InternalMessageInfo + +func (m *Subject) Reset() { *m = Subject{} } +func (*Subject) ProtoMessage() {} +func (*Subject) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{20} +} +func (m *Subject) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Subject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *Subject) XXX_Merge(src proto.Message) { + xxx_messageInfo_Subject.Merge(m, src) +} +func (m *Subject) XXX_Size() int { + return m.Size() +} +func (m *Subject) XXX_DiscardUnknown() { + xxx_messageInfo_Subject.DiscardUnknown(m) +} + +var xxx_messageInfo_Subject proto.InternalMessageInfo + +func (m *UserSubject) Reset() { *m = UserSubject{} } +func (*UserSubject) ProtoMessage() {} +func (*UserSubject) Descriptor() ([]byte, []int) { + return fileDescriptor_ed300aa8e672704e, []int{21} +} +func (m *UserSubject) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UserSubject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *UserSubject) XXX_Merge(src proto.Message) { + xxx_messageInfo_UserSubject.Merge(m, src) +} +func (m *UserSubject) XXX_Size() int { + return m.Size() +} +func (m *UserSubject) XXX_DiscardUnknown() { + xxx_messageInfo_UserSubject.DiscardUnknown(m) +} + +var xxx_messageInfo_UserSubject proto.InternalMessageInfo + +func init() { + proto.RegisterType((*FlowDistinguisherMethod)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowDistinguisherMethod") + proto.RegisterType((*FlowSchema)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchema") + proto.RegisterType((*FlowSchemaCondition)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchemaCondition") + proto.RegisterType((*FlowSchemaList)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchemaList") + proto.RegisterType((*FlowSchemaSpec)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchemaSpec") + proto.RegisterType((*FlowSchemaStatus)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchemaStatus") + proto.RegisterType((*GroupSubject)(nil), "k8s.io.api.flowcontrol.v1beta2.GroupSubject") + proto.RegisterType((*LimitResponse)(nil), "k8s.io.api.flowcontrol.v1beta2.LimitResponse") + proto.RegisterType((*LimitedPriorityLevelConfiguration)(nil), "k8s.io.api.flowcontrol.v1beta2.LimitedPriorityLevelConfiguration") + proto.RegisterType((*NonResourcePolicyRule)(nil), "k8s.io.api.flowcontrol.v1beta2.NonResourcePolicyRule") + proto.RegisterType((*PolicyRulesWithSubjects)(nil), "k8s.io.api.flowcontrol.v1beta2.PolicyRulesWithSubjects") + proto.RegisterType((*PriorityLevelConfiguration)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfiguration") + proto.RegisterType((*PriorityLevelConfigurationCondition)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationCondition") + proto.RegisterType((*PriorityLevelConfigurationList)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationList") + proto.RegisterType((*PriorityLevelConfigurationReference)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationReference") + proto.RegisterType((*PriorityLevelConfigurationSpec)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationSpec") + proto.RegisterType((*PriorityLevelConfigurationStatus)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationStatus") + proto.RegisterType((*QueuingConfiguration)(nil), "k8s.io.api.flowcontrol.v1beta2.QueuingConfiguration") + proto.RegisterType((*ResourcePolicyRule)(nil), "k8s.io.api.flowcontrol.v1beta2.ResourcePolicyRule") + proto.RegisterType((*ServiceAccountSubject)(nil), "k8s.io.api.flowcontrol.v1beta2.ServiceAccountSubject") + proto.RegisterType((*Subject)(nil), "k8s.io.api.flowcontrol.v1beta2.Subject") + proto.RegisterType((*UserSubject)(nil), "k8s.io.api.flowcontrol.v1beta2.UserSubject") +} + +func init() { + proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/flowcontrol/v1beta2/generated.proto", fileDescriptor_ed300aa8e672704e) +} + +var fileDescriptor_ed300aa8e672704e = []byte{ + // 1495 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x57, 0xcb, 0x73, 0xdb, 0x44, + 0x18, 0x8f, 0x1c, 0x3b, 0x89, 0xbf, 0x3c, 0xbb, 0x69, 0x27, 0x9e, 0x74, 0xc6, 0x4e, 0xc5, 0x0c, + 0x05, 0xda, 0xca, 0x6d, 0x69, 0x69, 0x81, 0xe1, 0x11, 0xa5, 0x50, 0x4a, 0x93, 0x34, 0xdd, 0xb4, + 0xc0, 0x94, 0xce, 0x50, 0x59, 0xde, 0xd8, 0x6a, 0x6c, 0x49, 0xd5, 0xae, 0x9c, 0x09, 0xbd, 0x30, + 0xfc, 0x05, 0x9c, 0xe1, 0xc8, 0x81, 0x3b, 0xff, 0x00, 0x47, 0x3a, 0x9c, 0x7a, 0xec, 0xc9, 0x50, + 0x73, 0xe2, 0xc0, 0x1d, 0x7a, 0x62, 0x76, 0xb5, 0x92, 0x2c, 0xbf, 0xe4, 0x69, 0x67, 0x7a, 0xe2, + 0x66, 0x7d, 0x8f, 0xdf, 0xf7, 0xd8, 0xdf, 0x7e, 0xfb, 0x19, 0xae, 0xee, 0x5f, 0xa6, 0x9a, 0xe5, + 0x94, 0xf7, 0xfd, 0x0a, 0xf1, 0x6c, 0xc2, 0x08, 0x2d, 0xb7, 0x88, 0x5d, 0x75, 0xbc, 0xb2, 0x54, + 0x18, 0xae, 0x55, 0xde, 0x6b, 0x38, 0x07, 0xa6, 0x63, 0x33, 0xcf, 0x69, 0x94, 0x5b, 0xe7, 0x2a, + 0x84, 0x19, 0xe7, 0xcb, 0x35, 0x62, 0x13, 0xcf, 0x60, 0xa4, 0xaa, 0xb9, 0x9e, 0xc3, 0x1c, 0x54, + 0x0c, 0xec, 0x35, 0xc3, 0xb5, 0xb4, 0x2e, 0x7b, 0x4d, 0xda, 0xaf, 0x9e, 0xa9, 0x59, 0xac, 0xee, + 0x57, 0x34, 0xd3, 0x69, 0x96, 0x6b, 0x4e, 0xcd, 0x29, 0x0b, 0xb7, 0x8a, 0xbf, 0x27, 0xbe, 0xc4, + 0x87, 0xf8, 0x15, 0xc0, 0xad, 0x5e, 0x88, 0xc3, 0x37, 0x0d, 0xb3, 0x6e, 0xd9, 0xc4, 0x3b, 0x2c, + 0xbb, 0xfb, 0x35, 0x2e, 0xa0, 0xe5, 0x26, 0x61, 0x46, 0xb9, 0x75, 0xae, 0x37, 0x89, 0xd5, 0xf2, + 0x30, 0x2f, 0xcf, 0xb7, 0x99, 0xd5, 0x24, 0x7d, 0x0e, 0x6f, 0xa5, 0x39, 0x50, 0xb3, 0x4e, 0x9a, + 0x46, 0xaf, 0x9f, 0x7a, 0x07, 0x56, 0x3e, 0x6e, 0x38, 0x07, 0x57, 0x2c, 0xca, 0x2c, 0xbb, 0xe6, + 0x5b, 0xb4, 0x4e, 0xbc, 0x2d, 0xc2, 0xea, 0x4e, 0x15, 0x7d, 0x00, 0x59, 0x76, 0xe8, 0x92, 0x82, + 0xb2, 0xa6, 0xbc, 0x96, 0xd7, 0x4f, 0x3d, 0x6a, 0x97, 0x26, 0x3a, 0xed, 0x52, 0xf6, 0xd6, 0xa1, + 0x4b, 0x9e, 0xb5, 0x4b, 0xc7, 0x87, 0xb8, 0x71, 0x35, 0x16, 0x8e, 0xea, 0xf7, 0x19, 0x00, 0x6e, + 0xb5, 0x2b, 0x42, 0xa3, 0x7b, 0x30, 0xc3, 0xcb, 0xad, 0x1a, 0xcc, 0x10, 0x98, 0xb3, 0xe7, 0xcf, + 0x6a, 0x71, 0xaf, 0xa3, 0xac, 0x35, 0x77, 0xbf, 0xc6, 0x05, 0x54, 0xe3, 0xd6, 0x5a, 0xeb, 0x9c, + 0x76, 0xa3, 0x72, 0x9f, 0x98, 0x6c, 0x8b, 0x30, 0x43, 0x47, 0x32, 0x0b, 0x88, 0x65, 0x38, 0x42, + 0x45, 0x3b, 0x90, 0xa5, 0x2e, 0x31, 0x0b, 0x19, 0x81, 0xae, 0x69, 0xa3, 0x4f, 0x52, 0x8b, 0x73, + 0xdb, 0x75, 0x89, 0xa9, 0xcf, 0x85, 0x15, 0xf2, 0x2f, 0x2c, 0x90, 0xd0, 0x17, 0x30, 0x45, 0x99, + 0xc1, 0x7c, 0x5a, 0x98, 0xec, 0xcb, 0x38, 0x0d, 0x53, 0xf8, 0xe9, 0x0b, 0x12, 0x75, 0x2a, 0xf8, + 0xc6, 0x12, 0x4f, 0x7d, 0x92, 0x81, 0xe5, 0xd8, 0x78, 0xc3, 0xb1, 0xab, 0x16, 0xb3, 0x1c, 0x1b, + 0xbd, 0x9b, 0xe8, 0xfa, 0xc9, 0x9e, 0xae, 0xaf, 0x0c, 0x70, 0x89, 0x3b, 0x8e, 0xde, 0x8e, 0xd2, + 0xcd, 0x08, 0xf7, 0x13, 0xc9, 0xe0, 0xcf, 0xda, 0xa5, 0xc5, 0xc8, 0x2d, 0x99, 0x0f, 0x6a, 0x01, + 0x6a, 0x18, 0x94, 0xdd, 0xf2, 0x0c, 0x9b, 0x06, 0xb0, 0x56, 0x93, 0xc8, 0xaa, 0xdf, 0x18, 0xef, + 0x9c, 0xb8, 0x87, 0xbe, 0x2a, 0x43, 0xa2, 0xcd, 0x3e, 0x34, 0x3c, 0x20, 0x02, 0x7a, 0x15, 0xa6, + 0x3c, 0x62, 0x50, 0xc7, 0x2e, 0x64, 0x45, 0xca, 0x51, 0xbf, 0xb0, 0x90, 0x62, 0xa9, 0x45, 0xaf, + 0xc3, 0x74, 0x93, 0x50, 0x6a, 0xd4, 0x48, 0x21, 0x27, 0x0c, 0x17, 0xa5, 0xe1, 0xf4, 0x56, 0x20, + 0xc6, 0xa1, 0x5e, 0xfd, 0x45, 0x81, 0x85, 0xb8, 0x4f, 0x9b, 0x16, 0x65, 0xe8, 0x6e, 0x1f, 0xf7, + 0xb4, 0xf1, 0x6a, 0xe2, 0xde, 0x82, 0x79, 0x4b, 0x32, 0xdc, 0x4c, 0x28, 0xe9, 0xe2, 0xdd, 0x0d, + 0xc8, 0x59, 0x8c, 0x34, 0x79, 0xd7, 0x27, 0x7b, 0xda, 0x95, 0x42, 0x12, 0x7d, 0x5e, 0xc2, 0xe6, + 0xae, 0x71, 0x00, 0x1c, 0xe0, 0xa8, 0x7f, 0x4d, 0x76, 0x57, 0xc0, 0xf9, 0x88, 0x7e, 0x52, 0x60, + 0xd5, 0xf5, 0x2c, 0xc7, 0xb3, 0xd8, 0xe1, 0x26, 0x69, 0x91, 0xc6, 0x86, 0x63, 0xef, 0x59, 0x35, + 0xdf, 0x33, 0x78, 0x2b, 0x65, 0x51, 0x1b, 0x69, 0x91, 0x77, 0x86, 0x22, 0x60, 0xb2, 0x47, 0x3c, + 0x62, 0x9b, 0x44, 0x57, 0x65, 0x4a, 0xab, 0x23, 0x8c, 0x47, 0xa4, 0x82, 0x3e, 0x05, 0xd4, 0x34, + 0x18, 0xef, 0x68, 0x6d, 0xc7, 0x23, 0x26, 0xa9, 0x72, 0x54, 0x41, 0xc8, 0x5c, 0xcc, 0x8e, 0xad, + 0x3e, 0x0b, 0x3c, 0xc0, 0x0b, 0x7d, 0xab, 0xc0, 0x72, 0xb5, 0x7f, 0xc8, 0x48, 0x5e, 0x5e, 0x1a, + 0xa7, 0xd1, 0x03, 0x66, 0x94, 0xbe, 0xd2, 0x69, 0x97, 0x96, 0x07, 0x28, 0xf0, 0xa0, 0x60, 0xe8, + 0x2e, 0xe4, 0x3c, 0xbf, 0x41, 0x68, 0x21, 0x2b, 0x8e, 0x37, 0x35, 0xea, 0x8e, 0xd3, 0xb0, 0xcc, + 0x43, 0xcc, 0x5d, 0x3e, 0xb7, 0x58, 0x7d, 0xd7, 0x17, 0xb3, 0x8a, 0xc6, 0x67, 0x2d, 0x54, 0x38, + 0x00, 0x55, 0x1f, 0xc2, 0x52, 0xef, 0xd0, 0x40, 0x35, 0x00, 0x33, 0xbc, 0xa7, 0xb4, 0xa0, 0x88, + 0xb0, 0x6f, 0x8e, 0xcf, 0xaa, 0xe8, 0x8e, 0xc7, 0xf3, 0x32, 0x12, 0x51, 0xdc, 0x05, 0xad, 0x9e, + 0x85, 0xb9, 0xab, 0x9e, 0xe3, 0xbb, 0x32, 0x47, 0xb4, 0x06, 0x59, 0xdb, 0x68, 0x86, 0xd3, 0x27, + 0x9a, 0x88, 0xdb, 0x46, 0x93, 0x60, 0xa1, 0x51, 0x7f, 0x54, 0x60, 0x7e, 0xd3, 0x6a, 0x5a, 0x0c, + 0x13, 0xea, 0x3a, 0x36, 0x25, 0xe8, 0x62, 0x62, 0x62, 0x9d, 0xe8, 0x99, 0x58, 0x47, 0x12, 0xc6, + 0x5d, 0xb3, 0xea, 0x4b, 0x98, 0x7e, 0xe0, 0x13, 0xdf, 0xb2, 0x6b, 0x72, 0x5e, 0x5f, 0x48, 0x2b, + 0xf0, 0x66, 0x60, 0x9e, 0x60, 0x9b, 0x3e, 0xcb, 0x47, 0x80, 0xd4, 0xe0, 0x10, 0x51, 0xfd, 0x5b, + 0x81, 0x13, 0x22, 0x30, 0xa9, 0x0e, 0x67, 0x31, 0xba, 0x0b, 0x05, 0x83, 0x52, 0xdf, 0x23, 0xd5, + 0x0d, 0xc7, 0x36, 0x7d, 0x8f, 0xf3, 0xff, 0x70, 0xb7, 0x6e, 0x78, 0x84, 0x8a, 0x6a, 0x72, 0xfa, + 0x9a, 0xac, 0xa6, 0xb0, 0x3e, 0xc4, 0x0e, 0x0f, 0x45, 0x40, 0xf7, 0x61, 0xbe, 0xd1, 0x5d, 0xbb, + 0x2c, 0xf3, 0x4c, 0x5a, 0x99, 0x89, 0x86, 0xe9, 0xc7, 0x64, 0x06, 0xc9, 0xa6, 0xe3, 0x24, 0xb4, + 0x7a, 0x00, 0xc7, 0xb6, 0xf9, 0x1d, 0xa6, 0x8e, 0xef, 0x99, 0x24, 0x26, 0x20, 0x2a, 0x41, 0xae, + 0x45, 0xbc, 0x4a, 0x40, 0xa2, 0xbc, 0x9e, 0xe7, 0xf4, 0xfb, 0x8c, 0x0b, 0x70, 0x20, 0x47, 0xef, + 0xc1, 0xa2, 0x1d, 0x7b, 0xde, 0xc6, 0x9b, 0xb4, 0x30, 0x25, 0x4c, 0x97, 0x3b, 0xed, 0xd2, 0xe2, + 0x76, 0x52, 0x85, 0x7b, 0x6d, 0xd5, 0x76, 0x06, 0x56, 0x86, 0xf0, 0x1d, 0xdd, 0x86, 0x19, 0x2a, + 0x7f, 0x4b, 0x0e, 0x9f, 0x4c, 0xab, 0x5d, 0xfa, 0xc6, 0xd3, 0x36, 0x04, 0xc3, 0x11, 0x14, 0x72, + 0x60, 0xde, 0x93, 0x29, 0x88, 0x98, 0x72, 0xea, 0x9e, 0x4f, 0xc3, 0xee, 0xef, 0x4e, 0xdc, 0x5c, + 0xdc, 0x0d, 0x88, 0x93, 0xf8, 0xe8, 0x21, 0x2c, 0x75, 0x95, 0x1d, 0xc4, 0x9c, 0x14, 0x31, 0x2f, + 0xa6, 0xc5, 0x1c, 0x78, 0x28, 0x7a, 0x41, 0x86, 0x5d, 0xda, 0xee, 0x81, 0xc5, 0x7d, 0x81, 0xd4, + 0xdf, 0x32, 0x30, 0x62, 0x10, 0xbf, 0x84, 0xa5, 0xea, 0x5e, 0x62, 0xa9, 0x7a, 0xff, 0xf9, 0x5f, + 0x98, 0xa1, 0x4b, 0x56, 0xbd, 0x67, 0xc9, 0xfa, 0xf0, 0x05, 0x62, 0x8c, 0x5e, 0xba, 0xfe, 0xc9, + 0xc0, 0x2b, 0xc3, 0x9d, 0xe3, 0x25, 0xec, 0x7a, 0x62, 0xa4, 0x5d, 0xea, 0x19, 0x69, 0x27, 0xc7, + 0x80, 0xf8, 0x7f, 0x29, 0xeb, 0x59, 0xca, 0x7e, 0x57, 0xa0, 0x38, 0xbc, 0x6f, 0x2f, 0x61, 0x49, + 0xfb, 0x2a, 0xb9, 0xa4, 0xbd, 0xf3, 0xfc, 0x24, 0x1b, 0xb2, 0xb4, 0x5d, 0x1d, 0xc5, 0xad, 0x68, + 0xbd, 0x1a, 0xe3, 0x89, 0xfd, 0x75, 0x64, 0xab, 0xc4, 0x36, 0x98, 0xf2, 0x2f, 0x21, 0xe1, 0xfd, + 0x91, 0x6d, 0x54, 0x1a, 0xa4, 0x49, 0x6c, 0x26, 0x09, 0x59, 0x87, 0xe9, 0x46, 0xf0, 0x36, 0xca, + 0x4b, 0xbd, 0x3e, 0xd6, 0x93, 0x34, 0xea, 0x29, 0x0d, 0x9e, 0x61, 0x69, 0x86, 0x43, 0x78, 0xf5, + 0x07, 0x05, 0xd6, 0xd2, 0x2e, 0x2b, 0x3a, 0x18, 0xb0, 0xec, 0xbc, 0xc0, 0x22, 0x3b, 0xfe, 0xf2, + 0xf3, 0xb3, 0x02, 0x47, 0x07, 0xed, 0x14, 0x9c, 0xfe, 0x7c, 0x91, 0x88, 0xb6, 0x80, 0x88, 0xfe, + 0x37, 0x85, 0x14, 0x4b, 0x2d, 0x3a, 0x0d, 0x33, 0x75, 0xc3, 0xae, 0xee, 0x5a, 0x5f, 0x87, 0xfb, + 0x6d, 0x44, 0xc0, 0x4f, 0xa4, 0x1c, 0x47, 0x16, 0xe8, 0x0a, 0x2c, 0x09, 0xbf, 0x4d, 0x62, 0xd7, + 0x58, 0x5d, 0xf4, 0x4a, 0x5c, 0xe5, 0x5c, 0xfc, 0x1e, 0xdc, 0xec, 0xd1, 0xe3, 0x3e, 0x0f, 0xf5, + 0x5f, 0x05, 0xd0, 0xf3, 0xbc, 0xf3, 0xa7, 0x20, 0x6f, 0xb8, 0x96, 0x58, 0xf6, 0x82, 0x2b, 0x90, + 0xd7, 0xe7, 0x3b, 0xed, 0x52, 0x7e, 0x7d, 0xe7, 0x5a, 0x20, 0xc4, 0xb1, 0x9e, 0x1b, 0x87, 0x4f, + 0x60, 0xf0, 0xd4, 0x49, 0xe3, 0x30, 0x30, 0xc5, 0xb1, 0x1e, 0x5d, 0x86, 0x39, 0xb3, 0xe1, 0x53, + 0x46, 0xbc, 0x5d, 0xd3, 0x71, 0x89, 0x18, 0x19, 0x33, 0xfa, 0x51, 0x59, 0xd3, 0xdc, 0x46, 0x97, + 0x0e, 0x27, 0x2c, 0x91, 0x06, 0xc0, 0x09, 0x4f, 0x5d, 0x83, 0xc7, 0xc9, 0x89, 0x38, 0x0b, 0xfc, + 0xc0, 0xb6, 0x23, 0x29, 0xee, 0xb2, 0x50, 0xef, 0xc3, 0xb1, 0x5d, 0xe2, 0xb5, 0x2c, 0x93, 0xac, + 0x9b, 0xa6, 0xe3, 0xdb, 0x2c, 0x5c, 0x5b, 0xcb, 0x90, 0x8f, 0xcc, 0xe4, 0x9d, 0x38, 0x22, 0xe3, + 0xe7, 0x23, 0x2c, 0x1c, 0xdb, 0x44, 0x97, 0x30, 0x33, 0xfc, 0x12, 0x66, 0x60, 0x3a, 0x86, 0xcf, + 0xee, 0x5b, 0x76, 0x55, 0x22, 0x1f, 0x0f, 0xad, 0xaf, 0x5b, 0x76, 0xf5, 0x59, 0xbb, 0x34, 0x2b, + 0xcd, 0xf8, 0x27, 0x16, 0x86, 0xe8, 0x1a, 0x64, 0x7d, 0x4a, 0x3c, 0x79, 0xbd, 0x4e, 0xa5, 0x91, + 0xf9, 0x36, 0x25, 0x5e, 0xb8, 0xf9, 0xcc, 0x70, 0x64, 0x2e, 0xc0, 0x02, 0x02, 0x6d, 0x41, 0xae, + 0xc6, 0x0f, 0x45, 0x4e, 0xfd, 0xd3, 0x69, 0x58, 0xdd, 0xeb, 0x7c, 0x40, 0x03, 0x21, 0xc1, 0x01, + 0x0a, 0x7a, 0x00, 0x0b, 0x34, 0xd1, 0x42, 0x71, 0x5c, 0x63, 0x6c, 0x32, 0x03, 0x1b, 0xaf, 0xa3, + 0x4e, 0xbb, 0xb4, 0x90, 0x54, 0xe1, 0x9e, 0x00, 0x6a, 0x19, 0x66, 0xbb, 0x0a, 0x4c, 0x9f, 0x7f, + 0xfa, 0x99, 0x47, 0x4f, 0x8b, 0x13, 0x8f, 0x9f, 0x16, 0x27, 0x9e, 0x3c, 0x2d, 0x4e, 0x7c, 0xd3, + 0x29, 0x2a, 0x8f, 0x3a, 0x45, 0xe5, 0x71, 0xa7, 0xa8, 0x3c, 0xe9, 0x14, 0x95, 0x3f, 0x3a, 0x45, + 0xe5, 0xbb, 0x3f, 0x8b, 0x13, 0x77, 0xa6, 0x65, 0x66, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xc1, + 0xb4, 0x84, 0x2d, 0xfa, 0x13, 0x00, 0x00, +} + +func (m *FlowDistinguisherMethod) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FlowDistinguisherMethod) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FlowDistinguisherMethod) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *FlowSchema) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FlowSchema) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FlowSchema) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *FlowSchemaCondition) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FlowSchemaCondition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FlowSchemaCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x2a + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x22 + { + size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x12 + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *FlowSchemaList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FlowSchemaList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FlowSchemaList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *FlowSchemaSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FlowSchemaSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FlowSchemaSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Rules) > 0 { + for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Rules[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if m.DistinguisherMethod != nil { + { + size, err := m.DistinguisherMethod.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + i = encodeVarintGenerated(dAtA, i, uint64(m.MatchingPrecedence)) + i-- + dAtA[i] = 0x10 + { + size, err := m.PriorityLevelConfiguration.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *FlowSchemaStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FlowSchemaStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FlowSchemaStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Conditions) > 0 { + for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *GroupSubject) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GroupSubject) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GroupSubject) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *LimitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LimitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LimitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Queuing != nil { + { + size, err := m.Queuing.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *LimitedPriorityLevelConfiguration) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LimitedPriorityLevelConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LimitedPriorityLevelConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.LimitResponse.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i = encodeVarintGenerated(dAtA, i, uint64(m.AssuredConcurrencyShares)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *NonResourcePolicyRule) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *NonResourcePolicyRule) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NonResourcePolicyRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.NonResourceURLs) > 0 { + for iNdEx := len(m.NonResourceURLs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.NonResourceURLs[iNdEx]) + copy(dAtA[i:], m.NonResourceURLs[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.NonResourceURLs[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(m.Verbs) > 0 { + for iNdEx := len(m.Verbs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Verbs[iNdEx]) + copy(dAtA[i:], m.Verbs[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Verbs[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *PolicyRulesWithSubjects) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PolicyRulesWithSubjects) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PolicyRulesWithSubjects) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.NonResourceRules) > 0 { + for iNdEx := len(m.NonResourceRules) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.NonResourceRules[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.ResourceRules) > 0 { + for iNdEx := len(m.ResourceRules) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ResourceRules[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Subjects) > 0 { + for iNdEx := len(m.Subjects) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Subjects[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *PriorityLevelConfiguration) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PriorityLevelConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PriorityLevelConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PriorityLevelConfigurationCondition) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PriorityLevelConfigurationCondition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PriorityLevelConfigurationCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x2a + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x22 + { + size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x12 + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PriorityLevelConfigurationList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PriorityLevelConfigurationList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PriorityLevelConfigurationList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PriorityLevelConfigurationReference) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PriorityLevelConfigurationReference) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PriorityLevelConfigurationReference) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PriorityLevelConfigurationSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PriorityLevelConfigurationSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PriorityLevelConfigurationSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Limited != nil { + { + size, err := m.Limited.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *PriorityLevelConfigurationStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PriorityLevelConfigurationStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PriorityLevelConfigurationStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Conditions) > 0 { + for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueuingConfiguration) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueuingConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueuingConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i = encodeVarintGenerated(dAtA, i, uint64(m.QueueLengthLimit)) + i-- + dAtA[i] = 0x18 + i = encodeVarintGenerated(dAtA, i, uint64(m.HandSize)) + i-- + dAtA[i] = 0x10 + i = encodeVarintGenerated(dAtA, i, uint64(m.Queues)) + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *ResourcePolicyRule) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResourcePolicyRule) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResourcePolicyRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Namespaces) > 0 { + for iNdEx := len(m.Namespaces) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Namespaces[iNdEx]) + copy(dAtA[i:], m.Namespaces[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespaces[iNdEx]))) + i-- + dAtA[i] = 0x2a + } + } + i-- + if m.ClusterScope { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + if len(m.Resources) > 0 { + for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Resources[iNdEx]) + copy(dAtA[i:], m.Resources[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resources[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(m.APIGroups) > 0 { + for iNdEx := len(m.APIGroups) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.APIGroups[iNdEx]) + copy(dAtA[i:], m.APIGroups[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIGroups[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Verbs) > 0 { + for iNdEx := len(m.Verbs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Verbs[iNdEx]) + copy(dAtA[i:], m.Verbs[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Verbs[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ServiceAccountSubject) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServiceAccountSubject) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ServiceAccountSubject) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + i -= len(m.Namespace) + copy(dAtA[i:], m.Namespace) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Subject) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Subject) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Subject) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ServiceAccount != nil { + { + size, err := m.ServiceAccount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Group != nil { + { + size, err := m.Group.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.User != nil { + { + size, err := m.User.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.Kind) + copy(dAtA[i:], m.Kind) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *UserSubject) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserSubject) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UserSubject) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { + offset -= sovGenerated(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *FlowDistinguisherMethod) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *FlowSchema) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Status.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *FlowSchemaCondition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Status) + n += 1 + l + sovGenerated(uint64(l)) + l = m.LastTransitionTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Reason) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *FlowSchemaList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ListMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *FlowSchemaSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.PriorityLevelConfiguration.Size() + n += 1 + l + sovGenerated(uint64(l)) + n += 1 + sovGenerated(uint64(m.MatchingPrecedence)) + if m.DistinguisherMethod != nil { + l = m.DistinguisherMethod.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.Rules) > 0 { + for _, e := range m.Rules { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *FlowSchemaStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Conditions) > 0 { + for _, e := range m.Conditions { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *GroupSubject) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *LimitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + if m.Queuing != nil { + l = m.Queuing.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *LimitedPriorityLevelConfiguration) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.AssuredConcurrencyShares)) + l = m.LimitResponse.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *NonResourcePolicyRule) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Verbs) > 0 { + for _, s := range m.Verbs { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.NonResourceURLs) > 0 { + for _, s := range m.NonResourceURLs { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *PolicyRulesWithSubjects) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Subjects) > 0 { + for _, e := range m.Subjects { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.ResourceRules) > 0 { + for _, e := range m.ResourceRules { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.NonResourceRules) > 0 { + for _, e := range m.NonResourceRules { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *PriorityLevelConfiguration) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.Status.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *PriorityLevelConfigurationCondition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Status) + n += 1 + l + sovGenerated(uint64(l)) + l = m.LastTransitionTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Reason) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *PriorityLevelConfigurationList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ListMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *PriorityLevelConfigurationReference) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *PriorityLevelConfigurationSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + if m.Limited != nil { + l = m.Limited.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *PriorityLevelConfigurationStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Conditions) > 0 { + for _, e := range m.Conditions { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *QueuingConfiguration) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovGenerated(uint64(m.Queues)) + n += 1 + sovGenerated(uint64(m.HandSize)) + n += 1 + sovGenerated(uint64(m.QueueLengthLimit)) + return n +} + +func (m *ResourcePolicyRule) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Verbs) > 0 { + for _, s := range m.Verbs { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.APIGroups) > 0 { + for _, s := range m.APIGroups { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.Resources) > 0 { + for _, s := range m.Resources { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + n += 2 + if len(m.Namespaces) > 0 { + for _, s := range m.Namespaces { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *ServiceAccountSubject) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Namespace) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *Subject) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Kind) + n += 1 + l + sovGenerated(uint64(l)) + if m.User != nil { + l = m.User.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Group != nil { + l = m.Group.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.ServiceAccount != nil { + l = m.ServiceAccount.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *UserSubject) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func sovGenerated(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenerated(x uint64) (n int) { + return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *FlowDistinguisherMethod) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FlowDistinguisherMethod{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `}`, + }, "") + return s +} +func (this *FlowSchema) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FlowSchema{`, + `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "FlowSchemaSpec", "FlowSchemaSpec", 1), `&`, ``, 1) + `,`, + `Status:` + strings.Replace(strings.Replace(this.Status.String(), "FlowSchemaStatus", "FlowSchemaStatus", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *FlowSchemaCondition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FlowSchemaCondition{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Status:` + fmt.Sprintf("%v", this.Status) + `,`, + `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, + `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `}`, + }, "") + return s +} +func (this *FlowSchemaList) String() string { + if this == nil { + return "nil" + } + repeatedStringForItems := "[]FlowSchema{" + for _, f := range this.Items { + repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "FlowSchema", "FlowSchema", 1), `&`, ``, 1) + "," + } + repeatedStringForItems += "}" + s := strings.Join([]string{`&FlowSchemaList{`, + `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, + `Items:` + repeatedStringForItems + `,`, + `}`, + }, "") + return s +} +func (this *FlowSchemaSpec) String() string { + if this == nil { + return "nil" + } + repeatedStringForRules := "[]PolicyRulesWithSubjects{" + for _, f := range this.Rules { + repeatedStringForRules += strings.Replace(strings.Replace(f.String(), "PolicyRulesWithSubjects", "PolicyRulesWithSubjects", 1), `&`, ``, 1) + "," + } + repeatedStringForRules += "}" + s := strings.Join([]string{`&FlowSchemaSpec{`, + `PriorityLevelConfiguration:` + strings.Replace(strings.Replace(this.PriorityLevelConfiguration.String(), "PriorityLevelConfigurationReference", "PriorityLevelConfigurationReference", 1), `&`, ``, 1) + `,`, + `MatchingPrecedence:` + fmt.Sprintf("%v", this.MatchingPrecedence) + `,`, + `DistinguisherMethod:` + strings.Replace(this.DistinguisherMethod.String(), "FlowDistinguisherMethod", "FlowDistinguisherMethod", 1) + `,`, + `Rules:` + repeatedStringForRules + `,`, + `}`, + }, "") + return s +} +func (this *FlowSchemaStatus) String() string { + if this == nil { + return "nil" + } + repeatedStringForConditions := "[]FlowSchemaCondition{" + for _, f := range this.Conditions { + repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "FlowSchemaCondition", "FlowSchemaCondition", 1), `&`, ``, 1) + "," + } + repeatedStringForConditions += "}" + s := strings.Join([]string{`&FlowSchemaStatus{`, + `Conditions:` + repeatedStringForConditions + `,`, + `}`, + }, "") + return s +} +func (this *GroupSubject) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&GroupSubject{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} +func (this *LimitResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&LimitResponse{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Queuing:` + strings.Replace(this.Queuing.String(), "QueuingConfiguration", "QueuingConfiguration", 1) + `,`, + `}`, + }, "") + return s +} +func (this *LimitedPriorityLevelConfiguration) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&LimitedPriorityLevelConfiguration{`, + `AssuredConcurrencyShares:` + fmt.Sprintf("%v", this.AssuredConcurrencyShares) + `,`, + `LimitResponse:` + strings.Replace(strings.Replace(this.LimitResponse.String(), "LimitResponse", "LimitResponse", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *NonResourcePolicyRule) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NonResourcePolicyRule{`, + `Verbs:` + fmt.Sprintf("%v", this.Verbs) + `,`, + `NonResourceURLs:` + fmt.Sprintf("%v", this.NonResourceURLs) + `,`, + `}`, + }, "") + return s +} +func (this *PolicyRulesWithSubjects) String() string { + if this == nil { + return "nil" + } + repeatedStringForSubjects := "[]Subject{" + for _, f := range this.Subjects { + repeatedStringForSubjects += strings.Replace(strings.Replace(f.String(), "Subject", "Subject", 1), `&`, ``, 1) + "," + } + repeatedStringForSubjects += "}" + repeatedStringForResourceRules := "[]ResourcePolicyRule{" + for _, f := range this.ResourceRules { + repeatedStringForResourceRules += strings.Replace(strings.Replace(f.String(), "ResourcePolicyRule", "ResourcePolicyRule", 1), `&`, ``, 1) + "," + } + repeatedStringForResourceRules += "}" + repeatedStringForNonResourceRules := "[]NonResourcePolicyRule{" + for _, f := range this.NonResourceRules { + repeatedStringForNonResourceRules += strings.Replace(strings.Replace(f.String(), "NonResourcePolicyRule", "NonResourcePolicyRule", 1), `&`, ``, 1) + "," + } + repeatedStringForNonResourceRules += "}" + s := strings.Join([]string{`&PolicyRulesWithSubjects{`, + `Subjects:` + repeatedStringForSubjects + `,`, + `ResourceRules:` + repeatedStringForResourceRules + `,`, + `NonResourceRules:` + repeatedStringForNonResourceRules + `,`, + `}`, + }, "") + return s +} +func (this *PriorityLevelConfiguration) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PriorityLevelConfiguration{`, + `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PriorityLevelConfigurationSpec", "PriorityLevelConfigurationSpec", 1), `&`, ``, 1) + `,`, + `Status:` + strings.Replace(strings.Replace(this.Status.String(), "PriorityLevelConfigurationStatus", "PriorityLevelConfigurationStatus", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *PriorityLevelConfigurationCondition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PriorityLevelConfigurationCondition{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Status:` + fmt.Sprintf("%v", this.Status) + `,`, + `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, + `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `}`, + }, "") + return s +} +func (this *PriorityLevelConfigurationList) String() string { + if this == nil { + return "nil" + } + repeatedStringForItems := "[]PriorityLevelConfiguration{" + for _, f := range this.Items { + repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "PriorityLevelConfiguration", "PriorityLevelConfiguration", 1), `&`, ``, 1) + "," + } + repeatedStringForItems += "}" + s := strings.Join([]string{`&PriorityLevelConfigurationList{`, + `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, + `Items:` + repeatedStringForItems + `,`, + `}`, + }, "") + return s +} +func (this *PriorityLevelConfigurationReference) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PriorityLevelConfigurationReference{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} +func (this *PriorityLevelConfigurationSpec) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PriorityLevelConfigurationSpec{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Limited:` + strings.Replace(this.Limited.String(), "LimitedPriorityLevelConfiguration", "LimitedPriorityLevelConfiguration", 1) + `,`, + `}`, + }, "") + return s +} +func (this *PriorityLevelConfigurationStatus) String() string { + if this == nil { + return "nil" + } + repeatedStringForConditions := "[]PriorityLevelConfigurationCondition{" + for _, f := range this.Conditions { + repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "PriorityLevelConfigurationCondition", "PriorityLevelConfigurationCondition", 1), `&`, ``, 1) + "," + } + repeatedStringForConditions += "}" + s := strings.Join([]string{`&PriorityLevelConfigurationStatus{`, + `Conditions:` + repeatedStringForConditions + `,`, + `}`, + }, "") + return s +} +func (this *QueuingConfiguration) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&QueuingConfiguration{`, + `Queues:` + fmt.Sprintf("%v", this.Queues) + `,`, + `HandSize:` + fmt.Sprintf("%v", this.HandSize) + `,`, + `QueueLengthLimit:` + fmt.Sprintf("%v", this.QueueLengthLimit) + `,`, + `}`, + }, "") + return s +} +func (this *ResourcePolicyRule) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ResourcePolicyRule{`, + `Verbs:` + fmt.Sprintf("%v", this.Verbs) + `,`, + `APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`, + `Resources:` + fmt.Sprintf("%v", this.Resources) + `,`, + `ClusterScope:` + fmt.Sprintf("%v", this.ClusterScope) + `,`, + `Namespaces:` + fmt.Sprintf("%v", this.Namespaces) + `,`, + `}`, + }, "") + return s +} +func (this *ServiceAccountSubject) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ServiceAccountSubject{`, + `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} +func (this *Subject) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subject{`, + `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, + `User:` + strings.Replace(this.User.String(), "UserSubject", "UserSubject", 1) + `,`, + `Group:` + strings.Replace(this.Group.String(), "GroupSubject", "GroupSubject", 1) + `,`, + `ServiceAccount:` + strings.Replace(this.ServiceAccount.String(), "ServiceAccountSubject", "ServiceAccountSubject", 1) + `,`, + `}`, + }, "") + return s +} +func (this *UserSubject) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UserSubject{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} +func valueToStringGenerated(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *FlowDistinguisherMethod) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FlowDistinguisherMethod: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FlowDistinguisherMethod: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = FlowDistinguisherMethodType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FlowSchema) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FlowSchema: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FlowSchema: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FlowSchemaCondition) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FlowSchemaCondition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FlowSchemaCondition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = FlowSchemaConditionType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = ConditionStatus(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FlowSchemaList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FlowSchemaList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FlowSchemaList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, FlowSchema{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FlowSchemaSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FlowSchemaSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FlowSchemaSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PriorityLevelConfiguration", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.PriorityLevelConfiguration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MatchingPrecedence", wireType) + } + m.MatchingPrecedence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MatchingPrecedence |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DistinguisherMethod", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DistinguisherMethod == nil { + m.DistinguisherMethod = &FlowDistinguisherMethod{} + } + if err := m.DistinguisherMethod.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rules = append(m.Rules, PolicyRulesWithSubjects{}) + if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FlowSchemaStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FlowSchemaStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FlowSchemaStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Conditions = append(m.Conditions, FlowSchemaCondition{}) + if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GroupSubject) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GroupSubject: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GroupSubject: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LimitResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LimitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LimitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = LimitResponseType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Queuing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Queuing == nil { + m.Queuing = &QueuingConfiguration{} + } + if err := m.Queuing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LimitedPriorityLevelConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LimitedPriorityLevelConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LimitedPriorityLevelConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AssuredConcurrencyShares", wireType) + } + m.AssuredConcurrencyShares = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AssuredConcurrencyShares |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LimitResponse", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LimitResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NonResourcePolicyRule) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NonResourcePolicyRule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NonResourcePolicyRule: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Verbs = append(m.Verbs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NonResourceURLs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NonResourceURLs = append(m.NonResourceURLs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PolicyRulesWithSubjects) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PolicyRulesWithSubjects: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PolicyRulesWithSubjects: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Subjects", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Subjects = append(m.Subjects, Subject{}) + if err := m.Subjects[len(m.Subjects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResourceRules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ResourceRules = append(m.ResourceRules, ResourcePolicyRule{}) + if err := m.ResourceRules[len(m.ResourceRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NonResourceRules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NonResourceRules = append(m.NonResourceRules, NonResourcePolicyRule{}) + if err := m.NonResourceRules[len(m.NonResourceRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PriorityLevelConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PriorityLevelConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PriorityLevelConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PriorityLevelConfigurationCondition) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PriorityLevelConfigurationCondition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PriorityLevelConfigurationCondition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = PriorityLevelConfigurationConditionType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = ConditionStatus(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PriorityLevelConfigurationList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PriorityLevelConfigurationList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PriorityLevelConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, PriorityLevelConfiguration{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PriorityLevelConfigurationReference) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PriorityLevelConfigurationReference: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PriorityLevelConfigurationReference: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PriorityLevelConfigurationSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PriorityLevelConfigurationSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PriorityLevelConfigurationSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = PriorityLevelEnablement(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Limited", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Limited == nil { + m.Limited = &LimitedPriorityLevelConfiguration{} + } + if err := m.Limited.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PriorityLevelConfigurationStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PriorityLevelConfigurationStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PriorityLevelConfigurationStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Conditions = append(m.Conditions, PriorityLevelConfigurationCondition{}) + if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueuingConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueuingConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueuingConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Queues", wireType) + } + m.Queues = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Queues |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HandSize", wireType) + } + m.HandSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.HandSize |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field QueueLengthLimit", wireType) + } + m.QueueLengthLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.QueueLengthLimit |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResourcePolicyRule) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResourcePolicyRule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResourcePolicyRule: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Verbs = append(m.Verbs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterScope", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ClusterScope = bool(v != 0) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Namespaces", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Namespaces = append(m.Namespaces, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServiceAccountSubject) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServiceAccountSubject: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServiceAccountSubject: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Namespace = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Subject) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Subject: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Subject: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Kind = SubjectKind(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.User == nil { + m.User = &UserSubject{} + } + if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Group == nil { + m.Group = &GroupSubject{} + } + if err := m.Group.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServiceAccount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ServiceAccount == nil { + m.ServiceAccount = &ServiceAccountSubject{} + } + if err := m.ServiceAccount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserSubject) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UserSubject: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserSubject: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenerated(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenerated + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenerated + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenerated + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group") +) diff --git a/vendor/k8s.io/api/flowcontrol/v1beta2/generated.proto b/vendor/k8s.io/api/flowcontrol/v1beta2/generated.proto new file mode 100644 index 0000000000..7e367b47c8 --- /dev/null +++ b/vendor/k8s.io/api/flowcontrol/v1beta2/generated.proto @@ -0,0 +1,440 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + + +// This file was autogenerated by go-to-protobuf. Do not edit it manually! + +syntax = "proto2"; + +package k8s.io.api.flowcontrol.v1beta2; + +import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; +import "k8s.io/apimachinery/pkg/runtime/generated.proto"; +import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; + +// Package-wide variables from generator "generated". +option go_package = "v1beta2"; + +// FlowDistinguisherMethod specifies the method of a flow distinguisher. +message FlowDistinguisherMethod { + // `type` is the type of flow distinguisher method + // The supported types are "ByUser" and "ByNamespace". + // Required. + optional string type = 1; +} + +// FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with +// similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". +message FlowSchema { + // `metadata` is the standard object's metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + + // `spec` is the specification of the desired behavior of a FlowSchema. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + // +optional + optional FlowSchemaSpec spec = 2; + + // `status` is the current status of a FlowSchema. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + // +optional + optional FlowSchemaStatus status = 3; +} + +// FlowSchemaCondition describes conditions for a FlowSchema. +message FlowSchemaCondition { + // `type` is the type of the condition. + // Required. + optional string type = 1; + + // `status` is the status of the condition. + // Can be True, False, Unknown. + // Required. + optional string status = 2; + + // `lastTransitionTime` is the last time the condition transitioned from one status to another. + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 3; + + // `reason` is a unique, one-word, CamelCase reason for the condition's last transition. + optional string reason = 4; + + // `message` is a human-readable message indicating details about last transition. + optional string message = 5; +} + +// FlowSchemaList is a list of FlowSchema objects. +message FlowSchemaList { + // `metadata` is the standard list metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + + // `items` is a list of FlowSchemas. + repeated FlowSchema items = 2; +} + +// FlowSchemaSpec describes how the FlowSchema's specification looks like. +message FlowSchemaSpec { + // `priorityLevelConfiguration` should reference a PriorityLevelConfiguration in the cluster. If the reference cannot + // be resolved, the FlowSchema will be ignored and marked as invalid in its status. + // Required. + optional PriorityLevelConfigurationReference priorityLevelConfiguration = 1; + + // `matchingPrecedence` is used to choose among the FlowSchemas that match a given request. The chosen + // FlowSchema is among those with the numerically lowest (which we take to be logically highest) + // MatchingPrecedence. Each MatchingPrecedence value must be ranged in [1,10000]. + // Note that if the precedence is not specified, it will be set to 1000 as default. + // +optional + optional int32 matchingPrecedence = 2; + + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. + // `nil` specifies that the distinguisher is disabled and thus will always be the empty string. + // +optional + optional FlowDistinguisherMethod distinguisherMethod = 3; + + // `rules` describes which requests will match this flow schema. This FlowSchema matches a request if and only if + // at least one member of rules matches the request. + // if it is an empty slice, there will be no requests matching the FlowSchema. + // +listType=atomic + // +optional + repeated PolicyRulesWithSubjects rules = 4; +} + +// FlowSchemaStatus represents the current state of a FlowSchema. +message FlowSchemaStatus { + // `conditions` is a list of the current states of FlowSchema. + // +listType=map + // +listMapKey=type + // +optional + repeated FlowSchemaCondition conditions = 1; +} + +// GroupSubject holds detailed information for group-kind subject. +message GroupSubject { + // name is the user group that matches, or "*" to match all user groups. + // See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some + // well-known group names. + // Required. + optional string name = 1; +} + +// LimitResponse defines how to handle requests that can not be executed right now. +// +union +message LimitResponse { + // `type` is "Queue" or "Reject". + // "Queue" means that requests that can not be executed upon arrival + // are held in a queue until they can be executed or a queuing limit + // is reached. + // "Reject" means that requests that can not be executed upon arrival + // are rejected. + // Required. + // +unionDiscriminator + optional string type = 1; + + // `queuing` holds the configuration parameters for queuing. + // This field may be non-empty only if `type` is `"Queue"`. + // +optional + optional QueuingConfiguration queuing = 2; +} + +// LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. +// It addresses two issues: +// * How are requests for this priority level limited? +// * What should be done with requests that exceed the limit? +message LimitedPriorityLevelConfiguration { + // `assuredConcurrencyShares` (ACS) configures the execution + // limit, which is a limit on the number of requests of this + // priority level that may be exeucting at a given time. ACS must + // be a positive number. The server's concurrency limit (SCL) is + // divided among the concurrency-controlled priority levels in + // proportion to their assured concurrency shares. This produces + // the assured concurrency value (ACV) --- the number of requests + // that may be executing at a time --- for each such priority + // level: + // + // ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) + // + // bigger numbers of ACS mean more reserved concurrent requests (at the + // expense of every other PL). + // This field has a default value of 30. + // +optional + optional int32 assuredConcurrencyShares = 1; + + // `limitResponse` indicates what to do with requests that can not be executed right now + optional LimitResponse limitResponse = 2; +} + +// NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the +// target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member +// of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. +message NonResourcePolicyRule { + // `verbs` is a list of matching verbs and may not be empty. + // "*" matches all verbs. If it is present, it must be the only entry. + // +listType=set + // Required. + repeated string verbs = 1; + + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. + // For example: + // - "/healthz" is legal + // - "/hea*" is illegal + // - "/hea" is legal but matches nothing + // - "/hea/*" also matches nothing + // - "/healthz/*" matches all per-component health checks. + // "*" matches all non-resource urls. if it is present, it must be the only entry. + // +listType=set + // Required. + repeated string nonResourceURLs = 6; +} + +// PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject +// making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches +// a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member +// of resourceRules or nonResourceRules matches the request. +message PolicyRulesWithSubjects { + // subjects is the list of normal user, serviceaccount, or group that this rule cares about. + // There must be at least one member in this slice. + // A slice that includes both the system:authenticated and system:unauthenticated user groups matches every request. + // +listType=atomic + // Required. + repeated Subject subjects = 1; + + // `resourceRules` is a slice of ResourcePolicyRules that identify matching requests according to their verb and the + // target resource. + // At least one of `resourceRules` and `nonResourceRules` has to be non-empty. + // +listType=atomic + // +optional + repeated ResourcePolicyRule resourceRules = 2; + + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb + // and the target non-resource URL. + // +listType=atomic + // +optional + repeated NonResourcePolicyRule nonResourceRules = 3; +} + +// PriorityLevelConfiguration represents the configuration of a priority level. +message PriorityLevelConfiguration { + // `metadata` is the standard object's metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + + // `spec` is the specification of the desired behavior of a "request-priority". + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + // +optional + optional PriorityLevelConfigurationSpec spec = 2; + + // `status` is the current status of a "request-priority". + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + // +optional + optional PriorityLevelConfigurationStatus status = 3; +} + +// PriorityLevelConfigurationCondition defines the condition of priority level. +message PriorityLevelConfigurationCondition { + // `type` is the type of the condition. + // Required. + optional string type = 1; + + // `status` is the status of the condition. + // Can be True, False, Unknown. + // Required. + optional string status = 2; + + // `lastTransitionTime` is the last time the condition transitioned from one status to another. + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 3; + + // `reason` is a unique, one-word, CamelCase reason for the condition's last transition. + optional string reason = 4; + + // `message` is a human-readable message indicating details about last transition. + optional string message = 5; +} + +// PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. +message PriorityLevelConfigurationList { + // `metadata` is the standard object's metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + + // `items` is a list of request-priorities. + repeated PriorityLevelConfiguration items = 2; +} + +// PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. +message PriorityLevelConfigurationReference { + // `name` is the name of the priority level configuration being referenced + // Required. + optional string name = 1; +} + +// PriorityLevelConfigurationSpec specifies the configuration of a priority level. +// +union +message PriorityLevelConfigurationSpec { + // `type` indicates whether this priority level is subject to + // limitation on request execution. A value of `"Exempt"` means + // that requests of this priority level are not subject to a limit + // (and thus are never queued) and do not detract from the + // capacity made available to other priority levels. A value of + // `"Limited"` means that (a) requests of this priority level + // _are_ subject to limits and (b) some of the server's limited + // capacity is made available exclusively to this priority level. + // Required. + // +unionDiscriminator + optional string type = 1; + + // `limited` specifies how requests are handled for a Limited priority level. + // This field must be non-empty if and only if `type` is `"Limited"`. + // +optional + optional LimitedPriorityLevelConfiguration limited = 2; +} + +// PriorityLevelConfigurationStatus represents the current state of a "request-priority". +message PriorityLevelConfigurationStatus { + // `conditions` is the current state of "request-priority". + // +listType=map + // +listMapKey=type + // +optional + repeated PriorityLevelConfigurationCondition conditions = 1; +} + +// QueuingConfiguration holds the configuration parameters for queuing +message QueuingConfiguration { + // `queues` is the number of queues for this priority level. The + // queues exist independently at each apiserver. The value must be + // positive. Setting it to 1 effectively precludes + // shufflesharding and thus makes the distinguisher method of + // associated flow schemas irrelevant. This field has a default + // value of 64. + // +optional + optional int32 queues = 1; + + // `handSize` is a small positive number that configures the + // shuffle sharding of requests into queues. When enqueuing a request + // at this priority level the request's flow identifier (a string + // pair) is hashed and the hash value is used to shuffle the list + // of queues and deal a hand of the size specified here. The + // request is put into one of the shortest queues in that hand. + // `handSize` must be no larger than `queues`, and should be + // significantly smaller (so that a few heavy flows do not + // saturate most of the queues). See the user-facing + // documentation for more extensive guidance on setting this + // field. This field has a default value of 8. + // +optional + optional int32 handSize = 2; + + // `queueLengthLimit` is the maximum number of requests allowed to + // be waiting in a given queue of this priority level at a time; + // excess requests are rejected. This value must be positive. If + // not specified, it will be defaulted to 50. + // +optional + optional int32 queueLengthLimit = 3; +} + +// ResourcePolicyRule is a predicate that matches some resource +// requests, testing the request's verb and the target resource. A +// ResourcePolicyRule matches a resource request if and only if: (a) +// at least one member of verbs matches the request, (b) at least one +// member of apiGroups matches the request, (c) at least one member of +// resources matches the request, and (d) either (d1) the request does +// not specify a namespace (i.e., `Namespace==""`) and clusterScope is +// true or (d2) the request specifies a namespace and least one member +// of namespaces matches the request's namespace. +message ResourcePolicyRule { + // `verbs` is a list of matching verbs and may not be empty. + // "*" matches all verbs and, if present, must be the only entry. + // +listType=set + // Required. + repeated string verbs = 1; + + // `apiGroups` is a list of matching API groups and may not be empty. + // "*" matches all API groups and, if present, must be the only entry. + // +listType=set + // Required. + repeated string apiGroups = 2; + + // `resources` is a list of matching resources (i.e., lowercase + // and plural) with, if desired, subresource. For example, [ + // "services", "nodes/status" ]. This list may not be empty. + // "*" matches all resources and, if present, must be the only entry. + // Required. + // +listType=set + repeated string resources = 3; + + // `clusterScope` indicates whether to match requests that do not + // specify a namespace (which happens either because the resource + // is not namespaced or the request targets all namespaces). + // If this field is omitted or false then the `namespaces` field + // must contain a non-empty list. + // +optional + optional bool clusterScope = 4; + + // `namespaces` is a list of target namespaces that restricts + // matches. A request that specifies a target namespace matches + // only if either (a) this list contains that target namespace or + // (b) this list contains "*". Note that "*" matches any + // specified namespace but does not match a request that _does + // not specify_ a namespace (see the `clusterScope` field for + // that). + // This list may be empty, but only if `clusterScope` is true. + // +optional + // +listType=set + repeated string namespaces = 5; +} + +// ServiceAccountSubject holds detailed information for service-account-kind subject. +message ServiceAccountSubject { + // `namespace` is the namespace of matching ServiceAccount objects. + // Required. + optional string namespace = 1; + + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. + // Required. + optional string name = 2; +} + +// Subject matches the originator of a request, as identified by the request authentication system. There are three +// ways of matching an originator; by user, group, or service account. +// +union +message Subject { + // `kind` indicates which one of the other fields is non-empty. + // Required + // +unionDiscriminator + optional string kind = 1; + + // `user` matches based on username. + // +optional + optional UserSubject user = 2; + + // `group` matches based on user group name. + // +optional + optional GroupSubject group = 3; + + // `serviceAccount` matches ServiceAccounts. + // +optional + optional ServiceAccountSubject serviceAccount = 4; +} + +// UserSubject holds detailed information for user-kind subject. +message UserSubject { + // `name` is the username that matches, or "*" to match all usernames. + // Required. + optional string name = 1; +} + diff --git a/vendor/k8s.io/api/flowcontrol/v1beta2/register.go b/vendor/k8s.io/api/flowcontrol/v1beta2/register.go new file mode 100644 index 0000000000..0ffe55133f --- /dev/null +++ b/vendor/k8s.io/api/flowcontrol/v1beta2/register.go @@ -0,0 +1,58 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta2 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +// GroupName is the name of api group +const GroupName = "flowcontrol.apiserver.k8s.io" + +// SchemeGroupVersion is group version used to register these objects +var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta2"} + +// Kind takes an unqualified kind and returns a Group qualified GroupKind +func Kind(kind string) schema.GroupKind { + return SchemeGroupVersion.WithKind(kind).GroupKind() +} + +// Resource takes an unqualified resource and returns a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +var ( + // SchemeBuilder installs the api group to a scheme + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + // AddToScheme adds api to a scheme + AddToScheme = SchemeBuilder.AddToScheme +) + +// Adds the list of known types to the given scheme. +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &FlowSchema{}, + &FlowSchemaList{}, + &PriorityLevelConfiguration{}, + &PriorityLevelConfigurationList{}, + ) + metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/vendor/k8s.io/api/flowcontrol/v1beta2/types.go b/vendor/k8s.io/api/flowcontrol/v1beta2/types.go new file mode 100644 index 0000000000..408681e998 --- /dev/null +++ b/vendor/k8s.io/api/flowcontrol/v1beta2/types.go @@ -0,0 +1,579 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta2 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// These are valid wildcards. +const ( + APIGroupAll = "*" + ResourceAll = "*" + VerbAll = "*" + NonResourceAll = "*" + NameAll = "*" + + NamespaceEvery = "*" // matches every particular namespace +) + +// System preset priority level names +const ( + PriorityLevelConfigurationNameExempt = "exempt" + PriorityLevelConfigurationNameCatchAll = "catch-all" + FlowSchemaNameExempt = "exempt" + FlowSchemaNameCatchAll = "catch-all" +) + +// Conditions +const ( + FlowSchemaConditionDangling = "Dangling" + + PriorityLevelConfigurationConditionConcurrencyShared = "ConcurrencyShared" +) + +// Constants used by api validation. +const ( + FlowSchemaMaxMatchingPrecedence int32 = 10000 +) + +// Constants for apiserver response headers. +const ( + ResponseHeaderMatchedPriorityLevelConfigurationUID = "X-Kubernetes-PF-PriorityLevel-UID" + ResponseHeaderMatchedFlowSchemaUID = "X-Kubernetes-PF-FlowSchema-UID" +) + +const ( + // AutoUpdateAnnotationKey is the name of an annotation that enables + // automatic update of the spec of the bootstrap configuration + // object(s), if set to 'true'. + // + // On a fresh install, all bootstrap configuration objects will have auto + // update enabled with the following annotation key: + // apf.kubernetes.io/autoupdate-spec: 'true' + // + // The kube-apiserver periodically checks the bootstrap configuration + // objects on the cluster and applies updates if necessary. + // + // kube-apiserver enforces an 'always auto-update' policy for the + // mandatory configuration object(s). This implies: + // - the auto-update annotation key is added with a value of 'true' + // if it is missing. + // - the auto-update annotation key is set to 'true' if its current value + // is a boolean false or has an invalid boolean representation + // (if the cluster operator sets it to 'false' it will be stomped) + // - any changes to the spec made by the cluster operator will be + // stomped. + // + // The kube-apiserver will apply updates on the suggested configuration if: + // - the cluster operator has enabled auto-update by setting the annotation + // (apf.kubernetes.io/autoupdate-spec: 'true') or + // - the annotation key is missing but the generation is 1 + // + // If the suggested configuration object is missing the annotation key, + // kube-apiserver will update the annotation appropriately: + // - it is set to 'true' if generation of the object is '1' which usually + // indicates that the spec of the object has not been changed. + // - it is set to 'false' if generation of the object is greater than 1. + // + // The goal is to enable the kube-apiserver to apply update on suggested + // configuration objects installed by previous releases but not overwrite + // changes made by the cluster operators. + // Note that this distinction is imperfectly detected: in the case where an + // operator deletes a suggested configuration object and later creates it + // but with a variant spec and then does no updates of the object + // (generation is 1), the technique outlined above will incorrectly + // determine that the object should be auto-updated. + AutoUpdateAnnotationKey = "apf.kubernetes.io/autoupdate-spec" +) + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:prerelease-lifecycle-gen:introduced=1.23 + +// FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with +// similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". +type FlowSchema struct { + metav1.TypeMeta `json:",inline"` + // `metadata` is the standard object's metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + // `spec` is the specification of the desired behavior of a FlowSchema. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + // +optional + Spec FlowSchemaSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` + // `status` is the current status of a FlowSchema. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + // +optional + Status FlowSchemaStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:prerelease-lifecycle-gen:introduced=1.23 + +// FlowSchemaList is a list of FlowSchema objects. +type FlowSchemaList struct { + metav1.TypeMeta `json:",inline"` + // `metadata` is the standard list metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // `items` is a list of FlowSchemas. + Items []FlowSchema `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// FlowSchemaSpec describes how the FlowSchema's specification looks like. +type FlowSchemaSpec struct { + // `priorityLevelConfiguration` should reference a PriorityLevelConfiguration in the cluster. If the reference cannot + // be resolved, the FlowSchema will be ignored and marked as invalid in its status. + // Required. + PriorityLevelConfiguration PriorityLevelConfigurationReference `json:"priorityLevelConfiguration" protobuf:"bytes,1,opt,name=priorityLevelConfiguration"` + // `matchingPrecedence` is used to choose among the FlowSchemas that match a given request. The chosen + // FlowSchema is among those with the numerically lowest (which we take to be logically highest) + // MatchingPrecedence. Each MatchingPrecedence value must be ranged in [1,10000]. + // Note that if the precedence is not specified, it will be set to 1000 as default. + // +optional + MatchingPrecedence int32 `json:"matchingPrecedence" protobuf:"varint,2,opt,name=matchingPrecedence"` + // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. + // `nil` specifies that the distinguisher is disabled and thus will always be the empty string. + // +optional + DistinguisherMethod *FlowDistinguisherMethod `json:"distinguisherMethod,omitempty" protobuf:"bytes,3,opt,name=distinguisherMethod"` + // `rules` describes which requests will match this flow schema. This FlowSchema matches a request if and only if + // at least one member of rules matches the request. + // if it is an empty slice, there will be no requests matching the FlowSchema. + // +listType=atomic + // +optional + Rules []PolicyRulesWithSubjects `json:"rules,omitempty" protobuf:"bytes,4,rep,name=rules"` +} + +// FlowDistinguisherMethodType is the type of flow distinguisher method +type FlowDistinguisherMethodType string + +// These are valid flow-distinguisher methods. +const ( + // FlowDistinguisherMethodByUserType specifies that the flow distinguisher is the username in the request. + // This type is used to provide some insulation between users. + FlowDistinguisherMethodByUserType FlowDistinguisherMethodType = "ByUser" + + // FlowDistinguisherMethodByNamespaceType specifies that the flow distinguisher is the namespace of the + // object that the request acts upon. If the object is not namespaced, or if the request is a non-resource + // request, then the distinguisher will be the empty string. An example usage of this type is to provide + // some insulation between tenants in a situation where there are multiple tenants and each namespace + // is dedicated to a tenant. + FlowDistinguisherMethodByNamespaceType FlowDistinguisherMethodType = "ByNamespace" +) + +// FlowDistinguisherMethod specifies the method of a flow distinguisher. +type FlowDistinguisherMethod struct { + // `type` is the type of flow distinguisher method + // The supported types are "ByUser" and "ByNamespace". + // Required. + Type FlowDistinguisherMethodType `json:"type" protobuf:"bytes,1,opt,name=type"` +} + +// PriorityLevelConfigurationReference contains information that points to the "request-priority" being used. +type PriorityLevelConfigurationReference struct { + // `name` is the name of the priority level configuration being referenced + // Required. + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` +} + +// PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject +// making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches +// a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member +// of resourceRules or nonResourceRules matches the request. +type PolicyRulesWithSubjects struct { + // subjects is the list of normal user, serviceaccount, or group that this rule cares about. + // There must be at least one member in this slice. + // A slice that includes both the system:authenticated and system:unauthenticated user groups matches every request. + // +listType=atomic + // Required. + Subjects []Subject `json:"subjects" protobuf:"bytes,1,rep,name=subjects"` + // `resourceRules` is a slice of ResourcePolicyRules that identify matching requests according to their verb and the + // target resource. + // At least one of `resourceRules` and `nonResourceRules` has to be non-empty. + // +listType=atomic + // +optional + ResourceRules []ResourcePolicyRule `json:"resourceRules,omitempty" protobuf:"bytes,2,opt,name=resourceRules"` + // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb + // and the target non-resource URL. + // +listType=atomic + // +optional + NonResourceRules []NonResourcePolicyRule `json:"nonResourceRules,omitempty" protobuf:"bytes,3,opt,name=nonResourceRules"` +} + +// Subject matches the originator of a request, as identified by the request authentication system. There are three +// ways of matching an originator; by user, group, or service account. +// +union +type Subject struct { + // `kind` indicates which one of the other fields is non-empty. + // Required + // +unionDiscriminator + Kind SubjectKind `json:"kind" protobuf:"bytes,1,opt,name=kind"` + // `user` matches based on username. + // +optional + User *UserSubject `json:"user,omitempty" protobuf:"bytes,2,opt,name=user"` + // `group` matches based on user group name. + // +optional + Group *GroupSubject `json:"group,omitempty" protobuf:"bytes,3,opt,name=group"` + // `serviceAccount` matches ServiceAccounts. + // +optional + ServiceAccount *ServiceAccountSubject `json:"serviceAccount,omitempty" protobuf:"bytes,4,opt,name=serviceAccount"` +} + +// SubjectKind is the kind of subject. +type SubjectKind string + +// Supported subject's kinds. +const ( + SubjectKindUser SubjectKind = "User" + SubjectKindGroup SubjectKind = "Group" + SubjectKindServiceAccount SubjectKind = "ServiceAccount" +) + +// UserSubject holds detailed information for user-kind subject. +type UserSubject struct { + // `name` is the username that matches, or "*" to match all usernames. + // Required. + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` +} + +// GroupSubject holds detailed information for group-kind subject. +type GroupSubject struct { + // name is the user group that matches, or "*" to match all user groups. + // See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some + // well-known group names. + // Required. + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` +} + +// ServiceAccountSubject holds detailed information for service-account-kind subject. +type ServiceAccountSubject struct { + // `namespace` is the namespace of matching ServiceAccount objects. + // Required. + Namespace string `json:"namespace" protobuf:"bytes,1,opt,name=namespace"` + // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. + // Required. + Name string `json:"name" protobuf:"bytes,2,opt,name=name"` +} + +// ResourcePolicyRule is a predicate that matches some resource +// requests, testing the request's verb and the target resource. A +// ResourcePolicyRule matches a resource request if and only if: (a) +// at least one member of verbs matches the request, (b) at least one +// member of apiGroups matches the request, (c) at least one member of +// resources matches the request, and (d) either (d1) the request does +// not specify a namespace (i.e., `Namespace==""`) and clusterScope is +// true or (d2) the request specifies a namespace and least one member +// of namespaces matches the request's namespace. +type ResourcePolicyRule struct { + // `verbs` is a list of matching verbs and may not be empty. + // "*" matches all verbs and, if present, must be the only entry. + // +listType=set + // Required. + Verbs []string `json:"verbs" protobuf:"bytes,1,rep,name=verbs"` + + // `apiGroups` is a list of matching API groups and may not be empty. + // "*" matches all API groups and, if present, must be the only entry. + // +listType=set + // Required. + APIGroups []string `json:"apiGroups" protobuf:"bytes,2,rep,name=apiGroups"` + + // `resources` is a list of matching resources (i.e., lowercase + // and plural) with, if desired, subresource. For example, [ + // "services", "nodes/status" ]. This list may not be empty. + // "*" matches all resources and, if present, must be the only entry. + // Required. + // +listType=set + Resources []string `json:"resources" protobuf:"bytes,3,rep,name=resources"` + + // `clusterScope` indicates whether to match requests that do not + // specify a namespace (which happens either because the resource + // is not namespaced or the request targets all namespaces). + // If this field is omitted or false then the `namespaces` field + // must contain a non-empty list. + // +optional + ClusterScope bool `json:"clusterScope,omitempty" protobuf:"varint,4,opt,name=clusterScope"` + + // `namespaces` is a list of target namespaces that restricts + // matches. A request that specifies a target namespace matches + // only if either (a) this list contains that target namespace or + // (b) this list contains "*". Note that "*" matches any + // specified namespace but does not match a request that _does + // not specify_ a namespace (see the `clusterScope` field for + // that). + // This list may be empty, but only if `clusterScope` is true. + // +optional + // +listType=set + Namespaces []string `json:"namespaces" protobuf:"bytes,5,rep,name=namespaces"` +} + +// NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the +// target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member +// of verbs matches the request and (b) at least one member of nonResourceURLs matches the request. +type NonResourcePolicyRule struct { + // `verbs` is a list of matching verbs and may not be empty. + // "*" matches all verbs. If it is present, it must be the only entry. + // +listType=set + // Required. + Verbs []string `json:"verbs" protobuf:"bytes,1,rep,name=verbs"` + // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. + // For example: + // - "/healthz" is legal + // - "/hea*" is illegal + // - "/hea" is legal but matches nothing + // - "/hea/*" also matches nothing + // - "/healthz/*" matches all per-component health checks. + // "*" matches all non-resource urls. if it is present, it must be the only entry. + // +listType=set + // Required. + NonResourceURLs []string `json:"nonResourceURLs" protobuf:"bytes,6,rep,name=nonResourceURLs"` +} + +// FlowSchemaStatus represents the current state of a FlowSchema. +type FlowSchemaStatus struct { + // `conditions` is a list of the current states of FlowSchema. + // +listType=map + // +listMapKey=type + // +optional + Conditions []FlowSchemaCondition `json:"conditions,omitempty" protobuf:"bytes,1,rep,name=conditions"` +} + +// FlowSchemaCondition describes conditions for a FlowSchema. +type FlowSchemaCondition struct { + // `type` is the type of the condition. + // Required. + Type FlowSchemaConditionType `json:"type,omitempty" protobuf:"bytes,1,opt,name=type"` + // `status` is the status of the condition. + // Can be True, False, Unknown. + // Required. + Status ConditionStatus `json:"status,omitempty" protobuf:"bytes,2,opt,name=status"` + // `lastTransitionTime` is the last time the condition transitioned from one status to another. + LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,3,opt,name=lastTransitionTime"` + // `reason` is a unique, one-word, CamelCase reason for the condition's last transition. + Reason string `json:"reason,omitempty" protobuf:"bytes,4,opt,name=reason"` + // `message` is a human-readable message indicating details about last transition. + Message string `json:"message,omitempty" protobuf:"bytes,5,opt,name=message"` +} + +// FlowSchemaConditionType is a valid value for FlowSchemaStatusCondition.Type +type FlowSchemaConditionType string + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:prerelease-lifecycle-gen:introduced=1.23 + +// PriorityLevelConfiguration represents the configuration of a priority level. +type PriorityLevelConfiguration struct { + metav1.TypeMeta `json:",inline"` + // `metadata` is the standard object's metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + // `spec` is the specification of the desired behavior of a "request-priority". + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + // +optional + Spec PriorityLevelConfigurationSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` + // `status` is the current status of a "request-priority". + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + // +optional + Status PriorityLevelConfigurationStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:prerelease-lifecycle-gen:introduced=1.23 + +// PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects. +type PriorityLevelConfigurationList struct { + metav1.TypeMeta `json:",inline"` + // `metadata` is the standard object's metadata. + // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + // +optional + metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + // `items` is a list of request-priorities. + Items []PriorityLevelConfiguration `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// PriorityLevelConfigurationSpec specifies the configuration of a priority level. +// +union +type PriorityLevelConfigurationSpec struct { + // `type` indicates whether this priority level is subject to + // limitation on request execution. A value of `"Exempt"` means + // that requests of this priority level are not subject to a limit + // (and thus are never queued) and do not detract from the + // capacity made available to other priority levels. A value of + // `"Limited"` means that (a) requests of this priority level + // _are_ subject to limits and (b) some of the server's limited + // capacity is made available exclusively to this priority level. + // Required. + // +unionDiscriminator + Type PriorityLevelEnablement `json:"type" protobuf:"bytes,1,opt,name=type"` + + // `limited` specifies how requests are handled for a Limited priority level. + // This field must be non-empty if and only if `type` is `"Limited"`. + // +optional + Limited *LimitedPriorityLevelConfiguration `json:"limited,omitempty" protobuf:"bytes,2,opt,name=limited"` +} + +// PriorityLevelEnablement indicates whether limits on execution are enabled for the priority level +type PriorityLevelEnablement string + +// Supported priority level enablement values. +const ( + // PriorityLevelEnablementExempt means that requests are not subject to limits + PriorityLevelEnablementExempt PriorityLevelEnablement = "Exempt" + + // PriorityLevelEnablementLimited means that requests are subject to limits + PriorityLevelEnablementLimited PriorityLevelEnablement = "Limited" +) + +// LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. +// It addresses two issues: +// * How are requests for this priority level limited? +// * What should be done with requests that exceed the limit? +type LimitedPriorityLevelConfiguration struct { + // `assuredConcurrencyShares` (ACS) configures the execution + // limit, which is a limit on the number of requests of this + // priority level that may be exeucting at a given time. ACS must + // be a positive number. The server's concurrency limit (SCL) is + // divided among the concurrency-controlled priority levels in + // proportion to their assured concurrency shares. This produces + // the assured concurrency value (ACV) --- the number of requests + // that may be executing at a time --- for each such priority + // level: + // + // ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) + // + // bigger numbers of ACS mean more reserved concurrent requests (at the + // expense of every other PL). + // This field has a default value of 30. + // +optional + AssuredConcurrencyShares int32 `json:"assuredConcurrencyShares" protobuf:"varint,1,opt,name=assuredConcurrencyShares"` + + // `limitResponse` indicates what to do with requests that can not be executed right now + LimitResponse LimitResponse `json:"limitResponse,omitempty" protobuf:"bytes,2,opt,name=limitResponse"` +} + +// LimitResponse defines how to handle requests that can not be executed right now. +// +union +type LimitResponse struct { + // `type` is "Queue" or "Reject". + // "Queue" means that requests that can not be executed upon arrival + // are held in a queue until they can be executed or a queuing limit + // is reached. + // "Reject" means that requests that can not be executed upon arrival + // are rejected. + // Required. + // +unionDiscriminator + Type LimitResponseType `json:"type" protobuf:"bytes,1,opt,name=type"` + + // `queuing` holds the configuration parameters for queuing. + // This field may be non-empty only if `type` is `"Queue"`. + // +optional + Queuing *QueuingConfiguration `json:"queuing,omitempty" protobuf:"bytes,2,opt,name=queuing"` +} + +// LimitResponseType identifies how a Limited priority level handles a request that can not be executed right now +type LimitResponseType string + +// Supported limit responses. +const ( + // LimitResponseTypeQueue means that requests that can not be executed right now are queued until they can be executed or a queuing limit is hit + LimitResponseTypeQueue LimitResponseType = "Queue" + + // LimitResponseTypeReject means that requests that can not be executed right now are rejected + LimitResponseTypeReject LimitResponseType = "Reject" +) + +// QueuingConfiguration holds the configuration parameters for queuing +type QueuingConfiguration struct { + // `queues` is the number of queues for this priority level. The + // queues exist independently at each apiserver. The value must be + // positive. Setting it to 1 effectively precludes + // shufflesharding and thus makes the distinguisher method of + // associated flow schemas irrelevant. This field has a default + // value of 64. + // +optional + Queues int32 `json:"queues" protobuf:"varint,1,opt,name=queues"` + + // `handSize` is a small positive number that configures the + // shuffle sharding of requests into queues. When enqueuing a request + // at this priority level the request's flow identifier (a string + // pair) is hashed and the hash value is used to shuffle the list + // of queues and deal a hand of the size specified here. The + // request is put into one of the shortest queues in that hand. + // `handSize` must be no larger than `queues`, and should be + // significantly smaller (so that a few heavy flows do not + // saturate most of the queues). See the user-facing + // documentation for more extensive guidance on setting this + // field. This field has a default value of 8. + // +optional + HandSize int32 `json:"handSize" protobuf:"varint,2,opt,name=handSize"` + + // `queueLengthLimit` is the maximum number of requests allowed to + // be waiting in a given queue of this priority level at a time; + // excess requests are rejected. This value must be positive. If + // not specified, it will be defaulted to 50. + // +optional + QueueLengthLimit int32 `json:"queueLengthLimit" protobuf:"varint,3,opt,name=queueLengthLimit"` +} + +// PriorityLevelConfigurationConditionType is a valid value for PriorityLevelConfigurationStatusCondition.Type +type PriorityLevelConfigurationConditionType string + +// PriorityLevelConfigurationStatus represents the current state of a "request-priority". +type PriorityLevelConfigurationStatus struct { + // `conditions` is the current state of "request-priority". + // +listType=map + // +listMapKey=type + // +optional + Conditions []PriorityLevelConfigurationCondition `json:"conditions,omitempty" protobuf:"bytes,1,rep,name=conditions"` +} + +// PriorityLevelConfigurationCondition defines the condition of priority level. +type PriorityLevelConfigurationCondition struct { + // `type` is the type of the condition. + // Required. + Type PriorityLevelConfigurationConditionType `json:"type,omitempty" protobuf:"bytes,1,opt,name=type"` + // `status` is the status of the condition. + // Can be True, False, Unknown. + // Required. + Status ConditionStatus `json:"status,omitempty" protobuf:"bytes,2,opt,name=status"` + // `lastTransitionTime` is the last time the condition transitioned from one status to another. + LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,3,opt,name=lastTransitionTime"` + // `reason` is a unique, one-word, CamelCase reason for the condition's last transition. + Reason string `json:"reason,omitempty" protobuf:"bytes,4,opt,name=reason"` + // `message` is a human-readable message indicating details about last transition. + Message string `json:"message,omitempty" protobuf:"bytes,5,opt,name=message"` +} + +// ConditionStatus is the status of the condition. +type ConditionStatus string + +// These are valid condition statuses. "ConditionTrue" means a resource is in the condition. +// "ConditionFalse" means a resource is not in the condition. "ConditionUnknown" means kubernetes +// can't decide if a resource is in the condition or not. In the future, we could add other +// intermediate conditions, e.g. ConditionDegraded. +const ( + ConditionTrue ConditionStatus = "True" + ConditionFalse ConditionStatus = "False" + ConditionUnknown ConditionStatus = "Unknown" +) diff --git a/vendor/k8s.io/api/flowcontrol/v1beta2/types_swagger_doc_generated.go b/vendor/k8s.io/api/flowcontrol/v1beta2/types_swagger_doc_generated.go new file mode 100644 index 0000000000..4775a8e993 --- /dev/null +++ b/vendor/k8s.io/api/flowcontrol/v1beta2/types_swagger_doc_generated.go @@ -0,0 +1,261 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta2 + +// This file contains a collection of methods that can be used from go-restful to +// generate Swagger API documentation for its models. Please read this PR for more +// information on the implementation: https://github.com/emicklei/go-restful/pull/215 +// +// TODOs are ignored from the parser (e.g. TODO(andronat):... || TODO:...) if and only if +// they are on one line! For multiple line or blocks that you want to ignore use ---. +// Any context after a --- is ignored. +// +// Those methods can be generated by using hack/update-generated-swagger-docs.sh + +// AUTO-GENERATED FUNCTIONS START HERE. DO NOT EDIT. +var map_FlowDistinguisherMethod = map[string]string{ + "": "FlowDistinguisherMethod specifies the method of a flow distinguisher.", + "type": "`type` is the type of flow distinguisher method The supported types are \"ByUser\" and \"ByNamespace\". Required.", +} + +func (FlowDistinguisherMethod) SwaggerDoc() map[string]string { + return map_FlowDistinguisherMethod +} + +var map_FlowSchema = map[string]string{ + "": "FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a \"flow distinguisher\".", + "metadata": "`metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "spec": "`spec` is the specification of the desired behavior of a FlowSchema. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "status": "`status` is the current status of a FlowSchema. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", +} + +func (FlowSchema) SwaggerDoc() map[string]string { + return map_FlowSchema +} + +var map_FlowSchemaCondition = map[string]string{ + "": "FlowSchemaCondition describes conditions for a FlowSchema.", + "type": "`type` is the type of the condition. Required.", + "status": "`status` is the status of the condition. Can be True, False, Unknown. Required.", + "lastTransitionTime": "`lastTransitionTime` is the last time the condition transitioned from one status to another.", + "reason": "`reason` is a unique, one-word, CamelCase reason for the condition's last transition.", + "message": "`message` is a human-readable message indicating details about last transition.", +} + +func (FlowSchemaCondition) SwaggerDoc() map[string]string { + return map_FlowSchemaCondition +} + +var map_FlowSchemaList = map[string]string{ + "": "FlowSchemaList is a list of FlowSchema objects.", + "metadata": "`metadata` is the standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "items": "`items` is a list of FlowSchemas.", +} + +func (FlowSchemaList) SwaggerDoc() map[string]string { + return map_FlowSchemaList +} + +var map_FlowSchemaSpec = map[string]string{ + "": "FlowSchemaSpec describes how the FlowSchema's specification looks like.", + "priorityLevelConfiguration": "`priorityLevelConfiguration` should reference a PriorityLevelConfiguration in the cluster. If the reference cannot be resolved, the FlowSchema will be ignored and marked as invalid in its status. Required.", + "matchingPrecedence": "`matchingPrecedence` is used to choose among the FlowSchemas that match a given request. The chosen FlowSchema is among those with the numerically lowest (which we take to be logically highest) MatchingPrecedence. Each MatchingPrecedence value must be ranged in [1,10000]. Note that if the precedence is not specified, it will be set to 1000 as default.", + "distinguisherMethod": "`distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string.", + "rules": "`rules` describes which requests will match this flow schema. This FlowSchema matches a request if and only if at least one member of rules matches the request. if it is an empty slice, there will be no requests matching the FlowSchema.", +} + +func (FlowSchemaSpec) SwaggerDoc() map[string]string { + return map_FlowSchemaSpec +} + +var map_FlowSchemaStatus = map[string]string{ + "": "FlowSchemaStatus represents the current state of a FlowSchema.", + "conditions": "`conditions` is a list of the current states of FlowSchema.", +} + +func (FlowSchemaStatus) SwaggerDoc() map[string]string { + return map_FlowSchemaStatus +} + +var map_GroupSubject = map[string]string{ + "": "GroupSubject holds detailed information for group-kind subject.", + "name": "name is the user group that matches, or \"*\" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required.", +} + +func (GroupSubject) SwaggerDoc() map[string]string { + return map_GroupSubject +} + +var map_LimitResponse = map[string]string{ + "": "LimitResponse defines how to handle requests that can not be executed right now.", + "type": "`type` is \"Queue\" or \"Reject\". \"Queue\" means that requests that can not be executed upon arrival are held in a queue until they can be executed or a queuing limit is reached. \"Reject\" means that requests that can not be executed upon arrival are rejected. Required.", + "queuing": "`queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `\"Queue\"`.", +} + +func (LimitResponse) SwaggerDoc() map[string]string { + return map_LimitResponse +} + +var map_LimitedPriorityLevelConfiguration = map[string]string{ + "": "LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues:\n * How are requests for this priority level limited?\n * What should be done with requests that exceed the limit?", + "assuredConcurrencyShares": "`assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) ", + "limitResponse": "`limitResponse` indicates what to do with requests that can not be executed right now", +} + +func (LimitedPriorityLevelConfiguration) SwaggerDoc() map[string]string { + return map_LimitedPriorityLevelConfiguration +} + +var map_NonResourcePolicyRule = map[string]string{ + "": "NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request.", + "verbs": "`verbs` is a list of matching verbs and may not be empty. \"*\" matches all verbs. If it is present, it must be the only entry. Required.", + "nonResourceURLs": "`nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example:\n - \"/healthz\" is legal\n - \"/hea*\" is illegal\n - \"/hea\" is legal but matches nothing\n - \"/hea/*\" also matches nothing\n - \"/healthz/*\" matches all per-component health checks.\n\"*\" matches all non-resource urls. if it is present, it must be the only entry. Required.", +} + +func (NonResourcePolicyRule) SwaggerDoc() map[string]string { + return map_NonResourcePolicyRule +} + +var map_PolicyRulesWithSubjects = map[string]string{ + "": "PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request.", + "subjects": "subjects is the list of normal user, serviceaccount, or group that this rule cares about. There must be at least one member in this slice. A slice that includes both the system:authenticated and system:unauthenticated user groups matches every request. Required.", + "resourceRules": "`resourceRules` is a slice of ResourcePolicyRules that identify matching requests according to their verb and the target resource. At least one of `resourceRules` and `nonResourceRules` has to be non-empty.", + "nonResourceRules": "`nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL.", +} + +func (PolicyRulesWithSubjects) SwaggerDoc() map[string]string { + return map_PolicyRulesWithSubjects +} + +var map_PriorityLevelConfiguration = map[string]string{ + "": "PriorityLevelConfiguration represents the configuration of a priority level.", + "metadata": "`metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "spec": "`spec` is the specification of the desired behavior of a \"request-priority\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", + "status": "`status` is the current status of a \"request-priority\". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status", +} + +func (PriorityLevelConfiguration) SwaggerDoc() map[string]string { + return map_PriorityLevelConfiguration +} + +var map_PriorityLevelConfigurationCondition = map[string]string{ + "": "PriorityLevelConfigurationCondition defines the condition of priority level.", + "type": "`type` is the type of the condition. Required.", + "status": "`status` is the status of the condition. Can be True, False, Unknown. Required.", + "lastTransitionTime": "`lastTransitionTime` is the last time the condition transitioned from one status to another.", + "reason": "`reason` is a unique, one-word, CamelCase reason for the condition's last transition.", + "message": "`message` is a human-readable message indicating details about last transition.", +} + +func (PriorityLevelConfigurationCondition) SwaggerDoc() map[string]string { + return map_PriorityLevelConfigurationCondition +} + +var map_PriorityLevelConfigurationList = map[string]string{ + "": "PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects.", + "metadata": "`metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "items": "`items` is a list of request-priorities.", +} + +func (PriorityLevelConfigurationList) SwaggerDoc() map[string]string { + return map_PriorityLevelConfigurationList +} + +var map_PriorityLevelConfigurationReference = map[string]string{ + "": "PriorityLevelConfigurationReference contains information that points to the \"request-priority\" being used.", + "name": "`name` is the name of the priority level configuration being referenced Required.", +} + +func (PriorityLevelConfigurationReference) SwaggerDoc() map[string]string { + return map_PriorityLevelConfigurationReference +} + +var map_PriorityLevelConfigurationSpec = map[string]string{ + "": "PriorityLevelConfigurationSpec specifies the configuration of a priority level.", + "type": "`type` indicates whether this priority level is subject to limitation on request execution. A value of `\"Exempt\"` means that requests of this priority level are not subject to a limit (and thus are never queued) and do not detract from the capacity made available to other priority levels. A value of `\"Limited\"` means that (a) requests of this priority level _are_ subject to limits and (b) some of the server's limited capacity is made available exclusively to this priority level. Required.", + "limited": "`limited` specifies how requests are handled for a Limited priority level. This field must be non-empty if and only if `type` is `\"Limited\"`.", +} + +func (PriorityLevelConfigurationSpec) SwaggerDoc() map[string]string { + return map_PriorityLevelConfigurationSpec +} + +var map_PriorityLevelConfigurationStatus = map[string]string{ + "": "PriorityLevelConfigurationStatus represents the current state of a \"request-priority\".", + "conditions": "`conditions` is the current state of \"request-priority\".", +} + +func (PriorityLevelConfigurationStatus) SwaggerDoc() map[string]string { + return map_PriorityLevelConfigurationStatus +} + +var map_QueuingConfiguration = map[string]string{ + "": "QueuingConfiguration holds the configuration parameters for queuing", + "queues": "`queues` is the number of queues for this priority level. The queues exist independently at each apiserver. The value must be positive. Setting it to 1 effectively precludes shufflesharding and thus makes the distinguisher method of associated flow schemas irrelevant. This field has a default value of 64.", + "handSize": "`handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8.", + "queueLengthLimit": "`queueLengthLimit` is the maximum number of requests allowed to be waiting in a given queue of this priority level at a time; excess requests are rejected. This value must be positive. If not specified, it will be defaulted to 50.", +} + +func (QueuingConfiguration) SwaggerDoc() map[string]string { + return map_QueuingConfiguration +} + +var map_ResourcePolicyRule = map[string]string{ + "": "ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) either (d1) the request does not specify a namespace (i.e., `Namespace==\"\"`) and clusterScope is true or (d2) the request specifies a namespace and least one member of namespaces matches the request's namespace.", + "verbs": "`verbs` is a list of matching verbs and may not be empty. \"*\" matches all verbs and, if present, must be the only entry. Required.", + "apiGroups": "`apiGroups` is a list of matching API groups and may not be empty. \"*\" matches all API groups and, if present, must be the only entry. Required.", + "resources": "`resources` is a list of matching resources (i.e., lowercase and plural) with, if desired, subresource. For example, [ \"services\", \"nodes/status\" ]. This list may not be empty. \"*\" matches all resources and, if present, must be the only entry. Required.", + "clusterScope": "`clusterScope` indicates whether to match requests that do not specify a namespace (which happens either because the resource is not namespaced or the request targets all namespaces). If this field is omitted or false then the `namespaces` field must contain a non-empty list.", + "namespaces": "`namespaces` is a list of target namespaces that restricts matches. A request that specifies a target namespace matches only if either (a) this list contains that target namespace or (b) this list contains \"*\". Note that \"*\" matches any specified namespace but does not match a request that _does not specify_ a namespace (see the `clusterScope` field for that). This list may be empty, but only if `clusterScope` is true.", +} + +func (ResourcePolicyRule) SwaggerDoc() map[string]string { + return map_ResourcePolicyRule +} + +var map_ServiceAccountSubject = map[string]string{ + "": "ServiceAccountSubject holds detailed information for service-account-kind subject.", + "namespace": "`namespace` is the namespace of matching ServiceAccount objects. Required.", + "name": "`name` is the name of matching ServiceAccount objects, or \"*\" to match regardless of name. Required.", +} + +func (ServiceAccountSubject) SwaggerDoc() map[string]string { + return map_ServiceAccountSubject +} + +var map_Subject = map[string]string{ + "": "Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account.", + "kind": "`kind` indicates which one of the other fields is non-empty. Required", + "user": "`user` matches based on username.", + "group": "`group` matches based on user group name.", + "serviceAccount": "`serviceAccount` matches ServiceAccounts.", +} + +func (Subject) SwaggerDoc() map[string]string { + return map_Subject +} + +var map_UserSubject = map[string]string{ + "": "UserSubject holds detailed information for user-kind subject.", + "name": "`name` is the username that matches, or \"*\" to match all usernames. Required.", +} + +func (UserSubject) SwaggerDoc() map[string]string { + return map_UserSubject +} + +// AUTO-GENERATED FUNCTIONS END HERE diff --git a/vendor/k8s.io/api/flowcontrol/v1beta2/zz_generated.deepcopy.go b/vendor/k8s.io/api/flowcontrol/v1beta2/zz_generated.deepcopy.go new file mode 100644 index 0000000000..e6288a687a --- /dev/null +++ b/vendor/k8s.io/api/flowcontrol/v1beta2/zz_generated.deepcopy.go @@ -0,0 +1,542 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package v1beta2 + +import ( + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FlowDistinguisherMethod) DeepCopyInto(out *FlowDistinguisherMethod) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlowDistinguisherMethod. +func (in *FlowDistinguisherMethod) DeepCopy() *FlowDistinguisherMethod { + if in == nil { + return nil + } + out := new(FlowDistinguisherMethod) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FlowSchema) DeepCopyInto(out *FlowSchema) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlowSchema. +func (in *FlowSchema) DeepCopy() *FlowSchema { + if in == nil { + return nil + } + out := new(FlowSchema) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *FlowSchema) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FlowSchemaCondition) DeepCopyInto(out *FlowSchemaCondition) { + *out = *in + in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlowSchemaCondition. +func (in *FlowSchemaCondition) DeepCopy() *FlowSchemaCondition { + if in == nil { + return nil + } + out := new(FlowSchemaCondition) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FlowSchemaList) DeepCopyInto(out *FlowSchemaList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]FlowSchema, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlowSchemaList. +func (in *FlowSchemaList) DeepCopy() *FlowSchemaList { + if in == nil { + return nil + } + out := new(FlowSchemaList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *FlowSchemaList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FlowSchemaSpec) DeepCopyInto(out *FlowSchemaSpec) { + *out = *in + out.PriorityLevelConfiguration = in.PriorityLevelConfiguration + if in.DistinguisherMethod != nil { + in, out := &in.DistinguisherMethod, &out.DistinguisherMethod + *out = new(FlowDistinguisherMethod) + **out = **in + } + if in.Rules != nil { + in, out := &in.Rules, &out.Rules + *out = make([]PolicyRulesWithSubjects, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlowSchemaSpec. +func (in *FlowSchemaSpec) DeepCopy() *FlowSchemaSpec { + if in == nil { + return nil + } + out := new(FlowSchemaSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FlowSchemaStatus) DeepCopyInto(out *FlowSchemaStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]FlowSchemaCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlowSchemaStatus. +func (in *FlowSchemaStatus) DeepCopy() *FlowSchemaStatus { + if in == nil { + return nil + } + out := new(FlowSchemaStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *GroupSubject) DeepCopyInto(out *GroupSubject) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GroupSubject. +func (in *GroupSubject) DeepCopy() *GroupSubject { + if in == nil { + return nil + } + out := new(GroupSubject) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *LimitResponse) DeepCopyInto(out *LimitResponse) { + *out = *in + if in.Queuing != nil { + in, out := &in.Queuing, &out.Queuing + *out = new(QueuingConfiguration) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitResponse. +func (in *LimitResponse) DeepCopy() *LimitResponse { + if in == nil { + return nil + } + out := new(LimitResponse) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *LimitedPriorityLevelConfiguration) DeepCopyInto(out *LimitedPriorityLevelConfiguration) { + *out = *in + in.LimitResponse.DeepCopyInto(&out.LimitResponse) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitedPriorityLevelConfiguration. +func (in *LimitedPriorityLevelConfiguration) DeepCopy() *LimitedPriorityLevelConfiguration { + if in == nil { + return nil + } + out := new(LimitedPriorityLevelConfiguration) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *NonResourcePolicyRule) DeepCopyInto(out *NonResourcePolicyRule) { + *out = *in + if in.Verbs != nil { + in, out := &in.Verbs, &out.Verbs + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.NonResourceURLs != nil { + in, out := &in.NonResourceURLs, &out.NonResourceURLs + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NonResourcePolicyRule. +func (in *NonResourcePolicyRule) DeepCopy() *NonResourcePolicyRule { + if in == nil { + return nil + } + out := new(NonResourcePolicyRule) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PolicyRulesWithSubjects) DeepCopyInto(out *PolicyRulesWithSubjects) { + *out = *in + if in.Subjects != nil { + in, out := &in.Subjects, &out.Subjects + *out = make([]Subject, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.ResourceRules != nil { + in, out := &in.ResourceRules, &out.ResourceRules + *out = make([]ResourcePolicyRule, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.NonResourceRules != nil { + in, out := &in.NonResourceRules, &out.NonResourceRules + *out = make([]NonResourcePolicyRule, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PolicyRulesWithSubjects. +func (in *PolicyRulesWithSubjects) DeepCopy() *PolicyRulesWithSubjects { + if in == nil { + return nil + } + out := new(PolicyRulesWithSubjects) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PriorityLevelConfiguration) DeepCopyInto(out *PriorityLevelConfiguration) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityLevelConfiguration. +func (in *PriorityLevelConfiguration) DeepCopy() *PriorityLevelConfiguration { + if in == nil { + return nil + } + out := new(PriorityLevelConfiguration) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *PriorityLevelConfiguration) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PriorityLevelConfigurationCondition) DeepCopyInto(out *PriorityLevelConfigurationCondition) { + *out = *in + in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityLevelConfigurationCondition. +func (in *PriorityLevelConfigurationCondition) DeepCopy() *PriorityLevelConfigurationCondition { + if in == nil { + return nil + } + out := new(PriorityLevelConfigurationCondition) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PriorityLevelConfigurationList) DeepCopyInto(out *PriorityLevelConfigurationList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]PriorityLevelConfiguration, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityLevelConfigurationList. +func (in *PriorityLevelConfigurationList) DeepCopy() *PriorityLevelConfigurationList { + if in == nil { + return nil + } + out := new(PriorityLevelConfigurationList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *PriorityLevelConfigurationList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PriorityLevelConfigurationReference) DeepCopyInto(out *PriorityLevelConfigurationReference) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityLevelConfigurationReference. +func (in *PriorityLevelConfigurationReference) DeepCopy() *PriorityLevelConfigurationReference { + if in == nil { + return nil + } + out := new(PriorityLevelConfigurationReference) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PriorityLevelConfigurationSpec) DeepCopyInto(out *PriorityLevelConfigurationSpec) { + *out = *in + if in.Limited != nil { + in, out := &in.Limited, &out.Limited + *out = new(LimitedPriorityLevelConfiguration) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityLevelConfigurationSpec. +func (in *PriorityLevelConfigurationSpec) DeepCopy() *PriorityLevelConfigurationSpec { + if in == nil { + return nil + } + out := new(PriorityLevelConfigurationSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PriorityLevelConfigurationStatus) DeepCopyInto(out *PriorityLevelConfigurationStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]PriorityLevelConfigurationCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityLevelConfigurationStatus. +func (in *PriorityLevelConfigurationStatus) DeepCopy() *PriorityLevelConfigurationStatus { + if in == nil { + return nil + } + out := new(PriorityLevelConfigurationStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *QueuingConfiguration) DeepCopyInto(out *QueuingConfiguration) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueuingConfiguration. +func (in *QueuingConfiguration) DeepCopy() *QueuingConfiguration { + if in == nil { + return nil + } + out := new(QueuingConfiguration) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourcePolicyRule) DeepCopyInto(out *ResourcePolicyRule) { + *out = *in + if in.Verbs != nil { + in, out := &in.Verbs, &out.Verbs + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.APIGroups != nil { + in, out := &in.APIGroups, &out.APIGroups + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.Resources != nil { + in, out := &in.Resources, &out.Resources + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.Namespaces != nil { + in, out := &in.Namespaces, &out.Namespaces + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourcePolicyRule. +func (in *ResourcePolicyRule) DeepCopy() *ResourcePolicyRule { + if in == nil { + return nil + } + out := new(ResourcePolicyRule) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ServiceAccountSubject) DeepCopyInto(out *ServiceAccountSubject) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceAccountSubject. +func (in *ServiceAccountSubject) DeepCopy() *ServiceAccountSubject { + if in == nil { + return nil + } + out := new(ServiceAccountSubject) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Subject) DeepCopyInto(out *Subject) { + *out = *in + if in.User != nil { + in, out := &in.User, &out.User + *out = new(UserSubject) + **out = **in + } + if in.Group != nil { + in, out := &in.Group, &out.Group + *out = new(GroupSubject) + **out = **in + } + if in.ServiceAccount != nil { + in, out := &in.ServiceAccount, &out.ServiceAccount + *out = new(ServiceAccountSubject) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Subject. +func (in *Subject) DeepCopy() *Subject { + if in == nil { + return nil + } + out := new(Subject) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *UserSubject) DeepCopyInto(out *UserSubject) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserSubject. +func (in *UserSubject) DeepCopy() *UserSubject { + if in == nil { + return nil + } + out := new(UserSubject) + in.DeepCopyInto(out) + return out +} diff --git a/vendor/k8s.io/api/flowcontrol/v1beta2/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/flowcontrol/v1beta2/zz_generated.prerelease-lifecycle.go new file mode 100644 index 0000000000..00cefde419 --- /dev/null +++ b/vendor/k8s.io/api/flowcontrol/v1beta2/zz_generated.prerelease-lifecycle.go @@ -0,0 +1,94 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by prerelease-lifecycle-gen. DO NOT EDIT. + +package v1beta2 + +// APILifecycleIntroduced is an autogenerated function, returning the release in which the API struct was introduced as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:introduced" tags in types.go. +func (in *FlowSchema) APILifecycleIntroduced() (major, minor int) { + return 1, 23 +} + +// APILifecycleDeprecated is an autogenerated function, returning the release in which the API struct was or will be deprecated as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:deprecated" tags in types.go or "k8s:prerelease-lifecycle-gen:introduced" plus three minor. +func (in *FlowSchema) APILifecycleDeprecated() (major, minor int) { + return 1, 26 +} + +// APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:removed" tags in types.go or "k8s:prerelease-lifecycle-gen:deprecated" plus three minor. +func (in *FlowSchema) APILifecycleRemoved() (major, minor int) { + return 1, 29 +} + +// APILifecycleIntroduced is an autogenerated function, returning the release in which the API struct was introduced as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:introduced" tags in types.go. +func (in *FlowSchemaList) APILifecycleIntroduced() (major, minor int) { + return 1, 23 +} + +// APILifecycleDeprecated is an autogenerated function, returning the release in which the API struct was or will be deprecated as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:deprecated" tags in types.go or "k8s:prerelease-lifecycle-gen:introduced" plus three minor. +func (in *FlowSchemaList) APILifecycleDeprecated() (major, minor int) { + return 1, 26 +} + +// APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:removed" tags in types.go or "k8s:prerelease-lifecycle-gen:deprecated" plus three minor. +func (in *FlowSchemaList) APILifecycleRemoved() (major, minor int) { + return 1, 29 +} + +// APILifecycleIntroduced is an autogenerated function, returning the release in which the API struct was introduced as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:introduced" tags in types.go. +func (in *PriorityLevelConfiguration) APILifecycleIntroduced() (major, minor int) { + return 1, 23 +} + +// APILifecycleDeprecated is an autogenerated function, returning the release in which the API struct was or will be deprecated as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:deprecated" tags in types.go or "k8s:prerelease-lifecycle-gen:introduced" plus three minor. +func (in *PriorityLevelConfiguration) APILifecycleDeprecated() (major, minor int) { + return 1, 26 +} + +// APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:removed" tags in types.go or "k8s:prerelease-lifecycle-gen:deprecated" plus three minor. +func (in *PriorityLevelConfiguration) APILifecycleRemoved() (major, minor int) { + return 1, 29 +} + +// APILifecycleIntroduced is an autogenerated function, returning the release in which the API struct was introduced as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:introduced" tags in types.go. +func (in *PriorityLevelConfigurationList) APILifecycleIntroduced() (major, minor int) { + return 1, 23 +} + +// APILifecycleDeprecated is an autogenerated function, returning the release in which the API struct was or will be deprecated as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:deprecated" tags in types.go or "k8s:prerelease-lifecycle-gen:introduced" plus three minor. +func (in *PriorityLevelConfigurationList) APILifecycleDeprecated() (major, minor int) { + return 1, 26 +} + +// APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison. +// It is controlled by "k8s:prerelease-lifecycle-gen:removed" tags in types.go or "k8s:prerelease-lifecycle-gen:deprecated" plus three minor. +func (in *PriorityLevelConfigurationList) APILifecycleRemoved() (major, minor int) { + return 1, 29 +} diff --git a/vendor/k8s.io/api/imagepolicy/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/api/imagepolicy/v1alpha1/zz_generated.deepcopy.go index 83d47b7919..f230656f3f 100644 --- a/vendor/k8s.io/api/imagepolicy/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/imagepolicy/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/networking/v1/generated.proto b/vendor/k8s.io/api/networking/v1/generated.proto index 8559e92d73..e98ab179e2 100644 --- a/vendor/k8s.io/api/networking/v1/generated.proto +++ b/vendor/k8s.io/api/networking/v1/generated.proto @@ -167,16 +167,13 @@ message IngressClassParametersReference { // Scope represents if this refers to a cluster or namespace scoped resource. // This may be set to "Cluster" (default) or "Namespace". - // Field can be enabled with IngressClassNamespacedParams feature gate. // +optional - // +featureGate=IngressClassNamespacedParams optional string scope = 4; // Namespace is the namespace of the resource being referenced. This field is // required when scope is set to "Namespace" and must be unset when scope is set to // "Cluster". // +optional - // +featureGate=IngressClassNamespacedParams optional string namespace = 5; } diff --git a/vendor/k8s.io/api/networking/v1/types.go b/vendor/k8s.io/api/networking/v1/types.go index 7edbcd5979..c49110e5ca 100644 --- a/vendor/k8s.io/api/networking/v1/types.go +++ b/vendor/k8s.io/api/networking/v1/types.go @@ -40,6 +40,7 @@ type NetworkPolicy struct { // PolicyType string describes the NetworkPolicy type // This type is beta-level in 1.8 +// +enum type PolicyType string const ( @@ -373,6 +374,7 @@ type HTTPIngressRuleValue struct { } // PathType represents the type of path referred to by a HTTPIngressPath. +// +enum type PathType string const ( @@ -534,15 +536,12 @@ type IngressClassParametersReference struct { Name string `json:"name" protobuf:"bytes,3,opt,name=name"` // Scope represents if this refers to a cluster or namespace scoped resource. // This may be set to "Cluster" (default) or "Namespace". - // Field can be enabled with IngressClassNamespacedParams feature gate. // +optional - // +featureGate=IngressClassNamespacedParams Scope *string `json:"scope" protobuf:"bytes,4,opt,name=scope"` // Namespace is the namespace of the resource being referenced. This field is // required when scope is set to "Namespace" and must be unset when scope is set to // "Cluster". // +optional - // +featureGate=IngressClassNamespacedParams Namespace *string `json:"namespace,omitempty" protobuf:"bytes,5,opt,name=namespace"` } diff --git a/vendor/k8s.io/api/networking/v1/types_swagger_doc_generated.go b/vendor/k8s.io/api/networking/v1/types_swagger_doc_generated.go index 49b38bd049..38bd9c502b 100644 --- a/vendor/k8s.io/api/networking/v1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/networking/v1/types_swagger_doc_generated.go @@ -103,7 +103,7 @@ var map_IngressClassParametersReference = map[string]string{ "apiGroup": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", "kind": "Kind is the type of resource being referenced.", "name": "Name is the name of resource being referenced.", - "scope": "Scope represents if this refers to a cluster or namespace scoped resource. This may be set to \"Cluster\" (default) or \"Namespace\". Field can be enabled with IngressClassNamespacedParams feature gate.", + "scope": "Scope represents if this refers to a cluster or namespace scoped resource. This may be set to \"Cluster\" (default) or \"Namespace\".", "namespace": "Namespace is the namespace of the resource being referenced. This field is required when scope is set to \"Namespace\" and must be unset when scope is set to \"Cluster\".", } diff --git a/vendor/k8s.io/api/networking/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/networking/v1/zz_generated.deepcopy.go index 76e339aed9..82677ca8b9 100644 --- a/vendor/k8s.io/api/networking/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/networking/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/networking/v1beta1/generated.proto b/vendor/k8s.io/api/networking/v1beta1/generated.proto index 5479ac482b..ef8cceff43 100644 --- a/vendor/k8s.io/api/networking/v1beta1/generated.proto +++ b/vendor/k8s.io/api/networking/v1beta1/generated.proto @@ -154,16 +154,12 @@ message IngressClassParametersReference { // Scope represents if this refers to a cluster or namespace scoped resource. // This may be set to "Cluster" (default) or "Namespace". - // Field can be enabled with IngressClassNamespacedParams feature gate. - // +optional - // +featureGate=IngressClassNamespacedParams optional string scope = 4; // Namespace is the namespace of the resource being referenced. This field is // required when scope is set to "Namespace" and must be unset when scope is set to // "Cluster". // +optional - // +featureGate=IngressClassNamespacedParams optional string namespace = 5; } diff --git a/vendor/k8s.io/api/networking/v1beta1/types.go b/vendor/k8s.io/api/networking/v1beta1/types.go index 4646e90b64..1bfdcd0915 100644 --- a/vendor/k8s.io/api/networking/v1beta1/types.go +++ b/vendor/k8s.io/api/networking/v1beta1/types.go @@ -337,15 +337,11 @@ type IngressClassParametersReference struct { Name string `json:"name" protobuf:"bytes,3,opt,name=name"` // Scope represents if this refers to a cluster or namespace scoped resource. // This may be set to "Cluster" (default) or "Namespace". - // Field can be enabled with IngressClassNamespacedParams feature gate. - // +optional - // +featureGate=IngressClassNamespacedParams Scope *string `json:"scope" protobuf:"bytes,4,opt,name=scope"` // Namespace is the namespace of the resource being referenced. This field is // required when scope is set to "Namespace" and must be unset when scope is set to // "Cluster". // +optional - // +featureGate=IngressClassNamespacedParams Namespace *string `json:"namespace,omitempty" protobuf:"bytes,5,opt,name=namespace"` } diff --git a/vendor/k8s.io/api/networking/v1beta1/types_swagger_doc_generated.go b/vendor/k8s.io/api/networking/v1beta1/types_swagger_doc_generated.go index 88c130e89b..79c42a6ba4 100644 --- a/vendor/k8s.io/api/networking/v1beta1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/networking/v1beta1/types_swagger_doc_generated.go @@ -94,7 +94,7 @@ var map_IngressClassParametersReference = map[string]string{ "apiGroup": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", "kind": "Kind is the type of resource being referenced.", "name": "Name is the name of resource being referenced.", - "scope": "Scope represents if this refers to a cluster or namespace scoped resource. This may be set to \"Cluster\" (default) or \"Namespace\". Field can be enabled with IngressClassNamespacedParams feature gate.", + "scope": "Scope represents if this refers to a cluster or namespace scoped resource. This may be set to \"Cluster\" (default) or \"Namespace\".", "namespace": "Namespace is the namespace of the resource being referenced. This field is required when scope is set to \"Namespace\" and must be unset when scope is set to \"Cluster\".", } diff --git a/vendor/k8s.io/api/networking/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/networking/v1beta1/zz_generated.deepcopy.go index e1b4543d30..77259e368d 100644 --- a/vendor/k8s.io/api/networking/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/networking/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/networking/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/networking/v1beta1/zz_generated.prerelease-lifecycle.go index 5e69fd5d9f..e8b4c7ec7f 100644 --- a/vendor/k8s.io/api/networking/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/networking/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/node/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/node/v1/zz_generated.deepcopy.go index 35084da7e3..c1424f045d 100644 --- a/vendor/k8s.io/api/node/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/node/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/node/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/api/node/v1alpha1/zz_generated.deepcopy.go index 20f8051835..9669362625 100644 --- a/vendor/k8s.io/api/node/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/node/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/node/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/node/v1beta1/zz_generated.deepcopy.go index c3989528b2..e5034a587b 100644 --- a/vendor/k8s.io/api/node/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/node/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/node/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/node/v1beta1/zz_generated.prerelease-lifecycle.go index 2fda72ef5e..860923d8ff 100644 --- a/vendor/k8s.io/api/node/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/node/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/policy/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/policy/v1/zz_generated.deepcopy.go index 9b7aac2f19..485e1c9380 100644 --- a/vendor/k8s.io/api/policy/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/policy/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/policy/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/policy/v1beta1/zz_generated.deepcopy.go index 02d8a85cf7..0a6239b87e 100644 --- a/vendor/k8s.io/api/policy/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/policy/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/policy/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/policy/v1beta1/zz_generated.prerelease-lifecycle.go index 8bda4b00f2..612061d6cf 100644 --- a/vendor/k8s.io/api/policy/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/policy/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/rbac/v1/generated.proto b/vendor/k8s.io/api/rbac/v1/generated.proto index db8fd427cd..2cf427f122 100644 --- a/vendor/k8s.io/api/rbac/v1/generated.proto +++ b/vendor/k8s.io/api/rbac/v1/generated.proto @@ -92,7 +92,7 @@ message ClusterRoleList { // PolicyRule holds information that describes a policy rule, but does not contain information // about who the rule applies to or which namespace the rule applies to. message PolicyRule { - // Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + // Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. repeated string verbs = 1; // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of diff --git a/vendor/k8s.io/api/rbac/v1/types.go b/vendor/k8s.io/api/rbac/v1/types.go index 038baf61b5..067b6f15ef 100644 --- a/vendor/k8s.io/api/rbac/v1/types.go +++ b/vendor/k8s.io/api/rbac/v1/types.go @@ -47,7 +47,7 @@ const ( // PolicyRule holds information that describes a policy rule, but does not contain information // about who the rule applies to or which namespace the rule applies to. type PolicyRule struct { - // Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + // Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. Verbs []string `json:"verbs" protobuf:"bytes,1,rep,name=verbs"` // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of diff --git a/vendor/k8s.io/api/rbac/v1/types_swagger_doc_generated.go b/vendor/k8s.io/api/rbac/v1/types_swagger_doc_generated.go index 664cf95f84..228ee54c08 100644 --- a/vendor/k8s.io/api/rbac/v1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/rbac/v1/types_swagger_doc_generated.go @@ -80,7 +80,7 @@ func (ClusterRoleList) SwaggerDoc() map[string]string { var map_PolicyRule = map[string]string{ "": "PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to.", - "verbs": "Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs.", + "verbs": "Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs.", "apiGroups": "APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed.", "resources": "Resources is a list of resources this rule applies to. '*' represents all resources.", "resourceNames": "ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.", diff --git a/vendor/k8s.io/api/rbac/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/rbac/v1/zz_generated.deepcopy.go index 095a5e9c28..eab086899d 100644 --- a/vendor/k8s.io/api/rbac/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/rbac/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/rbac/v1alpha1/generated.proto b/vendor/k8s.io/api/rbac/v1alpha1/generated.proto index 9dea00e05e..9795cffd9e 100644 --- a/vendor/k8s.io/api/rbac/v1alpha1/generated.proto +++ b/vendor/k8s.io/api/rbac/v1alpha1/generated.proto @@ -96,7 +96,7 @@ message ClusterRoleList { // PolicyRule holds information that describes a policy rule, but does not contain information // about who the rule applies to or which namespace the rule applies to. message PolicyRule { - // Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + // Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. repeated string verbs = 1; // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of diff --git a/vendor/k8s.io/api/rbac/v1alpha1/types.go b/vendor/k8s.io/api/rbac/v1alpha1/types.go index 57d993caab..13a0a1f0a3 100644 --- a/vendor/k8s.io/api/rbac/v1alpha1/types.go +++ b/vendor/k8s.io/api/rbac/v1alpha1/types.go @@ -47,7 +47,7 @@ const ( // PolicyRule holds information that describes a policy rule, but does not contain information // about who the rule applies to or which namespace the rule applies to. type PolicyRule struct { - // Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + // Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. Verbs []string `json:"verbs" protobuf:"bytes,1,rep,name=verbs"` // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of diff --git a/vendor/k8s.io/api/rbac/v1alpha1/types_swagger_doc_generated.go b/vendor/k8s.io/api/rbac/v1alpha1/types_swagger_doc_generated.go index 8fc984ad56..46b8b9ee6f 100644 --- a/vendor/k8s.io/api/rbac/v1alpha1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/rbac/v1alpha1/types_swagger_doc_generated.go @@ -80,7 +80,7 @@ func (ClusterRoleList) SwaggerDoc() map[string]string { var map_PolicyRule = map[string]string{ "": "PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to.", - "verbs": "Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs.", + "verbs": "Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs.", "apiGroups": "APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed.", "resources": "Resources is a list of resources this rule applies to. '*' represents all resources.", "resourceNames": "ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.", diff --git a/vendor/k8s.io/api/rbac/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/api/rbac/v1alpha1/zz_generated.deepcopy.go index 0358227fab..9288bd0179 100644 --- a/vendor/k8s.io/api/rbac/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/rbac/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/rbac/v1beta1/generated.proto b/vendor/k8s.io/api/rbac/v1beta1/generated.proto index fb975e2eab..53c252554d 100644 --- a/vendor/k8s.io/api/rbac/v1beta1/generated.proto +++ b/vendor/k8s.io/api/rbac/v1beta1/generated.proto @@ -96,7 +96,7 @@ message ClusterRoleList { // PolicyRule holds information that describes a policy rule, but does not contain information // about who the rule applies to or which namespace the rule applies to. message PolicyRule { - // Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + // Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. repeated string verbs = 1; // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of diff --git a/vendor/k8s.io/api/rbac/v1beta1/types.go b/vendor/k8s.io/api/rbac/v1beta1/types.go index ad8391fd71..96e6b18f54 100644 --- a/vendor/k8s.io/api/rbac/v1beta1/types.go +++ b/vendor/k8s.io/api/rbac/v1beta1/types.go @@ -47,7 +47,7 @@ const ( // PolicyRule holds information that describes a policy rule, but does not contain information // about who the rule applies to or which namespace the rule applies to. type PolicyRule struct { - // Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs. + // Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. Verbs []string `json:"verbs" protobuf:"bytes,1,rep,name=verbs"` // APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of diff --git a/vendor/k8s.io/api/rbac/v1beta1/types_swagger_doc_generated.go b/vendor/k8s.io/api/rbac/v1beta1/types_swagger_doc_generated.go index eef80f834c..5d57cb348f 100644 --- a/vendor/k8s.io/api/rbac/v1beta1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/rbac/v1beta1/types_swagger_doc_generated.go @@ -80,7 +80,7 @@ func (ClusterRoleList) SwaggerDoc() map[string]string { var map_PolicyRule = map[string]string{ "": "PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to.", - "verbs": "Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. '*' represents all verbs.", + "verbs": "Verbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs.", "apiGroups": "APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed.", "resources": "Resources is a list of resources this rule applies to. '*' represents all resources in the specified apiGroups. '*/foo' represents the subresource 'foo' for all resources in the specified apiGroups.", "resourceNames": "ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.", diff --git a/vendor/k8s.io/api/rbac/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/rbac/v1beta1/zz_generated.deepcopy.go index 7ffe581065..8abaa90c10 100644 --- a/vendor/k8s.io/api/rbac/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/rbac/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/rbac/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/rbac/v1beta1/zz_generated.prerelease-lifecycle.go index a4d99b35ac..3e38fff084 100644 --- a/vendor/k8s.io/api/rbac/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/rbac/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/scheduling/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/scheduling/v1/zz_generated.deepcopy.go index 63bfe64042..e7ff186306 100644 --- a/vendor/k8s.io/api/scheduling/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/scheduling/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/scheduling/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/api/scheduling/v1alpha1/zz_generated.deepcopy.go index 0392823975..b130c990e4 100644 --- a/vendor/k8s.io/api/scheduling/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/scheduling/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/scheduling/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/scheduling/v1beta1/zz_generated.deepcopy.go index 6e2008578e..ff38c9854f 100644 --- a/vendor/k8s.io/api/scheduling/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/scheduling/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/scheduling/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/scheduling/v1beta1/zz_generated.prerelease-lifecycle.go index 45969d15c0..15aefb1085 100644 --- a/vendor/k8s.io/api/scheduling/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/scheduling/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/storage/v1/generated.proto b/vendor/k8s.io/api/storage/v1/generated.proto index 9602c9098a..de639354d3 100644 --- a/vendor/k8s.io/api/storage/v1/generated.proto +++ b/vendor/k8s.io/api/storage/v1/generated.proto @@ -142,7 +142,7 @@ message CSIDriverSpec { // unset or false and it can be flipped later when storage // capacity information has been published. // - // This field is immutable. + // This field was immutable in Kubernetes <= 1.22 and now is mutable. // // This is a beta field and only available when the CSIStorageCapacity // feature is enabled. The default is false. @@ -154,8 +154,6 @@ message CSIDriverSpec { // Defines if the underlying volume supports changing ownership and // permission of the volume before being mounted. // Refer to the specific FSGroupPolicy values for additional details. - // This field is beta, and is only honored by servers - // that enable the CSIVolumeFSGroupPolicy feature gate. // // This field is immutable. // diff --git a/vendor/k8s.io/api/storage/v1/types.go b/vendor/k8s.io/api/storage/v1/types.go index d805e1539b..6da0657ecc 100644 --- a/vendor/k8s.io/api/storage/v1/types.go +++ b/vendor/k8s.io/api/storage/v1/types.go @@ -90,6 +90,7 @@ type StorageClassList struct { } // VolumeBindingMode indicates how PersistentVolumeClaims should be bound. +// +enum type VolumeBindingMode string const ( @@ -341,7 +342,7 @@ type CSIDriverSpec struct { // unset or false and it can be flipped later when storage // capacity information has been published. // - // This field is immutable. + // This field was immutable in Kubernetes <= 1.22 and now is mutable. // // This is a beta field and only available when the CSIStorageCapacity // feature is enabled. The default is false. @@ -353,8 +354,6 @@ type CSIDriverSpec struct { // Defines if the underlying volume supports changing ownership and // permission of the volume before being mounted. // Refer to the specific FSGroupPolicy values for additional details. - // This field is beta, and is only honored by servers - // that enable the CSIVolumeFSGroupPolicy feature gate. // // This field is immutable. // diff --git a/vendor/k8s.io/api/storage/v1/types_swagger_doc_generated.go b/vendor/k8s.io/api/storage/v1/types_swagger_doc_generated.go index d3747dc862..ed5b18cb7a 100644 --- a/vendor/k8s.io/api/storage/v1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/storage/v1/types_swagger_doc_generated.go @@ -52,8 +52,8 @@ var map_CSIDriverSpec = map[string]string{ "attachRequired": "attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the CSIDriverRegistry feature gate is enabled and the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called.\n\nThis field is immutable.", "podInfoOnMount": "If set to true, podInfoOnMount indicates this CSI volume driver requires additional pod information (like podName, podUID, etc.) during mount operations. If set to false, pod information will not be passed on mount. Default is false. The CSI driver specifies podInfoOnMount as part of driver deployment. If true, Kubelet will pass pod information as VolumeContext in the CSI NodePublishVolume() calls. The CSI driver is responsible for parsing and validating the information passed in as VolumeContext. The following VolumeConext will be passed if podInfoOnMount is set to true. This list might grow, but the prefix will be used. \"csi.storage.k8s.io/pod.name\": pod.Name \"csi.storage.k8s.io/pod.namespace\": pod.Namespace \"csi.storage.k8s.io/pod.uid\": string(pod.UID) \"csi.storage.k8s.io/ephemeral\": \"true\" if the volume is an ephemeral inline volume\n defined by a CSIVolumeSource, otherwise \"false\"\n\n\"csi.storage.k8s.io/ephemeral\" is a new feature in Kubernetes 1.16. It is only required for drivers which support both the \"Persistent\" and \"Ephemeral\" VolumeLifecycleMode. Other drivers can leave pod info disabled and/or ignore this field. As Kubernetes 1.15 doesn't support this field, drivers can only support one mode when deployed on such a cluster and the deployment determines which mode that is, for example via a command line parameter of the driver.\n\nThis field is immutable.", "volumeLifecycleModes": "volumeLifecycleModes defines what kind of volumes this CSI volume driver supports. The default if the list is empty is \"Persistent\", which is the usage defined by the CSI specification and implemented in Kubernetes via the usual PV/PVC mechanism. The other mode is \"Ephemeral\". In this mode, volumes are defined inline inside the pod spec with CSIVolumeSource and their lifecycle is tied to the lifecycle of that pod. A driver has to be aware of this because it is only going to get a NodePublishVolume call for such a volume. For more information about implementing this mode, see https://kubernetes-csi.github.io/docs/ephemeral-local-volumes.html A driver can support one or more of these modes and more modes may be added in the future. This field is beta.\n\nThis field is immutable.", - "storageCapacity": "If set to true, storageCapacity indicates that the CSI volume driver wants pod scheduling to consider the storage capacity that the driver deployment will report by creating CSIStorageCapacity objects with capacity information.\n\nThe check can be enabled immediately when deploying a driver. In that case, provisioning new volumes with late binding will pause until the driver deployment has published some suitable CSIStorageCapacity object.\n\nAlternatively, the driver can be deployed with the field unset or false and it can be flipped later when storage capacity information has been published.\n\nThis field is immutable.\n\nThis is a beta field and only available when the CSIStorageCapacity feature is enabled. The default is false.", - "fsGroupPolicy": "Defines if the underlying volume supports changing ownership and permission of the volume before being mounted. Refer to the specific FSGroupPolicy values for additional details. This field is beta, and is only honored by servers that enable the CSIVolumeFSGroupPolicy feature gate.\n\nThis field is immutable.\n\nDefaults to ReadWriteOnceWithFSType, which will examine each volume to determine if Kubernetes should modify ownership and permissions of the volume. With the default policy the defined fsGroup will only be applied if a fstype is defined and the volume's access mode contains ReadWriteOnce.", + "storageCapacity": "If set to true, storageCapacity indicates that the CSI volume driver wants pod scheduling to consider the storage capacity that the driver deployment will report by creating CSIStorageCapacity objects with capacity information.\n\nThe check can be enabled immediately when deploying a driver. In that case, provisioning new volumes with late binding will pause until the driver deployment has published some suitable CSIStorageCapacity object.\n\nAlternatively, the driver can be deployed with the field unset or false and it can be flipped later when storage capacity information has been published.\n\nThis field was immutable in Kubernetes <= 1.22 and now is mutable.\n\nThis is a beta field and only available when the CSIStorageCapacity feature is enabled. The default is false.", + "fsGroupPolicy": "Defines if the underlying volume supports changing ownership and permission of the volume before being mounted. Refer to the specific FSGroupPolicy values for additional details.\n\nThis field is immutable.\n\nDefaults to ReadWriteOnceWithFSType, which will examine each volume to determine if Kubernetes should modify ownership and permissions of the volume. With the default policy the defined fsGroup will only be applied if a fstype is defined and the volume's access mode contains ReadWriteOnce.", "tokenRequests": "TokenRequests indicates the CSI driver needs pods' service account tokens it is mounting volume for to do necessary authentication. Kubelet will pass the tokens in VolumeContext in the CSI NodePublishVolume calls. The CSI driver should parse and validate the following VolumeContext: \"csi.storage.k8s.io/serviceAccount.tokens\": {\n \"\": {\n \"token\": ,\n \"expirationTimestamp\": ,\n },\n ...\n}\n\nNote: Audience in each TokenRequest should be different and at most one token is empty string. To receive a new token after expiry, RequiresRepublish can be used to trigger NodePublishVolume periodically.", "requiresRepublish": "RequiresRepublish indicates the CSI driver wants `NodePublishVolume` being periodically called to reflect any possible change in the mounted volume. This field defaults to false.\n\nNote: After a successful initial NodePublishVolume call, subsequent calls to NodePublishVolume should only update the contents of the volume. New mount points will not be seen by a running container.", } diff --git a/vendor/k8s.io/api/storage/v1/zz_generated.deepcopy.go b/vendor/k8s.io/api/storage/v1/zz_generated.deepcopy.go index f4de942161..300f42cbba 100644 --- a/vendor/k8s.io/api/storage/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/storage/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/storage/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/api/storage/v1alpha1/zz_generated.deepcopy.go index 64a34670b3..d9bc94b250 100644 --- a/vendor/k8s.io/api/storage/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/storage/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/storage/v1alpha1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/storage/v1alpha1/zz_generated.prerelease-lifecycle.go index 44311b4bbf..41114c3c68 100644 --- a/vendor/k8s.io/api/storage/v1alpha1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/storage/v1alpha1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/storage/v1beta1/generated.proto b/vendor/k8s.io/api/storage/v1beta1/generated.proto index f72ca6b237..bfe8280d53 100644 --- a/vendor/k8s.io/api/storage/v1beta1/generated.proto +++ b/vendor/k8s.io/api/storage/v1beta1/generated.proto @@ -144,7 +144,7 @@ message CSIDriverSpec { // unset or false and it can be flipped later when storage // capacity information has been published. // - // This field is immutable. + // This field was immutable in Kubernetes <= 1.22 and now is mutable. // // This is a beta field and only available when the CSIStorageCapacity // feature is enabled. The default is false. @@ -156,8 +156,6 @@ message CSIDriverSpec { // Defines if the underlying volume supports changing ownership and // permission of the volume before being mounted. // Refer to the specific FSGroupPolicy values for additional details. - // This field is beta, and is only honored by servers - // that enable the CSIVolumeFSGroupPolicy feature gate. // // This field is immutable. // diff --git a/vendor/k8s.io/api/storage/v1beta1/types.go b/vendor/k8s.io/api/storage/v1beta1/types.go index 9fe5646adc..524d8b5341 100644 --- a/vendor/k8s.io/api/storage/v1beta1/types.go +++ b/vendor/k8s.io/api/storage/v1beta1/types.go @@ -362,7 +362,7 @@ type CSIDriverSpec struct { // unset or false and it can be flipped later when storage // capacity information has been published. // - // This field is immutable. + // This field was immutable in Kubernetes <= 1.22 and now is mutable. // // This is a beta field and only available when the CSIStorageCapacity // feature is enabled. The default is false. @@ -374,8 +374,6 @@ type CSIDriverSpec struct { // Defines if the underlying volume supports changing ownership and // permission of the volume before being mounted. // Refer to the specific FSGroupPolicy values for additional details. - // This field is beta, and is only honored by servers - // that enable the CSIVolumeFSGroupPolicy feature gate. // // This field is immutable. // diff --git a/vendor/k8s.io/api/storage/v1beta1/types_swagger_doc_generated.go b/vendor/k8s.io/api/storage/v1beta1/types_swagger_doc_generated.go index 9e1efa25b4..f4dbf0fefa 100644 --- a/vendor/k8s.io/api/storage/v1beta1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/api/storage/v1beta1/types_swagger_doc_generated.go @@ -52,8 +52,8 @@ var map_CSIDriverSpec = map[string]string{ "attachRequired": "attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the CSIDriverRegistry feature gate is enabled and the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called.\n\nThis field is immutable.", "podInfoOnMount": "If set to true, podInfoOnMount indicates this CSI volume driver requires additional pod information (like podName, podUID, etc.) during mount operations. If set to false, pod information will not be passed on mount. Default is false. The CSI driver specifies podInfoOnMount as part of driver deployment. If true, Kubelet will pass pod information as VolumeContext in the CSI NodePublishVolume() calls. The CSI driver is responsible for parsing and validating the information passed in as VolumeContext. The following VolumeConext will be passed if podInfoOnMount is set to true. This list might grow, but the prefix will be used. \"csi.storage.k8s.io/pod.name\": pod.Name \"csi.storage.k8s.io/pod.namespace\": pod.Namespace \"csi.storage.k8s.io/pod.uid\": string(pod.UID) \"csi.storage.k8s.io/ephemeral\": \"true\" if the volume is an ephemeral inline volume\n defined by a CSIVolumeSource, otherwise \"false\"\n\n\"csi.storage.k8s.io/ephemeral\" is a new feature in Kubernetes 1.16. It is only required for drivers which support both the \"Persistent\" and \"Ephemeral\" VolumeLifecycleMode. Other drivers can leave pod info disabled and/or ignore this field. As Kubernetes 1.15 doesn't support this field, drivers can only support one mode when deployed on such a cluster and the deployment determines which mode that is, for example via a command line parameter of the driver.\n\nThis field is immutable.", "volumeLifecycleModes": "VolumeLifecycleModes defines what kind of volumes this CSI volume driver supports. The default if the list is empty is \"Persistent\", which is the usage defined by the CSI specification and implemented in Kubernetes via the usual PV/PVC mechanism. The other mode is \"Ephemeral\". In this mode, volumes are defined inline inside the pod spec with CSIVolumeSource and their lifecycle is tied to the lifecycle of that pod. A driver has to be aware of this because it is only going to get a NodePublishVolume call for such a volume. For more information about implementing this mode, see https://kubernetes-csi.github.io/docs/ephemeral-local-volumes.html A driver can support one or more of these modes and more modes may be added in the future.\n\nThis field is immutable.", - "storageCapacity": "If set to true, storageCapacity indicates that the CSI volume driver wants pod scheduling to consider the storage capacity that the driver deployment will report by creating CSIStorageCapacity objects with capacity information.\n\nThe check can be enabled immediately when deploying a driver. In that case, provisioning new volumes with late binding will pause until the driver deployment has published some suitable CSIStorageCapacity object.\n\nAlternatively, the driver can be deployed with the field unset or false and it can be flipped later when storage capacity information has been published.\n\nThis field is immutable.\n\nThis is a beta field and only available when the CSIStorageCapacity feature is enabled. The default is false.", - "fsGroupPolicy": "Defines if the underlying volume supports changing ownership and permission of the volume before being mounted. Refer to the specific FSGroupPolicy values for additional details. This field is beta, and is only honored by servers that enable the CSIVolumeFSGroupPolicy feature gate.\n\nThis field is immutable.\n\nDefaults to ReadWriteOnceWithFSType, which will examine each volume to determine if Kubernetes should modify ownership and permissions of the volume. With the default policy the defined fsGroup will only be applied if a fstype is defined and the volume's access mode contains ReadWriteOnce.", + "storageCapacity": "If set to true, storageCapacity indicates that the CSI volume driver wants pod scheduling to consider the storage capacity that the driver deployment will report by creating CSIStorageCapacity objects with capacity information.\n\nThe check can be enabled immediately when deploying a driver. In that case, provisioning new volumes with late binding will pause until the driver deployment has published some suitable CSIStorageCapacity object.\n\nAlternatively, the driver can be deployed with the field unset or false and it can be flipped later when storage capacity information has been published.\n\nThis field was immutable in Kubernetes <= 1.22 and now is mutable.\n\nThis is a beta field and only available when the CSIStorageCapacity feature is enabled. The default is false.", + "fsGroupPolicy": "Defines if the underlying volume supports changing ownership and permission of the volume before being mounted. Refer to the specific FSGroupPolicy values for additional details.\n\nThis field is immutable.\n\nDefaults to ReadWriteOnceWithFSType, which will examine each volume to determine if Kubernetes should modify ownership and permissions of the volume. With the default policy the defined fsGroup will only be applied if a fstype is defined and the volume's access mode contains ReadWriteOnce.", "tokenRequests": "TokenRequests indicates the CSI driver needs pods' service account tokens it is mounting volume for to do necessary authentication. Kubelet will pass the tokens in VolumeContext in the CSI NodePublishVolume calls. The CSI driver should parse and validate the following VolumeContext: \"csi.storage.k8s.io/serviceAccount.tokens\": {\n \"\": {\n \"token\": ,\n \"expirationTimestamp\": ,\n },\n ...\n}\n\nNote: Audience in each TokenRequest should be different and at most one token is empty string. To receive a new token after expiry, RequiresRepublish can be used to trigger NodePublishVolume periodically.", "requiresRepublish": "RequiresRepublish indicates the CSI driver wants `NodePublishVolume` being periodically called to reflect any possible change in the mounted volume. This field defaults to false.\n\nNote: After a successful initial NodePublishVolume call, subsequent calls to NodePublishVolume should only update the contents of the volume. New mount points will not be seen by a running container.", } diff --git a/vendor/k8s.io/api/storage/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/api/storage/v1beta1/zz_generated.deepcopy.go index 9b7e675ee6..5411ed8c00 100644 --- a/vendor/k8s.io/api/storage/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/api/storage/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/api/storage/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/api/storage/v1beta1/zz_generated.prerelease-lifecycle.go index 275b5d5dbe..7b69b2cbca 100644 --- a/vendor/k8s.io/api/storage/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/api/storage/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types_jsonschema.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types_jsonschema.go index c0ac63e575..f402c416d6 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types_jsonschema.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types_jsonschema.go @@ -122,6 +122,80 @@ type JSONSchemaProps struct { // Atomic maps will be entirely replaced when updated. // +optional XMapType *string + + // x-kubernetes-validations -kubernetes-validations describes a list of validation rules written in the CEL expression language. + // This field is an alpha-level. Using this field requires the feature gate `CustomResourceValidationExpressions` to be enabled. + // +patchMergeKey=rule + // +patchStrategy=merge + // +listType=map + // +listMapKey=rule + XValidations ValidationRules +} + +// ValidationRules describes a list of validation rules written in the CEL expression language. +type ValidationRules []ValidationRule + +// ValidationRule describes a validation rule written in the CEL expression language. +type ValidationRule struct { + // Rule represents the expression which will be evaluated by CEL. + // ref: https://github.com/google/cel-spec + // The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. + // The `self` variable in the CEL expression is bound to the scoped value. + // Example: + // - Rule scoped to the root of a resource with a status subresource: {"rule": "self.status.actual <= self.spec.maxDesired"} + // + // If the Rule is scoped to an object with properties, the accessible properties of the object are field selectable + // via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as + // absent fields in CEL expressions. + // If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map + // are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map + // are accessible via CEL macros and functions such as `self.all(...)`. + // If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and + // functions. + // If the Rule is scoped to a scalar, `self` is bound to the scalar value. + // Examples: + // - Rule scoped to a map of objects: {"rule": "self.components['Widget'].priority < 10"} + // - Rule scoped to a list of integers: {"rule": "self.values.all(value, value >= 0 && value < 100)"} + // - Rule scoped to a string value: {"rule": "self.startsWith('kube')"} + // + // The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the + // object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible. + // + // Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL + // expressions. This includes: + // - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. + // - Object properties where the property schema is of an "unknown type". An "unknown type" is recursively defined as: + // - A schema with no type and x-kubernetes-preserve-unknown-fields set to true + // - An array where the items schema is of an "unknown type" + // - An object where the additionalProperties schema is of an "unknown type" + // + // Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. + // Accessible property names are escaped according to the following rules when accessed in the expression: + // - '__' escapes to '__underscores__' + // - '.' escapes to '__dot__' + // - '-' escapes to '__dash__' + // - '/' escapes to '__slash__' + // - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: + // "true", "false", "null", "in", "as", "break", "const", "continue", "else", "for", "function", "if", + // "import", "let", "loop", "package", "namespace", "return". + // Examples: + // - Rule accessing a property named "namespace": {"rule": "self.__namespace__ > 0"} + // - Rule accessing a property named "x-prop": {"rule": "self.x__dash__prop > 0"} + // - Rule accessing a property named "redact__d": {"rule": "self.redact__underscores__d > 0"} + // + // Equality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. + // Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: + // - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and + // non-intersecting elements in `Y` are appended, retaining their partial order. + // - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values + // are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with + // non-intersecting keys are appended, retaining their partial order. + Rule string + // Message represents the message displayed when validation fails. The message is required if the Rule contains + // line breaks. The message must not contain line breaks. + // If unset, the message is "failed rule: {Rule}". + // e.g. "must be a URL with the host matching spec.host" + Message string } // JSON represents any valid JSON value. diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/conversion.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/conversion.go index c056dd91ff..9bcbe50267 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/conversion.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/conversion.go @@ -17,6 +17,8 @@ limitations under the License. package v1 import ( + "bytes" + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" apiequality "k8s.io/apimachinery/pkg/api/equality" "k8s.io/apimachinery/pkg/conversion" @@ -36,20 +38,29 @@ func Convert_apiextensions_JSONSchemaProps_To_v1_JSONSchemaProps(in *apiextensio return nil } +var nullLiteral = []byte(`null`) + func Convert_apiextensions_JSON_To_v1_JSON(in *apiextensions.JSON, out *JSON, s conversion.Scope) error { raw, err := json.Marshal(*in) if err != nil { return err } - out.Raw = raw + if len(raw) == 0 || bytes.Equal(raw, nullLiteral) { + // match JSON#UnmarshalJSON treatment of literal nulls + out.Raw = nil + } else { + out.Raw = raw + } return nil } func Convert_v1_JSON_To_apiextensions_JSON(in *JSON, out *apiextensions.JSON, s conversion.Scope) error { if in != nil { var i interface{} - if err := json.Unmarshal(in.Raw, &i); err != nil { - return err + if len(in.Raw) > 0 && !bytes.Equal(in.Raw, nullLiteral) { + if err := json.Unmarshal(in.Raw, &i); err != nil { + return err + } } *out = i } else { @@ -103,7 +114,7 @@ func Convert_apiextensions_CustomResourceDefinitionSpec_To_v1_CustomResourceDefi func Convert_v1_CustomResourceDefinitionSpec_To_apiextensions_CustomResourceDefinitionSpec(in *CustomResourceDefinitionSpec, out *apiextensions.CustomResourceDefinitionSpec, s conversion.Scope) error { if err := autoConvert_v1_CustomResourceDefinitionSpec_To_apiextensions_CustomResourceDefinitionSpec(in, out, s); err != nil { - return nil + return err } if len(out.Versions) == 0 { diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/generated.pb.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/generated.pb.go index f3388ffe85..86403d68e9 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/generated.pb.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/generated.pb.go @@ -692,10 +692,38 @@ func (m *ServiceReference) XXX_DiscardUnknown() { var xxx_messageInfo_ServiceReference proto.InternalMessageInfo +func (m *ValidationRule) Reset() { *m = ValidationRule{} } +func (*ValidationRule) ProtoMessage() {} +func (*ValidationRule) Descriptor() ([]byte, []int) { + return fileDescriptor_f5a35c9667703937, []int{23} +} +func (m *ValidationRule) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidationRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ValidationRule) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidationRule.Merge(m, src) +} +func (m *ValidationRule) XXX_Size() int { + return m.Size() +} +func (m *ValidationRule) XXX_DiscardUnknown() { + xxx_messageInfo_ValidationRule.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidationRule proto.InternalMessageInfo + func (m *WebhookClientConfig) Reset() { *m = WebhookClientConfig{} } func (*WebhookClientConfig) ProtoMessage() {} func (*WebhookClientConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_f5a35c9667703937, []int{23} + return fileDescriptor_f5a35c9667703937, []int{24} } func (m *WebhookClientConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -723,7 +751,7 @@ var xxx_messageInfo_WebhookClientConfig proto.InternalMessageInfo func (m *WebhookConversion) Reset() { *m = WebhookConversion{} } func (*WebhookConversion) ProtoMessage() {} func (*WebhookConversion) Descriptor() ([]byte, []int) { - return fileDescriptor_f5a35c9667703937, []int{24} + return fileDescriptor_f5a35c9667703937, []int{25} } func (m *WebhookConversion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -776,6 +804,7 @@ func init() { proto.RegisterType((*JSONSchemaPropsOrBool)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool") proto.RegisterType((*JSONSchemaPropsOrStringArray)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArray") proto.RegisterType((*ServiceReference)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1.ServiceReference") + proto.RegisterType((*ValidationRule)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1.ValidationRule") proto.RegisterType((*WebhookClientConfig)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig") proto.RegisterType((*WebhookConversion)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1.WebhookConversion") } @@ -785,194 +814,198 @@ func init() { } var fileDescriptor_f5a35c9667703937 = []byte{ - // 2989 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdf, 0x6f, 0x5c, 0x47, - 0xf5, 0xcf, 0x5d, 0x7b, 0xed, 0xf5, 0xd8, 0x8e, 0xed, 0x49, 0xec, 0xef, 0x8d, 0x9b, 0x78, 0x9d, - 0xed, 0xb7, 0xc1, 0x6d, 0xd3, 0x75, 0x63, 0x5a, 0x5a, 0x2a, 0x04, 0xf2, 0xda, 0x4e, 0x71, 0x63, - 0xc7, 0xd6, 0x6c, 0x92, 0xba, 0x2d, 0x52, 0x3b, 0xde, 0x3b, 0x5e, 0xdf, 0xfa, 0xfe, 0xca, 0x9d, - 0x7b, 0xd7, 0xb6, 0x04, 0x52, 0x05, 0xaa, 0x80, 0x4a, 0x50, 0x1e, 0x10, 0x3c, 0x21, 0x84, 0x50, - 0x1f, 0xe0, 0x01, 0xde, 0xe0, 0x5f, 0xe8, 0x0b, 0x52, 0x9f, 0xa0, 0x12, 0xd2, 0x8a, 0x2e, 0x7f, - 0x02, 0x20, 0x84, 0x1f, 0x10, 0x9a, 0x1f, 0x77, 0xee, 0xec, 0xdd, 0xdd, 0x24, 0x8a, 0xd7, 0xed, - 0x9b, 0xf7, 0xfc, 0xfa, 0x9c, 0x39, 0x73, 0xe6, 0xcc, 0x99, 0x73, 0x0d, 0xf0, 0xc1, 0xcb, 0xb4, - 0x6c, 0xfb, 0x8b, 0x07, 0xf1, 0x2e, 0x09, 0x3d, 0x12, 0x11, 0xba, 0xd8, 0x20, 0x9e, 0xe5, 0x87, - 0x8b, 0x92, 0x81, 0x03, 0x9b, 0x1c, 0x45, 0xc4, 0xa3, 0xb6, 0xef, 0xd1, 0xe7, 0x70, 0x60, 0x53, - 0x12, 0x36, 0x48, 0xb8, 0x18, 0x1c, 0xd4, 0x19, 0x8f, 0xb6, 0x0b, 0x2c, 0x36, 0x6e, 0x2c, 0xd6, - 0x89, 0x47, 0x42, 0x1c, 0x11, 0xab, 0x1c, 0x84, 0x7e, 0xe4, 0xc3, 0x97, 0x85, 0xa5, 0x72, 0x9b, - 0xe0, 0xdb, 0xca, 0x52, 0x39, 0x38, 0xa8, 0x33, 0x1e, 0x6d, 0x17, 0x28, 0x37, 0x6e, 0xcc, 0x3e, - 0x57, 0xb7, 0xa3, 0xfd, 0x78, 0xb7, 0x5c, 0xf3, 0xdd, 0xc5, 0xba, 0x5f, 0xf7, 0x17, 0xb9, 0xc1, - 0xdd, 0x78, 0x8f, 0xff, 0xe2, 0x3f, 0xf8, 0x5f, 0x02, 0x68, 0xf6, 0x85, 0xd4, 0x65, 0x17, 0xd7, - 0xf6, 0x6d, 0x8f, 0x84, 0xc7, 0xa9, 0x9f, 0x2e, 0x89, 0x70, 0x17, 0xf7, 0x66, 0x17, 0x7b, 0x69, - 0x85, 0xb1, 0x17, 0xd9, 0x2e, 0xe9, 0x50, 0xf8, 0xca, 0xc3, 0x14, 0x68, 0x6d, 0x9f, 0xb8, 0x38, - 0xab, 0x57, 0x3a, 0x31, 0xc0, 0xd4, 0x8a, 0xef, 0x35, 0x48, 0xc8, 0x16, 0x88, 0xc8, 0xfd, 0x98, - 0xd0, 0x08, 0x56, 0xc0, 0x40, 0x6c, 0x5b, 0xa6, 0x31, 0x6f, 0x2c, 0x8c, 0x54, 0x9e, 0xff, 0xb8, - 0x59, 0x3c, 0xd7, 0x6a, 0x16, 0x07, 0xee, 0xae, 0xaf, 0x9e, 0x34, 0x8b, 0x57, 0x7b, 0x21, 0x45, - 0xc7, 0x01, 0xa1, 0xe5, 0xbb, 0xeb, 0xab, 0x88, 0x29, 0xc3, 0x57, 0xc1, 0x94, 0x45, 0xa8, 0x1d, - 0x12, 0x6b, 0x79, 0x7b, 0xfd, 0x9e, 0xb0, 0x6f, 0xe6, 0xb8, 0xc5, 0x4b, 0xd2, 0xe2, 0xd4, 0x6a, - 0x56, 0x00, 0x75, 0xea, 0xc0, 0x1d, 0x30, 0xec, 0xef, 0xbe, 0x4b, 0x6a, 0x11, 0x35, 0x07, 0xe6, - 0x07, 0x16, 0x46, 0x97, 0x9e, 0x2b, 0xa7, 0x9b, 0xa7, 0x5c, 0xe0, 0x3b, 0x26, 0x17, 0x5b, 0x46, - 0xf8, 0x70, 0x2d, 0xd9, 0xb4, 0xca, 0x84, 0x44, 0x1b, 0xde, 0x12, 0x56, 0x50, 0x62, 0xae, 0xf4, - 0xeb, 0x1c, 0x80, 0xfa, 0xe2, 0x69, 0xe0, 0x7b, 0x94, 0xf4, 0x65, 0xf5, 0x14, 0x4c, 0xd6, 0xb8, - 0xe5, 0x88, 0x58, 0x12, 0xd7, 0xcc, 0x3d, 0x8e, 0xf7, 0xa6, 0xc4, 0x9f, 0x5c, 0xc9, 0x98, 0x43, - 0x1d, 0x00, 0xf0, 0x0e, 0x18, 0x0a, 0x09, 0x8d, 0x9d, 0xc8, 0x1c, 0x98, 0x37, 0x16, 0x46, 0x97, - 0xae, 0xf7, 0x84, 0xe2, 0xa9, 0xcd, 0x92, 0xaf, 0xdc, 0xb8, 0x51, 0xae, 0x46, 0x38, 0x8a, 0x69, - 0xe5, 0xbc, 0x44, 0x1a, 0x42, 0xdc, 0x06, 0x92, 0xb6, 0x4a, 0xff, 0x35, 0xc0, 0xa4, 0x1e, 0xa5, - 0x86, 0x4d, 0x0e, 0x61, 0x08, 0x86, 0x43, 0x91, 0x2c, 0x3c, 0x4e, 0xa3, 0x4b, 0xb7, 0xca, 0x8f, - 0x7b, 0xa2, 0xca, 0x1d, 0xf9, 0x57, 0x19, 0x65, 0xdb, 0x25, 0x7f, 0xa0, 0x04, 0x08, 0x36, 0x40, - 0x21, 0x94, 0x7b, 0xc4, 0x13, 0x69, 0x74, 0x69, 0xa3, 0x3f, 0xa0, 0xc2, 0x66, 0x65, 0xac, 0xd5, - 0x2c, 0x16, 0x92, 0x5f, 0x48, 0x61, 0x95, 0x7e, 0x99, 0x03, 0x73, 0x2b, 0x31, 0x8d, 0x7c, 0x17, - 0x11, 0xea, 0xc7, 0x61, 0x8d, 0xac, 0xf8, 0x4e, 0xec, 0x7a, 0xab, 0x64, 0xcf, 0xf6, 0xec, 0x88, - 0xe5, 0xe8, 0x3c, 0x18, 0xf4, 0xb0, 0x4b, 0x64, 0xce, 0x8c, 0xc9, 0x48, 0x0e, 0xde, 0xc6, 0x2e, - 0x41, 0x9c, 0xc3, 0x24, 0x58, 0x8a, 0xc8, 0x13, 0xa0, 0x24, 0xee, 0x1c, 0x07, 0x04, 0x71, 0x0e, - 0xbc, 0x06, 0x86, 0xf6, 0xfc, 0xd0, 0xc5, 0x62, 0xf7, 0x46, 0xd2, 0xfd, 0xb8, 0xc9, 0xa9, 0x48, - 0x72, 0xe1, 0x8b, 0x60, 0xd4, 0x22, 0xb4, 0x16, 0xda, 0x01, 0x83, 0x36, 0x07, 0xb9, 0xf0, 0x05, - 0x29, 0x3c, 0xba, 0x9a, 0xb2, 0x90, 0x2e, 0x07, 0xaf, 0x83, 0x42, 0x10, 0xda, 0x7e, 0x68, 0x47, - 0xc7, 0x66, 0x7e, 0xde, 0x58, 0xc8, 0x57, 0x26, 0xa5, 0x4e, 0x61, 0x5b, 0xd2, 0x91, 0x92, 0x60, - 0xd2, 0xef, 0x52, 0xdf, 0xdb, 0xc6, 0xd1, 0xbe, 0x39, 0xc4, 0x11, 0x94, 0xf4, 0x6b, 0xd5, 0xad, - 0xdb, 0x8c, 0x8e, 0x94, 0x44, 0xe9, 0xcf, 0x06, 0x30, 0xb3, 0x11, 0x4a, 0xc2, 0x0b, 0x6f, 0x82, - 0x02, 0x8d, 0x58, 0xcd, 0xa9, 0x1f, 0xcb, 0xf8, 0x3c, 0x93, 0x98, 0xaa, 0x4a, 0xfa, 0x49, 0xb3, - 0x38, 0x93, 0x6a, 0x24, 0x54, 0x1e, 0x1b, 0xa5, 0xcb, 0x52, 0xee, 0x90, 0xec, 0xee, 0xfb, 0xfe, - 0x81, 0xdc, 0xfd, 0x53, 0xa4, 0xdc, 0xeb, 0xc2, 0x50, 0x8a, 0x29, 0x52, 0x4e, 0x92, 0x51, 0x02, - 0x54, 0xfa, 0x4f, 0x2e, 0xbb, 0x30, 0x6d, 0xd3, 0xdf, 0x01, 0x05, 0x76, 0x84, 0x2c, 0x1c, 0x61, - 0x79, 0x08, 0x9e, 0x7f, 0xb4, 0x03, 0x27, 0xce, 0xeb, 0x26, 0x89, 0x70, 0x05, 0xca, 0x50, 0x80, - 0x94, 0x86, 0x94, 0x55, 0x78, 0x04, 0x06, 0x69, 0x40, 0x6a, 0x72, 0xbd, 0xf7, 0x4e, 0x91, 0xed, - 0x3d, 0xd6, 0x50, 0x0d, 0x48, 0x2d, 0x4d, 0x46, 0xf6, 0x0b, 0x71, 0x44, 0xf8, 0x9e, 0x01, 0x86, - 0x28, 0xaf, 0x0b, 0xb2, 0x96, 0xec, 0x9c, 0x01, 0x78, 0xa6, 0xee, 0x88, 0xdf, 0x48, 0xe2, 0x96, - 0xfe, 0x99, 0x03, 0x57, 0x7b, 0xa9, 0xae, 0xf8, 0x9e, 0x25, 0x36, 0x61, 0x5d, 0x9e, 0x2b, 0x91, - 0x59, 0x2f, 0xea, 0xe7, 0xea, 0xa4, 0x59, 0x7c, 0xea, 0xa1, 0x06, 0xb4, 0x03, 0xf8, 0x55, 0xb5, - 0x64, 0x71, 0x48, 0xaf, 0xb6, 0x3b, 0x76, 0xd2, 0x2c, 0x4e, 0x28, 0xb5, 0x76, 0x5f, 0x61, 0x03, - 0x40, 0x07, 0xd3, 0xe8, 0x4e, 0x88, 0x3d, 0x2a, 0xcc, 0xda, 0x2e, 0x91, 0x91, 0x7b, 0xe6, 0xd1, - 0x92, 0x82, 0x69, 0x54, 0x66, 0x25, 0x24, 0xdc, 0xe8, 0xb0, 0x86, 0xba, 0x20, 0xb0, 0x9a, 0x11, - 0x12, 0x4c, 0x55, 0x19, 0xd0, 0x6a, 0x38, 0xa3, 0x22, 0xc9, 0x85, 0x4f, 0x83, 0x61, 0x97, 0x50, - 0x8a, 0xeb, 0x84, 0x9f, 0xfd, 0x91, 0xf4, 0x52, 0xdc, 0x14, 0x64, 0x94, 0xf0, 0x4b, 0xff, 0x32, - 0xc0, 0xe5, 0x5e, 0x51, 0xdb, 0xb0, 0x69, 0x04, 0xbf, 0xd5, 0x91, 0xf6, 0xe5, 0x47, 0x5b, 0x21, - 0xd3, 0xe6, 0x49, 0xaf, 0x4a, 0x49, 0x42, 0xd1, 0x52, 0xfe, 0x10, 0xe4, 0xed, 0x88, 0xb8, 0xc9, - 0x6d, 0x89, 0xfa, 0x9f, 0x76, 0x95, 0x71, 0x09, 0x9f, 0x5f, 0x67, 0x40, 0x48, 0xe0, 0x95, 0x3e, - 0xca, 0x81, 0x2b, 0xbd, 0x54, 0x58, 0x1d, 0xa7, 0x2c, 0xd8, 0x81, 0x13, 0x87, 0xd8, 0x91, 0xc9, - 0xa6, 0x82, 0xbd, 0xcd, 0xa9, 0x48, 0x72, 0x59, 0xed, 0xa4, 0xb6, 0x57, 0x8f, 0x1d, 0x1c, 0xca, - 0x4c, 0x52, 0x0b, 0xae, 0x4a, 0x3a, 0x52, 0x12, 0xb0, 0x0c, 0x00, 0xdd, 0xf7, 0xc3, 0x88, 0x63, - 0xf0, 0x0e, 0x67, 0xa4, 0x72, 0x9e, 0x55, 0x84, 0xaa, 0xa2, 0x22, 0x4d, 0x82, 0x5d, 0x24, 0x07, - 0xb6, 0x67, 0xc9, 0x0d, 0x57, 0x67, 0xf7, 0x96, 0xed, 0x59, 0x88, 0x73, 0x18, 0xbe, 0x63, 0xd3, - 0x88, 0x51, 0xe4, 0x6e, 0xb7, 0x05, 0x9c, 0x4b, 0x2a, 0x09, 0x86, 0x5f, 0x63, 0x05, 0xd6, 0x0f, - 0x6d, 0x42, 0xcd, 0xa1, 0x14, 0x7f, 0x45, 0x51, 0x91, 0x26, 0x51, 0xfa, 0xeb, 0x60, 0xef, 0xfc, - 0x60, 0x05, 0x04, 0x3e, 0x09, 0xf2, 0xf5, 0xd0, 0x8f, 0x03, 0x19, 0x25, 0x15, 0xed, 0x57, 0x19, - 0x11, 0x09, 0x1e, 0xfc, 0x36, 0xc8, 0x7b, 0x72, 0xc1, 0x2c, 0x83, 0x5e, 0xef, 0xff, 0x36, 0xf3, - 0x68, 0xa5, 0xe8, 0x22, 0x90, 0x02, 0x14, 0xbe, 0x00, 0xf2, 0xb4, 0xe6, 0x07, 0x44, 0x06, 0x71, - 0x2e, 0x11, 0xaa, 0x32, 0xe2, 0x49, 0xb3, 0x38, 0x9e, 0x98, 0xe3, 0x04, 0x24, 0x84, 0xe1, 0xf7, - 0x0d, 0x50, 0x90, 0xd7, 0x05, 0x35, 0x87, 0x79, 0x7a, 0xbe, 0xd1, 0x7f, 0xbf, 0x65, 0xdb, 0x9b, - 0xee, 0x99, 0x24, 0x50, 0xa4, 0xc0, 0xe1, 0x77, 0x0d, 0x00, 0x6a, 0xea, 0xee, 0x32, 0x47, 0x78, - 0x0c, 0xfb, 0x76, 0x54, 0xb4, 0x5b, 0x51, 0x24, 0x42, 0xda, 0x2a, 0x69, 0xa8, 0xb0, 0x0a, 0xa6, - 0x83, 0x90, 0x70, 0xdb, 0x77, 0xbd, 0x03, 0xcf, 0x3f, 0xf4, 0x6e, 0xda, 0xc4, 0xb1, 0xa8, 0x09, - 0xe6, 0x8d, 0x85, 0x42, 0xe5, 0x8a, 0xf4, 0x7f, 0x7a, 0xbb, 0x9b, 0x10, 0xea, 0xae, 0x5b, 0x7a, - 0x7f, 0x20, 0xdb, 0x6b, 0x65, 0xef, 0x0b, 0xf8, 0xa1, 0x58, 0xbc, 0xa8, 0xc3, 0xd4, 0x34, 0xf8, - 0x46, 0xbc, 0xd5, 0xff, 0x8d, 0x50, 0xb5, 0x3e, 0xbd, 0xa4, 0x15, 0x89, 0x22, 0xcd, 0x05, 0xf8, - 0x53, 0x03, 0x8c, 0xe3, 0x5a, 0x8d, 0x04, 0x11, 0xb1, 0xc4, 0x31, 0xce, 0x9d, 0x6d, 0x56, 0x4f, - 0x4b, 0x87, 0xc6, 0x97, 0x75, 0x54, 0xd4, 0xee, 0x04, 0x7c, 0x05, 0x9c, 0xa7, 0x91, 0x1f, 0x12, - 0x2b, 0xc9, 0x20, 0x59, 0x5d, 0x60, 0xab, 0x59, 0x3c, 0x5f, 0x6d, 0xe3, 0xa0, 0x8c, 0x64, 0xe9, - 0x93, 0x3c, 0x28, 0x3e, 0x24, 0x43, 0x1f, 0xa1, 0xe9, 0xbd, 0x06, 0x86, 0xf8, 0x4a, 0x2d, 0x1e, - 0x90, 0x82, 0x76, 0xd5, 0x73, 0x2a, 0x92, 0x5c, 0x76, 0x3d, 0x31, 0x7c, 0x76, 0x3d, 0x0d, 0x70, - 0x41, 0x75, 0x3d, 0x55, 0x05, 0x19, 0x25, 0x7c, 0xb8, 0x04, 0x80, 0x45, 0x82, 0x90, 0xb0, 0x8a, - 0x64, 0x99, 0xc3, 0x5c, 0x5a, 0xed, 0xcf, 0xaa, 0xe2, 0x20, 0x4d, 0x0a, 0xde, 0x04, 0x30, 0xf9, - 0x65, 0xfb, 0xde, 0xeb, 0x38, 0xf4, 0x6c, 0xaf, 0x6e, 0x16, 0xb8, 0xdb, 0x33, 0xec, 0xb6, 0x5d, - 0xed, 0xe0, 0xa2, 0x2e, 0x1a, 0xb0, 0x01, 0x86, 0xc4, 0x33, 0x9a, 0xd7, 0x8d, 0x3e, 0x9e, 0xb8, - 0x7b, 0xd8, 0xb1, 0x2d, 0x0e, 0x55, 0x01, 0x3c, 0x3c, 0x1c, 0x05, 0x49, 0x34, 0xf8, 0x81, 0x01, - 0xc6, 0x68, 0xbc, 0x1b, 0x4a, 0x69, 0xca, 0xab, 0xfa, 0xe8, 0xd2, 0x9d, 0x7e, 0xc1, 0x57, 0x35, - 0xdb, 0x95, 0xc9, 0x56, 0xb3, 0x38, 0xa6, 0x53, 0x50, 0x1b, 0x36, 0xfc, 0x83, 0x01, 0x4c, 0x6c, - 0x89, 0xd4, 0xc7, 0xce, 0x76, 0x68, 0x7b, 0x11, 0x09, 0xc5, 0x83, 0x48, 0x5c, 0x1f, 0x7d, 0xec, - 0x15, 0xb3, 0xef, 0xac, 0xca, 0xbc, 0xdc, 0x69, 0x73, 0xb9, 0x87, 0x07, 0xa8, 0xa7, 0x6f, 0xa5, - 0x7f, 0x1b, 0xd9, 0xd2, 0xa2, 0xad, 0xb2, 0x5a, 0xc3, 0x0e, 0x81, 0xab, 0x60, 0x92, 0x75, 0xbf, - 0x88, 0x04, 0x8e, 0x5d, 0xc3, 0x94, 0xbf, 0x7e, 0x44, 0x76, 0xab, 0x67, 0x78, 0x35, 0xc3, 0x47, - 0x1d, 0x1a, 0xf0, 0x35, 0x00, 0x45, 0x5b, 0xd8, 0x66, 0x47, 0x74, 0x02, 0xaa, 0xc1, 0xab, 0x76, - 0x48, 0xa0, 0x2e, 0x5a, 0x70, 0x05, 0x4c, 0x39, 0x78, 0x97, 0x38, 0x55, 0xe2, 0x90, 0x5a, 0xe4, - 0x87, 0xdc, 0x94, 0x78, 0x1f, 0x4e, 0xb7, 0x9a, 0xc5, 0xa9, 0x8d, 0x2c, 0x13, 0x75, 0xca, 0x97, - 0xae, 0x66, 0xcf, 0xb2, 0xbe, 0x70, 0xd1, 0x6c, 0xff, 0x2c, 0x07, 0x66, 0x7b, 0x27, 0x05, 0xfc, - 0x8e, 0x6a, 0x8d, 0x45, 0xc7, 0xf7, 0xc6, 0x19, 0xa4, 0x9e, 0x7c, 0x0e, 0x80, 0xce, 0xa7, 0x00, - 0x3c, 0x66, 0xf7, 0x35, 0x76, 0x92, 0x67, 0xff, 0xce, 0x59, 0xa0, 0x33, 0xfb, 0x95, 0x11, 0xd1, - 0x05, 0x60, 0x87, 0x5f, 0xfa, 0xd8, 0x21, 0xa5, 0x8f, 0x3a, 0x9e, 0xb6, 0xe9, 0x61, 0x85, 0x3f, - 0x30, 0xc0, 0x84, 0x1f, 0x10, 0x6f, 0x79, 0x7b, 0xfd, 0xde, 0x97, 0xc5, 0xa1, 0x95, 0x01, 0x5a, - 0x7f, 0x7c, 0x17, 0xd9, 0xfb, 0x5a, 0xd8, 0xda, 0x0e, 0xfd, 0x80, 0x56, 0x2e, 0xb4, 0x9a, 0xc5, - 0x89, 0xad, 0x76, 0x14, 0x94, 0x85, 0x2d, 0xb9, 0x60, 0x7a, 0xed, 0x28, 0x22, 0xa1, 0x87, 0x9d, - 0x55, 0xbf, 0x16, 0xbb, 0xc4, 0x8b, 0x84, 0x8f, 0x99, 0x71, 0x81, 0xf1, 0x88, 0xe3, 0x82, 0x2b, - 0x60, 0x20, 0x0e, 0x1d, 0x99, 0xb5, 0xa3, 0x6a, 0x08, 0x86, 0x36, 0x10, 0xa3, 0x97, 0xae, 0x82, - 0x41, 0xe6, 0x27, 0xbc, 0x04, 0x06, 0x42, 0x7c, 0xc8, 0xad, 0x8e, 0x55, 0x86, 0x99, 0x08, 0xc2, - 0x87, 0x88, 0xd1, 0x4a, 0x7f, 0x29, 0x82, 0x89, 0xcc, 0x5a, 0xe0, 0x2c, 0xc8, 0xa9, 0xc9, 0x1a, - 0x90, 0x46, 0x73, 0xeb, 0xab, 0x28, 0x67, 0x5b, 0xf0, 0x25, 0x55, 0x5d, 0x05, 0x68, 0x51, 0x5d, - 0x16, 0x9c, 0xca, 0xda, 0xb2, 0xd4, 0x1c, 0x73, 0x24, 0x29, 0x8f, 0xcc, 0x07, 0xb2, 0x27, 0x4f, - 0x85, 0xf0, 0x81, 0xec, 0x21, 0x46, 0x7b, 0xdc, 0x59, 0x49, 0x32, 0xac, 0xc9, 0x3f, 0xc2, 0xb0, - 0x66, 0xe8, 0x81, 0xc3, 0x9a, 0x27, 0x41, 0x3e, 0xb2, 0x23, 0x87, 0xf0, 0x9b, 0x4a, 0x6b, 0x86, - 0xef, 0x30, 0x22, 0x12, 0x3c, 0x48, 0xc0, 0xb0, 0x45, 0xf6, 0x70, 0xec, 0x44, 0xfc, 0x52, 0x1a, - 0x5d, 0xfa, 0xfa, 0xe9, 0xb2, 0x47, 0x0c, 0x33, 0x56, 0x85, 0x49, 0x94, 0xd8, 0x86, 0x4f, 0x81, - 0x61, 0x17, 0x1f, 0xd9, 0x6e, 0xec, 0xf2, 0x8e, 0xd1, 0x10, 0x62, 0x9b, 0x82, 0x84, 0x12, 0x1e, - 0x2b, 0x82, 0xe4, 0xa8, 0xe6, 0xc4, 0xd4, 0x6e, 0x10, 0xc9, 0x94, 0x2d, 0x9d, 0x2a, 0x82, 0x6b, - 0x19, 0x3e, 0xea, 0xd0, 0xe0, 0x60, 0xb6, 0xc7, 0x95, 0x47, 0x35, 0x30, 0x41, 0x42, 0x09, 0xaf, - 0x1d, 0x4c, 0xca, 0x8f, 0xf5, 0x02, 0x93, 0xca, 0x1d, 0x1a, 0xf0, 0x59, 0x30, 0xe2, 0xe2, 0xa3, - 0x0d, 0xe2, 0xd5, 0xa3, 0x7d, 0x73, 0x7c, 0xde, 0x58, 0x18, 0xa8, 0x8c, 0xb7, 0x9a, 0xc5, 0x91, - 0xcd, 0x84, 0x88, 0x52, 0x3e, 0x17, 0xb6, 0x3d, 0x29, 0x7c, 0x5e, 0x13, 0x4e, 0x88, 0x28, 0xe5, - 0xb3, 0xce, 0x24, 0xc0, 0x11, 0x3b, 0x57, 0xe6, 0x44, 0xfb, 0xc3, 0x79, 0x5b, 0x90, 0x51, 0xc2, - 0x87, 0x0b, 0xa0, 0xe0, 0xe2, 0x23, 0xfe, 0xa6, 0x34, 0x27, 0xb9, 0x59, 0x3e, 0x50, 0xdc, 0x94, - 0x34, 0xa4, 0xb8, 0x5c, 0xd2, 0xf6, 0x84, 0xe4, 0x94, 0x26, 0x29, 0x69, 0x48, 0x71, 0x59, 0xfe, - 0xc6, 0x9e, 0x7d, 0x3f, 0x26, 0x42, 0x18, 0xf2, 0xc8, 0xa8, 0xfc, 0xbd, 0x9b, 0xb2, 0x90, 0x2e, - 0xc7, 0xde, 0x74, 0x6e, 0xec, 0x44, 0x76, 0xe0, 0x90, 0xad, 0x3d, 0xf3, 0x02, 0x8f, 0x3f, 0x6f, - 0xe5, 0x37, 0x15, 0x15, 0x69, 0x12, 0xf0, 0x1d, 0x30, 0x48, 0xbc, 0xd8, 0x35, 0x2f, 0xf2, 0xeb, - 0xfb, 0xb4, 0xd9, 0xa7, 0xce, 0xcb, 0x9a, 0x17, 0xbb, 0x88, 0x5b, 0x86, 0x2f, 0x81, 0x71, 0x17, - 0x1f, 0xb1, 0x22, 0x40, 0xc2, 0x88, 0x3d, 0x34, 0xa7, 0xf9, 0xba, 0xa7, 0x58, 0x13, 0xbb, 0xa9, - 0x33, 0x50, 0xbb, 0x1c, 0x57, 0xb4, 0x3d, 0x4d, 0x71, 0x46, 0x53, 0xd4, 0x19, 0xa8, 0x5d, 0x8e, - 0x05, 0x39, 0x24, 0xf7, 0x63, 0x3b, 0x24, 0x96, 0xf9, 0x7f, 0xbc, 0xef, 0x95, 0xf3, 0x5d, 0x41, - 0x43, 0x8a, 0x0b, 0xef, 0x27, 0x23, 0x07, 0x93, 0x1f, 0xbe, 0xed, 0xbe, 0x95, 0xee, 0xad, 0x70, - 0x39, 0x0c, 0xf1, 0xb1, 0xb8, 0x55, 0xf4, 0x61, 0x03, 0xf4, 0x40, 0x1e, 0x3b, 0xce, 0xd6, 0x9e, - 0x79, 0x89, 0x47, 0xbc, 0x8f, 0xb7, 0x85, 0xaa, 0x30, 0xcb, 0xcc, 0x3e, 0x12, 0x30, 0x0c, 0xcf, - 0xf7, 0x58, 0x2e, 0xcc, 0x9e, 0x19, 0xde, 0x16, 0xb3, 0x8f, 0x04, 0x0c, 0x5f, 0x9f, 0x77, 0xbc, - 0xb5, 0x67, 0x3e, 0x71, 0x76, 0xeb, 0x63, 0xf6, 0x91, 0x80, 0x81, 0x16, 0x18, 0xf0, 0xfc, 0xc8, - 0xbc, 0xdc, 0xef, 0xbb, 0x97, 0xdf, 0x26, 0xb7, 0xfd, 0x08, 0x31, 0xf3, 0xf0, 0x47, 0x06, 0x00, - 0x41, 0x9a, 0x89, 0x57, 0x4e, 0x3b, 0x02, 0xc8, 0xa0, 0x95, 0xd3, 0xec, 0x5d, 0xf3, 0xa2, 0xf0, - 0x38, 0x7d, 0xd7, 0x68, 0x59, 0xae, 0x39, 0x00, 0x7f, 0x61, 0x80, 0x8b, 0x7a, 0xbb, 0xab, 0x3c, - 0x9b, 0xe3, 0x71, 0xd8, 0xea, 0x63, 0x22, 0x57, 0x7c, 0xdf, 0xa9, 0x98, 0xad, 0x66, 0xf1, 0xe2, - 0x72, 0x17, 0x40, 0xd4, 0xd5, 0x0d, 0xf8, 0x1b, 0x03, 0x4c, 0xc9, 0xea, 0xa8, 0x39, 0x57, 0xe4, - 0x61, 0x7b, 0xa7, 0x8f, 0x61, 0xcb, 0x42, 0x88, 0xe8, 0xa9, 0xaf, 0x8c, 0x1d, 0x7c, 0xd4, 0xe9, - 0x15, 0xfc, 0xbd, 0x01, 0xc6, 0x2c, 0x12, 0x10, 0xcf, 0x22, 0x5e, 0x8d, 0xb9, 0x39, 0x7f, 0xda, - 0xb9, 0x42, 0xd6, 0xcd, 0x55, 0xcd, 0xba, 0xf0, 0xb0, 0x2c, 0x3d, 0x1c, 0xd3, 0x59, 0x27, 0xcd, - 0xe2, 0x4c, 0xaa, 0xaa, 0x73, 0x50, 0x9b, 0x83, 0xf0, 0xc7, 0x06, 0x98, 0x48, 0xc3, 0x2e, 0x2e, - 0x88, 0xab, 0x67, 0xb3, 0xf1, 0xbc, 0x05, 0x5d, 0x6e, 0xc7, 0x42, 0x59, 0x70, 0xf8, 0x5b, 0x83, - 0x75, 0x5b, 0xc9, 0x5b, 0x8d, 0x9a, 0x25, 0x1e, 0xc1, 0x37, 0xfb, 0x19, 0x41, 0x65, 0x5c, 0x04, - 0xf0, 0x7a, 0xda, 0xc9, 0x29, 0xce, 0x49, 0xb3, 0x38, 0xad, 0xc7, 0x4f, 0x31, 0x90, 0xee, 0x1c, - 0x7c, 0xdf, 0x00, 0x63, 0x24, 0x6d, 0x98, 0xa9, 0xf9, 0xe4, 0x69, 0x43, 0xd7, 0xb5, 0xfd, 0x16, - 0xcf, 0x69, 0x8d, 0x45, 0x51, 0x1b, 0x2c, 0xeb, 0xfd, 0xc8, 0x11, 0x76, 0x03, 0x87, 0x98, 0xff, - 0xdf, 0xbf, 0xde, 0x6f, 0x4d, 0x98, 0x44, 0x89, 0x6d, 0x78, 0x1d, 0x14, 0xbc, 0xd8, 0x71, 0xf0, - 0xae, 0x43, 0xcc, 0xa7, 0x78, 0x17, 0xa1, 0xe6, 0x8b, 0xb7, 0x25, 0x1d, 0x29, 0x09, 0xb8, 0x07, - 0xe6, 0x8f, 0x6e, 0xa9, 0x7f, 0xbe, 0xe8, 0x3a, 0xc0, 0x33, 0xaf, 0x71, 0x2b, 0xb3, 0xad, 0x66, - 0x71, 0x66, 0xa7, 0xfb, 0x88, 0xef, 0xa1, 0x36, 0xe0, 0x5b, 0xe0, 0x09, 0x4d, 0x66, 0xcd, 0xdd, - 0x25, 0x96, 0x45, 0xac, 0xe4, 0xa1, 0x65, 0x7e, 0x89, 0x43, 0xa8, 0x73, 0xbc, 0x93, 0x15, 0x40, - 0x0f, 0xd2, 0x86, 0x1b, 0x60, 0x46, 0x63, 0xaf, 0x7b, 0xd1, 0x56, 0x58, 0x8d, 0x42, 0xdb, 0xab, - 0x9b, 0x0b, 0xdc, 0xee, 0xc5, 0xe4, 0xf4, 0xed, 0x68, 0x3c, 0xd4, 0x43, 0x07, 0x7e, 0xb3, 0xcd, - 0x1a, 0xff, 0x70, 0x81, 0x83, 0x5b, 0xe4, 0x98, 0x9a, 0x4f, 0xf3, 0xe6, 0x82, 0xef, 0xf3, 0x8e, - 0x46, 0x47, 0x3d, 0xe4, 0xe1, 0x37, 0xc0, 0x85, 0x0c, 0x87, 0xbd, 0x2b, 0xcc, 0x67, 0xc4, 0x03, - 0x81, 0x75, 0xa2, 0x3b, 0x09, 0x11, 0x75, 0x93, 0x84, 0x5f, 0x03, 0x50, 0x23, 0x6f, 0xe2, 0x80, - 0xeb, 0x3f, 0x2b, 0xde, 0x2a, 0x6c, 0x47, 0x77, 0x24, 0x0d, 0x75, 0x91, 0x9b, 0x65, 0x6f, 0xd6, - 0x4c, 0xa9, 0x84, 0x93, 0x60, 0xe0, 0x80, 0xc8, 0xaf, 0xb3, 0x88, 0xfd, 0x09, 0xdf, 0x06, 0xf9, - 0x06, 0x76, 0xe2, 0xe4, 0xc5, 0xdd, 0xbf, 0x2b, 0x15, 0x09, 0xbb, 0xaf, 0xe4, 0x5e, 0x36, 0x66, - 0x3f, 0x34, 0xc0, 0x4c, 0xf7, 0xe2, 0xfd, 0x45, 0x79, 0xf4, 0x73, 0x03, 0x4c, 0x75, 0xd4, 0xe9, - 0x2e, 0xce, 0x38, 0xed, 0xce, 0xdc, 0xeb, 0x63, 0xc1, 0x15, 0xf9, 0xc6, 0x1b, 0x47, 0xdd, 0xb3, - 0x1f, 0x1a, 0x60, 0x32, 0x5b, 0xff, 0xbe, 0xa0, 0x28, 0x95, 0x3e, 0xc8, 0x81, 0x99, 0xee, 0xad, - 0x2e, 0x74, 0xd5, 0x23, 0xbe, 0xef, 0x73, 0x90, 0x6e, 0x93, 0xd1, 0xf7, 0x0c, 0x30, 0xfa, 0xae, - 0x92, 0x4b, 0x3e, 0x1a, 0xf6, 0x73, 0xf8, 0x92, 0xdc, 0x30, 0x29, 0x83, 0x22, 0x1d, 0xb2, 0xf4, - 0x3b, 0x03, 0x4c, 0x77, 0xbd, 0x35, 0xe1, 0x35, 0x30, 0x84, 0x1d, 0xc7, 0x3f, 0x14, 0x43, 0x33, - 0x6d, 0xfa, 0xbd, 0xcc, 0xa9, 0x48, 0x72, 0xb5, 0x98, 0xe5, 0x3e, 0x87, 0x98, 0x95, 0xfe, 0x68, - 0x80, 0xcb, 0x0f, 0xca, 0xba, 0xcf, 0x7b, 0x0f, 0x17, 0x40, 0x41, 0xf6, 0xb4, 0xc7, 0x7c, 0xff, - 0x64, 0x11, 0x93, 0x15, 0x81, 0xff, 0x53, 0x8a, 0xf8, 0xab, 0xf4, 0x2b, 0x03, 0x4c, 0x56, 0x49, - 0xd8, 0xb0, 0x6b, 0x04, 0x91, 0x3d, 0x12, 0x12, 0xaf, 0x46, 0xe0, 0x22, 0x18, 0xe1, 0x1f, 0xf5, - 0x02, 0x5c, 0x4b, 0x3e, 0x45, 0x4c, 0xc9, 0x40, 0x8f, 0xdc, 0x4e, 0x18, 0x28, 0x95, 0x51, 0x9f, - 0x2d, 0x72, 0x3d, 0x3f, 0x5b, 0x5c, 0x06, 0x83, 0x41, 0x3a, 0x67, 0x2d, 0x30, 0x2e, 0x1f, 0xad, - 0x72, 0x2a, 0xe7, 0xfa, 0x61, 0xc4, 0x87, 0x49, 0x79, 0xc9, 0xf5, 0xc3, 0x08, 0x71, 0x6a, 0xe9, - 0x4f, 0x06, 0xb8, 0x90, 0xfc, 0x77, 0x89, 0x63, 0x13, 0x2f, 0x5a, 0xf1, 0xbd, 0x3d, 0xbb, 0x0e, - 0x2f, 0x89, 0x79, 0x9a, 0x36, 0xa4, 0x4a, 0x66, 0x69, 0xf0, 0x3e, 0x18, 0xa6, 0x62, 0x55, 0x32, - 0xe0, 0xaf, 0x3d, 0x7e, 0xc0, 0xb3, 0xe1, 0x11, 0xed, 0x40, 0x42, 0x4d, 0x70, 0x58, 0xcc, 0x6b, - 0xb8, 0x12, 0x7b, 0x96, 0x9c, 0xa9, 0x8e, 0x89, 0x98, 0xaf, 0x2c, 0x0b, 0x1a, 0x52, 0xdc, 0xd2, - 0x3f, 0x0c, 0x30, 0xd5, 0xf1, 0xdf, 0x32, 0xf0, 0x7b, 0x06, 0x18, 0xab, 0x69, 0xcb, 0x93, 0x99, - 0xbb, 0x79, 0xfa, 0xff, 0xc8, 0xd1, 0x8c, 0x8a, 0x3b, 0x55, 0xa7, 0xa0, 0x36, 0x50, 0xb8, 0x03, - 0xcc, 0x5a, 0xe6, 0x1f, 0xd3, 0x32, 0x9f, 0xba, 0x2e, 0xb7, 0x9a, 0x45, 0x73, 0xa5, 0x87, 0x0c, - 0xea, 0xa9, 0x5d, 0x59, 0xf8, 0xf8, 0xb3, 0xb9, 0x73, 0x9f, 0x7c, 0x36, 0x77, 0xee, 0xd3, 0xcf, - 0xe6, 0xce, 0xbd, 0xd7, 0x9a, 0x33, 0x3e, 0x6e, 0xcd, 0x19, 0x9f, 0xb4, 0xe6, 0x8c, 0x4f, 0x5b, - 0x73, 0xc6, 0xdf, 0x5a, 0x73, 0xc6, 0x4f, 0xfe, 0x3e, 0x77, 0xee, 0xcd, 0x5c, 0xe3, 0xc6, 0xff, - 0x02, 0x00, 0x00, 0xff, 0xff, 0x59, 0xc7, 0x8d, 0x55, 0xac, 0x2a, 0x00, 0x00, + // 3046 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdf, 0x6f, 0x24, 0x47, + 0xf1, 0xbf, 0x59, 0x7b, 0xed, 0x75, 0xdb, 0x3e, 0xdb, 0x7d, 0x67, 0x7f, 0xe7, 0x9c, 0x3b, 0xaf, + 0x6f, 0xf3, 0xcd, 0x7d, 0x9d, 0xe4, 0xb2, 0xce, 0xf9, 0x9b, 0x90, 0x10, 0x21, 0x90, 0xd7, 0xf6, + 0x25, 0xce, 0xd9, 0x67, 0xab, 0xf7, 0xee, 0xe2, 0x24, 0xa0, 0x64, 0xbc, 0xd3, 0x5e, 0x4f, 0x3c, + 0xbf, 0xae, 0x7b, 0x66, 0x6d, 0x4b, 0x20, 0x45, 0xa0, 0x08, 0x88, 0x04, 0xe1, 0x01, 0x85, 0x27, + 0x84, 0x10, 0xca, 0x03, 0x3c, 0xc0, 0x1b, 0xfc, 0x0b, 0x79, 0x41, 0xca, 0x13, 0x8a, 0x84, 0xb4, + 0x22, 0xcb, 0x3f, 0x80, 0x04, 0x08, 0xe1, 0x07, 0x84, 0xfa, 0xc7, 0xf4, 0xf4, 0xce, 0xee, 0xe6, + 0x4e, 0xe7, 0x75, 0xf2, 0x66, 0x57, 0x55, 0xd7, 0xa7, 0xba, 0xba, 0xba, 0xaa, 0xba, 0x66, 0x81, + 0x75, 0xf0, 0x22, 0x2d, 0x3b, 0xc1, 0xe2, 0x41, 0xbc, 0x8b, 0x89, 0x8f, 0x23, 0x4c, 0x17, 0x1b, + 0xd8, 0xb7, 0x03, 0xb2, 0x28, 0x19, 0x56, 0xe8, 0xe0, 0xa3, 0x08, 0xfb, 0xd4, 0x09, 0x7c, 0xfa, + 0x8c, 0x15, 0x3a, 0x14, 0x93, 0x06, 0x26, 0x8b, 0xe1, 0x41, 0x9d, 0xf1, 0x68, 0xbb, 0xc0, 0x62, + 0xe3, 0xc6, 0x62, 0x1d, 0xfb, 0x98, 0x58, 0x11, 0xb6, 0xcb, 0x21, 0x09, 0xa2, 0x00, 0xbe, 0x28, + 0x34, 0x95, 0xdb, 0x04, 0xdf, 0x52, 0x9a, 0xca, 0xe1, 0x41, 0x9d, 0xf1, 0x68, 0xbb, 0x40, 0xb9, + 0x71, 0x63, 0xf6, 0x99, 0xba, 0x13, 0xed, 0xc7, 0xbb, 0xe5, 0x5a, 0xe0, 0x2d, 0xd6, 0x83, 0x7a, + 0xb0, 0xc8, 0x15, 0xee, 0xc6, 0x7b, 0xfc, 0x3f, 0xfe, 0x0f, 0xff, 0x4b, 0x00, 0xcd, 0x3e, 0x97, + 0x9a, 0xec, 0x59, 0xb5, 0x7d, 0xc7, 0xc7, 0xe4, 0x38, 0xb5, 0xd3, 0xc3, 0x91, 0xd5, 0xc5, 0xbc, + 0xd9, 0xc5, 0x5e, 0xab, 0x48, 0xec, 0x47, 0x8e, 0x87, 0x3b, 0x16, 0x7c, 0xe5, 0x41, 0x0b, 0x68, + 0x6d, 0x1f, 0x7b, 0x56, 0x76, 0x5d, 0xe9, 0xc4, 0x00, 0x53, 0x2b, 0x81, 0xdf, 0xc0, 0x84, 0x6d, + 0x10, 0xe1, 0xfb, 0x31, 0xa6, 0x11, 0xac, 0x80, 0x81, 0xd8, 0xb1, 0x4d, 0x63, 0xde, 0x58, 0x18, + 0xa9, 0x3c, 0xfb, 0x71, 0xb3, 0x78, 0xae, 0xd5, 0x2c, 0x0e, 0xdc, 0x5d, 0x5f, 0x3d, 0x69, 0x16, + 0xaf, 0xf6, 0x42, 0x8a, 0x8e, 0x43, 0x4c, 0xcb, 0x77, 0xd7, 0x57, 0x11, 0x5b, 0x0c, 0x5f, 0x06, + 0x53, 0x36, 0xa6, 0x0e, 0xc1, 0xf6, 0xf2, 0xf6, 0xfa, 0x3d, 0xa1, 0xdf, 0xcc, 0x71, 0x8d, 0x97, + 0xa4, 0xc6, 0xa9, 0xd5, 0xac, 0x00, 0xea, 0x5c, 0x03, 0x77, 0xc0, 0x70, 0xb0, 0xfb, 0x0e, 0xae, + 0x45, 0xd4, 0x1c, 0x98, 0x1f, 0x58, 0x18, 0x5d, 0x7a, 0xa6, 0x9c, 0x1e, 0x9e, 0x32, 0x81, 0x9f, + 0x98, 0xdc, 0x6c, 0x19, 0x59, 0x87, 0x6b, 0xc9, 0xa1, 0x55, 0x26, 0x24, 0xda, 0xf0, 0x96, 0xd0, + 0x82, 0x12, 0x75, 0xa5, 0x5f, 0xe5, 0x00, 0xd4, 0x37, 0x4f, 0xc3, 0xc0, 0xa7, 0xb8, 0x2f, 0xbb, + 0xa7, 0x60, 0xb2, 0xc6, 0x35, 0x47, 0xd8, 0x96, 0xb8, 0x66, 0xee, 0x51, 0xac, 0x37, 0x25, 0xfe, + 0xe4, 0x4a, 0x46, 0x1d, 0xea, 0x00, 0x80, 0x77, 0xc0, 0x10, 0xc1, 0x34, 0x76, 0x23, 0x73, 0x60, + 0xde, 0x58, 0x18, 0x5d, 0xba, 0xde, 0x13, 0x8a, 0x87, 0x36, 0x0b, 0xbe, 0x72, 0xe3, 0x46, 0xb9, + 0x1a, 0x59, 0x51, 0x4c, 0x2b, 0xe7, 0x25, 0xd2, 0x10, 0xe2, 0x3a, 0x90, 0xd4, 0x55, 0xfa, 0x8f, + 0x01, 0x26, 0x75, 0x2f, 0x35, 0x1c, 0x7c, 0x08, 0x09, 0x18, 0x26, 0x22, 0x58, 0xb8, 0x9f, 0x46, + 0x97, 0x6e, 0x95, 0x1f, 0xf5, 0x46, 0x95, 0x3b, 0xe2, 0xaf, 0x32, 0xca, 0x8e, 0x4b, 0xfe, 0x83, + 0x12, 0x20, 0xd8, 0x00, 0x05, 0x22, 0xcf, 0x88, 0x07, 0xd2, 0xe8, 0xd2, 0x46, 0x7f, 0x40, 0x85, + 0xce, 0xca, 0x58, 0xab, 0x59, 0x2c, 0x24, 0xff, 0x21, 0x85, 0x55, 0xfa, 0x45, 0x0e, 0xcc, 0xad, + 0xc4, 0x34, 0x0a, 0x3c, 0x84, 0x69, 0x10, 0x93, 0x1a, 0x5e, 0x09, 0xdc, 0xd8, 0xf3, 0x57, 0xf1, + 0x9e, 0xe3, 0x3b, 0x11, 0x8b, 0xd1, 0x79, 0x30, 0xe8, 0x5b, 0x1e, 0x96, 0x31, 0x33, 0x26, 0x3d, + 0x39, 0x78, 0xdb, 0xf2, 0x30, 0xe2, 0x1c, 0x26, 0xc1, 0x42, 0x44, 0xde, 0x00, 0x25, 0x71, 0xe7, + 0x38, 0xc4, 0x88, 0x73, 0xe0, 0x35, 0x30, 0xb4, 0x17, 0x10, 0xcf, 0x12, 0xa7, 0x37, 0x92, 0x9e, + 0xc7, 0x4d, 0x4e, 0x45, 0x92, 0x0b, 0x9f, 0x07, 0xa3, 0x36, 0xa6, 0x35, 0xe2, 0x84, 0x0c, 0xda, + 0x1c, 0xe4, 0xc2, 0x17, 0xa4, 0xf0, 0xe8, 0x6a, 0xca, 0x42, 0xba, 0x1c, 0xbc, 0x0e, 0x0a, 0x21, + 0x71, 0x02, 0xe2, 0x44, 0xc7, 0x66, 0x7e, 0xde, 0x58, 0xc8, 0x57, 0x26, 0xe5, 0x9a, 0xc2, 0xb6, + 0xa4, 0x23, 0x25, 0xc1, 0xa4, 0xdf, 0xa1, 0x81, 0xbf, 0x6d, 0x45, 0xfb, 0xe6, 0x10, 0x47, 0x50, + 0xd2, 0xaf, 0x56, 0xb7, 0x6e, 0x33, 0x3a, 0x52, 0x12, 0xa5, 0x3f, 0x19, 0xc0, 0xcc, 0x7a, 0x28, + 0x71, 0x2f, 0xbc, 0x09, 0x0a, 0x34, 0x62, 0x39, 0xa7, 0x7e, 0x2c, 0xfd, 0xf3, 0x54, 0xa2, 0xaa, + 0x2a, 0xe9, 0x27, 0xcd, 0xe2, 0x4c, 0xba, 0x22, 0xa1, 0x72, 0xdf, 0xa8, 0xb5, 0x2c, 0xe4, 0x0e, + 0xf1, 0xee, 0x7e, 0x10, 0x1c, 0xc8, 0xd3, 0x3f, 0x45, 0xc8, 0xbd, 0x26, 0x14, 0xa5, 0x98, 0x22, + 0xe4, 0x24, 0x19, 0x25, 0x40, 0xa5, 0x7f, 0xe7, 0xb2, 0x1b, 0xd3, 0x0e, 0xfd, 0x6d, 0x50, 0x60, + 0x57, 0xc8, 0xb6, 0x22, 0x4b, 0x5e, 0x82, 0x67, 0x1f, 0xee, 0xc2, 0x89, 0xfb, 0xba, 0x89, 0x23, + 0xab, 0x02, 0xa5, 0x2b, 0x40, 0x4a, 0x43, 0x4a, 0x2b, 0x3c, 0x02, 0x83, 0x34, 0xc4, 0x35, 0xb9, + 0xdf, 0x7b, 0xa7, 0x88, 0xf6, 0x1e, 0x7b, 0xa8, 0x86, 0xb8, 0x96, 0x06, 0x23, 0xfb, 0x0f, 0x71, + 0x44, 0xf8, 0xae, 0x01, 0x86, 0x28, 0xcf, 0x0b, 0x32, 0x97, 0xec, 0x9c, 0x01, 0x78, 0x26, 0xef, + 0x88, 0xff, 0x91, 0xc4, 0x2d, 0xfd, 0x23, 0x07, 0xae, 0xf6, 0x5a, 0xba, 0x12, 0xf8, 0xb6, 0x38, + 0x84, 0x75, 0x79, 0xaf, 0x44, 0x64, 0x3d, 0xaf, 0xdf, 0xab, 0x93, 0x66, 0xf1, 0x89, 0x07, 0x2a, + 0xd0, 0x2e, 0xe0, 0x57, 0xd5, 0x96, 0xc5, 0x25, 0xbd, 0xda, 0x6e, 0xd8, 0x49, 0xb3, 0x38, 0xa1, + 0x96, 0xb5, 0xdb, 0x0a, 0x1b, 0x00, 0xba, 0x16, 0x8d, 0xee, 0x10, 0xcb, 0xa7, 0x42, 0xad, 0xe3, + 0x61, 0xe9, 0xb9, 0xa7, 0x1e, 0x2e, 0x28, 0xd8, 0x8a, 0xca, 0xac, 0x84, 0x84, 0x1b, 0x1d, 0xda, + 0x50, 0x17, 0x04, 0x96, 0x33, 0x08, 0xb6, 0xa8, 0x4a, 0x03, 0x5a, 0x0e, 0x67, 0x54, 0x24, 0xb9, + 0xf0, 0x49, 0x30, 0xec, 0x61, 0x4a, 0xad, 0x3a, 0xe6, 0x77, 0x7f, 0x24, 0x2d, 0x8a, 0x9b, 0x82, + 0x8c, 0x12, 0x7e, 0xe9, 0x9f, 0x06, 0xb8, 0xdc, 0xcb, 0x6b, 0x1b, 0x0e, 0x8d, 0xe0, 0x37, 0x3b, + 0xc2, 0xbe, 0xfc, 0x70, 0x3b, 0x64, 0xab, 0x79, 0xd0, 0xab, 0x54, 0x92, 0x50, 0xb4, 0x90, 0x3f, + 0x04, 0x79, 0x27, 0xc2, 0x5e, 0x52, 0x2d, 0x51, 0xff, 0xc3, 0xae, 0x32, 0x2e, 0xe1, 0xf3, 0xeb, + 0x0c, 0x08, 0x09, 0xbc, 0xd2, 0x47, 0x39, 0x70, 0xa5, 0xd7, 0x12, 0x96, 0xc7, 0x29, 0x73, 0x76, + 0xe8, 0xc6, 0xc4, 0x72, 0x65, 0xb0, 0x29, 0x67, 0x6f, 0x73, 0x2a, 0x92, 0x5c, 0x96, 0x3b, 0xa9, + 0xe3, 0xd7, 0x63, 0xd7, 0x22, 0x32, 0x92, 0xd4, 0x86, 0xab, 0x92, 0x8e, 0x94, 0x04, 0x2c, 0x03, + 0x40, 0xf7, 0x03, 0x12, 0x71, 0x0c, 0xde, 0xe1, 0x8c, 0x54, 0xce, 0xb3, 0x8c, 0x50, 0x55, 0x54, + 0xa4, 0x49, 0xb0, 0x42, 0x72, 0xe0, 0xf8, 0xb6, 0x3c, 0x70, 0x75, 0x77, 0x6f, 0x39, 0xbe, 0x8d, + 0x38, 0x87, 0xe1, 0xbb, 0x0e, 0x8d, 0x18, 0x45, 0x9e, 0x76, 0x9b, 0xc3, 0xb9, 0xa4, 0x92, 0x60, + 0xf8, 0x35, 0x96, 0x60, 0x03, 0xe2, 0x60, 0x6a, 0x0e, 0xa5, 0xf8, 0x2b, 0x8a, 0x8a, 0x34, 0x89, + 0xd2, 0x9f, 0x07, 0x7b, 0xc7, 0x07, 0x4b, 0x20, 0xf0, 0x71, 0x90, 0xaf, 0x93, 0x20, 0x0e, 0xa5, + 0x97, 0x94, 0xb7, 0x5f, 0x66, 0x44, 0x24, 0x78, 0xf0, 0xdb, 0x20, 0xef, 0xcb, 0x0d, 0xb3, 0x08, + 0x7a, 0xad, 0xff, 0xc7, 0xcc, 0xbd, 0x95, 0xa2, 0x0b, 0x47, 0x0a, 0x50, 0xf8, 0x1c, 0xc8, 0xd3, + 0x5a, 0x10, 0x62, 0xe9, 0xc4, 0xb9, 0x44, 0xa8, 0xca, 0x88, 0x27, 0xcd, 0xe2, 0x78, 0xa2, 0x8e, + 0x13, 0x90, 0x10, 0x86, 0xdf, 0x37, 0x40, 0x41, 0x96, 0x0b, 0x6a, 0x0e, 0xf3, 0xf0, 0x7c, 0xbd, + 0xff, 0x76, 0xcb, 0xb6, 0x37, 0x3d, 0x33, 0x49, 0xa0, 0x48, 0x81, 0xc3, 0xef, 0x1a, 0x00, 0xd4, + 0x54, 0xed, 0x32, 0x47, 0xb8, 0x0f, 0xfb, 0x76, 0x55, 0xb4, 0xaa, 0x28, 0x02, 0x21, 0x6d, 0x95, + 0x34, 0x54, 0x58, 0x05, 0xd3, 0x21, 0xc1, 0x5c, 0xf7, 0x5d, 0xff, 0xc0, 0x0f, 0x0e, 0xfd, 0x9b, + 0x0e, 0x76, 0x6d, 0x6a, 0x82, 0x79, 0x63, 0xa1, 0x50, 0xb9, 0x22, 0xed, 0x9f, 0xde, 0xee, 0x26, + 0x84, 0xba, 0xaf, 0x2d, 0xbd, 0x37, 0x90, 0xed, 0xb5, 0xb2, 0xf5, 0x02, 0x7e, 0x20, 0x36, 0x2f, + 0xf2, 0x30, 0x35, 0x0d, 0x7e, 0x10, 0x6f, 0xf6, 0xff, 0x20, 0x54, 0xae, 0x4f, 0x8b, 0xb4, 0x22, + 0x51, 0xa4, 0x99, 0x00, 0x7f, 0x6a, 0x80, 0x71, 0xab, 0x56, 0xc3, 0x61, 0x84, 0x6d, 0x71, 0x8d, + 0x73, 0x67, 0x1b, 0xd5, 0xd3, 0xd2, 0xa0, 0xf1, 0x65, 0x1d, 0x15, 0xb5, 0x1b, 0x01, 0x5f, 0x02, + 0xe7, 0x69, 0x14, 0x10, 0x6c, 0x27, 0x11, 0x24, 0xb3, 0x0b, 0x6c, 0x35, 0x8b, 0xe7, 0xab, 0x6d, + 0x1c, 0x94, 0x91, 0x2c, 0x7d, 0x92, 0x07, 0xc5, 0x07, 0x44, 0xe8, 0x43, 0x34, 0xbd, 0xd7, 0xc0, + 0x10, 0xdf, 0xa9, 0xcd, 0x1d, 0x52, 0xd0, 0x4a, 0x3d, 0xa7, 0x22, 0xc9, 0x65, 0xe5, 0x89, 0xe1, + 0xb3, 0xf2, 0x34, 0xc0, 0x05, 0x55, 0x79, 0xaa, 0x0a, 0x32, 0x4a, 0xf8, 0x70, 0x09, 0x00, 0x1b, + 0x87, 0x04, 0xb3, 0x8c, 0x64, 0x9b, 0xc3, 0x5c, 0x5a, 0x9d, 0xcf, 0xaa, 0xe2, 0x20, 0x4d, 0x0a, + 0xde, 0x04, 0x30, 0xf9, 0xcf, 0x09, 0xfc, 0xd7, 0x2c, 0xe2, 0x3b, 0x7e, 0xdd, 0x2c, 0x70, 0xb3, + 0x67, 0x58, 0xb5, 0x5d, 0xed, 0xe0, 0xa2, 0x2e, 0x2b, 0x60, 0x03, 0x0c, 0x89, 0x67, 0x34, 0xcf, + 0x1b, 0x7d, 0xbc, 0x71, 0xf7, 0x2c, 0xd7, 0xb1, 0x39, 0x54, 0x05, 0x70, 0xf7, 0x70, 0x14, 0x24, + 0xd1, 0xe0, 0xfb, 0x06, 0x18, 0xa3, 0xf1, 0x2e, 0x91, 0xd2, 0x94, 0x67, 0xf5, 0xd1, 0xa5, 0x3b, + 0xfd, 0x82, 0xaf, 0x6a, 0xba, 0x2b, 0x93, 0xad, 0x66, 0x71, 0x4c, 0xa7, 0xa0, 0x36, 0x6c, 0xf8, + 0x7b, 0x03, 0x98, 0x96, 0x2d, 0x42, 0xdf, 0x72, 0xb7, 0x89, 0xe3, 0x47, 0x98, 0x88, 0x07, 0x91, + 0x28, 0x1f, 0x7d, 0xec, 0x15, 0xb3, 0xef, 0xac, 0xca, 0xbc, 0x3c, 0x69, 0x73, 0xb9, 0x87, 0x05, + 0xa8, 0xa7, 0x6d, 0xa5, 0x7f, 0x19, 0xd9, 0xd4, 0xa2, 0xed, 0xb2, 0x5a, 0xb3, 0x5c, 0x0c, 0x57, + 0xc1, 0x24, 0xeb, 0x7e, 0x11, 0x0e, 0x5d, 0xa7, 0x66, 0x51, 0xfe, 0xfa, 0x11, 0xd1, 0xad, 0x9e, + 0xe1, 0xd5, 0x0c, 0x1f, 0x75, 0xac, 0x80, 0xaf, 0x02, 0x28, 0xda, 0xc2, 0x36, 0x3d, 0xa2, 0x13, + 0x50, 0x0d, 0x5e, 0xb5, 0x43, 0x02, 0x75, 0x59, 0x05, 0x57, 0xc0, 0x94, 0x6b, 0xed, 0x62, 0xb7, + 0x8a, 0x5d, 0x5c, 0x8b, 0x02, 0xc2, 0x55, 0x89, 0xf7, 0xe1, 0x74, 0xab, 0x59, 0x9c, 0xda, 0xc8, + 0x32, 0x51, 0xa7, 0x7c, 0xe9, 0x6a, 0xf6, 0x2e, 0xeb, 0x1b, 0x17, 0xcd, 0xf6, 0x87, 0x39, 0x30, + 0xdb, 0x3b, 0x28, 0xe0, 0x77, 0x54, 0x6b, 0x2c, 0x3a, 0xbe, 0xd7, 0xcf, 0x20, 0xf4, 0xe4, 0x73, + 0x00, 0x74, 0x3e, 0x05, 0xe0, 0x31, 0xab, 0xd7, 0x96, 0x9b, 0x3c, 0xfb, 0x77, 0xce, 0x02, 0x9d, + 0xe9, 0xaf, 0x8c, 0x88, 0x2e, 0xc0, 0x72, 0x79, 0xd1, 0xb7, 0x5c, 0x5c, 0xfa, 0xa8, 0xe3, 0x69, + 0x9b, 0x5e, 0x56, 0xf8, 0x03, 0x03, 0x4c, 0x04, 0x21, 0xf6, 0x97, 0xb7, 0xd7, 0xef, 0xfd, 0xbf, + 0xb8, 0xb4, 0xd2, 0x41, 0xeb, 0x8f, 0x6e, 0x22, 0x7b, 0x5f, 0x0b, 0x5d, 0xdb, 0x24, 0x08, 0x69, + 0xe5, 0x42, 0xab, 0x59, 0x9c, 0xd8, 0x6a, 0x47, 0x41, 0x59, 0xd8, 0x92, 0x07, 0xa6, 0xd7, 0x8e, + 0x22, 0x4c, 0x7c, 0xcb, 0x5d, 0x0d, 0x6a, 0xb1, 0x87, 0xfd, 0x48, 0xd8, 0x98, 0x19, 0x17, 0x18, + 0x0f, 0x39, 0x2e, 0xb8, 0x02, 0x06, 0x62, 0xe2, 0xca, 0xa8, 0x1d, 0x55, 0x43, 0x30, 0xb4, 0x81, + 0x18, 0xbd, 0x74, 0x15, 0x0c, 0x32, 0x3b, 0xe1, 0x25, 0x30, 0x40, 0xac, 0x43, 0xae, 0x75, 0xac, + 0x32, 0xcc, 0x44, 0x90, 0x75, 0x88, 0x18, 0xad, 0xf4, 0xb7, 0x79, 0x30, 0x91, 0xd9, 0x0b, 0x9c, + 0x05, 0x39, 0x35, 0x59, 0x03, 0x52, 0x69, 0x6e, 0x7d, 0x15, 0xe5, 0x1c, 0x1b, 0xbe, 0xa0, 0xb2, + 0xab, 0x00, 0x2d, 0xaa, 0x62, 0xc1, 0xa9, 0xac, 0x2d, 0x4b, 0xd5, 0x31, 0x43, 0x92, 0xf4, 0xc8, + 0x6c, 0xc0, 0x7b, 0xf2, 0x56, 0x08, 0x1b, 0xf0, 0x1e, 0x62, 0xb4, 0x47, 0x9d, 0x95, 0x24, 0xc3, + 0x9a, 0xfc, 0x43, 0x0c, 0x6b, 0x86, 0x3e, 0x77, 0x58, 0xf3, 0x38, 0xc8, 0x47, 0x4e, 0xe4, 0x62, + 0x5e, 0xa9, 0xb4, 0x66, 0xf8, 0x0e, 0x23, 0x22, 0xc1, 0x83, 0x18, 0x0c, 0xdb, 0x78, 0xcf, 0x8a, + 0xdd, 0x88, 0x17, 0xa5, 0xd1, 0xa5, 0xaf, 0x9f, 0x2e, 0x7a, 0xc4, 0x30, 0x63, 0x55, 0xa8, 0x44, + 0x89, 0x6e, 0xf8, 0x04, 0x18, 0xf6, 0xac, 0x23, 0xc7, 0x8b, 0x3d, 0xde, 0x31, 0x1a, 0x42, 0x6c, + 0x53, 0x90, 0x50, 0xc2, 0x63, 0x49, 0x10, 0x1f, 0xd5, 0xdc, 0x98, 0x3a, 0x0d, 0x2c, 0x99, 0xb2, + 0xa5, 0x53, 0x49, 0x70, 0x2d, 0xc3, 0x47, 0x1d, 0x2b, 0x38, 0x98, 0xe3, 0xf3, 0xc5, 0xa3, 0x1a, + 0x98, 0x20, 0xa1, 0x84, 0xd7, 0x0e, 0x26, 0xe5, 0xc7, 0x7a, 0x81, 0xc9, 0xc5, 0x1d, 0x2b, 0xe0, + 0xd3, 0x60, 0xc4, 0xb3, 0x8e, 0x36, 0xb0, 0x5f, 0x8f, 0xf6, 0xcd, 0xf1, 0x79, 0x63, 0x61, 0xa0, + 0x32, 0xde, 0x6a, 0x16, 0x47, 0x36, 0x13, 0x22, 0x4a, 0xf9, 0x5c, 0xd8, 0xf1, 0xa5, 0xf0, 0x79, + 0x4d, 0x38, 0x21, 0xa2, 0x94, 0xcf, 0x3a, 0x93, 0xd0, 0x8a, 0xd8, 0xbd, 0x32, 0x27, 0xda, 0x1f, + 0xce, 0xdb, 0x82, 0x8c, 0x12, 0x3e, 0x5c, 0x00, 0x05, 0xcf, 0x3a, 0xe2, 0x6f, 0x4a, 0x73, 0x92, + 0xab, 0xe5, 0x03, 0xc5, 0x4d, 0x49, 0x43, 0x8a, 0xcb, 0x25, 0x1d, 0x5f, 0x48, 0x4e, 0x69, 0x92, + 0x92, 0x86, 0x14, 0x97, 0xc5, 0x6f, 0xec, 0x3b, 0xf7, 0x63, 0x2c, 0x84, 0x21, 0xf7, 0x8c, 0x8a, + 0xdf, 0xbb, 0x29, 0x0b, 0xe9, 0x72, 0xec, 0x4d, 0xe7, 0xc5, 0x6e, 0xe4, 0x84, 0x2e, 0xde, 0xda, + 0x33, 0x2f, 0x70, 0xff, 0xf3, 0x56, 0x7e, 0x53, 0x51, 0x91, 0x26, 0x01, 0xdf, 0x06, 0x83, 0xd8, + 0x8f, 0x3d, 0xf3, 0x22, 0x2f, 0xdf, 0xa7, 0x8d, 0x3e, 0x75, 0x5f, 0xd6, 0xfc, 0xd8, 0x43, 0x5c, + 0x33, 0x7c, 0x01, 0x8c, 0x7b, 0xd6, 0x11, 0x4b, 0x02, 0x98, 0x44, 0xec, 0xa1, 0x39, 0xcd, 0xf7, + 0x3d, 0xc5, 0x9a, 0xd8, 0x4d, 0x9d, 0x81, 0xda, 0xe5, 0xf8, 0x42, 0xc7, 0xd7, 0x16, 0xce, 0x68, + 0x0b, 0x75, 0x06, 0x6a, 0x97, 0x63, 0x4e, 0x26, 0xf8, 0x7e, 0xec, 0x10, 0x6c, 0x9b, 0xff, 0xc3, + 0xfb, 0x5e, 0x39, 0xdf, 0x15, 0x34, 0xa4, 0xb8, 0xf0, 0x7e, 0x32, 0x72, 0x30, 0xf9, 0xe5, 0xdb, + 0xee, 0x5b, 0xea, 0xde, 0x22, 0xcb, 0x84, 0x58, 0xc7, 0xa2, 0xaa, 0xe8, 0xc3, 0x06, 0xe8, 0x83, + 0xbc, 0xe5, 0xba, 0x5b, 0x7b, 0xe6, 0x25, 0xee, 0xf1, 0x3e, 0x56, 0x0b, 0x95, 0x61, 0x96, 0x99, + 0x7e, 0x24, 0x60, 0x18, 0x5e, 0xe0, 0xb3, 0x58, 0x98, 0x3d, 0x33, 0xbc, 0x2d, 0xa6, 0x1f, 0x09, + 0x18, 0xbe, 0x3f, 0xff, 0x78, 0x6b, 0xcf, 0x7c, 0xec, 0xec, 0xf6, 0xc7, 0xf4, 0x23, 0x01, 0x03, + 0x6d, 0x30, 0xe0, 0x07, 0x91, 0x79, 0xb9, 0xdf, 0xb5, 0x97, 0x57, 0x93, 0xdb, 0x41, 0x84, 0x98, + 0x7a, 0xf8, 0x23, 0x03, 0x80, 0x30, 0x8d, 0xc4, 0x2b, 0xa7, 0x1d, 0x01, 0x64, 0xd0, 0xca, 0x69, + 0xf4, 0xae, 0xf9, 0x11, 0x39, 0x4e, 0xdf, 0x35, 0x5a, 0x94, 0x6b, 0x06, 0xc0, 0x9f, 0x1b, 0xe0, + 0xa2, 0xde, 0xee, 0x2a, 0xcb, 0xe6, 0xb8, 0x1f, 0xb6, 0xfa, 0x18, 0xc8, 0x95, 0x20, 0x70, 0x2b, + 0x66, 0xab, 0x59, 0xbc, 0xb8, 0xdc, 0x05, 0x10, 0x75, 0x35, 0x03, 0xfe, 0xda, 0x00, 0x53, 0x32, + 0x3b, 0x6a, 0xc6, 0x15, 0xb9, 0xdb, 0xde, 0xee, 0xa3, 0xdb, 0xb2, 0x10, 0xc2, 0x7b, 0xea, 0x2b, + 0x63, 0x07, 0x1f, 0x75, 0x5a, 0x05, 0x7f, 0x67, 0x80, 0x31, 0x1b, 0x87, 0xd8, 0xb7, 0xb1, 0x5f, + 0x63, 0x66, 0xce, 0x9f, 0x76, 0xae, 0x90, 0x35, 0x73, 0x55, 0xd3, 0x2e, 0x2c, 0x2c, 0x4b, 0x0b, + 0xc7, 0x74, 0xd6, 0x49, 0xb3, 0x38, 0x93, 0x2e, 0xd5, 0x39, 0xa8, 0xcd, 0x40, 0xf8, 0x63, 0x03, + 0x4c, 0xa4, 0x6e, 0x17, 0x05, 0xe2, 0xea, 0xd9, 0x1c, 0x3c, 0x6f, 0x41, 0x97, 0xdb, 0xb1, 0x50, + 0x16, 0x1c, 0xfe, 0xc6, 0x60, 0xdd, 0x56, 0xf2, 0x56, 0xa3, 0x66, 0x89, 0x7b, 0xf0, 0x8d, 0x7e, + 0x7a, 0x50, 0x29, 0x17, 0x0e, 0xbc, 0x9e, 0x76, 0x72, 0x8a, 0x73, 0xd2, 0x2c, 0x4e, 0xeb, 0xfe, + 0x53, 0x0c, 0xa4, 0x1b, 0x07, 0xdf, 0x33, 0xc0, 0x18, 0x4e, 0x1b, 0x66, 0x6a, 0x3e, 0x7e, 0x5a, + 0xd7, 0x75, 0x6d, 0xbf, 0xc5, 0x73, 0x5a, 0x63, 0x51, 0xd4, 0x06, 0xcb, 0x7a, 0x3f, 0x7c, 0x64, + 0x79, 0xa1, 0x8b, 0xcd, 0xff, 0xed, 0x5f, 0xef, 0xb7, 0x26, 0x54, 0xa2, 0x44, 0x37, 0xbc, 0x0e, + 0x0a, 0x7e, 0xec, 0xba, 0xd6, 0xae, 0x8b, 0xcd, 0x27, 0x78, 0x17, 0xa1, 0xe6, 0x8b, 0xb7, 0x25, + 0x1d, 0x29, 0x09, 0xb8, 0x07, 0xe6, 0x8f, 0x6e, 0xa9, 0x1f, 0x5f, 0x74, 0x1d, 0xe0, 0x99, 0xd7, + 0xb8, 0x96, 0xd9, 0x56, 0xb3, 0x38, 0xb3, 0xd3, 0x7d, 0xc4, 0xf7, 0x40, 0x1d, 0xf0, 0x4d, 0xf0, + 0x98, 0x26, 0xb3, 0xe6, 0xed, 0x62, 0xdb, 0xc6, 0x76, 0xf2, 0xd0, 0x32, 0xff, 0x8f, 0x43, 0xa8, + 0x7b, 0xbc, 0x93, 0x15, 0x40, 0x9f, 0xb7, 0x1a, 0x6e, 0x80, 0x19, 0x8d, 0xbd, 0xee, 0x47, 0x5b, + 0xa4, 0x1a, 0x11, 0xc7, 0xaf, 0x9b, 0x0b, 0x5c, 0xef, 0xc5, 0xe4, 0xf6, 0xed, 0x68, 0x3c, 0xd4, + 0x63, 0x0d, 0x7c, 0xa5, 0x4d, 0x1b, 0xff, 0x70, 0x61, 0x85, 0xb7, 0xf0, 0x31, 0x35, 0x9f, 0xe4, + 0xcd, 0x05, 0x3f, 0xe7, 0x1d, 0x8d, 0x8e, 0x7a, 0xc8, 0xc3, 0x6f, 0x80, 0x0b, 0x19, 0x0e, 0x7b, + 0x57, 0x98, 0x4f, 0x89, 0x07, 0x02, 0xeb, 0x44, 0x77, 0x12, 0x22, 0xea, 0x26, 0x09, 0xbf, 0x06, + 0xa0, 0x46, 0xde, 0xb4, 0x42, 0xbe, 0xfe, 0x69, 0xf1, 0x56, 0x61, 0x27, 0xba, 0x23, 0x69, 0xa8, + 0x8b, 0x1c, 0xfc, 0xd0, 0x68, 0xdb, 0x49, 0xfa, 0x9a, 0xa5, 0xe6, 0x75, 0x7e, 0x61, 0x5f, 0x79, + 0xf4, 0x00, 0x4c, 0x95, 0xa1, 0xd8, 0xc5, 0x9a, 0x87, 0x35, 0x14, 0xd4, 0x03, 0x7d, 0x96, 0x3d, + 0xa6, 0x33, 0x39, 0x1c, 0x4e, 0x82, 0x81, 0x03, 0x2c, 0x3f, 0x1b, 0x23, 0xf6, 0x27, 0x7c, 0x0b, + 0xe4, 0x1b, 0x96, 0x1b, 0x27, 0xa3, 0x80, 0xfe, 0xd5, 0x7a, 0x24, 0xf4, 0xbe, 0x94, 0x7b, 0xd1, + 0x98, 0xfd, 0xc0, 0x00, 0x33, 0xdd, 0xab, 0xca, 0x97, 0x65, 0xd1, 0xcf, 0x0c, 0x30, 0xd5, 0x51, + 0x40, 0xba, 0x18, 0xe3, 0xb6, 0x1b, 0x73, 0xaf, 0x8f, 0x95, 0x40, 0x5c, 0x04, 0xde, 0xd1, 0xea, + 0x96, 0xfd, 0xd0, 0x00, 0x93, 0xd9, 0xc4, 0xfc, 0x25, 0x79, 0xa9, 0xf4, 0x7e, 0x0e, 0xcc, 0x74, + 0xef, 0xc1, 0xa1, 0xa7, 0xa6, 0x0b, 0x7d, 0x1f, 0xd0, 0x74, 0x1b, 0xd9, 0xbe, 0x6b, 0x80, 0xd1, + 0x77, 0x94, 0x5c, 0xf2, 0x35, 0xb3, 0x9f, 0x53, 0xa1, 0xa4, 0xf4, 0xa5, 0x0c, 0x8a, 0x74, 0xc8, + 0xd2, 0x6f, 0x0d, 0x30, 0xdd, 0xb5, 0x9c, 0xc3, 0x6b, 0x60, 0xc8, 0x72, 0xdd, 0xe0, 0x50, 0x4c, + 0xf3, 0xb4, 0xb1, 0xfc, 0x32, 0xa7, 0x22, 0xc9, 0xd5, 0x7c, 0x96, 0xfb, 0x02, 0x7c, 0x56, 0xfa, + 0x83, 0x01, 0x2e, 0x7f, 0x5e, 0xd4, 0x7d, 0xd1, 0x67, 0xb8, 0x00, 0x0a, 0xb2, 0xd9, 0x3e, 0xe6, + 0xe7, 0x27, 0xb3, 0xab, 0xcc, 0x08, 0xfc, 0xd7, 0x32, 0xe2, 0xaf, 0xd2, 0x2f, 0x0d, 0x30, 0x59, + 0xc5, 0xa4, 0xe1, 0xd4, 0x30, 0xc2, 0x7b, 0x98, 0x60, 0xbf, 0x86, 0xe1, 0x22, 0x18, 0xe1, 0x5f, + 0x1b, 0x43, 0xab, 0x96, 0x7c, 0x23, 0x99, 0x92, 0x8e, 0x1e, 0xb9, 0x9d, 0x30, 0x50, 0x2a, 0xa3, + 0xbe, 0xa7, 0xe4, 0x7a, 0x7e, 0x4f, 0xb9, 0x0c, 0x06, 0xc3, 0x74, 0x00, 0x5c, 0x60, 0x5c, 0x3e, + 0xf3, 0xe5, 0x54, 0xce, 0x0d, 0x48, 0xc4, 0xa7, 0x5c, 0x79, 0xc9, 0x0d, 0x48, 0x84, 0x38, 0xb5, + 0xf4, 0x2d, 0x70, 0xbe, 0x3d, 0x3d, 0x33, 0x3c, 0x12, 0xbb, 0x1d, 0xdf, 0x6f, 0x18, 0x0f, 0x71, + 0x8e, 0xfe, 0xb3, 0x81, 0xdc, 0x03, 0x7e, 0x36, 0xf0, 0x47, 0x03, 0x5c, 0x48, 0x7e, 0x55, 0xe3, + 0x3a, 0xd8, 0x8f, 0x56, 0x02, 0x7f, 0xcf, 0xa9, 0xc3, 0x4b, 0x62, 0x8e, 0xa8, 0x0d, 0xe7, 0x92, + 0x19, 0x22, 0xbc, 0x0f, 0x86, 0xa9, 0x70, 0x9a, 0x3c, 0xcf, 0x57, 0x1f, 0xfd, 0x3c, 0xb3, 0xde, + 0x17, 0x6d, 0x50, 0x42, 0x4d, 0x70, 0xd8, 0x91, 0xd6, 0xac, 0x4a, 0xec, 0xdb, 0x72, 0x96, 0x3c, + 0x26, 0x8e, 0x74, 0x65, 0x59, 0xd0, 0x90, 0xe2, 0x96, 0xfe, 0x6e, 0x80, 0xa9, 0x8e, 0x5f, 0x09, + 0xc1, 0xef, 0x19, 0x60, 0xac, 0xa6, 0x6d, 0x4f, 0x5e, 0x8c, 0xcd, 0xd3, 0xff, 0x12, 0x49, 0x53, + 0x2a, 0x7a, 0x09, 0x9d, 0x82, 0xda, 0x40, 0xe1, 0x0e, 0x30, 0x6b, 0x99, 0x1f, 0xe4, 0x65, 0x3e, + 0xf1, 0x5d, 0x6e, 0x35, 0x8b, 0xe6, 0x4a, 0x0f, 0x19, 0xd4, 0x73, 0x75, 0x65, 0xe1, 0xe3, 0xcf, + 0xe6, 0xce, 0x7d, 0xf2, 0xd9, 0xdc, 0xb9, 0x4f, 0x3f, 0x9b, 0x3b, 0xf7, 0x6e, 0x6b, 0xce, 0xf8, + 0xb8, 0x35, 0x67, 0x7c, 0xd2, 0x9a, 0x33, 0x3e, 0x6d, 0xcd, 0x19, 0x7f, 0x69, 0xcd, 0x19, 0x3f, + 0xf9, 0xeb, 0xdc, 0xb9, 0x37, 0x72, 0x8d, 0x1b, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x19, 0x76, + 0x99, 0xb1, 0xa4, 0x2b, 0x00, 0x00, } func (m *ConversionRequest) Marshal() (dAtA []byte, err error) { @@ -1884,6 +1917,22 @@ func (m *JSONSchemaProps) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.XValidations) > 0 { + for iNdEx := len(m.XValidations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.XValidations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xe2 + } + } if m.XMapType != nil { i -= len(*m.XMapType) copy(dAtA[i:], *m.XMapType) @@ -2560,6 +2609,39 @@ func (m *ServiceReference) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ValidationRule) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ValidationRule) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidationRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x12 + i -= len(m.Rule) + copy(dAtA[i:], m.Rule) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *WebhookClientConfig) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -3165,6 +3247,12 @@ func (m *JSONSchemaProps) Size() (n int) { l = len(*m.XMapType) n += 2 + l + sovGenerated(uint64(l)) } + if len(m.XValidations) > 0 { + for _, e := range m.XValidations { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } return n } @@ -3240,6 +3328,19 @@ func (m *ServiceReference) Size() (n int) { return n } +func (m *ValidationRule) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Rule) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *WebhookClientConfig) Size() (n int) { if m == nil { return 0 @@ -3560,6 +3661,11 @@ func (this *JSONSchemaProps) String() string { repeatedStringForAnyOf += strings.Replace(strings.Replace(f.String(), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + "," } repeatedStringForAnyOf += "}" + repeatedStringForXValidations := "[]ValidationRule{" + for _, f := range this.XValidations { + repeatedStringForXValidations += strings.Replace(strings.Replace(f.String(), "ValidationRule", "ValidationRule", 1), `&`, ``, 1) + "," + } + repeatedStringForXValidations += "}" keysForProperties := make([]string, 0, len(this.Properties)) for k := range this.Properties { keysForProperties = append(keysForProperties, k) @@ -3644,6 +3750,7 @@ func (this *JSONSchemaProps) String() string { `XListMapKeys:` + fmt.Sprintf("%v", this.XListMapKeys) + `,`, `XListType:` + valueToStringGenerated(this.XListType) + `,`, `XMapType:` + valueToStringGenerated(this.XMapType) + `,`, + `XValidations:` + repeatedStringForXValidations + `,`, `}`, }, "") return s @@ -3699,6 +3806,17 @@ func (this *ServiceReference) String() string { }, "") return s } +func (this *ValidationRule) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ValidationRule{`, + `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `}`, + }, "") + return s +} func (this *WebhookClientConfig) String() string { if this == nil { return "nil" @@ -8102,6 +8220,40 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error { s := string(dAtA[iNdEx:postIndex]) m.XMapType = &s iNdEx = postIndex + case 44: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field XValidations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.XValidations = append(m.XValidations, ValidationRule{}) + if err := m.XValidations[len(m.XValidations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -8634,6 +8786,120 @@ func (m *ServiceReference) Unmarshal(dAtA []byte) error { } return nil } +func (m *ValidationRule) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ValidationRule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidationRule: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rule = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *WebhookClientConfig) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/generated.proto b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/generated.proto index 9bdfa2030b..fe92dab21d 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/generated.proto +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/generated.proto @@ -549,6 +549,14 @@ message JSONSchemaProps { // Atomic maps will be entirely replaced when updated. // +optional optional string xKubernetesMapType = 43; + + // x-kubernetes-validations describes a list of validation rules written in the CEL expression language. + // This field is an alpha-level. Using this field requires the feature gate `CustomResourceValidationExpressions` to be enabled. + // +patchMergeKey=rule + // +patchStrategy=merge + // +listType=map + // +listMapKey=rule + repeated ValidationRule xKubernetesValidations = 44; } // JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps @@ -595,6 +603,70 @@ message ServiceReference { optional int32 port = 4; } +// ValidationRule describes a validation rule written in the CEL expression language. +message ValidationRule { + // Rule represents the expression which will be evaluated by CEL. + // ref: https://github.com/google/cel-spec + // The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. + // The `self` variable in the CEL expression is bound to the scoped value. + // Example: + // - Rule scoped to the root of a resource with a status subresource: {"rule": "self.status.actual <= self.spec.maxDesired"} + // + // If the Rule is scoped to an object with properties, the accessible properties of the object are field selectable + // via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as + // absent fields in CEL expressions. + // If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map + // are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map + // are accessible via CEL macros and functions such as `self.all(...)`. + // If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and + // functions. + // If the Rule is scoped to a scalar, `self` is bound to the scalar value. + // Examples: + // - Rule scoped to a map of objects: {"rule": "self.components['Widget'].priority < 10"} + // - Rule scoped to a list of integers: {"rule": "self.values.all(value, value >= 0 && value < 100)"} + // - Rule scoped to a string value: {"rule": "self.startsWith('kube')"} + // + // The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the + // object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible. + // + // Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL + // expressions. This includes: + // - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. + // - Object properties where the property schema is of an "unknown type". An "unknown type" is recursively defined as: + // - A schema with no type and x-kubernetes-preserve-unknown-fields set to true + // - An array where the items schema is of an "unknown type" + // - An object where the additionalProperties schema is of an "unknown type" + // + // Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. + // Accessible property names are escaped according to the following rules when accessed in the expression: + // - '__' escapes to '__underscores__' + // - '.' escapes to '__dot__' + // - '-' escapes to '__dash__' + // - '/' escapes to '__slash__' + // - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: + // "true", "false", "null", "in", "as", "break", "const", "continue", "else", "for", "function", "if", + // "import", "let", "loop", "package", "namespace", "return". + // Examples: + // - Rule accessing a property named "namespace": {"rule": "self.__namespace__ > 0"} + // - Rule accessing a property named "x-prop": {"rule": "self.x__dash__prop > 0"} + // - Rule accessing a property named "redact__d": {"rule": "self.redact__underscores__d > 0"} + // + // Equality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. + // Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: + // - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and + // non-intersecting elements in `Y` are appended, retaining their partial order. + // - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values + // are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with + // non-intersecting keys are appended, retaining their partial order. + optional string rule = 1; + + // Message represents the message displayed when validation fails. The message is required if the Rule contains + // line breaks. The message must not contain line breaks. + // If unset, the message is "failed rule: {Rule}". + // e.g. "must be a URL with the host matching spec.host" + optional string message = 2; +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook. message WebhookClientConfig { // url gives the location of the webhook, in standard URL form diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/marshal.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/marshal.go index ba7f286eb4..12cc2f6f2c 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/marshal.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/marshal.go @@ -17,6 +17,7 @@ limitations under the License. package v1 import ( + "bytes" "errors" "k8s.io/apimachinery/pkg/util/json" @@ -128,7 +129,7 @@ func (s JSON) MarshalJSON() ([]byte, error) { } func (s *JSON) UnmarshalJSON(data []byte) error { - if len(data) > 0 && string(data) != "null" { + if len(data) > 0 && !bytes.Equal(data, nullLiteral) { s.Raw = data } return nil diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/types_jsonschema.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/types_jsonschema.go index 4433e2446f..277fd7a124 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/types_jsonschema.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/types_jsonschema.go @@ -161,6 +161,80 @@ type JSONSchemaProps struct { // Atomic maps will be entirely replaced when updated. // +optional XMapType *string `json:"x-kubernetes-map-type,omitempty" protobuf:"bytes,43,opt,name=xKubernetesMapType"` + + // x-kubernetes-validations describes a list of validation rules written in the CEL expression language. + // This field is an alpha-level. Using this field requires the feature gate `CustomResourceValidationExpressions` to be enabled. + // +patchMergeKey=rule + // +patchStrategy=merge + // +listType=map + // +listMapKey=rule + XValidations ValidationRules `json:"x-kubernetes-validations,omitempty" patchStrategy:"merge" patchMergeKey:"rule" protobuf:"bytes,44,rep,name=xKubernetesValidations"` +} + +// ValidationRules describes a list of validation rules written in the CEL expression language. +type ValidationRules []ValidationRule + +// ValidationRule describes a validation rule written in the CEL expression language. +type ValidationRule struct { + // Rule represents the expression which will be evaluated by CEL. + // ref: https://github.com/google/cel-spec + // The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. + // The `self` variable in the CEL expression is bound to the scoped value. + // Example: + // - Rule scoped to the root of a resource with a status subresource: {"rule": "self.status.actual <= self.spec.maxDesired"} + // + // If the Rule is scoped to an object with properties, the accessible properties of the object are field selectable + // via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as + // absent fields in CEL expressions. + // If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map + // are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map + // are accessible via CEL macros and functions such as `self.all(...)`. + // If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and + // functions. + // If the Rule is scoped to a scalar, `self` is bound to the scalar value. + // Examples: + // - Rule scoped to a map of objects: {"rule": "self.components['Widget'].priority < 10"} + // - Rule scoped to a list of integers: {"rule": "self.values.all(value, value >= 0 && value < 100)"} + // - Rule scoped to a string value: {"rule": "self.startsWith('kube')"} + // + // The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the + // object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible. + // + // Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL + // expressions. This includes: + // - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. + // - Object properties where the property schema is of an "unknown type". An "unknown type" is recursively defined as: + // - A schema with no type and x-kubernetes-preserve-unknown-fields set to true + // - An array where the items schema is of an "unknown type" + // - An object where the additionalProperties schema is of an "unknown type" + // + // Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. + // Accessible property names are escaped according to the following rules when accessed in the expression: + // - '__' escapes to '__underscores__' + // - '.' escapes to '__dot__' + // - '-' escapes to '__dash__' + // - '/' escapes to '__slash__' + // - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: + // "true", "false", "null", "in", "as", "break", "const", "continue", "else", "for", "function", "if", + // "import", "let", "loop", "package", "namespace", "return". + // Examples: + // - Rule accessing a property named "namespace": {"rule": "self.__namespace__ > 0"} + // - Rule accessing a property named "x-prop": {"rule": "self.x__dash__prop > 0"} + // - Rule accessing a property named "redact__d": {"rule": "self.redact__underscores__d > 0"} + // + // Equality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. + // Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: + // - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and + // non-intersecting elements in `Y` are appended, retaining their partial order. + // - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values + // are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with + // non-intersecting keys are appended, retaining their partial order. + Rule string `json:"rule" protobuf:"bytes,1,opt,name=rule"` + // Message represents the message displayed when validation fails. The message is required if the Rule contains + // line breaks. The message must not contain line breaks. + // If unset, the message is "failed rule: {Rule}". + // e.g. "must be a URL with the host matching spec.host" + Message string `json:"message,omitempty" protobuf:"bytes,2,opt,name=message"` } // JSON represents any valid JSON value. diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.conversion.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.conversion.go index b22872dc08..77d22c16ce 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -201,6 +202,16 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } + if err := s.AddGeneratedConversionFunc((*ValidationRule)(nil), (*apiextensions.ValidationRule)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1_ValidationRule_To_apiextensions_ValidationRule(a.(*ValidationRule), b.(*apiextensions.ValidationRule), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*apiextensions.ValidationRule)(nil), (*ValidationRule)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_apiextensions_ValidationRule_To_v1_ValidationRule(a.(*apiextensions.ValidationRule), b.(*ValidationRule), scope) + }); err != nil { + return err + } if err := s.AddGeneratedConversionFunc((*WebhookClientConfig)(nil), (*apiextensions.WebhookClientConfig)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_v1_WebhookClientConfig_To_apiextensions_WebhookClientConfig(a.(*WebhookClientConfig), b.(*apiextensions.WebhookClientConfig), scope) }); err != nil { @@ -882,6 +893,7 @@ func autoConvert_v1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(in *JSONSch out.XListMapKeys = *(*[]string)(unsafe.Pointer(&in.XListMapKeys)) out.XListType = (*string)(unsafe.Pointer(in.XListType)) out.XMapType = (*string)(unsafe.Pointer(in.XMapType)) + out.XValidations = *(*apiextensions.ValidationRules)(unsafe.Pointer(&in.XValidations)) return nil } @@ -1070,6 +1082,7 @@ func autoConvert_apiextensions_JSONSchemaProps_To_v1_JSONSchemaProps(in *apiexte out.XListMapKeys = *(*[]string)(unsafe.Pointer(&in.XListMapKeys)) out.XListType = (*string)(unsafe.Pointer(in.XListType)) out.XMapType = (*string)(unsafe.Pointer(in.XMapType)) + out.XValidations = *(*ValidationRules)(unsafe.Pointer(&in.XValidations)) return nil } @@ -1237,6 +1250,28 @@ func Convert_apiextensions_ServiceReference_To_v1_ServiceReference(in *apiextens return autoConvert_apiextensions_ServiceReference_To_v1_ServiceReference(in, out, s) } +func autoConvert_v1_ValidationRule_To_apiextensions_ValidationRule(in *ValidationRule, out *apiextensions.ValidationRule, s conversion.Scope) error { + out.Rule = in.Rule + out.Message = in.Message + return nil +} + +// Convert_v1_ValidationRule_To_apiextensions_ValidationRule is an autogenerated conversion function. +func Convert_v1_ValidationRule_To_apiextensions_ValidationRule(in *ValidationRule, out *apiextensions.ValidationRule, s conversion.Scope) error { + return autoConvert_v1_ValidationRule_To_apiextensions_ValidationRule(in, out, s) +} + +func autoConvert_apiextensions_ValidationRule_To_v1_ValidationRule(in *apiextensions.ValidationRule, out *ValidationRule, s conversion.Scope) error { + out.Rule = in.Rule + out.Message = in.Message + return nil +} + +// Convert_apiextensions_ValidationRule_To_v1_ValidationRule is an autogenerated conversion function. +func Convert_apiextensions_ValidationRule_To_v1_ValidationRule(in *apiextensions.ValidationRule, out *ValidationRule, s conversion.Scope) error { + return autoConvert_apiextensions_ValidationRule_To_v1_ValidationRule(in, out, s) +} + func autoConvert_v1_WebhookClientConfig_To_apiextensions_WebhookClientConfig(in *WebhookClientConfig, out *apiextensions.WebhookClientConfig, s conversion.Scope) error { out.URL = (*string)(unsafe.Pointer(in.URL)) if in.Service != nil { diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.deepcopy.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.deepcopy.go index 7d72bebab2..e27daa9a35 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -610,6 +611,42 @@ func (in *ServiceReference) DeepCopy() *ServiceReference { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ValidationRule) DeepCopyInto(out *ValidationRule) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidationRule. +func (in *ValidationRule) DeepCopy() *ValidationRule { + if in == nil { + return nil + } + out := new(ValidationRule) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in ValidationRules) DeepCopyInto(out *ValidationRules) { + { + in := &in + *out = make(ValidationRules, len(*in)) + copy(*out, *in) + return + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidationRules. +func (in ValidationRules) DeepCopy() ValidationRules { + if in == nil { + return nil + } + out := new(ValidationRules) + in.DeepCopyInto(out) + return *out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *WebhookClientConfig) DeepCopyInto(out *WebhookClientConfig) { *out = *in diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.defaults.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.defaults.go index ed03cdd886..2bc7057809 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion.go index e014ce62fd..eed3fde63e 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion.go @@ -17,6 +17,8 @@ limitations under the License. package v1beta1 import ( + "bytes" + "k8s.io/apimachinery/pkg/conversion" "k8s.io/apimachinery/pkg/util/json" @@ -36,20 +38,29 @@ func Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(in *apiext return nil } +var nullLiteral = []byte(`null`) + func Convert_apiextensions_JSON_To_v1beta1_JSON(in *apiextensions.JSON, out *JSON, s conversion.Scope) error { raw, err := json.Marshal(*in) if err != nil { return err } - out.Raw = raw + if len(raw) == 0 || bytes.Equal(raw, nullLiteral) { + // match JSON#UnmarshalJSON treatment of literal nulls + out.Raw = nil + } else { + out.Raw = raw + } return nil } func Convert_v1beta1_JSON_To_apiextensions_JSON(in *JSON, out *apiextensions.JSON, s conversion.Scope) error { if in != nil { var i interface{} - if err := json.Unmarshal(in.Raw, &i); err != nil { - return err + if len(in.Raw) > 0 && !bytes.Equal(in.Raw, nullLiteral) { + if err := json.Unmarshal(in.Raw, &i); err != nil { + return err + } } *out = i } else { diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go index 7537be1866..625339a042 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go @@ -692,10 +692,38 @@ func (m *ServiceReference) XXX_DiscardUnknown() { var xxx_messageInfo_ServiceReference proto.InternalMessageInfo +func (m *ValidationRule) Reset() { *m = ValidationRule{} } +func (*ValidationRule) ProtoMessage() {} +func (*ValidationRule) Descriptor() ([]byte, []int) { + return fileDescriptor_98a4cc6918394e53, []int{23} +} +func (m *ValidationRule) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidationRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ValidationRule) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidationRule.Merge(m, src) +} +func (m *ValidationRule) XXX_Size() int { + return m.Size() +} +func (m *ValidationRule) XXX_DiscardUnknown() { + xxx_messageInfo_ValidationRule.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidationRule proto.InternalMessageInfo + func (m *WebhookClientConfig) Reset() { *m = WebhookClientConfig{} } func (*WebhookClientConfig) ProtoMessage() {} func (*WebhookClientConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_98a4cc6918394e53, []int{23} + return fileDescriptor_98a4cc6918394e53, []int{24} } func (m *WebhookClientConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -748,6 +776,7 @@ func init() { proto.RegisterType((*JSONSchemaPropsOrBool)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrBool") proto.RegisterType((*JSONSchemaPropsOrStringArray)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrStringArray") proto.RegisterType((*ServiceReference)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ServiceReference") + proto.RegisterType((*ValidationRule)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ValidationRule") proto.RegisterType((*WebhookClientConfig)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.WebhookClientConfig") } @@ -756,196 +785,200 @@ func init() { } var fileDescriptor_98a4cc6918394e53 = []byte{ - // 3022 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcb, 0x73, 0x23, 0x57, - 0xd5, 0x9f, 0x96, 0x2d, 0x5b, 0x3e, 0xb6, 0xc7, 0xf6, 0x9d, 0xb1, 0xd3, 0xe3, 0x4c, 0x2c, 0x8f, - 0xf2, 0x65, 0x3e, 0x27, 0x99, 0x91, 0x13, 0x93, 0x90, 0x90, 0x82, 0xa2, 0x2c, 0xdb, 0x13, 0x9c, - 0x8c, 0x1f, 0x5c, 0xcd, 0x24, 0x86, 0x3c, 0xdb, 0xea, 0x2b, 0xb9, 0xe3, 0x56, 0x77, 0x4f, 0xdf, - 0x6e, 0xd9, 0xae, 0x00, 0xc5, 0xa3, 0x52, 0x50, 0x14, 0x10, 0x8a, 0x64, 0x43, 0x15, 0x2c, 0x02, - 0xc5, 0x86, 0x05, 0x2c, 0xa0, 0xd8, 0xc0, 0x1f, 0x90, 0x65, 0x8a, 0x55, 0x16, 0x94, 0x20, 0x62, - 0xcb, 0x92, 0x2a, 0xaa, 0xbc, 0xa2, 0xee, 0xa3, 0x6f, 0xb7, 0x5a, 0xd2, 0xcc, 0x54, 0x46, 0xca, - 0xb0, 0xb3, 0xce, 0xeb, 0x77, 0xee, 0xb9, 0xe7, 0x9e, 0x7b, 0xee, 0x69, 0x43, 0xf5, 0xf0, 0x59, - 0x5a, 0xb4, 0xdc, 0xe5, 0xc3, 0x70, 0x9f, 0xf8, 0x0e, 0x09, 0x08, 0x5d, 0x6e, 0x10, 0xc7, 0x74, - 0xfd, 0x65, 0xc9, 0x30, 0x3c, 0x8b, 0x1c, 0x07, 0xc4, 0xa1, 0x96, 0xeb, 0xd0, 0xab, 0x86, 0x67, - 0x51, 0xe2, 0x37, 0x88, 0xbf, 0xec, 0x1d, 0xd6, 0x18, 0x8f, 0xb6, 0x0b, 0x2c, 0x37, 0x9e, 0xdc, - 0x27, 0x81, 0xf1, 0xe4, 0x72, 0x8d, 0x38, 0xc4, 0x37, 0x02, 0x62, 0x16, 0x3d, 0xdf, 0x0d, 0x5c, - 0xf4, 0x25, 0x61, 0xae, 0xd8, 0x26, 0xfd, 0x86, 0x32, 0x57, 0xf4, 0x0e, 0x6b, 0x8c, 0x47, 0xdb, - 0x05, 0x8a, 0xd2, 0xdc, 0xfc, 0xd5, 0x9a, 0x15, 0x1c, 0x84, 0xfb, 0xc5, 0x8a, 0x5b, 0x5f, 0xae, - 0xb9, 0x35, 0x77, 0x99, 0x5b, 0xdd, 0x0f, 0xab, 0xfc, 0x17, 0xff, 0xc1, 0xff, 0x12, 0x68, 0xf3, - 0x4f, 0xc5, 0xce, 0xd7, 0x8d, 0xca, 0x81, 0xe5, 0x10, 0xff, 0x24, 0xf6, 0xb8, 0x4e, 0x02, 0x63, - 0xb9, 0xd1, 0xe1, 0xe3, 0xfc, 0x72, 0x2f, 0x2d, 0x3f, 0x74, 0x02, 0xab, 0x4e, 0x3a, 0x14, 0x3e, - 0x7f, 0x27, 0x05, 0x5a, 0x39, 0x20, 0x75, 0x23, 0xad, 0x57, 0x38, 0xd5, 0x60, 0x66, 0xcd, 0x75, - 0x1a, 0xc4, 0x67, 0xab, 0xc4, 0xe4, 0x56, 0x48, 0x68, 0x80, 0x4a, 0x30, 0x14, 0x5a, 0xa6, 0xae, - 0x2d, 0x6a, 0x4b, 0x63, 0xa5, 0x27, 0x3e, 0x6c, 0xe6, 0xcf, 0xb4, 0x9a, 0xf9, 0xa1, 0x9b, 0x9b, - 0xeb, 0xa7, 0xcd, 0xfc, 0xa5, 0x5e, 0x48, 0xc1, 0x89, 0x47, 0x68, 0xf1, 0xe6, 0xe6, 0x3a, 0x66, - 0xca, 0xe8, 0x79, 0x98, 0x31, 0x09, 0xb5, 0x7c, 0x62, 0xae, 0xee, 0x6e, 0xbe, 0x24, 0xec, 0xeb, - 0x19, 0x6e, 0xf1, 0x82, 0xb4, 0x38, 0xb3, 0x9e, 0x16, 0xc0, 0x9d, 0x3a, 0x68, 0x0f, 0x46, 0xdd, - 0xfd, 0xb7, 0x48, 0x25, 0xa0, 0xfa, 0xd0, 0xe2, 0xd0, 0xd2, 0xf8, 0xca, 0xd5, 0x62, 0xbc, 0x83, - 0xca, 0x05, 0xbe, 0x6d, 0x72, 0xb1, 0x45, 0x6c, 0x1c, 0x6d, 0x44, 0x3b, 0x57, 0x9a, 0x92, 0x68, - 0xa3, 0x3b, 0xc2, 0x0a, 0x8e, 0xcc, 0x15, 0x7e, 0x9d, 0x01, 0x94, 0x5c, 0x3c, 0xf5, 0x5c, 0x87, - 0x92, 0xbe, 0xac, 0x9e, 0xc2, 0x74, 0x85, 0x5b, 0x0e, 0x88, 0x29, 0x71, 0xf5, 0xcc, 0xa7, 0xf1, - 0x5e, 0x97, 0xf8, 0xd3, 0x6b, 0x29, 0x73, 0xb8, 0x03, 0x00, 0xdd, 0x80, 0x11, 0x9f, 0xd0, 0xd0, - 0x0e, 0xf4, 0xa1, 0x45, 0x6d, 0x69, 0x7c, 0xe5, 0x4a, 0x4f, 0x28, 0x9e, 0xdf, 0x2c, 0xf9, 0x8a, - 0x8d, 0x27, 0x8b, 0xe5, 0xc0, 0x08, 0x42, 0x5a, 0x3a, 0x2b, 0x91, 0x46, 0x30, 0xb7, 0x81, 0xa5, - 0xad, 0xc2, 0x0f, 0x32, 0x30, 0x9d, 0x8c, 0x52, 0xc3, 0x22, 0x47, 0xe8, 0x08, 0x46, 0x7d, 0x91, - 0x2c, 0x3c, 0x4e, 0xe3, 0x2b, 0xbb, 0xc5, 0x7b, 0x3a, 0x56, 0xc5, 0x8e, 0x24, 0x2c, 0x8d, 0xb3, - 0x3d, 0x93, 0x3f, 0x70, 0x84, 0x86, 0xde, 0x86, 0x9c, 0x2f, 0x37, 0x8a, 0x67, 0xd3, 0xf8, 0xca, - 0x57, 0xfb, 0x88, 0x2c, 0x0c, 0x97, 0x26, 0x5a, 0xcd, 0x7c, 0x2e, 0xfa, 0x85, 0x15, 0x60, 0xe1, - 0xbd, 0x0c, 0x2c, 0xac, 0x85, 0x34, 0x70, 0xeb, 0x98, 0x50, 0x37, 0xf4, 0x2b, 0x64, 0xcd, 0xb5, - 0xc3, 0xba, 0xb3, 0x4e, 0xaa, 0x96, 0x63, 0x05, 0x2c, 0x5b, 0x17, 0x61, 0xd8, 0x31, 0xea, 0x44, - 0x66, 0xcf, 0x84, 0x8c, 0xe9, 0xf0, 0xb6, 0x51, 0x27, 0x98, 0x73, 0x98, 0x04, 0x4b, 0x16, 0x79, - 0x16, 0x94, 0xc4, 0x8d, 0x13, 0x8f, 0x60, 0xce, 0x41, 0x97, 0x61, 0xa4, 0xea, 0xfa, 0x75, 0x43, - 0xec, 0xe3, 0x58, 0xbc, 0x33, 0xd7, 0x38, 0x15, 0x4b, 0x2e, 0x7a, 0x1a, 0xc6, 0x4d, 0x42, 0x2b, - 0xbe, 0xe5, 0x31, 0x68, 0x7d, 0x98, 0x0b, 0x9f, 0x93, 0xc2, 0xe3, 0xeb, 0x31, 0x0b, 0x27, 0xe5, - 0xd0, 0x15, 0xc8, 0x79, 0xbe, 0xe5, 0xfa, 0x56, 0x70, 0xa2, 0x67, 0x17, 0xb5, 0xa5, 0x6c, 0x69, - 0x5a, 0xea, 0xe4, 0x76, 0x25, 0x1d, 0x2b, 0x09, 0xb4, 0x08, 0xb9, 0x17, 0xca, 0x3b, 0xdb, 0xbb, - 0x46, 0x70, 0xa0, 0x8f, 0x70, 0x84, 0x61, 0x26, 0x8d, 0x15, 0xb5, 0xf0, 0xb7, 0x0c, 0xe8, 0xe9, - 0xa8, 0x44, 0x21, 0x45, 0xd7, 0x20, 0x47, 0x03, 0x56, 0x71, 0x6a, 0x27, 0x32, 0x26, 0x8f, 0x45, - 0x60, 0x65, 0x49, 0x3f, 0x6d, 0xe6, 0xe7, 0x62, 0x8d, 0x88, 0xca, 0xe3, 0xa1, 0x74, 0xd1, 0x2f, - 0x35, 0x38, 0x77, 0x44, 0xf6, 0x0f, 0x5c, 0xf7, 0x70, 0xcd, 0xb6, 0x88, 0x13, 0xac, 0xb9, 0x4e, - 0xd5, 0xaa, 0xc9, 0x1c, 0xc0, 0xf7, 0x98, 0x03, 0x2f, 0x77, 0x5a, 0x2e, 0x3d, 0xd0, 0x6a, 0xe6, - 0xcf, 0x75, 0x61, 0xe0, 0x6e, 0x7e, 0xa0, 0x3d, 0xd0, 0x2b, 0xa9, 0x43, 0x22, 0x0b, 0x98, 0x28, - 0x5b, 0x63, 0xa5, 0x8b, 0xad, 0x66, 0x5e, 0x5f, 0xeb, 0x21, 0x83, 0x7b, 0x6a, 0x17, 0xbe, 0x37, - 0x94, 0x0e, 0x6f, 0x22, 0xdd, 0xde, 0x84, 0x1c, 0x3b, 0xc6, 0xa6, 0x11, 0x18, 0xf2, 0x20, 0x3e, - 0x71, 0x77, 0x87, 0x5e, 0xd4, 0x8c, 0x2d, 0x12, 0x18, 0x25, 0x24, 0x37, 0x04, 0x62, 0x1a, 0x56, - 0x56, 0xd1, 0x37, 0x61, 0x98, 0x7a, 0xa4, 0x22, 0x03, 0xfd, 0xca, 0xbd, 0x1e, 0xb6, 0x1e, 0x0b, - 0x29, 0x7b, 0xa4, 0x12, 0x9f, 0x05, 0xf6, 0x0b, 0x73, 0x58, 0xf4, 0x8e, 0x06, 0x23, 0x94, 0x17, - 0x28, 0x59, 0xd4, 0x5e, 0x1b, 0x94, 0x07, 0xa9, 0x2a, 0x28, 0x7e, 0x63, 0x09, 0x5e, 0xf8, 0x77, - 0x06, 0x2e, 0xf5, 0x52, 0x5d, 0x73, 0x1d, 0x53, 0x6c, 0xc7, 0xa6, 0x3c, 0xdb, 0x22, 0xd3, 0x9f, - 0x4e, 0x9e, 0xed, 0xd3, 0x66, 0xfe, 0x91, 0x3b, 0x1a, 0x48, 0x14, 0x81, 0x2f, 0xa8, 0x75, 0x8b, - 0x42, 0x71, 0xa9, 0xdd, 0xb1, 0xd3, 0x66, 0x7e, 0x4a, 0xa9, 0xb5, 0xfb, 0x8a, 0x1a, 0x80, 0x6c, - 0x83, 0x06, 0x37, 0x7c, 0xc3, 0xa1, 0xc2, 0xac, 0x55, 0x27, 0x32, 0x7c, 0x8f, 0xdd, 0x5d, 0x7a, - 0x30, 0x8d, 0xd2, 0xbc, 0x84, 0x44, 0xd7, 0x3b, 0xac, 0xe1, 0x2e, 0x08, 0xac, 0x6e, 0xf9, 0xc4, - 0xa0, 0xaa, 0x14, 0x25, 0x6e, 0x14, 0x46, 0xc5, 0x92, 0x8b, 0x1e, 0x85, 0xd1, 0x3a, 0xa1, 0xd4, - 0xa8, 0x11, 0x5e, 0x7f, 0xc6, 0xe2, 0x2b, 0x7a, 0x4b, 0x90, 0x71, 0xc4, 0x67, 0xfd, 0xc9, 0xc5, - 0x5e, 0x51, 0xbb, 0x6e, 0xd1, 0x00, 0xbd, 0xda, 0x71, 0x00, 0x8a, 0x77, 0xb7, 0x42, 0xa6, 0xcd, - 0xd3, 0x5f, 0x15, 0xbf, 0x88, 0x92, 0x48, 0xfe, 0x6f, 0x40, 0xd6, 0x0a, 0x48, 0x3d, 0xba, 0xbb, - 0x5f, 0x1e, 0x50, 0xee, 0x95, 0x26, 0xa5, 0x0f, 0xd9, 0x4d, 0x86, 0x86, 0x05, 0x68, 0xe1, 0x37, - 0x19, 0x78, 0xa8, 0x97, 0x0a, 0xbb, 0x50, 0x28, 0x8b, 0xb8, 0x67, 0x87, 0xbe, 0x61, 0xcb, 0x8c, - 0x53, 0x11, 0xdf, 0xe5, 0x54, 0x2c, 0xb9, 0xac, 0xe4, 0x53, 0xcb, 0xa9, 0x85, 0xb6, 0xe1, 0xcb, - 0x74, 0x52, 0xab, 0x2e, 0x4b, 0x3a, 0x56, 0x12, 0xa8, 0x08, 0x40, 0x0f, 0x5c, 0x3f, 0xe0, 0x18, - 0xb2, 0x7a, 0x9d, 0x65, 0x05, 0xa2, 0xac, 0xa8, 0x38, 0x21, 0xc1, 0x6e, 0xb4, 0x43, 0xcb, 0x31, - 0xe5, 0xae, 0xab, 0x53, 0xfc, 0xa2, 0xe5, 0x98, 0x98, 0x73, 0x18, 0xbe, 0x6d, 0xd1, 0x80, 0x51, - 0xe4, 0x96, 0xb7, 0x45, 0x9d, 0x4b, 0x2a, 0x09, 0x86, 0x5f, 0x61, 0x55, 0xdf, 0xf5, 0x2d, 0x42, - 0xf5, 0x91, 0x18, 0x7f, 0x4d, 0x51, 0x71, 0x42, 0xa2, 0xf0, 0xaf, 0x5c, 0xef, 0x24, 0x61, 0xa5, - 0x04, 0x3d, 0x0c, 0xd9, 0x9a, 0xef, 0x86, 0x9e, 0x8c, 0x92, 0x8a, 0xf6, 0xf3, 0x8c, 0x88, 0x05, - 0x8f, 0x65, 0x65, 0xa3, 0xad, 0x4d, 0x55, 0x59, 0x19, 0x35, 0xa7, 0x11, 0x1f, 0x7d, 0x47, 0x83, - 0xac, 0x23, 0x83, 0xc3, 0x52, 0xee, 0xd5, 0x01, 0xe5, 0x05, 0x0f, 0x6f, 0xec, 0xae, 0x88, 0xbc, - 0x40, 0x46, 0x4f, 0x41, 0x96, 0x56, 0x5c, 0x8f, 0xc8, 0xa8, 0x2f, 0x44, 0x42, 0x65, 0x46, 0x3c, - 0x6d, 0xe6, 0x27, 0x23, 0x73, 0x9c, 0x80, 0x85, 0x30, 0xfa, 0xbe, 0x06, 0xd0, 0x30, 0x6c, 0xcb, - 0x34, 0x78, 0xcb, 0x90, 0xe5, 0xee, 0xf7, 0x37, 0xad, 0x5f, 0x52, 0xe6, 0xc5, 0xa6, 0xc5, 0xbf, - 0x71, 0x02, 0x1a, 0xbd, 0xab, 0xc1, 0x04, 0x0d, 0xf7, 0x7d, 0xa9, 0x45, 0x79, 0x73, 0x31, 0xbe, - 0xf2, 0xb5, 0xbe, 0xfa, 0x52, 0x4e, 0x00, 0x94, 0xa6, 0x5b, 0xcd, 0xfc, 0x44, 0x92, 0x82, 0xdb, - 0x1c, 0x40, 0x3f, 0xd2, 0x20, 0xd7, 0x88, 0xee, 0xec, 0x51, 0x7e, 0xe0, 0x5f, 0x1f, 0xd0, 0xc6, - 0xca, 0x8c, 0x8a, 0x4f, 0x81, 0xea, 0x03, 0x94, 0x07, 0xe8, 0xcf, 0x1a, 0xe8, 0x86, 0x29, 0x0a, - 0xbc, 0x61, 0xef, 0xfa, 0x96, 0x13, 0x10, 0x5f, 0xf4, 0x9b, 0x54, 0xcf, 0x71, 0xf7, 0xfa, 0x7b, - 0x17, 0xa6, 0x7b, 0xd9, 0xd2, 0xa2, 0xf4, 0x4e, 0x5f, 0xed, 0xe1, 0x06, 0xee, 0xe9, 0x20, 0x4f, - 0xb4, 0xb8, 0xa5, 0xd1, 0xc7, 0x06, 0x90, 0x68, 0x71, 0x2f, 0x25, 0xab, 0x43, 0xdc, 0x41, 0x25, - 0xa0, 0xd1, 0x0e, 0xcc, 0x7a, 0x3e, 0xe1, 0x00, 0x37, 0x9d, 0x43, 0xc7, 0x3d, 0x72, 0xae, 0x59, - 0xc4, 0x36, 0xa9, 0x0e, 0x8b, 0xda, 0x52, 0xae, 0x74, 0xa1, 0xd5, 0xcc, 0xcf, 0xee, 0x76, 0x13, - 0xc0, 0xdd, 0xf5, 0x0a, 0xef, 0x0e, 0xa5, 0x5f, 0x01, 0xe9, 0x2e, 0x02, 0xbd, 0x2f, 0x56, 0x2f, - 0x62, 0x43, 0x75, 0x8d, 0xef, 0xd6, 0x9b, 0x03, 0x4a, 0x26, 0xd5, 0x06, 0xc4, 0x9d, 0x9c, 0x22, - 0x51, 0x9c, 0xf0, 0x03, 0xfd, 0x5c, 0x83, 0x49, 0xa3, 0x52, 0x21, 0x5e, 0x40, 0x4c, 0x51, 0xdc, - 0x33, 0x9f, 0x41, 0xfd, 0x9a, 0x95, 0x5e, 0x4d, 0xae, 0x26, 0xa1, 0x71, 0xbb, 0x27, 0xe8, 0x39, - 0x38, 0x4b, 0x03, 0xd7, 0x27, 0x66, 0xaa, 0x6d, 0x46, 0xad, 0x66, 0xfe, 0x6c, 0xb9, 0x8d, 0x83, - 0x53, 0x92, 0x85, 0xbf, 0x67, 0x21, 0x7f, 0x87, 0xa3, 0x76, 0x17, 0x0f, 0xb3, 0xcb, 0x30, 0xc2, - 0x97, 0x6b, 0xf2, 0xa8, 0xe4, 0x12, 0xad, 0x20, 0xa7, 0x62, 0xc9, 0x65, 0x17, 0x05, 0xc3, 0x67, - 0xed, 0xcb, 0x10, 0x17, 0x54, 0x17, 0x45, 0x59, 0x90, 0x71, 0xc4, 0x47, 0x2b, 0x00, 0x26, 0xf1, - 0x7c, 0xc2, 0x2e, 0x2b, 0x53, 0x1f, 0xe5, 0xd2, 0x6a, 0x93, 0xd6, 0x15, 0x07, 0x27, 0xa4, 0xd0, - 0x35, 0x40, 0xd1, 0x2f, 0xcb, 0x75, 0x5e, 0x36, 0x7c, 0xc7, 0x72, 0x6a, 0x7a, 0x8e, 0xbb, 0x3d, - 0xc7, 0xba, 0xb1, 0xf5, 0x0e, 0x2e, 0xee, 0xa2, 0x81, 0xde, 0x86, 0x11, 0x31, 0xf4, 0xe1, 0x37, - 0xc4, 0x00, 0xab, 0x3c, 0xf0, 0x18, 0x71, 0x28, 0x2c, 0x21, 0x3b, 0xab, 0x7b, 0xf6, 0x7e, 0x57, - 0xf7, 0xdb, 0x96, 0xd3, 0x91, 0xff, 0xf1, 0x72, 0x5a, 0xf8, 0x8f, 0x96, 0xae, 0x39, 0x89, 0xa5, - 0x96, 0x2b, 0x86, 0x4d, 0xd0, 0x3a, 0x4c, 0xb3, 0x17, 0x13, 0x26, 0x9e, 0x6d, 0x55, 0x0c, 0xca, - 0x1f, 0xec, 0x22, 0xd9, 0xd5, 0x0c, 0xa9, 0x9c, 0xe2, 0xe3, 0x0e, 0x0d, 0xf4, 0x02, 0x20, 0xf1, - 0x8a, 0x68, 0xb3, 0x23, 0x1a, 0x22, 0xf5, 0x1e, 0x28, 0x77, 0x48, 0xe0, 0x2e, 0x5a, 0x68, 0x0d, - 0x66, 0x6c, 0x63, 0x9f, 0xd8, 0x65, 0x62, 0x93, 0x4a, 0xe0, 0xfa, 0xdc, 0x94, 0x18, 0x69, 0xcc, - 0xb6, 0x9a, 0xf9, 0x99, 0xeb, 0x69, 0x26, 0xee, 0x94, 0x2f, 0x5c, 0x4a, 0x1f, 0xed, 0xe4, 0xc2, - 0xc5, 0xdb, 0xec, 0x83, 0x0c, 0xcc, 0xf7, 0xce, 0x0c, 0xf4, 0xdd, 0xf8, 0x09, 0x29, 0x5e, 0x08, - 0xaf, 0x0f, 0x2a, 0x0b, 0xe5, 0x1b, 0x12, 0x3a, 0xdf, 0x8f, 0xe8, 0x5b, 0xac, 0x5d, 0x33, 0xec, - 0x68, 0x68, 0xf5, 0xda, 0xc0, 0x5c, 0x60, 0x20, 0xa5, 0x31, 0xd1, 0x09, 0x1a, 0x36, 0x6f, 0xfc, - 0x0c, 0x9b, 0x14, 0x7e, 0xab, 0xa5, 0xa7, 0x08, 0xf1, 0x09, 0x46, 0x3f, 0xd6, 0x60, 0xca, 0xf5, - 0x88, 0xb3, 0xba, 0xbb, 0xf9, 0xd2, 0xe7, 0xc4, 0x49, 0x96, 0xa1, 0xda, 0xbe, 0x47, 0x3f, 0x5f, - 0x28, 0xef, 0x6c, 0x0b, 0x83, 0xbb, 0xbe, 0xeb, 0xd1, 0xd2, 0xb9, 0x56, 0x33, 0x3f, 0xb5, 0xd3, - 0x0e, 0x85, 0xd3, 0xd8, 0x85, 0x3a, 0xcc, 0x6e, 0x1c, 0x07, 0xc4, 0x77, 0x0c, 0x7b, 0xdd, 0xad, - 0x84, 0x75, 0xe2, 0x04, 0xc2, 0xd1, 0xd4, 0xc4, 0x4b, 0xbb, 0xcb, 0x89, 0xd7, 0x43, 0x30, 0x14, - 0xfa, 0xb6, 0xcc, 0xe2, 0x71, 0x35, 0xd1, 0xc5, 0xd7, 0x31, 0xa3, 0x17, 0x2e, 0xc1, 0x30, 0xf3, - 0x13, 0x5d, 0x80, 0x21, 0xdf, 0x38, 0xe2, 0x56, 0x27, 0x4a, 0xa3, 0x4c, 0x04, 0x1b, 0x47, 0x98, - 0xd1, 0x0a, 0x7f, 0x5a, 0x84, 0xa9, 0xd4, 0x5a, 0xd0, 0x3c, 0x64, 0xd4, 0x98, 0x18, 0xa4, 0xd1, - 0xcc, 0xe6, 0x3a, 0xce, 0x58, 0x26, 0x7a, 0x46, 0x15, 0x5f, 0x01, 0x9a, 0x57, 0x77, 0x09, 0xa7, - 0xb2, 0xfe, 0x3c, 0x36, 0xc7, 0x1c, 0x89, 0x0a, 0x27, 0xf3, 0x81, 0x54, 0xe5, 0x29, 0x11, 0x3e, - 0x90, 0x2a, 0x66, 0xb4, 0x4f, 0x3b, 0xee, 0x8b, 0xe6, 0x8d, 0xd9, 0xbb, 0x98, 0x37, 0x8e, 0xdc, - 0x76, 0xde, 0xf8, 0x30, 0x64, 0x03, 0x2b, 0xb0, 0x09, 0xbf, 0xc8, 0x12, 0xcf, 0xa8, 0x1b, 0x8c, - 0x88, 0x05, 0x0f, 0xbd, 0x05, 0xa3, 0x26, 0xa9, 0x1a, 0xa1, 0x1d, 0xf0, 0x3b, 0x6b, 0x7c, 0x65, - 0xad, 0x0f, 0x29, 0x24, 0x86, 0xc1, 0xeb, 0xc2, 0x2e, 0x8e, 0x00, 0xd0, 0x23, 0x30, 0x5a, 0x37, - 0x8e, 0xad, 0x7a, 0x58, 0xe7, 0x0d, 0xa6, 0x26, 0xc4, 0xb6, 0x04, 0x09, 0x47, 0x3c, 0x56, 0x19, - 0xc9, 0x71, 0xc5, 0x0e, 0xa9, 0xd5, 0x20, 0x92, 0x29, 0x9b, 0x3f, 0x55, 0x19, 0x37, 0x52, 0x7c, - 0xdc, 0xa1, 0xc1, 0xc1, 0x2c, 0x87, 0x2b, 0x8f, 0x27, 0xc0, 0x04, 0x09, 0x47, 0xbc, 0x76, 0x30, - 0x29, 0x3f, 0xd1, 0x0b, 0x4c, 0x2a, 0x77, 0x68, 0xa0, 0xc7, 0x61, 0xac, 0x6e, 0x1c, 0x5f, 0x27, - 0x4e, 0x2d, 0x38, 0xd0, 0x27, 0x17, 0xb5, 0xa5, 0xa1, 0xd2, 0x64, 0xab, 0x99, 0x1f, 0xdb, 0x8a, - 0x88, 0x38, 0xe6, 0x73, 0x61, 0xcb, 0x91, 0xc2, 0x67, 0x13, 0xc2, 0x11, 0x11, 0xc7, 0x7c, 0xd6, - 0xbd, 0x78, 0x46, 0xc0, 0x0e, 0x97, 0x3e, 0xd5, 0xfe, 0xcc, 0xdd, 0x15, 0x64, 0x1c, 0xf1, 0xd1, - 0x12, 0xe4, 0xea, 0xc6, 0x31, 0x1f, 0x49, 0xe8, 0xd3, 0xdc, 0x2c, 0x1f, 0x8c, 0x6f, 0x49, 0x1a, - 0x56, 0x5c, 0x2e, 0x69, 0x39, 0x42, 0x72, 0x26, 0x21, 0x29, 0x69, 0x58, 0x71, 0x59, 0x12, 0x87, - 0x8e, 0x75, 0x2b, 0x24, 0x42, 0x18, 0xf1, 0xc8, 0xa8, 0x24, 0xbe, 0x19, 0xb3, 0x70, 0x52, 0x0e, - 0x15, 0x01, 0xea, 0xa1, 0x1d, 0x58, 0x9e, 0x4d, 0x76, 0xaa, 0xfa, 0x39, 0x1e, 0x7f, 0xde, 0xf4, - 0x6f, 0x29, 0x2a, 0x4e, 0x48, 0x20, 0x02, 0xc3, 0xc4, 0x09, 0xeb, 0xfa, 0x79, 0x7e, 0xb1, 0xf7, - 0x25, 0x05, 0xd5, 0xc9, 0xd9, 0x70, 0xc2, 0x3a, 0xe6, 0xe6, 0xd1, 0x33, 0x30, 0x59, 0x37, 0x8e, - 0x59, 0x39, 0x20, 0x7e, 0x60, 0x11, 0xaa, 0xcf, 0xf2, 0xc5, 0xcf, 0xb0, 0x6e, 0x77, 0x2b, 0xc9, - 0xc0, 0xed, 0x72, 0x5c, 0xd1, 0x72, 0x12, 0x8a, 0x73, 0x09, 0xc5, 0x24, 0x03, 0xb7, 0xcb, 0xb1, - 0x48, 0xfb, 0xe4, 0x56, 0x68, 0xf9, 0xc4, 0xd4, 0x1f, 0xe0, 0x0d, 0xb2, 0xfc, 0x58, 0x21, 0x68, - 0x58, 0x71, 0x51, 0x23, 0x9a, 0x5d, 0xe9, 0xfc, 0x18, 0xde, 0xec, 0x6f, 0x25, 0xdf, 0xf1, 0x57, - 0x7d, 0xdf, 0x38, 0x11, 0x37, 0x4d, 0x72, 0x6a, 0x85, 0x28, 0x64, 0x0d, 0xdb, 0xde, 0xa9, 0xea, - 0x17, 0x78, 0xec, 0xfb, 0x7d, 0x83, 0xa8, 0xaa, 0xb3, 0xca, 0x40, 0xb0, 0xc0, 0x62, 0xa0, 0xae, - 0xc3, 0x52, 0x63, 0x7e, 0xb0, 0xa0, 0x3b, 0x0c, 0x04, 0x0b, 0x2c, 0xbe, 0x52, 0xe7, 0x64, 0xa7, - 0xaa, 0x3f, 0x38, 0xe0, 0x95, 0x32, 0x10, 0x2c, 0xb0, 0x90, 0x05, 0x43, 0x8e, 0x1b, 0xe8, 0x17, - 0x07, 0x72, 0x3d, 0xf3, 0x0b, 0x67, 0xdb, 0x0d, 0x30, 0xc3, 0x40, 0x3f, 0xd3, 0x00, 0xbc, 0x38, - 0x45, 0x1f, 0xea, 0xcb, 0x48, 0x24, 0x05, 0x59, 0x8c, 0x73, 0x7b, 0xc3, 0x09, 0xfc, 0x93, 0xf8, - 0x79, 0x94, 0x38, 0x03, 0x09, 0x2f, 0xd0, 0xaf, 0x34, 0x38, 0x9f, 0x6c, 0x93, 0x95, 0x7b, 0x0b, - 0x3c, 0x22, 0x37, 0xfa, 0x9d, 0xe6, 0x25, 0xd7, 0xb5, 0x4b, 0x7a, 0xab, 0x99, 0x3f, 0xbf, 0xda, - 0x05, 0x15, 0x77, 0xf5, 0x05, 0xfd, 0x4e, 0x83, 0x19, 0x59, 0x45, 0x13, 0x1e, 0xe6, 0x79, 0x00, - 0x49, 0xbf, 0x03, 0x98, 0xc6, 0x11, 0x71, 0x54, 0x1f, 0xd9, 0x3b, 0xf8, 0xb8, 0xd3, 0x35, 0xf4, - 0x47, 0x0d, 0x26, 0x4c, 0xe2, 0x11, 0xc7, 0x24, 0x4e, 0x85, 0xf9, 0xba, 0xd8, 0x97, 0x91, 0x45, - 0xda, 0xd7, 0xf5, 0x04, 0x84, 0x70, 0xb3, 0x28, 0xdd, 0x9c, 0x48, 0xb2, 0x4e, 0x9b, 0xf9, 0xb9, - 0x58, 0x35, 0xc9, 0xc1, 0x6d, 0x5e, 0xa2, 0xf7, 0x34, 0x98, 0x8a, 0x37, 0x40, 0x5c, 0x29, 0x97, - 0x06, 0x98, 0x07, 0xbc, 0x7d, 0x5d, 0x6d, 0x07, 0xc4, 0x69, 0x0f, 0xd0, 0xef, 0x35, 0xd6, 0xa9, - 0x45, 0xef, 0x3e, 0xaa, 0x17, 0x78, 0x2c, 0xdf, 0xe8, 0x7b, 0x2c, 0x15, 0x82, 0x08, 0xe5, 0x95, - 0xb8, 0x15, 0x54, 0x9c, 0xd3, 0x66, 0x7e, 0x36, 0x19, 0x49, 0xc5, 0xc0, 0x49, 0x0f, 0xd1, 0x0f, - 0x35, 0x98, 0x20, 0x71, 0xc7, 0x4d, 0xf5, 0x87, 0xfb, 0x12, 0xc4, 0xae, 0x4d, 0xbc, 0x78, 0xa9, - 0x27, 0x58, 0x14, 0xb7, 0x61, 0xb3, 0x0e, 0x92, 0x1c, 0x1b, 0x75, 0xcf, 0x26, 0xfa, 0xff, 0xf5, - 0xb9, 0x83, 0xdc, 0x10, 0x76, 0x71, 0x04, 0x80, 0xae, 0x40, 0xce, 0x09, 0x6d, 0xdb, 0xd8, 0xb7, - 0x89, 0xfe, 0x08, 0xef, 0x45, 0xd4, 0x48, 0x76, 0x5b, 0xd2, 0xb1, 0x92, 0x40, 0x55, 0x58, 0x3c, - 0x7e, 0x51, 0xfd, 0x7b, 0x52, 0xd7, 0xa1, 0xa1, 0x7e, 0x99, 0x5b, 0x99, 0x6f, 0x35, 0xf3, 0x73, - 0x7b, 0xdd, 0xc7, 0x8a, 0x77, 0xb4, 0x81, 0x5e, 0x81, 0x07, 0x13, 0x32, 0x1b, 0xf5, 0x7d, 0x62, - 0x9a, 0xc4, 0x8c, 0x1e, 0x6e, 0xfa, 0xff, 0x8b, 0xc1, 0x65, 0x74, 0xc0, 0xf7, 0xd2, 0x02, 0xf8, - 0x76, 0xda, 0xe8, 0x3a, 0xcc, 0x25, 0xd8, 0x9b, 0x4e, 0xb0, 0xe3, 0x97, 0x03, 0xdf, 0x72, 0x6a, - 0xfa, 0x12, 0xb7, 0x7b, 0x3e, 0x3a, 0x91, 0x7b, 0x09, 0x1e, 0xee, 0xa1, 0x83, 0xbe, 0xd2, 0x66, - 0x8d, 0x7f, 0x42, 0x33, 0xbc, 0x17, 0xc9, 0x09, 0xd5, 0x1f, 0xe5, 0xdd, 0x09, 0xdf, 0xec, 0xbd, - 0x04, 0x1d, 0xf7, 0x90, 0x47, 0x5f, 0x86, 0x73, 0x29, 0x0e, 0x7b, 0xa2, 0xe8, 0x8f, 0x89, 0xb7, - 0x06, 0xeb, 0x67, 0xf7, 0x22, 0x22, 0xee, 0x26, 0x89, 0xbe, 0x08, 0x28, 0x41, 0xde, 0x32, 0x3c, - 0xae, 0xff, 0xb8, 0x78, 0xf6, 0xb0, 0x1d, 0xdd, 0x93, 0x34, 0xdc, 0x45, 0x6e, 0x9e, 0xbd, 0x81, - 0x53, 0x35, 0x14, 0x4d, 0xc3, 0xd0, 0x21, 0x91, 0xff, 0xb7, 0x80, 0xd9, 0x9f, 0xc8, 0x84, 0x6c, - 0xc3, 0xb0, 0xc3, 0xe8, 0x19, 0xdf, 0xe7, 0xfb, 0x17, 0x0b, 0xe3, 0xcf, 0x65, 0x9e, 0xd5, 0xe6, - 0xdf, 0xd7, 0x60, 0xae, 0x7b, 0x69, 0xbf, 0xaf, 0x6e, 0xfd, 0x42, 0x83, 0x99, 0x8e, 0x2a, 0xde, - 0xc5, 0xa3, 0x5b, 0xed, 0x1e, 0xbd, 0xd2, 0xef, 0x72, 0x2c, 0xd2, 0x8f, 0xf7, 0xa0, 0x49, 0xf7, - 0x7e, 0xa2, 0xc1, 0x74, 0xba, 0x30, 0xde, 0xcf, 0x78, 0x15, 0xde, 0xcf, 0xc0, 0x5c, 0xf7, 0xd6, - 0x19, 0xf9, 0x6a, 0x46, 0x30, 0x98, 0x59, 0x4b, 0xb7, 0xb9, 0xec, 0x3b, 0x1a, 0x8c, 0xbf, 0xa5, - 0xe4, 0xa2, 0xef, 0xda, 0x7d, 0x9f, 0xf2, 0x44, 0x37, 0x51, 0xcc, 0xa0, 0x38, 0x89, 0x5b, 0xf8, - 0x83, 0x06, 0xb3, 0x5d, 0xaf, 0x58, 0x74, 0x19, 0x46, 0x0c, 0xdb, 0x76, 0x8f, 0xc4, 0xb0, 0x2e, - 0x31, 0x85, 0x5f, 0xe5, 0x54, 0x2c, 0xb9, 0x89, 0xe8, 0x65, 0x3e, 0xab, 0xe8, 0x15, 0xfe, 0xa2, - 0xc1, 0xc5, 0xdb, 0x65, 0xe2, 0x7d, 0xd9, 0xd2, 0x25, 0xc8, 0xc9, 0xf6, 0xf8, 0x84, 0x6f, 0xa7, - 0x2c, 0x76, 0xb2, 0x68, 0xf0, 0x7f, 0xe5, 0x12, 0x7f, 0x15, 0x3e, 0xd0, 0x60, 0xba, 0x4c, 0xfc, - 0x86, 0x55, 0x21, 0x98, 0x54, 0x89, 0x4f, 0x9c, 0x0a, 0x41, 0xcb, 0x30, 0xc6, 0x3f, 0x28, 0x7b, - 0x46, 0x25, 0xfa, 0x38, 0x32, 0x23, 0x43, 0x3e, 0xb6, 0x1d, 0x31, 0x70, 0x2c, 0xa3, 0x3e, 0xa4, - 0x64, 0x7a, 0x7e, 0x48, 0xb9, 0x08, 0xc3, 0x5e, 0x3c, 0xea, 0xcd, 0x31, 0x2e, 0x9f, 0xee, 0x72, - 0x2a, 0xe7, 0xba, 0x7e, 0xc0, 0xe7, 0x57, 0x59, 0xc9, 0x75, 0xfd, 0x00, 0x73, 0x6a, 0xe1, 0xaf, - 0x1a, 0x74, 0xfb, 0xa7, 0x2b, 0x74, 0x41, 0x8c, 0xf0, 0x12, 0x73, 0xb1, 0x68, 0x7c, 0x87, 0x1a, - 0x30, 0x4a, 0xc5, 0xaa, 0x64, 0xd4, 0x77, 0xee, 0x31, 0xea, 0xe9, 0x18, 0x89, 0xde, 0x21, 0xa2, - 0x46, 0x60, 0x2c, 0xf0, 0x15, 0xa3, 0x14, 0x3a, 0xa6, 0x9c, 0xea, 0x4e, 0x88, 0xc0, 0xaf, 0xad, - 0x0a, 0x1a, 0x56, 0xdc, 0xd2, 0xd5, 0x0f, 0x3f, 0x59, 0x38, 0xf3, 0xd1, 0x27, 0x0b, 0x67, 0x3e, - 0xfe, 0x64, 0xe1, 0xcc, 0xb7, 0x5b, 0x0b, 0xda, 0x87, 0xad, 0x05, 0xed, 0xa3, 0xd6, 0x82, 0xf6, - 0x71, 0x6b, 0x41, 0xfb, 0x47, 0x6b, 0x41, 0xfb, 0xe9, 0x3f, 0x17, 0xce, 0x7c, 0x7d, 0x54, 0xe2, - 0xff, 0x37, 0x00, 0x00, 0xff, 0xff, 0x26, 0x4f, 0x67, 0x24, 0x0a, 0x2d, 0x00, 0x00, + // 3075 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x73, 0x23, 0x47, + 0x15, 0xdf, 0x91, 0x2d, 0x5b, 0x6e, 0xdb, 0x6b, 0xbb, 0x77, 0xed, 0xcc, 0x3a, 0x1b, 0xcb, 0x56, + 0xc8, 0xe2, 0x24, 0xbb, 0x72, 0x62, 0x12, 0x12, 0x52, 0x50, 0x94, 0x65, 0x7b, 0x83, 0x93, 0xf5, + 0x07, 0xad, 0xdd, 0xc4, 0x90, 0xcf, 0xb6, 0xa6, 0x2d, 0x4f, 0x3c, 0x9a, 0x99, 0x9d, 0x9e, 0x91, + 0xed, 0x0a, 0x50, 0x7c, 0x54, 0x0a, 0x8a, 0x02, 0x42, 0x91, 0x5c, 0x28, 0xe0, 0x10, 0x28, 0x2e, + 0x1c, 0xe0, 0x00, 0x37, 0xf8, 0x03, 0x72, 0x4c, 0x51, 0x1c, 0x72, 0xa0, 0x04, 0x2b, 0xae, 0x1c, + 0xa9, 0xa2, 0xca, 0x27, 0xaa, 0x3f, 0xa6, 0xa7, 0x35, 0x92, 0x76, 0xb7, 0xb2, 0x52, 0x96, 0x9b, + 0xf5, 0xbe, 0x7e, 0xaf, 0x5f, 0xbf, 0x7e, 0xfd, 0xfa, 0x8d, 0xc1, 0xfe, 0xe1, 0xb3, 0xb4, 0x68, + 0x7b, 0x4b, 0x87, 0xd1, 0x1e, 0x09, 0x5c, 0x12, 0x12, 0xba, 0x54, 0x27, 0xae, 0xe5, 0x05, 0x4b, + 0x92, 0x81, 0x7d, 0x9b, 0x1c, 0x87, 0xc4, 0xa5, 0xb6, 0xe7, 0xd2, 0x2b, 0xd8, 0xb7, 0x29, 0x09, + 0xea, 0x24, 0x58, 0xf2, 0x0f, 0xab, 0x8c, 0x47, 0x5b, 0x05, 0x96, 0xea, 0x4f, 0xee, 0x91, 0x10, + 0x3f, 0xb9, 0x54, 0x25, 0x2e, 0x09, 0x70, 0x48, 0xac, 0xa2, 0x1f, 0x78, 0xa1, 0x07, 0xbf, 0x24, + 0xcc, 0x15, 0x5b, 0xa4, 0xdf, 0x50, 0xe6, 0x8a, 0xfe, 0x61, 0x95, 0xf1, 0x68, 0xab, 0x40, 0x51, + 0x9a, 0x9b, 0xbd, 0x52, 0xb5, 0xc3, 0x83, 0x68, 0xaf, 0x58, 0xf1, 0x6a, 0x4b, 0x55, 0xaf, 0xea, + 0x2d, 0x71, 0xab, 0x7b, 0xd1, 0x3e, 0xff, 0xc5, 0x7f, 0xf0, 0xbf, 0x04, 0xda, 0xec, 0x53, 0x89, + 0xf3, 0x35, 0x5c, 0x39, 0xb0, 0x5d, 0x12, 0x9c, 0x24, 0x1e, 0xd7, 0x48, 0x88, 0x97, 0xea, 0x6d, + 0x3e, 0xce, 0x2e, 0x75, 0xd3, 0x0a, 0x22, 0x37, 0xb4, 0x6b, 0xa4, 0x4d, 0xe1, 0xf3, 0x77, 0x52, + 0xa0, 0x95, 0x03, 0x52, 0xc3, 0x69, 0xbd, 0xc2, 0xa9, 0x01, 0xa6, 0x56, 0x3d, 0xb7, 0x4e, 0x02, + 0xb6, 0x4a, 0x44, 0x6e, 0x46, 0x84, 0x86, 0xb0, 0x04, 0x06, 0x22, 0xdb, 0x32, 0x8d, 0x79, 0x63, + 0x71, 0xa4, 0xf4, 0xc4, 0x87, 0x8d, 0xfc, 0x99, 0x66, 0x23, 0x3f, 0x70, 0x63, 0x63, 0xed, 0xb4, + 0x91, 0x5f, 0xe8, 0x86, 0x14, 0x9e, 0xf8, 0x84, 0x16, 0x6f, 0x6c, 0xac, 0x21, 0xa6, 0x0c, 0x9f, + 0x07, 0x53, 0x16, 0xa1, 0x76, 0x40, 0xac, 0x95, 0x9d, 0x8d, 0x97, 0x84, 0x7d, 0x33, 0xc3, 0x2d, + 0x5e, 0x90, 0x16, 0xa7, 0xd6, 0xd2, 0x02, 0xa8, 0x5d, 0x07, 0xee, 0x82, 0x61, 0x6f, 0xef, 0x2d, + 0x52, 0x09, 0xa9, 0x39, 0x30, 0x3f, 0xb0, 0x38, 0xba, 0x7c, 0xa5, 0x98, 0xec, 0xa0, 0x72, 0x81, + 0x6f, 0x9b, 0x5c, 0x6c, 0x11, 0xe1, 0xa3, 0xf5, 0x78, 0xe7, 0x4a, 0x13, 0x12, 0x6d, 0x78, 0x5b, + 0x58, 0x41, 0xb1, 0xb9, 0xc2, 0x6f, 0x32, 0x00, 0xea, 0x8b, 0xa7, 0xbe, 0xe7, 0x52, 0xd2, 0x93, + 0xd5, 0x53, 0x30, 0x59, 0xe1, 0x96, 0x43, 0x62, 0x49, 0x5c, 0x33, 0xf3, 0x49, 0xbc, 0x37, 0x25, + 0xfe, 0xe4, 0x6a, 0xca, 0x1c, 0x6a, 0x03, 0x80, 0xd7, 0xc1, 0x50, 0x40, 0x68, 0xe4, 0x84, 0xe6, + 0xc0, 0xbc, 0xb1, 0x38, 0xba, 0x7c, 0xb9, 0x2b, 0x14, 0xcf, 0x6f, 0x96, 0x7c, 0xc5, 0xfa, 0x93, + 0xc5, 0x72, 0x88, 0xc3, 0x88, 0x96, 0xce, 0x4a, 0xa4, 0x21, 0xc4, 0x6d, 0x20, 0x69, 0xab, 0xf0, + 0x83, 0x0c, 0x98, 0xd4, 0xa3, 0x54, 0xb7, 0xc9, 0x11, 0x3c, 0x02, 0xc3, 0x81, 0x48, 0x16, 0x1e, + 0xa7, 0xd1, 0xe5, 0x9d, 0xe2, 0x3d, 0x1d, 0xab, 0x62, 0x5b, 0x12, 0x96, 0x46, 0xd9, 0x9e, 0xc9, + 0x1f, 0x28, 0x46, 0x83, 0x6f, 0x83, 0x5c, 0x20, 0x37, 0x8a, 0x67, 0xd3, 0xe8, 0xf2, 0x57, 0x7b, + 0x88, 0x2c, 0x0c, 0x97, 0xc6, 0x9a, 0x8d, 0x7c, 0x2e, 0xfe, 0x85, 0x14, 0x60, 0xe1, 0xbd, 0x0c, + 0x98, 0x5b, 0x8d, 0x68, 0xe8, 0xd5, 0x10, 0xa1, 0x5e, 0x14, 0x54, 0xc8, 0xaa, 0xe7, 0x44, 0x35, + 0x77, 0x8d, 0xec, 0xdb, 0xae, 0x1d, 0xb2, 0x6c, 0x9d, 0x07, 0x83, 0x2e, 0xae, 0x11, 0x99, 0x3d, + 0x63, 0x32, 0xa6, 0x83, 0x5b, 0xb8, 0x46, 0x10, 0xe7, 0x30, 0x09, 0x96, 0x2c, 0xf2, 0x2c, 0x28, + 0x89, 0xeb, 0x27, 0x3e, 0x41, 0x9c, 0x03, 0x2f, 0x81, 0xa1, 0x7d, 0x2f, 0xa8, 0x61, 0xb1, 0x8f, + 0x23, 0xc9, 0xce, 0x5c, 0xe5, 0x54, 0x24, 0xb9, 0xf0, 0x69, 0x30, 0x6a, 0x11, 0x5a, 0x09, 0x6c, + 0x9f, 0x41, 0x9b, 0x83, 0x5c, 0xf8, 0x9c, 0x14, 0x1e, 0x5d, 0x4b, 0x58, 0x48, 0x97, 0x83, 0x97, + 0x41, 0xce, 0x0f, 0x6c, 0x2f, 0xb0, 0xc3, 0x13, 0x33, 0x3b, 0x6f, 0x2c, 0x66, 0x4b, 0x93, 0x52, + 0x27, 0xb7, 0x23, 0xe9, 0x48, 0x49, 0xc0, 0x79, 0x90, 0x7b, 0xa1, 0xbc, 0xbd, 0xb5, 0x83, 0xc3, + 0x03, 0x73, 0x88, 0x23, 0x0c, 0x32, 0x69, 0xa4, 0xa8, 0x85, 0xbf, 0x67, 0x80, 0x99, 0x8e, 0x4a, + 0x1c, 0x52, 0x78, 0x15, 0xe4, 0x68, 0xc8, 0x2a, 0x4e, 0xf5, 0x44, 0xc6, 0xe4, 0xb1, 0x18, 0xac, + 0x2c, 0xe9, 0xa7, 0x8d, 0xfc, 0x4c, 0xa2, 0x11, 0x53, 0x79, 0x3c, 0x94, 0x2e, 0xfc, 0x95, 0x01, + 0xce, 0x1d, 0x91, 0xbd, 0x03, 0xcf, 0x3b, 0x5c, 0x75, 0x6c, 0xe2, 0x86, 0xab, 0x9e, 0xbb, 0x6f, + 0x57, 0x65, 0x0e, 0xa0, 0x7b, 0xcc, 0x81, 0x97, 0xdb, 0x2d, 0x97, 0x1e, 0x68, 0x36, 0xf2, 0xe7, + 0x3a, 0x30, 0x50, 0x27, 0x3f, 0xe0, 0x2e, 0x30, 0x2b, 0xa9, 0x43, 0x22, 0x0b, 0x98, 0x28, 0x5b, + 0x23, 0xa5, 0x8b, 0xcd, 0x46, 0xde, 0x5c, 0xed, 0x22, 0x83, 0xba, 0x6a, 0x17, 0xbe, 0x37, 0x90, + 0x0e, 0xaf, 0x96, 0x6e, 0x6f, 0x82, 0x1c, 0x3b, 0xc6, 0x16, 0x0e, 0xb1, 0x3c, 0x88, 0x4f, 0xdc, + 0xdd, 0xa1, 0x17, 0x35, 0x63, 0x93, 0x84, 0xb8, 0x04, 0xe5, 0x86, 0x80, 0x84, 0x86, 0x94, 0x55, + 0xf8, 0x4d, 0x30, 0x48, 0x7d, 0x52, 0x91, 0x81, 0x7e, 0xe5, 0x5e, 0x0f, 0x5b, 0x97, 0x85, 0x94, + 0x7d, 0x52, 0x49, 0xce, 0x02, 0xfb, 0x85, 0x38, 0x2c, 0x7c, 0xc7, 0x00, 0x43, 0x94, 0x17, 0x28, + 0x59, 0xd4, 0x5e, 0xeb, 0x97, 0x07, 0xa9, 0x2a, 0x28, 0x7e, 0x23, 0x09, 0x5e, 0xf8, 0x4f, 0x06, + 0x2c, 0x74, 0x53, 0x5d, 0xf5, 0x5c, 0x4b, 0x6c, 0xc7, 0x86, 0x3c, 0xdb, 0x22, 0xd3, 0x9f, 0xd6, + 0xcf, 0xf6, 0x69, 0x23, 0xff, 0xc8, 0x1d, 0x0d, 0x68, 0x45, 0xe0, 0x0b, 0x6a, 0xdd, 0xa2, 0x50, + 0x2c, 0xb4, 0x3a, 0x76, 0xda, 0xc8, 0x4f, 0x28, 0xb5, 0x56, 0x5f, 0x61, 0x1d, 0x40, 0x07, 0xd3, + 0xf0, 0x7a, 0x80, 0x5d, 0x2a, 0xcc, 0xda, 0x35, 0x22, 0xc3, 0xf7, 0xd8, 0xdd, 0xa5, 0x07, 0xd3, + 0x28, 0xcd, 0x4a, 0x48, 0x78, 0xad, 0xcd, 0x1a, 0xea, 0x80, 0xc0, 0xea, 0x56, 0x40, 0x30, 0x55, + 0xa5, 0x48, 0xbb, 0x51, 0x18, 0x15, 0x49, 0x2e, 0x7c, 0x14, 0x0c, 0xd7, 0x08, 0xa5, 0xb8, 0x4a, + 0x78, 0xfd, 0x19, 0x49, 0xae, 0xe8, 0x4d, 0x41, 0x46, 0x31, 0x9f, 0xf5, 0x27, 0x17, 0xbb, 0x45, + 0xed, 0x9a, 0x4d, 0x43, 0xf8, 0x6a, 0xdb, 0x01, 0x28, 0xde, 0xdd, 0x0a, 0x99, 0x36, 0x4f, 0x7f, + 0x55, 0xfc, 0x62, 0x8a, 0x96, 0xfc, 0xdf, 0x00, 0x59, 0x3b, 0x24, 0xb5, 0xf8, 0xee, 0x7e, 0xb9, + 0x4f, 0xb9, 0x57, 0x1a, 0x97, 0x3e, 0x64, 0x37, 0x18, 0x1a, 0x12, 0xa0, 0x85, 0xdf, 0x66, 0xc0, + 0x43, 0xdd, 0x54, 0xd8, 0x85, 0x42, 0x59, 0xc4, 0x7d, 0x27, 0x0a, 0xb0, 0x23, 0x33, 0x4e, 0x45, + 0x7c, 0x87, 0x53, 0x91, 0xe4, 0xb2, 0x92, 0x4f, 0x6d, 0xb7, 0x1a, 0x39, 0x38, 0x90, 0xe9, 0xa4, + 0x56, 0x5d, 0x96, 0x74, 0xa4, 0x24, 0x60, 0x11, 0x00, 0x7a, 0xe0, 0x05, 0x21, 0xc7, 0x90, 0xd5, + 0xeb, 0x2c, 0x2b, 0x10, 0x65, 0x45, 0x45, 0x9a, 0x04, 0xbb, 0xd1, 0x0e, 0x6d, 0xd7, 0x92, 0xbb, + 0xae, 0x4e, 0xf1, 0x8b, 0xb6, 0x6b, 0x21, 0xce, 0x61, 0xf8, 0x8e, 0x4d, 0x43, 0x46, 0x91, 0x5b, + 0xde, 0x12, 0x75, 0x2e, 0xa9, 0x24, 0x18, 0x7e, 0x85, 0x55, 0x7d, 0x2f, 0xb0, 0x09, 0x35, 0x87, + 0x12, 0xfc, 0x55, 0x45, 0x45, 0x9a, 0x44, 0xe1, 0xdf, 0xb9, 0xee, 0x49, 0xc2, 0x4a, 0x09, 0x7c, + 0x18, 0x64, 0xab, 0x81, 0x17, 0xf9, 0x32, 0x4a, 0x2a, 0xda, 0xcf, 0x33, 0x22, 0x12, 0x3c, 0x96, + 0x95, 0xf5, 0x96, 0x36, 0x55, 0x65, 0x65, 0xdc, 0x9c, 0xc6, 0x7c, 0xf8, 0x1d, 0x03, 0x64, 0x5d, + 0x19, 0x1c, 0x96, 0x72, 0xaf, 0xf6, 0x29, 0x2f, 0x78, 0x78, 0x13, 0x77, 0x45, 0xe4, 0x05, 0x32, + 0x7c, 0x0a, 0x64, 0x69, 0xc5, 0xf3, 0x89, 0x8c, 0xfa, 0x5c, 0x2c, 0x54, 0x66, 0xc4, 0xd3, 0x46, + 0x7e, 0x3c, 0x36, 0xc7, 0x09, 0x48, 0x08, 0xc3, 0xef, 0x1b, 0x00, 0xd4, 0xb1, 0x63, 0x5b, 0x98, + 0xb7, 0x0c, 0x59, 0xee, 0x7e, 0x6f, 0xd3, 0xfa, 0x25, 0x65, 0x5e, 0x6c, 0x5a, 0xf2, 0x1b, 0x69, + 0xd0, 0xf0, 0x5d, 0x03, 0x8c, 0xd1, 0x68, 0x2f, 0x90, 0x5a, 0x94, 0x37, 0x17, 0xa3, 0xcb, 0x5f, + 0xeb, 0xa9, 0x2f, 0x65, 0x0d, 0xa0, 0x34, 0xd9, 0x6c, 0xe4, 0xc7, 0x74, 0x0a, 0x6a, 0x71, 0x00, + 0xfe, 0xc8, 0x00, 0xb9, 0x7a, 0x7c, 0x67, 0x0f, 0xf3, 0x03, 0xff, 0x7a, 0x9f, 0x36, 0x56, 0x66, + 0x54, 0x72, 0x0a, 0x54, 0x1f, 0xa0, 0x3c, 0x80, 0x7f, 0x36, 0x80, 0x89, 0x2d, 0x51, 0xe0, 0xb1, + 0xb3, 0x13, 0xd8, 0x6e, 0x48, 0x02, 0xd1, 0x6f, 0x52, 0x33, 0xc7, 0xdd, 0xeb, 0xed, 0x5d, 0x98, + 0xee, 0x65, 0x4b, 0xf3, 0xd2, 0x3b, 0x73, 0xa5, 0x8b, 0x1b, 0xa8, 0xab, 0x83, 0x3c, 0xd1, 0x92, + 0x96, 0xc6, 0x1c, 0xe9, 0x43, 0xa2, 0x25, 0xbd, 0x94, 0xac, 0x0e, 0x49, 0x07, 0xa5, 0x41, 0xc3, + 0x6d, 0x30, 0xed, 0x07, 0x84, 0x03, 0xdc, 0x70, 0x0f, 0x5d, 0xef, 0xc8, 0xbd, 0x6a, 0x13, 0xc7, + 0xa2, 0x26, 0x98, 0x37, 0x16, 0x73, 0xa5, 0x0b, 0xcd, 0x46, 0x7e, 0x7a, 0xa7, 0x93, 0x00, 0xea, + 0xac, 0x57, 0x78, 0x77, 0x20, 0xfd, 0x0a, 0x48, 0x77, 0x11, 0xf0, 0x7d, 0xb1, 0x7a, 0x11, 0x1b, + 0x6a, 0x1a, 0x7c, 0xb7, 0xde, 0xec, 0x53, 0x32, 0xa9, 0x36, 0x20, 0xe9, 0xe4, 0x14, 0x89, 0x22, + 0xcd, 0x0f, 0xf8, 0x73, 0x03, 0x8c, 0xe3, 0x4a, 0x85, 0xf8, 0x21, 0xb1, 0x44, 0x71, 0xcf, 0x7c, + 0x0a, 0xf5, 0x6b, 0x5a, 0x7a, 0x35, 0xbe, 0xa2, 0x43, 0xa3, 0x56, 0x4f, 0xe0, 0x73, 0xe0, 0x2c, + 0x0d, 0xbd, 0x80, 0x58, 0xa9, 0xb6, 0x19, 0x36, 0x1b, 0xf9, 0xb3, 0xe5, 0x16, 0x0e, 0x4a, 0x49, + 0x16, 0xfe, 0x91, 0x05, 0xf9, 0x3b, 0x1c, 0xb5, 0xbb, 0x78, 0x98, 0x5d, 0x02, 0x43, 0x7c, 0xb9, + 0x16, 0x8f, 0x4a, 0x4e, 0x6b, 0x05, 0x39, 0x15, 0x49, 0x2e, 0xbb, 0x28, 0x18, 0x3e, 0x6b, 0x5f, + 0x06, 0xb8, 0xa0, 0xba, 0x28, 0xca, 0x82, 0x8c, 0x62, 0x3e, 0x5c, 0x06, 0xc0, 0x22, 0x7e, 0x40, + 0xd8, 0x65, 0x65, 0x99, 0xc3, 0x5c, 0x5a, 0x6d, 0xd2, 0x9a, 0xe2, 0x20, 0x4d, 0x0a, 0x5e, 0x05, + 0x30, 0xfe, 0x65, 0x7b, 0xee, 0xcb, 0x38, 0x70, 0x6d, 0xb7, 0x6a, 0xe6, 0xb8, 0xdb, 0x33, 0xac, + 0x1b, 0x5b, 0x6b, 0xe3, 0xa2, 0x0e, 0x1a, 0xf0, 0x6d, 0x30, 0x24, 0x86, 0x3e, 0xfc, 0x86, 0xe8, + 0x63, 0x95, 0x07, 0x3c, 0x46, 0x1c, 0x0a, 0x49, 0xc8, 0xf6, 0xea, 0x9e, 0xbd, 0xdf, 0xd5, 0xfd, + 0xb6, 0xe5, 0x74, 0xe8, 0xff, 0xbc, 0x9c, 0x16, 0xfe, 0x6b, 0xa4, 0x6b, 0x8e, 0xb6, 0xd4, 0x72, + 0x05, 0x3b, 0x04, 0xae, 0x81, 0x49, 0xf6, 0x62, 0x42, 0xc4, 0x77, 0xec, 0x0a, 0xa6, 0xfc, 0xc1, + 0x2e, 0x92, 0x5d, 0xcd, 0x90, 0xca, 0x29, 0x3e, 0x6a, 0xd3, 0x80, 0x2f, 0x00, 0x28, 0x5e, 0x11, + 0x2d, 0x76, 0x44, 0x43, 0xa4, 0xde, 0x03, 0xe5, 0x36, 0x09, 0xd4, 0x41, 0x0b, 0xae, 0x82, 0x29, + 0x07, 0xef, 0x11, 0xa7, 0x4c, 0x1c, 0x52, 0x09, 0xbd, 0x80, 0x9b, 0x12, 0x23, 0x8d, 0xe9, 0x66, + 0x23, 0x3f, 0x75, 0x2d, 0xcd, 0x44, 0xed, 0xf2, 0x85, 0x85, 0xf4, 0xd1, 0xd6, 0x17, 0x2e, 0xde, + 0x66, 0x1f, 0x64, 0xc0, 0x6c, 0xf7, 0xcc, 0x80, 0xdf, 0x4d, 0x9e, 0x90, 0xe2, 0x85, 0xf0, 0x7a, + 0xbf, 0xb2, 0x50, 0xbe, 0x21, 0x41, 0xfb, 0xfb, 0x11, 0x7e, 0x8b, 0xb5, 0x6b, 0xd8, 0x89, 0x87, + 0x56, 0xaf, 0xf5, 0xcd, 0x05, 0x06, 0x52, 0x1a, 0x11, 0x9d, 0x20, 0x76, 0x78, 0xe3, 0x87, 0x1d, + 0x52, 0xf8, 0x9d, 0x91, 0x9e, 0x22, 0x24, 0x27, 0x18, 0xfe, 0xd8, 0x00, 0x13, 0x9e, 0x4f, 0xdc, + 0x95, 0x9d, 0x8d, 0x97, 0x3e, 0x27, 0x4e, 0xb2, 0x0c, 0xd5, 0xd6, 0x3d, 0xfa, 0xf9, 0x42, 0x79, + 0x7b, 0x4b, 0x18, 0xdc, 0x09, 0x3c, 0x9f, 0x96, 0xce, 0x35, 0x1b, 0xf9, 0x89, 0xed, 0x56, 0x28, + 0x94, 0xc6, 0x2e, 0xd4, 0xc0, 0xf4, 0xfa, 0x71, 0x48, 0x02, 0x17, 0x3b, 0x6b, 0x5e, 0x25, 0xaa, + 0x11, 0x37, 0x14, 0x8e, 0xa6, 0x26, 0x5e, 0xc6, 0x5d, 0x4e, 0xbc, 0x1e, 0x02, 0x03, 0x51, 0xe0, + 0xc8, 0x2c, 0x1e, 0x55, 0x13, 0x5d, 0x74, 0x0d, 0x31, 0x7a, 0x61, 0x01, 0x0c, 0x32, 0x3f, 0xe1, + 0x05, 0x30, 0x10, 0xe0, 0x23, 0x6e, 0x75, 0xac, 0x34, 0xcc, 0x44, 0x10, 0x3e, 0x42, 0x8c, 0x56, + 0xf8, 0xdb, 0x02, 0x98, 0x48, 0xad, 0x05, 0xce, 0x82, 0x8c, 0x1a, 0x13, 0x03, 0x69, 0x34, 0xb3, + 0xb1, 0x86, 0x32, 0xb6, 0x05, 0x9f, 0x51, 0xc5, 0x57, 0x80, 0xe6, 0xd5, 0x5d, 0xc2, 0xa9, 0xac, + 0x3f, 0x4f, 0xcc, 0x31, 0x47, 0xe2, 0xc2, 0xc9, 0x7c, 0x20, 0xfb, 0xf2, 0x94, 0x08, 0x1f, 0xc8, + 0x3e, 0x62, 0xb4, 0x4f, 0x3a, 0xee, 0x8b, 0xe7, 0x8d, 0xd9, 0xbb, 0x98, 0x37, 0x0e, 0xdd, 0x76, + 0xde, 0xf8, 0x30, 0xc8, 0x86, 0x76, 0xe8, 0x10, 0x7e, 0x91, 0x69, 0xcf, 0xa8, 0xeb, 0x8c, 0x88, + 0x04, 0x0f, 0xbe, 0x05, 0x86, 0x2d, 0xb2, 0x8f, 0x23, 0x27, 0xe4, 0x77, 0xd6, 0xe8, 0xf2, 0x6a, + 0x0f, 0x52, 0x48, 0x0c, 0x83, 0xd7, 0x84, 0x5d, 0x14, 0x03, 0xc0, 0x47, 0xc0, 0x70, 0x0d, 0x1f, + 0xdb, 0xb5, 0xa8, 0xc6, 0x1b, 0x4c, 0x43, 0x88, 0x6d, 0x0a, 0x12, 0x8a, 0x79, 0xac, 0x32, 0x92, + 0xe3, 0x8a, 0x13, 0x51, 0xbb, 0x4e, 0x24, 0x53, 0x36, 0x7f, 0xaa, 0x32, 0xae, 0xa7, 0xf8, 0xa8, + 0x4d, 0x83, 0x83, 0xd9, 0x2e, 0x57, 0x1e, 0xd5, 0xc0, 0x04, 0x09, 0xc5, 0xbc, 0x56, 0x30, 0x29, + 0x3f, 0xd6, 0x0d, 0x4c, 0x2a, 0xb7, 0x69, 0xc0, 0xc7, 0xc1, 0x48, 0x0d, 0x1f, 0x5f, 0x23, 0x6e, + 0x35, 0x3c, 0x30, 0xc7, 0xe7, 0x8d, 0xc5, 0x81, 0xd2, 0x78, 0xb3, 0x91, 0x1f, 0xd9, 0x8c, 0x89, + 0x28, 0xe1, 0x73, 0x61, 0xdb, 0x95, 0xc2, 0x67, 0x35, 0xe1, 0x98, 0x88, 0x12, 0x3e, 0xeb, 0x5e, + 0x7c, 0x1c, 0xb2, 0xc3, 0x65, 0x4e, 0xb4, 0x3e, 0x73, 0x77, 0x04, 0x19, 0xc5, 0x7c, 0xb8, 0x08, + 0x72, 0x35, 0x7c, 0xcc, 0x47, 0x12, 0xe6, 0x24, 0x37, 0xcb, 0x07, 0xe3, 0x9b, 0x92, 0x86, 0x14, + 0x97, 0x4b, 0xda, 0xae, 0x90, 0x9c, 0xd2, 0x24, 0x25, 0x0d, 0x29, 0x2e, 0x4b, 0xe2, 0xc8, 0xb5, + 0x6f, 0x46, 0x44, 0x08, 0x43, 0x1e, 0x19, 0x95, 0xc4, 0x37, 0x12, 0x16, 0xd2, 0xe5, 0x60, 0x11, + 0x80, 0x5a, 0xe4, 0x84, 0xb6, 0xef, 0x90, 0xed, 0x7d, 0xf3, 0x1c, 0x8f, 0x3f, 0x6f, 0xfa, 0x37, + 0x15, 0x15, 0x69, 0x12, 0x90, 0x80, 0x41, 0xe2, 0x46, 0x35, 0xf3, 0x3c, 0xbf, 0xd8, 0x7b, 0x92, + 0x82, 0xea, 0xe4, 0xac, 0xbb, 0x51, 0x0d, 0x71, 0xf3, 0xf0, 0x19, 0x30, 0x5e, 0xc3, 0xc7, 0xac, + 0x1c, 0x90, 0x20, 0xb4, 0x09, 0x35, 0xa7, 0xf9, 0xe2, 0xa7, 0x58, 0xb7, 0xbb, 0xa9, 0x33, 0x50, + 0xab, 0x1c, 0x57, 0xb4, 0x5d, 0x4d, 0x71, 0x46, 0x53, 0xd4, 0x19, 0xa8, 0x55, 0x8e, 0x45, 0x3a, + 0x20, 0x37, 0x23, 0x3b, 0x20, 0x96, 0xf9, 0x00, 0x6f, 0x90, 0xe5, 0xc7, 0x0a, 0x41, 0x43, 0x8a, + 0x0b, 0xeb, 0xf1, 0xec, 0xca, 0xe4, 0xc7, 0xf0, 0x46, 0x6f, 0x2b, 0xf9, 0x76, 0xb0, 0x12, 0x04, + 0xf8, 0x44, 0xdc, 0x34, 0xfa, 0xd4, 0x0a, 0x52, 0x90, 0xc5, 0x8e, 0xb3, 0xbd, 0x6f, 0x5e, 0xe0, + 0xb1, 0xef, 0xf5, 0x0d, 0xa2, 0xaa, 0xce, 0x0a, 0x03, 0x41, 0x02, 0x8b, 0x81, 0x7a, 0x2e, 0x4b, + 0x8d, 0xd9, 0xfe, 0x82, 0x6e, 0x33, 0x10, 0x24, 0xb0, 0xf8, 0x4a, 0xdd, 0x93, 0xed, 0x7d, 0xf3, + 0xc1, 0x3e, 0xaf, 0x94, 0x81, 0x20, 0x81, 0x05, 0x6d, 0x30, 0xe0, 0x7a, 0xa1, 0x79, 0xb1, 0x2f, + 0xd7, 0x33, 0xbf, 0x70, 0xb6, 0xbc, 0x10, 0x31, 0x0c, 0xf8, 0x33, 0x03, 0x00, 0x3f, 0x49, 0xd1, + 0x87, 0x7a, 0x32, 0x12, 0x49, 0x41, 0x16, 0x93, 0xdc, 0x5e, 0x77, 0xc3, 0xe0, 0x24, 0x79, 0x1e, + 0x69, 0x67, 0x40, 0xf3, 0x02, 0xfe, 0xda, 0x00, 0xe7, 0xf5, 0x36, 0x59, 0xb9, 0x37, 0xc7, 0x23, + 0x72, 0xbd, 0xd7, 0x69, 0x5e, 0xf2, 0x3c, 0xa7, 0x64, 0x36, 0x1b, 0xf9, 0xf3, 0x2b, 0x1d, 0x50, + 0x51, 0x47, 0x5f, 0xe0, 0xef, 0x0d, 0x30, 0x25, 0xab, 0xa8, 0xe6, 0x61, 0x9e, 0x07, 0x90, 0xf4, + 0x3a, 0x80, 0x69, 0x1c, 0x11, 0x47, 0xf5, 0x91, 0xbd, 0x8d, 0x8f, 0xda, 0x5d, 0x83, 0x7f, 0x32, + 0xc0, 0x98, 0x45, 0x7c, 0xe2, 0x5a, 0xc4, 0xad, 0x30, 0x5f, 0xe7, 0x7b, 0x32, 0xb2, 0x48, 0xfb, + 0xba, 0xa6, 0x41, 0x08, 0x37, 0x8b, 0xd2, 0xcd, 0x31, 0x9d, 0x75, 0xda, 0xc8, 0xcf, 0x24, 0xaa, + 0x3a, 0x07, 0xb5, 0x78, 0x09, 0xdf, 0x33, 0xc0, 0x44, 0xb2, 0x01, 0xe2, 0x4a, 0x59, 0xe8, 0x63, + 0x1e, 0xf0, 0xf6, 0x75, 0xa5, 0x15, 0x10, 0xa5, 0x3d, 0x80, 0x7f, 0x30, 0x58, 0xa7, 0x16, 0xbf, + 0xfb, 0xa8, 0x59, 0xe0, 0xb1, 0x7c, 0xa3, 0xe7, 0xb1, 0x54, 0x08, 0x22, 0x94, 0x97, 0x93, 0x56, + 0x50, 0x71, 0x4e, 0x1b, 0xf9, 0x69, 0x3d, 0x92, 0x8a, 0x81, 0x74, 0x0f, 0xe1, 0x0f, 0x0d, 0x30, + 0x46, 0x92, 0x8e, 0x9b, 0x9a, 0x0f, 0xf7, 0x24, 0x88, 0x1d, 0x9b, 0x78, 0xf1, 0x52, 0xd7, 0x58, + 0x14, 0xb5, 0x60, 0xb3, 0x0e, 0x92, 0x1c, 0xe3, 0x9a, 0xef, 0x10, 0xf3, 0x33, 0x3d, 0xee, 0x20, + 0xd7, 0x85, 0x5d, 0x14, 0x03, 0xc0, 0xcb, 0x20, 0xe7, 0x46, 0x8e, 0x83, 0xf7, 0x1c, 0x62, 0x3e, + 0xc2, 0x7b, 0x11, 0x35, 0x92, 0xdd, 0x92, 0x74, 0xa4, 0x24, 0xe0, 0x3e, 0x98, 0x3f, 0x7e, 0x51, + 0xfd, 0x7b, 0x52, 0xc7, 0xa1, 0xa1, 0x79, 0x89, 0x5b, 0x99, 0x6d, 0x36, 0xf2, 0x33, 0xbb, 0x9d, + 0xc7, 0x8a, 0x77, 0xb4, 0x01, 0x5f, 0x01, 0x0f, 0x6a, 0x32, 0xeb, 0xb5, 0x3d, 0x62, 0x59, 0xc4, + 0x8a, 0x1f, 0x6e, 0xe6, 0x67, 0xc5, 0xe0, 0x32, 0x3e, 0xe0, 0xbb, 0x69, 0x01, 0x74, 0x3b, 0x6d, + 0x78, 0x0d, 0xcc, 0x68, 0xec, 0x0d, 0x37, 0xdc, 0x0e, 0xca, 0x61, 0x60, 0xbb, 0x55, 0x73, 0x91, + 0xdb, 0x3d, 0x1f, 0x9f, 0xc8, 0x5d, 0x8d, 0x87, 0xba, 0xe8, 0xc0, 0xaf, 0xb4, 0x58, 0xe3, 0x9f, + 0xd0, 0xb0, 0xff, 0x22, 0x39, 0xa1, 0xe6, 0xa3, 0xbc, 0x3b, 0xe1, 0x9b, 0xbd, 0xab, 0xd1, 0x51, + 0x17, 0x79, 0xf8, 0x65, 0x70, 0x2e, 0xc5, 0x61, 0x4f, 0x14, 0xf3, 0x31, 0xf1, 0xd6, 0x60, 0xfd, + 0xec, 0x6e, 0x4c, 0x44, 0x9d, 0x24, 0xe1, 0x17, 0x01, 0xd4, 0xc8, 0x9b, 0xd8, 0xe7, 0xfa, 0x8f, + 0x8b, 0x67, 0x0f, 0xdb, 0xd1, 0x5d, 0x49, 0x43, 0x1d, 0xe4, 0xe0, 0x2f, 0x8c, 0x96, 0x95, 0x24, + 0xaf, 0x63, 0x6a, 0x5e, 0xe6, 0xe7, 0x77, 0xf3, 0x1e, 0xb3, 0x50, 0xfb, 0x0e, 0x12, 0x39, 0x44, + 0x0b, 0xb3, 0x06, 0x85, 0xba, 0xb8, 0x30, 0xcb, 0x5e, 0xe8, 0xa9, 0x0a, 0x0f, 0x27, 0xc1, 0xc0, + 0x21, 0x91, 0xff, 0x55, 0x81, 0xd8, 0x9f, 0xd0, 0x02, 0xd9, 0x3a, 0x76, 0xa2, 0x78, 0xc8, 0xd0, + 0xe3, 0xee, 0x00, 0x09, 0xe3, 0xcf, 0x65, 0x9e, 0x35, 0x66, 0xdf, 0x37, 0xc0, 0x4c, 0xe7, 0x8b, + 0xe7, 0xbe, 0xba, 0xf5, 0x4b, 0x03, 0x4c, 0xb5, 0xdd, 0x31, 0x1d, 0x3c, 0xba, 0xd9, 0xea, 0xd1, + 0x2b, 0xbd, 0xbe, 0x2c, 0xc4, 0xe1, 0xe0, 0x1d, 0xb2, 0xee, 0xde, 0x4f, 0x0c, 0x30, 0x99, 0x2e, + 0xdb, 0xf7, 0x33, 0x5e, 0x85, 0xf7, 0x33, 0x60, 0xa6, 0x73, 0x63, 0x0f, 0x03, 0x35, 0xc1, 0xe8, + 0xcf, 0x24, 0xa8, 0xd3, 0xd4, 0xf8, 0x1d, 0x03, 0x8c, 0xbe, 0xa5, 0xe4, 0xe2, 0xaf, 0xee, 0x3d, + 0x9f, 0x41, 0xc5, 0xf7, 0x64, 0xc2, 0xa0, 0x48, 0xc7, 0x2d, 0xfc, 0xd1, 0x00, 0xd3, 0x1d, 0x1b, + 0x00, 0x78, 0x09, 0x0c, 0x61, 0xc7, 0xf1, 0x8e, 0xc4, 0x28, 0x51, 0xfb, 0x46, 0xb0, 0xc2, 0xa9, + 0x48, 0x72, 0xb5, 0xe8, 0x65, 0x3e, 0xad, 0xe8, 0x15, 0xfe, 0x62, 0x80, 0x8b, 0xb7, 0xcb, 0xc4, + 0xfb, 0xb2, 0xa5, 0x8b, 0x20, 0x27, 0x9b, 0xf7, 0x13, 0xbe, 0x9d, 0xb2, 0x14, 0xcb, 0xa2, 0xc1, + 0xff, 0xd1, 0x4c, 0xfc, 0x55, 0xf8, 0xc0, 0x00, 0x93, 0x65, 0x12, 0xd4, 0xed, 0x0a, 0x41, 0x64, + 0x9f, 0x04, 0xc4, 0xad, 0x10, 0xb8, 0x04, 0x46, 0xf8, 0xe7, 0x6e, 0x1f, 0x57, 0xe2, 0x4f, 0x37, + 0x53, 0x32, 0xe4, 0x23, 0x5b, 0x31, 0x03, 0x25, 0x32, 0xea, 0x33, 0x4f, 0xa6, 0xeb, 0x67, 0x9e, + 0x8b, 0x60, 0xd0, 0x4f, 0x06, 0xd1, 0x39, 0xc6, 0xe5, 0xb3, 0x67, 0x4e, 0xe5, 0x5c, 0x2f, 0x08, + 0xf9, 0x74, 0x2d, 0x2b, 0xb9, 0x5e, 0x10, 0x22, 0x4e, 0x2d, 0xbc, 0x06, 0xce, 0xb6, 0x96, 0x71, + 0x86, 0x17, 0x44, 0x4e, 0xdb, 0x67, 0x25, 0xc6, 0x43, 0x9c, 0xa3, 0xff, 0xb7, 0x4b, 0xe6, 0x0e, + 0xff, 0xed, 0xf2, 0x57, 0x03, 0x74, 0xfa, 0x8f, 0x33, 0x78, 0x41, 0xcc, 0x2f, 0xb5, 0xa1, 0x60, + 0x3c, 0xbb, 0x84, 0x75, 0x30, 0x4c, 0x45, 0xd0, 0xe4, 0xa6, 0x6e, 0xdf, 0xe3, 0xa6, 0xa6, 0xb7, + 0x40, 0x34, 0x4e, 0x31, 0x35, 0x06, 0x63, 0xfb, 0x5a, 0xc1, 0xa5, 0xc8, 0xb5, 0xe4, 0x48, 0x7b, + 0x4c, 0xec, 0xeb, 0xea, 0x8a, 0xa0, 0x21, 0xc5, 0x2d, 0x5d, 0xf9, 0xf0, 0xd6, 0xdc, 0x99, 0x8f, + 0x6e, 0xcd, 0x9d, 0xf9, 0xf8, 0xd6, 0xdc, 0x99, 0x6f, 0x37, 0xe7, 0x8c, 0x0f, 0x9b, 0x73, 0xc6, + 0x47, 0xcd, 0x39, 0xe3, 0xe3, 0xe6, 0x9c, 0xf1, 0xcf, 0xe6, 0x9c, 0xf1, 0xd3, 0x7f, 0xcd, 0x9d, + 0xf9, 0xfa, 0xb0, 0xc4, 0xff, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xae, 0xd4, 0x36, 0xef, 0x07, + 0x2e, 0x00, 0x00, } func (m *ConversionRequest) Marshal() (dAtA []byte, err error) { @@ -1911,6 +1944,22 @@ func (m *JSONSchemaProps) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.XValidations) > 0 { + for iNdEx := len(m.XValidations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.XValidations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xe2 + } + } if m.XMapType != nil { i -= len(*m.XMapType) copy(dAtA[i:], *m.XMapType) @@ -2587,6 +2636,39 @@ func (m *ServiceReference) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ValidationRule) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ValidationRule) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidationRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x12 + i -= len(m.Rule) + copy(dAtA[i:], m.Rule) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *WebhookClientConfig) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -3172,6 +3254,12 @@ func (m *JSONSchemaProps) Size() (n int) { l = len(*m.XMapType) n += 2 + l + sovGenerated(uint64(l)) } + if len(m.XValidations) > 0 { + for _, e := range m.XValidations { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } return n } @@ -3247,6 +3335,19 @@ func (m *ServiceReference) Size() (n int) { return n } +func (m *ValidationRule) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Rule) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *WebhookClientConfig) Size() (n int) { if m == nil { return 0 @@ -3558,6 +3659,11 @@ func (this *JSONSchemaProps) String() string { repeatedStringForAnyOf += strings.Replace(strings.Replace(f.String(), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + "," } repeatedStringForAnyOf += "}" + repeatedStringForXValidations := "[]ValidationRule{" + for _, f := range this.XValidations { + repeatedStringForXValidations += strings.Replace(strings.Replace(f.String(), "ValidationRule", "ValidationRule", 1), `&`, ``, 1) + "," + } + repeatedStringForXValidations += "}" keysForProperties := make([]string, 0, len(this.Properties)) for k := range this.Properties { keysForProperties = append(keysForProperties, k) @@ -3642,6 +3748,7 @@ func (this *JSONSchemaProps) String() string { `XListMapKeys:` + fmt.Sprintf("%v", this.XListMapKeys) + `,`, `XListType:` + valueToStringGenerated(this.XListType) + `,`, `XMapType:` + valueToStringGenerated(this.XMapType) + `,`, + `XValidations:` + repeatedStringForXValidations + `,`, `}`, }, "") return s @@ -3697,6 +3804,17 @@ func (this *ServiceReference) String() string { }, "") return s } +func (this *ValidationRule) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ValidationRule{`, + `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `}`, + }, "") + return s +} func (this *WebhookClientConfig) String() string { if this == nil { return "nil" @@ -8260,6 +8378,40 @@ func (m *JSONSchemaProps) Unmarshal(dAtA []byte) error { s := string(dAtA[iNdEx:postIndex]) m.XMapType = &s iNdEx = postIndex + case 44: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field XValidations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.XValidations = append(m.XValidations, ValidationRule{}) + if err := m.XValidations[len(m.XValidations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -8792,6 +8944,120 @@ func (m *ServiceReference) Unmarshal(dAtA []byte) error { } return nil } +func (m *ValidationRule) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ValidationRule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidationRule: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rule = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *WebhookClientConfig) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto index f5072b35cd..9d1830f986 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto @@ -601,6 +601,14 @@ message JSONSchemaProps { // Atomic maps will be entirely replaced when updated. // +optional optional string xKubernetesMapType = 43; + + // x-kubernetes-validations describes a list of validation rules written in the CEL expression language. + // This field is an alpha-level. Using this field requires the feature gate `CustomResourceValidationExpressions` to be enabled. + // +patchMergeKey=rule + // +patchStrategy=merge + // +listType=map + // +listMapKey=rule + repeated ValidationRule xKubernetesValidations = 44; } // JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps @@ -647,6 +655,70 @@ message ServiceReference { optional int32 port = 4; } +// ValidationRule describes a validation rule written in the CEL expression language. +message ValidationRule { + // Rule represents the expression which will be evaluated by CEL. + // ref: https://github.com/google/cel-spec + // The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. + // The `self` variable in the CEL expression is bound to the scoped value. + // Example: + // - Rule scoped to the root of a resource with a status subresource: {"rule": "self.status.actual <= self.spec.maxDesired"} + // + // If the Rule is scoped to an object with properties, the accessible properties of the object are field selectable + // via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as + // absent fields in CEL expressions. + // If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map + // are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map + // are accessible via CEL macros and functions such as `self.all(...)`. + // If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and + // functions. + // If the Rule is scoped to a scalar, `self` is bound to the scalar value. + // Examples: + // - Rule scoped to a map of objects: {"rule": "self.components['Widget'].priority < 10"} + // - Rule scoped to a list of integers: {"rule": "self.values.all(value, value >= 0 && value < 100)"} + // - Rule scoped to a string value: {"rule": "self.startsWith('kube')"} + // + // The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the + // object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible. + // + // Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL + // expressions. This includes: + // - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. + // - Object properties where the property schema is of an "unknown type". An "unknown type" is recursively defined as: + // - A schema with no type and x-kubernetes-preserve-unknown-fields set to true + // - An array where the items schema is of an "unknown type" + // - An object where the additionalProperties schema is of an "unknown type" + // + // Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. + // Accessible property names are escaped according to the following rules when accessed in the expression: + // - '__' escapes to '__underscores__' + // - '.' escapes to '__dot__' + // - '-' escapes to '__dash__' + // - '/' escapes to '__slash__' + // - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: + // "true", "false", "null", "in", "as", "break", "const", "continue", "else", "for", "function", "if", + // "import", "let", "loop", "package", "namespace", "return". + // Examples: + // - Rule accessing a property named "namespace": {"rule": "self.__namespace__ > 0"} + // - Rule accessing a property named "x-prop": {"rule": "self.x__dash__prop > 0"} + // - Rule accessing a property named "redact__d": {"rule": "self.redact__underscores__d > 0"} + // + // Equality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. + // Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: + // - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and + // non-intersecting elements in `Y` are appended, retaining their partial order. + // - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values + // are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with + // non-intersecting keys are appended, retaining their partial order. + optional string rule = 1; + + // Message represents the message displayed when validation fails. The message is required if the Rule contains + // line breaks. The message must not contain line breaks. + // If unset, the message is "failed rule: {Rule}". + // e.g. "must be a URL with the host matching spec.host" + optional string message = 2; +} + // WebhookClientConfig contains the information to make a TLS connection with the webhook. message WebhookClientConfig { // url gives the location of the webhook, in standard URL form diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal.go index 9a8fad3b77..44941d82ef 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal.go @@ -17,6 +17,7 @@ limitations under the License. package v1beta1 import ( + "bytes" "errors" "k8s.io/apimachinery/pkg/util/json" @@ -128,7 +129,7 @@ func (s JSON) MarshalJSON() ([]byte, error) { } func (s *JSON) UnmarshalJSON(data []byte) error { - if len(data) > 0 && string(data) != "null" { + if len(data) > 0 && !bytes.Equal(data, nullLiteral) { s.Raw = data } return nil diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types_jsonschema.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types_jsonschema.go index 1837723a08..c9d943c9a8 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types_jsonschema.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types_jsonschema.go @@ -161,6 +161,80 @@ type JSONSchemaProps struct { // Atomic maps will be entirely replaced when updated. // +optional XMapType *string `json:"x-kubernetes-map-type,omitempty" protobuf:"bytes,43,opt,name=xKubernetesMapType"` + + // x-kubernetes-validations describes a list of validation rules written in the CEL expression language. + // This field is an alpha-level. Using this field requires the feature gate `CustomResourceValidationExpressions` to be enabled. + // +patchMergeKey=rule + // +patchStrategy=merge + // +listType=map + // +listMapKey=rule + XValidations ValidationRules `json:"x-kubernetes-validations,omitempty" patchStrategy:"merge" patchMergeKey:"rule" protobuf:"bytes,44,rep,name=xKubernetesValidations"` +} + +// ValidationRules describes a list of validation rules written in the CEL expression language. +type ValidationRules []ValidationRule + +// ValidationRule describes a validation rule written in the CEL expression language. +type ValidationRule struct { + // Rule represents the expression which will be evaluated by CEL. + // ref: https://github.com/google/cel-spec + // The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. + // The `self` variable in the CEL expression is bound to the scoped value. + // Example: + // - Rule scoped to the root of a resource with a status subresource: {"rule": "self.status.actual <= self.spec.maxDesired"} + // + // If the Rule is scoped to an object with properties, the accessible properties of the object are field selectable + // via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as + // absent fields in CEL expressions. + // If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map + // are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map + // are accessible via CEL macros and functions such as `self.all(...)`. + // If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and + // functions. + // If the Rule is scoped to a scalar, `self` is bound to the scalar value. + // Examples: + // - Rule scoped to a map of objects: {"rule": "self.components['Widget'].priority < 10"} + // - Rule scoped to a list of integers: {"rule": "self.values.all(value, value >= 0 && value < 100)"} + // - Rule scoped to a string value: {"rule": "self.startsWith('kube')"} + // + // The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the + // object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible. + // + // Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL + // expressions. This includes: + // - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. + // - Object properties where the property schema is of an "unknown type". An "unknown type" is recursively defined as: + // - A schema with no type and x-kubernetes-preserve-unknown-fields set to true + // - An array where the items schema is of an "unknown type" + // - An object where the additionalProperties schema is of an "unknown type" + // + // Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. + // Accessible property names are escaped according to the following rules when accessed in the expression: + // - '__' escapes to '__underscores__' + // - '.' escapes to '__dot__' + // - '-' escapes to '__dash__' + // - '/' escapes to '__slash__' + // - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: + // "true", "false", "null", "in", "as", "break", "const", "continue", "else", "for", "function", "if", + // "import", "let", "loop", "package", "namespace", "return". + // Examples: + // - Rule accessing a property named "namespace": {"rule": "self.__namespace__ > 0"} + // - Rule accessing a property named "x-prop": {"rule": "self.x__dash__prop > 0"} + // - Rule accessing a property named "redact__d": {"rule": "self.redact__underscores__d > 0"} + // + // Equality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. + // Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: + // - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and + // non-intersecting elements in `Y` are appended, retaining their partial order. + // - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values + // are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with + // non-intersecting keys are appended, retaining their partial order. + Rule string `json:"rule" protobuf:"bytes,1,opt,name=rule"` + // Message represents the message displayed when validation fails. The message is required if the Rule contains + // line breaks. The message must not contain line breaks. + // If unset, the message is "failed rule: {Rule}". + // e.g. "must be a URL with the host matching spec.host" + Message string `json:"message,omitempty" protobuf:"bytes,2,opt,name=message"` } // JSON represents any valid JSON value. diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.conversion.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.conversion.go index 322b4d28cf..54cae3cfdf 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -221,6 +222,16 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } + if err := s.AddGeneratedConversionFunc((*ValidationRule)(nil), (*apiextensions.ValidationRule)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1beta1_ValidationRule_To_apiextensions_ValidationRule(a.(*ValidationRule), b.(*apiextensions.ValidationRule), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*apiextensions.ValidationRule)(nil), (*ValidationRule)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_apiextensions_ValidationRule_To_v1beta1_ValidationRule(a.(*apiextensions.ValidationRule), b.(*ValidationRule), scope) + }); err != nil { + return err + } if err := s.AddGeneratedConversionFunc((*WebhookClientConfig)(nil), (*apiextensions.WebhookClientConfig)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_v1beta1_WebhookClientConfig_To_apiextensions_WebhookClientConfig(a.(*WebhookClientConfig), b.(*apiextensions.WebhookClientConfig), scope) }); err != nil { @@ -935,6 +946,7 @@ func autoConvert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(in *JS out.XListMapKeys = *(*[]string)(unsafe.Pointer(&in.XListMapKeys)) out.XListType = (*string)(unsafe.Pointer(in.XListType)) out.XMapType = (*string)(unsafe.Pointer(in.XMapType)) + out.XValidations = *(*apiextensions.ValidationRules)(unsafe.Pointer(&in.XValidations)) return nil } @@ -1123,6 +1135,7 @@ func autoConvert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(in *ap out.XListMapKeys = *(*[]string)(unsafe.Pointer(&in.XListMapKeys)) out.XListType = (*string)(unsafe.Pointer(in.XListType)) out.XMapType = (*string)(unsafe.Pointer(in.XMapType)) + out.XValidations = *(*ValidationRules)(unsafe.Pointer(&in.XValidations)) return nil } @@ -1290,6 +1303,28 @@ func Convert_apiextensions_ServiceReference_To_v1beta1_ServiceReference(in *apie return autoConvert_apiextensions_ServiceReference_To_v1beta1_ServiceReference(in, out, s) } +func autoConvert_v1beta1_ValidationRule_To_apiextensions_ValidationRule(in *ValidationRule, out *apiextensions.ValidationRule, s conversion.Scope) error { + out.Rule = in.Rule + out.Message = in.Message + return nil +} + +// Convert_v1beta1_ValidationRule_To_apiextensions_ValidationRule is an autogenerated conversion function. +func Convert_v1beta1_ValidationRule_To_apiextensions_ValidationRule(in *ValidationRule, out *apiextensions.ValidationRule, s conversion.Scope) error { + return autoConvert_v1beta1_ValidationRule_To_apiextensions_ValidationRule(in, out, s) +} + +func autoConvert_apiextensions_ValidationRule_To_v1beta1_ValidationRule(in *apiextensions.ValidationRule, out *ValidationRule, s conversion.Scope) error { + out.Rule = in.Rule + out.Message = in.Message + return nil +} + +// Convert_apiextensions_ValidationRule_To_v1beta1_ValidationRule is an autogenerated conversion function. +func Convert_apiextensions_ValidationRule_To_v1beta1_ValidationRule(in *apiextensions.ValidationRule, out *ValidationRule, s conversion.Scope) error { + return autoConvert_apiextensions_ValidationRule_To_v1beta1_ValidationRule(in, out, s) +} + func autoConvert_v1beta1_WebhookClientConfig_To_apiextensions_WebhookClientConfig(in *WebhookClientConfig, out *apiextensions.WebhookClientConfig, s conversion.Scope) error { out.URL = (*string)(unsafe.Pointer(in.URL)) if in.Service != nil { diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.deepcopy.go index b39a5900f8..26a9d4db9d 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -635,6 +636,42 @@ func (in *ServiceReference) DeepCopy() *ServiceReference { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ValidationRule) DeepCopyInto(out *ValidationRule) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidationRule. +func (in *ValidationRule) DeepCopy() *ValidationRule { + if in == nil { + return nil + } + out := new(ValidationRule) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in ValidationRules) DeepCopyInto(out *ValidationRules) { + { + in := &in + *out = make(ValidationRules, len(*in)) + copy(*out, *in) + return + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidationRules. +func (in ValidationRules) DeepCopy() ValidationRules { + if in == nil { + return nil + } + out := new(ValidationRules) + in.DeepCopyInto(out) + return *out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *WebhookClientConfig) DeepCopyInto(out *WebhookClientConfig) { *out = *in diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.defaults.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.defaults.go index e1807243f0..225c6ff512 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.prerelease-lifecycle.go index 7b73b9cf24..9c22ae5c1c 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/validation.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/validation.go index 32ae5e9943..30732d500c 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/validation.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/validation.go @@ -19,15 +19,16 @@ package validation import ( "fmt" "reflect" + "regexp" "strings" "unicode" "unicode/utf8" "k8s.io/apiextensions-apiserver/pkg/apihelpers" + "k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel" structuraldefaulting "k8s.io/apiextensions-apiserver/pkg/apiserver/schema/defaulting" apiequality "k8s.io/apimachinery/pkg/api/equality" genericvalidation "k8s.io/apimachinery/pkg/api/validation" - "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/util/sets" utilvalidation "k8s.io/apimachinery/pkg/util/validation" "k8s.io/apimachinery/pkg/util/validation/field" @@ -47,7 +48,7 @@ var ( ) // ValidateCustomResourceDefinition statically validates -func ValidateCustomResourceDefinition(obj *apiextensions.CustomResourceDefinition, requestGV schema.GroupVersion) field.ErrorList { +func ValidateCustomResourceDefinition(obj *apiextensions.CustomResourceDefinition) field.ErrorList { nameValidationFn := func(name string, prefix bool) []string { ret := genericvalidation.NameIsDNSSubdomain(name, prefix) requiredName := obj.Spec.Names.Plural + "." + obj.Spec.Group @@ -57,15 +58,13 @@ func ValidateCustomResourceDefinition(obj *apiextensions.CustomResourceDefinitio return ret } - allowDefaults, rejectDefaultsReason := allowDefaults(requestGV, nil) opts := validationOptions{ - allowDefaults: allowDefaults, - disallowDefaultsReason: rejectDefaultsReason, + allowDefaults: true, requireRecognizedConversionReviewVersion: true, requireImmutableNames: false, - requireOpenAPISchema: requireOpenAPISchema(requestGV, nil), - requireValidPropertyType: requireValidPropertyType(requestGV, nil), - requireStructuralSchema: requireStructuralSchema(requestGV, nil), + requireOpenAPISchema: true, + requireValidPropertyType: true, + requireStructuralSchema: true, requirePrunedDefaults: true, requireAtomicSetType: true, requireMapListKeysMapSetValidation: true, @@ -75,8 +74,8 @@ func ValidateCustomResourceDefinition(obj *apiextensions.CustomResourceDefinitio allErrs = append(allErrs, validateCustomResourceDefinitionSpec(&obj.Spec, opts, field.NewPath("spec"))...) allErrs = append(allErrs, ValidateCustomResourceDefinitionStatus(&obj.Status, field.NewPath("status"))...) allErrs = append(allErrs, ValidateCustomResourceDefinitionStoredVersions(obj.Status.StoredVersions, obj.Spec.Versions, field.NewPath("status").Child("storedVersions"))...) - allErrs = append(allErrs, validateAPIApproval(obj, nil, requestGV)...) - allErrs = append(allErrs, validatePreserveUnknownFields(obj, nil, requestGV)...) + allErrs = append(allErrs, validateAPIApproval(obj, nil)...) + allErrs = append(allErrs, validatePreserveUnknownFields(obj, nil)...) return allErrs } @@ -107,16 +106,14 @@ type validationOptions struct { } // ValidateCustomResourceDefinitionUpdate statically validates -func ValidateCustomResourceDefinitionUpdate(obj, oldObj *apiextensions.CustomResourceDefinition, requestGV schema.GroupVersion) field.ErrorList { - allowDefaults, rejectDefaultsReason := allowDefaults(requestGV, &oldObj.Spec) +func ValidateCustomResourceDefinitionUpdate(obj, oldObj *apiextensions.CustomResourceDefinition) field.ErrorList { opts := validationOptions{ - allowDefaults: allowDefaults, - disallowDefaultsReason: rejectDefaultsReason, + allowDefaults: true, requireRecognizedConversionReviewVersion: oldObj.Spec.Conversion == nil || hasValidConversionReviewVersionOrEmpty(oldObj.Spec.Conversion.ConversionReviewVersions), requireImmutableNames: apiextensions.IsCRDConditionTrue(oldObj, apiextensions.Established), - requireOpenAPISchema: requireOpenAPISchema(requestGV, &oldObj.Spec), - requireValidPropertyType: requireValidPropertyType(requestGV, &oldObj.Spec), - requireStructuralSchema: requireStructuralSchema(requestGV, &oldObj.Spec), + requireOpenAPISchema: requireOpenAPISchema(&oldObj.Spec), + requireValidPropertyType: requireValidPropertyType(&oldObj.Spec), + requireStructuralSchema: requireStructuralSchema(&oldObj.Spec), requirePrunedDefaults: requirePrunedDefaults(&oldObj.Spec), requireAtomicSetType: requireAtomicSetType(&oldObj.Spec), requireMapListKeysMapSetValidation: requireMapListKeysMapSetValidation(&oldObj.Spec), @@ -126,8 +123,8 @@ func ValidateCustomResourceDefinitionUpdate(obj, oldObj *apiextensions.CustomRes allErrs = append(allErrs, validateCustomResourceDefinitionSpecUpdate(&obj.Spec, &oldObj.Spec, opts, field.NewPath("spec"))...) allErrs = append(allErrs, ValidateCustomResourceDefinitionStatus(&obj.Status, field.NewPath("status"))...) allErrs = append(allErrs, ValidateCustomResourceDefinitionStoredVersions(obj.Status.StoredVersions, obj.Spec.Versions, field.NewPath("status").Child("storedVersions"))...) - allErrs = append(allErrs, validateAPIApproval(obj, oldObj, requestGV)...) - allErrs = append(allErrs, validatePreserveUnknownFields(obj, oldObj, requestGV)...) + allErrs = append(allErrs, validateAPIApproval(obj, oldObj)...) + allErrs = append(allErrs, validatePreserveUnknownFields(obj, oldObj)...) return allErrs } @@ -914,6 +911,40 @@ func ValidateCustomResourceDefinitionOpenAPISchema(schema *apiextensions.JSONSch } } + if len(schema.XValidations) > 0 { + for i, rule := range schema.XValidations { + trimmedRule := strings.TrimSpace(rule.Rule) + trimmedMsg := strings.TrimSpace(rule.Message) + if len(trimmedRule) == 0 { + allErrs = append(allErrs, field.Required(fldPath.Child("x-kubernetes-validations").Index(i).Child("rule"), "rule is not specified")) + } else if len(rule.Message) > 0 && len(trimmedMsg) == 0 { + allErrs = append(allErrs, field.Invalid(fldPath.Child("x-kubernetes-validations").Index(i).Child("message"), rule.Message, "message must be non-empty if specified")) + } else if hasNewlines(trimmedMsg) { + allErrs = append(allErrs, field.Invalid(fldPath.Child("x-kubernetes-validations").Index(i).Child("message"), rule.Message, "message must not contain line breaks")) + } else if hasNewlines(trimmedRule) && len(trimmedMsg) == 0 { + allErrs = append(allErrs, field.Required(fldPath.Child("x-kubernetes-validations").Index(i).Child("message"), "message must be specified if rule contains line breaks")) + } + } + + structural, err := structuralschema.NewStructural(schema) + if err == nil { + compResults, err := cel.Compile(structural, isRoot) + if err != nil { + allErrs = append(allErrs, field.InternalError(fldPath.Child("x-kubernetes-validations"), err)) + } else { + for i, cr := range compResults { + if cr.Error != nil { + if cr.Error.Type == cel.ErrorTypeRequired { + allErrs = append(allErrs, field.Required(fldPath.Child("x-kubernetes-validations").Index(i).Child("rule"), cr.Error.Detail)) + } else { + allErrs = append(allErrs, field.Invalid(fldPath.Child("x-kubernetes-validations").Index(i).Child("rule"), schema.XValidations[i], cr.Error.Detail)) + } + } + } + } + } + } + if opts.requireMapListKeysMapSetValidation { allErrs = append(allErrs, validateMapListKeysMapSet(schema, fldPath)...) } @@ -921,6 +952,11 @@ func ValidateCustomResourceDefinitionOpenAPISchema(schema *apiextensions.JSONSch return allErrs } +var newlineMatcher = regexp.MustCompile(`[\n\r]+`) // valid newline chars in CEL grammar +func hasNewlines(s string) bool { + return newlineMatcher.MatchString(s) +} + func validateMapListKeysMapSet(schema *apiextensions.JSONSchemaProps, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} @@ -1117,7 +1153,7 @@ func validateSimpleJSONPath(s string, fldPath *field.Path) field.ErrorList { return allErrs } -var allowedFieldsAtRootSchema = []string{"Description", "Type", "Format", "Title", "Maximum", "ExclusiveMaximum", "Minimum", "ExclusiveMinimum", "MaxLength", "MinLength", "Pattern", "MaxItems", "MinItems", "UniqueItems", "MultipleOf", "Required", "Items", "Properties", "ExternalDocs", "Example", "XPreserveUnknownFields"} +var allowedFieldsAtRootSchema = []string{"Description", "Type", "Format", "Title", "Maximum", "ExclusiveMaximum", "Minimum", "ExclusiveMinimum", "MaxLength", "MinLength", "Pattern", "MaxItems", "MinItems", "UniqueItems", "MultipleOf", "Required", "Items", "Properties", "ExternalDocs", "Example", "XPreserveUnknownFields", "XValidations"} func allowedAtRootSchema(field string) bool { for _, v := range allowedFieldsAtRootSchema { @@ -1129,11 +1165,7 @@ func allowedAtRootSchema(field string) bool { } // requireOpenAPISchema returns true if the request group version requires a schema -func requireOpenAPISchema(requestGV schema.GroupVersion, oldCRDSpec *apiextensions.CustomResourceDefinitionSpec) bool { - if requestGV == apiextensionsv1beta1.SchemeGroupVersion { - // for backwards compatibility - return false - } +func requireOpenAPISchema(oldCRDSpec *apiextensions.CustomResourceDefinitionSpec) bool { if oldCRDSpec != nil && !allVersionsSpecifyOpenAPISchema(oldCRDSpec) { // don't tighten validation on existing persisted data return false @@ -1152,30 +1184,17 @@ func allVersionsSpecifyOpenAPISchema(spec *apiextensions.CustomResourceDefinitio return true } -// allowDefaults returns true if the defaulting feature is enabled and the request group version allows adding defaults, -// or false and a reason for the user if defaults are not allowed. -func allowDefaults(requestGV schema.GroupVersion, oldCRDSpec *apiextensions.CustomResourceDefinitionSpec) (bool, string) { - if oldCRDSpec != nil && specHasDefaults(oldCRDSpec) { - // don't tighten validation on existing persisted data - return true, "" - } - if requestGV == apiextensionsv1beta1.SchemeGroupVersion { - return false, "(cannot set default values in apiextensions.k8s.io/v1beta1 CRDs, must use apiextensions.k8s.io/v1)" - } - return true, "" -} - func specHasDefaults(spec *apiextensions.CustomResourceDefinitionSpec) bool { - return hasSchemaWith(spec, schemaHasDefaults) + return HasSchemaWith(spec, schemaHasDefaults) } func schemaHasDefaults(s *apiextensions.JSONSchemaProps) bool { - return schemaHas(s, func(s *apiextensions.JSONSchemaProps) bool { + return SchemaHas(s, func(s *apiextensions.JSONSchemaProps) bool { return s.Default != nil }) } -func hasSchemaWith(spec *apiextensions.CustomResourceDefinitionSpec, pred func(s *apiextensions.JSONSchemaProps) bool) bool { +func HasSchemaWith(spec *apiextensions.CustomResourceDefinitionSpec, pred func(s *apiextensions.JSONSchemaProps) bool) bool { if spec.Validation != nil && spec.Validation.OpenAPIV3Schema != nil && pred(spec.Validation.OpenAPIV3Schema) { return true } @@ -1187,7 +1206,7 @@ func hasSchemaWith(spec *apiextensions.CustomResourceDefinitionSpec, pred func(s return false } -func schemaHas(s *apiextensions.JSONSchemaProps, pred func(s *apiextensions.JSONSchemaProps) bool) bool { +func SchemaHas(s *apiextensions.JSONSchemaProps, pred func(s *apiextensions.JSONSchemaProps) bool) bool { if s == nil { return false } @@ -1197,60 +1216,60 @@ func schemaHas(s *apiextensions.JSONSchemaProps, pred func(s *apiextensions.JSON } if s.Items != nil { - if s.Items != nil && schemaHas(s.Items.Schema, pred) { + if s.Items != nil && SchemaHas(s.Items.Schema, pred) { return true } for _, s := range s.Items.JSONSchemas { - if schemaHas(&s, pred) { + if SchemaHas(&s, pred) { return true } } } for _, s := range s.AllOf { - if schemaHas(&s, pred) { + if SchemaHas(&s, pred) { return true } } for _, s := range s.AnyOf { - if schemaHas(&s, pred) { + if SchemaHas(&s, pred) { return true } } for _, s := range s.OneOf { - if schemaHas(&s, pred) { + if SchemaHas(&s, pred) { return true } } - if schemaHas(s.Not, pred) { + if SchemaHas(s.Not, pred) { return true } for _, s := range s.Properties { - if schemaHas(&s, pred) { + if SchemaHas(&s, pred) { return true } } if s.AdditionalProperties != nil { - if schemaHas(s.AdditionalProperties.Schema, pred) { + if SchemaHas(s.AdditionalProperties.Schema, pred) { return true } } for _, s := range s.PatternProperties { - if schemaHas(&s, pred) { + if SchemaHas(&s, pred) { return true } } if s.AdditionalItems != nil { - if schemaHas(s.AdditionalItems.Schema, pred) { + if SchemaHas(s.AdditionalItems.Schema, pred) { return true } } for _, s := range s.Definitions { - if schemaHas(&s, pred) { + if SchemaHas(&s, pred) { return true } } for _, d := range s.Dependencies { - if schemaHas(d.Schema, pred) { + if SchemaHas(d.Schema, pred) { return true } } @@ -1271,17 +1290,13 @@ func specHasKubernetesExtensions(spec *apiextensions.CustomResourceDefinitionSpe } func schemaHasKubernetesExtensions(s *apiextensions.JSONSchemaProps) bool { - return schemaHas(s, func(s *apiextensions.JSONSchemaProps) bool { - return s.XEmbeddedResource || s.XPreserveUnknownFields != nil || s.XIntOrString || len(s.XListMapKeys) > 0 || s.XListType != nil + return SchemaHas(s, func(s *apiextensions.JSONSchemaProps) bool { + return s.XEmbeddedResource || s.XPreserveUnknownFields != nil || s.XIntOrString || len(s.XListMapKeys) > 0 || s.XListType != nil || len(s.XValidations) > 0 }) } // requireStructuralSchema returns true if schemas specified must be structural -func requireStructuralSchema(requestGV schema.GroupVersion, oldCRDSpec *apiextensions.CustomResourceDefinitionSpec) bool { - if requestGV == apiextensionsv1beta1.SchemeGroupVersion { - // for compatibility - return false - } +func requireStructuralSchema(oldCRDSpec *apiextensions.CustomResourceDefinitionSpec) bool { if oldCRDSpec != nil && specHasNonStructuralSchema(oldCRDSpec) { // don't tighten validation on existing persisted data return false @@ -1348,12 +1363,12 @@ func schemaHasUnprunedDefaults(schema *apiextensions.JSONSchemaProps) (bool, err // requireAtomicSetType returns true if the old CRD spec as at least one x-kubernetes-list-type=set with non-atomic items type. func requireAtomicSetType(oldCRDSpec *apiextensions.CustomResourceDefinitionSpec) bool { - return !hasSchemaWith(oldCRDSpec, hasNonAtomicSetType) + return !HasSchemaWith(oldCRDSpec, hasNonAtomicSetType) } // hasNonAtomicSetType recurses over the schema and returns whether any list of type "set" as non-atomic item types. func hasNonAtomicSetType(schema *apiextensions.JSONSchemaProps) bool { - return schemaHas(schema, func(schema *apiextensions.JSONSchemaProps) bool { + return SchemaHas(schema, func(schema *apiextensions.JSONSchemaProps) bool { if schema.XListType != nil && *schema.XListType == "set" && schema.Items != nil && schema.Items.Schema != nil { // we don't support schema.Items.JSONSchemas is := schema.Items.Schema switch is.Type { @@ -1370,21 +1385,17 @@ func hasNonAtomicSetType(schema *apiextensions.JSONSchemaProps) bool { } func requireMapListKeysMapSetValidation(oldCRDSpec *apiextensions.CustomResourceDefinitionSpec) bool { - return !hasSchemaWith(oldCRDSpec, hasInvalidMapListKeysMapSet) + return !HasSchemaWith(oldCRDSpec, hasInvalidMapListKeysMapSet) } func hasInvalidMapListKeysMapSet(schema *apiextensions.JSONSchemaProps) bool { - return schemaHas(schema, func(schema *apiextensions.JSONSchemaProps) bool { + return SchemaHas(schema, func(schema *apiextensions.JSONSchemaProps) bool { return len(validateMapListKeysMapSet(schema, field.NewPath(""))) > 0 }) } // requireValidPropertyType returns true if valid openapi v3 types should be required for the given API version -func requireValidPropertyType(requestGV schema.GroupVersion, oldCRDSpec *apiextensions.CustomResourceDefinitionSpec) bool { - if requestGV == apiextensionsv1beta1.SchemeGroupVersion { - // for compatibility - return false - } +func requireValidPropertyType(oldCRDSpec *apiextensions.CustomResourceDefinitionSpec) bool { if oldCRDSpec != nil && specHasInvalidTypes(oldCRDSpec) { // don't tighten validation on existing persisted data return false @@ -1393,13 +1404,8 @@ func requireValidPropertyType(requestGV schema.GroupVersion, oldCRDSpec *apiexte } // validateAPIApproval returns a list of errors if the API approval annotation isn't valid -func validateAPIApproval(newCRD, oldCRD *apiextensions.CustomResourceDefinition, requestGV schema.GroupVersion) field.ErrorList { +func validateAPIApproval(newCRD, oldCRD *apiextensions.CustomResourceDefinition) field.ErrorList { // check to see if we need confirm API approval for kube group. - - if requestGV == apiextensionsv1beta1.SchemeGroupVersion { - // no-op for compatibility with v1beta1 - return nil - } if !apihelpers.IsProtectedCommunityGroup(newCRD.Spec.Group) { // no-op for non-protected groups return nil @@ -1433,12 +1439,7 @@ func validateAPIApproval(newCRD, oldCRD *apiextensions.CustomResourceDefinition, } } -func validatePreserveUnknownFields(crd, oldCRD *apiextensions.CustomResourceDefinition, requestGV schema.GroupVersion) field.ErrorList { - if requestGV == apiextensionsv1beta1.SchemeGroupVersion { - // no-op for compatibility with v1beta1 - return nil - } - +func validatePreserveUnknownFields(crd, oldCRD *apiextensions.CustomResourceDefinition) field.ErrorList { if oldCRD != nil && oldCRD.Spec.PreserveUnknownFields != nil && *oldCRD.Spec.PreserveUnknownFields { // no-op for compatibility with existing data return nil @@ -1466,7 +1467,7 @@ func specHasInvalidTypes(spec *apiextensions.CustomResourceDefinitionSpec) bool // SchemaHasInvalidTypes returns true if it contains invalid offending openapi-v3 specification. func SchemaHasInvalidTypes(s *apiextensions.JSONSchemaProps) bool { - return schemaHas(s, func(s *apiextensions.JSONSchemaProps) bool { + return SchemaHas(s, func(s *apiextensions.JSONSchemaProps) bool { return len(s.Type) > 0 && !openapiV3Types.Has(s.Type) }) } diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/zz_generated.deepcopy.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/zz_generated.deepcopy.go index ba9e31e996..998c9dbe27 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -527,6 +528,42 @@ func (in *ServiceReference) DeepCopy() *ServiceReference { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ValidationRule) DeepCopyInto(out *ValidationRule) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidationRule. +func (in *ValidationRule) DeepCopy() *ValidationRule { + if in == nil { + return nil + } + out := new(ValidationRule) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in ValidationRules) DeepCopyInto(out *ValidationRules) { + { + in := &in + *out = make(ValidationRules, len(*in)) + copy(*out, *in) + return + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidationRules. +func (in ValidationRules) DeepCopy() ValidationRules { + if in == nil { + return nil + } + out := new(ValidationRules) + in.DeepCopyInto(out) + return *out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *WebhookClientConfig) DeepCopyInto(out *WebhookClientConfig) { *out = *in diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/compilation.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/compilation.go new file mode 100644 index 0000000000..53652f6652 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/compilation.go @@ -0,0 +1,127 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cel + +import ( + "fmt" + "strings" + "time" + + "github.com/google/cel-go/cel" + "github.com/google/cel-go/checker/decls" + "github.com/google/cel-go/ext" + + expr "google.golang.org/genproto/googleapis/api/expr/v1alpha1" + "google.golang.org/protobuf/proto" + + "k8s.io/apiextensions-apiserver/pkg/apiserver/schema" + celmodel "k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model" +) + +// ScopedVarName is the variable name assigned to the locally scoped data element of a CEL valid. +const ScopedVarName = "self" + +// CompilationResult represents the cel compilation result for one rule +type CompilationResult struct { + Program cel.Program + Error *Error +} + +// Compile compiles all the XValidations rules (without recursing into the schema) and returns a slice containing a +// CompilationResult for each ValidationRule, or an error. +// Each CompilationResult may contain: +/// - non-nil Program, nil Error: The program was compiled successfully +// - nil Program, non-nil Error: Compilation resulted in an error +// - nil Program, nil Error: The provided rule was empty so compilation was not attempted +func Compile(s *schema.Structural, isResourceRoot bool) ([]CompilationResult, error) { + if len(s.Extensions.XValidations) == 0 { + return nil, nil + } + celRules := s.Extensions.XValidations + + var propDecls []*expr.Decl + var root *celmodel.DeclType + var ok bool + env, err := cel.NewEnv() + if err != nil { + return nil, err + } + reg := celmodel.NewRegistry(env) + scopedTypeName := generateUniqueSelfTypeName() + rt, err := celmodel.NewRuleTypes(scopedTypeName, s, isResourceRoot, reg) + if err != nil { + return nil, err + } + if rt == nil { + return nil, nil + } + opts, err := rt.EnvOptions(env.TypeProvider()) + if err != nil { + return nil, err + } + root, ok = rt.FindDeclType(scopedTypeName) + if !ok { + rootDecl := celmodel.SchemaDeclType(s, isResourceRoot) + if rootDecl == nil { + return nil, fmt.Errorf("rule declared on schema that does not support validation rules type: '%s' x-kubernetes-preserve-unknown-fields: '%t'", s.Type, s.XPreserveUnknownFields) + } + root = rootDecl.MaybeAssignTypeName(scopedTypeName) + } + propDecls = append(propDecls, decls.NewVar(ScopedVarName, root.ExprType())) + opts = append(opts, cel.Declarations(propDecls...)) + opts = append(opts, ext.Strings()) + env, err = env.Extend(opts...) + if err != nil { + return nil, err + } + + // compResults is the return value which saves a list of compilation results in the same order as x-kubernetes-validations rules. + compResults := make([]CompilationResult, len(celRules)) + for i, rule := range celRules { + var compilationResult CompilationResult + if len(strings.TrimSpace(rule.Rule)) == 0 { + // include a compilation result, but leave both program and error nil per documented return semantics of this + // function + } else { + ast, issues := env.Compile(rule.Rule) + if issues != nil { + compilationResult.Error = &Error{ErrorTypeInvalid, "compilation failed: " + issues.String()} + } else if !proto.Equal(ast.ResultType(), decls.Bool) { + compilationResult.Error = &Error{ErrorTypeInvalid, "cel expression must evaluate to a bool"} + } else { + prog, err := env.Program(ast) + if err != nil { + compilationResult.Error = &Error{ErrorTypeInvalid, "program instantiation failed: " + err.Error()} + } else { + compilationResult.Program = prog + } + } + } + + compResults[i] = compilationResult + } + + return compResults, nil +} + +// generateUniqueSelfTypeName creates a placeholder type name to use in a CEL programs for cases +// where we do not wish to expose a stable type name to CEL validator rule authors. For this to effectively prevent +// developers from depending on the generated name (i.e. using it in CEL programs), it must be changed each time a +// CRD is created or updated. +func generateUniqueSelfTypeName() string { + return fmt.Sprintf("selfType%d", time.Now().Nanosecond()) +} diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/errors.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/errors.go new file mode 100644 index 0000000000..907ca6ec8f --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/errors.go @@ -0,0 +1,47 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cel + +// Error is an implementation of the 'error' interface, which represents a +// XValidation error. +type Error struct { + Type ErrorType + Detail string +} + +var _ error = &Error{} + +// Error implements the error interface. +func (v *Error) Error() string { + return v.Detail +} + +// ErrorType is a machine readable value providing more detail about why +// a XValidation is invalid. +type ErrorType string + +const ( + // ErrorTypeRequired is used to report withNullable values that are not + // provided (e.g. empty strings, null values, or empty arrays). See + // Required(). + ErrorTypeRequired ErrorType = "RuleRequired" + // ErrorTypeInvalid is used to report malformed values + ErrorTypeInvalid ErrorType = "RuleInvalid" + // ErrorTypeInternal is used to report other errors that are not related + // to user input. See InternalError(). + ErrorTypeInternal ErrorType = "InternalError" +) diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/validation.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/validation.go new file mode 100644 index 0000000000..acaa7478bd --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/validation.go @@ -0,0 +1,223 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cel + +import ( + "fmt" + "strings" + + "github.com/google/cel-go/common/types" + "github.com/google/cel-go/common/types/ref" + "github.com/google/cel-go/interpreter" + + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" + "k8s.io/apiextensions-apiserver/pkg/apiserver/schema" + "k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model" + "k8s.io/apimachinery/pkg/util/validation/field" +) + +// Validator parallels the structure of schema.Structural and includes the compiled CEL programs +// for the x-kubernetes-validations of each schema node. +type Validator struct { + Items *Validator + Properties map[string]Validator + + AdditionalProperties *Validator + + compiledRules []CompilationResult + + // Program compilation is pre-checked at CRD creation/update time, so we don't expect compilation to fail + // they are recompiled and added to this type, and it does, it is an internal bug. + // But if somehow we get any compilation errors, we track them and then surface them as validation errors. + compilationErr error + + // isResourceRoot is true if this validator node is for the root of a resource. Either the root of the + // custom resource being validated, or the root of an XEmbeddedResource object. + isResourceRoot bool +} + +// NewValidator returns compiles all the CEL programs defined in x-kubernetes-validations extensions +// of the Structural schema and returns a custom resource validator that contains nested +// validators for all items, properties and additionalProperties that transitively contain validator rules. +// Returns nil only if there no validator rules in the Structural schema. May return a validator containing +// only errors. +func NewValidator(s *schema.Structural) *Validator { + return validator(s, true) +} + +func validator(s *schema.Structural, isResourceRoot bool) *Validator { + compiledRules, err := Compile(s, isResourceRoot) + var itemsValidator, additionalPropertiesValidator *Validator + var propertiesValidators map[string]Validator + if s.Items != nil { + itemsValidator = validator(s.Items, s.Items.XEmbeddedResource) + } + if len(s.Properties) > 0 { + propertiesValidators = make(map[string]Validator, len(s.Properties)) + for k, prop := range s.Properties { + if p := validator(&prop, prop.XEmbeddedResource); p != nil { + propertiesValidators[k] = *p + } + } + } + if s.AdditionalProperties != nil && s.AdditionalProperties.Structural != nil { + additionalPropertiesValidator = validator(s.AdditionalProperties.Structural, s.AdditionalProperties.Structural.XEmbeddedResource) + } + if len(compiledRules) > 0 || err != nil || itemsValidator != nil || additionalPropertiesValidator != nil || len(propertiesValidators) > 0 { + return &Validator{ + compiledRules: compiledRules, + compilationErr: err, + isResourceRoot: isResourceRoot, + Items: itemsValidator, + AdditionalProperties: additionalPropertiesValidator, + Properties: propertiesValidators, + } + } + + return nil +} + +// Validate validates all x-kubernetes-validations rules in Validator against obj and returns any errors. +func (s *Validator) Validate(fldPath *field.Path, sts *schema.Structural, obj interface{}) field.ErrorList { + if s == nil || obj == nil { + return nil + } + + errs := s.validateExpressions(fldPath, sts, obj) + switch obj := obj.(type) { + case []interface{}: + return append(errs, s.validateArray(fldPath, sts, obj)...) + case map[string]interface{}: + return append(errs, s.validateMap(fldPath, sts, obj)...) + } + return errs +} + +func (s *Validator) validateExpressions(fldPath *field.Path, sts *schema.Structural, obj interface{}) (errs field.ErrorList) { + if obj == nil { + // We only validate non-null values. Rules that need to check for the state of a nullable value or the presence of an optional + // field must do so from the surrounding schema. E.g. if an array has nullable string items, a rule on the array + // schema can check if items are null, but a rule on the nullable string schema only validates the non-null strings. + return nil + } + if s.compilationErr != nil { + errs = append(errs, field.Invalid(fldPath, obj, fmt.Sprintf("rule compiler initialization error: %v", s.compilationErr))) + return errs + } + if len(s.compiledRules) == 0 { + return nil // nothing to do + } + if s.isResourceRoot { + sts = model.WithTypeAndObjectMeta(sts) + } + activation := NewValidationActivation(obj, sts) + for i, compiled := range s.compiledRules { + rule := sts.XValidations[i] + if compiled.Error != nil { + errs = append(errs, field.Invalid(fldPath, obj, fmt.Sprintf("rule compile error: %v", compiled.Error))) + continue + } + if compiled.Program == nil { + // rule is empty + continue + } + evalResult, _, err := compiled.Program.Eval(activation) + if err != nil { + // see types.Err for list of well defined error types + if strings.HasPrefix(err.Error(), "no such overload") { + // Most overload errors are caught by the compiler, which provides details on where exactly in the rule + // error was found. Here, an overload error has occurred at runtime no details are provided, so we + // append a more descriptive error message. This error can only occur when static type checking has + // been bypassed. int-or-string is typed as dynamic and so bypasses compiler type checking. + errs = append(errs, field.Invalid(fldPath, obj, fmt.Sprintf("'%v': call arguments did not match a supported operator, function or macro signature for rule: %v", err, ruleErrorString(rule)))) + } else { + // no such key: {key}, index out of bounds: {index}, integer overflow, division by zero, ... + errs = append(errs, field.Invalid(fldPath, obj, fmt.Sprintf("%v evaluating rule: %v", err, ruleErrorString(rule)))) + } + continue + } + if evalResult != types.True { + if len(rule.Message) != 0 { + errs = append(errs, field.Invalid(fldPath, obj, rule.Message)) + } else { + errs = append(errs, field.Invalid(fldPath, obj, fmt.Sprintf("failed rule: %s", ruleErrorString(rule)))) + } + } + } + return errs +} + +func ruleErrorString(rule apiextensions.ValidationRule) string { + if len(rule.Message) > 0 { + return strings.TrimSpace(rule.Message) + } + return strings.TrimSpace(rule.Rule) +} + +type validationActivation struct { + self ref.Val +} + +func NewValidationActivation(obj interface{}, structural *schema.Structural) *validationActivation { + return &validationActivation{self: UnstructuredToVal(obj, structural)} +} + +func (a *validationActivation) ResolveName(name string) (interface{}, bool) { + if name == ScopedVarName { + return a.self, true + } + return nil, false +} + +func (a *validationActivation) Parent() interpreter.Activation { + return nil +} + +func (s *Validator) validateMap(fldPath *field.Path, sts *schema.Structural, obj map[string]interface{}) (errs field.ErrorList) { + if s == nil || obj == nil { + return nil + } + + if s.AdditionalProperties != nil && sts.AdditionalProperties != nil && sts.AdditionalProperties.Structural != nil { + for k, v := range obj { + errs = append(errs, s.AdditionalProperties.Validate(fldPath.Key(k), sts.AdditionalProperties.Structural, v)...) + } + } + if s.Properties != nil && sts.Properties != nil { + for k, v := range obj { + stsProp, stsOk := sts.Properties[k] + sub, ok := s.Properties[k] + if ok && stsOk { + errs = append(errs, sub.Validate(fldPath.Child(k), &stsProp, v)...) + } + } + } + + return errs +} + +func (s *Validator) validateArray(fldPath *field.Path, sts *schema.Structural, obj []interface{}) field.ErrorList { + var errs field.ErrorList + + if s.Items != nil && sts.Items != nil { + for i := range obj { + errs = append(errs, s.Items.Validate(fldPath.Index(i), sts.Items, obj[i])...) + } + } + + return errs +} diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/values.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/values.go new file mode 100644 index 0000000000..25c0333067 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel/values.go @@ -0,0 +1,703 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cel + +import ( + "fmt" + "reflect" + "sync" + "time" + + "github.com/google/cel-go/common/types" + "github.com/google/cel-go/common/types/ref" + "github.com/google/cel-go/common/types/traits" + "k8s.io/apimachinery/pkg/api/equality" + + structuralschema "k8s.io/apiextensions-apiserver/pkg/apiserver/schema" + "k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model" + "k8s.io/kube-openapi/pkg/validation/strfmt" +) + +// UnstructuredToVal converts a Kubernetes unstructured data element to a CEL Val. +// The root schema of custom resource schema is expected contain type meta and object meta schemas. +// If Embedded resources do not contain type meta and object meta schemas, they will be added automatically. +func UnstructuredToVal(unstructured interface{}, schema *structuralschema.Structural) ref.Val { + if unstructured == nil { + if schema.Nullable { + return types.NullValue + } + return types.NewErr("invalid data, got null for schema with nullable=false") + } + if schema.XIntOrString { + switch v := unstructured.(type) { + case string: + return types.String(v) + case int: + return types.Int(v) + case int32: + return types.Int(v) + case int64: + return types.Int(v) + } + return types.NewErr("invalid data, expected XIntOrString value to be either a string or integer") + } + if schema.Type == "object" { + m, ok := unstructured.(map[string]interface{}) + if !ok { + return types.NewErr("invalid data, expected map[string]interface{} to match the provided schema with type=object") + } + if schema.XEmbeddedResource || schema.Properties != nil { + if schema.XEmbeddedResource { + schema = model.WithTypeAndObjectMeta(schema) + } + return &unstructuredMap{ + value: m, + schema: schema, + propSchema: func(key string) (*structuralschema.Structural, bool) { + if schema, ok := schema.Properties[key]; ok { + return &schema, true + } + return nil, false + }, + } + } + if schema.AdditionalProperties != nil && schema.AdditionalProperties.Structural != nil { + return &unstructuredMap{ + value: m, + schema: schema, + propSchema: func(key string) (*structuralschema.Structural, bool) { + return schema.AdditionalProperties.Structural, true + }, + } + } + // A object with x-preserve-unknown-fields but no properties or additionalProperties is treated + // as an empty object. + if schema.XPreserveUnknownFields { + return &unstructuredMap{ + value: m, + schema: schema, + propSchema: func(key string) (*structuralschema.Structural, bool) { + return nil, false + }, + } + } + return types.NewErr("invalid object type, expected either Properties or AdditionalProperties with Allows=true and non-empty Schema") + } + + if schema.Type == "array" { + l, ok := unstructured.([]interface{}) + if !ok { + return types.NewErr("invalid data, expected []interface{} to match the provided schema with type=array") + } + if schema.Items == nil { + return types.NewErr("invalid array type, expected Items with a non-empty Schema") + } + typedList := unstructuredList{elements: l, itemsSchema: schema.Items} + listType := schema.XListType + if listType != nil { + switch *listType { + case "map": + mapKeys := schema.Extensions.XListMapKeys + return &unstructuredMapList{unstructuredList: typedList, escapedKeyProps: escapeKeyProps(mapKeys)} + case "set": + return &unstructuredSetList{unstructuredList: typedList} + case "atomic": + return &typedList + default: + return types.NewErr("invalid x-kubernetes-list-type, expected 'map', 'set' or 'atomic' but got %s", *listType) + } + } + return &typedList + } + + if schema.Type == "string" { + str, ok := unstructured.(string) + if !ok { + return types.NewErr("invalid data, expected string, got %T", unstructured) + } + if schema.ValueValidation != nil { + switch schema.ValueValidation.Format { + case "duration": + d, err := strfmt.ParseDuration(str) + if err != nil { + return types.NewErr("Invalid duration %s: %v", str, err) + } + return types.Duration{Duration: d} + case "date": + d, err := time.Parse(strfmt.RFC3339FullDate, str) // strfmt uses this format for OpenAPIv3 value validation + if err != nil { + return types.NewErr("Invalid date formatted string %s: %v", str, err) + } + return types.Timestamp{Time: d} + case "date-time": + d, err := strfmt.ParseDateTime(str) + if err != nil { + return types.NewErr("Invalid date-time formatted string %s: %v", str, err) + } + return types.Timestamp{Time: time.Time(d)} + case "byte": + base64 := strfmt.Base64{} + err := base64.UnmarshalText([]byte(str)) + if err != nil { + return types.NewErr("Invalid byte formatted string %s: %v", str, err) + } + return types.Bytes(base64) + } + } + return types.String(str) + } + if schema.Type == "number" { + switch v := unstructured.(type) { + // float representations of whole numbers (e.g. 1.0, 0.0) can convert to int representations (e.g. 1, 0) in yaml + // to json translation, and then get parsed as int64s + case int: + return types.Double(v) + case int32: + return types.Double(v) + case int64: + return types.Double(v) + + case float32: + return types.Double(v) + case float64: + return types.Double(v) + default: + return types.NewErr("invalid data, expected float, got %T", unstructured) + } + } + if schema.Type == "integer" { + switch v := unstructured.(type) { + case int: + return types.Int(v) + case int32: + return types.Int(v) + case int64: + return types.Int(v) + default: + return types.NewErr("invalid data, expected int, got %T", unstructured) + } + } + if schema.Type == "boolean" { + b, ok := unstructured.(bool) + if !ok { + return types.NewErr("invalid data, expected bool, got %T", unstructured) + } + return types.Bool(b) + } + + if schema.XPreserveUnknownFields { + return &unknownPreserved{u: unstructured} + } + + return types.NewErr("invalid type, expected object, array, number, integer, boolean or string, or no type with x-kubernetes-int-or-string or x-kubernetes-preserve-unknown-fields is true, got %s", schema.Type) +} + +// unknownPreserved represents unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields. +// It preserves the data at runtime without assuming it is of any particular type and supports only equality checking. +// unknownPreserved should be used only for values are not directly accessible in CEL expressions, i.e. for data +// where there is no corresponding CEL type declaration. +type unknownPreserved struct { + u interface{} +} + +func (t *unknownPreserved) ConvertToNative(refType reflect.Type) (interface{}, error) { + return nil, fmt.Errorf("type conversion to '%s' not supported for values preserved by x-kubernetes-preserve-unknown-fields", refType) +} + +func (t *unknownPreserved) ConvertToType(typeValue ref.Type) ref.Val { + return types.NewErr("type conversion to '%s' not supported for values preserved by x-kubernetes-preserve-unknown-fields", typeValue.TypeName()) +} + +func (t *unknownPreserved) Equal(other ref.Val) ref.Val { + return types.Bool(equality.Semantic.DeepEqual(t.u, other.Value())) +} + +func (t *unknownPreserved) Type() ref.Type { + return types.UnknownType +} + +func (t *unknownPreserved) Value() interface{} { + return t.u // used by Equal checks +} + +// unstructuredMapList represents an unstructured data instance of an OpenAPI array with x-kubernetes-list-type=map. +type unstructuredMapList struct { + unstructuredList + escapedKeyProps []string + + sync.Once // for for lazy load of mapOfList since it is only needed if Equals is called + mapOfList map[interface{}]interface{} +} + +func (t *unstructuredMapList) getMap() map[interface{}]interface{} { + t.Do(func() { + t.mapOfList = make(map[interface{}]interface{}, len(t.elements)) + for _, e := range t.elements { + t.mapOfList[t.toMapKey(e)] = e + } + }) + return t.mapOfList +} + +// toMapKey returns a valid golang map key for the given element of the map list. +// element must be a valid map list entry where all map key props are scalar types (which are comparable in go +// and valid for use in a golang map key). +func (t *unstructuredMapList) toMapKey(element interface{}) interface{} { + eObj, ok := element.(map[string]interface{}) + if !ok { + return types.NewErr("unexpected data format for element of array with x-kubernetes-list-type=map: %T", element) + } + // Arrays are comparable in go and may be used as map keys, but maps and slices are not. + // So we can special case small numbers of key props as arrays and fall back to serialization + // for larger numbers of key props + if len(t.escapedKeyProps) == 1 { + return eObj[t.escapedKeyProps[0]] + } + if len(t.escapedKeyProps) == 2 { + return [2]interface{}{eObj[t.escapedKeyProps[0]], eObj[t.escapedKeyProps[1]]} + } + if len(t.escapedKeyProps) == 3 { + return [3]interface{}{eObj[t.escapedKeyProps[0]], eObj[t.escapedKeyProps[1]], eObj[t.escapedKeyProps[2]]} + } + + key := make([]interface{}, len(t.escapedKeyProps)) + for i, kf := range t.escapedKeyProps { + key[i] = eObj[kf] + } + return fmt.Sprintf("%v", key) +} + +// Equal on a map list ignores list element order. +func (t *unstructuredMapList) Equal(other ref.Val) ref.Val { + oMapList, ok := other.(traits.Lister) + if !ok { + return types.MaybeNoSuchOverloadErr(other) + } + sz := types.Int(len(t.elements)) + if sz != oMapList.Size() { + return types.False + } + tMap := t.getMap() + for it := oMapList.Iterator(); it.HasNext() == types.True; { + v := it.Next() + k := t.toMapKey(v.Value()) + tVal, ok := tMap[k] + if !ok { + return types.False + } + eq := UnstructuredToVal(tVal, t.itemsSchema).Equal(v) + if eq != types.True { + return eq // either false or error + } + } + return types.True +} + +// Add for a map list `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values +// are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with +// non-intersecting keys are appended, retaining their partial order. +func (t *unstructuredMapList) Add(other ref.Val) ref.Val { + oMapList, ok := other.(traits.Lister) + if !ok { + return types.MaybeNoSuchOverloadErr(other) + } + elements := make([]interface{}, len(t.elements)) + keyToIdx := map[interface{}]int{} + for i, e := range t.elements { + k := t.toMapKey(e) + keyToIdx[k] = i + elements[i] = e + } + for it := oMapList.Iterator(); it.HasNext() == types.True; { + v := it.Next().Value() + k := t.toMapKey(v) + if overwritePosition, ok := keyToIdx[k]; ok { + elements[overwritePosition] = v + } else { + elements = append(elements, v) + } + } + return &unstructuredMapList{ + unstructuredList: unstructuredList{elements: elements, itemsSchema: t.itemsSchema}, + escapedKeyProps: t.escapedKeyProps, + } +} + +// escapeKeyProps returns identifiers with Escape applied to each. +// Identifiers that cannot be escaped are left as-is. They are inaccessible to CEL programs but are +// are still needed internally to perform equality checks. +func escapeKeyProps(idents []string) []string { + result := make([]string, len(idents)) + for i, prop := range idents { + if escaped, ok := model.Escape(prop); ok { + result[i] = escaped + } else { + result[i] = prop + } + } + return result +} + +// unstructuredSetList represents an unstructured data instance of an OpenAPI array with x-kubernetes-list-type=set. +type unstructuredSetList struct { + unstructuredList + escapedKeyProps []string + + sync.Once // for for lazy load of setOfList since it is only needed if Equals is called + set map[interface{}]struct{} +} + +func (t *unstructuredSetList) getSet() map[interface{}]struct{} { + // sets are only allowed to contain scalar elements, which are comparable in go, and can safely be used as + // golang map keys + t.Do(func() { + t.set = make(map[interface{}]struct{}, len(t.elements)) + for _, e := range t.elements { + t.set[e] = struct{}{} + } + }) + return t.set +} + +// Equal on a map list ignores list element order. +func (t *unstructuredSetList) Equal(other ref.Val) ref.Val { + oSetList, ok := other.(traits.Lister) + if !ok { + return types.MaybeNoSuchOverloadErr(other) + } + sz := types.Int(len(t.elements)) + if sz != oSetList.Size() { + return types.False + } + tSet := t.getSet() + for it := oSetList.Iterator(); it.HasNext() == types.True; { + next := it.Next().Value() + _, ok := tSet[next] + if !ok { + return types.False + } + } + return types.True +} + +// Add for a set list `X + Y` performs a union where the array positions of all elements in `X` are preserved and +// non-intersecting elements in `Y` are appended, retaining their partial order. +func (t *unstructuredSetList) Add(other ref.Val) ref.Val { + oSetList, ok := other.(traits.Lister) + if !ok { + return types.MaybeNoSuchOverloadErr(other) + } + elements := t.elements + set := t.getSet() + for it := oSetList.Iterator(); it.HasNext() == types.True; { + next := it.Next().Value() + if _, ok := set[next]; !ok { + set[next] = struct{}{} + elements = append(elements, next) + } + } + return &unstructuredSetList{ + unstructuredList: unstructuredList{elements: elements, itemsSchema: t.itemsSchema}, + escapedKeyProps: t.escapedKeyProps, + } +} + +// unstructuredList represents an unstructured data instance of an OpenAPI array with x-kubernetes-list-type=atomic (the default). +type unstructuredList struct { + elements []interface{} + itemsSchema *structuralschema.Structural +} + +var _ = traits.Lister(&unstructuredList{}) + +func (t *unstructuredList) ConvertToNative(typeDesc reflect.Type) (interface{}, error) { + switch typeDesc.Kind() { + case reflect.Slice: + return t.elements, nil + } + return nil, fmt.Errorf("type conversion error from '%s' to '%s'", t.Type(), typeDesc) +} + +func (t *unstructuredList) ConvertToType(typeValue ref.Type) ref.Val { + switch typeValue { + case types.ListType: + return t + case types.TypeType: + return types.ListType + } + return types.NewErr("type conversion error from '%s' to '%s'", t.Type(), typeValue.TypeName()) +} + +func (t *unstructuredList) Equal(other ref.Val) ref.Val { + oList, ok := other.(traits.Lister) + if !ok { + return types.MaybeNoSuchOverloadErr(other) + } + sz := types.Int(len(t.elements)) + if sz != oList.Size() { + return types.False + } + for i := types.Int(0); i < sz; i++ { + eq := t.Get(i).Equal(oList.Get(i)) + if eq != types.True { + return eq // either false or error + } + } + return types.True +} + +func (t *unstructuredList) Type() ref.Type { + return types.ListType +} + +func (t *unstructuredList) Value() interface{} { + return t.elements +} + +func (t *unstructuredList) Add(other ref.Val) ref.Val { + oList, ok := other.(traits.Lister) + if !ok { + return types.MaybeNoSuchOverloadErr(other) + } + elements := t.elements + for it := oList.Iterator(); it.HasNext() == types.True; { + next := it.Next().Value() + elements = append(elements, next) + } + + return &unstructuredList{elements: elements, itemsSchema: t.itemsSchema} +} + +func (t *unstructuredList) Contains(val ref.Val) ref.Val { + if types.IsUnknownOrError(val) { + return val + } + var err ref.Val + sz := len(t.elements) + for i := 0; i < sz; i++ { + elem := UnstructuredToVal(t.elements[i], t.itemsSchema) + cmp := elem.Equal(val) + b, ok := cmp.(types.Bool) + if !ok && err == nil { + err = types.MaybeNoSuchOverloadErr(cmp) + } + if b == types.True { + return types.True + } + } + if err != nil { + return err + } + return types.False +} + +func (t *unstructuredList) Get(idx ref.Val) ref.Val { + iv, isInt := idx.(types.Int) + if !isInt { + return types.ValOrErr(idx, "unsupported index: %v", idx) + } + i := int(iv) + if i < 0 || i >= len(t.elements) { + return types.NewErr("index out of bounds: %v", idx) + } + return UnstructuredToVal(t.elements[i], t.itemsSchema) +} + +func (t *unstructuredList) Iterator() traits.Iterator { + items := make([]ref.Val, len(t.elements)) + for i, item := range t.elements { + itemCopy := item + items[i] = UnstructuredToVal(itemCopy, t.itemsSchema) + } + return &listIterator{unstructuredList: t, items: items} +} + +type listIterator struct { + *unstructuredList + items []ref.Val + idx int +} + +func (it *listIterator) HasNext() ref.Val { + return types.Bool(it.idx < len(it.items)) +} + +func (it *listIterator) Next() ref.Val { + item := it.items[it.idx] + it.idx++ + return item +} + +func (t *unstructuredList) Size() ref.Val { + return types.Int(len(t.elements)) +} + +// unstructuredMap represented an unstructured data instance of an OpenAPI object. +type unstructuredMap struct { + value map[string]interface{} + schema *structuralschema.Structural + // propSchema finds the schema to use for a particular map key. + propSchema func(key string) (*structuralschema.Structural, bool) +} + +var _ = traits.Mapper(&unstructuredMap{}) + +func (t *unstructuredMap) ConvertToNative(typeDesc reflect.Type) (interface{}, error) { + switch typeDesc.Kind() { + case reflect.Map: + return t.value, nil + } + return nil, fmt.Errorf("type conversion error from '%s' to '%s'", t.Type(), typeDesc) +} + +func (t *unstructuredMap) ConvertToType(typeValue ref.Type) ref.Val { + switch typeValue { + case types.MapType: + return t + case types.TypeType: + return types.MapType + } + return types.NewErr("type conversion error from '%s' to '%s'", t.Type(), typeValue.TypeName()) +} + +func (t *unstructuredMap) Equal(other ref.Val) ref.Val { + oMap, isMap := other.(traits.Mapper) + if !isMap { + return types.MaybeNoSuchOverloadErr(other) + } + if t.Size() != oMap.Size() { + return types.False + } + for key, value := range t.value { + if propSchema, ok := t.propSchema(key); ok { + ov, found := oMap.Find(types.String(key)) + if !found { + return types.False + } + v := UnstructuredToVal(value, propSchema) + vEq := v.Equal(ov) + if vEq != types.True { + return vEq // either false or error + } + } else { + // Must be an object with properties. + // Since we've encountered an unknown field, fallback to unstructured equality checking. + ouMap, ok := other.(*unstructuredMap) + if !ok { + // The compiler ensures equality is against the same type of object, so this should be unreachable + return types.MaybeNoSuchOverloadErr(other) + } + if oValue, ok := ouMap.value[key]; ok { + if !equality.Semantic.DeepEqual(value, oValue) { + return types.False + } + } + } + } + return types.True +} + +func (t *unstructuredMap) Type() ref.Type { + return types.MapType +} + +func (t *unstructuredMap) Value() interface{} { + return t.value +} + +func (t *unstructuredMap) Contains(key ref.Val) ref.Val { + v, found := t.Find(key) + if v != nil && types.IsUnknownOrError(v) { + return v + } + + return types.Bool(found) +} + +func (t *unstructuredMap) Get(key ref.Val) ref.Val { + v, found := t.Find(key) + if found { + return v + } + return types.ValOrErr(key, "no such key: %v", key) +} + +func (t *unstructuredMap) Iterator() traits.Iterator { + isObject := t.schema.Properties != nil + keys := make([]ref.Val, len(t.value)) + i := 0 + for k := range t.value { + if _, ok := t.propSchema(k); ok { + mapKey := k + if isObject { + if escaped, ok := model.Escape(k); ok { + mapKey = escaped + } + } + keys[i] = types.String(mapKey) + i++ + } + } + return &mapIterator{unstructuredMap: t, keys: keys} +} + +type mapIterator struct { + *unstructuredMap + keys []ref.Val + idx int +} + +func (it *mapIterator) HasNext() ref.Val { + return types.Bool(it.idx < len(it.keys)) +} + +func (it *mapIterator) Next() ref.Val { + key := it.keys[it.idx] + it.idx++ + return key +} + +func (t *unstructuredMap) Size() ref.Val { + return types.Int(len(t.value)) +} + +func (t *unstructuredMap) Find(key ref.Val) (ref.Val, bool) { + isObject := t.schema.Properties != nil + keyStr, ok := key.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(key), true + } + k := keyStr.Value().(string) + if isObject { + k, ok = model.Unescape(k) + if !ok { + return nil, false + } + } + if v, ok := t.value[k]; ok { + // If this is an object with properties, not an object with additionalProperties, + // then null valued nullable fields are treated the same as absent optional fields. + if isObject && v == nil { + return nil, false + } + if propSchema, ok := t.propSchema(k); ok { + return UnstructuredToVal(v, propSchema), true + } + } + + return nil, false +} diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/convert.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/convert.go index b7a19d17de..4b6b1eedf6 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/convert.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/convert.go @@ -18,7 +18,6 @@ package schema import ( "fmt" - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" ) @@ -247,6 +246,7 @@ func newExtensions(s *apiextensions.JSONSchemaProps) (*Extensions, error) { XListMapKeys: s.XListMapKeys, XListType: s.XListType, XMapType: s.XMapType, + XValidations: s.XValidations, } if s.XPreserveUnknownFields != nil { diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/defaulting/validation.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/defaulting/validation.go index 7700a6ced9..88fa3eba9b 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/defaulting/validation.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/defaulting/validation.go @@ -21,6 +21,7 @@ import ( "reflect" structuralschema "k8s.io/apiextensions-apiserver/pkg/apiserver/schema" + "k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel" schemaobjectmeta "k8s.io/apiextensions-apiserver/pkg/apiserver/schema/objectmeta" "k8s.io/apiextensions-apiserver/pkg/apiserver/schema/pruning" apiservervalidation "k8s.io/apiextensions-apiserver/pkg/apiserver/validation" @@ -84,6 +85,8 @@ func validate(pth *field.Path, s *structuralschema.Structural, rootSchema *struc allErrs = append(allErrs, field.Invalid(pth.Child("default"), s.Default.Object, fmt.Sprintf("must result in valid metadata: %v", errs.ToAggregate()))) } else if errs := apiservervalidation.ValidateCustomResource(pth.Child("default"), s.Default.Object, validator); len(errs) > 0 { allErrs = append(allErrs, errs...) + } else if celValidator := cel.NewValidator(s); celValidator != nil { + allErrs = append(allErrs, celValidator.Validate(pth.Child("default"), s, s.Default.Object)...) } } else { // check whether default is pruned @@ -102,6 +105,8 @@ func validate(pth *field.Path, s *structuralschema.Structural, rootSchema *struc allErrs = append(allErrs, errs...) } else if errs := apiservervalidation.ValidateCustomResource(pth.Child("default"), s.Default.Object, validator); len(errs) > 0 { allErrs = append(allErrs, errs...) + } else if celValidator := cel.NewValidator(s); celValidator != nil { + allErrs = append(allErrs, celValidator.Validate(pth.Child("default"), s, s.Default.Object)...) } } } diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/kubeopenapi.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/kubeopenapi.go index f389ed4e05..23bffbfb19 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/kubeopenapi.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/kubeopenapi.go @@ -87,6 +87,9 @@ func (x *Extensions) toKubeOpenAPI(ret *spec.Schema) { if x.XMapType != nil { ret.VendorExtensible.AddExtension("x-kubernetes-map-type", *x.XMapType) } + if len(x.XValidations) > 0 { + ret.VendorExtensible.AddExtension("x-kubernetes-validations", x.XValidations) + } } func (v *ValueValidation) toKubeOpenAPI(ret *spec.Schema) { diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/objectmeta/coerce.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/objectmeta/coerce.go index 39850e3d20..d9c486c37e 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/objectmeta/coerce.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/objectmeta/coerce.go @@ -22,11 +22,9 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/runtime/serializer/json" + utiljson "k8s.io/apimachinery/pkg/util/json" ) -var encodingjson = json.CaseSensitiveJSONIterator() - // GetObjectMeta does conversion of JSON to ObjectMeta. It first tries json.Unmarshal into a metav1.ObjectMeta // type. If that does not work and dropMalformedFields is true, it does field-by-field best-effort conversion // throwing away fields which lead to errors. @@ -38,11 +36,11 @@ func GetObjectMeta(obj map[string]interface{}, dropMalformedFields bool) (*metav // round-trip through JSON first, hoping that unmarshalling just works objectMeta := &metav1.ObjectMeta{} - metadataBytes, err := encodingjson.Marshal(metadata) + metadataBytes, err := utiljson.Marshal(metadata) if err != nil { return nil, false, err } - if err = encodingjson.Unmarshal(metadataBytes, objectMeta); err == nil { + if err = utiljson.Unmarshal(metadataBytes, objectMeta); err == nil { // if successful, return return objectMeta, true, nil } @@ -63,11 +61,11 @@ func GetObjectMeta(obj map[string]interface{}, dropMalformedFields bool) (*metav testObjectMeta := &metav1.ObjectMeta{} for k, v := range metadataMap { // serialize a single field - if singleFieldBytes, err := encodingjson.Marshal(map[string]interface{}{k: v}); err == nil { + if singleFieldBytes, err := utiljson.Marshal(map[string]interface{}{k: v}); err == nil { // do a test unmarshal - if encodingjson.Unmarshal(singleFieldBytes, testObjectMeta) == nil { + if utiljson.Unmarshal(singleFieldBytes, testObjectMeta) == nil { // if that succeeds, unmarshal for real - encodingjson.Unmarshal(singleFieldBytes, accumulatedObjectMeta) + utiljson.Unmarshal(singleFieldBytes, accumulatedObjectMeta) } } } diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/pruning/algorithm.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/pruning/algorithm.go index a1fd711c6a..b7ed87b439 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/pruning/algorithm.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/pruning/algorithm.go @@ -17,13 +17,38 @@ limitations under the License. package pruning import ( + "sort" + "strconv" + "strings" + structuralschema "k8s.io/apiextensions-apiserver/pkg/apiserver/schema" ) -// Prune removes object fields in obj which are not specified in s. It skips TypeMeta and ObjectMeta fields -// if XEmbeddedResource is set to true, or for the root if isResourceRoot=true, i.e. it does not -// prune unknown metadata fields. -func Prune(obj interface{}, s *structuralschema.Structural, isResourceRoot bool) { +// PruneOptions sets options for pruning +// unknown fields +type PruneOptions struct { + // parentPath collects the path that the pruning + // takes as it traverses the object. + // It is used to report the full path to any unknown + // fields that the pruning encounters. + // It is only populated if ReturnPruned is true. + parentPath []string + + // prunedPaths collects pruned field paths resulting from + // calls to recordPrunedKey. + // It is only populated if ReturnPruned is true. + prunedPaths []string + + // ReturnPruned defines whether we want to track the + // fields that are pruned + ReturnPruned bool +} + +// PruneWithOptions removes object fields in obj which are not specified in s. It skips TypeMeta +// and ObjectMeta fields if XEmbeddedResource is set to true, or for the root if isResourceRoot=true, +// i.e. it does not prune unknown metadata fields. +// It returns the set of fields that it prunes if opts.ReturnPruned is true +func PruneWithOptions(obj interface{}, s *structuralschema.Structural, isResourceRoot bool, opts PruneOptions) []string { if isResourceRoot { if s == nil { s = &structuralschema.Structural{} @@ -34,7 +59,15 @@ func Prune(obj interface{}, s *structuralschema.Structural, isResourceRoot bool) s = &clone } } - prune(obj, s) + prune(obj, s, &opts) + sort.Strings(opts.prunedPaths) + return opts.prunedPaths +} + +// Prune is equivalent to +// PruneWithOptions(obj, s, isResourceRoot, PruneOptions{}) +func Prune(obj interface{}, s *structuralschema.Structural, isResourceRoot bool) { + PruneWithOptions(obj, s, isResourceRoot, PruneOptions{}) } var metaFields = map[string]bool{ @@ -43,16 +76,48 @@ var metaFields = map[string]bool{ "metadata": true, } -func prune(x interface{}, s *structuralschema.Structural) { +func (p *PruneOptions) recordPrunedKey(key string) { + if !p.ReturnPruned { + return + } + l := len(p.parentPath) + p.appendKey(key) + p.prunedPaths = append(p.prunedPaths, strings.Join(p.parentPath, "")) + p.parentPath = p.parentPath[:l] +} + +func (p *PruneOptions) appendKey(key string) { + if !p.ReturnPruned { + return + } + if len(p.parentPath) > 0 { + p.parentPath = append(p.parentPath, ".") + } + p.parentPath = append(p.parentPath, key) +} + +func (p *PruneOptions) appendIndex(index int) { + if !p.ReturnPruned { + return + } + p.parentPath = append(p.parentPath, "[", strconv.Itoa(index), "]") +} + +func prune(x interface{}, s *structuralschema.Structural, opts *PruneOptions) { if s != nil && s.XPreserveUnknownFields { - skipPrune(x, s) + skipPrune(x, s, opts) return } + origPathLen := len(opts.parentPath) + defer func() { + opts.parentPath = opts.parentPath[:origPathLen] + }() switch x := x.(type) { case map[string]interface{}: if s == nil { for k := range x { + opts.recordPrunedKey(k) delete(x, k) } return @@ -63,32 +128,47 @@ func prune(x interface{}, s *structuralschema.Structural) { } prop, ok := s.Properties[k] if ok { - prune(v, &prop) + opts.appendKey(k) + prune(v, &prop, opts) + opts.parentPath = opts.parentPath[:origPathLen] } else if s.AdditionalProperties != nil { - prune(v, s.AdditionalProperties.Structural) + opts.appendKey(k) + prune(v, s.AdditionalProperties.Structural, opts) + opts.parentPath = opts.parentPath[:origPathLen] } else { + if !metaFields[k] || len(opts.parentPath) > 0 { + opts.recordPrunedKey(k) + } delete(x, k) } } case []interface{}: if s == nil { - for _, v := range x { - prune(v, nil) + for i, v := range x { + opts.appendIndex(i) + prune(v, nil, opts) + opts.parentPath = opts.parentPath[:origPathLen] } return } - for _, v := range x { - prune(v, s.Items) + for i, v := range x { + opts.appendIndex(i) + prune(v, s.Items, opts) + opts.parentPath = opts.parentPath[:origPathLen] } default: // scalars, do nothing } } -func skipPrune(x interface{}, s *structuralschema.Structural) { +func skipPrune(x interface{}, s *structuralschema.Structural, opts *PruneOptions) { if s == nil { return } + origPathLen := len(opts.parentPath) + defer func() { + opts.parentPath = opts.parentPath[:origPathLen] + }() switch x := x.(type) { case map[string]interface{}: @@ -97,14 +177,20 @@ func skipPrune(x interface{}, s *structuralschema.Structural) { continue } if prop, ok := s.Properties[k]; ok { - prune(v, &prop) + opts.appendKey(k) + prune(v, &prop, opts) + opts.parentPath = opts.parentPath[:origPathLen] } else if s.AdditionalProperties != nil { - prune(v, s.AdditionalProperties.Structural) + opts.appendKey(k) + prune(v, s.AdditionalProperties.Structural, opts) + opts.parentPath = opts.parentPath[:origPathLen] } } case []interface{}: - for _, v := range x { - skipPrune(v, s.Items) + for i, v := range x { + opts.appendIndex(i) + prune(v, s.Items, opts) + opts.parentPath = opts.parentPath[:origPathLen] } default: // scalars, do nothing diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/structural.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/structural.go index ebcffdea68..1948b7ba47 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/structural.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/structural.go @@ -17,6 +17,7 @@ limitations under the License. package schema import ( + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" "k8s.io/apimachinery/pkg/runtime" ) @@ -127,6 +128,9 @@ type Extensions struct { // Atomic maps will be entirely replaced when updated. // +optional XMapType *string + + // x-kubernetes-validations describes a list of validation rules for expression validation. + XValidations apiextensions.ValidationRules } // +k8s:deepcopy-gen=true diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/validation.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/validation.go index 73c847e891..e2966341a7 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/validation.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/validation.go @@ -145,35 +145,45 @@ func validateStructuralInvariants(s *Structural, lvl level, fldPath *field.Path) allErrs = append(allErrs, field.Invalid(fldPath.Child("properties").Key("apiVersion").Child("type"), apiVersion.Type, "must be string")) } } - if metadata, found := s.Properties["metadata"]; found && checkMetadata { - if metadata.Type != "object" { - allErrs = append(allErrs, field.Invalid(fldPath.Child("properties").Key("metadata").Child("type"), metadata.Type, "must be object")) - } + + if metadata, found := s.Properties["metadata"]; found { + allErrs = append(allErrs, validateStructuralMetadataInvariants(&metadata, checkMetadata, lvl, fldPath.Child("properties").Key("metadata"))...) + } + + if s.XEmbeddedResource && !s.XPreserveUnknownFields && len(s.Properties) == 0 { + allErrs = append(allErrs, field.Required(fldPath.Child("properties"), "must not be empty if x-kubernetes-embedded-resource is true without x-kubernetes-preserve-unknown-fields")) } - if metadata, found := s.Properties["metadata"]; found && lvl == rootLevel { + + return allErrs +} + +func validateStructuralMetadataInvariants(s *Structural, checkMetadata bool, lvl level, fldPath *field.Path) field.ErrorList { + allErrs := field.ErrorList{} + + if checkMetadata && s.Type != "object" { + allErrs = append(allErrs, field.Invalid(fldPath.Child("type"), s.Type, "must be object")) + } + + if lvl == rootLevel { // metadata is a shallow copy. We can mutate it. - _, foundName := metadata.Properties["name"] - _, foundGenerateName := metadata.Properties["generateName"] - if foundName && foundGenerateName && len(metadata.Properties) == 2 { - metadata.Properties = nil - } else if (foundName || foundGenerateName) && len(metadata.Properties) == 1 { - metadata.Properties = nil + _, foundName := s.Properties["name"] + _, foundGenerateName := s.Properties["generateName"] + if foundName && foundGenerateName && len(s.Properties) == 2 { + s.Properties = nil + } else if (foundName || foundGenerateName) && len(s.Properties) == 1 { + s.Properties = nil } - metadata.Type = "" - metadata.Default.Object = nil // this is checked in API validation (and also tested) - if metadata.ValueValidation == nil { - metadata.ValueValidation = &ValueValidation{} + s.Type = "" + s.Default.Object = nil // this is checked in API validation (and also tested) + if s.ValueValidation == nil { + s.ValueValidation = &ValueValidation{} } - if !reflect.DeepEqual(metadata, Structural{ValueValidation: &ValueValidation{}}) { + if !reflect.DeepEqual(*s, Structural{ValueValidation: &ValueValidation{}}) { // TODO: this is actually a field.Invalid error, but we cannot do JSON serialization of metadata here to get a proper message - allErrs = append(allErrs, field.Forbidden(fldPath.Child("properties").Key("metadata"), "must not specify anything other than name and generateName, but metadata is implicitly specified")) + allErrs = append(allErrs, field.Forbidden(fldPath, "must not specify anything other than name and generateName, but metadata is implicitly specified")) } } - if s.XEmbeddedResource && !s.XPreserveUnknownFields && len(s.Properties) == 0 { - allErrs = append(allErrs, field.Required(fldPath.Child("properties"), "must not be empty if x-kubernetes-embedded-resource is true without x-kubernetes-preserve-unknown-fields")) - } - return allErrs } @@ -314,6 +324,9 @@ func validateNestedValueValidation(v *NestedValueValidation, skipAnyOf, skipAllO if v.ForbiddenExtensions.XMapType != nil { allErrs = append(allErrs, field.Forbidden(fldPath.Child("x-kubernetes-map-type"), "must be undefined to be structural")) } + if len(v.ForbiddenExtensions.XValidations) > 0 { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("x-kubernetes-validations"), "must be empty to be structural")) + } // forbid reasoning about metadata because it can lead to metadata restriction we don't want if _, found := v.Properties["metadata"]; found { diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/zz_generated.deepcopy.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/zz_generated.deepcopy.go index ae67d7967c..3ce631066b 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/schema/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -20,6 +21,10 @@ limitations under the License. package schema +import ( + apiextensions "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" +) + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *Extensions) DeepCopyInto(out *Extensions) { *out = *in @@ -38,6 +43,11 @@ func (in *Extensions) DeepCopyInto(out *Extensions) { *out = new(string) **out = **in } + if in.XValidations != nil { + in, out := &in.XValidations, &out.XValidations + *out = make(apiextensions.ValidationRules, len(*in)) + copy(*out, *in) + } return } diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go index 3a29d9f757..14081c9446 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go @@ -20,13 +20,12 @@ import ( "encoding/json" "strings" + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" + "k8s.io/apimachinery/pkg/util/validation/field" openapierrors "k8s.io/kube-openapi/pkg/validation/errors" "k8s.io/kube-openapi/pkg/validation/spec" "k8s.io/kube-openapi/pkg/validation/strfmt" "k8s.io/kube-openapi/pkg/validation/validate" - - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" - "k8s.io/apimachinery/pkg/util/validation/field" ) // NewSchemaValidator creates an openapi schema validator for the given CRD validation. @@ -255,6 +254,9 @@ func ConvertJSONSchemaPropsWithPostProcess(in *apiextensions.JSONSchemaProps, ou if in.XMapType != nil { out.VendorExtensible.AddExtension("x-kubernetes-map-type", *in.XMapType) } + if len(in.XValidations) != 0 { + out.VendorExtensible.AddExtension("x-kubernetes-validations", in.XValidations) + } return nil } diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/clientset.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/clientset.go index 74aca8f569..23f75d5d17 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/clientset.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/clientset.go @@ -20,6 +20,7 @@ package clientset import ( "fmt" + "net/http" apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1" apiextensionsv1beta1 "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1" @@ -63,26 +64,45 @@ func (c *Clientset) Discovery() discovery.DiscoveryInterface { // NewForConfig creates a new Clientset for the given config. // If config's RateLimiter is not set and QPS and Burst are acceptable, // NewForConfig will generate a rate-limiter in configShallowCopy. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*Clientset, error) { configShallowCopy := *c + + // share the transport between all clients + httpClient, err := rest.HTTPClientFor(&configShallowCopy) + if err != nil { + return nil, err + } + + return NewForConfigAndClient(&configShallowCopy, httpClient) +} + +// NewForConfigAndClient creates a new Clientset for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +// If config's RateLimiter is not set and QPS and Burst are acceptable, +// NewForConfigAndClient will generate a rate-limiter in configShallowCopy. +func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset, error) { + configShallowCopy := *c if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 { if configShallowCopy.Burst <= 0 { return nil, fmt.Errorf("burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0") } configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst) } + var cs Clientset var err error - cs.apiextensionsV1beta1, err = apiextensionsv1beta1.NewForConfig(&configShallowCopy) + cs.apiextensionsV1beta1, err = apiextensionsv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.apiextensionsV1, err = apiextensionsv1.NewForConfig(&configShallowCopy) + cs.apiextensionsV1, err = apiextensionsv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy) + cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } @@ -92,12 +112,11 @@ func NewForConfig(c *rest.Config) (*Clientset, error) { // NewForConfigOrDie creates a new Clientset for the given config and // panics if there is an error in the config. func NewForConfigOrDie(c *rest.Config) *Clientset { - var cs Clientset - cs.apiextensionsV1beta1 = apiextensionsv1beta1.NewForConfigOrDie(c) - cs.apiextensionsV1 = apiextensionsv1.NewForConfigOrDie(c) - - cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) - return &cs + cs, err := NewForConfig(c) + if err != nil { + panic(err) + } + return cs } // New creates a new Clientset for the given RESTClient. diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1/apiextensions_client.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1/apiextensions_client.go index 8823cb6a93..0bdc44c408 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1/apiextensions_client.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1/apiextensions_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *ApiextensionsV1Client) CustomResourceDefinitions() CustomResourceDefini } // NewForConfig creates a new ApiextensionsV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*ApiextensionsV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new ApiextensionsV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*ApiextensionsV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1/apiextensions_client.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1/apiextensions_client.go index ff1ec4f256..657ce2ca8d 100644 --- a/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1/apiextensions_client.go +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1/apiextensions_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *ApiextensionsV1beta1Client) CustomResourceDefinitions() CustomResourceD } // NewForConfig creates a new ApiextensionsV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*ApiextensionsV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new ApiextensionsV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*ApiextensionsV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/staging/api/LICENSE b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/LICENSE similarity index 99% rename from staging/api/LICENSE rename to vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/LICENSE index 261eeb9e9f..7a4a3ea242 100644 --- a/staging/api/LICENSE +++ b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/LICENSE @@ -1,3 +1,4 @@ + Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ @@ -198,4 +199,4 @@ 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. + limitations under the License. \ No newline at end of file diff --git a/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/README.md b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/README.md new file mode 100644 index 0000000000..6b38d87153 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/README.md @@ -0,0 +1,4 @@ +This directory contains a port of https://github.com/google/cel-policy-templates-go/tree/master/policy/model modified in a few ways: + +- Uses the Structural schema types +- All template related code has been removed diff --git a/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/escaping.go b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/escaping.go new file mode 100644 index 0000000000..2f841b58bf --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/escaping.go @@ -0,0 +1,110 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package model + +import ( + "regexp" + + "k8s.io/apimachinery/pkg/util/sets" +) + +// celReservedSymbols is a list of RESERVED symbols defined in the CEL lexer. +// No identifiers are allowed to collide with these symbols. +// https://github.com/google/cel-spec/blob/master/doc/langdef.md#syntax +var celReservedSymbols = sets.NewString( + "true", "false", "null", "in", + "as", "break", "const", "continue", "else", + "for", "function", "if", "import", "let", + "loop", "package", "namespace", "return", // !! 'namespace' is used heavily in Kubernetes + "var", "void", "while", +) + +// expandMatcher matches the escape sequence, characters that are escaped, and characters that are unsupported +var expandMatcher = regexp.MustCompile(`(__|[-./]|[^a-zA-Z0-9-./_])`) + +// Escape escapes ident and returns a CEL identifier (of the form '[a-zA-Z_][a-zA-Z0-9_]*'), or returns +// false if the ident does not match the supported input format of `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*`. +// Escaping Rules: +// - '__' escapes to '__underscores__' +// - '.' escapes to '__dot__' +// - '-' escapes to '__dash__' +// - '/' escapes to '__slash__' +// - Identifiers that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: "true", "false", +// "null", "in", "as", "break", "const", "continue", "else", "for", "function", "if", "import", "let", loop", "package", +// "namespace", "return". +func Escape(ident string) (string, bool) { + if len(ident) == 0 || ('0' <= ident[0] && ident[0] <= '9') { + return "", false + } + if celReservedSymbols.Has(ident) { + return "__" + ident + "__", true + } + ok := true + ident = expandMatcher.ReplaceAllStringFunc(ident, func(s string) string { + switch s { + case "__": + return "__underscores__" + case ".": + return "__dot__" + case "-": + return "__dash__" + case "/": + return "__slash__" + default: // matched a unsupported supported + ok = false + return "" + } + }) + if !ok { + return "", false + } + return ident, true +} + +var unexpandMatcher = regexp.MustCompile(`(_{2}[^_]+_{2})`) + +// Unescape unescapes an CEL identifier containing the escape sequences described in Escape, or return false if the +// string contains invalid escape sequences. The escaped input is expected to be a valid CEL identifier, but is +// not checked. +func Unescape(escaped string) (string, bool) { + ok := true + escaped = unexpandMatcher.ReplaceAllStringFunc(escaped, func(s string) string { + contents := s[2 : len(s)-2] + switch contents { + case "underscores": + return "__" + case "dot": + return "." + case "dash": + return "-" + case "slash": + return "/" + } + if celReservedSymbols.Has(contents) { + if len(s) != len(escaped) { + ok = false + } + return contents + } + ok = false + return "" + }) + if !ok { + return "", false + } + return escaped, true +} diff --git a/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/registry.go b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/registry.go new file mode 100644 index 0000000000..a5ed729505 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/registry.go @@ -0,0 +1,80 @@ +// Copyright 2020 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package model + +import ( + "sync" + + "github.com/google/cel-go/cel" + "k8s.io/apiextensions-apiserver/pkg/apiserver/schema" +) + +// Resolver declares methods to find policy templates and related configuration objects. +type Resolver interface { + // FindType returns a DeclType instance corresponding to the given fully-qualified name, if + // present. + FindType(name string) (*DeclType, bool) +} + +// NewRegistry create a registry for keeping track of environments, schemas, templates, and more +// from a base cel.Env expression environment. +func NewRegistry(stdExprEnv *cel.Env) *Registry { + return &Registry{ + exprEnvs: map[string]*cel.Env{"": stdExprEnv}, + schemas: map[string]*schema.Structural{}, + types: map[string]*DeclType{ + BoolType.TypeName(): BoolType, + BytesType.TypeName(): BytesType, + DoubleType.TypeName(): DoubleType, + DurationType.TypeName(): DurationType, + IntType.TypeName(): IntType, + NullType.TypeName(): NullType, + StringType.TypeName(): StringType, + TimestampType.TypeName(): TimestampType, + UintType.TypeName(): UintType, + ListType.TypeName(): ListType, + MapType.TypeName(): MapType, + }, + } +} + +// Registry defines a repository of environment, schema, template, and type definitions. +// +// Registry instances are concurrency-safe. +type Registry struct { + rwMux sync.RWMutex + exprEnvs map[string]*cel.Env + schemas map[string]*schema.Structural + types map[string]*DeclType +} + +// FindType implements the Resolver interface method. +func (r *Registry) FindType(name string) (*DeclType, bool) { + r.rwMux.RLock() + defer r.rwMux.RUnlock() + typ, found := r.types[name] + if found { + return typ, true + } + return typ, found +} + +// SetType registers a DeclType descriptor by its fully qualified name. +func (r *Registry) SetType(name string, declType *DeclType) error { + r.rwMux.Lock() + defer r.rwMux.Unlock() + r.types[name] = declType + return nil +} diff --git a/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/schemas.go b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/schemas.go new file mode 100644 index 0000000000..7d8e910da0 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/schemas.go @@ -0,0 +1,161 @@ +// Copyright 2020 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package model + +import ( + "k8s.io/apiextensions-apiserver/pkg/apiserver/schema" +) + +// SchemaDeclType converts the structural schema to a CEL declaration, or returns nil if the +// the structural schema should not be exposed in CEL expressions. +// Set isResourceRoot to true for the root of a custom resource or embedded resource. +// +// Schemas with XPreserveUnknownFields not exposed unless they are objects. Array and "maps" schemas +// are not exposed if their items or additionalProperties schemas are not exposed. Object Properties are not exposed +// if their schema is not exposed. +// +// The CEL declaration for objects with XPreserveUnknownFields does not expose unknown fields. +func SchemaDeclType(s *schema.Structural, isResourceRoot bool) *DeclType { + if s == nil { + return nil + } + if s.XIntOrString { + // schemas using XIntOrString are not required to have a type. + + // intOrStringType represents the x-kubernetes-int-or-string union type in CEL expressions. + // In CEL, the type is represented as dynamic value, which can be thought of as a union type of all types. + // All type checking for XIntOrString is deferred to runtime, so all access to values of this type must + // be guarded with a type check, e.g.: + // + // To require that the string representation be a percentage: + // `type(intOrStringField) == string && intOrStringField.matches(r'(\d+(\.\d+)?%)')` + // To validate requirements on both the int and string representation: + // `type(intOrStringField) == int ? intOrStringField < 5 : double(intOrStringField.replace('%', '')) < 0.5 + // + return DynType + } + + // We ignore XPreserveUnknownFields since we don't support validation rules on + // data that we don't have schema information for. + + if isResourceRoot { + // 'apiVersion', 'kind', 'metadata.name' and 'metadata.generateName' are always accessible to validator rules + // at the root of resources, even if not specified in the schema. + // This includes the root of a custom resource and the root of XEmbeddedResource objects. + s = WithTypeAndObjectMeta(s) + } + + switch s.Type { + case "array": + if s.Items != nil { + itemsType := SchemaDeclType(s.Items, s.Items.XEmbeddedResource) + if itemsType != nil { + return NewListType(itemsType) + } + } + return nil + case "object": + if s.AdditionalProperties != nil && s.AdditionalProperties.Structural != nil { + propsType := SchemaDeclType(s.AdditionalProperties.Structural, s.AdditionalProperties.Structural.XEmbeddedResource) + if propsType != nil { + return NewMapType(StringType, propsType) + } + return nil + } + fields := make(map[string]*DeclField, len(s.Properties)) + + required := map[string]bool{} + if s.ValueValidation != nil { + for _, f := range s.ValueValidation.Required { + required[f] = true + } + } + for name, prop := range s.Properties { + var enumValues []interface{} + if prop.ValueValidation != nil { + for _, e := range prop.ValueValidation.Enum { + enumValues = append(enumValues, e.Object) + } + } + if fieldType := SchemaDeclType(&prop, prop.XEmbeddedResource); fieldType != nil { + if propName, ok := Escape(name); ok { + fields[propName] = &DeclField{ + Name: propName, + Required: required[name], + Type: fieldType, + defaultValue: prop.Default.Object, + enumValues: enumValues, // Enum values are represented as strings in CEL + } + } + } + } + return NewObjectType("object", fields) + case "string": + if s.ValueValidation != nil { + switch s.ValueValidation.Format { + case "byte": + return BytesType + case "duration": + return DurationType + case "date", "date-time": + return TimestampType + } + } + return StringType + case "boolean": + return BoolType + case "number": + return DoubleType + case "integer": + return IntType + } + return nil +} + +// WithTypeAndObjectMeta ensures the kind, apiVersion and +// metadata.name and metadata.generateName properties are specified, making a shallow copy of the provided schema if needed. +func WithTypeAndObjectMeta(s *schema.Structural) *schema.Structural { + if s.Properties != nil && + s.Properties["kind"].Type == "string" && + s.Properties["apiVersion"].Type == "string" && + s.Properties["metadata"].Type == "object" && + s.Properties["metadata"].Properties != nil && + s.Properties["metadata"].Properties["name"].Type == "string" && + s.Properties["metadata"].Properties["generateName"].Type == "string" { + return s + } + result := &schema.Structural{ + Generic: s.Generic, + Extensions: s.Extensions, + ValueValidation: s.ValueValidation, + } + props := make(map[string]schema.Structural, len(s.Properties)) + for k, prop := range s.Properties { + props[k] = prop + } + stringType := schema.Structural{Generic: schema.Generic{Type: "string"}} + props["kind"] = stringType + props["apiVersion"] = stringType + props["metadata"] = schema.Structural{ + Generic: schema.Generic{Type: "object"}, + Properties: map[string]schema.Structural{ + "name": stringType, + "generateName": stringType, + }, + } + result.Properties = props + + return result +} \ No newline at end of file diff --git a/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/types.go b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/types.go new file mode 100644 index 0000000000..0822e1d747 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/types.go @@ -0,0 +1,554 @@ +// Copyright 2020 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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. + +package model + +import ( + "fmt" + "time" + + "github.com/google/cel-go/cel" + "github.com/google/cel-go/checker/decls" + "github.com/google/cel-go/common/types" + "github.com/google/cel-go/common/types/ref" + "github.com/google/cel-go/common/types/traits" + + exprpb "google.golang.org/genproto/googleapis/api/expr/v1alpha1" + "google.golang.org/protobuf/proto" + + "k8s.io/apiextensions-apiserver/pkg/apiserver/schema" +) + +// NewListType returns a parameterized list type with a specified element type. +func NewListType(elem *DeclType) *DeclType { + return &DeclType{ + name: "list", + ElemType: elem, + exprType: decls.NewListType(elem.ExprType()), + defaultValue: NewListValue(), + } +} + +// NewMapType returns a parameterized map type with the given key and element types. +func NewMapType(key, elem *DeclType) *DeclType { + return &DeclType{ + name: "map", + KeyType: key, + ElemType: elem, + exprType: decls.NewMapType(key.ExprType(), elem.ExprType()), + defaultValue: NewMapValue(), + } +} + +// NewObjectType creates an object type with a qualified name and a set of field declarations. +func NewObjectType(name string, fields map[string]*DeclField) *DeclType { + t := &DeclType{ + name: name, + Fields: fields, + exprType: decls.NewObjectType(name), + traitMask: traits.FieldTesterType | traits.IndexerType, + } + t.defaultValue = NewObjectValue(t) + return t +} + +// NewObjectTypeRef returns a reference to an object type by name +func NewObjectTypeRef(name string) *DeclType { + t := &DeclType{ + name: name, + exprType: decls.NewObjectType(name), + traitMask: traits.FieldTesterType | traits.IndexerType, + } + return t +} + +// NewTypeParam creates a type parameter type with a simple name. +// +// Type parameters are resolved at compilation time to concrete types, or CEL 'dyn' type if no +// type assignment can be inferred. +func NewTypeParam(name string) *DeclType { + return &DeclType{ + name: name, + TypeParam: true, + exprType: decls.NewTypeParamType(name), + } +} + +func newSimpleType(name string, exprType *exprpb.Type, zeroVal ref.Val) *DeclType { + return &DeclType{ + name: name, + exprType: exprType, + defaultValue: zeroVal, + } +} + +// DeclType represents the universal type descriptor for OpenAPIv3 types. +type DeclType struct { + fmt.Stringer + + name string + Fields map[string]*DeclField + KeyType *DeclType + ElemType *DeclType + TypeParam bool + Metadata map[string]string + + exprType *exprpb.Type + traitMask int + defaultValue ref.Val +} + +// MaybeAssignTypeName attempts to set the DeclType name to a fully qualified name, if the type +// is of `object` type. +// +// The DeclType must return true for `IsObject` or this assignment will error. +func (t *DeclType) MaybeAssignTypeName(name string) *DeclType { + if t.IsObject() { + objUpdated := false + if t.name != "object" { + name = t.name + } else { + objUpdated = true + } + fieldMap := make(map[string]*DeclField, len(t.Fields)) + for fieldName, field := range t.Fields { + fieldType := field.Type + fieldTypeName := fmt.Sprintf("%s.%s", name, fieldName) + updated := fieldType.MaybeAssignTypeName(fieldTypeName) + if updated == fieldType { + fieldMap[fieldName] = field + continue + } + objUpdated = true + fieldMap[fieldName] = &DeclField{ + Name: fieldName, + Type: updated, + Required: field.Required, + enumValues: field.enumValues, + defaultValue: field.defaultValue, + } + } + if !objUpdated { + return t + } + return &DeclType{ + name: name, + Fields: fieldMap, + KeyType: t.KeyType, + ElemType: t.ElemType, + TypeParam: t.TypeParam, + Metadata: t.Metadata, + exprType: decls.NewObjectType(name), + traitMask: t.traitMask, + defaultValue: t.defaultValue, + } + } + if t.IsMap() { + elemTypeName := fmt.Sprintf("%s.@elem", name) + updated := t.ElemType.MaybeAssignTypeName(elemTypeName) + if updated == t.ElemType { + return t + } + return NewMapType(t.KeyType, updated) + } + if t.IsList() { + elemTypeName := fmt.Sprintf("%s.@idx", name) + updated := t.ElemType.MaybeAssignTypeName(elemTypeName) + if updated == t.ElemType { + return t + } + return NewListType(updated) + } + return t +} + +// ExprType returns the CEL expression type of this declaration. +func (t *DeclType) ExprType() *exprpb.Type { + return t.exprType +} + +// FindField returns the DeclField with the given name if present. +func (t *DeclType) FindField(name string) (*DeclField, bool) { + f, found := t.Fields[name] + return f, found +} + +// HasTrait implements the CEL ref.Type interface making this type declaration suitable for use +// within the CEL evaluator. +func (t *DeclType) HasTrait(trait int) bool { + if t.traitMask&trait == trait { + return true + } + if t.defaultValue == nil { + return false + } + _, isDecl := t.defaultValue.Type().(*DeclType) + if isDecl { + return false + } + return t.defaultValue.Type().HasTrait(trait) +} + +// IsList returns whether the declaration is a `list` type which defines a parameterized element +// type, but not a parameterized key type or fields. +func (t *DeclType) IsList() bool { + return t.KeyType == nil && t.ElemType != nil && t.Fields == nil +} + +// IsMap returns whether the declaration is a 'map' type which defines parameterized key and +// element types, but not fields. +func (t *DeclType) IsMap() bool { + return t.KeyType != nil && t.ElemType != nil && t.Fields == nil +} + +// IsObject returns whether the declartion is an 'object' type which defined a set of typed fields. +func (t *DeclType) IsObject() bool { + return t.KeyType == nil && t.ElemType == nil && t.Fields != nil +} + +// String implements the fmt.Stringer interface method. +func (t *DeclType) String() string { + return t.name +} + +// TypeName returns the fully qualified type name for the DeclType. +func (t *DeclType) TypeName() string { + return t.name +} + +// DefaultValue returns the CEL ref.Val representing the default value for this object type, +// if one exists. +func (t *DeclType) DefaultValue() ref.Val { + return t.defaultValue +} + +// FieldTypeMap constructs a map of the field and object types nested within a given type. +func FieldTypeMap(path string, t *DeclType) map[string]*DeclType { + if t.IsObject() && t.TypeName() != "object" { + path = t.TypeName() + } + types := make(map[string]*DeclType) + buildDeclTypes(path, t, types) + return types +} + +func buildDeclTypes(path string, t *DeclType, types map[string]*DeclType) { + // Ensure object types are properly named according to where they appear in the schema. + if t.IsObject() { + // Hack to ensure that names are uniquely qualified and work well with the type + // resolution steps which require fully qualified type names for field resolution + // to function properly. + types[t.TypeName()] = t + for name, field := range t.Fields { + fieldPath := fmt.Sprintf("%s.%s", path, name) + buildDeclTypes(fieldPath, field.Type, types) + } + } + // Map element properties to type names if needed. + if t.IsMap() { + mapElemPath := fmt.Sprintf("%s.@elem", path) + buildDeclTypes(mapElemPath, t.ElemType, types) + types[path] = t + } + // List element properties. + if t.IsList() { + listIdxPath := fmt.Sprintf("%s.@idx", path) + buildDeclTypes(listIdxPath, t.ElemType, types) + types[path] = t + } +} + +// DeclField describes the name, ordinal, and optionality of a field declaration within a type. +type DeclField struct { + Name string + Type *DeclType + Required bool + enumValues []interface{} + defaultValue interface{} +} + +// TypeName returns the string type name of the field. +func (f *DeclField) TypeName() string { + return f.Type.TypeName() +} + +// DefaultValue returns the zero value associated with the field. +func (f *DeclField) DefaultValue() ref.Val { + if f.defaultValue != nil { + return types.DefaultTypeAdapter.NativeToValue(f.defaultValue) + } + return f.Type.DefaultValue() +} + +// EnumValues returns the set of values that this field may take. +func (f *DeclField) EnumValues() []ref.Val { + if f.enumValues == nil || len(f.enumValues) == 0 { + return []ref.Val{} + } + ev := make([]ref.Val, len(f.enumValues)) + for i, e := range f.enumValues { + ev[i] = types.DefaultTypeAdapter.NativeToValue(e) + } + return ev +} + +// NewRuleTypes returns an Open API Schema-based type-system which is CEL compatible. +func NewRuleTypes(kind string, + schema *schema.Structural, + isResourceRoot bool, + res Resolver) (*RuleTypes, error) { + // Note, if the schema indicates that it's actually based on another proto + // then prefer the proto definition. For expressions in the proto, a new field + // annotation will be needed to indicate the expected environment and type of + // the expression. + schemaTypes, err := newSchemaTypeProvider(kind, schema, isResourceRoot) + if err != nil { + return nil, err + } + if schemaTypes == nil { + return nil, nil + } + return &RuleTypes{ + Schema: schema, + ruleSchemaDeclTypes: schemaTypes, + resolver: res, + }, nil +} + +// RuleTypes extends the CEL ref.TypeProvider interface and provides an Open API Schema-based +// type-system. +type RuleTypes struct { + ref.TypeProvider + Schema *schema.Structural + ruleSchemaDeclTypes *schemaTypeProvider + typeAdapter ref.TypeAdapter + resolver Resolver +} + +// EnvOptions returns a set of cel.EnvOption values which includes the declaration set +// as well as a custom ref.TypeProvider. +// +// Note, the standard declaration set includes 'rule' which is defined as the top-level rule-schema +// type if one is configured. +// +// If the RuleTypes value is nil, an empty []cel.EnvOption set is returned. +func (rt *RuleTypes) EnvOptions(tp ref.TypeProvider) ([]cel.EnvOption, error) { + if rt == nil { + return []cel.EnvOption{}, nil + } + var ta ref.TypeAdapter = types.DefaultTypeAdapter + tpa, ok := tp.(ref.TypeAdapter) + if ok { + ta = tpa + } + rtWithTypes := &RuleTypes{ + TypeProvider: tp, + typeAdapter: ta, + Schema: rt.Schema, + ruleSchemaDeclTypes: rt.ruleSchemaDeclTypes, + resolver: rt.resolver, + } + for name, declType := range rt.ruleSchemaDeclTypes.types { + tpType, found := tp.FindType(name) + if found && !proto.Equal(tpType, declType.ExprType()) { + return nil, fmt.Errorf( + "type %s definition differs between CEL environment and rule", name) + } + } + return []cel.EnvOption{ + cel.CustomTypeProvider(rtWithTypes), + cel.CustomTypeAdapter(rtWithTypes), + cel.Declarations( + decls.NewVar("rule", rt.ruleSchemaDeclTypes.root.ExprType()), + ), + }, nil +} + +// FindType attempts to resolve the typeName provided from the rule's rule-schema, or if not +// from the embedded ref.TypeProvider. +// +// FindType overrides the default type-finding behavior of the embedded TypeProvider. +// +// Note, when the type name is based on the Open API Schema, the name will reflect the object path +// where the type definition appears. +func (rt *RuleTypes) FindType(typeName string) (*exprpb.Type, bool) { + if rt == nil { + return nil, false + } + declType, found := rt.findDeclType(typeName) + if found { + return declType.ExprType(), found + } + return rt.TypeProvider.FindType(typeName) +} + +// FindDeclType returns the CPT type description which can be mapped to a CEL type. +func (rt *RuleTypes) FindDeclType(typeName string) (*DeclType, bool) { + if rt == nil { + return nil, false + } + return rt.findDeclType(typeName) +} + +// FindFieldType returns a field type given a type name and field name, if found. +// +// Note, the type name for an Open API Schema type is likely to be its qualified object path. +// If, in the future an object instance rather than a type name were provided, the field +// resolution might more accurately reflect the expected type model. However, in this case +// concessions were made to align with the existing CEL interfaces. +func (rt *RuleTypes) FindFieldType(typeName, fieldName string) (*ref.FieldType, bool) { + st, found := rt.findDeclType(typeName) + if !found { + return rt.TypeProvider.FindFieldType(typeName, fieldName) + } + + f, found := st.Fields[fieldName] + if found { + ft := f.Type + return &ref.FieldType{ + Type: ft.ExprType(), + }, true + } + // This could be a dynamic map. + if st.IsMap() { + et := st.ElemType + return &ref.FieldType{ + Type: et.ExprType(), + }, true + } + return nil, false +} + +// NativeToValue is an implementation of the ref.TypeAdapater interface which supports conversion +// of rule values to CEL ref.Val instances. +func (rt *RuleTypes) NativeToValue(val interface{}) ref.Val { + return rt.typeAdapter.NativeToValue(val) +} + +// TypeNames returns the list of type names declared within the RuleTypes object. +func (rt *RuleTypes) TypeNames() []string { + typeNames := make([]string, len(rt.ruleSchemaDeclTypes.types)) + i := 0 + for name := range rt.ruleSchemaDeclTypes.types { + typeNames[i] = name + i++ + } + return typeNames +} + +func (rt *RuleTypes) findDeclType(typeName string) (*DeclType, bool) { + declType, found := rt.ruleSchemaDeclTypes.types[typeName] + if found { + return declType, true + } + declType, found = rt.resolver.FindType(typeName) + if found { + return declType, true + } + return nil, false +} + +func (rt *RuleTypes) convertToCustomType(dyn *DynValue, declType *DeclType) *DynValue { + switch v := dyn.Value().(type) { + case *MapValue: + if declType.IsObject() { + obj := v.ConvertToObject(declType) + for name, f := range obj.fieldMap { + field := declType.Fields[name] + f.Ref = rt.convertToCustomType(f.Ref, field.Type) + } + dyn.SetValue(obj) + return dyn + } + fieldType := declType.ElemType + for _, f := range v.fieldMap { + f.Ref = rt.convertToCustomType(f.Ref, fieldType) + } + return dyn + case *ListValue: + for i := 0; i < len(v.Entries); i++ { + elem := v.Entries[i] + elem = rt.convertToCustomType(elem, declType.ElemType) + v.Entries[i] = elem + } + return dyn + default: + return dyn + } +} + +func newSchemaTypeProvider(kind string, schema *schema.Structural, isResourceRoot bool) (*schemaTypeProvider, error) { + delType := SchemaDeclType(schema, isResourceRoot) + if delType == nil { + return nil, nil + } + root := delType.MaybeAssignTypeName(kind) + types := FieldTypeMap(kind, root) + return &schemaTypeProvider{ + root: root, + types: types, + }, nil +} + +type schemaTypeProvider struct { + root *DeclType + types map[string]*DeclType +} + +var ( + // AnyType is equivalent to the CEL 'protobuf.Any' type in that the value may have any of the + // types supported. + AnyType = newSimpleType("any", decls.Any, nil) + + // BoolType is equivalent to the CEL 'bool' type. + BoolType = newSimpleType("bool", decls.Bool, types.False) + + // BytesType is equivalent to the CEL 'bytes' type. + BytesType = newSimpleType("bytes", decls.Bytes, types.Bytes([]byte{})) + + // DoubleType is equivalent to the CEL 'double' type which is a 64-bit floating point value. + DoubleType = newSimpleType("double", decls.Double, types.Double(0)) + + // DurationType is equivalent to the CEL 'duration' type. + DurationType = newSimpleType("duration", decls.Duration, types.Duration{Duration: time.Duration(0)}) + + // DateType is equivalent to the CEL 'date' type. + DateType = newSimpleType("date", decls.Timestamp, types.Timestamp{Time: time.Time{}}) + + // DynType is the equivalent of the CEL 'dyn' concept which indicates that the type will be + // determined at runtime rather than compile time. + DynType = newSimpleType("dyn", decls.Dyn, nil) + + // IntType is equivalent to the CEL 'int' type which is a 64-bit signed int. + IntType = newSimpleType("int", decls.Int, types.IntZero) + + // NullType is equivalent to the CEL 'null_type'. + NullType = newSimpleType("null_type", decls.Null, types.NullValue) + + // StringType is equivalent to the CEL 'string' type which is expected to be a UTF-8 string. + // StringType values may either be string literals or expression strings. + StringType = newSimpleType("string", decls.String, types.String("")) + + // TimestampType corresponds to the well-known protobuf.Timestamp type supported within CEL. + TimestampType = newSimpleType("timestamp", decls.Timestamp, types.Timestamp{Time: time.Time{}}) + + // UintType is equivalent to the CEL 'uint' type. + UintType = newSimpleType("uint", decls.Uint, types.Uint(0)) + + // ListType is equivalent to the CEL 'list' type. + ListType = NewListType(AnyType) + + // MapType is equivalent to the CEL 'map' type. + MapType = NewMapType(AnyType, AnyType) +) diff --git a/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/value.go b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/value.go new file mode 100644 index 0000000000..eb827893b8 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model/value.go @@ -0,0 +1,769 @@ +// Copyright 2020 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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. + +package model + +import ( + "fmt" + "reflect" + "sync" + "time" + + "github.com/google/cel-go/common/types" + "github.com/google/cel-go/common/types/ref" + "github.com/google/cel-go/common/types/traits" +) + +// EncodeStyle is a hint for string encoding of parsed values. +type EncodeStyle int + +const ( + // BlockValueStyle is the default string encoding which preserves whitespace and newlines. + BlockValueStyle EncodeStyle = iota + + // FlowValueStyle indicates that the string is an inline representation of complex types. + FlowValueStyle + + // FoldedValueStyle is a multiline string with whitespace and newlines trimmed to a single + // a whitespace. Repeated newlines are replaced with a single newline rather than a single + // whitespace. + FoldedValueStyle + + // LiteralStyle is a multiline string that preserves newlines, but trims all other whitespace + // to a single character. + LiteralStyle +) + +// NewEmptyDynValue returns the zero-valued DynValue. +func NewEmptyDynValue() *DynValue { + // note: 0 is not a valid parse node identifier. + dv, _ := NewDynValue(0, nil) + return dv +} + +// NewDynValue returns a DynValue that corresponds to a parse node id and value. +func NewDynValue(id int64, val interface{}) (*DynValue, error) { + dv := &DynValue{ID: id} + err := dv.SetValue(val) + return dv, err +} + +// DynValue is a dynamically typed value used to describe unstructured content. +// Whether the value has the desired type is determined by where it is used within the Instance or +// Template, and whether there are schemas which might enforce a more rigid type definition. +type DynValue struct { + ID int64 + EncodeStyle EncodeStyle + value interface{} + exprValue ref.Val + declType *DeclType +} + +// DeclType returns the policy model type of the dyn value. +func (dv *DynValue) DeclType() *DeclType { + return dv.declType +} + +// ConvertToNative is an implementation of the CEL ref.Val method used to adapt between CEL types +// and Go-native types. +// +// The default behavior of this method is to first convert to a CEL type which has a well-defined +// set of conversion behaviors and proxy to the CEL ConvertToNative method for the type. +func (dv *DynValue) ConvertToNative(typeDesc reflect.Type) (interface{}, error) { + ev := dv.ExprValue() + if types.IsError(ev) { + return nil, ev.(*types.Err) + } + return ev.ConvertToNative(typeDesc) +} + +// Equal returns whether the dyn value is equal to a given CEL value. +func (dv *DynValue) Equal(other ref.Val) ref.Val { + dvType := dv.Type() + otherType := other.Type() + // Preserve CEL's homogeneous equality constraint. + if dvType.TypeName() != otherType.TypeName() { + return types.MaybeNoSuchOverloadErr(other) + } + switch v := dv.value.(type) { + case ref.Val: + return v.Equal(other) + case PlainTextValue: + return celBool(string(v) == other.Value().(string)) + case *MultilineStringValue: + return celBool(v.Value == other.Value().(string)) + case time.Duration: + otherDuration := other.Value().(time.Duration) + return celBool(v == otherDuration) + case time.Time: + otherTimestamp := other.Value().(time.Time) + return celBool(v.Equal(otherTimestamp)) + default: + return celBool(reflect.DeepEqual(v, other.Value())) + } +} + +// ExprValue converts the DynValue into a CEL value. +func (dv *DynValue) ExprValue() ref.Val { + return dv.exprValue +} + +// Value returns the underlying value held by this reference. +func (dv *DynValue) Value() interface{} { + return dv.value +} + +// SetValue updates the underlying value held by this reference. +func (dv *DynValue) SetValue(value interface{}) error { + dv.value = value + var err error + dv.exprValue, dv.declType, err = exprValue(value) + return err +} + +// Type returns the CEL type for the given value. +func (dv *DynValue) Type() ref.Type { + return dv.ExprValue().Type() +} + +func exprValue(value interface{}) (ref.Val, *DeclType, error) { + switch v := value.(type) { + case bool: + return types.Bool(v), BoolType, nil + case []byte: + return types.Bytes(v), BytesType, nil + case float64: + return types.Double(v), DoubleType, nil + case int64: + return types.Int(v), IntType, nil + case string: + return types.String(v), StringType, nil + case uint64: + return types.Uint(v), UintType, nil + case time.Duration: + return types.Duration{Duration: v}, DurationType, nil + case time.Time: + return types.Timestamp{Time: v}, TimestampType, nil + case types.Null: + return v, NullType, nil + case *ListValue: + return v, ListType, nil + case *MapValue: + return v, MapType, nil + case *ObjectValue: + return v, v.objectType, nil + default: + return nil, unknownType, fmt.Errorf("unsupported type: (%T)%v", v, v) + } +} + +// PlainTextValue is a text string literal which must not be treated as an expression. +type PlainTextValue string + +// MultilineStringValue is a multiline string value which has been parsed in a way which omits +// whitespace as well as a raw form which preserves whitespace. +type MultilineStringValue struct { + Value string + Raw string +} + +func newStructValue() *structValue { + return &structValue{ + Fields: []*Field{}, + fieldMap: map[string]*Field{}, + } +} + +type structValue struct { + Fields []*Field + fieldMap map[string]*Field +} + +// AddField appends a MapField to the MapValue and indexes the field by name. +func (sv *structValue) AddField(field *Field) { + sv.Fields = append(sv.Fields, field) + sv.fieldMap[field.Name] = field +} + +// ConvertToNative converts the MapValue type to a native go types. +func (sv *structValue) ConvertToNative(typeDesc reflect.Type) (interface{}, error) { + if typeDesc.Kind() != reflect.Map && + typeDesc.Kind() != reflect.Struct && + typeDesc.Kind() != reflect.Ptr && + typeDesc.Kind() != reflect.Interface { + return nil, fmt.Errorf("type conversion error from object to '%v'", typeDesc) + } + + // Unwrap pointers, but track their use. + isPtr := false + if typeDesc.Kind() == reflect.Ptr { + tk := typeDesc + typeDesc = typeDesc.Elem() + if typeDesc.Kind() == reflect.Ptr { + return nil, fmt.Errorf("unsupported type conversion to '%v'", tk) + } + isPtr = true + } + + if typeDesc.Kind() == reflect.Map { + keyType := typeDesc.Key() + if keyType.Kind() != reflect.String && keyType.Kind() != reflect.Interface { + return nil, fmt.Errorf("object fields cannot be converted to type '%v'", keyType) + } + elemType := typeDesc.Elem() + sz := len(sv.fieldMap) + ntvMap := reflect.MakeMapWithSize(typeDesc, sz) + for name, val := range sv.fieldMap { + refVal, err := val.Ref.ConvertToNative(elemType) + if err != nil { + return nil, err + } + ntvMap.SetMapIndex(reflect.ValueOf(name), reflect.ValueOf(refVal)) + } + return ntvMap.Interface(), nil + } + + if typeDesc.Kind() == reflect.Struct { + ntvObjPtr := reflect.New(typeDesc) + ntvObj := ntvObjPtr.Elem() + for name, val := range sv.fieldMap { + f := ntvObj.FieldByName(name) + if !f.IsValid() { + return nil, fmt.Errorf("type conversion error, no such field %s in type %v", + name, typeDesc) + } + fv, err := val.Ref.ConvertToNative(f.Type()) + if err != nil { + return nil, err + } + f.Set(reflect.ValueOf(fv)) + } + if isPtr { + return ntvObjPtr.Interface(), nil + } + return ntvObj.Interface(), nil + } + return nil, fmt.Errorf("type conversion error from object to '%v'", typeDesc) +} + +// GetField returns a MapField by name if one exists. +func (sv *structValue) GetField(name string) (*Field, bool) { + field, found := sv.fieldMap[name] + return field, found +} + +// IsSet returns whether the given field, which is defined, has also been set. +func (sv *structValue) IsSet(key ref.Val) ref.Val { + k, ok := key.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(key) + } + name := string(k) + _, found := sv.fieldMap[name] + return celBool(found) +} + +// NewObjectValue creates a struct value with a schema type and returns the empty ObjectValue. +func NewObjectValue(sType *DeclType) *ObjectValue { + return &ObjectValue{ + structValue: newStructValue(), + objectType: sType, + } +} + +// ObjectValue is a struct with a custom schema type which indicates the fields and types +// associated with the structure. +type ObjectValue struct { + *structValue + objectType *DeclType +} + +// ConvertToType is an implementation of the CEL ref.Val interface method. +func (o *ObjectValue) ConvertToType(t ref.Type) ref.Val { + if t == types.TypeType { + return types.NewObjectTypeValue(o.objectType.TypeName()) + } + if t.TypeName() == o.objectType.TypeName() { + return o + } + return types.NewErr("type conversion error from '%s' to '%s'", o.Type(), t) +} + +// Equal returns true if the two object types are equal and their field values are equal. +func (o *ObjectValue) Equal(other ref.Val) ref.Val { + // Preserve CEL's homogeneous equality semantics. + if o.objectType.TypeName() != other.Type().TypeName() { + return types.MaybeNoSuchOverloadErr(other) + } + o2 := other.(traits.Indexer) + for name := range o.objectType.Fields { + k := types.String(name) + v := o.Get(k) + ov := o2.Get(k) + vEq := v.Equal(ov) + if vEq != types.True { + return vEq + } + } + return types.True +} + +// Get returns the value of the specified field. +// +// If the field is set, its value is returned. If the field is not set, the default value for the +// field is returned thus allowing for safe-traversal and preserving proto-like field traversal +// semantics for Open API Schema backed types. +func (o *ObjectValue) Get(name ref.Val) ref.Val { + n, ok := name.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(n) + } + nameStr := string(n) + field, found := o.fieldMap[nameStr] + if found { + return field.Ref.ExprValue() + } + fieldDef, found := o.objectType.Fields[nameStr] + if !found { + return types.NewErr("no such field: %s", nameStr) + } + defValue := fieldDef.DefaultValue() + if defValue != nil { + return defValue + } + return types.NewErr("no default for type: %s", fieldDef.TypeName()) +} + +// Type returns the CEL type value of the object. +func (o *ObjectValue) Type() ref.Type { + return o.objectType +} + +// Value returns the Go-native representation of the object. +func (o *ObjectValue) Value() interface{} { + return o +} + +// NewMapValue returns an empty MapValue. +func NewMapValue() *MapValue { + return &MapValue{ + structValue: newStructValue(), + } +} + +// MapValue declares an object with a set of named fields whose values are dynamically typed. +type MapValue struct { + *structValue +} + +// ConvertToObject produces an ObjectValue from the MapValue with the associated schema type. +// +// The conversion is shallow and the memory shared between the Object and Map as all references +// to the map are expected to be replaced with the Object reference. +func (m *MapValue) ConvertToObject(declType *DeclType) *ObjectValue { + return &ObjectValue{ + structValue: m.structValue, + objectType: declType, + } +} + +// Contains returns whether the given key is contained in the MapValue. +func (m *MapValue) Contains(key ref.Val) ref.Val { + v, found := m.Find(key) + if v != nil && types.IsUnknownOrError(v) { + return v + } + return celBool(found) +} + +// ConvertToType converts the MapValue to another CEL type, if possible. +func (m *MapValue) ConvertToType(t ref.Type) ref.Val { + switch t { + case types.MapType: + return m + case types.TypeType: + return types.MapType + } + return types.NewErr("type conversion error from '%s' to '%s'", m.Type(), t) +} + +// Equal returns true if the maps are of the same size, have the same keys, and the key-values +// from each map are equal. +func (m *MapValue) Equal(other ref.Val) ref.Val { + oMap, isMap := other.(traits.Mapper) + if !isMap { + return types.MaybeNoSuchOverloadErr(other) + } + if m.Size() != oMap.Size() { + return types.False + } + for name, field := range m.fieldMap { + k := types.String(name) + ov, found := oMap.Find(k) + if !found { + return types.False + } + v := field.Ref.ExprValue() + vEq := v.Equal(ov) + if vEq != types.True { + return vEq + } + } + return types.True +} + +// Find returns the value for the key in the map, if found. +func (m *MapValue) Find(name ref.Val) (ref.Val, bool) { + // Currently only maps with string keys are supported as this is best aligned with JSON, + // and also much simpler to support. + n, ok := name.(types.String) + if !ok { + return types.MaybeNoSuchOverloadErr(n), true + } + nameStr := string(n) + field, found := m.fieldMap[nameStr] + if found { + return field.Ref.ExprValue(), true + } + return nil, false +} + +// Get returns the value for the key in the map, or error if not found. +func (m *MapValue) Get(key ref.Val) ref.Val { + v, found := m.Find(key) + if found { + return v + } + return types.ValOrErr(key, "no such key: %v", key) +} + +// Iterator produces a traits.Iterator which walks over the map keys. +// +// The Iterator is frequently used within comprehensions. +func (m *MapValue) Iterator() traits.Iterator { + keys := make([]ref.Val, len(m.fieldMap)) + i := 0 + for k := range m.fieldMap { + keys[i] = types.String(k) + i++ + } + return &baseMapIterator{ + baseVal: &baseVal{}, + keys: keys, + } +} + +// Size returns the number of keys in the map. +func (m *MapValue) Size() ref.Val { + return types.Int(len(m.Fields)) +} + +// Type returns the CEL ref.Type for the map. +func (m *MapValue) Type() ref.Type { + return types.MapType +} + +// Value returns the Go-native representation of the MapValue. +func (m *MapValue) Value() interface{} { + return m +} + +type baseMapIterator struct { + *baseVal + keys []ref.Val + idx int +} + +// HasNext implements the traits.Iterator interface method. +func (it *baseMapIterator) HasNext() ref.Val { + if it.idx < len(it.keys) { + return types.True + } + return types.False +} + +// Next implements the traits.Iterator interface method. +func (it *baseMapIterator) Next() ref.Val { + key := it.keys[it.idx] + it.idx++ + return key +} + +// Type implements the CEL ref.Val interface metohd. +func (it *baseMapIterator) Type() ref.Type { + return types.IteratorType +} + +// NewField returns a MapField instance with an empty DynValue that refers to the +// specified parse node id and field name. +func NewField(id int64, name string) *Field { + return &Field{ + ID: id, + Name: name, + Ref: NewEmptyDynValue(), + } +} + +// Field specifies a field name and a reference to a dynamic value. +type Field struct { + ID int64 + Name string + Ref *DynValue +} + +// NewListValue returns an empty ListValue instance. +func NewListValue() *ListValue { + return &ListValue{ + Entries: []*DynValue{}, + } +} + +// ListValue contains a list of dynamically typed entries. +type ListValue struct { + Entries []*DynValue + initValueSet sync.Once + valueSet map[ref.Val]struct{} +} + +// Add concatenates two lists together to produce a new CEL list value. +func (lv *ListValue) Add(other ref.Val) ref.Val { + oArr, isArr := other.(traits.Lister) + if !isArr { + return types.MaybeNoSuchOverloadErr(other) + } + szRight := len(lv.Entries) + szLeft := int(oArr.Size().(types.Int)) + sz := szRight + szLeft + combo := make([]ref.Val, sz) + for i := 0; i < szRight; i++ { + combo[i] = lv.Entries[i].ExprValue() + } + for i := 0; i < szLeft; i++ { + combo[i+szRight] = oArr.Get(types.Int(i)) + } + return types.DefaultTypeAdapter.NativeToValue(combo) +} + +// Append adds another entry into the ListValue. +func (lv *ListValue) Append(entry *DynValue) { + lv.Entries = append(lv.Entries, entry) + // The append resets all previously built indices. + lv.initValueSet = sync.Once{} +} + +// Contains returns whether the input `val` is equal to an element in the list. +// +// If any pair-wise comparison between the input value and the list element is an error, the +// operation will return an error. +func (lv *ListValue) Contains(val ref.Val) ref.Val { + if types.IsUnknownOrError(val) { + return val + } + lv.initValueSet.Do(lv.finalizeValueSet) + if lv.valueSet != nil { + _, found := lv.valueSet[val] + if found { + return types.True + } + // Instead of returning false, ensure that CEL's heterogeneous equality constraint + // is satisfied by allowing pair-wise equality behavior to determine the outcome. + } + var err ref.Val + sz := len(lv.Entries) + for i := 0; i < sz; i++ { + elem := lv.Entries[i] + cmp := elem.Equal(val) + b, ok := cmp.(types.Bool) + if !ok && err == nil { + err = types.MaybeNoSuchOverloadErr(cmp) + } + if b == types.True { + return types.True + } + } + if err != nil { + return err + } + return types.False +} + +// ConvertToNative is an implementation of the CEL ref.Val method used to adapt between CEL types +// and Go-native array-like types. +func (lv *ListValue) ConvertToNative(typeDesc reflect.Type) (interface{}, error) { + // Non-list conversion. + if typeDesc.Kind() != reflect.Slice && + typeDesc.Kind() != reflect.Array && + typeDesc.Kind() != reflect.Interface { + return nil, fmt.Errorf("type conversion error from list to '%v'", typeDesc) + } + + // If the list is already assignable to the desired type return it. + if reflect.TypeOf(lv).AssignableTo(typeDesc) { + return lv, nil + } + + // List conversion. + otherElem := typeDesc.Elem() + + // Allow the element ConvertToNative() function to determine whether conversion is possible. + sz := len(lv.Entries) + nativeList := reflect.MakeSlice(typeDesc, int(sz), int(sz)) + for i := 0; i < sz; i++ { + elem := lv.Entries[i] + nativeElemVal, err := elem.ConvertToNative(otherElem) + if err != nil { + return nil, err + } + nativeList.Index(int(i)).Set(reflect.ValueOf(nativeElemVal)) + } + return nativeList.Interface(), nil +} + +// ConvertToType converts the ListValue to another CEL type. +func (lv *ListValue) ConvertToType(t ref.Type) ref.Val { + switch t { + case types.ListType: + return lv + case types.TypeType: + return types.ListType + } + return types.NewErr("type conversion error from '%s' to '%s'", ListType, t) +} + +// Equal returns true if two lists are of the same size, and the values at each index are also +// equal. +func (lv *ListValue) Equal(other ref.Val) ref.Val { + oArr, isArr := other.(traits.Lister) + if !isArr { + return types.MaybeNoSuchOverloadErr(other) + } + sz := types.Int(len(lv.Entries)) + if sz != oArr.Size() { + return types.False + } + for i := types.Int(0); i < sz; i++ { + cmp := lv.Get(i).Equal(oArr.Get(i)) + if cmp != types.True { + return cmp + } + } + return types.True +} + +// Get returns the value at the given index. +// +// If the index is negative or greater than the size of the list, an error is returned. +func (lv *ListValue) Get(idx ref.Val) ref.Val { + iv, isInt := idx.(types.Int) + if !isInt { + return types.ValOrErr(idx, "unsupported index: %v", idx) + } + i := int(iv) + if i < 0 || i >= len(lv.Entries) { + return types.NewErr("index out of bounds: %v", idx) + } + return lv.Entries[i].ExprValue() +} + +// Iterator produces a traits.Iterator suitable for use in CEL comprehension macros. +func (lv *ListValue) Iterator() traits.Iterator { + return &baseListIterator{ + getter: lv.Get, + sz: len(lv.Entries), + } +} + +// Size returns the number of elements in the list. +func (lv *ListValue) Size() ref.Val { + return types.Int(len(lv.Entries)) +} + +// Type returns the CEL ref.Type for the list. +func (lv *ListValue) Type() ref.Type { + return types.ListType +} + +// Value returns the Go-native value. +func (lv *ListValue) Value() interface{} { + return lv +} + +// finalizeValueSet inspects the ListValue entries in order to make internal optimizations once all list +// entries are known. +func (lv *ListValue) finalizeValueSet() { + valueSet := make(map[ref.Val]struct{}) + for _, e := range lv.Entries { + switch e.value.(type) { + case bool, float64, int64, string, uint64, types.Null, PlainTextValue: + if valueSet != nil { + valueSet[e.ExprValue()] = struct{}{} + } + default: + lv.valueSet = nil + return + } + } + lv.valueSet = valueSet +} + +type baseVal struct{} + +func (*baseVal) ConvertToNative(typeDesc reflect.Type) (interface{}, error) { + return nil, fmt.Errorf("unsupported native conversion to: %v", typeDesc) +} + +func (*baseVal) ConvertToType(t ref.Type) ref.Val { + return types.NewErr("unsupported type conversion to: %v", t) +} + +func (*baseVal) Equal(other ref.Val) ref.Val { + return types.NewErr("unsupported equality test between instances") +} + +func (v *baseVal) Value() interface{} { + return nil +} + +type baseListIterator struct { + *baseVal + getter func(idx ref.Val) ref.Val + sz int + idx int +} + +func (it *baseListIterator) HasNext() ref.Val { + if it.idx < it.sz { + return types.True + } + return types.False +} + +func (it *baseListIterator) Next() ref.Val { + v := it.getter(types.Int(it.idx)) + it.idx++ + return v +} + +func (it *baseListIterator) Type() ref.Type { + return types.IteratorType +} + +func celBool(pred bool) ref.Val { + if pred { + return types.True + } + return types.False +} + +var unknownType = &DeclType{name: "unknown"} diff --git a/vendor/k8s.io/apimachinery/pkg/api/errors/errors.go b/vendor/k8s.io/apimachinery/pkg/api/errors/errors.go index 31eddfc1ea..97e17be394 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/errors/errors.go +++ b/vendor/k8s.io/apimachinery/pkg/api/errors/errors.go @@ -44,6 +44,28 @@ type APIStatus interface { var _ error = &StatusError{} +var knownReasons = map[metav1.StatusReason]struct{}{ + // metav1.StatusReasonUnknown : {} + metav1.StatusReasonUnauthorized: {}, + metav1.StatusReasonForbidden: {}, + metav1.StatusReasonNotFound: {}, + metav1.StatusReasonAlreadyExists: {}, + metav1.StatusReasonConflict: {}, + metav1.StatusReasonGone: {}, + metav1.StatusReasonInvalid: {}, + metav1.StatusReasonServerTimeout: {}, + metav1.StatusReasonTimeout: {}, + metav1.StatusReasonTooManyRequests: {}, + metav1.StatusReasonBadRequest: {}, + metav1.StatusReasonMethodNotAllowed: {}, + metav1.StatusReasonNotAcceptable: {}, + metav1.StatusReasonRequestEntityTooLarge: {}, + metav1.StatusReasonUnsupportedMediaType: {}, + metav1.StatusReasonInternalError: {}, + metav1.StatusReasonExpired: {}, + metav1.StatusReasonServiceUnavailable: {}, +} + // Error implements the Error interface. func (e *StatusError) Error() string { return e.ErrStatus.Message @@ -148,6 +170,25 @@ func NewAlreadyExists(qualifiedResource schema.GroupResource, name string) *Stat }} } +// NewGenerateNameConflict returns an error indicating the server +// was not able to generate a valid name for a resource. +func NewGenerateNameConflict(qualifiedResource schema.GroupResource, name string, retryAfterSeconds int) *StatusError { + return &StatusError{metav1.Status{ + Status: metav1.StatusFailure, + Code: http.StatusConflict, + Reason: metav1.StatusReasonAlreadyExists, + Details: &metav1.StatusDetails{ + Group: qualifiedResource.Group, + Kind: qualifiedResource.Resource, + Name: name, + RetryAfterSeconds: int32(retryAfterSeconds), + }, + Message: fmt.Sprintf( + "%s %q already exists, the server was not able to generate a unique name for the object", + qualifiedResource.String(), name), + }} +} + // NewUnauthorized returns an error indicating the client is not authorized to perform the requested // action. func NewUnauthorized(reason string) *StatusError { @@ -248,7 +289,7 @@ func NewInvalid(qualifiedKind schema.GroupKind, name string, errs field.ErrorLis Field: err.Field, }) } - return &StatusError{metav1.Status{ + err := &StatusError{metav1.Status{ Status: metav1.StatusFailure, Code: http.StatusUnprocessableEntity, Reason: metav1.StatusReasonInvalid, @@ -258,8 +299,14 @@ func NewInvalid(qualifiedKind schema.GroupKind, name string, errs field.ErrorLis Name: name, Causes: causes, }, - Message: fmt.Sprintf("%s %q is invalid: %v", qualifiedKind.String(), name, errs.ToAggregate()), }} + aggregatedErrs := errs.ToAggregate() + if aggregatedErrs == nil { + err.ErrStatus.Message = fmt.Sprintf("%s %q is invalid", qualifiedKind.String(), name) + } else { + err.ErrStatus.Message = fmt.Sprintf("%s %q is invalid: %v", qualifiedKind.String(), name, aggregatedErrs) + } + return err } // NewBadRequest creates an error that indicates that the request is invalid and can not be processed. @@ -478,7 +525,14 @@ func NewGenericServerResponse(code int, verb string, qualifiedResource schema.Gr // IsNotFound returns true if the specified error was created by NewNotFound. // It supports wrapped errors. func IsNotFound(err error) bool { - return ReasonForError(err) == metav1.StatusReasonNotFound + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonNotFound { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusNotFound { + return true + } + return false } // IsAlreadyExists determines if the err is an error which indicates that a specified resource already exists. @@ -490,19 +544,40 @@ func IsAlreadyExists(err error) bool { // IsConflict determines if the err is an error which indicates the provided update conflicts. // It supports wrapped errors. func IsConflict(err error) bool { - return ReasonForError(err) == metav1.StatusReasonConflict + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonConflict { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusConflict { + return true + } + return false } // IsInvalid determines if the err is an error which indicates the provided resource is not valid. // It supports wrapped errors. func IsInvalid(err error) bool { - return ReasonForError(err) == metav1.StatusReasonInvalid + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonInvalid { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusUnprocessableEntity { + return true + } + return false } // IsGone is true if the error indicates the requested resource is no longer available. // It supports wrapped errors. func IsGone(err error) bool { - return ReasonForError(err) == metav1.StatusReasonGone + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonGone { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusGone { + return true + } + return false } // IsResourceExpired is true if the error indicates the resource has expired and the current action is @@ -515,77 +590,147 @@ func IsResourceExpired(err error) bool { // IsNotAcceptable determines if err is an error which indicates that the request failed due to an invalid Accept header // It supports wrapped errors. func IsNotAcceptable(err error) bool { - return ReasonForError(err) == metav1.StatusReasonNotAcceptable + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonNotAcceptable { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusNotAcceptable { + return true + } + return false } // IsUnsupportedMediaType determines if err is an error which indicates that the request failed due to an invalid Content-Type header // It supports wrapped errors. func IsUnsupportedMediaType(err error) bool { - return ReasonForError(err) == metav1.StatusReasonUnsupportedMediaType + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonUnsupportedMediaType { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusUnsupportedMediaType { + return true + } + return false } // IsMethodNotSupported determines if the err is an error which indicates the provided action could not // be performed because it is not supported by the server. // It supports wrapped errors. func IsMethodNotSupported(err error) bool { - return ReasonForError(err) == metav1.StatusReasonMethodNotAllowed + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonMethodNotAllowed { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusMethodNotAllowed { + return true + } + return false } // IsServiceUnavailable is true if the error indicates the underlying service is no longer available. // It supports wrapped errors. func IsServiceUnavailable(err error) bool { - return ReasonForError(err) == metav1.StatusReasonServiceUnavailable + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonServiceUnavailable { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusServiceUnavailable { + return true + } + return false } // IsBadRequest determines if err is an error which indicates that the request is invalid. // It supports wrapped errors. func IsBadRequest(err error) bool { - return ReasonForError(err) == metav1.StatusReasonBadRequest + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonBadRequest { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusBadRequest { + return true + } + return false } // IsUnauthorized determines if err is an error which indicates that the request is unauthorized and // requires authentication by the user. // It supports wrapped errors. func IsUnauthorized(err error) bool { - return ReasonForError(err) == metav1.StatusReasonUnauthorized + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonUnauthorized { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusUnauthorized { + return true + } + return false } // IsForbidden determines if err is an error which indicates that the request is forbidden and cannot // be completed as requested. // It supports wrapped errors. func IsForbidden(err error) bool { - return ReasonForError(err) == metav1.StatusReasonForbidden + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonForbidden { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusForbidden { + return true + } + return false } // IsTimeout determines if err is an error which indicates that request times out due to long // processing. // It supports wrapped errors. func IsTimeout(err error) bool { - return ReasonForError(err) == metav1.StatusReasonTimeout + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonTimeout { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusGatewayTimeout { + return true + } + return false } // IsServerTimeout determines if err is an error which indicates that the request needs to be retried // by the client. // It supports wrapped errors. func IsServerTimeout(err error) bool { + // do not check the status code, because no https status code exists that can + // be scoped to retryable timeouts. return ReasonForError(err) == metav1.StatusReasonServerTimeout } // IsInternalError determines if err is an error which indicates an internal server error. // It supports wrapped errors. func IsInternalError(err error) bool { - return ReasonForError(err) == metav1.StatusReasonInternalError + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonInternalError { + return true + } + if _, ok := knownReasons[reason]; !ok && code == http.StatusInternalServerError { + return true + } + return false } // IsTooManyRequests determines if err is an error which indicates that there are too many requests // that the server cannot handle. // It supports wrapped errors. func IsTooManyRequests(err error) bool { - if ReasonForError(err) == metav1.StatusReasonTooManyRequests { + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonTooManyRequests { return true } - if status := APIStatus(nil); errors.As(err, &status) { - return status.Status().Code == http.StatusTooManyRequests + + // IsTooManyRequests' checking of code predates the checking of the code in + // the other Is* functions. In order to maintain backward compatibility, this + // does not check that the reason is unknown. + if code == http.StatusTooManyRequests { + return true } return false } @@ -594,11 +739,16 @@ func IsTooManyRequests(err error) bool { // the request entity is too large. // It supports wrapped errors. func IsRequestEntityTooLargeError(err error) bool { - if ReasonForError(err) == metav1.StatusReasonRequestEntityTooLarge { + reason, code := reasonAndCodeForError(err) + if reason == metav1.StatusReasonRequestEntityTooLarge { return true } - if status := APIStatus(nil); errors.As(err, &status) { - return status.Status().Code == http.StatusRequestEntityTooLarge + + // IsRequestEntityTooLargeError's checking of code predates the checking of + // the code in the other Is* functions. In order to maintain backward + // compatibility, this does not check that the reason is unknown. + if code == http.StatusRequestEntityTooLarge { + return true } return false } @@ -653,6 +803,13 @@ func ReasonForError(err error) metav1.StatusReason { return metav1.StatusReasonUnknown } +func reasonAndCodeForError(err error) (metav1.StatusReason, int32) { + if status := APIStatus(nil); errors.As(err, &status) { + return status.Status().Reason, status.Status().Code + } + return metav1.StatusReasonUnknown, 0 +} + // ErrorReporter converts generic errors into runtime.Object errors without // requiring the caller to take a dependency on meta/v1 (where Status lives). // This prevents circular dependencies in core watch code. diff --git a/vendor/k8s.io/apimachinery/pkg/api/meta/firsthit_restmapper.go b/vendor/k8s.io/apimachinery/pkg/api/meta/firsthit_restmapper.go index fd22100229..1bc816fe3f 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/meta/firsthit_restmapper.go +++ b/vendor/k8s.io/apimachinery/pkg/api/meta/firsthit_restmapper.go @@ -23,6 +23,10 @@ import ( utilerrors "k8s.io/apimachinery/pkg/util/errors" ) +var ( + _ ResettableRESTMapper = &FirstHitRESTMapper{} +) + // FirstHitRESTMapper is a wrapper for multiple RESTMappers which returns the // first successful result for the singular requests type FirstHitRESTMapper struct { @@ -75,6 +79,10 @@ func (m FirstHitRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) return nil, collapseAggregateErrors(errors) } +func (m FirstHitRESTMapper) Reset() { + m.MultiRESTMapper.Reset() +} + // collapseAggregateErrors returns the minimal errors. it handles empty as nil, handles one item in a list // by returning the item, and collapses all NoMatchErrors to a single one (since they should all be the same) func collapseAggregateErrors(errors []error) error { diff --git a/vendor/k8s.io/apimachinery/pkg/api/meta/interfaces.go b/vendor/k8s.io/apimachinery/pkg/api/meta/interfaces.go index 42eac3af00..a35ce3bd0a 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/meta/interfaces.go +++ b/vendor/k8s.io/apimachinery/pkg/api/meta/interfaces.go @@ -132,3 +132,12 @@ type RESTMapper interface { ResourceSingularizer(resource string) (singular string, err error) } + +// ResettableRESTMapper is a RESTMapper which is capable of resetting itself +// from discovery. +// All rest mappers that delegate to other rest mappers must implement this interface and dynamically +// check if the delegate mapper supports the Reset() operation. +type ResettableRESTMapper interface { + RESTMapper + Reset() +} diff --git a/vendor/k8s.io/apimachinery/pkg/api/meta/lazy.go b/vendor/k8s.io/apimachinery/pkg/api/meta/lazy.go index 431a0a6353..a4298114b6 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/meta/lazy.go +++ b/vendor/k8s.io/apimachinery/pkg/api/meta/lazy.go @@ -32,7 +32,7 @@ type lazyObject struct { mapper RESTMapper } -// NewLazyObjectLoader handles unrecoverable errors when creating a RESTMapper / ObjectTyper by +// NewLazyRESTMapperLoader handles unrecoverable errors when creating a RESTMapper / ObjectTyper by // returning those initialization errors when the interface methods are invoked. This defers the // initialization and any server calls until a client actually needs to perform the action. func NewLazyRESTMapperLoader(fn func() (RESTMapper, error)) RESTMapper { @@ -52,7 +52,7 @@ func (o *lazyObject) init() error { return o.err } -var _ RESTMapper = &lazyObject{} +var _ ResettableRESTMapper = &lazyObject{} func (o *lazyObject) KindFor(resource schema.GroupVersionResource) (schema.GroupVersionKind, error) { if err := o.init(); err != nil { @@ -102,3 +102,11 @@ func (o *lazyObject) ResourceSingularizer(resource string) (singular string, err } return o.mapper.ResourceSingularizer(resource) } + +func (o *lazyObject) Reset() { + o.lock.Lock() + defer o.lock.Unlock() + if o.loaded && o.err == nil { + MaybeResetRESTMapper(o.mapper) + } +} diff --git a/vendor/k8s.io/apimachinery/pkg/api/meta/multirestmapper.go b/vendor/k8s.io/apimachinery/pkg/api/meta/multirestmapper.go index 6b01bf197f..b7e9712505 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/meta/multirestmapper.go +++ b/vendor/k8s.io/apimachinery/pkg/api/meta/multirestmapper.go @@ -24,11 +24,15 @@ import ( utilerrors "k8s.io/apimachinery/pkg/util/errors" ) +var ( + _ ResettableRESTMapper = MultiRESTMapper{} +) + // MultiRESTMapper is a wrapper for multiple RESTMappers. type MultiRESTMapper []RESTMapper func (m MultiRESTMapper) String() string { - nested := []string{} + nested := make([]string, 0, len(m)) for _, t := range m { currString := fmt.Sprintf("%v", t) splitStrings := strings.Split(currString, "\n") @@ -208,3 +212,9 @@ func (m MultiRESTMapper) RESTMappings(gk schema.GroupKind, versions ...string) ( } return allMappings, nil } + +func (m MultiRESTMapper) Reset() { + for _, t := range m { + MaybeResetRESTMapper(t) + } +} diff --git a/vendor/k8s.io/apimachinery/pkg/api/meta/priority.go b/vendor/k8s.io/apimachinery/pkg/api/meta/priority.go index fa11c580f7..4f097c9c90 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/meta/priority.go +++ b/vendor/k8s.io/apimachinery/pkg/api/meta/priority.go @@ -29,6 +29,10 @@ const ( AnyKind = "*" ) +var ( + _ ResettableRESTMapper = PriorityRESTMapper{} +) + // PriorityRESTMapper is a wrapper for automatically choosing a particular Resource or Kind // when multiple matches are possible type PriorityRESTMapper struct { @@ -220,3 +224,7 @@ func (m PriorityRESTMapper) ResourcesFor(partiallySpecifiedResource schema.Group func (m PriorityRESTMapper) KindsFor(partiallySpecifiedResource schema.GroupVersionResource) (gvk []schema.GroupVersionKind, err error) { return m.Delegate.KindsFor(partiallySpecifiedResource) } + +func (m PriorityRESTMapper) Reset() { + MaybeResetRESTMapper(m.Delegate) +} diff --git a/vendor/k8s.io/apimachinery/pkg/api/meta/restmapper.go b/vendor/k8s.io/apimachinery/pkg/api/meta/restmapper.go index 00bd86f51a..f41b9bf78c 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/meta/restmapper.go +++ b/vendor/k8s.io/apimachinery/pkg/api/meta/restmapper.go @@ -519,3 +519,12 @@ func (m *DefaultRESTMapper) RESTMappings(gk schema.GroupKind, versions ...string } return mappings, nil } + +// MaybeResetRESTMapper calls Reset() on the mapper if it is a ResettableRESTMapper. +func MaybeResetRESTMapper(mapper RESTMapper) bool { + m, ok := mapper.(ResettableRESTMapper) + if ok { + m.Reset() + } + return ok +} diff --git a/vendor/k8s.io/apimachinery/pkg/api/resource/generated.pb.go b/vendor/k8s.io/apimachinery/pkg/api/resource/generated.pb.go index 2e09f4face..172db57fac 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/resource/generated.pb.go +++ b/vendor/k8s.io/apimachinery/pkg/api/resource/generated.pb.go @@ -61,8 +61,32 @@ func (m *Quantity) XXX_DiscardUnknown() { var xxx_messageInfo_Quantity proto.InternalMessageInfo +func (m *QuantityValue) Reset() { *m = QuantityValue{} } +func (*QuantityValue) ProtoMessage() {} +func (*QuantityValue) Descriptor() ([]byte, []int) { + return fileDescriptor_612bba87bd70906c, []int{1} +} +func (m *QuantityValue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QuantityValue.Unmarshal(m, b) +} +func (m *QuantityValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QuantityValue.Marshal(b, m, deterministic) +} +func (m *QuantityValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_QuantityValue.Merge(m, src) +} +func (m *QuantityValue) XXX_Size() int { + return xxx_messageInfo_QuantityValue.Size(m) +} +func (m *QuantityValue) XXX_DiscardUnknown() { + xxx_messageInfo_QuantityValue.DiscardUnknown(m) +} + +var xxx_messageInfo_QuantityValue proto.InternalMessageInfo + func init() { proto.RegisterType((*Quantity)(nil), "k8s.io.apimachinery.pkg.api.resource.Quantity") + proto.RegisterType((*QuantityValue)(nil), "k8s.io.apimachinery.pkg.api.resource.QuantityValue") } func init() { @@ -70,20 +94,21 @@ func init() { } var fileDescriptor_612bba87bd70906c = []byte{ - // 237 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x8e, 0xb1, 0x4e, 0xc3, 0x30, - 0x10, 0x40, 0xcf, 0x0b, 0x2a, 0x19, 0x2b, 0x84, 0x10, 0xc3, 0xa5, 0x42, 0x0c, 0x2c, 0xd8, 0x6b, - 0xc5, 0xc8, 0xce, 0x00, 0x23, 0x5b, 0x92, 0x1e, 0xae, 0x15, 0xd5, 0x8e, 0x2e, 0x36, 0x52, 0xb7, - 0x8e, 0x8c, 0x1d, 0x19, 0x9b, 0xbf, 0xe9, 0xd8, 0xb1, 0x03, 0x03, 0x31, 0x3f, 0x82, 0xea, 0x36, - 0x52, 0xb7, 0x7b, 0xef, 0xf4, 0x4e, 0x97, 0xbd, 0xd4, 0xd3, 0x56, 0x1a, 0xa7, 0xea, 0x50, 0x12, - 0x5b, 0xf2, 0xd4, 0xaa, 0x4f, 0xb2, 0x33, 0xc7, 0xea, 0xb4, 0x28, 0x1a, 0xb3, 0x28, 0xaa, 0xb9, - 0xb1, 0xc4, 0x4b, 0xd5, 0xd4, 0xfa, 0x20, 0x14, 0x53, 0xeb, 0x02, 0x57, 0xa4, 0x34, 0x59, 0xe2, - 0xc2, 0xd3, 0x4c, 0x36, 0xec, 0xbc, 0x1b, 0xdf, 0x1f, 0x2b, 0x79, 0x5e, 0xc9, 0xa6, 0xd6, 0x07, - 0x21, 0x87, 0xea, 0xf6, 0x51, 0x1b, 0x3f, 0x0f, 0xa5, 0xac, 0xdc, 0x42, 0x69, 0xa7, 0x9d, 0x4a, - 0x71, 0x19, 0x3e, 0x12, 0x25, 0x48, 0xd3, 0xf1, 0xe8, 0xdd, 0x34, 0x1b, 0xbd, 0x86, 0xc2, 0x7a, - 0xe3, 0x97, 0xe3, 0xeb, 0xec, 0xa2, 0xf5, 0x6c, 0xac, 0xbe, 0x11, 0x13, 0xf1, 0x70, 0xf9, 0x76, - 0xa2, 0xa7, 0xab, 0xef, 0x4d, 0x0e, 0x5f, 0x5d, 0x0e, 0xeb, 0x2e, 0x87, 0x4d, 0x97, 0xc3, 0xea, - 0x67, 0x02, 0xcf, 0x72, 0xdb, 0x23, 0xec, 0x7a, 0x84, 0x7d, 0x8f, 0xb0, 0x8a, 0x28, 0xb6, 0x11, - 0xc5, 0x2e, 0xa2, 0xd8, 0x47, 0x14, 0xbf, 0x11, 0xc5, 0xfa, 0x0f, 0xe1, 0x7d, 0x34, 0x3c, 0xf6, - 0x1f, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x08, 0x88, 0x49, 0x0e, 0x01, 0x00, 0x00, + // 254 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xf2, 0xcd, 0xb6, 0x28, 0xd6, + 0xcb, 0xcc, 0xd7, 0xcf, 0x2e, 0x4d, 0x4a, 0x2d, 0xca, 0x4b, 0x2d, 0x49, 0x2d, 0xd6, 0x2f, 0x4b, + 0xcd, 0x4b, 0xc9, 0x2f, 0xd2, 0x87, 0x4a, 0x24, 0x16, 0x64, 0xe6, 0x26, 0x26, 0x67, 0x64, 0xe6, + 0xa5, 0x16, 0x55, 0xea, 0x17, 0x64, 0xa7, 0x83, 0x04, 0xf4, 0x8b, 0x52, 0x8b, 0xf3, 0x4b, 0x8b, + 0x92, 0x53, 0xf5, 0xd3, 0x53, 0xf3, 0x52, 0x8b, 0x12, 0x4b, 0x52, 0x53, 0xf4, 0x0a, 0x8a, 0xf2, + 0x4b, 0xf2, 0x85, 0x54, 0x20, 0xba, 0xf4, 0x90, 0x75, 0xe9, 0x15, 0x64, 0xa7, 0x83, 0x04, 0xf4, + 0x60, 0xba, 0xa4, 0x74, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xd3, + 0xf3, 0xd3, 0xf3, 0xf5, 0xc1, 0x9a, 0x93, 0x4a, 0xd3, 0xc0, 0x3c, 0x30, 0x07, 0xcc, 0x82, 0x18, + 0xaa, 0x64, 0xc1, 0xc5, 0x11, 0x58, 0x9a, 0x98, 0x57, 0x92, 0x59, 0x52, 0x29, 0x24, 0xc6, 0xc5, + 0x56, 0x5c, 0x52, 0x94, 0x99, 0x97, 0x2e, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0x04, 0xe5, 0x59, + 0x89, 0xcc, 0x58, 0x20, 0xcf, 0xd0, 0xb1, 0x50, 0x9e, 0x61, 0xc2, 0x42, 0x79, 0x86, 0x05, 0x0b, + 0xe5, 0x19, 0x1a, 0xee, 0x28, 0x30, 0x28, 0xd9, 0x72, 0xf1, 0xc2, 0x74, 0x86, 0x25, 0xe6, 0x94, + 0xa6, 0x92, 0xa6, 0xdd, 0x49, 0xef, 0xc4, 0x43, 0x39, 0x86, 0x0b, 0x0f, 0xe5, 0x18, 0x6e, 0x3c, + 0x94, 0x63, 0x68, 0x78, 0x24, 0xc7, 0x78, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x37, + 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0x43, 0x14, 0x07, 0xcc, 0x5f, + 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x21, 0x76, 0x9f, 0x66, 0x4d, 0x01, 0x00, 0x00, } diff --git a/vendor/k8s.io/apimachinery/pkg/api/resource/generated.proto b/vendor/k8s.io/apimachinery/pkg/api/resource/generated.proto index 472104d542..54240b7b5f 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/resource/generated.proto +++ b/vendor/k8s.io/apimachinery/pkg/api/resource/generated.proto @@ -86,3 +86,15 @@ message Quantity { optional string string = 1; } +// QuantityValue makes it possible to use a Quantity as value for a command +// line parameter. +// +// +protobuf=true +// +protobuf.embed=string +// +protobuf.options.marshal=false +// +protobuf.options.(gogoproto.goproto_stringer)=false +// +k8s:deepcopy-gen=true +message QuantityValue { + optional string string = 1; +} + diff --git a/vendor/k8s.io/apimachinery/pkg/api/resource/quantity.go b/vendor/k8s.io/apimachinery/pkg/api/resource/quantity.go index 2395656cc9..6d43868ba8 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/resource/quantity.go +++ b/vendor/k8s.io/apimachinery/pkg/api/resource/quantity.go @@ -460,17 +460,7 @@ func (q *Quantity) AsApproximateFloat64() float64 { return base } - // multiply by the appropriate exponential scale - switch q.Format { - case DecimalExponent, DecimalSI: - return base * math.Pow10(exponent) - default: - // fast path for exponents that can fit in 64 bits - if exponent > 0 && exponent < 7 { - return base * float64(int64(1)<<(exponent*10)) - } - return base * math.Pow(2, float64(exponent*10)) - } + return base * math.Pow10(exponent) } // AsInt64 returns a representation of the current value as an int64 if a fast conversion @@ -774,3 +764,30 @@ func (q *Quantity) SetScaled(value int64, scale Scale) { q.d.Dec = nil q.i = int64Amount{value: value, scale: scale} } + +// QuantityValue makes it possible to use a Quantity as value for a command +// line parameter. +// +// +protobuf=true +// +protobuf.embed=string +// +protobuf.options.marshal=false +// +protobuf.options.(gogoproto.goproto_stringer)=false +// +k8s:deepcopy-gen=true +type QuantityValue struct { + Quantity +} + +// Set implements pflag.Value.Set and Go flag.Value.Set. +func (q *QuantityValue) Set(s string) error { + quantity, err := ParseQuantity(s) + if err != nil { + return err + } + q.Quantity = quantity + return nil +} + +// Type implements pflag.Value.Type. +func (q QuantityValue) Type() string { + return "quantity" +} diff --git a/vendor/k8s.io/apimachinery/pkg/api/resource/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/api/resource/zz_generated.deepcopy.go index ab47407900..abb00f38e2 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/resource/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apimachinery/pkg/api/resource/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -25,3 +26,20 @@ func (in *Quantity) DeepCopyInto(out *Quantity) { *out = in.DeepCopy() return } + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *QuantityValue) DeepCopyInto(out *QuantityValue) { + *out = *in + out.Quantity = in.Quantity.DeepCopy() + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QuantityValue. +func (in *QuantityValue) DeepCopy() *QuantityValue { + if in == nil { + return nil + } + out := new(QuantityValue) + in.DeepCopyInto(out) + return out +} diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion/zz_generated.conversion.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion/zz_generated.conversion.go index a9b28f2442..6d212b846a 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion/zz_generated.conversion.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion/zz_generated.deepcopy.go index d5e4fc680d..6e1eac5c75 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go index 326f68812d..9e7924c12f 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go @@ -1326,184 +1326,186 @@ func init() { } var fileDescriptor_cf52fa777ced5367 = []byte{ - // 2829 bytes of a gzipped FileDescriptorProto + // 2859 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x3a, 0xcb, 0x6f, 0x24, 0x47, 0xf9, 0xee, 0x19, 0x8f, 0x3d, 0xf3, 0x8d, 0xc7, 0x8f, 0x5a, 0xef, 0xef, 0x37, 0x6b, 0x84, 0xc7, 0xe9, 0xa0, 0x68, 0x03, 0xc9, 0x38, 0x5e, 0x42, 0xb4, 0xd9, 0x90, 0x80, 0xc7, 0xb3, 0xde, 0x98, 0xac, 0x63, 0xab, 0xbc, 0xbb, 0x40, 0x88, 0x50, 0xda, 0xdd, 0xe5, 0x71, 0xe3, 0x9e, 0xee, 0x49, - 0x55, 0x8f, 0x37, 0x03, 0x07, 0x72, 0x00, 0x01, 0x12, 0x44, 0xe1, 0xc6, 0x09, 0x25, 0x82, 0xbf, - 0x80, 0x0b, 0xfc, 0x01, 0x48, 0xe4, 0x18, 0xc4, 0x25, 0x12, 0x68, 0x94, 0x98, 0x03, 0x47, 0xc4, - 0xd5, 0x17, 0x50, 0x3d, 0xba, 0xbb, 0x7a, 0x1e, 0xeb, 0x9e, 0xec, 0x12, 0x71, 0x9b, 0xfe, 0xde, - 0x55, 0xf5, 0xd5, 0xf7, 0xaa, 0x81, 0xdd, 0x93, 0xeb, 0xac, 0xee, 0x06, 0xeb, 0x27, 0xdd, 0x43, - 0x42, 0x7d, 0x12, 0x12, 0xb6, 0x7e, 0x4a, 0x7c, 0x27, 0xa0, 0xeb, 0x0a, 0x61, 0x75, 0xdc, 0xb6, - 0x65, 0x1f, 0xbb, 0x3e, 0xa1, 0xbd, 0xf5, 0xce, 0x49, 0x8b, 0x03, 0xd8, 0x7a, 0x9b, 0x84, 0xd6, - 0xfa, 0xe9, 0xc6, 0x7a, 0x8b, 0xf8, 0x84, 0x5a, 0x21, 0x71, 0xea, 0x1d, 0x1a, 0x84, 0x01, 0xfa, - 0x82, 0xe4, 0xaa, 0xeb, 0x5c, 0xf5, 0xce, 0x49, 0x8b, 0x03, 0x58, 0x9d, 0x73, 0xd5, 0x4f, 0x37, - 0x56, 0x9e, 0x6e, 0xb9, 0xe1, 0x71, 0xf7, 0xb0, 0x6e, 0x07, 0xed, 0xf5, 0x56, 0xd0, 0x0a, 0xd6, - 0x05, 0xf3, 0x61, 0xf7, 0x48, 0x7c, 0x89, 0x0f, 0xf1, 0x4b, 0x0a, 0x5d, 0x19, 0x6b, 0x0a, 0xed, - 0xfa, 0xa1, 0xdb, 0x26, 0x83, 0x56, 0xac, 0x3c, 0x77, 0x11, 0x03, 0xb3, 0x8f, 0x49, 0xdb, 0x1a, - 0xe4, 0x33, 0xff, 0x94, 0x87, 0xe2, 0xe6, 0xfe, 0xce, 0x2d, 0x1a, 0x74, 0x3b, 0x68, 0x0d, 0xa6, - 0x7d, 0xab, 0x4d, 0xaa, 0xc6, 0x9a, 0x71, 0xb5, 0xd4, 0x98, 0xfb, 0xa0, 0x5f, 0x9b, 0x3a, 0xeb, - 0xd7, 0xa6, 0x5f, 0xb5, 0xda, 0x04, 0x0b, 0x0c, 0xf2, 0xa0, 0x78, 0x4a, 0x28, 0x73, 0x03, 0x9f, - 0x55, 0x73, 0x6b, 0xf9, 0xab, 0xe5, 0x6b, 0x2f, 0xd5, 0xb3, 0xac, 0xbf, 0x2e, 0x14, 0xdc, 0x93, - 0xac, 0xdb, 0x01, 0x6d, 0xba, 0xcc, 0x0e, 0x4e, 0x09, 0xed, 0x35, 0x16, 0x95, 0x96, 0xa2, 0x42, - 0x32, 0x1c, 0x6b, 0x40, 0x3f, 0x32, 0x60, 0xb1, 0x43, 0xc9, 0x11, 0xa1, 0x94, 0x38, 0x0a, 0x5f, - 0xcd, 0xaf, 0x19, 0x8f, 0x40, 0x6d, 0x55, 0xa9, 0x5d, 0xdc, 0x1f, 0x90, 0x8f, 0x87, 0x34, 0xa2, - 0xdf, 0x18, 0xb0, 0xc2, 0x08, 0x3d, 0x25, 0x74, 0xd3, 0x71, 0x28, 0x61, 0xac, 0xd1, 0xdb, 0xf2, - 0x5c, 0xe2, 0x87, 0x5b, 0x3b, 0x4d, 0xcc, 0xaa, 0xd3, 0x62, 0x1f, 0xbe, 0x96, 0xcd, 0xa0, 0x83, - 0x71, 0x72, 0x1a, 0xa6, 0xb2, 0x68, 0x65, 0x2c, 0x09, 0xc3, 0x0f, 0x30, 0xc3, 0x3c, 0x82, 0xb9, - 0xe8, 0x20, 0x6f, 0xbb, 0x2c, 0x44, 0xf7, 0x60, 0xa6, 0xc5, 0x3f, 0x58, 0xd5, 0x10, 0x06, 0xd6, - 0xb3, 0x19, 0x18, 0xc9, 0x68, 0xcc, 0x2b, 0x7b, 0x66, 0xc4, 0x27, 0xc3, 0x4a, 0x9a, 0xf9, 0xb3, - 0x69, 0x28, 0x6f, 0xee, 0xef, 0x60, 0xc2, 0x82, 0x2e, 0xb5, 0x49, 0x06, 0xa7, 0xb9, 0x0e, 0x73, - 0xcc, 0xf5, 0x5b, 0x5d, 0xcf, 0xa2, 0x1c, 0x5a, 0x9d, 0x11, 0x94, 0xcb, 0x8a, 0x72, 0xee, 0x40, - 0xc3, 0xe1, 0x14, 0x25, 0xba, 0x06, 0xc0, 0x25, 0xb0, 0x8e, 0x65, 0x13, 0xa7, 0x9a, 0x5b, 0x33, - 0xae, 0x16, 0x1b, 0x48, 0xf1, 0xc1, 0xab, 0x31, 0x06, 0x6b, 0x54, 0xe8, 0x71, 0x28, 0x08, 0x4b, - 0xab, 0x45, 0xa1, 0xa6, 0xa2, 0xc8, 0x0b, 0x62, 0x19, 0x58, 0xe2, 0xd0, 0x93, 0x30, 0xab, 0xbc, - 0xac, 0x5a, 0x12, 0x64, 0x0b, 0x8a, 0x6c, 0x36, 0x72, 0x83, 0x08, 0xcf, 0xd7, 0x77, 0xe2, 0xfa, - 0x8e, 0xf0, 0x3b, 0x6d, 0x7d, 0xaf, 0xb8, 0xbe, 0x83, 0x05, 0x06, 0xdd, 0x86, 0xc2, 0x29, 0xa1, - 0x87, 0xdc, 0x13, 0xb8, 0x6b, 0x7e, 0x29, 0xdb, 0x46, 0xdf, 0xe3, 0x2c, 0x8d, 0x12, 0x37, 0x4d, - 0xfc, 0xc4, 0x52, 0x08, 0xaa, 0x03, 0xb0, 0xe3, 0x80, 0x86, 0x62, 0x79, 0xd5, 0xc2, 0x5a, 0xfe, - 0x6a, 0xa9, 0x31, 0xcf, 0xd7, 0x7b, 0x10, 0x43, 0xb1, 0x46, 0xc1, 0xe9, 0x6d, 0x2b, 0x24, 0xad, - 0x80, 0xba, 0x84, 0x55, 0x67, 0x13, 0xfa, 0xad, 0x18, 0x8a, 0x35, 0x0a, 0xf4, 0x0d, 0x40, 0x2c, - 0x0c, 0xa8, 0xd5, 0x22, 0x6a, 0xa9, 0x2f, 0x5b, 0xec, 0xb8, 0x0a, 0x62, 0x75, 0x2b, 0x6a, 0x75, - 0xe8, 0x60, 0x88, 0x02, 0x8f, 0xe0, 0x32, 0x7f, 0x67, 0xc0, 0x82, 0xe6, 0x0b, 0xc2, 0xef, 0xae, - 0xc3, 0x5c, 0x4b, 0xbb, 0x75, 0xca, 0x2f, 0xe2, 0xd3, 0xd6, 0x6f, 0x24, 0x4e, 0x51, 0x22, 0x02, - 0x25, 0xaa, 0x24, 0x45, 0xd1, 0x65, 0x23, 0xb3, 0xd3, 0x46, 0x36, 0x24, 0x9a, 0x34, 0x20, 0xc3, - 0x89, 0x64, 0xf3, 0x1f, 0x86, 0x70, 0xe0, 0x28, 0xde, 0xa0, 0xab, 0x5a, 0x4c, 0x33, 0xc4, 0xf6, - 0xcd, 0x8d, 0x89, 0x47, 0x17, 0x04, 0x82, 0xdc, 0xff, 0x44, 0x20, 0xb8, 0x51, 0xfc, 0xd5, 0x7b, - 0xb5, 0xa9, 0xb7, 0xff, 0xb6, 0x36, 0x65, 0xfe, 0xd2, 0x80, 0xb9, 0xcd, 0x4e, 0xc7, 0xeb, 0xed, - 0x75, 0x42, 0xb1, 0x00, 0x13, 0x66, 0x1c, 0xda, 0xc3, 0x5d, 0x5f, 0x2d, 0x14, 0xf8, 0xfd, 0x6e, - 0x0a, 0x08, 0x56, 0x18, 0x7e, 0x7f, 0x8e, 0x02, 0x6a, 0x13, 0x75, 0xdd, 0xe2, 0xfb, 0xb3, 0xcd, - 0x81, 0x58, 0xe2, 0xf8, 0x21, 0x1f, 0xb9, 0xc4, 0x73, 0x76, 0x2d, 0xdf, 0x6a, 0x11, 0xaa, 0x2e, - 0x47, 0xbc, 0xf5, 0xdb, 0x1a, 0x0e, 0xa7, 0x28, 0xcd, 0x7f, 0xe7, 0xa0, 0xb4, 0x15, 0xf8, 0x8e, - 0x1b, 0xaa, 0xcb, 0x15, 0xf6, 0x3a, 0x43, 0xc1, 0xe3, 0x4e, 0xaf, 0x43, 0xb0, 0xc0, 0xa0, 0xe7, - 0x61, 0x86, 0x85, 0x56, 0xd8, 0x65, 0xc2, 0x9e, 0x52, 0xe3, 0xb1, 0x28, 0x2c, 0x1d, 0x08, 0xe8, - 0x79, 0xbf, 0xb6, 0x10, 0x8b, 0x93, 0x20, 0xac, 0x18, 0xb8, 0xa7, 0x07, 0x87, 0x62, 0xa3, 0x9c, - 0x5b, 0x32, 0xed, 0x45, 0xf9, 0x23, 0x9f, 0x78, 0xfa, 0xde, 0x10, 0x05, 0x1e, 0xc1, 0x85, 0x4e, - 0x01, 0x79, 0x16, 0x0b, 0xef, 0x50, 0xcb, 0x67, 0x42, 0xd7, 0x1d, 0xb7, 0x4d, 0xd4, 0x85, 0xff, - 0x62, 0xb6, 0x13, 0xe7, 0x1c, 0x89, 0xde, 0xdb, 0x43, 0xd2, 0xf0, 0x08, 0x0d, 0xe8, 0x09, 0x98, - 0xa1, 0xc4, 0x62, 0x81, 0x5f, 0x2d, 0x88, 0xe5, 0xc7, 0x51, 0x19, 0x0b, 0x28, 0x56, 0x58, 0x1e, - 0xd0, 0xda, 0x84, 0x31, 0xab, 0x15, 0x85, 0xd7, 0x38, 0xa0, 0xed, 0x4a, 0x30, 0x8e, 0xf0, 0x66, - 0x1b, 0x2a, 0x5b, 0x94, 0x58, 0x21, 0x99, 0xc4, 0x2b, 0x3e, 0xfd, 0x81, 0xff, 0x24, 0x0f, 0x95, - 0x26, 0xf1, 0x48, 0xa2, 0x6f, 0x1b, 0x50, 0x8b, 0x5a, 0x36, 0xd9, 0x27, 0xd4, 0x0d, 0x9c, 0x03, - 0x62, 0x07, 0xbe, 0xc3, 0x84, 0x0b, 0xe4, 0x1b, 0xff, 0xc7, 0xf7, 0xe6, 0xd6, 0x10, 0x16, 0x8f, - 0xe0, 0x40, 0x1e, 0x54, 0x3a, 0x54, 0xfc, 0x16, 0xfb, 0x25, 0x3d, 0xa4, 0x7c, 0xed, 0xcb, 0xd9, - 0x8e, 0x63, 0x5f, 0x67, 0x6d, 0x2c, 0x9d, 0xf5, 0x6b, 0x95, 0x14, 0x08, 0xa7, 0x85, 0xa3, 0xaf, - 0xc3, 0x62, 0x40, 0x3b, 0xc7, 0x96, 0xdf, 0x24, 0x1d, 0xe2, 0x3b, 0xc4, 0x0f, 0x99, 0xd8, 0x85, - 0x62, 0x63, 0x99, 0xd7, 0x11, 0x7b, 0x03, 0x38, 0x3c, 0x44, 0x8d, 0x5e, 0x83, 0xa5, 0x0e, 0x0d, - 0x3a, 0x56, 0x4b, 0xb8, 0xd4, 0x7e, 0xe0, 0xb9, 0x76, 0x4f, 0xb8, 0x50, 0xa9, 0xf1, 0xd4, 0x59, - 0xbf, 0xb6, 0xb4, 0x3f, 0x88, 0x3c, 0xef, 0xd7, 0x2e, 0x89, 0xad, 0xe3, 0x90, 0x04, 0x89, 0x87, - 0xc5, 0x68, 0x67, 0x58, 0x18, 0x77, 0x86, 0xe6, 0x0e, 0x14, 0x9b, 0x5d, 0xe5, 0xcf, 0x2f, 0x42, - 0xd1, 0x51, 0xbf, 0xd5, 0xce, 0x47, 0x17, 0x2b, 0xa6, 0x39, 0xef, 0xd7, 0x2a, 0xbc, 0x74, 0xac, - 0x47, 0x00, 0x1c, 0xb3, 0x98, 0x4f, 0x40, 0x51, 0x1c, 0x39, 0xbb, 0xb7, 0x81, 0x16, 0x21, 0x8f, - 0xad, 0xfb, 0x42, 0xca, 0x1c, 0xe6, 0x3f, 0xb5, 0x08, 0xb4, 0x07, 0x70, 0x8b, 0x84, 0xd1, 0xc1, - 0x6f, 0xc2, 0x42, 0x14, 0x86, 0xd3, 0xd9, 0xe1, 0xff, 0x95, 0xee, 0x05, 0x9c, 0x46, 0xe3, 0x41, - 0x7a, 0xf3, 0x75, 0x28, 0x89, 0x0c, 0xc2, 0xd3, 0x6f, 0x92, 0xea, 0x8d, 0x07, 0xa4, 0xfa, 0x28, - 0x7f, 0xe7, 0xc6, 0xe5, 0x6f, 0xcd, 0x5c, 0x0f, 0x2a, 0x92, 0x37, 0x2a, 0x6e, 0x32, 0x69, 0x78, - 0x0a, 0x8a, 0x91, 0x99, 0x4a, 0x4b, 0x5c, 0xd4, 0x46, 0x82, 0x70, 0x4c, 0xa1, 0x69, 0x3b, 0x86, - 0x54, 0x36, 0xcc, 0xa6, 0x4c, 0xab, 0x5c, 0x72, 0x0f, 0xae, 0x5c, 0x34, 0x4d, 0x3f, 0x84, 0xea, - 0xb8, 0x4a, 0xf8, 0x21, 0xf2, 0x75, 0x76, 0x53, 0xcc, 0x77, 0x0c, 0x58, 0xd4, 0x25, 0x65, 0x3f, - 0xbe, 0xec, 0x4a, 0x2e, 0xae, 0xd4, 0xb4, 0x1d, 0xf9, 0xb5, 0x01, 0xcb, 0xa9, 0xa5, 0x4d, 0x74, - 0xe2, 0x13, 0x18, 0xa5, 0x3b, 0x47, 0x7e, 0x02, 0xe7, 0xf8, 0x4b, 0x0e, 0x2a, 0xb7, 0xad, 0x43, - 0xe2, 0x1d, 0x10, 0x8f, 0xd8, 0x61, 0x40, 0xd1, 0x0f, 0xa0, 0xdc, 0xb6, 0x42, 0xfb, 0x58, 0x40, - 0xa3, 0xaa, 0xbe, 0x99, 0x2d, 0xd8, 0xa5, 0x24, 0xd5, 0x77, 0x13, 0x31, 0x37, 0xfd, 0x90, 0xf6, - 0x1a, 0x97, 0x94, 0x49, 0x65, 0x0d, 0x83, 0x75, 0x6d, 0xa2, 0x15, 0x13, 0xdf, 0x37, 0xdf, 0xea, - 0xf0, 0x92, 0x63, 0xf2, 0x0e, 0x30, 0x65, 0x02, 0x26, 0x6f, 0x76, 0x5d, 0x4a, 0xda, 0xc4, 0x0f, - 0x93, 0x56, 0x6c, 0x77, 0x40, 0x3e, 0x1e, 0xd2, 0xb8, 0xf2, 0x12, 0x2c, 0x0e, 0x1a, 0xcf, 0xe3, - 0xcf, 0x09, 0xe9, 0xc9, 0xf3, 0xc2, 0xfc, 0x27, 0x5a, 0x86, 0xc2, 0xa9, 0xe5, 0x75, 0xd5, 0x6d, - 0xc4, 0xf2, 0xe3, 0x46, 0xee, 0xba, 0x61, 0xfe, 0xd6, 0x80, 0xea, 0x38, 0x43, 0xd0, 0xe7, 0x35, - 0x41, 0x8d, 0xb2, 0xb2, 0x2a, 0xff, 0x0a, 0xe9, 0x49, 0xa9, 0x37, 0xa1, 0x18, 0x74, 0x78, 0x3d, - 0x10, 0x50, 0x75, 0xea, 0x4f, 0x46, 0x27, 0xb9, 0xa7, 0xe0, 0xe7, 0xfd, 0xda, 0xe5, 0x94, 0xf8, - 0x08, 0x81, 0x63, 0x56, 0x1e, 0xa9, 0x85, 0x3d, 0x3c, 0x7b, 0xc4, 0x91, 0xfa, 0x9e, 0x80, 0x60, - 0x85, 0x31, 0xff, 0x60, 0xc0, 0xb4, 0x28, 0xa6, 0x5f, 0x87, 0x22, 0xdf, 0x3f, 0xc7, 0x0a, 0x2d, - 0x61, 0x57, 0xe6, 0x36, 0x8e, 0x73, 0xef, 0x92, 0xd0, 0x4a, 0xbc, 0x2d, 0x82, 0xe0, 0x58, 0x22, - 0xc2, 0x50, 0x70, 0x43, 0xd2, 0x8e, 0x0e, 0xf2, 0xe9, 0xb1, 0xa2, 0xd5, 0x10, 0xa1, 0x8e, 0xad, - 0xfb, 0x37, 0xdf, 0x0a, 0x89, 0xcf, 0x0f, 0x23, 0xb9, 0x1a, 0x3b, 0x5c, 0x06, 0x96, 0xa2, 0xcc, - 0x7f, 0x19, 0x10, 0xab, 0xe2, 0xce, 0xcf, 0x88, 0x77, 0x74, 0xdb, 0xf5, 0x4f, 0xd4, 0xb6, 0xc6, - 0xe6, 0x1c, 0x28, 0x38, 0x8e, 0x29, 0x46, 0xa5, 0x87, 0xdc, 0x64, 0xe9, 0x81, 0x2b, 0xb4, 0x03, - 0x3f, 0x74, 0xfd, 0xee, 0xd0, 0x6d, 0xdb, 0x52, 0x70, 0x1c, 0x53, 0xf0, 0x42, 0x84, 0x92, 0xb6, - 0xe5, 0xfa, 0xae, 0xdf, 0xe2, 0x8b, 0xd8, 0x0a, 0xba, 0x7e, 0x28, 0x32, 0xb2, 0x2a, 0x44, 0xf0, - 0x10, 0x16, 0x8f, 0xe0, 0x30, 0x7f, 0x3f, 0x0d, 0x65, 0xbe, 0xe6, 0x28, 0xcf, 0xbd, 0x00, 0x15, - 0x4f, 0xf7, 0x02, 0xb5, 0xf6, 0xcb, 0xca, 0x94, 0xf4, 0xbd, 0xc6, 0x69, 0x5a, 0xce, 0x2c, 0xea, - 0xa7, 0x98, 0x39, 0x97, 0x66, 0xde, 0xd6, 0x91, 0x38, 0x4d, 0xcb, 0xa3, 0xd7, 0x7d, 0x7e, 0x3f, - 0x54, 0x65, 0x12, 0x1f, 0xd1, 0x37, 0x39, 0x10, 0x4b, 0x1c, 0xda, 0x85, 0x4b, 0x96, 0xe7, 0x05, - 0xf7, 0x05, 0xb0, 0x11, 0x04, 0x27, 0x6d, 0x8b, 0x9e, 0x30, 0xd1, 0x08, 0x17, 0x1b, 0x9f, 0x53, - 0x2c, 0x97, 0x36, 0x87, 0x49, 0xf0, 0x28, 0xbe, 0x51, 0xc7, 0x36, 0x3d, 0xe1, 0xb1, 0x1d, 0xc3, - 0xf2, 0x00, 0x48, 0xdc, 0x72, 0xd5, 0x95, 0x3e, 0xab, 0xe4, 0x2c, 0xe3, 0x11, 0x34, 0xe7, 0x63, - 0xe0, 0x78, 0xa4, 0x44, 0x74, 0x03, 0xe6, 0xb9, 0x27, 0x07, 0xdd, 0x30, 0xaa, 0x3b, 0x0b, 0xe2, - 0xb8, 0xd1, 0x59, 0xbf, 0x36, 0x7f, 0x27, 0x85, 0xc1, 0x03, 0x94, 0x7c, 0x73, 0x3d, 0xb7, 0xed, - 0x86, 0xd5, 0x59, 0xc1, 0x12, 0x6f, 0xee, 0x6d, 0x0e, 0xc4, 0x12, 0x97, 0xf2, 0xc0, 0xe2, 0x45, - 0x1e, 0x68, 0xfe, 0x39, 0x0f, 0x48, 0x16, 0xca, 0x8e, 0xac, 0xa7, 0x64, 0x48, 0xe3, 0xd5, 0xbc, - 0x2a, 0xb4, 0x8d, 0x81, 0x6a, 0x5e, 0xd5, 0xd8, 0x11, 0x1e, 0xed, 0x42, 0x49, 0x86, 0x96, 0xe4, - 0xba, 0xac, 0x2b, 0xe2, 0xd2, 0x5e, 0x84, 0x38, 0xef, 0xd7, 0x56, 0x52, 0x6a, 0x62, 0x8c, 0xe8, - 0xb4, 0x12, 0x09, 0xe8, 0x1a, 0x80, 0xd5, 0x71, 0xf5, 0x59, 0x5b, 0x29, 0x99, 0xb8, 0x24, 0x5d, - 0x33, 0xd6, 0xa8, 0xd0, 0xcb, 0x30, 0x1d, 0x7e, 0xba, 0x6e, 0xa8, 0x28, 0x9a, 0x3d, 0xde, 0xfb, - 0x08, 0x09, 0x5c, 0xbb, 0xf0, 0x67, 0xc6, 0xcd, 0x52, 0x8d, 0x4c, 0xac, 0x7d, 0x3b, 0xc6, 0x60, - 0x8d, 0x0a, 0x7d, 0x0b, 0x8a, 0x47, 0xaa, 0x14, 0x15, 0x07, 0x93, 0x39, 0x44, 0x46, 0x05, 0xac, - 0x6c, 0xf7, 0xa3, 0x2f, 0x1c, 0x4b, 0x43, 0x5f, 0x81, 0x32, 0xeb, 0x1e, 0xc6, 0xd9, 0x5b, 0x9e, - 0x66, 0x9c, 0x2a, 0x0f, 0x12, 0x14, 0xd6, 0xe9, 0xcc, 0x37, 0xa1, 0xb4, 0xeb, 0xda, 0x34, 0x10, - 0xfd, 0xdb, 0x93, 0x30, 0xcb, 0x52, 0x0d, 0x4e, 0x7c, 0x92, 0x91, 0x97, 0x45, 0x78, 0xee, 0x5e, - 0xbe, 0xe5, 0x07, 0xb2, 0x8d, 0x29, 0x24, 0xee, 0xf5, 0x2a, 0x07, 0x62, 0x89, 0xbb, 0xb1, 0xcc, - 0x0b, 0x84, 0x9f, 0xbe, 0x5f, 0x9b, 0x7a, 0xf7, 0xfd, 0xda, 0xd4, 0x7b, 0xef, 0xab, 0x62, 0xe1, - 0x1c, 0x00, 0xf6, 0x0e, 0xbf, 0x47, 0x6c, 0x19, 0x76, 0x33, 0x8d, 0xe4, 0xa2, 0x49, 0xb0, 0x18, - 0xc9, 0xe5, 0x06, 0x8a, 0x3e, 0x0d, 0x87, 0x53, 0x94, 0x68, 0x1d, 0x4a, 0xf1, 0xb0, 0x4d, 0xf9, - 0xc7, 0x52, 0xe4, 0x6f, 0xf1, 0x44, 0x0e, 0x27, 0x34, 0xa9, 0x1c, 0x30, 0x7d, 0x61, 0x0e, 0x68, - 0x40, 0xbe, 0xeb, 0x3a, 0xaa, 0xd9, 0x7d, 0x26, 0xca, 0xc1, 0x77, 0x77, 0x9a, 0xe7, 0xfd, 0xda, - 0x63, 0xe3, 0x66, 0xdc, 0x61, 0xaf, 0x43, 0x58, 0xfd, 0xee, 0x4e, 0x13, 0x73, 0xe6, 0x51, 0x01, - 0x69, 0x66, 0xc2, 0x80, 0x74, 0x0d, 0xa0, 0x95, 0x8c, 0x0c, 0xe4, 0x7d, 0x8f, 0x1d, 0x51, 0x1b, - 0x15, 0x68, 0x54, 0x88, 0xc1, 0x92, 0xcd, 0xfb, 0x6a, 0xd5, 0xba, 0xb3, 0xd0, 0x6a, 0xcb, 0x21, - 0xe4, 0x64, 0x77, 0xe2, 0x8a, 0x52, 0xb3, 0xb4, 0x35, 0x28, 0x0c, 0x0f, 0xcb, 0x47, 0x01, 0x2c, - 0x39, 0xaa, 0x43, 0x4c, 0x94, 0x96, 0x26, 0x56, 0x7a, 0x99, 0x2b, 0x6c, 0x0e, 0x0a, 0xc2, 0xc3, - 0xb2, 0xd1, 0x77, 0x61, 0x25, 0x02, 0x0e, 0xb7, 0xe9, 0x22, 0x60, 0xe7, 0x1b, 0xab, 0x67, 0xfd, - 0xda, 0x4a, 0x73, 0x2c, 0x15, 0x7e, 0x80, 0x04, 0xe4, 0xc0, 0x8c, 0x27, 0x0b, 0xdc, 0xb2, 0x28, - 0x4a, 0xbe, 0x9a, 0x6d, 0x15, 0x89, 0xf7, 0xd7, 0xf5, 0xc2, 0x36, 0x1e, 0x97, 0xa8, 0x9a, 0x56, - 0xc9, 0x46, 0x6f, 0x41, 0xd9, 0xf2, 0xfd, 0x20, 0xb4, 0xe4, 0xe0, 0x60, 0x4e, 0xa8, 0xda, 0x9c, - 0x58, 0xd5, 0x66, 0x22, 0x63, 0xa0, 0x90, 0xd6, 0x30, 0x58, 0x57, 0x85, 0xee, 0xc3, 0x42, 0x70, - 0xdf, 0x27, 0x14, 0x93, 0x23, 0x42, 0x89, 0x6f, 0x13, 0x56, 0xad, 0x08, 0xed, 0xcf, 0x66, 0xd4, - 0x9e, 0x62, 0x4e, 0x5c, 0x3a, 0x0d, 0x67, 0x78, 0x50, 0x0b, 0xaa, 0xf3, 0xd8, 0xea, 0x5b, 0x9e, - 0xfb, 0x7d, 0x42, 0x59, 0x75, 0x3e, 0x99, 0x13, 0x6f, 0xc7, 0x50, 0xac, 0x51, 0xf0, 0xe8, 0x67, - 0x7b, 0x5d, 0x16, 0x12, 0x39, 0xb4, 0x5f, 0x48, 0x47, 0xbf, 0xad, 0x04, 0x85, 0x75, 0x3a, 0xd4, - 0x85, 0x4a, 0x5b, 0xcf, 0x34, 0xd5, 0x25, 0xb1, 0xba, 0xeb, 0xd9, 0x56, 0x37, 0x9c, 0x0b, 0x93, - 0xc2, 0x27, 0x85, 0xc3, 0x69, 0x2d, 0x2b, 0xcf, 0x43, 0xf9, 0x53, 0xf6, 0x04, 0xbc, 0xa7, 0x18, - 0x3c, 0xc7, 0x89, 0x7a, 0x8a, 0x3f, 0xe6, 0x60, 0x3e, 0xbd, 0xfb, 0x03, 0x59, 0xb4, 0x90, 0x29, - 0x8b, 0x46, 0xdd, 0xab, 0x31, 0xf6, 0x9d, 0x21, 0x0a, 0xeb, 0xf9, 0xb1, 0x61, 0x5d, 0x45, 0xcf, - 0xe9, 0x87, 0x89, 0x9e, 0x75, 0x00, 0x5e, 0x9e, 0xd0, 0xc0, 0xf3, 0x08, 0x15, 0x81, 0xb3, 0xa8, - 0xde, 0x13, 0x62, 0x28, 0xd6, 0x28, 0x78, 0x11, 0x7d, 0xe8, 0x05, 0xf6, 0x89, 0xd8, 0x82, 0xe8, - 0xd2, 0x8b, 0x90, 0x59, 0x94, 0x45, 0x74, 0x63, 0x08, 0x8b, 0x47, 0x70, 0x98, 0x3d, 0xb8, 0xbc, - 0x6f, 0xd1, 0xd0, 0xb5, 0xbc, 0xe4, 0x82, 0x89, 0x2e, 0xe5, 0x8d, 0xa1, 0x1e, 0xe8, 0x99, 0x49, - 0x2f, 0x6a, 0xb2, 0xf9, 0x09, 0x2c, 0xe9, 0x83, 0xcc, 0xbf, 0x1a, 0x70, 0x65, 0xa4, 0xee, 0xcf, - 0xa0, 0x07, 0x7b, 0x23, 0xdd, 0x83, 0xbd, 0x90, 0x71, 0x78, 0x39, 0xca, 0xda, 0x31, 0x1d, 0xd9, - 0x2c, 0x14, 0xf6, 0x79, 0xed, 0x6b, 0xfe, 0xc2, 0x80, 0x39, 0xf1, 0x6b, 0x92, 0xc1, 0x6f, 0x2d, - 0xfd, 0x1c, 0x50, 0x7a, 0x84, 0x4f, 0x01, 0xef, 0x18, 0x90, 0x1e, 0xb9, 0xa2, 0x97, 0xa4, 0xff, - 0x1a, 0xf1, 0x4c, 0x74, 0x42, 0xdf, 0x7d, 0x71, 0x5c, 0x07, 0x79, 0x29, 0xd3, 0x70, 0xf1, 0x29, - 0x28, 0xe1, 0x20, 0x08, 0xf7, 0xad, 0xf0, 0x98, 0xf1, 0x85, 0x77, 0xf8, 0x0f, 0xb5, 0x37, 0x62, - 0xe1, 0x02, 0x83, 0x25, 0xdc, 0xfc, 0xb9, 0x01, 0x57, 0xc6, 0x3e, 0xd1, 0xf0, 0x10, 0x60, 0xc7, - 0x5f, 0x6a, 0x45, 0xb1, 0x17, 0x26, 0x74, 0x58, 0xa3, 0xe2, 0xad, 0x5f, 0xea, 0x5d, 0x67, 0xb0, - 0xf5, 0x4b, 0x69, 0xc3, 0x69, 0x5a, 0xf3, 0x9f, 0x39, 0x50, 0x6f, 0x22, 0xff, 0x65, 0x8f, 0x7d, - 0x62, 0xe0, 0x45, 0x66, 0x3e, 0xfd, 0x22, 0x13, 0x3f, 0xbf, 0x68, 0x4f, 0x12, 0xf9, 0x07, 0x3f, - 0x49, 0xa0, 0xe7, 0xe2, 0x57, 0x0e, 0x19, 0xba, 0x56, 0xd3, 0xaf, 0x1c, 0xe7, 0xfd, 0xda, 0x9c, - 0x12, 0x9e, 0x7e, 0xf5, 0x78, 0x0d, 0x66, 0x1d, 0x12, 0x5a, 0xae, 0x27, 0xdb, 0xb8, 0xcc, 0xb3, - 0x7f, 0x29, 0xac, 0x29, 0x59, 0x1b, 0x65, 0x6e, 0x93, 0xfa, 0xc0, 0x91, 0x40, 0x1e, 0x6d, 0xed, - 0xc0, 0x91, 0x5d, 0x48, 0x21, 0x89, 0xb6, 0x5b, 0x81, 0x43, 0xb0, 0xc0, 0x98, 0xef, 0x1a, 0x50, - 0x96, 0x92, 0xb6, 0xac, 0x2e, 0x23, 0x68, 0x23, 0x5e, 0x85, 0x3c, 0xee, 0x2b, 0xfa, 0x73, 0xd6, - 0x79, 0xbf, 0x56, 0x12, 0x64, 0xa2, 0x81, 0x19, 0xf1, 0x6c, 0x93, 0xbb, 0x60, 0x8f, 0x1e, 0x87, - 0x82, 0xb8, 0x3d, 0x6a, 0x33, 0x93, 0x77, 0x39, 0x0e, 0xc4, 0x12, 0x67, 0x7e, 0x9c, 0x83, 0x4a, - 0x6a, 0x71, 0x19, 0x7a, 0x81, 0x78, 0xe2, 0x99, 0xcb, 0x30, 0x45, 0x1f, 0xff, 0x0a, 0xae, 0x72, - 0xcf, 0xcc, 0xc3, 0xe4, 0x9e, 0x6f, 0xc3, 0x8c, 0xcd, 0xf7, 0x28, 0xfa, 0x53, 0xc5, 0xc6, 0x24, - 0xc7, 0x29, 0x76, 0x37, 0xf1, 0x46, 0xf1, 0xc9, 0xb0, 0x12, 0x88, 0x6e, 0xc1, 0x12, 0x25, 0x21, - 0xed, 0x6d, 0x1e, 0x85, 0x84, 0xea, 0xbd, 0x7f, 0x21, 0xa9, 0xb8, 0xf1, 0x20, 0x01, 0x1e, 0xe6, - 0x31, 0x0f, 0x61, 0xee, 0x8e, 0x75, 0xe8, 0xc5, 0xaf, 0x59, 0x18, 0x2a, 0xae, 0x6f, 0x7b, 0x5d, - 0x87, 0xc8, 0x68, 0x1c, 0x45, 0xaf, 0xe8, 0xd2, 0xee, 0xe8, 0xc8, 0xf3, 0x7e, 0xed, 0x52, 0x0a, - 0x20, 0x9f, 0x6f, 0x70, 0x5a, 0x84, 0xe9, 0xc1, 0xf4, 0x67, 0xd8, 0x3d, 0x7e, 0x07, 0x4a, 0x49, - 0x7d, 0xff, 0x88, 0x55, 0x9a, 0x6f, 0x40, 0x91, 0x7b, 0x7c, 0xd4, 0x97, 0x5e, 0x50, 0xe2, 0xa4, - 0x0b, 0xa7, 0x5c, 0x96, 0xc2, 0xc9, 0x6c, 0x43, 0xe5, 0x6e, 0xc7, 0x79, 0xc8, 0xf7, 0xcc, 0x5c, - 0xe6, 0xac, 0x75, 0x0d, 0xe4, 0xff, 0x35, 0x78, 0x82, 0x90, 0x99, 0x5b, 0x4b, 0x10, 0x7a, 0xe2, - 0xd5, 0x86, 0xf9, 0x3f, 0x36, 0x00, 0xc4, 0xd4, 0xec, 0xe6, 0x29, 0xf1, 0xc3, 0x0c, 0xaf, 0xde, - 0x77, 0x61, 0x26, 0x90, 0xde, 0x24, 0xdf, 0x34, 0x27, 0x1c, 0xcd, 0xc6, 0x97, 0x40, 0xfa, 0x13, - 0x56, 0xc2, 0x1a, 0x57, 0x3f, 0xf8, 0x64, 0x75, 0xea, 0xc3, 0x4f, 0x56, 0xa7, 0x3e, 0xfa, 0x64, - 0x75, 0xea, 0xed, 0xb3, 0x55, 0xe3, 0x83, 0xb3, 0x55, 0xe3, 0xc3, 0xb3, 0x55, 0xe3, 0xa3, 0xb3, - 0x55, 0xe3, 0xe3, 0xb3, 0x55, 0xe3, 0xdd, 0xbf, 0xaf, 0x4e, 0xbd, 0x96, 0x3b, 0xdd, 0xf8, 0x4f, - 0x00, 0x00, 0x00, 0xff, 0xff, 0x0d, 0x18, 0xc5, 0x8c, 0x25, 0x27, 0x00, 0x00, + 0x55, 0x8f, 0x37, 0x03, 0x07, 0x72, 0x00, 0x01, 0x12, 0x8a, 0xc2, 0x8d, 0x13, 0x4a, 0x04, 0x7f, + 0x00, 0xe2, 0x02, 0x7f, 0x00, 0x12, 0x39, 0x06, 0x71, 0x89, 0x04, 0x1a, 0x25, 0xe6, 0xc0, 0x11, + 0x71, 0xf5, 0x05, 0x54, 0x8f, 0xee, 0xae, 0x9e, 0xc7, 0xba, 0x27, 0xbb, 0x44, 0xdc, 0xa6, 0xbf, + 0x77, 0x55, 0x7d, 0xf5, 0xbd, 0x6a, 0x60, 0xf7, 0xe4, 0x3a, 0xab, 0xbb, 0xc1, 0xfa, 0x49, 0xf7, + 0x90, 0x50, 0x9f, 0x84, 0x84, 0xad, 0x9f, 0x12, 0xdf, 0x09, 0xe8, 0xba, 0x42, 0x58, 0x1d, 0xb7, + 0x6d, 0xd9, 0xc7, 0xae, 0x4f, 0x68, 0x6f, 0xbd, 0x73, 0xd2, 0xe2, 0x00, 0xb6, 0xde, 0x26, 0xa1, + 0xb5, 0x7e, 0xba, 0xb1, 0xde, 0x22, 0x3e, 0xa1, 0x56, 0x48, 0x9c, 0x7a, 0x87, 0x06, 0x61, 0x80, + 0xbe, 0x20, 0xb9, 0xea, 0x3a, 0x57, 0xbd, 0x73, 0xd2, 0xe2, 0x00, 0x56, 0xe7, 0x5c, 0xf5, 0xd3, + 0x8d, 0x95, 0xa7, 0x5b, 0x6e, 0x78, 0xdc, 0x3d, 0xac, 0xdb, 0x41, 0x7b, 0xbd, 0x15, 0xb4, 0x82, + 0x75, 0xc1, 0x7c, 0xd8, 0x3d, 0x12, 0x5f, 0xe2, 0x43, 0xfc, 0x92, 0x42, 0x57, 0xc6, 0x9a, 0x42, + 0xbb, 0x7e, 0xe8, 0xb6, 0xc9, 0xa0, 0x15, 0x2b, 0xcf, 0x5d, 0xc4, 0xc0, 0xec, 0x63, 0xd2, 0xb6, + 0x06, 0xf9, 0xcc, 0x3f, 0xe5, 0xa1, 0xb8, 0xb9, 0xbf, 0x73, 0x8b, 0x06, 0xdd, 0x0e, 0x5a, 0x83, + 0x69, 0xdf, 0x6a, 0x93, 0xaa, 0xb1, 0x66, 0x5c, 0x2d, 0x35, 0xe6, 0x3e, 0xe8, 0xd7, 0xa6, 0xce, + 0xfa, 0xb5, 0xe9, 0x57, 0xad, 0x36, 0xc1, 0x02, 0x83, 0x3c, 0x28, 0x9e, 0x12, 0xca, 0xdc, 0xc0, + 0x67, 0xd5, 0xdc, 0x5a, 0xfe, 0x6a, 0xf9, 0xda, 0x4b, 0xf5, 0x2c, 0xeb, 0xaf, 0x0b, 0x05, 0xf7, + 0x24, 0xeb, 0x76, 0x40, 0x9b, 0x2e, 0xb3, 0x83, 0x53, 0x42, 0x7b, 0x8d, 0x45, 0xa5, 0xa5, 0xa8, + 0x90, 0x0c, 0xc7, 0x1a, 0xd0, 0x8f, 0x0c, 0x58, 0xec, 0x50, 0x72, 0x44, 0x28, 0x25, 0x8e, 0xc2, + 0x57, 0xf3, 0x6b, 0xc6, 0x23, 0x50, 0x5b, 0x55, 0x6a, 0x17, 0xf7, 0x07, 0xe4, 0xe3, 0x21, 0x8d, + 0xe8, 0xd7, 0x06, 0xac, 0x30, 0x42, 0x4f, 0x09, 0xdd, 0x74, 0x1c, 0x4a, 0x18, 0x6b, 0xf4, 0xb6, + 0x3c, 0x97, 0xf8, 0xe1, 0xd6, 0x4e, 0x13, 0xb3, 0xea, 0xb4, 0xd8, 0x87, 0xaf, 0x65, 0x33, 0xe8, + 0x60, 0x9c, 0x9c, 0x86, 0xa9, 0x2c, 0x5a, 0x19, 0x4b, 0xc2, 0xf0, 0x03, 0xcc, 0x30, 0x8f, 0x60, + 0x2e, 0x3a, 0xc8, 0xdb, 0x2e, 0x0b, 0xd1, 0x3d, 0x98, 0x69, 0xf1, 0x0f, 0x56, 0x35, 0x84, 0x81, + 0xf5, 0x6c, 0x06, 0x46, 0x32, 0x1a, 0xf3, 0xca, 0x9e, 0x19, 0xf1, 0xc9, 0xb0, 0x92, 0x66, 0xfe, + 0x6c, 0x1a, 0xca, 0x9b, 0xfb, 0x3b, 0x98, 0xb0, 0xa0, 0x4b, 0x6d, 0x92, 0xc1, 0x69, 0xae, 0xc3, + 0x1c, 0x73, 0xfd, 0x56, 0xd7, 0xb3, 0x28, 0x87, 0x56, 0x67, 0x04, 0xe5, 0xb2, 0xa2, 0x9c, 0x3b, + 0xd0, 0x70, 0x38, 0x45, 0x89, 0xae, 0x01, 0x70, 0x09, 0xac, 0x63, 0xd9, 0xc4, 0xa9, 0xe6, 0xd6, + 0x8c, 0xab, 0xc5, 0x06, 0x52, 0x7c, 0xf0, 0x6a, 0x8c, 0xc1, 0x1a, 0x15, 0x7a, 0x1c, 0x0a, 0xc2, + 0xd2, 0x6a, 0x51, 0xa8, 0xa9, 0x28, 0xf2, 0x82, 0x58, 0x06, 0x96, 0x38, 0xf4, 0x24, 0xcc, 0x2a, + 0x2f, 0xab, 0x96, 0x04, 0xd9, 0x82, 0x22, 0x9b, 0x8d, 0xdc, 0x20, 0xc2, 0xf3, 0xf5, 0x9d, 0xb8, + 0xbe, 0x23, 0xfc, 0x4e, 0x5b, 0xdf, 0x2b, 0xae, 0xef, 0x60, 0x81, 0x41, 0xb7, 0xa1, 0x70, 0x4a, + 0xe8, 0x21, 0xf7, 0x04, 0xee, 0x9a, 0x5f, 0xca, 0xb6, 0xd1, 0xf7, 0x38, 0x4b, 0xa3, 0xc4, 0x4d, + 0x13, 0x3f, 0xb1, 0x14, 0x82, 0xea, 0x00, 0xec, 0x38, 0xa0, 0xa1, 0x58, 0x5e, 0xb5, 0xb0, 0x96, + 0xbf, 0x5a, 0x6a, 0xcc, 0xf3, 0xf5, 0x1e, 0xc4, 0x50, 0xac, 0x51, 0x70, 0x7a, 0xdb, 0x0a, 0x49, + 0x2b, 0xa0, 0x2e, 0x61, 0xd5, 0xd9, 0x84, 0x7e, 0x2b, 0x86, 0x62, 0x8d, 0x02, 0x7d, 0x03, 0x10, + 0x0b, 0x03, 0x6a, 0xb5, 0x88, 0x5a, 0xea, 0xcb, 0x16, 0x3b, 0xae, 0x82, 0x58, 0xdd, 0x8a, 0x5a, + 0x1d, 0x3a, 0x18, 0xa2, 0xc0, 0x23, 0xb8, 0xcc, 0xdf, 0x19, 0xb0, 0xa0, 0xf9, 0x82, 0xf0, 0xbb, + 0xeb, 0x30, 0xd7, 0xd2, 0x6e, 0x9d, 0xf2, 0x8b, 0xf8, 0xb4, 0xf5, 0x1b, 0x89, 0x53, 0x94, 0x88, + 0x40, 0x89, 0x2a, 0x49, 0x51, 0x74, 0xd9, 0xc8, 0xec, 0xb4, 0x91, 0x0d, 0x89, 0x26, 0x0d, 0xc8, + 0x70, 0x22, 0xd9, 0xfc, 0x87, 0x21, 0x1c, 0x38, 0x8a, 0x37, 0xe8, 0xaa, 0x16, 0xd3, 0x0c, 0xb1, + 0x7d, 0x73, 0x63, 0xe2, 0xd1, 0x05, 0x81, 0x20, 0xf7, 0x3f, 0x11, 0x08, 0x6e, 0x14, 0x7f, 0xf9, + 0x5e, 0x6d, 0xea, 0xed, 0xbf, 0xad, 0x4d, 0x99, 0xbf, 0x30, 0x60, 0x6e, 0xb3, 0xd3, 0xf1, 0x7a, + 0x7b, 0x9d, 0x50, 0x2c, 0xc0, 0x84, 0x19, 0x87, 0xf6, 0x70, 0xd7, 0x57, 0x0b, 0x05, 0x7e, 0xbf, + 0x9b, 0x02, 0x82, 0x15, 0x86, 0xdf, 0x9f, 0xa3, 0x80, 0xda, 0x44, 0x5d, 0xb7, 0xf8, 0xfe, 0x6c, + 0x73, 0x20, 0x96, 0x38, 0x7e, 0xc8, 0x47, 0x2e, 0xf1, 0x9c, 0x5d, 0xcb, 0xb7, 0x5a, 0x84, 0xaa, + 0xcb, 0x11, 0x6f, 0xfd, 0xb6, 0x86, 0xc3, 0x29, 0x4a, 0xf3, 0xdf, 0x39, 0x28, 0x6d, 0x05, 0xbe, + 0xe3, 0x86, 0xea, 0x72, 0x85, 0xbd, 0xce, 0x50, 0xf0, 0xb8, 0xd3, 0xeb, 0x10, 0x2c, 0x30, 0xe8, + 0x79, 0x98, 0x61, 0xa1, 0x15, 0x76, 0x99, 0xb0, 0xa7, 0xd4, 0x78, 0x2c, 0x0a, 0x4b, 0x07, 0x02, + 0x7a, 0xde, 0xaf, 0x2d, 0xc4, 0xe2, 0x24, 0x08, 0x2b, 0x06, 0xee, 0xe9, 0xc1, 0xa1, 0xd8, 0x28, + 0xe7, 0x96, 0x4c, 0x7b, 0x51, 0xfe, 0xc8, 0x27, 0x9e, 0xbe, 0x37, 0x44, 0x81, 0x47, 0x70, 0xa1, + 0x53, 0x40, 0x9e, 0xc5, 0xc2, 0x3b, 0xd4, 0xf2, 0x99, 0xd0, 0x75, 0xc7, 0x6d, 0x13, 0x75, 0xe1, + 0xbf, 0x98, 0xed, 0xc4, 0x39, 0x47, 0xa2, 0xf7, 0xf6, 0x90, 0x34, 0x3c, 0x42, 0x03, 0x7a, 0x02, + 0x66, 0x28, 0xb1, 0x58, 0xe0, 0x57, 0x0b, 0x62, 0xf9, 0x71, 0x54, 0xc6, 0x02, 0x8a, 0x15, 0x96, + 0x07, 0xb4, 0x36, 0x61, 0xcc, 0x6a, 0x45, 0xe1, 0x35, 0x0e, 0x68, 0xbb, 0x12, 0x8c, 0x23, 0xbc, + 0xf9, 0x5b, 0x03, 0x2a, 0x5b, 0x94, 0x58, 0x21, 0x99, 0xc4, 0x2d, 0x3e, 0xf5, 0x89, 0xa3, 0x4d, + 0x58, 0x10, 0xdf, 0xf7, 0x2c, 0xcf, 0x75, 0xe4, 0x19, 0x4c, 0x0b, 0xe6, 0xff, 0x57, 0xcc, 0x0b, + 0xdb, 0x69, 0x34, 0x1e, 0xa4, 0x37, 0x7f, 0x92, 0x87, 0x4a, 0x93, 0x78, 0x24, 0x31, 0x79, 0x1b, + 0x50, 0x8b, 0x5a, 0x36, 0xd9, 0x27, 0xd4, 0x0d, 0x9c, 0x03, 0x62, 0x07, 0xbe, 0xc3, 0x84, 0x1b, + 0xe5, 0x1b, 0xff, 0xc7, 0xf7, 0xf7, 0xd6, 0x10, 0x16, 0x8f, 0xe0, 0x40, 0x1e, 0x54, 0x3a, 0x54, + 0xfc, 0x16, 0x7b, 0x2e, 0xbd, 0xac, 0x7c, 0xed, 0xcb, 0xd9, 0x8e, 0x74, 0x5f, 0x67, 0x6d, 0x2c, + 0x9d, 0xf5, 0x6b, 0x95, 0x14, 0x08, 0xa7, 0x85, 0xa3, 0xaf, 0xc3, 0x62, 0x40, 0x3b, 0xc7, 0x96, + 0xdf, 0x24, 0x1d, 0xe2, 0x3b, 0xc4, 0x0f, 0x99, 0xd8, 0xc8, 0x62, 0x63, 0x99, 0xd7, 0x22, 0x7b, + 0x03, 0x38, 0x3c, 0x44, 0x8d, 0x5e, 0x83, 0xa5, 0x0e, 0x0d, 0x3a, 0x56, 0x4b, 0x6c, 0xcc, 0x7e, + 0xe0, 0xb9, 0x76, 0x4f, 0x6d, 0xe7, 0x53, 0x67, 0xfd, 0xda, 0xd2, 0xfe, 0x20, 0xf2, 0xbc, 0x5f, + 0xbb, 0x24, 0xb6, 0x8e, 0x43, 0x12, 0x24, 0x1e, 0x16, 0xa3, 0xb9, 0x41, 0x61, 0x9c, 0x1b, 0x98, + 0x3b, 0x50, 0x6c, 0x76, 0xd5, 0x9d, 0x78, 0x11, 0x8a, 0x8e, 0xfa, 0xad, 0x76, 0x3e, 0xba, 0x9c, + 0x31, 0xcd, 0x79, 0xbf, 0x56, 0xe1, 0xe5, 0x67, 0x3d, 0x02, 0xe0, 0x98, 0xc5, 0x7c, 0x02, 0x8a, + 0xe2, 0xe0, 0xd9, 0xbd, 0x0d, 0xb4, 0x08, 0x79, 0x6c, 0xdd, 0x17, 0x52, 0xe6, 0x30, 0xff, 0xa9, + 0x45, 0xb1, 0x3d, 0x80, 0x5b, 0x24, 0x8c, 0x0e, 0x7e, 0x13, 0x16, 0xa2, 0x50, 0x9e, 0xce, 0x30, + 0xb1, 0x37, 0xe1, 0x34, 0x1a, 0x0f, 0xd2, 0x9b, 0xaf, 0x43, 0x49, 0x64, 0x21, 0x9e, 0xc2, 0x93, + 0x72, 0xc1, 0x78, 0x40, 0xb9, 0x10, 0xd5, 0x00, 0xb9, 0x71, 0x35, 0x80, 0x66, 0xae, 0x07, 0x15, + 0xc9, 0x1b, 0x15, 0x48, 0x99, 0x34, 0x3c, 0x05, 0xc5, 0xc8, 0x4c, 0xa5, 0x25, 0x2e, 0x8c, 0x23, + 0x41, 0x38, 0xa6, 0xd0, 0xb4, 0x1d, 0x43, 0x2a, 0xa3, 0x66, 0x53, 0xa6, 0x55, 0x3f, 0xb9, 0x07, + 0x57, 0x3f, 0x9a, 0xa6, 0x1f, 0x42, 0x75, 0x5c, 0x35, 0xfd, 0x10, 0x39, 0x3f, 0xbb, 0x29, 0xe6, + 0x3b, 0x06, 0x2c, 0xea, 0x92, 0xb2, 0x1f, 0x5f, 0x76, 0x25, 0x17, 0x57, 0x7b, 0xda, 0x8e, 0xfc, + 0xca, 0x80, 0xe5, 0xd4, 0xd2, 0x26, 0x3a, 0xf1, 0x09, 0x8c, 0xd2, 0x9d, 0x23, 0x3f, 0x81, 0x73, + 0xfc, 0x25, 0x07, 0x95, 0xdb, 0xd6, 0x21, 0xf1, 0x0e, 0x88, 0x47, 0xec, 0x30, 0xa0, 0xe8, 0x07, + 0x50, 0x6e, 0x5b, 0xa1, 0x7d, 0x2c, 0xa0, 0x51, 0x67, 0xd0, 0xcc, 0x16, 0xec, 0x52, 0x92, 0xea, + 0xbb, 0x89, 0x98, 0x9b, 0x7e, 0x48, 0x7b, 0x8d, 0x4b, 0xca, 0xa4, 0xb2, 0x86, 0xc1, 0xba, 0x36, + 0xd1, 0xce, 0x89, 0xef, 0x9b, 0x6f, 0x75, 0x78, 0xd9, 0x32, 0x79, 0x17, 0x99, 0x32, 0x01, 0x93, + 0x37, 0xbb, 0x2e, 0x25, 0x6d, 0xe2, 0x87, 0x49, 0x3b, 0xb7, 0x3b, 0x20, 0x1f, 0x0f, 0x69, 0x5c, + 0x79, 0x09, 0x16, 0x07, 0x8d, 0xe7, 0xf1, 0xe7, 0x84, 0xf4, 0xe4, 0x79, 0x61, 0xfe, 0x13, 0x2d, + 0x43, 0xe1, 0xd4, 0xf2, 0xba, 0xea, 0x36, 0x62, 0xf9, 0x71, 0x23, 0x77, 0xdd, 0x30, 0x7f, 0x63, + 0x40, 0x75, 0x9c, 0x21, 0xe8, 0xf3, 0x9a, 0xa0, 0x46, 0x59, 0x59, 0x95, 0x7f, 0x85, 0xf4, 0xa4, + 0xd4, 0x9b, 0x50, 0x0c, 0x3a, 0xbc, 0xa6, 0x08, 0xa8, 0x3a, 0xf5, 0x27, 0xa3, 0x93, 0xdc, 0x53, + 0xf0, 0xf3, 0x7e, 0xed, 0x72, 0x4a, 0x7c, 0x84, 0xc0, 0x31, 0x2b, 0x8f, 0xd4, 0xc2, 0x1e, 0x9e, + 0x3d, 0xe2, 0x48, 0x7d, 0x4f, 0x40, 0xb0, 0xc2, 0x98, 0x7f, 0x30, 0x60, 0x5a, 0x14, 0xe4, 0xaf, + 0x43, 0x91, 0xef, 0x9f, 0x63, 0x85, 0x96, 0xb0, 0x2b, 0x73, 0x2b, 0xc8, 0xb9, 0x77, 0x49, 0x68, + 0x25, 0xde, 0x16, 0x41, 0x70, 0x2c, 0x11, 0x61, 0x28, 0xb8, 0x21, 0x69, 0x47, 0x07, 0xf9, 0xf4, + 0x58, 0xd1, 0x6a, 0x10, 0x51, 0xc7, 0xd6, 0xfd, 0x9b, 0x6f, 0x85, 0xc4, 0xe7, 0x87, 0x91, 0x5c, + 0x8d, 0x1d, 0x2e, 0x03, 0x4b, 0x51, 0xe6, 0xbf, 0x0c, 0x88, 0x55, 0x71, 0xe7, 0x67, 0xc4, 0x3b, + 0xba, 0xed, 0xfa, 0x27, 0x6a, 0x5b, 0x63, 0x73, 0x0e, 0x14, 0x1c, 0xc7, 0x14, 0xa3, 0xd2, 0x43, + 0x6e, 0xb2, 0xf4, 0xc0, 0x15, 0xda, 0x81, 0x1f, 0xba, 0x7e, 0x77, 0xe8, 0xb6, 0x6d, 0x29, 0x38, + 0x8e, 0x29, 0x78, 0x21, 0x42, 0x49, 0xdb, 0x72, 0x7d, 0xd7, 0x6f, 0xf1, 0x45, 0x6c, 0x05, 0x5d, + 0x3f, 0x14, 0x19, 0x59, 0x15, 0x22, 0x78, 0x08, 0x8b, 0x47, 0x70, 0x98, 0xbf, 0x9f, 0x86, 0x32, + 0x5f, 0x73, 0x94, 0xe7, 0x5e, 0x80, 0x8a, 0xa7, 0x7b, 0x81, 0x5a, 0xfb, 0x65, 0x65, 0x4a, 0xfa, + 0x5e, 0xe3, 0x34, 0x2d, 0x67, 0x16, 0x25, 0x54, 0xcc, 0x9c, 0x4b, 0x33, 0x6f, 0xeb, 0x48, 0x9c, + 0xa6, 0xe5, 0xd1, 0xeb, 0x3e, 0xbf, 0x1f, 0xaa, 0x32, 0x89, 0x8f, 0xe8, 0x9b, 0x1c, 0x88, 0x25, + 0x0e, 0xed, 0xc2, 0x25, 0xcb, 0xf3, 0x82, 0xfb, 0x02, 0xd8, 0x08, 0x82, 0x93, 0xb6, 0x45, 0x4f, + 0x98, 0x68, 0xa6, 0x8b, 0x8d, 0xcf, 0x29, 0x96, 0x4b, 0x9b, 0xc3, 0x24, 0x78, 0x14, 0xdf, 0xa8, + 0x63, 0x9b, 0x9e, 0xf0, 0xd8, 0x8e, 0x61, 0x79, 0x00, 0x24, 0x6e, 0xb9, 0xea, 0x6c, 0x9f, 0x55, + 0x72, 0x96, 0xf1, 0x08, 0x9a, 0xf3, 0x31, 0x70, 0x3c, 0x52, 0x22, 0xba, 0x01, 0xf3, 0xdc, 0x93, + 0x83, 0x6e, 0x18, 0xd5, 0x9d, 0x05, 0x71, 0xdc, 0xe8, 0xac, 0x5f, 0x9b, 0xbf, 0x93, 0xc2, 0xe0, + 0x01, 0x4a, 0xbe, 0xb9, 0x9e, 0xdb, 0x76, 0xc3, 0xea, 0xac, 0x60, 0x89, 0x37, 0xf7, 0x36, 0x07, + 0x62, 0x89, 0x4b, 0x79, 0x60, 0xf1, 0x22, 0x0f, 0x34, 0xff, 0x9c, 0x07, 0x24, 0x6b, 0x6d, 0x47, + 0xd6, 0x53, 0x32, 0xa4, 0xf1, 0x8e, 0x40, 0xd5, 0xea, 0xc6, 0x40, 0x47, 0xa0, 0xca, 0xf4, 0x08, + 0x8f, 0x76, 0xa1, 0x24, 0x43, 0x4b, 0x72, 0x5d, 0xd6, 0x15, 0x71, 0x69, 0x2f, 0x42, 0x9c, 0xf7, + 0x6b, 0x2b, 0x29, 0x35, 0x31, 0x46, 0x74, 0x6b, 0x89, 0x04, 0x74, 0x0d, 0xc0, 0xea, 0xb8, 0xfa, + 0xbc, 0xae, 0x94, 0x4c, 0x6d, 0x92, 0xce, 0x1b, 0x6b, 0x54, 0xe8, 0x65, 0x98, 0x0e, 0x3f, 0x5d, + 0x47, 0x55, 0x14, 0x0d, 0x23, 0xef, 0x9f, 0x84, 0x04, 0xae, 0x5d, 0xf8, 0x33, 0xe3, 0x66, 0xa9, + 0x66, 0x28, 0xd6, 0xbe, 0x1d, 0x63, 0xb0, 0x46, 0x85, 0xbe, 0x05, 0xc5, 0x23, 0x55, 0x8a, 0x8a, + 0x83, 0xc9, 0x1c, 0x22, 0xa3, 0x02, 0x56, 0x8e, 0x0c, 0xa2, 0x2f, 0x1c, 0x4b, 0x43, 0x5f, 0x81, + 0x32, 0xeb, 0x1e, 0xc6, 0xd9, 0x5b, 0x9e, 0x66, 0x9c, 0x2a, 0x0f, 0x12, 0x14, 0xd6, 0xe9, 0xcc, + 0x37, 0xa1, 0xb4, 0xeb, 0xda, 0x34, 0x10, 0x3d, 0xe0, 0x93, 0x30, 0xcb, 0x52, 0x0d, 0x4e, 0x7c, + 0x92, 0x91, 0x97, 0x45, 0x78, 0xee, 0x5e, 0xbe, 0xe5, 0x07, 0xb2, 0x8d, 0x29, 0x24, 0xee, 0xf5, + 0x2a, 0x07, 0x62, 0x89, 0xbb, 0xb1, 0xcc, 0x0b, 0x84, 0x9f, 0xbe, 0x5f, 0x9b, 0x7a, 0xf7, 0xfd, + 0xda, 0xd4, 0x7b, 0xef, 0xab, 0x62, 0xe1, 0x1c, 0x00, 0xf6, 0x0e, 0xbf, 0x47, 0x6c, 0x19, 0x76, + 0x33, 0x8d, 0xf5, 0xa2, 0x69, 0xb2, 0x18, 0xeb, 0xe5, 0x06, 0x8a, 0x3e, 0x0d, 0x87, 0x53, 0x94, + 0x68, 0x1d, 0x4a, 0xf1, 0xc0, 0x4e, 0xf9, 0xc7, 0x52, 0xe4, 0x6f, 0xf1, 0x54, 0x0f, 0x27, 0x34, + 0xa9, 0x1c, 0x30, 0x7d, 0x61, 0x0e, 0x68, 0x40, 0xbe, 0xeb, 0x3a, 0xaa, 0x61, 0x7e, 0x26, 0xca, + 0xc1, 0x77, 0x77, 0x9a, 0xe7, 0xfd, 0xda, 0x63, 0xe3, 0xe6, 0xe4, 0x61, 0xaf, 0x43, 0x58, 0xfd, + 0xee, 0x4e, 0x13, 0x73, 0xe6, 0x51, 0x01, 0x69, 0x66, 0xc2, 0x80, 0x74, 0x0d, 0xa0, 0x95, 0x8c, + 0x1d, 0xe4, 0x7d, 0x8f, 0x1d, 0x51, 0x1b, 0x37, 0x68, 0x54, 0x88, 0xc1, 0x92, 0xcd, 0x5b, 0x73, + 0xd5, 0xfe, 0xb3, 0xd0, 0x6a, 0xcb, 0x41, 0xe6, 0x64, 0x77, 0xe2, 0x8a, 0x52, 0xb3, 0xb4, 0x35, + 0x28, 0x0c, 0x0f, 0xcb, 0x47, 0x01, 0x2c, 0x39, 0xaa, 0x43, 0x4c, 0x94, 0x96, 0x26, 0x56, 0x7a, + 0x99, 0x2b, 0x6c, 0x0e, 0x0a, 0xc2, 0xc3, 0xb2, 0xd1, 0x77, 0x61, 0x25, 0x02, 0x0e, 0xb7, 0xe9, + 0x22, 0x60, 0xe7, 0x1b, 0xab, 0x67, 0xfd, 0xda, 0x4a, 0x73, 0x2c, 0x15, 0x7e, 0x80, 0x04, 0xe4, + 0xc0, 0x8c, 0x27, 0x0b, 0xdc, 0xb2, 0x28, 0x4a, 0xbe, 0x9a, 0x6d, 0x15, 0x89, 0xf7, 0xd7, 0xf5, + 0xc2, 0x36, 0x1e, 0xb9, 0xa8, 0x9a, 0x56, 0xc9, 0x46, 0x6f, 0x41, 0xd9, 0xf2, 0xfd, 0x20, 0xb4, + 0xe4, 0xe0, 0x60, 0x4e, 0xa8, 0xda, 0x9c, 0x58, 0xd5, 0x66, 0x22, 0x63, 0xa0, 0x90, 0xd6, 0x30, + 0x58, 0x57, 0x85, 0xee, 0xc3, 0x42, 0x70, 0xdf, 0x27, 0x14, 0x93, 0x23, 0x42, 0x89, 0x6f, 0x13, + 0x56, 0xad, 0x08, 0xed, 0xcf, 0x66, 0xd4, 0x9e, 0x62, 0x4e, 0x5c, 0x3a, 0x0d, 0x67, 0x78, 0x50, + 0x0b, 0xaa, 0xf3, 0xd8, 0xea, 0x5b, 0x9e, 0xfb, 0x7d, 0x42, 0x59, 0x75, 0x3e, 0x99, 0x35, 0x6f, + 0xc7, 0x50, 0xac, 0x51, 0xf0, 0xe8, 0x67, 0x7b, 0x5d, 0x16, 0x12, 0x39, 0xf8, 0x5f, 0x48, 0x47, + 0xbf, 0xad, 0x04, 0x85, 0x75, 0x3a, 0xd4, 0x85, 0x4a, 0x5b, 0xcf, 0x34, 0xd5, 0x25, 0xb1, 0xba, + 0xeb, 0xd9, 0x56, 0x37, 0x9c, 0x0b, 0x93, 0xc2, 0x27, 0x85, 0xc3, 0x69, 0x2d, 0x2b, 0xcf, 0x43, + 0xf9, 0x53, 0xf6, 0x04, 0xbc, 0xa7, 0x18, 0x3c, 0xc7, 0x89, 0x7a, 0x8a, 0x3f, 0xe6, 0x60, 0x3e, + 0xbd, 0xfb, 0x03, 0x59, 0xb4, 0x90, 0x29, 0x8b, 0x46, 0xdd, 0xab, 0x31, 0xf6, 0xad, 0x22, 0x0a, + 0xeb, 0xf9, 0xb1, 0x61, 0x5d, 0x45, 0xcf, 0xe9, 0x87, 0x89, 0x9e, 0x75, 0x00, 0x5e, 0x9e, 0xd0, + 0xc0, 0xf3, 0x08, 0x15, 0x81, 0xb3, 0xa8, 0xde, 0x24, 0x62, 0x28, 0xd6, 0x28, 0x78, 0x11, 0x7d, + 0xe8, 0x05, 0xf6, 0x89, 0xd8, 0x82, 0xe8, 0xd2, 0x8b, 0x90, 0x59, 0x94, 0x45, 0x74, 0x63, 0x08, + 0x8b, 0x47, 0x70, 0x98, 0x3d, 0xb8, 0xbc, 0x6f, 0xd1, 0xd0, 0xb5, 0xbc, 0xe4, 0x82, 0x89, 0x2e, + 0xe5, 0x8d, 0xa1, 0x1e, 0xe8, 0x99, 0x49, 0x2f, 0x6a, 0xb2, 0xf9, 0x09, 0x2c, 0xe9, 0x83, 0xcc, + 0xbf, 0x1a, 0x70, 0x65, 0xa4, 0xee, 0xcf, 0xa0, 0x07, 0x7b, 0x23, 0xdd, 0x83, 0xbd, 0x90, 0x71, + 0x78, 0x39, 0xca, 0xda, 0x31, 0x1d, 0xd9, 0x2c, 0x14, 0xf6, 0x79, 0xed, 0x6b, 0x7e, 0x68, 0xc0, + 0x9c, 0xf8, 0x35, 0xc9, 0xec, 0xb8, 0x96, 0x7e, 0x52, 0x28, 0x3d, 0xba, 0xe7, 0x84, 0x47, 0x31, + 0x5c, 0x7e, 0xc7, 0x80, 0xf4, 0xd4, 0x16, 0xbd, 0x24, 0xaf, 0x80, 0x11, 0x8f, 0x55, 0x27, 0x74, + 0xff, 0x17, 0xc7, 0x35, 0xa1, 0x97, 0x32, 0xcd, 0x27, 0x9f, 0x82, 0x12, 0x0e, 0x82, 0x70, 0xdf, + 0x0a, 0x8f, 0x19, 0xdf, 0xbb, 0x0e, 0xff, 0xa1, 0xb6, 0x57, 0xec, 0x9d, 0xc0, 0x60, 0x09, 0x37, + 0x7f, 0x6e, 0xc0, 0x95, 0xb1, 0x2f, 0x45, 0x3c, 0x8a, 0xd8, 0xf1, 0x97, 0x5a, 0x51, 0xec, 0xc8, + 0x09, 0x1d, 0xd6, 0xa8, 0x78, 0xf7, 0x98, 0x7a, 0x5e, 0x1a, 0xec, 0x1e, 0x53, 0xda, 0x70, 0x9a, + 0xd6, 0xfc, 0x67, 0x0e, 0xd4, 0xd3, 0xcc, 0x7f, 0xd9, 0xe9, 0x9f, 0x18, 0x78, 0x18, 0x9a, 0x4f, + 0x3f, 0x0c, 0xc5, 0xaf, 0x40, 0xda, 0xcb, 0x48, 0xfe, 0xc1, 0x2f, 0x23, 0xe8, 0xb9, 0xf8, 0xb1, + 0x45, 0xfa, 0xd0, 0x6a, 0xfa, 0xb1, 0xe5, 0xbc, 0x5f, 0x9b, 0x53, 0xc2, 0xd3, 0x8f, 0x2f, 0xaf, + 0xc1, 0xac, 0x43, 0x42, 0xcb, 0xf5, 0x64, 0x27, 0x98, 0xf9, 0xf9, 0x40, 0x0a, 0x6b, 0x4a, 0xd6, + 0x46, 0x99, 0xdb, 0xa4, 0x3e, 0x70, 0x24, 0x90, 0x07, 0x6c, 0x3b, 0x70, 0x64, 0x23, 0x53, 0x48, + 0x02, 0xf6, 0x56, 0xe0, 0x10, 0x2c, 0x30, 0xe6, 0xbb, 0x06, 0x94, 0xa5, 0xa4, 0x2d, 0xab, 0xcb, + 0x08, 0xda, 0x88, 0x57, 0x21, 0x8f, 0xfb, 0x8a, 0xfe, 0xaa, 0x76, 0xde, 0xaf, 0x95, 0x04, 0x99, + 0xe8, 0x81, 0x46, 0xbc, 0x1e, 0xe5, 0x2e, 0xd8, 0xa3, 0xc7, 0xa1, 0x20, 0x2e, 0x90, 0xda, 0xcc, + 0xe4, 0x79, 0x90, 0x03, 0xb1, 0xc4, 0x99, 0x1f, 0xe7, 0xa0, 0x92, 0x5a, 0x5c, 0x86, 0x76, 0x22, + 0x1e, 0x9a, 0xe6, 0x32, 0x0c, 0xe2, 0xc7, 0x3f, 0xc6, 0xab, 0xf4, 0x35, 0xf3, 0x30, 0xe9, 0xeb, + 0xdb, 0x30, 0x63, 0xf3, 0x3d, 0x8a, 0xfe, 0xdb, 0xb1, 0x31, 0xc9, 0x71, 0x8a, 0xdd, 0x4d, 0xbc, + 0x51, 0x7c, 0x32, 0xac, 0x04, 0xa2, 0x5b, 0xb0, 0x44, 0x49, 0x48, 0x7b, 0x9b, 0x47, 0x21, 0xa1, + 0xfa, 0xf8, 0xa0, 0x90, 0x14, 0xed, 0x78, 0x90, 0x00, 0x0f, 0xf3, 0x98, 0x87, 0x30, 0x77, 0xc7, + 0x3a, 0xf4, 0xe2, 0x07, 0x31, 0x0c, 0x15, 0xd7, 0xb7, 0xbd, 0xae, 0x43, 0x64, 0x40, 0x8f, 0xa2, + 0x57, 0x74, 0x69, 0x77, 0x74, 0xe4, 0x79, 0xbf, 0x76, 0x29, 0x05, 0x90, 0x2f, 0x40, 0x38, 0x2d, + 0xc2, 0xf4, 0x60, 0xfa, 0x33, 0x6c, 0x40, 0xbf, 0x03, 0xa5, 0xa4, 0x45, 0x78, 0xc4, 0x2a, 0xcd, + 0x37, 0xa0, 0xc8, 0x3d, 0x3e, 0x6a, 0x6d, 0x2f, 0xa8, 0x92, 0xd2, 0xb5, 0x57, 0x2e, 0x4b, 0xed, + 0x25, 0x9e, 0x55, 0xef, 0x76, 0x9c, 0x87, 0x7c, 0x56, 0xcd, 0x3d, 0x4c, 0xe6, 0xcb, 0x4f, 0x98, + 0xf9, 0xae, 0x81, 0xfc, 0xeb, 0x09, 0x4f, 0x32, 0xb2, 0x80, 0xd0, 0x92, 0x8c, 0x9e, 0xff, 0xb5, + 0x37, 0x85, 0x1f, 0x1b, 0x00, 0x62, 0x78, 0x77, 0xf3, 0x94, 0xf8, 0x61, 0x86, 0x07, 0xfc, 0xbb, + 0x30, 0x13, 0x48, 0x8f, 0x94, 0x4f, 0xab, 0x13, 0x4e, 0x88, 0xe3, 0x8b, 0x24, 0x7d, 0x12, 0x2b, + 0x61, 0x8d, 0xab, 0x1f, 0x7c, 0xb2, 0x3a, 0xf5, 0xe1, 0x27, 0xab, 0x53, 0x1f, 0x7d, 0xb2, 0x3a, + 0xf5, 0xf6, 0xd9, 0xaa, 0xf1, 0xc1, 0xd9, 0xaa, 0xf1, 0xe1, 0xd9, 0xaa, 0xf1, 0xd1, 0xd9, 0xaa, + 0xf1, 0xf1, 0xd9, 0xaa, 0xf1, 0xee, 0xdf, 0x57, 0xa7, 0x5e, 0xcb, 0x9d, 0x6e, 0xfc, 0x27, 0x00, + 0x00, 0xff, 0xff, 0x7e, 0xef, 0x1e, 0xdd, 0xf0, 0x27, 0x00, 0x00, } func (m *APIGroup) Marshal() (dAtA []byte, err error) { @@ -1909,6 +1911,11 @@ func (m *CreateOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + i -= len(m.FieldValidation) + copy(dAtA[i:], m.FieldValidation) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldValidation))) + i-- + dAtA[i] = 0x22 i -= len(m.FieldManager) copy(dAtA[i:], m.FieldManager) i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldManager))) @@ -2982,6 +2989,11 @@ func (m *PatchOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + i -= len(m.FieldValidation) + copy(dAtA[i:], m.FieldValidation) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldValidation))) + i-- + dAtA[i] = 0x22 i -= len(m.FieldManager) copy(dAtA[i:], m.FieldManager) i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldManager))) @@ -3382,6 +3394,11 @@ func (m *UpdateOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + i -= len(m.FieldValidation) + copy(dAtA[i:], m.FieldValidation) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldValidation))) + i-- + dAtA[i] = 0x1a i -= len(m.FieldManager) copy(dAtA[i:], m.FieldManager) i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldManager))) @@ -3648,6 +3665,8 @@ func (m *CreateOptions) Size() (n int) { } l = len(m.FieldManager) n += 1 + l + sovGenerated(uint64(l)) + l = len(m.FieldValidation) + n += 1 + l + sovGenerated(uint64(l)) return n } @@ -4069,6 +4088,8 @@ func (m *PatchOptions) Size() (n int) { } l = len(m.FieldManager) n += 1 + l + sovGenerated(uint64(l)) + l = len(m.FieldValidation) + n += 1 + l + sovGenerated(uint64(l)) return n } @@ -4227,6 +4248,8 @@ func (m *UpdateOptions) Size() (n int) { } l = len(m.FieldManager) n += 1 + l + sovGenerated(uint64(l)) + l = len(m.FieldValidation) + n += 1 + l + sovGenerated(uint64(l)) return n } @@ -4371,6 +4394,7 @@ func (this *CreateOptions) String() string { s := strings.Join([]string{`&CreateOptions{`, `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`, `FieldManager:` + fmt.Sprintf("%v", this.FieldManager) + `,`, + `FieldValidation:` + fmt.Sprintf("%v", this.FieldValidation) + `,`, `}`, }, "") return s @@ -4634,6 +4658,7 @@ func (this *PatchOptions) String() string { `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`, `Force:` + valueToStringGenerated(this.Force) + `,`, `FieldManager:` + fmt.Sprintf("%v", this.FieldManager) + `,`, + `FieldValidation:` + fmt.Sprintf("%v", this.FieldValidation) + `,`, `}`, }, "") return s @@ -4756,6 +4781,7 @@ func (this *UpdateOptions) String() string { s := strings.Join([]string{`&UpdateOptions{`, `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`, `FieldManager:` + fmt.Sprintf("%v", this.FieldManager) + `,`, + `FieldValidation:` + fmt.Sprintf("%v", this.FieldValidation) + `,`, `}`, }, "") return s @@ -6097,6 +6123,38 @@ func (m *CreateOptions) Unmarshal(dAtA []byte) error { } m.FieldManager = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldValidation", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldValidation = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -9824,6 +9882,38 @@ func (m *PatchOptions) Unmarshal(dAtA []byte) error { } m.FieldManager = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldValidation", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldValidation = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -11145,6 +11235,38 @@ func (m *UpdateOptions) Unmarshal(dAtA []byte) error { } m.FieldManager = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldValidation", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldValidation = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto index 7d450644d2..472fcacb10 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto @@ -242,6 +242,19 @@ message CreateOptions { // as defined by https://golang.org/pkg/unicode/#IsPrint. // +optional optional string fieldManager = 3; + + // fieldValidation determines how the server should respond to + // unknown/duplicate fields in the object in the request. + // Introduced as alpha in 1.23, older servers or servers with the + // `ServerSideFieldValidation` feature disabled will discard valid values + // specified in this param and not perform any server side field validation. + // Valid values are: + // - Ignore: ignores unknown/duplicate fields. + // - Warn: responds with a warning for each + // unknown/duplicate field, but successfully serves the request. + // - Strict: fails the request on unknown/duplicate fields. + // +optional + optional string fieldValidation = 4; } // DeleteOptions may be provided when deleting an API object. @@ -362,7 +375,7 @@ message GroupVersionForDiscovery { } // GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion -// to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling +// to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling // // +protobuf.options.(gogoproto.goproto_stringer)=false message GroupVersionKind { @@ -374,7 +387,7 @@ message GroupVersionKind { } // GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion -// to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling +// to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling // // +protobuf.options.(gogoproto.goproto_stringer)=false message GroupVersionResource { @@ -878,6 +891,19 @@ message PatchOptions { // types (JsonPatch, MergePatch, StrategicMergePatch). // +optional optional string fieldManager = 3; + + // fieldValidation determines how the server should respond to + // unknown/duplicate fields in the object in the request. + // Introduced as alpha in 1.23, older servers or servers with the + // `ServerSideFieldValidation` feature disabled will discard valid values + // specified in this param and not perform any server side field validation. + // Valid values are: + // - Ignore: ignores unknown/duplicate fields. + // - Warn: responds with a warning for each + // unknown/duplicate field, but successfully serves the request. + // - Strict: fails the request on unknown/duplicate fields. + // +optional + optional string fieldValidation = 4; } // Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out. @@ -1095,6 +1121,19 @@ message UpdateOptions { // as defined by https://golang.org/pkg/unicode/#IsPrint. // +optional optional string fieldManager = 2; + + // fieldValidation determines how the server should respond to + // unknown/duplicate fields in the object in the request. + // Introduced as alpha in 1.23, older servers or servers with the + // `ServerSideFieldValidation` feature disabled will discard valid values + // specified in this param and not perform any server side field validation. + // Valid values are: + // - Ignore: ignores unknown/duplicate fields. + // - Warn: responds with a warning for each + // unknown/duplicate field, but successfully serves the request. + // - Strict: fails the request on unknown/duplicate fields. + // +optional + optional string fieldValidation = 3; } // Verbs masks the value so protobuf can generate diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/group_version.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/group_version.go index 54a0944af1..fc9e521e21 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/group_version.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/group_version.go @@ -44,7 +44,7 @@ func (gr *GroupResource) String() string { } // GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion -// to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling +// to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling // // +protobuf.options.(gogoproto.goproto_stringer)=false type GroupVersionResource struct { @@ -80,7 +80,7 @@ func (gk *GroupKind) String() string { } // GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion -// to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling +// to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling // // +protobuf.options.(gogoproto.goproto_stringer)=false type GroupVersionKind struct { diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/micro_time_fuzz.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/micro_time_fuzz.go index befab16f72..3cf9d48e96 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/micro_time_fuzz.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/micro_time_fuzz.go @@ -1,3 +1,4 @@ +//go:build !notest // +build !notest /* diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/time_fuzz.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/time_fuzz.go index 94ad8d7cf4..bf9e21b5bd 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/time_fuzz.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/time_fuzz.go @@ -1,3 +1,4 @@ +//go:build !notest // +build !notest /* diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types.go index 9660282c48..f9c27c146d 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types.go @@ -522,6 +522,15 @@ type DeleteOptions struct { DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,5,rep,name=dryRun"` } +const ( + // FieldValidationIgnore ignores unknown/duplicate fields + FieldValidationIgnore = "Ignore" + // FieldValidationWarn responds with a warning, but successfully serve the request + FieldValidationWarn = "Warn" + // FieldValidationStrict fails the request on unknown/duplicate fields + FieldValidationStrict = "Strict" +) + // +k8s:conversion-gen:explicit-from=net/url.Values // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object @@ -544,6 +553,19 @@ type CreateOptions struct { // as defined by https://golang.org/pkg/unicode/#IsPrint. // +optional FieldManager string `json:"fieldManager,omitempty" protobuf:"bytes,3,name=fieldManager"` + + // fieldValidation determines how the server should respond to + // unknown/duplicate fields in the object in the request. + // Introduced as alpha in 1.23, older servers or servers with the + // `ServerSideFieldValidation` feature disabled will discard valid values + // specified in this param and not perform any server side field validation. + // Valid values are: + // - Ignore: ignores unknown/duplicate fields. + // - Warn: responds with a warning for each + // unknown/duplicate field, but successfully serves the request. + // - Strict: fails the request on unknown/duplicate fields. + // +optional + FieldValidation string `json:"fieldValidation,omitempty" protobuf:"bytes,4,name=fieldValidation"` } // +k8s:conversion-gen:explicit-from=net/url.Values @@ -577,6 +599,19 @@ type PatchOptions struct { // types (JsonPatch, MergePatch, StrategicMergePatch). // +optional FieldManager string `json:"fieldManager,omitempty" protobuf:"bytes,3,name=fieldManager"` + + // fieldValidation determines how the server should respond to + // unknown/duplicate fields in the object in the request. + // Introduced as alpha in 1.23, older servers or servers with the + // `ServerSideFieldValidation` feature disabled will discard valid values + // specified in this param and not perform any server side field validation. + // Valid values are: + // - Ignore: ignores unknown/duplicate fields. + // - Warn: responds with a warning for each + // unknown/duplicate field, but successfully serves the request. + // - Strict: fails the request on unknown/duplicate fields. + // +optional + FieldValidation string `json:"fieldValidation,omitempty" protobuf:"bytes,4,name=fieldValidation"` } // ApplyOptions may be provided when applying an API object. @@ -632,6 +667,19 @@ type UpdateOptions struct { // as defined by https://golang.org/pkg/unicode/#IsPrint. // +optional FieldManager string `json:"fieldManager,omitempty" protobuf:"bytes,2,name=fieldManager"` + + // fieldValidation determines how the server should respond to + // unknown/duplicate fields in the object in the request. + // Introduced as alpha in 1.23, older servers or servers with the + // `ServerSideFieldValidation` feature disabled will discard valid values + // specified in this param and not perform any server side field validation. + // Valid values are: + // - Ignore: ignores unknown/duplicate fields. + // - Warn: responds with a warning for each + // unknown/duplicate field, but successfully serves the request. + // - Strict: fails the request on unknown/duplicate fields. + // +optional + FieldValidation string `json:"fieldValidation,omitempty" protobuf:"bytes,3,name=fieldValidation"` } // Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out. diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types_swagger_doc_generated.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types_swagger_doc_generated.go index 3eae04d072..088ff01f0b 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types_swagger_doc_generated.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types_swagger_doc_generated.go @@ -112,9 +112,10 @@ func (Condition) SwaggerDoc() map[string]string { } var map_CreateOptions = map[string]string{ - "": "CreateOptions may be provided when creating an API object.", - "dryRun": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", - "fieldManager": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "": "CreateOptions may be provided when creating an API object.", + "dryRun": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "fieldManager": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "fieldValidation": "fieldValidation determines how the server should respond to unknown/duplicate fields in the object in the request. Introduced as alpha in 1.23, older servers or servers with the `ServerSideFieldValidation` feature disabled will discard valid values specified in this param and not perform any server side field validation. Valid values are: - Ignore: ignores unknown/duplicate fields. - Warn: responds with a warning for each unknown/duplicate field, but successfully serves the request. - Strict: fails the request on unknown/duplicate fields.", } func (CreateOptions) SwaggerDoc() map[string]string { @@ -302,10 +303,11 @@ func (Patch) SwaggerDoc() map[string]string { } var map_PatchOptions = map[string]string{ - "": "PatchOptions may be provided when patching an API object. PatchOptions is meant to be a superset of UpdateOptions.", - "dryRun": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", - "force": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", - "fieldManager": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "": "PatchOptions may be provided when patching an API object. PatchOptions is meant to be a superset of UpdateOptions.", + "dryRun": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "force": "Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.", + "fieldManager": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).", + "fieldValidation": "fieldValidation determines how the server should respond to unknown/duplicate fields in the object in the request. Introduced as alpha in 1.23, older servers or servers with the `ServerSideFieldValidation` feature disabled will discard valid values specified in this param and not perform any server side field validation. Valid values are: - Ignore: ignores unknown/duplicate fields. - Warn: responds with a warning for each unknown/duplicate field, but successfully serves the request. - Strict: fails the request on unknown/duplicate fields.", } func (PatchOptions) SwaggerDoc() map[string]string { @@ -447,9 +449,10 @@ func (TypeMeta) SwaggerDoc() map[string]string { } var map_UpdateOptions = map[string]string{ - "": "UpdateOptions may be provided when updating an API object. All fields in UpdateOptions should also be present in PatchOptions.", - "dryRun": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", - "fieldManager": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "": "UpdateOptions may be provided when updating an API object. All fields in UpdateOptions should also be present in PatchOptions.", + "dryRun": "When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed", + "fieldManager": "fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.", + "fieldValidation": "fieldValidation determines how the server should respond to unknown/duplicate fields in the object in the request. Introduced as alpha in 1.23, older servers or servers with the `ServerSideFieldValidation` feature disabled will discard valid values specified in this param and not perform any server side field validation. Valid values are: - Ignore: ignores unknown/duplicate fields. - Warn: responds with a warning for each unknown/duplicate field, but successfully serves the request. - Strict: fails the request on unknown/duplicate fields.", } func (UpdateOptions) SwaggerDoc() map[string]string { diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/helpers.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/helpers.go index 7b101ea512..d26c6cff4e 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/helpers.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/helpers.go @@ -382,7 +382,7 @@ func (unstructuredJSONScheme) Identifier() runtime.Identifier { func (s unstructuredJSONScheme) decode(data []byte) (runtime.Object, error) { type detector struct { - Items gojson.RawMessage + Items gojson.RawMessage `json:"items"` } var det detector if err := json.Unmarshal(data, &det); err != nil { @@ -425,7 +425,7 @@ func (unstructuredJSONScheme) decodeToUnstructured(data []byte, unstruct *Unstru func (s unstructuredJSONScheme) decodeToList(data []byte, list *UnstructuredList) error { type decodeList struct { - Items []gojson.RawMessage + Items []gojson.RawMessage `json:"items"` } var dList decodeList diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/zz_generated.deepcopy.go index 9a9f25e8f2..fe8250dd6f 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go index bd82a9d651..4c09898b8b 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go @@ -96,17 +96,19 @@ func ValidateDeleteOptions(options *metav1.DeleteOptions) field.ErrorList { } func ValidateCreateOptions(options *metav1.CreateOptions) field.ErrorList { - return append( - ValidateFieldManager(options.FieldManager, field.NewPath("fieldManager")), - ValidateDryRun(field.NewPath("dryRun"), options.DryRun)..., - ) + allErrs := field.ErrorList{} + allErrs = append(allErrs, ValidateFieldManager(options.FieldManager, field.NewPath("fieldManager"))...) + allErrs = append(allErrs, ValidateDryRun(field.NewPath("dryRun"), options.DryRun)...) + allErrs = append(allErrs, ValidateFieldValidation(field.NewPath("fieldValidation"), options.FieldValidation)...) + return allErrs } func ValidateUpdateOptions(options *metav1.UpdateOptions) field.ErrorList { - return append( - ValidateFieldManager(options.FieldManager, field.NewPath("fieldManager")), - ValidateDryRun(field.NewPath("dryRun"), options.DryRun)..., - ) + allErrs := field.ErrorList{} + allErrs = append(allErrs, ValidateFieldManager(options.FieldManager, field.NewPath("fieldManager"))...) + allErrs = append(allErrs, ValidateDryRun(field.NewPath("dryRun"), options.DryRun)...) + allErrs = append(allErrs, ValidateFieldValidation(field.NewPath("fieldValidation"), options.FieldValidation)...) + return allErrs } func ValidatePatchOptions(options *metav1.PatchOptions, patchType types.PatchType) field.ErrorList { @@ -123,6 +125,7 @@ func ValidatePatchOptions(options *metav1.PatchOptions, patchType types.PatchTyp } allErrs = append(allErrs, ValidateFieldManager(options.FieldManager, field.NewPath("fieldManager"))...) allErrs = append(allErrs, ValidateDryRun(field.NewPath("dryRun"), options.DryRun)...) + allErrs = append(allErrs, ValidateFieldValidation(field.NewPath("fieldValidation"), options.FieldValidation)...) return allErrs } @@ -159,6 +162,18 @@ func ValidateDryRun(fldPath *field.Path, dryRun []string) field.ErrorList { return allErrs } +var allowedFieldValidationValues = sets.NewString("", metav1.FieldValidationIgnore, metav1.FieldValidationWarn, metav1.FieldValidationStrict) + +// ValidateFieldValidation validates that a fieldValidation query param only contains allowed values. +func ValidateFieldValidation(fldPath *field.Path, fieldValidation string) field.ErrorList { + allErrs := field.ErrorList{} + if !allowedFieldValidationValues.Has(fieldValidation) { + allErrs = append(allErrs, field.NotSupported(fldPath, fieldValidation, allowedFieldValidationValues.List())) + } + return allErrs + +} + const UninitializedStatusUpdateErrorMsg string = `must not update status when the object is uninitialized` // ValidateTableOptions returns any invalid flags on TableOptions. diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.conversion.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.conversion.go index 3ecb67c827..b7590f0b31 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.conversion.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -293,6 +294,13 @@ func autoConvert_url_Values_To_v1_CreateOptions(in *url.Values, out *CreateOptio } else { out.FieldManager = "" } + if values, ok := map[string][]string(*in)["fieldValidation"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.FieldValidation, s); err != nil { + return err + } + } else { + out.FieldValidation = "" + } return nil } @@ -448,6 +456,13 @@ func autoConvert_url_Values_To_v1_PatchOptions(in *url.Values, out *PatchOptions } else { out.FieldManager = "" } + if values, ok := map[string][]string(*in)["fieldValidation"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.FieldValidation, s); err != nil { + return err + } + } else { + out.FieldValidation = "" + } return nil } @@ -496,6 +511,13 @@ func autoConvert_url_Values_To_v1_UpdateOptions(in *url.Values, out *UpdateOptio } else { out.FieldManager = "" } + if values, ok := map[string][]string(*in)["fieldValidation"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.FieldValidation, s); err != nil { + return err + } + } else { + out.FieldValidation = "" + } return nil } diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.deepcopy.go index d43020da57..418e6099f4 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.defaults.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.defaults.go index cce2e603a6..dac177e93b 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.defaults.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1/zz_generated.deepcopy.go index 89053b9819..972b7f03ea 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1/zz_generated.defaults.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1/zz_generated.defaults.go index 73e63fc114..198b5be4af 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1/zz_generated.defaults.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apimachinery/pkg/conversion/converter.go b/vendor/k8s.io/apimachinery/pkg/conversion/converter.go index 7913484764..ed51a25e33 100644 --- a/vendor/k8s.io/apimachinery/pkg/conversion/converter.go +++ b/vendor/k8s.io/apimachinery/pkg/conversion/converter.go @@ -44,23 +44,16 @@ type Converter struct { generatedConversionFuncs ConversionFuncs // Set of conversions that should be treated as a no-op - ignoredConversions map[typePair]struct{} ignoredUntypedConversions map[typePair]struct{} - - // nameFunc is called to retrieve the name of a type; this name is used for the - // purpose of deciding whether two types match or not (i.e., will we attempt to - // do a conversion). The default returns the go type name. - nameFunc func(t reflect.Type) string } // NewConverter creates a new Converter object. -func NewConverter(nameFn NameFunc) *Converter { +// Arg NameFunc is just for backward compatibility. +func NewConverter(NameFunc) *Converter { c := &Converter{ conversionFuncs: NewConversionFuncs(), generatedConversionFuncs: NewConversionFuncs(), - ignoredConversions: make(map[typePair]struct{}), ignoredUntypedConversions: make(map[typePair]struct{}), - nameFunc: nameFn, } c.RegisterUntypedConversionFunc( (*[]byte)(nil), (*[]byte)(nil), @@ -192,7 +185,6 @@ func (c *Converter) RegisterIgnoredConversion(from, to interface{}) error { if typeTo.Kind() != reflect.Ptr { return fmt.Errorf("expected pointer arg for 'to' param 1, got: %v", typeTo) } - c.ignoredConversions[typePair{typeFrom.Elem(), typeTo.Elem()}] = struct{}{} c.ignoredUntypedConversions[typePair{typeFrom, typeTo}] = struct{}{} return nil } diff --git a/vendor/k8s.io/apimachinery/pkg/labels/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/labels/zz_generated.deepcopy.go index 4d482947fc..fdf4c31e1e 100644 --- a/vendor/k8s.io/apimachinery/pkg/labels/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apimachinery/pkg/labels/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/converter.go b/vendor/k8s.io/apimachinery/pkg/runtime/converter.go index 4a6cc68574..b99492a891 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/converter.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/converter.go @@ -22,6 +22,7 @@ import ( "math" "os" "reflect" + "sort" "strconv" "strings" "sync" @@ -109,21 +110,141 @@ type unstructuredConverter struct { // to Go types via reflection. It performs mismatch detection automatically and is intended for use by external // test tools. Use DefaultUnstructuredConverter if you do not explicitly need mismatch detection. func NewTestUnstructuredConverter(comparison conversion.Equalities) UnstructuredConverter { + return NewTestUnstructuredConverterWithValidation(comparison) +} + +// NewTestUnstrucutredConverterWithValidation allows for access to +// FromUnstructuredWithValidation from within tests. +func NewTestUnstructuredConverterWithValidation(comparison conversion.Equalities) *unstructuredConverter { return &unstructuredConverter{ mismatchDetection: true, comparison: comparison, } } -// FromUnstructured converts an object from map[string]interface{} representation into a concrete type. +// fromUnstructuredContext provides options for informing the converter +// the state of its recursive walk through the conversion process. +type fromUnstructuredContext struct { + // isInlined indicates whether the converter is currently in + // an inlined field or not to determine whether it should + // validate the matchedKeys yet or only collect them. + // This should only be set from `structFromUnstructured` + isInlined bool + // matchedKeys is a stack of the set of all fields that exist in the + // concrete go type of the object being converted into. + // This should only be manipulated via `pushMatchedKeyTracker`, + // `recordMatchedKey`, or `popAndVerifyMatchedKeys` + matchedKeys []map[string]struct{} + // parentPath collects the path that the conversion + // takes as it traverses the unstructured json map. + // It is used to report the full path to any unknown + // fields that the converter encounters. + parentPath []string + // returnUnknownFields indicates whether or not + // unknown field errors should be collected and + // returned to the caller + returnUnknownFields bool + // unknownFieldErrors are the collection of + // the full path to each unknown field in the + // object. + unknownFieldErrors []error +} + +// pushMatchedKeyTracker adds a placeholder set for tracking +// matched keys for the given level. This should only be +// called from `structFromUnstructured`. +func (c *fromUnstructuredContext) pushMatchedKeyTracker() { + if !c.returnUnknownFields { + return + } + + c.matchedKeys = append(c.matchedKeys, nil) +} + +// recordMatchedKey initializes the last element of matchedKeys +// (if needed) and sets 'key'. This should only be called from +// `structFromUnstructured`. +func (c *fromUnstructuredContext) recordMatchedKey(key string) { + if !c.returnUnknownFields { + return + } + + last := len(c.matchedKeys) - 1 + if c.matchedKeys[last] == nil { + c.matchedKeys[last] = map[string]struct{}{} + } + c.matchedKeys[last][key] = struct{}{} +} + +// popAndVerifyMatchedKeys pops the last element of matchedKeys, +// checks the matched keys against the data, and adds unknown +// field errors for any matched keys. +// `mapValue` is the value of sv containing all of the keys that exist at this level +// (ie. sv.MapKeys) in the source data. +// `matchedKeys` are all the keys found for that level in the destination object. +// This should only be called from `structFromUnstructured`. +func (c *fromUnstructuredContext) popAndVerifyMatchedKeys(mapValue reflect.Value) { + if !c.returnUnknownFields { + return + } + + last := len(c.matchedKeys) - 1 + curMatchedKeys := c.matchedKeys[last] + c.matchedKeys[last] = nil + c.matchedKeys = c.matchedKeys[:last] + for _, key := range mapValue.MapKeys() { + if _, ok := curMatchedKeys[key.String()]; !ok { + c.recordUnknownField(key.String()) + } + } +} + +func (c *fromUnstructuredContext) recordUnknownField(field string) { + if !c.returnUnknownFields { + return + } + + pathLen := len(c.parentPath) + c.pushKey(field) + errPath := strings.Join(c.parentPath, "") + c.parentPath = c.parentPath[:pathLen] + c.unknownFieldErrors = append(c.unknownFieldErrors, fmt.Errorf(`unknown field "%s"`, errPath)) +} + +func (c *fromUnstructuredContext) pushIndex(index int) { + if !c.returnUnknownFields { + return + } + + c.parentPath = append(c.parentPath, "[", strconv.Itoa(index), "]") +} + +func (c *fromUnstructuredContext) pushKey(key string) { + if !c.returnUnknownFields { + return + } + + if len(c.parentPath) > 0 { + c.parentPath = append(c.parentPath, ".") + } + c.parentPath = append(c.parentPath, key) + +} + +// FromUnstructuredWIthValidation converts an object from map[string]interface{} representation into a concrete type. // It uses encoding/json/Unmarshaler if object implements it or reflection if not. -func (c *unstructuredConverter) FromUnstructured(u map[string]interface{}, obj interface{}) error { +// It takes a validationDirective that indicates how to behave when it encounters unknown fields. +func (c *unstructuredConverter) FromUnstructuredWithValidation(u map[string]interface{}, obj interface{}, returnUnknownFields bool) error { t := reflect.TypeOf(obj) value := reflect.ValueOf(obj) if t.Kind() != reflect.Ptr || value.IsNil() { return fmt.Errorf("FromUnstructured requires a non-nil pointer to an object, got %v", t) } - err := fromUnstructured(reflect.ValueOf(u), value.Elem()) + + fromUnstructuredContext := &fromUnstructuredContext{ + returnUnknownFields: returnUnknownFields, + } + err := fromUnstructured(reflect.ValueOf(u), value.Elem(), fromUnstructuredContext) if c.mismatchDetection { newObj := reflect.New(t.Elem()).Interface() newErr := fromUnstructuredViaJSON(u, newObj) @@ -134,7 +255,23 @@ func (c *unstructuredConverter) FromUnstructured(u map[string]interface{}, obj i klog.Fatalf("FromUnstructured mismatch\nobj1: %#v\nobj2: %#v", obj, newObj) } } - return err + if err != nil { + return err + } + if returnUnknownFields && len(fromUnstructuredContext.unknownFieldErrors) > 0 { + sort.Slice(fromUnstructuredContext.unknownFieldErrors, func(i, j int) bool { + return fromUnstructuredContext.unknownFieldErrors[i].Error() < + fromUnstructuredContext.unknownFieldErrors[j].Error() + }) + return NewStrictDecodingError(fromUnstructuredContext.unknownFieldErrors) + } + return nil +} + +// FromUnstructured converts an object from map[string]interface{} representation into a concrete type. +// It uses encoding/json/Unmarshaler if object implements it or reflection if not. +func (c *unstructuredConverter) FromUnstructured(u map[string]interface{}, obj interface{}) error { + return c.FromUnstructuredWithValidation(u, obj, false) } func fromUnstructuredViaJSON(u map[string]interface{}, obj interface{}) error { @@ -145,7 +282,7 @@ func fromUnstructuredViaJSON(u map[string]interface{}, obj interface{}) error { return json.Unmarshal(data, obj) } -func fromUnstructured(sv, dv reflect.Value) error { +func fromUnstructured(sv, dv reflect.Value, ctx *fromUnstructuredContext) error { sv = unwrapInterface(sv) if !sv.IsValid() { dv.Set(reflect.Zero(dv.Type())) @@ -213,18 +350,19 @@ func fromUnstructured(sv, dv reflect.Value) error { switch dt.Kind() { case reflect.Map: - return mapFromUnstructured(sv, dv) + return mapFromUnstructured(sv, dv, ctx) case reflect.Slice: - return sliceFromUnstructured(sv, dv) + return sliceFromUnstructured(sv, dv, ctx) case reflect.Ptr: - return pointerFromUnstructured(sv, dv) + return pointerFromUnstructured(sv, dv, ctx) case reflect.Struct: - return structFromUnstructured(sv, dv) + return structFromUnstructured(sv, dv, ctx) case reflect.Interface: return interfaceFromUnstructured(sv, dv) default: return fmt.Errorf("unrecognized type: %v", dt.Kind()) } + } func fieldInfoFromField(structType reflect.Type, field int) *fieldInfo { @@ -275,7 +413,7 @@ func unwrapInterface(v reflect.Value) reflect.Value { return v } -func mapFromUnstructured(sv, dv reflect.Value) error { +func mapFromUnstructured(sv, dv reflect.Value, ctx *fromUnstructuredContext) error { st, dt := sv.Type(), dv.Type() if st.Kind() != reflect.Map { return fmt.Errorf("cannot restore map from %v", st.Kind()) @@ -293,7 +431,7 @@ func mapFromUnstructured(sv, dv reflect.Value) error { for _, key := range sv.MapKeys() { value := reflect.New(dt.Elem()).Elem() if val := unwrapInterface(sv.MapIndex(key)); val.IsValid() { - if err := fromUnstructured(val, value); err != nil { + if err := fromUnstructured(val, value, ctx); err != nil { return err } } else { @@ -308,7 +446,7 @@ func mapFromUnstructured(sv, dv reflect.Value) error { return nil } -func sliceFromUnstructured(sv, dv reflect.Value) error { +func sliceFromUnstructured(sv, dv reflect.Value, ctx *fromUnstructuredContext) error { st, dt := sv.Type(), dv.Type() if st.Kind() == reflect.String && dt.Elem().Kind() == reflect.Uint8 { // We store original []byte representation as string. @@ -340,15 +478,22 @@ func sliceFromUnstructured(sv, dv reflect.Value) error { return nil } dv.Set(reflect.MakeSlice(dt, sv.Len(), sv.Cap())) + + pathLen := len(ctx.parentPath) + defer func() { + ctx.parentPath = ctx.parentPath[:pathLen] + }() for i := 0; i < sv.Len(); i++ { - if err := fromUnstructured(sv.Index(i), dv.Index(i)); err != nil { + ctx.pushIndex(i) + if err := fromUnstructured(sv.Index(i), dv.Index(i), ctx); err != nil { return err } + ctx.parentPath = ctx.parentPath[:pathLen] } return nil } -func pointerFromUnstructured(sv, dv reflect.Value) error { +func pointerFromUnstructured(sv, dv reflect.Value, ctx *fromUnstructuredContext) error { st, dt := sv.Type(), dv.Type() if st.Kind() == reflect.Ptr && sv.IsNil() { @@ -358,38 +503,63 @@ func pointerFromUnstructured(sv, dv reflect.Value) error { dv.Set(reflect.New(dt.Elem())) switch st.Kind() { case reflect.Ptr, reflect.Interface: - return fromUnstructured(sv.Elem(), dv.Elem()) + return fromUnstructured(sv.Elem(), dv.Elem(), ctx) default: - return fromUnstructured(sv, dv.Elem()) + return fromUnstructured(sv, dv.Elem(), ctx) } } -func structFromUnstructured(sv, dv reflect.Value) error { +func structFromUnstructured(sv, dv reflect.Value, ctx *fromUnstructuredContext) error { st, dt := sv.Type(), dv.Type() if st.Kind() != reflect.Map { return fmt.Errorf("cannot restore struct from: %v", st.Kind()) } + pathLen := len(ctx.parentPath) + svInlined := ctx.isInlined + defer func() { + ctx.parentPath = ctx.parentPath[:pathLen] + ctx.isInlined = svInlined + }() + if !svInlined { + ctx.pushMatchedKeyTracker() + } for i := 0; i < dt.NumField(); i++ { fieldInfo := fieldInfoFromField(dt, i) fv := dv.Field(i) if len(fieldInfo.name) == 0 { - // This field is inlined. - if err := fromUnstructured(sv, fv); err != nil { + // This field is inlined, recurse into fromUnstructured again + // with the same set of matched keys. + ctx.isInlined = true + if err := fromUnstructured(sv, fv, ctx); err != nil { return err } + ctx.isInlined = svInlined } else { + // This field is not inlined so we recurse into + // child field of sv corresponding to field i of + // dv, with a new set of matchedKeys and updating + // the parentPath to indicate that we are one level + // deeper. + ctx.recordMatchedKey(fieldInfo.name) value := unwrapInterface(sv.MapIndex(fieldInfo.nameValue)) if value.IsValid() { - if err := fromUnstructured(value, fv); err != nil { + ctx.isInlined = false + ctx.pushKey(fieldInfo.name) + if err := fromUnstructured(value, fv, ctx); err != nil { return err } + ctx.parentPath = ctx.parentPath[:pathLen] + ctx.isInlined = svInlined } else { fv.Set(reflect.Zero(fv.Type())) } } } + if !svInlined { + ctx.popAndVerifyMatchedKeys(sv) + } return nil } diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/error.go b/vendor/k8s.io/apimachinery/pkg/runtime/error.go index be0c5edc85..7dfa45762f 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/error.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/error.go @@ -19,6 +19,7 @@ package runtime import ( "fmt" "reflect" + "strings" "k8s.io/apimachinery/pkg/runtime/schema" ) @@ -124,20 +125,30 @@ func IsMissingVersion(err error) bool { // strictDecodingError is a base error type that is returned by a strict Decoder such // as UniversalStrictDecoder. type strictDecodingError struct { - message string - data string + errors []error } // NewStrictDecodingError creates a new strictDecodingError object. -func NewStrictDecodingError(message string, data string) error { +func NewStrictDecodingError(errors []error) error { return &strictDecodingError{ - message: message, - data: data, + errors: errors, } } func (e *strictDecodingError) Error() string { - return fmt.Sprintf("strict decoder error for %s: %s", e.data, e.message) + var s strings.Builder + s.WriteString("strict decoding error: ") + for i, err := range e.errors { + if i != 0 { + s.WriteString(", ") + } + s.WriteString(err.Error()) + } + return s.String() +} + +func (e *strictDecodingError) Errors() []error { + return e.errors } // IsStrictDecodingError returns true if the error indicates that the provided object @@ -149,3 +160,13 @@ func IsStrictDecodingError(err error) bool { _, ok := err.(*strictDecodingError) return ok } + +// AsStrictDecodingError returns a strict decoding error +// containing all the strictness violations. +func AsStrictDecodingError(err error) (*strictDecodingError, bool) { + if err == nil { + return nil, false + } + strictErr, ok := err.(*strictDecodingError) + return strictErr, ok +} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go b/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go index 3e1fab1d11..b324b76c67 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go @@ -125,6 +125,9 @@ type SerializerInfo struct { // PrettySerializer, if set, can serialize this object in a form biased towards // readability. PrettySerializer Serializer + // StrictSerializer, if set, deserializes this object strictly, + // erring on unknown fields. + StrictSerializer Serializer // StreamSerializer, if set, describes the streaming serialization format // for this media type. StreamSerializer *StreamSerializerInfo diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go b/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go index ae47ab3aba..f5da6b12f4 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go @@ -99,7 +99,7 @@ func NewScheme() *Scheme { versionPriority: map[string][]string{}, schemeName: naming.GetNameFromCallsite(internalPackages...), } - s.converter = conversion.NewConverter(s.nameFunc) + s.converter = conversion.NewConverter(nil) // Enable couple default conversions by default. utilruntime.Must(RegisterEmbeddedConversions(s)) @@ -107,28 +107,6 @@ func NewScheme() *Scheme { return s } -// nameFunc returns the name of the type that we wish to use to determine when two types attempt -// a conversion. Defaults to the go name of the type if the type is not registered. -func (s *Scheme) nameFunc(t reflect.Type) string { - // find the preferred names for this type - gvks, ok := s.typeToGVK[t] - if !ok { - return t.Name() - } - - for _, gvk := range gvks { - internalGV := gvk.GroupVersion() - internalGV.Version = APIVersionInternal // this is hacky and maybe should be passed in - internalGVK := internalGV.WithKind(gvk.Kind) - - if internalType, exists := s.gvkToType[internalGVK]; exists { - return s.typeToGVK[internalType][0].Kind - } - } - - return gvks[0].Kind -} - // Converter allows access to the converter for the scheme func (s *Scheme) Converter() *conversion.Converter { return s.converter diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/codec_factory.go b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/codec_factory.go index e55ab94d14..9de35e791c 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/codec_factory.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/codec_factory.go @@ -40,6 +40,7 @@ type serializerType struct { Serializer runtime.Serializer PrettySerializer runtime.Serializer + StrictSerializer runtime.Serializer AcceptStreamContentTypes []string StreamContentType string @@ -70,10 +71,20 @@ func newSerializersForScheme(scheme *runtime.Scheme, mf json.MetaFactory, option ) } + strictJSONSerializer := json.NewSerializerWithOptions( + mf, scheme, scheme, + json.SerializerOptions{Yaml: false, Pretty: false, Strict: true}, + ) + jsonSerializerType.StrictSerializer = strictJSONSerializer + yamlSerializer := json.NewSerializerWithOptions( mf, scheme, scheme, json.SerializerOptions{Yaml: true, Pretty: false, Strict: options.Strict}, ) + strictYAMLSerializer := json.NewSerializerWithOptions( + mf, scheme, scheme, + json.SerializerOptions{Yaml: true, Pretty: false, Strict: true}, + ) protoSerializer := protobuf.NewSerializer(scheme, scheme) protoRawSerializer := protobuf.NewRawSerializer(scheme, scheme) @@ -85,12 +96,16 @@ func newSerializersForScheme(scheme *runtime.Scheme, mf json.MetaFactory, option FileExtensions: []string{"yaml"}, EncodesAsText: true, Serializer: yamlSerializer, + StrictSerializer: strictYAMLSerializer, }, { AcceptContentTypes: []string{runtime.ContentTypeProtobuf}, ContentType: runtime.ContentTypeProtobuf, FileExtensions: []string{"pb"}, Serializer: protoSerializer, + // note, strict decoding is unsupported for protobuf, + // fall back to regular serializing + StrictSerializer: protoSerializer, Framer: protobuf.LengthDelimitedFramer, StreamSerializer: protoRawSerializer, @@ -187,6 +202,7 @@ func newCodecFactory(scheme *runtime.Scheme, serializers []serializerType) Codec EncodesAsText: d.EncodesAsText, Serializer: d.Serializer, PrettySerializer: d.PrettySerializer, + StrictSerializer: d.StrictSerializer, } mediaType, _, err := mime.ParseMediaType(info.MediaType) diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/json/json.go b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/json/json.go index 48f0777b24..6c082f660e 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/json/json.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/json/json.go @@ -20,10 +20,8 @@ import ( "encoding/json" "io" "strconv" - "unsafe" - jsoniter "github.com/json-iterator/go" - "github.com/modern-go/reflect2" + kjson "sigs.k8s.io/json" "sigs.k8s.io/yaml" "k8s.io/apimachinery/pkg/runtime" @@ -68,6 +66,7 @@ func identifier(options SerializerOptions) runtime.Identifier { "name": "json", "yaml": strconv.FormatBool(options.Yaml), "pretty": strconv.FormatBool(options.Pretty), + "strict": strconv.FormatBool(options.Strict), } identifier, err := json.Marshal(result) if err != nil { @@ -110,79 +109,6 @@ type Serializer struct { var _ runtime.Serializer = &Serializer{} var _ recognizer.RecognizingDecoder = &Serializer{} -type customNumberExtension struct { - jsoniter.DummyExtension -} - -func (cne *customNumberExtension) CreateDecoder(typ reflect2.Type) jsoniter.ValDecoder { - if typ.String() == "interface {}" { - return customNumberDecoder{} - } - return nil -} - -type customNumberDecoder struct { -} - -func (customNumberDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) { - switch iter.WhatIsNext() { - case jsoniter.NumberValue: - var number jsoniter.Number - iter.ReadVal(&number) - i64, err := strconv.ParseInt(string(number), 10, 64) - if err == nil { - *(*interface{})(ptr) = i64 - return - } - f64, err := strconv.ParseFloat(string(number), 64) - if err == nil { - *(*interface{})(ptr) = f64 - return - } - iter.ReportError("DecodeNumber", err.Error()) - default: - *(*interface{})(ptr) = iter.Read() - } -} - -// CaseSensitiveJSONIterator returns a jsoniterator API that's configured to be -// case-sensitive when unmarshalling, and otherwise compatible with -// the encoding/json standard library. -func CaseSensitiveJSONIterator() jsoniter.API { - config := jsoniter.Config{ - EscapeHTML: true, - SortMapKeys: true, - ValidateJsonRawMessage: true, - CaseSensitive: true, - }.Froze() - // Force jsoniter to decode number to interface{} via int64/float64, if possible. - config.RegisterExtension(&customNumberExtension{}) - return config -} - -// StrictCaseSensitiveJSONIterator returns a jsoniterator API that's configured to be -// case-sensitive, but also disallows unknown fields when unmarshalling. It is compatible with -// the encoding/json standard library. -func StrictCaseSensitiveJSONIterator() jsoniter.API { - config := jsoniter.Config{ - EscapeHTML: true, - SortMapKeys: true, - ValidateJsonRawMessage: true, - CaseSensitive: true, - DisallowUnknownFields: true, - }.Froze() - // Force jsoniter to decode number to interface{} via int64/float64, if possible. - config.RegisterExtension(&customNumberExtension{}) - return config -} - -// Private copies of jsoniter to try to shield against possible mutations -// from outside. Still does not protect from package level jsoniter.Register*() functions - someone calling them -// in some other library will mess with every usage of the jsoniter library in the whole program. -// See https://github.com/json-iterator/go/issues/265 -var caseSensitiveJSONIterator = CaseSensitiveJSONIterator() -var strictCaseSensitiveJSONIterator = StrictCaseSensitiveJSONIterator() - // gvkWithDefaults returns group kind and version defaulting from provided default func gvkWithDefaults(actual, defaultGVK schema.GroupVersionKind) schema.GroupVersionKind { if len(actual.Kind) == 0 { @@ -237,8 +163,11 @@ func (s *Serializer) Decode(originalData []byte, gvk *schema.GroupVersionKind, i types, _, err := s.typer.ObjectKinds(into) switch { case runtime.IsNotRegisteredError(err), isUnstructured: - if err := caseSensitiveJSONIterator.Unmarshal(data, into); err != nil { + strictErrs, err := s.unmarshal(into, data, originalData) + if err != nil { return nil, actual, err + } else if len(strictErrs) > 0 { + return into, actual, runtime.NewStrictDecodingError(strictErrs) } return into, actual, nil case err != nil: @@ -261,35 +190,12 @@ func (s *Serializer) Decode(originalData []byte, gvk *schema.GroupVersionKind, i return nil, actual, err } - if err := caseSensitiveJSONIterator.Unmarshal(data, obj); err != nil { - return nil, actual, err - } - - // If the deserializer is non-strict, return successfully here. - if !s.options.Strict { - return obj, actual, nil - } - - // In strict mode pass the data trough the YAMLToJSONStrict converter. - // This is done to catch duplicate fields regardless of encoding (JSON or YAML). For JSON data, - // the output would equal the input, unless there is a parsing error such as duplicate fields. - // As we know this was successful in the non-strict case, the only error that may be returned here - // is because of the newly-added strictness. hence we know we can return the typed strictDecoderError - // the actual error is that the object contains duplicate fields. - altered, err := yaml.YAMLToJSONStrict(originalData) + strictErrs, err := s.unmarshal(obj, data, originalData) if err != nil { - return nil, actual, runtime.NewStrictDecodingError(err.Error(), string(originalData)) - } - // As performance is not an issue for now for the strict deserializer (one has regardless to do - // the unmarshal twice), we take the sanitized, altered data that is guaranteed to have no duplicated - // fields, and unmarshal this into a copy of the already-populated obj. Any error that occurs here is - // due to that a matching field doesn't exist in the object. hence we can return a typed strictDecoderError, - // the actual error is that the object contains unknown field. - strictObj := obj.DeepCopyObject() - if err := strictCaseSensitiveJSONIterator.Unmarshal(altered, strictObj); err != nil { - return nil, actual, runtime.NewStrictDecodingError(err.Error(), string(originalData)) + return nil, actual, err + } else if len(strictErrs) > 0 { + return obj, actual, runtime.NewStrictDecodingError(strictErrs) } - // Always return the same object as the non-strict serializer to avoid any deviations. return obj, actual, nil } @@ -303,7 +209,7 @@ func (s *Serializer) Encode(obj runtime.Object, w io.Writer) error { func (s *Serializer) doEncode(obj runtime.Object, w io.Writer) error { if s.options.Yaml { - json, err := caseSensitiveJSONIterator.Marshal(obj) + json, err := json.Marshal(obj) if err != nil { return err } @@ -316,7 +222,7 @@ func (s *Serializer) doEncode(obj runtime.Object, w io.Writer) error { } if s.options.Pretty { - data, err := caseSensitiveJSONIterator.MarshalIndent(obj, "", " ") + data, err := json.MarshalIndent(obj, "", " ") if err != nil { return err } @@ -327,6 +233,50 @@ func (s *Serializer) doEncode(obj runtime.Object, w io.Writer) error { return encoder.Encode(obj) } +// IsStrict indicates whether the serializer +// uses strict decoding or not +func (s *Serializer) IsStrict() bool { + return s.options.Strict +} + +func (s *Serializer) unmarshal(into runtime.Object, data, originalData []byte) (strictErrs []error, err error) { + // If the deserializer is non-strict, return here. + if !s.options.Strict { + if err := kjson.UnmarshalCaseSensitivePreserveInts(data, into); err != nil { + return nil, err + } + return nil, nil + } + + if s.options.Yaml { + // In strict mode pass the original data through the YAMLToJSONStrict converter. + // This is done to catch duplicate fields in YAML that would have been dropped in the original YAMLToJSON conversion. + // TODO: rework YAMLToJSONStrict to return warnings about duplicate fields without terminating so we don't have to do this twice. + _, err := yaml.YAMLToJSONStrict(originalData) + if err != nil { + strictErrs = append(strictErrs, err) + } + } + + var strictJSONErrs []error + if u, isUnstructured := into.(runtime.Unstructured); isUnstructured { + // Unstructured is a custom unmarshaler that gets delegated + // to, so inorder to detect strict JSON errors we need + // to unmarshal directly into the object. + m := u.UnstructuredContent() + strictJSONErrs, err = kjson.UnmarshalStrict(data, &m) + u.SetUnstructuredContent(m) + } else { + strictJSONErrs, err = kjson.UnmarshalStrict(data, into) + } + if err != nil { + // fatal decoding error, not due to strictness + return nil, err + } + strictErrs = append(strictErrs, strictJSONErrs...) + return strictErrs, nil +} + // Identifier implements runtime.Encoder interface. func (s *Serializer) Identifier() runtime.Identifier { return s.identifier diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/recognizer/recognizer.go b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/recognizer/recognizer.go index 709f852911..5a6c200dd1 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/recognizer/recognizer.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/recognizer/recognizer.go @@ -109,10 +109,16 @@ func (d *decoder) Decode(data []byte, gvk *schema.GroupVersionKind, into runtime for _, r := range skipped { out, actual, err := r.Decode(data, gvk, into) if err != nil { - lastErr = err - continue + // if we got an object back from the decoder, and the + // error was a strict decoding error (e.g. unknown or + // duplicate fields), we still consider the recognizer + // to have understood the object + if out == nil || !runtime.IsStrictDecodingError(err) { + lastErr = err + continue + } } - return out, actual, nil + return out, actual, err } if lastErr == nil { diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/streaming/streaming.go b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/streaming/streaming.go index a60a7c0415..971c46d496 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/streaming/streaming.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/streaming/streaming.go @@ -90,7 +90,6 @@ func (d *decoder) Decode(defaults *schema.GroupVersionKind, into runtime.Object) } // must read the rest of the frame (until we stop getting ErrShortBuffer) d.resetRead = true - base = 0 return nil, nil, ErrObjectTooLarge } if err != nil { diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/versioning/versioning.go b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/versioning/versioning.go index 718c5dfb7d..ea7c580bd6 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/serializer/versioning/versioning.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/serializer/versioning/versioning.go @@ -133,11 +133,18 @@ func (c *codec) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into ru } } + var strictDecodingErr error obj, gvk, err := c.decoder.Decode(data, defaultGVK, decodeInto) if err != nil { - return nil, gvk, err + if obj != nil && runtime.IsStrictDecodingError(err) { + // save the strictDecodingError and the caller decide what to do with it + strictDecodingErr = err + } else { + return nil, gvk, err + } } + // TODO: look into strict handling of nested object decoding if d, ok := obj.(runtime.NestedObjectDecoder); ok { if err := d.DecodeNestedObjects(runtime.WithoutVersionDecoder{c.decoder}); err != nil { return nil, gvk, err @@ -153,14 +160,14 @@ func (c *codec) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into ru // Short-circuit conversion if the into object is same object if into == obj { - return into, gvk, nil + return into, gvk, strictDecodingErr } if err := c.convertor.Convert(obj, into, c.decodeVersion); err != nil { return nil, gvk, err } - return into, gvk, nil + return into, gvk, strictDecodingErr } // perform defaulting if requested @@ -172,7 +179,7 @@ func (c *codec) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into ru if err != nil { return nil, gvk, err } - return out, gvk, nil + return out, gvk, strictDecodingErr } // Encode ensures the provided object is output in the appropriate group and version, invoking diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go index b0393839e1..069ea4f92d 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apimachinery/pkg/util/cache/expiring.go b/vendor/k8s.io/apimachinery/pkg/util/cache/expiring.go index faf2c26453..0d2f153bf9 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/cache/expiring.go +++ b/vendor/k8s.io/apimachinery/pkg/util/cache/expiring.go @@ -21,17 +21,17 @@ import ( "sync" "time" - utilclock "k8s.io/apimachinery/pkg/util/clock" + "k8s.io/utils/clock" ) // NewExpiring returns an initialized expiring cache. func NewExpiring() *Expiring { - return NewExpiringWithClock(utilclock.RealClock{}) + return NewExpiringWithClock(clock.RealClock{}) } // NewExpiringWithClock is like NewExpiring but allows passing in a custom // clock for testing. -func NewExpiringWithClock(clock utilclock.Clock) *Expiring { +func NewExpiringWithClock(clock clock.Clock) *Expiring { return &Expiring{ clock: clock, cache: make(map[interface{}]entry), @@ -40,7 +40,7 @@ func NewExpiringWithClock(clock utilclock.Clock) *Expiring { // Expiring is a map whose entries expire after a per-entry timeout. type Expiring struct { - clock utilclock.Clock + clock clock.Clock // mu protects the below fields mu sync.RWMutex diff --git a/vendor/k8s.io/apimachinery/pkg/util/framer/framer.go b/vendor/k8s.io/apimachinery/pkg/util/framer/framer.go index 45aa74bf58..10df0d99cd 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/framer/framer.go +++ b/vendor/k8s.io/apimachinery/pkg/util/framer/framer.go @@ -132,14 +132,14 @@ func (r *jsonFrameReader) Read(data []byte) (int, error) { // Return whatever remaining data exists from an in progress frame if n := len(r.remaining); n > 0 { if n <= len(data) { - //lint:ignore SA4006,SA4010 underlying array of data is modified here. + //nolint:staticcheck // SA4006,SA4010 underlying array of data is modified here. data = append(data[0:0], r.remaining...) r.remaining = nil return n, nil } n = len(data) - //lint:ignore SA4006,SA4010 underlying array of data is modified here. + //nolint:staticcheck // SA4006,SA4010 underlying array of data is modified here. data = append(data[0:0], r.remaining[:n]...) r.remaining = r.remaining[n:] return n, io.ErrShortBuffer @@ -157,7 +157,7 @@ func (r *jsonFrameReader) Read(data []byte) (int, error) { // and set m to it, which means we need to copy the partial result back into data and preserve // the remaining result for subsequent reads. if len(m) > n { - //lint:ignore SA4006,SA4010 underlying array of data is modified here. + //nolint:staticcheck // SA4006,SA4010 underlying array of data is modified here. data = append(data[0:0], m[:n]...) r.remaining = m[n:] return n, io.ErrShortBuffer diff --git a/vendor/k8s.io/apimachinery/pkg/util/httpstream/spdy/roundtripper.go b/vendor/k8s.io/apimachinery/pkg/util/httpstream/spdy/roundtripper.go index b8e329571e..086e4bcf0b 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/httpstream/spdy/roundtripper.go +++ b/vendor/k8s.io/apimachinery/pkg/util/httpstream/spdy/roundtripper.go @@ -183,10 +183,10 @@ func (s *SpdyRoundTripper) dial(req *http.Request) (net.Conn, error) { return nil, err } - //lint:ignore SA1019 ignore deprecated httputil.NewProxyClientConn + //nolint:staticcheck // SA1019 ignore deprecated httputil.NewProxyClientConn proxyClientConn := httputil.NewProxyClientConn(proxyDialConn, nil) _, err = proxyClientConn.Do(&proxyReq) - //lint:ignore SA1019 ignore deprecated httputil.ErrPersistEOF: it might be + //nolint:staticcheck // SA1019 ignore deprecated httputil.ErrPersistEOF: it might be // returned from the invocation of proxyClientConn.Do if err != nil && err != httputil.ErrPersistEOF { return nil, err diff --git a/vendor/k8s.io/apimachinery/pkg/util/intstr/instr_fuzz.go b/vendor/k8s.io/apimachinery/pkg/util/intstr/instr_fuzz.go index 2501d55166..a502b5adb6 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/intstr/instr_fuzz.go +++ b/vendor/k8s.io/apimachinery/pkg/util/intstr/instr_fuzz.go @@ -1,3 +1,4 @@ +//go:build !notest // +build !notest /* diff --git a/vendor/k8s.io/apimachinery/pkg/util/json/json.go b/vendor/k8s.io/apimachinery/pkg/util/json/json.go index 778e58f704..55dba361c3 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/json/json.go +++ b/vendor/k8s.io/apimachinery/pkg/util/json/json.go @@ -17,10 +17,11 @@ limitations under the License. package json import ( - "bytes" "encoding/json" "fmt" "io" + + kjson "sigs.k8s.io/json" ) // NewEncoder delegates to json.NewEncoder @@ -38,50 +39,11 @@ func Marshal(v interface{}) ([]byte, error) { // limit recursive depth to prevent stack overflow errors const maxDepth = 10000 -// Unmarshal unmarshals the given data -// If v is a *map[string]interface{}, *[]interface{}, or *interface{} numbers -// are converted to int64 or float64 +// Unmarshal unmarshals the given data. +// Object keys are case-sensitive. +// Numbers decoded into interface{} fields are converted to int64 or float64. func Unmarshal(data []byte, v interface{}) error { - switch v := v.(type) { - case *map[string]interface{}: - // Build a decoder from the given data - decoder := json.NewDecoder(bytes.NewBuffer(data)) - // Preserve numbers, rather than casting to float64 automatically - decoder.UseNumber() - // Run the decode - if err := decoder.Decode(v); err != nil { - return err - } - // If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64 - return ConvertMapNumbers(*v, 0) - - case *[]interface{}: - // Build a decoder from the given data - decoder := json.NewDecoder(bytes.NewBuffer(data)) - // Preserve numbers, rather than casting to float64 automatically - decoder.UseNumber() - // Run the decode - if err := decoder.Decode(v); err != nil { - return err - } - // If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64 - return ConvertSliceNumbers(*v, 0) - - case *interface{}: - // Build a decoder from the given data - decoder := json.NewDecoder(bytes.NewBuffer(data)) - // Preserve numbers, rather than casting to float64 automatically - decoder.UseNumber() - // Run the decode - if err := decoder.Decode(v); err != nil { - return err - } - // If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64 - return ConvertInterfaceNumbers(v, 0) - - default: - return json.Unmarshal(data, v) - } + return kjson.UnmarshalCaseSensitivePreserveInts(data, v) } // ConvertInterfaceNumbers converts any json.Number values to int64 or float64. diff --git a/vendor/k8s.io/apimachinery/pkg/util/managedfields/extract.go b/vendor/k8s.io/apimachinery/pkg/util/managedfields/extract.go index 590c168670..792badbc3d 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/managedfields/extract.go +++ b/vendor/k8s.io/apimachinery/pkg/util/managedfields/extract.go @@ -75,6 +75,13 @@ func ExtractInto(object runtime.Object, objectType typed.ParseableType, fieldMan if !ok { return fmt.Errorf("unable to convert managed fields for %s to unstructured, expected map, got %T", fieldManager, u) } + + // set the type meta manually if it doesn't exist to avoid missing kind errors + // when decoding from unstructured JSON + if _, ok := m["kind"]; !ok && object.GetObjectKind().GroupVersionKind().Kind != "" { + m["kind"] = object.GetObjectKind().GroupVersionKind().Kind + m["apiVersion"] = object.GetObjectKind().GroupVersionKind().GroupVersion().String() + } if err := runtime.DefaultUnstructuredConverter.FromUnstructured(m, applyConfiguration); err != nil { return fmt.Errorf("error extracting into obj from unstructured: %w", err) } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal/gvkparser.go b/vendor/k8s.io/apimachinery/pkg/util/managedfields/gvkparser.go similarity index 99% rename from vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal/gvkparser.go rename to vendor/k8s.io/apimachinery/pkg/util/managedfields/gvkparser.go index f8abcaf04e..0cc228af93 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal/gvkparser.go +++ b/vendor/k8s.io/apimachinery/pkg/util/managedfields/gvkparser.go @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -package internal +package managedfields import ( "fmt" diff --git a/vendor/k8s.io/apimachinery/pkg/util/net/http.go b/vendor/k8s.io/apimachinery/pkg/util/net/http.go index d75ac6efa2..04432b175d 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/net/http.go +++ b/vendor/k8s.io/apimachinery/pkg/util/net/http.go @@ -39,6 +39,7 @@ import ( "golang.org/x/net/http2" "k8s.io/klog/v2" + netutils "k8s.io/utils/net" ) // JoinPreservingTrailingSlash does a path.Join of the specified elements, @@ -237,6 +238,29 @@ func DialerFor(transport http.RoundTripper) (DialFunc, error) { } } +// CloseIdleConnectionsFor close idles connections for the Transport. +// If the Transport is wrapped it iterates over the wrapped round trippers +// until it finds one that implements the CloseIdleConnections method. +// If the Transport does not have a CloseIdleConnections method +// then this function does nothing. +func CloseIdleConnectionsFor(transport http.RoundTripper) { + if transport == nil { + return + } + type closeIdler interface { + CloseIdleConnections() + } + + switch transport := transport.(type) { + case closeIdler: + transport.CloseIdleConnections() + case RoundTripperWrapper: + CloseIdleConnectionsFor(transport.WrappedRoundTripper()) + default: + klog.Warningf("unknown transport type: %T", transport) + } +} + type TLSClientConfigHolder interface { TLSClientConfig() *tls.Config } @@ -289,7 +313,7 @@ func SourceIPs(req *http.Request) []net.IP { // Use the first valid one. parts := strings.Split(hdrForwardedFor, ",") for _, part := range parts { - ip := net.ParseIP(strings.TrimSpace(part)) + ip := netutils.ParseIPSloppy(strings.TrimSpace(part)) if ip != nil { srcIPs = append(srcIPs, ip) } @@ -299,7 +323,7 @@ func SourceIPs(req *http.Request) []net.IP { // Try the X-Real-Ip header. hdrRealIp := hdr.Get("X-Real-Ip") if hdrRealIp != "" { - ip := net.ParseIP(hdrRealIp) + ip := netutils.ParseIPSloppy(hdrRealIp) // Only append the X-Real-Ip if it's not already contained in the X-Forwarded-For chain. if ip != nil && !containsIP(srcIPs, ip) { srcIPs = append(srcIPs, ip) @@ -311,11 +335,11 @@ func SourceIPs(req *http.Request) []net.IP { // Remote Address in Go's HTTP server is in the form host:port so we need to split that first. host, _, err := net.SplitHostPort(req.RemoteAddr) if err == nil { - remoteIP = net.ParseIP(host) + remoteIP = netutils.ParseIPSloppy(host) } // Fallback if Remote Address was just IP. if remoteIP == nil { - remoteIP = net.ParseIP(req.RemoteAddr) + remoteIP = netutils.ParseIPSloppy(req.RemoteAddr) } // Don't duplicate remote IP if it's already the last address in the chain. @@ -382,7 +406,7 @@ func NewProxierWithNoProxyCIDR(delegate func(req *http.Request) (*url.URL, error cidrs := []*net.IPNet{} for _, noProxyRule := range noProxyRules { - _, cidr, _ := net.ParseCIDR(noProxyRule) + _, cidr, _ := netutils.ParseCIDRSloppy(noProxyRule) if cidr != nil { cidrs = append(cidrs, cidr) } @@ -393,7 +417,7 @@ func NewProxierWithNoProxyCIDR(delegate func(req *http.Request) (*url.URL, error } return func(req *http.Request) (*url.URL, error) { - ip := net.ParseIP(req.URL.Hostname()) + ip := netutils.ParseIPSloppy(req.URL.Hostname()) if ip == nil { return delegate(req) } diff --git a/vendor/k8s.io/apimachinery/pkg/util/net/interface.go b/vendor/k8s.io/apimachinery/pkg/util/net/interface.go index 9adf4cfe47..8224168064 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/net/interface.go +++ b/vendor/k8s.io/apimachinery/pkg/util/net/interface.go @@ -27,6 +27,7 @@ import ( "strings" "k8s.io/klog/v2" + netutils "k8s.io/utils/net" ) type AddressFamily uint @@ -221,7 +222,7 @@ func getMatchingGlobalIP(addrs []net.Addr, family AddressFamily) (net.IP, error) if len(addrs) > 0 { for i := range addrs { klog.V(4).Infof("Checking addr %s.", addrs[i].String()) - ip, _, err := net.ParseCIDR(addrs[i].String()) + ip, _, err := netutils.ParseCIDRSloppy(addrs[i].String()) if err != nil { return nil, err } @@ -336,7 +337,7 @@ func chooseIPFromHostInterfaces(nw networkInterfacer, addressFamilies AddressFam continue } for _, addr := range addrs { - ip, _, err := net.ParseCIDR(addr.String()) + ip, _, err := netutils.ParseCIDRSloppy(addr.String()) if err != nil { return nil, fmt.Errorf("Unable to parse CIDR for interface %q: %s", intf.Name, err) } diff --git a/vendor/k8s.io/apimachinery/pkg/util/strategicpatch/meta.go b/vendor/k8s.io/apimachinery/pkg/util/strategicpatch/meta.go index c31de15e7a..d49a56536c 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/strategicpatch/meta.go +++ b/vendor/k8s.io/apimachinery/pkg/util/strategicpatch/meta.go @@ -31,22 +31,22 @@ type PatchMeta struct { patchMergeKey string } -func (pm PatchMeta) GetPatchStrategies() []string { +func (pm *PatchMeta) GetPatchStrategies() []string { if pm.patchStrategies == nil { return []string{} } return pm.patchStrategies } -func (pm PatchMeta) SetPatchStrategies(ps []string) { +func (pm *PatchMeta) SetPatchStrategies(ps []string) { pm.patchStrategies = ps } -func (pm PatchMeta) GetPatchMergeKey() string { +func (pm *PatchMeta) GetPatchMergeKey() string { return pm.patchMergeKey } -func (pm PatchMeta) SetPatchMergeKey(pmk string) { +func (pm *PatchMeta) SetPatchMergeKey(pmk string) { pm.patchMergeKey = pmk } diff --git a/vendor/k8s.io/apimachinery/pkg/util/strategicpatch/patch.go b/vendor/k8s.io/apimachinery/pkg/util/strategicpatch/patch.go index fd2081a28d..1aedaa1563 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/strategicpatch/patch.go +++ b/vendor/k8s.io/apimachinery/pkg/util/strategicpatch/patch.go @@ -1328,15 +1328,19 @@ func mergeMap(original, patch map[string]interface{}, schema LookupPatchMeta, me _, ok := original[k] if !ok { - // If it's not in the original document, just take the patch value. - original[k] = patchV + if !isDeleteList { + // If it's not in the original document, just take the patch value. + original[k] = patchV + } continue } originalType := reflect.TypeOf(original[k]) patchType := reflect.TypeOf(patchV) if originalType != patchType { - original[k] = patchV + if !isDeleteList { + original[k] = patchV + } continue } // If they're both maps or lists, recurse into the value. diff --git a/vendor/k8s.io/apimachinery/pkg/util/validation/field/errors.go b/vendor/k8s.io/apimachinery/pkg/util/validation/field/errors.go index c283ad189a..2ed368f569 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/validation/field/errors.go +++ b/vendor/k8s.io/apimachinery/pkg/util/validation/field/errors.go @@ -239,6 +239,9 @@ func NewErrorTypeMatcher(t ErrorType) utilerrors.Matcher { // ToAggregate converts the ErrorList into an errors.Aggregate. func (list ErrorList) ToAggregate() utilerrors.Aggregate { + if len(list) == 0 { + return nil + } errs := make([]error, 0, len(list)) errorMsgs := sets.NewString() for _, err := range list { diff --git a/vendor/k8s.io/apimachinery/pkg/util/validation/validation.go b/vendor/k8s.io/apimachinery/pkg/util/validation/validation.go index c8b4199840..83df4fb8d4 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/validation/validation.go +++ b/vendor/k8s.io/apimachinery/pkg/util/validation/validation.go @@ -25,6 +25,7 @@ import ( "strings" "k8s.io/apimachinery/pkg/util/validation/field" + netutils "k8s.io/utils/net" ) const qnameCharFmt string = "[A-Za-z0-9]" @@ -346,7 +347,7 @@ func IsValidPortName(port string) []string { // IsValidIP tests that the argument is a valid IP address. func IsValidIP(value string) []string { - if net.ParseIP(value) == nil { + if netutils.ParseIPSloppy(value) == nil { return []string{"must be a valid IP address, (e.g. 10.9.8.7 or 2001:db8::ffff)"} } return nil @@ -355,7 +356,7 @@ func IsValidIP(value string) []string { // IsValidIPv4Address tests that the argument is a valid IPv4 address. func IsValidIPv4Address(fldPath *field.Path, value string) field.ErrorList { var allErrors field.ErrorList - ip := net.ParseIP(value) + ip := netutils.ParseIPSloppy(value) if ip == nil || ip.To4() == nil { allErrors = append(allErrors, field.Invalid(fldPath, value, "must be a valid IPv4 address")) } @@ -365,7 +366,7 @@ func IsValidIPv4Address(fldPath *field.Path, value string) field.ErrorList { // IsValidIPv6Address tests that the argument is a valid IPv6 address. func IsValidIPv6Address(fldPath *field.Path, value string) field.ErrorList { var allErrors field.ErrorList - ip := net.ParseIP(value) + ip := netutils.ParseIPSloppy(value) if ip == nil || ip.To4() != nil { allErrors = append(allErrors, field.Invalid(fldPath, value, "must be a valid IPv6 address")) } diff --git a/vendor/k8s.io/apimachinery/pkg/util/wait/wait.go b/vendor/k8s.io/apimachinery/pkg/util/wait/wait.go index afb24876ad..ec5be90b82 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/wait/wait.go +++ b/vendor/k8s.io/apimachinery/pkg/util/wait/wait.go @@ -24,8 +24,8 @@ import ( "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/runtime" + "k8s.io/utils/clock" ) // For any test of the style: @@ -166,6 +166,9 @@ func BackoffUntil(f func(), backoff BackoffManager, sliding bool, stopCh <-chan // of every loop to prevent extra executions of f(). select { case <-stopCh: + if !t.Stop() { + <-t.C() + } return case <-t.C(): } diff --git a/vendor/k8s.io/apimachinery/pkg/util/yaml/decoder.go b/vendor/k8s.io/apimachinery/pkg/util/yaml/decoder.go index 56f4262aca..9837b3df28 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/yaml/decoder.go +++ b/vendor/k8s.io/apimachinery/pkg/util/yaml/decoder.go @@ -59,6 +59,34 @@ func Unmarshal(data []byte, v interface{}) error { } } +// UnmarshalStrict unmarshals the given data +// strictly (erroring when there are duplicate fields). +func UnmarshalStrict(data []byte, v interface{}) error { + preserveIntFloat := func(d *json.Decoder) *json.Decoder { + d.UseNumber() + return d + } + switch v := v.(type) { + case *map[string]interface{}: + if err := yaml.UnmarshalStrict(data, v, preserveIntFloat); err != nil { + return err + } + return jsonutil.ConvertMapNumbers(*v, 0) + case *[]interface{}: + if err := yaml.UnmarshalStrict(data, v, preserveIntFloat); err != nil { + return err + } + return jsonutil.ConvertSliceNumbers(*v, 0) + case *interface{}: + if err := yaml.UnmarshalStrict(data, v, preserveIntFloat); err != nil { + return err + } + return jsonutil.ConvertInterfaceNumbers(v, 0) + default: + return yaml.UnmarshalStrict(data, v) + } +} + // ToJSON converts a single YAML document into a JSON document // or returns an error. If the document appears to be JSON the // YAML decoding path is not used (so that error messages are diff --git a/vendor/k8s.io/apimachinery/pkg/watch/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/watch/zz_generated.deepcopy.go index 71ef4da334..dd27d4526f 100644 --- a/vendor/k8s.io/apimachinery/pkg/watch/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apimachinery/pkg/watch/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/admission/audit.go b/vendor/k8s.io/apiserver/pkg/admission/audit.go index d1e103cfc6..02694b0a91 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/audit.go +++ b/vendor/k8s.io/apiserver/pkg/admission/audit.go @@ -19,6 +19,7 @@ package admission import ( "context" "fmt" + "sync" auditinternal "k8s.io/apiserver/pkg/apis/audit" "k8s.io/apiserver/pkg/audit" @@ -27,7 +28,10 @@ import ( // auditHandler logs annotations set by other admission handlers type auditHandler struct { Interface - ae *auditinternal.Event + // TODO: move the lock near the Annotations field of the audit event so it is always protected from concurrent access. + // to protect the 'Annotations' map of the audit event from concurrent writes + mutex sync.Mutex + ae *auditinternal.Event } var _ Interface = &auditHandler{} @@ -42,10 +46,10 @@ func WithAudit(i Interface, ae *auditinternal.Event) Interface { if i == nil { return i } - return &auditHandler{i, ae} + return &auditHandler{Interface: i, ae: ae} } -func (handler auditHandler) Admit(ctx context.Context, a Attributes, o ObjectInterfaces) error { +func (handler *auditHandler) Admit(ctx context.Context, a Attributes, o ObjectInterfaces) error { if !handler.Interface.Handles(a.GetOperation()) { return nil } @@ -60,7 +64,7 @@ func (handler auditHandler) Admit(ctx context.Context, a Attributes, o ObjectInt return err } -func (handler auditHandler) Validate(ctx context.Context, a Attributes, o ObjectInterfaces) error { +func (handler *auditHandler) Validate(ctx context.Context, a Attributes, o ObjectInterfaces) error { if !handler.Interface.Handles(a.GetOperation()) { return nil } @@ -84,10 +88,13 @@ func ensureAnnotationGetter(a Attributes) error { return fmt.Errorf("attributes must be an instance of privateAnnotationsGetter or AnnotationsGetter") } -func (handler auditHandler) logAnnotations(a Attributes) { +func (handler *auditHandler) logAnnotations(a Attributes) { if handler.ae == nil { return } + handler.mutex.Lock() + defer handler.mutex.Unlock() + switch a := a.(type) { case privateAnnotationsGetter: for key, value := range a.getAnnotations(handler.ae.Level) { diff --git a/vendor/k8s.io/apiserver/pkg/admission/metrics/metrics.go b/vendor/k8s.io/apiserver/pkg/admission/metrics/metrics.go index 82752fe08c..757e26882d 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/metrics/metrics.go +++ b/vendor/k8s.io/apiserver/pkg/admission/metrics/metrics.go @@ -18,7 +18,6 @@ package metrics import ( "context" - "fmt" "strconv" "time" @@ -45,8 +44,6 @@ const ( ) var ( - // Use buckets ranging from 5 ms to 2.5 seconds (admission webhooks timeout at 30 seconds by default). - latencyBuckets = []float64{0.005, 0.025, 0.1, 0.5, 2.5} latencySummaryMaxAge = 5 * time.Hour // Metrics provides access to all admission metrics. @@ -119,25 +116,75 @@ type AdmissionMetrics struct { controller *metricSet webhook *metricSet webhookRejection *metrics.CounterVec + webhookRequest *metrics.CounterVec } // newAdmissionMetrics create a new AdmissionMetrics, configured with default metric names. func newAdmissionMetrics() *AdmissionMetrics { // Admission metrics for a step of the admission flow. The entire admission flow is broken down into a series of steps // Each step is identified by a distinct type label value. - step := newMetricSet("step", - []string{"type", "operation", "rejected"}, - "Admission sub-step %s, broken out for each operation and API resource and step type (validate or admit).", true) + // Use buckets ranging from 5 ms to 2.5 seconds. + step := &metricSet{ + latencies: metrics.NewHistogramVec( + &metrics.HistogramOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "step_admission_duration_seconds", + Help: "Admission sub-step latency histogram in seconds, broken out for each operation and API resource and step type (validate or admit).", + Buckets: []float64{0.005, 0.025, 0.1, 0.5, 1.0, 2.5}, + StabilityLevel: metrics.STABLE, + }, + []string{"type", "operation", "rejected"}, + ), + + latenciesSummary: metrics.NewSummaryVec( + &metrics.SummaryOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "step_admission_duration_seconds_summary", + Help: "Admission sub-step latency summary in seconds, broken out for each operation and API resource and step type (validate or admit).", + MaxAge: latencySummaryMaxAge, + StabilityLevel: metrics.ALPHA, + }, + []string{"type", "operation", "rejected"}, + ), + } // Built-in admission controller metrics. Each admission controller is identified by name. - controller := newMetricSet("controller", - []string{"name", "type", "operation", "rejected"}, - "Admission controller %s, identified by name and broken out for each operation and API resource and type (validate or admit).", false) + // Use buckets ranging from 5 ms to 2.5 seconds. + controller := &metricSet{ + latencies: metrics.NewHistogramVec( + &metrics.HistogramOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "controller_admission_duration_seconds", + Help: "Admission controller latency histogram in seconds, identified by name and broken out for each operation and API resource and type (validate or admit).", + Buckets: []float64{0.005, 0.025, 0.1, 0.5, 1.0, 2.5}, + StabilityLevel: metrics.STABLE, + }, + []string{"name", "type", "operation", "rejected"}, + ), + + latenciesSummary: nil, + } // Admission webhook metrics. Each webhook is identified by name. - webhook := newMetricSet("webhook", - []string{"name", "type", "operation", "rejected"}, - "Admission webhook %s, identified by name and broken out for each operation and API resource and type (validate or admit).", false) + // Use buckets ranging from 5 ms to 2.5 seconds (admission webhooks timeout at 30 seconds by default). + webhook := &metricSet{ + latencies: metrics.NewHistogramVec( + &metrics.HistogramOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "webhook_admission_duration_seconds", + Help: "Admission webhook latency histogram in seconds, identified by name and broken out for each operation and API resource and type (validate or admit).", + Buckets: []float64{0.005, 0.025, 0.1, 0.5, 1.0, 2.5}, + StabilityLevel: metrics.STABLE, + }, + []string{"name", "type", "operation", "rejected"}, + ), + + latenciesSummary: nil, + } webhookRejection := metrics.NewCounterVec( &metrics.CounterOpts{ @@ -149,11 +196,22 @@ func newAdmissionMetrics() *AdmissionMetrics { }, []string{"name", "type", "operation", "error_type", "rejection_code"}) + webhookRequest := metrics.NewCounterVec( + &metrics.CounterOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "webhook_request_total", + Help: "Admission webhook request total, identified by name and broken out for each admission type (validating or mutating) and operation. Additional labels specify whether the request was rejected or not and an HTTP status code. Codes greater than 600 are truncated to 600, to keep the metrics cardinality bounded.", + StabilityLevel: metrics.ALPHA, + }, + []string{"name", "type", "operation", "code", "rejected"}) + step.mustRegister() controller.mustRegister() webhook.mustRegister() legacyregistry.MustRegister(webhookRejection) - return &AdmissionMetrics{step: step, controller: controller, webhook: webhook, webhookRejection: webhookRejection} + legacyregistry.MustRegister(webhookRequest) + return &AdmissionMetrics{step: step, controller: controller, webhook: webhook, webhookRejection: webhookRejection, webhookRequest: webhookRequest} } func (m *AdmissionMetrics) reset() { @@ -173,8 +231,13 @@ func (m *AdmissionMetrics) ObserveAdmissionController(ctx context.Context, elaps } // ObserveWebhook records admission related metrics for a admission webhook. -func (m *AdmissionMetrics) ObserveWebhook(ctx context.Context, elapsed time.Duration, rejected bool, attr admission.Attributes, stepType string, extraLabels ...string) { - m.webhook.observe(ctx, elapsed, append(extraLabels, stepType, string(attr.GetOperation()), strconv.FormatBool(rejected))...) +func (m *AdmissionMetrics) ObserveWebhook(ctx context.Context, name string, elapsed time.Duration, rejected bool, attr admission.Attributes, stepType string, code int) { + // We truncate codes greater than 600 to keep the cardinality bounded. + if code > 600 { + code = 600 + } + m.webhookRequest.WithContext(ctx).WithLabelValues(name, stepType, string(attr.GetOperation()), strconv.Itoa(code), strconv.FormatBool(rejected)).Inc() + m.webhook.observe(ctx, elapsed, name, stepType, string(attr.GetOperation()), strconv.FormatBool(rejected)) } // ObserveWebhookRejection records admission related metrics for an admission webhook rejection. @@ -192,39 +255,6 @@ type metricSet struct { latenciesSummary *metrics.SummaryVec } -func newMetricSet(name string, labels []string, helpTemplate string, hasSummary bool) *metricSet { - var summary *metrics.SummaryVec - if hasSummary { - summary = metrics.NewSummaryVec( - &metrics.SummaryOpts{ - Namespace: namespace, - Subsystem: subsystem, - Name: fmt.Sprintf("%s_admission_duration_seconds_summary", name), - Help: fmt.Sprintf(helpTemplate, "latency summary in seconds"), - MaxAge: latencySummaryMaxAge, - StabilityLevel: metrics.ALPHA, - }, - labels, - ) - } - - return &metricSet{ - latencies: metrics.NewHistogramVec( - &metrics.HistogramOpts{ - Namespace: namespace, - Subsystem: subsystem, - Name: fmt.Sprintf("%s_admission_duration_seconds", name), - Help: fmt.Sprintf(helpTemplate, "latency histogram in seconds"), - Buckets: latencyBuckets, - StabilityLevel: metrics.ALPHA, - }, - labels, - ), - - latenciesSummary: summary, - } -} - // MustRegister registers all the prometheus metrics in the metricSet. func (m *metricSet) mustRegister() { legacyregistry.MustRegister(m.latencies) diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/namespace/lifecycle/admission.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/namespace/lifecycle/admission.go index c417e3f98a..936a95e45c 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/namespace/lifecycle/admission.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/namespace/lifecycle/admission.go @@ -29,13 +29,13 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime/schema" utilcache "k8s.io/apimachinery/pkg/util/cache" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apiserver/pkg/admission" "k8s.io/apiserver/pkg/admission/initializer" "k8s.io/client-go/informers" "k8s.io/client-go/kubernetes" corelisters "k8s.io/client-go/listers/core/v1" + "k8s.io/utils/clock" ) const ( diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.conversion.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.conversion.go index 65eb414fcc..4cf69291b3 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.deepcopy.go index 99fc6a6fa7..839c1fc7ac 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.defaults.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.defaults.go index cce2e603a6..dac177e93b 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.conversion.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.conversion.go index eadb147c40..66aaecbd86 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.deepcopy.go index a59d62d6c4..f997f4abaf 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.defaults.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.defaults.go index dd621a3acd..5070cb91b9 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/v1alpha1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/zz_generated.deepcopy.go index 90b7e0ae62..27c3ede0da 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/config/apis/webhookadmission/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/mutating/dispatcher.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/mutating/dispatcher.go index 3b35bb31ec..16642c183e 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/mutating/dispatcher.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/mutating/dispatcher.go @@ -34,6 +34,7 @@ import ( "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/serializer/json" + utiljson "k8s.io/apimachinery/pkg/util/json" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apiserver/pkg/admission" admissionmetrics "k8s.io/apiserver/pkg/admission/metrics" @@ -42,6 +43,7 @@ import ( "k8s.io/apiserver/pkg/admission/plugin/webhook/generic" webhookrequest "k8s.io/apiserver/pkg/admission/plugin/webhook/request" auditinternal "k8s.io/apiserver/pkg/apis/audit" + endpointsrequest "k8s.io/apiserver/pkg/endpoints/request" webhookutil "k8s.io/apiserver/pkg/util/webhook" "k8s.io/apiserver/pkg/warning" utiltrace "k8s.io/utils/trace" @@ -61,8 +63,6 @@ const ( MutationAuditAnnotationFailedOpenKeyPrefix string = "failed-open." + MutationAuditAnnotationPrefix ) -var encodingjson = json.CaseSensitiveJSONIterator() - type mutatingDispatcher struct { cm *webhookutil.ClientManager plugin *Plugin @@ -148,17 +148,21 @@ func (a *mutatingDispatcher) Dispatch(ctx context.Context, attr admission.Attrib case *webhookutil.ErrCallingWebhook: if !ignoreClientCallFailures { rejected = true - admissionmetrics.Metrics.ObserveWebhookRejection(ctx, hook.Name, "admit", string(versionedAttr.Attributes.GetOperation()), admissionmetrics.WebhookRejectionCallingWebhookError, 0) + admissionmetrics.Metrics.ObserveWebhookRejection(ctx, hook.Name, "admit", string(versionedAttr.Attributes.GetOperation()), admissionmetrics.WebhookRejectionCallingWebhookError, int(err.Status.ErrStatus.Code)) } + admissionmetrics.Metrics.ObserveWebhook(ctx, hook.Name, time.Since(t), rejected, versionedAttr.Attributes, "admit", int(err.Status.ErrStatus.Code)) case *webhookutil.ErrWebhookRejection: rejected = true admissionmetrics.Metrics.ObserveWebhookRejection(ctx, hook.Name, "admit", string(versionedAttr.Attributes.GetOperation()), admissionmetrics.WebhookRejectionNoError, int(err.Status.ErrStatus.Code)) + admissionmetrics.Metrics.ObserveWebhook(ctx, hook.Name, time.Since(t), rejected, versionedAttr.Attributes, "admit", int(err.Status.ErrStatus.Code)) default: rejected = true admissionmetrics.Metrics.ObserveWebhookRejection(ctx, hook.Name, "admit", string(versionedAttr.Attributes.GetOperation()), admissionmetrics.WebhookRejectionAPIServerInternalError, 0) + admissionmetrics.Metrics.ObserveWebhook(ctx, hook.Name, time.Since(t), rejected, versionedAttr.Attributes, "admit", 0) } + } else { + admissionmetrics.Metrics.ObserveWebhook(ctx, hook.Name, time.Since(t), rejected, versionedAttr.Attributes, "admit", 200) } - admissionmetrics.Metrics.ObserveWebhook(ctx, time.Since(t), rejected, versionedAttr.Attributes, "admit", hook.Name) if changed { // Patch had changed the object. Prepare to reinvoke all previous webhooks that are eligible for re-invocation. webhookReinvokeCtx.RequireReinvokingPreviouslyInvokedPlugins() @@ -213,7 +217,7 @@ func (a *mutatingDispatcher) callAttrMutatingHook(ctx context.Context, h *admiss defer func() { annotator.addMutationAnnotation(changed) }() if attr.Attributes.IsDryRun() { if h.SideEffects == nil { - return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("Webhook SideEffects is nil")} + return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("Webhook SideEffects is nil"), Status: apierrors.NewBadRequest("Webhook SideEffects is nil")} } if !(*h.SideEffects == admissionregistrationv1.SideEffectClassNone || *h.SideEffects == admissionregistrationv1.SideEffectClassNoneOnDryRun) { return false, webhookerrors.NewDryRunUnsupportedErr(h.Name) @@ -222,12 +226,12 @@ func (a *mutatingDispatcher) callAttrMutatingHook(ctx context.Context, h *admiss uid, request, response, err := webhookrequest.CreateAdmissionObjects(attr, invocation) if err != nil { - return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("could not create admission objects: %w", err)} + return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("could not create admission objects: %w", err), Status: apierrors.NewBadRequest("error creating admission objects")} } // Make the webhook request client, err := invocation.Webhook.GetRESTClient(a.cm) if err != nil { - return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("could not get REST client: %w", err)} + return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("could not get REST client: %w", err), Status: apierrors.NewBadRequest("error getting REST client")} } trace := utiltrace.New("Call mutating webhook", utiltrace.Field{"configuration", configurationName}, @@ -260,14 +264,26 @@ func (a *mutatingDispatcher) callAttrMutatingHook(ctx context.Context, h *admiss } } - if err := r.Do(ctx).Into(response); err != nil { - return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("failed to call webhook: %w", err)} + do := func() { err = r.Do(ctx).Into(response) } + if wd, ok := endpointsrequest.WebhookDurationFrom(ctx); ok { + tmp := do + do = func() { wd.AdmitTracker.Track(tmp) } + } + do() + if err != nil { + var status *apierrors.StatusError + if se, ok := err.(*apierrors.StatusError); ok { + status = se + } else { + status = apierrors.NewBadRequest("error calling webhook") + } + return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("failed to call webhook: %w", err), Status: status} } trace.Step("Request completed") result, err := webhookrequest.VerifyAdmissionResponse(uid, true, response) if err != nil { - return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("received invalid webhook response: %w", err)} + return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("received invalid webhook response: %w", err), Status: apierrors.NewServiceUnavailable("error validating webhook response")} } for k, v := range result.AuditAnnotations { @@ -315,7 +331,7 @@ func (a *mutatingDispatcher) callAttrMutatingHook(ctx context.Context, h *admiss return false, apierrors.NewInternalError(err) } default: - return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("unsupported patch type %q", result.PatchType)} + return false, &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("unsupported patch type %q", result.PatchType), Status: webhookerrors.ToStatusErr(h.Name, result.Result)} } var newVersionedObject runtime.Object @@ -434,7 +450,7 @@ func mutationAnnotationValue(configuration, webhook string, mutated bool) (strin Webhook: webhook, Mutated: mutated, } - bytes, err := encodingjson.Marshal(m) + bytes, err := utiljson.Marshal(m) return string(bytes), err } @@ -445,6 +461,6 @@ func jsonPatchAnnotationValue(configuration, webhook string, patch interface{}) Patch: patch, PatchType: string(admissionv1.PatchTypeJSONPatch), } - bytes, err := encodingjson.Marshal(p) + bytes, err := utiljson.Marshal(p) return string(bytes), err } diff --git a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/validating/dispatcher.go b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/validating/dispatcher.go index 250bb02a78..56099695a6 100644 --- a/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/validating/dispatcher.go +++ b/vendor/k8s.io/apiserver/pkg/admission/plugin/webhook/validating/dispatcher.go @@ -32,6 +32,7 @@ import ( webhookerrors "k8s.io/apiserver/pkg/admission/plugin/webhook/errors" "k8s.io/apiserver/pkg/admission/plugin/webhook/generic" webhookrequest "k8s.io/apiserver/pkg/admission/plugin/webhook/request" + endpointsrequest "k8s.io/apiserver/pkg/endpoints/request" webhookutil "k8s.io/apiserver/pkg/util/webhook" "k8s.io/apiserver/pkg/warning" "k8s.io/klog/v2" @@ -119,18 +120,20 @@ func (d *validatingDispatcher) Dispatch(ctx context.Context, attr admission.Attr case *webhookutil.ErrCallingWebhook: if !ignoreClientCallFailures { rejected = true - admissionmetrics.Metrics.ObserveWebhookRejection(ctx, hook.Name, "validating", string(versionedAttr.Attributes.GetOperation()), admissionmetrics.WebhookRejectionCallingWebhookError, 0) + admissionmetrics.Metrics.ObserveWebhookRejection(ctx, hook.Name, "validating", string(versionedAttr.Attributes.GetOperation()), admissionmetrics.WebhookRejectionCallingWebhookError, int(err.Status.ErrStatus.Code)) } + admissionmetrics.Metrics.ObserveWebhook(ctx, hook.Name, time.Since(t), rejected, versionedAttr.Attributes, "validating", int(err.Status.ErrStatus.Code)) case *webhookutil.ErrWebhookRejection: rejected = true admissionmetrics.Metrics.ObserveWebhookRejection(ctx, hook.Name, "validating", string(versionedAttr.Attributes.GetOperation()), admissionmetrics.WebhookRejectionNoError, int(err.Status.ErrStatus.Code)) + admissionmetrics.Metrics.ObserveWebhook(ctx, hook.Name, time.Since(t), rejected, versionedAttr.Attributes, "validating", int(err.Status.ErrStatus.Code)) default: rejected = true admissionmetrics.Metrics.ObserveWebhookRejection(ctx, hook.Name, "validating", string(versionedAttr.Attributes.GetOperation()), admissionmetrics.WebhookRejectionAPIServerInternalError, 0) + admissionmetrics.Metrics.ObserveWebhook(ctx, hook.Name, time.Since(t), rejected, versionedAttr.Attributes, "validating", 0) } - } - admissionmetrics.Metrics.ObserveWebhook(ctx, time.Since(t), rejected, versionedAttr.Attributes, "validating", hook.Name) - if err == nil { + } else { + admissionmetrics.Metrics.ObserveWebhook(ctx, hook.Name, time.Since(t), rejected, versionedAttr.Attributes, "validating", 200) return } @@ -181,7 +184,7 @@ func (d *validatingDispatcher) Dispatch(ctx context.Context, attr admission.Attr func (d *validatingDispatcher) callHook(ctx context.Context, h *v1.ValidatingWebhook, invocation *generic.WebhookInvocation, attr *generic.VersionedAttributes) error { if attr.Attributes.IsDryRun() { if h.SideEffects == nil { - return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("Webhook SideEffects is nil")} + return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("Webhook SideEffects is nil"), Status: apierrors.NewBadRequest("Webhook SideEffects is nil")} } if !(*h.SideEffects == v1.SideEffectClassNone || *h.SideEffects == v1.SideEffectClassNoneOnDryRun) { return webhookerrors.NewDryRunUnsupportedErr(h.Name) @@ -190,12 +193,12 @@ func (d *validatingDispatcher) callHook(ctx context.Context, h *v1.ValidatingWeb uid, request, response, err := webhookrequest.CreateAdmissionObjects(attr, invocation) if err != nil { - return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: err} + return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("could not create admission objects: %w", err), Status: apierrors.NewBadRequest("error creating admission objects")} } // Make the webhook request client, err := invocation.Webhook.GetRESTClient(d.cm) if err != nil { - return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: err} + return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("could not get REST client: %w", err), Status: apierrors.NewBadRequest("error getting REST client")} } trace := utiltrace.New("Call validating webhook", utiltrace.Field{"configuration", invocation.Webhook.GetConfigurationName()}, @@ -228,14 +231,26 @@ func (d *validatingDispatcher) callHook(ctx context.Context, h *v1.ValidatingWeb } } - if err := r.Do(ctx).Into(response); err != nil { - return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: err} + do := func() { err = r.Do(ctx).Into(response) } + if wd, ok := endpointsrequest.WebhookDurationFrom(ctx); ok { + tmp := do + do = func() { wd.ValidateTracker.Track(tmp) } + } + do() + if err != nil { + var status *apierrors.StatusError + if se, ok := err.(*apierrors.StatusError); ok { + status = se + } else { + status = apierrors.NewBadRequest("error calling webhook") + } + return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("failed to call webhook: %w", err), Status: status} } trace.Step("Request completed") result, err := webhookrequest.VerifyAdmissionResponse(uid, false, response) if err != nil { - return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: err} + return &webhookutil.ErrCallingWebhook{WebhookName: h.Name, Reason: fmt.Errorf("received invalid webhook response: %w", err), Status: apierrors.NewServiceUnavailable("error validating webhook response")} } for k, v := range result.AuditAnnotations { diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/types.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/types.go index 6b30c0fc23..1d723d5e36 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/types.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/types.go @@ -62,8 +62,7 @@ type EgressSelectorConfiguration struct { // EgressSelection provides the configuration for a single egress selection client. type EgressSelection struct { // Name is the name of the egress selection. - // Currently supported values are "controlplane", "master", "etcd" and "cluster" - // The "master" egress selector is deprecated in favor of "controlplane" + // Currently supported values are "controlplane", "etcd" and "cluster" Name string // Connection is the exact information used to configure the egress selection diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.conversion.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.conversion.go index 5116139ae9..22562c87a0 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.deepcopy.go index a0e039de0d..d1bc5e01f5 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.defaults.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.defaults.go index cce2e603a6..dac177e93b 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/conversion.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/conversion.go new file mode 100644 index 0000000000..31b8b7064b --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/conversion.go @@ -0,0 +1,32 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1alpha1 + +import ( + conversion "k8s.io/apimachinery/pkg/conversion" + apiserver "k8s.io/apiserver/pkg/apis/apiserver" +) + +func Convert_v1alpha1_EgressSelection_To_apiserver_EgressSelection(in *EgressSelection, out *apiserver.EgressSelection, s conversion.Scope) error { + if err := autoConvert_v1alpha1_EgressSelection_To_apiserver_EgressSelection(in, out, s); err != nil { + return err + } + if out.Name == "master" { + out.Name = "controlplane" + } + return nil +} diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.conversion.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.conversion.go index 0a5f3d413c..e60f2f3b70 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -65,11 +66,6 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } - if err := s.AddGeneratedConversionFunc((*EgressSelection)(nil), (*apiserver.EgressSelection)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_v1alpha1_EgressSelection_To_apiserver_EgressSelection(a.(*EgressSelection), b.(*apiserver.EgressSelection), scope) - }); err != nil { - return err - } if err := s.AddGeneratedConversionFunc((*apiserver.EgressSelection)(nil), (*EgressSelection)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_apiserver_EgressSelection_To_v1alpha1_EgressSelection(a.(*apiserver.EgressSelection), b.(*EgressSelection), scope) }); err != nil { @@ -135,6 +131,11 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } + if err := s.AddConversionFunc((*EgressSelection)(nil), (*apiserver.EgressSelection)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha1_EgressSelection_To_apiserver_EgressSelection(a.(*EgressSelection), b.(*apiserver.EgressSelection), scope) + }); err != nil { + return err + } return nil } @@ -212,11 +213,6 @@ func autoConvert_v1alpha1_EgressSelection_To_apiserver_EgressSelection(in *Egres return nil } -// Convert_v1alpha1_EgressSelection_To_apiserver_EgressSelection is an autogenerated conversion function. -func Convert_v1alpha1_EgressSelection_To_apiserver_EgressSelection(in *EgressSelection, out *apiserver.EgressSelection, s conversion.Scope) error { - return autoConvert_v1alpha1_EgressSelection_To_apiserver_EgressSelection(in, out, s) -} - func autoConvert_apiserver_EgressSelection_To_v1alpha1_EgressSelection(in *apiserver.EgressSelection, out *EgressSelection, s conversion.Scope) error { out.Name = in.Name if err := Convert_apiserver_Connection_To_v1alpha1_Connection(&in.Connection, &out.Connection, s); err != nil { @@ -231,7 +227,17 @@ func Convert_apiserver_EgressSelection_To_v1alpha1_EgressSelection(in *apiserver } func autoConvert_v1alpha1_EgressSelectorConfiguration_To_apiserver_EgressSelectorConfiguration(in *EgressSelectorConfiguration, out *apiserver.EgressSelectorConfiguration, s conversion.Scope) error { - out.EgressSelections = *(*[]apiserver.EgressSelection)(unsafe.Pointer(&in.EgressSelections)) + if in.EgressSelections != nil { + in, out := &in.EgressSelections, &out.EgressSelections + *out = make([]apiserver.EgressSelection, len(*in)) + for i := range *in { + if err := Convert_v1alpha1_EgressSelection_To_apiserver_EgressSelection(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.EgressSelections = nil + } return nil } @@ -241,7 +247,17 @@ func Convert_v1alpha1_EgressSelectorConfiguration_To_apiserver_EgressSelectorCon } func autoConvert_apiserver_EgressSelectorConfiguration_To_v1alpha1_EgressSelectorConfiguration(in *apiserver.EgressSelectorConfiguration, out *EgressSelectorConfiguration, s conversion.Scope) error { - out.EgressSelections = *(*[]EgressSelection)(unsafe.Pointer(&in.EgressSelections)) + if in.EgressSelections != nil { + in, out := &in.EgressSelections, &out.EgressSelections + *out = make([]EgressSelection, len(*in)) + for i := range *in { + if err := Convert_apiserver_EgressSelection_To_v1alpha1_EgressSelection(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.EgressSelections = nil + } return nil } diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.deepcopy.go index 3f0fae3f8a..0e95103e01 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.defaults.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.defaults.go index dd621a3acd..5070cb91b9 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1alpha1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/conversion.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/conversion.go new file mode 100644 index 0000000000..d7110eff1b --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/conversion.go @@ -0,0 +1,32 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +import ( + conversion "k8s.io/apimachinery/pkg/conversion" + apiserver "k8s.io/apiserver/pkg/apis/apiserver" +) + +func Convert_v1beta1_EgressSelection_To_apiserver_EgressSelection(in *EgressSelection, out *apiserver.EgressSelection, s conversion.Scope) error { + if err := autoConvert_v1beta1_EgressSelection_To_apiserver_EgressSelection(in, out, s); err != nil { + return err + } + if out.Name == "master" { + out.Name = "controlplane" + } + return nil +} diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.conversion.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.conversion.go index b0e44b7e16..37b0f2f7b7 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -45,11 +46,6 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } - if err := s.AddGeneratedConversionFunc((*EgressSelection)(nil), (*apiserver.EgressSelection)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_v1beta1_EgressSelection_To_apiserver_EgressSelection(a.(*EgressSelection), b.(*apiserver.EgressSelection), scope) - }); err != nil { - return err - } if err := s.AddGeneratedConversionFunc((*apiserver.EgressSelection)(nil), (*EgressSelection)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_apiserver_EgressSelection_To_v1beta1_EgressSelection(a.(*apiserver.EgressSelection), b.(*EgressSelection), scope) }); err != nil { @@ -105,6 +101,11 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } + if err := s.AddConversionFunc((*EgressSelection)(nil), (*apiserver.EgressSelection)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1beta1_EgressSelection_To_apiserver_EgressSelection(a.(*EgressSelection), b.(*apiserver.EgressSelection), scope) + }); err != nil { + return err + } return nil } @@ -138,11 +139,6 @@ func autoConvert_v1beta1_EgressSelection_To_apiserver_EgressSelection(in *Egress return nil } -// Convert_v1beta1_EgressSelection_To_apiserver_EgressSelection is an autogenerated conversion function. -func Convert_v1beta1_EgressSelection_To_apiserver_EgressSelection(in *EgressSelection, out *apiserver.EgressSelection, s conversion.Scope) error { - return autoConvert_v1beta1_EgressSelection_To_apiserver_EgressSelection(in, out, s) -} - func autoConvert_apiserver_EgressSelection_To_v1beta1_EgressSelection(in *apiserver.EgressSelection, out *EgressSelection, s conversion.Scope) error { out.Name = in.Name if err := Convert_apiserver_Connection_To_v1beta1_Connection(&in.Connection, &out.Connection, s); err != nil { @@ -157,7 +153,17 @@ func Convert_apiserver_EgressSelection_To_v1beta1_EgressSelection(in *apiserver. } func autoConvert_v1beta1_EgressSelectorConfiguration_To_apiserver_EgressSelectorConfiguration(in *EgressSelectorConfiguration, out *apiserver.EgressSelectorConfiguration, s conversion.Scope) error { - out.EgressSelections = *(*[]apiserver.EgressSelection)(unsafe.Pointer(&in.EgressSelections)) + if in.EgressSelections != nil { + in, out := &in.EgressSelections, &out.EgressSelections + *out = make([]apiserver.EgressSelection, len(*in)) + for i := range *in { + if err := Convert_v1beta1_EgressSelection_To_apiserver_EgressSelection(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.EgressSelections = nil + } return nil } @@ -167,7 +173,17 @@ func Convert_v1beta1_EgressSelectorConfiguration_To_apiserver_EgressSelectorConf } func autoConvert_apiserver_EgressSelectorConfiguration_To_v1beta1_EgressSelectorConfiguration(in *apiserver.EgressSelectorConfiguration, out *EgressSelectorConfiguration, s conversion.Scope) error { - out.EgressSelections = *(*[]EgressSelection)(unsafe.Pointer(&in.EgressSelections)) + if in.EgressSelections != nil { + in, out := &in.EgressSelections, &out.EgressSelections + *out = make([]EgressSelection, len(*in)) + for i := range *in { + if err := Convert_apiserver_EgressSelection_To_v1beta1_EgressSelection(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.EgressSelections = nil + } return nil } diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.deepcopy.go index eda0eaffc4..bb1819cac6 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.defaults.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.defaults.go index 73e63fc114..198b5be4af 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/v1beta1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/apiserver/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/apiserver/zz_generated.deepcopy.go index 55321b084c..86acce65f8 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/apiserver/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/apiserver/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/types.go b/vendor/k8s.io/apiserver/pkg/apis/audit/types.go index e94a60093f..596e022026 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/types.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/types.go @@ -172,6 +172,15 @@ type Policy struct { // be specified per rule in which case the union of both are omitted. // +optional OmitStages []Stage + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // This is used as a global default - a value of 'true' will omit the managed fileds, + // otherwise the managed fields will be included in the API audit log. + // Note that this can also be specified per rule in which case the value specified + // in a rule will override the global default. + // +optional + OmitManagedFields bool } // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object @@ -232,6 +241,17 @@ type PolicyRule struct { // An empty list means no restrictions will apply. // +optional OmitStages []Stage + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // - a value of 'true' will drop the managed fields from the API audit log + // - a value of 'false' indicates that the managed fileds should be included + // in the API audit log + // Note that the value, if specified, in this rule will override the global default + // If a value is not specified then the global default specified in + // Policy.OmitManagedFields will stand. + // +optional + OmitManagedFields *bool } // GroupResources represents resource kinds in an API group. diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/generated.pb.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/generated.pb.go index c569f50681..32b1e98e2c 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/generated.pb.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/generated.pb.go @@ -261,85 +261,88 @@ func init() { } var fileDescriptor_4982ac40a460d730 = []byte{ - // 1243 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcd, 0x8e, 0x1b, 0x45, - 0x10, 0xde, 0x59, 0xaf, 0xb3, 0x76, 0x3b, 0xeb, 0x75, 0x3a, 0x11, 0x19, 0xed, 0xc1, 0x36, 0x46, - 0x42, 0x06, 0x96, 0x99, 0xec, 0x12, 0x48, 0x14, 0x09, 0x24, 0x5b, 0x89, 0xc0, 0x22, 0xd9, 0xac, - 0xda, 0x38, 0x07, 0xc4, 0x21, 0xe3, 0x71, 0xc5, 0x1e, 0x6c, 0xcf, 0x4c, 0xba, 0x7b, 0x8c, 0xf6, - 0xc6, 0x0b, 0x20, 0x71, 0xe7, 0x2d, 0xb8, 0x45, 0xbc, 0x40, 0x8e, 0x39, 0xe6, 0x64, 0x11, 0xc3, - 0x43, 0xa0, 0x9c, 0x50, 0xff, 0xcc, 0x8f, 0xbd, 0x6b, 0xc5, 0xcb, 0x81, 0xdb, 0x74, 0xd5, 0xf7, - 0x7d, 0x55, 0x5d, 0xd3, 0x55, 0xdd, 0xe8, 0xdb, 0xf1, 0x5d, 0x66, 0x79, 0x81, 0x3d, 0x8e, 0xfa, - 0x40, 0x7d, 0xe0, 0xc0, 0xec, 0x19, 0xf8, 0x83, 0x80, 0xda, 0xda, 0xe1, 0x84, 0x1e, 0x03, 0x3a, - 0x03, 0x6a, 0x87, 0xe3, 0xa1, 0x5c, 0xd9, 0x4e, 0x34, 0xf0, 0xb8, 0x3d, 0x3b, 0xb2, 0x87, 0xe0, - 0x03, 0x75, 0x38, 0x0c, 0xac, 0x90, 0x06, 0x3c, 0xc0, 0x0d, 0xc5, 0xb1, 0x12, 0x8e, 0x15, 0x8e, - 0x87, 0x72, 0x65, 0x49, 0x8e, 0x35, 0x3b, 0x3a, 0xf8, 0x74, 0xe8, 0xf1, 0x51, 0xd4, 0xb7, 0xdc, - 0x60, 0x6a, 0x0f, 0x83, 0x61, 0x60, 0x4b, 0x6a, 0x3f, 0x7a, 0x26, 0x57, 0x72, 0x21, 0xbf, 0x94, - 0xe4, 0xc1, 0x61, 0x9a, 0x86, 0xed, 0x44, 0x7c, 0x04, 0x3e, 0xf7, 0x5c, 0x87, 0x7b, 0x81, 0x7f, - 0x41, 0x02, 0x07, 0xb7, 0x53, 0xf4, 0xd4, 0x71, 0x47, 0x9e, 0x0f, 0xf4, 0x2c, 0xcd, 0x7b, 0x0a, - 0xdc, 0xb9, 0x88, 0x65, 0xaf, 0x63, 0xd1, 0xc8, 0xe7, 0xde, 0x14, 0xce, 0x11, 0xbe, 0x78, 0x17, - 0x81, 0xb9, 0x23, 0x98, 0x3a, 0xab, 0xbc, 0xc6, 0xdf, 0x08, 0xe5, 0x1f, 0xcc, 0xc0, 0xe7, 0xf8, - 0x10, 0xe5, 0x27, 0x30, 0x83, 0x89, 0x69, 0xd4, 0x8d, 0x66, 0xb1, 0xfd, 0xde, 0xcb, 0x79, 0x6d, - 0x6b, 0x31, 0xaf, 0xe5, 0x1f, 0x0a, 0xe3, 0xdb, 0xf8, 0x83, 0x28, 0x10, 0x3e, 0x41, 0xbb, 0xb2, - 0x7e, 0x9d, 0xfb, 0xe6, 0xb6, 0xc4, 0xdf, 0xd6, 0xf8, 0xdd, 0x96, 0x32, 0xbf, 0x9d, 0xd7, 0xde, - 0x5f, 0x97, 0x13, 0x3f, 0x0b, 0x81, 0x59, 0xbd, 0xce, 0x7d, 0x12, 0x8b, 0x88, 0xe8, 0x8c, 0x3b, - 0x43, 0x30, 0x73, 0xcb, 0xd1, 0xbb, 0xc2, 0xf8, 0x36, 0xfe, 0x20, 0x0a, 0x84, 0x8f, 0x11, 0xa2, - 0xf0, 0x3c, 0x02, 0xc6, 0x7b, 0xa4, 0x63, 0xee, 0x48, 0x0a, 0xd6, 0x14, 0x44, 0x12, 0x0f, 0xc9, - 0xa0, 0x70, 0x1d, 0xed, 0xcc, 0x80, 0xf6, 0xcd, 0xbc, 0x44, 0x5f, 0xd5, 0xe8, 0x9d, 0x27, 0x40, - 0xfb, 0x44, 0x7a, 0xf0, 0x37, 0x68, 0x27, 0x62, 0x40, 0xcd, 0x2b, 0x75, 0xa3, 0x59, 0x3a, 0xfe, - 0xd0, 0x4a, 0x8f, 0x8e, 0xb5, 0xfc, 0x9f, 0xad, 0xd9, 0x91, 0xd5, 0x63, 0x40, 0x3b, 0xfe, 0xb3, - 0x20, 0x55, 0x12, 0x16, 0x22, 0x15, 0xf0, 0x08, 0x55, 0xbc, 0x69, 0x08, 0x94, 0x05, 0xbe, 0xa8, - 0xb5, 0xf0, 0x98, 0xbb, 0x97, 0x52, 0xbd, 0xb1, 0x98, 0xd7, 0x2a, 0x9d, 0x15, 0x0d, 0x72, 0x4e, - 0x15, 0x7f, 0x82, 0x8a, 0x2c, 0x88, 0xa8, 0x0b, 0x9d, 0x53, 0x66, 0x16, 0xea, 0xb9, 0x66, 0xb1, - 0xbd, 0xb7, 0x98, 0xd7, 0x8a, 0xdd, 0xd8, 0x48, 0x52, 0x3f, 0xb6, 0x51, 0x51, 0xa4, 0xd7, 0x1a, - 0x82, 0xcf, 0xcd, 0x8a, 0xac, 0xc3, 0x35, 0x9d, 0x7d, 0xb1, 0x17, 0x3b, 0x48, 0x8a, 0xc1, 0x4f, - 0x51, 0x31, 0xe8, 0xff, 0x08, 0x2e, 0x27, 0xf0, 0xcc, 0x2c, 0xca, 0x0d, 0x7c, 0x66, 0xbd, 0xbb, - 0xa3, 0xac, 0xc7, 0x31, 0x09, 0x28, 0xf8, 0x2e, 0xa8, 0x94, 0x12, 0x23, 0x49, 0x45, 0xf1, 0x08, - 0x95, 0x29, 0xb0, 0x30, 0xf0, 0x19, 0x74, 0xb9, 0xc3, 0x23, 0x66, 0x22, 0x19, 0xe6, 0x30, 0x13, - 0x26, 0x39, 0x3c, 0x69, 0x24, 0xd1, 0x37, 0x22, 0x90, 0xe2, 0xb4, 0xf1, 0x62, 0x5e, 0x2b, 0x93, - 0x25, 0x1d, 0xb2, 0xa2, 0x8b, 0x1d, 0xb4, 0xa7, 0x4f, 0x83, 0x4a, 0xc4, 0x2c, 0xc9, 0x40, 0xcd, - 0xb5, 0x81, 0x74, 0xe7, 0x58, 0x3d, 0x7f, 0xec, 0x07, 0x3f, 0xf9, 0xed, 0x6b, 0x8b, 0x79, 0x6d, - 0x8f, 0x64, 0x25, 0xc8, 0xb2, 0x22, 0x1e, 0xa4, 0x9b, 0xd1, 0x31, 0xae, 0x5e, 0x32, 0xc6, 0xd2, - 0x46, 0x74, 0x90, 0x15, 0x4d, 0xfc, 0x8b, 0x81, 0x4c, 0x1d, 0x97, 0x80, 0x0b, 0xde, 0x0c, 0x06, - 0xdf, 0x79, 0x53, 0x60, 0xdc, 0x99, 0x86, 0xe6, 0x9e, 0x0c, 0x68, 0x6f, 0x56, 0xbd, 0x47, 0x9e, - 0x4b, 0x03, 0xc1, 0x6d, 0xd7, 0xf5, 0x31, 0x30, 0xc9, 0x1a, 0x61, 0xb2, 0x36, 0x24, 0x0e, 0x50, - 0x59, 0x76, 0x65, 0x9a, 0x44, 0xf9, 0xbf, 0x25, 0x11, 0x37, 0x7d, 0xb9, 0xbb, 0x24, 0x47, 0x56, - 0xe4, 0xf1, 0x73, 0x54, 0x72, 0x7c, 0x3f, 0xe0, 0xb2, 0x6b, 0x98, 0xb9, 0x5f, 0xcf, 0x35, 0x4b, - 0xc7, 0xf7, 0x36, 0x39, 0x97, 0x72, 0xd2, 0x59, 0xad, 0x94, 0xfc, 0xc0, 0xe7, 0xf4, 0xac, 0x7d, - 0x5d, 0x07, 0x2e, 0x65, 0x3c, 0x24, 0x1b, 0xe3, 0xe0, 0x2b, 0x54, 0x59, 0x65, 0xe1, 0x0a, 0xca, - 0x8d, 0xe1, 0x4c, 0x8d, 0x4b, 0x22, 0x3e, 0xf1, 0x0d, 0x94, 0x9f, 0x39, 0x93, 0x08, 0xd4, 0x48, - 0x24, 0x6a, 0x71, 0x6f, 0xfb, 0xae, 0xd1, 0x78, 0x61, 0xa0, 0xa2, 0x0c, 0xfe, 0xd0, 0x63, 0x1c, - 0xff, 0x80, 0x0a, 0x62, 0xf7, 0x03, 0x87, 0x3b, 0x92, 0x5e, 0x3a, 0xb6, 0x36, 0xab, 0x95, 0x60, - 0x3f, 0x02, 0xee, 0xb4, 0x2b, 0x3a, 0xe3, 0x42, 0x6c, 0x21, 0x89, 0x22, 0x3e, 0x41, 0x79, 0x8f, - 0xc3, 0x94, 0x99, 0xdb, 0xb2, 0x30, 0x1f, 0x6d, 0x5c, 0x98, 0xf6, 0x5e, 0x3c, 0x75, 0x3b, 0x82, - 0x4f, 0x94, 0x4c, 0xe3, 0x37, 0x03, 0x95, 0xbf, 0xa6, 0x41, 0x14, 0x12, 0x50, 0xa3, 0x84, 0xe1, - 0x0f, 0x50, 0x7e, 0x28, 0x2c, 0xfa, 0xae, 0x48, 0x78, 0x0a, 0xa6, 0x7c, 0x62, 0x34, 0xd1, 0x98, - 0x21, 0x73, 0xd1, 0xa3, 0x29, 0x91, 0x21, 0xa9, 0x1f, 0xdf, 0x11, 0xdd, 0xa9, 0x16, 0x27, 0xce, - 0x14, 0x98, 0x99, 0x93, 0x04, 0xdd, 0x73, 0x19, 0x07, 0x59, 0xc6, 0x35, 0x7e, 0xcf, 0xa1, 0xfd, - 0x95, 0x71, 0x83, 0x0f, 0x51, 0x21, 0x06, 0xe9, 0x0c, 0x93, 0x7a, 0xc5, 0x5a, 0x24, 0x41, 0x88, - 0xa9, 0xe8, 0x0b, 0xa9, 0xd0, 0x71, 0xf5, 0x9f, 0x4b, 0xa7, 0xe2, 0x49, 0xec, 0x20, 0x29, 0x46, - 0xdc, 0x24, 0x62, 0xa1, 0xaf, 0xaa, 0x64, 0xfe, 0x0b, 0x2c, 0x91, 0x1e, 0xdc, 0x46, 0xb9, 0xc8, - 0x1b, 0xe8, 0x8b, 0xe9, 0x96, 0x06, 0xe4, 0x7a, 0x9b, 0xde, 0x8a, 0x82, 0x2c, 0x36, 0xe1, 0x84, - 0x9e, 0xac, 0xa8, 0xbe, 0xb3, 0x92, 0x4d, 0xb4, 0x4e, 0x3b, 0xaa, 0xd2, 0x09, 0x42, 0xdc, 0x88, - 0x4e, 0xe8, 0x3d, 0x01, 0xca, 0xbc, 0xc0, 0x97, 0x37, 0x58, 0xe6, 0x46, 0x6c, 0x9d, 0x76, 0xb4, - 0x87, 0x64, 0x50, 0xb8, 0x85, 0xf6, 0xe3, 0x22, 0xc4, 0xc4, 0x5d, 0x49, 0xbc, 0xa9, 0x89, 0xfb, - 0x64, 0xd9, 0x4d, 0x56, 0xf1, 0xf8, 0x73, 0x54, 0x62, 0x51, 0x3f, 0x29, 0x76, 0x41, 0xd2, 0x93, - 0x76, 0xea, 0xa6, 0x2e, 0x92, 0xc5, 0x35, 0xfe, 0x31, 0xd0, 0x95, 0xd3, 0x60, 0xe2, 0xb9, 0x67, - 0xf8, 0xe9, 0xb9, 0x5e, 0xb8, 0xb5, 0x59, 0x2f, 0xa8, 0x9f, 0x2e, 0xbb, 0x21, 0xd9, 0x68, 0x6a, - 0xcb, 0xf4, 0x43, 0x17, 0xe5, 0x69, 0x34, 0x81, 0xb8, 0x1f, 0xac, 0x4d, 0xfa, 0x41, 0x25, 0x47, - 0xa2, 0x09, 0xa4, 0x87, 0x5b, 0xac, 0x18, 0x51, 0x5a, 0xf8, 0x0e, 0x42, 0xc1, 0xd4, 0xe3, 0x72, - 0x52, 0xc5, 0x87, 0xf5, 0xa6, 0x4c, 0x21, 0xb1, 0xa6, 0xaf, 0x96, 0x0c, 0xb4, 0xf1, 0x87, 0x81, - 0x90, 0x52, 0xff, 0x1f, 0x46, 0xc1, 0xe3, 0xe5, 0x51, 0xf0, 0xf1, 0xe6, 0x5b, 0x5f, 0x33, 0x0b, - 0x5e, 0xe4, 0xe2, 0xec, 0x45, 0x35, 0x2e, 0xf9, 0x66, 0xac, 0xa1, 0xbc, 0x78, 0x5a, 0xc4, 0xc3, - 0xa0, 0x28, 0x90, 0xe2, 0xd9, 0xc1, 0x88, 0xb2, 0x63, 0x0b, 0x21, 0xf1, 0x21, 0x4f, 0x74, 0x5c, - 0xd4, 0xb2, 0x28, 0x6a, 0x2f, 0xb1, 0x92, 0x0c, 0x42, 0x08, 0x8a, 0x87, 0x1b, 0x33, 0x77, 0x52, - 0x41, 0xf1, 0x9e, 0x63, 0x44, 0xd9, 0xb1, 0x9b, 0x1d, 0x41, 0x79, 0x59, 0x83, 0xe3, 0x4d, 0x6a, - 0xb0, 0x3c, 0xee, 0xd2, 0x71, 0x70, 0xe1, 0xe8, 0xb2, 0x10, 0x4a, 0x66, 0x03, 0x33, 0xaf, 0xa4, - 0x59, 0x27, 0xc3, 0x83, 0x91, 0x0c, 0x02, 0x7f, 0x89, 0xf6, 0xfd, 0xc0, 0x8f, 0xa5, 0x7a, 0xe4, - 0x21, 0x33, 0x77, 0x25, 0xe9, 0xba, 0x68, 0xb9, 0x93, 0x65, 0x17, 0x59, 0xc5, 0xae, 0x9c, 0xbc, - 0xc2, 0xc6, 0x27, 0xaf, 0xdd, 0x7c, 0xf9, 0xa6, 0xba, 0xf5, 0xea, 0x4d, 0x75, 0xeb, 0xf5, 0x9b, - 0xea, 0xd6, 0xcf, 0x8b, 0xaa, 0xf1, 0x72, 0x51, 0x35, 0x5e, 0x2d, 0xaa, 0xc6, 0xeb, 0x45, 0xd5, - 0xf8, 0x73, 0x51, 0x35, 0x7e, 0xfd, 0xab, 0xba, 0xf5, 0xfd, 0xf6, 0xec, 0xe8, 0xdf, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x33, 0x6e, 0xcf, 0xc7, 0x82, 0x0d, 0x00, 0x00, + // 1287 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcf, 0x6f, 0x1b, 0xc5, + 0x17, 0xcf, 0xc6, 0x71, 0x63, 0x8f, 0x1b, 0xc7, 0x99, 0xf6, 0xfb, 0xed, 0x92, 0x83, 0x6d, 0x8c, + 0x84, 0x0c, 0x84, 0xdd, 0x26, 0x14, 0x5a, 0x55, 0x02, 0xc9, 0xa6, 0xa5, 0x58, 0xb4, 0x49, 0x34, + 0xc6, 0x3d, 0x20, 0x0e, 0x5d, 0xaf, 0x5f, 0xec, 0xc5, 0xf6, 0xec, 0x76, 0x67, 0xd6, 0x28, 0x37, + 0xfe, 0x01, 0x24, 0xee, 0xfc, 0x17, 0xdc, 0x10, 0x27, 0x6e, 0x39, 0xf6, 0xd8, 0x93, 0x45, 0x0c, + 0x7f, 0x45, 0x0e, 0x08, 0xcd, 0xec, 0xec, 0x0f, 0x3b, 0xb1, 0xea, 0x70, 0xe0, 0xb6, 0xf3, 0xde, + 0xe7, 0xf3, 0x79, 0x6f, 0xdf, 0xbe, 0xf7, 0x66, 0xd1, 0x57, 0xc3, 0x07, 0xcc, 0x70, 0x5c, 0x73, + 0x18, 0x74, 0xc1, 0xa7, 0xc0, 0x81, 0x99, 0x13, 0xa0, 0x3d, 0xd7, 0x37, 0x95, 0xc3, 0xf2, 0x1c, + 0x06, 0xfe, 0x04, 0x7c, 0xd3, 0x1b, 0xf6, 0xe5, 0xc9, 0xb4, 0x82, 0x9e, 0xc3, 0xcd, 0xc9, 0xbe, + 0xd9, 0x07, 0x0a, 0xbe, 0xc5, 0xa1, 0x67, 0x78, 0xbe, 0xcb, 0x5d, 0x5c, 0x0b, 0x39, 0x46, 0xcc, + 0x31, 0xbc, 0x61, 0x5f, 0x9e, 0x0c, 0xc9, 0x31, 0x26, 0xfb, 0xbb, 0x1f, 0xf6, 0x1d, 0x3e, 0x08, + 0xba, 0x86, 0xed, 0x8e, 0xcd, 0xbe, 0xdb, 0x77, 0x4d, 0x49, 0xed, 0x06, 0x27, 0xf2, 0x24, 0x0f, + 0xf2, 0x29, 0x94, 0xdc, 0xdd, 0x4b, 0xd2, 0x30, 0xad, 0x80, 0x0f, 0x80, 0x72, 0xc7, 0xb6, 0xb8, + 0xe3, 0xd2, 0x2b, 0x12, 0xd8, 0xbd, 0x97, 0xa0, 0xc7, 0x96, 0x3d, 0x70, 0x28, 0xf8, 0xa7, 0x49, + 0xde, 0x63, 0xe0, 0xd6, 0x55, 0x2c, 0x73, 0x19, 0xcb, 0x0f, 0x28, 0x77, 0xc6, 0x70, 0x89, 0xf0, + 0xc9, 0x9b, 0x08, 0xcc, 0x1e, 0xc0, 0xd8, 0x5a, 0xe4, 0xd5, 0xfe, 0x42, 0x28, 0xfb, 0x78, 0x02, + 0x94, 0xe3, 0x3d, 0x94, 0x1d, 0xc1, 0x04, 0x46, 0xba, 0x56, 0xd5, 0xea, 0xf9, 0xe6, 0xff, 0xcf, + 0xa6, 0x95, 0xb5, 0xd9, 0xb4, 0x92, 0x7d, 0x2a, 0x8c, 0x17, 0xd1, 0x03, 0x09, 0x41, 0xf8, 0x10, + 0x6d, 0xca, 0xfa, 0xb5, 0x1e, 0xe9, 0xeb, 0x12, 0x7f, 0x4f, 0xe1, 0x37, 0x1b, 0xa1, 0xf9, 0x62, + 0x5a, 0x79, 0x7b, 0x59, 0x4e, 0xfc, 0xd4, 0x03, 0x66, 0x74, 0x5a, 0x8f, 0x48, 0x24, 0x22, 0xa2, + 0x33, 0x6e, 0xf5, 0x41, 0xcf, 0xcc, 0x47, 0x6f, 0x0b, 0xe3, 0x45, 0xf4, 0x40, 0x42, 0x10, 0x3e, + 0x40, 0xc8, 0x87, 0x97, 0x01, 0x30, 0xde, 0x21, 0x2d, 0x7d, 0x43, 0x52, 0xb0, 0xa2, 0x20, 0x12, + 0x7b, 0x48, 0x0a, 0x85, 0xab, 0x68, 0x63, 0x02, 0x7e, 0x57, 0xcf, 0x4a, 0xf4, 0x4d, 0x85, 0xde, + 0x78, 0x0e, 0x7e, 0x97, 0x48, 0x0f, 0xfe, 0x12, 0x6d, 0x04, 0x0c, 0x7c, 0xfd, 0x46, 0x55, 0xab, + 0x17, 0x0e, 0xde, 0x35, 0x92, 0xd6, 0x31, 0xe6, 0xbf, 0xb3, 0x31, 0xd9, 0x37, 0x3a, 0x0c, 0xfc, + 0x16, 0x3d, 0x71, 0x13, 0x25, 0x61, 0x21, 0x52, 0x01, 0x0f, 0x50, 0xc9, 0x19, 0x7b, 0xe0, 0x33, + 0x97, 0x8a, 0x5a, 0x0b, 0x8f, 0xbe, 0x79, 0x2d, 0xd5, 0xdb, 0xb3, 0x69, 0xa5, 0xd4, 0x5a, 0xd0, + 0x20, 0x97, 0x54, 0xf1, 0x07, 0x28, 0xcf, 0xdc, 0xc0, 0xb7, 0xa1, 0x75, 0xcc, 0xf4, 0x5c, 0x35, + 0x53, 0xcf, 0x37, 0xb7, 0x66, 0xd3, 0x4a, 0xbe, 0x1d, 0x19, 0x49, 0xe2, 0xc7, 0x26, 0xca, 0x8b, + 0xf4, 0x1a, 0x7d, 0xa0, 0x5c, 0x2f, 0xc9, 0x3a, 0xec, 0xa8, 0xec, 0xf3, 0x9d, 0xc8, 0x41, 0x12, + 0x0c, 0x7e, 0x81, 0xf2, 0x6e, 0xf7, 0x3b, 0xb0, 0x39, 0x81, 0x13, 0x3d, 0x2f, 0x5f, 0xe0, 0x23, + 0xe3, 0xcd, 0x13, 0x65, 0x1c, 0x45, 0x24, 0xf0, 0x81, 0xda, 0x10, 0xa6, 0x14, 0x1b, 0x49, 0x22, + 0x8a, 0x07, 0xa8, 0xe8, 0x03, 0xf3, 0x5c, 0xca, 0xa0, 0xcd, 0x2d, 0x1e, 0x30, 0x1d, 0xc9, 0x30, + 0x7b, 0xa9, 0x30, 0x71, 0xf3, 0x24, 0x91, 0xc4, 0xdc, 0x88, 0x40, 0x21, 0xa7, 0x89, 0x67, 0xd3, + 0x4a, 0x91, 0xcc, 0xe9, 0x90, 0x05, 0x5d, 0x6c, 0xa1, 0x2d, 0xd5, 0x0d, 0x61, 0x22, 0x7a, 0x41, + 0x06, 0xaa, 0x2f, 0x0d, 0xa4, 0x26, 0xc7, 0xe8, 0xd0, 0x21, 0x75, 0xbf, 0xa7, 0xcd, 0x9d, 0xd9, + 0xb4, 0xb2, 0x45, 0xd2, 0x12, 0x64, 0x5e, 0x11, 0xf7, 0x92, 0x97, 0x51, 0x31, 0x6e, 0x5e, 0x33, + 0xc6, 0xdc, 0x8b, 0xa8, 0x20, 0x0b, 0x9a, 0xf8, 0x47, 0x0d, 0xe9, 0x2a, 0x2e, 0x01, 0x1b, 0x9c, + 0x09, 0xf4, 0xbe, 0x76, 0xc6, 0xc0, 0xb8, 0x35, 0xf6, 0xf4, 0x2d, 0x19, 0xd0, 0x5c, 0xad, 0x7a, + 0xcf, 0x1c, 0xdb, 0x77, 0x05, 0xb7, 0x59, 0x55, 0x6d, 0xa0, 0x93, 0x25, 0xc2, 0x64, 0x69, 0x48, + 0xec, 0xa2, 0xa2, 0x9c, 0xca, 0x24, 0x89, 0xe2, 0xbf, 0x4b, 0x22, 0x1a, 0xfa, 0x62, 0x7b, 0x4e, + 0x8e, 0x2c, 0xc8, 0xe3, 0x97, 0xa8, 0x60, 0x51, 0xea, 0x72, 0x39, 0x35, 0x4c, 0xdf, 0xae, 0x66, + 0xea, 0x85, 0x83, 0x87, 0xab, 0xf4, 0xa5, 0xdc, 0x74, 0x46, 0x23, 0x21, 0x3f, 0xa6, 0xdc, 0x3f, + 0x6d, 0xde, 0x52, 0x81, 0x0b, 0x29, 0x0f, 0x49, 0xc7, 0xd8, 0xfd, 0x0c, 0x95, 0x16, 0x59, 0xb8, + 0x84, 0x32, 0x43, 0x38, 0x0d, 0xd7, 0x25, 0x11, 0x8f, 0xf8, 0x36, 0xca, 0x4e, 0xac, 0x51, 0x00, + 0xe1, 0x4a, 0x24, 0xe1, 0xe1, 0xe1, 0xfa, 0x03, 0xad, 0xf6, 0xab, 0x86, 0xf2, 0x32, 0xf8, 0x53, + 0x87, 0x71, 0xfc, 0x2d, 0xca, 0x89, 0xb7, 0xef, 0x59, 0xdc, 0x92, 0xf4, 0xc2, 0x81, 0xb1, 0x5a, + 0xad, 0x04, 0xfb, 0x19, 0x70, 0xab, 0x59, 0x52, 0x19, 0xe7, 0x22, 0x0b, 0x89, 0x15, 0xf1, 0x21, + 0xca, 0x3a, 0x1c, 0xc6, 0x4c, 0x5f, 0x97, 0x85, 0x79, 0x6f, 0xe5, 0xc2, 0x34, 0xb7, 0xa2, 0xad, + 0xdb, 0x12, 0x7c, 0x12, 0xca, 0xd4, 0x7e, 0xd6, 0x50, 0xf1, 0x89, 0xef, 0x06, 0x1e, 0x81, 0x70, + 0x95, 0x30, 0xfc, 0x0e, 0xca, 0xf6, 0x85, 0x45, 0xdd, 0x15, 0x31, 0x2f, 0x84, 0x85, 0x3e, 0xb1, + 0x9a, 0xfc, 0x88, 0x21, 0x73, 0x51, 0xab, 0x29, 0x96, 0x21, 0x89, 0x1f, 0xdf, 0x17, 0xd3, 0x19, + 0x1e, 0x0e, 0xad, 0x31, 0x30, 0x3d, 0x23, 0x09, 0x6a, 0xe6, 0x52, 0x0e, 0x32, 0x8f, 0xab, 0xfd, + 0x92, 0x41, 0xdb, 0x0b, 0xeb, 0x06, 0xef, 0xa1, 0x5c, 0x04, 0x52, 0x19, 0xc6, 0xf5, 0x8a, 0xb4, + 0x48, 0x8c, 0x10, 0x5b, 0x91, 0x0a, 0x29, 0xcf, 0xb2, 0xd5, 0x97, 0x4b, 0xb6, 0xe2, 0x61, 0xe4, + 0x20, 0x09, 0x46, 0xdc, 0x24, 0xe2, 0xa0, 0xae, 0xaa, 0x78, 0xff, 0x0b, 0x2c, 0x91, 0x1e, 0xdc, + 0x44, 0x99, 0xc0, 0xe9, 0xa9, 0x8b, 0xe9, 0xae, 0x02, 0x64, 0x3a, 0xab, 0xde, 0x8a, 0x82, 0x2c, + 0x5e, 0xc2, 0xf2, 0x1c, 0x59, 0x51, 0x75, 0x67, 0xc5, 0x2f, 0xd1, 0x38, 0x6e, 0x85, 0x95, 0x8e, + 0x11, 0xe2, 0x46, 0xb4, 0x3c, 0xe7, 0x39, 0xf8, 0xcc, 0x71, 0xa9, 0xbc, 0xc1, 0x52, 0x37, 0x62, + 0xe3, 0xb8, 0xa5, 0x3c, 0x24, 0x85, 0xc2, 0x0d, 0xb4, 0x1d, 0x15, 0x21, 0x22, 0x6e, 0x4a, 0xe2, + 0x1d, 0x45, 0xdc, 0x26, 0xf3, 0x6e, 0xb2, 0x88, 0xc7, 0x1f, 0xa3, 0x02, 0x0b, 0xba, 0x71, 0xb1, + 0x73, 0x92, 0x1e, 0x8f, 0x53, 0x3b, 0x71, 0x91, 0x34, 0xae, 0xf6, 0xfb, 0x3a, 0xba, 0x71, 0xec, + 0x8e, 0x1c, 0xfb, 0x14, 0xbf, 0xb8, 0x34, 0x0b, 0x77, 0x57, 0x9b, 0x85, 0xf0, 0xa3, 0xcb, 0x69, + 0x88, 0x5f, 0x34, 0xb1, 0xa5, 0xe6, 0xa1, 0x8d, 0xb2, 0x7e, 0x30, 0x82, 0x68, 0x1e, 0x8c, 0x55, + 0xe6, 0x21, 0x4c, 0x8e, 0x04, 0x23, 0x48, 0x9a, 0x5b, 0x9c, 0x18, 0x09, 0xb5, 0xf0, 0x7d, 0x84, + 0xdc, 0xb1, 0xc3, 0xe5, 0xa6, 0x8a, 0x9a, 0xf5, 0x8e, 0x4c, 0x21, 0xb6, 0x26, 0x7f, 0x2d, 0x29, + 0x28, 0x7e, 0x82, 0x76, 0xc4, 0xe9, 0x99, 0x45, 0xad, 0x3e, 0xf4, 0xbe, 0x70, 0x60, 0xd4, 0x63, + 0xb2, 0x51, 0x72, 0xcd, 0xb7, 0x54, 0xa4, 0x9d, 0xa3, 0x45, 0x00, 0xb9, 0xcc, 0xa9, 0xfd, 0xa6, + 0x21, 0x14, 0xa6, 0xf9, 0x1f, 0xec, 0x94, 0xa3, 0xf9, 0x9d, 0xf2, 0xfe, 0xea, 0x35, 0x5c, 0xb2, + 0x54, 0xfe, 0xce, 0x44, 0xd9, 0x8b, 0xb2, 0x5e, 0xf3, 0xe7, 0xb3, 0x82, 0xb2, 0xe2, 0x1f, 0x25, + 0xda, 0x2a, 0x79, 0x81, 0x14, 0xff, 0x2f, 0x8c, 0x84, 0x76, 0x6c, 0x20, 0x24, 0x1e, 0xe4, 0x68, + 0x44, 0x5f, 0xa7, 0x28, 0xbe, 0x4e, 0x27, 0xb6, 0x92, 0x14, 0x42, 0x08, 0x8a, 0x3f, 0x40, 0xf1, + 0x21, 0x62, 0x41, 0xf1, 0x63, 0xc8, 0x48, 0x68, 0xc7, 0x76, 0x7a, 0x97, 0x65, 0x65, 0x0d, 0x0e, + 0x56, 0xa9, 0xc1, 0xfc, 0xde, 0x4c, 0xf6, 0xca, 0x95, 0x3b, 0xd0, 0x40, 0x28, 0x5e, 0x32, 0x4c, + 0xbf, 0x91, 0x64, 0x1d, 0x6f, 0x21, 0x46, 0x52, 0x08, 0xfc, 0x29, 0xda, 0xa6, 0x2e, 0x8d, 0xa4, + 0x3a, 0xe4, 0x29, 0xd3, 0x37, 0x25, 0xe9, 0x96, 0x98, 0xdd, 0xc3, 0x79, 0x17, 0x59, 0xc4, 0x2e, + 0xb4, 0x70, 0x6e, 0xf5, 0x16, 0xfe, 0xfc, 0xaa, 0x16, 0xce, 0xcb, 0x16, 0xfe, 0xdf, 0xaa, 0xed, + 0xdb, 0xac, 0x9f, 0x9d, 0x97, 0xd7, 0x5e, 0x9d, 0x97, 0xd7, 0x5e, 0x9f, 0x97, 0xd7, 0x7e, 0x98, + 0x95, 0xb5, 0xb3, 0x59, 0x59, 0x7b, 0x35, 0x2b, 0x6b, 0xaf, 0x67, 0x65, 0xed, 0x8f, 0x59, 0x59, + 0xfb, 0xe9, 0xcf, 0xf2, 0xda, 0x37, 0xeb, 0x93, 0xfd, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x6a, + 0x8e, 0x8a, 0xae, 0x10, 0x0e, 0x00, 0x00, } func (m *Event) Marshal() (dAtA []byte, err error) { @@ -696,6 +699,14 @@ func (m *Policy) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + i-- + if m.OmitManagedFields { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 if len(m.OmitStages) > 0 { for iNdEx := len(m.OmitStages) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.OmitStages[iNdEx]) @@ -799,6 +810,16 @@ func (m *PolicyRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.OmitManagedFields != nil { + i-- + if *m.OmitManagedFields { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } if len(m.OmitStages) > 0 { for iNdEx := len(m.OmitStages) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.OmitStages[iNdEx]) @@ -1032,6 +1053,7 @@ func (m *Policy) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + n += 2 return n } @@ -1102,6 +1124,9 @@ func (m *PolicyRule) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + if m.OmitManagedFields != nil { + n += 2 + } return n } @@ -1204,6 +1229,7 @@ func (this *Policy) String() string { `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`, `Rules:` + repeatedStringForRules + `,`, `OmitStages:` + fmt.Sprintf("%v", this.OmitStages) + `,`, + `OmitManagedFields:` + fmt.Sprintf("%v", this.OmitManagedFields) + `,`, `}`, }, "") return s @@ -1242,6 +1268,7 @@ func (this *PolicyRule) String() string { `Namespaces:` + fmt.Sprintf("%v", this.Namespaces) + `,`, `NonResourceURLs:` + fmt.Sprintf("%v", this.NonResourceURLs) + `,`, `OmitStages:` + fmt.Sprintf("%v", this.OmitStages) + `,`, + `OmitManagedFields:` + valueToStringGenerated(this.OmitManagedFields) + `,`, `}`, }, "") return s @@ -2631,6 +2658,26 @@ func (m *Policy) Unmarshal(dAtA []byte) error { } m.OmitStages = append(m.OmitStages, Stage(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OmitManagedFields", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.OmitManagedFields = bool(v != 0) default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -3056,6 +3103,27 @@ func (m *PolicyRule) Unmarshal(dAtA []byte) error { } m.OmitStages = append(m.OmitStages, Stage(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OmitManagedFields", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.OmitManagedFields = &b default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/generated.proto b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/generated.proto index d142ee7e49..0c20506501 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/generated.proto +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/generated.proto @@ -190,6 +190,15 @@ message Policy { // be specified per rule in which case the union of both are omitted. // +optional repeated string omitStages = 3; + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // This is used as a global default - a value of 'true' will omit the managed fileds, + // otherwise the managed fields will be included in the API audit log. + // Note that this can also be specified per rule in which case the value specified + // in a rule will override the global default. + // +optional + optional bool omitManagedFields = 4; } // PolicyList is a list of audit Policies. @@ -245,5 +254,16 @@ message PolicyRule { // An empty list means no restrictions will apply. // +optional repeated string omitStages = 8; + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // - a value of 'true' will drop the managed fields from the API audit log + // - a value of 'false' indicates that the managed fileds should be included + // in the API audit log + // Note that the value, if specified, in this rule will override the global default + // If a value is not specified then the global default specified in + // Policy.OmitManagedFields will stand. + // +optional + optional bool omitManagedFields = 9; } diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/types.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/types.go index dace73ed95..3f70ebaa51 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/types.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/types.go @@ -166,6 +166,15 @@ type Policy struct { // be specified per rule in which case the union of both are omitted. // +optional OmitStages []Stage `json:"omitStages,omitempty" protobuf:"bytes,3,rep,name=omitStages"` + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // This is used as a global default - a value of 'true' will omit the managed fileds, + // otherwise the managed fields will be included in the API audit log. + // Note that this can also be specified per rule in which case the value specified + // in a rule will override the global default. + // +optional + OmitManagedFields bool `json:"omitManagedFields,omitempty" protobuf:"varint,4,opt,name=omitManagedFields"` } // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object @@ -226,6 +235,17 @@ type PolicyRule struct { // An empty list means no restrictions will apply. // +optional OmitStages []Stage `json:"omitStages,omitempty" protobuf:"bytes,8,rep,name=omitStages"` + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // - a value of 'true' will drop the managed fields from the API audit log + // - a value of 'false' indicates that the managed fileds should be included + // in the API audit log + // Note that the value, if specified, in this rule will override the global default + // If a value is not specified then the global default specified in + // Policy.OmitManagedFields will stand. + // +optional + OmitManagedFields *bool `json:"omitManagedFields,omitempty" protobuf:"varint,9,opt,name=omitManagedFields"` } // GroupResources represents resource kinds in an API group. diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.conversion.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.conversion.go index 4500bfe314..53cbb02084 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -245,6 +246,7 @@ func autoConvert_v1_Policy_To_audit_Policy(in *Policy, out *audit.Policy, s conv out.ObjectMeta = in.ObjectMeta out.Rules = *(*[]audit.PolicyRule)(unsafe.Pointer(&in.Rules)) out.OmitStages = *(*[]audit.Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = in.OmitManagedFields return nil } @@ -257,6 +259,7 @@ func autoConvert_audit_Policy_To_v1_Policy(in *audit.Policy, out *Policy, s conv out.ObjectMeta = in.ObjectMeta out.Rules = *(*[]PolicyRule)(unsafe.Pointer(&in.Rules)) out.OmitStages = *(*[]Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = in.OmitManagedFields return nil } @@ -296,6 +299,7 @@ func autoConvert_v1_PolicyRule_To_audit_PolicyRule(in *PolicyRule, out *audit.Po out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces)) out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs)) out.OmitStages = *(*[]audit.Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = (*bool)(unsafe.Pointer(in.OmitManagedFields)) return nil } @@ -313,6 +317,7 @@ func autoConvert_audit_PolicyRule_To_v1_PolicyRule(in *audit.PolicyRule, out *Po out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces)) out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs)) out.OmitStages = *(*[]Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = (*bool)(unsafe.Pointer(in.OmitManagedFields)) return nil } diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.deepcopy.go index 81d126d4e0..0b1b0052d5 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -277,6 +278,11 @@ func (in *PolicyRule) DeepCopyInto(out *PolicyRule) { *out = make([]Stage, len(*in)) copy(*out, *in) } + if in.OmitManagedFields != nil { + in, out := &in.OmitManagedFields, &out.OmitManagedFields + *out = new(bool) + **out = **in + } return } diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.defaults.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.defaults.go index cce2e603a6..dac177e93b 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.pb.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.pb.go index 4af2810f08..84ceca0b7b 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.pb.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.pb.go @@ -261,86 +261,89 @@ func init() { } var fileDescriptor_46c0b2c8ea67b187 = []byte{ - // 1263 bytes of a gzipped FileDescriptorProto + // 1306 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x6f, 0x1b, 0x45, - 0x14, 0xcf, 0xd6, 0x71, 0x63, 0x8f, 0x1b, 0xc7, 0x99, 0x56, 0x74, 0x95, 0x83, 0x6d, 0x8c, 0x84, - 0x2c, 0x08, 0xbb, 0x49, 0x14, 0x68, 0x40, 0x02, 0x11, 0xab, 0x15, 0x58, 0x4a, 0x43, 0x78, 0x89, - 0x2b, 0xf1, 0xe7, 0xc0, 0xda, 0x7e, 0xb1, 0x17, 0xdb, 0xbb, 0xcb, 0xce, 0xac, 0xab, 0xdc, 0x38, - 0x70, 0x45, 0xe2, 0xce, 0x87, 0xe0, 0x23, 0x54, 0xdc, 0x72, 0xec, 0xb1, 0x27, 0x8b, 0x98, 0x6f, - 0x91, 0x03, 0x42, 0x33, 0xfb, 0x67, 0xd6, 0x4e, 0x2d, 0x1c, 0x0e, 0xbd, 0xed, 0xbc, 0xf7, 0x7b, - 0xbf, 0xf7, 0xe6, 0xed, 0xfb, 0x33, 0xe4, 0xeb, 0xc1, 0x01, 0x33, 0x6c, 0xd7, 0x1c, 0x04, 0x6d, - 0xf4, 0x1d, 0xe4, 0xc8, 0xcc, 0x31, 0x3a, 0x5d, 0xd7, 0x37, 0x23, 0x85, 0xe5, 0xd9, 0x0c, 0xfd, - 0x31, 0xfa, 0xa6, 0x37, 0xe8, 0xc9, 0x93, 0x69, 0x05, 0x5d, 0x9b, 0x9b, 0xe3, 0x5d, 0x6b, 0xe8, - 0xf5, 0xad, 0x5d, 0xb3, 0x87, 0x0e, 0xfa, 0x16, 0xc7, 0xae, 0xe1, 0xf9, 0x2e, 0x77, 0x69, 0x3d, - 0xb4, 0x34, 0x12, 0x4b, 0xc3, 0x1b, 0xf4, 0xe4, 0xc9, 0x90, 0x96, 0x46, 0x6c, 0xb9, 0xf5, 0x41, - 0xcf, 0xe6, 0xfd, 0xa0, 0x6d, 0x74, 0xdc, 0x91, 0xd9, 0x73, 0x7b, 0xae, 0x29, 0x09, 0xda, 0xc1, - 0xb9, 0x3c, 0xc9, 0x83, 0xfc, 0x0a, 0x89, 0xb7, 0xb6, 0x55, 0x48, 0xa6, 0x15, 0xf0, 0x3e, 0x3a, - 0xdc, 0xee, 0x58, 0xdc, 0x76, 0x1d, 0x73, 0x7c, 0x23, 0x8c, 0xad, 0x7d, 0x85, 0x1e, 0x59, 0x9d, - 0xbe, 0xed, 0xa0, 0x7f, 0xa1, 0xee, 0x30, 0x42, 0x6e, 0xbd, 0xce, 0xca, 0x5c, 0x64, 0xe5, 0x07, - 0x0e, 0xb7, 0x47, 0x78, 0xc3, 0xe0, 0xa3, 0xff, 0x32, 0x60, 0x9d, 0x3e, 0x8e, 0xac, 0x79, 0xbb, - 0xda, 0x1f, 0xf7, 0x48, 0xf6, 0xc9, 0x18, 0x1d, 0x4e, 0x7f, 0x20, 0x39, 0x11, 0x4d, 0xd7, 0xe2, - 0x96, 0xae, 0x55, 0xb5, 0x7a, 0x61, 0x6f, 0xc7, 0x50, 0x29, 0x4c, 0x48, 0x55, 0x16, 0x05, 0xda, - 0x18, 0xef, 0x1a, 0x5f, 0xb5, 0x7f, 0xc4, 0x0e, 0x7f, 0x8a, 0xdc, 0x6a, 0xd0, 0xcb, 0x49, 0x65, - 0x65, 0x3a, 0xa9, 0x10, 0x25, 0x83, 0x84, 0x95, 0x6e, 0x93, 0xec, 0x10, 0xc7, 0x38, 0xd4, 0xef, - 0x54, 0xb5, 0x7a, 0xbe, 0xf1, 0x56, 0x04, 0xce, 0x1e, 0x09, 0xe1, 0x75, 0xfc, 0x01, 0x21, 0x88, - 0x7e, 0x47, 0xf2, 0x22, 0x70, 0xc6, 0xad, 0x91, 0xa7, 0x67, 0x64, 0x40, 0xef, 0x2d, 0x17, 0xd0, - 0x99, 0x3d, 0xc2, 0xc6, 0x66, 0xc4, 0x9e, 0x3f, 0x8b, 0x49, 0x40, 0xf1, 0xd1, 0x63, 0xb2, 0x26, - 0x8b, 0xa0, 0xf9, 0x58, 0x5f, 0x95, 0xc1, 0xec, 0x47, 0xf0, 0xb5, 0xc3, 0x50, 0x7c, 0x3d, 0xa9, - 0xbc, 0xbd, 0x28, 0xa5, 0xfc, 0xc2, 0x43, 0x66, 0xb4, 0x9a, 0x8f, 0x21, 0x26, 0x11, 0x57, 0x63, - 0xdc, 0xea, 0xa1, 0x9e, 0x9d, 0xbd, 0xda, 0xa9, 0x10, 0x5e, 0xc7, 0x1f, 0x10, 0x82, 0xe8, 0x1e, - 0x21, 0x3e, 0xfe, 0x14, 0x20, 0xe3, 0x2d, 0x68, 0xea, 0x77, 0xa5, 0x49, 0x92, 0x3a, 0x48, 0x34, - 0x90, 0x42, 0xd1, 0x2a, 0x59, 0x1d, 0xa3, 0xdf, 0xd6, 0xd7, 0x24, 0xfa, 0x5e, 0x84, 0x5e, 0x7d, - 0x86, 0x7e, 0x1b, 0xa4, 0x86, 0x7e, 0x49, 0x56, 0x03, 0x86, 0xbe, 0x9e, 0x93, 0xb9, 0x7a, 0x37, - 0x95, 0x2b, 0x63, 0xb6, 0x4c, 0x45, 0x8e, 0x5a, 0x0c, 0xfd, 0xa6, 0x73, 0xee, 0x2a, 0x26, 0x21, - 0x01, 0xc9, 0x40, 0xfb, 0xa4, 0x64, 0x8f, 0x3c, 0xf4, 0x99, 0xeb, 0x88, 0x52, 0x11, 0x1a, 0x3d, - 0x7f, 0x2b, 0xd6, 0x07, 0xd3, 0x49, 0xa5, 0xd4, 0x9c, 0xe3, 0x80, 0x1b, 0xac, 0xf4, 0x7d, 0x92, - 0x67, 0x6e, 0xe0, 0x77, 0xb0, 0x79, 0xc2, 0x74, 0x52, 0xcd, 0xd4, 0xf3, 0x8d, 0x75, 0xf1, 0xd3, - 0x4e, 0x63, 0x21, 0x28, 0x3d, 0x35, 0x49, 0x5e, 0x84, 0x77, 0xd8, 0x43, 0x87, 0xeb, 0x54, 0xe6, - 0x21, 0xf9, 0xcb, 0xad, 0x58, 0x01, 0x0a, 0x43, 0xcf, 0x49, 0xde, 0x95, 0x85, 0x08, 0x78, 0xae, - 0x17, 0xe4, 0x05, 0x3e, 0x36, 0x96, 0x1d, 0x0b, 0x51, 0x5d, 0x03, 0x9e, 0xa3, 0x8f, 0x4e, 0x07, - 0xc3, 0xc0, 0x12, 0x21, 0x28, 0x6a, 0xda, 0x27, 0x45, 0x1f, 0x99, 0xe7, 0x3a, 0x0c, 0x4f, 0xb9, - 0xc5, 0x03, 0xa6, 0xdf, 0x93, 0xce, 0xb6, 0x97, 0xab, 0xd7, 0xd0, 0xa6, 0x41, 0xa7, 0x93, 0x4a, - 0x11, 0x66, 0x78, 0x60, 0x8e, 0x97, 0x5a, 0x64, 0x3d, 0xaa, 0x89, 0x30, 0x10, 0x7d, 0x5d, 0x3a, - 0xaa, 0x2f, 0x74, 0x14, 0xb5, 0xbf, 0xd1, 0x72, 0x06, 0x8e, 0xfb, 0xdc, 0x69, 0x6c, 0x4e, 0x27, - 0x95, 0x75, 0x48, 0x53, 0xc0, 0x2c, 0x23, 0xed, 0xaa, 0xcb, 0x44, 0x3e, 0x8a, 0xb7, 0xf4, 0x31, - 0x73, 0x91, 0xc8, 0xc9, 0x1c, 0x27, 0xfd, 0x55, 0x23, 0x7a, 0xe4, 0x17, 0xb0, 0x83, 0xf6, 0x18, - 0xbb, 0x49, 0xa3, 0xea, 0x1b, 0xd2, 0xa1, 0xb9, 0x5c, 0xf6, 0x9e, 0xda, 0x1d, 0xdf, 0x95, 0x2d, - 0x5f, 0x8d, 0x8a, 0x41, 0x87, 0x05, 0xc4, 0xb0, 0xd0, 0x25, 0x75, 0x49, 0x51, 0xf6, 0xa6, 0x0a, - 0xa2, 0xf4, 0xff, 0x82, 0x88, 0x5b, 0xbf, 0x78, 0x3a, 0x43, 0x07, 0x73, 0xf4, 0xf4, 0x39, 0x29, - 0x58, 0x8e, 0xe3, 0x72, 0xd9, 0x3b, 0x4c, 0xdf, 0xac, 0x66, 0xea, 0x85, 0xbd, 0xcf, 0x97, 0xaf, - 0x4e, 0x39, 0xb4, 0x8d, 0x43, 0x45, 0xf1, 0xc4, 0xe1, 0xfe, 0x45, 0xe3, 0x7e, 0xe4, 0xbe, 0x90, - 0xd2, 0x40, 0xda, 0xd3, 0xd6, 0x67, 0xa4, 0x34, 0x6f, 0x45, 0x4b, 0x24, 0x33, 0xc0, 0x0b, 0x39, - 0xf6, 0xf3, 0x20, 0x3e, 0xe9, 0x03, 0x92, 0x1d, 0x5b, 0xc3, 0x00, 0xc3, 0x59, 0x0d, 0xe1, 0xe1, - 0x93, 0x3b, 0x07, 0x5a, 0xed, 0x85, 0x46, 0xf2, 0xd2, 0xf9, 0x91, 0xcd, 0x38, 0xfd, 0xfe, 0xc6, - 0xd6, 0x30, 0x96, 0xcb, 0x98, 0xb0, 0x96, 0x3b, 0xa3, 0x14, 0x45, 0x9c, 0x8b, 0x25, 0xa9, 0x8d, - 0x71, 0x46, 0xb2, 0x36, 0xc7, 0x11, 0xd3, 0xef, 0xc8, 0xf4, 0x98, 0xb7, 0x4c, 0x4f, 0x63, 0x3d, - 0x9e, 0xc3, 0x4d, 0xc1, 0x02, 0x21, 0x59, 0xed, 0x77, 0x8d, 0x14, 0xbf, 0xf0, 0xdd, 0xc0, 0x03, - 0x0c, 0x87, 0x0b, 0xa3, 0xef, 0x90, 0x6c, 0x4f, 0x48, 0xc2, 0x14, 0x28, 0xbb, 0x10, 0x16, 0xea, - 0xc4, 0xb0, 0xf2, 0x63, 0x0b, 0x19, 0x51, 0x34, 0xac, 0x12, 0x1a, 0x50, 0x7a, 0xfa, 0x48, 0x74, - 0x6a, 0x78, 0x38, 0xb6, 0x46, 0xc8, 0xf4, 0x8c, 0x34, 0x88, 0xfa, 0x2f, 0xa5, 0x80, 0x59, 0x5c, - 0xed, 0x97, 0x0c, 0xd9, 0x98, 0x1b, 0x3d, 0x74, 0x9b, 0xe4, 0x62, 0x50, 0x14, 0x61, 0x92, 0xb5, - 0x98, 0x0b, 0x12, 0x84, 0x98, 0x93, 0x8e, 0xa0, 0xf2, 0xac, 0x4e, 0xf4, 0xff, 0xd4, 0x9c, 0x3c, - 0x8e, 0x15, 0xa0, 0x30, 0x62, 0xb7, 0x88, 0x83, 0xdc, 0xb2, 0xa9, 0xdd, 0x22, 0xb0, 0x20, 0x35, - 0xb4, 0x41, 0x32, 0x81, 0xdd, 0x8d, 0x76, 0xe5, 0x4e, 0x04, 0xc8, 0xb4, 0x96, 0xdd, 0x93, 0xc2, - 0x58, 0x6c, 0x3d, 0xcb, 0xb3, 0x9f, 0xa1, 0xcf, 0x6c, 0xd7, 0x89, 0x16, 0x65, 0xb2, 0xf5, 0x0e, - 0x4f, 0x9a, 0x91, 0x06, 0x52, 0x28, 0x7a, 0x48, 0x36, 0xe2, 0x6b, 0xc5, 0x86, 0xe1, 0xba, 0x7c, - 0x18, 0x19, 0x6e, 0xc0, 0xac, 0x1a, 0xe6, 0xf1, 0xf4, 0x43, 0x52, 0x60, 0x41, 0x3b, 0x49, 0x5f, - 0xb8, 0x3f, 0x93, 0x36, 0x39, 0x55, 0x2a, 0x48, 0xe3, 0x6a, 0xff, 0x68, 0xe4, 0xee, 0x89, 0x3b, - 0xb4, 0x3b, 0x17, 0x6f, 0xe0, 0x65, 0xf4, 0x0d, 0xc9, 0xfa, 0xc1, 0x10, 0xe3, 0x3a, 0xdf, 0x5f, - 0xbe, 0xce, 0xc3, 0x10, 0x21, 0x18, 0xa2, 0x2a, 0x5a, 0x71, 0x62, 0x10, 0x32, 0xd2, 0x47, 0x84, - 0xb8, 0x23, 0x9b, 0xcb, 0x69, 0x14, 0x17, 0xe1, 0x43, 0x19, 0x48, 0x22, 0x55, 0xef, 0x93, 0x14, - 0xb4, 0xf6, 0xa7, 0x46, 0x48, 0xc8, 0xfe, 0x06, 0x1a, 0xbd, 0x35, 0xdb, 0xe8, 0x3b, 0xb7, 0x4d, - 0xc0, 0x82, 0x4e, 0x7f, 0x91, 0x89, 0xef, 0x20, 0x72, 0xa2, 0x1e, 0xa0, 0xda, 0x32, 0x0f, 0xd0, - 0x0a, 0xc9, 0x8a, 0xa7, 0x44, 0xdc, 0xea, 0x79, 0x81, 0x14, 0xcf, 0x0c, 0x06, 0xa1, 0x9c, 0x1a, - 0x84, 0x88, 0x0f, 0x39, 0x23, 0xe2, 0xd4, 0x16, 0x45, 0x6a, 0x5b, 0x89, 0x14, 0x52, 0x08, 0x41, - 0x28, 0x1e, 0x6a, 0x4c, 0x5f, 0x55, 0x84, 0xe2, 0xfd, 0xc6, 0x20, 0x94, 0x53, 0x3b, 0x3d, 0x60, - 0xb2, 0x32, 0x13, 0x07, 0xcb, 0x67, 0x62, 0x76, 0xa4, 0xa9, 0x96, 0x7f, 0xed, 0x78, 0x32, 0x08, - 0x49, 0xfa, 0x9f, 0xe9, 0x77, 0x55, 0xec, 0xc9, 0x80, 0x60, 0x90, 0x42, 0xd0, 0x4f, 0xc9, 0x86, - 0xe3, 0x3a, 0x31, 0x55, 0x0b, 0x8e, 0x98, 0xbe, 0x26, 0x8d, 0xee, 0x8b, 0x26, 0x3c, 0x9e, 0x55, - 0xc1, 0x3c, 0x76, 0xae, 0x0a, 0x73, 0x4b, 0x57, 0x61, 0xc3, 0xb8, 0xbc, 0x2a, 0xaf, 0xbc, 0xbc, - 0x2a, 0xaf, 0xbc, 0xba, 0x2a, 0xaf, 0xfc, 0x3c, 0x2d, 0x6b, 0x97, 0xd3, 0xb2, 0xf6, 0x72, 0x5a, - 0xd6, 0x5e, 0x4d, 0xcb, 0xda, 0x5f, 0xd3, 0xb2, 0xf6, 0xdb, 0xdf, 0xe5, 0x95, 0x6f, 0x73, 0x71, - 0x12, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x19, 0xf8, 0xf6, 0xd0, 0x49, 0x0e, 0x00, 0x00, + 0x14, 0xcf, 0xc6, 0x71, 0xe3, 0x9d, 0x34, 0x4e, 0x32, 0x2d, 0x74, 0xc9, 0xc1, 0x0e, 0x41, 0x42, + 0x11, 0x84, 0xdd, 0xb6, 0x2a, 0xb4, 0x20, 0x81, 0x88, 0x69, 0x29, 0x96, 0xda, 0xb4, 0x4c, 0xea, + 0x4a, 0xfc, 0x39, 0x30, 0xb6, 0x5f, 0xec, 0xc5, 0xf6, 0xec, 0xb2, 0x33, 0xeb, 0x2a, 0x37, 0x0e, + 0xbd, 0x22, 0x71, 0xe7, 0x43, 0xf0, 0x11, 0x10, 0x27, 0x7a, 0xec, 0xb1, 0x27, 0x8b, 0x9a, 0x6f, + 0xd1, 0x13, 0x9a, 0xd9, 0xd9, 0x9d, 0xb5, 0x13, 0x8b, 0x0d, 0x87, 0xde, 0x66, 0xde, 0xfb, 0xbd, + 0xdf, 0x7b, 0xf3, 0xe6, 0xcd, 0x7b, 0x83, 0xbe, 0x1e, 0xdc, 0xe2, 0xae, 0x1f, 0x78, 0x83, 0xb8, + 0x0d, 0x11, 0x03, 0x01, 0xdc, 0x1b, 0x03, 0xeb, 0x06, 0x91, 0xa7, 0x15, 0x34, 0xf4, 0x39, 0x44, + 0x63, 0x88, 0xbc, 0x70, 0xd0, 0x53, 0x3b, 0x8f, 0xc6, 0x5d, 0x5f, 0x78, 0xe3, 0x6b, 0x74, 0x18, + 0xf6, 0xe9, 0x35, 0xaf, 0x07, 0x0c, 0x22, 0x2a, 0xa0, 0xeb, 0x86, 0x51, 0x20, 0x02, 0xbc, 0x97, + 0x58, 0xba, 0x99, 0xa5, 0x1b, 0x0e, 0x7a, 0x6a, 0xe7, 0x2a, 0x4b, 0x37, 0xb5, 0xdc, 0xfe, 0xa0, + 0xe7, 0x8b, 0x7e, 0xdc, 0x76, 0x3b, 0xc1, 0xc8, 0xeb, 0x05, 0xbd, 0xc0, 0x53, 0x04, 0xed, 0xf8, + 0x58, 0xed, 0xd4, 0x46, 0xad, 0x12, 0xe2, 0xed, 0x7d, 0x13, 0x92, 0x47, 0x63, 0xd1, 0x07, 0x26, + 0xfc, 0x0e, 0x15, 0x7e, 0xc0, 0xbc, 0xf1, 0xa9, 0x30, 0xb6, 0x6f, 0x18, 0xf4, 0x88, 0x76, 0xfa, + 0x3e, 0x83, 0xe8, 0xc4, 0x9c, 0x61, 0x04, 0x82, 0x9e, 0x65, 0xe5, 0x2d, 0xb2, 0x8a, 0x62, 0x26, + 0xfc, 0x11, 0x9c, 0x32, 0xf8, 0xe8, 0xbf, 0x0c, 0x78, 0xa7, 0x0f, 0x23, 0x3a, 0x6f, 0xb7, 0xfb, + 0xfb, 0x45, 0x54, 0xbe, 0x33, 0x06, 0x26, 0xf0, 0x0f, 0xa8, 0x22, 0xa3, 0xe9, 0x52, 0x41, 0x1d, + 0x6b, 0xc7, 0xda, 0x5b, 0xbb, 0x7e, 0xd5, 0x35, 0x29, 0xcc, 0x48, 0x4d, 0x16, 0x25, 0xda, 0x1d, + 0x5f, 0x73, 0x1f, 0xb4, 0x7f, 0x84, 0x8e, 0xb8, 0x0f, 0x82, 0x36, 0xf0, 0xb3, 0x49, 0x7d, 0x69, + 0x3a, 0xa9, 0x23, 0x23, 0x23, 0x19, 0x2b, 0xde, 0x47, 0xe5, 0x21, 0x8c, 0x61, 0xe8, 0x2c, 0xef, + 0x58, 0x7b, 0x76, 0xe3, 0x4d, 0x0d, 0x2e, 0xdf, 0x93, 0xc2, 0x57, 0xe9, 0x82, 0x24, 0x20, 0xfc, + 0x1d, 0xb2, 0x65, 0xe0, 0x5c, 0xd0, 0x51, 0xe8, 0x94, 0x54, 0x40, 0xef, 0x15, 0x0b, 0xe8, 0x91, + 0x3f, 0x82, 0xc6, 0x96, 0x66, 0xb7, 0x1f, 0xa5, 0x24, 0xc4, 0xf0, 0xe1, 0x43, 0xb4, 0xaa, 0x8a, + 0xa0, 0x79, 0xdb, 0x59, 0x51, 0xc1, 0xdc, 0xd0, 0xf0, 0xd5, 0x83, 0x44, 0xfc, 0x6a, 0x52, 0x7f, + 0x7b, 0x51, 0x4a, 0xc5, 0x49, 0x08, 0xdc, 0x6d, 0x35, 0x6f, 0x93, 0x94, 0x44, 0x1e, 0x8d, 0x0b, + 0xda, 0x03, 0xa7, 0x3c, 0x7b, 0xb4, 0x23, 0x29, 0x7c, 0x95, 0x2e, 0x48, 0x02, 0xc2, 0xd7, 0x11, + 0x8a, 0xe0, 0xa7, 0x18, 0xb8, 0x68, 0x91, 0xa6, 0x73, 0x41, 0x99, 0x64, 0xa9, 0x23, 0x99, 0x86, + 0xe4, 0x50, 0x78, 0x07, 0xad, 0x8c, 0x21, 0x6a, 0x3b, 0xab, 0x0a, 0x7d, 0x51, 0xa3, 0x57, 0x1e, + 0x43, 0xd4, 0x26, 0x4a, 0x83, 0xbf, 0x42, 0x2b, 0x31, 0x87, 0xc8, 0xa9, 0xa8, 0x5c, 0xbd, 0x9b, + 0xcb, 0x95, 0x3b, 0x5b, 0xa6, 0x32, 0x47, 0x2d, 0x0e, 0x51, 0x93, 0x1d, 0x07, 0x86, 0x49, 0x4a, + 0x88, 0x62, 0xc0, 0x7d, 0xb4, 0xe9, 0x8f, 0x42, 0x88, 0x78, 0xc0, 0x64, 0xa9, 0x48, 0x8d, 0x63, + 0x9f, 0x8b, 0xf5, 0xf2, 0x74, 0x52, 0xdf, 0x6c, 0xce, 0x71, 0x90, 0x53, 0xac, 0xf8, 0x7d, 0x64, + 0xf3, 0x20, 0x8e, 0x3a, 0xd0, 0x7c, 0xc8, 0x1d, 0xb4, 0x53, 0xda, 0xb3, 0x1b, 0xeb, 0xf2, 0xd2, + 0x8e, 0x52, 0x21, 0x31, 0x7a, 0xec, 0x21, 0x5b, 0x86, 0x77, 0xd0, 0x03, 0x26, 0x1c, 0xac, 0xf2, + 0x90, 0xdd, 0x72, 0x2b, 0x55, 0x10, 0x83, 0xc1, 0xc7, 0xc8, 0x0e, 0x54, 0x21, 0x12, 0x38, 0x76, + 0xd6, 0xd4, 0x01, 0x3e, 0x76, 0x8b, 0xb6, 0x05, 0x5d, 0xd7, 0x04, 0x8e, 0x21, 0x02, 0xd6, 0x81, + 0x24, 0xb0, 0x4c, 0x48, 0x0c, 0x35, 0xee, 0xa3, 0x6a, 0x04, 0x3c, 0x0c, 0x18, 0x87, 0x23, 0x41, + 0x45, 0xcc, 0x9d, 0x8b, 0xca, 0xd9, 0x7e, 0xb1, 0x7a, 0x4d, 0x6c, 0x1a, 0x78, 0x3a, 0xa9, 0x57, + 0xc9, 0x0c, 0x0f, 0x99, 0xe3, 0xc5, 0x14, 0xad, 0xeb, 0x9a, 0x48, 0x02, 0x71, 0xd6, 0x95, 0xa3, + 0xbd, 0x85, 0x8e, 0xf4, 0xf3, 0x77, 0x5b, 0x6c, 0xc0, 0x82, 0x27, 0xac, 0xb1, 0x35, 0x9d, 0xd4, + 0xd7, 0x49, 0x9e, 0x82, 0xcc, 0x32, 0xe2, 0xae, 0x39, 0x8c, 0xf6, 0x51, 0x3d, 0xa7, 0x8f, 0x99, + 0x83, 0x68, 0x27, 0x73, 0x9c, 0xf8, 0x17, 0x0b, 0x39, 0xda, 0x2f, 0x81, 0x0e, 0xf8, 0x63, 0xe8, + 0x66, 0x0f, 0xd5, 0xd9, 0x50, 0x0e, 0xbd, 0x62, 0xd9, 0xbb, 0xef, 0x77, 0xa2, 0x40, 0x3d, 0xf9, + 0x1d, 0x5d, 0x0c, 0x0e, 0x59, 0x40, 0x4c, 0x16, 0xba, 0xc4, 0x01, 0xaa, 0xaa, 0xb7, 0x69, 0x82, + 0xd8, 0xfc, 0x7f, 0x41, 0xa4, 0x4f, 0xbf, 0x7a, 0x34, 0x43, 0x47, 0xe6, 0xe8, 0xf1, 0x13, 0xb4, + 0x46, 0x19, 0x0b, 0x84, 0x7a, 0x3b, 0xdc, 0xd9, 0xda, 0x29, 0xed, 0xad, 0x5d, 0xff, 0xbc, 0x78, + 0x75, 0xaa, 0xa6, 0xed, 0x1e, 0x18, 0x8a, 0x3b, 0x4c, 0x44, 0x27, 0x8d, 0x4b, 0xda, 0xfd, 0x5a, + 0x4e, 0x43, 0xf2, 0x9e, 0xb6, 0x3f, 0x43, 0x9b, 0xf3, 0x56, 0x78, 0x13, 0x95, 0x06, 0x70, 0xa2, + 0xda, 0xbe, 0x4d, 0xe4, 0x12, 0x5f, 0x46, 0xe5, 0x31, 0x1d, 0xc6, 0x90, 0xf4, 0x6a, 0x92, 0x6c, + 0x3e, 0x59, 0xbe, 0x65, 0xed, 0xfe, 0x61, 0x21, 0x5b, 0x39, 0xbf, 0xe7, 0x73, 0x81, 0xbf, 0x3f, + 0x35, 0x35, 0xdc, 0x62, 0x19, 0x93, 0xd6, 0x6a, 0x66, 0x6c, 0xea, 0x88, 0x2b, 0xa9, 0x24, 0x37, + 0x31, 0x1e, 0xa1, 0xb2, 0x2f, 0x60, 0xc4, 0x9d, 0x65, 0x95, 0x1e, 0xef, 0x9c, 0xe9, 0x69, 0xac, + 0xa7, 0x7d, 0xb8, 0x29, 0x59, 0x48, 0x42, 0xb6, 0xfb, 0x9b, 0x85, 0xaa, 0x77, 0xa3, 0x20, 0x0e, + 0x09, 0x24, 0xcd, 0x85, 0xe3, 0x77, 0x50, 0xb9, 0x27, 0x25, 0x49, 0x0a, 0x8c, 0x5d, 0x02, 0x4b, + 0x74, 0xb2, 0x59, 0x45, 0xa9, 0x85, 0x8a, 0x48, 0x37, 0xab, 0x8c, 0x86, 0x18, 0x3d, 0xbe, 0x29, + 0x5f, 0x6a, 0xb2, 0x39, 0xa4, 0x23, 0xe0, 0x4e, 0x49, 0x19, 0xe8, 0xf7, 0x97, 0x53, 0x90, 0x59, + 0xdc, 0xee, 0xd3, 0x12, 0xda, 0x98, 0x6b, 0x3d, 0x78, 0x1f, 0x55, 0x52, 0x90, 0x8e, 0x30, 0xcb, + 0x5a, 0xca, 0x45, 0x32, 0x84, 0xec, 0x93, 0x4c, 0x52, 0x85, 0xb4, 0xa3, 0xef, 0xcf, 0xf4, 0xc9, + 0xc3, 0x54, 0x41, 0x0c, 0x46, 0xce, 0x16, 0xb9, 0x51, 0x53, 0x36, 0x37, 0x5b, 0x24, 0x96, 0x28, + 0x0d, 0x6e, 0xa0, 0x52, 0xec, 0x77, 0xf5, 0xac, 0xbc, 0xaa, 0x01, 0xa5, 0x56, 0xd1, 0x39, 0x29, + 0x8d, 0xe5, 0xd4, 0xa3, 0xa1, 0xff, 0x18, 0x22, 0xee, 0x07, 0x4c, 0x0f, 0xca, 0x6c, 0xea, 0x1d, + 0x3c, 0x6c, 0x6a, 0x0d, 0xc9, 0xa1, 0xf0, 0x01, 0xda, 0x48, 0x8f, 0x95, 0x1a, 0x26, 0xe3, 0xf2, + 0x8a, 0x36, 0xdc, 0x20, 0xb3, 0x6a, 0x32, 0x8f, 0xc7, 0x1f, 0xa2, 0x35, 0x1e, 0xb7, 0xb3, 0xf4, + 0x25, 0xf3, 0x33, 0x7b, 0x26, 0x47, 0x46, 0x45, 0xf2, 0xb8, 0xdd, 0xbf, 0x96, 0xd1, 0x85, 0x87, + 0xc1, 0xd0, 0xef, 0x9c, 0xbc, 0x86, 0x9f, 0xd1, 0x37, 0xa8, 0x1c, 0xc5, 0x43, 0x48, 0xeb, 0xfc, + 0x46, 0xf1, 0x3a, 0x4f, 0x42, 0x24, 0xf1, 0x10, 0x4c, 0xd1, 0xca, 0x1d, 0x27, 0x09, 0x23, 0xbe, + 0x89, 0x50, 0x30, 0xf2, 0x85, 0xea, 0x46, 0x69, 0x11, 0x5e, 0x51, 0x81, 0x64, 0x52, 0xf3, 0x3f, + 0xc9, 0x41, 0xf1, 0x5d, 0xb4, 0x25, 0x77, 0xf7, 0x29, 0xa3, 0x3d, 0xe8, 0x7e, 0xe9, 0xc3, 0xb0, + 0xcb, 0x55, 0x01, 0x54, 0x1a, 0x6f, 0x69, 0x4f, 0x5b, 0x0f, 0xe6, 0x01, 0xe4, 0xb4, 0xcd, 0xee, + 0x9f, 0x16, 0x42, 0x49, 0x98, 0xaf, 0xa1, 0x63, 0xb4, 0x66, 0x3b, 0xc6, 0xd5, 0xf3, 0x66, 0x72, + 0x41, 0xcb, 0x78, 0xba, 0x92, 0x9e, 0x41, 0x26, 0xd7, 0xfc, 0x64, 0xad, 0x22, 0x3f, 0xd9, 0x3a, + 0x2a, 0xcb, 0x3f, 0x49, 0xda, 0x33, 0x6c, 0x89, 0x94, 0xff, 0x15, 0x4e, 0x12, 0x39, 0x76, 0x11, + 0x92, 0x0b, 0xd5, 0x6c, 0xd2, 0x3b, 0xaa, 0xca, 0x3b, 0x6a, 0x65, 0x52, 0x92, 0x43, 0x48, 0x42, + 0xf9, 0xe3, 0x93, 0xd7, 0x91, 0x11, 0xca, 0x8f, 0x20, 0x27, 0x89, 0x1c, 0xfb, 0xf9, 0x4e, 0x55, + 0x56, 0x99, 0xb8, 0x55, 0x3c, 0x13, 0xb3, 0xbd, 0xd1, 0xf4, 0x8e, 0x33, 0xfb, 0x9c, 0x8b, 0x50, + 0xd6, 0x48, 0xb8, 0x73, 0xc1, 0xc4, 0x9e, 0x75, 0x1a, 0x4e, 0x72, 0x08, 0xfc, 0x29, 0xda, 0x60, + 0x01, 0x4b, 0xa9, 0x5a, 0xe4, 0x1e, 0x77, 0x56, 0x95, 0xd1, 0x25, 0xf9, 0x9a, 0x0f, 0x67, 0x55, + 0x64, 0x1e, 0x3b, 0x57, 0xce, 0x95, 0xe2, 0xe5, 0xfc, 0xc5, 0x59, 0xe5, 0x6c, 0xab, 0x72, 0x7e, + 0xa3, 0x68, 0x29, 0x37, 0xdc, 0x67, 0x2f, 0x6b, 0x4b, 0xcf, 0x5f, 0xd6, 0x96, 0x5e, 0xbc, 0xac, + 0x2d, 0xfd, 0x3c, 0xad, 0x59, 0xcf, 0xa6, 0x35, 0xeb, 0xf9, 0xb4, 0x66, 0xbd, 0x98, 0xd6, 0xac, + 0xbf, 0xa7, 0x35, 0xeb, 0xd7, 0x7f, 0x6a, 0x4b, 0xdf, 0x56, 0xd2, 0x4c, 0xfe, 0x1b, 0x00, 0x00, + 0xff, 0xff, 0x3a, 0xc5, 0x5b, 0x91, 0xd7, 0x0e, 0x00, 0x00, } func (m *Event) Marshal() (dAtA []byte, err error) { @@ -716,6 +719,14 @@ func (m *Policy) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + i-- + if m.OmitManagedFields { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 if len(m.OmitStages) > 0 { for iNdEx := len(m.OmitStages) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.OmitStages[iNdEx]) @@ -819,6 +830,16 @@ func (m *PolicyRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.OmitManagedFields != nil { + i-- + if *m.OmitManagedFields { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } if len(m.OmitStages) > 0 { for iNdEx := len(m.OmitStages) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.OmitStages[iNdEx]) @@ -1054,6 +1075,7 @@ func (m *Policy) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + n += 2 return n } @@ -1124,6 +1146,9 @@ func (m *PolicyRule) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + if m.OmitManagedFields != nil { + n += 2 + } return n } @@ -1227,6 +1252,7 @@ func (this *Policy) String() string { `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, `Rules:` + repeatedStringForRules + `,`, `OmitStages:` + fmt.Sprintf("%v", this.OmitStages) + `,`, + `OmitManagedFields:` + fmt.Sprintf("%v", this.OmitManagedFields) + `,`, `}`, }, "") return s @@ -1265,6 +1291,7 @@ func (this *PolicyRule) String() string { `Namespaces:` + fmt.Sprintf("%v", this.Namespaces) + `,`, `NonResourceURLs:` + fmt.Sprintf("%v", this.NonResourceURLs) + `,`, `OmitStages:` + fmt.Sprintf("%v", this.OmitStages) + `,`, + `OmitManagedFields:` + valueToStringGenerated(this.OmitManagedFields) + `,`, `}`, }, "") return s @@ -2688,6 +2715,26 @@ func (m *Policy) Unmarshal(dAtA []byte) error { } m.OmitStages = append(m.OmitStages, Stage(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OmitManagedFields", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.OmitManagedFields = bool(v != 0) default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -3113,6 +3160,27 @@ func (m *PolicyRule) Unmarshal(dAtA []byte) error { } m.OmitStages = append(m.OmitStages, Stage(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OmitManagedFields", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.OmitManagedFields = &b default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.proto b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.proto index 9b5138ea54..5c457e381d 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.proto +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/generated.proto @@ -195,6 +195,15 @@ message Policy { // be specified per rule in which case the union of both are omitted. // +optional repeated string omitStages = 3; + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // This is used as a global default - a value of 'true' will omit the managed fileds, + // otherwise the managed fields will be included in the API audit log. + // Note that this can also be specified per rule in which case the value specified + // in a rule will override the global default. + // +optional + optional bool omitManagedFields = 4; } // PolicyList is a list of audit Policies. @@ -250,5 +259,16 @@ message PolicyRule { // An empty list means no restrictions will apply. // +optional repeated string omitStages = 8; + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // - a value of 'true' will drop the managed fields from the API audit log + // - a value of 'false' indicates that the managed fileds should be included + // in the API audit log + // Note that the value, if specified, in this rule will override the global default + // If a value is not specified then the global default specified in + // Policy.OmitManagedFields will stand. + // +optional + optional bool omitManagedFields = 9; } diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/types.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/types.go index 2616f5fe70..f108b9bc58 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/types.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/types.go @@ -191,6 +191,15 @@ type Policy struct { // be specified per rule in which case the union of both are omitted. // +optional OmitStages []Stage `json:"omitStages,omitempty" protobuf:"bytes,3,rep,name=omitStages"` + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // This is used as a global default - a value of 'true' will omit the managed fileds, + // otherwise the managed fields will be included in the API audit log. + // Note that this can also be specified per rule in which case the value specified + // in a rule will override the global default. + // +optional + OmitManagedFields bool `json:"omitManagedFields,omitempty" protobuf:"varint,4,opt,name=omitManagedFields"` } // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object @@ -254,6 +263,17 @@ type PolicyRule struct { // An empty list means no restrictions will apply. // +optional OmitStages []Stage `json:"omitStages,omitempty" protobuf:"bytes,8,rep,name=omitStages"` + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // - a value of 'true' will drop the managed fields from the API audit log + // - a value of 'false' indicates that the managed fileds should be included + // in the API audit log + // Note that the value, if specified, in this rule will override the global default + // If a value is not specified then the global default specified in + // Policy.OmitManagedFields will stand. + // +optional + OmitManagedFields *bool `json:"omitManagedFields,omitempty" protobuf:"varint,9,opt,name=omitManagedFields"` } // GroupResources represents resource kinds in an API group. diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.conversion.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.conversion.go index 74a1842053..de9e938d47 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -262,6 +263,7 @@ func autoConvert_v1alpha1_Policy_To_audit_Policy(in *Policy, out *audit.Policy, out.ObjectMeta = in.ObjectMeta out.Rules = *(*[]audit.PolicyRule)(unsafe.Pointer(&in.Rules)) out.OmitStages = *(*[]audit.Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = in.OmitManagedFields return nil } @@ -274,6 +276,7 @@ func autoConvert_audit_Policy_To_v1alpha1_Policy(in *audit.Policy, out *Policy, out.ObjectMeta = in.ObjectMeta out.Rules = *(*[]PolicyRule)(unsafe.Pointer(&in.Rules)) out.OmitStages = *(*[]Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = in.OmitManagedFields return nil } @@ -313,6 +316,7 @@ func autoConvert_v1alpha1_PolicyRule_To_audit_PolicyRule(in *PolicyRule, out *au out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces)) out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs)) out.OmitStages = *(*[]audit.Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = (*bool)(unsafe.Pointer(in.OmitManagedFields)) return nil } @@ -330,6 +334,7 @@ func autoConvert_audit_PolicyRule_To_v1alpha1_PolicyRule(in *audit.PolicyRule, o out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces)) out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs)) out.OmitStages = *(*[]Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = (*bool)(unsafe.Pointer(in.OmitManagedFields)) return nil } diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.deepcopy.go index efb6cd87de..5f99185eeb 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -279,6 +280,11 @@ func (in *PolicyRule) DeepCopyInto(out *PolicyRule) { *out = make([]Stage, len(*in)) copy(*out, *in) } + if in.OmitManagedFields != nil { + in, out := &in.OmitManagedFields, &out.OmitManagedFields + *out = new(bool) + **out = **in + } return } diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.defaults.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.defaults.go index dd621a3acd..5070cb91b9 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.prerelease-lifecycle.go index 1fb3352112..d1a38ca83b 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1alpha1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.pb.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.pb.go index 0437d71cf5..ef04b4463e 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.pb.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.pb.go @@ -261,87 +261,90 @@ func init() { } var fileDescriptor_c7e4d52063960930 = []byte{ - // 1279 bytes of a gzipped FileDescriptorProto + // 1320 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x6f, 0x1b, 0x45, - 0x14, 0xcf, 0xd6, 0x71, 0x63, 0x8f, 0x1b, 0xc7, 0x9d, 0x56, 0x74, 0x95, 0x83, 0x6d, 0x8c, 0x04, - 0x11, 0xa4, 0xbb, 0x4d, 0x28, 0x24, 0x42, 0x02, 0x64, 0xab, 0x15, 0x58, 0x4a, 0x43, 0x34, 0x8e, - 0x2b, 0x04, 0x1c, 0x58, 0xdb, 0x2f, 0xf6, 0x62, 0x7b, 0x77, 0xd9, 0x99, 0x35, 0xca, 0x8d, 0x2f, - 0x80, 0xc4, 0x9d, 0xcf, 0xc0, 0x85, 0x0f, 0x50, 0x71, 0xcc, 0xb1, 0xc7, 0x9e, 0x2c, 0x62, 0xbe, - 0x45, 0x24, 0x24, 0x34, 0x7f, 0x76, 0x67, 0xed, 0xd4, 0xc2, 0xe1, 0xd0, 0xdb, 0xce, 0x7b, 0xbf, - 0xf7, 0x9b, 0x37, 0xbf, 0x7d, 0xf3, 0xde, 0xa0, 0x93, 0xe1, 0x21, 0xb5, 0x5c, 0xdf, 0x1e, 0x46, - 0x1d, 0x08, 0x3d, 0x60, 0x40, 0xed, 0x09, 0x78, 0x3d, 0x3f, 0xb4, 0x95, 0xc3, 0x09, 0x5c, 0x0a, - 0xe1, 0x04, 0x42, 0x3b, 0x18, 0xf6, 0xc5, 0xca, 0x76, 0xa2, 0x9e, 0xcb, 0xec, 0xc9, 0x5e, 0x07, - 0x98, 0xb3, 0x67, 0xf7, 0xc1, 0x83, 0xd0, 0x61, 0xd0, 0xb3, 0x82, 0xd0, 0x67, 0x3e, 0x7e, 0x4f, - 0x06, 0x5a, 0x49, 0xa0, 0x15, 0x0c, 0xfb, 0x62, 0x65, 0x89, 0x40, 0x4b, 0x05, 0x6e, 0x3f, 0xec, - 0xbb, 0x6c, 0x10, 0x75, 0xac, 0xae, 0x3f, 0xb6, 0xfb, 0x7e, 0xdf, 0xb7, 0x45, 0x7c, 0x27, 0x3a, - 0x13, 0x2b, 0xb1, 0x10, 0x5f, 0x92, 0x77, 0x7b, 0x57, 0x27, 0x64, 0x3b, 0x11, 0x1b, 0x80, 0xc7, - 0xdc, 0xae, 0xc3, 0x5c, 0xdf, 0xb3, 0x27, 0xd7, 0xb2, 0xd8, 0x7e, 0xac, 0xd1, 0x63, 0xa7, 0x3b, - 0x70, 0x3d, 0x08, 0xcf, 0xf5, 0x09, 0xc6, 0xc0, 0x9c, 0xd7, 0x45, 0xd9, 0xcb, 0xa2, 0xc2, 0xc8, - 0x63, 0xee, 0x18, 0xae, 0x05, 0x7c, 0xfc, 0x5f, 0x01, 0xb4, 0x3b, 0x80, 0xb1, 0xb3, 0x18, 0x57, - 0xfb, 0xfd, 0x0e, 0xca, 0x3e, 0x9d, 0x80, 0xc7, 0xf0, 0xf7, 0x28, 0xc7, 0xb3, 0xe9, 0x39, 0xcc, - 0x31, 0x8d, 0xaa, 0xb1, 0x53, 0xd8, 0x7f, 0x64, 0x69, 0x05, 0x13, 0x52, 0x2d, 0x22, 0x47, 0x5b, - 0x93, 0x3d, 0xeb, 0xab, 0xce, 0x0f, 0xd0, 0x65, 0xcf, 0x80, 0x39, 0x0d, 0x7c, 0x31, 0xad, 0xac, - 0xcd, 0xa6, 0x15, 0xa4, 0x6d, 0x24, 0x61, 0xc5, 0xbb, 0x28, 0x3b, 0x82, 0x09, 0x8c, 0xcc, 0x5b, - 0x55, 0x63, 0x27, 0xdf, 0x78, 0x4b, 0x81, 0xb3, 0x47, 0xdc, 0x78, 0x15, 0x7f, 0x10, 0x09, 0xc2, - 0xdf, 0xa2, 0x3c, 0x4f, 0x9c, 0x32, 0x67, 0x1c, 0x98, 0x19, 0x91, 0xd0, 0xfb, 0xab, 0x25, 0x74, - 0xea, 0x8e, 0xa1, 0x71, 0x57, 0xb1, 0xe7, 0x4f, 0x63, 0x12, 0xa2, 0xf9, 0xf0, 0x31, 0xda, 0x10, - 0x35, 0xd0, 0x7c, 0x62, 0xae, 0x8b, 0x64, 0x1e, 0x2b, 0xf8, 0x46, 0x5d, 0x9a, 0xaf, 0xa6, 0x95, - 0xb7, 0x97, 0x49, 0xca, 0xce, 0x03, 0xa0, 0x56, 0xbb, 0xf9, 0x84, 0xc4, 0x24, 0xfc, 0x68, 0x94, - 0x39, 0x7d, 0x30, 0xb3, 0xf3, 0x47, 0x6b, 0x71, 0xe3, 0x55, 0xfc, 0x41, 0x24, 0x08, 0xef, 0x23, - 0x14, 0xc2, 0x8f, 0x11, 0x50, 0xd6, 0x26, 0x4d, 0xf3, 0xb6, 0x08, 0x49, 0xa4, 0x23, 0x89, 0x87, - 0xa4, 0x50, 0xb8, 0x8a, 0xd6, 0x27, 0x10, 0x76, 0xcc, 0x0d, 0x81, 0xbe, 0xa3, 0xd0, 0xeb, 0xcf, - 0x21, 0xec, 0x10, 0xe1, 0xc1, 0x5f, 0xa2, 0xf5, 0x88, 0x42, 0x68, 0xe6, 0x84, 0x56, 0xef, 0xa6, - 0xb4, 0xb2, 0xe6, 0xcb, 0x94, 0x6b, 0xd4, 0xa6, 0x10, 0x36, 0xbd, 0x33, 0x5f, 0x33, 0x71, 0x0b, - 0x11, 0x0c, 0x78, 0x80, 0x4a, 0xee, 0x38, 0x80, 0x90, 0xfa, 0x1e, 0x2f, 0x15, 0xee, 0x31, 0xf3, - 0x37, 0x62, 0xbd, 0x3f, 0x9b, 0x56, 0x4a, 0xcd, 0x05, 0x0e, 0x72, 0x8d, 0x15, 0x7f, 0x80, 0xf2, - 0xd4, 0x8f, 0xc2, 0x2e, 0x34, 0x4f, 0xa8, 0x89, 0xaa, 0x99, 0x9d, 0x7c, 0x63, 0x93, 0xff, 0xb4, - 0x56, 0x6c, 0x24, 0xda, 0x8f, 0x6d, 0x94, 0xe7, 0xe9, 0xd5, 0xfb, 0xe0, 0x31, 0x13, 0x0b, 0x1d, - 0x92, 0xbf, 0xdc, 0x8e, 0x1d, 0x44, 0x63, 0x30, 0xa0, 0xbc, 0x2f, 0x0a, 0x91, 0xc0, 0x99, 0x59, - 0x10, 0x07, 0x38, 0xb4, 0x56, 0xec, 0x0a, 0xaa, 0xac, 0x09, 0x9c, 0x41, 0x08, 0x5e, 0x17, 0x64, - 0x5e, 0x89, 0x91, 0x68, 0x66, 0x3c, 0x40, 0xc5, 0x10, 0x68, 0xe0, 0x7b, 0x14, 0x5a, 0xcc, 0x61, - 0x11, 0x35, 0xef, 0x88, 0xbd, 0x76, 0x57, 0x2b, 0x57, 0x19, 0xd3, 0xc0, 0xb3, 0x69, 0xa5, 0x48, - 0xe6, 0x78, 0xc8, 0x02, 0x2f, 0x76, 0xd0, 0xa6, 0x2a, 0x09, 0x99, 0x88, 0xb9, 0x29, 0x36, 0xda, - 0x59, 0xba, 0x91, 0xba, 0xfd, 0x56, 0xdb, 0x1b, 0x7a, 0xfe, 0x4f, 0x5e, 0xe3, 0xee, 0x6c, 0x5a, - 0xd9, 0x24, 0x69, 0x0a, 0x32, 0xcf, 0x88, 0x7b, 0xfa, 0x30, 0x6a, 0x8f, 0xe2, 0x0d, 0xf7, 0x98, - 0x3b, 0x88, 0xda, 0x64, 0x81, 0x13, 0xff, 0x62, 0x20, 0x53, 0xed, 0x4b, 0xa0, 0x0b, 0xee, 0x04, - 0x7a, 0xc9, 0x3d, 0x35, 0xb7, 0xc4, 0x86, 0xf6, 0x6a, 0xea, 0x3d, 0x73, 0xbb, 0xa1, 0x2f, 0x6e, - 0x7c, 0x55, 0xd5, 0x82, 0x49, 0x96, 0x10, 0x93, 0xa5, 0x5b, 0x62, 0x1f, 0x15, 0xc5, 0xd5, 0xd4, - 0x49, 0x94, 0xfe, 0x5f, 0x12, 0xf1, 0xcd, 0x2f, 0xb6, 0xe6, 0xe8, 0xc8, 0x02, 0x3d, 0x9e, 0xa0, - 0x82, 0xe3, 0x79, 0x3e, 0x13, 0x57, 0x87, 0x9a, 0x77, 0xab, 0x99, 0x9d, 0xc2, 0xfe, 0xe7, 0x2b, - 0x17, 0xa7, 0x68, 0xd9, 0x56, 0x5d, 0x33, 0x3c, 0xf5, 0x58, 0x78, 0xde, 0xb8, 0xa7, 0x76, 0x2f, - 0xa4, 0x3c, 0x24, 0xbd, 0xd1, 0xf6, 0x67, 0xa8, 0xb4, 0x18, 0x85, 0x4b, 0x28, 0x33, 0x84, 0x73, - 0xd1, 0xf4, 0xf3, 0x84, 0x7f, 0xe2, 0xfb, 0x28, 0x3b, 0x71, 0x46, 0x11, 0xc8, 0x4e, 0x4d, 0xe4, - 0xe2, 0x93, 0x5b, 0x87, 0x46, 0xed, 0x85, 0x81, 0xf2, 0x62, 0xf3, 0x23, 0x97, 0x32, 0xfc, 0xdd, - 0xb5, 0x99, 0x61, 0xad, 0x26, 0x18, 0x8f, 0x16, 0x13, 0xa3, 0xa4, 0x32, 0xce, 0xc5, 0x96, 0xd4, - 0xbc, 0x68, 0xa1, 0xac, 0xcb, 0x60, 0x4c, 0xcd, 0x5b, 0x42, 0x1d, 0xeb, 0x66, 0xea, 0x34, 0x36, - 0xe3, 0x26, 0xdc, 0xe4, 0x24, 0x44, 0x72, 0xd5, 0x7e, 0x33, 0x50, 0xf1, 0x8b, 0xd0, 0x8f, 0x02, - 0x02, 0xb2, 0xb3, 0x50, 0xfc, 0x0e, 0xca, 0xf6, 0xb9, 0x45, 0x2a, 0xa0, 0xe3, 0x24, 0x4c, 0xfa, - 0x78, 0xa7, 0x0a, 0xe3, 0x08, 0x91, 0x90, 0xea, 0x54, 0x09, 0x0d, 0xd1, 0x7e, 0x7c, 0xc0, 0xef, - 0xa9, 0x5c, 0x1c, 0x3b, 0x63, 0xa0, 0x66, 0x46, 0x04, 0xa8, 0xdb, 0x97, 0x72, 0x90, 0x79, 0x5c, - 0xed, 0x8f, 0x0c, 0xda, 0x5a, 0x68, 0x3c, 0x78, 0x17, 0xe5, 0x62, 0x90, 0xca, 0x30, 0x11, 0x2d, - 0xe6, 0x22, 0x09, 0x82, 0x37, 0x49, 0x8f, 0x53, 0x05, 0x4e, 0x57, 0xfd, 0x3e, 0xdd, 0x24, 0x8f, - 0x63, 0x07, 0xd1, 0x18, 0x3e, 0x58, 0xf8, 0x42, 0x8c, 0xd8, 0xd4, 0x60, 0xe1, 0x58, 0x22, 0x3c, - 0xb8, 0x81, 0x32, 0x91, 0xdb, 0x53, 0x83, 0xf2, 0x91, 0x02, 0x64, 0xda, 0xab, 0x0e, 0x49, 0x1e, - 0xcc, 0x0f, 0xe1, 0x04, 0xae, 0x50, 0x54, 0xcd, 0xc8, 0xe4, 0x10, 0xf5, 0x93, 0xa6, 0x54, 0x3a, - 0x41, 0xf0, 0x01, 0xe9, 0x04, 0xee, 0x73, 0x08, 0xa9, 0xeb, 0x7b, 0x8b, 0x03, 0xb2, 0x7e, 0xd2, - 0x54, 0x1e, 0x92, 0x42, 0xe1, 0x3a, 0xda, 0x8a, 0x45, 0x88, 0x03, 0xe5, 0xac, 0x7c, 0xa0, 0x02, - 0xb7, 0xc8, 0xbc, 0x9b, 0x2c, 0xe2, 0xf1, 0x47, 0xa8, 0x40, 0xa3, 0x4e, 0x22, 0x76, 0x4e, 0x84, - 0x27, 0x77, 0xaa, 0xa5, 0x5d, 0x24, 0x8d, 0xab, 0xfd, 0x63, 0xa0, 0xdb, 0x27, 0xfe, 0xc8, 0xed, - 0x9e, 0xbf, 0x81, 0x47, 0xd4, 0xd7, 0x28, 0x1b, 0x46, 0x23, 0x88, 0x2f, 0xc5, 0x87, 0x2b, 0x5f, - 0x0a, 0x99, 0x21, 0x89, 0x46, 0xa0, 0x2b, 0x9c, 0xaf, 0x28, 0x91, 0x84, 0xf8, 0x00, 0x21, 0x7f, - 0xec, 0x32, 0xd1, 0xb8, 0xe2, 0x8a, 0x7d, 0x20, 0xf2, 0x48, 0xac, 0xfa, 0x25, 0x93, 0x82, 0xd6, - 0xfe, 0x34, 0x10, 0x92, 0xec, 0x6f, 0xa0, 0x29, 0x9c, 0xce, 0x37, 0x05, 0xfb, 0x86, 0xe7, 0x5f, - 0xd2, 0x15, 0x5e, 0x64, 0xe2, 0x23, 0x70, 0x49, 0xf4, 0x4b, 0xd5, 0x58, 0xe5, 0xa5, 0x5a, 0x41, - 0x59, 0xfe, 0xe6, 0x88, 0xdb, 0x42, 0x9e, 0x23, 0xf9, 0x7b, 0x84, 0x12, 0x69, 0xc7, 0x16, 0x42, - 0xfc, 0x43, 0xd4, 0x76, 0xac, 0x6c, 0x91, 0x2b, 0xdb, 0x4e, 0xac, 0x24, 0x85, 0xe0, 0x84, 0xfc, - 0x45, 0x47, 0xcd, 0x75, 0x4d, 0xc8, 0x1f, 0x7a, 0x94, 0x48, 0x3b, 0x1e, 0xa4, 0x9b, 0x51, 0x56, - 0x08, 0x71, 0xb0, 0xb2, 0x10, 0xf3, 0xdd, 0x4f, 0x77, 0x87, 0xd7, 0x76, 0x32, 0x0b, 0xa1, 0xa4, - 0x55, 0x50, 0xf3, 0xb6, 0x4e, 0x3d, 0xe9, 0x25, 0x94, 0xa4, 0x10, 0xf8, 0x53, 0xb4, 0xe5, 0xf9, - 0x5e, 0x4c, 0xd5, 0x26, 0x47, 0xd4, 0xdc, 0x10, 0x41, 0xf7, 0xf8, 0x0d, 0x3c, 0x9e, 0x77, 0x91, - 0x45, 0xec, 0x42, 0x0d, 0xe6, 0x56, 0xae, 0xc1, 0xc6, 0xc3, 0x8b, 0xcb, 0xf2, 0xda, 0xcb, 0xcb, - 0xf2, 0xda, 0xab, 0xcb, 0xf2, 0xda, 0xcf, 0xb3, 0xb2, 0x71, 0x31, 0x2b, 0x1b, 0x2f, 0x67, 0x65, - 0xe3, 0xd5, 0xac, 0x6c, 0xfc, 0x35, 0x2b, 0x1b, 0xbf, 0xfe, 0x5d, 0x5e, 0xfb, 0x66, 0x43, 0x69, - 0xf0, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4f, 0xae, 0x4a, 0x9d, 0x6e, 0x0e, 0x00, 0x00, + 0x14, 0xcf, 0xc6, 0x71, 0xe3, 0x9d, 0x34, 0x4e, 0x32, 0x2d, 0x74, 0xc9, 0xc1, 0x0e, 0x41, 0x82, + 0x08, 0xd2, 0xdd, 0xb6, 0x14, 0x5a, 0x21, 0x01, 0x8a, 0x69, 0x29, 0x96, 0xda, 0x34, 0x9a, 0xd4, + 0x15, 0x02, 0x0e, 0x8c, 0xed, 0x17, 0x7b, 0x89, 0x3d, 0xbb, 0xec, 0xcc, 0x1a, 0xe5, 0x86, 0xc4, + 0x19, 0x89, 0x3b, 0x9f, 0x81, 0x0b, 0x1f, 0x00, 0x71, 0x42, 0x3d, 0xf6, 0xd8, 0x53, 0x44, 0xcd, + 0xb7, 0xe8, 0x09, 0xcd, 0xec, 0xec, 0xce, 0x7a, 0x53, 0x8b, 0x0d, 0x87, 0xde, 0x76, 0xde, 0xfb, + 0xbd, 0xdf, 0x7b, 0xf3, 0xf6, 0xfd, 0x19, 0x74, 0x70, 0x7c, 0x9b, 0xbb, 0x7e, 0xe0, 0x1d, 0xc7, + 0x5d, 0x88, 0x18, 0x08, 0xe0, 0xde, 0x04, 0x58, 0x3f, 0x88, 0x3c, 0xad, 0xa0, 0xa1, 0xcf, 0x21, + 0x9a, 0x40, 0xe4, 0x85, 0xc7, 0x03, 0x75, 0xf2, 0x68, 0xdc, 0xf7, 0x85, 0x37, 0xb9, 0xde, 0x05, + 0x41, 0xaf, 0x7b, 0x03, 0x60, 0x10, 0x51, 0x01, 0x7d, 0x37, 0x8c, 0x02, 0x11, 0xe0, 0x77, 0x12, + 0x43, 0x37, 0x33, 0x74, 0xc3, 0xe3, 0x81, 0x3a, 0xb9, 0xca, 0xd0, 0xd5, 0x86, 0x9b, 0x57, 0x07, + 0xbe, 0x18, 0xc6, 0x5d, 0xb7, 0x17, 0x8c, 0xbd, 0x41, 0x30, 0x08, 0x3c, 0x65, 0xdf, 0x8d, 0x8f, + 0xd4, 0x49, 0x1d, 0xd4, 0x57, 0xc2, 0xbb, 0xb9, 0x6b, 0x02, 0xf2, 0x68, 0x2c, 0x86, 0xc0, 0x84, + 0xdf, 0xa3, 0xc2, 0x0f, 0x98, 0x37, 0x39, 0x13, 0xc5, 0xe6, 0x4d, 0x83, 0x1e, 0xd3, 0xde, 0xd0, + 0x67, 0x10, 0x9d, 0x98, 0x1b, 0x8c, 0x41, 0xd0, 0x97, 0x59, 0x79, 0xf3, 0xac, 0xa2, 0x98, 0x09, + 0x7f, 0x0c, 0x67, 0x0c, 0x3e, 0xfc, 0x2f, 0x03, 0xde, 0x1b, 0xc2, 0x98, 0x16, 0xed, 0xb6, 0x7f, + 0xbb, 0x88, 0xaa, 0x77, 0x27, 0xc0, 0x04, 0xfe, 0x16, 0xd5, 0x64, 0x34, 0x7d, 0x2a, 0xa8, 0x63, + 0x6d, 0x59, 0x3b, 0x2b, 0x37, 0xae, 0xb9, 0x26, 0x83, 0x19, 0xa9, 0x49, 0xa2, 0x44, 0xbb, 0x93, + 0xeb, 0xee, 0xc3, 0xee, 0x77, 0xd0, 0x13, 0x0f, 0x40, 0xd0, 0x16, 0x7e, 0x72, 0xda, 0x5c, 0x98, + 0x9e, 0x36, 0x91, 0x91, 0x91, 0x8c, 0x15, 0xef, 0xa2, 0xea, 0x08, 0x26, 0x30, 0x72, 0x16, 0xb7, + 0xac, 0x1d, 0xbb, 0xf5, 0xba, 0x06, 0x57, 0xef, 0x4b, 0xe1, 0x8b, 0xf4, 0x83, 0x24, 0x20, 0xfc, + 0x35, 0xb2, 0x65, 0xe0, 0x5c, 0xd0, 0x71, 0xe8, 0x54, 0x54, 0x40, 0xef, 0x96, 0x0b, 0xe8, 0x91, + 0x3f, 0x86, 0xd6, 0x86, 0x66, 0xb7, 0x1f, 0xa5, 0x24, 0xc4, 0xf0, 0xe1, 0x7d, 0xb4, 0xac, 0x6a, + 0xa0, 0x7d, 0xc7, 0x59, 0x52, 0xc1, 0xdc, 0xd4, 0xf0, 0xe5, 0xbd, 0x44, 0xfc, 0xe2, 0xb4, 0xf9, + 0xe6, 0xbc, 0x94, 0x8a, 0x93, 0x10, 0xb8, 0xdb, 0x69, 0xdf, 0x21, 0x29, 0x89, 0xbc, 0x1a, 0x17, + 0x74, 0x00, 0x4e, 0x75, 0xf6, 0x6a, 0x87, 0x52, 0xf8, 0x22, 0xfd, 0x20, 0x09, 0x08, 0xdf, 0x40, + 0x28, 0x82, 0xef, 0x63, 0xe0, 0xa2, 0x43, 0xda, 0xce, 0x05, 0x65, 0x92, 0xa5, 0x8e, 0x64, 0x1a, + 0x92, 0x43, 0xe1, 0x2d, 0xb4, 0x34, 0x81, 0xa8, 0xeb, 0x2c, 0x2b, 0xf4, 0x45, 0x8d, 0x5e, 0x7a, + 0x0c, 0x51, 0x97, 0x28, 0x0d, 0xfe, 0x02, 0x2d, 0xc5, 0x1c, 0x22, 0xa7, 0xa6, 0x72, 0xf5, 0x76, + 0x2e, 0x57, 0xee, 0x6c, 0x99, 0xca, 0x1c, 0x75, 0x38, 0x44, 0x6d, 0x76, 0x14, 0x18, 0x26, 0x29, + 0x21, 0x8a, 0x01, 0x0f, 0xd1, 0xba, 0x3f, 0x0e, 0x21, 0xe2, 0x01, 0x93, 0xa5, 0x22, 0x35, 0x8e, + 0x7d, 0x2e, 0xd6, 0xcb, 0xd3, 0xd3, 0xe6, 0x7a, 0xbb, 0xc0, 0x41, 0xce, 0xb0, 0xe2, 0xf7, 0x90, + 0xcd, 0x83, 0x38, 0xea, 0x41, 0xfb, 0x80, 0x3b, 0x68, 0xab, 0xb2, 0x63, 0xb7, 0x56, 0xe5, 0x4f, + 0x3b, 0x4c, 0x85, 0xc4, 0xe8, 0xb1, 0x87, 0x6c, 0x19, 0xde, 0xde, 0x00, 0x98, 0x70, 0xb0, 0xca, + 0x43, 0xf6, 0x97, 0x3b, 0xa9, 0x82, 0x18, 0x0c, 0x06, 0x64, 0x07, 0xaa, 0x10, 0x09, 0x1c, 0x39, + 0x2b, 0xea, 0x02, 0xb7, 0xdd, 0x92, 0x53, 0x41, 0x97, 0x35, 0x81, 0x23, 0x88, 0x80, 0xf5, 0x20, + 0x89, 0x2b, 0x13, 0x12, 0xc3, 0x8c, 0x87, 0xa8, 0x1e, 0x01, 0x0f, 0x03, 0xc6, 0xe1, 0x50, 0x50, + 0x11, 0x73, 0xe7, 0xa2, 0xf2, 0xb5, 0x5b, 0xae, 0x5c, 0x13, 0x9b, 0x16, 0x9e, 0x9e, 0x36, 0xeb, + 0x64, 0x86, 0x87, 0x14, 0x78, 0x31, 0x45, 0xab, 0xba, 0x24, 0x92, 0x40, 0x9c, 0x55, 0xe5, 0x68, + 0x67, 0xae, 0x23, 0xdd, 0xfd, 0x6e, 0x87, 0x1d, 0xb3, 0xe0, 0x07, 0xd6, 0xda, 0x98, 0x9e, 0x36, + 0x57, 0x49, 0x9e, 0x82, 0xcc, 0x32, 0xe2, 0xbe, 0xb9, 0x8c, 0xf6, 0x51, 0x3f, 0xa7, 0x8f, 0x99, + 0x8b, 0x68, 0x27, 0x05, 0x4e, 0xfc, 0xb3, 0x85, 0x1c, 0xed, 0x97, 0x40, 0x0f, 0xfc, 0x09, 0xf4, + 0xb3, 0x3e, 0x75, 0xd6, 0x94, 0x43, 0xaf, 0x5c, 0xf6, 0x1e, 0xf8, 0xbd, 0x28, 0x50, 0x1d, 0xbf, + 0xa5, 0x6b, 0xc1, 0x21, 0x73, 0x88, 0xc9, 0x5c, 0x97, 0x38, 0x40, 0x75, 0xd5, 0x9a, 0x26, 0x88, + 0xf5, 0xff, 0x17, 0x44, 0xda, 0xf9, 0xf5, 0xc3, 0x19, 0x3a, 0x52, 0xa0, 0xc7, 0x13, 0xb4, 0x42, + 0x19, 0x0b, 0x84, 0x6a, 0x1d, 0xee, 0x6c, 0x6c, 0x55, 0x76, 0x56, 0x6e, 0x7c, 0x5a, 0xba, 0x38, + 0xd5, 0xc8, 0x76, 0xf7, 0x0c, 0xc3, 0x5d, 0x26, 0xa2, 0x93, 0xd6, 0x25, 0xed, 0x7d, 0x25, 0xa7, + 0x21, 0x79, 0x47, 0x9b, 0x9f, 0xa0, 0xf5, 0xa2, 0x15, 0x5e, 0x47, 0x95, 0x63, 0x38, 0x51, 0x43, + 0xdf, 0x26, 0xf2, 0x13, 0x5f, 0x46, 0xd5, 0x09, 0x1d, 0xc5, 0x90, 0x4c, 0x6a, 0x92, 0x1c, 0x3e, + 0x5a, 0xbc, 0x6d, 0x6d, 0xff, 0x61, 0x21, 0x5b, 0x39, 0xbf, 0xef, 0x73, 0x81, 0xbf, 0x39, 0xb3, + 0x33, 0xdc, 0x72, 0x09, 0x93, 0xd6, 0x6a, 0x63, 0xac, 0xeb, 0x88, 0x6b, 0xa9, 0x24, 0xb7, 0x2f, + 0x0e, 0x51, 0xd5, 0x17, 0x30, 0xe6, 0xce, 0xa2, 0xca, 0x8e, 0x7b, 0xbe, 0xec, 0xb4, 0x56, 0xd3, + 0x21, 0xdc, 0x96, 0x24, 0x24, 0xe1, 0xda, 0xfe, 0xd5, 0x42, 0xf5, 0x7b, 0x51, 0x10, 0x87, 0x04, + 0x92, 0xc9, 0xc2, 0xf1, 0x5b, 0xa8, 0x3a, 0x90, 0x92, 0x24, 0x03, 0xc6, 0x2e, 0x81, 0x25, 0x3a, + 0x39, 0xa9, 0xa2, 0xd4, 0x42, 0x05, 0xa4, 0x27, 0x55, 0x46, 0x43, 0x8c, 0x1e, 0xdf, 0x92, 0x7d, + 0x9a, 0x1c, 0xf6, 0xe9, 0x18, 0xb8, 0x53, 0x51, 0x06, 0xba, 0xfb, 0x72, 0x0a, 0x32, 0x8b, 0xdb, + 0xfe, 0xbd, 0x82, 0xd6, 0x0a, 0x83, 0x07, 0xef, 0xa2, 0x5a, 0x0a, 0xd2, 0x11, 0x66, 0x49, 0x4b, + 0xb9, 0x48, 0x86, 0x90, 0x43, 0x92, 0x49, 0xaa, 0x90, 0xf6, 0xf4, 0xef, 0x33, 0x43, 0x72, 0x3f, + 0x55, 0x10, 0x83, 0x91, 0x8b, 0x45, 0x1e, 0xd4, 0x8a, 0xcd, 0x2d, 0x16, 0x89, 0x25, 0x4a, 0x83, + 0x5b, 0xa8, 0x12, 0xfb, 0x7d, 0xbd, 0x28, 0xaf, 0x69, 0x40, 0xa5, 0x53, 0x76, 0x49, 0x4a, 0x63, + 0x79, 0x09, 0x1a, 0xfa, 0x2a, 0xa3, 0x7a, 0x47, 0x66, 0x97, 0xd8, 0x3b, 0x68, 0x27, 0x99, 0xce, + 0x10, 0x72, 0x41, 0xd2, 0xd0, 0x7f, 0x0c, 0x11, 0xf7, 0x03, 0x56, 0x5c, 0x90, 0x7b, 0x07, 0x6d, + 0xad, 0x21, 0x39, 0x14, 0xde, 0x43, 0x6b, 0x69, 0x12, 0x52, 0xc3, 0x64, 0x57, 0x5e, 0xd1, 0x86, + 0x6b, 0x64, 0x56, 0x4d, 0x8a, 0x78, 0xfc, 0x01, 0x5a, 0xe1, 0x71, 0x37, 0x4b, 0x76, 0x4d, 0x99, + 0x67, 0x3d, 0x75, 0x68, 0x54, 0x24, 0x8f, 0xdb, 0xfe, 0x6b, 0x11, 0x5d, 0x38, 0x08, 0x46, 0x7e, + 0xef, 0xe4, 0x15, 0x3c, 0xa2, 0xbe, 0x44, 0xd5, 0x28, 0x1e, 0x41, 0xda, 0x14, 0xef, 0x97, 0x6e, + 0x8a, 0x24, 0x42, 0x12, 0x8f, 0xc0, 0x54, 0xb8, 0x3c, 0x71, 0x92, 0x10, 0xe2, 0x5b, 0x08, 0x05, + 0x63, 0x5f, 0xa8, 0xc1, 0x95, 0x56, 0xec, 0x15, 0x15, 0x47, 0x26, 0x35, 0x2f, 0x99, 0x1c, 0x14, + 0xdf, 0x43, 0x1b, 0xf2, 0xf4, 0x80, 0x32, 0x3a, 0x80, 0xfe, 0xe7, 0x3e, 0x8c, 0xfa, 0x5c, 0x55, + 0x4b, 0xad, 0xf5, 0x86, 0xf6, 0xb4, 0xf1, 0xb0, 0x08, 0x20, 0x67, 0x6d, 0xb6, 0xff, 0xb4, 0x10, + 0x4a, 0xc2, 0x7c, 0x05, 0xd3, 0xe5, 0xd1, 0xec, 0x74, 0xf1, 0xce, 0x99, 0xc8, 0x39, 0xe3, 0xe5, + 0xa7, 0xa5, 0xf4, 0x0a, 0x32, 0xb7, 0xe6, 0xc9, 0x6b, 0x95, 0x79, 0xf2, 0x36, 0x51, 0x55, 0x3e, + 0x5e, 0xd2, 0xf9, 0x62, 0x4b, 0xa4, 0x7c, 0xd8, 0x70, 0x92, 0xc8, 0xb1, 0x8b, 0x90, 0xfc, 0x50, + 0x4d, 0x92, 0xfe, 0xa2, 0xba, 0xfc, 0x45, 0x9d, 0x4c, 0x4a, 0x72, 0x08, 0x49, 0x28, 0x9f, 0x86, + 0xf2, 0x6f, 0x64, 0x84, 0xf2, 0xc5, 0xc8, 0x49, 0x22, 0xc7, 0xc3, 0xfc, 0x54, 0xab, 0xaa, 0x44, + 0xdc, 0x2a, 0x9d, 0x88, 0xd9, 0x31, 0x6a, 0xc6, 0xcc, 0x4b, 0x47, 0xa2, 0x8b, 0x50, 0x36, 0x73, + 0xb8, 0x73, 0xc1, 0x84, 0x9e, 0x0d, 0x25, 0x4e, 0x72, 0x08, 0xfc, 0x31, 0x5a, 0x63, 0x01, 0x4b, + 0xa9, 0x3a, 0xe4, 0x3e, 0x77, 0x96, 0x95, 0xd1, 0x25, 0xd9, 0xca, 0xfb, 0xb3, 0x2a, 0x52, 0xc4, + 0x16, 0x8a, 0xb9, 0x56, 0xbe, 0x98, 0x3f, 0x7b, 0x59, 0x31, 0xdb, 0xaa, 0x98, 0x5f, 0x2b, 0x5b, + 0xc8, 0xad, 0xab, 0x4f, 0x9e, 0x37, 0x16, 0x9e, 0x3e, 0x6f, 0x2c, 0x3c, 0x7b, 0xde, 0x58, 0xf8, + 0x71, 0xda, 0xb0, 0x9e, 0x4c, 0x1b, 0xd6, 0xd3, 0x69, 0xc3, 0x7a, 0x36, 0x6d, 0x58, 0x7f, 0x4f, + 0x1b, 0xd6, 0x2f, 0xff, 0x34, 0x16, 0xbe, 0x5a, 0xd6, 0x89, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff, + 0x21, 0x57, 0x33, 0x77, 0xfc, 0x0e, 0x00, 0x00, } func (m *Event) Marshal() (dAtA []byte, err error) { @@ -722,6 +725,14 @@ func (m *Policy) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + i-- + if m.OmitManagedFields { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 if len(m.OmitStages) > 0 { for iNdEx := len(m.OmitStages) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.OmitStages[iNdEx]) @@ -825,6 +836,16 @@ func (m *PolicyRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.OmitManagedFields != nil { + i-- + if *m.OmitManagedFields { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } if len(m.OmitStages) > 0 { for iNdEx := len(m.OmitStages) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.OmitStages[iNdEx]) @@ -1062,6 +1083,7 @@ func (m *Policy) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + n += 2 return n } @@ -1132,6 +1154,9 @@ func (m *PolicyRule) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + if m.OmitManagedFields != nil { + n += 2 + } return n } @@ -1236,6 +1261,7 @@ func (this *Policy) String() string { `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, `Rules:` + repeatedStringForRules + `,`, `OmitStages:` + fmt.Sprintf("%v", this.OmitStages) + `,`, + `OmitManagedFields:` + fmt.Sprintf("%v", this.OmitManagedFields) + `,`, `}`, }, "") return s @@ -1274,6 +1300,7 @@ func (this *PolicyRule) String() string { `Namespaces:` + fmt.Sprintf("%v", this.Namespaces) + `,`, `NonResourceURLs:` + fmt.Sprintf("%v", this.NonResourceURLs) + `,`, `OmitStages:` + fmt.Sprintf("%v", this.OmitStages) + `,`, + `OmitManagedFields:` + valueToStringGenerated(this.OmitManagedFields) + `,`, `}`, }, "") return s @@ -2729,6 +2756,26 @@ func (m *Policy) Unmarshal(dAtA []byte) error { } m.OmitStages = append(m.OmitStages, Stage(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OmitManagedFields", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.OmitManagedFields = bool(v != 0) default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -3154,6 +3201,27 @@ func (m *PolicyRule) Unmarshal(dAtA []byte) error { } m.OmitStages = append(m.OmitStages, Stage(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OmitManagedFields", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.OmitManagedFields = &b default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.proto b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.proto index 0a200b5383..e78039fdd5 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.proto +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/generated.proto @@ -204,6 +204,15 @@ message Policy { // be specified per rule in which case the union of both are omitted. // +optional repeated string omitStages = 3; + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // This is used as a global default - a value of 'true' will omit the managed fileds, + // otherwise the managed fields will be included in the API audit log. + // Note that this can also be specified per rule in which case the value specified + // in a rule will override the global default. + // +optional + optional bool omitManagedFields = 4; } // PolicyList is a list of audit Policies. @@ -259,5 +268,16 @@ message PolicyRule { // An empty list means no restrictions will apply. // +optional repeated string omitStages = 8; + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // - a value of 'true' will drop the managed fields from the API audit log + // - a value of 'false' indicates that the managed fileds should be included + // in the API audit log + // Note that the value, if specified, in this rule will override the global default + // If a value is not specified then the global default specified in + // Policy.OmitManagedFields will stand. + // +optional + optional bool omitManagedFields = 9; } diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/types.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/types.go index eb538bc176..fcca2bcb86 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/types.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/types.go @@ -187,6 +187,15 @@ type Policy struct { // be specified per rule in which case the union of both are omitted. // +optional OmitStages []Stage `json:"omitStages,omitempty" protobuf:"bytes,3,rep,name=omitStages"` + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // This is used as a global default - a value of 'true' will omit the managed fileds, + // otherwise the managed fields will be included in the API audit log. + // Note that this can also be specified per rule in which case the value specified + // in a rule will override the global default. + // +optional + OmitManagedFields bool `json:"omitManagedFields,omitempty" protobuf:"varint,4,opt,name=omitManagedFields"` } // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object @@ -250,6 +259,17 @@ type PolicyRule struct { // An empty list means no restrictions will apply. // +optional OmitStages []Stage `json:"omitStages,omitempty" protobuf:"bytes,8,rep,name=omitStages"` + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + // - a value of 'true' will drop the managed fields from the API audit log + // - a value of 'false' indicates that the managed fileds should be included + // in the API audit log + // Note that the value, if specified, in this rule will override the global default + // If a value is not specified then the global default specified in + // Policy.OmitManagedFields will stand. + // +optional + OmitManagedFields *bool `json:"omitManagedFields,omitempty" protobuf:"varint,9,opt,name=omitManagedFields"` } // GroupResources represents resource kinds in an API group. diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.conversion.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.conversion.go index 0aac32119e..33bfc76e32 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -257,6 +258,7 @@ func autoConvert_v1beta1_Policy_To_audit_Policy(in *Policy, out *audit.Policy, s out.ObjectMeta = in.ObjectMeta out.Rules = *(*[]audit.PolicyRule)(unsafe.Pointer(&in.Rules)) out.OmitStages = *(*[]audit.Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = in.OmitManagedFields return nil } @@ -269,6 +271,7 @@ func autoConvert_audit_Policy_To_v1beta1_Policy(in *audit.Policy, out *Policy, s out.ObjectMeta = in.ObjectMeta out.Rules = *(*[]PolicyRule)(unsafe.Pointer(&in.Rules)) out.OmitStages = *(*[]Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = in.OmitManagedFields return nil } @@ -308,6 +311,7 @@ func autoConvert_v1beta1_PolicyRule_To_audit_PolicyRule(in *PolicyRule, out *aud out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces)) out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs)) out.OmitStages = *(*[]audit.Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = (*bool)(unsafe.Pointer(in.OmitManagedFields)) return nil } @@ -325,6 +329,7 @@ func autoConvert_audit_PolicyRule_To_v1beta1_PolicyRule(in *audit.PolicyRule, ou out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces)) out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs)) out.OmitStages = *(*[]Stage)(unsafe.Pointer(&in.OmitStages)) + out.OmitManagedFields = (*bool)(unsafe.Pointer(in.OmitManagedFields)) return nil } diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.deepcopy.go index 5adbd5a78c..ee7f8b90ea 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -279,6 +280,11 @@ func (in *PolicyRule) DeepCopyInto(out *PolicyRule) { *out = make([]Stage, len(*in)) copy(*out, *in) } + if in.OmitManagedFields != nil { + in, out := &in.OmitManagedFields, &out.OmitManagedFields + *out = new(bool) + **out = **in + } return } diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.defaults.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.defaults.go index 73e63fc114..198b5be4af 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.prerelease-lifecycle.go b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.prerelease-lifecycle.go index e475d4c2e6..0a0dc6669f 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.prerelease-lifecycle.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/v1beta1/zz_generated.prerelease-lifecycle.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/audit/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/audit/zz_generated.deepcopy.go index a210f631b2..81d5add47d 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/audit/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/audit/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -277,6 +278,11 @@ func (in *PolicyRule) DeepCopyInto(out *PolicyRule) { *out = make([]Stage, len(*in)) copy(*out, *in) } + if in.OmitManagedFields != nil { + in, out := &in.OmitManagedFields, &out.OmitManagedFields + *out = new(bool) + **out = **in + } return } diff --git a/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.conversion.go b/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.conversion.go index c7de6539d8..ff2132f729 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.conversion.go +++ b/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.deepcopy.go index dcb4e85529..3d2ac484b0 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.defaults.go b/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.defaults.go index 1c8db8d04f..82fec01110 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.defaults.go +++ b/vendor/k8s.io/apiserver/pkg/apis/config/v1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/config/zz_generated.deepcopy.go b/vendor/k8s.io/apiserver/pkg/apis/config/zz_generated.deepcopy.go index dd66315ee7..13e5cffca8 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/config/zz_generated.deepcopy.go +++ b/vendor/k8s.io/apiserver/pkg/apis/config/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/apiserver/pkg/apis/flowcontrol/bootstrap/default.go b/vendor/k8s.io/apiserver/pkg/apis/flowcontrol/bootstrap/default.go index dbb932aa34..8ae15a0ec7 100644 --- a/vendor/k8s.io/apiserver/pkg/apis/flowcontrol/bootstrap/default.go +++ b/vendor/k8s.io/apiserver/pkg/apis/flowcontrol/bootstrap/default.go @@ -19,7 +19,7 @@ package bootstrap import ( coordinationv1 "k8s.io/api/coordination/v1" corev1 "k8s.io/api/core/v1" - flowcontrol "k8s.io/api/flowcontrol/v1beta1" + flowcontrol "k8s.io/api/flowcontrol/v1beta2" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apiserver/pkg/authentication/serviceaccount" "k8s.io/apiserver/pkg/authentication/user" diff --git a/vendor/k8s.io/apiserver/pkg/audit/context.go b/vendor/k8s.io/apiserver/pkg/audit/context.go index 3d616bbd4c..eada7add9a 100644 --- a/vendor/k8s.io/apiserver/pkg/audit/context.go +++ b/vendor/k8s.io/apiserver/pkg/audit/context.go @@ -19,6 +19,7 @@ package audit import ( "context" + auditinternal "k8s.io/apiserver/pkg/apis/audit" genericapirequest "k8s.io/apiserver/pkg/endpoints/request" ) @@ -27,7 +28,15 @@ type key int const ( // auditAnnotationsKey is the context key for the audit annotations. + // TODO: it's wasteful to store the audit annotations under a separate key, we + // copy the request context twice for audit purposes. We should move the audit + // annotations under AuditContext so we can get rid of the additional request + // context copy. auditAnnotationsKey key = iota + + // auditKey is the context key for storing the audit event that is being + // captured and the evaluated policy that applies to the given request. + auditKey ) // annotations = *[]annotation instead of a map to preserve order of insertions @@ -59,7 +68,7 @@ func WithAuditAnnotations(parent context.Context) context.Context { // prefer AddAuditAnnotation over LogAnnotation to avoid dropping annotations. func AddAuditAnnotation(ctx context.Context, key, value string) { // use the audit event directly if we have it - if ae := genericapirequest.AuditEventFrom(ctx); ae != nil { + if ae := AuditEventFrom(ctx); ae != nil { LogAnnotation(ae, key, value) return } @@ -82,3 +91,26 @@ func auditAnnotationsFrom(ctx context.Context) []annotation { return *annotations } + +// WithAuditContext returns a new context that stores the pair of the audit +// configuration object that applies to the given request and +// the audit event that is going to be written to the API audit log. +func WithAuditContext(parent context.Context, ev *AuditContext) context.Context { + return genericapirequest.WithValue(parent, auditKey, ev) +} + +// AuditEventFrom returns the audit event struct on the ctx +func AuditEventFrom(ctx context.Context) *auditinternal.Event { + if o := AuditContextFrom(ctx); o != nil { + return o.Event + } + return nil +} + +// AuditContextFrom returns the pair of the audit configuration object +// that applies to the given request and the audit event that is going to +// be written to the API audit log. +func AuditContextFrom(ctx context.Context) *AuditContext { + ev, _ := ctx.Value(auditKey).(*AuditContext) + return ev +} diff --git a/vendor/k8s.io/apiserver/pkg/audit/evaluator.go b/vendor/k8s.io/apiserver/pkg/audit/evaluator.go new file mode 100644 index 0000000000..d5e40428c0 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/audit/evaluator.go @@ -0,0 +1,65 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package audit + +import ( + "k8s.io/apiserver/pkg/apis/audit" + "k8s.io/apiserver/pkg/authorization/authorizer" +) + +// AuditContext is a pair of the audit configuration object that applies to +// a given request and the audit Event object that is being captured. +// It's a convenient placeholder to store both these objects in the request context. +type AuditContext struct { + // RequestAuditConfig is the audit configuration that applies to the request + RequestAuditConfig RequestAuditConfig + + // Event is the audit Event object that is being captured to be written in + // the API audit log. It is set to nil when the request is not being audited. + Event *audit.Event +} + +// RequestAuditConfig is the evaluated audit configuration that is applicable to +// a given request. PolicyRuleEvaluator evaluates the audit policy against the +// authorizer attributes and returns a RequestAuditConfig that applies to the request. +type RequestAuditConfig struct { + // OmitStages is the stages that need to be omitted from being audited. + OmitStages []audit.Stage + + // OmitManagedFields indicates whether to omit the managed fields of the request + // and response bodies from being written to the API audit log. + OmitManagedFields bool +} + +// RequestAuditConfigWithLevel includes Level at which the request is being audited. +// PolicyRuleEvaluator evaluates the audit configuration for a request +// against the authorizer attributes and returns an RequestAuditConfigWithLevel +// that applies to the request. +type RequestAuditConfigWithLevel struct { + RequestAuditConfig + + // Level at which the request is being audited at + Level audit.Level +} + +// PolicyRuleEvaluator exposes methods for evaluating the policy rules. +type PolicyRuleEvaluator interface { + // EvaluatePolicyRule evaluates the audit policy of the apiserver against + // the given authorizer attributes and returns the audit configuration that + // is applicable to the given equest. + EvaluatePolicyRule(authorizer.Attributes) RequestAuditConfigWithLevel +} diff --git a/vendor/k8s.io/apiserver/pkg/audit/policy/checker.go b/vendor/k8s.io/apiserver/pkg/audit/policy/checker.go index e9a901abf6..6a98ff4ac0 100644 --- a/vendor/k8s.io/apiserver/pkg/audit/policy/checker.go +++ b/vendor/k8s.io/apiserver/pkg/audit/policy/checker.go @@ -20,6 +20,7 @@ import ( "strings" "k8s.io/apiserver/pkg/apis/audit" + auditinternal "k8s.io/apiserver/pkg/audit" "k8s.io/apiserver/pkg/authorization/authorizer" ) @@ -28,18 +29,12 @@ const ( DefaultAuditLevel = audit.LevelNone ) -// Checker exposes methods for checking the policy rules. -type Checker interface { - // Check the audit level for a request with the given authorizer attributes. - LevelAndStages(authorizer.Attributes) (audit.Level, []audit.Stage) -} - -// NewChecker creates a new policy checker. -func NewChecker(policy *audit.Policy) Checker { +// NewPolicyRuleEvaluator creates a new policy rule evaluator. +func NewPolicyRuleEvaluator(policy *audit.Policy) auditinternal.PolicyRuleEvaluator { for i, rule := range policy.Rules { policy.Rules[i].OmitStages = unionStages(policy.OmitStages, rule.OmitStages) } - return &policyChecker{*policy} + return &policyRuleEvaluator{*policy} } func unionStages(stageLists ...[]audit.Stage) []audit.Stage { @@ -56,22 +51,48 @@ func unionStages(stageLists ...[]audit.Stage) []audit.Stage { return result } -// FakeChecker creates a checker that returns a constant level for all requests (for testing). -func FakeChecker(level audit.Level, stage []audit.Stage) Checker { - return &fakeChecker{level, stage} +// NewFakePolicyRuleEvaluator creates a fake policy rule evaluator that returns +// a constant level for all requests (for testing). +func NewFakePolicyRuleEvaluator(level audit.Level, stage []audit.Stage) auditinternal.PolicyRuleEvaluator { + return &fakePolicyRuleEvaluator{level, stage} } -type policyChecker struct { +type policyRuleEvaluator struct { audit.Policy } -func (p *policyChecker) LevelAndStages(attrs authorizer.Attributes) (audit.Level, []audit.Stage) { +func (p *policyRuleEvaluator) EvaluatePolicyRule(attrs authorizer.Attributes) auditinternal.RequestAuditConfigWithLevel { for _, rule := range p.Rules { if ruleMatches(&rule, attrs) { - return rule.Level, rule.OmitStages + return auditinternal.RequestAuditConfigWithLevel{ + Level: rule.Level, + RequestAuditConfig: auditinternal.RequestAuditConfig{ + OmitStages: rule.OmitStages, + OmitManagedFields: isOmitManagedFields(&rule, p.OmitManagedFields), + }, + } } } - return DefaultAuditLevel, p.OmitStages + + return auditinternal.RequestAuditConfigWithLevel{ + Level: DefaultAuditLevel, + RequestAuditConfig: auditinternal.RequestAuditConfig{ + OmitStages: p.OmitStages, + OmitManagedFields: p.OmitManagedFields, + }, + } +} + +// isOmitManagedFields returns whether to omit managed fields from the request +// and response bodies from being written to the API audit log. +// If a user specifies OmitManagedFields inside a policy rule, that overrides +// the global policy default in Policy.OmitManagedFields. +func isOmitManagedFields(policyRule *audit.PolicyRule, policyDefault bool) bool { + if policyRule.OmitManagedFields == nil { + return policyDefault + } + + return *policyRule.OmitManagedFields } // Check whether the rule matches the request attrs. @@ -209,11 +230,16 @@ func hasString(slice []string, value string) bool { return false } -type fakeChecker struct { +type fakePolicyRuleEvaluator struct { level audit.Level stage []audit.Stage } -func (f *fakeChecker) LevelAndStages(_ authorizer.Attributes) (audit.Level, []audit.Stage) { - return f.level, f.stage +func (f *fakePolicyRuleEvaluator) EvaluatePolicyRule(_ authorizer.Attributes) auditinternal.RequestAuditConfigWithLevel { + return auditinternal.RequestAuditConfigWithLevel{ + Level: f.level, + RequestAuditConfig: auditinternal.RequestAuditConfig{ + OmitStages: f.stage, + }, + } } diff --git a/vendor/k8s.io/apiserver/pkg/audit/request.go b/vendor/k8s.io/apiserver/pkg/audit/request.go index 29ad4b72b4..cdfd535f7e 100644 --- a/vendor/k8s.io/apiserver/pkg/audit/request.go +++ b/vendor/k8s.io/apiserver/pkg/audit/request.go @@ -18,6 +18,7 @@ package audit import ( "bytes" + "context" "fmt" "net/http" "reflect" @@ -111,7 +112,8 @@ func LogImpersonatedUser(ae *auditinternal.Event, user user.Info) { // LogRequestObject fills in the request object into an audit event. The passed runtime.Object // will be converted to the given gv. -func LogRequestObject(ae *auditinternal.Event, obj runtime.Object, objGV schema.GroupVersion, gvr schema.GroupVersionResource, subresource string, s runtime.NegotiatedSerializer) { +func LogRequestObject(ctx context.Context, obj runtime.Object, objGV schema.GroupVersion, gvr schema.GroupVersionResource, subresource string, s runtime.NegotiatedSerializer) { + ae := AuditEventFrom(ctx) if ae == nil || ae.Level.Less(auditinternal.LevelMetadata) { return } @@ -151,6 +153,16 @@ func LogRequestObject(ae *auditinternal.Event, obj runtime.Object, objGV schema. return } + if shouldOmitManagedFields(ctx) { + copy, ok, err := copyWithoutManagedFields(obj) + if err != nil { + klog.Warningf("error while dropping managed fields from the request for %q error: %v", reflect.TypeOf(obj).Name(), err) + } + if ok { + obj = copy + } + } + // TODO(audit): hook into the serializer to avoid double conversion var err error ae.RequestObject, err = encodeObject(obj, objGV, s) @@ -162,7 +174,8 @@ func LogRequestObject(ae *auditinternal.Event, obj runtime.Object, objGV schema. } // LogRequestPatch fills in the given patch as the request object into an audit event. -func LogRequestPatch(ae *auditinternal.Event, patch []byte) { +func LogRequestPatch(ctx context.Context, patch []byte) { + ae := AuditEventFrom(ctx) if ae == nil || ae.Level.Less(auditinternal.LevelRequest) { return } @@ -175,7 +188,8 @@ func LogRequestPatch(ae *auditinternal.Event, patch []byte) { // LogResponseObject fills in the response object into an audit event. The passed runtime.Object // will be converted to the given gv. -func LogResponseObject(ae *auditinternal.Event, obj runtime.Object, gv schema.GroupVersion, s runtime.NegotiatedSerializer) { +func LogResponseObject(ctx context.Context, obj runtime.Object, gv schema.GroupVersion, s runtime.NegotiatedSerializer) { + ae := AuditEventFrom(ctx) if ae == nil || ae.Level.Less(auditinternal.LevelMetadata) { return } @@ -191,6 +205,17 @@ func LogResponseObject(ae *auditinternal.Event, obj runtime.Object, gv schema.Gr if ae.Level.Less(auditinternal.LevelRequestResponse) { return } + + if shouldOmitManagedFields(ctx) { + copy, ok, err := copyWithoutManagedFields(obj) + if err != nil { + klog.Warningf("error while dropping managed fields from the response for %q error: %v", reflect.TypeOf(obj).Name(), err) + } + if ok { + obj = copy + } + } + // TODO(audit): hook into the serializer to avoid double conversion var err error ae.ResponseObject, err = encodeObject(obj, gv, s) @@ -242,3 +267,72 @@ func maybeTruncateUserAgent(req *http.Request) string { return ua } + +// copyWithoutManagedFields will make a deep copy of the specified object and +// will discard the managed fields from the copy. +// The specified object is expected to be a meta.Object or a "list". +// The specified object obj is treated as readonly and hence not mutated. +// On return, an error is set if the function runs into any error while +// removing the managed fields, the boolean value is true if the copy has +// been made successfully, otherwise false. +func copyWithoutManagedFields(obj runtime.Object) (runtime.Object, bool, error) { + isAccessor := true + if _, err := meta.Accessor(obj); err != nil { + isAccessor = false + } + isList := meta.IsListType(obj) + _, isTable := obj.(*metav1.Table) + if !isAccessor && !isList && !isTable { + return nil, false, nil + } + + // TODO a deep copy isn't really needed here, figure out how we can reliably + // use shallow copy here to omit the manageFields. + copy := obj.DeepCopyObject() + + if isAccessor { + if err := removeManagedFields(copy); err != nil { + return nil, false, err + } + } + + if isList { + if err := meta.EachListItem(copy, removeManagedFields); err != nil { + return nil, false, err + } + } + + if isTable { + table := copy.(*metav1.Table) + for i := range table.Rows { + rowObj := table.Rows[i].Object + if err := removeManagedFields(rowObj.Object); err != nil { + return nil, false, err + } + } + } + + return copy, true, nil +} + +func removeManagedFields(obj runtime.Object) error { + if obj == nil { + return nil + } + accessor, err := meta.Accessor(obj) + if err != nil { + return err + } + accessor.SetManagedFields(nil) + return nil +} + +func shouldOmitManagedFields(ctx context.Context) bool { + if auditContext := AuditContextFrom(ctx); auditContext != nil { + return auditContext.RequestAuditConfig.OmitManagedFields + } + + // If we can't decide, return false to maintain current behavior which is + // to retain the manage fields in the audit. + return false +} diff --git a/vendor/k8s.io/apiserver/pkg/authentication/token/cache/cache_simple.go b/vendor/k8s.io/apiserver/pkg/authentication/token/cache/cache_simple.go index 8e0520af16..a2c5ce680b 100644 --- a/vendor/k8s.io/apiserver/pkg/authentication/token/cache/cache_simple.go +++ b/vendor/k8s.io/apiserver/pkg/authentication/token/cache/cache_simple.go @@ -20,7 +20,7 @@ import ( "time" utilcache "k8s.io/apimachinery/pkg/util/cache" - "k8s.io/apimachinery/pkg/util/clock" + "k8s.io/utils/clock" ) type simpleCache struct { diff --git a/vendor/k8s.io/apiserver/pkg/authentication/token/cache/cached_token_authenticator.go b/vendor/k8s.io/apiserver/pkg/authentication/token/cache/cached_token_authenticator.go index b0d06a2318..787d926b4e 100644 --- a/vendor/k8s.io/apiserver/pkg/authentication/token/cache/cached_token_authenticator.go +++ b/vendor/k8s.io/apiserver/pkg/authentication/token/cache/cached_token_authenticator.go @@ -33,12 +33,11 @@ import ( "golang.org/x/sync/singleflight" apierrors "k8s.io/apimachinery/pkg/api/errors" - utilclock "k8s.io/apimachinery/pkg/util/clock" auditinternal "k8s.io/apiserver/pkg/apis/audit" "k8s.io/apiserver/pkg/audit" "k8s.io/apiserver/pkg/authentication/authenticator" - "k8s.io/apiserver/pkg/endpoints/request" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) var errAuthnCrash = apierrors.NewInternalError(errors.New("authentication failed unexpectedly")) @@ -89,10 +88,10 @@ type cache interface { // New returns a token authenticator that caches the results of the specified authenticator. A ttl of 0 bypasses the cache. func New(authenticator authenticator.Token, cacheErrs bool, successTTL, failureTTL time.Duration) authenticator.Token { - return newWithClock(authenticator, cacheErrs, successTTL, failureTTL, utilclock.RealClock{}) + return newWithClock(authenticator, cacheErrs, successTTL, failureTTL, clock.RealClock{}) } -func newWithClock(authenticator authenticator.Token, cacheErrs bool, successTTL, failureTTL time.Duration, clock utilclock.Clock) authenticator.Token { +func newWithClock(authenticator authenticator.Token, cacheErrs bool, successTTL, failureTTL time.Duration, clock clock.Clock) authenticator.Token { randomCacheKey := make([]byte, 32) if _, err := rand.Read(randomCacheKey); err != nil { panic(err) // rand should never fail @@ -189,7 +188,7 @@ func (a *cachedTokenAuthenticator) doAuthenticateToken(ctx context.Context, toke // since this is shared work between multiple requests, we have no way of knowing if any // particular request supports audit annotations. thus we always attempt to record them. ev := &auditinternal.Event{Level: auditinternal.LevelMetadata} - ctx = request.WithAuditEvent(ctx, ev) + ctx = audit.WithAuditContext(ctx, &audit.AuditContext{Event: ev}) record.resp, record.ok, record.err = a.authenticator.AuthenticateToken(ctx, token) record.annotations = ev.Annotations diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filterlatency/filterlatency.go b/vendor/k8s.io/apiserver/pkg/endpoints/filterlatency/filterlatency.go index 07880e5e2a..40e32a1a19 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/filterlatency/filterlatency.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filterlatency/filterlatency.go @@ -18,14 +18,15 @@ package filterlatency import ( "context" + "fmt" "net/http" "time" - utilclock "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apiserver/pkg/endpoints/metrics" apirequest "k8s.io/apiserver/pkg/endpoints/request" "k8s.io/apiserver/pkg/server/httplog" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) type requestFilterRecordKeyType int @@ -54,22 +55,22 @@ func requestFilterRecordFrom(ctx context.Context) *requestFilterRecord { // TrackStarted measures the timestamp the given handler has started execution // by attaching a handler to the chain. func TrackStarted(handler http.Handler, name string) http.Handler { - return trackStarted(handler, name, utilclock.RealClock{}) + return trackStarted(handler, name, clock.RealClock{}) } // TrackCompleted measures the timestamp the given handler has completed execution and then // it updates the corresponding metric with the filter latency duration. func TrackCompleted(handler http.Handler) http.Handler { - return trackCompleted(handler, utilclock.RealClock{}, func(ctx context.Context, fr *requestFilterRecord, completedAt time.Time) { + return trackCompleted(handler, clock.RealClock{}, func(ctx context.Context, fr *requestFilterRecord, completedAt time.Time) { latency := completedAt.Sub(fr.startedTimestamp) metrics.RecordFilterLatency(ctx, fr.name, latency) if klog.V(3).Enabled() && latency > minFilterLatencyToLog { - httplog.AddInfof(ctx, "%s=%s", fr.name, latency.String()) + httplog.AddKeyValue(ctx, fmt.Sprintf("fl_%s", fr.name), latency.String()) } }) } -func trackStarted(handler http.Handler, name string, clock utilclock.PassiveClock) http.Handler { +func trackStarted(handler http.Handler, name string, clock clock.PassiveClock) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { ctx := r.Context() if fr := requestFilterRecordFrom(ctx); fr != nil { @@ -89,7 +90,7 @@ func trackStarted(handler http.Handler, name string, clock utilclock.PassiveCloc }) } -func trackCompleted(handler http.Handler, clock utilclock.PassiveClock, action func(context.Context, *requestFilterRecord, time.Time)) http.Handler { +func trackCompleted(handler http.Handler, clock clock.PassiveClock, action func(context.Context, *requestFilterRecord, time.Time)) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { // The previous filter has just completed. completedAt := clock.Now() diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filters/audit.go b/vendor/k8s.io/apiserver/pkg/endpoints/filters/audit.go index 02f57909ef..5a97c7d47f 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/filters/audit.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filters/audit.go @@ -30,32 +30,38 @@ import ( utilruntime "k8s.io/apimachinery/pkg/util/runtime" auditinternal "k8s.io/apiserver/pkg/apis/audit" "k8s.io/apiserver/pkg/audit" - "k8s.io/apiserver/pkg/audit/policy" "k8s.io/apiserver/pkg/endpoints/handlers/responsewriters" "k8s.io/apiserver/pkg/endpoints/request" + "k8s.io/apiserver/pkg/endpoints/responsewriter" ) // WithAudit decorates a http.Handler with audit logging information for all the // requests coming to the server. Audit level is decided according to requests' // attributes and audit policy. Logs are emitted to the audit sink to // process events. If sink or audit policy is nil, no decoration takes place. -func WithAudit(handler http.Handler, sink audit.Sink, policy policy.Checker, longRunningCheck request.LongRunningRequestCheck) http.Handler { +func WithAudit(handler http.Handler, sink audit.Sink, policy audit.PolicyRuleEvaluator, longRunningCheck request.LongRunningRequestCheck) http.Handler { if sink == nil || policy == nil { return handler } return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { - req, ev, omitStages, err := createAuditEventAndAttachToContext(req, policy) + auditContext, err := evaluatePolicyAndCreateAuditEvent(req, policy) if err != nil { utilruntime.HandleError(fmt.Errorf("failed to create audit event: %v", err)) responsewriters.InternalError(w, req, errors.New("failed to create audit event")) return } - ctx := req.Context() - if ev == nil || ctx == nil { + + ev := auditContext.Event + if ev == nil || req.Context() == nil { handler.ServeHTTP(w, req) return } + req = req.WithContext(audit.WithAuditContext(req.Context(), auditContext)) + + ctx := req.Context() + omitStages := auditContext.RequestAuditConfig.OmitStages + ev.Stage = auditinternal.StageRequestReceived if processed := processAuditEvent(ctx, sink, ev, omitStages); !processed { audit.ApiserverAuditDroppedCounter.WithContext(ctx).Inc() @@ -112,38 +118,40 @@ func WithAudit(handler http.Handler, sink audit.Sink, policy policy.Checker, lon }) } -// createAuditEventAndAttachToContext is responsible for creating the audit event -// and attaching it to the appropriate request context. It returns: -// - context with audit event attached to it -// - created audit event +// evaluatePolicyAndCreateAuditEvent is responsible for evaluating the audit +// policy configuration applicable to the request and create a new audit +// event that will be written to the API audit log. // - error if anything bad happened -func createAuditEventAndAttachToContext(req *http.Request, policy policy.Checker) (*http.Request, *auditinternal.Event, []auditinternal.Stage, error) { +func evaluatePolicyAndCreateAuditEvent(req *http.Request, policy audit.PolicyRuleEvaluator) (*audit.AuditContext, error) { ctx := req.Context() attribs, err := GetAuthorizerAttributes(ctx) if err != nil { - return req, nil, nil, fmt.Errorf("failed to GetAuthorizerAttributes: %v", err) + return nil, fmt.Errorf("failed to GetAuthorizerAttributes: %v", err) } - level, omitStages := policy.LevelAndStages(attribs) - audit.ObservePolicyLevel(ctx, level) - if level == auditinternal.LevelNone { + ls := policy.EvaluatePolicyRule(attribs) + audit.ObservePolicyLevel(ctx, ls.Level) + if ls.Level == auditinternal.LevelNone { // Don't audit. - return req, nil, nil, nil + return &audit.AuditContext{ + RequestAuditConfig: ls.RequestAuditConfig, + }, nil } requestReceivedTimestamp, ok := request.ReceivedTimestampFrom(ctx) if !ok { requestReceivedTimestamp = time.Now() } - ev, err := audit.NewEventFromRequest(req, requestReceivedTimestamp, level, attribs) + ev, err := audit.NewEventFromRequest(req, requestReceivedTimestamp, ls.Level, attribs) if err != nil { - return req, nil, nil, fmt.Errorf("failed to complete audit event from request: %v", err) + return nil, fmt.Errorf("failed to complete audit event from request: %v", err) } - req = req.WithContext(request.WithAuditEvent(ctx, ev)) - - return req, ev, omitStages, nil + return &audit.AuditContext{ + RequestAuditConfig: ls.RequestAuditConfig, + Event: ev, + }, nil } func processAuditEvent(ctx context.Context, sink audit.Sink, ev *auditinternal.Event, omitStages []auditinternal.Stage) bool { @@ -171,19 +179,11 @@ func decorateResponseWriter(ctx context.Context, responseWriter http.ResponseWri omitStages: omitStages, } - // check if the ResponseWriter we're wrapping is the fancy one we need - // or if the basic is sufficient - //lint:file-ignore SA1019 Keep supporting deprecated http.CloseNotifier - _, cn := responseWriter.(http.CloseNotifier) - _, fl := responseWriter.(http.Flusher) - _, hj := responseWriter.(http.Hijacker) - if cn && fl && hj { - return &fancyResponseWriterDelegator{delegate} - } - return delegate + return responsewriter.WrapForHTTP1Or2(delegate) } var _ http.ResponseWriter = &auditResponseWriter{} +var _ responsewriter.UserProvidedDecorator = &auditResponseWriter{} // auditResponseWriter intercepts WriteHeader, sets it in the event. If the sink is set, it will // create immediately an event (for long running requests). @@ -196,6 +196,10 @@ type auditResponseWriter struct { omitStages []auditinternal.Stage } +func (a *auditResponseWriter) Unwrap() http.ResponseWriter { + return a.ResponseWriter +} + func (a *auditResponseWriter) processCode(code int) { a.once.Do(func() { if a.event.ResponseStatus == nil { @@ -221,28 +225,11 @@ func (a *auditResponseWriter) WriteHeader(code int) { a.ResponseWriter.WriteHeader(code) } -// fancyResponseWriterDelegator implements http.CloseNotifier, http.Flusher and -// http.Hijacker which are needed to make certain http operation (e.g. watch, rsh, etc) -// working. -type fancyResponseWriterDelegator struct { - *auditResponseWriter -} - -func (f *fancyResponseWriterDelegator) CloseNotify() <-chan bool { - return f.ResponseWriter.(http.CloseNotifier).CloseNotify() -} - -func (f *fancyResponseWriterDelegator) Flush() { - f.ResponseWriter.(http.Flusher).Flush() -} - -func (f *fancyResponseWriterDelegator) Hijack() (net.Conn, *bufio.ReadWriter, error) { +func (a *auditResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { // fake a response status before protocol switch happens - f.processCode(http.StatusSwitchingProtocols) + a.processCode(http.StatusSwitchingProtocols) - return f.ResponseWriter.(http.Hijacker).Hijack() + // the outer ResponseWriter object returned by WrapForHTTP1Or2 implements + // http.Hijacker if the inner object (a.ResponseWriter) implements http.Hijacker. + return a.ResponseWriter.(http.Hijacker).Hijack() } - -var _ http.CloseNotifier = &fancyResponseWriterDelegator{} -var _ http.Flusher = &fancyResponseWriterDelegator{} -var _ http.Hijacker = &fancyResponseWriterDelegator{} diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filters/audit_annotations.go b/vendor/k8s.io/apiserver/pkg/endpoints/filters/audit_annotations.go index 22b276991c..6a885711f0 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/filters/audit_annotations.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filters/audit_annotations.go @@ -20,14 +20,13 @@ import ( "net/http" "k8s.io/apiserver/pkg/audit" - "k8s.io/apiserver/pkg/audit/policy" ) // WithAuditAnnotations decorates a http.Handler with a []{key, value} that is merged // with the audit.Event.Annotations map. This allows layers that run before WithAudit // (such as authentication) to assert annotations. // If sink or audit policy is nil, no decoration takes place. -func WithAuditAnnotations(handler http.Handler, sink audit.Sink, policy policy.Checker) http.Handler { +func WithAuditAnnotations(handler http.Handler, sink audit.Sink, policy audit.PolicyRuleEvaluator) http.Handler { // no need to wrap if auditing is disabled if sink == nil || policy == nil { return handler diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filters/authn_audit.go b/vendor/k8s.io/apiserver/pkg/endpoints/filters/authn_audit.go index 2de13f7470..fc9340b10e 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/filters/authn_audit.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filters/authn_audit.go @@ -26,33 +26,36 @@ import ( utilruntime "k8s.io/apimachinery/pkg/util/runtime" auditinternal "k8s.io/apiserver/pkg/apis/audit" "k8s.io/apiserver/pkg/audit" - "k8s.io/apiserver/pkg/audit/policy" "k8s.io/apiserver/pkg/endpoints/handlers/responsewriters" ) // WithFailedAuthenticationAudit decorates a failed http.Handler used in WithAuthentication handler. // It is meant to log only failed authentication requests. -func WithFailedAuthenticationAudit(failedHandler http.Handler, sink audit.Sink, policy policy.Checker) http.Handler { +func WithFailedAuthenticationAudit(failedHandler http.Handler, sink audit.Sink, policy audit.PolicyRuleEvaluator) http.Handler { if sink == nil || policy == nil { return failedHandler } return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { - req, ev, omitStages, err := createAuditEventAndAttachToContext(req, policy) + a, err := evaluatePolicyAndCreateAuditEvent(req, policy) if err != nil { utilruntime.HandleError(fmt.Errorf("failed to create audit event: %v", err)) responsewriters.InternalError(w, req, errors.New("failed to create audit event")) return } + + ev := a.Event if ev == nil { failedHandler.ServeHTTP(w, req) return } + req = req.WithContext(audit.WithAuditContext(req.Context(), a)) + ev.ResponseStatus = &metav1.Status{} ev.ResponseStatus.Message = getAuthMethods(req) ev.Stage = auditinternal.StageResponseStarted - rw := decorateResponseWriter(req.Context(), w, ev, sink, omitStages) + rw := decorateResponseWriter(req.Context(), w, ev, sink, a.RequestAuditConfig.OmitStages) failedHandler.ServeHTTP(rw, req) }) } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filters/authorization.go b/vendor/k8s.io/apiserver/pkg/endpoints/filters/authorization.go index 9683493812..395d9332a1 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/filters/authorization.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filters/authorization.go @@ -49,7 +49,7 @@ func WithAuthorization(handler http.Handler, a authorizer.Authorizer, s runtime. } return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { ctx := req.Context() - ae := request.AuditEventFrom(ctx) + ae := audit.AuditEventFrom(ctx) attributes, err := GetAuthorizerAttributes(ctx) if err != nil { diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filters/impersonation.go b/vendor/k8s.io/apiserver/pkg/endpoints/filters/impersonation.go index d82ad68a7c..1dc1fe4a50 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/filters/impersonation.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filters/impersonation.go @@ -166,7 +166,7 @@ func WithImpersonation(handler http.Handler, a authorizer.Authorizer, s runtime. oldUser, _ := request.UserFrom(ctx) httplog.LogOf(req, w).Addf("%v is acting as %v", oldUser, newUser) - ae := request.AuditEventFrom(ctx) + ae := audit.AuditEventFrom(ctx) audit.LogImpersonatedUser(ae, newUser) // clear all the impersonation headers from the request diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filters/mux_discovery_complete.go b/vendor/k8s.io/apiserver/pkg/endpoints/filters/mux_discovery_complete.go new file mode 100644 index 0000000000..d2fee3b158 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filters/mux_discovery_complete.go @@ -0,0 +1,64 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package filters + +import ( + "context" + "net/http" +) + +type muxAndDiscoveryIncompleteKeyType int + +const ( + // muxAndDiscoveryIncompleteKey is a key under which a protection signal for all requests made before the server have installed all known HTTP paths is stored in the request's context + muxAndDiscoveryIncompleteKey muxAndDiscoveryIncompleteKeyType = iota +) + +// NoMuxAndDiscoveryIncompleteKey checks if the context contains muxAndDiscoveryIncompleteKey. +// The presence of the key indicates the request has been made when the HTTP paths weren't installed. +func NoMuxAndDiscoveryIncompleteKey(ctx context.Context) bool { + muxAndDiscoveryCompleteProtectionKeyValue, _ := ctx.Value(muxAndDiscoveryIncompleteKey).(string) + return len(muxAndDiscoveryCompleteProtectionKeyValue) == 0 +} + +// WithMuxAndDiscoveryComplete puts the muxAndDiscoveryIncompleteKey in the context if a request has been made before muxAndDiscoveryCompleteSignal has been ready. +// Putting the key protect us from returning a 404 response instead of a 503. +// It is especially important for controllers like GC and NS since they act on 404s. +// +// The presence of the key is checked in the NotFoundHandler (staging/src/k8s.io/apiserver/pkg/util/notfoundhandler/not_found_handler.go) +// +// The primary reason this filter exists is to protect from a potential race between the client's requests reaching the NotFoundHandler and the server becoming ready. +// Without the protection key a request could still get a 404 response when the registered signals changed their status just slightly before reaching the new handler. +// In that case, the presence of the key will make the handler return a 503 instead of a 404. +func WithMuxAndDiscoveryComplete(handler http.Handler, muxAndDiscoveryCompleteSignal <-chan struct{}) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + if muxAndDiscoveryCompleteSignal != nil && !isClosed(muxAndDiscoveryCompleteSignal) { + req = req.WithContext(context.WithValue(req.Context(), muxAndDiscoveryIncompleteKey, "MuxAndDiscoveryInstallationNotComplete")) + } + handler.ServeHTTP(w, req) + }) +} + +// isClosed is a convenience function that simply check if the given chan has been closed +func isClosed(ch <-chan struct{}) bool { + select { + case <-ch: + return true + default: + return false + } +} diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filters/request_deadline.go b/vendor/k8s.io/apiserver/pkg/endpoints/filters/request_deadline.go index cc4997968a..84255d525a 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/filters/request_deadline.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filters/request_deadline.go @@ -27,14 +27,13 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" - utilclock "k8s.io/apimachinery/pkg/util/clock" utilruntime "k8s.io/apimachinery/pkg/util/runtime" auditinternal "k8s.io/apiserver/pkg/apis/audit" "k8s.io/apiserver/pkg/audit" - "k8s.io/apiserver/pkg/audit/policy" "k8s.io/apiserver/pkg/endpoints/handlers/responsewriters" "k8s.io/apiserver/pkg/endpoints/request" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) const ( @@ -47,13 +46,13 @@ const ( // auditWrapper provides an http.Handler that audits a failed request. // longRunning returns true if he given request is a long running request. // requestTimeoutMaximum specifies the default request timeout value. -func WithRequestDeadline(handler http.Handler, sink audit.Sink, policy policy.Checker, longRunning request.LongRunningRequestCheck, +func WithRequestDeadline(handler http.Handler, sink audit.Sink, policy audit.PolicyRuleEvaluator, longRunning request.LongRunningRequestCheck, negotiatedSerializer runtime.NegotiatedSerializer, requestTimeoutMaximum time.Duration) http.Handler { - return withRequestDeadline(handler, sink, policy, longRunning, negotiatedSerializer, requestTimeoutMaximum, utilclock.RealClock{}) + return withRequestDeadline(handler, sink, policy, longRunning, negotiatedSerializer, requestTimeoutMaximum, clock.RealClock{}) } -func withRequestDeadline(handler http.Handler, sink audit.Sink, policy policy.Checker, longRunning request.LongRunningRequestCheck, - negotiatedSerializer runtime.NegotiatedSerializer, requestTimeoutMaximum time.Duration, clock utilclock.PassiveClock) http.Handler { +func withRequestDeadline(handler http.Handler, sink audit.Sink, policy audit.PolicyRuleEvaluator, longRunning request.LongRunningRequestCheck, + negotiatedSerializer runtime.NegotiatedSerializer, requestTimeoutMaximum time.Duration, clock clock.PassiveClock) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { ctx := req.Context() @@ -104,29 +103,33 @@ func withRequestDeadline(handler http.Handler, sink audit.Sink, policy policy.Ch // withFailedRequestAudit decorates a failed http.Handler and is used to audit a failed request. // statusErr is used to populate the Message property of ResponseStatus. -func withFailedRequestAudit(failedHandler http.Handler, statusErr *apierrors.StatusError, sink audit.Sink, policy policy.Checker) http.Handler { +func withFailedRequestAudit(failedHandler http.Handler, statusErr *apierrors.StatusError, sink audit.Sink, policy audit.PolicyRuleEvaluator) http.Handler { if sink == nil || policy == nil { return failedHandler } return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { - req, ev, omitStages, err := createAuditEventAndAttachToContext(req, policy) + a, err := evaluatePolicyAndCreateAuditEvent(req, policy) if err != nil { utilruntime.HandleError(fmt.Errorf("failed to create audit event: %v", err)) responsewriters.InternalError(w, req, errors.New("failed to create audit event")) return } + + ev := a.Event if ev == nil { failedHandler.ServeHTTP(w, req) return } + req = req.WithContext(audit.WithAuditContext(req.Context(), a)) + ev.ResponseStatus = &metav1.Status{} ev.Stage = auditinternal.StageResponseStarted if statusErr != nil { ev.ResponseStatus.Message = statusErr.Error() } - rw := decorateResponseWriter(req.Context(), w, ev, sink, omitStages) + rw := decorateResponseWriter(req.Context(), w, ev, sink, a.RequestAuditConfig.OmitStages) failedHandler.ServeHTTP(rw, req) }) } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filters/request_received_time.go b/vendor/k8s.io/apiserver/pkg/endpoints/filters/request_received_time.go index d9e7369f67..576bb3e7a2 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/filters/request_received_time.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filters/request_received_time.go @@ -19,18 +19,18 @@ package filters import ( "net/http" - utilclock "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apiserver/pkg/endpoints/request" + "k8s.io/utils/clock" ) // WithRequestReceivedTimestamp attaches the ReceivedTimestamp (the time the request reached // the apiserver) to the context. func WithRequestReceivedTimestamp(handler http.Handler) http.Handler { - return withRequestReceivedTimestampWithClock(handler, utilclock.RealClock{}) + return withRequestReceivedTimestampWithClock(handler, clock.RealClock{}) } // The clock is passed as a parameter, handy for unit testing. -func withRequestReceivedTimestampWithClock(handler http.Handler, clock utilclock.PassiveClock) http.Handler { +func withRequestReceivedTimestampWithClock(handler http.Handler, clock clock.PassiveClock) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { ctx := req.Context() req = req.WithContext(request.WithReceivedTimestamp(ctx, clock.Now())) diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/filters/webhook_duration.go b/vendor/k8s.io/apiserver/pkg/endpoints/filters/webhook_duration.go new file mode 100644 index 0000000000..e81b340eba --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/endpoints/filters/webhook_duration.go @@ -0,0 +1,33 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package filters + +import ( + "net/http" + + "k8s.io/apiserver/pkg/endpoints/request" +) + +// WithWebhookDuration adds WebhookDuration trackers to the +// context associated with a request. +func WithWebhookDuration(handler http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + ctx := req.Context() + req = req.WithContext(request.WithWebhookDuration(ctx)) + handler.ServeHTTP(w, req) + }) +} diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/create.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/create.go index d5f7c414b0..21f0b02731 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/create.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/create.go @@ -43,6 +43,7 @@ import ( "k8s.io/apiserver/pkg/registry/rest" "k8s.io/apiserver/pkg/util/dryrun" utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/klog/v2" utiltrace "k8s.io/utils/trace" ) @@ -92,8 +93,6 @@ func createHandler(r rest.NamedCreater, scope *RequestScope, admit admission.Int return } - decoder := scope.Serializer.DecoderToVersion(s.Serializer, scope.HubGroupVersion) - body, err := limitedReadBody(req, scope.MaxRequestBodyBytes) if err != nil { scope.err(err, w, req) @@ -116,12 +115,29 @@ func createHandler(r rest.NamedCreater, scope *RequestScope, admit admission.Int defaultGVK := scope.Kind original := r.New() + + validationDirective := fieldValidation(options.FieldValidation) + decodeSerializer := s.Serializer + if validationDirective == metav1.FieldValidationWarn || validationDirective == metav1.FieldValidationStrict { + decodeSerializer = s.StrictSerializer + } + + decoder := scope.Serializer.DecoderToVersion(decodeSerializer, scope.HubGroupVersion) trace.Step("About to convert to expected version") obj, gvk, err := decoder.Decode(body, &defaultGVK, original) if err != nil { - err = transformDecodeError(scope.Typer, err, original, gvk, body) - scope.err(err, w, req) - return + strictError, isStrictError := runtime.AsStrictDecodingError(err) + switch { + case isStrictError && obj != nil && validationDirective == metav1.FieldValidationWarn: + addStrictDecodingWarnings(req.Context(), strictError.Errors()) + case isStrictError && validationDirective == metav1.FieldValidationIgnore: + klog.Warningf("unexpected strict error when field validation is set to ignore") + fallthrough + default: + err = transformDecodeError(scope.Typer, err, original, gvk, body) + scope.err(err, w, req) + return + } } objGV := gvk.GroupVersion() @@ -141,9 +157,9 @@ func createHandler(r rest.NamedCreater, scope *RequestScope, admit admission.Int } ctx = request.WithNamespace(ctx, namespace) - ae := request.AuditEventFrom(ctx) + ae := audit.AuditEventFrom(ctx) admit = admission.WithAudit(admit, ae) - audit.LogRequestObject(ae, obj, objGV, scope.Resource, scope.Subresource, scope.Serializer) + audit.LogRequestObject(req.Context(), obj, objGV, scope.Resource, scope.Subresource, scope.Serializer) userInfo, _ := request.UserFrom(ctx) @@ -195,7 +211,7 @@ func createHandler(r rest.NamedCreater, scope *RequestScope, admit admission.Int code := http.StatusCreated status, ok := result.(*metav1.Status) - if ok && err == nil && status.Code == 0 { + if ok && status.Code == 0 { status.Code = int32(code) } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/delete.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/delete.go index 9b2b9b60a2..05ccd39308 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/delete.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/delete.go @@ -67,7 +67,7 @@ func DeleteResource(r rest.GracefulDeleter, allowsOptions bool, scope *RequestSc defer cancel() ctx = request.WithNamespace(ctx, namespace) - ae := request.AuditEventFrom(ctx) + ae := audit.AuditEventFrom(ctx) admit = admission.WithAudit(admit, ae) outputMediaType, _, err := negotiation.NegotiateOutputMediaType(req, scope.Serializer, scope) @@ -103,9 +103,8 @@ func DeleteResource(r rest.GracefulDeleter, allowsOptions bool, scope *RequestSc } trace.Step("Decoded delete options") - ae := request.AuditEventFrom(ctx) objGV := gvk.GroupVersion() - audit.LogRequestObject(ae, obj, objGV, scope.Resource, scope.Subresource, scope.Serializer) + audit.LogRequestObject(req.Context(), obj, objGV, scope.Resource, scope.Subresource, scope.Serializer) trace.Step("Recorded the audit event") } else { if err := metainternalversionscheme.ParameterCodec.DecodeParameters(req.URL.Query(), scope.MetaGroupVersion, options); err != nil { @@ -144,7 +143,7 @@ func DeleteResource(r rest.GracefulDeleter, allowsOptions bool, scope *RequestSc // that will break existing clients. // Other cases where resource is not instantly deleted are: namespace deletion // and pod graceful deletion. - //lint:ignore SA1019 backwards compatibility + //nolint:staticcheck // SA1019 backwards compatibility //nolint: staticcheck if !wasDeleted && options.OrphanDependents != nil && !*options.OrphanDependents { status = http.StatusAccepted @@ -189,7 +188,7 @@ func DeleteCollection(r rest.CollectionDeleter, checkBody bool, scope *RequestSc defer cancel() ctx = request.WithNamespace(ctx, namespace) - ae := request.AuditEventFrom(ctx) + ae := audit.AuditEventFrom(ctx) outputMediaType, _, err := negotiation.NegotiateOutputMediaType(req, scope.Serializer, scope) if err != nil { @@ -250,9 +249,8 @@ func DeleteCollection(r rest.CollectionDeleter, checkBody bool, scope *RequestSc return } - ae := request.AuditEventFrom(ctx) objGV := gvk.GroupVersion() - audit.LogRequestObject(ae, obj, objGV, scope.Resource, scope.Subresource, scope.Serializer) + audit.LogRequestObject(req.Context(), obj, objGV, scope.Resource, scope.Subresource, scope.Serializer) } else { if err := metainternalversionscheme.ParameterCodec.DecodeParameters(req.URL.Query(), scope.MetaGroupVersion, options); err != nil { err = errors.NewBadRequest(err.Error()) diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/fieldmanager.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/fieldmanager.go index a4023a0e76..dde120d150 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/fieldmanager.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/fieldmanager.go @@ -56,10 +56,18 @@ type Manager interface { // Update is used when the object has already been merged (non-apply // use-case), and simply updates the managed fields in the output // object. + // * `liveObj` is not mutated by this function + // * `newObj` may be mutated by this function + // Returns the new object with managedFields removed, and the object's new + // proposed managedFields separately. Update(liveObj, newObj runtime.Object, managed Managed, manager string) (runtime.Object, Managed, error) // Apply is used when server-side apply is called, as it merges the // object and updates the managed fields. + // * `liveObj` is not mutated by this function + // * `newObj` may be mutated by this function + // Returns the new object with managedFields removed, and the object's new + // proposed managedFields separately. Apply(liveObj, appliedObj runtime.Object, managed Managed, fieldManager string, force bool) (runtime.Object, Managed, error) } @@ -173,7 +181,6 @@ func (f *FieldManager) Update(liveObj, newObj runtime.Object, manager string) (o return newObj, nil } - internal.RemoveObjectManagedFields(liveObj) internal.RemoveObjectManagedFields(newObj) if object, managed, err = f.fieldManager.Update(liveObj, newObj, managed, manager); err != nil { @@ -194,8 +201,15 @@ func (f *FieldManager) UpdateNoErrors(liveObj, newObj runtime.Object, manager st obj, err := f.Update(liveObj, newObj, manager) if err != nil { atMostEverySecond.Do(func() { + ns, name := "unknown", "unknown" + accessor, err := meta.Accessor(newObj) + if err == nil { + ns = accessor.GetNamespace() + name = accessor.GetName() + } + klog.ErrorS(err, "[SHOULD NOT HAPPEN] failed to update managedFields", "VersionKind", - newObj.GetObjectKind().GroupVersionKind()) + newObj.GetObjectKind().GroupVersionKind(), "namespace", ns, "name", name) }) // Explicitly remove managedFields on failure, so that // we can't have garbage in it. @@ -235,8 +249,6 @@ func (f *FieldManager) Apply(liveObj, appliedObj runtime.Object, manager string, return nil, fmt.Errorf("failed to decode managed fields: %v", err) } - internal.RemoveObjectManagedFields(liveObj) - object, managed, err = f.fieldManager.Apply(liveObj, appliedObj, managed, manager, force) if err != nil { if conflicts, ok := err.(merge.Conflicts); ok { diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater.go index 9bee82a854..83f92b8cce 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater.go @@ -21,6 +21,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal" "sigs.k8s.io/structured-merge-diff/v4/fieldpath" ) @@ -80,7 +81,8 @@ func (f *managedFieldsUpdater) Apply(liveObj, appliedObj runtime.Object, managed managed.Times()[fieldManager] = &metav1.Time{Time: time.Now().UTC()} } if object == nil { - object = liveObj + object = liveObj.DeepCopyObject() + internal.RemoveObjectManagedFields(object) } return object, managed, nil } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/structuredmerge.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/structuredmerge.go index 1be9e763af..213988e23c 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/structuredmerge.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/structuredmerge.go @@ -72,30 +72,41 @@ func NewCRDStructuredMergeManager(typeConverter TypeConverter, objectConverter r }, nil } +func objectGVKNN(obj runtime.Object) string { + name := "" + namespace := "" + if accessor, err := meta.Accessor(obj); err == nil { + name = accessor.GetName() + namespace = accessor.GetNamespace() + } + + return fmt.Sprintf("%v/%v; %v", namespace, name, obj.GetObjectKind().GroupVersionKind()) +} + // Update implements Manager. func (f *structuredMergeManager) Update(liveObj, newObj runtime.Object, managed Managed, manager string) (runtime.Object, Managed, error) { newObjVersioned, err := f.toVersioned(newObj) if err != nil { - return nil, nil, fmt.Errorf("failed to convert new object to proper version: %v (from %v to %v)", err, newObj.GetObjectKind().GroupVersionKind(), f.groupVersion) + return nil, nil, fmt.Errorf("failed to convert new object (%v) to proper version (%v): %v", objectGVKNN(newObj), f.groupVersion, err) } liveObjVersioned, err := f.toVersioned(liveObj) if err != nil { - return nil, nil, fmt.Errorf("failed to convert live object to proper version: %v", err) + return nil, nil, fmt.Errorf("failed to convert live object (%v) to proper version: %v", objectGVKNN(liveObj), err) } newObjTyped, err := f.typeConverter.ObjectToTyped(newObjVersioned) if err != nil { - return nil, nil, fmt.Errorf("failed to convert new object (%v) to smd typed: %v", newObjVersioned.GetObjectKind().GroupVersionKind(), err) + return nil, nil, fmt.Errorf("failed to convert new object (%v) to smd typed: %v", objectGVKNN(newObjVersioned), err) } liveObjTyped, err := f.typeConverter.ObjectToTyped(liveObjVersioned) if err != nil { - return nil, nil, fmt.Errorf("failed to convert live object (%v) to smd typed: %v", liveObjVersioned.GetObjectKind().GroupVersionKind(), err) + return nil, nil, fmt.Errorf("failed to convert live object (%v) to smd typed: %v", objectGVKNN(liveObjVersioned), err) } apiVersion := fieldpath.APIVersion(f.groupVersion.String()) // TODO(apelisse) use the first return value when unions are implemented _, managedFields, err := f.updater.Update(liveObjTyped, newObjTyped, apiVersion, managed.Fields(), manager) if err != nil { - return nil, nil, fmt.Errorf("failed to update ManagedFields: %v", err) + return nil, nil, fmt.Errorf("failed to update ManagedFields (%v): %v", objectGVKNN(newObjVersioned), err) } managed = internal.NewManaged(managedFields, managed.Times()) @@ -123,16 +134,16 @@ func (f *structuredMergeManager) Apply(liveObj, patchObj runtime.Object, managed liveObjVersioned, err := f.toVersioned(liveObj) if err != nil { - return nil, nil, fmt.Errorf("failed to convert live object to proper version: %v", err) + return nil, nil, fmt.Errorf("failed to convert live object (%v) to proper version: %v", objectGVKNN(liveObj), err) } patchObjTyped, err := f.typeConverter.ObjectToTyped(patchObj) if err != nil { - return nil, nil, fmt.Errorf("failed to create typed patch object: %v", err) + return nil, nil, fmt.Errorf("failed to create typed patch object (%v): %v", objectGVKNN(patchObj), err) } liveObjTyped, err := f.typeConverter.ObjectToTyped(liveObjVersioned) if err != nil { - return nil, nil, fmt.Errorf("failed to create typed live object: %v", err) + return nil, nil, fmt.Errorf("failed to create typed live object (%v): %v", objectGVKNN(liveObjVersioned), err) } apiVersion := fieldpath.APIVersion(f.groupVersion.String()) @@ -148,18 +159,18 @@ func (f *structuredMergeManager) Apply(liveObj, patchObj runtime.Object, managed newObj, err := f.typeConverter.TypedToObject(newObjTyped) if err != nil { - return nil, nil, fmt.Errorf("failed to convert new typed object to object: %v", err) + return nil, nil, fmt.Errorf("failed to convert new typed object (%v) to object: %v", objectGVKNN(patchObj), err) } newObjVersioned, err := f.toVersioned(newObj) if err != nil { - return nil, nil, fmt.Errorf("failed to convert new object to proper version: %v", err) + return nil, nil, fmt.Errorf("failed to convert new object (%v) to proper version: %v", objectGVKNN(patchObj), err) } f.objectDefaulter.Default(newObjVersioned) newObjUnversioned, err := f.toUnversioned(newObjVersioned) if err != nil { - return nil, nil, fmt.Errorf("failed to convert to unversioned: %v", err) + return nil, nil, fmt.Errorf("failed to convert to unversioned (%v): %v", objectGVKNN(patchObj), err) } return newObjUnversioned, managed, nil } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/typeconverter.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/typeconverter.go index 8bb2f0c9eb..fc40546f10 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/typeconverter.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/typeconverter.go @@ -22,7 +22,7 @@ import ( "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" - "k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal" + "k8s.io/apimachinery/pkg/util/managedfields" "k8s.io/kube-openapi/pkg/util/proto" "sigs.k8s.io/structured-merge-diff/v4/typed" "sigs.k8s.io/structured-merge-diff/v4/value" @@ -65,7 +65,7 @@ func (DeducedTypeConverter) TypedToObject(value *typed.TypedValue) (runtime.Obje } type typeConverter struct { - parser *internal.GvkParser + parser *managedfields.GvkParser } var _ TypeConverter = &typeConverter{} @@ -74,7 +74,7 @@ var _ TypeConverter = &typeConverter{} // will automatically find the proper version of the object, and the // corresponding schema information. func NewTypeConverter(models proto.Models, preserveUnknownFields bool) (TypeConverter, error) { - parser, err := internal.NewGVKParser(models, preserveUnknownFields) + parser, err := managedfields.NewGVKParser(models, preserveUnknownFields) if err != nil { return nil, err } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/namer.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/namer.go index 755da22eea..2eb0c174dc 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/namer.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/namer.go @@ -76,15 +76,11 @@ func (n ContextBasedNaming) Name(req *http.Request) (namespace, name string, err if !ok { return "", "", fmt.Errorf("missing requestInfo") } - ns, err := n.Namespace(req) - if err != nil { - return "", "", err - } if len(requestInfo.Name) == 0 { return "", "", errEmptyName } - return ns, requestInfo.Name, nil + return requestInfo.Namespace, requestInfo.Name, nil } // fastURLPathEncode encodes the provided path as a URL path diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/patch.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/patch.go index 1abcccaa17..6803baaa60 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/patch.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/patch.go @@ -23,6 +23,8 @@ import ( "strings" "time" + kjson "sigs.k8s.io/json" + jsonpatch "github.com/evanphx/json-patch" "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" @@ -33,7 +35,6 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/json" "k8s.io/apimachinery/pkg/util/mergepatch" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/strategicpatch" @@ -123,10 +124,10 @@ func PatchResource(r rest.Patcher, scope *RequestScope, admit admission.Interfac } options.TypeMeta.SetGroupVersionKind(metav1.SchemeGroupVersion.WithKind("PatchOptions")) - ae := request.AuditEventFrom(ctx) + ae := audit.AuditEventFrom(ctx) admit = admission.WithAudit(admit, ae) - audit.LogRequestPatch(ae, patchBytes) + audit.LogRequestPatch(req.Context(), patchBytes) trace.Step("Recorded the audit event") baseContentType := runtime.ContentTypeJSON @@ -140,9 +141,15 @@ func PatchResource(r rest.Patcher, scope *RequestScope, admit admission.Interfac } gv := scope.Kind.GroupVersion() + validationDirective := fieldValidation(options.FieldValidation) + decodeSerializer := s.Serializer + if validationDirective == metav1.FieldValidationWarn || validationDirective == metav1.FieldValidationStrict { + decodeSerializer = s.StrictSerializer + } + codec := runtime.NewCodec( scope.Serializer.EncoderForVersion(s.Serializer, gv), - scope.Serializer.DecoderToVersion(s.Serializer, scope.HubGroupVersion), + scope.Serializer.DecoderToVersion(decodeSerializer, scope.HubGroupVersion), ) userInfo, _ := request.UserFrom(ctx) @@ -190,15 +197,16 @@ func PatchResource(r rest.Patcher, scope *RequestScope, admit admission.Interfac } p := patcher{ - namer: scope.Namer, - creater: scope.Creater, - defaulter: scope.Defaulter, - typer: scope.Typer, - unsafeConvertor: scope.UnsafeConvertor, - kind: scope.Kind, - resource: scope.Resource, - subresource: scope.Subresource, - dryRun: dryrun.IsDryRun(options.DryRun), + namer: scope.Namer, + creater: scope.Creater, + defaulter: scope.Defaulter, + typer: scope.Typer, + unsafeConvertor: scope.UnsafeConvertor, + kind: scope.Kind, + resource: scope.Resource, + subresource: scope.Subresource, + dryRun: dryrun.IsDryRun(options.DryRun), + validationDirective: validationDirective, objectInterfaces: scope, @@ -251,15 +259,16 @@ type mutateObjectUpdateFunc func(ctx context.Context, obj, old runtime.Object) e // moved into this type. type patcher struct { // Pieces of RequestScope - namer ScopeNamer - creater runtime.ObjectCreater - defaulter runtime.ObjectDefaulter - typer runtime.ObjectTyper - unsafeConvertor runtime.ObjectConvertor - resource schema.GroupVersionResource - kind schema.GroupVersionKind - subresource string - dryRun bool + namer ScopeNamer + creater runtime.ObjectCreater + defaulter runtime.ObjectDefaulter + typer runtime.ObjectTyper + unsafeConvertor runtime.ObjectConvertor + resource schema.GroupVersionResource + kind schema.GroupVersionKind + subresource string + dryRun bool + validationDirective string objectInterfaces admission.ObjectInterfaces @@ -291,8 +300,8 @@ type patcher struct { } type patchMechanism interface { - applyPatchToCurrentObject(currentObject runtime.Object) (runtime.Object, error) - createNewObject() (runtime.Object, error) + applyPatchToCurrentObject(requextContext context.Context, currentObject runtime.Object) (runtime.Object, error) + createNewObject(requestContext context.Context) (runtime.Object, error) } type jsonPatcher struct { @@ -301,7 +310,7 @@ type jsonPatcher struct { fieldManager *fieldmanager.FieldManager } -func (p *jsonPatcher) applyPatchToCurrentObject(currentObject runtime.Object) (runtime.Object, error) { +func (p *jsonPatcher) applyPatchToCurrentObject(requestContext context.Context, currentObject runtime.Object) (runtime.Object, error) { // Encode will convert & return a versioned object in JSON. currentObjJS, err := runtime.Encode(p.codec, currentObject) if err != nil { @@ -309,7 +318,7 @@ func (p *jsonPatcher) applyPatchToCurrentObject(currentObject runtime.Object) (r } // Apply the patch. - patchedObjJS, err := p.applyJSPatch(currentObjJS) + patchedObjJS, appliedStrictErrs, err := p.applyJSPatch(currentObjJS) if err != nil { return nil, err } @@ -317,9 +326,32 @@ func (p *jsonPatcher) applyPatchToCurrentObject(currentObject runtime.Object) (r // Construct the resulting typed, unversioned object. objToUpdate := p.restPatcher.New() if err := runtime.DecodeInto(p.codec, patchedObjJS, objToUpdate); err != nil { - return nil, errors.NewInvalid(schema.GroupKind{}, "", field.ErrorList{ - field.Invalid(field.NewPath("patch"), string(patchedObjJS), err.Error()), - }) + strictError, isStrictError := runtime.AsStrictDecodingError(err) + switch { + case !isStrictError: + // disregard any appliedStrictErrs, because it's an incomplete + // list of strict errors given that we don't know what fields were + // unknown because DecodeInto failed. Non-strict errors trump in this case. + return nil, errors.NewInvalid(schema.GroupKind{}, "", field.ErrorList{ + field.Invalid(field.NewPath("patch"), string(patchedObjJS), err.Error()), + }) + case p.validationDirective == metav1.FieldValidationWarn: + addStrictDecodingWarnings(requestContext, append(appliedStrictErrs, strictError.Errors()...)) + default: + strictDecodingError := runtime.NewStrictDecodingError(append(appliedStrictErrs, strictError.Errors()...)) + return nil, errors.NewInvalid(schema.GroupKind{}, "", field.ErrorList{ + field.Invalid(field.NewPath("patch"), string(patchedObjJS), strictDecodingError.Error()), + }) + } + } else if len(appliedStrictErrs) > 0 { + switch { + case p.validationDirective == metav1.FieldValidationWarn: + addStrictDecodingWarnings(requestContext, appliedStrictErrs) + default: + return nil, errors.NewInvalid(schema.GroupKind{}, "", field.ErrorList{ + field.Invalid(field.NewPath("patch"), string(patchedObjJS), runtime.NewStrictDecodingError(appliedStrictErrs).Error()), + }) + } } if p.fieldManager != nil { @@ -328,52 +360,65 @@ func (p *jsonPatcher) applyPatchToCurrentObject(currentObject runtime.Object) (r return objToUpdate, nil } -func (p *jsonPatcher) createNewObject() (runtime.Object, error) { +func (p *jsonPatcher) createNewObject(_ context.Context) (runtime.Object, error) { return nil, errors.NewNotFound(p.resource.GroupResource(), p.name) } +type jsonPatchOp struct { + Op string `json:"op"` + Path string `json:"path"` + From string `json:"from"` + Value interface{} `json:"value"` +} + // applyJSPatch applies the patch. Input and output objects must both have // the external version, since that is what the patch must have been constructed against. -func (p *jsonPatcher) applyJSPatch(versionedJS []byte) (patchedJS []byte, retErr error) { +func (p *jsonPatcher) applyJSPatch(versionedJS []byte) (patchedJS []byte, strictErrors []error, retErr error) { switch p.patchType { case types.JSONPatchType: - // sanity check potentially abusive patches - // TODO(liggitt): drop this once golang json parser limits stack depth (https://github.com/golang/go/issues/31789) - if len(p.patchBytes) > 1024*1024 { - v := []interface{}{} - if err := json.Unmarshal(p.patchBytes, &v); err != nil { - return nil, errors.NewBadRequest(fmt.Sprintf("error decoding patch: %v", err)) + if p.validationDirective == metav1.FieldValidationStrict || p.validationDirective == metav1.FieldValidationWarn { + var v []jsonPatchOp + var err error + if strictErrors, err = kjson.UnmarshalStrict(p.patchBytes, &v); err != nil { + return nil, nil, errors.NewBadRequest(fmt.Sprintf("error decoding patch: %v", err)) + } + for i, e := range strictErrors { + strictErrors[i] = fmt.Errorf("json patch %v", e) } } patchObj, err := jsonpatch.DecodePatch(p.patchBytes) if err != nil { - return nil, errors.NewBadRequest(err.Error()) + return nil, nil, errors.NewBadRequest(err.Error()) } if len(patchObj) > maxJSONPatchOperations { - return nil, errors.NewRequestEntityTooLargeError( + return nil, nil, errors.NewRequestEntityTooLargeError( fmt.Sprintf("The allowed maximum operations in a JSON patch is %d, got %d", maxJSONPatchOperations, len(patchObj))) } patchedJS, err := patchObj.Apply(versionedJS) if err != nil { - return nil, errors.NewGenericServerResponse(http.StatusUnprocessableEntity, "", schema.GroupResource{}, "", err.Error(), 0, false) + return nil, nil, errors.NewGenericServerResponse(http.StatusUnprocessableEntity, "", schema.GroupResource{}, "", err.Error(), 0, false) } - return patchedJS, nil + return patchedJS, strictErrors, nil case types.MergePatchType: - // sanity check potentially abusive patches - // TODO(liggitt): drop this once golang json parser limits stack depth (https://github.com/golang/go/issues/31789) - if len(p.patchBytes) > 1024*1024 { + if p.validationDirective == metav1.FieldValidationStrict || p.validationDirective == metav1.FieldValidationWarn { v := map[string]interface{}{} - if err := json.Unmarshal(p.patchBytes, &v); err != nil { - return nil, errors.NewBadRequest(fmt.Sprintf("error decoding patch: %v", err)) + var err error + strictErrors, err = kjson.UnmarshalStrict(p.patchBytes, &v) + if err != nil { + return nil, nil, errors.NewBadRequest(fmt.Sprintf("error decoding patch: %v", err)) } } - return jsonpatch.MergePatch(versionedJS, p.patchBytes) + patchedJS, retErr = jsonpatch.MergePatch(versionedJS, p.patchBytes) + if retErr == jsonpatch.ErrBadJSONPatch { + return nil, nil, errors.NewBadRequest(retErr.Error()) + } + return patchedJS, strictErrors, retErr default: // only here as a safety net - go-restful filters content-type - return nil, fmt.Errorf("unknown Content-Type header for patch: %v", p.patchType) + return nil, nil, fmt.Errorf("unknown Content-Type header for patch: %v", p.patchType) } } @@ -385,7 +430,7 @@ type smpPatcher struct { fieldManager *fieldmanager.FieldManager } -func (p *smpPatcher) applyPatchToCurrentObject(currentObject runtime.Object) (runtime.Object, error) { +func (p *smpPatcher) applyPatchToCurrentObject(requestContext context.Context, currentObject runtime.Object) (runtime.Object, error) { // Since the patch is applied on versioned objects, we need to convert the // current object to versioned representation first. currentVersionedObject, err := p.unsafeConvertor.ConvertToVersion(currentObject, p.kind.GroupVersion()) @@ -396,7 +441,7 @@ func (p *smpPatcher) applyPatchToCurrentObject(currentObject runtime.Object) (ru if err != nil { return nil, err } - if err := strategicPatchObject(p.defaulter, currentVersionedObject, p.patchBytes, versionedObjToUpdate, p.schemaReferenceObj); err != nil { + if err := strategicPatchObject(requestContext, p.defaulter, currentVersionedObject, p.patchBytes, versionedObjToUpdate, p.schemaReferenceObj, p.validationDirective); err != nil { return nil, err } // Convert the object back to the hub version @@ -411,20 +456,21 @@ func (p *smpPatcher) applyPatchToCurrentObject(currentObject runtime.Object) (ru return newObj, nil } -func (p *smpPatcher) createNewObject() (runtime.Object, error) { +func (p *smpPatcher) createNewObject(_ context.Context) (runtime.Object, error) { return nil, errors.NewNotFound(p.resource.GroupResource(), p.name) } type applyPatcher struct { - patch []byte - options *metav1.PatchOptions - creater runtime.ObjectCreater - kind schema.GroupVersionKind - fieldManager *fieldmanager.FieldManager - userAgent string + patch []byte + options *metav1.PatchOptions + creater runtime.ObjectCreater + kind schema.GroupVersionKind + fieldManager *fieldmanager.FieldManager + userAgent string + validationDirective string } -func (p *applyPatcher) applyPatchToCurrentObject(obj runtime.Object) (runtime.Object, error) { +func (p *applyPatcher) applyPatchToCurrentObject(requestContext context.Context, obj runtime.Object) (runtime.Object, error) { force := false if p.options.Force != nil { force = *p.options.Force @@ -438,15 +484,30 @@ func (p *applyPatcher) applyPatchToCurrentObject(obj runtime.Object) (runtime.Ob return nil, errors.NewBadRequest(fmt.Sprintf("error decoding YAML: %v", err)) } - return p.fieldManager.Apply(obj, patchObj, p.options.FieldManager, force) + obj, err := p.fieldManager.Apply(obj, patchObj, p.options.FieldManager, force) + if err != nil { + return obj, err + } + + // TODO: spawn something to track deciding whether a fieldValidation=Strict + // fatal error should return before an error from the apply operation + if p.validationDirective == metav1.FieldValidationStrict || p.validationDirective == metav1.FieldValidationWarn { + if err := yaml.UnmarshalStrict(p.patch, &map[string]interface{}{}); err != nil { + if p.validationDirective == metav1.FieldValidationStrict { + return nil, errors.NewBadRequest(fmt.Sprintf("error strict decoding YAML: %v", err)) + } + addStrictDecodingWarnings(requestContext, []error{err}) + } + } + return obj, nil } -func (p *applyPatcher) createNewObject() (runtime.Object, error) { +func (p *applyPatcher) createNewObject(requestContext context.Context) (runtime.Object, error) { obj, err := p.creater.New(p.kind) if err != nil { return nil, fmt.Errorf("failed to create new object: %v", err) } - return p.applyPatchToCurrentObject(obj) + return p.applyPatchToCurrentObject(requestContext, obj) } // strategicPatchObject applies a strategic merge patch of to @@ -455,11 +516,13 @@ func (p *applyPatcher) createNewObject() (runtime.Object, error) { // and . // NOTE: Both and are supposed to be versioned. func strategicPatchObject( + requestContext context.Context, defaulter runtime.ObjectDefaulter, originalObject runtime.Object, patchBytes []byte, objToUpdate runtime.Object, schemaReferenceObj runtime.Object, + validationDirective string, ) error { originalObjMap, err := runtime.DefaultUnstructuredConverter.ToUnstructured(originalObject) if err != nil { @@ -467,11 +530,19 @@ func strategicPatchObject( } patchMap := make(map[string]interface{}) - if err := json.Unmarshal(patchBytes, &patchMap); err != nil { - return errors.NewBadRequest(err.Error()) + var strictErrs []error + if validationDirective == metav1.FieldValidationWarn || validationDirective == metav1.FieldValidationStrict { + strictErrs, err = kjson.UnmarshalStrict(patchBytes, &patchMap) + if err != nil { + return errors.NewBadRequest(err.Error()) + } + } else { + if err = kjson.UnmarshalCaseSensitivePreserveInts(patchBytes, &patchMap); err != nil { + return errors.NewBadRequest(err.Error()) + } } - if err := applyPatchToObject(defaulter, originalObjMap, patchMap, objToUpdate, schemaReferenceObj); err != nil { + if err := applyPatchToObject(requestContext, defaulter, originalObjMap, patchMap, objToUpdate, schemaReferenceObj, strictErrs, validationDirective); err != nil { return err } return nil @@ -480,16 +551,16 @@ func strategicPatchObject( // applyPatch is called every time GuaranteedUpdate asks for the updated object, // and is given the currently persisted object as input. // TODO: rename this function because the name implies it is related to applyPatcher -func (p *patcher) applyPatch(_ context.Context, _, currentObject runtime.Object) (objToUpdate runtime.Object, patchErr error) { +func (p *patcher) applyPatch(ctx context.Context, _, currentObject runtime.Object) (objToUpdate runtime.Object, patchErr error) { // Make sure we actually have a persisted currentObject p.trace.Step("About to apply patch") currentObjectHasUID, err := hasUID(currentObject) if err != nil { return nil, err } else if !currentObjectHasUID { - objToUpdate, patchErr = p.mechanism.createNewObject() + objToUpdate, patchErr = p.mechanism.createNewObject(ctx) } else { - objToUpdate, patchErr = p.mechanism.applyPatchToCurrentObject(currentObject) + objToUpdate, patchErr = p.mechanism.applyPatchToCurrentObject(ctx, currentObject) } if patchErr != nil { @@ -565,12 +636,13 @@ func (p *patcher) patchResource(ctx context.Context, scope *RequestScope) (runti // this case is unreachable if ServerSideApply is not enabled because we will have already rejected the content type case types.ApplyPatchType: p.mechanism = &applyPatcher{ - fieldManager: scope.FieldManager, - patch: p.patchBytes, - options: p.options, - creater: p.creater, - kind: p.kind, - userAgent: p.userAgent, + fieldManager: scope.FieldManager, + patch: p.patchBytes, + options: p.options, + creater: p.creater, + kind: p.kind, + userAgent: p.userAgent, + validationDirective: p.validationDirective, } p.forceAllowCreate = true default: @@ -592,6 +664,7 @@ func (p *patcher) patchResource(ctx context.Context, scope *RequestScope) (runti return updateObject, updateErr } result, err := finisher.FinishRequest(ctx, func() (runtime.Object, error) { + result, err := requestFunc() // If the object wasn't committed to storage because it's serialized size was too large, // it is safe to remove managedFields (which can be large) and try again. @@ -618,11 +691,14 @@ func (p *patcher) patchResource(ctx context.Context, scope *RequestScope) (runti // and stores the result in . // NOTE: must be a versioned object. func applyPatchToObject( + requestContext context.Context, defaulter runtime.ObjectDefaulter, originalMap map[string]interface{}, patchMap map[string]interface{}, objToUpdate runtime.Object, schemaReferenceObj runtime.Object, + strictErrs []error, + validationDirective string, ) error { patchedObjMap, err := strategicpatch.StrategicMergeMapPatch(originalMap, patchMap, schemaReferenceObj) if err != nil { @@ -630,11 +706,38 @@ func applyPatchToObject( } // Rather than serialize the patched map to JSON, then decode it to an object, we go directly from a map to an object - if err := runtime.DefaultUnstructuredConverter.FromUnstructured(patchedObjMap, objToUpdate); err != nil { - return errors.NewInvalid(schema.GroupKind{}, "", field.ErrorList{ - field.Invalid(field.NewPath("patch"), fmt.Sprintf("%+v", patchMap), err.Error()), - }) + converter := runtime.DefaultUnstructuredConverter + returnUnknownFields := validationDirective == metav1.FieldValidationWarn || validationDirective == metav1.FieldValidationStrict + if err := converter.FromUnstructuredWithValidation(patchedObjMap, objToUpdate, returnUnknownFields); err != nil { + strictError, isStrictError := runtime.AsStrictDecodingError(err) + switch { + case !isStrictError: + // disregard any sttrictErrs, because it's an incomplete + // list of strict errors given that we don't know what fields were + // unknown because StrategicMergeMapPatch failed. + // Non-strict errors trump in this case. + return errors.NewInvalid(schema.GroupKind{}, "", field.ErrorList{ + field.Invalid(field.NewPath("patch"), fmt.Sprintf("%+v", patchMap), err.Error()), + }) + case validationDirective == metav1.FieldValidationWarn: + addStrictDecodingWarnings(requestContext, append(strictErrs, strictError.Errors()...)) + default: + strictDecodingError := runtime.NewStrictDecodingError(append(strictErrs, strictError.Errors()...)) + return errors.NewInvalid(schema.GroupKind{}, "", field.ErrorList{ + field.Invalid(field.NewPath("patch"), fmt.Sprintf("%+v", patchMap), strictDecodingError.Error()), + }) + } + } else if len(strictErrs) > 0 { + switch { + case validationDirective == metav1.FieldValidationWarn: + addStrictDecodingWarnings(requestContext, strictErrs) + default: + return errors.NewInvalid(schema.GroupKind{}, "", field.ErrorList{ + field.Invalid(field.NewPath("patch"), fmt.Sprintf("%+v", patchMap), runtime.NewStrictDecodingError(strictErrs).Error()), + }) + } } + // Decoding from JSON to a versioned object would apply defaults, so we do the same here defaulter.Default(objToUpdate) @@ -659,8 +762,9 @@ func patchToUpdateOptions(po *metav1.PatchOptions) *metav1.UpdateOptions { return nil } uo := &metav1.UpdateOptions{ - DryRun: po.DryRun, - FieldManager: po.FieldManager, + DryRun: po.DryRun, + FieldManager: po.FieldManager, + FieldValidation: po.FieldValidation, } uo.TypeMeta.SetGroupVersionKind(metav1.SchemeGroupVersion.WithKind("UpdateOptions")) return uo @@ -672,8 +776,9 @@ func patchToCreateOptions(po *metav1.PatchOptions) *metav1.CreateOptions { return nil } co := &metav1.CreateOptions{ - DryRun: po.DryRun, - FieldManager: po.FieldManager, + DryRun: po.DryRun, + FieldManager: po.FieldManager, + FieldValidation: po.FieldValidation, } co.TypeMeta.SetGroupVersionKind(metav1.SchemeGroupVersion.WithKind("CreateOptions")) return co diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/responsewriters/writers.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/responsewriters/writers.go index 16e16c3537..0e4b98b839 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/responsewriters/writers.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/responsewriters/writers.go @@ -201,7 +201,8 @@ func (w *deferredResponseWriter) Write(p []byte) (n int, err error) { w.trace.Step("Write call finished", utiltrace.Field{"writer", fmt.Sprintf("%T", w.w)}, utiltrace.Field{"size", len(p)}, - utiltrace.Field{"firstWrite", firstWrite}) + utiltrace.Field{"firstWrite", firstWrite}, + utiltrace.Field{"err", err}) }() } if w.hasWritten { @@ -267,9 +268,7 @@ func WriteObjectNegotiated(s runtime.NegotiatedSerializer, restrictions negotiat return } - if ae := request.AuditEventFrom(req.Context()); ae != nil { - audit.LogResponseObject(ae, object, gv, s) - } + audit.LogResponseObject(req.Context(), object, gv, s) encoder := s.EncoderForVersion(serializer.Serializer, gv) SerializeObject(serializer.MediaType, encoder, w, req, statusCode, object) diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/rest.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/rest.go index 4c2e63e10c..c5fd95e894 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/rest.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/rest.go @@ -39,6 +39,7 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/types" "k8s.io/apiserver/pkg/admission" + "k8s.io/apiserver/pkg/audit" "k8s.io/apiserver/pkg/authorization/authorizer" "k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager" "k8s.io/apiserver/pkg/endpoints/handlers/responsewriters" @@ -63,6 +64,10 @@ const ( // NOTE: For CREATE and UPDATE requests the API server dedups both before and after mutating admission. // For PATCH request the API server only dedups after mutating admission. DuplicateOwnerReferencesAfterMutatingAdmissionWarningFormat = ".metadata.ownerReferences contains duplicate entries after mutating admission happens; API server dedups owner references in 1.20+, and may reject such requests as early as 1.24; please fix your requests; duplicate UID(s) observed: %v" + // shortPrefix is one possible beginning of yaml unmarshal strict errors. + shortPrefix = "yaml: unmarshal errors:\n" + // longPrefix is the other possible beginning of yaml unmarshal strict errors. + longPrefix = "error converting YAML to JSON: yaml: unmarshal errors:\n" ) // RequestScope encapsulates common fields across all RESTful handler methods. @@ -187,7 +192,7 @@ func ConnectResource(connecter rest.Connecter, scope *RequestScope, admit admiss } ctx := req.Context() ctx = request.WithNamespace(ctx, namespace) - ae := request.AuditEventFrom(ctx) + ae := audit.AuditEventFrom(ctx) admit = admission.WithAudit(admit, ae) opts, subpath, subpathKey := connecter.NewConnectOptions() @@ -456,6 +461,53 @@ func isDryRun(url *url.URL) bool { return len(url.Query()["dryRun"]) != 0 } +// fieldValidation checks that the field validation feature is enabled +// and returns a valid directive of either +// - Ignore (default when feature is disabled) +// - Warn (default when feature is enabled) +// - Strict +func fieldValidation(directive string) string { + if !utilfeature.DefaultFeatureGate.Enabled(features.ServerSideFieldValidation) { + return metav1.FieldValidationIgnore + } + if directive == "" { + return metav1.FieldValidationWarn + } + return directive +} + +// parseYAMLWarnings takes the strict decoding errors from the yaml decoder's output +// and parses each individual warnings, or leaves the warning as is if +// it does not look like a yaml strict decoding error. +func parseYAMLWarnings(errString string) []string { + var trimmedString string + if trimmedShortString := strings.TrimPrefix(errString, shortPrefix); len(trimmedShortString) < len(errString) { + trimmedString = trimmedShortString + } else if trimmedLongString := strings.TrimPrefix(errString, longPrefix); len(trimmedLongString) < len(errString) { + trimmedString = trimmedLongString + } else { + // not a yaml error, return as-is + return []string{errString} + } + + splitStrings := strings.Split(trimmedString, "\n") + for i, s := range splitStrings { + splitStrings[i] = strings.TrimSpace(s) + } + return splitStrings +} + +// addStrictDecodingWarnings confirms that the error is a strict decoding error +// and if so adds a warning for each strict decoding violation. +func addStrictDecodingWarnings(requestContext context.Context, errs []error) { + for _, e := range errs { + yamlWarnings := parseYAMLWarnings(e.Error()) + for _, w := range yamlWarnings { + warning.AddWarning(requestContext, "", w) + } + } +} + type etcdError interface { Code() grpccodes.Code Error() string diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/update.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/update.go index e0dbd54a54..96eda0b9c8 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/update.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/update.go @@ -41,6 +41,7 @@ import ( "k8s.io/apiserver/pkg/registry/rest" "k8s.io/apiserver/pkg/util/dryrun" utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/klog/v2" utiltrace "k8s.io/utils/trace" ) @@ -102,14 +103,30 @@ func UpdateResource(r rest.Updater, scope *RequestScope, admit admission.Interfa defaultGVK := scope.Kind original := r.New() + validationDirective := fieldValidation(options.FieldValidation) + decodeSerializer := s.Serializer + if validationDirective == metav1.FieldValidationWarn || validationDirective == metav1.FieldValidationStrict { + decodeSerializer = s.StrictSerializer + } + + decoder := scope.Serializer.DecoderToVersion(decodeSerializer, scope.HubGroupVersion) trace.Step("About to convert to expected version") - decoder := scope.Serializer.DecoderToVersion(s.Serializer, scope.HubGroupVersion) obj, gvk, err := decoder.Decode(body, &defaultGVK, original) if err != nil { - err = transformDecodeError(scope.Typer, err, original, gvk, body) - scope.err(err, w, req) - return + strictError, isStrictError := runtime.AsStrictDecodingError(err) + switch { + case isStrictError && obj != nil && validationDirective == metav1.FieldValidationWarn: + addStrictDecodingWarnings(req.Context(), strictError.Errors()) + case isStrictError && validationDirective == metav1.FieldValidationIgnore: + klog.Warningf("unexpected strict error when field validation is set to ignore") + fallthrough + default: + err = transformDecodeError(scope.Typer, err, original, gvk, body) + scope.err(err, w, req) + return + } } + objGV := gvk.GroupVersion() if !scope.AcceptsGroupVersion(objGV) { err = errors.NewBadRequest(fmt.Sprintf("the API version in the data (%s) does not match the expected API version (%s)", objGV, defaultGVK.GroupVersion())) @@ -118,8 +135,8 @@ func UpdateResource(r rest.Updater, scope *RequestScope, admit admission.Interfa } trace.Step("Conversion done") - ae := request.AuditEventFrom(ctx) - audit.LogRequestObject(ae, obj, objGV, scope.Resource, scope.Subresource, scope.Serializer) + ae := audit.AuditEventFrom(ctx) + audit.LogRequestObject(req.Context(), obj, objGV, scope.Resource, scope.Subresource, scope.Serializer) admit = admission.WithAudit(admit, ae) if err := checkName(obj, name, namespace, scope.Namer); err != nil { @@ -266,8 +283,9 @@ func updateToCreateOptions(uo *metav1.UpdateOptions) *metav1.CreateOptions { return nil } co := &metav1.CreateOptions{ - DryRun: uo.DryRun, - FieldManager: uo.FieldManager, + DryRun: uo.DryRun, + FieldManager: uo.FieldManager, + FieldValidation: uo.FieldValidation, } co.TypeMeta.SetGroupVersionKind(metav1.SchemeGroupVersion.WithKind("CreateOptions")) return co diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/watch.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/watch.go index 47fe44b78d..818d94ae4c 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/watch.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/watch.go @@ -31,7 +31,6 @@ import ( "k8s.io/apimachinery/pkg/watch" "k8s.io/apiserver/pkg/endpoints/handlers/negotiation" "k8s.io/apiserver/pkg/endpoints/metrics" - "k8s.io/apiserver/pkg/server/httplog" "k8s.io/apiserver/pkg/util/wsstream" "golang.org/x/net/websocket" @@ -166,8 +165,6 @@ func (s *WatchServer) ServeHTTP(w http.ResponseWriter, req *http.Request) { metrics.RegisteredWatchers.WithContext(req.Context()).WithLabelValues(kind.Group, kind.Version, kind.Kind).Inc() defer metrics.RegisteredWatchers.WithContext(req.Context()).WithLabelValues(kind.Group, kind.Version, kind.Kind).Dec() - w = httplog.Unlogged(req, w) - if wsstream.IsWebSocketRequest(req) { w.Header().Set("Content-Type", s.MediaType) websocket.Handler(s.HandleWS).ServeHTTP(w, req) diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/installer.go b/vendor/k8s.io/apiserver/pkg/endpoints/installer.go index 0902add482..13d703afb2 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/installer.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/installer.go @@ -217,7 +217,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag isSubresource := len(subresource) > 0 // If there is a subresource, namespace scoping is defined by the parent resource - namespaceScoped := true + var namespaceScoped bool if isSubresource { parentStorage, ok := a.group.Storage[resource] if !ok { @@ -541,6 +541,11 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag } } + var disabledParams []string + if !utilfeature.DefaultFeatureGate.Enabled(features.ServerSideFieldValidation) { + disabledParams = []string{"fieldValidation"} + } + // Create Routes for the actions. // TODO: Add status documentation using Returns() // Errors (see api/errors/errors.go as well as go-restful router): @@ -771,7 +776,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag Returns(http.StatusCreated, "Created", producedObject). Reads(defaultVersionedObject). Writes(producedObject) - if err := AddObjectParams(ws, route, versionedUpdateOptions); err != nil { + if err := AddObjectParams(ws, route, versionedUpdateOptions, disabledParams...); err != nil { return nil, nil, err } addParams(route, action.Params) @@ -802,7 +807,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag Returns(http.StatusCreated, "Created", producedObject). Reads(metav1.Patch{}). Writes(producedObject) - if err := AddObjectParams(ws, route, versionedPatchOptions); err != nil { + if err := AddObjectParams(ws, route, versionedPatchOptions, disabledParams...); err != nil { return nil, nil, err } addParams(route, action.Params) @@ -833,7 +838,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag Returns(http.StatusAccepted, "Accepted", producedObject). Reads(defaultVersionedObject). Writes(producedObject) - if err := AddObjectParams(ws, route, versionedCreateOptions); err != nil { + if err := AddObjectParams(ws, route, versionedCreateOptions, disabledParams...); err != nil { return nil, nil, err } addParams(route, action.Params) diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/metrics/metrics.go b/vendor/k8s.io/apiserver/pkg/endpoints/metrics/metrics.go index 5efc0a8347..7dd40a373c 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/metrics/metrics.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/metrics/metrics.go @@ -17,9 +17,7 @@ limitations under the License. package metrics import ( - "bufio" "context" - "net" "net/http" "net/url" "strconv" @@ -34,6 +32,7 @@ import ( "k8s.io/apiserver/pkg/audit" "k8s.io/apiserver/pkg/authentication/user" "k8s.io/apiserver/pkg/endpoints/request" + "k8s.io/apiserver/pkg/endpoints/responsewriter" "k8s.io/apiserver/pkg/features" utilfeature "k8s.io/apiserver/pkg/util/feature" compbasemetrics "k8s.io/component-base/metrics" @@ -80,14 +79,23 @@ var ( }, []string{"verb", "dry_run", "group", "version", "resource", "subresource", "scope", "component", "code"}, ) - longRunningRequestGauge = compbasemetrics.NewGaugeVec( + longRunningRequestsGauge = compbasemetrics.NewGaugeVec( &compbasemetrics.GaugeOpts{ - Name: "apiserver_longrunning_gauge", + Name: "apiserver_longrunning_requests", Help: "Gauge of all active long-running apiserver requests broken out by verb, group, version, resource, scope and component. Not all requests are tracked this way.", StabilityLevel: compbasemetrics.ALPHA, }, []string{"verb", "group", "version", "resource", "subresource", "scope", "component"}, ) + longRunningRequestGauge = compbasemetrics.NewGaugeVec( + &compbasemetrics.GaugeOpts{ + Name: "apiserver_longrunning_gauge", + Help: "Gauge of all active long-running apiserver requests broken out by verb, group, version, resource, scope and component. Not all requests are tracked this way.", + StabilityLevel: compbasemetrics.ALPHA, + DeprecatedVersion: "1.23.0", + }, + []string{"verb", "group", "version", "resource", "subresource", "scope", "component"}, + ) requestLatencies = compbasemetrics.NewHistogramVec( &compbasemetrics.HistogramOpts{ Name: "apiserver_request_duration_seconds", @@ -95,19 +103,32 @@ var ( // This metric is used for verifying api call latencies SLO, // as well as tracking regressions in this aspects. // Thus we customize buckets significantly, to empower both usecases. - Buckets: []float64{0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, - 1.25, 1.5, 1.75, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 40, 50, 60}, + Buckets: []float64{0.05, 0.1, 0.2, 0.4, 0.6, 0.8, 1.0, 1.25, 1.5, 2, 3, + 4, 5, 6, 8, 10, 15, 20, 30, 45, 60}, StabilityLevel: compbasemetrics.STABLE, }, []string{"verb", "dry_run", "group", "version", "resource", "subresource", "scope", "component"}, ) + requestSloLatencies = compbasemetrics.NewHistogramVec( + &compbasemetrics.HistogramOpts{ + Name: "apiserver_request_slo_duration_seconds", + Help: "Response latency distribution (not counting webhook duration) in seconds for each verb, group, version, resource, subresource, scope and component.", + // This metric is supplementary to the requestLatencies metric. + // It measures request duration excluding webhooks as they are mostly + // dependant on user configuration. + Buckets: []float64{0.05, 0.1, 0.2, 0.4, 0.6, 0.8, 1.0, 1.25, 1.5, 2, 3, + 4, 5, 6, 8, 10, 15, 20, 30, 45, 60}, + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{"verb", "group", "version", "resource", "subresource", "scope", "component"}, + ) responseSizes = compbasemetrics.NewHistogramVec( &compbasemetrics.HistogramOpts{ Name: "apiserver_response_sizes", Help: "Response size distribution in bytes for each group, version, verb, resource, subresource, scope and component.", // Use buckets ranging from 1000 bytes (1KB) to 10^9 bytes (1GB). Buckets: compbasemetrics.ExponentialBuckets(1000, 10.0, 7), - StabilityLevel: compbasemetrics.ALPHA, + StabilityLevel: compbasemetrics.STABLE, }, []string{"verb", "group", "version", "resource", "subresource", "scope", "component"}, ) @@ -131,9 +152,10 @@ var ( // RegisteredWatchers is a number of currently registered watchers splitted by resource. RegisteredWatchers = compbasemetrics.NewGaugeVec( &compbasemetrics.GaugeOpts{ - Name: "apiserver_registered_watchers", - Help: "Number of currently registered watchers for a given resources", - StabilityLevel: compbasemetrics.ALPHA, + Name: "apiserver_registered_watchers", + Help: "Number of currently registered watchers for a given resources", + StabilityLevel: compbasemetrics.ALPHA, + DeprecatedVersion: "1.23.0", }, []string{"group", "version", "kind"}, ) @@ -160,7 +182,7 @@ var ( &compbasemetrics.GaugeOpts{ Name: "apiserver_current_inflight_requests", Help: "Maximal number of currently used inflight request limit of this apiserver per request kind in last second.", - StabilityLevel: compbasemetrics.ALPHA, + StabilityLevel: compbasemetrics.STABLE, }, []string{"request_kind"}, ) @@ -234,8 +256,10 @@ var ( metrics = []resettableCollector{ deprecatedRequestGauge, requestCounter, + longRunningRequestsGauge, longRunningRequestGauge, requestLatencies, + requestSloLatencies, responseSizes, DroppedRequests, TLSHandshakeErrors, @@ -370,7 +394,7 @@ func RecordRequestAbort(req *http.Request, requestInfo *request.RequestInfo) { } scope := CleanScope(requestInfo) - reportedVerb := cleanVerb(CanonicalVerb(strings.ToUpper(req.Method), scope), "", req) + reportedVerb := cleanVerb(CanonicalVerb(strings.ToUpper(req.Method), scope), getVerbIfWatch(req), req) resource := requestInfo.Resource subresource := requestInfo.Subresource group := requestInfo.APIGroup @@ -393,7 +417,7 @@ func RecordRequestTermination(req *http.Request, requestInfo *request.RequestInf // InstrumentRouteFunc which is registered in installer.go with predefined // list of verbs (different than those translated to RequestInfo). // However, we need to tweak it e.g. to differentiate GET from LIST. - reportedVerb := cleanVerb(CanonicalVerb(strings.ToUpper(req.Method), scope), "", req) + reportedVerb := cleanVerb(CanonicalVerb(strings.ToUpper(req.Method), scope), getVerbIfWatch(req), req) if requestInfo.IsResourceRequest { requestTerminationsTotal.WithContext(req.Context()).WithLabelValues(reportedVerb, requestInfo.APIGroup, requestInfo.APIVersion, requestInfo.Resource, requestInfo.Subresource, scope, component, codeToString(code)).Inc() @@ -408,22 +432,28 @@ func RecordLongRunning(req *http.Request, requestInfo *request.RequestInfo, comp if requestInfo == nil { requestInfo = &request.RequestInfo{Verb: req.Method, Path: req.URL.Path} } - var g compbasemetrics.GaugeMetric + var g, e compbasemetrics.GaugeMetric scope := CleanScope(requestInfo) // We don't use verb from , as this may be propagated from // InstrumentRouteFunc which is registered in installer.go with predefined // list of verbs (different than those translated to RequestInfo). // However, we need to tweak it e.g. to differentiate GET from LIST. - reportedVerb := cleanVerb(CanonicalVerb(strings.ToUpper(req.Method), scope), "", req) + reportedVerb := cleanVerb(CanonicalVerb(strings.ToUpper(req.Method), scope), getVerbIfWatch(req), req) if requestInfo.IsResourceRequest { + e = longRunningRequestsGauge.WithContext(req.Context()).WithLabelValues(reportedVerb, requestInfo.APIGroup, requestInfo.APIVersion, requestInfo.Resource, requestInfo.Subresource, scope, component) g = longRunningRequestGauge.WithContext(req.Context()).WithLabelValues(reportedVerb, requestInfo.APIGroup, requestInfo.APIVersion, requestInfo.Resource, requestInfo.Subresource, scope, component) } else { + e = longRunningRequestsGauge.WithContext(req.Context()).WithLabelValues(reportedVerb, "", "", "", requestInfo.Path, scope, component) g = longRunningRequestGauge.WithContext(req.Context()).WithLabelValues(reportedVerb, "", "", "", requestInfo.Path, scope, component) } + e.Inc() g.Inc() - defer g.Dec() + defer func() { + e.Dec() + g.Dec() + }() fn() } @@ -452,6 +482,10 @@ func MonitorRequest(req *http.Request, verb, group, version, resource, subresour } } requestLatencies.WithContext(req.Context()).WithLabelValues(reportedVerb, dryRun, group, version, resource, subresource, scope, component).Observe(elapsedSeconds) + if wd, ok := request.WebhookDurationFrom(req.Context()); ok { + sloLatency := elapsedSeconds - (wd.AdmitTracker.GetLatency() + wd.ValidateTracker.GetLatency()).Seconds() + requestSloLatencies.WithContext(req.Context()).WithLabelValues(reportedVerb, group, version, resource, subresource, scope, component).Observe(sloLatency) + } // We are only interested in response sizes of read requests. if verb == "GET" || verb == "LIST" { responseSizes.WithContext(req.Context()).WithLabelValues(reportedVerb, group, version, resource, subresource, scope, component).Observe(float64(respSize)) @@ -469,16 +503,7 @@ func InstrumentRouteFunc(verb, group, version, resource, subresource, scope, com delegate := &ResponseWriterDelegator{ResponseWriter: response.ResponseWriter} - //lint:file-ignore SA1019 Keep supporting deprecated http.CloseNotifier - _, cn := response.ResponseWriter.(http.CloseNotifier) - _, fl := response.ResponseWriter.(http.Flusher) - _, hj := response.ResponseWriter.(http.Hijacker) - var rw http.ResponseWriter - if cn && fl && hj { - rw = &fancyResponseWriterDelegator{delegate} - } else { - rw = delegate - } + rw := responsewriter.WrapForHTTP1Or2(delegate) response.ResponseWriter = rw routeFunc(req, response) @@ -496,15 +521,7 @@ func InstrumentHandlerFunc(verb, group, version, resource, subresource, scope, c } delegate := &ResponseWriterDelegator{ResponseWriter: w} - - _, cn := w.(http.CloseNotifier) - _, fl := w.(http.Flusher) - _, hj := w.(http.Hijacker) - if cn && fl && hj { - w = &fancyResponseWriterDelegator{delegate} - } else { - w = delegate - } + w = responsewriter.WrapForHTTP1Or2(delegate) handler(w, req) @@ -545,13 +562,8 @@ func CanonicalVerb(verb string, scope string) string { // LIST and APPLY from PATCH. func CleanVerb(verb string, request *http.Request) string { reportedVerb := verb - if verb == "LIST" { - // see apimachinery/pkg/runtime/conversion.go Convert_Slice_string_To_bool - if values := request.URL.Query()["watch"]; len(values) > 0 { - if value := strings.ToLower(values[0]); value != "0" && value != "false" { - reportedVerb = "WATCH" - } - } + if verb == "LIST" && checkIfWatch(request) { + reportedVerb = "WATCH" } // normalize the legacy WATCHLIST to WATCH to ensure users aren't surprised by metrics if verb == "WATCHLIST" { @@ -565,13 +577,15 @@ func CleanVerb(verb string, request *http.Request) string { // cleanVerb additionally ensures that unknown verbs don't clog up the metrics. func cleanVerb(verb, suggestedVerb string, request *http.Request) string { - reportedVerb := CleanVerb(verb, request) // CanonicalVerb (being an input for this function) doesn't handle correctly the // deprecated path pattern for watch of: // GET /api/{version}/watch/{resource} // We correct it manually based on the pass verb from the installer. + var reportedVerb string if suggestedVerb == "WATCH" || suggestedVerb == "WATCHLIST" { reportedVerb = "WATCH" + } else { + reportedVerb = CleanVerb(verb, request) } if validRequestMethods.Has(reportedVerb) { return reportedVerb @@ -579,6 +593,27 @@ func cleanVerb(verb, suggestedVerb string, request *http.Request) string { return OtherRequestMethod } +//getVerbIfWatch additionally ensures that GET or List would be transformed to WATCH +func getVerbIfWatch(req *http.Request) string { + if strings.ToUpper(req.Method) == "GET" || strings.ToUpper(req.Method) == "LIST" { + if checkIfWatch(req) { + return "WATCH" + } + } + return "" +} + +//checkIfWatch check request is watch +func checkIfWatch(req *http.Request) bool { + // see apimachinery/pkg/runtime/conversion.go Convert_Slice_string_To_bool + if values := req.URL.Query()["watch"]; len(values) > 0 { + if value := strings.ToLower(values[0]); value != "0" && value != "false" { + return true + } + } + return false +} + func cleanDryRun(u *url.URL) string { // avoid allocating when we don't see dryRun in the query if !strings.Contains(u.RawQuery, "dryRun") { @@ -595,6 +630,9 @@ func cleanDryRun(u *url.URL) string { return strings.Join(utilsets.NewString(dryRun...).List(), ",") } +var _ http.ResponseWriter = (*ResponseWriterDelegator)(nil) +var _ responsewriter.UserProvidedDecorator = (*ResponseWriterDelegator)(nil) + // ResponseWriterDelegator interface wraps http.ResponseWriter to additionally record content-length, status-code, etc. type ResponseWriterDelegator struct { http.ResponseWriter @@ -604,6 +642,10 @@ type ResponseWriterDelegator struct { wroteHeader bool } +func (r *ResponseWriterDelegator) Unwrap() http.ResponseWriter { + return r.ResponseWriter +} + func (r *ResponseWriterDelegator) WriteHeader(code int) { r.status = code r.wroteHeader = true @@ -627,22 +669,6 @@ func (r *ResponseWriterDelegator) ContentLength() int { return int(r.written) } -type fancyResponseWriterDelegator struct { - *ResponseWriterDelegator -} - -func (f *fancyResponseWriterDelegator) CloseNotify() <-chan bool { - return f.ResponseWriter.(http.CloseNotifier).CloseNotify() -} - -func (f *fancyResponseWriterDelegator) Flush() { - f.ResponseWriter.(http.Flusher).Flush() -} - -func (f *fancyResponseWriterDelegator) Hijack() (net.Conn, *bufio.ReadWriter, error) { - return f.ResponseWriter.(http.Hijacker).Hijack() -} - // Small optimization over Itoa func codeToString(s int) string { switch s { diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/request/context.go b/vendor/k8s.io/apiserver/pkg/endpoints/request/context.go index 95166f5c47..8f4e60f549 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/request/context.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/request/context.go @@ -20,7 +20,6 @@ import ( "context" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apiserver/pkg/apis/audit" "k8s.io/apiserver/pkg/authentication/user" ) @@ -33,9 +32,6 @@ const ( // userKey is the context key for the request user. userKey - - // auditKey is the context key for the audit event. - auditKey ) // NewContext instantiates a base context object for request flows. @@ -80,14 +76,3 @@ func UserFrom(ctx context.Context) (user.Info, bool) { user, ok := ctx.Value(userKey).(user.Info) return user, ok } - -// WithAuditEvent returns set audit event struct. -func WithAuditEvent(parent context.Context, ev *audit.Event) context.Context { - return WithValue(parent, auditKey, ev) -} - -// AuditEventFrom returns the audit event struct on the ctx -func AuditEventFrom(ctx context.Context) *audit.Event { - ev, _ := ctx.Value(auditKey).(*audit.Event) - return ev -} diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/request/webhook_duration.go b/vendor/k8s.io/apiserver/pkg/endpoints/request/webhook_duration.go new file mode 100644 index 0000000000..209b33cdf1 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/endpoints/request/webhook_duration.go @@ -0,0 +1,122 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package request + +import ( + "context" + "sync" + "time" + + "k8s.io/utils/clock" +) + +func sumDuration(d1 time.Duration, d2 time.Duration) time.Duration { + return d1 + d2 +} + +func maxDuration(d1 time.Duration, d2 time.Duration) time.Duration { + if d1 > d2 { + return d1 + } + return d2 +} + +// DurationTracker is a simple interface for tracking functions duration +type DurationTracker interface { + Track(func()) + GetLatency() time.Duration +} + +// durationTracker implements DurationTracker by measuring function time +// using given clock and aggregates the duration using given aggregate function +type durationTracker struct { + clock clock.Clock + latency time.Duration + mu sync.Mutex + aggregateFunction func(time.Duration, time.Duration) time.Duration +} + +// Track measures time spent in given function and aggregates measured +// duration using aggregateFunction +func (t *durationTracker) Track(f func()) { + startedAt := t.clock.Now() + defer func() { + duration := t.clock.Since(startedAt) + t.mu.Lock() + defer t.mu.Unlock() + t.latency = t.aggregateFunction(t.latency, duration) + }() + + f() +} + +// GetLatency returns aggregated latency tracked by a tracker +func (t *durationTracker) GetLatency() time.Duration { + t.mu.Lock() + defer t.mu.Unlock() + return t.latency +} + +func newSumLatencyTracker(c clock.Clock) DurationTracker { + return &durationTracker{ + clock: c, + aggregateFunction: sumDuration, + } +} + +func newMaxLatencyTracker(c clock.Clock) DurationTracker { + return &durationTracker{ + clock: c, + aggregateFunction: maxDuration, + } +} + +// WebhookDuration stores trackers used to measure webhook request durations. +// Since admit webhooks are done sequentially duration is aggregated using +// sum function. Validate webhooks are done in parallel so max function +// is used. +type WebhookDuration struct { + AdmitTracker DurationTracker + ValidateTracker DurationTracker +} + +type webhookDurationKeyType int + +// webhookDurationKey is the WebhookDuration (the time the request spent waiting +// for the webhooks to finish) key for the context. +const webhookDurationKey webhookDurationKeyType = iota + +// WithWebhookDuration returns a copy of parent context to which the +// WebhookDuration trackers are added. +func WithWebhookDuration(parent context.Context) context.Context { + return WithWebhookDurationAndCustomClock(parent, clock.RealClock{}) +} + +// WithWebhookDurationAndCustomClock returns a copy of parent context to which +// the WebhookDuration trackers are added. Tracers use given clock. +func WithWebhookDurationAndCustomClock(parent context.Context, c clock.Clock) context.Context { + return WithValue(parent, webhookDurationKey, &WebhookDuration{ + AdmitTracker: newSumLatencyTracker(c), + ValidateTracker: newMaxLatencyTracker(c), + }) +} + +// WebhookDurationFrom returns the value of the WebhookDuration key from the specified context. +func WebhookDurationFrom(ctx context.Context) (*WebhookDuration, bool) { + wd, ok := ctx.Value(webhookDurationKey).(*WebhookDuration) + return wd, ok && wd != nil +} diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/responsewriter/fake.go b/vendor/k8s.io/apiserver/pkg/endpoints/responsewriter/fake.go new file mode 100644 index 0000000000..3a8fe7a6a8 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/endpoints/responsewriter/fake.go @@ -0,0 +1,54 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package responsewriter + +import ( + "bufio" + "net" + "net/http" +) + +var _ http.ResponseWriter = &FakeResponseWriter{} + +// FakeResponseWriter implements http.ResponseWriter, +// it is used for testing purpose only +type FakeResponseWriter struct{} + +func (fw *FakeResponseWriter) Header() http.Header { return http.Header{} } +func (fw *FakeResponseWriter) WriteHeader(code int) {} +func (fw *FakeResponseWriter) Write(bs []byte) (int, error) { return len(bs), nil } + +// For HTTP2 an http.ResponseWriter object implements +// http.Flusher and http.CloseNotifier. +// It is used for testing purpose only +type FakeResponseWriterFlusherCloseNotifier struct { + *FakeResponseWriter +} + +func (fw *FakeResponseWriterFlusherCloseNotifier) Flush() {} +func (fw *FakeResponseWriterFlusherCloseNotifier) CloseNotify() <-chan bool { return nil } + +// For HTTP/1.x an http.ResponseWriter object implements +// http.Flusher, http.CloseNotifier and http.Hijacker. +// It is used for testing purpose only +type FakeResponseWriterFlusherCloseNotifierHijacker struct { + *FakeResponseWriterFlusherCloseNotifier +} + +func (fw *FakeResponseWriterFlusherCloseNotifierHijacker) Hijack() (net.Conn, *bufio.ReadWriter, error) { + return nil, nil, nil +} diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/responsewriter/wrapper.go b/vendor/k8s.io/apiserver/pkg/endpoints/responsewriter/wrapper.go new file mode 100644 index 0000000000..758e7addd2 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/endpoints/responsewriter/wrapper.go @@ -0,0 +1,180 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package responsewriter + +import ( + "bufio" + "net" + "net/http" +) + +// UserProvidedDecorator represensts a user (client that uses this package) +// provided decorator that wraps an inner http.ResponseWriter object. +// The user-provided decorator object must return the inner (decorated) +// http.ResponseWriter object via the Unwrap function. +type UserProvidedDecorator interface { + http.ResponseWriter + + // Unwrap returns the inner http.ResponseWriter object associated + // with the user-provided decorator. + Unwrap() http.ResponseWriter +} + +// WrapForHTTP1Or2 accepts a user-provided decorator of an "inner" http.responseWriter +// object and potentially wraps the user-provided decorator with a new http.ResponseWriter +// object that implements http.CloseNotifier, http.Flusher, and/or http.Hijacker by +// delegating to the user-provided decorator (if it implements the relevant method) or +// the inner http.ResponseWriter (otherwise), so that the returned http.ResponseWriter +// object implements the same subset of those interfaces as the inner http.ResponseWriter. +// +// This function handles the following three casses. +// - The inner ResponseWriter implements `http.CloseNotifier`, `http.Flusher`, +// and `http.Hijacker` (an HTTP/1.1 sever provides such a ResponseWriter). +// - The inner ResponseWriter implements `http.CloseNotifier` and `http.Flusher` +// but not `http.Hijacker` (an HTTP/2 server provides such a ResponseWriter). +// - All the other cases collapse to this one, in which the given ResponseWriter is returned. +// +// There are three applicable terms: +// - "outer": this is the ResponseWriter object returned by the WrapForHTTP1Or2 function. +// - "user-provided decorator" or "middle": this is the user-provided decorator +// that decorates an inner ResponseWriter object. A user-provided decorator +// implements the UserProvidedDecorator interface. A user-provided decorator +// may or may not implement http.CloseNotifier, http.Flusher or http.Hijacker. +// - "inner": the ResponseWriter that the user-provided decorator extends. +func WrapForHTTP1Or2(decorator UserProvidedDecorator) http.ResponseWriter { + // from go net/http documentation: + // The default HTTP/1.x and HTTP/2 ResponseWriter implementations support Flusher + // Handlers should always test for this ability at runtime. + // + // The Hijacker interface is implemented by ResponseWriters that allow an HTTP handler + // to take over the connection. + // The default ResponseWriter for HTTP/1.x connections supports Hijacker, but HTTP/2 connections + // intentionally do not. ResponseWriter wrappers may also not support Hijacker. + // Handlers should always test for this ability at runtime + // + // The CloseNotifier interface is implemented by ResponseWriters which allow detecting + // when the underlying connection has gone away. + // Deprecated: the CloseNotifier interface predates Go's context package. + // New code should use Request.Context instead. + inner := decorator.Unwrap() + if innerNotifierFlusher, ok := inner.(CloseNotifierFlusher); ok { + // for HTTP/2 request, the default ResponseWriter object (http2responseWriter) + // implements Flusher and CloseNotifier. + outerHTTP2 := outerWithCloseNotifyAndFlush{ + UserProvidedDecorator: decorator, + InnerCloseNotifierFlusher: innerNotifierFlusher, + } + + if innerHijacker, hijackable := inner.(http.Hijacker); hijackable { + // for HTTP/1.x request the default implementation of ResponseWriter + // also implement CloseNotifier, Flusher and Hijacker + return &outerWithCloseNotifyFlushAndHijack{ + outerWithCloseNotifyAndFlush: outerHTTP2, + InnerHijacker: innerHijacker, + } + } + + return outerHTTP2 + } + + // we should never be here for either http/1.x or http2 request + return decorator +} + +// CloseNotifierFlusher is a combination of http.CloseNotifier and http.Flusher +// This applies to both http/1.x and http2 requests. +type CloseNotifierFlusher interface { + http.CloseNotifier + http.Flusher +} + +// GetOriginal goes through the chain of wrapped http.ResponseWriter objects +// and returns the original http.ResponseWriter object provided to the first +// request handler in the filter chain. +func GetOriginal(w http.ResponseWriter) http.ResponseWriter { + decorator, ok := w.(UserProvidedDecorator) + if !ok { + return w + } + + inner := decorator.Unwrap() + if inner == w { + // infinite cycle here, we should never be here though. + panic("http.ResponseWriter decorator chain has a cycle") + } + + return GetOriginal(inner) +} + +//nolint:staticcheck // SA1019 +var _ http.CloseNotifier = outerWithCloseNotifyAndFlush{} +var _ http.Flusher = outerWithCloseNotifyAndFlush{} +var _ http.ResponseWriter = outerWithCloseNotifyAndFlush{} +var _ UserProvidedDecorator = outerWithCloseNotifyAndFlush{} + +// outerWithCloseNotifyAndFlush is the outer object that extends the +// user provied decorator with http.CloseNotifier and http.Flusher only. +type outerWithCloseNotifyAndFlush struct { + // UserProvidedDecorator is the user-provided object, it decorates + // an inner ResponseWriter object. + UserProvidedDecorator + + // http.CloseNotifier and http.Flusher for the inner object + InnerCloseNotifierFlusher CloseNotifierFlusher +} + +func (wr outerWithCloseNotifyAndFlush) CloseNotify() <-chan bool { + if notifier, ok := wr.UserProvidedDecorator.(http.CloseNotifier); ok { + return notifier.CloseNotify() + } + + return wr.InnerCloseNotifierFlusher.CloseNotify() +} + +func (wr outerWithCloseNotifyAndFlush) Flush() { + if flusher, ok := wr.UserProvidedDecorator.(http.Flusher); ok { + flusher.Flush() + return + } + + wr.InnerCloseNotifierFlusher.Flush() +} + +//lint:file-ignore SA1019 Keep supporting deprecated http.CloseNotifier +var _ http.CloseNotifier = outerWithCloseNotifyFlushAndHijack{} +var _ http.Flusher = outerWithCloseNotifyFlushAndHijack{} +var _ http.Hijacker = outerWithCloseNotifyFlushAndHijack{} +var _ http.ResponseWriter = outerWithCloseNotifyFlushAndHijack{} +var _ UserProvidedDecorator = outerWithCloseNotifyFlushAndHijack{} + +// outerWithCloseNotifyFlushAndHijack is the outer object that extends the +// user-provided decorator with http.CloseNotifier, http.Flusher and http.Hijacker. +// This applies to http/1.x requests only. +type outerWithCloseNotifyFlushAndHijack struct { + outerWithCloseNotifyAndFlush + + // http.Hijacker for the inner object + InnerHijacker http.Hijacker +} + +func (wr outerWithCloseNotifyFlushAndHijack) Hijack() (net.Conn, *bufio.ReadWriter, error) { + if hijacker, ok := wr.UserProvidedDecorator.(http.Hijacker); ok { + return hijacker.Hijack() + } + + return wr.InnerHijacker.Hijack() +} diff --git a/vendor/k8s.io/apiserver/pkg/features/kube_features.go b/vendor/k8s.io/apiserver/pkg/features/kube_features.go index 645e67e7ea..ffab26970c 100644 --- a/vendor/k8s.io/apiserver/pkg/features/kube_features.go +++ b/vendor/k8s.io/apiserver/pkg/features/kube_features.go @@ -170,6 +170,35 @@ const ( // // Add support for distributed tracing in the API Server APIServerTracing featuregate.Feature = "APIServerTracing" + + // owner: @jiahuif + // kep: http://kep.k8s.io/2887 + // alpha: v1.23 + // + // Enables populating "enum" field of OpenAPI schemas + // in the spec returned from kube-apiserver. + OpenAPIEnums featuregate.Feature = "OpenAPIEnums" + + // owner: @cici37 + // kep: http://kep.k8s.io/2876 + // alpha: v1.23 + // + // Enables expression validation for Custom Resource + CustomResourceValidationExpressions featuregate.Feature = "CustomResourceValidationExpressions" + + // owner: @jefftree + // kep: http://kep.k8s.io/2896 + // alpha: v1.23 + // + // Enables kubernetes to publish OpenAPI v3 + OpenAPIV3 featuregate.Feature = "OpenAPIV3" + + // owner: @kevindelgado + // kep: http://kep.k8s.io/2885 + // alpha: v1.23 + // + // Enables server-side field validation. + ServerSideFieldValidation featuregate.Feature = "ServerSideFieldValidation" ) func init() { @@ -180,22 +209,26 @@ func init() { // To add a new feature, define a key for it above and add it here. The features will be // available throughout Kubernetes binaries. var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureSpec{ - StreamingProxyRedirects: {Default: false, PreRelease: featuregate.Deprecated}, - ValidateProxyRedirects: {Default: true, PreRelease: featuregate.Deprecated}, - AdvancedAuditing: {Default: true, PreRelease: featuregate.GA}, - APIResponseCompression: {Default: true, PreRelease: featuregate.Beta}, - APIListChunking: {Default: true, PreRelease: featuregate.Beta}, - DryRun: {Default: true, PreRelease: featuregate.GA}, - RemainingItemCount: {Default: true, PreRelease: featuregate.Beta}, - ServerSideApply: {Default: true, PreRelease: featuregate.GA}, - StorageVersionHash: {Default: true, PreRelease: featuregate.Beta}, - StorageVersionAPI: {Default: false, PreRelease: featuregate.Alpha}, - WatchBookmark: {Default: true, PreRelease: featuregate.GA, LockToDefault: true}, - APIPriorityAndFairness: {Default: true, PreRelease: featuregate.Beta}, - RemoveSelfLink: {Default: true, PreRelease: featuregate.Beta}, - SelectorIndex: {Default: true, PreRelease: featuregate.GA, LockToDefault: true}, - WarningHeaders: {Default: true, PreRelease: featuregate.GA, LockToDefault: true}, - EfficientWatchResumption: {Default: true, PreRelease: featuregate.Beta}, - APIServerIdentity: {Default: false, PreRelease: featuregate.Alpha}, - APIServerTracing: {Default: false, PreRelease: featuregate.Alpha}, + StreamingProxyRedirects: {Default: false, PreRelease: featuregate.Deprecated}, + ValidateProxyRedirects: {Default: true, PreRelease: featuregate.Deprecated}, + AdvancedAuditing: {Default: true, PreRelease: featuregate.GA}, + APIResponseCompression: {Default: true, PreRelease: featuregate.Beta}, + APIListChunking: {Default: true, PreRelease: featuregate.Beta}, + DryRun: {Default: true, PreRelease: featuregate.GA}, + RemainingItemCount: {Default: true, PreRelease: featuregate.Beta}, + ServerSideApply: {Default: true, PreRelease: featuregate.GA}, + StorageVersionHash: {Default: true, PreRelease: featuregate.Beta}, + StorageVersionAPI: {Default: false, PreRelease: featuregate.Alpha}, + WatchBookmark: {Default: true, PreRelease: featuregate.GA, LockToDefault: true}, + APIPriorityAndFairness: {Default: true, PreRelease: featuregate.Beta}, + RemoveSelfLink: {Default: true, PreRelease: featuregate.Beta}, + SelectorIndex: {Default: true, PreRelease: featuregate.GA, LockToDefault: true}, + WarningHeaders: {Default: true, PreRelease: featuregate.GA, LockToDefault: true}, + EfficientWatchResumption: {Default: true, PreRelease: featuregate.Beta}, + APIServerIdentity: {Default: false, PreRelease: featuregate.Alpha}, + APIServerTracing: {Default: false, PreRelease: featuregate.Alpha}, + OpenAPIEnums: {Default: false, PreRelease: featuregate.Alpha}, + CustomResourceValidationExpressions: {Default: false, PreRelease: featuregate.Alpha}, + OpenAPIV3: {Default: false, PreRelease: featuregate.Alpha}, + ServerSideFieldValidation: {Default: false, PreRelease: featuregate.Alpha}, } diff --git a/vendor/k8s.io/apiserver/pkg/registry/generic/options.go b/vendor/k8s.io/apiserver/pkg/registry/generic/options.go index 577192b626..d675a258f5 100644 --- a/vendor/k8s.io/apiserver/pkg/registry/generic/options.go +++ b/vendor/k8s.io/apiserver/pkg/registry/generic/options.go @@ -22,18 +22,20 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apiserver/pkg/storage" "k8s.io/apiserver/pkg/storage/storagebackend" + flowcontrolrequest "k8s.io/apiserver/pkg/util/flowcontrol/request" "k8s.io/client-go/tools/cache" ) -// RESTOptions is set of configuration options to generic registries. +// RESTOptions is set of resource-specific configuration options to generic registries. type RESTOptions struct { - StorageConfig *storagebackend.Config + StorageConfig *storagebackend.ConfigForResource Decorator StorageDecorator - EnableGarbageCollection bool - DeleteCollectionWorkers int - ResourcePrefix string - CountMetricPollPeriod time.Duration + EnableGarbageCollection bool + DeleteCollectionWorkers int + ResourcePrefix string + CountMetricPollPeriod time.Duration + StorageObjectCountTracker flowcontrolrequest.StorageObjectCountTracker } // Implement RESTOptionsGetter so that RESTOptions can directly be used when available (i.e. tests) diff --git a/vendor/k8s.io/apiserver/pkg/registry/generic/registry/storage_factory.go b/vendor/k8s.io/apiserver/pkg/registry/generic/registry/storage_factory.go index f2fa59723f..6a4426ee60 100644 --- a/vendor/k8s.io/apiserver/pkg/registry/generic/registry/storage_factory.go +++ b/vendor/k8s.io/apiserver/pkg/registry/generic/registry/storage_factory.go @@ -36,7 +36,7 @@ import ( // Creates a cacher based given storageConfig. func StorageWithCacher() generic.StorageDecorator { return func( - storageConfig *storagebackend.Config, + storageConfig *storagebackend.ConfigForResource, resourcePrefix string, keyFunc func(obj runtime.Object) (string, error), newFunc func() runtime.Object, diff --git a/vendor/k8s.io/apiserver/pkg/registry/generic/registry/store.go b/vendor/k8s.io/apiserver/pkg/registry/generic/registry/store.go index 7a626855a1..4397f631e8 100644 --- a/vendor/k8s.io/apiserver/pkg/registry/generic/registry/store.go +++ b/vendor/k8s.io/apiserver/pkg/registry/generic/registry/store.go @@ -44,6 +44,7 @@ import ( storeerr "k8s.io/apiserver/pkg/storage/errors" "k8s.io/apiserver/pkg/storage/etcd3/metrics" "k8s.io/apiserver/pkg/util/dryrun" + flowcontrolrequest "k8s.io/apiserver/pkg/util/flowcontrol/request" "k8s.io/client-go/tools/cache" "sigs.k8s.io/structured-merge-diff/v4/fieldpath" @@ -292,7 +293,7 @@ func (e *Store) NamespaceScoped() bool { return e.UpdateStrategy.NamespaceScoped() } - panic("programmer error: no CRUD for resource, you're crazy, override NamespaceScoped too") + panic("programmer error: no CRUD for resource, override NamespaceScoped too") } // GetCreateStrategy implements GenericStore. @@ -359,6 +360,9 @@ func (e *Store) ListPredicate(ctx context.Context, p storage.SelectionPredicate, func finishNothing(context.Context, bool) {} // Create inserts a new item according to the unique key from the object. +// Note that registries may mutate the input object (e.g. in the strategy +// hooks). Tests which call this might want to call DeepCopy if they expect to +// be able to examine the input and output objects for differences. func (e *Store) Create(ctx context.Context, obj runtime.Object, createValidation rest.ValidateObjectFunc, options *metav1.CreateOptions) (runtime.Object, error) { var finishCreate FinishFunc = finishNothing @@ -400,7 +404,7 @@ func (e *Store) Create(ctx context.Context, obj runtime.Object, createValidation out := e.NewFunc() if err := e.Storage.Create(ctx, key, obj, out, ttl, dryrun.IsDryRun(options.DryRun)); err != nil { err = storeerr.InterpretCreateError(err, qualifiedResource, name) - err = rest.CheckGeneratedNameError(e.CreateStrategy, err, obj) + err = rest.CheckGeneratedNameError(ctx, e.CreateStrategy, err, obj) if !apierrors.IsAlreadyExists(err) { return nil, err } @@ -655,7 +659,7 @@ func (e *Store) Update(ctx context.Context, name string, objInfo rest.UpdatedObj } if creating { err = storeerr.InterpretCreateError(err, qualifiedResource, name) - err = rest.CheckGeneratedNameError(e.CreateStrategy, err, creatingObj) + err = rest.CheckGeneratedNameError(ctx, e.CreateStrategy, err, creatingObj) } else { err = storeerr.InterpretUpdateError(err, qualifiedResource, name) } @@ -681,8 +685,9 @@ func (e *Store) Update(ctx context.Context, name string, objInfo rest.UpdatedObj // create-on-update path. func newCreateOptionsFromUpdateOptions(in *metav1.UpdateOptions) *metav1.CreateOptions { co := &metav1.CreateOptions{ - DryRun: in.DryRun, - FieldManager: in.FieldManager, + DryRun: in.DryRun, + FieldManager: in.FieldManager, + FieldValidation: in.FieldValidation, } co.TypeMeta.SetGroupVersionKind(metav1.SchemeGroupVersion.WithKind("CreateOptions")) return co @@ -749,9 +754,9 @@ func shouldOrphanDependents(ctx context.Context, e *Store, accessor metav1.Objec } // An explicit policy was set at deletion time, that overrides everything - //lint:ignore SA1019 backwards compatibility + //nolint:staticcheck // SA1019 backwards compatibility if options != nil && options.OrphanDependents != nil { - //lint:ignore SA1019 backwards compatibility + //nolint:staticcheck // SA1019 backwards compatibility return *options.OrphanDependents } if options != nil && options.PropagationPolicy != nil { @@ -792,7 +797,7 @@ func shouldDeleteDependents(ctx context.Context, e *Store, accessor metav1.Objec } // If an explicit policy was set at deletion time, that overrides both - //lint:ignore SA1019 backwards compatibility + //nolint:staticcheck // SA1019 backwards compatibility if options != nil && options.OrphanDependents != nil { return false } @@ -1123,13 +1128,21 @@ func (e *Store) DeleteCollection(ctx context.Context, deleteValidation rest.Vali wg := sync.WaitGroup{} toProcess := make(chan int, 2*workersNumber) errs := make(chan error, workersNumber+1) + workersExited := make(chan struct{}) + distributorExited := make(chan struct{}) go func() { defer utilruntime.HandleCrash(func(panicReason interface{}) { errs <- fmt.Errorf("DeleteCollection distributor panicked: %v", panicReason) }) + defer close(distributorExited) for i := 0; i < len(items); i++ { - toProcess <- i + select { + case toProcess <- i: + case <-workersExited: + klog.V(4).InfoS("workers already exited, and there are some items waiting to be processed", "finished", i, "total", len(items)) + return + } } close(toProcess) }() @@ -1162,6 +1175,9 @@ func (e *Store) DeleteCollection(ctx context.Context, deleteValidation rest.Vali }() } wg.Wait() + // notify distributor to exit + close(workersExited) + <-distributorExited select { case err := <-errs: return nil, err @@ -1413,7 +1429,7 @@ func (e *Store) CompleteWithOptions(options *generic.StoreOptions) error { e.StorageVersioner = opts.StorageConfig.EncodeVersioner if opts.CountMetricPollPeriod > 0 { - stopFunc := e.startObservingCount(opts.CountMetricPollPeriod) + stopFunc := e.startObservingCount(opts.CountMetricPollPeriod, opts.StorageObjectCountTracker) previousDestroy := e.DestroyFunc e.DestroyFunc = func() { stopFunc() @@ -1428,7 +1444,7 @@ func (e *Store) CompleteWithOptions(options *generic.StoreOptions) error { } // startObservingCount starts monitoring given prefix and periodically updating metrics. It returns a function to stop collection. -func (e *Store) startObservingCount(period time.Duration) func() { +func (e *Store) startObservingCount(period time.Duration, objectCountTracker flowcontrolrequest.StorageObjectCountTracker) func() { prefix := e.KeyRootFunc(genericapirequest.NewContext()) resourceName := e.DefaultQualifiedResource.String() klog.V(2).InfoS("Monitoring resource count at path", "resource", resourceName, "path", "/"+prefix) @@ -1437,9 +1453,12 @@ func (e *Store) startObservingCount(period time.Duration) func() { count, err := e.Storage.Count(prefix) if err != nil { klog.V(5).InfoS("Failed to update storage count metric", "err", err) - metrics.UpdateObjectCount(resourceName, -1) - } else { - metrics.UpdateObjectCount(resourceName, count) + count = -1 + } + + metrics.UpdateObjectCount(resourceName, count) + if objectCountTracker != nil { + objectCountTracker.Set(resourceName, count) } }, period, resourceCountPollPeriodJitter, true, stopCh) return func() { close(stopCh) } diff --git a/vendor/k8s.io/apiserver/pkg/registry/generic/storage_decorator.go b/vendor/k8s.io/apiserver/pkg/registry/generic/storage_decorator.go index e0ca2df04c..715aa10477 100644 --- a/vendor/k8s.io/apiserver/pkg/registry/generic/storage_decorator.go +++ b/vendor/k8s.io/apiserver/pkg/registry/generic/storage_decorator.go @@ -27,7 +27,7 @@ import ( // StorageDecorator is a function signature for producing a storage.Interface // and an associated DestroyFunc from given parameters. type StorageDecorator func( - config *storagebackend.Config, + config *storagebackend.ConfigForResource, resourcePrefix string, keyFunc func(obj runtime.Object) (string, error), newFunc func() runtime.Object, @@ -39,7 +39,7 @@ type StorageDecorator func( // UndecoratedStorage returns the given a new storage from the given config // without any decoration. func UndecoratedStorage( - config *storagebackend.Config, + config *storagebackend.ConfigForResource, resourcePrefix string, keyFunc func(obj runtime.Object) (string, error), newFunc func() runtime.Object, @@ -53,6 +53,6 @@ func UndecoratedStorage( // NewRawStorage creates the low level kv storage. This is a work-around for current // two layer of same storage interface. // TODO: Once cacher is enabled on all registries (event registry is special), we will remove this method. -func NewRawStorage(config *storagebackend.Config, newFunc func() runtime.Object) (storage.Interface, factory.DestroyFunc, error) { +func NewRawStorage(config *storagebackend.ConfigForResource, newFunc func() runtime.Object) (storage.Interface, factory.DestroyFunc, error) { return factory.Create(*config, newFunc) } diff --git a/vendor/k8s.io/apiserver/pkg/registry/rest/create.go b/vendor/k8s.io/apiserver/pkg/registry/rest/create.go index 950260e457..942ee4774c 100644 --- a/vendor/k8s.io/apiserver/pkg/registry/rest/create.go +++ b/vendor/k8s.io/apiserver/pkg/registry/rest/create.go @@ -28,6 +28,7 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/util/validation/field" "k8s.io/apiserver/pkg/admission" + genericapirequest "k8s.io/apiserver/pkg/endpoints/request" "k8s.io/apiserver/pkg/features" "k8s.io/apiserver/pkg/storage/names" utilfeature "k8s.io/apiserver/pkg/util/feature" @@ -109,6 +110,7 @@ func BeforeCreate(strategy RESTCreateStrategy, ctx context.Context, obj runtime. objectMeta.SetDeletionGracePeriodSeconds(nil) strategy.PrepareForCreate(ctx, obj) FillObjectMetaSystemFields(objectMeta) + if len(objectMeta.GetGenerateName()) > 0 && len(objectMeta.GetName()) == 0 { objectMeta.SetName(strategy.GenerateName(objectMeta.GetGenerateName())) } @@ -145,21 +147,31 @@ func BeforeCreate(strategy RESTCreateStrategy, ctx context.Context, obj runtime. // CheckGeneratedNameError checks whether an error that occurred creating a resource is due // to generation being unable to pick a valid name. -func CheckGeneratedNameError(strategy RESTCreateStrategy, err error, obj runtime.Object) error { +func CheckGeneratedNameError(ctx context.Context, strategy RESTCreateStrategy, err error, obj runtime.Object) error { if !errors.IsAlreadyExists(err) { return err } - objectMeta, kind, kerr := objectMetaAndKind(strategy, obj) + objectMeta, gvk, kerr := objectMetaAndKind(strategy, obj) if kerr != nil { return kerr } if len(objectMeta.GetGenerateName()) == 0 { + // If we don't have a generated name, return the original error (AlreadyExists). + // When we're here, the user picked a name that is causing a conflict. return err } - return errors.NewServerTimeoutForKind(kind.GroupKind(), "POST", 0) + // Get the group resource information from the context, if populated. + gr := schema.GroupResource{} + if requestInfo, found := genericapirequest.RequestInfoFrom(ctx); found { + gr = schema.GroupResource{Group: gvk.Group, Resource: requestInfo.Resource} + } + + // If we have a name and generated name, the server picked a name + // that already exists. + return errors.NewGenerateNameConflict(gr, objectMeta.GetName(), 1) } // objectMetaAndKind retrieves kind and ObjectMeta from a runtime object, or returns an error. diff --git a/vendor/k8s.io/apiserver/pkg/server/config.go b/vendor/k8s.io/apiserver/pkg/server/config.go index c4bbe15119..fb3179c462 100644 --- a/vendor/k8s.io/apiserver/pkg/server/config.go +++ b/vendor/k8s.io/apiserver/pkg/server/config.go @@ -35,13 +35,11 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/runtime/serializer" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/sets" utilwaitgroup "k8s.io/apimachinery/pkg/util/waitgroup" "k8s.io/apimachinery/pkg/version" "k8s.io/apiserver/pkg/admission" "k8s.io/apiserver/pkg/audit" - auditpolicy "k8s.io/apiserver/pkg/audit/policy" "k8s.io/apiserver/pkg/authentication/authenticator" "k8s.io/apiserver/pkg/authentication/authenticatorfactory" authenticatorunion "k8s.io/apiserver/pkg/authentication/request/union" @@ -74,6 +72,7 @@ import ( "k8s.io/klog/v2" openapicommon "k8s.io/kube-openapi/pkg/common" "k8s.io/kube-openapi/pkg/validation/spec" + "k8s.io/utils/clock" utilsnet "k8s.io/utils/net" // install apis @@ -135,8 +134,8 @@ type Config struct { Version *version.Info // AuditBackend is where audit events are sent to. AuditBackend audit.Backend - // AuditPolicyChecker makes the decision of whether and how to audit log a request. - AuditPolicyChecker auditpolicy.Checker + // AuditPolicyRuleEvaluator makes the decision of whether and how to audit log a request. + AuditPolicyRuleEvaluator audit.PolicyRuleEvaluator // ExternalAddress is the host name to use for external (public internet) facing URLs (e.g. Swagger) // Will default to a value based on secure serving info and available ipv4 IPs. ExternalAddress string @@ -222,14 +221,24 @@ type Config struct { // If not specify any in flags, then genericapiserver will only enable defaultAPIResourceConfig. MergedResourceConfig *serverstore.ResourceConfig - // RequestWidthEstimator is used to estimate the "width" of the incoming request(s). - RequestWidthEstimator flowcontrolrequest.WidthEstimatorFunc - // lifecycleSignals provides access to the various signals // that happen during lifecycle of the apiserver. // it's intentionally marked private as it should never be overridden. lifecycleSignals lifecycleSignals + // StorageObjectCountTracker is used to keep track of the total number of objects + // in the storage per resource, so we can estimate width of incoming requests. + StorageObjectCountTracker flowcontrolrequest.StorageObjectCountTracker + + // ShutdownSendRetryAfter dictates when to initiate shutdown of the HTTP + // Server during the graceful termination of the apiserver. If true, we wait + // for non longrunning requests in flight to be drained and then initiate a + // shutdown of the HTTP Server. If false, we initiate a shutdown of the HTTP + // Server as soon as ShutdownDelayDuration has elapsed. + // If enabled, after ShutdownDelayDuration elapses, any incoming request is + // rejected with a 429 status code and a 'Retry-After' response. + ShutdownSendRetryAfter bool + //=========================================================================== // values below here are targets for removal //=========================================================================== @@ -315,6 +324,8 @@ func NewConfig(codecs serializer.CodecFactory) *Config { if feature.DefaultFeatureGate.Enabled(features.APIServerIdentity) { id = "kube-apiserver-" + uuid.New().String() } + lifecycleSignals := newLifecycleSignals() + return &Config{ Serializer: codecs, BuildHandlerChainFunc: DefaultBuildHandlerChain, @@ -352,9 +363,9 @@ func NewConfig(codecs serializer.CodecFactory) *Config { // Default to treating watch as a long-running operation // Generic API servers have no inherent long-running subresources - LongRunningFunc: genericfilters.BasicLongRunningRequestCheck(sets.NewString("watch"), sets.NewString()), - RequestWidthEstimator: flowcontrolrequest.DefaultWidthEstimator, - lifecycleSignals: newLifecycleSignals(), + LongRunningFunc: genericfilters.BasicLongRunningRequestCheck(sets.NewString("watch"), sets.NewString()), + lifecycleSignals: lifecycleSignals, + StorageObjectCountTracker: flowcontrolrequest.NewStorageObjectCountTracker(lifecycleSignals.ShutdownInitiated.Signaled()), APIServerID: id, StorageVersionManager: storageversion.NewDefaultManager(), @@ -567,6 +578,7 @@ func (c completedConfig) New(name string, delegationTarget DelegationTarget) (*G handlerChainBuilder := func(handler http.Handler) http.Handler { return c.BuildHandlerChainFunc(handler, c.Config) } + apiServerHandler := NewAPIServerHandler(name, c.Serializer, handlerChainBuilder, delegationTarget.UnprotectedHandler()) s := &GenericAPIServer{ @@ -580,6 +592,9 @@ func (c completedConfig) New(name string, delegationTarget DelegationTarget) (*G delegationTarget: delegationTarget, EquivalentResourceRegistry: c.EquivalentResourceRegistry, HandlerChainWaitGroup: c.HandlerChainWaitGroup, + Handler: apiServerHandler, + + listedPathProvider: apiServerHandler, minRequestTimeout: time.Duration(c.MinRequestTimeout) * time.Second, ShutdownTimeout: c.RequestTimeout, @@ -587,10 +602,6 @@ func (c completedConfig) New(name string, delegationTarget DelegationTarget) (*G SecureServingInfo: c.SecureServing, ExternalAddress: c.ExternalAddress, - Handler: apiServerHandler, - - listedPathProvider: apiServerHandler, - openAPIConfig: c.OpenAPIConfig, skipOpenAPIInstallation: c.SkipOpenAPIInstallation, @@ -608,12 +619,15 @@ func (c completedConfig) New(name string, delegationTarget DelegationTarget) (*G maxRequestBodyBytes: c.MaxRequestBodyBytes, livezClock: clock.RealClock{}, - lifecycleSignals: c.lifecycleSignals, + lifecycleSignals: c.lifecycleSignals, + ShutdownSendRetryAfter: c.ShutdownSendRetryAfter, APIServerID: c.APIServerID, StorageVersionManager: c.StorageVersionManager, Version: c.Version, + + muxAndDiscoveryCompleteSignals: map[string]<-chan struct{}{}, } for { @@ -645,6 +659,13 @@ func (c completedConfig) New(name string, delegationTarget DelegationTarget) (*G } } + // register mux signals from the delegated server + for k, v := range delegationTarget.MuxAndDiscoveryCompleteSignals() { + if err := s.RegisterMuxAndDiscoveryCompleteSignal(k, v); err != nil { + return nil, err + } + } + genericApiServerHookName := "generic-apiserver-start-informers" if c.SharedInformerFactory != nil { if !s.isPostStartHookRegistered(genericApiServerHookName) { @@ -741,13 +762,15 @@ func BuildHandlerChainWithStorageVersionPrecondition(apiHandler http.Handler, c } func DefaultBuildHandlerChain(apiHandler http.Handler, c *Config) http.Handler { - handler := filterlatency.TrackCompleted(apiHandler) + handler := genericapifilters.WithWebhookDuration(apiHandler) + handler = filterlatency.TrackCompleted(handler) handler = genericapifilters.WithAuthorization(handler, c.Authorization.Authorizer, c.Serializer) handler = filterlatency.TrackStarted(handler, "authorization") if c.FlowControl != nil { + requestWorkEstimator := flowcontrolrequest.NewWorkEstimator(c.StorageObjectCountTracker.Get, c.FlowControl.GetInterestedWatchCount) handler = filterlatency.TrackCompleted(handler) - handler = genericfilters.WithPriorityAndFairness(handler, c.LongRunningFunc, c.FlowControl, c.RequestWidthEstimator) + handler = genericfilters.WithPriorityAndFairness(handler, c.LongRunningFunc, c.FlowControl, requestWorkEstimator) handler = filterlatency.TrackStarted(handler, "priorityandfairness") } else { handler = genericfilters.WithMaxInFlightLimit(handler, c.MaxRequestsInFlight, c.MaxMutatingRequestsInFlight, c.LongRunningFunc) @@ -758,11 +781,11 @@ func DefaultBuildHandlerChain(apiHandler http.Handler, c *Config) http.Handler { handler = filterlatency.TrackStarted(handler, "impersonation") handler = filterlatency.TrackCompleted(handler) - handler = genericapifilters.WithAudit(handler, c.AuditBackend, c.AuditPolicyChecker, c.LongRunningFunc) + handler = genericapifilters.WithAudit(handler, c.AuditBackend, c.AuditPolicyRuleEvaluator, c.LongRunningFunc) handler = filterlatency.TrackStarted(handler, "audit") failedHandler := genericapifilters.Unauthorized(c.Serializer) - failedHandler = genericapifilters.WithFailedAuthenticationAudit(failedHandler, c.AuditBackend, c.AuditPolicyChecker) + failedHandler = genericapifilters.WithFailedAuthenticationAudit(failedHandler, c.AuditBackend, c.AuditPolicyRuleEvaluator) failedHandler = filterlatency.TrackCompleted(failedHandler) handler = filterlatency.TrackCompleted(handler) @@ -775,22 +798,26 @@ func DefaultBuildHandlerChain(apiHandler http.Handler, c *Config) http.Handler { // context with deadline. The go-routine can keep running, while the timeout logic will return a timeout to the client. handler = genericfilters.WithTimeoutForNonLongRunningRequests(handler, c.LongRunningFunc) - handler = genericapifilters.WithRequestDeadline(handler, c.AuditBackend, c.AuditPolicyChecker, + handler = genericapifilters.WithRequestDeadline(handler, c.AuditBackend, c.AuditPolicyRuleEvaluator, c.LongRunningFunc, c.Serializer, c.RequestTimeout) handler = genericfilters.WithWaitGroup(handler, c.LongRunningFunc, c.HandlerChainWaitGroup) if c.SecureServing != nil && !c.SecureServing.DisableHTTP2 && c.GoawayChance > 0 { handler = genericfilters.WithProbabilisticGoaway(handler, c.GoawayChance) } - handler = genericapifilters.WithAuditAnnotations(handler, c.AuditBackend, c.AuditPolicyChecker) + handler = genericapifilters.WithAuditAnnotations(handler, c.AuditBackend, c.AuditPolicyRuleEvaluator) handler = genericapifilters.WithWarningRecorder(handler) handler = genericapifilters.WithCacheControl(handler) handler = genericfilters.WithHSTS(handler, c.HSTSDirectives) + if c.ShutdownSendRetryAfter { + handler = genericfilters.WithRetryAfter(handler, c.lifecycleSignals.AfterShutdownDelayDuration.Signaled()) + } handler = genericfilters.WithHTTPLogging(handler) if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.APIServerTracing) { handler = genericapifilters.WithTracing(handler, c.TracerProvider) } handler = genericapifilters.WithRequestInfo(handler, c.RequestInfoResolver) handler = genericapifilters.WithRequestReceivedTimestamp(handler) + handler = genericapifilters.WithMuxAndDiscoveryComplete(handler, c.lifecycleSignals.MuxAndDiscoveryComplete.Signaled()) handler = genericfilters.WithPanicRecovery(handler, c.RequestInfoResolver) handler = genericapifilters.WithAuditID(handler) return handler diff --git a/vendor/k8s.io/apiserver/pkg/server/deleted_kinds.go b/vendor/k8s.io/apiserver/pkg/server/deleted_kinds.go index f9735a8393..ab10774cbe 100644 --- a/vendor/k8s.io/apiserver/pkg/server/deleted_kinds.go +++ b/vendor/k8s.io/apiserver/pkg/server/deleted_kinds.go @@ -54,10 +54,7 @@ type ResourceExpirationEvaluator interface { } func NewResourceExpirationEvaluator(currentVersion apimachineryversion.Info) (ResourceExpirationEvaluator, error) { - ret := &resourceExpirationEvaluator{ - // TODO https://github.com/kubernetes/kubernetes/issues/101951 set this back to false after beta is tagged. - strictRemovedHandlingInAlpha: true, - } + ret := &resourceExpirationEvaluator{} if len(currentVersion.Major) > 0 { currentMajor64, err := strconv.ParseInt(currentVersion.Major, 10, 32) if err != nil { diff --git a/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_cafile_content.go b/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_cafile_content.go index 15f3c1dad1..fb1515c182 100644 --- a/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_cafile_content.go +++ b/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_cafile_content.go @@ -24,6 +24,7 @@ import ( "sync/atomic" "time" + "github.com/fsnotify/fsnotify" "k8s.io/client-go/util/cert" utilruntime "k8s.io/apimachinery/pkg/util/runtime" @@ -44,7 +45,7 @@ type ControllerRunner interface { Run(workers int, stopCh <-chan struct{}) } -// DynamicFileCAContent provies a CAContentProvider that can dynamically react to new file content +// DynamicFileCAContent provides a CAContentProvider that can dynamically react to new file content // It also fulfills the authenticator interface to provide verifyoptions type DynamicFileCAContent struct { name string @@ -147,7 +148,7 @@ func (c *DynamicFileCAContent) RunOnce() error { return c.loadCABundle() } -// Run starts the kube-apiserver and blocks until stopCh is closed. +// Run starts the controller and blocks until stopCh is closed. func (c *DynamicFileCAContent) Run(workers int, stopCh <-chan struct{}) { defer utilruntime.HandleCrash() defer c.queue.ShutDown() @@ -158,17 +159,62 @@ func (c *DynamicFileCAContent) Run(workers int, stopCh <-chan struct{}) { // doesn't matter what workers say, only start one. go wait.Until(c.runWorker, time.Second, stopCh) - // start timer that rechecks every minute, just in case. this also serves to prime the controller quickly. - go wait.PollImmediateUntil(FileRefreshDuration, func() (bool, error) { - c.queue.Add(workItemKey) - return false, nil - }, stopCh) - - // TODO this can be wired to an fsnotifier as well. + // start the loop that watches the CA file until stopCh is closed. + go wait.Until(func() { + if err := c.watchCAFile(stopCh); err != nil { + klog.ErrorS(err, "Failed to watch CA file, will retry later") + } + }, time.Minute, stopCh) <-stopCh } +func (c *DynamicFileCAContent) watchCAFile(stopCh <-chan struct{}) error { + // Trigger a check here to ensure the content will be checked periodically even if the following watch fails. + c.queue.Add(workItemKey) + + w, err := fsnotify.NewWatcher() + if err != nil { + return fmt.Errorf("error creating fsnotify watcher: %v", err) + } + defer w.Close() + + if err = w.Add(c.filename); err != nil { + return fmt.Errorf("error adding watch for file %s: %v", c.filename, err) + } + // Trigger a check in case the file is updated before the watch starts. + c.queue.Add(workItemKey) + + for { + select { + case e := <-w.Events: + if err := c.handleWatchEvent(e, w); err != nil { + return err + } + case err := <-w.Errors: + return fmt.Errorf("received fsnotify error: %v", err) + case <-stopCh: + return nil + } + } +} + +// handleWatchEvent triggers reloading the CA file, and restarts a new watch if it's a Remove or Rename event. +func (c *DynamicFileCAContent) handleWatchEvent(e fsnotify.Event, w *fsnotify.Watcher) error { + // This should be executed after restarting the watch (if applicable) to ensure no file event will be missing. + defer c.queue.Add(workItemKey) + if e.Op&(fsnotify.Remove|fsnotify.Rename) == 0 { + return nil + } + if err := w.Remove(c.filename); err != nil { + klog.InfoS("Failed to remove file watch, it may have been deleted", "file", c.filename, "err", err) + } + if err := w.Add(c.filename); err != nil { + return fmt.Errorf("error adding watch for file %s: %v", c.filename, err) + } + return nil +} + func (c *DynamicFileCAContent) runWorker() { for c.processNextWorkItem() { } diff --git a/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_serving_content.go b/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_serving_content.go index de79fb58f5..00117176b0 100644 --- a/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_serving_content.go +++ b/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_serving_content.go @@ -23,6 +23,8 @@ import ( "sync/atomic" "time" + "github.com/fsnotify/fsnotify" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/util/workqueue" @@ -38,7 +40,7 @@ type DynamicCertKeyPairContent struct { // keyFile is the name of the key file to read. keyFile string - // servingCert is a certKeyContent that contains the last read, non-zero length content of the key and cert + // certKeyPair is a certKeyContent that contains the last read, non-zero length content of the key and cert certKeyPair atomic.Value listeners []Listener @@ -75,7 +77,7 @@ func (c *DynamicCertKeyPairContent) AddListener(listener Listener) { c.listeners = append(c.listeners, listener) } -// loadServingCert determines the next set of content for the file. +// loadCertKeyPair determines the next set of content for the file. func (c *DynamicCertKeyPairContent) loadCertKeyPair() error { cert, err := ioutil.ReadFile(c.certFile) if err != nil { @@ -132,17 +134,68 @@ func (c *DynamicCertKeyPairContent) Run(workers int, stopCh <-chan struct{}) { // doesn't matter what workers say, only start one. go wait.Until(c.runWorker, time.Second, stopCh) - // start timer that rechecks every minute, just in case. this also serves to prime the controller quickly. - go wait.PollImmediateUntil(FileRefreshDuration, func() (bool, error) { - c.queue.Add(workItemKey) - return false, nil - }, stopCh) - - // TODO this can be wired to an fsnotifier as well. + // start the loop that watches the cert and key files until stopCh is closed. + go wait.Until(func() { + if err := c.watchCertKeyFile(stopCh); err != nil { + klog.ErrorS(err, "Failed to watch cert and key file, will retry later") + } + }, time.Minute, stopCh) <-stopCh } +func (c *DynamicCertKeyPairContent) watchCertKeyFile(stopCh <-chan struct{}) error { + // Trigger a check here to ensure the content will be checked periodically even if the following watch fails. + c.queue.Add(workItemKey) + + w, err := fsnotify.NewWatcher() + if err != nil { + return fmt.Errorf("error creating fsnotify watcher: %v", err) + } + defer w.Close() + + if err := w.Add(c.certFile); err != nil { + return fmt.Errorf("error adding watch for file %s: %v", c.certFile, err) + } + if err := w.Add(c.keyFile); err != nil { + return fmt.Errorf("error adding watch for file %s: %v", c.keyFile, err) + } + // Trigger a check in case the file is updated before the watch starts. + c.queue.Add(workItemKey) + + for { + select { + case e := <-w.Events: + if err := c.handleWatchEvent(e, w); err != nil { + return err + } + case err := <-w.Errors: + return fmt.Errorf("received fsnotify error: %v", err) + case <-stopCh: + return nil + } + } +} + +// handleWatchEvent triggers reloading the cert and key file, and restarts a new watch if it's a Remove or Rename event. +// If one file is updated before the other, the loadCertKeyPair method will catch the mismatch and will not apply the +// change. When an event of the other file is received, it will trigger reloading the files again and the new content +// will be loaded and used. +func (c *DynamicCertKeyPairContent) handleWatchEvent(e fsnotify.Event, w *fsnotify.Watcher) error { + // This should be executed after restarting the watch (if applicable) to ensure no file event will be missing. + defer c.queue.Add(workItemKey) + if e.Op&(fsnotify.Remove|fsnotify.Rename) == 0 { + return nil + } + if err := w.Remove(e.Name); err != nil { + klog.InfoS("Failed to remove file watch, it may have been deleted", "file", e.Name, "err", err) + } + if err := w.Add(e.Name); err != nil { + return fmt.Errorf("error adding watch for file %s: %v", e.Name, err) + } + return nil +} + func (c *DynamicCertKeyPairContent) runWorker() { for c.processNextWorkItem() { } diff --git a/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/named_certificates.go b/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/named_certificates.go index ee0aa8de0f..e8be133c02 100644 --- a/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/named_certificates.go +++ b/vendor/k8s.io/apiserver/pkg/server/dynamiccertificates/named_certificates.go @@ -20,12 +20,12 @@ import ( "crypto/tls" "crypto/x509" "fmt" - "net" "strings" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/util/validation" "k8s.io/klog/v2" + netutils "k8s.io/utils/net" ) // BuildNamedCertificates returns a map of *tls.Certificate by name. It's @@ -77,7 +77,7 @@ func getCertificateNames(cert *x509.Certificate) []string { var names []string cn := cert.Subject.CommonName - cnIsIP := net.ParseIP(cn) != nil + cnIsIP := netutils.ParseIPSloppy(cn) != nil cnIsValidDomain := cn == "*" || len(validation.IsDNS1123Subdomain(strings.TrimPrefix(cn, "*."))) == 0 // don't use the CN if it is a valid IP because our IP serving detection may unexpectedly use it to terminate the connection. if !cnIsIP && cnIsValidDomain { diff --git a/vendor/k8s.io/apiserver/pkg/server/egressselector/config.go b/vendor/k8s.io/apiserver/pkg/server/egressselector/config.go index b7e378e430..2df786e13f 100644 --- a/vendor/k8s.io/apiserver/pkg/server/egressselector/config.go +++ b/vendor/k8s.io/apiserver/pkg/server/egressselector/config.go @@ -34,8 +34,7 @@ import ( var cfgScheme = runtime.NewScheme() // validEgressSelectorNames contains the set of valid egress selctor names. -// 'master' is deprecated in favor of 'controlplane' and will be removed in v1.22. -var validEgressSelectorNames = sets.NewString("master", "controlplane", "cluster", "etcd") +var validEgressSelectorNames = sets.NewString("controlplane", "cluster", "etcd") func init() { install.Install(cfgScheme) @@ -103,29 +102,23 @@ func ValidateEgressSelectorConfiguration(config *apiserver.EgressSelectorConfigu } } - var foundControlPlane, foundMaster bool - for _, service := range config.EgressSelections { + seen := sets.String{} + for i, service := range config.EgressSelections { canonicalName := strings.ToLower(service.Name) - - if !validEgressSelectorNames.Has(canonicalName) { - allErrs = append(allErrs, field.NotSupported(field.NewPath("egressSelection", "name"), canonicalName, validEgressSelectorNames.List())) + fldPath := field.NewPath("service", "connection") + // no duplicate check + if seen.Has(canonicalName) { + allErrs = append(allErrs, field.Duplicate(fldPath.Index(i), canonicalName)) continue } + seen.Insert(canonicalName) - if canonicalName == "master" { - foundMaster = true - } - - if canonicalName == "controlplane" { - foundControlPlane = true + if !validEgressSelectorNames.Has(canonicalName) { + allErrs = append(allErrs, field.NotSupported(fldPath, canonicalName, validEgressSelectorNames.List())) + continue } } - // error if both master and controlplane egress selectors are set - if foundMaster && foundControlPlane { - allErrs = append(allErrs, field.Forbidden(field.NewPath("egressSelection", "name"), "both egressSelection names 'master' and 'controlplane' are specified, only one is allowed")) - } - return allErrs } diff --git a/vendor/k8s.io/apiserver/pkg/server/egressselector/egress_selector.go b/vendor/k8s.io/apiserver/pkg/server/egressselector/egress_selector.go index 7e0185001c..9da0e2a099 100644 --- a/vendor/k8s.io/apiserver/pkg/server/egressselector/egress_selector.go +++ b/vendor/k8s.io/apiserver/pkg/server/egressselector/egress_selector.go @@ -91,10 +91,6 @@ func (s EgressType) AsNetworkContext() NetworkContext { func lookupServiceName(name string) (EgressType, error) { switch strings.ToLower(name) { - // 'master' is deprecated, interpret "master" as controlplane internally until removed in v1.22. - case "master": - klog.Warning("EgressSelection name 'master' is deprecated, use 'controlplane' instead") - return ControlPlane, nil case "controlplane": return ControlPlane, nil case "etcd": @@ -362,6 +358,16 @@ func NewEgressSelector(config *apiserver.EgressSelectorConfiguration) (*EgressSe return cs, nil } +// NewEgressSelectorWithMap returns a EgressSelector with the supplied EgressType to DialFunc map. +func NewEgressSelectorWithMap(m map[EgressType]utilnet.DialFunc) *EgressSelector { + if m == nil { + m = make(map[EgressType]utilnet.DialFunc) + } + return &EgressSelector{ + egressToDialer: m, + } +} + // Lookup gets the dialer function for the network context. // This is configured for the Kubernetes API Server at startup. func (cs *EgressSelector) Lookup(networkContext NetworkContext) (utilnet.DialFunc, error) { diff --git a/vendor/k8s.io/apiserver/pkg/server/egressselector/metrics/metrics.go b/vendor/k8s.io/apiserver/pkg/server/egressselector/metrics/metrics.go index 04ad61c4fd..af38461818 100644 --- a/vendor/k8s.io/apiserver/pkg/server/egressselector/metrics/metrics.go +++ b/vendor/k8s.io/apiserver/pkg/server/egressselector/metrics/metrics.go @@ -19,9 +19,9 @@ package metrics import ( "time" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/component-base/metrics" "k8s.io/component-base/metrics/legacyregistry" + "k8s.io/utils/clock" ) const ( diff --git a/vendor/k8s.io/apiserver/pkg/server/filters/maxinflight.go b/vendor/k8s.io/apiserver/pkg/server/filters/maxinflight.go index 70c8d8b855..71d8a534bb 100644 --- a/vendor/k8s.io/apiserver/pkg/server/filters/maxinflight.go +++ b/vendor/k8s.io/apiserver/pkg/server/filters/maxinflight.go @@ -61,13 +61,13 @@ func handleError(w http.ResponseWriter, r *http.Request, err error) { // requestWatermark is used to track maximal numbers of requests in a particular phase of handling type requestWatermark struct { phase string - readOnlyObserver, mutatingObserver fcmetrics.TimedObserver + readOnlyObserver, mutatingObserver fcmetrics.RatioedChangeObserver lock sync.Mutex readOnlyWatermark, mutatingWatermark int } func (w *requestWatermark) recordMutating(mutatingVal int) { - w.mutatingObserver.Set(float64(mutatingVal)) + w.mutatingObserver.Observe(float64(mutatingVal)) w.lock.Lock() defer w.lock.Unlock() @@ -78,7 +78,7 @@ func (w *requestWatermark) recordMutating(mutatingVal int) { } func (w *requestWatermark) recordReadOnly(readOnlyVal int) { - w.readOnlyObserver.Set(float64(readOnlyVal)) + w.readOnlyObserver.Observe(float64(readOnlyVal)) w.lock.Lock() defer w.lock.Unlock() @@ -132,11 +132,11 @@ func WithMaxInFlightLimit( var mutatingChan chan bool if nonMutatingLimit != 0 { nonMutatingChan = make(chan bool, nonMutatingLimit) - watermark.readOnlyObserver.SetX1(float64(nonMutatingLimit)) + watermark.readOnlyObserver.SetDenominator(float64(nonMutatingLimit)) } if mutatingLimit != 0 { mutatingChan = make(chan bool, mutatingLimit) - watermark.mutatingObserver.SetX1(float64(mutatingLimit)) + watermark.mutatingObserver.SetDenominator(float64(mutatingLimit)) } return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { diff --git a/vendor/k8s.io/apiserver/pkg/server/filters/priority-and-fairness.go b/vendor/k8s.io/apiserver/pkg/server/filters/priority-and-fairness.go index c89cbbd86a..8b95021c74 100644 --- a/vendor/k8s.io/apiserver/pkg/server/filters/priority-and-fairness.go +++ b/vendor/k8s.io/apiserver/pkg/server/filters/priority-and-fairness.go @@ -22,11 +22,13 @@ import ( "net/http" "runtime" "sync/atomic" + "time" - flowcontrol "k8s.io/api/flowcontrol/v1beta1" + flowcontrol "k8s.io/api/flowcontrol/v1beta2" apitypes "k8s.io/apimachinery/pkg/types" epmetrics "k8s.io/apiserver/pkg/endpoints/metrics" apirequest "k8s.io/apiserver/pkg/endpoints/request" + "k8s.io/apiserver/pkg/server/httplog" utilflowcontrol "k8s.io/apiserver/pkg/util/flowcontrol" fcmetrics "k8s.io/apiserver/pkg/util/flowcontrol/metrics" flowcontrolrequest "k8s.io/apiserver/pkg/util/flowcontrol/request" @@ -55,13 +57,22 @@ var atomicMutatingWaiting, atomicReadOnlyWaiting int32 // newInitializationSignal is defined for testing purposes. var newInitializationSignal = utilflowcontrol.NewInitializationSignal +func truncateLogField(s string) string { + const maxFieldLogLength = 64 + + if len(s) > maxFieldLogLength { + s = s[0:maxFieldLogLength] + } + return s +} + // WithPriorityAndFairness limits the number of in-flight // requests in a fine-grained way. func WithPriorityAndFairness( handler http.Handler, longRunningRequestCheck apirequest.LongRunningRequestCheck, fcIfc utilflowcontrol.Interface, - widthEstimator flowcontrolrequest.WidthEstimatorFunc, + workEstimator flowcontrolrequest.WorkEstimatorFunc, ) http.Handler { if fcIfc == nil { klog.Warningf("priority and fairness support not found, skipping") @@ -90,12 +101,17 @@ func WithPriorityAndFairness( } var classification *PriorityAndFairnessClassification - note := func(fs *flowcontrol.FlowSchema, pl *flowcontrol.PriorityLevelConfiguration) { + estimateWork := func(fs *flowcontrol.FlowSchema, pl *flowcontrol.PriorityLevelConfiguration, flowDistinguisher string) flowcontrolrequest.WorkEstimate { classification = &PriorityAndFairnessClassification{ FlowSchemaName: fs.Name, FlowSchemaUID: fs.UID, PriorityLevelName: pl.Name, PriorityLevelUID: pl.UID} + + httplog.AddKeyValue(ctx, "apf_pl", truncateLogField(pl.Name)) + httplog.AddKeyValue(ctx, "apf_fs", truncateLogField(fs.Name)) + httplog.AddKeyValue(ctx, "apf_fd", truncateLogField(flowDistinguisher)) + return workEstimator(r, fs.Name, pl.Name) } var served bool @@ -122,11 +138,10 @@ func WithPriorityAndFairness( } } - // find the estimated "width" of the request - // TODO: Maybe just make it costEstimator and let it return additionalLatency too for the watch? - // TODO: Estimate cost should also take fcIfc.GetWatchCount(requestInfo) as a parameter. - width := widthEstimator.EstimateWidth(r) - digest := utilflowcontrol.RequestDigest{RequestInfo: requestInfo, User: user, Width: width} + digest := utilflowcontrol.RequestDigest{ + RequestInfo: requestInfo, + User: user, + } if isWatchRequest { // This channel blocks calling handler.ServeHTTP() until closed, and is closed inside execute(). @@ -159,12 +174,16 @@ func WithPriorityAndFairness( }() execute := func() { + startedAt := time.Now() + defer func() { + httplog.AddKeyValue(ctx, "apf_init_latency", time.Since(startedAt)) + }() noteExecutingDelta(1) defer noteExecutingDelta(-1) served = true setResponseHeaders(classification, w) - forgetWatch = fcIfc.RegisterWatch(requestInfo) + forgetWatch = fcIfc.RegisterWatch(r) // Notify the main thread that we're ready to start the watch. close(shouldStartWatchCh) @@ -216,7 +235,7 @@ func WithPriorityAndFairness( // Note that Handle will return irrespective of whether the request // executes or is rejected. In the latter case, the function will return // without calling the passed `execute` function. - fcIfc.Handle(handleCtx, digest, note, queueNote, execute) + fcIfc.Handle(handleCtx, digest, estimateWork, queueNote, execute) }() select { @@ -247,7 +266,7 @@ func WithPriorityAndFairness( handler.ServeHTTP(w, r) } - fcIfc.Handle(ctx, digest, note, queueNote, execute) + fcIfc.Handle(ctx, digest, estimateWork, queueNote, execute) } if !served { diff --git a/vendor/k8s.io/apiserver/pkg/server/filters/timeout.go b/vendor/k8s.io/apiserver/pkg/server/filters/timeout.go index 69e4fd4f21..7487fbf1ec 100644 --- a/vendor/k8s.io/apiserver/pkg/server/filters/timeout.go +++ b/vendor/k8s.io/apiserver/pkg/server/filters/timeout.go @@ -30,6 +30,7 @@ import ( utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apiserver/pkg/endpoints/metrics" apirequest "k8s.io/apiserver/pkg/endpoints/request" + "k8s.io/apiserver/pkg/endpoints/responsewriter" ) // WithTimeoutForNonLongRunningRequests times out non-long-running requests after the time given by timeout. @@ -90,7 +91,8 @@ func (t *timeoutHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { // resultCh is used as both errCh and stopCh resultCh := make(chan interface{}) - tw := newTimeoutWriter(w) + var tw timeoutWriter + tw, w = newTimeoutWriter(w) go func() { defer func() { err := recover() @@ -105,7 +107,7 @@ func (t *timeoutHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { } resultCh <- err }() - t.handler.ServeHTTP(tw, r) + t.handler.ServeHTTP(w, r) }() select { case err := <-resultCh: @@ -146,24 +148,16 @@ type timeoutWriter interface { timeout(*apierrors.StatusError) } -func newTimeoutWriter(w http.ResponseWriter) timeoutWriter { +func newTimeoutWriter(w http.ResponseWriter) (timeoutWriter, http.ResponseWriter) { base := &baseTimeoutWriter{w: w} + wrapped := responsewriter.WrapForHTTP1Or2(base) - _, notifiable := w.(http.CloseNotifier) - _, hijackable := w.(http.Hijacker) - - switch { - case notifiable && hijackable: - return &closeHijackTimeoutWriter{base} - case notifiable: - return &closeTimeoutWriter{base} - case hijackable: - return &hijackTimeoutWriter{base} - default: - return base - } + return base, wrapped } +var _ http.ResponseWriter = &baseTimeoutWriter{} +var _ responsewriter.UserProvidedDecorator = &baseTimeoutWriter{} + type baseTimeoutWriter struct { w http.ResponseWriter @@ -176,6 +170,10 @@ type baseTimeoutWriter struct { hijacked bool } +func (tw *baseTimeoutWriter) Unwrap() http.ResponseWriter { + return tw.w +} + func (tw *baseTimeoutWriter) Header() http.Header { tw.mu.Lock() defer tw.mu.Unlock() @@ -210,9 +208,9 @@ func (tw *baseTimeoutWriter) Flush() { return } - if flusher, ok := tw.w.(http.Flusher); ok { - flusher.Flush() - } + // the outer ResponseWriter object returned by WrapForHTTP1Or2 implements + // http.Flusher if the inner object (tw.w) implements http.Flusher. + tw.w.(http.Flusher).Flush() } func (tw *baseTimeoutWriter) WriteHeader(code int) { @@ -259,7 +257,7 @@ func (tw *baseTimeoutWriter) timeout(err *apierrors.StatusError) { } } -func (tw *baseTimeoutWriter) closeNotify() <-chan bool { +func (tw *baseTimeoutWriter) CloseNotify() <-chan bool { tw.mu.Lock() defer tw.mu.Unlock() @@ -269,47 +267,24 @@ func (tw *baseTimeoutWriter) closeNotify() <-chan bool { return done } + // the outer ResponseWriter object returned by WrapForHTTP1Or2 implements + // http.CloseNotifier if the inner object (tw.w) implements http.CloseNotifier. return tw.w.(http.CloseNotifier).CloseNotify() } -func (tw *baseTimeoutWriter) hijack() (net.Conn, *bufio.ReadWriter, error) { +func (tw *baseTimeoutWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { tw.mu.Lock() defer tw.mu.Unlock() if tw.timedOut { return nil, nil, http.ErrHandlerTimeout } + + // the outer ResponseWriter object returned by WrapForHTTP1Or2 implements + // http.Hijacker if the inner object (tw.w) implements http.Hijacker. conn, rw, err := tw.w.(http.Hijacker).Hijack() if err == nil { tw.hijacked = true } return conn, rw, err } - -type closeTimeoutWriter struct { - *baseTimeoutWriter -} - -func (tw *closeTimeoutWriter) CloseNotify() <-chan bool { - return tw.closeNotify() -} - -type hijackTimeoutWriter struct { - *baseTimeoutWriter -} - -func (tw *hijackTimeoutWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { - return tw.hijack() -} - -type closeHijackTimeoutWriter struct { - *baseTimeoutWriter -} - -func (tw *closeHijackTimeoutWriter) CloseNotify() <-chan bool { - return tw.closeNotify() -} - -func (tw *closeHijackTimeoutWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { - return tw.hijack() -} diff --git a/vendor/k8s.io/apiserver/pkg/server/filters/waitgroup.go b/vendor/k8s.io/apiserver/pkg/server/filters/waitgroup.go index 857ce18830..70b32c7669 100644 --- a/vendor/k8s.io/apiserver/pkg/server/filters/waitgroup.go +++ b/vendor/k8s.io/apiserver/pkg/server/filters/waitgroup.go @@ -32,6 +32,12 @@ import ( // WithWaitGroup adds all non long-running requests to wait group, which is used for graceful shutdown. func WithWaitGroup(handler http.Handler, longRunning apirequest.LongRunningRequestCheck, wg *utilwaitgroup.SafeWaitGroup) http.Handler { + // NOTE: both WithWaitGroup and WithRetryAfter must use the same exact isRequestExemptFunc 'isRequestExemptFromRetryAfter, + // otherwise SafeWaitGroup might wait indefinitely and will prevent the server from shutting down gracefully. + return withWaitGroup(handler, longRunning, wg, isRequestExemptFromRetryAfter) +} + +func withWaitGroup(handler http.Handler, longRunning apirequest.LongRunningRequestCheck, wg *utilwaitgroup.SafeWaitGroup, isRequestExemptFn isRequestExemptFunc) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { ctx := req.Context() requestInfo, ok := apirequest.RequestInfoFrom(ctx) @@ -41,21 +47,33 @@ func WithWaitGroup(handler http.Handler, longRunning apirequest.LongRunningReque return } - if !longRunning(req, requestInfo) { - if err := wg.Add(1); err != nil { - // When apiserver is shutting down, signal clients to retry - // There is a good chance the client hit a different server, so a tight retry is good for client responsiveness. - w.Header().Add("Retry-After", "1") - w.Header().Set("Content-Type", runtime.ContentTypeJSON) - w.Header().Set("X-Content-Type-Options", "nosniff") - statusErr := apierrors.NewServiceUnavailable("apiserver is shutting down").Status() - w.WriteHeader(int(statusErr.Code)) - fmt.Fprintln(w, runtime.EncodeOrDie(scheme.Codecs.LegacyCodec(v1.SchemeGroupVersion), &statusErr)) + if longRunning(req, requestInfo) { + handler.ServeHTTP(w, req) + return + } + + if err := wg.Add(1); err != nil { + // shutdown delay duration has elapsed and SafeWaitGroup.Wait has been invoked, + // this means 'WithRetryAfter' has started sending Retry-After response. + // we are going to exempt the same set of requests that WithRetryAfter are + // exempting from being rejected with a Retry-After response. + if isRequestExemptFn(req) { + handler.ServeHTTP(w, req) return } - defer wg.Done() + + // When apiserver is shutting down, signal clients to retry + // There is a good chance the client hit a different server, so a tight retry is good for client responsiveness. + w.Header().Add("Retry-After", "1") + w.Header().Set("Content-Type", runtime.ContentTypeJSON) + w.Header().Set("X-Content-Type-Options", "nosniff") + statusErr := apierrors.NewServiceUnavailable("apiserver is shutting down").Status() + w.WriteHeader(int(statusErr.Code)) + fmt.Fprintln(w, runtime.EncodeOrDie(scheme.Codecs.LegacyCodec(v1.SchemeGroupVersion), &statusErr)) + return } + defer wg.Done() handler.ServeHTTP(w, req) }) } diff --git a/vendor/k8s.io/apiserver/pkg/server/filters/with_retry_after.go b/vendor/k8s.io/apiserver/pkg/server/filters/with_retry_after.go new file mode 100644 index 0000000000..c5e2daa8ed --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/server/filters/with_retry_after.go @@ -0,0 +1,130 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package filters + +import ( + "net/http" + "strings" +) + +var ( + // health probes and metrics scraping are never rejected, we will continue + // serving these requests after shutdown delay duration elapses. + pathPrefixesExemptFromRetryAfter = []string{ + "/readyz", + "/livez", + "/healthz", + "/metrics", + } +) + +// isRequestExemptFunc returns true if the request should not be rejected, +// with a Retry-After response, otherwise it returns false. +type isRequestExemptFunc func(*http.Request) bool + +// retryAfterParams dictates how the Retry-After response is constructed +type retryAfterParams struct { + // TearDownConnection is true when we should send a 'Connection: close' + // header in the response so net/http can tear down the TCP connection. + TearDownConnection bool + + // Message describes why Retry-After response has been sent by the server + Message string +} + +// shouldRespondWithRetryAfterFunc returns true if the requests should +// be rejected with a Retry-After response once certain conditions are met. +// The retryAfterParams returned contains instructions on how to +// construct the Retry-After response. +type shouldRespondWithRetryAfterFunc func() (*retryAfterParams, bool) + +// WithRetryAfter rejects any incoming new request(s) with a 429 +// if the specified shutdownDelayDurationElapsedFn channel is closed +// +// It includes new request(s) on a new or an existing TCP connection +// Any new request(s) arriving after shutdownDelayDurationElapsedFn is closed +// are replied with a 429 and the following response headers: +// - 'Retry-After: N` (so client can retry after N seconds, hopefully on a new apiserver instance) +// - 'Connection: close': tear down the TCP connection +// +// TODO: is there a way to merge WithWaitGroup and this filter? +func WithRetryAfter(handler http.Handler, shutdownDelayDurationElapsedCh <-chan struct{}) http.Handler { + shutdownRetryAfterParams := &retryAfterParams{ + TearDownConnection: true, + Message: "The apiserver is shutting down, please try again later.", + } + + // NOTE: both WithRetryAfter and WithWaitGroup must use the same exact isRequestExemptFunc 'isRequestExemptFromRetryAfter, + // otherwise SafeWaitGroup might wait indefinitely and will prevent the server from shutting down gracefully. + return withRetryAfter(handler, isRequestExemptFromRetryAfter, func() (*retryAfterParams, bool) { + select { + case <-shutdownDelayDurationElapsedCh: + return shutdownRetryAfterParams, true + default: + return nil, false + } + }) +} + +func withRetryAfter(handler http.Handler, isRequestExemptFn isRequestExemptFunc, shouldRespondWithRetryAfterFn shouldRespondWithRetryAfterFunc) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + params, send := shouldRespondWithRetryAfterFn() + if !send || isRequestExemptFn(req) { + handler.ServeHTTP(w, req) + return + } + + // If we are here this means it's time to send Retry-After response + // + // Copied from net/http2 library + // "Connection" headers aren't allowed in HTTP/2 (RFC 7540, 8.1.2.2), + // but respect "Connection" == "close" to mean sending a GOAWAY and tearing + // down the TCP connection when idle, like we do for HTTP/1. + if params.TearDownConnection { + w.Header().Set("Connection", "close") + } + + // Return a 429 status asking the client to try again after 5 seconds + w.Header().Set("Retry-After", "5") + http.Error(w, params.Message, http.StatusTooManyRequests) + }) +} + +// isRequestExemptFromRetryAfter returns true if the given request should be exempt +// from being rejected with a 'Retry-After' response. +// NOTE: both 'WithRetryAfter' and 'WithWaitGroup' filters should use this function +// to exempt the set of requests from being rejected or tracked. +func isRequestExemptFromRetryAfter(r *http.Request) bool { + return isKubeApiserverUserAgent(r) || hasExemptPathPrefix(r) +} + +// isKubeApiserverUserAgent returns true if the user-agent matches +// the one set by the local loopback. +// NOTE: we can't look up the authenticated user informaion from the +// request context since the authentication filter has not executed yet. +func isKubeApiserverUserAgent(req *http.Request) bool { + return strings.HasPrefix(req.UserAgent(), "kube-apiserver/") +} + +func hasExemptPathPrefix(r *http.Request) bool { + for _, whiteListedPrefix := range pathPrefixesExemptFromRetryAfter { + if strings.HasPrefix(r.URL.Path, whiteListedPrefix) { + return true + } + } + return false +} diff --git a/vendor/k8s.io/apiserver/pkg/server/genericapiserver.go b/vendor/k8s.io/apiserver/pkg/server/genericapiserver.go index 5f4e8e348a..954c61756d 100644 --- a/vendor/k8s.io/apiserver/pkg/server/genericapiserver.go +++ b/vendor/k8s.io/apiserver/pkg/server/genericapiserver.go @@ -31,7 +31,6 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/runtime/serializer" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/sets" utilwaitgroup "k8s.io/apimachinery/pkg/util/waitgroup" "k8s.io/apimachinery/pkg/version" @@ -50,12 +49,14 @@ import ( utilopenapi "k8s.io/apiserver/pkg/util/openapi" restclient "k8s.io/client-go/rest" "k8s.io/klog/v2" - openapibuilder "k8s.io/kube-openapi/pkg/builder" + openapibuilder2 "k8s.io/kube-openapi/pkg/builder" openapicommon "k8s.io/kube-openapi/pkg/common" "k8s.io/kube-openapi/pkg/handler" + "k8s.io/kube-openapi/pkg/handler3" openapiutil "k8s.io/kube-openapi/pkg/util" openapiproto "k8s.io/kube-openapi/pkg/util/proto" "k8s.io/kube-openapi/pkg/validation/spec" + "k8s.io/utils/clock" ) // Info about an API group. @@ -144,6 +145,10 @@ type GenericAPIServer struct { // It is set during PrepareRun if `openAPIConfig` is non-nil unless `skipOpenAPIInstallation` is true. OpenAPIVersionedService *handler.OpenAPIService + // OpenAPIV3VersionedService controls the /openapi/v3 endpoint and can be used to update the served spec. + // It is set during PrepareRun if `openAPIConfig` is non-nil unless `skipOpenAPIInstallation` is true. + OpenAPIV3VersionedService *handler3.OpenAPIService + // StaticOpenAPISpec is the spec derived from the restful container endpoints. // It is set during PrepareRun. StaticOpenAPISpec *spec.Swagger @@ -213,6 +218,21 @@ type GenericAPIServer struct { // lifecycleSignals provides access to the various signals that happen during the life cycle of the apiserver. lifecycleSignals lifecycleSignals + + // muxAndDiscoveryCompleteSignals holds signals that indicate all known HTTP paths have been registered. + // it exists primarily to avoid returning a 404 response when a resource actually exists but we haven't installed the path to a handler. + // it is exposed for easier composition of the individual servers. + // the primary users of this field are the WithMuxCompleteProtection filter and the NotFoundHandler + muxAndDiscoveryCompleteSignals map[string]<-chan struct{} + + // ShutdownSendRetryAfter dictates when to initiate shutdown of the HTTP + // Server during the graceful termination of the apiserver. If true, we wait + // for non longrunning requests in flight to be drained and then initiate a + // shutdown of the HTTP Server. If false, we initiate a shutdown of the HTTP + // Server as soon as ShutdownDelayDuration has elapsed. + // If enabled, after ShutdownDelayDuration elapses, any incoming request is + // rejected with a 429 status code and a 'Retry-After' response. + ShutdownSendRetryAfter bool } // DelegationTarget is an interface which allows for composition of API servers with top level handling that works @@ -238,6 +258,9 @@ type DelegationTarget interface { // PrepareRun does post API installation setup steps. It calls recursively the same function of the delegates. PrepareRun() preparedGenericAPIServer + + // MuxAndDiscoveryCompleteSignals exposes registered signals that indicate if all known HTTP paths have been installed. + MuxAndDiscoveryCompleteSignals() map[string]<-chan struct{} } func (s *GenericAPIServer) UnprotectedHandler() http.Handler { @@ -261,15 +284,37 @@ func (s *GenericAPIServer) NextDelegate() DelegationTarget { return s.delegationTarget } +// RegisterMuxAndDiscoveryCompleteSignal registers the given signal that will be used to determine if all known +// HTTP paths have been registered. It is okay to call this method after instantiating the generic server but before running. +func (s *GenericAPIServer) RegisterMuxAndDiscoveryCompleteSignal(signalName string, signal <-chan struct{}) error { + if _, exists := s.muxAndDiscoveryCompleteSignals[signalName]; exists { + return fmt.Errorf("%s already registered", signalName) + } + s.muxAndDiscoveryCompleteSignals[signalName] = signal + return nil +} + +func (s *GenericAPIServer) MuxAndDiscoveryCompleteSignals() map[string]<-chan struct{} { + return s.muxAndDiscoveryCompleteSignals +} + type emptyDelegate struct { + // handler is called at the end of the delegation chain + // when a request has been made against an unregistered HTTP path the individual servers will simply pass it through until it reaches the handler. + handler http.Handler } func NewEmptyDelegate() DelegationTarget { return emptyDelegate{} } +// NewEmptyDelegateWithCustomHandler allows for registering a custom handler usually for special handling of 404 requests +func NewEmptyDelegateWithCustomHandler(handler http.Handler) DelegationTarget { + return emptyDelegate{handler} +} + func (s emptyDelegate) UnprotectedHandler() http.Handler { - return nil + return s.handler } func (s emptyDelegate) PostStartHooks() map[string]postStartHookEntry { return map[string]postStartHookEntry{} @@ -289,6 +334,9 @@ func (s emptyDelegate) NextDelegate() DelegationTarget { func (s emptyDelegate) PrepareRun() preparedGenericAPIServer { return preparedGenericAPIServer{nil} } +func (s emptyDelegate) MuxAndDiscoveryCompleteSignals() map[string]<-chan struct{} { + return map[string]<-chan struct{}{} +} // preparedGenericAPIServer is a private wrapper that enforces a call of PrepareRun() before Run can be invoked. type preparedGenericAPIServer struct { @@ -302,7 +350,12 @@ func (s *GenericAPIServer) PrepareRun() preparedGenericAPIServer { if s.openAPIConfig != nil && !s.skipOpenAPIInstallation { s.OpenAPIVersionedService, s.StaticOpenAPISpec = routes.OpenAPI{ Config: s.openAPIConfig, - }.Install(s.Handler.GoRestfulContainer, s.Handler.NonGoRestfulMux) + }.InstallV2(s.Handler.GoRestfulContainer, s.Handler.NonGoRestfulMux) + if utilfeature.DefaultFeatureGate.Enabled(features.OpenAPIV3) { + s.OpenAPIV3VersionedService = routes.OpenAPI{ + Config: s.openAPIConfig, + }.InstallV3(s.Handler.GoRestfulContainer, s.Handler.NonGoRestfulMux) + } } s.installHealthz() @@ -336,6 +389,23 @@ func (s preparedGenericAPIServer) Run(stopCh <-chan struct{}) error { delayedStopCh := s.lifecycleSignals.AfterShutdownDelayDuration shutdownInitiatedCh := s.lifecycleSignals.ShutdownInitiated + // spawn a new goroutine for closing the MuxAndDiscoveryComplete signal + // registration happens during construction of the generic api server + // the last server in the chain aggregates signals from the previous instances + go func() { + for _, muxAndDiscoveryCompletedSignal := range s.GenericAPIServer.MuxAndDiscoveryCompleteSignals() { + select { + case <-muxAndDiscoveryCompletedSignal: + continue + case <-stopCh: + klog.V(1).Infof("haven't completed %s, stop requested", s.lifecycleSignals.MuxAndDiscoveryComplete.Name()) + return + } + } + s.lifecycleSignals.MuxAndDiscoveryComplete.Signal() + klog.V(1).Infof("%s has all endpoints registered and discovery information is complete", s.lifecycleSignals.MuxAndDiscoveryComplete.Name()) + }() + go func() { defer delayedStopCh.Signal() defer klog.V(1).InfoS("[graceful-termination] shutdown event", "name", delayedStopCh.Name()) @@ -352,7 +422,22 @@ func (s preparedGenericAPIServer) Run(stopCh <-chan struct{}) error { }() // close socket after delayed stopCh - stoppedCh, listenerStoppedCh, err := s.NonBlockingRun(delayedStopCh.Signaled()) + drainedCh := s.lifecycleSignals.InFlightRequestsDrained + stopHttpServerCh := delayedStopCh.Signaled() + shutdownTimeout := s.ShutdownTimeout + if s.ShutdownSendRetryAfter { + // when this mode is enabled, we do the following: + // - the server will continue to listen until all existing requests in flight + // (not including active long runnning requests) have been drained. + // - once drained, http Server Shutdown is invoked with a timeout of 2s, + // net/http waits for 1s for the peer to respond to a GO_AWAY frame, so + // we should wait for a minimum of 2s + stopHttpServerCh = drainedCh.Signaled() + shutdownTimeout = 2 * time.Second + klog.V(1).InfoS("[graceful-termination] using HTTP Server shutdown timeout", "ShutdownTimeout", shutdownTimeout) + } + + stoppedCh, listenerStoppedCh, err := s.NonBlockingRun(stopHttpServerCh, shutdownTimeout) if err != nil { return err } @@ -363,7 +448,6 @@ func (s preparedGenericAPIServer) Run(stopCh <-chan struct{}) error { klog.V(1).InfoS("[graceful-termination] shutdown event", "name", httpServerStoppedListeningCh.Name()) }() - drainedCh := s.lifecycleSignals.InFlightRequestsDrained go func() { defer drainedCh.Signal() defer klog.V(1).InfoS("[graceful-termination] shutdown event", "name", drainedCh.Name()) @@ -397,7 +481,7 @@ func (s preparedGenericAPIServer) Run(stopCh <-chan struct{}) error { // NonBlockingRun spawns the secure http server. An error is // returned if the secure port cannot be listened on. // The returned channel is closed when the (asynchronous) termination is finished. -func (s preparedGenericAPIServer) NonBlockingRun(stopCh <-chan struct{}) (<-chan struct{}, <-chan struct{}, error) { +func (s preparedGenericAPIServer) NonBlockingRun(stopCh <-chan struct{}, shutdownTimeout time.Duration) (<-chan struct{}, <-chan struct{}, error) { // Use an stop channel to allow graceful shutdown without dropping audit events // after http server shutdown. auditStopCh := make(chan struct{}) @@ -416,8 +500,7 @@ func (s preparedGenericAPIServer) NonBlockingRun(stopCh <-chan struct{}) (<-chan var listenerStoppedCh <-chan struct{} if s.SecureServingInfo != nil && s.Handler != nil { var err error - klog.V(1).Infof("[graceful-termination] ShutdownTimeout=%s", s.ShutdownTimeout) - stoppedCh, listenerStoppedCh, err = s.SecureServingInfo.ServeWithListenerStopped(s.Handler, s.ShutdownTimeout, internalStopCh) + stoppedCh, listenerStoppedCh, err = s.SecureServingInfo.ServeWithListenerStopped(s.Handler, shutdownTimeout, internalStopCh) if err != nil { close(internalStopCh) close(auditStopCh) @@ -633,7 +716,7 @@ func (s *GenericAPIServer) getOpenAPIModels(apiPrefix string, apiGroupInfos ...* } // Build the openapi definitions for those resources and convert it to proto models - openAPISpec, err := openapibuilder.BuildOpenAPIDefinitionsForResources(s.openAPIConfig, resourceNames...) + openAPISpec, err := openapibuilder2.BuildOpenAPIDefinitionsForResources(s.openAPIConfig, resourceNames...) if err != nil { return nil, err } diff --git a/vendor/k8s.io/apiserver/pkg/server/healthz.go b/vendor/k8s.io/apiserver/pkg/server/healthz.go index 61da5873ce..d6d13444d7 100644 --- a/vendor/k8s.io/apiserver/pkg/server/healthz.go +++ b/vendor/k8s.io/apiserver/pkg/server/healthz.go @@ -21,8 +21,8 @@ import ( "net/http" "time" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apiserver/pkg/server/healthz" + "k8s.io/utils/clock" ) // AddHealthChecks adds HealthCheck(s) to health endpoints (healthz, livez, readyz) but diff --git a/vendor/k8s.io/apiserver/pkg/server/healthz/healthz.go b/vendor/k8s.io/apiserver/pkg/server/healthz/healthz.go index eb288239ce..e19505e9c1 100644 --- a/vendor/k8s.io/apiserver/pkg/server/healthz/healthz.go +++ b/vendor/k8s.io/apiserver/pkg/server/healthz/healthz.go @@ -29,7 +29,7 @@ import ( "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/apiserver/pkg/endpoints/metrics" - "k8s.io/apiserver/pkg/server/httplog" + "k8s.io/apiserver/pkg/endpoints/responsewriter" "k8s.io/klog/v2" ) @@ -255,7 +255,7 @@ func handleRootHealth(name string, firstTimeHealthy func(), checks ...HealthChec // always be verbose on failure if len(failedChecks) > 0 { klog.V(2).Infof("%s check failed: %s\n%v", strings.Join(failedChecks, ","), name, failedVerboseLogOutput.String()) - http.Error(httplog.Unlogged(r, w), fmt.Sprintf("%s%s check failed", individualCheckOutput.String(), name), http.StatusInternalServerError) + http.Error(responsewriter.GetOriginal(w), fmt.Sprintf("%s%s check failed", individualCheckOutput.String(), name), http.StatusInternalServerError) return } diff --git a/vendor/k8s.io/apiserver/pkg/server/httplog/httplog.go b/vendor/k8s.io/apiserver/pkg/server/httplog/httplog.go index 89ba28a9ec..8ac036f9b2 100644 --- a/vendor/k8s.io/apiserver/pkg/server/httplog/httplog.go +++ b/vendor/k8s.io/apiserver/pkg/server/httplog/httplog.go @@ -24,16 +24,21 @@ import ( "net/http" "runtime" "strings" + "sync" "time" "k8s.io/apiserver/pkg/endpoints/metrics" "k8s.io/apiserver/pkg/endpoints/request" + "k8s.io/apiserver/pkg/endpoints/responsewriter" "k8s.io/klog/v2" ) // StacktracePred returns true if a stacktrace should be logged for this status. type StacktracePred func(httpStatus int) (logStacktrace bool) +// ShouldLogRequestPred returns true if logging should be enabled for this request +type ShouldLogRequestPred func() bool + type logger interface { Addf(format string, data ...interface{}) } @@ -54,23 +59,32 @@ type respLogger struct { statusRecorded bool status int statusStack string - addedInfo strings.Builder - startTime time.Time + // mutex is used when accessing addedInfo and addedKeyValuePairs. + // They can be modified by other goroutine when logging happens (in case of request timeout) + mutex sync.Mutex + addedInfo strings.Builder + addedKeyValuePairs []interface{} + startTime time.Time captureErrorOutput bool - req *http.Request - w http.ResponseWriter + req *http.Request + userAgent string + w http.ResponseWriter logStacktracePred StacktracePred } +var _ http.ResponseWriter = &respLogger{} +var _ responsewriter.UserProvidedDecorator = &respLogger{} + +func (rl *respLogger) Unwrap() http.ResponseWriter { + return rl.w +} + // Simple logger that logs immediately when Addf is called type passthroughLogger struct{} -//lint:ignore SA1019 Interface implementation check to make sure we don't drop CloseNotifier again -var _ http.CloseNotifier = &respLogger{} - // Addf logs info immediately. func (passthroughLogger) Addf(format string, data ...interface{}) { klog.V(2).Info(fmt.Sprintf(format, data...)) @@ -83,7 +97,18 @@ func DefaultStacktracePred(status int) bool { // WithLogging wraps the handler with logging. func WithLogging(handler http.Handler, pred StacktracePred) http.Handler { + return withLogging(handler, pred, func() bool { + return klog.V(3).Enabled() + }) +} + +func withLogging(handler http.Handler, stackTracePred StacktracePred, shouldLogRequest ShouldLogRequestPred) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + if !shouldLogRequest() { + handler.ServeHTTP(w, req) + return + } + ctx := req.Context() if old := respLoggerFromRequest(req); old != nil { panic("multiple WithLogging calls!") @@ -94,13 +119,13 @@ func WithLogging(handler http.Handler, pred StacktracePred) http.Handler { startTime = receivedTimestamp } - rl := newLoggedWithStartTime(req, w, startTime).StacktraceWhen(pred) + rl := newLoggedWithStartTime(req, w, startTime) + rl.StacktraceWhen(stackTracePred) req = req.WithContext(context.WithValue(ctx, respLoggerContextKey, rl)) + defer rl.Log() - if klog.V(3).Enabled() { - defer rl.Log() - } - handler.ServeHTTP(rl, req) + w = responsewriter.WrapForHTTP1Or2(rl) + handler.ServeHTTP(w, req) }) } @@ -118,12 +143,14 @@ func respLoggerFromRequest(req *http.Request) *respLogger { } func newLoggedWithStartTime(req *http.Request, w http.ResponseWriter, startTime time.Time) *respLogger { - return &respLogger{ + logger := &respLogger{ startTime: startTime, req: req, + userAgent: req.UserAgent(), w: w, logStacktracePred: DefaultStacktracePred, } + return logger } // newLogged turns a normal response writer into a logged response writer. @@ -171,6 +198,8 @@ func StatusIsNot(statuses ...int) StacktracePred { // Addf adds additional data to be logged with this request. func (rl *respLogger) Addf(format string, data ...interface{}) { + rl.mutex.Lock() + defer rl.mutex.Unlock() rl.addedInfo.WriteString("\n") rl.addedInfo.WriteString(fmt.Sprintf(format, data...)) } @@ -181,6 +210,22 @@ func AddInfof(ctx context.Context, format string, data ...interface{}) { } } +func (rl *respLogger) AddKeyValue(key string, value interface{}) { + rl.mutex.Lock() + defer rl.mutex.Unlock() + rl.addedKeyValuePairs = append(rl.addedKeyValuePairs, key, value) +} + +// AddKeyValue adds a (key, value) pair to the httplog associated +// with the request. +// Use this function if you want your data to show up in httplog +// in a more structured and readable way. +func AddKeyValue(ctx context.Context, key string, value interface{}) { + if rl := respLoggerFromContext(ctx); rl != nil { + rl.AddKeyValue(key, value) + } +} + // Log is intended to be called once at the end of your request handler, via defer func (rl *respLogger) Log() { latency := time.Since(rl.startTime) @@ -200,10 +245,19 @@ func (rl *respLogger) Log() { "verb", verb, "URI", rl.req.RequestURI, "latency", latency, - "userAgent", rl.req.UserAgent(), + // We can't get UserAgent from rl.req.UserAgent() here as it accesses headers map, + // which can be modified in another goroutine when apiserver request times out. + // For example authentication filter modifies request's headers, + // This can cause apiserver to crash with unrecoverable fatal error. + // More info about concurrent read and write for maps: https://golang.org/doc/go1.6#runtime + "userAgent", rl.userAgent, "audit-ID", auditID, "srcIP", rl.req.RemoteAddr, } + // Lock for accessing addedKeyValuePairs and addedInfo + rl.mutex.Lock() + defer rl.mutex.Unlock() + keysAndValues = append(keysAndValues, rl.addedKeyValuePairs...) if rl.hijacked { keysAndValues = append(keysAndValues, "hijacked", true) @@ -237,32 +291,18 @@ func (rl *respLogger) Write(b []byte) (int, error) { return rl.w.Write(b) } -// Flush implements http.Flusher even if the underlying http.Writer doesn't implement it. -// Flush is used for streaming purposes and allows to flush buffered data to the client. -func (rl *respLogger) Flush() { - if flusher, ok := rl.w.(http.Flusher); ok { - flusher.Flush() - } else if klog.V(2).Enabled() { - klog.InfoDepth(1, fmt.Sprintf("Unable to convert %+v into http.Flusher", rl.w)) - } -} - // WriteHeader implements http.ResponseWriter. func (rl *respLogger) WriteHeader(status int) { rl.recordStatus(status) rl.w.WriteHeader(status) } -// Hijack implements http.Hijacker. func (rl *respLogger) Hijack() (net.Conn, *bufio.ReadWriter, error) { rl.hijacked = true - return rl.w.(http.Hijacker).Hijack() -} -// CloseNotify implements http.CloseNotifier -func (rl *respLogger) CloseNotify() <-chan bool { - //lint:ignore SA1019 There are places in the code base requiring the CloseNotifier interface to be implemented. - return rl.w.(http.CloseNotifier).CloseNotify() + // the outer ResponseWriter object returned by WrapForHTTP1Or2 implements + // http.Hijacker if the inner object (rl.w) implements http.Hijacker. + return rl.w.(http.Hijacker).Hijack() } func (rl *respLogger) recordStatus(status int) { diff --git a/vendor/k8s.io/apiserver/pkg/server/lifecycle_signals.go b/vendor/k8s.io/apiserver/pkg/server/lifecycle_signals.go index fda4f09519..6b406072b6 100644 --- a/vendor/k8s.io/apiserver/pkg/server/lifecycle_signals.go +++ b/vendor/k8s.io/apiserver/pkg/server/lifecycle_signals.go @@ -16,6 +16,10 @@ limitations under the License. package server +import ( + "sync" +) + /* We make an attempt here to identify the events that take place during lifecycle of the apiserver. @@ -28,7 +32,9 @@ Events: - InFlightRequestsDrained: all in flight request(s) have been drained - HasBeenReady is signaled when the readyz endpoint succeeds for the first time -The following is a sequence of shutdown events that we expect to see during termination: +The following is a sequence of shutdown events that we expect to see with + 'ShutdownSendRetryAfter' = false: + T0: ShutdownInitiated: KILL signal received - /readyz starts returning red - run pre shutdown hooks @@ -54,6 +60,31 @@ T0 + 70s + up-to 60s: InFlightRequestsDrained: existing in flight requests have any request in flight has a hard timeout of 60s. - it's time to call 'Shutdown' on the audit events since all in flight request(s) have drained. + + +The following is a sequence of shutdown events that we expect to see with + 'ShutdownSendRetryAfter' = true: + +T0: ShutdownInitiated: KILL signal received + - /readyz starts returning red + - run pre shutdown hooks + +T0+70s: AfterShutdownDelayDuration: shutdown delay duration has passed + - the default value of 'ShutdownDelayDuration' is '70s' + - the HTTP Server will continue to listen + - the apiserver is not accepting new request(s) + - it includes new request(s) on a new or an existing TCP connection + - new request(s) arriving after this point are replied with a 429 + and the response headers: 'Retry-After: 1` and 'Connection: close' + - note: these new request(s) will not show up in audit logs + +T0 + 70s + up to 60s: InFlightRequestsDrained: existing in flight requests have been drained + - long running requests are outside of this scope + - up to 60s: the default value of 'ShutdownTimeout' is 60s, this means that + any request in flight has a hard timeout of 60s. + - server.Shutdown is called, the HTTP Server stops listening immediately + - the HTTP Server waits gracefully for existing requests to complete + up to '2s' (it's hard coded right now) */ // lifecycleSignal encapsulates a named apiserver event @@ -99,6 +130,11 @@ type lifecycleSignals struct { // HasBeenReady is signaled when the readyz endpoint succeeds for the first time. HasBeenReady lifecycleSignal + + // MuxAndDiscoveryComplete is signaled when all known HTTP paths have been installed. + // It exists primarily to avoid returning a 404 response when a resource actually exists but we haven't installed the path to a handler. + // The actual logic is implemented by an APIServer using the generic server library. + MuxAndDiscoveryComplete lifecycleSignal } // newLifecycleSignals returns an instance of lifecycleSignals interface to be used @@ -110,28 +146,28 @@ func newLifecycleSignals() lifecycleSignals { InFlightRequestsDrained: newNamedChannelWrapper("InFlightRequestsDrained"), HTTPServerStoppedListening: newNamedChannelWrapper("HTTPServerStoppedListening"), HasBeenReady: newNamedChannelWrapper("HasBeenReady"), + MuxAndDiscoveryComplete: newNamedChannelWrapper("MuxAndDiscoveryComplete"), } } func newNamedChannelWrapper(name string) lifecycleSignal { return &namedChannelWrapper{ name: name, + once: sync.Once{}, ch: make(chan struct{}), } } type namedChannelWrapper struct { name string + once sync.Once ch chan struct{} } func (e *namedChannelWrapper) Signal() { - select { - case <-e.ch: - // already closed, don't close again. - default: + e.once.Do(func() { close(e.ch) - } + }) } func (e *namedChannelWrapper) Signaled() <-chan struct{} { diff --git a/vendor/k8s.io/apiserver/pkg/server/options/api_enablement.go b/vendor/k8s.io/apiserver/pkg/server/options/api_enablement.go index 794e89dedb..13968b4e7d 100644 --- a/vendor/k8s.io/apiserver/pkg/server/options/api_enablement.go +++ b/vendor/k8s.io/apiserver/pkg/server/options/api_enablement.go @@ -58,7 +58,7 @@ func (s *APIEnablementOptions) AddFlags(fs *pflag.FlagSet) { // But in the advanced (and usually not recommended) case of delegated apiservers there can be more. // Validate will filter out the known groups of each registry. // If anything is left over after that, an error is returned. -func (s *APIEnablementOptions) Validate(registries ...GroupRegisty) []error { +func (s *APIEnablementOptions) Validate(registries ...GroupRegistry) []error { if s == nil { return nil } @@ -98,7 +98,7 @@ func (s *APIEnablementOptions) ApplyTo(c *server.Config, defaultResourceConfig * return err } -func unknownGroups(groups []string, registry GroupRegisty) []string { +func unknownGroups(groups []string, registry GroupRegistry) []string { unknownGroups := []string{} for _, group := range groups { if !registry.IsGroupRegistered(group) { @@ -108,8 +108,8 @@ func unknownGroups(groups []string, registry GroupRegisty) []string { return unknownGroups } -// GroupRegisty provides a method to check whether given group is registered. -type GroupRegisty interface { +// GroupRegistry provides a method to check whether given group is registered. +type GroupRegistry interface { // IsRegistered returns true if given group is registered. IsGroupRegistered(group string) bool } diff --git a/vendor/k8s.io/apiserver/pkg/server/options/audit.go b/vendor/k8s.io/apiserver/pkg/server/options/audit.go index 6e062c987a..fde8e8eb08 100644 --- a/vendor/k8s.io/apiserver/pkg/server/options/audit.go +++ b/vendor/k8s.io/apiserver/pkg/server/options/audit.go @@ -289,8 +289,8 @@ func (o *AuditOptions) ApplyTo( return fmt.Errorf("server config must be non-nil") } - // 1. Build policy checker - checker, err := o.newPolicyChecker() + // 1. Build policy evaluator + evaluator, err := o.newPolicyRuleEvaluator() if err != nil { return err } @@ -302,7 +302,7 @@ func (o *AuditOptions) ApplyTo( return err } if w != nil { - if checker == nil { + if evaluator == nil { klog.V(2).Info("No audit policy file provided, no events will be recorded for log backend") } else { logBackend = o.LogOptions.newBackend(w) @@ -312,7 +312,7 @@ func (o *AuditOptions) ApplyTo( // 3. Build webhook backend var webhookBackend audit.Backend if o.WebhookOptions.enabled() { - if checker == nil { + if evaluator == nil { klog.V(2).Info("No audit policy file provided, no events will be recorded for webhook backend") } else { if c.EgressSelector != nil { @@ -343,8 +343,8 @@ func (o *AuditOptions) ApplyTo( dynamicBackend = o.WebhookOptions.TruncateOptions.wrapBackend(webhookBackend, groupVersion) } - // 5. Set the policy checker - c.AuditPolicyChecker = checker + // 5. Set the policy rule evaluator + c.AuditPolicyRuleEvaluator = evaluator // 6. Join the log backend with the webhooks c.AuditBackend = appendBackend(logBackend, dynamicBackend) @@ -355,7 +355,7 @@ func (o *AuditOptions) ApplyTo( return nil } -func (o *AuditOptions) newPolicyChecker() (policy.Checker, error) { +func (o *AuditOptions) newPolicyRuleEvaluator() (audit.PolicyRuleEvaluator, error) { if o.PolicyFile == "" { return nil, nil } @@ -364,7 +364,7 @@ func (o *AuditOptions) newPolicyChecker() (policy.Checker, error) { if err != nil { return nil, fmt.Errorf("loading audit policy file: %v", err) } - return policy.NewChecker(p), nil + return policy.NewPolicyRuleEvaluator(p), nil } func (o *AuditBatchOptions) AddFlags(pluginName string, fs *pflag.FlagSet) { @@ -451,7 +451,7 @@ func (o *AuditLogOptions) AddFlags(fs *pflag.FlagSet) { fs.IntVar(&o.MaxAge, "audit-log-maxage", o.MaxAge, "The maximum number of days to retain old audit log files based on the timestamp encoded in their filename.") fs.IntVar(&o.MaxBackups, "audit-log-maxbackup", o.MaxBackups, - "The maximum number of old audit log files to retain.") + "The maximum number of old audit log files to retain. Setting a value of 0 will mean there's no restriction on the number of files.") fs.IntVar(&o.MaxSize, "audit-log-maxsize", o.MaxSize, "The maximum size in megabytes of the audit log file before it gets rotated.") fs.StringVar(&o.Format, "audit-log-format", o.Format, diff --git a/vendor/k8s.io/apiserver/pkg/server/options/encryptionconfig/config.go b/vendor/k8s.io/apiserver/pkg/server/options/encryptionconfig/config.go index 09659676ac..fd0c95c22a 100644 --- a/vendor/k8s.io/apiserver/pkg/server/options/encryptionconfig/config.go +++ b/vendor/k8s.io/apiserver/pkg/server/options/encryptionconfig/config.go @@ -101,7 +101,7 @@ func getKMSPluginProbes(reader io.Reader) ([]*kmsPluginProbe, error) { config, err := loadConfig(configFileContents) if err != nil { - return result, fmt.Errorf("error while parsing encrypiton provider configuration: %v", err) + return result, fmt.Errorf("error while parsing encryption provider configuration: %v", err) } for _, r := range config.Resources { diff --git a/vendor/k8s.io/apiserver/pkg/server/options/etcd.go b/vendor/k8s.io/apiserver/pkg/server/options/etcd.go index d8b45b8198..dfadadbcad 100644 --- a/vendor/k8s.io/apiserver/pkg/server/options/etcd.go +++ b/vendor/k8s.io/apiserver/pkg/server/options/etcd.go @@ -206,6 +206,9 @@ func (s *EtcdOptions) ApplyTo(c *server.Config) error { } } + // use the StorageObjectCountTracker interface instance from server.Config + s.StorageConfig.StorageObjectCountTracker = c.StorageObjectCountTracker + c.RESTOptionsGetter = &SimpleRestOptionsFactory{ Options: *s, TransformerOverrides: transformerOverrides, @@ -217,6 +220,10 @@ func (s *EtcdOptions) ApplyWithStorageFactoryTo(factory serverstorage.StorageFac if err := s.addEtcdHealthEndpoint(c); err != nil { return err } + + // use the StorageObjectCountTracker interface instance from server.Config + s.StorageConfig.StorageObjectCountTracker = c.StorageObjectCountTracker + c.RESTOptionsGetter = &StorageFactoryRestOptionsFactory{Options: *s, StorageFactory: factory} return nil } @@ -248,12 +255,13 @@ type SimpleRestOptionsFactory struct { func (f *SimpleRestOptionsFactory) GetRESTOptions(resource schema.GroupResource) (generic.RESTOptions, error) { ret := generic.RESTOptions{ - StorageConfig: &f.Options.StorageConfig, - Decorator: generic.UndecoratedStorage, - EnableGarbageCollection: f.Options.EnableGarbageCollection, - DeleteCollectionWorkers: f.Options.DeleteCollectionWorkers, - ResourcePrefix: resource.Group + "/" + resource.Resource, - CountMetricPollPeriod: f.Options.StorageConfig.CountMetricPollPeriod, + StorageConfig: f.Options.StorageConfig.ForResource(resource), + Decorator: generic.UndecoratedStorage, + EnableGarbageCollection: f.Options.EnableGarbageCollection, + DeleteCollectionWorkers: f.Options.DeleteCollectionWorkers, + ResourcePrefix: resource.Group + "/" + resource.Resource, + CountMetricPollPeriod: f.Options.StorageConfig.CountMetricPollPeriod, + StorageObjectCountTracker: f.Options.StorageConfig.StorageObjectCountTracker, } if f.TransformerOverrides != nil { if transformer, ok := f.TransformerOverrides[resource]; ok { @@ -290,12 +298,13 @@ func (f *StorageFactoryRestOptionsFactory) GetRESTOptions(resource schema.GroupR } ret := generic.RESTOptions{ - StorageConfig: storageConfig, - Decorator: generic.UndecoratedStorage, - DeleteCollectionWorkers: f.Options.DeleteCollectionWorkers, - EnableGarbageCollection: f.Options.EnableGarbageCollection, - ResourcePrefix: f.StorageFactory.ResourcePrefix(resource), - CountMetricPollPeriod: f.Options.StorageConfig.CountMetricPollPeriod, + StorageConfig: storageConfig, + Decorator: generic.UndecoratedStorage, + DeleteCollectionWorkers: f.Options.DeleteCollectionWorkers, + EnableGarbageCollection: f.Options.EnableGarbageCollection, + ResourcePrefix: f.StorageFactory.ResourcePrefix(resource), + CountMetricPollPeriod: f.Options.StorageConfig.CountMetricPollPeriod, + StorageObjectCountTracker: f.Options.StorageConfig.StorageObjectCountTracker, } if f.Options.EnableWatchCache { sizes, err := ParseWatchCacheSizes(f.Options.WatchCacheSizes) diff --git a/vendor/k8s.io/apiserver/pkg/server/options/recommended.go b/vendor/k8s.io/apiserver/pkg/server/options/recommended.go index b8d60517ad..0d9c6ca9f4 100644 --- a/vendor/k8s.io/apiserver/pkg/server/options/recommended.go +++ b/vendor/k8s.io/apiserver/pkg/server/options/recommended.go @@ -143,7 +143,7 @@ func (o *RecommendedOptions) ApplyTo(config *server.RecommendedConfig) error { } config.FlowControl = utilflowcontrol.New( config.SharedInformerFactory, - kubernetes.NewForConfigOrDie(config.ClientConfig).FlowcontrolV1beta1(), + kubernetes.NewForConfigOrDie(config.ClientConfig).FlowcontrolV1beta2(), config.MaxRequestsInFlight+config.MaxMutatingRequestsInFlight, config.RequestTimeout/4, ) diff --git a/vendor/k8s.io/apiserver/pkg/server/options/server_run_options.go b/vendor/k8s.io/apiserver/pkg/server/options/server_run_options.go index 9758eec11b..07a887a539 100644 --- a/vendor/k8s.io/apiserver/pkg/server/options/server_run_options.go +++ b/vendor/k8s.io/apiserver/pkg/server/options/server_run_options.go @@ -54,6 +54,15 @@ type ServerRunOptions struct { // apiserver library can wire it to a flag. MaxRequestBodyBytes int64 EnablePriorityAndFairness bool + + // ShutdownSendRetryAfter dictates when to initiate shutdown of the HTTP + // Server during the graceful termination of the apiserver. If true, we wait + // for non longrunning requests in flight to be drained and then initiate a + // shutdown of the HTTP Server. If false, we initiate a shutdown of the HTTP + // Server as soon as ShutdownDelayDuration has elapsed. + // If enabled, after ShutdownDelayDuration elapses, any incoming request is + // rejected with a 429 status code and a 'Retry-After' response. + ShutdownSendRetryAfter bool } func NewServerRunOptions() *ServerRunOptions { @@ -68,6 +77,7 @@ func NewServerRunOptions() *ServerRunOptions { JSONPatchMaxCopyBytes: defaults.JSONPatchMaxCopyBytes, MaxRequestBodyBytes: defaults.MaxRequestBodyBytes, EnablePriorityAndFairness: true, + ShutdownSendRetryAfter: false, } } @@ -86,6 +96,7 @@ func (s *ServerRunOptions) ApplyTo(c *server.Config) error { c.JSONPatchMaxCopyBytes = s.JSONPatchMaxCopyBytes c.MaxRequestBodyBytes = s.MaxRequestBodyBytes c.PublicAddress = s.AdvertiseAddress + c.ShutdownSendRetryAfter = s.ShutdownSendRetryAfter return nil } @@ -245,5 +256,10 @@ func (s *ServerRunOptions) AddUniversalFlags(fs *pflag.FlagSet) { "will return success, but /readyz immediately returns failure. Graceful termination starts after this delay "+ "has elapsed. This can be used to allow load balancer to stop sending traffic to this server.") + fs.BoolVar(&s.ShutdownSendRetryAfter, "shutdown-send-retry-after", s.ShutdownSendRetryAfter, ""+ + "If true the HTTP Server will continue listening until all non long running request(s) in flight have been drained, "+ + "during this window all incoming requests will be rejected with a status code 429 and a 'Retry-After' response header, "+ + "in addition 'Connection: close' response header is set in order to tear down the TCP connection when idle.") + utilfeature.DefaultMutableFeatureGate.AddFlag(fs) } diff --git a/vendor/k8s.io/apiserver/pkg/server/options/serving.go b/vendor/k8s.io/apiserver/pkg/server/options/serving.go index f435ba5b8d..c64798b4f9 100644 --- a/vendor/k8s.io/apiserver/pkg/server/options/serving.go +++ b/vendor/k8s.io/apiserver/pkg/server/options/serving.go @@ -27,6 +27,7 @@ import ( "github.com/spf13/pflag" "k8s.io/klog/v2" + netutils "k8s.io/utils/net" utilnet "k8s.io/apimachinery/pkg/util/net" "k8s.io/apiserver/pkg/server" @@ -108,7 +109,7 @@ type GeneratableKeyCert struct { func NewSecureServingOptions() *SecureServingOptions { return &SecureServingOptions{ - BindAddress: net.ParseIP("0.0.0.0"), + BindAddress: netutils.ParseIPSloppy("0.0.0.0"), BindPort: 443, ServerCert: GeneratableKeyCert{ PairName: "apiserver", diff --git a/vendor/k8s.io/apiserver/pkg/server/options/serving_unix.go b/vendor/k8s.io/apiserver/pkg/server/options/serving_unix.go index 5bf87e4b17..483eac79b2 100644 --- a/vendor/k8s.io/apiserver/pkg/server/options/serving_unix.go +++ b/vendor/k8s.io/apiserver/pkg/server/options/serving_unix.go @@ -1,3 +1,4 @@ +//go:build !windows // +build !windows /* diff --git a/vendor/k8s.io/apiserver/pkg/server/options/serving_windows.go b/vendor/k8s.io/apiserver/pkg/server/options/serving_windows.go index 1663acee0b..844de61883 100644 --- a/vendor/k8s.io/apiserver/pkg/server/options/serving_windows.go +++ b/vendor/k8s.io/apiserver/pkg/server/options/serving_windows.go @@ -1,3 +1,4 @@ +//go:build windows // +build windows /* diff --git a/vendor/k8s.io/apiserver/pkg/server/routes/metrics.go b/vendor/k8s.io/apiserver/pkg/server/routes/metrics.go index 1121e95c36..d30f74b9c4 100644 --- a/vendor/k8s.io/apiserver/pkg/server/routes/metrics.go +++ b/vendor/k8s.io/apiserver/pkg/server/routes/metrics.go @@ -19,6 +19,7 @@ package routes import ( apimetrics "k8s.io/apiserver/pkg/endpoints/metrics" "k8s.io/apiserver/pkg/server/mux" + cachermetrics "k8s.io/apiserver/pkg/storage/cacher/metrics" etcd3metrics "k8s.io/apiserver/pkg/storage/etcd3/metrics" flowcontrolmetrics "k8s.io/apiserver/pkg/util/flowcontrol/metrics" "k8s.io/component-base/metrics/legacyregistry" @@ -46,6 +47,7 @@ func (m MetricsWithReset) Install(c *mux.PathRecorderMux) { // register apiserver and etcd metrics func register() { apimetrics.Register() + cachermetrics.Register() etcd3metrics.Register() flowcontrolmetrics.Register() } diff --git a/vendor/k8s.io/apiserver/pkg/server/routes/openapi.go b/vendor/k8s.io/apiserver/pkg/server/routes/openapi.go index 4be4d03fc2..44e463532a 100644 --- a/vendor/k8s.io/apiserver/pkg/server/routes/openapi.go +++ b/vendor/k8s.io/apiserver/pkg/server/routes/openapi.go @@ -21,9 +21,11 @@ import ( "k8s.io/klog/v2" "k8s.io/apiserver/pkg/server/mux" - "k8s.io/kube-openapi/pkg/builder" + builder2 "k8s.io/kube-openapi/pkg/builder" + "k8s.io/kube-openapi/pkg/builder3" "k8s.io/kube-openapi/pkg/common" "k8s.io/kube-openapi/pkg/handler" + "k8s.io/kube-openapi/pkg/handler3" "k8s.io/kube-openapi/pkg/validation/spec" ) @@ -33,8 +35,8 @@ type OpenAPI struct { } // Install adds the SwaggerUI webservice to the given mux. -func (oa OpenAPI) Install(c *restful.Container, mux *mux.PathRecorderMux) (*handler.OpenAPIService, *spec.Swagger) { - spec, err := builder.BuildOpenAPISpec(c.RegisteredWebServices(), oa.Config) +func (oa OpenAPI) InstallV2(c *restful.Container, mux *mux.PathRecorderMux) (*handler.OpenAPIService, *spec.Swagger) { + spec, err := builder2.BuildOpenAPISpec(c.RegisteredWebServices(), oa.Config) if err != nil { klog.Fatalf("Failed to build open api spec for root: %v", err) } @@ -51,3 +53,34 @@ func (oa OpenAPI) Install(c *restful.Container, mux *mux.PathRecorderMux) (*hand return openAPIVersionedService, spec } + +// InstallV3 adds the static group/versions defined in the RegisteredWebServices to the OpenAPI v3 spec +func (oa OpenAPI) InstallV3(c *restful.Container, mux *mux.PathRecorderMux) *handler3.OpenAPIService { + openAPIVersionedService, err := handler3.NewOpenAPIService(nil) + if err != nil { + klog.Fatalf("Failed to create OpenAPIService: %v", err) + } + + err = openAPIVersionedService.RegisterOpenAPIV3VersionedService("/openapi/v3", mux) + if err != nil { + klog.Fatalf("Failed to register versioned open api spec for root: %v", err) + } + + grouped := make(map[string][]*restful.WebService) + + for _, t := range c.RegisteredWebServices() { + // Strip the "/" prefix from the name + gvName := t.RootPath()[1:] + grouped[gvName] = []*restful.WebService{t} + } + + for gv, ws := range grouped { + spec, err := builder3.BuildOpenAPISpec(ws, oa.Config) + if err != nil { + klog.Errorf("Failed to build OpenAPI v3 for group %s, %q", gv, err) + + } + openAPIVersionedService.UpdateGroupVersion(gv, spec) + } + return openAPIVersionedService +} diff --git a/vendor/k8s.io/apiserver/pkg/server/signal_posix.go b/vendor/k8s.io/apiserver/pkg/server/signal_posix.go index 11b3bba65f..7acb2038a1 100644 --- a/vendor/k8s.io/apiserver/pkg/server/signal_posix.go +++ b/vendor/k8s.io/apiserver/pkg/server/signal_posix.go @@ -1,3 +1,4 @@ +//go:build !windows // +build !windows /* diff --git a/vendor/k8s.io/apiserver/pkg/server/storage/storage_factory.go b/vendor/k8s.io/apiserver/pkg/server/storage/storage_factory.go index 689b513223..3b8c71de1f 100644 --- a/vendor/k8s.io/apiserver/pkg/server/storage/storage_factory.go +++ b/vendor/k8s.io/apiserver/pkg/server/storage/storage_factory.go @@ -46,7 +46,7 @@ type Backend struct { type StorageFactory interface { // New finds the storage destination for the given group and resource. It will // return an error if the group has no storage destination configured. - NewConfig(groupResource schema.GroupResource) (*storagebackend.Config, error) + NewConfig(groupResource schema.GroupResource) (*storagebackend.ConfigForResource, error) // ResourcePrefix returns the overridden resource prefix for the GroupResource // This allows for cohabitation of resources with different native types and provides @@ -250,7 +250,7 @@ func (s *DefaultStorageFactory) getStorageGroupResource(groupResource schema.Gro // New finds the storage destination for the given group and resource. It will // return an error if the group has no storage destination configured. -func (s *DefaultStorageFactory) NewConfig(groupResource schema.GroupResource) (*storagebackend.Config, error) { +func (s *DefaultStorageFactory) NewConfig(groupResource schema.GroupResource) (*storagebackend.ConfigForResource, error) { chosenStorageResource := s.getStorageGroupResource(groupResource) // operate on copy @@ -284,7 +284,7 @@ func (s *DefaultStorageFactory) NewConfig(groupResource schema.GroupResource) (* } klog.V(3).Infof("storing %v in %v, reading as %v from %#v", groupResource, codecConfig.StorageVersion, codecConfig.MemoryVersion, codecConfig.Config) - return &storageConfig, nil + return storageConfig.ForResource(groupResource), nil } // Backends returns all backends for all registered storage destinations. diff --git a/vendor/k8s.io/apiserver/pkg/storage/cacher/cacher.go b/vendor/k8s.io/apiserver/pkg/storage/cacher/cacher.go index 03efddb5bc..217fa72588 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/cacher/cacher.go +++ b/vendor/k8s.io/apiserver/pkg/storage/cacher/cacher.go @@ -31,16 +31,17 @@ import ( "k8s.io/apimachinery/pkg/fields" "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/util/clock" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/apimachinery/pkg/watch" "k8s.io/apiserver/pkg/features" "k8s.io/apiserver/pkg/storage" + "k8s.io/apiserver/pkg/storage/cacher/metrics" utilfeature "k8s.io/apiserver/pkg/util/feature" utilflowcontrol "k8s.io/apiserver/pkg/util/flowcontrol" "k8s.io/client-go/tools/cache" "k8s.io/klog/v2" + "k8s.io/utils/clock" utiltrace "k8s.io/utils/trace" ) @@ -191,7 +192,7 @@ func (t *watcherBookmarkTimeBuckets) addWatcher(w *cacheWatcher) bool { if bucketID < t.startBucketID { bucketID = t.startBucketID } - watchers, _ := t.watchersBuckets[bucketID] + watchers := t.watchersBuckets[bucketID] t.watchersBuckets[bucketID] = append(watchers, w) return true } @@ -231,6 +232,8 @@ type Cacher struct { // Incoming events that should be dispatched to watchers. incoming chan watchCacheEvent + resourcePrefix string + sync.RWMutex // Before accessing the cacher's cache, wait for the ready to be ok. @@ -329,6 +332,7 @@ func NewCacherFromConfig(config Config) (*Cacher, error) { } objType := reflect.TypeOf(obj) cacher := &Cacher{ + resourcePrefix: config.ResourcePrefix, ready: newReady(), storage: config.Storage, objectType: objType, @@ -342,7 +346,7 @@ func NewCacherFromConfig(config Config) (*Cacher, error) { }, // TODO: Figure out the correct value for the buffer size. incoming: make(chan watchCacheEvent, 100), - dispatchTimeoutBudget: newTimeBudget(stopCh), + dispatchTimeoutBudget: newTimeBudget(), // We need to (potentially) stop both: // - wait.Until go-routine // - reflector.ListAndWatch @@ -512,13 +516,6 @@ func (c *Cacher) Watch(ctx context.Context, key string, opts storage.ListOptions return newErrWatcher(err), nil } - // With some events already sent, update resourceVersion so that - // events that were buffered and not yet processed won't be delivered - // to this watcher second time causing going back in time. - if len(initEvents) > 0 { - watchRV = initEvents[len(initEvents)-1].ResourceVersion - } - func() { c.Lock() defer c.Unlock() @@ -533,7 +530,7 @@ func (c *Cacher) Watch(ctx context.Context, key string, opts storage.ListOptions c.watcherIdx++ }() - go watcher.process(ctx, initEvents, watchRV) + go watcher.processEvents(ctx, initEvents, watchRV) return watcher, nil } @@ -593,6 +590,8 @@ func (c *Cacher) Get(ctx context.Context, key string, opts storage.GetOptions, o return nil } +// NOTICE: Keep in sync with shouldListFromStorage function in +// staging/src/k8s.io/apiserver/pkg/util/flowcontrol/request/list_work_estimator.go func shouldDelegateList(opts storage.ListOptions) bool { resourceVersion := opts.ResourceVersion pred := opts.Predicate @@ -716,7 +715,7 @@ func (c *Cacher) List(ctx context.Context, key string, opts storage.ListOptions, } filter := filterWithAttrsFunction(key, pred) - objs, readResourceVersion, err := c.watchCache.WaitUntilFreshAndList(listRV, pred.MatcherIndex(), trace) + objs, readResourceVersion, indexUsed, err := c.watchCache.WaitUntilFreshAndList(listRV, pred.MatcherIndex(), trace) if err != nil { return err } @@ -742,6 +741,7 @@ func (c *Cacher) List(ctx context.Context, key string, opts storage.ListOptions, return err } } + metrics.RecordListCacheMetrics(c.resourcePrefix, indexUsed, len(objs), listVal.Len()) return nil } @@ -927,8 +927,11 @@ func (c *Cacher) dispatchEvent(event *watchCacheEvent) { timeout := c.dispatchTimeoutBudget.takeAvailable() c.timer.Reset(timeout) - // Make sure every watcher will try to send event without blocking first, - // even if the timer has already expired. + // Send event to all blocked watchers. As long as timer is running, + // `add` will wait for the watcher to unblock. After timeout, + // `add` will not wait, but immediately close a still blocked watcher. + // Hence, every watcher gets the chance to unblock itself while timer + // is running, not only the first ones in the list. timer := c.timer for _, watcher := range c.blockedWatchers { if !watcher.add(event, timer) { @@ -1382,7 +1385,7 @@ func (c *cacheWatcher) sendWatchCacheEvent(event *watchCacheEvent) { } } -func (c *cacheWatcher) process(ctx context.Context, initEvents []*watchCacheEvent, resourceVersion uint64) { +func (c *cacheWatcher) processEvents(ctx context.Context, initEvents []*watchCacheEvent, resourceVersion uint64) { defer utilruntime.HandleCrash() // Check how long we are processing initEvents. @@ -1403,15 +1406,25 @@ func (c *cacheWatcher) process(ctx context.Context, initEvents []*watchCacheEven for _, event := range initEvents { c.sendWatchCacheEvent(event) } + objType := c.objectType.String() if len(initEvents) > 0 { initCounter.WithLabelValues(objType).Add(float64(len(initEvents))) + // With some events already sent, update resourceVersion + // so that events that were buffered and not yet processed + // won't be delivered to this watcher second time causing + // going back in time. + resourceVersion = initEvents[len(initEvents)-1].ResourceVersion } processingTime := time.Since(startTime) if processingTime > initProcessThreshold { klog.V(2).Infof("processing %d initEvents of %s (%s) took %v", len(initEvents), objType, c.identifier, processingTime) } + c.process(ctx, resourceVersion) +} + +func (c *cacheWatcher) process(ctx context.Context, resourceVersion uint64) { // At this point we already start processing incoming watch events. // However, the init event can still be processed because their serialization // and sending to the client happens asynchrnously. diff --git a/vendor/k8s.io/apiserver/pkg/storage/cacher/metrics/OWNERS b/vendor/k8s.io/apiserver/pkg/storage/cacher/metrics/OWNERS new file mode 100644 index 0000000000..b26e7a4dc7 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/storage/cacher/metrics/OWNERS @@ -0,0 +1,8 @@ +# See the OWNERS docs at https://go.k8s.io/owners + +approvers: + - sig-instrumentation-approvers +reviewers: + - sig-instrumentation-reviewers +labels: + - sig/instrumentation diff --git a/vendor/k8s.io/apiserver/pkg/storage/cacher/metrics/metrics.go b/vendor/k8s.io/apiserver/pkg/storage/cacher/metrics/metrics.go new file mode 100644 index 0000000000..652730332e --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/storage/cacher/metrics/metrics.go @@ -0,0 +1,78 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package metrics + +import ( + "sync" + + compbasemetrics "k8s.io/component-base/metrics" + "k8s.io/component-base/metrics/legacyregistry" +) + +/* + * By default, all the following metrics are defined as falling under + * ALPHA stability level https://github.com/kubernetes/enhancements/blob/master/keps/sig-instrumentation/1209-metrics-stability/kubernetes-control-plane-metrics-stability.md#stability-classes) + * + * Promoting the stability level of the metric is a responsibility of the component owner, since it + * involves explicitly acknowledging support for the metric across multiple releases, in accordance with + * the metric stability policy. + */ +var ( + listCacheCount = compbasemetrics.NewCounterVec( + &compbasemetrics.CounterOpts{ + Name: "apiserver_cache_list_total", + Help: "Number of LIST requests served from watch cache", + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{"resource_prefix", "index"}, + ) + listCacheNumFetched = compbasemetrics.NewCounterVec( + &compbasemetrics.CounterOpts{ + Name: "apiserver_cache_list_fetched_objects_total", + Help: "Number of objects read from watch cache in the course of serving a LIST request", + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{"resource_prefix", "index"}, + ) + listCacheNumReturned = compbasemetrics.NewCounterVec( + &compbasemetrics.CounterOpts{ + Name: "apiserver_cache_list_returned_objects_total", + Help: "Number of objects returned for a LIST request from watch cache", + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{"resource_prefix"}, + ) +) + +var registerMetrics sync.Once + +// Register all metrics. +func Register() { + // Register the metrics. + registerMetrics.Do(func() { + legacyregistry.MustRegister(listCacheCount) + legacyregistry.MustRegister(listCacheNumFetched) + legacyregistry.MustRegister(listCacheNumReturned) + }) +} + +// RecordListCacheMetrics notes various metrics of the cost to serve a LIST request +func RecordListCacheMetrics(resourcePrefix, indexName string, numFetched, numReturned int) { + listCacheCount.WithLabelValues(resourcePrefix, indexName).Inc() + listCacheNumFetched.WithLabelValues(resourcePrefix, indexName).Add(float64(numFetched)) + listCacheNumReturned.WithLabelValues(resourcePrefix).Add(float64(numReturned)) +} diff --git a/vendor/k8s.io/apiserver/pkg/storage/cacher/time_budget.go b/vendor/k8s.io/apiserver/pkg/storage/cacher/time_budget.go index 2eb0fed32d..da77bd42b0 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/cacher/time_budget.go +++ b/vendor/k8s.io/apiserver/pkg/storage/cacher/time_budget.go @@ -19,6 +19,8 @@ package cacher import ( "sync" "time" + + "k8s.io/utils/clock" ) const ( @@ -46,42 +48,39 @@ type timeBudget interface { type timeBudgetImpl struct { sync.Mutex - budget time.Duration - - refresh time.Duration + clock clock.Clock + budget time.Duration maxBudget time.Duration + refresh time.Duration + // last store last access time + last time.Time } -func newTimeBudget(stopCh <-chan struct{}) timeBudget { +func newTimeBudget() timeBudget { result := &timeBudgetImpl{ + clock: clock.RealClock{}, budget: time.Duration(0), refresh: refreshPerSecond, maxBudget: maxBudget, } - go result.periodicallyRefresh(stopCh) + result.last = result.clock.Now() return result } -func (t *timeBudgetImpl) periodicallyRefresh(stopCh <-chan struct{}) { - ticker := time.NewTicker(time.Second) - defer ticker.Stop() - for { - select { - case <-ticker.C: - t.Lock() - if t.budget = t.budget + t.refresh; t.budget > t.maxBudget { - t.budget = t.maxBudget - } - t.Unlock() - case <-stopCh: - return - } - } -} - func (t *timeBudgetImpl) takeAvailable() time.Duration { t.Lock() defer t.Unlock() + // budget accumulated since last access + now := t.clock.Now() + acc := now.Sub(t.last).Seconds() * t.refresh.Seconds() + if acc < 0 { + acc = 0 + } + // update current budget and store the current time + if t.budget = t.budget + time.Duration(acc*1e9); t.budget > t.maxBudget { + t.budget = t.maxBudget + } + t.last = now result := t.budget t.budget = time.Duration(0) return result @@ -94,6 +93,8 @@ func (t *timeBudgetImpl) returnUnused(unused time.Duration) { // We used more than allowed. return } + // add the unused time directly to the budget + // takeAvailable() will take into account the elapsed time if t.budget = t.budget + unused; t.budget > t.maxBudget { t.budget = t.maxBudget } diff --git a/vendor/k8s.io/apiserver/pkg/storage/cacher/watch_cache.go b/vendor/k8s.io/apiserver/pkg/storage/cacher/watch_cache.go index b3c925e180..f52bdd053e 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/cacher/watch_cache.go +++ b/vendor/k8s.io/apiserver/pkg/storage/cacher/watch_cache.go @@ -27,11 +27,11 @@ import ( "k8s.io/apimachinery/pkg/fields" "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/watch" "k8s.io/apiserver/pkg/storage" "k8s.io/client-go/tools/cache" "k8s.io/klog/v2" + "k8s.io/utils/clock" utiltrace "k8s.io/utils/trace" ) @@ -420,17 +420,27 @@ func (w *watchCache) List() []interface{} { // You HAVE TO explicitly call w.RUnlock() after this function. func (w *watchCache) waitUntilFreshAndBlock(resourceVersion uint64, trace *utiltrace.Trace) error { startTime := w.clock.Now() - go func() { - // Wake us up when the time limit has expired. The docs - // promise that time.After (well, NewTimer, which it calls) - // will wait *at least* the duration given. Since this go - // routine starts sometime after we record the start time, and - // it will wake up the loop below sometime after the broadcast, - // we don't need to worry about waking it up before the time - // has expired accidentally. - <-w.clock.After(blockTimeout) - w.cond.Broadcast() - }() + + // In case resourceVersion is 0, we accept arbitrarily stale result. + // As a result, the condition in the below for loop will never be + // satisfied (w.resourceVersion is never negative), this call will + // never hit the w.cond.Wait(). + // As a result - we can optimize the code by not firing the wakeup + // function (and avoid starting a gorotuine), especially given that + // resourceVersion=0 is the most common case. + if resourceVersion > 0 { + go func() { + // Wake us up when the time limit has expired. The docs + // promise that time.After (well, NewTimer, which it calls) + // will wait *at least* the duration given. Since this go + // routine starts sometime after we record the start time, and + // it will wake up the loop below sometime after the broadcast, + // we don't need to worry about waking it up before the time + // has expired accidentally. + <-w.clock.After(blockTimeout) + w.cond.Broadcast() + }() + } w.RLock() if trace != nil { @@ -449,12 +459,13 @@ func (w *watchCache) waitUntilFreshAndBlock(resourceVersion uint64, trace *utilt return nil } -// WaitUntilFreshAndList returns list of pointers to objects. -func (w *watchCache) WaitUntilFreshAndList(resourceVersion uint64, matchValues []storage.MatchValue, trace *utiltrace.Trace) ([]interface{}, uint64, error) { +// WaitUntilFreshAndList returns list of pointers to `storeElement` objects along +// with their ResourceVersion and the name of the index, if any, that was used. +func (w *watchCache) WaitUntilFreshAndList(resourceVersion uint64, matchValues []storage.MatchValue, trace *utiltrace.Trace) ([]interface{}, uint64, string, error) { err := w.waitUntilFreshAndBlock(resourceVersion, trace) defer w.RUnlock() if err != nil { - return nil, 0, err + return nil, 0, "", err } // This isn't the place where we do "final filtering" - only some "prefiltering" is happening here. So the only @@ -463,10 +474,10 @@ func (w *watchCache) WaitUntilFreshAndList(resourceVersion uint64, matchValues [ // TODO: if multiple indexes match, return the one with the fewest items, so as to do as much filtering as possible. for _, matchValue := range matchValues { if result, err := w.store.ByIndex(matchValue.IndexName, matchValue.Value); err == nil { - return result, w.resourceVersion, nil + return result, w.resourceVersion, matchValue.IndexName, nil } } - return w.store.List(), w.resourceVersion, nil + return w.store.List(), w.resourceVersion, "", nil } // WaitUntilFreshAndGet returns a pointers to object. @@ -621,12 +632,6 @@ func (w *watchCache) GetAllEventsSinceThreadUnsafe(resourceVersion uint64) ([]*w return result, nil } -func (w *watchCache) GetAllEventsSince(resourceVersion uint64) ([]*watchCacheEvent, error) { - w.RLock() - defer w.RUnlock() - return w.GetAllEventsSinceThreadUnsafe(resourceVersion) -} - func (w *watchCache) Resync() error { // Nothing to do return nil diff --git a/vendor/k8s.io/apiserver/pkg/storage/etcd3/metrics/metrics.go b/vendor/k8s.io/apiserver/pkg/storage/etcd3/metrics/metrics.go index c10eb273e6..dc9917cef9 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/etcd3/metrics/metrics.go +++ b/vendor/k8s.io/apiserver/pkg/storage/etcd3/metrics/metrics.go @@ -85,6 +85,38 @@ var ( }, []string{}, ) + listStorageCount = compbasemetrics.NewCounterVec( + &compbasemetrics.CounterOpts{ + Name: "apiserver_storage_list_total", + Help: "Number of LIST requests served from storage", + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{"resource"}, + ) + listStorageNumFetched = compbasemetrics.NewCounterVec( + &compbasemetrics.CounterOpts{ + Name: "apiserver_storage_list_fetched_objects_total", + Help: "Number of objects read from storage in the course of serving a LIST request", + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{"resource"}, + ) + listStorageNumSelectorEvals = compbasemetrics.NewCounterVec( + &compbasemetrics.CounterOpts{ + Name: "apiserver_storage_list_evaluated_objects_total", + Help: "Number of objects tested in the course of serving a LIST request from storage", + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{"resource"}, + ) + listStorageNumReturned = compbasemetrics.NewCounterVec( + &compbasemetrics.CounterOpts{ + Name: "apiserver_storage_list_returned_objects_total", + Help: "Number of objects returned for a LIST request from storage", + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{"resource"}, + ) ) var registerMetrics sync.Once @@ -99,6 +131,10 @@ func Register() { legacyregistry.MustRegister(dbTotalSize) legacyregistry.MustRegister(etcdBookmarkCounts) legacyregistry.MustRegister(etcdLeaseObjectCounts) + legacyregistry.MustRegister(listStorageCount) + legacyregistry.MustRegister(listStorageNumFetched) + legacyregistry.MustRegister(listStorageNumSelectorEvals) + legacyregistry.MustRegister(listStorageNumReturned) }) } @@ -139,3 +175,11 @@ func UpdateLeaseObjectCount(count int64) { // See pkg/storage/etcd3/lease_manager.go etcdLeaseObjectCounts.WithLabelValues().Observe(float64(count)) } + +// RecordListEtcd3Metrics notes various metrics of the cost to serve a LIST request +func RecordStorageListMetrics(resource string, numFetched, numEvald, numReturned int) { + listStorageCount.WithLabelValues(resource).Inc() + listStorageNumFetched.WithLabelValues(resource).Add(float64(numFetched)) + listStorageNumSelectorEvals.WithLabelValues(resource).Add(float64(numEvald)) + listStorageNumReturned.WithLabelValues(resource).Add(float64(numReturned)) +} diff --git a/vendor/k8s.io/apiserver/pkg/storage/etcd3/store.go b/vendor/k8s.io/apiserver/pkg/storage/etcd3/store.go index 7f558a5886..37d411c774 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/etcd3/store.go +++ b/vendor/k8s.io/apiserver/pkg/storage/etcd3/store.go @@ -33,6 +33,7 @@ import ( apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/conversion" @@ -64,14 +65,16 @@ func (d authenticatedDataString) AuthenticatedData() []byte { var _ value.Context = authenticatedDataString("") type store struct { - client *clientv3.Client - codec runtime.Codec - versioner storage.Versioner - transformer value.Transformer - pathPrefix string - watcher *watcher - pagingEnabled bool - leaseManager *leaseManager + client *clientv3.Client + codec runtime.Codec + versioner storage.Versioner + transformer value.Transformer + pathPrefix string + groupResource schema.GroupResource + groupResourceString string + watcher *watcher + pagingEnabled bool + leaseManager *leaseManager } type objState struct { @@ -83,11 +86,11 @@ type objState struct { } // New returns an etcd3 implementation of storage.Interface. -func New(c *clientv3.Client, codec runtime.Codec, newFunc func() runtime.Object, prefix string, transformer value.Transformer, pagingEnabled bool, leaseManagerConfig LeaseManagerConfig) storage.Interface { - return newStore(c, codec, newFunc, prefix, transformer, pagingEnabled, leaseManagerConfig) +func New(c *clientv3.Client, codec runtime.Codec, newFunc func() runtime.Object, prefix string, groupResource schema.GroupResource, transformer value.Transformer, pagingEnabled bool, leaseManagerConfig LeaseManagerConfig) storage.Interface { + return newStore(c, codec, newFunc, prefix, groupResource, transformer, pagingEnabled, leaseManagerConfig) } -func newStore(c *clientv3.Client, codec runtime.Codec, newFunc func() runtime.Object, prefix string, transformer value.Transformer, pagingEnabled bool, leaseManagerConfig LeaseManagerConfig) *store { +func newStore(c *clientv3.Client, codec runtime.Codec, newFunc func() runtime.Object, prefix string, groupResource schema.GroupResource, transformer value.Transformer, pagingEnabled bool, leaseManagerConfig LeaseManagerConfig) *store { versioner := APIObjectVersioner{} result := &store{ client: c, @@ -98,9 +101,11 @@ func newStore(c *clientv3.Client, codec runtime.Codec, newFunc func() runtime.Ob // for compatibility with etcd2 impl. // no-op for default prefix of '/registry'. // keeps compatibility with etcd2 impl for custom prefixes that don't start with '/' - pathPrefix: path.Join("/", prefix), - watcher: newWatcher(c, codec, newFunc, versioner, transformer), - leaseManager: newDefaultLeaseManager(c, leaseManagerConfig), + pathPrefix: path.Join("/", prefix), + groupResource: groupResource, + groupResourceString: groupResource.String(), + watcher: newWatcher(c, codec, newFunc, versioner, transformer), + leaseManager: newDefaultLeaseManager(c, leaseManagerConfig), } return result } @@ -724,6 +729,14 @@ func (s *store) List(ctx context.Context, key string, opts storage.ListOptions, var lastKey []byte var hasMore bool var getResp *clientv3.GetResponse + var numFetched int + var numEvald int + // Because these metrics are for understanding the costs of handling LIST requests, + // get them recorded even in error cases. + defer func() { + numReturn := v.Len() + metrics.RecordStorageListMetrics(s.groupResourceString, numFetched, numEvald, numReturn) + }() for { startTime := time.Now() getResp, err = s.client.KV.Get(ctx, key, options...) @@ -731,6 +744,7 @@ func (s *store) List(ctx context.Context, key string, opts storage.ListOptions, if err != nil { return interpretListError(err, len(pred.Continue) > 0, continueKey, keyPrefix) } + numFetched += len(getResp.Kvs) if err = s.validateMinimumResourceVersion(resourceVersion, uint64(getResp.Header.Revision)); err != nil { return err } @@ -749,7 +763,7 @@ func (s *store) List(ctx context.Context, key string, opts storage.ListOptions, } // take items from the response until the bucket is full, filtering as we go - for _, kv := range getResp.Kvs { + for i, kv := range getResp.Kvs { if paging && int64(v.Len()) >= pred.Limit { hasMore = true break @@ -764,6 +778,10 @@ func (s *store) List(ctx context.Context, key string, opts storage.ListOptions, if err := appendListItem(v, data, uint64(kv.ModRevision), pred, s.codec, s.versioner, newItemFunc); err != nil { return err } + numEvald++ + + // free kv early. Long lists can take O(seconds) to decode. + getResp.Kvs[i] = nil } // indicate to the client which resource version was returned diff --git a/vendor/k8s.io/apiserver/pkg/storage/interfaces.go b/vendor/k8s.io/apiserver/pkg/storage/interfaces.go index db72d91550..176e52a599 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/interfaces.go +++ b/vendor/k8s.io/apiserver/pkg/storage/interfaces.go @@ -75,11 +75,11 @@ type ResponseMeta struct { } // IndexerFunc is a function that for a given object computes -// for a particular . +// `` for a particular ``. type IndexerFunc func(obj runtime.Object) string -// IndexerFuncs is a mapping from to function that -// for a given object computes . +// IndexerFuncs is a mapping from `` to function that +// for a given object computes ``. type IndexerFuncs map[string]IndexerFunc // Everything accepts all objects. @@ -88,7 +88,7 @@ var Everything = SelectionPredicate{ Field: fields.Everything(), } -// MatchValue defines a pair (, ). +// MatchValue defines a pair (``, ``). type MatchValue struct { IndexName string Value string diff --git a/vendor/k8s.io/apiserver/pkg/storage/storagebackend/config.go b/vendor/k8s.io/apiserver/pkg/storage/storagebackend/config.go index 45cfd2ea18..aa4163877f 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/storagebackend/config.go +++ b/vendor/k8s.io/apiserver/pkg/storage/storagebackend/config.go @@ -21,9 +21,11 @@ import ( "go.opentelemetry.io/otel/trace" "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apiserver/pkg/server/egressselector" "k8s.io/apiserver/pkg/storage/etcd3" "k8s.io/apiserver/pkg/storage/value" + flowcontrolrequest "k8s.io/apiserver/pkg/util/flowcontrol/request" ) const ( @@ -84,6 +86,27 @@ type Config struct { HealthcheckTimeout time.Duration LeaseManagerConfig etcd3.LeaseManagerConfig + + // StorageObjectCountTracker is used to keep track of the total + // number of objects in the storage per resource. + StorageObjectCountTracker flowcontrolrequest.StorageObjectCountTracker +} + +// ConfigForResource is a Config specialized to a particular `schema.GroupResource` +type ConfigForResource struct { + // Config is the resource-independent configuration + Config + + // GroupResource is the relevant one + GroupResource schema.GroupResource +} + +// ForResource specializes to the given resource +func (config *Config) ForResource(resource schema.GroupResource) *ConfigForResource { + return &ConfigForResource{ + Config: *config, + GroupResource: resource, + } } func NewDefaultConfig(prefix string, codec runtime.Codec) *Config { diff --git a/vendor/k8s.io/apiserver/pkg/storage/storagebackend/factory/etcd3.go b/vendor/k8s.io/apiserver/pkg/storage/storagebackend/factory/etcd3.go index 74ebea655c..63e18699d6 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/storagebackend/factory/etcd3.go +++ b/vendor/k8s.io/apiserver/pkg/storage/storagebackend/factory/etcd3.go @@ -137,8 +137,13 @@ func newETCD3Client(c storagebackend.TransportConfig) (*clientv3.Client, error) } dialOptions := []grpc.DialOption{ grpc.WithBlock(), // block until the underlying connection is up - grpc.WithUnaryInterceptor(grpcprom.UnaryClientInterceptor), - grpc.WithStreamInterceptor(grpcprom.StreamClientInterceptor), + // use chained interceptors so that the default (retry and backoff) interceptors are added. + // otherwise they will be overwritten by the metric interceptor. + // + // these optional interceptors will be placed after the default ones. + // which seems to be what we want as the metrics will be collected on each attempt (retry) + grpc.WithChainUnaryInterceptor(grpcprom.UnaryClientInterceptor), + grpc.WithChainStreamInterceptor(grpcprom.StreamClientInterceptor), } if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.APIServerTracing) { tracingOpts := []otelgrpc.Option{ @@ -244,7 +249,7 @@ func startCompactorOnce(c storagebackend.TransportConfig, interval time.Duration }, nil } -func newETCD3Storage(c storagebackend.Config, newFunc func() runtime.Object) (storage.Interface, DestroyFunc, error) { +func newETCD3Storage(c storagebackend.ConfigForResource, newFunc func() runtime.Object) (storage.Interface, DestroyFunc, error) { stopCompactor, err := startCompactorOnce(c.Transport, c.CompactionInterval) if err != nil { return nil, nil, err @@ -276,7 +281,7 @@ func newETCD3Storage(c storagebackend.Config, newFunc func() runtime.Object) (st if transformer == nil { transformer = value.IdentityTransformer } - return etcd3.New(client, c.Codec, newFunc, c.Prefix, transformer, c.Paging, c.LeaseManagerConfig), destroyFunc, nil + return etcd3.New(client, c.Codec, newFunc, c.Prefix, c.GroupResource, transformer, c.Paging, c.LeaseManagerConfig), destroyFunc, nil } // startDBSizeMonitorPerEndpoint starts a loop to monitor etcd database size and update the diff --git a/vendor/k8s.io/apiserver/pkg/storage/storagebackend/factory/factory.go b/vendor/k8s.io/apiserver/pkg/storage/storagebackend/factory/factory.go index fb1e2d2896..68c45a18f0 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/storagebackend/factory/factory.go +++ b/vendor/k8s.io/apiserver/pkg/storage/storagebackend/factory/factory.go @@ -28,7 +28,7 @@ import ( type DestroyFunc func() // Create creates a storage backend based on given config. -func Create(c storagebackend.Config, newFunc func() runtime.Object) (storage.Interface, DestroyFunc, error) { +func Create(c storagebackend.ConfigForResource, newFunc func() runtime.Object) (storage.Interface, DestroyFunc, error) { switch c.Type { case storagebackend.StorageTypeETCD2: return nil, nil, fmt.Errorf("%s is no longer a supported storage backend", c.Type) diff --git a/vendor/k8s.io/apiserver/pkg/util/apihelpers/helpers.go b/vendor/k8s.io/apiserver/pkg/util/apihelpers/helpers.go index 905523c734..8d20029234 100644 --- a/vendor/k8s.io/apiserver/pkg/util/apihelpers/helpers.go +++ b/vendor/k8s.io/apiserver/pkg/util/apihelpers/helpers.go @@ -19,7 +19,7 @@ package apihelpers import ( "sort" - flowcontrol "k8s.io/api/flowcontrol/v1beta1" + flowcontrol "k8s.io/api/flowcontrol/v1beta2" ) // SetFlowSchemaCondition sets conditions. diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_context.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_context.go index 6497e3fff5..1cd59049de 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_context.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_context.go @@ -52,6 +52,17 @@ func WatchInitialized(ctx context.Context) { } } +// RequestDelegated informs the priority and fairness dispatcher that +// a given request has been delegated to an aggregated API +// server. No-op when priority and fairness is disabled. +func RequestDelegated(ctx context.Context) { + // The watch initialization signal doesn't traverse request + // boundaries, so we generously fire it as soon as we know + // that the request won't be serviced locally. Safe to call + // for non-watch requests. + WatchInitialized(ctx) +} + // InitializationSignal is an interface that allows sending and handling // initialization signals. type InitializationSignal interface { diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_controller.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_controller.go index bd9fd9ad92..3b2b4a1738 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_controller.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_controller.go @@ -29,12 +29,12 @@ import ( "sync" "time" + "github.com/google/go-cmp/cmp" apiequality "k8s.io/apimachinery/pkg/api/equality" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/labels" apitypes "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/clock" utilerrors "k8s.io/apimachinery/pkg/util/errors" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/sets" @@ -50,10 +50,11 @@ import ( "k8s.io/client-go/tools/cache" "k8s.io/client-go/util/workqueue" "k8s.io/klog/v2" + "k8s.io/utils/clock" - flowcontrol "k8s.io/api/flowcontrol/v1beta1" - flowcontrolclient "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1" - flowcontrollister "k8s.io/client-go/listers/flowcontrol/v1beta1" + flowcontrol "k8s.io/api/flowcontrol/v1beta2" + flowcontrolclient "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2" + flowcontrollister "k8s.io/client-go/listers/flowcontrol/v1beta2" ) const timeFmt = "2006-01-02T15:04:05.999" @@ -67,6 +68,14 @@ const timeFmt = "2006-01-02T15:04:05.999" // undesired becomes completely unused, all the config objects are // read and processed as a whole. +// The funcs in this package follow the naming convention that the suffix +// "Locked" means the relevant mutex must be locked at the start of each +// call and will be locked upon return. For a configController, the +// suffix "ReadLocked" stipulates a read lock while just "Locked" +// stipulates a full lock. Absence of either suffix means that either +// (a) the lock must NOT be held at call time and will not be held +// upon return or (b) locking is irrelevant. + // StartFunction begins the process of handling a request. If the // request gets queued then this function uses the given hashValue as // the source of entropy as it shuffle-shards the request into a @@ -82,7 +91,6 @@ type StartFunction func(ctx context.Context, hashValue uint64) (execute bool, af type RequestDigest struct { RequestInfo *request.RequestInfo User user.Info - Width fcrequest.Width } // `*configController` maintains eventual consistency with the API @@ -91,10 +99,11 @@ type RequestDigest struct { // this type and cfgMeal follow the convention that the suffix // "Locked" means that the caller must hold the configController lock. type configController struct { - name string // varies in tests of fighting controllers - clock clock.PassiveClock - queueSetFactory fq.QueueSetFactory - obsPairGenerator metrics.TimedObserverPairGenerator + name string // varies in tests of fighting controllers + clock clock.PassiveClock + queueSetFactory fq.QueueSetFactory + reqsObsPairGenerator metrics.RatioedChangeObserverPairGenerator + execSeatsObsGenerator metrics.RatioedChangeObserverGenerator // How this controller appears in an ObjectMeta ManagedFieldsEntry.Manager asFieldManager string @@ -114,7 +123,7 @@ type configController struct { fsLister flowcontrollister.FlowSchemaLister fsInformerSynced cache.InformerSynced - flowcontrolClient flowcontrolclient.FlowcontrolV1beta1Interface + flowcontrolClient flowcontrolclient.FlowcontrolV1beta2Interface // serverConcurrencyLimit is the limit on the server's total // number of non-exempt requests being served at once. This comes @@ -124,10 +133,25 @@ type configController struct { // requestWaitLimit comes from server configuration. requestWaitLimit time.Duration + // watchTracker implements the necessary WatchTracker interface. + WatchTracker + + // the most recent update attempts, ordered by increasing age. + // Consumer trims to keep only the last minute's worth of entries. + // The controller uses this to limit itself to at most six updates + // to a given FlowSchema in any minute. + // This may only be accessed from the one and only worker goroutine. + mostRecentUpdates []updateAttempt + // This must be locked while accessing flowSchemas or - // priorityLevelStates. It is the lock involved in - // LockingWriteMultiple. - lock sync.Mutex + // priorityLevelStates. A lock for writing is needed + // for writing to any of the following: + // - the flowSchemas field + // - the slice held in the flowSchemas field + // - the priorityLevelStates field + // - the map held in the priorityLevelStates field + // - any field of a priorityLevelState held in that map + lock sync.RWMutex // flowSchemas holds the flow schema objects, sorted by increasing // numerical (decreasing logical) matching precedence. Every @@ -138,16 +162,6 @@ type configController struct { // name to the state for that level. Every name referenced from a // member of `flowSchemas` has an entry here. priorityLevelStates map[string]*priorityLevelState - - // the most recent update attempts, ordered by increasing age. - // Consumer trims to keep only the last minute's worth of entries. - // The controller uses this to limit itself to at most six updates - // to a given FlowSchema in any minute. - // This may only be accessed from the one and only worker goroutine. - mostRecentUpdates []updateAttempt - - // watchTracker implements the necessary WatchTracker interface. - WatchTracker } type updateAttempt struct { @@ -178,8 +192,11 @@ type priorityLevelState struct { // returned StartFunction numPending int - // Observers tracking number waiting, executing - obsPair metrics.TimedObserverPair + // Observers tracking number of requests waiting, executing + reqsObsPair metrics.RatioedChangeObserverPair + + // Observer of number of seats occupied throughout execution + execSeatsObs metrics.RatioedChangeObserver } // NewTestableController is extra flexible to facilitate testing @@ -188,7 +205,8 @@ func newTestableController(config TestableConfig) *configController { name: config.Name, clock: config.Clock, queueSetFactory: config.QueueSetFactory, - obsPairGenerator: config.ObsPairGenerator, + reqsObsPairGenerator: config.ReqsObsPairGenerator, + execSeatsObsGenerator: config.ExecSeatsObsGenerator, asFieldManager: config.AsFieldManager, foundToDangling: config.FoundToDangling, serverConcurrencyLimit: config.ServerConcurrencyLimit, @@ -203,7 +221,7 @@ func newTestableController(config TestableConfig) *configController { cfgCtlr.configQueue = workqueue.NewNamedRateLimitingQueue(workqueue.NewItemExponentialFailureRateLimiter(200*time.Millisecond, 8*time.Hour), "priority_and_fairness_config_queue") // ensure the data structure reflects the mandatory config cfgCtlr.lockAndDigestConfigObjects(nil, nil) - fci := config.InformerFactory.Flowcontrol().V1beta1() + fci := config.InformerFactory.Flowcontrol().V1beta2() pli := fci.PriorityLevelConfigurations() fsi := fci.FlowSchemas() cfgCtlr.plLister = pli.Lister() @@ -281,8 +299,8 @@ func (cfgCtlr *configController) MaintainObservations(stopCh <-chan struct{}) { } func (cfgCtlr *configController) updateObservations() { - cfgCtlr.lock.Lock() - defer cfgCtlr.lock.Unlock() + cfgCtlr.lock.RLock() + defer cfgCtlr.lock.RUnlock() for _, plc := range cfgCtlr.priorityLevelStates { if plc.queues != nil { plc.queues.UpdateObservations() @@ -327,7 +345,7 @@ func (cfgCtlr *configController) processNextWorkItem() bool { func(obj interface{}) { defer cfgCtlr.configQueue.Done(obj) - specificDelay, err := cfgCtlr.syncOne(map[string]string{}) + specificDelay, err := cfgCtlr.syncOne() switch { case err != nil: klog.Error(err) @@ -346,7 +364,7 @@ func (cfgCtlr *configController) processNextWorkItem() bool { // objects that configure API Priority and Fairness and updates the // local configController accordingly. // Only invoke this in the one and only worker goroutine -func (cfgCtlr *configController) syncOne(flowSchemaRVs map[string]string) (specificDelay time.Duration, err error) { +func (cfgCtlr *configController) syncOne() (specificDelay time.Duration, err error) { klog.V(5).Infof("%s syncOne at %s", cfgCtlr.name, cfgCtlr.clock.Now().Format(timeFmt)) all := labels.Everything() newPLs, err := cfgCtlr.plLister.List(all) @@ -357,7 +375,7 @@ func (cfgCtlr *configController) syncOne(flowSchemaRVs map[string]string) (speci if err != nil { return 0, fmt.Errorf("unable to list FlowSchema objects: %w", err) } - return cfgCtlr.digestConfigObjects(newPLs, newFSs, flowSchemaRVs) + return cfgCtlr.digestConfigObjects(newPLs, newFSs) } // cfgMeal is the data involved in the process of digesting the API @@ -398,7 +416,7 @@ type fsStatusUpdate struct { // digestConfigObjects is given all the API objects that configure // cfgCtlr and writes its consequent new configState. // Only invoke this in the one and only worker goroutine -func (cfgCtlr *configController) digestConfigObjects(newPLs []*flowcontrol.PriorityLevelConfiguration, newFSs []*flowcontrol.FlowSchema, flowSchemaRVs map[string]string) (time.Duration, error) { +func (cfgCtlr *configController) digestConfigObjects(newPLs []*flowcontrol.PriorityLevelConfiguration, newFSs []*flowcontrol.FlowSchema) (time.Duration, error) { fsStatusUpdates := cfgCtlr.lockAndDigestConfigObjects(newPLs, newFSs) var errs []error currResult := updateAttempt{ @@ -417,26 +435,26 @@ func (cfgCtlr *configController) digestConfigObjects(newPLs []*flowcontrol.Prior // if we are going to issue an update, be sure we track every name we update so we know if we update it too often. currResult.updatedItems.Insert(fsu.flowSchema.Name) - - enc, err := json.Marshal(fsu.condition) + patchBytes, err := makeFlowSchemaConditionPatch(fsu.condition) if err != nil { // should never happen because these conditions are created here and well formed panic(fmt.Sprintf("Failed to json.Marshall(%#+v): %s", fsu.condition, err.Error())) } - klog.V(4).Infof("%s writing Condition %s to FlowSchema %s, which had ResourceVersion=%s, because its previous value was %s", cfgCtlr.name, string(enc), fsu.flowSchema.Name, fsu.flowSchema.ResourceVersion, fcfmt.Fmt(fsu.oldValue)) + if klog.V(4).Enabled() { + klog.V(4).Infof("%s writing Condition %s to FlowSchema %s, which had ResourceVersion=%s, because its previous value was %s, diff: %s", + cfgCtlr.name, fsu.condition, fsu.flowSchema.Name, fsu.flowSchema.ResourceVersion, fcfmt.Fmt(fsu.oldValue), cmp.Diff(fsu.oldValue, fsu.condition)) + } fsIfc := cfgCtlr.flowcontrolClient.FlowSchemas() - patchBytes := []byte(fmt.Sprintf(`{"status": {"conditions": [ %s ] } }`, string(enc))) patchOptions := metav1.PatchOptions{FieldManager: cfgCtlr.asFieldManager} - patchedFlowSchema, err := fsIfc.Patch(context.TODO(), fsu.flowSchema.Name, apitypes.StrategicMergePatchType, patchBytes, patchOptions, "status") - if err == nil { - key, _ := cache.MetaNamespaceKeyFunc(patchedFlowSchema) - flowSchemaRVs[key] = patchedFlowSchema.ResourceVersion - } else if apierrors.IsNotFound(err) { - // This object has been deleted. A notification is coming - // and nothing more needs to be done here. - klog.V(5).Infof("%s at %s: attempted update of concurrently deleted FlowSchema %s; nothing more needs to be done", cfgCtlr.name, cfgCtlr.clock.Now().Format(timeFmt), fsu.flowSchema.Name) - } else { - errs = append(errs, fmt.Errorf("failed to set a status.condition for FlowSchema %s: %w", fsu.flowSchema.Name, err)) + _, err = fsIfc.Patch(context.TODO(), fsu.flowSchema.Name, apitypes.StrategicMergePatchType, patchBytes, patchOptions, "status") + if err != nil { + if apierrors.IsNotFound(err) { + // This object has been deleted. A notification is coming + // and nothing more needs to be done here. + klog.V(5).Infof("%s at %s: attempted update of concurrently deleted FlowSchema %s; nothing more needs to be done", cfgCtlr.name, cfgCtlr.clock.Now().Format(timeFmt), fsu.flowSchema.Name) + } else { + errs = append(errs, fmt.Errorf("failed to set a status.condition for FlowSchema %s: %w", fsu.flowSchema.Name, err)) + } } } cfgCtlr.addUpdateResult(currResult) @@ -444,6 +462,20 @@ func (cfgCtlr *configController) digestConfigObjects(newPLs []*flowcontrol.Prior return suggestedDelay, utilerrors.NewAggregate(errs) } +// makeFlowSchemaConditionPatch takes in a condition and returns the patch status as a json. +func makeFlowSchemaConditionPatch(condition flowcontrol.FlowSchemaCondition) ([]byte, error) { + o := struct { + Status flowcontrol.FlowSchemaStatus `json:"status"` + }{ + Status: flowcontrol.FlowSchemaStatus{ + Conditions: []flowcontrol.FlowSchemaCondition{ + condition, + }, + }, + } + return json.Marshal(o) +} + // shouldDelayUpdate checks to see if a flowschema has been updated too often and returns true if a delay is needed. // Only invoke this in the one and only worker goroutine func (cfgCtlr *configController) shouldDelayUpdate(flowSchemaName string) bool { @@ -506,9 +538,10 @@ func (meal *cfgMeal) digestNewPLsLocked(newPLs []*flowcontrol.PriorityLevelConfi for _, pl := range newPLs { state := meal.cfgCtlr.priorityLevelStates[pl.Name] if state == nil { - state = &priorityLevelState{obsPair: meal.cfgCtlr.obsPairGenerator.Generate(1, 1, []string{pl.Name})} + labelValues := []string{pl.Name} + state = &priorityLevelState{reqsObsPair: meal.cfgCtlr.reqsObsPairGenerator.Generate(1, 1, labelValues), execSeatsObs: meal.cfgCtlr.execSeatsObsGenerator.Generate(1, 1, labelValues)} } - qsCompleter, err := queueSetCompleterForPL(meal.cfgCtlr.queueSetFactory, state.queues, pl, meal.cfgCtlr.requestWaitLimit, state.obsPair) + qsCompleter, err := queueSetCompleterForPL(meal.cfgCtlr.queueSetFactory, state.queues, pl, meal.cfgCtlr.requestWaitLimit, state.reqsObsPair, state.execSeatsObs) if err != nil { klog.Warningf("Ignoring PriorityLevelConfiguration object %s because its spec (%s) is broken: %s", pl.Name, fcfmt.Fmt(pl.Spec), err) continue @@ -611,7 +644,7 @@ func (meal *cfgMeal) processOldPLsLocked() { } } var err error - plState.qsCompleter, err = queueSetCompleterForPL(meal.cfgCtlr.queueSetFactory, plState.queues, plState.pl, meal.cfgCtlr.requestWaitLimit, plState.obsPair) + plState.qsCompleter, err = queueSetCompleterForPL(meal.cfgCtlr.queueSetFactory, plState.queues, plState.pl, meal.cfgCtlr.requestWaitLimit, plState.reqsObsPair, plState.execSeatsObs) if err != nil { // This can not happen because queueSetCompleterForPL already approved this config panic(fmt.Sprintf("%s from name=%q spec=%s", err, plName, fcfmt.Fmt(plState.pl.Spec))) @@ -660,7 +693,7 @@ func (meal *cfgMeal) finishQueueSetReconfigsLocked() { // given priority level configuration. Returns nil if that config // does not call for limiting. Returns nil and an error if the given // object is malformed in a way that is a problem for this package. -func queueSetCompleterForPL(qsf fq.QueueSetFactory, queues fq.QueueSet, pl *flowcontrol.PriorityLevelConfiguration, requestWaitLimit time.Duration, intPair metrics.TimedObserverPair) (fq.QueueSetCompleter, error) { +func queueSetCompleterForPL(qsf fq.QueueSetFactory, queues fq.QueueSet, pl *flowcontrol.PriorityLevelConfiguration, requestWaitLimit time.Duration, reqsIntPair metrics.RatioedChangeObserverPair, execSeatsObs metrics.RatioedChangeObserver) (fq.QueueSetCompleter, error) { if (pl.Spec.Type == flowcontrol.PriorityLevelEnablementExempt) != (pl.Spec.Limited == nil) { return nil, errors.New("broken union structure at the top") } @@ -689,7 +722,7 @@ func queueSetCompleterForPL(qsf fq.QueueSetFactory, queues fq.QueueSet, pl *flow if queues != nil { qsc, err = queues.BeginConfigChange(qcQS) } else { - qsc, err = qsf.BeginConstruction(qcQS, intPair) + qsc, err = qsf.BeginConstruction(qcQS, reqsIntPair, execSeatsObs) } if err != nil { err = fmt.Errorf("priority level %q has QueuingConfiguration %#+v, which is invalid: %w", pl.Name, qcAPI, err) @@ -734,17 +767,20 @@ func (meal *cfgMeal) presyncFlowSchemaStatus(fs *flowcontrol.FlowSchema, isDangl // that does not actually exist (right now) as a real API object. func (meal *cfgMeal) imaginePL(proto *flowcontrol.PriorityLevelConfiguration, requestWaitLimit time.Duration) { klog.V(3).Infof("No %s PriorityLevelConfiguration found, imagining one", proto.Name) - obsPair := meal.cfgCtlr.obsPairGenerator.Generate(1, 1, []string{proto.Name}) - qsCompleter, err := queueSetCompleterForPL(meal.cfgCtlr.queueSetFactory, nil, proto, requestWaitLimit, obsPair) + labelValues := []string{proto.Name} + reqsObsPair := meal.cfgCtlr.reqsObsPairGenerator.Generate(1, 1, labelValues) + execSeatsObs := meal.cfgCtlr.execSeatsObsGenerator.Generate(1, 1, labelValues) + qsCompleter, err := queueSetCompleterForPL(meal.cfgCtlr.queueSetFactory, nil, proto, requestWaitLimit, reqsObsPair, execSeatsObs) if err != nil { // This can not happen because proto is one of the mandatory // objects and these are not erroneous panic(err) } meal.newPLStates[proto.Name] = &priorityLevelState{ - pl: proto, - qsCompleter: qsCompleter, - obsPair: obsPair, + pl: proto, + qsCompleter: qsCompleter, + reqsObsPair: reqsObsPair, + execSeatsObs: execSeatsObs, } if proto.Spec.Limited != nil { meal.shareSum += float64(proto.Spec.Limited.AssuredConcurrencyShares) @@ -763,10 +799,10 @@ func (immediateRequest) Finish(execute func()) bool { // The returned bool indicates whether the request is exempt from // limitation. The startWaitingTime is when the request started // waiting in its queue, or `Time{}` if this did not happen. -func (cfgCtlr *configController) startRequest(ctx context.Context, rd RequestDigest, queueNoteFn fq.QueueNoteFn) (fs *flowcontrol.FlowSchema, pl *flowcontrol.PriorityLevelConfiguration, isExempt bool, req fq.Request, startWaitingTime time.Time) { +func (cfgCtlr *configController) startRequest(ctx context.Context, rd RequestDigest, workEstimator func(fs *flowcontrol.FlowSchema, pl *flowcontrol.PriorityLevelConfiguration, flowDistinguisher string) fcrequest.WorkEstimate, queueNoteFn fq.QueueNoteFn) (fs *flowcontrol.FlowSchema, pl *flowcontrol.PriorityLevelConfiguration, isExempt bool, req fq.Request, startWaitingTime time.Time) { klog.V(7).Infof("startRequest(%#+v)", rd) - cfgCtlr.lock.Lock() - defer cfgCtlr.lock.Unlock() + cfgCtlr.lock.RLock() + defer cfgCtlr.lock.RUnlock() var selectedFlowSchema, catchAllFlowSchema *flowcontrol.FlowSchema for _, fs := range cfgCtlr.flowSchemas { if matchesFlowSchema(rd, fs) { @@ -807,11 +843,12 @@ func (cfgCtlr *configController) startRequest(ctx context.Context, rd RequestDig flowDistinguisher = computeFlowDistinguisher(rd, selectedFlowSchema.Spec.DistinguisherMethod) hashValue = hashFlowID(selectedFlowSchema.Name, flowDistinguisher) } + workEstimate := workEstimator(selectedFlowSchema, plState.pl, flowDistinguisher) startWaitingTime = time.Now() klog.V(7).Infof("startRequest(%#+v) => fsName=%q, distMethod=%#+v, plName=%q, numQueues=%d", rd, selectedFlowSchema.Name, selectedFlowSchema.Spec.DistinguisherMethod, plName, numQueues) - req, idle := plState.queues.StartRequest(ctx, &rd.Width, hashValue, flowDistinguisher, selectedFlowSchema.Name, rd.RequestInfo, rd.User, queueNoteFn) + req, idle := plState.queues.StartRequest(ctx, &workEstimate, hashValue, flowDistinguisher, selectedFlowSchema.Name, rd.RequestInfo, rd.User, queueNoteFn) if idle { - cfgCtlr.maybeReapLocked(plName, plState) + cfgCtlr.maybeReapReadLocked(plName, plState) } return selectedFlowSchema, plState.pl, false, req, startWaitingTime } @@ -820,8 +857,8 @@ func (cfgCtlr *configController) startRequest(ctx context.Context, rd RequestDig // priority level if it has no more use. Call this after getting a // clue that the given priority level is undesired and idle. func (cfgCtlr *configController) maybeReap(plName string) { - cfgCtlr.lock.Lock() - defer cfgCtlr.lock.Unlock() + cfgCtlr.lock.RLock() + defer cfgCtlr.lock.RUnlock() plState := cfgCtlr.priorityLevelStates[plName] if plState == nil { klog.V(7).Infof("plName=%s, plState==nil", plName) @@ -843,7 +880,7 @@ func (cfgCtlr *configController) maybeReap(plName string) { // it has no more use. Call this if both (1) plState.queues is // non-nil and reported being idle, and (2) cfgCtlr's lock has not // been released since then. -func (cfgCtlr *configController) maybeReapLocked(plName string, plState *priorityLevelState) { +func (cfgCtlr *configController) maybeReapReadLocked(plName string, plState *priorityLevelState) { if !(plState.quiescing && plState.numPending == 0) { return } diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_controller_debug.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_controller_debug.go index 3c2c9fc744..91c49a4bed 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_controller_debug.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_controller_debug.go @@ -102,7 +102,11 @@ func (cfgCtlr *configController) dumpQueues(w http.ResponseWriter, r *http.Reque "Index", // 2 "PendingRequests", // 3 "ExecutingRequests", // 4 - "VirtualStart", // 5 + "SeatsInUse", // 5 + "NextDispatchR", // 6 + "InitialSeatsSum", // 7 + "MaxSeatsSum", // 8 + "TotalWorkSum", // 9 } tabPrint(tabWriter, rowForHeaders(columnHeaders)) endLine(tabWriter) @@ -114,18 +118,26 @@ func (cfgCtlr *configController) dumpQueues(w http.ResponseWriter, r *http.Reque "", // 3 "", // 4 "", // 5 + "", // 6 + "", // 7 + "", // 8 + "", // 9 )) endLine(tabWriter) continue } queueSetDigest := plState.queues.Dump(false) for i, q := range queueSetDigest.Queues { - tabPrint(tabWriter, rowForQueue( - plState.pl.Name, // 1 - i, // 2 - len(q.Requests), // 3 - q.ExecutingRequests, // 4 - q.VirtualStart, // 5 + tabPrint(tabWriter, row( + plState.pl.Name, // 1 - "PriorityLevelName" + strconv.Itoa(i), // 2 - "Index" + strconv.Itoa(len(q.Requests)), // 3 - "PendingRequests" + strconv.Itoa(q.ExecutingRequests), // 4 - "ExecutingRequests" + strconv.Itoa(q.SeatsInUse), // 5 - "SeatsInUse" + q.NextDispatchR, // 6 - "NextDispatchR" + strconv.Itoa(q.QueueSum.InitialSeatsSum), // 7 - "InitialSeatsSum" + strconv.Itoa(q.QueueSum.MaxSeatsSum), // 8 - "MaxSeatsSum" + q.QueueSum.TotalWorkSum, // 9 - "TotalWorkSum" )) endLine(tabWriter) } @@ -147,18 +159,21 @@ func (cfgCtlr *configController) dumpRequests(w http.ResponseWriter, r *http.Req "RequestIndexInQueue", // 4 "FlowDistingsher", // 5 "ArriveTime", // 6 + "InitialSeats", // 7 + "FinalSeats", // 8 + "AdditionalLatency", // 9 })) if includeRequestDetails { continueLine(tabWriter) tabPrint(tabWriter, rowForHeaders([]string{ - "UserName", // 7 - "Verb", // 8 - "APIPath", // 9 - "Namespace", // 10 - "Name", // 11 - "APIVersion", // 12 - "Resource", // 13 - "SubResource", // 14 + "UserName", // 10 + "Verb", // 11 + "APIPath", // 12 + "Namespace", // 13 + "Name", // 14 + "APIVersion", // 15 + "Resource", // 16 + "SubResource", // 17 })) } endLine(tabWriter) @@ -169,28 +184,31 @@ func (cfgCtlr *configController) dumpRequests(w http.ResponseWriter, r *http.Req queueSetDigest := plState.queues.Dump(includeRequestDetails) for iq, q := range queueSetDigest.Queues { for ir, r := range q.Requests { - tabPrint(tabWriter, rowForRequest( + tabPrint(tabWriter, row( plState.pl.Name, // 1 r.MatchedFlowSchema, // 2 - iq, // 3 - ir, // 4 + strconv.Itoa(iq), // 3 + strconv.Itoa(ir), // 4 r.FlowDistinguisher, // 5 - r.ArriveTime, // 6 + r.ArriveTime.UTC().Format(time.RFC3339Nano), // 6 + strconv.Itoa(int(r.WorkEstimate.InitialSeats)), // 7 + strconv.Itoa(int(r.WorkEstimate.FinalSeats)), // 8 + r.WorkEstimate.AdditionalLatency.String(), // 9 )) if includeRequestDetails { continueLine(tabWriter) tabPrint(tabWriter, rowForRequestDetails( - r.UserName, // 7 - r.RequestInfo.Verb, // 8 - r.RequestInfo.Path, // 9 - r.RequestInfo.Namespace, // 10 - r.RequestInfo.Name, // 11 + r.UserName, // 10 + r.RequestInfo.Verb, // 11 + r.RequestInfo.Path, // 12 + r.RequestInfo.Namespace, // 13 + r.RequestInfo.Name, // 14 schema.GroupVersion{ Group: r.RequestInfo.APIGroup, Version: r.RequestInfo.APIVersion, - }.String(), // 12 - r.RequestInfo.Resource, // 13 - r.RequestInfo.Subresource, // 14 + }.String(), // 15 + r.RequestInfo.Resource, // 16 + r.RequestInfo.Subresource, // 17 )) } endLine(tabWriter) @@ -229,27 +247,6 @@ func rowForPriorityLevel(plName string, activeQueues int, isIdle, isQuiescing bo ) } -func rowForQueue(plName string, index, waitingRequests, executingRequests int, virtualStart float64) string { - return row( - plName, - strconv.Itoa(index), - strconv.Itoa(waitingRequests), - strconv.Itoa(executingRequests), - fmt.Sprintf("%.4f", virtualStart), - ) -} - -func rowForRequest(plName, fsName string, queueIndex, requestIndex int, flowDistinguisher string, arriveTime time.Time) string { - return row( - plName, - fsName, - strconv.Itoa(queueIndex), - strconv.Itoa(requestIndex), - flowDistinguisher, - arriveTime.UTC().Format(time.RFC3339Nano), - ) -} - func rowForRequestDetails(username, verb, path, namespace, name, apiVersion, resource, subResource string) string { return row( username, diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_filter.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_filter.go index 8d914e796b..67149fd836 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_filter.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/apf_filter.go @@ -21,17 +21,18 @@ import ( "strconv" "time" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apiserver/pkg/server/mux" - "k8s.io/apiserver/pkg/util/flowcontrol/counter" fq "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing" + "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/eventclock" fqs "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset" "k8s.io/apiserver/pkg/util/flowcontrol/metrics" + fcrequest "k8s.io/apiserver/pkg/util/flowcontrol/request" kubeinformers "k8s.io/client-go/informers" "k8s.io/klog/v2" + "k8s.io/utils/clock" - flowcontrol "k8s.io/api/flowcontrol/v1beta1" - flowcontrolclient "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1" + flowcontrol "k8s.io/api/flowcontrol/v1beta2" + flowcontrolclient "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2" ) // ConfigConsumerAsFieldManager is how the config consuminng @@ -41,8 +42,9 @@ const ConfigConsumerAsFieldManager = "api-priority-and-fairness-config-consumer- // Interface defines how the API Priority and Fairness filter interacts with the underlying system. type Interface interface { // Handle takes care of queuing and dispatching a request - // characterized by the given digest. The given `noteFn` will be - // invoked with the results of request classification. If the + // characterized by the given digest. The given `workEstimator` will be + // invoked with the results of request classification and must return the + // work parameters for the request. If the // request is queued then `queueNoteFn` will be called twice, // first with `true` and then with `false`; otherwise // `queueNoteFn` will not be called at all. If Handle decides @@ -53,7 +55,7 @@ type Interface interface { // ctx is cancelled or times out. Handle(ctx context.Context, requestDigest RequestDigest, - noteFn func(fs *flowcontrol.FlowSchema, pl *flowcontrol.PriorityLevelConfiguration), + workEstimator func(fs *flowcontrol.FlowSchema, pl *flowcontrol.PriorityLevelConfiguration, flowDistinguisher string) fcrequest.WorkEstimate, queueNoteFn fq.QueueNoteFn, execFn func(), ) @@ -78,12 +80,11 @@ type Interface interface { // New creates a new instance to implement API priority and fairness func New( informerFactory kubeinformers.SharedInformerFactory, - flowcontrolClient flowcontrolclient.FlowcontrolV1beta1Interface, + flowcontrolClient flowcontrolclient.FlowcontrolV1beta2Interface, serverConcurrencyLimit int, requestWaitLimit time.Duration, ) Interface { - grc := counter.NoOp{} - clk := clock.RealClock{} + clk := eventclock.Real{} return NewTestable(TestableConfig{ Name: "Controller", Clock: clk, @@ -93,8 +94,9 @@ func New( FlowcontrolClient: flowcontrolClient, ServerConcurrencyLimit: serverConcurrencyLimit, RequestWaitLimit: requestWaitLimit, - ObsPairGenerator: metrics.PriorityLevelConcurrencyObserverPairGenerator, - QueueSetFactory: fqs.NewQueueSetFactory(clk, grc), + ReqsObsPairGenerator: metrics.PriorityLevelConcurrencyObserverPairGenerator, + ExecSeatsObsGenerator: metrics.PriorityLevelExecutionSeatsObserverGenerator, + QueueSetFactory: fqs.NewQueueSetFactory(clk), }) } @@ -124,7 +126,7 @@ type TestableConfig struct { InformerFactory kubeinformers.SharedInformerFactory // FlowcontrolClient to use for manipulating config objects - FlowcontrolClient flowcontrolclient.FlowcontrolV1beta1Interface + FlowcontrolClient flowcontrolclient.FlowcontrolV1beta2Interface // ServerConcurrencyLimit for the controller to enforce ServerConcurrencyLimit int @@ -132,8 +134,11 @@ type TestableConfig struct { // RequestWaitLimit configured on the server RequestWaitLimit time.Duration - // ObsPairGenerator for metrics - ObsPairGenerator metrics.TimedObserverPairGenerator + // ObsPairGenerator for metrics about requests + ReqsObsPairGenerator metrics.RatioedChangeObserverPairGenerator + + // RatioedChangeObserverPairGenerator for metrics about seats occupied by all phases of execution + ExecSeatsObsGenerator metrics.RatioedChangeObserverGenerator // QueueSetFactory for the queuing implementation QueueSetFactory fq.QueueSetFactory @@ -145,12 +150,11 @@ func NewTestable(config TestableConfig) Interface { } func (cfgCtlr *configController) Handle(ctx context.Context, requestDigest RequestDigest, - noteFn func(fs *flowcontrol.FlowSchema, pl *flowcontrol.PriorityLevelConfiguration), + workEstimator func(fs *flowcontrol.FlowSchema, pl *flowcontrol.PriorityLevelConfiguration, flowDistinguisher string) fcrequest.WorkEstimate, queueNoteFn fq.QueueNoteFn, execFn func()) { - fs, pl, isExempt, req, startWaitingTime := cfgCtlr.startRequest(ctx, requestDigest, queueNoteFn) + fs, pl, isExempt, req, startWaitingTime := cfgCtlr.startRequest(ctx, requestDigest, workEstimator, queueNoteFn) queued := startWaitingTime != time.Time{} - noteFn(fs, pl) if req == nil { if queued { metrics.ObserveWaitingDuration(ctx, pl.Name, fs.Name, strconv.FormatBool(req != nil), time.Since(startWaitingTime)) diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/counter/interface.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/counter/interface.go deleted file mode 100644 index 0418e1217a..0000000000 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/counter/interface.go +++ /dev/null @@ -1,33 +0,0 @@ -/* -Copyright 2019 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package counter - -// GoRoutineCounter keeps track of the number of active goroutines -// working on/for something. This is a utility that makes such code more -// testable. The code uses this utility to report the number of active -// goroutines to the test code, so that the test code can advance a fake -// clock when and only when the code being tested has finished all -// the work that is ready to do at the present time. -type GoRoutineCounter interface { - // Add adds the given delta to the count of active goroutines. - // Call Add(1) before forking a goroutine, Add(-1) at the end of that goroutine. - // Call Add(-1) just before waiting on something from another goroutine (e.g., - // just before a `select`). - // Call Add(1) just before doing something that unblocks a goroutine that is - // waiting on that something. - Add(delta int) -} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/debug/dump.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/debug/dump.go index 9d50c3e21a..b3cdb17bb9 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/debug/dump.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/debug/dump.go @@ -20,6 +20,7 @@ import ( "time" "k8s.io/apiserver/pkg/endpoints/request" + flowcontrolrequest "k8s.io/apiserver/pkg/util/flowcontrol/request" ) // QueueSetDump is an instant dump of queue-set. @@ -32,18 +33,26 @@ type QueueSetDump struct { // QueueDump is an instant dump of one queue in a queue-set. type QueueDump struct { + QueueSum QueueSum Requests []RequestDump - VirtualStart float64 + NextDispatchR string ExecutingRequests int SeatsInUse int } +type QueueSum struct { + InitialSeatsSum int + MaxSeatsSum int + TotalWorkSum string +} + // RequestDump is an instant dump of one requests pending in the queue. type RequestDump struct { MatchedFlowSchema string FlowDistinguisher string ArriveTime time.Time StartTime time.Time + WorkEstimate flowcontrolrequest.WorkEstimate // request details UserName string RequestInfo request.RequestInfo diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/eventclock/interface.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/eventclock/interface.go new file mode 100644 index 0000000000..58f88b9924 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/eventclock/interface.go @@ -0,0 +1,47 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package eventclock + +import ( + "time" + + baseclock "k8s.io/utils/clock" +) + +// EventFunc does some work that needs to be done at or after the +// given time. +type EventFunc func(time.Time) + +// EventClock is an active clock abstraction for use in code that is +// testable with a fake clock that itself determines how time may be +// advanced. The timing paradigm is invoking EventFuncs rather than +// synchronizing through channels, so that the fake clock has a handle +// on when associated activity is done. +type Interface interface { + baseclock.PassiveClock + + // Sleep returns after the given duration (or more). + Sleep(d time.Duration) + + // EventAfterDuration invokes the given EventFunc after the given duration (or more), + // passing the time when the invocation was launched. + EventAfterDuration(f EventFunc, d time.Duration) + + // EventAfterTime invokes the given EventFunc at the given time or later, + // passing the time when the invocation was launched. + EventAfterTime(f EventFunc, t time.Time) +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/eventclock/real.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/eventclock/real.go new file mode 100644 index 0000000000..d567a0f45e --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/eventclock/real.go @@ -0,0 +1,44 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package eventclock + +import ( + "time" + + "k8s.io/utils/clock" +) + +// RealEventClock fires event on real world time +type Real struct { + clock.RealClock +} + +var _ Interface = Real{} + +// EventAfterDuration schedules an EventFunc +func (Real) EventAfterDuration(f EventFunc, d time.Duration) { + ch := time.After(d) + go func() { + t := <-ch + f(t) + }() +} + +// EventAfterTime schedules an EventFunc +func (r Real) EventAfterTime(f EventFunc, t time.Time) { + r.EventAfterDuration(f, time.Until(t)) +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/integrator.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/integrator.go index dcba6f2c2e..800fa765fb 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/integrator.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/integrator.go @@ -21,17 +21,16 @@ import ( "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apiserver/pkg/util/flowcontrol/metrics" + "k8s.io/utils/clock" ) // Integrator computes the moments of some variable X over time as // read from a particular clock. The integrals start when the // Integrator is created, and ends at the latest operation on the -// Integrator. As a `metrics.TimedObserver` this fixes X1=1 and -// ignores attempts to change X1. +// Integrator. type Integrator interface { - metrics.TimedObserver + metrics.ChangeObserver GetResults() IntegratorResults @@ -70,10 +69,7 @@ func NewIntegrator(clock clock.PassiveClock) Integrator { } } -func (igr *integrator) SetX1(x1 float64) { -} - -func (igr *integrator) Set(x float64) { +func (igr *integrator) Observe(x float64) { igr.Lock() igr.setLocked(x) igr.Unlock() diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/interface.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/interface.go index 2de44c350d..cc772d8b7d 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/interface.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/interface.go @@ -31,8 +31,11 @@ import ( // are separated so that errors from the first phase can be found // before committing to a concurrency allotment for the second. type QueueSetFactory interface { - // BeginConstruction does the first phase of creating a QueueSet - BeginConstruction(QueuingConfig, metrics.TimedObserverPair) (QueueSetCompleter, error) + // BeginConstruction does the first phase of creating a QueueSet. + // The RatioedChangeObserverPair observes number of requests, + // execution covering just the regular phase. + // The RatioedChangeObserver observes number of seats occupied through all phases of execution. + BeginConstruction(QueuingConfig, metrics.RatioedChangeObserverPair, metrics.RatioedChangeObserver) (QueueSetCompleter, error) } // QueueSetCompleter finishes the two-step process of creating or @@ -81,7 +84,7 @@ type QueueSet interface { // was idle at the moment of the return. Otherwise idle==false // and the client must call the Finish method of the Request // exactly once. - StartRequest(ctx context.Context, width *request.Width, hashValue uint64, flowDistinguisher, fsName string, descr1, descr2 interface{}, queueNoteFn QueueNoteFn) (req Request, idle bool) + StartRequest(ctx context.Context, width *request.WorkEstimate, hashValue uint64, flowDistinguisher, fsName string, descr1, descr2 interface{}, queueNoteFn QueueNoteFn) (req Request, idle bool) // UpdateObservations makes sure any time-based statistics have // caught up with the current clock reading diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/interface.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/interface.go index 1977f7522a..b2e3adbdcb 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/interface.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/interface.go @@ -16,47 +16,15 @@ limitations under the License. package promise -// This file defines interfaces for promises and futures and related -// things. These are about coordination among multiple goroutines and -// so are safe for concurrent calls --- although moderated in some -// cases by a requirement that the caller hold a certain lock. - -// Readable represents a variable that is initially not set and later -// becomes set. Some instances may be set to multiple values in -// series. A Readable for a variable that can only get one value is -// commonly known as a "future". -type Readable interface { - // Get reads the current value of this variable. If this variable - // is not set yet then this call blocks until this variable gets a - // value. +// WriteOnce represents a variable that is initially not set and can +// be set once and is readable. This is the common meaning for +// "promise". +type WriteOnce interface { + // Get reads the current value of this variable. If this + // variable is not set yet then this call blocks until this + // variable gets a value. Get() interface{} - // IsSet returns immediately with an indication of whether this - // variable has been set. - IsSet() bool -} - -// LockingReadable is a Readable whose implementation is protected by -// a lock -type LockingReadable interface { - Readable - - // GetLocked is like Get but the caller must already hold the - // lock. GetLocked may release, and later re-acquire, the lock - // any number of times. Get may acquire, and later release, the - // lock any number of times. - GetLocked() interface{} - - // IsSetLocked is like IsSet but the caller must already hold the - // lock. IsSetLocked may release, and later re-acquire, the lock - // any number of times. IsSet may acquire, and later release, the - // lock any number of times. - IsSetLocked() bool -} - -// WriteOnceOnly represents a variable that is initially not set and -// can be set once. -type WriteOnceOnly interface { // Set normally writes a value into this variable, unblocks every // goroutine waiting for this variable to have a value, and // returns true. In the unhappy case that this variable is @@ -64,66 +32,3 @@ type WriteOnceOnly interface { // variable's value. Set(interface{}) bool } - -// WriteOnce represents a variable that is initially not set and can -// be set once and is readable. This is the common meaning for -// "promise". -type WriteOnce interface { - Readable - WriteOnceOnly -} - -// LockingWriteOnceOnly is a WriteOnceOnly whose implementation is -// protected by a lock. -type LockingWriteOnceOnly interface { - WriteOnceOnly - - // SetLocked is like Set but the caller must already hold the - // lock. SetLocked may release, and later re-acquire, the lock - // any number of times. Set may acquire, and later release, the - // lock any number of times - SetLocked(interface{}) bool -} - -// LockingWriteOnce is a WriteOnce whose implementation is protected -// by a lock. -type LockingWriteOnce interface { - LockingReadable - LockingWriteOnceOnly -} - -// WriteMultipleOnly represents a variable that is initially not set -// and can be set one or more times (unlike a traditional "promise", -// which can be written only once). -type WriteMultipleOnly interface { - // Set writes a value into this variable and unblocks every - // goroutine waiting for this variable to have a value - Set(interface{}) -} - -// WriteMultiple represents a variable that is initially not set and -// can be set one or more times (unlike a traditional "promise", which -// can be written only once) and is readable. -type WriteMultiple interface { - Readable - WriteMultipleOnly -} - -// LockingWriteMultipleOnly is a WriteMultipleOnly whose -// implementation is protected by a lock. -type LockingWriteMultipleOnly interface { - WriteMultipleOnly - - // SetLocked is like Set but the caller must already hold the - // lock. SetLocked may release, and later re-acquire, the lock - // any number of times. Set may acquire, and later release, the - // lock any number of times - SetLocked(interface{}) -} - -// LockingWriteMultiple is a WriteMultiple whose implementation is -// protected by a lock. -type LockingWriteMultiple interface { - LockingReadable - LockingWriteMultipleOnly -} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/lockingpromise/lockingpromise.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/lockingpromise/lockingpromise.go deleted file mode 100644 index db5598f898..0000000000 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/lockingpromise/lockingpromise.go +++ /dev/null @@ -1,124 +0,0 @@ -/* -Copyright 2019 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package lockingpromise - -import ( - "sync" - - "k8s.io/apiserver/pkg/util/flowcontrol/counter" - "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise" -) - -// promisoid is the data and behavior common to all the promise-like -// abstractions implemented here. This implementation is based on a -// condition variable. This implementation tracks active goroutines: -// the given counter is decremented for a goroutine waiting for this -// varible to be set and incremented when such a goroutine is -// unblocked. -type promisoid struct { - lock sync.Locker - cond sync.Cond - activeCounter counter.GoRoutineCounter // counter of active goroutines - waitingCount int // number of goroutines idle due to this being unset - isSet bool - value interface{} -} - -func (pr *promisoid) Get() interface{} { - pr.lock.Lock() - defer pr.lock.Unlock() - return pr.GetLocked() -} - -func (pr *promisoid) GetLocked() interface{} { - if !pr.isSet { - pr.waitingCount++ - pr.activeCounter.Add(-1) - pr.cond.Wait() - } - return pr.value -} - -func (pr *promisoid) IsSet() bool { - pr.lock.Lock() - defer pr.lock.Unlock() - return pr.IsSetLocked() -} - -func (pr *promisoid) IsSetLocked() bool { - return pr.isSet -} - -func (pr *promisoid) SetLocked(value interface{}) { - pr.isSet = true - pr.value = value - if pr.waitingCount > 0 { - pr.activeCounter.Add(pr.waitingCount) - pr.waitingCount = 0 - pr.cond.Broadcast() - } -} - -type writeOnce struct { - promisoid -} - -var _ promise.LockingWriteOnce = &writeOnce{} - -// NewWriteOnce makes a new promise.LockingWriteOnce -func NewWriteOnce(lock sync.Locker, activeCounter counter.GoRoutineCounter) promise.LockingWriteOnce { - return &writeOnce{promisoid{ - lock: lock, - cond: *sync.NewCond(lock), - activeCounter: activeCounter, - }} -} - -func (wr *writeOnce) Set(value interface{}) bool { - wr.lock.Lock() - defer wr.lock.Unlock() - return wr.SetLocked(value) -} - -func (wr *writeOnce) SetLocked(value interface{}) bool { - if wr.isSet { - return false - } - wr.promisoid.SetLocked(value) - return true -} - -type writeMultiple struct { - promisoid -} - -var _ promise.LockingWriteMultiple = &writeMultiple{} - -// NewWriteMultiple makes a new promise.LockingWriteMultiple -func NewWriteMultiple(lock sync.Locker, activeCounter counter.GoRoutineCounter) promise.LockingWriteMultiple { - return &writeMultiple{promisoid{ - lock: lock, - cond: *sync.NewCond(lock), - activeCounter: activeCounter, - }} -} - -func (wr *writeMultiple) Set(value interface{}) { - wr.lock.Lock() - defer wr.lock.Unlock() - wr.SetLocked(value) -} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/promise.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/promise.go new file mode 100644 index 0000000000..d3bda40aaa --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/promise.go @@ -0,0 +1,70 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package promise + +import ( + "sync" +) + +// promise implements the WriteOnce interface. +type promise struct { + doneCh <-chan struct{} + doneVal interface{} + setCh chan struct{} + onceler sync.Once + value interface{} +} + +var _ WriteOnce = &promise{} + +// NewWriteOnce makes a new thread-safe WriteOnce. +// +// If `initial` is non-nil then that value is Set at creation time. +// +// If a `Get` is waiting soon after `doneCh` becomes selectable (which +// never happens for the nil channel) then `Set(doneVal)` effectively +// happens at that time. +func NewWriteOnce(initial interface{}, doneCh <-chan struct{}, doneVal interface{}) WriteOnce { + p := &promise{ + doneCh: doneCh, + doneVal: doneVal, + setCh: make(chan struct{}), + } + if initial != nil { + p.Set(initial) + } + return p +} + +func (p *promise) Get() interface{} { + select { + case <-p.setCh: + case <-p.doneCh: + p.Set(p.doneVal) + } + return p.value +} + +func (p *promise) Set(value interface{}) bool { + var ans bool + p.onceler.Do(func() { + p.value = value + close(p.setCh) + ans = true + }) + return ans +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/fifo_list.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/fifo_list.go index 5c7e7acf5d..eb56e1e946 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/fifo_list.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/fifo_list.go @@ -20,22 +20,25 @@ import ( "container/list" ) -// removeFromFIFOFunc removes a designated element from the list. -// The complexity of the runtime cost is O(1) -// It returns the request removed from the list. +// removeFromFIFOFunc removes a designated element from the list +// if that element is in the list. +// The complexity of the runtime cost is O(1). +// The returned value is the element removed, if indeed one was removed, +// otherwise `nil`. type removeFromFIFOFunc func() *request // walkFunc is called for each request in the list in the // oldest -> newest order. // ok: if walkFunc returns false then the iteration stops immediately. +// walkFunc may remove the given request from the fifo, +// but may not mutate the fifo in any othe way. type walkFunc func(*request) (ok bool) // Internal interface to abstract out the implementation details // of the underlying list used to maintain the requests. // -// Note that the FIFO list is not safe for concurrent use by multiple -// goroutines without additional locking or coordination. It rests with -// the user to ensure that the FIFO list is used with proper locking. +// Note that a fifo, including the removeFromFIFOFuncs returned from Enqueue, +// is not safe for concurrent use by multiple goroutines. type fifo interface { // Enqueue enqueues the specified request into the list and // returns a removeFromFIFOFunc function that can be used to remove the @@ -45,12 +48,15 @@ type fifo interface { // Dequeue pulls out the oldest request from the list. Dequeue() (*request, bool) + // Peek returns the oldest request without removing it. + Peek() (*request, bool) + // Length returns the number of requests in the list. Length() int - // SeatsSum returns the total number of seats of all requests - // in this list. - SeatsSum() int + // QueueSum returns the sum of initial seats, final seats, and + // additional latency aggregated from all requests in this queue. + QueueSum() queueSum // Walk iterates through the list in order of oldest -> newest // and executes the specified walkFunc for each request in that order. @@ -61,11 +67,11 @@ type fifo interface { } // the FIFO list implementation is not safe for concurrent use by multiple -// goroutines without additional locking or coordination. +// goroutines. type requestFIFO struct { *list.List - seatsSum int + sum queueSum } func newRequestFIFO() fifo { @@ -78,44 +84,57 @@ func (l *requestFIFO) Length() int { return l.Len() } -func (l *requestFIFO) SeatsSum() int { - return l.seatsSum +func (l *requestFIFO) QueueSum() queueSum { + return l.sum } func (l *requestFIFO) Enqueue(req *request) removeFromFIFOFunc { e := l.PushBack(req) - l.seatsSum += req.Seats() + addToQueueSum(&l.sum, req) return func() *request { - if e.Value != nil { - l.Remove(e) - e.Value = nil - l.seatsSum -= req.Seats() + if e.Value == nil { + return nil } + l.Remove(e) + e.Value = nil + deductFromQueueSum(&l.sum, req) return req } } func (l *requestFIFO) Dequeue() (*request, bool) { + return l.getFirst(true) +} + +func (l *requestFIFO) Peek() (*request, bool) { + return l.getFirst(false) +} + +func (l *requestFIFO) getFirst(remove bool) (*request, bool) { e := l.Front() if e == nil { return nil, false } - defer func() { - l.Remove(e) - e.Value = nil - }() + if remove { + defer func() { + l.Remove(e) + e.Value = nil + }() + } request, ok := e.Value.(*request) - if ok { - l.seatsSum -= request.Seats() + if remove && ok { + deductFromQueueSum(&l.sum, request) } return request, ok } func (l *requestFIFO) Walk(f walkFunc) { - for current := l.Front(); current != nil; current = current.Next() { + var next *list.Element + for current := l.Front(); current != nil; current = next { + next = current.Next() // f is allowed to remove current if r, ok := current.Value.(*request); ok { if !f(r) { return @@ -123,3 +142,15 @@ func (l *requestFIFO) Walk(f walkFunc) { } } } + +func addToQueueSum(sum *queueSum, req *request) { + sum.InitialSeatsSum += req.InitialSeats() + sum.MaxSeatsSum += req.MaxSeats() + sum.TotalWorkSum += req.totalWork() +} + +func deductFromQueueSum(sum *queueSum, req *request) { + sum.InitialSeatsSum -= req.InitialSeats() + sum.MaxSeatsSum -= req.MaxSeats() + sum.TotalWorkSum -= req.totalWork() +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/queueset.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/queueset.go index e4938e9f2e..440975faf3 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/queueset.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/queueset.go @@ -18,21 +18,25 @@ package queueset import ( "context" + "errors" "fmt" "math" "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" - "k8s.io/apimachinery/pkg/util/runtime" - "k8s.io/apiserver/pkg/util/flowcontrol/counter" "k8s.io/apiserver/pkg/util/flowcontrol/debug" fq "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing" - "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/lockingpromise" + "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/eventclock" + "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise" "k8s.io/apiserver/pkg/util/flowcontrol/metrics" fqrequest "k8s.io/apiserver/pkg/util/flowcontrol/request" "k8s.io/apiserver/pkg/util/shufflesharding" "k8s.io/klog/v2" + + // The following hack is needed to work around a tooling deficiency. + // Packages imported only for test code are not included in vendor. + // See https://kubernetes.slack.com/archives/C0EG7JC6T/p1626985671458800?thread_ts=1626983387.450800&cid=C0EG7JC6T + _ "k8s.io/utils/clock/testing" ) const nsTimeFmt = "2006-01-02 15:04:05.000000000" @@ -40,34 +44,48 @@ const nsTimeFmt = "2006-01-02 15:04:05.000000000" // queueSetFactory implements the QueueSetFactory interface // queueSetFactory makes QueueSet objects. type queueSetFactory struct { - counter counter.GoRoutineCounter - clock clock.PassiveClock + clock eventclock.Interface + promiseFactoryFactory promiseFactoryFactory } +// promiseFactory returns a WriteOnce +// - whose Set method is invoked with the queueSet locked, and +// - whose Get method is invoked with the queueSet not locked. +// The parameters are the same as for `promise.NewWriteOnce`. +type promiseFactory func(initial interface{}, doneCh <-chan struct{}, doneVal interface{}) promise.WriteOnce + +// promiseFactoryFactory returns the promiseFactory to use for the given queueSet +type promiseFactoryFactory func(*queueSet) promiseFactory + // `*queueSetCompleter` implements QueueSetCompleter. Exactly one of // the fields `factory` and `theSet` is non-nil. type queueSetCompleter struct { - factory *queueSetFactory - obsPair metrics.TimedObserverPair - theSet *queueSet - qCfg fq.QueuingConfig - dealer *shufflesharding.Dealer + factory *queueSetFactory + reqsObsPair metrics.RatioedChangeObserverPair + execSeatsObs metrics.RatioedChangeObserver + theSet *queueSet + qCfg fq.QueuingConfig + dealer *shufflesharding.Dealer } // queueSet implements the Fair Queuing for Server Requests technique // described in this package's doc, and a pointer to one implements -// the QueueSet interface. The clock, GoRoutineCounter, and estimated -// service time should not be changed; the fields listed after the +// the QueueSet interface. The fields listed before the lock +// should not be changed; the fields listed after the // lock must be accessed only while holding the lock. The methods of // this type follow the naming convention that the suffix "Locked" // means the caller must hold the lock; for a method whose name does // not end in "Locked" either acquires the lock or does not care about // locking. type queueSet struct { - clock clock.PassiveClock - counter counter.GoRoutineCounter - estimatedServiceTime float64 - obsPair metrics.TimedObserverPair + clock eventclock.Interface + estimatedServiceDuration time.Duration + + reqsObsPair metrics.RatioedChangeObserverPair // .RequestsExecuting covers regular phase only + + execSeatsObs metrics.RatioedChangeObserver // for all phases of execution + + promiseFactory promiseFactory lock sync.Mutex @@ -81,16 +99,17 @@ type queueSet struct { // the current dispatching configuration. dCfg fq.DispatchingConfig - // If `config.DesiredNumQueues` is non-zero then dealer is not nil - // and is good for `config`. + // If `qCfg.DesiredNumQueues` is non-zero then dealer is not nil + // and is good for `qCfg`. dealer *shufflesharding.Dealer // queues may be longer than the desired number, while the excess // queues are still draining. queues []*queue - // virtualTime is the number of virtual seconds since process startup - virtualTime float64 + // currentR is the amount of seat-seconds allocated per queue since process startup. + // This is our generalization of the progress meter named R in the original fair queuing work. + currentR fqrequest.SeatSeconds // lastRealTime is what `clock.Now()` yielded when `virtualTime` was last updated lastRealTime time.Time @@ -111,26 +130,35 @@ type queueSet struct { // totSeatsInUse is the number of total "seats" in use by all the // request(s) that are currently executing in this queueset. totSeatsInUse int + + // enqueues is the number of requests that have ever been enqueued + enqueues int } // NewQueueSetFactory creates a new QueueSetFactory object -func NewQueueSetFactory(c clock.PassiveClock, counter counter.GoRoutineCounter) fq.QueueSetFactory { +func NewQueueSetFactory(c eventclock.Interface) fq.QueueSetFactory { + return newTestableQueueSetFactory(c, ordinaryPromiseFactoryFactory) +} + +// newTestableQueueSetFactory creates a new QueueSetFactory object with the given promiseFactoryFactory +func newTestableQueueSetFactory(c eventclock.Interface, promiseFactoryFactory promiseFactoryFactory) fq.QueueSetFactory { return &queueSetFactory{ - counter: counter, - clock: c, + clock: c, + promiseFactoryFactory: promiseFactoryFactory, } } -func (qsf *queueSetFactory) BeginConstruction(qCfg fq.QueuingConfig, obsPair metrics.TimedObserverPair) (fq.QueueSetCompleter, error) { +func (qsf *queueSetFactory) BeginConstruction(qCfg fq.QueuingConfig, reqsObsPair metrics.RatioedChangeObserverPair, execSeatsObs metrics.RatioedChangeObserver) (fq.QueueSetCompleter, error) { dealer, err := checkConfig(qCfg) if err != nil { return nil, err } return &queueSetCompleter{ - factory: qsf, - obsPair: obsPair, - qCfg: qCfg, - dealer: dealer}, nil + factory: qsf, + reqsObsPair: reqsObsPair, + execSeatsObs: execSeatsObs, + qCfg: qCfg, + dealer: dealer}, nil } // checkConfig returns a non-nil Dealer if the config is valid and @@ -151,16 +179,17 @@ func (qsc *queueSetCompleter) Complete(dCfg fq.DispatchingConfig) fq.QueueSet { qs := qsc.theSet if qs == nil { qs = &queueSet{ - clock: qsc.factory.clock, - counter: qsc.factory.counter, - estimatedServiceTime: 60, - obsPair: qsc.obsPair, - qCfg: qsc.qCfg, - virtualTime: 0, - lastRealTime: qsc.factory.clock.Now(), + clock: qsc.factory.clock, + estimatedServiceDuration: 3 * time.Millisecond, + reqsObsPair: qsc.reqsObsPair, + execSeatsObs: qsc.execSeatsObs, + qCfg: qsc.qCfg, + currentR: 0, + lastRealTime: qsc.factory.clock.Now(), } + qs.promiseFactory = qsc.factory.promiseFactoryFactory(qs) } - qs.setConfiguration(qsc.qCfg, qsc.dealer, dCfg) + qs.setConfiguration(context.Background(), qsc.qCfg, qsc.dealer, dCfg) return qs } @@ -184,18 +213,18 @@ func (qs *queueSet) BeginConfigChange(qCfg fq.QueuingConfig) (fq.QueueSetComplet dealer: dealer}, nil } -// SetConfiguration is used to set the configuration for a queueSet. +// setConfiguration is used to set the configuration for a queueSet. // Update handling for when fields are updated is handled here as well - -// eg: if DesiredNum is increased, SetConfiguration reconciles by +// eg: if DesiredNum is increased, setConfiguration reconciles by // adding more queues. -func (qs *queueSet) setConfiguration(qCfg fq.QueuingConfig, dealer *shufflesharding.Dealer, dCfg fq.DispatchingConfig) { - qs.lockAndSyncTime() +func (qs *queueSet) setConfiguration(ctx context.Context, qCfg fq.QueuingConfig, dealer *shufflesharding.Dealer, dCfg fq.DispatchingConfig) { + qs.lockAndSyncTime(ctx) defer qs.lock.Unlock() if qCfg.DesiredNumQueues > 0 { // Adding queues is the only thing that requires immediate action - // Removing queues is handled by omitting indexes >DesiredNum from - // chooseQueueIndexLocked + // Removing queues is handled by attrition, removing a queue when + // it goes empty and there are too many. numQueues := len(qs.queues) if qCfg.DesiredNumQueues > numQueues { qs.queues = append(qs.queues, @@ -214,8 +243,9 @@ func (qs *queueSet) setConfiguration(qCfg fq.QueuingConfig, dealer *shuffleshard if qll < 1 { qll = 1 } - qs.obsPair.RequestsWaiting.SetX1(float64(qll)) - qs.obsPair.RequestsExecuting.SetX1(float64(dCfg.ConcurrencyLimit)) + qs.reqsObsPair.RequestsWaiting.SetDenominator(float64(qll)) + qs.reqsObsPair.RequestsExecuting.SetDenominator(float64(dCfg.ConcurrencyLimit)) + qs.execSeatsObs.SetDenominator(float64(dCfg.ConcurrencyLimit)) qs.dispatchAsMuchAsPossibleLocked() } @@ -225,8 +255,13 @@ type requestDecision int // Values passed through a request's decision const ( + // Serve this one decisionExecute requestDecision = iota + + // Reject this one due to APF queuing considerations decisionReject + + // This one's context timed out / was canceled decisionCancel ) @@ -235,8 +270,10 @@ const ( // executing at each point where there is a change in that quantity, // because the metrics --- and only the metrics --- track that // quantity per FlowSchema. -func (qs *queueSet) StartRequest(ctx context.Context, width *fqrequest.Width, hashValue uint64, flowDistinguisher, fsName string, descr1, descr2 interface{}, queueNoteFn fq.QueueNoteFn) (fq.Request, bool) { - qs.lockAndSyncTime() +// The queueSet's promiseFactory is invoked once if the returned Request is non-nil, +// not invoked if the Request is nil. +func (qs *queueSet) StartRequest(ctx context.Context, workEstimate *fqrequest.WorkEstimate, hashValue uint64, flowDistinguisher, fsName string, descr1, descr2 interface{}, queueNoteFn fq.QueueNoteFn) (fq.Request, bool) { + qs.lockAndSyncTime(ctx) defer qs.lock.Unlock() var req *request @@ -244,13 +281,13 @@ func (qs *queueSet) StartRequest(ctx context.Context, width *fqrequest.Width, ha // Step 0: // Apply only concurrency limit, if zero queues desired if qs.qCfg.DesiredNumQueues < 1 { - if !qs.canAccommodateSeatsLocked(int(width.Seats)) { + if !qs.canAccommodateSeatsLocked(workEstimate.MaxSeats()) { klog.V(5).Infof("QS(%s): rejecting request %q %#+v %#+v because %d seats are asked for, %d seats are in use (%d are executing) and the limit is %d", - qs.qCfg.Name, fsName, descr1, descr2, width, qs.totSeatsInUse, qs.totRequestsExecuting, qs.dCfg.ConcurrencyLimit) + qs.qCfg.Name, fsName, descr1, descr2, workEstimate, qs.totSeatsInUse, qs.totRequestsExecuting, qs.dCfg.ConcurrencyLimit) metrics.AddReject(ctx, qs.qCfg.Name, fsName, "concurrency-limit") return nil, qs.isIdleLocked() } - req = qs.dispatchSansQueueLocked(ctx, width, flowDistinguisher, fsName, descr1, descr2) + req = qs.dispatchSansQueueLocked(ctx, workEstimate, flowDistinguisher, fsName, descr1, descr2) return req, false } @@ -261,7 +298,7 @@ func (qs *queueSet) StartRequest(ctx context.Context, width *fqrequest.Width, ha // 3) Reject current request if there is not enough concurrency shares and // we are at max queue length // 4) If not rejected, create a request and enqueue - req = qs.timeoutOldRequestsAndRejectOrEnqueueLocked(ctx, width, hashValue, flowDistinguisher, fsName, descr1, descr2, queueNoteFn) + req = qs.timeoutOldRequestsAndRejectOrEnqueueLocked(ctx, workEstimate, hashValue, flowDistinguisher, fsName, descr1, descr2, queueNoteFn) // req == nil means that the request was rejected - no remaining // concurrency shares and at max queue length already if req == nil { @@ -281,42 +318,24 @@ func (qs *queueSet) StartRequest(ctx context.Context, width *fqrequest.Width, ha // request from that queue. qs.dispatchAsMuchAsPossibleLocked() - // ======================================================================== - // Step 3: - - // Set up a relay from the context's Done channel to the world - // of well-counted goroutines. We Are Told that every - // request's context's Done channel gets closed by the time - // the request is done being processed. - doneCh := ctx.Done() - - // Retrieve the queueset configuration name while we have the lock - // and use it in the goroutine below. - configName := qs.qCfg.Name - - if doneCh != nil { - qs.preCreateOrUnblockGoroutine() - go func() { - defer runtime.HandleCrash() - qs.goroutineDoneOrBlocked() - _ = <-doneCh - // Whatever goroutine unblocked the preceding receive MUST - // have already either (a) incremented qs.counter or (b) - // known that said counter is not actually counting or (c) - // known that the count does not need to be accurate. - // BTW, the count only needs to be accurate in a test that - // uses FakeEventClock::Run(). - klog.V(6).Infof("QS(%s): Context of request %q %#+v %#+v is Done", configName, fsName, descr1, descr2) - qs.cancelWait(req) - qs.goroutineDoneOrBlocked() - }() - } return req, false } -// Seats returns the number of seats this request requires. -func (req *request) Seats() int { - return int(req.width.Seats) +// ordinaryPromiseFactoryFactory is the promiseFactoryFactory that +// a queueSetFactory would ordinarily use. +// Test code might use something different. +func ordinaryPromiseFactoryFactory(qs *queueSet) promiseFactory { + return promise.NewWriteOnce +} + +// MaxSeats returns the maximum number of seats this request requires, it is +// the maxumum of the two - WorkEstimate.InitialSeats, WorkEstimate.FinalSeats. +func (req *request) MaxSeats() int { + return req.workEstimate.MaxSeats() +} + +func (req *request) InitialSeats() int { + return int(req.workEstimate.InitialSeats) } func (req *request) NoteQueued(inQueue bool) { @@ -343,41 +362,45 @@ func (req *request) Finish(execFn func()) bool { func (req *request) wait() (bool, bool) { qs := req.qs - qs.lock.Lock() + + // ======================================================================== + // Step 3: + // The final step is to wait on a decision from + // somewhere and then act on it. + decisionAny := req.decision.Get() + qs.lockAndSyncTime(req.ctx) defer qs.lock.Unlock() if req.waitStarted { // This can not happen, because the client is forbidden to // call Wait twice on the same request - panic(fmt.Sprintf("Multiple calls to the Wait method, QueueSet=%s, startTime=%s, descr1=%#+v, descr2=%#+v", req.qs.qCfg.Name, req.startTime, req.descr1, req.descr2)) + klog.Errorf("Duplicate call to the Wait method! Immediately returning execute=false. QueueSet=%s, startTime=%s, descr1=%#+v, descr2=%#+v", req.qs.qCfg.Name, req.startTime, req.descr1, req.descr2) + return false, qs.isIdleLocked() } req.waitStarted = true - - // ======================================================================== - // Step 4: - // The final step is to wait on a decision from - // somewhere and then act on it. - decisionAny := req.decision.GetLocked() - qs.syncTimeLocked() - decision, isDecision := decisionAny.(requestDecision) - if !isDecision { - panic(fmt.Sprintf("QS(%s): Impossible decision %#+v (of type %T) for request %#+v %#+v", qs.qCfg.Name, decisionAny, decisionAny, req.descr1, req.descr2)) - } - switch decision { + switch decisionAny { case decisionReject: klog.V(5).Infof("QS(%s): request %#+v %#+v timed out after being enqueued\n", qs.qCfg.Name, req.descr1, req.descr2) metrics.AddReject(req.ctx, qs.qCfg.Name, req.fsName, "time-out") return false, qs.isIdleLocked() case decisionCancel: - // TODO(aaron-prindle) add metrics for this case - klog.V(5).Infof("QS(%s): Ejecting request %#+v %#+v from its queue", qs.qCfg.Name, req.descr1, req.descr2) - return false, qs.isIdleLocked() case decisionExecute: klog.V(5).Infof("QS(%s): Dispatching request %#+v %#+v from its queue", qs.qCfg.Name, req.descr1, req.descr2) return true, false default: // This can not happen, all possible values are handled above - panic(decision) + klog.Errorf("QS(%s): Impossible decision (type %T, value %#+v) for request %#+v %#+v! Treating as cancel", qs.qCfg.Name, decisionAny, decisionAny, req.descr1, req.descr2) } + // TODO(aaron-prindle) add metrics for this case + klog.V(5).Infof("QS(%s): Ejecting request %#+v %#+v from its queue", qs.qCfg.Name, req.descr1, req.descr2) + // remove the request from the queue as it has timed out + if req.removeFromQueueLocked() != nil { + qs.totRequestsWaiting-- + metrics.AddReject(req.ctx, qs.qCfg.Name, req.fsName, "cancelled") + metrics.AddRequestsInQueues(req.ctx, qs.qCfg.Name, req.fsName, -1) + req.NoteQueued(false) + qs.reqsObsPair.RequestsWaiting.Add(-1) + } + return false, qs.isIdleLocked() } func (qs *queueSet) IsIdle() bool { @@ -391,23 +414,74 @@ func (qs *queueSet) isIdleLocked() bool { } // lockAndSyncTime acquires the lock and updates the virtual time. -// Doing them together avoids the mistake of modify some queue state +// Doing them together avoids the mistake of modifying some queue state // before calling syncTimeLocked. -func (qs *queueSet) lockAndSyncTime() { +func (qs *queueSet) lockAndSyncTime(ctx context.Context) { qs.lock.Lock() - qs.syncTimeLocked() + qs.syncTimeLocked(ctx) } // syncTimeLocked updates the virtual time based on the assumption // that the current state of the queues has been in effect since // `qs.lastRealTime`. Thus, it should be invoked after acquiring the // lock and before modifying the state of any queue. -func (qs *queueSet) syncTimeLocked() { +func (qs *queueSet) syncTimeLocked(ctx context.Context) { realNow := qs.clock.Now() - timeSinceLast := realNow.Sub(qs.lastRealTime).Seconds() + timeSinceLast := realNow.Sub(qs.lastRealTime) qs.lastRealTime = realNow - qs.virtualTime += timeSinceLast * qs.getVirtualTimeRatioLocked() - metrics.SetCurrentR(qs.qCfg.Name, qs.virtualTime) + prevR := qs.currentR + incrR := fqrequest.SeatsTimesDuration(qs.getVirtualTimeRatioLocked(), timeSinceLast) + qs.currentR = prevR + incrR + switch { + case prevR > qs.currentR: + klog.ErrorS(errors.New("queueset::currentR overflow"), "Overflow", "QS", qs.qCfg.Name, "when", realNow.Format(nsTimeFmt), "prevR", prevR, "incrR", incrR, "currentR", qs.currentR) + case qs.currentR >= highR: + qs.advanceEpoch(ctx, realNow, incrR) + } + metrics.SetCurrentR(qs.qCfg.Name, qs.currentR.ToFloat()) +} + +// rDecrement is the amount by which the progress meter R is wound backwards +// when needed to avoid overflow. +const rDecrement = fqrequest.MaxSeatSeconds / 2 + +// highR is the threshold that triggers advance of the epoch. +// That is, decrementing the global progress meter R by rDecrement. +const highR = rDecrement + rDecrement/2 + +// advanceEpoch subtracts rDecrement from the global progress meter R +// and all the readings that have been taked from that meter. +// The now and incrR parameters are only used to add info to the log messages. +func (qs *queueSet) advanceEpoch(ctx context.Context, now time.Time, incrR fqrequest.SeatSeconds) { + oldR := qs.currentR + qs.currentR -= rDecrement + klog.InfoS("Advancing epoch", "QS", qs.qCfg.Name, "when", now.Format(nsTimeFmt), "oldR", oldR, "newR", qs.currentR, "incrR", incrR) + success := true + for qIdx, queue := range qs.queues { + if queue.requests.Length() == 0 && queue.requestsExecuting == 0 { + // Do not just decrement, the value could be quite outdated. + // It is safe to reset to zero in this case, because the next request + // will overwrite the zero with `qs.currentR`. + queue.nextDispatchR = 0 + continue + } + oldNextDispatchR := queue.nextDispatchR + queue.nextDispatchR -= rDecrement + if queue.nextDispatchR > oldNextDispatchR { + klog.ErrorS(errors.New("queue::nextDispatchR underflow"), "Underflow", "QS", qs.qCfg.Name, "queue", qIdx, "oldNextDispatchR", oldNextDispatchR, "newNextDispatchR", queue.nextDispatchR, "incrR", incrR) + success = false + } + queue.requests.Walk(func(req *request) bool { + oldArrivalR := req.arrivalR + req.arrivalR -= rDecrement + if req.arrivalR > oldArrivalR { + klog.ErrorS(errors.New("request::arrivalR underflow"), "Underflow", "QS", qs.qCfg.Name, "queue", qIdx, "request", *req, "oldArrivalR", oldArrivalR, "incrR", incrR) + success = false + } + return true + }) + } + metrics.AddEpochAdvance(ctx, qs.qCfg.Name, success) } // getVirtualTimeRatio calculates the rate at which virtual time has @@ -416,7 +490,9 @@ func (qs *queueSet) getVirtualTimeRatioLocked() float64 { activeQueues := 0 seatsRequested := 0 for _, queue := range qs.queues { - seatsRequested += (queue.seatsInUse + queue.requests.SeatsSum()) + // here we want the sum of the maximum width of the requests in this queue since our + // goal is to find the maximum rate at which the queue could work. + seatsRequested += (queue.seatsInUse + queue.requests.QueueSum().MaxSeatsSum) if queue.requests.Length() > 0 || queue.requestsExecuting > 0 { activeQueues++ } @@ -437,9 +513,9 @@ func (qs *queueSet) getVirtualTimeRatioLocked() float64 { // returns the enqueud request on a successful enqueue // returns nil in the case that there is no available concurrency or // the queuelengthlimit has been reached -func (qs *queueSet) timeoutOldRequestsAndRejectOrEnqueueLocked(ctx context.Context, width *fqrequest.Width, hashValue uint64, flowDistinguisher, fsName string, descr1, descr2 interface{}, queueNoteFn fq.QueueNoteFn) *request { +func (qs *queueSet) timeoutOldRequestsAndRejectOrEnqueueLocked(ctx context.Context, workEstimate *fqrequest.WorkEstimate, hashValue uint64, flowDistinguisher, fsName string, descr1, descr2 interface{}, queueNoteFn fq.QueueNoteFn) *request { // Start with the shuffle sharding, to pick a queue. - queueIdx := qs.chooseQueueIndexLocked(hashValue, descr1, descr2) + queueIdx := qs.shuffleShardLocked(hashValue, descr1, descr2) queue := qs.queues[queueIdx] // The next step is the logic to reject requests that have been waiting too long qs.removeTimedOutRequestsFromQueueLocked(queue, fsName) @@ -447,19 +523,22 @@ func (qs *queueSet) timeoutOldRequestsAndRejectOrEnqueueLocked(ctx context.Conte // requests that are in the queue longer than the timeout if there are no new requests // We prefer the simplicity over the promptness, at least for now. + defer qs.boundNextDispatchLocked(queue) + // Create a request and enqueue req := &request{ qs: qs, fsName: fsName, flowDistinguisher: flowDistinguisher, ctx: ctx, - decision: lockingpromise.NewWriteOnce(&qs.lock, qs.counter), + decision: qs.promiseFactory(nil, ctx.Done(), decisionCancel), arrivalTime: qs.clock.Now(), + arrivalR: qs.currentR, queue: queue, descr1: descr1, descr2: descr2, queueNoteFn: queueNoteFn, - width: *width, + workEstimate: qs.completeWorkEstimate(workEstimate), } if ok := qs.rejectOrEnqueueLocked(req); !ok { return nil @@ -468,24 +547,36 @@ func (qs *queueSet) timeoutOldRequestsAndRejectOrEnqueueLocked(ctx context.Conte return req } -// chooseQueueIndexLocked uses shuffle sharding to select a queue index +// shuffleShardLocked uses shuffle sharding to select a queue index // using the given hashValue and the shuffle sharding parameters of the queueSet. -func (qs *queueSet) chooseQueueIndexLocked(hashValue uint64, descr1, descr2 interface{}) int { +func (qs *queueSet) shuffleShardLocked(hashValue uint64, descr1, descr2 interface{}) int { + var backHand [8]int + // Deal into a data structure, so that the order of visit below is not necessarily the order of the deal. + // This removes bias in the case of flows with overlapping hands. + hand := qs.dealer.DealIntoHand(hashValue, backHand[:]) + handSize := len(hand) + offset := qs.enqueues % handSize + qs.enqueues++ bestQueueIdx := -1 - bestQueueSeatsSum := int(math.MaxInt32) - // the dealer uses the current desired number of queues, which is no larger than the number in `qs.queues`. - qs.dealer.Deal(hashValue, func(queueIdx int) { - // TODO: Consider taking into account `additional latency` of requests - // in addition to their widths. - // Ideally, this should be based on projected completion time in the - // virtual world of the youngest request in the queue. - thisSeatsSum := qs.queues[queueIdx].requests.SeatsSum() - klog.V(7).Infof("QS(%s): For request %#+v %#+v considering queue %d of seatsSum %d", qs.qCfg.Name, descr1, descr2, queueIdx, thisSeatsSum) - if thisSeatsSum < bestQueueSeatsSum { - bestQueueIdx, bestQueueSeatsSum = queueIdx, thisSeatsSum + minQueueSeatSeconds := fqrequest.MaxSeatSeconds + for i := 0; i < handSize; i++ { + queueIdx := hand[(offset+i)%handSize] + queue := qs.queues[queueIdx] + queueSum := queue.requests.QueueSum() + + // this is the total amount of work in seat-seconds for requests + // waiting in this queue, we will select the queue with the minimum. + thisQueueSeatSeconds := queueSum.TotalWorkSum + klog.V(7).Infof("QS(%s): For request %#+v %#+v considering queue %d with sum: %#v and %d seats in use, nextDispatchR=%v", qs.qCfg.Name, descr1, descr2, queueIdx, queueSum, queue.seatsInUse, queue.nextDispatchR) + if thisQueueSeatSeconds < minQueueSeatSeconds { + minQueueSeatSeconds = thisQueueSeatSeconds + bestQueueIdx = queueIdx } - }) - klog.V(6).Infof("QS(%s) at r=%s v=%.9fs: For request %#+v %#+v chose queue %d, had %d waiting & %d executing", qs.qCfg.Name, qs.clock.Now().Format(nsTimeFmt), qs.virtualTime, descr1, descr2, bestQueueIdx, bestQueueSeatsSum, qs.queues[bestQueueIdx].requestsExecuting) + } + if klog.V(6).Enabled() { + chosenQueue := qs.queues[bestQueueIdx] + klog.V(6).Infof("QS(%s) at t=%s R=%v: For request %#+v %#+v chose queue %d, with sum: %#v & %d seats in use & nextDispatchR=%v", qs.qCfg.Name, qs.clock.Now().Format(nsTimeFmt), qs.currentR, descr1, descr2, bestQueueIdx, chosenQueue.requests.QueueSum(), chosenQueue.seatsInUse, chosenQueue.nextDispatchR) + } return bestQueueIdx } @@ -499,33 +590,26 @@ func (qs *queueSet) removeTimedOutRequestsFromQueueLocked(queue *queue, fsName s // can short circuit loop (break) if oldest requests are not timing out // as newer requests also will not have timed out - // now - requestWaitLimit = waitLimit - waitLimit := now.Add(-qs.qCfg.RequestWaitLimit) + // now - requestWaitLimit = arrivalLimit + arrivalLimit := now.Add(-qs.qCfg.RequestWaitLimit) reqs.Walk(func(req *request) bool { - if waitLimit.After(req.arrivalTime) { - req.decision.SetLocked(decisionReject) - timeoutCount++ - metrics.AddRequestsInQueues(req.ctx, qs.qCfg.Name, req.fsName, -1) - req.NoteQueued(false) - + if arrivalLimit.After(req.arrivalTime) { + if req.decision.Set(decisionReject) && req.removeFromQueueLocked() != nil { + timeoutCount++ + req.NoteQueued(false) + metrics.AddRequestsInQueues(req.ctx, qs.qCfg.Name, req.fsName, -1) + } // we need to check if the next request has timed out. return true } - // since reqs are sorted oldest -> newest, we are done here. return false }) // remove timed out requests from queue if timeoutCount > 0 { - // The number of requests we have timed out is timeoutCount, - // so, let's dequeue the exact number of requests for this queue. - for i := 0; i < timeoutCount; i++ { - queue.requests.Dequeue() - } - // decrement the # of requestsEnqueued qs.totRequestsWaiting -= timeoutCount - qs.obsPair.RequestsWaiting.Add(float64(-timeoutCount)) + qs.reqsObsPair.RequestsWaiting.Add(float64(-timeoutCount)) } } @@ -551,35 +635,26 @@ func (qs *queueSet) enqueueLocked(request *request) { queue := request.queue now := qs.clock.Now() if queue.requests.Length() == 0 && queue.requestsExecuting == 0 { - // the queue’s virtual start time is set to the virtual time. - queue.virtualStart = qs.virtualTime + // the queue’s start R is set to the virtual time. + queue.nextDispatchR = qs.currentR if klog.V(6).Enabled() { - klog.Infof("QS(%s) at r=%s v=%.9fs: initialized queue %d virtual start time due to request %#+v %#+v", qs.qCfg.Name, now.Format(nsTimeFmt), queue.virtualStart, queue.index, request.descr1, request.descr2) + klog.Infof("QS(%s) at t=%s R=%v: initialized queue %d start R due to request %#+v %#+v", qs.qCfg.Name, now.Format(nsTimeFmt), queue.nextDispatchR, queue.index, request.descr1, request.descr2) } } - queue.Enqueue(request) + request.removeFromQueueLocked = queue.requests.Enqueue(request) qs.totRequestsWaiting++ metrics.AddRequestsInQueues(request.ctx, qs.qCfg.Name, request.fsName, 1) request.NoteQueued(true) - qs.obsPair.RequestsWaiting.Add(1) + qs.reqsObsPair.RequestsWaiting.Add(1) } -// dispatchAsMuchAsPossibleLocked runs a loop, as long as there -// are non-empty queues and the number currently executing is less than the -// assured concurrency value. The body of the loop uses the fair queuing -// technique to pick a queue, dequeue the request at the head of that -// queue, increment the count of the number executing, and send true -// to the request's channel. +// dispatchAsMuchAsPossibleLocked does as many dispatches as possible now. func (qs *queueSet) dispatchAsMuchAsPossibleLocked() { - for qs.totRequestsWaiting != 0 && qs.totSeatsInUse < qs.dCfg.ConcurrencyLimit { - ok := qs.dispatchLocked() - if !ok { - break - } + for qs.totRequestsWaiting != 0 && qs.totSeatsInUse < qs.dCfg.ConcurrencyLimit && qs.dispatchLocked() { } } -func (qs *queueSet) dispatchSansQueueLocked(ctx context.Context, width *fqrequest.Width, flowDistinguisher, fsName string, descr1, descr2 interface{}) *request { +func (qs *queueSet) dispatchSansQueueLocked(ctx context.Context, workEstimate *fqrequest.WorkEstimate, flowDistinguisher, fsName string, descr1, descr2 interface{}) *request { // does not call metrics.SetDispatchMetrics because there is no queuing and thus no interesting virtual world now := qs.clock.Now() req := &request{ @@ -588,83 +663,68 @@ func (qs *queueSet) dispatchSansQueueLocked(ctx context.Context, width *fqreques flowDistinguisher: flowDistinguisher, ctx: ctx, startTime: now, - decision: lockingpromise.NewWriteOnce(&qs.lock, qs.counter), + decision: qs.promiseFactory(decisionExecute, ctx.Done(), decisionCancel), arrivalTime: now, + arrivalR: qs.currentR, descr1: descr1, descr2: descr2, - width: *width, + workEstimate: qs.completeWorkEstimate(workEstimate), } - req.decision.SetLocked(decisionExecute) qs.totRequestsExecuting++ - qs.totSeatsInUse += req.Seats() + qs.totSeatsInUse += req.MaxSeats() metrics.AddRequestsExecuting(ctx, qs.qCfg.Name, fsName, 1) - metrics.AddRequestConcurrencyInUse(qs.qCfg.Name, fsName, req.Seats()) - qs.obsPair.RequestsExecuting.Add(1) + metrics.AddRequestConcurrencyInUse(qs.qCfg.Name, fsName, req.MaxSeats()) + qs.reqsObsPair.RequestsExecuting.Add(1) + qs.execSeatsObs.Add(float64(req.MaxSeats())) if klog.V(5).Enabled() { - klog.Infof("QS(%s) at r=%s v=%.9fs: immediate dispatch of request %q %#+v %#+v, qs will have %d executing", qs.qCfg.Name, now.Format(nsTimeFmt), qs.virtualTime, fsName, descr1, descr2, qs.totRequestsExecuting) + klog.Infof("QS(%s) at t=%s R=%v: immediate dispatch of request %q %#+v %#+v, qs will have %d executing", qs.qCfg.Name, now.Format(nsTimeFmt), qs.currentR, fsName, descr1, descr2, qs.totRequestsExecuting) } return req } // dispatchLocked uses the Fair Queuing for Server Requests method to // select a queue and dispatch the oldest request in that queue. The -// return value indicates whether a request was dispatched; this will -// be false when there are no requests waiting in any queue. +// return value indicates whether a request was dequeued; this will +// be false when either all queues are empty or the request at the head +// of the next queue cannot be dispatched. func (qs *queueSet) dispatchLocked() bool { - queue := qs.selectQueueLocked() + queue, request := qs.findDispatchQueueLocked() if queue == nil { return false } - request, ok := queue.Dequeue() - if !ok { // This should never happen. But if it does... + if request == nil { // This should never happen. But if it does... return false } + qs.totRequestsWaiting-- + metrics.AddRequestsInQueues(request.ctx, qs.qCfg.Name, request.fsName, -1) + request.NoteQueued(false) + qs.reqsObsPair.RequestsWaiting.Add(-1) + defer qs.boundNextDispatchLocked(queue) + if !request.decision.Set(decisionExecute) { + return true + } request.startTime = qs.clock.Now() // At this moment the request leaves its queue and starts // executing. We do not recognize any interim state between // "queued" and "executing". While that means "executing" // includes a little overhead from this package, this is not a // problem because other overhead is also included. - qs.totRequestsWaiting-- qs.totRequestsExecuting++ - qs.totSeatsInUse += request.Seats() + qs.totSeatsInUse += request.MaxSeats() queue.requestsExecuting++ - queue.seatsInUse += request.Seats() - metrics.AddRequestsInQueues(request.ctx, qs.qCfg.Name, request.fsName, -1) - request.NoteQueued(false) + queue.seatsInUse += request.MaxSeats() metrics.AddRequestsExecuting(request.ctx, qs.qCfg.Name, request.fsName, 1) - metrics.AddRequestConcurrencyInUse(qs.qCfg.Name, request.fsName, request.Seats()) - qs.obsPair.RequestsWaiting.Add(-1) - qs.obsPair.RequestsExecuting.Add(1) + metrics.AddRequestConcurrencyInUse(qs.qCfg.Name, request.fsName, request.MaxSeats()) + qs.reqsObsPair.RequestsExecuting.Add(1) + qs.execSeatsObs.Add(float64(request.MaxSeats())) if klog.V(6).Enabled() { - klog.Infof("QS(%s) at r=%s v=%.9fs: dispatching request %#+v %#+v from queue %d with virtual start time %.9fs, queue will have %d waiting & %d executing", - qs.qCfg.Name, request.startTime.Format(nsTimeFmt), qs.virtualTime, request.descr1, request.descr2, - queue.index, queue.virtualStart, queue.requests.Length(), queue.requestsExecuting) + klog.Infof("QS(%s) at t=%s R=%v: dispatching request %#+v %#+v work %v from queue %d with start R %v, queue will have %d waiting & %d requests occupying %d seats, set will have %d seats occupied", + qs.qCfg.Name, request.startTime.Format(nsTimeFmt), qs.currentR, request.descr1, request.descr2, + request.workEstimate, queue.index, queue.nextDispatchR, queue.requests.Length(), queue.requestsExecuting, queue.seatsInUse, qs.totSeatsInUse) } - // When a request is dequeued for service -> qs.virtualStart += G - queue.virtualStart += qs.estimatedServiceTime * float64(request.Seats()) - request.decision.SetLocked(decisionExecute) - return ok -} - -// cancelWait ensures the request is not waiting. This is only -// applicable to a request that has been assigned to a queue. -func (qs *queueSet) cancelWait(req *request) { - qs.lock.Lock() - defer qs.lock.Unlock() - if req.decision.IsSetLocked() { - // The request has already been removed from the queue - // and so we consider its wait to be over. - return - } - req.decision.SetLocked(decisionCancel) - - // remove the request from the queue as it has timed out - req.removeFromQueueFn() - qs.totRequestsWaiting-- - metrics.AddRequestsInQueues(req.ctx, qs.qCfg.Name, req.fsName, -1) - req.NoteQueued(false) - qs.obsPair.RequestsWaiting.Add(-1) + // When a request is dequeued for service -> qs.virtualStart += G * width + queue.nextDispatchR += request.totalWork() + return true } // canAccommodateSeatsLocked returns true if this queueSet has enough @@ -682,10 +742,6 @@ func (qs *queueSet) canAccommodateSeatsLocked(seats int) bool { } // wait for all "currently" executing requests in this queueSet // to finish before we can execute this request. - if klog.V(4).Enabled() { - klog.Infof("QS(%s): seats (%d) asked for exceeds concurrency limit, waiting for currently executing requests to complete, %d seats are in use (%d are executing) and the limit is %d", - qs.qCfg.Name, seats, qs.totSeatsInUse, qs.totRequestsExecuting, qs.dCfg.ConcurrencyLimit) - } return false case qs.totSeatsInUse+seats > qs.dCfg.ConcurrencyLimit: return false @@ -694,45 +750,31 @@ func (qs *queueSet) canAccommodateSeatsLocked(seats int) bool { return true } -// selectQueueLocked examines the queues in round robin order and +// findDispatchQueueLocked examines the queues in round robin order and // returns the first one of those for which the virtual finish time of -// the oldest waiting request is minimal. -func (qs *queueSet) selectQueueLocked() *queue { - minVirtualFinish := math.Inf(1) - sMin := math.Inf(1) - dsMin := math.Inf(1) - sMax := math.Inf(-1) - dsMax := math.Inf(-1) +// the oldest waiting request is minimal, and also returns that request. +// Returns nils if the head of the selected queue can not be dispatched now. +func (qs *queueSet) findDispatchQueueLocked() (*queue, *request) { + minVirtualFinish := fqrequest.MaxSeatSeconds + sMin := fqrequest.MaxSeatSeconds + dsMin := fqrequest.MaxSeatSeconds + sMax := fqrequest.MinSeatSeconds + dsMax := fqrequest.MinSeatSeconds var minQueue *queue var minIndex int nq := len(qs.queues) for range qs.queues { qs.robinIndex = (qs.robinIndex + 1) % nq queue := qs.queues[qs.robinIndex] - if queue.requests.Length() != 0 { - sMin = math.Min(sMin, queue.virtualStart) - sMax = math.Max(sMax, queue.virtualStart) - estimatedWorkInProgress := qs.estimatedServiceTime * float64(queue.seatsInUse) - dsMin = math.Min(dsMin, queue.virtualStart-estimatedWorkInProgress) - dsMax = math.Max(dsMax, queue.virtualStart-estimatedWorkInProgress) - // the virtual finish time of the oldest request is: - // virtual start time + G - // we are not taking the width of the request into account when - // we calculate the virtual finish time of the request because - // it can starve requests with smaller wdith in other queues. - // - // so let's draw an example of the starving scenario: - // - G=60 (estimated service time in seconds) - // - concurrency limit=2 - // - we have two queues, q1 and q2 - // - q1 has an infinite supply of requests with width W=1 - // - q2 has one request waiting in the queue with width W=2 - // - virtual start time for both q1 and q2 are at t0 - // - requests complete really fast, S=1ms on q1 - // in this scenario we will execute roughly 60,000 requests - // from q1 before we pick the request from q2. - currentVirtualFinish := queue.virtualStart + qs.estimatedServiceTime - + oldestWaiting, _ := queue.requests.Peek() + if oldestWaiting != nil { + sMin = ssMin(sMin, queue.nextDispatchR) + sMax = ssMax(sMax, queue.nextDispatchR) + estimatedWorkInProgress := fqrequest.SeatsTimesDuration(float64(queue.seatsInUse), qs.estimatedServiceDuration) + dsMin = ssMin(dsMin, queue.nextDispatchR-estimatedWorkInProgress) + dsMax = ssMax(dsMax, queue.nextDispatchR-estimatedWorkInProgress) + currentVirtualFinish := queue.nextDispatchR + oldestWaiting.totalWork() + klog.V(11).InfoS("Considering queue to dispatch", "queueSet", qs.qCfg.Name, "queue", qs.robinIndex, "finishR", currentVirtualFinish) if currentVirtualFinish < minVirtualFinish { minVirtualFinish = currentVirtualFinish minQueue = queue @@ -741,41 +783,57 @@ func (qs *queueSet) selectQueueLocked() *queue { } } - // TODO: add a method to fifo that lets us peek at the oldest request - var oldestReqFromMinQueue *request - minQueue.requests.Walk(func(r *request) bool { - oldestReqFromMinQueue = r - return false - }) - if oldestReqFromMinQueue == nil || !qs.canAccommodateSeatsLocked(oldestReqFromMinQueue.Seats()) { + oldestReqFromMinQueue, _ := minQueue.requests.Peek() + if oldestReqFromMinQueue == nil { + // This cannot happen + klog.ErrorS(errors.New("selected queue is empty"), "Impossible", "queueSet", qs.qCfg.Name) + return nil, nil + } + if !qs.canAccommodateSeatsLocked(oldestReqFromMinQueue.MaxSeats()) { // since we have not picked the queue with the minimum virtual finish // time, we are not going to advance the round robin index here. - return nil + if klog.V(4).Enabled() { + klog.Infof("QS(%s): request %v %v seats %d cannot be dispatched from queue %d, waiting for currently executing requests to complete, %d requests are occupying %d seats and the limit is %d", + qs.qCfg.Name, oldestReqFromMinQueue.descr1, oldestReqFromMinQueue.descr2, oldestReqFromMinQueue.MaxSeats(), minQueue.index, qs.totRequestsExecuting, qs.totSeatsInUse, qs.dCfg.ConcurrencyLimit) + } + return nil, nil + } + oldestReqFromMinQueue.removeFromQueueLocked() + + // If the requested final seats exceed capacity of that queue, + // we reduce them to current capacity and adjust additional latency + // to preserve the total amount of work. + if oldestReqFromMinQueue.workEstimate.FinalSeats > uint(qs.dCfg.ConcurrencyLimit) { + finalSeats := uint(qs.dCfg.ConcurrencyLimit) + additionalLatency := oldestReqFromMinQueue.workEstimate.finalWork.DurationPerSeat(float64(finalSeats)) + oldestReqFromMinQueue.workEstimate.FinalSeats = finalSeats + oldestReqFromMinQueue.workEstimate.AdditionalLatency = additionalLatency } // we set the round robin indexing to start at the chose queue // for the next round. This way the non-selected queues // win in the case that the virtual finish times are the same qs.robinIndex = minIndex - // according to the original FQ formula: - // - // Si = MAX(R(t), Fi-1) - // - // the virtual start (excluding the estimated cost) of the chose - // queue should always be greater or equal to the global virtual - // time. - // - // hence we're refreshing the per-queue virtual time for the chosen - // queue here. if the last virtual start time (excluded estimated cost) - // falls behind the global virtual time, we update the latest virtual - // start by: + - previouslyEstimatedServiceTime := float64(minQueue.seatsInUse) * qs.estimatedServiceTime - if qs.virtualTime > minQueue.virtualStart-previouslyEstimatedServiceTime { - // per-queue virtual time should not fall behind the global - minQueue.virtualStart = qs.virtualTime + previouslyEstimatedServiceTime - } - metrics.SetDispatchMetrics(qs.qCfg.Name, qs.virtualTime, minQueue.virtualStart, sMin, sMax, dsMin, dsMax) - return minQueue + + if minQueue.nextDispatchR < oldestReqFromMinQueue.arrivalR { + klog.ErrorS(errors.New("dispatch before arrival"), "Inconceivable!", "QS", qs.qCfg.Name, "queue", minQueue.index, "dispatchR", minQueue.nextDispatchR, "request", oldestReqFromMinQueue) + } + metrics.SetDispatchMetrics(qs.qCfg.Name, qs.currentR.ToFloat(), minQueue.nextDispatchR.ToFloat(), sMin.ToFloat(), sMax.ToFloat(), dsMin.ToFloat(), dsMax.ToFloat()) + return minQueue, oldestReqFromMinQueue +} + +func ssMin(a, b fqrequest.SeatSeconds) fqrequest.SeatSeconds { + if a > b { + return b + } + return a +} + +func ssMax(a, b fqrequest.SeatSeconds) fqrequest.SeatSeconds { + if a < b { + return b + } + return a } // finishRequestAndDispatchAsMuchAsPossible is a convenience method @@ -784,7 +842,7 @@ func (qs *queueSet) selectQueueLocked() *queue { // once a request finishes execution or is canceled. This returns a bool // indicating whether the QueueSet is now idle. func (qs *queueSet) finishRequestAndDispatchAsMuchAsPossible(req *request) bool { - qs.lockAndSyncTime() + qs.lockAndSyncTime(req.ctx) defer qs.lock.Unlock() qs.finishRequestLocked(req) @@ -798,32 +856,105 @@ func (qs *queueSet) finishRequestAndDispatchAsMuchAsPossible(req *request) bool func (qs *queueSet) finishRequestLocked(r *request) { now := qs.clock.Now() qs.totRequestsExecuting-- - qs.totSeatsInUse -= r.Seats() metrics.AddRequestsExecuting(r.ctx, qs.qCfg.Name, r.fsName, -1) - metrics.AddRequestConcurrencyInUse(qs.qCfg.Name, r.fsName, -r.Seats()) - qs.obsPair.RequestsExecuting.Add(-1) + qs.reqsObsPair.RequestsExecuting.Add(-1) - if r.queue == nil { - if klog.V(6).Enabled() { - klog.Infof("QS(%s) at r=%s v=%.9fs: request %#+v %#+v finished, qs will have %d executing", qs.qCfg.Name, now.Format(nsTimeFmt), qs.virtualTime, r.descr1, r.descr2, qs.totRequestsExecuting) + actualServiceDuration := now.Sub(r.startTime) + + // TODO: for now we keep the logic localized so it is easier to see + // how the counters are tracked for queueset and queue, in future we + // can refactor to move this function. + releaseSeatsLocked := func() { + defer qs.removeQueueIfEmptyLocked(r) + + qs.totSeatsInUse -= r.MaxSeats() + metrics.AddRequestConcurrencyInUse(qs.qCfg.Name, r.fsName, -r.MaxSeats()) + qs.execSeatsObs.Add(-float64(r.MaxSeats())) + if r.queue != nil { + r.queue.seatsInUse -= r.MaxSeats() } - return } - S := now.Sub(r.startTime).Seconds() + defer func() { + if r.workEstimate.AdditionalLatency <= 0 { + // release the seats allocated to this request immediately + releaseSeatsLocked() + if !klog.V(6).Enabled() { + } else if r.queue != nil { + klog.Infof("QS(%s) at t=%s R=%v: request %#+v %#+v finished all use of %d seats, adjusted queue %d start R to %v due to service time %.9fs, queue will have %d requests with %#v waiting & %d requests occupying %d seats", + qs.qCfg.Name, now.Format(nsTimeFmt), qs.currentR, r.descr1, r.descr2, r.workEstimate.MaxSeats(), r.queue.index, + r.queue.nextDispatchR, actualServiceDuration.Seconds(), r.queue.requests.Length(), r.queue.requests.QueueSum(), r.queue.requestsExecuting, r.queue.seatsInUse) + } else { + klog.Infof("QS(%s) at t=%s R=%v: request %#+v %#+v finished all use of %d seats, qs will have %d requests occupying %d seats", qs.qCfg.Name, now.Format(nsTimeFmt), qs.currentR, r.descr1, r.descr2, r.workEstimate.InitialSeats, qs.totRequestsExecuting, qs.totSeatsInUse) + } + return + } - // When a request finishes being served, and the actual service time was S, - // the queue’s virtual start time is decremented by (G - S)*width. - r.queue.virtualStart -= (qs.estimatedServiceTime - S) * float64(r.Seats()) + additionalLatency := r.workEstimate.AdditionalLatency + if !klog.V(6).Enabled() { + } else if r.queue != nil { + klog.Infof("QS(%s) at t=%s R=%v: request %#+v %#+v finished main use of %d seats but lingering on %d seats for %v seconds, adjusted queue %d start R to %v due to service time %.9fs, queue will have %d requests with %#v waiting & %d requests occupying %d seats", + qs.qCfg.Name, now.Format(nsTimeFmt), qs.currentR, r.descr1, r.descr2, r.workEstimate.InitialSeats, r.workEstimate.FinalSeats, additionalLatency.Seconds(), r.queue.index, + r.queue.nextDispatchR, actualServiceDuration.Seconds(), r.queue.requests.Length(), r.queue.requests.QueueSum(), r.queue.requestsExecuting, r.queue.seatsInUse) + } else { + klog.Infof("QS(%s) at t=%s R=%v: request %#+v %#+v finished main use of %d seats but lingering on %d seats for %v seconds, qs will have %d requests occupying %d seats", qs.qCfg.Name, now.Format(nsTimeFmt), qs.currentR, r.descr1, r.descr2, r.workEstimate.InitialSeats, r.workEstimate.FinalSeats, additionalLatency.Seconds(), qs.totRequestsExecuting, qs.totSeatsInUse) + } + // EventAfterDuration will execute the event func in a new goroutine, + // so the seats allocated to this request will be released after + // AdditionalLatency elapses, this ensures that the additional + // latency has no impact on the user experience. + qs.clock.EventAfterDuration(func(_ time.Time) { + qs.lockAndSyncTime(r.ctx) + defer qs.lock.Unlock() + now := qs.clock.Now() + releaseSeatsLocked() + if !klog.V(6).Enabled() { + } else if r.queue != nil { + klog.Infof("QS(%s) at t=%s R=%v: request %#+v %#+v finished lingering on %d seats, queue %d will have %d requests with %#v waiting & %d requests occupying %d seats", + qs.qCfg.Name, now.Format(nsTimeFmt), qs.currentR, r.descr1, r.descr2, r.workEstimate.FinalSeats, r.queue.index, + r.queue.requests.Length(), r.queue.requests.QueueSum(), r.queue.requestsExecuting, r.queue.seatsInUse) + } else { + klog.Infof("QS(%s) at t=%s R=%v: request %#+v %#+v finished lingering on %d seats, qs will have %d requests occupying %d seats", qs.qCfg.Name, now.Format(nsTimeFmt), qs.currentR, r.descr1, r.descr2, r.workEstimate.FinalSeats, qs.totRequestsExecuting, qs.totSeatsInUse) + } + qs.dispatchAsMuchAsPossibleLocked() + }, additionalLatency) + }() - // request has finished, remove from requests executing - r.queue.requestsExecuting-- - r.queue.seatsInUse -= r.Seats() + if r.queue != nil { + // request has finished, remove from requests executing + r.queue.requestsExecuting-- - if klog.V(6).Enabled() { - klog.Infof("QS(%s) at r=%s v=%.9fs: request %#+v %#+v finished, adjusted queue %d virtual start time to %.9fs due to service time %.9fs, queue will have %d waiting & %d executing", - qs.qCfg.Name, now.Format(nsTimeFmt), qs.virtualTime, r.descr1, r.descr2, r.queue.index, - r.queue.virtualStart, S, r.queue.requests.Length(), r.queue.requestsExecuting) + // When a request finishes being served, and the actual service time was S, + // the queue’s start R is decremented by (G - S)*width. + r.queue.nextDispatchR -= fqrequest.SeatsTimesDuration(float64(r.InitialSeats()), qs.estimatedServiceDuration-actualServiceDuration) + qs.boundNextDispatchLocked(r.queue) + } +} + +// boundNextDispatchLocked applies the anti-windup hack. +// We need a hack because all non-empty queues are allocated the same +// number of seats. A queue that can not use all those seats and does +// not go empty accumulates a progresively earlier `virtualStart` compared +// to queues that are using more than they are allocated. +// The following hack addresses the first side of that inequity, +// by insisting that dispatch in the virtual world not precede arrival. +func (qs *queueSet) boundNextDispatchLocked(queue *queue) { + oldestReqFromMinQueue, _ := queue.requests.Peek() + if oldestReqFromMinQueue == nil { + return + } + var virtualStartBound = oldestReqFromMinQueue.arrivalR + if queue.nextDispatchR < virtualStartBound { + if klog.V(4).Enabled() { + klog.InfoS("AntiWindup tweaked queue", "QS", qs.qCfg.Name, "queue", queue.index, "time", qs.clock.Now().Format(nsTimeFmt), "requestDescr1", oldestReqFromMinQueue.descr1, "requestDescr2", oldestReqFromMinQueue.descr2, "newVirtualStart", virtualStartBound, "deltaVirtualStart", (virtualStartBound - queue.nextDispatchR)) + } + queue.nextDispatchR = virtualStartBound + } +} + +func (qs *queueSet) removeQueueIfEmptyLocked(r *request) { + if r.queue == nil { + return } // If there are more queues than desired and this one has no @@ -851,24 +982,10 @@ func removeQueueAndUpdateIndexes(queues []*queue, index int) []*queue { return keptQueues } -// preCreateOrUnblockGoroutine needs to be called before creating a -// goroutine associated with this queueSet or unblocking a blocked -// one, to properly update the accounting used in testing. -func (qs *queueSet) preCreateOrUnblockGoroutine() { - qs.counter.Add(1) -} - -// goroutineDoneOrBlocked needs to be called at the end of every -// goroutine associated with this queueSet or when such a goroutine is -// about to wait on some other goroutine to do something; this is to -// properly update the accounting used in testing. -func (qs *queueSet) goroutineDoneOrBlocked() { - qs.counter.Add(-1) -} - func (qs *queueSet) UpdateObservations() { - qs.obsPair.RequestsWaiting.Add(0) - qs.obsPair.RequestsExecuting.Add(0) + qs.reqsObsPair.RequestsWaiting.Add(0) + qs.reqsObsPair.RequestsExecuting.Add(0) + qs.execSeatsObs.Add(0) } func (qs *queueSet) Dump(includeRequestDetails bool) debug.QueueSetDump { @@ -881,7 +998,7 @@ func (qs *queueSet) Dump(includeRequestDetails bool) debug.QueueSetDump { SeatsInUse: qs.totSeatsInUse, } for i, q := range qs.queues { - d.Queues[i] = q.dump(includeRequestDetails) + d.Queues[i] = q.dumpLocked(includeRequestDetails) } return d } diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/types.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/types.go index 7f121d707a..f1073b96b2 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/types.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset/types.go @@ -28,7 +28,7 @@ import ( ) // request is a temporary container for "requests" with additional -// tracking fields required for the functionality FQScheduler +// tracking fields required for QueueSet functionality. type request struct { ctx context.Context @@ -41,18 +41,17 @@ type request struct { // a queue. queue *queue - // startTime is the real time when the request began executing - startTime time.Time - - // width of the request - width fcrequest.Width + // estimated amount of work of the request + workEstimate completedWorkEstimate // decision gets set to a `requestDecision` indicating what to do // with this request. It gets set exactly once, when the request // is removed from its queue. The value will be decisionReject, - // decisionCancel, or decisionExecute; decisionTryAnother never - // appears here. - decision promise.LockingWriteOnce + // decisionCancel, or decisionExecute. + // + // decision.Set is called with the queueSet locked. + // decision.Get is called without the queueSet locked. + decision promise.WriteOnce // arrivalTime is the real time when the request entered this system arrivalTime time.Time @@ -61,48 +60,91 @@ type request struct { // log messages descr1, descr2 interface{} - // Indicates whether client has called Request::Wait() - waitStarted bool - queueNoteFn fq.QueueNoteFn + // The preceding fields are filled in at creation and not modified since; + // the following fields may be modified later and must only be accessed while + // holding the queueSet's lock. + // Removes this request from its queue. If the request is not put into a // a queue it will be nil. - removeFromQueueFn removeFromFIFOFunc + removeFromQueueLocked removeFromFIFOFunc + + // arrivalR is R(arrivalTime). R is, confusingly, also called "virtual time". + // This field is meaningful only while the request is waiting in the virtual world. + arrivalR fcrequest.SeatSeconds + + // startTime is the real time when the request began executing + startTime time.Time + + // Indicates whether client has called Request::Wait() + waitStarted bool } -// queue is an array of requests with additional metadata required for -// the FQScheduler +type completedWorkEstimate struct { + fcrequest.WorkEstimate + totalWork fcrequest.SeatSeconds // initial plus final work + finalWork fcrequest.SeatSeconds // only final work +} + +// queue is a sequence of requests that have arrived but not yet finished +// execution in both the real and virtual worlds. type queue struct { - // The requests are stored in a FIFO list. + // The requests not yet executing in the real world are stored in a FIFO list. requests fifo - // virtualStart is the virtual time (virtual seconds since process - // startup) when the oldest request in the queue (if there is any) - // started virtually executing - virtualStart float64 + // nextDispatchR is the R progress meter reading at + // which the next request will be dispatched in the virtual world. + nextDispatchR fcrequest.SeatSeconds + // requestsExecuting is the count in the real world. requestsExecuting int - index int + + // index is the position of this queue among those in its queueSet. + index int // seatsInUse is the total number of "seats" currently occupied // by all the requests that are currently executing in this queue. seatsInUse int } -// Enqueue enqueues a request into the queue and -// sets the removeFromQueueFn of the request appropriately. -func (q *queue) Enqueue(request *request) { - request.removeFromQueueFn = q.requests.Enqueue(request) +// queueSum tracks the sum of initial seats, max seats, and +// totalWork from all requests in a given queue +type queueSum struct { + // InitialSeatsSum is the sum of InitialSeats + // associated with all requests in a given queue. + InitialSeatsSum int + + // MaxSeatsSum is the sum of MaxSeats + // associated with all requests in a given queue. + MaxSeatsSum int + + // TotalWorkSum is the sum of totalWork of the waiting requests + TotalWorkSum fcrequest.SeatSeconds +} + +func (req *request) totalWork() fcrequest.SeatSeconds { + return req.workEstimate.totalWork +} + +func (qs *queueSet) completeWorkEstimate(we *fcrequest.WorkEstimate) completedWorkEstimate { + finalWork := qs.computeFinalWork(we) + return completedWorkEstimate{ + WorkEstimate: *we, + totalWork: qs.computeInitialWork(we) + finalWork, + finalWork: finalWork, + } +} + +func (qs *queueSet) computeInitialWork(we *fcrequest.WorkEstimate) fcrequest.SeatSeconds { + return fcrequest.SeatsTimesDuration(float64(we.InitialSeats), qs.estimatedServiceDuration) } -// Dequeue dequeues a request from the queue -func (q *queue) Dequeue() (*request, bool) { - request, ok := q.requests.Dequeue() - return request, ok +func (qs *queueSet) computeFinalWork(we *fcrequest.WorkEstimate) fcrequest.SeatSeconds { + return fcrequest.SeatsTimesDuration(float64(we.FinalSeats), we.AdditionalLatency) } -func (q *queue) dump(includeDetails bool) debug.QueueDump { +func (q *queue) dumpLocked(includeDetails bool) debug.QueueDump { digest := make([]debug.RequestDump, q.requests.Length()) i := 0 q.requests.Walk(func(r *request) bool { @@ -111,6 +153,7 @@ func (q *queue) dump(includeDetails bool) debug.QueueDump { digest[i].FlowDistinguisher = r.flowDistinguisher digest[i].ArriveTime = r.arrivalTime digest[i].StartTime = r.startTime + digest[i].WorkEstimate = r.workEstimate.WorkEstimate if includeDetails { userInfo, _ := genericrequest.UserFrom(r.ctx) digest[i].UserName = userInfo.GetName() @@ -122,10 +165,19 @@ func (q *queue) dump(includeDetails bool) debug.QueueDump { i++ return true }) + + sum := q.requests.QueueSum() + queueSum := debug.QueueSum{ + InitialSeatsSum: sum.InitialSeatsSum, + MaxSeatsSum: sum.MaxSeatsSum, + TotalWorkSum: sum.TotalWorkSum.String(), + } + return debug.QueueDump{ - VirtualStart: q.virtualStart, + NextDispatchR: q.nextDispatchR.String(), Requests: digest, ExecutingRequests: q.requestsExecuting, SeatsInUse: q.seatsInUse, + QueueSum: queueSum, } } diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/format/formatting.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/format/formatting.go index d2c917e0ba..2199c1412a 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/format/formatting.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/format/formatting.go @@ -21,7 +21,7 @@ import ( "encoding/json" "fmt" - flowcontrol "k8s.io/api/flowcontrol/v1beta1" + flowcontrol "k8s.io/api/flowcontrol/v1beta2" "k8s.io/apiserver/pkg/authentication/user" "k8s.io/apiserver/pkg/endpoints/request" ) diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/metrics.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/metrics.go index a0d2285231..88f812490b 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/metrics.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/metrics.go @@ -18,14 +18,15 @@ package metrics import ( "context" + "strconv" "strings" "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" compbasemetrics "k8s.io/component-base/metrics" "k8s.io/component-base/metrics/legacyregistry" basemetricstestutil "k8s.io/component-base/metrics/testutil" + "k8s.io/utils/clock" ) const ( @@ -103,7 +104,28 @@ var ( }, []string{priorityLevel, flowSchema}, ) - + // PriorityLevelExecutionSeatsObserverGenerator creates observers of seats occupied throughout execution for priority levels + PriorityLevelExecutionSeatsObserverGenerator = NewSampleAndWaterMarkHistogramsGenerator(clock.RealClock{}, time.Millisecond, + &compbasemetrics.HistogramOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "priority_level_seat_count_samples", + Help: "Periodic observations of the number of requests", + Buckets: []float64{0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1}, + ConstLabels: map[string]string{phase: "executing"}, + StabilityLevel: compbasemetrics.ALPHA, + }, + &compbasemetrics.HistogramOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "priority_level_seat_count_watermarks", + Help: "Watermarks of the number of requests", + Buckets: []float64{0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1}, + ConstLabels: map[string]string{phase: "executing"}, + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{priorityLevel}, + ) // PriorityLevelConcurrencyObserverPairGenerator creates pairs that observe concurrency for priority levels PriorityLevelConcurrencyObserverPairGenerator = NewSampleAndWaterMarkHistogramsPairGenerator(clock.RealClock{}, time.Millisecond, &compbasemetrics.HistogramOpts{ @@ -122,8 +144,8 @@ var ( Buckets: []float64{0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1}, StabilityLevel: compbasemetrics.ALPHA, }, - []string{priorityLevel}) - + []string{priorityLevel}, + ) // ReadWriteConcurrencyObserverPairGenerator creates pairs that observe concurrency broken down by mutating vs readonly ReadWriteConcurrencyObserverPairGenerator = NewSampleAndWaterMarkHistogramsPairGenerator(clock.RealClock{}, time.Millisecond, &compbasemetrics.HistogramOpts{ @@ -142,8 +164,8 @@ var ( Buckets: []float64{0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1}, StabilityLevel: compbasemetrics.ALPHA, }, - []string{requestKind}) - + []string{requestKind}, + ) apiserverCurrentR = compbasemetrics.NewGaugeVec( &compbasemetrics.GaugeOpts{ Namespace: namespace, @@ -154,7 +176,6 @@ var ( }, []string{priorityLevel}, ) - apiserverDispatchR = compbasemetrics.NewGaugeVec( &compbasemetrics.GaugeOpts{ Namespace: namespace, @@ -165,7 +186,6 @@ var ( }, []string{priorityLevel}, ) - apiserverLatestS = compbasemetrics.NewGaugeVec( &compbasemetrics.GaugeOpts{ Namespace: namespace, @@ -176,7 +196,6 @@ var ( }, []string{priorityLevel}, ) - apiserverNextSBounds = compbasemetrics.NewGaugeVec( &compbasemetrics.GaugeOpts{ Namespace: namespace, @@ -187,7 +206,6 @@ var ( }, []string{priorityLevel, "bound"}, ) - apiserverNextDiscountedSBounds = compbasemetrics.NewGaugeVec( &compbasemetrics.GaugeOpts{ Namespace: namespace, @@ -198,7 +216,6 @@ var ( }, []string{priorityLevel, "bound"}, ) - apiserverCurrentInqueueRequests = compbasemetrics.NewGaugeVec( &compbasemetrics.GaugeOpts{ Namespace: namespace, @@ -235,7 +252,7 @@ var ( Namespace: namespace, Subsystem: subsystem, Name: "current_executing_requests", - Help: "Number of requests currently executing in the API Priority and Fairness system", + Help: "Number of requests in regular execution phase in the API Priority and Fairness system", StabilityLevel: compbasemetrics.ALPHA, }, []string{priorityLevel, flowSchema}, @@ -245,7 +262,7 @@ var ( Namespace: namespace, Subsystem: subsystem, Name: "request_concurrency_in_use", - Help: "Concurrency (number of seats) occupided by the currently executing requests in the API Priority and Fairness system", + Help: "Concurrency (number of seats) occupided by the currently executing (all phases count) requests in the API Priority and Fairness system", StabilityLevel: compbasemetrics.ALPHA, }, []string{priorityLevel, flowSchema}, @@ -266,12 +283,34 @@ var ( Namespace: namespace, Subsystem: subsystem, Name: "request_execution_seconds", - Help: "Duration of request execution in the API Priority and Fairness system", + Help: "Duration of regular phase of request execution in the API Priority and Fairness system", Buckets: requestDurationSecondsBuckets, StabilityLevel: compbasemetrics.ALPHA, }, []string{priorityLevel, flowSchema}, ) + watchCountSamples = compbasemetrics.NewHistogramVec( + &compbasemetrics.HistogramOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "watch_count_samples", + Help: "count of watchers for mutating requests in API Priority and Fairness", + Buckets: []float64{0, 1, 10, 100, 1000, 10000}, + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{priorityLevel, flowSchema}, + ) + apiserverEpochAdvances = compbasemetrics.NewCounterVec( + &compbasemetrics.CounterOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "epoch_advance_total", + Help: "Number of times the queueset's progress meter jumped backward", + StabilityLevel: compbasemetrics.ALPHA, + }, + []string{priorityLevel, "success"}, + ) + metrics = Registerables{ apiserverRejectedRequestsTotal, apiserverDispatchedRequestsTotal, @@ -287,7 +326,10 @@ var ( apiserverCurrentExecutingRequests, apiserverRequestWaitingSeconds, apiserverRequestExecutionSeconds, + watchCountSamples, + apiserverEpochAdvances, }. + Append(PriorityLevelExecutionSeatsObserverGenerator.metrics()...). Append(PriorityLevelConcurrencyObserverPairGenerator.metrics()...). Append(ReadWriteConcurrencyObserverPairGenerator.metrics()...) ) @@ -352,3 +394,13 @@ func ObserveWaitingDuration(ctx context.Context, priorityLevel, flowSchema, exec func ObserveExecutionDuration(ctx context.Context, priorityLevel, flowSchema string, executionTime time.Duration) { apiserverRequestExecutionSeconds.WithContext(ctx).WithLabelValues(priorityLevel, flowSchema).Observe(executionTime.Seconds()) } + +// ObserveWatchCount notes a sampling of a watch count +func ObserveWatchCount(ctx context.Context, priorityLevel, flowSchema string, count int) { + watchCountSamples.WithLabelValues(priorityLevel, flowSchema).Observe(float64(count)) +} + +// AddEpochAdvance notes an advance of the progress meter baseline for a given priority level +func AddEpochAdvance(ctx context.Context, priorityLevel string, success bool) { + apiserverEpochAdvances.WithContext(ctx).WithLabelValues(priorityLevel, strconv.FormatBool(success)).Inc() +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/observer.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/observer.go new file mode 100644 index 0000000000..1e55a0e1e7 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/observer.go @@ -0,0 +1,65 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package metrics + +// Observer is something that can be given numeric observations. +type Observer interface { + // Observe takes an observation + Observe(float64) +} + +// ChangeObserver extends Observer with the ability to take +// an observation that is relative to the previous observation. +type ChangeObserver interface { + Observer + + // Observe a new value that differs by the given amount from the previous observation. + Add(float64) +} + +// RatioedChangeObserver tracks ratios. +// The numerator is set/changed through the ChangeObserver methods, +// and the denominator can be updated through the SetDenominator method. +// A ratio is tracked whenever the numerator is set/changed. +type RatioedChangeObserver interface { + ChangeObserver + + // SetDenominator sets the denominator to use until it is changed again + SetDenominator(float64) +} + +// RatioedChangeObserverGenerator creates related observers that are +// differentiated by a series of label values +type RatioedChangeObserverGenerator interface { + Generate(initialNumerator, initialDenominator float64, labelValues []string) RatioedChangeObserver +} + +// RatioedChangeObserverPair is a corresponding pair of observers, one for the +// number of requests waiting in queue(s) and one for the number of +// requests being executed +type RatioedChangeObserverPair struct { + // RequestsWaiting is given observations of the number of currently queued requests + RequestsWaiting RatioedChangeObserver + + // RequestsExecuting is given observations of the number of requests currently executing + RequestsExecuting RatioedChangeObserver +} + +// RatioedChangeObserverPairGenerator generates pairs +type RatioedChangeObserverPairGenerator interface { + Generate(initialWaitingDenominator, initialExecutingDenominator float64, labelValues []string) RatioedChangeObserverPair +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/sample_and_watermark.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/sample_and_watermark.go index 43bd13adb0..29366b5363 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/sample_and_watermark.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/sample_and_watermark.go @@ -20,9 +20,9 @@ import ( "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" compbasemetrics "k8s.io/component-base/metrics" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) const ( @@ -34,13 +34,13 @@ const ( labelValueExecuting = "executing" ) -// SampleAndWaterMarkPairGenerator makes pairs of TimedObservers that +// SampleAndWaterMarkPairGenerator makes pairs of RatioedChangeObservers that // track samples and watermarks. type SampleAndWaterMarkPairGenerator struct { urGenerator SampleAndWaterMarkObserverGenerator } -var _ TimedObserverPairGenerator = SampleAndWaterMarkPairGenerator{} +var _ RatioedChangeObserverPairGenerator = SampleAndWaterMarkPairGenerator{} // NewSampleAndWaterMarkHistogramsPairGenerator makes a new pair generator func NewSampleAndWaterMarkHistogramsPairGenerator(clock clock.PassiveClock, samplePeriod time.Duration, sampleOpts, waterMarkOpts *compbasemetrics.HistogramOpts, labelNames []string) SampleAndWaterMarkPairGenerator { @@ -50,10 +50,10 @@ func NewSampleAndWaterMarkHistogramsPairGenerator(clock clock.PassiveClock, samp } // Generate makes a new pair -func (spg SampleAndWaterMarkPairGenerator) Generate(waiting1, executing1 float64, labelValues []string) TimedObserverPair { - return TimedObserverPair{ - RequestsWaiting: spg.urGenerator.Generate(0, waiting1, append([]string{labelValueWaiting}, labelValues...)), - RequestsExecuting: spg.urGenerator.Generate(0, executing1, append([]string{labelValueExecuting}, labelValues...)), +func (spg SampleAndWaterMarkPairGenerator) Generate(initialWaitingDenominator, initialExecutingDenominator float64, labelValues []string) RatioedChangeObserverPair { + return RatioedChangeObserverPair{ + RequestsWaiting: spg.urGenerator.Generate(0, initialWaitingDenominator, append([]string{labelValueWaiting}, labelValues...)), + RequestsExecuting: spg.urGenerator.Generate(0, initialExecutingDenominator, append([]string{labelValueExecuting}, labelValues...)), } } @@ -61,7 +61,7 @@ func (spg SampleAndWaterMarkPairGenerator) metrics() Registerables { return spg.urGenerator.metrics() } -// SampleAndWaterMarkObserverGenerator creates TimedObservers that +// SampleAndWaterMarkObserverGenerator creates RatioedChangeObservers that // populate histograms of samples and low- and high-water-marks. The // generator has a samplePeriod, and the histograms get an observation // every samplePeriod. The sampling windows are quantized based on @@ -79,7 +79,7 @@ type sampleAndWaterMarkObserverGenerator struct { waterMarks *compbasemetrics.HistogramVec } -var _ TimedObserverGenerator = (*sampleAndWaterMarkObserverGenerator)(nil) +var _ RatioedChangeObserverGenerator = SampleAndWaterMarkObserverGenerator{} // NewSampleAndWaterMarkHistogramsGenerator makes a new one func NewSampleAndWaterMarkHistogramsGenerator(clock clock.PassiveClock, samplePeriod time.Duration, sampleOpts, waterMarkOpts *compbasemetrics.HistogramOpts, labelNames []string) SampleAndWaterMarkObserverGenerator { @@ -97,23 +97,23 @@ func (swg *sampleAndWaterMarkObserverGenerator) quantize(when time.Time) int64 { return int64(when.Sub(swg.t0) / swg.samplePeriod) } -// Generate makes a new TimedObserver -func (swg *sampleAndWaterMarkObserverGenerator) Generate(x, x1 float64, labelValues []string) TimedObserver { - relX := x / x1 +// Generate makes a new RatioedChangeObserver +func (swg *sampleAndWaterMarkObserverGenerator) Generate(initialNumerator, initialDenominator float64, labelValues []string) RatioedChangeObserver { + ratio := initialNumerator / initialDenominator when := swg.clock.Now() return &sampleAndWaterMarkHistograms{ sampleAndWaterMarkObserverGenerator: swg, labelValues: labelValues, loLabelValues: append([]string{labelValueLo}, labelValues...), hiLabelValues: append([]string{labelValueHi}, labelValues...), - x1: x1, + denominator: initialDenominator, sampleAndWaterMarkAccumulator: sampleAndWaterMarkAccumulator{ lastSet: when, lastSetInt: swg.quantize(when), - x: x, - relX: relX, - loRelX: relX, - hiRelX: relX, + numerator: initialNumerator, + ratio: ratio, + loRatio: ratio, + hiRatio: ratio, }} } @@ -127,39 +127,39 @@ type sampleAndWaterMarkHistograms struct { loLabelValues, hiLabelValues []string sync.Mutex - x1 float64 + denominator float64 sampleAndWaterMarkAccumulator } type sampleAndWaterMarkAccumulator struct { - lastSet time.Time - lastSetInt int64 // lastSet / samplePeriod - x float64 - relX float64 // x / x1 - loRelX, hiRelX float64 + lastSet time.Time + lastSetInt int64 // lastSet / samplePeriod + numerator float64 + ratio float64 // numerator/denominator + loRatio, hiRatio float64 } -var _ TimedObserver = (*sampleAndWaterMarkHistograms)(nil) +var _ RatioedChangeObserver = (*sampleAndWaterMarkHistograms)(nil) -func (saw *sampleAndWaterMarkHistograms) Add(deltaX float64) { +func (saw *sampleAndWaterMarkHistograms) Add(deltaNumerator float64) { saw.innerSet(func() { - saw.x += deltaX + saw.numerator += deltaNumerator }) } -func (saw *sampleAndWaterMarkHistograms) Set(x float64) { +func (saw *sampleAndWaterMarkHistograms) Observe(numerator float64) { saw.innerSet(func() { - saw.x = x + saw.numerator = numerator }) } -func (saw *sampleAndWaterMarkHistograms) SetX1(x1 float64) { +func (saw *sampleAndWaterMarkHistograms) SetDenominator(denominator float64) { saw.innerSet(func() { - saw.x1 = x1 + saw.denominator = denominator }) } -func (saw *sampleAndWaterMarkHistograms) innerSet(updateXOrX1 func()) { +func (saw *sampleAndWaterMarkHistograms) innerSet(updateNumeratorOrDenominator func()) { when, whenInt, acc, wellOrdered := func() (time.Time, int64, sampleAndWaterMarkAccumulator, bool) { saw.Lock() defer saw.Unlock() @@ -168,11 +168,11 @@ func (saw *sampleAndWaterMarkHistograms) innerSet(updateXOrX1 func()) { whenInt := saw.quantize(when) acc := saw.sampleAndWaterMarkAccumulator wellOrdered := !when.Before(acc.lastSet) - updateXOrX1() - saw.relX = saw.x / saw.x1 + updateNumeratorOrDenominator() + saw.ratio = saw.numerator / saw.denominator if wellOrdered { if acc.lastSetInt < whenInt { - saw.loRelX, saw.hiRelX = acc.relX, acc.relX + saw.loRatio, saw.hiRatio = acc.ratio, acc.ratio saw.lastSetInt = whenInt } saw.lastSet = when @@ -187,10 +187,10 @@ func (saw *sampleAndWaterMarkHistograms) innerSet(updateXOrX1 func()) { // would be wrong to update `saw.lastSet` in this case because // that plants a time bomb for future updates to // `saw.lastSetInt`. - if saw.relX < saw.loRelX { - saw.loRelX = saw.relX - } else if saw.relX > saw.hiRelX { - saw.hiRelX = saw.relX + if saw.ratio < saw.loRatio { + saw.loRatio = saw.ratio + } else if saw.ratio > saw.hiRatio { + saw.hiRatio = saw.ratio } return when, whenInt, acc, wellOrdered }() @@ -200,10 +200,10 @@ func (saw *sampleAndWaterMarkHistograms) innerSet(updateXOrX1 func()) { klog.Errorf("Time went backwards from %s to %s for labelValues=%#+v", lastSetS, whenS, saw.labelValues) } for acc.lastSetInt < whenInt { - saw.samples.WithLabelValues(saw.labelValues...).Observe(acc.relX) - saw.waterMarks.WithLabelValues(saw.loLabelValues...).Observe(acc.loRelX) - saw.waterMarks.WithLabelValues(saw.hiLabelValues...).Observe(acc.hiRelX) + saw.samples.WithLabelValues(saw.labelValues...).Observe(acc.ratio) + saw.waterMarks.WithLabelValues(saw.loLabelValues...).Observe(acc.loRatio) + saw.waterMarks.WithLabelValues(saw.hiLabelValues...).Observe(acc.hiRatio) acc.lastSetInt++ - acc.loRelX, acc.hiRelX = acc.relX, acc.relX + acc.loRatio, acc.hiRatio = acc.ratio, acc.ratio } } diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/timed_observer.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/timed_observer.go deleted file mode 100644 index 25f41493c3..0000000000 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/metrics/timed_observer.go +++ /dev/null @@ -1,52 +0,0 @@ -/* -Copyright 2019 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package metrics - -// TimedObserver gets informed about the values assigned to a variable -// `X float64` over time, and reports on the ratio `X/X1`. -type TimedObserver interface { - // Add notes a change to the variable - Add(deltaX float64) - - // Set notes a setting of the variable - Set(x float64) - - // SetX1 changes the value to use for X1 - SetX1(x1 float64) -} - -// TimedObserverGenerator creates related observers that are -// differentiated by a series of label values -type TimedObserverGenerator interface { - Generate(x, x1 float64, labelValues []string) TimedObserver -} - -// TimedObserverPair is a corresponding pair of observers, one for the -// number of requests waiting in queue(s) and one for the number of -// requests being executed -type TimedObserverPair struct { - // RequestsWaiting is given observations of the number of currently queued requests - RequestsWaiting TimedObserver - - // RequestsExecuting is given observations of the number of requests currently executing - RequestsExecuting TimedObserver -} - -// TimedObserverPairGenerator generates pairs -type TimedObserverPairGenerator interface { - Generate(waiting1, executing1 float64, labelValues []string) TimedObserverPair -} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/list_work_estimator.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/list_work_estimator.go new file mode 100644 index 0000000000..7fcc0903e8 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/list_work_estimator.go @@ -0,0 +1,136 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package request + +import ( + "math" + "net/http" + "net/url" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime/schema" + apirequest "k8s.io/apiserver/pkg/endpoints/request" + "k8s.io/apiserver/pkg/features" + utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/klog/v2" +) + +func newListWorkEstimator(countFn objectCountGetterFunc) WorkEstimatorFunc { + estimator := &listWorkEstimator{ + countGetterFn: countFn, + } + return estimator.estimate +} + +type listWorkEstimator struct { + countGetterFn objectCountGetterFunc +} + +func (e *listWorkEstimator) estimate(r *http.Request, flowSchemaName, priorityLevelName string) WorkEstimate { + requestInfo, ok := apirequest.RequestInfoFrom(r.Context()) + if !ok { + // no RequestInfo should never happen, but to be on the safe side + // let's return maximumSeats + return WorkEstimate{InitialSeats: maximumSeats} + } + + query := r.URL.Query() + listOptions := metav1.ListOptions{} + if err := metav1.Convert_url_Values_To_v1_ListOptions(&query, &listOptions, nil); err != nil { + klog.ErrorS(err, "Failed to convert options while estimating work for the list request") + + // This request is destined to fail in the validation layer, + // return maximumSeats for this request to be consistent. + return WorkEstimate{InitialSeats: maximumSeats} + } + isListFromCache := !shouldListFromStorage(query, &listOptions) + + numStored, err := e.countGetterFn(key(requestInfo)) + switch { + case err == ObjectCountStaleErr: + // object count going stale is indicative of degradation, so we should + // be conservative here and allocate maximum seats to this list request. + // NOTE: if a CRD is removed, its count will go stale first and then the + // pruner will eventually remove the CRD from the cache. + return WorkEstimate{InitialSeats: maximumSeats} + case err == ObjectCountNotFoundErr: + // there are two scenarios in which we can see this error: + // a. the type is truly unknown, a typo on the caller's part. + // b. the count has gone stale for too long and the pruner + // has removed the type from the cache. + // we don't have a way to distinguish between a and b. b seems to indicate + // to a more severe case of degradation, although b can naturally trigger + // when a CRD is removed. let's be conservative and allocate maximum seats. + return WorkEstimate{InitialSeats: maximumSeats} + case err != nil: + // we should never be here since Get returns either ObjectCountStaleErr or + // ObjectCountNotFoundErr, return maximumSeats to be on the safe side. + return WorkEstimate{InitialSeats: maximumSeats} + } + + limit := numStored + if utilfeature.DefaultFeatureGate.Enabled(features.APIListChunking) && listOptions.Limit > 0 && + listOptions.Limit < numStored { + limit = listOptions.Limit + } + + var estimatedObjectsToBeProcessed int64 + + switch { + case isListFromCache: + // TODO: For resources that implement indexes at the watchcache level, + // we need to adjust the cost accordingly + estimatedObjectsToBeProcessed = numStored + case listOptions.FieldSelector != "" || listOptions.LabelSelector != "": + estimatedObjectsToBeProcessed = numStored + limit + default: + estimatedObjectsToBeProcessed = 2 * limit + } + + // for now, our rough estimate is to allocate one seat to each 100 obejcts that + // will be processed by the list request. + // we will come up with a different formula for the transformation function and/or + // fine tune this number in future iteratons. + seats := uint(math.Ceil(float64(estimatedObjectsToBeProcessed) / float64(100))) + + // make sure we never return a seat of zero + if seats < minimumSeats { + seats = minimumSeats + } + if seats > maximumSeats { + seats = maximumSeats + } + return WorkEstimate{InitialSeats: seats} +} + +func key(requestInfo *apirequest.RequestInfo) string { + groupResource := &schema.GroupResource{ + Group: requestInfo.APIGroup, + Resource: requestInfo.Resource, + } + return groupResource.String() +} + +// NOTICE: Keep in sync with shouldDelegateList function in +// staging/src/k8s.io/apiserver/pkg/storage/cacher/cacher.go +func shouldListFromStorage(query url.Values, opts *metav1.ListOptions) bool { + resourceVersion := opts.ResourceVersion + pagingEnabled := utilfeature.DefaultFeatureGate.Enabled(features.APIListChunking) + hasContinuation := pagingEnabled && len(opts.Continue) > 0 + hasLimit := pagingEnabled && opts.Limit > 0 && resourceVersion != "0" + return resourceVersion == "" || hasContinuation || hasLimit || opts.ResourceVersionMatch == metav1.ResourceVersionMatchExact +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/mutating_work_estimator.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/mutating_work_estimator.go new file mode 100644 index 0000000000..1c6c441e27 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/mutating_work_estimator.go @@ -0,0 +1,143 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package request + +import ( + "math" + "net/http" + "time" + + apirequest "k8s.io/apiserver/pkg/endpoints/request" + "k8s.io/apiserver/pkg/util/flowcontrol/metrics" +) + +const ( + watchesPerSeat = 10.0 + eventAdditionalDuration = 5 * time.Millisecond + // TODO(wojtekt): Remove it once we tune the algorithm to not fail + // scalability tests. + enableMutatingWorkEstimator = false +) + +func newMutatingWorkEstimator(countFn watchCountGetterFunc) WorkEstimatorFunc { + return newTestMutatingWorkEstimator(countFn, enableMutatingWorkEstimator) +} + +func newTestMutatingWorkEstimator(countFn watchCountGetterFunc, enabled bool) WorkEstimatorFunc { + estimator := &mutatingWorkEstimator{ + countFn: countFn, + enabled: enabled, + } + return estimator.estimate +} + +type mutatingWorkEstimator struct { + countFn watchCountGetterFunc + enabled bool +} + +func (e *mutatingWorkEstimator) estimate(r *http.Request, flowSchemaName, priorityLevelName string) WorkEstimate { + // TODO(wojtekt): Remove once we tune the algorithm to not fail + // scalability tests. + if !e.enabled { + return WorkEstimate{ + InitialSeats: 1, + } + } + + requestInfo, ok := apirequest.RequestInfoFrom(r.Context()) + if !ok { + // no RequestInfo should never happen, but to be on the safe side + // let's return a large value. + return WorkEstimate{ + InitialSeats: 1, + FinalSeats: maximumSeats, + AdditionalLatency: eventAdditionalDuration, + } + } + watchCount := e.countFn(requestInfo) + metrics.ObserveWatchCount(r.Context(), priorityLevelName, flowSchemaName, watchCount) + + // The cost of the request associated with the watchers of that event + // consists of three parts: + // - cost of going through the event change logic + // - cost of serialization of the event + // - cost of processing an event object for each watcher (e.g. filtering, + // sending data over network) + // We're starting simple to get some operational experience with it and + // we will work on tuning the algorithm later. Given that the actual work + // associated with processing watch events is happening in multiple + // goroutines (proportional to the number of watchers) that are all + // resumed at once, as a starting point we assume that each such goroutine + // is taking 1/Nth of a seat for M milliseconds. + // We allow the accounting of that work in P&F to be reshaped into another + // rectangle of equal area for practical reasons. + var finalSeats uint + var additionalLatency time.Duration + + // TODO: Make this unconditional after we tune the algorithm better. + // Technically, there is an overhead connected to processing an event after + // the request finishes even if there is a small number of watches. + // However, until we tune the estimation we want to stay on the safe side + // an avoid introducing additional latency for almost every single request. + if watchCount >= watchesPerSeat { + // TODO: As described in the KEP, we should take into account that not all + // events are equal and try to estimate the cost of a single event based on + // some historical data about size of events. + finalSeats = uint(math.Ceil(float64(watchCount) / watchesPerSeat)) + finalWork := SeatsTimesDuration(float64(finalSeats), eventAdditionalDuration) + + // While processing individual events is highly parallel, + // the design/implementation of P&F has a couple limitations that + // make using this assumption in the P&F implementation very + // inefficient because: + // - we reserve max(initialSeats, finalSeats) for time of executing + // both phases of the request + // - even more importantly, when a given `wide` request is the one to + // be dispatched, we are not dispatching any other request until + // we accumulate enough seats to dispatch the nominated one, even + // if currently unoccupied seats would allow for dispatching some + // other requests in the meantime + // As a consequence of these, the wider the request, the more capacity + // will effectively be blocked and unused during dispatching and + // executing this request. + // + // To mitigate the impact of it, we're capping the maximum number of + // seats that can be assigned to a given request. Thanks to it: + // 1) we reduce the amount of seat-seconds that are "wasted" during + // dispatching and executing initial phase of the request + // 2) we are not changing the finalWork estimate - just potentially + // reshaping it to be narrower and longer. As long as the maximum + // seats setting will prevent dispatching too many requests at once + // to prevent overloading kube-apiserver (and/or etcd or the VM or + // a physical machine it is running on), we believe the relaxed + // version should be good enough to achieve the P&F goals. + // + // TODO: Confirm that the current cap of maximumSeats allow us to + // achieve the above. + if finalSeats > maximumSeats { + finalSeats = maximumSeats + } + additionalLatency = finalWork.DurationPerSeat(float64(finalSeats)) + } + + return WorkEstimate{ + InitialSeats: 1, + FinalSeats: finalSeats, + AdditionalLatency: additionalLatency, + } +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/object_count_tracker.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/object_count_tracker.go new file mode 100644 index 0000000000..dd1d5e570c --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/object_count_tracker.go @@ -0,0 +1,166 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package request + +import ( + "errors" + "sync" + "time" + + "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/klog/v2" + "k8s.io/utils/clock" +) + +const ( + // type deletion (it applies mostly to CRD) is not a very frequent + // operation so we can afford to prune the cache at a large interval. + // at the same time, we also want to make sure that the scalability + // tests hit this code path. + pruneInterval = 1 * time.Hour + + // the storage layer polls for object count at every 1m interval, we will allow + // up to 2-3 transient failures to get the latest count for a given resource. + staleTolerationThreshold = 3 * time.Minute +) + +var ( + // ObjectCountNotFoundErr is returned when the object count for + // a given resource is not being tracked. + ObjectCountNotFoundErr = errors.New("object count not found for the given resource") + + // ObjectCountStaleErr is returned when the object count for a + // given resource has gone stale due to transient failures. + ObjectCountStaleErr = errors.New("object count has gone stale for the given resource") +) + +// StorageObjectCountTracker is an interface that is used to keep track of +// of the total number of objects for each resource. +// {group}.{resource} is used as the key name to update and retrieve +// the total number of objects for a given resource. +type StorageObjectCountTracker interface { + // Set is invoked to update the current number of total + // objects for the given resource + Set(string, int64) + + // Get returns the total number of objects for the given resource. + // The following errors are returned: + // - if the count has gone stale for a given resource due to transient + // failures ObjectCountStaleErr is returned. + // - if the given resource is not being tracked then + // ObjectCountNotFoundErr is returned. + Get(string) (int64, error) +} + +// NewStorageObjectCountTracker returns an instance of +// StorageObjectCountTracker interface that can be used to +// keep track of the total number of objects for each resource. +func NewStorageObjectCountTracker(stopCh <-chan struct{}) StorageObjectCountTracker { + tracker := &objectCountTracker{ + clock: &clock.RealClock{}, + counts: map[string]*timestampedCount{}, + } + go func() { + wait.PollUntil( + pruneInterval, + func() (bool, error) { + // always prune at every pruneInterval + return false, tracker.prune(pruneInterval) + }, stopCh) + klog.InfoS("StorageObjectCountTracker pruner is exiting") + }() + + return tracker +} + +// timestampedCount stores the count of a given resource with a last updated +// timestamp so we can prune it after it goes stale for certain threshold. +type timestampedCount struct { + count int64 + lastUpdatedAt time.Time +} + +// objectCountTracker implements StorageObjectCountTracker with +// reader/writer mutual exclusion lock. +type objectCountTracker struct { + clock clock.PassiveClock + + lock sync.RWMutex + counts map[string]*timestampedCount +} + +func (t *objectCountTracker) Set(groupResource string, count int64) { + if count <= -1 { + // a value of -1 indicates that the 'Count' call failed to contact + // the storage layer, in most cases this error can be transient. + // we will continue to work with the count that is in the cache + // up to a certain threshold defined by staleTolerationThreshold. + // in case this becomes a non transient error then the count for + // the given resource will will eventually be removed from + // the cache by the pruner. + return + } + + now := t.clock.Now() + + // lock for writing + t.lock.Lock() + defer t.lock.Unlock() + + if item, ok := t.counts[groupResource]; ok { + item.count = count + item.lastUpdatedAt = now + return + } + + t.counts[groupResource] = ×tampedCount{ + count: count, + lastUpdatedAt: now, + } +} + +func (t *objectCountTracker) Get(groupResource string) (int64, error) { + staleThreshold := t.clock.Now().Add(-staleTolerationThreshold) + + t.lock.RLock() + defer t.lock.RUnlock() + + if item, ok := t.counts[groupResource]; ok { + if item.lastUpdatedAt.Before(staleThreshold) { + return item.count, ObjectCountStaleErr + } + return item.count, nil + } + return 0, ObjectCountNotFoundErr +} + +func (t *objectCountTracker) prune(threshold time.Duration) error { + oldestLastUpdatedAtAllowed := t.clock.Now().Add(-threshold) + + // lock for writing + t.lock.Lock() + defer t.lock.Unlock() + + for groupResource, count := range t.counts { + if count.lastUpdatedAt.After(oldestLastUpdatedAtAllowed) { + continue + } + delete(t.counts, groupResource) + } + + return nil +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/seat_seconds.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/seat_seconds.go new file mode 100644 index 0000000000..e3a4017452 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/seat_seconds.go @@ -0,0 +1,65 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package request + +import ( + "fmt" + "math" + "time" +) + +// SeatSeconds is a measure of work, in units of seat-seconds, using a fixed-point representation. +// `SeatSeconds(n)` represents `n/ssScale` seat-seconds. +// The `ssScale` constant is private to the implementation here, +// no other code should use it. +type SeatSeconds uint64 + +// MaxSeatsSeconds is the maximum representable value of SeatSeconds +const MaxSeatSeconds = SeatSeconds(math.MaxUint64) + +// MinSeatSeconds is the lowest representable value of SeatSeconds +const MinSeatSeconds = SeatSeconds(0) + +// SeatsTimeDuration produces the SeatSeconds value for the given factors. +// This is intended only to produce small values, increments in work +// rather than amount of work done since process start. +func SeatsTimesDuration(seats float64, duration time.Duration) SeatSeconds { + return SeatSeconds(math.Round(seats * float64(duration/time.Nanosecond) / (1e9 / ssScale))) +} + +// ToFloat converts to a floating-point representation. +// This conversion may lose precision. +func (ss SeatSeconds) ToFloat() float64 { + return float64(ss) / ssScale +} + +// DurationPerSeat returns duration per seat. +// This division may lose precision. +func (ss SeatSeconds) DurationPerSeat(seats float64) time.Duration { + return time.Duration(float64(ss) / seats * (float64(time.Second) / ssScale)) +} + +// String converts to a string. +// This is suitable for large as well as small values. +func (ss SeatSeconds) String() string { + const div = SeatSeconds(ssScale) + quo := ss / div + rem := ss - quo*div + return fmt.Sprintf("%d.%08dss", quo, rem) +} + +const ssScale = 1e8 diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/width.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/width.go index c5fa478a71..675433c2c3 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/width.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/request/width.go @@ -17,31 +17,99 @@ limitations under the License. package request import ( + "fmt" "net/http" + "time" + + apirequest "k8s.io/apiserver/pkg/endpoints/request" + "k8s.io/klog/v2" ) -type Width struct { - // Seats represents the number of seats associated with this request - Seats uint +const ( + // the minimum number of seats a request must occupy + minimumSeats = 1 + + // the maximum number of seats a request can occupy + maximumSeats = 10 +) + +// WorkEstimate carries three of the four parameters that determine the work in a request. +// The fourth parameter is the duration of the initial phase of execution. +type WorkEstimate struct { + // InitialSeats is the number of seats occupied while the server is + // executing this request. + InitialSeats uint + + // FinalSeats is the number of seats occupied at the end, + // during the AdditionalLatency. + FinalSeats uint + + // AdditionalLatency specifies the additional duration the seats allocated + // to this request must be reserved after the given request had finished. + // AdditionalLatency should not have any impact on the user experience, the + // caller must not experience this additional latency. + AdditionalLatency time.Duration +} + +// MaxSeats returns the maximum number of seats the request occupies over the +// phases of being served. +func (we *WorkEstimate) MaxSeats() int { + if we.InitialSeats >= we.FinalSeats { + return int(we.InitialSeats) + } + + return int(we.FinalSeats) } -// DefaultWidthEstimator returns returns '1' as the "width" -// of the given request. -// -// TODO: when we plumb in actual "width" handling for different -// type of request(s) this function will iterate through a chain -// of widthEstimator instance(s). -func DefaultWidthEstimator(_ *http.Request) Width { - return Width{ - Seats: 1, +// objectCountGetterFunc represents a function that gets the total +// number of objects for a given resource. +type objectCountGetterFunc func(string) (int64, error) + +// watchCountGetterFunc represents a function that gets the total +// number of watchers potentially interested in a given request. +type watchCountGetterFunc func(*apirequest.RequestInfo) int + +// NewWorkEstimator estimates the work that will be done by a given request, +// if no WorkEstimatorFunc matches the given request then the default +// work estimate of 1 seat is allocated to the request. +func NewWorkEstimator(objectCountFn objectCountGetterFunc, watchCountFn watchCountGetterFunc) WorkEstimatorFunc { + estimator := &workEstimator{ + listWorkEstimator: newListWorkEstimator(objectCountFn), + mutatingWorkEstimator: newMutatingWorkEstimator(watchCountFn), } + return estimator.estimate } -// WidthEstimatorFunc returns the estimated "width" of a given request. +// WorkEstimatorFunc returns the estimated work of a given request. // This function will be used by the Priority & Fairness filter to -// estimate the "width" of incoming requests. -type WidthEstimatorFunc func(*http.Request) Width +// estimate the work of of incoming requests. +type WorkEstimatorFunc func(request *http.Request, flowSchemaName, priorityLevelName string) WorkEstimate + +func (e WorkEstimatorFunc) EstimateWork(r *http.Request, flowSchemaName, priorityLevelName string) WorkEstimate { + return e(r, flowSchemaName, priorityLevelName) +} + +type workEstimator struct { + // listWorkEstimator estimates work for list request(s) + listWorkEstimator WorkEstimatorFunc + // mutatingWorkEstimator calculates the width of mutating request(s) + mutatingWorkEstimator WorkEstimatorFunc +} + +func (e *workEstimator) estimate(r *http.Request, flowSchemaName, priorityLevelName string) WorkEstimate { + requestInfo, ok := apirequest.RequestInfoFrom(r.Context()) + if !ok { + klog.ErrorS(fmt.Errorf("no RequestInfo found in context"), "Failed to estimate work for the request", "URI", r.RequestURI) + // no RequestInfo should never happen, but to be on the safe side let's return maximumSeats + return WorkEstimate{InitialSeats: maximumSeats} + } + + switch requestInfo.Verb { + case "list": + return e.listWorkEstimator.EstimateWork(r, flowSchemaName, priorityLevelName) + case "create", "update", "patch", "delete": + return e.mutatingWorkEstimator.EstimateWork(r, flowSchemaName, priorityLevelName) + } -func (e WidthEstimatorFunc) EstimateWidth(r *http.Request) Width { - return e(r) + return WorkEstimate{InitialSeats: minimumSeats} } diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/rule.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/rule.go index 765e28790f..83380e3742 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/rule.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/rule.go @@ -19,7 +19,7 @@ package flowcontrol import ( "strings" - flowcontrol "k8s.io/api/flowcontrol/v1beta1" + flowcontrol "k8s.io/api/flowcontrol/v1beta2" "k8s.io/apiserver/pkg/authentication/serviceaccount" "k8s.io/apiserver/pkg/authentication/user" "k8s.io/apiserver/pkg/endpoints/request" diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/watch_tracker.go b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/watch_tracker.go index 4dc7c131eb..e4ebb21459 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/watch_tracker.go +++ b/vendor/k8s.io/apiserver/pkg/util/flowcontrol/watch_tracker.go @@ -17,10 +17,16 @@ limitations under the License. package flowcontrol import ( + "net/http" "sync" + metainternalversion "k8s.io/apimachinery/pkg/apis/meta/internalversion" + "k8s.io/apimachinery/pkg/apis/meta/internalversion/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apiserver/pkg/endpoints/request" + + "k8s.io/klog/v2" ) // readOnlyVerbs contains verbs for read-only requests. @@ -51,10 +57,10 @@ type ForgetWatchFunc func() // of watches in the system for the purpose of estimating the // cost of incoming mutating requests. type WatchTracker interface { - // RegisterWatch reqisters a watch with the provided requestInfo + // RegisterWatch reqisters a watch based on the provided http.Request // in the tracker. It returns the function that should be called // to forget the watcher once it is finished. - RegisterWatch(requestInfo *request.RequestInfo) ForgetWatchFunc + RegisterWatch(r *http.Request) ForgetWatchFunc // GetInterestedWatchCount returns the number of watches that are // potentially interested in a request with a given RequestInfo @@ -62,26 +68,81 @@ type WatchTracker interface { GetInterestedWatchCount(requestInfo *request.RequestInfo) int } +// builtinIndexes represents of set of indexes registered in +// watchcache that are indexing watches and increase speed of +// their processing. +// We define the indexes as a map from a resource to the path +// to the field in the object on which the index is built. +type builtinIndexes map[string]string + +func getBuiltinIndexes() builtinIndexes { + // The only existing indexes as of now are: + // - spec.nodeName for pods + // - metadata.Name for nodes, secrets and configmaps + // However, we can ignore the latter, because the requestInfo.Name + // is set for them (i.e. we already catch them correctly). + return map[string]string{ + "pods": "spec.nodeName", + } +} + // watchTracker tracks the number of watches in the system for // the purpose of estimating the cost of incoming mutating requests. type watchTracker struct { - lock sync.Mutex + // indexes represents a set of registered indexes. + // It can't change after creation. + indexes builtinIndexes + lock sync.Mutex watchCount map[watchIdentifier]int } func NewWatchTracker() WatchTracker { return &watchTracker{ + indexes: getBuiltinIndexes(), watchCount: make(map[watchIdentifier]int), } } +const ( + unsetValue = "" +) + +func getIndexValue(r *http.Request, field string) string { + opts := metainternalversion.ListOptions{} + if err := scheme.ParameterCodec.DecodeParameters(r.URL.Query(), metav1.SchemeGroupVersion, &opts); err != nil { + klog.Warningf("Couldn't parse list options for %v: %v", r.URL.Query(), err) + return unsetValue + } + if opts.FieldSelector == nil { + return unsetValue + } + if value, ok := opts.FieldSelector.RequiresExactMatch(field); ok { + return value + } + return unsetValue +} + +type indexValue struct { + resource string + value string +} + // RegisterWatch implements WatchTracker interface. -func (w *watchTracker) RegisterWatch(requestInfo *request.RequestInfo) ForgetWatchFunc { - if requestInfo == nil || requestInfo.Verb != "watch" { +func (w *watchTracker) RegisterWatch(r *http.Request) ForgetWatchFunc { + requestInfo, ok := request.RequestInfoFrom(r.Context()) + if !ok || requestInfo == nil || requestInfo.Verb != "watch" { return nil } + var index *indexValue + if indexField, ok := w.indexes[requestInfo.Resource]; ok { + index = &indexValue{ + resource: requestInfo.Resource, + value: getIndexValue(r, indexField), + } + } + identifier := &watchIdentifier{ apiGroup: requestInfo.APIGroup, resource: requestInfo.Resource, @@ -91,16 +152,40 @@ func (w *watchTracker) RegisterWatch(requestInfo *request.RequestInfo) ForgetWat w.lock.Lock() defer w.lock.Unlock() - w.watchCount[*identifier]++ - return w.forgetWatch(identifier) + w.updateIndexLocked(identifier, index, 1) + return w.forgetWatch(identifier, index) +} + +func (w *watchTracker) updateIndexLocked(identifier *watchIdentifier, index *indexValue, incr int) { + if index == nil { + w.watchCount[*identifier] += incr + } else { + // For resources with defined index, for a given watch event we are + // only processing the watchers that: + // (a) do not specify field selector for an index field + // (b) do specify field selector with the value equal to the value + // coming from the processed object + // + // TODO(wojtek-t): For the sake of making progress and initially + // simplifying the implementation, we approximate (b) for all values + // as the value for an empty string. The assumption we're making here + // is that the difference between the actual number of watchers that + // will be processed, i.e. (a)+(b) above and the one from our + // approximation i.e. (a)+[(b) for field value of ""] will be small. + // This seem to be true in almost all production clusters, which makes + // it a reasonable first step simplification to unblock progres on it. + if index.value == unsetValue || index.value == "" { + w.watchCount[*identifier] += incr + } + } } -func (w *watchTracker) forgetWatch(identifier *watchIdentifier) ForgetWatchFunc { +func (w *watchTracker) forgetWatch(identifier *watchIdentifier, index *indexValue) ForgetWatchFunc { return func() { w.lock.Lock() defer w.lock.Unlock() - w.watchCount[*identifier]-- + w.updateIndexLocked(identifier, index, -1) if w.watchCount[*identifier] == 0 { delete(w.watchCount, *identifier) } diff --git a/vendor/k8s.io/apiserver/pkg/util/openapi/enablement.go b/vendor/k8s.io/apiserver/pkg/util/openapi/enablement.go new file mode 100644 index 0000000000..693821ac02 --- /dev/null +++ b/vendor/k8s.io/apiserver/pkg/util/openapi/enablement.go @@ -0,0 +1,83 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package openapi + +import ( + "strings" + + genericfeatures "k8s.io/apiserver/pkg/features" + utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/kube-openapi/pkg/common" + "k8s.io/kube-openapi/pkg/schemamutation" + "k8s.io/kube-openapi/pkg/validation/spec" +) + +// enumTypeDescriptionHeader is the header of enum section in schema description. +const enumTypeDescriptionHeader = "Possible enum values:" + +// GetOpenAPIDefinitionsWithoutDisabledFeatures wraps a GetOpenAPIDefinitions to revert +// any change to the schema that was made by disabled features. +func GetOpenAPIDefinitionsWithoutDisabledFeatures(GetOpenAPIDefinitions common.GetOpenAPIDefinitions) common.GetOpenAPIDefinitions { + return func(ref common.ReferenceCallback) map[string]common.OpenAPIDefinition { + defs := GetOpenAPIDefinitions(ref) + restoreDefinitions(defs) + return defs + } +} + +// restoreDefinitions restores any changes by disabled features from definition map. +func restoreDefinitions(defs map[string]common.OpenAPIDefinition) { + // revert changes from OpenAPIEnums + if !utilfeature.DefaultFeatureGate.Enabled(genericfeatures.OpenAPIEnums) { + for gvk, def := range defs { + orig := &def.Schema + if ret := pruneEnums(orig); ret != orig { + def.Schema = *ret + defs[gvk] = def + } + } + } +} + +func pruneEnums(schema *spec.Schema) *spec.Schema { + walker := schemamutation.Walker{ + SchemaCallback: func(schema *spec.Schema) *spec.Schema { + orig := schema + clone := func() { + if orig == schema { // if schema has not been mutated yet + schema = new(spec.Schema) + *schema = *orig // make a clone from orig to schema + } + } + if headerIndex := strings.Index(schema.Description, enumTypeDescriptionHeader); headerIndex != -1 { + // remove the enum section from description. + // note that the new lines before the header should be removed too, + // thus the slice range. + clone() + schema.Description = schema.Description[:headerIndex] + } + if len(schema.Enum) != 0 { + // remove the enum field + clone() + schema.Enum = nil + } + return schema + }, + RefCallback: schemamutation.RefCallbackNoop, + } + return walker.WalkSchema(schema) +} diff --git a/vendor/k8s.io/apiserver/pkg/util/webhook/error.go b/vendor/k8s.io/apiserver/pkg/util/webhook/error.go index 9c6f780e2f..3c5d39ae3c 100644 --- a/vendor/k8s.io/apiserver/pkg/util/webhook/error.go +++ b/vendor/k8s.io/apiserver/pkg/util/webhook/error.go @@ -28,6 +28,7 @@ import ( type ErrCallingWebhook struct { WebhookName string Reason error + Status *apierrors.StatusError } func (e *ErrCallingWebhook) Error() string { diff --git a/vendor/k8s.io/cli-runtime/pkg/genericclioptions/command_headers.go b/vendor/k8s.io/cli-runtime/pkg/genericclioptions/command_headers.go index 04889da094..0eea122fe6 100644 --- a/vendor/k8s.io/cli-runtime/pkg/genericclioptions/command_headers.go +++ b/vendor/k8s.io/cli-runtime/pkg/genericclioptions/command_headers.go @@ -77,3 +77,15 @@ func (c *CommandHeaderRoundTripper) ParseCommandHeaders(cmd *cobra.Command, args c.Headers[kubectlCommandHeader] = strings.Join(cmdStrs, " ") } } + +// CancelRequest is propagated to the Delegate RoundTripper within +// if the wrapped RoundTripper implements this function. +func (c *CommandHeaderRoundTripper) CancelRequest(req *http.Request) { + type canceler interface { + CancelRequest(*http.Request) + } + // If possible, call "CancelRequest" on the wrapped Delegate RoundTripper. + if cr, ok := c.Delegate.(canceler); ok { + cr.CancelRequest(req) + } +} diff --git a/vendor/k8s.io/cli-runtime/pkg/genericclioptions/config_flags.go b/vendor/k8s.io/cli-runtime/pkg/genericclioptions/config_flags.go index 86a601a0de..2d939c7bd6 100644 --- a/vendor/k8s.io/cli-runtime/pkg/genericclioptions/config_flags.go +++ b/vendor/k8s.io/cli-runtime/pkg/genericclioptions/config_flags.go @@ -48,6 +48,7 @@ const ( flagCAFile = "certificate-authority" flagBearerToken = "token" flagImpersonate = "as" + flagImpersonateUID = "as-uid" flagImpersonateGroup = "as-group" flagUsername = "username" flagPassword = "password" @@ -94,6 +95,7 @@ type ConfigFlags struct { CAFile *string BearerToken *string Impersonate *string + ImpersonateUID *string ImpersonateGroup *[]string Username *string Password *string @@ -102,15 +104,25 @@ type ConfigFlags struct { // before it is returned in ToRESTConfig function. WrapConfigFn func(*rest.Config) *rest.Config - clientConfig clientcmd.ClientConfig - lock sync.Mutex - // If set to true, will use persistent client config and - // propagate the config to the places that need it, rather than - // loading the config multiple times + clientConfig clientcmd.ClientConfig + clientConfigLock sync.Mutex + + restMapper meta.RESTMapper + restMapperLock sync.Mutex + + discoveryClient discovery.CachedDiscoveryInterface + discoveryClientLock sync.Mutex + + // If set to true, will use persistent client config, rest mapper, discovery client, and + // propagate them to the places that need them, rather than + // instantiating them multiple times. usePersistentConfig bool // Allows increasing burst used for discovery, this is useful // in clusters with many registered resources discoveryBurst int + // Allows increasing qps used for discovery, this is useful + // in clusters with many registered resources + discoveryQPS float32 } // ToRESTConfig implements RESTClientGetter. @@ -164,6 +176,9 @@ func (f *ConfigFlags) toRawKubeConfigLoader() clientcmd.ClientConfig { if f.Impersonate != nil { overrides.AuthInfo.Impersonate = *f.Impersonate } + if f.ImpersonateUID != nil { + overrides.AuthInfo.ImpersonateUID = *f.ImpersonateUID + } if f.ImpersonateGroup != nil { overrides.AuthInfo.ImpersonateGroups = *f.ImpersonateGroup } @@ -216,8 +231,8 @@ func (f *ConfigFlags) toRawKubeConfigLoader() clientcmd.ClientConfig { // toRawKubePersistentConfigLoader binds config flag values to config overrides // Returns a persistent clientConfig for propagation. func (f *ConfigFlags) toRawKubePersistentConfigLoader() clientcmd.ClientConfig { - f.lock.Lock() - defer f.lock.Unlock() + f.clientConfigLock.Lock() + defer f.clientConfigLock.Unlock() if f.clientConfig == nil { f.clientConfig = f.toRawKubeConfigLoader() @@ -230,15 +245,34 @@ func (f *ConfigFlags) toRawKubePersistentConfigLoader() clientcmd.ClientConfig { // Expects the AddFlags method to have been called. // Returns a CachedDiscoveryInterface using a computed RESTConfig. func (f *ConfigFlags) ToDiscoveryClient() (discovery.CachedDiscoveryInterface, error) { + if f.usePersistentConfig { + return f.toPersistentDiscoveryClient() + } + return f.toDiscoveryClient() +} + +func (f *ConfigFlags) toPersistentDiscoveryClient() (discovery.CachedDiscoveryInterface, error) { + f.discoveryClientLock.Lock() + defer f.discoveryClientLock.Unlock() + + if f.discoveryClient == nil { + discoveryClient, err := f.toDiscoveryClient() + if err != nil { + return nil, err + } + f.discoveryClient = discoveryClient + } + return f.discoveryClient, nil +} + +func (f *ConfigFlags) toDiscoveryClient() (discovery.CachedDiscoveryInterface, error) { config, err := f.ToRESTConfig() if err != nil { return nil, err } - // The more groups you have, the more discovery requests you need to make. - // given 25 groups (our groups + a few custom resources) with one-ish version each, discovery needs to make 50 requests - // double it just so we don't end up here again for a while. This config is only used for discovery. config.Burst = f.discoveryBurst + config.QPS = f.discoveryQPS cacheDir := defaultCacheDir @@ -255,6 +289,27 @@ func (f *ConfigFlags) ToDiscoveryClient() (discovery.CachedDiscoveryInterface, e // ToRESTMapper returns a mapper. func (f *ConfigFlags) ToRESTMapper() (meta.RESTMapper, error) { + if f.usePersistentConfig { + return f.toPersistentRESTMapper() + } + return f.toRESTMapper() +} + +func (f *ConfigFlags) toPersistentRESTMapper() (meta.RESTMapper, error) { + f.restMapperLock.Lock() + defer f.restMapperLock.Unlock() + + if f.restMapper == nil { + restMapper, err := f.toRESTMapper() + if err != nil { + return nil, err + } + f.restMapper = restMapper + } + return f.restMapper, nil +} + +func (f *ConfigFlags) toRESTMapper() (meta.RESTMapper, error) { discoveryClient, err := f.ToDiscoveryClient() if err != nil { return nil, err @@ -285,7 +340,10 @@ func (f *ConfigFlags) AddFlags(flags *pflag.FlagSet) { flags.StringVar(f.BearerToken, flagBearerToken, *f.BearerToken, "Bearer token for authentication to the API server") } if f.Impersonate != nil { - flags.StringVar(f.Impersonate, flagImpersonate, *f.Impersonate, "Username to impersonate for the operation") + flags.StringVar(f.Impersonate, flagImpersonate, *f.Impersonate, "Username to impersonate for the operation. User could be a regular user or a service account in a namespace.") + } + if f.ImpersonateUID != nil { + flags.StringVar(f.ImpersonateUID, flagImpersonateUID, *f.ImpersonateUID, "UID to impersonate for the operation.") } if f.ImpersonateGroup != nil { flags.StringArrayVar(f.ImpersonateGroup, flagImpersonateGroup, *f.ImpersonateGroup, "Group to impersonate for the operation, this flag can be repeated to specify multiple groups.") @@ -324,7 +382,6 @@ func (f *ConfigFlags) AddFlags(flags *pflag.FlagSet) { if f.Timeout != nil { flags.StringVar(f.Timeout, flagTimeout, *f.Timeout, "The length of time to wait before giving up on a single server request. Non-zero values should contain a corresponding time unit (e.g. 1s, 2m, 3h). A value of zero means don't timeout requests.") } - } // WithDeprecatedPasswordFlag enables the username and password config flags @@ -340,6 +397,18 @@ func (f *ConfigFlags) WithDiscoveryBurst(discoveryBurst int) *ConfigFlags { return f } +// WithDiscoveryBurst sets the RESTClient burst for discovery. +func (f *ConfigFlags) WithDiscoveryQPS(discoveryQPS float32) *ConfigFlags { + f.discoveryQPS = discoveryQPS + return f +} + +// WithWrapConfigFn allows providing a wrapper function for the client Config. +func (f *ConfigFlags) WithWrapConfigFn(wrapConfigFn func(*rest.Config) *rest.Config) *ConfigFlags { + f.WrapConfigFn = wrapConfigFn + return f +} + // NewConfigFlags returns ConfigFlags with default values set func NewConfigFlags(usePersistentConfig bool) *ConfigFlags { impersonateGroup := []string{} @@ -362,6 +431,7 @@ func NewConfigFlags(usePersistentConfig bool) *ConfigFlags { CAFile: stringptr(""), BearerToken: stringptr(""), Impersonate: stringptr(""), + ImpersonateUID: stringptr(""), ImpersonateGroup: &impersonateGroup, usePersistentConfig: usePersistentConfig, @@ -377,7 +447,7 @@ func stringptr(val string) *string { } // overlyCautiousIllegalFileCharacters matches characters that *might* not be supported. Windows is really restrictive, so this is really restrictive -var overlyCautiousIllegalFileCharacters = regexp.MustCompile(`[^(\w/\.)]`) +var overlyCautiousIllegalFileCharacters = regexp.MustCompile(`[^(\w/.)]`) // computeDiscoverCacheDir takes the parentDir and the host and comes up with a "usually non-colliding" name. func computeDiscoverCacheDir(parentDir, host string) string { diff --git a/vendor/k8s.io/cli-runtime/pkg/printers/json.go b/vendor/k8s.io/cli-runtime/pkg/printers/json.go index 1c35b97d73..8ab2235f8b 100644 --- a/vendor/k8s.io/cli-runtime/pkg/printers/json.go +++ b/vendor/k8s.io/cli-runtime/pkg/printers/json.go @@ -22,12 +22,9 @@ import ( "fmt" "io" "reflect" - "sync/atomic" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" - - "sigs.k8s.io/yaml" ) // JSONPrinter is an implementation of ResourcePrinter which outputs an object as JSON. @@ -80,63 +77,3 @@ func (p *JSONPrinter) PrintObj(obj runtime.Object, w io.Writer) error { _, err = w.Write(data) return err } - -// YAMLPrinter is an implementation of ResourcePrinter which outputs an object as YAML. -// The input object is assumed to be in the internal version of an API and is converted -// to the given version first. -// If PrintObj() is called multiple times, objects are separated with a '---' separator. -type YAMLPrinter struct { - printCount int64 -} - -// PrintObj prints the data as YAML. -func (p *YAMLPrinter) PrintObj(obj runtime.Object, w io.Writer) error { - // we use reflect.Indirect here in order to obtain the actual value from a pointer. - // we need an actual value in order to retrieve the package path for an object. - // using reflect.Indirect indiscriminately is valid here, as all runtime.Objects are supposed to be pointers. - if InternalObjectPreventer.IsForbidden(reflect.Indirect(reflect.ValueOf(obj)).Type().PkgPath()) { - return fmt.Errorf(InternalObjectPrinterErr) - } - - count := atomic.AddInt64(&p.printCount, 1) - if count > 1 { - if _, err := w.Write([]byte("---\n")); err != nil { - return err - } - } - - switch obj := obj.(type) { - case *metav1.WatchEvent: - if InternalObjectPreventer.IsForbidden(reflect.Indirect(reflect.ValueOf(obj.Object.Object)).Type().PkgPath()) { - return fmt.Errorf(InternalObjectPrinterErr) - } - data, err := json.Marshal(obj) - if err != nil { - return err - } - data, err = yaml.JSONToYAML(data) - if err != nil { - return err - } - _, err = w.Write(data) - return err - case *runtime.Unknown: - data, err := yaml.JSONToYAML(obj.Raw) - if err != nil { - return err - } - _, err = w.Write(data) - return err - } - - if obj.GetObjectKind().GroupVersionKind().Empty() { - return fmt.Errorf("missing apiVersion or kind; try GetObjectKind().SetGroupVersionKind() if you know the type") - } - - output, err := yaml.Marshal(obj) - if err != nil { - return err - } - _, err = fmt.Fprint(w, string(output)) - return err -} diff --git a/vendor/k8s.io/cli-runtime/pkg/printers/yaml.go b/vendor/k8s.io/cli-runtime/pkg/printers/yaml.go new file mode 100644 index 0000000000..1d636ba740 --- /dev/null +++ b/vendor/k8s.io/cli-runtime/pkg/printers/yaml.go @@ -0,0 +1,90 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package printers + +import ( + "encoding/json" + "fmt" + "io" + "reflect" + "sync/atomic" + + "sigs.k8s.io/yaml" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" +) + +// YAMLPrinter is an implementation of ResourcePrinter which outputs an object as YAML. +// The input object is assumed to be in the internal version of an API and is converted +// to the given version first. +// If PrintObj() is called multiple times, objects are separated with a '---' separator. +type YAMLPrinter struct { + printCount int64 +} + +// PrintObj prints the data as YAML. +func (p *YAMLPrinter) PrintObj(obj runtime.Object, w io.Writer) error { + // we use reflect.Indirect here in order to obtain the actual value from a pointer. + // we need an actual value in order to retrieve the package path for an object. + // using reflect.Indirect indiscriminately is valid here, as all runtime.Objects are supposed to be pointers. + if InternalObjectPreventer.IsForbidden(reflect.Indirect(reflect.ValueOf(obj)).Type().PkgPath()) { + return fmt.Errorf(InternalObjectPrinterErr) + } + + count := atomic.AddInt64(&p.printCount, 1) + if count > 1 { + if _, err := w.Write([]byte("---\n")); err != nil { + return err + } + } + + switch obj := obj.(type) { + case *metav1.WatchEvent: + if InternalObjectPreventer.IsForbidden(reflect.Indirect(reflect.ValueOf(obj.Object.Object)).Type().PkgPath()) { + return fmt.Errorf(InternalObjectPrinterErr) + } + data, err := json.Marshal(obj) + if err != nil { + return err + } + data, err = yaml.JSONToYAML(data) + if err != nil { + return err + } + _, err = w.Write(data) + return err + case *runtime.Unknown: + data, err := yaml.JSONToYAML(obj.Raw) + if err != nil { + return err + } + _, err = w.Write(data) + return err + } + + if obj.GetObjectKind().GroupVersionKind().Empty() { + return fmt.Errorf("missing apiVersion or kind; try GetObjectKind().SetGroupVersionKind() if you know the type") + } + + output, err := yaml.Marshal(obj) + if err != nil { + return err + } + _, err = fmt.Fprint(w, string(output)) + return err +} diff --git a/vendor/k8s.io/cli-runtime/pkg/resource/builder.go b/vendor/k8s.io/cli-runtime/pkg/resource/builder.go index 87922680ed..f206f3b3ef 100644 --- a/vendor/k8s.io/cli-runtime/pkg/resource/builder.go +++ b/vendor/k8s.io/cli-runtime/pkg/resource/builder.go @@ -212,7 +212,7 @@ func NewBuilder(restClientGetter RESTClientGetter) *Builder { return newBuilder( restClientGetter.ToRESTConfig, - (&cachingRESTMapperFunc{delegate: restClientGetter.ToRESTMapper}).ToRESTMapper, + restClientGetter.ToRESTMapper, (&cachingCategoryExpanderFunc{delegate: categoryExpanderFn}).ToCategoryExpander, ) } @@ -1187,28 +1187,6 @@ func HasNames(args []string) (bool, error) { return hasCombinedTypes || len(args) > 1, nil } -type cachingRESTMapperFunc struct { - delegate RESTMapperFunc - - lock sync.Mutex - cached meta.RESTMapper -} - -func (c *cachingRESTMapperFunc) ToRESTMapper() (meta.RESTMapper, error) { - c.lock.Lock() - defer c.lock.Unlock() - if c.cached != nil { - return c.cached, nil - } - - ret, err := c.delegate() - if err != nil { - return nil, err - } - c.cached = ret - return c.cached, nil -} - type cachingCategoryExpanderFunc struct { delegate CategoryExpanderFunc diff --git a/vendor/k8s.io/cli-runtime/pkg/resource/metadata_decoder.go b/vendor/k8s.io/cli-runtime/pkg/resource/metadata_decoder.go index 12770573e2..d688c3a08a 100644 --- a/vendor/k8s.io/cli-runtime/pkg/resource/metadata_decoder.go +++ b/vendor/k8s.io/cli-runtime/pkg/resource/metadata_decoder.go @@ -20,12 +20,9 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" - "k8s.io/apimachinery/pkg/runtime/serializer/json" + utiljson "k8s.io/apimachinery/pkg/util/json" ) -// hold a single instance of the case-sensitive decoder -var caseSensitiveJsonIterator = json.CaseSensitiveJSONIterator() - // metadataValidatingDecoder wraps a decoder and additionally ensures metadata schema fields decode before returning an unstructured object type metadataValidatingDecoder struct { decoder runtime.Decoder @@ -47,7 +44,7 @@ func (m *metadataValidatingDecoder) Decode(data []byte, defaults *schema.GroupVe // make sure the data can decode into ObjectMeta before we return, // so we don't silently truncate schema errors in metadata later with accesser get/set calls v := &metadataOnlyObject{} - if typedErr := caseSensitiveJsonIterator.Unmarshal(data, v); typedErr != nil { + if typedErr := utiljson.Unmarshal(data, v); typedErr != nil { return obj, gvk, typedErr } return obj, gvk, err diff --git a/vendor/k8s.io/cli-runtime/pkg/resource/visitor.go b/vendor/k8s.io/cli-runtime/pkg/resource/visitor.go index 25d2443465..41962cb5e0 100644 --- a/vendor/k8s.io/cli-runtime/pkg/resource/visitor.go +++ b/vendor/k8s.io/cli-runtime/pkg/resource/visitor.go @@ -430,6 +430,10 @@ func (v FlattenListVisitor) Visit(fn VisitorFunc) error { if len(info.ResourceVersion) != 0 { item.ResourceVersion = info.ResourceVersion } + // propagate list source to items source + if len(info.Source) != 0 { + item.Source = info.Source + } if err := fn(item, nil); err != nil { errs = append(errs, err) } @@ -671,16 +675,6 @@ func RetrieveLazy(info *Info, err error) error { return nil } -// CreateAndRefresh creates an object from input info and refreshes info with that object -func CreateAndRefresh(info *Info) error { - obj, err := NewHelper(info.Client, info.Mapping).Create(info.Namespace, true, info.Object) - if err != nil { - return err - } - info.Refresh(obj, true) - return nil -} - type FilterFunc func(info *Info, err error) (bool, error) type FilteredVisitor struct { diff --git a/vendor/k8s.io/client-go/applyconfigurations/apps/v1/statefulsetpersistentvolumeclaimretentionpolicy.go b/vendor/k8s.io/client-go/applyconfigurations/apps/v1/statefulsetpersistentvolumeclaimretentionpolicy.go new file mode 100644 index 0000000000..ba01d5d3c1 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/apps/v1/statefulsetpersistentvolumeclaimretentionpolicy.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "k8s.io/api/apps/v1" +) + +// StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration represents an declarative configuration of the StatefulSetPersistentVolumeClaimRetentionPolicy type for use +// with apply. +type StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration struct { + WhenDeleted *v1.PersistentVolumeClaimRetentionPolicyType `json:"whenDeleted,omitempty"` + WhenScaled *v1.PersistentVolumeClaimRetentionPolicyType `json:"whenScaled,omitempty"` +} + +// StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration constructs an declarative configuration of the StatefulSetPersistentVolumeClaimRetentionPolicy type for use with +// apply. +func StatefulSetPersistentVolumeClaimRetentionPolicy() *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration { + return &StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration{} +} + +// WithWhenDeleted sets the WhenDeleted field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the WhenDeleted field is set to the value of the last call. +func (b *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration) WithWhenDeleted(value v1.PersistentVolumeClaimRetentionPolicyType) *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration { + b.WhenDeleted = &value + return b +} + +// WithWhenScaled sets the WhenScaled field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the WhenScaled field is set to the value of the last call. +func (b *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration) WithWhenScaled(value v1.PersistentVolumeClaimRetentionPolicyType) *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration { + b.WhenScaled = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/apps/v1/statefulsetspec.go b/vendor/k8s.io/client-go/applyconfigurations/apps/v1/statefulsetspec.go index ade14180b2..ee0ed40a56 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/apps/v1/statefulsetspec.go +++ b/vendor/k8s.io/client-go/applyconfigurations/apps/v1/statefulsetspec.go @@ -27,15 +27,16 @@ import ( // StatefulSetSpecApplyConfiguration represents an declarative configuration of the StatefulSetSpec type for use // with apply. type StatefulSetSpecApplyConfiguration struct { - Replicas *int32 `json:"replicas,omitempty"` - Selector *v1.LabelSelectorApplyConfiguration `json:"selector,omitempty"` - Template *corev1.PodTemplateSpecApplyConfiguration `json:"template,omitempty"` - VolumeClaimTemplates []corev1.PersistentVolumeClaimApplyConfiguration `json:"volumeClaimTemplates,omitempty"` - ServiceName *string `json:"serviceName,omitempty"` - PodManagementPolicy *appsv1.PodManagementPolicyType `json:"podManagementPolicy,omitempty"` - UpdateStrategy *StatefulSetUpdateStrategyApplyConfiguration `json:"updateStrategy,omitempty"` - RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"` - MinReadySeconds *int32 `json:"minReadySeconds,omitempty"` + Replicas *int32 `json:"replicas,omitempty"` + Selector *v1.LabelSelectorApplyConfiguration `json:"selector,omitempty"` + Template *corev1.PodTemplateSpecApplyConfiguration `json:"template,omitempty"` + VolumeClaimTemplates []corev1.PersistentVolumeClaimApplyConfiguration `json:"volumeClaimTemplates,omitempty"` + ServiceName *string `json:"serviceName,omitempty"` + PodManagementPolicy *appsv1.PodManagementPolicyType `json:"podManagementPolicy,omitempty"` + UpdateStrategy *StatefulSetUpdateStrategyApplyConfiguration `json:"updateStrategy,omitempty"` + RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"` + MinReadySeconds *int32 `json:"minReadySeconds,omitempty"` + PersistentVolumeClaimRetentionPolicy *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration `json:"persistentVolumeClaimRetentionPolicy,omitempty"` } // StatefulSetSpecApplyConfiguration constructs an declarative configuration of the StatefulSetSpec type for use with @@ -120,3 +121,11 @@ func (b *StatefulSetSpecApplyConfiguration) WithMinReadySeconds(value int32) *St b.MinReadySeconds = &value return b } + +// WithPersistentVolumeClaimRetentionPolicy sets the PersistentVolumeClaimRetentionPolicy field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the PersistentVolumeClaimRetentionPolicy field is set to the value of the last call. +func (b *StatefulSetSpecApplyConfiguration) WithPersistentVolumeClaimRetentionPolicy(value *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration) *StatefulSetSpecApplyConfiguration { + b.PersistentVolumeClaimRetentionPolicy = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta1/statefulsetpersistentvolumeclaimretentionpolicy.go b/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta1/statefulsetpersistentvolumeclaimretentionpolicy.go new file mode 100644 index 0000000000..0048724c04 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta1/statefulsetpersistentvolumeclaimretentionpolicy.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta1 + +import ( + v1beta1 "k8s.io/api/apps/v1beta1" +) + +// StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration represents an declarative configuration of the StatefulSetPersistentVolumeClaimRetentionPolicy type for use +// with apply. +type StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration struct { + WhenDeleted *v1beta1.PersistentVolumeClaimRetentionPolicyType `json:"whenDeleted,omitempty"` + WhenScaled *v1beta1.PersistentVolumeClaimRetentionPolicyType `json:"whenScaled,omitempty"` +} + +// StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration constructs an declarative configuration of the StatefulSetPersistentVolumeClaimRetentionPolicy type for use with +// apply. +func StatefulSetPersistentVolumeClaimRetentionPolicy() *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration { + return &StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration{} +} + +// WithWhenDeleted sets the WhenDeleted field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the WhenDeleted field is set to the value of the last call. +func (b *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration) WithWhenDeleted(value v1beta1.PersistentVolumeClaimRetentionPolicyType) *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration { + b.WhenDeleted = &value + return b +} + +// WithWhenScaled sets the WhenScaled field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the WhenScaled field is set to the value of the last call. +func (b *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration) WithWhenScaled(value v1beta1.PersistentVolumeClaimRetentionPolicyType) *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration { + b.WhenScaled = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta1/statefulsetspec.go b/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta1/statefulsetspec.go index befd1f7e0a..886433d9ea 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta1/statefulsetspec.go +++ b/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta1/statefulsetspec.go @@ -27,15 +27,16 @@ import ( // StatefulSetSpecApplyConfiguration represents an declarative configuration of the StatefulSetSpec type for use // with apply. type StatefulSetSpecApplyConfiguration struct { - Replicas *int32 `json:"replicas,omitempty"` - Selector *v1.LabelSelectorApplyConfiguration `json:"selector,omitempty"` - Template *corev1.PodTemplateSpecApplyConfiguration `json:"template,omitempty"` - VolumeClaimTemplates []corev1.PersistentVolumeClaimApplyConfiguration `json:"volumeClaimTemplates,omitempty"` - ServiceName *string `json:"serviceName,omitempty"` - PodManagementPolicy *v1beta1.PodManagementPolicyType `json:"podManagementPolicy,omitempty"` - UpdateStrategy *StatefulSetUpdateStrategyApplyConfiguration `json:"updateStrategy,omitempty"` - RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"` - MinReadySeconds *int32 `json:"minReadySeconds,omitempty"` + Replicas *int32 `json:"replicas,omitempty"` + Selector *v1.LabelSelectorApplyConfiguration `json:"selector,omitempty"` + Template *corev1.PodTemplateSpecApplyConfiguration `json:"template,omitempty"` + VolumeClaimTemplates []corev1.PersistentVolumeClaimApplyConfiguration `json:"volumeClaimTemplates,omitempty"` + ServiceName *string `json:"serviceName,omitempty"` + PodManagementPolicy *v1beta1.PodManagementPolicyType `json:"podManagementPolicy,omitempty"` + UpdateStrategy *StatefulSetUpdateStrategyApplyConfiguration `json:"updateStrategy,omitempty"` + RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"` + MinReadySeconds *int32 `json:"minReadySeconds,omitempty"` + PersistentVolumeClaimRetentionPolicy *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration `json:"persistentVolumeClaimRetentionPolicy,omitempty"` } // StatefulSetSpecApplyConfiguration constructs an declarative configuration of the StatefulSetSpec type for use with @@ -120,3 +121,11 @@ func (b *StatefulSetSpecApplyConfiguration) WithMinReadySeconds(value int32) *St b.MinReadySeconds = &value return b } + +// WithPersistentVolumeClaimRetentionPolicy sets the PersistentVolumeClaimRetentionPolicy field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the PersistentVolumeClaimRetentionPolicy field is set to the value of the last call. +func (b *StatefulSetSpecApplyConfiguration) WithPersistentVolumeClaimRetentionPolicy(value *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration) *StatefulSetSpecApplyConfiguration { + b.PersistentVolumeClaimRetentionPolicy = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta2/statefulsetpersistentvolumeclaimretentionpolicy.go b/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta2/statefulsetpersistentvolumeclaimretentionpolicy.go new file mode 100644 index 0000000000..aee27803d3 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta2/statefulsetpersistentvolumeclaimretentionpolicy.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +import ( + v1beta2 "k8s.io/api/apps/v1beta2" +) + +// StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration represents an declarative configuration of the StatefulSetPersistentVolumeClaimRetentionPolicy type for use +// with apply. +type StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration struct { + WhenDeleted *v1beta2.PersistentVolumeClaimRetentionPolicyType `json:"whenDeleted,omitempty"` + WhenScaled *v1beta2.PersistentVolumeClaimRetentionPolicyType `json:"whenScaled,omitempty"` +} + +// StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration constructs an declarative configuration of the StatefulSetPersistentVolumeClaimRetentionPolicy type for use with +// apply. +func StatefulSetPersistentVolumeClaimRetentionPolicy() *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration { + return &StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration{} +} + +// WithWhenDeleted sets the WhenDeleted field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the WhenDeleted field is set to the value of the last call. +func (b *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration) WithWhenDeleted(value v1beta2.PersistentVolumeClaimRetentionPolicyType) *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration { + b.WhenDeleted = &value + return b +} + +// WithWhenScaled sets the WhenScaled field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the WhenScaled field is set to the value of the last call. +func (b *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration) WithWhenScaled(value v1beta2.PersistentVolumeClaimRetentionPolicyType) *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration { + b.WhenScaled = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta2/statefulsetspec.go b/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta2/statefulsetspec.go index 44044be265..08922cea57 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta2/statefulsetspec.go +++ b/vendor/k8s.io/client-go/applyconfigurations/apps/v1beta2/statefulsetspec.go @@ -27,15 +27,16 @@ import ( // StatefulSetSpecApplyConfiguration represents an declarative configuration of the StatefulSetSpec type for use // with apply. type StatefulSetSpecApplyConfiguration struct { - Replicas *int32 `json:"replicas,omitempty"` - Selector *v1.LabelSelectorApplyConfiguration `json:"selector,omitempty"` - Template *corev1.PodTemplateSpecApplyConfiguration `json:"template,omitempty"` - VolumeClaimTemplates []corev1.PersistentVolumeClaimApplyConfiguration `json:"volumeClaimTemplates,omitempty"` - ServiceName *string `json:"serviceName,omitempty"` - PodManagementPolicy *v1beta2.PodManagementPolicyType `json:"podManagementPolicy,omitempty"` - UpdateStrategy *StatefulSetUpdateStrategyApplyConfiguration `json:"updateStrategy,omitempty"` - RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"` - MinReadySeconds *int32 `json:"minReadySeconds,omitempty"` + Replicas *int32 `json:"replicas,omitempty"` + Selector *v1.LabelSelectorApplyConfiguration `json:"selector,omitempty"` + Template *corev1.PodTemplateSpecApplyConfiguration `json:"template,omitempty"` + VolumeClaimTemplates []corev1.PersistentVolumeClaimApplyConfiguration `json:"volumeClaimTemplates,omitempty"` + ServiceName *string `json:"serviceName,omitempty"` + PodManagementPolicy *v1beta2.PodManagementPolicyType `json:"podManagementPolicy,omitempty"` + UpdateStrategy *StatefulSetUpdateStrategyApplyConfiguration `json:"updateStrategy,omitempty"` + RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"` + MinReadySeconds *int32 `json:"minReadySeconds,omitempty"` + PersistentVolumeClaimRetentionPolicy *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration `json:"persistentVolumeClaimRetentionPolicy,omitempty"` } // StatefulSetSpecApplyConfiguration constructs an declarative configuration of the StatefulSetSpec type for use with @@ -120,3 +121,11 @@ func (b *StatefulSetSpecApplyConfiguration) WithMinReadySeconds(value int32) *St b.MinReadySeconds = &value return b } + +// WithPersistentVolumeClaimRetentionPolicy sets the PersistentVolumeClaimRetentionPolicy field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the PersistentVolumeClaimRetentionPolicy field is set to the value of the last call. +func (b *StatefulSetSpecApplyConfiguration) WithPersistentVolumeClaimRetentionPolicy(value *StatefulSetPersistentVolumeClaimRetentionPolicyApplyConfiguration) *StatefulSetSpecApplyConfiguration { + b.PersistentVolumeClaimRetentionPolicy = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/containerresourcemetricsource.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/containerresourcemetricsource.go new file mode 100644 index 0000000000..15ef216d1b --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/containerresourcemetricsource.go @@ -0,0 +1,61 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v1 "k8s.io/api/core/v1" +) + +// ContainerResourceMetricSourceApplyConfiguration represents an declarative configuration of the ContainerResourceMetricSource type for use +// with apply. +type ContainerResourceMetricSourceApplyConfiguration struct { + Name *v1.ResourceName `json:"name,omitempty"` + Target *MetricTargetApplyConfiguration `json:"target,omitempty"` + Container *string `json:"container,omitempty"` +} + +// ContainerResourceMetricSourceApplyConfiguration constructs an declarative configuration of the ContainerResourceMetricSource type for use with +// apply. +func ContainerResourceMetricSource() *ContainerResourceMetricSourceApplyConfiguration { + return &ContainerResourceMetricSourceApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *ContainerResourceMetricSourceApplyConfiguration) WithName(value v1.ResourceName) *ContainerResourceMetricSourceApplyConfiguration { + b.Name = &value + return b +} + +// WithTarget sets the Target field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Target field is set to the value of the last call. +func (b *ContainerResourceMetricSourceApplyConfiguration) WithTarget(value *MetricTargetApplyConfiguration) *ContainerResourceMetricSourceApplyConfiguration { + b.Target = value + return b +} + +// WithContainer sets the Container field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Container field is set to the value of the last call. +func (b *ContainerResourceMetricSourceApplyConfiguration) WithContainer(value string) *ContainerResourceMetricSourceApplyConfiguration { + b.Container = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/containerresourcemetricstatus.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/containerresourcemetricstatus.go new file mode 100644 index 0000000000..34213bca3f --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/containerresourcemetricstatus.go @@ -0,0 +1,61 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v1 "k8s.io/api/core/v1" +) + +// ContainerResourceMetricStatusApplyConfiguration represents an declarative configuration of the ContainerResourceMetricStatus type for use +// with apply. +type ContainerResourceMetricStatusApplyConfiguration struct { + Name *v1.ResourceName `json:"name,omitempty"` + Current *MetricValueStatusApplyConfiguration `json:"current,omitempty"` + Container *string `json:"container,omitempty"` +} + +// ContainerResourceMetricStatusApplyConfiguration constructs an declarative configuration of the ContainerResourceMetricStatus type for use with +// apply. +func ContainerResourceMetricStatus() *ContainerResourceMetricStatusApplyConfiguration { + return &ContainerResourceMetricStatusApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *ContainerResourceMetricStatusApplyConfiguration) WithName(value v1.ResourceName) *ContainerResourceMetricStatusApplyConfiguration { + b.Name = &value + return b +} + +// WithCurrent sets the Current field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Current field is set to the value of the last call. +func (b *ContainerResourceMetricStatusApplyConfiguration) WithCurrent(value *MetricValueStatusApplyConfiguration) *ContainerResourceMetricStatusApplyConfiguration { + b.Current = value + return b +} + +// WithContainer sets the Container field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Container field is set to the value of the last call. +func (b *ContainerResourceMetricStatusApplyConfiguration) WithContainer(value string) *ContainerResourceMetricStatusApplyConfiguration { + b.Container = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/crossversionobjectreference.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/crossversionobjectreference.go new file mode 100644 index 0000000000..19045706dc --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/crossversionobjectreference.go @@ -0,0 +1,57 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +// CrossVersionObjectReferenceApplyConfiguration represents an declarative configuration of the CrossVersionObjectReference type for use +// with apply. +type CrossVersionObjectReferenceApplyConfiguration struct { + Kind *string `json:"kind,omitempty"` + Name *string `json:"name,omitempty"` + APIVersion *string `json:"apiVersion,omitempty"` +} + +// CrossVersionObjectReferenceApplyConfiguration constructs an declarative configuration of the CrossVersionObjectReference type for use with +// apply. +func CrossVersionObjectReference() *CrossVersionObjectReferenceApplyConfiguration { + return &CrossVersionObjectReferenceApplyConfiguration{} +} + +// WithKind sets the Kind field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Kind field is set to the value of the last call. +func (b *CrossVersionObjectReferenceApplyConfiguration) WithKind(value string) *CrossVersionObjectReferenceApplyConfiguration { + b.Kind = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *CrossVersionObjectReferenceApplyConfiguration) WithName(value string) *CrossVersionObjectReferenceApplyConfiguration { + b.Name = &value + return b +} + +// WithAPIVersion sets the APIVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the APIVersion field is set to the value of the last call. +func (b *CrossVersionObjectReferenceApplyConfiguration) WithAPIVersion(value string) *CrossVersionObjectReferenceApplyConfiguration { + b.APIVersion = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/externalmetricsource.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/externalmetricsource.go new file mode 100644 index 0000000000..11a8eff263 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/externalmetricsource.go @@ -0,0 +1,48 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +// ExternalMetricSourceApplyConfiguration represents an declarative configuration of the ExternalMetricSource type for use +// with apply. +type ExternalMetricSourceApplyConfiguration struct { + Metric *MetricIdentifierApplyConfiguration `json:"metric,omitempty"` + Target *MetricTargetApplyConfiguration `json:"target,omitempty"` +} + +// ExternalMetricSourceApplyConfiguration constructs an declarative configuration of the ExternalMetricSource type for use with +// apply. +func ExternalMetricSource() *ExternalMetricSourceApplyConfiguration { + return &ExternalMetricSourceApplyConfiguration{} +} + +// WithMetric sets the Metric field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Metric field is set to the value of the last call. +func (b *ExternalMetricSourceApplyConfiguration) WithMetric(value *MetricIdentifierApplyConfiguration) *ExternalMetricSourceApplyConfiguration { + b.Metric = value + return b +} + +// WithTarget sets the Target field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Target field is set to the value of the last call. +func (b *ExternalMetricSourceApplyConfiguration) WithTarget(value *MetricTargetApplyConfiguration) *ExternalMetricSourceApplyConfiguration { + b.Target = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/externalmetricstatus.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/externalmetricstatus.go new file mode 100644 index 0000000000..3b1a0329b8 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/externalmetricstatus.go @@ -0,0 +1,48 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +// ExternalMetricStatusApplyConfiguration represents an declarative configuration of the ExternalMetricStatus type for use +// with apply. +type ExternalMetricStatusApplyConfiguration struct { + Metric *MetricIdentifierApplyConfiguration `json:"metric,omitempty"` + Current *MetricValueStatusApplyConfiguration `json:"current,omitempty"` +} + +// ExternalMetricStatusApplyConfiguration constructs an declarative configuration of the ExternalMetricStatus type for use with +// apply. +func ExternalMetricStatus() *ExternalMetricStatusApplyConfiguration { + return &ExternalMetricStatusApplyConfiguration{} +} + +// WithMetric sets the Metric field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Metric field is set to the value of the last call. +func (b *ExternalMetricStatusApplyConfiguration) WithMetric(value *MetricIdentifierApplyConfiguration) *ExternalMetricStatusApplyConfiguration { + b.Metric = value + return b +} + +// WithCurrent sets the Current field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Current field is set to the value of the last call. +func (b *ExternalMetricStatusApplyConfiguration) WithCurrent(value *MetricValueStatusApplyConfiguration) *ExternalMetricStatusApplyConfiguration { + b.Current = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscaler.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscaler.go new file mode 100644 index 0000000000..af805488ec --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscaler.go @@ -0,0 +1,276 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + autoscalingv2 "k8s.io/api/autoscaling/v2" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + managedfields "k8s.io/apimachinery/pkg/util/managedfields" + internal "k8s.io/client-go/applyconfigurations/internal" + v1 "k8s.io/client-go/applyconfigurations/meta/v1" +) + +// HorizontalPodAutoscalerApplyConfiguration represents an declarative configuration of the HorizontalPodAutoscaler type for use +// with apply. +type HorizontalPodAutoscalerApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *HorizontalPodAutoscalerSpecApplyConfiguration `json:"spec,omitempty"` + Status *HorizontalPodAutoscalerStatusApplyConfiguration `json:"status,omitempty"` +} + +// HorizontalPodAutoscaler constructs an declarative configuration of the HorizontalPodAutoscaler type for use with +// apply. +func HorizontalPodAutoscaler(name, namespace string) *HorizontalPodAutoscalerApplyConfiguration { + b := &HorizontalPodAutoscalerApplyConfiguration{} + b.WithName(name) + b.WithNamespace(namespace) + b.WithKind("HorizontalPodAutoscaler") + b.WithAPIVersion("autoscaling/v2") + return b +} + +// ExtractHorizontalPodAutoscaler extracts the applied configuration owned by fieldManager from +// horizontalPodAutoscaler. If no managedFields are found in horizontalPodAutoscaler for fieldManager, a +// HorizontalPodAutoscalerApplyConfiguration is returned with only the Name, Namespace (if applicable), +// APIVersion and Kind populated. It is possible that no managed fields were found for because other +// field managers have taken ownership of all the fields previously owned by fieldManager, or because +// the fieldManager never owned fields any fields. +// horizontalPodAutoscaler must be a unmodified HorizontalPodAutoscaler API object that was retrieved from the Kubernetes API. +// ExtractHorizontalPodAutoscaler provides a way to perform a extract/modify-in-place/apply workflow. +// Note that an extracted apply configuration will contain fewer fields than what the fieldManager previously +// applied if another fieldManager has updated or force applied any of the previously applied fields. +// Experimental! +func ExtractHorizontalPodAutoscaler(horizontalPodAutoscaler *autoscalingv2.HorizontalPodAutoscaler, fieldManager string) (*HorizontalPodAutoscalerApplyConfiguration, error) { + return extractHorizontalPodAutoscaler(horizontalPodAutoscaler, fieldManager, "") +} + +// ExtractHorizontalPodAutoscalerStatus is the same as ExtractHorizontalPodAutoscaler except +// that it extracts the status subresource applied configuration. +// Experimental! +func ExtractHorizontalPodAutoscalerStatus(horizontalPodAutoscaler *autoscalingv2.HorizontalPodAutoscaler, fieldManager string) (*HorizontalPodAutoscalerApplyConfiguration, error) { + return extractHorizontalPodAutoscaler(horizontalPodAutoscaler, fieldManager, "status") +} + +func extractHorizontalPodAutoscaler(horizontalPodAutoscaler *autoscalingv2.HorizontalPodAutoscaler, fieldManager string, subresource string) (*HorizontalPodAutoscalerApplyConfiguration, error) { + b := &HorizontalPodAutoscalerApplyConfiguration{} + err := managedfields.ExtractInto(horizontalPodAutoscaler, internal.Parser().Type("io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler"), fieldManager, b, subresource) + if err != nil { + return nil, err + } + b.WithName(horizontalPodAutoscaler.Name) + b.WithNamespace(horizontalPodAutoscaler.Namespace) + + b.WithKind("HorizontalPodAutoscaler") + b.WithAPIVersion("autoscaling/v2") + return b, nil +} + +// WithKind sets the Kind field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Kind field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithKind(value string) *HorizontalPodAutoscalerApplyConfiguration { + b.Kind = &value + return b +} + +// WithAPIVersion sets the APIVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the APIVersion field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithAPIVersion(value string) *HorizontalPodAutoscalerApplyConfiguration { + b.APIVersion = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithName(value string) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Name = &value + return b +} + +// WithGenerateName sets the GenerateName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the GenerateName field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithGenerateName(value string) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.GenerateName = &value + return b +} + +// WithNamespace sets the Namespace field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Namespace field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithNamespace(value string) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Namespace = &value + return b +} + +// WithSelfLink sets the SelfLink field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the SelfLink field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithSelfLink(value string) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.SelfLink = &value + return b +} + +// WithUID sets the UID field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the UID field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithUID(value types.UID) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.UID = &value + return b +} + +// WithResourceVersion sets the ResourceVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ResourceVersion field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithResourceVersion(value string) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ResourceVersion = &value + return b +} + +// WithGeneration sets the Generation field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Generation field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithGeneration(value int64) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Generation = &value + return b +} + +// WithCreationTimestamp sets the CreationTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CreationTimestamp field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithCreationTimestamp(value metav1.Time) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.CreationTimestamp = &value + return b +} + +// WithDeletionTimestamp sets the DeletionTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionTimestamp field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionTimestamp = &value + return b +} + +// WithDeletionGracePeriodSeconds sets the DeletionGracePeriodSeconds field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionGracePeriodSeconds field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionGracePeriodSeconds = &value + return b +} + +// WithLabels puts the entries into the Labels field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Labels field, +// overwriting an existing map entries in Labels field with the same key. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithLabels(entries map[string]string) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Labels == nil && len(entries) > 0 { + b.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Labels[k] = v + } + return b +} + +// WithAnnotations puts the entries into the Annotations field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Annotations field, +// overwriting an existing map entries in Annotations field with the same key. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithAnnotations(entries map[string]string) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Annotations == nil && len(entries) > 0 { + b.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Annotations[k] = v + } + return b +} + +// WithOwnerReferences adds the given value to the OwnerReferences field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the OwnerReferences field. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.OwnerReferences = append(b.OwnerReferences, *values[i]) + } + return b +} + +// WithFinalizers adds the given value to the Finalizers field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Finalizers field. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithFinalizers(values ...string) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.Finalizers = append(b.Finalizers, values[i]) + } + return b +} + +// WithClusterName sets the ClusterName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ClusterName field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithClusterName(value string) *HorizontalPodAutoscalerApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ClusterName = &value + return b +} + +func (b *HorizontalPodAutoscalerApplyConfiguration) ensureObjectMetaApplyConfigurationExists() { + if b.ObjectMetaApplyConfiguration == nil { + b.ObjectMetaApplyConfiguration = &v1.ObjectMetaApplyConfiguration{} + } +} + +// WithSpec sets the Spec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Spec field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithSpec(value *HorizontalPodAutoscalerSpecApplyConfiguration) *HorizontalPodAutoscalerApplyConfiguration { + b.Spec = value + return b +} + +// WithStatus sets the Status field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Status field is set to the value of the last call. +func (b *HorizontalPodAutoscalerApplyConfiguration) WithStatus(value *HorizontalPodAutoscalerStatusApplyConfiguration) *HorizontalPodAutoscalerApplyConfiguration { + b.Status = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalerbehavior.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalerbehavior.go new file mode 100644 index 0000000000..e6fdabd7c8 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalerbehavior.go @@ -0,0 +1,48 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +// HorizontalPodAutoscalerBehaviorApplyConfiguration represents an declarative configuration of the HorizontalPodAutoscalerBehavior type for use +// with apply. +type HorizontalPodAutoscalerBehaviorApplyConfiguration struct { + ScaleUp *HPAScalingRulesApplyConfiguration `json:"scaleUp,omitempty"` + ScaleDown *HPAScalingRulesApplyConfiguration `json:"scaleDown,omitempty"` +} + +// HorizontalPodAutoscalerBehaviorApplyConfiguration constructs an declarative configuration of the HorizontalPodAutoscalerBehavior type for use with +// apply. +func HorizontalPodAutoscalerBehavior() *HorizontalPodAutoscalerBehaviorApplyConfiguration { + return &HorizontalPodAutoscalerBehaviorApplyConfiguration{} +} + +// WithScaleUp sets the ScaleUp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ScaleUp field is set to the value of the last call. +func (b *HorizontalPodAutoscalerBehaviorApplyConfiguration) WithScaleUp(value *HPAScalingRulesApplyConfiguration) *HorizontalPodAutoscalerBehaviorApplyConfiguration { + b.ScaleUp = value + return b +} + +// WithScaleDown sets the ScaleDown field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ScaleDown field is set to the value of the last call. +func (b *HorizontalPodAutoscalerBehaviorApplyConfiguration) WithScaleDown(value *HPAScalingRulesApplyConfiguration) *HorizontalPodAutoscalerBehaviorApplyConfiguration { + b.ScaleDown = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalercondition.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalercondition.go new file mode 100644 index 0000000000..c020eccd3d --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalercondition.go @@ -0,0 +1,81 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v2 "k8s.io/api/autoscaling/v2" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// HorizontalPodAutoscalerConditionApplyConfiguration represents an declarative configuration of the HorizontalPodAutoscalerCondition type for use +// with apply. +type HorizontalPodAutoscalerConditionApplyConfiguration struct { + Type *v2.HorizontalPodAutoscalerConditionType `json:"type,omitempty"` + Status *v1.ConditionStatus `json:"status,omitempty"` + LastTransitionTime *metav1.Time `json:"lastTransitionTime,omitempty"` + Reason *string `json:"reason,omitempty"` + Message *string `json:"message,omitempty"` +} + +// HorizontalPodAutoscalerConditionApplyConfiguration constructs an declarative configuration of the HorizontalPodAutoscalerCondition type for use with +// apply. +func HorizontalPodAutoscalerCondition() *HorizontalPodAutoscalerConditionApplyConfiguration { + return &HorizontalPodAutoscalerConditionApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *HorizontalPodAutoscalerConditionApplyConfiguration) WithType(value v2.HorizontalPodAutoscalerConditionType) *HorizontalPodAutoscalerConditionApplyConfiguration { + b.Type = &value + return b +} + +// WithStatus sets the Status field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Status field is set to the value of the last call. +func (b *HorizontalPodAutoscalerConditionApplyConfiguration) WithStatus(value v1.ConditionStatus) *HorizontalPodAutoscalerConditionApplyConfiguration { + b.Status = &value + return b +} + +// WithLastTransitionTime sets the LastTransitionTime field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the LastTransitionTime field is set to the value of the last call. +func (b *HorizontalPodAutoscalerConditionApplyConfiguration) WithLastTransitionTime(value metav1.Time) *HorizontalPodAutoscalerConditionApplyConfiguration { + b.LastTransitionTime = &value + return b +} + +// WithReason sets the Reason field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Reason field is set to the value of the last call. +func (b *HorizontalPodAutoscalerConditionApplyConfiguration) WithReason(value string) *HorizontalPodAutoscalerConditionApplyConfiguration { + b.Reason = &value + return b +} + +// WithMessage sets the Message field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Message field is set to the value of the last call. +func (b *HorizontalPodAutoscalerConditionApplyConfiguration) WithMessage(value string) *HorizontalPodAutoscalerConditionApplyConfiguration { + b.Message = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalerspec.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalerspec.go new file mode 100644 index 0000000000..c36bc3f225 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalerspec.go @@ -0,0 +1,80 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +// HorizontalPodAutoscalerSpecApplyConfiguration represents an declarative configuration of the HorizontalPodAutoscalerSpec type for use +// with apply. +type HorizontalPodAutoscalerSpecApplyConfiguration struct { + ScaleTargetRef *CrossVersionObjectReferenceApplyConfiguration `json:"scaleTargetRef,omitempty"` + MinReplicas *int32 `json:"minReplicas,omitempty"` + MaxReplicas *int32 `json:"maxReplicas,omitempty"` + Metrics []MetricSpecApplyConfiguration `json:"metrics,omitempty"` + Behavior *HorizontalPodAutoscalerBehaviorApplyConfiguration `json:"behavior,omitempty"` +} + +// HorizontalPodAutoscalerSpecApplyConfiguration constructs an declarative configuration of the HorizontalPodAutoscalerSpec type for use with +// apply. +func HorizontalPodAutoscalerSpec() *HorizontalPodAutoscalerSpecApplyConfiguration { + return &HorizontalPodAutoscalerSpecApplyConfiguration{} +} + +// WithScaleTargetRef sets the ScaleTargetRef field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ScaleTargetRef field is set to the value of the last call. +func (b *HorizontalPodAutoscalerSpecApplyConfiguration) WithScaleTargetRef(value *CrossVersionObjectReferenceApplyConfiguration) *HorizontalPodAutoscalerSpecApplyConfiguration { + b.ScaleTargetRef = value + return b +} + +// WithMinReplicas sets the MinReplicas field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the MinReplicas field is set to the value of the last call. +func (b *HorizontalPodAutoscalerSpecApplyConfiguration) WithMinReplicas(value int32) *HorizontalPodAutoscalerSpecApplyConfiguration { + b.MinReplicas = &value + return b +} + +// WithMaxReplicas sets the MaxReplicas field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the MaxReplicas field is set to the value of the last call. +func (b *HorizontalPodAutoscalerSpecApplyConfiguration) WithMaxReplicas(value int32) *HorizontalPodAutoscalerSpecApplyConfiguration { + b.MaxReplicas = &value + return b +} + +// WithMetrics adds the given value to the Metrics field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Metrics field. +func (b *HorizontalPodAutoscalerSpecApplyConfiguration) WithMetrics(values ...*MetricSpecApplyConfiguration) *HorizontalPodAutoscalerSpecApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithMetrics") + } + b.Metrics = append(b.Metrics, *values[i]) + } + return b +} + +// WithBehavior sets the Behavior field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Behavior field is set to the value of the last call. +func (b *HorizontalPodAutoscalerSpecApplyConfiguration) WithBehavior(value *HorizontalPodAutoscalerBehaviorApplyConfiguration) *HorizontalPodAutoscalerSpecApplyConfiguration { + b.Behavior = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalerstatus.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalerstatus.go new file mode 100644 index 0000000000..d4d551df85 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/horizontalpodautoscalerstatus.go @@ -0,0 +1,98 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// HorizontalPodAutoscalerStatusApplyConfiguration represents an declarative configuration of the HorizontalPodAutoscalerStatus type for use +// with apply. +type HorizontalPodAutoscalerStatusApplyConfiguration struct { + ObservedGeneration *int64 `json:"observedGeneration,omitempty"` + LastScaleTime *v1.Time `json:"lastScaleTime,omitempty"` + CurrentReplicas *int32 `json:"currentReplicas,omitempty"` + DesiredReplicas *int32 `json:"desiredReplicas,omitempty"` + CurrentMetrics []MetricStatusApplyConfiguration `json:"currentMetrics,omitempty"` + Conditions []HorizontalPodAutoscalerConditionApplyConfiguration `json:"conditions,omitempty"` +} + +// HorizontalPodAutoscalerStatusApplyConfiguration constructs an declarative configuration of the HorizontalPodAutoscalerStatus type for use with +// apply. +func HorizontalPodAutoscalerStatus() *HorizontalPodAutoscalerStatusApplyConfiguration { + return &HorizontalPodAutoscalerStatusApplyConfiguration{} +} + +// WithObservedGeneration sets the ObservedGeneration field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ObservedGeneration field is set to the value of the last call. +func (b *HorizontalPodAutoscalerStatusApplyConfiguration) WithObservedGeneration(value int64) *HorizontalPodAutoscalerStatusApplyConfiguration { + b.ObservedGeneration = &value + return b +} + +// WithLastScaleTime sets the LastScaleTime field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the LastScaleTime field is set to the value of the last call. +func (b *HorizontalPodAutoscalerStatusApplyConfiguration) WithLastScaleTime(value v1.Time) *HorizontalPodAutoscalerStatusApplyConfiguration { + b.LastScaleTime = &value + return b +} + +// WithCurrentReplicas sets the CurrentReplicas field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CurrentReplicas field is set to the value of the last call. +func (b *HorizontalPodAutoscalerStatusApplyConfiguration) WithCurrentReplicas(value int32) *HorizontalPodAutoscalerStatusApplyConfiguration { + b.CurrentReplicas = &value + return b +} + +// WithDesiredReplicas sets the DesiredReplicas field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DesiredReplicas field is set to the value of the last call. +func (b *HorizontalPodAutoscalerStatusApplyConfiguration) WithDesiredReplicas(value int32) *HorizontalPodAutoscalerStatusApplyConfiguration { + b.DesiredReplicas = &value + return b +} + +// WithCurrentMetrics adds the given value to the CurrentMetrics field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the CurrentMetrics field. +func (b *HorizontalPodAutoscalerStatusApplyConfiguration) WithCurrentMetrics(values ...*MetricStatusApplyConfiguration) *HorizontalPodAutoscalerStatusApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithCurrentMetrics") + } + b.CurrentMetrics = append(b.CurrentMetrics, *values[i]) + } + return b +} + +// WithConditions adds the given value to the Conditions field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Conditions field. +func (b *HorizontalPodAutoscalerStatusApplyConfiguration) WithConditions(values ...*HorizontalPodAutoscalerConditionApplyConfiguration) *HorizontalPodAutoscalerStatusApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithConditions") + } + b.Conditions = append(b.Conditions, *values[i]) + } + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/hpascalingpolicy.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/hpascalingpolicy.go new file mode 100644 index 0000000000..139f0fb5c7 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/hpascalingpolicy.go @@ -0,0 +1,61 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v2 "k8s.io/api/autoscaling/v2" +) + +// HPAScalingPolicyApplyConfiguration represents an declarative configuration of the HPAScalingPolicy type for use +// with apply. +type HPAScalingPolicyApplyConfiguration struct { + Type *v2.HPAScalingPolicyType `json:"type,omitempty"` + Value *int32 `json:"value,omitempty"` + PeriodSeconds *int32 `json:"periodSeconds,omitempty"` +} + +// HPAScalingPolicyApplyConfiguration constructs an declarative configuration of the HPAScalingPolicy type for use with +// apply. +func HPAScalingPolicy() *HPAScalingPolicyApplyConfiguration { + return &HPAScalingPolicyApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *HPAScalingPolicyApplyConfiguration) WithType(value v2.HPAScalingPolicyType) *HPAScalingPolicyApplyConfiguration { + b.Type = &value + return b +} + +// WithValue sets the Value field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Value field is set to the value of the last call. +func (b *HPAScalingPolicyApplyConfiguration) WithValue(value int32) *HPAScalingPolicyApplyConfiguration { + b.Value = &value + return b +} + +// WithPeriodSeconds sets the PeriodSeconds field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the PeriodSeconds field is set to the value of the last call. +func (b *HPAScalingPolicyApplyConfiguration) WithPeriodSeconds(value int32) *HPAScalingPolicyApplyConfiguration { + b.PeriodSeconds = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/hpascalingrules.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/hpascalingrules.go new file mode 100644 index 0000000000..e768076aa4 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/hpascalingrules.go @@ -0,0 +1,66 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v2 "k8s.io/api/autoscaling/v2" +) + +// HPAScalingRulesApplyConfiguration represents an declarative configuration of the HPAScalingRules type for use +// with apply. +type HPAScalingRulesApplyConfiguration struct { + StabilizationWindowSeconds *int32 `json:"stabilizationWindowSeconds,omitempty"` + SelectPolicy *v2.ScalingPolicySelect `json:"selectPolicy,omitempty"` + Policies []HPAScalingPolicyApplyConfiguration `json:"policies,omitempty"` +} + +// HPAScalingRulesApplyConfiguration constructs an declarative configuration of the HPAScalingRules type for use with +// apply. +func HPAScalingRules() *HPAScalingRulesApplyConfiguration { + return &HPAScalingRulesApplyConfiguration{} +} + +// WithStabilizationWindowSeconds sets the StabilizationWindowSeconds field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the StabilizationWindowSeconds field is set to the value of the last call. +func (b *HPAScalingRulesApplyConfiguration) WithStabilizationWindowSeconds(value int32) *HPAScalingRulesApplyConfiguration { + b.StabilizationWindowSeconds = &value + return b +} + +// WithSelectPolicy sets the SelectPolicy field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the SelectPolicy field is set to the value of the last call. +func (b *HPAScalingRulesApplyConfiguration) WithSelectPolicy(value v2.ScalingPolicySelect) *HPAScalingRulesApplyConfiguration { + b.SelectPolicy = &value + return b +} + +// WithPolicies adds the given value to the Policies field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Policies field. +func (b *HPAScalingRulesApplyConfiguration) WithPolicies(values ...*HPAScalingPolicyApplyConfiguration) *HPAScalingRulesApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithPolicies") + } + b.Policies = append(b.Policies, *values[i]) + } + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricidentifier.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricidentifier.go new file mode 100644 index 0000000000..312ad3ddd6 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricidentifier.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v1 "k8s.io/client-go/applyconfigurations/meta/v1" +) + +// MetricIdentifierApplyConfiguration represents an declarative configuration of the MetricIdentifier type for use +// with apply. +type MetricIdentifierApplyConfiguration struct { + Name *string `json:"name,omitempty"` + Selector *v1.LabelSelectorApplyConfiguration `json:"selector,omitempty"` +} + +// MetricIdentifierApplyConfiguration constructs an declarative configuration of the MetricIdentifier type for use with +// apply. +func MetricIdentifier() *MetricIdentifierApplyConfiguration { + return &MetricIdentifierApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *MetricIdentifierApplyConfiguration) WithName(value string) *MetricIdentifierApplyConfiguration { + b.Name = &value + return b +} + +// WithSelector sets the Selector field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Selector field is set to the value of the last call. +func (b *MetricIdentifierApplyConfiguration) WithSelector(value *v1.LabelSelectorApplyConfiguration) *MetricIdentifierApplyConfiguration { + b.Selector = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricspec.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricspec.go new file mode 100644 index 0000000000..094ead6c16 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricspec.go @@ -0,0 +1,88 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v2 "k8s.io/api/autoscaling/v2" +) + +// MetricSpecApplyConfiguration represents an declarative configuration of the MetricSpec type for use +// with apply. +type MetricSpecApplyConfiguration struct { + Type *v2.MetricSourceType `json:"type,omitempty"` + Object *ObjectMetricSourceApplyConfiguration `json:"object,omitempty"` + Pods *PodsMetricSourceApplyConfiguration `json:"pods,omitempty"` + Resource *ResourceMetricSourceApplyConfiguration `json:"resource,omitempty"` + ContainerResource *ContainerResourceMetricSourceApplyConfiguration `json:"containerResource,omitempty"` + External *ExternalMetricSourceApplyConfiguration `json:"external,omitempty"` +} + +// MetricSpecApplyConfiguration constructs an declarative configuration of the MetricSpec type for use with +// apply. +func MetricSpec() *MetricSpecApplyConfiguration { + return &MetricSpecApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *MetricSpecApplyConfiguration) WithType(value v2.MetricSourceType) *MetricSpecApplyConfiguration { + b.Type = &value + return b +} + +// WithObject sets the Object field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Object field is set to the value of the last call. +func (b *MetricSpecApplyConfiguration) WithObject(value *ObjectMetricSourceApplyConfiguration) *MetricSpecApplyConfiguration { + b.Object = value + return b +} + +// WithPods sets the Pods field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Pods field is set to the value of the last call. +func (b *MetricSpecApplyConfiguration) WithPods(value *PodsMetricSourceApplyConfiguration) *MetricSpecApplyConfiguration { + b.Pods = value + return b +} + +// WithResource sets the Resource field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Resource field is set to the value of the last call. +func (b *MetricSpecApplyConfiguration) WithResource(value *ResourceMetricSourceApplyConfiguration) *MetricSpecApplyConfiguration { + b.Resource = value + return b +} + +// WithContainerResource sets the ContainerResource field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ContainerResource field is set to the value of the last call. +func (b *MetricSpecApplyConfiguration) WithContainerResource(value *ContainerResourceMetricSourceApplyConfiguration) *MetricSpecApplyConfiguration { + b.ContainerResource = value + return b +} + +// WithExternal sets the External field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the External field is set to the value of the last call. +func (b *MetricSpecApplyConfiguration) WithExternal(value *ExternalMetricSourceApplyConfiguration) *MetricSpecApplyConfiguration { + b.External = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricstatus.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricstatus.go new file mode 100644 index 0000000000..c65ad446f0 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricstatus.go @@ -0,0 +1,88 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v2 "k8s.io/api/autoscaling/v2" +) + +// MetricStatusApplyConfiguration represents an declarative configuration of the MetricStatus type for use +// with apply. +type MetricStatusApplyConfiguration struct { + Type *v2.MetricSourceType `json:"type,omitempty"` + Object *ObjectMetricStatusApplyConfiguration `json:"object,omitempty"` + Pods *PodsMetricStatusApplyConfiguration `json:"pods,omitempty"` + Resource *ResourceMetricStatusApplyConfiguration `json:"resource,omitempty"` + ContainerResource *ContainerResourceMetricStatusApplyConfiguration `json:"containerResource,omitempty"` + External *ExternalMetricStatusApplyConfiguration `json:"external,omitempty"` +} + +// MetricStatusApplyConfiguration constructs an declarative configuration of the MetricStatus type for use with +// apply. +func MetricStatus() *MetricStatusApplyConfiguration { + return &MetricStatusApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *MetricStatusApplyConfiguration) WithType(value v2.MetricSourceType) *MetricStatusApplyConfiguration { + b.Type = &value + return b +} + +// WithObject sets the Object field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Object field is set to the value of the last call. +func (b *MetricStatusApplyConfiguration) WithObject(value *ObjectMetricStatusApplyConfiguration) *MetricStatusApplyConfiguration { + b.Object = value + return b +} + +// WithPods sets the Pods field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Pods field is set to the value of the last call. +func (b *MetricStatusApplyConfiguration) WithPods(value *PodsMetricStatusApplyConfiguration) *MetricStatusApplyConfiguration { + b.Pods = value + return b +} + +// WithResource sets the Resource field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Resource field is set to the value of the last call. +func (b *MetricStatusApplyConfiguration) WithResource(value *ResourceMetricStatusApplyConfiguration) *MetricStatusApplyConfiguration { + b.Resource = value + return b +} + +// WithContainerResource sets the ContainerResource field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ContainerResource field is set to the value of the last call. +func (b *MetricStatusApplyConfiguration) WithContainerResource(value *ContainerResourceMetricStatusApplyConfiguration) *MetricStatusApplyConfiguration { + b.ContainerResource = value + return b +} + +// WithExternal sets the External field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the External field is set to the value of the last call. +func (b *MetricStatusApplyConfiguration) WithExternal(value *ExternalMetricStatusApplyConfiguration) *MetricStatusApplyConfiguration { + b.External = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metrictarget.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metrictarget.go new file mode 100644 index 0000000000..f301e4d2be --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metrictarget.go @@ -0,0 +1,71 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v2 "k8s.io/api/autoscaling/v2" + resource "k8s.io/apimachinery/pkg/api/resource" +) + +// MetricTargetApplyConfiguration represents an declarative configuration of the MetricTarget type for use +// with apply. +type MetricTargetApplyConfiguration struct { + Type *v2.MetricTargetType `json:"type,omitempty"` + Value *resource.Quantity `json:"value,omitempty"` + AverageValue *resource.Quantity `json:"averageValue,omitempty"` + AverageUtilization *int32 `json:"averageUtilization,omitempty"` +} + +// MetricTargetApplyConfiguration constructs an declarative configuration of the MetricTarget type for use with +// apply. +func MetricTarget() *MetricTargetApplyConfiguration { + return &MetricTargetApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *MetricTargetApplyConfiguration) WithType(value v2.MetricTargetType) *MetricTargetApplyConfiguration { + b.Type = &value + return b +} + +// WithValue sets the Value field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Value field is set to the value of the last call. +func (b *MetricTargetApplyConfiguration) WithValue(value resource.Quantity) *MetricTargetApplyConfiguration { + b.Value = &value + return b +} + +// WithAverageValue sets the AverageValue field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the AverageValue field is set to the value of the last call. +func (b *MetricTargetApplyConfiguration) WithAverageValue(value resource.Quantity) *MetricTargetApplyConfiguration { + b.AverageValue = &value + return b +} + +// WithAverageUtilization sets the AverageUtilization field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the AverageUtilization field is set to the value of the last call. +func (b *MetricTargetApplyConfiguration) WithAverageUtilization(value int32) *MetricTargetApplyConfiguration { + b.AverageUtilization = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricvaluestatus.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricvaluestatus.go new file mode 100644 index 0000000000..e8474b1890 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/metricvaluestatus.go @@ -0,0 +1,61 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + resource "k8s.io/apimachinery/pkg/api/resource" +) + +// MetricValueStatusApplyConfiguration represents an declarative configuration of the MetricValueStatus type for use +// with apply. +type MetricValueStatusApplyConfiguration struct { + Value *resource.Quantity `json:"value,omitempty"` + AverageValue *resource.Quantity `json:"averageValue,omitempty"` + AverageUtilization *int32 `json:"averageUtilization,omitempty"` +} + +// MetricValueStatusApplyConfiguration constructs an declarative configuration of the MetricValueStatus type for use with +// apply. +func MetricValueStatus() *MetricValueStatusApplyConfiguration { + return &MetricValueStatusApplyConfiguration{} +} + +// WithValue sets the Value field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Value field is set to the value of the last call. +func (b *MetricValueStatusApplyConfiguration) WithValue(value resource.Quantity) *MetricValueStatusApplyConfiguration { + b.Value = &value + return b +} + +// WithAverageValue sets the AverageValue field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the AverageValue field is set to the value of the last call. +func (b *MetricValueStatusApplyConfiguration) WithAverageValue(value resource.Quantity) *MetricValueStatusApplyConfiguration { + b.AverageValue = &value + return b +} + +// WithAverageUtilization sets the AverageUtilization field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the AverageUtilization field is set to the value of the last call. +func (b *MetricValueStatusApplyConfiguration) WithAverageUtilization(value int32) *MetricValueStatusApplyConfiguration { + b.AverageUtilization = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/objectmetricsource.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/objectmetricsource.go new file mode 100644 index 0000000000..a9482565e0 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/objectmetricsource.go @@ -0,0 +1,57 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +// ObjectMetricSourceApplyConfiguration represents an declarative configuration of the ObjectMetricSource type for use +// with apply. +type ObjectMetricSourceApplyConfiguration struct { + DescribedObject *CrossVersionObjectReferenceApplyConfiguration `json:"describedObject,omitempty"` + Target *MetricTargetApplyConfiguration `json:"target,omitempty"` + Metric *MetricIdentifierApplyConfiguration `json:"metric,omitempty"` +} + +// ObjectMetricSourceApplyConfiguration constructs an declarative configuration of the ObjectMetricSource type for use with +// apply. +func ObjectMetricSource() *ObjectMetricSourceApplyConfiguration { + return &ObjectMetricSourceApplyConfiguration{} +} + +// WithDescribedObject sets the DescribedObject field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DescribedObject field is set to the value of the last call. +func (b *ObjectMetricSourceApplyConfiguration) WithDescribedObject(value *CrossVersionObjectReferenceApplyConfiguration) *ObjectMetricSourceApplyConfiguration { + b.DescribedObject = value + return b +} + +// WithTarget sets the Target field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Target field is set to the value of the last call. +func (b *ObjectMetricSourceApplyConfiguration) WithTarget(value *MetricTargetApplyConfiguration) *ObjectMetricSourceApplyConfiguration { + b.Target = value + return b +} + +// WithMetric sets the Metric field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Metric field is set to the value of the last call. +func (b *ObjectMetricSourceApplyConfiguration) WithMetric(value *MetricIdentifierApplyConfiguration) *ObjectMetricSourceApplyConfiguration { + b.Metric = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/objectmetricstatus.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/objectmetricstatus.go new file mode 100644 index 0000000000..70ba43bedd --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/objectmetricstatus.go @@ -0,0 +1,57 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +// ObjectMetricStatusApplyConfiguration represents an declarative configuration of the ObjectMetricStatus type for use +// with apply. +type ObjectMetricStatusApplyConfiguration struct { + Metric *MetricIdentifierApplyConfiguration `json:"metric,omitempty"` + Current *MetricValueStatusApplyConfiguration `json:"current,omitempty"` + DescribedObject *CrossVersionObjectReferenceApplyConfiguration `json:"describedObject,omitempty"` +} + +// ObjectMetricStatusApplyConfiguration constructs an declarative configuration of the ObjectMetricStatus type for use with +// apply. +func ObjectMetricStatus() *ObjectMetricStatusApplyConfiguration { + return &ObjectMetricStatusApplyConfiguration{} +} + +// WithMetric sets the Metric field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Metric field is set to the value of the last call. +func (b *ObjectMetricStatusApplyConfiguration) WithMetric(value *MetricIdentifierApplyConfiguration) *ObjectMetricStatusApplyConfiguration { + b.Metric = value + return b +} + +// WithCurrent sets the Current field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Current field is set to the value of the last call. +func (b *ObjectMetricStatusApplyConfiguration) WithCurrent(value *MetricValueStatusApplyConfiguration) *ObjectMetricStatusApplyConfiguration { + b.Current = value + return b +} + +// WithDescribedObject sets the DescribedObject field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DescribedObject field is set to the value of the last call. +func (b *ObjectMetricStatusApplyConfiguration) WithDescribedObject(value *CrossVersionObjectReferenceApplyConfiguration) *ObjectMetricStatusApplyConfiguration { + b.DescribedObject = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/podresourcemetricsource.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/podresourcemetricsource.go new file mode 100644 index 0000000000..86601cc48a --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/podresourcemetricsource.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v1 "k8s.io/api/core/v1" +) + +// PodResourceMetricSourceApplyConfiguration represents an declarative configuration of the PodResourceMetricSource type for use +// with apply. +type PodResourceMetricSourceApplyConfiguration struct { + Name *v1.ResourceName `json:"name,omitempty"` + Target *MetricTargetApplyConfiguration `json:"target,omitempty"` +} + +// PodResourceMetricSourceApplyConfiguration constructs an declarative configuration of the PodResourceMetricSource type for use with +// apply. +func PodResourceMetricSource() *PodResourceMetricSourceApplyConfiguration { + return &PodResourceMetricSourceApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *PodResourceMetricSourceApplyConfiguration) WithName(value v1.ResourceName) *PodResourceMetricSourceApplyConfiguration { + b.Name = &value + return b +} + +// WithTarget sets the Target field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Target field is set to the value of the last call. +func (b *PodResourceMetricSourceApplyConfiguration) WithTarget(value *MetricTargetApplyConfiguration) *PodResourceMetricSourceApplyConfiguration { + b.Target = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/podsmetricsource.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/podsmetricsource.go new file mode 100644 index 0000000000..0a7a5c2595 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/podsmetricsource.go @@ -0,0 +1,48 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +// PodsMetricSourceApplyConfiguration represents an declarative configuration of the PodsMetricSource type for use +// with apply. +type PodsMetricSourceApplyConfiguration struct { + Metric *MetricIdentifierApplyConfiguration `json:"metric,omitempty"` + Target *MetricTargetApplyConfiguration `json:"target,omitempty"` +} + +// PodsMetricSourceApplyConfiguration constructs an declarative configuration of the PodsMetricSource type for use with +// apply. +func PodsMetricSource() *PodsMetricSourceApplyConfiguration { + return &PodsMetricSourceApplyConfiguration{} +} + +// WithMetric sets the Metric field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Metric field is set to the value of the last call. +func (b *PodsMetricSourceApplyConfiguration) WithMetric(value *MetricIdentifierApplyConfiguration) *PodsMetricSourceApplyConfiguration { + b.Metric = value + return b +} + +// WithTarget sets the Target field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Target field is set to the value of the last call. +func (b *PodsMetricSourceApplyConfiguration) WithTarget(value *MetricTargetApplyConfiguration) *PodsMetricSourceApplyConfiguration { + b.Target = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/podsmetricstatus.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/podsmetricstatus.go new file mode 100644 index 0000000000..865fcc33e3 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/podsmetricstatus.go @@ -0,0 +1,48 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +// PodsMetricStatusApplyConfiguration represents an declarative configuration of the PodsMetricStatus type for use +// with apply. +type PodsMetricStatusApplyConfiguration struct { + Metric *MetricIdentifierApplyConfiguration `json:"metric,omitempty"` + Current *MetricValueStatusApplyConfiguration `json:"current,omitempty"` +} + +// PodsMetricStatusApplyConfiguration constructs an declarative configuration of the PodsMetricStatus type for use with +// apply. +func PodsMetricStatus() *PodsMetricStatusApplyConfiguration { + return &PodsMetricStatusApplyConfiguration{} +} + +// WithMetric sets the Metric field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Metric field is set to the value of the last call. +func (b *PodsMetricStatusApplyConfiguration) WithMetric(value *MetricIdentifierApplyConfiguration) *PodsMetricStatusApplyConfiguration { + b.Metric = value + return b +} + +// WithCurrent sets the Current field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Current field is set to the value of the last call. +func (b *PodsMetricStatusApplyConfiguration) WithCurrent(value *MetricValueStatusApplyConfiguration) *PodsMetricStatusApplyConfiguration { + b.Current = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/resourcemetricsource.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/resourcemetricsource.go new file mode 100644 index 0000000000..25a065fef6 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/resourcemetricsource.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v1 "k8s.io/api/core/v1" +) + +// ResourceMetricSourceApplyConfiguration represents an declarative configuration of the ResourceMetricSource type for use +// with apply. +type ResourceMetricSourceApplyConfiguration struct { + Name *v1.ResourceName `json:"name,omitempty"` + Target *MetricTargetApplyConfiguration `json:"target,omitempty"` +} + +// ResourceMetricSourceApplyConfiguration constructs an declarative configuration of the ResourceMetricSource type for use with +// apply. +func ResourceMetricSource() *ResourceMetricSourceApplyConfiguration { + return &ResourceMetricSourceApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *ResourceMetricSourceApplyConfiguration) WithName(value v1.ResourceName) *ResourceMetricSourceApplyConfiguration { + b.Name = &value + return b +} + +// WithTarget sets the Target field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Target field is set to the value of the last call. +func (b *ResourceMetricSourceApplyConfiguration) WithTarget(value *MetricTargetApplyConfiguration) *ResourceMetricSourceApplyConfiguration { + b.Target = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/resourcemetricstatus.go b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/resourcemetricstatus.go new file mode 100644 index 0000000000..fb5625afab --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/autoscaling/v2/resourcemetricstatus.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v2 + +import ( + v1 "k8s.io/api/core/v1" +) + +// ResourceMetricStatusApplyConfiguration represents an declarative configuration of the ResourceMetricStatus type for use +// with apply. +type ResourceMetricStatusApplyConfiguration struct { + Name *v1.ResourceName `json:"name,omitempty"` + Current *MetricValueStatusApplyConfiguration `json:"current,omitempty"` +} + +// ResourceMetricStatusApplyConfiguration constructs an declarative configuration of the ResourceMetricStatus type for use with +// apply. +func ResourceMetricStatus() *ResourceMetricStatusApplyConfiguration { + return &ResourceMetricStatusApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *ResourceMetricStatusApplyConfiguration) WithName(value v1.ResourceName) *ResourceMetricStatusApplyConfiguration { + b.Name = &value + return b +} + +// WithCurrent sets the Current field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Current field is set to the value of the last call. +func (b *ResourceMetricStatusApplyConfiguration) WithCurrent(value *MetricValueStatusApplyConfiguration) *ResourceMetricStatusApplyConfiguration { + b.Current = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/batch/v1/jobstatus.go b/vendor/k8s.io/client-go/applyconfigurations/batch/v1/jobstatus.go index ba7e27e085..a36d5d0ae1 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/batch/v1/jobstatus.go +++ b/vendor/k8s.io/client-go/applyconfigurations/batch/v1/jobstatus.go @@ -33,6 +33,7 @@ type JobStatusApplyConfiguration struct { Failed *int32 `json:"failed,omitempty"` CompletedIndexes *string `json:"completedIndexes,omitempty"` UncountedTerminatedPods *UncountedTerminatedPodsApplyConfiguration `json:"uncountedTerminatedPods,omitempty"` + Ready *int32 `json:"ready,omitempty"` } // JobStatusApplyConfiguration constructs an declarative configuration of the JobStatus type for use with @@ -109,3 +110,11 @@ func (b *JobStatusApplyConfiguration) WithUncountedTerminatedPods(value *Uncount b.UncountedTerminatedPods = value return b } + +// WithReady sets the Ready field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Ready field is set to the value of the last call. +func (b *JobStatusApplyConfiguration) WithReady(value int32) *JobStatusApplyConfiguration { + b.Ready = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/core/v1/grpcaction.go b/vendor/k8s.io/client-go/applyconfigurations/core/v1/grpcaction.go new file mode 100644 index 0000000000..f94e55937a --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/core/v1/grpcaction.go @@ -0,0 +1,48 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +// GRPCActionApplyConfiguration represents an declarative configuration of the GRPCAction type for use +// with apply. +type GRPCActionApplyConfiguration struct { + Port *int32 `json:"port,omitempty"` + Service *string `json:"service,omitempty"` +} + +// GRPCActionApplyConfiguration constructs an declarative configuration of the GRPCAction type for use with +// apply. +func GRPCAction() *GRPCActionApplyConfiguration { + return &GRPCActionApplyConfiguration{} +} + +// WithPort sets the Port field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Port field is set to the value of the last call. +func (b *GRPCActionApplyConfiguration) WithPort(value int32) *GRPCActionApplyConfiguration { + b.Port = &value + return b +} + +// WithService sets the Service field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Service field is set to the value of the last call. +func (b *GRPCActionApplyConfiguration) WithService(value string) *GRPCActionApplyConfiguration { + b.Service = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/core/v1/lifecycle.go b/vendor/k8s.io/client-go/applyconfigurations/core/v1/lifecycle.go index ab37b6677b..db9abf8af7 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/core/v1/lifecycle.go +++ b/vendor/k8s.io/client-go/applyconfigurations/core/v1/lifecycle.go @@ -21,8 +21,8 @@ package v1 // LifecycleApplyConfiguration represents an declarative configuration of the Lifecycle type for use // with apply. type LifecycleApplyConfiguration struct { - PostStart *HandlerApplyConfiguration `json:"postStart,omitempty"` - PreStop *HandlerApplyConfiguration `json:"preStop,omitempty"` + PostStart *LifecycleHandlerApplyConfiguration `json:"postStart,omitempty"` + PreStop *LifecycleHandlerApplyConfiguration `json:"preStop,omitempty"` } // LifecycleApplyConfiguration constructs an declarative configuration of the Lifecycle type for use with @@ -34,7 +34,7 @@ func Lifecycle() *LifecycleApplyConfiguration { // WithPostStart sets the PostStart field in the declarative configuration to the given value // and returns the receiver, so that objects can be built by chaining "With" function invocations. // If called multiple times, the PostStart field is set to the value of the last call. -func (b *LifecycleApplyConfiguration) WithPostStart(value *HandlerApplyConfiguration) *LifecycleApplyConfiguration { +func (b *LifecycleApplyConfiguration) WithPostStart(value *LifecycleHandlerApplyConfiguration) *LifecycleApplyConfiguration { b.PostStart = value return b } @@ -42,7 +42,7 @@ func (b *LifecycleApplyConfiguration) WithPostStart(value *HandlerApplyConfigura // WithPreStop sets the PreStop field in the declarative configuration to the given value // and returns the receiver, so that objects can be built by chaining "With" function invocations. // If called multiple times, the PreStop field is set to the value of the last call. -func (b *LifecycleApplyConfiguration) WithPreStop(value *HandlerApplyConfiguration) *LifecycleApplyConfiguration { +func (b *LifecycleApplyConfiguration) WithPreStop(value *LifecycleHandlerApplyConfiguration) *LifecycleApplyConfiguration { b.PreStop = value return b } diff --git a/vendor/k8s.io/client-go/applyconfigurations/core/v1/handler.go b/vendor/k8s.io/client-go/applyconfigurations/core/v1/lifecyclehandler.go similarity index 69% rename from vendor/k8s.io/client-go/applyconfigurations/core/v1/handler.go rename to vendor/k8s.io/client-go/applyconfigurations/core/v1/lifecyclehandler.go index fbf1511ccc..6e373dd4ed 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/core/v1/handler.go +++ b/vendor/k8s.io/client-go/applyconfigurations/core/v1/lifecyclehandler.go @@ -18,24 +18,24 @@ limitations under the License. package v1 -// HandlerApplyConfiguration represents an declarative configuration of the Handler type for use +// LifecycleHandlerApplyConfiguration represents an declarative configuration of the LifecycleHandler type for use // with apply. -type HandlerApplyConfiguration struct { +type LifecycleHandlerApplyConfiguration struct { Exec *ExecActionApplyConfiguration `json:"exec,omitempty"` HTTPGet *HTTPGetActionApplyConfiguration `json:"httpGet,omitempty"` TCPSocket *TCPSocketActionApplyConfiguration `json:"tcpSocket,omitempty"` } -// HandlerApplyConfiguration constructs an declarative configuration of the Handler type for use with +// LifecycleHandlerApplyConfiguration constructs an declarative configuration of the LifecycleHandler type for use with // apply. -func Handler() *HandlerApplyConfiguration { - return &HandlerApplyConfiguration{} +func LifecycleHandler() *LifecycleHandlerApplyConfiguration { + return &LifecycleHandlerApplyConfiguration{} } // WithExec sets the Exec field in the declarative configuration to the given value // and returns the receiver, so that objects can be built by chaining "With" function invocations. // If called multiple times, the Exec field is set to the value of the last call. -func (b *HandlerApplyConfiguration) WithExec(value *ExecActionApplyConfiguration) *HandlerApplyConfiguration { +func (b *LifecycleHandlerApplyConfiguration) WithExec(value *ExecActionApplyConfiguration) *LifecycleHandlerApplyConfiguration { b.Exec = value return b } @@ -43,7 +43,7 @@ func (b *HandlerApplyConfiguration) WithExec(value *ExecActionApplyConfiguration // WithHTTPGet sets the HTTPGet field in the declarative configuration to the given value // and returns the receiver, so that objects can be built by chaining "With" function invocations. // If called multiple times, the HTTPGet field is set to the value of the last call. -func (b *HandlerApplyConfiguration) WithHTTPGet(value *HTTPGetActionApplyConfiguration) *HandlerApplyConfiguration { +func (b *LifecycleHandlerApplyConfiguration) WithHTTPGet(value *HTTPGetActionApplyConfiguration) *LifecycleHandlerApplyConfiguration { b.HTTPGet = value return b } @@ -51,7 +51,7 @@ func (b *HandlerApplyConfiguration) WithHTTPGet(value *HTTPGetActionApplyConfigu // WithTCPSocket sets the TCPSocket field in the declarative configuration to the given value // and returns the receiver, so that objects can be built by chaining "With" function invocations. // If called multiple times, the TCPSocket field is set to the value of the last call. -func (b *HandlerApplyConfiguration) WithTCPSocket(value *TCPSocketActionApplyConfiguration) *HandlerApplyConfiguration { +func (b *LifecycleHandlerApplyConfiguration) WithTCPSocket(value *TCPSocketActionApplyConfiguration) *LifecycleHandlerApplyConfiguration { b.TCPSocket = value return b } diff --git a/vendor/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimstatus.go b/vendor/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimstatus.go index 711651e0bc..4c38d89f57 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimstatus.go +++ b/vendor/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimstatus.go @@ -25,10 +25,12 @@ import ( // PersistentVolumeClaimStatusApplyConfiguration represents an declarative configuration of the PersistentVolumeClaimStatus type for use // with apply. type PersistentVolumeClaimStatusApplyConfiguration struct { - Phase *v1.PersistentVolumeClaimPhase `json:"phase,omitempty"` - AccessModes []v1.PersistentVolumeAccessMode `json:"accessModes,omitempty"` - Capacity *v1.ResourceList `json:"capacity,omitempty"` - Conditions []PersistentVolumeClaimConditionApplyConfiguration `json:"conditions,omitempty"` + Phase *v1.PersistentVolumeClaimPhase `json:"phase,omitempty"` + AccessModes []v1.PersistentVolumeAccessMode `json:"accessModes,omitempty"` + Capacity *v1.ResourceList `json:"capacity,omitempty"` + Conditions []PersistentVolumeClaimConditionApplyConfiguration `json:"conditions,omitempty"` + AllocatedResources *v1.ResourceList `json:"allocatedResources,omitempty"` + ResizeStatus *v1.PersistentVolumeClaimResizeStatus `json:"resizeStatus,omitempty"` } // PersistentVolumeClaimStatusApplyConfiguration constructs an declarative configuration of the PersistentVolumeClaimStatus type for use with @@ -75,3 +77,19 @@ func (b *PersistentVolumeClaimStatusApplyConfiguration) WithConditions(values .. } return b } + +// WithAllocatedResources sets the AllocatedResources field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the AllocatedResources field is set to the value of the last call. +func (b *PersistentVolumeClaimStatusApplyConfiguration) WithAllocatedResources(value v1.ResourceList) *PersistentVolumeClaimStatusApplyConfiguration { + b.AllocatedResources = &value + return b +} + +// WithResizeStatus sets the ResizeStatus field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ResizeStatus field is set to the value of the last call. +func (b *PersistentVolumeClaimStatusApplyConfiguration) WithResizeStatus(value v1.PersistentVolumeClaimResizeStatus) *PersistentVolumeClaimStatusApplyConfiguration { + b.ResizeStatus = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/core/v1/podos.go b/vendor/k8s.io/client-go/applyconfigurations/core/v1/podos.go new file mode 100644 index 0000000000..a5315d636b --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/core/v1/podos.go @@ -0,0 +1,43 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "k8s.io/api/core/v1" +) + +// PodOSApplyConfiguration represents an declarative configuration of the PodOS type for use +// with apply. +type PodOSApplyConfiguration struct { + Name *v1.OSName `json:"name,omitempty"` +} + +// PodOSApplyConfiguration constructs an declarative configuration of the PodOS type for use with +// apply. +func PodOS() *PodOSApplyConfiguration { + return &PodOSApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *PodOSApplyConfiguration) WithName(value v1.OSName) *PodOSApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/core/v1/podspec.go b/vendor/k8s.io/client-go/applyconfigurations/core/v1/podspec.go index d1c9ea9cb6..015859e9a3 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/core/v1/podspec.go +++ b/vendor/k8s.io/client-go/applyconfigurations/core/v1/podspec.go @@ -60,6 +60,7 @@ type PodSpecApplyConfiguration struct { Overhead *corev1.ResourceList `json:"overhead,omitempty"` TopologySpreadConstraints []TopologySpreadConstraintApplyConfiguration `json:"topologySpreadConstraints,omitempty"` SetHostnameAsFQDN *bool `json:"setHostnameAsFQDN,omitempty"` + OS *PodOSApplyConfiguration `json:"os,omitempty"` } // PodSpecApplyConfiguration constructs an declarative configuration of the PodSpec type for use with @@ -398,3 +399,11 @@ func (b *PodSpecApplyConfiguration) WithSetHostnameAsFQDN(value bool) *PodSpecAp b.SetHostnameAsFQDN = &value return b } + +// WithOS sets the OS field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the OS field is set to the value of the last call. +func (b *PodSpecApplyConfiguration) WithOS(value *PodOSApplyConfiguration) *PodSpecApplyConfiguration { + b.OS = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/core/v1/probe.go b/vendor/k8s.io/client-go/applyconfigurations/core/v1/probe.go index f87adcd5f3..10730557a0 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/core/v1/probe.go +++ b/vendor/k8s.io/client-go/applyconfigurations/core/v1/probe.go @@ -21,13 +21,13 @@ package v1 // ProbeApplyConfiguration represents an declarative configuration of the Probe type for use // with apply. type ProbeApplyConfiguration struct { - HandlerApplyConfiguration `json:",inline"` - InitialDelaySeconds *int32 `json:"initialDelaySeconds,omitempty"` - TimeoutSeconds *int32 `json:"timeoutSeconds,omitempty"` - PeriodSeconds *int32 `json:"periodSeconds,omitempty"` - SuccessThreshold *int32 `json:"successThreshold,omitempty"` - FailureThreshold *int32 `json:"failureThreshold,omitempty"` - TerminationGracePeriodSeconds *int64 `json:"terminationGracePeriodSeconds,omitempty"` + ProbeHandlerApplyConfiguration `json:",inline"` + InitialDelaySeconds *int32 `json:"initialDelaySeconds,omitempty"` + TimeoutSeconds *int32 `json:"timeoutSeconds,omitempty"` + PeriodSeconds *int32 `json:"periodSeconds,omitempty"` + SuccessThreshold *int32 `json:"successThreshold,omitempty"` + FailureThreshold *int32 `json:"failureThreshold,omitempty"` + TerminationGracePeriodSeconds *int64 `json:"terminationGracePeriodSeconds,omitempty"` } // ProbeApplyConfiguration constructs an declarative configuration of the Probe type for use with @@ -60,6 +60,14 @@ func (b *ProbeApplyConfiguration) WithTCPSocket(value *TCPSocketActionApplyConfi return b } +// WithGRPC sets the GRPC field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the GRPC field is set to the value of the last call. +func (b *ProbeApplyConfiguration) WithGRPC(value *GRPCActionApplyConfiguration) *ProbeApplyConfiguration { + b.GRPC = value + return b +} + // WithInitialDelaySeconds sets the InitialDelaySeconds field in the declarative configuration to the given value // and returns the receiver, so that objects can be built by chaining "With" function invocations. // If called multiple times, the InitialDelaySeconds field is set to the value of the last call. diff --git a/vendor/k8s.io/client-go/applyconfigurations/core/v1/probehandler.go b/vendor/k8s.io/client-go/applyconfigurations/core/v1/probehandler.go new file mode 100644 index 0000000000..54f3344ac7 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/core/v1/probehandler.go @@ -0,0 +1,66 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +// ProbeHandlerApplyConfiguration represents an declarative configuration of the ProbeHandler type for use +// with apply. +type ProbeHandlerApplyConfiguration struct { + Exec *ExecActionApplyConfiguration `json:"exec,omitempty"` + HTTPGet *HTTPGetActionApplyConfiguration `json:"httpGet,omitempty"` + TCPSocket *TCPSocketActionApplyConfiguration `json:"tcpSocket,omitempty"` + GRPC *GRPCActionApplyConfiguration `json:"grpc,omitempty"` +} + +// ProbeHandlerApplyConfiguration constructs an declarative configuration of the ProbeHandler type for use with +// apply. +func ProbeHandler() *ProbeHandlerApplyConfiguration { + return &ProbeHandlerApplyConfiguration{} +} + +// WithExec sets the Exec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Exec field is set to the value of the last call. +func (b *ProbeHandlerApplyConfiguration) WithExec(value *ExecActionApplyConfiguration) *ProbeHandlerApplyConfiguration { + b.Exec = value + return b +} + +// WithHTTPGet sets the HTTPGet field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the HTTPGet field is set to the value of the last call. +func (b *ProbeHandlerApplyConfiguration) WithHTTPGet(value *HTTPGetActionApplyConfiguration) *ProbeHandlerApplyConfiguration { + b.HTTPGet = value + return b +} + +// WithTCPSocket sets the TCPSocket field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the TCPSocket field is set to the value of the last call. +func (b *ProbeHandlerApplyConfiguration) WithTCPSocket(value *TCPSocketActionApplyConfiguration) *ProbeHandlerApplyConfiguration { + b.TCPSocket = value + return b +} + +// WithGRPC sets the GRPC field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the GRPC field is set to the value of the last call. +func (b *ProbeHandlerApplyConfiguration) WithGRPC(value *GRPCActionApplyConfiguration) *ProbeHandlerApplyConfiguration { + b.GRPC = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowdistinguishermethod.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowdistinguishermethod.go new file mode 100644 index 0000000000..924f966d48 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowdistinguishermethod.go @@ -0,0 +1,43 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +import ( + v1beta2 "k8s.io/api/flowcontrol/v1beta2" +) + +// FlowDistinguisherMethodApplyConfiguration represents an declarative configuration of the FlowDistinguisherMethod type for use +// with apply. +type FlowDistinguisherMethodApplyConfiguration struct { + Type *v1beta2.FlowDistinguisherMethodType `json:"type,omitempty"` +} + +// FlowDistinguisherMethodApplyConfiguration constructs an declarative configuration of the FlowDistinguisherMethod type for use with +// apply. +func FlowDistinguisherMethod() *FlowDistinguisherMethodApplyConfiguration { + return &FlowDistinguisherMethodApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *FlowDistinguisherMethodApplyConfiguration) WithType(value v1beta2.FlowDistinguisherMethodType) *FlowDistinguisherMethodApplyConfiguration { + b.Type = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschema.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschema.go new file mode 100644 index 0000000000..323d7241d3 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschema.go @@ -0,0 +1,274 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +import ( + flowcontrolv1beta2 "k8s.io/api/flowcontrol/v1beta2" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + managedfields "k8s.io/apimachinery/pkg/util/managedfields" + internal "k8s.io/client-go/applyconfigurations/internal" + v1 "k8s.io/client-go/applyconfigurations/meta/v1" +) + +// FlowSchemaApplyConfiguration represents an declarative configuration of the FlowSchema type for use +// with apply. +type FlowSchemaApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *FlowSchemaSpecApplyConfiguration `json:"spec,omitempty"` + Status *FlowSchemaStatusApplyConfiguration `json:"status,omitempty"` +} + +// FlowSchema constructs an declarative configuration of the FlowSchema type for use with +// apply. +func FlowSchema(name string) *FlowSchemaApplyConfiguration { + b := &FlowSchemaApplyConfiguration{} + b.WithName(name) + b.WithKind("FlowSchema") + b.WithAPIVersion("flowcontrol.apiserver.k8s.io/v1beta2") + return b +} + +// ExtractFlowSchema extracts the applied configuration owned by fieldManager from +// flowSchema. If no managedFields are found in flowSchema for fieldManager, a +// FlowSchemaApplyConfiguration is returned with only the Name, Namespace (if applicable), +// APIVersion and Kind populated. It is possible that no managed fields were found for because other +// field managers have taken ownership of all the fields previously owned by fieldManager, or because +// the fieldManager never owned fields any fields. +// flowSchema must be a unmodified FlowSchema API object that was retrieved from the Kubernetes API. +// ExtractFlowSchema provides a way to perform a extract/modify-in-place/apply workflow. +// Note that an extracted apply configuration will contain fewer fields than what the fieldManager previously +// applied if another fieldManager has updated or force applied any of the previously applied fields. +// Experimental! +func ExtractFlowSchema(flowSchema *flowcontrolv1beta2.FlowSchema, fieldManager string) (*FlowSchemaApplyConfiguration, error) { + return extractFlowSchema(flowSchema, fieldManager, "") +} + +// ExtractFlowSchemaStatus is the same as ExtractFlowSchema except +// that it extracts the status subresource applied configuration. +// Experimental! +func ExtractFlowSchemaStatus(flowSchema *flowcontrolv1beta2.FlowSchema, fieldManager string) (*FlowSchemaApplyConfiguration, error) { + return extractFlowSchema(flowSchema, fieldManager, "status") +} + +func extractFlowSchema(flowSchema *flowcontrolv1beta2.FlowSchema, fieldManager string, subresource string) (*FlowSchemaApplyConfiguration, error) { + b := &FlowSchemaApplyConfiguration{} + err := managedfields.ExtractInto(flowSchema, internal.Parser().Type("io.k8s.api.flowcontrol.v1beta2.FlowSchema"), fieldManager, b, subresource) + if err != nil { + return nil, err + } + b.WithName(flowSchema.Name) + + b.WithKind("FlowSchema") + b.WithAPIVersion("flowcontrol.apiserver.k8s.io/v1beta2") + return b, nil +} + +// WithKind sets the Kind field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Kind field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithKind(value string) *FlowSchemaApplyConfiguration { + b.Kind = &value + return b +} + +// WithAPIVersion sets the APIVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the APIVersion field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithAPIVersion(value string) *FlowSchemaApplyConfiguration { + b.APIVersion = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithName(value string) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Name = &value + return b +} + +// WithGenerateName sets the GenerateName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the GenerateName field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithGenerateName(value string) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.GenerateName = &value + return b +} + +// WithNamespace sets the Namespace field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Namespace field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithNamespace(value string) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Namespace = &value + return b +} + +// WithSelfLink sets the SelfLink field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the SelfLink field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithSelfLink(value string) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.SelfLink = &value + return b +} + +// WithUID sets the UID field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the UID field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithUID(value types.UID) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.UID = &value + return b +} + +// WithResourceVersion sets the ResourceVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ResourceVersion field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithResourceVersion(value string) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ResourceVersion = &value + return b +} + +// WithGeneration sets the Generation field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Generation field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithGeneration(value int64) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Generation = &value + return b +} + +// WithCreationTimestamp sets the CreationTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CreationTimestamp field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithCreationTimestamp(value metav1.Time) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.CreationTimestamp = &value + return b +} + +// WithDeletionTimestamp sets the DeletionTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionTimestamp field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionTimestamp = &value + return b +} + +// WithDeletionGracePeriodSeconds sets the DeletionGracePeriodSeconds field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionGracePeriodSeconds field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionGracePeriodSeconds = &value + return b +} + +// WithLabels puts the entries into the Labels field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Labels field, +// overwriting an existing map entries in Labels field with the same key. +func (b *FlowSchemaApplyConfiguration) WithLabels(entries map[string]string) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Labels == nil && len(entries) > 0 { + b.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Labels[k] = v + } + return b +} + +// WithAnnotations puts the entries into the Annotations field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Annotations field, +// overwriting an existing map entries in Annotations field with the same key. +func (b *FlowSchemaApplyConfiguration) WithAnnotations(entries map[string]string) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Annotations == nil && len(entries) > 0 { + b.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Annotations[k] = v + } + return b +} + +// WithOwnerReferences adds the given value to the OwnerReferences field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the OwnerReferences field. +func (b *FlowSchemaApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.OwnerReferences = append(b.OwnerReferences, *values[i]) + } + return b +} + +// WithFinalizers adds the given value to the Finalizers field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Finalizers field. +func (b *FlowSchemaApplyConfiguration) WithFinalizers(values ...string) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.Finalizers = append(b.Finalizers, values[i]) + } + return b +} + +// WithClusterName sets the ClusterName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ClusterName field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithClusterName(value string) *FlowSchemaApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ClusterName = &value + return b +} + +func (b *FlowSchemaApplyConfiguration) ensureObjectMetaApplyConfigurationExists() { + if b.ObjectMetaApplyConfiguration == nil { + b.ObjectMetaApplyConfiguration = &v1.ObjectMetaApplyConfiguration{} + } +} + +// WithSpec sets the Spec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Spec field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithSpec(value *FlowSchemaSpecApplyConfiguration) *FlowSchemaApplyConfiguration { + b.Spec = value + return b +} + +// WithStatus sets the Status field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Status field is set to the value of the last call. +func (b *FlowSchemaApplyConfiguration) WithStatus(value *FlowSchemaStatusApplyConfiguration) *FlowSchemaApplyConfiguration { + b.Status = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschemacondition.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschemacondition.go new file mode 100644 index 0000000000..04dfcbf11a --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschemacondition.go @@ -0,0 +1,80 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +import ( + v1beta2 "k8s.io/api/flowcontrol/v1beta2" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// FlowSchemaConditionApplyConfiguration represents an declarative configuration of the FlowSchemaCondition type for use +// with apply. +type FlowSchemaConditionApplyConfiguration struct { + Type *v1beta2.FlowSchemaConditionType `json:"type,omitempty"` + Status *v1beta2.ConditionStatus `json:"status,omitempty"` + LastTransitionTime *v1.Time `json:"lastTransitionTime,omitempty"` + Reason *string `json:"reason,omitempty"` + Message *string `json:"message,omitempty"` +} + +// FlowSchemaConditionApplyConfiguration constructs an declarative configuration of the FlowSchemaCondition type for use with +// apply. +func FlowSchemaCondition() *FlowSchemaConditionApplyConfiguration { + return &FlowSchemaConditionApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *FlowSchemaConditionApplyConfiguration) WithType(value v1beta2.FlowSchemaConditionType) *FlowSchemaConditionApplyConfiguration { + b.Type = &value + return b +} + +// WithStatus sets the Status field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Status field is set to the value of the last call. +func (b *FlowSchemaConditionApplyConfiguration) WithStatus(value v1beta2.ConditionStatus) *FlowSchemaConditionApplyConfiguration { + b.Status = &value + return b +} + +// WithLastTransitionTime sets the LastTransitionTime field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the LastTransitionTime field is set to the value of the last call. +func (b *FlowSchemaConditionApplyConfiguration) WithLastTransitionTime(value v1.Time) *FlowSchemaConditionApplyConfiguration { + b.LastTransitionTime = &value + return b +} + +// WithReason sets the Reason field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Reason field is set to the value of the last call. +func (b *FlowSchemaConditionApplyConfiguration) WithReason(value string) *FlowSchemaConditionApplyConfiguration { + b.Reason = &value + return b +} + +// WithMessage sets the Message field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Message field is set to the value of the last call. +func (b *FlowSchemaConditionApplyConfiguration) WithMessage(value string) *FlowSchemaConditionApplyConfiguration { + b.Message = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschemaspec.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschemaspec.go new file mode 100644 index 0000000000..a5477e2768 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschemaspec.go @@ -0,0 +1,71 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// FlowSchemaSpecApplyConfiguration represents an declarative configuration of the FlowSchemaSpec type for use +// with apply. +type FlowSchemaSpecApplyConfiguration struct { + PriorityLevelConfiguration *PriorityLevelConfigurationReferenceApplyConfiguration `json:"priorityLevelConfiguration,omitempty"` + MatchingPrecedence *int32 `json:"matchingPrecedence,omitempty"` + DistinguisherMethod *FlowDistinguisherMethodApplyConfiguration `json:"distinguisherMethod,omitempty"` + Rules []PolicyRulesWithSubjectsApplyConfiguration `json:"rules,omitempty"` +} + +// FlowSchemaSpecApplyConfiguration constructs an declarative configuration of the FlowSchemaSpec type for use with +// apply. +func FlowSchemaSpec() *FlowSchemaSpecApplyConfiguration { + return &FlowSchemaSpecApplyConfiguration{} +} + +// WithPriorityLevelConfiguration sets the PriorityLevelConfiguration field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the PriorityLevelConfiguration field is set to the value of the last call. +func (b *FlowSchemaSpecApplyConfiguration) WithPriorityLevelConfiguration(value *PriorityLevelConfigurationReferenceApplyConfiguration) *FlowSchemaSpecApplyConfiguration { + b.PriorityLevelConfiguration = value + return b +} + +// WithMatchingPrecedence sets the MatchingPrecedence field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the MatchingPrecedence field is set to the value of the last call. +func (b *FlowSchemaSpecApplyConfiguration) WithMatchingPrecedence(value int32) *FlowSchemaSpecApplyConfiguration { + b.MatchingPrecedence = &value + return b +} + +// WithDistinguisherMethod sets the DistinguisherMethod field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DistinguisherMethod field is set to the value of the last call. +func (b *FlowSchemaSpecApplyConfiguration) WithDistinguisherMethod(value *FlowDistinguisherMethodApplyConfiguration) *FlowSchemaSpecApplyConfiguration { + b.DistinguisherMethod = value + return b +} + +// WithRules adds the given value to the Rules field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Rules field. +func (b *FlowSchemaSpecApplyConfiguration) WithRules(values ...*PolicyRulesWithSubjectsApplyConfiguration) *FlowSchemaSpecApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithRules") + } + b.Rules = append(b.Rules, *values[i]) + } + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschemastatus.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschemastatus.go new file mode 100644 index 0000000000..67c5be2cbe --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/flowschemastatus.go @@ -0,0 +1,44 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// FlowSchemaStatusApplyConfiguration represents an declarative configuration of the FlowSchemaStatus type for use +// with apply. +type FlowSchemaStatusApplyConfiguration struct { + Conditions []FlowSchemaConditionApplyConfiguration `json:"conditions,omitempty"` +} + +// FlowSchemaStatusApplyConfiguration constructs an declarative configuration of the FlowSchemaStatus type for use with +// apply. +func FlowSchemaStatus() *FlowSchemaStatusApplyConfiguration { + return &FlowSchemaStatusApplyConfiguration{} +} + +// WithConditions adds the given value to the Conditions field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Conditions field. +func (b *FlowSchemaStatusApplyConfiguration) WithConditions(values ...*FlowSchemaConditionApplyConfiguration) *FlowSchemaStatusApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithConditions") + } + b.Conditions = append(b.Conditions, *values[i]) + } + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/groupsubject.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/groupsubject.go new file mode 100644 index 0000000000..b670f2cfd9 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/groupsubject.go @@ -0,0 +1,39 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// GroupSubjectApplyConfiguration represents an declarative configuration of the GroupSubject type for use +// with apply. +type GroupSubjectApplyConfiguration struct { + Name *string `json:"name,omitempty"` +} + +// GroupSubjectApplyConfiguration constructs an declarative configuration of the GroupSubject type for use with +// apply. +func GroupSubject() *GroupSubjectApplyConfiguration { + return &GroupSubjectApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *GroupSubjectApplyConfiguration) WithName(value string) *GroupSubjectApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/limitedprioritylevelconfiguration.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/limitedprioritylevelconfiguration.go new file mode 100644 index 0000000000..e25f7f6b06 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/limitedprioritylevelconfiguration.go @@ -0,0 +1,48 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// LimitedPriorityLevelConfigurationApplyConfiguration represents an declarative configuration of the LimitedPriorityLevelConfiguration type for use +// with apply. +type LimitedPriorityLevelConfigurationApplyConfiguration struct { + AssuredConcurrencyShares *int32 `json:"assuredConcurrencyShares,omitempty"` + LimitResponse *LimitResponseApplyConfiguration `json:"limitResponse,omitempty"` +} + +// LimitedPriorityLevelConfigurationApplyConfiguration constructs an declarative configuration of the LimitedPriorityLevelConfiguration type for use with +// apply. +func LimitedPriorityLevelConfiguration() *LimitedPriorityLevelConfigurationApplyConfiguration { + return &LimitedPriorityLevelConfigurationApplyConfiguration{} +} + +// WithAssuredConcurrencyShares sets the AssuredConcurrencyShares field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the AssuredConcurrencyShares field is set to the value of the last call. +func (b *LimitedPriorityLevelConfigurationApplyConfiguration) WithAssuredConcurrencyShares(value int32) *LimitedPriorityLevelConfigurationApplyConfiguration { + b.AssuredConcurrencyShares = &value + return b +} + +// WithLimitResponse sets the LimitResponse field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the LimitResponse field is set to the value of the last call. +func (b *LimitedPriorityLevelConfigurationApplyConfiguration) WithLimitResponse(value *LimitResponseApplyConfiguration) *LimitedPriorityLevelConfigurationApplyConfiguration { + b.LimitResponse = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/limitresponse.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/limitresponse.go new file mode 100644 index 0000000000..a9b7661fb2 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/limitresponse.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +import ( + v1beta2 "k8s.io/api/flowcontrol/v1beta2" +) + +// LimitResponseApplyConfiguration represents an declarative configuration of the LimitResponse type for use +// with apply. +type LimitResponseApplyConfiguration struct { + Type *v1beta2.LimitResponseType `json:"type,omitempty"` + Queuing *QueuingConfigurationApplyConfiguration `json:"queuing,omitempty"` +} + +// LimitResponseApplyConfiguration constructs an declarative configuration of the LimitResponse type for use with +// apply. +func LimitResponse() *LimitResponseApplyConfiguration { + return &LimitResponseApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *LimitResponseApplyConfiguration) WithType(value v1beta2.LimitResponseType) *LimitResponseApplyConfiguration { + b.Type = &value + return b +} + +// WithQueuing sets the Queuing field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Queuing field is set to the value of the last call. +func (b *LimitResponseApplyConfiguration) WithQueuing(value *QueuingConfigurationApplyConfiguration) *LimitResponseApplyConfiguration { + b.Queuing = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/nonresourcepolicyrule.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/nonresourcepolicyrule.go new file mode 100644 index 0000000000..cb8ba0afd6 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/nonresourcepolicyrule.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// NonResourcePolicyRuleApplyConfiguration represents an declarative configuration of the NonResourcePolicyRule type for use +// with apply. +type NonResourcePolicyRuleApplyConfiguration struct { + Verbs []string `json:"verbs,omitempty"` + NonResourceURLs []string `json:"nonResourceURLs,omitempty"` +} + +// NonResourcePolicyRuleApplyConfiguration constructs an declarative configuration of the NonResourcePolicyRule type for use with +// apply. +func NonResourcePolicyRule() *NonResourcePolicyRuleApplyConfiguration { + return &NonResourcePolicyRuleApplyConfiguration{} +} + +// WithVerbs adds the given value to the Verbs field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Verbs field. +func (b *NonResourcePolicyRuleApplyConfiguration) WithVerbs(values ...string) *NonResourcePolicyRuleApplyConfiguration { + for i := range values { + b.Verbs = append(b.Verbs, values[i]) + } + return b +} + +// WithNonResourceURLs adds the given value to the NonResourceURLs field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the NonResourceURLs field. +func (b *NonResourcePolicyRuleApplyConfiguration) WithNonResourceURLs(values ...string) *NonResourcePolicyRuleApplyConfiguration { + for i := range values { + b.NonResourceURLs = append(b.NonResourceURLs, values[i]) + } + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/policyruleswithsubjects.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/policyruleswithsubjects.go new file mode 100644 index 0000000000..179c3979db --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/policyruleswithsubjects.go @@ -0,0 +1,72 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// PolicyRulesWithSubjectsApplyConfiguration represents an declarative configuration of the PolicyRulesWithSubjects type for use +// with apply. +type PolicyRulesWithSubjectsApplyConfiguration struct { + Subjects []SubjectApplyConfiguration `json:"subjects,omitempty"` + ResourceRules []ResourcePolicyRuleApplyConfiguration `json:"resourceRules,omitempty"` + NonResourceRules []NonResourcePolicyRuleApplyConfiguration `json:"nonResourceRules,omitempty"` +} + +// PolicyRulesWithSubjectsApplyConfiguration constructs an declarative configuration of the PolicyRulesWithSubjects type for use with +// apply. +func PolicyRulesWithSubjects() *PolicyRulesWithSubjectsApplyConfiguration { + return &PolicyRulesWithSubjectsApplyConfiguration{} +} + +// WithSubjects adds the given value to the Subjects field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Subjects field. +func (b *PolicyRulesWithSubjectsApplyConfiguration) WithSubjects(values ...*SubjectApplyConfiguration) *PolicyRulesWithSubjectsApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithSubjects") + } + b.Subjects = append(b.Subjects, *values[i]) + } + return b +} + +// WithResourceRules adds the given value to the ResourceRules field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the ResourceRules field. +func (b *PolicyRulesWithSubjectsApplyConfiguration) WithResourceRules(values ...*ResourcePolicyRuleApplyConfiguration) *PolicyRulesWithSubjectsApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithResourceRules") + } + b.ResourceRules = append(b.ResourceRules, *values[i]) + } + return b +} + +// WithNonResourceRules adds the given value to the NonResourceRules field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the NonResourceRules field. +func (b *PolicyRulesWithSubjectsApplyConfiguration) WithNonResourceRules(values ...*NonResourcePolicyRuleApplyConfiguration) *PolicyRulesWithSubjectsApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithNonResourceRules") + } + b.NonResourceRules = append(b.NonResourceRules, *values[i]) + } + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfiguration.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfiguration.go new file mode 100644 index 0000000000..4ac11bba65 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfiguration.go @@ -0,0 +1,274 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +import ( + flowcontrolv1beta2 "k8s.io/api/flowcontrol/v1beta2" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + managedfields "k8s.io/apimachinery/pkg/util/managedfields" + internal "k8s.io/client-go/applyconfigurations/internal" + v1 "k8s.io/client-go/applyconfigurations/meta/v1" +) + +// PriorityLevelConfigurationApplyConfiguration represents an declarative configuration of the PriorityLevelConfiguration type for use +// with apply. +type PriorityLevelConfigurationApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *PriorityLevelConfigurationSpecApplyConfiguration `json:"spec,omitempty"` + Status *PriorityLevelConfigurationStatusApplyConfiguration `json:"status,omitempty"` +} + +// PriorityLevelConfiguration constructs an declarative configuration of the PriorityLevelConfiguration type for use with +// apply. +func PriorityLevelConfiguration(name string) *PriorityLevelConfigurationApplyConfiguration { + b := &PriorityLevelConfigurationApplyConfiguration{} + b.WithName(name) + b.WithKind("PriorityLevelConfiguration") + b.WithAPIVersion("flowcontrol.apiserver.k8s.io/v1beta2") + return b +} + +// ExtractPriorityLevelConfiguration extracts the applied configuration owned by fieldManager from +// priorityLevelConfiguration. If no managedFields are found in priorityLevelConfiguration for fieldManager, a +// PriorityLevelConfigurationApplyConfiguration is returned with only the Name, Namespace (if applicable), +// APIVersion and Kind populated. It is possible that no managed fields were found for because other +// field managers have taken ownership of all the fields previously owned by fieldManager, or because +// the fieldManager never owned fields any fields. +// priorityLevelConfiguration must be a unmodified PriorityLevelConfiguration API object that was retrieved from the Kubernetes API. +// ExtractPriorityLevelConfiguration provides a way to perform a extract/modify-in-place/apply workflow. +// Note that an extracted apply configuration will contain fewer fields than what the fieldManager previously +// applied if another fieldManager has updated or force applied any of the previously applied fields. +// Experimental! +func ExtractPriorityLevelConfiguration(priorityLevelConfiguration *flowcontrolv1beta2.PriorityLevelConfiguration, fieldManager string) (*PriorityLevelConfigurationApplyConfiguration, error) { + return extractPriorityLevelConfiguration(priorityLevelConfiguration, fieldManager, "") +} + +// ExtractPriorityLevelConfigurationStatus is the same as ExtractPriorityLevelConfiguration except +// that it extracts the status subresource applied configuration. +// Experimental! +func ExtractPriorityLevelConfigurationStatus(priorityLevelConfiguration *flowcontrolv1beta2.PriorityLevelConfiguration, fieldManager string) (*PriorityLevelConfigurationApplyConfiguration, error) { + return extractPriorityLevelConfiguration(priorityLevelConfiguration, fieldManager, "status") +} + +func extractPriorityLevelConfiguration(priorityLevelConfiguration *flowcontrolv1beta2.PriorityLevelConfiguration, fieldManager string, subresource string) (*PriorityLevelConfigurationApplyConfiguration, error) { + b := &PriorityLevelConfigurationApplyConfiguration{} + err := managedfields.ExtractInto(priorityLevelConfiguration, internal.Parser().Type("io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfiguration"), fieldManager, b, subresource) + if err != nil { + return nil, err + } + b.WithName(priorityLevelConfiguration.Name) + + b.WithKind("PriorityLevelConfiguration") + b.WithAPIVersion("flowcontrol.apiserver.k8s.io/v1beta2") + return b, nil +} + +// WithKind sets the Kind field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Kind field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithKind(value string) *PriorityLevelConfigurationApplyConfiguration { + b.Kind = &value + return b +} + +// WithAPIVersion sets the APIVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the APIVersion field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithAPIVersion(value string) *PriorityLevelConfigurationApplyConfiguration { + b.APIVersion = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithName(value string) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Name = &value + return b +} + +// WithGenerateName sets the GenerateName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the GenerateName field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithGenerateName(value string) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.GenerateName = &value + return b +} + +// WithNamespace sets the Namespace field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Namespace field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithNamespace(value string) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Namespace = &value + return b +} + +// WithSelfLink sets the SelfLink field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the SelfLink field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithSelfLink(value string) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.SelfLink = &value + return b +} + +// WithUID sets the UID field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the UID field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithUID(value types.UID) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.UID = &value + return b +} + +// WithResourceVersion sets the ResourceVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ResourceVersion field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithResourceVersion(value string) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ResourceVersion = &value + return b +} + +// WithGeneration sets the Generation field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Generation field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithGeneration(value int64) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Generation = &value + return b +} + +// WithCreationTimestamp sets the CreationTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CreationTimestamp field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithCreationTimestamp(value metav1.Time) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.CreationTimestamp = &value + return b +} + +// WithDeletionTimestamp sets the DeletionTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionTimestamp field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionTimestamp = &value + return b +} + +// WithDeletionGracePeriodSeconds sets the DeletionGracePeriodSeconds field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionGracePeriodSeconds field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionGracePeriodSeconds = &value + return b +} + +// WithLabels puts the entries into the Labels field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Labels field, +// overwriting an existing map entries in Labels field with the same key. +func (b *PriorityLevelConfigurationApplyConfiguration) WithLabels(entries map[string]string) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Labels == nil && len(entries) > 0 { + b.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Labels[k] = v + } + return b +} + +// WithAnnotations puts the entries into the Annotations field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Annotations field, +// overwriting an existing map entries in Annotations field with the same key. +func (b *PriorityLevelConfigurationApplyConfiguration) WithAnnotations(entries map[string]string) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Annotations == nil && len(entries) > 0 { + b.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Annotations[k] = v + } + return b +} + +// WithOwnerReferences adds the given value to the OwnerReferences field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the OwnerReferences field. +func (b *PriorityLevelConfigurationApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.OwnerReferences = append(b.OwnerReferences, *values[i]) + } + return b +} + +// WithFinalizers adds the given value to the Finalizers field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Finalizers field. +func (b *PriorityLevelConfigurationApplyConfiguration) WithFinalizers(values ...string) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.Finalizers = append(b.Finalizers, values[i]) + } + return b +} + +// WithClusterName sets the ClusterName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ClusterName field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithClusterName(value string) *PriorityLevelConfigurationApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ClusterName = &value + return b +} + +func (b *PriorityLevelConfigurationApplyConfiguration) ensureObjectMetaApplyConfigurationExists() { + if b.ObjectMetaApplyConfiguration == nil { + b.ObjectMetaApplyConfiguration = &v1.ObjectMetaApplyConfiguration{} + } +} + +// WithSpec sets the Spec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Spec field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithSpec(value *PriorityLevelConfigurationSpecApplyConfiguration) *PriorityLevelConfigurationApplyConfiguration { + b.Spec = value + return b +} + +// WithStatus sets the Status field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Status field is set to the value of the last call. +func (b *PriorityLevelConfigurationApplyConfiguration) WithStatus(value *PriorityLevelConfigurationStatusApplyConfiguration) *PriorityLevelConfigurationApplyConfiguration { + b.Status = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationcondition.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationcondition.go new file mode 100644 index 0000000000..f742adeff0 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationcondition.go @@ -0,0 +1,80 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +import ( + v1beta2 "k8s.io/api/flowcontrol/v1beta2" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// PriorityLevelConfigurationConditionApplyConfiguration represents an declarative configuration of the PriorityLevelConfigurationCondition type for use +// with apply. +type PriorityLevelConfigurationConditionApplyConfiguration struct { + Type *v1beta2.PriorityLevelConfigurationConditionType `json:"type,omitempty"` + Status *v1beta2.ConditionStatus `json:"status,omitempty"` + LastTransitionTime *v1.Time `json:"lastTransitionTime,omitempty"` + Reason *string `json:"reason,omitempty"` + Message *string `json:"message,omitempty"` +} + +// PriorityLevelConfigurationConditionApplyConfiguration constructs an declarative configuration of the PriorityLevelConfigurationCondition type for use with +// apply. +func PriorityLevelConfigurationCondition() *PriorityLevelConfigurationConditionApplyConfiguration { + return &PriorityLevelConfigurationConditionApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *PriorityLevelConfigurationConditionApplyConfiguration) WithType(value v1beta2.PriorityLevelConfigurationConditionType) *PriorityLevelConfigurationConditionApplyConfiguration { + b.Type = &value + return b +} + +// WithStatus sets the Status field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Status field is set to the value of the last call. +func (b *PriorityLevelConfigurationConditionApplyConfiguration) WithStatus(value v1beta2.ConditionStatus) *PriorityLevelConfigurationConditionApplyConfiguration { + b.Status = &value + return b +} + +// WithLastTransitionTime sets the LastTransitionTime field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the LastTransitionTime field is set to the value of the last call. +func (b *PriorityLevelConfigurationConditionApplyConfiguration) WithLastTransitionTime(value v1.Time) *PriorityLevelConfigurationConditionApplyConfiguration { + b.LastTransitionTime = &value + return b +} + +// WithReason sets the Reason field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Reason field is set to the value of the last call. +func (b *PriorityLevelConfigurationConditionApplyConfiguration) WithReason(value string) *PriorityLevelConfigurationConditionApplyConfiguration { + b.Reason = &value + return b +} + +// WithMessage sets the Message field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Message field is set to the value of the last call. +func (b *PriorityLevelConfigurationConditionApplyConfiguration) WithMessage(value string) *PriorityLevelConfigurationConditionApplyConfiguration { + b.Message = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationreference.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationreference.go new file mode 100644 index 0000000000..581b451ffd --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationreference.go @@ -0,0 +1,39 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// PriorityLevelConfigurationReferenceApplyConfiguration represents an declarative configuration of the PriorityLevelConfigurationReference type for use +// with apply. +type PriorityLevelConfigurationReferenceApplyConfiguration struct { + Name *string `json:"name,omitempty"` +} + +// PriorityLevelConfigurationReferenceApplyConfiguration constructs an declarative configuration of the PriorityLevelConfigurationReference type for use with +// apply. +func PriorityLevelConfigurationReference() *PriorityLevelConfigurationReferenceApplyConfiguration { + return &PriorityLevelConfigurationReferenceApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *PriorityLevelConfigurationReferenceApplyConfiguration) WithName(value string) *PriorityLevelConfigurationReferenceApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationspec.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationspec.go new file mode 100644 index 0000000000..5560ed9e56 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationspec.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +import ( + v1beta2 "k8s.io/api/flowcontrol/v1beta2" +) + +// PriorityLevelConfigurationSpecApplyConfiguration represents an declarative configuration of the PriorityLevelConfigurationSpec type for use +// with apply. +type PriorityLevelConfigurationSpecApplyConfiguration struct { + Type *v1beta2.PriorityLevelEnablement `json:"type,omitempty"` + Limited *LimitedPriorityLevelConfigurationApplyConfiguration `json:"limited,omitempty"` +} + +// PriorityLevelConfigurationSpecApplyConfiguration constructs an declarative configuration of the PriorityLevelConfigurationSpec type for use with +// apply. +func PriorityLevelConfigurationSpec() *PriorityLevelConfigurationSpecApplyConfiguration { + return &PriorityLevelConfigurationSpecApplyConfiguration{} +} + +// WithType sets the Type field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Type field is set to the value of the last call. +func (b *PriorityLevelConfigurationSpecApplyConfiguration) WithType(value v1beta2.PriorityLevelEnablement) *PriorityLevelConfigurationSpecApplyConfiguration { + b.Type = &value + return b +} + +// WithLimited sets the Limited field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Limited field is set to the value of the last call. +func (b *PriorityLevelConfigurationSpecApplyConfiguration) WithLimited(value *LimitedPriorityLevelConfigurationApplyConfiguration) *PriorityLevelConfigurationSpecApplyConfiguration { + b.Limited = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationstatus.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationstatus.go new file mode 100644 index 0000000000..b55e32be00 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/prioritylevelconfigurationstatus.go @@ -0,0 +1,44 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// PriorityLevelConfigurationStatusApplyConfiguration represents an declarative configuration of the PriorityLevelConfigurationStatus type for use +// with apply. +type PriorityLevelConfigurationStatusApplyConfiguration struct { + Conditions []PriorityLevelConfigurationConditionApplyConfiguration `json:"conditions,omitempty"` +} + +// PriorityLevelConfigurationStatusApplyConfiguration constructs an declarative configuration of the PriorityLevelConfigurationStatus type for use with +// apply. +func PriorityLevelConfigurationStatus() *PriorityLevelConfigurationStatusApplyConfiguration { + return &PriorityLevelConfigurationStatusApplyConfiguration{} +} + +// WithConditions adds the given value to the Conditions field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Conditions field. +func (b *PriorityLevelConfigurationStatusApplyConfiguration) WithConditions(values ...*PriorityLevelConfigurationConditionApplyConfiguration) *PriorityLevelConfigurationStatusApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithConditions") + } + b.Conditions = append(b.Conditions, *values[i]) + } + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/queuingconfiguration.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/queuingconfiguration.go new file mode 100644 index 0000000000..06246fb27e --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/queuingconfiguration.go @@ -0,0 +1,57 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// QueuingConfigurationApplyConfiguration represents an declarative configuration of the QueuingConfiguration type for use +// with apply. +type QueuingConfigurationApplyConfiguration struct { + Queues *int32 `json:"queues,omitempty"` + HandSize *int32 `json:"handSize,omitempty"` + QueueLengthLimit *int32 `json:"queueLengthLimit,omitempty"` +} + +// QueuingConfigurationApplyConfiguration constructs an declarative configuration of the QueuingConfiguration type for use with +// apply. +func QueuingConfiguration() *QueuingConfigurationApplyConfiguration { + return &QueuingConfigurationApplyConfiguration{} +} + +// WithQueues sets the Queues field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Queues field is set to the value of the last call. +func (b *QueuingConfigurationApplyConfiguration) WithQueues(value int32) *QueuingConfigurationApplyConfiguration { + b.Queues = &value + return b +} + +// WithHandSize sets the HandSize field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the HandSize field is set to the value of the last call. +func (b *QueuingConfigurationApplyConfiguration) WithHandSize(value int32) *QueuingConfigurationApplyConfiguration { + b.HandSize = &value + return b +} + +// WithQueueLengthLimit sets the QueueLengthLimit field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the QueueLengthLimit field is set to the value of the last call. +func (b *QueuingConfigurationApplyConfiguration) WithQueueLengthLimit(value int32) *QueuingConfigurationApplyConfiguration { + b.QueueLengthLimit = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/resourcepolicyrule.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/resourcepolicyrule.go new file mode 100644 index 0000000000..b67ea1c7f9 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/resourcepolicyrule.go @@ -0,0 +1,83 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// ResourcePolicyRuleApplyConfiguration represents an declarative configuration of the ResourcePolicyRule type for use +// with apply. +type ResourcePolicyRuleApplyConfiguration struct { + Verbs []string `json:"verbs,omitempty"` + APIGroups []string `json:"apiGroups,omitempty"` + Resources []string `json:"resources,omitempty"` + ClusterScope *bool `json:"clusterScope,omitempty"` + Namespaces []string `json:"namespaces,omitempty"` +} + +// ResourcePolicyRuleApplyConfiguration constructs an declarative configuration of the ResourcePolicyRule type for use with +// apply. +func ResourcePolicyRule() *ResourcePolicyRuleApplyConfiguration { + return &ResourcePolicyRuleApplyConfiguration{} +} + +// WithVerbs adds the given value to the Verbs field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Verbs field. +func (b *ResourcePolicyRuleApplyConfiguration) WithVerbs(values ...string) *ResourcePolicyRuleApplyConfiguration { + for i := range values { + b.Verbs = append(b.Verbs, values[i]) + } + return b +} + +// WithAPIGroups adds the given value to the APIGroups field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the APIGroups field. +func (b *ResourcePolicyRuleApplyConfiguration) WithAPIGroups(values ...string) *ResourcePolicyRuleApplyConfiguration { + for i := range values { + b.APIGroups = append(b.APIGroups, values[i]) + } + return b +} + +// WithResources adds the given value to the Resources field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Resources field. +func (b *ResourcePolicyRuleApplyConfiguration) WithResources(values ...string) *ResourcePolicyRuleApplyConfiguration { + for i := range values { + b.Resources = append(b.Resources, values[i]) + } + return b +} + +// WithClusterScope sets the ClusterScope field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ClusterScope field is set to the value of the last call. +func (b *ResourcePolicyRuleApplyConfiguration) WithClusterScope(value bool) *ResourcePolicyRuleApplyConfiguration { + b.ClusterScope = &value + return b +} + +// WithNamespaces adds the given value to the Namespaces field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Namespaces field. +func (b *ResourcePolicyRuleApplyConfiguration) WithNamespaces(values ...string) *ResourcePolicyRuleApplyConfiguration { + for i := range values { + b.Namespaces = append(b.Namespaces, values[i]) + } + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/serviceaccountsubject.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/serviceaccountsubject.go new file mode 100644 index 0000000000..b6cfdcad3b --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/serviceaccountsubject.go @@ -0,0 +1,48 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// ServiceAccountSubjectApplyConfiguration represents an declarative configuration of the ServiceAccountSubject type for use +// with apply. +type ServiceAccountSubjectApplyConfiguration struct { + Namespace *string `json:"namespace,omitempty"` + Name *string `json:"name,omitempty"` +} + +// ServiceAccountSubjectApplyConfiguration constructs an declarative configuration of the ServiceAccountSubject type for use with +// apply. +func ServiceAccountSubject() *ServiceAccountSubjectApplyConfiguration { + return &ServiceAccountSubjectApplyConfiguration{} +} + +// WithNamespace sets the Namespace field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Namespace field is set to the value of the last call. +func (b *ServiceAccountSubjectApplyConfiguration) WithNamespace(value string) *ServiceAccountSubjectApplyConfiguration { + b.Namespace = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *ServiceAccountSubjectApplyConfiguration) WithName(value string) *ServiceAccountSubjectApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/subject.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/subject.go new file mode 100644 index 0000000000..7030785b8c --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/subject.go @@ -0,0 +1,70 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +import ( + v1beta2 "k8s.io/api/flowcontrol/v1beta2" +) + +// SubjectApplyConfiguration represents an declarative configuration of the Subject type for use +// with apply. +type SubjectApplyConfiguration struct { + Kind *v1beta2.SubjectKind `json:"kind,omitempty"` + User *UserSubjectApplyConfiguration `json:"user,omitempty"` + Group *GroupSubjectApplyConfiguration `json:"group,omitempty"` + ServiceAccount *ServiceAccountSubjectApplyConfiguration `json:"serviceAccount,omitempty"` +} + +// SubjectApplyConfiguration constructs an declarative configuration of the Subject type for use with +// apply. +func Subject() *SubjectApplyConfiguration { + return &SubjectApplyConfiguration{} +} + +// WithKind sets the Kind field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Kind field is set to the value of the last call. +func (b *SubjectApplyConfiguration) WithKind(value v1beta2.SubjectKind) *SubjectApplyConfiguration { + b.Kind = &value + return b +} + +// WithUser sets the User field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the User field is set to the value of the last call. +func (b *SubjectApplyConfiguration) WithUser(value *UserSubjectApplyConfiguration) *SubjectApplyConfiguration { + b.User = value + return b +} + +// WithGroup sets the Group field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Group field is set to the value of the last call. +func (b *SubjectApplyConfiguration) WithGroup(value *GroupSubjectApplyConfiguration) *SubjectApplyConfiguration { + b.Group = value + return b +} + +// WithServiceAccount sets the ServiceAccount field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ServiceAccount field is set to the value of the last call. +func (b *SubjectApplyConfiguration) WithServiceAccount(value *ServiceAccountSubjectApplyConfiguration) *SubjectApplyConfiguration { + b.ServiceAccount = value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/usersubject.go b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/usersubject.go new file mode 100644 index 0000000000..8c77b3e8a2 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2/usersubject.go @@ -0,0 +1,39 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1beta2 + +// UserSubjectApplyConfiguration represents an declarative configuration of the UserSubject type for use +// with apply. +type UserSubjectApplyConfiguration struct { + Name *string `json:"name,omitempty"` +} + +// UserSubjectApplyConfiguration constructs an declarative configuration of the UserSubject type for use with +// apply. +func UserSubject() *UserSubjectApplyConfiguration { + return &UserSubjectApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *UserSubjectApplyConfiguration) WithName(value string) *UserSubjectApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/k8s.io/client-go/applyconfigurations/internal/internal.go b/vendor/k8s.io/client-go/applyconfigurations/internal/internal.go index 5960666fdb..824c5e9582 100644 --- a/vendor/k8s.io/client-go/applyconfigurations/internal/internal.go +++ b/vendor/k8s.io/client-go/applyconfigurations/internal/internal.go @@ -482,8 +482,8 @@ var schemaYAML = typed.YAMLObject(`types: elementRelationship: atomic map: elementType: - namedType: __untyped_atomic_ - elementRelationship: atomic + namedType: __untyped_deduced_ + elementRelationship: separable - name: io.k8s.api.apiserverinternal.v1alpha1.StorageVersionStatus map: fields: @@ -907,12 +907,24 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" +- name: io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy + map: + fields: + - name: whenDeleted + type: + scalar: string + - name: whenScaled + type: + scalar: string - name: io.k8s.api.apps.v1.StatefulSetSpec map: fields: - name: minReadySeconds type: scalar: numeric + - name: persistentVolumeClaimRetentionPolicy + type: + namedType: io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy - name: podManagementPolicy type: scalar: string @@ -949,6 +961,7 @@ var schemaYAML = typed.YAMLObject(`types: - name: availableReplicas type: scalar: numeric + default: 0 - name: collisionCount type: scalar: numeric @@ -1194,12 +1207,24 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" +- name: io.k8s.api.apps.v1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy + map: + fields: + - name: whenDeleted + type: + scalar: string + - name: whenScaled + type: + scalar: string - name: io.k8s.api.apps.v1beta1.StatefulSetSpec map: fields: - name: minReadySeconds type: scalar: numeric + - name: persistentVolumeClaimRetentionPolicy + type: + namedType: io.k8s.api.apps.v1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy - name: podManagementPolicy type: scalar: string @@ -1236,6 +1261,7 @@ var schemaYAML = typed.YAMLObject(`types: - name: availableReplicas type: scalar: numeric + default: 0 - name: collisionCount type: scalar: numeric @@ -1679,12 +1705,24 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" +- name: io.k8s.api.apps.v1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy + map: + fields: + - name: whenDeleted + type: + scalar: string + - name: whenScaled + type: + scalar: string - name: io.k8s.api.apps.v1beta2.StatefulSetSpec map: fields: - name: minReadySeconds type: scalar: numeric + - name: persistentVolumeClaimRetentionPolicy + type: + namedType: io.k8s.api.apps.v1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy - name: podManagementPolicy type: scalar: string @@ -1721,6 +1759,7 @@ var schemaYAML = typed.YAMLObject(`types: - name: availableReplicas type: scalar: numeric + default: 0 - name: collisionCount type: scalar: numeric @@ -1836,7 +1875,7 @@ var schemaYAML = typed.YAMLObject(`types: - name: observedGeneration type: scalar: numeric -- name: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricSource +- name: io.k8s.api.autoscaling.v2.ContainerResourceMetricSource map: fields: - name: container @@ -1847,31 +1886,26 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" - - name: targetAverageUtilization - type: - scalar: numeric - - name: targetAverageValue + - name: target type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity -- name: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricStatus + namedType: io.k8s.api.autoscaling.v2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus map: fields: - name: container type: scalar: string default: "" - - name: currentAverageUtilization - type: - scalar: numeric - - name: currentAverageValue + - name: current type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus default: {} - name: name type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference +- name: io.k8s.api.autoscaling.v2.CrossVersionObjectReference map: fields: - name: apiVersion @@ -1885,40 +1919,59 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta1.ExternalMetricSource +- name: io.k8s.api.autoscaling.v2.ExternalMetricSource map: fields: - - name: metricName - type: - scalar: string - default: "" - - name: metricSelector - type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector - - name: targetAverageValue + - name: metric type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - - name: targetValue + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier + default: {} + - name: target type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity -- name: io.k8s.api.autoscaling.v2beta1.ExternalMetricStatus + namedType: io.k8s.api.autoscaling.v2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2.ExternalMetricStatus map: fields: - - name: currentAverageValue + - name: current type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - - name: currentValue + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus + default: {} + - name: metric type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier default: {} - - name: metricName +- name: io.k8s.api.autoscaling.v2.HPAScalingPolicy + map: + fields: + - name: periodSeconds + type: + scalar: numeric + default: 0 + - name: type type: scalar: string default: "" - - name: metricSelector + - name: value type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector -- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler + scalar: numeric + default: 0 +- name: io.k8s.api.autoscaling.v2.HPAScalingRules + map: + fields: + - name: policies + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2.HPAScalingPolicy + elementRelationship: atomic + - name: selectPolicy + type: + scalar: string + - name: stabilizationWindowSeconds + type: + scalar: numeric +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler map: fields: - name: apiVersion @@ -1933,13 +1986,22 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerSpec + namedType: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec default: {} - name: status type: - namedType: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerStatus + namedType: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus default: {} -- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerCondition +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior + map: + fields: + - name: scaleDown + type: + namedType: io.k8s.api.autoscaling.v2.HPAScalingRules + - name: scaleUp + type: + namedType: io.k8s.api.autoscaling.v2.HPAScalingRules +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition map: fields: - name: lastTransitionTime @@ -1960,9 +2022,12 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerSpec +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec map: fields: + - name: behavior + type: + namedType: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior - name: maxReplicas type: scalar: numeric @@ -1971,34 +2036,35 @@ var schemaYAML = typed.YAMLObject(`types: type: list: elementType: - namedType: io.k8s.api.autoscaling.v2beta1.MetricSpec + namedType: io.k8s.api.autoscaling.v2.MetricSpec elementRelationship: atomic - name: minReplicas type: scalar: numeric - name: scaleTargetRef type: - namedType: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference + namedType: io.k8s.api.autoscaling.v2.CrossVersionObjectReference default: {} -- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerStatus +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus map: fields: - name: conditions type: list: elementType: - namedType: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerCondition - elementRelationship: atomic + namedType: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition + elementRelationship: associative + keys: + - type - name: currentMetrics type: list: elementType: - namedType: io.k8s.api.autoscaling.v2beta1.MetricStatus + namedType: io.k8s.api.autoscaling.v2.MetricStatus elementRelationship: atomic - name: currentReplicas type: scalar: numeric - default: 0 - name: desiredReplicas type: scalar: numeric @@ -2009,148 +2075,163 @@ var schemaYAML = typed.YAMLObject(`types: - name: observedGeneration type: scalar: numeric -- name: io.k8s.api.autoscaling.v2beta1.MetricSpec +- name: io.k8s.api.autoscaling.v2.MetricIdentifier + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.autoscaling.v2.MetricSpec map: fields: - name: containerResource type: - namedType: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricSource + namedType: io.k8s.api.autoscaling.v2.ContainerResourceMetricSource - name: external type: - namedType: io.k8s.api.autoscaling.v2beta1.ExternalMetricSource + namedType: io.k8s.api.autoscaling.v2.ExternalMetricSource - name: object type: - namedType: io.k8s.api.autoscaling.v2beta1.ObjectMetricSource + namedType: io.k8s.api.autoscaling.v2.ObjectMetricSource - name: pods type: - namedType: io.k8s.api.autoscaling.v2beta1.PodsMetricSource + namedType: io.k8s.api.autoscaling.v2.PodsMetricSource - name: resource type: - namedType: io.k8s.api.autoscaling.v2beta1.ResourceMetricSource + namedType: io.k8s.api.autoscaling.v2.ResourceMetricSource - name: type type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta1.MetricStatus +- name: io.k8s.api.autoscaling.v2.MetricStatus map: fields: - name: containerResource type: - namedType: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricStatus + namedType: io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus - name: external type: - namedType: io.k8s.api.autoscaling.v2beta1.ExternalMetricStatus + namedType: io.k8s.api.autoscaling.v2.ExternalMetricStatus - name: object type: - namedType: io.k8s.api.autoscaling.v2beta1.ObjectMetricStatus + namedType: io.k8s.api.autoscaling.v2.ObjectMetricStatus - name: pods type: - namedType: io.k8s.api.autoscaling.v2beta1.PodsMetricStatus + namedType: io.k8s.api.autoscaling.v2.PodsMetricStatus - name: resource type: - namedType: io.k8s.api.autoscaling.v2beta1.ResourceMetricStatus + namedType: io.k8s.api.autoscaling.v2.ResourceMetricStatus - name: type type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta1.ObjectMetricSource +- name: io.k8s.api.autoscaling.v2.MetricTarget map: fields: + - name: averageUtilization + type: + scalar: numeric - name: averageValue type: namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - - name: metricName + - name: type type: scalar: string default: "" - - name: selector - type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector - - name: target - type: - namedType: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference - default: {} - - name: targetValue + - name: value type: namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - default: {} -- name: io.k8s.api.autoscaling.v2beta1.ObjectMetricStatus +- name: io.k8s.api.autoscaling.v2.MetricValueStatus map: fields: + - name: averageUtilization + type: + scalar: numeric - name: averageValue type: namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - - name: currentValue + - name: value type: namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - default: {} - - name: metricName +- name: io.k8s.api.autoscaling.v2.ObjectMetricSource + map: + fields: + - name: describedObject type: - scalar: string - default: "" - - name: selector + namedType: io.k8s.api.autoscaling.v2.CrossVersionObjectReference + default: {} + - name: metric type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier + default: {} - name: target type: - namedType: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference + namedType: io.k8s.api.autoscaling.v2.MetricTarget default: {} -- name: io.k8s.api.autoscaling.v2beta1.PodsMetricSource +- name: io.k8s.api.autoscaling.v2.ObjectMetricStatus map: fields: - - name: metricName + - name: current type: - scalar: string - default: "" - - name: selector + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus + default: {} + - name: describedObject type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector - - name: targetAverageValue + namedType: io.k8s.api.autoscaling.v2.CrossVersionObjectReference + default: {} + - name: metric type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier default: {} -- name: io.k8s.api.autoscaling.v2beta1.PodsMetricStatus +- name: io.k8s.api.autoscaling.v2.PodsMetricSource map: fields: - - name: currentAverageValue + - name: metric type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier default: {} - - name: metricName + - name: target type: - scalar: string - default: "" - - name: selector + namedType: io.k8s.api.autoscaling.v2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2.PodsMetricStatus + map: + fields: + - name: current type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector -- name: io.k8s.api.autoscaling.v2beta1.ResourceMetricSource + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus + default: {} + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier + default: {} +- name: io.k8s.api.autoscaling.v2.ResourceMetricSource map: fields: - name: name type: scalar: string default: "" - - name: targetAverageUtilization - type: - scalar: numeric - - name: targetAverageValue + - name: target type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity -- name: io.k8s.api.autoscaling.v2beta1.ResourceMetricStatus + namedType: io.k8s.api.autoscaling.v2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2.ResourceMetricStatus map: fields: - - name: currentAverageUtilization - type: - scalar: numeric - - name: currentAverageValue + - name: current type: - namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus default: {} - name: name type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricSource +- name: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricSource map: fields: - name: container @@ -2161,26 +2242,31 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" - - name: target + - name: targetAverageUtilization type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget - default: {} -- name: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricStatus + scalar: numeric + - name: targetAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricStatus map: fields: - name: container type: scalar: string default: "" - - name: current + - name: currentAverageUtilization type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + scalar: numeric + - name: currentAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity default: {} - name: name type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference +- name: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference map: fields: - name: apiVersion @@ -2194,59 +2280,40 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta2.ExternalMetricSource +- name: io.k8s.api.autoscaling.v2beta1.ExternalMetricSource map: fields: - - name: metric + - name: metricName type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier - default: {} - - name: target + scalar: string + default: "" + - name: metricSelector type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget - default: {} -- name: io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus - map: - fields: - - name: current + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: targetAverageValue type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus - default: {} - - name: metric + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: targetValue type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier - default: {} -- name: io.k8s.api.autoscaling.v2beta2.HPAScalingPolicy + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta1.ExternalMetricStatus map: fields: - - name: periodSeconds - type: - scalar: numeric - default: 0 - - name: type - type: - scalar: string - default: "" - - name: value + - name: currentAverageValue type: - scalar: numeric - default: 0 -- name: io.k8s.api.autoscaling.v2beta2.HPAScalingRules - map: - fields: - - name: policies + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: currentValue type: - list: - elementType: - namedType: io.k8s.api.autoscaling.v2beta2.HPAScalingPolicy - elementRelationship: atomic - - name: selectPolicy + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + default: {} + - name: metricName type: scalar: string - - name: stabilizationWindowSeconds + default: "" + - name: metricSelector type: - scalar: numeric -- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler map: fields: - name: apiVersion @@ -2261,22 +2328,13 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerSpec + namedType: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerSpec default: {} - name: status type: - namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerStatus + namedType: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerStatus default: {} -- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerBehavior - map: - fields: - - name: scaleDown - type: - namedType: io.k8s.api.autoscaling.v2beta2.HPAScalingRules - - name: scaleUp - type: - namedType: io.k8s.api.autoscaling.v2beta2.HPAScalingRules -- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerCondition +- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerCondition map: fields: - name: lastTransitionTime @@ -2297,12 +2355,9 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerSpec +- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerSpec map: fields: - - name: behavior - type: - namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerBehavior - name: maxReplicas type: scalar: numeric @@ -2311,29 +2366,29 @@ var schemaYAML = typed.YAMLObject(`types: type: list: elementType: - namedType: io.k8s.api.autoscaling.v2beta2.MetricSpec + namedType: io.k8s.api.autoscaling.v2beta1.MetricSpec elementRelationship: atomic - name: minReplicas type: scalar: numeric - name: scaleTargetRef type: - namedType: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference + namedType: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference default: {} -- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerStatus +- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerStatus map: fields: - name: conditions type: list: elementType: - namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerCondition + namedType: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerCondition elementRelationship: atomic - name: currentMetrics type: list: elementType: - namedType: io.k8s.api.autoscaling.v2beta2.MetricStatus + namedType: io.k8s.api.autoscaling.v2beta1.MetricStatus elementRelationship: atomic - name: currentReplicas type: @@ -2349,143 +2404,154 @@ var schemaYAML = typed.YAMLObject(`types: - name: observedGeneration type: scalar: numeric -- name: io.k8s.api.autoscaling.v2beta2.MetricIdentifier - map: - fields: - - name: name - type: - scalar: string - default: "" - - name: selector - type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector -- name: io.k8s.api.autoscaling.v2beta2.MetricSpec +- name: io.k8s.api.autoscaling.v2beta1.MetricSpec map: fields: - name: containerResource type: - namedType: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricSource + namedType: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricSource - name: external type: - namedType: io.k8s.api.autoscaling.v2beta2.ExternalMetricSource + namedType: io.k8s.api.autoscaling.v2beta1.ExternalMetricSource - name: object type: - namedType: io.k8s.api.autoscaling.v2beta2.ObjectMetricSource + namedType: io.k8s.api.autoscaling.v2beta1.ObjectMetricSource - name: pods type: - namedType: io.k8s.api.autoscaling.v2beta2.PodsMetricSource + namedType: io.k8s.api.autoscaling.v2beta1.PodsMetricSource - name: resource type: - namedType: io.k8s.api.autoscaling.v2beta2.ResourceMetricSource + namedType: io.k8s.api.autoscaling.v2beta1.ResourceMetricSource - name: type type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta2.MetricStatus +- name: io.k8s.api.autoscaling.v2beta1.MetricStatus map: fields: - name: containerResource type: - namedType: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricStatus + namedType: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricStatus - name: external type: - namedType: io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus + namedType: io.k8s.api.autoscaling.v2beta1.ExternalMetricStatus - name: object type: - namedType: io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus + namedType: io.k8s.api.autoscaling.v2beta1.ObjectMetricStatus - name: pods type: - namedType: io.k8s.api.autoscaling.v2beta2.PodsMetricStatus + namedType: io.k8s.api.autoscaling.v2beta1.PodsMetricStatus - name: resource type: - namedType: io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus + namedType: io.k8s.api.autoscaling.v2beta1.ResourceMetricStatus - name: type type: scalar: string default: "" -- name: io.k8s.api.autoscaling.v2beta2.MetricTarget +- name: io.k8s.api.autoscaling.v2beta1.ObjectMetricSource map: fields: - - name: averageUtilization - type: - scalar: numeric - name: averageValue type: namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - - name: type + - name: metricName type: scalar: string default: "" - - name: value + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: target + type: + namedType: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference + default: {} + - name: targetValue type: namedType: io.k8s.apimachinery.pkg.api.resource.Quantity -- name: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + default: {} +- name: io.k8s.api.autoscaling.v2beta1.ObjectMetricStatus map: fields: - - name: averageUtilization - type: - scalar: numeric - name: averageValue type: namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - - name: value + - name: currentValue type: namedType: io.k8s.apimachinery.pkg.api.resource.Quantity -- name: io.k8s.api.autoscaling.v2beta2.ObjectMetricSource - map: - fields: - - name: describedObject - type: - namedType: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference default: {} - - name: metric + - name: metricName type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier - default: {} + scalar: string + default: "" + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector - name: target type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget + namedType: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference default: {} -- name: io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus +- name: io.k8s.api.autoscaling.v2beta1.PodsMetricSource map: fields: - - name: current + - name: metricName type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus - default: {} - - name: describedObject + scalar: string + default: "" + - name: selector type: - namedType: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference - default: {} - - name: metric + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: targetAverageValue type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity default: {} -- name: io.k8s.api.autoscaling.v2beta2.PodsMetricSource +- name: io.k8s.api.autoscaling.v2beta1.PodsMetricStatus map: fields: - - name: metric + - name: currentAverageValue type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity default: {} - - name: target + - name: metricName type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget - default: {} -- name: io.k8s.api.autoscaling.v2beta2.PodsMetricStatus + scalar: string + default: "" + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.autoscaling.v2beta1.ResourceMetricSource map: fields: - - name: current + - name: name type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus - default: {} - - name: metric + scalar: string + default: "" + - name: targetAverageUtilization type: - namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + scalar: numeric + - name: targetAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta1.ResourceMetricStatus + map: + fields: + - name: currentAverageUtilization + type: + scalar: numeric + - name: currentAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity default: {} -- name: io.k8s.api.autoscaling.v2beta2.ResourceMetricSource + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricSource map: fields: + - name: container + type: + scalar: string + default: "" - name: name type: scalar: string @@ -2494,9 +2560,13 @@ var schemaYAML = typed.YAMLObject(`types: type: namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget default: {} -- name: io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus +- name: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricStatus map: fields: + - name: container + type: + scalar: string + default: "" - name: current type: namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus @@ -2505,7 +2575,7 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.batch.v1.CronJob +- name: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference map: fields: - name: apiVersion @@ -2514,60 +2584,64 @@ var schemaYAML = typed.YAMLObject(`types: - name: kind type: scalar: string - - name: metadata + default: "" + - name: name type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta - default: {} - - name: spec + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta2.ExternalMetricSource + map: + fields: + - name: metric type: - namedType: io.k8s.api.batch.v1.CronJobSpec + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier default: {} - - name: status + - name: target type: - namedType: io.k8s.api.batch.v1.CronJobStatus + namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget default: {} -- name: io.k8s.api.batch.v1.CronJobSpec +- name: io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus map: fields: - - name: concurrencyPolicy - type: - scalar: string - - name: failedJobsHistoryLimit - type: - scalar: numeric - - name: jobTemplate + - name: current type: - namedType: io.k8s.api.batch.v1.JobTemplateSpec + namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus default: {} - - name: schedule + - name: metric type: - scalar: string - default: "" - - name: startingDeadlineSeconds + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + default: {} +- name: io.k8s.api.autoscaling.v2beta2.HPAScalingPolicy + map: + fields: + - name: periodSeconds type: scalar: numeric - - name: successfulJobsHistoryLimit + default: 0 + - name: type type: - scalar: numeric - - name: suspend + scalar: string + default: "" + - name: value type: - scalar: boolean -- name: io.k8s.api.batch.v1.CronJobStatus + scalar: numeric + default: 0 +- name: io.k8s.api.autoscaling.v2beta2.HPAScalingRules map: fields: - - name: active + - name: policies type: list: elementType: - namedType: io.k8s.api.core.v1.ObjectReference + namedType: io.k8s.api.autoscaling.v2beta2.HPAScalingPolicy elementRelationship: atomic - - name: lastScheduleTime + - name: selectPolicy type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time - - name: lastSuccessfulTime + scalar: string + - name: stabilizationWindowSeconds type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time -- name: io.k8s.api.batch.v1.Job + scalar: numeric +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler map: fields: - name: apiVersion @@ -2582,19 +2656,24 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.batch.v1.JobSpec + namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerSpec default: {} - name: status type: - namedType: io.k8s.api.batch.v1.JobStatus + namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerStatus default: {} -- name: io.k8s.api.batch.v1.JobCondition +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerBehavior map: fields: - - name: lastProbeTime + - name: scaleDown type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time - default: {} + namedType: io.k8s.api.autoscaling.v2beta2.HPAScalingRules + - name: scaleUp + type: + namedType: io.k8s.api.autoscaling.v2beta2.HPAScalingRules +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerCondition + map: + fields: - name: lastTransitionTime type: namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time @@ -2613,269 +2692,277 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.batch.v1.JobSpec +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerSpec map: fields: - - name: activeDeadlineSeconds - type: - scalar: numeric - - name: backoffLimit - type: - scalar: numeric - - name: completionMode + - name: behavior type: - scalar: string - - name: completions + namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerBehavior + - name: maxReplicas type: scalar: numeric - - name: manualSelector + default: 0 + - name: metrics type: - scalar: boolean - - name: parallelism + list: + elementType: + namedType: io.k8s.api.autoscaling.v2beta2.MetricSpec + elementRelationship: atomic + - name: minReplicas type: scalar: numeric - - name: selector - type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector - - name: suspend - type: - scalar: boolean - - name: template + - name: scaleTargetRef type: - namedType: io.k8s.api.core.v1.PodTemplateSpec + namedType: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference default: {} - - name: ttlSecondsAfterFinished - type: - scalar: numeric -- name: io.k8s.api.batch.v1.JobStatus +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerStatus map: fields: - - name: active - type: - scalar: numeric - - name: completedIndexes - type: - scalar: string - - name: completionTime - type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time - name: conditions type: list: elementType: - namedType: io.k8s.api.batch.v1.JobCondition + namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerCondition elementRelationship: atomic - - name: failed + - name: currentMetrics + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2beta2.MetricStatus + elementRelationship: atomic + - name: currentReplicas type: scalar: numeric - - name: startTime + default: 0 + - name: desiredReplicas + type: + scalar: numeric + default: 0 + - name: lastScaleTime type: namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time - - name: succeeded + - name: observedGeneration type: scalar: numeric - - name: uncountedTerminatedPods - type: - namedType: io.k8s.api.batch.v1.UncountedTerminatedPods -- name: io.k8s.api.batch.v1.JobTemplateSpec +- name: io.k8s.api.autoscaling.v2beta2.MetricIdentifier map: fields: - - name: metadata + - name: name type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta - default: {} - - name: spec + scalar: string + default: "" + - name: selector type: - namedType: io.k8s.api.batch.v1.JobSpec - default: {} -- name: io.k8s.api.batch.v1.UncountedTerminatedPods + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.autoscaling.v2beta2.MetricSpec map: fields: - - name: failed - type: - list: - elementType: - scalar: string - elementRelationship: associative - - name: succeeded + - name: containerResource type: - list: - elementType: - scalar: string - elementRelationship: associative -- name: io.k8s.api.batch.v1beta1.CronJob - map: - fields: - - name: apiVersion + namedType: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricSource + - name: external type: - scalar: string - - name: kind + namedType: io.k8s.api.autoscaling.v2beta2.ExternalMetricSource + - name: object type: - scalar: string - - name: metadata + namedType: io.k8s.api.autoscaling.v2beta2.ObjectMetricSource + - name: pods type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta - default: {} - - name: spec + namedType: io.k8s.api.autoscaling.v2beta2.PodsMetricSource + - name: resource type: - namedType: io.k8s.api.batch.v1beta1.CronJobSpec - default: {} - - name: status + namedType: io.k8s.api.autoscaling.v2beta2.ResourceMetricSource + - name: type type: - namedType: io.k8s.api.batch.v1beta1.CronJobStatus - default: {} -- name: io.k8s.api.batch.v1beta1.CronJobSpec + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta2.MetricStatus map: fields: - - name: concurrencyPolicy + - name: containerResource type: - scalar: string - - name: failedJobsHistoryLimit + namedType: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricStatus + - name: external type: - scalar: numeric - - name: jobTemplate + namedType: io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus + - name: object type: - namedType: io.k8s.api.batch.v1beta1.JobTemplateSpec - default: {} - - name: schedule + namedType: io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus + - name: pods + type: + namedType: io.k8s.api.autoscaling.v2beta2.PodsMetricStatus + - name: resource + type: + namedType: io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus + - name: type type: scalar: string default: "" - - name: startingDeadlineSeconds +- name: io.k8s.api.autoscaling.v2beta2.MetricTarget + map: + fields: + - name: averageUtilization type: scalar: numeric - - name: successfulJobsHistoryLimit + - name: averageValue type: - scalar: numeric - - name: suspend + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: type type: - scalar: boolean -- name: io.k8s.api.batch.v1beta1.CronJobStatus + scalar: string + default: "" + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta2.MetricValueStatus map: fields: - - name: active + - name: averageUtilization type: - list: - elementType: - namedType: io.k8s.api.core.v1.ObjectReference - elementRelationship: atomic - - name: lastScheduleTime + scalar: numeric + - name: averageValue type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time - - name: lastSuccessfulTime + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: value type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time -- name: io.k8s.api.batch.v1beta1.JobTemplateSpec + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta2.ObjectMetricSource map: fields: - - name: metadata + - name: describedObject type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + namedType: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference default: {} - - name: spec + - name: metric type: - namedType: io.k8s.api.batch.v1.JobSpec + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier default: {} -- name: io.k8s.api.certificates.v1.CertificateSigningRequest + - name: target + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus map: fields: - - name: apiVersion + - name: current type: - scalar: string - - name: kind + namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + default: {} + - name: describedObject type: - scalar: string - - name: metadata + namedType: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference + default: {} + - name: metric type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier default: {} - - name: spec +- name: io.k8s.api.autoscaling.v2beta2.PodsMetricSource + map: + fields: + - name: metric type: - namedType: io.k8s.api.certificates.v1.CertificateSigningRequestSpec + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier default: {} - - name: status + - name: target type: - namedType: io.k8s.api.certificates.v1.CertificateSigningRequestStatus + namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget default: {} -- name: io.k8s.api.certificates.v1.CertificateSigningRequestCondition +- name: io.k8s.api.autoscaling.v2beta2.PodsMetricStatus map: fields: - - name: lastTransitionTime + - name: current type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus default: {} - - name: lastUpdateTime + - name: metric type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier default: {} - - name: message +- name: io.k8s.api.autoscaling.v2beta2.ResourceMetricSource + map: + fields: + - name: name type: scalar: string - - name: reason + default: "" + - name: target type: - scalar: string - - name: status + namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus + map: + fields: + - name: current type: - scalar: string - default: "" - - name: type + namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + default: {} + - name: name type: scalar: string default: "" -- name: io.k8s.api.certificates.v1.CertificateSigningRequestSpec +- name: io.k8s.api.batch.v1.CronJob map: fields: - - name: expirationSeconds + - name: apiVersion type: - scalar: numeric - - name: extra + scalar: string + - name: kind type: - map: - elementType: - list: - elementType: - scalar: string - elementRelationship: atomic - - name: groups + scalar: string + - name: metadata type: - list: - elementType: - scalar: string - elementRelationship: atomic - - name: request + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.batch.v1.CronJobSpec + default: {} + - name: status + type: + namedType: io.k8s.api.batch.v1.CronJobStatus + default: {} +- name: io.k8s.api.batch.v1.CronJobSpec + map: + fields: + - name: concurrencyPolicy type: scalar: string - - name: signerName + - name: failedJobsHistoryLimit + type: + scalar: numeric + - name: jobTemplate + type: + namedType: io.k8s.api.batch.v1.JobTemplateSpec + default: {} + - name: schedule type: scalar: string default: "" - - name: uid + - name: startingDeadlineSeconds type: - scalar: string - - name: usages + scalar: numeric + - name: successfulJobsHistoryLimit type: - list: - elementType: - scalar: string - elementRelationship: atomic - - name: username + scalar: numeric + - name: suspend type: - scalar: string -- name: io.k8s.api.certificates.v1.CertificateSigningRequestStatus + scalar: boolean +- name: io.k8s.api.batch.v1.CronJobStatus map: fields: - - name: certificate - type: - scalar: string - - name: conditions + - name: active type: list: elementType: - namedType: io.k8s.api.certificates.v1.CertificateSigningRequestCondition - elementRelationship: associative - keys: - - type -- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequest + namedType: io.k8s.api.core.v1.ObjectReference + elementRelationship: atomic + - name: lastScheduleTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastSuccessfulTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.batch.v1.Job map: fields: - name: apiVersion @@ -2890,20 +2977,20 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.certificates.v1beta1.CertificateSigningRequestSpec + namedType: io.k8s.api.batch.v1.JobSpec default: {} - name: status type: - namedType: io.k8s.api.certificates.v1beta1.CertificateSigningRequestStatus + namedType: io.k8s.api.batch.v1.JobStatus default: {} -- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequestCondition +- name: io.k8s.api.batch.v1.JobCondition map: fields: - - name: lastTransitionTime + - name: lastProbeTime type: namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time default: {} - - name: lastUpdateTime + - name: lastTransitionTime type: namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time default: {} @@ -2921,59 +3008,100 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequestSpec +- name: io.k8s.api.batch.v1.JobSpec map: fields: - - name: expirationSeconds + - name: activeDeadlineSeconds type: scalar: numeric - - name: extra - type: - map: - elementType: - list: - elementType: - scalar: string - elementRelationship: atomic - - name: groups + - name: backoffLimit type: - list: - elementType: - scalar: string - elementRelationship: atomic - - name: request + scalar: numeric + - name: completionMode type: scalar: string - - name: signerName + - name: completions type: - scalar: string - - name: uid + scalar: numeric + - name: manualSelector + type: + scalar: boolean + - name: parallelism + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: suspend + type: + scalar: boolean + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} + - name: ttlSecondsAfterFinished + type: + scalar: numeric +- name: io.k8s.api.batch.v1.JobStatus + map: + fields: + - name: active + type: + scalar: numeric + - name: completedIndexes type: scalar: string - - name: usages + - name: completionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: conditions type: list: elementType: - scalar: string + namedType: io.k8s.api.batch.v1.JobCondition elementRelationship: atomic - - name: username + - name: failed type: - scalar: string -- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequestStatus + scalar: numeric + - name: ready + type: + scalar: numeric + - name: startTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: succeeded + type: + scalar: numeric + - name: uncountedTerminatedPods + type: + namedType: io.k8s.api.batch.v1.UncountedTerminatedPods +- name: io.k8s.api.batch.v1.JobTemplateSpec map: fields: - - name: certificate + - name: metadata type: - scalar: string - - name: conditions + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.batch.v1.JobSpec + default: {} +- name: io.k8s.api.batch.v1.UncountedTerminatedPods + map: + fields: + - name: failed type: list: elementType: - namedType: io.k8s.api.certificates.v1beta1.CertificateSigningRequestCondition + scalar: string elementRelationship: associative - keys: - - type -- name: io.k8s.api.coordination.v1.Lease + - name: succeeded + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.batch.v1beta1.CronJob map: fields: - name: apiVersion @@ -2988,202 +3116,472 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.coordination.v1.LeaseSpec + namedType: io.k8s.api.batch.v1beta1.CronJobSpec default: {} -- name: io.k8s.api.coordination.v1.LeaseSpec + - name: status + type: + namedType: io.k8s.api.batch.v1beta1.CronJobStatus + default: {} +- name: io.k8s.api.batch.v1beta1.CronJobSpec map: fields: - - name: acquireTime + - name: concurrencyPolicy type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime - - name: holderIdentity + scalar: string + - name: failedJobsHistoryLimit + type: + scalar: numeric + - name: jobTemplate + type: + namedType: io.k8s.api.batch.v1beta1.JobTemplateSpec + default: {} + - name: schedule type: scalar: string - - name: leaseDurationSeconds + default: "" + - name: startingDeadlineSeconds type: scalar: numeric - - name: leaseTransitions + - name: successfulJobsHistoryLimit type: scalar: numeric - - name: renewTime + - name: suspend type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime -- name: io.k8s.api.coordination.v1beta1.Lease + scalar: boolean +- name: io.k8s.api.batch.v1beta1.CronJobStatus map: fields: - - name: apiVersion + - name: active type: - scalar: string - - name: kind + list: + elementType: + namedType: io.k8s.api.core.v1.ObjectReference + elementRelationship: atomic + - name: lastScheduleTime type: - scalar: string + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastSuccessfulTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.batch.v1beta1.JobTemplateSpec + map: + fields: - name: metadata type: namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta default: {} - name: spec type: - namedType: io.k8s.api.coordination.v1beta1.LeaseSpec + namedType: io.k8s.api.batch.v1.JobSpec default: {} -- name: io.k8s.api.coordination.v1beta1.LeaseSpec +- name: io.k8s.api.certificates.v1.CertificateSigningRequest map: fields: - - name: acquireTime + - name: apiVersion type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime - - name: holderIdentity + scalar: string + - name: kind type: scalar: string - - name: leaseDurationSeconds + - name: metadata type: - scalar: numeric - - name: leaseTransitions + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec type: - scalar: numeric - - name: renewTime + namedType: io.k8s.api.certificates.v1.CertificateSigningRequestSpec + default: {} + - name: status type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime -- name: io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource + namedType: io.k8s.api.certificates.v1.CertificateSigningRequestStatus + default: {} +- name: io.k8s.api.certificates.v1.CertificateSigningRequestCondition map: fields: - - name: fsType + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + default: {} + - name: lastUpdateTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + default: {} + - name: message type: scalar: string - - name: partition + - name: reason type: - scalar: numeric - - name: readOnly + scalar: string + - name: status type: - scalar: boolean - - name: volumeID + scalar: string + default: "" + - name: type type: scalar: string default: "" -- name: io.k8s.api.core.v1.Affinity +- name: io.k8s.api.certificates.v1.CertificateSigningRequestSpec map: fields: - - name: nodeAffinity + - name: expirationSeconds type: - namedType: io.k8s.api.core.v1.NodeAffinity - - name: podAffinity + scalar: numeric + - name: extra type: - namedType: io.k8s.api.core.v1.PodAffinity - - name: podAntiAffinity + map: + elementType: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: groups type: - namedType: io.k8s.api.core.v1.PodAntiAffinity -- name: io.k8s.api.core.v1.AttachedVolume - map: - fields: - - name: devicePath + list: + elementType: + scalar: string + elementRelationship: atomic + - name: request type: scalar: string - default: "" - - name: name + - name: signerName type: scalar: string default: "" -- name: io.k8s.api.core.v1.AzureDiskVolumeSource - map: - fields: - - name: cachingMode + - name: uid type: scalar: string - - name: diskName + - name: usages + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: username type: scalar: string - default: "" - - name: diskURI +- name: io.k8s.api.certificates.v1.CertificateSigningRequestStatus + map: + fields: + - name: certificate type: scalar: string - default: "" - - name: fsType + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.certificates.v1.CertificateSigningRequestCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequest + map: + fields: + - name: apiVersion type: scalar: string - name: kind type: scalar: string - - name: readOnly + - name: metadata type: - scalar: boolean -- name: io.k8s.api.core.v1.AzureFilePersistentVolumeSource + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.certificates.v1beta1.CertificateSigningRequestSpec + default: {} + - name: status + type: + namedType: io.k8s.api.certificates.v1beta1.CertificateSigningRequestStatus + default: {} +- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequestCondition map: fields: - - name: readOnly + - name: lastTransitionTime type: - scalar: boolean - - name: secretName + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + default: {} + - name: lastUpdateTime type: - scalar: string - default: "" - - name: secretNamespace + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + default: {} + - name: message type: scalar: string - - name: shareName + - name: reason type: scalar: string - default: "" -- name: io.k8s.api.core.v1.AzureFileVolumeSource - map: - fields: - - name: readOnly - type: - scalar: boolean - - name: secretName + - name: status type: scalar: string default: "" - - name: shareName + - name: type type: scalar: string default: "" -- name: io.k8s.api.core.v1.CSIPersistentVolumeSource +- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequestSpec map: fields: - - name: controllerExpandSecretRef + - name: expirationSeconds type: - namedType: io.k8s.api.core.v1.SecretReference - - name: controllerPublishSecretRef + scalar: numeric + - name: extra type: - namedType: io.k8s.api.core.v1.SecretReference - - name: driver + map: + elementType: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: groups type: - scalar: string - default: "" - - name: fsType + list: + elementType: + scalar: string + elementRelationship: atomic + - name: request type: scalar: string - - name: nodePublishSecretRef - type: - namedType: io.k8s.api.core.v1.SecretReference - - name: nodeStageSecretRef + - name: signerName type: - namedType: io.k8s.api.core.v1.SecretReference - - name: readOnly + scalar: string + - name: uid type: - scalar: boolean - - name: volumeAttributes + scalar: string + - name: usages type: - map: + list: elementType: scalar: string - - name: volumeHandle + elementRelationship: atomic + - name: username type: scalar: string - default: "" -- name: io.k8s.api.core.v1.CSIVolumeSource +- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequestStatus map: fields: - - name: driver + - name: certificate type: scalar: string - default: "" - - name: fsType + - name: conditions type: - scalar: string - - name: nodePublishSecretRef + list: + elementType: + namedType: io.k8s.api.certificates.v1beta1.CertificateSigningRequestCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.coordination.v1.Lease + map: + fields: + - name: apiVersion type: - namedType: io.k8s.api.core.v1.LocalObjectReference - - name: readOnly + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.coordination.v1.LeaseSpec + default: {} +- name: io.k8s.api.coordination.v1.LeaseSpec + map: + fields: + - name: acquireTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: holderIdentity + type: + scalar: string + - name: leaseDurationSeconds + type: + scalar: numeric + - name: leaseTransitions + type: + scalar: numeric + - name: renewTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime +- name: io.k8s.api.coordination.v1beta1.Lease + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.coordination.v1beta1.LeaseSpec + default: {} +- name: io.k8s.api.coordination.v1beta1.LeaseSpec + map: + fields: + - name: acquireTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: holderIdentity + type: + scalar: string + - name: leaseDurationSeconds + type: + scalar: numeric + - name: leaseTransitions + type: + scalar: numeric + - name: renewTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime +- name: io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: partition + type: + scalar: numeric + - name: readOnly + type: + scalar: boolean + - name: volumeID + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.Affinity + map: + fields: + - name: nodeAffinity + type: + namedType: io.k8s.api.core.v1.NodeAffinity + - name: podAffinity + type: + namedType: io.k8s.api.core.v1.PodAffinity + - name: podAntiAffinity + type: + namedType: io.k8s.api.core.v1.PodAntiAffinity +- name: io.k8s.api.core.v1.AttachedVolume + map: + fields: + - name: devicePath + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.AzureDiskVolumeSource + map: + fields: + - name: cachingMode + type: + scalar: string + - name: diskName + type: + scalar: string + default: "" + - name: diskURI + type: + scalar: string + default: "" + - name: fsType + type: + scalar: string + - name: kind + type: + scalar: string + - name: readOnly + type: + scalar: boolean +- name: io.k8s.api.core.v1.AzureFilePersistentVolumeSource + map: + fields: + - name: readOnly + type: + scalar: boolean + - name: secretName + type: + scalar: string + default: "" + - name: secretNamespace + type: + scalar: string + - name: shareName + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.AzureFileVolumeSource + map: + fields: + - name: readOnly + type: + scalar: boolean + - name: secretName + type: + scalar: string + default: "" + - name: shareName + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.CSIPersistentVolumeSource + map: + fields: + - name: controllerExpandSecretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: controllerPublishSecretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: driver + type: + scalar: string + default: "" + - name: fsType + type: + scalar: string + - name: nodePublishSecretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: nodeStageSecretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: readOnly + type: + scalar: boolean + - name: volumeAttributes + type: + map: + elementType: + scalar: string + - name: volumeHandle + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.CSIVolumeSource + map: + fields: + - name: driver + type: + scalar: string + default: "" + - name: fsType + type: + scalar: string + - name: nodePublishSecretRef + type: + namedType: io.k8s.api.core.v1.LocalObjectReference + - name: readOnly type: scalar: boolean - name: volumeAttributes @@ -3875,7 +4273,10 @@ var schemaYAML = typed.YAMLObject(`types: list: elementType: namedType: io.k8s.api.core.v1.ContainerPort - elementRelationship: atomic + elementRelationship: associative + keys: + - containerPort + - protocol - name: readinessProbe type: namedType: io.k8s.api.core.v1.Probe @@ -4113,6 +4514,17 @@ var schemaYAML = typed.YAMLObject(`types: - name: readOnly type: scalar: boolean +- name: io.k8s.api.core.v1.GRPCAction + map: + fields: + - name: port + type: + scalar: numeric + default: 0 + - name: service + type: + scalar: string + default: "" - name: io.k8s.api.core.v1.GitRepoVolumeSource map: fields: @@ -4190,18 +4602,6 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.core.v1.Handler - map: - fields: - - name: exec - type: - namedType: io.k8s.api.core.v1.ExecAction - - name: httpGet - type: - namedType: io.k8s.api.core.v1.HTTPGetAction - - name: tcpSocket - type: - namedType: io.k8s.api.core.v1.TCPSocketAction - name: io.k8s.api.core.v1.HostAlias map: fields: @@ -4327,10 +4727,22 @@ var schemaYAML = typed.YAMLObject(`types: fields: - name: postStart type: - namedType: io.k8s.api.core.v1.Handler + namedType: io.k8s.api.core.v1.LifecycleHandler - name: preStop type: - namedType: io.k8s.api.core.v1.Handler + namedType: io.k8s.api.core.v1.LifecycleHandler +- name: io.k8s.api.core.v1.LifecycleHandler + map: + fields: + - name: exec + type: + namedType: io.k8s.api.core.v1.ExecAction + - name: httpGet + type: + namedType: io.k8s.api.core.v1.HTTPGetAction + - name: tcpSocket + type: + namedType: io.k8s.api.core.v1.TCPSocketAction - name: io.k8s.api.core.v1.LimitRange map: fields: @@ -4926,6 +5338,11 @@ var schemaYAML = typed.YAMLObject(`types: elementType: scalar: string elementRelationship: atomic + - name: allocatedResources + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - name: capacity type: map: @@ -4942,6 +5359,9 @@ var schemaYAML = typed.YAMLObject(`types: - name: phase type: scalar: string + - name: resizeStatus + type: + scalar: string - name: io.k8s.api.core.v1.PersistentVolumeClaimTemplate map: fields: @@ -5217,6 +5637,13 @@ var schemaYAML = typed.YAMLObject(`types: - name: ip type: scalar: string +- name: io.k8s.api.core.v1.PodOS + map: + fields: + - name: name + type: + scalar: string + default: "" - name: io.k8s.api.core.v1.PodReadinessGate map: fields: @@ -5345,6 +5772,9 @@ var schemaYAML = typed.YAMLObject(`types: elementType: scalar: string elementRelationship: atomic + - name: os + type: + namedType: io.k8s.api.core.v1.PodOS - name: overhead type: map: @@ -5554,6 +5984,9 @@ var schemaYAML = typed.YAMLObject(`types: - name: failureThreshold type: scalar: numeric + - name: grpc + type: + namedType: io.k8s.api.core.v1.GRPCAction - name: httpGet type: namedType: io.k8s.api.core.v1.HTTPGetAction @@ -7452,36 +7885,341 @@ var schemaYAML = typed.YAMLObject(`types: scalar: numeric - name: port type: - namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString - - name: protocol + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: protocol + type: + scalar: string +- name: io.k8s.api.extensions.v1beta1.NetworkPolicySpec + map: + fields: + - name: egress + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyEgressRule + elementRelationship: atomic + - name: ingress + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyIngressRule + elementRelationship: atomic + - name: podSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + default: {} + - name: policyTypes + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.PodSecurityPolicy + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.extensions.v1beta1.PodSecurityPolicySpec + default: {} +- name: io.k8s.api.extensions.v1beta1.PodSecurityPolicySpec + map: + fields: + - name: allowPrivilegeEscalation + type: + scalar: boolean + - name: allowedCSIDrivers + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.AllowedCSIDriver + elementRelationship: atomic + - name: allowedCapabilities + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: allowedFlexVolumes + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.AllowedFlexVolume + elementRelationship: atomic + - name: allowedHostPaths + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.AllowedHostPath + elementRelationship: atomic + - name: allowedProcMountTypes + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: allowedUnsafeSysctls + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: defaultAddCapabilities + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: defaultAllowPrivilegeEscalation + type: + scalar: boolean + - name: forbiddenSysctls + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: fsGroup + type: + namedType: io.k8s.api.extensions.v1beta1.FSGroupStrategyOptions + default: {} + - name: hostIPC + type: + scalar: boolean + - name: hostNetwork + type: + scalar: boolean + - name: hostPID + type: + scalar: boolean + - name: hostPorts + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.HostPortRange + elementRelationship: atomic + - name: privileged + type: + scalar: boolean + - name: readOnlyRootFilesystem + type: + scalar: boolean + - name: requiredDropCapabilities + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: runAsGroup + type: + namedType: io.k8s.api.extensions.v1beta1.RunAsGroupStrategyOptions + - name: runAsUser + type: + namedType: io.k8s.api.extensions.v1beta1.RunAsUserStrategyOptions + default: {} + - name: runtimeClass + type: + namedType: io.k8s.api.extensions.v1beta1.RuntimeClassStrategyOptions + - name: seLinux + type: + namedType: io.k8s.api.extensions.v1beta1.SELinuxStrategyOptions + default: {} + - name: supplementalGroups + type: + namedType: io.k8s.api.extensions.v1beta1.SupplementalGroupsStrategyOptions + default: {} + - name: volumes + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.ReplicaSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.extensions.v1beta1.ReplicaSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.extensions.v1beta1.ReplicaSetStatus + default: {} +- name: io.k8s.api.extensions.v1beta1.ReplicaSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + default: {} + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.extensions.v1beta1.ReplicaSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} +- name: io.k8s.api.extensions.v1beta1.ReplicaSetStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.ReplicaSetCondition + elementRelationship: associative + keys: + - type + - name: fullyLabeledReplicas + type: + scalar: numeric + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + default: 0 +- name: io.k8s.api.extensions.v1beta1.RollbackConfig + map: + fields: + - name: revision + type: + scalar: numeric +- name: io.k8s.api.extensions.v1beta1.RollingUpdateDaemonSet + map: + fields: + - name: maxSurge + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.extensions.v1beta1.RollingUpdateDeployment + map: + fields: + - name: maxSurge + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.extensions.v1beta1.RunAsGroupStrategyOptions + map: + fields: + - name: ranges + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.IDRange + elementRelationship: atomic + - name: rule type: scalar: string -- name: io.k8s.api.extensions.v1beta1.NetworkPolicySpec + default: "" +- name: io.k8s.api.extensions.v1beta1.RunAsUserStrategyOptions map: fields: - - name: egress + - name: ranges type: list: elementType: - namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyEgressRule + namedType: io.k8s.api.extensions.v1beta1.IDRange elementRelationship: atomic - - name: ingress + - name: rule + type: + scalar: string + default: "" +- name: io.k8s.api.extensions.v1beta1.RuntimeClassStrategyOptions + map: + fields: + - name: allowedRuntimeClassNames type: list: elementType: - namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyIngressRule + scalar: string elementRelationship: atomic - - name: podSelector + - name: defaultRuntimeClassName type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector - default: {} - - name: policyTypes + scalar: string +- name: io.k8s.api.extensions.v1beta1.SELinuxStrategyOptions + map: + fields: + - name: rule + type: + scalar: string + default: "" + - name: seLinuxOptions + type: + namedType: io.k8s.api.core.v1.SELinuxOptions +- name: io.k8s.api.extensions.v1beta1.SupplementalGroupsStrategyOptions + map: + fields: + - name: ranges type: list: elementType: - scalar: string + namedType: io.k8s.api.extensions.v1beta1.IDRange elementRelationship: atomic -- name: io.k8s.api.extensions.v1beta1.PodSecurityPolicy + - name: rule + type: + scalar: string +- name: io.k8s.api.flowcontrol.v1alpha1.FlowDistinguisherMethod + map: + fields: + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1alpha1.FlowSchema map: fields: - name: apiVersion @@ -7496,121 +8234,132 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.extensions.v1beta1.PodSecurityPolicySpec + namedType: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaSpec default: {} -- name: io.k8s.api.extensions.v1beta1.PodSecurityPolicySpec + - name: status + type: + namedType: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaStatus + default: {} +- name: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaCondition map: fields: - - name: allowPrivilegeEscalation + - name: lastTransitionTime type: - scalar: boolean - - name: allowedCSIDrivers + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + default: {} + - name: message type: - list: - elementType: - namedType: io.k8s.api.extensions.v1beta1.AllowedCSIDriver - elementRelationship: atomic - - name: allowedCapabilities + scalar: string + - name: reason type: - list: - elementType: - scalar: string - elementRelationship: atomic - - name: allowedFlexVolumes + scalar: string + - name: status type: - list: - elementType: - namedType: io.k8s.api.extensions.v1beta1.AllowedFlexVolume - elementRelationship: atomic - - name: allowedHostPaths + scalar: string + - name: type type: - list: - elementType: - namedType: io.k8s.api.extensions.v1beta1.AllowedHostPath - elementRelationship: atomic - - name: allowedProcMountTypes + scalar: string +- name: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaSpec + map: + fields: + - name: distinguisherMethod + type: + namedType: io.k8s.api.flowcontrol.v1alpha1.FlowDistinguisherMethod + - name: matchingPrecedence + type: + scalar: numeric + default: 0 + - name: priorityLevelConfiguration + type: + namedType: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationReference + default: {} + - name: rules type: list: elementType: - scalar: string + namedType: io.k8s.api.flowcontrol.v1alpha1.PolicyRulesWithSubjects elementRelationship: atomic - - name: allowedUnsafeSysctls +- name: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaStatus + map: + fields: + - name: conditions type: list: elementType: - scalar: string - elementRelationship: atomic - - name: defaultAddCapabilities + namedType: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.flowcontrol.v1alpha1.GroupSubject + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1alpha1.LimitResponse + map: + fields: + - name: queuing + type: + namedType: io.k8s.api.flowcontrol.v1alpha1.QueuingConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: queuing + discriminatorValue: Queuing +- name: io.k8s.api.flowcontrol.v1alpha1.LimitedPriorityLevelConfiguration + map: + fields: + - name: assuredConcurrencyShares + type: + scalar: numeric + default: 0 + - name: limitResponse + type: + namedType: io.k8s.api.flowcontrol.v1alpha1.LimitResponse + default: {} +- name: io.k8s.api.flowcontrol.v1alpha1.NonResourcePolicyRule + map: + fields: + - name: nonResourceURLs type: list: elementType: scalar: string - elementRelationship: atomic - - name: defaultAllowPrivilegeEscalation - type: - scalar: boolean - - name: forbiddenSysctls + elementRelationship: associative + - name: verbs type: list: elementType: scalar: string - elementRelationship: atomic - - name: fsGroup - type: - namedType: io.k8s.api.extensions.v1beta1.FSGroupStrategyOptions - default: {} - - name: hostIPC - type: - scalar: boolean - - name: hostNetwork - type: - scalar: boolean - - name: hostPID - type: - scalar: boolean - - name: hostPorts + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1alpha1.PolicyRulesWithSubjects + map: + fields: + - name: nonResourceRules type: list: elementType: - namedType: io.k8s.api.extensions.v1beta1.HostPortRange + namedType: io.k8s.api.flowcontrol.v1alpha1.NonResourcePolicyRule elementRelationship: atomic - - name: privileged - type: - scalar: boolean - - name: readOnlyRootFilesystem - type: - scalar: boolean - - name: requiredDropCapabilities + - name: resourceRules type: list: elementType: - scalar: string + namedType: io.k8s.api.flowcontrol.v1alpha1.ResourcePolicyRule elementRelationship: atomic - - name: runAsGroup - type: - namedType: io.k8s.api.extensions.v1beta1.RunAsGroupStrategyOptions - - name: runAsUser - type: - namedType: io.k8s.api.extensions.v1beta1.RunAsUserStrategyOptions - default: {} - - name: runtimeClass - type: - namedType: io.k8s.api.extensions.v1beta1.RuntimeClassStrategyOptions - - name: seLinux - type: - namedType: io.k8s.api.extensions.v1beta1.SELinuxStrategyOptions - default: {} - - name: supplementalGroups - type: - namedType: io.k8s.api.extensions.v1beta1.SupplementalGroupsStrategyOptions - default: {} - - name: volumes + - name: subjects type: list: elementType: - scalar: string + namedType: io.k8s.api.flowcontrol.v1alpha1.Subject elementRelationship: atomic -- name: io.k8s.api.extensions.v1beta1.ReplicaSet +- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfiguration map: fields: - name: apiVersion @@ -7625,13 +8374,13 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.extensions.v1beta1.ReplicaSetSpec + namedType: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationSpec default: {} - name: status type: - namedType: io.k8s.api.extensions.v1beta1.ReplicaSetStatus + namedType: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationStatus default: {} -- name: io.k8s.api.extensions.v1beta1.ReplicaSetCondition +- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationCondition map: fields: - name: lastTransitionTime @@ -7647,146 +8396,138 @@ var schemaYAML = typed.YAMLObject(`types: - name: status type: scalar: string - default: "" - name: type type: scalar: string - default: "" -- name: io.k8s.api.extensions.v1beta1.ReplicaSetSpec +- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationReference map: fields: - - name: minReadySeconds - type: - scalar: numeric - - name: replicas - type: - scalar: numeric - - name: selector - type: - namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector - - name: template + - name: name type: - namedType: io.k8s.api.core.v1.PodTemplateSpec - default: {} -- name: io.k8s.api.extensions.v1beta1.ReplicaSetStatus + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationSpec map: fields: - - name: availableReplicas + - name: limited type: - scalar: numeric + namedType: io.k8s.api.flowcontrol.v1alpha1.LimitedPriorityLevelConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: limited + discriminatorValue: Limited +- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationStatus + map: + fields: - name: conditions type: list: elementType: - namedType: io.k8s.api.extensions.v1beta1.ReplicaSetCondition + namedType: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationCondition elementRelationship: associative keys: - type - - name: fullyLabeledReplicas - type: - scalar: numeric - - name: observedGeneration - type: - scalar: numeric - - name: readyReplicas +- name: io.k8s.api.flowcontrol.v1alpha1.QueuingConfiguration + map: + fields: + - name: handSize type: scalar: numeric - - name: replicas + default: 0 + - name: queueLengthLimit type: scalar: numeric default: 0 -- name: io.k8s.api.extensions.v1beta1.RollbackConfig - map: - fields: - - name: revision + - name: queues type: scalar: numeric -- name: io.k8s.api.extensions.v1beta1.RollingUpdateDaemonSet - map: - fields: - - name: maxSurge - type: - namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString - - name: maxUnavailable - type: - namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString -- name: io.k8s.api.extensions.v1beta1.RollingUpdateDeployment - map: - fields: - - name: maxSurge - type: - namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString - - name: maxUnavailable - type: - namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString -- name: io.k8s.api.extensions.v1beta1.RunAsGroupStrategyOptions + default: 0 +- name: io.k8s.api.flowcontrol.v1alpha1.ResourcePolicyRule map: fields: - - name: ranges + - name: apiGroups type: list: elementType: - namedType: io.k8s.api.extensions.v1beta1.IDRange - elementRelationship: atomic - - name: rule + scalar: string + elementRelationship: associative + - name: clusterScope type: - scalar: string - default: "" -- name: io.k8s.api.extensions.v1beta1.RunAsUserStrategyOptions - map: - fields: - - name: ranges + scalar: boolean + - name: namespaces type: list: elementType: - namedType: io.k8s.api.extensions.v1beta1.IDRange - elementRelationship: atomic - - name: rule + scalar: string + elementRelationship: associative + - name: resources type: - scalar: string - default: "" -- name: io.k8s.api.extensions.v1beta1.RuntimeClassStrategyOptions - map: - fields: - - name: allowedRuntimeClassNames + list: + elementType: + scalar: string + elementRelationship: associative + - name: verbs type: list: elementType: scalar: string - elementRelationship: atomic - - name: defaultRuntimeClassName + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1alpha1.ServiceAccountSubject + map: + fields: + - name: name type: scalar: string -- name: io.k8s.api.extensions.v1beta1.SELinuxStrategyOptions + default: "" + - name: namespace + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1alpha1.Subject map: fields: - - name: rule + - name: group + type: + namedType: io.k8s.api.flowcontrol.v1alpha1.GroupSubject + - name: kind type: scalar: string default: "" - - name: seLinuxOptions + - name: serviceAccount type: - namedType: io.k8s.api.core.v1.SELinuxOptions -- name: io.k8s.api.extensions.v1beta1.SupplementalGroupsStrategyOptions + namedType: io.k8s.api.flowcontrol.v1alpha1.ServiceAccountSubject + - name: user + type: + namedType: io.k8s.api.flowcontrol.v1alpha1.UserSubject + unions: + - discriminator: kind + fields: + - fieldName: group + discriminatorValue: Group + - fieldName: serviceAccount + discriminatorValue: ServiceAccount + - fieldName: user + discriminatorValue: User +- name: io.k8s.api.flowcontrol.v1alpha1.UserSubject map: fields: - - name: ranges - type: - list: - elementType: - namedType: io.k8s.api.extensions.v1beta1.IDRange - elementRelationship: atomic - - name: rule + - name: name type: scalar: string -- name: io.k8s.api.flowcontrol.v1alpha1.FlowDistinguisherMethod + default: "" +- name: io.k8s.api.flowcontrol.v1beta1.FlowDistinguisherMethod map: fields: - name: type type: scalar: string default: "" -- name: io.k8s.api.flowcontrol.v1alpha1.FlowSchema +- name: io.k8s.api.flowcontrol.v1beta1.FlowSchema map: fields: - name: apiVersion @@ -7801,13 +8542,13 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaSpec + namedType: io.k8s.api.flowcontrol.v1beta1.FlowSchemaSpec default: {} - name: status type: - namedType: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaStatus + namedType: io.k8s.api.flowcontrol.v1beta1.FlowSchemaStatus default: {} -- name: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaCondition +- name: io.k8s.api.flowcontrol.v1beta1.FlowSchemaCondition map: fields: - name: lastTransitionTime @@ -7826,50 +8567,50 @@ var schemaYAML = typed.YAMLObject(`types: - name: type type: scalar: string -- name: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaSpec +- name: io.k8s.api.flowcontrol.v1beta1.FlowSchemaSpec map: fields: - name: distinguisherMethod type: - namedType: io.k8s.api.flowcontrol.v1alpha1.FlowDistinguisherMethod + namedType: io.k8s.api.flowcontrol.v1beta1.FlowDistinguisherMethod - name: matchingPrecedence type: scalar: numeric default: 0 - name: priorityLevelConfiguration type: - namedType: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationReference + namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationReference default: {} - name: rules type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1alpha1.PolicyRulesWithSubjects + namedType: io.k8s.api.flowcontrol.v1beta1.PolicyRulesWithSubjects elementRelationship: atomic -- name: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaStatus +- name: io.k8s.api.flowcontrol.v1beta1.FlowSchemaStatus map: fields: - name: conditions type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1alpha1.FlowSchemaCondition + namedType: io.k8s.api.flowcontrol.v1beta1.FlowSchemaCondition elementRelationship: associative keys: - type -- name: io.k8s.api.flowcontrol.v1alpha1.GroupSubject +- name: io.k8s.api.flowcontrol.v1beta1.GroupSubject map: fields: - name: name type: scalar: string default: "" -- name: io.k8s.api.flowcontrol.v1alpha1.LimitResponse +- name: io.k8s.api.flowcontrol.v1beta1.LimitResponse map: fields: - name: queuing type: - namedType: io.k8s.api.flowcontrol.v1alpha1.QueuingConfiguration + namedType: io.k8s.api.flowcontrol.v1beta1.QueuingConfiguration - name: type type: scalar: string @@ -7879,7 +8620,7 @@ var schemaYAML = typed.YAMLObject(`types: fields: - fieldName: queuing discriminatorValue: Queuing -- name: io.k8s.api.flowcontrol.v1alpha1.LimitedPriorityLevelConfiguration +- name: io.k8s.api.flowcontrol.v1beta1.LimitedPriorityLevelConfiguration map: fields: - name: assuredConcurrencyShares @@ -7888,9 +8629,9 @@ var schemaYAML = typed.YAMLObject(`types: default: 0 - name: limitResponse type: - namedType: io.k8s.api.flowcontrol.v1alpha1.LimitResponse + namedType: io.k8s.api.flowcontrol.v1beta1.LimitResponse default: {} -- name: io.k8s.api.flowcontrol.v1alpha1.NonResourcePolicyRule +- name: io.k8s.api.flowcontrol.v1beta1.NonResourcePolicyRule map: fields: - name: nonResourceURLs @@ -7905,28 +8646,28 @@ var schemaYAML = typed.YAMLObject(`types: elementType: scalar: string elementRelationship: associative -- name: io.k8s.api.flowcontrol.v1alpha1.PolicyRulesWithSubjects +- name: io.k8s.api.flowcontrol.v1beta1.PolicyRulesWithSubjects map: fields: - name: nonResourceRules type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1alpha1.NonResourcePolicyRule + namedType: io.k8s.api.flowcontrol.v1beta1.NonResourcePolicyRule elementRelationship: atomic - name: resourceRules type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1alpha1.ResourcePolicyRule + namedType: io.k8s.api.flowcontrol.v1beta1.ResourcePolicyRule elementRelationship: atomic - name: subjects type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1alpha1.Subject + namedType: io.k8s.api.flowcontrol.v1beta1.Subject elementRelationship: atomic -- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfiguration +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfiguration map: fields: - name: apiVersion @@ -7941,13 +8682,13 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationSpec + namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationSpec default: {} - name: status type: - namedType: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationStatus + namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationStatus default: {} -- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationCondition +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationCondition map: fields: - name: lastTransitionTime @@ -7966,19 +8707,19 @@ var schemaYAML = typed.YAMLObject(`types: - name: type type: scalar: string -- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationReference +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationReference map: fields: - name: name type: scalar: string default: "" -- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationSpec +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationSpec map: fields: - name: limited type: - namedType: io.k8s.api.flowcontrol.v1alpha1.LimitedPriorityLevelConfiguration + namedType: io.k8s.api.flowcontrol.v1beta1.LimitedPriorityLevelConfiguration - name: type type: scalar: string @@ -7988,18 +8729,18 @@ var schemaYAML = typed.YAMLObject(`types: fields: - fieldName: limited discriminatorValue: Limited -- name: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationStatus +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationStatus map: fields: - name: conditions type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationCondition + namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationCondition elementRelationship: associative keys: - type -- name: io.k8s.api.flowcontrol.v1alpha1.QueuingConfiguration +- name: io.k8s.api.flowcontrol.v1beta1.QueuingConfiguration map: fields: - name: handSize @@ -8014,7 +8755,7 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: numeric default: 0 -- name: io.k8s.api.flowcontrol.v1alpha1.ResourcePolicyRule +- name: io.k8s.api.flowcontrol.v1beta1.ResourcePolicyRule map: fields: - name: apiGroups @@ -8044,7 +8785,7 @@ var schemaYAML = typed.YAMLObject(`types: elementType: scalar: string elementRelationship: associative -- name: io.k8s.api.flowcontrol.v1alpha1.ServiceAccountSubject +- name: io.k8s.api.flowcontrol.v1beta1.ServiceAccountSubject map: fields: - name: name @@ -8055,22 +8796,22 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.flowcontrol.v1alpha1.Subject +- name: io.k8s.api.flowcontrol.v1beta1.Subject map: fields: - name: group type: - namedType: io.k8s.api.flowcontrol.v1alpha1.GroupSubject + namedType: io.k8s.api.flowcontrol.v1beta1.GroupSubject - name: kind type: scalar: string default: "" - name: serviceAccount type: - namedType: io.k8s.api.flowcontrol.v1alpha1.ServiceAccountSubject + namedType: io.k8s.api.flowcontrol.v1beta1.ServiceAccountSubject - name: user type: - namedType: io.k8s.api.flowcontrol.v1alpha1.UserSubject + namedType: io.k8s.api.flowcontrol.v1beta1.UserSubject unions: - discriminator: kind fields: @@ -8080,21 +8821,21 @@ var schemaYAML = typed.YAMLObject(`types: discriminatorValue: ServiceAccount - fieldName: user discriminatorValue: User -- name: io.k8s.api.flowcontrol.v1alpha1.UserSubject +- name: io.k8s.api.flowcontrol.v1beta1.UserSubject map: fields: - name: name type: scalar: string default: "" -- name: io.k8s.api.flowcontrol.v1beta1.FlowDistinguisherMethod +- name: io.k8s.api.flowcontrol.v1beta2.FlowDistinguisherMethod map: fields: - name: type type: scalar: string default: "" -- name: io.k8s.api.flowcontrol.v1beta1.FlowSchema +- name: io.k8s.api.flowcontrol.v1beta2.FlowSchema map: fields: - name: apiVersion @@ -8109,13 +8850,13 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.flowcontrol.v1beta1.FlowSchemaSpec + namedType: io.k8s.api.flowcontrol.v1beta2.FlowSchemaSpec default: {} - name: status type: - namedType: io.k8s.api.flowcontrol.v1beta1.FlowSchemaStatus + namedType: io.k8s.api.flowcontrol.v1beta2.FlowSchemaStatus default: {} -- name: io.k8s.api.flowcontrol.v1beta1.FlowSchemaCondition +- name: io.k8s.api.flowcontrol.v1beta2.FlowSchemaCondition map: fields: - name: lastTransitionTime @@ -8134,50 +8875,50 @@ var schemaYAML = typed.YAMLObject(`types: - name: type type: scalar: string -- name: io.k8s.api.flowcontrol.v1beta1.FlowSchemaSpec +- name: io.k8s.api.flowcontrol.v1beta2.FlowSchemaSpec map: fields: - name: distinguisherMethod type: - namedType: io.k8s.api.flowcontrol.v1beta1.FlowDistinguisherMethod + namedType: io.k8s.api.flowcontrol.v1beta2.FlowDistinguisherMethod - name: matchingPrecedence type: scalar: numeric default: 0 - name: priorityLevelConfiguration type: - namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationReference + namedType: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationReference default: {} - name: rules type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1beta1.PolicyRulesWithSubjects + namedType: io.k8s.api.flowcontrol.v1beta2.PolicyRulesWithSubjects elementRelationship: atomic -- name: io.k8s.api.flowcontrol.v1beta1.FlowSchemaStatus +- name: io.k8s.api.flowcontrol.v1beta2.FlowSchemaStatus map: fields: - name: conditions type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1beta1.FlowSchemaCondition + namedType: io.k8s.api.flowcontrol.v1beta2.FlowSchemaCondition elementRelationship: associative keys: - type -- name: io.k8s.api.flowcontrol.v1beta1.GroupSubject +- name: io.k8s.api.flowcontrol.v1beta2.GroupSubject map: fields: - name: name type: scalar: string default: "" -- name: io.k8s.api.flowcontrol.v1beta1.LimitResponse +- name: io.k8s.api.flowcontrol.v1beta2.LimitResponse map: fields: - name: queuing type: - namedType: io.k8s.api.flowcontrol.v1beta1.QueuingConfiguration + namedType: io.k8s.api.flowcontrol.v1beta2.QueuingConfiguration - name: type type: scalar: string @@ -8187,7 +8928,7 @@ var schemaYAML = typed.YAMLObject(`types: fields: - fieldName: queuing discriminatorValue: Queuing -- name: io.k8s.api.flowcontrol.v1beta1.LimitedPriorityLevelConfiguration +- name: io.k8s.api.flowcontrol.v1beta2.LimitedPriorityLevelConfiguration map: fields: - name: assuredConcurrencyShares @@ -8196,9 +8937,9 @@ var schemaYAML = typed.YAMLObject(`types: default: 0 - name: limitResponse type: - namedType: io.k8s.api.flowcontrol.v1beta1.LimitResponse + namedType: io.k8s.api.flowcontrol.v1beta2.LimitResponse default: {} -- name: io.k8s.api.flowcontrol.v1beta1.NonResourcePolicyRule +- name: io.k8s.api.flowcontrol.v1beta2.NonResourcePolicyRule map: fields: - name: nonResourceURLs @@ -8213,28 +8954,28 @@ var schemaYAML = typed.YAMLObject(`types: elementType: scalar: string elementRelationship: associative -- name: io.k8s.api.flowcontrol.v1beta1.PolicyRulesWithSubjects +- name: io.k8s.api.flowcontrol.v1beta2.PolicyRulesWithSubjects map: fields: - name: nonResourceRules type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1beta1.NonResourcePolicyRule + namedType: io.k8s.api.flowcontrol.v1beta2.NonResourcePolicyRule elementRelationship: atomic - name: resourceRules type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1beta1.ResourcePolicyRule + namedType: io.k8s.api.flowcontrol.v1beta2.ResourcePolicyRule elementRelationship: atomic - name: subjects type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1beta1.Subject + namedType: io.k8s.api.flowcontrol.v1beta2.Subject elementRelationship: atomic -- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfiguration +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfiguration map: fields: - name: apiVersion @@ -8249,13 +8990,13 @@ var schemaYAML = typed.YAMLObject(`types: default: {} - name: spec type: - namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationSpec + namedType: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationSpec default: {} - name: status type: - namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationStatus + namedType: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationStatus default: {} -- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationCondition +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationCondition map: fields: - name: lastTransitionTime @@ -8274,19 +9015,19 @@ var schemaYAML = typed.YAMLObject(`types: - name: type type: scalar: string -- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationReference +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationReference map: fields: - name: name type: scalar: string default: "" -- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationSpec +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationSpec map: fields: - name: limited type: - namedType: io.k8s.api.flowcontrol.v1beta1.LimitedPriorityLevelConfiguration + namedType: io.k8s.api.flowcontrol.v1beta2.LimitedPriorityLevelConfiguration - name: type type: scalar: string @@ -8296,18 +9037,18 @@ var schemaYAML = typed.YAMLObject(`types: fields: - fieldName: limited discriminatorValue: Limited -- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationStatus +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationStatus map: fields: - name: conditions type: list: elementType: - namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationCondition + namedType: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationCondition elementRelationship: associative keys: - type -- name: io.k8s.api.flowcontrol.v1beta1.QueuingConfiguration +- name: io.k8s.api.flowcontrol.v1beta2.QueuingConfiguration map: fields: - name: handSize @@ -8322,7 +9063,7 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: numeric default: 0 -- name: io.k8s.api.flowcontrol.v1beta1.ResourcePolicyRule +- name: io.k8s.api.flowcontrol.v1beta2.ResourcePolicyRule map: fields: - name: apiGroups @@ -8352,7 +9093,7 @@ var schemaYAML = typed.YAMLObject(`types: elementType: scalar: string elementRelationship: associative -- name: io.k8s.api.flowcontrol.v1beta1.ServiceAccountSubject +- name: io.k8s.api.flowcontrol.v1beta2.ServiceAccountSubject map: fields: - name: name @@ -8363,22 +9104,22 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" -- name: io.k8s.api.flowcontrol.v1beta1.Subject +- name: io.k8s.api.flowcontrol.v1beta2.Subject map: fields: - name: group type: - namedType: io.k8s.api.flowcontrol.v1beta1.GroupSubject + namedType: io.k8s.api.flowcontrol.v1beta2.GroupSubject - name: kind type: scalar: string default: "" - name: serviceAccount type: - namedType: io.k8s.api.flowcontrol.v1beta1.ServiceAccountSubject + namedType: io.k8s.api.flowcontrol.v1beta2.ServiceAccountSubject - name: user type: - namedType: io.k8s.api.flowcontrol.v1beta1.UserSubject + namedType: io.k8s.api.flowcontrol.v1beta2.UserSubject unions: - discriminator: kind fields: @@ -8388,7 +9129,7 @@ var schemaYAML = typed.YAMLObject(`types: discriminatorValue: ServiceAccount - fieldName: user discriminatorValue: User -- name: io.k8s.api.flowcontrol.v1beta1.UserSubject +- name: io.k8s.api.flowcontrol.v1beta2.UserSubject map: fields: - name: name @@ -10647,8 +11388,8 @@ var schemaYAML = typed.YAMLObject(`types: elementRelationship: atomic map: elementType: - namedType: __untyped_atomic_ - elementRelationship: atomic + namedType: __untyped_deduced_ + elementRelationship: separable - name: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector map: fields: @@ -10821,8 +11562,8 @@ var schemaYAML = typed.YAMLObject(`types: elementRelationship: atomic map: elementType: - namedType: __untyped_atomic_ - elementRelationship: atomic + namedType: __untyped_deduced_ + elementRelationship: separable - name: io.k8s.apimachinery.pkg.util.intstr.IntOrString scalar: untyped - name: __untyped_atomic_ diff --git a/vendor/k8s.io/client-go/applyconfigurations/meta/v1/unstructured.go b/vendor/k8s.io/client-go/applyconfigurations/meta/v1/unstructured.go new file mode 100644 index 0000000000..8a58d9e870 --- /dev/null +++ b/vendor/k8s.io/client-go/applyconfigurations/meta/v1/unstructured.go @@ -0,0 +1,137 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1 + +import ( + "fmt" + "sync" + "time" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/util/managedfields" + "k8s.io/client-go/discovery" + "k8s.io/kube-openapi/pkg/util/proto" + "sigs.k8s.io/structured-merge-diff/v4/typed" +) + +// openAPISchemaTTL is how frequently we need to check +// whether the open API schema has changed or not. +const openAPISchemaTTL = time.Minute + +// UnstructuredExtractor enables extracting the applied configuration state from object for fieldManager into an +// unstructured object type. +type UnstructuredExtractor interface { + Extract(object *unstructured.Unstructured, fieldManager string) (*unstructured.Unstructured, error) + ExtractStatus(object *unstructured.Unstructured, fieldManager string) (*unstructured.Unstructured, error) +} + +// gvkParserCache caches the GVKParser in order to prevent from having to repeatedly +// parse the models from the open API schema when the schema itself changes infrequently. +type gvkParserCache struct { + // discoveryClient is the client for retrieving the openAPI document and checking + // whether the document has changed recently + discoveryClient discovery.DiscoveryInterface + // mu protects the gvkParser + mu sync.Mutex + // gvkParser retrieves the objectType for a given gvk + gvkParser *managedfields.GvkParser + // lastChecked is the last time we checked if the openAPI doc has changed. + lastChecked time.Time +} + +// regenerateGVKParser builds the parser from the raw OpenAPI schema. +func regenerateGVKParser(dc discovery.DiscoveryInterface) (*managedfields.GvkParser, error) { + doc, err := dc.OpenAPISchema() + if err != nil { + return nil, err + } + + models, err := proto.NewOpenAPIData(doc) + if err != nil { + return nil, err + } + + return managedfields.NewGVKParser(models, false) +} + +// objectTypeForGVK retrieves the typed.ParseableType for a given gvk from the cache +func (c *gvkParserCache) objectTypeForGVK(gvk schema.GroupVersionKind) (*typed.ParseableType, error) { + c.mu.Lock() + defer c.mu.Unlock() + // if the ttl on the openAPISchema has expired, + // regenerate the gvk parser + if time.Since(c.lastChecked) > openAPISchemaTTL { + c.lastChecked = time.Now() + parser, err := regenerateGVKParser(c.discoveryClient) + if err != nil { + return nil, err + } + c.gvkParser = parser + } + return c.gvkParser.Type(gvk), nil +} + +type extractor struct { + cache *gvkParserCache +} + +// NewUnstructuredExtractor creates the extractor with which you can extract the applied configuration +// for a given manager from an unstructured object. +func NewUnstructuredExtractor(dc discovery.DiscoveryInterface) (UnstructuredExtractor, error) { + parser, err := regenerateGVKParser(dc) + if err != nil { + return nil, fmt.Errorf("failed generating initial GVK Parser: %v", err) + } + return &extractor{ + cache: &gvkParserCache{ + gvkParser: parser, + discoveryClient: dc, + }, + }, nil +} + +// Extract extracts the applied configuration owned by fieldManager from an unstructured object. +// Note that the apply configuration itself is also an unstructured object. +func (e *extractor) Extract(object *unstructured.Unstructured, fieldManager string) (*unstructured.Unstructured, error) { + return e.extractUnstructured(object, fieldManager, "") +} + +// ExtractStatus is the same as ExtractUnstructured except +// that it extracts the status subresource applied configuration. +// Experimental! +func (e *extractor) ExtractStatus(object *unstructured.Unstructured, fieldManager string) (*unstructured.Unstructured, error) { + return e.extractUnstructured(object, fieldManager, "status") +} + +func (e *extractor) extractUnstructured(object *unstructured.Unstructured, fieldManager string, subresource string) (*unstructured.Unstructured, error) { + gvk := object.GetObjectKind().GroupVersionKind() + objectType, err := e.cache.objectTypeForGVK(gvk) + if err != nil { + return nil, fmt.Errorf("failed to fetch the objectType: %v", err) + } + result := &unstructured.Unstructured{} + err = managedfields.ExtractInto(object, *objectType, fieldManager, result, subresource) + if err != nil { + return nil, fmt.Errorf("failed calling ExtractInto for unstructured: %v", err) + } + result.SetName(object.GetName()) + result.SetNamespace(object.GetNamespace()) + result.SetKind(object.GetKind()) + result.SetAPIVersion(object.GetAPIVersion()) + return result, nil +} diff --git a/vendor/k8s.io/client-go/discovery/discovery_client.go b/vendor/k8s.io/client-go/discovery/discovery_client.go index 87de32970e..50e59c5d85 100644 --- a/vendor/k8s.io/client-go/discovery/discovery_client.go +++ b/vendor/k8s.io/client-go/discovery/discovery_client.go @@ -20,13 +20,14 @@ import ( "context" "encoding/json" "fmt" + "net/http" "net/url" "sort" "strings" "sync" "time" - //lint:ignore SA1019 Keep using module since it's still being maintained and the api of google.golang.org/protobuf/proto differs + //nolint:staticcheck // SA1019 Keep using module since it's still being maintained and the api of google.golang.org/protobuf/proto differs "github.com/golang/protobuf/proto" openapi_v2 "github.com/googleapis/gnostic/openapiv2" @@ -482,12 +483,29 @@ func setDiscoveryDefaults(config *restclient.Config) error { // NewDiscoveryClientForConfig creates a new DiscoveryClient for the given config. This client // can be used to discover supported resources in the API server. +// NewDiscoveryClientForConfig is equivalent to NewDiscoveryClientForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewDiscoveryClientForConfig(c *restclient.Config) (*DiscoveryClient, error) { config := *c if err := setDiscoveryDefaults(&config); err != nil { return nil, err } - client, err := restclient.UnversionedRESTClientFor(&config) + httpClient, err := restclient.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewDiscoveryClientForConfigAndClient(&config, httpClient) +} + +// NewDiscoveryClientForConfigAndClient creates a new DiscoveryClient for the given config. This client +// can be used to discover supported resources in the API server. +// Note the http client provided takes precedence over the configured transport values. +func NewDiscoveryClientForConfigAndClient(c *restclient.Config, httpClient *http.Client) (*DiscoveryClient, error) { + config := *c + if err := setDiscoveryDefaults(&config); err != nil { + return nil, err + } + client, err := restclient.UnversionedRESTClientForConfigAndClient(&config, httpClient) return &DiscoveryClient{restClient: client, LegacyPrefix: "/api"}, err } diff --git a/vendor/k8s.io/client-go/dynamic/simple.go b/vendor/k8s.io/client-go/dynamic/simple.go index 9ae320d301..87594bf2e1 100644 --- a/vendor/k8s.io/client-go/dynamic/simple.go +++ b/vendor/k8s.io/client-go/dynamic/simple.go @@ -19,6 +19,7 @@ package dynamic import ( "context" "fmt" + "net/http" "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -60,17 +61,30 @@ func NewForConfigOrDie(c *rest.Config) Interface { } // NewForConfig creates a new dynamic client or returns an error. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(inConfig *rest.Config) (Interface, error) { config := ConfigFor(inConfig) + + httpClient, err := rest.HTTPClientFor(config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(config, httpClient) +} + +// NewForConfigAndClient creates a new dynamic client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(inConfig *rest.Config, h *http.Client) (Interface, error) { + config := ConfigFor(inConfig) // for serializing the options config.GroupVersion = &schema.GroupVersion{} config.APIPath = "/if-you-see-this-search-for-the-break" - restClient, err := rest.RESTClientFor(config) + restClient, err := rest.RESTClientForConfigAndClient(config, h) if err != nil { return nil, err } - return &dynamicClient{client: restClient}, nil } @@ -110,6 +124,7 @@ func (c *dynamicResourceClient) Create(ctx context.Context, obj *unstructured.Un result := c.client.client. Post(). AbsPath(append(c.makeURLSegments(name), subresources...)...). + SetHeader("Content-Type", runtime.ContentTypeJSON). Body(outBytes). SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1). Do(ctx) @@ -145,6 +160,7 @@ func (c *dynamicResourceClient) Update(ctx context.Context, obj *unstructured.Un result := c.client.client. Put(). AbsPath(append(c.makeURLSegments(name), subresources...)...). + SetHeader("Content-Type", runtime.ContentTypeJSON). Body(outBytes). SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1). Do(ctx) @@ -181,6 +197,7 @@ func (c *dynamicResourceClient) UpdateStatus(ctx context.Context, obj *unstructu result := c.client.client. Put(). AbsPath(append(c.makeURLSegments(name), "status")...). + SetHeader("Content-Type", runtime.ContentTypeJSON). Body(outBytes). SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1). Do(ctx) @@ -211,6 +228,7 @@ func (c *dynamicResourceClient) Delete(ctx context.Context, name string, opts me result := c.client.client. Delete(). AbsPath(append(c.makeURLSegments(name), subresources...)...). + SetHeader("Content-Type", runtime.ContentTypeJSON). Body(deleteOptionsByte). Do(ctx) return result.Error() @@ -225,6 +243,7 @@ func (c *dynamicResourceClient) DeleteCollection(ctx context.Context, opts metav result := c.client.client. Delete(). AbsPath(c.makeURLSegments("")...). + SetHeader("Content-Type", runtime.ContentTypeJSON). Body(deleteOptionsByte). SpecificallyVersionedParams(&listOptions, dynamicParameterCodec, versionV1). Do(ctx) diff --git a/vendor/k8s.io/client-go/informers/autoscaling/interface.go b/vendor/k8s.io/client-go/informers/autoscaling/interface.go index 81e8390147..2b3b2d0e50 100644 --- a/vendor/k8s.io/client-go/informers/autoscaling/interface.go +++ b/vendor/k8s.io/client-go/informers/autoscaling/interface.go @@ -20,6 +20,7 @@ package autoscaling import ( v1 "k8s.io/client-go/informers/autoscaling/v1" + v2 "k8s.io/client-go/informers/autoscaling/v2" v2beta1 "k8s.io/client-go/informers/autoscaling/v2beta1" v2beta2 "k8s.io/client-go/informers/autoscaling/v2beta2" internalinterfaces "k8s.io/client-go/informers/internalinterfaces" @@ -29,6 +30,8 @@ import ( type Interface interface { // V1 provides access to shared informers for resources in V1. V1() v1.Interface + // V2 provides access to shared informers for resources in V2. + V2() v2.Interface // V2beta1 provides access to shared informers for resources in V2beta1. V2beta1() v2beta1.Interface // V2beta2 provides access to shared informers for resources in V2beta2. @@ -51,6 +54,11 @@ func (g *group) V1() v1.Interface { return v1.New(g.factory, g.namespace, g.tweakListOptions) } +// V2 returns a new v2.Interface. +func (g *group) V2() v2.Interface { + return v2.New(g.factory, g.namespace, g.tweakListOptions) +} + // V2beta1 returns a new v2beta1.Interface. func (g *group) V2beta1() v2beta1.Interface { return v2beta1.New(g.factory, g.namespace, g.tweakListOptions) diff --git a/vendor/k8s.io/client-go/informers/autoscaling/v2/horizontalpodautoscaler.go b/vendor/k8s.io/client-go/informers/autoscaling/v2/horizontalpodautoscaler.go new file mode 100644 index 0000000000..5ddb3b015f --- /dev/null +++ b/vendor/k8s.io/client-go/informers/autoscaling/v2/horizontalpodautoscaler.go @@ -0,0 +1,90 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package v2 + +import ( + "context" + time "time" + + autoscalingv2 "k8s.io/api/autoscaling/v2" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + internalinterfaces "k8s.io/client-go/informers/internalinterfaces" + kubernetes "k8s.io/client-go/kubernetes" + v2 "k8s.io/client-go/listers/autoscaling/v2" + cache "k8s.io/client-go/tools/cache" +) + +// HorizontalPodAutoscalerInformer provides access to a shared informer and lister for +// HorizontalPodAutoscalers. +type HorizontalPodAutoscalerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v2.HorizontalPodAutoscalerLister +} + +type horizontalPodAutoscalerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc + namespace string +} + +// NewHorizontalPodAutoscalerInformer constructs a new informer for HorizontalPodAutoscaler type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewHorizontalPodAutoscalerInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredHorizontalPodAutoscalerInformer(client, namespace, resyncPeriod, indexers, nil) +} + +// NewFilteredHorizontalPodAutoscalerInformer constructs a new informer for HorizontalPodAutoscaler type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredHorizontalPodAutoscalerInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options v1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.AutoscalingV2().HorizontalPodAutoscalers(namespace).List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.AutoscalingV2().HorizontalPodAutoscalers(namespace).Watch(context.TODO(), options) + }, + }, + &autoscalingv2.HorizontalPodAutoscaler{}, + resyncPeriod, + indexers, + ) +} + +func (f *horizontalPodAutoscalerInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredHorizontalPodAutoscalerInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *horizontalPodAutoscalerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&autoscalingv2.HorizontalPodAutoscaler{}, f.defaultInformer) +} + +func (f *horizontalPodAutoscalerInformer) Lister() v2.HorizontalPodAutoscalerLister { + return v2.NewHorizontalPodAutoscalerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/k8s.io/client-go/informers/autoscaling/v2/interface.go b/vendor/k8s.io/client-go/informers/autoscaling/v2/interface.go new file mode 100644 index 0000000000..2c71908e40 --- /dev/null +++ b/vendor/k8s.io/client-go/informers/autoscaling/v2/interface.go @@ -0,0 +1,45 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package v2 + +import ( + internalinterfaces "k8s.io/client-go/informers/internalinterfaces" +) + +// Interface provides access to all the informers in this group version. +type Interface interface { + // HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer. + HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer +} + +type version struct { + factory internalinterfaces.SharedInformerFactory + namespace string + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// New returns a new Interface. +func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface { + return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions} +} + +// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer. +func (v *version) HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer { + return &horizontalPodAutoscalerInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} +} diff --git a/vendor/k8s.io/client-go/informers/flowcontrol/interface.go b/vendor/k8s.io/client-go/informers/flowcontrol/interface.go index b04ca59d3c..828a7bc8bc 100644 --- a/vendor/k8s.io/client-go/informers/flowcontrol/interface.go +++ b/vendor/k8s.io/client-go/informers/flowcontrol/interface.go @@ -21,6 +21,7 @@ package flowcontrol import ( v1alpha1 "k8s.io/client-go/informers/flowcontrol/v1alpha1" v1beta1 "k8s.io/client-go/informers/flowcontrol/v1beta1" + v1beta2 "k8s.io/client-go/informers/flowcontrol/v1beta2" internalinterfaces "k8s.io/client-go/informers/internalinterfaces" ) @@ -30,6 +31,8 @@ type Interface interface { V1alpha1() v1alpha1.Interface // V1beta1 provides access to shared informers for resources in V1beta1. V1beta1() v1beta1.Interface + // V1beta2 provides access to shared informers for resources in V1beta2. + V1beta2() v1beta2.Interface } type group struct { @@ -52,3 +55,8 @@ func (g *group) V1alpha1() v1alpha1.Interface { func (g *group) V1beta1() v1beta1.Interface { return v1beta1.New(g.factory, g.namespace, g.tweakListOptions) } + +// V1beta2 returns a new v1beta2.Interface. +func (g *group) V1beta2() v1beta2.Interface { + return v1beta2.New(g.factory, g.namespace, g.tweakListOptions) +} diff --git a/vendor/k8s.io/client-go/informers/flowcontrol/v1beta2/flowschema.go b/vendor/k8s.io/client-go/informers/flowcontrol/v1beta2/flowschema.go new file mode 100644 index 0000000000..6f6abecea8 --- /dev/null +++ b/vendor/k8s.io/client-go/informers/flowcontrol/v1beta2/flowschema.go @@ -0,0 +1,89 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package v1beta2 + +import ( + "context" + time "time" + + flowcontrolv1beta2 "k8s.io/api/flowcontrol/v1beta2" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + internalinterfaces "k8s.io/client-go/informers/internalinterfaces" + kubernetes "k8s.io/client-go/kubernetes" + v1beta2 "k8s.io/client-go/listers/flowcontrol/v1beta2" + cache "k8s.io/client-go/tools/cache" +) + +// FlowSchemaInformer provides access to a shared informer and lister for +// FlowSchemas. +type FlowSchemaInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1beta2.FlowSchemaLister +} + +type flowSchemaInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewFlowSchemaInformer constructs a new informer for FlowSchema type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFlowSchemaInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredFlowSchemaInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredFlowSchemaInformer constructs a new informer for FlowSchema type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredFlowSchemaInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options v1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.FlowcontrolV1beta2().FlowSchemas().List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.FlowcontrolV1beta2().FlowSchemas().Watch(context.TODO(), options) + }, + }, + &flowcontrolv1beta2.FlowSchema{}, + resyncPeriod, + indexers, + ) +} + +func (f *flowSchemaInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredFlowSchemaInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *flowSchemaInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&flowcontrolv1beta2.FlowSchema{}, f.defaultInformer) +} + +func (f *flowSchemaInformer) Lister() v1beta2.FlowSchemaLister { + return v1beta2.NewFlowSchemaLister(f.Informer().GetIndexer()) +} diff --git a/vendor/k8s.io/client-go/informers/flowcontrol/v1beta2/interface.go b/vendor/k8s.io/client-go/informers/flowcontrol/v1beta2/interface.go new file mode 100644 index 0000000000..142d552896 --- /dev/null +++ b/vendor/k8s.io/client-go/informers/flowcontrol/v1beta2/interface.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package v1beta2 + +import ( + internalinterfaces "k8s.io/client-go/informers/internalinterfaces" +) + +// Interface provides access to all the informers in this group version. +type Interface interface { + // FlowSchemas returns a FlowSchemaInformer. + FlowSchemas() FlowSchemaInformer + // PriorityLevelConfigurations returns a PriorityLevelConfigurationInformer. + PriorityLevelConfigurations() PriorityLevelConfigurationInformer +} + +type version struct { + factory internalinterfaces.SharedInformerFactory + namespace string + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// New returns a new Interface. +func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface { + return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions} +} + +// FlowSchemas returns a FlowSchemaInformer. +func (v *version) FlowSchemas() FlowSchemaInformer { + return &flowSchemaInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// PriorityLevelConfigurations returns a PriorityLevelConfigurationInformer. +func (v *version) PriorityLevelConfigurations() PriorityLevelConfigurationInformer { + return &priorityLevelConfigurationInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} diff --git a/vendor/k8s.io/client-go/informers/flowcontrol/v1beta2/prioritylevelconfiguration.go b/vendor/k8s.io/client-go/informers/flowcontrol/v1beta2/prioritylevelconfiguration.go new file mode 100644 index 0000000000..306a901851 --- /dev/null +++ b/vendor/k8s.io/client-go/informers/flowcontrol/v1beta2/prioritylevelconfiguration.go @@ -0,0 +1,89 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package v1beta2 + +import ( + "context" + time "time" + + flowcontrolv1beta2 "k8s.io/api/flowcontrol/v1beta2" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + internalinterfaces "k8s.io/client-go/informers/internalinterfaces" + kubernetes "k8s.io/client-go/kubernetes" + v1beta2 "k8s.io/client-go/listers/flowcontrol/v1beta2" + cache "k8s.io/client-go/tools/cache" +) + +// PriorityLevelConfigurationInformer provides access to a shared informer and lister for +// PriorityLevelConfigurations. +type PriorityLevelConfigurationInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1beta2.PriorityLevelConfigurationLister +} + +type priorityLevelConfigurationInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewPriorityLevelConfigurationInformer constructs a new informer for PriorityLevelConfiguration type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewPriorityLevelConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredPriorityLevelConfigurationInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredPriorityLevelConfigurationInformer constructs a new informer for PriorityLevelConfiguration type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredPriorityLevelConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options v1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.FlowcontrolV1beta2().PriorityLevelConfigurations().List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.FlowcontrolV1beta2().PriorityLevelConfigurations().Watch(context.TODO(), options) + }, + }, + &flowcontrolv1beta2.PriorityLevelConfiguration{}, + resyncPeriod, + indexers, + ) +} + +func (f *priorityLevelConfigurationInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredPriorityLevelConfigurationInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *priorityLevelConfigurationInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&flowcontrolv1beta2.PriorityLevelConfiguration{}, f.defaultInformer) +} + +func (f *priorityLevelConfigurationInformer) Lister() v1beta2.PriorityLevelConfigurationLister { + return v1beta2.NewPriorityLevelConfigurationLister(f.Informer().GetIndexer()) +} diff --git a/vendor/k8s.io/client-go/informers/generic.go b/vendor/k8s.io/client-go/informers/generic.go index aede51a5e6..5b94a2d2a3 100644 --- a/vendor/k8s.io/client-go/informers/generic.go +++ b/vendor/k8s.io/client-go/informers/generic.go @@ -28,6 +28,7 @@ import ( appsv1beta1 "k8s.io/api/apps/v1beta1" v1beta2 "k8s.io/api/apps/v1beta2" autoscalingv1 "k8s.io/api/autoscaling/v1" + v2 "k8s.io/api/autoscaling/v2" v2beta1 "k8s.io/api/autoscaling/v2beta1" v2beta2 "k8s.io/api/autoscaling/v2beta2" batchv1 "k8s.io/api/batch/v1" @@ -44,6 +45,7 @@ import ( extensionsv1beta1 "k8s.io/api/extensions/v1beta1" v1alpha1 "k8s.io/api/flowcontrol/v1alpha1" flowcontrolv1beta1 "k8s.io/api/flowcontrol/v1beta1" + flowcontrolv1beta2 "k8s.io/api/flowcontrol/v1beta2" networkingv1 "k8s.io/api/networking/v1" networkingv1beta1 "k8s.io/api/networking/v1beta1" nodev1 "k8s.io/api/node/v1" @@ -138,6 +140,10 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource case autoscalingv1.SchemeGroupVersion.WithResource("horizontalpodautoscalers"): return &genericInformer{resource: resource.GroupResource(), informer: f.Autoscaling().V1().HorizontalPodAutoscalers().Informer()}, nil + // Group=autoscaling, Version=v2 + case v2.SchemeGroupVersion.WithResource("horizontalpodautoscalers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Autoscaling().V2().HorizontalPodAutoscalers().Informer()}, nil + // Group=autoscaling, Version=v2beta1 case v2beta1.SchemeGroupVersion.WithResource("horizontalpodautoscalers"): return &genericInformer{resource: resource.GroupResource(), informer: f.Autoscaling().V2beta1().HorizontalPodAutoscalers().Informer()}, nil @@ -248,6 +254,12 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource case flowcontrolv1beta1.SchemeGroupVersion.WithResource("prioritylevelconfigurations"): return &genericInformer{resource: resource.GroupResource(), informer: f.Flowcontrol().V1beta1().PriorityLevelConfigurations().Informer()}, nil + // Group=flowcontrol.apiserver.k8s.io, Version=v1beta2 + case flowcontrolv1beta2.SchemeGroupVersion.WithResource("flowschemas"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Flowcontrol().V1beta2().FlowSchemas().Informer()}, nil + case flowcontrolv1beta2.SchemeGroupVersion.WithResource("prioritylevelconfigurations"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Flowcontrol().V1beta2().PriorityLevelConfigurations().Informer()}, nil + // Group=internal.apiserver.k8s.io, Version=v1alpha1 case apiserverinternalv1alpha1.SchemeGroupVersion.WithResource("storageversions"): return &genericInformer{resource: resource.GroupResource(), informer: f.Internal().V1alpha1().StorageVersions().Informer()}, nil diff --git a/vendor/k8s.io/client-go/kubernetes/clientset.go b/vendor/k8s.io/client-go/kubernetes/clientset.go index 55a236fac5..3e512a7c2e 100644 --- a/vendor/k8s.io/client-go/kubernetes/clientset.go +++ b/vendor/k8s.io/client-go/kubernetes/clientset.go @@ -20,6 +20,7 @@ package kubernetes import ( "fmt" + "net/http" discovery "k8s.io/client-go/discovery" admissionregistrationv1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1" @@ -33,6 +34,7 @@ import ( authorizationv1 "k8s.io/client-go/kubernetes/typed/authorization/v1" authorizationv1beta1 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1" autoscalingv1 "k8s.io/client-go/kubernetes/typed/autoscaling/v1" + autoscalingv2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2" autoscalingv2beta1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1" autoscalingv2beta2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2" batchv1 "k8s.io/client-go/kubernetes/typed/batch/v1" @@ -49,6 +51,7 @@ import ( extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1" flowcontrolv1alpha1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1" flowcontrolv1beta1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1" + flowcontrolv1beta2 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2" networkingv1 "k8s.io/client-go/kubernetes/typed/networking/v1" networkingv1beta1 "k8s.io/client-go/kubernetes/typed/networking/v1beta1" nodev1 "k8s.io/client-go/kubernetes/typed/node/v1" @@ -82,6 +85,7 @@ type Interface interface { AuthorizationV1() authorizationv1.AuthorizationV1Interface AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface AutoscalingV1() autoscalingv1.AutoscalingV1Interface + AutoscalingV2() autoscalingv2.AutoscalingV2Interface AutoscalingV2beta1() autoscalingv2beta1.AutoscalingV2beta1Interface AutoscalingV2beta2() autoscalingv2beta2.AutoscalingV2beta2Interface BatchV1() batchv1.BatchV1Interface @@ -98,6 +102,7 @@ type Interface interface { ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface FlowcontrolV1alpha1() flowcontrolv1alpha1.FlowcontrolV1alpha1Interface FlowcontrolV1beta1() flowcontrolv1beta1.FlowcontrolV1beta1Interface + FlowcontrolV1beta2() flowcontrolv1beta2.FlowcontrolV1beta2Interface NetworkingV1() networkingv1.NetworkingV1Interface NetworkingV1beta1() networkingv1beta1.NetworkingV1beta1Interface NodeV1() nodev1.NodeV1Interface @@ -131,6 +136,7 @@ type Clientset struct { authorizationV1 *authorizationv1.AuthorizationV1Client authorizationV1beta1 *authorizationv1beta1.AuthorizationV1beta1Client autoscalingV1 *autoscalingv1.AutoscalingV1Client + autoscalingV2 *autoscalingv2.AutoscalingV2Client autoscalingV2beta1 *autoscalingv2beta1.AutoscalingV2beta1Client autoscalingV2beta2 *autoscalingv2beta2.AutoscalingV2beta2Client batchV1 *batchv1.BatchV1Client @@ -147,6 +153,7 @@ type Clientset struct { extensionsV1beta1 *extensionsv1beta1.ExtensionsV1beta1Client flowcontrolV1alpha1 *flowcontrolv1alpha1.FlowcontrolV1alpha1Client flowcontrolV1beta1 *flowcontrolv1beta1.FlowcontrolV1beta1Client + flowcontrolV1beta2 *flowcontrolv1beta2.FlowcontrolV1beta2Client networkingV1 *networkingv1.NetworkingV1Client networkingV1beta1 *networkingv1beta1.NetworkingV1beta1Client nodeV1 *nodev1.NodeV1Client @@ -220,6 +227,11 @@ func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface { return c.autoscalingV1 } +// AutoscalingV2 retrieves the AutoscalingV2Client +func (c *Clientset) AutoscalingV2() autoscalingv2.AutoscalingV2Interface { + return c.autoscalingV2 +} + // AutoscalingV2beta1 retrieves the AutoscalingV2beta1Client func (c *Clientset) AutoscalingV2beta1() autoscalingv2beta1.AutoscalingV2beta1Interface { return c.autoscalingV2beta1 @@ -300,6 +312,11 @@ func (c *Clientset) FlowcontrolV1beta1() flowcontrolv1beta1.FlowcontrolV1beta1In return c.flowcontrolV1beta1 } +// FlowcontrolV1beta2 retrieves the FlowcontrolV1beta2Client +func (c *Clientset) FlowcontrolV1beta2() flowcontrolv1beta2.FlowcontrolV1beta2Interface { + return c.flowcontrolV1beta2 +} + // NetworkingV1 retrieves the NetworkingV1Client func (c *Clientset) NetworkingV1() networkingv1.NetworkingV1Interface { return c.networkingV1 @@ -391,190 +408,217 @@ func (c *Clientset) Discovery() discovery.DiscoveryInterface { // NewForConfig creates a new Clientset for the given config. // If config's RateLimiter is not set and QPS and Burst are acceptable, // NewForConfig will generate a rate-limiter in configShallowCopy. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*Clientset, error) { configShallowCopy := *c + + // share the transport between all clients + httpClient, err := rest.HTTPClientFor(&configShallowCopy) + if err != nil { + return nil, err + } + + return NewForConfigAndClient(&configShallowCopy, httpClient) +} + +// NewForConfigAndClient creates a new Clientset for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +// If config's RateLimiter is not set and QPS and Burst are acceptable, +// NewForConfigAndClient will generate a rate-limiter in configShallowCopy. +func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset, error) { + configShallowCopy := *c if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 { if configShallowCopy.Burst <= 0 { return nil, fmt.Errorf("burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0") } configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst) } + var cs Clientset var err error - cs.admissionregistrationV1, err = admissionregistrationv1.NewForConfig(&configShallowCopy) + cs.admissionregistrationV1, err = admissionregistrationv1.NewForConfigAndClient(&configShallowCopy, httpClient) + if err != nil { + return nil, err + } + cs.admissionregistrationV1beta1, err = admissionregistrationv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) + if err != nil { + return nil, err + } + cs.internalV1alpha1, err = internalv1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.admissionregistrationV1beta1, err = admissionregistrationv1beta1.NewForConfig(&configShallowCopy) + cs.appsV1, err = appsv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.internalV1alpha1, err = internalv1alpha1.NewForConfig(&configShallowCopy) + cs.appsV1beta1, err = appsv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.appsV1, err = appsv1.NewForConfig(&configShallowCopy) + cs.appsV1beta2, err = appsv1beta2.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.appsV1beta1, err = appsv1beta1.NewForConfig(&configShallowCopy) + cs.authenticationV1, err = authenticationv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.appsV1beta2, err = appsv1beta2.NewForConfig(&configShallowCopy) + cs.authenticationV1beta1, err = authenticationv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.authenticationV1, err = authenticationv1.NewForConfig(&configShallowCopy) + cs.authorizationV1, err = authorizationv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.authenticationV1beta1, err = authenticationv1beta1.NewForConfig(&configShallowCopy) + cs.authorizationV1beta1, err = authorizationv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.authorizationV1, err = authorizationv1.NewForConfig(&configShallowCopy) + cs.autoscalingV1, err = autoscalingv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.authorizationV1beta1, err = authorizationv1beta1.NewForConfig(&configShallowCopy) + cs.autoscalingV2, err = autoscalingv2.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.autoscalingV1, err = autoscalingv1.NewForConfig(&configShallowCopy) + cs.autoscalingV2beta1, err = autoscalingv2beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.autoscalingV2beta1, err = autoscalingv2beta1.NewForConfig(&configShallowCopy) + cs.autoscalingV2beta2, err = autoscalingv2beta2.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.autoscalingV2beta2, err = autoscalingv2beta2.NewForConfig(&configShallowCopy) + cs.batchV1, err = batchv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.batchV1, err = batchv1.NewForConfig(&configShallowCopy) + cs.batchV1beta1, err = batchv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.batchV1beta1, err = batchv1beta1.NewForConfig(&configShallowCopy) + cs.certificatesV1, err = certificatesv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.certificatesV1, err = certificatesv1.NewForConfig(&configShallowCopy) + cs.certificatesV1beta1, err = certificatesv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.certificatesV1beta1, err = certificatesv1beta1.NewForConfig(&configShallowCopy) + cs.coordinationV1beta1, err = coordinationv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.coordinationV1beta1, err = coordinationv1beta1.NewForConfig(&configShallowCopy) + cs.coordinationV1, err = coordinationv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.coordinationV1, err = coordinationv1.NewForConfig(&configShallowCopy) + cs.coreV1, err = corev1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.coreV1, err = corev1.NewForConfig(&configShallowCopy) + cs.discoveryV1, err = discoveryv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.discoveryV1, err = discoveryv1.NewForConfig(&configShallowCopy) + cs.discoveryV1beta1, err = discoveryv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.discoveryV1beta1, err = discoveryv1beta1.NewForConfig(&configShallowCopy) + cs.eventsV1, err = eventsv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.eventsV1, err = eventsv1.NewForConfig(&configShallowCopy) + cs.eventsV1beta1, err = eventsv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.eventsV1beta1, err = eventsv1beta1.NewForConfig(&configShallowCopy) + cs.extensionsV1beta1, err = extensionsv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.extensionsV1beta1, err = extensionsv1beta1.NewForConfig(&configShallowCopy) + cs.flowcontrolV1alpha1, err = flowcontrolv1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.flowcontrolV1alpha1, err = flowcontrolv1alpha1.NewForConfig(&configShallowCopy) + cs.flowcontrolV1beta1, err = flowcontrolv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.flowcontrolV1beta1, err = flowcontrolv1beta1.NewForConfig(&configShallowCopy) + cs.flowcontrolV1beta2, err = flowcontrolv1beta2.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.networkingV1, err = networkingv1.NewForConfig(&configShallowCopy) + cs.networkingV1, err = networkingv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.networkingV1beta1, err = networkingv1beta1.NewForConfig(&configShallowCopy) + cs.networkingV1beta1, err = networkingv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.nodeV1, err = nodev1.NewForConfig(&configShallowCopy) + cs.nodeV1, err = nodev1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.nodeV1alpha1, err = nodev1alpha1.NewForConfig(&configShallowCopy) + cs.nodeV1alpha1, err = nodev1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.nodeV1beta1, err = nodev1beta1.NewForConfig(&configShallowCopy) + cs.nodeV1beta1, err = nodev1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.policyV1, err = policyv1.NewForConfig(&configShallowCopy) + cs.policyV1, err = policyv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.policyV1beta1, err = policyv1beta1.NewForConfig(&configShallowCopy) + cs.policyV1beta1, err = policyv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.rbacV1, err = rbacv1.NewForConfig(&configShallowCopy) + cs.rbacV1, err = rbacv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.rbacV1beta1, err = rbacv1beta1.NewForConfig(&configShallowCopy) + cs.rbacV1beta1, err = rbacv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.rbacV1alpha1, err = rbacv1alpha1.NewForConfig(&configShallowCopy) + cs.rbacV1alpha1, err = rbacv1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.schedulingV1alpha1, err = schedulingv1alpha1.NewForConfig(&configShallowCopy) + cs.schedulingV1alpha1, err = schedulingv1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.schedulingV1beta1, err = schedulingv1beta1.NewForConfig(&configShallowCopy) + cs.schedulingV1beta1, err = schedulingv1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.schedulingV1, err = schedulingv1.NewForConfig(&configShallowCopy) + cs.schedulingV1, err = schedulingv1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.storageV1beta1, err = storagev1beta1.NewForConfig(&configShallowCopy) + cs.storageV1beta1, err = storagev1beta1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.storageV1, err = storagev1.NewForConfig(&configShallowCopy) + cs.storageV1, err = storagev1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.storageV1alpha1, err = storagev1alpha1.NewForConfig(&configShallowCopy) + cs.storageV1alpha1, err = storagev1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } - cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy) + cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfigAndClient(&configShallowCopy, httpClient) if err != nil { return nil, err } @@ -584,53 +628,11 @@ func NewForConfig(c *rest.Config) (*Clientset, error) { // NewForConfigOrDie creates a new Clientset for the given config and // panics if there is an error in the config. func NewForConfigOrDie(c *rest.Config) *Clientset { - var cs Clientset - cs.admissionregistrationV1 = admissionregistrationv1.NewForConfigOrDie(c) - cs.admissionregistrationV1beta1 = admissionregistrationv1beta1.NewForConfigOrDie(c) - cs.internalV1alpha1 = internalv1alpha1.NewForConfigOrDie(c) - cs.appsV1 = appsv1.NewForConfigOrDie(c) - cs.appsV1beta1 = appsv1beta1.NewForConfigOrDie(c) - cs.appsV1beta2 = appsv1beta2.NewForConfigOrDie(c) - cs.authenticationV1 = authenticationv1.NewForConfigOrDie(c) - cs.authenticationV1beta1 = authenticationv1beta1.NewForConfigOrDie(c) - cs.authorizationV1 = authorizationv1.NewForConfigOrDie(c) - cs.authorizationV1beta1 = authorizationv1beta1.NewForConfigOrDie(c) - cs.autoscalingV1 = autoscalingv1.NewForConfigOrDie(c) - cs.autoscalingV2beta1 = autoscalingv2beta1.NewForConfigOrDie(c) - cs.autoscalingV2beta2 = autoscalingv2beta2.NewForConfigOrDie(c) - cs.batchV1 = batchv1.NewForConfigOrDie(c) - cs.batchV1beta1 = batchv1beta1.NewForConfigOrDie(c) - cs.certificatesV1 = certificatesv1.NewForConfigOrDie(c) - cs.certificatesV1beta1 = certificatesv1beta1.NewForConfigOrDie(c) - cs.coordinationV1beta1 = coordinationv1beta1.NewForConfigOrDie(c) - cs.coordinationV1 = coordinationv1.NewForConfigOrDie(c) - cs.coreV1 = corev1.NewForConfigOrDie(c) - cs.discoveryV1 = discoveryv1.NewForConfigOrDie(c) - cs.discoveryV1beta1 = discoveryv1beta1.NewForConfigOrDie(c) - cs.eventsV1 = eventsv1.NewForConfigOrDie(c) - cs.eventsV1beta1 = eventsv1beta1.NewForConfigOrDie(c) - cs.extensionsV1beta1 = extensionsv1beta1.NewForConfigOrDie(c) - cs.flowcontrolV1alpha1 = flowcontrolv1alpha1.NewForConfigOrDie(c) - cs.flowcontrolV1beta1 = flowcontrolv1beta1.NewForConfigOrDie(c) - cs.networkingV1 = networkingv1.NewForConfigOrDie(c) - cs.networkingV1beta1 = networkingv1beta1.NewForConfigOrDie(c) - cs.nodeV1 = nodev1.NewForConfigOrDie(c) - cs.nodeV1alpha1 = nodev1alpha1.NewForConfigOrDie(c) - cs.nodeV1beta1 = nodev1beta1.NewForConfigOrDie(c) - cs.policyV1 = policyv1.NewForConfigOrDie(c) - cs.policyV1beta1 = policyv1beta1.NewForConfigOrDie(c) - cs.rbacV1 = rbacv1.NewForConfigOrDie(c) - cs.rbacV1beta1 = rbacv1beta1.NewForConfigOrDie(c) - cs.rbacV1alpha1 = rbacv1alpha1.NewForConfigOrDie(c) - cs.schedulingV1alpha1 = schedulingv1alpha1.NewForConfigOrDie(c) - cs.schedulingV1beta1 = schedulingv1beta1.NewForConfigOrDie(c) - cs.schedulingV1 = schedulingv1.NewForConfigOrDie(c) - cs.storageV1beta1 = storagev1beta1.NewForConfigOrDie(c) - cs.storageV1 = storagev1.NewForConfigOrDie(c) - cs.storageV1alpha1 = storagev1alpha1.NewForConfigOrDie(c) - - cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) - return &cs + cs, err := NewForConfig(c) + if err != nil { + panic(err) + } + return cs } // New creates a new Clientset for the given RESTClient. @@ -647,6 +649,7 @@ func New(c rest.Interface) *Clientset { cs.authorizationV1 = authorizationv1.New(c) cs.authorizationV1beta1 = authorizationv1beta1.New(c) cs.autoscalingV1 = autoscalingv1.New(c) + cs.autoscalingV2 = autoscalingv2.New(c) cs.autoscalingV2beta1 = autoscalingv2beta1.New(c) cs.autoscalingV2beta2 = autoscalingv2beta2.New(c) cs.batchV1 = batchv1.New(c) @@ -663,6 +666,7 @@ func New(c rest.Interface) *Clientset { cs.extensionsV1beta1 = extensionsv1beta1.New(c) cs.flowcontrolV1alpha1 = flowcontrolv1alpha1.New(c) cs.flowcontrolV1beta1 = flowcontrolv1beta1.New(c) + cs.flowcontrolV1beta2 = flowcontrolv1beta2.New(c) cs.networkingV1 = networkingv1.New(c) cs.networkingV1beta1 = networkingv1beta1.New(c) cs.nodeV1 = nodev1.New(c) diff --git a/vendor/k8s.io/client-go/kubernetes/scheme/register.go b/vendor/k8s.io/client-go/kubernetes/scheme/register.go index a46fb29629..b41466151d 100644 --- a/vendor/k8s.io/client-go/kubernetes/scheme/register.go +++ b/vendor/k8s.io/client-go/kubernetes/scheme/register.go @@ -30,6 +30,7 @@ import ( authorizationv1 "k8s.io/api/authorization/v1" authorizationv1beta1 "k8s.io/api/authorization/v1beta1" autoscalingv1 "k8s.io/api/autoscaling/v1" + autoscalingv2 "k8s.io/api/autoscaling/v2" autoscalingv2beta1 "k8s.io/api/autoscaling/v2beta1" autoscalingv2beta2 "k8s.io/api/autoscaling/v2beta2" batchv1 "k8s.io/api/batch/v1" @@ -46,6 +47,7 @@ import ( extensionsv1beta1 "k8s.io/api/extensions/v1beta1" flowcontrolv1alpha1 "k8s.io/api/flowcontrol/v1alpha1" flowcontrolv1beta1 "k8s.io/api/flowcontrol/v1beta1" + flowcontrolv1beta2 "k8s.io/api/flowcontrol/v1beta2" networkingv1 "k8s.io/api/networking/v1" networkingv1beta1 "k8s.io/api/networking/v1beta1" nodev1 "k8s.io/api/node/v1" @@ -84,6 +86,7 @@ var localSchemeBuilder = runtime.SchemeBuilder{ authorizationv1.AddToScheme, authorizationv1beta1.AddToScheme, autoscalingv1.AddToScheme, + autoscalingv2.AddToScheme, autoscalingv2beta1.AddToScheme, autoscalingv2beta2.AddToScheme, batchv1.AddToScheme, @@ -100,6 +103,7 @@ var localSchemeBuilder = runtime.SchemeBuilder{ extensionsv1beta1.AddToScheme, flowcontrolv1alpha1.AddToScheme, flowcontrolv1beta1.AddToScheme, + flowcontrolv1beta2.AddToScheme, networkingv1.AddToScheme, networkingv1beta1.AddToScheme, nodev1.AddToScheme, diff --git a/vendor/k8s.io/client-go/kubernetes/typed/admissionregistration/v1/admissionregistration_client.go b/vendor/k8s.io/client-go/kubernetes/typed/admissionregistration/v1/admissionregistration_client.go index 751273159e..10848bed17 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/admissionregistration/v1/admissionregistration_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/admissionregistration/v1/admissionregistration_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/admissionregistration/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -44,12 +46,28 @@ func (c *AdmissionregistrationV1Client) ValidatingWebhookConfigurations() Valida } // NewForConfig creates a new AdmissionregistrationV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AdmissionregistrationV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AdmissionregistrationV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AdmissionregistrationV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1/admissionregistration_client.go b/vendor/k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1/admissionregistration_client.go index 2d93ff02ee..8fda84b1d2 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1/admissionregistration_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1/admissionregistration_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/admissionregistration/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -44,12 +46,28 @@ func (c *AdmissionregistrationV1beta1Client) ValidatingWebhookConfigurations() V } // NewForConfig creates a new AdmissionregistrationV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AdmissionregistrationV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AdmissionregistrationV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AdmissionregistrationV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1/apiserverinternal_client.go b/vendor/k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1/apiserverinternal_client.go index e43a9a3687..1794cb941d 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1/apiserverinternal_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1/apiserverinternal_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1alpha1 import ( + "net/http" + v1alpha1 "k8s.io/api/apiserverinternal/v1alpha1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *InternalV1alpha1Client) StorageVersions() StorageVersionInterface { } // NewForConfig creates a new InternalV1alpha1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*InternalV1alpha1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new InternalV1alpha1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*InternalV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/apps/v1/apps_client.go b/vendor/k8s.io/client-go/kubernetes/typed/apps/v1/apps_client.go index 621c734afa..397542eeb4 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/apps/v1/apps_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/apps/v1/apps_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/apps/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -59,12 +61,28 @@ func (c *AppsV1Client) StatefulSets(namespace string) StatefulSetInterface { } // NewForConfig creates a new AppsV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AppsV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AppsV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AppsV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta1/apps_client.go b/vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta1/apps_client.go index e5dd64d983..6b7148c5a8 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta1/apps_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta1/apps_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/apps/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -49,12 +51,28 @@ func (c *AppsV1beta1Client) StatefulSets(namespace string) StatefulSetInterface } // NewForConfig creates a new AppsV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AppsV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AppsV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AppsV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta2/apps_client.go b/vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta2/apps_client.go index 7ca4e0b20d..968abc56f8 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta2/apps_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta2/apps_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta2 import ( + "net/http" + v1beta2 "k8s.io/api/apps/v1beta2" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -59,12 +61,28 @@ func (c *AppsV1beta2Client) StatefulSets(namespace string) StatefulSetInterface } // NewForConfig creates a new AppsV1beta2Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AppsV1beta2Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AppsV1beta2Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AppsV1beta2Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1/authentication_client.go b/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1/authentication_client.go index de8864e22a..aea9d0e133 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1/authentication_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1/authentication_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/authentication/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *AuthenticationV1Client) TokenReviews() TokenReviewInterface { } // NewForConfig creates a new AuthenticationV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AuthenticationV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AuthenticationV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AuthenticationV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1beta1/authentication_client.go b/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1beta1/authentication_client.go index 816bd0a2cd..218cb60c31 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1beta1/authentication_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/authentication/v1beta1/authentication_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/authentication/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *AuthenticationV1beta1Client) TokenReviews() TokenReviewInterface { } // NewForConfig creates a new AuthenticationV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AuthenticationV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AuthenticationV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AuthenticationV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/authorization/v1/authorization_client.go b/vendor/k8s.io/client-go/kubernetes/typed/authorization/v1/authorization_client.go index 2cc2263222..edfc90346a 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/authorization/v1/authorization_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/authorization/v1/authorization_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/authorization/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -54,12 +56,28 @@ func (c *AuthorizationV1Client) SubjectAccessReviews() SubjectAccessReviewInterf } // NewForConfig creates a new AuthorizationV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AuthorizationV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AuthorizationV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AuthorizationV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/authorization/v1beta1/authorization_client.go b/vendor/k8s.io/client-go/kubernetes/typed/authorization/v1beta1/authorization_client.go index 88eac75b76..23b0edf272 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/authorization/v1beta1/authorization_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/authorization/v1beta1/authorization_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/authorization/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -54,12 +56,28 @@ func (c *AuthorizationV1beta1Client) SubjectAccessReviews() SubjectAccessReviewI } // NewForConfig creates a new AuthorizationV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AuthorizationV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AuthorizationV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AuthorizationV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v1/autoscaling_client.go b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v1/autoscaling_client.go index 4f3e96aec5..f3a2752cbb 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v1/autoscaling_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v1/autoscaling_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/autoscaling/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *AutoscalingV1Client) HorizontalPodAutoscalers(namespace string) Horizon } // NewForConfig creates a new AutoscalingV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AutoscalingV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AutoscalingV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AutoscalingV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/autoscaling_client.go b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/autoscaling_client.go new file mode 100644 index 0000000000..04d5d0f949 --- /dev/null +++ b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/autoscaling_client.go @@ -0,0 +1,107 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package v2 + +import ( + "net/http" + + v2 "k8s.io/api/autoscaling/v2" + "k8s.io/client-go/kubernetes/scheme" + rest "k8s.io/client-go/rest" +) + +type AutoscalingV2Interface interface { + RESTClient() rest.Interface + HorizontalPodAutoscalersGetter +} + +// AutoscalingV2Client is used to interact with features provided by the autoscaling group. +type AutoscalingV2Client struct { + restClient rest.Interface +} + +func (c *AutoscalingV2Client) HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface { + return newHorizontalPodAutoscalers(c, namespace) +} + +// NewForConfig creates a new AutoscalingV2Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). +func NewForConfig(c *rest.Config) (*AutoscalingV2Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AutoscalingV2Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AutoscalingV2Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) + if err != nil { + return nil, err + } + return &AutoscalingV2Client{client}, nil +} + +// NewForConfigOrDie creates a new AutoscalingV2Client for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *AutoscalingV2Client { + client, err := NewForConfig(c) + if err != nil { + panic(err) + } + return client +} + +// New creates a new AutoscalingV2Client for the given RESTClient. +func New(c rest.Interface) *AutoscalingV2Client { + return &AutoscalingV2Client{c} +} + +func setConfigDefaults(config *rest.Config) error { + gv := v2.SchemeGroupVersion + config.GroupVersion = &gv + config.APIPath = "/apis" + config.NegotiatedSerializer = scheme.Codecs.WithoutConversion() + + if config.UserAgent == "" { + config.UserAgent = rest.DefaultKubernetesUserAgent() + } + + return nil +} + +// RESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *AutoscalingV2Client) RESTClient() rest.Interface { + if c == nil { + return nil + } + return c.restClient +} diff --git a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/doc.go b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/doc.go new file mode 100644 index 0000000000..86fb4bf582 --- /dev/null +++ b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/doc.go @@ -0,0 +1,20 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +// This package has the automatically generated typed clients. +package v2 diff --git a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/generated_expansion.go b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/generated_expansion.go new file mode 100644 index 0000000000..0470400fdf --- /dev/null +++ b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/generated_expansion.go @@ -0,0 +1,21 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package v2 + +type HorizontalPodAutoscalerExpansion interface{} diff --git a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/horizontalpodautoscaler.go b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/horizontalpodautoscaler.go new file mode 100644 index 0000000000..3a077d71da --- /dev/null +++ b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2/horizontalpodautoscaler.go @@ -0,0 +1,256 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package v2 + +import ( + "context" + json "encoding/json" + "fmt" + "time" + + v2 "k8s.io/api/autoscaling/v2" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + autoscalingv2 "k8s.io/client-go/applyconfigurations/autoscaling/v2" + scheme "k8s.io/client-go/kubernetes/scheme" + rest "k8s.io/client-go/rest" +) + +// HorizontalPodAutoscalersGetter has a method to return a HorizontalPodAutoscalerInterface. +// A group's client should implement this interface. +type HorizontalPodAutoscalersGetter interface { + HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface +} + +// HorizontalPodAutoscalerInterface has methods to work with HorizontalPodAutoscaler resources. +type HorizontalPodAutoscalerInterface interface { + Create(ctx context.Context, horizontalPodAutoscaler *v2.HorizontalPodAutoscaler, opts v1.CreateOptions) (*v2.HorizontalPodAutoscaler, error) + Update(ctx context.Context, horizontalPodAutoscaler *v2.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*v2.HorizontalPodAutoscaler, error) + UpdateStatus(ctx context.Context, horizontalPodAutoscaler *v2.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*v2.HorizontalPodAutoscaler, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v2.HorizontalPodAutoscaler, error) + List(ctx context.Context, opts v1.ListOptions) (*v2.HorizontalPodAutoscalerList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v2.HorizontalPodAutoscaler, err error) + Apply(ctx context.Context, horizontalPodAutoscaler *autoscalingv2.HorizontalPodAutoscalerApplyConfiguration, opts v1.ApplyOptions) (result *v2.HorizontalPodAutoscaler, err error) + ApplyStatus(ctx context.Context, horizontalPodAutoscaler *autoscalingv2.HorizontalPodAutoscalerApplyConfiguration, opts v1.ApplyOptions) (result *v2.HorizontalPodAutoscaler, err error) + HorizontalPodAutoscalerExpansion +} + +// horizontalPodAutoscalers implements HorizontalPodAutoscalerInterface +type horizontalPodAutoscalers struct { + client rest.Interface + ns string +} + +// newHorizontalPodAutoscalers returns a HorizontalPodAutoscalers +func newHorizontalPodAutoscalers(c *AutoscalingV2Client, namespace string) *horizontalPodAutoscalers { + return &horizontalPodAutoscalers{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the horizontalPodAutoscaler, and returns the corresponding horizontalPodAutoscaler object, and an error if there is any. +func (c *horizontalPodAutoscalers) Get(ctx context.Context, name string, options v1.GetOptions) (result *v2.HorizontalPodAutoscaler, err error) { + result = &v2.HorizontalPodAutoscaler{} + err = c.client.Get(). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of HorizontalPodAutoscalers that match those selectors. +func (c *horizontalPodAutoscalers) List(ctx context.Context, opts v1.ListOptions) (result *v2.HorizontalPodAutoscalerList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v2.HorizontalPodAutoscalerList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers. +func (c *horizontalPodAutoscalers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a horizontalPodAutoscaler and creates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if there is any. +func (c *horizontalPodAutoscalers) Create(ctx context.Context, horizontalPodAutoscaler *v2.HorizontalPodAutoscaler, opts v1.CreateOptions) (result *v2.HorizontalPodAutoscaler, err error) { + result = &v2.HorizontalPodAutoscaler{} + err = c.client.Post(). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(horizontalPodAutoscaler). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if there is any. +func (c *horizontalPodAutoscalers) Update(ctx context.Context, horizontalPodAutoscaler *v2.HorizontalPodAutoscaler, opts v1.UpdateOptions) (result *v2.HorizontalPodAutoscaler, err error) { + result = &v2.HorizontalPodAutoscaler{} + err = c.client.Put(). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + Name(horizontalPodAutoscaler.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(horizontalPodAutoscaler). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *horizontalPodAutoscalers) UpdateStatus(ctx context.Context, horizontalPodAutoscaler *v2.HorizontalPodAutoscaler, opts v1.UpdateOptions) (result *v2.HorizontalPodAutoscaler, err error) { + result = &v2.HorizontalPodAutoscaler{} + err = c.client.Put(). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + Name(horizontalPodAutoscaler.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(horizontalPodAutoscaler). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the horizontalPodAutoscaler and deletes it. Returns an error if one occurs. +func (c *horizontalPodAutoscalers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *horizontalPodAutoscalers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched horizontalPodAutoscaler. +func (c *horizontalPodAutoscalers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v2.HorizontalPodAutoscaler, err error) { + result = &v2.HorizontalPodAutoscaler{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// Apply takes the given apply declarative configuration, applies it and returns the applied horizontalPodAutoscaler. +func (c *horizontalPodAutoscalers) Apply(ctx context.Context, horizontalPodAutoscaler *autoscalingv2.HorizontalPodAutoscalerApplyConfiguration, opts v1.ApplyOptions) (result *v2.HorizontalPodAutoscaler, err error) { + if horizontalPodAutoscaler == nil { + return nil, fmt.Errorf("horizontalPodAutoscaler provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(horizontalPodAutoscaler) + if err != nil { + return nil, err + } + name := horizontalPodAutoscaler.Name + if name == nil { + return nil, fmt.Errorf("horizontalPodAutoscaler.Name must be provided to Apply") + } + result = &v2.HorizontalPodAutoscaler{} + err = c.client.Patch(types.ApplyPatchType). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + Name(*name). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// ApplyStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). +func (c *horizontalPodAutoscalers) ApplyStatus(ctx context.Context, horizontalPodAutoscaler *autoscalingv2.HorizontalPodAutoscalerApplyConfiguration, opts v1.ApplyOptions) (result *v2.HorizontalPodAutoscaler, err error) { + if horizontalPodAutoscaler == nil { + return nil, fmt.Errorf("horizontalPodAutoscaler provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(horizontalPodAutoscaler) + if err != nil { + return nil, err + } + + name := horizontalPodAutoscaler.Name + if name == nil { + return nil, fmt.Errorf("horizontalPodAutoscaler.Name must be provided to Apply") + } + + result = &v2.HorizontalPodAutoscaler{} + err = c.client.Patch(types.ApplyPatchType). + Namespace(c.ns). + Resource("horizontalpodautoscalers"). + Name(*name). + SubResource("status"). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1/autoscaling_client.go b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1/autoscaling_client.go index c1a91fc3e7..d1dde5ed1b 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1/autoscaling_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1/autoscaling_client.go @@ -19,6 +19,8 @@ limitations under the License. package v2beta1 import ( + "net/http" + v2beta1 "k8s.io/api/autoscaling/v2beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *AutoscalingV2beta1Client) HorizontalPodAutoscalers(namespace string) Ho } // NewForConfig creates a new AutoscalingV2beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AutoscalingV2beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AutoscalingV2beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AutoscalingV2beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2/autoscaling_client.go b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2/autoscaling_client.go index bd2b392701..cae1b4e43a 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2/autoscaling_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2/autoscaling_client.go @@ -19,6 +19,8 @@ limitations under the License. package v2beta2 import ( + "net/http" + v2beta2 "k8s.io/api/autoscaling/v2beta2" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *AutoscalingV2beta2Client) HorizontalPodAutoscalers(namespace string) Ho } // NewForConfig creates a new AutoscalingV2beta2Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*AutoscalingV2beta2Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new AutoscalingV2beta2Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*AutoscalingV2beta2Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/batch/v1/batch_client.go b/vendor/k8s.io/client-go/kubernetes/typed/batch/v1/batch_client.go index ba414eebc7..eee144f711 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/batch/v1/batch_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/batch/v1/batch_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/batch/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -44,12 +46,28 @@ func (c *BatchV1Client) Jobs(namespace string) JobInterface { } // NewForConfig creates a new BatchV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*BatchV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new BatchV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*BatchV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/batch/v1beta1/batch_client.go b/vendor/k8s.io/client-go/kubernetes/typed/batch/v1beta1/batch_client.go index 257085358e..ebbf063ec2 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/batch/v1beta1/batch_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/batch/v1beta1/batch_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/batch/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *BatchV1beta1Client) CronJobs(namespace string) CronJobInterface { } // NewForConfig creates a new BatchV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*BatchV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new BatchV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*BatchV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/certificates/v1/certificates_client.go b/vendor/k8s.io/client-go/kubernetes/typed/certificates/v1/certificates_client.go index 25aea93c79..6d87c539eb 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/certificates/v1/certificates_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/certificates/v1/certificates_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/certificates/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *CertificatesV1Client) CertificateSigningRequests() CertificateSigningRe } // NewForConfig creates a new CertificatesV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*CertificatesV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new CertificatesV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*CertificatesV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/certificates/v1beta1/certificates_client.go b/vendor/k8s.io/client-go/kubernetes/typed/certificates/v1beta1/certificates_client.go index 1c52d551b2..fa97b441de 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/certificates/v1beta1/certificates_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/certificates/v1beta1/certificates_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/certificates/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *CertificatesV1beta1Client) CertificateSigningRequests() CertificateSign } // NewForConfig creates a new CertificatesV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*CertificatesV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new CertificatesV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*CertificatesV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/coordination/v1/coordination_client.go b/vendor/k8s.io/client-go/kubernetes/typed/coordination/v1/coordination_client.go index 0df7b71bf2..e19469d530 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/coordination/v1/coordination_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/coordination/v1/coordination_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/coordination/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *CoordinationV1Client) Leases(namespace string) LeaseInterface { } // NewForConfig creates a new CoordinationV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*CoordinationV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new CoordinationV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*CoordinationV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/coordination/v1beta1/coordination_client.go b/vendor/k8s.io/client-go/kubernetes/typed/coordination/v1beta1/coordination_client.go index d68ed5d344..27d674e239 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/coordination/v1beta1/coordination_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/coordination/v1beta1/coordination_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/coordination/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *CoordinationV1beta1Client) Leases(namespace string) LeaseInterface { } // NewForConfig creates a new CoordinationV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*CoordinationV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new CoordinationV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*CoordinationV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/core/v1/core_client.go b/vendor/k8s.io/client-go/kubernetes/typed/core/v1/core_client.go index 428d2afa3b..6e59e4cc6b 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/core/v1/core_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/core/v1/core_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/core/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -114,12 +116,28 @@ func (c *CoreV1Client) ServiceAccounts(namespace string) ServiceAccountInterface } // NewForConfig creates a new CoreV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*CoreV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new CoreV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*CoreV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion.go b/vendor/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion.go index 211cf0603c..a3fdf57a98 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion.go @@ -34,6 +34,7 @@ type EventExpansion interface { CreateWithEventNamespace(event *v1.Event) (*v1.Event, error) // UpdateWithEventNamespace is the same as a Update, except that it sends the request to the event.Namespace. UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error) + // PatchWithEventNamespace is the same as a Patch, except that it sends the request to the event.Namespace. PatchWithEventNamespace(event *v1.Event, data []byte) (*v1.Event, error) // Search finds events about the specified object Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.EventList, error) @@ -66,6 +67,9 @@ func (e *events) CreateWithEventNamespace(event *v1.Event) (*v1.Event, error) { // created with the "" namespace. Update also requires the ResourceVersion to be set in the event // object. func (e *events) UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error) { + if e.ns != "" && event.Namespace != e.ns { + return nil, fmt.Errorf("can't update an event with namespace '%v' in namespace '%v'", event.Namespace, e.ns) + } result := &v1.Event{} err := e.client.Put(). NamespaceIfScoped(event.Namespace, len(event.Namespace) > 0). diff --git a/vendor/k8s.io/client-go/kubernetes/typed/discovery/v1/discovery_client.go b/vendor/k8s.io/client-go/kubernetes/typed/discovery/v1/discovery_client.go index cb26327626..9041443b38 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/discovery/v1/discovery_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/discovery/v1/discovery_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/discovery/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *DiscoveryV1Client) EndpointSlices(namespace string) EndpointSliceInterf } // NewForConfig creates a new DiscoveryV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*DiscoveryV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new DiscoveryV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*DiscoveryV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/discovery/v1beta1/discovery_client.go b/vendor/k8s.io/client-go/kubernetes/typed/discovery/v1beta1/discovery_client.go index 997239a950..193d5e9ebb 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/discovery/v1beta1/discovery_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/discovery/v1beta1/discovery_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/discovery/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *DiscoveryV1beta1Client) EndpointSlices(namespace string) EndpointSliceI } // NewForConfig creates a new DiscoveryV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*DiscoveryV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new DiscoveryV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*DiscoveryV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/events/v1/events_client.go b/vendor/k8s.io/client-go/kubernetes/typed/events/v1/events_client.go index 9230ca5ca7..8c73918d1c 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/events/v1/events_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/events/v1/events_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/events/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *EventsV1Client) Events(namespace string) EventInterface { } // NewForConfig creates a new EventsV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*EventsV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new EventsV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*EventsV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion.go b/vendor/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion.go index e0ae41dfe7..7213193bf1 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion.go @@ -33,7 +33,7 @@ type EventExpansion interface { // UpdateWithEventNamespace is the same as a Update // except that it sends the request to the event.Namespace. UpdateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error) - // PatchWithEventNamespace is the same as an Update + // PatchWithEventNamespace is the same as a Patch // except that it sends the request to the event.Namespace. PatchWithEventNamespace(event *v1beta1.Event, data []byte) (*v1beta1.Event, error) } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/events/v1beta1/events_client.go b/vendor/k8s.io/client-go/kubernetes/typed/events/v1beta1/events_client.go index e372ccffac..66506bf88e 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/events/v1beta1/events_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/events/v1beta1/events_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/events/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *EventsV1beta1Client) Events(namespace string) EventInterface { } // NewForConfig creates a new EventsV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*EventsV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new EventsV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*EventsV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1/extensions_client.go b/vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1/extensions_client.go index e3b22aa44c..827b514df6 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1/extensions_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1/extensions_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/extensions/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -64,12 +66,28 @@ func (c *ExtensionsV1beta1Client) ReplicaSets(namespace string) ReplicaSetInterf } // NewForConfig creates a new ExtensionsV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*ExtensionsV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new ExtensionsV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*ExtensionsV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1/flowcontrol_client.go b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1/flowcontrol_client.go index 37a1ff2d7b..c6f2d94056 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1/flowcontrol_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1/flowcontrol_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1alpha1 import ( + "net/http" + v1alpha1 "k8s.io/api/flowcontrol/v1alpha1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -44,12 +46,28 @@ func (c *FlowcontrolV1alpha1Client) PriorityLevelConfigurations() PriorityLevelC } // NewForConfig creates a new FlowcontrolV1alpha1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*FlowcontrolV1alpha1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new FlowcontrolV1alpha1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*FlowcontrolV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1/flowcontrol_client.go b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1/flowcontrol_client.go index 9a8ba560e6..c29cfca957 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1/flowcontrol_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1/flowcontrol_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/flowcontrol/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -44,12 +46,28 @@ func (c *FlowcontrolV1beta1Client) PriorityLevelConfigurations() PriorityLevelCo } // NewForConfig creates a new FlowcontrolV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*FlowcontrolV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new FlowcontrolV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*FlowcontrolV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/doc.go b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/doc.go new file mode 100644 index 0000000000..56518ef7f2 --- /dev/null +++ b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/doc.go @@ -0,0 +1,20 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +// This package has the automatically generated typed clients. +package v1beta2 diff --git a/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/flowcontrol_client.go b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/flowcontrol_client.go new file mode 100644 index 0000000000..f3cca4fc75 --- /dev/null +++ b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/flowcontrol_client.go @@ -0,0 +1,112 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package v1beta2 + +import ( + "net/http" + + v1beta2 "k8s.io/api/flowcontrol/v1beta2" + "k8s.io/client-go/kubernetes/scheme" + rest "k8s.io/client-go/rest" +) + +type FlowcontrolV1beta2Interface interface { + RESTClient() rest.Interface + FlowSchemasGetter + PriorityLevelConfigurationsGetter +} + +// FlowcontrolV1beta2Client is used to interact with features provided by the flowcontrol.apiserver.k8s.io group. +type FlowcontrolV1beta2Client struct { + restClient rest.Interface +} + +func (c *FlowcontrolV1beta2Client) FlowSchemas() FlowSchemaInterface { + return newFlowSchemas(c) +} + +func (c *FlowcontrolV1beta2Client) PriorityLevelConfigurations() PriorityLevelConfigurationInterface { + return newPriorityLevelConfigurations(c) +} + +// NewForConfig creates a new FlowcontrolV1beta2Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). +func NewForConfig(c *rest.Config) (*FlowcontrolV1beta2Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new FlowcontrolV1beta2Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*FlowcontrolV1beta2Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) + if err != nil { + return nil, err + } + return &FlowcontrolV1beta2Client{client}, nil +} + +// NewForConfigOrDie creates a new FlowcontrolV1beta2Client for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *FlowcontrolV1beta2Client { + client, err := NewForConfig(c) + if err != nil { + panic(err) + } + return client +} + +// New creates a new FlowcontrolV1beta2Client for the given RESTClient. +func New(c rest.Interface) *FlowcontrolV1beta2Client { + return &FlowcontrolV1beta2Client{c} +} + +func setConfigDefaults(config *rest.Config) error { + gv := v1beta2.SchemeGroupVersion + config.GroupVersion = &gv + config.APIPath = "/apis" + config.NegotiatedSerializer = scheme.Codecs.WithoutConversion() + + if config.UserAgent == "" { + config.UserAgent = rest.DefaultKubernetesUserAgent() + } + + return nil +} + +// RESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *FlowcontrolV1beta2Client) RESTClient() rest.Interface { + if c == nil { + return nil + } + return c.restClient +} diff --git a/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/flowschema.go b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/flowschema.go new file mode 100644 index 0000000000..3a1f12b6a2 --- /dev/null +++ b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/flowschema.go @@ -0,0 +1,243 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package v1beta2 + +import ( + "context" + json "encoding/json" + "fmt" + "time" + + v1beta2 "k8s.io/api/flowcontrol/v1beta2" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + flowcontrolv1beta2 "k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2" + scheme "k8s.io/client-go/kubernetes/scheme" + rest "k8s.io/client-go/rest" +) + +// FlowSchemasGetter has a method to return a FlowSchemaInterface. +// A group's client should implement this interface. +type FlowSchemasGetter interface { + FlowSchemas() FlowSchemaInterface +} + +// FlowSchemaInterface has methods to work with FlowSchema resources. +type FlowSchemaInterface interface { + Create(ctx context.Context, flowSchema *v1beta2.FlowSchema, opts v1.CreateOptions) (*v1beta2.FlowSchema, error) + Update(ctx context.Context, flowSchema *v1beta2.FlowSchema, opts v1.UpdateOptions) (*v1beta2.FlowSchema, error) + UpdateStatus(ctx context.Context, flowSchema *v1beta2.FlowSchema, opts v1.UpdateOptions) (*v1beta2.FlowSchema, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta2.FlowSchema, error) + List(ctx context.Context, opts v1.ListOptions) (*v1beta2.FlowSchemaList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta2.FlowSchema, err error) + Apply(ctx context.Context, flowSchema *flowcontrolv1beta2.FlowSchemaApplyConfiguration, opts v1.ApplyOptions) (result *v1beta2.FlowSchema, err error) + ApplyStatus(ctx context.Context, flowSchema *flowcontrolv1beta2.FlowSchemaApplyConfiguration, opts v1.ApplyOptions) (result *v1beta2.FlowSchema, err error) + FlowSchemaExpansion +} + +// flowSchemas implements FlowSchemaInterface +type flowSchemas struct { + client rest.Interface +} + +// newFlowSchemas returns a FlowSchemas +func newFlowSchemas(c *FlowcontrolV1beta2Client) *flowSchemas { + return &flowSchemas{ + client: c.RESTClient(), + } +} + +// Get takes name of the flowSchema, and returns the corresponding flowSchema object, and an error if there is any. +func (c *flowSchemas) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta2.FlowSchema, err error) { + result = &v1beta2.FlowSchema{} + err = c.client.Get(). + Resource("flowschemas"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of FlowSchemas that match those selectors. +func (c *flowSchemas) List(ctx context.Context, opts v1.ListOptions) (result *v1beta2.FlowSchemaList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1beta2.FlowSchemaList{} + err = c.client.Get(). + Resource("flowschemas"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested flowSchemas. +func (c *flowSchemas) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Resource("flowschemas"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a flowSchema and creates it. Returns the server's representation of the flowSchema, and an error, if there is any. +func (c *flowSchemas) Create(ctx context.Context, flowSchema *v1beta2.FlowSchema, opts v1.CreateOptions) (result *v1beta2.FlowSchema, err error) { + result = &v1beta2.FlowSchema{} + err = c.client.Post(). + Resource("flowschemas"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(flowSchema). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a flowSchema and updates it. Returns the server's representation of the flowSchema, and an error, if there is any. +func (c *flowSchemas) Update(ctx context.Context, flowSchema *v1beta2.FlowSchema, opts v1.UpdateOptions) (result *v1beta2.FlowSchema, err error) { + result = &v1beta2.FlowSchema{} + err = c.client.Put(). + Resource("flowschemas"). + Name(flowSchema.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(flowSchema). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *flowSchemas) UpdateStatus(ctx context.Context, flowSchema *v1beta2.FlowSchema, opts v1.UpdateOptions) (result *v1beta2.FlowSchema, err error) { + result = &v1beta2.FlowSchema{} + err = c.client.Put(). + Resource("flowschemas"). + Name(flowSchema.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(flowSchema). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the flowSchema and deletes it. Returns an error if one occurs. +func (c *flowSchemas) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Resource("flowschemas"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *flowSchemas) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("flowschemas"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched flowSchema. +func (c *flowSchemas) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta2.FlowSchema, err error) { + result = &v1beta2.FlowSchema{} + err = c.client.Patch(pt). + Resource("flowschemas"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// Apply takes the given apply declarative configuration, applies it and returns the applied flowSchema. +func (c *flowSchemas) Apply(ctx context.Context, flowSchema *flowcontrolv1beta2.FlowSchemaApplyConfiguration, opts v1.ApplyOptions) (result *v1beta2.FlowSchema, err error) { + if flowSchema == nil { + return nil, fmt.Errorf("flowSchema provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(flowSchema) + if err != nil { + return nil, err + } + name := flowSchema.Name + if name == nil { + return nil, fmt.Errorf("flowSchema.Name must be provided to Apply") + } + result = &v1beta2.FlowSchema{} + err = c.client.Patch(types.ApplyPatchType). + Resource("flowschemas"). + Name(*name). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// ApplyStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). +func (c *flowSchemas) ApplyStatus(ctx context.Context, flowSchema *flowcontrolv1beta2.FlowSchemaApplyConfiguration, opts v1.ApplyOptions) (result *v1beta2.FlowSchema, err error) { + if flowSchema == nil { + return nil, fmt.Errorf("flowSchema provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(flowSchema) + if err != nil { + return nil, err + } + + name := flowSchema.Name + if name == nil { + return nil, fmt.Errorf("flowSchema.Name must be provided to Apply") + } + + result = &v1beta2.FlowSchema{} + err = c.client.Patch(types.ApplyPatchType). + Resource("flowschemas"). + Name(*name). + SubResource("status"). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/counter/noop.go b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/generated_expansion.go similarity index 68% rename from vendor/k8s.io/apiserver/pkg/util/flowcontrol/counter/noop.go rename to vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/generated_expansion.go index fa946f6f08..1d4477006c 100644 --- a/vendor/k8s.io/apiserver/pkg/util/flowcontrol/counter/noop.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/generated_expansion.go @@ -1,5 +1,5 @@ /* -Copyright 2019 The Kubernetes Authors. +Copyright The Kubernetes Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -14,12 +14,10 @@ See the License for the specific language governing permissions and limitations under the License. */ -package counter +// Code generated by client-gen. DO NOT EDIT. -// NoOp is a GoRoutineCounter that does not actually count -type NoOp struct{} +package v1beta2 -var _ GoRoutineCounter = NoOp{} +type FlowSchemaExpansion interface{} -// Add would adjust the count, if a count were being kept -func (NoOp) Add(int) {} +type PriorityLevelConfigurationExpansion interface{} diff --git a/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/prioritylevelconfiguration.go b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/prioritylevelconfiguration.go new file mode 100644 index 0000000000..f028869f17 --- /dev/null +++ b/vendor/k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2/prioritylevelconfiguration.go @@ -0,0 +1,243 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package v1beta2 + +import ( + "context" + json "encoding/json" + "fmt" + "time" + + v1beta2 "k8s.io/api/flowcontrol/v1beta2" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + flowcontrolv1beta2 "k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2" + scheme "k8s.io/client-go/kubernetes/scheme" + rest "k8s.io/client-go/rest" +) + +// PriorityLevelConfigurationsGetter has a method to return a PriorityLevelConfigurationInterface. +// A group's client should implement this interface. +type PriorityLevelConfigurationsGetter interface { + PriorityLevelConfigurations() PriorityLevelConfigurationInterface +} + +// PriorityLevelConfigurationInterface has methods to work with PriorityLevelConfiguration resources. +type PriorityLevelConfigurationInterface interface { + Create(ctx context.Context, priorityLevelConfiguration *v1beta2.PriorityLevelConfiguration, opts v1.CreateOptions) (*v1beta2.PriorityLevelConfiguration, error) + Update(ctx context.Context, priorityLevelConfiguration *v1beta2.PriorityLevelConfiguration, opts v1.UpdateOptions) (*v1beta2.PriorityLevelConfiguration, error) + UpdateStatus(ctx context.Context, priorityLevelConfiguration *v1beta2.PriorityLevelConfiguration, opts v1.UpdateOptions) (*v1beta2.PriorityLevelConfiguration, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta2.PriorityLevelConfiguration, error) + List(ctx context.Context, opts v1.ListOptions) (*v1beta2.PriorityLevelConfigurationList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta2.PriorityLevelConfiguration, err error) + Apply(ctx context.Context, priorityLevelConfiguration *flowcontrolv1beta2.PriorityLevelConfigurationApplyConfiguration, opts v1.ApplyOptions) (result *v1beta2.PriorityLevelConfiguration, err error) + ApplyStatus(ctx context.Context, priorityLevelConfiguration *flowcontrolv1beta2.PriorityLevelConfigurationApplyConfiguration, opts v1.ApplyOptions) (result *v1beta2.PriorityLevelConfiguration, err error) + PriorityLevelConfigurationExpansion +} + +// priorityLevelConfigurations implements PriorityLevelConfigurationInterface +type priorityLevelConfigurations struct { + client rest.Interface +} + +// newPriorityLevelConfigurations returns a PriorityLevelConfigurations +func newPriorityLevelConfigurations(c *FlowcontrolV1beta2Client) *priorityLevelConfigurations { + return &priorityLevelConfigurations{ + client: c.RESTClient(), + } +} + +// Get takes name of the priorityLevelConfiguration, and returns the corresponding priorityLevelConfiguration object, and an error if there is any. +func (c *priorityLevelConfigurations) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta2.PriorityLevelConfiguration, err error) { + result = &v1beta2.PriorityLevelConfiguration{} + err = c.client.Get(). + Resource("prioritylevelconfigurations"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of PriorityLevelConfigurations that match those selectors. +func (c *priorityLevelConfigurations) List(ctx context.Context, opts v1.ListOptions) (result *v1beta2.PriorityLevelConfigurationList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1beta2.PriorityLevelConfigurationList{} + err = c.client.Get(). + Resource("prioritylevelconfigurations"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested priorityLevelConfigurations. +func (c *priorityLevelConfigurations) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Resource("prioritylevelconfigurations"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a priorityLevelConfiguration and creates it. Returns the server's representation of the priorityLevelConfiguration, and an error, if there is any. +func (c *priorityLevelConfigurations) Create(ctx context.Context, priorityLevelConfiguration *v1beta2.PriorityLevelConfiguration, opts v1.CreateOptions) (result *v1beta2.PriorityLevelConfiguration, err error) { + result = &v1beta2.PriorityLevelConfiguration{} + err = c.client.Post(). + Resource("prioritylevelconfigurations"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(priorityLevelConfiguration). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a priorityLevelConfiguration and updates it. Returns the server's representation of the priorityLevelConfiguration, and an error, if there is any. +func (c *priorityLevelConfigurations) Update(ctx context.Context, priorityLevelConfiguration *v1beta2.PriorityLevelConfiguration, opts v1.UpdateOptions) (result *v1beta2.PriorityLevelConfiguration, err error) { + result = &v1beta2.PriorityLevelConfiguration{} + err = c.client.Put(). + Resource("prioritylevelconfigurations"). + Name(priorityLevelConfiguration.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(priorityLevelConfiguration). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *priorityLevelConfigurations) UpdateStatus(ctx context.Context, priorityLevelConfiguration *v1beta2.PriorityLevelConfiguration, opts v1.UpdateOptions) (result *v1beta2.PriorityLevelConfiguration, err error) { + result = &v1beta2.PriorityLevelConfiguration{} + err = c.client.Put(). + Resource("prioritylevelconfigurations"). + Name(priorityLevelConfiguration.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(priorityLevelConfiguration). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the priorityLevelConfiguration and deletes it. Returns an error if one occurs. +func (c *priorityLevelConfigurations) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Resource("prioritylevelconfigurations"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *priorityLevelConfigurations) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("prioritylevelconfigurations"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched priorityLevelConfiguration. +func (c *priorityLevelConfigurations) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta2.PriorityLevelConfiguration, err error) { + result = &v1beta2.PriorityLevelConfiguration{} + err = c.client.Patch(pt). + Resource("prioritylevelconfigurations"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// Apply takes the given apply declarative configuration, applies it and returns the applied priorityLevelConfiguration. +func (c *priorityLevelConfigurations) Apply(ctx context.Context, priorityLevelConfiguration *flowcontrolv1beta2.PriorityLevelConfigurationApplyConfiguration, opts v1.ApplyOptions) (result *v1beta2.PriorityLevelConfiguration, err error) { + if priorityLevelConfiguration == nil { + return nil, fmt.Errorf("priorityLevelConfiguration provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(priorityLevelConfiguration) + if err != nil { + return nil, err + } + name := priorityLevelConfiguration.Name + if name == nil { + return nil, fmt.Errorf("priorityLevelConfiguration.Name must be provided to Apply") + } + result = &v1beta2.PriorityLevelConfiguration{} + err = c.client.Patch(types.ApplyPatchType). + Resource("prioritylevelconfigurations"). + Name(*name). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// ApplyStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). +func (c *priorityLevelConfigurations) ApplyStatus(ctx context.Context, priorityLevelConfiguration *flowcontrolv1beta2.PriorityLevelConfigurationApplyConfiguration, opts v1.ApplyOptions) (result *v1beta2.PriorityLevelConfiguration, err error) { + if priorityLevelConfiguration == nil { + return nil, fmt.Errorf("priorityLevelConfiguration provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(priorityLevelConfiguration) + if err != nil { + return nil, err + } + + name := priorityLevelConfiguration.Name + if name == nil { + return nil, fmt.Errorf("priorityLevelConfiguration.Name must be provided to Apply") + } + + result = &v1beta2.PriorityLevelConfiguration{} + err = c.client.Patch(types.ApplyPatchType). + Resource("prioritylevelconfigurations"). + Name(*name). + SubResource("status"). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/k8s.io/client-go/kubernetes/typed/networking/v1/networking_client.go b/vendor/k8s.io/client-go/kubernetes/typed/networking/v1/networking_client.go index c83b93575e..3b72a7ae92 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/networking/v1/networking_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/networking/v1/networking_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/networking/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -49,12 +51,28 @@ func (c *NetworkingV1Client) NetworkPolicies(namespace string) NetworkPolicyInte } // NewForConfig creates a new NetworkingV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*NetworkingV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new NetworkingV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*NetworkingV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/networking/v1beta1/networking_client.go b/vendor/k8s.io/client-go/kubernetes/typed/networking/v1beta1/networking_client.go index 849ac219f6..851634ed0f 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/networking/v1beta1/networking_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/networking/v1beta1/networking_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/networking/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -44,12 +46,28 @@ func (c *NetworkingV1beta1Client) IngressClasses() IngressClassInterface { } // NewForConfig creates a new NetworkingV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*NetworkingV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new NetworkingV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*NetworkingV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/node/v1/node_client.go b/vendor/k8s.io/client-go/kubernetes/typed/node/v1/node_client.go index 7f0da811b2..844f9fc70f 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/node/v1/node_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/node/v1/node_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/node/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *NodeV1Client) RuntimeClasses() RuntimeClassInterface { } // NewForConfig creates a new NodeV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*NodeV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new NodeV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*NodeV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/node/v1alpha1/node_client.go b/vendor/k8s.io/client-go/kubernetes/typed/node/v1alpha1/node_client.go index e7acc27e40..2a197d58e6 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/node/v1alpha1/node_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/node/v1alpha1/node_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1alpha1 import ( + "net/http" + v1alpha1 "k8s.io/api/node/v1alpha1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *NodeV1alpha1Client) RuntimeClasses() RuntimeClassInterface { } // NewForConfig creates a new NodeV1alpha1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*NodeV1alpha1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new NodeV1alpha1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*NodeV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/node/v1beta1/node_client.go b/vendor/k8s.io/client-go/kubernetes/typed/node/v1beta1/node_client.go index b38d9acac6..4f6802ffac 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/node/v1beta1/node_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/node/v1beta1/node_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/node/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *NodeV1beta1Client) RuntimeClasses() RuntimeClassInterface { } // NewForConfig creates a new NodeV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*NodeV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new NodeV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*NodeV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/policy/v1/policy_client.go b/vendor/k8s.io/client-go/kubernetes/typed/policy/v1/policy_client.go index ecd29deb87..9bfd98aa9f 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/policy/v1/policy_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/policy/v1/policy_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/policy/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -44,12 +46,28 @@ func (c *PolicyV1Client) PodDisruptionBudgets(namespace string) PodDisruptionBud } // NewForConfig creates a new PolicyV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*PolicyV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new PolicyV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*PolicyV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/policy/v1beta1/policy_client.go b/vendor/k8s.io/client-go/kubernetes/typed/policy/v1beta1/policy_client.go index 8b8b22c6de..5b65c9c0aa 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/policy/v1beta1/policy_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/policy/v1beta1/policy_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/policy/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -49,12 +51,28 @@ func (c *PolicyV1beta1Client) PodSecurityPolicies() PodSecurityPolicyInterface { } // NewForConfig creates a new PolicyV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*PolicyV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new PolicyV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*PolicyV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1/rbac_client.go b/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1/rbac_client.go index 1bc0179c62..a02f0357d9 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1/rbac_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1/rbac_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/rbac/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -54,12 +56,28 @@ func (c *RbacV1Client) RoleBindings(namespace string) RoleBindingInterface { } // NewForConfig creates a new RbacV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*RbacV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new RbacV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*RbacV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1alpha1/rbac_client.go b/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1alpha1/rbac_client.go index efbbc68be9..cc5b309e90 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1alpha1/rbac_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1alpha1/rbac_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1alpha1 import ( + "net/http" + v1alpha1 "k8s.io/api/rbac/v1alpha1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -54,12 +56,28 @@ func (c *RbacV1alpha1Client) RoleBindings(namespace string) RoleBindingInterface } // NewForConfig creates a new RbacV1alpha1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*RbacV1alpha1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new RbacV1alpha1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*RbacV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1beta1/rbac_client.go b/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1beta1/rbac_client.go index 4db94cfad7..8dac5c1d4b 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1beta1/rbac_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/rbac/v1beta1/rbac_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/rbac/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -54,12 +56,28 @@ func (c *RbacV1beta1Client) RoleBindings(namespace string) RoleBindingInterface } // NewForConfig creates a new RbacV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*RbacV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new RbacV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*RbacV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1/scheduling_client.go b/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1/scheduling_client.go index 5028bac892..11fc4b9f39 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1/scheduling_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1/scheduling_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/scheduling/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *SchedulingV1Client) PriorityClasses() PriorityClassInterface { } // NewForConfig creates a new SchedulingV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*SchedulingV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new SchedulingV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*SchedulingV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1/scheduling_client.go b/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1/scheduling_client.go index 83bc0b8a91..47fb774a37 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1/scheduling_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1/scheduling_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1alpha1 import ( + "net/http" + v1alpha1 "k8s.io/api/scheduling/v1alpha1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *SchedulingV1alpha1Client) PriorityClasses() PriorityClassInterface { } // NewForConfig creates a new SchedulingV1alpha1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*SchedulingV1alpha1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new SchedulingV1alpha1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*SchedulingV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1beta1/scheduling_client.go b/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1beta1/scheduling_client.go index 373f5cca88..dbaf694141 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1beta1/scheduling_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/scheduling/v1beta1/scheduling_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/scheduling/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -39,12 +41,28 @@ func (c *SchedulingV1beta1Client) PriorityClasses() PriorityClassInterface { } // NewForConfig creates a new SchedulingV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*SchedulingV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new SchedulingV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*SchedulingV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/storage/v1/storage_client.go b/vendor/k8s.io/client-go/kubernetes/typed/storage/v1/storage_client.go index f03beae855..b31862f439 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/storage/v1/storage_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/storage/v1/storage_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1 import ( + "net/http" + v1 "k8s.io/api/storage/v1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -54,12 +56,28 @@ func (c *StorageV1Client) VolumeAttachments() VolumeAttachmentInterface { } // NewForConfig creates a new StorageV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*StorageV1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new StorageV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*StorageV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/storage/v1alpha1/storage_client.go b/vendor/k8s.io/client-go/kubernetes/typed/storage/v1alpha1/storage_client.go index 9686923004..c9bf11d766 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/storage/v1alpha1/storage_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/storage/v1alpha1/storage_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1alpha1 import ( + "net/http" + v1alpha1 "k8s.io/api/storage/v1alpha1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -44,12 +46,28 @@ func (c *StorageV1alpha1Client) VolumeAttachments() VolumeAttachmentInterface { } // NewForConfig creates a new StorageV1alpha1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*StorageV1alpha1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new StorageV1alpha1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*StorageV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/kubernetes/typed/storage/v1beta1/storage_client.go b/vendor/k8s.io/client-go/kubernetes/typed/storage/v1beta1/storage_client.go index 19267b3625..4c7604bd29 100644 --- a/vendor/k8s.io/client-go/kubernetes/typed/storage/v1beta1/storage_client.go +++ b/vendor/k8s.io/client-go/kubernetes/typed/storage/v1beta1/storage_client.go @@ -19,6 +19,8 @@ limitations under the License. package v1beta1 import ( + "net/http" + v1beta1 "k8s.io/api/storage/v1beta1" "k8s.io/client-go/kubernetes/scheme" rest "k8s.io/client-go/rest" @@ -59,12 +61,28 @@ func (c *StorageV1beta1Client) VolumeAttachments() VolumeAttachmentInterface { } // NewForConfig creates a new StorageV1beta1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *rest.Config) (*StorageV1beta1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := rest.RESTClientFor(&config) + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new StorageV1beta1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*StorageV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/client-go/listers/autoscaling/v2/expansion_generated.go b/vendor/k8s.io/client-go/listers/autoscaling/v2/expansion_generated.go new file mode 100644 index 0000000000..97742b77b2 --- /dev/null +++ b/vendor/k8s.io/client-go/listers/autoscaling/v2/expansion_generated.go @@ -0,0 +1,27 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by lister-gen. DO NOT EDIT. + +package v2 + +// HorizontalPodAutoscalerListerExpansion allows custom methods to be added to +// HorizontalPodAutoscalerLister. +type HorizontalPodAutoscalerListerExpansion interface{} + +// HorizontalPodAutoscalerNamespaceListerExpansion allows custom methods to be added to +// HorizontalPodAutoscalerNamespaceLister. +type HorizontalPodAutoscalerNamespaceListerExpansion interface{} diff --git a/vendor/k8s.io/client-go/listers/autoscaling/v2/horizontalpodautoscaler.go b/vendor/k8s.io/client-go/listers/autoscaling/v2/horizontalpodautoscaler.go new file mode 100644 index 0000000000..a5cef27725 --- /dev/null +++ b/vendor/k8s.io/client-go/listers/autoscaling/v2/horizontalpodautoscaler.go @@ -0,0 +1,99 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by lister-gen. DO NOT EDIT. + +package v2 + +import ( + v2 "k8s.io/api/autoscaling/v2" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// HorizontalPodAutoscalerLister helps list HorizontalPodAutoscalers. +// All objects returned here must be treated as read-only. +type HorizontalPodAutoscalerLister interface { + // List lists all HorizontalPodAutoscalers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v2.HorizontalPodAutoscaler, err error) + // HorizontalPodAutoscalers returns an object that can list and get HorizontalPodAutoscalers. + HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerNamespaceLister + HorizontalPodAutoscalerListerExpansion +} + +// horizontalPodAutoscalerLister implements the HorizontalPodAutoscalerLister interface. +type horizontalPodAutoscalerLister struct { + indexer cache.Indexer +} + +// NewHorizontalPodAutoscalerLister returns a new HorizontalPodAutoscalerLister. +func NewHorizontalPodAutoscalerLister(indexer cache.Indexer) HorizontalPodAutoscalerLister { + return &horizontalPodAutoscalerLister{indexer: indexer} +} + +// List lists all HorizontalPodAutoscalers in the indexer. +func (s *horizontalPodAutoscalerLister) List(selector labels.Selector) (ret []*v2.HorizontalPodAutoscaler, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v2.HorizontalPodAutoscaler)) + }) + return ret, err +} + +// HorizontalPodAutoscalers returns an object that can list and get HorizontalPodAutoscalers. +func (s *horizontalPodAutoscalerLister) HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerNamespaceLister { + return horizontalPodAutoscalerNamespaceLister{indexer: s.indexer, namespace: namespace} +} + +// HorizontalPodAutoscalerNamespaceLister helps list and get HorizontalPodAutoscalers. +// All objects returned here must be treated as read-only. +type HorizontalPodAutoscalerNamespaceLister interface { + // List lists all HorizontalPodAutoscalers in the indexer for a given namespace. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v2.HorizontalPodAutoscaler, err error) + // Get retrieves the HorizontalPodAutoscaler from the indexer for a given namespace and name. + // Objects returned here must be treated as read-only. + Get(name string) (*v2.HorizontalPodAutoscaler, error) + HorizontalPodAutoscalerNamespaceListerExpansion +} + +// horizontalPodAutoscalerNamespaceLister implements the HorizontalPodAutoscalerNamespaceLister +// interface. +type horizontalPodAutoscalerNamespaceLister struct { + indexer cache.Indexer + namespace string +} + +// List lists all HorizontalPodAutoscalers in the indexer for a given namespace. +func (s horizontalPodAutoscalerNamespaceLister) List(selector labels.Selector) (ret []*v2.HorizontalPodAutoscaler, err error) { + err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) { + ret = append(ret, m.(*v2.HorizontalPodAutoscaler)) + }) + return ret, err +} + +// Get retrieves the HorizontalPodAutoscaler from the indexer for a given namespace and name. +func (s horizontalPodAutoscalerNamespaceLister) Get(name string) (*v2.HorizontalPodAutoscaler, error) { + obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v2.Resource("horizontalpodautoscaler"), name) + } + return obj.(*v2.HorizontalPodAutoscaler), nil +} diff --git a/vendor/k8s.io/client-go/listers/flowcontrol/v1beta2/expansion_generated.go b/vendor/k8s.io/client-go/listers/flowcontrol/v1beta2/expansion_generated.go new file mode 100644 index 0000000000..b658de6549 --- /dev/null +++ b/vendor/k8s.io/client-go/listers/flowcontrol/v1beta2/expansion_generated.go @@ -0,0 +1,27 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by lister-gen. DO NOT EDIT. + +package v1beta2 + +// FlowSchemaListerExpansion allows custom methods to be added to +// FlowSchemaLister. +type FlowSchemaListerExpansion interface{} + +// PriorityLevelConfigurationListerExpansion allows custom methods to be added to +// PriorityLevelConfigurationLister. +type PriorityLevelConfigurationListerExpansion interface{} diff --git a/vendor/k8s.io/client-go/listers/flowcontrol/v1beta2/flowschema.go b/vendor/k8s.io/client-go/listers/flowcontrol/v1beta2/flowschema.go new file mode 100644 index 0000000000..2710f26306 --- /dev/null +++ b/vendor/k8s.io/client-go/listers/flowcontrol/v1beta2/flowschema.go @@ -0,0 +1,68 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by lister-gen. DO NOT EDIT. + +package v1beta2 + +import ( + v1beta2 "k8s.io/api/flowcontrol/v1beta2" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// FlowSchemaLister helps list FlowSchemas. +// All objects returned here must be treated as read-only. +type FlowSchemaLister interface { + // List lists all FlowSchemas in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1beta2.FlowSchema, err error) + // Get retrieves the FlowSchema from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1beta2.FlowSchema, error) + FlowSchemaListerExpansion +} + +// flowSchemaLister implements the FlowSchemaLister interface. +type flowSchemaLister struct { + indexer cache.Indexer +} + +// NewFlowSchemaLister returns a new FlowSchemaLister. +func NewFlowSchemaLister(indexer cache.Indexer) FlowSchemaLister { + return &flowSchemaLister{indexer: indexer} +} + +// List lists all FlowSchemas in the indexer. +func (s *flowSchemaLister) List(selector labels.Selector) (ret []*v1beta2.FlowSchema, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1beta2.FlowSchema)) + }) + return ret, err +} + +// Get retrieves the FlowSchema from the index for a given name. +func (s *flowSchemaLister) Get(name string) (*v1beta2.FlowSchema, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1beta2.Resource("flowschema"), name) + } + return obj.(*v1beta2.FlowSchema), nil +} diff --git a/vendor/k8s.io/client-go/listers/flowcontrol/v1beta2/prioritylevelconfiguration.go b/vendor/k8s.io/client-go/listers/flowcontrol/v1beta2/prioritylevelconfiguration.go new file mode 100644 index 0000000000..00ede00709 --- /dev/null +++ b/vendor/k8s.io/client-go/listers/flowcontrol/v1beta2/prioritylevelconfiguration.go @@ -0,0 +1,68 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by lister-gen. DO NOT EDIT. + +package v1beta2 + +import ( + v1beta2 "k8s.io/api/flowcontrol/v1beta2" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// PriorityLevelConfigurationLister helps list PriorityLevelConfigurations. +// All objects returned here must be treated as read-only. +type PriorityLevelConfigurationLister interface { + // List lists all PriorityLevelConfigurations in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1beta2.PriorityLevelConfiguration, err error) + // Get retrieves the PriorityLevelConfiguration from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1beta2.PriorityLevelConfiguration, error) + PriorityLevelConfigurationListerExpansion +} + +// priorityLevelConfigurationLister implements the PriorityLevelConfigurationLister interface. +type priorityLevelConfigurationLister struct { + indexer cache.Indexer +} + +// NewPriorityLevelConfigurationLister returns a new PriorityLevelConfigurationLister. +func NewPriorityLevelConfigurationLister(indexer cache.Indexer) PriorityLevelConfigurationLister { + return &priorityLevelConfigurationLister{indexer: indexer} +} + +// List lists all PriorityLevelConfigurations in the indexer. +func (s *priorityLevelConfigurationLister) List(selector labels.Selector) (ret []*v1beta2.PriorityLevelConfiguration, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1beta2.PriorityLevelConfiguration)) + }) + return ret, err +} + +// Get retrieves the PriorityLevelConfiguration from the index for a given name. +func (s *priorityLevelConfigurationLister) Get(name string) (*v1beta2.PriorityLevelConfiguration, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1beta2.Resource("prioritylevelconfiguration"), name) + } + return obj.(*v1beta2.PriorityLevelConfiguration), nil +} diff --git a/vendor/k8s.io/client-go/metadata/metadata.go b/vendor/k8s.io/client-go/metadata/metadata.go index 72b5579914..8152aa1248 100644 --- a/vendor/k8s.io/client-go/metadata/metadata.go +++ b/vendor/k8s.io/client-go/metadata/metadata.go @@ -20,6 +20,7 @@ import ( "context" "encoding/json" "fmt" + "net/http" "time" "k8s.io/klog/v2" @@ -85,13 +86,27 @@ func NewForConfigOrDie(c *rest.Config) Interface { // metadata details about any Kubernetes object (core, aggregated, or custom // resource based) in the form of PartialObjectMetadata objects, or returns // an error. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(inConfig *rest.Config) (Interface, error) { config := ConfigFor(inConfig) + + httpClient, err := rest.HTTPClientFor(config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(config, httpClient) +} + +// NewForConfigAndClient creates a new metadata client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(inConfig *rest.Config, h *http.Client) (Interface, error) { + config := ConfigFor(inConfig) // for serializing the options config.GroupVersion = &schema.GroupVersion{} config.APIPath = "/this-value-should-never-be-sent" - restClient, err := rest.RESTClientFor(config) + restClient, err := rest.RESTClientForConfigAndClient(config, h) if err != nil { return nil, err } @@ -124,6 +139,12 @@ func (c *client) Delete(ctx context.Context, name string, opts metav1.DeleteOpti if len(name) == 0 { return fmt.Errorf("name is required") } + // if DeleteOptions are delivered to Negotiator for serialization, + // HTTP-Request header will bring "Content-Type: application/vnd.kubernetes.protobuf" + // apiextensions-apiserver uses unstructuredNegotiatedSerializer to decode the input, + // server-side will reply with 406 errors. + // The special treatment here is to be compatible with CRD Handler + // see: https://github.com/kubernetes/kubernetes/blob/1a845ccd076bbf1b03420fe694c85a5cd3bd6bed/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/customresource_handler.go#L843 deleteOptionsByte, err := runtime.Encode(deleteOptionsCodec.LegacyCodec(schema.GroupVersion{Version: "v1"}), &opts) if err != nil { return err @@ -132,6 +153,7 @@ func (c *client) Delete(ctx context.Context, name string, opts metav1.DeleteOpti result := c.client.client. Delete(). AbsPath(append(c.makeURLSegments(name), subresources...)...). + SetHeader("Content-Type", runtime.ContentTypeJSON). Body(deleteOptionsByte). Do(ctx) return result.Error() @@ -139,6 +161,7 @@ func (c *client) Delete(ctx context.Context, name string, opts metav1.DeleteOpti // DeleteCollection triggers deletion of all resources in the specified scope (namespace or cluster). func (c *client) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOptions metav1.ListOptions) error { + // See comment on Delete deleteOptionsByte, err := runtime.Encode(deleteOptionsCodec.LegacyCodec(schema.GroupVersion{Version: "v1"}), &opts) if err != nil { return err @@ -147,6 +170,7 @@ func (c *client) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions result := c.client.client. Delete(). AbsPath(c.makeURLSegments("")...). + SetHeader("Content-Type", runtime.ContentTypeJSON). Body(deleteOptionsByte). SpecificallyVersionedParams(&listOptions, dynamicParameterCodec, versionV1). Do(ctx) diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.conversion.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.conversion.go index 39e7ef2597..277d9d93ee 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.conversion.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.deepcopy.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.deepcopy.go index 60ab25d81b..893933c45f 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.defaults.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.defaults.go index cce2e603a6..dac177e93b 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.defaults.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.conversion.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.conversion.go index b0e503af49..fc59decef5 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.conversion.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.deepcopy.go index a73d31b3f1..ce614c0b87 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.defaults.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.defaults.go index dd621a3acd..5070cb91b9 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.defaults.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.conversion.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.conversion.go index 8daed80524..c82993897d 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.conversion.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.deepcopy.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.deepcopy.go index 3a72ece0c6..d7a801c27d 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.defaults.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.defaults.go index 73e63fc114..198b5be4af 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.defaults.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/v1beta1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/zz_generated.deepcopy.go b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/zz_generated.deepcopy.go index 045b07f5b0..3103629f61 100644 --- a/vendor/k8s.io/client-go/pkg/apis/clientauthentication/zz_generated.deepcopy.go +++ b/vendor/k8s.io/client-go/pkg/apis/clientauthentication/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/plugin/pkg/client/auth/exec/exec.go b/vendor/k8s.io/client-go/plugin/pkg/client/auth/exec/exec.go index 7a09846260..e405e3dc12 100644 --- a/vendor/k8s.io/client-go/plugin/pkg/client/auth/exec/exec.go +++ b/vendor/k8s.io/client-go/plugin/pkg/client/auth/exec/exec.go @@ -38,7 +38,7 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/runtime/serializer" - "k8s.io/apimachinery/pkg/util/clock" + utilnet "k8s.io/apimachinery/pkg/util/net" "k8s.io/client-go/pkg/apis/clientauthentication" "k8s.io/client-go/pkg/apis/clientauthentication/install" clientauthenticationv1 "k8s.io/client-go/pkg/apis/clientauthentication/v1" @@ -49,6 +49,7 @@ import ( "k8s.io/client-go/transport" "k8s.io/client-go/util/connrotation" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) const execInfoEnv = "KUBERNETES_EXEC_INFO" @@ -316,11 +317,17 @@ func (a *Authenticator) UpdateTransportConfig(c *transport.Config) error { return nil } +var _ utilnet.RoundTripperWrapper = &roundTripper{} + type roundTripper struct { a *Authenticator base http.RoundTripper } +func (r *roundTripper) WrappedRoundTripper() http.RoundTripper { + return r.base +} + func (r *roundTripper) RoundTrip(req *http.Request) (*http.Response, error) { // If a user has already set credentials, use that. This makes commands like // "kubectl get --token (token) pods" work. diff --git a/vendor/k8s.io/client-go/plugin/pkg/client/auth/plugins_providers.go b/vendor/k8s.io/client-go/plugin/pkg/client/auth/plugins_providers.go index 967039662c..ebfbd715c0 100644 --- a/vendor/k8s.io/client-go/plugin/pkg/client/auth/plugins_providers.go +++ b/vendor/k8s.io/client-go/plugin/pkg/client/auth/plugins_providers.go @@ -1,3 +1,4 @@ +//go:build !providerless // +build !providerless /* diff --git a/vendor/k8s.io/client-go/rest/config.go b/vendor/k8s.io/client-go/rest/config.go index 3735750bbc..4909dc53ab 100644 --- a/vendor/k8s.io/client-go/rest/config.go +++ b/vendor/k8s.io/client-go/rest/config.go @@ -202,6 +202,8 @@ func (c *Config) String() string { type ImpersonationConfig struct { // UserName is the username to impersonate on each request. UserName string + // UID is a unique value that identifies the user. + UID string // Groups are the groups to impersonate on each request. Groups []string // Extra is a free-form field which can be used to link some authentication information @@ -303,6 +305,8 @@ type ContentConfig struct { // object. Note that a RESTClient may require fields that are optional when initializing a Client. // A RESTClient created by this method is generic - it expects to operate on an API that follows // the Kubernetes conventions, but may not be the Kubernetes API. +// RESTClientFor is equivalent to calling RESTClientForConfigAndClient(config, httpClient), +// where httpClient was generated with HTTPClientFor(config). func RESTClientFor(config *Config) (*RESTClient, error) { if config.GroupVersion == nil { return nil, fmt.Errorf("GroupVersion is required when initializing a RESTClient") @@ -311,22 +315,38 @@ func RESTClientFor(config *Config) (*RESTClient, error) { return nil, fmt.Errorf("NegotiatedSerializer is required when initializing a RESTClient") } - baseURL, versionedAPIPath, err := defaultServerUrlFor(config) + // Validate config.Host before constructing the transport/client so we can fail fast. + // ServerURL will be obtained later in RESTClientForConfigAndClient() + _, _, err := defaultServerUrlFor(config) if err != nil { return nil, err } - transport, err := TransportFor(config) + httpClient, err := HTTPClientFor(config) if err != nil { return nil, err } - var httpClient *http.Client - if transport != http.DefaultTransport { - httpClient = &http.Client{Transport: transport} - if config.Timeout > 0 { - httpClient.Timeout = config.Timeout - } + return RESTClientForConfigAndClient(config, httpClient) +} + +// RESTClientForConfigAndClient returns a RESTClient that satisfies the requested attributes on a +// client Config object. +// Unlike RESTClientFor, RESTClientForConfigAndClient allows to pass an http.Client that is shared +// between all the API Groups and Versions. +// Note that the http client takes precedence over the transport values configured. +// The http client defaults to the `http.DefaultClient` if nil. +func RESTClientForConfigAndClient(config *Config, httpClient *http.Client) (*RESTClient, error) { + if config.GroupVersion == nil { + return nil, fmt.Errorf("GroupVersion is required when initializing a RESTClient") + } + if config.NegotiatedSerializer == nil { + return nil, fmt.Errorf("NegotiatedSerializer is required when initializing a RESTClient") + } + + baseURL, versionedAPIPath, err := defaultServerUrlFor(config) + if err != nil { + return nil, err } rateLimiter := config.RateLimiter @@ -369,22 +389,31 @@ func UnversionedRESTClientFor(config *Config) (*RESTClient, error) { return nil, fmt.Errorf("NegotiatedSerializer is required when initializing a RESTClient") } - baseURL, versionedAPIPath, err := defaultServerUrlFor(config) + // Validate config.Host before constructing the transport/client so we can fail fast. + // ServerURL will be obtained later in UnversionedRESTClientForConfigAndClient() + _, _, err := defaultServerUrlFor(config) if err != nil { return nil, err } - transport, err := TransportFor(config) + httpClient, err := HTTPClientFor(config) if err != nil { return nil, err } - var httpClient *http.Client - if transport != http.DefaultTransport { - httpClient = &http.Client{Transport: transport} - if config.Timeout > 0 { - httpClient.Timeout = config.Timeout - } + return UnversionedRESTClientForConfigAndClient(config, httpClient) +} + +// UnversionedRESTClientForConfigAndClient is the same as RESTClientForConfigAndClient, +// except that it allows the config.Version to be empty. +func UnversionedRESTClientForConfigAndClient(config *Config, httpClient *http.Client) (*RESTClient, error) { + if config.NegotiatedSerializer == nil { + return nil, fmt.Errorf("NegotiatedSerializer is required when initializing a RESTClient") + } + + baseURL, versionedAPIPath, err := defaultServerUrlFor(config) + if err != nil { + return nil, err } rateLimiter := config.RateLimiter @@ -608,9 +637,10 @@ func CopyConfig(config *Config) *Config { BearerToken: config.BearerToken, BearerTokenFile: config.BearerTokenFile, Impersonate: ImpersonationConfig{ + UserName: config.Impersonate.UserName, + UID: config.Impersonate.UID, Groups: config.Impersonate.Groups, Extra: config.Impersonate.Extra, - UserName: config.Impersonate.UserName, }, AuthProvider: config.AuthProvider, AuthConfigPersister: config.AuthConfigPersister, diff --git a/vendor/k8s.io/client-go/rest/request.go b/vendor/k8s.io/client-go/rest/request.go index e5a8100be2..5cc9900b04 100644 --- a/vendor/k8s.io/client-go/rest/request.go +++ b/vendor/k8s.io/client-go/rest/request.go @@ -39,13 +39,13 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/runtime/serializer/streaming" - utilclock "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/net" "k8s.io/apimachinery/pkg/watch" restclientwatch "k8s.io/client-go/rest/watch" "k8s.io/client-go/tools/metrics" "k8s.io/client-go/util/flowcontrol" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) var ( @@ -619,12 +619,12 @@ type throttleSettings struct { } type throttledLogger struct { - clock utilclock.PassiveClock + clock clock.PassiveClock settings []*throttleSettings } var globalThrottledLogger = &throttledLogger{ - clock: utilclock.RealClock{}, + clock: clock.RealClock{}, settings: []*throttleSettings{ { logLevel: 2, diff --git a/vendor/k8s.io/client-go/rest/transport.go b/vendor/k8s.io/client-go/rest/transport.go index 87792750ad..7c38c6d92c 100644 --- a/vendor/k8s.io/client-go/rest/transport.go +++ b/vendor/k8s.io/client-go/rest/transport.go @@ -26,6 +26,27 @@ import ( "k8s.io/client-go/transport" ) +// HTTPClientFor returns an http.Client that will provide the authentication +// or transport level security defined by the provided Config. Will return the +// default http.DefaultClient if no special case behavior is needed. +func HTTPClientFor(config *Config) (*http.Client, error) { + transport, err := TransportFor(config) + if err != nil { + return nil, err + } + var httpClient *http.Client + if transport != http.DefaultTransport || config.Timeout > 0 { + httpClient = &http.Client{ + Transport: transport, + Timeout: config.Timeout, + } + } else { + httpClient = http.DefaultClient + } + + return httpClient, nil +} + // TLSConfigFor returns a tls.Config that will provide the transport level security defined // by the provided Config. Will return nil if no transport level security is requested. func TLSConfigFor(config *Config) (*tls.Config, error) { @@ -83,6 +104,7 @@ func (c *Config) TransportConfig() (*transport.Config, error) { BearerTokenFile: c.BearerTokenFile, Impersonate: transport.ImpersonationConfig{ UserName: c.Impersonate.UserName, + UID: c.Impersonate.UID, Groups: c.Impersonate.Groups, Extra: c.Impersonate.Extra, }, diff --git a/vendor/k8s.io/client-go/rest/zz_generated.deepcopy.go b/vendor/k8s.io/client-go/rest/zz_generated.deepcopy.go index da4a1624e8..86991be3b5 100644 --- a/vendor/k8s.io/client-go/rest/zz_generated.deepcopy.go +++ b/vendor/k8s.io/client-go/rest/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/restmapper/discovery.go b/vendor/k8s.io/client-go/restmapper/discovery.go index 19ae95e1b5..3505178b66 100644 --- a/vendor/k8s.io/client-go/restmapper/discovery.go +++ b/vendor/k8s.io/client-go/restmapper/discovery.go @@ -205,7 +205,7 @@ func (d *DeferredDiscoveryRESTMapper) getDelegate() (meta.RESTMapper, error) { } d.delegate = NewDiscoveryRESTMapper(groupResources) - return d.delegate, err + return d.delegate, nil } // Reset resets the internally cached Discovery information and will @@ -335,4 +335,4 @@ func (d *DeferredDiscoveryRESTMapper) String() string { } // Make sure it satisfies the interface -var _ meta.RESTMapper = &DeferredDiscoveryRESTMapper{} +var _ meta.ResettableRESTMapper = &DeferredDiscoveryRESTMapper{} diff --git a/vendor/k8s.io/client-go/restmapper/shortcut.go b/vendor/k8s.io/client-go/restmapper/shortcut.go index 73b317c1ca..714ba90a7a 100644 --- a/vendor/k8s.io/client-go/restmapper/shortcut.go +++ b/vendor/k8s.io/client-go/restmapper/shortcut.go @@ -34,7 +34,7 @@ type shortcutExpander struct { discoveryClient discovery.DiscoveryInterface } -var _ meta.RESTMapper = &shortcutExpander{} +var _ meta.ResettableRESTMapper = shortcutExpander{} // NewShortcutExpander wraps a restmapper in a layer that expands shortcuts found via discovery func NewShortcutExpander(delegate meta.RESTMapper, client discovery.DiscoveryInterface) meta.RESTMapper { @@ -164,6 +164,10 @@ func (e shortcutExpander) expandResourceShortcut(resource schema.GroupVersionRes return resource } +func (e shortcutExpander) Reset() { + meta.MaybeResetRESTMapper(e.RESTMapper) +} + // ResourceShortcuts represents a structure that holds the information how to // transition from resource's shortcut to its full name. type resourceShortcuts struct { diff --git a/vendor/k8s.io/client-go/scale/scheme/appsv1beta1/zz_generated.conversion.go b/vendor/k8s.io/client-go/scale/scheme/appsv1beta1/zz_generated.conversion.go index 02a36051e6..d56861ead5 100644 --- a/vendor/k8s.io/client-go/scale/scheme/appsv1beta1/zz_generated.conversion.go +++ b/vendor/k8s.io/client-go/scale/scheme/appsv1beta1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/scale/scheme/appsv1beta2/zz_generated.conversion.go b/vendor/k8s.io/client-go/scale/scheme/appsv1beta2/zz_generated.conversion.go index c31ad4b353..09c17420e0 100644 --- a/vendor/k8s.io/client-go/scale/scheme/appsv1beta2/zz_generated.conversion.go +++ b/vendor/k8s.io/client-go/scale/scheme/appsv1beta2/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/scale/scheme/autoscalingv1/zz_generated.conversion.go b/vendor/k8s.io/client-go/scale/scheme/autoscalingv1/zz_generated.conversion.go index 9bc48695dd..09e73584eb 100644 --- a/vendor/k8s.io/client-go/scale/scheme/autoscalingv1/zz_generated.conversion.go +++ b/vendor/k8s.io/client-go/scale/scheme/autoscalingv1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/scale/scheme/extensionsv1beta1/zz_generated.conversion.go b/vendor/k8s.io/client-go/scale/scheme/extensionsv1beta1/zz_generated.conversion.go index 5fd69a5a88..46b29f171f 100644 --- a/vendor/k8s.io/client-go/scale/scheme/extensionsv1beta1/zz_generated.conversion.go +++ b/vendor/k8s.io/client-go/scale/scheme/extensionsv1beta1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/scale/scheme/zz_generated.deepcopy.go b/vendor/k8s.io/client-go/scale/scheme/zz_generated.deepcopy.go index 3db7081546..6ee3c2071d 100644 --- a/vendor/k8s.io/client-go/scale/scheme/zz_generated.deepcopy.go +++ b/vendor/k8s.io/client-go/scale/scheme/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/testing/actions.go b/vendor/k8s.io/client-go/testing/actions.go index b6b2c1f222..c8ae0aaf5d 100644 --- a/vendor/k8s.io/client-go/testing/actions.go +++ b/vendor/k8s.io/client-go/testing/actions.go @@ -222,10 +222,15 @@ func NewUpdateSubresourceAction(resource schema.GroupVersionResource, subresourc } func NewRootDeleteAction(resource schema.GroupVersionResource, name string) DeleteActionImpl { + return NewRootDeleteActionWithOptions(resource, name, metav1.DeleteOptions{}) +} + +func NewRootDeleteActionWithOptions(resource schema.GroupVersionResource, name string, opts metav1.DeleteOptions) DeleteActionImpl { action := DeleteActionImpl{} action.Verb = "delete" action.Resource = resource action.Name = name + action.DeleteOptions = opts return action } @@ -241,11 +246,16 @@ func NewRootDeleteSubresourceAction(resource schema.GroupVersionResource, subres } func NewDeleteAction(resource schema.GroupVersionResource, namespace, name string) DeleteActionImpl { + return NewDeleteActionWithOptions(resource, namespace, name, metav1.DeleteOptions{}) +} + +func NewDeleteActionWithOptions(resource schema.GroupVersionResource, namespace, name string, opts metav1.DeleteOptions) DeleteActionImpl { action := DeleteActionImpl{} action.Verb = "delete" action.Resource = resource action.Namespace = namespace action.Name = name + action.DeleteOptions = opts return action } @@ -391,6 +401,7 @@ type UpdateAction interface { type DeleteAction interface { Action GetName() string + GetDeleteOptions() metav1.DeleteOptions } type DeleteCollectionAction interface { @@ -583,17 +594,23 @@ func (a PatchActionImpl) DeepCopy() Action { type DeleteActionImpl struct { ActionImpl - Name string + Name string + DeleteOptions metav1.DeleteOptions } func (a DeleteActionImpl) GetName() string { return a.Name } +func (a DeleteActionImpl) GetDeleteOptions() metav1.DeleteOptions { + return a.DeleteOptions +} + func (a DeleteActionImpl) DeepCopy() Action { return DeleteActionImpl{ - ActionImpl: a.ActionImpl.DeepCopy().(ActionImpl), - Name: a.Name, + ActionImpl: a.ActionImpl.DeepCopy().(ActionImpl), + Name: a.Name, + DeleteOptions: *a.DeleteOptions.DeepCopy(), } } diff --git a/vendor/k8s.io/client-go/tools/cache/controller.go b/vendor/k8s.io/client-go/tools/cache/controller.go index fe394d16ce..c85c29db35 100644 --- a/vendor/k8s.io/client-go/tools/cache/controller.go +++ b/vendor/k8s.io/client-go/tools/cache/controller.go @@ -21,9 +21,9 @@ import ( "time" "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/util/clock" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/utils/clock" ) // This file implements a low-level controller that is used in @@ -322,7 +322,7 @@ func NewInformer( // This will hold the client state, as we know it. clientState := NewStore(DeletionHandlingMetaNamespaceKeyFunc) - return clientState, newInformer(lw, objType, resyncPeriod, h, clientState) + return clientState, newInformer(lw, objType, resyncPeriod, h, clientState, nil) } // NewIndexerInformer returns an Indexer and a Controller for populating the index @@ -351,7 +351,59 @@ func NewIndexerInformer( // This will hold the client state, as we know it. clientState := NewIndexer(DeletionHandlingMetaNamespaceKeyFunc, indexers) - return clientState, newInformer(lw, objType, resyncPeriod, h, clientState) + return clientState, newInformer(lw, objType, resyncPeriod, h, clientState, nil) +} + +// TransformFunc allows for transforming an object before it will be processed +// and put into the controller cache and before the corresponding handlers will +// be called on it. +// TransformFunc (similarly to ResourceEventHandler functions) should be able +// to correctly handle the tombstone of type cache.DeletedFinalStateUnknown +// +// The most common usage pattern is to clean-up some parts of the object to +// reduce component memory usage if a given component doesn't care about them. +// given controller doesn't care for them +type TransformFunc func(interface{}) (interface{}, error) + +// NewTransformingInformer returns a Store and a controller for populating +// the store while also providing event notifications. You should only used +// the returned Store for Get/List operations; Add/Modify/Deletes will cause +// the event notifications to be faulty. +// The given transform function will be called on all objects before they will +// put put into the Store and corresponding Add/Modify/Delete handlers will +// be invokved for them. +func NewTransformingInformer( + lw ListerWatcher, + objType runtime.Object, + resyncPeriod time.Duration, + h ResourceEventHandler, + transformer TransformFunc, +) (Store, Controller) { + // This will hold the client state, as we know it. + clientState := NewStore(DeletionHandlingMetaNamespaceKeyFunc) + + return clientState, newInformer(lw, objType, resyncPeriod, h, clientState, transformer) +} + +// NewTransformingIndexerInformer returns an Indexer and a controller for +// populating the index while also providing event notifications. You should +// only used the returned Index for Get/List operations; Add/Modify/Deletes +// will cause the event notifications to be faulty. +// The given transform function will be called on all objects before they will +// be put into the Index and corresponding Add/Modify/Delete handlers will +// be invoked for them. +func NewTransformingIndexerInformer( + lw ListerWatcher, + objType runtime.Object, + resyncPeriod time.Duration, + h ResourceEventHandler, + indexers Indexers, + transformer TransformFunc, +) (Indexer, Controller) { + // This will hold the client state, as we know it. + clientState := NewIndexer(DeletionHandlingMetaNamespaceKeyFunc, indexers) + + return clientState, newInformer(lw, objType, resyncPeriod, h, clientState, transformer) } // newInformer returns a controller for populating the store while also @@ -374,6 +426,7 @@ func newInformer( resyncPeriod time.Duration, h ResourceEventHandler, clientState Store, + transformer TransformFunc, ) Controller { // This will hold incoming changes. Note how we pass clientState in as a // KeyLister, that way resync operations will result in the correct set @@ -393,24 +446,33 @@ func newInformer( Process: func(obj interface{}) error { // from oldest to newest for _, d := range obj.(Deltas) { + obj := d.Object + if transformer != nil { + var err error + obj, err = transformer(obj) + if err != nil { + return err + } + } + switch d.Type { case Sync, Replaced, Added, Updated: - if old, exists, err := clientState.Get(d.Object); err == nil && exists { - if err := clientState.Update(d.Object); err != nil { + if old, exists, err := clientState.Get(obj); err == nil && exists { + if err := clientState.Update(obj); err != nil { return err } - h.OnUpdate(old, d.Object) + h.OnUpdate(old, obj) } else { - if err := clientState.Add(d.Object); err != nil { + if err := clientState.Add(obj); err != nil { return err } - h.OnAdd(d.Object) + h.OnAdd(obj) } case Deleted: - if err := clientState.Delete(d.Object); err != nil { + if err := clientState.Delete(obj); err != nil { return err } - h.OnDelete(d.Object) + h.OnDelete(obj) } } return nil diff --git a/vendor/k8s.io/client-go/tools/cache/delta_fifo.go b/vendor/k8s.io/client-go/tools/cache/delta_fifo.go index 82038e0f94..2da2933ab7 100644 --- a/vendor/k8s.io/client-go/tools/cache/delta_fifo.go +++ b/vendor/k8s.io/client-go/tools/cache/delta_fifo.go @@ -20,10 +20,12 @@ import ( "errors" "fmt" "sync" + "time" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/klog/v2" + utiltrace "k8s.io/utils/trace" ) // DeltaFIFOOptions is the configuration parameters for DeltaFIFO. All are @@ -121,7 +123,7 @@ type DeltaFIFO struct { knownObjects KeyListerGetter // Used to indicate a queue is closed so a control loop can exit when a queue is empty. - // Currently, not used to gate any of CRED operations. + // Currently, not used to gate any of CRUD operations. closed bool // emitDeltaTypeReplaced is whether to emit the Replaced or Sync @@ -456,8 +458,8 @@ func (f *DeltaFIFO) listLocked() []interface{} { func (f *DeltaFIFO) ListKeys() []string { f.lock.RLock() defer f.lock.RUnlock() - list := make([]string, 0, len(f.items)) - for key := range f.items { + list := make([]string, 0, len(f.queue)) + for _, key := range f.queue { list = append(list, key) } return list @@ -526,6 +528,7 @@ func (f *DeltaFIFO) Pop(process PopProcessFunc) (interface{}, error) { } id := f.queue[0] f.queue = f.queue[1:] + depth := len(f.queue) if f.initialPopulationCount > 0 { f.initialPopulationCount-- } @@ -536,6 +539,18 @@ func (f *DeltaFIFO) Pop(process PopProcessFunc) (interface{}, error) { continue } delete(f.items, id) + // Only log traces if the queue depth is greater than 10 and it takes more than + // 100 milliseconds to process one item from the queue. + // Queue depth never goes high because processing an item is locking the queue, + // and new items can't be added until processing finish. + // https://github.com/kubernetes/kubernetes/issues/103789 + if depth > 10 { + trace := utiltrace.New("DeltaFIFO Pop Process", + utiltrace.Field{Key: "ID", Value: id}, + utiltrace.Field{Key: "Depth", Value: depth}, + utiltrace.Field{Key: "Reason", Value: "slow event handlers blocking the queue"}) + defer trace.LogIfLong(100 * time.Millisecond) + } err := process(item) if e, ok := err.(ErrRequeue); ok { f.addIfNotPresent(id, item) @@ -557,7 +572,7 @@ func (f *DeltaFIFO) Pop(process PopProcessFunc) (interface{}, error) { // of the Deltas associated with K. Otherwise the pre-existing keys // are those listed by `f.knownObjects` and the current object of K is // what `f.knownObjects.GetByKey(K)` returns. -func (f *DeltaFIFO) Replace(list []interface{}, resourceVersion string) error { +func (f *DeltaFIFO) Replace(list []interface{}, _ string) error { f.lock.Lock() defer f.lock.Unlock() keys := make(sets.String, len(list)) diff --git a/vendor/k8s.io/client-go/tools/cache/expiration_cache.go b/vendor/k8s.io/client-go/tools/cache/expiration_cache.go index dfa9561930..7abdae7374 100644 --- a/vendor/k8s.io/client-go/tools/cache/expiration_cache.go +++ b/vendor/k8s.io/client-go/tools/cache/expiration_cache.go @@ -20,8 +20,8 @@ import ( "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) // ExpirationCache implements the store interface diff --git a/vendor/k8s.io/client-go/tools/cache/expiration_cache_fakes.go b/vendor/k8s.io/client-go/tools/cache/expiration_cache_fakes.go index 33afd32c86..a16f4735e3 100644 --- a/vendor/k8s.io/client-go/tools/cache/expiration_cache_fakes.go +++ b/vendor/k8s.io/client-go/tools/cache/expiration_cache_fakes.go @@ -17,8 +17,8 @@ limitations under the License. package cache import ( - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/sets" + "k8s.io/utils/clock" ) type fakeThreadSafeMap struct { diff --git a/vendor/k8s.io/client-go/tools/cache/fifo.go b/vendor/k8s.io/client-go/tools/cache/fifo.go index f82bf22d2f..5c9255027a 100644 --- a/vendor/k8s.io/client-go/tools/cache/fifo.go +++ b/vendor/k8s.io/client-go/tools/cache/fifo.go @@ -127,7 +127,7 @@ type FIFO struct { // Indication the queue is closed. // Used to indicate a queue is closed so a control loop can exit when a queue is empty. - // Currently, not used to gate any of CRED operations. + // Currently, not used to gate any of CRUD operations. closed bool } diff --git a/vendor/k8s.io/client-go/tools/cache/index.go b/vendor/k8s.io/client-go/tools/cache/index.go index fa29e6a704..1d6aae560a 100644 --- a/vendor/k8s.io/client-go/tools/cache/index.go +++ b/vendor/k8s.io/client-go/tools/cache/index.go @@ -78,7 +78,7 @@ func IndexFuncToKeyFuncAdapter(indexFunc IndexFunc) KeyFunc { } const ( - // NamespaceIndex is the lookup name for the most comment index function, which is to index by the namespace field. + // NamespaceIndex is the lookup name for the most common index function, which is to index by the namespace field. NamespaceIndex string = "namespace" ) @@ -94,7 +94,7 @@ func MetaNamespaceIndexFunc(obj interface{}) ([]string, error) { // Index maps the indexed value to a set of keys in the store that match on that value type Index map[string]sets.String -// Indexers maps a name to a IndexFunc +// Indexers maps a name to an IndexFunc type Indexers map[string]IndexFunc // Indices maps a name to an Index diff --git a/vendor/k8s.io/client-go/tools/cache/reflector.go b/vendor/k8s.io/client-go/tools/cache/reflector.go index 90fa45ddbf..0708a6e8b5 100644 --- a/vendor/k8s.io/client-go/tools/cache/reflector.go +++ b/vendor/k8s.io/client-go/tools/cache/reflector.go @@ -32,7 +32,6 @@ import ( "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/naming" utilnet "k8s.io/apimachinery/pkg/util/net" utilruntime "k8s.io/apimachinery/pkg/util/runtime" @@ -40,6 +39,7 @@ import ( "k8s.io/apimachinery/pkg/watch" "k8s.io/client-go/tools/pager" "k8s.io/klog/v2" + "k8s.io/utils/clock" "k8s.io/utils/trace" ) @@ -69,7 +69,7 @@ type Reflector struct { // backoff manages backoff of ListWatch backoffManager wait.BackoffManager - // initConnBackoffManager manages backoff the initial connection with the Watch calll of ListAndWatch. + // initConnBackoffManager manages backoff the initial connection with the Watch call of ListAndWatch. initConnBackoffManager wait.BackoffManager resyncPeriod time.Duration @@ -319,7 +319,9 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error { panic(r) case <-listCh: } + initTrace.Step("Objects listed", trace.Field{"error", err}) if err != nil { + klog.Warningf("%s: failed to list %v: %v", r.name, r.expectedTypeName, err) return fmt.Errorf("failed to list %v: %v", r.expectedTypeName, err) } @@ -338,7 +340,6 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error { } r.setIsLastSyncResourceVersionUnavailable(false) // list was successful - initTrace.Step("Objects listed") listMetaInterface, err := meta.ListAccessor(list) if err != nil { return fmt.Errorf("unable to understand list result %#v: %v", list, err) diff --git a/vendor/k8s.io/client-go/tools/cache/shared_informer.go b/vendor/k8s.io/client-go/tools/cache/shared_informer.go index 3a3f538a15..4b7fc04e3e 100644 --- a/vendor/k8s.io/client-go/tools/cache/shared_informer.go +++ b/vendor/k8s.io/client-go/tools/cache/shared_informer.go @@ -23,10 +23,10 @@ import ( "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/util/clock" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/utils/buffer" + "k8s.io/utils/clock" "k8s.io/klog/v2" ) @@ -368,6 +368,10 @@ func (s *sharedIndexInformer) SetWatchErrorHandler(handler WatchErrorHandler) er func (s *sharedIndexInformer) Run(stopCh <-chan struct{}) { defer utilruntime.HandleCrash() + if s.HasStarted() { + klog.Warningf("The sharedIndexInformer has started, run more than once is not allowed") + return + } fifo := NewDeltaFIFOWithOptions(DeltaFIFOOptions{ KnownObjects: s.indexer, EmitDeltaTypeReplaced: true, @@ -410,6 +414,12 @@ func (s *sharedIndexInformer) Run(stopCh <-chan struct{}) { s.controller.Run(stopCh) } +func (s *sharedIndexInformer) HasStarted() bool { + s.startedLock.Lock() + defer s.startedLock.Unlock() + return s.started +} + func (s *sharedIndexInformer) HasSynced() bool { s.startedLock.Lock() defer s.startedLock.Unlock() @@ -694,9 +704,9 @@ type processorListener struct { // full resync from the shared informer, but modified by two // adjustments. One is imposing a lower bound, // `minimumResyncPeriod`. The other is another lower bound, the - // sharedProcessor's `resyncCheckPeriod`, that is imposed (a) only + // sharedIndexInformer's `resyncCheckPeriod`, that is imposed (a) only // in AddEventHandlerWithResyncPeriod invocations made after the - // sharedProcessor starts and (b) only if the informer does + // sharedIndexInformer starts and (b) only if the informer does // resyncs at all. requestedResyncPeriod time.Duration // resyncPeriod is the threshold that will be used in the logic diff --git a/vendor/k8s.io/client-go/tools/cache/thread_safe_store.go b/vendor/k8s.io/client-go/tools/cache/thread_safe_store.go index 56251179b5..ea34e90355 100644 --- a/vendor/k8s.io/client-go/tools/cache/thread_safe_store.go +++ b/vendor/k8s.io/client-go/tools/cache/thread_safe_store.go @@ -90,7 +90,7 @@ func (c *threadSafeMap) Delete(key string) { c.lock.Lock() defer c.lock.Unlock() if obj, exists := c.items[key]; exists { - c.deleteFromIndices(obj, key) + c.updateIndices(obj, nil, key) delete(c.items, key) } } @@ -251,61 +251,76 @@ func (c *threadSafeMap) AddIndexers(newIndexers Indexers) error { return nil } -// updateIndices modifies the objects location in the managed indexes, if this is an update, you must provide an oldObj +// updateIndices modifies the objects location in the managed indexes: +// - for create you must provide only the newObj +// - for update you must provide both the oldObj and the newObj +// - for delete you must provide only the oldObj // updateIndices must be called from a function that already has a lock on the cache func (c *threadSafeMap) updateIndices(oldObj interface{}, newObj interface{}, key string) { - // if we got an old object, we need to remove it before we add it again - if oldObj != nil { - c.deleteFromIndices(oldObj, key) - } + var oldIndexValues, indexValues []string + var err error for name, indexFunc := range c.indexers { - indexValues, err := indexFunc(newObj) + if oldObj != nil { + oldIndexValues, err = indexFunc(oldObj) + } else { + oldIndexValues = oldIndexValues[:0] + } if err != nil { panic(fmt.Errorf("unable to calculate an index entry for key %q on index %q: %v", key, name, err)) } + + if newObj != nil { + indexValues, err = indexFunc(newObj) + } else { + indexValues = indexValues[:0] + } + if err != nil { + panic(fmt.Errorf("unable to calculate an index entry for key %q on index %q: %v", key, name, err)) + } + index := c.indices[name] if index == nil { index = Index{} c.indices[name] = index } - for _, indexValue := range indexValues { - set := index[indexValue] - if set == nil { - set = sets.String{} - index[indexValue] = set + for _, value := range oldIndexValues { + // We optimize for the most common case where index returns a single value. + if len(indexValues) == 1 && value == indexValues[0] { + continue } - set.Insert(key) + c.deleteKeyFromIndex(key, value, index) + } + for _, value := range indexValues { + // We optimize for the most common case where index returns a single value. + if len(oldIndexValues) == 1 && value == oldIndexValues[0] { + continue + } + c.addKeyToIndex(key, value, index) } } } -// deleteFromIndices removes the object from each of the managed indexes -// it is intended to be called from a function that already has a lock on the cache -func (c *threadSafeMap) deleteFromIndices(obj interface{}, key string) { - for name, indexFunc := range c.indexers { - indexValues, err := indexFunc(obj) - if err != nil { - panic(fmt.Errorf("unable to calculate an index entry for key %q on index %q: %v", key, name, err)) - } +func (c *threadSafeMap) addKeyToIndex(key, indexValue string, index Index) { + set := index[indexValue] + if set == nil { + set = sets.String{} + index[indexValue] = set + } + set.Insert(key) +} - index := c.indices[name] - if index == nil { - continue - } - for _, indexValue := range indexValues { - set := index[indexValue] - if set != nil { - set.Delete(key) - - // If we don't delete the set when zero, indices with high cardinality - // short lived resources can cause memory to increase over time from - // unused empty sets. See `kubernetes/kubernetes/issues/84959`. - if len(set) == 0 { - delete(index, indexValue) - } - } - } +func (c *threadSafeMap) deleteKeyFromIndex(key, indexValue string, index Index) { + set := index[indexValue] + if set == nil { + return + } + set.Delete(key) + // If we don't delete the set when zero, indices with high cardinality + // short lived resources can cause memory to increase over time from + // unused empty sets. See `kubernetes/kubernetes/issues/84959`. + if len(set) == 0 { + delete(index, indexValue) } } diff --git a/vendor/k8s.io/client-go/tools/clientcmd/api/types.go b/vendor/k8s.io/client-go/tools/clientcmd/api/types.go index 31716abf18..44a2fb94b1 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/api/types.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/api/types.go @@ -124,7 +124,10 @@ type AuthInfo struct { // Impersonate is the username to act-as. // +optional Impersonate string `json:"act-as,omitempty"` - // ImpersonateGroups is the groups to imperonate. + // ImpersonateUID is the uid to impersonate. + // +optional + ImpersonateUID string `json:"act-as-uid,omitempty"` + // ImpersonateGroups is the groups to impersonate. // +optional ImpersonateGroups []string `json:"act-as-groups,omitempty"` // ImpersonateUserExtra contains additional information for impersonated user. diff --git a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/conversion.go b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/conversion.go index c38ebc0760..6eee281bc6 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/conversion.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/conversion.go @@ -165,7 +165,7 @@ func Convert_Map_string_To_runtime_Object_To_Slice_v1_NamedExtension(in *map[str newExtension := (*in)[key] oldExtension := runtime.RawExtension{} if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&newExtension, &oldExtension, s); err != nil { - return nil + return err } namedExtension := NamedExtension{key, oldExtension} *out = append(*out, namedExtension) diff --git a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/types.go b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/types.go index 7e8351032c..757ed817b2 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/types.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/types.go @@ -111,10 +111,13 @@ type AuthInfo struct { // TokenFile is a pointer to a file that contains a bearer token (as described above). If both Token and TokenFile are present, Token takes precedence. // +optional TokenFile string `json:"tokenFile,omitempty"` - // Impersonate is the username to imperonate. The name matches the flag. + // Impersonate is the username to impersonate. The name matches the flag. // +optional Impersonate string `json:"as,omitempty"` - // ImpersonateGroups is the groups to imperonate. + // ImpersonateUID is the uid to impersonate. + // +optional + ImpersonateUID string `json:"as-uid,omitempty"` + // ImpersonateGroups is the groups to impersonate. // +optional ImpersonateGroups []string `json:"as-groups,omitempty"` // ImpersonateUserExtra contains additional information for impersonated user. diff --git a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.conversion.go b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.conversion.go index 13dfa903cf..a13bae64da 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.conversion.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -166,6 +167,7 @@ func autoConvert_v1_AuthInfo_To_api_AuthInfo(in *AuthInfo, out *api.AuthInfo, s out.Token = in.Token out.TokenFile = in.TokenFile out.Impersonate = in.Impersonate + out.ImpersonateUID = in.ImpersonateUID out.ImpersonateGroups = *(*[]string)(unsafe.Pointer(&in.ImpersonateGroups)) out.ImpersonateUserExtra = *(*map[string][]string)(unsafe.Pointer(&in.ImpersonateUserExtra)) out.Username = in.Username @@ -200,6 +202,7 @@ func autoConvert_api_AuthInfo_To_v1_AuthInfo(in *api.AuthInfo, out *AuthInfo, s out.Token = in.Token out.TokenFile = in.TokenFile out.Impersonate = in.Impersonate + out.ImpersonateUID = in.ImpersonateUID out.ImpersonateGroups = *(*[]string)(unsafe.Pointer(&in.ImpersonateGroups)) out.ImpersonateUserExtra = *(*map[string][]string)(unsafe.Pointer(&in.ImpersonateUserExtra)) out.Username = in.Username diff --git a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.deepcopy.go b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.deepcopy.go index da519dfa3b..78492598bc 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.defaults.go b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.defaults.go index aae469033c..6a57decf62 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.defaults.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.defaults.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/tools/clientcmd/api/zz_generated.deepcopy.go b/vendor/k8s.io/client-go/tools/clientcmd/api/zz_generated.deepcopy.go index a04de6260b..86e4ddef1b 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/api/zz_generated.deepcopy.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/api/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/k8s.io/client-go/tools/clientcmd/client_config.go b/vendor/k8s.io/client-go/tools/clientcmd/client_config.go index 0a905490c9..cc37c9fbf6 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/client_config.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/client_config.go @@ -181,6 +181,7 @@ func (config *DirectClientConfig) ClientConfig() (*restclient.Config, error) { if len(configAuthInfo.Impersonate) > 0 { clientConfig.Impersonate = restclient.ImpersonationConfig{ UserName: configAuthInfo.Impersonate, + UID: configAuthInfo.ImpersonateUID, Groups: configAuthInfo.ImpersonateGroups, Extra: configAuthInfo.ImpersonateUserExtra, } @@ -255,6 +256,7 @@ func (config *DirectClientConfig) getUserIdentificationPartialConfig(configAuthI if len(configAuthInfo.Impersonate) > 0 { mergedConfig.Impersonate = restclient.ImpersonationConfig{ UserName: configAuthInfo.Impersonate, + UID: configAuthInfo.ImpersonateUID, Groups: configAuthInfo.ImpersonateGroups, Extra: configAuthInfo.ImpersonateUserExtra, } diff --git a/vendor/k8s.io/client-go/tools/clientcmd/overrides.go b/vendor/k8s.io/client-go/tools/clientcmd/overrides.go index 95cba0fac2..ff643cc13d 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/overrides.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/overrides.go @@ -53,6 +53,7 @@ type AuthOverrideFlags struct { ClientKey FlagInfo Token FlagInfo Impersonate FlagInfo + ImpersonateUID FlagInfo ImpersonateGroups FlagInfo Username FlagInfo Password FlagInfo @@ -154,6 +155,7 @@ const ( FlagEmbedCerts = "embed-certs" FlagBearerToken = "token" FlagImpersonate = "as" + FlagImpersonateUID = "as-uid" FlagImpersonateGroup = "as-group" FlagUsername = "username" FlagPassword = "password" @@ -179,6 +181,7 @@ func RecommendedAuthOverrideFlags(prefix string) AuthOverrideFlags { ClientKey: FlagInfo{prefix + FlagKeyFile, "", "", "Path to a client key file for TLS"}, Token: FlagInfo{prefix + FlagBearerToken, "", "", "Bearer token for authentication to the API server"}, Impersonate: FlagInfo{prefix + FlagImpersonate, "", "", "Username to impersonate for the operation"}, + ImpersonateUID: FlagInfo{prefix + FlagImpersonateUID, "", "", "UID to impersonate for the operation"}, ImpersonateGroups: FlagInfo{prefix + FlagImpersonateGroup, "", "", "Group to impersonate for the operation, this flag can be repeated to specify multiple groups."}, Username: FlagInfo{prefix + FlagUsername, "", "", "Username for basic authentication to the API server"}, Password: FlagInfo{prefix + FlagPassword, "", "", "Password for basic authentication to the API server"}, @@ -219,6 +222,7 @@ func BindAuthInfoFlags(authInfo *clientcmdapi.AuthInfo, flags *pflag.FlagSet, fl flagNames.ClientKey.BindStringFlag(flags, &authInfo.ClientKey).AddSecretAnnotation(flags) flagNames.Token.BindStringFlag(flags, &authInfo.Token).AddSecretAnnotation(flags) flagNames.Impersonate.BindStringFlag(flags, &authInfo.Impersonate).AddSecretAnnotation(flags) + flagNames.ImpersonateUID.BindStringFlag(flags, &authInfo.ImpersonateUID).AddSecretAnnotation(flags) flagNames.ImpersonateGroups.BindStringArrayFlag(flags, &authInfo.ImpersonateGroups).AddSecretAnnotation(flags) flagNames.Username.BindStringFlag(flags, &authInfo.Username).AddSecretAnnotation(flags) flagNames.Password.BindStringFlag(flags, &authInfo.Password).AddSecretAnnotation(flags) diff --git a/vendor/k8s.io/client-go/tools/clientcmd/validation.go b/vendor/k8s.io/client-go/tools/clientcmd/validation.go index 8541a08b2f..2ae1eb706a 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/validation.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/validation.go @@ -229,7 +229,7 @@ func validateClusterInfo(clusterName string, clusterInfo clientcmdapi.Cluster) [ } if proxyURL := clusterInfo.ProxyURL; proxyURL != "" { if _, err := parseProxyURL(proxyURL); err != nil { - validationErrors = append(validationErrors, fmt.Errorf("invalid 'proxy-url' %q for cluster %q: %v", proxyURL, clusterName, err)) + validationErrors = append(validationErrors, fmt.Errorf("invalid 'proxy-url' %q for cluster %q: %w", proxyURL, clusterName, err)) } } // Make sure CA data and CA file aren't both specified @@ -239,7 +239,7 @@ func validateClusterInfo(clusterName string, clusterInfo clientcmdapi.Cluster) [ if len(clusterInfo.CertificateAuthority) != 0 { clientCertCA, err := os.Open(clusterInfo.CertificateAuthority) if err != nil { - validationErrors = append(validationErrors, fmt.Errorf("unable to read certificate-authority %v for %v due to %v", clusterInfo.CertificateAuthority, clusterName, err)) + validationErrors = append(validationErrors, fmt.Errorf("unable to read certificate-authority %v for %v due to %w", clusterInfo.CertificateAuthority, clusterName, err)) } else { defer clientCertCA.Close() } @@ -278,7 +278,7 @@ func validateAuthInfo(authInfoName string, authInfo clientcmdapi.AuthInfo) []err if len(authInfo.ClientCertificate) != 0 { clientCertFile, err := os.Open(authInfo.ClientCertificate) if err != nil { - validationErrors = append(validationErrors, fmt.Errorf("unable to read client-cert %v for %v due to %v", authInfo.ClientCertificate, authInfoName, err)) + validationErrors = append(validationErrors, fmt.Errorf("unable to read client-cert %v for %v due to %w", authInfo.ClientCertificate, authInfoName, err)) } else { defer clientCertFile.Close() } @@ -286,7 +286,7 @@ func validateAuthInfo(authInfoName string, authInfo clientcmdapi.AuthInfo) []err if len(authInfo.ClientKey) != 0 { clientKeyFile, err := os.Open(authInfo.ClientKey) if err != nil { - validationErrors = append(validationErrors, fmt.Errorf("unable to read client-key %v for %v due to %v", authInfo.ClientKey, authInfoName, err)) + validationErrors = append(validationErrors, fmt.Errorf("unable to read client-key %v for %v due to %w", authInfo.ClientKey, authInfoName, err)) } else { defer clientKeyFile.Close() } @@ -323,9 +323,9 @@ func validateAuthInfo(authInfoName string, authInfo clientcmdapi.AuthInfo) []err validationErrors = append(validationErrors, fmt.Errorf("more than one authentication method found for %v; found %v, only one is allowed", authInfoName, methods)) } - // ImpersonateGroups or ImpersonateUserExtra should be requested with a user - if (len(authInfo.ImpersonateGroups) > 0 || len(authInfo.ImpersonateUserExtra) > 0) && (len(authInfo.Impersonate) == 0) { - validationErrors = append(validationErrors, fmt.Errorf("requesting groups or user-extra for %v without impersonating a user", authInfoName)) + // ImpersonateUID, ImpersonateGroups or ImpersonateUserExtra should be requested with a user + if (len(authInfo.ImpersonateUID) > 0 || len(authInfo.ImpersonateGroups) > 0 || len(authInfo.ImpersonateUserExtra) > 0) && (len(authInfo.Impersonate) == 0) { + validationErrors = append(validationErrors, fmt.Errorf("requesting uid, groups or user-extra for %v without impersonating a user", authInfoName)) } return validationErrors } diff --git a/vendor/k8s.io/client-go/tools/events/doc.go b/vendor/k8s.io/client-go/tools/events/doc.go index 795582b028..8c48f607e1 100644 --- a/vendor/k8s.io/client-go/tools/events/doc.go +++ b/vendor/k8s.io/client-go/tools/events/doc.go @@ -15,5 +15,5 @@ limitations under the License. */ // Package events has all client logic for recording and reporting -// "k8s.io/api/events/v1beta1".Event events. +// "k8s.io/api/events/v1".Event events. package events // import "k8s.io/client-go/tools/events" diff --git a/vendor/k8s.io/client-go/tools/events/event_broadcaster.go b/vendor/k8s.io/client-go/tools/events/event_broadcaster.go index bde888ee98..3dd3cea1a9 100644 --- a/vendor/k8s.io/client-go/tools/events/event_broadcaster.go +++ b/vendor/k8s.io/client-go/tools/events/event_broadcaster.go @@ -29,7 +29,6 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/json" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/strategicpatch" @@ -43,6 +42,7 @@ import ( "k8s.io/client-go/tools/record" "k8s.io/client-go/tools/record/util" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) const ( @@ -290,6 +290,20 @@ func getKey(event *eventsv1.Event) eventKey { return key } +// StartStructuredLogging starts sending events received from this EventBroadcaster to the structured logging function. +// The return value can be ignored or used to stop recording, if desired. +func (e *eventBroadcasterImpl) StartStructuredLogging(verbosity klog.Level) func() { + return e.StartEventWatcher( + func(obj runtime.Object) { + event, ok := obj.(*eventsv1.Event) + if !ok { + klog.Errorf("unexpected type, expected eventsv1.Event") + return + } + klog.V(verbosity).InfoS("Event occurred", "object", klog.KRef(event.Regarding.Namespace, event.Regarding.Name), "kind", event.Regarding.Kind, "apiVersion", event.Regarding.APIVersion, "type", event.Type, "reason", event.Reason, "action", event.Action, "note", event.Note) + }) +} + // StartEventWatcher starts sending events received from this EventBroadcaster to the given event handler function. // The return value is used to stop recording func (e *eventBroadcasterImpl) StartEventWatcher(eventHandler func(event runtime.Object)) func() { diff --git a/vendor/k8s.io/client-go/tools/events/event_recorder.go b/vendor/k8s.io/client-go/tools/events/event_recorder.go index 2837cc1603..132843742b 100644 --- a/vendor/k8s.io/client-go/tools/events/event_recorder.go +++ b/vendor/k8s.io/client-go/tools/events/event_recorder.go @@ -24,12 +24,12 @@ import ( eventsv1 "k8s.io/api/events/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/util/clock" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/watch" "k8s.io/client-go/tools/record/util" "k8s.io/client-go/tools/reference" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) type recorderImpl struct { @@ -48,9 +48,13 @@ func (recorder *recorderImpl) Eventf(regarding runtime.Object, related runtime.O klog.Errorf("Could not construct reference to: '%#v' due to: '%v'. Will not report event: '%v' '%v' '%v'", regarding, err, eventtype, reason, message) return } - refRelated, err := reference.GetReference(recorder.scheme, related) - if err != nil { - klog.V(9).Infof("Could not construct reference to: '%#v' due to: '%v'.", related, err) + + var refRelated *v1.ObjectReference + if related != nil { + refRelated, err = reference.GetReference(recorder.scheme, related) + if err != nil { + klog.V(9).Infof("Could not construct reference to: '%#v' due to: '%v'.", related, err) + } } if !util.ValidateEventType(eventtype) { klog.Errorf("Unsupported event type: '%v'", eventtype) diff --git a/vendor/k8s.io/client-go/tools/events/interfaces.go b/vendor/k8s.io/client-go/tools/events/interfaces.go index f1a523caa8..57bfa1ce81 100644 --- a/vendor/k8s.io/client-go/tools/events/interfaces.go +++ b/vendor/k8s.io/client-go/tools/events/interfaces.go @@ -20,6 +20,7 @@ import ( eventsv1 "k8s.io/api/events/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/tools/record" + "k8s.io/klog/v2" ) // EventRecorder knows how to record events on behalf of an EventSource. @@ -56,6 +57,10 @@ type EventBroadcaster interface { // TODO: figure out if this can be removed. StartEventWatcher(eventHandler func(event runtime.Object)) func() + // StartStructuredLogging starts sending events received from this EventBroadcaster to the structured + // logging function. The return value can be ignored or used to stop recording, if desired. + StartStructuredLogging(verbosity klog.Level) func() + // Shutdown shuts down the broadcaster Shutdown() } diff --git a/vendor/k8s.io/client-go/tools/leaderelection/leaderelection.go b/vendor/k8s.io/client-go/tools/leaderelection/leaderelection.go index 55f34fd3e7..03a13e6b63 100644 --- a/vendor/k8s.io/client-go/tools/leaderelection/leaderelection.go +++ b/vendor/k8s.io/client-go/tools/leaderelection/leaderelection.go @@ -61,10 +61,10 @@ import ( "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" rl "k8s.io/client-go/tools/leaderelection/resourcelock" + "k8s.io/utils/clock" "k8s.io/klog/v2" ) @@ -143,7 +143,7 @@ type LeaderElectionConfig struct { Callbacks LeaderCallbacks // WatchDog is the associated health checker - // WatchDog may be null if its not needed/configured. + // WatchDog may be null if it's not needed/configured. WatchDog *HealthzAdaptor // ReleaseOnCancel should be set true if the lock should be released diff --git a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go index ceb76b9cbe..552280d2d7 100644 --- a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go +++ b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go @@ -107,7 +107,11 @@ func (cml *ConfigMapLock) RecordEvent(s string) { return } events := fmt.Sprintf("%v %v", cml.LockConfig.Identity, s) - cml.LockConfig.EventRecorder.Eventf(&v1.ConfigMap{ObjectMeta: cml.cm.ObjectMeta}, v1.EventTypeNormal, "LeaderElection", events) + subject := &v1.ConfigMap{ObjectMeta: cml.cm.ObjectMeta} + // Populate the type meta, so we don't have to get it from the schema + subject.Kind = "ConfigMap" + subject.APIVersion = v1.SchemeGroupVersion.String() + cml.LockConfig.EventRecorder.Eventf(subject, v1.EventTypeNormal, "LeaderElection", events) } // Describe is used to convert details on current resource lock diff --git a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/endpointslock.go b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/endpointslock.go index 20b4c94d99..dcd2026efd 100644 --- a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/endpointslock.go +++ b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/endpointslock.go @@ -102,7 +102,11 @@ func (el *EndpointsLock) RecordEvent(s string) { return } events := fmt.Sprintf("%v %v", el.LockConfig.Identity, s) - el.LockConfig.EventRecorder.Eventf(&v1.Endpoints{ObjectMeta: el.e.ObjectMeta}, v1.EventTypeNormal, "LeaderElection", events) + subject := &v1.Endpoints{ObjectMeta: el.e.ObjectMeta} + // Populate the type meta, so we don't have to get it from the schema + subject.Kind = "Endpoints" + subject.APIVersion = v1.SchemeGroupVersion.String() + el.LockConfig.EventRecorder.Eventf(subject, v1.EventTypeNormal, "LeaderElection", events) } // Describe is used to convert details on current resource lock diff --git a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/leaselock.go b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/leaselock.go index a403497279..ab80d7f158 100644 --- a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/leaselock.go +++ b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/leaselock.go @@ -87,7 +87,11 @@ func (ll *LeaseLock) RecordEvent(s string) { return } events := fmt.Sprintf("%v %v", ll.LockConfig.Identity, s) - ll.LockConfig.EventRecorder.Eventf(&coordinationv1.Lease{ObjectMeta: ll.lease.ObjectMeta}, corev1.EventTypeNormal, "LeaderElection", events) + subject := &coordinationv1.Lease{ObjectMeta: ll.lease.ObjectMeta} + // Populate the type meta, so we don't have to get it from the schema + subject.Kind = "Lease" + subject.APIVersion = coordinationv1.SchemeGroupVersion.String() + ll.LockConfig.EventRecorder.Eventf(subject, corev1.EventTypeNormal, "LeaderElection", events) } // Describe is used to convert details on current resource lock diff --git a/vendor/k8s.io/client-go/tools/record/event.go b/vendor/k8s.io/client-go/tools/record/event.go index 30a6660198..4b61d0052f 100644 --- a/vendor/k8s.io/client-go/tools/record/event.go +++ b/vendor/k8s.io/client-go/tools/record/event.go @@ -25,13 +25,13 @@ import ( "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/util/clock" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/watch" restclient "k8s.io/client-go/rest" "k8s.io/client-go/tools/record/util" ref "k8s.io/client-go/tools/reference" "k8s.io/klog/v2" + "k8s.io/utils/clock" ) const maxTriesPerEvent = 12 @@ -81,7 +81,10 @@ type CorrelatorOptions struct { MaxIntervalInSeconds int // The clock used by the EventAggregator to allow for testing // If not specified (zero value), clock.RealClock{} will be used - Clock clock.Clock + Clock clock.PassiveClock + // The func used by EventFilterFunc, which returns a key for given event, based on which filtering will take place + // If not specified (zero value), getSpamKey will be used + SpamKeyFunc EventSpamKeyFunc } // EventRecorder knows how to record events on behalf of an EventSource. @@ -320,7 +323,7 @@ type recorderImpl struct { scheme *runtime.Scheme source v1.EventSource *watch.Broadcaster - clock clock.Clock + clock clock.PassiveClock } func (recorder *recorderImpl) generateEvent(object runtime.Object, annotations map[string]string, eventtype, reason, message string) { diff --git a/vendor/k8s.io/client-go/tools/record/events_cache.go b/vendor/k8s.io/client-go/tools/record/events_cache.go index 329c7ce575..4f041e8fd2 100644 --- a/vendor/k8s.io/client-go/tools/record/events_cache.go +++ b/vendor/k8s.io/client-go/tools/record/events_cache.go @@ -27,10 +27,10 @@ import ( v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/clock" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/strategicpatch" "k8s.io/client-go/util/flowcontrol" + "k8s.io/utils/clock" ) const ( @@ -81,6 +81,9 @@ func getSpamKey(event *v1.Event) string { "") } +// EventSpamKeyFunc is a function that returns unique key based on provided event +type EventSpamKeyFunc func(event *v1.Event) string + // EventFilterFunc is a function that returns true if the event should be skipped type EventFilterFunc func(event *v1.Event) bool @@ -99,31 +102,35 @@ type EventSourceObjectSpamFilter struct { qps float32 // clock is used to allow for testing over a time interval - clock clock.Clock + clock clock.PassiveClock + + // spamKeyFunc is a func used to create a key based on an event, which is later used to filter spam events. + spamKeyFunc EventSpamKeyFunc } // NewEventSourceObjectSpamFilter allows burst events from a source about an object with the specified qps refill. -func NewEventSourceObjectSpamFilter(lruCacheSize, burst int, qps float32, clock clock.Clock) *EventSourceObjectSpamFilter { +func NewEventSourceObjectSpamFilter(lruCacheSize, burst int, qps float32, clock clock.PassiveClock, spamKeyFunc EventSpamKeyFunc) *EventSourceObjectSpamFilter { return &EventSourceObjectSpamFilter{ - cache: lru.New(lruCacheSize), - burst: burst, - qps: qps, - clock: clock, + cache: lru.New(lruCacheSize), + burst: burst, + qps: qps, + clock: clock, + spamKeyFunc: spamKeyFunc, } } // spamRecord holds data used to perform spam filtering decisions. type spamRecord struct { // rateLimiter controls the rate of events about this object - rateLimiter flowcontrol.RateLimiter + rateLimiter flowcontrol.PassiveRateLimiter } // Filter controls that a given source+object are not exceeding the allowed rate. func (f *EventSourceObjectSpamFilter) Filter(event *v1.Event) bool { var record spamRecord - // controls our cached information about this event (source+object) - eventKey := getSpamKey(event) + // controls our cached information about this event + eventKey := f.spamKeyFunc(event) // do we have a record of similar events in our cache? f.Lock() @@ -135,7 +142,7 @@ func (f *EventSourceObjectSpamFilter) Filter(event *v1.Event) bool { // verify we have a rate limiter for this record if record.rateLimiter == nil { - record.rateLimiter = flowcontrol.NewTokenBucketRateLimiterWithClock(f.qps, f.burst, f.clock) + record.rateLimiter = flowcontrol.NewTokenBucketPassiveRateLimiterWithClock(f.qps, f.burst, f.clock) } // ensure we have available rate @@ -200,12 +207,12 @@ type EventAggregator struct { maxIntervalInSeconds uint // clock is used to allow for testing over a time interval - clock clock.Clock + clock clock.PassiveClock } // NewEventAggregator returns a new instance of an EventAggregator func NewEventAggregator(lruCacheSize int, keyFunc EventAggregatorKeyFunc, messageFunc EventAggregatorMessageFunc, - maxEvents int, maxIntervalInSeconds int, clock clock.Clock) *EventAggregator { + maxEvents int, maxIntervalInSeconds int, clock clock.PassiveClock) *EventAggregator { return &EventAggregator{ cache: lru.New(lruCacheSize), keyFunc: keyFunc, @@ -308,11 +315,11 @@ type eventLog struct { type eventLogger struct { sync.RWMutex cache *lru.Cache - clock clock.Clock + clock clock.PassiveClock } // newEventLogger observes events and counts their frequencies -func newEventLogger(lruCacheEntries int, clock clock.Clock) *eventLogger { +func newEventLogger(lruCacheEntries int, clock clock.PassiveClock) *eventLogger { return &eventLogger{cache: lru.New(lruCacheEntries), clock: clock} } @@ -429,9 +436,9 @@ type EventCorrelateResult struct { // times. // * A source may burst 25 events about an object, but has a refill rate budget // per object of 1 event every 5 minutes to control long-tail of spam. -func NewEventCorrelator(clock clock.Clock) *EventCorrelator { +func NewEventCorrelator(clock clock.PassiveClock) *EventCorrelator { cacheSize := maxLruCacheEntries - spamFilter := NewEventSourceObjectSpamFilter(cacheSize, defaultSpamBurst, defaultSpamQPS, clock) + spamFilter := NewEventSourceObjectSpamFilter(cacheSize, defaultSpamBurst, defaultSpamQPS, clock, getSpamKey) return &EventCorrelator{ filterFunc: spamFilter.Filter, aggregator: NewEventAggregator( @@ -448,8 +455,12 @@ func NewEventCorrelator(clock clock.Clock) *EventCorrelator { func NewEventCorrelatorWithOptions(options CorrelatorOptions) *EventCorrelator { optionsWithDefaults := populateDefaults(options) - spamFilter := NewEventSourceObjectSpamFilter(optionsWithDefaults.LRUCacheSize, - optionsWithDefaults.BurstSize, optionsWithDefaults.QPS, optionsWithDefaults.Clock) + spamFilter := NewEventSourceObjectSpamFilter( + optionsWithDefaults.LRUCacheSize, + optionsWithDefaults.BurstSize, + optionsWithDefaults.QPS, + optionsWithDefaults.Clock, + optionsWithDefaults.SpamKeyFunc) return &EventCorrelator{ filterFunc: spamFilter.Filter, aggregator: NewEventAggregator( @@ -489,6 +500,9 @@ func populateDefaults(options CorrelatorOptions) CorrelatorOptions { if options.Clock == nil { options.Clock = clock.RealClock{} } + if options.SpamKeyFunc == nil { + options.SpamKeyFunc = getSpamKey + } return options } diff --git a/vendor/k8s.io/client-go/transport/config.go b/vendor/k8s.io/client-go/transport/config.go index 0704748317..89de798f60 100644 --- a/vendor/k8s.io/client-go/transport/config.go +++ b/vendor/k8s.io/client-go/transport/config.go @@ -82,6 +82,8 @@ type Config struct { type ImpersonationConfig struct { // UserName matches user.Info.GetName() UserName string + // UID matches user.Info.GetUID() + UID string // Groups matches user.Info.GetGroups() Groups []string // Extra matches user.Info.GetExtra() diff --git a/vendor/k8s.io/client-go/transport/round_trippers.go b/vendor/k8s.io/client-go/transport/round_trippers.go index 818fd52d6e..4c74606a98 100644 --- a/vendor/k8s.io/client-go/transport/round_trippers.go +++ b/vendor/k8s.io/client-go/transport/round_trippers.go @@ -17,9 +17,12 @@ limitations under the License. package transport import ( + "crypto/tls" "fmt" "net/http" + "net/http/httptrace" "strings" + "sync" "time" "golang.org/x/oauth2" @@ -57,6 +60,7 @@ func HTTPWrappersForConfig(config *Config, rt http.RoundTripper) (http.RoundTrip rt = NewUserAgentRoundTripper(config.UserAgent, rt) } if len(config.Impersonate.UserName) > 0 || + len(config.Impersonate.UID) > 0 || len(config.Impersonate.Groups) > 0 || len(config.Impersonate.Extra) > 0 { rt = NewImpersonatingRoundTripper(config.Impersonate, rt) @@ -68,7 +72,7 @@ func HTTPWrappersForConfig(config *Config, rt http.RoundTripper) (http.RoundTrip func DebugWrappers(rt http.RoundTripper) http.RoundTripper { switch { case bool(klog.V(9).Enabled()): - rt = NewDebuggingRoundTripper(rt, DebugCurlCommand, DebugURLTiming, DebugResponseHeaders) + rt = NewDebuggingRoundTripper(rt, DebugCurlCommand, DebugDetailedTiming, DebugResponseHeaders) case bool(klog.V(8).Enabled()): rt = NewDebuggingRoundTripper(rt, DebugJustURL, DebugRequestHeaders, DebugResponseStatus, DebugResponseHeaders) case bool(klog.V(7).Enabled()): @@ -88,6 +92,8 @@ type authProxyRoundTripper struct { rt http.RoundTripper } +var _ utilnet.RoundTripperWrapper = &authProxyRoundTripper{} + // NewAuthProxyRoundTripper provides a roundtripper which will add auth proxy fields to requests for // authentication terminating proxy cases // assuming you pull the user from the context: @@ -146,6 +152,8 @@ type userAgentRoundTripper struct { rt http.RoundTripper } +var _ utilnet.RoundTripperWrapper = &userAgentRoundTripper{} + // NewUserAgentRoundTripper will add User-Agent header to a request unless it has already been set. func NewUserAgentRoundTripper(agent string, rt http.RoundTripper) http.RoundTripper { return &userAgentRoundTripper{agent, rt} @@ -172,6 +180,8 @@ type basicAuthRoundTripper struct { rt http.RoundTripper } +var _ utilnet.RoundTripperWrapper = &basicAuthRoundTripper{} + // NewBasicAuthRoundTripper will apply a BASIC auth authorization header to a // request unless it has already been set. func NewBasicAuthRoundTripper(username, password string, rt http.RoundTripper) http.RoundTripper { @@ -199,6 +209,9 @@ const ( // ImpersonateUserHeader is used to impersonate a particular user during an API server request ImpersonateUserHeader = "Impersonate-User" + // ImpersonateUIDHeader is used to impersonate a particular UID during an API server request + ImpersonateUIDHeader = "Impersonate-Uid" + // ImpersonateGroupHeader is used to impersonate a particular group during an API server request. // It can be repeated multiplied times for multiple groups. ImpersonateGroupHeader = "Impersonate-Group" @@ -218,6 +231,8 @@ type impersonatingRoundTripper struct { delegate http.RoundTripper } +var _ utilnet.RoundTripperWrapper = &impersonatingRoundTripper{} + // NewImpersonatingRoundTripper will add an Act-As header to a request unless it has already been set. func NewImpersonatingRoundTripper(impersonate ImpersonationConfig, delegate http.RoundTripper) http.RoundTripper { return &impersonatingRoundTripper{impersonate, delegate} @@ -230,7 +245,9 @@ func (rt *impersonatingRoundTripper) RoundTrip(req *http.Request) (*http.Respons } req = utilnet.CloneRequest(req) req.Header.Set(ImpersonateUserHeader, rt.impersonate.UserName) - + if rt.impersonate.UID != "" { + req.Header.Set(ImpersonateUIDHeader, rt.impersonate.UID) + } for _, group := range rt.impersonate.Groups { req.Header.Add(ImpersonateGroupHeader, group) } @@ -255,6 +272,8 @@ type bearerAuthRoundTripper struct { rt http.RoundTripper } +var _ utilnet.RoundTripperWrapper = &bearerAuthRoundTripper{} + // NewBearerAuthRoundTripper adds the provided bearer token to a request // unless the authorization header has already been set. func NewBearerAuthRoundTripper(bearer string, rt http.RoundTripper) http.RoundTripper { @@ -314,6 +333,14 @@ type requestInfo struct { ResponseHeaders http.Header ResponseErr error + muTrace sync.Mutex // Protect trace fields + DNSLookup time.Duration + Dialing time.Duration + GetConnection time.Duration + TLSHandshake time.Duration + ServerProcessing time.Duration + ConnectionReused bool + Duration time.Duration } @@ -356,6 +383,8 @@ type debuggingRoundTripper struct { levels map[DebugLevel]bool } +var _ utilnet.RoundTripperWrapper = &debuggingRoundTripper{} + // DebugLevel is used to enable debugging of certain // HTTP requests and responses fields via the debuggingRoundTripper. type DebugLevel int @@ -374,6 +403,8 @@ const ( DebugResponseStatus // DebugResponseHeaders will add to the debug output the HTTP response headers. DebugResponseHeaders + // DebugDetailedTiming will add to the debug output the duration of the HTTP requests events. + DebugDetailedTiming ) // NewDebuggingRoundTripper allows to display in the logs output debug information @@ -445,6 +476,74 @@ func (rt *debuggingRoundTripper) RoundTrip(req *http.Request) (*http.Response, e } startTime := time.Now() + + if rt.levels[DebugDetailedTiming] { + var getConn, dnsStart, dialStart, tlsStart, serverStart time.Time + var host string + trace := &httptrace.ClientTrace{ + // DNS + DNSStart: func(info httptrace.DNSStartInfo) { + reqInfo.muTrace.Lock() + defer reqInfo.muTrace.Unlock() + dnsStart = time.Now() + host = info.Host + }, + DNSDone: func(info httptrace.DNSDoneInfo) { + reqInfo.muTrace.Lock() + defer reqInfo.muTrace.Unlock() + reqInfo.DNSLookup = time.Now().Sub(dnsStart) + klog.Infof("HTTP Trace: DNS Lookup for %s resolved to %v", host, info.Addrs) + }, + // Dial + ConnectStart: func(network, addr string) { + reqInfo.muTrace.Lock() + defer reqInfo.muTrace.Unlock() + dialStart = time.Now() + }, + ConnectDone: func(network, addr string, err error) { + reqInfo.muTrace.Lock() + defer reqInfo.muTrace.Unlock() + reqInfo.Dialing = time.Now().Sub(dialStart) + if err != nil { + klog.Infof("HTTP Trace: Dial to %s:%s failed: %v", network, addr, err) + } else { + klog.Infof("HTTP Trace: Dial to %s:%s succeed", network, addr) + } + }, + // TLS + TLSHandshakeStart: func() { + tlsStart = time.Now() + }, + TLSHandshakeDone: func(_ tls.ConnectionState, _ error) { + reqInfo.muTrace.Lock() + defer reqInfo.muTrace.Unlock() + reqInfo.TLSHandshake = time.Now().Sub(tlsStart) + }, + // Connection (it can be DNS + Dial or just the time to get one from the connection pool) + GetConn: func(hostPort string) { + getConn = time.Now() + }, + GotConn: func(info httptrace.GotConnInfo) { + reqInfo.muTrace.Lock() + defer reqInfo.muTrace.Unlock() + reqInfo.GetConnection = time.Now().Sub(getConn) + reqInfo.ConnectionReused = info.Reused + }, + // Server Processing (time since we wrote the request until first byte is received) + WroteRequest: func(info httptrace.WroteRequestInfo) { + reqInfo.muTrace.Lock() + defer reqInfo.muTrace.Unlock() + serverStart = time.Now() + }, + GotFirstResponseByte: func() { + reqInfo.muTrace.Lock() + defer reqInfo.muTrace.Unlock() + reqInfo.ServerProcessing = time.Now().Sub(serverStart) + }, + } + req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace)) + } + response, err := rt.delegatedRoundTripper.RoundTrip(req) reqInfo.Duration = time.Since(startTime) @@ -453,6 +552,24 @@ func (rt *debuggingRoundTripper) RoundTrip(req *http.Request) (*http.Response, e if rt.levels[DebugURLTiming] { klog.Infof("%s %s %s in %d milliseconds", reqInfo.RequestVerb, reqInfo.RequestURL, reqInfo.ResponseStatus, reqInfo.Duration.Nanoseconds()/int64(time.Millisecond)) } + if rt.levels[DebugDetailedTiming] { + stats := "" + if !reqInfo.ConnectionReused { + stats += fmt.Sprintf(`DNSLookup %d ms Dial %d ms TLSHandshake %d ms`, + reqInfo.DNSLookup.Nanoseconds()/int64(time.Millisecond), + reqInfo.Dialing.Nanoseconds()/int64(time.Millisecond), + reqInfo.TLSHandshake.Nanoseconds()/int64(time.Millisecond), + ) + } else { + stats += fmt.Sprintf(`GetConnection %d ms`, reqInfo.GetConnection.Nanoseconds()/int64(time.Millisecond)) + } + if reqInfo.ServerProcessing != 0 { + stats += fmt.Sprintf(` ServerProcessing %d ms`, reqInfo.ServerProcessing.Nanoseconds()/int64(time.Millisecond)) + } + stats += fmt.Sprintf(` Duration %d ms`, reqInfo.Duration.Nanoseconds()/int64(time.Millisecond)) + klog.Infof("HTTP Statistics: %s", stats) + } + if rt.levels[DebugResponseStatus] { klog.Infof("Response Status: %s in %d milliseconds", reqInfo.ResponseStatus, reqInfo.Duration.Nanoseconds()/int64(time.Millisecond)) } diff --git a/vendor/k8s.io/client-go/transport/token_source.go b/vendor/k8s.io/client-go/transport/token_source.go index fea02e6111..68a0a704fe 100644 --- a/vendor/k8s.io/client-go/transport/token_source.go +++ b/vendor/k8s.io/client-go/transport/token_source.go @@ -26,6 +26,7 @@ import ( "golang.org/x/oauth2" + utilnet "k8s.io/apimachinery/pkg/util/net" "k8s.io/klog/v2" ) @@ -95,6 +96,8 @@ type tokenSourceTransport struct { src ResettableTokenSource } +var _ utilnet.RoundTripperWrapper = &tokenSourceTransport{} + func (tst *tokenSourceTransport) RoundTrip(req *http.Request) (*http.Response, error) { // This is to allow --token to override other bearer token providers. if req.Header.Get("Authorization") != "" { @@ -119,6 +122,8 @@ func (tst *tokenSourceTransport) CancelRequest(req *http.Request) { tryCancelRequest(tst.ort, req) } +func (tst *tokenSourceTransport) WrappedRoundTripper() http.RoundTripper { return tst.base } + type fileTokenSource struct { path string period time.Duration diff --git a/vendor/k8s.io/client-go/util/cert/cert.go b/vendor/k8s.io/client-go/util/cert/cert.go index bffb152627..75143ec071 100644 --- a/vendor/k8s.io/client-go/util/cert/cert.go +++ b/vendor/k8s.io/client-go/util/cert/cert.go @@ -33,6 +33,7 @@ import ( "time" "k8s.io/client-go/util/keyutil" + netutils "k8s.io/utils/net" ) const duration365d = time.Hour * 24 * 365 @@ -157,7 +158,7 @@ func GenerateSelfSignedCertKeyWithFixtures(host string, alternateIPs []net.IP, a BasicConstraintsValid: true, } - if ip := net.ParseIP(host); ip != nil { + if ip := netutils.ParseIPSloppy(host); ip != nil { template.IPAddresses = append(template.IPAddresses, ip) } else { template.DNSNames = append(template.DNSNames, host) diff --git a/vendor/k8s.io/client-go/util/flowcontrol/backoff.go b/vendor/k8s.io/client-go/util/flowcontrol/backoff.go index c48ba03e8c..3ef88dbdb8 100644 --- a/vendor/k8s.io/client-go/util/flowcontrol/backoff.go +++ b/vendor/k8s.io/client-go/util/flowcontrol/backoff.go @@ -17,10 +17,12 @@ limitations under the License. package flowcontrol import ( + "math/rand" "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" + "k8s.io/utils/clock" + testingclock "k8s.io/utils/clock/testing" "k8s.io/utils/integer" ) @@ -35,23 +37,43 @@ type Backoff struct { defaultDuration time.Duration maxDuration time.Duration perItemBackoff map[string]*backoffEntry + rand *rand.Rand + + // maxJitterFactor adds jitter to the exponentially backed off delay. + // if maxJitterFactor is zero, no jitter is added to the delay in + // order to maintain current behavior. + maxJitterFactor float64 } -func NewFakeBackOff(initial, max time.Duration, tc *clock.FakeClock) *Backoff { - return &Backoff{ - perItemBackoff: map[string]*backoffEntry{}, - Clock: tc, - defaultDuration: initial, - maxDuration: max, - } +func NewFakeBackOff(initial, max time.Duration, tc *testingclock.FakeClock) *Backoff { + return newBackoff(tc, initial, max, 0.0) } func NewBackOff(initial, max time.Duration) *Backoff { + return NewBackOffWithJitter(initial, max, 0.0) +} + +func NewFakeBackOffWithJitter(initial, max time.Duration, tc *testingclock.FakeClock, maxJitterFactor float64) *Backoff { + return newBackoff(tc, initial, max, maxJitterFactor) +} + +func NewBackOffWithJitter(initial, max time.Duration, maxJitterFactor float64) *Backoff { + clock := clock.RealClock{} + return newBackoff(clock, initial, max, maxJitterFactor) +} + +func newBackoff(clock clock.Clock, initial, max time.Duration, maxJitterFactor float64) *Backoff { + var random *rand.Rand + if maxJitterFactor > 0 { + random = rand.New(rand.NewSource(clock.Now().UnixNano())) + } return &Backoff{ perItemBackoff: map[string]*backoffEntry{}, - Clock: clock.RealClock{}, + Clock: clock, defaultDuration: initial, maxDuration: max, + maxJitterFactor: maxJitterFactor, + rand: random, } } @@ -74,8 +96,10 @@ func (p *Backoff) Next(id string, eventTime time.Time) { entry, ok := p.perItemBackoff[id] if !ok || hasExpired(eventTime, entry.lastUpdate, p.maxDuration) { entry = p.initEntryUnsafe(id) + entry.backoff += p.jitter(entry.backoff) } else { - delay := entry.backoff * 2 // exponential + delay := entry.backoff * 2 // exponential + delay += p.jitter(entry.backoff) // add some jitter to the delay entry.backoff = time.Duration(integer.Int64Min(int64(delay), int64(p.maxDuration))) } entry.lastUpdate = p.Clock.Now() @@ -143,6 +167,14 @@ func (p *Backoff) initEntryUnsafe(id string) *backoffEntry { return entry } +func (p *Backoff) jitter(delay time.Duration) time.Duration { + if p.rand == nil { + return 0 + } + + return time.Duration(p.rand.Float64() * p.maxJitterFactor * float64(delay)) +} + // After 2*maxDuration we restart the backoff factor to the beginning func hasExpired(eventTime time.Time, lastUpdate time.Time, maxDuration time.Duration) bool { return eventTime.Sub(lastUpdate) > maxDuration*2 // consider stable if it's ok for twice the maxDuration diff --git a/vendor/k8s.io/client-go/util/flowcontrol/throttle.go b/vendor/k8s.io/client-go/util/flowcontrol/throttle.go index ffd912c560..af7abd898f 100644 --- a/vendor/k8s.io/client-go/util/flowcontrol/throttle.go +++ b/vendor/k8s.io/client-go/util/flowcontrol/throttle.go @@ -23,26 +23,36 @@ import ( "time" "golang.org/x/time/rate" + "k8s.io/utils/clock" ) -type RateLimiter interface { +type PassiveRateLimiter interface { // TryAccept returns true if a token is taken immediately. Otherwise, // it returns false. TryAccept() bool - // Accept returns once a token becomes available. - Accept() // Stop stops the rate limiter, subsequent calls to CanAccept will return false Stop() // QPS returns QPS of this rate limiter QPS() float32 +} + +type RateLimiter interface { + PassiveRateLimiter + // Accept returns once a token becomes available. + Accept() // Wait returns nil if a token is taken before the Context is done. Wait(ctx context.Context) error } -type tokenBucketRateLimiter struct { +type tokenBucketPassiveRateLimiter struct { limiter *rate.Limiter - clock Clock qps float32 + clock clock.PassiveClock +} + +type tokenBucketRateLimiter struct { + tokenBucketPassiveRateLimiter + clock Clock } // NewTokenBucketRateLimiter creates a rate limiter which implements a token bucket approach. @@ -52,58 +62,73 @@ type tokenBucketRateLimiter struct { // The maximum number of tokens in the bucket is capped at 'burst'. func NewTokenBucketRateLimiter(qps float32, burst int) RateLimiter { limiter := rate.NewLimiter(rate.Limit(qps), burst) - return newTokenBucketRateLimiter(limiter, realClock{}, qps) + return newTokenBucketRateLimiterWithClock(limiter, clock.RealClock{}, qps) +} + +// NewTokenBucketPassiveRateLimiter is similar to NewTokenBucketRateLimiter except that it returns +// a PassiveRateLimiter which does not have Accept() and Wait() methods. +func NewTokenBucketPassiveRateLimiter(qps float32, burst int) PassiveRateLimiter { + limiter := rate.NewLimiter(rate.Limit(qps), burst) + return newTokenBucketRateLimiterWithPassiveClock(limiter, clock.RealClock{}, qps) } // An injectable, mockable clock interface. type Clock interface { - Now() time.Time + clock.PassiveClock Sleep(time.Duration) } -type realClock struct{} - -func (realClock) Now() time.Time { - return time.Now() -} -func (realClock) Sleep(d time.Duration) { - time.Sleep(d) -} +var _ Clock = (*clock.RealClock)(nil) // NewTokenBucketRateLimiterWithClock is identical to NewTokenBucketRateLimiter // but allows an injectable clock, for testing. func NewTokenBucketRateLimiterWithClock(qps float32, burst int, c Clock) RateLimiter { limiter := rate.NewLimiter(rate.Limit(qps), burst) - return newTokenBucketRateLimiter(limiter, c, qps) + return newTokenBucketRateLimiterWithClock(limiter, c, qps) +} + +// NewTokenBucketPassiveRateLimiterWithClock is similar to NewTokenBucketRateLimiterWithClock +// except that it returns a PassiveRateLimiter which does not have Accept() and Wait() methods +// and uses a PassiveClock. +func NewTokenBucketPassiveRateLimiterWithClock(qps float32, burst int, c clock.PassiveClock) PassiveRateLimiter { + limiter := rate.NewLimiter(rate.Limit(qps), burst) + return newTokenBucketRateLimiterWithPassiveClock(limiter, c, qps) } -func newTokenBucketRateLimiter(limiter *rate.Limiter, c Clock, qps float32) RateLimiter { +func newTokenBucketRateLimiterWithClock(limiter *rate.Limiter, c Clock, qps float32) *tokenBucketRateLimiter { return &tokenBucketRateLimiter{ + tokenBucketPassiveRateLimiter: *newTokenBucketRateLimiterWithPassiveClock(limiter, c, qps), + clock: c, + } +} + +func newTokenBucketRateLimiterWithPassiveClock(limiter *rate.Limiter, c clock.PassiveClock, qps float32) *tokenBucketPassiveRateLimiter { + return &tokenBucketPassiveRateLimiter{ limiter: limiter, - clock: c, qps: qps, + clock: c, } } -func (t *tokenBucketRateLimiter) TryAccept() bool { - return t.limiter.AllowN(t.clock.Now(), 1) +func (tbprl *tokenBucketPassiveRateLimiter) Stop() { } -// Accept will block until a token becomes available -func (t *tokenBucketRateLimiter) Accept() { - now := t.clock.Now() - t.clock.Sleep(t.limiter.ReserveN(now, 1).DelayFrom(now)) +func (tbprl *tokenBucketPassiveRateLimiter) QPS() float32 { + return tbprl.qps } -func (t *tokenBucketRateLimiter) Stop() { +func (tbprl *tokenBucketPassiveRateLimiter) TryAccept() bool { + return tbprl.limiter.AllowN(tbprl.clock.Now(), 1) } -func (t *tokenBucketRateLimiter) QPS() float32 { - return t.qps +// Accept will block until a token becomes available +func (tbrl *tokenBucketRateLimiter) Accept() { + now := tbrl.clock.Now() + tbrl.clock.Sleep(tbrl.limiter.ReserveN(now, 1).DelayFrom(now)) } -func (t *tokenBucketRateLimiter) Wait(ctx context.Context) error { - return t.limiter.Wait(ctx) +func (tbrl *tokenBucketRateLimiter) Wait(ctx context.Context) error { + return tbrl.limiter.Wait(ctx) } type fakeAlwaysRateLimiter struct{} @@ -157,3 +182,11 @@ func (t *fakeNeverRateLimiter) QPS() float32 { func (t *fakeNeverRateLimiter) Wait(ctx context.Context) error { return errors.New("can not be accept") } + +var ( + _ RateLimiter = (*tokenBucketRateLimiter)(nil) + _ RateLimiter = (*fakeAlwaysRateLimiter)(nil) + _ RateLimiter = (*fakeNeverRateLimiter)(nil) +) + +var _ PassiveRateLimiter = (*tokenBucketPassiveRateLimiter)(nil) diff --git a/vendor/k8s.io/client-go/util/retry/util.go b/vendor/k8s.io/client-go/util/retry/util.go index 15e2722f30..772f5bd7a7 100644 --- a/vendor/k8s.io/client-go/util/retry/util.go +++ b/vendor/k8s.io/client-go/util/retry/util.go @@ -79,7 +79,7 @@ func OnError(backoff wait.Backoff, retriable func(error) bool, fn func() error) // // if you got a conflict on the last update attempt then you need to get // // the current version before making your own changes. // pod, err := c.Pods("mynamespace").Get(name, metav1.GetOptions{}) -// if err ! nil { +// if err != nil { // return err // } // diff --git a/vendor/k8s.io/client-go/util/workqueue/default_rate_limiters.go b/vendor/k8s.io/client-go/util/workqueue/default_rate_limiters.go index 71bb6322e0..efda7c197f 100644 --- a/vendor/k8s.io/client-go/util/workqueue/default_rate_limiters.go +++ b/vendor/k8s.io/client-go/util/workqueue/default_rate_limiters.go @@ -27,7 +27,7 @@ import ( type RateLimiter interface { // When gets an item and gets to decide how long that item should wait When(item interface{}) time.Duration - // Forget indicates that an item is finished being retried. Doesn't matter whether its for perm failing + // Forget indicates that an item is finished being retried. Doesn't matter whether it's for failing // or for success, we'll stop tracking it Forget(item interface{}) // NumRequeues returns back how many failures the item has had @@ -209,3 +209,30 @@ func (r *MaxOfRateLimiter) Forget(item interface{}) { limiter.Forget(item) } } + +// WithMaxWaitRateLimiter have maxDelay which avoids waiting too long +type WithMaxWaitRateLimiter struct { + limiter RateLimiter + maxDelay time.Duration +} + +func NewWithMaxWaitRateLimiter(limiter RateLimiter, maxDelay time.Duration) RateLimiter { + return &WithMaxWaitRateLimiter{limiter: limiter, maxDelay: maxDelay} +} + +func (w WithMaxWaitRateLimiter) When(item interface{}) time.Duration { + delay := w.limiter.When(item) + if delay > w.maxDelay { + return w.maxDelay + } + + return delay +} + +func (w WithMaxWaitRateLimiter) Forget(item interface{}) { + w.limiter.Forget(item) +} + +func (w WithMaxWaitRateLimiter) NumRequeues(item interface{}) int { + return w.limiter.NumRequeues(item) +} diff --git a/vendor/k8s.io/client-go/util/workqueue/delaying_queue.go b/vendor/k8s.io/client-go/util/workqueue/delaying_queue.go index 31d9182dea..61c4da530c 100644 --- a/vendor/k8s.io/client-go/util/workqueue/delaying_queue.go +++ b/vendor/k8s.io/client-go/util/workqueue/delaying_queue.go @@ -21,8 +21,8 @@ import ( "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" utilruntime "k8s.io/apimachinery/pkg/util/runtime" + "k8s.io/utils/clock" ) // DelayingInterface is an Interface that can Add an item at a later time. This makes it easier to @@ -51,11 +51,11 @@ func NewNamedDelayingQueue(name string) DelayingInterface { // NewDelayingQueueWithCustomClock constructs a new named workqueue // with ability to inject real or fake clock for testing purposes -func NewDelayingQueueWithCustomClock(clock clock.Clock, name string) DelayingInterface { +func NewDelayingQueueWithCustomClock(clock clock.WithTicker, name string) DelayingInterface { return newDelayingQueue(clock, NewNamed(name), name) } -func newDelayingQueue(clock clock.Clock, q Interface, name string) *delayingType { +func newDelayingQueue(clock clock.WithTicker, q Interface, name string) *delayingType { ret := &delayingType{ Interface: q, clock: clock, diff --git a/vendor/k8s.io/client-go/util/workqueue/metrics.go b/vendor/k8s.io/client-go/util/workqueue/metrics.go index 556e6432eb..4b0a69616d 100644 --- a/vendor/k8s.io/client-go/util/workqueue/metrics.go +++ b/vendor/k8s.io/client-go/util/workqueue/metrics.go @@ -20,7 +20,7 @@ import ( "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" + "k8s.io/utils/clock" ) // This file provides abstractions for setting the provider (e.g., prometheus) diff --git a/vendor/k8s.io/client-go/util/workqueue/queue.go b/vendor/k8s.io/client-go/util/workqueue/queue.go index f7c14ddcdb..6f7063269f 100644 --- a/vendor/k8s.io/client-go/util/workqueue/queue.go +++ b/vendor/k8s.io/client-go/util/workqueue/queue.go @@ -20,7 +20,7 @@ import ( "sync" "time" - "k8s.io/apimachinery/pkg/util/clock" + "k8s.io/utils/clock" ) type Interface interface { @@ -29,6 +29,7 @@ type Interface interface { Get() (item interface{}, shutdown bool) Done(item interface{}) ShutDown() + ShutDownWithDrain() ShuttingDown() bool } @@ -46,7 +47,7 @@ func NewNamed(name string) *Type { ) } -func newQueue(c clock.Clock, metrics queueMetrics, updatePeriod time.Duration) *Type { +func newQueue(c clock.WithTicker, metrics queueMetrics, updatePeriod time.Duration) *Type { t := &Type{ clock: c, dirty: set{}, @@ -86,11 +87,12 @@ type Type struct { cond *sync.Cond shuttingDown bool + drain bool metrics queueMetrics unfinishedWorkUpdatePeriod time.Duration - clock clock.Clock + clock clock.WithTicker } type empty struct{} @@ -110,6 +112,10 @@ func (s set) delete(item t) { delete(s, item) } +func (s set) len() int { + return len(s) +} + // Add marks item as needing processing. func (q *Type) Add(item interface{}) { q.cond.L.Lock() @@ -155,7 +161,10 @@ func (q *Type) Get() (item interface{}, shutdown bool) { return nil, true } - item, q.queue = q.queue[0], q.queue[1:] + item = q.queue[0] + // The underlying array still exists and reference this object, so the object will not be garbage collected. + q.queue[0] = nil + q.queue = q.queue[1:] q.metrics.get(item) @@ -178,13 +187,71 @@ func (q *Type) Done(item interface{}) { if q.dirty.has(item) { q.queue = append(q.queue, item) q.cond.Signal() + } else if q.processing.len() == 0 { + q.cond.Signal() } } -// ShutDown will cause q to ignore all new items added to it. As soon as the -// worker goroutines have drained the existing items in the queue, they will be -// instructed to exit. +// ShutDown will cause q to ignore all new items added to it and +// immediately instruct the worker goroutines to exit. func (q *Type) ShutDown() { + q.setDrain(false) + q.shutdown() +} + +// ShutDownWithDrain will cause q to ignore all new items added to it. As soon +// as the worker goroutines have "drained", i.e: finished processing and called +// Done on all existing items in the queue; they will be instructed to exit and +// ShutDownWithDrain will return. Hence: a strict requirement for using this is; +// your workers must ensure that Done is called on all items in the queue once +// the shut down has been initiated, if that is not the case: this will block +// indefinitely. It is, however, safe to call ShutDown after having called +// ShutDownWithDrain, as to force the queue shut down to terminate immediately +// without waiting for the drainage. +func (q *Type) ShutDownWithDrain() { + q.setDrain(true) + q.shutdown() + for q.isProcessing() && q.shouldDrain() { + q.waitForProcessing() + } +} + +// isProcessing indicates if there are still items on the work queue being +// processed. It's used to drain the work queue on an eventual shutdown. +func (q *Type) isProcessing() bool { + q.cond.L.Lock() + defer q.cond.L.Unlock() + return q.processing.len() != 0 +} + +// waitForProcessing waits for the worker goroutines to finish processing items +// and call Done on them. +func (q *Type) waitForProcessing() { + q.cond.L.Lock() + defer q.cond.L.Unlock() + // Ensure that we do not wait on a queue which is already empty, as that + // could result in waiting for Done to be called on items in an empty queue + // which has already been shut down, which will result in waiting + // indefinitely. + if q.processing.len() == 0 { + return + } + q.cond.Wait() +} + +func (q *Type) setDrain(shouldDrain bool) { + q.cond.L.Lock() + defer q.cond.L.Unlock() + q.drain = shouldDrain +} + +func (q *Type) shouldDrain() bool { + q.cond.L.Lock() + defer q.cond.L.Unlock() + return q.drain +} + +func (q *Type) shutdown() { q.cond.L.Lock() defer q.cond.L.Unlock() q.shuttingDown = true diff --git a/vendor/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_type.go b/vendor/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_type.go index 884abbde94..ec40fb4ed7 100644 --- a/vendor/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_type.go +++ b/vendor/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_type.go @@ -144,7 +144,9 @@ func (g *genFakeForType) GenerateType(c *generator.Context, t *types.Type, w io. "NewRootGetAction": c.Universe.Function(types.Name{Package: pkgClientGoTesting, Name: "NewRootGetAction"}), "NewGetAction": c.Universe.Function(types.Name{Package: pkgClientGoTesting, Name: "NewGetAction"}), "NewRootDeleteAction": c.Universe.Function(types.Name{Package: pkgClientGoTesting, Name: "NewRootDeleteAction"}), + "NewRootDeleteActionWithOptions": c.Universe.Function(types.Name{Package: pkgClientGoTesting, Name: "NewRootDeleteActionWithOptions"}), "NewDeleteAction": c.Universe.Function(types.Name{Package: pkgClientGoTesting, Name: "NewDeleteAction"}), + "NewDeleteActionWithOptions": c.Universe.Function(types.Name{Package: pkgClientGoTesting, Name: "NewDeleteActionWithOptions"}), "NewRootDeleteCollectionAction": c.Universe.Function(types.Name{Package: pkgClientGoTesting, Name: "NewRootDeleteCollectionAction"}), "NewDeleteCollectionAction": c.Universe.Function(types.Name{Package: pkgClientGoTesting, Name: "NewDeleteCollectionAction"}), "NewRootUpdateAction": c.Universe.Function(types.Name{Package: pkgClientGoTesting, Name: "NewRootUpdateAction"}), @@ -412,8 +414,8 @@ var deleteTemplate = ` // Delete takes name of the $.type|private$ and deletes it. Returns an error if one occurs. func (c *Fake$.type|publicPlural$) Delete(ctx context.Context, name string, opts $.DeleteOptions|raw$) error { _, err := c.Fake. - $if .namespaced$Invokes($.NewDeleteAction|raw$($.type|allLowercasePlural$Resource, c.ns, name), &$.type|raw${}) - $else$Invokes($.NewRootDeleteAction|raw$($.type|allLowercasePlural$Resource, name), &$.type|raw${})$end$ + $if .namespaced$Invokes($.NewDeleteActionWithOptions|raw$($.type|allLowercasePlural$Resource, c.ns, name, opts), &$.type|raw${}) + $else$Invokes($.NewRootDeleteActionWithOptions|raw$($.type|allLowercasePlural$Resource, name, opts), &$.type|raw${})$end$ return err } ` diff --git a/vendor/k8s.io/code-generator/cmd/client-gen/generators/generator_for_clientset.go b/vendor/k8s.io/code-generator/cmd/client-gen/generators/generator_for_clientset.go index 20e8796bfa..b0212296c1 100644 --- a/vendor/k8s.io/code-generator/cmd/client-gen/generators/generator_for_clientset.go +++ b/vendor/k8s.io/code-generator/cmd/client-gen/generators/generator_for_clientset.go @@ -77,9 +77,10 @@ func (g *genClientset) GenerateType(c *generator.Context, t *types.Type, w io.Wr "Config": c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Config"}), "DefaultKubernetesUserAgent": c.Universe.Function(types.Name{Package: "k8s.io/client-go/rest", Name: "DefaultKubernetesUserAgent"}), "RESTClientInterface": c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Interface"}), + "RESTHTTPClientFor": c.Universe.Function(types.Name{Package: "k8s.io/client-go/rest", Name: "HTTPClientFor"}), "DiscoveryInterface": c.Universe.Type(types.Name{Package: "k8s.io/client-go/discovery", Name: "DiscoveryInterface"}), "DiscoveryClient": c.Universe.Type(types.Name{Package: "k8s.io/client-go/discovery", Name: "DiscoveryClient"}), - "NewDiscoveryClientForConfig": c.Universe.Function(types.Name{Package: "k8s.io/client-go/discovery", Name: "NewDiscoveryClientForConfig"}), + "NewDiscoveryClientForConfigAndClient": c.Universe.Function(types.Name{Package: "k8s.io/client-go/discovery", Name: "NewDiscoveryClientForConfigAndClient"}), "NewDiscoveryClientForConfigOrDie": c.Universe.Function(types.Name{Package: "k8s.io/client-go/discovery", Name: "NewDiscoveryClientForConfigOrDie"}), "NewDiscoveryClient": c.Universe.Function(types.Name{Package: "k8s.io/client-go/discovery", Name: "NewDiscoveryClient"}), "flowcontrolNewTokenBucketRateLimiter": c.Universe.Function(types.Name{Package: "k8s.io/client-go/util/flowcontrol", Name: "NewTokenBucketRateLimiter"}), @@ -91,6 +92,7 @@ func (g *genClientset) GenerateType(c *generator.Context, t *types.Type, w io.Wr } sw.Do(getDiscoveryTemplate, m) sw.Do(newClientsetForConfigTemplate, m) + sw.Do(newClientsetForConfigAndClientTemplate, m) sw.Do(newClientsetForConfigOrDieTemplate, m) sw.Do(newClientsetForRESTClientTemplate, m) @@ -136,22 +138,43 @@ var newClientsetForConfigTemplate = ` // NewForConfig creates a new Clientset for the given config. // If config's RateLimiter is not set and QPS and Burst are acceptable, // NewForConfig will generate a rate-limiter in configShallowCopy. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *$.Config|raw$) (*Clientset, error) { configShallowCopy := *c + + // share the transport between all clients + httpClient, err := $.RESTHTTPClientFor|raw$(&configShallowCopy) + if err != nil { + return nil, err + } + + return NewForConfigAndClient(&configShallowCopy, httpClient) +} +` + +var newClientsetForConfigAndClientTemplate = ` +// NewForConfigAndClient creates a new Clientset for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +// If config's RateLimiter is not set and QPS and Burst are acceptable, +// NewForConfigAndClient will generate a rate-limiter in configShallowCopy. +func NewForConfigAndClient(c *$.Config|raw$, httpClient *http.Client) (*Clientset, error) { + configShallowCopy := *c if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 { if configShallowCopy.Burst <= 0 { return nil, fmt.Errorf("burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0") } configShallowCopy.RateLimiter = $.flowcontrolNewTokenBucketRateLimiter|raw$(configShallowCopy.QPS, configShallowCopy.Burst) } + var cs Clientset var err error -$range .allGroups$ cs.$.LowerCaseGroupGoName$$.Version$, err =$.PackageAlias$.NewForConfig(&configShallowCopy) +$range .allGroups$ cs.$.LowerCaseGroupGoName$$.Version$, err =$.PackageAlias$.NewForConfigAndClient(&configShallowCopy, httpClient) if err!=nil { return nil, err } $end$ - cs.DiscoveryClient, err = $.NewDiscoveryClientForConfig|raw$(&configShallowCopy) + cs.DiscoveryClient, err = $.NewDiscoveryClientForConfigAndClient|raw$(&configShallowCopy, httpClient) if err!=nil { return nil, err } @@ -163,11 +186,11 @@ var newClientsetForConfigOrDieTemplate = ` // NewForConfigOrDie creates a new Clientset for the given config and // panics if there is an error in the config. func NewForConfigOrDie(c *$.Config|raw$) *Clientset { - var cs Clientset -$range .allGroups$ cs.$.LowerCaseGroupGoName$$.Version$ =$.PackageAlias$.NewForConfigOrDie(c) -$end$ - cs.DiscoveryClient = $.NewDiscoveryClientForConfigOrDie|raw$(c) - return &cs + cs, err := NewForConfig(c) + if err!=nil { + panic(err) + } + return cs } ` diff --git a/vendor/k8s.io/code-generator/cmd/client-gen/generators/generator_for_group.go b/vendor/k8s.io/code-generator/cmd/client-gen/generators/generator_for_group.go index 215a0171ca..3028499003 100644 --- a/vendor/k8s.io/code-generator/cmd/client-gen/generators/generator_for_group.go +++ b/vendor/k8s.io/code-generator/cmd/client-gen/generators/generator_for_group.go @@ -89,20 +89,22 @@ func (g *genGroup) GenerateType(c *generator.Context, t *types.Type, w io.Writer } m := map[string]interface{}{ - "group": g.group, - "version": g.version, - "groupName": groupName, - "GroupGoName": g.groupGoName, - "Version": namer.IC(g.version), - "types": g.types, - "apiPath": apiPath(g.group), - "schemaGroupVersion": c.Universe.Type(types.Name{Package: "k8s.io/apimachinery/pkg/runtime/schema", Name: "GroupVersion"}), - "runtimeAPIVersionInternal": c.Universe.Variable(types.Name{Package: "k8s.io/apimachinery/pkg/runtime", Name: "APIVersionInternal"}), - "restConfig": c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Config"}), - "restDefaultKubernetesUserAgent": c.Universe.Function(types.Name{Package: "k8s.io/client-go/rest", Name: "DefaultKubernetesUserAgent"}), - "restRESTClientInterface": c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Interface"}), - "restRESTClientFor": c.Universe.Function(types.Name{Package: "k8s.io/client-go/rest", Name: "RESTClientFor"}), - "SchemeGroupVersion": c.Universe.Variable(types.Name{Package: path.Vendorless(g.inputPackage), Name: "SchemeGroupVersion"}), + "group": g.group, + "version": g.version, + "groupName": groupName, + "GroupGoName": g.groupGoName, + "Version": namer.IC(g.version), + "types": g.types, + "apiPath": apiPath(g.group), + "schemaGroupVersion": c.Universe.Type(types.Name{Package: "k8s.io/apimachinery/pkg/runtime/schema", Name: "GroupVersion"}), + "runtimeAPIVersionInternal": c.Universe.Variable(types.Name{Package: "k8s.io/apimachinery/pkg/runtime", Name: "APIVersionInternal"}), + "restConfig": c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Config"}), + "restDefaultKubernetesUserAgent": c.Universe.Function(types.Name{Package: "k8s.io/client-go/rest", Name: "DefaultKubernetesUserAgent"}), + "restRESTClientInterface": c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Interface"}), + "RESTHTTPClientFor": c.Universe.Function(types.Name{Package: "k8s.io/client-go/rest", Name: "HTTPClientFor"}), + "restRESTClientFor": c.Universe.Function(types.Name{Package: "k8s.io/client-go/rest", Name: "RESTClientFor"}), + "restRESTClientForConfigAndClient": c.Universe.Function(types.Name{Package: "k8s.io/client-go/rest", Name: "RESTClientForConfigAndClient"}), + "SchemeGroupVersion": c.Universe.Variable(types.Name{Package: path.Vendorless(g.inputPackage), Name: "SchemeGroupVersion"}), } sw.Do(groupInterfaceTemplate, m) sw.Do(groupClientTemplate, m) @@ -123,6 +125,7 @@ func (g *genGroup) GenerateType(c *generator.Context, t *types.Type, w io.Writer } } sw.Do(newClientForConfigTemplate, m) + sw.Do(newClientForConfigAndClientTemplate, m) sw.Do(newClientForConfigOrDieTemplate, m) sw.Do(newClientForRESTClientTemplate, m) if g.version == "" { @@ -164,12 +167,30 @@ func (c *$.GroupGoName$$.Version$Client) $.type|publicPlural$() $.type|public$In var newClientForConfigTemplate = ` // NewForConfig creates a new $.GroupGoName$$.Version$Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). func NewForConfig(c *$.restConfig|raw$) (*$.GroupGoName$$.Version$Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } - client, err := $.restRESTClientFor|raw$(&config) + httpClient, err := $.RESTHTTPClientFor|raw$(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} +` + +var newClientForConfigAndClientTemplate = ` +// NewForConfigAndClient creates a new $.GroupGoName$$.Version$Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *$.restConfig|raw$, h *http.Client) (*$.GroupGoName$$.Version$Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := $.restRESTClientForConfigAndClient|raw$(&config, h) if err != nil { return nil, err } diff --git a/vendor/k8s.io/code-generator/cmd/client-gen/main.go b/vendor/k8s.io/code-generator/cmd/client-gen/main.go index cc0f72a692..bdb5546138 100644 --- a/vendor/k8s.io/code-generator/cmd/client-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/client-gen/main.go @@ -19,10 +19,8 @@ package main import ( "flag" - "path/filepath" "github.com/spf13/pflag" - "k8s.io/gengo/args" "k8s.io/klog/v2" generatorargs "k8s.io/code-generator/cmd/client-gen/args" @@ -36,7 +34,7 @@ func main() { // Override defaults. // TODO: move this out of client-gen - genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) + genericArgs.GoHeaderFilePath = util.BoilerplatePath() genericArgs.OutputPackagePath = "k8s.io/kubernetes/pkg/client/clientset_generated/" genericArgs.AddFlags(pflag.CommandLine) diff --git a/vendor/k8s.io/code-generator/cmd/conversion-gen/main.go b/vendor/k8s.io/code-generator/cmd/conversion-gen/main.go index 6e0f31f068..feba7d0290 100644 --- a/vendor/k8s.io/code-generator/cmd/conversion-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/conversion-gen/main.go @@ -87,10 +87,8 @@ package main import ( "flag" - "path/filepath" "github.com/spf13/pflag" - "k8s.io/gengo/args" "k8s.io/klog/v2" generatorargs "k8s.io/code-generator/cmd/conversion-gen/args" @@ -104,7 +102,7 @@ func main() { // Override defaults. // TODO: move this out of conversion-gen - genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) + genericArgs.GoHeaderFilePath = util.BoilerplatePath() genericArgs.AddFlags(pflag.CommandLine) customArgs.AddFlags(pflag.CommandLine) diff --git a/vendor/k8s.io/code-generator/cmd/deepcopy-gen/main.go b/vendor/k8s.io/code-generator/cmd/deepcopy-gen/main.go index 31a4824a5c..888c2e306a 100644 --- a/vendor/k8s.io/code-generator/cmd/deepcopy-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/deepcopy-gen/main.go @@ -44,10 +44,8 @@ package main import ( "flag" - "path/filepath" "github.com/spf13/pflag" - "k8s.io/gengo/args" "k8s.io/gengo/examples/deepcopy-gen/generators" "k8s.io/klog/v2" @@ -61,7 +59,7 @@ func main() { // Override defaults. // TODO: move this out of deepcopy-gen - genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) + genericArgs.GoHeaderFilePath = util.BoilerplatePath() genericArgs.AddFlags(pflag.CommandLine) customArgs.AddFlags(pflag.CommandLine) diff --git a/vendor/k8s.io/code-generator/cmd/defaulter-gen/main.go b/vendor/k8s.io/code-generator/cmd/defaulter-gen/main.go index e9aef8d223..f050a13278 100644 --- a/vendor/k8s.io/code-generator/cmd/defaulter-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/defaulter-gen/main.go @@ -43,10 +43,8 @@ package main import ( "flag" - "path/filepath" "github.com/spf13/pflag" - "k8s.io/gengo/args" "k8s.io/gengo/examples/defaulter-gen/generators" "k8s.io/klog/v2" @@ -60,7 +58,7 @@ func main() { // Override defaults. // TODO: move this out of defaulter-gen - genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) + genericArgs.GoHeaderFilePath = util.BoilerplatePath() genericArgs.AddFlags(pflag.CommandLine) customArgs.AddFlags(pflag.CommandLine) diff --git a/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/cmd.go b/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/cmd.go index f7c8fb7ffc..8a92082bef 100644 --- a/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/cmd.go +++ b/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/cmd.go @@ -57,7 +57,7 @@ func New() *Generator { sourceTree := args.DefaultSourceTree() common := args.GeneratorArgs{ OutputBase: sourceTree, - GoHeaderFilePath: filepath.Join(sourceTree, util.BoilerplatePath()), + GoHeaderFilePath: util.BoilerplatePath(), } defaultProtoImport := filepath.Join(sourceTree, "k8s.io", "kubernetes", "vendor", "github.com", "gogo", "protobuf", "protobuf") cwd, err := os.Getwd() diff --git a/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/generator.go b/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/generator.go index 6eff86bf7a..54df66e45e 100644 --- a/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/generator.go +++ b/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/generator.go @@ -573,7 +573,7 @@ func protobufTagToField(tag string, field *protoField, m types.Member, t *types. switch parts[0] { case "varint", "fixed32", "fixed64", "bytes", "group": default: - name := types.Name{} + var name types.Name if last := strings.LastIndex(parts[0], "."); last != -1 { prefix := parts[0][:last] name = types.Name{ diff --git a/vendor/k8s.io/code-generator/cmd/import-boss/main.go b/vendor/k8s.io/code-generator/cmd/import-boss/main.go index 3fd0cf80d5..0fc56445e8 100644 --- a/vendor/k8s.io/code-generator/cmd/import-boss/main.go +++ b/vendor/k8s.io/code-generator/cmd/import-boss/main.go @@ -19,7 +19,6 @@ package main import ( "os" - "path/filepath" "github.com/spf13/pflag" "k8s.io/code-generator/pkg/util" @@ -34,7 +33,7 @@ func main() { arguments := args.Default() // Override defaults. - arguments.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) + arguments.GoHeaderFilePath = util.BoilerplatePath() pflag.CommandLine.BoolVar(&arguments.IncludeTestFiles, "include-test-files", false, "If true, include *_test.go files.") if err := arguments.Execute( diff --git a/vendor/k8s.io/code-generator/cmd/informer-gen/main.go b/vendor/k8s.io/code-generator/cmd/informer-gen/main.go index 6148296a04..650a3d78bd 100644 --- a/vendor/k8s.io/code-generator/cmd/informer-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/informer-gen/main.go @@ -18,12 +18,10 @@ package main import ( "flag" - "path/filepath" "github.com/spf13/pflag" "k8s.io/code-generator/cmd/informer-gen/generators" "k8s.io/code-generator/pkg/util" - "k8s.io/gengo/args" "k8s.io/klog/v2" generatorargs "k8s.io/code-generator/cmd/informer-gen/args" @@ -35,7 +33,7 @@ func main() { // Override defaults. // TODO: move out of informer-gen - genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) + genericArgs.GoHeaderFilePath = util.BoilerplatePath() genericArgs.OutputPackagePath = "k8s.io/kubernetes/pkg/client/informers/informers_generated" customArgs.VersionedClientSetPackage = "k8s.io/kubernetes/pkg/client/clientset_generated/clientset" customArgs.InternalClientSetPackage = "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" diff --git a/vendor/k8s.io/code-generator/cmd/lister-gen/main.go b/vendor/k8s.io/code-generator/cmd/lister-gen/main.go index 855b4e15c7..3418005c62 100644 --- a/vendor/k8s.io/code-generator/cmd/lister-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/lister-gen/main.go @@ -18,12 +18,10 @@ package main import ( "flag" - "path/filepath" "github.com/spf13/pflag" "k8s.io/code-generator/cmd/lister-gen/generators" "k8s.io/code-generator/pkg/util" - "k8s.io/gengo/args" "k8s.io/klog/v2" generatorargs "k8s.io/code-generator/cmd/lister-gen/args" @@ -35,7 +33,7 @@ func main() { // Override defaults. // TODO: move this out of lister-gen - genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) + genericArgs.GoHeaderFilePath = util.BoilerplatePath() genericArgs.OutputPackagePath = "k8s.io/kubernetes/pkg/client/listers" genericArgs.AddFlags(pflag.CommandLine) diff --git a/vendor/k8s.io/code-generator/cmd/register-gen/generators/packages.go b/vendor/k8s.io/code-generator/cmd/register-gen/generators/packages.go index 037adca2fc..242eb3aa10 100644 --- a/vendor/k8s.io/code-generator/cmd/register-gen/generators/packages.go +++ b/vendor/k8s.io/code-generator/cmd/register-gen/generators/packages.go @@ -82,7 +82,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat // if there is a comment of the form "// +groupName=somegroup" or "// +groupName=somegroup.foo.bar.io", // extract the fully qualified API group name from it and overwrite the group inferred from the package path - if override := types.ExtractCommentTags("+", pkg.DocComments)["groupName"]; override != nil { + if override := types.ExtractCommentTags("+", pkg.Comments)["groupName"]; override != nil { groupName := override[0] klog.V(5).Infof("overriding the group name with = %s", groupName) gv.Group = clientgentypes.Group(groupName) diff --git a/vendor/k8s.io/code-generator/cmd/register-gen/main.go b/vendor/k8s.io/code-generator/cmd/register-gen/main.go index 816bd81678..b8ba66f0da 100644 --- a/vendor/k8s.io/code-generator/cmd/register-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/register-gen/main.go @@ -18,7 +18,6 @@ package main import ( "flag" - "path/filepath" "github.com/spf13/pflag" "k8s.io/klog/v2" @@ -26,13 +25,12 @@ import ( generatorargs "k8s.io/code-generator/cmd/register-gen/args" "k8s.io/code-generator/cmd/register-gen/generators" "k8s.io/code-generator/pkg/util" - "k8s.io/gengo/args" ) func main() { klog.InitFlags(nil) genericArgs := generatorargs.NewDefaults() - genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) + genericArgs.GoHeaderFilePath = util.BoilerplatePath() genericArgs.AddFlags(pflag.CommandLine) flag.Set("logtostderr", "true") pflag.CommandLine.AddGoFlagSet(flag.CommandLine) diff --git a/vendor/k8s.io/code-generator/cmd/set-gen/main.go b/vendor/k8s.io/code-generator/cmd/set-gen/main.go index 2d98a1b328..f40c5e4a44 100644 --- a/vendor/k8s.io/code-generator/cmd/set-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/set-gen/main.go @@ -26,7 +26,6 @@ package main import ( "os" - "path/filepath" "k8s.io/code-generator/pkg/util" "k8s.io/gengo/args" @@ -40,7 +39,7 @@ func main() { arguments := args.Default() // Override defaults. - arguments.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) + arguments.GoHeaderFilePath = util.BoilerplatePath() arguments.InputDirs = []string{"k8s.io/kubernetes/pkg/util/sets/types"} arguments.OutputPackagePath = "k8s.io/apimachinery/pkg/util/sets" diff --git a/vendor/k8s.io/code-generator/doc.go b/vendor/k8s.io/code-generator/doc.go new file mode 100644 index 0000000000..fd86730697 --- /dev/null +++ b/vendor/k8s.io/code-generator/doc.go @@ -0,0 +1,17 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package codegenerator // import "k8s.io/code-generator" diff --git a/vendor/k8s.io/code-generator/generate-groups.sh b/vendor/k8s.io/code-generator/generate-groups.sh index 1c2fd7a55b..cfc2576a85 100644 --- a/vendor/k8s.io/code-generator/generate-groups.sh +++ b/vendor/k8s.io/code-generator/generate-groups.sh @@ -47,10 +47,10 @@ GROUPS_WITH_VERSIONS="$4" shift 4 ( - # To support running this script from anywhere, we have to first cd into this directory - # so we can install the tools. + # To support running this script from anywhere, first cd into this directory, + # and then install with forced module mode on and fully qualified name. cd "$(dirname "${0}")" - go install ./cmd/{defaulter-gen,client-gen,lister-gen,informer-gen,deepcopy-gen} + GO111MODULE=on go install k8s.io/code-generator/cmd/{defaulter-gen,client-gen,lister-gen,informer-gen,deepcopy-gen} ) # Go installs the above commands to get installed in $GOBIN if defined, and $GOPATH/bin otherwise: GOBIN="$(go env GOBIN)" @@ -71,7 +71,7 @@ done if [ "${GENS}" = "all" ] || grep -qw "deepcopy" <<<"${GENS}"; then echo "Generating deepcopy funcs" - "${gobin}/deepcopy-gen" --input-dirs "$(codegen::join , "${FQ_APIS[@]}")" -O zz_generated.deepcopy --bounding-dirs "${APIS_PKG}" "$@" + "${gobin}/deepcopy-gen" --input-dirs "$(codegen::join , "${FQ_APIS[@]}")" -O zz_generated.deepcopy "$@" fi if [ "${GENS}" = "all" ] || grep -qw "client" <<<"${GENS}"; then diff --git a/vendor/k8s.io/code-generator/generate-internal-groups.sh b/vendor/k8s.io/code-generator/generate-internal-groups.sh index e4430b27d5..2c114a3703 100644 --- a/vendor/k8s.io/code-generator/generate-internal-groups.sh +++ b/vendor/k8s.io/code-generator/generate-internal-groups.sh @@ -47,7 +47,12 @@ EXT_APIS_PKG="$4" GROUPS_WITH_VERSIONS="$5" shift 5 -go install ./"$(dirname "${0}")"/cmd/{defaulter-gen,conversion-gen,client-gen,lister-gen,informer-gen,deepcopy-gen,openapi-gen} +( + # To support running this script from anywhere, first cd into this directory, + # and then install with forced module mode on and fully qualified name. + cd "$(dirname "${0}")" + GO111MODULE=on go install k8s.io/code-generator/cmd/{defaulter-gen,conversion-gen,client-gen,lister-gen,informer-gen,deepcopy-gen,openapi-gen} +) function codegen::join() { local IFS="$1"; shift; echo "$*"; } @@ -72,7 +77,7 @@ done if [ "${GENS}" = "all" ] || grep -qw "deepcopy" <<<"${GENS}"; then echo "Generating deepcopy funcs" - "${GOPATH}/bin/deepcopy-gen" --input-dirs "$(codegen::join , "${ALL_FQ_APIS[@]}")" -O zz_generated.deepcopy --bounding-dirs "${INT_APIS_PKG},${EXT_APIS_PKG}" "$@" + "${GOPATH}/bin/deepcopy-gen" --input-dirs "$(codegen::join , "${ALL_FQ_APIS[@]}")" -O zz_generated.deepcopy "$@" fi if [ "${GENS}" = "all" ] || grep -qw "defaulter" <<<"${GENS}"; then diff --git a/vendor/k8s.io/code-generator/go.mod b/vendor/k8s.io/code-generator/go.mod index 1819e30114..f4287f45f2 100644 --- a/vendor/k8s.io/code-generator/go.mod +++ b/vendor/k8s.io/code-generator/go.mod @@ -6,22 +6,21 @@ go 1.16 require ( github.com/emicklei/go-restful v2.9.5+incompatible // indirect - github.com/go-openapi/jsonpointer v0.19.5 // indirect github.com/go-openapi/jsonreference v0.19.5 // indirect github.com/go-openapi/swag v0.19.14 // indirect github.com/gogo/protobuf v1.3.2 github.com/googleapis/gnostic v0.5.5 - github.com/json-iterator/go v1.1.11 // indirect + github.com/json-iterator/go v1.1.12 // indirect github.com/onsi/ginkgo v1.14.0 // indirect github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.7.0 // indirect - golang.org/x/net v0.0.0-20210520170846-37e1c6afe023 // indirect - golang.org/x/sys v0.0.0-20210616094352-59db8d763f22 // indirect - golang.org/x/tools v0.1.2 // indirect + golang.org/x/net v0.0.0-20211209124913-491a49abca63 // indirect + golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e // indirect + golang.org/x/text v0.3.7 // indirect + golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff gopkg.in/yaml.v2 v2.4.0 - gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect - k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027 - k8s.io/klog/v2 v2.9.0 - k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e + k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c + k8s.io/klog/v2 v2.30.0 + k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65 sigs.k8s.io/structured-merge-diff/v4 v4.1.2 // indirect ) diff --git a/vendor/k8s.io/code-generator/go.sum b/vendor/k8s.io/code-generator/go.sum index bbf23964ed..91bbf0a252 100644 --- a/vendor/k8s.io/code-generator/go.sum +++ b/vendor/k8s.io/code-generator/go.sum @@ -21,10 +21,12 @@ github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/getkin/kin-openapi v0.76.0/go.mod h1:660oXbgy5JFMKreazJaQTw7o+X00qeSyhcnluiMv+Xg= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas= github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= -github.com/go-logr/logr v0.4.0 h1:K7/B1jt6fIBQVd4Owv2MqGQClcgf0R266+7C/QjRcLc= -github.com/go-logr/logr v0.4.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= +github.com/go-logr/logr v1.2.0 h1:QK40JKJyMdUDz+h+xvCsru/bJhvG0UxvePV0ufL/AcE= +github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= github.com/go-openapi/jsonpointer v0.19.5 h1:gZr+CIYByUqjcgeLXnQu2gHYQC9o73G2XUeOFYEICuY= github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= @@ -59,16 +61,17 @@ github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.1.0 h1:Hsa8mG0dQ46ij8Sl2AYJDUv1oA9/d6Vk+3LG99Oe02g= github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gnostic v0.5.1/go.mod h1:6U4PtQXGIEt/Z3h5MAT7FNofLnw9vXk2cUuW7uA/OeU= github.com/googleapis/gnostic v0.5.5 h1:9fHAtK0uDfpveeqqo1hkEZJcFvYXAiCN3UutL8F9xHw= github.com/googleapis/gnostic v0.5.5/go.mod h1:7+EbHbldMins07ALC74bsA81Ovc97DwqyJO1AENw9kA= +github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= -github.com/json-iterator/go v1.1.11 h1:uVUAXhF2To8cbw/3xN3pxj6kk7TYKs98NIrTqPlMWAQ= -github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= @@ -85,9 +88,9 @@ github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= @@ -105,7 +108,7 @@ github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1y github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= @@ -118,6 +121,7 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= @@ -138,12 +142,12 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.0.0-20210520170846-37e1c6afe023 h1:ADo5wSpq2gqaCGQWzk7S5vd//0iyyLeAratkEoG5dLE= -golang.org/x/net v0.0.0-20210520170846-37e1c6afe023/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211209124913-491a49abca63 h1:iocB37TsdFuN6IBRZ+ry36wrkoV51/tl5vOWqkcPGvY= +golang.org/x/net v0.0.0-20211209124913-491a49abca63/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -165,14 +169,17 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210616094352-59db8d763f22 h1:RqytpXGR1iVNX7psjB3ff8y7sNFinVFvkx1c8SjBkio= -golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e h1:XMgFehsDnnLGtjvjOfqWSUzt0alpTR1RSEuznObga2c= +golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= @@ -182,8 +189,9 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200505023115-26f46d2f7ef8/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.2 h1:kRBLX7v7Af8W7Gdbbc908OJcdgtK8bOz9Uaj8/F1ACA= -golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff h1:VX/uD7MK0AHXGiScH3fsieUQUcpmRERPDYtqZdJnA+Q= +golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff/go.mod h1:YD9qOF0M9xpSpdWTBbzEl5e/RnCefISl8E5Noe10jFM= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -208,8 +216,9 @@ google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= @@ -231,15 +240,15 @@ gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -k8s.io/gengo v0.0.0-20200413195148-3a45101e95ac/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= -k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027 h1:Uusb3oh8XcdzDF/ndlI4ToKTYVlkCSJP39SRY2mfRAw= -k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E= +k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c h1:GohjlNKauSai7gN4wsJkeZ3WAJx4Sh+oT/b5IYn5suA= +k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E= k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE= k8s.io/klog/v2 v2.2.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y= -k8s.io/klog/v2 v2.9.0 h1:D7HV+n1V57XeZ0m6tdRkfknthUaM06VFbWldOFh8kzM= -k8s.io/klog/v2 v2.9.0/go.mod h1:hy9LJ/NvuK+iVyP4Ehqva4HxZG/oXyIS3n3Jmire4Ec= -k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e h1:KLHHjkdQFomZy8+06csTWZ0m1343QqxZhR2LJ1OxCYM= -k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e/go.mod h1:vHXdDvt9+2spS2Rx9ql3I8tycm3H9FDfdUoIuKCefvw= +k8s.io/klog/v2 v2.30.0 h1:bUO6drIvCIsvZ/XFgfxoGFQU/a4Qkh0iAlvUR7vlHJw= +k8s.io/klog/v2 v2.30.0/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= +k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65 h1:E3J9oCLlaobFUqsjG9DfKbP2BmgwBL2p7pn0A3dG9W4= +k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65/go.mod h1:sX9MT8g7NVZM5lVL/j8QyCCJe8YSMW30QvGZWaCIDIk= +k8s.io/utils v0.0.0-20210802155522-efc7438f0176/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= sigs.k8s.io/structured-merge-diff/v4 v4.0.2/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw= sigs.k8s.io/structured-merge-diff/v4 v4.1.2 h1:Hr/htKFmJEbtMgS/UD0N+gtgctAqz81t3nu+sPzynno= sigs.k8s.io/structured-merge-diff/v4 v4.1.2/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4= diff --git a/vendor/k8s.io/code-generator/pkg/util/build.go b/vendor/k8s.io/code-generator/pkg/util/build.go index 6ed1fe497c..72ae683d8d 100644 --- a/vendor/k8s.io/code-generator/pkg/util/build.go +++ b/vendor/k8s.io/code-generator/pkg/util/build.go @@ -18,10 +18,12 @@ package util import ( gobuild "go/build" - "path" + "os" "path/filepath" "reflect" "strings" + + "golang.org/x/tools/go/packages" ) type empty struct{} @@ -55,9 +57,37 @@ func hasSubdir(root, dir string) (rel string, ok bool) { return filepath.ToSlash(dir[len(root):]), true } -// BoilerplatePath uses the boilerplate in code-generator by calculating the relative path to it. +// BoilerplatePath returns the path to the boilerplate file in code-generator, +// or "" if the default boilerplate.go.txt file cannot be located. func BoilerplatePath() string { - return path.Join(reflect.TypeOf(empty{}).PkgPath(), "/../../hack/boilerplate.go.txt") + // set up paths to check + paths := []string{ + // works when run from root of $GOPATH containing k8s.io/code-generator + filepath.Join(reflect.TypeOf(empty{}).PkgPath(), "/../../hack/boilerplate.go.txt"), + // works when run from root of module vendoring k8s.io/code-generator + "vendor/k8s.io/code-generator/hack/boilerplate.go.txt", + // works when run from root of $GOPATH containing k8s.io/kubernetes + "k8s.io/kubernetes/vendor/k8s.io/code-generator/hack/boilerplate.go.txt", + } + + // see if we can locate the module directory and add that to the list + config := packages.Config{Mode: packages.NeedModule} + if loadedPackages, err := packages.Load(&config, "k8s.io/code-generator/pkg/util"); err == nil { + for _, loadedPackage := range loadedPackages { + if loadedPackage.Module != nil && loadedPackage.Module.Dir != "" { + paths = append(paths, filepath.Join(loadedPackage.Module.Dir, "hack/boilerplate.go.txt")) + } + } + } + + // try all paths and return the first that exists + for _, path := range paths { + if _, err := os.Stat(path); err == nil { + return path + } + } + // cannot be located, invoker will have to explicitly specify boilerplate file + return "" } // Vendorless trims vendor prefix from a package path to make it canonical diff --git a/vendor/k8s.io/code-generator/tools.go b/vendor/k8s.io/code-generator/tools.go index 7d13de5a19..fb797be032 100644 --- a/vendor/k8s.io/code-generator/tools.go +++ b/vendor/k8s.io/code-generator/tools.go @@ -1,3 +1,4 @@ +//go:build tools // +build tools /* @@ -18,7 +19,7 @@ limitations under the License. // This package contains code generation utilities // This package imports things required by build scripts, to force `go mod` to see them as dependencies -package tools +package codegenerator import ( _ "k8s.io/code-generator/cmd/client-gen" diff --git a/vendor/k8s.io/component-base/cli/flag/ciphersuites_flag.go b/vendor/k8s.io/component-base/cli/flag/ciphersuites_flag.go index a52faf9197..11adc26831 100644 --- a/vendor/k8s.io/component-base/cli/flag/ciphersuites_flag.go +++ b/vendor/k8s.io/component-base/cli/flag/ciphersuites_flag.go @@ -23,39 +23,24 @@ import ( "k8s.io/apimachinery/pkg/util/sets" ) -// ciphers maps strings into tls package cipher constants in -// https://golang.org/pkg/crypto/tls/#pkg-constants -// to be replaced by tls.CipherSuites() when the project migrates to go1.14. -var ciphers = map[string]uint16{ - "TLS_RSA_WITH_3DES_EDE_CBC_SHA": tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA, - "TLS_RSA_WITH_AES_128_CBC_SHA": tls.TLS_RSA_WITH_AES_128_CBC_SHA, - "TLS_RSA_WITH_AES_256_CBC_SHA": tls.TLS_RSA_WITH_AES_256_CBC_SHA, - "TLS_RSA_WITH_AES_128_GCM_SHA256": tls.TLS_RSA_WITH_AES_128_GCM_SHA256, - "TLS_RSA_WITH_AES_256_GCM_SHA384": tls.TLS_RSA_WITH_AES_256_GCM_SHA384, - "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA": tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, - "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA": tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, - "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA": tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, - "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA": tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, - "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA": tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, - "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256": tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, - "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256": tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, - "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384": tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, - "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384": tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, - "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305": tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305, - "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305": tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, - "TLS_AES_128_GCM_SHA256": tls.TLS_AES_128_GCM_SHA256, - "TLS_CHACHA20_POLY1305_SHA256": tls.TLS_CHACHA20_POLY1305_SHA256, - "TLS_AES_256_GCM_SHA384": tls.TLS_AES_256_GCM_SHA384, -} +var ( + // ciphers maps strings into tls package cipher constants in + // https://golang.org/pkg/crypto/tls/#pkg-constants + ciphers = map[string]uint16{} + insecureCiphers = map[string]uint16{} +) -// to be replaced by tls.InsecureCipherSuites() when the project migrates to go1.14. -var insecureCiphers = map[string]uint16{ - "TLS_RSA_WITH_RC4_128_SHA": tls.TLS_RSA_WITH_RC4_128_SHA, - "TLS_RSA_WITH_AES_128_CBC_SHA256": tls.TLS_RSA_WITH_AES_128_CBC_SHA256, - "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA": tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, - "TLS_ECDHE_RSA_WITH_RC4_128_SHA": tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA, - "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256": tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, - "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256": tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, +func init() { + for _, suite := range tls.CipherSuites() { + ciphers[suite.Name] = suite.ID + } + // keep legacy names for backward compatibility + ciphers["TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305"] = tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 + ciphers["TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305"] = tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 + + for _, suite := range tls.InsecureCipherSuites() { + insecureCiphers[suite.Name] = suite.ID + } } // InsecureTLSCiphers returns the cipher suites implemented by crypto/tls which have diff --git a/vendor/k8s.io/component-base/cli/flag/flags.go b/vendor/k8s.io/component-base/cli/flag/flags.go index 70146f3359..2388340d5c 100644 --- a/vendor/k8s.io/component-base/cli/flag/flags.go +++ b/vendor/k8s.io/component-base/cli/flag/flags.go @@ -24,6 +24,8 @@ import ( "k8s.io/klog/v2" ) +var underscoreWarnings = make(map[string]bool) + // WordSepNormalizeFunc changes all flags that contain "_" separators func WordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName { if strings.Contains(name, "_") { @@ -36,7 +38,10 @@ func WordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName { func WarnWordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName { if strings.Contains(name, "_") { nname := strings.Replace(name, "_", "-", -1) - klog.Warningf("%s is DEPRECATED and will be removed in a future version. Use %s instead.", name, nname) + if _, alreadyWarned := underscoreWarnings[name]; !alreadyWarned { + klog.Warningf("using an underscore in a flag name is not supported. %s has been converted to %s.", name, nname) + underscoreWarnings[name] = true + } return pflag.NormalizedName(nname) } diff --git a/vendor/k8s.io/component-base/config/OWNERS b/vendor/k8s.io/component-base/config/OWNERS index 11d499d75d..8d65ac8f20 100644 --- a/vendor/k8s.io/component-base/config/OWNERS +++ b/vendor/k8s.io/component-base/config/OWNERS @@ -7,8 +7,11 @@ approvers: - api-approvers reviewers: - api-reviewers +emeritus_reviewers: - luxas - mtaufen - sttts labels: - kind/api-change +- sig/api-machinery +- sig/scheduling diff --git a/vendor/k8s.io/component-base/config/types.go b/vendor/k8s.io/component-base/config/types.go index c6cd112af1..52336173c2 100644 --- a/vendor/k8s.io/component-base/config/types.go +++ b/vendor/k8s.io/component-base/config/types.go @@ -17,6 +17,14 @@ limitations under the License. package config import ( + "fmt" + "strconv" + "strings" + "time" + + "github.com/spf13/pflag" + + "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) @@ -85,7 +93,122 @@ type LoggingConfiguration struct { // Format Flag specifies the structure of log messages. // default value of format is `text` Format string + // Maximum number of seconds between log flushes. Ignored if the + // selected logging backend writes log messages without buffering. + FlushFrequency time.Duration + // Verbosity is the threshold that determines which log messages are + // logged. Default is zero which logs only the most important + // messages. Higher values enable additional messages. Error messages + // are always logged. + Verbosity VerbosityLevel + // VModule overrides the verbosity threshold for individual files. + // Only supported for "text" log format. + VModule VModuleConfiguration // [Experimental] When enabled prevents logging of fields tagged as sensitive (passwords, keys, tokens). // Runtime log sanitization may introduce significant computation overhead and therefore should not be enabled in production.`) Sanitization bool + // [Experimental] Options holds additional parameters that are specific + // to the different logging formats. Only the options for the selected + // format get used, but all of them get validated. + Options FormatOptions +} + +// FormatOptions contains options for the different logging formats. +type FormatOptions struct { + // [Experimental] JSON contains options for logging format "json". + JSON JSONOptions +} + +// JSONOptions contains options for logging format "json". +type JSONOptions struct { + // [Experimental] SplitStream redirects error messages to stderr while + // info messages go to stdout, with buffering. The default is to write + // both to stdout, without buffering. + SplitStream bool + // [Experimental] InfoBufferSize sets the size of the info stream when + // using split streams. The default is zero, which disables buffering. + InfoBufferSize resource.QuantityValue +} + +// VModuleConfiguration is a collection of individual file names or patterns +// and the corresponding verbosity threshold. +type VModuleConfiguration []VModuleItem + +var _ pflag.Value = &VModuleConfiguration{} + +// VModuleItem defines verbosity for one or more files which match a certain +// glob pattern. +type VModuleItem struct { + // FilePattern is a base file name (i.e. minus the ".go" suffix and + // directory) or a "glob" pattern for such a name. It must not contain + // comma and equal signs because those are separators for the + // corresponding klog command line argument. + FilePattern string + // Verbosity is the threshold for log messages emitted inside files + // that match the pattern. + Verbosity VerbosityLevel +} + +// String returns the -vmodule parameter (comma-separated list of pattern=N). +func (vmodule *VModuleConfiguration) String() string { + var patterns []string + for _, item := range *vmodule { + patterns = append(patterns, fmt.Sprintf("%s=%d", item.FilePattern, item.Verbosity)) + } + return strings.Join(patterns, ",") +} + +// Set parses the -vmodule parameter (comma-separated list of pattern=N). +func (vmodule *VModuleConfiguration) Set(value string) error { + // This code mirrors https://github.com/kubernetes/klog/blob/9ad246211af1ed84621ee94a26fcce0038b69cd1/klog.go#L287-L313 + + for _, pat := range strings.Split(value, ",") { + if len(pat) == 0 { + // Empty strings such as from a trailing comma can be ignored. + continue + } + patLev := strings.Split(pat, "=") + if len(patLev) != 2 || len(patLev[0]) == 0 || len(patLev[1]) == 0 { + return fmt.Errorf("%q does not have the pattern=N format", pat) + } + pattern := patLev[0] + // 31 instead of 32 to ensure that it also fits into int32. + v, err := strconv.ParseUint(patLev[1], 10, 31) + if err != nil { + return fmt.Errorf("parsing verbosity in %q: %v", pat, err) + } + *vmodule = append(*vmodule, VModuleItem{FilePattern: pattern, Verbosity: VerbosityLevel(v)}) + } + return nil +} + +func (vmodule *VModuleConfiguration) Type() string { + return "pattern=N,..." +} + +// VerbosityLevel represents a klog or logr verbosity threshold. +type VerbosityLevel uint32 + +var _ pflag.Value = new(VerbosityLevel) + +func (l *VerbosityLevel) String() string { + return strconv.FormatInt(int64(*l), 10) +} + +func (l *VerbosityLevel) Get() interface{} { + return *l +} + +func (l *VerbosityLevel) Set(value string) error { + // Limited to int32 for compatibility with klog. + v, err := strconv.ParseUint(value, 10, 31) + if err != nil { + return err + } + *l = VerbosityLevel(v) + return nil +} + +func (l *VerbosityLevel) Type() string { + return "Level" } diff --git a/vendor/k8s.io/component-base/config/v1alpha1/defaults.go b/vendor/k8s.io/component-base/config/v1alpha1/defaults.go index 098c5739d3..57d066edac 100644 --- a/vendor/k8s.io/component-base/config/v1alpha1/defaults.go +++ b/vendor/k8s.io/component-base/config/v1alpha1/defaults.go @@ -19,6 +19,7 @@ package v1alpha1 import ( "time" + "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" utilpointer "k8s.io/utils/pointer" ) @@ -110,4 +111,18 @@ func RecommendedLoggingConfiguration(obj *LoggingConfiguration) { if obj.Format == "" { obj.Format = "text" } + var empty resource.QuantityValue + if obj.Options.JSON.InfoBufferSize == empty { + obj.Options.JSON.InfoBufferSize = resource.QuantityValue{ + // This is similar, but not quite the same as a default + // constructed instance. + Quantity: *resource.NewQuantity(0, resource.DecimalSI), + } + // This sets the unexported Quantity.s which will be compared + // by reflect.DeepEqual in some tests. + _ = obj.Options.JSON.InfoBufferSize.String() + } + if obj.FlushFrequency == 0 { + obj.FlushFrequency = 5 * time.Second + } } diff --git a/vendor/k8s.io/component-base/config/v1alpha1/types.go b/vendor/k8s.io/component-base/config/v1alpha1/types.go index cd56c1fcfc..734e0d9703 100644 --- a/vendor/k8s.io/component-base/config/v1alpha1/types.go +++ b/vendor/k8s.io/component-base/config/v1alpha1/types.go @@ -17,6 +17,9 @@ limitations under the License. package v1alpha1 import ( + "time" + + "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) @@ -87,7 +90,56 @@ type LoggingConfiguration struct { // Format Flag specifies the structure of log messages. // default value of format is `text` Format string `json:"format,omitempty"` + // Maximum number of seconds between log flushes. Ignored if the + // selected logging backend writes log messages without buffering. + FlushFrequency time.Duration `json:"flushFrequency"` + // Verbosity is the threshold that determines which log messages are + // logged. Default is zero which logs only the most important + // messages. Higher values enable additional messages. Error messages + // are always logged. + Verbosity uint32 `json:"verbosity"` + // VModule overrides the verbosity threshold for individual files. + // Only supported for "text" log format. + VModule VModuleConfiguration `json:"vmodule,omitempty"` // [Experimental] When enabled prevents logging of fields tagged as sensitive (passwords, keys, tokens). // Runtime log sanitization may introduce significant computation overhead and therefore should not be enabled in production.`) Sanitization bool `json:"sanitization,omitempty"` + // [Experimental] Options holds additional parameters that are specific + // to the different logging formats. Only the options for the selected + // format get used, but all of them get validated. + Options FormatOptions `json:"options,omitempty"` +} + +// FormatOptions contains options for the different logging formats. +type FormatOptions struct { + // [Experimental] JSON contains options for logging format "json". + JSON JSONOptions `json:"json,omitempty"` +} + +// JSONOptions contains options for logging format "json". +type JSONOptions struct { + // [Experimental] SplitStream redirects error messages to stderr while + // info messages go to stdout, with buffering. The default is to write + // both to stdout, without buffering. + SplitStream bool `json:"splitStream,omitempty"` + // [Experimental] InfoBufferSize sets the size of the info stream when + // using split streams. The default is zero, which disables buffering. + InfoBufferSize resource.QuantityValue `json:"infoBufferSize,omitempty"` +} + +// VModuleConfiguration is a collection of individual file names or patterns +// and the corresponding verbosity threshold. +type VModuleConfiguration []VModuleItem + +// VModuleItem defines verbosity for one or more files which match a certain +// glob pattern. +type VModuleItem struct { + // FilePattern is a base file name (i.e. minus the ".go" suffix and + // directory) or a "glob" pattern for such a name. It must not contain + // comma and equal signs because those are separators for the + // corresponding klog command line argument. + FilePattern string `json:"filePattern"` + // Verbosity is the threshold for log messages emitted inside files + // that match the pattern. + Verbosity uint32 `json:"verbosity"` } diff --git a/vendor/k8s.io/component-base/config/v1alpha1/zz_generated.conversion.go b/vendor/k8s.io/component-base/config/v1alpha1/zz_generated.conversion.go index 5490ba3ba6..93cf4cc649 100644 --- a/vendor/k8s.io/component-base/config/v1alpha1/zz_generated.conversion.go +++ b/vendor/k8s.io/component-base/config/v1alpha1/zz_generated.conversion.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -21,6 +22,9 @@ limitations under the License. package v1alpha1 import ( + time "time" + unsafe "unsafe" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" conversion "k8s.io/apimachinery/pkg/conversion" runtime "k8s.io/apimachinery/pkg/runtime" @@ -34,6 +38,36 @@ func init() { // RegisterConversions adds conversion functions to the given scheme. // Public to allow building arbitrary schemes. func RegisterConversions(s *runtime.Scheme) error { + if err := s.AddGeneratedConversionFunc((*FormatOptions)(nil), (*config.FormatOptions)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha1_FormatOptions_To_config_FormatOptions(a.(*FormatOptions), b.(*config.FormatOptions), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*config.FormatOptions)(nil), (*FormatOptions)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_config_FormatOptions_To_v1alpha1_FormatOptions(a.(*config.FormatOptions), b.(*FormatOptions), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*JSONOptions)(nil), (*config.JSONOptions)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha1_JSONOptions_To_config_JSONOptions(a.(*JSONOptions), b.(*config.JSONOptions), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*config.JSONOptions)(nil), (*JSONOptions)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_config_JSONOptions_To_v1alpha1_JSONOptions(a.(*config.JSONOptions), b.(*JSONOptions), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VModuleItem)(nil), (*config.VModuleItem)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha1_VModuleItem_To_config_VModuleItem(a.(*VModuleItem), b.(*config.VModuleItem), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*config.VModuleItem)(nil), (*VModuleItem)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_config_VModuleItem_To_v1alpha1_VModuleItem(a.(*config.VModuleItem), b.(*VModuleItem), scope) + }); err != nil { + return err + } if err := s.AddConversionFunc((*config.ClientConnectionConfiguration)(nil), (*ClientConnectionConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_config_ClientConnectionConfiguration_To_v1alpha1_ClientConnectionConfiguration(a.(*config.ClientConnectionConfiguration), b.(*ClientConnectionConfiguration), scope) }); err != nil { @@ -115,6 +149,52 @@ func autoConvert_config_DebuggingConfiguration_To_v1alpha1_DebuggingConfiguratio return nil } +func autoConvert_v1alpha1_FormatOptions_To_config_FormatOptions(in *FormatOptions, out *config.FormatOptions, s conversion.Scope) error { + if err := Convert_v1alpha1_JSONOptions_To_config_JSONOptions(&in.JSON, &out.JSON, s); err != nil { + return err + } + return nil +} + +// Convert_v1alpha1_FormatOptions_To_config_FormatOptions is an autogenerated conversion function. +func Convert_v1alpha1_FormatOptions_To_config_FormatOptions(in *FormatOptions, out *config.FormatOptions, s conversion.Scope) error { + return autoConvert_v1alpha1_FormatOptions_To_config_FormatOptions(in, out, s) +} + +func autoConvert_config_FormatOptions_To_v1alpha1_FormatOptions(in *config.FormatOptions, out *FormatOptions, s conversion.Scope) error { + if err := Convert_config_JSONOptions_To_v1alpha1_JSONOptions(&in.JSON, &out.JSON, s); err != nil { + return err + } + return nil +} + +// Convert_config_FormatOptions_To_v1alpha1_FormatOptions is an autogenerated conversion function. +func Convert_config_FormatOptions_To_v1alpha1_FormatOptions(in *config.FormatOptions, out *FormatOptions, s conversion.Scope) error { + return autoConvert_config_FormatOptions_To_v1alpha1_FormatOptions(in, out, s) +} + +func autoConvert_v1alpha1_JSONOptions_To_config_JSONOptions(in *JSONOptions, out *config.JSONOptions, s conversion.Scope) error { + out.SplitStream = in.SplitStream + out.InfoBufferSize = in.InfoBufferSize + return nil +} + +// Convert_v1alpha1_JSONOptions_To_config_JSONOptions is an autogenerated conversion function. +func Convert_v1alpha1_JSONOptions_To_config_JSONOptions(in *JSONOptions, out *config.JSONOptions, s conversion.Scope) error { + return autoConvert_v1alpha1_JSONOptions_To_config_JSONOptions(in, out, s) +} + +func autoConvert_config_JSONOptions_To_v1alpha1_JSONOptions(in *config.JSONOptions, out *JSONOptions, s conversion.Scope) error { + out.SplitStream = in.SplitStream + out.InfoBufferSize = in.InfoBufferSize + return nil +} + +// Convert_config_JSONOptions_To_v1alpha1_JSONOptions is an autogenerated conversion function. +func Convert_config_JSONOptions_To_v1alpha1_JSONOptions(in *config.JSONOptions, out *JSONOptions, s conversion.Scope) error { + return autoConvert_config_JSONOptions_To_v1alpha1_JSONOptions(in, out, s) +} + func autoConvert_v1alpha1_LeaderElectionConfiguration_To_config_LeaderElectionConfiguration(in *LeaderElectionConfiguration, out *config.LeaderElectionConfiguration, s conversion.Scope) error { if err := v1.Convert_Pointer_bool_To_bool(&in.LeaderElect, &out.LeaderElect, s); err != nil { return err @@ -143,12 +223,46 @@ func autoConvert_config_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionCo func autoConvert_v1alpha1_LoggingConfiguration_To_config_LoggingConfiguration(in *LoggingConfiguration, out *config.LoggingConfiguration, s conversion.Scope) error { out.Format = in.Format + out.FlushFrequency = time.Duration(in.FlushFrequency) + out.Verbosity = config.VerbosityLevel(in.Verbosity) + out.VModule = *(*config.VModuleConfiguration)(unsafe.Pointer(&in.VModule)) out.Sanitization = in.Sanitization + if err := Convert_v1alpha1_FormatOptions_To_config_FormatOptions(&in.Options, &out.Options, s); err != nil { + return err + } return nil } func autoConvert_config_LoggingConfiguration_To_v1alpha1_LoggingConfiguration(in *config.LoggingConfiguration, out *LoggingConfiguration, s conversion.Scope) error { out.Format = in.Format + out.FlushFrequency = time.Duration(in.FlushFrequency) + out.Verbosity = uint32(in.Verbosity) + out.VModule = *(*VModuleConfiguration)(unsafe.Pointer(&in.VModule)) out.Sanitization = in.Sanitization + if err := Convert_config_FormatOptions_To_v1alpha1_FormatOptions(&in.Options, &out.Options, s); err != nil { + return err + } + return nil +} + +func autoConvert_v1alpha1_VModuleItem_To_config_VModuleItem(in *VModuleItem, out *config.VModuleItem, s conversion.Scope) error { + out.FilePattern = in.FilePattern + out.Verbosity = config.VerbosityLevel(in.Verbosity) return nil } + +// Convert_v1alpha1_VModuleItem_To_config_VModuleItem is an autogenerated conversion function. +func Convert_v1alpha1_VModuleItem_To_config_VModuleItem(in *VModuleItem, out *config.VModuleItem, s conversion.Scope) error { + return autoConvert_v1alpha1_VModuleItem_To_config_VModuleItem(in, out, s) +} + +func autoConvert_config_VModuleItem_To_v1alpha1_VModuleItem(in *config.VModuleItem, out *VModuleItem, s conversion.Scope) error { + out.FilePattern = in.FilePattern + out.Verbosity = uint32(in.Verbosity) + return nil +} + +// Convert_config_VModuleItem_To_v1alpha1_VModuleItem is an autogenerated conversion function. +func Convert_config_VModuleItem_To_v1alpha1_VModuleItem(in *config.VModuleItem, out *VModuleItem, s conversion.Scope) error { + return autoConvert_config_VModuleItem_To_v1alpha1_VModuleItem(in, out, s) +} diff --git a/vendor/k8s.io/component-base/config/v1alpha1/zz_generated.deepcopy.go b/vendor/k8s.io/component-base/config/v1alpha1/zz_generated.deepcopy.go index f5f2a0e91e..5503e7a869 100644 --- a/vendor/k8s.io/component-base/config/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/k8s.io/component-base/config/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -62,6 +63,40 @@ func (in *DebuggingConfiguration) DeepCopy() *DebuggingConfiguration { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FormatOptions) DeepCopyInto(out *FormatOptions) { + *out = *in + in.JSON.DeepCopyInto(&out.JSON) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FormatOptions. +func (in *FormatOptions) DeepCopy() *FormatOptions { + if in == nil { + return nil + } + out := new(FormatOptions) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONOptions) DeepCopyInto(out *JSONOptions) { + *out = *in + in.InfoBufferSize.DeepCopyInto(&out.InfoBufferSize) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONOptions. +func (in *JSONOptions) DeepCopy() *JSONOptions { + if in == nil { + return nil + } + out := new(JSONOptions) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *LeaderElectionConfiguration) DeepCopyInto(out *LeaderElectionConfiguration) { *out = *in @@ -89,6 +124,12 @@ func (in *LeaderElectionConfiguration) DeepCopy() *LeaderElectionConfiguration { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *LoggingConfiguration) DeepCopyInto(out *LoggingConfiguration) { *out = *in + if in.VModule != nil { + in, out := &in.VModule, &out.VModule + *out = make(VModuleConfiguration, len(*in)) + copy(*out, *in) + } + in.Options.DeepCopyInto(&out.Options) return } @@ -101,3 +142,39 @@ func (in *LoggingConfiguration) DeepCopy() *LoggingConfiguration { in.DeepCopyInto(out) return out } + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in VModuleConfiguration) DeepCopyInto(out *VModuleConfiguration) { + { + in := &in + *out = make(VModuleConfiguration, len(*in)) + copy(*out, *in) + return + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VModuleConfiguration. +func (in VModuleConfiguration) DeepCopy() VModuleConfiguration { + if in == nil { + return nil + } + out := new(VModuleConfiguration) + in.DeepCopyInto(out) + return *out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VModuleItem) DeepCopyInto(out *VModuleItem) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VModuleItem. +func (in *VModuleItem) DeepCopy() *VModuleItem { + if in == nil { + return nil + } + out := new(VModuleItem) + in.DeepCopyInto(out) + return out +} diff --git a/vendor/k8s.io/component-base/config/zz_generated.deepcopy.go b/vendor/k8s.io/component-base/config/zz_generated.deepcopy.go index 77260a06f0..ede25cd32f 100644 --- a/vendor/k8s.io/component-base/config/zz_generated.deepcopy.go +++ b/vendor/k8s.io/component-base/config/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -52,6 +53,40 @@ func (in *DebuggingConfiguration) DeepCopy() *DebuggingConfiguration { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FormatOptions) DeepCopyInto(out *FormatOptions) { + *out = *in + in.JSON.DeepCopyInto(&out.JSON) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FormatOptions. +func (in *FormatOptions) DeepCopy() *FormatOptions { + if in == nil { + return nil + } + out := new(FormatOptions) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONOptions) DeepCopyInto(out *JSONOptions) { + *out = *in + in.InfoBufferSize.DeepCopyInto(&out.InfoBufferSize) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONOptions. +func (in *JSONOptions) DeepCopy() *JSONOptions { + if in == nil { + return nil + } + out := new(JSONOptions) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *LeaderElectionConfiguration) DeepCopyInto(out *LeaderElectionConfiguration) { *out = *in @@ -74,6 +109,12 @@ func (in *LeaderElectionConfiguration) DeepCopy() *LeaderElectionConfiguration { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *LoggingConfiguration) DeepCopyInto(out *LoggingConfiguration) { *out = *in + if in.VModule != nil { + in, out := &in.VModule, &out.VModule + *out = make(VModuleConfiguration, len(*in)) + copy(*out, *in) + } + in.Options.DeepCopyInto(&out.Options) return } @@ -86,3 +127,39 @@ func (in *LoggingConfiguration) DeepCopy() *LoggingConfiguration { in.DeepCopyInto(out) return out } + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in VModuleConfiguration) DeepCopyInto(out *VModuleConfiguration) { + { + in := &in + *out = make(VModuleConfiguration, len(*in)) + copy(*out, *in) + return + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VModuleConfiguration. +func (in VModuleConfiguration) DeepCopy() VModuleConfiguration { + if in == nil { + return nil + } + out := new(VModuleConfiguration) + in.DeepCopyInto(out) + return *out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VModuleItem) DeepCopyInto(out *VModuleItem) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VModuleItem. +func (in *VModuleItem) DeepCopy() *VModuleItem { + if in == nil { + return nil + } + out := new(VModuleItem) + in.DeepCopyInto(out) + return out +} diff --git a/vendor/k8s.io/component-base/featuregate/OWNERS b/vendor/k8s.io/component-base/featuregate/OWNERS new file mode 100644 index 0000000000..48e811bf4c --- /dev/null +++ b/vendor/k8s.io/component-base/featuregate/OWNERS @@ -0,0 +1,17 @@ +# See the OWNERS docs at https://go.k8s.io/owners + +# Currently assigned to api-approvers since feature gates are the API +# for enabling/disabling other APIs. + +# Disable inheritance as this is an api owners file +options: + no_parent_owners: true +approvers: +- api-approvers +reviewers: +- api-reviewers + +labels: +- kind/api-change +- sig/api-machinery +- sig/cluster-lifecycle diff --git a/vendor/k8s.io/component-base/logs/config.go b/vendor/k8s.io/component-base/logs/config.go index 8a029fa7cc..a3fe6fb5fc 100644 --- a/vendor/k8s.io/component-base/logs/config.go +++ b/vendor/k8s.io/component-base/logs/config.go @@ -19,11 +19,14 @@ package logs import ( "flag" "fmt" + "sort" "strings" "github.com/spf13/pflag" + cliflag "k8s.io/component-base/cli/flag" "k8s.io/component-base/config" + "k8s.io/component-base/logs/registry" "k8s.io/klog/v2" ) @@ -33,59 +36,83 @@ const ( JSONLogFormat = "json" ) -// LogRegistry is new init LogFormatRegistry struct -var LogRegistry = NewLogFormatRegistry() +// loggingFlags captures the state of the logging flags, in particular their default value +// before flag parsing. It is used by UnsupportedLoggingFlags. +var loggingFlags pflag.FlagSet func init() { // Text format is default klog format - LogRegistry.Register(DefaultLogFormat, nil) + registry.LogRegistry.Register(DefaultLogFormat, nil) + + var fs flag.FlagSet + klog.InitFlags(&fs) + loggingFlags.AddGoFlagSet(&fs) } // List of logs (k8s.io/klog + k8s.io/component-base/logs) flags supported by all logging formats var supportedLogsFlags = map[string]struct{}{ "v": {}, - // TODO: support vmodule after 1.19 Alpha } -// BindLoggingFlags binds the Options struct fields to a flagset +// BindLoggingFlags binds the Options struct fields to a flagset. +// +// Programs using LoggingConfiguration must use SkipLoggingConfigurationFlags +// when calling AddFlags to avoid the duplicate registration of flags. func BindLoggingFlags(c *config.LoggingConfiguration, fs *pflag.FlagSet) { - normalizeFunc := func(name string) string { - f := fs.GetNormalizeFunc() - return string(f(fs, name)) - } - unsupportedFlags := fmt.Sprintf("--%s", strings.Join(UnsupportedLoggingFlags(normalizeFunc), ", --")) - formats := fmt.Sprintf(`"%s"`, strings.Join(LogRegistry.List(), `", "`)) + // The help text is generated assuming that flags will eventually use + // hyphens, even if currently no normalization function is set for the + // flag set yet. + unsupportedFlags := strings.Join(unsupportedLoggingFlagNames(cliflag.WordSepNormalizeFunc), ", ") + formats := fmt.Sprintf(`"%s"`, strings.Join(registry.LogRegistry.List(), `", "`)) fs.StringVar(&c.Format, "logging-format", c.Format, fmt.Sprintf("Sets the log format. Permitted formats: %s.\nNon-default formats don't honor these flags: %s.\nNon-default choices are currently alpha and subject to change without warning.", formats, unsupportedFlags)) // No new log formats should be added after generation is of flag options - LogRegistry.Freeze() + registry.LogRegistry.Freeze() + + fs.DurationVar(&c.FlushFrequency, logFlushFreqFlagName, logFlushFreq, "Maximum number of seconds between log flushes") + fs.VarP(&c.Verbosity, "v", "v", "number for the log level verbosity") + fs.Var(&c.VModule, "vmodule", "comma-separated list of pattern=N settings for file-filtered logging (only works for text log format)") fs.BoolVar(&c.Sanitization, "experimental-logging-sanitization", c.Sanitization, `[Experimental] When enabled prevents logging of fields tagged as sensitive (passwords, keys, tokens). Runtime log sanitization may introduce significant computation overhead and therefore should not be enabled in production.`) -} -// UnsupportedLoggingFlags lists unsupported logging flags -func UnsupportedLoggingFlags(normalizeFunc func(name string) string) []string { - allFlags := []string{} + // JSON options. We only register them if "json" is a valid format. The + // config file API however always has them. + if _, err := registry.LogRegistry.Get("json"); err == nil { + fs.BoolVar(&c.Options.JSON.SplitStream, "log-json-split-stream", false, "[Experimental] In JSON format, write error messages to stderr and info messages to stdout. The default is to write a single stream to stdout.") + fs.Var(&c.Options.JSON.InfoBufferSize, "log-json-info-buffer-size", "[Experimental] In JSON format with split output streams, the info messages can be buffered for a while to increase performance. The default value of zero bytes disables buffering. The size can be specified as number of bytes (512), multiples of 1000 (1K), multiples of 1024 (2Ki), or powers of those (3M, 4G, 5Mi, 6Gi).") + } +} - // k8s.io/klog flags - fs := &flag.FlagSet{} - klog.InitFlags(fs) - fs.VisitAll(func(flag *flag.Flag) { +// UnsupportedLoggingFlags lists unsupported logging flags. The normalize +// function is optional. +func UnsupportedLoggingFlags(normalizeFunc func(f *pflag.FlagSet, name string) pflag.NormalizedName) []*pflag.Flag { + // k8s.io/component-base/logs and klog flags + pfs := &pflag.FlagSet{} + loggingFlags.VisitAll(func(flag *pflag.Flag) { if _, found := supportedLogsFlags[flag.Name]; !found { - name := flag.Name - if normalizeFunc != nil { - name = normalizeFunc(name) - } - allFlags = append(allFlags, name) + // Normalization changes flag.Name, so make a copy. + clone := *flag + pfs.AddFlag(&clone) } }) - // k8s.io/component-base/logs flags - pfs := &pflag.FlagSet{} - AddFlags(pfs) + // Apply normalization. + pfs.SetNormalizeFunc(normalizeFunc) + + var allFlags []*pflag.Flag pfs.VisitAll(func(flag *pflag.Flag) { - if _, found := supportedLogsFlags[flag.Name]; !found { - allFlags = append(allFlags, flag.Name) - } + allFlags = append(allFlags, flag) }) return allFlags } + +// unsupportedLoggingFlagNames lists unsupported logging flags by name, with +// optional normalization and sorted. +func unsupportedLoggingFlagNames(normalizeFunc func(f *pflag.FlagSet, name string) pflag.NormalizedName) []string { + unsupportedFlags := UnsupportedLoggingFlags(normalizeFunc) + names := make([]string, 0, len(unsupportedFlags)) + for _, f := range unsupportedFlags { + names = append(names, "--"+f.Name) + } + sort.Strings(names) + return names +} diff --git a/vendor/k8s.io/component-base/logs/logs.go b/vendor/k8s.io/component-base/logs/logs.go index 073e0312fb..0f494deedd 100644 --- a/vendor/k8s.io/component-base/logs/logs.go +++ b/vendor/k8s.io/component-base/logs/logs.go @@ -14,6 +14,9 @@ See the License for the specific language governing permissions and limitations under the License. */ +// Package logs contains support for logging options, flags and setup. +// Commands must explicitly enable command line flags. They no longer +// get added automatically when importing this package. package logs import ( @@ -28,17 +31,131 @@ import ( ) const logFlushFreqFlagName = "log-flush-frequency" - -var logFlushFreq = pflag.Duration(logFlushFreqFlagName, 5*time.Second, "Maximum number of seconds between log flushes") +const deprecated = "will be removed in a future release, see https://github.com/kubernetes/enhancements/tree/master/keps/sig-instrumentation/2845-deprecate-klog-specific-flags-in-k8s-components" + +// TODO (https://github.com/kubernetes/kubernetes/issues/105310): once klog +// flags are removed, stop warning about "Non-default formats don't honor these +// flags" in config.go and instead add this remark here. +// +// const vmoduleUsage = " (only works for the default text log format)" + +var ( + packageFlags = flag.NewFlagSet("logging", flag.ContinueOnError) + logrFlush func() + + // Periodic flushing gets configured either via the global flag + // in this file or via LoggingConfiguration. + logFlushFreq time.Duration + logFlushFreqAdded bool +) func init() { - klog.InitFlags(flag.CommandLine) + klog.InitFlags(packageFlags) + packageFlags.DurationVar(&logFlushFreq, logFlushFreqFlagName, 5*time.Second, "Maximum number of seconds between log flushes") +} + +type addFlagsOptions struct { + skipLoggingConfigurationFlags bool +} + +type Option func(*addFlagsOptions) + +// SkipLoggingConfigurationFlags must be used as option for AddFlags when +// the program also uses a LoggingConfiguration struct for configuring +// logging. Then only flags not covered by that get added. +func SkipLoggingConfigurationFlags() Option { + return func(o *addFlagsOptions) { + o.skipLoggingConfigurationFlags = true + } +} + +// AddFlags registers this package's flags on arbitrary FlagSets. This includes +// the klog flags, with the original underscore as separator between. If +// commands want hyphens as separators, they can set +// k8s.io/component-base/cli/flag/WordSepNormalizeFunc as normalization +// function on the flag set before calling AddFlags. +// +// May be called more than once. +func AddFlags(fs *pflag.FlagSet, opts ...Option) { + // Determine whether the flags are already present by looking up one + // which always should exist. + if fs.Lookup("logtostderr") != nil { + return + } + + o := addFlagsOptions{} + for _, opt := range opts { + opt(&o) + } + + // Add flags with pflag deprecation remark for some klog flags. + packageFlags.VisitAll(func(f *flag.Flag) { + pf := pflag.PFlagFromGoFlag(f) + switch f.Name { + case "v": + // unchanged, potentially skip it + if o.skipLoggingConfigurationFlags { + return + } + case logFlushFreqFlagName: + // unchanged, potentially skip it + if o.skipLoggingConfigurationFlags { + return + } + logFlushFreqAdded = true + case "vmodule": + // TODO: see above + // pf.Usage += vmoduleUsage + if o.skipLoggingConfigurationFlags { + return + } + default: + // deprecated, but not hidden + pf.Deprecated = deprecated + } + fs.AddFlag(pf) + }) } -// AddFlags registers this package's flags on arbitrary FlagSets, such that they point to the -// same value as the global flags. -func AddFlags(fs *pflag.FlagSet) { - fs.AddFlag(pflag.Lookup(logFlushFreqFlagName)) +// AddGoFlags is a variant of AddFlags for traditional Go flag.FlagSet. +// Commands should use pflag whenever possible for the sake of consistency. +// Cases where this function is needed include tests (they have to set up flags +// in flag.CommandLine) and commands that for historic reasons use Go +// flag.Parse and cannot change to pflag because it would break their command +// line interface. +func AddGoFlags(fs *flag.FlagSet, opts ...Option) { + o := addFlagsOptions{} + for _, opt := range opts { + opt(&o) + } + + // Add flags with deprecation remark added to the usage text of + // some klog flags. + packageFlags.VisitAll(func(f *flag.Flag) { + usage := f.Usage + switch f.Name { + case "v": + // unchanged + if o.skipLoggingConfigurationFlags { + return + } + case logFlushFreqFlagName: + // unchanged + if o.skipLoggingConfigurationFlags { + return + } + logFlushFreqAdded = true + case "vmodule": + // TODO: see above + // usage += vmoduleUsage + if o.skipLoggingConfigurationFlags { + return + } + default: + usage += " (DEPRECATED: " + deprecated + ")" + } + fs.Var(f.Value, f.Name, usage) + }) } // KlogWriter serves as a bridge between the standard log package and the glog package. @@ -50,17 +167,27 @@ func (writer KlogWriter) Write(data []byte) (n int, err error) { return len(data), nil } -// InitLogs initializes logs the way we want for kubernetes. +// InitLogs initializes logs the way we want for Kubernetes. +// It should be called after parsing flags. If called before that, +// it will use the default log settings. func InitLogs() { log.SetOutput(KlogWriter{}) log.SetFlags(0) - // The default glog flush interval is 5 seconds. - go wait.Forever(klog.Flush, *logFlushFreq) + if logFlushFreqAdded { + // The flag from this file was activated, so use it now. + // Otherwise LoggingConfiguration.Apply will do this. + go wait.Forever(FlushLogs, logFlushFreq) + } } -// FlushLogs flushes logs immediately. +// FlushLogs flushes logs immediately. This should be called at the end of +// the main function via defer to ensure that all pending log messages +// are printed before exiting the program. func FlushLogs() { klog.Flush() + if logrFlush != nil { + logrFlush() + } } // NewLogger creates a new log.Logger which sends logs to klog.Info. diff --git a/vendor/k8s.io/component-base/logs/options.go b/vendor/k8s.io/component-base/logs/options.go index 46e52a0a13..8e3e9fffe2 100644 --- a/vendor/k8s.io/component-base/logs/options.go +++ b/vendor/k8s.io/component-base/logs/options.go @@ -17,13 +17,17 @@ limitations under the License. package logs import ( - "github.com/spf13/pflag" + "fmt" - "k8s.io/klog/v2" + "github.com/spf13/pflag" + utilerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/apimachinery/pkg/util/wait" "k8s.io/component-base/config" "k8s.io/component-base/config/v1alpha1" + "k8s.io/component-base/logs/registry" "k8s.io/component-base/logs/sanitization" + "k8s.io/klog/v2" ) // Options has klog format parameters @@ -40,9 +44,22 @@ func NewOptions() *Options { return o } -// Validate verifies if any unsupported flag is set +// ValidateAndApply combines validation and application of the logging configuration. +// This should be invoked as early as possible because then the rest of the program +// startup (including validation of other options) will already run with the final +// logging configuration. +func (o *Options) ValidateAndApply() error { + errs := o.validate() + if len(errs) > 0 { + return utilerrors.NewAggregate(errs) + } + o.apply() + return nil +} + +// validate verifies if any unsupported flag is set // for non-default logging format -func (o *Options) Validate() []error { +func (o *Options) validate() []error { errs := ValidateLoggingConfiguration(&o.Config, nil) if len(errs) != 0 { return errs.ToAggregate().Errors() @@ -50,17 +67,33 @@ func (o *Options) Validate() []error { return nil } -// AddFlags add logging-format flag +// AddFlags add logging-format flag. +// +// Programs using LoggingConfiguration must use SkipLoggingConfigurationFlags +// when calling AddFlags to avoid the duplicate registration of flags. func (o *Options) AddFlags(fs *pflag.FlagSet) { BindLoggingFlags(&o.Config, fs) } -// Apply set klog logger from LogFormat type -func (o *Options) Apply() { +// apply set klog logger from LogFormat type +func (o *Options) apply() { // if log format not exists, use nil loggr - loggr, _ := LogRegistry.Get(o.Config.Format) - klog.SetLogger(loggr) + factory, _ := registry.LogRegistry.Get(o.Config.Format) + if factory == nil { + klog.ClearLogger() + } else { + log, flush := factory.Create(o.Config.Options) + klog.SetLogger(log) + logrFlush = flush + } if o.Config.Sanitization { klog.SetLogFilter(&sanitization.SanitizingFilter{}) } + if err := loggingFlags.Lookup("v").Value.Set(o.Config.Verbosity.String()); err != nil { + panic(fmt.Errorf("internal error while setting klog verbosity: %v", err)) + } + if err := loggingFlags.Lookup("vmodule").Value.Set(o.Config.VModule.String()); err != nil { + panic(fmt.Errorf("internal error while setting klog vmodule: %v", err)) + } + go wait.Forever(FlushLogs, o.Config.FlushFrequency) } diff --git a/vendor/k8s.io/component-base/logs/registry.go b/vendor/k8s.io/component-base/logs/registry/registry.go similarity index 65% rename from vendor/k8s.io/component-base/logs/registry.go rename to vendor/k8s.io/component-base/logs/registry/registry.go index 150af394c2..145c0b8fd0 100644 --- a/vendor/k8s.io/component-base/logs/registry.go +++ b/vendor/k8s.io/component-base/logs/registry/registry.go @@ -14,43 +14,59 @@ See the License for the specific language governing permissions and limitations under the License. */ -package logs +package registry import ( "fmt" "sort" "github.com/go-logr/logr" + + "k8s.io/component-base/config" ) +// LogRegistry is new init LogFormatRegistry struct +var LogRegistry = NewLogFormatRegistry() + // LogFormatRegistry store klog format registry type LogFormatRegistry struct { - registry map[string]logr.Logger + registry map[string]LogFormatFactory frozen bool } +// LogFormatFactory provides support for a certain additional, +// non-default log format. +type LogFormatFactory interface { + // Create returns a logger with the requested configuration. + // Returning a flush function for the logger is optional. + // If provided, the caller must ensure that it is called + // periodically (if desired) and at program exit. + Create(options config.FormatOptions) (log logr.Logger, flush func()) +} + // NewLogFormatRegistry return new init LogFormatRegistry struct func NewLogFormatRegistry() *LogFormatRegistry { return &LogFormatRegistry{ - registry: make(map[string]logr.Logger), + registry: make(map[string]LogFormatFactory), frozen: false, } } -// Register new log format registry to global logRegistry -func (lfr *LogFormatRegistry) Register(name string, logger logr.Logger) error { +// Register new log format registry to global logRegistry. +// nil is valid and selects the default klog output. +func (lfr *LogFormatRegistry) Register(name string, factory LogFormatFactory) error { if lfr.frozen { return fmt.Errorf("log format is frozen, unable to register log format") } if _, ok := lfr.registry[name]; ok { return fmt.Errorf("log format: %s already exists", name) } - lfr.registry[name] = logger + lfr.registry[name] = factory return nil } // Get specified log format logger -func (lfr *LogFormatRegistry) Get(name string) (logr.Logger, error) { +func (lfr *LogFormatRegistry) Get(name string) (LogFormatFactory, error) { re, ok := lfr.registry[name] if !ok { return nil, fmt.Errorf("log format: %s does not exists", name) @@ -59,12 +75,12 @@ func (lfr *LogFormatRegistry) Get(name string) (logr.Logger, error) { } // Set specified log format logger -func (lfr *LogFormatRegistry) Set(name string, logger logr.Logger) error { +func (lfr *LogFormatRegistry) Set(name string, factory LogFormatFactory) error { if lfr.frozen { return fmt.Errorf("log format is frozen, unable to set log format") } - lfr.registry[name] = logger + lfr.registry[name] = factory return nil } diff --git a/vendor/k8s.io/component-base/logs/validate.go b/vendor/k8s.io/component-base/logs/validate.go index 86f1cecf34..694e95d468 100644 --- a/vendor/k8s.io/component-base/logs/validate.go +++ b/vendor/k8s.io/component-base/logs/validate.go @@ -17,52 +17,54 @@ limitations under the License. package logs import ( - "flag" "fmt" + "math" "strings" - "github.com/spf13/pflag" - "k8s.io/apimachinery/pkg/util/validation/field" + cliflag "k8s.io/component-base/cli/flag" "k8s.io/component-base/config" + "k8s.io/component-base/logs/registry" ) func ValidateLoggingConfiguration(c *config.LoggingConfiguration, fldPath *field.Path) field.ErrorList { errs := field.ErrorList{} if c.Format != DefaultLogFormat { - allFlags := UnsupportedLoggingFlags(hyphensToUnderscores) - for _, fname := range allFlags { - if flagIsSet(fname, hyphensToUnderscores) { - errs = append(errs, field.Invalid(fldPath.Child("format"), c.Format, fmt.Sprintf("Non-default format doesn't honor flag: %s", fname))) + // WordSepNormalizeFunc is just a guess. Commands should use it, + // but we cannot know for sure. + allFlags := UnsupportedLoggingFlags(cliflag.WordSepNormalizeFunc) + for _, f := range allFlags { + if f.DefValue != f.Value.String() { + errs = append(errs, field.Invalid(fldPath.Child("format"), c.Format, fmt.Sprintf("Non-default format doesn't honor flag: %s", f.Name))) } } } - if _, err := LogRegistry.Get(c.Format); err != nil { + _, err := registry.LogRegistry.Get(c.Format) + if err != nil { errs = append(errs, field.Invalid(fldPath.Child("format"), c.Format, "Unsupported log format")) } - return errs -} -// hyphensToUnderscores replaces hyphens with underscores -// we should always use underscores instead of hyphens when validate flags -func hyphensToUnderscores(s string) string { - return strings.Replace(s, "-", "_", -1) -} - -func flagIsSet(name string, normalizeFunc func(name string) string) bool { - f := flag.Lookup(name) - if f != nil { - return f.DefValue != f.Value.String() + // The type in our struct is uint32, but klog only accepts positive int32. + if c.Verbosity > math.MaxInt32 { + errs = append(errs, field.Invalid(fldPath.Child("verbosity"), c.Verbosity, fmt.Sprintf("Must be <= %d", math.MaxInt32))) } - if normalizeFunc != nil { - f = flag.Lookup(normalizeFunc(name)) - if f != nil { - return f.DefValue != f.Value.String() - } + vmoduleFldPath := fldPath.Child("vmodule") + if len(c.VModule) > 0 && c.Format != "" && c.Format != "text" { + errs = append(errs, field.Forbidden(vmoduleFldPath, "Only supported for text log format")) } - pf := pflag.Lookup(name) - if pf != nil { - return pf.DefValue != pf.Value.String() + for i, item := range c.VModule { + if item.FilePattern == "" { + errs = append(errs, field.Required(vmoduleFldPath.Index(i), "File pattern must not be empty")) + } + if strings.ContainsAny(item.FilePattern, "=,") { + errs = append(errs, field.Invalid(vmoduleFldPath.Index(i), item.FilePattern, "File pattern must not contain equal sign or comma")) + } + if item.Verbosity > math.MaxInt32 { + errs = append(errs, field.Invalid(vmoduleFldPath.Index(i), item.Verbosity, fmt.Sprintf("Must be <= %d", math.MaxInt32))) + } } - panic("failed to lookup unsupported log flag") + + // Currently nothing to validate for c.Options. + + return errs } diff --git a/vendor/k8s.io/component-base/metrics/legacyregistry/registry.go b/vendor/k8s.io/component-base/metrics/legacyregistry/registry.go index ff38953ba3..56a9dcae58 100644 --- a/vendor/k8s.io/component-base/metrics/legacyregistry/registry.go +++ b/vendor/k8s.io/component-base/metrics/legacyregistry/registry.go @@ -44,9 +44,9 @@ var ( ) func init() { - //lint:ignore SA1019 - replacement function still calls prometheus.NewProcessCollector(). + //nolint:staticcheck // SA1019 - replacement function still calls prometheus.NewProcessCollector(). RawMustRegister(prometheus.NewProcessCollector(prometheus.ProcessCollectorOpts{})) - //lint:ignore SA1019 - replacement function still calls prometheus.NewGoCollector(). + //nolint:staticcheck // SA1019 - replacement function still calls prometheus.NewGoCollector(). RawMustRegister(prometheus.NewGoCollector()) } diff --git a/vendor/k8s.io/component-base/metrics/options.go b/vendor/k8s.io/component-base/metrics/options.go index 91a76ba7e5..456fe0b0a3 100644 --- a/vendor/k8s.io/component-base/metrics/options.go +++ b/vendor/k8s.io/component-base/metrics/options.go @@ -58,8 +58,8 @@ func (o *Options) Validate() []error { // AddFlags adds flags for exposing component metrics. func (o *Options) AddFlags(fs *pflag.FlagSet) { - if o != nil { - o = NewOptions() + if o == nil { + return } fs.StringVar(&o.ShowHiddenMetricsForVersion, "show-hidden-metrics-for-version", o.ShowHiddenMetricsForVersion, "The previous version for which you want to show hidden metrics. "+ diff --git a/vendor/k8s.io/component-base/metrics/processstarttime_others.go b/vendor/k8s.io/component-base/metrics/processstarttime_others.go index 89ea8a68e8..a14cd8833a 100644 --- a/vendor/k8s.io/component-base/metrics/processstarttime_others.go +++ b/vendor/k8s.io/component-base/metrics/processstarttime_others.go @@ -1,3 +1,4 @@ +//go:build !windows // +build !windows /* diff --git a/vendor/k8s.io/component-base/metrics/processstarttime_windows.go b/vendor/k8s.io/component-base/metrics/processstarttime_windows.go index 8fcdf273a2..7813115e7e 100644 --- a/vendor/k8s.io/component-base/metrics/processstarttime_windows.go +++ b/vendor/k8s.io/component-base/metrics/processstarttime_windows.go @@ -1,3 +1,4 @@ +//go:build windows // +build windows /* diff --git a/vendor/k8s.io/component-base/metrics/registry.go b/vendor/k8s.io/component-base/metrics/registry.go index b608fb568f..b01bc011e3 100644 --- a/vendor/k8s.io/component-base/metrics/registry.go +++ b/vendor/k8s.io/component-base/metrics/registry.go @@ -274,7 +274,7 @@ func (kr *kubeRegistry) enableHiddenCollectors() { cs = append(cs, c) } - kr.hiddenCollectors = nil + kr.hiddenCollectors = make(map[string]Registerable) kr.hiddenCollectorsLock.Unlock() kr.MustRegister(cs...) } diff --git a/vendor/k8s.io/component-base/metrics/testutil/metrics.go b/vendor/k8s.io/component-base/metrics/testutil/metrics.go index 60a186483f..df3f8ee0c1 100644 --- a/vendor/k8s.io/component-base/metrics/testutil/metrics.go +++ b/vendor/k8s.io/component-base/metrics/testutil/metrics.go @@ -176,13 +176,87 @@ type Histogram struct { *dto.Histogram } -// GetHistogramFromGatherer collects a metric from a gatherer implementing k8s.io/component-base/metrics.Gatherer interface. +// HistogramVec wraps a slice of Histogram. +// Note that each Histogram must have the same number of buckets. +type HistogramVec []*Histogram + +// GetAggregatedSampleCount aggregates the sample count of each inner Histogram. +func (vec HistogramVec) GetAggregatedSampleCount() uint64 { + var count uint64 + for _, hist := range vec { + count += hist.GetSampleCount() + } + return count +} + +// GetAggregatedSampleSum aggregates the sample sum of each inner Histogram. +func (vec HistogramVec) GetAggregatedSampleSum() float64 { + var sum float64 + for _, hist := range vec { + sum += hist.GetSampleSum() + } + return sum +} + +// Quantile first aggregates inner buckets of each Histogram, and then +// computes q-th quantile of a cumulative histogram. +func (vec HistogramVec) Quantile(q float64) float64 { + var buckets []bucket + + for i, hist := range vec { + for j, bckt := range hist.Bucket { + if i == 0 { + buckets = append(buckets, bucket{ + count: float64(bckt.GetCumulativeCount()), + upperBound: bckt.GetUpperBound(), + }) + } else { + buckets[j].count += float64(bckt.GetCumulativeCount()) + } + } + } + + if len(buckets) == 0 || buckets[len(buckets)-1].upperBound != math.Inf(+1) { + // The list of buckets in dto.Histogram doesn't include the final +Inf bucket, so we + // add it here for the rest of the samples. + buckets = append(buckets, bucket{ + count: float64(vec.GetAggregatedSampleCount()), + upperBound: math.Inf(+1), + }) + } + + return bucketQuantile(q, buckets) +} + +// Average computes wrapped histograms' average value. +func (vec HistogramVec) Average() float64 { + return vec.GetAggregatedSampleSum() / float64(vec.GetAggregatedSampleCount()) +} + +// Validate makes sure the wrapped histograms have all necessary fields set and with valid values. +func (vec HistogramVec) Validate() error { + bucketSize := 0 + for i, hist := range vec { + if err := hist.Validate(); err != nil { + return err + } + if i == 0 { + bucketSize = len(hist.GetBucket()) + } else if bucketSize != len(hist.GetBucket()) { + return fmt.Errorf("found different bucket size: expect %v, but got %v at index %v", bucketSize, len(hist.GetBucket()), i) + } + } + return nil +} + +// GetHistogramVecFromGatherer collects a metric, that matches the input labelValue map, +// from a gatherer implementing k8s.io/component-base/metrics.Gatherer interface. // Used only for testing purposes where we need to gather metrics directly from a running binary (without metrics endpoint). -func GetHistogramFromGatherer(gatherer metrics.Gatherer, metricName string) (Histogram, error) { +func GetHistogramVecFromGatherer(gatherer metrics.Gatherer, metricName string, lvMap map[string]string) (HistogramVec, error) { var metricFamily *dto.MetricFamily m, err := gatherer.Gather() if err != nil { - return Histogram{}, err + return nil, err } for _, mFamily := range m { if mFamily.GetName() == metricName { @@ -192,23 +266,22 @@ func GetHistogramFromGatherer(gatherer metrics.Gatherer, metricName string) (His } if metricFamily == nil { - return Histogram{}, fmt.Errorf("metric %q not found", metricName) - } - - if metricFamily.GetMetric() == nil { - return Histogram{}, fmt.Errorf("metric %q is empty", metricName) + return nil, fmt.Errorf("metric %q not found", metricName) } if len(metricFamily.GetMetric()) == 0 { - return Histogram{}, fmt.Errorf("metric %q is empty", metricName) + return nil, fmt.Errorf("metric %q is empty", metricName) } - return Histogram{ - // Histograms are stored under the first index (based on observation). - // Given there's only one histogram registered per each metric name, accessing - // the first index is sufficient. - metricFamily.GetMetric()[0].GetHistogram(), - }, nil + vec := make(HistogramVec, 0) + for _, metric := range metricFamily.GetMetric() { + if LabelsMatch(metric, lvMap) { + if hist := metric.GetHistogram(); hist != nil { + vec = append(vec, &Histogram{hist}) + } + } + } + return vec, nil } func uint64Ptr(u uint64) *uint64 { @@ -266,7 +339,7 @@ func (hist *Histogram) Quantile(q float64) float64 { if len(buckets) == 0 || buckets[len(buckets)-1].upperBound != math.Inf(+1) { // The list of buckets in dto.Histogram doesn't include the final +Inf bucket, so we - // add it here for the reset of the samples. + // add it here for the rest of the samples. buckets = append(buckets, bucket{ count: float64(hist.GetSampleCount()), upperBound: math.Inf(+1), diff --git a/vendor/k8s.io/component-base/version/OWNERS b/vendor/k8s.io/component-base/version/OWNERS new file mode 100644 index 0000000000..329ea14748 --- /dev/null +++ b/vendor/k8s.io/component-base/version/OWNERS @@ -0,0 +1,17 @@ +# See the OWNERS docs at https://go.k8s.io/owners + +# Currently assigned this directory to sig-api-machinery since this is +# an interface to the version definition in "k8s.io/apimachinery/pkg/version", +# and also to sig-release since this version information is set up for +# each release. + +approvers: +- sig-api-machinery-api-approvers +- release-engineering-approvers +reviewers: +- sig-api-machinery-api-reviewers +- release-managers + +labels: +- sig/api-machinery +- sig/release diff --git a/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go b/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go index 68b81d47ea..fe8270a9c3 100644 --- a/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go +++ b/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go @@ -864,6 +864,8 @@ func (g *genDeepCopy) doStruct(t *types.Type, sw *generator.SnippetWriter) { sw.Do("in, out := &in.$.name$, &out.$.name$\n", args) g.generateFor(ft, sw) sw.Do("}\n", nil) + case uft.Kind == types.Array: + sw.Do("out.$.name$ = in.$.name$\n", args) case uft.Kind == types.Struct: if ft.IsAssignable() { sw.Do("out.$.name$ = in.$.name$\n", args) diff --git a/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go b/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go index 72782b166e..220ec7e0d8 100644 --- a/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go +++ b/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go @@ -318,9 +318,18 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } if len(inputTags) == 1 { var err error - typesPkg, err = context.AddDirectory(filepath.Join(pkg.Path, inputTags[0])) + + inputPath := inputTags[0] + if strings.HasPrefix(inputPath, "./") || strings.HasPrefix(inputPath, "../") { + // this is a relative dir, which will not work under gomodules. + // join with the local package path, but warn + klog.Warningf("relative path %s=%s will not work under gomodule mode; use full package path (as used by 'import') instead", inputTagName, inputPath) + inputPath = filepath.Join(pkg.Path, inputTags[0]) + } + + typesPkg, err = context.AddDirectory(inputPath) if err != nil { - klog.Fatalf("cannot import package %s", inputTags[0]) + klog.Fatalf("cannot import package %s", inputPath) } // update context.Order to the latest context.Universe orderer := namer.Orderer{Namer: namer.NewPublicNamer(1)} diff --git a/vendor/k8s.io/gengo/namer/namer.go b/vendor/k8s.io/gengo/namer/namer.go index d700a00a53..6feb2d0c46 100644 --- a/vendor/k8s.io/gengo/namer/namer.go +++ b/vendor/k8s.io/gengo/namer/namer.go @@ -17,7 +17,9 @@ limitations under the License. package namer import ( + "fmt" "path/filepath" + "strconv" "strings" "k8s.io/gengo/types" @@ -246,6 +248,12 @@ func (ns *NameStrategy) Name(t *types.Type) string { "Slice", ns.removePrefixAndSuffix(ns.Name(t.Elem)), }, ns.Suffix) + case types.Array: + name = ns.Join(ns.Prefix, []string{ + "Array", + ns.removePrefixAndSuffix(fmt.Sprintf("%d", t.Len)), + ns.removePrefixAndSuffix(ns.Name(t.Elem)), + }, ns.Suffix) case types.Pointer: name = ns.Join(ns.Prefix, []string{ "Pointer", @@ -340,6 +348,9 @@ func (r *rawNamer) Name(t *types.Type) string { name = "map[" + r.Name(t.Key) + "]" + r.Name(t.Elem) case types.Slice: name = "[]" + r.Name(t.Elem) + case types.Array: + l := strconv.Itoa(int(t.Len)) + name = "[" + l + "]" + r.Name(t.Elem) case types.Pointer: name = "*" + r.Name(t.Elem) case types.Struct: diff --git a/vendor/k8s.io/gengo/parser/parse.go b/vendor/k8s.io/gengo/parser/parse.go index 635afcf282..311d5dfb54 100644 --- a/vendor/k8s.io/gengo/parser/parse.go +++ b/vendor/k8s.io/gengo/parser/parse.go @@ -723,8 +723,7 @@ func (b *Builder) walkType(u types.Universe, useName *types.Name, in tc.Type) *t } out.Kind = types.Array out.Elem = b.walkType(u, nil, t.Elem()) - // TODO: need to store array length, otherwise raw type name - // cannot be properly written. + out.Len = in.(*tc.Array).Len() return out case *tc.Chan: out := u.Type(name) diff --git a/vendor/k8s.io/gengo/types/types.go b/vendor/k8s.io/gengo/types/types.go index 12ec1d9752..124766e766 100644 --- a/vendor/k8s.io/gengo/types/types.go +++ b/vendor/k8s.io/gengo/types/types.go @@ -83,11 +83,13 @@ const ( // Interface is any type that could have differing types at run time. Interface Kind = "Interface" + // Array is just like slice, but has a fixed length. + Array Kind = "Array" + // The remaining types are included for completeness, but are not well // supported. - Array Kind = "Array" // Array is just like slice, but has a fixed length. - Chan Kind = "Chan" - Func Kind = "Func" + Chan Kind = "Chan" + Func Kind = "Func" // DeclarationOf is different from other Kinds; it indicates that instead of // representing an actual Type, the type is a declaration of an instance of @@ -350,7 +352,9 @@ type Type struct { // TODO: Add: // * channel direction - // * array length + + // If Kind == Array + Len int64 } // String returns the name of the type. diff --git a/vendor/k8s.io/klog/v2/OWNERS b/vendor/k8s.io/klog/v2/OWNERS index 380e514f28..ad5063fdf1 100644 --- a/vendor/k8s.io/klog/v2/OWNERS +++ b/vendor/k8s.io/klog/v2/OWNERS @@ -15,5 +15,5 @@ approvers: - tallclair - piosz - brancz - - DirectXMan12 - lavalamp + - serathius diff --git a/vendor/k8s.io/klog/v2/go.mod b/vendor/k8s.io/klog/v2/go.mod index eb297b6a1e..31aefba74a 100644 --- a/vendor/k8s.io/klog/v2/go.mod +++ b/vendor/k8s.io/klog/v2/go.mod @@ -2,4 +2,4 @@ module k8s.io/klog/v2 go 1.13 -require github.com/go-logr/logr v0.4.0 +require github.com/go-logr/logr v1.2.0 diff --git a/vendor/k8s.io/klog/v2/go.sum b/vendor/k8s.io/klog/v2/go.sum index 5778f81742..919fbadbc0 100644 --- a/vendor/k8s.io/klog/v2/go.sum +++ b/vendor/k8s.io/klog/v2/go.sum @@ -1,2 +1,2 @@ -github.com/go-logr/logr v0.4.0 h1:K7/B1jt6fIBQVd4Owv2MqGQClcgf0R266+7C/QjRcLc= -github.com/go-logr/logr v0.4.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= +github.com/go-logr/logr v1.2.0 h1:QK40JKJyMdUDz+h+xvCsru/bJhvG0UxvePV0ufL/AcE= +github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= diff --git a/vendor/k8s.io/klog/v2/klog.go b/vendor/k8s.io/klog/v2/klog.go index 1e187f7635..45efbb0755 100644 --- a/vendor/k8s.io/klog/v2/klog.go +++ b/vendor/k8s.io/klog/v2/klog.go @@ -509,7 +509,7 @@ type loggingT struct { addDirHeader bool // If set, all output will be redirected unconditionally to the provided logr.Logger - logr logr.Logger + logr *logr.Logger // If true, messages will not be propagated to lower severity log levels oneOutput bool @@ -698,11 +698,11 @@ func (buf *buffer) someDigits(i, d int) int { return copy(buf.tmp[i:], buf.tmp[j:]) } -func (l *loggingT) println(s severity, logr logr.Logger, filter LogFilter, args ...interface{}) { +func (l *loggingT) println(s severity, logger *logr.Logger, filter LogFilter, args ...interface{}) { buf, file, line := l.header(s, 0) - // if logr is set, we clear the generated header as we rely on the backing - // logr implementation to print headers - if logr != nil { + // if logger is set, we clear the generated header as we rely on the backing + // logger implementation to print headers + if logger != nil { l.putBuffer(buf) buf = l.getBuffer() } @@ -710,18 +710,18 @@ func (l *loggingT) println(s severity, logr logr.Logger, filter LogFilter, args args = filter.Filter(args) } fmt.Fprintln(buf, args...) - l.output(s, logr, buf, 0 /* depth */, file, line, false) + l.output(s, logger, buf, 0 /* depth */, file, line, false) } -func (l *loggingT) print(s severity, logr logr.Logger, filter LogFilter, args ...interface{}) { - l.printDepth(s, logr, filter, 1, args...) +func (l *loggingT) print(s severity, logger *logr.Logger, filter LogFilter, args ...interface{}) { + l.printDepth(s, logger, filter, 1, args...) } -func (l *loggingT) printDepth(s severity, logr logr.Logger, filter LogFilter, depth int, args ...interface{}) { +func (l *loggingT) printDepth(s severity, logger *logr.Logger, filter LogFilter, depth int, args ...interface{}) { buf, file, line := l.header(s, depth) // if logr is set, we clear the generated header as we rely on the backing // logr implementation to print headers - if logr != nil { + if logger != nil { l.putBuffer(buf) buf = l.getBuffer() } @@ -732,14 +732,14 @@ func (l *loggingT) printDepth(s severity, logr logr.Logger, filter LogFilter, de if buf.Bytes()[buf.Len()-1] != '\n' { buf.WriteByte('\n') } - l.output(s, logr, buf, depth, file, line, false) + l.output(s, logger, buf, depth, file, line, false) } -func (l *loggingT) printf(s severity, logr logr.Logger, filter LogFilter, format string, args ...interface{}) { +func (l *loggingT) printf(s severity, logger *logr.Logger, filter LogFilter, format string, args ...interface{}) { buf, file, line := l.header(s, 0) // if logr is set, we clear the generated header as we rely on the backing // logr implementation to print headers - if logr != nil { + if logger != nil { l.putBuffer(buf) buf = l.getBuffer() } @@ -750,17 +750,17 @@ func (l *loggingT) printf(s severity, logr logr.Logger, filter LogFilter, format if buf.Bytes()[buf.Len()-1] != '\n' { buf.WriteByte('\n') } - l.output(s, logr, buf, 0 /* depth */, file, line, false) + l.output(s, logger, buf, 0 /* depth */, file, line, false) } // printWithFileLine behaves like print but uses the provided file and line number. If // alsoLogToStderr is true, the log message always appears on standard error; it // will also appear in the log file unless --logtostderr is set. -func (l *loggingT) printWithFileLine(s severity, logr logr.Logger, filter LogFilter, file string, line int, alsoToStderr bool, args ...interface{}) { +func (l *loggingT) printWithFileLine(s severity, logger *logr.Logger, filter LogFilter, file string, line int, alsoToStderr bool, args ...interface{}) { buf := l.formatHeader(s, file, line) // if logr is set, we clear the generated header as we rely on the backing // logr implementation to print headers - if logr != nil { + if logger != nil { l.putBuffer(buf) buf = l.getBuffer() } @@ -771,28 +771,28 @@ func (l *loggingT) printWithFileLine(s severity, logr logr.Logger, filter LogFil if buf.Bytes()[buf.Len()-1] != '\n' { buf.WriteByte('\n') } - l.output(s, logr, buf, 2 /* depth */, file, line, alsoToStderr) + l.output(s, logger, buf, 2 /* depth */, file, line, alsoToStderr) } // if loggr is specified, will call loggr.Error, otherwise output with logging module. -func (l *loggingT) errorS(err error, loggr logr.Logger, filter LogFilter, depth int, msg string, keysAndValues ...interface{}) { +func (l *loggingT) errorS(err error, logger *logr.Logger, filter LogFilter, depth int, msg string, keysAndValues ...interface{}) { if filter != nil { msg, keysAndValues = filter.FilterS(msg, keysAndValues) } - if loggr != nil { - logr.WithCallDepth(loggr, depth+2).Error(err, msg, keysAndValues...) + if logger != nil { + logger.WithCallDepth(depth+2).Error(err, msg, keysAndValues...) return } l.printS(err, errorLog, depth+1, msg, keysAndValues...) } // if loggr is specified, will call loggr.Info, otherwise output with logging module. -func (l *loggingT) infoS(loggr logr.Logger, filter LogFilter, depth int, msg string, keysAndValues ...interface{}) { +func (l *loggingT) infoS(logger *logr.Logger, filter LogFilter, depth int, msg string, keysAndValues ...interface{}) { if filter != nil { msg, keysAndValues = filter.FilterS(msg, keysAndValues) } - if loggr != nil { - logr.WithCallDepth(loggr, depth+2).Info(msg, keysAndValues...) + if logger != nil { + logger.WithCallDepth(depth+2).Info(msg, keysAndValues...) return } l.printS(nil, infoLog, depth+1, msg, keysAndValues...) @@ -862,11 +862,23 @@ func (rb *redirectBuffer) Write(bytes []byte) (n int, err error) { // Use as: // ... // klog.SetLogger(zapr.NewLogger(zapLog)) +// +// To remove a backing logr implemention, use ClearLogger. Setting an +// empty logger with SetLogger(logr.Logger{}) does not work. func SetLogger(logr logr.Logger) { logging.mu.Lock() defer logging.mu.Unlock() - logging.logr = logr + logging.logr = &logr +} + +// ClearLogger removes a backing logr implementation if one was set earlier +// with SetLogger. +func ClearLogger() { + logging.mu.Lock() + defer logging.mu.Unlock() + + logging.logr = nil } // SetOutput sets the output destination for all severities @@ -904,7 +916,7 @@ func LogToStderr(stderr bool) { } // output writes the data to the log files and releases the buffer. -func (l *loggingT) output(s severity, log logr.Logger, buf *buffer, depth int, file string, line int, alsoToStderr bool) { +func (l *loggingT) output(s severity, log *logr.Logger, buf *buffer, depth int, file string, line int, alsoToStderr bool) { l.mu.Lock() if l.traceLocation.isSet() { if l.traceLocation.match(file, line) { @@ -916,9 +928,9 @@ func (l *loggingT) output(s severity, log logr.Logger, buf *buffer, depth int, f // TODO: set 'severity' and caller information as structured log info // keysAndValues := []interface{}{"severity", severityName[s], "file", file, "line", line} if s == errorLog { - logr.WithCallDepth(l.logr, depth+3).Error(nil, string(data)) + l.logr.WithCallDepth(depth+3).Error(nil, string(data)) } else { - logr.WithCallDepth(log, depth+3).Info(string(data)) + log.WithCallDepth(depth + 3).Info(string(data)) } } else if l.toStderr { os.Stderr.Write(data) @@ -1269,7 +1281,7 @@ func (l *loggingT) setV(pc uintptr) Level { // See the documentation of V for more information. type Verbose struct { enabled bool - logr logr.Logger + logr *logr.Logger filter LogFilter } @@ -1277,7 +1289,8 @@ func newVerbose(level Level, b bool) Verbose { if logging.logr == nil { return Verbose{b, nil, logging.filter} } - return Verbose{b, logging.logr.V(int(level)), logging.filter} + v := logging.logr.V(int(level)) + return Verbose{b, &v, logging.filter} } // V reports whether verbosity at the call site is at least the requested level. @@ -1315,9 +1328,14 @@ func V(level Level) Verbose { if runtime.Callers(2, logging.pcs[:]) == 0 { return newVerbose(level, false) } - v, ok := logging.vmap[logging.pcs[0]] + // runtime.Callers returns "return PCs", but we want + // to look up the symbolic information for the call, + // so subtract 1 from the PC. runtime.CallersFrames + // would be cleaner, but allocates. + pc := logging.pcs[0] - 1 + v, ok := logging.vmap[pc] if !ok { - v = logging.setV(logging.pcs[0]) + v = logging.setV(pc) } return newVerbose(level, v >= level) } @@ -1573,6 +1591,15 @@ func (ref ObjectRef) String() string { return ref.Name } +// MarshalLog ensures that loggers with support for structured output will log +// as a struct by removing the String method via a custom type. +func (ref ObjectRef) MarshalLog() interface{} { + type or ObjectRef + return or(ref) +} + +var _ logr.Marshaler = ObjectRef{} + // KMetadata is a subset of the kubernetes k8s.io/apimachinery/pkg/apis/meta/v1.Object interface // this interface may expand in the future, but will always be a subset of the // kubernetes k8s.io/apimachinery/pkg/apis/meta/v1.Object interface @@ -1603,3 +1630,20 @@ func KRef(namespace, name string) ObjectRef { Namespace: namespace, } } + +// KObjs returns slice of ObjectRef from an slice of ObjectMeta +func KObjs(arg interface{}) []ObjectRef { + s := reflect.ValueOf(arg) + if s.Kind() != reflect.Slice { + return nil + } + objectRefs := make([]ObjectRef, 0, s.Len()) + for i := 0; i < s.Len(); i++ { + if v, ok := s.Index(i).Interface().(KMetadata); ok { + objectRefs = append(objectRefs, KObj(v)) + } else { + return nil + } + } + return objectRefs +} diff --git a/vendor/k8s.io/kube-openapi/pkg/builder3/openapi.go b/vendor/k8s.io/kube-openapi/pkg/builder3/openapi.go new file mode 100644 index 0000000000..6d716ed583 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/builder3/openapi.go @@ -0,0 +1,410 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package builder3 + +import ( + "encoding/json" + "fmt" + restful "github.com/emicklei/go-restful" + "k8s.io/kube-openapi/pkg/common" + "k8s.io/kube-openapi/pkg/spec3" + "k8s.io/kube-openapi/pkg/util" + "k8s.io/kube-openapi/pkg/validation/spec" + "net/http" + "strings" +) + +const ( + OpenAPIVersion = "3.0" +) + +type openAPI struct { + config *common.Config + spec *spec3.OpenAPI + definitions map[string]common.OpenAPIDefinition +} + +func groupRoutesByPath(routes []restful.Route) map[string][]restful.Route { + pathToRoutes := make(map[string][]restful.Route) + for _, r := range routes { + pathToRoutes[r.Path] = append(pathToRoutes[r.Path], r) + } + return pathToRoutes +} + +func (o *openAPI) buildResponse(model interface{}, description string, content []string) (*spec3.Response, error) { + response := &spec3.Response{ + ResponseProps: spec3.ResponseProps{ + Description: description, + Content: make(map[string]*spec3.MediaType), + }, + } + + s, err := o.toSchema(util.GetCanonicalTypeName(model)) + if err != nil { + return nil, err + } + + for _, contentType := range content { + response.ResponseProps.Content[contentType] = &spec3.MediaType{ + MediaTypeProps: spec3.MediaTypeProps{ + Schema: s, + }, + } + } + return response, nil +} + +func (o *openAPI) buildOperations(route restful.Route, inPathCommonParamsMap map[interface{}]*spec3.Parameter) (*spec3.Operation, error) { + ret := &spec3.Operation{ + OperationProps: spec3.OperationProps{ + Description: route.Doc, + Responses: &spec3.Responses{ + ResponsesProps: spec3.ResponsesProps{ + StatusCodeResponses: make(map[int]*spec3.Response), + }, + }, + }, + } + var err error + if ret.OperationId, ret.Tags, err = o.config.GetOperationIDAndTags(&route); err != nil { + return ret, err + } + + // Build responses + for _, resp := range route.ResponseErrors { + ret.Responses.StatusCodeResponses[resp.Code], err = o.buildResponse(resp.Model, resp.Message, route.Produces) + if err != nil { + return ret, err + } + } + + // If there is no response but a write sample, assume that write sample is an http.StatusOK response. + if len(ret.Responses.StatusCodeResponses) == 0 && route.WriteSample != nil { + ret.Responses.StatusCodeResponses[http.StatusOK], err = o.buildResponse(route.WriteSample, "OK", route.Produces) + if err != nil { + return ret, err + } + } + + // TODO: Default response if needed. Common Response config + + ret.Parameters = make([]*spec3.Parameter, 0) + for _, param := range route.ParameterDocs { + _, isCommon := inPathCommonParamsMap[mapKeyFromParam(param)] + if !isCommon && param.Data().Kind != restful.BodyParameterKind { + openAPIParam, err := o.buildParameter(param.Data()) + if err != nil { + return ret, err + } + ret.Parameters = append(ret.Parameters, openAPIParam) + } + } + + body, err := o.buildRequestBody(route.ParameterDocs, route.ReadSample) + if err != nil { + return nil ,err + } + + if body != nil { + ret.RequestBody = body + } + return ret, nil +} + +func (o *openAPI) buildRequestBody(parameters []*restful.Parameter, bodySample interface{}) (*spec3.RequestBody, error) { + for _, param := range parameters { + if param.Data().Kind == restful.BodyParameterKind && bodySample != nil { + schema, err := o.toSchema(util.GetCanonicalTypeName(bodySample)) + if err != nil { + return nil, err + } + r := &spec3.RequestBody{ + RequestBodyProps: spec3.RequestBodyProps{ + Content: map[string]*spec3.MediaType{ + "application/json": &spec3.MediaType{ + MediaTypeProps: spec3.MediaTypeProps{ + Schema: schema, + }, + }, + }, + }, + } + return r, nil + } + } + return nil, nil +} + +func newOpenAPI(config *common.Config) openAPI { + o := openAPI{ + config: config, + spec: &spec3.OpenAPI{ + Version: "3.0.0", + Info: config.Info, + Paths: &spec3.Paths{ + Paths: map[string]*spec3.Path{}, + }, + Components: &spec3.Components{ + Schemas: map[string]*spec.Schema{}, + }, + }, + } + if o.config.GetOperationIDAndTags == nil { + o.config.GetOperationIDAndTags = func(r *restful.Route) (string, []string, error) { + return r.Operation, nil, nil + } + } + + if o.config.GetDefinitionName == nil { + o.config.GetDefinitionName = func(name string) (string, spec.Extensions) { + return name[strings.LastIndex(name, "/")+1:], nil + } + } + + o.definitions = o.config.GetDefinitions(func(name string) spec.Ref { + defName, _ := o.config.GetDefinitionName(name) + return spec.MustCreateRef("#/components/schemas/" + common.EscapeJsonPointer(defName)) + }) + + return o +} + +func (o *openAPI) buildOpenAPISpec(webServices []*restful.WebService) error { + pathsToIgnore := util.NewTrie(o.config.IgnorePrefixes) + for _, w := range webServices { + rootPath := w.RootPath() + if pathsToIgnore.HasPrefix(rootPath) { + continue + } + + commonParams, err := o.buildParameters(w.PathParameters()) + if err != nil { + return err + } + + for path, routes := range groupRoutesByPath(w.Routes()) { + // go-swagger has special variable definition {$NAME:*} that can only be + // used at the end of the path and it is not recognized by OpenAPI. + if strings.HasSuffix(path, ":*}") { + path = path[:len(path)-3] + "}" + } + if pathsToIgnore.HasPrefix(path) { + continue + } + + // Aggregating common parameters make API spec (and generated clients) simpler + inPathCommonParamsMap, err := o.findCommonParameters(routes) + if err != nil { + return err + } + pathItem, exists := o.spec.Paths.Paths[path] + if exists { + return fmt.Errorf("duplicate webservice route has been found for path: %v", path) + } + + pathItem = &spec3.Path{ + PathProps: spec3.PathProps{ + Parameters: make([]*spec3.Parameter, 0), + }, + } + + // add web services's parameters as well as any parameters appears in all ops, as common parameters + pathItem.Parameters = append(pathItem.Parameters, commonParams...) + for _, p := range inPathCommonParamsMap { + pathItem.Parameters = append(pathItem.Parameters, p) + } + sortParameters(pathItem.Parameters) + + for _, route := range routes { + op, _ := o.buildOperations(route, inPathCommonParamsMap) + + switch strings.ToUpper(route.Method) { + case "GET": + pathItem.Get = op + case "POST": + pathItem.Post = op + case "HEAD": + pathItem.Head = op + case "PUT": + pathItem.Put = op + case "DELETE": + pathItem.Delete = op + case "OPTIONS": + pathItem.Options = op + case "PATCH": + pathItem.Patch = op + } + + } + o.spec.Paths.Paths[path] = pathItem + } + } + return nil +} + +func BuildOpenAPISpec(webServices []*restful.WebService, config *common.Config) (*spec3.OpenAPI, error) { + a := newOpenAPI(config) + err := a.buildOpenAPISpec(webServices) + if err != nil { + return nil, err + } + return a.spec, nil +} + +func (o *openAPI) findCommonParameters(routes []restful.Route) (map[interface{}]*spec3.Parameter, error) { + commonParamsMap := make(map[interface{}]*spec3.Parameter, 0) + paramOpsCountByName := make(map[interface{}]int, 0) + paramNameKindToDataMap := make(map[interface{}]restful.ParameterData, 0) + for _, route := range routes { + routeParamDuplicateMap := make(map[interface{}]bool) + s := "" + for _, param := range route.ParameterDocs { + m, _ := json.Marshal(param.Data()) + s += string(m) + "\n" + key := mapKeyFromParam(param) + if routeParamDuplicateMap[key] { + msg, _ := json.Marshal(route.ParameterDocs) + return commonParamsMap, fmt.Errorf("duplicate parameter %v for route %v, %v", param.Data().Name, string(msg), s) + } + routeParamDuplicateMap[key] = true + paramOpsCountByName[key]++ + paramNameKindToDataMap[key] = param.Data() + } + } + for key, count := range paramOpsCountByName { + paramData := paramNameKindToDataMap[key] + if count == len(routes) && paramData.Kind != restful.BodyParameterKind { + openAPIParam, err := o.buildParameter(paramData) + if err != nil { + return commonParamsMap, err + } + commonParamsMap[key] = openAPIParam + } + } + return commonParamsMap, nil +} + +func (o *openAPI) buildParameters(restParam []*restful.Parameter) (ret []*spec3.Parameter, err error) { + ret = make([]*spec3.Parameter, len(restParam)) + for i, v := range restParam { + ret[i], err = o.buildParameter(v.Data()) + if err != nil { + return ret, err + } + } + return ret, nil +} + +func (o *openAPI) buildParameter(restParam restful.ParameterData) (ret *spec3.Parameter, err error) { + ret = &spec3.Parameter{ + ParameterProps: spec3.ParameterProps{ + Name: restParam.Name, + Description: restParam.Description, + Required: restParam.Required, + }, + } + switch restParam.Kind { + case restful.BodyParameterKind: + return nil, nil + case restful.PathParameterKind: + ret.In = "path" + if !restParam.Required { + return ret, fmt.Errorf("path parameters should be marked at required for parameter %v", restParam) + } + case restful.QueryParameterKind: + ret.In = "query" + case restful.HeaderParameterKind: + ret.In = "header" + /* TODO: add support for the cookie param */ + default: + return ret, fmt.Errorf("unsupported restful parameter kind : %v", restParam.Kind) + } + openAPIType, openAPIFormat := common.OpenAPITypeFormat(restParam.DataType) + if openAPIType == "" { + return ret, fmt.Errorf("non-body Restful parameter type should be a simple type, but got : %v", restParam.DataType) + } + + ret.Schema = &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{openAPIType}, + Format: openAPIFormat, + UniqueItems: !restParam.AllowMultiple, + }, + } + return ret, nil +} + +func (o *openAPI) buildDefinitionRecursively(name string) error { + uniqueName, extensions := o.config.GetDefinitionName(name) + if _, ok := o.spec.Components.Schemas[uniqueName]; ok { + return nil + } + if item, ok := o.definitions[name]; ok { + schema := &spec.Schema{ + VendorExtensible: item.Schema.VendorExtensible, + SchemaProps: item.Schema.SchemaProps, + SwaggerSchemaProps: item.Schema.SwaggerSchemaProps, + } + if extensions != nil { + if schema.Extensions == nil { + schema.Extensions = spec.Extensions{} + } + for k, v := range extensions { + schema.Extensions[k] = v + } + } + o.spec.Components.Schemas[uniqueName] = schema + for _, v := range item.Dependencies { + if err := o.buildDefinitionRecursively(v); err != nil { + return err + } + } + } else { + return fmt.Errorf("cannot find model definition for %v. If you added a new type, you may need to add +k8s:openapi-gen=true to the package or type and run code-gen again", name) + } + return nil +} + +func (o *openAPI) buildDefinitionForType(name string) (string, error) { + if err := o.buildDefinitionRecursively(name); err != nil { + return "", err + } + defName, _ := o.config.GetDefinitionName(name) + return "#/components/schemas/" + common.EscapeJsonPointer(defName), nil +} + +func (o *openAPI) toSchema(name string) (_ *spec.Schema, err error) { + if openAPIType, openAPIFormat := common.OpenAPITypeFormat(name); openAPIType != "" { + return &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{openAPIType}, + Format: openAPIFormat, + }, + }, nil + } else { + ref, err := o.buildDefinitionForType(name) + if err != nil { + return nil, err + } + return &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Ref: spec.MustCreateRef(ref), + }, + }, nil + } +} diff --git a/vendor/k8s.io/kube-openapi/pkg/builder3/util.go b/vendor/k8s.io/kube-openapi/pkg/builder3/util.go new file mode 100644 index 0000000000..d977bdf90f --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/builder3/util.go @@ -0,0 +1,52 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package builder3 + +import ( + "sort" + + "github.com/emicklei/go-restful" + "k8s.io/kube-openapi/pkg/spec3" +) + +func mapKeyFromParam(param *restful.Parameter) interface{} { + return struct { + Name string + Kind int + }{ + Name: param.Data().Name, + Kind: param.Data().Kind, + } +} + +func (s parameters) Len() int { return len(s) } +func (s parameters) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + +type parameters []*spec3.Parameter + +type byNameIn struct { + parameters +} + +func (s byNameIn) Less(i, j int) bool { + return s.parameters[i].Name < s.parameters[j].Name || (s.parameters[i].Name == s.parameters[j].Name && s.parameters[i].In < s.parameters[j].In) +} + +// SortParameters sorts parameters by Name and In fields. +func sortParameters(p []*spec3.Parameter) { + sort.Sort(byNameIn{p}) +} diff --git a/vendor/k8s.io/kube-openapi/pkg/common/common.go b/vendor/k8s.io/kube-openapi/pkg/common/common.go index 682014bda9..cf1d01f903 100644 --- a/vendor/k8s.io/kube-openapi/pkg/common/common.go +++ b/vendor/k8s.io/kube-openapi/pkg/common/common.go @@ -57,6 +57,11 @@ type PathHandler interface { Handle(path string, handler http.Handler) } +type PathHandlerByGroupVersion interface { + Handle(path string, handler http.Handler) + HandlePrefix(path string, handler http.Handler) +} + // Config is set of configuration for openAPI spec generation. type Config struct { // List of supported protocols such as https, http, etc. diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/enum.go b/vendor/k8s.io/kube-openapi/pkg/generators/enum.go new file mode 100644 index 0000000000..8b1994fec9 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/generators/enum.go @@ -0,0 +1,152 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package generators + +import ( + "fmt" + "regexp" + "sort" + "strings" + + "k8s.io/gengo/generator" + "k8s.io/gengo/types" +) + +const tagEnumType = "enum" +const enumTypeDescriptionHeader = "Possible enum values:" + +type enumValue struct { + Name string + Value string + Comment string +} + +type enumType struct { + Name types.Name + Values []*enumValue +} + +// enumMap is a map from the name to the matching enum type. +type enumMap map[types.Name]*enumType + +type enumContext struct { + enumTypes enumMap +} + +func newEnumContext(c *generator.Context) *enumContext { + return &enumContext{enumTypes: parseEnums(c)} +} + +// EnumType checks and finds the enumType for a given type. +// If the given type is a known enum type, returns the enumType, true +// Otherwise, returns nil, false +func (ec *enumContext) EnumType(t *types.Type) (enum *enumType, isEnum bool) { + enum, ok := ec.enumTypes[t.Name] + return enum, ok +} + +// ValueStrings returns all possible values of the enum type as strings +// the results are sorted and quoted as Go literals. +func (et *enumType) ValueStrings() []string { + var values []string + for _, value := range et.Values { + // use "%q" format to generate a Go literal of the string const value + values = append(values, fmt.Sprintf("%q", value.Value)) + } + sort.Strings(values) + return values +} + +// DescriptionLines returns a description of the enum in this format: +// +// Possible enum values: +// - `"value1"` description 1 +// - `"value2"` description 2 +func (et *enumType) DescriptionLines() []string { + var lines []string + for _, value := range et.Values { + lines = append(lines, value.Description()) + } + sort.Strings(lines) + // Prepend an empty string to initiate a new paragraph. + return append([]string{"", enumTypeDescriptionHeader}, lines...) +} + +func parseEnums(c *generator.Context) enumMap { + // First, find the builtin "string" type + stringType := c.Universe.Type(types.Name{Name: "string"}) + + enumTypes := make(enumMap) + for _, p := range c.Universe { + // find all enum types. + for _, t := range p.Types { + if isEnumType(stringType, t) { + if _, ok := enumTypes[t.Name]; !ok { + enumTypes[t.Name] = &enumType{ + Name: t.Name, + } + } + } + } + // find all enum values from constants, and try to match each with its type. + for _, c := range p.Constants { + enumType := c.Underlying + if _, ok := enumTypes[enumType.Name]; ok { + value := &enumValue{ + Name: c.Name.Name, + Value: *c.ConstValue, + Comment: strings.Join(c.CommentLines, " "), + } + enumTypes[enumType.Name].appendValue(value) + } + } + } + + return enumTypes +} + +func (et *enumType) appendValue(value *enumValue) { + et.Values = append(et.Values, value) +} + +// Description returns the description line for the enumValue +// with the format: +// - `"FooValue"` is the Foo value +func (ev *enumValue) Description() string { + comment := strings.TrimSpace(ev.Comment) + // The comment should starts with the type name, trim it first. + comment = strings.TrimPrefix(comment, ev.Name) + // Trim the possible space after previous step. + comment = strings.TrimSpace(comment) + // The comment may be multiline, cascade all consecutive whitespaces. + comment = whitespaceRegex.ReplaceAllString(comment, " ") + return fmt.Sprintf(" - `%q` %s", ev.Value, comment) +} + +// isEnumType checks if a given type is an enum by the definition +// An enum type should be an alias of string and has tag '+enum' in its comment. +// Additionally, pass the type of builtin 'string' to check against. +func isEnumType(stringType *types.Type, t *types.Type) bool { + return t.Kind == types.Alias && t.Underlying == stringType && hasEnumTag(t) +} + +func hasEnumTag(t *types.Type) bool { + return types.ExtractCommentTags("+", t.CommentLines)[tagEnumType] != nil +} + +// whitespaceRegex is the regex for consecutive whitespaces. +var whitespaceRegex = regexp.MustCompile(`\s+`) diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/extension.go b/vendor/k8s.io/kube-openapi/pkg/generators/extension.go index 15a911288f..e37d93ef73 100644 --- a/vendor/k8s.io/kube-openapi/pkg/generators/extension.go +++ b/vendor/k8s.io/kube-openapi/pkg/generators/extension.go @@ -66,6 +66,10 @@ var tagToExtension = map[string]extensionAttributes{ kind: types.Struct, allowedValues: sets.NewString("atomic", "granular"), }, + "validations": { + xName: "x-kubernetes-validations", + kind: types.Slice, + }, } // Extension encapsulates information necessary to generate an OpenAPI extension. diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/openapi.go b/vendor/k8s.io/kube-openapi/pkg/generators/openapi.go index 44a82510e0..5d0349ccb9 100644 --- a/vendor/k8s.io/kube-openapi/pkg/generators/openapi.go +++ b/vendor/k8s.io/kube-openapi/pkg/generators/openapi.go @@ -225,6 +225,7 @@ type openAPITypeWriter struct { *generator.SnippetWriter context *generator.Context refTypes map[string]*types.Type + enumContext *enumContext GetDefinitionInterface *types.Type } @@ -233,6 +234,7 @@ func newOpenAPITypeWriter(sw *generator.SnippetWriter, c *generator.Context) ope SnippetWriter: sw, context: c, refTypes: map[string]*types.Type{}, + enumContext: newEnumContext(c), } } @@ -625,7 +627,11 @@ func (g openAPITypeWriter) generateProperty(m *types.Member, parent *types.Type) return err } g.Do("SchemaProps: spec.SchemaProps{\n", nil) - g.generateDescription(m.CommentLines) + var extraComments []string + if enumType, isEnum := g.enumContext.EnumType(m.Type); isEnum { + extraComments = enumType.DescriptionLines() + } + g.generateDescription(append(m.CommentLines, extraComments...)) jsonTags := getJsonTags(m) if len(jsonTags) > 1 && jsonTags[1] == "string" { g.generateSimpleProperty("string", "") @@ -641,6 +647,10 @@ func (g openAPITypeWriter) generateProperty(m *types.Member, parent *types.Type) typeString, format := openapi.OpenAPITypeFormat(t.String()) if typeString != "" { g.generateSimpleProperty(typeString, format) + if enumType, isEnum := g.enumContext.EnumType(m.Type); isEnum { + // original type is an enum, add "Enum: " and the values + g.Do("Enum: []interface{}{$.$}", strings.Join(enumType.ValueStrings(), ", ")) + } g.Do("},\n},\n", nil) return nil } diff --git a/vendor/k8s.io/kube-openapi/pkg/handler/handler.go b/vendor/k8s.io/kube-openapi/pkg/handler/handler.go index 7de4eba762..7338094cbe 100644 --- a/vendor/k8s.io/kube-openapi/pkg/handler/handler.go +++ b/vendor/k8s.io/kube-openapi/pkg/handler/handler.go @@ -20,6 +20,7 @@ import ( "bytes" "compress/gzip" "crypto/sha512" + "encoding/json" "fmt" "mime" "net/http" @@ -30,9 +31,9 @@ import ( "github.com/emicklei/go-restful" "github.com/golang/protobuf/proto" openapi_v2 "github.com/googleapis/gnostic/openapiv2" - jsoniter "github.com/json-iterator/go" "github.com/munnerz/goautoneg" "gopkg.in/yaml.v2" + klog "k8s.io/klog/v2" "k8s.io/kube-openapi/pkg/builder" "k8s.io/kube-openapi/pkg/common" "k8s.io/kube-openapi/pkg/validation/spec" @@ -55,13 +56,40 @@ type OpenAPIService struct { lastModified time.Time - specBytes []byte - specPb []byte - specPbGz []byte + jsonCache cache + protoCache cache +} + +type cache struct { + BuildCache func() ([]byte, error) + once sync.Once + bytes []byte + etag string + err error +} - specBytesETag string - specPbETag string - specPbGzETag string +func (c *cache) Get() ([]byte, string, error) { + c.once.Do(func() { + bytes, err := c.BuildCache() + // if there is an error updating the cache, there can be situations where + // c.bytes contains a valid value (carried over from the previous update) + // but c.err is also not nil; the cache user is expected to check for this + c.err = err + if c.err == nil { + // don't override previous spec if we had an error + c.bytes = bytes + c.etag = computeETag(c.bytes) + } + }) + return c.bytes, c.etag, c.err +} + +func (c *cache) New(cacheBuilder func() ([]byte, error)) cache { + return cache{ + bytes: c.bytes, + etag: c.etag, + BuildCache: cacheBuilder, + } } func init() { @@ -71,6 +99,9 @@ func init() { } func computeETag(data []byte) string { + if data == nil { + return "" + } return fmt.Sprintf("\"%X\"", sha512.Sum512(data)) } @@ -83,51 +114,40 @@ func NewOpenAPIService(spec *spec.Swagger) (*OpenAPIService, error) { return o, nil } -func (o *OpenAPIService) getSwaggerBytes() ([]byte, string, time.Time) { - o.rwMutex.RLock() - defer o.rwMutex.RUnlock() - return o.specBytes, o.specBytesETag, o.lastModified -} - -func (o *OpenAPIService) getSwaggerPbBytes() ([]byte, string, time.Time) { +func (o *OpenAPIService) getSwaggerBytes() ([]byte, string, time.Time, error) { o.rwMutex.RLock() defer o.rwMutex.RUnlock() - return o.specPb, o.specPbETag, o.lastModified + specBytes, etag, err := o.jsonCache.Get() + if err != nil { + return nil, "", time.Time{}, err + } + return specBytes, etag, o.lastModified, nil } -func (o *OpenAPIService) getSwaggerPbGzBytes() ([]byte, string, time.Time) { +func (o *OpenAPIService) getSwaggerPbBytes() ([]byte, string, time.Time, error) { o.rwMutex.RLock() defer o.rwMutex.RUnlock() - return o.specPbGz, o.specPbGzETag, o.lastModified -} - -func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) { - specBytes, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(openapiSpec) + specPb, etag, err := o.protoCache.Get() if err != nil { - return err + return nil, "", time.Time{}, err } - specPb, err := ToProtoBinary(specBytes) - if err != nil { - return err - } - specPbGz := toGzip(specPb) - - specBytesETag := computeETag(specBytes) - specPbETag := computeETag(specPb) - specPbGzETag := computeETag(specPbGz) - - lastModified := time.Now() + return specPb, etag, o.lastModified, nil +} +func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) { o.rwMutex.Lock() defer o.rwMutex.Unlock() - - o.specBytes = specBytes - o.specPb = specPb - o.specPbGz = specPbGz - o.specBytesETag = specBytesETag - o.specPbETag = specPbETag - o.specPbGzETag = specPbGzETag - o.lastModified = lastModified + o.jsonCache = o.jsonCache.New(func() ([]byte, error) { + return json.Marshal(openapiSpec) + }) + o.protoCache = o.protoCache.New(func() ([]byte, error) { + json, _, err := o.jsonCache.Get() + if err != nil { + return nil, err + } + return ToProtoBinary(json) + }) + o.lastModified = time.Now() return nil } @@ -206,7 +226,7 @@ func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handl accepted := []struct { Type string SubType string - GetDataAndETag func() ([]byte, string, time.Time) + GetDataAndETag func() ([]byte, string, time.Time, error) }{ {"application", "json", o.getSwaggerBytes}, {"application", "com.github.proto-openapi.spec.v2@v1.0+protobuf", o.getSwaggerPbBytes}, @@ -230,7 +250,15 @@ func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handl } // serve the first matching media type in the sorted clause list - data, etag, lastModified := accepts.GetDataAndETag() + data, etag, lastModified, err := accepts.GetDataAndETag() + if err != nil { + klog.Errorf("Error in OpenAPI handler: %s", err) + // only return a 503 if we have no older cache data to serve + if data == nil { + w.WriteHeader(http.StatusServiceUnavailable) + return + } + } w.Header().Set("Etag", etag) // ServeContent will take care of caching using eTag. http.ServeContent(w, r, servePath, lastModified, bytes.NewReader(data)) diff --git a/vendor/k8s.io/kube-openapi/pkg/handler3/handler.go b/vendor/k8s.io/kube-openapi/pkg/handler3/handler.go new file mode 100644 index 0000000000..aa32908236 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/handler3/handler.go @@ -0,0 +1,248 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package handler3 + +import ( + "bytes" + "compress/gzip" + "crypto/sha512" + "encoding/json" + "fmt" + "mime" + "net/http" + "sort" + "strings" + "sync" + "time" + + "github.com/golang/protobuf/proto" + openapi_v3 "github.com/googleapis/gnostic/openapiv3" + "github.com/munnerz/goautoneg" + "k8s.io/kube-openapi/pkg/common" + "k8s.io/kube-openapi/pkg/spec3" + "k8s.io/kube-openapi/pkg/validation/spec" +) + +const ( + jsonExt = ".json" + + mimeJson = "application/json" + // TODO(mehdy): change @68f4ded to a version tag when gnostic add version tags. + mimePb = "application/com.github.googleapis.gnostic.OpenAPIv3@68f4ded+protobuf" + mimePbGz = "application/x-gzip" + + subTypeProtobuf = "com.github.proto-openapi.spec.v3@v1.0+protobuf" + subTypeJSON = "json" +) + +// OpenAPIService is the service responsible for serving OpenAPI spec. It has +// the ability to safely change the spec while serving it. +// OpenAPI V3 currently does not use the lazy marshaling strategy that OpenAPI V2 is using +type OpenAPIService struct { + // rwMutex protects All members of this service. + rwMutex sync.RWMutex + lastModified time.Time + v3Schema map[string]*OpenAPIV3Group +} + +type OpenAPIV3Group struct { + rwMutex sync.RWMutex + + lastModified time.Time + + specBytes []byte + specPb []byte + specPbGz []byte + + specBytesETag string + specPbETag string + specPbGzETag string +} + +func init() { + mime.AddExtensionType(".json", mimeJson) + mime.AddExtensionType(".pb-v1", mimePb) + mime.AddExtensionType(".gz", mimePbGz) +} + +func computeETag(data []byte) string { + return fmt.Sprintf("\"%X\"", sha512.Sum512(data)) +} + +// NewOpenAPIService builds an OpenAPIService starting with the given spec. +func NewOpenAPIService(spec *spec.Swagger) (*OpenAPIService, error) { + o := &OpenAPIService{} + o.v3Schema = make(map[string]*OpenAPIV3Group) + return o, nil +} + +func (o *OpenAPIService) getGroupBytes() ([]byte, error) { + o.rwMutex.RLock() + defer o.rwMutex.RUnlock() + keys := make([]string, len(o.v3Schema)) + i := 0 + for k := range o.v3Schema { + keys[i] = k + i++ + } + + sort.Strings(keys) + group := make(map[string][]string) + group["Paths"] = keys + + j, err := json.Marshal(group) + if err != nil { + return nil, err + } + return j, nil +} + +func (o *OpenAPIService) getSingleGroupBytes(getType string, group string) ([]byte, string, time.Time, error) { + o.rwMutex.RLock() + defer o.rwMutex.RUnlock() + v, ok := o.v3Schema[group] + if !ok { + return nil, "", time.Now(), fmt.Errorf("Cannot find CRD group %s", group) + } + if getType == subTypeJSON { + return v.specBytes, v.specBytesETag, v.lastModified, nil + } else if getType == subTypeProtobuf { + return v.specPb, v.specPbETag, v.lastModified, nil + } + return nil, "", time.Now(), fmt.Errorf("Invalid accept clause %s", getType) +} + +func (o *OpenAPIService) UpdateGroupVersion(group string, openapi *spec3.OpenAPI) (err error) { + o.rwMutex.Lock() + defer o.rwMutex.Unlock() + + specBytes, err := json.Marshal(openapi) + if err != nil { + return err + } + + if _, ok := o.v3Schema[group]; !ok { + o.v3Schema[group] = &OpenAPIV3Group{} + } + return o.v3Schema[group].UpdateSpec(specBytes) +} + +func (o *OpenAPIService) DeleteGroupVersion(group string) { + o.rwMutex.Lock() + defer o.rwMutex.Unlock() + delete(o.v3Schema, group) +} + +func ToV3ProtoBinary(json []byte) ([]byte, error) { + document, err := openapi_v3.ParseDocument(json) + if err != nil { + return nil, err + } + return proto.Marshal(document) +} + +func toGzip(data []byte) []byte { + var buf bytes.Buffer + zw := gzip.NewWriter(&buf) + zw.Write(data) + zw.Close() + return buf.Bytes() +} + +func (o *OpenAPIService) HandleDiscovery(w http.ResponseWriter, r *http.Request) { + data, _ := o.getGroupBytes() + http.ServeContent(w, r, "/openapi/v3", time.Now(), bytes.NewReader(data)) +} + +func (o *OpenAPIService) HandleGroupVersion(w http.ResponseWriter, r *http.Request) { + url := strings.SplitAfterN(r.URL.Path, "/", 4) + group := url[3] + + decipherableFormats := r.Header.Get("Accept") + if decipherableFormats == "" { + decipherableFormats = "*/*" + } + clauses := goautoneg.ParseAccept(decipherableFormats) + w.Header().Add("Vary", "Accept") + + if len(clauses) == 0 { + return + } + + accepted := []struct { + Type string + SubType string + }{ + {"application", subTypeJSON}, + {"application", subTypeProtobuf}, + } + + for _, clause := range clauses { + for _, accepts := range accepted { + if clause.Type != accepts.Type && clause.Type != "*" { + continue + } + if clause.SubType != accepts.SubType && clause.SubType != "*" { + continue + } + data, etag, lastModified, err := o.getSingleGroupBytes(accepts.SubType, group) + if err != nil { + return + } + w.Header().Set("Etag", etag) + http.ServeContent(w, r, "", lastModified, bytes.NewReader(data)) + return + } + } + w.WriteHeader(406) + return +} + +func (o *OpenAPIService) RegisterOpenAPIV3VersionedService(servePath string, handler common.PathHandlerByGroupVersion) error { + handler.Handle(servePath, http.HandlerFunc(o.HandleDiscovery)) + handler.HandlePrefix(servePath+"/", http.HandlerFunc(o.HandleGroupVersion)) + return nil +} + +func (o *OpenAPIV3Group) UpdateSpec(specBytes []byte) (err error) { + o.rwMutex.Lock() + defer o.rwMutex.Unlock() + + specPb, err := ToV3ProtoBinary(specBytes) + if err != nil { + return err + } + + specPbGz := toGzip(specPb) + + specBytesETag := computeETag(specBytes) + specPbETag := computeETag(specPb) + specPbGzETag := computeETag(specPbGz) + + lastModified := time.Now() + + o.specBytes = specBytes + o.specPb = specPb + o.specPbGz = specPbGz + + o.specBytesETag = specBytesETag + o.specPbETag = specPbETag + o.specPbGzETag = specPbGzETag + + o.lastModified = lastModified + return nil +} diff --git a/vendor/k8s.io/kube-openapi/pkg/schemamutation/walker.go b/vendor/k8s.io/kube-openapi/pkg/schemamutation/walker.go new file mode 100644 index 0000000000..3fac658e3c --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/schemamutation/walker.go @@ -0,0 +1,519 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package schemamutation + +import ( + "k8s.io/kube-openapi/pkg/validation/spec" +) + +// Walker runs callback functions on all references of an OpenAPI spec, +// replacing the values when visiting corresponding types. +type Walker struct { + // SchemaCallback will be called on each schema, taking the original schema, + // and before any other callbacks of the Walker. + // If the schema needs to be mutated, DO NOT mutate it in-place, + // always create a copy, mutate, and return it. + SchemaCallback func(schema *spec.Schema) *spec.Schema + + // RefCallback will be called on each ref. + // If the ref needs to be mutated, DO NOT mutate it in-place, + // always create a copy, mutate, and return it. + RefCallback func(ref *spec.Ref) *spec.Ref +} + +type SchemaCallbackFunc func(schema *spec.Schema) *spec.Schema +type RefCallbackFunc func(ref *spec.Ref) *spec.Ref + +var SchemaCallBackNoop SchemaCallbackFunc = func(schema *spec.Schema) *spec.Schema { + return schema +} +var RefCallbackNoop RefCallbackFunc = func(ref *spec.Ref) *spec.Ref { + return ref +} + +// ReplaceReferences rewrites the references without mutating the input. +// The output might share data with the input. +func ReplaceReferences(walkRef func(ref *spec.Ref) *spec.Ref, sp *spec.Swagger) *spec.Swagger { + walker := &Walker{RefCallback: walkRef, SchemaCallback: SchemaCallBackNoop} + return walker.WalkRoot(sp) +} + +func (w *Walker) WalkSchema(schema *spec.Schema) *spec.Schema { + if schema == nil { + return nil + } + + orig := schema + clone := func() { + if orig == schema { + schema = &spec.Schema{} + *schema = *orig + } + } + + // Always run callback on the whole schema first + // so that SchemaCallback can take the original schema as input. + schema = w.SchemaCallback(schema) + + if r := w.RefCallback(&schema.Ref); r != &schema.Ref { + clone() + schema.Ref = *r + } + + definitionsCloned := false + for k, v := range schema.Definitions { + if s := w.WalkSchema(&v); s != &v { + if !definitionsCloned { + definitionsCloned = true + clone() + schema.Definitions = make(spec.Definitions, len(orig.Definitions)) + for k2, v2 := range orig.Definitions { + schema.Definitions[k2] = v2 + } + } + schema.Definitions[k] = *s + } + } + + propertiesCloned := false + for k, v := range schema.Properties { + if s := w.WalkSchema(&v); s != &v { + if !propertiesCloned { + propertiesCloned = true + clone() + schema.Properties = make(map[string]spec.Schema, len(orig.Properties)) + for k2, v2 := range orig.Properties { + schema.Properties[k2] = v2 + } + } + schema.Properties[k] = *s + } + } + + patternPropertiesCloned := false + for k, v := range schema.PatternProperties { + if s := w.WalkSchema(&v); s != &v { + if !patternPropertiesCloned { + patternPropertiesCloned = true + clone() + schema.PatternProperties = make(map[string]spec.Schema, len(orig.PatternProperties)) + for k2, v2 := range orig.PatternProperties { + schema.PatternProperties[k2] = v2 + } + } + schema.PatternProperties[k] = *s + } + } + + allOfCloned := false + for i := range schema.AllOf { + if s := w.WalkSchema(&schema.AllOf[i]); s != &schema.AllOf[i] { + if !allOfCloned { + allOfCloned = true + clone() + schema.AllOf = make([]spec.Schema, len(orig.AllOf)) + copy(schema.AllOf, orig.AllOf) + } + schema.AllOf[i] = *s + } + } + + anyOfCloned := false + for i := range schema.AnyOf { + if s := w.WalkSchema(&schema.AnyOf[i]); s != &schema.AnyOf[i] { + if !anyOfCloned { + anyOfCloned = true + clone() + schema.AnyOf = make([]spec.Schema, len(orig.AnyOf)) + copy(schema.AnyOf, orig.AnyOf) + } + schema.AnyOf[i] = *s + } + } + + oneOfCloned := false + for i := range schema.OneOf { + if s := w.WalkSchema(&schema.OneOf[i]); s != &schema.OneOf[i] { + if !oneOfCloned { + oneOfCloned = true + clone() + schema.OneOf = make([]spec.Schema, len(orig.OneOf)) + copy(schema.OneOf, orig.OneOf) + } + schema.OneOf[i] = *s + } + } + + if schema.Not != nil { + if s := w.WalkSchema(schema.Not); s != schema.Not { + clone() + schema.Not = s + } + } + + if schema.AdditionalProperties != nil && schema.AdditionalProperties.Schema != nil { + if s := w.WalkSchema(schema.AdditionalProperties.Schema); s != schema.AdditionalProperties.Schema { + clone() + schema.AdditionalProperties = &spec.SchemaOrBool{Schema: s, Allows: schema.AdditionalProperties.Allows} + } + } + + if schema.AdditionalItems != nil && schema.AdditionalItems.Schema != nil { + if s := w.WalkSchema(schema.AdditionalItems.Schema); s != schema.AdditionalItems.Schema { + clone() + schema.AdditionalItems = &spec.SchemaOrBool{Schema: s, Allows: schema.AdditionalItems.Allows} + } + } + + if schema.Items != nil { + if schema.Items.Schema != nil { + if s := w.WalkSchema(schema.Items.Schema); s != schema.Items.Schema { + clone() + schema.Items = &spec.SchemaOrArray{Schema: s} + } + } else { + itemsCloned := false + for i := range schema.Items.Schemas { + if s := w.WalkSchema(&schema.Items.Schemas[i]); s != &schema.Items.Schemas[i] { + if !itemsCloned { + clone() + schema.Items = &spec.SchemaOrArray{ + Schemas: make([]spec.Schema, len(orig.Items.Schemas)), + } + itemsCloned = true + copy(schema.Items.Schemas, orig.Items.Schemas) + } + schema.Items.Schemas[i] = *s + } + } + } + } + + return schema +} + +func (w *Walker) walkParameter(param *spec.Parameter) *spec.Parameter { + if param == nil { + return nil + } + + orig := param + cloned := false + clone := func() { + if !cloned { + cloned = true + param = &spec.Parameter{} + *param = *orig + } + } + + if r := w.RefCallback(¶m.Ref); r != ¶m.Ref { + clone() + param.Ref = *r + } + if s := w.WalkSchema(param.Schema); s != param.Schema { + clone() + param.Schema = s + } + if param.Items != nil { + if r := w.RefCallback(¶m.Items.Ref); r != ¶m.Items.Ref { + param.Items.Ref = *r + } + } + + return param +} + +func (w *Walker) walkParameters(params []spec.Parameter) ([]spec.Parameter, bool) { + if params == nil { + return nil, false + } + + orig := params + cloned := false + clone := func() { + if !cloned { + cloned = true + params = make([]spec.Parameter, len(params)) + copy(params, orig) + } + } + + for i := range params { + if s := w.walkParameter(¶ms[i]); s != ¶ms[i] { + clone() + params[i] = *s + } + } + + return params, cloned +} + +func (w *Walker) walkResponse(resp *spec.Response) *spec.Response { + if resp == nil { + return nil + } + + orig := resp + cloned := false + clone := func() { + if !cloned { + cloned = true + resp = &spec.Response{} + *resp = *orig + } + } + + if r := w.RefCallback(&resp.Ref); r != &resp.Ref { + clone() + resp.Ref = *r + } + if s := w.WalkSchema(resp.Schema); s != resp.Schema { + clone() + resp.Schema = s + } + + return resp +} + +func (w *Walker) walkResponses(resps *spec.Responses) *spec.Responses { + if resps == nil { + return nil + } + + orig := resps + cloned := false + clone := func() { + if !cloned { + cloned = true + resps = &spec.Responses{} + *resps = *orig + } + } + + if r := w.walkResponse(resps.ResponsesProps.Default); r != resps.ResponsesProps.Default { + clone() + resps.Default = r + } + + responsesCloned := false + for k, v := range resps.ResponsesProps.StatusCodeResponses { + if r := w.walkResponse(&v); r != &v { + if !responsesCloned { + responsesCloned = true + clone() + resps.ResponsesProps.StatusCodeResponses = make(map[int]spec.Response, len(orig.StatusCodeResponses)) + for k2, v2 := range orig.StatusCodeResponses { + resps.ResponsesProps.StatusCodeResponses[k2] = v2 + } + } + resps.ResponsesProps.StatusCodeResponses[k] = *r + } + } + + return resps +} + +func (w *Walker) walkOperation(op *spec.Operation) *spec.Operation { + if op == nil { + return nil + } + + orig := op + cloned := false + clone := func() { + if !cloned { + cloned = true + op = &spec.Operation{} + *op = *orig + } + } + + parametersCloned := false + for i := range op.Parameters { + if s := w.walkParameter(&op.Parameters[i]); s != &op.Parameters[i] { + if !parametersCloned { + parametersCloned = true + clone() + op.Parameters = make([]spec.Parameter, len(orig.Parameters)) + copy(op.Parameters, orig.Parameters) + } + op.Parameters[i] = *s + } + } + + if r := w.walkResponses(op.Responses); r != op.Responses { + clone() + op.Responses = r + } + + return op +} + +func (w *Walker) walkPathItem(pathItem *spec.PathItem) *spec.PathItem { + if pathItem == nil { + return nil + } + + orig := pathItem + cloned := false + clone := func() { + if !cloned { + cloned = true + pathItem = &spec.PathItem{} + *pathItem = *orig + } + } + + if p, changed := w.walkParameters(pathItem.Parameters); changed { + clone() + pathItem.Parameters = p + } + if op := w.walkOperation(pathItem.Get); op != pathItem.Get { + clone() + pathItem.Get = op + } + if op := w.walkOperation(pathItem.Head); op != pathItem.Head { + clone() + pathItem.Head = op + } + if op := w.walkOperation(pathItem.Delete); op != pathItem.Delete { + clone() + pathItem.Delete = op + } + if op := w.walkOperation(pathItem.Options); op != pathItem.Options { + clone() + pathItem.Options = op + } + if op := w.walkOperation(pathItem.Patch); op != pathItem.Patch { + clone() + pathItem.Patch = op + } + if op := w.walkOperation(pathItem.Post); op != pathItem.Post { + clone() + pathItem.Post = op + } + if op := w.walkOperation(pathItem.Put); op != pathItem.Put { + clone() + pathItem.Put = op + } + + return pathItem +} + +func (w *Walker) walkPaths(paths *spec.Paths) *spec.Paths { + if paths == nil { + return nil + } + + orig := paths + cloned := false + clone := func() { + if !cloned { + cloned = true + paths = &spec.Paths{} + *paths = *orig + } + } + + pathsCloned := false + for k, v := range paths.Paths { + if p := w.walkPathItem(&v); p != &v { + if !pathsCloned { + pathsCloned = true + clone() + paths.Paths = make(map[string]spec.PathItem, len(orig.Paths)) + for k2, v2 := range orig.Paths { + paths.Paths[k2] = v2 + } + } + paths.Paths[k] = *p + } + } + + return paths +} + +func (w *Walker) WalkRoot(swagger *spec.Swagger) *spec.Swagger { + if swagger == nil { + return nil + } + + orig := swagger + cloned := false + clone := func() { + if !cloned { + cloned = true + swagger = &spec.Swagger{} + *swagger = *orig + } + } + + parametersCloned := false + for k, v := range swagger.Parameters { + if p := w.walkParameter(&v); p != &v { + if !parametersCloned { + parametersCloned = true + clone() + swagger.Parameters = make(map[string]spec.Parameter, len(orig.Parameters)) + for k2, v2 := range orig.Parameters { + swagger.Parameters[k2] = v2 + } + } + swagger.Parameters[k] = *p + } + } + + responsesCloned := false + for k, v := range swagger.Responses { + if r := w.walkResponse(&v); r != &v { + if !responsesCloned { + responsesCloned = true + clone() + swagger.Responses = make(map[string]spec.Response, len(orig.Responses)) + for k2, v2 := range orig.Responses { + swagger.Responses[k2] = v2 + } + } + swagger.Responses[k] = *r + } + } + + definitionsCloned := false + for k, v := range swagger.Definitions { + if s := w.WalkSchema(&v); s != &v { + if !definitionsCloned { + definitionsCloned = true + clone() + swagger.Definitions = make(spec.Definitions, len(orig.Definitions)) + for k2, v2 := range orig.Definitions { + swagger.Definitions[k2] = v2 + } + } + swagger.Definitions[k] = *s + } + } + + if swagger.Paths != nil { + if p := w.walkPaths(swagger.Paths); p != swagger.Paths { + clone() + swagger.Paths = p + } + } + + return swagger +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/component.go b/vendor/k8s.io/kube-openapi/pkg/spec3/component.go new file mode 100644 index 0000000000..c1bb8bc7be --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/component.go @@ -0,0 +1,47 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import "k8s.io/kube-openapi/pkg/validation/spec" + +// Components holds a set of reusable objects for different aspects of the OAS. +// All objects defined within the components object will have no effect on the API +// unless they are explicitly referenced from properties outside the components object. +// +// more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#componentsObject +type Components struct { + // Schemas holds reusable Schema Objects + Schemas map[string]*spec.Schema `json:"schemas,omitempty"` + // SecuritySchemes holds reusable Security Scheme Objects, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#securitySchemeObject + SecuritySchemes SecuritySchemes `json:"securitySchemes,omitempty"` + // Responses holds reusable Responses Objects + Responses map[string]*Response `json:"responses,omitempty"` + // Parameters holds reusable Parameters Objects + Parameters map[string]*Parameter `json:"parameters,omitempty"` + // Example holds reusable Example objects + Examples map[string]*Example `json:"examples,omitempty"` + // RequestBodies holds reusable Request Body objects + RequestBodies map[string]*RequestBody `json:"requestBodies,omitempty"` + // Links is a map of operations links that can be followed from the response + Links map[string]*Link `json:"links,omitempty"` + // Headers holds a maps of a headers name to its definition + Headers map[string]*Header `json:"headers,omitempty"` + // all fields are defined at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#componentsObject +} + +// SecuritySchemes holds reusable Security Scheme Objects, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#securitySchemeObject +type SecuritySchemes map[string]*SecurityScheme diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/encoding.go b/vendor/k8s.io/kube-openapi/pkg/spec3/encoding.go new file mode 100644 index 0000000000..51dac4bdf0 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/encoding.go @@ -0,0 +1,64 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + "github.com/go-openapi/swag" + "k8s.io/kube-openapi/pkg/validation/spec" +) + +type Encoding struct { + EncodingProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode Encoding as JSON +func (e *Encoding) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(e.EncodingProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(e.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +func (e *Encoding) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &e.EncodingProps); err != nil { + return err + } + if err := json.Unmarshal(data, &e.VendorExtensible); err != nil { + return err + } + return nil +} + +type EncodingProps struct { + // Content Type for encoding a specific property + ContentType string `json:"contentType,omitempty"` + // A map allowing additional information to be provided as headers + Headers map[string]*Header `json:"headers,omitempty"` + // Describes how a specific property value will be serialized depending on its type + Style string `json:"style,omitempty"` + // When this is true, property values of type array or object generate separate parameters for each value of the array, or key-value-pair of the map. For other types of properties this property has no effect + Explode string `json:"explode,omitempty"` + // AllowReserved determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986 + AllowReserved bool `json:"allowReserved,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/example.go b/vendor/k8s.io/kube-openapi/pkg/spec3/example.go new file mode 100644 index 0000000000..0f5ab983cc --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/example.go @@ -0,0 +1,73 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + + "k8s.io/kube-openapi/pkg/validation/spec" + "github.com/go-openapi/swag" +) + +// Example https://swagger.io/specification/#example-object + +type Example struct { + spec.Refable + ExampleProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode RequestBody as JSON +func (e *Example) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(e.Refable) + if err != nil { + return nil, err + } + b2, err := json.Marshal(e.ExampleProps) + if err != nil { + return nil, err + } + b3, err := json.Marshal(e.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2, b3), nil +} + +func (e *Example) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &e.Refable); err != nil { + return err + } + if err := json.Unmarshal(data, &e.ExampleProps); err != nil { + return err + } + if err := json.Unmarshal(data, &e.VendorExtensible); err != nil { + return err + } + return nil +} + +type ExampleProps struct { + // Summary holds a short description of the example + Summary string `json:"summary,omitempty"` + // Description holds a long description of the example + Description string `json:"description,omitempty"` + // Embedded literal example. + Value interface{} `json:"value,omitempty"` + // A URL that points to the literal example. This provides the capability to reference examples that cannot easily be included in JSON or YAML documents. + ExternalValue string `json:"externalValue,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/external_documentation.go b/vendor/k8s.io/kube-openapi/pkg/spec3/external_documentation.go new file mode 100644 index 0000000000..117113e7a7 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/external_documentation.go @@ -0,0 +1,58 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + "k8s.io/kube-openapi/pkg/validation/spec" + "github.com/go-openapi/swag" +) + +type ExternalDocumentation struct { + ExternalDocumentationProps + spec.VendorExtensible +} + +type ExternalDocumentationProps struct { + // Description is a short description of the target documentation. CommonMark syntax MAY be used for rich text representation. + Description string `json:"description,omitempty"` + // URL is the URL for the target documentation. + URL string `json:"url"` +} + +// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON +func (e *ExternalDocumentation) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(e.ExternalDocumentationProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(e.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +func (e *ExternalDocumentation) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &e.ExternalDocumentationProps); err != nil { + return err + } + if err := json.Unmarshal(data, &e.VendorExtensible); err != nil { + return err + } + return nil +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/header.go b/vendor/k8s.io/kube-openapi/pkg/spec3/header.go new file mode 100644 index 0000000000..cead4b15d1 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/header.go @@ -0,0 +1,90 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + + "github.com/go-openapi/swag" + "k8s.io/kube-openapi/pkg/validation/spec" +) + +// Header a struct that describes a single operation parameter, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#parameterObject +// +// Note that this struct is actually a thin wrapper around HeaderProps to make it referable and extensible +type Header struct { + spec.Refable + HeaderProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode Header as JSON +func (h *Header) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(h.Refable) + if err != nil { + return nil, err + } + b2, err := json.Marshal(h.HeaderProps) + if err != nil { + return nil, err + } + b3, err := json.Marshal(h.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2, b3), nil +} + +func (h *Header) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &h.Refable); err != nil { + return err + } + if err := json.Unmarshal(data, &h.HeaderProps); err != nil { + return err + } + if err := json.Unmarshal(data, &h.VendorExtensible); err != nil { + return err + } + + return nil +} + +// HeaderProps a struct that describes a header object +type HeaderProps struct { + // Description holds a brief description of the parameter + Description string `json:"description,omitempty"` + // Required determines whether this parameter is mandatory + Required bool `json:"required,omitempty"` + // Deprecated declares this operation to be deprecated + Deprecated bool `json:"deprecated,omitempty"` + // AllowEmptyValue sets the ability to pass empty-valued parameters + AllowEmptyValue bool `json:"allowEmptyValue,omitempty"` + // Style describes how the parameter value will be serialized depending on the type of the parameter value + Style string `json:"style,omitempty"` + // Explode when true, parameter values of type array or object generate separate parameters for each value of the array or key-value pair of the map + Explode bool `json:"explode,omitempty"` + // AllowReserved determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986 + AllowReserved bool `json:"allowReserved,omitempty"` + // Schema holds the schema defining the type used for the parameter + Schema *spec.Schema `json:"schema,omitempty"` + // Content holds a map containing the representations for the parameter + Content map[string]*MediaType `json:"content,omitempty"` + // Example of the header + Example interface{} `json:"example,omitempty"` + // Examples of the header + Examples map[string]*Example `json:"examples,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/media_type.go b/vendor/k8s.io/kube-openapi/pkg/spec3/media_type.go new file mode 100644 index 0000000000..828fd8dc56 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/media_type.go @@ -0,0 +1,66 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + "github.com/go-openapi/swag" + "k8s.io/kube-openapi/pkg/validation/spec" +) + +// MediaType a struct that allows you to specify content format, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#mediaTypeObject +// +// Note that this struct is actually a thin wrapper around MediaTypeProps to make it referable and extensible +type MediaType struct { + MediaTypeProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode MediaType as JSON +func (m *MediaType) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(m.MediaTypeProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(m.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +func (m *MediaType) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &m.MediaTypeProps); err != nil { + return err + } + if err := json.Unmarshal(data, &m.VendorExtensible); err != nil { + return err + } + return nil +} + +// MediaTypeProps a struct that allows you to specify content format, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#mediaTypeObject +type MediaTypeProps struct { + // Schema holds the schema defining the type used for the media type + Schema *spec.Schema `json:"schema,omitempty"` + // Example of the media type + Example interface{} `json:"example,omitempty"` + // Examples of the media type. Each example object should match the media type and specific schema if present + Examples map[string]*Example `json:"examples,omitempty"` + // A map between a property name and its encoding information. The key, being the property name, MUST exist in the schema as a property. The encoding object SHALL only apply to requestBody objects when the media type is multipart or application/x-www-form-urlencoded + Encoding map[string]*Encoding `json:"encoding,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/operation.go b/vendor/k8s.io/kube-openapi/pkg/spec3/operation.go new file mode 100644 index 0000000000..de8aa46021 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/operation.go @@ -0,0 +1,79 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + + "k8s.io/kube-openapi/pkg/validation/spec" + "github.com/go-openapi/swag" +) + +// Operation describes a single API operation on a path, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#operationObject +// +// Note that this struct is actually a thin wrapper around OperationProps to make it referable and extensible +type Operation struct { + OperationProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode Operation as JSON +func (o *Operation) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(o.OperationProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(o.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (o *Operation) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &o.OperationProps); err != nil { + return err + } + return json.Unmarshal(data, &o.VendorExtensible) +} + +// OperationProps describes a single API operation on a path, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#operationObject +type OperationProps struct { + // Tags holds a list of tags for API documentation control + Tags []string `json:"tags,omitempty"` + // Summary holds a short summary of what the operation does + Summary string `json:"summary,omitempty"` + // Description holds a verbose explanation of the operation behavior + Description string `json:"description,omitempty"` + // ExternalDocs holds additional external documentation for this operation + ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"` + // OperationId holds a unique string used to identify the operation + OperationId string `json:"operationId,omitempty"` + // Parameters a list of parameters that are applicable for this operation + Parameters []*Parameter `json:"parameters,omitempty"` + // RequestBody holds the request body applicable for this operation + RequestBody *RequestBody `json:"requestBody,omitempty"` + // Responses holds the list of possible responses as they are returned from executing this operation + Responses *Responses `json:"responses,omitempty"` + // Deprecated declares this operation to be deprecated + Deprecated bool `json:"deprecated,omitempty"` + // SecurityRequirement holds a declaration of which security mechanisms can be used for this operation + SecurityRequirement []*SecurityRequirement `json:"security,omitempty"` + // Servers contains an alternative server array to service this operation + Servers []*Server `json:"servers,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/parameter.go b/vendor/k8s.io/kube-openapi/pkg/spec3/parameter.go new file mode 100644 index 0000000000..0d7180e506 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/parameter.go @@ -0,0 +1,94 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + + "github.com/go-openapi/swag" + "k8s.io/kube-openapi/pkg/validation/spec" +) + +// Parameter a struct that describes a single operation parameter, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#parameterObject +// +// Note that this struct is actually a thin wrapper around ParameterProps to make it referable and extensible +type Parameter struct { + spec.Refable + ParameterProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode Parameter as JSON +func (p *Parameter) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(p.Refable) + if err != nil { + return nil, err + } + b2, err := json.Marshal(p.ParameterProps) + if err != nil { + return nil, err + } + b3, err := json.Marshal(p.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2, b3), nil +} + +func (p *Parameter) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &p.Refable); err != nil { + return err + } + if err := json.Unmarshal(data, &p.ParameterProps); err != nil { + return err + } + if err := json.Unmarshal(data, &p.VendorExtensible); err != nil { + return err + } + + return nil +} + +// ParameterProps a struct that describes a single operation parameter, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#parameterObject +type ParameterProps struct { + // Name holds the name of the parameter + Name string `json:"name,omitempty"` + // In holds the location of the parameter + In string `json:"in,omitempty"` + // Description holds a brief description of the parameter + Description string `json:"description,omitempty"` + // Required determines whether this parameter is mandatory + Required bool `json:"required,omitempty"` + // Deprecated declares this operation to be deprecated + Deprecated bool `json:"deprecated,omitempty"` + // AllowEmptyValue sets the ability to pass empty-valued parameters + AllowEmptyValue bool `json:"allowEmptyValue,omitempty"` + // Style describes how the parameter value will be serialized depending on the type of the parameter value + Style string `json:"style,omitempty"` + // Explode when true, parameter values of type array or object generate separate parameters for each value of the array or key-value pair of the map + Explode bool `json:"explode,omitempty"` + // AllowReserved determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986 + AllowReserved bool `json:"allowReserved,omitempty"` + // Schema holds the schema defining the type used for the parameter + Schema *spec.Schema `json:"schema,omitempty"` + // Content holds a map containing the representations for the parameter + Content map[string]*MediaType `json:"content,omitempty"` + // Example of the parameter's potential value + Example interface{} `json:"example,omitempty"` + // Examples of the parameter's potential value. Each example SHOULD contain a value in the correct format as specified in the parameter encoding + Examples map[string]*Example `json:"examples,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/path.go b/vendor/k8s.io/kube-openapi/pkg/spec3/path.go new file mode 100644 index 0000000000..bc48c504de --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/path.go @@ -0,0 +1,142 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + "strings" + + "k8s.io/kube-openapi/pkg/validation/spec" + "github.com/go-openapi/swag" +) + +// Paths describes the available paths and operations for the API, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#pathsObject +type Paths struct { + Paths map[string]*Path + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode Paths as JSON +func (p *Paths) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(p.Paths) + if err != nil { + return nil, err + } + b2, err := json.Marshal(p.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (p *Paths) UnmarshalJSON(data []byte) error { + var res map[string]json.RawMessage + if err := json.Unmarshal(data, &res); err != nil { + return err + } + for k, v := range res { + if strings.HasPrefix(strings.ToLower(k), "x-") { + if p.Extensions == nil { + p.Extensions = make(map[string]interface{}) + } + var d interface{} + if err := json.Unmarshal(v, &d); err != nil { + return err + } + p.Extensions[k] = d + } + if strings.HasPrefix(k, "/") { + if p.Paths == nil { + p.Paths = make(map[string]*Path) + } + var pi *Path + if err := json.Unmarshal(v, &pi); err != nil { + return err + } + p.Paths[k] = pi + } + } + return nil +} + +// Path describes the operations available on a single path, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#pathItemObject +// +// Note that this struct is actually a thin wrapper around PathProps to make it referable and extensible +type Path struct { + spec.Refable + PathProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode Path as JSON +func (p *Path) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(p.Refable) + if err != nil { + return nil, err + } + b2, err := json.Marshal(p.PathProps) + if err != nil { + return nil, err + } + b3, err := json.Marshal(p.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2, b3), nil +} + +func (p *Path) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &p.Refable); err != nil { + return err + } + if err := json.Unmarshal(data, &p.PathProps); err != nil { + return err + } + if err := json.Unmarshal(data, &p.VendorExtensible); err != nil { + return err + } + return nil +} + +// PathProps describes the operations available on a single path, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#pathItemObject +type PathProps struct { + // Summary holds a summary for all operations in this path + Summary string `json:"summary,omitempty"` + // Description holds a description for all operations in this path + Description string `json:"description,omitempty"` + // Get defines GET operation + Get *Operation `json:"get,omitempty"` + // Put defines PUT operation + Put *Operation `json:"put,omitempty"` + // Post defines POST operation + Post *Operation `json:"post,omitempty"` + // Delete defines DELETE operation + Delete *Operation `json:"delete,omitempty"` + // Options defines OPTIONS operation + Options *Operation `json:"options,omitempty"` + // Head defines HEAD operation + Head *Operation `json:"head,omitempty"` + // Patch defines PATCH operation + Patch *Operation `json:"patch,omitempty"` + // Trace defines TRACE operation + Trace *Operation `json:"trace,omitempty"` + // Servers is an alternative server array to service all operations in this path + Servers []*Server `json:"servers,omitempty"` + // Parameters a list of parameters that are applicable for this operation + Parameters []*Parameter `json:"parameters,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/request_body.go b/vendor/k8s.io/kube-openapi/pkg/spec3/request_body.go new file mode 100644 index 0000000000..0adc628266 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/request_body.go @@ -0,0 +1,73 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + + "k8s.io/kube-openapi/pkg/validation/spec" + "github.com/go-openapi/swag" +) + +// RequestBody describes a single request body, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#requestBodyObject +// +// Note that this struct is actually a thin wrapper around RequestBodyProps to make it referable and extensible +type RequestBody struct { + spec.Refable + RequestBodyProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode RequestBody as JSON +func (r *RequestBody) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(r.Refable) + if err != nil { + return nil, err + } + b2, err := json.Marshal(r.RequestBodyProps) + if err != nil { + return nil, err + } + b3, err := json.Marshal(r.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2, b3), nil +} + +func (r *RequestBody) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &r.Refable); err != nil { + return err + } + if err := json.Unmarshal(data, &r.RequestBodyProps); err != nil { + return err + } + if err := json.Unmarshal(data, &r.VendorExtensible); err != nil { + return err + } + return nil +} + +// RequestBodyProps describes a single request body, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#requestBodyObject +type RequestBodyProps struct { + // Description holds a brief description of the request body + Description string `json:"description,omitempty"` + // Content is the content of the request body. The key is a media type or media type range and the value describes it + Content map[string]*MediaType `json:"content,omitempty"` + // Required determines if the request body is required in the request + Required bool `json:"required,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/response.go b/vendor/k8s.io/kube-openapi/pkg/spec3/response.go new file mode 100644 index 0000000000..ccd73369f7 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/response.go @@ -0,0 +1,203 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + "strconv" + + "k8s.io/kube-openapi/pkg/validation/spec" + "github.com/go-openapi/swag" +) + +// Responses holds the list of possible responses as they are returned from executing this operation +// +// Note that this struct is actually a thin wrapper around ResponsesProps to make it referable and extensible +type Responses struct { + ResponsesProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON +func (r *Responses) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(r.ResponsesProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(r.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +func (r *Responses) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &r.ResponsesProps); err != nil { + return err + } + if err := json.Unmarshal(data, &r.VendorExtensible); err != nil { + return err + } + + return nil +} + +// ResponsesProps holds the list of possible responses as they are returned from executing this operation +type ResponsesProps struct { + // Default holds the documentation of responses other than the ones declared for specific HTTP response codes. Use this field to cover undeclared responses + Default *Response `json:"-"` + // StatusCodeResponses holds a map of any HTTP status code to the response definition + StatusCodeResponses map[int]*Response `json:"-"` +} + +// MarshalJSON is a custom marshal function that knows how to encode ResponsesProps as JSON +func (r ResponsesProps) MarshalJSON() ([]byte, error) { + toser := map[string]*Response{} + if r.Default != nil { + toser["default"] = r.Default + } + for k, v := range r.StatusCodeResponses { + toser[strconv.Itoa(k)] = v + } + return json.Marshal(toser) +} + +// UnmarshalJSON unmarshals responses from JSON +func (r *ResponsesProps) UnmarshalJSON(data []byte) error { + var res map[string]*Response + if err := json.Unmarshal(data, &res); err != nil { + return nil + } + if v, ok := res["default"]; ok { + r.Default = v + delete(res, "default") + } + for k, v := range res { + if nk, err := strconv.Atoi(k); err == nil { + if r.StatusCodeResponses == nil { + r.StatusCodeResponses = map[int]*Response{} + } + r.StatusCodeResponses[nk] = v + } + } + return nil +} + +// Response describes a single response from an API Operation, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#responseObject +// +// Note that this struct is actually a thin wrapper around ResponseProps to make it referable and extensible +type Response struct { + spec.Refable + ResponseProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode Response as JSON +func (r *Response) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(r.Refable) + if err != nil { + return nil, err + } + b2, err := json.Marshal(r.ResponseProps) + if err != nil { + return nil, err + } + b3, err := json.Marshal(r.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2, b3), nil +} + +func (r *Response) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &r.Refable); err != nil { + return err + } + if err := json.Unmarshal(data, &r.ResponseProps); err != nil { + return err + } + if err := json.Unmarshal(data, &r.VendorExtensible); err != nil { + return err + } + + return nil +} + +// ResponseProps describes a single response from an API Operation, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#responseObject +type ResponseProps struct { + // Description holds a short description of the response + Description string `json:"description,omitempty"` + // Headers holds a maps of a headers name to its definition + Headers map[string]*Header `json:"headers,omitempty"` + // Content holds a map containing descriptions of potential response payloads + Content map[string]*MediaType `json:"content,omitempty"` + // Links is a map of operations links that can be followed from the response + Links map[string]*Link `json:"links,omitempty"` +} + + +// Link represents a possible design-time link for a response, more at https://swagger.io/specification/#link-object +type Link struct { + spec.Refable + LinkProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode Link as JSON +func (r *Link) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(r.Refable) + if err != nil { + return nil, err + } + b2, err := json.Marshal(r.LinkProps) + if err != nil { + return nil, err + } + b3, err := json.Marshal(r.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2, b3), nil +} + +func (r *Link) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &r.Refable); err != nil { + return err + } + if err := json.Unmarshal(data, &r.LinkProps); err != nil { + return err + } + if err := json.Unmarshal(data, &r.VendorExtensible); err != nil { + return err + } + + return nil +} + +// LinkProps describes a single response from an API Operation, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#responseObject +type LinkProps struct { + // OperationId is the name of an existing, resolvable OAS operation + OperationId string `json:"operationId,omitempty"` + // Parameters is a map representing parameters to pass to an operation as specified with operationId or identified via operationRef + Parameters map[string]interface{} `json:"parameters,omitempty"` + // Description holds a description of the link + Description string `json:"description,omitempty"` + // RequestBody is a literal value or expresion to use as a request body when calling the target operation + RequestBody interface{} `json:"requestBody,omitempty"` + // Server holds a server object used by the target operation + Server *Server `json:"server,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/security_requirement.go b/vendor/k8s.io/kube-openapi/pkg/spec3/security_requirement.go new file mode 100644 index 0000000000..0ce8924efd --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/security_requirement.go @@ -0,0 +1,56 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + + "k8s.io/kube-openapi/pkg/validation/spec" + "github.com/go-openapi/swag" +) + +// SecurityRequirementProps describes the required security schemes to execute an operation, more at https://swagger.io/specification/#security-requirement-object +// +// Note that this struct is actually a thin wrapper around SecurityRequirementProps to make it referable and extensible +type SecurityRequirement struct { + SecurityRequirementProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode SecurityRequirement as JSON +func (s *SecurityRequirement) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(s.SecurityRequirementProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(s.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (s *SecurityRequirement) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &s.SecurityRequirementProps); err != nil { + return err + } + return json.Unmarshal(data, &s.VendorExtensible) +} + +// SecurityRequirementProps describes the required security schemes to execute an operation, more at https://swagger.io/specification/#security-requirement-object +type SecurityRequirementProps map[string][]string diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/security_scheme.go b/vendor/k8s.io/kube-openapi/pkg/spec3/security_scheme.go new file mode 100644 index 0000000000..9b1352f4e3 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/security_scheme.go @@ -0,0 +1,118 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + + "k8s.io/kube-openapi/pkg/validation/spec" + "github.com/go-openapi/swag" +) + +// SecurityScheme defines reusable Security Scheme Object, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#securitySchemeObject +type SecurityScheme struct { + spec.Refable + SecuritySchemeProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode SecurityScheme as JSON +func (s *SecurityScheme) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(s.SecuritySchemeProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(s.VendorExtensible) + if err != nil { + return nil, err + } + b3, err := json.Marshal(s.Refable) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2, b3), nil +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (s *SecurityScheme) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &s.SecuritySchemeProps); err != nil { + return err + } + if err := json.Unmarshal(data, &s.VendorExtensible); err != nil { + return err + } + return json.Unmarshal(data, &s.Refable) +} + +// SecuritySchemeProps defines a security scheme that can be used by the operations +type SecuritySchemeProps struct { + // Type of the security scheme + Type string `json:"type,omitempty"` + // Description holds a short description for security scheme + Description string `json:"description,omitempty"` + // Name holds the name of the header, query or cookie parameter to be used + Name string `json:"name,omitempty"` + // In holds the location of the API key + In string `json:"in,omitempty"` + // Scheme holds the name of the HTTP Authorization scheme to be used in the Authorization header + Scheme string `json:"scheme,omitempty"` + // BearerFormat holds a hint to the client to identify how the bearer token is formatted + BearerFormat string `json:"bearerFormat,omitempty"` + // Flows contains configuration information for the flow types supported. + Flows map[string]*OAuthFlow `json:"flows,omitempty"` + // OpenIdConnectUrl holds an url to discover OAuth2 configuration values from + OpenIdConnectUrl string `json:"openIdConnectUrl,omitempty"` +} + +// OAuthFlow contains configuration information for the flow types supported. +type OAuthFlow struct { + OAuthFlowProps + spec.VendorExtensible +} + +// MarshalJSON is a custom marshal function that knows how to encode OAuthFlow as JSON +func (o *OAuthFlow) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(o.OAuthFlowProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(o.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +// UnmarshalJSON hydrates this items instance with the data from JSON +func (o *OAuthFlow) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &o.OAuthFlowProps); err != nil { + return err + } + return json.Unmarshal(data, &o.VendorExtensible) +} + +// OAuthFlowProps holds configuration details for a supported OAuth Flow +type OAuthFlowProps struct { + // AuthorizationUrl hold the authorization URL to be used for this flow + AuthorizationUrl string `json:"authorizationUrl,omitempty"` + // TokenUrl holds the token URL to be used for this flow + TokenUrl string `json:"tokenUrl,omitempty"` + // RefreshUrl holds the URL to be used for obtaining refresh tokens + RefreshUrl string `json:"refreshUrl,omitempty"` + // Scopes holds the available scopes for the OAuth2 security scheme + Scopes map[string]string `json:"scopes,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/server.go b/vendor/k8s.io/kube-openapi/pkg/spec3/server.go new file mode 100644 index 0000000000..a505fb2218 --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/server.go @@ -0,0 +1,98 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "encoding/json" + "k8s.io/kube-openapi/pkg/validation/spec" + "github.com/go-openapi/swag" + +) + +type Server struct { + ServerProps + spec.VendorExtensible +} + +type ServerProps struct { + // Description is a short description of the target documentation. CommonMark syntax MAY be used for rich text representation. + Description string `json:"description,omitempty"` + // URL is the URL for the target documentation. + URL string `json:"url"` + // Variables contains a map between a variable name and its value. The value is used for substitution in the server's URL templeate + Variables map[string]*ServerVariable `json:"variables,omitempty"` +} + +// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON +func (s *Server) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(s.ServerProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(s.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +func (s *Server) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &s.ServerProps); err != nil { + return err + } + if err := json.Unmarshal(data, &s.VendorExtensible); err != nil { + return err + } + return nil +} + +type ServerVariable struct { + ServerVariableProps + spec.VendorExtensible +} + +type ServerVariableProps struct { + // Enum is an enumeration of string values to be used if the substitution options are from a limited set + Enum []string `json:"enum,omitempty"` + // Default is the default value to use for substitution, which SHALL be sent if an alternate value is not supplied + Default string `json:"default"` + // Description is a description for the server variable + Description string `json:"description,omitempty"` +} + +// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON +func (s *ServerVariable) MarshalJSON() ([]byte, error) { + b1, err := json.Marshal(s.ServerVariableProps) + if err != nil { + return nil, err + } + b2, err := json.Marshal(s.VendorExtensible) + if err != nil { + return nil, err + } + return swag.ConcatJSON(b1, b2), nil +} + +func (s *ServerVariable) UnmarshalJSON(data []byte) error { + if err := json.Unmarshal(data, &s.ServerVariableProps); err != nil { + return err + } + if err := json.Unmarshal(data, &s.VendorExtensible); err != nil { + return err + } + return nil +} diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/spec.go b/vendor/k8s.io/kube-openapi/pkg/spec3/spec.go new file mode 100644 index 0000000000..3ff48a3c3d --- /dev/null +++ b/vendor/k8s.io/kube-openapi/pkg/spec3/spec.go @@ -0,0 +1,37 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package spec3 + +import ( + "k8s.io/kube-openapi/pkg/validation/spec" +) + +// OpenAPI is an object that describes an API and conforms to the OpenAPI Specification. +type OpenAPI struct { + // Version represents the semantic version number of the OpenAPI Specification that this document uses + Version string `json:"openapi"` + // Info provides metadata about the API + Info *spec.Info `json:"info"` + // Paths holds the available target and operations for the API + Paths *Paths `json:"paths,omitempty"` + // Servers is an array of Server objects which provide connectivity information to a target server + Servers []*Server `json:"servers,omitempty"` + // Components hold various schemas for the specification + Components *Components `json:"components,omitempty"` + // ExternalDocs holds additional external documentation + ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"` +} diff --git a/vendor/k8s.io/kube-openapi/pkg/validation/spec/info.go b/vendor/k8s.io/kube-openapi/pkg/validation/spec/info.go index 504a3972af..51a2f5781f 100644 --- a/vendor/k8s.io/kube-openapi/pkg/validation/spec/info.go +++ b/vendor/k8s.io/kube-openapi/pkg/validation/spec/info.go @@ -68,6 +68,25 @@ func (e Extensions) GetStringSlice(key string) ([]string, bool) { return nil, false } +// GetObject gets the object value from the extensions. +// out must be a json serializable type; the json go struct +// tags of out are used to populate it. +func (e Extensions) GetObject(key string, out interface{}) error { + // This json serialization/deserialization could be replaced with + // an approach using reflection if the optimization becomes justified. + if v, ok := e[strings.ToLower(key)]; ok { + b, err := json.Marshal(v) + if err != nil { + return err + } + err = json.Unmarshal(b, out) + if err != nil { + return err + } + } + return nil +} + // VendorExtensible composition block. type VendorExtensible struct { Extensions Extensions diff --git a/vendor/k8s.io/kube-openapi/pkg/validation/strfmt/default.go b/vendor/k8s.io/kube-openapi/pkg/validation/strfmt/default.go index d9b898bcb8..e85b0f1b46 100644 --- a/vendor/k8s.io/kube-openapi/pkg/validation/strfmt/default.go +++ b/vendor/k8s.io/kube-openapi/pkg/validation/strfmt/default.go @@ -23,6 +23,8 @@ import ( "strings" "github.com/asaskevich/govalidator" + + netutils "k8s.io/utils/net" ) const ( @@ -154,13 +156,13 @@ func init() { Default.Add("hostname", &hn, IsHostname) ip4 := IPv4("") - Default.Add("ipv4", &ip4, govalidator.IsIPv4) + Default.Add("ipv4", &ip4, isIPv4) ip6 := IPv6("") Default.Add("ipv6", &ip6, govalidator.IsIPv6) cidr := CIDR("") - Default.Add("cidr", &cidr, govalidator.IsCIDR) + Default.Add("cidr", &cidr, isCIDR) mac := MAC("") Default.Add("mac", &mac, govalidator.IsMAC) @@ -205,6 +207,18 @@ func init() { Default.Add("password", &pw, func(_ string) bool { return true }) } +// isIPv4 checks if the string is an IPv4 address, tolerating leading 0's for compatibility with go < 1.17. +func isIPv4(s string) bool { + ip := netutils.ParseIPSloppy(s) + return ip != nil && strings.Contains(s, ".") +} + +// isCIDR checks if the string is valid CIDR notation, tolerating leading 0's for compatibility with go < 1.17. +func isCIDR(s string) bool { + _, _, err := netutils.ParseCIDRSloppy(s) + return err == nil +} + // Base64 represents a base64 encoded string, using URLEncoding alphabet // // swagger:strfmt byte diff --git a/vendor/k8s.io/kube-openapi/pkg/validation/validate/schema.go b/vendor/k8s.io/kube-openapi/pkg/validation/validate/schema.go index b275112e4a..8cd1c54b8d 100644 --- a/vendor/k8s.io/kube-openapi/pkg/validation/validate/schema.go +++ b/vendor/k8s.io/kube-openapi/pkg/validation/validate/schema.go @@ -91,7 +91,7 @@ func NewSchemaValidator(schema *spec.Schema, rootSchema interface{}, root string return &s } -// SetPath sets the path for this schema valdiator +// SetPath sets the path for this schema validator func (s *SchemaValidator) SetPath(path string) { s.Path = path } diff --git a/vendor/k8s.io/kube-openapi/pkg/validation/validate/schema_option.go b/vendor/k8s.io/kube-openapi/pkg/validation/validate/schema_option.go index 133152ee2c..34991102b3 100644 --- a/vendor/k8s.io/kube-openapi/pkg/validation/validate/schema_option.go +++ b/vendor/k8s.io/kube-openapi/pkg/validation/validate/schema_option.go @@ -16,6 +16,7 @@ package validate // SchemaValidatorOptions defines optional rules for schema validation type SchemaValidatorOptions struct { + validationRulesEnabled bool } // Option sets optional rules for schema validation diff --git a/vendor/k8s.io/kube-openapi/pkg/validation/validate/validator.go b/vendor/k8s.io/kube-openapi/pkg/validation/validate/validator.go index ef0aadce0a..38a6b31c36 100644 --- a/vendor/k8s.io/kube-openapi/pkg/validation/validate/validator.go +++ b/vendor/k8s.io/kube-openapi/pkg/validation/validate/validator.go @@ -21,15 +21,17 @@ import ( "k8s.io/kube-openapi/pkg/validation/spec" ) -// An EntityValidator is an interface for things that can validate entities -type EntityValidator interface { - Validate(interface{}) *Result -} - +// valueValidator validates the values it applies to. type valueValidator interface { + // SetPath sets the exact path of the validator prior to calling Validate. + // The exact path contains the map keys and array indices to locate the + // value to be validated from the root data element. SetPath(path string) - Applies(interface{}, reflect.Kind) bool - Validate(interface{}) *Result + // Applies returns true if the validator applies to the valueKind + // from source. Validate will be called if and only if Applies returns true. + Applies(source interface{}, valueKind reflect.Kind) bool + // Validate validates the value. + Validate(value interface{}) *Result } type basicCommonValidator struct { diff --git a/vendor/k8s.io/kubectl/pkg/cmd/util/helpers.go b/vendor/k8s.io/kubectl/pkg/cmd/util/helpers.go index 1d86235402..168e776b06 100644 --- a/vendor/k8s.io/kubectl/pkg/cmd/util/helpers.go +++ b/vendor/k8s.io/kubectl/pkg/cmd/util/helpers.go @@ -30,12 +30,14 @@ import ( jsonpatch "github.com/evanphx/json-patch" "github.com/spf13/cobra" "github.com/spf13/pflag" + apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" utilerrors "k8s.io/apimachinery/pkg/util/errors" "k8s.io/apimachinery/pkg/util/sets" + "k8s.io/apimachinery/pkg/util/strategicpatch" "k8s.io/apimachinery/pkg/util/yaml" "k8s.io/cli-runtime/pkg/genericclioptions" "k8s.io/cli-runtime/pkg/resource" @@ -465,7 +467,8 @@ type ValidateOptions struct { EnableValidation bool } -// Merge requires JSON serialization +// Merge converts the passed in object to JSON, merges the fragment into it using an RFC7396 JSON Merge Patch, +// and returns the resulting object // TODO: merge assumes JSON serialization, and does not properly abstract API retrieval func Merge(codec runtime.Codec, dst runtime.Object, fragment string) (runtime.Object, error) { // encode dst into versioned json and apply fragment directly too it @@ -484,6 +487,46 @@ func Merge(codec runtime.Codec, dst runtime.Object, fragment string) (runtime.Ob return out, nil } +// StrategicMerge converts the passed in object to JSON, merges the fragment into it using a Strategic Merge Patch, +// and returns the resulting object +func StrategicMerge(codec runtime.Codec, dst runtime.Object, fragment string, dataStruct runtime.Object) (runtime.Object, error) { + target, err := runtime.Encode(codec, dst) + if err != nil { + return nil, err + } + patched, err := strategicpatch.StrategicMergePatch(target, []byte(fragment), dataStruct) + if err != nil { + return nil, err + } + out, err := runtime.Decode(codec, patched) + if err != nil { + return nil, err + } + return out, nil +} + +// JSONPatch converts the passed in object to JSON, performs an RFC6902 JSON Patch using operations specified in the +// fragment, and returns the resulting object +func JSONPatch(codec runtime.Codec, dst runtime.Object, fragment string) (runtime.Object, error) { + target, err := runtime.Encode(codec, dst) + if err != nil { + return nil, err + } + patch, err := jsonpatch.DecodePatch([]byte(fragment)) + if err != nil { + return nil, err + } + patched, err := patch.Apply(target) + if err != nil { + return nil, err + } + out, err := runtime.Decode(codec, patched) + if err != nil { + return nil, err + } + return out, nil +} + // DumpReaderToFile writes all data from the given io.Reader to the specified file // (usually for temporary use). func DumpReaderToFile(reader io.Reader, filename string) error { @@ -695,7 +738,9 @@ func ManualStrip(file []byte) []byte { stripped := []byte{} lines := bytes.Split(file, []byte("\n")) for i, line := range lines { - if bytes.HasPrefix(bytes.TrimSpace(line), []byte("#")) { + trimline := bytes.TrimSpace(line) + + if bytes.HasPrefix(trimline, []byte("#")) && !bytes.HasPrefix(trimline, []byte("#!")) { continue } stripped = append(stripped, line...) @@ -746,3 +791,18 @@ func Warning(cmdErr io.Writer, newGeneratorName, oldGeneratorName string) { oldGeneratorName, ) } + +// Difference removes any elements of subArray from fullArray and returns the result +func Difference(fullArray []string, subArray []string) []string { + exclude := make(map[string]bool, len(subArray)) + for _, elem := range subArray { + exclude[elem] = true + } + var result []string + for _, elem := range fullArray { + if _, found := exclude[elem]; !found { + result = append(result, elem) + } + } + return result +} diff --git a/vendor/k8s.io/kubectl/pkg/cmd/util/override_options.go b/vendor/k8s.io/kubectl/pkg/cmd/util/override_options.go new file mode 100644 index 0000000000..1e63bc789b --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/cmd/util/override_options.go @@ -0,0 +1,90 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package util + +import ( + "fmt" + + "github.com/spf13/cobra" + + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/kubectl/pkg/scheme" + "k8s.io/kubectl/pkg/util/i18n" +) + +type OverrideType string + +const ( + // OverrideTypeJSON will use an RFC6902 JSON Patch to alter the generated output + OverrideTypeJSON OverrideType = "json" + + // OverrideTypeMerge will use an RFC7396 JSON Merge Patch to alter the generated output + OverrideTypeMerge OverrideType = "merge" + + // OverrideTypeStrategic will use a Strategic Merge Patch to alter the generated output + OverrideTypeStrategic OverrideType = "strategic" +) + +const DefaultOverrideType = OverrideTypeMerge + +type OverrideOptions struct { + Overrides string + OverrideType OverrideType +} + +func (o *OverrideOptions) AddOverrideFlags(cmd *cobra.Command) { + cmd.Flags().StringVar(&o.Overrides, "overrides", "", i18n.T("An inline JSON override for the generated object. If this is non-empty, it is used to override the generated object. Requires that the object supply a valid apiVersion field.")) + cmd.Flags().StringVar((*string)(&o.OverrideType), "override-type", string(DefaultOverrideType), fmt.Sprintf("The method used to override the generated object: %s, %s, or %s.", OverrideTypeJSON, OverrideTypeMerge, OverrideTypeStrategic)) +} + +func (o *OverrideOptions) NewOverrider(dataStruct runtime.Object) *Overrider { + return &Overrider{ + Options: o, + DataStruct: dataStruct, + } +} + +type Overrider struct { + Options *OverrideOptions + DataStruct runtime.Object +} + +func (o *Overrider) Apply(obj runtime.Object) (runtime.Object, error) { + if len(o.Options.Overrides) == 0 { + return obj, nil + } + + codec := runtime.NewCodec(scheme.DefaultJSONEncoder(), scheme.Codecs.UniversalDecoder(scheme.Scheme.PrioritizedVersionsAllGroups()...)) + + var overrideType OverrideType + if len(o.Options.OverrideType) == 0 { + overrideType = DefaultOverrideType + } else { + overrideType = o.Options.OverrideType + } + + switch overrideType { + case OverrideTypeJSON: + return JSONPatch(codec, obj, o.Options.Overrides) + case OverrideTypeMerge: + return Merge(codec, obj, o.Options.Overrides) + case OverrideTypeStrategic: + return StrategicMerge(codec, obj, o.Options.Overrides, o.DataStruct) + default: + return nil, fmt.Errorf("invalid override type: %v", overrideType) + } +} diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/i18n.go b/vendor/k8s.io/kubectl/pkg/util/i18n/i18n.go new file mode 100644 index 0000000000..526389ae6d --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/i18n.go @@ -0,0 +1,150 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package i18n + +import ( + "archive/zip" + "bytes" + "embed" + "errors" + "fmt" + "os" + "strings" + + "github.com/chai2010/gettext-go/gettext" + "k8s.io/klog/v2" +) + +//go:embed translations +var translations embed.FS + +var knownTranslations = map[string][]string{ + "kubectl": { + "default", + "en_US", + "fr_FR", + "zh_CN", + "ja_JP", + "zh_TW", + "it_IT", + "de_DE", + "ko_KR", + "pt_BR", + }, + // only used for unit tests. + "test": { + "default", + "en_US", + }, +} + +func loadSystemLanguage() string { + // Implements the following locale priority order: LC_ALL, LC_MESSAGES, LANG + // Similarly to: https://www.gnu.org/software/gettext/manual/html_node/Locale-Environment-Variables.html + langStr := os.Getenv("LC_ALL") + if langStr == "" { + langStr = os.Getenv("LC_MESSAGES") + } + if langStr == "" { + langStr = os.Getenv("LANG") + } + + if langStr == "" { + klog.V(3).Infof("Couldn't find the LC_ALL, LC_MESSAGES or LANG environment variables, defaulting to en_US") + return "default" + } + pieces := strings.Split(langStr, ".") + if len(pieces) != 2 { + klog.V(3).Infof("Unexpected system language (%s), defaulting to en_US", langStr) + return "default" + } + return pieces[0] +} + +func findLanguage(root string, getLanguageFn func() string) string { + langStr := getLanguageFn() + + translations := knownTranslations[root] + for ix := range translations { + if translations[ix] == langStr { + return langStr + } + } + klog.V(3).Infof("Couldn't find translations for %s, using default", langStr) + return "default" +} + +// LoadTranslations loads translation files. getLanguageFn should return a language +// string (e.g. 'en-US'). If getLanguageFn is nil, then the loadSystemLanguage function +// is used, which uses the 'LANG' environment variable. +func LoadTranslations(root string, getLanguageFn func() string) error { + if getLanguageFn == nil { + getLanguageFn = loadSystemLanguage + } + + langStr := findLanguage(root, getLanguageFn) + translationFiles := []string{ + fmt.Sprintf("%s/%s/LC_MESSAGES/k8s.po", root, langStr), + fmt.Sprintf("%s/%s/LC_MESSAGES/k8s.mo", root, langStr), + } + + klog.V(3).Infof("Setting language to %s", langStr) + // TODO: list the directory and load all files. + buf := new(bytes.Buffer) + w := zip.NewWriter(buf) + + // Make sure to check the error on Close. + for _, file := range translationFiles { + filename := "translations/" + file + f, err := w.Create(file) + if err != nil { + return err + } + data, err := translations.ReadFile(filename) + if err != nil { + return err + } + if _, err := f.Write(data); err != nil { + return nil + } + } + if err := w.Close(); err != nil { + return err + } + gettext.BindTextdomain("k8s", root+".zip", buf.Bytes()) + gettext.Textdomain("k8s") + gettext.SetLocale(langStr) + return nil +} + +// T translates a string, possibly substituting arguments into it along +// the way. If len(args) is > 0, args1 is assumed to be the plural value +// and plural translation is used. +func T(defaultValue string, args ...int) string { + if len(args) == 0 { + return gettext.PGettext("", defaultValue) + } + return fmt.Sprintf(gettext.PNGettext("", defaultValue, defaultValue+".plural", args[0]), + args[0]) +} + +// Errorf produces an error with a translated error string. +// Substitution is performed via the `T` function above, following +// the same rules. +func Errorf(defaultValue string, args ...int) error { + return errors.New(T(defaultValue, args...)) +} diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/OWNERS b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/OWNERS new file mode 100644 index 0000000000..1cc9545a47 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/OWNERS @@ -0,0 +1,7 @@ +# See the OWNERS docs at https://go.k8s.io/owners + +reviewers: + - brendandburns +approvers: + - sig-cli-maintainers + - brendandburns diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/README.md b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/README.md new file mode 100644 index 0000000000..6318ffe627 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/README.md @@ -0,0 +1,82 @@ +# Translations README + +This is a basic sketch of the workflow needed to add translations: + +# Adding/Updating Translations + +## New languages +Create `staging/src/k8s.io/kubectl/pkg/util/i18n/translations/kubectl//LC_MESSAGES/k8s.po`. There's +no need to update `translations/test/...` which is only used for unit tests. + +There is an example [PR here](https://github.com/kubernetes/kubernetes/pull/40645) which adds support for French. + +Once you've added a new language, you'll need to register it in +`staging/src/k8s.io/kubectl/pkg/util/i18n/i18n.go` by adding it to the `knownTranslations` map. + +## Wrapping strings +There is a simple script in `staging/src/k8s.io/kubectl/pkg/util/i18n/translations/extract.py` that performs +simple regular expression based wrapping of strings. It can always +use improvements to understand additional strings. + +## Extracting strings +Once the strings are wrapped, you can extract strings from go files using +the `go-xgettext` command which can be installed with: + +```console +go get github.com/gosexy/gettext/go-xgettext +``` + +Once that's installed you can run `./hack/update-translations.sh`, which +will extract and sort any new strings. + +## Adding new translations +Edit the appropriate `k8s.po` file, `poedit` is a popular open source tool +for translations. You can load the `staging/src/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/template.pot` file +to find messages that might be missing. + +Once you are done with your `k8s.po` file, generate the corresponding `k8s.mo` +file. `poedit` does this automatically on save, but you can also run +`./hack/update-translations.sh` to perform the `po` to `mo` translation. + +We use the English translation as the `msgid`. + +## Regenerating the bindata file + +> Note: Regeneration of bindata is no more necessary for Kubernetes 1.22+ as +> the translations are now embedded into the binary at compile time. +> See: https://github.com/kubernetes/kubernetes/pull/99829 + +With the `mo` files up to date, you can now convert the generated files +into code using `go-bindata` command which can be installed with: + +```console +go get github.com/go-bindata/go-bindata/... +``` + +Run `./hack/generate-bindata.sh`, this will turn the translation files +into generated code which will in turn be packaged into the Kubernetes +binaries. + +## Extracting strings + +There is a script in `staging/src/k8s.io/kubectl/pkg/util/i18n/translations/extract.py` that knows how to do some +simple extraction. It needs a lot of work. + +# Using translations + +To use translations, you simply need to add: +```go +import pkg/i18n +... +// Get a translated string +translated := i18n.T("Your message in english here") + +// Get a translated plural string +translated := i18n.T("You had % items", items) + +// Translated error +return i18n.Error("Something bad happened") + +// Translated plural error +return i18n.Error("%d bad things happened") +``` diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/extract.py b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/extract.py new file mode 100644 index 0000000000..f4c3398a2c --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/extract.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python + +# Copyright 2017 The Kubernetes Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Extract strings from command files and externalize into translation files. +Expects to be run from the root directory of the repository. + +Usage: + extract.py pkg/kubectl/cmd/apply.go + +""" +import fileinput +import sys +import re + +class MatchHandler(object): + """ Simple holder for a regular expression and a function + to run if that regular expression matches a line. + The function should expect (re.match, file, linenumber) as parameters + """ + def __init__(self, regex, replace_fn): + self.regex = re.compile(regex) + self.replace_fn = replace_fn + +def short_replace(match, file, line_number): + """Replace a Short: ... cobra command description with an internationalization + """ + sys.stdout.write('{}i18n.T({}),\n'.format(match.group(1), match.group(2))) + +SHORT_MATCH = MatchHandler(r'(\s+Short:\s+)("[^"]+"),', short_replace) + +def import_replace(match, file, line_number): + """Add an extra import for the i18n library. + Doesn't try to be smart and detect if it's already present, assumes a + gofmt round wil fix things. + """ + sys.stdout.write('{}\n"k8s.io/kubectl/pkg/util/i18n"\n'.format(match.group(1))) + +IMPORT_MATCH = MatchHandler('(.*"k8s.io/kubectl/pkg/cmd/util")', import_replace) + + +def string_flag_replace(match, file, line_number): + """Replace a cmd.Flags().String("...", "", "...") with an internationalization + """ + sys.stdout.write('{}i18n.T("{})"))\n'.format(match.group(1), match.group(2))) + +STRING_FLAG_MATCH = MatchHandler('(\s+cmd\.Flags\(\).String\("[^"]*", "[^"]*", )"([^"]*)"\)', string_flag_replace) + + +def long_string_replace(match, file, line_number): + return '{}i18n.T({}){}'.format(match.group(1), match.group(2), match.group(3)) + +LONG_DESC_MATCH = MatchHandler('(LongDesc\()(`[^`]+`)([^\n]\n)', long_string_replace) + +EXAMPLE_MATCH = MatchHandler('(Examples\()(`[^`]+`)([^\n]\n)', long_string_replace) + +def replace(filename, matchers, multiline_matchers): + """Given a file and a set of matchers, run those matchers + across the file and replace it with the results. + """ + # Run all the matchers + line_number = 0 + for line in fileinput.input(filename, inplace=True): + line_number += 1 + matched = False + for matcher in matchers: + match = matcher.regex.match(line) + if match: + matcher.replace_fn(match, filename, line_number) + matched = True + break + if not matched: + sys.stdout.write(line) + sys.stdout.flush() + with open(filename, 'r') as datafile: + content = datafile.read() + for matcher in multiline_matchers: + match = matcher.regex.search(content) + while match: + rep = matcher.replace_fn(match, filename, 0) + # Escape back references in the replacement string + # (And escape for Python) + # (And escape for regex) + rep = re.sub('\\\\(\\d)', '\\\\\\\\\\1', rep) + content = matcher.regex.sub(rep, content, 1) + match = matcher.regex.search(content) + sys.stdout.write(content) + + # gofmt the file again + from subprocess import call + call(["goimports", "-w", filename]) + +replace(sys.argv[1], [SHORT_MATCH, IMPORT_MATCH, STRING_FLAG_MATCH], [LONG_DESC_MATCH, EXAMPLE_MATCH]) diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/OWNERS b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/OWNERS new file mode 100644 index 0000000000..d3e63eb0d8 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/OWNERS @@ -0,0 +1,6 @@ +# See the OWNERS docs at https://go.k8s.io/owners + +approvers: +- sig-cli-maintainers +reviewers: +- sig-cli diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/de_DE/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/de_DE/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..ee64eb7a8d Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/de_DE/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/de_DE/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/de_DE/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..cd5d53c888 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/de_DE/LC_MESSAGES/k8s.po @@ -0,0 +1,2920 @@ +# German translation. +# Copyright (C) 2017 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR steffenschmitz@hotmail.de, 2017. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: kubernetes\n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2017-09-02 01:36+0200\n" +"Last-Translator: Steffen Schmitz \n" +"Language-Team: Steffen Schmitz \n" +"Language: de_DE\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"X-Generator: Poedit 1.8.7.1\n" +"X-Poedit-SourceCharset: UTF-8\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:62 +msgid "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" +msgstr "" +"\n" +"\t\t # Zeige Metriken für alle Nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Zeige Metriken für den gegebenen Node\n" +"\t\t kubectl top node NODE_NAME" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:46 +msgid "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" +msgstr "" +"\n" +"\t\t# Erhalte die Dokumentation einer Resource und ihrer Felder\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Erhalte die Dokumentation eines speziellen Felds einer Resource\n" +"\t\tkubectl explain pods.spec.containers" + +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:29 +msgid "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" +msgstr "" +"\n" +"\t\t# Gebe Optionen aus, die an alle Kommandos vererbt werden\n" +"\t\tkubectl options" + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:44 +msgid "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" +msgstr "" +"\n" +"\t\t# Gebe die Client- und Server-Versionen des aktuellen Kontexts aus\n" +"\t\tkubectl version" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:34 +msgid "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" +msgstr "" +"\n" +"\t\t# Gebe die unterstützten API Versionen aus\n" +"\t\tkubectl api-versions" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:75 +msgid "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" +msgstr "" +"\n" +"\t\t# Zeige Metriken für alle Pods im Namespace default\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Zeige Metriken für alle Pods im gegebenen namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Zeige Metriken für den gebenen Pod und seine Container\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Zeige Metriken für Pods mit dem Label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" + +#: pkg/kubectl/cmd/convert/convert.go:40 +msgid "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." +msgstr "" +"\n" +"\t\tKonvertiere Konfigurationsdateien zwischen API Versionen. Sowohl YAML-\n" +"\t\talsauch JSON-Formate werden akzeptiert.\n" +"\n" +"\t\tDer Befehlt akzeptiert Dateinamen, Ordner oder URL als Parameter und " +"konvertiert es ins Format\n" +"\t\tder mit --output-version gegebenen Version. Wenn die Zielversion nicht \n" +"\t\tangegeben wird oder ungültig ist, wird die neueste Version verwendet.\n" +"\n" +"\t\tDie Standardausgabe wird auf stdout im YAML-Format ausgegeben. Man kann " +"die Option -o verwenden,\n" +"\t\tum das Ausgabeziel festzulegen." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:39 +msgid "" +"\n" +"\t\tCreate a namespace with the specified name." +msgstr "" +"\n" +"\t\tErstelle einen Namespace mit dem gegebenen Namen." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:43 +msgid "" +"\n" +"\t\tCreate a role with single rule." +msgstr "" +"\n" +"\t\tErstelle eine Role mit einer einzelnen Rule." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:40 +msgid "" +"\n" +"\t\tCreate a service account with the specified name." +msgstr "" +"\n" +"\t\tErstelle einen ServiceAccount mit dem gegebenen Namen." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:84 +msgid "" +"\n" +"\t\tMark node as schedulable." +msgstr "" +"\n" +"\t\tMarkiere Knoten als schedulable." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:55 +msgid "" +"\n" +"\t\tMark node as unschedulable." +msgstr "" +"\n" +"\t\tMarkiere Knoten als unschedulable." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:70 +msgid "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." +msgstr "" +"\n" +"\t\tSetze die aktuelle Annotation Last-Applied-Configuration auf den Inhalt " +"der Datei.\n" +"\t\tDas bedeutet, dass Last-Applied-Configuration aktualisiert wird, als ob " +"'kubectl apply -f ' ausgeführt wurde,\n" +"\t\tohne andere Teile des Objekts zu aktualisieren." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:42 +msgid "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" +msgstr "" +"\n" +"\t # Erstelle einen neuen Namespace my-namespace\n" +"\t kubectl create namespace my-namespace" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:43 +msgid "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" +msgstr "" +"\n" +"\t # Erstelle einen neuen ServiceAccount my-service-account\n" +"\t kubectl create serviceaccount my-service-account" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:344 +msgid "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." +msgstr "" +"\n" +"\tErstelle einen ExternalName-Service mit den gegebenen Namen.\n" +"\n" +"\tExternalName service referenziert eine externe DNS Adresse statt\n" +"\teines pods, was Anwendungsautoren erlaubt, einen Service zu " +"referenzieren,\n" +"\tder abseits der Platform, auf anderen Clustern oder lokal exisiert." + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:28 +msgid "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." +msgstr "" +"\n" +"\tHelp hilft bei jedem Befehl in der Anwendung.\n" +"\tGib einfach kubectl help [path to command] für alle Details ein." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:311 +msgid "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" +msgstr "" +"\n" +" # Erstelle einen neuen LoadBalancer-Service my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:102 +msgid "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" +msgstr "" +"\n" +" # Schreibe den aktuellen Cluster-Zustand auf stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Schreibe aktuellen Cluster-Zustand in /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Schreibe alle Namespaces auf stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Schreibe eine Menge an Namespaces in /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:308 +msgid "" +"\n" +" Create a LoadBalancer service with the specified name." +msgstr "" +"\n" +" Erstelle einen LoadBalancer-Service mit dem gegebenen Namen." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:107 +msgid "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." +msgstr "" +"Eine komma-separierte Menge von Quota-Scopes, die zu jedem Object passen " +"muss, dass von der Quota betroffen ist." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:106 +msgid "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." +msgstr "" +"Eine komma-separierte Menge von resource=quantity Paaren, die ein hartes " +"Limit definieren." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:113 +msgid "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." +msgstr "" +"Ein Label-Selektor, der für das Budget benutzt werden kann. Nur gleichheits-" +"basierte Auswahlkriterien werden unterstützt." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:152 +msgid "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" +msgstr "" +"Ein Label-Selektor, der für den Service benutzt werden kann. Nur gleichheits-" +"basierte Auswahlkriterien werden unterstützt. Wenn er leer ist (standard), " +"wird der Selektor vom ReplicationController oder ReplicaSet abgeleitet" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:157 +msgid "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." +msgstr "" +"Zusätzliche, externe IP Adressen (die nicht von Kubernetes verwaltet " +"werden), die der Service akzeptieren soll. Wenn diese IP zu einem Knoten " +"gerouted wird, kann der Service über die IP angesprochen werden, zusätzlich " +"zu seiner generierten Service-IP." + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:125 +msgid "Approve a certificate signing request" +msgstr "Genehmige eine Certificate-Signing-Request" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:263 +msgid "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." +msgstr "" +"Weise Deine eigene ClusterIP zu oder setze sie auf 'None' für einen " +"'headless'-Service (kein LoadBalancing)." + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:105 +msgid "Attach to a running container" +msgstr "Weise einem laufenden Container zu" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:161 +msgid "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." +msgstr "" +"ClusterIP, die dem Service zugewiesen werden soll. Freilassen, für " +"automatische Zuweisung oder auf 'None' setzen für einen headless-Service." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:101 +msgid "ClusterRole this ClusterRoleBinding should reference" +msgstr "ClusterRole, die das ClusterRoleBinding referenzieren soll" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:104 +msgid "ClusterRole this RoleBinding should reference" +msgstr "ClusterRole, die das RoleBinding referenzieren soll" + +#: pkg/kubectl/cmd/convert/convert.go:95 +msgid "Convert config files between different API versions" +msgstr "Konvertiere Config-Dateien zwischen verschiedenen API Versionen" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:106 +msgid "Copy files and directories to and from containers." +msgstr "Kopiere Dateien und Ordner aus/in Container(n)." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:94 +msgid "Create a TLS secret" +msgstr "Erstelle ein TLS-Secret" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:83 +msgid "Create a namespace with the specified name" +msgstr "Erstelle einen Namespace mit dem gegebenen Namen" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:134 +msgid "Create a secret for use with a Docker registry" +msgstr "Erstelle ein Secret für die Benutzung mit einer Docker-Registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:49 +msgid "Create a secret using specified subcommand" +msgstr "Erstelle ein Secret mit dem angegebenen Sub-Befehl" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:85 +msgid "Create a service account with the specified name" +msgstr "Erstelle einen ServiceAccount mit dem gegebenen Namen" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "Lösche das angegebene Cluster aus der kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "Lösche den angegebenen Kontext aus der kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:174 +msgid "Deny a certificate signing request" +msgstr "Lehne eine Certificate-Signing-Request ab" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "Beschreibe einen oder mehrere Kontexte" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "Zeige Cluster, die in der kubeconfig definiert sind" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "" +"Zeige vereinte kubeconfig-Einstellungen oder die angegebene kubeconfig-Datei" + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:165 +msgid "Display one or many resources" +msgstr "Zeige eine oder mehrere Resourcen" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:184 +msgid "Drain node in preparation for maintenance" +msgstr "Leere Knoten, um eine Wartung vorzubereiten" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:77 +msgid "Edit a resource on the server" +msgstr "Bearbeite eine Resource auf dem Server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:152 +msgid "Email for Docker registry" +msgstr "E-Mail für Docker-Registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:89 +msgid "Execute a command in a container" +msgstr "Führe einen Befehl im Container aus" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:109 +msgid "Forward one or more local ports to a pod" +msgstr "Leite einen oder mehrere lokale Ports an einen Pod weiter" + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:37 +msgid "Help about any command" +msgstr "Hilfe für jeden Befehl" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:98 +msgid "Mark node as schedulable" +msgstr "Markiere Knoten als schedulable" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:69 +msgid "Mark node as unschedulable" +msgstr "Markiere Knoten als unschedulable" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:83 +msgid "Mark the provided resource as paused" +msgstr "Markiere die gegebene Resource als pausiert" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:49 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:50 +msgid "Modify certificate resources." +msgstr "Verändere Certificate-Resources" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "Verändere kubeconfig Dateien" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:156 +msgid "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." +msgstr "" +"Name oder Nummer des Ports in dem Container, zu dem der Service Daten leiten " +"soll. Optional." + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:174 +msgid "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." +msgstr "" +"Zeige nur Logs nach einem bestimmten Datum (RFC3339) an. Zeigt standardmäßig " +"alle logs. Es kann entweder since-time oder since benutzt werden." + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:112 +msgid "Output shell completion code for the specified shell (bash or zsh)" +msgstr "Zeige Shell-Completion-Code für die angegebene Shell (bash oder zsh)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:151 +msgid "Password for Docker registry authentication" +msgstr "Passwort für die Authentifizierung bei der Docker-Registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:110 +msgid "Path to PEM encoded public key certificate." +msgstr "Pfad des Public-Key-Zertifikats im PEM-Format." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:111 +msgid "Path to private key associated with given certificate." +msgstr "Pfad zum Private-Key, der zum gegebenen Zertifikat passt." + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:130 +msgid "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." +msgstr "" +"Vorbedingung für Resource-Version. Verlangt, dass die aktuelle Resource-" +"Version diesen Wert erfüllt, um zu skalieren." + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:73 +msgid "Print the client and server version information" +msgstr "Schreibt die Client- und Server-Versionsinformation" + +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:38 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:39 +msgid "Print the list of flags inherited by all commands" +msgstr "Schreibt die Liste von Optionen, die alle Befehle erben" + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:152 +msgid "Print the logs for a container in a pod" +msgstr "Schreibt die Logs für einen Container in einem Pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:87 +msgid "Resume a paused resource" +msgstr "Setze eine pausierte Resource fort" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:105 +msgid "Role this RoleBinding should reference" +msgstr "Role, die dieses RoleBinding referenzieren soll" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:152 +msgid "Run a particular image on the cluster" +msgstr "Starte ein bestimmtes Image auf dem Cluster" + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:119 +msgid "Run a proxy to the Kubernetes API server" +msgstr "Starte einen Proxy zum Kubernetes-API-Server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:39 +msgid "Set specific features on objects" +msgstr "Setze bestimmte Features auf Objekten" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:104 +msgid "Set the selector on a resource" +msgstr "Setze den Selektor auf einer Resource" + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:107 +msgid "Show details of a specific resource or group of resources" +msgstr "Zeige Details zu einer bestimmten Resource oder Gruppe von Resourcen" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:102 +msgid "Show the status of the rollout" +msgstr "Zeige den Status des Rollout" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:154 +msgid "Synonym for --target-port" +msgstr "Synonym für --target-port" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:174 +msgid "The image for the container to run." +msgstr "Das Image, dass auf dem Container gestartet werden soll." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:176 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" +msgstr "" +"Die Image-Pull-Policy für den Container. Wenn leer, wird der Wert nicht vom " +"Client gesetzt, sondern standardmäßig vom Server." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:111 +msgid "" +"The minimum number or percentage of available pods this budget requires." +msgstr "" +"Die minimale Anzahl oder Prozentzahl von verfügbaren Pods, die das Budget " +"voraussetzt." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:159 +msgid "The name for the newly created object." +msgstr "Der Name des neu erstellten Objekts." + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:125 +msgid "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." +msgstr "" +"Der Name des neu erstellten Objekts. Falls nicht angegeben, wird der Name " +"der Input-Resource verwendet." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:147 +msgid "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." +msgstr "" +"Der Name des zu verwendenden API-Generators. Es gibt zwei Generatoren: " +"'service/v1' und 'service/v2'. Der einzige Unterschied ist, dass der " +"Serviceport in v1 'default' heißt, während er in v2 unbenannt bleibt. " +"Standard ist 'service/v2'." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:148 +msgid "The network protocol for the service to be created. Default is 'TCP'." +msgstr "" +"Das Netzwerkprotokoll, für den zu erstellenden Service. Standard ist 'TCP'." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:149 +msgid "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" +msgstr "" +"Der Port auf den der Service hören soll. Wird von der angebotenen Resource " +"kopiert, falls nicht angegeben" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:155 +msgid "The type of secret to create" +msgstr "Der Typ des zu erstellenden Secrets" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:87 +msgid "Undo a previous rollout" +msgstr "Widerrufe ein vorheriges Rollout" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:116 +msgid "Update resource requests/limits on objects with pod templates" +msgstr "Aktualisiere Resourcen requests/limits auf Objekten mit Pod-Templates" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "Aktualisiere die Annotationen auf einer Resource" + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:133 +msgid "Update the labels on a resource" +msgstr "Aktualisiere die Labels auf einer Resource" + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:109 +msgid "Update the taints on one or more nodes" +msgstr "Aktualisiere die Taints auf einem oder mehreren Knoten" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:150 +msgid "Username for Docker registry authentication" +msgstr "Username für Authentifizierung bei der Docker-Registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:83 +msgid "View rollout history" +msgstr "Zeige rollout-Verlauf" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cmd.go:227 +msgid "kubectl controls the Kubernetes cluster manager" +msgstr "kubectl kontrolliert den Kubernetes-Cluster-Manager" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a ClusterRoleBinding for user1, user2, and group1 using " +#~ "the cluster-admin ClusterRole\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin --user=user1 --user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Erstellt ein ClusterRoleBinding für user1, user2 und group1 mit " +#~ "der ClusterRole cluster-admin\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin --user=user1 --user=user2 --group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a RoleBinding for user1, user2, and group1 using the admin " +#~ "ClusterRole\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +#~ "user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Erstellt ein RoleBinding für user1, user2 und group1 mit der " +#~ "ClusterRole admin\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +#~ "user=user2 --group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config based on folder bar\n" +#~ "\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with specified keys " +#~ "instead of file basenames on disk\n" +#~ "\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/" +#~ "file1.txt --from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with key1=config1 and " +#~ "key2=config2\n" +#~ "\t\t kubectl create configmap my-config --from-literal=key1=config1 --" +#~ "from-literal=key2=config2" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Erstellt eine neue ConfigMap mit dem Namen my-config basierend " +#~ "auf dem Ordner bar\n" +#~ "\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # Erstellt eine neue ConfigMap mit dem Namen my-config mit den " +#~ "angegebenen Keys statt des Dateinamens auf der Festplatte.\n" +#~ "\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/" +#~ "file1.txt --from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # Erstellt eine neue ConfigMap mit dem Namen my-config mit " +#~ "key1=config1 und key2=config2\n" +#~ "\t\t kubectl create configmap my-config --from-literal=key1=config1 --" +#~ "from-literal=key2=config2" + +#~ msgid "" +#~ "\n" +#~ "\t\t # If you don't already have a .dockercfg file, you can create a " +#~ "dockercfg secret directly by using:\n" +#~ "\t\t kubectl create secret docker-registry my-secret --docker-" +#~ "server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +#~ "password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Wenn keine .dockercfg Datei existiert, kann direkt ein dockercfg " +#~ "Secret erstellen mit:\n" +#~ "\t\t kubectl create secret docker-registry my-secret --docker-" +#~ "server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +#~ "password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Apply the configuration in pod.json to a pod.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Apply the JSON passed into stdin to a pod.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Note: --prune is still in Alpha\n" +#~ "\t\t# Apply the configuration in manifest.yaml that matches label " +#~ "app=nginx and delete all the other resources that are not in the file and " +#~ "match label app=nginx.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# Apply the configuration in manifest.yaml and delete all the other " +#~ "configmaps that are not in the file.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/" +#~ "v1/ConfigMap" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Wende die Konfiguration in pod.json auf einen Pod an.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Wende die JSON-Daten von stdin auf einen Pod an.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Hinweis: --prune ist noch in Alpha\n" +#~ "\t\t# Wende die Konfiguration, mit dem Label app=nginx, im manifest.yaml " +#~ "an und lösche alle Resourcen, die nicht in der Datei sind oder nicht das " +#~ "Label app=nginx besitzen.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# Wende die Konfiguration im manifest.yaml an und lösche alle " +#~ "ConfigMaps, die nicht in der Datei sind.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/" +#~ "v1/ConfigMap" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 " +#~ "and 10, no target CPU utilization specified so a default autoscaling " +#~ "policy will be used:\n" +#~ "\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +#~ "\n" +#~ "\t\t# Auto scale a replication controller \"foo\", with the number of " +#~ "pods between 1 and 5, target CPU utilization at 80%:\n" +#~ "\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Auto-skaliere ein Deployment \"foo\", mit einer Anzahl an Pods " +#~ "zwischen 2 und 10, eine Ziel-CPU-Auslastung ist angegeben, sodass eine " +#~ "Standard-autoskalierungsregel verwendet wird:\n" +#~ "\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +#~ "\n" +#~ "\t\t# Auto-skaliere einen Replication-Controller \"foo\", mit einer " +#~ "Anzahl an Pods zwischen 1 und 5, mit einer Ziel-CPU-Auslastung von 80%:\n" +#~ "\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# Convert the live state of the resource specified by 'pod.yaml' to " +#~ "the latest version\n" +#~ "\t\t# and print to stdout in json format.\n" +#~ "\t\tkubectl convert -f pod.yaml --local -o json\n" +#~ "\n" +#~ "\t\t# Convert all files under current directory to latest version and " +#~ "create them all.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Konvertiere 'pod.yaml' zur neuesten Version und schreibe auf " +#~ "stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# Konvertiere den aktuellen Zustand der Resource, die in 'pod.yaml' " +#~ "angegeben ist, zur neuesten Version\n" +#~ "\t\t# und schreibe auf stdout im JSON-Format.\n" +#~ "\t\tkubectl convert -f pod.yaml --local -o json\n" +#~ "\n" +#~ "\t\t# Konvertiere alle Dateien im aktuellen Ordner zur neuesten Version " +#~ "und erstelle sie.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" that allows user to " +#~ "perform \"get\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" with ResourceName " +#~ "specified\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods --resource-name=readablepod" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Erstellt eine ClusterRole \"pod-reader\", die es Nutzern erlaubt " +#~ "\"get\", \"watch\" und \"list\" auf den Pods auszuführen\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Erstellt eine ClusterRole \"pod-reader\" mit dem angegebenen " +#~ "ResourceName\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods --resource-name=readablepod" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" that allows user to perform \"get" +#~ "\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" with ResourceName specified\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verg=list --verb=watch --" +#~ "resource=pods --resource-name=readablepod" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Erstellt eine Role \"pod-reader\", die es dem Nutzer erlaubt \"get" +#~ "\", \"watch\" und \"list\" auf den Pods auszuführen\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Erstellt eine Role \"pod-reader\" mit dem angegebenen ResourceName\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verg=list --verb=watch --" +#~ "resource=pods --resource-name=readablepod" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a new resourcequota named my-quota\n" +#~ "\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2," +#~ "services=3,replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# Create a new resourcequota named best-effort\n" +#~ "\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Erstellt eine neue ResourceQuota my-quota\n" +#~ "\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2," +#~ "services=3,replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# Erstellt eine neue ResourceQuota best-effort\n" +#~ "\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=rails label\n" +#~ "\t\t# and require at least one of them being available at any point in " +#~ "time.\n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=nginx label\n" +#~ "\t\t# and require at least half of the pods selected to be available at " +#~ "any point in time.\n" +#~ "\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Erstellt ein Pod-Disruption-Budget my-pdb, dass alle Pods mit dem " +#~ "Label app=rails auswählt\n" +#~ "\t\t# und sicherstellt, dass mindestens einer von ihnen zu jedem " +#~ "Zeitpunkt verfügbar ist.\n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# Erstellt ein Pod-Disruption-Budget my-pdb, dass alle Pods mit dem " +#~ "Label app=nginx auswählt\n" +#~ "\t\t# und sicherstellt, dass mindestens die Hälfte der gewählten Pods zu " +#~ "jedem Zeitpunkt verfügbar ist.\n" +#~ "\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod using the data in pod.json.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Create a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# Edit the data in docker-registry.yaml in JSON using the v1 API " +#~ "format then create the resource using the edited data.\n" +#~ "\t\tkubectl create -f docker-registry.yaml --edit --output-version=v1 -o " +#~ "json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Erstellt einen Pod mit den Daten in pod.json.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Erstellt einen Pod basierend auf den JSON-Daten von stdin.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# Verändert die Daten in docker-registry.yaml in JSON mit dem v1 API " +#~ "Format und erstellt eine Resource mit den veränderten Daten.\n" +#~ "\t\tkubectl create -f docker-registry.yaml --edit --output-version=v1 -o " +#~ "json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a replication controller identified by type " +#~ "and name specified in \"nginx-controller.yaml\", which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +#~ "the name \"frontend\"\n" +#~ "\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +#~ "\n" +#~ "\t\t# Create a second service based on the above service, exposing the " +#~ "container port 8443 as port 443 with the name \"nginx-https\"\n" +#~ "\t\tkubectl expose service nginx --port=443 --target-port=8443 --" +#~ "name=nginx-https\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated streaming application on port " +#~ "4100 balancing UDP traffic and named 'video-stream'.\n" +#~ "\t\tkubectl expose rc streamer --port=4100 --protocol=udp --name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx using replica set, which " +#~ "serves on port 80 and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for an nginx deployment, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose deployment nginx --port=80 --target-port=8000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Erstellt einen Service für einen replizierten nginx, der auf Port " +#~ "80 hört und verbindet sich mit den Containern auf Port 8000.\n" +#~ "\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Erstellt einen Service für einen Replication-Controller, der über " +#~ "type und name in \"nginx-controller.yaml\" identifiziert wird, auf Port " +#~ "80 hört und verbindet sich mit den Containern auf Port 8000.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Erstellt einen Service, mit dem Namen \"frontend\", für einen Pod " +#~ "valid-pod, der auf port 444 hört\n" +#~ "\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +#~ "\n" +#~ "\t\t# Erstellt einen zweiten Service basierend auf dem vorherigen " +#~ "Service, der den Container Port 8443 auf Port 443 mit dem Namen \"nginx-" +#~ "https\" anbietet\n" +#~ "\t\tkubectl expose service nginx --port=443 --target-port=8443 --" +#~ "name=nginx-https\n" +#~ "\n" +#~ "\t\t# Erstellt einen Service für eine Replicated-Streaming-Application " +#~ "auf Port 4100, die UDP-Traffic verarbeitet und 'video-stream' heißt.\n" +#~ "\t\tkubectl expose rc streamer --port=4100 --protocol=udp --name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# Erstellt einen Service für einen replizierten nginx mit einem " +#~ "Replica-Set, dass auf Port 80 hört und verbindet sich mit den Containern " +#~ "auf Port 8000.\n" +#~ "\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Erstellt einen Service für ein nginx Deployment, dass auf Port 80 " +#~ "hört und verbindet sich mit den Containern auf Port 8000.\n" +#~ "\t\tkubectl expose deployment nginx --port=80 --target-port=8000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Delete a pod using the type and name specified in pod.json.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Delete a pod based on the type and name in the JSON passed into " +#~ "stdin.\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# Delete pods and services with label name=myLabel.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Delete a pod with minimal delay\n" +#~ "\t\tkubectl delete pod foo --now\n" +#~ "\n" +#~ "\t\t# Force delete a pod on a dead node\n" +#~ "\t\tkubectl delete pod foo --grace-period=0 --force\n" +#~ "\n" +#~ "\t\t# Delete all pods\n" +#~ "\t\tkubectl delete pods --all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Löscht einen Pod mit type und name aus pod.json.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Löscht einen Pod mit dem type und name aus den JSON-Daten von " +#~ "stdin.\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# Löscht Pods und Services mit den Namen \"baz\" und \"foo\"\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# Löscht Pods und Services mit dem Label name=myLabel.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Löscht einen Pod mit minimaler Verzögerung\n" +#~ "\t\tkubectl delete pod foo --now\n" +#~ "\n" +#~ "\t\t# Erzwingt das Löschen eines Pods auf einem toten Node\n" +#~ "\t\tkubectl delete pod foo --grace-period=0 --force\n" +#~ "\n" +#~ "\t\t# Löscht alle Pods\n" +#~ "\t\tkubectl delete pods --all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Describe a node\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# Describe a pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# Describe all pods\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# Describe pods by label name=myLabel\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Describe all pods managed by the 'frontend' replication controller " +#~ "(rc-created pods\n" +#~ "\t\t# get the name of the rc as a prefix in the pod the name).\n" +#~ "\t\tkubectl describe pods frontend" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Beschreibt einen Knoten\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# Beschreibt einen Pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# Beschreibt einen Pod mit type und name aus \"pod.json\"\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# Beschreibt alle Pods\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# Beschreibt Pods mit dem Label name=myLabel\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Beschreibt alle Pods, die vom ReplicationController 'frontend' " +#~ "verwaltet werden (rc-erstellte Pods\n" +#~ "\t\t# bekommen den Namen des rc als Prefix im Podnamen).\n" +#~ "\t\tkubectl describe pods frontend" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Drain node \"foo\", even if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet on it.\n" +#~ "\t\t$ kubectl drain foo --force\n" +#~ "\n" +#~ "\t\t# As above, but abort if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet, and use " +#~ "a grace period of 15 minutes.\n" +#~ "\t\t$ kubectl drain foo --grace-period=900" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Leere den Knoten \"foo\", selbst wenn er Pods enthält, die nicht " +#~ "von einem ReplicationController, ReplicaSet, Job, DaemonSet oder " +#~ "StatefulSet verwaltet werden.\n" +#~ "\t\t$ kubectl drain foo --force\n" +#~ "\n" +#~ "\t\t# Wie zuvor, aber es wird abgebrochen, wenn er Pods enthält, die " +#~ "nicht von einem ReplicationController, ReplicaSet, Job, DaemonSet oder " +#~ "StatefulSet verwaltet werden und mit einer Schonfrist von 15 Minuten.\n" +#~ "\t\t$ kubectl drain foo --grace-period=900" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Edit the service named 'docker-registry':\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Use an alternative editor\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Edit the job 'myjob' in JSON using the v1 API format:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +#~ "config in its annotation:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml --save-config" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Bearbeite den Service 'docker-registry':\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Benutze einen anderen Editor\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Bearbeite den Job 'myjob' in JSON mit dem v1 API Format:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# Bearbeite das Deployment 'mydeployment' in YAML und speichere die " +#~ "veränderte Konfiguration in ihrer Annotation:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml --save-config" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running 'date' from pod 123456-7890, using the " +#~ "first container by default\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# Get output from running 'date' in ruby-container from pod " +#~ "123456-7890\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t -- bash -il" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Erhalte die Ausgabe vom Aufruf von 'date' auf dem Pod 123456-7890, " +#~ "mit dem ersten Container als Standard\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# Erhalte die Ausgabe vom Aufruf von 'date' im Ruby-Container aus dem " +#~ "Pod 123456-7890\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# Wechsle in den Terminal-Modus und sende stdin zu 'bash' im Ruby-" +#~ "Container aus dem Pod 123456-7890\n" +#~ "\t\t# und sende stdout/stderr von 'bash' zurück zum Client\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t -- bash -il" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running pod 123456-7890, using the first container " +#~ "by default\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# Get output from ruby-container from pod 123456-7890\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# Get output from the first pod of a ReplicaSet named nginx\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Erhalte die Ausgabe vom laufenden Pod 123456-7890, mit dem ersten " +#~ "Container als Standard\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# Erhalte die Ausgabe vom Ruby-Container aus dem Pod 123456-7890\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# Wechsle in den Terminal-Modus und sende stdin zu 'bash' im Ruby-" +#~ "Container aus dem Pod 123456-7890\n" +#~ "\t\t# und sende stdout/stderr von 'bash' zurück zum Client\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# Erhalte die Ausgabe vom ersten Pod eines ReplicaSets nginx\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Install bash completion on a Mac using homebrew\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash completion support\n" +#~ "source $(brew --prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for bash into the current shell\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# Write bash completion code to a file and source if from ." +#~ "bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell completion\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +#~ "\t\tsource <(kubectl completion zsh)" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Installiere bash completion auf einem Mac mit homebrew\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash completion support\n" +#~ "source $(brew --prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Lade den kubectl-Completion-Code für bash in der aktuellen Shell\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# Schreibe den Bash-Completion-Code in eine Datei und source sie im ." +#~ "bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell completion\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Lade den kubectl-Completion-Code für zsh[1] in die aktuelle Shell\n" +#~ "\t\tsource <(kubectl completion zsh)" + +#~ msgid "" +#~ "\n" +#~ "\t\t# List all pods in ps output format.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# List all pods in ps output format with more information (such as " +#~ "node name).\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# List a single replication controller with specified NAME in ps " +#~ "output format.\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# List a single pod in JSON output format.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +#~ "JSON output format.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# Return only the phase value of the specified pod.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# List all replication controllers and services together in ps output " +#~ "format.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# List one or more resources by their type and names.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List all resources with different types.\n" +#~ "\t\tkubectl get all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Liste alle Pods im ps-Format auf.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# Liste alle Pods im ps-Format mit zusätzlichen Informationen (wie " +#~ "dem Knotennamen) auf.\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# Liste alle einzelnen ReplicationController mit dem angegebenen " +#~ "Namen im ps-Format auf.\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# Liste einen einzelnen Pod im JSON-Format auf.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# Liste einen Pod mit Typ und Namen aus \"pod.yaml\" im JSON-Format " +#~ "auf.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# Gib nur den phase-Wert des angegebenen Pods zurück.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# Liste alle ReplicationController und Services im ps-Format auf.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# Liste eine oder mehrere Resourcen über ihren Typ und Namen auf.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# Liste alle Resourcen mit verschiedenen Typen auf.\n" +#~ "\t\tkubectl get all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 5000 6000\n" +#~ "\n" +#~ "\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 8888:5000\n" +#~ "\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod :5000\n" +#~ "\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 0:5000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Hört lokal auf Port 5000 und 6000 und leitet Daten zum/vom Port " +#~ "5000 und 6000 weiter an den Pod\n" +#~ "\t\tkubectl port-forward mypod 5000 6000\n" +#~ "\n" +#~ "\t\t# Hört lokal auf Port 8888 und leitet an Port 5000 des Pods weiter\n" +#~ "\t\tkubectl port-forward mypod 8888:5000\n" +#~ "\n" +#~ "\t\t# Hört auf einen zufälligen lokalen Port und leitet an Port 5000 des " +#~ "Pods weiter\n" +#~ "\t\tkubectl port-forward mypod :5000\n" +#~ "\n" +#~ "\t\t# Hört auf einen zufälligen lokalen Port und leitet an Port 5000 des " +#~ "Pods weiter\n" +#~ "\t\tkubectl port-forward mypod 0:5000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as schedulable.\n" +#~ "\t\t$ kubectl uncordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Markiere Knoten \"foo\" als schedulable.\n" +#~ "\t\t$ kubectl uncordon foo" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as unschedulable.\n" +#~ "\t\tkubectl cordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Markiere Knoten \"foo\" als unschedulable.\n" +#~ "\t\tkubectl cordon foo" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Partially update a node using strategic merge patch\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# Partially update a node identified by the type and name specified " +#~ "in \"node.json\" using strategic merge patch\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image; spec.containers[*].name is required " +#~ "because it's a merge key\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image using a json patch with positional " +#~ "arrays\n" +#~ "\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Aktualisiere einen Knoten teilweise mit einem Strategic-Merge-" +#~ "Patch\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# Aktualisiere einen Knoten, mit type und name aus \"node.json\", mit " +#~ "einem Strategic-Merge-Patch\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# Aktualisiere das Image eines Containers; spec.containers[*].name " +#~ "ist erforderlich, da es der Merge-Key ist\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# Aktualisiere das Image eines Containers mit einem JSON-Patch mit " +#~ "Positional-Arrays\n" +#~ "\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Print the address of the master and cluster services\n" +#~ "\t\tkubectl cluster-info" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Gebe die Adresse des Masters und des Cluster-Services aus\n" +#~ "\t\tkubectl cluster-info" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Replace a pod using the data in pod.json.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Replace a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Update a single-container pod's image version (tag) to v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Force replace, delete and then re-create the resource\n" +#~ "\t\tkubectl replace --force -f ./pod.json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Ersetze einen Pod mit den Daten aus pod.json.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Ersetze einen Pod mit den JSON-Daten von stdin.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Setze die Pod-Image-Version (tag) eines einzelnen Containers zu v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Erzwinge das Ersetzen, Löschen und Neu-Erstellen der Resource\n" +#~ "\t\tkubectl replace --force -f ./pod.json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Return snapshot logs from pod nginx with only one container\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs for the pods defined by label app=nginx\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot of previous terminated ruby container logs from pod " +#~ "web-1\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Display only the most recent 20 lines of output in pod nginx\n" +#~ "\t\tkubectl logs --tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Show all logs from pod nginx written in the last hour\n" +#~ "\t\tkubectl logs --since=1h nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from first container of a job named hello\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from container nginx-1 of a deployment named " +#~ "nginx\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Gib die Snapshot-Logs des Pods nginx mit nur einem Container " +#~ "zurück\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# Gib die Snapshot-Logs für die Pods mit dem Label app=nginx zurück\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Gib die Snapshot-Logs des zuvor gelöschten Ruby-Containers des Pods " +#~ "web-1 zurück\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Starte das Streaming der Logs vom Ruby-Container im Pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Zeige die letzten 20 Zeilen der Ausgabe des Pods nginx\n" +#~ "\t\tkubectl logs --tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Zeige alle Logs der letzten Stunde des Pods nginx an\n" +#~ "\t\tkubectl logs --since=1h nginx\n" +#~ "\n" +#~ "\t\t# Gib die Snapshot-Logs des ersten Containers des Jobs hello zurück\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Gib die Snapshot-Logs des Containers nginx-1 eines Deployments " +#~ "nginx zurück\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on port 8011, serving static " +#~ "content from ./local/www/\n" +#~ "\t\tkubectl proxy --port=8011 --www=./local/www/\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on an arbitrary local port.\n" +#~ "\t\t# The chosen port for the server will be output to stdout.\n" +#~ "\t\tkubectl proxy --port=0\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver, changing the api prefix to k8s-" +#~ "api\n" +#~ "\t\t# This makes e.g. the pods api available at localhost:8001/k8s-api/v1/" +#~ "pods/\n" +#~ "\t\tkubectl proxy --api-prefix=/k8s-api" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Starte einen Proxy zum Kubernetes-Apiserver auf Port 8011 und sende " +#~ "statische Inhalte von ./local/www/\n" +#~ "\t\tkubectl proxy --port=8011 --www=./local/www/\n" +#~ "\n" +#~ "\t\t# Starte einen Proxy zum Kubernetes-Apiserver auf einem zufälligen " +#~ "lokalen Port.\n" +#~ "\t\t# Der gewählte Port für den Server wird im stdout zurückgegeben.\n" +#~ "\t\tkubectl proxy --port=0\n" +#~ "\n" +#~ "\t\t# Starte einen Proxy zum Kubernetes-Apiserver und ändere das API-" +#~ "Prefix zu k8s-api\n" +#~ "\t\t# Damit ist die Pods-API bspw. unter localhost:8001/k8s-api/v1/pods/ " +#~ "erreichbar\n" +#~ "\t\tkubectl proxy --api-prefix=/k8s-api" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Scale a replicaset named 'foo' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Scale a resource identified by type and name specified in \"foo.yaml" +#~ "\" to 3.\n" +#~ "\t\tkubectl scale --replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# If the deployment named mysql's current size is 2, scale mysql to " +#~ "3.\n" +#~ "\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Scale multiple replication controllers.\n" +#~ "\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Scale job named 'cron' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 job/cron" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Skaliere ein ReplicaSet 'foo' auf 3.\n" +#~ "\t\tkubectl scale --replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Skaliere eine Resource mit type und name aus \"foo.yaml\" auf 3.\n" +#~ "\t\tkubectl scale --replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# Wenn die aktuelle Größe des Deployments mysql 2 ist, skaliere mysql " +#~ "auf 3.\n" +#~ "\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Skaliere mehrere MultiplicationController.\n" +#~ "\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Skaliere den Job cron auf 3.\n" +#~ "\t\tkubectl scale --replicas=3 job/cron" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Execute set-last-applied against each configuration file in a " +#~ "directory.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file, will create the annotation if it does not already " +#~ "exist.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml --create-" +#~ "annotation=true\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Setze die Last-Applied-Configuration einer Resource auf den Inhalt " +#~ "einer Datei.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Führe Set-Last-Applied auf jeder Konfigurationsdatei in einem " +#~ "Ordner aus.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# Setze die Last-Applied-Configuration einer Resource auf den Inhalt " +#~ "einer Datei; erstellt die Annotation, wenn sie noch nicht existiert.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml --create-" +#~ "annotation=true\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Shut down foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Stop pods and services with label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Shut down the service defined in service.json\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Shut down all resources in the path/to/resources directory\n" +#~ "\t\tkubectl stop -f path/to/resources" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Stoppe foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Stoppe Pods und Services mit dem Label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Stoppe den in service.json definierten Service\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Stoppe alle Resourcen im Ordner path/to/resources\n" +#~ "\t\tkubectl stop -f path/to/resources" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Start a single instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and let the container expose " +#~ "port 5701 .\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --port=5701\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and set environment variables " +#~ "\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --env=\"DNS_DOMAIN=cluster\" " +#~ "--env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Start a replicated instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx --replicas=5\n" +#~ "\n" +#~ "\t\t# Dry run. Print the corresponding API objects without creating " +#~ "them.\n" +#~ "\t\tkubectl run nginx --image=nginx --dry-run\n" +#~ "\n" +#~ "\t\t# Start a single instance of nginx, but overload the spec of the " +#~ "deployment with a partial set of values parsed from JSON.\n" +#~ "\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": " +#~ "\"v1\", \"spec\": { ... } }'\n" +#~ "\n" +#~ "\t\t# Start a pod of busybox and keep it in the foreground, don't restart " +#~ "it if it exits.\n" +#~ "\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +#~ "\n" +#~ "\t\t# Start the nginx container using the default command, but use custom " +#~ "arguments (arg1 .. argN) for that command.\n" +#~ "\t\tkubectl run nginx --image=nginx -- ... \n" +#~ "\n" +#~ "\t\t# Start the nginx container using a different command and custom " +#~ "arguments.\n" +#~ "\t\tkubectl run nginx --image=nginx --command -- ... \n" +#~ "\n" +#~ "\t\t# Start the perl container to compute π to 2000 places and print it " +#~ "out.\n" +#~ "\t\tkubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Start the cron job to compute π to 2000 places and print it out " +#~ "every 5 minutes.\n" +#~ "\t\tkubectl run pi --schedule=\"0/5 * * * ?\" --image=perl --" +#~ "restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Starte eine einzelne Instanz von nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx\n" +#~ "\n" +#~ "\t\t# Starte eine einzelne Instanz von hazelcast und öffne Port 5701 auf " +#~ "dem Container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --port=5701\n" +#~ "\n" +#~ "\t\t# Starte eine einzelne Instanz von hazelcast und setze die Umgebungs-" +#~ "variablen \"DNS_DOMAIN=cluster\" und \"POD_NAMESPACE=default\" im " +#~ "Container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --env=\"DNS_DOMAIN=cluster\" " +#~ "--env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Starte eine replizierte Instanz von nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx --replicas=5\n" +#~ "\n" +#~ "\t\t# Testlauf. Zeige die zugehörigen API Objekte ohne sie zu erstellen.\n" +#~ "\t\tkubectl run nginx --image=nginx --dry-run\n" +#~ "\n" +#~ "\t\t# Starte eine einzelne Instanz von nginx, aber überlade die Spec des " +#~ "Deployments mit einer Teilmenge von JSON-Werten.\n" +#~ "\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": " +#~ "\"v1\", \"spec\": { ... } }'\n" +#~ "\n" +#~ "\t\t# Starte einen busybox Pod und lass ihn im Vordergrund laufen; starte " +#~ "ihn nicht neu, wenn er existiert.\n" +#~ "\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +#~ "\n" +#~ "\t\t# Starte einen nginx-Container mit dem Standardkommando, aber " +#~ "übergebe die Parameter (arg1 .. argN) an das Kommando.\n" +#~ "\t\tkubectl run nginx --image=nginx -- ... \n" +#~ "\n" +#~ "\t\t# Starte den nginx-Container mit einem anderen Kommando und " +#~ "Parametern.\n" +#~ "\t\tkubectl run nginx --image=nginx --command -- ... \n" +#~ "\n" +#~ "\t\t# Starte den perl-Container, um π auf 2000 Stellen zu berechnen und " +#~ "gib es aus.\n" +#~ "\t\tkubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Starte den cron-Job, um π auf 2000 Stellen zu berechnen und gib sie " +#~ "alle 5 Minuten aus.\n" +#~ "\t\tkubectl run pi --schedule=\"0/5 * * * ?\" --image=perl --" +#~ "restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update node 'foo' with a taint with key 'dedicated' and value " +#~ "'special-user' and effect 'NoSchedule'.\n" +#~ "\t\t# If a taint with that key and effect already exists, its value is " +#~ "replaced as specified.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +#~ "'NoSchedule' if one exists.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Aktualisiere Knoten 'foo' mit einem Taint mit dem Key 'dedicated', " +#~ "dem Value 'special-user' und dem Effect 'NoSchedule'.\n" +#~ "\t\t# Wenn ein Taint mit dem Key und Effect schon existiert, wird sein " +#~ "Value mit den gegebenen Werten ersetzt.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Entferne vom Knoten 'foo' den Taint mit dem Key 'dedicated' und dem " +#~ "Effect 'NoSchedule', wenn er existiert.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Entferne vom Knoten 'foo' alle Tains mit dem Key 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +#~ "overwriting any existing value.\n" +#~ "\t\tkubectl label --overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update all pods in the namespace\n" +#~ "\t\tkubectl label pods --all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ "\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' by removing a label named 'bar' if it exists.\n" +#~ "\t\t# Does not require the --overwrite flag.\n" +#~ "\t\tkubectl label pods foo bar-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Aktualisiere den Pod 'foo' mit dem Label 'unhealthy' und dem Value " +#~ "'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Aktualisiere den Pod 'foo' mit dem Label 'status' und dem Value " +#~ "'unhealthy' und überschreibe alle bisherigen Values.\n" +#~ "\t\tkubectl label --overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Aktualisiere alle Pods im Namespace\n" +#~ "\t\tkubectl label pods --all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Aktualisiere den Pod mit type und name aus \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Aktualisiere den Pod 'foo', wenn die Resource sich nicht von " +#~ "version 1 unterscheidet.\n" +#~ "\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +#~ "\n" +#~ "\t\t# Aktualisiere den Pod 'foo', indem das Label 'bar' gelöscht wird, " +#~ "wenn es existiert.\n" +#~ "\t\t# Benötigt kein --overwrite flag.\n" +#~ "\t\tkubectl label pods foo bar-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using new replication controller data in " +#~ "frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using JSON data passed into stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend-v1 to frontend-v2 by just changing the " +#~ "image, and switching the\n" +#~ "\t\t# name of the replication controller.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend by just changing the image, and keeping " +#~ "the old name.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Abort and reverse an existing rollout in progress (from frontend-v1 " +#~ "to frontend-v2).\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Aktualisiere die Pods in frontend-v1 mit den neuen Replication-" +#~ "Controller Daten in frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Aktualisiere die Pods in frontend-v1 mit den JSON-Daten von stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Aktualisiere die Pods von frontend-v1 auf frontend-v2, indem das " +#~ "Image geändert wird und\n" +#~ "\t\t# der Name des ReplicationControllers.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Aktualisiere die Pods in frontend, indem das Image geändert, aber " +#~ "der alte Name beibehalten wird.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Breche ein laufendes Rollout (von frontend-v1 zu frontend-v2) ab " +#~ "und mache es rückgängig.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" + +#~ msgid "" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by type/name in " +#~ "YAML.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by file in JSON\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Zeige die Annotation Last-Applied-Configuration mit type/name in " +#~ "YAML an.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# Zeige die Annotation Last-applied-configuration mit der Datei in " +#~ "JSON an\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" + +#~ msgid "" +#~ "\n" +#~ "\t\tApply a configuration to a resource by filename or stdin.\n" +#~ "\t\tThis resource will be created if it doesn't exist yet.\n" +#~ "\t\tTo use 'apply', always create the resource initially with either " +#~ "'apply' or 'create --save-config'.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do " +#~ "not use unless you are aware of what the current state is. See https://" +#~ "issues.k8s.io/34274." +#~ msgstr "" +#~ "\n" +#~ "\t\tWende eine Konfiguration auf eine Resource mit Dateinamen oder stdin " +#~ "an.\n" +#~ "\t\tDie Resource wird erstellt, wenn sie noch nicht existiert.\n" +#~ "\t\tUm 'apply' zu benutzen, muss die Resource initital mit 'apply' oder " +#~ "'create --save-config' erstellt werden.\n" +#~ "\n" +#~ "\t\tJSON- und YAML-Formate werden akzeptiert.\n" +#~ "\n" +#~ "\t\tAlpha Disclaimer: Die --prune Funktion ist noch nicht fertig. Benutze " +#~ "sie nicht, wenn der aktuelle Zustand nicht bekannt ist. Siehe https://" +#~ "issues.k8s.io/34274." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle eine ClusterRole." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRoleBinding for a particular ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle ein ClusterRoleBinding für eine bestimmte ClusterRole." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a RoleBinding for a particular Role or ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle ein RoleBinding für eine bestimmte ClusterRole." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a TLS secret from the given public/private key pair.\n" +#~ "\n" +#~ "\t\tThe public/private key pair must exist before hand. The public key " +#~ "certificate must be .PEM encoded and match the given private key." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle ein TLS-Secret vom gegebenen Public/Private-Schlüsselpaar.\n" +#~ "\n" +#~ "\t\tDas Public/Private-Schlüsselpaar muss vorab bestehen. Das Public-Key-" +#~ "Zertifikat muss im PEM-Format sein und zum gegebenen Private-Key passen." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a configmap based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single configmap may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a file, the key will default to " +#~ "the basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a directory, each file whose " +#~ "basename is a valid key in the directory will be\n" +#~ "\t\tpackaged into the configmap. Any directory entries except regular " +#~ "files are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle eine ConfigMap basierend auf einer Datei, einem Order oder " +#~ "einem gegebenen Wert.\n" +#~ "\n" +#~ "\t\tEine einzelne ConfigMap kann eins oder mehr Key/Value-Paare " +#~ "beinhalten.\n" +#~ "\n" +#~ "\t\tWenn man eine ConfigMap von einer Datei erstellt, wird der Key " +#~ "standardmäßig der Name der Datei, und der Wert wird\n" +#~ "\t\tstandardmäßig der Dateiinhalt. Wenn der Dateiname ein ungültiger Key " +#~ "ist, kann ein anderer Key angegeben werden.\n" +#~ "\n" +#~ "\t\tWenn man eine ConfigMap von einem Ordner erstellt, wird jede Datei, " +#~ "deren Name ein gültiger Key ist\n" +#~ "\t\tin die ConfigMap aufgenommen. Jegliche Einträge im Ordner, die keine " +#~ "regulären Dateien sind, werden ignoriert (z.B. SubDirectories, \n" +#~ "\t\tSymLinks, Devices, Pipes, usw)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a new secret for use with Docker registries.\n" +#~ "\n" +#~ "\t\tDockercfg secrets are used to authenticate against Docker " +#~ "registries.\n" +#~ "\n" +#~ "\t\tWhen using the Docker command line to push images, you can " +#~ "authenticate to a given registry by running\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +#~ "password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " That produces a ~/.dockercfg file that is used by subsequent 'docker " +#~ "push' and 'docker pull' commands to\n" +#~ "\t\tauthenticate to the registry. The email address is optional.\n" +#~ "\n" +#~ "\t\tWhen creating applications, you may have a Docker registry that " +#~ "requires authentication. In order for the\n" +#~ "\t\tnodes to pull images on your behalf, they have to have the " +#~ "credentials. You can provide this information\n" +#~ "\t\tby creating a dockercfg secret and attaching it to your service " +#~ "account." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle ein Secret für die Benutzung mit Docker-Registries.\n" +#~ "\n" +#~ "\t\tDockercfg Secrets werden für die Authentifizierung bei Docker-" +#~ "Registries benutzt.\n" +#~ "\n" +#~ "\t\tWenn die Docker-command -line zum pushen von Images benutzt wird, " +#~ "kann man sich bei einer gegebenen Registry authentifizieren mit\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +#~ "password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " Dies produziert eine ~/.dockercfg Datei, die für folgende 'docker " +#~ "push' und 'docker pull' Befehle genutzt wird,\n" +#~ "\t\tum sich an der Registry zu authentifizieren. Die E-Mail-Adresse ist " +#~ "optional.\n" +#~ "\n" +#~ "\t\tBei der Erstellung von Applikationen, kann eine Docker-Registry eine " +#~ "Authentifizierung verlangen. Damit\n" +#~ "\t\tdeine Knoten in deinem Namen Images herunterladen können, benötigen " +#~ "sie die Credentials. Man kann diese Information bereitstellen\n" +#~ "\t\tindem man ein dockercfg secret erstellt und zu seinem ServiceAccount " +#~ "hinzufügt." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a pod disruption budget with the specified name, selector, and " +#~ "desired minimum available pods" +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle ein Pod-Disruption-Budget mit dem gegebenen name, selector " +#~ "und der gewünschten Mindestanzahl verfügbarer Pods" + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle eine Resource mit Dateinamen oder stdin.\n" +#~ "\n" +#~ "\t\tJSON- und YAML-Formate werden akzeptiert." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resourcequota with the specified name, hard limits and " +#~ "optional scopes" +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle eine ResourceQuota mit dem gegebenen name, hard limits und " +#~ "optional scopes" + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a secret based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single secret may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a file, the key will default to the " +#~ "basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a directory, each file whose basename " +#~ "is a valid key in the directory will be\n" +#~ "\t\tpackaged into the secret. Any directory entries except regular files " +#~ "are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle ein Secret basierend auf einer Datei, einem Ordner oder " +#~ "einem gegebenen Wert.\n" +#~ "\n" +#~ "\t\tEin einzelnes Secret kann eins oder mehr Key/Value-Paare beinhalten.\n" +#~ "\n" +#~ "\t\tWenn man ein Secret von einer Datei erstellt, wird der Key " +#~ "standardmäßig der Name der Datei, und der Wert wird\n" +#~ "\t\tstandardmäßig der Dateiinhalt. Wenn der Dateiname ein ungültiger Key " +#~ "ist, kann ein anderer Key angegeben werden.\n" +#~ "\n" +#~ "\t\tWenn man ein Secret von einem Ordner erstellt, wird jede Datei, deren " +#~ "Name ein gültiger Key ist\n" +#~ "\t\tin das Secret aufgenommen. Jegliche Einträge im Ordner, die keine " +#~ "regulären Dateien sind, werden ignoriert (z.B. SubDirectories, \n" +#~ "\t\tSymLinks, Devices, Pipes, usw)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate and run a particular image, possibly replicated.\n" +#~ "\n" +#~ "\t\tCreates a deployment or job to manage the created container(s)." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstelle und starte ein bestimmtes Image, möglicherweise repliziert.\n" +#~ "\n" +#~ "\t\tErstellt ein Deployment oder Job, um den/die erstellten Container zu " +#~ "verwalten." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreates an autoscaler that automatically chooses and sets the number " +#~ "of pods that run in a kubernetes cluster.\n" +#~ "\n" +#~ "\t\tLooks up a Deployment, ReplicaSet, or ReplicationController by name " +#~ "and creates an autoscaler that uses the given resource as a reference.\n" +#~ "\t\tAn autoscaler can automatically increase or decrease number of pods " +#~ "deployed within the system as needed." +#~ msgstr "" +#~ "\n" +#~ "\t\tErstellt einen AutoScaler der die Anzahl der Pods, die im Kubernetes-" +#~ "Cluster laufen, automatisch wählt und anpasst.\n" +#~ "\n" +#~ "\t\tSucht ein Deployment, ReplicaSet oder ReplicationController mit Namen " +#~ "name und erstellt einen AutoScaler, der die Resource als Referenz nimmt.\n" +#~ "\t\tEin AutoScaler kann die Anzahl der im System deployten Pods nach " +#~ "Bedarf erhöhen oder verringern." + +#~ msgid "" +#~ "\n" +#~ "\t\tDelete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. Only one type of the arguments " +#~ "may be specified: filenames,\n" +#~ "\t\tresources and names, or resources and label selector.\n" +#~ "\n" +#~ "\t\tSome resources, such as pods, support graceful deletion. These " +#~ "resources define a default period\n" +#~ "\t\tbefore they are forcibly terminated (the grace period) but you may " +#~ "override that value with\n" +#~ "\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +#~ "Because these resources often\n" +#~ "\t\trepresent entities in the cluster, deletion may not be acknowledged " +#~ "immediately. If the node\n" +#~ "\t\thosting a pod is down or cannot reach the API server, termination may " +#~ "take significantly longer\n" +#~ "\t\tthan the grace period. To force delete a resource,\tyou must pass a " +#~ "grace\tperiod of 0 and specify\n" +#~ "\t\tthe --force flag.\n" +#~ "\n" +#~ "\t\tIMPORTANT: Force deleting pods does not wait for confirmation that " +#~ "the pod's processes have been\n" +#~ "\t\tterminated, which can leave those processes running until the node " +#~ "detects the deletion and\n" +#~ "\t\tcompletes graceful deletion. If your processes use shared storage or " +#~ "talk to a remote API and\n" +#~ "\t\tdepend on the name of the pod to identify themselves, force deleting " +#~ "those pods may result in\n" +#~ "\t\tmultiple processes running on different machines using the same " +#~ "identification which may lead\n" +#~ "\t\tto data corruption or inconsistency. Only force delete pods when you " +#~ "are sure the pod is\n" +#~ "\t\tterminated, or if your application can tolerate multiple copies of " +#~ "the same pod running at once.\n" +#~ "\t\tAlso, if you force delete pods the scheduler may place new pods on " +#~ "those nodes before the node\n" +#~ "\t\thas released those resources and causing those pods to be evicted " +#~ "immediately.\n" +#~ "\n" +#~ "\t\tNote that the delete command does NOT do resource version checks, so " +#~ "if someone\n" +#~ "\t\tsubmits an update to a resource right when you submit a delete, their " +#~ "update\n" +#~ "\t\twill be lost along with the rest of the resource." +#~ msgstr "" +#~ "\n" +#~ "\t\tLöscht die Resourcen mit Dateinamen, stdin, resources- und names- " +#~ "oder mit resources- und label-Selektor.\n" +#~ "\n" +#~ "\t\tJSON- und YAML-Formate werden akzeptiert. Nur einer der Parameter " +#~ "darf verwendet werden: Dateiname,\n" +#~ "\t\tresources- und names-, oder resources- und label-Selektor.\n" +#~ "\n" +#~ "\t\tManche Resourcen, zum Beispiel Pods, unterstützen graziöses Löschen. " +#~ "Sie definieren einen Standardzeitraum\n" +#~ "\t\tbevor das Löschen erzwungen wird (grace-period), aber dieser Wert " +#~ "kann überschrieben werden mit\n" +#~ "\t\tder --grace-period Option, oder mit --now, das die grace-period auf 1 " +#~ "setzt. Da diese Resourcen\n" +#~ "\t\thäufig Einheiten im Cluster sind, kann das Löschen nicht immer direkt " +#~ "bestätigt werden. Wenn der Knoten\n" +#~ "\t\tauf dem der Pod läuft nicht verfügbar ist, oder den API Server nicht " +#~ "erreichen kann, kann das Löschen bedeutend länger dauern\n" +#~ "\t\tals die grace-period. Um das Löschen zu erzwingen, muss eine grace-" +#~ "period von 0 übergeben werden\n" +#~ "\t\tund die --force Option gesetzt sein.\n" +#~ "\n" +#~ "\t\tWICHTIG: Ein erzwungenes Löschen wartet nicht auf die Bestätigung, " +#~ "dass der Prozess\n" +#~ "\t\tbeendet wurde, was den Prozess am Leben erhalten kann, bis der Knoten " +#~ "die Löschung erkennt\n" +#~ "\t\tund das graziöse Löschen beendet. Wenn Prozesse Shared-Storage oder " +#~ "eine Remote-API verwenden und\n" +#~ "\t\tden Namen des Pods brauchen, um sich selbst zu identifizieren, kann " +#~ "das erzwungene Löschen dazu führen, dass\n" +#~ "\t\tmehrere Prozesse auf der gleichen Maschine die gleiche Identität " +#~ "verwenden, was zu\n" +#~ "\t\tDatenkorruption oder Inkonsistenz führen kann. Erzwinge nur ein " +#~ "Löschen, wenn sichergestellt ist, dass der Pod\n" +#~ "\t\tgelöscht ist, oder wenn die Anwendung mehrere gleichzeitig laufende " +#~ "Kopien verarbeiten kann.\n" +#~ "\t\tAußerdem kann es passieren, dass der Scheduler neue Pods auf dem " +#~ "Knoten plaziert, bevor der Knoten\n" +#~ "\t\tdie Resourcen freigegeben hat, sodass diese Pods direkt entfernt " +#~ "werden.\n" +#~ "\n" +#~ "\t\tBerücksichtige außerdem, dass der Delete-Befehl KEINE versionen " +#~ "prüft, sodass, wenn jemand\n" +#~ "\t\tein Update einer Resource gleichzeitig mit Deinem delete anstößt, " +#~ "dessen Update\n" +#~ "\t\tmit dem Rest der Resource entfernt wird." + +#~ msgid "" +#~ "\n" +#~ "\t\tDeprecated: Gracefully shut down a resource by name or filename.\n" +#~ "\n" +#~ "\t\tThe stop command is deprecated, all its functionalities are covered " +#~ "by delete command.\n" +#~ "\t\tSee 'kubectl delete --help' for more details.\n" +#~ "\n" +#~ "\t\tAttempts to shut down and delete a resource that supports graceful " +#~ "termination.\n" +#~ "\t\tIf the resource is scalable it will be scaled to 0 before deletion." +#~ msgstr "" +#~ "\n" +#~ "\t\tVeraltet: Fahre eine Resource mit Namen oder Dateinamen graziös " +#~ "heruter.\n" +#~ "\n" +#~ "\t\tDer Stop-Befehl ist veraltet und alle Funktioneren werden mit dem " +#~ "Delete-Befehl abgedeckt.\n" +#~ "\t\tSiehe 'kubectl delete --help' für mehr Details.\n" +#~ "\n" +#~ "\t\tVersucht eine Resource, die graziöses Löschen unterstützt, " +#~ "herunterzufahren und zu löschen.\n" +#~ "\t\tWenn die Resource skaliert werden kann, wird sie vor dem Löschen auf " +#~ "0 skaliert." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of nodes.\n" +#~ "\n" +#~ "\t\tThe top-node command allows you to see the resource consumption of " +#~ "nodes." +#~ msgstr "" +#~ "\n" +#~ "\t\tZeigt die Resourcennutzung (CPU/Memory/Storage) von Knoten.\n" +#~ "\n" +#~ "\t\tDer top-node-Befehl erlaubt es, die Resourcennutzung von Knoten zu " +#~ "betrachten." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of pods.\n" +#~ "\n" +#~ "\t\tThe 'top pod' command allows you to see the resource consumption of " +#~ "pods.\n" +#~ "\n" +#~ "\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +#~ "minutes\n" +#~ "\t\tsince pod creation." +#~ msgstr "" +#~ "\n" +#~ "\t\tZeigt die Resourcennutzung (CPU/Memory/Storage) von Pods.\n" +#~ "\n" +#~ "\t\tDer 'top pod'-Befehl erlaubt es, die Resourcennutzung von Pods zu " +#~ "betrachten.\n" +#~ "\n" +#~ "\t\tAufgrund der Metrik-Pipeline-Verzögerung, können sie für ein paar " +#~ "Minuten nicht verfügbar sein,\n" +#~ "\t\tnach der Pod-Erstellung." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage.\n" +#~ "\n" +#~ "\t\tThe top command allows you to see the resource consumption for nodes " +#~ "or pods.\n" +#~ "\n" +#~ "\t\tThis command requires Heapster to be correctly configured and working " +#~ "on the server. " +#~ msgstr "" +#~ "\n" +#~ "\t\tZeige Resourcennutzung (CPU/Memory/Storage).\n" +#~ "\n" +#~ "\t\tDer top-Befehl erlaubt es, die Resourcennutzung von Knoten oder Pods " +#~ "zu betrachten.\n" +#~ "\n" +#~ "\t\tDieser Befehl benötigt eine korrekt konfigurierte und funktionierende " +#~ "Heapster-Installation auf dem Server. " + +#~ msgid "" +#~ "\n" +#~ "\t\tDrain node in preparation for maintenance.\n" +#~ "\n" +#~ "\t\tThe given node will be marked unschedulable to prevent new pods from " +#~ "arriving.\n" +#~ "\t\t'drain' evicts the pods if the APIServer supports eviction\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Otherwise, it will " +#~ "use normal DELETE\n" +#~ "\t\tto delete the pods.\n" +#~ "\t\tThe 'drain' evicts or deletes all pods except mirror pods (which " +#~ "cannot be deleted through\n" +#~ "\t\tthe API server). If there are DaemonSet-managed pods, drain will not " +#~ "proceed\n" +#~ "\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +#~ "\t\tDaemonSet-managed pods, because those pods would be immediately " +#~ "replaced by the\n" +#~ "\t\tDaemonSet controller, which ignores unschedulable markings. If there " +#~ "are any\n" +#~ "\t\tpods that are neither mirror pods nor managed by " +#~ "ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet or Job, then drain will not delete " +#~ "any pods unless you\n" +#~ "\t\tuse --force. --force will also allow deletion to proceed if the " +#~ "managing resource of one\n" +#~ "\t\tor more pods is missing.\n" +#~ "\n" +#~ "\t\t'drain' waits for graceful termination. You should not operate on the " +#~ "machine until\n" +#~ "\t\tthe command completes.\n" +#~ "\n" +#~ "\t\tWhen you are ready to put the node back into service, use kubectl " +#~ "uncordon, which\n" +#~ "\t\twill make the node schedulable again.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\tLeere Knoten, um eine Wartung vorzubereiten.\n" +#~ "\n" +#~ "\t\tDer gegebene Knoten wird als unschedulable markiert, um die Zuordnung " +#~ "von neuen Pods zu verhindern.\n" +#~ "\t\t'drain' entfernt den Pod, falls der API-Server die Entfernung " +#~ "unterstützt\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Wenn nicht, wird ein " +#~ "normales DELETE verwendet,\n" +#~ "\t\tum die Pods zu löschen.\n" +#~ "\t\t'drain' entfernt oder löscht alle Pods mit der Ausnahme von Mirror-" +#~ "Pods (welche vom API Server nicht gelöscht werden können)\n" +#~ "\t\tWenn DaemonSet-verwaltete Pods existieren, wird 'drain' nicht " +#~ "fortgesetzt\n" +#~ "\t\tohne die --ignore-daemonsets Option, und es wird in keinem Fall\n" +#~ "\t\tDaemonSet-verwaltete Pods löschen, weil diese Pods direkt ersetzt " +#~ "würden durch den\n" +#~ "\t\tDaemonSet-Controller, der unschedulable Markierungen ignoriert. Wenn " +#~ "es irgendwelche\n" +#~ "\t\tPods gibt, die weder Mirror-Pods sind, noch von einem " +#~ "ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet oder Job verwaltet werden, wird " +#~ "drain keine Pods löschen, außer die\n" +#~ "\t\t--force Option ist gesetzt. --force lässt das Löschen selbst zu, " +#~ "wenn die verwaltende Resource von einem\n" +#~ "\t\toder mehreren Pods fehlt.\n" +#~ "\n" +#~ "\t\t'drain' wartet auf eine graziöse Löschung. Man sollte auf der " +#~ "Maschine nichts tun, während\n" +#~ "\t\tder Befehl läuft.\n" +#~ "\n" +#~ "\t\tWenn der Knoten wieder bereit ist die Arbeit aufzunehmen, benutze " +#~ "kubectl uncordon,\n" +#~ "\t\twas den Knoten als schedulable markiert.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tEdit a resource from the default editor.\n" +#~ "\n" +#~ "\t\tThe edit command allows you to directly edit any API resource you can " +#~ "retrieve via the\n" +#~ "\t\tcommand line tools. It will open the editor defined by your " +#~ "KUBE_EDITOR, or EDITOR\n" +#~ "\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' " +#~ "for Windows.\n" +#~ "\t\tYou can edit multiple objects, although changes are applied one at a " +#~ "time. The command\n" +#~ "\t\taccepts filenames as well as command line arguments, although the " +#~ "files you point to must\n" +#~ "\t\tbe previously saved versions of resources.\n" +#~ "\n" +#~ "\t\tEditing is done with the API version used to fetch the resource.\n" +#~ "\t\tTo edit using a specific API version, fully-qualify the resource, " +#~ "version, and group.\n" +#~ "\n" +#~ "\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +#~ "\n" +#~ "\t\tThe flag --windows-line-endings can be used to force Windows line " +#~ "endings,\n" +#~ "\t\totherwise the default for your operating system will be used.\n" +#~ "\n" +#~ "\t\tIn the event an error occurs while updating, a temporary file will be " +#~ "created on disk\n" +#~ "\t\tthat contains your unapplied changes. The most common error when " +#~ "updating a resource\n" +#~ "\t\tis another editor changing the resource on the server. When this " +#~ "occurs, you will have\n" +#~ "\t\tto apply your changes to the newer version of the resource, or update " +#~ "your temporary\n" +#~ "\t\tsaved copy to include the latest resource version." +#~ msgstr "" +#~ "\n" +#~ "\t\tBearbeite eine Resource mit dem Standardeditor.\n" +#~ "\n" +#~ "\t\tDer edit-Befehl erlaubt es jede API Resource direkt zu bearbeiten, " +#~ "wenn sie mit den\n" +#~ "\t\tCommand-Line-Tools erreichbar ist. Er öffnet den Editor, der in der " +#~ "KUBE_EDITOR oder EDITOR\n" +#~ "\t\tUmgebunsvariable festgelegt ist, oder 'vi' auf Linux und 'notepad' " +#~ "auf Windows.\n" +#~ "\t\tEs ist möglich mehrere Objekte zu bearbeiten, aber die Änderungen " +#~ "werden nacheinander angewendet. Der Befehl\n" +#~ "\t\takzeptiert Dateinamen und Command-Line-Parameter, aber die " +#~ "verwendeten Dateien müssen\n" +#~ "\t\tvorab gespeicherte Versionen von Resourcen sein.\n" +#~ "\n" +#~ "\t\tDie Bearbeitung verwendet die API Version, die genutzt wurde, um die " +#~ "Resource zu lesen.\n" +#~ "\t\tUm eine spezifische API Version zu verwenden, muss die vollständige " +#~ "Resource, Version und Group angegeben werden.\n" +#~ "\n" +#~ "\t\tDas Standardformat ist YAML. Um mit JSON zu arbeiten, setze \"-o json" +#~ "\".\n" +#~ "\n" +#~ "\t\tDie Option --windows-line-endings kann benutzt werden, um Windows " +#~ "Zeilen-umbrüche zu verwenden,\n" +#~ "\t\tansonsten wird der Standard des Betriebssystems verwendet.\n" +#~ "\n" +#~ "\t\tFalls beim Update ein Fehler auftritt, wird eine temporäre Datei auf " +#~ "der Festplatte angelegt,\n" +#~ "\t\tdie die nicht verarbeiteten Änderungen enthält. Der häufigste Fehler " +#~ "beim Bearbeiten einer Resource\n" +#~ "\t\tist ein anderer Editor, der die Resource auf dem Server ändert. Wenn " +#~ "das auftritt, muss man\n" +#~ "\t\tseine Änderungen auf die neue Version anwenden oder seine temporäre\n" +#~ "\t\tgespeicherte Kopie mit der neuesten Resourcenversion aktualisieren." + +#~ msgid "" +#~ "\n" +#~ "\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +#~ "\t\tThe shell code must be evaluated to provide interactive\n" +#~ "\t\tcompletion of kubectl commands. This can be done by sourcing it " +#~ "from\n" +#~ "\t\tthe .bash_profile.\n" +#~ "\n" +#~ "\t\tNote: this requires the bash-completion framework, which is not " +#~ "installed\n" +#~ "\t\tby default on Mac. This can be installed by using homebrew:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tOnce installed, bash_completion must be evaluated. This can be done " +#~ "by adding the\n" +#~ "\t\tfollowing line to the .bash_profile\n" +#~ "\n" +#~ "\t\t $ source $(brew --prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tNote for zsh users: [1] zsh completions are only supported in " +#~ "versions of zsh >= 5.2" +#~ msgstr "" +#~ "\n" +#~ "\t\tGibt den Shell-Completion-Code für die angegebene Shell aus (bash " +#~ "oder zsh).\n" +#~ "\t\tDer Shell-Code muss für eine interaktive Vervollständigung von " +#~ "kubectl \n" +#~ "\t\tausgewertet werden. Das ist möglich, indem man\n" +#~ "\t\tdie .bash_profile Datei sourcet.\n" +#~ "\n" +#~ "\t\tHinweis: Dies setzt das Bash-Completion-Framework voraus, das auf dem " +#~ "Mac nicht standardmäßig installiert ist. \n" +#~ "\t\tEs kann mit homebrew installiert werden:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tSobald es installiert ist, muss bash_completion ausgewertet werden. " +#~ "Dies wird erreicht, indem man\n" +#~ "\t\tdie folgende Zeile zur .bash_profile-Datei hinzufügt\n" +#~ "\n" +#~ "\t\t $ source $(brew --prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tHinweis für zsh Nutzer: [1] zsh completions werden nur in Versionen " +#~ "von zsh >= 5.2 unterstützt" + +#~ msgid "" +#~ "\n" +#~ "\t\tPerform a rolling update of the given ReplicationController.\n" +#~ "\n" +#~ "\t\tReplaces the specified replication controller with a new replication " +#~ "controller by updating one pod at a time to use the\n" +#~ "\t\tnew PodTemplate. The new-controller.json must specify the same " +#~ "namespace as the\n" +#~ "\t\texisting replication controller and overwrite at least one (common) " +#~ "label in its replicaSelector.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\tFühre ein Rolling-Update des gegebenen ReplicationControllers aus.\n" +#~ "\n" +#~ "\t\tErsetzt den gegebenen ReplicationController mit einem neuen " +#~ "Replication-Controller, indem die neue PodTampleta Pod für Pod\n" +#~ "\t\tangewendet wird. Die new-controller.json muss den gleichen Namespace " +#~ "wie\n" +#~ "\t\tder aktuelle ReplicationController besitzen und mindestens ein " +#~ "gemeinsames Label im ReplicaSelector überschreiben.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tReplace a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. If replacing an existing " +#~ "resource, the\n" +#~ "\t\tcomplete resource spec must be provided. This can be obtained by\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." +#~ msgstr "" +#~ "\n" +#~ "\t\tErsetze eine Resource mit Dateinamen oder stdin.\n" +#~ "\n" +#~ "\t\tJSON- and YAML-Formate werden akzeptiert. Wenn eine existierende " +#~ "Resource ersetzt wird,\n" +#~ "\t\tmuss die vollständige spSpecec mitgegeben werden. Diese kann hiermit " +#~ "ausgelesen werden\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" +#~ "\n" +#~ "\t\tBitte konsultiere https://htmlpreview.github.io/?https://github.com/" +#~ "kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html um " +#~ "zu erfahren, ob ein Feld verändert werden darf." + +#~ msgid "" +#~ "\n" +#~ "\t\tSet a new size for a Deployment, ReplicaSet, Replication Controller, " +#~ "or Job.\n" +#~ "\n" +#~ "\t\tScale also allows users to specify one or more preconditions for the " +#~ "scale action.\n" +#~ "\n" +#~ "\t\tIf --current-replicas or --resource-version is specified, it is " +#~ "validated before the\n" +#~ "\t\tscale is attempted, and it is guaranteed that the precondition holds " +#~ "true when the\n" +#~ "\t\tscale is sent to the server." +#~ msgstr "" +#~ "\n" +#~ "\t\tSetze eine neue Größe für ein Deployment, ReplicaSet, Replication-" +#~ "Contoller oder Job.\n" +#~ "\n" +#~ "\t\tScale erlaubt es Nutzern eine oder mehr Voraussetzungen für die " +#~ "Aktion festzulegen.\n" +#~ "\n" +#~ "\t\tWenn --current-replicas oder --resource-version gegeben ist, wird es " +#~ "validiert, bevor\n" +#~ "\t\tscale versucht wird, und es wird garantiert, dass die Voraussetzungen " +#~ "erfüllt sind, wenn\n" +#~ "\t\tscale zum Server geschickt wird." + +#~ msgid "" +#~ "\n" +#~ "\t\tTo proxy all of the kubernetes api and nothing else, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/\n" +#~ "\n" +#~ "\t\tTo proxy only part of the kubernetes api and also some static files:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-" +#~ "prefix=/api/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/api/v1/pods'.\n" +#~ "\n" +#~ "\t\tTo proxy the entire kubernetes api at a different root, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/custom/api/v1/pods'" +#~ msgstr "" +#~ "\n" +#~ "\t\tProxy alle Teile der Kubernetes-API und sonst nichts:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/\n" +#~ "\n" +#~ "\t\tProxy nur bestimmte Teile der Kubernetes-API und einige statische " +#~ "Dateien:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-" +#~ "prefix=/api/\n" +#~ "\n" +#~ "\t\tDer Befehl oben lässt dich 'curl localhost:8001/api/v1/pods' " +#~ "aufrufen.\n" +#~ "\n" +#~ "\t\tProxy alle Teile der Kubernetes-API auf einem anderen root:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tDer Befehl oben lässt dich 'curl localhost:8001/custom/api/v1/pods' " +#~ "aufrufen" + +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate field(s) of a resource using strategic merge patch\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." +#~ msgstr "" +#~ "\n" +#~ "\t\tAktualisiere Felder einer Resource mit einem Strategic-Merge-Patch\n" +#~ "\n" +#~ "\t\tJSON- und YAML-Formate werden akzeptiert.\n" +#~ "\n" +#~ "\t\tBitte konsultiere https://htmlpreview.github.io/?https://github.com/" +#~ "kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html um " +#~ "zu erfahren, ob ein Feld mutable ist." + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new TLS secret named tls-secret with the given key pair:\n" +#~ "\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --" +#~ "key=path/to/tls.key" +#~ msgstr "" +#~ "\n" +#~ "\t # Erstelle ein neues TLS Secret tl-secret mit dem gegebenen " +#~ "Schlüsselpaar:\n" +#~ "\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --" +#~ "key=path/to/tls.key" + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new secret named my-secret with keys for each file in " +#~ "folder bar\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with specified keys instead of " +#~ "names on disk\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with key1=supersecret and " +#~ "key2=topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" +#~ msgstr "" +#~ "\n" +#~ "\t # Erstelle ein neues Secret my-secret mit einem Key für jede Datei im " +#~ "Ordner bar\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Erstelle ein neues Secret my-secret mit den gegebenen Keys statt " +#~ "der Namen auf der Festplatte\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Erstelle ein neues Scret my-secret mit key1=supersecret und " +#~ "key2=topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" + +#~ msgid "" +#~ "\n" +#~ "\t# Create a new ExternalName service named my-ns \n" +#~ "\tkubectl create service externalname my-ns --external-name bar.com" +#~ msgstr "" +#~ "\n" +#~ "\t# Erstelle einen neuen ExternalName-Service my-ns \n" +#~ "\tkubectl create service externalname my-ns --external-name bar.com" + +#~ msgid "" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs (in headless mode)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" +#~ msgstr "" +#~ "\n" +#~ " # Erstelle einen neuen ClusterIP-Service my-cs\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # Erstelle einen neuen ClusterIP-Service my-cs (im headless-Modus)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" + +#~ msgid "" +#~ "\n" +#~ " # Create a new deployment named my-dep that runs the busybox image.\n" +#~ " kubectl create deployment my-dep --image=busybox" +#~ msgstr "" +#~ "\n" +#~ " # Erstelle ein neues Deployment my-dep, dass das busybox-Image " +#~ "nutzt.\n" +#~ " kubectl create deployment my-dep --image=busybox" + +#~ msgid "" +#~ "\n" +#~ " # Create a new nodeport service named my-ns\n" +#~ " kubectl create service nodeport my-ns --tcp=5678:8080" +#~ msgstr "" +#~ "\n" +#~ " # Erstelle einen neuen NodePort-Service my-ns\n" +#~ " kubectl create service nodeport my-ns --tcp=5678:8080" + +#~ msgid "" +#~ "\n" +#~ " Create a clusterIP service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Erstelle einen ClusterIP-Service mit dem gegebenen Namen." + +#~ msgid "" +#~ "\n" +#~ " Create a deployment with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Erstelle ein Deployment mit dem gegebenen Namen." + +#~ msgid "" +#~ "\n" +#~ " Create a nodeport service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Erstelle einen NodePort-Service mit dem gegebenen Namen." + +#~ msgid "" +#~ "\n" +#~ " Display addresses of the master and services with label kubernetes.io/" +#~ "cluster-service=true\n" +#~ " To further debug and diagnose cluster problems, use 'kubectl cluster-" +#~ "info dump'." +#~ msgstr "" +#~ "\n" +#~ " Zeigt Adressen des Master und von Services mit Label kubernetes.io/" +#~ "cluster-service=true\n" +#~ " Für das weitere Debugging und die Diagnose von Clusterproblemen nutze " +#~ "'kubectl cluster-info dump'." + +#~ msgid "A schedule in the Cron format the job should be run with." +#~ msgstr "Ein Schedule im Cron Format, dass der Job nutzen soll." + +#~ msgid "Apply a configuration to a resource by filename or stdin" +#~ msgstr "" +#~ "Wende eine Konfiguration auf eine Resource über den Dateinamen oder stdin " +#~ "an" + +#~ msgid "Auto-scale a Deployment, ReplicaSet, or ReplicationController" +#~ msgstr "Auto-skaliere ein Deployment, ReplicaSet oder ReplicationController" + +#~ msgid "" +#~ "Container name which will have its image upgraded. Only relevant when --" +#~ "image is specified, ignored otherwise. Required when using --image on a " +#~ "multi-container pod" +#~ msgstr "" +#~ "Name des Containers dessen Image aktualisiert wird. Nur relevant, wenn --" +#~ "image angegeben ist, sonst ignoriert. Verpflichtend, wenn --image auf " +#~ "einem Multi-Container-Pod verwendet wird" + +#~ msgid "Create a ClusterRoleBinding for a particular ClusterRole" +#~ msgstr "Erstelle ein ClusterRoleBinding für eine bestimmte ClusterRole" + +#~ msgid "Create a LoadBalancer service." +#~ msgstr "Erstelle einen LoadBalancer-Service." + +#~ msgid "Create a NodePort service." +#~ msgstr "Erstelle einen NodePort-Service." + +#~ msgid "Create a RoleBinding for a particular Role or ClusterRole" +#~ msgstr "Erstelle ein RoleBinding für eine bestimmte Role oder ClusterRole" + +#~ msgid "Create a clusterIP service." +#~ msgstr "Erstelle einen ClusterIP-Service" + +#~ msgid "Create a configmap from a local file, directory or literal value" +#~ msgstr "" +#~ "Erstelle eine ConfigMap von einer Datei, einem Ordner oder einem festen " +#~ "Wert" + +#~ msgid "Create a deployment with the specified name." +#~ msgstr "Erstelle ein Deployment mit dem gegebenen Namen." + +#~ msgid "Create a pod disruption budget with the specified name." +#~ msgstr "Erstelle ein Pod-Disruption-Budget mit dem gegebenen Namen." + +#~ msgid "Create a quota with the specified name." +#~ msgstr "Erstelle eine Quota mit dem gegebenen Namen." + +#~ msgid "Create a resource by filename or stdin" +#~ msgstr "Erstelle eine Resource von einer Datei oder stdin" + +#~ msgid "Create a secret from a local file, directory or literal value" +#~ msgstr "" +#~ "Erstelle ein Secret von einer lokalen Datei, einem Ordner oder einem " +#~ "festen Wert" + +#~ msgid "Create a service using specified subcommand." +#~ msgstr "Erstelle einen Servuce mit dem angegebenen Sub-Befehl" + +#~ msgid "Create an ExternalName service." +#~ msgstr "Erstelle einen ExternalName-Service." + +#~ msgid "" +#~ "Delete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector" +#~ msgstr "" +#~ "Lösche Resourcen von einer Datei, stdin, resources- und names- oder mit " +#~ "resources- und label-Selektor" + +#~ msgid "Deprecated: Gracefully shut down a resource by name or filename" +#~ msgstr "" +#~ "Veraltet: Graziöses herunterfahren einer Resource über den Namen oder " +#~ "Dateinamen" + +#~ msgid "Display Resource (CPU/Memory) usage of nodes" +#~ msgstr "Zeige Resourcennutzung (CPU/Memory) von Knoten" + +#~ msgid "Display Resource (CPU/Memory) usage of pods" +#~ msgstr "Zeige Resourcennutzung (CPU/Memory) von Pods" + +#~ msgid "Display Resource (CPU/Memory) usage." +#~ msgstr "Zeige Resourcennutzung (CPU/Memory)." + +#~ msgid "Display cluster info" +#~ msgstr "Zeige Cluster-Info" + +#~ msgid "Displays the current-context" +#~ msgstr "Zeige den aktuellen Kontext" + +#~ msgid "Documentation of resources" +#~ msgstr "Dokumentation einer Resource" + +#~ msgid "Dump lots of relevant info for debugging and diagnosis" +#~ msgstr "Zeige viele relevante Informationen für Debugging und Diagnose" + +#~ msgid "" +#~ "Explicit policy for when to pull container images. Required when --image " +#~ "is same as existing image, ignored otherwise." +#~ msgstr "" +#~ "Explizite Vorgabe, wann Container-Images gepullt werden. Verpflichtend, " +#~ "wenn --image ist gleich dem aktuellen Image ist - sonst ignoriert." + +#~ msgid "" +#~ "IP to assign to the Load Balancer. If empty, an ephemeral IP will be " +#~ "created and used (cloud-provider specific)." +#~ msgstr "" +#~ "IP, die dem Load-Balancer zugewiesen wird. Falls leer, wird eine " +#~ "temporäre IP erstellt und verwendet (Cloud-Provider spezifisch)" + +#~ msgid "Manage a deployment rollout" +#~ msgstr "Verwalte ein Deployment-Rollout" + +#~ msgid "Perform a rolling update of the given ReplicationController" +#~ msgstr "Führe ein Rolling-Update des gegebenen ReplicationControllers aus" + +#~ msgid "Replace a resource by filename or stdin" +#~ msgstr "Ersetze eine Resource von einem Dateinamen oder stdin" + +#~ msgid "" +#~ "Set a new size for a Deployment, ReplicaSet, Replication Controller, or " +#~ "Job" +#~ msgstr "" +#~ "Setze eine neue Größe für ein Deployment, ReplicaSet, " +#~ "ReplicationController oder Job" + +#~ msgid "" +#~ "Set the last-applied-configuration annotation on a live object to match " +#~ "the contents of a file." +#~ msgstr "" +#~ "Setze die Annotation Last-Applied-Configuration auf einem Live-Objekt auf " +#~ "den Inhalt einer Datei." + +#~ msgid "Sets a cluster entry in kubeconfig" +#~ msgstr "Setze einen Cluster-Eintrag in der kubeconfig" + +#~ msgid "Sets a context entry in kubeconfig" +#~ msgstr "Setze einen Kontext-Eintrag in der kubeconfig" + +#~ msgid "Sets a user entry in kubeconfig" +#~ msgstr "Setze einen User-Eintrag in der kubeconfig" + +#~ msgid "Sets an individual value in a kubeconfig file" +#~ msgstr "Setze einen einzelnen Value in einer kubeconfig-Datei" + +#~ msgid "Sets the current-context in a kubeconfig file" +#~ msgstr "Setze den aktuellen Kontext in einer kubeconfig-Datei" + +#~ msgid "" +#~ "Take a replication controller, service, deployment or pod and expose it " +#~ "as a new Kubernetes Service" +#~ msgstr "" +#~ "Nehme einen Replication Controller, Service, Deployment oder Pod und " +#~ "biete ihn als neuen Kubernetes-Service an" + +#~ msgid "" +#~ "The name of the API generator to use, see http://kubernetes.io/docs/user-" +#~ "guide/kubectl-conventions/#generators for a list." +#~ msgstr "" +#~ "Der Name des zu verwendenden API-Generators. Siehe http://kubernetes.io/" +#~ "docs/user-guide/kubectl-conventions/#generators für eine Übersicht." + +#~ msgid "" +#~ "The name of the API generator to use. Currently there is only 1 generator." +#~ msgstr "" +#~ "Der Name des zu verwendenden API-Generators. Zur Zeit gibt es nur einen " +#~ "Generator." + +#~ msgid "" +#~ "The name of the generator to use for creating a service. Only used if --" +#~ "expose is true" +#~ msgstr "" +#~ "Der Name des zu verwendenden Generators, um einen Service zu erstellen. " +#~ "Wird nur benutzt, wenn --expose true ist" + +#~ msgid "" +#~ "The port that this container exposes. If --expose is true, this is also " +#~ "the port used by the service that is created." +#~ msgstr "" +#~ "Der Port, den der Container anbietet. Wenn --expose true ist, ist es " +#~ "auch der Port, den der zu erstellende Service verwendet" + +#~ msgid "" +#~ "Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is " +#~ "'ClusterIP'." +#~ msgstr "" +#~ "Typ für diesen Service: ClusterIP, NodePort oder LoadBalancer. Standard " +#~ "ist 'ClusterIP'." + +#~ msgid "Update field(s) of a resource using strategic merge patch" +#~ msgstr "Aktualisiere Felder einer Resource mit einem Strategic-Merge-Patch" + +#~ msgid "Update image of a pod template" +#~ msgstr "Aktualisiere das Image einer Pod-Template" + +#~ msgid "" +#~ "View latest last-applied-configuration annotations of a resource/object" +#~ msgstr "" +#~ "Zeige die aktuelle Annotation Last-Applied-Configuration einer Resource / " +#~ "eines Object" diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/default/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/default/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..77b13524a3 Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/default/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/default/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/default/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..c0952d13c7 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/default/LC_MESSAGES/k8s.po @@ -0,0 +1,5085 @@ +# Test translations for unit tests. +# Copyright (C) 2016 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR brendan.d.burns@gmail.com, 2016. +# +msgid "" +msgstr "" +"Project-Id-Version: gettext-go-examples-hello\n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2017-05-24 18:01+0800\n" +"Last-Translator: Brendan Burns \n" +"Language-Team: \n" +"Language: en\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 1.8.12\n" +"X-Poedit-SourceCharset: UTF-8\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:138 +msgid "" +"\n" +"\t\t\t# Approve CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate approve csr-sqgzp\n" +"\t\t" +msgstr "" +"\n" +"\t\t\t# Approve CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate approve csr-sqgzp\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:182 +msgid "" +"\n" +"\t\t\t# Deny CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate deny csr-sqgzp\n" +"\t\t" +msgstr "" +"\n" +"\t\t\t# Deny CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate deny csr-sqgzp\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:43 +msgid "" +"\n" +"\t\t\tModify kubeconfig files using subcommands like \"kubectl config set " +"current-context my-context\"\n" +"\n" +"\t\t\tThe loading order follows these rules:\n" +"\n" +"\t\t\t1. If the --" +msgstr "" +"\n" +"\t\t\tModify kubeconfig files using subcommands like \"kubectl config set " +"current-context my-context\"\n" +"\n" +"\t\t\tThe loading order follows these rules:\n" +"\n" +"\t\t\t1. If the --" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:44 +msgid "" +"\n" +"\t\t # Create a cluster role binding for user1, user2, and group1 using the " +"cluster-admin cluster role\n" +"\t\t kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-" +"admin --user=user1 --user=user2 --group=group1" +msgstr "" +"\n" +"\t\t # Create a cluster role binding for user1, user2, and group1 using the " +"cluster-admin cluster role\n" +"\t\t kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-" +"admin --user=user1 --user=user2 --group=group1" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:58 +msgid "" +"\n" +"\t\t # Create a new config map named my-config based on folder bar\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config with specified keys instead " +"of file basenames on disk\n" +"\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/file1." +"txt --from-file=key2=/path/to/bar/file2.txt\n" +"\n" +"\t\t # Create a new config map named my-config with key1=config1 and " +"key2=config2\n" +"\t\t kubectl create configmap my-config --from-literal=key1=config1 --from-" +"literal=key2=config2\n" +"\n" +"\t\t # Create a new config map named my-config from the key=value pairs in " +"the file\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config from an env file\n" +"\t\t kubectl create configmap my-config --from-env-file=path/to/bar.env" +msgstr "" +"\n" +"\t\t # Create a new config map named my-config based on folder bar\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config with specified keys instead " +"of file basenames on disk\n" +"\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/file1." +"txt --from-file=key2=/path/to/bar/file2.txt\n" +"\n" +"\t\t # Create a new config map named my-config with key1=config1 and " +"key2=config2\n" +"\t\t kubectl create configmap my-config --from-literal=key1=config1 --from-" +"literal=key2=config2\n" +"\n" +"\t\t # Create a new config map named my-config from the key=value pairs in " +"the file\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config from an env file\n" +"\t\t kubectl create configmap my-config --from-env-file=path/to/bar.env" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:43 +msgid "" +"\n" +"\t\t # Create a role binding for user1, user2, and group1 using the admin " +"cluster role\n" +"\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +"user=user2 --group=group1" +msgstr "" +"\n" +"\t\t # Create a role binding for user1, user2, and group1 using the admin " +"cluster role\n" +"\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +"user=user2 --group=group1" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:56 +msgid "" +"\n" +"\t\t # If you don't already have a .dockercfg file, you can create a " +"dockercfg secret directly by using:\n" +"\t\t kubectl create secret docker-registry my-secret --docker-" +"server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +"password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL\n" +"\n" +"\t\t # Create a new secret named my-secret from ~/.docker/config.json\n" +"\t\t kubectl create secret docker-registry my-secret --from-file=." +"dockerconfigjson=path/to/.docker/config.json" +msgstr "" +"\n" +"\t\t # If you don't already have a .dockercfg file, you can create a " +"dockercfg secret directly by using:\n" +"\t\t kubectl create secret docker-registry my-secret --docker-" +"server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +"password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL\n" +"\n" +"\t\t # Create a new secret named my-secret from ~/.docker/config.json\n" +"\t\t kubectl create secret docker-registry my-secret --from-file=." +"dockerconfigjson=path/to/.docker/config.json" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:62 +msgid "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" +msgstr "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:45 +msgid "" +"\n" +"\t\t# !!!Important Note!!!\n" +"\t\t# Requires that the 'tar' binary is present in your container\n" +"\t\t# image. If 'tar' is not present, 'kubectl cp' will fail.\n" +"\t\t#\n" +"\t\t# For advanced use cases, such as symlinks, wildcard expansion or\n" +"\t\t# file mode preservation, consider using 'kubectl exec'.\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\ttar cf - /tmp/foo | kubectl exec -i -n -- " +"tar xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl exec -n -- tar cf - /tmp/foo | tar " +"xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in " +"the default namespace\n" +"\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific " +"container\n" +"\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl cp /:/tmp/foo /tmp/bar" +msgstr "" +"\n" +"\t\t# !!!Important Note!!!\n" +"\t\t# Requires that the 'tar' binary is present in your container\n" +"\t\t# image. If 'tar' is not present, 'kubectl cp' will fail.\n" +"\t\t#\n" +"\t\t# For advanced use cases, such as symlinks, wildcard expansion or\n" +"\t\t# file mode preservation, consider using 'kubectl exec'.\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\ttar cf - /tmp/foo | kubectl exec -i -n -- " +"tar xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl exec -n -- tar cf - /tmp/foo | tar " +"xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in " +"the default namespace\n" +"\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific " +"container\n" +"\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl cp /:/tmp/foo /tmp/bar" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:119 +msgid "" +"\n" +"\t\t# Apply the configuration in pod.json to a pod\n" +"\t\tkubectl apply -f ./pod.json\n" +"\n" +"\t\t# Apply resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl apply -k dir/\n" +"\n" +"\t\t# Apply the JSON passed into stdin to a pod\n" +"\t\tcat pod.json | kubectl apply -f -\n" +"\n" +"\t\t# Note: --prune is still in Alpha\n" +"\t\t# Apply the configuration in manifest.yaml that matches label app=nginx " +"and delete all other resources that are not in the file and match label " +"app=nginx\n" +"\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +"\n" +"\t\t# Apply the configuration in manifest.yaml and delete all the other " +"config maps that are not in the file\n" +"\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/v1/" +"ConfigMap" +msgstr "" +"\n" +"\t\t# Apply the configuration in pod.json to a pod\n" +"\t\tkubectl apply -f ./pod.json\n" +"\n" +"\t\t# Apply resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl apply -k dir/\n" +"\n" +"\t\t# Apply the JSON passed into stdin to a pod\n" +"\t\tcat pod.json | kubectl apply -f -\n" +"\n" +"\t\t# Note: --prune is still in Alpha\n" +"\t\t# Apply the configuration in manifest.yaml that matches label app=nginx " +"and delete all other resources that are not in the file and match label " +"app=nginx\n" +"\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +"\n" +"\t\t# Apply the configuration in manifest.yaml and delete all the other " +"config maps that are not in the file\n" +"\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/v1/" +"ConfigMap" + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:48 +#, c-format +msgid "" +"\n" +"\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 and " +"10, no target CPU utilization specified so a default autoscaling policy will " +"be used\n" +"\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +"\n" +"\t\t# Auto scale a replication controller \"foo\", with the number of pods " +"between 1 and 5, target CPU utilization at 80%\n" +"\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" +msgstr "" +"\n" +"\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 and " +"10, no target CPU utilization specified so a default autoscaling policy will " +"be used\n" +"\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +"\n" +"\t\t# Auto scale a replication controller \"foo\", with the number of pods " +"between 1 and 5, target CPU utilization at 80%\n" +"\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" + +#: pkg/kubectl/cmd/convert/convert.go:51 +msgid "" +"\n" +"\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +"\t\tkubectl convert -f pod.yaml\n" +"\n" +"\t\t# Convert the live state of the resource specified by 'pod.yaml' to the " +"latest version\n" +"\t\t# and print to stdout in JSON format.\n" +"\t\tkubectl convert -f pod.yaml --local -o json\n" +"\n" +"\t\t# Convert all files under current directory to latest version and create " +"them all.\n" +"\t\tkubectl convert -f . | kubectl create -f -" +msgstr "" +"\n" +"\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +"\t\tkubectl convert -f pod.yaml\n" +"\n" +"\t\t# Convert the live state of the resource specified by 'pod.yaml' to the " +"latest version\n" +"\t\t# and print to stdout in JSON format.\n" +"\t\tkubectl convert -f pod.yaml --local -o json\n" +"\n" +"\t\t# Convert all files under current directory to latest version and create " +"them all.\n" +"\t\tkubectl convert -f . | kubectl create -f -" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:41 +msgid "" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" that allows user to perform " +"\"get\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +"resource=pods\n" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" with ResourceName " +"specified\n" +"\t\tkubectl create clusterrole pod-reader --verb=get --resource=pods --" +"resource-name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with API Group specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=rs." +"extensions\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with SubResource specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=pods," +"pods/status\n" +"\n" +"\t\t# Create a cluster role name \"foo\" with NonResourceURL specified\n" +"\t\tkubectl create clusterrole \"foo\" --verb=get --non-resource-url=/logs/" +"*\n" +"\n" +"\t\t# Create a cluster role name \"monitoring\" with AggregationRule " +"specified\n" +"\t\tkubectl create clusterrole monitoring --aggregation-rule=\"rbac.example." +"com/aggregate-to-monitoring=true\"" +msgstr "" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" that allows user to perform " +"\"get\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +"resource=pods\n" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" with ResourceName " +"specified\n" +"\t\tkubectl create clusterrole pod-reader --verb=get --resource=pods --" +"resource-name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with API Group specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=rs." +"extensions\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with SubResource specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=pods," +"pods/status\n" +"\n" +"\t\t# Create a cluster role name \"foo\" with NonResourceURL specified\n" +"\t\tkubectl create clusterrole \"foo\" --verb=get --non-resource-url=/logs/" +"*\n" +"\n" +"\t\t# Create a cluster role name \"monitoring\" with AggregationRule " +"specified\n" +"\t\tkubectl create clusterrole monitoring --aggregation-rule=\"rbac.example." +"com/aggregate-to-monitoring=true\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:43 +msgid "" +"\n" +"\t\t# Create a job\n" +"\t\tkubectl create job my-job --image=busybox\n" +"\n" +"\t\t# Create a job with a command\n" +"\t\tkubectl create job my-job --image=busybox -- date\n" +"\n" +"\t\t# Create a job from a cron job named \"a-cronjob\"\n" +"\t\tkubectl create job test-job --from=cronjob/a-cronjob" +msgstr "" +"\n" +"\t\t# Create a job\n" +"\t\tkubectl create job my-job --image=busybox\n" +"\n" +"\t\t# Create a job with a command\n" +"\t\tkubectl create job my-job --image=busybox -- date\n" +"\n" +"\t\t# Create a job from a cron job named \"a-cronjob\"\n" +"\t\tkubectl create job test-job --from=cronjob/a-cronjob" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:44 +msgid "" +"\n" +"\t\t# Create a new resource quota named my-quota\n" +"\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3," +"replicationcontrollers=2,resourcequotas=1,secrets=5," +"persistentvolumeclaims=10\n" +"\n" +"\t\t# Create a new resource quota named best-effort\n" +"\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" +msgstr "" +"\n" +"\t\t# Create a new resource quota named my-quota\n" +"\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3," +"replicationcontrollers=2,resourcequotas=1,secrets=5," +"persistentvolumeclaims=10\n" +"\n" +"\t\t# Create a new resource quota named best-effort\n" +"\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:44 +#, c-format +msgid "" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=rails label\n" +"\t\t# and require at least one of them being available at any point in time\n" +"\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +"available=1\n" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=nginx label\n" +"\t\t# and require at least half of the pods selected to be available at any " +"point in time\n" +"\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" +msgstr "" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=rails label\n" +"\t\t# and require at least one of them being available at any point in time\n" +"\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +"available=1\n" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=nginx label\n" +"\t\t# and require at least half of the pods selected to be available at any " +"point in time\n" +"\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:76 +msgid "" +"\n" +"\t\t# Create a pod using the data in pod.json\n" +"\t\tkubectl create -f ./pod.json\n" +"\n" +"\t\t# Create a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl create -f -\n" +"\n" +"\t\t# Edit the data in docker-registry.yaml in JSON then create the resource " +"using the edited data\n" +"\t\tkubectl create -f docker-registry.yaml --edit -o json" +msgstr "" +"\n" +"\t\t# Create a pod using the data in pod.json\n" +"\t\tkubectl create -f ./pod.json\n" +"\n" +"\t\t# Create a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl create -f -\n" +"\n" +"\t\t# Edit the data in docker-registry.yaml in JSON then create the resource " +"using the edited data\n" +"\t\tkubectl create -f docker-registry.yaml --edit -o json" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:43 +msgid "" +"\n" +"\t\t# Create a priority class named high-priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\"\n" +"\n" +"\t\t# Create a priority class named default-priority that is considered as " +"the global default priority\n" +"\t\tkubectl create priorityclass default-priority --value=1000 --global-" +"default=true --description=\"default priority\"\n" +"\n" +"\t\t# Create a priority class named high-priority that cannot preempt pods " +"with lower priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\" --preemption-policy=\"Never\"" +msgstr "" +"\n" +"\t\t# Create a priority class named high-priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\"\n" +"\n" +"\t\t# Create a priority class named default-priority that is considered as " +"the global default priority\n" +"\t\tkubectl create priorityclass default-priority --value=1000 --global-" +"default=true --description=\"default priority\"\n" +"\n" +"\t\t# Create a priority class named high-priority that cannot preempt pods " +"with lower priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\" --preemption-policy=\"Never\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:46 +msgid "" +"\n" +"\t\t# Create a role named \"pod-reader\" that allows user to perform \"get" +"\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +"resource=pods\n" +"\n" +"\t\t# Create a role named \"pod-reader\" with ResourceName specified\n" +"\t\tkubectl create role pod-reader --verb=get --resource=pods --resource-" +"name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a role named \"foo\" with API Group specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=rs.extensions\n" +"\n" +"\t\t# Create a role named \"foo\" with SubResource specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=pods,pods/status" +msgstr "" +"\n" +"\t\t# Create a role named \"pod-reader\" that allows user to perform \"get" +"\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +"resource=pods\n" +"\n" +"\t\t# Create a role named \"pod-reader\" with ResourceName specified\n" +"\t\tkubectl create role pod-reader --verb=get --resource=pods --resource-" +"name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a role named \"foo\" with API Group specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=rs.extensions\n" +"\n" +"\t\t# Create a role named \"foo\" with SubResource specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=pods,pods/status" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:61 +msgid "" +"\n" +"\t\t# Create a service for a replicated nginx, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a replication controller identified by type and " +"name specified in \"nginx-controller.yaml\", which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +"the name \"frontend\"\n" +"\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +"\n" +"\t\t# Create a second service based on the above service, exposing the " +"container port 8443 as port 443 with the name \"nginx-https\"\n" +"\t\tkubectl expose service nginx --port=443 --target-port=8443 --name=nginx-" +"https\n" +"\n" +"\t\t# Create a service for a replicated streaming application on port 4100 " +"balancing UDP traffic and named 'video-stream'.\n" +"\t\tkubectl expose rc streamer --port=4100 --protocol=UDP --name=video-" +"stream\n" +"\n" +"\t\t# Create a service for a replicated nginx using replica set, which " +"serves on port 80 and connects to the containers on port 8000\n" +"\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for an nginx deployment, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose deployment nginx --port=80 --target-port=8000" +msgstr "" +"\n" +"\t\t# Create a service for a replicated nginx, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a replication controller identified by type and " +"name specified in \"nginx-controller.yaml\", which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +"the name \"frontend\"\n" +"\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +"\n" +"\t\t# Create a second service based on the above service, exposing the " +"container port 8443 as port 443 with the name \"nginx-https\"\n" +"\t\tkubectl expose service nginx --port=443 --target-port=8443 --name=nginx-" +"https\n" +"\n" +"\t\t# Create a service for a replicated streaming application on port 4100 " +"balancing UDP traffic and named 'video-stream'.\n" +"\t\tkubectl expose rc streamer --port=4100 --protocol=UDP --name=video-" +"stream\n" +"\n" +"\t\t# Create a service for a replicated nginx using replica set, which " +"serves on port 80 and connects to the containers on port 8000\n" +"\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for an nginx deployment, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose deployment nginx --port=80 --target-port=8000" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:64 +msgid "" +"\n" +"\t\t# Create a single ingress called 'simple' that directs requests to foo." +"com/bar to svc\n" +"\t\t# svc1:8080 with a tls secret \"my-cert\"\n" +"\t\tkubectl create ingress simple --rule=\"foo.com/bar=svc1:8080,tls=my-cert" +"\"\n" +"\n" +"\t\t# Create a catch all ingress of \"/path\" pointing to service svc:port " +"and Ingress Class as \"otheringress\"\n" +"\t\tkubectl create ingress catch-all --class=otheringress --rule=\"/path=svc:" +"port\"\n" +"\n" +"\t\t# Create an ingress with two annotations: ingress.annotation1 and " +"ingress.annotations2\n" +"\t\tkubectl create ingress annotated --class=default --rule=\"foo.com/" +"bar=svc:port\" \\n\t\t\t--annotation ingress.annotation1=foo \\n\t\t\t--" +"annotation ingress.annotation2=bla\n" +"\n" +"\t\t# Create an ingress with the same host and multiple paths\n" +"\t\tkubectl create ingress multipath --class=default \\n\t\t\t--rule=\"foo." +"com/=svc:port\" \\n\t\t\t--rule=\"foo.com/admin/=svcadmin:portadmin\"\n" +"\n" +"\t\t# Create an ingress with multiple hosts and the pathType as Prefix\n" +"\t\tkubectl create ingress ingress1 --class=default \\n\t\t\t--rule=\"foo." +"com/path*=svc:8080\" \\n\t\t\t--rule=\"bar.com/admin*=svc2:http\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using the default ingress " +"certificate and different path types\n" +"\t\tkubectl create ingress ingtls --class=default \\n\t\t --rule=\"foo.com/" +"=svc:https,tls\" \\n\t\t --rule=\"foo.com/path/subpath*=othersvc:8080\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using a specific secret and " +"pathType as Prefix\n" +"\t\tkubectl create ingress ingsecret --class=default \\n\t\t --rule=\"foo." +"com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t# Create an ingress with a default backend\n" +"\t\tkubectl create ingress ingdefault --class=default \\n\t\t --default-" +"backend=defaultsvc:http \\n\t\t --rule=\"foo.com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t" +msgstr "" +"\n" +"\t\t# Create a single ingress called 'simple' that directs requests to foo." +"com/bar to svc\n" +"\t\t# svc1:8080 with a tls secret \"my-cert\"\n" +"\t\tkubectl create ingress simple --rule=\"foo.com/bar=svc1:8080,tls=my-cert" +"\"\n" +"\n" +"\t\t# Create a catch all ingress of \"/path\" pointing to service svc:port " +"and Ingress Class as \"otheringress\"\n" +"\t\tkubectl create ingress catch-all --class=otheringress --rule=\"/path=svc:" +"port\"\n" +"\n" +"\t\t# Create an ingress with two annotations: ingress.annotation1 and " +"ingress.annotations2\n" +"\t\tkubectl create ingress annotated --class=default --rule=\"foo.com/" +"bar=svc:port\" \\n\t\t\t--annotation ingress.annotation1=foo \\n\t\t\t--" +"annotation ingress.annotation2=bla\n" +"\n" +"\t\t# Create an ingress with the same host and multiple paths\n" +"\t\tkubectl create ingress multipath --class=default \\n\t\t\t--rule=\"foo." +"com/=svc:port\" \\n\t\t\t--rule=\"foo.com/admin/=svcadmin:portadmin\"\n" +"\n" +"\t\t# Create an ingress with multiple hosts and the pathType as Prefix\n" +"\t\tkubectl create ingress ingress1 --class=default \\n\t\t\t--rule=\"foo." +"com/path*=svc:8080\" \\n\t\t\t--rule=\"bar.com/admin*=svc2:http\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using the default ingress " +"certificate and different path types\n" +"\t\tkubectl create ingress ingtls --class=default \\n\t\t --rule=\"foo.com/" +"=svc:https,tls\" \\n\t\t --rule=\"foo.com/path/subpath*=othersvc:8080\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using a specific secret and " +"pathType as Prefix\n" +"\t\tkubectl create ingress ingsecret --class=default \\n\t\t --rule=\"foo." +"com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t# Create an ingress with a default backend\n" +"\t\tkubectl create ingress ingdefault --class=default \\n\t\t --default-" +"backend=defaultsvc:http \\n\t\t --rule=\"foo.com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:74 +msgid "" +"\n" +"\t\t# Create an interactive debugging session in pod mypod and immediately " +"attach to it.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug mypod -it --image=busybox\n" +"\n" +"\t\t# Create a debug container named debugger using a custom automated " +"debugging image.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug --image=myproj/debug-tools -c debugger mypod\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and attach to it\n" +"\t\tkubectl debug mypod -it --image=busybox --copy-to=my-debugger\n" +"\n" +"\t\t# Create a copy of mypod changing the command of mycontainer\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --container=mycontainer -- " +"sh\n" +"\n" +"\t\t# Create a copy of mypod changing all container images to busybox\n" +"\t\tkubectl debug mypod --copy-to=my-debugger --set-image=*=busybox\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and changing container " +"images\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --image=debian --set-" +"image=app=app:debug,sidecar=sidecar:debug\n" +"\n" +"\t\t# Create an interactive debugging session on a node and immediately " +"attach to it.\n" +"\t\t# The container will run in the host namespaces and the host's " +"filesystem will be mounted at /host\n" +"\t\tkubectl debug node/mynode -it --image=busybox\n" +msgstr "" +"\n" +"\t\t# Create an interactive debugging session in pod mypod and immediately " +"attach to it.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug mypod -it --image=busybox\n" +"\n" +"\t\t# Create a debug container named debugger using a custom automated " +"debugging image.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug --image=myproj/debug-tools -c debugger mypod\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and attach to it\n" +"\t\tkubectl debug mypod -it --image=busybox --copy-to=my-debugger\n" +"\n" +"\t\t# Create a copy of mypod changing the command of mycontainer\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --container=mycontainer -- " +"sh\n" +"\n" +"\t\t# Create a copy of mypod changing all container images to busybox\n" +"\t\tkubectl debug mypod --copy-to=my-debugger --set-image=*=busybox\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and changing container " +"images\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --image=debian --set-" +"image=app=app:debug,sidecar=sidecar:debug\n" +"\n" +"\t\t# Create an interactive debugging session on a node and immediately " +"attach to it.\n" +"\t\t# The container will run in the host namespaces and the host's " +"filesystem will be mounted at /host\n" +"\t\tkubectl debug node/mynode -it --image=busybox\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:74 +msgid "" +"\n" +"\t\t# Delete a pod using the type and name specified in pod.json\n" +"\t\tkubectl delete -f ./pod.json\n" +"\n" +"\t\t# Delete resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl delete -k dir\n" +"\n" +"\t\t# Delete a pod based on the type and name in the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl delete -f -\n" +"\n" +"\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +"\t\tkubectl delete pod,service baz foo\n" +"\n" +"\t\t# Delete pods and services with label name=myLabel\n" +"\t\tkubectl delete pods,services -l name=myLabel\n" +"\n" +"\t\t# Delete a pod with minimal delay\n" +"\t\tkubectl delete pod foo --now\n" +"\n" +"\t\t# Force delete a pod on a dead node\n" +"\t\tkubectl delete pod foo --force\n" +"\n" +"\t\t# Delete all pods\n" +"\t\tkubectl delete pods --all" +msgstr "" +"\n" +"\t\t# Delete a pod using the type and name specified in pod.json\n" +"\t\tkubectl delete -f ./pod.json\n" +"\n" +"\t\t# Delete resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl delete -k dir\n" +"\n" +"\t\t# Delete a pod based on the type and name in the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl delete -f -\n" +"\n" +"\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +"\t\tkubectl delete pod,service baz foo\n" +"\n" +"\t\t# Delete pods and services with label name=myLabel\n" +"\t\tkubectl delete pods,services -l name=myLabel\n" +"\n" +"\t\t# Delete a pod with minimal delay\n" +"\t\tkubectl delete pod foo --now\n" +"\n" +"\t\t# Force delete a pod on a dead node\n" +"\t\tkubectl delete pod foo --force\n" +"\n" +"\t\t# Delete all pods\n" +"\t\tkubectl delete pods --all" + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:51 +msgid "" +"\n" +"\t\t# Describe a node\n" +"\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +"\n" +"\t\t# Describe a pod\n" +"\t\tkubectl describe pods/nginx\n" +"\n" +"\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +"\t\tkubectl describe -f pod.json\n" +"\n" +"\t\t# Describe all pods\n" +"\t\tkubectl describe pods\n" +"\n" +"\t\t# Describe pods by label name=myLabel\n" +"\t\tkubectl describe po -l name=myLabel\n" +"\n" +"\t\t# Describe all pods managed by the 'frontend' replication controller (rc-" +"created pods\n" +"\t\t# get the name of the rc as a prefix in the pod the name)\n" +"\t\tkubectl describe pods frontend" +msgstr "" +"\n" +"\t\t# Describe a node\n" +"\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +"\n" +"\t\t# Describe a pod\n" +"\t\tkubectl describe pods/nginx\n" +"\n" +"\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +"\t\tkubectl describe -f pod.json\n" +"\n" +"\t\t# Describe all pods\n" +"\t\tkubectl describe pods\n" +"\n" +"\t\t# Describe pods by label name=myLabel\n" +"\t\tkubectl describe po -l name=myLabel\n" +"\n" +"\t\t# Describe all pods managed by the 'frontend' replication controller (rc-" +"created pods\n" +"\t\t# get the name of the rc as a prefix in the pod the name)\n" +"\t\tkubectl describe pods frontend" + +#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:76 +msgid "" +"\n" +"\t\t# Diff resources included in pod.json\n" +"\t\tkubectl diff -f pod.json\n" +"\n" +"\t\t# Diff file read from stdin\n" +"\t\tcat service.yaml | kubectl diff -f -" +msgstr "" +"\n" +"\t\t# Diff resources included in pod.json\n" +"\t\tkubectl diff -f pod.json\n" +"\n" +"\t\t# Diff file read from stdin\n" +"\t\tcat service.yaml | kubectl diff -f -" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:138 +msgid "" +"\n" +"\t\t# Drain node \"foo\", even if there are pods not managed by a " +"replication controller, replica set, job, daemon set or stateful set on it\n" +"\t\tkubectl drain foo --force\n" +"\n" +"\t\t# As above, but abort if there are pods not managed by a replication " +"controller, replica set, job, daemon set or stateful set, and use a grace " +"period of 15 minutes\n" +"\t\tkubectl drain foo --grace-period=900" +msgstr "" +"\n" +"\t\t# Drain node \"foo\", even if there are pods not managed by a " +"replication controller, replica set, job, daemon set or stateful set on it\n" +"\t\tkubectl drain foo --force\n" +"\n" +"\t\t# As above, but abort if there are pods not managed by a replication " +"controller, replica set, job, daemon set or stateful set, and use a grace " +"period of 15 minutes\n" +"\t\tkubectl drain foo --grace-period=900" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:55 +msgid "" +"\n" +"\t\t# Edit the service named 'docker-registry'\n" +"\t\tkubectl edit svc/docker-registry\n" +"\n" +"\t\t# Use an alternative editor\n" +"\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +"\n" +"\t\t# Edit the job 'myjob' in JSON using the v1 API format\n" +"\t\tkubectl edit job.v1.batch/myjob -o json\n" +"\n" +"\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +"config in its annotation\n" +"\t\tkubectl edit deployment/mydeployment -o yaml --save-config" +msgstr "" +"\n" +"\t\t# Edit the service named 'docker-registry'\n" +"\t\tkubectl edit svc/docker-registry\n" +"\n" +"\t\t# Use an alternative editor\n" +"\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +"\n" +"\t\t# Edit the job 'myjob' in JSON using the v1 API format\n" +"\t\tkubectl edit job.v1.batch/myjob -o json\n" +"\n" +"\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +"config in its annotation\n" +"\t\tkubectl edit deployment/mydeployment -o yaml --save-config" + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:44 +msgid "" +"\n" +"\t\t# Get output from running pod mypod; use the 'kubectl.kubernetes.io/" +"default-container' annotation\n" +"\t\t# for selecting the container to be attached or the first container in " +"the pod will be chosen\n" +"\t\tkubectl attach mypod\n" +"\n" +"\t\t# Get output from ruby-container from pod mypod\n" +"\t\tkubectl attach mypod -c ruby-container\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl attach mypod -c ruby-container -i -t\n" +"\n" +"\t\t# Get output from the first pod of a replica set named nginx\n" +"\t\tkubectl attach rs/nginx\n" +"\t\t" +msgstr "" +"\n" +"\t\t# Get output from running pod mypod; use the 'kubectl.kubernetes.io/" +"default-container' annotation\n" +"\t\t# for selecting the container to be attached or the first container in " +"the pod will be chosen\n" +"\t\tkubectl attach mypod\n" +"\n" +"\t\t# Get output from ruby-container from pod mypod\n" +"\t\tkubectl attach mypod -c ruby-container\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl attach mypod -c ruby-container -i -t\n" +"\n" +"\t\t# Get output from the first pod of a replica set named nginx\n" +"\t\tkubectl attach rs/nginx\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:48 +msgid "" +"\n" +"\t\t# Get output from running the 'date' command from pod mypod, using the " +"first container by default\n" +"\t\tkubectl exec mypod -- date\n" +"\n" +"\t\t# Get output from running the 'date' command in ruby-container from pod " +"mypod\n" +"\t\tkubectl exec mypod -c ruby-container -- date\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl exec mypod -c ruby-container -i -t -- bash -il\n" +"\n" +"\t\t# List contents of /usr from the first container of pod mypod and sort " +"by modification time\n" +"\t\t# If the command you want to execute in the pod has any flags in common " +"(e.g. -i),\n" +"\t\t# you must use two dashes (--) to separate your command's flags/" +"arguments\n" +"\t\t# Also note, do not surround your command and its flags/arguments with " +"quotes\n" +"\t\t# unless that is how you would execute it normally (i.e., do ls -t /usr, " +"not \"ls -t /usr\")\n" +"\t\tkubectl exec mypod -i -t -- ls -t /usr\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"deployment mydeployment, using the first container by default\n" +"\t\tkubectl exec deploy/mydeployment -- date\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"service myservice, using the first container by default\n" +"\t\tkubectl exec svc/myservice -- date\n" +"\t\t" +msgstr "" +"\n" +"\t\t# Get output from running the 'date' command from pod mypod, using the " +"first container by default\n" +"\t\tkubectl exec mypod -- date\n" +"\n" +"\t\t# Get output from running the 'date' command in ruby-container from pod " +"mypod\n" +"\t\tkubectl exec mypod -c ruby-container -- date\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl exec mypod -c ruby-container -i -t -- bash -il\n" +"\n" +"\t\t# List contents of /usr from the first container of pod mypod and sort " +"by modification time\n" +"\t\t# If the command you want to execute in the pod has any flags in common " +"(e.g. -i),\n" +"\t\t# you must use two dashes (--) to separate your command's flags/" +"arguments\n" +"\t\t# Also note, do not surround your command and its flags/arguments with " +"quotes\n" +"\t\t# unless that is how you would execute it normally (i.e., do ls -t /usr, " +"not \"ls -t /usr\")\n" +"\t\tkubectl exec mypod -i -t -- ls -t /usr\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"deployment mydeployment, using the first container by default\n" +"\t\tkubectl exec deploy/mydeployment -- date\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"service myservice, using the first container by default\n" +"\t\tkubectl exec svc/myservice -- date\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:46 +msgid "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" +msgstr "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:65 +msgid "" +"\n" +"\t\t# Installing bash completion on macOS using homebrew\n" +"\t\t## If running Bash 3.2 included with macOS\n" +"\t\t brew install bash-completion\n" +"\t\t## or, if running Bash 4.1+\n" +"\t\t brew install bash-completion@2\n" +"\t\t## If kubectl is installed via homebrew, this should start working " +"immediately\n" +"\t\t## If you've installed via other means, you may need add the completion " +"to your completion directory\n" +"\t\t kubectl completion bash > $(brew --prefix)/etc/bash_completion.d/" +"kubectl\n" +"\n" +"\n" +"\t\t# Installing bash completion on Linux\n" +"\t\t## If bash-completion is not installed on Linux, install the 'bash-" +"completion' package\n" +"\t\t## via your distribution's package manager.\n" +"\t\t## Load the kubectl completion code for bash into the current shell\n" +"\t\t source <(kubectl completion bash)\n" +"\t\t## Write bash completion code to a file and source it from ." +"bash_profile\n" +"\t\t kubectl completion bash > ~/.kube/completion.bash.inc\n" +"\t\t printf \"\n" +"\t\t # Kubectl shell completion\n" +"\t\t source '$HOME/.kube/completion.bash.inc'\n" +"\t\t \" >> $HOME/.bash_profile\n" +"\t\t source $HOME/.bash_profile\n" +"\n" +"\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +"\t\t source <(kubectl completion zsh)\n" +"\t\t# Set the kubectl completion code for zsh[1] to autoload on startup\n" +"\t\t kubectl completion zsh > \"${fpath[1]}/_kubectl\"" +msgstr "" +"\n" +"\t\t# Installing bash completion on macOS using homebrew\n" +"\t\t## If running Bash 3.2 included with macOS\n" +"\t\t brew install bash-completion\n" +"\t\t## or, if running Bash 4.1+\n" +"\t\t brew install bash-completion@2\n" +"\t\t## If kubectl is installed via homebrew, this should start working " +"immediately\n" +"\t\t## If you've installed via other means, you may need add the completion " +"to your completion directory\n" +"\t\t kubectl completion bash > $(brew --prefix)/etc/bash_completion.d/" +"kubectl\n" +"\n" +"\n" +"\t\t# Installing bash completion on Linux\n" +"\t\t## If bash-completion is not installed on Linux, install the 'bash-" +"completion' package\n" +"\t\t## via your distribution's package manager.\n" +"\t\t## Load the kubectl completion code for bash into the current shell\n" +"\t\t source <(kubectl completion bash)\n" +"\t\t## Write bash completion code to a file and source it from ." +"bash_profile\n" +"\t\t kubectl completion bash > ~/.kube/completion.bash.inc\n" +"\t\t printf \"\n" +"\t\t # Kubectl shell completion\n" +"\t\t source '$HOME/.kube/completion.bash.inc'\n" +"\t\t \" >> $HOME/.bash_profile\n" +"\t\t source $HOME/.bash_profile\n" +"\n" +"\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +"\t\t source <(kubectl completion zsh)\n" +"\t\t# Set the kubectl completion code for zsh[1] to autoload on startup\n" +"\t\t kubectl completion zsh > \"${fpath[1]}/_kubectl\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:105 +msgid "" +"\n" +"\t\t# List all pods in ps output format\n" +"\t\tkubectl get pods\n" +"\n" +"\t\t# List all pods in ps output format with more information (such as node " +"name)\n" +"\t\tkubectl get pods -o wide\n" +"\n" +"\t\t# List a single replication controller with specified NAME in ps output " +"format\n" +"\t\tkubectl get replicationcontroller web\n" +"\n" +"\t\t# List deployments in JSON output format, in the \"v1\" version of the " +"\"apps\" API group\n" +"\t\tkubectl get deployments.v1.apps -o json\n" +"\n" +"\t\t# List a single pod in JSON output format\n" +"\t\tkubectl get -o json pod web-pod-13je7\n" +"\n" +"\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +"JSON output format\n" +"\t\tkubectl get -f pod.yaml -o json\n" +"\n" +"\t\t# List resources from a directory with kustomization.yaml - e.g. dir/" +"kustomization.yaml\n" +"\t\tkubectl get -k dir/\n" +"\n" +"\t\t# Return only the phase value of the specified pod\n" +"\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}\n" +"\n" +"\t\t# List resource information in custom columns\n" +"\t\tkubectl get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0]." +"name,IMAGE:.spec.containers[0].image\n" +"\n" +"\t\t# List all replication controllers and services together in ps output " +"format\n" +"\t\tkubectl get rc,services\n" +"\n" +"\t\t# List one or more resources by their type and names\n" +"\t\tkubectl get rc/web service/frontend pods/web-pod-13je7" +msgstr "" +"\n" +"\t\t# List all pods in ps output format\n" +"\t\tkubectl get pods\n" +"\n" +"\t\t# List all pods in ps output format with more information (such as node " +"name)\n" +"\t\tkubectl get pods -o wide\n" +"\n" +"\t\t# List a single replication controller with specified NAME in ps output " +"format\n" +"\t\tkubectl get replicationcontroller web\n" +"\n" +"\t\t# List deployments in JSON output format, in the \"v1\" version of the " +"\"apps\" API group\n" +"\t\tkubectl get deployments.v1.apps -o json\n" +"\n" +"\t\t# List a single pod in JSON output format\n" +"\t\tkubectl get -o json pod web-pod-13je7\n" +"\n" +"\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +"JSON output format\n" +"\t\tkubectl get -f pod.yaml -o json\n" +"\n" +"\t\t# List resources from a directory with kustomization.yaml - e.g. dir/" +"kustomization.yaml\n" +"\t\tkubectl get -k dir/\n" +"\n" +"\t\t# Return only the phase value of the specified pod\n" +"\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}\n" +"\n" +"\t\t# List resource information in custom columns\n" +"\t\tkubectl get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0]." +"name,IMAGE:.spec.containers[0].image\n" +"\n" +"\t\t# List all replication controllers and services together in ps output " +"format\n" +"\t\tkubectl get rc,services\n" +"\n" +"\t\t# List one or more resources by their type and names\n" +"\t\tkubectl get rc/web service/frontend pods/web-pod-13je7" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:72 +msgid "" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 5000 6000\n" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in a pod selected by the deployment\n" +"\t\tkubectl port-forward deployment/mydeployment 5000 6000\n" +"\n" +"\t\t# Listen on port 8443 locally, forwarding to the targetPort of the " +"service's port named \"https\" in a pod selected by the service\n" +"\t\tkubectl port-forward service/myservice 8443:https\n" +"\n" +"\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on all addresses, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on localhost and selected IP, forwarding to 5000 " +"in the pod\n" +"\t\tkubectl port-forward --address localhost,10.19.21.23 pod/mypod " +"8888:5000\n" +"\n" +"\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod :5000" +msgstr "" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 5000 6000\n" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in a pod selected by the deployment\n" +"\t\tkubectl port-forward deployment/mydeployment 5000 6000\n" +"\n" +"\t\t# Listen on port 8443 locally, forwarding to the targetPort of the " +"service's port named \"https\" in a pod selected by the service\n" +"\t\tkubectl port-forward service/myservice 8443:https\n" +"\n" +"\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on all addresses, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on localhost and selected IP, forwarding to 5000 " +"in the pod\n" +"\t\tkubectl port-forward --address localhost,10.19.21.23 pod/mypod " +"8888:5000\n" +"\n" +"\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod :5000" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:87 +msgid "" +"\n" +"\t\t# Mark node \"foo\" as schedulable\n" +"\t\tkubectl uncordon foo" +msgstr "" +"\n" +"\t\t# Mark node \"foo\" as schedulable\n" +"\t\tkubectl uncordon foo" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:58 +msgid "" +"\n" +"\t\t# Mark node \"foo\" as unschedulable\n" +"\t\tkubectl cordon foo" +msgstr "" +"\n" +"\t\t# Mark node \"foo\" as unschedulable\n" +"\t\tkubectl cordon foo" + +#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:83 +msgid "" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as JSON\n" +"\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as YAML\n" +"\t\tkubectl patch node k8s-node-1 -p $'spec:\n" +" unschedulable: true'\n" +"\n" +"\t\t# Partially update a node identified by the type and name specified in " +"\"node.json\" using strategic merge patch\n" +"\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Update a container's image; spec.containers[*].name is required " +"because it's a merge key\n" +"\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +"\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +"\n" +"\t\t# Update a container's image using a JSON patch with positional arrays\n" +"\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +"\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" +msgstr "" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as JSON\n" +"\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as YAML\n" +"\t\tkubectl patch node k8s-node-1 -p $'spec:\n" +" unschedulable: true'\n" +"\n" +"\t\t# Partially update a node identified by the type and name specified in " +"\"node.json\" using strategic merge patch\n" +"\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Update a container's image; spec.containers[*].name is required " +"because it's a merge key\n" +"\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +"\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +"\n" +"\t\t# Update a container's image using a JSON patch with positional arrays\n" +"\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +"\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/options.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:29 +msgid "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" +msgstr "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:44 +msgid "" +"\n" +"\t\t# Print the address of the control plane and cluster services\n" +"\t\tkubectl cluster-info" +msgstr "" +"\n" +"\t\t# Print the address of the control plane and cluster services\n" +"\t\tkubectl cluster-info" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/version.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:44 +msgid "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" +msgstr "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:34 +msgid "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" +msgstr "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" + +#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:56 +msgid "" +"\n" +"\t\t# Replace a pod using the data in pod.json\n" +"\t\tkubectl replace -f ./pod.json\n" +"\n" +"\t\t# Replace a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl replace -f -\n" +"\n" +"\t\t# Update a single-container pod's image version (tag) to v4\n" +"\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' | " +"kubectl replace -f -\n" +"\n" +"\t\t# Force replace, delete and then re-create the resource\n" +"\t\tkubectl replace --force -f ./pod.json" +msgstr "" +"\n" +"\t\t# Replace a pod using the data in pod.json\n" +"\t\tkubectl replace -f ./pod.json\n" +"\n" +"\t\t# Replace a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl replace -f -\n" +"\n" +"\t\t# Update a single-container pod's image version (tag) to v4\n" +"\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' | " +"kubectl replace -f -\n" +"\n" +"\t\t# Force replace, delete and then re-create the resource\n" +"\t\tkubectl replace --force -f ./pod.json" + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:53 +msgid "" +"\n" +"\t\t# Return snapshot logs from pod nginx with only one container\n" +"\t\tkubectl logs nginx\n" +"\n" +"\t\t# Return snapshot logs from pod nginx with multi containers\n" +"\t\tkubectl logs nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot of previous terminated ruby container logs from pod " +"web-1\n" +"\t\tkubectl logs -p -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +"\t\tkubectl logs -f -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -f -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Display only the most recent 20 lines of output in pod nginx\n" +"\t\tkubectl logs --tail=20 nginx\n" +"\n" +"\t\t# Show all logs from pod nginx written in the last hour\n" +"\t\tkubectl logs --since=1h nginx\n" +"\n" +"\t\t# Show logs from a kubelet with an expired serving certificate\n" +"\t\tkubectl logs --insecure-skip-tls-verify-backend nginx\n" +"\n" +"\t\t# Return snapshot logs from first container of a job named hello\n" +"\t\tkubectl logs job/hello\n" +"\n" +"\t\t# Return snapshot logs from container nginx-1 of a deployment named " +"nginx\n" +"\t\tkubectl logs deployment/nginx -c nginx-1" +msgstr "" +"\n" +"\t\t# Return snapshot logs from pod nginx with only one container\n" +"\t\tkubectl logs nginx\n" +"\n" +"\t\t# Return snapshot logs from pod nginx with multi containers\n" +"\t\tkubectl logs nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot of previous terminated ruby container logs from pod " +"web-1\n" +"\t\tkubectl logs -p -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +"\t\tkubectl logs -f -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -f -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Display only the most recent 20 lines of output in pod nginx\n" +"\t\tkubectl logs --tail=20 nginx\n" +"\n" +"\t\t# Show all logs from pod nginx written in the last hour\n" +"\t\tkubectl logs --since=1h nginx\n" +"\n" +"\t\t# Show logs from a kubelet with an expired serving certificate\n" +"\t\tkubectl logs --insecure-skip-tls-verify-backend nginx\n" +"\n" +"\t\t# Return snapshot logs from first container of a job named hello\n" +"\t\tkubectl logs job/hello\n" +"\n" +"\t\t# Return snapshot logs from container nginx-1 of a deployment named " +"nginx\n" +"\t\tkubectl logs deployment/nginx -c nginx-1" + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:49 +msgid "" +"\n" +"\t\t# Scale a replica set named 'foo' to 3\n" +"\t\tkubectl scale --replicas=3 rs/foo\n" +"\n" +"\t\t# Scale a resource identified by type and name specified in \"foo.yaml\" " +"to 3\n" +"\t\tkubectl scale --replicas=3 -f foo.yaml\n" +"\n" +"\t\t# If the deployment named mysql's current size is 2, scale mysql to 3\n" +"\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +"\n" +"\t\t# Scale multiple replication controllers\n" +"\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +"\n" +"\t\t# Scale stateful set named 'web' to 3\n" +"\t\tkubectl scale --replicas=3 statefulset/web" +msgstr "" +"\n" +"\t\t# Scale a replica set named 'foo' to 3\n" +"\t\tkubectl scale --replicas=3 rs/foo\n" +"\n" +"\t\t# Scale a resource identified by type and name specified in \"foo.yaml\" " +"to 3\n" +"\t\tkubectl scale --replicas=3 -f foo.yaml\n" +"\n" +"\t\t# If the deployment named mysql's current size is 2, scale mysql to 3\n" +"\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +"\n" +"\t\t# Scale multiple replication controllers\n" +"\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +"\n" +"\t\t# Scale stateful set named 'web' to 3\n" +"\t\tkubectl scale --replicas=3 statefulset/web" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:75 +msgid "" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml\n" +"\n" +"\t\t# Execute set-last-applied against each configuration file in a " +"directory\n" +"\t\tkubectl apply set-last-applied -f path/\n" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file; will create the annotation if it does not already exist\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml --create-annotation=true\n" +"\t\t" +msgstr "" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml\n" +"\n" +"\t\t# Execute set-last-applied against each configuration file in a " +"directory\n" +"\t\tkubectl apply set-last-applied -f path/\n" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file; will create the annotation if it does not already exist\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml --create-annotation=true\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:75 +msgid "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" +msgstr "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:62 +msgid "" +"\n" +"\t\t# Start a nginx pod\n" +"\t\tkubectl run nginx --image=nginx\n" +"\n" +"\t\t# Start a hazelcast pod and let the container expose port 5701\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --port=5701\n" +"\n" +"\t\t# Start a hazelcast pod and set environment variables " +"\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --env=" +"\"DNS_DOMAIN=cluster\" --env=\"POD_NAMESPACE=default\"\n" +"\n" +"\t\t# Start a hazelcast pod and set labels \"app=hazelcast\" and \"env=prod" +"\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --labels=" +"\"app=hazelcast,env=prod\"\n" +"\n" +"\t\t# Dry run; print the corresponding API objects without creating them\n" +"\t\tkubectl run nginx --image=nginx --dry-run=client\n" +"\n" +"\t\t# Start a nginx pod, but overload the spec with a partial set of values " +"parsed from JSON\n" +"\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": \"v1\", " +"\"spec\": { ... } }'\n" +"\n" +"\t\t# Start a busybox pod and keep it in the foreground, don't restart it if " +"it exits\n" +"\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +"\n" +"\t\t# Start the nginx pod using the default command, but use custom " +"arguments (arg1 .. argN) for that command\n" +"\t\tkubectl run nginx --image=nginx -- ... \n" +"\n" +"\t\t# Start the nginx pod using a different command and custom arguments\n" +"\t\tkubectl run nginx --image=nginx --command -- ... " +msgstr "" +"\n" +"\t\t# Start a nginx pod\n" +"\t\tkubectl run nginx --image=nginx\n" +"\n" +"\t\t# Start a hazelcast pod and let the container expose port 5701\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --port=5701\n" +"\n" +"\t\t# Start a hazelcast pod and set environment variables " +"\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --env=" +"\"DNS_DOMAIN=cluster\" --env=\"POD_NAMESPACE=default\"\n" +"\n" +"\t\t# Start a hazelcast pod and set labels \"app=hazelcast\" and \"env=prod" +"\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --labels=" +"\"app=hazelcast,env=prod\"\n" +"\n" +"\t\t# Dry run; print the corresponding API objects without creating them\n" +"\t\tkubectl run nginx --image=nginx --dry-run=client\n" +"\n" +"\t\t# Start a nginx pod, but overload the spec with a partial set of values " +"parsed from JSON\n" +"\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": \"v1\", " +"\"spec\": { ... } }'\n" +"\n" +"\t\t# Start a busybox pod and keep it in the foreground, don't restart it if " +"it exits\n" +"\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +"\n" +"\t\t# Start the nginx pod using the default command, but use custom " +"arguments (arg1 .. argN) for that command\n" +"\t\tkubectl run nginx --image=nginx -- ... \n" +"\n" +"\t\t# Start the nginx pod using a different command and custom arguments\n" +"\t\tkubectl run nginx --image=nginx --command -- ... " + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:73 +msgid "" +"\n" +"\t\t# To proxy all of the Kubernetes API and nothing else\n" +"\t\tkubectl proxy --api-prefix=/\n" +"\n" +"\t\t# To proxy only part of the Kubernetes API and also some static files\n" +"\t\t# You can get pods info with 'curl localhost:8001/api/v1/pods'\n" +"\t\tkubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/\n" +"\n" +"\t\t# To proxy the entire Kubernetes API at a different root\n" +"\t\t# You can get pods info with 'curl localhost:8001/custom/api/v1/pods'\n" +"\t\tkubectl proxy --api-prefix=/custom/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on port 8011, serving static " +"content from ./local/www/\n" +"\t\tkubectl proxy --port=8011 --www=./local/www/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on an arbitrary local port\n" +"\t\t# The chosen port for the server will be output to stdout\n" +"\t\tkubectl proxy --port=0\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server, changing the API prefix to " +"k8s-api\n" +"\t\t# This makes e.g. the pods API available at localhost:8001/k8s-api/v1/" +"pods/\n" +"\t\tkubectl proxy --api-prefix=/k8s-api" +msgstr "" +"\n" +"\t\t# To proxy all of the Kubernetes API and nothing else\n" +"\t\tkubectl proxy --api-prefix=/\n" +"\n" +"\t\t# To proxy only part of the Kubernetes API and also some static files\n" +"\t\t# You can get pods info with 'curl localhost:8001/api/v1/pods'\n" +"\t\tkubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/\n" +"\n" +"\t\t# To proxy the entire Kubernetes API at a different root\n" +"\t\t# You can get pods info with 'curl localhost:8001/custom/api/v1/pods'\n" +"\t\tkubectl proxy --api-prefix=/custom/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on port 8011, serving static " +"content from ./local/www/\n" +"\t\tkubectl proxy --port=8011 --www=./local/www/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on an arbitrary local port\n" +"\t\t# The chosen port for the server will be output to stdout\n" +"\t\tkubectl proxy --port=0\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server, changing the API prefix to " +"k8s-api\n" +"\t\t# This makes e.g. the pods API available at localhost:8001/k8s-api/v1/" +"pods/\n" +"\t\tkubectl proxy --api-prefix=/k8s-api" + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:80 +msgid "" +"\n" +"\t\t# Update node 'foo' with a taint with key 'dedicated' and value 'special-" +"user' and effect 'NoSchedule'\n" +"\t\t# If a taint with that key and effect already exists, its value is " +"replaced as specified\n" +"\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +"\n" +"\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +"'NoSchedule' if one exists\n" +"\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +"\n" +"\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +"\t\tkubectl taint nodes foo dedicated-\n" +"\n" +"\t\t# Add a taint with key 'dedicated' on nodes having label mylabel=X\n" +"\t\tkubectl taint node -l myLabel=X dedicated=foo:PreferNoSchedule\n" +"\n" +"\t\t# Add to node 'foo' a taint with key 'bar' and no value\n" +"\t\tkubectl taint nodes foo bar:NoSchedule" +msgstr "" +"\n" +"\t\t# Update node 'foo' with a taint with key 'dedicated' and value 'special-" +"user' and effect 'NoSchedule'\n" +"\t\t# If a taint with that key and effect already exists, its value is " +"replaced as specified\n" +"\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +"\n" +"\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +"'NoSchedule' if one exists\n" +"\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +"\n" +"\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +"\t\tkubectl taint nodes foo dedicated-\n" +"\n" +"\t\t# Add a taint with key 'dedicated' on nodes having label mylabel=X\n" +"\t\tkubectl taint node -l myLabel=X dedicated=foo:PreferNoSchedule\n" +"\n" +"\t\t# Add to node 'foo' a taint with key 'bar' and no value\n" +"\t\tkubectl taint nodes foo bar:NoSchedule" + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:95 +msgid "" +"\n" +"\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'\n" +"\t\tkubectl label pods foo unhealthy=true\n" +"\n" +"\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +"overwriting any existing value\n" +"\t\tkubectl label --overwrite pods foo status=unhealthy\n" +"\n" +"\t\t# Update all pods in the namespace\n" +"\t\tkubectl label pods --all status=unhealthy\n" +"\n" +"\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +"\t\tkubectl label -f pod.json status=unhealthy\n" +"\n" +"\t\t# Update pod 'foo' only if the resource is unchanged from version 1\n" +"\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +"\n" +"\t\t# Update pod 'foo' by removing a label named 'bar' if it exists\n" +"\t\t# Does not require the --overwrite flag\n" +"\t\tkubectl label pods foo bar-" +msgstr "" +"\n" +"\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'\n" +"\t\tkubectl label pods foo unhealthy=true\n" +"\n" +"\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +"overwriting any existing value\n" +"\t\tkubectl label --overwrite pods foo status=unhealthy\n" +"\n" +"\t\t# Update all pods in the namespace\n" +"\t\tkubectl label pods --all status=unhealthy\n" +"\n" +"\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +"\t\tkubectl label -f pod.json status=unhealthy\n" +"\n" +"\t\t# Update pod 'foo' only if the resource is unchanged from version 1\n" +"\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +"\n" +"\t\t# Update pod 'foo' by removing a label named 'bar' if it exists\n" +"\t\t# Does not require the --overwrite flag\n" +"\t\tkubectl label pods foo bar-" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_view_last_applied.go:53 +msgid "" +"\n" +"\t\t# View the last-applied-configuration annotations by type/name in YAML\n" +"\t\tkubectl apply view-last-applied deployment/nginx\n" +"\n" +"\t\t# View the last-applied-configuration annotations by file in JSON\n" +"\t\tkubectl apply view-last-applied -f deploy.yaml -o json" +msgstr "" +"\n" +"\t\t# View the last-applied-configuration annotations by type/name in YAML\n" +"\t\tkubectl apply view-last-applied deployment/nginx\n" +"\n" +"\t\t# View the last-applied-configuration annotations by file in JSON\n" +"\t\tkubectl apply view-last-applied -f deploy.yaml -o json" + +#: staging/src/k8s.io/kubectl/pkg/cmd/wait/wait.go:61 +msgid "" +"\n" +"\t\t# Wait for the pod \"busybox1\" to contain the status condition of type " +"\"Ready\"\n" +"\t\tkubectl wait --for=condition=Ready pod/busybox1\n" +"\n" +"\t\t# The default value of status condition is true; you can set it to " +"false\n" +"\t\tkubectl wait --for=condition=Ready=false pod/busybox1\n" +"\n" +"\t\t# Wait for the pod \"busybox1\" to be deleted, with a timeout of 60s, " +"after having issued the \"delete\" command\n" +"\t\tkubectl delete pod/busybox1\n" +"\t\tkubectl wait --for=delete pod/busybox1 --timeout=60s" +msgstr "" +"\n" +"\t\t# Wait for the pod \"busybox1\" to contain the status condition of type " +"\"Ready\"\n" +"\t\tkubectl wait --for=condition=Ready pod/busybox1\n" +"\n" +"\t\t# The default value of status condition is true; you can set it to " +"false\n" +"\t\tkubectl wait --for=condition=Ready=false pod/busybox1\n" +"\n" +"\t\t# Wait for the pod \"busybox1\" to be deleted, with a timeout of 60s, " +"after having issued the \"delete\" command\n" +"\t\tkubectl delete pod/busybox1\n" +"\t\tkubectl wait --for=delete pod/busybox1 --timeout=60s" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:110 +msgid "" +"\n" +"\t\tApply a configuration to a resource by file name or stdin.\n" +"\t\tThe resource name must be specified. This resource will be created if it " +"doesn't exist yet.\n" +"\t\tTo use 'apply', always create the resource initially with either 'apply' " +"or 'create --save-config'.\n" +"\n" +"\t\tJSON and YAML formats are accepted.\n" +"\n" +"\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do not " +"use unless you are aware of what the current state is. See https://issues." +"k8s.io/34274." +msgstr "" +"\n" +"\t\tApply a configuration to a resource by file name or stdin.\n" +"\t\tThe resource name must be specified. This resource will be created if it " +"doesn't exist yet.\n" +"\t\tTo use 'apply', always create the resource initially with either 'apply' " +"or 'create --save-config'.\n" +"\n" +"\t\tJSON and YAML formats are accepted.\n" +"\n" +"\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do not " +"use unless you are aware of what the current state is. See https://issues." +"k8s.io/34274." + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:126 +msgid "" +"\n" +"\t\tApprove a certificate signing request.\n" +"\n" +"\t\tkubectl certificate approve allows a cluster admin to approve a " +"certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tissue a certificate to the requestor with the attributes requested in " +"the CSR.\n" +"\n" +"\t\tSECURITY NOTICE: Depending on the requested attributes, the issued " +"certificate\n" +"\t\tcan potentially grant a requester access to cluster resources or to " +"authenticate\n" +"\t\tas a requested identity. Before approving a CSR, ensure you understand " +"what the\n" +"\t\tsigned certificate can do.\n" +"\t\t" +msgstr "" +"\n" +"\t\tApprove a certificate signing request.\n" +"\n" +"\t\tkubectl certificate approve allows a cluster admin to approve a " +"certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tissue a certificate to the requestor with the attributes requested in " +"the CSR.\n" +"\n" +"\t\tSECURITY NOTICE: Depending on the requested attributes, the issued " +"certificate\n" +"\t\tcan potentially grant a requester access to cluster resources or to " +"authenticate\n" +"\t\tas a requested identity. Before approving a CSR, ensure you understand " +"what the\n" +"\t\tsigned certificate can do.\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:28 +msgid "" +"\n" +"\t\tConfigure application resources.\n" +"\n" +"\t\tThese commands help you make changes to existing application resources." +msgstr "" +"\n" +"\t\tConfigure application resources.\n" +"\n" +"\t\tThese commands help you make changes to existing application resources." + +#: pkg/kubectl/cmd/convert/convert.go:40 +msgid "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." +msgstr "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:41 +msgid "" +"\n" +"\t\tCreate a TLS secret from the given public/private key pair.\n" +"\n" +"\t\tThe public/private key pair must exist beforehand. The public key " +"certificate must be .PEM encoded and match\n" +"\t\tthe given private key." +msgstr "" +"\n" +"\t\tCreate a TLS secret from the given public/private key pair.\n" +"\n" +"\t\tThe public/private key pair must exist beforehand. The public key " +"certificate must be .PEM encoded and match\n" +"\t\tthe given private key." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:41 +msgid "" +"\n" +"\t\tCreate a cluster role binding for a particular cluster role." +msgstr "" +"\n" +"\t\tCreate a cluster role binding for a particular cluster role." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:38 +msgid "" +"\n" +"\t\tCreate a cluster role." +msgstr "" +"\n" +"\t\tCreate a cluster role." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:46 +msgid "" +"\n" +"\t\tCreate a config map based on a file, directory, or specified literal " +"value.\n" +"\n" +"\t\tA single config map may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a config map based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key, you may " +"specify an alternate key.\n" +"\n" +"\t\tWhen creating a config map based on a directory, each file whose " +"basename is a valid key in the directory will be\n" +"\t\tpackaged into the config map. Any directory entries except regular " +"files are ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." +msgstr "" +"\n" +"\t\tCreate a config map based on a file, directory, or specified literal " +"value.\n" +"\n" +"\t\tA single config map may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a config map based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key, you may " +"specify an alternate key.\n" +"\n" +"\t\tWhen creating a config map based on a directory, each file whose " +"basename is a valid key in the directory will be\n" +"\t\tpackaged into the config map. Any directory entries except regular " +"files are ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_cronjob.go:40 +msgid "" +"\n" +"\t\tCreate a cron job with the specified name." +msgstr "" +"\n" +"\t\tCreate a cron job with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:40 +msgid "" +"\n" +"\t\tCreate a job with the specified name." +msgstr "" +"\n" +"\t\tCreate a job with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:39 +msgid "" +"\n" +"\t\tCreate a namespace with the specified name." +msgstr "" +"\n" +"\t\tCreate a namespace with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:41 +msgid "" +"\n" +"\t\tCreate a new secret for use with Docker registries.\n" +"\n" +"\t\tDockercfg secrets are used to authenticate against Docker registries.\n" +"\n" +"\t\tWhen using the Docker command line to push images, you can authenticate " +"to a given registry by running:\n" +"\t\t\t'$ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +"password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +"\n" +"\tThat produces a ~/.dockercfg file that is used by subsequent 'docker push' " +"and 'docker pull' commands to\n" +"\t\tauthenticate to the registry. The email address is optional.\n" +"\n" +"\t\tWhen creating applications, you may have a Docker registry that requires " +"authentication. In order for the\n" +"\t\tnodes to pull images on your behalf, they must have the credentials. " +"You can provide this information\n" +"\t\tby creating a dockercfg secret and attaching it to your service account." +msgstr "" +"\n" +"\t\tCreate a new secret for use with Docker registries.\n" +"\n" +"\t\tDockercfg secrets are used to authenticate against Docker registries.\n" +"\n" +"\t\tWhen using the Docker command line to push images, you can authenticate " +"to a given registry by running:\n" +"\t\t\t'$ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +"password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +"\n" +"\tThat produces a ~/.dockercfg file that is used by subsequent 'docker push' " +"and 'docker pull' commands to\n" +"\t\tauthenticate to the registry. The email address is optional.\n" +"\n" +"\t\tWhen creating applications, you may have a Docker registry that requires " +"authentication. In order for the\n" +"\t\tnodes to pull images on your behalf, they must have the credentials. " +"You can provide this information\n" +"\t\tby creating a dockercfg secret and attaching it to your service account." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:41 +msgid "" +"\n" +"\t\tCreate a pod disruption budget with the specified name, selector, and " +"desired minimum available pods." +msgstr "" +"\n" +"\t\tCreate a pod disruption budget with the specified name, selector, and " +"desired minimum available pods." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:40 +msgid "" +"\n" +"\t\tCreate a priority class with the specified name, value, globalDefault " +"and description." +msgstr "" +"\n" +"\t\tCreate a priority class with the specified name, value, globalDefault " +"and description." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:71 +msgid "" +"\n" +"\t\tCreate a resource from a file or from stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted." +msgstr "" +"\n" +"\t\tCreate a resource from a file or from stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:41 +msgid "" +"\n" +"\t\tCreate a resource quota with the specified name, hard limits, and " +"optional scopes." +msgstr "" +"\n" +"\t\tCreate a resource quota with the specified name, hard limits, and " +"optional scopes." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:40 +msgid "" +"\n" +"\t\tCreate a role binding for a particular role or cluster role." +msgstr "" +"\n" +"\t\tCreate a role binding for a particular role or cluster role." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L47 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:43 +msgid "" +"\n" +"\t\tCreate a role with single rule." +msgstr "" +"\n" +"\t\tCreate a role with single rule." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:61 +msgid "" +"\n" +"\t\tCreate a secret based on a file, directory, or specified literal value.\n" +"\n" +"\t\tA single secret may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a secret based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key or you " +"wish to chose your own, you may specify\n" +"\t\tan alternate key.\n" +"\n" +"\t\tWhen creating a secret based on a directory, each file whose basename is " +"a valid key in the directory will be\n" +"\t\tpackaged into the secret. Any directory entries except regular files are " +"ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." +msgstr "" +"\n" +"\t\tCreate a secret based on a file, directory, or specified literal value.\n" +"\n" +"\t\tA single secret may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a secret based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key or you " +"wish to chose your own, you may specify\n" +"\t\tan alternate key.\n" +"\n" +"\t\tWhen creating a secret based on a directory, each file whose basename is " +"a valid key in the directory will be\n" +"\t\tpackaged into the secret. Any directory entries except regular files are " +"ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:40 +msgid "" +"\n" +"\t\tCreate a service account with the specified name." +msgstr "" +"\n" +"\t\tCreate a service account with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:67 +msgid "" +"\n" +"\t\tCreates a proxy server or application-level gateway between localhost " +"and\n" +"\t\tthe Kubernetes API server. It also allows serving static content over " +"specified\n" +"\t\tHTTP path. All incoming data enters through one port and gets forwarded " +"to\n" +"\t\tthe remote Kubernetes API server port, except for the path matching the " +"static content path." +msgstr "" +"\n" +"\t\tCreates a proxy server or application-level gateway between localhost " +"and\n" +"\t\tthe Kubernetes API server. It also allows serving static content over " +"specified\n" +"\t\tHTTP path. All incoming data enters through one port and gets forwarded " +"to\n" +"\t\tthe remote Kubernetes API server port, except for the path matching the " +"static content path." + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:42 +msgid "" +"\n" +"\t\tCreates an autoscaler that automatically chooses and sets the number of " +"pods that run in a Kubernetes cluster.\n" +"\n" +"\t\tLooks up a deployment, replica set, stateful set, or replication " +"controller by name and creates an autoscaler that uses the given resource as " +"a reference.\n" +"\t\tAn autoscaler can automatically increase or decrease number of pods " +"deployed within the system as needed." +msgstr "" +"\n" +"\t\tCreates an autoscaler that automatically chooses and sets the number of " +"pods that run in a Kubernetes cluster.\n" +"\n" +"\t\tLooks up a deployment, replica set, stateful set, or replication " +"controller by name and creates an autoscaler that uses the given resource as " +"a reference.\n" +"\t\tAn autoscaler can automatically increase or decrease number of pods " +"deployed within the system as needed." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:57 +msgid "" +"\n" +"\t\tDebug cluster resources using interactive debugging containers.\n" +"\n" +"\t\t'debug' provides automation for common debugging tasks for cluster " +"objects identified by\n" +"\t\tresource and name. Pods will be used by default if no resource is " +"specified.\n" +"\n" +"\t\tThe action taken by 'debug' varies depending on what resource is " +"specified. Supported\n" +"\t\tactions include:\n" +"\n" +"\t\t* Workload: Create a copy of an existing pod with certain attributes " +"changed,\n" +"\t for example changing the image tag to a new version.\n" +"\t\t* Workload: Add an ephemeral container to an already running pod, for " +"example to add\n" +"\t\t debugging utilities without restarting the pod.\n" +"\t\t* Node: Create a new pod that runs in the node's host namespaces and can " +"access\n" +"\t\t the node's filesystem.\n" +msgstr "" +"\n" +"\t\tDebug cluster resources using interactive debugging containers.\n" +"\n" +"\t\t'debug' provides automation for common debugging tasks for cluster " +"objects identified by\n" +"\t\tresource and name. Pods will be used by default if no resource is " +"specified.\n" +"\n" +"\t\tThe action taken by 'debug' varies depending on what resource is " +"specified. Supported\n" +"\t\tactions include:\n" +"\n" +"\t\t* Workload: Create a copy of an existing pod with certain attributes " +"changed,\n" +"\t for example changing the image tag to a new version.\n" +"\t\t* Workload: Add an ephemeral container to an already running pod, for " +"example to add\n" +"\t\t debugging utilities without restarting the pod.\n" +"\t\t* Node: Create a new pod that runs in the node's host namespaces and can " +"access\n" +"\t\t the node's filesystem.\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:45 +msgid "" +"\n" +"\t\tDelete resources by file names, stdin, resources and names, or by " +"resources and label selector.\n" +"\n" +"\t\tJSON and YAML formats are accepted. Only one type of argument may be " +"specified: file names,\n" +"\t\tresources and names, or resources and label selector.\n" +"\n" +"\t\tSome resources, such as pods, support graceful deletion. These resources " +"define a default period\n" +"\t\tbefore they are forcibly terminated (the grace period) but you may " +"override that value with\n" +"\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +"Because these resources often\n" +"\t\trepresent entities in the cluster, deletion may not be acknowledged " +"immediately. If the node\n" +"\t\thosting a pod is down or cannot reach the API server, termination may " +"take significantly longer\n" +"\t\tthan the grace period. To force delete a resource, you must specify the " +"--force flag.\n" +"\t\tNote: only a subset of resources support graceful deletion. In absence " +"of the support,\n" +"\t\tthe --grace-period flag is ignored.\n" +"\n" +"\t\tIMPORTANT: Force deleting pods does not wait for confirmation that the " +"pod's processes have been\n" +"\t\tterminated, which can leave those processes running until the node " +"detects the deletion and\n" +"\t\tcompletes graceful deletion. If your processes use shared storage or " +"talk to a remote API and\n" +"\t\tdepend on the name of the pod to identify themselves, force deleting " +"those pods may result in\n" +"\t\tmultiple processes running on different machines using the same " +"identification which may lead\n" +"\t\tto data corruption or inconsistency. Only force delete pods when you are " +"sure the pod is\n" +"\t\tterminated, or if your application can tolerate multiple copies of the " +"same pod running at once.\n" +"\t\tAlso, if you force delete pods, the scheduler may place new pods on " +"those nodes before the node\n" +"\t\thas released those resources and causing those pods to be evicted " +"immediately.\n" +"\n" +"\t\tNote that the delete command does NOT do resource version checks, so if " +"someone submits an\n" +"\t\tupdate to a resource right when you submit a delete, their update will " +"be lost along with the\n" +"\t\trest of the resource." +msgstr "" +"\n" +"\t\tDelete resources by file names, stdin, resources and names, or by " +"resources and label selector.\n" +"\n" +"\t\tJSON and YAML formats are accepted. Only one type of argument may be " +"specified: file names,\n" +"\t\tresources and names, or resources and label selector.\n" +"\n" +"\t\tSome resources, such as pods, support graceful deletion. These resources " +"define a default period\n" +"\t\tbefore they are forcibly terminated (the grace period) but you may " +"override that value with\n" +"\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +"Because these resources often\n" +"\t\trepresent entities in the cluster, deletion may not be acknowledged " +"immediately. If the node\n" +"\t\thosting a pod is down or cannot reach the API server, termination may " +"take significantly longer\n" +"\t\tthan the grace period. To force delete a resource, you must specify the " +"--force flag.\n" +"\t\tNote: only a subset of resources support graceful deletion. In absence " +"of the support,\n" +"\t\tthe --grace-period flag is ignored.\n" +"\n" +"\t\tIMPORTANT: Force deleting pods does not wait for confirmation that the " +"pod's processes have been\n" +"\t\tterminated, which can leave those processes running until the node " +"detects the deletion and\n" +"\t\tcompletes graceful deletion. If your processes use shared storage or " +"talk to a remote API and\n" +"\t\tdepend on the name of the pod to identify themselves, force deleting " +"those pods may result in\n" +"\t\tmultiple processes running on different machines using the same " +"identification which may lead\n" +"\t\tto data corruption or inconsistency. Only force delete pods when you are " +"sure the pod is\n" +"\t\tterminated, or if your application can tolerate multiple copies of the " +"same pod running at once.\n" +"\t\tAlso, if you force delete pods, the scheduler may place new pods on " +"those nodes before the node\n" +"\t\thas released those resources and causing those pods to be evicted " +"immediately.\n" +"\n" +"\t\tNote that the delete command does NOT do resource version checks, so if " +"someone submits an\n" +"\t\tupdate to a resource right when you submit a delete, their update will " +"be lost along with the\n" +"\t\trest of the resource." + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:175 +msgid "" +"\n" +"\t\tDeny a certificate signing request.\n" +"\n" +"\t\tkubectl certificate deny allows a cluster admin to deny a certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tnot to issue a certificate to the requestor.\n" +"\t\t" +msgstr "" +"\n" +"\t\tDeny a certificate signing request.\n" +"\n" +"\t\tkubectl certificate deny allows a cluster admin to deny a certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tnot to issue a certificate to the requestor.\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:53 +msgid "" +"\n" +"\t\tDiff configurations specified by file name or stdin between the current " +"online\n" +"\t\tconfiguration, and the configuration as it would be if applied.\n" +"\n" +"\t\tThe output is always YAML.\n" +"\n" +"\t\tKUBECTL_EXTERNAL_DIFF environment variable can be used to select your " +"own\n" +"\t\tdiff command. Users can use external commands with params too, example:\n" +"\t\tKUBECTL_EXTERNAL_DIFF=\"colordiff -N -u\"\n" +"\n" +"\t\tBy default, the \"diff\" command available in your path will be\n" +"\t\trun with the \"-u\" (unified diff) and \"-N\" (treat absent files as " +"empty) options.\n" +"\n" +"\t\tExit status:\n" +"\t\t 0\n" +"\t\tNo differences were found.\n" +"\t\t 1\n" +"\t\tDifferences were found.\n" +"\t\t >1\n" +"\t\tKubectl or diff failed with an error.\n" +"\n" +"\t\tNote: KUBECTL_EXTERNAL_DIFF, if used, is expected to follow that " +"convention." +msgstr "" +"\n" +"\t\tDiff configurations specified by file name or stdin between the current " +"online\n" +"\t\tconfiguration, and the configuration as it would be if applied.\n" +"\n" +"\t\tThe output is always YAML.\n" +"\n" +"\t\tKUBECTL_EXTERNAL_DIFF environment variable can be used to select your " +"own\n" +"\t\tdiff command. Users can use external commands with params too, example:\n" +"\t\tKUBECTL_EXTERNAL_DIFF=\"colordiff -N -u\"\n" +"\n" +"\t\tBy default, the \"diff\" command available in your path will be\n" +"\t\trun with the \"-u\" (unified diff) and \"-N\" (treat absent files as " +"empty) options.\n" +"\n" +"\t\tExit status:\n" +"\t\t 0\n" +"\t\tNo differences were found.\n" +"\t\t 1\n" +"\t\tDifferences were found.\n" +"\t\t >1\n" +"\t\tKubectl or diff failed with an error.\n" +"\n" +"\t\tNote: KUBECTL_EXTERNAL_DIFF, if used, is expected to follow that " +"convention." + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top.go:39 +msgid "" +"\n" +"\t\tDisplay Resource (CPU/Memory) usage.\n" +"\n" +"\t\tThe top command allows you to see the resource consumption for nodes or " +"pods.\n" +"\n" +"\t\tThis command requires Metrics Server to be correctly configured and " +"working on the server. " +msgstr "" +"\n" +"\t\tDisplay Resource (CPU/Memory) usage.\n" +"\n" +"\t\tThe top command allows you to see the resource consumption for nodes or " +"pods.\n" +"\n" +"\t\tThis command requires Metrics Server to be correctly configured and " +"working on the server. " + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:54 +msgid "" +"\n" +"\t\tDisplay merged kubeconfig settings or a specified kubeconfig file.\n" +"\n" +"\t\tYou can use --output jsonpath={...} to extract specific values using a " +"jsonpath expression." +msgstr "" +"\n" +"\t\tDisplay merged kubeconfig settings or a specified kubeconfig file.\n" +"\n" +"\t\tYou can use --output jsonpath={...} to extract specific values using a " +"jsonpath expression." + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:92 +msgid "" +"\n" +"\t\tDisplay one or many resources.\n" +"\n" +"\t\tPrints a table of the most important information about the specified " +"resources.\n" +"\t\tYou can filter the list using a label selector and the --selector flag. " +"If the\n" +"\t\tdesired resource type is namespaced you will only see results in your " +"current\n" +"\t\tnamespace unless you pass --all-namespaces.\n" +"\n" +"\t\tUninitialized objects are not shown unless --include-uninitialized is " +"passed.\n" +"\n" +"\t\tBy specifying the output as 'template' and providing a Go template as " +"the value\n" +"\t\tof the --template flag, you can filter the attributes of the fetched " +"resources." +msgstr "" +"\n" +"\t\tDisplay one or many resources.\n" +"\n" +"\t\tPrints a table of the most important information about the specified " +"resources.\n" +"\t\tYou can filter the list using a label selector and the --selector flag. " +"If the\n" +"\t\tdesired resource type is namespaced you will only see results in your " +"current\n" +"\t\tnamespace unless you pass --all-namespaces.\n" +"\n" +"\t\tUninitialized objects are not shown unless --include-uninitialized is " +"passed.\n" +"\n" +"\t\tBy specifying the output as 'template' and providing a Go template as " +"the value\n" +"\t\tof the --template flag, you can filter the attributes of the fetched " +"resources." + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:57 +msgid "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of nodes.\n" +"\n" +"\t\tThe top-node command allows you to see the resource consumption of nodes." +msgstr "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of nodes.\n" +"\n" +"\t\tThe top-node command allows you to see the resource consumption of nodes." + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:67 +msgid "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of pods.\n" +"\n" +"\t\tThe 'top pod' command allows you to see the resource consumption of " +"pods.\n" +"\n" +"\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +"minutes\n" +"\t\tsince pod creation." +msgstr "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of pods.\n" +"\n" +"\t\tThe 'top pod' command allows you to see the resource consumption of " +"pods.\n" +"\n" +"\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +"minutes\n" +"\t\tsince pod creation." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/current_context.go:37 +msgid "" +"\n" +"\t\tDisplay the current-context." +msgstr "" +"\n" +"\t\tDisplay the current-context." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:113 +msgid "" +"\n" +"\t\tDrain node in preparation for maintenance.\n" +"\n" +"\t\tThe given node will be marked unschedulable to prevent new pods from " +"arriving.\n" +"\t\t'drain' evicts the pods if the API server supports\n" +"\t\t[eviction](https://kubernetes.io/docs/concepts/workloads/pods/" +"disruptions/). Otherwise, it will use normal\n" +"\t\tDELETE to delete the pods.\n" +"\t\tThe 'drain' evicts or deletes all pods except mirror pods (which cannot " +"be deleted through\n" +"\t\tthe API server). If there are daemon set-managed pods, drain will not " +"proceed\n" +"\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +"\t\tdaemon set-managed pods, because those pods would be immediately " +"replaced by the\n" +"\t\tdaemon set controller, which ignores unschedulable markings. If there " +"are any\n" +"\t\tpods that are neither mirror pods nor managed by a replication " +"controller,\n" +"\t\treplica set, daemon set, stateful set, or job, then drain will not " +"delete any pods unless you\n" +"\t\tuse --force. --force will also allow deletion to proceed if the " +"managing resource of one\n" +"\t\tor more pods is missing.\n" +"\n" +"\t\t'drain' waits for graceful termination. You should not operate on the " +"machine until\n" +"\t\tthe command completes.\n" +"\n" +"\t\tWhen you are ready to put the node back into service, use kubectl " +"uncordon, which\n" +"\t\twill make the node schedulable again.\n" +"\n" +"\t\t![Workflow](https://kubernetes.io/images/docs/kubectl_drain.svg)" +msgstr "" +"\n" +"\t\tDrain node in preparation for maintenance.\n" +"\n" +"\t\tThe given node will be marked unschedulable to prevent new pods from " +"arriving.\n" +"\t\t'drain' evicts the pods if the API server supports\n" +"\t\t[eviction](https://kubernetes.io/docs/concepts/workloads/pods/" +"disruptions/). Otherwise, it will use normal\n" +"\t\tDELETE to delete the pods.\n" +"\t\tThe 'drain' evicts or deletes all pods except mirror pods (which cannot " +"be deleted through\n" +"\t\tthe API server). If there are daemon set-managed pods, drain will not " +"proceed\n" +"\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +"\t\tdaemon set-managed pods, because those pods would be immediately " +"replaced by the\n" +"\t\tdaemon set controller, which ignores unschedulable markings. If there " +"are any\n" +"\t\tpods that are neither mirror pods nor managed by a replication " +"controller,\n" +"\t\treplica set, daemon set, stateful set, or job, then drain will not " +"delete any pods unless you\n" +"\t\tuse --force. --force will also allow deletion to proceed if the " +"managing resource of one\n" +"\t\tor more pods is missing.\n" +"\n" +"\t\t'drain' waits for graceful termination. You should not operate on the " +"machine until\n" +"\t\tthe command completes.\n" +"\n" +"\t\tWhen you are ready to put the node back into service, use kubectl " +"uncordon, which\n" +"\t\twill make the node schedulable again.\n" +"\n" +"\t\t![Workflow](https://kubernetes.io/images/docs/kubectl_drain.svg)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:31 +msgid "" +"\n" +"\t\tEdit a resource from the default editor.\n" +"\n" +"\t\tThe edit command allows you to directly edit any API resource you can " +"retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tEditing is done with the API version used to fetch the resource.\n" +"\t\tTo edit using a specific API version, fully-qualify the resource, " +"version, and group.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." +msgstr "" +"\n" +"\t\tEdit a resource from the default editor.\n" +"\n" +"\t\tThe edit command allows you to directly edit any API resource you can " +"retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tEditing is done with the API version used to fetch the resource.\n" +"\t\tTo edit using a specific API version, fully-qualify the resource, " +"version, and group.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_edit_last_applied.go:31 +msgid "" +"\n" +"\t\tEdit the latest last-applied-configuration annotations of resources from " +"the default editor.\n" +"\n" +"\t\tThe edit-last-applied command allows you to directly edit any API " +"resource you can retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." +msgstr "" +"\n" +"\t\tEdit the latest last-applied-configuration annotations of resources from " +"the default editor.\n" +"\n" +"\t\tThe edit-last-applied command allows you to directly edit any API " +"resource you can retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." + +#: staging/src/k8s.io/kubectl/pkg/cmd/wait/wait.go:49 +msgid "" +"\n" +"\t\tExperimental: Wait for a specific condition on one or many resources.\n" +"\n" +"\t\tThe command takes multiple resources and waits until the specified " +"condition\n" +"\t\tis seen in the Status field of every given resource.\n" +"\n" +"\t\tAlternatively, the command can wait for the given set of resources to be " +"deleted\n" +"\t\tby providing the \"delete\" keyword as the value to the --for flag.\n" +"\n" +"\t\tA successful message will be printed to stdout indicating when the " +"specified\n" +" condition has been met. You can use -o option to change to output " +"destination." +msgstr "" +"\n" +"\t\tExperimental: Wait for a specific condition on one or many resources.\n" +"\n" +"\t\tThe command takes multiple resources and waits until the specified " +"condition\n" +"\t\tis seen in the Status field of every given resource.\n" +"\n" +"\t\tAlternatively, the command can wait for the given set of resources to be " +"deleted\n" +"\t\tby providing the \"delete\" keyword as the value to the --for flag.\n" +"\n" +"\t\tA successful message will be printed to stdout indicating when the " +"specified\n" +" condition has been met. You can use -o option to change to output " +"destination." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:47 +msgid "" +"\n" +"\t\tExpose a resource as a new Kubernetes service.\n" +"\n" +"\t\tLooks up a deployment, service, replica set, replication controller or " +"pod by name and uses the selector\n" +"\t\tfor that resource as the selector for a new service on the specified " +"port. A deployment or replica set\n" +"\t\twill be exposed as a service only if its selector is convertible to a " +"selector that service supports,\n" +"\t\ti.e. when the selector contains only the matchLabels component. Note " +"that if no port is specified via\n" +"\t\t--port and the exposed resource has multiple ports, all will be re-used " +"by the new service. Also if no\n" +"\t\tlabels are specified, the new service will re-use the labels from the " +"resource it exposes.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\n" +"\t\t" +msgstr "" +"\n" +"\t\tExpose a resource as a new Kubernetes service.\n" +"\n" +"\t\tLooks up a deployment, service, replica set, replication controller or " +"pod by name and uses the selector\n" +"\t\tfor that resource as the selector for a new service on the specified " +"port. A deployment or replica set\n" +"\t\twill be exposed as a service only if its selector is convertible to a " +"selector that service supports,\n" +"\t\ti.e. when the selector contains only the matchLabels component. Note " +"that if no port is specified via\n" +"\t\t--port and the exposed resource has multiple ports, all will be re-used " +"by the new service. Also if no\n" +"\t\tlabels are specified, the new service will re-use the labels from the " +"resource it exposes.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:46 +msgid "" +"\n" +"\t\tList all available plugin files on a user's PATH.\n" +"\n" +"\t\tAvailable plugin files are those that are:\n" +"\t\t- executable\n" +"\t\t- anywhere on the user's PATH\n" +"\t\t- begin with \"kubectl-\"\n" +msgstr "" +"\n" +"\t\tList all available plugin files on a user's PATH.\n" +"\n" +"\t\tAvailable plugin files are those that are:\n" +"\t\t- executable\n" +"\t\t- anywhere on the user's PATH\n" +"\t\t- begin with \"kubectl-\"\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:35 +msgid "" +"\n" +"\t\tList the fields for supported resources.\n" +"\n" +"\t\tThis command describes the fields associated with each supported API " +"resource.\n" +"\t\tFields are identified via a simple JSONPath identifier:\n" +"\n" +"\t\t\t.[.]\n" +"\n" +"\t\tAdd the --recursive flag to display all of the fields at once without " +"descriptions.\n" +"\t\tInformation about each field is retrieved from the server in OpenAPI " +"format." +msgstr "" +"\n" +"\t\tList the fields for supported resources.\n" +"\n" +"\t\tThis command describes the fields associated with each supported API " +"resource.\n" +"\t\tFields are identified via a simple JSONPath identifier:\n" +"\n" +"\t\t\t.[.]\n" +"\n" +"\t\tAdd the --recursive flag to display all of the fields at once without " +"descriptions.\n" +"\t\tInformation about each field is retrieved from the server in OpenAPI " +"format." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout.go:30 +msgid "" +"\n" +"\t\tManage the rollout of a resource." +msgstr "" +"\n" +"\t\tManage the rollout of a resource." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L127 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:84 +msgid "" +"\n" +"\t\tMark node as schedulable." +msgstr "" +"\n" +"\t\tMark node as schedulable." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:55 +msgid "" +"\n" +"\t\tMark node as unschedulable." +msgstr "" +"\n" +"\t\tMark node as unschedulable." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:57 +msgid "" +"\n" +"\t\tMark the provided resource as paused.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller.\n" +"\t\tUse \"kubectl rollout resume\" to resume a paused resource.\n" +"\t\tCurrently only deployments support being paused." +msgstr "" +"\n" +"\t\tMark the provided resource as paused.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller.\n" +"\t\tUse \"kubectl rollout resume\" to resume a paused resource.\n" +"\t\tCurrently only deployments support being paused." + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:46 +msgid "" +"\n" +"\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +"\t\tThe shell code must be evaluated to provide interactive\n" +"\t\tcompletion of kubectl commands. This can be done by sourcing it from\n" +"\t\tthe .bash_profile.\n" +"\n" +"\t\tDetailed instructions on how to do this are available here:\n" +"\n" +" for macOS:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-macos/#enable-" +"shell-autocompletion\n" +"\n" +" for linux:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/#enable-" +"shell-autocompletion\n" +"\n" +" for windows:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/" +"#enable-shell-autocompletion\n" +"\n" +"\t\tNote for zsh users: [1] zsh completions are only supported in versions " +"of zsh >= 5.2." +msgstr "" +"\n" +"\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +"\t\tThe shell code must be evaluated to provide interactive\n" +"\t\tcompletion of kubectl commands. This can be done by sourcing it from\n" +"\t\tthe .bash_profile.\n" +"\n" +"\t\tDetailed instructions on how to do this are available here:\n" +"\n" +" for macOS:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-macos/#enable-" +"shell-autocompletion\n" +"\n" +" for linux:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/#enable-" +"shell-autocompletion\n" +"\n" +" for windows:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/" +"#enable-shell-autocompletion\n" +"\n" +"\t\tNote for zsh users: [1] zsh completions are only supported in versions " +"of zsh >= 5.2." + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:49 +msgid "" +"\n" +"\t\tPrint the logs for a container in a pod or specified resource. \n" +"\t\tIf the pod has only one container, the container name is optional." +msgstr "" +"\n" +"\t\tPrint the logs for a container in a pod or specified resource. \n" +"\t\tIf the pod has only one container, the container name is optional." + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:37 +msgid "" +"\n" +"\t\tProvides utilities for interacting with plugins.\n" +"\n" +"\t\tPlugins provide extended functionality that is not part of the major " +"command-line distribution.\n" +"\t\tPlease refer to the documentation and examples for more information " +"about how write your own plugins.\n" +"\n" +"\t\tThe easiest way to discover and install plugins is via the kubernetes " +"sub-project krew.\n" +"\t\tTo install krew, visit [krew.sigs.k8s.io](https://krew.sigs.k8s.io/docs/" +"user-guide/setup/install/)" +msgstr "" +"\n" +"\t\tProvides utilities for interacting with plugins.\n" +"\n" +"\t\tPlugins provide extended functionality that is not part of the major " +"command-line distribution.\n" +"\t\tPlease refer to the documentation and examples for more information " +"about how write your own plugins.\n" +"\n" +"\t\tThe easiest way to discover and install plugins is via the kubernetes " +"sub-project krew.\n" +"\t\tTo install krew, visit [krew.sigs.k8s.io](https://krew.sigs.k8s.io/docs/" +"user-guide/setup/install/)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/rename_context.go:47 +msgid "" +"\n" +"\t\tRenames a context from the kubeconfig file.\n" +"\n" +"\t\tCONTEXT_NAME is the context name that you want to change.\n" +"\n" +"\t\tNEW_NAME is the new name you want to set.\n" +"\n" +"\t\tNote: If the context being renamed is the 'current-context', this field " +"will also be updated." +msgstr "" +"\n" +"\t\tRenames a context from the kubeconfig file.\n" +"\n" +"\t\tCONTEXT_NAME is the context name that you want to change.\n" +"\n" +"\t\tNEW_NAME is the new name you want to set.\n" +"\n" +"\t\tNote: If the context being renamed is the 'current-context', this field " +"will also be updated." + +#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:48 +msgid "" +"\n" +"\t\tReplace a resource by file name or stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted. If replacing an existing resource, " +"the\n" +"\t\tcomplete resource spec must be provided. This can be obtained by\n" +"\n" +"\t\t $ kubectl get TYPE NAME -o yaml" +msgstr "" +"\n" +"\t\tReplace a resource by file name or stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted. If replacing an existing resource, " +"the\n" +"\t\tcomplete resource spec must be provided. This can be obtained by\n" +"\n" +"\t\t $ kubectl get TYPE NAME -o yaml" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_restart.go:57 +msgid "" +"\n" +"\t\tRestart a resource.\n" +"\n" +"\t Resource rollout will be restarted." +msgstr "" +"\n" +"\t\tRestart a resource.\n" +"\n" +"\t Resource rollout will be restarted." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:58 +msgid "" +"\n" +"\t\tResume a paused resource.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller. By resuming a\n" +"\t\tresource, we allow it to be reconciled again.\n" +"\t\tCurrently only deployments support being resumed." +msgstr "" +"\n" +"\t\tResume a paused resource.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller. By resuming a\n" +"\t\tresource, we allow it to be reconciled again.\n" +"\t\tCurrently only deployments support being resumed." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:55 +msgid "" +"\n" +"\t\tRoll back to a previous rollout." +msgstr "" +"\n" +"\t\tRoll back to a previous rollout." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_cluster.go:47 +msgid "" +"\n" +"\t\tSet a cluster entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." +msgstr "" +"\n" +"\t\tSet a cluster entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_context.go:44 +msgid "" +"\n" +"\t\tSet a context entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." +msgstr "" +"\n" +"\t\tSet a context entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:40 +msgid "" +"\n" +"\t\tSet a new size for a deployment, replica set, replication controller, or " +"stateful set.\n" +"\n" +"\t\tScale also allows users to specify one or more preconditions for the " +"scale action.\n" +"\n" +"\t\tIf --current-replicas or --resource-version is specified, it is " +"validated before the\n" +"\t\tscale is attempted, and it is guaranteed that the precondition holds " +"true when the\n" +"\t\tscale is sent to the server." +msgstr "" +"\n" +"\t\tSet a new size for a deployment, replica set, replication controller, or " +"stateful set.\n" +"\n" +"\t\tScale also allows users to specify one or more preconditions for the " +"scale action.\n" +"\n" +"\t\tIf --current-replicas or --resource-version is specified, it is " +"validated before the\n" +"\t\tscale is attempted, and it is guaranteed that the precondition holds " +"true when the\n" +"\t\tscale is sent to the server." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_authinfo.go:70 +#, c-format +msgid "" +"\n" +"\t\tSet a user entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values.\n" +"\n" +"\t\t Client-certificate flags:\n" +"\t\t --%v=certfile --%v=keyfile\n" +"\n" +"\t\t Bearer token flags:\n" +"\t\t\t --%v=bearer_token\n" +"\n" +"\t\t Basic auth flags:\n" +"\t\t\t --%v=basic_user --%v=basic_password\n" +"\n" +"\t\tBearer token and basic auth are mutually exclusive." +msgstr "" +"\n" +"\t\tSet a user entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values.\n" +"\n" +"\t\t Client-certificate flags:\n" +"\t\t --%v=certfile --%v=keyfile\n" +"\n" +"\t\t Bearer token flags:\n" +"\t\t\t --%v=bearer_token\n" +"\n" +"\t\t Basic auth flags:\n" +"\t\t\t --%v=basic_user --%v=basic_password\n" +"\n" +"\t\tBearer token and basic auth are mutually exclusive." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:70 +msgid "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." +msgstr "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:67 +#, c-format +msgid "" +"\n" +"\t\tSet the selector on a resource. Note that the new selector will " +"overwrite the old selector if the resource had one prior to the invocation\n" +"\t\tof 'set selector'.\n" +"\n" +"\t\tA selector must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\tIf --resource-version is specified, then updates will use this resource " +"version, otherwise the existing resource-version will be used.\n" +" Note: currently selectors can only be set on Service objects." +msgstr "" +"\n" +"\t\tSet the selector on a resource. Note that the new selector will " +"overwrite the old selector if the resource had one prior to the invocation\n" +"\t\tof 'set selector'.\n" +"\n" +"\t\tA selector must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\tIf --resource-version is specified, then updates will use this resource " +"version, otherwise the existing resource-version will be used.\n" +" Note: currently selectors can only be set on Service objects." + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:39 +msgid "" +"\n" +"\t\tShow details of a specific resource or group of resources.\n" +"\n" +"\t\tPrint a detailed description of the selected resources, including " +"related resources such\n" +"\t\tas events or controllers. You may select a single object by name, all " +"objects of that\n" +"\t\ttype, provide a name prefix, or label selector. For example:\n" +"\n" +"\t\t $ kubectl describe TYPE NAME_PREFIX\n" +"\n" +"\t\twill first check for an exact match on TYPE and NAME_PREFIX. If no such " +"resource\n" +"\t\texists, it will output details for every resource that has a name " +"prefixed with NAME_PREFIX." +msgstr "" +"\n" +"\t\tShow details of a specific resource or group of resources.\n" +"\n" +"\t\tPrint a detailed description of the selected resources, including " +"related resources such\n" +"\t\tas events or controllers. You may select a single object by name, all " +"objects of that\n" +"\t\ttype, provide a name prefix, or label selector. For example:\n" +"\n" +"\t\t $ kubectl describe TYPE NAME_PREFIX\n" +"\n" +"\t\twill first check for an exact match on TYPE and NAME_PREFIX. If no such " +"resource\n" +"\t\texists, it will output details for every resource that has a name " +"prefixed with NAME_PREFIX." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:47 +msgid "" +"\n" +"\t\tShow the status of the rollout.\n" +"\n" +"\t\tBy default 'rollout status' will watch the status of the latest rollout\n" +"\t\tuntil it's done. If you don't want to wait for the rollout to finish " +"then\n" +"\t\tyou can use --watch=false. Note that if a new rollout starts in-between, " +"then\n" +"\t\t'rollout status' will continue watching the latest revision. If you want " +"to\n" +"\t\tpin to a specific revision and abort if it is rolled over by another " +"revision,\n" +"\t\tuse --revision=N where N is the revision you need to watch for." +msgstr "" +"\n" +"\t\tShow the status of the rollout.\n" +"\n" +"\t\tBy default 'rollout status' will watch the status of the latest rollout\n" +"\t\tuntil it's done. If you don't want to wait for the rollout to finish " +"then\n" +"\t\tyou can use --watch=false. Note that if a new rollout starts in-between, " +"then\n" +"\t\t'rollout status' will continue watching the latest revision. If you want " +"to\n" +"\t\tpin to a specific revision and abort if it is rolled over by another " +"revision,\n" +"\t\tuse --revision=N where N is the revision you need to watch for." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:41 +#, c-format +msgid "" +"\n" +"\t\tSpecify compute resource requirements (CPU, memory) for any resource " +"that defines a pod template. If a pod is successfully scheduled, it is " +"guaranteed the amount of resource requested, but may burst up to its " +"specified limits.\n" +"\n" +"\t\tFor each compute resource, if a limit is specified and a request is " +"omitted, the request will default to the limit.\n" +"\n" +"\t\tPossible resources include (case insensitive): %s." +msgstr "" +"\n" +"\t\tSpecify compute resource requirements (CPU, memory) for any resource " +"that defines a pod template. If a pod is successfully scheduled, it is " +"guaranteed the amount of resource requested, but may burst up to its " +"specified limits.\n" +"\n" +"\t\tFor each compute resource, if a limit is specified and a request is " +"omitted, the request will default to the limit.\n" +"\n" +"\t\tPossible resources include (case insensitive): %s." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_env.go:50 +msgid "" +"\n" +"\t\tUpdate environment variables on a pod template.\n" +"\n" +"\t\tList environment variable definitions in one or more pods, pod " +"templates.\n" +"\t\tAdd, update, or remove container environment variable definitions in one " +"or\n" +"\t\tmore pod templates (within replication controllers or deployment " +"configurations).\n" +"\t\tView or modify the environment variable definitions on all containers in " +"the\n" +"\t\tspecified pods or pod templates, or just those that match a wildcard.\n" +"\n" +"\t\tIf \"--env -\" is passed, environment variables can be read from STDIN " +"using the standard env\n" +"\t\tsyntax.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" +msgstr "" +"\n" +"\t\tUpdate environment variables on a pod template.\n" +"\n" +"\t\tList environment variable definitions in one or more pods, pod " +"templates.\n" +"\t\tAdd, update, or remove container environment variable definitions in one " +"or\n" +"\t\tmore pod templates (within replication controllers or deployment " +"configurations).\n" +"\t\tView or modify the environment variable definitions on all containers in " +"the\n" +"\t\tspecified pods or pod templates, or just those that match a wildcard.\n" +"\n" +"\t\tIf \"--env -\" is passed, environment variables can be read from STDIN " +"using the standard env\n" +"\t\tsyntax.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_image.go:71 +msgid "" +"\n" +"\t\tUpdate existing container image(s) of resources.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" +msgstr "" +"\n" +"\t\tUpdate existing container image(s) of resources.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:78 +msgid "" +"\n" +"\t\tUpdate fields of a resource using strategic merge patch, a JSON merge " +"patch, or a JSON patch.\n" +"\n" +"\t\tJSON and YAML formats are accepted." +msgstr "" +"\n" +"\t\tUpdate fields of a resource using strategic merge patch, a JSON merge " +"patch, or a JSON patch.\n" +"\n" +"\t\tJSON and YAML formats are accepted." + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:83 +msgid "" +"\n" +"\t\tUpdate the annotations on one or more resources.\n" +"\n" +"\t\tAll Kubernetes objects support the ability to store additional data with " +"the object as\n" +"\t\tannotations. Annotations are key/value pairs that can be larger than " +"labels and include\n" +"\t\tarbitrary string values such as structured JSON. Tools and system " +"extensions may use\n" +"\t\tannotations to store their own data.\n" +"\n" +"\t\tAttempting to set an annotation that already exists will fail unless --" +"overwrite is set.\n" +"\t\tIf --resource-version is specified and does not match the current " +"resource version on\n" +"\t\tthe server the command will fail." +msgstr "" +"\n" +"\t\tUpdate the annotations on one or more resources.\n" +"\n" +"\t\tAll Kubernetes objects support the ability to store additional data with " +"the object as\n" +"\t\tannotations. Annotations are key/value pairs that can be larger than " +"labels and include\n" +"\t\tarbitrary string values such as structured JSON. Tools and system " +"extensions may use\n" +"\t\tannotations to store their own data.\n" +"\n" +"\t\tAttempting to set an annotation that already exists will fail unless --" +"overwrite is set.\n" +"\t\tIf --resource-version is specified and does not match the current " +"resource version on\n" +"\t\tthe server the command will fail." + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:87 +#, c-format +msgid "" +"\n" +"\t\tUpdate the labels on a resource.\n" +"\n" +"\t\t* A label key and value must begin with a letter or number, and may " +"contain letters, numbers, hyphens, dots, and underscores, up to %[1]d " +"characters each.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* If --overwrite is true, then existing labels can be overwritten, " +"otherwise attempting to overwrite a label will result in an error.\n" +"\t\t* If --resource-version is specified, then updates will use this " +"resource version, otherwise the existing resource-version will be used." +msgstr "" +"\n" +"\t\tUpdate the labels on a resource.\n" +"\n" +"\t\t* A label key and value must begin with a letter or number, and may " +"contain letters, numbers, hyphens, dots, and underscores, up to %[1]d " +"characters each.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* If --overwrite is true, then existing labels can be overwritten, " +"otherwise attempting to overwrite a label will result in an error.\n" +"\t\t* If --resource-version is specified, then updates will use this " +"resource version, otherwise the existing resource-version will be used." + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:70 +#, c-format +msgid "" +"\n" +"\t\tUpdate the taints on one or more nodes.\n" +"\n" +"\t\t* A taint consists of a key, value, and effect. As an argument here, it " +"is expressed as key=value:effect.\n" +"\t\t* The key must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* The value is optional. If given, it must begin with a letter or " +"number, and may contain letters, numbers, hyphens, dots, and underscores, up " +"to %[2]d characters.\n" +"\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +"\t\t* Currently taint can only apply to node." +msgstr "" +"\n" +"\t\tUpdate the taints on one or more nodes.\n" +"\n" +"\t\t* A taint consists of a key, value, and effect. As an argument here, it " +"is expressed as key=value:effect.\n" +"\t\t* The key must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* The value is optional. If given, it must begin with a letter or " +"number, and may contain letters, numbers, hyphens, dots, and underscores, up " +"to %[2]d characters.\n" +"\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +"\t\t* Currently taint can only apply to node." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:36 +msgid "" +"\n" +"\t\tView previous rollout revisions and configurations." +msgstr "" +"\n" +"\t\tView previous rollout revisions and configurations." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_view_last_applied.go:47 +msgid "" +"\n" +"\t\tView the latest last-applied-configuration annotations by type/name or " +"file.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. You can use " +"the -o option\n" +"\t\tto change the output format." +msgstr "" +"\n" +"\t\tView the latest last-applied-configuration annotations by type/name or " +"file.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. You can use " +"the -o option\n" +"\t\tto change the output format." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:47 +msgid "" +"\n" +"\t # Create a new TLS secret named tls-secret with the given key pair\n" +"\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --key=path/" +"to/tls.key" +msgstr "" +"\n" +"\t # Create a new TLS secret named tls-secret with the given key pair\n" +"\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --key=path/" +"to/tls.key" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:42 +msgid "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" +msgstr "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:74 +msgid "" +"\n" +"\t # Create a new secret named my-secret with keys for each file in folder " +"bar\n" +"\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +"\n" +"\t # Create a new secret named my-secret with specified keys instead of " +"names on disk\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-file=ssh-publickey=path/to/id_rsa.pub\n" +"\n" +"\t # Create a new secret named my-secret with key1=supersecret and " +"key2=topsecret\n" +"\t kubectl create secret generic my-secret --from-literal=key1=supersecret " +"--from-literal=key2=topsecret\n" +"\n" +"\t # Create a new secret named my-secret using a combination of a file and " +"a literal\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-literal=passphrase=topsecret\n" +"\n" +"\t # Create a new secret named my-secret from an env file\n" +"\t kubectl create secret generic my-secret --from-env-file=path/to/bar.env" +msgstr "" +"\n" +"\t # Create a new secret named my-secret with keys for each file in folder " +"bar\n" +"\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +"\n" +"\t # Create a new secret named my-secret with specified keys instead of " +"names on disk\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-file=ssh-publickey=path/to/id_rsa.pub\n" +"\n" +"\t # Create a new secret named my-secret with key1=supersecret and " +"key2=topsecret\n" +"\t kubectl create secret generic my-secret --from-literal=key1=supersecret " +"--from-literal=key2=topsecret\n" +"\n" +"\t # Create a new secret named my-secret using a combination of a file and " +"a literal\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-literal=passphrase=topsecret\n" +"\n" +"\t # Create a new secret named my-secret from an env file\n" +"\t kubectl create secret generic my-secret --from-env-file=path/to/bar.env" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:43 +msgid "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" +msgstr "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_deployment.go:45 +msgid "" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image\n" +"\tkubectl create deployment my-dep --image=busybox\n" +"\n" +"\t# Create a deployment with a command\n" +"\tkubectl create deployment my-dep --image=busybox -- date\n" +"\n" +"\t# Create a deployment named my-dep that runs the nginx image with 3 " +"replicas\n" +"\tkubectl create deployment my-dep --image=nginx --replicas=3\n" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image and expose " +"port 5701\n" +"\tkubectl create deployment my-dep --image=busybox --port=5701" +msgstr "" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image\n" +"\tkubectl create deployment my-dep --image=busybox\n" +"\n" +"\t# Create a deployment with a command\n" +"\tkubectl create deployment my-dep --image=busybox -- date\n" +"\n" +"\t# Create a deployment named my-dep that runs the nginx image with 3 " +"replicas\n" +"\tkubectl create deployment my-dep --image=nginx --replicas=3\n" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image and expose " +"port 5701\n" +"\tkubectl create deployment my-dep --image=busybox --port=5701" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:351 +msgid "" +"\n" +"\t# Create a new ExternalName service named my-ns\n" +"\tkubectl create service externalname my-ns --external-name bar.com" +msgstr "" +"\n" +"\t# Create a new ExternalName service named my-ns\n" +"\tkubectl create service externalname my-ns --external-name bar.com" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:50 +msgid "" +"\n" +"\t# Set deployment nginx-deployment's service account to serviceaccount1\n" +"\tkubectl set serviceaccount deployment nginx-deployment serviceaccount1\n" +"\n" +"\t# Print the result (in YAML format) of updated nginx deployment with the " +"service account from local file, without hitting the API server\n" +"\tkubectl set sa -f nginx-deployment.yaml serviceaccount1 --local --dry-" +"run=client -o yaml\n" +"\t" +msgstr "" +"\n" +"\t# Set deployment nginx-deployment's service account to serviceaccount1\n" +"\tkubectl set serviceaccount deployment nginx-deployment serviceaccount1\n" +"\n" +"\t# Print the result (in YAML format) of updated nginx deployment with the " +"service account from local file, without hitting the API server\n" +"\tkubectl set sa -f nginx-deployment.yaml serviceaccount1 --local --dry-" +"run=client -o yaml\n" +"\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_deployment.go:42 +msgid "" +"\n" +"\tCreate a deployment with the specified name." +msgstr "" +"\n" +"\tCreate a deployment with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:344 +msgid "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." +msgstr "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:61 +msgid "" +"\n" +"\tCreate an ingress with the specified name." +msgstr "" +"\n" +"\tCreate an ingress with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:28 +msgid "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." +msgstr "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/set.go:44 +msgid "" +"\n" +"\tSet an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots.\n" +"\n" +"\tPROPERTY_VALUE is the new value you want to set. Binary fields such as " +"'certificate-authority-data' expect a base64 encoded string unless the --set-" +"raw-bytes flag is used.\n" +"\n" +"\tSpecifying an attribute name that already exists will merge new fields on " +"top of existing values." +msgstr "" +"\n" +"\tSet an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots.\n" +"\n" +"\tPROPERTY_VALUE is the new value you want to set. Binary fields such as " +"'certificate-authority-data' expect a base64 encoded string unless the --set-" +"raw-bytes flag is used.\n" +"\n" +"\tSpecifying an attribute name that already exists will merge new fields on " +"top of existing values." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/unset.go:39 +msgid "" +"\n" +"\tUnset an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots." +msgstr "" +"\n" +"\tUnset an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:43 +msgid "" +"\n" +"\tUpdate the service account of pod template resources.\n" +"\n" +"\tPossible resources (case insensitive) can be:\n" +"\n" +"\t" +msgstr "" +"\n" +"\tUpdate the service account of pod template resources.\n" +"\n" +"\tPossible resources (case insensitive) can be:\n" +"\n" +"\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_subject.go:40 +msgid "" +"\n" +"\tUpdate the user, group, or service account in a role binding or cluster " +"role binding." +msgstr "" +"\n" +"\tUpdate the user, group, or service account in a role binding or cluster " +"role binding." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_image.go:68 +msgid "" +"\n" +" \tpod (po), replicationcontroller (rc), deployment (deploy), daemonset " +"(ds), replicaset (rs)" +msgstr "" +"\n" +" \tpod (po), replicationcontroller (rc), deployment (deploy), daemonset " +"(ds), replicaset (rs)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:63 +msgid "" +"\n" +" Forward one or more local ports to a pod.\n" +"\n" +" Use resource type/name such as deployment/mydeployment to " +"select a pod. Resource type defaults to 'pod' if omitted.\n" +"\n" +" If there are multiple pods matching the criteria, a pod will " +"be selected automatically. The\n" +" forwarding session ends when the selected pod terminates, " +"and a rerun of the command is needed\n" +" to resume forwarding." +msgstr "" +"\n" +" Forward one or more local ports to a pod.\n" +"\n" +" Use resource type/name such as deployment/mydeployment to " +"select a pod. Resource type defaults to 'pod' if omitted.\n" +"\n" +" If there are multiple pods matching the criteria, a pod will " +"be selected automatically. The\n" +" forwarding session ends when the selected pod terminates, " +"and a rerun of the command is needed\n" +" to resume forwarding." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:233 +msgid "" +"\n" +" # Create a new ClusterIP service named my-cs\n" +" kubectl create service clusterip my-cs --tcp=5678:8080\n" +"\n" +" # Create a new ClusterIP service named my-cs (in headless mode)\n" +" kubectl create service clusterip my-cs --clusterip=\"None\"" +msgstr "" +"\n" +" # Create a new ClusterIP service named my-cs\n" +" kubectl create service clusterip my-cs --tcp=5678:8080\n" +"\n" +" # Create a new ClusterIP service named my-cs (in headless mode)\n" +" kubectl create service clusterip my-cs --clusterip=\"None\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:311 +msgid "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" +msgstr "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:274 +msgid "" +"\n" +" # Create a new NodePort service named my-ns\n" +" kubectl create service nodeport my-ns --tcp=5678:8080" +msgstr "" +"\n" +" # Create a new NodePort service named my-ns\n" +" kubectl create service nodeport my-ns --tcp=5678:8080" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:102 +msgid "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" +msgstr "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:95 +msgid "" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend'\n" +" # If the same annotation is set multiple times, only the last value will " +"be applied\n" +" kubectl annotate pods foo description='my frontend'\n" +"\n" +" # Update a pod identified by type and name in \"pod.json\"\n" +" kubectl annotate -f pod.json description='my frontend'\n" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend running nginx', overwriting any existing value\n" +" kubectl annotate --overwrite pods foo description='my frontend running " +"nginx'\n" +"\n" +" # Update all pods in the namespace\n" +" kubectl annotate pods --all description='my frontend running nginx'\n" +"\n" +" # Update pod 'foo' only if the resource is unchanged from version 1\n" +" kubectl annotate pods foo description='my frontend running nginx' --" +"resource-version=1\n" +"\n" +" # Update pod 'foo' by removing an annotation named 'description' if it " +"exists\n" +" # Does not require the --overwrite flag\n" +" kubectl annotate pods foo description-" +msgstr "" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend'\n" +" # If the same annotation is set multiple times, only the last value will " +"be applied\n" +" kubectl annotate pods foo description='my frontend'\n" +"\n" +" # Update a pod identified by type and name in \"pod.json\"\n" +" kubectl annotate -f pod.json description='my frontend'\n" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend running nginx', overwriting any existing value\n" +" kubectl annotate --overwrite pods foo description='my frontend running " +"nginx'\n" +"\n" +" # Update all pods in the namespace\n" +" kubectl annotate pods --all description='my frontend running nginx'\n" +"\n" +" # Update pod 'foo' only if the resource is unchanged from version 1\n" +" kubectl annotate pods foo description='my frontend running nginx' --" +"resource-version=1\n" +"\n" +" # Update pod 'foo' by removing an annotation named 'description' if it " +"exists\n" +" # Does not require the --overwrite flag\n" +" kubectl annotate pods foo description-" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:230 +msgid "" +"\n" +" Create a ClusterIP service with the specified name." +msgstr "" +"\n" +" Create a ClusterIP service with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:308 +msgid "" +"\n" +" Create a LoadBalancer service with the specified name." +msgstr "" +"\n" +" Create a LoadBalancer service with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:271 +msgid "" +"\n" +" Create a NodePort service with the specified name." +msgstr "" +"\n" +" Create a NodePort service with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:93 +msgid "" +"\n" +" Dump cluster information out suitable for debugging and diagnosing " +"cluster problems. By default, dumps everything to\n" +" stdout. You can optionally specify a directory with --output-directory. " +"If you specify a directory, Kubernetes will\n" +" build a set of files in that directory. By default, only dumps things " +"in the current namespace and 'kube-system' namespace, but you can\n" +" switch to a different namespace with the --namespaces flag, or specify --" +"all-namespaces to dump all namespaces.\n" +"\n" +" The command also dumps the logs of all of the pods in the cluster; these " +"logs are dumped into different directories\n" +" based on namespace and pod name." +msgstr "" +"\n" +" Dump cluster information out suitable for debugging and diagnosing " +"cluster problems. By default, dumps everything to\n" +" stdout. You can optionally specify a directory with --output-directory. " +"If you specify a directory, Kubernetes will\n" +" build a set of files in that directory. By default, only dumps things " +"in the current namespace and 'kube-system' namespace, but you can\n" +" switch to a different namespace with the --namespaces flag, or specify --" +"all-namespaces to dump all namespaces.\n" +"\n" +" The command also dumps the logs of all of the pods in the cluster; these " +"logs are dumped into different directories\n" +" based on namespace and pod name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:40 +msgid "" +"\n" +" Display addresses of the control plane and services with label kubernetes." +"io/cluster-service=true.\n" +" To further debug and diagnose cluster problems, use 'kubectl cluster-info " +"dump'." +msgstr "" +"\n" +" Display addresses of the control plane and services with label kubernetes." +"io/cluster-service=true.\n" +" To further debug and diagnose cluster problems, use 'kubectl cluster-info " +"dump'." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:49 +msgid "" +" environment variable is set, then it is used as a list of paths (normal " +"path delimiting rules for your system). These paths are merged. When a value " +"is modified, it is modified in the file that defines the stanza. When a " +"value is created, it is created in the first file that exists. If no files " +"in the chain exist, then it creates the last file in the list.\n" +"\t\t\t3. Otherwise, " +msgstr "" +" environment variable is set, then it is used as a list of paths (normal " +"path delimiting rules for your system). These paths are merged. When a value " +"is modified, it is modified in the file that defines the stanza. When a " +"value is created, it is created in the first file that exists. If no files " +"in the chain exist, then it creates the last file in the list.\n" +"\t\t\t3. Otherwise, " + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:48 +msgid "" +" flag is set, then only that file is loaded. The flag may only be set once " +"and no merging takes place.\n" +"\t\t\t2. If $" +msgstr "" +" flag is set, then only that file is loaded. The flag may only be set once " +"and no merging takes place.\n" +"\t\t\t2. If $" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:50 +msgid " is used and no merging takes place." +msgstr " is used and no merging takes place." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L61 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:107 +msgid "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." +msgstr "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L60 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:106 +msgid "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." +msgstr "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L63 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:113 +msgid "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." +msgstr "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L106 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:152 +msgid "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" +msgstr "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L111 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:157 +msgid "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." +msgstr "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:178 +msgid "Allocate a TTY for the debugging container." +msgstr "Allocate a TTY for the debugging container." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L119 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:158 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:178 +msgid "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." +msgstr "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:173 +msgid "Annotations to apply to the pod." +msgstr "Annotations to apply to the pod." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:173 +msgid "Apply a configuration to a resource by file name or stdin" +msgstr "Apply a configuration to a resource by file name or stdin" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:125 +msgid "Approve a certificate signing request" +msgstr "Approve a certificate signing request" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L81 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:263 +msgid "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." +msgstr "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:106 +msgid "" +"Attach to a process that is already running inside an existing container." +msgstr "" +"Attach to a process that is already running inside an existing container." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/attach.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:105 +msgid "Attach to a running container" +msgstr "Attach to a running container" + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:107 +msgid "" +"Auto-scale a deployment, replica set, stateful set, or replication controller" +msgstr "" +"Auto-scale a deployment, replica set, stateful set, or replication controller" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L115 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:161 +msgid "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." +msgstr "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_clusterrolebinding.go#L55 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:101 +msgid "ClusterRole this ClusterRoleBinding should reference" +msgstr "ClusterRole this ClusterRoleBinding should reference" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L55 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:104 +msgid "ClusterRole this RoleBinding should reference" +msgstr "ClusterRole this RoleBinding should reference" + +#: staging/src/k8s.io/kubectl/pkg/cmd/alpha.go:32 +msgid "Commands for features in alpha" +msgstr "Commands for features in alpha" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:170 +msgid "Container image to use for debug container." +msgstr "Container image to use for debug container." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:166 +msgid "Container name to use for debug container." +msgstr "Container name to use for debug container." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/convert.go#L67 +#: pkg/kubectl/cmd/convert/convert.go:95 +msgid "Convert config files between different API versions" +msgstr "Convert config files between different API versions" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:105 +msgid "Copy files and directories to and from containers" +msgstr "Copy files and directories to and from containers" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/cp.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:106 +msgid "Copy files and directories to and from containers." +msgstr "Copy files and directories to and from containers." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:248 +msgid "Create a ClusterIP service" +msgstr "Create a ClusterIP service" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:323 +msgid "Create a LoadBalancer service" +msgstr "Create a LoadBalancer service" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:286 +msgid "Create a NodePort service" +msgstr "Create a NodePort service" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L214 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:94 +msgid "Create a TLS secret" +msgstr "Create a TLS secret" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:81 +msgid "Create a cluster role" +msgstr "Create a cluster role" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:87 +msgid "Create a cluster role binding for a particular cluster role" +msgstr "Create a cluster role binding for a particular cluster role" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:124 +msgid "Create a config map from a local file, directory or literal value" +msgstr "Create a config map from a local file, directory or literal value" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:167 +msgid "Create a copy of the target Pod with this name." +msgstr "Create a copy of the target Pod with this name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_cronjob.go:90 +msgid "Create a cron job with the specified name" +msgstr "Create a cron job with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_deployment.go:100 +msgid "Create a deployment with the specified name" +msgstr "Create a deployment with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:91 +msgid "Create a job with the specified name" +msgstr "Create a job with the specified name" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:83 +msgid "Create a namespace with the specified name" +msgstr "Create a namespace with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:95 +msgid "Create a pod disruption budget with the specified name" +msgstr "Create a pod disruption budget with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:92 +msgid "Create a priority class with the specified name" +msgstr "Create a priority class with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:91 +msgid "Create a quota with the specified name" +msgstr "Create a quota with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:106 +msgid "Create a resource from a file or from stdin" +msgstr "Create a resource from a file or from stdin" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:89 +msgid "Create a role binding for a particular role or cluster role" +msgstr "Create a role binding for a particular role or cluster role" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:161 +msgid "Create a role with single rule" +msgstr "Create a role with single rule" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L143 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:134 +msgid "Create a secret for use with a Docker registry" +msgstr "Create a secret for use with a Docker registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:137 +msgid "Create a secret from a local file, directory, or literal value" +msgstr "Create a secret from a local file, directory, or literal value" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L34 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:49 +msgid "Create a secret using specified subcommand" +msgstr "Create a secret using specified subcommand" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:50 +msgid "Create a secret using specified subcommand." +msgstr "Create a secret using specified subcommand." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:85 +msgid "Create a service account with the specified name" +msgstr "Create a service account with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:48 +msgid "Create a service using a specified subcommand" +msgstr "Create a service using a specified subcommand" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:49 +msgid "Create a service using a specified subcommand." +msgstr "Create a service using a specified subcommand." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:363 +msgid "Create an ExternalName service" +msgstr "Create an ExternalName service" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:145 +msgid "Create an ingress with the specified name" +msgstr "Create an ingress with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:60 +msgid "Create and run a particular image in a pod." +msgstr "Create and run a particular image in a pod." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:149 +msgid "Create debugging sessions for troubleshooting workloads and nodes" +msgstr "Create debugging sessions for troubleshooting workloads and nodes" + +#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:137 +msgid "" +"Delete resources by file names, stdin, resources and names, or by resources " +"and label selector" +msgstr "" +"Delete resources by file names, stdin, resources and names, or by resources " +"and label selector" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_cluster.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "Delete the specified cluster from the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:43 +msgid "Delete the specified cluster from the kubeconfig." +msgstr "Delete the specified cluster from the kubeconfig." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_context.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "Delete the specified context from the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:43 +msgid "Delete the specified context from the kubeconfig." +msgstr "Delete the specified context from the kubeconfig." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_user.go:64 +msgid "Delete the specified user from the kubeconfig" +msgstr "Delete the specified user from the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_user.go:65 +msgid "Delete the specified user from the kubeconfig." +msgstr "Delete the specified user from the kubeconfig." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L121 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:174 +msgid "Deny a certificate signing request" +msgstr "Deny a certificate signing request" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_contexts.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "Describe one or many contexts" + +#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:142 +msgid "Diff the live version against a would-be applied version" +msgstr "Diff the live version against a would-be applied version" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:65 +msgid "Display cluster information" +msgstr "Display cluster information" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_clusters.go#L40 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "Display clusters defined in the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:42 +msgid "Display clusters defined in the kubeconfig." +msgstr "Display clusters defined in the kubeconfig." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/view.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "Display merged kubeconfig settings or a specified kubeconfig file" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:50 +msgid "Display one or many contexts from the kubeconfig file." +msgstr "Display one or many contexts from the kubeconfig file." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/get.go#L107 +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:165 +msgid "Display one or many resources" +msgstr "Display one or many resources" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top.go:50 +msgid "Display resource (CPU/memory) usage" +msgstr "Display resource (CPU/memory) usage" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:81 +msgid "Display resource (CPU/memory) usage of nodes" +msgstr "Display resource (CPU/memory) usage of nodes" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:100 +msgid "Display resource (CPU/memory) usage of pods" +msgstr "Display resource (CPU/memory) usage of pods" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/current_context.go:51 +msgid "Display the current-context" +msgstr "Display the current-context" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_users.go:60 +msgid "Display users defined in the kubeconfig" +msgstr "Display users defined in the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_users.go:61 +msgid "Display users defined in the kubeconfig." +msgstr "Display users defined in the kubeconfig." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L176 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:184 +msgid "Drain node in preparation for maintenance" +msgstr "Drain node in preparation for maintenance" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:74 +msgid "Dump relevant information for debugging and diagnosis" +msgstr "Dump relevant information for debugging and diagnosis" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/edit.go#L100 +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:77 +msgid "Edit a resource on the server" +msgstr "Edit a resource on the server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_edit_last_applied.go:67 +msgid "Edit latest last-applied-configuration annotations of a resource/object" +msgstr "" +"Edit latest last-applied-configuration annotations of a resource/object" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L159 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:152 +msgid "Email for Docker registry" +msgstr "Email for Docker registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:169 +msgid "Environment variables to set in the container." +msgstr "Environment variables to set in the container." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/exec.go#L68 +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:89 +msgid "Execute a command in a container" +msgstr "Execute a command in a container" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:90 +msgid "Execute a command in a container." +msgstr "Execute a command in a container." + +#: staging/src/k8s.io/kubectl/pkg/cmd/wait/wait.go:115 +msgid "Experimental: Wait for a specific condition on one or many resources" +msgstr "Experimental: Wait for a specific condition on one or many resources" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:378 +msgid "External name of service" +msgstr "External name of service" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/portforward.go#L75 +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:109 +msgid "Forward one or more local ports to a pod" +msgstr "Forward one or more local ports to a pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:79 +msgid "Get documentation for a resource" +msgstr "Get documentation for a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/help.go#L36 +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:37 +msgid "Help about any command" +msgstr "Help about any command" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:151 +msgid "" +"IP to assign to the LoadBalancer. If empty, an ephemeral IP will be created " +"and used (cloud-provider specific)." +msgstr "" +"IP to assign to the LoadBalancer. If empty, an ephemeral IP will be created " +"and used (cloud-provider specific)." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L114 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:160 +msgid "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" +msgstr "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/annotate.go#L135 +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:157 +msgid "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/label.go#L132 +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:154 +msgid "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:164 +msgid "" +"If specified, everything after -- will be passed to the new container as " +"Args instead of Command." +msgstr "" +"If specified, everything after -- will be passed to the new container as " +"Args instead of Command." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:198 +msgid "If true, run the container in privileged mode." +msgstr "If true, run the container in privileged mode." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:174 +msgid "If true, suppress informational messages." +msgstr "If true, suppress informational messages." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:165 +msgid "" +"If true, wait for the container to start running, and then attach as if " +"'kubectl attach ...' were called. Default false, unless '-i/--stdin' is " +"set, in which case the default is true." +msgstr "" +"If true, wait for the container to start running, and then attach as if " +"'kubectl attach ...' were called. Default false, unless '-i/--stdin' is " +"set, in which case the default is true." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:173 +msgid "" +"Keep stdin open on the container(s) in the pod, even if nothing is attached." +msgstr "" +"Keep stdin open on the container(s) in the pod, even if nothing is attached." + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:90 +msgid "List all visible plugin executables on a user's PATH" +msgstr "List all visible plugin executables on a user's PATH" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout.go:54 +msgid "Manage the rollout of a resource" +msgstr "Manage the rollout of a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L127 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:98 +msgid "Mark node as schedulable" +msgstr "Mark node as schedulable" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:69 +msgid "Mark node as unschedulable" +msgstr "Mark node as unschedulable" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_pause.go#L73 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:83 +msgid "Mark the provided resource as paused" +msgstr "Mark the provided resource as paused" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L35 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:49 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:50 +msgid "Modify certificate resources." +msgstr "Modify certificate resources." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/config.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "Modify kubeconfig files" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L110 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:156 +msgid "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." +msgstr "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." + +#: staging/src/k8s.io/kubectl/pkg/cmd/alpha.go:43 +msgid "No alpha commands are available in this version of kubectl" +msgstr "No alpha commands are available in this version of kubectl" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/logs.go#L108 +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:174 +msgid "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." +msgstr "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/completion.go#L97 +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:112 +msgid "Output shell completion code for the specified shell (bash or zsh)" +msgstr "Output shell completion code for the specified shell (bash or zsh)" + +#: pkg/kubectl/cmd/convert/convert.go:105 +msgid "" +"Output the formatted object with the given group version (for ex: " +"'extensions/v1beta1')." +msgstr "" +"Output the formatted object with the given group version (for ex: " +"'extensions/v1beta1')." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L157 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:151 +msgid "Password for Docker registry authentication" +msgstr "Password for Docker registry authentication" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L226 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:110 +msgid "Path to PEM encoded public key certificate." +msgstr "Path to PEM encoded public key certificate." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L227 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:111 +msgid "Path to private key associated with given certificate." +msgstr "Path to private key associated with given certificate." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/scale.go#L82 +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:130 +msgid "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." +msgstr "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/version.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:73 +msgid "Print the client and server version information" +msgstr "Print the client and server version information" + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:74 +msgid "" +"Print the client and server version information for the current context." +msgstr "" +"Print the client and server version information for the current context." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/options.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:38 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:39 +msgid "Print the list of flags inherited by all commands" +msgstr "Print the list of flags inherited by all commands" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/logs.go#L86 +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:152 +msgid "Print the logs for a container in a pod" +msgstr "Print the logs for a container in a pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiresources.go:97 +msgid "Print the supported API resources on the server" +msgstr "Print the supported API resources on the server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiresources.go:98 +msgid "Print the supported API resources on the server." +msgstr "Print the supported API resources on the server." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:58 +msgid "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"" +msgstr "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:59 +msgid "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"." +msgstr "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"." + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:62 +msgid "Provides utilities for interacting with plugins" +msgstr "Provides utilities for interacting with plugins" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/rename_context.go:45 +msgid "Rename a context from the kubeconfig file" +msgstr "Rename a context from the kubeconfig file" + +#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:115 +msgid "Replace a resource by file name or stdin" +msgstr "Replace a resource by file name or stdin" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_restart.go:87 +msgid "Restart a resource" +msgstr "Restart a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_resume.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:87 +msgid "Resume a paused resource" +msgstr "Resume a paused resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L56 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:105 +msgid "Role this RoleBinding should reference" +msgstr "Role this RoleBinding should reference" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L94 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:152 +msgid "Run a particular image on the cluster" +msgstr "Run a particular image on the cluster" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/proxy.go#L68 +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:119 +msgid "Run a proxy to the Kubernetes API server" +msgstr "Run a proxy to the Kubernetes API server" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L161 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:153 +msgid "Server location for Docker registry" +msgstr "Server location for Docker registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_cluster.go:73 +msgid "Set a cluster entry in kubeconfig" +msgstr "Set a cluster entry in kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_context.go:61 +msgid "Set a context entry in kubeconfig" +msgstr "Set a context entry in kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:114 +msgid "Set a new size for a deployment, replica set, or replication controller" +msgstr "" +"Set a new size for a deployment, replica set, or replication controller" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_authinfo.go:152 +msgid "Set a user entry in kubeconfig" +msgstr "Set a user entry in kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/set.go:74 +msgid "Set an individual value in a kubeconfig file" +msgstr "Set an individual value in a kubeconfig file" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:39 +msgid "Set specific features on objects" +msgstr "Set specific features on objects" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/use_context.go:52 +msgid "Set the current-context in a kubeconfig file" +msgstr "Set the current-context in a kubeconfig file" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:101 +msgid "" +"Set the last-applied-configuration annotation on a live object to match the " +"contents of a file" +msgstr "" +"Set the last-applied-configuration annotation on a live object to match the " +"contents of a file" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_selector.go#L81 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:104 +msgid "Set the selector on a resource" +msgstr "Set the selector on a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/describe.go#L80 +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:107 +msgid "Show details of a specific resource or group of resources" +msgstr "Show details of a specific resource or group of resources" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_status.go#L57 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:102 +msgid "Show the status of the rollout" +msgstr "Show the status of the rollout" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L108 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:154 +msgid "Synonym for --target-port" +msgstr "Synonym for --target-port" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:134 +msgid "" +"Take a replication controller, service, deployment or pod and expose it as a " +"new Kubernetes service" +msgstr "" +"Take a replication controller, service, deployment or pod and expose it as a " +"new Kubernetes service" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L114 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:174 +msgid "The image for the container to run." +msgstr "The image for the container to run." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L116 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:176 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" +msgstr "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:172 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server." +msgstr "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:112 +msgid "" +"The maximum number or percentage of unavailable pods this budget requires." +msgstr "" +"The maximum number or percentage of unavailable pods this budget requires." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:111 +msgid "" +"The minimum number or percentage of available pods this budget requires." +msgstr "" +"The minimum number or percentage of available pods this budget requires." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L113 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:159 +msgid "The name for the newly created object." +msgstr "The name for the newly created object." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/autoscale.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:125 +msgid "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." +msgstr "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L98 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:147 +msgid "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." +msgstr "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L99 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:148 +msgid "The network protocol for the service to be created. Default is 'TCP'." +msgstr "The network protocol for the service to be created. Default is 'TCP'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L100 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:149 +msgid "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" +msgstr "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:182 +msgid "The port that this container exposes." +msgstr "The port that this container exposes." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L131 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:194 +msgid "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." +msgstr "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L130 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:192 +msgid "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." +msgstr "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:190 +msgid "" +"The restart policy for this Pod. Legal values [Always, OnFailure, Never]." +msgstr "" +"The restart policy for this Pod. Legal values [Always, OnFailure, Never]." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L87 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:155 +msgid "The type of secret to create" +msgstr "The type of secret to create" + +#: staging/src/k8s.io/kubectl/pkg/cmd/alpha.go:33 +msgid "" +"These commands correspond to alpha features that are not enabled in " +"Kubernetes clusters by default." +msgstr "" +"These commands correspond to alpha features that are not enabled in " +"Kubernetes clusters by default." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:150 +msgid "" +"Type for this service: ClusterIP, NodePort, LoadBalancer, or ExternalName. " +"Default is 'ClusterIP'." +msgstr "" +"Type for this service: ClusterIP, NodePort, LoadBalancer, or ExternalName. " +"Default is 'ClusterIP'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_undo.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:87 +msgid "Undo a previous rollout" +msgstr "Undo a previous rollout" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/unset.go:59 +msgid "Unset an individual value in a kubeconfig file" +msgstr "Unset an individual value in a kubeconfig file" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_env.go:154 +msgid "Update environment variables on a pod template" +msgstr "Update environment variables on a pod template" + +#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:115 +msgid "Update fields of a resource" +msgstr "Update fields of a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_resources.go#L101 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:116 +msgid "Update resource requests/limits on objects with pod templates" +msgstr "Update resource requests/limits on objects with pod templates" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "Update the annotations on a resource" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_image.go:110 +msgid "Update the image of a pod template" +msgstr "Update the image of a pod template" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/label.go#L109 +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:133 +msgid "Update the labels on a resource" +msgstr "Update the labels on a resource" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:102 +msgid "Update the service account of a resource" +msgstr "Update the service account of a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/taint.go#L88 +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:109 +msgid "Update the taints on one or more nodes" +msgstr "Update the taints on one or more nodes" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_subject.go:99 +msgid "" +"Update the user, group, or service account in a role binding or cluster role " +"binding" +msgstr "" +"Update the user, group, or service account in a role binding or cluster role " +"binding" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L155 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:150 +msgid "Username for Docker registry authentication" +msgstr "Username for Docker registry authentication" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_history.go#L51 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:83 +msgid "View rollout history" +msgstr "View rollout history" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_view_last_applied.go:77 +msgid "" +"View the latest last-applied-configuration annotations of a resource/object" +msgstr "" +"View the latest last-applied-configuration annotations of a resource/object" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:171 +msgid "" +"When used with '--copy-to', a list of name=image pairs for changing " +"container images, similar to how 'kubectl set image' works." +msgstr "" +"When used with '--copy-to', a list of name=image pairs for changing " +"container images, similar to how 'kubectl set image' works." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:168 +msgid "When used with '--copy-to', delete the original Pod." +msgstr "When used with '--copy-to', delete the original Pod." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:176 +msgid "" +"When used with '--copy-to', enable process namespace sharing in the copy." +msgstr "" +"When used with '--copy-to', enable process namespace sharing in the copy." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:175 +msgid "" +"When used with '--copy-to', schedule the copy of target Pod on the same node." +msgstr "" +"When used with '--copy-to', schedule the copy of target Pod on the same node." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:177 +msgid "" +"When using an ephemeral container, target processes in this container name." +msgstr "" +"When using an ephemeral container, target processes in this container name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/clusterinfo_dump.go#L45 +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:85 +msgid "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" +msgstr "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:108 +msgid "" +"description is an arbitrary string that usually provides guidelines on when " +"this priority class should be used." +msgstr "" +"description is an arbitrary string that usually provides guidelines on when " +"this priority class should be used." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run_test.go:88 +msgid "dummy restart flag)" +msgstr "dummy restart flag)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:107 +msgid "" +"global-default specifies whether this PriorityClass should be considered as " +"the default priority." +msgstr "" +"global-default specifies whether this PriorityClass should be considered as " +"the default priority." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/cmd.go#L217 +#: staging/src/k8s.io/kubectl/pkg/cmd/cmd.go:227 +msgid "kubectl controls the Kubernetes cluster manager" +msgstr "kubectl controls the Kubernetes cluster manager" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:45 +msgid "" +"pod (po), service (svc), replicationcontroller (rc), deployment (deploy), " +"replicaset (rs)" +msgstr "" +"pod (po), service (svc), replicationcontroller (rc), deployment (deploy), " +"replicaset (rs)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:109 +msgid "" +"preemption-policy is the policy for preempting pods with lower priority." +msgstr "" +"preemption-policy is the policy for preempting pods with lower priority." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:41 +msgid "" +"replicationcontroller (rc), deployment (deploy), daemonset (ds), job, " +"replicaset (rs), statefulset" +msgstr "" +"replicationcontroller (rc), deployment (deploy), daemonset (ds), job, " +"replicaset (rs), statefulset" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:106 +msgid "the value of this priority class." +msgstr "the value of this priority class." diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/en_US/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/en_US/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..9c0c708fcd Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/en_US/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/en_US/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/en_US/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..90ea088d67 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/en_US/LC_MESSAGES/k8s.po @@ -0,0 +1,5085 @@ +# Test translations for unit tests. +# Copyright (C) 2016 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR brendan.d.burns@gmail.com, 2016. +# +msgid "" +msgstr "" +"Project-Id-Version: gettext-go-examples-hello\n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2017-03-14 21:33-0800\n" +"Last-Translator: Brendan Burns \n" +"Language-Team: \n" +"Language: en\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 1.6.10\n" +"X-Poedit-SourceCharset: UTF-8\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:138 +msgid "" +"\n" +"\t\t\t# Approve CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate approve csr-sqgzp\n" +"\t\t" +msgstr "" +"\n" +"\t\t\t# Approve CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate approve csr-sqgzp\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:182 +msgid "" +"\n" +"\t\t\t# Deny CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate deny csr-sqgzp\n" +"\t\t" +msgstr "" +"\n" +"\t\t\t# Deny CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate deny csr-sqgzp\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:43 +msgid "" +"\n" +"\t\t\tModify kubeconfig files using subcommands like \"kubectl config set " +"current-context my-context\"\n" +"\n" +"\t\t\tThe loading order follows these rules:\n" +"\n" +"\t\t\t1. If the --" +msgstr "" +"\n" +"\t\t\tModify kubeconfig files using subcommands like \"kubectl config set " +"current-context my-context\"\n" +"\n" +"\t\t\tThe loading order follows these rules:\n" +"\n" +"\t\t\t1. If the --" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:44 +msgid "" +"\n" +"\t\t # Create a cluster role binding for user1, user2, and group1 using the " +"cluster-admin cluster role\n" +"\t\t kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-" +"admin --user=user1 --user=user2 --group=group1" +msgstr "" +"\n" +"\t\t # Create a cluster role binding for user1, user2, and group1 using the " +"cluster-admin cluster role\n" +"\t\t kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-" +"admin --user=user1 --user=user2 --group=group1" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:58 +msgid "" +"\n" +"\t\t # Create a new config map named my-config based on folder bar\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config with specified keys instead " +"of file basenames on disk\n" +"\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/file1." +"txt --from-file=key2=/path/to/bar/file2.txt\n" +"\n" +"\t\t # Create a new config map named my-config with key1=config1 and " +"key2=config2\n" +"\t\t kubectl create configmap my-config --from-literal=key1=config1 --from-" +"literal=key2=config2\n" +"\n" +"\t\t # Create a new config map named my-config from the key=value pairs in " +"the file\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config from an env file\n" +"\t\t kubectl create configmap my-config --from-env-file=path/to/bar.env" +msgstr "" +"\n" +"\t\t # Create a new config map named my-config based on folder bar\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config with specified keys instead " +"of file basenames on disk\n" +"\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/file1." +"txt --from-file=key2=/path/to/bar/file2.txt\n" +"\n" +"\t\t # Create a new config map named my-config with key1=config1 and " +"key2=config2\n" +"\t\t kubectl create configmap my-config --from-literal=key1=config1 --from-" +"literal=key2=config2\n" +"\n" +"\t\t # Create a new config map named my-config from the key=value pairs in " +"the file\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config from an env file\n" +"\t\t kubectl create configmap my-config --from-env-file=path/to/bar.env" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:43 +msgid "" +"\n" +"\t\t # Create a role binding for user1, user2, and group1 using the admin " +"cluster role\n" +"\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +"user=user2 --group=group1" +msgstr "" +"\n" +"\t\t # Create a role binding for user1, user2, and group1 using the admin " +"cluster role\n" +"\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +"user=user2 --group=group1" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:56 +msgid "" +"\n" +"\t\t # If you don't already have a .dockercfg file, you can create a " +"dockercfg secret directly by using:\n" +"\t\t kubectl create secret docker-registry my-secret --docker-" +"server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +"password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL\n" +"\n" +"\t\t # Create a new secret named my-secret from ~/.docker/config.json\n" +"\t\t kubectl create secret docker-registry my-secret --from-file=." +"dockerconfigjson=path/to/.docker/config.json" +msgstr "" +"\n" +"\t\t # If you don't already have a .dockercfg file, you can create a " +"dockercfg secret directly by using:\n" +"\t\t kubectl create secret docker-registry my-secret --docker-" +"server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +"password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL\n" +"\n" +"\t\t # Create a new secret named my-secret from ~/.docker/config.json\n" +"\t\t kubectl create secret docker-registry my-secret --from-file=." +"dockerconfigjson=path/to/.docker/config.json" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:62 +msgid "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" +msgstr "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:45 +msgid "" +"\n" +"\t\t# !!!Important Note!!!\n" +"\t\t# Requires that the 'tar' binary is present in your container\n" +"\t\t# image. If 'tar' is not present, 'kubectl cp' will fail.\n" +"\t\t#\n" +"\t\t# For advanced use cases, such as symlinks, wildcard expansion or\n" +"\t\t# file mode preservation, consider using 'kubectl exec'.\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\ttar cf - /tmp/foo | kubectl exec -i -n -- " +"tar xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl exec -n -- tar cf - /tmp/foo | tar " +"xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in " +"the default namespace\n" +"\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific " +"container\n" +"\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl cp /:/tmp/foo /tmp/bar" +msgstr "" +"\n" +"\t\t# !!!Important Note!!!\n" +"\t\t# Requires that the 'tar' binary is present in your container\n" +"\t\t# image. If 'tar' is not present, 'kubectl cp' will fail.\n" +"\t\t#\n" +"\t\t# For advanced use cases, such as symlinks, wildcard expansion or\n" +"\t\t# file mode preservation, consider using 'kubectl exec'.\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\ttar cf - /tmp/foo | kubectl exec -i -n -- " +"tar xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl exec -n -- tar cf - /tmp/foo | tar " +"xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in " +"the default namespace\n" +"\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific " +"container\n" +"\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl cp /:/tmp/foo /tmp/bar" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:119 +msgid "" +"\n" +"\t\t# Apply the configuration in pod.json to a pod\n" +"\t\tkubectl apply -f ./pod.json\n" +"\n" +"\t\t# Apply resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl apply -k dir/\n" +"\n" +"\t\t# Apply the JSON passed into stdin to a pod\n" +"\t\tcat pod.json | kubectl apply -f -\n" +"\n" +"\t\t# Note: --prune is still in Alpha\n" +"\t\t# Apply the configuration in manifest.yaml that matches label app=nginx " +"and delete all other resources that are not in the file and match label " +"app=nginx\n" +"\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +"\n" +"\t\t# Apply the configuration in manifest.yaml and delete all the other " +"config maps that are not in the file\n" +"\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/v1/" +"ConfigMap" +msgstr "" +"\n" +"\t\t# Apply the configuration in pod.json to a pod\n" +"\t\tkubectl apply -f ./pod.json\n" +"\n" +"\t\t# Apply resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl apply -k dir/\n" +"\n" +"\t\t# Apply the JSON passed into stdin to a pod\n" +"\t\tcat pod.json | kubectl apply -f -\n" +"\n" +"\t\t# Note: --prune is still in Alpha\n" +"\t\t# Apply the configuration in manifest.yaml that matches label app=nginx " +"and delete all other resources that are not in the file and match label " +"app=nginx\n" +"\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +"\n" +"\t\t# Apply the configuration in manifest.yaml and delete all the other " +"config maps that are not in the file\n" +"\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/v1/" +"ConfigMap" + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:48 +#, c-format +msgid "" +"\n" +"\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 and " +"10, no target CPU utilization specified so a default autoscaling policy will " +"be used\n" +"\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +"\n" +"\t\t# Auto scale a replication controller \"foo\", with the number of pods " +"between 1 and 5, target CPU utilization at 80%\n" +"\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" +msgstr "" +"\n" +"\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 and " +"10, no target CPU utilization specified so a default autoscaling policy will " +"be used\n" +"\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +"\n" +"\t\t# Auto scale a replication controller \"foo\", with the number of pods " +"between 1 and 5, target CPU utilization at 80%\n" +"\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" + +#: pkg/kubectl/cmd/convert/convert.go:51 +msgid "" +"\n" +"\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +"\t\tkubectl convert -f pod.yaml\n" +"\n" +"\t\t# Convert the live state of the resource specified by 'pod.yaml' to the " +"latest version\n" +"\t\t# and print to stdout in JSON format.\n" +"\t\tkubectl convert -f pod.yaml --local -o json\n" +"\n" +"\t\t# Convert all files under current directory to latest version and create " +"them all.\n" +"\t\tkubectl convert -f . | kubectl create -f -" +msgstr "" +"\n" +"\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +"\t\tkubectl convert -f pod.yaml\n" +"\n" +"\t\t# Convert the live state of the resource specified by 'pod.yaml' to the " +"latest version\n" +"\t\t# and print to stdout in JSON format.\n" +"\t\tkubectl convert -f pod.yaml --local -o json\n" +"\n" +"\t\t# Convert all files under current directory to latest version and create " +"them all.\n" +"\t\tkubectl convert -f . | kubectl create -f -" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:41 +msgid "" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" that allows user to perform " +"\"get\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +"resource=pods\n" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" with ResourceName " +"specified\n" +"\t\tkubectl create clusterrole pod-reader --verb=get --resource=pods --" +"resource-name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with API Group specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=rs." +"extensions\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with SubResource specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=pods," +"pods/status\n" +"\n" +"\t\t# Create a cluster role name \"foo\" with NonResourceURL specified\n" +"\t\tkubectl create clusterrole \"foo\" --verb=get --non-resource-url=/logs/" +"*\n" +"\n" +"\t\t# Create a cluster role name \"monitoring\" with AggregationRule " +"specified\n" +"\t\tkubectl create clusterrole monitoring --aggregation-rule=\"rbac.example." +"com/aggregate-to-monitoring=true\"" +msgstr "" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" that allows user to perform " +"\"get\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +"resource=pods\n" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" with ResourceName " +"specified\n" +"\t\tkubectl create clusterrole pod-reader --verb=get --resource=pods --" +"resource-name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with API Group specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=rs." +"extensions\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with SubResource specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=pods," +"pods/status\n" +"\n" +"\t\t# Create a cluster role name \"foo\" with NonResourceURL specified\n" +"\t\tkubectl create clusterrole \"foo\" --verb=get --non-resource-url=/logs/" +"*\n" +"\n" +"\t\t# Create a cluster role name \"monitoring\" with AggregationRule " +"specified\n" +"\t\tkubectl create clusterrole monitoring --aggregation-rule=\"rbac.example." +"com/aggregate-to-monitoring=true\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:43 +msgid "" +"\n" +"\t\t# Create a job\n" +"\t\tkubectl create job my-job --image=busybox\n" +"\n" +"\t\t# Create a job with a command\n" +"\t\tkubectl create job my-job --image=busybox -- date\n" +"\n" +"\t\t# Create a job from a cron job named \"a-cronjob\"\n" +"\t\tkubectl create job test-job --from=cronjob/a-cronjob" +msgstr "" +"\n" +"\t\t# Create a job\n" +"\t\tkubectl create job my-job --image=busybox\n" +"\n" +"\t\t# Create a job with a command\n" +"\t\tkubectl create job my-job --image=busybox -- date\n" +"\n" +"\t\t# Create a job from a cron job named \"a-cronjob\"\n" +"\t\tkubectl create job test-job --from=cronjob/a-cronjob" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:44 +msgid "" +"\n" +"\t\t# Create a new resource quota named my-quota\n" +"\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3," +"replicationcontrollers=2,resourcequotas=1,secrets=5," +"persistentvolumeclaims=10\n" +"\n" +"\t\t# Create a new resource quota named best-effort\n" +"\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" +msgstr "" +"\n" +"\t\t# Create a new resource quota named my-quota\n" +"\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3," +"replicationcontrollers=2,resourcequotas=1,secrets=5," +"persistentvolumeclaims=10\n" +"\n" +"\t\t# Create a new resource quota named best-effort\n" +"\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:44 +#, c-format +msgid "" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=rails label\n" +"\t\t# and require at least one of them being available at any point in time\n" +"\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +"available=1\n" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=nginx label\n" +"\t\t# and require at least half of the pods selected to be available at any " +"point in time\n" +"\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" +msgstr "" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=rails label\n" +"\t\t# and require at least one of them being available at any point in time\n" +"\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +"available=1\n" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=nginx label\n" +"\t\t# and require at least half of the pods selected to be available at any " +"point in time\n" +"\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:76 +msgid "" +"\n" +"\t\t# Create a pod using the data in pod.json\n" +"\t\tkubectl create -f ./pod.json\n" +"\n" +"\t\t# Create a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl create -f -\n" +"\n" +"\t\t# Edit the data in docker-registry.yaml in JSON then create the resource " +"using the edited data\n" +"\t\tkubectl create -f docker-registry.yaml --edit -o json" +msgstr "" +"\n" +"\t\t# Create a pod using the data in pod.json\n" +"\t\tkubectl create -f ./pod.json\n" +"\n" +"\t\t# Create a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl create -f -\n" +"\n" +"\t\t# Edit the data in docker-registry.yaml in JSON then create the resource " +"using the edited data\n" +"\t\tkubectl create -f docker-registry.yaml --edit -o json" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:43 +msgid "" +"\n" +"\t\t# Create a priority class named high-priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\"\n" +"\n" +"\t\t# Create a priority class named default-priority that is considered as " +"the global default priority\n" +"\t\tkubectl create priorityclass default-priority --value=1000 --global-" +"default=true --description=\"default priority\"\n" +"\n" +"\t\t# Create a priority class named high-priority that cannot preempt pods " +"with lower priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\" --preemption-policy=\"Never\"" +msgstr "" +"\n" +"\t\t# Create a priority class named high-priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\"\n" +"\n" +"\t\t# Create a priority class named default-priority that is considered as " +"the global default priority\n" +"\t\tkubectl create priorityclass default-priority --value=1000 --global-" +"default=true --description=\"default priority\"\n" +"\n" +"\t\t# Create a priority class named high-priority that cannot preempt pods " +"with lower priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\" --preemption-policy=\"Never\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:46 +msgid "" +"\n" +"\t\t# Create a role named \"pod-reader\" that allows user to perform \"get" +"\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +"resource=pods\n" +"\n" +"\t\t# Create a role named \"pod-reader\" with ResourceName specified\n" +"\t\tkubectl create role pod-reader --verb=get --resource=pods --resource-" +"name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a role named \"foo\" with API Group specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=rs.extensions\n" +"\n" +"\t\t# Create a role named \"foo\" with SubResource specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=pods,pods/status" +msgstr "" +"\n" +"\t\t# Create a role named \"pod-reader\" that allows user to perform \"get" +"\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +"resource=pods\n" +"\n" +"\t\t# Create a role named \"pod-reader\" with ResourceName specified\n" +"\t\tkubectl create role pod-reader --verb=get --resource=pods --resource-" +"name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a role named \"foo\" with API Group specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=rs.extensions\n" +"\n" +"\t\t# Create a role named \"foo\" with SubResource specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=pods,pods/status" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:61 +msgid "" +"\n" +"\t\t# Create a service for a replicated nginx, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a replication controller identified by type and " +"name specified in \"nginx-controller.yaml\", which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +"the name \"frontend\"\n" +"\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +"\n" +"\t\t# Create a second service based on the above service, exposing the " +"container port 8443 as port 443 with the name \"nginx-https\"\n" +"\t\tkubectl expose service nginx --port=443 --target-port=8443 --name=nginx-" +"https\n" +"\n" +"\t\t# Create a service for a replicated streaming application on port 4100 " +"balancing UDP traffic and named 'video-stream'.\n" +"\t\tkubectl expose rc streamer --port=4100 --protocol=UDP --name=video-" +"stream\n" +"\n" +"\t\t# Create a service for a replicated nginx using replica set, which " +"serves on port 80 and connects to the containers on port 8000\n" +"\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for an nginx deployment, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose deployment nginx --port=80 --target-port=8000" +msgstr "" +"\n" +"\t\t# Create a service for a replicated nginx, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a replication controller identified by type and " +"name specified in \"nginx-controller.yaml\", which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +"the name \"frontend\"\n" +"\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +"\n" +"\t\t# Create a second service based on the above service, exposing the " +"container port 8443 as port 443 with the name \"nginx-https\"\n" +"\t\tkubectl expose service nginx --port=443 --target-port=8443 --name=nginx-" +"https\n" +"\n" +"\t\t# Create a service for a replicated streaming application on port 4100 " +"balancing UDP traffic and named 'video-stream'.\n" +"\t\tkubectl expose rc streamer --port=4100 --protocol=UDP --name=video-" +"stream\n" +"\n" +"\t\t# Create a service for a replicated nginx using replica set, which " +"serves on port 80 and connects to the containers on port 8000\n" +"\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for an nginx deployment, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose deployment nginx --port=80 --target-port=8000" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:64 +msgid "" +"\n" +"\t\t# Create a single ingress called 'simple' that directs requests to foo." +"com/bar to svc\n" +"\t\t# svc1:8080 with a tls secret \"my-cert\"\n" +"\t\tkubectl create ingress simple --rule=\"foo.com/bar=svc1:8080,tls=my-cert" +"\"\n" +"\n" +"\t\t# Create a catch all ingress of \"/path\" pointing to service svc:port " +"and Ingress Class as \"otheringress\"\n" +"\t\tkubectl create ingress catch-all --class=otheringress --rule=\"/path=svc:" +"port\"\n" +"\n" +"\t\t# Create an ingress with two annotations: ingress.annotation1 and " +"ingress.annotations2\n" +"\t\tkubectl create ingress annotated --class=default --rule=\"foo.com/" +"bar=svc:port\" \\n\t\t\t--annotation ingress.annotation1=foo \\n\t\t\t--" +"annotation ingress.annotation2=bla\n" +"\n" +"\t\t# Create an ingress with the same host and multiple paths\n" +"\t\tkubectl create ingress multipath --class=default \\n\t\t\t--rule=\"foo." +"com/=svc:port\" \\n\t\t\t--rule=\"foo.com/admin/=svcadmin:portadmin\"\n" +"\n" +"\t\t# Create an ingress with multiple hosts and the pathType as Prefix\n" +"\t\tkubectl create ingress ingress1 --class=default \\n\t\t\t--rule=\"foo." +"com/path*=svc:8080\" \\n\t\t\t--rule=\"bar.com/admin*=svc2:http\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using the default ingress " +"certificate and different path types\n" +"\t\tkubectl create ingress ingtls --class=default \\n\t\t --rule=\"foo.com/" +"=svc:https,tls\" \\n\t\t --rule=\"foo.com/path/subpath*=othersvc:8080\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using a specific secret and " +"pathType as Prefix\n" +"\t\tkubectl create ingress ingsecret --class=default \\n\t\t --rule=\"foo." +"com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t# Create an ingress with a default backend\n" +"\t\tkubectl create ingress ingdefault --class=default \\n\t\t --default-" +"backend=defaultsvc:http \\n\t\t --rule=\"foo.com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t" +msgstr "" +"\n" +"\t\t# Create a single ingress called 'simple' that directs requests to foo." +"com/bar to svc\n" +"\t\t# svc1:8080 with a tls secret \"my-cert\"\n" +"\t\tkubectl create ingress simple --rule=\"foo.com/bar=svc1:8080,tls=my-cert" +"\"\n" +"\n" +"\t\t# Create a catch all ingress of \"/path\" pointing to service svc:port " +"and Ingress Class as \"otheringress\"\n" +"\t\tkubectl create ingress catch-all --class=otheringress --rule=\"/path=svc:" +"port\"\n" +"\n" +"\t\t# Create an ingress with two annotations: ingress.annotation1 and " +"ingress.annotations2\n" +"\t\tkubectl create ingress annotated --class=default --rule=\"foo.com/" +"bar=svc:port\" \\n\t\t\t--annotation ingress.annotation1=foo \\n\t\t\t--" +"annotation ingress.annotation2=bla\n" +"\n" +"\t\t# Create an ingress with the same host and multiple paths\n" +"\t\tkubectl create ingress multipath --class=default \\n\t\t\t--rule=\"foo." +"com/=svc:port\" \\n\t\t\t--rule=\"foo.com/admin/=svcadmin:portadmin\"\n" +"\n" +"\t\t# Create an ingress with multiple hosts and the pathType as Prefix\n" +"\t\tkubectl create ingress ingress1 --class=default \\n\t\t\t--rule=\"foo." +"com/path*=svc:8080\" \\n\t\t\t--rule=\"bar.com/admin*=svc2:http\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using the default ingress " +"certificate and different path types\n" +"\t\tkubectl create ingress ingtls --class=default \\n\t\t --rule=\"foo.com/" +"=svc:https,tls\" \\n\t\t --rule=\"foo.com/path/subpath*=othersvc:8080\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using a specific secret and " +"pathType as Prefix\n" +"\t\tkubectl create ingress ingsecret --class=default \\n\t\t --rule=\"foo." +"com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t# Create an ingress with a default backend\n" +"\t\tkubectl create ingress ingdefault --class=default \\n\t\t --default-" +"backend=defaultsvc:http \\n\t\t --rule=\"foo.com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:74 +msgid "" +"\n" +"\t\t# Create an interactive debugging session in pod mypod and immediately " +"attach to it.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug mypod -it --image=busybox\n" +"\n" +"\t\t# Create a debug container named debugger using a custom automated " +"debugging image.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug --image=myproj/debug-tools -c debugger mypod\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and attach to it\n" +"\t\tkubectl debug mypod -it --image=busybox --copy-to=my-debugger\n" +"\n" +"\t\t# Create a copy of mypod changing the command of mycontainer\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --container=mycontainer -- " +"sh\n" +"\n" +"\t\t# Create a copy of mypod changing all container images to busybox\n" +"\t\tkubectl debug mypod --copy-to=my-debugger --set-image=*=busybox\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and changing container " +"images\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --image=debian --set-" +"image=app=app:debug,sidecar=sidecar:debug\n" +"\n" +"\t\t# Create an interactive debugging session on a node and immediately " +"attach to it.\n" +"\t\t# The container will run in the host namespaces and the host's " +"filesystem will be mounted at /host\n" +"\t\tkubectl debug node/mynode -it --image=busybox\n" +msgstr "" +"\n" +"\t\t# Create an interactive debugging session in pod mypod and immediately " +"attach to it.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug mypod -it --image=busybox\n" +"\n" +"\t\t# Create a debug container named debugger using a custom automated " +"debugging image.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug --image=myproj/debug-tools -c debugger mypod\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and attach to it\n" +"\t\tkubectl debug mypod -it --image=busybox --copy-to=my-debugger\n" +"\n" +"\t\t# Create a copy of mypod changing the command of mycontainer\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --container=mycontainer -- " +"sh\n" +"\n" +"\t\t# Create a copy of mypod changing all container images to busybox\n" +"\t\tkubectl debug mypod --copy-to=my-debugger --set-image=*=busybox\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and changing container " +"images\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --image=debian --set-" +"image=app=app:debug,sidecar=sidecar:debug\n" +"\n" +"\t\t# Create an interactive debugging session on a node and immediately " +"attach to it.\n" +"\t\t# The container will run in the host namespaces and the host's " +"filesystem will be mounted at /host\n" +"\t\tkubectl debug node/mynode -it --image=busybox\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:74 +msgid "" +"\n" +"\t\t# Delete a pod using the type and name specified in pod.json\n" +"\t\tkubectl delete -f ./pod.json\n" +"\n" +"\t\t# Delete resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl delete -k dir\n" +"\n" +"\t\t# Delete a pod based on the type and name in the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl delete -f -\n" +"\n" +"\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +"\t\tkubectl delete pod,service baz foo\n" +"\n" +"\t\t# Delete pods and services with label name=myLabel\n" +"\t\tkubectl delete pods,services -l name=myLabel\n" +"\n" +"\t\t# Delete a pod with minimal delay\n" +"\t\tkubectl delete pod foo --now\n" +"\n" +"\t\t# Force delete a pod on a dead node\n" +"\t\tkubectl delete pod foo --force\n" +"\n" +"\t\t# Delete all pods\n" +"\t\tkubectl delete pods --all" +msgstr "" +"\n" +"\t\t# Delete a pod using the type and name specified in pod.json\n" +"\t\tkubectl delete -f ./pod.json\n" +"\n" +"\t\t# Delete resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl delete -k dir\n" +"\n" +"\t\t# Delete a pod based on the type and name in the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl delete -f -\n" +"\n" +"\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +"\t\tkubectl delete pod,service baz foo\n" +"\n" +"\t\t# Delete pods and services with label name=myLabel\n" +"\t\tkubectl delete pods,services -l name=myLabel\n" +"\n" +"\t\t# Delete a pod with minimal delay\n" +"\t\tkubectl delete pod foo --now\n" +"\n" +"\t\t# Force delete a pod on a dead node\n" +"\t\tkubectl delete pod foo --force\n" +"\n" +"\t\t# Delete all pods\n" +"\t\tkubectl delete pods --all" + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:51 +msgid "" +"\n" +"\t\t# Describe a node\n" +"\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +"\n" +"\t\t# Describe a pod\n" +"\t\tkubectl describe pods/nginx\n" +"\n" +"\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +"\t\tkubectl describe -f pod.json\n" +"\n" +"\t\t# Describe all pods\n" +"\t\tkubectl describe pods\n" +"\n" +"\t\t# Describe pods by label name=myLabel\n" +"\t\tkubectl describe po -l name=myLabel\n" +"\n" +"\t\t# Describe all pods managed by the 'frontend' replication controller (rc-" +"created pods\n" +"\t\t# get the name of the rc as a prefix in the pod the name)\n" +"\t\tkubectl describe pods frontend" +msgstr "" +"\n" +"\t\t# Describe a node\n" +"\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +"\n" +"\t\t# Describe a pod\n" +"\t\tkubectl describe pods/nginx\n" +"\n" +"\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +"\t\tkubectl describe -f pod.json\n" +"\n" +"\t\t# Describe all pods\n" +"\t\tkubectl describe pods\n" +"\n" +"\t\t# Describe pods by label name=myLabel\n" +"\t\tkubectl describe po -l name=myLabel\n" +"\n" +"\t\t# Describe all pods managed by the 'frontend' replication controller (rc-" +"created pods\n" +"\t\t# get the name of the rc as a prefix in the pod the name)\n" +"\t\tkubectl describe pods frontend" + +#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:76 +msgid "" +"\n" +"\t\t# Diff resources included in pod.json\n" +"\t\tkubectl diff -f pod.json\n" +"\n" +"\t\t# Diff file read from stdin\n" +"\t\tcat service.yaml | kubectl diff -f -" +msgstr "" +"\n" +"\t\t# Diff resources included in pod.json\n" +"\t\tkubectl diff -f pod.json\n" +"\n" +"\t\t# Diff file read from stdin\n" +"\t\tcat service.yaml | kubectl diff -f -" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:138 +msgid "" +"\n" +"\t\t# Drain node \"foo\", even if there are pods not managed by a " +"replication controller, replica set, job, daemon set or stateful set on it\n" +"\t\tkubectl drain foo --force\n" +"\n" +"\t\t# As above, but abort if there are pods not managed by a replication " +"controller, replica set, job, daemon set or stateful set, and use a grace " +"period of 15 minutes\n" +"\t\tkubectl drain foo --grace-period=900" +msgstr "" +"\n" +"\t\t# Drain node \"foo\", even if there are pods not managed by a " +"replication controller, replica set, job, daemon set or stateful set on it\n" +"\t\tkubectl drain foo --force\n" +"\n" +"\t\t# As above, but abort if there are pods not managed by a replication " +"controller, replica set, job, daemon set or stateful set, and use a grace " +"period of 15 minutes\n" +"\t\tkubectl drain foo --grace-period=900" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:55 +msgid "" +"\n" +"\t\t# Edit the service named 'docker-registry'\n" +"\t\tkubectl edit svc/docker-registry\n" +"\n" +"\t\t# Use an alternative editor\n" +"\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +"\n" +"\t\t# Edit the job 'myjob' in JSON using the v1 API format\n" +"\t\tkubectl edit job.v1.batch/myjob -o json\n" +"\n" +"\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +"config in its annotation\n" +"\t\tkubectl edit deployment/mydeployment -o yaml --save-config" +msgstr "" +"\n" +"\t\t# Edit the service named 'docker-registry'\n" +"\t\tkubectl edit svc/docker-registry\n" +"\n" +"\t\t# Use an alternative editor\n" +"\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +"\n" +"\t\t# Edit the job 'myjob' in JSON using the v1 API format\n" +"\t\tkubectl edit job.v1.batch/myjob -o json\n" +"\n" +"\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +"config in its annotation\n" +"\t\tkubectl edit deployment/mydeployment -o yaml --save-config" + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:44 +msgid "" +"\n" +"\t\t# Get output from running pod mypod; use the 'kubectl.kubernetes.io/" +"default-container' annotation\n" +"\t\t# for selecting the container to be attached or the first container in " +"the pod will be chosen\n" +"\t\tkubectl attach mypod\n" +"\n" +"\t\t# Get output from ruby-container from pod mypod\n" +"\t\tkubectl attach mypod -c ruby-container\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl attach mypod -c ruby-container -i -t\n" +"\n" +"\t\t# Get output from the first pod of a replica set named nginx\n" +"\t\tkubectl attach rs/nginx\n" +"\t\t" +msgstr "" +"\n" +"\t\t# Get output from running pod mypod; use the 'kubectl.kubernetes.io/" +"default-container' annotation\n" +"\t\t# for selecting the container to be attached or the first container in " +"the pod will be chosen\n" +"\t\tkubectl attach mypod\n" +"\n" +"\t\t# Get output from ruby-container from pod mypod\n" +"\t\tkubectl attach mypod -c ruby-container\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl attach mypod -c ruby-container -i -t\n" +"\n" +"\t\t# Get output from the first pod of a replica set named nginx\n" +"\t\tkubectl attach rs/nginx\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:48 +msgid "" +"\n" +"\t\t# Get output from running the 'date' command from pod mypod, using the " +"first container by default\n" +"\t\tkubectl exec mypod -- date\n" +"\n" +"\t\t# Get output from running the 'date' command in ruby-container from pod " +"mypod\n" +"\t\tkubectl exec mypod -c ruby-container -- date\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl exec mypod -c ruby-container -i -t -- bash -il\n" +"\n" +"\t\t# List contents of /usr from the first container of pod mypod and sort " +"by modification time\n" +"\t\t# If the command you want to execute in the pod has any flags in common " +"(e.g. -i),\n" +"\t\t# you must use two dashes (--) to separate your command's flags/" +"arguments\n" +"\t\t# Also note, do not surround your command and its flags/arguments with " +"quotes\n" +"\t\t# unless that is how you would execute it normally (i.e., do ls -t /usr, " +"not \"ls -t /usr\")\n" +"\t\tkubectl exec mypod -i -t -- ls -t /usr\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"deployment mydeployment, using the first container by default\n" +"\t\tkubectl exec deploy/mydeployment -- date\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"service myservice, using the first container by default\n" +"\t\tkubectl exec svc/myservice -- date\n" +"\t\t" +msgstr "" +"\n" +"\t\t# Get output from running the 'date' command from pod mypod, using the " +"first container by default\n" +"\t\tkubectl exec mypod -- date\n" +"\n" +"\t\t# Get output from running the 'date' command in ruby-container from pod " +"mypod\n" +"\t\tkubectl exec mypod -c ruby-container -- date\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl exec mypod -c ruby-container -i -t -- bash -il\n" +"\n" +"\t\t# List contents of /usr from the first container of pod mypod and sort " +"by modification time\n" +"\t\t# If the command you want to execute in the pod has any flags in common " +"(e.g. -i),\n" +"\t\t# you must use two dashes (--) to separate your command's flags/" +"arguments\n" +"\t\t# Also note, do not surround your command and its flags/arguments with " +"quotes\n" +"\t\t# unless that is how you would execute it normally (i.e., do ls -t /usr, " +"not \"ls -t /usr\")\n" +"\t\tkubectl exec mypod -i -t -- ls -t /usr\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"deployment mydeployment, using the first container by default\n" +"\t\tkubectl exec deploy/mydeployment -- date\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"service myservice, using the first container by default\n" +"\t\tkubectl exec svc/myservice -- date\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:46 +msgid "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" +msgstr "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:65 +msgid "" +"\n" +"\t\t# Installing bash completion on macOS using homebrew\n" +"\t\t## If running Bash 3.2 included with macOS\n" +"\t\t brew install bash-completion\n" +"\t\t## or, if running Bash 4.1+\n" +"\t\t brew install bash-completion@2\n" +"\t\t## If kubectl is installed via homebrew, this should start working " +"immediately\n" +"\t\t## If you've installed via other means, you may need add the completion " +"to your completion directory\n" +"\t\t kubectl completion bash > $(brew --prefix)/etc/bash_completion.d/" +"kubectl\n" +"\n" +"\n" +"\t\t# Installing bash completion on Linux\n" +"\t\t## If bash-completion is not installed on Linux, install the 'bash-" +"completion' package\n" +"\t\t## via your distribution's package manager.\n" +"\t\t## Load the kubectl completion code for bash into the current shell\n" +"\t\t source <(kubectl completion bash)\n" +"\t\t## Write bash completion code to a file and source it from ." +"bash_profile\n" +"\t\t kubectl completion bash > ~/.kube/completion.bash.inc\n" +"\t\t printf \"\n" +"\t\t # Kubectl shell completion\n" +"\t\t source '$HOME/.kube/completion.bash.inc'\n" +"\t\t \" >> $HOME/.bash_profile\n" +"\t\t source $HOME/.bash_profile\n" +"\n" +"\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +"\t\t source <(kubectl completion zsh)\n" +"\t\t# Set the kubectl completion code for zsh[1] to autoload on startup\n" +"\t\t kubectl completion zsh > \"${fpath[1]}/_kubectl\"" +msgstr "" +"\n" +"\t\t# Installing bash completion on macOS using homebrew\n" +"\t\t## If running Bash 3.2 included with macOS\n" +"\t\t brew install bash-completion\n" +"\t\t## or, if running Bash 4.1+\n" +"\t\t brew install bash-completion@2\n" +"\t\t## If kubectl is installed via homebrew, this should start working " +"immediately\n" +"\t\t## If you've installed via other means, you may need add the completion " +"to your completion directory\n" +"\t\t kubectl completion bash > $(brew --prefix)/etc/bash_completion.d/" +"kubectl\n" +"\n" +"\n" +"\t\t# Installing bash completion on Linux\n" +"\t\t## If bash-completion is not installed on Linux, install the 'bash-" +"completion' package\n" +"\t\t## via your distribution's package manager.\n" +"\t\t## Load the kubectl completion code for bash into the current shell\n" +"\t\t source <(kubectl completion bash)\n" +"\t\t## Write bash completion code to a file and source it from ." +"bash_profile\n" +"\t\t kubectl completion bash > ~/.kube/completion.bash.inc\n" +"\t\t printf \"\n" +"\t\t # Kubectl shell completion\n" +"\t\t source '$HOME/.kube/completion.bash.inc'\n" +"\t\t \" >> $HOME/.bash_profile\n" +"\t\t source $HOME/.bash_profile\n" +"\n" +"\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +"\t\t source <(kubectl completion zsh)\n" +"\t\t# Set the kubectl completion code for zsh[1] to autoload on startup\n" +"\t\t kubectl completion zsh > \"${fpath[1]}/_kubectl\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:105 +msgid "" +"\n" +"\t\t# List all pods in ps output format\n" +"\t\tkubectl get pods\n" +"\n" +"\t\t# List all pods in ps output format with more information (such as node " +"name)\n" +"\t\tkubectl get pods -o wide\n" +"\n" +"\t\t# List a single replication controller with specified NAME in ps output " +"format\n" +"\t\tkubectl get replicationcontroller web\n" +"\n" +"\t\t# List deployments in JSON output format, in the \"v1\" version of the " +"\"apps\" API group\n" +"\t\tkubectl get deployments.v1.apps -o json\n" +"\n" +"\t\t# List a single pod in JSON output format\n" +"\t\tkubectl get -o json pod web-pod-13je7\n" +"\n" +"\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +"JSON output format\n" +"\t\tkubectl get -f pod.yaml -o json\n" +"\n" +"\t\t# List resources from a directory with kustomization.yaml - e.g. dir/" +"kustomization.yaml\n" +"\t\tkubectl get -k dir/\n" +"\n" +"\t\t# Return only the phase value of the specified pod\n" +"\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}\n" +"\n" +"\t\t# List resource information in custom columns\n" +"\t\tkubectl get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0]." +"name,IMAGE:.spec.containers[0].image\n" +"\n" +"\t\t# List all replication controllers and services together in ps output " +"format\n" +"\t\tkubectl get rc,services\n" +"\n" +"\t\t# List one or more resources by their type and names\n" +"\t\tkubectl get rc/web service/frontend pods/web-pod-13je7" +msgstr "" +"\n" +"\t\t# List all pods in ps output format\n" +"\t\tkubectl get pods\n" +"\n" +"\t\t# List all pods in ps output format with more information (such as node " +"name)\n" +"\t\tkubectl get pods -o wide\n" +"\n" +"\t\t# List a single replication controller with specified NAME in ps output " +"format\n" +"\t\tkubectl get replicationcontroller web\n" +"\n" +"\t\t# List deployments in JSON output format, in the \"v1\" version of the " +"\"apps\" API group\n" +"\t\tkubectl get deployments.v1.apps -o json\n" +"\n" +"\t\t# List a single pod in JSON output format\n" +"\t\tkubectl get -o json pod web-pod-13je7\n" +"\n" +"\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +"JSON output format\n" +"\t\tkubectl get -f pod.yaml -o json\n" +"\n" +"\t\t# List resources from a directory with kustomization.yaml - e.g. dir/" +"kustomization.yaml\n" +"\t\tkubectl get -k dir/\n" +"\n" +"\t\t# Return only the phase value of the specified pod\n" +"\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}\n" +"\n" +"\t\t# List resource information in custom columns\n" +"\t\tkubectl get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0]." +"name,IMAGE:.spec.containers[0].image\n" +"\n" +"\t\t# List all replication controllers and services together in ps output " +"format\n" +"\t\tkubectl get rc,services\n" +"\n" +"\t\t# List one or more resources by their type and names\n" +"\t\tkubectl get rc/web service/frontend pods/web-pod-13je7" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:72 +msgid "" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 5000 6000\n" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in a pod selected by the deployment\n" +"\t\tkubectl port-forward deployment/mydeployment 5000 6000\n" +"\n" +"\t\t# Listen on port 8443 locally, forwarding to the targetPort of the " +"service's port named \"https\" in a pod selected by the service\n" +"\t\tkubectl port-forward service/myservice 8443:https\n" +"\n" +"\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on all addresses, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on localhost and selected IP, forwarding to 5000 " +"in the pod\n" +"\t\tkubectl port-forward --address localhost,10.19.21.23 pod/mypod " +"8888:5000\n" +"\n" +"\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod :5000" +msgstr "" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 5000 6000\n" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in a pod selected by the deployment\n" +"\t\tkubectl port-forward deployment/mydeployment 5000 6000\n" +"\n" +"\t\t# Listen on port 8443 locally, forwarding to the targetPort of the " +"service's port named \"https\" in a pod selected by the service\n" +"\t\tkubectl port-forward service/myservice 8443:https\n" +"\n" +"\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on all addresses, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on localhost and selected IP, forwarding to 5000 " +"in the pod\n" +"\t\tkubectl port-forward --address localhost,10.19.21.23 pod/mypod " +"8888:5000\n" +"\n" +"\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod :5000" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:87 +msgid "" +"\n" +"\t\t# Mark node \"foo\" as schedulable\n" +"\t\tkubectl uncordon foo" +msgstr "" +"\n" +"\t\t# Mark node \"foo\" as schedulable\n" +"\t\tkubectl uncordon foo" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:58 +msgid "" +"\n" +"\t\t# Mark node \"foo\" as unschedulable\n" +"\t\tkubectl cordon foo" +msgstr "" +"\n" +"\t\t# Mark node \"foo\" as unschedulable\n" +"\t\tkubectl cordon foo" + +#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:83 +msgid "" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as JSON\n" +"\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as YAML\n" +"\t\tkubectl patch node k8s-node-1 -p $'spec:\n" +" unschedulable: true'\n" +"\n" +"\t\t# Partially update a node identified by the type and name specified in " +"\"node.json\" using strategic merge patch\n" +"\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Update a container's image; spec.containers[*].name is required " +"because it's a merge key\n" +"\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +"\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +"\n" +"\t\t# Update a container's image using a JSON patch with positional arrays\n" +"\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +"\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" +msgstr "" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as JSON\n" +"\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as YAML\n" +"\t\tkubectl patch node k8s-node-1 -p $'spec:\n" +" unschedulable: true'\n" +"\n" +"\t\t# Partially update a node identified by the type and name specified in " +"\"node.json\" using strategic merge patch\n" +"\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Update a container's image; spec.containers[*].name is required " +"because it's a merge key\n" +"\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +"\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +"\n" +"\t\t# Update a container's image using a JSON patch with positional arrays\n" +"\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +"\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/options.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:29 +msgid "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" +msgstr "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:44 +msgid "" +"\n" +"\t\t# Print the address of the control plane and cluster services\n" +"\t\tkubectl cluster-info" +msgstr "" +"\n" +"\t\t# Print the address of the control plane and cluster services\n" +"\t\tkubectl cluster-info" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/version.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:44 +msgid "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" +msgstr "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:34 +msgid "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" +msgstr "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" + +#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:56 +msgid "" +"\n" +"\t\t# Replace a pod using the data in pod.json\n" +"\t\tkubectl replace -f ./pod.json\n" +"\n" +"\t\t# Replace a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl replace -f -\n" +"\n" +"\t\t# Update a single-container pod's image version (tag) to v4\n" +"\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' | " +"kubectl replace -f -\n" +"\n" +"\t\t# Force replace, delete and then re-create the resource\n" +"\t\tkubectl replace --force -f ./pod.json" +msgstr "" +"\n" +"\t\t# Replace a pod using the data in pod.json\n" +"\t\tkubectl replace -f ./pod.json\n" +"\n" +"\t\t# Replace a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl replace -f -\n" +"\n" +"\t\t# Update a single-container pod's image version (tag) to v4\n" +"\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' | " +"kubectl replace -f -\n" +"\n" +"\t\t# Force replace, delete and then re-create the resource\n" +"\t\tkubectl replace --force -f ./pod.json" + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:53 +msgid "" +"\n" +"\t\t# Return snapshot logs from pod nginx with only one container\n" +"\t\tkubectl logs nginx\n" +"\n" +"\t\t# Return snapshot logs from pod nginx with multi containers\n" +"\t\tkubectl logs nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot of previous terminated ruby container logs from pod " +"web-1\n" +"\t\tkubectl logs -p -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +"\t\tkubectl logs -f -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -f -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Display only the most recent 20 lines of output in pod nginx\n" +"\t\tkubectl logs --tail=20 nginx\n" +"\n" +"\t\t# Show all logs from pod nginx written in the last hour\n" +"\t\tkubectl logs --since=1h nginx\n" +"\n" +"\t\t# Show logs from a kubelet with an expired serving certificate\n" +"\t\tkubectl logs --insecure-skip-tls-verify-backend nginx\n" +"\n" +"\t\t# Return snapshot logs from first container of a job named hello\n" +"\t\tkubectl logs job/hello\n" +"\n" +"\t\t# Return snapshot logs from container nginx-1 of a deployment named " +"nginx\n" +"\t\tkubectl logs deployment/nginx -c nginx-1" +msgstr "" +"\n" +"\t\t# Return snapshot logs from pod nginx with only one container\n" +"\t\tkubectl logs nginx\n" +"\n" +"\t\t# Return snapshot logs from pod nginx with multi containers\n" +"\t\tkubectl logs nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot of previous terminated ruby container logs from pod " +"web-1\n" +"\t\tkubectl logs -p -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +"\t\tkubectl logs -f -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -f -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Display only the most recent 20 lines of output in pod nginx\n" +"\t\tkubectl logs --tail=20 nginx\n" +"\n" +"\t\t# Show all logs from pod nginx written in the last hour\n" +"\t\tkubectl logs --since=1h nginx\n" +"\n" +"\t\t# Show logs from a kubelet with an expired serving certificate\n" +"\t\tkubectl logs --insecure-skip-tls-verify-backend nginx\n" +"\n" +"\t\t# Return snapshot logs from first container of a job named hello\n" +"\t\tkubectl logs job/hello\n" +"\n" +"\t\t# Return snapshot logs from container nginx-1 of a deployment named " +"nginx\n" +"\t\tkubectl logs deployment/nginx -c nginx-1" + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:49 +msgid "" +"\n" +"\t\t# Scale a replica set named 'foo' to 3\n" +"\t\tkubectl scale --replicas=3 rs/foo\n" +"\n" +"\t\t# Scale a resource identified by type and name specified in \"foo.yaml\" " +"to 3\n" +"\t\tkubectl scale --replicas=3 -f foo.yaml\n" +"\n" +"\t\t# If the deployment named mysql's current size is 2, scale mysql to 3\n" +"\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +"\n" +"\t\t# Scale multiple replication controllers\n" +"\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +"\n" +"\t\t# Scale stateful set named 'web' to 3\n" +"\t\tkubectl scale --replicas=3 statefulset/web" +msgstr "" +"\n" +"\t\t# Scale a replica set named 'foo' to 3\n" +"\t\tkubectl scale --replicas=3 rs/foo\n" +"\n" +"\t\t# Scale a resource identified by type and name specified in \"foo.yaml\" " +"to 3\n" +"\t\tkubectl scale --replicas=3 -f foo.yaml\n" +"\n" +"\t\t# If the deployment named mysql's current size is 2, scale mysql to 3\n" +"\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +"\n" +"\t\t# Scale multiple replication controllers\n" +"\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +"\n" +"\t\t# Scale stateful set named 'web' to 3\n" +"\t\tkubectl scale --replicas=3 statefulset/web" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:75 +msgid "" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml\n" +"\n" +"\t\t# Execute set-last-applied against each configuration file in a " +"directory\n" +"\t\tkubectl apply set-last-applied -f path/\n" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file; will create the annotation if it does not already exist\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml --create-annotation=true\n" +"\t\t" +msgstr "" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml\n" +"\n" +"\t\t# Execute set-last-applied against each configuration file in a " +"directory\n" +"\t\tkubectl apply set-last-applied -f path/\n" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file; will create the annotation if it does not already exist\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml --create-annotation=true\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:75 +msgid "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" +msgstr "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:62 +msgid "" +"\n" +"\t\t# Start a nginx pod\n" +"\t\tkubectl run nginx --image=nginx\n" +"\n" +"\t\t# Start a hazelcast pod and let the container expose port 5701\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --port=5701\n" +"\n" +"\t\t# Start a hazelcast pod and set environment variables " +"\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --env=" +"\"DNS_DOMAIN=cluster\" --env=\"POD_NAMESPACE=default\"\n" +"\n" +"\t\t# Start a hazelcast pod and set labels \"app=hazelcast\" and \"env=prod" +"\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --labels=" +"\"app=hazelcast,env=prod\"\n" +"\n" +"\t\t# Dry run; print the corresponding API objects without creating them\n" +"\t\tkubectl run nginx --image=nginx --dry-run=client\n" +"\n" +"\t\t# Start a nginx pod, but overload the spec with a partial set of values " +"parsed from JSON\n" +"\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": \"v1\", " +"\"spec\": { ... } }'\n" +"\n" +"\t\t# Start a busybox pod and keep it in the foreground, don't restart it if " +"it exits\n" +"\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +"\n" +"\t\t# Start the nginx pod using the default command, but use custom " +"arguments (arg1 .. argN) for that command\n" +"\t\tkubectl run nginx --image=nginx -- ... \n" +"\n" +"\t\t# Start the nginx pod using a different command and custom arguments\n" +"\t\tkubectl run nginx --image=nginx --command -- ... " +msgstr "" +"\n" +"\t\t# Start a nginx pod\n" +"\t\tkubectl run nginx --image=nginx\n" +"\n" +"\t\t# Start a hazelcast pod and let the container expose port 5701\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --port=5701\n" +"\n" +"\t\t# Start a hazelcast pod and set environment variables " +"\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --env=" +"\"DNS_DOMAIN=cluster\" --env=\"POD_NAMESPACE=default\"\n" +"\n" +"\t\t# Start a hazelcast pod and set labels \"app=hazelcast\" and \"env=prod" +"\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --labels=" +"\"app=hazelcast,env=prod\"\n" +"\n" +"\t\t# Dry run; print the corresponding API objects without creating them\n" +"\t\tkubectl run nginx --image=nginx --dry-run=client\n" +"\n" +"\t\t# Start a nginx pod, but overload the spec with a partial set of values " +"parsed from JSON\n" +"\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": \"v1\", " +"\"spec\": { ... } }'\n" +"\n" +"\t\t# Start a busybox pod and keep it in the foreground, don't restart it if " +"it exits\n" +"\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +"\n" +"\t\t# Start the nginx pod using the default command, but use custom " +"arguments (arg1 .. argN) for that command\n" +"\t\tkubectl run nginx --image=nginx -- ... \n" +"\n" +"\t\t# Start the nginx pod using a different command and custom arguments\n" +"\t\tkubectl run nginx --image=nginx --command -- ... " + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:73 +msgid "" +"\n" +"\t\t# To proxy all of the Kubernetes API and nothing else\n" +"\t\tkubectl proxy --api-prefix=/\n" +"\n" +"\t\t# To proxy only part of the Kubernetes API and also some static files\n" +"\t\t# You can get pods info with 'curl localhost:8001/api/v1/pods'\n" +"\t\tkubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/\n" +"\n" +"\t\t# To proxy the entire Kubernetes API at a different root\n" +"\t\t# You can get pods info with 'curl localhost:8001/custom/api/v1/pods'\n" +"\t\tkubectl proxy --api-prefix=/custom/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on port 8011, serving static " +"content from ./local/www/\n" +"\t\tkubectl proxy --port=8011 --www=./local/www/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on an arbitrary local port\n" +"\t\t# The chosen port for the server will be output to stdout\n" +"\t\tkubectl proxy --port=0\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server, changing the API prefix to " +"k8s-api\n" +"\t\t# This makes e.g. the pods API available at localhost:8001/k8s-api/v1/" +"pods/\n" +"\t\tkubectl proxy --api-prefix=/k8s-api" +msgstr "" +"\n" +"\t\t# To proxy all of the Kubernetes API and nothing else\n" +"\t\tkubectl proxy --api-prefix=/\n" +"\n" +"\t\t# To proxy only part of the Kubernetes API and also some static files\n" +"\t\t# You can get pods info with 'curl localhost:8001/api/v1/pods'\n" +"\t\tkubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/\n" +"\n" +"\t\t# To proxy the entire Kubernetes API at a different root\n" +"\t\t# You can get pods info with 'curl localhost:8001/custom/api/v1/pods'\n" +"\t\tkubectl proxy --api-prefix=/custom/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on port 8011, serving static " +"content from ./local/www/\n" +"\t\tkubectl proxy --port=8011 --www=./local/www/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on an arbitrary local port\n" +"\t\t# The chosen port for the server will be output to stdout\n" +"\t\tkubectl proxy --port=0\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server, changing the API prefix to " +"k8s-api\n" +"\t\t# This makes e.g. the pods API available at localhost:8001/k8s-api/v1/" +"pods/\n" +"\t\tkubectl proxy --api-prefix=/k8s-api" + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:80 +msgid "" +"\n" +"\t\t# Update node 'foo' with a taint with key 'dedicated' and value 'special-" +"user' and effect 'NoSchedule'\n" +"\t\t# If a taint with that key and effect already exists, its value is " +"replaced as specified\n" +"\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +"\n" +"\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +"'NoSchedule' if one exists\n" +"\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +"\n" +"\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +"\t\tkubectl taint nodes foo dedicated-\n" +"\n" +"\t\t# Add a taint with key 'dedicated' on nodes having label mylabel=X\n" +"\t\tkubectl taint node -l myLabel=X dedicated=foo:PreferNoSchedule\n" +"\n" +"\t\t# Add to node 'foo' a taint with key 'bar' and no value\n" +"\t\tkubectl taint nodes foo bar:NoSchedule" +msgstr "" +"\n" +"\t\t# Update node 'foo' with a taint with key 'dedicated' and value 'special-" +"user' and effect 'NoSchedule'\n" +"\t\t# If a taint with that key and effect already exists, its value is " +"replaced as specified\n" +"\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +"\n" +"\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +"'NoSchedule' if one exists\n" +"\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +"\n" +"\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +"\t\tkubectl taint nodes foo dedicated-\n" +"\n" +"\t\t# Add a taint with key 'dedicated' on nodes having label mylabel=X\n" +"\t\tkubectl taint node -l myLabel=X dedicated=foo:PreferNoSchedule\n" +"\n" +"\t\t# Add to node 'foo' a taint with key 'bar' and no value\n" +"\t\tkubectl taint nodes foo bar:NoSchedule" + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:95 +msgid "" +"\n" +"\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'\n" +"\t\tkubectl label pods foo unhealthy=true\n" +"\n" +"\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +"overwriting any existing value\n" +"\t\tkubectl label --overwrite pods foo status=unhealthy\n" +"\n" +"\t\t# Update all pods in the namespace\n" +"\t\tkubectl label pods --all status=unhealthy\n" +"\n" +"\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +"\t\tkubectl label -f pod.json status=unhealthy\n" +"\n" +"\t\t# Update pod 'foo' only if the resource is unchanged from version 1\n" +"\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +"\n" +"\t\t# Update pod 'foo' by removing a label named 'bar' if it exists\n" +"\t\t# Does not require the --overwrite flag\n" +"\t\tkubectl label pods foo bar-" +msgstr "" +"\n" +"\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'\n" +"\t\tkubectl label pods foo unhealthy=true\n" +"\n" +"\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +"overwriting any existing value\n" +"\t\tkubectl label --overwrite pods foo status=unhealthy\n" +"\n" +"\t\t# Update all pods in the namespace\n" +"\t\tkubectl label pods --all status=unhealthy\n" +"\n" +"\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +"\t\tkubectl label -f pod.json status=unhealthy\n" +"\n" +"\t\t# Update pod 'foo' only if the resource is unchanged from version 1\n" +"\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +"\n" +"\t\t# Update pod 'foo' by removing a label named 'bar' if it exists\n" +"\t\t# Does not require the --overwrite flag\n" +"\t\tkubectl label pods foo bar-" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_view_last_applied.go:53 +msgid "" +"\n" +"\t\t# View the last-applied-configuration annotations by type/name in YAML\n" +"\t\tkubectl apply view-last-applied deployment/nginx\n" +"\n" +"\t\t# View the last-applied-configuration annotations by file in JSON\n" +"\t\tkubectl apply view-last-applied -f deploy.yaml -o json" +msgstr "" +"\n" +"\t\t# View the last-applied-configuration annotations by type/name in YAML\n" +"\t\tkubectl apply view-last-applied deployment/nginx\n" +"\n" +"\t\t# View the last-applied-configuration annotations by file in JSON\n" +"\t\tkubectl apply view-last-applied -f deploy.yaml -o json" + +#: staging/src/k8s.io/kubectl/pkg/cmd/wait/wait.go:61 +msgid "" +"\n" +"\t\t# Wait for the pod \"busybox1\" to contain the status condition of type " +"\"Ready\"\n" +"\t\tkubectl wait --for=condition=Ready pod/busybox1\n" +"\n" +"\t\t# The default value of status condition is true; you can set it to " +"false\n" +"\t\tkubectl wait --for=condition=Ready=false pod/busybox1\n" +"\n" +"\t\t# Wait for the pod \"busybox1\" to be deleted, with a timeout of 60s, " +"after having issued the \"delete\" command\n" +"\t\tkubectl delete pod/busybox1\n" +"\t\tkubectl wait --for=delete pod/busybox1 --timeout=60s" +msgstr "" +"\n" +"\t\t# Wait for the pod \"busybox1\" to contain the status condition of type " +"\"Ready\"\n" +"\t\tkubectl wait --for=condition=Ready pod/busybox1\n" +"\n" +"\t\t# The default value of status condition is true; you can set it to " +"false\n" +"\t\tkubectl wait --for=condition=Ready=false pod/busybox1\n" +"\n" +"\t\t# Wait for the pod \"busybox1\" to be deleted, with a timeout of 60s, " +"after having issued the \"delete\" command\n" +"\t\tkubectl delete pod/busybox1\n" +"\t\tkubectl wait --for=delete pod/busybox1 --timeout=60s" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:110 +msgid "" +"\n" +"\t\tApply a configuration to a resource by file name or stdin.\n" +"\t\tThe resource name must be specified. This resource will be created if it " +"doesn't exist yet.\n" +"\t\tTo use 'apply', always create the resource initially with either 'apply' " +"or 'create --save-config'.\n" +"\n" +"\t\tJSON and YAML formats are accepted.\n" +"\n" +"\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do not " +"use unless you are aware of what the current state is. See https://issues." +"k8s.io/34274." +msgstr "" +"\n" +"\t\tApply a configuration to a resource by file name or stdin.\n" +"\t\tThe resource name must be specified. This resource will be created if it " +"doesn't exist yet.\n" +"\t\tTo use 'apply', always create the resource initially with either 'apply' " +"or 'create --save-config'.\n" +"\n" +"\t\tJSON and YAML formats are accepted.\n" +"\n" +"\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do not " +"use unless you are aware of what the current state is. See https://issues." +"k8s.io/34274." + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:126 +msgid "" +"\n" +"\t\tApprove a certificate signing request.\n" +"\n" +"\t\tkubectl certificate approve allows a cluster admin to approve a " +"certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tissue a certificate to the requestor with the attributes requested in " +"the CSR.\n" +"\n" +"\t\tSECURITY NOTICE: Depending on the requested attributes, the issued " +"certificate\n" +"\t\tcan potentially grant a requester access to cluster resources or to " +"authenticate\n" +"\t\tas a requested identity. Before approving a CSR, ensure you understand " +"what the\n" +"\t\tsigned certificate can do.\n" +"\t\t" +msgstr "" +"\n" +"\t\tApprove a certificate signing request.\n" +"\n" +"\t\tkubectl certificate approve allows a cluster admin to approve a " +"certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tissue a certificate to the requestor with the attributes requested in " +"the CSR.\n" +"\n" +"\t\tSECURITY NOTICE: Depending on the requested attributes, the issued " +"certificate\n" +"\t\tcan potentially grant a requester access to cluster resources or to " +"authenticate\n" +"\t\tas a requested identity. Before approving a CSR, ensure you understand " +"what the\n" +"\t\tsigned certificate can do.\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:28 +msgid "" +"\n" +"\t\tConfigure application resources.\n" +"\n" +"\t\tThese commands help you make changes to existing application resources." +msgstr "" +"\n" +"\t\tConfigure application resources.\n" +"\n" +"\t\tThese commands help you make changes to existing application resources." + +#: pkg/kubectl/cmd/convert/convert.go:40 +msgid "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." +msgstr "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:41 +msgid "" +"\n" +"\t\tCreate a TLS secret from the given public/private key pair.\n" +"\n" +"\t\tThe public/private key pair must exist beforehand. The public key " +"certificate must be .PEM encoded and match\n" +"\t\tthe given private key." +msgstr "" +"\n" +"\t\tCreate a TLS secret from the given public/private key pair.\n" +"\n" +"\t\tThe public/private key pair must exist beforehand. The public key " +"certificate must be .PEM encoded and match\n" +"\t\tthe given private key." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:41 +msgid "" +"\n" +"\t\tCreate a cluster role binding for a particular cluster role." +msgstr "" +"\n" +"\t\tCreate a cluster role binding for a particular cluster role." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:38 +msgid "" +"\n" +"\t\tCreate a cluster role." +msgstr "" +"\n" +"\t\tCreate a cluster role." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:46 +msgid "" +"\n" +"\t\tCreate a config map based on a file, directory, or specified literal " +"value.\n" +"\n" +"\t\tA single config map may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a config map based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key, you may " +"specify an alternate key.\n" +"\n" +"\t\tWhen creating a config map based on a directory, each file whose " +"basename is a valid key in the directory will be\n" +"\t\tpackaged into the config map. Any directory entries except regular " +"files are ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." +msgstr "" +"\n" +"\t\tCreate a config map based on a file, directory, or specified literal " +"value.\n" +"\n" +"\t\tA single config map may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a config map based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key, you may " +"specify an alternate key.\n" +"\n" +"\t\tWhen creating a config map based on a directory, each file whose " +"basename is a valid key in the directory will be\n" +"\t\tpackaged into the config map. Any directory entries except regular " +"files are ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_cronjob.go:40 +msgid "" +"\n" +"\t\tCreate a cron job with the specified name." +msgstr "" +"\n" +"\t\tCreate a cron job with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:40 +msgid "" +"\n" +"\t\tCreate a job with the specified name." +msgstr "" +"\n" +"\t\tCreate a job with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:39 +msgid "" +"\n" +"\t\tCreate a namespace with the specified name." +msgstr "" +"\n" +"\t\tCreate a namespace with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:41 +msgid "" +"\n" +"\t\tCreate a new secret for use with Docker registries.\n" +"\n" +"\t\tDockercfg secrets are used to authenticate against Docker registries.\n" +"\n" +"\t\tWhen using the Docker command line to push images, you can authenticate " +"to a given registry by running:\n" +"\t\t\t'$ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +"password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +"\n" +"\tThat produces a ~/.dockercfg file that is used by subsequent 'docker push' " +"and 'docker pull' commands to\n" +"\t\tauthenticate to the registry. The email address is optional.\n" +"\n" +"\t\tWhen creating applications, you may have a Docker registry that requires " +"authentication. In order for the\n" +"\t\tnodes to pull images on your behalf, they must have the credentials. " +"You can provide this information\n" +"\t\tby creating a dockercfg secret and attaching it to your service account." +msgstr "" +"\n" +"\t\tCreate a new secret for use with Docker registries.\n" +"\n" +"\t\tDockercfg secrets are used to authenticate against Docker registries.\n" +"\n" +"\t\tWhen using the Docker command line to push images, you can authenticate " +"to a given registry by running:\n" +"\t\t\t'$ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +"password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +"\n" +"\tThat produces a ~/.dockercfg file that is used by subsequent 'docker push' " +"and 'docker pull' commands to\n" +"\t\tauthenticate to the registry. The email address is optional.\n" +"\n" +"\t\tWhen creating applications, you may have a Docker registry that requires " +"authentication. In order for the\n" +"\t\tnodes to pull images on your behalf, they must have the credentials. " +"You can provide this information\n" +"\t\tby creating a dockercfg secret and attaching it to your service account." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:41 +msgid "" +"\n" +"\t\tCreate a pod disruption budget with the specified name, selector, and " +"desired minimum available pods." +msgstr "" +"\n" +"\t\tCreate a pod disruption budget with the specified name, selector, and " +"desired minimum available pods." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:40 +msgid "" +"\n" +"\t\tCreate a priority class with the specified name, value, globalDefault " +"and description." +msgstr "" +"\n" +"\t\tCreate a priority class with the specified name, value, globalDefault " +"and description." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:71 +msgid "" +"\n" +"\t\tCreate a resource from a file or from stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted." +msgstr "" +"\n" +"\t\tCreate a resource from a file or from stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:41 +msgid "" +"\n" +"\t\tCreate a resource quota with the specified name, hard limits, and " +"optional scopes." +msgstr "" +"\n" +"\t\tCreate a resource quota with the specified name, hard limits, and " +"optional scopes." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:40 +msgid "" +"\n" +"\t\tCreate a role binding for a particular role or cluster role." +msgstr "" +"\n" +"\t\tCreate a role binding for a particular role or cluster role." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L47 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:43 +msgid "" +"\n" +"\t\tCreate a role with single rule." +msgstr "" +"\n" +"\t\tCreate a role with single rule." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:61 +msgid "" +"\n" +"\t\tCreate a secret based on a file, directory, or specified literal value.\n" +"\n" +"\t\tA single secret may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a secret based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key or you " +"wish to chose your own, you may specify\n" +"\t\tan alternate key.\n" +"\n" +"\t\tWhen creating a secret based on a directory, each file whose basename is " +"a valid key in the directory will be\n" +"\t\tpackaged into the secret. Any directory entries except regular files are " +"ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." +msgstr "" +"\n" +"\t\tCreate a secret based on a file, directory, or specified literal value.\n" +"\n" +"\t\tA single secret may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a secret based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key or you " +"wish to chose your own, you may specify\n" +"\t\tan alternate key.\n" +"\n" +"\t\tWhen creating a secret based on a directory, each file whose basename is " +"a valid key in the directory will be\n" +"\t\tpackaged into the secret. Any directory entries except regular files are " +"ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:40 +msgid "" +"\n" +"\t\tCreate a service account with the specified name." +msgstr "" +"\n" +"\t\tCreate a service account with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:67 +msgid "" +"\n" +"\t\tCreates a proxy server or application-level gateway between localhost " +"and\n" +"\t\tthe Kubernetes API server. It also allows serving static content over " +"specified\n" +"\t\tHTTP path. All incoming data enters through one port and gets forwarded " +"to\n" +"\t\tthe remote Kubernetes API server port, except for the path matching the " +"static content path." +msgstr "" +"\n" +"\t\tCreates a proxy server or application-level gateway between localhost " +"and\n" +"\t\tthe Kubernetes API server. It also allows serving static content over " +"specified\n" +"\t\tHTTP path. All incoming data enters through one port and gets forwarded " +"to\n" +"\t\tthe remote Kubernetes API server port, except for the path matching the " +"static content path." + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:42 +msgid "" +"\n" +"\t\tCreates an autoscaler that automatically chooses and sets the number of " +"pods that run in a Kubernetes cluster.\n" +"\n" +"\t\tLooks up a deployment, replica set, stateful set, or replication " +"controller by name and creates an autoscaler that uses the given resource as " +"a reference.\n" +"\t\tAn autoscaler can automatically increase or decrease number of pods " +"deployed within the system as needed." +msgstr "" +"\n" +"\t\tCreates an autoscaler that automatically chooses and sets the number of " +"pods that run in a Kubernetes cluster.\n" +"\n" +"\t\tLooks up a deployment, replica set, stateful set, or replication " +"controller by name and creates an autoscaler that uses the given resource as " +"a reference.\n" +"\t\tAn autoscaler can automatically increase or decrease number of pods " +"deployed within the system as needed." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:57 +msgid "" +"\n" +"\t\tDebug cluster resources using interactive debugging containers.\n" +"\n" +"\t\t'debug' provides automation for common debugging tasks for cluster " +"objects identified by\n" +"\t\tresource and name. Pods will be used by default if no resource is " +"specified.\n" +"\n" +"\t\tThe action taken by 'debug' varies depending on what resource is " +"specified. Supported\n" +"\t\tactions include:\n" +"\n" +"\t\t* Workload: Create a copy of an existing pod with certain attributes " +"changed,\n" +"\t for example changing the image tag to a new version.\n" +"\t\t* Workload: Add an ephemeral container to an already running pod, for " +"example to add\n" +"\t\t debugging utilities without restarting the pod.\n" +"\t\t* Node: Create a new pod that runs in the node's host namespaces and can " +"access\n" +"\t\t the node's filesystem.\n" +msgstr "" +"\n" +"\t\tDebug cluster resources using interactive debugging containers.\n" +"\n" +"\t\t'debug' provides automation for common debugging tasks for cluster " +"objects identified by\n" +"\t\tresource and name. Pods will be used by default if no resource is " +"specified.\n" +"\n" +"\t\tThe action taken by 'debug' varies depending on what resource is " +"specified. Supported\n" +"\t\tactions include:\n" +"\n" +"\t\t* Workload: Create a copy of an existing pod with certain attributes " +"changed,\n" +"\t for example changing the image tag to a new version.\n" +"\t\t* Workload: Add an ephemeral container to an already running pod, for " +"example to add\n" +"\t\t debugging utilities without restarting the pod.\n" +"\t\t* Node: Create a new pod that runs in the node's host namespaces and can " +"access\n" +"\t\t the node's filesystem.\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:45 +msgid "" +"\n" +"\t\tDelete resources by file names, stdin, resources and names, or by " +"resources and label selector.\n" +"\n" +"\t\tJSON and YAML formats are accepted. Only one type of argument may be " +"specified: file names,\n" +"\t\tresources and names, or resources and label selector.\n" +"\n" +"\t\tSome resources, such as pods, support graceful deletion. These resources " +"define a default period\n" +"\t\tbefore they are forcibly terminated (the grace period) but you may " +"override that value with\n" +"\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +"Because these resources often\n" +"\t\trepresent entities in the cluster, deletion may not be acknowledged " +"immediately. If the node\n" +"\t\thosting a pod is down or cannot reach the API server, termination may " +"take significantly longer\n" +"\t\tthan the grace period. To force delete a resource, you must specify the " +"--force flag.\n" +"\t\tNote: only a subset of resources support graceful deletion. In absence " +"of the support,\n" +"\t\tthe --grace-period flag is ignored.\n" +"\n" +"\t\tIMPORTANT: Force deleting pods does not wait for confirmation that the " +"pod's processes have been\n" +"\t\tterminated, which can leave those processes running until the node " +"detects the deletion and\n" +"\t\tcompletes graceful deletion. If your processes use shared storage or " +"talk to a remote API and\n" +"\t\tdepend on the name of the pod to identify themselves, force deleting " +"those pods may result in\n" +"\t\tmultiple processes running on different machines using the same " +"identification which may lead\n" +"\t\tto data corruption or inconsistency. Only force delete pods when you are " +"sure the pod is\n" +"\t\tterminated, or if your application can tolerate multiple copies of the " +"same pod running at once.\n" +"\t\tAlso, if you force delete pods, the scheduler may place new pods on " +"those nodes before the node\n" +"\t\thas released those resources and causing those pods to be evicted " +"immediately.\n" +"\n" +"\t\tNote that the delete command does NOT do resource version checks, so if " +"someone submits an\n" +"\t\tupdate to a resource right when you submit a delete, their update will " +"be lost along with the\n" +"\t\trest of the resource." +msgstr "" +"\n" +"\t\tDelete resources by file names, stdin, resources and names, or by " +"resources and label selector.\n" +"\n" +"\t\tJSON and YAML formats are accepted. Only one type of argument may be " +"specified: file names,\n" +"\t\tresources and names, or resources and label selector.\n" +"\n" +"\t\tSome resources, such as pods, support graceful deletion. These resources " +"define a default period\n" +"\t\tbefore they are forcibly terminated (the grace period) but you may " +"override that value with\n" +"\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +"Because these resources often\n" +"\t\trepresent entities in the cluster, deletion may not be acknowledged " +"immediately. If the node\n" +"\t\thosting a pod is down or cannot reach the API server, termination may " +"take significantly longer\n" +"\t\tthan the grace period. To force delete a resource, you must specify the " +"--force flag.\n" +"\t\tNote: only a subset of resources support graceful deletion. In absence " +"of the support,\n" +"\t\tthe --grace-period flag is ignored.\n" +"\n" +"\t\tIMPORTANT: Force deleting pods does not wait for confirmation that the " +"pod's processes have been\n" +"\t\tterminated, which can leave those processes running until the node " +"detects the deletion and\n" +"\t\tcompletes graceful deletion. If your processes use shared storage or " +"talk to a remote API and\n" +"\t\tdepend on the name of the pod to identify themselves, force deleting " +"those pods may result in\n" +"\t\tmultiple processes running on different machines using the same " +"identification which may lead\n" +"\t\tto data corruption or inconsistency. Only force delete pods when you are " +"sure the pod is\n" +"\t\tterminated, or if your application can tolerate multiple copies of the " +"same pod running at once.\n" +"\t\tAlso, if you force delete pods, the scheduler may place new pods on " +"those nodes before the node\n" +"\t\thas released those resources and causing those pods to be evicted " +"immediately.\n" +"\n" +"\t\tNote that the delete command does NOT do resource version checks, so if " +"someone submits an\n" +"\t\tupdate to a resource right when you submit a delete, their update will " +"be lost along with the\n" +"\t\trest of the resource." + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:175 +msgid "" +"\n" +"\t\tDeny a certificate signing request.\n" +"\n" +"\t\tkubectl certificate deny allows a cluster admin to deny a certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tnot to issue a certificate to the requestor.\n" +"\t\t" +msgstr "" +"\n" +"\t\tDeny a certificate signing request.\n" +"\n" +"\t\tkubectl certificate deny allows a cluster admin to deny a certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tnot to issue a certificate to the requestor.\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:53 +msgid "" +"\n" +"\t\tDiff configurations specified by file name or stdin between the current " +"online\n" +"\t\tconfiguration, and the configuration as it would be if applied.\n" +"\n" +"\t\tThe output is always YAML.\n" +"\n" +"\t\tKUBECTL_EXTERNAL_DIFF environment variable can be used to select your " +"own\n" +"\t\tdiff command. Users can use external commands with params too, example:\n" +"\t\tKUBECTL_EXTERNAL_DIFF=\"colordiff -N -u\"\n" +"\n" +"\t\tBy default, the \"diff\" command available in your path will be\n" +"\t\trun with the \"-u\" (unified diff) and \"-N\" (treat absent files as " +"empty) options.\n" +"\n" +"\t\tExit status:\n" +"\t\t 0\n" +"\t\tNo differences were found.\n" +"\t\t 1\n" +"\t\tDifferences were found.\n" +"\t\t >1\n" +"\t\tKubectl or diff failed with an error.\n" +"\n" +"\t\tNote: KUBECTL_EXTERNAL_DIFF, if used, is expected to follow that " +"convention." +msgstr "" +"\n" +"\t\tDiff configurations specified by file name or stdin between the current " +"online\n" +"\t\tconfiguration, and the configuration as it would be if applied.\n" +"\n" +"\t\tThe output is always YAML.\n" +"\n" +"\t\tKUBECTL_EXTERNAL_DIFF environment variable can be used to select your " +"own\n" +"\t\tdiff command. Users can use external commands with params too, example:\n" +"\t\tKUBECTL_EXTERNAL_DIFF=\"colordiff -N -u\"\n" +"\n" +"\t\tBy default, the \"diff\" command available in your path will be\n" +"\t\trun with the \"-u\" (unified diff) and \"-N\" (treat absent files as " +"empty) options.\n" +"\n" +"\t\tExit status:\n" +"\t\t 0\n" +"\t\tNo differences were found.\n" +"\t\t 1\n" +"\t\tDifferences were found.\n" +"\t\t >1\n" +"\t\tKubectl or diff failed with an error.\n" +"\n" +"\t\tNote: KUBECTL_EXTERNAL_DIFF, if used, is expected to follow that " +"convention." + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top.go:39 +msgid "" +"\n" +"\t\tDisplay Resource (CPU/Memory) usage.\n" +"\n" +"\t\tThe top command allows you to see the resource consumption for nodes or " +"pods.\n" +"\n" +"\t\tThis command requires Metrics Server to be correctly configured and " +"working on the server. " +msgstr "" +"\n" +"\t\tDisplay Resource (CPU/Memory) usage.\n" +"\n" +"\t\tThe top command allows you to see the resource consumption for nodes or " +"pods.\n" +"\n" +"\t\tThis command requires Metrics Server to be correctly configured and " +"working on the server. " + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:54 +msgid "" +"\n" +"\t\tDisplay merged kubeconfig settings or a specified kubeconfig file.\n" +"\n" +"\t\tYou can use --output jsonpath={...} to extract specific values using a " +"jsonpath expression." +msgstr "" +"\n" +"\t\tDisplay merged kubeconfig settings or a specified kubeconfig file.\n" +"\n" +"\t\tYou can use --output jsonpath={...} to extract specific values using a " +"jsonpath expression." + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:92 +msgid "" +"\n" +"\t\tDisplay one or many resources.\n" +"\n" +"\t\tPrints a table of the most important information about the specified " +"resources.\n" +"\t\tYou can filter the list using a label selector and the --selector flag. " +"If the\n" +"\t\tdesired resource type is namespaced you will only see results in your " +"current\n" +"\t\tnamespace unless you pass --all-namespaces.\n" +"\n" +"\t\tUninitialized objects are not shown unless --include-uninitialized is " +"passed.\n" +"\n" +"\t\tBy specifying the output as 'template' and providing a Go template as " +"the value\n" +"\t\tof the --template flag, you can filter the attributes of the fetched " +"resources." +msgstr "" +"\n" +"\t\tDisplay one or many resources.\n" +"\n" +"\t\tPrints a table of the most important information about the specified " +"resources.\n" +"\t\tYou can filter the list using a label selector and the --selector flag. " +"If the\n" +"\t\tdesired resource type is namespaced you will only see results in your " +"current\n" +"\t\tnamespace unless you pass --all-namespaces.\n" +"\n" +"\t\tUninitialized objects are not shown unless --include-uninitialized is " +"passed.\n" +"\n" +"\t\tBy specifying the output as 'template' and providing a Go template as " +"the value\n" +"\t\tof the --template flag, you can filter the attributes of the fetched " +"resources." + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:57 +msgid "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of nodes.\n" +"\n" +"\t\tThe top-node command allows you to see the resource consumption of nodes." +msgstr "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of nodes.\n" +"\n" +"\t\tThe top-node command allows you to see the resource consumption of nodes." + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:67 +msgid "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of pods.\n" +"\n" +"\t\tThe 'top pod' command allows you to see the resource consumption of " +"pods.\n" +"\n" +"\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +"minutes\n" +"\t\tsince pod creation." +msgstr "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of pods.\n" +"\n" +"\t\tThe 'top pod' command allows you to see the resource consumption of " +"pods.\n" +"\n" +"\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +"minutes\n" +"\t\tsince pod creation." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/current_context.go:37 +msgid "" +"\n" +"\t\tDisplay the current-context." +msgstr "" +"\n" +"\t\tDisplay the current-context." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:113 +msgid "" +"\n" +"\t\tDrain node in preparation for maintenance.\n" +"\n" +"\t\tThe given node will be marked unschedulable to prevent new pods from " +"arriving.\n" +"\t\t'drain' evicts the pods if the API server supports\n" +"\t\t[eviction](https://kubernetes.io/docs/concepts/workloads/pods/" +"disruptions/). Otherwise, it will use normal\n" +"\t\tDELETE to delete the pods.\n" +"\t\tThe 'drain' evicts or deletes all pods except mirror pods (which cannot " +"be deleted through\n" +"\t\tthe API server). If there are daemon set-managed pods, drain will not " +"proceed\n" +"\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +"\t\tdaemon set-managed pods, because those pods would be immediately " +"replaced by the\n" +"\t\tdaemon set controller, which ignores unschedulable markings. If there " +"are any\n" +"\t\tpods that are neither mirror pods nor managed by a replication " +"controller,\n" +"\t\treplica set, daemon set, stateful set, or job, then drain will not " +"delete any pods unless you\n" +"\t\tuse --force. --force will also allow deletion to proceed if the " +"managing resource of one\n" +"\t\tor more pods is missing.\n" +"\n" +"\t\t'drain' waits for graceful termination. You should not operate on the " +"machine until\n" +"\t\tthe command completes.\n" +"\n" +"\t\tWhen you are ready to put the node back into service, use kubectl " +"uncordon, which\n" +"\t\twill make the node schedulable again.\n" +"\n" +"\t\t![Workflow](https://kubernetes.io/images/docs/kubectl_drain.svg)" +msgstr "" +"\n" +"\t\tDrain node in preparation for maintenance.\n" +"\n" +"\t\tThe given node will be marked unschedulable to prevent new pods from " +"arriving.\n" +"\t\t'drain' evicts the pods if the API server supports\n" +"\t\t[eviction](https://kubernetes.io/docs/concepts/workloads/pods/" +"disruptions/). Otherwise, it will use normal\n" +"\t\tDELETE to delete the pods.\n" +"\t\tThe 'drain' evicts or deletes all pods except mirror pods (which cannot " +"be deleted through\n" +"\t\tthe API server). If there are daemon set-managed pods, drain will not " +"proceed\n" +"\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +"\t\tdaemon set-managed pods, because those pods would be immediately " +"replaced by the\n" +"\t\tdaemon set controller, which ignores unschedulable markings. If there " +"are any\n" +"\t\tpods that are neither mirror pods nor managed by a replication " +"controller,\n" +"\t\treplica set, daemon set, stateful set, or job, then drain will not " +"delete any pods unless you\n" +"\t\tuse --force. --force will also allow deletion to proceed if the " +"managing resource of one\n" +"\t\tor more pods is missing.\n" +"\n" +"\t\t'drain' waits for graceful termination. You should not operate on the " +"machine until\n" +"\t\tthe command completes.\n" +"\n" +"\t\tWhen you are ready to put the node back into service, use kubectl " +"uncordon, which\n" +"\t\twill make the node schedulable again.\n" +"\n" +"\t\t![Workflow](https://kubernetes.io/images/docs/kubectl_drain.svg)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:31 +msgid "" +"\n" +"\t\tEdit a resource from the default editor.\n" +"\n" +"\t\tThe edit command allows you to directly edit any API resource you can " +"retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tEditing is done with the API version used to fetch the resource.\n" +"\t\tTo edit using a specific API version, fully-qualify the resource, " +"version, and group.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." +msgstr "" +"\n" +"\t\tEdit a resource from the default editor.\n" +"\n" +"\t\tThe edit command allows you to directly edit any API resource you can " +"retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tEditing is done with the API version used to fetch the resource.\n" +"\t\tTo edit using a specific API version, fully-qualify the resource, " +"version, and group.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_edit_last_applied.go:31 +msgid "" +"\n" +"\t\tEdit the latest last-applied-configuration annotations of resources from " +"the default editor.\n" +"\n" +"\t\tThe edit-last-applied command allows you to directly edit any API " +"resource you can retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." +msgstr "" +"\n" +"\t\tEdit the latest last-applied-configuration annotations of resources from " +"the default editor.\n" +"\n" +"\t\tThe edit-last-applied command allows you to directly edit any API " +"resource you can retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." + +#: staging/src/k8s.io/kubectl/pkg/cmd/wait/wait.go:49 +msgid "" +"\n" +"\t\tExperimental: Wait for a specific condition on one or many resources.\n" +"\n" +"\t\tThe command takes multiple resources and waits until the specified " +"condition\n" +"\t\tis seen in the Status field of every given resource.\n" +"\n" +"\t\tAlternatively, the command can wait for the given set of resources to be " +"deleted\n" +"\t\tby providing the \"delete\" keyword as the value to the --for flag.\n" +"\n" +"\t\tA successful message will be printed to stdout indicating when the " +"specified\n" +" condition has been met. You can use -o option to change to output " +"destination." +msgstr "" +"\n" +"\t\tExperimental: Wait for a specific condition on one or many resources.\n" +"\n" +"\t\tThe command takes multiple resources and waits until the specified " +"condition\n" +"\t\tis seen in the Status field of every given resource.\n" +"\n" +"\t\tAlternatively, the command can wait for the given set of resources to be " +"deleted\n" +"\t\tby providing the \"delete\" keyword as the value to the --for flag.\n" +"\n" +"\t\tA successful message will be printed to stdout indicating when the " +"specified\n" +" condition has been met. You can use -o option to change to output " +"destination." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:47 +msgid "" +"\n" +"\t\tExpose a resource as a new Kubernetes service.\n" +"\n" +"\t\tLooks up a deployment, service, replica set, replication controller or " +"pod by name and uses the selector\n" +"\t\tfor that resource as the selector for a new service on the specified " +"port. A deployment or replica set\n" +"\t\twill be exposed as a service only if its selector is convertible to a " +"selector that service supports,\n" +"\t\ti.e. when the selector contains only the matchLabels component. Note " +"that if no port is specified via\n" +"\t\t--port and the exposed resource has multiple ports, all will be re-used " +"by the new service. Also if no\n" +"\t\tlabels are specified, the new service will re-use the labels from the " +"resource it exposes.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\n" +"\t\t" +msgstr "" +"\n" +"\t\tExpose a resource as a new Kubernetes service.\n" +"\n" +"\t\tLooks up a deployment, service, replica set, replication controller or " +"pod by name and uses the selector\n" +"\t\tfor that resource as the selector for a new service on the specified " +"port. A deployment or replica set\n" +"\t\twill be exposed as a service only if its selector is convertible to a " +"selector that service supports,\n" +"\t\ti.e. when the selector contains only the matchLabels component. Note " +"that if no port is specified via\n" +"\t\t--port and the exposed resource has multiple ports, all will be re-used " +"by the new service. Also if no\n" +"\t\tlabels are specified, the new service will re-use the labels from the " +"resource it exposes.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:46 +msgid "" +"\n" +"\t\tList all available plugin files on a user's PATH.\n" +"\n" +"\t\tAvailable plugin files are those that are:\n" +"\t\t- executable\n" +"\t\t- anywhere on the user's PATH\n" +"\t\t- begin with \"kubectl-\"\n" +msgstr "" +"\n" +"\t\tList all available plugin files on a user's PATH.\n" +"\n" +"\t\tAvailable plugin files are those that are:\n" +"\t\t- executable\n" +"\t\t- anywhere on the user's PATH\n" +"\t\t- begin with \"kubectl-\"\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:35 +msgid "" +"\n" +"\t\tList the fields for supported resources.\n" +"\n" +"\t\tThis command describes the fields associated with each supported API " +"resource.\n" +"\t\tFields are identified via a simple JSONPath identifier:\n" +"\n" +"\t\t\t.[.]\n" +"\n" +"\t\tAdd the --recursive flag to display all of the fields at once without " +"descriptions.\n" +"\t\tInformation about each field is retrieved from the server in OpenAPI " +"format." +msgstr "" +"\n" +"\t\tList the fields for supported resources.\n" +"\n" +"\t\tThis command describes the fields associated with each supported API " +"resource.\n" +"\t\tFields are identified via a simple JSONPath identifier:\n" +"\n" +"\t\t\t.[.]\n" +"\n" +"\t\tAdd the --recursive flag to display all of the fields at once without " +"descriptions.\n" +"\t\tInformation about each field is retrieved from the server in OpenAPI " +"format." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout.go:30 +msgid "" +"\n" +"\t\tManage the rollout of a resource." +msgstr "" +"\n" +"\t\tManage the rollout of a resource." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L127 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:84 +msgid "" +"\n" +"\t\tMark node as schedulable." +msgstr "" +"\n" +"\t\tMark node as schedulable." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:55 +msgid "" +"\n" +"\t\tMark node as unschedulable." +msgstr "" +"\n" +"\t\tMark node as unschedulable." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:57 +msgid "" +"\n" +"\t\tMark the provided resource as paused.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller.\n" +"\t\tUse \"kubectl rollout resume\" to resume a paused resource.\n" +"\t\tCurrently only deployments support being paused." +msgstr "" +"\n" +"\t\tMark the provided resource as paused.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller.\n" +"\t\tUse \"kubectl rollout resume\" to resume a paused resource.\n" +"\t\tCurrently only deployments support being paused." + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:46 +msgid "" +"\n" +"\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +"\t\tThe shell code must be evaluated to provide interactive\n" +"\t\tcompletion of kubectl commands. This can be done by sourcing it from\n" +"\t\tthe .bash_profile.\n" +"\n" +"\t\tDetailed instructions on how to do this are available here:\n" +"\n" +" for macOS:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-macos/#enable-" +"shell-autocompletion\n" +"\n" +" for linux:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/#enable-" +"shell-autocompletion\n" +"\n" +" for windows:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/" +"#enable-shell-autocompletion\n" +"\n" +"\t\tNote for zsh users: [1] zsh completions are only supported in versions " +"of zsh >= 5.2." +msgstr "" +"\n" +"\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +"\t\tThe shell code must be evaluated to provide interactive\n" +"\t\tcompletion of kubectl commands. This can be done by sourcing it from\n" +"\t\tthe .bash_profile.\n" +"\n" +"\t\tDetailed instructions on how to do this are available here:\n" +"\n" +" for macOS:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-macos/#enable-" +"shell-autocompletion\n" +"\n" +" for linux:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/#enable-" +"shell-autocompletion\n" +"\n" +" for windows:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/" +"#enable-shell-autocompletion\n" +"\n" +"\t\tNote for zsh users: [1] zsh completions are only supported in versions " +"of zsh >= 5.2." + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:49 +msgid "" +"\n" +"\t\tPrint the logs for a container in a pod or specified resource. \n" +"\t\tIf the pod has only one container, the container name is optional." +msgstr "" +"\n" +"\t\tPrint the logs for a container in a pod or specified resource. \n" +"\t\tIf the pod has only one container, the container name is optional." + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:37 +msgid "" +"\n" +"\t\tProvides utilities for interacting with plugins.\n" +"\n" +"\t\tPlugins provide extended functionality that is not part of the major " +"command-line distribution.\n" +"\t\tPlease refer to the documentation and examples for more information " +"about how write your own plugins.\n" +"\n" +"\t\tThe easiest way to discover and install plugins is via the kubernetes " +"sub-project krew.\n" +"\t\tTo install krew, visit [krew.sigs.k8s.io](https://krew.sigs.k8s.io/docs/" +"user-guide/setup/install/)" +msgstr "" +"\n" +"\t\tProvides utilities for interacting with plugins.\n" +"\n" +"\t\tPlugins provide extended functionality that is not part of the major " +"command-line distribution.\n" +"\t\tPlease refer to the documentation and examples for more information " +"about how write your own plugins.\n" +"\n" +"\t\tThe easiest way to discover and install plugins is via the kubernetes " +"sub-project krew.\n" +"\t\tTo install krew, visit [krew.sigs.k8s.io](https://krew.sigs.k8s.io/docs/" +"user-guide/setup/install/)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/rename_context.go:47 +msgid "" +"\n" +"\t\tRenames a context from the kubeconfig file.\n" +"\n" +"\t\tCONTEXT_NAME is the context name that you want to change.\n" +"\n" +"\t\tNEW_NAME is the new name you want to set.\n" +"\n" +"\t\tNote: If the context being renamed is the 'current-context', this field " +"will also be updated." +msgstr "" +"\n" +"\t\tRenames a context from the kubeconfig file.\n" +"\n" +"\t\tCONTEXT_NAME is the context name that you want to change.\n" +"\n" +"\t\tNEW_NAME is the new name you want to set.\n" +"\n" +"\t\tNote: If the context being renamed is the 'current-context', this field " +"will also be updated." + +#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:48 +msgid "" +"\n" +"\t\tReplace a resource by file name or stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted. If replacing an existing resource, " +"the\n" +"\t\tcomplete resource spec must be provided. This can be obtained by\n" +"\n" +"\t\t $ kubectl get TYPE NAME -o yaml" +msgstr "" +"\n" +"\t\tReplace a resource by file name or stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted. If replacing an existing resource, " +"the\n" +"\t\tcomplete resource spec must be provided. This can be obtained by\n" +"\n" +"\t\t $ kubectl get TYPE NAME -o yaml" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_restart.go:57 +msgid "" +"\n" +"\t\tRestart a resource.\n" +"\n" +"\t Resource rollout will be restarted." +msgstr "" +"\n" +"\t\tRestart a resource.\n" +"\n" +"\t Resource rollout will be restarted." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:58 +msgid "" +"\n" +"\t\tResume a paused resource.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller. By resuming a\n" +"\t\tresource, we allow it to be reconciled again.\n" +"\t\tCurrently only deployments support being resumed." +msgstr "" +"\n" +"\t\tResume a paused resource.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller. By resuming a\n" +"\t\tresource, we allow it to be reconciled again.\n" +"\t\tCurrently only deployments support being resumed." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:55 +msgid "" +"\n" +"\t\tRoll back to a previous rollout." +msgstr "" +"\n" +"\t\tRoll back to a previous rollout." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_cluster.go:47 +msgid "" +"\n" +"\t\tSet a cluster entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." +msgstr "" +"\n" +"\t\tSet a cluster entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_context.go:44 +msgid "" +"\n" +"\t\tSet a context entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." +msgstr "" +"\n" +"\t\tSet a context entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:40 +msgid "" +"\n" +"\t\tSet a new size for a deployment, replica set, replication controller, or " +"stateful set.\n" +"\n" +"\t\tScale also allows users to specify one or more preconditions for the " +"scale action.\n" +"\n" +"\t\tIf --current-replicas or --resource-version is specified, it is " +"validated before the\n" +"\t\tscale is attempted, and it is guaranteed that the precondition holds " +"true when the\n" +"\t\tscale is sent to the server." +msgstr "" +"\n" +"\t\tSet a new size for a deployment, replica set, replication controller, or " +"stateful set.\n" +"\n" +"\t\tScale also allows users to specify one or more preconditions for the " +"scale action.\n" +"\n" +"\t\tIf --current-replicas or --resource-version is specified, it is " +"validated before the\n" +"\t\tscale is attempted, and it is guaranteed that the precondition holds " +"true when the\n" +"\t\tscale is sent to the server." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_authinfo.go:70 +#, c-format +msgid "" +"\n" +"\t\tSet a user entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values.\n" +"\n" +"\t\t Client-certificate flags:\n" +"\t\t --%v=certfile --%v=keyfile\n" +"\n" +"\t\t Bearer token flags:\n" +"\t\t\t --%v=bearer_token\n" +"\n" +"\t\t Basic auth flags:\n" +"\t\t\t --%v=basic_user --%v=basic_password\n" +"\n" +"\t\tBearer token and basic auth are mutually exclusive." +msgstr "" +"\n" +"\t\tSet a user entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values.\n" +"\n" +"\t\t Client-certificate flags:\n" +"\t\t --%v=certfile --%v=keyfile\n" +"\n" +"\t\t Bearer token flags:\n" +"\t\t\t --%v=bearer_token\n" +"\n" +"\t\t Basic auth flags:\n" +"\t\t\t --%v=basic_user --%v=basic_password\n" +"\n" +"\t\tBearer token and basic auth are mutually exclusive." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:70 +msgid "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." +msgstr "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:67 +#, c-format +msgid "" +"\n" +"\t\tSet the selector on a resource. Note that the new selector will " +"overwrite the old selector if the resource had one prior to the invocation\n" +"\t\tof 'set selector'.\n" +"\n" +"\t\tA selector must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\tIf --resource-version is specified, then updates will use this resource " +"version, otherwise the existing resource-version will be used.\n" +" Note: currently selectors can only be set on Service objects." +msgstr "" +"\n" +"\t\tSet the selector on a resource. Note that the new selector will " +"overwrite the old selector if the resource had one prior to the invocation\n" +"\t\tof 'set selector'.\n" +"\n" +"\t\tA selector must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\tIf --resource-version is specified, then updates will use this resource " +"version, otherwise the existing resource-version will be used.\n" +" Note: currently selectors can only be set on Service objects." + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:39 +msgid "" +"\n" +"\t\tShow details of a specific resource or group of resources.\n" +"\n" +"\t\tPrint a detailed description of the selected resources, including " +"related resources such\n" +"\t\tas events or controllers. You may select a single object by name, all " +"objects of that\n" +"\t\ttype, provide a name prefix, or label selector. For example:\n" +"\n" +"\t\t $ kubectl describe TYPE NAME_PREFIX\n" +"\n" +"\t\twill first check for an exact match on TYPE and NAME_PREFIX. If no such " +"resource\n" +"\t\texists, it will output details for every resource that has a name " +"prefixed with NAME_PREFIX." +msgstr "" +"\n" +"\t\tShow details of a specific resource or group of resources.\n" +"\n" +"\t\tPrint a detailed description of the selected resources, including " +"related resources such\n" +"\t\tas events or controllers. You may select a single object by name, all " +"objects of that\n" +"\t\ttype, provide a name prefix, or label selector. For example:\n" +"\n" +"\t\t $ kubectl describe TYPE NAME_PREFIX\n" +"\n" +"\t\twill first check for an exact match on TYPE and NAME_PREFIX. If no such " +"resource\n" +"\t\texists, it will output details for every resource that has a name " +"prefixed with NAME_PREFIX." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:47 +msgid "" +"\n" +"\t\tShow the status of the rollout.\n" +"\n" +"\t\tBy default 'rollout status' will watch the status of the latest rollout\n" +"\t\tuntil it's done. If you don't want to wait for the rollout to finish " +"then\n" +"\t\tyou can use --watch=false. Note that if a new rollout starts in-between, " +"then\n" +"\t\t'rollout status' will continue watching the latest revision. If you want " +"to\n" +"\t\tpin to a specific revision and abort if it is rolled over by another " +"revision,\n" +"\t\tuse --revision=N where N is the revision you need to watch for." +msgstr "" +"\n" +"\t\tShow the status of the rollout.\n" +"\n" +"\t\tBy default 'rollout status' will watch the status of the latest rollout\n" +"\t\tuntil it's done. If you don't want to wait for the rollout to finish " +"then\n" +"\t\tyou can use --watch=false. Note that if a new rollout starts in-between, " +"then\n" +"\t\t'rollout status' will continue watching the latest revision. If you want " +"to\n" +"\t\tpin to a specific revision and abort if it is rolled over by another " +"revision,\n" +"\t\tuse --revision=N where N is the revision you need to watch for." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:41 +#, c-format +msgid "" +"\n" +"\t\tSpecify compute resource requirements (CPU, memory) for any resource " +"that defines a pod template. If a pod is successfully scheduled, it is " +"guaranteed the amount of resource requested, but may burst up to its " +"specified limits.\n" +"\n" +"\t\tFor each compute resource, if a limit is specified and a request is " +"omitted, the request will default to the limit.\n" +"\n" +"\t\tPossible resources include (case insensitive): %s." +msgstr "" +"\n" +"\t\tSpecify compute resource requirements (CPU, memory) for any resource " +"that defines a pod template. If a pod is successfully scheduled, it is " +"guaranteed the amount of resource requested, but may burst up to its " +"specified limits.\n" +"\n" +"\t\tFor each compute resource, if a limit is specified and a request is " +"omitted, the request will default to the limit.\n" +"\n" +"\t\tPossible resources include (case insensitive): %s." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_env.go:50 +msgid "" +"\n" +"\t\tUpdate environment variables on a pod template.\n" +"\n" +"\t\tList environment variable definitions in one or more pods, pod " +"templates.\n" +"\t\tAdd, update, or remove container environment variable definitions in one " +"or\n" +"\t\tmore pod templates (within replication controllers or deployment " +"configurations).\n" +"\t\tView or modify the environment variable definitions on all containers in " +"the\n" +"\t\tspecified pods or pod templates, or just those that match a wildcard.\n" +"\n" +"\t\tIf \"--env -\" is passed, environment variables can be read from STDIN " +"using the standard env\n" +"\t\tsyntax.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" +msgstr "" +"\n" +"\t\tUpdate environment variables on a pod template.\n" +"\n" +"\t\tList environment variable definitions in one or more pods, pod " +"templates.\n" +"\t\tAdd, update, or remove container environment variable definitions in one " +"or\n" +"\t\tmore pod templates (within replication controllers or deployment " +"configurations).\n" +"\t\tView or modify the environment variable definitions on all containers in " +"the\n" +"\t\tspecified pods or pod templates, or just those that match a wildcard.\n" +"\n" +"\t\tIf \"--env -\" is passed, environment variables can be read from STDIN " +"using the standard env\n" +"\t\tsyntax.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_image.go:71 +msgid "" +"\n" +"\t\tUpdate existing container image(s) of resources.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" +msgstr "" +"\n" +"\t\tUpdate existing container image(s) of resources.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:78 +msgid "" +"\n" +"\t\tUpdate fields of a resource using strategic merge patch, a JSON merge " +"patch, or a JSON patch.\n" +"\n" +"\t\tJSON and YAML formats are accepted." +msgstr "" +"\n" +"\t\tUpdate fields of a resource using strategic merge patch, a JSON merge " +"patch, or a JSON patch.\n" +"\n" +"\t\tJSON and YAML formats are accepted." + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:83 +msgid "" +"\n" +"\t\tUpdate the annotations on one or more resources.\n" +"\n" +"\t\tAll Kubernetes objects support the ability to store additional data with " +"the object as\n" +"\t\tannotations. Annotations are key/value pairs that can be larger than " +"labels and include\n" +"\t\tarbitrary string values such as structured JSON. Tools and system " +"extensions may use\n" +"\t\tannotations to store their own data.\n" +"\n" +"\t\tAttempting to set an annotation that already exists will fail unless --" +"overwrite is set.\n" +"\t\tIf --resource-version is specified and does not match the current " +"resource version on\n" +"\t\tthe server the command will fail." +msgstr "" +"\n" +"\t\tUpdate the annotations on one or more resources.\n" +"\n" +"\t\tAll Kubernetes objects support the ability to store additional data with " +"the object as\n" +"\t\tannotations. Annotations are key/value pairs that can be larger than " +"labels and include\n" +"\t\tarbitrary string values such as structured JSON. Tools and system " +"extensions may use\n" +"\t\tannotations to store their own data.\n" +"\n" +"\t\tAttempting to set an annotation that already exists will fail unless --" +"overwrite is set.\n" +"\t\tIf --resource-version is specified and does not match the current " +"resource version on\n" +"\t\tthe server the command will fail." + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:87 +#, c-format +msgid "" +"\n" +"\t\tUpdate the labels on a resource.\n" +"\n" +"\t\t* A label key and value must begin with a letter or number, and may " +"contain letters, numbers, hyphens, dots, and underscores, up to %[1]d " +"characters each.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* If --overwrite is true, then existing labels can be overwritten, " +"otherwise attempting to overwrite a label will result in an error.\n" +"\t\t* If --resource-version is specified, then updates will use this " +"resource version, otherwise the existing resource-version will be used." +msgstr "" +"\n" +"\t\tUpdate the labels on a resource.\n" +"\n" +"\t\t* A label key and value must begin with a letter or number, and may " +"contain letters, numbers, hyphens, dots, and underscores, up to %[1]d " +"characters each.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* If --overwrite is true, then existing labels can be overwritten, " +"otherwise attempting to overwrite a label will result in an error.\n" +"\t\t* If --resource-version is specified, then updates will use this " +"resource version, otherwise the existing resource-version will be used." + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:70 +#, c-format +msgid "" +"\n" +"\t\tUpdate the taints on one or more nodes.\n" +"\n" +"\t\t* A taint consists of a key, value, and effect. As an argument here, it " +"is expressed as key=value:effect.\n" +"\t\t* The key must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* The value is optional. If given, it must begin with a letter or " +"number, and may contain letters, numbers, hyphens, dots, and underscores, up " +"to %[2]d characters.\n" +"\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +"\t\t* Currently taint can only apply to node." +msgstr "" +"\n" +"\t\tUpdate the taints on one or more nodes.\n" +"\n" +"\t\t* A taint consists of a key, value, and effect. As an argument here, it " +"is expressed as key=value:effect.\n" +"\t\t* The key must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* The value is optional. If given, it must begin with a letter or " +"number, and may contain letters, numbers, hyphens, dots, and underscores, up " +"to %[2]d characters.\n" +"\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +"\t\t* Currently taint can only apply to node." + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:36 +msgid "" +"\n" +"\t\tView previous rollout revisions and configurations." +msgstr "" +"\n" +"\t\tView previous rollout revisions and configurations." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_view_last_applied.go:47 +msgid "" +"\n" +"\t\tView the latest last-applied-configuration annotations by type/name or " +"file.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. You can use " +"the -o option\n" +"\t\tto change the output format." +msgstr "" +"\n" +"\t\tView the latest last-applied-configuration annotations by type/name or " +"file.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. You can use " +"the -o option\n" +"\t\tto change the output format." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:47 +msgid "" +"\n" +"\t # Create a new TLS secret named tls-secret with the given key pair\n" +"\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --key=path/" +"to/tls.key" +msgstr "" +"\n" +"\t # Create a new TLS secret named tls-secret with the given key pair\n" +"\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --key=path/" +"to/tls.key" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:42 +msgid "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" +msgstr "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:74 +msgid "" +"\n" +"\t # Create a new secret named my-secret with keys for each file in folder " +"bar\n" +"\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +"\n" +"\t # Create a new secret named my-secret with specified keys instead of " +"names on disk\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-file=ssh-publickey=path/to/id_rsa.pub\n" +"\n" +"\t # Create a new secret named my-secret with key1=supersecret and " +"key2=topsecret\n" +"\t kubectl create secret generic my-secret --from-literal=key1=supersecret " +"--from-literal=key2=topsecret\n" +"\n" +"\t # Create a new secret named my-secret using a combination of a file and " +"a literal\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-literal=passphrase=topsecret\n" +"\n" +"\t # Create a new secret named my-secret from an env file\n" +"\t kubectl create secret generic my-secret --from-env-file=path/to/bar.env" +msgstr "" +"\n" +"\t # Create a new secret named my-secret with keys for each file in folder " +"bar\n" +"\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +"\n" +"\t # Create a new secret named my-secret with specified keys instead of " +"names on disk\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-file=ssh-publickey=path/to/id_rsa.pub\n" +"\n" +"\t # Create a new secret named my-secret with key1=supersecret and " +"key2=topsecret\n" +"\t kubectl create secret generic my-secret --from-literal=key1=supersecret " +"--from-literal=key2=topsecret\n" +"\n" +"\t # Create a new secret named my-secret using a combination of a file and " +"a literal\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-literal=passphrase=topsecret\n" +"\n" +"\t # Create a new secret named my-secret from an env file\n" +"\t kubectl create secret generic my-secret --from-env-file=path/to/bar.env" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:43 +msgid "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" +msgstr "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_deployment.go:45 +msgid "" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image\n" +"\tkubectl create deployment my-dep --image=busybox\n" +"\n" +"\t# Create a deployment with a command\n" +"\tkubectl create deployment my-dep --image=busybox -- date\n" +"\n" +"\t# Create a deployment named my-dep that runs the nginx image with 3 " +"replicas\n" +"\tkubectl create deployment my-dep --image=nginx --replicas=3\n" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image and expose " +"port 5701\n" +"\tkubectl create deployment my-dep --image=busybox --port=5701" +msgstr "" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image\n" +"\tkubectl create deployment my-dep --image=busybox\n" +"\n" +"\t# Create a deployment with a command\n" +"\tkubectl create deployment my-dep --image=busybox -- date\n" +"\n" +"\t# Create a deployment named my-dep that runs the nginx image with 3 " +"replicas\n" +"\tkubectl create deployment my-dep --image=nginx --replicas=3\n" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image and expose " +"port 5701\n" +"\tkubectl create deployment my-dep --image=busybox --port=5701" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:351 +msgid "" +"\n" +"\t# Create a new ExternalName service named my-ns\n" +"\tkubectl create service externalname my-ns --external-name bar.com" +msgstr "" +"\n" +"\t# Create a new ExternalName service named my-ns\n" +"\tkubectl create service externalname my-ns --external-name bar.com" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:50 +msgid "" +"\n" +"\t# Set deployment nginx-deployment's service account to serviceaccount1\n" +"\tkubectl set serviceaccount deployment nginx-deployment serviceaccount1\n" +"\n" +"\t# Print the result (in YAML format) of updated nginx deployment with the " +"service account from local file, without hitting the API server\n" +"\tkubectl set sa -f nginx-deployment.yaml serviceaccount1 --local --dry-" +"run=client -o yaml\n" +"\t" +msgstr "" +"\n" +"\t# Set deployment nginx-deployment's service account to serviceaccount1\n" +"\tkubectl set serviceaccount deployment nginx-deployment serviceaccount1\n" +"\n" +"\t# Print the result (in YAML format) of updated nginx deployment with the " +"service account from local file, without hitting the API server\n" +"\tkubectl set sa -f nginx-deployment.yaml serviceaccount1 --local --dry-" +"run=client -o yaml\n" +"\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_deployment.go:42 +msgid "" +"\n" +"\tCreate a deployment with the specified name." +msgstr "" +"\n" +"\tCreate a deployment with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:344 +msgid "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." +msgstr "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:61 +msgid "" +"\n" +"\tCreate an ingress with the specified name." +msgstr "" +"\n" +"\tCreate an ingress with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:28 +msgid "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." +msgstr "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/set.go:44 +msgid "" +"\n" +"\tSet an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots.\n" +"\n" +"\tPROPERTY_VALUE is the new value you want to set. Binary fields such as " +"'certificate-authority-data' expect a base64 encoded string unless the --set-" +"raw-bytes flag is used.\n" +"\n" +"\tSpecifying an attribute name that already exists will merge new fields on " +"top of existing values." +msgstr "" +"\n" +"\tSet an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots.\n" +"\n" +"\tPROPERTY_VALUE is the new value you want to set. Binary fields such as " +"'certificate-authority-data' expect a base64 encoded string unless the --set-" +"raw-bytes flag is used.\n" +"\n" +"\tSpecifying an attribute name that already exists will merge new fields on " +"top of existing values." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/unset.go:39 +msgid "" +"\n" +"\tUnset an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots." +msgstr "" +"\n" +"\tUnset an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:43 +msgid "" +"\n" +"\tUpdate the service account of pod template resources.\n" +"\n" +"\tPossible resources (case insensitive) can be:\n" +"\n" +"\t" +msgstr "" +"\n" +"\tUpdate the service account of pod template resources.\n" +"\n" +"\tPossible resources (case insensitive) can be:\n" +"\n" +"\t" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_subject.go:40 +msgid "" +"\n" +"\tUpdate the user, group, or service account in a role binding or cluster " +"role binding." +msgstr "" +"\n" +"\tUpdate the user, group, or service account in a role binding or cluster " +"role binding." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_image.go:68 +msgid "" +"\n" +" \tpod (po), replicationcontroller (rc), deployment (deploy), daemonset " +"(ds), replicaset (rs)" +msgstr "" +"\n" +" \tpod (po), replicationcontroller (rc), deployment (deploy), daemonset " +"(ds), replicaset (rs)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:63 +msgid "" +"\n" +" Forward one or more local ports to a pod.\n" +"\n" +" Use resource type/name such as deployment/mydeployment to " +"select a pod. Resource type defaults to 'pod' if omitted.\n" +"\n" +" If there are multiple pods matching the criteria, a pod will " +"be selected automatically. The\n" +" forwarding session ends when the selected pod terminates, " +"and a rerun of the command is needed\n" +" to resume forwarding." +msgstr "" +"\n" +" Forward one or more local ports to a pod.\n" +"\n" +" Use resource type/name such as deployment/mydeployment to " +"select a pod. Resource type defaults to 'pod' if omitted.\n" +"\n" +" If there are multiple pods matching the criteria, a pod will " +"be selected automatically. The\n" +" forwarding session ends when the selected pod terminates, " +"and a rerun of the command is needed\n" +" to resume forwarding." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:233 +msgid "" +"\n" +" # Create a new ClusterIP service named my-cs\n" +" kubectl create service clusterip my-cs --tcp=5678:8080\n" +"\n" +" # Create a new ClusterIP service named my-cs (in headless mode)\n" +" kubectl create service clusterip my-cs --clusterip=\"None\"" +msgstr "" +"\n" +" # Create a new ClusterIP service named my-cs\n" +" kubectl create service clusterip my-cs --tcp=5678:8080\n" +"\n" +" # Create a new ClusterIP service named my-cs (in headless mode)\n" +" kubectl create service clusterip my-cs --clusterip=\"None\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:311 +msgid "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" +msgstr "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:274 +msgid "" +"\n" +" # Create a new NodePort service named my-ns\n" +" kubectl create service nodeport my-ns --tcp=5678:8080" +msgstr "" +"\n" +" # Create a new NodePort service named my-ns\n" +" kubectl create service nodeport my-ns --tcp=5678:8080" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:102 +msgid "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" +msgstr "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:95 +msgid "" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend'\n" +" # If the same annotation is set multiple times, only the last value will " +"be applied\n" +" kubectl annotate pods foo description='my frontend'\n" +"\n" +" # Update a pod identified by type and name in \"pod.json\"\n" +" kubectl annotate -f pod.json description='my frontend'\n" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend running nginx', overwriting any existing value\n" +" kubectl annotate --overwrite pods foo description='my frontend running " +"nginx'\n" +"\n" +" # Update all pods in the namespace\n" +" kubectl annotate pods --all description='my frontend running nginx'\n" +"\n" +" # Update pod 'foo' only if the resource is unchanged from version 1\n" +" kubectl annotate pods foo description='my frontend running nginx' --" +"resource-version=1\n" +"\n" +" # Update pod 'foo' by removing an annotation named 'description' if it " +"exists\n" +" # Does not require the --overwrite flag\n" +" kubectl annotate pods foo description-" +msgstr "" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend'\n" +" # If the same annotation is set multiple times, only the last value will " +"be applied\n" +" kubectl annotate pods foo description='my frontend'\n" +"\n" +" # Update a pod identified by type and name in \"pod.json\"\n" +" kubectl annotate -f pod.json description='my frontend'\n" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend running nginx', overwriting any existing value\n" +" kubectl annotate --overwrite pods foo description='my frontend running " +"nginx'\n" +"\n" +" # Update all pods in the namespace\n" +" kubectl annotate pods --all description='my frontend running nginx'\n" +"\n" +" # Update pod 'foo' only if the resource is unchanged from version 1\n" +" kubectl annotate pods foo description='my frontend running nginx' --" +"resource-version=1\n" +"\n" +" # Update pod 'foo' by removing an annotation named 'description' if it " +"exists\n" +" # Does not require the --overwrite flag\n" +" kubectl annotate pods foo description-" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:230 +msgid "" +"\n" +" Create a ClusterIP service with the specified name." +msgstr "" +"\n" +" Create a ClusterIP service with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:308 +msgid "" +"\n" +" Create a LoadBalancer service with the specified name." +msgstr "" +"\n" +" Create a LoadBalancer service with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:271 +msgid "" +"\n" +" Create a NodePort service with the specified name." +msgstr "" +"\n" +" Create a NodePort service with the specified name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:93 +msgid "" +"\n" +" Dump cluster information out suitable for debugging and diagnosing " +"cluster problems. By default, dumps everything to\n" +" stdout. You can optionally specify a directory with --output-directory. " +"If you specify a directory, Kubernetes will\n" +" build a set of files in that directory. By default, only dumps things " +"in the current namespace and 'kube-system' namespace, but you can\n" +" switch to a different namespace with the --namespaces flag, or specify --" +"all-namespaces to dump all namespaces.\n" +"\n" +" The command also dumps the logs of all of the pods in the cluster; these " +"logs are dumped into different directories\n" +" based on namespace and pod name." +msgstr "" +"\n" +" Dump cluster information out suitable for debugging and diagnosing " +"cluster problems. By default, dumps everything to\n" +" stdout. You can optionally specify a directory with --output-directory. " +"If you specify a directory, Kubernetes will\n" +" build a set of files in that directory. By default, only dumps things " +"in the current namespace and 'kube-system' namespace, but you can\n" +" switch to a different namespace with the --namespaces flag, or specify --" +"all-namespaces to dump all namespaces.\n" +"\n" +" The command also dumps the logs of all of the pods in the cluster; these " +"logs are dumped into different directories\n" +" based on namespace and pod name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:40 +msgid "" +"\n" +" Display addresses of the control plane and services with label kubernetes." +"io/cluster-service=true.\n" +" To further debug and diagnose cluster problems, use 'kubectl cluster-info " +"dump'." +msgstr "" +"\n" +" Display addresses of the control plane and services with label kubernetes." +"io/cluster-service=true.\n" +" To further debug and diagnose cluster problems, use 'kubectl cluster-info " +"dump'." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:49 +msgid "" +" environment variable is set, then it is used as a list of paths (normal " +"path delimiting rules for your system). These paths are merged. When a value " +"is modified, it is modified in the file that defines the stanza. When a " +"value is created, it is created in the first file that exists. If no files " +"in the chain exist, then it creates the last file in the list.\n" +"\t\t\t3. Otherwise, " +msgstr "" +" environment variable is set, then it is used as a list of paths (normal " +"path delimiting rules for your system). These paths are merged. When a value " +"is modified, it is modified in the file that defines the stanza. When a " +"value is created, it is created in the first file that exists. If no files " +"in the chain exist, then it creates the last file in the list.\n" +"\t\t\t3. Otherwise, " + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:48 +msgid "" +" flag is set, then only that file is loaded. The flag may only be set once " +"and no merging takes place.\n" +"\t\t\t2. If $" +msgstr "" +" flag is set, then only that file is loaded. The flag may only be set once " +"and no merging takes place.\n" +"\t\t\t2. If $" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:50 +msgid " is used and no merging takes place." +msgstr " is used and no merging takes place." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L61 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:107 +msgid "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." +msgstr "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L60 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:106 +msgid "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." +msgstr "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L63 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:113 +msgid "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." +msgstr "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L106 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:152 +msgid "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" +msgstr "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L111 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:157 +msgid "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." +msgstr "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:178 +msgid "Allocate a TTY for the debugging container." +msgstr "Allocate a TTY for the debugging container." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L119 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:158 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:178 +msgid "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." +msgstr "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:173 +msgid "Annotations to apply to the pod." +msgstr "Annotations to apply to the pod." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:173 +msgid "Apply a configuration to a resource by file name or stdin" +msgstr "Apply a configuration to a resource by file name or stdin" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:125 +msgid "Approve a certificate signing request" +msgstr "Approve a certificate signing request" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L81 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:263 +msgid "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." +msgstr "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:106 +msgid "" +"Attach to a process that is already running inside an existing container." +msgstr "" +"Attach to a process that is already running inside an existing container." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/attach.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:105 +msgid "Attach to a running container" +msgstr "Attach to a running container" + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:107 +msgid "" +"Auto-scale a deployment, replica set, stateful set, or replication controller" +msgstr "" +"Auto-scale a deployment, replica set, stateful set, or replication controller" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L115 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:161 +msgid "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." +msgstr "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_clusterrolebinding.go#L55 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:101 +msgid "ClusterRole this ClusterRoleBinding should reference" +msgstr "ClusterRole this ClusterRoleBinding should reference" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L55 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:104 +msgid "ClusterRole this RoleBinding should reference" +msgstr "ClusterRole this RoleBinding should reference" + +#: staging/src/k8s.io/kubectl/pkg/cmd/alpha.go:32 +msgid "Commands for features in alpha" +msgstr "Commands for features in alpha" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:170 +msgid "Container image to use for debug container." +msgstr "Container image to use for debug container." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:166 +msgid "Container name to use for debug container." +msgstr "Container name to use for debug container." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/convert.go#L67 +#: pkg/kubectl/cmd/convert/convert.go:95 +msgid "Convert config files between different API versions" +msgstr "Convert config files between different API versions" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:105 +msgid "Copy files and directories to and from containers" +msgstr "Copy files and directories to and from containers" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/cp.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:106 +msgid "Copy files and directories to and from containers." +msgstr "Copy files and directories to and from containers." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:248 +msgid "Create a ClusterIP service" +msgstr "Create a ClusterIP service" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:323 +msgid "Create a LoadBalancer service" +msgstr "Create a LoadBalancer service" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:286 +msgid "Create a NodePort service" +msgstr "Create a NodePort service" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L214 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:94 +msgid "Create a TLS secret" +msgstr "Create a TLS secret" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:81 +msgid "Create a cluster role" +msgstr "Create a cluster role" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:87 +msgid "Create a cluster role binding for a particular cluster role" +msgstr "Create a cluster role binding for a particular cluster role" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:124 +msgid "Create a config map from a local file, directory or literal value" +msgstr "Create a config map from a local file, directory or literal value" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:167 +msgid "Create a copy of the target Pod with this name." +msgstr "Create a copy of the target Pod with this name." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_cronjob.go:90 +msgid "Create a cron job with the specified name" +msgstr "Create a cron job with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_deployment.go:100 +msgid "Create a deployment with the specified name" +msgstr "Create a deployment with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:91 +msgid "Create a job with the specified name" +msgstr "Create a job with the specified name" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:83 +msgid "Create a namespace with the specified name" +msgstr "Create a namespace with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:95 +msgid "Create a pod disruption budget with the specified name" +msgstr "Create a pod disruption budget with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:92 +msgid "Create a priority class with the specified name" +msgstr "Create a priority class with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:91 +msgid "Create a quota with the specified name" +msgstr "Create a quota with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:106 +msgid "Create a resource from a file or from stdin" +msgstr "Create a resource from a file or from stdin" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:89 +msgid "Create a role binding for a particular role or cluster role" +msgstr "Create a role binding for a particular role or cluster role" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:161 +msgid "Create a role with single rule" +msgstr "Create a role with single rule" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L143 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:134 +msgid "Create a secret for use with a Docker registry" +msgstr "Create a secret for use with a Docker registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:137 +msgid "Create a secret from a local file, directory, or literal value" +msgstr "Create a secret from a local file, directory, or literal value" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L34 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:49 +msgid "Create a secret using specified subcommand" +msgstr "Create a secret using specified subcommand" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:50 +msgid "Create a secret using specified subcommand." +msgstr "Create a secret using specified subcommand." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:85 +msgid "Create a service account with the specified name" +msgstr "Create a service account with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:48 +msgid "Create a service using a specified subcommand" +msgstr "Create a service using a specified subcommand" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:49 +msgid "Create a service using a specified subcommand." +msgstr "Create a service using a specified subcommand." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:363 +msgid "Create an ExternalName service" +msgstr "Create an ExternalName service" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:145 +msgid "Create an ingress with the specified name" +msgstr "Create an ingress with the specified name" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:60 +msgid "Create and run a particular image in a pod." +msgstr "Create and run a particular image in a pod." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:149 +msgid "Create debugging sessions for troubleshooting workloads and nodes" +msgstr "Create debugging sessions for troubleshooting workloads and nodes" + +#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:137 +msgid "" +"Delete resources by file names, stdin, resources and names, or by resources " +"and label selector" +msgstr "" +"Delete resources by file names, stdin, resources and names, or by resources " +"and label selector" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_cluster.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "Delete the specified cluster from the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:43 +msgid "Delete the specified cluster from the kubeconfig." +msgstr "Delete the specified cluster from the kubeconfig." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_context.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "Delete the specified context from the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:43 +msgid "Delete the specified context from the kubeconfig." +msgstr "Delete the specified context from the kubeconfig." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_user.go:64 +msgid "Delete the specified user from the kubeconfig" +msgstr "Delete the specified user from the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_user.go:65 +msgid "Delete the specified user from the kubeconfig." +msgstr "Delete the specified user from the kubeconfig." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L121 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:174 +msgid "Deny a certificate signing request" +msgstr "Deny a certificate signing request" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_contexts.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "Describe one or many contexts" + +#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:142 +msgid "Diff the live version against a would-be applied version" +msgstr "Diff the live version against a would-be applied version" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:65 +msgid "Display cluster information" +msgstr "Display cluster information" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_clusters.go#L40 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "Display clusters defined in the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:42 +msgid "Display clusters defined in the kubeconfig." +msgstr "Display clusters defined in the kubeconfig." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/view.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "Display merged kubeconfig settings or a specified kubeconfig file" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:50 +msgid "Display one or many contexts from the kubeconfig file." +msgstr "Display one or many contexts from the kubeconfig file." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/get.go#L107 +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:165 +msgid "Display one or many resources" +msgstr "Display one or many resources" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top.go:50 +msgid "Display resource (CPU/memory) usage" +msgstr "Display resource (CPU/memory) usage" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:81 +msgid "Display resource (CPU/memory) usage of nodes" +msgstr "Display resource (CPU/memory) usage of nodes" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:100 +msgid "Display resource (CPU/memory) usage of pods" +msgstr "Display resource (CPU/memory) usage of pods" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/current_context.go:51 +msgid "Display the current-context" +msgstr "Display the current-context" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_users.go:60 +msgid "Display users defined in the kubeconfig" +msgstr "Display users defined in the kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_users.go:61 +msgid "Display users defined in the kubeconfig." +msgstr "Display users defined in the kubeconfig." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L176 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:184 +msgid "Drain node in preparation for maintenance" +msgstr "Drain node in preparation for maintenance" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:74 +msgid "Dump relevant information for debugging and diagnosis" +msgstr "Dump relevant information for debugging and diagnosis" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/edit.go#L100 +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:77 +msgid "Edit a resource on the server" +msgstr "Edit a resource on the server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_edit_last_applied.go:67 +msgid "Edit latest last-applied-configuration annotations of a resource/object" +msgstr "" +"Edit latest last-applied-configuration annotations of a resource/object" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L159 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:152 +msgid "Email for Docker registry" +msgstr "Email for Docker registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:169 +msgid "Environment variables to set in the container." +msgstr "Environment variables to set in the container." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/exec.go#L68 +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:89 +msgid "Execute a command in a container" +msgstr "Execute a command in a container" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:90 +msgid "Execute a command in a container." +msgstr "Execute a command in a container." + +#: staging/src/k8s.io/kubectl/pkg/cmd/wait/wait.go:115 +msgid "Experimental: Wait for a specific condition on one or many resources" +msgstr "Experimental: Wait for a specific condition on one or many resources" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:378 +msgid "External name of service" +msgstr "External name of service" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/portforward.go#L75 +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:109 +msgid "Forward one or more local ports to a pod" +msgstr "Forward one or more local ports to a pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:79 +msgid "Get documentation for a resource" +msgstr "Get documentation for a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/help.go#L36 +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:37 +msgid "Help about any command" +msgstr "Help about any command" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:151 +msgid "" +"IP to assign to the LoadBalancer. If empty, an ephemeral IP will be created " +"and used (cloud-provider specific)." +msgstr "" +"IP to assign to the LoadBalancer. If empty, an ephemeral IP will be created " +"and used (cloud-provider specific)." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L114 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:160 +msgid "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" +msgstr "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/annotate.go#L135 +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:157 +msgid "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/label.go#L132 +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:154 +msgid "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:164 +msgid "" +"If specified, everything after -- will be passed to the new container as " +"Args instead of Command." +msgstr "" +"If specified, everything after -- will be passed to the new container as " +"Args instead of Command." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:198 +msgid "If true, run the container in privileged mode." +msgstr "If true, run the container in privileged mode." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:174 +msgid "If true, suppress informational messages." +msgstr "If true, suppress informational messages." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:165 +msgid "" +"If true, wait for the container to start running, and then attach as if " +"'kubectl attach ...' were called. Default false, unless '-i/--stdin' is " +"set, in which case the default is true." +msgstr "" +"If true, wait for the container to start running, and then attach as if " +"'kubectl attach ...' were called. Default false, unless '-i/--stdin' is " +"set, in which case the default is true." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:173 +msgid "" +"Keep stdin open on the container(s) in the pod, even if nothing is attached." +msgstr "" +"Keep stdin open on the container(s) in the pod, even if nothing is attached." + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:90 +msgid "List all visible plugin executables on a user's PATH" +msgstr "List all visible plugin executables on a user's PATH" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout.go:54 +msgid "Manage the rollout of a resource" +msgstr "Manage the rollout of a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L127 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:98 +msgid "Mark node as schedulable" +msgstr "Mark node as schedulable" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:69 +msgid "Mark node as unschedulable" +msgstr "Mark node as unschedulable" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_pause.go#L73 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:83 +msgid "Mark the provided resource as paused" +msgstr "Mark the provided resource as paused" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L35 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:49 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:50 +msgid "Modify certificate resources." +msgstr "Modify certificate resources." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/config.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "Modify kubeconfig files" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L110 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:156 +msgid "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." +msgstr "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." + +#: staging/src/k8s.io/kubectl/pkg/cmd/alpha.go:43 +msgid "No alpha commands are available in this version of kubectl" +msgstr "No alpha commands are available in this version of kubectl" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/logs.go#L108 +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:174 +msgid "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." +msgstr "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/completion.go#L97 +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:112 +msgid "Output shell completion code for the specified shell (bash or zsh)" +msgstr "Output shell completion code for the specified shell (bash or zsh)" + +#: pkg/kubectl/cmd/convert/convert.go:105 +msgid "" +"Output the formatted object with the given group version (for ex: " +"'extensions/v1beta1')." +msgstr "" +"Output the formatted object with the given group version (for ex: " +"'extensions/v1beta1')." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L157 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:151 +msgid "Password for Docker registry authentication" +msgstr "Password for Docker registry authentication" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L226 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:110 +msgid "Path to PEM encoded public key certificate." +msgstr "Path to PEM encoded public key certificate." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L227 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:111 +msgid "Path to private key associated with given certificate." +msgstr "Path to private key associated with given certificate." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/scale.go#L82 +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:130 +msgid "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." +msgstr "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/version.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:73 +msgid "Print the client and server version information" +msgstr "Print the client and server version information" + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:74 +msgid "" +"Print the client and server version information for the current context." +msgstr "" +"Print the client and server version information for the current context." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/options.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:38 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:39 +msgid "Print the list of flags inherited by all commands" +msgstr "Print the list of flags inherited by all commands" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/logs.go#L86 +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:152 +msgid "Print the logs for a container in a pod" +msgstr "Print the logs for a container in a pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiresources.go:97 +msgid "Print the supported API resources on the server" +msgstr "Print the supported API resources on the server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiresources.go:98 +msgid "Print the supported API resources on the server." +msgstr "Print the supported API resources on the server." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:58 +msgid "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"" +msgstr "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:59 +msgid "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"." +msgstr "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"." + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:62 +msgid "Provides utilities for interacting with plugins" +msgstr "Provides utilities for interacting with plugins" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/rename_context.go:45 +msgid "Rename a context from the kubeconfig file" +msgstr "Rename a context from the kubeconfig file" + +#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:115 +msgid "Replace a resource by file name or stdin" +msgstr "Replace a resource by file name or stdin" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_restart.go:87 +msgid "Restart a resource" +msgstr "Restart a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_resume.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:87 +msgid "Resume a paused resource" +msgstr "Resume a paused resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L56 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:105 +msgid "Role this RoleBinding should reference" +msgstr "Role this RoleBinding should reference" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L94 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:152 +msgid "Run a particular image on the cluster" +msgstr "Run a particular image on the cluster" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/proxy.go#L68 +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:119 +msgid "Run a proxy to the Kubernetes API server" +msgstr "Run a proxy to the Kubernetes API server" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L161 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:153 +msgid "Server location for Docker registry" +msgstr "Server location for Docker registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_cluster.go:73 +msgid "Set a cluster entry in kubeconfig" +msgstr "Set a cluster entry in kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_context.go:61 +msgid "Set a context entry in kubeconfig" +msgstr "Set a context entry in kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:114 +msgid "Set a new size for a deployment, replica set, or replication controller" +msgstr "" +"Set a new size for a deployment, replica set, or replication controller" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_authinfo.go:152 +msgid "Set a user entry in kubeconfig" +msgstr "Set a user entry in kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/set.go:74 +msgid "Set an individual value in a kubeconfig file" +msgstr "Set an individual value in a kubeconfig file" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:39 +msgid "Set specific features on objects" +msgstr "Set specific features on objects" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/use_context.go:52 +msgid "Set the current-context in a kubeconfig file" +msgstr "Set the current-context in a kubeconfig file" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:101 +msgid "" +"Set the last-applied-configuration annotation on a live object to match the " +"contents of a file" +msgstr "" +"Set the last-applied-configuration annotation on a live object to match the " +"contents of a file" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_selector.go#L81 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:104 +msgid "Set the selector on a resource" +msgstr "Set the selector on a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/describe.go#L80 +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:107 +msgid "Show details of a specific resource or group of resources" +msgstr "Show details of a specific resource or group of resources" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_status.go#L57 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:102 +msgid "Show the status of the rollout" +msgstr "Show the status of the rollout" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L108 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:154 +msgid "Synonym for --target-port" +msgstr "Synonym for --target-port" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:134 +msgid "" +"Take a replication controller, service, deployment or pod and expose it as a " +"new Kubernetes service" +msgstr "" +"Take a replication controller, service, deployment or pod and expose it as a " +"new Kubernetes service" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L114 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:174 +msgid "The image for the container to run." +msgstr "The image for the container to run." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L116 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:176 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" +msgstr "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:172 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server." +msgstr "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:112 +msgid "" +"The maximum number or percentage of unavailable pods this budget requires." +msgstr "" +"The maximum number or percentage of unavailable pods this budget requires." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:111 +msgid "" +"The minimum number or percentage of available pods this budget requires." +msgstr "" +"The minimum number or percentage of available pods this budget requires." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L113 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:159 +msgid "The name for the newly created object." +msgstr "The name for the newly created object." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/autoscale.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:125 +msgid "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." +msgstr "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L98 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:147 +msgid "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." +msgstr "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L99 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:148 +msgid "The network protocol for the service to be created. Default is 'TCP'." +msgstr "The network protocol for the service to be created. Default is 'TCP'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L100 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:149 +msgid "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" +msgstr "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:182 +msgid "The port that this container exposes." +msgstr "The port that this container exposes." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L131 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:194 +msgid "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." +msgstr "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L130 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:192 +msgid "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." +msgstr "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:190 +msgid "" +"The restart policy for this Pod. Legal values [Always, OnFailure, Never]." +msgstr "" +"The restart policy for this Pod. Legal values [Always, OnFailure, Never]." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L87 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:155 +msgid "The type of secret to create" +msgstr "The type of secret to create" + +#: staging/src/k8s.io/kubectl/pkg/cmd/alpha.go:33 +msgid "" +"These commands correspond to alpha features that are not enabled in " +"Kubernetes clusters by default." +msgstr "" +"These commands correspond to alpha features that are not enabled in " +"Kubernetes clusters by default." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:150 +msgid "" +"Type for this service: ClusterIP, NodePort, LoadBalancer, or ExternalName. " +"Default is 'ClusterIP'." +msgstr "" +"Type for this service: ClusterIP, NodePort, LoadBalancer, or ExternalName. " +"Default is 'ClusterIP'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_undo.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:87 +msgid "Undo a previous rollout" +msgstr "Undo a previous rollout" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/unset.go:59 +msgid "Unset an individual value in a kubeconfig file" +msgstr "Unset an individual value in a kubeconfig file" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_env.go:154 +msgid "Update environment variables on a pod template" +msgstr "Update environment variables on a pod template" + +#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:115 +msgid "Update fields of a resource" +msgstr "Update fields of a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_resources.go#L101 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:116 +msgid "Update resource requests/limits on objects with pod templates" +msgstr "Update resource requests/limits on objects with pod templates" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "Update the annotations on a resource" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_image.go:110 +msgid "Update the image of a pod template" +msgstr "Update the image of a pod template" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/label.go#L109 +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:133 +msgid "Update the labels on a resource" +msgstr "Update the labels on a resource" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:102 +msgid "Update the service account of a resource" +msgstr "Update the service account of a resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/taint.go#L88 +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:109 +msgid "Update the taints on one or more nodes" +msgstr "Update the taints on one or more nodes" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_subject.go:99 +msgid "" +"Update the user, group, or service account in a role binding or cluster role " +"binding" +msgstr "" +"Update the user, group, or service account in a role binding or cluster role " +"binding" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L155 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:150 +msgid "Username for Docker registry authentication" +msgstr "Username for Docker registry authentication" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_history.go#L51 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:83 +msgid "View rollout history" +msgstr "View rollout history" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_view_last_applied.go:77 +msgid "" +"View the latest last-applied-configuration annotations of a resource/object" +msgstr "" +"View the latest last-applied-configuration annotations of a resource/object" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:171 +msgid "" +"When used with '--copy-to', a list of name=image pairs for changing " +"container images, similar to how 'kubectl set image' works." +msgstr "" +"When used with '--copy-to', a list of name=image pairs for changing " +"container images, similar to how 'kubectl set image' works." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:168 +msgid "When used with '--copy-to', delete the original Pod." +msgstr "When used with '--copy-to', delete the original Pod." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:176 +msgid "" +"When used with '--copy-to', enable process namespace sharing in the copy." +msgstr "" +"When used with '--copy-to', enable process namespace sharing in the copy." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:175 +msgid "" +"When used with '--copy-to', schedule the copy of target Pod on the same node." +msgstr "" +"When used with '--copy-to', schedule the copy of target Pod on the same node." + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:177 +msgid "" +"When using an ephemeral container, target processes in this container name." +msgstr "" +"When using an ephemeral container, target processes in this container name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/clusterinfo_dump.go#L45 +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:85 +msgid "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" +msgstr "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:108 +msgid "" +"description is an arbitrary string that usually provides guidelines on when " +"this priority class should be used." +msgstr "" +"description is an arbitrary string that usually provides guidelines on when " +"this priority class should be used." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run_test.go:88 +msgid "dummy restart flag)" +msgstr "dummy restart flag)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:107 +msgid "" +"global-default specifies whether this PriorityClass should be considered as " +"the default priority." +msgstr "" +"global-default specifies whether this PriorityClass should be considered as " +"the default priority." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/cmd.go#L217 +#: staging/src/k8s.io/kubectl/pkg/cmd/cmd.go:227 +msgid "kubectl controls the Kubernetes cluster manager" +msgstr "kubectl controls the Kubernetes cluster manager" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:45 +msgid "" +"pod (po), service (svc), replicationcontroller (rc), deployment (deploy), " +"replicaset (rs)" +msgstr "" +"pod (po), service (svc), replicationcontroller (rc), deployment (deploy), " +"replicaset (rs)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:109 +msgid "" +"preemption-policy is the policy for preempting pods with lower priority." +msgstr "" +"preemption-policy is the policy for preempting pods with lower priority." + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:41 +msgid "" +"replicationcontroller (rc), deployment (deploy), daemonset (ds), job, " +"replicaset (rs), statefulset" +msgstr "" +"replicationcontroller (rc), deployment (deploy), daemonset (ds), job, " +"replicaset (rs), statefulset" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:106 +msgid "the value of this priority class." +msgstr "the value of this priority class." diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/fr_FR/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/fr_FR/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..5a22e42887 Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/fr_FR/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/fr_FR/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/fr_FR/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..78b601a372 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/fr_FR/LC_MESSAGES/k8s.po @@ -0,0 +1,103 @@ +# Test translations for unit tests. +# Copyright (C) 2016 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR brendan.d.burns@gmail.com, 2016. +# +msgid "" +msgstr "" +"Project-Id-Version: gettext-go-examples-hello\n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2017-01-29 22:54-0800\n" +"Last-Translator: Brendan Burns \n" +"Language-Team: \n" +"Language: fr\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 1.6.10\n" +"X-Poedit-SourceCharset: UTF-8\n" +"Plural-Forms: nplurals=2; plural=(n > 1);\n" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_cluster.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "Supprimer le cluster spécifié du kubeconfig" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_context.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "Supprimer le contexte spécifié du kubeconfig" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_contexts.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "Décrire un ou plusieurs contextes" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_clusters.go#L40 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "Afficher les cluster définis dans kubeconfig" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/view.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "" +"Afficher les paramètres fusionnés de kubeconfig ou d'un fichier kubeconfig " +"spécifié" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/config.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "Modifier des fichiers kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "Mettre à jour les annotations d'une ressource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/apply.go#L98 +#~ msgid "Apply a configuration to a resource by filename or stdin" +#~ msgstr "" +#~ "Appliquer une configuration à une ressource par nom de fichier ou depuis " +#~ "stdin" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/current_context.go#L48 +#~ msgid "Displays the current-context" +#~ msgstr "Affiche le contexte actuel" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_cluster.go#L67 +#~ msgid "Sets a cluster entry in kubeconfig" +#~ msgstr "Définit un cluster dans kubeconfig" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_context.go#L57 +#~ msgid "Sets a context entry in kubeconfig" +#~ msgstr "Définit un contexte dans kubeconfig" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_authinfo.go#L103 +#~ msgid "Sets a user entry in kubeconfig" +#~ msgstr "Définit un utilisateur dans kubeconfig" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/set.go#L59 +#~ msgid "Sets an individual value in a kubeconfig file" +#~ msgstr "Définit une valeur individuelle dans un fichier kubeconfig" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/use_context.go#L48 +#~ msgid "Sets the current-context in a kubeconfig file" +#~ msgstr "Définit le contexte courant dans un fichier kubeconfig" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/unset.go#L47 +#~ msgid "Unsets an individual value in a kubeconfig file" +#~ msgstr "Supprime une valeur individuelle dans un fichier kubeconfig" + +#~ msgid "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgid_plural "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgstr[0] "" +#~ "watch n'est compatible qu'avec les ressources individuelles et les " +#~ "collections de ressources. - %d ressource a été trouvée. " +#~ msgstr[1] "" +#~ "watch n'est compatible qu'avec les ressources individuelles et les " +#~ "collections de ressources. - %d ressources ont été trouvées. " diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/it_IT/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/it_IT/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..afe881717e Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/it_IT/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/it_IT/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/it_IT/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..13bb37b246 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/it_IT/LC_MESSAGES/k8s.po @@ -0,0 +1,3249 @@ +# Italian translation. +# Copyright (C) 2017 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR evolution85@gmail.com, 2017. +# +msgid "" +msgstr "" +"Project-Id-Version: kubernetes\n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2017-08-28 15:20+0200\n" +"Last-Translator: Luca Berton \n" +"Language-Team: Luca Berton \n" +"Language: it_IT\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"X-Generator: Poedit 1.8.7.1\n" +"X-Poedit-SourceCharset: UTF-8\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:62 +msgid "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" +msgstr "" +"\n" +"\t\t # Mostra metriche per tutti i nodi\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Mostra metriche per un determinato nodo\n" +"\t\t kubectl top node NODE_NAME" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:46 +msgid "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" +msgstr "" +"\n" +"\t\t# Ottieni la documentazione della risorsa e i relativi campi\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Ottieni la documentazione di un campo specifico di una risorsa\n" +"\t\tkubectl explain pods.spec.containers" + +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:29 +msgid "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" +msgstr "" +"\n" +"\t\t# Stampa i flag ereditati da tutti i comandi\n" +"\t\tkubectl options" + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:44 +msgid "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" +msgstr "" +"\n" +"\t\t# Stampa le versioni client e server per il current context\n" +"\t\tkubectl version" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:34 +msgid "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" +msgstr "" +"\n" +"\t\t# Stampa le versioni API supportate\n" +"\t\tkubectl api-versions" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:75 +msgid "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" +msgstr "" +"\n" +"\t\t# Mostra metriche di tutti i pod nello spazio dei nomi predefinito\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Mostra metriche di tutti i pod nello spazio dei nomi specificato\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Mostra metriche per un pod e i suoi relativi container\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Mostra metriche per i pod definiti da label name = myLabel\n" +"\t\tkubectl top pod -l name=myLabel" + +#: pkg/kubectl/cmd/convert/convert.go:40 +msgid "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." +msgstr "" +"\n" +"\t\tConvertire i file di configurazione tra diverse versioni API. Sono\n" +"\t\taccettati i formati YAML e JSON.\n" +"\n" +"\t\tIl comando prende il nome di file, la directory o l'URL come input e lo " +"converte nel formato\n" +"\t\tdi versione specificata dal flag -output-version. Se la versione di " +"destinazione non è specificata o\n" +"\t\tnon supportata, viene convertita nella versione più recente.\n" +"\n" +"\t\tL'output predefinito verrà stampato su stdout nel formato YAML. Si può " +"usare l'opzione -o\n" +"\t\tper cambiare la destinazione di output." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:39 +msgid "" +"\n" +"\t\tCreate a namespace with the specified name." +msgstr "" +"\n" +"\t\tCreare un namespace con il nome specificato." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:43 +msgid "" +"\n" +"\t\tCreate a role with single rule." +msgstr "" +"\n" +"\t\tCrea un ruolo con una singola regola." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:40 +msgid "" +"\n" +"\t\tCreate a service account with the specified name." +msgstr "" +"\n" +"\t\tCreare un service account con il nome specificato." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:84 +msgid "" +"\n" +"\t\tMark node as schedulable." +msgstr "" +"\n" +"\t\tContrassegna il nodo come programmabile." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:55 +msgid "" +"\n" +"\t\tMark node as unschedulable." +msgstr "" +"\n" +"\t\tContrassegnare il nodo come non programmabile." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:70 +msgid "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." +msgstr "" +"\n" +"\t\tImposta le annotazioni dell'ultima-configurazione-applicata impostandola " +"in modo che corrisponda al contenuto di un file.\n" +"\t\tCiò determina l'aggiornamento dell'ultima-configurazione-applicata come " +"se 'kubectl apply -f ' fosse stato eseguito,\n" +"\t\tsenza aggiornare altre parti dell'oggetto." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:42 +msgid "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" +msgstr "" +"\n" +"\t # Crea un nuovo namespace denominato my-namespace\n" +"\t kubectl create namespace my-namespace" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:43 +msgid "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" +msgstr "" +"\n" +"\t # Crea un nuovo service account denominato my-service-account\n" +"\t kubectl create serviceaccount my-service-account" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:344 +msgid "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." +msgstr "" +"\n" +"\tCrea un servizio ExternalName con il nome specificato.\n" +"\n" +"\tIl servizio ExternalName fa riferimento a un indirizzo DNS esterno \n" +"\tsolo pod, che permetteranno agli autori delle applicazioni di utilizzare i " +"servizi di riferimento\n" +"\tche esistono fuori dalla piattaforma, su altri cluster, o localmente.." + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:28 +msgid "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." +msgstr "" +"\n" +"\tHelp fornisce assistenza per qualsiasi comando nell'applicazione.\n" +"\tBasta digitare kubectl help [path to command] per i dettagli completi." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:311 +msgid "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" +msgstr "" +"\n" +" # Creare un nuovo servizio LoadBalancer denominato my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:102 +msgid "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" +msgstr "" +"\n" +" # Dump dello stato corrente del cluster verso stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump dello stato corrente del cluster verso /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump di tutti i namespaces verso stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump di un set di namespace verso /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:308 +msgid "" +"\n" +" Create a LoadBalancer service with the specified name." +msgstr "" +"\n" +" Crea un servizio LoadBalancer con il nome specificato." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:107 +msgid "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." +msgstr "" +"Un insieme delimitato-da-virgole di quota scopes che devono corrispondere a " +"ciascun oggetto gestito dalla quota." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:106 +msgid "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." +msgstr "" +"Un insieme delimitato-da-virgola di coppie risorsa = quantità che " +"definiscono un hard limit." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:113 +msgid "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." +msgstr "" +"Un label selector da utilizzare per questo budget. Sono supportati solo i " +"selettori equality-based selector." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:152 +msgid "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" +msgstr "" +"Un selettore di label da utilizzare per questo servizio. Sono supportati " +"solo equality-based selector. Se vuota (default) dedurre il selettore dal " +"replication controller o replica set.)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:157 +msgid "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." +msgstr "" +"Indirizzo IP esterno aggiuntivo (non gestito da Kubernetes) da accettare per " +"il servizio. Se questo IP viene indirizzato a un nodo, è possibile accedere " +"da questo IP in aggiunta al service IP generato." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:158 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:178 +msgid "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." +msgstr "" +"Un override JSON inline per l'oggetto generato. Se questo non è vuoto, viene " +"utilizzato per ignorare l'oggetto generato. Richiede che l'oggetto fornisca " +"un campo valido apiVersion." + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:125 +msgid "Approve a certificate signing request" +msgstr "Approva una richiesta di firma del certificato" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:263 +msgid "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." +msgstr "" +"Assegnare il proprio ClusterIP o impostare su 'None' per un servizio " +"'headless' (nessun bilanciamento del carico)." + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:105 +msgid "Attach to a running container" +msgstr "Collega a un container in esecuzione" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:161 +msgid "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." +msgstr "" +"ClusterIP da assegnare al servizio. Lasciare vuoto per allocare " +"automaticamente o impostare su 'None' per creare un servizio headless." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:101 +msgid "ClusterRole this ClusterRoleBinding should reference" +msgstr "ClusterRole a cui questo ClusterRoleBinding fa riferimento" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:104 +msgid "ClusterRole this RoleBinding should reference" +msgstr "ClusterRole a cui questo RoleBinding fa riferimento" + +#: pkg/kubectl/cmd/convert/convert.go:95 +msgid "Convert config files between different API versions" +msgstr "Convertire i file di configurazione tra diverse versioni APIs" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:106 +msgid "Copy files and directories to and from containers." +msgstr "Copiare file e directory da e verso i container." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:94 +msgid "Create a TLS secret" +msgstr "Crea un secret TLS" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:83 +msgid "Create a namespace with the specified name" +msgstr "Crea un namespace con il nome specificato" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:134 +msgid "Create a secret for use with a Docker registry" +msgstr "Crea un secret da utilizzare con un registro Docker" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:49 +msgid "Create a secret using specified subcommand" +msgstr "Crea un secret utilizzando un subcommand specificato" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:85 +msgid "Create a service account with the specified name" +msgstr "Creare un account di servizio con il nome specificato" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "Elimina il cluster specificato dal kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "Elimina il context specificato dal kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:174 +msgid "Deny a certificate signing request" +msgstr "Nega una richiesta di firma del certificato" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "Descrive uno o più context" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "Mostra i cluster definiti nel kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "" +"Visualizza le impostazioni merged di kubeconfig o un file kubeconfig " +"specificato" + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:165 +msgid "Display one or many resources" +msgstr "Visualizza una o più risorse" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:184 +msgid "Drain node in preparation for maintenance" +msgstr "Drain node in preparazione alla manutenzione" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:77 +msgid "Edit a resource on the server" +msgstr "Modificare una risorsa sul server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:152 +msgid "Email for Docker registry" +msgstr "Email per il registro Docker" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:89 +msgid "Execute a command in a container" +msgstr "Esegui un comando in un contenitore" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:109 +msgid "Forward one or more local ports to a pod" +msgstr "Inoltra una o più porte locali a un pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:37 +msgid "Help about any command" +msgstr "Aiuto per qualsiasi comando" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:160 +msgid "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" +msgstr "" +"Se non è vuoto, impostare l'affinità di sessione per il servizio; Valori " +"validi: 'None', 'ClientIP'" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:157 +msgid "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"Se non è vuoto, l'aggiornamento delle annotazioni avrà successo solo se " +"questa è la resource-version corrente per l'oggetto. Valido solo quando si " +"specifica una singola risorsa." + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:154 +msgid "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"Se non vuoto, l'aggiornamento delle label avrà successo solo se questa è la " +"resource-version corrente per l'oggetto. Valido solo quando si specifica una " +"singola risorsa." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:98 +msgid "Mark node as schedulable" +msgstr "Contrassegnare il nodo come programmabile" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:69 +msgid "Mark node as unschedulable" +msgstr "Contrassegnare il nodo come non programmabile" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:83 +msgid "Mark the provided resource as paused" +msgstr "Imposta la risorsa indicata in pausa" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:49 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:50 +msgid "Modify certificate resources." +msgstr "Modificare le risorse del certificato." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "Modifica i file kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:156 +msgid "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." +msgstr "" +"Nome o numero di porta nel container verso il quale il servizio deve " +"dirigere il traffico. Opzionale." + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:174 +msgid "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." +msgstr "" +"Restituisce solo i log dopo una data specificata (RFC3339). Predefinito " +"tutti i log. È possibile utilizzare solo uno tra data-inizio/a-partire-da." + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:112 +msgid "Output shell completion code for the specified shell (bash or zsh)" +msgstr "" +"Codice di completamento shell di output per la shell specificata (bash o zsh)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:151 +msgid "Password for Docker registry authentication" +msgstr "Password per l'autenticazione al registro di Docker" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:110 +msgid "Path to PEM encoded public key certificate." +msgstr "Percorso certificato di chiave pubblica codificato PEM." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:111 +msgid "Path to private key associated with given certificate." +msgstr "Percorso alla chiave privata associata a un certificato specificato." + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:130 +msgid "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." +msgstr "" +"Prerequisito per la versione delle risorse. Richiede che la versione " +"corrente delle risorse corrisponda a questo valore per scalare." + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:73 +msgid "Print the client and server version information" +msgstr "Stampa per client e server le informazioni sulla versione" + +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:38 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:39 +msgid "Print the list of flags inherited by all commands" +msgstr "Stampa l'elenco flag ereditati da tutti i comandi" + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:152 +msgid "Print the logs for a container in a pod" +msgstr "Stampa i log per container in un pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:87 +msgid "Resume a paused resource" +msgstr "Riprendere una risorsa in pausa" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:105 +msgid "Role this RoleBinding should reference" +msgstr "Ruolo di riferimento per RoleBinding" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:152 +msgid "Run a particular image on the cluster" +msgstr "Esegui una particolare immagine nel cluster" + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:119 +msgid "Run a proxy to the Kubernetes API server" +msgstr "Eseguire un proxy al server Kubernetes API" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:153 +msgid "Server location for Docker registry" +msgstr "Posizione del server per il Registro Docker" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:39 +msgid "Set specific features on objects" +msgstr "Imposta caratteristiche specifiche sugli oggetti" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:104 +msgid "Set the selector on a resource" +msgstr "Impostare il selettore di una risorsa" + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:107 +msgid "Show details of a specific resource or group of resources" +msgstr "Mostra i dettagli di una specifica risorsa o un gruppo di risorse" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:102 +msgid "Show the status of the rollout" +msgstr "Mostra lo stato del rollout" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:154 +msgid "Synonym for --target-port" +msgstr "Sinonimo di --target-port" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:174 +msgid "The image for the container to run." +msgstr "L'immagine per il container da eseguire." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:176 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" +msgstr "" +"La politica di pull dell'immagine per il container. Se lasciato vuoto, " +"questo valore non verrà specificato dal client e predefinito dal server" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:111 +msgid "" +"The minimum number or percentage of available pods this budget requires." +msgstr "" +"Il numero minimo o la percentuale di pod disponibili che questo budget " +"richiede." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:159 +msgid "The name for the newly created object." +msgstr "Il nome dell'oggetto appena creato." + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:125 +msgid "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." +msgstr "" +"Il nome dell'oggetto appena creato. Se non specificato, verrà utilizzato il " +"nome della risorsa di input." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:147 +msgid "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." +msgstr "" +"Il nome del generatore API da utilizzare. Ci sono 2 generatori: 'service/v1' " +"e 'service/v2'. L'unica differenza tra loro è che la porta di servizio in v1 " +"è denominata \"predefinita\", mentre viene lasciata unnamed in v2. Il valore " +"predefinito è 'service/v2'." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:148 +msgid "The network protocol for the service to be created. Default is 'TCP'." +msgstr "" +"Il protocollo di rete per il servizio da creare. Il valore predefinito è " +"'TCP'." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:149 +msgid "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" +msgstr "" +"La porta che il servizio deve servire. Copiato dalla risorsa esposta, se non " +"specificata" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:194 +msgid "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." +msgstr "" +"I limiti delle richieste di risorse per questo contenitore. Ad esempio, " +"'cpu=200m,memory=512Mi'. Si noti che i componenti lato server possono " +"assegnare i limiti a seconda della configurazione del server, ad esempio " +"intervalli di limiti." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:192 +msgid "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." +msgstr "" +"La risorsa necessita di richieste di requisiti per questo pod. Ad esempio, " +"'cpu = 100m, memoria = 256Mi'. Si noti che i componenti lato server possono " +"assegnare i requisiti a seconda della configurazione del server, ad esempio " +"intervalli di limiti." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:155 +msgid "The type of secret to create" +msgstr "Tipo di segreto da creare" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:87 +msgid "Undo a previous rollout" +msgstr "Annulla un precedente rollout" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:116 +msgid "Update resource requests/limits on objects with pod templates" +msgstr "Aggiorna richieste di risorse/limiti sugli oggetti con pod template" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "Aggiorna annotazioni di risorsa" + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:133 +msgid "Update the labels on a resource" +msgstr "Aggiorna label di una risorsa" + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:109 +msgid "Update the taints on one or more nodes" +msgstr "Aggiorna i taints su uno o più nodi" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:150 +msgid "Username for Docker registry authentication" +msgstr "Nome utente per l'autenticazione nel registro Docker" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:83 +msgid "View rollout history" +msgstr "Visualizza la storia del rollout" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:85 +msgid "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" +msgstr "" +"Dove eseguire l'output dei file. Se vuota o '-' utilizza lo stdout, " +"altrimenti crea una gerarchia di directory in quella directory" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run_test.go:88 +msgid "dummy restart flag)" +msgstr "flag di riavvio finto)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cmd.go:227 +msgid "kubectl controls the Kubernetes cluster manager" +msgstr "Kubectl controlla il gestore cluster di Kubernetes" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a ClusterRoleBinding for user1, user2, and group1 using " +#~ "the cluster-admin ClusterRole\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin --user=user1 --user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Creare un ClusterRoleBinding per user1, user2 e group1 utilizzando " +#~ "il cluster-admin ClusterRole\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin --user=user1 --user=user2 --group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a RoleBinding for user1, user2, and group1 using the admin " +#~ "ClusterRole\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +#~ "user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Crea un RoleBinding per user1, user2, and group1 utilizzando " +#~ "l'admin ClusterRole\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +#~ "user=user2 --group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config based on folder bar\n" +#~ "\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with specified keys " +#~ "instead of file basenames on disk\n" +#~ "\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/" +#~ "file1.txt --from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with key1=config1 and " +#~ "key2=config2\n" +#~ "\t\t kubectl create configmap my-config --from-literal=key1=config1 --" +#~ "from-literal=key2=config2" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Crea un nuovo configmap denominato my-config in base alla " +#~ "cartella bar\n" +#~ "\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # Crea un nuovo configmap denominato my-config con le chiavi " +#~ "specificate anziché i nomi dei file su disco\n" +#~ "\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/" +#~ "file1.txt --from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # Crea un nuovo configmap denominato my-config con key1 = config1 e " +#~ "key2 = config2\n" +#~ "\t\t kubectl create configmap my-config --from-literal=key1=config1 --" +#~ "from-literal=key2=config2" + +#~ msgid "" +#~ "\n" +#~ "\t\t # If you don't already have a .dockercfg file, you can create a " +#~ "dockercfg secret directly by using:\n" +#~ "\t\t kubectl create secret docker-registry my-secret --docker-" +#~ "server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +#~ "password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Se non si dispone ancora di un file .dockercfg, è possibile " +#~ "creare un secret dockercfg direttamente utilizzando:\n" +#~ "\t\t kubectl create secret docker-registry my-secret --docker-" +#~ "server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +#~ "password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Apply the configuration in pod.json to a pod.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Apply the JSON passed into stdin to a pod.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Note: --prune is still in Alpha\n" +#~ "\t\t# Apply the configuration in manifest.yaml that matches label " +#~ "app=nginx and delete all the other resources that are not in the file and " +#~ "match label app=nginx.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# Apply the configuration in manifest.yaml and delete all the other " +#~ "configmaps that are not in the file.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/" +#~ "v1/ConfigMap" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Applica la configurazione pod.json a un pod.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Applicare il JSON passato in stdin a un pod.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Nota: --prune è ancora in in Alpha\n" +#~ "\t\t# Applica la configurazione manifest.yaml che corrisponde alla label " +#~ "app = nginx ed elimina tutte le altre risorse che non sono nel file e " +#~ "nella label corrispondente app = nginx.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# Applica la configurazione manifest.yaml ed elimina tutti gli altri " +#~ "configmaps non presenti nel file.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/" +#~ "v1/ConfigMap" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 " +#~ "and 10, no target CPU utilization specified so a default autoscaling " +#~ "policy will be used:\n" +#~ "\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +#~ "\n" +#~ "\t\t# Auto scale a replication controller \"foo\", with the number of " +#~ "pods between 1 and 5, target CPU utilization at 80%:\n" +#~ "\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Auto scale un deployment \"foo\", con il numero di pod compresi " +#~ "tra 2 e 10, utilizzo della CPU target specificato in modo da utilizzare " +#~ "una politica di autoscaling predefinita:\n" +#~ "\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +#~ "\n" +#~ "\t\t# Auto scale un controller di replica \"foo\", con il numero di pod " +#~ "compresi tra 1 e 5, utilizzo dell'utilizzo della CPU a 80%:\n" +#~ "\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# Convert the live state of the resource specified by 'pod.yaml' to " +#~ "the latest version\n" +#~ "\t\t# and print to stdout in json format.\n" +#~ "\t\tkubectl convert -f pod.yaml --local -o json\n" +#~ "\n" +#~ "\t\t# Convert all files under current directory to latest version and " +#~ "create them all.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Converte 'pod.yaml' alla versione più recente e stampa in stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# Converte lo stato live della risorsa specificata da 'pod.yaml' " +#~ "nella versione più recente.\n" +#~ "\t\t# e stampa in stdout nel formato json.\n" +#~ "\t\tkubectl convert -f pod.yaml --local -o json\n" +#~ "\n" +#~ "\t\t# Converte tutti i file nella directory corrente alla versione più " +#~ "recente e li crea tutti.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" that allows user to " +#~ "perform \"get\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" with ResourceName " +#~ "specified\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods --resource-name=readablepod" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Crea un ClusterRole denominato \"pod-reader\" che consente " +#~ "all'utente di eseguire \"get\", \"watch\" e \"list\" sui pod\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Crea un ClusterRole denominato \"pod-reader\" con ResourceName " +#~ "specificato\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods --resource-name=readablepod" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" that allows user to perform \"get" +#~ "\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" with ResourceName specified\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verg=list --verb=watch --" +#~ "resource=pods --resource-name=readablepod" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Crea un ruolo denominato \"pod-reader\" che consente all'utente di " +#~ "eseguire \"get\", \"watch\" e \"list\" sui pod\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Crea un ruolo denominato \"pod-reader\" con ResourceName " +#~ "specificato\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verg=list --verb=watch --" +#~ "resource=pods --resource-name=readablepod" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a new resourcequota named my-quota\n" +#~ "\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2," +#~ "services=3,replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# Create a new resourcequota named best-effort\n" +#~ "\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Crea una nuova resourcequota chiamata my-quota\n" +#~ "\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2," +#~ "services=3,replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# Creare una nuova resourcequota denominata best-effort\n" +#~ "\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=rails label\n" +#~ "\t\t# and require at least one of them being available at any point in " +#~ "time.\n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=nginx label\n" +#~ "\t\t# and require at least half of the pods selected to be available at " +#~ "any point in time.\n" +#~ "\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Crea un pod disruption budget chiamato my-pdb che seleziona tutti i " +#~ "pod con label app = rail\n" +#~ "\t\t# e richiede che almeno uno di essi sia disponibile in qualsiasi " +#~ "momento.\n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# Crea un pod disruption budget con nome my-pdb che seleziona tutti i " +#~ "pod con label app = nginx \n" +#~ "\t\t# e richiede che almeno la metà dei pod selezionati sia disponibile " +#~ "in qualsiasi momento.\n" +#~ "\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod using the data in pod.json.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Create a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# Edit the data in docker-registry.yaml in JSON using the v1 API " +#~ "format then create the resource using the edited data.\n" +#~ "\t\tkubectl create -f docker-registry.yaml --edit --output-version=v1 -o " +#~ "json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Crea un pod utilizzando i dati in pod.json.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Crea un pod basato sul JSON passato in stdin.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# Modifica i dati in docker-registry.yaml in JSON utilizzando il " +#~ "formato API v1 quindi creare la risorsa utilizzando i dati modificati.\n" +#~ "\t\tkubectl create -f docker-registry.yaml --edit --output-version=v1 -o " +#~ "json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a replication controller identified by type " +#~ "and name specified in \"nginx-controller.yaml\", which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +#~ "the name \"frontend\"\n" +#~ "\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +#~ "\n" +#~ "\t\t# Create a second service based on the above service, exposing the " +#~ "container port 8443 as port 443 with the name \"nginx-https\"\n" +#~ "\t\tkubectl expose service nginx --port=443 --target-port=8443 --" +#~ "name=nginx-https\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated streaming application on port " +#~ "4100 balancing UDP traffic and named 'video-stream'.\n" +#~ "\t\tkubectl expose rc streamer --port=4100 --protocol=udp --name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx using replica set, which " +#~ "serves on port 80 and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for an nginx deployment, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose deployment nginx --port=80 --target-port=8000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Crea un servizio per un nginx replicato, che serve nella porta 80 e " +#~ "si collega ai container sulla porta 8000.\n" +#~ "\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Crea un servizio per un controller di replica identificato per tipo " +#~ "e nome specificato in \"nginx-controller.yaml\", che serve nella porta 80 " +#~ "e si collega ai container sulla porta 8000.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Crea un servizio per un pod valid-pod, che serve nella porta 444 " +#~ "con il nome \"frontend\"\n" +#~ "\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +#~ "\n" +#~ "\t\t# Crea un secondo servizio basato sul servizio sopra, esponendo la " +#~ "porta container 8443 come porta 443 con il nome \"nginx-https\"\n" +#~ "\t\tkubectl expose service nginx --port=443 --target-port=8443 --" +#~ "name=nginx-https\n" +#~ "\n" +#~ "\t\t# Crea un servizio per un'applicazione di replica in porta 4100 che " +#~ "bilanci il traffico UDP e denominato \"video stream\".\n" +#~ "\t\tkubectl expose rc streamer --port=4100 --protocol=udp --name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# Crea un servizio per un nginx replicato utilizzando l'insieme di " +#~ "replica, che serve nella porta 80 e si collega ai contenitori sulla porta " +#~ "8000.\n" +#~ "\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Crea un servizio per una distribuzione di nginx, che serve nella " +#~ "porta 80 e si collega ai contenitori della porta 8000.\n" +#~ "\t\tkubectl expose deployment nginx --port=80 --target-port=8000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Delete a pod using the type and name specified in pod.json.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Delete a pod based on the type and name in the JSON passed into " +#~ "stdin.\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# Delete pods and services with label name=myLabel.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Delete a pod with minimal delay\n" +#~ "\t\tkubectl delete pod foo --now\n" +#~ "\n" +#~ "\t\t# Force delete a pod on a dead node\n" +#~ "\t\tkubectl delete pod foo --grace-period=0 --force\n" +#~ "\n" +#~ "\t\t# Delete all pods\n" +#~ "\t\tkubectl delete pods --all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Elimina un pod utilizzando il tipo e il nome specificati in pod." +#~ "json.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Elimina un pod in base al tipo e al nome del JSON passato in " +#~ "stdin.\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# Elimina i baccelli ei servizi con gli stessi nomi \"baz\" e \"foo" +#~ "\"\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# Elimina i baccelli ei servizi con il nome dell'etichetta = " +#~ "myLabel.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Eliminare un pod con un ritardo minimo\n" +#~ "\t\tkubectl delete pod foo --now\n" +#~ "\n" +#~ "\t\t# Forza elimina un pod in un nodo morto\n" +#~ "\t\tkubectl delete pod foo --grace-period=0 --force\n" +#~ "\n" +#~ "\t\t# Elimina tutti i pod\n" +#~ "\t\tkubectl delete pods --all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Describe a node\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# Describe a pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# Describe all pods\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# Describe pods by label name=myLabel\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Describe all pods managed by the 'frontend' replication controller " +#~ "(rc-created pods\n" +#~ "\t\t# get the name of the rc as a prefix in the pod the name).\n" +#~ "\t\tkubectl describe pods frontend" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Descrive un nodo\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# Descrive un pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# Descrive un pod identificato da tipo e nome in \"pod.json\"\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# Descrive tutti i pod\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# Descrive i pod con label name=myLabel\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Descrivere tutti i pod gestiti dal controller di replica \"frontend" +#~ "\" (rc-created pods\n" +#~ "\t\t# ottiene il nome del rc come un prefisso del nome pod).\n" +#~ "\t\tkubectl describe pods frontend" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Drain node \"foo\", even if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet on it.\n" +#~ "\t\t$ kubectl drain foo --force\n" +#~ "\n" +#~ "\t\t# As above, but abort if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet, and use " +#~ "a grace period of 15 minutes.\n" +#~ "\t\t$ kubectl drain foo --grace-period=900" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Drain node \"foo\", anche se ci sono i baccelli non gestiti da " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet o StatefulSet su di " +#~ "esso.\n" +#~ "\t\t$ kubectl drain foo --force\n" +#~ "\n" +#~ "\t\t# Come sopra, ma interrompere se ci sono i baccelli non gestiti da " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet, e " +#~ "utilizzare un periodo di grazia di 15 minuti.\n" +#~ "\t\t$ kubectl drain foo --grace-period=900" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Edit the service named 'docker-registry':\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Use an alternative editor\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Edit the job 'myjob' in JSON using the v1 API format:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +#~ "config in its annotation:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml --save-config" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Modifica il servizio denominato 'docker-registry':\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Usa un editor alternativo\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Modifica il lavoro 'myjob' in JSON utilizzando il formato API v1:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# Modifica la distribuzione 'mydeployment' in YAML e salvare la " +#~ "configurazione modificata nella sua annotazione:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml --save-config" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running 'date' from pod 123456-7890, using the " +#~ "first container by default\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# Get output from running 'date' in ruby-container from pod " +#~ "123456-7890\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t -- bash -il" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Ottieni l'output dalla 'data' di esecuzione del pod 123456-7890, " +#~ "utilizzando il primo contenitore per impostazione predefinita\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# Ottieni l'output dalla data di esecuzione in ruby-container del pod " +#~ "123456-7890\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# Passare alla modalità raw terminal, invia stdin a 'bash' in ruby-" +#~ "container del pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t -- bash -il" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running pod 123456-7890, using the first container " +#~ "by default\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# Get output from ruby-container from pod 123456-7890\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# Get output from the first pod of a ReplicaSet named nginx\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Ottieni l'output dal pod 123456-7890 in esecuzione, utilizzando il " +#~ "primo contenitore per impostazione predefinita\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# Ottieni l'output dal ruby-container del pod 123456-7890\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# Passa alla modalità raw terminal, invia stdin a 'bash' in ruby-" +#~ "container del pod 123456-7890\n" +#~ "\t\t# e invia stdout/stderr da 'bash' al client\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# Ottieni l'output dal primo pod di una ReplicaSet denominata nginx\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Install bash completion on a Mac using homebrew\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash completion support\n" +#~ "source $(brew --prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for bash into the current shell\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# Write bash completion code to a file and source if from ." +#~ "bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell completion\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +#~ "\t\tsource <(kubectl completion zsh)" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Installa il completamento di bash su un Mac utilizzando homebrew\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash completion support\n" +#~ "source $(brew --prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Carica il codice di completamento kubectl per bash nella shell " +#~ "corrente\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# Scrive il codice di completamento bash in un file e lo carica da ." +#~ "bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell completion\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Carica il codice di completamento kubectl per zsh [1] nella shell " +#~ "corrente\n" +#~ "\t\tsource <(kubectl completion zsh)" + +#~ msgid "" +#~ "\n" +#~ "\t\t# List all pods in ps output format.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# List all pods in ps output format with more information (such as " +#~ "node name).\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# List a single replication controller with specified NAME in ps " +#~ "output format.\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# List a single pod in JSON output format.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +#~ "JSON output format.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# Return only the phase value of the specified pod.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# List all replication controllers and services together in ps output " +#~ "format.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# List one or more resources by their type and names.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List all resources with different types.\n" +#~ "\t\tkubectl get all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Elenca tutti i pod in formato output ps.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# Elenca tutti i pod in formato output ps con maggiori informazioni " +#~ "(ad esempio il nome del nodo).\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# Elenca un controller di replica singolo con NAME specificato nel " +#~ "formato di output ps.\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# Elenca un singolo pod nel formato di uscita JSON.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# Elenca un pod identificato per tipo e nome specificato in \"pod.yaml" +#~ "\" nel formato di uscita JSON.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# Restituisce solo il valore di fase del pod specificato.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# Elenca tutti i controller e servizi di replica insieme in formato " +#~ "output ps.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# Elenca una o più risorse per il tipo e per i nomi.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# Elenca tutte le risorse con tipi diversi.\n" +#~ "\t\tkubectl get all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 5000 6000\n" +#~ "\n" +#~ "\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 8888:5000\n" +#~ "\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod :5000\n" +#~ "\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 0:5000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Ascolta localmente le porte 5000 e 6000, inoltrando i dati da/verso " +#~ "le porte 5000 e 6000 nel pod\n" +#~ "\t\tkubectl port-forward mypod 5000 6000\n" +#~ "\n" +#~ "\t\t# Ascolta localmente la porta 8888, inoltra a 5000 nel pod\n" +#~ "\t\tkubectl port-forward mypod 8888:5000\n" +#~ "\n" +#~ "\t\t# Ascolta localmente una porta casuale, inoltra a 5000 nel pod\n" +#~ "\t\tkubectl port-forward mypod :5000\n" +#~ "\n" +#~ "\t\t# Ascolta localmente una porta casuale, inoltra a 5000 nel pod\n" +#~ "\t\tkubectl port-forward mypod 0:5000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as schedulable.\n" +#~ "\t\t$ kubectl uncordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Segna il nodo \"foo\" come programmabile.\n" +#~ "\t\t$ Kubectl uncordon foo" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as unschedulable.\n" +#~ "\t\tkubectl cordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Segna il nodo \"foo\" come non programmabile.\n" +#~ "\t\tkubectl cordon foo" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Partially update a node using strategic merge patch\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# Partially update a node identified by the type and name specified " +#~ "in \"node.json\" using strategic merge patch\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image; spec.containers[*].name is required " +#~ "because it's a merge key\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image using a json patch with positional " +#~ "arrays\n" +#~ "\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Aggiorna parzialmente un nodo utilizzando merge patch strategica\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# Aggiorna parzialmente un nodo identificato dal tipo e dal nome " +#~ "specificato in \"node.json\" utilizzando merge patch strategica\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# Aggiorna l'immagine di un contenitore; spec.containers [*]. name è " +#~ "richiesto perché è una chiave di fusione\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# Aggiorna l'immagine di un contenitore utilizzando una patch json " +#~ "con array posizionali\n" +#~ "\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Print the address of the master and cluster services\n" +#~ "\t\tkubectl cluster-info" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Stampa l'indirizzo dei servizi master e cluster\n" +#~ "\t\tkubectl cluster-info" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Replace a pod using the data in pod.json.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Replace a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Update a single-container pod's image version (tag) to v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Force replace, delete and then re-create the resource\n" +#~ "\t\tkubectl replace --force -f ./pod.json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Sostituire un pod utilizzando i dati in pod.json.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Sostituire un pod usando il JSON passato da stdin.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Aggiorna la versione dell'immagine (tag) di un singolo container di " +#~ "pod a v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Forza la sostituzione, cancellazione e quindi ricreare la risorsa\n" +#~ "\t\tkubectl replace --force -f ./pod.json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Return snapshot logs from pod nginx with only one container\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs for the pods defined by label app=nginx\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot of previous terminated ruby container logs from pod " +#~ "web-1\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Display only the most recent 20 lines of output in pod nginx\n" +#~ "\t\tkubectl logs --tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Show all logs from pod nginx written in the last hour\n" +#~ "\t\tkubectl logs --since=1h nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from first container of a job named hello\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from container nginx-1 of a deployment named " +#~ "nginx\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Restituisce snapshot log dal pod nginx con un solo container\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# Restituisce snapshot log dei pod definiti dalla label app=nginx\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Restituisce snapshot log del container ruby terminato nel pod " +#~ "web-1\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Iniziare a trasmettere i log del contenitore ruby nel pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Visualizza solo le ultime 20 righe di output del pod nginx\n" +#~ "\t\tkubectl logs --tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Mostra tutti i log del pod nginx scritti nell'ultima ora\n" +#~ "\t\tkubectl logs --since=1h nginx\n" +#~ "\n" +#~ "\t\t# Restituisce snapshot log dal primo contenitore di un lavoro " +#~ "chiamato hello\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Restituisce snapshot logs del container nginx-1 del deployment " +#~ "chiamato nginx\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on port 8011, serving static " +#~ "content from ./local/www/\n" +#~ "\t\tkubectl proxy --port=8011 --www=./local/www/\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on an arbitrary local port.\n" +#~ "\t\t# The chosen port for the server will be output to stdout.\n" +#~ "\t\tkubectl proxy --port=0\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver, changing the api prefix to k8s-" +#~ "api\n" +#~ "\t\t# This makes e.g. the pods api available at localhost:8001/k8s-api/v1/" +#~ "pods/\n" +#~ "\t\tkubectl proxy --api-prefix=/k8s-api" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Esegui un proxy verso kubernetes apiserver sulla porta 8011, che " +#~ "fornisce contenuti statici da ./local/www/\n" +#~ "\t\tkubectl proxy --port=8011 --www=./local/www/\n" +#~ "\n" +#~ "\t\t# Esegui un proxy verso kubernetes apiserver su una porta locale " +#~ "arbitraria.\n" +#~ "\t\t# La porta selezionata per il server verrà inviata a stdout.\n" +#~ "\t\tkubectl proxy --port=0\n" +#~ "\n" +#~ "\t\t# Esegui un proxy verso kubernetes apiserver, cambiando il prefisso " +#~ "api in k8s-api\n" +#~ "\t\t# Questo comporta, ad es., pod api disponibili presso localhost:8001/" +#~ "k8s-api/v1/pods/\n" +#~ "\t\tkubectl proxy --api-prefix=/k8s-api" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Scale a replicaset named 'foo' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Scale a resource identified by type and name specified in \"foo.yaml" +#~ "\" to 3.\n" +#~ "\t\tkubectl scale --replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# If the deployment named mysql's current size is 2, scale mysql to " +#~ "3.\n" +#~ "\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Scale multiple replication controllers.\n" +#~ "\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Scale job named 'cron' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 job/cron" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Scala un replicaset denominato 'foo' a 3.\n" +#~ "\t\tkubectl scale --replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Scala una risorsa identificata per tipo e nome specificato in \"foo." +#~ "yaml\" a 3.\n" +#~ "\t\tkubectl scale --replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# Se la distribuzione corrente di mysql è 2, scala mysql a 3.\n" +#~ "\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Scalare più controllori di replica.\n" +#~ "\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Scala il lavoro denominato 'cron' a 3.\n" +#~ "\t\tkubectl scale --replicas=3 job/cron" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Execute set-last-applied against each configuration file in a " +#~ "directory.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file, will create the annotation if it does not already " +#~ "exist.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml --create-" +#~ "annotation=true\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Imposta l'ultima-configurazione-applicata di una risorsa che " +#~ "corrisponda al contenuto di un file.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Esegue set-last-applied per ogni file di configurazione in una " +#~ "directory.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# Imposta la configurazione dell'ultima applicazione di una risorsa " +#~ "che corrisponda al contenuto di un file, creerà l'annotazione se non " +#~ "esiste già.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml --create-" +#~ "annotation=true\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Shut down foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Stop pods and services with label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Shut down the service defined in service.json\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Shut down all resources in the path/to/resources directory\n" +#~ "\t\tkubectl stop -f path/to/resources" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Spegni foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Stop di tutti i pod e servizi con label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Spegnere il servizio definito in service.json\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Spegnere tutte le resources in path/to/resources directory\n" +#~ "\t\tkubectl stop -f path/to/resources" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Start a single instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and let the container expose " +#~ "port 5701 .\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --port=5701\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and set environment variables " +#~ "\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --env=\"DNS_DOMAIN=cluster\" " +#~ "--env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Start a replicated instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx --replicas=5\n" +#~ "\n" +#~ "\t\t# Dry run. Print the corresponding API objects without creating " +#~ "them.\n" +#~ "\t\tkubectl run nginx --image=nginx --dry-run\n" +#~ "\n" +#~ "\t\t# Start a single instance of nginx, but overload the spec of the " +#~ "deployment with a partial set of values parsed from JSON.\n" +#~ "\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": " +#~ "\"v1\", \"spec\": { ... } }'\n" +#~ "\n" +#~ "\t\t# Start a pod of busybox and keep it in the foreground, don't restart " +#~ "it if it exits.\n" +#~ "\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +#~ "\n" +#~ "\t\t# Start the nginx container using the default command, but use custom " +#~ "arguments (arg1 .. argN) for that command.\n" +#~ "\t\tkubectl run nginx --image=nginx -- ... \n" +#~ "\n" +#~ "\t\t# Start the nginx container using a different command and custom " +#~ "arguments.\n" +#~ "\t\tkubectl run nginx --image=nginx --command -- ... \n" +#~ "\n" +#~ "\t\t# Start the perl container to compute π to 2000 places and print it " +#~ "out.\n" +#~ "\t\tkubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Start the cron job to compute π to 2000 places and print it out " +#~ "every 5 minutes.\n" +#~ "\t\tkubectl run pi --schedule=\"0/5 * * * ?\" --image=perl --" +#~ "restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Avviare un'unica istanza di nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx\n" +#~ "\n" +#~ "\t\t# Avviare un'unica istanza di hazelcast e lasciare che il container " +#~ "esponga la porta 5701.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --port=5701\n" +#~ "\n" +#~ "\t\t# Avviare una singola istanza di hazelcast ed imposta le variabili " +#~ "ambiente \"DNS_DOMAIN=cluster\" e \"POD_NAMESPACE=default\" nel " +#~ "container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --env=\"DNS_DOMAIN=cluster\" " +#~ "--env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Avviare un'istanza replicata di nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx --replicas=5\n" +#~ "\n" +#~ "\t\t# Dry run. Stampare gli oggetti API corrispondenti senza crearli.\n" +#~ "\t\tkubectl run nginx --image=nginx --dry-run\n" +#~ "\n" +#~ "\t\t# Avviare un'unica istanza di nginx, ma overload le spec del " +#~ "deployment con un insieme parziale di valori analizzati da JSON.\n" +#~ "\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": " +#~ "\"v1\", \"spec\": { ... } }'\n" +#~ "\n" +#~ "\t\t# Avviare un pod di busybox e tenerlo in primo piano, non riavviarlo " +#~ "se esce.\n" +#~ "\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +#~ "\n" +#~ "\t\t# Avviare il container nginx utilizzando il comando predefinito, ma " +#~ "utilizzare argomenti personalizzati (arg1 .. argN) per quel comando.\n" +#~ "\t\tkubectl run nginx --image=nginx -- ... \n" +#~ "\n" +#~ "\t\t# Avviare il container nginx utilizzando un diverso comando e " +#~ "argomenti personalizzati.\n" +#~ "\t\tkubectl run nginx --image=nginx --command -- ... \n" +#~ "\n" +#~ "\t\t# Avviare il contenitore perl per calcolare π a 2000 posti e " +#~ "stamparlo.\n" +#~ "\t\tkubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Avviare il cron job per calcolare π a 2000 posti e stampare ogni 5 " +#~ "minuti.\n" +#~ "\t\tkubectl run pi --schedule=\"0/5 * * * ?\" --image=perl --" +#~ "restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update node 'foo' with a taint with key 'dedicated' and value " +#~ "'special-user' and effect 'NoSchedule'.\n" +#~ "\t\t# If a taint with that key and effect already exists, its value is " +#~ "replaced as specified.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +#~ "'NoSchedule' if one exists.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Aggiorna il nodo \"foo\" con un marcatore con il tasto 'dedicated' " +#~ "e il valore 'special-user' ed effettua 'NoSchedule'.\n" +#~ "\t\t# Se un marcatore con quel tasto e l'effetto già esiste, il suo " +#~ "valore viene sostituito come specificato.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Rimuove dal nodo 'foo' il marcatore con il tasto 'dedicated' ed " +#~ "effettua 'NoSchedule' se esiste.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Rimuovi dal nodo 'foo' tutti i marcatori con chiave 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +#~ "overwriting any existing value.\n" +#~ "\t\tkubectl label --overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update all pods in the namespace\n" +#~ "\t\tkubectl label pods --all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ "\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' by removing a label named 'bar' if it exists.\n" +#~ "\t\t# Does not require the --overwrite flag.\n" +#~ "\t\tkubectl label pods foo bar-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Aggiorna il pod 'foo' con l'etichetta 'unhealthy' e il valore " +#~ "'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Aggiorna il pod 'foo' con l'etichetta 'status' e il valore " +#~ "'unhealthy', sovrascrivendo qualsiasi valore esistente.\n" +#~ "\t\tkubectl label --overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Aggiorna tutti i pod nello spazio dei nomi\n" +#~ "\t\tkubectl label pods --all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Aggiorna un pod identificato dal tipo e dal nome in \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Aggiorna il pod 'foo' solo se la risorsa è invariata dalla versione " +#~ "1.\n" +#~ "\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +#~ "\n" +#~ "\t\t# Aggiorna il pod 'foo' rimuovendo un'etichetta denominata 'bar' se " +#~ "esiste.\n" +#~ "\t\t# Non richiede la flag -overwrite.\n" +#~ "\t\tkubectl label pods foo bar-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using new replication controller data in " +#~ "frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using JSON data passed into stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend-v1 to frontend-v2 by just changing the " +#~ "image, and switching the\n" +#~ "\t\t# name of the replication controller.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend by just changing the image, and keeping " +#~ "the old name.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Abort and reverse an existing rollout in progress (from frontend-v1 " +#~ "to frontend-v2).\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Aggiorna i pod di frontend-v1 usando i dati del replication " +#~ "controller in frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Aggiorna i pod di frontend-v1 usando i dati JSON passati da stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Aggiorna i pod di frontend-v1 in frontend-v2 solo cambiando " +#~ "l'immagine e modificando\n" +#~ "\t\t# il nome del replication controller.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Aggiorna i pod di frontend solo cambiando l'immaginee mantenendo il " +#~ "vecchio none.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Interrompee ed invertire un rollout esistente in corso (da " +#~ "frontend-v1 a frontend-v2).\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" + +#~ msgid "" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by type/name in " +#~ "YAML.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by file in JSON\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Visualizza le annotazioni dell'ultima-configurazione-applicata per " +#~ "tipo/nome in YAML.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# # Visualizza le annotazioni dell'ultima-configurazione-applicata " +#~ "per file in JSON.\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" + +#~ msgid "" +#~ "\n" +#~ "\t\tApply a configuration to a resource by filename or stdin.\n" +#~ "\t\tThis resource will be created if it doesn't exist yet.\n" +#~ "\t\tTo use 'apply', always create the resource initially with either " +#~ "'apply' or 'create --save-config'.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do " +#~ "not use unless you are aware of what the current state is. See https://" +#~ "issues.k8s.io/34274." +#~ msgstr "" +#~ "\n" +#~ "\t\tApplicare una configurazione a una risorsa per nomefile o stdin.\n" +#~ "\t\tQuesta risorsa verrà creata se non esiste ancora.\n" +#~ "\t\tPer utilizzare 'apply', creare sempre la risorsa inizialmente con " +#~ "'apply' o 'create --save-config'.\n" +#~ "\n" +#~ "\t\tSono accettati i formati JSON e YAML.\n" +#~ "\n" +#~ "\t\tDisclaimer Alpha: la funzionalità --prune non è ancora completa. Non " +#~ "utilizzare a meno che non si sia a conoscenza di quale sia lo stato " +#~ "attuale. Vedi https://issues.k8s.io/34274." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\n" +#~ "Crea un ClusterRole." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRoleBinding for a particular ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tCrea un ClusterRoleBinding per un ClusterRole particolare." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a RoleBinding for a particular Role or ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tCrea un RoleBinding per un particolare Ruolo o ClusterRole." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a TLS secret from the given public/private key pair.\n" +#~ "\n" +#~ "\t\tThe public/private key pair must exist before hand. The public key " +#~ "certificate must be .PEM encoded and match the given private key." +#~ msgstr "" +#~ "\n" +#~ "\t\tCrea un TLS secret dalla coppia di chiavi pubblica/privata.\n" +#~ "\n" +#~ "\t\tLa coppia di chiavi pubblica/privata deve esistere prima. Il " +#~ "certificato chiave pubblica deve essere .PEM codificato e corrispondere " +#~ "alla chiave privata data." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a configmap based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single configmap may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a file, the key will default to " +#~ "the basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a directory, each file whose " +#~ "basename is a valid key in the directory will be\n" +#~ "\t\tpackaged into the configmap. Any directory entries except regular " +#~ "files are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreare un configmap basato su un file, una directory o un valore " +#~ "literal specificato.\n" +#~ "\n" +#~ "\t\tUn singolo configmap può includere una o più coppie chiave/valore.\n" +#~ "\n" +#~ "\t\tQuando si crea una configmap basata su un file, il valore predefinito " +#~ "sarà il nome di base del file e il valore sarà\n" +#~ "\t\tpredefinito per il contenuto del file. Se il nome di base è una " +#~ "chiave non valida, è possibile specificare un tasto alternativo.\n" +#~ "\n" +#~ "\t\tQuando si crea un configmap basato su una directory, ogni file il cui " +#~ "nome di base è una chiave valida nella directory verrà\n" +#~ "\t\tpacchettizzata nel configmap. Le voci di directory tranne i file " +#~ "regolari vengono ignorati (ad esempio sottodirectory,\n" +#~ "\t\tsymlinks, devices, pipes, ecc)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a new secret for use with Docker registries.\n" +#~ "\n" +#~ "\t\tDockercfg secrets are used to authenticate against Docker " +#~ "registries.\n" +#~ "\n" +#~ "\t\tWhen using the Docker command line to push images, you can " +#~ "authenticate to a given registry by running\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +#~ "password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " That produces a ~/.dockercfg file that is used by subsequent 'docker " +#~ "push' and 'docker pull' commands to\n" +#~ "\t\tauthenticate to the registry. The email address is optional.\n" +#~ "\n" +#~ "\t\tWhen creating applications, you may have a Docker registry that " +#~ "requires authentication. In order for the\n" +#~ "\t\tnodes to pull images on your behalf, they have to have the " +#~ "credentials. You can provide this information\n" +#~ "\t\tby creating a dockercfg secret and attaching it to your service " +#~ "account." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreare un nuovo secret per l'utilizzo con i registri Docker.\n" +#~ "\n" +#~ "\t\tDockercfg secrets vengono utilizzati per autenticare i registri " +#~ "Docker.\n" +#~ "\n" +#~ "\t\tQuando utilizzi la riga di comando Docker per il push delle immagini, " +#~ "è possibile eseguire l'autenticazione eseguendo correttamente un " +#~ "determinato registry\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +#~ "password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " Questo produce un file ~ / .dockercfg che viene utilizzato dai " +#~ "successivi comandi \"docker push\" e \"docker pull\"\n" +#~ "\t\tper autenticarsi nel registry. L'indirizzo email è facoltativo.\n" +#~ "\n" +#~ "\t\tDurante la creazione di applicazioni, è possibile avere un Docker " +#~ "registry che richiede l'autenticazione. Affinché i \n" +#~ "\t\tnodi eseguano pull di immagini per vostro conto, devono avere le " +#~ "credenziali. È possibile fornire queste informazioni \n" +#~ "\t\tcreando un dockercfg secret e collegandolo al tuo account di servizio." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a pod disruption budget with the specified name, selector, and " +#~ "desired minimum available pods" +#~ msgstr "" +#~ "\n" +#~ "\t\tCrea un pod disruption budget con il nome specificato, selector e il " +#~ "numero minimo di pod disponibili" + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted." +#~ msgstr "" +#~ "\n" +#~ "\t\tCrea una risorsa per nome file o stdin.\n" +#~ "\n" +#~ "\t\tSono accettati i formati JSON e YAML." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resourcequota with the specified name, hard limits and " +#~ "optional scopes" +#~ msgstr "" +#~ "\n" +#~ "\t\tCrea una resourcequota con il nome specificato, hard limits e gli " +#~ "scope opzionali" + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a secret based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single secret may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a file, the key will default to the " +#~ "basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a directory, each file whose basename " +#~ "is a valid key in the directory will be\n" +#~ "\t\tpackaged into the secret. Any directory entries except regular files " +#~ "are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCrea un secret basato su un file, una directory o un valore specifico " +#~ "literal.\n" +#~ "\n" +#~ "\t\tUn singolo secret può includere una o più coppie chiave/valore.\n" +#~ "\n" +#~ "\t\tQuando si crea un secret basato su un file, la chiave per " +#~ "impostazione predefinita sarà il nome di base del file e il valore sarà\n" +#~ "\t\tpredefinito al contenuto del file. Se il nome di base è una chiave " +#~ "non valida, è possibile specificare un tasto alternativo.\n" +#~ "\n" +#~ "\n" +#~ "\t\tQuando si crea un segreto basato su una directory, ogni file il cui " +#~ "nome di base è una chiave valida nella directory verrà \n" +#~ "\t\\paccehttizzataw in un secret. Le voci di directory tranne i file " +#~ "regolari vengono ignorati (ad esempio sottodirectory,\n" +#~ "\t\tsymlinks, devices, pipes, ecc)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate and run a particular image, possibly replicated.\n" +#~ "\n" +#~ "\t\tCreates a deployment or job to manage the created container(s)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCrea ed esegue un'immagine particolare, eventualmente replicata.\n" +#~ "\n" +#~ "\t\tCrea un deployment o un job per gestire i container creati." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreates an autoscaler that automatically chooses and sets the number " +#~ "of pods that run in a kubernetes cluster.\n" +#~ "\n" +#~ "\t\tLooks up a Deployment, ReplicaSet, or ReplicationController by name " +#~ "and creates an autoscaler that uses the given resource as a reference.\n" +#~ "\t\tAn autoscaler can automatically increase or decrease number of pods " +#~ "deployed within the system as needed." +#~ msgstr "" +#~ "\n" +#~ "\t\tCrea un autoscaler che automaticamente sceglie e imposta il numero di " +#~ "pod che vengono eseguiti in un cluster di kubernets.\n" +#~ "\n" +#~ "\t\tEsegue una ricerca di un Deployment, ReplicaSet o " +#~ "ReplicationController per nome e crea un autoscaler che utilizza la " +#~ "risorsa indicata come riferimento.\n" +#~ "\t\tUn autoscaler può aumentare o diminuire automaticamente il numero di " +#~ "pod distribuiti all'interno del sistema se necessario." + +#~ msgid "" +#~ "\n" +#~ "\t\tDelete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. Only one type of the arguments " +#~ "may be specified: filenames,\n" +#~ "\t\tresources and names, or resources and label selector.\n" +#~ "\n" +#~ "\t\tSome resources, such as pods, support graceful deletion. These " +#~ "resources define a default period\n" +#~ "\t\tbefore they are forcibly terminated (the grace period) but you may " +#~ "override that value with\n" +#~ "\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +#~ "Because these resources often\n" +#~ "\t\trepresent entities in the cluster, deletion may not be acknowledged " +#~ "immediately. If the node\n" +#~ "\t\thosting a pod is down or cannot reach the API server, termination may " +#~ "take significantly longer\n" +#~ "\t\tthan the grace period. To force delete a resource,\tyou must pass a " +#~ "grace\tperiod of 0 and specify\n" +#~ "\t\tthe --force flag.\n" +#~ "\n" +#~ "\t\tIMPORTANT: Force deleting pods does not wait for confirmation that " +#~ "the pod's processes have been\n" +#~ "\t\tterminated, which can leave those processes running until the node " +#~ "detects the deletion and\n" +#~ "\t\tcompletes graceful deletion. If your processes use shared storage or " +#~ "talk to a remote API and\n" +#~ "\t\tdepend on the name of the pod to identify themselves, force deleting " +#~ "those pods may result in\n" +#~ "\t\tmultiple processes running on different machines using the same " +#~ "identification which may lead\n" +#~ "\t\tto data corruption or inconsistency. Only force delete pods when you " +#~ "are sure the pod is\n" +#~ "\t\tterminated, or if your application can tolerate multiple copies of " +#~ "the same pod running at once.\n" +#~ "\t\tAlso, if you force delete pods the scheduler may place new pods on " +#~ "those nodes before the node\n" +#~ "\t\thas released those resources and causing those pods to be evicted " +#~ "immediately.\n" +#~ "\n" +#~ "\t\tNote that the delete command does NOT do resource version checks, so " +#~ "if someone\n" +#~ "\t\tsubmits an update to a resource right when you submit a delete, their " +#~ "update\n" +#~ "\t\twill be lost along with the rest of the resource." +#~ msgstr "" +#~ "\n" +#~ "\t\tCancella risorse secondo nomi di file, stdin, risorse e nomi, o per " +#~ "selettori di risorse e etichette.\n" +#~ "\n" +#~ "\t\tSono accettati i formati JSON e YAML. È possibile specificare un solo " +#~ "tipo di argomenti: nome file,\n" +#~ "\t\trisorse e nomi, o risorse e selettore di etichette.\n" +#~ "\n" +#~ "\t\tAlcune risorse, come i pod, supportano cacellazione corretta. Queste " +#~ "risorse definiscono un periodo di default\n" +#~ "\t\tprima che siano forzatamente terminate (il grace period) ma si può " +#~ "sostituire quel valore con\n" +#~ "\t\til falg --grace-period, o passare --now per impostare il grace-period " +#~ "a 1. Poiché queste risorse spesso\n" +#~ "\t\trappresentano entità del cluster, la cancellazione non può essere " +#~ "presa in carico immediatamente. Se il nodo\n" +#~ "\t\tche ospita un pod è spento o non raggiungibile da API server, " +#~ "termination può richiedere molto più tempo\n" +#~ "\t\tdel grace period. Per forzare la cancellazione di una resource,\tdevi " +#~ "obbligatoriamente indicare un grace\tperiod di 0 e specificare\n" +#~ "\t\til flag --force.\n" +#~ "\n" +#~ "\t\tIMPORTANTE: Fozare la cancellazione dei pod non attende conferma che " +#~ "i processi del pod siano\n" +#~ "\t\tterminati, che può lasciare questi processi in esecuzione fino a " +#~ "quando il nodo rileva la cancellazione\n" +#~ "\t\tcompletata correttamente. Se i tuoi processi utilizzano " +#~ "l'archiviazione condivisa o parlano con un'API remota e\n" +#~ "\t\tdipendono dal nome del pod per identificarsi, la forzata eliminazione " +#~ "di questi pod può comportare\n" +#~ "\t\tpiù processi in esecuzione su macchine diverse che utilizzando la " +#~ "stessa identificazione che può portare\n" +#~ "\t\tcorruzione o inconsistenza dei dati. Forza i pod solo quando si è " +#~ "sicuri che il pod sia\n" +#~ "\t\tterminato, o se la tua applicazione può can tollerare più copie dello " +#~ "stesso pod in esecuzione contemporaneamente.\n" +#~ "\t\tInoltre, se forzate l'eliminazione dei i nodi, lo scheduler può può " +#~ "creare nuovi nodi su questi nodi prima che il nodo\n" +#~ "\t\tabbia liberato quelle risorse e provocando immediatamente evict di " +#~ "tali pod.\n" +#~ "\n" +#~ "\n" +#~ "\t\tNotare che il comando di eliminazione NON fa verificare la versione " +#~ "delle risorse, quindi se qualcuno\n" +#~ "\t\tinvia un aggiornamento ad una risorsa quando invii un eliminazione, " +#~ "il loro aggiornamento\n" +#~ "\t\tsaranno persi insieme al resto della risorsa." + +#~ msgid "" +#~ "\n" +#~ "\t\tDeprecated: Gracefully shut down a resource by name or filename.\n" +#~ "\n" +#~ "\t\tThe stop command is deprecated, all its functionalities are covered " +#~ "by delete command.\n" +#~ "\t\tSee 'kubectl delete --help' for more details.\n" +#~ "\n" +#~ "\t\tAttempts to shut down and delete a resource that supports graceful " +#~ "termination.\n" +#~ "\t\tIf the resource is scalable it will be scaled to 0 before deletion." +#~ msgstr "" +#~ "\n" +#~ "\t\tDeprecated: chiudere correttamente una risorsa per nome o nome file.\n" +#~ "\n" +#~ "\t\tIl comando stop è deprecato, tutte le sue funzionalità sono coperte " +#~ "dal comando delete.\n" +#~ "\t\tVedere 'kubectl delete --help' per ulteriori dettagli.\n" +#~ "\n" +#~ "\t\tTenta di arrestare ed eliminare una risorsa che supporta la corretta " +#~ "terminazione.\n" +#~ "\t\tSe la risorsa è scalabile, verrà scalata a 0 prima dell'eliminazione." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of nodes.\n" +#~ "\n" +#~ "\t\tThe top-node command allows you to see the resource consumption of " +#~ "nodes." +#~ msgstr "" +#~ "\n" +#~ "\t\tVisualizza l'utilizzo di risorse (CPU/Memoria/Storage) dei nodi.\n" +#~ "\n" +#~ "\t\tIl comando top-node consente di visualizzare il consumo di risorse " +#~ "dei nodi." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of pods.\n" +#~ "\n" +#~ "\t\tThe 'top pod' command allows you to see the resource consumption of " +#~ "pods.\n" +#~ "\n" +#~ "\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +#~ "minutes\n" +#~ "\t\tsince pod creation." +#~ msgstr "" +#~ "\n" +#~ "\t\tVisualizza l'utilizzo di risorse (CPU/Memoria/Storage) dei pod.\n" +#~ "\n" +#~ "\t\tIl comando \"top pod\" consente di visualizzare il consumo delle " +#~ "risorse dei pod.\n" +#~ "\n" +#~ "\t\tA causa del ritardo della pipeline metrica, potrebbero non essere " +#~ "disponibili per alcuni minuti\n" +#~ "\t\teal momento della creazione dei pod." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage.\n" +#~ "\n" +#~ "\t\tThe top command allows you to see the resource consumption for nodes " +#~ "or pods.\n" +#~ "\n" +#~ "\t\tThis command requires Heapster to be correctly configured and working " +#~ "on the server. " +#~ msgstr "" +#~ "\n" +#~ "\t\tVisualizza l'utilizzo di risorse (CPU/Memoria/Storage).\n" +#~ "\n" +#~ "\t\tIl comando top consente di visualizzare il consumo di risorse per " +#~ "nodi o pod.\n" +#~ "\n" +#~ "\t\tQuesto comando richiede che Heapster sia configurato correttamente e " +#~ "che funzioni sul server." + +#~ msgid "" +#~ "\n" +#~ "\t\tDrain node in preparation for maintenance.\n" +#~ "\n" +#~ "\t\tThe given node will be marked unschedulable to prevent new pods from " +#~ "arriving.\n" +#~ "\t\t'drain' evicts the pods if the APIServer supports eviction\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Otherwise, it will " +#~ "use normal DELETE\n" +#~ "\t\tto delete the pods.\n" +#~ "\t\tThe 'drain' evicts or deletes all pods except mirror pods (which " +#~ "cannot be deleted through\n" +#~ "\t\tthe API server). If there are DaemonSet-managed pods, drain will not " +#~ "proceed\n" +#~ "\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +#~ "\t\tDaemonSet-managed pods, because those pods would be immediately " +#~ "replaced by the\n" +#~ "\t\tDaemonSet controller, which ignores unschedulable markings. If there " +#~ "are any\n" +#~ "\t\tpods that are neither mirror pods nor managed by " +#~ "ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet or Job, then drain will not delete " +#~ "any pods unless you\n" +#~ "\t\tuse --force. --force will also allow deletion to proceed if the " +#~ "managing resource of one\n" +#~ "\t\tor more pods is missing.\n" +#~ "\n" +#~ "\t\t'drain' waits for graceful termination. You should not operate on the " +#~ "machine until\n" +#~ "\t\tthe command completes.\n" +#~ "\n" +#~ "\t\tWhen you are ready to put the node back into service, use kubectl " +#~ "uncordon, which\n" +#~ "\t\twill make the node schedulable again.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\tDrain node in preparazione alla manutenzione.\n" +#~ "\n" +#~ "\t\tIl nodo indicato verrà contrassegnato unschedulable per impedire che " +#~ "nuovi pod arrivino.\n" +#~ "\t\t'drain' evict i pod se l'APIServer supporta eviction\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Altrimenti, usa il " +#~ "normale DELETE\n" +#~ "\t\tper eliminare i pod.\n" +#~ "\t\tIl 'drain' evicts o la cancellazione di tutti all pod tranne mirror " +#~ "pods (che non possono essere eliminati\n" +#~ "\t\tattraverso API server). Se ci sono i pod gestiti da DaemonSet, " +#~ "drain non procederà\n" +#~ "\t\tsenza --ignore-daemonsets e, a prescindere da ciò, non cancellerà " +#~ "alcun\n" +#~ "\t\tpod gestitto da DaemonSet,poiché questi pods verrebbero " +#~ "immediatamente sostituiti dal\n" +#~ "\t\tDaemonSet controller, che ignora le marcature unschedulable. Se ci " +#~ "sono\n" +#~ "\t\tpod che non sono né mirror pod né gestiti dal ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet o Job, allora drain non cancellerà " +#~ "alcun pod finché non\n" +#~ "\t\tuserai --force. --force permetterà alla cancellazione di procedere " +#~ "se la risorsa gestita da uno\n" +#~ "\t\to più pod è mancante.\n" +#~ "\n" +#~ "\t\t'drain' attende il termine corretto. Non devi operare sulla macchina " +#~ "finché\n" +#~ "\t\til comando non viene completato.\n" +#~ "\n" +#~ "\t\tQuando sei pronto per riportare il nodo al servizio, utilizza kubectl " +#~ "uncordon, per\n" +#~ "\t\trimettere il nodo schedulable nuovamente.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tEdit a resource from the default editor.\n" +#~ "\n" +#~ "\t\tThe edit command allows you to directly edit any API resource you can " +#~ "retrieve via the\n" +#~ "\t\tcommand line tools. It will open the editor defined by your " +#~ "KUBE_EDITOR, or EDITOR\n" +#~ "\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' " +#~ "for Windows.\n" +#~ "\t\tYou can edit multiple objects, although changes are applied one at a " +#~ "time. The command\n" +#~ "\t\taccepts filenames as well as command line arguments, although the " +#~ "files you point to must\n" +#~ "\t\tbe previously saved versions of resources.\n" +#~ "\n" +#~ "\t\tEditing is done with the API version used to fetch the resource.\n" +#~ "\t\tTo edit using a specific API version, fully-qualify the resource, " +#~ "version, and group.\n" +#~ "\n" +#~ "\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +#~ "\n" +#~ "\t\tThe flag --windows-line-endings can be used to force Windows line " +#~ "endings,\n" +#~ "\t\totherwise the default for your operating system will be used.\n" +#~ "\n" +#~ "\t\tIn the event an error occurs while updating, a temporary file will be " +#~ "created on disk\n" +#~ "\t\tthat contains your unapplied changes. The most common error when " +#~ "updating a resource\n" +#~ "\t\tis another editor changing the resource on the server. When this " +#~ "occurs, you will have\n" +#~ "\t\tto apply your changes to the newer version of the resource, or update " +#~ "your temporary\n" +#~ "\t\tsaved copy to include the latest resource version." +#~ msgstr "" +#~ "\n" +#~ "\t\tModificare una risorsa dall'editor predefinito.\n" +#~ "\n" +#~ "\t\tIl comando di modifica consente di modificare direttamente qualsiasi " +#~ "risorsa API che è possibile recuperare tramite gli\n" +#~ "\t\tstrumenti di riga di comando. Apre l'editor definito dalle variabili " +#~ "d'ambiente\n" +#~ "\t\tKUBE_EDITOR o EDITOR, o ritornare a 'vi' per Linux o 'notepad' per " +#~ "Windows.\n" +#~ "\t\tÈ possibile modificare più oggetti, anche se le modifiche vengono " +#~ "applicate una alla volta. Il comando\n" +#~ "\t\taccetta sia nomi di file che argomenti da riga di comando, anche se i " +#~ "file a cui fa riferimento devono\n" +#~ "\t\tessere state salvate precedentemente le versioni delle risorse.\n" +#~ "\n" +#~ "\t\tLa modifica viene eseguita con la versione API utilizzata per " +#~ "recuperare la risorsa.\n" +#~ "\t\tPer modificare utilizzando una specifica versione API, fully-qualify " +#~ "la risorsa, versione e il gruppo.\n" +#~ "\n" +#~ "\t\tIl formato predefinito è YAML. Per modificare in JSON, specificare \"-" +#~ "o json\".\n" +#~ "\n" +#~ "\t\tIl flag --windows-line-endings può essere utilizzato per forzare i " +#~ "fine linea Windows,\n" +#~ "\t\taltrimenti verrà utilizzato il default per il sistema operativo.\n" +#~ "\n" +#~ "\t\tNel caso in cui si verifica un errore durante l'aggiornamento, verrà " +#~ "creato un file temporaneo sul disco\n" +#~ "\t\tche contiene le modifiche non apportate. L'errore più comune durante " +#~ "l'aggiornamento di una risorsa\n" +#~ "\t\tè una modifica da pare di un altro editor della risorsa sul server. " +#~ "Quando questo si verifica, dovrai\n" +#~ "\t\tapplicare le modifiche alla versione più recente della risorsa o " +#~ "aggiornare il tua copia\n" +#~ "\t\ttemporanea salvata per includere l'ultima versione delle risorse." + +#~ msgid "" +#~ "\n" +#~ "\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +#~ "\t\tThe shell code must be evaluated to provide interactive\n" +#~ "\t\tcompletion of kubectl commands. This can be done by sourcing it " +#~ "from\n" +#~ "\t\tthe .bash_profile.\n" +#~ "\n" +#~ "\t\tNote: this requires the bash-completion framework, which is not " +#~ "installed\n" +#~ "\t\tby default on Mac. This can be installed by using homebrew:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tOnce installed, bash_completion must be evaluated. This can be done " +#~ "by adding the\n" +#~ "\t\tfollowing line to the .bash_profile\n" +#~ "\n" +#~ "\t\t $ source $(brew --prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tNote for zsh users: [1] zsh completions are only supported in " +#~ "versions of zsh >= 5.2" +#~ msgstr "" +#~ "\n" +#~ "\t\tIn output codice di completamento shell output per la shell " +#~ "specificata (bash o zsh).\n" +#~ "\t\tIl codice di shell deve essere valorizzato per fornire completamento\n" +#~ "\t\tinterattivo dei comandi kubectl. Questo può essere eseguito " +#~ "richiamandolo\n" +#~ "\t\tda .bash_profile.\n" +#~ "\n" +#~ "\t\tNota: questo richiede il framework di completamento bash, che non è " +#~ "installato\n" +#~ "\t\tper impostazione predefinita su Mac. Questo può essere installato " +#~ "utilizzando homebrew:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tUna volta installato, bash_completion deve essere valutato. Ciò può " +#~ "essere fatto aggiungendo la\n" +#~ "\t\tseguente riga al file .bash_profile\n" +#~ "\n" +#~ "\t\t $ source $(brew --prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tNota per gli utenti zsh: [1] i completamenti zsh sono supportati solo " +#~ "nelle versioni zsh> = 5.2" + +#~ msgid "" +#~ "\n" +#~ "\t\tPerform a rolling update of the given ReplicationController.\n" +#~ "\n" +#~ "\t\tReplaces the specified replication controller with a new replication " +#~ "controller by updating one pod at a time to use the\n" +#~ "\t\tnew PodTemplate. The new-controller.json must specify the same " +#~ "namespace as the\n" +#~ "\t\texisting replication controller and overwrite at least one (common) " +#~ "label in its replicaSelector.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\tEseguire un rolling update del ReplicationController specificato.\n" +#~ "\n" +#~ "\t\tSostituisce il replication controller specificato con un nuovo " +#~ "replication controller aggiornando un pod alla volta per usare il\n" +#~ "\t\tnuovo PodTemplate. Il new-controller.json deve specificare lo stesso " +#~ "namespace del\n" +#~ "\t\tcontroller di replica esistente e sovrascrivere almeno una etichetta " +#~ "(comune) nella sua replicaSelector.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tReplace a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. If replacing an existing " +#~ "resource, the\n" +#~ "\t\tcomplete resource spec must be provided. This can be obtained by\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." +#~ msgstr "" +#~ "\n" +#~ "\t\tSostituire una risorsa per nomefile o stdin.\n" +#~ "\n" +#~ "\t\tSono accettati i formati JSON e YAML. Se si sostituisce una risorsa " +#~ "esistente, \n" +#~ "\t\tè necessario fornire la specifica completa delle risorse. Questo può " +#~ "essere ottenuta da\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" +#~ "\n" +#~ "\t\tFare riferimento ai modelli https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html per trovare se un campo è mutevole." + +#~ msgid "" +#~ "\n" +#~ "\t\tSet a new size for a Deployment, ReplicaSet, Replication Controller, " +#~ "or Job.\n" +#~ "\n" +#~ "\t\tScale also allows users to specify one or more preconditions for the " +#~ "scale action.\n" +#~ "\n" +#~ "\t\tIf --current-replicas or --resource-version is specified, it is " +#~ "validated before the\n" +#~ "\t\tscale is attempted, and it is guaranteed that the precondition holds " +#~ "true when the\n" +#~ "\t\tscale is sent to the server." +#~ msgstr "" +#~ "\n" +#~ "\t\tImposta una nuova dimensione per Deployment, ReplicaSet, Replication " +#~ "Controller, o Job.\n" +#~ "\n" +#~ "\t\tScala consente anche agli utenti di specificare una o più condizioni " +#~ "preliminari per l'azione della scala.\n" +#~ "\n" +#~ "\t\tSe --current-replicas o --resource-version sono specificate, viene " +#~ "convalidata prima di\n" +#~ "\t\ttentare scale, ed è garantito che la precondizione vale quando\n" +#~ "\t\tscale viene inviata al server.." + +#~ msgid "" +#~ "\n" +#~ "\t\tTo proxy all of the kubernetes api and nothing else, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/\n" +#~ "\n" +#~ "\t\tTo proxy only part of the kubernetes api and also some static files:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-" +#~ "prefix=/api/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/api/v1/pods'.\n" +#~ "\n" +#~ "\t\tTo proxy the entire kubernetes api at a different root, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/custom/api/v1/pods'" +#~ msgstr "" +#~ "\n" +#~ "\t\tPer proxy tutti i kubernetes api e nient'altro, utilizzare:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/\n" +#~ "\n" +#~ "\t\tPer proxy solo una parte dei kubernetes api e anche alcuni file " +#~ "static\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-" +#~ "prefix=/api/\n" +#~ "\n" +#~ "\t\tQuanto sopra consente 'curl localhost:8001/api/v1/pods'.\n" +#~ "\n" +#~ "\t\tPer eseguire il proxy tutti i kubernetes api in una radice diversa, " +#~ "utilizzare:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tQuanto sopra ti permette 'curl localhost:8001/custom/api/v1/pods'" + +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate field(s) of a resource using strategic merge patch\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." +#~ msgstr "" +#~ "\n" +#~ "\t\tAggiorna i campi di una risorsa utilizzando la merge patch " +#~ "strategica\n" +#~ "\n" +#~ "\t\tSono accettati i formati JSON e YAML.\n" +#~ "\n" +#~ "\t\tSi prega di fare riferimento ai modelli in https://htmlpreview.github." +#~ "io/?https://github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/" +#~ "v1/definitions.html per trovare se un campo è mutevole." + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate the labels on a resource.\n" +#~ "\n" +#~ "\t\t* A label must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* If --overwrite is true, then existing labels can be overwritten, " +#~ "otherwise attempting to overwrite a label will result in an error.\n" +#~ "\t\t* If --resource-version is specified, then updates will use this " +#~ "resource version, otherwise the existing resource-version will be used." +#~ msgstr "" +#~ "\n" +#~ "\t\tAggiorna le label di una risorsa.\n" +#~ "\n" +#~ "\t\t* A label must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* If --overwrite is true, then existing labels can be overwritten, " +#~ "otherwise attempting to overwrite a label will result in an error.\n" +#~ "\t\t* If --resource-version is specified, then updates will use this " +#~ "resource version, otherwise the existing resource-version will be used." + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate the taints on one or more nodes.\n" +#~ "\n" +#~ "\t\t* A taint consists of a key, value, and effect. As an argument here, " +#~ "it is expressed as key=value:effect.\n" +#~ "\t\t* The key must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* The value must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[2]d " +#~ "characters.\n" +#~ "\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +#~ "\t\t* Currently taint can only apply to node." +#~ msgstr "" +#~ "\n" +#~ "\t\tAggiorna i marcatori su uno o più nodi.\n" +#~ "\n" +#~ "\t\t* Un marcatore è costituita da una chiave, un valore e un effetto. " +#~ "Come argomento qui, viene espresso come chiave = valore: effetto.\n" +#~ "\t\t* La chiave deve iniziare con una lettera o un numero e può contenere " +#~ "lettere, numeri, trattini, punti e sottolineature, fino a% [1] d " +#~ "caratteri.\n" +#~ "\t\t* Il valore deve iniziare con una lettera o un numero e può contenere " +#~ "lettere, numeri, trattini, punti e sottolineature, fino a% [2] d " +#~ "caratteri.\n" +#~ "\t\t* L'effetto deve essere NoSchedule, PreferNoSchedule o NoExecute.\n" +#~ "\t\t* Attualmente il marcatore può essere applicato solo al nodo." + +#~ msgid "" +#~ "\n" +#~ "\t\tView the latest last-applied-configuration annotations by type/name " +#~ "or file.\n" +#~ "\n" +#~ "\t\tThe default output will be printed to stdout in YAML format. One can " +#~ "use -o option\n" +#~ "\t\tto change output format." +#~ msgstr "" +#~ "\n" +#~ "\t\tVisualizza le annotazioni dell'ultima-configurazione-applicata per " +#~ "tipo/nome o file.\n" +#~ "\n" +#~ "\t\tL'output predefinito verrà stampato su stdout nel formato YAML. Si " +#~ "può usare l'opzione -o\n" +#~ "\t\tPer cambiare il formato di output." + +#~ msgid "" +#~ "\n" +#~ "\t # !!!Important Note!!!\n" +#~ "\t # Requires that the 'tar' binary is present in your container\n" +#~ "\t # image. If 'tar' is not present, 'kubectl cp' will fail.\n" +#~ "\n" +#~ "\t # Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod " +#~ "in the default namespace\n" +#~ "\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +#~ "\n" +#~ " # Copy /tmp/foo local file to /tmp/bar in a remote pod in a " +#~ "specific container\n" +#~ "\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +#~ "\n" +#~ "\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +#~ "\t\tkubectl cp /:/tmp/foo /tmp/bar" +#~ msgstr "" +#~ "\n" +#~ "\t # !!!Nota importante!!!\n" +#~ "\t # Richiede che il binario 'tar' sia presente nel tuo contenitore\n" +#~ "\t # immagine. Se 'tar' non è presente, 'kubectl cp' non riesce.\n" +#~ "\n" +#~ "\t # Copia /tmp/foo_dir directory locale in /tmp/bar_dir in un pod " +#~ "remoto nello spazio dei nomi predefinito\n" +#~ "\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +#~ "\n" +#~ " # Copia /tmp/foo file locale in /tmp/bar in un pod remoto in un " +#~ "contenitore specifico\n" +#~ "\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +#~ "\n" +#~ "\t\t# Copia /tmp/foo file locale in /tmp/bar in un pod remoto nello " +#~ "spazio dei nomi \n" +#~ "\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +#~ "\n" +#~ "\t\t# Copia /tmp/foo da un pod remoto in /tmp/bar localmente\n" +#~ "\t\tkubectl cp /:/tmp/foo /tmp/bar" + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new TLS secret named tls-secret with the given key pair:\n" +#~ "\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --" +#~ "key=path/to/tls.key" +#~ msgstr "" +#~ "\n" +#~ "\t # Crea un nuovo secret TLS denominato tls-secret con la coppia di " +#~ "dati fornita:\n" +#~ "\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --" +#~ "key=path/to/tls.key" + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new secret named my-secret with keys for each file in " +#~ "folder bar\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with specified keys instead of " +#~ "names on disk\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with key1=supersecret and " +#~ "key2=topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" +#~ msgstr "" +#~ "\n" +#~ "\t # Crea un nuovo secret denominato my-secret con i tasti per ogni file " +#~ "nella barra delle cartelle\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Crea un nuovo secret denominato my-secret con le chiavi specificate " +#~ "anziché i nomi sul disco\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Crea un nuovo secret denominato my-secret con key1 = supersecret e " +#~ "key2 = topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" + +#~ msgid "" +#~ "\n" +#~ "\t# Create a new ExternalName service named my-ns \n" +#~ "\tkubectl create service externalname my-ns --external-name bar.com" +#~ msgstr "" +#~ "\n" +#~ "\t# Crea un nuovo servizio ExternalName denominato my-ns \n" +#~ "\tkubectl create service externalname my-ns --external-name bar.com" + +#~ msgid "" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs (in headless mode)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" +#~ msgstr "" +#~ "\n" +#~ " # Creare un nuovo servizio clusterIP denominato my-cs\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # Creare un nuovo servizio clusterIP denominato my-cs (in modalità " +#~ "headless)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" + +#~ msgid "" +#~ "\n" +#~ " # Create a new deployment named my-dep that runs the busybox image.\n" +#~ " kubectl create deployment my-dep --image=busybox" +#~ msgstr "" +#~ "\n" +#~ " # Crea una nuovo deployment chiamato my-dep che esegue l'immagine " +#~ "busybox.\n" +#~ " kubectl create deployment my-dep --image=busybox" + +#~ msgid "" +#~ "\n" +#~ " # Create a new nodeport service named my-ns\n" +#~ " kubectl create service nodeport my-ns --tcp=5678:8080" +#~ msgstr "" +#~ "\n" +#~ " # Creare un nuovo servizio nodeport denominato my-ns\n" +#~ " kubectl create service nodeport my-ns --tcp=5678:8080" + +#~ msgid "" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend'.\n" +#~ " # If the same annotation is set multiple times, only the last value " +#~ "will be applied\n" +#~ " kubectl annotate pods foo description='my frontend'\n" +#~ "\n" +#~ " # Update a pod identified by type and name in \"pod.json\"\n" +#~ " kubectl annotate -f pod.json description='my frontend'\n" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend running nginx', overwriting any existing value.\n" +#~ " kubectl annotate --overwrite pods foo description='my frontend " +#~ "running nginx'\n" +#~ "\n" +#~ " # Update all pods in the namespace\n" +#~ " kubectl annotate pods --all description='my frontend running nginx'\n" +#~ "\n" +#~ " # Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ " kubectl annotate pods foo description='my frontend running nginx' --" +#~ "resource-version=1\n" +#~ "\n" +#~ " # Update pod 'foo' by removing an annotation named 'description' if " +#~ "it exists.\n" +#~ " # Does not require the --overwrite flag.\n" +#~ " kubectl annotate pods foo description-" +#~ msgstr "" +#~ "\n" +#~ " # Aggiorna il pod 'foo' con annotazione 'description'e il valore 'my " +#~ "frontend'.\n" +#~ " # Se la stessa annotazione è impostata più volte, verrà applicato " +#~ "solo l'ultimo valore\n" +#~ " kubectl annotate pods foo description='my frontend'\n" +#~ "\n" +#~ " # Aggiorna un pod identificato per tipo e nome in \"pod.json\"\n" +#~ " kubectl annotate -f pod.json description='my frontend'\n" +#~ "\n" +#~ " # Aggiorna pod 'foo' con la annotazione 'description' e il valore 'my " +#~ "frontend running nginx', sovrascrivendo qualsiasi valore esistente.\n" +#~ " kubectl annotate --overwrite pods foo description='my frontend " +#~ "running nginx'\n" +#~ "\n" +#~ " # Aggiorna tutti i baccelli nel namespace\n" +#~ " kubectl annotate pods --all description='my frontend running nginx'\n" +#~ "\n" +#~ " # Aggiorna il pod 'foo' solo se la risorsa è invariata dalla versione " +#~ "1.\n" +#~ " kubectl annotate pods foo description='my frontend running nginx' --" +#~ "resource-version=1\n" +#~ "\n" +#~ " # Aggiorna il pod 'foo' rimuovendo un'annotazione denominata " +#~ "'descrizione' se esiste.\n" +#~ " # Non richiede flag -overwrite.\n" +#~ " kubectl annotate pods foo description-" + +#~ msgid "" +#~ "\n" +#~ " Create a clusterIP service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Crea un servizio clusterIP con il nome specificato." + +#~ msgid "" +#~ "\n" +#~ " Create a deployment with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Creare un deployment con il nome specificato." + +#~ msgid "" +#~ "\n" +#~ " Create a nodeport service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Creare un servizio nodeport con il nome specificato." + +#~ msgid "" +#~ "\n" +#~ " Dumps cluster info out suitable for debugging and diagnosing cluster " +#~ "problems. By default, dumps everything to\n" +#~ " stdout. You can optionally specify a directory with --output-" +#~ "directory. If you specify a directory, kubernetes will\n" +#~ " build a set of files in that directory. By default only dumps things " +#~ "in the 'kube-system' namespace, but you can\n" +#~ " switch to a different namespace with the --namespaces flag, or " +#~ "specify --all-namespaces to dump all namespaces.\n" +#~ "\n" +#~ " The command also dumps the logs of all of the pods in the cluster, " +#~ "these logs are dumped into different directories\n" +#~ " based on namespace and pod name." +#~ msgstr "" +#~ "\n" +#~ " Dump delle informazioni di cluster idonee per il debug e la " +#~ "diagnostica di problemi di cluster. Per impostazione predefinita, tutto\n" +#~ "    verso stdout. È possibile specificare opzionalmente una directory con " +#~ "--output-directory. Se si specifica una directory, kubernetes \n" +#~ " creearà un insieme di file in quella directory. Per impostazione " +#~ "predefinita, dumps solo i dati del namespace \"kube-system\", ma è\n" +#~ " possibile passare ad namespace diverso con il flag --namespaces o " +#~ "specificare --all-namespaces per il dump di tutti i namespace.\n" +#~ "\n" +#~ "     Il comando esegue dump anche dei log di tutti i pod del cluster, " +#~ "questi log vengono scaricati in directory differenti\n" +#~ "     basati sul namespace e sul nome del pod." + +#~ msgid "" +#~ "\n" +#~ " Display addresses of the master and services with label kubernetes.io/" +#~ "cluster-service=true\n" +#~ " To further debug and diagnose cluster problems, use 'kubectl cluster-" +#~ "info dump'." +#~ msgstr "" +#~ "\n" +#~ " Visualizza gli indirizzi del master e dei servizi con label kubernetes." +#~ "io/cluster-service=true\n" +#~ "  Per ulteriore debug e diagnosticare i problemi di cluster, utilizzare " +#~ "'kubectl cluster-info dump'." + +#~ msgid "A schedule in the Cron format the job should be run with." +#~ msgstr "Un calendario in formato Cron del lavoro che deve essere eseguito." + +#~ msgid "" +#~ "An inline JSON override for the generated service object. If this is non-" +#~ "empty, it is used to override the generated object. Requires that the " +#~ "object supply a valid apiVersion field. Only used if --expose is true." +#~ msgstr "" +#~ "Un override JSON inline per l'oggetto di servizio generato. Se questo non " +#~ "è vuoto, viene utilizzato per ignorare l'oggetto generato. Richiede che " +#~ "l'oggetto fornisca un campo valido apiVersion. Utilizzato solo se --" +#~ "expose è true." + +#~ msgid "Apply a configuration to a resource by filename or stdin" +#~ msgstr "Applica una configurazione risorsa per nomefile o stdin" + +#~ msgid "Auto-scale a Deployment, ReplicaSet, or ReplicationController" +#~ msgstr "Auto-scale a Deployment, ReplicaSet, o ReplicationController" + +#~ msgid "" +#~ "Container name which will have its image upgraded. Only relevant when --" +#~ "image is specified, ignored otherwise. Required when using --image on a " +#~ "multi-container pod" +#~ msgstr "" +#~ "Nome container che avrà la sua immagine aggiornata. Soltanto rilevante " +#~ "quando --image è specificato, altrimenti ignorato. Necessario quando si " +#~ "utilizza --image su un contenitore a più contenitori" + +#~ msgid "Create a ClusterRoleBinding for a particular ClusterRole" +#~ msgstr "Crea un ClusterRoleBinding per un ClusterRole particolare" + +#~ msgid "Create a LoadBalancer service." +#~ msgstr "Creare un servizio LoadBalancer." + +#~ msgid "Create a NodePort service." +#~ msgstr "Crea un servizio NodePort." + +#~ msgid "Create a RoleBinding for a particular Role or ClusterRole" +#~ msgstr "Crea un RoleBinding per un particolare Role o ClusterRole" + +#~ msgid "Create a clusterIP service." +#~ msgstr "Crea un servizio clusterIP." + +#~ msgid "Create a configmap from a local file, directory or literal value" +#~ msgstr "" +#~ "Crea un configmap da un file locale, una directory o un valore letterale" + +#~ msgid "Create a deployment with the specified name." +#~ msgstr "Creare un deployment con il nome specificato." + +#~ msgid "Create a pod disruption budget with the specified name." +#~ msgstr "Crea un pod disruption budget con il nome specificato." + +#~ msgid "Create a quota with the specified name." +#~ msgstr "Crea una quota con il nome specificato." + +#~ msgid "Create a resource by filename or stdin" +#~ msgstr "Crea una risorsa per nome file o stdin" + +#~ msgid "Create a secret from a local file, directory or literal value" +#~ msgstr "" +#~ "Crea un secret da un file locale, una directory o un valore letterale" + +#~ msgid "Create a service using specified subcommand." +#~ msgstr "Crea un servizio utilizzando il subcommand specificato." + +#~ msgid "Create an ExternalName service." +#~ msgstr "Crea un servizio ExternalName." + +#~ msgid "" +#~ "Delete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector" +#~ msgstr "" +#~ "Elimina risorse selezionate per nomi di file, stdin, risorse e nomi, o " +#~ "per risorsa e selettore di label" + +#~ msgid "Deprecated: Gracefully shut down a resource by name or filename" +#~ msgstr "Deprecated: spegne correttamente una risorsa per nome o nome file" + +#~ msgid "Display Resource (CPU/Memory) usage of nodes" +#~ msgstr "Visualizza l'utilizzo di risorse (CPU/Memoria) per nodo" + +#~ msgid "Display Resource (CPU/Memory) usage of pods" +#~ msgstr "Visualizza l'utilizzo di risorse (CPU/Memoria) per pod." + +#~ msgid "Display Resource (CPU/Memory) usage." +#~ msgstr "Visualizza l'utilizzo di risorse (CPU/Memoria)." + +#~ msgid "Display cluster info" +#~ msgstr "Visualizza informazioni sul cluster" + +#~ msgid "Displays the current-context" +#~ msgstr "Visualizza il current-context" + +#~ msgid "Documentation of resources" +#~ msgstr "Documentazione delle risorse" + +#~ msgid "Dump lots of relevant info for debugging and diagnosis" +#~ msgstr "" +#~ "Dump di un sacco di informazioni pertinenti per il debug e la diagnosi" + +#~ msgid "" +#~ "Explicit policy for when to pull container images. Required when --image " +#~ "is same as existing image, ignored otherwise." +#~ msgstr "" +#~ "Politica esplicita per il pull delle immagini container. Richiesto quando " +#~ "--image è uguale all'immagine esistente, altrimenti ignorata." + +#~ msgid "" +#~ "IP to assign to the Load Balancer. If empty, an ephemeral IP will be " +#~ "created and used (cloud-provider specific)." +#~ msgstr "" +#~ "IP da assegnare al Load Balancer. Se vuota, un IP effimero verrà creato e " +#~ "utilizzato (specifico per provider cloud)." + +#~ msgid "" +#~ "Image to use for upgrading the replication controller. Must be distinct " +#~ "from the existing image (either new image or new image tag). Can not be " +#~ "used with --filename/-f" +#~ msgstr "" +#~ "Immagine da utilizzare per aggiornare il replication controller. Deve " +#~ "essere diversa dall'immagine esistente (nuova immagine o nuovo tag " +#~ "immagine). Non può essere utilizzata con --filename/-f" + +#~ msgid "Manage a deployment rollout" +#~ msgstr "Gestisci un deployment rollout" + +#~ msgid "" +#~ "Output the formatted object with the given group version (for ex: " +#~ "'extensions/v1beta1').)" +#~ msgstr "" +#~ "Output dell'oggetto formattato con la versione del gruppo fornito (per " +#~ "esempio: 'extensions/v1beta1').)" + +#~ msgid "Perform a rolling update of the given ReplicationController" +#~ msgstr "Eseguire un rolling update del ReplicationController specificato" + +#~ msgid "Replace a resource by filename or stdin" +#~ msgstr "Sostituire una risorsa per nomefile o stdin" + +#~ msgid "" +#~ "Set a new size for a Deployment, ReplicaSet, Replication Controller, or " +#~ "Job" +#~ msgstr "" +#~ "Imposta una nuova dimensione per Deployment, ReplicaSet, Replication " +#~ "Controller, o Job" + +#~ msgid "" +#~ "Set the last-applied-configuration annotation on a live object to match " +#~ "the contents of a file." +#~ msgstr "" +#~ "Imposta l'annotazione dell'ultima-configurazione-applicata ad un oggetto " +#~ "live per abbinare il contenuto di un file." + +#~ msgid "Sets a cluster entry in kubeconfig" +#~ msgstr "Imposta una voce cluster in kubeconfig" + +#~ msgid "Sets a context entry in kubeconfig" +#~ msgstr "Imposta una voce context in kubeconfig" + +#~ msgid "Sets a user entry in kubeconfig" +#~ msgstr "Imposta una voce utente in kubeconfig" + +#~ msgid "Sets an individual value in a kubeconfig file" +#~ msgstr "Imposta un singolo valore in un file kubeconfig" + +#~ msgid "Sets the current-context in a kubeconfig file" +#~ msgstr "Imposta il current-context in un file kubeconfig" + +#~ msgid "" +#~ "Take a replication controller, service, deployment or pod and expose it " +#~ "as a new Kubernetes Service" +#~ msgstr "" +#~ "Prende un replication controller, service, deployment o un pod e lo " +#~ "espone come nuovo servizio Kubernetes" + +#~ msgid "" +#~ "The key to use to differentiate between two different controllers, " +#~ "default 'deployment'. Only relevant when --image is specified, ignored " +#~ "otherwise" +#~ msgstr "" +#~ "La chiave da utilizzare per distinguere tra due controller diversi, " +#~ "predefinito \"deployment\". Rilevante soltanto quando --image è " +#~ "specificato, altrimenti ignorato" + +#~ msgid "" +#~ "The name of the API generator to use, see http://kubernetes.io/docs/user-" +#~ "guide/kubectl-conventions/#generators for a list." +#~ msgstr "" +#~ "Il nome del generatore API da utilizzare, si veda http://kubernetes.io/" +#~ "docs/user-guide/kubectl-conventions/#generators per un elenco." + +#~ msgid "" +#~ "The name of the API generator to use. Currently there is only 1 generator." +#~ msgstr "" +#~ "Il nome del generatore API da utilizzare. Attualmente c'è solo 1 " +#~ "generatore." + +#~ msgid "" +#~ "The name of the generator to use for creating a service. Only used if --" +#~ "expose is true" +#~ msgstr "" +#~ "Il nome del generatore da utilizzare per la creazione di un servizio. " +#~ "Utilizzato solo se --expose è true" + +#~ msgid "" +#~ "The port that this container exposes. If --expose is true, this is also " +#~ "the port used by the service that is created." +#~ msgstr "" +#~ "La porta che questo contenitore espone. Se --expose è true, questa è " +#~ "anche la porta utilizzata dal servizio creato." + +#~ msgid "" +#~ "The restart policy for this Pod. Legal values [Always, OnFailure, " +#~ "Never]. If set to 'Always' a deployment is created, if set to " +#~ "'OnFailure' a job is created, if set to 'Never', a regular pod is " +#~ "created. For the latter two --replicas must be 1. Default 'Always', for " +#~ "CronJobs `Never`." +#~ msgstr "" +#~ "La politica di riavvio per questo Pod. Valori accettati [Always, " +#~ "OnFailure, Never]. Se impostato su 'Always' viene creato un deployment, " +#~ "se impostato su 'OnFailure' viene creato un job, se impostato su 'Never', " +#~ "viene creato un pod. Per questi ultimi due le - repliche devono essere 1. " +#~ "Predefinito 'Always', per CronJobs `Never`." + +#~ msgid "" +#~ "Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is " +#~ "'ClusterIP'." +#~ msgstr "" +#~ "Digitare per questo servizio: ClusterIP, NodePort o LoadBalancer. " +#~ "Ppredefinito è 'ClusterIP'." + +#~ msgid "Unsets an individual value in a kubeconfig file" +#~ msgstr "Annulla singolo valore in un file kubeconfig" + +#~ msgid "Update field(s) of a resource using strategic merge patch" +#~ msgstr "Aggiornare campo/i risorsa utilizzando merge patch strategici" + +#~ msgid "Update image of a pod template" +#~ msgstr "Aggiorna immagine di un pod template" + +#~ msgid "" +#~ "View latest last-applied-configuration annotations of a resource/object" +#~ msgstr "" +#~ "Visualizza ultime annotazioni dell'ultima configurazione applicata per " +#~ "risorsa/oggetto" + +#~ msgid "external name of service" +#~ msgstr "nome esterno del servizio" diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ja_JP/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ja_JP/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..f917b6c5bf Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ja_JP/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ja_JP/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ja_JP/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..d6f4aa2c4b --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ja_JP/LC_MESSAGES/k8s.po @@ -0,0 +1,3365 @@ +# Test translations for unit tests. +# Copyright (C) 2017 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR girikuncoro@gmail.com, 2017. +# +msgid "" +msgstr "" +"Project-Id-Version: gettext-go-examples-hello\n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2020-01-05 09:55+0900\n" +"Last-Translator: Kohei Ota \n" +"Language-Team: \n" +"Language: ja\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 2.2.4\n" +"X-Poedit-SourceCharset: UTF-8\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:62 +msgid "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" +msgstr "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:46 +msgid "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" +msgstr "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/options.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:29 +msgid "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" +msgstr "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/version.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:44 +msgid "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" +msgstr "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:34 +msgid "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" +msgstr "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:75 +msgid "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" +msgstr "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" + +#: pkg/kubectl/cmd/convert/convert.go:40 +msgid "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." +msgstr "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:39 +msgid "" +"\n" +"\t\tCreate a namespace with the specified name." +msgstr "" +"\n" +"\t\tCreate a namespace with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L47 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:43 +msgid "" +"\n" +"\t\tCreate a role with single rule." +msgstr "" +"\n" +"\t\tCreate a role with single rule." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:40 +msgid "" +"\n" +"\t\tCreate a service account with the specified name." +msgstr "" +"\n" +"\t\tCreate a service account with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L127 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:84 +msgid "" +"\n" +"\t\tMark node as schedulable." +msgstr "" +"\n" +"\t\tMark node as schedulable." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:55 +msgid "" +"\n" +"\t\tMark node as unschedulable." +msgstr "" +"\n" +"\t\tMark node as unschedulable." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:70 +msgid "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." +msgstr "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:42 +msgid "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" +msgstr "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:43 +msgid "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" +msgstr "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:344 +msgid "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." +msgstr "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:28 +msgid "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." +msgstr "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:311 +msgid "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" +msgstr "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:102 +msgid "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" +msgstr "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:308 +msgid "" +"\n" +" Create a LoadBalancer service with the specified name." +msgstr "" +"\n" +" Create a LoadBalancer service with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L61 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:107 +msgid "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." +msgstr "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L60 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:106 +msgid "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." +msgstr "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L63 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:113 +msgid "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." +msgstr "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L106 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:152 +msgid "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" +msgstr "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L111 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:157 +msgid "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." +msgstr "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L119 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:158 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:178 +msgid "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." +msgstr "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:125 +msgid "Approve a certificate signing request" +msgstr "Approve a certificate signing request" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L81 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:263 +msgid "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." +msgstr "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/attach.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:105 +msgid "Attach to a running container" +msgstr "Attach to a running container" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L115 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:161 +msgid "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." +msgstr "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_clusterrolebinding.go#L55 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:101 +msgid "ClusterRole this ClusterRoleBinding should reference" +msgstr "ClusterRole this ClusterRoleBinding should reference" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L55 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:104 +msgid "ClusterRole this RoleBinding should reference" +msgstr "ClusterRole this RoleBinding should reference" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/convert.go#L67 +#: pkg/kubectl/cmd/convert/convert.go:95 +msgid "Convert config files between different API versions" +msgstr "Convert config files between different API versions" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/cp.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:106 +msgid "Copy files and directories to and from containers." +msgstr "Copy files and directories to and from containers." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L214 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:94 +msgid "Create a TLS secret" +msgstr "Create a TLS secret" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:83 +msgid "Create a namespace with the specified name" +msgstr "Create a namespace with the specified name" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L143 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:134 +msgid "Create a secret for use with a Docker registry" +msgstr "Create a secret for use with a Docker registry" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L34 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:49 +msgid "Create a secret using specified subcommand" +msgstr "Create a secret using specified subcommand" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:85 +msgid "Create a service account with the specified name" +msgstr "Create a service account with the specified name" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_cluster.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "指定したコンテキストをkubeconfigから削除する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_context.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "指定したコンテキストをkubeconfigから削除する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L121 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:174 +msgid "Deny a certificate signing request" +msgstr "Deny a certificate signing request" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_contexts.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "1つまたは複数のコンテキストを記述する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_clusters.go#L40 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "kubeconfigで定義されたクラスターを表示する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/view.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "マージされたkubeconfigの設定または指定されたkubeconfigを表示する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/get.go#L107 +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:165 +msgid "Display one or many resources" +msgstr "1つまたは複数のリソースを表示する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L176 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:184 +msgid "Drain node in preparation for maintenance" +msgstr "Drain node in preparation for maintenance" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/edit.go#L100 +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:77 +msgid "Edit a resource on the server" +msgstr "Edit a resource on the server" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L159 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:152 +msgid "Email for Docker registry" +msgstr "Email for Docker registry" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/exec.go#L68 +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:89 +msgid "Execute a command in a container" +msgstr "Execute a command in a container" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/portforward.go#L75 +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:109 +msgid "Forward one or more local ports to a pod" +msgstr "Forward one or more local ports to a pod" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/help.go#L36 +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:37 +msgid "Help about any command" +msgstr "Help about any command" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L114 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:160 +msgid "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" +msgstr "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/annotate.go#L135 +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:157 +msgid "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/label.go#L132 +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:154 +msgid "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L127 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:98 +msgid "Mark node as schedulable" +msgstr "Mark node as schedulable" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:69 +msgid "Mark node as unschedulable" +msgstr "Mark node as unschedulable" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_pause.go#L73 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:83 +msgid "Mark the provided resource as paused" +msgstr "Mark the provided resource as paused" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L35 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:49 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:50 +msgid "Modify certificate resources." +msgstr "Modify certificate resources." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/config.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "kubeconfigを変更する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L110 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:156 +msgid "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." +msgstr "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/logs.go#L108 +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:174 +msgid "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." +msgstr "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/completion.go#L97 +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:112 +msgid "Output shell completion code for the specified shell (bash or zsh)" +msgstr "Output shell completion code for the specified shell (bash or zsh)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L157 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:151 +msgid "Password for Docker registry authentication" +msgstr "Password for Docker registry authentication" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L226 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:110 +msgid "Path to PEM encoded public key certificate." +msgstr "Path to PEM encoded public key certificate." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L227 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:111 +msgid "Path to private key associated with given certificate." +msgstr "Path to private key associated with given certificate." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/scale.go#L82 +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:130 +msgid "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." +msgstr "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/version.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:73 +msgid "Print the client and server version information" +msgstr "Print the client and server version information" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/options.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:38 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:39 +msgid "Print the list of flags inherited by all commands" +msgstr "Print the list of flags inherited by all commands" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/logs.go#L86 +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:152 +msgid "Print the logs for a container in a pod" +msgstr "Print the logs for a container in a pod" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_resume.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:87 +msgid "Resume a paused resource" +msgstr "Resume a paused resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L56 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:105 +msgid "Role this RoleBinding should reference" +msgstr "Role this RoleBinding should reference" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L94 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:152 +msgid "Run a particular image on the cluster" +msgstr "Run a particular image on the cluster" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/proxy.go#L68 +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:119 +msgid "Run a proxy to the Kubernetes API server" +msgstr "Run a proxy to the Kubernetes API server" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L161 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:153 +msgid "Server location for Docker registry" +msgstr "Server location for Docker registry" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:39 +msgid "Set specific features on objects" +msgstr "Set specific features on objects" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_selector.go#L81 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:104 +msgid "Set the selector on a resource" +msgstr "リソースのセレクターを設定する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/describe.go#L80 +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:107 +msgid "Show details of a specific resource or group of resources" +msgstr "Show details of a specific resource or group of resources" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_status.go#L57 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:102 +msgid "Show the status of the rollout" +msgstr "Show the status of the rollout" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L108 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:154 +msgid "Synonym for --target-port" +msgstr "Synonym for --target-port" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L114 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:174 +msgid "The image for the container to run." +msgstr "The image for the container to run." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L116 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:176 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" +msgstr "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:111 +msgid "" +"The minimum number or percentage of available pods this budget requires." +msgstr "" +"The minimum number or percentage of available pods this budget requires." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L113 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:159 +msgid "The name for the newly created object." +msgstr "The name for the newly created object." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/autoscale.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:125 +msgid "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." +msgstr "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L98 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:147 +msgid "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." +msgstr "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L99 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:148 +msgid "The network protocol for the service to be created. Default is 'TCP'." +msgstr "The network protocol for the service to be created. Default is 'TCP'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L100 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:149 +msgid "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" +msgstr "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L131 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:194 +msgid "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." +msgstr "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L130 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:192 +msgid "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." +msgstr "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L87 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:155 +msgid "The type of secret to create" +msgstr "The type of secret to create" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_undo.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:87 +msgid "Undo a previous rollout" +msgstr "現在のロールアウトを取り消す" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_resources.go#L101 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:116 +msgid "Update resource requests/limits on objects with pod templates" +msgstr "Update resource requests/limits on objects with pod templates" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "リソースのアノテーションを更新する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/label.go#L109 +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:133 +msgid "Update the labels on a resource" +msgstr "リソースのラベルを更新する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/taint.go#L88 +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:109 +msgid "Update the taints on one or more nodes" +msgstr "Update the taints on one or more nodes" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L155 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:150 +msgid "Username for Docker registry authentication" +msgstr "Username for Docker registry authentication" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_history.go#L51 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:83 +msgid "View rollout history" +msgstr "ロールアウトの履歴を表示する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/clusterinfo_dump.go#L45 +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:85 +msgid "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" +msgstr "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run_test.go:88 +msgid "dummy restart flag)" +msgstr "dummy restart flag)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/cmd.go#L217 +#: staging/src/k8s.io/kubectl/pkg/cmd/cmd.go:227 +msgid "kubectl controls the Kubernetes cluster manager" +msgstr "kubectl controls the Kubernetes cluster manager" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a ClusterRoleBinding for user1, user2, and group1 using " +#~ "the cluster-admin ClusterRole\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin --user=user1 --user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Create a ClusterRoleBinding for user1, user2, and group1 using " +#~ "the cluster-admin ClusterRole\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin --user=user1 --user=user2 --group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a RoleBinding for user1, user2, and group1 using the admin " +#~ "ClusterRole\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +#~ "user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Create a RoleBinding for user1, user2, and group1 using the admin " +#~ "ClusterRole\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +#~ "user=user2 --group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config based on folder bar\n" +#~ "\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with specified keys " +#~ "instead of file basenames on disk\n" +#~ "\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/" +#~ "file1.txt --from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with key1=config1 and " +#~ "key2=config2\n" +#~ "\t\t kubectl create configmap my-config --from-literal=key1=config1 --" +#~ "from-literal=key2=config2" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config based on folder bar\n" +#~ "\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with specified keys " +#~ "instead of file basenames on disk\n" +#~ "\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/" +#~ "file1.txt --from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with key1=config1 and " +#~ "key2=config2\n" +#~ "\t\t kubectl create configmap my-config --from-literal=key1=config1 --" +#~ "from-literal=key2=config2" + +#~ msgid "" +#~ "\n" +#~ "\t\t # If you don't already have a .dockercfg file, you can create a " +#~ "dockercfg secret directly by using:\n" +#~ "\t\t kubectl create secret docker-registry my-secret --docker-" +#~ "server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +#~ "password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL" +#~ msgstr "" +#~ "\n" +#~ "\t\t # If you don't already have a .dockercfg file, you can create a " +#~ "dockercfg secret directly by using:\n" +#~ "\t\t kubectl create secret docker-registry my-secret --docker-" +#~ "server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +#~ "password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Apply the configuration in pod.json to a pod.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Apply the JSON passed into stdin to a pod.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Note: --prune is still in Alpha\n" +#~ "\t\t# Apply the configuration in manifest.yaml that matches label " +#~ "app=nginx and delete all the other resources that are not in the file and " +#~ "match label app=nginx.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# Apply the configuration in manifest.yaml and delete all the other " +#~ "configmaps that are not in the file.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/" +#~ "v1/ConfigMap" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Apply the configuration in pod.json to a pod.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Apply the JSON passed into stdin to a pod.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Note: --prune is still in Alpha\n" +#~ "\t\t# Apply the configuration in manifest.yaml that matches label " +#~ "app=nginx and delete all the other resources that are not in the file and " +#~ "match label app=nginx.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# Apply the configuration in manifest.yaml and delete all the other " +#~ "configmaps that are not in the file.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/" +#~ "v1/ConfigMap" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 " +#~ "and 10, no target CPU utilization specified so a default autoscaling " +#~ "policy will be used:\n" +#~ "\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +#~ "\n" +#~ "\t\t# Auto scale a replication controller \"foo\", with the number of " +#~ "pods between 1 and 5, target CPU utilization at 80%:\n" +#~ "\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 " +#~ "and 10, no target CPU utilization specified so a default autoscaling " +#~ "policy will be used:\n" +#~ "\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +#~ "\n" +#~ "\t\t# Auto scale a replication controller \"foo\", with the number of " +#~ "pods between 1 and 5, target CPU utilization at 80%:\n" +#~ "\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# Convert the live state of the resource specified by 'pod.yaml' to " +#~ "the latest version\n" +#~ "\t\t# and print to stdout in json format.\n" +#~ "\t\tkubectl convert -f pod.yaml --local -o json\n" +#~ "\n" +#~ "\t\t# Convert all files under current directory to latest version and " +#~ "create them all.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# Convert the live state of the resource specified by 'pod.yaml' to " +#~ "the latest version\n" +#~ "\t\t# and print to stdout in json format.\n" +#~ "\t\tkubectl convert -f pod.yaml --local -o json\n" +#~ "\n" +#~ "\t\t# Convert all files under current directory to latest version and " +#~ "create them all.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" that allows user to " +#~ "perform \"get\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" with ResourceName " +#~ "specified\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods --resource-name=readablepod" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" that allows user to " +#~ "perform \"get\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" with ResourceName " +#~ "specified\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods --resource-name=readablepod" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" that allows user to perform \"get" +#~ "\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" with ResourceName specified\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verg=list --verb=watch --" +#~ "resource=pods --resource-name=readablepod" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" that allows user to perform \"get" +#~ "\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" with ResourceName specified\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verg=list --verb=watch --" +#~ "resource=pods --resource-name=readablepod" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a new resourcequota named my-quota\n" +#~ "\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2," +#~ "services=3,replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# Create a new resourcequota named best-effort\n" +#~ "\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Create a new resourcequota named my-quota\n" +#~ "\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2," +#~ "services=3,replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# Create a new resourcequota named best-effort\n" +#~ "\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=rails label\n" +#~ "\t\t# and require at least one of them being available at any point in " +#~ "time.\n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=nginx label\n" +#~ "\t\t# and require at least half of the pods selected to be available at " +#~ "any point in time.\n" +#~ "\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=rails label\n" +#~ "\t\t# and require at least one of them being available at any point in " +#~ "time.\n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=nginx label\n" +#~ "\t\t# and require at least half of the pods selected to be available at " +#~ "any point in time.\n" +#~ "\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod using the data in pod.json.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Create a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# Edit the data in docker-registry.yaml in JSON using the v1 API " +#~ "format then create the resource using the edited data.\n" +#~ "\t\tkubectl create -f docker-registry.yaml --edit --output-version=v1 -o " +#~ "json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Create a pod using the data in pod.json.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Create a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# Edit the data in docker-registry.yaml in JSON using the v1 API " +#~ "format then create the resource using the edited data.\n" +#~ "\t\tkubectl create -f docker-registry.yaml --edit --output-version=v1 -o " +#~ "json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a replication controller identified by type " +#~ "and name specified in \"nginx-controller.yaml\", which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +#~ "the name \"frontend\"\n" +#~ "\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +#~ "\n" +#~ "\t\t# Create a second service based on the above service, exposing the " +#~ "container port 8443 as port 443 with the name \"nginx-https\"\n" +#~ "\t\tkubectl expose service nginx --port=443 --target-port=8443 --" +#~ "name=nginx-https\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated streaming application on port " +#~ "4100 balancing UDP traffic and named 'video-stream'.\n" +#~ "\t\tkubectl expose rc streamer --port=4100 --protocol=udp --name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx using replica set, which " +#~ "serves on port 80 and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for an nginx deployment, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose deployment nginx --port=80 --target-port=8000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a replication controller identified by type " +#~ "and name specified in \"nginx-controller.yaml\", which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +#~ "the name \"frontend\"\n" +#~ "\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +#~ "\n" +#~ "\t\t# Create a second service based on the above service, exposing the " +#~ "container port 8443 as port 443 with the name \"nginx-https\"\n" +#~ "\t\tkubectl expose service nginx --port=443 --target-port=8443 --" +#~ "name=nginx-https\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated streaming application on port " +#~ "4100 balancing UDP traffic and named 'video-stream'.\n" +#~ "\t\tkubectl expose rc streamer --port=4100 --protocol=udp --name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx using replica set, which " +#~ "serves on port 80 and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for an nginx deployment, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose deployment nginx --port=80 --target-port=8000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Delete a pod using the type and name specified in pod.json.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Delete a pod based on the type and name in the JSON passed into " +#~ "stdin.\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# Delete pods and services with label name=myLabel.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Delete a pod with minimal delay\n" +#~ "\t\tkubectl delete pod foo --now\n" +#~ "\n" +#~ "\t\t# Force delete a pod on a dead node\n" +#~ "\t\tkubectl delete pod foo --grace-period=0 --force\n" +#~ "\n" +#~ "\t\t# Delete all pods\n" +#~ "\t\tkubectl delete pods --all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Delete a pod using the type and name specified in pod.json.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Delete a pod based on the type and name in the JSON passed into " +#~ "stdin.\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# Delete pods and services with label name=myLabel.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Delete a pod with minimal delay\n" +#~ "\t\tkubectl delete pod foo --now\n" +#~ "\n" +#~ "\t\t# Force delete a pod on a dead node\n" +#~ "\t\tkubectl delete pod foo --grace-period=0 --force\n" +#~ "\n" +#~ "\t\t# Delete all pods\n" +#~ "\t\tkubectl delete pods --all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Describe a node\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# Describe a pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# Describe all pods\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# Describe pods by label name=myLabel\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Describe all pods managed by the 'frontend' replication controller " +#~ "(rc-created pods\n" +#~ "\t\t# get the name of the rc as a prefix in the pod the name).\n" +#~ "\t\tkubectl describe pods frontend" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Describe a node\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# Describe a pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# Describe all pods\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# Describe pods by label name=myLabel\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Describe all pods managed by the 'frontend' replication controller " +#~ "(rc-created pods\n" +#~ "\t\t# get the name of the rc as a prefix in the pod the name).\n" +#~ "\t\tkubectl describe pods frontend" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Drain node \"foo\", even if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet on it.\n" +#~ "\t\t$ kubectl drain foo --force\n" +#~ "\n" +#~ "\t\t# As above, but abort if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet, and use " +#~ "a grace period of 15 minutes.\n" +#~ "\t\t$ kubectl drain foo --grace-period=900" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Drain node \"foo\", even if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet on it.\n" +#~ "\t\t$ kubectl drain foo --force\n" +#~ "\n" +#~ "\t\t# As above, but abort if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet, and use " +#~ "a grace period of 15 minutes.\n" +#~ "\t\t$ kubectl drain foo --grace-period=900" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Edit the service named 'docker-registry':\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Use an alternative editor\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Edit the job 'myjob' in JSON using the v1 API format:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +#~ "config in its annotation:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml --save-config" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Edit the service named 'docker-registry':\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Use an alternative editor\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Edit the job 'myjob' in JSON using the v1 API format:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +#~ "config in its annotation:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml --save-config" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running 'date' from pod 123456-7890, using the " +#~ "first container by default\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# Get output from running 'date' in ruby-container from pod " +#~ "123456-7890\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t -- bash -il" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Get output from running 'date' from pod 123456-7890, using the " +#~ "first container by default\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# Get output from running 'date' in ruby-container from pod " +#~ "123456-7890\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t -- bash -il" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running pod 123456-7890, using the first container " +#~ "by default\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# Get output from ruby-container from pod 123456-7890\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# Get output from the first pod of a ReplicaSet named nginx\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Get output from running pod 123456-7890, using the first container " +#~ "by default\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# Get output from ruby-container from pod 123456-7890\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# Get output from the first pod of a ReplicaSet named nginx\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Install bash completion on a Mac using homebrew\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash completion support\n" +#~ "source $(brew --prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for bash into the current shell\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# Write bash completion code to a file and source if from ." +#~ "bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell completion\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +#~ "\t\tsource <(kubectl completion zsh)" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Install bash completion on a Mac using homebrew\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash completion support\n" +#~ "source $(brew --prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for bash into the current shell\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# Write bash completion code to a file and source if from ." +#~ "bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell completion\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +#~ "\t\tsource <(kubectl completion zsh)" + +#~ msgid "" +#~ "\n" +#~ "\t\t# List all pods in ps output format.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# List all pods in ps output format with more information (such as " +#~ "node name).\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# List a single replication controller with specified NAME in ps " +#~ "output format.\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# List a single pod in JSON output format.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +#~ "JSON output format.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# Return only the phase value of the specified pod.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# List all replication controllers and services together in ps output " +#~ "format.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# List one or more resources by their type and names.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List all resources with different types.\n" +#~ "\t\tkubectl get all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# List all pods in ps output format.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# List all pods in ps output format with more information (such as " +#~ "node name).\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# List a single replication controller with specified NAME in ps " +#~ "output format.\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# List a single pod in JSON output format.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +#~ "JSON output format.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# Return only the phase value of the specified pod.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# List all replication controllers and services together in ps output " +#~ "format.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# List one or more resources by their type and names.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List all resources with different types.\n" +#~ "\t\tkubectl get all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in the pod\t\tkubectl port-forward pod/mypod 5000 " +#~ "6000\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in a pod selected by the deployment\t\tkubectl port-" +#~ "forward deployment/mydeployment 5000 6000\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in a pod selected by the service\t\tkubectl port-" +#~ "forward service/myservice 5000 6000\n" +#~ "\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\t" +#~ "\tkubectl port-forward pod/mypod 8888:5000\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\t" +#~ "\tkubectl port-forward pod/mypod :5000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in the pod\t\tkubectl port-forward pod/mypod 5000 " +#~ "6000\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in a pod selected by the deployment\t\tkubectl port-" +#~ "forward deployment/mydeployment 5000 6000\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in a pod selected by the service\t\tkubectl port-" +#~ "forward service/myservice 5000 6000\n" +#~ "\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\t" +#~ "\tkubectl port-forward pod/mypod 8888:5000\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\t" +#~ "\tkubectl port-forward pod/mypod :5000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as schedulable.\n" +#~ "\t\t$ kubectl uncordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as schedulable.\n" +#~ "\t\t$ kubectl uncordon foo" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as unschedulable.\n" +#~ "\t\tkubectl cordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as unschedulable.\n" +#~ "\t\tkubectl cordon foo" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Partially update a node using strategic merge patch\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# Partially update a node identified by the type and name specified " +#~ "in \"node.json\" using strategic merge patch\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image; spec.containers[*].name is required " +#~ "because it's a merge key\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image using a json patch with positional " +#~ "arrays\n" +#~ "\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Partially update a node using strategic merge patch\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# Partially update a node identified by the type and name specified " +#~ "in \"node.json\" using strategic merge patch\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image; spec.containers[*].name is required " +#~ "because it's a merge key\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image using a json patch with positional " +#~ "arrays\n" +#~ "\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Print the address of the master and cluster services\n" +#~ "\t\tkubectl cluster-info" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Print the address of the master and cluster services\n" +#~ "\t\tkubectl cluster-info" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Replace a pod using the data in pod.json.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Replace a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Update a single-container pod's image version (tag) to v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Force replace, delete and then re-create the resource\n" +#~ "\t\tkubectl replace --force -f ./pod.json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Replace a pod using the data in pod.json.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Replace a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Update a single-container pod's image version (tag) to v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Force replace, delete and then re-create the resource\n" +#~ "\t\tkubectl replace --force -f ./pod.json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Return snapshot logs from pod nginx with only one container\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs for the pods defined by label app=nginx\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot of previous terminated ruby container logs from pod " +#~ "web-1\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Display only the most recent 20 lines of output in pod nginx\n" +#~ "\t\tkubectl logs --tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Show all logs from pod nginx written in the last hour\n" +#~ "\t\tkubectl logs --since=1h nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from first container of a job named hello\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from container nginx-1 of a deployment named " +#~ "nginx\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Return snapshot logs from pod nginx with only one container\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs for the pods defined by label app=nginx\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot of previous terminated ruby container logs from pod " +#~ "web-1\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Display only the most recent 20 lines of output in pod nginx\n" +#~ "\t\tkubectl logs --tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Show all logs from pod nginx written in the last hour\n" +#~ "\t\tkubectl logs --since=1h nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from first container of a job named hello\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from container nginx-1 of a deployment named " +#~ "nginx\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on port 8011, serving static " +#~ "content from ./local/www/\n" +#~ "\t\tkubectl proxy --port=8011 --www=./local/www/\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on an arbitrary local port.\n" +#~ "\t\t# The chosen port for the server will be output to stdout.\n" +#~ "\t\tkubectl proxy --port=0\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver, changing the api prefix to k8s-" +#~ "api\n" +#~ "\t\t# This makes e.g. the pods api available at localhost:8001/k8s-api/v1/" +#~ "pods/\n" +#~ "\t\tkubectl proxy --api-prefix=/k8s-api" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on port 8011, serving static " +#~ "content from ./local/www/\n" +#~ "\t\tkubectl proxy --port=8011 --www=./local/www/\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on an arbitrary local port.\n" +#~ "\t\t# The chosen port for the server will be output to stdout.\n" +#~ "\t\tkubectl proxy --port=0\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver, changing the api prefix to k8s-" +#~ "api\n" +#~ "\t\t# This makes e.g. the pods api available at localhost:8001/k8s-api/v1/" +#~ "pods/\n" +#~ "\t\tkubectl proxy --api-prefix=/k8s-api" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Scale a replicaset named 'foo' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Scale a resource identified by type and name specified in \"foo.yaml" +#~ "\" to 3.\n" +#~ "\t\tkubectl scale --replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# If the deployment named mysql's current size is 2, scale mysql to " +#~ "3.\n" +#~ "\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Scale multiple replication controllers.\n" +#~ "\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Scale job named 'cron' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 job/cron" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Scale a replicaset named 'foo' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Scale a resource identified by type and name specified in \"foo.yaml" +#~ "\" to 3.\n" +#~ "\t\tkubectl scale --replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# If the deployment named mysql's current size is 2, scale mysql to " +#~ "3.\n" +#~ "\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Scale multiple replication controllers.\n" +#~ "\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Scale job named 'cron' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 job/cron" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Execute set-last-applied against each configuration file in a " +#~ "directory.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file, will create the annotation if it does not already " +#~ "exist.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml --create-" +#~ "annotation=true\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Execute set-last-applied against each configuration file in a " +#~ "directory.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file, will create the annotation if it does not already " +#~ "exist.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml --create-" +#~ "annotation=true\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Shut down foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Stop pods and services with label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Shut down the service defined in service.json\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Shut down all resources in the path/to/resources directory\n" +#~ "\t\tkubectl stop -f path/to/resources" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Shut down foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Stop pods and services with label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Shut down the service defined in service.json\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Shut down all resources in the path/to/resources directory\n" +#~ "\t\tkubectl stop -f path/to/resources" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Start a single instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and let the container expose " +#~ "port 5701 .\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --port=5701\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and set environment variables " +#~ "\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --env=\"DNS_DOMAIN=cluster\" " +#~ "--env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Start a replicated instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx --replicas=5\n" +#~ "\n" +#~ "\t\t# Dry run. Print the corresponding API objects without creating " +#~ "them.\n" +#~ "\t\tkubectl run nginx --image=nginx --dry-run\n" +#~ "\n" +#~ "\t\t# Start a single instance of nginx, but overload the spec of the " +#~ "deployment with a partial set of values parsed from JSON.\n" +#~ "\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": " +#~ "\"v1\", \"spec\": { ... } }'\n" +#~ "\n" +#~ "\t\t# Start a pod of busybox and keep it in the foreground, don't restart " +#~ "it if it exits.\n" +#~ "\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +#~ "\n" +#~ "\t\t# Start the nginx container using the default command, but use custom " +#~ "arguments (arg1 .. argN) for that command.\n" +#~ "\t\tkubectl run nginx --image=nginx -- ... \n" +#~ "\n" +#~ "\t\t# Start the nginx container using a different command and custom " +#~ "arguments.\n" +#~ "\t\tkubectl run nginx --image=nginx --command -- ... \n" +#~ "\n" +#~ "\t\t# Start the perl container to compute π to 2000 places and print it " +#~ "out.\n" +#~ "\t\tkubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Start the cron job to compute π to 2000 places and print it out " +#~ "every 5 minutes.\n" +#~ "\t\tkubectl run pi --schedule=\"0/5 * * * ?\" --image=perl --" +#~ "restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Start a single instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and let the container expose " +#~ "port 5701 .\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --port=5701\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and set environment variables " +#~ "\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --env=\"DNS_DOMAIN=cluster\" " +#~ "--env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Start a replicated instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx --replicas=5\n" +#~ "\n" +#~ "\t\t# Dry run. Print the corresponding API objects without creating " +#~ "them.\n" +#~ "\t\tkubectl run nginx --image=nginx --dry-run\n" +#~ "\n" +#~ "\t\t# Start a single instance of nginx, but overload the spec of the " +#~ "deployment with a partial set of values parsed from JSON.\n" +#~ "\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": " +#~ "\"v1\", \"spec\": { ... } }'\n" +#~ "\n" +#~ "\t\t# Start a pod of busybox and keep it in the foreground, don't restart " +#~ "it if it exits.\n" +#~ "\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +#~ "\n" +#~ "\t\t# Start the nginx container using the default command, but use custom " +#~ "arguments (arg1 .. argN) for that command.\n" +#~ "\t\tkubectl run nginx --image=nginx -- ... \n" +#~ "\n" +#~ "\t\t# Start the nginx container using a different command and custom " +#~ "arguments.\n" +#~ "\t\tkubectl run nginx --image=nginx --command -- ... \n" +#~ "\n" +#~ "\t\t# Start the perl container to compute π to 2000 places and print it " +#~ "out.\n" +#~ "\t\tkubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Start the cron job to compute π to 2000 places and print it out " +#~ "every 5 minutes.\n" +#~ "\t\tkubectl run pi --schedule=\"0/5 * * * ?\" --image=perl --" +#~ "restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update node 'foo' with a taint with key 'dedicated' and value " +#~ "'special-user' and effect 'NoSchedule'.\n" +#~ "\t\t# If a taint with that key and effect already exists, its value is " +#~ "replaced as specified.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +#~ "'NoSchedule' if one exists.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Update node 'foo' with a taint with key 'dedicated' and value " +#~ "'special-user' and effect 'NoSchedule'.\n" +#~ "\t\t# If a taint with that key and effect already exists, its value is " +#~ "replaced as specified.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +#~ "'NoSchedule' if one exists.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +#~ "overwriting any existing value.\n" +#~ "\t\tkubectl label --overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update all pods in the namespace\n" +#~ "\t\tkubectl label pods --all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ "\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' by removing a label named 'bar' if it exists.\n" +#~ "\t\t# Does not require the --overwrite flag.\n" +#~ "\t\tkubectl label pods foo bar-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +#~ "overwriting any existing value.\n" +#~ "\t\tkubectl label --overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update all pods in the namespace\n" +#~ "\t\tkubectl label pods --all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ "\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' by removing a label named 'bar' if it exists.\n" +#~ "\t\t# Does not require the --overwrite flag.\n" +#~ "\t\tkubectl label pods foo bar-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using new replication controller data in " +#~ "frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using JSON data passed into stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend-v1 to frontend-v2 by just changing the " +#~ "image, and switching the\n" +#~ "\t\t# name of the replication controller.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend by just changing the image, and keeping " +#~ "the old name.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Abort and reverse an existing rollout in progress (from frontend-v1 " +#~ "to frontend-v2).\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using new replication controller data in " +#~ "frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using JSON data passed into stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend-v1 to frontend-v2 by just changing the " +#~ "image, and switching the\n" +#~ "\t\t# name of the replication controller.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend by just changing the image, and keeping " +#~ "the old name.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Abort and reverse an existing rollout in progress (from frontend-v1 " +#~ "to frontend-v2).\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" + +#~ msgid "" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by type/name in " +#~ "YAML.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by file in JSON\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by type/name in " +#~ "YAML.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by file in JSON\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" + +#~ msgid "" +#~ "\n" +#~ "\t\tApply a configuration to a resource by filename or stdin.\n" +#~ "\t\tThis resource will be created if it doesn't exist yet.\n" +#~ "\t\tTo use 'apply', always create the resource initially with either " +#~ "'apply' or 'create --save-config'.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do " +#~ "not use unless you are aware of what the current state is. See https://" +#~ "issues.k8s.io/34274." +#~ msgstr "" +#~ "\n" +#~ "\t\tApply a configuration to a resource by filename or stdin.\n" +#~ "\t\tThis resource will be created if it doesn't exist yet.\n" +#~ "\t\tTo use 'apply', always create the resource initially with either " +#~ "'apply' or 'create --save-config'.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do " +#~ "not use unless you are aware of what the current state is. See https://" +#~ "issues.k8s.io/34274." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L68 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a ClusterRole." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_clusterrolebinding.go#L43 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRoleBinding for a particular ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a ClusterRoleBinding for a particular ClusterRole." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L43 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a RoleBinding for a particular Role or ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a RoleBinding for a particular Role or ClusterRole." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a TLS secret from the given public/private key pair.\n" +#~ "\n" +#~ "\t\tThe public/private key pair must exist before hand. The public key " +#~ "certificate must be .PEM encoded and match the given private key." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a TLS secret from the given public/private key pair.\n" +#~ "\n" +#~ "\t\tThe public/private key pair must exist before hand. The public key " +#~ "certificate must be .PEM encoded and match the given private key." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a configmap based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single configmap may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a file, the key will default to " +#~ "the basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a directory, each file whose " +#~ "basename is a valid key in the directory will be\n" +#~ "\t\tpackaged into the configmap. Any directory entries except regular " +#~ "files are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a configmap based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single configmap may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a file, the key will default to " +#~ "the basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a directory, each file whose " +#~ "basename is a valid key in the directory will be\n" +#~ "\t\tpackaged into the configmap. Any directory entries except regular " +#~ "files are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a new secret for use with Docker registries.\n" +#~ "\n" +#~ "\t\tDockercfg secrets are used to authenticate against Docker " +#~ "registries.\n" +#~ "\n" +#~ "\t\tWhen using the Docker command line to push images, you can " +#~ "authenticate to a given registry by running\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +#~ "password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " That produces a ~/.dockercfg file that is used by subsequent 'docker " +#~ "push' and 'docker pull' commands to\n" +#~ "\t\tauthenticate to the registry. The email address is optional.\n" +#~ "\n" +#~ "\t\tWhen creating applications, you may have a Docker registry that " +#~ "requires authentication. In order for the\n" +#~ "\t\tnodes to pull images on your behalf, they have to have the " +#~ "credentials. You can provide this information\n" +#~ "\t\tby creating a dockercfg secret and attaching it to your service " +#~ "account." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a new secret for use with Docker registries.\n" +#~ "\n" +#~ "\t\tDockercfg secrets are used to authenticate against Docker " +#~ "registries.\n" +#~ "\n" +#~ "\t\tWhen using the Docker command line to push images, you can " +#~ "authenticate to a given registry by running\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +#~ "password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " That produces a ~/.dockercfg file that is used by subsequent 'docker " +#~ "push' and 'docker pull' commands to\n" +#~ "\t\tauthenticate to the registry. The email address is optional.\n" +#~ "\n" +#~ "\t\tWhen creating applications, you may have a Docker registry that " +#~ "requires authentication. In order for the\n" +#~ "\t\tnodes to pull images on your behalf, they have to have the " +#~ "credentials. You can provide this information\n" +#~ "\t\tby creating a dockercfg secret and attaching it to your service " +#~ "account." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L49 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a pod disruption budget with the specified name, selector, and " +#~ "desired minimum available pods" +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a pod disruption budget with the specified name, selector, and " +#~ "desired minimum available pods" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create.go#L56 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L47 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resourcequota with the specified name, hard limits and " +#~ "optional scopes" +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a resourcequota with the specified name, hard limits and " +#~ "optional scopes" + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a secret based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single secret may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a file, the key will default to the " +#~ "basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a directory, each file whose basename " +#~ "is a valid key in the directory will be\n" +#~ "\t\tpackaged into the secret. Any directory entries except regular files " +#~ "are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a secret based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single secret may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a file, the key will default to the " +#~ "basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a directory, each file whose basename " +#~ "is a valid key in the directory will be\n" +#~ "\t\tpackaged into the secret. Any directory entries except regular files " +#~ "are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate and run a particular image, possibly replicated.\n" +#~ "\n" +#~ "\t\tCreates a deployment or job to manage the created container(s)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate and run a particular image, possibly replicated.\n" +#~ "\n" +#~ "\t\tCreates a deployment or job to manage the created container(s)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreates an autoscaler that automatically chooses and sets the number " +#~ "of pods that run in a kubernetes cluster.\n" +#~ "\n" +#~ "\t\tLooks up a Deployment, ReplicaSet, or ReplicationController by name " +#~ "and creates an autoscaler that uses the given resource as a reference.\n" +#~ "\t\tAn autoscaler can automatically increase or decrease number of pods " +#~ "deployed within the system as needed." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreates an autoscaler that automatically chooses and sets the number " +#~ "of pods that run in a kubernetes cluster.\n" +#~ "\n" +#~ "\t\tLooks up a Deployment, ReplicaSet, or ReplicationController by name " +#~ "and creates an autoscaler that uses the given resource as a reference.\n" +#~ "\t\tAn autoscaler can automatically increase or decrease number of pods " +#~ "deployed within the system as needed." + +#~ msgid "" +#~ "\n" +#~ "\t\tDelete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. Only one type of the arguments " +#~ "may be specified: filenames,\n" +#~ "\t\tresources and names, or resources and label selector.\n" +#~ "\n" +#~ "\t\tSome resources, such as pods, support graceful deletion. These " +#~ "resources define a default period\n" +#~ "\t\tbefore they are forcibly terminated (the grace period) but you may " +#~ "override that value with\n" +#~ "\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +#~ "Because these resources often\n" +#~ "\t\trepresent entities in the cluster, deletion may not be acknowledged " +#~ "immediately. If the node\n" +#~ "\t\thosting a pod is down or cannot reach the API server, termination may " +#~ "take significantly longer\n" +#~ "\t\tthan the grace period. To force delete a resource,\tyou must pass a " +#~ "grace\tperiod of 0 and specify\n" +#~ "\t\tthe --force flag.\n" +#~ "\n" +#~ "\t\tIMPORTANT: Force deleting pods does not wait for confirmation that " +#~ "the pod's processes have been\n" +#~ "\t\tterminated, which can leave those processes running until the node " +#~ "detects the deletion and\n" +#~ "\t\tcompletes graceful deletion. If your processes use shared storage or " +#~ "talk to a remote API and\n" +#~ "\t\tdepend on the name of the pod to identify themselves, force deleting " +#~ "those pods may result in\n" +#~ "\t\tmultiple processes running on different machines using the same " +#~ "identification which may lead\n" +#~ "\t\tto data corruption or inconsistency. Only force delete pods when you " +#~ "are sure the pod is\n" +#~ "\t\tterminated, or if your application can tolerate multiple copies of " +#~ "the same pod running at once.\n" +#~ "\t\tAlso, if you force delete pods the scheduler may place new pods on " +#~ "those nodes before the node\n" +#~ "\t\thas released those resources and causing those pods to be evicted " +#~ "immediately.\n" +#~ "\n" +#~ "\t\tNote that the delete command does NOT do resource version checks, so " +#~ "if someone\n" +#~ "\t\tsubmits an update to a resource right when you submit a delete, their " +#~ "update\n" +#~ "\t\twill be lost along with the rest of the resource." +#~ msgstr "" +#~ "\n" +#~ "\t\tDelete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. Only one type of the arguments " +#~ "may be specified: filenames,\n" +#~ "\t\tresources and names, or resources and label selector.\n" +#~ "\n" +#~ "\t\tSome resources, such as pods, support graceful deletion. These " +#~ "resources define a default period\n" +#~ "\t\tbefore they are forcibly terminated (the grace period) but you may " +#~ "override that value with\n" +#~ "\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +#~ "Because these resources often\n" +#~ "\t\trepresent entities in the cluster, deletion may not be acknowledged " +#~ "immediately. If the node\n" +#~ "\t\thosting a pod is down or cannot reach the API server, termination may " +#~ "take significantly longer\n" +#~ "\t\tthan the grace period. To force delete a resource,\tyou must pass a " +#~ "grace\tperiod of 0 and specify\n" +#~ "\t\tthe --force flag.\n" +#~ "\n" +#~ "\t\tIMPORTANT: Force deleting pods does not wait for confirmation that " +#~ "the pod's processes have been\n" +#~ "\t\tterminated, which can leave those processes running until the node " +#~ "detects the deletion and\n" +#~ "\t\tcompletes graceful deletion. If your processes use shared storage or " +#~ "talk to a remote API and\n" +#~ "\t\tdepend on the name of the pod to identify themselves, force deleting " +#~ "those pods may result in\n" +#~ "\t\tmultiple processes running on different machines using the same " +#~ "identification which may lead\n" +#~ "\t\tto data corruption or inconsistency. Only force delete pods when you " +#~ "are sure the pod is\n" +#~ "\t\tterminated, or if your application can tolerate multiple copies of " +#~ "the same pod running at once.\n" +#~ "\t\tAlso, if you force delete pods the scheduler may place new pods on " +#~ "those nodes before the node\n" +#~ "\t\thas released those resources and causing those pods to be evicted " +#~ "immediately.\n" +#~ "\n" +#~ "\t\tNote that the delete command does NOT do resource version checks, so " +#~ "if someone\n" +#~ "\t\tsubmits an update to a resource right when you submit a delete, their " +#~ "update\n" +#~ "\t\twill be lost along with the rest of the resource." + +#~ msgid "" +#~ "\n" +#~ "\t\tDeprecated: Gracefully shut down a resource by name or filename.\n" +#~ "\n" +#~ "\t\tThe stop command is deprecated, all its functionalities are covered " +#~ "by delete command.\n" +#~ "\t\tSee 'kubectl delete --help' for more details.\n" +#~ "\n" +#~ "\t\tAttempts to shut down and delete a resource that supports graceful " +#~ "termination.\n" +#~ "\t\tIf the resource is scalable it will be scaled to 0 before deletion." +#~ msgstr "" +#~ "\n" +#~ "\t\tDeprecated: Gracefully shut down a resource by name or filename.\n" +#~ "\n" +#~ "\t\tThe stop command is deprecated, all its functionalities are covered " +#~ "by delete command.\n" +#~ "\t\tSee 'kubectl delete --help' for more details.\n" +#~ "\n" +#~ "\t\tAttempts to shut down and delete a resource that supports graceful " +#~ "termination.\n" +#~ "\t\tIf the resource is scalable it will be scaled to 0 before deletion." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of nodes.\n" +#~ "\n" +#~ "\t\tThe top-node command allows you to see the resource consumption of " +#~ "nodes." +#~ msgstr "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of nodes.\n" +#~ "\n" +#~ "\t\tThe top-node command allows you to see the resource consumption of " +#~ "nodes." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of pods.\n" +#~ "\n" +#~ "\t\tThe 'top pod' command allows you to see the resource consumption of " +#~ "pods.\n" +#~ "\n" +#~ "\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +#~ "minutes\n" +#~ "\t\tsince pod creation." +#~ msgstr "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of pods.\n" +#~ "\n" +#~ "\t\tThe 'top pod' command allows you to see the resource consumption of " +#~ "pods.\n" +#~ "\n" +#~ "\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +#~ "minutes\n" +#~ "\t\tsince pod creation." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage.\n" +#~ "\n" +#~ "\t\tThe top command allows you to see the resource consumption for nodes " +#~ "or pods.\n" +#~ "\n" +#~ "\t\tThis command requires Heapster to be correctly configured and working " +#~ "on the server. " +#~ msgstr "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage.\n" +#~ "\n" +#~ "\t\tThe top command allows you to see the resource consumption for nodes " +#~ "or pods.\n" +#~ "\n" +#~ "\t\tThis command requires Heapster to be correctly configured and working " +#~ "on the server. " + +#~ msgid "" +#~ "\n" +#~ "\t\tDrain node in preparation for maintenance.\n" +#~ "\n" +#~ "\t\tThe given node will be marked unschedulable to prevent new pods from " +#~ "arriving.\n" +#~ "\t\t'drain' evicts the pods if the APIServer supports eviction\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Otherwise, it will " +#~ "use normal DELETE\n" +#~ "\t\tto delete the pods.\n" +#~ "\t\tThe 'drain' evicts or deletes all pods except mirror pods (which " +#~ "cannot be deleted through\n" +#~ "\t\tthe API server). If there are DaemonSet-managed pods, drain will not " +#~ "proceed\n" +#~ "\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +#~ "\t\tDaemonSet-managed pods, because those pods would be immediately " +#~ "replaced by the\n" +#~ "\t\tDaemonSet controller, which ignores unschedulable markings. If there " +#~ "are any\n" +#~ "\t\tpods that are neither mirror pods nor managed by " +#~ "ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet or Job, then drain will not delete " +#~ "any pods unless you\n" +#~ "\t\tuse --force. --force will also allow deletion to proceed if the " +#~ "managing resource of one\n" +#~ "\t\tor more pods is missing.\n" +#~ "\n" +#~ "\t\t'drain' waits for graceful termination. You should not operate on the " +#~ "machine until\n" +#~ "\t\tthe command completes.\n" +#~ "\n" +#~ "\t\tWhen you are ready to put the node back into service, use kubectl " +#~ "uncordon, which\n" +#~ "\t\twill make the node schedulable again.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\tDrain node in preparation for maintenance.\n" +#~ "\n" +#~ "\t\tThe given node will be marked unschedulable to prevent new pods from " +#~ "arriving.\n" +#~ "\t\t'drain' evicts the pods if the APIServer supports eviction\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Otherwise, it will " +#~ "use normal DELETE\n" +#~ "\t\tto delete the pods.\n" +#~ "\t\tThe 'drain' evicts or deletes all pods except mirror pods (which " +#~ "cannot be deleted through\n" +#~ "\t\tthe API server). If there are DaemonSet-managed pods, drain will not " +#~ "proceed\n" +#~ "\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +#~ "\t\tDaemonSet-managed pods, because those pods would be immediately " +#~ "replaced by the\n" +#~ "\t\tDaemonSet controller, which ignores unschedulable markings. If there " +#~ "are any\n" +#~ "\t\tpods that are neither mirror pods nor managed by " +#~ "ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet or Job, then drain will not delete " +#~ "any pods unless you\n" +#~ "\t\tuse --force. --force will also allow deletion to proceed if the " +#~ "managing resource of one\n" +#~ "\t\tor more pods is missing.\n" +#~ "\n" +#~ "\t\t'drain' waits for graceful termination. You should not operate on the " +#~ "machine until\n" +#~ "\t\tthe command completes.\n" +#~ "\n" +#~ "\t\tWhen you are ready to put the node back into service, use kubectl " +#~ "uncordon, which\n" +#~ "\t\twill make the node schedulable again.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tEdit a resource from the default editor.\n" +#~ "\n" +#~ "\t\tThe edit command allows you to directly edit any API resource you can " +#~ "retrieve via the\n" +#~ "\t\tcommand line tools. It will open the editor defined by your " +#~ "KUBE_EDITOR, or EDITOR\n" +#~ "\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' " +#~ "for Windows.\n" +#~ "\t\tYou can edit multiple objects, although changes are applied one at a " +#~ "time. The command\n" +#~ "\t\taccepts filenames as well as command line arguments, although the " +#~ "files you point to must\n" +#~ "\t\tbe previously saved versions of resources.\n" +#~ "\n" +#~ "\t\tEditing is done with the API version used to fetch the resource.\n" +#~ "\t\tTo edit using a specific API version, fully-qualify the resource, " +#~ "version, and group.\n" +#~ "\n" +#~ "\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +#~ "\n" +#~ "\t\tThe flag --windows-line-endings can be used to force Windows line " +#~ "endings,\n" +#~ "\t\totherwise the default for your operating system will be used.\n" +#~ "\n" +#~ "\t\tIn the event an error occurs while updating, a temporary file will be " +#~ "created on disk\n" +#~ "\t\tthat contains your unapplied changes. The most common error when " +#~ "updating a resource\n" +#~ "\t\tis another editor changing the resource on the server. When this " +#~ "occurs, you will have\n" +#~ "\t\tto apply your changes to the newer version of the resource, or update " +#~ "your temporary\n" +#~ "\t\tsaved copy to include the latest resource version." +#~ msgstr "" +#~ "\n" +#~ "\t\tEdit a resource from the default editor.\n" +#~ "\n" +#~ "\t\tThe edit command allows you to directly edit any API resource you can " +#~ "retrieve via the\n" +#~ "\t\tcommand line tools. It will open the editor defined by your " +#~ "KUBE_EDITOR, or EDITOR\n" +#~ "\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' " +#~ "for Windows.\n" +#~ "\t\tYou can edit multiple objects, although changes are applied one at a " +#~ "time. The command\n" +#~ "\t\taccepts filenames as well as command line arguments, although the " +#~ "files you point to must\n" +#~ "\t\tbe previously saved versions of resources.\n" +#~ "\n" +#~ "\t\tEditing is done with the API version used to fetch the resource.\n" +#~ "\t\tTo edit using a specific API version, fully-qualify the resource, " +#~ "version, and group.\n" +#~ "\n" +#~ "\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +#~ "\n" +#~ "\t\tThe flag --windows-line-endings can be used to force Windows line " +#~ "endings,\n" +#~ "\t\totherwise the default for your operating system will be used.\n" +#~ "\n" +#~ "\t\tIn the event an error occurs while updating, a temporary file will be " +#~ "created on disk\n" +#~ "\t\tthat contains your unapplied changes. The most common error when " +#~ "updating a resource\n" +#~ "\t\tis another editor changing the resource on the server. When this " +#~ "occurs, you will have\n" +#~ "\t\tto apply your changes to the newer version of the resource, or update " +#~ "your temporary\n" +#~ "\t\tsaved copy to include the latest resource version." + +#~ msgid "" +#~ "\n" +#~ "\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +#~ "\t\tThe shell code must be evaluated to provide interactive\n" +#~ "\t\tcompletion of kubectl commands. This can be done by sourcing it " +#~ "from\n" +#~ "\t\tthe .bash_profile.\n" +#~ "\n" +#~ "\t\tNote: this requires the bash-completion framework, which is not " +#~ "installed\n" +#~ "\t\tby default on Mac. This can be installed by using homebrew:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tOnce installed, bash_completion must be evaluated. This can be done " +#~ "by adding the\n" +#~ "\t\tfollowing line to the .bash_profile\n" +#~ "\n" +#~ "\t\t $ source $(brew --prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tNote for zsh users: [1] zsh completions are only supported in " +#~ "versions of zsh >= 5.2" +#~ msgstr "" +#~ "\n" +#~ "\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +#~ "\t\tThe shell code must be evaluated to provide interactive\n" +#~ "\t\tcompletion of kubectl commands. This can be done by sourcing it " +#~ "from\n" +#~ "\t\tthe .bash_profile.\n" +#~ "\n" +#~ "\t\tNote: this requires the bash-completion framework, which is not " +#~ "installed\n" +#~ "\t\tby default on Mac. This can be installed by using homebrew:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tOnce installed, bash_completion must be evaluated. This can be done " +#~ "by adding the\n" +#~ "\t\tfollowing line to the .bash_profile\n" +#~ "\n" +#~ "\t\t $ source $(brew --prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tNote for zsh users: [1] zsh completions are only supported in " +#~ "versions of zsh >= 5.2" + +#~ msgid "" +#~ "\n" +#~ "\t\tPerform a rolling update of the given ReplicationController.\n" +#~ "\n" +#~ "\t\tReplaces the specified replication controller with a new replication " +#~ "controller by updating one pod at a time to use the\n" +#~ "\t\tnew PodTemplate. The new-controller.json must specify the same " +#~ "namespace as the\n" +#~ "\t\texisting replication controller and overwrite at least one (common) " +#~ "label in its replicaSelector.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\tPerform a rolling update of the given ReplicationController.\n" +#~ "\n" +#~ "\t\tReplaces the specified replication controller with a new replication " +#~ "controller by updating one pod at a time to use the\n" +#~ "\t\tnew PodTemplate. The new-controller.json must specify the same " +#~ "namespace as the\n" +#~ "\t\texisting replication controller and overwrite at least one (common) " +#~ "label in its replicaSelector.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tReplace a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. If replacing an existing " +#~ "resource, the\n" +#~ "\t\tcomplete resource spec must be provided. This can be obtained by\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." +#~ msgstr "" +#~ "\n" +#~ "\t\tReplace a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. If replacing an existing " +#~ "resource, the\n" +#~ "\t\tcomplete resource spec must be provided. This can be obtained by\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." + +#~ msgid "" +#~ "\n" +#~ "\t\tSet a new size for a Deployment, ReplicaSet, Replication Controller, " +#~ "or Job.\n" +#~ "\n" +#~ "\t\tScale also allows users to specify one or more preconditions for the " +#~ "scale action.\n" +#~ "\n" +#~ "\t\tIf --current-replicas or --resource-version is specified, it is " +#~ "validated before the\n" +#~ "\t\tscale is attempted, and it is guaranteed that the precondition holds " +#~ "true when the\n" +#~ "\t\tscale is sent to the server." +#~ msgstr "" +#~ "\n" +#~ "\t\tSet a new size for a Deployment, ReplicaSet, Replication Controller, " +#~ "or Job.\n" +#~ "\n" +#~ "\t\tScale also allows users to specify one or more preconditions for the " +#~ "scale action.\n" +#~ "\n" +#~ "\t\tIf --current-replicas or --resource-version is specified, it is " +#~ "validated before the\n" +#~ "\t\tscale is attempted, and it is guaranteed that the precondition holds " +#~ "true when the\n" +#~ "\t\tscale is sent to the server." + +#~ msgid "" +#~ "\n" +#~ "\t\tTo proxy all of the kubernetes api and nothing else, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/\n" +#~ "\n" +#~ "\t\tTo proxy only part of the kubernetes api and also some static files:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-" +#~ "prefix=/api/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/api/v1/pods'.\n" +#~ "\n" +#~ "\t\tTo proxy the entire kubernetes api at a different root, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/custom/api/v1/pods'" +#~ msgstr "" +#~ "\n" +#~ "\t\tTo proxy all of the kubernetes api and nothing else, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/\n" +#~ "\n" +#~ "\t\tTo proxy only part of the kubernetes api and also some static files:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-" +#~ "prefix=/api/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/api/v1/pods'.\n" +#~ "\n" +#~ "\t\tTo proxy the entire kubernetes api at a different root, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/custom/api/v1/pods'" + +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate field(s) of a resource using strategic merge patch\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." +#~ msgstr "" +#~ "\n" +#~ "\t\tUpdate field(s) of a resource using strategic merge patch\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate the labels on a resource.\n" +#~ "\n" +#~ "\t\t* A label must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* If --overwrite is true, then existing labels can be overwritten, " +#~ "otherwise attempting to overwrite a label will result in an error.\n" +#~ "\t\t* If --resource-version is specified, then updates will use this " +#~ "resource version, otherwise the existing resource-version will be used." +#~ msgstr "" +#~ "\n" +#~ "\t\tUpdate the labels on a resource.\n" +#~ "\n" +#~ "\t\t* A label must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* If --overwrite is true, then existing labels can be overwritten, " +#~ "otherwise attempting to overwrite a label will result in an error.\n" +#~ "\t\t* If --resource-version is specified, then updates will use this " +#~ "resource version, otherwise the existing resource-version will be used." + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate the taints on one or more nodes.\n" +#~ "\n" +#~ "\t\t* A taint consists of a key, value, and effect. As an argument here, " +#~ "it is expressed as key=value:effect.\n" +#~ "\t\t* The key must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* The value must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[2]d " +#~ "characters.\n" +#~ "\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +#~ "\t\t* Currently taint can only apply to node." +#~ msgstr "" +#~ "\n" +#~ "\t\tUpdate the taints on one or more nodes.\n" +#~ "\n" +#~ "\t\t* A taint consists of a key, value, and effect. As an argument here, " +#~ "it is expressed as key=value:effect.\n" +#~ "\t\t* The key must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* The value must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[2]d " +#~ "characters.\n" +#~ "\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +#~ "\t\t* Currently taint can only apply to node." + +#~ msgid "" +#~ "\n" +#~ "\t\tView the latest last-applied-configuration annotations by type/name " +#~ "or file.\n" +#~ "\n" +#~ "\t\tThe default output will be printed to stdout in YAML format. One can " +#~ "use -o option\n" +#~ "\t\tto change output format." +#~ msgstr "" +#~ "\n" +#~ "\t\tView the latest last-applied-configuration annotations by type/name " +#~ "or file.\n" +#~ "\n" +#~ "\t\tThe default output will be printed to stdout in YAML format. One can " +#~ "use -o option\n" +#~ "\t\tto change output format." + +#~ msgid "" +#~ "\n" +#~ "\t # !!!Important Note!!!\n" +#~ "\t # Requires that the 'tar' binary is present in your container\n" +#~ "\t # image. If 'tar' is not present, 'kubectl cp' will fail.\n" +#~ "\n" +#~ "\t # Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod " +#~ "in the default namespace\n" +#~ "\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +#~ "\n" +#~ " # Copy /tmp/foo local file to /tmp/bar in a remote pod in a " +#~ "specific container\n" +#~ "\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +#~ "\n" +#~ "\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +#~ "\t\tkubectl cp /:/tmp/foo /tmp/bar" +#~ msgstr "" +#~ "\n" +#~ "\t # !!!Important Note!!!\n" +#~ "\t # Requires that the 'tar' binary is present in your container\n" +#~ "\t # image. If 'tar' is not present, 'kubectl cp' will fail.\n" +#~ "\n" +#~ "\t # Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod " +#~ "in the default namespace\n" +#~ "\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +#~ "\n" +#~ " # Copy /tmp/foo local file to /tmp/bar in a remote pod in a " +#~ "specific container\n" +#~ "\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +#~ "\n" +#~ "\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +#~ "\t\tkubectl cp /:/tmp/foo /tmp/bar" + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new TLS secret named tls-secret with the given key pair:\n" +#~ "\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --" +#~ "key=path/to/tls.key" +#~ msgstr "" +#~ "\n" +#~ "\t # Create a new TLS secret named tls-secret with the given key pair:\n" +#~ "\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --" +#~ "key=path/to/tls.key" + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new secret named my-secret with keys for each file in " +#~ "folder bar\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with specified keys instead of " +#~ "names on disk\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with key1=supersecret and " +#~ "key2=topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" +#~ msgstr "" +#~ "\n" +#~ "\t # Create a new secret named my-secret with keys for each file in " +#~ "folder bar\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with specified keys instead of " +#~ "names on disk\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with key1=supersecret and " +#~ "key2=topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" + +#~ msgid "" +#~ "\n" +#~ "\t# Create a new ExternalName service named my-ns \n" +#~ "\tkubectl create service externalname my-ns --external-name bar.com" +#~ msgstr "" +#~ "\n" +#~ "\t# Create a new ExternalName service named my-ns \n" +#~ "\tkubectl create service externalname my-ns --external-name bar.com" + +#~ msgid "" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs (in headless mode)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" +#~ msgstr "" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs (in headless mode)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" + +#~ msgid "" +#~ "\n" +#~ " # Create a new deployment named my-dep that runs the busybox image.\n" +#~ " kubectl create deployment my-dep --image=busybox" +#~ msgstr "" +#~ "\n" +#~ " # Create a new deployment named my-dep that runs the busybox image.\n" +#~ " kubectl create deployment my-dep --image=busybox" + +#~ msgid "" +#~ "\n" +#~ " # Create a new nodeport service named my-ns\n" +#~ " kubectl create service nodeport my-ns --tcp=5678:8080" +#~ msgstr "" +#~ "\n" +#~ " # Create a new nodeport service named my-ns\n" +#~ " kubectl create service nodeport my-ns --tcp=5678:8080" + +#~ msgid "" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend'.\n" +#~ " # If the same annotation is set multiple times, only the last value " +#~ "will be applied\n" +#~ " kubectl annotate pods foo description='my frontend'\n" +#~ "\n" +#~ " # Update a pod identified by type and name in \"pod.json\"\n" +#~ " kubectl annotate -f pod.json description='my frontend'\n" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend running nginx', overwriting any existing value.\n" +#~ " kubectl annotate --overwrite pods foo description='my frontend " +#~ "running nginx'\n" +#~ "\n" +#~ " # Update all pods in the namespace\n" +#~ " kubectl annotate pods --all description='my frontend running nginx'\n" +#~ "\n" +#~ " # Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ " kubectl annotate pods foo description='my frontend running nginx' --" +#~ "resource-version=1\n" +#~ "\n" +#~ " # Update pod 'foo' by removing an annotation named 'description' if " +#~ "it exists.\n" +#~ " # Does not require the --overwrite flag.\n" +#~ " kubectl annotate pods foo description-" +#~ msgstr "" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend'.\n" +#~ " # If the same annotation is set multiple times, only the last value " +#~ "will be applied\n" +#~ " kubectl annotate pods foo description='my frontend'\n" +#~ "\n" +#~ " # Update a pod identified by type and name in \"pod.json\"\n" +#~ " kubectl annotate -f pod.json description='my frontend'\n" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend running nginx', overwriting any existing value.\n" +#~ " kubectl annotate --overwrite pods foo description='my frontend " +#~ "running nginx'\n" +#~ "\n" +#~ " # Update all pods in the namespace\n" +#~ " kubectl annotate pods --all description='my frontend running nginx'\n" +#~ "\n" +#~ " # Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ " kubectl annotate pods foo description='my frontend running nginx' --" +#~ "resource-version=1\n" +#~ "\n" +#~ " # Update pod 'foo' by removing an annotation named 'description' if " +#~ "it exists.\n" +#~ " # Does not require the --overwrite flag.\n" +#~ " kubectl annotate pods foo description-" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#~ msgid "" +#~ "\n" +#~ " Create a clusterIP service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Create a clusterIP service with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_deployment.go#L44 +#~ msgid "" +#~ "\n" +#~ " Create a deployment with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Create a deployment with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_deployment.go#L44 +#~ msgid "" +#~ "\n" +#~ " Create a nodeport service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Create a nodeport service with the specified name." + +#~ msgid "" +#~ "\n" +#~ " Dumps cluster info out suitable for debugging and diagnosing cluster " +#~ "problems. By default, dumps everything to\n" +#~ " stdout. You can optionally specify a directory with --output-" +#~ "directory. If you specify a directory, kubernetes will\n" +#~ " build a set of files in that directory. By default only dumps things " +#~ "in the 'kube-system' namespace, but you can\n" +#~ " switch to a different namespace with the --namespaces flag, or " +#~ "specify --all-namespaces to dump all namespaces.\n" +#~ "\n" +#~ " The command also dumps the logs of all of the pods in the cluster, " +#~ "these logs are dumped into different directories\n" +#~ " based on namespace and pod name." +#~ msgstr "" +#~ "\n" +#~ " Dumps cluster info out suitable for debugging and diagnosing cluster " +#~ "problems. By default, dumps everything to\n" +#~ " stdout. You can optionally specify a directory with --output-" +#~ "directory. If you specify a directory, kubernetes will\n" +#~ " build a set of files in that directory. By default only dumps things " +#~ "in the 'kube-system' namespace, but you can\n" +#~ " switch to a different namespace with the --namespaces flag, or " +#~ "specify --all-namespaces to dump all namespaces.\n" +#~ "\n" +#~ " The command also dumps the logs of all of the pods in the cluster, " +#~ "these logs are dumped into different directories\n" +#~ " based on namespace and pod name." + +#~ msgid "" +#~ "\n" +#~ " Display addresses of the master and services with label kubernetes.io/" +#~ "cluster-service=true\n" +#~ " To further debug and diagnose cluster problems, use 'kubectl cluster-" +#~ "info dump'." +#~ msgstr "" +#~ "\n" +#~ " Display addresses of the master and services with label kubernetes.io/" +#~ "cluster-service=true\n" +#~ " To further debug and diagnose cluster problems, use 'kubectl cluster-" +#~ "info dump'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L136 +#~ msgid "A schedule in the Cron format the job should be run with." +#~ msgstr "A schedule in the Cron format the job should be run with." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L134 +#~ msgid "" +#~ "An inline JSON override for the generated service object. If this is non-" +#~ "empty, it is used to override the generated object. Requires that the " +#~ "object supply a valid apiVersion field. Only used if --expose is true." +#~ msgstr "" +#~ "An inline JSON override for the generated service object. If this is non-" +#~ "empty, it is used to override the generated object. Requires that the " +#~ "object supply a valid apiVersion field. Only used if --expose is true." + +#~ msgid "Apply a configuration to a resource by filename or stdin" +#~ msgstr "ファイル名または標準入力でリソースにコンフィグを適用する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/autoscale.go#L55 +#~ msgid "Auto-scale a Deployment, ReplicaSet, or ReplicationController" +#~ msgstr "Auto-scale a Deployment, ReplicaSet, or ReplicationController" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L101 +#~ msgid "" +#~ "Container name which will have its image upgraded. Only relevant when --" +#~ "image is specified, ignored otherwise. Required when using --image on a " +#~ "multi-container pod" +#~ msgstr "" +#~ "Container name which will have its image upgraded. Only relevant when --" +#~ "image is specified, ignored otherwise. Required when using --image on a " +#~ "multi-container pod" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_clusterrolebinding.go#L43 +#~ msgid "Create a ClusterRoleBinding for a particular ClusterRole" +#~ msgstr "Create a ClusterRoleBinding for a particular ClusterRole" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L181 +#~ msgid "Create a LoadBalancer service." +#~ msgstr "Create a LoadBalancer service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L124 +#~ msgid "Create a NodePort service." +#~ msgstr "Create a NodePort service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L43 +#~ msgid "Create a RoleBinding for a particular Role or ClusterRole" +#~ msgstr "Create a RoleBinding for a particular Role or ClusterRole" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L68 +#~ msgid "Create a clusterIP service." +#~ msgstr "Create a clusterIP service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_configmap.go#L59 +#~ msgid "Create a configmap from a local file, directory or literal value" +#~ msgstr "Create a configmap from a local file, directory or literal value" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_deployment.go#L44 +#~ msgid "Create a deployment with the specified name." +#~ msgstr "Create a deployment with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L49 +#~ msgid "Create a pod disruption budget with the specified name." +#~ msgstr "Create a pod disruption budget with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L47 +#~ msgid "Create a quota with the specified name." +#~ msgstr "Create a quota with the specified name." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create.go#L56 +#~ msgid "Create a resource by filename or stdin" +#~ msgstr "ファイル名または標準入力でリソースを作成する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L73 +#~ msgid "Create a secret from a local file, directory or literal value" +#~ msgstr "Create a secret from a local file, directory or literal value" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L36 +#~ msgid "Create a service using specified subcommand." +#~ msgstr "Create a service using specified subcommand." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L240 +#~ msgid "Create an ExternalName service." +#~ msgstr "Create an ExternalName service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/delete.go#L130 +#~ msgid "" +#~ "Delete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector" +#~ msgstr "" +#~ "Delete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/stop.go#L58 +#~ msgid "Deprecated: Gracefully shut down a resource by name or filename" +#~ msgstr "Deprecated: Gracefully shut down a resource by name or filename" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/top_node.go#L77 +#~ msgid "Display Resource (CPU/Memory) usage of nodes" +#~ msgstr "Display Resource (CPU/Memory) usage of nodes" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/top_pod.go#L79 +#~ msgid "Display Resource (CPU/Memory) usage of pods" +#~ msgstr "Display Resource (CPU/Memory) usage of pods" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/top.go#L43 +#~ msgid "Display Resource (CPU/Memory) usage." +#~ msgstr "Display Resource (CPU/Memory) usage." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/clusterinfo.go#L49 +#~ msgid "Display cluster info" +#~ msgstr "クラスターの情報を表示する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/current_context.go#L48 +#~ msgid "Displays the current-context" +#~ msgstr "current-contextを表示する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/explain.go#L50 +#~ msgid "Documentation of resources" +#~ msgstr "リソースの説明を表示する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/clusterinfo_dump.go#L37 +#~ msgid "Dump lots of relevant info for debugging and diagnosis" +#~ msgstr "Dump lots of relevant info for debugging and diagnosis" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L102 +#~ msgid "" +#~ "Explicit policy for when to pull container images. Required when --image " +#~ "is same as existing image, ignored otherwise." +#~ msgstr "" +#~ "Explicit policy for when to pull container images. Required when --image " +#~ "is same as existing image, ignored otherwise." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L105 +#~ msgid "" +#~ "IP to assign to the Load Balancer. If empty, an ephemeral IP will be " +#~ "created and used (cloud-provider specific)." +#~ msgstr "" +#~ "IP to assign to the Load Balancer. If empty, an ephemeral IP will be " +#~ "created and used (cloud-provider specific)." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L98 +#~ msgid "" +#~ "Image to use for upgrading the replication controller. Must be distinct " +#~ "from the existing image (either new image or new image tag). Can not be " +#~ "used with --filename/-f" +#~ msgstr "" +#~ "Image to use for upgrading the replication controller. Must be distinct " +#~ "from the existing image (either new image or new image tag). Can not be " +#~ "used with --filename/-f" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout.go#L46 +#~ msgid "Manage a deployment rollout" +#~ msgstr "Manage a deployment rollout" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/edit.go#L115 +#~ msgid "" +#~ "Output the formatted object with the given group version (for ex: " +#~ "'extensions/v1beta1').)" +#~ msgstr "" +#~ "Output the formatted object with the given group version (for ex: " +#~ "'extensions/v1beta1').)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L84 +#~ msgid "Perform a rolling update of the given ReplicationController" +#~ msgstr "Perform a rolling update of the given ReplicationController" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/replace.go#L70 +#~ msgid "Replace a resource by filename or stdin" +#~ msgstr "Replace a resource by filename or stdin" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/scale.go#L71 +#~ msgid "" +#~ "Set a new size for a Deployment, ReplicaSet, Replication Controller, or " +#~ "Job" +#~ msgstr "" +#~ "Set a new size for a Deployment, ReplicaSet, Replication Controller, or " +#~ "Job" + +#~ msgid "" +#~ "Set the last-applied-configuration annotation on a live object to match " +#~ "the contents of a file." +#~ msgstr "" +#~ "Set the last-applied-configuration annotation on a live object to match " +#~ "the contents of a file." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_cluster.go#L67 +#~ msgid "Sets a cluster entry in kubeconfig" +#~ msgstr "kubeconfigにクラスターエントリを設定する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_context.go#L57 +#~ msgid "Sets a context entry in kubeconfig" +#~ msgstr "kubeconfigにコンテキストエントリを設定する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_authinfo.go#L103 +#~ msgid "Sets a user entry in kubeconfig" +#~ msgstr "kubeconfigにユーザーエントリを設定する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/set.go#L59 +#~ msgid "Sets an individual value in a kubeconfig file" +#~ msgstr "kubeconfigに個別の変数を設定する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/use_context.go#L48 +#~ msgid "Sets the current-context in a kubeconfig file" +#~ msgstr "kubeconfigにcurrent-contextを設定する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L87 +#~ msgid "" +#~ "Take a replication controller, service, deployment or pod and expose it " +#~ "as a new Kubernetes Service" +#~ msgstr "" +#~ "Take a replication controller, service, deployment or pod and expose it " +#~ "as a new Kubernetes Service" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L100 +#~ msgid "" +#~ "The key to use to differentiate between two different controllers, " +#~ "default 'deployment'. Only relevant when --image is specified, ignored " +#~ "otherwise" +#~ msgstr "" +#~ "The key to use to differentiate between two different controllers, " +#~ "default 'deployment'. Only relevant when --image is specified, ignored " +#~ "otherwise" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L113 +#~ msgid "" +#~ "The name of the API generator to use, see http://kubernetes.io/docs/user-" +#~ "guide/kubectl-conventions/#generators for a list." +#~ msgstr "" +#~ "The name of the API generator to use, see http://kubernetes.io/docs/user-" +#~ "guide/kubectl-conventions/#generators for a list." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/autoscale.go#L66 +#~ msgid "" +#~ "The name of the API generator to use. Currently there is only 1 generator." +#~ msgstr "" +#~ "The name of the API generator to use. Currently there is only 1 generator." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L133 +#~ msgid "" +#~ "The name of the generator to use for creating a service. Only used if --" +#~ "expose is true" +#~ msgstr "" +#~ "The name of the generator to use for creating a service. Only used if --" +#~ "expose is true" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L121 +#~ msgid "" +#~ "The port that this container exposes. If --expose is true, this is also " +#~ "the port used by the service that is created." +#~ msgstr "" +#~ "The port that this container exposes. If --expose is true, this is also " +#~ "the port used by the service that is created." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L128 +#~ msgid "" +#~ "The restart policy for this Pod. Legal values [Always, OnFailure, " +#~ "Never]. If set to 'Always' a deployment is created, if set to " +#~ "'OnFailure' a job is created, if set to 'Never', a regular pod is " +#~ "created. For the latter two --replicas must be 1. Default 'Always', for " +#~ "CronJobs `Never`." +#~ msgstr "" +#~ "The restart policy for this Pod. Legal values [Always, OnFailure, " +#~ "Never]. If set to 'Always' a deployment is created, if set to " +#~ "'OnFailure' a job is created, if set to 'Never', a regular pod is " +#~ "created. For the latter two --replicas must be 1. Default 'Always', for " +#~ "CronJobs `Never`." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L101 +#~ msgid "" +#~ "Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is " +#~ "'ClusterIP'." +#~ msgstr "" +#~ "Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is " +#~ "'ClusterIP'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/unset.go#L47 +#~ msgid "Unsets an individual value in a kubeconfig file" +#~ msgstr "kubeconfigから変数を個別に削除する" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/patch.go#L91 +#~ msgid "Update field(s) of a resource using strategic merge patch" +#~ msgstr "Update field(s) of a resource using strategic merge patch" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_image.go#L94 +#~ msgid "Update image of a pod template" +#~ msgstr "Update image of a pod template" + +#~ msgid "" +#~ "View latest last-applied-configuration annotations of a resource/object" +#~ msgstr "" +#~ "View latest last-applied-configuration annotations of a resource/object" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L253 +#~ msgid "external name of service" +#~ msgstr "external name of service" + +#~ msgid "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgid_plural "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgstr[0] "" +#~ "watchは単一リソース及びリソースコレクションのみサポートしています- %d個の" +#~ "リソースが見つかりました" +#~ msgstr[1] "" +#~ "watchは単一リソース及びリソースコレクションのみサポートしています- %d個の" +#~ "リソースが見つかりました" diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ko_KR/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ko_KR/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..70398367b1 Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ko_KR/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ko_KR/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ko_KR/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..b6804ef908 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/ko_KR/LC_MESSAGES/k8s.po @@ -0,0 +1,96 @@ +# Test translations for unit tests. +# Copyright (C) 2017 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR ianyrchoi@gmail.com, 2018. +# +msgid "" +msgstr "" +"Project-Id-Version: gettext-go-examples-hello\n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2018-04-03 06:05+0900\n" +"Last-Translator: Ian Y. Choi \n" +"Language-Team: \n" +"Language: ko_KR\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 2.0.6\n" +"X-Poedit-SourceCharset: UTF-8\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_cluster.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "kubeconfig에서 지정된 클러스터를 삭제합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_context.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "kubeconfig에서 지정된 컨텍스트를 삭제합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_contexts.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "하나 또는 여러 컨텍스트를 설명합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_clusters.go#L40 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "kubeconfig에 정의된 클러스터를 표시합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/view.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "병합된 kubeconfig 설정 또는 지정된 kubeconfig 파일을 표시합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/config.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "kubeconfig 파일을 수정합니다" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "자원에 대한 주석을 업데이트합니다" + +# https://github.com/kubernetes/kubernetes/blob/masterpkg/kubectl/cmd/apply.go#L98 +#~ msgid "Apply a configuration to a resource by filename or stdin" +#~ msgstr "구성을 파일 이름 또는 stdin에 의한 자원에 적용합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/current_context.go#L48 +#~ msgid "Displays the current-context" +#~ msgstr "현재-컨텍스트를 표시합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_cluster.go#L67 +#~ msgid "Sets a cluster entry in kubeconfig" +#~ msgstr "kubeconfig에서 클러스터 항목을 설정합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_context.go#L57 +#~ msgid "Sets a context entry in kubeconfig" +#~ msgstr "kubeconfig에서 컨텍스트 항목을 설정합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_authinfo.go#L103 +#~ msgid "Sets a user entry in kubeconfig" +#~ msgstr "kubeconfig에서 사용자 항목을 설정합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/set.go#L59 +#~ msgid "Sets an individual value in a kubeconfig file" +#~ msgstr "kubeconfig 파일에서 단일값을 설정합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/use_context.go#L48 +#~ msgid "Sets the current-context in a kubeconfig file" +#~ msgstr "kubeconfig 파일에서 현재-컨텍스트를 설정합니다" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/unset.go#L47 +#~ msgid "Unsets an individual value in a kubeconfig file" +#~ msgstr "kubeconfig 파일에서 단일값 설정을 해제합니다" + +#~ msgid "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgid_plural "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgstr[0] "" +#~ "watch는 단일 리소스와 리소스 모음만을 지원합니다 - %d 개 자원을 발견하였습" +#~ "니다" diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/pt_BR/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/pt_BR/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..e3c52ec8a6 Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/pt_BR/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/pt_BR/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/pt_BR/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..dad451281f --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/pt_BR/LC_MESSAGES/k8s.po @@ -0,0 +1,3250 @@ +# Brazilian Portuguese translation. +# Copyright (C) 2020 +# This file is distributed under the same license as the PACKAGE package. +# FIRST AUTHOR ctadeu@gmail.com, 2020. +# +msgid "" +msgstr "" +"Project-Id-Version: \n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2020-12-11 17:03+0100\n" +"Last-Translator: Carlos Panato \n" +"Language-Team: \n" +"Language: pt_BR\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 2.4.2\n" +"Plural-Forms: nplurals=2; plural=(n > 1);\n" +"X-Poedit-KeywordsList: \n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:62 +msgid "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" +msgstr "" +"\n" +"\t\t # Mostra as métricas para todos os nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Mostra as métricas para um node específico\n" +"\t\t kubectl top node NODE_NAME" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:46 +msgid "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" +msgstr "" +"\n" +"\t\t# Mostra a documentação do recurso e seus campos\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Mostra a documentação de um campo específico de um recurso\n" +"\t\tkubectl explain pods.spec.containers" + +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:29 +msgid "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" +msgstr "" +"\n" +"\t\t# Mostra as opções herdadas por todos os comandos\n" +"\t\tkubectl options" + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:44 +msgid "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" +msgstr "" +"\n" +"\t\t# Imprime a versão do cliente e do servidor para o contexto atual\n" +"\t\tkubectl version" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:34 +msgid "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" +msgstr "" +"\n" +"\t\t# Mostra as versões de API suportadas\n" +"\t\tkubectl api-versions" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:75 +msgid "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" +msgstr "" +"\n" +"\t\t# Mostra as métricas para todos os pods no namespace default\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Mostra as métricas para todos os pods em um dado namespace\n" +"\t\tkubectl top pod —namespace=NAMESPACE\n" +"\n" +"\t\t# Mostra as métricas para um dado pod e seus containers\n" +"\t\tkubectl top pod POD_NAME —containers\n" +"\n" +"\t\t# Mostra as métricas para os pods definidos pelo label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" + +#: pkg/kubectl/cmd/convert/convert.go:40 +msgid "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." +msgstr "" +"\n" +"\t\tConvert os arquivos de configuração para diferentes versões de API. " +"Ambos formatos YAML\n" +"\t\\e JSON são aceitos.\n" +"\n" +"\t\tO command recebe o nome do arquivo, diretório ou URL como entrada, e " +"converteno formato\n" +"\t\tpara a versão especificada pelo parametro —output-version. Se a versão " +"desejada não é especificada ou \n" +"\t\tnão é suportada, converte para a última versã disponível.\n" +"\n" +"\t\tA saída padrão é no formato YAML. Pode ser utilizadoa opção -o\n" +"\t\tpara mudar o formato de saída." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:39 +msgid "" +"\n" +"\t\tCreate a namespace with the specified name." +msgstr "" +"\n" +"\t\tCria um namespace com um nome especificado." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:43 +msgid "" +"\n" +"\t\tCreate a role with single rule." +msgstr "" +"\n" +"\t\tCria uma role com uma única regra." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:40 +msgid "" +"\n" +"\t\tCreate a service account with the specified name." +msgstr "" +"\n" +"\t\tCria uma conta de serviço com um nome especificado." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:84 +msgid "" +"\n" +"\t\tMark node as schedulable." +msgstr "" +"\n" +"\t\tRemove a restrição de execução de workloads no node." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:55 +msgid "" +"\n" +"\t\tMark node as unschedulable." +msgstr "" +"\n" +"\t\tAplica a restrição de execução de workloads no node." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:70 +msgid "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." +msgstr "" +"\n" +"\t\tDefine a annotation last-applied-configuration configurando para ser " +"igual ao conteúdo do arquivo.\n" +"\t\tIsto resulta no last-applied-configuration ser atualizado quando o " +"'kubectl apply -f ' executa,\n" +"\t\tnão atualizando as outras partes do objeto." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:42 +msgid "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" +msgstr "" +"\n" +"\t # Cria um novo namespace chamado my-namespace\n" +"\t kubectl create namespace my-namespace" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:43 +msgid "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" +msgstr "" +"\n" +"\t # Cria um novo service account chamado my-service-account\n" +"\t kubectl create serviceaccount my-service-account" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:344 +msgid "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." +msgstr "" +"\n" +"\tCria um serviço do tipo ExternalName com o nome especificado.\n" +"\n" +"\tServiço ExternalName referencia um endereço externo de DNS ao invés de\n" +"\tapenas pods, o que permite aos desenvolvedores de aplicações referenciar " +"serviços\n" +"\tque existem fora da plataforma, em outros clusters ou localmente." + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:28 +msgid "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." +msgstr "" +"\n" +"\tHelp provê ajuda para qualquer comando na aplicação.\n" +"\tDigite simplesmente kubectl help [caminho do comando] para detalhes " +"completos." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:311 +msgid "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" +msgstr "" +"\n" +" # Cria um novo serviço do tipo LoadBalancer chamado my-lbs\n" +" kubectl create service loadbalancer my-lbs —tcp=5678:8080" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:102 +msgid "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" +msgstr "" +"\n" +" # Coleta o estado corrente do cluster e exibe no stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Coleta o estado corrente do custer para /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Coleta informação de todos os namespaces para stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Coleta o conjunto especificado de namespaces para /path/to/cluster-" +"state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:308 +msgid "" +"\n" +" Create a LoadBalancer service with the specified name." +msgstr "" +"\n" +" Cria um serviço do tipo LoadBalancer com o nome especificado." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:107 +msgid "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." +msgstr "" +"Lista de valores delimitados por vírgulas para um conjunto de escopos de " +"quota que devem corresponder para cada objeto rastreado pela quota." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:106 +msgid "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." +msgstr "" +"Lista de valores delimitados por vírgulas ajusta os pares resource=quantity " +"que define um limite rigído." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:113 +msgid "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." +msgstr "" +"Um seletor de label a ser usado para o PDB. Apenas seletores baseado em " +"igualdade são suportados." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:152 +msgid "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" +msgstr "" +"Um seletor de label para ser utilizado neste serviço. Apenas seletores " +"baseado em igualdade são suportados. Se vazio (por padrão) o seletor do " +"replication controller ou replica set será utilizado." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:157 +msgid "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." +msgstr "" +"Um IP externo adicional (não gerenciado pelo Kubernetes) para ser usado no " +"serviço. Se este IP for roteado para um nó, o serviço pode ser acessado por " +"este IP além de seu IP de serviço gerado." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:158 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:178 +msgid "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." +msgstr "" +"Uma substituição inline JSON para o objeto gerado. Se não estiver vazio, ele " +"será usado para substituir o objeto gerado. Requer que o objeto forneça um " +"campo apiVersion válido." + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:125 +msgid "Approve a certificate signing request" +msgstr "Aprova uma solicitação de assinatura de certificado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:263 +msgid "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." +msgstr "" +"Atribuir o seu próprio ClusterIP ou configura para 'None' para um serviço " +"'headless' (sem loadbalancing)." + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:105 +msgid "Attach to a running container" +msgstr "Se conecta a um container em execução" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:161 +msgid "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." +msgstr "" +"ClusterIP que será atribuído ao serviço. Deixe vazio para auto atribuição, " +"ou configure para 'None' para criar um serviço headless." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:101 +msgid "ClusterRole this ClusterRoleBinding should reference" +msgstr "ClusterRole que esse ClusterRoleBinding deve referenciar" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:104 +msgid "ClusterRole this RoleBinding should reference" +msgstr "ClusterRole que esse RoleBinding deve referenciar" + +#: pkg/kubectl/cmd/convert/convert.go:95 +msgid "Convert config files between different API versions" +msgstr "Converte arquivos de configuração entre versões de API diferentes" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:106 +msgid "Copy files and directories to and from containers." +msgstr "Copia arquivos e diretórios de e para containers." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:94 +msgid "Create a TLS secret" +msgstr "Cria uma secret do tipo TLS" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:83 +msgid "Create a namespace with the specified name" +msgstr "Cria a namespace com um nome especificado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:134 +msgid "Create a secret for use with a Docker registry" +msgstr "Cria um secret para ser utilizado com o Docker registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:49 +msgid "Create a secret using specified subcommand" +msgstr "Cria um secret utilizando um sub-comando especificado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:85 +msgid "Create a service account with the specified name" +msgstr "Cria uma conta de serviço com um nome especificado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "Apaga o cluster especificado do kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "Apaga o contexto especificado do kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:174 +msgid "Deny a certificate signing request" +msgstr "Rejeita o pedido de assinatura do certificado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "Mostra um ou mais contextos" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "Mostra os clusters definidos no kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "" +"Mostra a configuração do kubeconfig mescladas ou um arquivo kubeconfig " +"especificado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:165 +msgid "Display one or many resources" +msgstr "Mostra um ou mais recursos" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:184 +msgid "Drain node in preparation for maintenance" +msgstr "Drenar o node para preparação de manutenção" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:77 +msgid "Edit a resource on the server" +msgstr "Edita um recurso no servidor" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:152 +msgid "Email for Docker registry" +msgstr "Email para o Docker registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:89 +msgid "Execute a command in a container" +msgstr "Executa um comando em um container" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:109 +msgid "Forward one or more local ports to a pod" +msgstr "Encaminhar uma ou mais portas locais para um pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:37 +msgid "Help about any command" +msgstr "Ajuda sobre qualquer comando" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:160 +msgid "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" +msgstr "" +"Se não vazio, configura a afinidade de sessão para o serviço; valores " +"válidos: 'None', 'ClientIP'" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:157 +msgid "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"Se não estiver vazio, a atualização dos annotation só terá êxito se esta for " +"a versão do recurso atual para o objeto. Válido apenas ao especificar um " +"único recurso." + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:154 +msgid "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"Se não estiver vazio, a atualização dos labels só terá êxito se esta for a " +"versão do recurso atual para o objeto. Válido apenas ao especificar um único " +"recurso." + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:98 +msgid "Mark node as schedulable" +msgstr "Marca o node como agendável" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:69 +msgid "Mark node as unschedulable" +msgstr "Marca o node como não agendável" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:83 +msgid "Mark the provided resource as paused" +msgstr "Marca o recurso fornecido como pausado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:49 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:50 +msgid "Modify certificate resources." +msgstr "Edita o certificado dos recursos." + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "Edita o arquivo kubeconfig" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:156 +msgid "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." +msgstr "" +"Nome ou o número da porta em um container em que o serviço deve direcionar o " +"tráfego. Opcional." + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:174 +msgid "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." +msgstr "" +"Apenas retorna os logs após uma data específica (RFC3339). Padrão para todos " +"os logs. Apenas um since-time / since deve ser utilizado." + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:112 +msgid "Output shell completion code for the specified shell (bash or zsh)" +msgstr "Saída do autocomplete de shell para um Shell específico (bash ou zsh)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:151 +msgid "Password for Docker registry authentication" +msgstr "Senha para a autenticação do registro do Docker" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:110 +msgid "Path to PEM encoded public key certificate." +msgstr "Caminho para a chave pública em formato PEM." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:111 +msgid "Path to private key associated with given certificate." +msgstr "Caminho para a chave private associada a um certificado fornecido." + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:130 +msgid "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." +msgstr "" +"Pré-condição para a versão do recurso. Requer que a versão do recurso atual " +"corresponda a este valor para escalar." + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:73 +msgid "Print the client and server version information" +msgstr "Mostra a informação de versão do cliente e do servidor" + +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:38 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:39 +msgid "Print the list of flags inherited by all commands" +msgstr "Mostra a lista de opções herdadas por todos os comandos" + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:152 +msgid "Print the logs for a container in a pod" +msgstr "Mostra os logs de um container em um pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:87 +msgid "Resume a paused resource" +msgstr "Retoma um recurso pausado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:105 +msgid "Role this RoleBinding should reference" +msgstr "Role que a RoleBinding deve referenciar" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:152 +msgid "Run a particular image on the cluster" +msgstr "Executa uma imagem específica no cluster" + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:119 +msgid "Run a proxy to the Kubernetes API server" +msgstr "Executa um proxy para o servidor de API do Kubernetes" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:153 +msgid "Server location for Docker registry" +msgstr "Localização do servidor para o registro do Docker" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:39 +msgid "Set specific features on objects" +msgstr "Define funcionalidades específicas em objetos" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:104 +msgid "Set the selector on a resource" +msgstr "Define um seletor em um recurso" + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:107 +msgid "Show details of a specific resource or group of resources" +msgstr "Mostra os detalhes de um recurso específico ou de um grupo de recursos" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:102 +msgid "Show the status of the rollout" +msgstr "Mostra o status de uma atualização dinamica" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:154 +msgid "Synonym for --target-port" +msgstr "Sinônimo para —target-port" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:174 +msgid "The image for the container to run." +msgstr "A imagem para o container executar." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:176 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" +msgstr "" +"A política de obtenção de imagens. Se deixado em branco, este valor não será " +"especificado pelo cliente e será utilizado o padrão do servidor" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:111 +msgid "" +"The minimum number or percentage of available pods this budget requires." +msgstr "" +"Um número mínimo ou porcentagem de pods disponíveis que este budget requer." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:159 +msgid "The name for the newly created object." +msgstr "O nome para o objeto recém criado." + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:125 +msgid "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." +msgstr "" +"O nome para o objeto recém criado. Se não especificado, o nome do input " +"resource será utilizado." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:147 +msgid "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." +msgstr "" +"O nome do gerador de API a ser usado. Existem 2 geradores: 'service/v1' e " +"'service/v2'. A única diferença entre eles é que a porta de serviço na v1 é " +"chamada de 'default', enquanto ela é deixada sem nome na v2. O padrão é " +"'service/v2'." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:148 +msgid "The network protocol for the service to be created. Default is 'TCP'." +msgstr "O protocolo de rede para o serviço ser criado. Padrão é 'TCP'." + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:149 +msgid "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" +msgstr "" +"A porta para que o serviço possa servir. Copiado do recurso sendo exposto, " +"se não especificado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:194 +msgid "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." +msgstr "" +"O recurso requerido para este container. Por exemplo, 'cpu=200m," +"memory=512Mi'. Observe que os componentes do lado do servidor podem " +"atribuir limites, dependendo da configuração do servidor, como intervalos de " +"limite." + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:192 +msgid "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." +msgstr "" +"O recurso requerido de requests para este container. Por exemplo, 'cpu=100m," +"memory=256Mi'. Observe que os componentes do lado do servidor podem " +"atribuir requests, dependendo da configuração do servidor, como intervalos " +"de limite." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:155 +msgid "The type of secret to create" +msgstr "O tipo de segredo para criar" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:87 +msgid "Undo a previous rollout" +msgstr "Desfazer o rollout anterior" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:116 +msgid "Update resource requests/limits on objects with pod templates" +msgstr "" +"Atualizar os recursos de request/limites em um objeto com template de pod" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "Atualizar as anotações de um recurso" + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:133 +msgid "Update the labels on a resource" +msgstr "Atualizar os labels de um recurso" + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:109 +msgid "Update the taints on one or more nodes" +msgstr "Atualizar o taints de um ou mais nodes" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:150 +msgid "Username for Docker registry authentication" +msgstr "Nome de usuário para a autenticação no Docker registry" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:83 +msgid "View rollout history" +msgstr "Visualizar o histórico de rollout" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:85 +msgid "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" +msgstr "" +"Onde colocar os arquivos de saída. Se vazio ou '-' usa o stdout do terminal, " +"caso contrário, cria uma hierarquia no diretório configurado" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run_test.go:88 +msgid "dummy restart flag)" +msgstr "dummy restart flag)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cmd.go:227 +msgid "kubectl controls the Kubernetes cluster manager" +msgstr "kubectl controla o gerenciador de cluster do Kubernetes" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a ClusterRoleBinding for user1, user2, and group1 using " +#~ "the cluster-admin ClusterRole\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin --user=user1 --user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Criar o ClusterRoleBinding para user1, user2, e group1 utilizando " +#~ "o ClusterRole cluster-admin\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin —user=user1 —user=user2 —group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a RoleBinding for user1, user2, and group1 using the admin " +#~ "ClusterRole\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +#~ "user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Criar uma RoleBinding para user1, user2, e group1 utilizando o " +#~ "admin ClusterRole\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin —user=user1 —" +#~ "user=user2 —group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config based on folder bar\n" +#~ "\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with specified keys " +#~ "instead of file basenames on disk\n" +#~ "\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/" +#~ "file1.txt --from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with key1=config1 and " +#~ "key2=config2\n" +#~ "\t\t kubectl create configmap my-config --from-literal=key1=config1 --" +#~ "from-literal=key2=config2" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Criar um novo configmap com o nome de my-config baseado na pasta " +#~ "bar\n" +#~ "\t\t kubectl create configmap my-config —from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # Cria um novo configmap com o nome my-config, onde cada chave " +#~ "possui o valor especificado em um arquivo distinto no disco\n" +#~ "\t\t kubectl create configmap my-config —from-file=key1=/path/to/bar/" +#~ "file1.txt —from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # Criar um novo configmap com o nome de my-config com key1=config1 " +#~ "e key2=config2\n" +#~ "\t\t kubectl create configmap my-config —from-literal=key1=config1 —from-" +#~ "literal=key2=config2" + +#~ msgid "" +#~ "\n" +#~ "\t\t # If you don't already have a .dockercfg file, you can create a " +#~ "dockercfg secret directly by using:\n" +#~ "\t\t kubectl create secret docker-registry my-secret --docker-" +#~ "server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +#~ "password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL" +#~ msgstr "" +#~ "\n" +#~ "\t\t # Se você ainda não tem o arquivo .dockercfg, você pode gerar " +#~ "diretamente o dockercfg secret utilizando o comando:\n" +#~ "\t\t kubectl create secret docker-registry my-secret —docker-" +#~ "server=DOCKER_REGISTRY_SERVER —docker-username=DOCKER_USER —docker-" +#~ "password=DOCKER_PASSWORD —docker-email=DOCKER_EMAIL" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Apply the configuration in pod.json to a pod.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Apply the JSON passed into stdin to a pod.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Note: --prune is still in Alpha\n" +#~ "\t\t# Apply the configuration in manifest.yaml that matches label " +#~ "app=nginx and delete all the other resources that are not in the file and " +#~ "match label app=nginx.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# Apply the configuration in manifest.yaml and delete all the other " +#~ "configmaps that are not in the file.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/" +#~ "v1/ConfigMap" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Aplica a configuração do arquivo pod.json a um pod.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Aplica o JSON recebido via stdin para um pod.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Nota: —prune ainda está em Alpha\n" +#~ "\t\t# Aplica a configuração do manifest.yaml que conter o label app=nginx " +#~ "e remove todos os outros recursos que não estejam no arquivo e não " +#~ "contenham o label.\n" +#~ "\t\tkubectl apply —prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# Aplica a configuração do manifest.yaml e remove todos os outros " +#~ "configmaps que não estão no arquivo.\n" +#~ "\t\tkubectl apply —prune -f manifest.yaml —all —prune-whitelist=core/v1/" +#~ "ConfigMap" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 " +#~ "and 10, no target CPU utilization specified so a default autoscaling " +#~ "policy will be used:\n" +#~ "\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +#~ "\n" +#~ "\t\t# Auto scale a replication controller \"foo\", with the number of " +#~ "pods between 1 and 5, target CPU utilization at 80%:\n" +#~ "\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Escala automaticamente um deployment \"foo\", com o número de pods " +#~ "entre 2 e 10, sem especificar a utilização da CPU o padrão da política de " +#~ "autoscaling será utilizado:\n" +#~ "\t\tkubectl autoscale deployment foo —min=2 —max=10\n" +#~ "\n" +#~ "\t\t# Escala automaticamente um replication controller \"foo\", com o " +#~ "número de pods entre 1 and 5, e definindo a utilização da CPU em 80%:\n" +#~ "\t\tkubectl autoscale rc foo —max=5 —cpu-percent=80" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# Convert the live state of the resource specified by 'pod.yaml' to " +#~ "the latest version\n" +#~ "\t\t# and print to stdout in json format.\n" +#~ "\t\tkubectl convert -f pod.yaml --local -o json\n" +#~ "\n" +#~ "\t\t# Convert all files under current directory to latest version and " +#~ "create them all.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" +#~ msgstr "" +#~ "\n" +#~ "\t\t# converte o arquivo 'pod.yaml' para a versão mais atual e imprime a " +#~ "saída para o stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# Converte o estado atual do recurso especificado pelo 'pod.yaml' " +#~ "para a versão mais atual\n" +#~ "\t\t# e imprime a saída para o stdout no formato json.\n" +#~ "\t\tkubectl convert -f pod.yaml —local -o json\n" +#~ "\n" +#~ "\t\t# Converte todos os arquivos dentro do diretório atual para a versão " +#~ "mais recente e cria todos.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" that allows user to " +#~ "perform \"get\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" with ResourceName " +#~ "specified\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods --resource-name=readablepod" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Cria um ClusterRole com o nome de \"pod-reader\" que permite o " +#~ "usuário realizar \"get\", \"watch\" e \"list\" em pods\n" +#~ "\t\tkubectl create clusterrole pod-reader —verb=get,list,watch —" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Cria a ClusterRole com o nome de \"pod-reader\" com um ResourceName " +#~ "especificado\n" +#~ "\t\tkubectl create clusterrole pod-reader —verb=get,list,watch —" +#~ "resource=pods —resource-name=readablepod" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" that allows user to perform \"get" +#~ "\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a Role named \"pod-reader\" with ResourceName specified\n" +#~ "\t\tkubectl create role pod-reader --verb=get --verg=list --verb=watch --" +#~ "resource=pods --resource-name=readablepod" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Cria uma Role com o nome de \"pod-reader\" que permite o usuário " +#~ "realizar \"get\", \"watch\" e \"list\" em pods\n" +#~ "\t\tkubectl create role pod-reader —verb=get —verb=list —verb=watch —" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Cria uma Role com o nome de \"pod-reader\" com um ResourceName " +#~ "especificado\n" +#~ "\t\tkubectl create role pod-reader —verb=get —verg=list —verb=watch —" +#~ "resource=pods —resource-name=readablepod" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a new resourcequota named my-quota\n" +#~ "\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2," +#~ "services=3,replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# Create a new resourcequota named best-effort\n" +#~ "\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Cria um novo resourcequota com o nome de my-quota\n" +#~ "\t\tkubectl create quota my-quota —hard=cpu=1,memory=1G,pods=2,services=3," +#~ "replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# Cria um novo resourcequota com o nome de best-effort\n" +#~ "\t\tkubectl create quota best-effort —hard=pods=100 —scopes=BestEffort" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=rails label\n" +#~ "\t\t# and require at least one of them being available at any point in " +#~ "time.\n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=nginx label\n" +#~ "\t\t# and require at least half of the pods selected to be available at " +#~ "any point in time.\n" +#~ "\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Cria um pod disruption budget com o nome de my-pdb que irá " +#~ "selecionar todos os pods com o label app=rails\n" +#~ "\t\t# e requer que pelo menos um deles esteja disponível a qualquer " +#~ "momento.\n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb —selector=app=rails —min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# Cria um pod disruption budget com o nome de my-pdb que irá " +#~ "selecionar todos os pods com o label app=nginx\n" +#~ "\t\t# e requer pelo menos que metade dos pods selecionados estejam " +#~ "disponíveis em qualquer momento.\n" +#~ "\t\tkubectl create pdb my-pdb —selector=app=nginx —min-available=50%" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod using the data in pod.json.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Create a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# Edit the data in docker-registry.yaml in JSON using the v1 API " +#~ "format then create the resource using the edited data.\n" +#~ "\t\tkubectl create -f docker-registry.yaml --edit --output-version=v1 -o " +#~ "json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Cria um pod utilizando o arquivo pod.json.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Cria um pod utilizando o JSON recebido via stdin.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# Edita o conteúdo do arquivo docker-registry.yaml em JSON utilizando " +#~ "o formato da API v1, criando o recurso com o conteúdo editado.\n" +#~ "\t\tkubectl create -f docker-registry.yaml —edit —output-version=v1 -o " +#~ "json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a replication controller identified by type " +#~ "and name specified in \"nginx-controller.yaml\", which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +#~ "the name \"frontend\"\n" +#~ "\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +#~ "\n" +#~ "\t\t# Create a second service based on the above service, exposing the " +#~ "container port 8443 as port 443 with the name \"nginx-https\"\n" +#~ "\t\tkubectl expose service nginx --port=443 --target-port=8443 --" +#~ "name=nginx-https\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated streaming application on port " +#~ "4100 balancing UDP traffic and named 'video-stream'.\n" +#~ "\t\tkubectl expose rc streamer --port=4100 --protocol=udp --name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx using replica set, which " +#~ "serves on port 80 and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for an nginx deployment, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose deployment nginx --port=80 --target-port=8000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Cria um serviço para um nginx replicado, que escuta na porta 80 e " +#~ "conecta na porta 8000 dos containers.\n" +#~ "\\t\tkubectl expose rc nginx —port=80 —target-port=8000\n" +#~ "\n" +#~ "\t\t# Cria um serviço para um replication controller identificado por " +#~ "tipo e com o nome especificado em \"nginx-controller.yaml\", que escuta " +#~ "na porta 80 e conecta na porta 8000 dos containers.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml —port=80 —target-port=8000\n" +#~ "\n" +#~ "\t\t# Cria um serviço para um pod valid-pod, que escuta na porta 444 com " +#~ "o nome \"frontend\"\n" +#~ "\t\tkubectl expose pod valid-pod —port=444 —name=frontend\n" +#~ "\n" +#~ "\t\t# Cria um segundo serviço baseado no serviço acima, expondo a porta " +#~ "8443 do container como porta 443 e com nome \"nginx-https\"\n" +#~ "\t\tkubectl expose service nginx —port=443 —target-port=8443 —name=nginx-" +#~ "https\n" +#~ "\n" +#~ "\t\t# Cria um serviço para uma aplicação streaming replicada na porta " +#~ "4100 com trafico balanceado UDP e nome 'video-stream'.\n" +#~ "\t\tkubectl expose rc streamer —port=4100 —protocol=udp —name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# Cria um serviço para um nginx replicado usando o replica set, que " +#~ "escuta na porta 80 e conecta na porta 8000 dos containers.\n" +#~ "\t\tkubectl expose rs nginx —port=80 —target-port=8000\n" +#~ "\n" +#~ "\t\t# Cria um serviço para um deployment nginx, que escuta na porta 80 e " +#~ "conecta na porta 8000 dos containers.\n" +#~ "\t\tkubectl expose deployment nginx —port=80 —target-port=8000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Delete a pod using the type and name specified in pod.json.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Delete a pod based on the type and name in the JSON passed into " +#~ "stdin.\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# Delete pods and services with label name=myLabel.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Delete a pod with minimal delay\n" +#~ "\t\tkubectl delete pod foo --now\n" +#~ "\n" +#~ "\t\t# Force delete a pod on a dead node\n" +#~ "\t\tkubectl delete pod foo --grace-period=0 --force\n" +#~ "\n" +#~ "\t\t# Delete all pods\n" +#~ "\t\tkubectl delete pods --all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Remove um pod usando o tipo e nome especificado no arquivo pod." +#~ "json.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Remove um pod baseado no tipo e nome no JSON passado na entrada de " +#~ "comando(stdin).\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# Remove pods e serviços com os nomes \"baz\" e \"foo\"\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# Remove pods e serviços com label name=myLabel.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Remove um pod com um mínimo de delay\n" +#~ "\t\tkubectl delete pod foo —now\n" +#~ "\n" +#~ "\t\t# Força a remoção de um pod em um node morto\n" +#~ "\t\tkubectl delete pod foo —grace-period=0 —force\n" +#~ "\n" +#~ "\t\t# Remove todos os pods\n" +#~ "\t\tkubectl delete pods —all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Describe a node\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# Describe a pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# Describe all pods\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# Describe pods by label name=myLabel\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Describe all pods managed by the 'frontend' replication controller " +#~ "(rc-created pods\n" +#~ "\t\t# get the name of the rc as a prefix in the pod the name).\n" +#~ "\t\tkubectl describe pods frontend" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Descreve um node\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# Descreve um pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# Descreve um pod identificado pelo tipo e nome no arquivo \"pod.json" +#~ "\"\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# Descreve todos os pods\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# Descreve os pods com label name=myLabel\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Descreve todos os pods gerenciados pelo replication controller " +#~ "'frontend' (rc-created pods\n" +#~ "\t\t# tem o nome de rc como prefixo no nome do pod).\n" +#~ "\t\tkubectl describe pods frontend" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Drain node \"foo\", even if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet on it.\n" +#~ "\t\t$ kubectl drain foo --force\n" +#~ "\n" +#~ "\t\t# As above, but abort if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet, and use " +#~ "a grace period of 15 minutes.\n" +#~ "\t\t$ kubectl drain foo --grace-period=900" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Drena o node \"foo\", mesmo se os pods não são gerenciados por um " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet ou StatefulSet.\n" +#~ "\t\t$ kubectl drain foo —force\n" +#~ "\n" +#~ "\t\t# Mesmo que acima, mas é interrompido se os pods não são gerenciados " +#~ "por um ReplicationController, ReplicaSet, Job, DaemonSet ou StatefulSet, " +#~ "e tem espera por 15 minutos.\n" +#~ "\t\t$ kubectl drain foo —grace-period=900" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Edit the service named 'docker-registry':\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Use an alternative editor\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Edit the job 'myjob' in JSON using the v1 API format:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +#~ "config in its annotation:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml --save-config" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Edita o serviço chamado 'docker-registry':\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Usa um editor alternativo\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Edita o Job 'myjob' em JSON utilizando o format da API v1:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# Edita o deployment 'mydeployment' em YAML e salva a configuração " +#~ "modificada em sua annotation:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml —save-config" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running 'date' from pod 123456-7890, using the " +#~ "first container by default\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# Get output from running 'date' in ruby-container from pod " +#~ "123456-7890\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t -- bash -il" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Pega a saída de execução do comando 'date' do pod 123456-7890, " +#~ "usando o primeiro container por padrão\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# Pega a saída de execução do comando 'date' no ruby-container do pod " +#~ "123456-7890\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# Troca para raw terminal mode, envia stdin para o 'bash' no ruby-" +#~ "container do pod 123456-7890\n" +#~ "\t\t# e envia stdout/stderr do 'bash' de volta para o cliente\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t — bash -il" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running pod 123456-7890, using the first container " +#~ "by default\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# Get output from ruby-container from pod 123456-7890\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# Get output from the first pod of a ReplicaSet named nginx\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Pega a saída do pod em execução 123456-7890, utilizando o primeiro " +#~ "container por padrão\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# Pega a saída do ruby-container do pod 123456-7890\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# Troca para raw terminal mode, envia stdin para o 'bash' no ruby-" +#~ "container do pod 123456-7890\n" +#~ "\t\t# e envia stdout/stderr do 'bash' de volta para o cliente\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# Pega a saída do primeiro pod de um ReplicaSet chamado nginx\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Install bash completion on a Mac using homebrew\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash completion support\n" +#~ "source $(brew --prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for bash into the current shell\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# Write bash completion code to a file and source if from ." +#~ "bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell completion\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +#~ "\t\tsource <(kubectl completion zsh)" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Instala o auto completar do bash no Mac utilizando homebrew\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash completion support\n" +#~ "source $(brew —prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Carrega o código de auto complentar do kubectl para o bash no shell " +#~ "corrente\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# Escreve o código de autocompletar do bash no arquivo de perfil e " +#~ "faz o source se é para o .bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell completion\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Carrega o código de auto complentar do kubectl para zsh[1] no shell " +#~ "em utilização\n" +#~ "\t\tsource <(kubectl completion zsh)" + +#~ msgid "" +#~ "\n" +#~ "\t\t# List all pods in ps output format.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# List all pods in ps output format with more information (such as " +#~ "node name).\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# List a single replication controller with specified NAME in ps " +#~ "output format.\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# List a single pod in JSON output format.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +#~ "JSON output format.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# Return only the phase value of the specified pod.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# List all replication controllers and services together in ps output " +#~ "format.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# List one or more resources by their type and names.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List all resources with different types.\n" +#~ "\t\tkubectl get all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Lista todos os pods no formato de saída ps.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# Lista todos os pods no formato de saída ps com mais informações " +#~ "(como o nome do node).\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# Lista um único replication controller com o nome especificado no " +#~ "formato de saída ps\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# Lista um único pod e usa o formato de saída JSON.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# Lista o pod identificado com o tipo e nome especificado no \"pod." +#~ "yaml\" e usa o formato de saída JSON.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# Mostra apenas em que estágio o pod especificado está.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 —template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# Lista todos os replication controllers e services juntos no formato " +#~ "de saída ps.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# Lista um ou mais recursos pelo seu tipo e nomes.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# Lista todos os recursos e com tipos diferentes.\n" +#~ "\t\tkubectl get all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 5000 6000\n" +#~ "\n" +#~ "\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 8888:5000\n" +#~ "\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod :5000\n" +#~ "\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 0:5000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Escuta nas portas locais 5000 e 6000, e redireciona os dados de/" +#~ "para as portas 5000 e 6000 no pod\n" +#~ "\t\tkubectl port-forward mypod 5000 6000\n" +#~ "\n" +#~ "\t\t# Escuta na porta local 8888 localmente, e redireciona para a porta " +#~ "5000 no pod\n" +#~ "\t\tkubectl port-forward mypod 8888:5000\n" +#~ "\n" +#~ "\t\t# Escuta uma porta local aleatória, e redireciona para a porta 5000 " +#~ "no pod\n" +#~ "\t\tkubectl port-forward mypod :5000\n" +#~ "\n" +#~ "\t\t# Escuta uma porta local aleatória, e redireciona para a porta 5000 " +#~ "no pod\\n\n" +#~ "\t\tkubectl port-forward mypod 0:5000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as schedulable.\n" +#~ "\t\t$ kubectl uncordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Remove a restrição de execução de Pods no node \"foo\".\n" +#~ "\t\t$ kubectl uncordon foo" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as unschedulable.\n" +#~ "\t\tkubectl cordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Restringe a execução de novos Pods no node \"foo\".\n" +#~ "\t\tkubectl cordon foo" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Partially update a node using strategic merge patch\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# Partially update a node identified by the type and name specified " +#~ "in \"node.json\" using strategic merge patch\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image; spec.containers[*].name is required " +#~ "because it's a merge key\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image using a json patch with positional " +#~ "arrays\n" +#~ "\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Atualiza parcialmente um node utilizando a estratégia merge patch\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# Atualiza parcialmente um node identificado pelo tipo e nome no " +#~ "arquivo \"node.json\" utilizando a estratégia merge patch\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# Atualiza uma imagem em um container; spec.containers[*].name é " +#~ "requerido pois será usado como índice para a mudança\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# Atualiza uma imagem em um container utilizando o json patch com " +#~ "positional arrays\n" +#~ "\t\tkubectl patch pod valid-pod —type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Print the address of the master and cluster services\n" +#~ "\t\tkubectl cluster-info" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Mostra o endereço do servidor de gerenciamento e dos serviços do " +#~ "cluster\n" +#~ "\t\tkubectl cluster-info" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Replace a pod using the data in pod.json.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Replace a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Update a single-container pod's image version (tag) to v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Force replace, delete and then re-create the resource\n" +#~ "\t\tkubectl replace --force -f ./pod.json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Substitui um pod utlizando os dados contidos em pod.json.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Troca um pod com base no JSON fornecido no stdin.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Atualiza uma versão de imagem (tag) de um pod com um único " +#~ "container para v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Força a troca, removendo e recriando o recurso\n" +#~ "\t\tkubectl replace —force -f ./pod.json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Return snapshot logs from pod nginx with only one container\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs for the pods defined by label app=nginx\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot of previous terminated ruby container logs from pod " +#~ "web-1\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Display only the most recent 20 lines of output in pod nginx\n" +#~ "\t\tkubectl logs --tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Show all logs from pod nginx written in the last hour\n" +#~ "\t\tkubectl logs --since=1h nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from first container of a job named hello\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from container nginx-1 of a deployment named " +#~ "nginx\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Retorna os logs do pod nginx com um único container\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# Retorna os logs dos pods definidos pelo label app=nginx\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Retorna os logs do container ruby finalizado do pod web-1\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Começa o streaming de logs de um ruby container no pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Mostra apenas as 20 linhas mais recentes de saída do pod nginx\n" +#~ "\t\tkubectl logs —tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Mostra todos os logs do pod nginx escrito na última hora\n" +#~ "\t\tkubectl logs —since=1h nginx\n" +#~ "\n" +#~ "\t\t# Retorna os logs do primeiro container com o Job chamado hello\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Retorna os logs do container nginx-1 de um deployment chamado " +#~ "nginx\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on port 8011, serving static " +#~ "content from ./local/www/\n" +#~ "\t\tkubectl proxy --port=8011 --www=./local/www/\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on an arbitrary local port.\n" +#~ "\t\t# The chosen port for the server will be output to stdout.\n" +#~ "\t\tkubectl proxy --port=0\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver, changing the api prefix to k8s-" +#~ "api\n" +#~ "\t\t# This makes e.g. the pods api available at localhost:8001/k8s-api/v1/" +#~ "pods/\n" +#~ "\t\tkubectl proxy --api-prefix=/k8s-api" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Executa um proxy para o apiserver do kubernetes na porta 8011, " +#~ "servindo um conteúdo estático do caminho ./local/www/\n" +#~ "\t\tkubectl proxy —port=8011 —www=./local/www/\n" +#~ "\n" +#~ "\t\t# Executa um proxy para o apiserver do kubernetes em uma porta local " +#~ "arbitrária.\n" +#~ "\t\t# A porta escolhida para o servidor será utilizada para o saída de " +#~ "stdout.\n" +#~ "\t\tkubectl proxy —port=0\n" +#~ "\n" +#~ "\t\t# Executa um proxy para o apiserver do kubernetes, mudando o prefixo " +#~ "do api para k8s-api\n" +#~ "\t\t# Com isso a api dos pods estarão disponível em localhost:8001/k8s-" +#~ "api/v1/pods/\n" +#~ "\t\tkubectl proxy —api-prefix=/k8s-api" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Scale a replicaset named 'foo' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Scale a resource identified by type and name specified in \"foo.yaml" +#~ "\" to 3.\n" +#~ "\t\tkubectl scale --replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# If the deployment named mysql's current size is 2, scale mysql to " +#~ "3.\n" +#~ "\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Scale multiple replication controllers.\n" +#~ "\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Scale job named 'cron' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 job/cron" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Escala um replicaset chamado 'foo' para 3.\n" +#~ "\t\tkubectl scale —replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Escala um recurso identificado pelo tipo e nome especificado no " +#~ "arquivo \"foo.yaml\" para 3.\n" +#~ "\t\tkubectl scale —replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# Se um deployment chamado mysql tem tamanho 2, escala o mysql para " +#~ "3.\n" +#~ "\t\tkubectl scale —current-replicas=2 —replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Escala múltiplos replication controllers.\n" +#~ "\t\tkubectl scale —replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Escala um Job chamado 'cron' para 3.\n" +#~ "\t\tkubectl scale —replicas=3 job/cron" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Execute set-last-applied against each configuration file in a " +#~ "directory.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file, will create the annotation if it does not already " +#~ "exist.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml --create-" +#~ "annotation=true\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Ajusta o last-applied-configuration de um recurso para corresponder " +#~ "ao conteúdo de um arquivo.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Executa o set-last-applied em todos os arquivos de configuração no " +#~ "diretório.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# Ajusta o last-applied-configuration de um recurso para corresponder " +#~ "ao conteúdo de um arquivo, será criada uma annotation se esta ainda não " +#~ "existe.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml —create-" +#~ "annotation=true\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Shut down foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Stop pods and services with label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Shut down the service defined in service.json\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Shut down all resources in the path/to/resources directory\n" +#~ "\t\tkubectl stop -f path/to/resources" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Termina o replicationcontroller foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Para os pods e serviços com o label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Termina o serviço definido no arquivo service.json\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Termina todos os recursos no caminho do diretório path/to/" +#~ "resources\n" +#~ "\t\tkubectl stop -f path/to/resources" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Start a single instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and let the container expose " +#~ "port 5701 .\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --port=5701\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and set environment variables " +#~ "\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --env=\"DNS_DOMAIN=cluster\" " +#~ "--env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Start a replicated instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx --replicas=5\n" +#~ "\n" +#~ "\t\t# Dry run. Print the corresponding API objects without creating " +#~ "them.\n" +#~ "\t\tkubectl run nginx --image=nginx --dry-run\n" +#~ "\n" +#~ "\t\t# Start a single instance of nginx, but overload the spec of the " +#~ "deployment with a partial set of values parsed from JSON.\n" +#~ "\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": " +#~ "\"v1\", \"spec\": { ... } }'\n" +#~ "\n" +#~ "\t\t# Start a pod of busybox and keep it in the foreground, don't restart " +#~ "it if it exits.\n" +#~ "\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +#~ "\n" +#~ "\t\t# Start the nginx container using the default command, but use custom " +#~ "arguments (arg1 .. argN) for that command.\n" +#~ "\t\tkubectl run nginx --image=nginx -- ... \n" +#~ "\n" +#~ "\t\t# Start the nginx container using a different command and custom " +#~ "arguments.\n" +#~ "\t\tkubectl run nginx --image=nginx --command -- ... \n" +#~ "\n" +#~ "\t\t# Start the perl container to compute π to 2000 places and print it " +#~ "out.\n" +#~ "\t\tkubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Start the cron job to compute π to 2000 places and print it out " +#~ "every 5 minutes.\n" +#~ "\t\tkubectl run pi --schedule=\"0/5 * * * ?\" --image=perl --" +#~ "restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Inicia uma única instância de nginx.\n" +#~ "\t\tkubectl run nginx —image=nginx\n" +#~ "\n" +#~ "\t\t# Inicia uma única instância do hazelcast e expõe a porta 5701 do " +#~ "container.\n" +#~ "\t\tkubectl run hazelcast —image=hazelcast —port=5701\n" +#~ "\n" +#~ "\t\t# Inicia uma única instância do hazelcast e seta as variáveis de " +#~ "ambiente \"DNS_DOMAIN=cluster\" e \"POD_NAMESPACE=default\" no " +#~ "container.\n" +#~ "\t\tkubectl run hazelcast —image=hazelcast —env=\"DNS_DOMAIN=cluster\" —" +#~ "env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Inicia uma instância replicada de nginx.\n" +#~ "\t\tkubectl run nginx —image=nginx —replicas=5\n" +#~ "\n" +#~ "\t\t# Dry run. Mostra os objetos da API correspondente sem criar elas.\n" +#~ "\t\tkubectl run nginx —image=nginx —dry-run\n" +#~ "\n" +#~ "\t\t# Inicia uma única instância de nginx, mas sobrescreve a spec do " +#~ "deployment com um conjunto parcial de valores passeados do JSON.\n" +#~ "\t\tkubectl run nginx —image=nginx —overrides='{ \"apiVersion\": \"v1\", " +#~ "\"spec\": { … } }'\n" +#~ "\n" +#~ "\t\t# Inicia um pod de busybox e mantém ele em primeiro plano, não " +#~ "reinicia se ele já existe.\n" +#~ "\t\tkubectl run -i -t busybox —image=busybox —restart=Never\n" +#~ "\n" +#~ "\t\t# Inicia um container nginx usando o comando padrão, mas utiliza " +#~ "argumentos customizados (arg1 .. argN) para o comando.\n" +#~ "\t\tkubectl run nginx —image=nginx — … \n" +#~ "\n" +#~ "\t\t# Inicia um container nginx usando um comando diferente e argumentos " +#~ "customizados.\n" +#~ "\t\tkubectl run nginx —image=nginx —command — … \n" +#~ "\n" +#~ "\t\t# Inicia um container perl para processar π to 2000 posições e mostra " +#~ "a saída.\n" +#~ "\t\tkubectl run pi —image=perl —restart=OnFailure — perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Inicia um cron job para processar as 2000 posições de π e mostra a " +#~ "saída a cada 5 minutos.\n" +#~ "\t\tkubectl run pi —schedule=\"0/5 * * * ?\" —image=perl —" +#~ "restart=OnFailure — perl -Mbignum=bpi -wle 'print bpi(2000)'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update node 'foo' with a taint with key 'dedicated' and value " +#~ "'special-user' and effect 'NoSchedule'.\n" +#~ "\t\t# If a taint with that key and effect already exists, its value is " +#~ "replaced as specified.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +#~ "'NoSchedule' if one exists.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Atualiza a restrição para a chave 'dedicated' e o valor 'special-" +#~ "user' e o efeito 'NoSchedule' para o node 'foo'.\n" +#~ "\t\t# Se o taint com esta chave e efeito já existirem, o seu valor é " +#~ "substituído pelo especificado.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Remove a restrição com a chave 'dedicated' e efeito 'NoSchedule' do " +#~ "nodo 'foo' se existir.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Remove o node 'foo' todos os taints com a chave 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +#~ "overwriting any existing value.\n" +#~ "\t\tkubectl label --overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update all pods in the namespace\n" +#~ "\t\tkubectl label pods --all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ "\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' by removing a label named 'bar' if it exists.\n" +#~ "\t\t# Does not require the --overwrite flag.\n" +#~ "\t\tkubectl label pods foo bar-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Atualiza o pod 'foo' com o label 'unhealthy' e valor 'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Atualiza o pod 'foo' com o label 'status' e valor 'unhealthy', " +#~ "sobrescrevendo qualquer valor existente.\n" +#~ "\t\tkubectl label —overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Atualiza todos os pods no namespace corrente\n" +#~ "\t\tkubectl label pods —all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Atualiza o pod identificado pelo tipo e nome em \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Atualiza o pod 'foo' apenas se o recurso não foi modificado na " +#~ "versão 1.\n" +#~ "\t\tkubectl label pods foo status=unhealthy —resource-version=1\n" +#~ "\n" +#~ "\t\t# Atualiza o pod 'foo' removendo o label chamado 'bar', se ele " +#~ "existir.\n" +#~ "\t\t# Não necessita a flag —overwrite.\n" +#~ "\t\tkubectl label pods foo bar-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using new replication controller data in " +#~ "frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using JSON data passed into stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend-v1 to frontend-v2 by just changing the " +#~ "image, and switching the\n" +#~ "\t\t# name of the replication controller.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend by just changing the image, and keeping " +#~ "the old name.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Abort and reverse an existing rollout in progress (from frontend-v1 " +#~ "to frontend-v2).\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Atualiza os pods de frontend-v1 utilizando os dados do novo " +#~ "replication controller definido em frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Atualiza os pods do frontend-v1 utilizando os dados em JSON " +#~ "passados pelo stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Atualiza os pods do frontend-v1 para frontend-v2 trocando a imagem, " +#~ "e trocando o\n" +#~ "\t\t# nome do replication controller.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Atualiza os pods do frontend trocando a imagem, e mantendo o nome " +#~ "antigo.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Cancela e reverte um rollout existente em progresso (de frontend-v1 " +#~ "para frontend-v2).\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" + +#~ msgid "" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by type/name in " +#~ "YAML.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by file in JSON\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Visualiza a anotação last-applied-configuration pelo tipo/nome no " +#~ "YAML.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# Visualiza a anotação last-applied-configuration no arquivo JSON\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" + +#~ msgid "" +#~ "\n" +#~ "\t\tApply a configuration to a resource by filename or stdin.\n" +#~ "\t\tThis resource will be created if it doesn't exist yet.\n" +#~ "\t\tTo use 'apply', always create the resource initially with either " +#~ "'apply' or 'create --save-config'.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do " +#~ "not use unless you are aware of what the current state is. See https://" +#~ "issues.k8s.io/34274." +#~ msgstr "" +#~ "\n" +#~ "\t\tAplica a configuração em um recurso usando um nome de arquivo ou " +#~ "stdin.\n" +#~ "\t\tEste recurso será criado se ele não existir.\n" +#~ "\t\tPara utilizar o 'apply', sempre crie o recurso inicialmente com " +#~ "'apply' ou 'create --save-config'.\n" +#~ "\n" +#~ "\t\tFormatos JSON e YAML são aceitos.\n" +#~ "\n" +#~ "\t\tNota Alpha: a funcionalidade --prune não está completa. Não utilize a " +#~ "não ser que você saibe qual é o estado corrente. Veja https://issues.k8s." +#~ "io/34274." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um ClusterRole." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRoleBinding for a particular ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um ClusterRoleBinding para um ClusterRole específico." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a RoleBinding for a particular Role or ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria uma RoleBinding para uma Role específica ou ClusterRole." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a TLS secret from the given public/private key pair.\n" +#~ "\n" +#~ "\t\tThe public/private key pair must exist before hand. The public key " +#~ "certificate must be .PEM encoded and match the given private key." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um TLS secret de uma chave pública/privada fornecida.\n" +#~ "\n" +#~ "\t\tA chave pública/privada deve existir antes. O certificado da chave " +#~ "deve ser codificada como PEM, e ter sido gerada pela chave privada." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a configmap based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single configmap may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a file, the key will default to " +#~ "the basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a directory, each file whose " +#~ "basename is a valid key in the directory will be\n" +#~ "\t\tpackaged into the configmap. Any directory entries except regular " +#~ "files are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um configmap com base em um arquivo, diretório, ou um valor " +#~ "literal especificado.\n" +#~ "\n" +#~ "\t\tUm configmap único pode conter um ou mais pares de chave/valor.\n" +#~ "\n" +#~ "\t\tQuando criar um configmap com base em um arquivo, a chave será por " +#~ "padrão o nome do arquivo, e o valor será\n" +#~ "\t\tpor padrão o conteúdo do arquivo. Se o nome do arquivo for uma chave " +#~ "inválida, você deve especificar uma chave alternativa.\n" +#~ "\n" +#~ "\t\tQuando criar um configmap com base em um diretório, cada arquivo cujo " +#~ "o nome é uma chave válida no diretório será\n" +#~ "\t\tcolocada no configmap. Qualquer entrada de diretório, exceto as com " +#~ "arquivos válidos serão ignorados (por exemplo: sub-diretórios,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a new secret for use with Docker registries.\n" +#~ "\n" +#~ "\t\tDockercfg secrets are used to authenticate against Docker " +#~ "registries.\n" +#~ "\n" +#~ "\t\tWhen using the Docker command line to push images, you can " +#~ "authenticate to a given registry by running\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +#~ "password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " That produces a ~/.dockercfg file that is used by subsequent 'docker " +#~ "push' and 'docker pull' commands to\n" +#~ "\t\tauthenticate to the registry. The email address is optional.\n" +#~ "\n" +#~ "\t\tWhen creating applications, you may have a Docker registry that " +#~ "requires authentication. In order for the\n" +#~ "\t\tnodes to pull images on your behalf, they have to have the " +#~ "credentials. You can provide this information\n" +#~ "\t\tby creating a dockercfg secret and attaching it to your service " +#~ "account." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um novo secret para utilizar com Docker registries.\n" +#~ "\n" +#~ "\t\tDockercfg secrets são utilizados para autenticar Docker registries.\n" +#~ "\n" +#~ "\t\tQuando utilizando a linha de comando do Docker para realizar envio " +#~ "das images, você pode se autenticar para um registro fornecido " +#~ "executando\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER —username=DOCKER_USER —" +#~ "password=DOCKER_PASSWORD —email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " Isso irá gerar um arquivo ~/.dockercfg que será utilizado para os " +#~ "comandos 'docker push' e 'docker pull' \n" +#~ "\t\tse autenticarem no registro. O endereço de email é opcional.\n" +#~ "\n" +#~ "\t\tQuando criar aplicações, você pode ter um Docker registry que requer " +#~ "autenticação. Para que \n" +#~ "\t\tos nodes possam baixar as imagens em seu nome, eles devem ter as " +#~ "credenciais. Você pode prover esta informação\n" +#~ "\t\tcriando um dockercfg secret e anexando-o à sua conta de serviço." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a pod disruption budget with the specified name, selector, and " +#~ "desired minimum available pods" +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um pod disruption budget com o nome especificado, seletor, e o " +#~ "número mínimo de pode disponíveis" + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um recurso por nome de arquivo ou stdin.\n" +#~ "\n" +#~ "\t\tOs formatos JSON e YAML são aceitos." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resourcequota with the specified name, hard limits and " +#~ "optional scopes" +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um resourcequota com o nome especificado, limits rigídos e " +#~ "escopo opcional" + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a secret based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single secret may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a file, the key will default to the " +#~ "basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a directory, each file whose basename " +#~ "is a valid key in the directory will be\n" +#~ "\t\tpackaged into the secret. Any directory entries except regular files " +#~ "are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um secret com base em um arquivo, diretório, ou um valor literal " +#~ "especificado.\n" +#~ "\n" +#~ "\t\tUm secret único pode conter um ou mais pares de chave/valor.\n" +#~ "\n" +#~ "\t\tQuando criar um secret com base em um arquivo, a chave será por " +#~ "padrão o nome do arquivo, e o valor será\n" +#~ "\t\tpor padrão o conteúdo do arquivo. Se o nome do arquivo for uma chave " +#~ "inválida, você deve especificar uma chave alternativa.\n" +#~ "\n" +#~ "\t\tQuando criar um secret com base em um diretório, cada arquivo cujo o " +#~ "nome é uma chave válida no diretório será\n" +#~ "\t\tcolocada no configmap. Qualquer entrada de diretório, exceto as com " +#~ "arquivos válidos serão ignorados (por exemplo: sub-diretórios,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate and run a particular image, possibly replicated.\n" +#~ "\n" +#~ "\t\tCreates a deployment or job to manage the created container(s)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria e executa uma imagem específica, possivelmente replicada.\n" +#~ "\n" +#~ "\t\tCria um deployment ou job para gerenciar o(s) container(s) criado(s)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreates an autoscaler that automatically chooses and sets the number " +#~ "of pods that run in a kubernetes cluster.\n" +#~ "\n" +#~ "\t\tLooks up a Deployment, ReplicaSet, or ReplicationController by name " +#~ "and creates an autoscaler that uses the given resource as a reference.\n" +#~ "\t\tAn autoscaler can automatically increase or decrease number of pods " +#~ "deployed within the system as needed." +#~ msgstr "" +#~ "\n" +#~ "\t\tCria um autoscaler que automaticamente escolhe e configura quantos " +#~ "pods irão executar em um cluster kubernetes.\n" +#~ "\n" +#~ "\t\tProcura por um Deployment, ReplicaSet, ou ReplicationController por " +#~ "nome e cria um autoscaler que utiliza o recurso fornecido como " +#~ "referência.\n" +#~ "\t\tUm autoscaler pode automaticamente aumentar ou reduzir o número de " +#~ "pods quando necessário." + +#~ msgid "" +#~ "\n" +#~ "\t\tDelete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. Only one type of the arguments " +#~ "may be specified: filenames,\n" +#~ "\t\tresources and names, or resources and label selector.\n" +#~ "\n" +#~ "\t\tSome resources, such as pods, support graceful deletion. These " +#~ "resources define a default period\n" +#~ "\t\tbefore they are forcibly terminated (the grace period) but you may " +#~ "override that value with\n" +#~ "\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +#~ "Because these resources often\n" +#~ "\t\trepresent entities in the cluster, deletion may not be acknowledged " +#~ "immediately. If the node\n" +#~ "\t\thosting a pod is down or cannot reach the API server, termination may " +#~ "take significantly longer\n" +#~ "\t\tthan the grace period. To force delete a resource,\tyou must pass a " +#~ "grace\tperiod of 0 and specify\n" +#~ "\t\tthe --force flag.\n" +#~ "\n" +#~ "\t\tIMPORTANT: Force deleting pods does not wait for confirmation that " +#~ "the pod's processes have been\n" +#~ "\t\tterminated, which can leave those processes running until the node " +#~ "detects the deletion and\n" +#~ "\t\tcompletes graceful deletion. If your processes use shared storage or " +#~ "talk to a remote API and\n" +#~ "\t\tdepend on the name of the pod to identify themselves, force deleting " +#~ "those pods may result in\n" +#~ "\t\tmultiple processes running on different machines using the same " +#~ "identification which may lead\n" +#~ "\t\tto data corruption or inconsistency. Only force delete pods when you " +#~ "are sure the pod is\n" +#~ "\t\tterminated, or if your application can tolerate multiple copies of " +#~ "the same pod running at once.\n" +#~ "\t\tAlso, if you force delete pods the scheduler may place new pods on " +#~ "those nodes before the node\n" +#~ "\t\thas released those resources and causing those pods to be evicted " +#~ "immediately.\n" +#~ "\n" +#~ "\t\tNote that the delete command does NOT do resource version checks, so " +#~ "if someone\n" +#~ "\t\tsubmits an update to a resource right when you submit a delete, their " +#~ "update\n" +#~ "\t\twill be lost along with the rest of the resource." +#~ msgstr "" +#~ "\n" +#~ "\t\tDelete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. Only one type of the arguments " +#~ "may be specified: filenames,\n" +#~ "\t\tresources and names, or resources and label selector.\n" +#~ "\n" +#~ "\t\tSome resources, such as pods, support graceful deletion. These " +#~ "resources define a default period\n" +#~ "\t\tbefore they are forcibly terminated (the grace period) but you may " +#~ "override that value with\n" +#~ "\t\tthe —grace-period flag, or pass —now to set a grace-period of 1. " +#~ "Because these resources often\n" +#~ "\t\trepresent entities in the cluster, deletion may not be acknowledged " +#~ "immediately. If the node\n" +#~ "\t\thosting a pod is down or cannot reach the API server, termination may " +#~ "take significantly longer\n" +#~ "\t\tthan the grace period. To force delete a resource,\tyou must pass a " +#~ "grace\tperiod of 0 and specify\n" +#~ "\t\tthe —force flag.\n" +#~ "\n" +#~ "\t\tIMPORTANT: Force deleting pods does not wait for confirmation that " +#~ "the pod's processes have been\n" +#~ "\t\tterminated, which can leave those processes running until the node " +#~ "detects the deletion and\n" +#~ "\t\tcompletes graceful deletion. If your processes use shared storage or " +#~ "talk to a remote API and\n" +#~ "\t\tdepend on the name of the pod to identify themselves, force deleting " +#~ "those pods may result in\n" +#~ "\t\tmultiple processes running on different machines using the same " +#~ "identification which may lead\n" +#~ "\t\tto data corruption or inconsistency. Only force delete pods when you " +#~ "are sure the pod is\n" +#~ "\t\tterminated, or if your application can tolerate multiple copies of " +#~ "the same pod running at once.\n" +#~ "\t\tAlso, if you force delete pods the scheduler may place new pods on " +#~ "those nodes before the node\n" +#~ "\t\thas released those resources and causing those pods to be evicted " +#~ "immediately.\n" +#~ "\n" +#~ "\t\tNote that the delete command does NOT do resource version checks, so " +#~ "if someone\n" +#~ "\t\tsubmits an update to a resource right when you submit a delete, their " +#~ "update\n" +#~ "\t\twill be lost along with the rest of the resource." + +#~ msgid "" +#~ "\n" +#~ "\t\tDeprecated: Gracefully shut down a resource by name or filename.\n" +#~ "\n" +#~ "\t\tThe stop command is deprecated, all its functionalities are covered " +#~ "by delete command.\n" +#~ "\t\tSee 'kubectl delete --help' for more details.\n" +#~ "\n" +#~ "\t\tAttempts to shut down and delete a resource that supports graceful " +#~ "termination.\n" +#~ "\t\tIf the resource is scalable it will be scaled to 0 before deletion." +#~ msgstr "" +#~ "\n" +#~ "\t\tDeprecated: Gracefully shut down a resource by name or filename.\n" +#~ "\n" +#~ "\t\tThe stop command is deprecated, all its functionalities are covered " +#~ "by delete command.\n" +#~ "\t\tSee 'kubectl delete —help' for more details.\n" +#~ "\n" +#~ "\t\tAttempts to shut down and delete a resource that supports graceful " +#~ "termination.\n" +#~ "\t\tIf the resource is scalable it will be scaled to 0 before deletion." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of nodes.\n" +#~ "\n" +#~ "\t\tThe top-node command allows you to see the resource consumption of " +#~ "nodes." +#~ msgstr "" +#~ "\n" +#~ "\t\tMostra os Recursos (CPU/Memória/Armazenamento) utilizados nos nodes.\n" +#~ "\n" +#~ "\t\tO comando top-node permite que você veja o consumo de recursos dos " +#~ "nodes." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of pods.\n" +#~ "\n" +#~ "\t\tThe 'top pod' command allows you to see the resource consumption of " +#~ "pods.\n" +#~ "\n" +#~ "\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +#~ "minutes\n" +#~ "\t\tsince pod creation." +#~ msgstr "" +#~ "\n" +#~ "\t\tMostra a utilização de recursos dos pods (CPU/Memória/" +#~ "Armazenamento).\n" +#~ "\n" +#~ "\t\tO comando 'top pod' deixa você ver a utilização dos recusrsos dos " +#~ "pods.\n" +#~ "\n" +#~ "\t\tDevido ao atraso da pipeline de métricas, o resultado pode estar " +#~ "indisponível por alguns minutos\n" +#~ "\t\tdesde a criação do pod." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage.\n" +#~ "\n" +#~ "\t\tThe top command allows you to see the resource consumption for nodes " +#~ "or pods.\n" +#~ "\n" +#~ "\t\tThis command requires Heapster to be correctly configured and working " +#~ "on the server. " +#~ msgstr "" +#~ "\n" +#~ "\t\tMostra a utilização de recursos (CPU/Memória/Armazenamento).\n" +#~ "\n" +#~ "\t\tO comando top deixa você ver a utilização de recursos de nodes e " +#~ "pods.\n" +#~ "\n" +#~ "\t\tEste comando necessita que o Heapster esteja corretamente configurado " +#~ "e rodando no servidor. " + +#~ msgid "" +#~ "\n" +#~ "\t\tDrain node in preparation for maintenance.\n" +#~ "\n" +#~ "\t\tThe given node will be marked unschedulable to prevent new pods from " +#~ "arriving.\n" +#~ "\t\t'drain' evicts the pods if the APIServer supports eviction\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Otherwise, it will " +#~ "use normal DELETE\n" +#~ "\t\tto delete the pods.\n" +#~ "\t\tThe 'drain' evicts or deletes all pods except mirror pods (which " +#~ "cannot be deleted through\n" +#~ "\t\tthe API server). If there are DaemonSet-managed pods, drain will not " +#~ "proceed\n" +#~ "\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +#~ "\t\tDaemonSet-managed pods, because those pods would be immediately " +#~ "replaced by the\n" +#~ "\t\tDaemonSet controller, which ignores unschedulable markings. If there " +#~ "are any\n" +#~ "\t\tpods that are neither mirror pods nor managed by " +#~ "ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet or Job, then drain will not delete " +#~ "any pods unless you\n" +#~ "\t\tuse --force. --force will also allow deletion to proceed if the " +#~ "managing resource of one\n" +#~ "\t\tor more pods is missing.\n" +#~ "\n" +#~ "\t\t'drain' waits for graceful termination. You should not operate on the " +#~ "machine until\n" +#~ "\t\tthe command completes.\n" +#~ "\n" +#~ "\t\tWhen you are ready to put the node back into service, use kubectl " +#~ "uncordon, which\n" +#~ "\t\twill make the node schedulable again.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\tDrain node in preparation for maintenance.\n" +#~ "\n" +#~ "\t\tThe given node will be marked unschedulable to prevent new pods from " +#~ "arriving.\n" +#~ "\t\t'drain' evicts the pods if the APIServer supports eviction\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Otherwise, it will " +#~ "use normal DELETE\n" +#~ "\t\tto delete the pods.\n" +#~ "\t\tThe 'drain' evicts or deletes all pods except mirror pods (which " +#~ "cannot be deleted through\n" +#~ "\t\tthe API server). If there are DaemonSet-managed pods, drain will not " +#~ "proceed\n" +#~ "\t\twithout —ignore-daemonsets, and regardless it will not delete any\n" +#~ "\t\tDaemonSet-managed pods, because those pods would be immediately " +#~ "replaced by the\n" +#~ "\t\tDaemonSet controller, which ignores unschedulable markings. If there " +#~ "are any\n" +#~ "\t\tpods that are neither mirror pods nor managed by " +#~ "ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet or Job, then drain will not delete " +#~ "any pods unless you\n" +#~ "\t\tuse —force. —force will also allow deletion to proceed if the " +#~ "managing resource of one\n" +#~ "\t\tor more pods is missing.\n" +#~ "\n" +#~ "\t\t'drain' waits for graceful termination. You should not operate on the " +#~ "machine until\n" +#~ "\t\tthe command completes.\n" +#~ "\n" +#~ "\t\tWhen you are ready to put the node back into service, use kubectl " +#~ "uncordon, which\n" +#~ "\t\twill make the node schedulable again.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tEdit a resource from the default editor.\n" +#~ "\n" +#~ "\t\tThe edit command allows you to directly edit any API resource you can " +#~ "retrieve via the\n" +#~ "\t\tcommand line tools. It will open the editor defined by your " +#~ "KUBE_EDITOR, or EDITOR\n" +#~ "\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' " +#~ "for Windows.\n" +#~ "\t\tYou can edit multiple objects, although changes are applied one at a " +#~ "time. The command\n" +#~ "\t\taccepts filenames as well as command line arguments, although the " +#~ "files you point to must\n" +#~ "\t\tbe previously saved versions of resources.\n" +#~ "\n" +#~ "\t\tEditing is done with the API version used to fetch the resource.\n" +#~ "\t\tTo edit using a specific API version, fully-qualify the resource, " +#~ "version, and group.\n" +#~ "\n" +#~ "\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +#~ "\n" +#~ "\t\tThe flag --windows-line-endings can be used to force Windows line " +#~ "endings,\n" +#~ "\t\totherwise the default for your operating system will be used.\n" +#~ "\n" +#~ "\t\tIn the event an error occurs while updating, a temporary file will be " +#~ "created on disk\n" +#~ "\t\tthat contains your unapplied changes. The most common error when " +#~ "updating a resource\n" +#~ "\t\tis another editor changing the resource on the server. When this " +#~ "occurs, you will have\n" +#~ "\t\tto apply your changes to the newer version of the resource, or update " +#~ "your temporary\n" +#~ "\t\tsaved copy to include the latest resource version." +#~ msgstr "" +#~ "\n" +#~ "\t\tEdit a resource from the default editor.\n" +#~ "\n" +#~ "\t\tThe edit command allows you to directly edit any API resource you can " +#~ "retrieve via the\n" +#~ "\t\tcommand line tools. It will open the editor defined by your " +#~ "KUBE_EDITOR, or EDITOR\n" +#~ "\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' " +#~ "for Windows.\n" +#~ "\t\tYou can edit multiple objects, although changes are applied one at a " +#~ "time. The command\n" +#~ "\t\taccepts filenames as well as command line arguments, although the " +#~ "files you point to must\n" +#~ "\t\tbe previously saved versions of resources.\n" +#~ "\n" +#~ "\t\tEditing is done with the API version used to fetch the resource.\n" +#~ "\t\tTo edit using a specific API version, fully-qualify the resource, " +#~ "version, and group.\n" +#~ "\n" +#~ "\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +#~ "\n" +#~ "\t\tThe flag —windows-line-endings can be used to force Windows line " +#~ "endings,\n" +#~ "\t\totherwise the default for your operating system will be used.\n" +#~ "\n" +#~ "\t\tIn the event an error occurs while updating, a temporary file will be " +#~ "created on disk\n" +#~ "\t\tthat contains your unapplied changes. The most common error when " +#~ "updating a resource\n" +#~ "\t\tis another editor changing the resource on the server. When this " +#~ "occurs, you will have\n" +#~ "\t\tto apply your changes to the newer version of the resource, or update " +#~ "your temporary\n" +#~ "\t\tsaved copy to include the latest resource version." + +#~ msgid "" +#~ "\n" +#~ "\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +#~ "\t\tThe shell code must be evaluated to provide interactive\n" +#~ "\t\tcompletion of kubectl commands. This can be done by sourcing it " +#~ "from\n" +#~ "\t\tthe .bash_profile.\n" +#~ "\n" +#~ "\t\tNote: this requires the bash-completion framework, which is not " +#~ "installed\n" +#~ "\t\tby default on Mac. This can be installed by using homebrew:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tOnce installed, bash_completion must be evaluated. This can be done " +#~ "by adding the\n" +#~ "\t\tfollowing line to the .bash_profile\n" +#~ "\n" +#~ "\t\t $ source $(brew --prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tNote for zsh users: [1] zsh completions are only supported in " +#~ "versions of zsh >= 5.2" +#~ msgstr "" +#~ "\n" +#~ "\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +#~ "\t\tThe shell code must be evaluated to provide interactive\n" +#~ "\t\tcompletion of kubectl commands. This can be done by sourcing it " +#~ "from\n" +#~ "\t\tthe .bash_profile.\n" +#~ "\n" +#~ "\t\tNote: this requires the bash-completion framework, which is not " +#~ "installed\n" +#~ "\t\tby default on Mac. This can be installed by using homebrew:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tOnce installed, bash_completion must be evaluated. This can be done " +#~ "by adding the\n" +#~ "\t\tfollowing line to the .bash_profile\n" +#~ "\n" +#~ "\t\t $ source $(brew —prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tNote for zsh users: [1] zsh completions are only supported in " +#~ "versions of zsh >= 5.2" + +#~ msgid "" +#~ "\n" +#~ "\t\tPerform a rolling update of the given ReplicationController.\n" +#~ "\n" +#~ "\t\tReplaces the specified replication controller with a new replication " +#~ "controller by updating one pod at a time to use the\n" +#~ "\t\tnew PodTemplate. The new-controller.json must specify the same " +#~ "namespace as the\n" +#~ "\t\texisting replication controller and overwrite at least one (common) " +#~ "label in its replicaSelector.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\tAplica uma atualização contínua em um ReplicationController.\n" +#~ "\n" +#~ "\t\tTroca o replication controller especificado por um novo replication " +#~ "controller atualizando um pod por vez para utilizar o\n" +#~ "\t\tnovo PodTemplate. O new-controller.json deve ser especificado no " +#~ "mesmo namespace que o\n" +#~ "\t\treplication controller existente e sobrescrever pelo menos uma label " +#~ "comum no seu replicaSelector.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tReplace a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. If replacing an existing " +#~ "resource, the\n" +#~ "\t\tcomplete resource spec must be provided. This can be obtained by\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." +#~ msgstr "" +#~ "\n" +#~ "\t\tSubstitui um recurso pelo especificado em um arquivo ou via stdin.\n" +#~ "\n" +#~ "\t\tOs formatos JSON and YAML são aceitos. Quando substituindo recursos " +#~ "existentes,\n" +#~ "\t\t especificação completa do recurso deve ser fornecida. Isto pode ser " +#~ "obtido com\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" +#~ "\n" +#~ "\t\tConsulte os modelos em https://htmlpreview.github.io/?https://github." +#~ "com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions." +#~ "html para descobrir se um campo é mutável." + +#~ msgid "" +#~ "\n" +#~ "\t\tSet a new size for a Deployment, ReplicaSet, Replication Controller, " +#~ "or Job.\n" +#~ "\n" +#~ "\t\tScale also allows users to specify one or more preconditions for the " +#~ "scale action.\n" +#~ "\n" +#~ "\t\tIf --current-replicas or --resource-version is specified, it is " +#~ "validated before the\n" +#~ "\t\tscale is attempted, and it is guaranteed that the precondition holds " +#~ "true when the\n" +#~ "\t\tscale is sent to the server." +#~ msgstr "" +#~ "\n" +#~ "\t\tDefine um novo tamanho para um Deployment, ReplicaSet, Replication " +#~ "Controller, ou Job.\n" +#~ "\n" +#~ "\t\tScale deixa os usuários especificar uma ou mais pre-condições para a " +#~ "ação de scale.\n" +#~ "\n" +#~ "\t\tSe --current-replicas ou --resource-version forem especificados, será " +#~ "validado antes\n" +#~ "\t\tda tentativa de scale, e garante que a pre-condição é verdadeira " +#~ "quando\n" +#~ "\t\to scale é enviado para o servidor." + +#~ msgid "" +#~ "\n" +#~ "\t\tTo proxy all of the kubernetes api and nothing else, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/\n" +#~ "\n" +#~ "\t\tTo proxy only part of the kubernetes api and also some static files:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-" +#~ "prefix=/api/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/api/v1/pods'.\n" +#~ "\n" +#~ "\t\tTo proxy the entire kubernetes api at a different root, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/custom/api/v1/pods'" +#~ msgstr "" +#~ "\n" +#~ "\t\tPara fazer o proxy the todas as apis do kubernetes, utilize:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy —api-prefix=/\n" +#~ "\n" +#~ "\t\tPara fazer o proxy de parte da api do kubernetes e alguns arquivos " +#~ "estáticos:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy —www=/my/files —www-prefix=/static/ —api-prefix=/" +#~ "api/\n" +#~ "\n" +#~ "\t\tCom os comandos acima você pode fazer 'curl localhost:8001/api/v1/" +#~ "pods'.\n" +#~ "\n" +#~ "\t\tPara fazer o proxy the todas as apis do kubernetes em um caminho " +#~ "diferente, utilize:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy —api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tCom o comando acima você pode fazer 'curl localhost:8001/custom/api/" +#~ "v1/pods'" + +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate field(s) of a resource using strategic merge patch\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tPlease refer to the models in https://htmlpreview.github.io/?https://" +#~ "github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/" +#~ "definitions.html to find if a field is mutable." +#~ msgstr "" +#~ "\n" +#~ "\t\tAtualiza o(s) campo(s) de um recurso usando strategic merge patch\n" +#~ "\n" +#~ "\t\tFormatos JSON e YAML são aceitos.\n" +#~ "\n" +#~ "\t\tConsulte os modelos em https://htmlpreview.github.io/?https://github." +#~ "com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions." +#~ "html para descobrir se um campo é mutável." + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate the labels on a resource.\n" +#~ "\n" +#~ "\t\t* A label must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* If --overwrite is true, then existing labels can be overwritten, " +#~ "otherwise attempting to overwrite a label will result in an error.\n" +#~ "\t\t* If --resource-version is specified, then updates will use this " +#~ "resource version, otherwise the existing resource-version will be used." +#~ msgstr "" +#~ "\n" +#~ "\t\tAtualiza labels em um recurso.\n" +#~ "\n" +#~ "\t\t* Um label deve começar com uma letra ou número, e pode conter letra, " +#~ "números, hífens, pontos e sublinhados, com no máximo %[1]d caracteres.\n" +#~ "\t\t* Se --overwrite for verdadeiro, então labels podem ser " +#~ "sobreescritos, caso contrário a sobreescrita irá falhar.\n" +#~ "\t\t* Se --resource-version for especificado, então as atualizações " +#~ "usarão esta versão do recurso, caso contrário, a versão do recurso " +#~ "existente será usada." + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate the taints on one or more nodes.\n" +#~ "\n" +#~ "\t\t* A taint consists of a key, value, and effect. As an argument here, " +#~ "it is expressed as key=value:effect.\n" +#~ "\t\t* The key must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* The value must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[2]d " +#~ "characters.\n" +#~ "\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +#~ "\t\t* Currently taint can only apply to node." +#~ msgstr "" +#~ "\n" +#~ "\t\tAtualiza os taints em um ou mais nodes.\n" +#~ "\n" +#~ "\t\t* Um taint consiste em uma chave, valor e efeito. Como arqgumento, é " +#~ "expressado como chave=valor:efeito.\n" +#~ "\t\t* Uma chave deve começar com uma letra ou número, e pode conter " +#~ "letras, números, hífens, pontos e sublinhados, com no máximo %[1]d " +#~ "caractéres.\n" +#~ "\t\t* Um valor deve começar com uma letra ou número, e pode conter " +#~ "letras, números, hífens, pontos e sublinhados, com no máximo %[2]d " +#~ "caractéres.\n" +#~ "\t\t* O efeito deve ser NoSchedule, PreferNoSchedule ou NoExecute.\n" +#~ "\t\t* Atualmente taint pode ser aplicado apenas para nodes." + +#~ msgid "" +#~ "\n" +#~ "\t\tView the latest last-applied-configuration annotations by type/name " +#~ "or file.\n" +#~ "\n" +#~ "\t\tThe default output will be printed to stdout in YAML format. One can " +#~ "use -o option\n" +#~ "\t\tto change output format." +#~ msgstr "" +#~ "\n" +#~ "\t\tView the latest last-applied-configuration annotations by type/name " +#~ "or file.\n" +#~ "\n" +#~ "\t\tThe default output will be printed to stdout in YAML format. One can " +#~ "use -o option\n" +#~ "\t\tto change output format." + +#~ msgid "" +#~ "\n" +#~ "\t # !!!Important Note!!!\n" +#~ "\t # Requires that the 'tar' binary is present in your container\n" +#~ "\t # image. If 'tar' is not present, 'kubectl cp' will fail.\n" +#~ "\n" +#~ "\t # Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod " +#~ "in the default namespace\n" +#~ "\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +#~ "\n" +#~ " # Copy /tmp/foo local file to /tmp/bar in a remote pod in a " +#~ "specific container\n" +#~ "\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +#~ "\n" +#~ "\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +#~ "\t\tkubectl cp /:/tmp/foo /tmp/bar" +#~ msgstr "" +#~ "\n" +#~ "\t # !!!Nota Importante!!!\n" +#~ "\t # Necessita que o binário 'tar' esteja presente na imagem do\n" +#~ "\t # container. Se 'tar' não estiver presente, o 'kubectl cp' irá " +#~ "falhar.\n" +#~ "\n" +#~ "\t # Copia o diretório local /tmp/foo_dir para /tmp/bar_dir no pod " +#~ "remoto no namespace default\n" +#~ "\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +#~ "\n" +#~ " # Copia o arquivo local /tmp/foo para /tmp/bar no pod remoto no " +#~ "container específico\n" +#~ "\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +#~ "\n" +#~ "\t\t# Copia o arquivo local /tmp/foo para /tmp/bar no pod remoto no " +#~ "namespace \n" +#~ "\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +#~ "\n" +#~ "\t\t# Copia /tmp/foo do pod remoto para /tmp/bar localmente\n" +#~ "\t\tkubectl cp /:/tmp/foo /tmp/bar" + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new TLS secret named tls-secret with the given key pair:\n" +#~ "\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --" +#~ "key=path/to/tls.key" +#~ msgstr "" +#~ "\n" +#~ "\t # Cria um novo segredo TLS chamado tls-secret com o par the chaves " +#~ "fornecido:\n" +#~ "\t kubectl create secret tls tls-secret —cert=path/to/tls.cert —key=path/" +#~ "to/tls.key" + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new secret named my-secret with keys for each file in " +#~ "folder bar\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with specified keys instead of " +#~ "names on disk\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with key1=supersecret and " +#~ "key2=topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" +#~ msgstr "" +#~ "\n" +#~ "\t # Cria um novo segredo chamado my-secret com as chaves para cada " +#~ "arquivo no diretório bar\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Cria um novo segredo chamado my-secret com chaves especificadas em " +#~ "vez dos nomes dos arquivos\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Cria um novo segredo chamado my-secret com key1=supersecret e " +#~ "key2=topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" + +#~ msgid "" +#~ "\n" +#~ "\t# Create a new ExternalName service named my-ns \n" +#~ "\tkubectl create service externalname my-ns --external-name bar.com" +#~ msgstr "" +#~ "\n" +#~ "\t# Cria um novo serviço do tipo ExternalName chamado my-ns \n" +#~ "\tkubectl create service externalname my-ns —external-name bar.com" + +#~ msgid "" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs (in headless mode)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" +#~ msgstr "" +#~ "\n" +#~ " # Cria um novo serviço clusterIP chamado my-cs\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # Cria um novo serviço clusterIP chamado my-cs (em modo headless)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" + +#~ msgid "" +#~ "\n" +#~ " # Create a new deployment named my-dep that runs the busybox image.\n" +#~ " kubectl create deployment my-dep --image=busybox" +#~ msgstr "" +#~ "\n" +#~ " # Cria um novo deployment chamado my-dep que executa uma imagem " +#~ "busybox.\n" +#~ " kubectl create deployment my-dep —image=busybox" + +#~ msgid "" +#~ "\n" +#~ " # Create a new nodeport service named my-ns\n" +#~ " kubectl create service nodeport my-ns --tcp=5678:8080" +#~ msgstr "" +#~ "\n" +#~ " # Cria um novo serviço nodeport chamado my-ns\n" +#~ " kubectl create service nodeport my-ns —tcp=5678:8080" + +#~ msgid "" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend'.\n" +#~ " # If the same annotation is set multiple times, only the last value " +#~ "will be applied\n" +#~ " kubectl annotate pods foo description='my frontend'\n" +#~ "\n" +#~ " # Update a pod identified by type and name in \"pod.json\"\n" +#~ " kubectl annotate -f pod.json description='my frontend'\n" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend running nginx', overwriting any existing value.\n" +#~ " kubectl annotate --overwrite pods foo description='my frontend " +#~ "running nginx'\n" +#~ "\n" +#~ " # Update all pods in the namespace\n" +#~ " kubectl annotate pods --all description='my frontend running nginx'\n" +#~ "\n" +#~ " # Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ " kubectl annotate pods foo description='my frontend running nginx' --" +#~ "resource-version=1\n" +#~ "\n" +#~ " # Update pod 'foo' by removing an annotation named 'description' if " +#~ "it exists.\n" +#~ " # Does not require the --overwrite flag.\n" +#~ " kubectl annotate pods foo description-" +#~ msgstr "" +#~ "\n" +#~ " # Atualiza o pod 'foo' com a annotation 'description' e o valor 'my " +#~ "frontend'.\n" +#~ " # Se a mesma annotation é configurada várias vezes, apenas o último " +#~ "valor será utilizado\n" +#~ " kubectl annotate pods foo description='my frontend'\n" +#~ "\n" +#~ " # Atualiza o pod identificado pelo tipo e nome definido no \"pod.json" +#~ "\"\n" +#~ " kubectl annotate -f pod.json description='my frontend'\n" +#~ "\n" +#~ " # Atualiza o pod 'foo' com a annotation 'description' e o valor 'my " +#~ "frontend running nginx', sobreescrevendo qualquer valor existente.\n" +#~ " kubectl annotate --overwrite pods foo description='my frontend " +#~ "running nginx'\n" +#~ "\n" +#~ " # Atualiza todos os pods no namespace\n" +#~ " kubectl annotate pods --all description='my frontend running nginx'\n" +#~ "\n" +#~ " # Atualiza o pod 'foo' apenas se o recurso não foi modificado na " +#~ "versão 1.\n" +#~ " kubectl annotate pods foo description='my frontend running nginx' --" +#~ "resource-version=1\n" +#~ "\n" +#~ " # Atualiza o pod 'foo' removendo a annotation chamada 'description' " +#~ "se ela existir.\n" +#~ " # Não necessita da flag --overwrite.\n" +#~ " kubectl annotate pods foo description-" + +#~ msgid "" +#~ "\n" +#~ " Create a clusterIP service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Cria um serviço do tipo clusterIP com o nome especificado." + +#~ msgid "" +#~ "\n" +#~ " Create a deployment with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Cria um deployment com o nome especificado." + +#~ msgid "" +#~ "\n" +#~ " Create a nodeport service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " Cria um serviço do tipo nodeport com o nome especificado." + +#~ msgid "" +#~ "\n" +#~ " Dumps cluster info out suitable for debugging and diagnosing cluster " +#~ "problems. By default, dumps everything to\n" +#~ " stdout. You can optionally specify a directory with --output-" +#~ "directory. If you specify a directory, kubernetes will\n" +#~ " build a set of files in that directory. By default only dumps things " +#~ "in the 'kube-system' namespace, but you can\n" +#~ " switch to a different namespace with the --namespaces flag, or " +#~ "specify --all-namespaces to dump all namespaces.\n" +#~ "\n" +#~ " The command also dumps the logs of all of the pods in the cluster, " +#~ "these logs are dumped into different directories\n" +#~ " based on namespace and pod name." +#~ msgstr "" +#~ "\n" +#~ " Coleta informações do cluster para debugar e diagnosticar problemas " +#~ "do dele. Por padrão, exibe tudo para o\n" +#~ " stdout. Você pode, se quiser, especificar um diretório com --output-" +#~ "directory. Se especificar o diretório, kubernetes irá\n" +#~ " montar um conjunto de arquivos no diretório. Por padrão, apenas " +#~ "coleta informações no namespace 'kube-system' , mas você pode\n" +#~ " trocar para um namespace diferente com a flag --namespaces, ou " +#~ "especificar --all-namespaces para todos os namespaces.\n" +#~ "\n" +#~ " O comando também coleta os logs de todos os pods no cluster, estes " +#~ "logs são salvos em outros diretórios\n" +#~ " baseado no namespace e nome do pod." + +#~ msgid "" +#~ "\n" +#~ " Display addresses of the master and services with label kubernetes.io/" +#~ "cluster-service=true\n" +#~ " To further debug and diagnose cluster problems, use 'kubectl cluster-" +#~ "info dump'." +#~ msgstr "" +#~ "\n" +#~ " Mostra os endereços dos servidores de gerenciamento e serviços com o " +#~ "label kubernetes.io/cluster-service=true\n" +#~ " Para debugar e diagnosticar outros problemas do cluster, utilize " +#~ "'kubectl cluster-info dump'." + +#~ msgid "A schedule in the Cron format the job should be run with." +#~ msgstr "Agendamento no formato Cron em qual o job deve rodar." + +#~ msgid "" +#~ "An inline JSON override for the generated service object. If this is non-" +#~ "empty, it is used to override the generated object. Requires that the " +#~ "object supply a valid apiVersion field. Only used if --expose is true." +#~ msgstr "" +#~ "Uma substituição inline JSON para o objeto de serviço gerado. Se não " +#~ "estiver vazio, ele será usado para substituir o objeto gerado. Requer que " +#~ "o objeto forneça o campo apiVersion válido. Usado apenas se --expose for " +#~ "true." + +#~ msgid "Apply a configuration to a resource by filename or stdin" +#~ msgstr "" +#~ "Aplica a configuração para um recurso utilizado um nome de arquivo ou " +#~ "stdin" + +#~ msgid "Auto-scale a Deployment, ReplicaSet, or ReplicationController" +#~ msgstr "Auto-escala um Deployment, ReplicaSet ou ReplicationController" + +#~ msgid "" +#~ "Container name which will have its image upgraded. Only relevant when --" +#~ "image is specified, ignored otherwise. Required when using --image on a " +#~ "multi-container pod" +#~ msgstr "" +#~ "Nome do contêiner que terá sua imagem atualizada. Relevante apenas quando " +#~ "--image for especificado, caso contrário, ignorado. Obrigatório ao usar --" +#~ "image em um pod com vários contêineres" + +#~ msgid "Create a ClusterRoleBinding for a particular ClusterRole" +#~ msgstr "Cria um ClusterRoleBinding para um ClusterRole especifico" + +#~ msgid "Create a LoadBalancer service." +#~ msgstr "Cria um serviço do tipo LoadBalancer." + +#~ msgid "Create a NodePort service." +#~ msgstr "Cria um serviço do tipo NodePort." + +#~ msgid "Create a RoleBinding for a particular Role or ClusterRole" +#~ msgstr "Cria um RoleBinding para uma Role ou ClusterRole especifico" + +#~ msgid "Create a clusterIP service." +#~ msgstr "Cria um serviço do tipo clusterIP." + +#~ msgid "Create a configmap from a local file, directory or literal value" +#~ msgstr "" +#~ "Cria um configmap com base em um arquivo, diretório, ou um valor literal" + +#~ msgid "Create a deployment with the specified name." +#~ msgstr "Cria um deployment com um nome especificado." + +#~ msgid "Create a pod disruption budget with the specified name." +#~ msgstr "Cria um pod disruption budget com um nome especificado." + +#~ msgid "Create a quota with the specified name." +#~ msgstr "Cria uma quota com um nome especificado." + +#~ msgid "Create a resource by filename or stdin" +#~ msgstr "Cria um recurso por nome de arquivo ou stdin" + +#~ msgid "Create a secret from a local file, directory or literal value" +#~ msgstr "" +#~ "Cria um secret com base em um arquivo, diretório ou um valor literal" + +#~ msgid "Create a service using specified subcommand." +#~ msgstr "Cria um service utilizando um sub-comando especificado." + +#~ msgid "Create an ExternalName service." +#~ msgstr "Cria um serviço do tipo ExternalName." + +#~ msgid "" +#~ "Delete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector" +#~ msgstr "" +#~ "Apaga os recusros por nome de arquivos, stdin, recursos e nomes, ou por " +#~ "recursos e seletor de label" + +#~ msgid "Deprecated: Gracefully shut down a resource by name or filename" +#~ msgstr "Descontinuado: Termina um recurso por nome ou nome de arquivo" + +#~ msgid "Display Resource (CPU/Memory) usage of nodes" +#~ msgstr "Mostra a utilização de recursos (CPU/Memória) nos nodes" + +#~ msgid "Display Resource (CPU/Memory) usage of pods" +#~ msgstr "Mostra a utilização de recursos (CPU/Memória) nos pods" + +#~ msgid "Display Resource (CPU/Memory) usage." +#~ msgstr "Mostra a utilização de recursos (CPU/Memória)." + +#~ msgid "Display cluster info" +#~ msgstr "Mostra as informações do cluster" + +#~ msgid "Displays the current-context" +#~ msgstr "Mostra o contexto corrente" + +#~ msgid "Documentation of resources" +#~ msgstr "Documentação dos recursos" + +#~ msgid "Dump lots of relevant info for debugging and diagnosis" +#~ msgstr "" +#~ "Realiza o dump de muitas informações relevantes para debugging e " +#~ "diagnósticos" + +#~ msgid "" +#~ "Explicit policy for when to pull container images. Required when --image " +#~ "is same as existing image, ignored otherwise." +#~ msgstr "" +#~ "Política explícita para quando extrair imagens de contêiner. Obrigatório " +#~ "quando --image for igual à imagem existente, caso contrário, será " +#~ "ignorado." + +#~ msgid "" +#~ "IP to assign to the Load Balancer. If empty, an ephemeral IP will be " +#~ "created and used (cloud-provider specific)." +#~ msgstr "" +#~ "IP para ser alocado no Load Balancer. Se vazio, um IP efêmero será criado " +#~ "e utilizado (específico para cada provedor cloud)." + +#~ msgid "" +#~ "Image to use for upgrading the replication controller. Must be distinct " +#~ "from the existing image (either new image or new image tag). Can not be " +#~ "used with --filename/-f" +#~ msgstr "" +#~ "Imagem a ser utilizada para atualizar o replication controller. Deve ser " +#~ "diferente da imagem atual (pode ser uma nova imagem ou uma nova tag). Não " +#~ "pode ser utilizada com —filename/-f" + +#~ msgid "Manage a deployment rollout" +#~ msgstr "Gerencia um deployment rollout" + +#~ msgid "" +#~ "Output the formatted object with the given group version (for ex: " +#~ "'extensions/v1beta1').)" +#~ msgstr "" +#~ "Imprime o objeto formatado com a dada versão de grupo (por exemplo: " +#~ "'extensions/v1beta1').)" + +#~ msgid "Perform a rolling update of the given ReplicationController" +#~ msgstr "Executa uma atualização contínua" + +#~ msgid "Replace a resource by filename or stdin" +#~ msgstr "Substitui um recurso por um nome de arquivo ou stdin" + +#~ msgid "" +#~ "Set a new size for a Deployment, ReplicaSet, Replication Controller, or " +#~ "Job" +#~ msgstr "" +#~ "Define um novo tamanho para um Deployment, ReplicaSet, Replication " +#~ "Controller, ou Job" + +#~ msgid "" +#~ "Set the last-applied-configuration annotation on a live object to match " +#~ "the contents of a file." +#~ msgstr "" +#~ "Define a anotação last-applied-configuration em um objeto existente para " +#~ "corresponder ao conteúdo do arquivo." + +#~ msgid "Sets a cluster entry in kubeconfig" +#~ msgstr "Define um cluster no arquivo kubeconfig" + +#~ msgid "Sets a context entry in kubeconfig" +#~ msgstr "Define um contexto no arquivo kubeconfig" + +#~ msgid "Sets a user entry in kubeconfig" +#~ msgstr "Define um usuário no arquivo kubeconfig" + +#~ msgid "Sets an individual value in a kubeconfig file" +#~ msgstr "Define um valor individual no arquivo kubeconfig" + +#~ msgid "Sets the current-context in a kubeconfig file" +#~ msgstr "Define o current-context no arquivo kubeconfig" + +#~ msgid "" +#~ "Take a replication controller, service, deployment or pod and expose it " +#~ "as a new Kubernetes Service" +#~ msgstr "" +#~ "Pega um replication controlar, service, deployment ou pod e expõe como um " +#~ "novo Serviço do Kubernetes" + +#~ msgid "" +#~ "The key to use to differentiate between two different controllers, " +#~ "default 'deployment'. Only relevant when --image is specified, ignored " +#~ "otherwise" +#~ msgstr "" +#~ "A chave utilizada para diferenciar entre dois controlares diferentes, " +#~ "padrão 'deployment'. Apenas relevante quando --image é especificado, é " +#~ "ignorado caso contrário" + +#~ msgid "" +#~ "The name of the API generator to use, see http://kubernetes.io/docs/user-" +#~ "guide/kubectl-conventions/#generators for a list." +#~ msgstr "" +#~ "O nome do gerador de API a ser usado, veja a lista em http://kubernetes." +#~ "io/docs/user-guide/kubectl-conventions/#generators." + +#~ msgid "" +#~ "The name of the API generator to use. Currently there is only 1 generator." +#~ msgstr "" +#~ "O nome do gerador de API a ser usado. Atualmente existe apenas 1 gerador." + +#~ msgid "" +#~ "The name of the generator to use for creating a service. Only used if --" +#~ "expose is true" +#~ msgstr "" +#~ "O nome do recurso para ser utilizado quando criando um serviço. Apenas " +#~ "utilizado se —expose é verdadeiro" + +#~ msgid "" +#~ "The port that this container exposes. If --expose is true, this is also " +#~ "the port used by the service that is created." +#~ msgstr "" +#~ "A porta que o container expõe. Se —expose é verdadeiro, esta também é a " +#~ "porta utilizada pelo serviço quando for criado." + +#~ msgid "" +#~ "The restart policy for this Pod. Legal values [Always, OnFailure, " +#~ "Never]. If set to 'Always' a deployment is created, if set to " +#~ "'OnFailure' a job is created, if set to 'Never', a regular pod is " +#~ "created. For the latter two --replicas must be 1. Default 'Always', for " +#~ "CronJobs `Never`." +#~ msgstr "" +#~ "A politica de restart para este Pod. Possíveis valores [Always, " +#~ "OnFailure, Never]. Se configurado para 'Always' um deployment é criado, " +#~ "se configurado para 'OnFailure' um job é criado, se configurado para " +#~ "'Never', um pod é criado. Para os dois últimos —replicas deve ser 1. " +#~ "Valor padrão 'Always', para CronJobs `Never`." + +#~ msgid "" +#~ "Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is " +#~ "'ClusterIP'." +#~ msgstr "" +#~ "Tipo para este serviço: ClusterIP, NodePort, ou LoadBalancer. Valor " +#~ "padrão é 'ClusterIP'." + +#~ msgid "Unsets an individual value in a kubeconfig file" +#~ msgstr "Remover um valor individual do arquivo kubeconfig" + +#~ msgid "Update field(s) of a resource using strategic merge patch" +#~ msgstr "" +#~ "Atualizar o(s) campo(s) de um recurso usando a estratégia de merge patch" + +#~ msgid "Update image of a pod template" +#~ msgstr "Atualizar a imagem de um template de pod" + +#~ msgid "" +#~ "View latest last-applied-configuration annotations of a resource/object" +#~ msgstr "" +#~ "Visualizar a última anotação last-applied-configuration de um recurso/" +#~ "objeto" + +#~ msgid "external name of service" +#~ msgstr "nome externo do serviço" diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/template.pot b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/template.pot new file mode 100644 index 0000000000..8fd30a104b --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/template.pot @@ -0,0 +1,3183 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# FIRST AUTHOR , YEAR. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: \n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"Language: \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:138 +msgid "" +"\n" +"\t\t\t# Approve CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate approve csr-sqgzp\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:182 +msgid "" +"\n" +"\t\t\t# Deny CSR 'csr-sqgzp'\n" +"\t\t\tkubectl certificate deny csr-sqgzp\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:43 +msgid "" +"\n" +"\t\t\tModify kubeconfig files using subcommands like \"kubectl config set " +"current-context my-context\"\n" +"\n" +"\t\t\tThe loading order follows these rules:\n" +"\n" +"\t\t\t1. If the --" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:44 +msgid "" +"\n" +"\t\t # Create a cluster role binding for user1, user2, and group1 using the " +"cluster-admin cluster role\n" +"\t\t kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-" +"admin --user=user1 --user=user2 --group=group1" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:58 +msgid "" +"\n" +"\t\t # Create a new config map named my-config based on folder bar\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config with specified keys instead " +"of file basenames on disk\n" +"\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/file1." +"txt --from-file=key2=/path/to/bar/file2.txt\n" +"\n" +"\t\t # Create a new config map named my-config with key1=config1 and " +"key2=config2\n" +"\t\t kubectl create configmap my-config --from-literal=key1=config1 --from-" +"literal=key2=config2\n" +"\n" +"\t\t # Create a new config map named my-config from the key=value pairs in " +"the file\n" +"\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +"\n" +"\t\t # Create a new config map named my-config from an env file\n" +"\t\t kubectl create configmap my-config --from-env-file=path/to/bar.env" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:43 +msgid "" +"\n" +"\t\t # Create a role binding for user1, user2, and group1 using the admin " +"cluster role\n" +"\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +"user=user2 --group=group1" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:56 +msgid "" +"\n" +"\t\t # If you don't already have a .dockercfg file, you can create a " +"dockercfg secret directly by using:\n" +"\t\t kubectl create secret docker-registry my-secret --docker-" +"server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +"password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL\n" +"\n" +"\t\t # Create a new secret named my-secret from ~/.docker/config.json\n" +"\t\t kubectl create secret docker-registry my-secret --from-file=." +"dockerconfigjson=path/to/.docker/config.json" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:62 +msgid "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:45 +msgid "" +"\n" +"\t\t# !!!Important Note!!!\n" +"\t\t# Requires that the 'tar' binary is present in your container\n" +"\t\t# image. If 'tar' is not present, 'kubectl cp' will fail.\n" +"\t\t#\n" +"\t\t# For advanced use cases, such as symlinks, wildcard expansion or\n" +"\t\t# file mode preservation, consider using 'kubectl exec'.\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\ttar cf - /tmp/foo | kubectl exec -i -n -- " +"tar xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl exec -n -- tar cf - /tmp/foo | tar " +"xf - -C /tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in " +"the default namespace\n" +"\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific " +"container\n" +"\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +"\n" +"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +"\n" +"\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +"\n" +"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +"\t\tkubectl cp /:/tmp/foo /tmp/bar" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:119 +msgid "" +"\n" +"\t\t# Apply the configuration in pod.json to a pod\n" +"\t\tkubectl apply -f ./pod.json\n" +"\n" +"\t\t# Apply resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl apply -k dir/\n" +"\n" +"\t\t# Apply the JSON passed into stdin to a pod\n" +"\t\tcat pod.json | kubectl apply -f -\n" +"\n" +"\t\t# Note: --prune is still in Alpha\n" +"\t\t# Apply the configuration in manifest.yaml that matches label app=nginx " +"and delete all other resources that are not in the file and match label " +"app=nginx\n" +"\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +"\n" +"\t\t# Apply the configuration in manifest.yaml and delete all the other " +"config maps that are not in the file\n" +"\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/v1/" +"ConfigMap" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:48 +#, c-format +msgid "" +"\n" +"\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 and " +"10, no target CPU utilization specified so a default autoscaling policy will " +"be used\n" +"\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +"\n" +"\t\t# Auto scale a replication controller \"foo\", with the number of pods " +"between 1 and 5, target CPU utilization at 80%\n" +"\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" +msgstr "" + +#: pkg/kubectl/cmd/convert/convert.go:51 +msgid "" +"\n" +"\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +"\t\tkubectl convert -f pod.yaml\n" +"\n" +"\t\t# Convert the live state of the resource specified by 'pod.yaml' to the " +"latest version\n" +"\t\t# and print to stdout in JSON format.\n" +"\t\tkubectl convert -f pod.yaml --local -o json\n" +"\n" +"\t\t# Convert all files under current directory to latest version and create " +"them all.\n" +"\t\tkubectl convert -f . | kubectl create -f -" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:41 +msgid "" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" that allows user to perform " +"\"get\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +"resource=pods\n" +"\n" +"\t\t# Create a cluster role named \"pod-reader\" with ResourceName " +"specified\n" +"\t\tkubectl create clusterrole pod-reader --verb=get --resource=pods --" +"resource-name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with API Group specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=rs." +"extensions\n" +"\n" +"\t\t# Create a cluster role named \"foo\" with SubResource specified\n" +"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=pods," +"pods/status\n" +"\n" +"\t\t# Create a cluster role name \"foo\" with NonResourceURL specified\n" +"\t\tkubectl create clusterrole \"foo\" --verb=get --non-resource-url=/logs/" +"*\n" +"\n" +"\t\t# Create a cluster role name \"monitoring\" with AggregationRule " +"specified\n" +"\t\tkubectl create clusterrole monitoring --aggregation-rule=\"rbac.example." +"com/aggregate-to-monitoring=true\"" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:43 +msgid "" +"\n" +"\t\t# Create a job\n" +"\t\tkubectl create job my-job --image=busybox\n" +"\n" +"\t\t# Create a job with a command\n" +"\t\tkubectl create job my-job --image=busybox -- date\n" +"\n" +"\t\t# Create a job from a cron job named \"a-cronjob\"\n" +"\t\tkubectl create job test-job --from=cronjob/a-cronjob" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:44 +msgid "" +"\n" +"\t\t# Create a new resource quota named my-quota\n" +"\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3," +"replicationcontrollers=2,resourcequotas=1,secrets=5," +"persistentvolumeclaims=10\n" +"\n" +"\t\t# Create a new resource quota named best-effort\n" +"\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:44 +#, c-format +msgid "" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=rails label\n" +"\t\t# and require at least one of them being available at any point in time\n" +"\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +"available=1\n" +"\n" +"\t\t# Create a pod disruption budget named my-pdb that will select all pods " +"with the app=nginx label\n" +"\t\t# and require at least half of the pods selected to be available at any " +"point in time\n" +"\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:76 +msgid "" +"\n" +"\t\t# Create a pod using the data in pod.json\n" +"\t\tkubectl create -f ./pod.json\n" +"\n" +"\t\t# Create a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl create -f -\n" +"\n" +"\t\t# Edit the data in docker-registry.yaml in JSON then create the resource " +"using the edited data\n" +"\t\tkubectl create -f docker-registry.yaml --edit -o json" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:43 +msgid "" +"\n" +"\t\t# Create a priority class named high-priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\"\n" +"\n" +"\t\t# Create a priority class named default-priority that is considered as " +"the global default priority\n" +"\t\tkubectl create priorityclass default-priority --value=1000 --global-" +"default=true --description=\"default priority\"\n" +"\n" +"\t\t# Create a priority class named high-priority that cannot preempt pods " +"with lower priority\n" +"\t\tkubectl create priorityclass high-priority --value=1000 --description=" +"\"high priority\" --preemption-policy=\"Never\"" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:46 +msgid "" +"\n" +"\t\t# Create a role named \"pod-reader\" that allows user to perform \"get" +"\", \"watch\" and \"list\" on pods\n" +"\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --" +"resource=pods\n" +"\n" +"\t\t# Create a role named \"pod-reader\" with ResourceName specified\n" +"\t\tkubectl create role pod-reader --verb=get --resource=pods --resource-" +"name=readablepod --resource-name=anotherpod\n" +"\n" +"\t\t# Create a role named \"foo\" with API Group specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=rs.extensions\n" +"\n" +"\t\t# Create a role named \"foo\" with SubResource specified\n" +"\t\tkubectl create role foo --verb=get,list,watch --resource=pods,pods/status" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:61 +msgid "" +"\n" +"\t\t# Create a service for a replicated nginx, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a replication controller identified by type and " +"name specified in \"nginx-controller.yaml\", which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +"the name \"frontend\"\n" +"\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +"\n" +"\t\t# Create a second service based on the above service, exposing the " +"container port 8443 as port 443 with the name \"nginx-https\"\n" +"\t\tkubectl expose service nginx --port=443 --target-port=8443 --name=nginx-" +"https\n" +"\n" +"\t\t# Create a service for a replicated streaming application on port 4100 " +"balancing UDP traffic and named 'video-stream'.\n" +"\t\tkubectl expose rc streamer --port=4100 --protocol=UDP --name=video-" +"stream\n" +"\n" +"\t\t# Create a service for a replicated nginx using replica set, which " +"serves on port 80 and connects to the containers on port 8000\n" +"\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +"\n" +"\t\t# Create a service for an nginx deployment, which serves on port 80 and " +"connects to the containers on port 8000\n" +"\t\tkubectl expose deployment nginx --port=80 --target-port=8000" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:64 +msgid "" +"\n" +"\t\t# Create a single ingress called 'simple' that directs requests to foo." +"com/bar to svc\n" +"\t\t# svc1:8080 with a tls secret \"my-cert\"\n" +"\t\tkubectl create ingress simple --rule=\"foo.com/bar=svc1:8080,tls=my-cert" +"\"\n" +"\n" +"\t\t# Create a catch all ingress of \"/path\" pointing to service svc:port " +"and Ingress Class as \"otheringress\"\n" +"\t\tkubectl create ingress catch-all --class=otheringress --rule=\"/path=svc:" +"port\"\n" +"\n" +"\t\t# Create an ingress with two annotations: ingress.annotation1 and " +"ingress.annotations2\n" +"\t\tkubectl create ingress annotated --class=default --rule=\"foo.com/" +"bar=svc:port\" \\n\t\t\t--annotation ingress.annotation1=foo \\n\t\t\t--" +"annotation ingress.annotation2=bla\n" +"\n" +"\t\t# Create an ingress with the same host and multiple paths\n" +"\t\tkubectl create ingress multipath --class=default \\n\t\t\t--rule=\"foo." +"com/=svc:port\" \\n\t\t\t--rule=\"foo.com/admin/=svcadmin:portadmin\"\n" +"\n" +"\t\t# Create an ingress with multiple hosts and the pathType as Prefix\n" +"\t\tkubectl create ingress ingress1 --class=default \\n\t\t\t--rule=\"foo." +"com/path*=svc:8080\" \\n\t\t\t--rule=\"bar.com/admin*=svc2:http\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using the default ingress " +"certificate and different path types\n" +"\t\tkubectl create ingress ingtls --class=default \\n\t\t --rule=\"foo.com/" +"=svc:https,tls\" \\n\t\t --rule=\"foo.com/path/subpath*=othersvc:8080\"\n" +"\n" +"\t\t# Create an ingress with TLS enabled using a specific secret and " +"pathType as Prefix\n" +"\t\tkubectl create ingress ingsecret --class=default \\n\t\t --rule=\"foo." +"com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t# Create an ingress with a default backend\n" +"\t\tkubectl create ingress ingdefault --class=default \\n\t\t --default-" +"backend=defaultsvc:http \\n\t\t --rule=\"foo.com/*=svc:8080,tls=secret1\"\n" +"\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:74 +msgid "" +"\n" +"\t\t# Create an interactive debugging session in pod mypod and immediately " +"attach to it.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug mypod -it --image=busybox\n" +"\n" +"\t\t# Create a debug container named debugger using a custom automated " +"debugging image.\n" +"\t\t# (requires the EphemeralContainers feature to be enabled in the " +"cluster)\n" +"\t\tkubectl debug --image=myproj/debug-tools -c debugger mypod\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and attach to it\n" +"\t\tkubectl debug mypod -it --image=busybox --copy-to=my-debugger\n" +"\n" +"\t\t# Create a copy of mypod changing the command of mycontainer\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --container=mycontainer -- " +"sh\n" +"\n" +"\t\t# Create a copy of mypod changing all container images to busybox\n" +"\t\tkubectl debug mypod --copy-to=my-debugger --set-image=*=busybox\n" +"\n" +"\t\t# Create a copy of mypod adding a debug container and changing container " +"images\n" +"\t\tkubectl debug mypod -it --copy-to=my-debugger --image=debian --set-" +"image=app=app:debug,sidecar=sidecar:debug\n" +"\n" +"\t\t# Create an interactive debugging session on a node and immediately " +"attach to it.\n" +"\t\t# The container will run in the host namespaces and the host's " +"filesystem will be mounted at /host\n" +"\t\tkubectl debug node/mynode -it --image=busybox\n" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:74 +msgid "" +"\n" +"\t\t# Delete a pod using the type and name specified in pod.json\n" +"\t\tkubectl delete -f ./pod.json\n" +"\n" +"\t\t# Delete resources from a directory containing kustomization.yaml - e.g. " +"dir/kustomization.yaml\n" +"\t\tkubectl delete -k dir\n" +"\n" +"\t\t# Delete a pod based on the type and name in the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl delete -f -\n" +"\n" +"\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +"\t\tkubectl delete pod,service baz foo\n" +"\n" +"\t\t# Delete pods and services with label name=myLabel\n" +"\t\tkubectl delete pods,services -l name=myLabel\n" +"\n" +"\t\t# Delete a pod with minimal delay\n" +"\t\tkubectl delete pod foo --now\n" +"\n" +"\t\t# Force delete a pod on a dead node\n" +"\t\tkubectl delete pod foo --force\n" +"\n" +"\t\t# Delete all pods\n" +"\t\tkubectl delete pods --all" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:51 +msgid "" +"\n" +"\t\t# Describe a node\n" +"\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +"\n" +"\t\t# Describe a pod\n" +"\t\tkubectl describe pods/nginx\n" +"\n" +"\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +"\t\tkubectl describe -f pod.json\n" +"\n" +"\t\t# Describe all pods\n" +"\t\tkubectl describe pods\n" +"\n" +"\t\t# Describe pods by label name=myLabel\n" +"\t\tkubectl describe po -l name=myLabel\n" +"\n" +"\t\t# Describe all pods managed by the 'frontend' replication controller (rc-" +"created pods\n" +"\t\t# get the name of the rc as a prefix in the pod the name)\n" +"\t\tkubectl describe pods frontend" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:76 +msgid "" +"\n" +"\t\t# Diff resources included in pod.json\n" +"\t\tkubectl diff -f pod.json\n" +"\n" +"\t\t# Diff file read from stdin\n" +"\t\tcat service.yaml | kubectl diff -f -" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:138 +msgid "" +"\n" +"\t\t# Drain node \"foo\", even if there are pods not managed by a " +"replication controller, replica set, job, daemon set or stateful set on it\n" +"\t\tkubectl drain foo --force\n" +"\n" +"\t\t# As above, but abort if there are pods not managed by a replication " +"controller, replica set, job, daemon set or stateful set, and use a grace " +"period of 15 minutes\n" +"\t\tkubectl drain foo --grace-period=900" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:55 +msgid "" +"\n" +"\t\t# Edit the service named 'docker-registry'\n" +"\t\tkubectl edit svc/docker-registry\n" +"\n" +"\t\t# Use an alternative editor\n" +"\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +"\n" +"\t\t# Edit the job 'myjob' in JSON using the v1 API format\n" +"\t\tkubectl edit job.v1.batch/myjob -o json\n" +"\n" +"\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +"config in its annotation\n" +"\t\tkubectl edit deployment/mydeployment -o yaml --save-config" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:44 +msgid "" +"\n" +"\t\t# Get output from running pod mypod; use the 'kubectl.kubernetes.io/" +"default-container' annotation\n" +"\t\t# for selecting the container to be attached or the first container in " +"the pod will be chosen\n" +"\t\tkubectl attach mypod\n" +"\n" +"\t\t# Get output from ruby-container from pod mypod\n" +"\t\tkubectl attach mypod -c ruby-container\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl attach mypod -c ruby-container -i -t\n" +"\n" +"\t\t# Get output from the first pod of a replica set named nginx\n" +"\t\tkubectl attach rs/nginx\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:48 +msgid "" +"\n" +"\t\t# Get output from running the 'date' command from pod mypod, using the " +"first container by default\n" +"\t\tkubectl exec mypod -- date\n" +"\n" +"\t\t# Get output from running the 'date' command in ruby-container from pod " +"mypod\n" +"\t\tkubectl exec mypod -c ruby-container -- date\n" +"\n" +"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container " +"from pod mypod\n" +"\t\t# and sends stdout/stderr from 'bash' back to the client\n" +"\t\tkubectl exec mypod -c ruby-container -i -t -- bash -il\n" +"\n" +"\t\t# List contents of /usr from the first container of pod mypod and sort " +"by modification time\n" +"\t\t# If the command you want to execute in the pod has any flags in common " +"(e.g. -i),\n" +"\t\t# you must use two dashes (--) to separate your command's flags/" +"arguments\n" +"\t\t# Also note, do not surround your command and its flags/arguments with " +"quotes\n" +"\t\t# unless that is how you would execute it normally (i.e., do ls -t /usr, " +"not \"ls -t /usr\")\n" +"\t\tkubectl exec mypod -i -t -- ls -t /usr\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"deployment mydeployment, using the first container by default\n" +"\t\tkubectl exec deploy/mydeployment -- date\n" +"\n" +"\t\t# Get output from running 'date' command from the first pod of the " +"service myservice, using the first container by default\n" +"\t\tkubectl exec svc/myservice -- date\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:46 +msgid "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:65 +msgid "" +"\n" +"\t\t# Installing bash completion on macOS using homebrew\n" +"\t\t## If running Bash 3.2 included with macOS\n" +"\t\t brew install bash-completion\n" +"\t\t## or, if running Bash 4.1+\n" +"\t\t brew install bash-completion@2\n" +"\t\t## If kubectl is installed via homebrew, this should start working " +"immediately\n" +"\t\t## If you've installed via other means, you may need add the completion " +"to your completion directory\n" +"\t\t kubectl completion bash > $(brew --prefix)/etc/bash_completion.d/" +"kubectl\n" +"\n" +"\n" +"\t\t# Installing bash completion on Linux\n" +"\t\t## If bash-completion is not installed on Linux, install the 'bash-" +"completion' package\n" +"\t\t## via your distribution's package manager.\n" +"\t\t## Load the kubectl completion code for bash into the current shell\n" +"\t\t source <(kubectl completion bash)\n" +"\t\t## Write bash completion code to a file and source it from ." +"bash_profile\n" +"\t\t kubectl completion bash > ~/.kube/completion.bash.inc\n" +"\t\t printf \"\n" +"\t\t # Kubectl shell completion\n" +"\t\t source '$HOME/.kube/completion.bash.inc'\n" +"\t\t \" >> $HOME/.bash_profile\n" +"\t\t source $HOME/.bash_profile\n" +"\n" +"\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +"\t\t source <(kubectl completion zsh)\n" +"\t\t# Set the kubectl completion code for zsh[1] to autoload on startup\n" +"\t\t kubectl completion zsh > \"${fpath[1]}/_kubectl\"" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:105 +msgid "" +"\n" +"\t\t# List all pods in ps output format\n" +"\t\tkubectl get pods\n" +"\n" +"\t\t# List all pods in ps output format with more information (such as node " +"name)\n" +"\t\tkubectl get pods -o wide\n" +"\n" +"\t\t# List a single replication controller with specified NAME in ps output " +"format\n" +"\t\tkubectl get replicationcontroller web\n" +"\n" +"\t\t# List deployments in JSON output format, in the \"v1\" version of the " +"\"apps\" API group\n" +"\t\tkubectl get deployments.v1.apps -o json\n" +"\n" +"\t\t# List a single pod in JSON output format\n" +"\t\tkubectl get -o json pod web-pod-13je7\n" +"\n" +"\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +"JSON output format\n" +"\t\tkubectl get -f pod.yaml -o json\n" +"\n" +"\t\t# List resources from a directory with kustomization.yaml - e.g. dir/" +"kustomization.yaml\n" +"\t\tkubectl get -k dir/\n" +"\n" +"\t\t# Return only the phase value of the specified pod\n" +"\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}\n" +"\n" +"\t\t# List resource information in custom columns\n" +"\t\tkubectl get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0]." +"name,IMAGE:.spec.containers[0].image\n" +"\n" +"\t\t# List all replication controllers and services together in ps output " +"format\n" +"\t\tkubectl get rc,services\n" +"\n" +"\t\t# List one or more resources by their type and names\n" +"\t\tkubectl get rc/web service/frontend pods/web-pod-13je7" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:72 +msgid "" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 5000 6000\n" +"\n" +"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports " +"5000 and 6000 in a pod selected by the deployment\n" +"\t\tkubectl port-forward deployment/mydeployment 5000 6000\n" +"\n" +"\t\t# Listen on port 8443 locally, forwarding to the targetPort of the " +"service's port named \"https\" in a pod selected by the service\n" +"\t\tkubectl port-forward service/myservice 8443:https\n" +"\n" +"\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on all addresses, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000\n" +"\n" +"\t\t# Listen on port 8888 on localhost and selected IP, forwarding to 5000 " +"in the pod\n" +"\t\tkubectl port-forward --address localhost,10.19.21.23 pod/mypod " +"8888:5000\n" +"\n" +"\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +"\t\tkubectl port-forward pod/mypod :5000" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:87 +msgid "" +"\n" +"\t\t# Mark node \"foo\" as schedulable\n" +"\t\tkubectl uncordon foo" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:58 +msgid "" +"\n" +"\t\t# Mark node \"foo\" as unschedulable\n" +"\t\tkubectl cordon foo" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:83 +msgid "" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as JSON\n" +"\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Partially update a node using a strategic merge patch, specifying the " +"patch as YAML\n" +"\t\tkubectl patch node k8s-node-1 -p $'spec:\n" +" unschedulable: true'\n" +"\n" +"\t\t# Partially update a node identified by the type and name specified in " +"\"node.json\" using strategic merge patch\n" +"\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +"\n" +"\t\t# Update a container's image; spec.containers[*].name is required " +"because it's a merge key\n" +"\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +"\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +"\n" +"\t\t# Update a container's image using a JSON patch with positional arrays\n" +"\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +"\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:29 +msgid "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:44 +msgid "" +"\n" +"\t\t# Print the address of the control plane and cluster services\n" +"\t\tkubectl cluster-info" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:44 +msgid "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:34 +msgid "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:56 +msgid "" +"\n" +"\t\t# Replace a pod using the data in pod.json\n" +"\t\tkubectl replace -f ./pod.json\n" +"\n" +"\t\t# Replace a pod based on the JSON passed into stdin\n" +"\t\tcat pod.json | kubectl replace -f -\n" +"\n" +"\t\t# Update a single-container pod's image version (tag) to v4\n" +"\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' | " +"kubectl replace -f -\n" +"\n" +"\t\t# Force replace, delete and then re-create the resource\n" +"\t\tkubectl replace --force -f ./pod.json" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:53 +msgid "" +"\n" +"\t\t# Return snapshot logs from pod nginx with only one container\n" +"\t\tkubectl logs nginx\n" +"\n" +"\t\t# Return snapshot logs from pod nginx with multi containers\n" +"\t\tkubectl logs nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Return snapshot of previous terminated ruby container logs from pod " +"web-1\n" +"\t\tkubectl logs -p -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +"\t\tkubectl logs -f -c ruby web-1\n" +"\n" +"\t\t# Begin streaming the logs from all containers in pods defined by label " +"app=nginx\n" +"\t\tkubectl logs -f -l app=nginx --all-containers=true\n" +"\n" +"\t\t# Display only the most recent 20 lines of output in pod nginx\n" +"\t\tkubectl logs --tail=20 nginx\n" +"\n" +"\t\t# Show all logs from pod nginx written in the last hour\n" +"\t\tkubectl logs --since=1h nginx\n" +"\n" +"\t\t# Show logs from a kubelet with an expired serving certificate\n" +"\t\tkubectl logs --insecure-skip-tls-verify-backend nginx\n" +"\n" +"\t\t# Return snapshot logs from first container of a job named hello\n" +"\t\tkubectl logs job/hello\n" +"\n" +"\t\t# Return snapshot logs from container nginx-1 of a deployment named " +"nginx\n" +"\t\tkubectl logs deployment/nginx -c nginx-1" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:49 +msgid "" +"\n" +"\t\t# Scale a replica set named 'foo' to 3\n" +"\t\tkubectl scale --replicas=3 rs/foo\n" +"\n" +"\t\t# Scale a resource identified by type and name specified in \"foo.yaml\" " +"to 3\n" +"\t\tkubectl scale --replicas=3 -f foo.yaml\n" +"\n" +"\t\t# If the deployment named mysql's current size is 2, scale mysql to 3\n" +"\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +"\n" +"\t\t# Scale multiple replication controllers\n" +"\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +"\n" +"\t\t# Scale stateful set named 'web' to 3\n" +"\t\tkubectl scale --replicas=3 statefulset/web" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:75 +msgid "" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml\n" +"\n" +"\t\t# Execute set-last-applied against each configuration file in a " +"directory\n" +"\t\tkubectl apply set-last-applied -f path/\n" +"\n" +"\t\t# Set the last-applied-configuration of a resource to match the contents " +"of a file; will create the annotation if it does not already exist\n" +"\t\tkubectl apply set-last-applied -f deploy.yaml --create-annotation=true\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:75 +msgid "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:62 +msgid "" +"\n" +"\t\t# Start a nginx pod\n" +"\t\tkubectl run nginx --image=nginx\n" +"\n" +"\t\t# Start a hazelcast pod and let the container expose port 5701\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --port=5701\n" +"\n" +"\t\t# Start a hazelcast pod and set environment variables " +"\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --env=" +"\"DNS_DOMAIN=cluster\" --env=\"POD_NAMESPACE=default\"\n" +"\n" +"\t\t# Start a hazelcast pod and set labels \"app=hazelcast\" and \"env=prod" +"\" in the container\n" +"\t\tkubectl run hazelcast --image=hazelcast/hazelcast --labels=" +"\"app=hazelcast,env=prod\"\n" +"\n" +"\t\t# Dry run; print the corresponding API objects without creating them\n" +"\t\tkubectl run nginx --image=nginx --dry-run=client\n" +"\n" +"\t\t# Start a nginx pod, but overload the spec with a partial set of values " +"parsed from JSON\n" +"\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": \"v1\", " +"\"spec\": { ... } }'\n" +"\n" +"\t\t# Start a busybox pod and keep it in the foreground, don't restart it if " +"it exits\n" +"\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +"\n" +"\t\t# Start the nginx pod using the default command, but use custom " +"arguments (arg1 .. argN) for that command\n" +"\t\tkubectl run nginx --image=nginx -- ... \n" +"\n" +"\t\t# Start the nginx pod using a different command and custom arguments\n" +"\t\tkubectl run nginx --image=nginx --command -- ... " +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:73 +msgid "" +"\n" +"\t\t# To proxy all of the Kubernetes API and nothing else\n" +"\t\tkubectl proxy --api-prefix=/\n" +"\n" +"\t\t# To proxy only part of the Kubernetes API and also some static files\n" +"\t\t# You can get pods info with 'curl localhost:8001/api/v1/pods'\n" +"\t\tkubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/\n" +"\n" +"\t\t# To proxy the entire Kubernetes API at a different root\n" +"\t\t# You can get pods info with 'curl localhost:8001/custom/api/v1/pods'\n" +"\t\tkubectl proxy --api-prefix=/custom/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on port 8011, serving static " +"content from ./local/www/\n" +"\t\tkubectl proxy --port=8011 --www=./local/www/\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server on an arbitrary local port\n" +"\t\t# The chosen port for the server will be output to stdout\n" +"\t\tkubectl proxy --port=0\n" +"\n" +"\t\t# Run a proxy to the Kubernetes API server, changing the API prefix to " +"k8s-api\n" +"\t\t# This makes e.g. the pods API available at localhost:8001/k8s-api/v1/" +"pods/\n" +"\t\tkubectl proxy --api-prefix=/k8s-api" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:80 +msgid "" +"\n" +"\t\t# Update node 'foo' with a taint with key 'dedicated' and value 'special-" +"user' and effect 'NoSchedule'\n" +"\t\t# If a taint with that key and effect already exists, its value is " +"replaced as specified\n" +"\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +"\n" +"\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +"'NoSchedule' if one exists\n" +"\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +"\n" +"\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +"\t\tkubectl taint nodes foo dedicated-\n" +"\n" +"\t\t# Add a taint with key 'dedicated' on nodes having label mylabel=X\n" +"\t\tkubectl taint node -l myLabel=X dedicated=foo:PreferNoSchedule\n" +"\n" +"\t\t# Add to node 'foo' a taint with key 'bar' and no value\n" +"\t\tkubectl taint nodes foo bar:NoSchedule" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:95 +msgid "" +"\n" +"\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'\n" +"\t\tkubectl label pods foo unhealthy=true\n" +"\n" +"\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +"overwriting any existing value\n" +"\t\tkubectl label --overwrite pods foo status=unhealthy\n" +"\n" +"\t\t# Update all pods in the namespace\n" +"\t\tkubectl label pods --all status=unhealthy\n" +"\n" +"\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +"\t\tkubectl label -f pod.json status=unhealthy\n" +"\n" +"\t\t# Update pod 'foo' only if the resource is unchanged from version 1\n" +"\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +"\n" +"\t\t# Update pod 'foo' by removing a label named 'bar' if it exists\n" +"\t\t# Does not require the --overwrite flag\n" +"\t\tkubectl label pods foo bar-" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_view_last_applied.go:53 +msgid "" +"\n" +"\t\t# View the last-applied-configuration annotations by type/name in YAML\n" +"\t\tkubectl apply view-last-applied deployment/nginx\n" +"\n" +"\t\t# View the last-applied-configuration annotations by file in JSON\n" +"\t\tkubectl apply view-last-applied -f deploy.yaml -o json" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/wait/wait.go:61 +msgid "" +"\n" +"\t\t# Wait for the pod \"busybox1\" to contain the status condition of type " +"\"Ready\"\n" +"\t\tkubectl wait --for=condition=Ready pod/busybox1\n" +"\n" +"\t\t# The default value of status condition is true; you can set it to " +"false\n" +"\t\tkubectl wait --for=condition=Ready=false pod/busybox1\n" +"\n" +"\t\t# Wait for the pod \"busybox1\" to be deleted, with a timeout of 60s, " +"after having issued the \"delete\" command\n" +"\t\tkubectl delete pod/busybox1\n" +"\t\tkubectl wait --for=delete pod/busybox1 --timeout=60s" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:110 +msgid "" +"\n" +"\t\tApply a configuration to a resource by file name or stdin.\n" +"\t\tThe resource name must be specified. This resource will be created if it " +"doesn't exist yet.\n" +"\t\tTo use 'apply', always create the resource initially with either 'apply' " +"or 'create --save-config'.\n" +"\n" +"\t\tJSON and YAML formats are accepted.\n" +"\n" +"\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do not " +"use unless you are aware of what the current state is. See https://issues." +"k8s.io/34274." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:126 +msgid "" +"\n" +"\t\tApprove a certificate signing request.\n" +"\n" +"\t\tkubectl certificate approve allows a cluster admin to approve a " +"certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tissue a certificate to the requestor with the attributes requested in " +"the CSR.\n" +"\n" +"\t\tSECURITY NOTICE: Depending on the requested attributes, the issued " +"certificate\n" +"\t\tcan potentially grant a requester access to cluster resources or to " +"authenticate\n" +"\t\tas a requested identity. Before approving a CSR, ensure you understand " +"what the\n" +"\t\tsigned certificate can do.\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:28 +msgid "" +"\n" +"\t\tConfigure application resources.\n" +"\n" +"\t\tThese commands help you make changes to existing application resources." +msgstr "" + +#: pkg/kubectl/cmd/convert/convert.go:40 +msgid "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:41 +msgid "" +"\n" +"\t\tCreate a TLS secret from the given public/private key pair.\n" +"\n" +"\t\tThe public/private key pair must exist beforehand. The public key " +"certificate must be .PEM encoded and match\n" +"\t\tthe given private key." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:41 +msgid "" +"\n" +"\t\tCreate a cluster role binding for a particular cluster role." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:38 +msgid "" +"\n" +"\t\tCreate a cluster role." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:46 +msgid "" +"\n" +"\t\tCreate a config map based on a file, directory, or specified literal " +"value.\n" +"\n" +"\t\tA single config map may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a config map based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key, you may " +"specify an alternate key.\n" +"\n" +"\t\tWhen creating a config map based on a directory, each file whose " +"basename is a valid key in the directory will be\n" +"\t\tpackaged into the config map. Any directory entries except regular " +"files are ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_cronjob.go:40 +msgid "" +"\n" +"\t\tCreate a cron job with the specified name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:40 +msgid "" +"\n" +"\t\tCreate a job with the specified name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:39 +msgid "" +"\n" +"\t\tCreate a namespace with the specified name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:41 +msgid "" +"\n" +"\t\tCreate a new secret for use with Docker registries.\n" +"\n" +"\t\tDockercfg secrets are used to authenticate against Docker registries.\n" +"\n" +"\t\tWhen using the Docker command line to push images, you can authenticate " +"to a given registry by running:\n" +"\t\t\t'$ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +"password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +"\n" +"\tThat produces a ~/.dockercfg file that is used by subsequent 'docker push' " +"and 'docker pull' commands to\n" +"\t\tauthenticate to the registry. The email address is optional.\n" +"\n" +"\t\tWhen creating applications, you may have a Docker registry that requires " +"authentication. In order for the\n" +"\t\tnodes to pull images on your behalf, they must have the credentials. " +"You can provide this information\n" +"\t\tby creating a dockercfg secret and attaching it to your service account." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:41 +msgid "" +"\n" +"\t\tCreate a pod disruption budget with the specified name, selector, and " +"desired minimum available pods." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:40 +msgid "" +"\n" +"\t\tCreate a priority class with the specified name, value, globalDefault " +"and description." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:71 +msgid "" +"\n" +"\t\tCreate a resource from a file or from stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:41 +msgid "" +"\n" +"\t\tCreate a resource quota with the specified name, hard limits, and " +"optional scopes." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:40 +msgid "" +"\n" +"\t\tCreate a role binding for a particular role or cluster role." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:43 +msgid "" +"\n" +"\t\tCreate a role with single rule." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:61 +msgid "" +"\n" +"\t\tCreate a secret based on a file, directory, or specified literal value.\n" +"\n" +"\t\tA single secret may package one or more key/value pairs.\n" +"\n" +"\t\tWhen creating a secret based on a file, the key will default to the " +"basename of the file, and the value will\n" +"\t\tdefault to the file content. If the basename is an invalid key or you " +"wish to chose your own, you may specify\n" +"\t\tan alternate key.\n" +"\n" +"\t\tWhen creating a secret based on a directory, each file whose basename is " +"a valid key in the directory will be\n" +"\t\tpackaged into the secret. Any directory entries except regular files are " +"ignored (e.g. subdirectories,\n" +"\t\tsymlinks, devices, pipes, etc)." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:40 +msgid "" +"\n" +"\t\tCreate a service account with the specified name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:67 +msgid "" +"\n" +"\t\tCreates a proxy server or application-level gateway between localhost " +"and\n" +"\t\tthe Kubernetes API server. It also allows serving static content over " +"specified\n" +"\t\tHTTP path. All incoming data enters through one port and gets forwarded " +"to\n" +"\t\tthe remote Kubernetes API server port, except for the path matching the " +"static content path." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:42 +msgid "" +"\n" +"\t\tCreates an autoscaler that automatically chooses and sets the number of " +"pods that run in a Kubernetes cluster.\n" +"\n" +"\t\tLooks up a deployment, replica set, stateful set, or replication " +"controller by name and creates an autoscaler that uses the given resource as " +"a reference.\n" +"\t\tAn autoscaler can automatically increase or decrease number of pods " +"deployed within the system as needed." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:57 +msgid "" +"\n" +"\t\tDebug cluster resources using interactive debugging containers.\n" +"\n" +"\t\t'debug' provides automation for common debugging tasks for cluster " +"objects identified by\n" +"\t\tresource and name. Pods will be used by default if no resource is " +"specified.\n" +"\n" +"\t\tThe action taken by 'debug' varies depending on what resource is " +"specified. Supported\n" +"\t\tactions include:\n" +"\n" +"\t\t* Workload: Create a copy of an existing pod with certain attributes " +"changed,\n" +"\t for example changing the image tag to a new version.\n" +"\t\t* Workload: Add an ephemeral container to an already running pod, for " +"example to add\n" +"\t\t debugging utilities without restarting the pod.\n" +"\t\t* Node: Create a new pod that runs in the node's host namespaces and can " +"access\n" +"\t\t the node's filesystem.\n" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:45 +msgid "" +"\n" +"\t\tDelete resources by file names, stdin, resources and names, or by " +"resources and label selector.\n" +"\n" +"\t\tJSON and YAML formats are accepted. Only one type of argument may be " +"specified: file names,\n" +"\t\tresources and names, or resources and label selector.\n" +"\n" +"\t\tSome resources, such as pods, support graceful deletion. These resources " +"define a default period\n" +"\t\tbefore they are forcibly terminated (the grace period) but you may " +"override that value with\n" +"\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +"Because these resources often\n" +"\t\trepresent entities in the cluster, deletion may not be acknowledged " +"immediately. If the node\n" +"\t\thosting a pod is down or cannot reach the API server, termination may " +"take significantly longer\n" +"\t\tthan the grace period. To force delete a resource, you must specify the " +"--force flag.\n" +"\t\tNote: only a subset of resources support graceful deletion. In absence " +"of the support,\n" +"\t\tthe --grace-period flag is ignored.\n" +"\n" +"\t\tIMPORTANT: Force deleting pods does not wait for confirmation that the " +"pod's processes have been\n" +"\t\tterminated, which can leave those processes running until the node " +"detects the deletion and\n" +"\t\tcompletes graceful deletion. If your processes use shared storage or " +"talk to a remote API and\n" +"\t\tdepend on the name of the pod to identify themselves, force deleting " +"those pods may result in\n" +"\t\tmultiple processes running on different machines using the same " +"identification which may lead\n" +"\t\tto data corruption or inconsistency. Only force delete pods when you are " +"sure the pod is\n" +"\t\tterminated, or if your application can tolerate multiple copies of the " +"same pod running at once.\n" +"\t\tAlso, if you force delete pods, the scheduler may place new pods on " +"those nodes before the node\n" +"\t\thas released those resources and causing those pods to be evicted " +"immediately.\n" +"\n" +"\t\tNote that the delete command does NOT do resource version checks, so if " +"someone submits an\n" +"\t\tupdate to a resource right when you submit a delete, their update will " +"be lost along with the\n" +"\t\trest of the resource." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:175 +msgid "" +"\n" +"\t\tDeny a certificate signing request.\n" +"\n" +"\t\tkubectl certificate deny allows a cluster admin to deny a certificate\n" +"\t\tsigning request (CSR). This action tells a certificate signing " +"controller to\n" +"\t\tnot to issue a certificate to the requestor.\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:53 +msgid "" +"\n" +"\t\tDiff configurations specified by file name or stdin between the current " +"online\n" +"\t\tconfiguration, and the configuration as it would be if applied.\n" +"\n" +"\t\tThe output is always YAML.\n" +"\n" +"\t\tKUBECTL_EXTERNAL_DIFF environment variable can be used to select your " +"own\n" +"\t\tdiff command. Users can use external commands with params too, example:\n" +"\t\tKUBECTL_EXTERNAL_DIFF=\"colordiff -N -u\"\n" +"\n" +"\t\tBy default, the \"diff\" command available in your path will be\n" +"\t\trun with the \"-u\" (unified diff) and \"-N\" (treat absent files as " +"empty) options.\n" +"\n" +"\t\tExit status:\n" +"\t\t 0\n" +"\t\tNo differences were found.\n" +"\t\t 1\n" +"\t\tDifferences were found.\n" +"\t\t >1\n" +"\t\tKubectl or diff failed with an error.\n" +"\n" +"\t\tNote: KUBECTL_EXTERNAL_DIFF, if used, is expected to follow that " +"convention." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top.go:39 +msgid "" +"\n" +"\t\tDisplay Resource (CPU/Memory) usage.\n" +"\n" +"\t\tThe top command allows you to see the resource consumption for nodes or " +"pods.\n" +"\n" +"\t\tThis command requires Metrics Server to be correctly configured and " +"working on the server. " +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:54 +msgid "" +"\n" +"\t\tDisplay merged kubeconfig settings or a specified kubeconfig file.\n" +"\n" +"\t\tYou can use --output jsonpath={...} to extract specific values using a " +"jsonpath expression." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:92 +msgid "" +"\n" +"\t\tDisplay one or many resources.\n" +"\n" +"\t\tPrints a table of the most important information about the specified " +"resources.\n" +"\t\tYou can filter the list using a label selector and the --selector flag. " +"If the\n" +"\t\tdesired resource type is namespaced you will only see results in your " +"current\n" +"\t\tnamespace unless you pass --all-namespaces.\n" +"\n" +"\t\tUninitialized objects are not shown unless --include-uninitialized is " +"passed.\n" +"\n" +"\t\tBy specifying the output as 'template' and providing a Go template as " +"the value\n" +"\t\tof the --template flag, you can filter the attributes of the fetched " +"resources." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:57 +msgid "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of nodes.\n" +"\n" +"\t\tThe top-node command allows you to see the resource consumption of nodes." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:67 +msgid "" +"\n" +"\t\tDisplay resource (CPU/memory) usage of pods.\n" +"\n" +"\t\tThe 'top pod' command allows you to see the resource consumption of " +"pods.\n" +"\n" +"\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +"minutes\n" +"\t\tsince pod creation." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/current_context.go:37 +msgid "" +"\n" +"\t\tDisplay the current-context." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:113 +msgid "" +"\n" +"\t\tDrain node in preparation for maintenance.\n" +"\n" +"\t\tThe given node will be marked unschedulable to prevent new pods from " +"arriving.\n" +"\t\t'drain' evicts the pods if the API server supports\n" +"\t\t[eviction](https://kubernetes.io/docs/concepts/workloads/pods/" +"disruptions/). Otherwise, it will use normal\n" +"\t\tDELETE to delete the pods.\n" +"\t\tThe 'drain' evicts or deletes all pods except mirror pods (which cannot " +"be deleted through\n" +"\t\tthe API server). If there are daemon set-managed pods, drain will not " +"proceed\n" +"\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +"\t\tdaemon set-managed pods, because those pods would be immediately " +"replaced by the\n" +"\t\tdaemon set controller, which ignores unschedulable markings. If there " +"are any\n" +"\t\tpods that are neither mirror pods nor managed by a replication " +"controller,\n" +"\t\treplica set, daemon set, stateful set, or job, then drain will not " +"delete any pods unless you\n" +"\t\tuse --force. --force will also allow deletion to proceed if the " +"managing resource of one\n" +"\t\tor more pods is missing.\n" +"\n" +"\t\t'drain' waits for graceful termination. You should not operate on the " +"machine until\n" +"\t\tthe command completes.\n" +"\n" +"\t\tWhen you are ready to put the node back into service, use kubectl " +"uncordon, which\n" +"\t\twill make the node schedulable again.\n" +"\n" +"\t\t![Workflow](https://kubernetes.io/images/docs/kubectl_drain.svg)" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:31 +msgid "" +"\n" +"\t\tEdit a resource from the default editor.\n" +"\n" +"\t\tThe edit command allows you to directly edit any API resource you can " +"retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tEditing is done with the API version used to fetch the resource.\n" +"\t\tTo edit using a specific API version, fully-qualify the resource, " +"version, and group.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_edit_last_applied.go:31 +msgid "" +"\n" +"\t\tEdit the latest last-applied-configuration annotations of resources from " +"the default editor.\n" +"\n" +"\t\tThe edit-last-applied command allows you to directly edit any API " +"resource you can retrieve via the\n" +"\t\tcommand-line tools. It will open the editor defined by your KUBE_EDITOR, " +"or EDITOR\n" +"\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' for " +"Windows.\n" +"\t\tYou can edit multiple objects, although changes are applied one at a " +"time. The command\n" +"\t\taccepts file names as well as command-line arguments, although the files " +"you point to must\n" +"\t\tbe previously saved versions of resources.\n" +"\n" +"\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +"\n" +"\t\tThe flag --windows-line-endings can be used to force Windows line " +"endings,\n" +"\t\totherwise the default for your operating system will be used.\n" +"\n" +"\t\tIn the event an error occurs while updating, a temporary file will be " +"created on disk\n" +"\t\tthat contains your unapplied changes. The most common error when " +"updating a resource\n" +"\t\tis another editor changing the resource on the server. When this occurs, " +"you will have\n" +"\t\tto apply your changes to the newer version of the resource, or update " +"your temporary\n" +"\t\tsaved copy to include the latest resource version." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/wait/wait.go:49 +msgid "" +"\n" +"\t\tExperimental: Wait for a specific condition on one or many resources.\n" +"\n" +"\t\tThe command takes multiple resources and waits until the specified " +"condition\n" +"\t\tis seen in the Status field of every given resource.\n" +"\n" +"\t\tAlternatively, the command can wait for the given set of resources to be " +"deleted\n" +"\t\tby providing the \"delete\" keyword as the value to the --for flag.\n" +"\n" +"\t\tA successful message will be printed to stdout indicating when the " +"specified\n" +" condition has been met. You can use -o option to change to output " +"destination." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:47 +msgid "" +"\n" +"\t\tExpose a resource as a new Kubernetes service.\n" +"\n" +"\t\tLooks up a deployment, service, replica set, replication controller or " +"pod by name and uses the selector\n" +"\t\tfor that resource as the selector for a new service on the specified " +"port. A deployment or replica set\n" +"\t\twill be exposed as a service only if its selector is convertible to a " +"selector that service supports,\n" +"\t\ti.e. when the selector contains only the matchLabels component. Note " +"that if no port is specified via\n" +"\t\t--port and the exposed resource has multiple ports, all will be re-used " +"by the new service. Also if no\n" +"\t\tlabels are specified, the new service will re-use the labels from the " +"resource it exposes.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:46 +msgid "" +"\n" +"\t\tList all available plugin files on a user's PATH.\n" +"\n" +"\t\tAvailable plugin files are those that are:\n" +"\t\t- executable\n" +"\t\t- anywhere on the user's PATH\n" +"\t\t- begin with \"kubectl-\"\n" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:35 +msgid "" +"\n" +"\t\tList the fields for supported resources.\n" +"\n" +"\t\tThis command describes the fields associated with each supported API " +"resource.\n" +"\t\tFields are identified via a simple JSONPath identifier:\n" +"\n" +"\t\t\t.[.]\n" +"\n" +"\t\tAdd the --recursive flag to display all of the fields at once without " +"descriptions.\n" +"\t\tInformation about each field is retrieved from the server in OpenAPI " +"format." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout.go:30 +msgid "" +"\n" +"\t\tManage the rollout of a resource." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:84 +msgid "" +"\n" +"\t\tMark node as schedulable." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:55 +msgid "" +"\n" +"\t\tMark node as unschedulable." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:57 +msgid "" +"\n" +"\t\tMark the provided resource as paused.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller.\n" +"\t\tUse \"kubectl rollout resume\" to resume a paused resource.\n" +"\t\tCurrently only deployments support being paused." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:46 +msgid "" +"\n" +"\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +"\t\tThe shell code must be evaluated to provide interactive\n" +"\t\tcompletion of kubectl commands. This can be done by sourcing it from\n" +"\t\tthe .bash_profile.\n" +"\n" +"\t\tDetailed instructions on how to do this are available here:\n" +"\n" +" for macOS:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-macos/#enable-" +"shell-autocompletion\n" +"\n" +" for linux:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/#enable-" +"shell-autocompletion\n" +"\n" +" for windows:\n" +" https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/" +"#enable-shell-autocompletion\n" +"\n" +"\t\tNote for zsh users: [1] zsh completions are only supported in versions " +"of zsh >= 5.2." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:49 +msgid "" +"\n" +"\t\tPrint the logs for a container in a pod or specified resource. \n" +"\t\tIf the pod has only one container, the container name is optional." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:37 +msgid "" +"\n" +"\t\tProvides utilities for interacting with plugins.\n" +"\n" +"\t\tPlugins provide extended functionality that is not part of the major " +"command-line distribution.\n" +"\t\tPlease refer to the documentation and examples for more information " +"about how write your own plugins.\n" +"\n" +"\t\tThe easiest way to discover and install plugins is via the kubernetes " +"sub-project krew.\n" +"\t\tTo install krew, visit [krew.sigs.k8s.io](https://krew.sigs.k8s.io/docs/" +"user-guide/setup/install/)" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/rename_context.go:47 +msgid "" +"\n" +"\t\tRenames a context from the kubeconfig file.\n" +"\n" +"\t\tCONTEXT_NAME is the context name that you want to change.\n" +"\n" +"\t\tNEW_NAME is the new name you want to set.\n" +"\n" +"\t\tNote: If the context being renamed is the 'current-context', this field " +"will also be updated." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:48 +msgid "" +"\n" +"\t\tReplace a resource by file name or stdin.\n" +"\n" +"\t\tJSON and YAML formats are accepted. If replacing an existing resource, " +"the\n" +"\t\tcomplete resource spec must be provided. This can be obtained by\n" +"\n" +"\t\t $ kubectl get TYPE NAME -o yaml" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_restart.go:57 +msgid "" +"\n" +"\t\tRestart a resource.\n" +"\n" +"\t Resource rollout will be restarted." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:58 +msgid "" +"\n" +"\t\tResume a paused resource.\n" +"\n" +"\t\tPaused resources will not be reconciled by a controller. By resuming a\n" +"\t\tresource, we allow it to be reconciled again.\n" +"\t\tCurrently only deployments support being resumed." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:55 +msgid "" +"\n" +"\t\tRoll back to a previous rollout." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_cluster.go:47 +msgid "" +"\n" +"\t\tSet a cluster entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_context.go:44 +msgid "" +"\n" +"\t\tSet a context entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values for those fields." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:40 +msgid "" +"\n" +"\t\tSet a new size for a deployment, replica set, replication controller, or " +"stateful set.\n" +"\n" +"\t\tScale also allows users to specify one or more preconditions for the " +"scale action.\n" +"\n" +"\t\tIf --current-replicas or --resource-version is specified, it is " +"validated before the\n" +"\t\tscale is attempted, and it is guaranteed that the precondition holds " +"true when the\n" +"\t\tscale is sent to the server." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_authinfo.go:70 +#, c-format +msgid "" +"\n" +"\t\tSet a user entry in kubeconfig.\n" +"\n" +"\t\tSpecifying a name that already exists will merge new fields on top of " +"existing values.\n" +"\n" +"\t\t Client-certificate flags:\n" +"\t\t --%v=certfile --%v=keyfile\n" +"\n" +"\t\t Bearer token flags:\n" +"\t\t\t --%v=bearer_token\n" +"\n" +"\t\t Basic auth flags:\n" +"\t\t\t --%v=basic_user --%v=basic_password\n" +"\n" +"\t\tBearer token and basic auth are mutually exclusive." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:70 +msgid "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:67 +#, c-format +msgid "" +"\n" +"\t\tSet the selector on a resource. Note that the new selector will " +"overwrite the old selector if the resource had one prior to the invocation\n" +"\t\tof 'set selector'.\n" +"\n" +"\t\tA selector must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\tIf --resource-version is specified, then updates will use this resource " +"version, otherwise the existing resource-version will be used.\n" +" Note: currently selectors can only be set on Service objects." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:39 +msgid "" +"\n" +"\t\tShow details of a specific resource or group of resources.\n" +"\n" +"\t\tPrint a detailed description of the selected resources, including " +"related resources such\n" +"\t\tas events or controllers. You may select a single object by name, all " +"objects of that\n" +"\t\ttype, provide a name prefix, or label selector. For example:\n" +"\n" +"\t\t $ kubectl describe TYPE NAME_PREFIX\n" +"\n" +"\t\twill first check for an exact match on TYPE and NAME_PREFIX. If no such " +"resource\n" +"\t\texists, it will output details for every resource that has a name " +"prefixed with NAME_PREFIX." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:47 +msgid "" +"\n" +"\t\tShow the status of the rollout.\n" +"\n" +"\t\tBy default 'rollout status' will watch the status of the latest rollout\n" +"\t\tuntil it's done. If you don't want to wait for the rollout to finish " +"then\n" +"\t\tyou can use --watch=false. Note that if a new rollout starts in-between, " +"then\n" +"\t\t'rollout status' will continue watching the latest revision. If you want " +"to\n" +"\t\tpin to a specific revision and abort if it is rolled over by another " +"revision,\n" +"\t\tuse --revision=N where N is the revision you need to watch for." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:41 +#, c-format +msgid "" +"\n" +"\t\tSpecify compute resource requirements (CPU, memory) for any resource " +"that defines a pod template. If a pod is successfully scheduled, it is " +"guaranteed the amount of resource requested, but may burst up to its " +"specified limits.\n" +"\n" +"\t\tFor each compute resource, if a limit is specified and a request is " +"omitted, the request will default to the limit.\n" +"\n" +"\t\tPossible resources include (case insensitive): %s." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_env.go:50 +msgid "" +"\n" +"\t\tUpdate environment variables on a pod template.\n" +"\n" +"\t\tList environment variable definitions in one or more pods, pod " +"templates.\n" +"\t\tAdd, update, or remove container environment variable definitions in one " +"or\n" +"\t\tmore pod templates (within replication controllers or deployment " +"configurations).\n" +"\t\tView or modify the environment variable definitions on all containers in " +"the\n" +"\t\tspecified pods or pod templates, or just those that match a wildcard.\n" +"\n" +"\t\tIf \"--env -\" is passed, environment variables can be read from STDIN " +"using the standard env\n" +"\t\tsyntax.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_image.go:71 +msgid "" +"\n" +"\t\tUpdate existing container image(s) of resources.\n" +"\n" +"\t\tPossible resources include (case insensitive):\n" +"\t\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:78 +msgid "" +"\n" +"\t\tUpdate fields of a resource using strategic merge patch, a JSON merge " +"patch, or a JSON patch.\n" +"\n" +"\t\tJSON and YAML formats are accepted." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:83 +msgid "" +"\n" +"\t\tUpdate the annotations on one or more resources.\n" +"\n" +"\t\tAll Kubernetes objects support the ability to store additional data with " +"the object as\n" +"\t\tannotations. Annotations are key/value pairs that can be larger than " +"labels and include\n" +"\t\tarbitrary string values such as structured JSON. Tools and system " +"extensions may use\n" +"\t\tannotations to store their own data.\n" +"\n" +"\t\tAttempting to set an annotation that already exists will fail unless --" +"overwrite is set.\n" +"\t\tIf --resource-version is specified and does not match the current " +"resource version on\n" +"\t\tthe server the command will fail." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:87 +#, c-format +msgid "" +"\n" +"\t\tUpdate the labels on a resource.\n" +"\n" +"\t\t* A label key and value must begin with a letter or number, and may " +"contain letters, numbers, hyphens, dots, and underscores, up to %[1]d " +"characters each.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* If --overwrite is true, then existing labels can be overwritten, " +"otherwise attempting to overwrite a label will result in an error.\n" +"\t\t* If --resource-version is specified, then updates will use this " +"resource version, otherwise the existing resource-version will be used." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:70 +#, c-format +msgid "" +"\n" +"\t\tUpdate the taints on one or more nodes.\n" +"\n" +"\t\t* A taint consists of a key, value, and effect. As an argument here, it " +"is expressed as key=value:effect.\n" +"\t\t* The key must begin with a letter or number, and may contain letters, " +"numbers, hyphens, dots, and underscores, up to %[1]d characters.\n" +"\t\t* Optionally, the key can begin with a DNS subdomain prefix and a single " +"'/', like example.com/my-app.\n" +"\t\t* The value is optional. If given, it must begin with a letter or " +"number, and may contain letters, numbers, hyphens, dots, and underscores, up " +"to %[2]d characters.\n" +"\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +"\t\t* Currently taint can only apply to node." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:36 +msgid "" +"\n" +"\t\tView previous rollout revisions and configurations." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_view_last_applied.go:47 +msgid "" +"\n" +"\t\tView the latest last-applied-configuration annotations by type/name or " +"file.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. You can use " +"the -o option\n" +"\t\tto change the output format." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:47 +msgid "" +"\n" +"\t # Create a new TLS secret named tls-secret with the given key pair\n" +"\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --key=path/" +"to/tls.key" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:42 +msgid "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:74 +msgid "" +"\n" +"\t # Create a new secret named my-secret with keys for each file in folder " +"bar\n" +"\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +"\n" +"\t # Create a new secret named my-secret with specified keys instead of " +"names on disk\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-file=ssh-publickey=path/to/id_rsa.pub\n" +"\n" +"\t # Create a new secret named my-secret with key1=supersecret and " +"key2=topsecret\n" +"\t kubectl create secret generic my-secret --from-literal=key1=supersecret " +"--from-literal=key2=topsecret\n" +"\n" +"\t # Create a new secret named my-secret using a combination of a file and " +"a literal\n" +"\t kubectl create secret generic my-secret --from-file=ssh-privatekey=path/" +"to/id_rsa --from-literal=passphrase=topsecret\n" +"\n" +"\t # Create a new secret named my-secret from an env file\n" +"\t kubectl create secret generic my-secret --from-env-file=path/to/bar.env" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:43 +msgid "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_deployment.go:45 +msgid "" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image\n" +"\tkubectl create deployment my-dep --image=busybox\n" +"\n" +"\t# Create a deployment with a command\n" +"\tkubectl create deployment my-dep --image=busybox -- date\n" +"\n" +"\t# Create a deployment named my-dep that runs the nginx image with 3 " +"replicas\n" +"\tkubectl create deployment my-dep --image=nginx --replicas=3\n" +"\n" +"\t# Create a deployment named my-dep that runs the busybox image and expose " +"port 5701\n" +"\tkubectl create deployment my-dep --image=busybox --port=5701" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:351 +msgid "" +"\n" +"\t# Create a new ExternalName service named my-ns\n" +"\tkubectl create service externalname my-ns --external-name bar.com" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:50 +msgid "" +"\n" +"\t# Set deployment nginx-deployment's service account to serviceaccount1\n" +"\tkubectl set serviceaccount deployment nginx-deployment serviceaccount1\n" +"\n" +"\t# Print the result (in YAML format) of updated nginx deployment with the " +"service account from local file, without hitting the API server\n" +"\tkubectl set sa -f nginx-deployment.yaml serviceaccount1 --local --dry-" +"run=client -o yaml\n" +"\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_deployment.go:42 +msgid "" +"\n" +"\tCreate a deployment with the specified name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:344 +msgid "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:61 +msgid "" +"\n" +"\tCreate an ingress with the specified name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:28 +msgid "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/set.go:44 +msgid "" +"\n" +"\tSet an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots.\n" +"\n" +"\tPROPERTY_VALUE is the new value you want to set. Binary fields such as " +"'certificate-authority-data' expect a base64 encoded string unless the --set-" +"raw-bytes flag is used.\n" +"\n" +"\tSpecifying an attribute name that already exists will merge new fields on " +"top of existing values." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/unset.go:39 +msgid "" +"\n" +"\tUnset an individual value in a kubeconfig file.\n" +"\n" +"\tPROPERTY_NAME is a dot delimited name where each token represents either " +"an attribute name or a map key. Map keys may not contain dots." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:43 +msgid "" +"\n" +"\tUpdate the service account of pod template resources.\n" +"\n" +"\tPossible resources (case insensitive) can be:\n" +"\n" +"\t" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_subject.go:40 +msgid "" +"\n" +"\tUpdate the user, group, or service account in a role binding or cluster " +"role binding." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_image.go:68 +msgid "" +"\n" +" \tpod (po), replicationcontroller (rc), deployment (deploy), daemonset " +"(ds), replicaset (rs)" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:63 +msgid "" +"\n" +" Forward one or more local ports to a pod.\n" +"\n" +" Use resource type/name such as deployment/mydeployment to " +"select a pod. Resource type defaults to 'pod' if omitted.\n" +"\n" +" If there are multiple pods matching the criteria, a pod will " +"be selected automatically. The\n" +" forwarding session ends when the selected pod terminates, " +"and a rerun of the command is needed\n" +" to resume forwarding." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:233 +msgid "" +"\n" +" # Create a new ClusterIP service named my-cs\n" +" kubectl create service clusterip my-cs --tcp=5678:8080\n" +"\n" +" # Create a new ClusterIP service named my-cs (in headless mode)\n" +" kubectl create service clusterip my-cs --clusterip=\"None\"" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:311 +msgid "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:274 +msgid "" +"\n" +" # Create a new NodePort service named my-ns\n" +" kubectl create service nodeport my-ns --tcp=5678:8080" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:102 +msgid "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:95 +msgid "" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend'\n" +" # If the same annotation is set multiple times, only the last value will " +"be applied\n" +" kubectl annotate pods foo description='my frontend'\n" +"\n" +" # Update a pod identified by type and name in \"pod.json\"\n" +" kubectl annotate -f pod.json description='my frontend'\n" +"\n" +" # Update pod 'foo' with the annotation 'description' and the value 'my " +"frontend running nginx', overwriting any existing value\n" +" kubectl annotate --overwrite pods foo description='my frontend running " +"nginx'\n" +"\n" +" # Update all pods in the namespace\n" +" kubectl annotate pods --all description='my frontend running nginx'\n" +"\n" +" # Update pod 'foo' only if the resource is unchanged from version 1\n" +" kubectl annotate pods foo description='my frontend running nginx' --" +"resource-version=1\n" +"\n" +" # Update pod 'foo' by removing an annotation named 'description' if it " +"exists\n" +" # Does not require the --overwrite flag\n" +" kubectl annotate pods foo description-" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:230 +msgid "" +"\n" +" Create a ClusterIP service with the specified name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:308 +msgid "" +"\n" +" Create a LoadBalancer service with the specified name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:271 +msgid "" +"\n" +" Create a NodePort service with the specified name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:93 +msgid "" +"\n" +" Dump cluster information out suitable for debugging and diagnosing " +"cluster problems. By default, dumps everything to\n" +" stdout. You can optionally specify a directory with --output-directory. " +"If you specify a directory, Kubernetes will\n" +" build a set of files in that directory. By default, only dumps things " +"in the current namespace and 'kube-system' namespace, but you can\n" +" switch to a different namespace with the --namespaces flag, or specify --" +"all-namespaces to dump all namespaces.\n" +"\n" +" The command also dumps the logs of all of the pods in the cluster; these " +"logs are dumped into different directories\n" +" based on namespace and pod name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:40 +msgid "" +"\n" +" Display addresses of the control plane and services with label kubernetes." +"io/cluster-service=true.\n" +" To further debug and diagnose cluster problems, use 'kubectl cluster-info " +"dump'." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:49 +msgid "" +" environment variable is set, then it is used as a list of paths (normal " +"path delimiting rules for your system). These paths are merged. When a value " +"is modified, it is modified in the file that defines the stanza. When a " +"value is created, it is created in the first file that exists. If no files " +"in the chain exist, then it creates the last file in the list.\n" +"\t\t\t3. Otherwise, " +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:48 +msgid "" +" flag is set, then only that file is loaded. The flag may only be set once " +"and no merging takes place.\n" +"\t\t\t2. If $" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:50 +msgid " is used and no merging takes place." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:107 +msgid "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:106 +msgid "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:113 +msgid "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:152 +msgid "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:157 +msgid "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:178 +msgid "Allocate a TTY for the debugging container." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:158 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:178 +msgid "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:173 +msgid "Annotations to apply to the pod." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:173 +msgid "Apply a configuration to a resource by file name or stdin" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:125 +msgid "Approve a certificate signing request" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:263 +msgid "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:106 +msgid "" +"Attach to a process that is already running inside an existing container." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:105 +msgid "Attach to a running container" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:107 +msgid "" +"Auto-scale a deployment, replica set, stateful set, or replication controller" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:161 +msgid "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:101 +msgid "ClusterRole this ClusterRoleBinding should reference" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:104 +msgid "ClusterRole this RoleBinding should reference" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/alpha.go:32 +msgid "Commands for features in alpha" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:170 +msgid "Container image to use for debug container." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:166 +msgid "Container name to use for debug container." +msgstr "" + +#: pkg/kubectl/cmd/convert/convert.go:95 +msgid "Convert config files between different API versions" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:105 +msgid "Copy files and directories to and from containers" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:106 +msgid "Copy files and directories to and from containers." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:248 +msgid "Create a ClusterIP service" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:323 +msgid "Create a LoadBalancer service" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:286 +msgid "Create a NodePort service" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:94 +msgid "Create a TLS secret" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:81 +msgid "Create a cluster role" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:87 +msgid "Create a cluster role binding for a particular cluster role" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:124 +msgid "Create a config map from a local file, directory or literal value" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:167 +msgid "Create a copy of the target Pod with this name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_cronjob.go:90 +msgid "Create a cron job with the specified name" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_deployment.go:100 +msgid "Create a deployment with the specified name" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:91 +msgid "Create a job with the specified name" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:83 +msgid "Create a namespace with the specified name" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:95 +msgid "Create a pod disruption budget with the specified name" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:92 +msgid "Create a priority class with the specified name" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:91 +msgid "Create a quota with the specified name" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:106 +msgid "Create a resource from a file or from stdin" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:89 +msgid "Create a role binding for a particular role or cluster role" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:161 +msgid "Create a role with single rule" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:134 +msgid "Create a secret for use with a Docker registry" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:137 +msgid "Create a secret from a local file, directory, or literal value" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:49 +msgid "Create a secret using specified subcommand" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:50 +msgid "Create a secret using specified subcommand." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:85 +msgid "Create a service account with the specified name" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:48 +msgid "Create a service using a specified subcommand" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:49 +msgid "Create a service using a specified subcommand." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:363 +msgid "Create an ExternalName service" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:145 +msgid "Create an ingress with the specified name" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:60 +msgid "Create and run a particular image in a pod." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:149 +msgid "Create debugging sessions for troubleshooting workloads and nodes" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:137 +msgid "" +"Delete resources by file names, stdin, resources and names, or by resources " +"and label selector" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:43 +msgid "Delete the specified cluster from the kubeconfig." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:43 +msgid "Delete the specified context from the kubeconfig." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_user.go:64 +msgid "Delete the specified user from the kubeconfig" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_user.go:65 +msgid "Delete the specified user from the kubeconfig." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:174 +msgid "Deny a certificate signing request" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:142 +msgid "Diff the live version against a would-be applied version" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:65 +msgid "Display cluster information" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:42 +msgid "Display clusters defined in the kubeconfig." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:50 +msgid "Display one or many contexts from the kubeconfig file." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:165 +msgid "Display one or many resources" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top.go:50 +msgid "Display resource (CPU/memory) usage" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:81 +msgid "Display resource (CPU/memory) usage of nodes" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:100 +msgid "Display resource (CPU/memory) usage of pods" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/current_context.go:51 +msgid "Display the current-context" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_users.go:60 +msgid "Display users defined in the kubeconfig" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_users.go:61 +msgid "Display users defined in the kubeconfig." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:184 +msgid "Drain node in preparation for maintenance" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:74 +msgid "Dump relevant information for debugging and diagnosis" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:77 +msgid "Edit a resource on the server" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_edit_last_applied.go:67 +msgid "Edit latest last-applied-configuration annotations of a resource/object" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:152 +msgid "Email for Docker registry" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:169 +msgid "Environment variables to set in the container." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:89 +msgid "Execute a command in a container" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:90 +msgid "Execute a command in a container." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/wait/wait.go:115 +msgid "Experimental: Wait for a specific condition on one or many resources" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:378 +msgid "External name of service" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:109 +msgid "Forward one or more local ports to a pod" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:79 +msgid "Get documentation for a resource" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:37 +msgid "Help about any command" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:151 +msgid "" +"IP to assign to the LoadBalancer. If empty, an ephemeral IP will be created " +"and used (cloud-provider specific)." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:160 +msgid "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:157 +msgid "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:154 +msgid "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:164 +msgid "" +"If specified, everything after -- will be passed to the new container as " +"Args instead of Command." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:198 +msgid "If true, run the container in privileged mode." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:174 +msgid "If true, suppress informational messages." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:165 +msgid "" +"If true, wait for the container to start running, and then attach as if " +"'kubectl attach ...' were called. Default false, unless '-i/--stdin' is " +"set, in which case the default is true." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:173 +msgid "" +"Keep stdin open on the container(s) in the pod, even if nothing is attached." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:90 +msgid "List all visible plugin executables on a user's PATH" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout.go:54 +msgid "Manage the rollout of a resource" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:98 +msgid "Mark node as schedulable" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:69 +msgid "Mark node as unschedulable" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:83 +msgid "Mark the provided resource as paused" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:49 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:50 +msgid "Modify certificate resources." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:156 +msgid "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/alpha.go:43 +msgid "No alpha commands are available in this version of kubectl" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:174 +msgid "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:112 +msgid "Output shell completion code for the specified shell (bash or zsh)" +msgstr "" + +#: pkg/kubectl/cmd/convert/convert.go:105 +msgid "" +"Output the formatted object with the given group version (for ex: " +"'extensions/v1beta1')." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:151 +msgid "Password for Docker registry authentication" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:110 +msgid "Path to PEM encoded public key certificate." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:111 +msgid "Path to private key associated with given certificate." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:130 +msgid "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:73 +msgid "Print the client and server version information" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:74 +msgid "" +"Print the client and server version information for the current context." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:38 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:39 +msgid "Print the list of flags inherited by all commands" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:152 +msgid "Print the logs for a container in a pod" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiresources.go:97 +msgid "Print the supported API resources on the server" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiresources.go:98 +msgid "Print the supported API resources on the server." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:58 +msgid "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:59 +msgid "" +"Print the supported API versions on the server, in the form of \"group/" +"version\"." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/plugin/plugin.go:62 +msgid "Provides utilities for interacting with plugins" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/rename_context.go:45 +msgid "Rename a context from the kubeconfig file" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:115 +msgid "Replace a resource by file name or stdin" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_restart.go:87 +msgid "Restart a resource" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:87 +msgid "Resume a paused resource" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:105 +msgid "Role this RoleBinding should reference" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:152 +msgid "Run a particular image on the cluster" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:119 +msgid "Run a proxy to the Kubernetes API server" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:153 +msgid "Server location for Docker registry" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_cluster.go:73 +msgid "Set a cluster entry in kubeconfig" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_context.go:61 +msgid "Set a context entry in kubeconfig" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:114 +msgid "Set a new size for a deployment, replica set, or replication controller" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/create_authinfo.go:152 +msgid "Set a user entry in kubeconfig" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/set.go:74 +msgid "Set an individual value in a kubeconfig file" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:39 +msgid "Set specific features on objects" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/use_context.go:52 +msgid "Set the current-context in a kubeconfig file" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:101 +msgid "" +"Set the last-applied-configuration annotation on a live object to match the " +"contents of a file" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:104 +msgid "Set the selector on a resource" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:107 +msgid "Show details of a specific resource or group of resources" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:102 +msgid "Show the status of the rollout" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:154 +msgid "Synonym for --target-port" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:134 +msgid "" +"Take a replication controller, service, deployment or pod and expose it as a " +"new Kubernetes service" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:174 +msgid "The image for the container to run." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:176 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:172 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:112 +msgid "" +"The maximum number or percentage of unavailable pods this budget requires." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:111 +msgid "" +"The minimum number or percentage of available pods this budget requires." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:159 +msgid "The name for the newly created object." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:125 +msgid "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:147 +msgid "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:148 +msgid "The network protocol for the service to be created. Default is 'TCP'." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:149 +msgid "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:182 +msgid "The port that this container exposes." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:194 +msgid "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:192 +msgid "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:190 +msgid "" +"The restart policy for this Pod. Legal values [Always, OnFailure, Never]." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:155 +msgid "The type of secret to create" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/alpha.go:33 +msgid "" +"These commands correspond to alpha features that are not enabled in " +"Kubernetes clusters by default." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:150 +msgid "" +"Type for this service: ClusterIP, NodePort, LoadBalancer, or ExternalName. " +"Default is 'ClusterIP'." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:87 +msgid "Undo a previous rollout" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/unset.go:59 +msgid "Unset an individual value in a kubeconfig file" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_env.go:154 +msgid "Update environment variables on a pod template" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:115 +msgid "Update fields of a resource" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:116 +msgid "Update resource requests/limits on objects with pod templates" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_image.go:110 +msgid "Update the image of a pod template" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:133 +msgid "Update the labels on a resource" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:102 +msgid "Update the service account of a resource" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:109 +msgid "Update the taints on one or more nodes" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_subject.go:99 +msgid "" +"Update the user, group, or service account in a role binding or cluster role " +"binding" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:150 +msgid "Username for Docker registry authentication" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:83 +msgid "View rollout history" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_view_last_applied.go:77 +msgid "" +"View the latest last-applied-configuration annotations of a resource/object" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:171 +msgid "" +"When used with '--copy-to', a list of name=image pairs for changing " +"container images, similar to how 'kubectl set image' works." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:168 +msgid "When used with '--copy-to', delete the original Pod." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:176 +msgid "" +"When used with '--copy-to', enable process namespace sharing in the copy." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:175 +msgid "" +"When used with '--copy-to', schedule the copy of target Pod on the same node." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:177 +msgid "" +"When using an ephemeral container, target processes in this container name." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:85 +msgid "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:108 +msgid "" +"description is an arbitrary string that usually provides guidelines on when " +"this priority class should be used." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run_test.go:88 +msgid "dummy restart flag)" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:107 +msgid "" +"global-default specifies whether this PriorityClass should be considered as " +"the default priority." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/cmd.go:227 +msgid "kubectl controls the Kubernetes cluster manager" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:45 +msgid "" +"pod (po), service (svc), replicationcontroller (rc), deployment (deploy), " +"replicaset (rs)" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:109 +msgid "" +"preemption-policy is the policy for preempting pods with lower priority." +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_serviceaccount.go:41 +msgid "" +"replicationcontroller (rc), deployment (deploy), daemonset (ds), job, " +"replicaset (rs), statefulset" +msgstr "" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:106 +msgid "the value of this priority class." +msgstr "" diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_CN/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_CN/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..68c526d19a Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_CN/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_CN/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_CN/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..a8314bb89d --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_CN/LC_MESSAGES/k8s.po @@ -0,0 +1,3287 @@ +# Test translations for unit tests. +# Copyright (C) 2017 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR shiywang@redhat.com, 2017. +# FIRST AUTHOR zhengjiajin@caicloud.io, 2017. +# +msgid "" +msgstr "" +"Project-Id-Version: gettext-go-examples-hello\n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2017-11-11 19:01+0800\n" +"Last-Translator: zhengjiajin \n" +"Language-Team: \n" +"Language: zh\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 2.0.4\n" +"X-Poedit-SourceCharset: UTF-8\n" +"Plural-Forms: nplurals=2; plural=(n > 1);\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:62 +msgid "" +"\n" +"\t\t # Show metrics for all nodes\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # Show metrics for a given node\n" +"\t\t kubectl top node NODE_NAME" +msgstr "" +"\n" +"\t\t # 显示所有 nodes 上的指标\n" +"\t\t kubectl top node\n" +"\n" +"\t\t # 显示指定 node 上的指标\n" +"\t\t kubectl top node NODE_NAME" + +#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:46 +msgid "" +"\n" +"\t\t# Get the documentation of the resource and its fields\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# Get the documentation of a specific field of a resource\n" +"\t\tkubectl explain pods.spec.containers" +msgstr "" +"\n" +"\t\t# 获取资源及其字段的文档\n" +"\t\tkubectl explain pods\n" +"\n" +"\t\t# 获取资源指定字段的文档\n" +"\t\tkubectl explain pods.spec.containers" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/options.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:29 +msgid "" +"\n" +"\t\t# Print flags inherited by all commands\n" +"\t\tkubectl options" +msgstr "" +"\n" +"\t\t# 输出所有命令继承的 flags\n" +"\t\tkubectl options" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/version.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:44 +msgid "" +"\n" +"\t\t# Print the client and server versions for the current context\n" +"\t\tkubectl version" +msgstr "" +"\n" +"\t\t# 输出当前 client 和 server 版本\n" +"\t\tkubectl version" + +#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:34 +msgid "" +"\n" +"\t\t# Print the supported API versions\n" +"\t\tkubectl api-versions" +msgstr "" +"\n" +"\t\t# 输出支持的 API 版本\n" +"\t\tkubectl api-versions" + +#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_pod.go:75 +msgid "" +"\n" +"\t\t# Show metrics for all pods in the default namespace\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# Show metrics for all pods in the given namespace\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# Show metrics for a given pod and its containers\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# Show metrics for the pods defined by label name=myLabel\n" +"\t\tkubectl top pod -l name=myLabel" +msgstr "" +"\n" +"\t\t# 显示 default namespace 下所有 pods 下的 metrics\n" +"\t\tkubectl top pod\n" +"\n" +"\t\t# 显示指定 namespace 下所有 pods 的 metrics\n" +"\t\tkubectl top pod --namespace=NAMESPACE\n" +"\n" +"\t\t# 显示指定 pod 和它的容器的 metrics\n" +"\t\tkubectl top pod POD_NAME --containers\n" +"\n" +"\t\t# 显示指定 label 为 name=myLabel 的 pods 的 metrics\n" +"\t\tkubectl top pod -l name=myLabel" + +#: pkg/kubectl/cmd/convert/convert.go:40 +msgid "" +"\n" +"\t\tConvert config files between different API versions. Both YAML\n" +"\t\tand JSON formats are accepted.\n" +"\n" +"\t\tThe command takes filename, directory, or URL as input, and convert it " +"into format\n" +"\t\tof version specified by --output-version flag. If target version is not " +"specified or\n" +"\t\tnot supported, convert to latest version.\n" +"\n" +"\t\tThe default output will be printed to stdout in YAML format. One can use " +"-o option\n" +"\t\tto change to output destination." +msgstr "" +"\n" +"\t\t在不同的 API versions 转换配置文件. 接受 YAML\n" +"\t\t和 JSON 格式.\n" +"\n" +"\t\t这个命令以 filename, directory, 或者 URL 作为输入, 并通过 —output-" +"version flag\n" +"\t\t 转换到指定版本的格式. 如果目标版本没有被指定或者\n" +"\t\t不支持, 转换到最后的版本.\n" +"\n" +"\t\t默认以 YAML 格式输出到 stdout. 可以使用 -o option\n" +"\t\t修改目标输出的格式." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:39 +msgid "" +"\n" +"\t\tCreate a namespace with the specified name." +msgstr "" +"\n" +"\t\t创建一个 namespace 并指定名称." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L47 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:43 +msgid "" +"\n" +"\t\tCreate a role with single rule." +msgstr "" +"\n" +"\t\t创建单一 rule 的 role." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:40 +msgid "" +"\n" +"\t\tCreate a service account with the specified name." +msgstr "" +"\n" +"\t\t创建一个指定名称的 service account." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L127 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:84 +msgid "" +"\n" +"\t\tMark node as schedulable." +msgstr "" +"\n" +"\t\t标记 node 为 schedulable." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:55 +msgid "" +"\n" +"\t\tMark node as unschedulable." +msgstr "" +"\n" +"\t\t标记 node 为 unschedulable." + +#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply_set_last_applied.go:70 +msgid "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." +msgstr "" +"\n" +"\t\tSet the latest last-applied-configuration annotations by setting it to " +"match the contents of a file.\n" +"\t\tThis results in the last-applied-configuration being updated as though " +"'kubectl apply -f ' was run,\n" +"\t\twithout updating any other parts of the object." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:42 +msgid "" +"\n" +"\t # Create a new namespace named my-namespace\n" +"\t kubectl create namespace my-namespace" +msgstr "" +"\n" +"\t # 创建一个名称为 my-namespace 的 namespace\n" +"\t kubectl create namespace my-namespace" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:43 +msgid "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" +msgstr "" +"\n" +"\t # Create a new service account named my-service-account\n" +"\t kubectl create serviceaccount my-service-account" + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:344 +msgid "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." +msgstr "" +"\n" +"\tCreate an ExternalName service with the specified name.\n" +"\n" +"\tExternalName service references to an external DNS address instead of\n" +"\tonly pods, which will allow application authors to reference services\n" +"\tthat exist off platform, on other clusters, or locally." + +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:28 +msgid "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." +msgstr "" +"\n" +"\tHelp provides help for any command in the application.\n" +"\tSimply type kubectl help [path to command] for full details." + +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:311 +msgid "" +"\n" +" # Create a new LoadBalancer service named my-lbs\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" +msgstr "" +"\n" +" # 创建一个名称为 my-lbs 的 LoadBalancer service\n" +" kubectl create service loadbalancer my-lbs --tcp=5678:8080" + +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:102 +msgid "" +"\n" +" # Dump current cluster state to stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # Dump current cluster state to /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # Dump all namespaces to stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # Dump a set of namespaces to /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" +msgstr "" +"\n" +" # 导出当前的集群状态信息到 stdout\n" +" kubectl cluster-info dump\n" +"\n" +" # 导出当前的集群状态 /path/to/cluster-state\n" +" kubectl cluster-info dump --output-directory=/path/to/cluster-state\n" +"\n" +" # 导出所有分区到 stdout\n" +" kubectl cluster-info dump --all-namespaces\n" +"\n" +" # 导出一组分区到 /path/to/cluster-state\n" +" kubectl cluster-info dump --namespaces default,kube-system --output-" +"directory=/path/to/cluster-state" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:308 +msgid "" +"\n" +" Create a LoadBalancer service with the specified name." +msgstr "" +"\n" +" 使用一个指定的名称创建一个 LoadBalancer service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L61 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:107 +msgid "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." +msgstr "" +"A comma-delimited set of quota scopes that must all match each object " +"tracked by the quota." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L60 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:106 +msgid "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." +msgstr "" +"A comma-delimited set of resource=quantity pairs that define a hard limit." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L63 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:113 +msgid "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." +msgstr "" +"A label selector to use for this budget. Only equality-based selector " +"requirements are supported." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L106 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:152 +msgid "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" +msgstr "" +"A label selector to use for this service. Only equality-based selector " +"requirements are supported. If empty (the default) infer the selector from " +"the replication controller or replica set.)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L111 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:157 +msgid "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." +msgstr "" +"Additional external IP address (not managed by Kubernetes) to accept for the " +"service. If this IP is routed to a node, the service can be accessed by this " +"IP in addition to its generated service IP." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L119 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:158 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:178 +msgid "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." +msgstr "" +"An inline JSON override for the generated object. If this is non-empty, it " +"is used to override the generated object. Requires that the object supply a " +"valid apiVersion field." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:125 +msgid "Approve a certificate signing request" +msgstr "同意一个自签证书请求" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L81 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_service.go:263 +msgid "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." +msgstr "" +"Assign your own ClusterIP or set to 'None' for a 'headless' service (no " +"loadbalancing)." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/attach.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:105 +msgid "Attach to a running container" +msgstr "Attach 到一个运行中的 container" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L115 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:161 +msgid "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." +msgstr "" +"ClusterIP to be assigned to the service. Leave empty to auto-allocate, or " +"set to 'None' to create a headless service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_clusterrolebinding.go#L55 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:101 +msgid "ClusterRole this ClusterRoleBinding should reference" +msgstr "ClusterRoleBinding 应该指定 ClusterRole" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L55 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:104 +msgid "ClusterRole this RoleBinding should reference" +msgstr "RoleBinding 应该指定 ClusterRole" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/convert.go#L67 +#: pkg/kubectl/cmd/convert/convert.go:95 +msgid "Convert config files between different API versions" +msgstr "在不同的 API versions 转换配置文件" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/cp.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:106 +msgid "Copy files and directories to and from containers." +msgstr "" +"复制 files 和 directories 到 containers 和从容器中复制 files 和 directories." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L214 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:94 +msgid "Create a TLS secret" +msgstr "创建一个 TLS secret" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_namespace.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_namespace.go:83 +msgid "Create a namespace with the specified name" +msgstr "创建一个指定名称的 namespace" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L143 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:134 +msgid "Create a secret for use with a Docker registry" +msgstr "创建一个给 Docker registry 使用的 secret" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L34 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:49 +msgid "Create a secret using specified subcommand" +msgstr "使用指定的 subcommand 创建一个 secret" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go:85 +msgid "Create a service account with the specified name" +msgstr "创建一个指定名称的 service account" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_cluster.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "删除 kubeconfig 文件中指定的集群" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/delete_context.go#L38 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "删除 kubeconfig 文件中指定的 context" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L121 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:174 +msgid "Deny a certificate signing request" +msgstr "拒绝一个自签证书请求" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_contexts.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "描述一个或多个 contexts" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/get_clusters.go#L40 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "显示 kubeconfig 文件中定义的集群" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/view.go#L64 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "显示合并的 kubeconfig 配置或一个指定的 kubeconfig 文件" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/get.go#L107 +#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:165 +msgid "Display one or many resources" +msgstr "显示一个或更多 resources" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L176 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:184 +msgid "Drain node in preparation for maintenance" +msgstr "Drain node in preparation for maintenance" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/edit.go#L100 +#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:77 +msgid "Edit a resource on the server" +msgstr "在服务器上编辑一个资源" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L159 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:152 +msgid "Email for Docker registry" +msgstr "Email for Docker registry" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/exec.go#L68 +#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:89 +msgid "Execute a command in a container" +msgstr "在一个 container 中执行一个命令" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/portforward.go#L75 +#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:109 +msgid "Forward one or more local ports to a pod" +msgstr "Forward one or more local ports to a pod" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/help.go#L36 +#: staging/src/k8s.io/kubectl/pkg/cmd/help/help.go:37 +msgid "Help about any command" +msgstr "Help about any command" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L114 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:160 +msgid "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" +msgstr "" +"If non-empty, set the session affinity for the service to this; legal " +"values: 'None', 'ClientIP'" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/annotate.go#L135 +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:157 +msgid "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"If non-empty, the annotation update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/label.go#L132 +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:154 +msgid "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." +msgstr "" +"If non-empty, the labels update will only succeed if this is the current " +"resource-version for the object. Only valid when specifying a single " +"resource." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L127 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:98 +msgid "Mark node as schedulable" +msgstr "标记 node 为 schedulable" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:69 +msgid "Mark node as unschedulable" +msgstr "标记 node 为 unschedulable" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_pause.go#L73 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_pause.go:83 +msgid "Mark the provided resource as paused" +msgstr "标记提供的 resource 为中止状态" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/certificates.go#L35 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:49 +#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:50 +msgid "Modify certificate resources." +msgstr "修改 certificate 资源." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/config.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "修改 kubeconfig 文件" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L110 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:156 +msgid "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." +msgstr "" +"Name or number for the port on the container that the service should direct " +"traffic to. Optional." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/logs.go#L108 +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:174 +msgid "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." +msgstr "" +"Only return logs after a specific date (RFC3339). Defaults to all logs. Only " +"one of since-time / since may be used." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/completion.go#L97 +#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:112 +msgid "Output shell completion code for the specified shell (bash or zsh)" +msgstr "Output shell completion code for the specified shell (bash or zsh)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L157 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:151 +msgid "Password for Docker registry authentication" +msgstr "Password for Docker registry authentication" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L226 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:110 +msgid "Path to PEM encoded public key certificate." +msgstr "Path to PEM encoded public key certificate." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L227 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_tls.go:111 +msgid "Path to private key associated with given certificate." +msgstr "Path to private key associated with given certificate." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/scale.go#L82 +#: staging/src/k8s.io/kubectl/pkg/cmd/scale/scale.go:130 +msgid "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." +msgstr "" +"Precondition for resource version. Requires that the current resource " +"version match this value in order to scale." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/version.go#L39 +#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:73 +msgid "Print the client and server version information" +msgstr "输出 client 和 server 的版本信息" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/options.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:38 +#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:39 +msgid "Print the list of flags inherited by all commands" +msgstr "输出所有命令的层级关系" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/logs.go#L86 +#: staging/src/k8s.io/kubectl/pkg/cmd/logs/logs.go:152 +msgid "Print the logs for a container in a pod" +msgstr "输出容器在 pod 中的日志" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_resume.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_resume.go:87 +msgid "Resume a paused resource" +msgstr "继续一个停止的 resource" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L56 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:105 +msgid "Role this RoleBinding should reference" +msgstr "RoleBinding 的 Role 应该被引用" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L94 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:152 +msgid "Run a particular image on the cluster" +msgstr "在集群中运行一个指定的镜像" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/proxy.go#L68 +#: staging/src/k8s.io/kubectl/pkg/cmd/proxy/proxy.go:119 +msgid "Run a proxy to the Kubernetes API server" +msgstr "运行一个 proxy 到 Kubernetes API server" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L161 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:153 +msgid "Server location for Docker registry" +msgstr "Server location for Docker registry" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set.go#L37 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set.go:39 +msgid "Set specific features on objects" +msgstr "为 objects 设置一个指定的特征" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_selector.go#L81 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_selector.go:104 +msgid "Set the selector on a resource" +msgstr "设置 resource 的 selector" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/describe.go#L80 +#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:107 +msgid "Show details of a specific resource or group of resources" +msgstr "显示一个指定 resource 或者 group 的 resources 详情" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_status.go#L57 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_status.go:102 +msgid "Show the status of the rollout" +msgstr "显示 rollout 的状态" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L108 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:154 +msgid "Synonym for --target-port" +msgstr "Synonym for --target-port" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L114 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:174 +msgid "The image for the container to run." +msgstr "指定容器要运行的镜像." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L116 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:176 +msgid "" +"The image pull policy for the container. If left empty, this value will not " +"be specified by the client and defaulted by the server" +msgstr "" +"容器的镜像拉取策略. 如果为空, 这个值将不会 被 client 指定且使用 server 端的默" +"认值" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L62 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:111 +msgid "" +"The minimum number or percentage of available pods this budget requires." +msgstr "最小数量百分比可用的 pods 作为 budget 要求." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L113 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:159 +msgid "The name for the newly created object." +msgstr "名称为最新创建的对象." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/autoscale.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:125 +msgid "" +"The name for the newly created object. If not specified, the name of the " +"input resource will be used." +msgstr "名称为最新创建的对象. 如果没有指定, 输入资源的 名称即将被使用." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L98 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:147 +msgid "" +"The name of the API generator to use. There are 2 generators: 'service/v1' " +"and 'service/v2'. The only difference between them is that service port in " +"v1 is named 'default', while it is left unnamed in v2. Default is 'service/" +"v2'." +msgstr "" +"使用 generator 的名称. 这里有 2 个 generators: 'service/v1' 和 'service/v2'. " +"为一个不同地方是服务端口在 v1 的情况下叫 'default', 如果在 v2 中没有指定名" +"称. 默认的名称是 'service/v2'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L99 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:148 +msgid "The network protocol for the service to be created. Default is 'TCP'." +msgstr "创建 service 的时候伴随着一个网络协议被创建. 默认是 'TCP'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L100 +#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:149 +msgid "" +"The port that the service should serve on. Copied from the resource being " +"exposed, if unspecified" +msgstr "服务的端口应该被指定. 如果没有指定, 从被创建的资源中复制" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L131 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:194 +msgid "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." +msgstr "" +"The resource requirement limits for this container. For example, 'cpu=200m," +"memory=512Mi'. Note that server side components may assign limits depending " +"on the server configuration, such as limit ranges." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L130 +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run.go:192 +msgid "" +"The resource requirement requests for this container. For example, " +"'cpu=100m,memory=256Mi'. Note that server side components may assign " +"requests depending on the server configuration, such as limit ranges." +msgstr "" +"资源为 container 请求 requests . 例如, 'cpu=100m,memory=256Mi'. 注意服务端组" +"件也许会赋予 requests, 这决定于服务器端配置, 比如 limit ranges." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L87 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret.go:155 +msgid "The type of secret to create" +msgstr "创建 secret 类型资源" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_undo.go#L71 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_undo.go:87 +msgid "Undo a previous rollout" +msgstr "撤销上一次的 rollout" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_resources.go#L101 +#: staging/src/k8s.io/kubectl/pkg/cmd/set/set_resources.go:116 +msgid "Update resource requests/limits on objects with pod templates" +msgstr "在对象的 pod templates 上更新资源的 requests/limits" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "更新一个资源的注解" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/label.go#L109 +#: staging/src/k8s.io/kubectl/pkg/cmd/label/label.go:133 +msgid "Update the labels on a resource" +msgstr "更新在这个资源上的 labels" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/taint.go#L88 +#: staging/src/k8s.io/kubectl/pkg/cmd/taint/taint.go:109 +msgid "Update the taints on one or more nodes" +msgstr "更新一个或者多个 node 上的 taints" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L155 +#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:150 +msgid "Username for Docker registry authentication" +msgstr "Username 为 Docker registry authentication" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout_history.go#L51 +#: staging/src/k8s.io/kubectl/pkg/cmd/rollout/rollout_history.go:83 +msgid "View rollout history" +msgstr "显示 rollout 历史" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/clusterinfo_dump.go#L45 +#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo_dump.go:85 +msgid "" +"Where to output the files. If empty or '-' uses stdout, otherwise creates a " +"directory hierarchy in that directory" +msgstr "" +"输出到 files. 如果是 empty or '-' 使用 stdout, 否则创建一个 目录层级在那个目" +"录" + +#: staging/src/k8s.io/kubectl/pkg/cmd/run/run_test.go:88 +msgid "dummy restart flag)" +msgstr "dummy restart flag)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/cmd.go#L217 +#: staging/src/k8s.io/kubectl/pkg/cmd/cmd.go:227 +msgid "kubectl controls the Kubernetes cluster manager" +msgstr "kubectl 控制 Kubernetes cluster 管理" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a ClusterRoleBinding for user1, user2, and group1 using " +#~ "the cluster-admin ClusterRole\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin --user=user1 --user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # 使用 cluster-admin ClusterRole 为 user1, user2, and group1 创建一" +#~ "个 ClusterRoleBinding\n" +#~ "\t\t kubectl create clusterrolebinding cluster-admin --" +#~ "clusterrole=cluster-admin --user=user1 --user=user2 --group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a RoleBinding for user1, user2, and group1 using the admin " +#~ "ClusterRole\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +#~ "user=user2 --group=group1" +#~ msgstr "" +#~ "\n" +#~ "\t\t # 使用 admin ClusterRole 为 user1, user2, and group1 创建一个 " +#~ "RoleBinding\n" +#~ "\t\t kubectl create rolebinding admin --clusterrole=admin --user=user1 --" +#~ "user=user2 --group=group1" + +#~ msgid "" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config based on folder bar\n" +#~ "\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with specified keys " +#~ "instead of file basenames on disk\n" +#~ "\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/" +#~ "file1.txt --from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # Create a new configmap named my-config with key1=config1 and " +#~ "key2=config2\n" +#~ "\t\t kubectl create configmap my-config --from-literal=key1=config1 --" +#~ "from-literal=key2=config2" +#~ msgstr "" +#~ "\n" +#~ "\t\t # 通过文件夹 bar 创建一个名称为 my-config 的 configmap\n" +#~ "\t\t kubectl create configmap my-config --from-file=path/to/bar\n" +#~ "\n" +#~ "\t\t # 创建一个名称为 my-config 的 configmap 并指定 keys 而不是使用磁盘上" +#~ "所在的文件名\n" +#~ "\t\t kubectl create configmap my-config --from-file=key1=/path/to/bar/" +#~ "file1.txt --from-file=key2=/path/to/bar/file2.txt\n" +#~ "\n" +#~ "\t\t # 创建一个名称为 my-config 的 configmap 且 key1=config1 和 " +#~ "key2=config2\n" +#~ "\t\t kubectl create configmap my-config --from-literal=key1=config1 --" +#~ "from-literal=key2=config2" + +#~ msgid "" +#~ "\n" +#~ "\t\t # If you don't already have a .dockercfg file, you can create a " +#~ "dockercfg secret directly by using:\n" +#~ "\t\t kubectl create secret docker-registry my-secret --docker-" +#~ "server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +#~ "password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL" +#~ msgstr "" +#~ "\n" +#~ "\t\t # 如果你还没有一个 .dockercfg 文件, 你可以直接使用下面的命令创建一" +#~ "个 dockercfg 的 secret:\n" +#~ "\t\t kubectl create secret docker-registry my-secret --docker-" +#~ "server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-" +#~ "password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Apply the configuration in pod.json to a pod.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Apply the JSON passed into stdin to a pod.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Note: --prune is still in Alpha\n" +#~ "\t\t# Apply the configuration in manifest.yaml that matches label " +#~ "app=nginx and delete all the other resources that are not in the file and " +#~ "match label app=nginx.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# Apply the configuration in manifest.yaml and delete all the other " +#~ "configmaps that are not in the file.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/" +#~ "v1/ConfigMap" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 将 pod.json 上的配置应用于 pod.\n" +#~ "\t\tkubectl apply -f ./pod.json\n" +#~ "\n" +#~ "\t\t# 将传入 stdin 的 JSON 应用到一个 pod.\n" +#~ "\t\tcat pod.json | kubectl apply -f -\n" +#~ "\n" +#~ "\t\t# Note: --prune 仍然在 Alpha\n" +#~ "\t\t# 应用在 manifest.yaml 中匹配标签 app=nginx 的资源配置并删除所有不在这" +#~ "个文件中并匹配标签app=nginx 的资源\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n" +#~ "\n" +#~ "\t\t# 应用 manifest.yaml 的配置并删除所有不在这个文件中的 configmaps.\n" +#~ "\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/" +#~ "v1/ConfigMap" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Auto scale a deployment \"foo\", with the number of pods between 2 " +#~ "and 10, target CPU utilization specified so a default autoscaling policy " +#~ "will be used:\n" +#~ "\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +#~ "\n" +#~ "\t\t# Auto scale a replication controller \"foo\", with the number of " +#~ "pods between 1 and 5, target CPU utilization at 80%:\n" +#~ "\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 自动弹性伸缩 deployment \"foo\", pods 的数量在 2 和 10 之间, 目标 " +#~ "CPU 指定为默认的弹性伸缩策略:\n" +#~ "\t\tkubectl autoscale deployment foo --min=2 --max=10\n" +#~ "\n" +#~ "\t\t# 自动弹性伸缩 replication controller \"foo\", pods 的数量在 1 和 5 之" +#~ "间, 目标 CPU 利用率为 80%:\n" +#~ "\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# Convert the live state of the resource specified by 'pod.yaml' to " +#~ "the latest version\n" +#~ "\t\t# and print to stdout in json format.\n" +#~ "\t\tkubectl convert -f pod.yaml --local -o json\n" +#~ "\n" +#~ "\t\t# Convert all files under current directory to latest version and " +#~ "create them all.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 将’pod.yaml' 转换为最新版本并打印到 stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml\n" +#~ "\n" +#~ "\t\t# 将 ‘pod.yaml' 指定的资源的实时状态转换为最新版本\n" +#~ "\t\t# 并以 json 格式打印到 stdout.\n" +#~ "\t\tkubectl convert -f pod.yaml --local -o json\n" +#~ "\n" +#~ "\t\t# 将当前目录下的所以文件转换为最新版本并创建它们.\n" +#~ "\t\tkubectl convert -f . | kubectl create -f -" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" that allows user to " +#~ "perform \"get\", \"watch\" and \"list\" on pods\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# Create a ClusterRole named \"pod-reader\" with ResourceName " +#~ "specified\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods --resource-name=readablepod" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 创建一个名为 \"pod-reader\" 的 ClusterRole, 允许用户在 pods 上执行 " +#~ "“get\", \"watch\" 和 \"list\"\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods\n" +#~ "\n" +#~ "\t\t# 创建一个名为 \"pod-reader\" ClusterRole, 其中指定了 ResourceName\n" +#~ "\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --" +#~ "resource=pods --resource-name=readablepod" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a new resourcequota named my-quota\n" +#~ "\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2," +#~ "services=3,replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# Create a new resourcequota named best-effort\n" +#~ "\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 创建一个名为 my-quota 的 resourcequota\n" +#~ "\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2," +#~ "services=3,replicationcontrollers=2,resourcequotas=1,secrets=5," +#~ "persistentvolumeclaims=10\n" +#~ "\n" +#~ "\t\t# 创建一个名为 best-effort 的 resourcequota\n" +#~ "\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=rails label\n" +#~ "\t\t# and require at least one of them being available at any point in " +#~ "time.\n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# Create a pod disruption budget named my-pdb that will select all " +#~ "pods with the app=nginx label\n" +#~ "\t\t# and require at least half of the pods selected to be available at " +#~ "any point in time.\n" +#~ "\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 创建一个名称为 my-pdb 的 pod disruption budget 并将会选择所有 " +#~ "app=rails 标签的 pods\n" +#~ "\t\t# 并要求他们在同一时间中最少有一个可用. \n" +#~ "\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-" +#~ "available=1\n" +#~ "\n" +#~ "\t\t# 创建一个名称为 my-pdb 的 pod disruption budget 并将会选择所有 " +#~ "app=rails 标签的 pods\n" +#~ "\t\t# 并要求他们在同一时间中最少有一半可用.\n" +#~ "\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a pod using the data in pod.json.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Create a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# Edit the data in docker-registry.yaml in JSON using the v1 API " +#~ "format then create the resource using the edited data.\n" +#~ "\t\tkubectl create -f docker-registry.yaml --edit --output-version=v1 -o " +#~ "json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 使用在 pod.json 的 数据创建一个 pod.\n" +#~ "\t\tkubectl create -f ./pod.json\n" +#~ "\n" +#~ "\t\t# 根据传入 stdin 的 JSON 创建一个 pod.\n" +#~ "\t\tcat pod.json | kubectl create -f -\n" +#~ "\n" +#~ "\t\t# 使用 v1 API 格式在 JSON 中编辑在 docker-registry.yaml 中的数据然后使" +#~ "用被编辑后的数据创建资源.\n" +#~ "\t\tkubectl create -f docker-registry.yaml --edit --output-version=v1 -o " +#~ "json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a replication controller identified by type " +#~ "and name specified in \"nginx-controller.yaml\", which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for a pod valid-pod, which serves on port 444 with " +#~ "the name \"frontend\"\n" +#~ "\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +#~ "\n" +#~ "\t\t# Create a second service based on the above service, exposing the " +#~ "container port 8443 as port 443 with the name \"nginx-https\"\n" +#~ "\t\tkubectl expose service nginx --port=443 --target-port=8443 --" +#~ "name=nginx-https\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated streaming application on port " +#~ "4100 balancing UDP traffic and named 'video-stream'.\n" +#~ "\t\tkubectl expose rc streamer --port=4100 --protocol=udp --name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# Create a service for a replicated nginx using replica set, which " +#~ "serves on port 80 and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# Create a service for an nginx deployment, which serves on port 80 " +#~ "and connects to the containers on port 8000.\n" +#~ "\t\tkubectl expose deployment nginx --port=80 --target-port=8000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 为一个 replicated nginx 创建一个 service, 服务在端口 80 并连接到 " +#~ "containers 的8000端口.\n" +#~ "\t\tkubectl expose rc nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# 使用在 \"nginx-controller.yaml\\ 中指定的 type 和 name 为一个" +#~ "replication controller 创建一个 service, 服务在端口 80 并连接到 " +#~ "containers 的8000端口.\n" +#~ "\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# 为名为 valid-pod 的 pod 创建一个 service, 服务在端口 444 并命名为 " +#~ "\"frontend\" \n" +#~ "\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n" +#~ "\n" +#~ "\t\t# 基于上面的 service 创建第二个 service, 暴露容器端口 8443 并命名为 " +#~ "\"nginx-https\" 端口为 443 \n" +#~ "\t\tkubectl expose service nginx --port=443 --target-port=8443 --" +#~ "name=nginx-https\n" +#~ "\n" +#~ "\t\t# 为一个名称为 streaming 的应用创建一个 service 暴露端口 4100, 协议为 " +#~ "UDP 名称为 'video-stream'.\n" +#~ "\t\tkubectl expose rc streamer --port=4100 --protocol=udp --name=video-" +#~ "stream\n" +#~ "\n" +#~ "\t\t# 为一个名称为 nginx 的 replica set 创建一个 service, 服务在 端口 80 " +#~ "且连接到容器端口 8000.\n" +#~ "\t\tkubectl expose rs nginx --port=80 --target-port=8000\n" +#~ "\n" +#~ "\t\t# 为一个名称为 nginx 的 deployment 创建一个 service, 服务在端口 80 且 " +#~ "连接到 containers 的 8000 端口.\n" +#~ "\t\tkubectl expose deployment nginx --port=80 --target-port=8000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Delete a pod using the type and name specified in pod.json.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Delete a pod based on the type and name in the JSON passed into " +#~ "stdin.\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# Delete pods and services with label name=myLabel.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Delete a pod with minimal delay\n" +#~ "\t\tkubectl delete pod foo --now\n" +#~ "\n" +#~ "\t\t# Force delete a pod on a dead node\n" +#~ "\t\tkubectl delete pod foo --grace-period=0 --force\n" +#~ "\n" +#~ "\t\t# Delete all pods\n" +#~ "\t\tkubectl delete pods --all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 使用 pod.json 中的类型和名称删除一个 pod.\n" +#~ "\t\tkubectl delete -f ./pod.json\n" +#~ "\n" +#~ "\t\t# 基于重定向到 stdin 中的 JSON 的类型和名称删除一个 pod.\n" +#~ "\t\tcat pod.json | kubectl delete -f -\n" +#~ "\n" +#~ "\t\t# 删除名为 \"baz\" 和 \"foo\" 的 pod 和 service\n" +#~ "\t\tkubectl delete pod,service baz foo\n" +#~ "\n" +#~ "\t\t# 删除标签为 name=myLabel 的 pods 和 services.\n" +#~ "\t\tkubectl delete pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# 删除最小延迟的 pod\n" +#~ "\t\tkubectl delete pod foo --now\n" +#~ "\n" +#~ "\t\t# 强制删除名为 foo 的 pod\n" +#~ "\t\tkubectl delete pod foo --grace-period=0 --force\n" +#~ "\n" +#~ "\t\t# 删除所有 pods\n" +#~ "\t\tkubectl delete pods --all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Describe a node\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# Describe a pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# Describe a pod identified by type and name in \"pod.json\"\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# Describe all pods\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# Describe pods by label name=myLabel\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Describe all pods managed by the 'frontend' replication controller " +#~ "(rc-created pods\n" +#~ "\t\t# get the name of the rc as a prefix in the pod the name).\n" +#~ "\t\tkubectl describe pods frontend" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 描述一个 node\n" +#~ "\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n" +#~ "\n" +#~ "\t\t# 描述一个 pod\n" +#~ "\t\tkubectl describe pods/nginx\n" +#~ "\n" +#~ "\t\t# 描述一个被 \"pod.json\" 中的类型和名称标识的 pod\n" +#~ "\t\tkubectl describe -f pod.json\n" +#~ "\n" +#~ "\t\t# 描述所有 pods\n" +#~ "\t\tkubectl describe pods\n" +#~ "\n" +#~ "\t\t# 描述标签为 name=myLabel 的 pods\n" +#~ "\t\tkubectl describe po -l name=myLabel\n" +#~ "\n" +#~ "\t\t# 描述所有被名称为 'frontend' 的 replication controller 管理的 " +#~ "pods(rc-创建 pods\n" +#~ "\t\t# 并使用 rc 的名称作为 pod 的前缀).\n" +#~ "\t\tkubectl describe pods frontend" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Drain node \"foo\", even if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet on it.\n" +#~ "\t\t$ kubectl drain foo --force\n" +#~ "\n" +#~ "\t\t# As above, but abort if there are pods not managed by a " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet 或者 StatefulSet, and " +#~ "use a grace period of 15 minutes.\n" +#~ "\t\t$ kubectl drain foo --grace-period=900" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 驱逐节点 \"foo\", 即使很多 pods 没有被一个在 node 上的 " +#~ "ReplicationController, ReplicaSet, Job, DaemonSet 或者 StatefulSet 管理.\n" +#~ "\t\t$ kubectl drain foo --force\n" +#~ "\n" +#~ "\t\t# 同上, 如果存在 pods 没有被一个 ReplicationController, ReplicaSet, " +#~ "Job, DaemonSet 或者 StatefulSet 管理超过 15 分钟则退出.\n" +#~ "\t\t$ kubectl drain foo --grace-period=900" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Edit the service named 'docker-registry':\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Use an alternative editor\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# Edit the job 'myjob' in JSON using the v1 API format:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# Edit the deployment 'mydeployment' in YAML and save the modified " +#~ "config in its annotation:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml --save-config" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 编辑名为 'docker-registry' 的 service:\n" +#~ "\t\tkubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# 使用一个可选择的编辑器\n" +#~ "\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n" +#~ "\n" +#~ "\t\t# 使用 v1 API 格式的 JSON 编辑名为 'myjob' 的 job:\n" +#~ "\t\tkubectl edit job.v1.batch/myjob -o json\n" +#~ "\n" +#~ "\t\t# 在 YAML 中编辑名为 'mydeployment' 的 deployment 并在它的注解中保存修" +#~ "改后的配置:\n" +#~ "\t\tkubectl edit deployment/mydeployment -o yaml --save-config" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running 'date' from pod 123456-7890, using the " +#~ "first container by default\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# Get output from running 'date' in ruby-container from pod " +#~ "123456-7890\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t -- bash -il" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 从运行中pod 123456-7890 获取执行 'date' 的输出, 默认使用第一个容器\n" +#~ "\t\tkubectl exec 123456-7890 date\n" +#~ "\n" +#~ "\t\t# 从 pod 123456-7890 的容器 ruby-container 获取执行 'date' 的输出\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container date\n" +#~ "\n" +#~ "\t\t# 切换到 terminal 模式, 发送 stdin 到运行在 pod 123456-7890 的容器 " +#~ "ruby-container 'bash' \n" +#~ "\t\t# 并从 'bash' 发送 stdout/stderr 返回到 client\n" +#~ "\t\tkubectl exec 123456-7890 -c ruby-container -i -t -- bash -il" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Get output from running pod 123456-7890, using the first container " +#~ "by default\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# Get output from ruby-container from pod 123456-7890\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# Switch to raw terminal mode, sends stdin to 'bash' in ruby-" +#~ "container from pod 123456-7890\n" +#~ "\t\t# and sends stdout/stderr from 'bash' back to the client\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# Get output from the first pod of a ReplicaSet named nginx\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 从运行中pod 123456-7890 获取执行 'date' 的输出, 默认使用第一个容器\n" +#~ "\t\tkubectl attach 123456-7890\n" +#~ "\n" +#~ "\t\t# 从 pod 123456-7890 的容器 ruby-container 获取输出\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container\n" +#~ "\n" +#~ "\t\t# 切换到 terminal 模式, 发送 stdin 到运行在 pod 123456-7890 的容器 " +#~ "ruby-container 'bash' \n" +#~ "\t\t# 并从 'bash' 发送 stdout/stderr 返回到 client\n" +#~ "\t\tkubectl attach 123456-7890 -c ruby-container -i -t\n" +#~ "\n" +#~ "\t\t# 从名称为 nginx 的 ReplicaSet 获取第一个 pod 的输出\n" +#~ "\t\tkubectl attach rs/nginx\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Install bash completion on a Mac using homebrew\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash completion support\n" +#~ "source $(brew --prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for bash into the current shell\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# Write bash completion code to a file and source if from ." +#~ "bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell completion\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# Load the kubectl completion code for zsh[1] into the current shell\n" +#~ "\t\tsource <(kubectl completion zsh)" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 在一个 Mac 中使用 homebrew 安装 bash 补全\n" +#~ "\t\tbrew install bash-completion\n" +#~ "\t\tprintf \"\n" +#~ "# Bash 补全支持\n" +#~ "source $(brew --prefix)/etc/bash_completion\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# 导入 kubectl 补全代码到当前 shell\n" +#~ "\t\tsource <(kubectl completion bash)\n" +#~ "\n" +#~ "\t\t# 写入 bash 补全代码到一个文件并 source 如果它是 .bash_profile\n" +#~ "\t\tkubectl completion bash > ~/.kube/completion.bash.inc\n" +#~ "\t\tprintf \"\n" +#~ "# Kubectl shell 补全\n" +#~ "source '$HOME/.kube/completion.bash.inc'\n" +#~ "\" >> $HOME/.bash_profile\n" +#~ "\t\tsource $HOME/.bash_profile\n" +#~ "\n" +#~ "\t\t# 为 zsh[1] 导入 kubectl 补全代码到当前 shell\n" +#~ "\t\tsource <(kubectl completion zsh)" + +#~ msgid "" +#~ "\n" +#~ "\t\t# List all pods in ps output format.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# List all pods in ps output format with more information (such as " +#~ "node name).\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# List a single replication controller with specified NAME in ps " +#~ "output format.\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# List a single pod in JSON output format.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List a pod identified by type and name specified in \"pod.yaml\" in " +#~ "JSON output format.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# Return only the phase value of the specified pod.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# List all replication controllers and services together in ps output " +#~ "format.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# List one or more resources by their type and names.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# List all resources with different types.\n" +#~ "\t\tkubectl get all" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 以 ps 输出格式列出所有 pod.\n" +#~ "\t\tkubectl get pods\n" +#~ "\n" +#~ "\t\t# 以 ps 输出格式列出所有 pod(如节点名称).\n" +#~ "\t\tkubectl get pods -o wide\n" +#~ "\n" +#~ "\t\t# 获取名称为 web 的 replicationcontroller.\n" +#~ "\t\tkubectl get replicationcontroller web\n" +#~ "\n" +#~ "\t\t# 使用 JSON 格式化输出显示一个单独的 pod.\n" +#~ "\t\tkubectl get -o json pod web-pod-13je7\n" +#~ "\n" +#~ "\t\t# 显示一个被 \"pod.yaml\" 中的 type 和 name 标识的 pod 并使用 JSON 格" +#~ "式化输出.\n" +#~ "\t\tkubectl get -f pod.yaml -o json\n" +#~ "\n" +#~ "\t\t# 只返回被指定 pod 中 phase 的值.\n" +#~ "\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status." +#~ "phase}}\n" +#~ "\n" +#~ "\t\t# 显示所有的 replication controllers 和 services 并格式化输出.\n" +#~ "\t\tkubectl get rc,services\n" +#~ "\n" +#~ "\t\t# 显示一个或者更多 resources 通过它们的 type 和 names.\n" +#~ "\t\tkubectl get rc/web service/frontend pods/web-pod-13je7\n" +#~ "\n" +#~ "\t\t# 使用不同的 types 显示所有 resources.\n" +#~ "\t\tkubectl get all" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from " +#~ "ports 5000 and 6000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 5000 6000\n" +#~ "\n" +#~ "\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 8888:5000\n" +#~ "\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod :5000\n" +#~ "\n" +#~ "\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n" +#~ "\t\tkubectl port-forward mypod 0:5000" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 在本地监听端口 5000 和 6000 , forwarding 数据 to/from 在 pod 5000 " +#~ "和 6000 端口\n" +#~ "\t\tkubectl port-forward mypod 5000 6000\n" +#~ "\n" +#~ "\t\t# 在本地监听端口 8888 , forwarding 到 pod 的 5000端口\n" +#~ "\t\tkubectl port-forward mypod 8888:5000\n" +#~ "\n" +#~ "\t\t# 在本地随机监听一个端口 , forwarding 到 pod 的 5000端口\n" +#~ "\t\tkubectl port-forward mypod :5000\n" +#~ "\n" +#~ "\t\t# 在本地随机监听一个端口 , forwarding 到 pod 的 5000端口\n" +#~ "\t\tkubectl port-forward mypod 0:5000" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as schedulable.\n" +#~ "\t\t$ kubectl uncordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 标记 node \"foo\" 为 schedulable.\n" +#~ "\t\t$ kubectl uncordon foo" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/drain.go#L102 +#~ msgid "" +#~ "\n" +#~ "\t\t# Mark node \"foo\" as unschedulable.\n" +#~ "\t\tkubectl cordon foo" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 标记 node \"foo\" 为 unschedulable.\n" +#~ "\t\tkubectl cordon foo" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Partially update a node using strategic merge patch\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# Partially update a node identified by the type and name specified " +#~ "in \"node.json\" using strategic merge patch\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image; spec.containers[*].name is required " +#~ "because it's a merge key\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# Update a container's image using a json patch with positional " +#~ "arrays\n" +#~ "\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 使用 strategic merge patch 部分更新一个 node\n" +#~ "\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":" +#~ "true}}'\n" +#~ "\n" +#~ "\t\t# 使用 strategic merge patch 部分更新一个被 \"node.json\" 的 type 和 " +#~ "name 标示 的 node.\n" +#~ "\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n" +#~ "\n" +#~ "\t\t# 更新一个 container 的 image; spec.containers[*].name 是必须的 因为它" +#~ "是一个 merge key\n" +#~ "\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":" +#~ "\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n" +#~ "\n" +#~ "\t\t# 使用一个 json patch 更新一个指定坐标的 container 的 image \n" +#~ "\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", " +#~ "\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Print the address of the master and cluster services\n" +#~ "\t\tkubectl cluster-info" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 输出 master 和 cluster services 的地址\n" +#~ "\t\tkubectl cluster-info" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Replace a pod using the data in pod.json.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# Replace a pod based on the JSON passed into stdin.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Update a single-container pod's image version (tag) to v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# Force replace, delete and then re-create the resource\n" +#~ "\t\tkubectl replace --force -f ./pod.json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 使用在 pod.json 中的数据替换一个 pod.\n" +#~ "\t\tkubectl replace -f ./pod.json\n" +#~ "\n" +#~ "\t\t# 基于被重定向到 stdin 中的 JSON 替换一个 pod.\n" +#~ "\t\tcat pod.json | kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# 更新一个单独容器的 pod 的 image 版本 (tag) 到 v4\n" +#~ "\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/:v4/' " +#~ "| kubectl replace -f -\n" +#~ "\n" +#~ "\t\t# 强制替换, 删除然后重新创建这个 resource\n" +#~ "\t\tkubectl replace --force -f ./pod.json" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Return snapshot logs from pod nginx with only one container\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs for the pods defined by label app=nginx\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot of previous terminated ruby container logs from pod " +#~ "web-1\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Display only the most recent 20 lines of output in pod nginx\n" +#~ "\t\tkubectl logs --tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Show all logs from pod nginx written in the last hour\n" +#~ "\t\tkubectl logs --since=1h nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from first container of a job named hello\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from container nginx-1 of a deployment named " +#~ "nginx\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 返回仅有一个容器 pod 名称为 nginx 的 snapshot 日志\n" +#~ "\t\tkubectl logs nginx\n" +#~ "\n" +#~ "\t\t# 返回 label 为 app=nginx 的 pods 的 snapshot 日志\n" +#~ "\t\tkubectl logs -lapp=nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot of previous terminated ruby container logs from pod " +#~ "web-1\n" +#~ "\t\tkubectl logs -p -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Begin streaming the logs of the ruby container in pod web-1\n" +#~ "\t\tkubectl logs -f -c ruby web-1\n" +#~ "\n" +#~ "\t\t# Display only the most recent 20 lines of output in pod nginx\n" +#~ "\t\tkubectl logs --tail=20 nginx\n" +#~ "\n" +#~ "\t\t# Show all logs from pod nginx written in the last hour\n" +#~ "\t\tkubectl logs --since=1h nginx\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from first container of a job named hello\n" +#~ "\t\tkubectl logs job/hello\n" +#~ "\n" +#~ "\t\t# Return snapshot logs from container nginx-1 of a deployment named " +#~ "nginx\n" +#~ "\t\tkubectl logs deployment/nginx -c nginx-1" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on port 8011, serving static " +#~ "content from ./local/www/\n" +#~ "\t\tkubectl proxy --port=8011 --www=./local/www/\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver on an arbitrary local port.\n" +#~ "\t\t# The chosen port for the server will be output to stdout.\n" +#~ "\t\tkubectl proxy --port=0\n" +#~ "\n" +#~ "\t\t# Run a proxy to kubernetes apiserver, changing the api prefix to k8s-" +#~ "api\n" +#~ "\t\t# This makes e.g. the pods api available at localhost:8001/k8s-api/v1/" +#~ "pods/\n" +#~ "\t\tkubectl proxy --api-prefix=/k8s-api" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 运行 proxy 到 kubernetes apiserver 的 8011 端口上, 服务静态内容路径" +#~ "为 ./local/www/\n" +#~ "\t\tkubectl proxy --port=8011 --www=./local/www/\n" +#~ "\n" +#~ "\t\t# 在任意的本地端口上运行一个 proxy 到 kubernetes apiserver.\n" +#~ "\t\t# 为这个 server 挑选的端口将会被输出到 stdout.\n" +#~ "\t\tkubectl proxy --port=0\n" +#~ "\n" +#~ "\t\t# 运行一个 proxy 到 kubernetes apiserver, 修改 api prefix 为 k8s-api\n" +#~ "\t\t# 这会使 e.g. 这个 pods 的有效 api 为 localhost:8001/k8s-api/v1/" +#~ "pods/\n" +#~ "\t\tkubectl proxy --api-prefix=/k8s-api" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Scale a replicaset named 'foo' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Scale a resource identified by type and name specified in \"foo.yaml" +#~ "\" to 3.\n" +#~ "\t\tkubectl scale --replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# If the deployment named mysql's current size is 2, scale mysql to " +#~ "3.\n" +#~ "\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Scale multiple replication controllers.\n" +#~ "\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Scale job named 'cron' to 3.\n" +#~ "\t\tkubectl scale --replicas=3 job/cron" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Scale 一个名称为 ‘foo’ 的 replicaset 服本数为 3.\n" +#~ "\t\tkubectl scale --replicas=3 rs/foo\n" +#~ "\n" +#~ "\t\t# Scale 指定的 \"foo.yaml\" 的 type 和 name 标识的 resource 副本数量" +#~ "为 3.\n" +#~ "\t\tkubectl scale --replicas=3 -f foo.yaml\n" +#~ "\n" +#~ "\t\t# 如果名称为 mysql 的 deployment 当前副本数量为 2, scale mysql 到 3.\n" +#~ "\t\tkubectl scale --current-replicas=2 --replicas=3 deployment/mysql\n" +#~ "\n" +#~ "\t\t# Scale 多个 replication controllers.\n" +#~ "\t\tkubectl scale --replicas=5 rc/foo rc/bar rc/baz\n" +#~ "\n" +#~ "\t\t# Scale 名称为 ’cron’ 的 job 副本数量为 3.\n" +#~ "\t\tkubectl scale --replicas=3 job/cron" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Execute set-last-applied against each configuration file in a " +#~ "directory.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# Set the last-applied-configuration of a resource to match the " +#~ "contents of a file, will create the annotation if it does not already " +#~ "exist.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml --create-" +#~ "annotation=true\n" +#~ "\t\t" +#~ msgstr "" +#~ "\n" +#~ "\t\t# 设置一个资源的 last-applied-configuration 去匹配一个文件的内容.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml\n" +#~ "\n" +#~ "\t\t# Execute set-last-applied against each configuration file in a " +#~ "directory.\n" +#~ "\t\tkubectl apply set-last-applied -f path/\n" +#~ "\n" +#~ "\t\t# 设置一个资源的 last-applied-configuration 去匹配一个文件的内容, 如果" +#~ "不存在将会创建一个 annotation.\n" +#~ "\t\tkubectl apply set-last-applied -f deploy.yaml --create-" +#~ "annotation=true\n" +#~ "\t\t" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Shut down foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Stop pods and services with label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Shut down the service defined in service.json\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Shut down all resources in the path/to/resources directory\n" +#~ "\t\tkubectl stop -f path/to/resources" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Shut down foo.\n" +#~ "\t\tkubectl stop replicationcontroller foo\n" +#~ "\n" +#~ "\t\t# Stop pods and services with label name=myLabel.\n" +#~ "\t\tkubectl stop pods,services -l name=myLabel\n" +#~ "\n" +#~ "\t\t# Shut down the service defined in service.json\n" +#~ "\t\tkubectl stop -f service.json\n" +#~ "\n" +#~ "\t\t# Shut down all resources in the path/to/resources directory\n" +#~ "\t\tkubectl stop -f path/to/resources" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Start a single instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and let the container expose " +#~ "port 5701 .\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --port=5701\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and set environment variables " +#~ "\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --env=\"DNS_DOMAIN=cluster\" " +#~ "--env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Start a replicated instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx --replicas=5\n" +#~ "\n" +#~ "\t\t# Dry run. Print the corresponding API objects without creating " +#~ "them.\n" +#~ "\t\tkubectl run nginx --image=nginx --dry-run\n" +#~ "\n" +#~ "\t\t# Start a single instance of nginx, but overload the spec of the " +#~ "deployment with a partial set of values parsed from JSON.\n" +#~ "\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": " +#~ "\"v1\", \"spec\": { ... } }'\n" +#~ "\n" +#~ "\t\t# Start a pod of busybox and keep it in the foreground, don't restart " +#~ "it if it exits.\n" +#~ "\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +#~ "\n" +#~ "\t\t# Start the nginx container using the default command, but use custom " +#~ "arguments (arg1 .. argN) for that command.\n" +#~ "\t\tkubectl run nginx --image=nginx -- ... \n" +#~ "\n" +#~ "\t\t# Start the nginx container using a different command and custom " +#~ "arguments.\n" +#~ "\t\tkubectl run nginx --image=nginx --command -- ... \n" +#~ "\n" +#~ "\t\t# Start the perl container to compute π to 2000 places and print it " +#~ "out.\n" +#~ "\t\tkubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Start the cron job to compute π to 2000 places and print it out " +#~ "every 5 minutes.\n" +#~ "\t\tkubectl run pi --schedule=\"0/5 * * * ?\" --image=perl --" +#~ "restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Start a single instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and let the container expose " +#~ "port 5701 .\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --port=5701\n" +#~ "\n" +#~ "\t\t# Start a single instance of hazelcast and set environment variables " +#~ "\"DNS_DOMAIN=cluster\" and \"POD_NAMESPACE=default\" in the container.\n" +#~ "\t\tkubectl run hazelcast --image=hazelcast --env=\"DNS_DOMAIN=cluster\" " +#~ "--env=\"POD_NAMESPACE=default\"\n" +#~ "\n" +#~ "\t\t# Start a replicated instance of nginx.\n" +#~ "\t\tkubectl run nginx --image=nginx --replicas=5\n" +#~ "\n" +#~ "\t\t# Dry run. Print the corresponding API objects without creating " +#~ "them.\n" +#~ "\t\tkubectl run nginx --image=nginx --dry-run\n" +#~ "\n" +#~ "\t\t# Start a single instance of nginx, but overload the spec of the " +#~ "deployment with a partial set of values parsed from JSON.\n" +#~ "\t\tkubectl run nginx --image=nginx --overrides='{ \"apiVersion\": " +#~ "\"v1\", \"spec\": { ... } }'\n" +#~ "\n" +#~ "\t\t# Start a pod of busybox and keep it in the foreground, don't restart " +#~ "it if it exits.\n" +#~ "\t\tkubectl run -i -t busybox --image=busybox --restart=Never\n" +#~ "\n" +#~ "\t\t# Start the nginx container using the default command, but use custom " +#~ "arguments (arg1 .. argN) for that command.\n" +#~ "\t\tkubectl run nginx --image=nginx -- ... \n" +#~ "\n" +#~ "\t\t# Start the nginx container using a different command and custom " +#~ "arguments.\n" +#~ "\t\tkubectl run nginx --image=nginx --command -- ... \n" +#~ "\n" +#~ "\t\t# Start the perl container to compute π to 2000 places and print it " +#~ "out.\n" +#~ "\t\tkubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -" +#~ "wle 'print bpi(2000)'\n" +#~ "\n" +#~ "\t\t# Start the cron job to compute π to 2000 places and print it out " +#~ "every 5 minutes.\n" +#~ "\t\tkubectl run pi --schedule=\"0/5 * * * ?\" --image=perl --" +#~ "restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update node 'foo' with a taint with key 'dedicated' and value " +#~ "'special-user' and effect 'NoSchedule'.\n" +#~ "\t\t# If a taint with that key and effect already exists, its value is " +#~ "replaced as specified.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +#~ "'NoSchedule' if one exists.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Update node 'foo' with a taint with key 'dedicated' and value " +#~ "'special-user' and effect 'NoSchedule'.\n" +#~ "\t\t# If a taint with that key and effect already exists, its value is " +#~ "replaced as specified.\n" +#~ "\t\tkubectl taint nodes foo dedicated=special-user:NoSchedule\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' the taint with key 'dedicated' and effect " +#~ "'NoSchedule' if one exists.\n" +#~ "\t\tkubectl taint nodes foo dedicated:NoSchedule-\n" +#~ "\n" +#~ "\t\t# Remove from node 'foo' all the taints with key 'dedicated'\n" +#~ "\t\tkubectl taint nodes foo dedicated-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +#~ "overwriting any existing value.\n" +#~ "\t\tkubectl label --overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update all pods in the namespace\n" +#~ "\t\tkubectl label pods --all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ "\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' by removing a label named 'bar' if it exists.\n" +#~ "\t\t# Does not require the --overwrite flag.\n" +#~ "\t\tkubectl label pods foo bar-" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'unhealthy' and the value 'true'.\n" +#~ "\t\tkubectl label pods foo unhealthy=true\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' with the label 'status' and the value 'unhealthy', " +#~ "overwriting any existing value.\n" +#~ "\t\tkubectl label --overwrite pods foo status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update all pods in the namespace\n" +#~ "\t\tkubectl label pods --all status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update a pod identified by the type and name in \"pod.json\"\n" +#~ "\t\tkubectl label -f pod.json status=unhealthy\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ "\t\tkubectl label pods foo status=unhealthy --resource-version=1\n" +#~ "\n" +#~ "\t\t# Update pod 'foo' by removing a label named 'bar' if it exists.\n" +#~ "\t\t# Does not require the --overwrite flag.\n" +#~ "\t\tkubectl label pods foo bar-" + +#~ msgid "" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using new replication controller data in " +#~ "frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using JSON data passed into stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend-v1 to frontend-v2 by just changing the " +#~ "image, and switching the\n" +#~ "\t\t# name of the replication controller.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend by just changing the image, and keeping " +#~ "the old name.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Abort and reverse an existing rollout in progress (from frontend-v1 " +#~ "to frontend-v2).\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" +#~ msgstr "" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using new replication controller data in " +#~ "frontend-v2.json.\n" +#~ "\t\tkubectl rolling-update frontend-v1 -f frontend-v2.json\n" +#~ "\n" +#~ "\t\t# Update pods of frontend-v1 using JSON data passed into stdin.\n" +#~ "\t\tcat frontend-v2.json | kubectl rolling-update frontend-v1 -f -\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend-v1 to frontend-v2 by just changing the " +#~ "image, and switching the\n" +#~ "\t\t# name of the replication controller.\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --image=image:v2\n" +#~ "\n" +#~ "\t\t# Update the pods of frontend by just changing the image, and keeping " +#~ "the old name.\n" +#~ "\t\tkubectl rolling-update frontend --image=image:v2\n" +#~ "\n" +#~ "\t\t# Abort and reverse an existing rollout in progress (from frontend-v1 " +#~ "to frontend-v2).\n" +#~ "\t\tkubectl rolling-update frontend-v1 frontend-v2 --rollback" + +#~ msgid "" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by type/name in " +#~ "YAML.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by file in JSON\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" +#~ msgstr "" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by type/name in " +#~ "YAML.\n" +#~ "\t\tkubectl apply view-last-applied deployment/nginx\n" +#~ "\n" +#~ "\t\t# View the last-applied-configuration annotations by file in JSON\n" +#~ "\t\tkubectl apply view-last-applied -f deploy.yaml -o json" + +#~ msgid "" +#~ "\n" +#~ "\t\tApply a configuration to a resource by filename or stdin.\n" +#~ "\t\tThis resource will be created if it doesn't exist yet.\n" +#~ "\t\tTo use 'apply', always create the resource initially with either " +#~ "'apply' or 'create --save-config'.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do " +#~ "not use unless you are aware of what the current state is. See https://" +#~ "issues.k8s.io/34274." +#~ msgstr "" +#~ "\n" +#~ "\t\t通过文件名或标准输入流(stdin)对资源进行配置.\n" +#~ "\t\tThis resource will be created if it doesn't exist yet.\n" +#~ "\t\tTo use 'apply', always create the resource initially with either " +#~ "'apply' or 'create --save-config'.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ "\n" +#~ "\t\tAlpha Disclaimer: the --prune functionality is not yet complete. Do " +#~ "not use unless you are aware of what the current state is. See https://" +#~ "issues.k8s.io/34274." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L68 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\t创建一个 ClusterRole." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_clusterrolebinding.go#L43 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a ClusterRoleBinding for a particular ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\t 为指定的 ClusterRole 创建一个 ClusterRoleBinding." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L43 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a RoleBinding for a particular Role or ClusterRole." +#~ msgstr "" +#~ "\n" +#~ "\t\t为指定的 Role 或者 ClusterRole 创建一个 RoleBinding." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a TLS secret from the given public/private key pair.\n" +#~ "\n" +#~ "\t\tThe public/private key pair must exist before hand. The public key " +#~ "certificate must be .PEM encoded and match the given private key." +#~ msgstr "" +#~ "\n" +#~ "\t\t为指定的 public/private key pair 创建一个 TLS secret.\n" +#~ "\n" +#~ "\t\tpublic/private key pair 必须在传递前存在. public key certificate 必须" +#~ "以 .PEM 被编码且匹配指定的 private key." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a configmap based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single configmap may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a file, the key will default to " +#~ "the basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a directory, each file whose " +#~ "basename is a valid key in the directory will be\n" +#~ "\t\tpackaged into the configmap. Any directory entries except regular " +#~ "files are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a configmap based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single configmap may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a file, the key will default to " +#~ "the basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a configmap based on a directory, each file whose " +#~ "basename is a valid key in the directory will be\n" +#~ "\t\tpackaged into the configmap. Any directory entries except regular " +#~ "files are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a new secret for use with Docker registries.\n" +#~ "\n" +#~ "\t\tDockercfg secrets are used to authenticate against Docker " +#~ "registries.\n" +#~ "\n" +#~ "\t\tWhen using the Docker command line to push images, you can " +#~ "authenticate to a given registry by running\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +#~ "password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " That produces a ~/.dockercfg file that is used by subsequent 'docker " +#~ "push' and 'docker pull' commands to\n" +#~ "\t\tauthenticate to the registry. The email address is optional.\n" +#~ "\n" +#~ "\t\tWhen creating applications, you may have a Docker registry that " +#~ "requires authentication. In order for the\n" +#~ "\t\tnodes to pull images on your behalf, they have to have the " +#~ "credentials. You can provide this information\n" +#~ "\t\tby creating a dockercfg secret and attaching it to your service " +#~ "account." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a new secret for use with Docker registries.\n" +#~ "\n" +#~ "\t\tDockercfg secrets are used to authenticate against Docker " +#~ "registries.\n" +#~ "\n" +#~ "\t\tWhen using the Docker command line to push images, you can " +#~ "authenticate to a given registry by running\n" +#~ "\n" +#~ "\t\t $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --" +#~ "password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.\n" +#~ "\n" +#~ " That produces a ~/.dockercfg file that is used by subsequent 'docker " +#~ "push' and 'docker pull' commands to\n" +#~ "\t\tauthenticate to the registry. The email address is optional.\n" +#~ "\n" +#~ "\t\tWhen creating applications, you may have a Docker registry that " +#~ "requires authentication. In order for the\n" +#~ "\t\tnodes to pull images on your behalf, they have to have the " +#~ "credentials. You can provide this information\n" +#~ "\t\tby creating a dockercfg secret and attaching it to your service " +#~ "account." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L49 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a pod disruption budget with the specified name, selector, and " +#~ "desired minimum available pods" +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a pod disruption budget with the specified name, selector, and " +#~ "desired minimum available pods" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create.go#L56 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted." +#~ msgstr "" +#~ "\n" +#~ "\t\t通过文件名或者标准输入流(stdin)创建一个资源.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L47 +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a resourcequota with the specified name, hard limits and " +#~ "optional scopes" +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a resourcequota with the specified name, hard limits and " +#~ "optional scopes" + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate a secret based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single secret may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a file, the key will default to the " +#~ "basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a directory, each file whose basename " +#~ "is a valid key in the directory will be\n" +#~ "\t\tpackaged into the secret. Any directory entries except regular files " +#~ "are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate a secret based on a file, directory, or specified literal " +#~ "value.\n" +#~ "\n" +#~ "\t\tA single secret may package one or more key/value pairs.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a file, the key will default to the " +#~ "basename of the file, and the value will\n" +#~ "\t\tdefault to the file content. If the basename is an invalid key, you " +#~ "may specify an alternate key.\n" +#~ "\n" +#~ "\t\tWhen creating a secret based on a directory, each file whose basename " +#~ "is a valid key in the directory will be\n" +#~ "\t\tpackaged into the secret. Any directory entries except regular files " +#~ "are ignored (e.g. subdirectories,\n" +#~ "\t\tsymlinks, devices, pipes, etc)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreate and run a particular image, possibly replicated.\n" +#~ "\n" +#~ "\t\tCreates a deployment or job to manage the created container(s)." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreate and run a particular image, possibly replicated.\n" +#~ "\n" +#~ "\t\tCreates a deployment or job to manage the created container(s)." + +#~ msgid "" +#~ "\n" +#~ "\t\tCreates an autoscaler that automatically chooses and sets the number " +#~ "of pods that run in a kubernetes cluster.\n" +#~ "\n" +#~ "\t\tLooks up a Deployment, ReplicaSet, or ReplicationController by name " +#~ "and creates an autoscaler that uses the given resource as a reference.\n" +#~ "\t\tAn autoscaler can automatically increase or decrease number of pods " +#~ "deployed within the system as needed." +#~ msgstr "" +#~ "\n" +#~ "\t\tCreates an autoscaler that automatically chooses and sets the number " +#~ "of pods that run in a kubernetes cluster.\n" +#~ "\n" +#~ "\t\tLooks up a Deployment, ReplicaSet, or ReplicationController by name " +#~ "and creates an autoscaler that uses the given resource as a reference.\n" +#~ "\t\tAn autoscaler can automatically increase or decrease number of pods " +#~ "deployed within the system as needed." + +#~ msgid "" +#~ "\n" +#~ "\t\tDelete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. Only one type of the arguments " +#~ "may be specified: filenames,\n" +#~ "\t\tresources and names, or resources and label selector.\n" +#~ "\n" +#~ "\t\tSome resources, such as pods, support graceful deletion. These " +#~ "resources define a default period\n" +#~ "\t\tbefore they are forcibly terminated (the grace period) but you may " +#~ "override that value with\n" +#~ "\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +#~ "Because these resources often\n" +#~ "\t\trepresent entities in the cluster, deletion may not be acknowledged " +#~ "immediately. If the node\n" +#~ "\t\thosting a pod is down or cannot reach the API server, termination may " +#~ "take significantly longer\n" +#~ "\t\tthan the grace period. To force delete a resource,\tyou must pass a " +#~ "grace\tperiod of 0 and specify\n" +#~ "\t\tthe --force flag.\n" +#~ "\n" +#~ "\t\tIMPORTANT: Force deleting pods does not wait for confirmation that " +#~ "the pod's processes have been\n" +#~ "\t\tterminated, which can leave those processes running until the node " +#~ "detects the deletion and\n" +#~ "\t\tcompletes graceful deletion. If your processes use shared storage or " +#~ "talk to a remote API and\n" +#~ "\t\tdepend on the name of the pod to identify themselves, force deleting " +#~ "those pods may result in\n" +#~ "\t\tmultiple processes running on different machines using the same " +#~ "identification which may lead\n" +#~ "\t\tto data corruption or inconsistency. Only force delete pods when you " +#~ "are sure the pod is\n" +#~ "\t\tterminated, or if your application can tolerate multiple copies of " +#~ "the same pod running at once.\n" +#~ "\t\tAlso, if you force delete pods the scheduler may place new pods on " +#~ "those nodes before the node\n" +#~ "\t\thas released those resources and causing those pods to be evicted " +#~ "immediately.\n" +#~ "\n" +#~ "\t\tNote that the delete command does NOT do resource version checks, so " +#~ "if someone\n" +#~ "\t\tsubmits an update to a resource right when you submit a delete, their " +#~ "update\n" +#~ "\t\twill be lost along with the rest of the resource." +#~ msgstr "" +#~ "\n" +#~ "\t\tDelete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. Only one type of the arguments " +#~ "may be specified: filenames,\n" +#~ "\t\tresources and names, or resources and label selector.\n" +#~ "\n" +#~ "\t\tSome resources, such as pods, support graceful deletion. These " +#~ "resources define a default period\n" +#~ "\t\tbefore they are forcibly terminated (the grace period) but you may " +#~ "override that value with\n" +#~ "\t\tthe --grace-period flag, or pass --now to set a grace-period of 1. " +#~ "Because these resources often\n" +#~ "\t\trepresent entities in the cluster, deletion may not be acknowledged " +#~ "immediately. If the node\n" +#~ "\t\thosting a pod is down or cannot reach the API server, termination may " +#~ "take significantly longer\n" +#~ "\t\tthan the grace period. To force delete a resource,\tyou must pass a " +#~ "grace\tperiod of 0 and specify\n" +#~ "\t\tthe --force flag.\n" +#~ "\n" +#~ "\t\tIMPORTANT: Force deleting pods does not wait for confirmation that " +#~ "the pod's processes have been\n" +#~ "\t\tterminated, which can leave those processes running until the node " +#~ "detects the deletion and\n" +#~ "\t\tcompletes graceful deletion. If your processes use shared storage or " +#~ "talk to a remote API and\n" +#~ "\t\tdepend on the name of the pod to identify themselves, force deleting " +#~ "those pods may result in\n" +#~ "\t\tmultiple processes running on different machines using the same " +#~ "identification which may lead\n" +#~ "\t\tto data corruption or inconsistency. Only force delete pods when you " +#~ "are sure the pod is\n" +#~ "\t\tterminated, or if your application can tolerate multiple copies of " +#~ "the same pod running at once.\n" +#~ "\t\tAlso, if you force delete pods the scheduler may place new pods on " +#~ "those nodes before the node\n" +#~ "\t\thas released those resources and causing those pods to be evicted " +#~ "immediately.\n" +#~ "\n" +#~ "\t\tNote that the delete command does NOT do resource version checks, so " +#~ "if someone\n" +#~ "\t\tsubmits an update to a resource right when you submit a delete, their " +#~ "update\n" +#~ "\t\twill be lost along with the rest of the resource." + +#~ msgid "" +#~ "\n" +#~ "\t\tDeprecated: Gracefully shut down a resource by name or filename.\n" +#~ "\n" +#~ "\t\tThe stop command is deprecated, all its functionalities are covered " +#~ "by delete command.\n" +#~ "\t\tSee 'kubectl delete --help' for more details.\n" +#~ "\n" +#~ "\t\tAttempts to shut down and delete a resource that supports graceful " +#~ "termination.\n" +#~ "\t\tIf the resource is scalable it will be scaled to 0 before deletion." +#~ msgstr "" +#~ "\n" +#~ "\t\tDeprecated: Gracefully shut down a resource by name or filename.\n" +#~ "\n" +#~ "\t\tThe stop command is deprecated, all its functionalities are covered " +#~ "by delete command.\n" +#~ "\t\tSee 'kubectl delete --help' for more details.\n" +#~ "\n" +#~ "\t\tAttempts to shut down and delete a resource that supports graceful " +#~ "termination.\n" +#~ "\t\tIf the resource is scalable it will be scaled to 0 before deletion." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of nodes.\n" +#~ "\n" +#~ "\t\tThe top-node command allows you to see the resource consumption of " +#~ "nodes." +#~ msgstr "" +#~ "\n" +#~ "\t\t显示 node 的资源(CPU/Memory/Storage)使用.\n" +#~ "\n" +#~ "\t\tThe top-node command allows you to see the resource consumption of " +#~ "nodes." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage of pods.\n" +#~ "\n" +#~ "\t\tThe 'top pod' command allows you to see the resource consumption of " +#~ "pods.\n" +#~ "\n" +#~ "\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +#~ "minutes\n" +#~ "\t\tsince pod creation." +#~ msgstr "" +#~ "\n" +#~ "\t\t显示 pods 资源(CPU/Memory/Storage)使用.\n" +#~ "\n" +#~ "\t\tThe 'top pod' command allows you to see the resource consumption of " +#~ "pods.\n" +#~ "\n" +#~ "\t\tDue to the metrics pipeline delay, they may be unavailable for a few " +#~ "minutes\n" +#~ "\t\tsince pod creation." + +#~ msgid "" +#~ "\n" +#~ "\t\tDisplay Resource (CPU/Memory/Storage) usage.\n" +#~ "\n" +#~ "\t\tThe top command allows you to see the resource consumption for nodes " +#~ "or pods.\n" +#~ "\n" +#~ "\t\tThis command requires Heapster to be correctly configured and working " +#~ "on the server. " +#~ msgstr "" +#~ "\n" +#~ "\t\t显示资源(CPU/Memory/Storage)使用.\n" +#~ "\n" +#~ "\t\tThe top command allows you to see the resource consumption for nodes " +#~ "or pods.\n" +#~ "\n" +#~ "\t\tThis command requires Heapster to be correctly configured and working " +#~ "on the server. " + +#~ msgid "" +#~ "\n" +#~ "\t\tDrain node in preparation for maintenance.\n" +#~ "\n" +#~ "\t\tThe given node will be marked unschedulable to prevent new pods from " +#~ "arriving.\n" +#~ "\t\t'drain' evicts the pods if the APIServer supports eviction\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Otherwise, it will " +#~ "use normal DELETE\n" +#~ "\t\tto delete the pods.\n" +#~ "\t\tThe 'drain' evicts or deletes all pods except mirror pods (which " +#~ "cannot be deleted through\n" +#~ "\t\tthe API server). If there are DaemonSet-managed pods, drain will not " +#~ "proceed\n" +#~ "\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +#~ "\t\tDaemonSet-managed pods, because those pods would be immediately " +#~ "replaced by the\n" +#~ "\t\tDaemonSet controller, which ignores unschedulable markings. If there " +#~ "are any\n" +#~ "\t\tpods that are neither mirror pods nor managed by " +#~ "ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet or Job, then drain will not delete " +#~ "any pods unless you\n" +#~ "\t\tuse --force. --force will also allow deletion to proceed if the " +#~ "managing resource of one\n" +#~ "\t\tor more pods is missing.\n" +#~ "\n" +#~ "\t\t'drain' waits for graceful termination. You should not operate on the " +#~ "machine until\n" +#~ "\t\tthe command completes.\n" +#~ "\n" +#~ "\t\tWhen you are ready to put the node back into service, use kubectl " +#~ "uncordon, which\n" +#~ "\t\twill make the node schedulable again.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\t清理节点为节点维护做准备.\n" +#~ "\n" +#~ "\t\tThe given node will be marked unschedulable to prevent new pods from " +#~ "arriving.\n" +#~ "\t\t'drain' evicts the pods if the APIServer supports eviction\n" +#~ "\t\t(http://kubernetes.io/docs/admin/disruptions/). Otherwise, it will " +#~ "use normal DELETE\n" +#~ "\t\tto delete the pods.\n" +#~ "\t\tThe 'drain' evicts or deletes all pods except mirror pods (which " +#~ "cannot be deleted through\n" +#~ "\t\tthe API server). If there are DaemonSet-managed pods, drain will not " +#~ "proceed\n" +#~ "\t\twithout --ignore-daemonsets, and regardless it will not delete any\n" +#~ "\t\tDaemonSet-managed pods, because those pods would be immediately " +#~ "replaced by the\n" +#~ "\t\tDaemonSet controller, which ignores unschedulable markings. If there " +#~ "are any\n" +#~ "\t\tpods that are neither mirror pods nor managed by " +#~ "ReplicationController,\n" +#~ "\t\tReplicaSet, DaemonSet, StatefulSet or Job, then drain will not delete " +#~ "any pods unless you\n" +#~ "\t\tuse --force. --force will also allow deletion to proceed if the " +#~ "managing resource of one\n" +#~ "\t\tor more pods is missing.\n" +#~ "\n" +#~ "\t\t'drain' waits for graceful termination. You should not operate on the " +#~ "machine until\n" +#~ "\t\tthe command completes.\n" +#~ "\n" +#~ "\t\tWhen you are ready to put the node back into service, use kubectl " +#~ "uncordon, which\n" +#~ "\t\twill make the node schedulable again.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tEdit a resource from the default editor.\n" +#~ "\n" +#~ "\t\tThe edit command allows you to directly edit any API resource you can " +#~ "retrieve via the\n" +#~ "\t\tcommand line tools. It will open the editor defined by your " +#~ "KUBE_EDITOR, or EDITOR\n" +#~ "\t\tenvironment variables, or fall back to 'vi' for Linux or 'notepad' " +#~ "for Windows.\n" +#~ "\t\tYou can edit multiple objects, although changes are applied one at a " +#~ "time. The command\n" +#~ "\t\taccepts filenames as well as command line arguments, although the " +#~ "files you point to must\n" +#~ "\t\tbe previously saved versions of resources.\n" +#~ "\n" +#~ "\t\tEditing is done with the API version used to fetch the resource.\n" +#~ "\t\tTo edit using a specific API version, fully-qualify the resource, " +#~ "version, and group.\n" +#~ "\n" +#~ "\t\tThe default format is YAML. To edit in JSON, specify \"-o json\".\n" +#~ "\n" +#~ "\t\tThe flag --windows-line-endings can be used to force Windows line " +#~ "endings,\n" +#~ "\t\totherwise the default for your operating system will be used.\n" +#~ "\n" +#~ "\t\tIn the event an error occurs while updating, a temporary file will be " +#~ "created on disk\n" +#~ "\t\tthat contains your unapplied changes. The most common error when " +#~ "updating a resource\n" +#~ "\t\tis another editor changing the resource on the server. When this " +#~ "occurs, you will have\n" +#~ "\t\tto apply your changes to the newer version of the resource, or update " +#~ "your temporary\n" +#~ "\t\tsaved copy to include the latest resource version." +#~ msgstr "" +#~ "\n" +#~ "\t\t使用默认的编辑器修改资源.\n" +#~ "\n" +#~ "\t\tedit 命令允许你通过命令行直接修改 API 资源.\n" +#~ "\t\t它会打开你在 KUBE_EDITOR 或者EDITOR 环境变量中定义的编辑器\n" +#~ "\t\t或者回滚到 Linux vi 编辑器或者 Windows notepad.\n" +#~ "\t\t你可以修改多个对象, 虽然每次只能修改一次. 这个命令\n" +#~ "\t\t同时也接受文件名作为命令行参数, 尽管这些文件你指出必须是\n" +#~ "\t\t你之前保存的资源版本.\n" +#~ "\n" +#~ "\t\tEditing 是通过用于获取资源的API版本完成的.\n" +#~ "\t\t为了能通过指定的 API 版本修改, 请完全限定 resource, version 和 " +#~ "group.\n" +#~ "\n" +#~ "\t\t默认是 YAML 格式. 想在 JSON 中修改, 指定 \"-o json\".\n" +#~ "\n" +#~ "\t\t--windows-line-endings 命令行参数可以用来强制使用 Windows line " +#~ "endings,\n" +#~ "\t\t否则会使用你操作系统的默认值.\n" +#~ "\n" +#~ "\t\t如果更新时发生错误，将在磁盘上创建一个临时文件\n" +#~ "\t\t里面包含您未应用的更改. 更新资源时最常见的错误\n" +#~ "\t\t是另一个编辑器也在服务器中修改这个资源. 当发生这种情况时, 你将\n" +#~ "\t\t需要应用你的修改到资源的最新版本, 或者更新你被保存的临时文件\n" +#~ "\t\t复制它并使用最新的版本." + +#~ msgid "" +#~ "\n" +#~ "\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +#~ "\t\tThe shell code must be evaluated to provide interactive\n" +#~ "\t\tcompletion of kubectl commands. This can be done by sourcing it " +#~ "from\n" +#~ "\t\tthe .bash_profile.\n" +#~ "\n" +#~ "\t\tNote: this requires the bash-completion framework, which is not " +#~ "installed\n" +#~ "\t\tby default on Mac. This can be installed by using homebrew:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tOnce installed, bash_completion must be evaluated. This can be done " +#~ "by adding the\n" +#~ "\t\tfollowing line to the .bash_profile\n" +#~ "\n" +#~ "\t\t $ source $(brew --prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tNote for zsh users: [1] zsh completions are only supported in " +#~ "versions of zsh >= 5.2" +#~ msgstr "" +#~ "\n" +#~ "\t\tOutput shell completion code for the specified shell (bash or zsh).\n" +#~ "\t\tThe shell code must be evaluated to provide interactive\n" +#~ "\t\tcompletion of kubectl commands. This can be done by sourcing it " +#~ "from\n" +#~ "\t\tthe .bash_profile.\n" +#~ "\n" +#~ "\t\tNote: this requires the bash-completion framework, which is not " +#~ "installed\n" +#~ "\t\tby default on Mac. This can be installed by using homebrew:\n" +#~ "\n" +#~ "\t\t $ brew install bash-completion\n" +#~ "\n" +#~ "\t\tOnce installed, bash_completion must be evaluated. This can be done " +#~ "by adding the\n" +#~ "\t\tfollowing line to the .bash_profile\n" +#~ "\n" +#~ "\t\t $ source $(brew --prefix)/etc/bash_completion\n" +#~ "\n" +#~ "\t\tNote for zsh users: [1] zsh completions are only supported in " +#~ "versions of zsh >= 5.2" + +#~ msgid "" +#~ "\n" +#~ "\t\tPerform a rolling update of the given ReplicationController.\n" +#~ "\n" +#~ "\t\tReplaces the specified replication controller with a new replication " +#~ "controller by updating one pod at a time to use the\n" +#~ "\t\tnew PodTemplate. The new-controller.json must specify the same " +#~ "namespace as the\n" +#~ "\t\texisting replication controller and overwrite at least one (common) " +#~ "label in its replicaSelector.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" +#~ msgstr "" +#~ "\n" +#~ "\t\t完成指定的 ReplicationController 的滚动升级.\n" +#~ "\n" +#~ "\t\tReplaces the specified replication controller with a new replication " +#~ "controller by updating one pod at a time to use the\n" +#~ "\t\tnew PodTemplate. The new-controller.json must specify the same " +#~ "namespace as the\n" +#~ "\t\texisting replication controller and overwrite at least one (common) " +#~ "label in its replicaSelector.\n" +#~ "\n" +#~ "\t\t![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate." +#~ "svg)" + +#~ msgid "" +#~ "\n" +#~ "\t\tReplace a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. If replacing an existing " +#~ "resource, the\n" +#~ "\t\tcomplete resource spec must be provided. This can be obtained by\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" +#~ msgstr "" +#~ "\n" +#~ "\t\tReplace a resource by filename or stdin.\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted. If replacing an existing " +#~ "resource, the\n" +#~ "\t\tcomplete resource spec must be provided. This can be obtained by\n" +#~ "\n" +#~ "\t\t $ kubectl get TYPE NAME -o yaml\n" + +#~ msgid "" +#~ "\n" +#~ "\t\tSet a new size for a Deployment, ReplicaSet, Replication Controller, " +#~ "or Job.\n" +#~ "\n" +#~ "\t\tScale also allows users to specify one or more preconditions for the " +#~ "scale action.\n" +#~ "\n" +#~ "\t\tIf --current-replicas or --resource-version is specified, it is " +#~ "validated before the\n" +#~ "\t\tscale is attempted, and it is guaranteed that the precondition holds " +#~ "true when the\n" +#~ "\t\tscale is sent to the server." +#~ msgstr "" +#~ "\n" +#~ "\t\tSet a new size for a Deployment, ReplicaSet, Replication Controller, " +#~ "or Job.\n" +#~ "\n" +#~ "\t\tScale also allows users to specify one or more preconditions for the " +#~ "scale action.\n" +#~ "\n" +#~ "\t\tIf --current-replicas or --resource-version is specified, it is " +#~ "validated before the\n" +#~ "\t\tscale is attempted, and it is guaranteed that the precondition holds " +#~ "true when the\n" +#~ "\t\tscale is sent to the server." + +#~ msgid "" +#~ "\n" +#~ "\t\tTo proxy all of the kubernetes api and nothing else, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/\n" +#~ "\n" +#~ "\t\tTo proxy only part of the kubernetes api and also some static files:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-" +#~ "prefix=/api/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/api/v1/pods'.\n" +#~ "\n" +#~ "\t\tTo proxy the entire kubernetes api at a different root, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/custom/api/v1/pods'" +#~ msgstr "" +#~ "\n" +#~ "\t\tTo proxy all of the kubernetes api and nothing else, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/\n" +#~ "\n" +#~ "\t\tTo proxy only part of the kubernetes api and also some static files:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-" +#~ "prefix=/api/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/api/v1/pods'.\n" +#~ "\n" +#~ "\t\tTo proxy the entire kubernetes api at a different root, use:\n" +#~ "\n" +#~ "\t\t $ kubectl proxy --api-prefix=/custom/\n" +#~ "\n" +#~ "\t\tThe above lets you 'curl localhost:8001/custom/api/v1/pods'" + +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate field(s) of a resource using strategic merge patch\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" +#~ msgstr "" +#~ "\n" +#~ "\t\tUpdate field(s) of a resource using strategic merge patch\n" +#~ "\n" +#~ "\t\tJSON and YAML formats are accepted.\n" + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate the labels on a resource.\n" +#~ "\n" +#~ "\t\t* A label must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* If --overwrite is true, then existing labels can be overwritten, " +#~ "otherwise attempting to overwrite a label will result in an error.\n" +#~ "\t\t* If --resource-version is specified, then updates will use this " +#~ "resource version, otherwise the existing resource-version will be used." +#~ msgstr "" +#~ "\n" +#~ "\t\tUpdate the labels on a resource.\n" +#~ "\n" +#~ "\t\t* A label must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* If --overwrite is true, then existing labels can be overwritten, " +#~ "otherwise attempting to overwrite a label will result in an error.\n" +#~ "\t\t* If --resource-version is specified, then updates will use this " +#~ "resource version, otherwise the existing resource-version will be used." + +#, c-format +#~ msgid "" +#~ "\n" +#~ "\t\tUpdate the taints on one or more nodes.\n" +#~ "\n" +#~ "\t\t* A taint consists of a key, value, and effect. As an argument here, " +#~ "it is expressed as key=value:effect.\n" +#~ "\t\t* The key must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* The value must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[2]d " +#~ "characters.\n" +#~ "\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +#~ "\t\t* Currently taint can only apply to node." +#~ msgstr "" +#~ "\n" +#~ "\t\t更新一个或者多个 node 上的 taints.\n" +#~ "\n" +#~ "\t\t* A taint consists of a key, value, and effect. As an argument here, " +#~ "it is expressed as key=value:effect.\n" +#~ "\t\t* The key must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[1]d " +#~ "characters.\n" +#~ "\t\t* The value must begin with a letter or number, and may contain " +#~ "letters, numbers, hyphens, dots, and underscores, up to %[2]d " +#~ "characters.\n" +#~ "\t\t* The effect must be NoSchedule, PreferNoSchedule or NoExecute.\n" +#~ "\t\t* Currently taint can only apply to node." + +#~ msgid "" +#~ "\n" +#~ "\t\tView the latest last-applied-configuration annotations by type/name " +#~ "or file.\n" +#~ "\n" +#~ "\t\tThe default output will be printed to stdout in YAML format. One can " +#~ "use -o option\n" +#~ "\t\tto change output format." +#~ msgstr "" +#~ "\n" +#~ "\t\tView the latest last-applied-configuration annotations by type/name " +#~ "or file.\n" +#~ "\n" +#~ "\t\tThe default output will be printed to stdout in YAML format. One can " +#~ "use -o option\n" +#~ "\t\tto change output format." + +#~ msgid "" +#~ "\n" +#~ "\t # !!!Important Note!!!\n" +#~ "\t # Requires that the 'tar' binary is present in your container\n" +#~ "\t # image. If 'tar' is not present, 'kubectl cp' will fail.\n" +#~ "\n" +#~ "\t # Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod " +#~ "in the default namespace\n" +#~ "\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +#~ "\n" +#~ " # Copy /tmp/foo local file to /tmp/bar in a remote pod in a " +#~ "specific container\n" +#~ "\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace " +#~ "\n" +#~ "\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +#~ "\n" +#~ "\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n" +#~ "\t\tkubectl cp /:/tmp/foo /tmp/bar" +#~ msgstr "" +#~ "\n" +#~ "\t # !!!注意!!!\n" +#~ "\t # 要求容器中有 'tar' 命令\n" +#~ "\t # image. If 'tar' is not present, 'kubectl cp' will fail.\n" +#~ "\n" +#~ "\t # 复制本地目录 /tmp/foo_dir 到 default namespace 下的远程 pod 的 /" +#~ "tmp/bar_dir 路径 \n" +#~ "\t\tkubectl cp /tmp/foo_dir :/tmp/bar_dir\n" +#~ "\n" +#~ " # 复制 /tmp/foo local 本地文件到指定远程 pod 的指定容器的 /tmp/" +#~ "bar 路径\n" +#~ "\t\tkubectl cp /tmp/foo :/tmp/bar -c \n" +#~ "\n" +#~ "\t\t# 复制 /tmp/foo 本地文件到在 namespace 下的某个 pod " +#~ "的 /tmp/bar 路径\n" +#~ "\t\tkubectl cp /tmp/foo /:/tmp/bar\n" +#~ "\n" +#~ "\t\t# 从一个远程的 pod 的 /tmp/foo 路径复制到本地 /tmp/bar 路径\n" +#~ "\t\tkubectl cp /:/tmp/foo /tmp/bar" + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new TLS secret named tls-secret with the given key pair:\n" +#~ "\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --" +#~ "key=path/to/tls.key" +#~ msgstr "" +#~ "\n" +#~ "\t # 使用提供的 key pair 名称为tls-secret 的 secret:\n" +#~ "\t kubectl create secret tls tls-secret --cert=path/to/tls.cert --" +#~ "key=path/to/tls.key" + +#~ msgid "" +#~ "\n" +#~ "\t # Create a new secret named my-secret with keys for each file in " +#~ "folder bar\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with specified keys instead of " +#~ "names on disk\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with key1=supersecret and " +#~ "key2=topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" +#~ msgstr "" +#~ "\n" +#~ "\t # Create a new secret named my-secret with keys for each file in " +#~ "folder bar\n" +#~ "\t kubectl create secret generic my-secret --from-file=path/to/bar\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with specified keys instead of " +#~ "names on disk\n" +#~ "\t kubectl create secret generic my-secret --from-file=ssh-privatekey=~/." +#~ "ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub\n" +#~ "\n" +#~ "\t # Create a new secret named my-secret with key1=supersecret and " +#~ "key2=topsecret\n" +#~ "\t kubectl create secret generic my-secret --from-" +#~ "literal=key1=supersecret --from-literal=key2=topsecret" + +#~ msgid "" +#~ "\n" +#~ "\t# Create a new ExternalName service named my-ns \n" +#~ "\tkubectl create service externalname my-ns --external-name bar.com" +#~ msgstr "" +#~ "\n" +#~ "\t# Create a new ExternalName service named my-ns \n" +#~ "\tkubectl create service externalname my-ns --external-name bar.com" + +#~ msgid "" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # Create a new clusterIP service named my-cs (in headless mode)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" +#~ msgstr "" +#~ "\n" +#~ " # 创建一个名称为 my-cs 的 clusterIP service\n" +#~ " kubectl create service clusterip my-cs --tcp=5678:8080\n" +#~ "\n" +#~ " # 创建一个名称为 my-cs 的 clusterIP service (在 headless 模式)\n" +#~ " kubectl create service clusterip my-cs --clusterip=\"None\"" + +#~ msgid "" +#~ "\n" +#~ " # Create a new deployment named my-dep that runs the busybox image.\n" +#~ " kubectl create deployment my-dep --image=busybox" +#~ msgstr "" +#~ "\n" +#~ " # 创建一个名称为 my-dep 的 deployment 并运行 busybox image.\n" +#~ " kubectl create deployment my-dep --image=busybox" + +#~ msgid "" +#~ "\n" +#~ " # Create a new nodeport service named my-ns\n" +#~ " kubectl create service nodeport my-ns --tcp=5678:8080" +#~ msgstr "" +#~ "\n" +#~ " # 创建一个名称为 my-ns 的 nodeport service\n" +#~ " kubectl create service nodeport my-ns --tcp=5678:8080" + +#~ msgid "" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend'.\n" +#~ " # If the same annotation is set multiple times, only the last value " +#~ "will be applied\n" +#~ " kubectl annotate pods foo description='my frontend'\n" +#~ "\n" +#~ " # Update a pod identified by type and name in \"pod.json\"\n" +#~ " kubectl annotate -f pod.json description='my frontend'\n" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend running nginx', overwriting any existing value.\n" +#~ " kubectl annotate --overwrite pods foo description='my frontend " +#~ "running nginx'\n" +#~ "\n" +#~ " # Update all pods in the namespace\n" +#~ " kubectl annotate pods --all description='my frontend running nginx'\n" +#~ "\n" +#~ " # Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ " kubectl annotate pods foo description='my frontend running nginx' --" +#~ "resource-version=1\n" +#~ "\n" +#~ " # Update pod 'foo' by removing an annotation named 'description' if " +#~ "it exists.\n" +#~ " # Does not require the --overwrite flag.\n" +#~ " kubectl annotate pods foo description-" +#~ msgstr "" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend'.\n" +#~ " # If the same annotation is set multiple times, only the last value " +#~ "will be applied\n" +#~ " kubectl annotate pods foo description='my frontend'\n" +#~ "\n" +#~ " # Update a pod identified by type and name in \"pod.json\"\n" +#~ " kubectl annotate -f pod.json description='my frontend'\n" +#~ "\n" +#~ " # Update pod 'foo' with the annotation 'description' and the value " +#~ "'my frontend running nginx', overwriting any existing value.\n" +#~ " kubectl annotate --overwrite pods foo description='my frontend " +#~ "running nginx'\n" +#~ "\n" +#~ " # Update all pods in the namespace\n" +#~ " kubectl annotate pods --all description='my frontend running nginx'\n" +#~ "\n" +#~ " # Update pod 'foo' only if the resource is unchanged from version 1.\n" +#~ " kubectl annotate pods foo description='my frontend running nginx' --" +#~ "resource-version=1\n" +#~ "\n" +#~ " # 更新名称为 'foo' 的 pod, 删除一个名称为 'description' 的 annotation " +#~ "如果它存在. \n" +#~ " # 不要求使用 --overwrite flag.\n" +#~ " kubectl annotate pods foo description-" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_serviceaccount.go#L44 +#~ msgid "" +#~ "\n" +#~ " Create a clusterIP service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " 使用一个指定的名称创建一个 clusterIP service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_deployment.go#L44 +#~ msgid "" +#~ "\n" +#~ " Create a deployment with the specified name." +#~ msgstr "" +#~ "\n" +#~ " 使用一个指定的名称创建一个 deployment." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_deployment.go#L44 +#~ msgid "" +#~ "\n" +#~ " Create a nodeport service with the specified name." +#~ msgstr "" +#~ "\n" +#~ " 使用一个指定的名称创建一个 nodeport service." + +#~ msgid "" +#~ "\n" +#~ " Dumps cluster info out suitable for debugging and diagnosing cluster " +#~ "problems. By default, dumps everything to\n" +#~ " stdout. You can optionally specify a directory with --output-" +#~ "directory. If you specify a directory, kubernetes will\n" +#~ " build a set of files in that directory. By default only dumps things " +#~ "in the 'kube-system' namespace, but you can\n" +#~ " switch to a different namespace with the --namespaces flag, or " +#~ "specify --all-namespaces to dump all namespaces.\n" +#~ "\n" +#~ " The command also dumps the logs of all of the pods in the cluster, " +#~ "these logs are dumped into different directories\n" +#~ " based on namespace and pod name." +#~ msgstr "" +#~ "\n" +#~ " Dumps cluster info out suitable for debugging and diagnosing cluster " +#~ "problems. By default, dumps everything to\n" +#~ " stdout. You can optionally specify a directory with --output-" +#~ "directory. If you specify a directory, kubernetes will\n" +#~ " build a set of files in that directory. By default only dumps things " +#~ "in the 'kube-system' namespace, but you can\n" +#~ " switch to a different namespace with the --namespaces flag, or " +#~ "specify --all-namespaces to dump all namespaces.\n" +#~ "\n" +#~ " The command also dumps the logs of all of the pods in the cluster, " +#~ "these logs are dumped into different directories\n" +#~ " based on namespace and pod name." + +#~ msgid "" +#~ "\n" +#~ " Display addresses of the master and services with label kubernetes.io/" +#~ "cluster-service=true\n" +#~ " To further debug and diagnose cluster problems, use 'kubectl cluster-" +#~ "info dump'." +#~ msgstr "" +#~ "\n" +#~ " Display addresses of the master and services with label kubernetes.io/" +#~ "cluster-service=true\n" +#~ " To further debug and diagnose cluster problems, use 'kubectl cluster-" +#~ "info dump'." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L136 +#~ msgid "A schedule in the Cron format the job should be run with." +#~ msgstr "A schedule in the Cron format the job should be run with." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L134 +#~ msgid "" +#~ "An inline JSON override for the generated service object. If this is non-" +#~ "empty, it is used to override the generated object. Requires that the " +#~ "object supply a valid apiVersion field. Only used if --expose is true." +#~ msgstr "" +#~ "An inline JSON override for the generated service object. If this is non-" +#~ "empty, it is used to override the generated object. Requires that the " +#~ "object supply a valid apiVersion field. Only used if --expose is true." + +#~ msgid "Apply a configuration to a resource by filename or stdin" +#~ msgstr "通过文件名或标准输入流(stdin)对资源进行配置" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/autoscale.go#L55 +#~ msgid "Auto-scale a Deployment, ReplicaSet, or ReplicationController" +#~ msgstr "" +#~ "自动调整一个 Deployment, ReplicaSet, 或者 ReplicationController 的副本数量" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L101 +#~ msgid "" +#~ "Container name which will have its image upgraded. Only relevant when --" +#~ "image is specified, ignored otherwise. Required when using --image on a " +#~ "multi-container pod" +#~ msgstr "" +#~ "Container name which will have its image upgraded. Only relevant when --" +#~ "image is specified, ignored otherwise. Required when using --image on a " +#~ "multi-container pod" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_clusterrolebinding.go#L43 +#~ msgid "Create a ClusterRoleBinding for a particular ClusterRole" +#~ msgstr "为一个指定的 ClusterRole 创建一个 ClusterRoleBinding" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L181 +#~ msgid "Create a LoadBalancer service." +#~ msgstr "创建一个 LoadBalancer service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L124 +#~ msgid "Create a NodePort service." +#~ msgstr "创建一个 NodePort service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_rolebinding.go#L43 +#~ msgid "Create a RoleBinding for a particular Role or ClusterRole" +#~ msgstr "为一个指定的 Role 或者 ClusterRole创建一个 RoleBinding" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L68 +#~ msgid "Create a clusterIP service." +#~ msgstr "创建一个 clusterIP service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_configmap.go#L59 +#~ msgid "Create a configmap from a local file, directory or literal value" +#~ msgstr "从本地 file, directory 或者 literal value 创建一个 configmap" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_deployment.go#L44 +#~ msgid "Create a deployment with the specified name." +#~ msgstr "创建一个指定名称的 deployment." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_pdb.go#L49 +#~ msgid "Create a pod disruption budget with the specified name." +#~ msgstr "创建一个指定名称的 pod disruption budget." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_quota.go#L47 +#~ msgid "Create a quota with the specified name." +#~ msgstr "创建一个指定名称的 quota." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create.go#L56 +#~ msgid "Create a resource by filename or stdin" +#~ msgstr "通过文件名或者标准输入流(stdin)创建一个资源" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_secret.go#L73 +#~ msgid "Create a secret from a local file, directory or literal value" +#~ msgstr "从本地 file, directory 或者 literal value 创建一个 secret" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L36 +#~ msgid "Create a service using specified subcommand." +#~ msgstr "使用指定的 subcommand 创建一个 service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L240 +#~ msgid "Create an ExternalName service." +#~ msgstr "Create an ExternalName service." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/delete.go#L130 +#~ msgid "" +#~ "Delete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector" +#~ msgstr "" +#~ "Delete resources by filenames, stdin, resources and names, or by " +#~ "resources and label selector" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/stop.go#L58 +#~ msgid "Deprecated: Gracefully shut down a resource by name or filename" +#~ msgstr "Deprecated: Gracefully shut down a resource by name or filename" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/top_node.go#L77 +#~ msgid "Display Resource (CPU/Memory) usage of nodes" +#~ msgstr "显示 nodes 的 Resource (CPU/Memory) 使用" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/top_pod.go#L79 +#~ msgid "Display Resource (CPU/Memory) usage of pods" +#~ msgstr "显示 pods 的 Resource (CPU/Memory) 使用" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/top.go#L43 +#~ msgid "Display Resource (CPU/Memory) usage." +#~ msgstr "显示 Resource (CPU/Memory) 使用." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/clusterinfo.go#L49 +#~ msgid "Display cluster info" +#~ msgstr "显示集群信息" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/current_context.go#L48 +#~ msgid "Displays the current-context" +#~ msgstr "显示当前的 context" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/explain.go#L50 +#~ msgid "Documentation of resources" +#~ msgstr "查看资源的文档" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/clusterinfo_dump.go#L37 +#~ msgid "Dump lots of relevant info for debugging and diagnosis" +#~ msgstr "Dump lots of relevant info for debugging and diagnosis" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L102 +#~ msgid "" +#~ "Explicit policy for when to pull container images. Required when --image " +#~ "is same as existing image, ignored otherwise." +#~ msgstr "" +#~ "Explicit policy for when to pull container images. Required when --image " +#~ "is same as existing image, ignored otherwise." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L105 +#~ msgid "" +#~ "IP to assign to the Load Balancer. If empty, an ephemeral IP will be " +#~ "created and used (cloud-provider specific)." +#~ msgstr "" +#~ "IP to assign to the Load Balancer. If empty, an ephemeral IP will be " +#~ "created and used (cloud-provider specific)." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L98 +#~ msgid "" +#~ "Image to use for upgrading the replication controller. Must be distinct " +#~ "from the existing image (either new image or new image tag). Can not be " +#~ "used with --filename/-f" +#~ msgstr "" +#~ "Image to use for upgrading the replication controller. Must be distinct " +#~ "from the existing image (either new image or new image tag). Can not be " +#~ "used with --filename/-f" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollout/rollout.go#L46 +#~ msgid "Manage a deployment rollout" +#~ msgstr "管理一个 deployment 的 rollout" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/edit.go#L115 +#~ msgid "" +#~ "Output the formatted object with the given group version (for ex: " +#~ "'extensions/v1beta1').)" +#~ msgstr "" +#~ "Output the formatted object with the given group version (for ex: " +#~ "'extensions/v1beta1').)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L84 +#~ msgid "Perform a rolling update of the given ReplicationController" +#~ msgstr "完成指定的 ReplicationController 的滚动升级" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/replace.go#L70 +#~ msgid "Replace a resource by filename or stdin" +#~ msgstr "通过 filename 或者 stdin替换一个资源" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/scale.go#L71 +#~ msgid "" +#~ "Set a new size for a Deployment, ReplicaSet, Replication Controller, or " +#~ "Job" +#~ msgstr "" +#~ "为 Deployment, ReplicaSet, Replication Controller 或者 Job 设置一个新的副" +#~ "本数量" + +#~ msgid "" +#~ "Set the last-applied-configuration annotation on a live object to match " +#~ "the contents of a file." +#~ msgstr "" +#~ "Set the last-applied-configuration annotation on a live object to match " +#~ "the contents of a file." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_cluster.go#L67 +#~ msgid "Sets a cluster entry in kubeconfig" +#~ msgstr "设置 kubeconfig 文件中的一个集群条目" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_context.go#L57 +#~ msgid "Sets a context entry in kubeconfig" +#~ msgstr "设置 kubeconfig 文件中的一个 context 条目" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/create_authinfo.go#L103 +#~ msgid "Sets a user entry in kubeconfig" +#~ msgstr "设置 kubeconfig 文件中的一个用户条目" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/set.go#L59 +#~ msgid "Sets an individual value in a kubeconfig file" +#~ msgstr "设置 kubeconfig 文件中的一个单个值" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/use_context.go#L48 +#~ msgid "Sets the current-context in a kubeconfig file" +#~ msgstr "设置 kubeconfig 文件中的当前上下文" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L87 +#~ msgid "" +#~ "Take a replication controller, service, deployment or pod and expose it " +#~ "as a new Kubernetes Service" +#~ msgstr "" +#~ "使用 replication controller, service, deployment 或者 pod 并暴露它作为一" +#~ "个 新的 Kubernetes Service" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/rollingupdate.go#L100 +#~ msgid "" +#~ "The key to use to differentiate between two different controllers, " +#~ "default 'deployment'. Only relevant when --image is specified, ignored " +#~ "otherwise" +#~ msgstr "" +#~ "这个 key 使用有区别在两个不同的 controllers, 默认 'deployment'. 只有当 --" +#~ "image 指定值, 否则忽略" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L113 +#~ msgid "" +#~ "The name of the API generator to use, see http://kubernetes.io/docs/user-" +#~ "guide/kubectl-conventions/#generators for a list." +#~ msgstr "" +#~ "使用 API generator 的名字, 在 http://kubernetes.io/docs/user-guide/" +#~ "kubectl-conventions/#generators 查看列表." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/autoscale.go#L66 +#~ msgid "" +#~ "The name of the API generator to use. Currently there is only 1 generator." +#~ msgstr "使用 API generator 的名字. 目前只有 1 个 generator." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L133 +#~ msgid "" +#~ "The name of the generator to use for creating a service. Only used if --" +#~ "expose is true" +#~ msgstr "" +#~ "使用 gnerator 的名称创建一个 service. 只有在 --expose 为 true 的时候使用" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L121 +#~ msgid "" +#~ "The port that this container exposes. If --expose is true, this is also " +#~ "the port used by the service that is created." +#~ msgstr "" +#~ "The port that this container exposes. If --expose is true, this is also " +#~ "the port used by the service that is created." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/run.go#L128 +#~ msgid "" +#~ "The restart policy for this Pod. Legal values [Always, OnFailure, " +#~ "Never]. If set to 'Always' a deployment is created, if set to " +#~ "'OnFailure' a job is created, if set to 'Never', a regular pod is " +#~ "created. For the latter two --replicas must be 1. Default 'Always', for " +#~ "CronJobs `Never`." +#~ msgstr "" +#~ "这个 Pod 的 restart policy. Legal values [Always, OnFailure, Never]. 如果" +#~ "设置为 'Always' 一个 deployment 被创建, 如果设置为 ’OnFailure' 一个 job 被" +#~ "创建, 如果设置为 'Never', 一个普通的 pod 被创建. 对于后面两个 --replicas " +#~ "必须为 1. 默认 'Always', 为 CronJobs 设置为 `Never`." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/expose.go#L101 +#~ msgid "" +#~ "Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is " +#~ "'ClusterIP'." +#~ msgstr "" +#~ "对于服务的类型: ClusterIP, NodePort, 或者 LoadBalancer. 默认是 " +#~ "'ClusterIP’." + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/config/unset.go#L47 +#~ msgid "Unsets an individual value in a kubeconfig file" +#~ msgstr "取消设置 kubeconfig 文件中的一个单个值" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/patch.go#L91 +#~ msgid "Update field(s) of a resource using strategic merge patch" +#~ msgstr "使用 strategic merge patch 更新一个资源的 field(s)" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/set/set_image.go#L94 +#~ msgid "Update image of a pod template" +#~ msgstr "更新一个 pod template 的镜像" + +#~ msgid "" +#~ "View latest last-applied-configuration annotations of a resource/object" +#~ msgstr "" +#~ "显示最后的 resource/object 的 last-applied-configuration annotations" + +# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/create_service.go#L253 +#~ msgid "external name of service" +#~ msgstr "服务的外部名称" + +#~ msgid "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgid_plural "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgstr[0] "" +#~ "watch 仅支持单独的资源或者资源集合 - 找到了 %d 个资源watch is only " +#~ "supported on individual resources and resource collections - %d resource " +#~ "was found" +#~ msgstr[1] "" +#~ "watch 仅支持单独的资源或者资源集合 - 找到了 %d 个资源watch is only " +#~ "supported on individual resources and resource collections - %d resources " +#~ "were found" diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_TW/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_TW/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..9be9a30d32 Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_TW/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_TW/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_TW/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..58fd63a9ff --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/kubectl/zh_TW/LC_MESSAGES/k8s.po @@ -0,0 +1,81 @@ +# Test translations for unit tests. +# Copyright (C) 2017 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR warmchang@outlook.com, 2017. +# +msgid "" +msgstr "" +"Project-Id-Version: hello-world\n" +"Report-Msgid-Bugs-To: EMAIL\n" +"POT-Creation-Date: 2021-07-07 20:15+0200\n" +"PO-Revision-Date: 2017-06-02 09:13+0800\n" +"Last-Translator: William Chang \n" +"Language-Team: \n" +"Language: zh\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 2.0.2\n" +"X-Poedit-SourceCharset: UTF-8\n" +"Plural-Forms: nplurals=2; plural=(n > 1);\n" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_cluster.go:42 +msgid "Delete the specified cluster from the kubeconfig" +msgstr "刪除 kubeconfig 檔案中指定的叢集(cluster)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/delete_context.go:42 +msgid "Delete the specified context from the kubeconfig" +msgstr "刪除 kubeconfig 檔案中指定的 context" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_contexts.go:72 +msgid "Describe one or many contexts" +msgstr "描述一個或多個 context" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/get_clusters.go:41 +msgid "Display clusters defined in the kubeconfig" +msgstr "顯示 kubeconfig 檔案中定義的叢集(cluster)" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/view.go:81 +msgid "Display merged kubeconfig settings or a specified kubeconfig file" +msgstr "顯示合併的 kubeconfig 配置或一個指定的 kubeconfig 檔案" + +#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:42 +msgid "Modify kubeconfig files" +msgstr "修改 kubeconfig 檔案" + +#: staging/src/k8s.io/kubectl/pkg/cmd/annotate/annotate.go:135 +msgid "Update the annotations on a resource" +msgstr "更新一個資源的注解(annotations)" + +#~ msgid "Apply a configuration to a resource by filename or stdin" +#~ msgstr "通過檔案名或標準輸入流(stdin)對資源進行配置" + +#~ msgid "Displays the current-context" +#~ msgstr "顯示目前的 context" + +#~ msgid "Sets a cluster entry in kubeconfig" +#~ msgstr "設置 kubeconfig 檔案中的一個叢集(cluster)條目" + +#~ msgid "Sets a context entry in kubeconfig" +#~ msgstr "設置 kubeconfig 檔案中的一個 context 條目" + +#~ msgid "Sets a user entry in kubeconfig" +#~ msgstr "設置 kubeconfig 檔案中的一個使用者條目" + +#~ msgid "Sets an individual value in a kubeconfig file" +#~ msgstr "設置 kubeconfig 檔案中的一個值" + +#~ msgid "Sets the current-context in a kubeconfig file" +#~ msgstr "設置 kubeconfig 檔案中的目前 context" + +#~ msgid "Unsets an individual value in a kubeconfig file" +#~ msgstr "取消設置 kubeconfig 檔案中的一個值" + +#~ msgid "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgid_plural "" +#~ "watch is only supported on individual resources and resource collections " +#~ "- %d resources were found" +#~ msgstr[0] "一次只能 watch 一個資源或資料集合 - 找到了 %d 個資源" +#~ msgstr[1] "一次只能 watch 一個資源或資料集合 - 找到了 %d 個資源" diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/default/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/default/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..5487fb8ccf Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/default/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/default/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/default/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..7e77c43009 --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/default/LC_MESSAGES/k8s.po @@ -0,0 +1,28 @@ +# Test translations for unit tests. +# Copyright (C) 2016 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR brendan.d.burns@gmail.com, 2016. +# +msgid "" +msgstr "" +"Project-Id-Version: gettext-go-examples-hello\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2013-12-12 20:03+0000\n" +"PO-Revision-Date: 2016-12-13 21:35-0800\n" +"Last-Translator: Brendan Burns \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 1.6.10\n" +"X-Poedit-SourceCharset: UTF-8\n" +"Language-Team: \n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Language: en\n" + +msgid "test_plural" +msgid_plural "test_plural" +msgstr[0] "there was %d item" +msgstr[1] "there were %d items" + +msgid "test_string" +msgstr "foo" diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/en_US/LC_MESSAGES/k8s.mo b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/en_US/LC_MESSAGES/k8s.mo new file mode 100644 index 0000000000..44fe7b5d96 Binary files /dev/null and b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/en_US/LC_MESSAGES/k8s.mo differ diff --git a/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/en_US/LC_MESSAGES/k8s.po b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/en_US/LC_MESSAGES/k8s.po new file mode 100644 index 0000000000..9944046aeb --- /dev/null +++ b/vendor/k8s.io/kubectl/pkg/util/i18n/translations/test/en_US/LC_MESSAGES/k8s.po @@ -0,0 +1,28 @@ +# Test translations for unit tests. +# Copyright (C) 2016 +# This file is distributed under the same license as the Kubernetes package. +# FIRST AUTHOR brendan.d.burns@gmail.com, 2016. +# +msgid "" +msgstr "" +"Project-Id-Version: gettext-go-examples-hello\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2013-12-12 20:03+0000\n" +"PO-Revision-Date: 2016-12-13 22:12-0800\n" +"Last-Translator: Brendan Burns \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 1.6.10\n" +"X-Poedit-SourceCharset: UTF-8\n" +"Language-Team: \n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Language: en\n" + +msgid "test_plural" +msgid_plural "test_plural" +msgstr[0] "there was %d item" +msgstr[1] "there were %d items" + +msgid "test_string" +msgstr "baz" diff --git a/vendor/k8s.io/kubectl/pkg/util/templates/templater.go b/vendor/k8s.io/kubectl/pkg/util/templates/templater.go index c8036ac134..b55adc6b9c 100644 --- a/vendor/k8s.io/kubectl/pkg/util/templates/templater.go +++ b/vendor/k8s.io/kubectl/pkg/util/templates/templater.go @@ -225,10 +225,10 @@ func flagsUsages(f *flag.FlagSet) string { if flag.Hidden { return } - format := "--%s=%s: %s\n" + format := "--%s=%s: %s%s\n" if flag.Value.Type() == "string" { - format = "--%s='%s': %s\n" + format = "--%s='%s': %s%s\n" } if len(flag.Shorthand) > 0 { @@ -237,7 +237,12 @@ func flagsUsages(f *flag.FlagSet) string { format = " %s " + format } - fmt.Fprintf(x, format, flag.Shorthand, flag.Name, flag.DefValue, flag.Usage) + deprecated := "" + if flag.Deprecated != "" { + deprecated = fmt.Sprintf(" (DEPRECATED: %s)", flag.Deprecated) + } + + fmt.Fprintf(x, format, flag.Shorthand, flag.Name, flag.DefValue, flag.Usage, deprecated) }) return x.String() diff --git a/vendor/k8s.io/kubectl/pkg/util/term/resizeevents.go b/vendor/k8s.io/kubectl/pkg/util/term/resizeevents.go index e3476f978d..e361b1adb3 100644 --- a/vendor/k8s.io/kubectl/pkg/util/term/resizeevents.go +++ b/vendor/k8s.io/kubectl/pkg/util/term/resizeevents.go @@ -1,3 +1,4 @@ +//go:build !windows // +build !windows /* diff --git a/vendor/k8s.io/utils/clock/README.md b/vendor/k8s.io/utils/clock/README.md new file mode 100644 index 0000000000..ad2a8868aa --- /dev/null +++ b/vendor/k8s.io/utils/clock/README.md @@ -0,0 +1,4 @@ +# Clock + +This package provides an interface for time-based operations. It allows +mocking time for testing. diff --git a/vendor/k8s.io/utils/clock/clock.go b/vendor/k8s.io/utils/clock/clock.go new file mode 100644 index 0000000000..dd181ce8d8 --- /dev/null +++ b/vendor/k8s.io/utils/clock/clock.go @@ -0,0 +1,168 @@ +/* +Copyright 2014 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package clock + +import "time" + +// PassiveClock allows for injecting fake or real clocks into code +// that needs to read the current time but does not support scheduling +// activity in the future. +type PassiveClock interface { + Now() time.Time + Since(time.Time) time.Duration +} + +// Clock allows for injecting fake or real clocks into code that +// needs to do arbitrary things based on time. +type Clock interface { + PassiveClock + // After returns the channel of a new Timer. + // This method does not allow to free/GC the backing timer before it fires. Use + // NewTimer instead. + After(d time.Duration) <-chan time.Time + // NewTimer returns a new Timer. + NewTimer(d time.Duration) Timer + // Sleep sleeps for the provided duration d. + // Consider making the sleep interruptible by using 'select' on a context channel and a timer channel. + Sleep(d time.Duration) + // Tick returns the channel of a new Ticker. + // This method does not allow to free/GC the backing ticker. Use + // NewTicker from WithTicker instead. + Tick(d time.Duration) <-chan time.Time +} + +// WithTicker allows for injecting fake or real clocks into code that +// needs to do arbitrary things based on time. +type WithTicker interface { + Clock + // NewTicker returns a new Ticker. + NewTicker(time.Duration) Ticker +} + +// WithDelayedExecution allows for injecting fake or real clocks into +// code that needs to make use of AfterFunc functionality. +type WithDelayedExecution interface { + Clock + // AfterFunc executes f in its own goroutine after waiting + // for d duration and returns a Timer whose channel can be + // closed by calling Stop() on the Timer. + AfterFunc(d time.Duration, f func()) Timer +} + +// Ticker defines the Ticker interface. +type Ticker interface { + C() <-chan time.Time + Stop() +} + +var _ = WithTicker(RealClock{}) + +// RealClock really calls time.Now() +type RealClock struct{} + +// Now returns the current time. +func (RealClock) Now() time.Time { + return time.Now() +} + +// Since returns time since the specified timestamp. +func (RealClock) Since(ts time.Time) time.Duration { + return time.Since(ts) +} + +// After is the same as time.After(d). +// This method does not allow to free/GC the backing timer before it fires. Use +// NewTimer instead. +func (RealClock) After(d time.Duration) <-chan time.Time { + return time.After(d) +} + +// NewTimer is the same as time.NewTimer(d) +func (RealClock) NewTimer(d time.Duration) Timer { + return &realTimer{ + timer: time.NewTimer(d), + } +} + +// AfterFunc is the same as time.AfterFunc(d, f). +func (RealClock) AfterFunc(d time.Duration, f func()) Timer { + return &realTimer{ + timer: time.AfterFunc(d, f), + } +} + +// Tick is the same as time.Tick(d) +// This method does not allow to free/GC the backing ticker. Use +// NewTicker instead. +func (RealClock) Tick(d time.Duration) <-chan time.Time { + return time.Tick(d) +} + +// NewTicker returns a new Ticker. +func (RealClock) NewTicker(d time.Duration) Ticker { + return &realTicker{ + ticker: time.NewTicker(d), + } +} + +// Sleep is the same as time.Sleep(d) +// Consider making the sleep interruptible by using 'select' on a context channel and a timer channel. +func (RealClock) Sleep(d time.Duration) { + time.Sleep(d) +} + +// Timer allows for injecting fake or real timers into code that +// needs to do arbitrary things based on time. +type Timer interface { + C() <-chan time.Time + Stop() bool + Reset(d time.Duration) bool +} + +var _ = Timer(&realTimer{}) + +// realTimer is backed by an actual time.Timer. +type realTimer struct { + timer *time.Timer +} + +// C returns the underlying timer's channel. +func (r *realTimer) C() <-chan time.Time { + return r.timer.C +} + +// Stop calls Stop() on the underlying timer. +func (r *realTimer) Stop() bool { + return r.timer.Stop() +} + +// Reset calls Reset() on the underlying timer. +func (r *realTimer) Reset(d time.Duration) bool { + return r.timer.Reset(d) +} + +type realTicker struct { + ticker *time.Ticker +} + +func (r *realTicker) C() <-chan time.Time { + return r.ticker.C +} + +func (r *realTicker) Stop() { + r.ticker.Stop() +} diff --git a/vendor/k8s.io/utils/clock/testing/fake_clock.go b/vendor/k8s.io/utils/clock/testing/fake_clock.go new file mode 100644 index 0000000000..fb493c4bab --- /dev/null +++ b/vendor/k8s.io/utils/clock/testing/fake_clock.go @@ -0,0 +1,360 @@ +/* +Copyright 2014 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package testing + +import ( + "sync" + "time" + + "k8s.io/utils/clock" +) + +var ( + _ = clock.PassiveClock(&FakePassiveClock{}) + _ = clock.WithTicker(&FakeClock{}) + _ = clock.Clock(&IntervalClock{}) +) + +// FakePassiveClock implements PassiveClock, but returns an arbitrary time. +type FakePassiveClock struct { + lock sync.RWMutex + time time.Time +} + +// FakeClock implements clock.Clock, but returns an arbitrary time. +type FakeClock struct { + FakePassiveClock + + // waiters are waiting for the fake time to pass their specified time + waiters []*fakeClockWaiter +} + +type fakeClockWaiter struct { + targetTime time.Time + stepInterval time.Duration + skipIfBlocked bool + destChan chan time.Time + fired bool + afterFunc func() +} + +// NewFakePassiveClock returns a new FakePassiveClock. +func NewFakePassiveClock(t time.Time) *FakePassiveClock { + return &FakePassiveClock{ + time: t, + } +} + +// NewFakeClock constructs a fake clock set to the provided time. +func NewFakeClock(t time.Time) *FakeClock { + return &FakeClock{ + FakePassiveClock: *NewFakePassiveClock(t), + } +} + +// Now returns f's time. +func (f *FakePassiveClock) Now() time.Time { + f.lock.RLock() + defer f.lock.RUnlock() + return f.time +} + +// Since returns time since the time in f. +func (f *FakePassiveClock) Since(ts time.Time) time.Duration { + f.lock.RLock() + defer f.lock.RUnlock() + return f.time.Sub(ts) +} + +// SetTime sets the time on the FakePassiveClock. +func (f *FakePassiveClock) SetTime(t time.Time) { + f.lock.Lock() + defer f.lock.Unlock() + f.time = t +} + +// After is the fake version of time.After(d). +func (f *FakeClock) After(d time.Duration) <-chan time.Time { + f.lock.Lock() + defer f.lock.Unlock() + stopTime := f.time.Add(d) + ch := make(chan time.Time, 1) // Don't block! + f.waiters = append(f.waiters, &fakeClockWaiter{ + targetTime: stopTime, + destChan: ch, + }) + return ch +} + +// NewTimer constructs a fake timer, akin to time.NewTimer(d). +func (f *FakeClock) NewTimer(d time.Duration) clock.Timer { + f.lock.Lock() + defer f.lock.Unlock() + stopTime := f.time.Add(d) + ch := make(chan time.Time, 1) // Don't block! + timer := &fakeTimer{ + fakeClock: f, + waiter: fakeClockWaiter{ + targetTime: stopTime, + destChan: ch, + }, + } + f.waiters = append(f.waiters, &timer.waiter) + return timer +} + +// AfterFunc is the Fake version of time.AfterFunc(d, cb). +func (f *FakeClock) AfterFunc(d time.Duration, cb func()) clock.Timer { + f.lock.Lock() + defer f.lock.Unlock() + stopTime := f.time.Add(d) + ch := make(chan time.Time, 1) // Don't block! + + timer := &fakeTimer{ + fakeClock: f, + waiter: fakeClockWaiter{ + targetTime: stopTime, + destChan: ch, + afterFunc: cb, + }, + } + f.waiters = append(f.waiters, &timer.waiter) + return timer +} + +// Tick constructs a fake ticker, akin to time.Tick +func (f *FakeClock) Tick(d time.Duration) <-chan time.Time { + if d <= 0 { + return nil + } + f.lock.Lock() + defer f.lock.Unlock() + tickTime := f.time.Add(d) + ch := make(chan time.Time, 1) // hold one tick + f.waiters = append(f.waiters, &fakeClockWaiter{ + targetTime: tickTime, + stepInterval: d, + skipIfBlocked: true, + destChan: ch, + }) + + return ch +} + +// NewTicker returns a new Ticker. +func (f *FakeClock) NewTicker(d time.Duration) clock.Ticker { + f.lock.Lock() + defer f.lock.Unlock() + tickTime := f.time.Add(d) + ch := make(chan time.Time, 1) // hold one tick + f.waiters = append(f.waiters, &fakeClockWaiter{ + targetTime: tickTime, + stepInterval: d, + skipIfBlocked: true, + destChan: ch, + }) + + return &fakeTicker{ + c: ch, + } +} + +// Step moves the clock by Duration and notifies anyone that's called After, +// Tick, or NewTimer. +func (f *FakeClock) Step(d time.Duration) { + f.lock.Lock() + defer f.lock.Unlock() + f.setTimeLocked(f.time.Add(d)) +} + +// SetTime sets the time. +func (f *FakeClock) SetTime(t time.Time) { + f.lock.Lock() + defer f.lock.Unlock() + f.setTimeLocked(t) +} + +// Actually changes the time and checks any waiters. f must be write-locked. +func (f *FakeClock) setTimeLocked(t time.Time) { + f.time = t + newWaiters := make([]*fakeClockWaiter, 0, len(f.waiters)) + for i := range f.waiters { + w := f.waiters[i] + if !w.targetTime.After(t) { + if w.skipIfBlocked { + select { + case w.destChan <- t: + w.fired = true + default: + } + } else { + w.destChan <- t + w.fired = true + } + + if w.afterFunc != nil { + w.afterFunc() + } + + if w.stepInterval > 0 { + for !w.targetTime.After(t) { + w.targetTime = w.targetTime.Add(w.stepInterval) + } + newWaiters = append(newWaiters, w) + } + + } else { + newWaiters = append(newWaiters, f.waiters[i]) + } + } + f.waiters = newWaiters +} + +// HasWaiters returns true if After or AfterFunc has been called on f but not yet satisfied (so you can +// write race-free tests). +func (f *FakeClock) HasWaiters() bool { + f.lock.RLock() + defer f.lock.RUnlock() + return len(f.waiters) > 0 +} + +// Sleep is akin to time.Sleep +func (f *FakeClock) Sleep(d time.Duration) { + f.Step(d) +} + +// IntervalClock implements clock.PassiveClock, but each invocation of Now steps the clock forward the specified duration. +// IntervalClock technically implements the other methods of clock.Clock, but each implementation is just a panic. +// See SimpleIntervalClock for an alternative that only has the methods of PassiveClock. +type IntervalClock struct { + Time time.Time + Duration time.Duration +} + +// Now returns i's time. +func (i *IntervalClock) Now() time.Time { + i.Time = i.Time.Add(i.Duration) + return i.Time +} + +// Since returns time since the time in i. +func (i *IntervalClock) Since(ts time.Time) time.Duration { + return i.Time.Sub(ts) +} + +// After is unimplemented, will panic. +// TODO: make interval clock use FakeClock so this can be implemented. +func (*IntervalClock) After(d time.Duration) <-chan time.Time { + panic("IntervalClock doesn't implement After") +} + +// NewTimer is unimplemented, will panic. +// TODO: make interval clock use FakeClock so this can be implemented. +func (*IntervalClock) NewTimer(d time.Duration) clock.Timer { + panic("IntervalClock doesn't implement NewTimer") +} + +// AfterFunc is unimplemented, will panic. +// TODO: make interval clock use FakeClock so this can be implemented. +func (*IntervalClock) AfterFunc(d time.Duration, f func()) clock.Timer { + panic("IntervalClock doesn't implement AfterFunc") +} + +// Tick is unimplemented, will panic. +// TODO: make interval clock use FakeClock so this can be implemented. +func (*IntervalClock) Tick(d time.Duration) <-chan time.Time { + panic("IntervalClock doesn't implement Tick") +} + +// NewTicker has no implementation yet and is omitted. +// TODO: make interval clock use FakeClock so this can be implemented. +//func (*IntervalClock) NewTicker(d time.Duration) clock.Ticker { +// panic("IntervalClock doesn't implement NewTicker") +//} + +// Sleep is unimplemented, will panic. +func (*IntervalClock) Sleep(d time.Duration) { + panic("IntervalClock doesn't implement Sleep") +} + +var _ = clock.Timer(&fakeTimer{}) + +// fakeTimer implements clock.Timer based on a FakeClock. +type fakeTimer struct { + fakeClock *FakeClock + waiter fakeClockWaiter +} + +// C returns the channel that notifies when this timer has fired. +func (f *fakeTimer) C() <-chan time.Time { + return f.waiter.destChan +} + +// Stop stops the timer and returns true if the timer has not yet fired, or false otherwise. +func (f *fakeTimer) Stop() bool { + f.fakeClock.lock.Lock() + defer f.fakeClock.lock.Unlock() + + newWaiters := make([]*fakeClockWaiter, 0, len(f.fakeClock.waiters)) + for i := range f.fakeClock.waiters { + w := f.fakeClock.waiters[i] + if w != &f.waiter { + newWaiters = append(newWaiters, w) + } + } + + f.fakeClock.waiters = newWaiters + + return !f.waiter.fired +} + +// Reset resets the timer to the fake clock's "now" + d. It returns true if the timer has not yet +// fired, or false otherwise. +func (f *fakeTimer) Reset(d time.Duration) bool { + f.fakeClock.lock.Lock() + defer f.fakeClock.lock.Unlock() + + active := !f.waiter.fired + + f.waiter.fired = false + f.waiter.targetTime = f.fakeClock.time.Add(d) + + var isWaiting bool + for i := range f.fakeClock.waiters { + w := f.fakeClock.waiters[i] + if w == &f.waiter { + isWaiting = true + break + } + } + if !isWaiting { + f.fakeClock.waiters = append(f.fakeClock.waiters, &f.waiter) + } + + return active +} + +type fakeTicker struct { + c <-chan time.Time +} + +func (t *fakeTicker) C() <-chan time.Time { + return t.c +} + +func (t *fakeTicker) Stop() { +} diff --git a/vendor/k8s.io/utils/clock/testing/simple_interval_clock.go b/vendor/k8s.io/utils/clock/testing/simple_interval_clock.go new file mode 100644 index 0000000000..951ca4d170 --- /dev/null +++ b/vendor/k8s.io/utils/clock/testing/simple_interval_clock.go @@ -0,0 +1,44 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package testing + +import ( + "time" + + "k8s.io/utils/clock" +) + +var ( + _ = clock.PassiveClock(&SimpleIntervalClock{}) +) + +// SimpleIntervalClock implements clock.PassiveClock, but each invocation of Now steps the clock forward the specified duration +type SimpleIntervalClock struct { + Time time.Time + Duration time.Duration +} + +// Now returns i's time. +func (i *SimpleIntervalClock) Now() time.Time { + i.Time = i.Time.Add(i.Duration) + return i.Time +} + +// Since returns time since the time in i. +func (i *SimpleIntervalClock) Since(ts time.Time) time.Duration { + return i.Time.Sub(ts) +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 55a56718ac..bb966b4ceb 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -62,6 +62,9 @@ github.com/NYTimes/gziphandler github.com/PuerkitoBio/purell # github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 github.com/PuerkitoBio/urlesc +# github.com/adrg/xdg v0.4.0 +github.com/adrg/xdg +github.com/adrg/xdg/internal/pathutil # github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e github.com/antlr/antlr4/runtime/Go/antlr # github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535 @@ -74,6 +77,11 @@ github.com/blang/semver github.com/blang/semver/v4 # github.com/cespare/xxhash/v2 v2.1.1 github.com/cespare/xxhash/v2 +# github.com/chai2010/gettext-go v0.0.0-20160711120539-c6fed771bfd5 +github.com/chai2010/gettext-go/gettext +github.com/chai2010/gettext-go/gettext/mo +github.com/chai2010/gettext-go/gettext/plural +github.com/chai2010/gettext-go/gettext/po # github.com/containerd/cgroups v0.0.0-20200531161412-0dbf7f05ba59 github.com/containerd/cgroups/stats/v1 # github.com/containerd/containerd v1.4.11 => github.com/ecordell/containerd v1.3.1-0.20200629153125-0ff1a1be2fa5 @@ -128,7 +136,7 @@ github.com/deislabs/oras/pkg/context github.com/deislabs/oras/pkg/oras # github.com/distribution/distribution v2.7.1+incompatible github.com/distribution/distribution/reference -# github.com/docker/cli v20.10.5+incompatible +# github.com/docker/cli v20.10.12+incompatible github.com/docker/cli/cli/config github.com/docker/cli/cli/config/configfile github.com/docker/cli/cli/config/credentials @@ -187,7 +195,7 @@ github.com/docker/go-units # github.com/emicklei/go-restful v2.9.5+incompatible github.com/emicklei/go-restful github.com/emicklei/go-restful/log -# github.com/evanphx/json-patch v4.11.0+incompatible +# github.com/evanphx/json-patch v4.12.0+incompatible github.com/evanphx/json-patch # github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d github.com/exponent-io/jsonpath @@ -197,7 +205,7 @@ github.com/fatih/color github.com/felixge/httpsnoop # github.com/form3tech-oss/jwt-go v3.2.3+incompatible github.com/form3tech-oss/jwt-go -# github.com/fsnotify/fsnotify v1.4.9 +# github.com/fsnotify/fsnotify v1.5.1 github.com/fsnotify/fsnotify # github.com/ghodss/yaml v1.0.0 github.com/ghodss/yaml @@ -225,10 +233,10 @@ github.com/go-git/go-billy/v5 github.com/go-git/go-git/v5/plumbing/format/config github.com/go-git/go-git/v5/plumbing/format/gitignore github.com/go-git/go-git/v5/utils/ioutil -# github.com/go-logr/logr v0.4.0 +# github.com/go-logr/logr v1.2.0 ## explicit github.com/go-logr/logr -# github.com/go-logr/zapr v0.4.0 +# github.com/go-logr/zapr v1.2.0 github.com/go-logr/zapr # github.com/go-openapi/jsonpointer v0.19.5 github.com/go-openapi/jsonpointer @@ -298,6 +306,7 @@ github.com/google/cel-go/common/types github.com/google/cel-go/common/types/pb github.com/google/cel-go/common/types/ref github.com/google/cel-go/common/types/traits +github.com/google/cel-go/ext github.com/google/cel-go/interpreter github.com/google/cel-go/interpreter/functions github.com/google/cel-go/parser @@ -327,7 +336,7 @@ github.com/googleapis/gnostic/openapiv2 github.com/googleapis/gnostic/openapiv3 github.com/googleapis/gnostic/plugins github.com/googleapis/gnostic/surface -# github.com/gorilla/mux v1.7.3 +# github.com/gorilla/mux v1.8.0 github.com/gorilla/mux # github.com/gosuri/uitable v0.0.4 github.com/gosuri/uitable @@ -371,7 +380,7 @@ github.com/jmoiron/sqlx/reflectx github.com/joelanford/ignore # github.com/josharian/intern v1.0.0 github.com/josharian/intern -# github.com/json-iterator/go v1.1.11 +# github.com/json-iterator/go v1.1.12 github.com/json-iterator/go # github.com/kisielk/errcheck v1.5.0 github.com/kisielk/errcheck @@ -400,7 +409,7 @@ github.com/mattn/go-colorable github.com/mattn/go-isatty # github.com/mattn/go-runewidth v0.0.9 github.com/mattn/go-runewidth -# github.com/mattn/go-sqlite3 v1.14.6 +# github.com/mattn/go-sqlite3 v1.14.10 github.com/mattn/go-sqlite3 # github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 github.com/matttproud/golang_protobuf_extensions/pbutil @@ -435,7 +444,7 @@ github.com/moby/term github.com/moby/term/windows # github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd github.com/modern-go/concurrent -# github.com/modern-go/reflect2 v1.0.1 +# github.com/modern-go/reflect2 v1.0.2 github.com/modern-go/reflect2 # github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 github.com/monochromegane/go-gitignore @@ -449,7 +458,7 @@ github.com/nxadm/tail/ratelimiter github.com/nxadm/tail/util github.com/nxadm/tail/watch github.com/nxadm/tail/winfile -# github.com/onsi/ginkgo v1.16.4 +# github.com/onsi/ginkgo v1.16.5 ## explicit github.com/onsi/ginkgo/config github.com/onsi/ginkgo/formatter @@ -474,7 +483,7 @@ github.com/onsi/ginkgo/reporters/stenographer github.com/onsi/ginkgo/reporters/stenographer/support/go-colorable github.com/onsi/ginkgo/reporters/stenographer/support/go-isatty github.com/onsi/ginkgo/types -# github.com/onsi/gomega v1.15.0 +# github.com/onsi/gomega v1.17.0 github.com/onsi/gomega/gstruct/errors github.com/onsi/gomega/types # github.com/opencontainers/go-digest v1.0.0 @@ -501,6 +510,7 @@ github.com/openshift/client-go/config/listers/config/v1 ## explicit github.com/operator-framework/api/crds github.com/operator-framework/api/pkg/constraints +github.com/operator-framework/api/pkg/encoding github.com/operator-framework/api/pkg/lib/version github.com/operator-framework/api/pkg/manifests github.com/operator-framework/api/pkg/operators @@ -618,10 +628,11 @@ github.com/operator-framework/operator-registry/cmd/opm github.com/operator-framework/operator-registry/cmd/opm/alpha github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle github.com/operator-framework/operator-registry/cmd/opm/alpha/diff -github.com/operator-framework/operator-registry/cmd/opm/alpha/generate github.com/operator-framework/operator-registry/cmd/opm/alpha/list +github.com/operator-framework/operator-registry/cmd/opm/generate github.com/operator-framework/operator-registry/cmd/opm/index github.com/operator-framework/operator-registry/cmd/opm/init +github.com/operator-framework/operator-registry/cmd/opm/internal/util github.com/operator-framework/operator-registry/cmd/opm/migrate github.com/operator-framework/operator-registry/cmd/opm/registry github.com/operator-framework/operator-registry/cmd/opm/render @@ -674,7 +685,7 @@ github.com/prometheus/client_golang/prometheus/testutil github.com/prometheus/client_golang/prometheus/testutil/promlint # github.com/prometheus/client_model v0.2.0 github.com/prometheus/client_model/go -# github.com/prometheus/common v0.26.0 +# github.com/prometheus/common v0.28.0 github.com/prometheus/common/expfmt github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg github.com/prometheus/common/model @@ -831,7 +842,7 @@ go.starlark.net/syntax go.uber.org/atomic # go.uber.org/multierr v1.6.0 go.uber.org/multierr -# go.uber.org/zap v1.19.0 +# go.uber.org/zap v1.19.1 go.uber.org/zap go.uber.org/zap/buffer go.uber.org/zap/internal/bufferpool @@ -839,7 +850,7 @@ go.uber.org/zap/internal/color go.uber.org/zap/internal/exit go.uber.org/zap/zapcore go.uber.org/zap/zapgrpc -# golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a +# golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 golang.org/x/crypto/bcrypt golang.org/x/crypto/blowfish golang.org/x/crypto/cast5 @@ -870,7 +881,7 @@ golang.org/x/mod/internal/lazyregexp golang.org/x/mod/modfile golang.org/x/mod/module golang.org/x/mod/semver -# golang.org/x/net v0.0.0-20210825183410-e898025ed96a +# golang.org/x/net v0.0.0-20211209124913-491a49abca63 golang.org/x/net/context golang.org/x/net/context/ctxhttp golang.org/x/net/http/httpguts @@ -883,8 +894,9 @@ golang.org/x/net/internal/timeseries golang.org/x/net/proxy golang.org/x/net/trace golang.org/x/net/websocket -# golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602 +# golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f golang.org/x/oauth2 +golang.org/x/oauth2/authhandler golang.org/x/oauth2/google golang.org/x/oauth2/google/internal/externalaccount golang.org/x/oauth2/internal @@ -894,14 +906,14 @@ golang.org/x/oauth2/jwt golang.org/x/sync/errgroup golang.org/x/sync/semaphore golang.org/x/sync/singleflight -# golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e +# golang.org/x/sys v0.0.0-20211029165221-6e7872819dc8 golang.org/x/sys/cpu golang.org/x/sys/execabs golang.org/x/sys/internal/unsafeheader golang.org/x/sys/plan9 golang.org/x/sys/unix golang.org/x/sys/windows -# golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d +# golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b golang.org/x/term # golang.org/x/text v0.3.7 golang.org/x/text/encoding @@ -917,7 +929,7 @@ golang.org/x/text/unicode/norm golang.org/x/text/width # golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac golang.org/x/time/rate -# golang.org/x/tools v0.1.5 +# golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff golang.org/x/tools/go/ast/astutil golang.org/x/tools/go/ast/inspector golang.org/x/tools/go/gcexportdata @@ -1123,7 +1135,7 @@ helm.sh/helm/v3/pkg/storage helm.sh/helm/v3/pkg/storage/driver helm.sh/helm/v3/pkg/strvals helm.sh/helm/v3/pkg/time -# k8s.io/api v0.22.2 +# k8s.io/api v0.23.1 ## explicit k8s.io/api/admission/v1 k8s.io/api/admission/v1beta1 @@ -1138,6 +1150,7 @@ k8s.io/api/authentication/v1beta1 k8s.io/api/authorization/v1 k8s.io/api/authorization/v1beta1 k8s.io/api/autoscaling/v1 +k8s.io/api/autoscaling/v2 k8s.io/api/autoscaling/v2beta1 k8s.io/api/autoscaling/v2beta2 k8s.io/api/batch/v1 @@ -1154,6 +1167,7 @@ k8s.io/api/events/v1beta1 k8s.io/api/extensions/v1beta1 k8s.io/api/flowcontrol/v1alpha1 k8s.io/api/flowcontrol/v1beta1 +k8s.io/api/flowcontrol/v1beta2 k8s.io/api/imagepolicy/v1alpha1 k8s.io/api/networking/v1 k8s.io/api/networking/v1beta1 @@ -1171,7 +1185,7 @@ k8s.io/api/scheduling/v1beta1 k8s.io/api/storage/v1 k8s.io/api/storage/v1alpha1 k8s.io/api/storage/v1beta1 -# k8s.io/apiextensions-apiserver v0.22.2 +# k8s.io/apiextensions-apiserver v0.23.0 k8s.io/apiextensions-apiserver/pkg/apihelpers k8s.io/apiextensions-apiserver/pkg/apis/apiextensions k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/install @@ -1179,6 +1193,7 @@ k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1 k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1 k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation k8s.io/apiextensions-apiserver/pkg/apiserver/schema +k8s.io/apiextensions-apiserver/pkg/apiserver/schema/cel k8s.io/apiextensions-apiserver/pkg/apiserver/schema/defaulting k8s.io/apiextensions-apiserver/pkg/apiserver/schema/objectmeta k8s.io/apiextensions-apiserver/pkg/apiserver/schema/pruning @@ -1194,7 +1209,8 @@ k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensio k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1 k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1 -# k8s.io/apimachinery v0.22.2 +k8s.io/apiextensions-apiserver/third_party/forked/celopenapi/model +# k8s.io/apimachinery v0.23.1 ## explicit k8s.io/apimachinery/pkg/api/equality k8s.io/apimachinery/pkg/api/errors @@ -1256,7 +1272,7 @@ k8s.io/apimachinery/pkg/watch k8s.io/apimachinery/third_party/forked/golang/json k8s.io/apimachinery/third_party/forked/golang/netutil k8s.io/apimachinery/third_party/forked/golang/reflect -# k8s.io/apiserver v0.22.2 +# k8s.io/apiserver v0.23.0 k8s.io/apiserver/pkg/admission k8s.io/apiserver/pkg/admission/configuration k8s.io/apiserver/pkg/admission/initializer @@ -1323,6 +1339,7 @@ k8s.io/apiserver/pkg/endpoints/handlers/responsewriters k8s.io/apiserver/pkg/endpoints/metrics k8s.io/apiserver/pkg/endpoints/openapi k8s.io/apiserver/pkg/endpoints/request +k8s.io/apiserver/pkg/endpoints/responsewriter k8s.io/apiserver/pkg/endpoints/warning k8s.io/apiserver/pkg/features k8s.io/apiserver/pkg/quota/v1 @@ -1344,6 +1361,7 @@ k8s.io/apiserver/pkg/server/routes k8s.io/apiserver/pkg/server/storage k8s.io/apiserver/pkg/storage k8s.io/apiserver/pkg/storage/cacher +k8s.io/apiserver/pkg/storage/cacher/metrics k8s.io/apiserver/pkg/storage/errors k8s.io/apiserver/pkg/storage/etcd3 k8s.io/apiserver/pkg/storage/etcd3/metrics @@ -1362,11 +1380,10 @@ k8s.io/apiserver/pkg/util/apihelpers k8s.io/apiserver/pkg/util/dryrun k8s.io/apiserver/pkg/util/feature k8s.io/apiserver/pkg/util/flowcontrol -k8s.io/apiserver/pkg/util/flowcontrol/counter k8s.io/apiserver/pkg/util/flowcontrol/debug k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing +k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/eventclock k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise -k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise/lockingpromise k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/queueset k8s.io/apiserver/pkg/util/flowcontrol/format k8s.io/apiserver/pkg/util/flowcontrol/metrics @@ -1384,11 +1401,11 @@ k8s.io/apiserver/plugin/pkg/audit/truncate k8s.io/apiserver/plugin/pkg/audit/webhook k8s.io/apiserver/plugin/pkg/authenticator/token/webhook k8s.io/apiserver/plugin/pkg/authorizer/webhook -# k8s.io/cli-runtime v0.22.0 +# k8s.io/cli-runtime v0.23.1 k8s.io/cli-runtime/pkg/genericclioptions k8s.io/cli-runtime/pkg/printers k8s.io/cli-runtime/pkg/resource -# k8s.io/client-go v0.22.2 +# k8s.io/client-go v0.23.1 ## explicit k8s.io/client-go/applyconfigurations/admissionregistration/v1 k8s.io/client-go/applyconfigurations/admissionregistration/v1beta1 @@ -1397,6 +1414,7 @@ k8s.io/client-go/applyconfigurations/apps/v1 k8s.io/client-go/applyconfigurations/apps/v1beta1 k8s.io/client-go/applyconfigurations/apps/v1beta2 k8s.io/client-go/applyconfigurations/autoscaling/v1 +k8s.io/client-go/applyconfigurations/autoscaling/v2 k8s.io/client-go/applyconfigurations/autoscaling/v2beta1 k8s.io/client-go/applyconfigurations/autoscaling/v2beta2 k8s.io/client-go/applyconfigurations/batch/v1 @@ -1413,6 +1431,7 @@ k8s.io/client-go/applyconfigurations/events/v1beta1 k8s.io/client-go/applyconfigurations/extensions/v1beta1 k8s.io/client-go/applyconfigurations/flowcontrol/v1alpha1 k8s.io/client-go/applyconfigurations/flowcontrol/v1beta1 +k8s.io/client-go/applyconfigurations/flowcontrol/v1beta2 k8s.io/client-go/applyconfigurations/internal k8s.io/client-go/applyconfigurations/meta/v1 k8s.io/client-go/applyconfigurations/networking/v1 @@ -1446,6 +1465,7 @@ k8s.io/client-go/informers/apps/v1beta1 k8s.io/client-go/informers/apps/v1beta2 k8s.io/client-go/informers/autoscaling k8s.io/client-go/informers/autoscaling/v1 +k8s.io/client-go/informers/autoscaling/v2 k8s.io/client-go/informers/autoscaling/v2beta1 k8s.io/client-go/informers/autoscaling/v2beta2 k8s.io/client-go/informers/batch @@ -1470,6 +1490,7 @@ k8s.io/client-go/informers/extensions/v1beta1 k8s.io/client-go/informers/flowcontrol k8s.io/client-go/informers/flowcontrol/v1alpha1 k8s.io/client-go/informers/flowcontrol/v1beta1 +k8s.io/client-go/informers/flowcontrol/v1beta2 k8s.io/client-go/informers/internalinterfaces k8s.io/client-go/informers/networking k8s.io/client-go/informers/networking/v1 @@ -1506,6 +1527,7 @@ k8s.io/client-go/kubernetes/typed/authentication/v1beta1 k8s.io/client-go/kubernetes/typed/authorization/v1 k8s.io/client-go/kubernetes/typed/authorization/v1beta1 k8s.io/client-go/kubernetes/typed/autoscaling/v1 +k8s.io/client-go/kubernetes/typed/autoscaling/v2 k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1 k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2 k8s.io/client-go/kubernetes/typed/batch/v1 @@ -1522,6 +1544,7 @@ k8s.io/client-go/kubernetes/typed/events/v1beta1 k8s.io/client-go/kubernetes/typed/extensions/v1beta1 k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1 k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1 +k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2 k8s.io/client-go/kubernetes/typed/networking/v1 k8s.io/client-go/kubernetes/typed/networking/v1beta1 k8s.io/client-go/kubernetes/typed/node/v1 @@ -1545,6 +1568,7 @@ k8s.io/client-go/listers/apps/v1 k8s.io/client-go/listers/apps/v1beta1 k8s.io/client-go/listers/apps/v1beta2 k8s.io/client-go/listers/autoscaling/v1 +k8s.io/client-go/listers/autoscaling/v2 k8s.io/client-go/listers/autoscaling/v2beta1 k8s.io/client-go/listers/autoscaling/v2beta2 k8s.io/client-go/listers/batch/v1 @@ -1561,6 +1585,7 @@ k8s.io/client-go/listers/events/v1beta1 k8s.io/client-go/listers/extensions/v1beta1 k8s.io/client-go/listers/flowcontrol/v1alpha1 k8s.io/client-go/listers/flowcontrol/v1beta1 +k8s.io/client-go/listers/flowcontrol/v1beta2 k8s.io/client-go/listers/networking/v1 k8s.io/client-go/listers/networking/v1beta1 k8s.io/client-go/listers/node/v1 @@ -1630,7 +1655,7 @@ k8s.io/client-go/util/jsonpath k8s.io/client-go/util/keyutil k8s.io/client-go/util/retry k8s.io/client-go/util/workqueue -# k8s.io/code-generator v0.22.2 +# k8s.io/code-generator v0.23.1 ## explicit k8s.io/code-generator k8s.io/code-generator/cmd/client-gen @@ -1665,13 +1690,14 @@ k8s.io/code-generator/cmd/set-gen k8s.io/code-generator/pkg/namer k8s.io/code-generator/pkg/util k8s.io/code-generator/third_party/forked/golang/reflect -# k8s.io/component-base v0.22.2 +# k8s.io/component-base v0.23.1 k8s.io/component-base/cli/flag k8s.io/component-base/config k8s.io/component-base/config/v1alpha1 k8s.io/component-base/featuregate k8s.io/component-base/logs k8s.io/component-base/logs/datapol +k8s.io/component-base/logs/registry k8s.io/component-base/logs/sanitization k8s.io/component-base/metrics k8s.io/component-base/metrics/legacyregistry @@ -1679,7 +1705,7 @@ k8s.io/component-base/metrics/prometheus/workqueue k8s.io/component-base/metrics/testutil k8s.io/component-base/traces k8s.io/component-base/version -# k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027 +# k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c k8s.io/gengo/args k8s.io/gengo/examples/deepcopy-gen/generators k8s.io/gengo/examples/defaulter-gen/generators @@ -1692,7 +1718,7 @@ k8s.io/gengo/parser k8s.io/gengo/types # k8s.io/klog v1.0.0 k8s.io/klog -# k8s.io/klog/v2 v2.9.0 +# k8s.io/klog/v2 v2.30.0 k8s.io/klog/v2 # k8s.io/kube-aggregator v0.22.0 k8s.io/kube-aggregator/pkg/apis/apiregistration @@ -1709,16 +1735,20 @@ k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1b k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1 k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1 -# k8s.io/kube-openapi v0.0.0-20210527164424-3c818078ee3d +# k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65 ## explicit k8s.io/kube-openapi/cmd/openapi-gen k8s.io/kube-openapi/cmd/openapi-gen/args k8s.io/kube-openapi/pkg/builder +k8s.io/kube-openapi/pkg/builder3 k8s.io/kube-openapi/pkg/common k8s.io/kube-openapi/pkg/generators k8s.io/kube-openapi/pkg/generators/rules k8s.io/kube-openapi/pkg/handler +k8s.io/kube-openapi/pkg/handler3 k8s.io/kube-openapi/pkg/schemaconv +k8s.io/kube-openapi/pkg/schemamutation +k8s.io/kube-openapi/pkg/spec3 k8s.io/kube-openapi/pkg/util k8s.io/kube-openapi/pkg/util/proto k8s.io/kube-openapi/pkg/util/proto/validation @@ -1728,18 +1758,21 @@ k8s.io/kube-openapi/pkg/validation/spec k8s.io/kube-openapi/pkg/validation/strfmt k8s.io/kube-openapi/pkg/validation/strfmt/bson k8s.io/kube-openapi/pkg/validation/validate -# k8s.io/kubectl v0.22.0 +# k8s.io/kubectl v0.23.1 k8s.io/kubectl/pkg/cmd/util k8s.io/kubectl/pkg/scheme +k8s.io/kubectl/pkg/util/i18n k8s.io/kubectl/pkg/util/interrupt k8s.io/kubectl/pkg/util/openapi k8s.io/kubectl/pkg/util/openapi/validation k8s.io/kubectl/pkg/util/templates k8s.io/kubectl/pkg/util/term k8s.io/kubectl/pkg/validation -# k8s.io/utils v0.0.0-20210819203725-bdf08cb9a70a +# k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b ## explicit k8s.io/utils/buffer +k8s.io/utils/clock +k8s.io/utils/clock/testing k8s.io/utils/exec k8s.io/utils/integer k8s.io/utils/internal/third_party/forked/golang/golang-lru @@ -1749,10 +1782,10 @@ k8s.io/utils/net k8s.io/utils/path k8s.io/utils/pointer k8s.io/utils/trace -# sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.22 +# sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.25 sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client -# sigs.k8s.io/controller-runtime v0.10.0 +# sigs.k8s.io/controller-runtime v0.11.0 ## explicit sigs.k8s.io/controller-runtime sigs.k8s.io/controller-runtime/pkg/builder @@ -1774,6 +1807,7 @@ sigs.k8s.io/controller-runtime/pkg/handler sigs.k8s.io/controller-runtime/pkg/healthz sigs.k8s.io/controller-runtime/pkg/internal/controller sigs.k8s.io/controller-runtime/pkg/internal/controller/metrics +sigs.k8s.io/controller-runtime/pkg/internal/httpserver sigs.k8s.io/controller-runtime/pkg/internal/log sigs.k8s.io/controller-runtime/pkg/internal/objectutil sigs.k8s.io/controller-runtime/pkg/internal/recorder @@ -1795,7 +1829,7 @@ sigs.k8s.io/controller-runtime/pkg/webhook sigs.k8s.io/controller-runtime/pkg/webhook/admission sigs.k8s.io/controller-runtime/pkg/webhook/conversion sigs.k8s.io/controller-runtime/pkg/webhook/internal/metrics -# sigs.k8s.io/controller-tools v0.6.2 +# sigs.k8s.io/controller-tools v0.8.0 ## explicit sigs.k8s.io/controller-tools/cmd/controller-gen sigs.k8s.io/controller-tools/pkg/crd @@ -1811,7 +1845,10 @@ sigs.k8s.io/controller-tools/pkg/schemapatcher sigs.k8s.io/controller-tools/pkg/schemapatcher/internal/yaml sigs.k8s.io/controller-tools/pkg/version sigs.k8s.io/controller-tools/pkg/webhook -# sigs.k8s.io/kustomize/api v0.8.11 +# sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6 +sigs.k8s.io/json +sigs.k8s.io/json/internal/golang/encoding/json +# sigs.k8s.io/kustomize/api v0.10.1 sigs.k8s.io/kustomize/api/builtins sigs.k8s.io/kustomize/api/filters/annotations sigs.k8s.io/kustomize/api/filters/fieldspec @@ -1855,7 +1892,7 @@ sigs.k8s.io/kustomize/api/provider sigs.k8s.io/kustomize/api/resmap sigs.k8s.io/kustomize/api/resource sigs.k8s.io/kustomize/api/types -# sigs.k8s.io/kustomize/kyaml v0.11.0 +# sigs.k8s.io/kustomize/kyaml v0.13.0 sigs.k8s.io/kustomize/kyaml/comments sigs.k8s.io/kustomize/kyaml/errors sigs.k8s.io/kustomize/kyaml/ext @@ -1872,11 +1909,13 @@ sigs.k8s.io/kustomize/kyaml/kio/filters sigs.k8s.io/kustomize/kyaml/kio/kioutil sigs.k8s.io/kustomize/kyaml/openapi sigs.k8s.io/kustomize/kyaml/openapi/kubernetesapi -sigs.k8s.io/kustomize/kyaml/openapi/kubernetesapi/v1204 +sigs.k8s.io/kustomize/kyaml/openapi/kubernetesapi/v1212 sigs.k8s.io/kustomize/kyaml/openapi/kustomizationapi +sigs.k8s.io/kustomize/kyaml/order sigs.k8s.io/kustomize/kyaml/resid sigs.k8s.io/kustomize/kyaml/runfn sigs.k8s.io/kustomize/kyaml/sets +sigs.k8s.io/kustomize/kyaml/sliceutil sigs.k8s.io/kustomize/kyaml/yaml sigs.k8s.io/kustomize/kyaml/yaml/internal/k8sgen/pkg/labels sigs.k8s.io/kustomize/kyaml/yaml/internal/k8sgen/pkg/selection @@ -1888,13 +1927,13 @@ sigs.k8s.io/kustomize/kyaml/yaml/merge2 sigs.k8s.io/kustomize/kyaml/yaml/merge3 sigs.k8s.io/kustomize/kyaml/yaml/schema sigs.k8s.io/kustomize/kyaml/yaml/walk -# sigs.k8s.io/structured-merge-diff/v4 v4.1.2 +# sigs.k8s.io/structured-merge-diff/v4 v4.2.0 sigs.k8s.io/structured-merge-diff/v4/fieldpath sigs.k8s.io/structured-merge-diff/v4/merge sigs.k8s.io/structured-merge-diff/v4/schema sigs.k8s.io/structured-merge-diff/v4/typed sigs.k8s.io/structured-merge-diff/v4/value -# sigs.k8s.io/yaml v1.2.0 +# sigs.k8s.io/yaml v1.3.0 sigs.k8s.io/yaml # github.com/containerd/containerd => github.com/ecordell/containerd v1.3.1-0.20200629153125-0ff1a1be2fa5 # github.com/docker/distribution => github.com/docker/distribution v0.0.0-20191216044856-a8371794149d diff --git a/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/client.go b/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/client.go index 761ac71fa8..31bf9e11fe 100644 --- a/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/client.go +++ b/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/client.go @@ -210,7 +210,7 @@ func (t *grpcTunnel) DialContext(ctx context.Context, protocol, address string) klog.V(5).Infoln("DIAL_REQ sent to proxy server") - c := &conn{stream: t.stream} + c := &conn{stream: t.stream, random: random} select { case res := <-resCh: diff --git a/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/conn.go b/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/conn.go index 4a93c69cf7..cc6e66be23 100644 --- a/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/conn.go +++ b/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/conn.go @@ -35,6 +35,7 @@ const CloseTimeout = 10 * time.Second type conn struct { stream client.ProxyService_ProxyClient connID int64 + random int64 readCh chan []byte closeCh chan string rdata []byte @@ -113,13 +114,26 @@ func (c *conn) SetWriteDeadline(t time.Time) error { // proxy service to notify remote to drop the connection. func (c *conn) Close() error { klog.V(4).Infoln("closing connection") - req := &client.Packet{ - Type: client.PacketType_CLOSE_REQ, - Payload: &client.Packet_CloseRequest{ - CloseRequest: &client.CloseRequest{ - ConnectID: c.connID, + var req *client.Packet + if c.connID != 0 { + req = &client.Packet{ + Type: client.PacketType_CLOSE_REQ, + Payload: &client.Packet_CloseRequest{ + CloseRequest: &client.CloseRequest{ + ConnectID: c.connID, + }, }, - }, + } + } else { + // Never received a DIAL response so no connection ID. + req = &client.Packet{ + Type: client.PacketType_DIAL_CLS, + Payload: &client.Packet_CloseDial{ + CloseDial: &client.CloseDial{ + Random: c.random, + }, + }, + } } klog.V(5).InfoS("[tracing] send req", "type", req.Type) diff --git a/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.pb.go b/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.pb.go index 107f2e546f..59a797df4c 100644 --- a/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.pb.go +++ b/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.pb.go @@ -47,6 +47,7 @@ const ( PacketType_CLOSE_REQ PacketType = 2 PacketType_CLOSE_RSP PacketType = 3 PacketType_DATA PacketType = 4 + PacketType_DIAL_CLS PacketType = 5 ) var PacketType_name = map[int32]string{ @@ -55,6 +56,7 @@ var PacketType_name = map[int32]string{ 2: "CLOSE_REQ", 3: "CLOSE_RSP", 4: "DATA", + 5: "DIAL_CLS", } var PacketType_value = map[string]int32{ @@ -63,6 +65,7 @@ var PacketType_value = map[string]int32{ "CLOSE_REQ": 2, "CLOSE_RSP": 3, "DATA": 4, + "DIAL_CLS": 5, } func (x PacketType) String() string { @@ -103,6 +106,7 @@ type Packet struct { // *Packet_Data // *Packet_CloseRequest // *Packet_CloseResponse + // *Packet_CloseDial Payload isPacket_Payload `protobuf_oneof:"payload"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -165,6 +169,10 @@ type Packet_CloseResponse struct { CloseResponse *CloseResponse `protobuf:"bytes,6,opt,name=closeResponse,proto3,oneof"` } +type Packet_CloseDial struct { + CloseDial *CloseDial `protobuf:"bytes,7,opt,name=closeDial,proto3,oneof"` +} + func (*Packet_DialRequest) isPacket_Payload() {} func (*Packet_DialResponse) isPacket_Payload() {} @@ -175,6 +183,8 @@ func (*Packet_CloseRequest) isPacket_Payload() {} func (*Packet_CloseResponse) isPacket_Payload() {} +func (*Packet_CloseDial) isPacket_Payload() {} + func (m *Packet) GetPayload() isPacket_Payload { if m != nil { return m.Payload @@ -217,6 +227,13 @@ func (m *Packet) GetCloseResponse() *CloseResponse { return nil } +func (m *Packet) GetCloseDial() *CloseDial { + if x, ok := m.GetPayload().(*Packet_CloseDial); ok { + return x.CloseDial + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*Packet) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -225,6 +242,7 @@ func (*Packet) XXX_OneofWrappers() []interface{} { (*Packet_Data)(nil), (*Packet_CloseRequest)(nil), (*Packet_CloseResponse)(nil), + (*Packet_CloseDial)(nil), } } @@ -433,6 +451,46 @@ func (m *CloseResponse) GetConnectID() int64 { return 0 } +type CloseDial struct { + // random id of the DialRequest + Random int64 `protobuf:"varint,1,opt,name=random,proto3" json:"random,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CloseDial) Reset() { *m = CloseDial{} } +func (m *CloseDial) String() string { return proto.CompactTextString(m) } +func (*CloseDial) ProtoMessage() {} +func (*CloseDial) Descriptor() ([]byte, []int) { + return fileDescriptor_fec4258d9ecd175d, []int{5} +} + +func (m *CloseDial) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CloseDial.Unmarshal(m, b) +} +func (m *CloseDial) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CloseDial.Marshal(b, m, deterministic) +} +func (m *CloseDial) XXX_Merge(src proto.Message) { + xxx_messageInfo_CloseDial.Merge(m, src) +} +func (m *CloseDial) XXX_Size() int { + return xxx_messageInfo_CloseDial.Size(m) +} +func (m *CloseDial) XXX_DiscardUnknown() { + xxx_messageInfo_CloseDial.DiscardUnknown(m) +} + +var xxx_messageInfo_CloseDial proto.InternalMessageInfo + +func (m *CloseDial) GetRandom() int64 { + if m != nil { + return m.Random + } + return 0 +} + type Data struct { // connectID to connect to ConnectID int64 `protobuf:"varint,1,opt,name=connectID,proto3" json:"connectID,omitempty"` @@ -449,7 +507,7 @@ func (m *Data) Reset() { *m = Data{} } func (m *Data) String() string { return proto.CompactTextString(m) } func (*Data) ProtoMessage() {} func (*Data) Descriptor() ([]byte, []int) { - return fileDescriptor_fec4258d9ecd175d, []int{5} + return fileDescriptor_fec4258d9ecd175d, []int{6} } func (m *Data) XXX_Unmarshal(b []byte) error { @@ -499,6 +557,7 @@ func init() { proto.RegisterType((*DialResponse)(nil), "DialResponse") proto.RegisterType((*CloseRequest)(nil), "CloseRequest") proto.RegisterType((*CloseResponse)(nil), "CloseResponse") + proto.RegisterType((*CloseDial)(nil), "CloseDial") proto.RegisterType((*Data)(nil), "Data") } @@ -507,37 +566,39 @@ func init() { } var fileDescriptor_fec4258d9ecd175d = []byte{ - // 472 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0xd1, 0x6e, 0x9b, 0x30, - 0x14, 0x85, 0x00, 0x49, 0xb8, 0x21, 0x15, 0xb2, 0xa6, 0x09, 0x75, 0x93, 0x5a, 0xf1, 0x14, 0x55, - 0x0b, 0x54, 0xa9, 0x34, 0xed, 0x35, 0x0d, 0xa9, 0x52, 0xa9, 0x5a, 0x99, 0xd3, 0xa7, 0xee, 0x61, - 0xf2, 0xc0, 0x9a, 0x50, 0x18, 0x66, 0xb6, 0x97, 0x8d, 0x0f, 0xda, 0x7f, 0x4e, 0x18, 0x52, 0xc8, - 0xa4, 0x6d, 0x52, 0x9f, 0xe0, 0x1c, 0xdf, 0x73, 0x7c, 0x7d, 0xae, 0x0d, 0xf3, 0x1d, 0x2b, 0x0a, - 0x9a, 0xc8, 0x6c, 0x9f, 0xc9, 0x6a, 0x9e, 0xe4, 0x19, 0x2d, 0x64, 0x58, 0x72, 0x26, 0x59, 0xd8, - 0x82, 0xe6, 0x13, 0x28, 0xce, 0xff, 0x35, 0x80, 0x61, 0x4c, 0x92, 0x1d, 0x95, 0xe8, 0x0c, 0x4c, - 0x59, 0x95, 0xd4, 0xd3, 0xcf, 0xf5, 0xd9, 0xc9, 0x62, 0x12, 0x34, 0xf4, 0x43, 0x55, 0x52, 0xac, - 0x16, 0xd0, 0x25, 0x4c, 0xd2, 0x8c, 0xe4, 0x98, 0x7e, 0xfb, 0x4e, 0x85, 0xf4, 0x06, 0xe7, 0xfa, - 0x6c, 0xb2, 0x70, 0x82, 0xa8, 0xe3, 0x36, 0x1a, 0xee, 0x97, 0xa0, 0x2b, 0x70, 0x1a, 0x28, 0x4a, - 0x56, 0x08, 0xea, 0x19, 0x4a, 0x32, 0x6d, 0x25, 0x0d, 0xb9, 0xd1, 0xf0, 0x51, 0x11, 0x7a, 0x05, - 0x66, 0x4a, 0x24, 0xf1, 0x4c, 0x55, 0x6c, 0x05, 0x11, 0x91, 0x64, 0xa3, 0x61, 0x45, 0xd6, 0x8e, - 0x49, 0xce, 0x04, 0x3d, 0x34, 0x61, 0xb5, 0x8e, 0xab, 0x1e, 0x59, 0x3b, 0xf6, 0x8b, 0xd0, 0x5b, - 0x98, 0xb6, 0xb8, 0xed, 0x63, 0xa8, 0x54, 0x27, 0x07, 0xd5, 0x53, 0x23, 0xc7, 0x65, 0xd7, 0x36, - 0x8c, 0x4a, 0x52, 0xe5, 0x8c, 0xa4, 0xfe, 0x47, 0x98, 0xf4, 0xce, 0x89, 0x4e, 0x61, 0xac, 0xf2, - 0x4b, 0x58, 0xae, 0xf2, 0xb2, 0xf1, 0x13, 0x46, 0x1e, 0x8c, 0x48, 0x9a, 0x72, 0x2a, 0x84, 0x8a, - 0xc8, 0xc6, 0x07, 0x88, 0x5e, 0xc2, 0x90, 0x93, 0x22, 0x65, 0x5f, 0x55, 0x10, 0x06, 0x6e, 0x91, - 0xff, 0x08, 0x4e, 0x3f, 0x11, 0xf4, 0x02, 0x2c, 0xca, 0x39, 0xe3, 0xad, 0x75, 0x03, 0xd0, 0x6b, - 0xb0, 0x93, 0x66, 0xb6, 0xb7, 0x91, 0x72, 0x36, 0x70, 0x47, 0xfc, 0xd5, 0xfb, 0x0d, 0x38, 0xfd, - 0x6c, 0x8e, 0x5d, 0xf4, 0x3f, 0x5c, 0xfc, 0x15, 0x4c, 0x8f, 0x32, 0x79, 0x4e, 0x2b, 0xfe, 0x7b, - 0x30, 0xeb, 0x99, 0xfd, 0x7b, 0xab, 0xce, 0x79, 0xd0, 0x77, 0x46, 0xed, 0xf0, 0xeb, 0x43, 0x38, - 0xcd, 0xcc, 0x2f, 0x62, 0x80, 0xee, 0x2e, 0x22, 0x07, 0xc6, 0xd1, 0xed, 0xf2, 0xee, 0x13, 0x5e, - 0x7f, 0x70, 0xb5, 0x0e, 0x6d, 0x63, 0x57, 0x47, 0x53, 0xb0, 0x57, 0x77, 0xf7, 0xdb, 0xb5, 0x5a, - 0x1c, 0xf4, 0xe0, 0x36, 0x76, 0x0d, 0x34, 0x06, 0x33, 0x5a, 0x3e, 0x2c, 0x5d, 0xf3, 0xc2, 0x05, - 0x6b, 0xad, 0xb6, 0x1b, 0x81, 0xb1, 0xbe, 0xbf, 0x71, 0xb5, 0x45, 0x08, 0x4e, 0xcc, 0xd9, 0xcf, - 0x6a, 0x4b, 0xf9, 0x3e, 0x4b, 0x28, 0x3a, 0x03, 0x4b, 0x61, 0x34, 0x6a, 0xdf, 0xc1, 0xe9, 0xe1, - 0xc7, 0xd7, 0x66, 0xfa, 0xa5, 0x7e, 0x7d, 0xf3, 0x18, 0x89, 0xec, 0x8b, 0x08, 0x76, 0xef, 0x44, - 0x90, 0xb1, 0x90, 0x94, 0x99, 0xa0, 0x7c, 0x4f, 0xf9, 0xbc, 0xa0, 0xf2, 0x07, 0xe3, 0xbb, 0x79, - 0x59, 0xcb, 0xc3, 0xff, 0xbd, 0xc6, 0xcf, 0x43, 0x85, 0xae, 0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, - 0x64, 0xe0, 0x62, 0xbe, 0xb8, 0x03, 0x00, 0x00, + // 505 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0x51, 0x8b, 0xd3, 0x40, + 0x18, 0x4c, 0xda, 0xa4, 0x6d, 0xbe, 0xa6, 0x47, 0x58, 0x44, 0xc2, 0x29, 0xdc, 0x11, 0x5f, 0x4a, + 0xb1, 0xe9, 0xd1, 0x03, 0xf1, 0xb5, 0xd7, 0xf4, 0xe8, 0x41, 0xf1, 0xea, 0xf6, 0x9e, 0x4e, 0x50, + 0xd6, 0x64, 0x91, 0xd0, 0x98, 0x8d, 0xbb, 0x6b, 0x35, 0x3f, 0xd3, 0x7f, 0x24, 0xd9, 0xa4, 0x4d, + 0x22, 0xa8, 0x70, 0x4f, 0xed, 0xcc, 0x7e, 0x33, 0x3b, 0x19, 0xbe, 0x85, 0xe9, 0x9e, 0xa5, 0x29, + 0x0d, 0x65, 0x7c, 0x88, 0x65, 0x3e, 0x0d, 0x93, 0x98, 0xa6, 0x72, 0x96, 0x71, 0x26, 0xd9, 0xac, + 0x02, 0xe5, 0x8f, 0xaf, 0x38, 0xef, 0x57, 0x07, 0x7a, 0x5b, 0x12, 0xee, 0xa9, 0x44, 0x17, 0x60, + 0xc8, 0x3c, 0xa3, 0xae, 0x7e, 0xa9, 0x8f, 0xcf, 0xe6, 0x43, 0xbf, 0xa4, 0x1f, 0xf2, 0x8c, 0x62, + 0x75, 0x80, 0xae, 0x60, 0x18, 0xc5, 0x24, 0xc1, 0xf4, 0xdb, 0x77, 0x2a, 0xa4, 0xdb, 0xb9, 0xd4, + 0xc7, 0xc3, 0xb9, 0xed, 0x07, 0x35, 0xb7, 0xd6, 0x70, 0x73, 0x04, 0x5d, 0x83, 0x5d, 0x42, 0x91, + 0xb1, 0x54, 0x50, 0xb7, 0xab, 0x24, 0xa3, 0x4a, 0x52, 0x92, 0x6b, 0x0d, 0xb7, 0x86, 0xd0, 0x0b, + 0x30, 0x22, 0x22, 0x89, 0x6b, 0xa8, 0x61, 0xd3, 0x0f, 0x88, 0x24, 0x6b, 0x0d, 0x2b, 0xb2, 0x70, + 0x0c, 0x13, 0x26, 0xe8, 0x31, 0x84, 0x59, 0x39, 0x2e, 0x1b, 0x64, 0xe1, 0xd8, 0x1c, 0x42, 0x6f, + 0x60, 0x54, 0xe1, 0x2a, 0x47, 0x4f, 0xa9, 0xce, 0x8e, 0xaa, 0x53, 0x90, 0xf6, 0x18, 0x9a, 0x80, + 0xa5, 0x88, 0x22, 0xae, 0xdb, 0x57, 0x1a, 0x28, 0x35, 0x05, 0xb3, 0xd6, 0x70, 0x7d, 0x7c, 0x63, + 0x41, 0x3f, 0x23, 0x79, 0xc2, 0x48, 0xe4, 0x7d, 0x80, 0x61, 0xa3, 0x13, 0x74, 0x0e, 0x03, 0xd5, + 0x75, 0xc8, 0x12, 0xd5, 0xad, 0x85, 0x4f, 0x18, 0xb9, 0xd0, 0x27, 0x51, 0xc4, 0xa9, 0x10, 0xaa, + 0x4e, 0x0b, 0x1f, 0x21, 0x7a, 0x0e, 0x3d, 0x4e, 0xd2, 0x88, 0x7d, 0x55, 0xa5, 0x75, 0x71, 0x85, + 0xbc, 0x47, 0xb0, 0x9b, 0xed, 0xa1, 0x67, 0x60, 0x52, 0xce, 0x19, 0xaf, 0xac, 0x4b, 0x80, 0x5e, + 0x82, 0x15, 0x96, 0x7b, 0x70, 0x17, 0x28, 0xe7, 0x2e, 0xae, 0x89, 0xbf, 0x7a, 0xbf, 0x06, 0xbb, + 0xd9, 0x63, 0xdb, 0x45, 0xff, 0xc3, 0xc5, 0x5b, 0xc2, 0xa8, 0xd5, 0xdf, 0x53, 0xa2, 0x78, 0xaf, + 0xc0, 0x3a, 0x15, 0xda, 0xc8, 0xa5, 0xb7, 0x72, 0xbd, 0x03, 0xa3, 0x58, 0x82, 0x7f, 0xe7, 0xa9, + 0xaf, 0xef, 0x34, 0xaf, 0x47, 0xd5, 0x36, 0x15, 0x5f, 0x6a, 0x97, 0x4b, 0x34, 0xf9, 0x08, 0x50, + 0x2f, 0x37, 0xb2, 0x61, 0x10, 0xdc, 0x2d, 0x36, 0x9f, 0xf0, 0xea, 0xbd, 0xa3, 0xd5, 0x68, 0xb7, + 0x75, 0x74, 0x34, 0x02, 0x6b, 0xb9, 0xb9, 0xdf, 0xad, 0xd4, 0x61, 0xa7, 0x01, 0x77, 0x5b, 0xa7, + 0x8b, 0x06, 0x60, 0x04, 0x8b, 0x87, 0x85, 0x63, 0x9c, 0x54, 0xcb, 0xcd, 0xce, 0x31, 0x27, 0x0e, + 0x98, 0x2b, 0x75, 0x79, 0x1f, 0xba, 0xab, 0xfb, 0x5b, 0x47, 0x9b, 0xcf, 0xc0, 0xde, 0x72, 0xf6, + 0x33, 0xdf, 0x51, 0x7e, 0x88, 0x43, 0x8a, 0x2e, 0xc0, 0x54, 0x18, 0xf5, 0xab, 0x67, 0x76, 0x7e, + 0xfc, 0xe3, 0x69, 0x63, 0xfd, 0x4a, 0xbf, 0xb9, 0x7d, 0x0c, 0x44, 0xfc, 0x45, 0xf8, 0xfb, 0xb7, + 0xc2, 0x8f, 0xd9, 0x8c, 0x64, 0xb1, 0xa0, 0xfc, 0x40, 0xf9, 0x34, 0xa5, 0xf2, 0x07, 0xe3, 0xfb, + 0x69, 0x56, 0xc8, 0x67, 0xff, 0x7b, 0xec, 0x9f, 0x7b, 0x0a, 0x5d, 0xff, 0x0e, 0x00, 0x00, 0xff, + 0xff, 0x38, 0x1b, 0xf6, 0x4f, 0x17, 0x04, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.proto b/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.proto index 3aadac0642..0c4cff8cd2 100644 --- a/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.proto +++ b/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.proto @@ -29,6 +29,7 @@ enum PacketType { CLOSE_REQ = 2; CLOSE_RSP = 3; DATA = 4; + DIAL_CLS = 5; } enum Error { @@ -45,6 +46,7 @@ message Packet { Data data = 4; CloseRequest closeRequest = 5; CloseResponse closeResponse = 6; + CloseDial closeDial = 7; } } @@ -83,6 +85,11 @@ message CloseResponse { int64 connectID = 2; } +message CloseDial { + // random id of the DialRequest + int64 random = 1; +} + message Data { // connectID to connect to int64 connectID = 1; diff --git a/vendor/sigs.k8s.io/controller-runtime/.golangci.yml b/vendor/sigs.k8s.io/controller-runtime/.golangci.yml index a5a5dad615..9ca3fd9270 100644 --- a/vendor/sigs.k8s.io/controller-runtime/.golangci.yml +++ b/vendor/sigs.k8s.io/controller-runtime/.golangci.yml @@ -59,9 +59,9 @@ linters-settings: - pkg: sigs.k8s.io/controller-runtime alias: ctrl staticcheck: - go: "1.16" + go: "1.17" stylecheck: - go: "1.16" + go: "1.17" issues: max-same-issues: 0 diff --git a/vendor/sigs.k8s.io/controller-runtime/go.mod b/vendor/sigs.k8s.io/controller-runtime/go.mod index 53596f3b14..c843d2031f 100644 --- a/vendor/sigs.k8s.io/controller-runtime/go.mod +++ b/vendor/sigs.k8s.io/controller-runtime/go.mod @@ -1,28 +1,66 @@ module sigs.k8s.io/controller-runtime -go 1.16 +go 1.17 require ( - github.com/evanphx/json-patch v4.11.0+incompatible - github.com/fsnotify/fsnotify v1.4.9 - github.com/go-logr/logr v0.4.0 - github.com/go-logr/zapr v0.4.0 - github.com/imdario/mergo v0.3.12 // indirect - github.com/onsi/ginkgo v1.16.4 - github.com/onsi/gomega v1.15.0 + github.com/evanphx/json-patch v4.12.0+incompatible + github.com/fsnotify/fsnotify v1.5.1 + github.com/go-logr/logr v1.2.0 + github.com/go-logr/zapr v1.2.0 + github.com/onsi/ginkgo v1.16.5 + github.com/onsi/gomega v1.17.0 github.com/prometheus/client_golang v1.11.0 github.com/prometheus/client_model v0.2.0 - go.uber.org/goleak v1.1.10 - go.uber.org/zap v1.19.0 - golang.org/x/sys v0.0.0-20210817190340-bfb29a6856f2 + go.uber.org/goleak v1.1.12 + go.uber.org/zap v1.19.1 + golang.org/x/sys v0.0.0-20211029165221-6e7872819dc8 golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac gomodules.xyz/jsonpatch/v2 v2.2.0 + k8s.io/api v0.23.0 + k8s.io/apiextensions-apiserver v0.23.0 + k8s.io/apimachinery v0.23.0 + k8s.io/client-go v0.23.0 + k8s.io/component-base v0.23.0 + k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b + sigs.k8s.io/yaml v1.3.0 +) + +require ( + cloud.google.com/go v0.81.0 // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/cespare/xxhash/v2 v2.1.1 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/golang/protobuf v1.5.2 // indirect + github.com/google/go-cmp v0.5.5 // indirect + github.com/google/gofuzz v1.1.0 // indirect + github.com/google/uuid v1.1.2 // indirect + github.com/googleapis/gnostic v0.5.5 // indirect + github.com/imdario/mergo v0.3.12 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/nxadm/tail v1.4.8 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/prometheus/common v0.28.0 // indirect + github.com/prometheus/procfs v0.6.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + go.uber.org/atomic v1.7.0 // indirect + go.uber.org/multierr v1.6.0 // indirect + golang.org/x/net v0.0.0-20210825183410-e898025ed96a // indirect + golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f // indirect + golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect + golang.org/x/text v0.3.7 // indirect google.golang.org/appengine v1.6.7 // indirect - k8s.io/api v0.22.1 - k8s.io/apiextensions-apiserver v0.22.1 - k8s.io/apimachinery v0.22.1 - k8s.io/client-go v0.22.1 - k8s.io/component-base v0.22.1 - k8s.io/utils v0.0.0-20210802155522-efc7438f0176 - sigs.k8s.io/yaml v1.2.0 + google.golang.org/protobuf v1.27.1 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect + gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect + k8s.io/klog/v2 v2.30.0 // indirect + k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65 // indirect + sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6 // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.2.0 // indirect ) diff --git a/vendor/sigs.k8s.io/controller-runtime/go.sum b/vendor/sigs.k8s.io/controller-runtime/go.sum index 82d98e7e53..1872ab8ce0 100644 --- a/vendor/sigs.k8s.io/controller-runtime/go.sum +++ b/vendor/sigs.k8s.io/controller-runtime/go.sum @@ -8,20 +8,35 @@ cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= -cloud.google.com/go v0.54.0 h1:3ithwDMr7/3vpAMXiH+ZQnYbuIsh+OPhUPMFC9enmn0= cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= +cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= +cloud.google.com/go v0.81.0 h1:at8Tk2zUz63cLPR0JPWm5vp77pEZmzxEQBEfRKn1VV8= +cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= +cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= github.com/Azure/go-ansiterm v0.0.0-20210608223527-2377c96fe795/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8= github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= @@ -45,6 +60,7 @@ github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRF github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e/go.mod h1:F7bn7fEU90QkQ3tnmaTx3LTKLEDqnwWODIYppRQ5hnY= github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= @@ -58,6 +74,7 @@ github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84= +github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM= github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/certifi/gocertifi v0.0.0-20191021191039-0944d244cd40/go.mod h1:sGbDF6GwGcLpkNXPUTkMRoywsNa/ol15pxFe6ERfguA= @@ -71,7 +88,9 @@ github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5P github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cockroachdb/datadriven v0.0.0-20200714090401-bf6692d28da5/go.mod h1:h6jFvWxBdQXxjopDMZyH2UVceIRfR84bdzbkoKrsWNo= github.com/cockroachdb/errors v1.2.4/go.mod h1:rQD95gz6FARkaKkQXUksEje/d9a6wBJoCr5oaCLELYA= github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= @@ -98,19 +117,23 @@ github.com/emicklei/go-restful v2.9.5+incompatible/go.mod h1:otzb+WCGbkyDHkqmQmT github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= +github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/evanphx/json-patch v0.5.2/go.mod h1:ZWS5hhDbVDyob71nXKNL0+PWn6ToqBHMikGIFbs31qQ= -github.com/evanphx/json-patch v4.11.0+incompatible h1:glyUF9yIYtMHzn8xaKw5rMhdWcwsYV8dZHIq5567/xs= -github.com/evanphx/json-patch v4.11.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= +github.com/evanphx/json-patch v4.12.0+incompatible h1:4onqiflcdA9EOZ4RxV643DvftH5pOlLGNtQ5lPWQu84= +github.com/evanphx/json-patch v4.12.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/form3tech-oss/jwt-go v3.2.2+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k= github.com/form3tech-oss/jwt-go v3.2.3+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWpgI= +github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU= +github.com/getkin/kin-openapi v0.76.0/go.mod h1:660oXbgy5JFMKreazJaQTw7o+X00qeSyhcnluiMv+Xg= github.com/getsentry/raven-go v0.2.0/go.mod h1:KungGk8q33+aIAZUIVWZDr2OfAEBsO49PX4NzFV5kcQ= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= @@ -124,10 +147,10 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas= github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= -github.com/go-logr/logr v0.4.0 h1:K7/B1jt6fIBQVd4Owv2MqGQClcgf0R266+7C/QjRcLc= -github.com/go-logr/logr v0.4.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= -github.com/go-logr/zapr v0.4.0 h1:uc1uML3hRYL9/ZZPdgHS/n8Nzo+eaYL/Efxkkamf7OM= -github.com/go-logr/zapr v0.4.0/go.mod h1:tabnROwaDl0UNxkVeFRbY8bwB37GwRv0P8lg6aAiEnk= +github.com/go-logr/logr v1.2.0 h1:QK40JKJyMdUDz+h+xvCsru/bJhvG0UxvePV0ufL/AcE= +github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/zapr v1.2.0 h1:n4JnPI1T3Qq1SFEi/F8rwLrZERp2bso19PJZDB9dayk= +github.com/go-logr/zapr v1.2.0/go.mod h1:Qa4Bsj2Vb+FAVeAKsLD8RLQ+YRJB8YDmOAKxaBQf7Ro= github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= github.com/go-openapi/jsonreference v0.19.3/go.mod h1:rjx6GuL8TTa9VaixXglHmQmIL98+wF9xc8zWvFonSJ8= @@ -143,6 +166,7 @@ github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXP github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -154,11 +178,15 @@ github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfb github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= @@ -174,11 +202,17 @@ github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiu github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.1/go.mod h1:xXMiIv4Fb/0kKde4SpL7qlzvu5cMJDRkFDxJfI9uaxA= +github.com/google/cel-go v0.9.0/go.mod h1:U7ayypeSkw23szu4GaQTPJGx66c20mx8JklMSxrmI1w= +github.com/google/cel-spec v0.6.0/go.mod h1:Nwjgxy5CbjlPrtCWjeDjUyKMl8w41YBYGjsyDdqk0xA= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= @@ -186,13 +220,20 @@ github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/ github.com/google/gofuzz v1.1.0 h1:Hsa8mG0dQ46ij8Sl2AYJDUv1oA9/d6Vk+3LG99Oe02g= github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= @@ -201,6 +242,7 @@ github.com/googleapis/gnostic v0.5.1/go.mod h1:6U4PtQXGIEt/Z3h5MAT7FNofLnw9vXk2c github.com/googleapis/gnostic v0.5.5 h1:9fHAtK0uDfpveeqqo1hkEZJcFvYXAiCN3UutL8F9xHw= github.com/googleapis/gnostic v0.5.5/go.mod h1:7+EbHbldMins07ALC74bsA81Ovc97DwqyJO1AENw9kA= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA= github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= @@ -230,6 +272,7 @@ github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2p github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= github.com/imdario/mergo v0.3.12 h1:b6R2BslTbIEToALKP7LxUvijTsNI9TAe80pLWN2g/HU= github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA= @@ -241,8 +284,9 @@ github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFF github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/json-iterator/go v1.1.11 h1:uVUAXhF2To8cbw/3xN3pxj6kk7TYKs98NIrTqPlMWAQ= github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= @@ -254,6 +298,7 @@ github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= @@ -262,6 +307,7 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mailru/easyjson v0.7.6/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= @@ -279,14 +325,16 @@ github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS4 github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY= github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/moby/spdystream v0.2.0/go.mod h1:f7i0iNDQJ059oMTcWxx8MA/zKFIuD/lY+0GqbN2Wy8c= github.com/moby/term v0.0.0-20210610120745-9d4ed1856297/go.mod h1:vgPCkQMyxTZ7IDy8SXRufE172gr8+K/JE/7hHFxHW3A= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= @@ -302,21 +350,24 @@ github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= -github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= +github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= +github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= -github.com/onsi/gomega v1.15.0 h1:WjP/FQ/sk43MRmnEcT+MlDw2TFvkrXlprrPST/IudjU= -github.com/onsi/gomega v1.15.0/go.mod h1:cIuvLEne0aoVhAgh/O6ac0Op8WWw9H6eYCriF+tEHG0= +github.com/onsi/gomega v1.17.0 h1:9Luw4uT5HTjHTN8+aNcSThgH1vdXnmdJ8xIfZ4wyTRE= +github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= +github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= @@ -336,8 +387,9 @@ github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7q github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= -github.com/prometheus/common v0.26.0 h1:iMAkS2TDoNWnKM+Kopnx/8tnEStIfpYA0ur0xQzzhMQ= github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= +github.com/prometheus/common v0.28.0 h1:vGVfV9KrDTvWt5boZO0I19g2E3CsWfpPPKZM9dt3mEw= +github.com/prometheus/common v0.28.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= @@ -364,14 +416,18 @@ github.com/soheilhy/cmux v0.1.5/go.mod h1:T7TcVDs9LWfQgPlPsdngu6I6QIoyIFZDDC6sNE github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk= +github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cobra v1.1.3/go.mod h1:pGADOWyqRD/YMrPZigI/zbliZ2wVD/23d+is3pSWzOo= +github.com/spf13/cobra v1.2.1/go.mod h1:ExllRjgxM/piMAM+3tAZvg8fsklGAf3tPfi+i8t68Nk= github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= -github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= +github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns= github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -386,9 +442,12 @@ github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tmc/grpc-websocket-proxy v0.0.0-20201229170055-e5319fda7802/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= +github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4= go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= @@ -402,6 +461,9 @@ go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= +go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= go.opentelemetry.io/contrib v0.20.0/go.mod h1:G/EtFaa6qaN7+LxqfIAT3GiZa7Wv5DTBUzl5H4LY0Kc= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.20.0/go.mod h1:oVGt1LRbBOBq1A5BQLlUg9UaU/54aiHw8cgjV3aWZ/E= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.20.0/go.mod h1:2AboqHi0CiIZU0qwhtUfCYD1GeUzvvIXWNkhDt7ZMG4= @@ -417,24 +479,28 @@ go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqe go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/goleak v1.1.10 h1:z+mqJhf6ss6BSfSM671tgKyZBFPTTJM+HLxnhPC3wu0= go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/goleak v1.1.12 h1:gZAh5/EyT/HQwlpkCy6wTpqfH9H8Lz8zbm3dZh+OyzA= +go.uber.org/goleak v1.1.12/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= -go.uber.org/zap v1.19.0 h1:mZQZefskPPCMIBCSEH0v2/iUqqLrYtaeqwD6FUGUnFE= go.uber.org/zap v1.19.0/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= +go.uber.org/zap v1.19.1 h1:ue41HOKd1vGURxrmeKIgELGb3jPW9DMUDGtsinblHwI= +go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= +golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -457,6 +523,7 @@ golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 h1:VLliZ0d+/avPrXXH+OakdXhpJuEoBZuwh1m2j7U6Iug= golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= @@ -467,6 +534,8 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -484,6 +553,7 @@ golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -493,27 +563,51 @@ golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= -golang.org/x/net v0.0.0-20210520170846-37e1c6afe023 h1:ADo5wSpq2gqaCGQWzk7S5vd//0iyyLeAratkEoG5dLE= -golang.org/x/net v0.0.0-20210520170846-37e1c6afe023/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210825183410-e898025ed96a h1:bRuuGXV8wwSdGTB+CtJf+FjgO1APK1CoO39T4BN/XBw= +golang.org/x/net v0.0.0-20210825183410-e898025ed96a/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BGiEpg5IG2JkU5FkPIawgtw= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f h1:Qmd2pbz05z7z6lm0DrgQVVPuBm92jqujBKMHMOlOQEw= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -548,35 +642,54 @@ golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200831180312-196b9ba8737a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210817190340-bfb29a6856f2 h1:c8PlLMqBbOHoqtjteWm5/kbe6rNY2pbRfbIMVnepueo= -golang.org/x/sys v0.0.0-20210817190340-bfb29a6856f2/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211029165221-6e7872819dc8 h1:M69LAlWZCshgp0QSzyDcSsSIejIEeuaCVpmwcKwyLMk= +golang.org/x/sys v0.0.0-20211029165221-6e7872819dc8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE= -golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE= +golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -618,13 +731,31 @@ golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapK golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200505023115-26f46d2f7ef8/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.2 h1:kRBLX7v7Af8W7Gdbbc908OJcdgtK8bOz9Uaj8/F1ACA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff h1:VX/uD7MK0AHXGiScH3fsieUQUcpmRERPDYtqZdJnA+Q= +golang.org/x/tools v0.1.6-0.20210820212750-d4cc65f0b2ff/go.mod h1:YD9qOF0M9xpSpdWTBbzEl5e/RnCefISl8E5Noe10jFM= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -641,12 +772,25 @@ google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsb google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= +google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= +google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= +google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= +google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= +google.golang.org/api v0.44.0/go.mod h1:EBOGZqzyhtvMDoxwS97ctnh0zUmYY6CxqXsc1AvkYD8= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c= google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= @@ -666,12 +810,34 @@ google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvx google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= +google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201019141844-1ed22bb0c154/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201102152239-715cce707fb0/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= @@ -680,11 +846,20 @@ google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQ google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= +google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -696,8 +871,9 @@ google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpAD google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= @@ -709,6 +885,7 @@ gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMy gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= gopkg.in/square/go-jose.v2 v2.2.2/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI= @@ -736,35 +913,39 @@ honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWh honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -k8s.io/api v0.22.1 h1:ISu3tD/jRhYfSW8jI/Q1e+lRxkR7w9UwQEZ7FgslrwY= -k8s.io/api v0.22.1/go.mod h1:bh13rkTp3F1XEaLGykbyRD2QaTTzPm0e/BMd8ptFONY= -k8s.io/apiextensions-apiserver v0.22.1 h1:YSJYzlFNFSfUle+yeEXX0lSQyLEoxoPJySRupepb0gE= -k8s.io/apiextensions-apiserver v0.22.1/go.mod h1:HeGmorjtRmRLE+Q8dJu6AYRoZccvCMsghwS8XTUYb2c= -k8s.io/apimachinery v0.22.1 h1:DTARnyzmdHMz7bFWFDDm22AM4pLWTQECMpRTFu2d2OM= -k8s.io/apimachinery v0.22.1/go.mod h1:O3oNtNadZdeOMxHFVxOreoznohCpy0z6mocxbZr7oJ0= -k8s.io/apiserver v0.22.1/go.mod h1:2mcM6dzSt+XndzVQJX21Gx0/Klo7Aen7i0Ai6tIa400= -k8s.io/client-go v0.22.1 h1:jW0ZSHi8wW260FvcXHkIa0NLxFBQszTlhiAVsU5mopw= -k8s.io/client-go v0.22.1/go.mod h1:BquC5A4UOo4qVDUtoc04/+Nxp1MeHcVc1HJm1KmG8kk= -k8s.io/code-generator v0.22.1/go.mod h1:eV77Y09IopzeXOJzndrDyCI88UBok2h6WxAlBwpxa+o= -k8s.io/component-base v0.22.1 h1:SFqIXsEN3v3Kkr1bS6rstrs1wd45StJqbtgbQ4nRQdo= -k8s.io/component-base v0.22.1/go.mod h1:0D+Bl8rrnsPN9v0dyYvkqFfBeAd4u7n77ze+p8CMiPo= -k8s.io/gengo v0.0.0-20200413195148-3a45101e95ac/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= -k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +k8s.io/api v0.23.0 h1:WrL1gb73VSC8obi8cuYETJGXEoFNEh3LU0Pt+Sokgro= +k8s.io/api v0.23.0/go.mod h1:8wmDdLBHBNxtOIytwLstXt5E9PddnZb0GaMcqsvDBpg= +k8s.io/apiextensions-apiserver v0.23.0 h1:uii8BYmHYiT2ZTAJxmvc3X8UhNYMxl2A0z0Xq3Pm+WY= +k8s.io/apiextensions-apiserver v0.23.0/go.mod h1:xIFAEEDlAZgpVBl/1VSjGDmLoXAWRG40+GsWhKhAxY4= +k8s.io/apimachinery v0.23.0 h1:mIfWRMjBuMdolAWJ3Fd+aPTMv3X9z+waiARMpvvb0HQ= +k8s.io/apimachinery v0.23.0/go.mod h1:fFCTTBKvKcwTPFzjlcxp91uPFZr+JA0FubU4fLzzFYc= +k8s.io/apiserver v0.23.0/go.mod h1:Cec35u/9zAepDPPFyT+UMrgqOCjgJ5qtfVJDxjZYmt4= +k8s.io/client-go v0.23.0 h1:vcsOqyPq7XV3QmQRCBH/t9BICJM9Q1M18qahjv+rebY= +k8s.io/client-go v0.23.0/go.mod h1:hrDnpnK1mSr65lHHcUuIZIXDgEbzc7/683c6hyG4jTA= +k8s.io/code-generator v0.23.0/go.mod h1:vQvOhDXhuzqiVfM/YHp+dmg10WDZCchJVObc9MvowsE= +k8s.io/component-base v0.23.0 h1:UAnyzjvVZ2ZR1lF35YwtNY6VMN94WtOnArcXBu34es8= +k8s.io/component-base v0.23.0/go.mod h1:DHH5uiFvLC1edCpvcTDV++NKULdYYU6pR9Tt3HIKMKI= +k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E= k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE= k8s.io/klog/v2 v2.2.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y= -k8s.io/klog/v2 v2.9.0 h1:D7HV+n1V57XeZ0m6tdRkfknthUaM06VFbWldOFh8kzM= -k8s.io/klog/v2 v2.9.0/go.mod h1:hy9LJ/NvuK+iVyP4Ehqva4HxZG/oXyIS3n3Jmire4Ec= -k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e h1:KLHHjkdQFomZy8+06csTWZ0m1343QqxZhR2LJ1OxCYM= -k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e/go.mod h1:vHXdDvt9+2spS2Rx9ql3I8tycm3H9FDfdUoIuKCefvw= -k8s.io/utils v0.0.0-20210707171843-4b05e18ac7d9/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= -k8s.io/utils v0.0.0-20210802155522-efc7438f0176 h1:Mx0aa+SUAcNRQbs5jUzV8lkDlGFU8laZsY9jrcVX5SY= +k8s.io/klog/v2 v2.30.0 h1:bUO6drIvCIsvZ/XFgfxoGFQU/a4Qkh0iAlvUR7vlHJw= +k8s.io/klog/v2 v2.30.0/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= +k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65 h1:E3J9oCLlaobFUqsjG9DfKbP2BmgwBL2p7pn0A3dG9W4= +k8s.io/kube-openapi v0.0.0-20211115234752-e816edb12b65/go.mod h1:sX9MT8g7NVZM5lVL/j8QyCCJe8YSMW30QvGZWaCIDIk= k8s.io/utils v0.0.0-20210802155522-efc7438f0176/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= +k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b h1:wxEMGetGMur3J1xuGLQY7GEQYg9bZxKn3tKo5k/eYcs= +k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= -sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.22/go.mod h1:LEScyzhFmoF5pso/YSeBstl57mOzx9xlU9n85RGrDQg= +sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.25/go.mod h1:Mlj9PNLmG9bZ6BHFwFKDo5afkpWyUISkb9Me0GnK66I= +sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6 h1:fD1pz4yfdADVNfFmcP2aBEtudwUQ1AlLnRBALr33v3s= +sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6/go.mod h1:p4QtZmO4uMYipTQNzagwnNoseA6OxSUutVw05NhYDRs= sigs.k8s.io/structured-merge-diff/v4 v4.0.2/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw= -sigs.k8s.io/structured-merge-diff/v4 v4.1.2 h1:Hr/htKFmJEbtMgS/UD0N+gtgctAqz81t3nu+sPzynno= sigs.k8s.io/structured-merge-diff/v4 v4.1.2/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4= -sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q= +sigs.k8s.io/structured-merge-diff/v4 v4.2.0 h1:kDvPBbnPk+qYmkHmSo8vKGp438IASWofnbbUKDE/bv0= +sigs.k8s.io/structured-merge-diff/v4 v4.2.0/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4= sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc= +sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= +sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/builder/controller.go b/vendor/sigs.k8s.io/controller-runtime/pkg/builder/controller.go index 2cd4ce9de1..9a74d6ec9a 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/builder/controller.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/builder/controller.go @@ -305,7 +305,7 @@ func (blder *Builder) doController(r reconcile.Reconciler) error { } // Setup the logger. - if ctrlOptions.Log == nil { + if ctrlOptions.Log.GetSink() == nil { ctrlOptions.Log = blder.mgr.GetLogger() } ctrlOptions.Log = ctrlOptions.Log.WithValues("reconciler group", gvk.Group, "reconciler kind", gvk.Kind) diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/builder/webhook.go b/vendor/sigs.k8s.io/controller-runtime/pkg/builder/webhook.go index d24877d303..18feb1cd74 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/builder/webhook.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/builder/webhook.go @@ -17,6 +17,7 @@ limitations under the License. package builder import ( + "errors" "net/http" "net/url" "strings" @@ -32,10 +33,12 @@ import ( // WebhookBuilder builds a Webhook. type WebhookBuilder struct { - apiType runtime.Object - gvk schema.GroupVersionKind - mgr manager.Manager - config *rest.Config + apiType runtime.Object + withDefaulter admission.CustomDefaulter + withValidator admission.CustomValidator + gvk schema.GroupVersionKind + mgr manager.Manager + config *rest.Config } // WebhookManagedBy allows inform its manager.Manager. @@ -53,6 +56,18 @@ func (blder *WebhookBuilder) For(apiType runtime.Object) *WebhookBuilder { return blder } +// WithDefaulter takes a admission.WithDefaulter interface, a MutatingWebhook will be wired for this type. +func (blder *WebhookBuilder) WithDefaulter(defaulter admission.CustomDefaulter) *WebhookBuilder { + blder.withDefaulter = defaulter + return blder +} + +// WithValidator takes a admission.WithValidator interface, a ValidatingWebhook will be wired for this type. +func (blder *WebhookBuilder) WithValidator(validator admission.CustomValidator) *WebhookBuilder { + blder.withValidator = validator + return blder +} + // Complete builds the webhook. func (blder *WebhookBuilder) Complete() error { // Set the Config @@ -69,9 +84,13 @@ func (blder *WebhookBuilder) loadRestConfig() { } func (blder *WebhookBuilder) registerWebhooks() error { + typ, err := blder.getType() + if err != nil { + return err + } + // Create webhook(s) for each type - var err error - blder.gvk, err = apiutil.GVKForObject(blder.apiType, blder.mgr.GetScheme()) + blder.gvk, err = apiutil.GVKForObject(typ, blder.mgr.GetScheme()) if err != nil { return err } @@ -88,12 +107,7 @@ func (blder *WebhookBuilder) registerWebhooks() error { // registerDefaultingWebhook registers a defaulting webhook if th. func (blder *WebhookBuilder) registerDefaultingWebhook() { - defaulter, isDefaulter := blder.apiType.(admission.Defaulter) - if !isDefaulter { - log.Info("skip registering a mutating webhook, admission.Defaulter interface is not implemented", "GVK", blder.gvk) - return - } - mwh := admission.DefaultingWebhookFor(defaulter) + mwh := blder.getDefaultingWebhook() if mwh != nil { path := generateMutatePath(blder.gvk) @@ -108,13 +122,21 @@ func (blder *WebhookBuilder) registerDefaultingWebhook() { } } -func (blder *WebhookBuilder) registerValidatingWebhook() { - validator, isValidator := blder.apiType.(admission.Validator) - if !isValidator { - log.Info("skip registering a validating webhook, admission.Validator interface is not implemented", "GVK", blder.gvk) - return +func (blder *WebhookBuilder) getDefaultingWebhook() *admission.Webhook { + if defaulter := blder.withDefaulter; defaulter != nil { + return admission.WithCustomDefaulter(blder.apiType, defaulter) + } + if defaulter, ok := blder.apiType.(admission.Defaulter); ok { + return admission.DefaultingWebhookFor(defaulter) } - vwh := admission.ValidatingWebhookFor(validator) + log.Info( + "skip registering a mutating webhook, object does not implement admission.Defaulter or WithDefaulter wasn't called", + "GVK", blder.gvk) + return nil +} + +func (blder *WebhookBuilder) registerValidatingWebhook() { + vwh := blder.getValidatingWebhook() if vwh != nil { path := generateValidatePath(blder.gvk) @@ -129,22 +151,42 @@ func (blder *WebhookBuilder) registerValidatingWebhook() { } } +func (blder *WebhookBuilder) getValidatingWebhook() *admission.Webhook { + if validator := blder.withValidator; validator != nil { + return admission.WithCustomValidator(blder.apiType, validator) + } + if validator, ok := blder.apiType.(admission.Validator); ok { + return admission.ValidatingWebhookFor(validator) + } + log.Info( + "skip registering a validating webhook, object does not implement admission.Validator or WithValidator wasn't called", + "GVK", blder.gvk) + return nil +} + func (blder *WebhookBuilder) registerConversionWebhook() error { ok, err := conversion.IsConvertible(blder.mgr.GetScheme(), blder.apiType) if err != nil { - log.Error(err, "conversion check failed", "object", blder.apiType) + log.Error(err, "conversion check failed", "GVK", blder.gvk) return err } if ok { if !blder.isAlreadyHandled("/convert") { blder.mgr.GetWebhookServer().Register("/convert", &conversion.Webhook{}) } - log.Info("conversion webhook enabled", "object", blder.apiType) + log.Info("Conversion webhook enabled", "GVK", blder.gvk) } return nil } +func (blder *WebhookBuilder) getType() (runtime.Object, error) { + if blder.apiType != nil { + return blder.apiType, nil + } + return nil, errors.New("For() must be called with a valid object") +} + func (blder *WebhookBuilder) isAlreadyHandled(path string) bool { if blder.mgr.GetWebhookServer().WebhookMux == nil { return false diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/cache.go b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/cache.go index f89800ca2f..f381098fe0 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/cache.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/cache.go @@ -86,8 +86,13 @@ type Informer interface { HasSynced() bool } +// ObjectSelector is an alias name of internal.Selector. +type ObjectSelector internal.Selector + // SelectorsByObject associate a client.Object's GVK to a field/label selector. -type SelectorsByObject map[client.Object]internal.Selector +// There is also `DefaultSelector` to set a global default (which will be overridden by +// a more specific setting here, if any). +type SelectorsByObject map[client.Object]ObjectSelector // Options are the optional arguments for creating a new InformersMap object. type Options struct { @@ -114,6 +119,10 @@ type Options struct { // [2] https://pkg.go.dev/k8s.io/apimachinery/pkg/fields#Set SelectorsByObject SelectorsByObject + // DefaultSelector will be used as selectors for all object types + // that do not have a selector in SelectorsByObject defined. + DefaultSelector ObjectSelector + // UnsafeDisableDeepCopyByObject indicates not to deep copy objects during get or // list objects per GVK at the specified object. // Be very careful with this, when enabled you must DeepCopy any object before mutating it, @@ -129,7 +138,7 @@ func New(config *rest.Config, opts Options) (Cache, error) { if err != nil { return nil, err } - selectorsByGVK, err := convertToSelectorsByGVK(opts.SelectorsByObject, opts.Scheme) + selectorsByGVK, err := convertToSelectorsByGVK(opts.SelectorsByObject, opts.DefaultSelector, opts.Scheme) if err != nil { return nil, err } @@ -150,21 +159,23 @@ func New(config *rest.Config, opts Options) (Cache, error) { // returned from cache get/list before mutating it. func BuilderWithOptions(options Options) NewCacheFunc { return func(config *rest.Config, opts Options) (Cache, error) { - if opts.Scheme == nil { - opts.Scheme = options.Scheme + if options.Scheme == nil { + options.Scheme = opts.Scheme + } + if options.Mapper == nil { + options.Mapper = opts.Mapper } - if opts.Mapper == nil { - opts.Mapper = options.Mapper + if options.Resync == nil { + options.Resync = opts.Resync + } + if options.Namespace == "" { + options.Namespace = opts.Namespace } if opts.Resync == nil { opts.Resync = options.Resync } - if opts.Namespace == "" { - opts.Namespace = options.Namespace - } - opts.SelectorsByObject = options.SelectorsByObject - opts.UnsafeDisableDeepCopyByObject = options.UnsafeDisableDeepCopyByObject - return New(config, opts) + + return New(config, options) } } @@ -191,15 +202,16 @@ func defaultOpts(config *rest.Config, opts Options) (Options, error) { return opts, nil } -func convertToSelectorsByGVK(selectorsByObject SelectorsByObject, scheme *runtime.Scheme) (internal.SelectorsByGVK, error) { +func convertToSelectorsByGVK(selectorsByObject SelectorsByObject, defaultSelector ObjectSelector, scheme *runtime.Scheme) (internal.SelectorsByGVK, error) { selectorsByGVK := internal.SelectorsByGVK{} for object, selector := range selectorsByObject { gvk, err := apiutil.GVKForObject(object, scheme) if err != nil { return nil, err } - selectorsByGVK[gvk] = selector + selectorsByGVK[gvk] = internal.Selector(selector) } + selectorsByGVK[schema.GroupVersionKind{}] = internal.Selector(defaultSelector) return selectorsByGVK, nil } diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/informers_map.go b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/informers_map.go index 413b048f0c..07f2f1261f 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/informers_map.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/informers_map.go @@ -34,6 +34,7 @@ import ( "k8s.io/client-go/metadata" "k8s.io/client-go/rest" "k8s.io/client-go/tools/cache" + "sigs.k8s.io/controller-runtime/pkg/client/apiutil" ) @@ -65,7 +66,7 @@ func newSpecificInformersMap(config *rest.Config, startWait: make(chan struct{}), createListWatcher: createListWatcher, namespace: namespace, - selectors: selectors, + selectors: selectors.forGVK, disableDeepCopy: disableDeepCopy, } return ip @@ -130,7 +131,7 @@ type specificInformersMap struct { // selectors are the label or field selectors that will be added to the // ListWatch ListOptions. - selectors SelectorsByGVK + selectors func(gvk schema.GroupVersionKind) Selector // disableDeepCopy indicates not to deep copy objects during get or list objects. disableDeepCopy DisableDeepCopyByGVK @@ -231,12 +232,6 @@ func (ip *specificInformersMap) addInformerToMap(gvk schema.GroupVersionKind, ob return nil, false, err } - switch obj.(type) { - case *metav1.PartialObjectMetadata, *metav1.PartialObjectMetadataList: - ni = metadataSharedIndexInformerPreserveGVK(gvk, ni) - default: - } - i := &MapEntry{ Informer: ni, Reader: CacheReader{ @@ -282,19 +277,19 @@ func createStructuredListWatch(gvk schema.GroupVersionKind, ip *specificInformer // Create a new ListWatch for the obj return &cache.ListWatch{ ListFunc: func(opts metav1.ListOptions) (runtime.Object, error) { - ip.selectors[gvk].ApplyToList(&opts) + ip.selectors(gvk).ApplyToList(&opts) res := listObj.DeepCopyObject() - namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors[gvk]) + namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors(gvk)) isNamespaceScoped := namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot err := client.Get().NamespaceIfScoped(namespace, isNamespaceScoped).Resource(mapping.Resource.Resource).VersionedParams(&opts, ip.paramCodec).Do(ctx).Into(res) return res, err }, // Setup the watch function WatchFunc: func(opts metav1.ListOptions) (watch.Interface, error) { - ip.selectors[gvk].ApplyToList(&opts) + ip.selectors(gvk).ApplyToList(&opts) // Watch needs to be set to true separately opts.Watch = true - namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors[gvk]) + namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors(gvk)) isNamespaceScoped := namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot return client.Get().NamespaceIfScoped(namespace, isNamespaceScoped).Resource(mapping.Resource.Resource).VersionedParams(&opts, ip.paramCodec).Watch(ctx) }, @@ -324,8 +319,8 @@ func createUnstructuredListWatch(gvk schema.GroupVersionKind, ip *specificInform // Create a new ListWatch for the obj return &cache.ListWatch{ ListFunc: func(opts metav1.ListOptions) (runtime.Object, error) { - ip.selectors[gvk].ApplyToList(&opts) - namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors[gvk]) + ip.selectors(gvk).ApplyToList(&opts) + namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors(gvk)) if namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot { return dynamicClient.Resource(mapping.Resource).Namespace(namespace).List(ctx, opts) } @@ -333,10 +328,10 @@ func createUnstructuredListWatch(gvk schema.GroupVersionKind, ip *specificInform }, // Setup the watch function WatchFunc: func(opts metav1.ListOptions) (watch.Interface, error) { - ip.selectors[gvk].ApplyToList(&opts) + ip.selectors(gvk).ApplyToList(&opts) // Watch needs to be set to true separately opts.Watch = true - namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors[gvk]) + namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors(gvk)) if namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot { return dynamicClient.Resource(mapping.Resource).Namespace(namespace).Watch(ctx, opts) } @@ -371,27 +366,86 @@ func createMetadataListWatch(gvk schema.GroupVersionKind, ip *specificInformersM // create the relevant listwatch return &cache.ListWatch{ ListFunc: func(opts metav1.ListOptions) (runtime.Object, error) { - ip.selectors[gvk].ApplyToList(&opts) - namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors[gvk]) + ip.selectors(gvk).ApplyToList(&opts) + + var ( + list *metav1.PartialObjectMetadataList + err error + ) + namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors(gvk)) if namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot { - return client.Resource(mapping.Resource).Namespace(namespace).List(ctx, opts) + list, err = client.Resource(mapping.Resource).Namespace(namespace).List(ctx, opts) + } else { + list, err = client.Resource(mapping.Resource).List(ctx, opts) + } + if list != nil { + for i := range list.Items { + list.Items[i].SetGroupVersionKind(gvk) + } } - return client.Resource(mapping.Resource).List(ctx, opts) + return list, err }, // Setup the watch function WatchFunc: func(opts metav1.ListOptions) (watch.Interface, error) { - ip.selectors[gvk].ApplyToList(&opts) + ip.selectors(gvk).ApplyToList(&opts) // Watch needs to be set to true separately opts.Watch = true - namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors[gvk]) + + var ( + watcher watch.Interface + err error + ) + namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors(gvk)) if namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot { - return client.Resource(mapping.Resource).Namespace(namespace).Watch(ctx, opts) + watcher, err = client.Resource(mapping.Resource).Namespace(namespace).Watch(ctx, opts) + } else { + watcher, err = client.Resource(mapping.Resource).Watch(ctx, opts) + } + if watcher != nil { + watcher = newGVKFixupWatcher(gvk, watcher) } - return client.Resource(mapping.Resource).Watch(ctx, opts) + return watcher, err }, }, nil } +type gvkFixupWatcher struct { + watcher watch.Interface + ch chan watch.Event + gvk schema.GroupVersionKind + wg sync.WaitGroup +} + +func newGVKFixupWatcher(gvk schema.GroupVersionKind, watcher watch.Interface) watch.Interface { + ch := make(chan watch.Event) + w := &gvkFixupWatcher{ + gvk: gvk, + watcher: watcher, + ch: ch, + } + w.wg.Add(1) + go w.run() + return w +} + +func (w *gvkFixupWatcher) run() { + for e := range w.watcher.ResultChan() { + e.Object.GetObjectKind().SetGroupVersionKind(w.gvk) + w.ch <- e + } + w.wg.Done() +} + +func (w *gvkFixupWatcher) Stop() { + w.watcher.Stop() + w.wg.Wait() + close(w.ch) +} + +func (w *gvkFixupWatcher) ResultChan() <-chan watch.Event { + return w.ch +} + // resyncPeriod returns a function which generates a duration each time it is // invoked; this is so that multiple controllers don't get into lock-step and all // hammer the apiserver with list requests simultaneously. diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/metadata_infomer_wrapper.go b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/metadata_infomer_wrapper.go deleted file mode 100644 index c0fa24a5c1..0000000000 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/metadata_infomer_wrapper.go +++ /dev/null @@ -1,71 +0,0 @@ -/* -Copyright 2021 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package internal - -import ( - "time" - - "k8s.io/apimachinery/pkg/runtime/schema" - "k8s.io/client-go/tools/cache" -) - -func metadataSharedIndexInformerPreserveGVK(gvk schema.GroupVersionKind, si cache.SharedIndexInformer) cache.SharedIndexInformer { - return &sharedInformerWrapper{ - gvk: gvk, - SharedIndexInformer: si, - } -} - -type sharedInformerWrapper struct { - gvk schema.GroupVersionKind - cache.SharedIndexInformer -} - -func (s *sharedInformerWrapper) AddEventHandler(handler cache.ResourceEventHandler) { - s.SharedIndexInformer.AddEventHandler(&handlerPreserveGVK{s.gvk, handler}) -} - -func (s *sharedInformerWrapper) AddEventHandlerWithResyncPeriod(handler cache.ResourceEventHandler, resyncPeriod time.Duration) { - s.SharedIndexInformer.AddEventHandlerWithResyncPeriod(&handlerPreserveGVK{s.gvk, handler}, resyncPeriod) -} - -type handlerPreserveGVK struct { - gvk schema.GroupVersionKind - cache.ResourceEventHandler -} - -func (h *handlerPreserveGVK) resetGroupVersionKind(obj interface{}) { - if v, ok := obj.(schema.ObjectKind); ok { - v.SetGroupVersionKind(h.gvk) - } -} - -func (h *handlerPreserveGVK) OnAdd(obj interface{}) { - h.resetGroupVersionKind(obj) - h.ResourceEventHandler.OnAdd(obj) -} - -func (h *handlerPreserveGVK) OnUpdate(oldObj, newObj interface{}) { - h.resetGroupVersionKind(oldObj) - h.resetGroupVersionKind(newObj) - h.ResourceEventHandler.OnUpdate(oldObj, newObj) -} - -func (h *handlerPreserveGVK) OnDelete(obj interface{}) { - h.resetGroupVersionKind(obj) - h.ResourceEventHandler.OnDelete(obj) -} diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/selector.go b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/selector.go index cd9c580008..4eff32fb35 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/selector.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/selector.go @@ -26,6 +26,17 @@ import ( // SelectorsByGVK associate a GroupVersionKind to a field/label selector. type SelectorsByGVK map[schema.GroupVersionKind]Selector +func (s SelectorsByGVK) forGVK(gvk schema.GroupVersionKind) Selector { + if specific, found := s[gvk]; found { + return specific + } + if defaultSelector, found := s[schema.GroupVersionKind{}]; found { + return defaultSelector + } + + return Selector{} +} + // Selector specify the label/field selector to fill in ListOptions. type Selector struct { Label labels.Selector diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/client/apiutil/apimachinery.go b/vendor/sigs.k8s.io/controller-runtime/pkg/client/apiutil/apimachinery.go index e21eb22389..c92b0eaaec 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/apiutil/apimachinery.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/apiutil/apimachinery.go @@ -158,14 +158,12 @@ func createRestConfig(gvk schema.GroupVersionKind, isUnstructured bool, baseConf protobufSchemeLock.RUnlock() } - if cfg.NegotiatedSerializer == nil { - if isUnstructured { - // If the object is unstructured, we need to preserve the GVK information. - // Use our own custom serializer. - cfg.NegotiatedSerializer = serializerWithDecodedGVK{serializer.WithoutConversionCodecFactory{CodecFactory: codecs}} - } else { - cfg.NegotiatedSerializer = serializerWithTargetZeroingDecode{NegotiatedSerializer: serializer.WithoutConversionCodecFactory{CodecFactory: codecs}} - } + if isUnstructured { + // If the object is unstructured, we need to preserve the GVK information. + // Use our own custom serializer. + cfg.NegotiatedSerializer = serializerWithDecodedGVK{serializer.WithoutConversionCodecFactory{CodecFactory: codecs}} + } else { + cfg.NegotiatedSerializer = serializerWithTargetZeroingDecode{NegotiatedSerializer: serializer.WithoutConversionCodecFactory{CodecFactory: codecs}} } return cfg diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/client/config/config.go b/vendor/sigs.k8s.io/controller-runtime/pkg/client/config/config.go index 235a7e450b..da87f2bd43 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/config/config.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/config/config.go @@ -21,7 +21,7 @@ import ( "fmt" "os" "os/user" - "path" + "path/filepath" "k8s.io/client-go/rest" "k8s.io/client-go/tools/clientcmd" @@ -125,7 +125,7 @@ func loadConfig(context string) (*rest.Config, error) { if err != nil { return nil, fmt.Errorf("could not get current user: %v", err) } - loadingRules.Precedence = append(loadingRules.Precedence, path.Join(u.HomeDir, clientcmd.RecommendedHomeDir, clientcmd.RecommendedFileName)) + loadingRules.Precedence = append(loadingRules.Precedence, filepath.Join(u.HomeDir, clientcmd.RecommendedHomeDir, clientcmd.RecommendedFileName)) } return loadConfigWithContext("", loadingRules, context) diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/client/fake/client.go b/vendor/sigs.k8s.io/controller-runtime/pkg/client/fake/client.go index f254523b7f..f72afe19d9 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/fake/client.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/fake/client.go @@ -21,6 +21,7 @@ import ( "encoding/json" "errors" "fmt" + "reflect" "strconv" "strings" "sync" @@ -50,6 +51,7 @@ type versionedTracker struct { type fakeClient struct { tracker versionedTracker scheme *runtime.Scheme + restMapper meta.RESTMapper schemeWriteLock sync.Mutex } @@ -86,6 +88,7 @@ func NewClientBuilder() *ClientBuilder { // ClientBuilder builds a fake client. type ClientBuilder struct { scheme *runtime.Scheme + restMapper meta.RESTMapper initObject []client.Object initLists []client.ObjectList initRuntimeObjects []runtime.Object @@ -98,6 +101,15 @@ func (f *ClientBuilder) WithScheme(scheme *runtime.Scheme) *ClientBuilder { return f } +// WithRESTMapper sets this builder's restMapper. +// The restMapper is directly set as mapper in the Client. This can be used for example +// with a meta.DefaultRESTMapper to provide a static rest mapping. +// If not set, defaults to an empty meta.DefaultRESTMapper. +func (f *ClientBuilder) WithRESTMapper(restMapper meta.RESTMapper) *ClientBuilder { + f.restMapper = restMapper + return f +} + // WithObjects can be optionally used to initialize this fake client with client.Object(s). func (f *ClientBuilder) WithObjects(initObjs ...client.Object) *ClientBuilder { f.initObject = append(f.initObject, initObjs...) @@ -121,6 +133,9 @@ func (f *ClientBuilder) Build() client.WithWatch { if f.scheme == nil { f.scheme = scheme.Scheme } + if f.restMapper == nil { + f.restMapper = meta.NewDefaultRESTMapper([]schema.GroupVersion{}) + } tracker := versionedTracker{ObjectTracker: testing.NewObjectTracker(f.scheme, scheme.Codecs.UniversalDecoder()), scheme: f.scheme} for _, obj := range f.initObject { @@ -139,8 +154,9 @@ func (f *ClientBuilder) Build() client.WithWatch { } } return &fakeClient{ - tracker: tracker, - scheme: f.scheme, + tracker: tracker, + scheme: f.scheme, + restMapper: f.restMapper, } } @@ -169,6 +185,11 @@ func (t versionedTracker) Add(obj runtime.Object) error { // be recognized accessor.SetResourceVersion(trackerAddResourceVersion) } + + obj, err = convertFromUnstructuredIfNecessary(t.scheme, obj) + if err != nil { + return err + } if err := t.ObjectTracker.Add(obj); err != nil { return err } @@ -192,13 +213,45 @@ func (t versionedTracker) Create(gvr schema.GroupVersionResource, obj runtime.Ob return apierrors.NewBadRequest("resourceVersion can not be set for Create requests") } accessor.SetResourceVersion("1") + obj, err = convertFromUnstructuredIfNecessary(t.scheme, obj) + if err != nil { + return err + } if err := t.ObjectTracker.Create(gvr, obj, ns); err != nil { accessor.SetResourceVersion("") return err } + return nil } +// convertFromUnstructuredIfNecessary will convert *unstructured.Unstructured for a GVK that is recocnized +// by the schema into the whatever the schema produces with New() for said GVK. +// This is required because the tracker unconditionally saves on manipulations, but it's List() implementation +// tries to assign whatever it finds into a ListType it gets from schema.New() - Thus we have to ensure +// we save as the very same type, otherwise subsequent List requests will fail. +func convertFromUnstructuredIfNecessary(s *runtime.Scheme, o runtime.Object) (runtime.Object, error) { + u, isUnstructured := o.(*unstructured.Unstructured) + if !isUnstructured || !s.Recognizes(u.GroupVersionKind()) { + return o, nil + } + + typed, err := s.New(u.GroupVersionKind()) + if err != nil { + return nil, fmt.Errorf("scheme recognizes %s but failed to produce an object for it: %w", u.GroupVersionKind().String(), err) + } + + unstructuredSerialized, err := json.Marshal(u) + if err != nil { + return nil, fmt.Errorf("failed to serialize %T: %w", unstructuredSerialized, err) + } + if err := json.Unmarshal(unstructuredSerialized, typed); err != nil { + return nil, fmt.Errorf("failed to unmarshal the content of %T into %T: %w", u, typed, err) + } + + return typed, nil +} + func (t versionedTracker) Update(gvr schema.GroupVersionResource, obj runtime.Object, ns string) error { accessor, err := meta.Accessor(obj) if err != nil { @@ -255,6 +308,10 @@ func (t versionedTracker) Update(gvr schema.GroupVersionResource, obj runtime.Ob if !accessor.GetDeletionTimestamp().IsZero() && len(accessor.GetFinalizers()) == 0 { return t.ObjectTracker.Delete(gvr, accessor.GetNamespace(), accessor.GetName()) } + obj, err = convertFromUnstructuredIfNecessary(t.scheme, obj) + if err != nil { + return err + } return t.ObjectTracker.Update(gvr, obj, ns) } @@ -284,6 +341,7 @@ func (c *fakeClient) Get(ctx context.Context, key client.ObjectKey, obj client.O return err } decoder := scheme.Codecs.UniversalDecoder() + zero(obj) _, _, err = decoder.Decode(j, nil, obj) return err } @@ -318,7 +376,7 @@ func (c *fakeClient) List(ctx context.Context, obj client.ObjectList, opts ...cl } if _, isUnstructuredList := obj.(*unstructured.UnstructuredList); isUnstructuredList && !c.scheme.Recognizes(gvk) { - // We need tor register the ListKind with UnstructuredList: + // We need to register the ListKind with UnstructuredList: // https://github.com/kubernetes/kubernetes/blob/7b2776b89fb1be28d4e9203bdeec079be903c103/staging/src/k8s.io/client-go/dynamic/fake/simple.go#L44-L51 c.schemeWriteLock.Lock() c.scheme.AddKnownTypeWithName(gvk.GroupVersion().WithKind(gvk.Kind+"List"), &unstructured.UnstructuredList{}) @@ -346,6 +404,7 @@ func (c *fakeClient) List(ctx context.Context, obj client.ObjectList, opts ...cl return err } decoder := scheme.Codecs.UniversalDecoder() + zero(obj) _, _, err = decoder.Decode(j, nil, obj) if err != nil { return err @@ -373,8 +432,7 @@ func (c *fakeClient) Scheme() *runtime.Scheme { } func (c *fakeClient) RESTMapper() meta.RESTMapper { - // TODO: Implement a fake RESTMapper. - return nil + return c.restMapper } func (c *fakeClient) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error { @@ -549,6 +607,7 @@ func (c *fakeClient) Patch(ctx context.Context, obj client.Object, patch client. return err } decoder := scheme.Codecs.UniversalDecoder() + zero(obj) _, _, err = decoder.Decode(j, nil, obj) return err } @@ -695,3 +754,12 @@ func allowsCreateOnUpdate(gvk schema.GroupVersionKind) bool { return false } + +// zero zeros the value of a pointer. +func zero(x interface{}) { + if x == nil { + return + } + res := reflect.ValueOf(x).Elem() + res.Set(reflect.Zero(res.Type())) +} diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/cluster/cluster.go b/vendor/sigs.k8s.io/controller-runtime/pkg/cluster/cluster.go index dfd0fa9dd8..4b8ee8e7c5 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/cluster/cluster.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cluster/cluster.go @@ -245,7 +245,7 @@ func setOptionsDefaults(options Options) Options { } } - if options.Logger == nil { + if options.Logger.GetSink() == nil { options.Logger = logf.RuntimeLog.WithName("cluster") } diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/config/v1alpha1/zz_generated.deepcopy.go b/vendor/sigs.k8s.io/controller-runtime/pkg/config/v1alpha1/zz_generated.deepcopy.go index 752fa9754c..5329bef667 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/config/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/config/v1alpha1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated // Code generated by controller-gen. DO NOT EDIT. diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/controller/controller.go b/vendor/sigs.k8s.io/controller-runtime/pkg/controller/controller.go index 88ba786717..a5c850274e 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/controller/controller.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/controller/controller.go @@ -104,7 +104,7 @@ func NewUnmanaged(name string, mgr manager.Manager, options Options) (Controller return nil, fmt.Errorf("must specify Name for Controller") } - if options.Log == nil { + if options.Log.GetSink() == nil { options.Log = mgr.GetLogger() } diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/internal/controller/controller.go b/vendor/sigs.k8s.io/controller-runtime/pkg/internal/controller/controller.go index 87431a438f..1f4712d8bf 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/internal/controller/controller.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/internal/controller/controller.go @@ -175,7 +175,7 @@ func (c *Controller) Start(ctx context.Context) error { // caches to sync so that they have a chance to register their intendeded // caches. for _, watch := range c.startWatches { - c.Log.Info("Starting EventSource", "source", watch.src) + c.Log.Info("Starting EventSource", "source", fmt.Sprintf("%s", watch.src)) if err := watch.src.Start(ctx, watch.handler, c.Queue, watch.predicates...); err != nil { return err diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/internal/httpserver/server.go b/vendor/sigs.k8s.io/controller-runtime/pkg/internal/httpserver/server.go new file mode 100644 index 0000000000..b5f91f18e0 --- /dev/null +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/internal/httpserver/server.go @@ -0,0 +1,16 @@ +package httpserver + +import ( + "net/http" + "time" +) + +// New returns a new server with sane defaults. +func New(handler http.Handler) *http.Server { + return &http.Server{ + Handler: handler, + MaxHeaderBytes: 1 << 20, + IdleTimeout: 90 * time.Second, // matches http.DefaultTransport keep-alive timeout + ReadHeaderTimeout: 32 * time.Second, + } +} diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/log/deleg.go b/vendor/sigs.k8s.io/controller-runtime/pkg/log/deleg.go index 9d73947dac..c15e73cff7 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/log/deleg.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/log/deleg.go @@ -25,16 +25,15 @@ import ( // loggerPromise knows how to populate a concrete logr.Logger // with options, given an actual base logger later on down the line. type loggerPromise struct { - logger *DelegatingLogger + logger *DelegatingLogSink childPromises []*loggerPromise promisesLock sync.Mutex - name *string - tags []interface{} - level int + name *string + tags []interface{} } -func (p *loggerPromise) WithName(l *DelegatingLogger, name string) *loggerPromise { +func (p *loggerPromise) WithName(l *DelegatingLogSink, name string) *loggerPromise { res := &loggerPromise{ logger: l, name: &name, @@ -48,7 +47,7 @@ func (p *loggerPromise) WithName(l *DelegatingLogger, name string) *loggerPromis } // WithValues provides a new Logger with the tags appended. -func (p *loggerPromise) WithValues(l *DelegatingLogger, tags ...interface{}) *loggerPromise { +func (p *loggerPromise) WithValues(l *DelegatingLogSink, tags ...interface{}) *loggerPromise { res := &loggerPromise{ logger: l, tags: tags, @@ -61,61 +60,53 @@ func (p *loggerPromise) WithValues(l *DelegatingLogger, tags ...interface{}) *lo return res } -func (p *loggerPromise) V(l *DelegatingLogger, level int) *loggerPromise { - res := &loggerPromise{ - logger: l, - level: level, - promisesLock: sync.Mutex{}, - } - - p.promisesLock.Lock() - defer p.promisesLock.Unlock() - p.childPromises = append(p.childPromises, res) - return res -} - // Fulfill instantiates the Logger with the provided logger. -func (p *loggerPromise) Fulfill(parentLogger logr.Logger) { - logger := logr.WithCallDepth(parentLogger, 1) +func (p *loggerPromise) Fulfill(parentLogSink logr.LogSink) { + sink := parentLogSink if p.name != nil { - logger = logger.WithName(*p.name) + sink = sink.WithName(*p.name) } if p.tags != nil { - logger = logger.WithValues(p.tags...) - } - if p.level != 0 { - logger = logger.V(p.level) + sink = sink.WithValues(p.tags...) } p.logger.lock.Lock() - p.logger.logger = logger + p.logger.logger = sink p.logger.promise = nil p.logger.lock.Unlock() for _, childPromise := range p.childPromises { - childPromise.Fulfill(logger) + childPromise.Fulfill(sink) } } -// DelegatingLogger is a logr.Logger that delegates to another logr.Logger. +// DelegatingLogSink is a logsink that delegates to another logr.LogSink. // If the underlying promise is not nil, it registers calls to sub-loggers with // the logging factory to be populated later, and returns a new delegating // logger. It expects to have *some* logr.Logger set at all times (generally // a no-op logger before the promises are fulfilled). -type DelegatingLogger struct { +type DelegatingLogSink struct { lock sync.RWMutex - logger logr.Logger + logger logr.LogSink promise *loggerPromise + info logr.RuntimeInfo +} + +// Init implements logr.LogSink. +func (l *DelegatingLogSink) Init(info logr.RuntimeInfo) { + l.lock.Lock() + defer l.lock.Unlock() + l.info = info } // Enabled tests whether this Logger is enabled. For example, commandline // flags might be used to set the logging verbosity and disable some info // logs. -func (l *DelegatingLogger) Enabled() bool { +func (l *DelegatingLogSink) Enabled(level int) bool { l.lock.RLock() defer l.lock.RUnlock() - return l.logger.Enabled() + return l.logger.Enabled(level) } // Info logs a non-error message with the given key/value pairs as context. @@ -124,10 +115,10 @@ func (l *DelegatingLogger) Enabled() bool { // the log line. The key/value pairs can then be used to add additional // variable information. The key/value pairs should alternate string // keys and arbitrary values. -func (l *DelegatingLogger) Info(msg string, keysAndValues ...interface{}) { +func (l *DelegatingLogSink) Info(level int, msg string, keysAndValues ...interface{}) { l.lock.RLock() defer l.lock.RUnlock() - l.logger.Info(msg, keysAndValues...) + l.logger.Info(level, msg, keysAndValues...) } // Error logs an error, with the given message and key/value pairs as context. @@ -138,33 +129,14 @@ func (l *DelegatingLogger) Info(msg string, keysAndValues ...interface{}) { // The msg field should be used to add context to any underlying error, // while the err field should be used to attach the actual error that // triggered this log line, if present. -func (l *DelegatingLogger) Error(err error, msg string, keysAndValues ...interface{}) { +func (l *DelegatingLogSink) Error(err error, msg string, keysAndValues ...interface{}) { l.lock.RLock() defer l.lock.RUnlock() l.logger.Error(err, msg, keysAndValues...) } -// V returns an Logger value for a specific verbosity level, relative to -// this Logger. In other words, V values are additive. V higher verbosity -// level means a log message is less important. It's illegal to pass a log -// level less than zero. -func (l *DelegatingLogger) V(level int) logr.Logger { - l.lock.RLock() - defer l.lock.RUnlock() - - if l.promise == nil { - return l.logger.V(level) - } - - res := &DelegatingLogger{logger: l.logger} - promise := l.promise.V(res, level) - res.promise = promise - - return res -} - // WithName provides a new Logger with the name appended. -func (l *DelegatingLogger) WithName(name string) logr.Logger { +func (l *DelegatingLogSink) WithName(name string) logr.LogSink { l.lock.RLock() defer l.lock.RUnlock() @@ -172,7 +144,7 @@ func (l *DelegatingLogger) WithName(name string) logr.Logger { return l.logger.WithName(name) } - res := &DelegatingLogger{logger: l.logger} + res := &DelegatingLogSink{logger: l.logger} promise := l.promise.WithName(res, name) res.promise = promise @@ -180,7 +152,7 @@ func (l *DelegatingLogger) WithName(name string) logr.Logger { } // WithValues provides a new Logger with the tags appended. -func (l *DelegatingLogger) WithValues(tags ...interface{}) logr.Logger { +func (l *DelegatingLogSink) WithValues(tags ...interface{}) logr.LogSink { l.lock.RLock() defer l.lock.RUnlock() @@ -188,7 +160,7 @@ func (l *DelegatingLogger) WithValues(tags ...interface{}) logr.Logger { return l.logger.WithValues(tags...) } - res := &DelegatingLogger{logger: l.logger} + res := &DelegatingLogSink{logger: l.logger} promise := l.promise.WithValues(res, tags...) res.promise = promise @@ -198,16 +170,16 @@ func (l *DelegatingLogger) WithValues(tags ...interface{}) logr.Logger { // Fulfill switches the logger over to use the actual logger // provided, instead of the temporary initial one, if this method // has not been previously called. -func (l *DelegatingLogger) Fulfill(actual logr.Logger) { +func (l *DelegatingLogSink) Fulfill(actual logr.LogSink) { if l.promise != nil { l.promise.Fulfill(actual) } } -// NewDelegatingLogger constructs a new DelegatingLogger which uses +// NewDelegatingLogSink constructs a new DelegatingLogSink which uses // the given logger before it's promise is fulfilled. -func NewDelegatingLogger(initial logr.Logger) *DelegatingLogger { - l := &DelegatingLogger{ +func NewDelegatingLogSink(initial logr.LogSink) *DelegatingLogSink { + l := &DelegatingLogSink{ logger: initial, promise: &loggerPromise{promisesLock: sync.Mutex{}}, } diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/log/log.go b/vendor/sigs.k8s.io/controller-runtime/pkg/log/log.go index 229ac7ec35..76950cc34b 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/log/log.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/log/log.go @@ -47,14 +47,14 @@ func SetLogger(l logr.Logger) { defer loggerWasSetLock.Unlock() loggerWasSet = true - Log.Fulfill(l) + dlog.Fulfill(l.GetSink()) } // It is safe to assume that if this wasn't set within the first 30 seconds of a binaries -// lifetime, it will never get set. The DelegatingLogger causes a high number of memory -// allocations when not given an actual Logger, so we set a NullLogger to avoid that. +// lifetime, it will never get set. The DelegatingLogSink causes a high number of memory +// allocations when not given an actual Logger, so we set a NullLogSink to avoid that. // -// We need to keep the DelegatingLogger because we have various inits() that get a logger from +// We need to keep the DelegatingLogSink because we have various inits() that get a logger from // here. They will always get executed before any code that imports controller-runtime // has a chance to run and hence to set an actual logger. func init() { @@ -64,7 +64,7 @@ func init() { loggerWasSetLock.Lock() defer loggerWasSetLock.Unlock() if !loggerWasSet { - Log.Fulfill(NullLogger{}) + dlog.Fulfill(NullLogSink{}) } }() } @@ -78,14 +78,17 @@ var ( // to another logr.Logger. You *must* call SetLogger to // get any actual logging. If SetLogger is not called within // the first 30 seconds of a binaries lifetime, it will get -// set to a NullLogger. -var Log = NewDelegatingLogger(NullLogger{}) +// set to a NullLogSink. +var ( + dlog = NewDelegatingLogSink(NullLogSink{}) + Log = logr.New(dlog) +) // FromContext returns a logger with predefined values from a context.Context. func FromContext(ctx context.Context, keysAndValues ...interface{}) logr.Logger { - var log logr.Logger = Log + log := Log if ctx != nil { - if logger := logr.FromContext(ctx); logger != nil { + if logger, err := logr.FromContext(ctx); err == nil { log = logger } } diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/log/null.go b/vendor/sigs.k8s.io/controller-runtime/pkg/log/null.go index 09a5a02eb6..f3e81074fe 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/log/null.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/log/null.go @@ -24,37 +24,36 @@ import ( // but avoids accidentally adding the testing flags to // all binaries. -// NullLogger is a logr.Logger that does nothing. -type NullLogger struct{} +// NullLogSink is a logr.Logger that does nothing. +type NullLogSink struct{} -var _ logr.Logger = NullLogger{} +var _ logr.LogSink = NullLogSink{} + +// Init implements logr.LogSink. +func (log NullLogSink) Init(logr.RuntimeInfo) { +} // Info implements logr.InfoLogger. -func (NullLogger) Info(_ string, _ ...interface{}) { +func (NullLogSink) Info(_ int, _ string, _ ...interface{}) { // Do nothing. } // Enabled implements logr.InfoLogger. -func (NullLogger) Enabled() bool { +func (NullLogSink) Enabled(level int) bool { return false } // Error implements logr.Logger. -func (NullLogger) Error(_ error, _ string, _ ...interface{}) { +func (NullLogSink) Error(_ error, _ string, _ ...interface{}) { // Do nothing. } -// V implements logr.Logger. -func (log NullLogger) V(_ int) logr.Logger { - return log -} - // WithName implements logr.Logger. -func (log NullLogger) WithName(_ string) logr.Logger { +func (log NullLogSink) WithName(_ string) logr.LogSink { return log } // WithValues implements logr.Logger. -func (log NullLogger) WithValues(_ ...interface{}) logr.Logger { +func (log NullLogSink) WithValues(_ ...interface{}) logr.LogSink { return log } diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/flags.go b/vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/flags.go index 3339655075..fb492b14da 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/flags.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/flags.go @@ -128,3 +128,41 @@ func (ev *stackTraceFlag) String() string { func (ev *stackTraceFlag) Type() string { return "level" } + +type timeEncodingFlag struct { + setFunc func(zapcore.TimeEncoder) + value string +} + +var _ flag.Value = &timeEncodingFlag{} + +func (ev *timeEncodingFlag) String() string { + return ev.value +} + +func (ev *timeEncodingFlag) Type() string { + return "time-encoding" +} + +func (ev *timeEncodingFlag) Set(flagValue string) error { + val := strings.ToLower(flagValue) + switch val { + case "rfc3339nano": + ev.setFunc(zapcore.RFC3339NanoTimeEncoder) + case "rfc3339": + ev.setFunc(zapcore.RFC3339TimeEncoder) + case "iso8601": + ev.setFunc(zapcore.ISO8601TimeEncoder) + case "millis": + ev.setFunc(zapcore.EpochMillisTimeEncoder) + case "nanos": + ev.setFunc(zapcore.EpochNanosTimeEncoder) + case "epoch": + ev.setFunc(zapcore.EpochTimeEncoder) + default: + return fmt.Errorf("invalid time-encoding value \"%s\"", flagValue) + } + + ev.value = flagValue + return nil +} diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/zap.go b/vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/zap.go index 22eb5d771a..fb44c88e5b 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/zap.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/zap.go @@ -167,6 +167,9 @@ type Options struct { // ZapOpts allows passing arbitrary zap.Options to configure on the // underlying Zap logger. ZapOpts []zap.Option + // TimeEncoder specifies the encoder for the timestamps in log messages. + // Defaults to EpochTimeEncoder as this is the default in Zap currently. + TimeEncoder zapcore.TimeEncoder } // addDefaults adds defaults to the Options. @@ -212,6 +215,16 @@ func (o *Options) addDefaults() { })) } } + + if o.TimeEncoder == nil { + o.TimeEncoder = zapcore.EpochTimeEncoder + } + f := func(ecfg *zapcore.EncoderConfig) { + ecfg.EncodeTime = o.TimeEncoder + } + // prepend instead of append it in case someone adds a time encoder option in it + o.EncoderConfigOptions = append([]EncoderConfigOption{f}, o.EncoderConfigOptions...) + if o.Encoder == nil { o.Encoder = o.NewEncoder(o.EncoderConfigOptions...) } @@ -273,6 +286,13 @@ func (o *Options) BindFlags(fs *flag.FlagSet) { } fs.Var(&stackVal, "zap-stacktrace-level", "Zap Level at and above which stacktraces are captured (one of 'info', 'error', 'panic').") + + // Set the time encoding + var timeEncoderVal timeEncodingFlag + timeEncoderVal.setFunc = func(fromFlag zapcore.TimeEncoder) { + o.TimeEncoder = fromFlag + } + fs.Var(&timeEncoderVal, "zap-time-encoding", "Zap time encoding (one of 'epoch', 'millis', 'nano', 'iso8601', 'rfc3339' or 'rfc3339nano'). Defaults to 'epoch'.") } // UseFlagOptions configures the logger to use the Options set by parsing zap option flags from the CLI. diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/internal.go b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/internal.go index 7c25bd3c60..6fb59abdc4 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/internal.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/internal.go @@ -23,6 +23,7 @@ import ( "net" "net/http" "sync" + "sync/atomic" "time" "github.com/go-logr/logr" @@ -30,6 +31,7 @@ import ( "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/runtime" kerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/rest" "k8s.io/client-go/tools/leaderelection" "k8s.io/client-go/tools/leaderelection/resourcelock" @@ -40,6 +42,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/cluster" "sigs.k8s.io/controller-runtime/pkg/config/v1alpha1" "sigs.k8s.io/controller-runtime/pkg/healthz" + "sigs.k8s.io/controller-runtime/pkg/internal/httpserver" intrec "sigs.k8s.io/controller-runtime/pkg/internal/recorder" "sigs.k8s.io/controller-runtime/pkg/metrics" "sigs.k8s.io/controller-runtime/pkg/runtime/inject" @@ -61,16 +64,15 @@ const ( var _ Runnable = &controllerManager{} type controllerManager struct { - // cluster holds a variety of methods to interact with a cluster. Required. - cluster cluster.Cluster + sync.Mutex + started bool - // leaderElectionRunnables is the set of Controllers that the controllerManager injects deps into and Starts. - // These Runnables are managed by lead election. - leaderElectionRunnables []Runnable + stopProcedureEngaged *int64 + errChan chan error + runnables *runnables - // nonLeaderElectionRunnables is the set of webhook servers that the controllerManager injects deps into and Starts. - // These Runnables will not be blocked by lead election. - nonLeaderElectionRunnables []Runnable + // cluster holds a variety of methods to interact with a cluster. Required. + cluster cluster.Cluster // recorderProvider is used to generate event recorders that will be injected into Controllers // (and EventHandlers, Sources and Predicates). @@ -104,12 +106,6 @@ type controllerManager struct { // Healthz probe handler healthzHandler *healthz.Handler - mu sync.Mutex - started bool - startedLeader bool - healthzStarted bool - errChan chan error - // controllerOptions are the global controller options. controllerOptions v1alpha1.ControllerConfigurationSpec @@ -117,25 +113,20 @@ type controllerManager struct { // If none is set, it defaults to log.Log global logger. logger logr.Logger - // leaderElectionCancel is used to cancel the leader election. It is distinct from internalStopper, - // because for safety reasons we need to os.Exit() when we lose the leader election, meaning that - // it must be deferred until after gracefulShutdown is done. - leaderElectionCancel context.CancelFunc - // leaderElectionStopped is an internal channel used to signal the stopping procedure that the // LeaderElection.Run(...) function has returned and the shutdown can proceed. leaderElectionStopped chan struct{} - // stop procedure engaged. In other words, we should not add anything else to the manager - stopProcedureEngaged bool + // leaderElectionCancel is used to cancel the leader election. It is distinct from internalStopper, + // because for safety reasons we need to os.Exit() when we lose the leader election, meaning that + // it must be deferred until after gracefulShutdown is done. + leaderElectionCancel context.CancelFunc // elected is closed when this manager becomes the leader of a group of // managers, either because it won a leader election or because no leader // election was configured. elected chan struct{} - caches []hasCache - // port is the port that the webhook server serves at. port int // host is the hostname that the webhook server binds to. @@ -160,10 +151,6 @@ type controllerManager struct { // between tries of actions. retryPeriod time.Duration - // waitForRunnable is holding the number of runnables currently running so that - // we can wait for them to exit before quitting the manager - waitForRunnable sync.WaitGroup - // gracefulShutdownTimeout is the duration given to runnable to stop // before the manager actually returns on stop. gracefulShutdownTimeout time.Duration @@ -192,36 +179,17 @@ type hasCache interface { // Add sets dependencies on i, and adds it to the list of Runnables to start. func (cm *controllerManager) Add(r Runnable) error { - cm.mu.Lock() - defer cm.mu.Unlock() - if cm.stopProcedureEngaged { - return errors.New("can't accept new runnable as stop procedure is already engaged") - } + cm.Lock() + defer cm.Unlock() + return cm.add(r) +} +func (cm *controllerManager) add(r Runnable) error { // Set dependencies on the object if err := cm.SetFields(r); err != nil { return err } - - var shouldStart bool - - // Add the runnable to the leader election or the non-leaderelection list - if leRunnable, ok := r.(LeaderElectionRunnable); ok && !leRunnable.NeedLeaderElection() { - shouldStart = cm.started - cm.nonLeaderElectionRunnables = append(cm.nonLeaderElectionRunnables, r) - } else if hasCache, ok := r.(hasCache); ok { - cm.caches = append(cm.caches, hasCache) - } else { - shouldStart = cm.startedLeader - cm.leaderElectionRunnables = append(cm.leaderElectionRunnables, r) - } - - if shouldStart { - // If already started, start the controller - cm.startRunnable(r) - } - - return nil + return cm.runnables.Add(r) } // Deprecated: use the equivalent Options field to set a field. This method will be removed in v0.10. @@ -244,13 +212,17 @@ func (cm *controllerManager) SetFields(i interface{}) error { // AddMetricsExtraHandler adds extra handler served on path to the http server that serves metrics. func (cm *controllerManager) AddMetricsExtraHandler(path string, handler http.Handler) error { + cm.Lock() + defer cm.Unlock() + + if cm.started { + return fmt.Errorf("unable to add new metrics handler because metrics endpoint has already been created") + } + if path == defaultMetricsEndpoint { return fmt.Errorf("overriding builtin %s endpoint is not allowed", defaultMetricsEndpoint) } - cm.mu.Lock() - defer cm.mu.Unlock() - if _, found := cm.metricsExtraHandlers[path]; found { return fmt.Errorf("can't register extra handler by duplicate path %q on metrics http server", path) } @@ -262,14 +234,10 @@ func (cm *controllerManager) AddMetricsExtraHandler(path string, handler http.Ha // AddHealthzCheck allows you to add Healthz checker. func (cm *controllerManager) AddHealthzCheck(name string, check healthz.Checker) error { - cm.mu.Lock() - defer cm.mu.Unlock() + cm.Lock() + defer cm.Unlock() - if cm.stopProcedureEngaged { - return errors.New("can't accept new healthCheck as stop procedure is already engaged") - } - - if cm.healthzStarted { + if cm.started { return fmt.Errorf("unable to add new checker because healthz endpoint has already been created") } @@ -283,15 +251,11 @@ func (cm *controllerManager) AddHealthzCheck(name string, check healthz.Checker) // AddReadyzCheck allows you to add Readyz checker. func (cm *controllerManager) AddReadyzCheck(name string, check healthz.Checker) error { - cm.mu.Lock() - defer cm.mu.Unlock() - - if cm.stopProcedureEngaged { - return errors.New("can't accept new ready check as stop procedure is already engaged") - } + cm.Lock() + defer cm.Unlock() - if cm.healthzStarted { - return fmt.Errorf("unable to add new checker because readyz endpoint has already been created") + if cm.started { + return fmt.Errorf("unable to add new checker because healthz endpoint has already been created") } if cm.readyzHandler == nil { @@ -344,7 +308,7 @@ func (cm *controllerManager) GetWebhookServer() *webhook.Server { } } if err := cm.Add(cm.webhookServer); err != nil { - panic("unable to add webhook server to the controller manager") + panic(fmt.Sprintf("unable to add webhook server to the controller manager: %s", err)) } }) return cm.webhookServer @@ -365,77 +329,89 @@ func (cm *controllerManager) serveMetrics() { // TODO(JoelSpeed): Use existing Kubernetes machinery for serving metrics mux := http.NewServeMux() mux.Handle(defaultMetricsEndpoint, handler) - - func() { - cm.mu.Lock() - defer cm.mu.Unlock() - - for path, extraHandler := range cm.metricsExtraHandlers { - mux.Handle(path, extraHandler) - } - }() - - server := http.Server{ - Handler: mux, + for path, extraHandler := range cm.metricsExtraHandlers { + mux.Handle(path, extraHandler) } - // Run the server - cm.startRunnable(RunnableFunc(func(_ context.Context) error { - cm.logger.Info("starting metrics server", "path", defaultMetricsEndpoint) - if err := server.Serve(cm.metricsListener); err != nil && err != http.ErrServerClosed { - return err - } - return nil - })) - // Shutdown the server when stop is closed - <-cm.internalProceduresStop - if err := server.Shutdown(cm.shutdownCtx); err != nil { - cm.errChan <- err - } + server := httpserver.New(mux) + go cm.httpServe("metrics", cm.logger.WithValues("path", defaultMetricsEndpoint), server, cm.metricsListener) } func (cm *controllerManager) serveHealthProbes() { mux := http.NewServeMux() - server := http.Server{ - Handler: mux, + server := httpserver.New(mux) + + if cm.readyzHandler != nil { + mux.Handle(cm.readinessEndpointName, http.StripPrefix(cm.readinessEndpointName, cm.readyzHandler)) + // Append '/' suffix to handle subpaths + mux.Handle(cm.readinessEndpointName+"/", http.StripPrefix(cm.readinessEndpointName, cm.readyzHandler)) + } + if cm.healthzHandler != nil { + mux.Handle(cm.livenessEndpointName, http.StripPrefix(cm.livenessEndpointName, cm.healthzHandler)) + // Append '/' suffix to handle subpaths + mux.Handle(cm.livenessEndpointName+"/", http.StripPrefix(cm.livenessEndpointName, cm.healthzHandler)) } - func() { - cm.mu.Lock() - defer cm.mu.Unlock() + go cm.httpServe("health probe", cm.logger, server, cm.healthProbeListener) +} - if cm.readyzHandler != nil { - mux.Handle(cm.readinessEndpointName, http.StripPrefix(cm.readinessEndpointName, cm.readyzHandler)) - // Append '/' suffix to handle subpaths - mux.Handle(cm.readinessEndpointName+"/", http.StripPrefix(cm.readinessEndpointName, cm.readyzHandler)) - } - if cm.healthzHandler != nil { - mux.Handle(cm.livenessEndpointName, http.StripPrefix(cm.livenessEndpointName, cm.healthzHandler)) - // Append '/' suffix to handle subpaths - mux.Handle(cm.livenessEndpointName+"/", http.StripPrefix(cm.livenessEndpointName, cm.healthzHandler)) - } +func (cm *controllerManager) httpServe(kind string, log logr.Logger, server *http.Server, ln net.Listener) { + log = log.WithValues("kind", kind, "addr", ln.Addr()) - // Run server - cm.startRunnable(RunnableFunc(func(_ context.Context) error { - if err := server.Serve(cm.healthProbeListener); err != nil && err != http.ErrServerClosed { - return err + go func() { + log.Info("Starting server") + if err := server.Serve(ln); err != nil { + if errors.Is(err, http.ErrServerClosed) { + return } - return nil - })) - cm.healthzStarted = true + if atomic.LoadInt64(cm.stopProcedureEngaged) > 0 { + // There might be cases where connections are still open and we try to shutdown + // but not having enough time to close the connection causes an error in Serve + // + // In that case we want to avoid returning an error to the main error channel. + log.Error(err, "error on Serve after stop has been engaged") + return + } + cm.errChan <- err + } }() - // Shutdown the server when stop is closed + // Shutdown the server when stop is closed. <-cm.internalProceduresStop if err := server.Shutdown(cm.shutdownCtx); err != nil { + if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) { + // Avoid logging context related errors. + return + } + if atomic.LoadInt64(cm.stopProcedureEngaged) > 0 { + cm.logger.Error(err, "error on Shutdown after stop has been engaged") + return + } cm.errChan <- err } } +// Start starts the manager and waits indefinitely. +// There is only two ways to have start return: +// An error has occurred during in one of the internal operations, +// such as leader election, cache start, webhooks, and so on. +// Or, the context is cancelled. func (cm *controllerManager) Start(ctx context.Context) (err error) { - if err := cm.Add(cm.cluster); err != nil { - return fmt.Errorf("failed to add cluster to runnables: %w", err) + cm.Lock() + if cm.started { + cm.Unlock() + return errors.New("manager already started") } + var ready bool + defer func() { + // Only unlock the manager if we haven't reached + // the internal readiness condition. + if !ready { + cm.Unlock() + } + }() + + // Initialize the internal context. cm.internalCtx, cm.internalCancel = context.WithCancel(ctx) // This chan indicates that stop is complete, in other words all runnables have returned or timeout on stop request @@ -457,40 +433,70 @@ func (cm *controllerManager) Start(ctx context.Context) (err error) { } }() - // initialize this here so that we reset the signal channel state on every start - // Everything that might write into this channel must be started in a new goroutine, - // because otherwise we might block this routine trying to write into the full channel - // and will not be able to enter the deferred cm.engageStopProcedure() which drains - // it. - cm.errChan = make(chan error) + // Add the cluster runnable. + if err := cm.add(cm.cluster); err != nil { + return fmt.Errorf("failed to add cluster to runnables: %w", err) + } // Metrics should be served whether the controller is leader or not. // (If we don't serve metrics for non-leaders, prometheus will still scrape - // the pod but will get a connection refused) + // the pod but will get a connection refused). if cm.metricsListener != nil { - go cm.serveMetrics() + cm.serveMetrics() } - // Serve health probes + // Serve health probes. if cm.healthProbeListener != nil { - go cm.serveHealthProbes() + cm.serveHealthProbes() + } + + // First start any webhook servers, which includes conversion, validation, and defaulting + // webhooks that are registered. + // + // WARNING: Webhooks MUST start before any cache is populated, otherwise there is a race condition + // between conversion webhooks and the cache sync (usually initial list) which causes the webhooks + // to never start because no cache can be populated. + if err := cm.runnables.Webhooks.Start(cm.internalCtx); err != nil { + if err != wait.ErrWaitTimeout { + return err + } } - go cm.startNonLeaderElectionRunnables() + // Start and wait for caches. + if err := cm.runnables.Caches.Start(cm.internalCtx); err != nil { + if err != wait.ErrWaitTimeout { + return err + } + } - go func() { - if cm.resourceLock != nil { - err := cm.startLeaderElection() - if err != nil { - cm.errChan <- err - } - } else { - // Treat not having leader election enabled the same as being elected. - cm.startLeaderElectionRunnables() - close(cm.elected) + // Start the non-leaderelection Runnables after the cache has synced. + if err := cm.runnables.Others.Start(cm.internalCtx); err != nil { + if err != wait.ErrWaitTimeout { + return err } - }() + } + + // Start the leader election and all required runnables. + { + ctx, cancel := context.WithCancel(context.Background()) + cm.leaderElectionCancel = cancel + go func() { + if cm.resourceLock != nil { + if err := cm.startLeaderElection(ctx); err != nil { + cm.errChan <- err + } + } else { + // Treat not having leader election enabled the same as being elected. + if err := cm.startLeaderElectionRunnables(); err != nil { + cm.errChan <- err + } + close(cm.elected) + } + }() + } + ready = true + cm.Unlock() select { case <-ctx.Done(): // We are done @@ -504,24 +510,31 @@ func (cm *controllerManager) Start(ctx context.Context) (err error) { // engageStopProcedure signals all runnables to stop, reads potential errors // from the errChan and waits for them to end. It must not be called more than once. func (cm *controllerManager) engageStopProcedure(stopComplete <-chan struct{}) error { - // Populate the shutdown context. - var shutdownCancel context.CancelFunc - if cm.gracefulShutdownTimeout > 0 { - cm.shutdownCtx, shutdownCancel = context.WithTimeout(context.Background(), cm.gracefulShutdownTimeout) - } else { - cm.shutdownCtx, shutdownCancel = context.WithCancel(context.Background()) + if !atomic.CompareAndSwapInt64(cm.stopProcedureEngaged, 0, 1) { + return errors.New("stop procedure already engaged") } - defer shutdownCancel() - // Cancel the internal stop channel and wait for the procedures to stop and complete. - close(cm.internalProceduresStop) - cm.internalCancel() + // Populate the shutdown context, this operation MUST be done before + // closing the internalProceduresStop channel. + // + // The shutdown context immediately expires if the gracefulShutdownTimeout is not set. + var shutdownCancel context.CancelFunc + cm.shutdownCtx, shutdownCancel = context.WithTimeout(context.Background(), cm.gracefulShutdownTimeout) + defer shutdownCancel() // Start draining the errors before acquiring the lock to make sure we don't deadlock // if something that has the lock is blocked on trying to write into the unbuffered // channel after something else already wrote into it. + var closeOnce sync.Once go func() { for { + // Closing in the for loop is required to avoid race conditions between + // the closure of all internal procedures and making sure to have a reader off the error channel. + closeOnce.Do(func() { + // Cancel the internal stop channel and wait for the procedures to stop and complete. + close(cm.internalProceduresStop) + cm.internalCancel() + }) select { case err, ok := <-cm.errChan: if ok { @@ -532,26 +545,14 @@ func (cm *controllerManager) engageStopProcedure(stopComplete <-chan struct{}) e } } }() - if cm.gracefulShutdownTimeout == 0 { - return nil - } - cm.mu.Lock() - defer cm.mu.Unlock() - cm.stopProcedureEngaged = true - // we want to close this after the other runnables stop, because we don't + // We want to close this after the other runnables stop, because we don't // want things like leader election to try and emit events on a closed // channel defer cm.recorderProvider.Stop(cm.shutdownCtx) - return cm.waitForRunnableToEnd(shutdownCancel) -} - -// waitForRunnableToEnd blocks until all runnables ended or the -// tearDownTimeout was reached. In the latter case, an error is returned. -func (cm *controllerManager) waitForRunnableToEnd(shutdownCancel context.CancelFunc) (retErr error) { - // Cancel leader election only after we waited. It will os.Exit() the app for safety. defer func() { - if retErr == nil && cm.leaderElectionCancel != nil { + // Cancel leader election only after we waited. It will os.Exit() the app for safety. + if cm.resourceLock != nil { // After asking the context to be cancelled, make sure // we wait for the leader stopped channel to be closed, otherwise // we might encounter race conditions between this code @@ -562,102 +563,48 @@ func (cm *controllerManager) waitForRunnableToEnd(shutdownCancel context.CancelF }() go func() { - cm.waitForRunnable.Wait() + // First stop the non-leader election runnables. + cm.logger.Info("Stopping and waiting for non leader election runnables") + cm.runnables.Others.StopAndWait(cm.shutdownCtx) + + // Stop all the leader election runnables, which includes reconcilers. + cm.logger.Info("Stopping and waiting for leader election runnables") + cm.runnables.LeaderElection.StopAndWait(cm.shutdownCtx) + + // Stop the caches before the leader election runnables, this is an important + // step to make sure that we don't race with the reconcilers by receiving more events + // from the API servers and enqueueing them. + cm.logger.Info("Stopping and waiting for caches") + cm.runnables.Caches.StopAndWait(cm.shutdownCtx) + + // Webhooks should come last, as they might be still serving some requests. + cm.logger.Info("Stopping and waiting for webhooks") + cm.runnables.Webhooks.StopAndWait(cm.shutdownCtx) + + // Proceed to close the manager and overall shutdown context. + cm.logger.Info("Wait completed, proceeding to shutdown the manager") shutdownCancel() }() <-cm.shutdownCtx.Done() if err := cm.shutdownCtx.Err(); err != nil && err != context.Canceled { - return fmt.Errorf("failed waiting for all runnables to end within grace period of %s: %w", cm.gracefulShutdownTimeout, err) - } - return nil -} - -func (cm *controllerManager) startNonLeaderElectionRunnables() { - cm.mu.Lock() - defer cm.mu.Unlock() - - // First start any webhook servers, which includes conversion, validation, and defaulting - // webhooks that are registered. - // - // WARNING: Webhooks MUST start before any cache is populated, otherwise there is a race condition - // between conversion webhooks and the cache sync (usually initial list) which causes the webhooks - // to never start because no cache can be populated. - for _, c := range cm.nonLeaderElectionRunnables { - if _, ok := c.(*webhook.Server); ok { - cm.startRunnable(c) - } - } - - // Start and wait for caches. - cm.waitForCache(cm.internalCtx) - - // Start the non-leaderelection Runnables after the cache has synced - for _, c := range cm.nonLeaderElectionRunnables { - if _, ok := c.(*webhook.Server); ok { - continue + if errors.Is(err, context.DeadlineExceeded) { + if cm.gracefulShutdownTimeout > 0 { + return fmt.Errorf("failed waiting for all runnables to end within grace period of %s: %w", cm.gracefulShutdownTimeout, err) + } + return nil } - - // Controllers block, but we want to return an error if any have an error starting. - // Write any Start errors to a channel so we can return them - cm.startRunnable(c) - } -} - -func (cm *controllerManager) startLeaderElectionRunnables() { - cm.mu.Lock() - defer cm.mu.Unlock() - - cm.waitForCache(cm.internalCtx) - - // Start the leader election Runnables after the cache has synced - for _, c := range cm.leaderElectionRunnables { - // Controllers block, but we want to return an error if any have an error starting. - // Write any Start errors to a channel so we can return them - cm.startRunnable(c) + // For any other error, return the error. + return err } - - cm.startedLeader = true + return nil } -func (cm *controllerManager) waitForCache(ctx context.Context) { - if cm.started { - return - } - - for _, cache := range cm.caches { - cm.startRunnable(cache) - } - - // Wait for the caches to sync. - // TODO(community): Check the return value and write a test - for _, cache := range cm.caches { - cache.GetCache().WaitForCacheSync(ctx) - } - // TODO: This should be the return value of cm.cache.WaitForCacheSync but we abuse - // cm.started as check if we already started the cache so it must always become true. - // Making sure that the cache doesn't get started twice is needed to not get a "close - // of closed channel" panic - cm.started = true +func (cm *controllerManager) startLeaderElectionRunnables() error { + return cm.runnables.LeaderElection.Start(cm.internalCtx) } -func (cm *controllerManager) startLeaderElection() (err error) { - ctx, cancel := context.WithCancel(context.Background()) - cm.mu.Lock() - cm.leaderElectionCancel = cancel - cm.mu.Unlock() - - if cm.onStoppedLeading == nil { - cm.onStoppedLeading = func() { - // Make sure graceful shutdown is skipped if we lost the leader lock without - // intending to. - cm.gracefulShutdownTimeout = time.Duration(0) - // Most implementations of leader election log.Fatal() here. - // Since Start is wrapped in log.Fatal when called, we can just return - // an error here which will cause the program to exit. - cm.errChan <- errors.New("leader election lost") - } - } +func (cm *controllerManager) startLeaderElection(ctx context.Context) (err error) { l, err := leaderelection.NewLeaderElector(leaderelection.LeaderElectionConfig{ Lock: cm.resourceLock, LeaseDuration: cm.leaseDuration, @@ -665,10 +612,24 @@ func (cm *controllerManager) startLeaderElection() (err error) { RetryPeriod: cm.retryPeriod, Callbacks: leaderelection.LeaderCallbacks{ OnStartedLeading: func(_ context.Context) { - cm.startLeaderElectionRunnables() + if err := cm.startLeaderElectionRunnables(); err != nil { + cm.errChan <- err + return + } close(cm.elected) }, - OnStoppedLeading: cm.onStoppedLeading, + OnStoppedLeading: func() { + if cm.onStoppedLeading != nil { + cm.onStoppedLeading() + } + // Make sure graceful shutdown is skipped if we lost the leader lock without + // intending to. + cm.gracefulShutdownTimeout = time.Duration(0) + // Most implementations of leader election log.Fatal() here. + // Since Start is wrapped in log.Fatal when called, we can just return + // an error here which will cause the program to exit. + cm.errChan <- errors.New("leader election lost") + }, }, ReleaseOnCancel: cm.leaderElectionReleaseOnCancel, }) @@ -688,13 +649,3 @@ func (cm *controllerManager) startLeaderElection() (err error) { func (cm *controllerManager) Elected() <-chan struct{} { return cm.elected } - -func (cm *controllerManager) startRunnable(r Runnable) { - cm.waitForRunnable.Add(1) - go func() { - defer cm.waitForRunnable.Done() - if err := r.Start(cm.internalCtx); err != nil { - cm.errChan <- err - } - }() -} diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/manager.go b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/manager.go index 2d2733f0a6..05edcdbb5a 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/manager.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/manager.go @@ -31,6 +31,7 @@ import ( "k8s.io/client-go/rest" "k8s.io/client-go/tools/leaderelection/resourcelock" "k8s.io/client-go/tools/record" + "k8s.io/utils/pointer" "sigs.k8s.io/controller-runtime/pkg/cache" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/cluster" @@ -365,8 +366,14 @@ func New(config *rest.Config, options Options) (Manager, error) { return nil, err } + errChan := make(chan error) + runnables := newRunnables(errChan) + return &controllerManager{ + stopProcedureEngaged: pointer.Int64(0), cluster: cluster, + runnables: runnables, + errChan: errChan, recorderProvider: recorderProvider, resourceLock: resourceLock, metricsListener: metricsListener, @@ -571,7 +578,7 @@ func setOptionsDefaults(options Options) Options { options.GracefulShutdownTimeout = &gracefulShutdownTimeout } - if options.Logger == nil { + if options.Logger.GetSink() == nil { options.Logger = log.Log } diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/runnable_group.go b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/runnable_group.go new file mode 100644 index 0000000000..ded8aed221 --- /dev/null +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/runnable_group.go @@ -0,0 +1,296 @@ +package manager + +import ( + "context" + "errors" + "sync" + + "sigs.k8s.io/controller-runtime/pkg/webhook" +) + +var ( + errRunnableGroupStopped = errors.New("can't accept new runnable as stop procedure is already engaged") +) + +// readyRunnable encapsulates a runnable with +// a ready check. +type readyRunnable struct { + Runnable + Check runnableCheck + signalReady bool +} + +// runnableCheck can be passed to Add() to let the runnable group determine that a +// runnable is ready. A runnable check should block until a runnable is ready, +// if the returned result is false, the runnable is considered not ready and failed. +type runnableCheck func(ctx context.Context) bool + +// runnables handles all the runnables for a manager by grouping them accordingly to their +// type (webhooks, caches etc.). +type runnables struct { + Webhooks *runnableGroup + Caches *runnableGroup + LeaderElection *runnableGroup + Others *runnableGroup +} + +// newRunnables creates a new runnables object. +func newRunnables(errChan chan error) *runnables { + return &runnables{ + Webhooks: newRunnableGroup(errChan), + Caches: newRunnableGroup(errChan), + LeaderElection: newRunnableGroup(errChan), + Others: newRunnableGroup(errChan), + } +} + +// Add adds a runnable to closest group of runnable that they belong to. +// +// Add should be able to be called before and after Start, but not after StopAndWait. +// Add should return an error when called during StopAndWait. +// The runnables added before Start are started when Start is called. +// The runnables added after Start are started directly. +func (r *runnables) Add(fn Runnable) error { + switch runnable := fn.(type) { + case hasCache: + return r.Caches.Add(fn, func(ctx context.Context) bool { + return runnable.GetCache().WaitForCacheSync(ctx) + }) + case *webhook.Server: + return r.Webhooks.Add(fn, nil) + case LeaderElectionRunnable: + if !runnable.NeedLeaderElection() { + return r.Others.Add(fn, nil) + } + return r.LeaderElection.Add(fn, nil) + default: + return r.LeaderElection.Add(fn, nil) + } +} + +// runnableGroup manages a group of runnables that are +// meant to be running together until StopAndWait is called. +// +// Runnables can be added to a group after the group has started +// but not after it's stopped or while shutting down. +type runnableGroup struct { + ctx context.Context + cancel context.CancelFunc + + start sync.Mutex + startOnce sync.Once + started bool + startQueue []*readyRunnable + startReadyCh chan *readyRunnable + + stop sync.RWMutex + stopOnce sync.Once + stopped bool + + // errChan is the error channel passed by the caller + // when the group is created. + // All errors are forwarded to this channel once they occur. + errChan chan error + + // ch is the internal channel where the runnables are read off from. + ch chan *readyRunnable + + // wg is an internal sync.WaitGroup that allows us to properly stop + // and wait for all the runnables to finish before returning. + wg *sync.WaitGroup +} + +func newRunnableGroup(errChan chan error) *runnableGroup { + r := &runnableGroup{ + startReadyCh: make(chan *readyRunnable), + errChan: errChan, + ch: make(chan *readyRunnable), + wg: new(sync.WaitGroup), + } + r.ctx, r.cancel = context.WithCancel(context.Background()) + return r +} + +// Started returns true if the group has started. +func (r *runnableGroup) Started() bool { + r.start.Lock() + defer r.start.Unlock() + return r.started +} + +// Start starts the group and waits for all +// initially registered runnables to start. +// It can only be called once, subsequent calls have no effect. +func (r *runnableGroup) Start(ctx context.Context) error { + var retErr error + + r.startOnce.Do(func() { + defer close(r.startReadyCh) + + // Start the internal reconciler. + go r.reconcile() + + // Start the group and queue up all + // the runnables that were added prior. + r.start.Lock() + r.started = true + for _, rn := range r.startQueue { + rn.signalReady = true + r.ch <- rn + } + r.start.Unlock() + + // If we don't have any queue, return. + if len(r.startQueue) == 0 { + return + } + + // Wait for all runnables to signal. + for { + select { + case <-ctx.Done(): + if err := ctx.Err(); !errors.Is(err, context.Canceled) { + retErr = err + } + case rn := <-r.startReadyCh: + for i, existing := range r.startQueue { + if existing == rn { + // Remove the item from the start queue. + r.startQueue = append(r.startQueue[:i], r.startQueue[i+1:]...) + break + } + } + // We're done waiting if the queue is empty, return. + if len(r.startQueue) == 0 { + return + } + } + } + }) + + return retErr +} + +// reconcile is our main entrypoint for every runnable added +// to this group. Its primary job is to read off the internal channel +// and schedule runnables while tracking their state. +func (r *runnableGroup) reconcile() { + for runnable := range r.ch { + // Handle stop. + // If the shutdown has been called we want to avoid + // adding new goroutines to the WaitGroup because Wait() + // panics if Add() is called after it. + { + r.stop.RLock() + if r.stopped { + // Drop any runnables if we're stopped. + r.errChan <- errRunnableGroupStopped + r.stop.RUnlock() + continue + } + + // Why is this here? + // When StopAndWait is called, if a runnable is in the process + // of being added, we could end up in a situation where + // the WaitGroup is incremented while StopAndWait has called Wait(), + // which would result in a panic. + r.wg.Add(1) + r.stop.RUnlock() + } + + // Start the runnable. + go func(rn *readyRunnable) { + go func() { + if rn.Check(r.ctx) { + if rn.signalReady { + r.startReadyCh <- rn + } + } + }() + + // If we return, the runnable ended cleanly + // or returned an error to the channel. + // + // We should always decrement the WaitGroup here. + defer r.wg.Done() + + // Start the runnable. + if err := rn.Start(r.ctx); err != nil { + r.errChan <- err + } + }(runnable) + } +} + +// Add should be able to be called before and after Start, but not after StopAndWait. +// Add should return an error when called during StopAndWait. +func (r *runnableGroup) Add(rn Runnable, ready runnableCheck) error { + r.stop.RLock() + if r.stopped { + r.stop.RUnlock() + return errRunnableGroupStopped + } + r.stop.RUnlock() + + if ready == nil { + ready = func(_ context.Context) bool { return true } + } + + readyRunnable := &readyRunnable{ + Runnable: rn, + Check: ready, + } + + // Handle start. + // If the overall runnable group isn't started yet + // we want to buffer the runnables and let Start() + // queue them up again later. + { + r.start.Lock() + + // Check if we're already started. + if !r.started { + // Store the runnable in the internal if not. + r.startQueue = append(r.startQueue, readyRunnable) + r.start.Unlock() + return nil + } + r.start.Unlock() + } + + // Enqueue the runnable. + r.ch <- readyRunnable + return nil +} + +// StopAndWait waits for all the runnables to finish before returning. +func (r *runnableGroup) StopAndWait(ctx context.Context) { + r.stopOnce.Do(func() { + // Close the reconciler channel once we're done. + defer close(r.ch) + + _ = r.Start(ctx) + r.stop.Lock() + // Store the stopped variable so we don't accept any new + // runnables for the time being. + r.stopped = true + r.stop.Unlock() + + // Cancel the internal channel. + r.cancel() + + done := make(chan struct{}) + go func() { + defer close(done) + // Wait for all the runnables to finish. + r.wg.Wait() + }() + + select { + case <-done: + // We're done, exit. + case <-ctx.Done(): + // Calling context has expired, exit. + } + }) +} diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal.go b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal.go index 9a85558f82..a79cfb42df 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal.go @@ -24,8 +24,8 @@ import ( var onlyOneSignalHandler = make(chan struct{}) -// SetupSignalHandler registers for SIGTERM and SIGINT. A stop channel is returned -// which is closed on one of these signals. If a second signal is caught, the program +// SetupSignalHandler registers for SIGTERM and SIGINT. A context is returned +// which is canceled on one of these signals. If a second signal is caught, the program // is terminated with exit code 1. func SetupSignalHandler() context.Context { close(onlyOneSignalHandler) // panics when called twice diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/listener.go b/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/listener.go index d32ae58186..123d8c15f9 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/listener.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/listener.go @@ -41,7 +41,7 @@ func NewListener(addr string) (net.Listener, error) { return nil, nil } - log.Info("metrics server is starting to listen", "addr", addr) + log.Info("Metrics server is starting to listen", "addr", addr) ln, err := net.Listen("tcp", addr) if err != nil { er := fmt.Errorf("error listening on %s: %w", addr, err) diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/reconcile/reconcile.go b/vendor/sigs.k8s.io/controller-runtime/pkg/reconcile/reconcile.go index b2159c531f..b044e65948 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/reconcile/reconcile.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/reconcile/reconcile.go @@ -87,7 +87,7 @@ For example if responding to a Pod Delete Event, the Request won't contain that instead the reconcile function observes this when reading the cluster state and seeing the Pod as missing. */ type Reconciler interface { - // Reconciler performs a full reconciliation for the object referred to by the Request. + // Reconcile performs a full reconciliation for the object referred to by the Request. // The Controller will requeue the Request to be processed again if an error is non-nil or // Result.Requeue is true, otherwise upon completion it will remove the work from the queue. Reconcile(context.Context, Request) (Result, error) diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/source/source.go b/vendor/sigs.k8s.io/controller-runtime/pkg/source/source.go index a63b37c443..8f649eaac4 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/source/source.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/source/source.go @@ -21,8 +21,10 @@ import ( "errors" "fmt" "sync" + "time" "k8s.io/apimachinery/pkg/api/meta" + "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/util/workqueue" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" @@ -119,17 +121,34 @@ func (ks *Kind) Start(ctx context.Context, handler handler.EventHandler, queue w ctx, ks.startCancel = context.WithCancel(ctx) ks.started = make(chan error) go func() { - // Lookup the Informer from the Cache and add an EventHandler which populates the Queue - i, err := ks.cache.GetInformer(ctx, ks.Type) - if err != nil { - kindMatchErr := &meta.NoKindMatchError{} - if errors.As(err, &kindMatchErr) { - log.Error(err, "if kind is a CRD, it should be installed before calling Start", - "kind", kindMatchErr.GroupKind) + var ( + i cache.Informer + lastErr error + ) + + // Tries to get an informer until it returns true, + // an error or the specified context is cancelled or expired. + if err := wait.PollImmediateUntilWithContext(ctx, 10*time.Second, func(ctx context.Context) (bool, error) { + // Lookup the Informer from the Cache and add an EventHandler which populates the Queue + i, lastErr = ks.cache.GetInformer(ctx, ks.Type) + if lastErr != nil { + kindMatchErr := &meta.NoKindMatchError{} + if errors.As(lastErr, &kindMatchErr) { + log.Error(lastErr, "if kind is a CRD, it should be installed before calling Start", + "kind", kindMatchErr.GroupKind) + } + return false, nil // Retry. + } + return true, nil + }); err != nil { + if lastErr != nil { + ks.started <- fmt.Errorf("failed to get informer from cache: %w", lastErr) + return } ks.started <- err return } + i.AddEventHandler(internal.EventHandler{Queue: queue, EventHandler: handler, Predicates: prct}) if !ks.cache.WaitForCacheSync(ctx) { // Would be great to return something more informative here @@ -142,10 +161,10 @@ func (ks *Kind) Start(ctx context.Context, handler handler.EventHandler, queue w } func (ks *Kind) String() string { - if ks.Type != nil && ks.Type.GetObjectKind() != nil { - return fmt.Sprintf("kind source: %v", ks.Type.GetObjectKind().GroupVersionKind().String()) + if ks.Type != nil { + return fmt.Sprintf("kind source: %T", ks.Type) } - return "kind source: unknown GVK" + return "kind source: unknown type" } // WaitForSync implements SyncingSource to allow controllers to wait with starting diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/defaulter_custom.go b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/defaulter_custom.go new file mode 100644 index 0000000000..a012784e43 --- /dev/null +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/defaulter_custom.go @@ -0,0 +1,85 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package admission + +import ( + "context" + "encoding/json" + + "errors" + "net/http" + + apierrors "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/runtime" +) + +// CustomDefaulter defines functions for setting defaults on resources. +type CustomDefaulter interface { + Default(ctx context.Context, obj runtime.Object) error +} + +// WithCustomDefaulter creates a new Webhook for a CustomDefaulter interface. +func WithCustomDefaulter(obj runtime.Object, defaulter CustomDefaulter) *Webhook { + return &Webhook{ + Handler: &defaulterForType{object: obj, defaulter: defaulter}, + } +} + +type defaulterForType struct { + defaulter CustomDefaulter + object runtime.Object + decoder *Decoder +} + +var _ DecoderInjector = &defaulterForType{} + +func (h *defaulterForType) InjectDecoder(d *Decoder) error { + h.decoder = d + return nil +} + +// Handle handles admission requests. +func (h *defaulterForType) Handle(ctx context.Context, req Request) Response { + if h.defaulter == nil { + panic("defaulter should never be nil") + } + if h.object == nil { + panic("object should never be nil") + } + + // Get the object in the request + obj := h.object.DeepCopyObject() + if err := h.decoder.Decode(req, obj); err != nil { + return Errored(http.StatusBadRequest, err) + } + + // Default the object + if err := h.defaulter.Default(ctx, obj); err != nil { + var apiStatus apierrors.APIStatus + if errors.As(err, &apiStatus) { + return validationResponseFromStatus(false, apiStatus.Status()) + } + return Denied(err.Error()) + } + + // Create the patch + marshalled, err := json.Marshal(obj) + if err != nil { + return Errored(http.StatusInternalServerError, err) + } + return PatchResponseFromRaw(req.Object.Raw, marshalled) +} diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/validator_custom.go b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/validator_custom.go new file mode 100644 index 0000000000..38d5565111 --- /dev/null +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/validator_custom.go @@ -0,0 +1,111 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package admission + +import ( + "context" + "errors" + "fmt" + "net/http" + + v1 "k8s.io/api/admission/v1" + apierrors "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/runtime" +) + +// CustomValidator defines functions for validating an operation. +type CustomValidator interface { + ValidateCreate(ctx context.Context, obj runtime.Object) error + ValidateUpdate(ctx context.Context, oldObj, newObj runtime.Object) error + ValidateDelete(ctx context.Context, obj runtime.Object) error +} + +// WithCustomValidator creates a new Webhook for validating the provided type. +func WithCustomValidator(obj runtime.Object, validator CustomValidator) *Webhook { + return &Webhook{ + Handler: &validatorForType{object: obj, validator: validator}, + } +} + +type validatorForType struct { + validator CustomValidator + object runtime.Object + decoder *Decoder +} + +var _ DecoderInjector = &validatorForType{} + +// InjectDecoder injects the decoder into a validatingHandler. +func (h *validatorForType) InjectDecoder(d *Decoder) error { + h.decoder = d + return nil +} + +// Handle handles admission requests. +func (h *validatorForType) Handle(ctx context.Context, req Request) Response { + if h.validator == nil { + panic("validator should never be nil") + } + if h.object == nil { + panic("object should never be nil") + } + + // Get the object in the request + obj := h.object.DeepCopyObject() + + var err error + switch req.Operation { + case v1.Create: + if err := h.decoder.Decode(req, obj); err != nil { + return Errored(http.StatusBadRequest, err) + } + + err = h.validator.ValidateCreate(ctx, obj) + case v1.Update: + oldObj := obj.DeepCopyObject() + if err := h.decoder.DecodeRaw(req.Object, obj); err != nil { + return Errored(http.StatusBadRequest, err) + } + if err := h.decoder.DecodeRaw(req.OldObject, oldObj); err != nil { + return Errored(http.StatusBadRequest, err) + } + + err = h.validator.ValidateUpdate(ctx, oldObj, obj) + case v1.Delete: + // In reference to PR: https://github.com/kubernetes/kubernetes/pull/76346 + // OldObject contains the object being deleted + if err := h.decoder.DecodeRaw(req.OldObject, obj); err != nil { + return Errored(http.StatusBadRequest, err) + } + + err = h.validator.ValidateDelete(ctx, obj) + default: + return Errored(http.StatusBadRequest, fmt.Errorf("unknown operation request %q", req.Operation)) + } + + // Check the error message first. + if err != nil { + var apiStatus apierrors.APIStatus + if errors.As(err, &apiStatus) { + return validationResponseFromStatus(false, apiStatus.Status()) + } + return Denied(err.Error()) + } + + // Return allowed if everything succeeded. + return Allowed("") +} diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/webhook.go b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/webhook.go index cf7dbcf68d..3dcff5fadd 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/webhook.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/webhook.go @@ -243,7 +243,7 @@ func StandaloneWebhook(hook *Webhook, opts StandaloneOptions) (http.Handler, err return nil, err } - if opts.Logger == nil { + if opts.Logger.GetSink() == nil { opts.Logger = logf.RuntimeLog.WithName("webhook") } hook.log = opts.Logger diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/alias.go b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/alias.go index 1a831016af..293137db49 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/alias.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/alias.go @@ -29,6 +29,12 @@ type Defaulter = admission.Defaulter // Validator defines functions for validating an operation. type Validator = admission.Validator +// CustomDefaulter defines functions for setting defaults on resources. +type CustomDefaulter = admission.CustomDefaulter + +// CustomValidator defines functions for validating an operation. +type CustomValidator = admission.CustomValidator + // AdmissionRequest defines the input for an admission handler. // It contains information to identify the object in // question (group, version, kind, resource, subresource, diff --git a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/server.go b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/server.go index d2338d0b77..364d0f902e 100644 --- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/server.go +++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/server.go @@ -34,6 +34,7 @@ import ( kscheme "k8s.io/client-go/kubernetes/scheme" "sigs.k8s.io/controller-runtime/pkg/certwatcher" "sigs.k8s.io/controller-runtime/pkg/healthz" + "sigs.k8s.io/controller-runtime/pkg/internal/httpserver" "sigs.k8s.io/controller-runtime/pkg/runtime/inject" "sigs.k8s.io/controller-runtime/pkg/webhook/internal/metrics" ) @@ -142,7 +143,7 @@ func (s *Server) Register(path string, hook http.Handler) { s.WebhookMux.Handle(path, metrics.InstrumentedHook(path, hook)) regLog := log.WithValues("path", path) - regLog.Info("registering webhook") + regLog.Info("Registering webhook") // we've already been "started", inject dependencies here. // Otherwise, InjectFunc will do this for us later. @@ -210,7 +211,7 @@ func (s *Server) Start(ctx context.Context) error { s.defaultingOnce.Do(s.setDefaults) baseHookLog := log.WithName("webhooks") - baseHookLog.Info("starting webhook server") + baseHookLog.Info("Starting webhook server") certPath := filepath.Join(s.CertDir, s.CertName) keyPath := filepath.Join(s.CertDir, s.KeyName) @@ -259,11 +260,9 @@ func (s *Server) Start(ctx context.Context) error { return err } - log.Info("serving webhook server", "host", s.Host, "port", s.Port) + log.Info("Serving webhook server", "host", s.Host, "port", s.Port) - srv := &http.Server{ - Handler: s.WebhookMux, - } + srv := httpserver.New(s.WebhookMux) idleConnsClosed := make(chan struct{}) go func() { diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/crd/conv.go b/vendor/sigs.k8s.io/controller-tools/pkg/crd/conv.go index e429db5cc0..374e02c373 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/crd/conv.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/crd/conv.go @@ -6,7 +6,6 @@ import ( apiextinternal "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" apiext "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" apiextv1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" - "k8s.io/apimachinery/pkg/api/equality" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) @@ -22,13 +21,15 @@ func init() { if err := apiext.AddToScheme(conversionScheme); err != nil { panic("must be able to add apiextensions/v1 to the CRD conversion Scheme") } - if err := apiextv1beta1.AddToScheme(conversionScheme); err != nil { - panic("must be able to add apiextensions/v1beta1 to the CRD conversion Scheme") - } } // AsVersion converts a CRD from the canonical internal form (currently v1) to some external form. func AsVersion(original apiext.CustomResourceDefinition, gv schema.GroupVersion) (runtime.Object, error) { + // TODO: Do we need to keep maintaining this conversion function + // post 1.22 when only CRDv1 is served by the apiserver? + if gv == apiextv1beta1.SchemeGroupVersion { + return nil, fmt.Errorf("apiVersion %q is not supported", gv.String()) + } // We can use the internal versions an existing conversions from kubernetes, since they're not in k/k itself. // This punts the problem of conversion down the road for a future maintainer (or future instance of @directxman12) // when we have to support older versions that get removed, or when API machinery decides to yell at us for this @@ -40,83 +41,3 @@ func AsVersion(original apiext.CustomResourceDefinition, gv schema.GroupVersion) return conversionScheme.ConvertToVersion(intVer, gv) } - -// mergeIdenticalSubresources checks to see if subresources are identical across -// all versions, and if so, merges them into a top-level version. -// -// This assumes you're not using trivial versions. -func mergeIdenticalSubresources(crd *apiextv1beta1.CustomResourceDefinition) { - subres := crd.Spec.Versions[0].Subresources - for _, ver := range crd.Spec.Versions { - if ver.Subresources == nil || !equality.Semantic.DeepEqual(subres, ver.Subresources) { - // either all nil, or not identical - return - } - } - - // things are identical if we've gotten this far, so move the subresources up - // and discard the identical per-version ones - crd.Spec.Subresources = subres - for i := range crd.Spec.Versions { - crd.Spec.Versions[i].Subresources = nil - } -} - -// mergeIdenticalSchemata checks to see if schemata are identical across -// all versions, and if so, merges them into a top-level version. -// -// This assumes you're not using trivial versions. -func mergeIdenticalSchemata(crd *apiextv1beta1.CustomResourceDefinition) { - schema := crd.Spec.Versions[0].Schema - for _, ver := range crd.Spec.Versions { - if ver.Schema == nil || !equality.Semantic.DeepEqual(schema, ver.Schema) { - // either all nil, or not identical - return - } - } - - // things are identical if we've gotten this far, so move the schemata up - // to a single schema and discard the identical per-version ones - crd.Spec.Validation = schema - for i := range crd.Spec.Versions { - crd.Spec.Versions[i].Schema = nil - } -} - -// mergeIdenticalPrinterColumns checks to see if schemata are identical across -// all versions, and if so, merges them into a top-level version. -// -// This assumes you're not using trivial versions. -func mergeIdenticalPrinterColumns(crd *apiextv1beta1.CustomResourceDefinition) { - cols := crd.Spec.Versions[0].AdditionalPrinterColumns - for _, ver := range crd.Spec.Versions { - if len(ver.AdditionalPrinterColumns) == 0 || !equality.Semantic.DeepEqual(cols, ver.AdditionalPrinterColumns) { - // either all nil, or not identical - return - } - } - - // things are identical if we've gotten this far, so move the printer columns up - // and discard the identical per-version ones - crd.Spec.AdditionalPrinterColumns = cols - for i := range crd.Spec.Versions { - crd.Spec.Versions[i].AdditionalPrinterColumns = nil - } -} - -// MergeIdenticalVersionInfo makes sure that components of the Versions field that are identical -// across all versions get merged into the top-level fields in v1beta1. -// -// This is required by the Kubernetes API server validation. -// -// The reason is that a v1beta1 -> v1 -> v1beta1 conversion cycle would need to -// round-trip identically, v1 doesn't have top-level subresources, and without -// this restriction it would be ambiguous how a v1-with-identical-subresources -// converts into a v1beta1). -func MergeIdenticalVersionInfo(crd *apiextv1beta1.CustomResourceDefinition) { - if len(crd.Spec.Versions) > 0 { - mergeIdenticalSubresources(crd) - mergeIdenticalSchemata(crd) - mergeIdenticalPrinterColumns(crd) - } -} diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/crd/gen.go b/vendor/sigs.k8s.io/controller-tools/pkg/crd/gen.go index dd154c549f..9959874624 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/crd/gen.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/crd/gen.go @@ -20,10 +20,8 @@ import ( "fmt" "go/ast" "go/types" - "os" apiext "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" - apiextlegacy "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" "k8s.io/apimachinery/pkg/runtime/schema" crdmarkers "sigs.k8s.io/controller-tools/pkg/crd/markers" @@ -33,31 +31,16 @@ import ( "sigs.k8s.io/controller-tools/pkg/version" ) +// The identifier for v1 CustomResourceDefinitions. +const v1 = "v1" + // The default CustomResourceDefinition version to generate. -const defaultVersion = "v1" +const defaultVersion = v1 // +controllertools:marker:generateHelp // Generator generates CustomResourceDefinition objects. type Generator struct { - // TrivialVersions indicates that we should produce a single-version CRD. - // - // Single "trivial-version" CRDs are compatible with older (pre 1.13) - // Kubernetes API servers. The storage version's schema will be used as - // the CRD's schema. - // - // Only works with the v1beta1 CRD version. - TrivialVersions bool `marker:",optional"` - - // PreserveUnknownFields indicates whether or not we should turn off pruning. - // - // Left unspecified, it'll default to true when only a v1beta1 CRD is - // generated (to preserve compatibility with older versions of this tool), - // or false otherwise. - // - // It's required to be false for v1 CRDs. - PreserveUnknownFields *bool `marker:",optional"` - // AllowDangerousTypes allows types which are usually omitted from CRD generation // because they are not recommended. // @@ -78,6 +61,8 @@ type Generator struct { // CRDVersions specifies the target API versions of the CRD type itself to // generate. Defaults to v1. // + // Currently, the only supported value is v1. + // // The first version listed will be assumed to be the "default" version and // will not get a version suffix in the output filename. // @@ -146,38 +131,8 @@ func (g Generator) Generate(ctx *genall.GenerationContext) error { versionedCRDs[i] = conv } - if g.TrivialVersions { - for i, crd := range versionedCRDs { - if crdVersions[i] == "v1beta1" { - toTrivialVersions(crd.(*apiextlegacy.CustomResourceDefinition)) - } - } - } - - // *If* we're only generating v1beta1 CRDs, default to `preserveUnknownFields: (unset)` - // for compatibility purposes. In any other case, default to false, since that's - // the sensible default and is required for v1. - v1beta1Only := len(crdVersions) == 1 && crdVersions[0] == "v1beta1" - switch { - case (g.PreserveUnknownFields == nil || *g.PreserveUnknownFields) && v1beta1Only: - crd := versionedCRDs[0].(*apiextlegacy.CustomResourceDefinition) - crd.Spec.PreserveUnknownFields = nil - case g.PreserveUnknownFields == nil, g.PreserveUnknownFields != nil && !*g.PreserveUnknownFields: - // it'll be false here (coming from v1) -- leave it as such - default: - return fmt.Errorf("you may only set PreserveUnknownFields to true with v1beta1 CRDs") - } - for i, crd := range versionedCRDs { - // defaults are not allowed to be specified in v1beta1 CRDs and - // decriptions are not allowed on the metadata regardless of version - // strip them before writing to a file - if crdVersions[i] == "v1beta1" { - removeDefaultsFromSchemas(crd.(*apiextlegacy.CustomResourceDefinition)) - removeDescriptionFromMetadataLegacy(crd.(*apiextlegacy.CustomResourceDefinition)) - } else { - removeDescriptionFromMetadata(crd.(*apiext.CustomResourceDefinition)) - } + removeDescriptionFromMetadata(crd.(*apiext.CustomResourceDefinition)) var fileName string if i == 0 { fileName = fmt.Sprintf("%s_%s.yaml", crdRaw.Spec.Group, crdRaw.Spec.Names.Plural) @@ -212,71 +167,6 @@ func removeDescriptionFromMetadataProps(v *apiext.JSONSchemaProps) { } } -func removeDescriptionFromMetadataLegacy(crd *apiextlegacy.CustomResourceDefinition) { - if crd.Spec.Validation != nil { - removeDescriptionFromMetadataPropsLegacy(crd.Spec.Validation.OpenAPIV3Schema) - } - for _, versionSpec := range crd.Spec.Versions { - if versionSpec.Schema != nil { - removeDescriptionFromMetadataPropsLegacy(versionSpec.Schema.OpenAPIV3Schema) - } - } -} - -func removeDescriptionFromMetadataPropsLegacy(v *apiextlegacy.JSONSchemaProps) { - if m, ok := v.Properties["metadata"]; ok { - meta := &m - if meta.Description != "" { - meta.Description = "" - v.Properties["metadata"] = m - - } - } -} - -// removeDefaultsFromSchemas will remove all instances of default values being -// specified across all defined API versions -func removeDefaultsFromSchemas(crd *apiextlegacy.CustomResourceDefinition) { - if crd.Spec.Validation != nil { - removeDefaultsFromSchemaProps(crd.Spec.Validation.OpenAPIV3Schema) - } - - for _, versionSpec := range crd.Spec.Versions { - if versionSpec.Schema != nil { - removeDefaultsFromSchemaProps(versionSpec.Schema.OpenAPIV3Schema) - } - } -} - -// removeDefaultsFromSchemaProps will recurse into JSONSchemaProps to remove -// all instances of default values being specified -func removeDefaultsFromSchemaProps(v *apiextlegacy.JSONSchemaProps) { - if v == nil { - return - } - - if v.Default != nil { - fmt.Fprintln(os.Stderr, "Warning: default unsupported in CRD version v1beta1, v1 required. Removing defaults.") - } - - // nil-out the default field - v.Default = nil - for name, prop := range v.Properties { - // iter var reference is fine -- we handle the persistence of the modfications on the line below - //nolint:gosec - removeDefaultsFromSchemaProps(&prop) - v.Properties[name] = prop - } - if v.Items != nil { - removeDefaultsFromSchemaProps(v.Items.Schema) - for i := range v.Items.JSONSchemas { - props := v.Items.JSONSchemas[i] - removeDefaultsFromSchemaProps(&props) - v.Items.JSONSchemas[i] = props - } - } -} - // FixTopLevelMetadata resets the schema for the top-level metadata field which is needed for CRD validation func FixTopLevelMetadata(crd apiext.CustomResourceDefinition) { for _, v := range crd.Spec.Versions { @@ -289,32 +179,6 @@ func FixTopLevelMetadata(crd apiext.CustomResourceDefinition) { } } -// toTrivialVersions strips out all schemata except for the storage schema, -// and moves that up into the root object. This makes the CRD compatible -// with pre 1.13 clusters. -func toTrivialVersions(crd *apiextlegacy.CustomResourceDefinition) { - var canonicalSchema *apiextlegacy.CustomResourceValidation - var canonicalSubresources *apiextlegacy.CustomResourceSubresources - var canonicalColumns []apiextlegacy.CustomResourceColumnDefinition - for i, ver := range crd.Spec.Versions { - if ver.Storage == true { - canonicalSchema = ver.Schema - canonicalSubresources = ver.Subresources - canonicalColumns = ver.AdditionalPrinterColumns - } - crd.Spec.Versions[i].Schema = nil - crd.Spec.Versions[i].Subresources = nil - crd.Spec.Versions[i].AdditionalPrinterColumns = nil - } - if canonicalSchema == nil { - return - } - - crd.Spec.Validation = canonicalSchema - crd.Spec.Subresources = canonicalSubresources - crd.Spec.AdditionalPrinterColumns = canonicalColumns -} - // addAttribution adds attribution info to indicate controller-gen tool was used // to generate this CRD definition along with the version info. func addAttribution(crd *apiext.CustomResourceDefinition) { diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/topology.go b/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/topology.go index c5a3b80e90..0f4a94b180 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/topology.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/topology.go @@ -101,7 +101,7 @@ type StructType string func (l ListType) ApplyToSchema(schema *apiext.JSONSchemaProps) error { if schema.Type != "array" { - return fmt.Errorf("must apply listType to an array") + return fmt.Errorf("must apply listType to an array, found %s", schema.Type) } if l != "map" && l != "atomic" && l != "set" { return fmt.Errorf(`ListType must be either "map", "set" or "atomic"`) @@ -115,7 +115,7 @@ func (l ListType) ApplyFirst() {} func (l ListMapKey) ApplyToSchema(schema *apiext.JSONSchemaProps) error { if schema.Type != "array" { - return fmt.Errorf("must apply listMapKey to an array") + return fmt.Errorf("must apply listMapKey to an array, found %s", schema.Type) } if schema.XListType == nil || *schema.XListType != "map" { return fmt.Errorf("must apply listMapKey to an associative-list") diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/validation.go b/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/validation.go index 5a038e4e6d..b20ff1623d 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/validation.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/validation.go @@ -66,6 +66,7 @@ var ValidationMarkers = mustMakeAllWithPrefix("kubebuilder:validation", markers. Type(""), XPreserveUnknownFields{}, XEmbeddedResource{}, + XIntOrString{}, ) // FieldOnlyMarkers list field-specific validation markers (i.e. those markers that don't make @@ -232,6 +233,14 @@ type XPreserveUnknownFields struct{} // field, yet it is possible. This can be combined with PreserveUnknownFields. type XEmbeddedResource struct{} +// +controllertools:marker:generateHelp:category="CRD validation" +// IntOrString marks a fields as an IntOrString. +// +// This is required when applying patterns or other validations to an IntOrString +// field. Knwon information about the type is applied during the collapse phase +// and as such is not normally available during marker application. +type XIntOrString struct{} + // +controllertools:marker:generateHelp:category="CRD validation" // Schemaless marks a field as being a schemaless object. // @@ -298,8 +307,11 @@ func (m MinLength) ApplyToSchema(schema *apiext.JSONSchemaProps) error { return nil } func (m Pattern) ApplyToSchema(schema *apiext.JSONSchemaProps) error { - if schema.Type != "string" { - return fmt.Errorf("must apply pattern to a string") + // Allow string types or IntOrStrings. An IntOrString will still + // apply the pattern validation when a string is detected, the pattern + // will not apply to ints though. + if schema.Type != "string" && !schema.XIntOrString { + return fmt.Errorf("must apply pattern to a `string` or `IntOrString`") } schema.Pattern = string(m) return nil @@ -406,3 +418,13 @@ func (m XEmbeddedResource) ApplyToSchema(schema *apiext.JSONSchemaProps) error { schema.XEmbeddedResource = true return nil } + +// NB(JoelSpeed): we use this property in other markers here, +// which means the "XIntOrString" marker *must* be applied first. + +func (m XIntOrString) ApplyToSchema(schema *apiext.JSONSchemaProps) error { + schema.XIntOrString = true + return nil +} + +func (m XIntOrString) ApplyFirst() {} diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/zz_generated.markerhelp.go b/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/zz_generated.markerhelp.go index e6875bb5f5..03d663601e 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/zz_generated.markerhelp.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/crd/markers/zz_generated.markerhelp.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -48,7 +49,7 @@ func (DeprecatedVersion) Help() *markers.DefinitionHelp { Details: "", }, FieldHelp: map[string]markers.DetailedHelp{ - "Warning": markers.DetailedHelp{ + "Warning": { Summary: "message to be shown on the deprecated version", Details: "", }, @@ -116,7 +117,7 @@ func (ListType) Help() *markers.DefinitionHelp { Category: "CRD processing", DetailedHelp: markers.DetailedHelp{ Summary: "specifies the type of data-structure that the list represents (map, set, atomic). ", - Details: "Possible data-structure types of a list are: \n - \"map\": it needs to have a key field, which will be used to build an associative list. A typical example is a the pod container list, which is indexed by the container name. \n - \"set\": Fields need to be \"scalar\", and there can be only one occurrence of each. \n - \"atomic\": All the fields in the list are treated as a single value, are typically manipulated together by the same actor.", + Details: "Possible data-structure types of a list are: \n - \"map\": it needs to have a key field, which will be used to build an associative list. A typical example is a the pod container list, which is indexed by the container name. \n - \"set\": Fields need to be \"scalar\", and there can be only one occurrence of each. \n - \"atomic\": All the fields in the list are treated as a single value, are typically manipulated together by the same actor.", }, FieldHelp: map[string]markers.DetailedHelp{}, } @@ -127,7 +128,7 @@ func (MapType) Help() *markers.DefinitionHelp { Category: "CRD processing", DetailedHelp: markers.DetailedHelp{ Summary: "specifies the level of atomicity of the map; i.e. whether each item in the map is independent of the others, or all fields are treated as a single unit. ", - Details: "Possible values: \n - \"granular\": items in the map are independent of each other, and can be manipulated by different actors. This is the default behavior. \n - \"atomic\": all fields are treated as one unit. Any changes have to replace the entire map.", + Details: "Possible values: \n - \"granular\": items in the map are independent of each other, and can be manipulated by different actors. This is the default behavior. \n - \"atomic\": all fields are treated as one unit. Any changes have to replace the entire map.", }, FieldHelp: map[string]markers.DetailedHelp{}, } @@ -360,7 +361,7 @@ func (StructType) Help() *markers.DefinitionHelp { Category: "CRD processing", DetailedHelp: markers.DetailedHelp{ Summary: "specifies the level of atomicity of the struct; i.e. whether each field in the struct is independent of the others, or all fields are treated as a single unit. ", - Details: "Possible values: \n - \"granular\": fields in the struct are independent of each other, and can be manipulated by different actors. This is the default behavior. \n - \"atomic\": all fields are treated as one unit. Any changes have to replace the entire struct.", + Details: "Possible values: \n - \"granular\": fields in the struct are independent of each other, and can be manipulated by different actors. This is the default behavior. \n - \"atomic\": all fields are treated as one unit. Any changes have to replace the entire struct.", }, FieldHelp: map[string]markers.DetailedHelp{}, } @@ -445,6 +446,17 @@ func (XEmbeddedResource) Help() *markers.DefinitionHelp { } } +func (XIntOrString) Help() *markers.DefinitionHelp { + return &markers.DefinitionHelp{ + Category: "CRD validation", + DetailedHelp: markers.DetailedHelp{ + Summary: "IntOrString marks a fields as an IntOrString. ", + Details: "This is required when applying patterns or other validations to an IntOrString field. Knwon information about the type is applied during the collapse phase and as such is not normally available during marker application.", + }, + FieldHelp: map[string]markers.DetailedHelp{}, + } +} + func (XPreserveUnknownFields) Help() *markers.DefinitionHelp { return &markers.DefinitionHelp{ Category: "CRD processing", diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/crd/schema.go b/vendor/sigs.k8s.io/controller-tools/pkg/crd/schema.go index 0f682808b6..b665817f91 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/crd/schema.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/crd/schema.go @@ -17,8 +17,10 @@ limitations under the License. package crd import ( + "errors" "fmt" "go/ast" + "go/token" "go/types" "strings" @@ -37,12 +39,10 @@ const ( defPrefix = "#/definitions/" ) -var ( - // byteType is the types.Type for byte (see the types documention - // for why we need to look this up in the Universe), saved - // for quick comparison. - byteType = types.Universe.Lookup("byte").Type() -) +// byteType is the types.Type for byte (see the types documention +// for why we need to look this up in the Universe), saved +// for quick comparison. +var byteType = types.Universe.Lookup("byte").Type() // SchemaMarker is any marker that needs to modify the schema of the underlying type or field. type SchemaMarker interface { @@ -109,6 +109,15 @@ func (c *schemaContext) requestSchema(pkgPath, typeName string) { // infoToSchema creates a schema for the type in the given set of type information. func infoToSchema(ctx *schemaContext) *apiext.JSONSchemaProps { + // If the obj implements a JSON marshaler and has a marker, use the markers value and do not traverse as + // the marshaler could be doing anything. If there is no marker, fall back to traversing. + if obj := ctx.pkg.Types.Scope().Lookup(ctx.info.Name); obj != nil && implementsJSONMarshaler(obj.Type()) { + schema := &apiext.JSONSchemaProps{} + applyMarkers(ctx, ctx.info.Markers, schema, ctx.info.RawSpec.Type) + if schema.Type != "" { + return schema + } + } return typeToSchema(ctx, ctx.info.RawSpec.Type) } @@ -298,14 +307,12 @@ func mapToSchema(ctx *schemaContext, mapType *ast.MapType) *apiext.JSONSchemaPro valSchema = namedToSchema(ctx.ForInfo(&markers.TypeInfo{}), val) case *ast.ArrayType: valSchema = arrayToSchema(ctx.ForInfo(&markers.TypeInfo{}), val) - if valSchema.Type == "array" && valSchema.Items.Schema.Type != "string" { - ctx.pkg.AddError(loader.ErrFromNode(fmt.Errorf("map values must be a named type, not %T", mapType.Value), mapType.Value)) - return &apiext.JSONSchemaProps{} - } case *ast.StarExpr: valSchema = typeToSchema(ctx.ForInfo(&markers.TypeInfo{}), val) + case *ast.MapType: + valSchema = typeToSchema(ctx.ForInfo(&markers.TypeInfo{}), val) default: - ctx.pkg.AddError(loader.ErrFromNode(fmt.Errorf("map values must be a named type, not %T", mapType.Value), mapType.Value)) + ctx.pkg.AddError(loader.ErrFromNode(fmt.Errorf("not a supported map value type: %T", mapType.Value), mapType.Value)) return &apiext.JSONSchemaProps{} } @@ -415,10 +422,13 @@ func builtinToType(basic *types.Basic, allowDangerousTypes bool) (typ string, fo typ = "string" case basicInfo&types.IsInteger != 0: typ = "integer" - case basicInfo&types.IsFloat != 0 && allowDangerousTypes: - typ = "number" + case basicInfo&types.IsFloat != 0: + if allowDangerousTypes { + typ = "number" + } else { + return "", "", errors.New("found float, the usage of which is highly discouraged, as support for them varies across languages. Please consider serializing your float as string instead. If you are really sure you want to use them, re-run with crd:allowDangerousTypes=true") + } default: - // NB(directxman12): floats are *NOT* allowed in kubernetes APIs return "", "", fmt.Errorf("unsupported type %q", basic.String()) } @@ -431,3 +441,16 @@ func builtinToType(basic *types.Basic, allowDangerousTypes bool) (typ string, fo return typ, format, nil } + +// Open coded go/types representation of encoding/json.Marshaller +var jsonMarshaler = types.NewInterfaceType([]*types.Func{ + types.NewFunc(token.NoPos, nil, "MarshalJSON", + types.NewSignature(nil, nil, + types.NewTuple( + types.NewVar(token.NoPos, nil, "", types.NewSlice(types.Universe.Lookup("byte").Type())), + types.NewVar(token.NoPos, nil, "", types.Universe.Lookup("error").Type())), false)), +}, nil).Complete() + +func implementsJSONMarshaler(typ types.Type) bool { + return types.Implements(typ, jsonMarshaler) || types.Implements(types.NewPointer(typ), jsonMarshaler) +} diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/crd/zz_generated.markerhelp.go b/vendor/sigs.k8s.io/controller-tools/pkg/crd/zz_generated.markerhelp.go index 4b008f5949..db9f40f2e0 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/crd/zz_generated.markerhelp.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/crd/zz_generated.markerhelp.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -32,14 +33,6 @@ func (Generator) Help() *markers.DefinitionHelp { Details: "", }, FieldHelp: map[string]markers.DetailedHelp{ - "TrivialVersions": { - Summary: "indicates that we should produce a single-version CRD. ", - Details: "Single \"trivial-version\" CRDs are compatible with older (pre 1.13) Kubernetes API servers. The storage version's schema will be used as the CRD's schema. \n Only works with the v1beta1 CRD version.", - }, - "PreserveUnknownFields": { - Summary: "indicates whether or not we should turn off pruning. ", - Details: "Left unspecified, it'll default to true when only a v1beta1 CRD is generated (to preserve compatibility with older versions of this tool), or false otherwise. \n It's required to be false for v1 CRDs.", - }, "AllowDangerousTypes": { Summary: "allows types which are usually omitted from CRD generation because they are not recommended. ", Details: "Currently the following additional types are allowed when this is true: float32 float64 \n Left unspecified, the default is false", @@ -50,7 +43,7 @@ func (Generator) Help() *markers.DefinitionHelp { }, "CRDVersions": { Summary: "specifies the target API versions of the CRD type itself to generate. Defaults to v1. ", - Details: "The first version listed will be assumed to be the \"default\" version and will not get a version suffix in the output filename. \n You'll need to use \"v1\" to get support for features like defaulting, along with an API server that supports it (Kubernetes 1.16+).", + Details: "Currently, the only supported value is v1. \n The first version listed will be assumed to be the \"default\" version and will not get a version suffix in the output filename. \n You'll need to use \"v1\" to get support for features like defaulting, along with an API server that supports it (Kubernetes 1.16+).", }, "GenerateEmbeddedObjectMeta": { Summary: "specifies if any embedded ObjectMeta in the CRD should be generated", diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/deepcopy/zz_generated.markerhelp.go b/vendor/sigs.k8s.io/controller-tools/pkg/deepcopy/zz_generated.markerhelp.go index 6e001c6e25..913bc1fb7f 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/deepcopy/zz_generated.markerhelp.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/deepcopy/zz_generated.markerhelp.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/genall/genall.go b/vendor/sigs.k8s.io/controller-tools/pkg/genall/genall.go index 0206a4afa5..e03888d4e3 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/genall/genall.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/genall/genall.go @@ -100,6 +100,8 @@ type Runtime struct { GenerationContext // OutputRules defines how to output artifacts for each Generator. OutputRules OutputRules + // ErrorWriter defines where to write error messages. + ErrorWriter io.Writer } // GenerationContext defines the common information needed for each Generator @@ -133,7 +135,7 @@ func (g GenerationContext) WriteYAML(itemPath string, objs ...interface{}) error if err != nil { return err } - n, err := out.Write(append([]byte("\n---\n"), yamlContent...)) + n, err := out.Write(append([]byte("---\n"), yamlContent...)) if err != nil { return err } @@ -188,8 +190,12 @@ func (g Generators) ForRoots(rootPaths ...string) (*Runtime, error) { func (r *Runtime) Run() bool { // TODO(directxman12): we could make this parallel, // but we'd need to ensure all underlying machinery is threadsafe + + if r.ErrorWriter == nil { + r.ErrorWriter = os.Stderr + } if len(r.Generators) == 0 { - fmt.Fprintln(os.Stderr, "no generators to run") + fmt.Fprintln(r.ErrorWriter, "no generators to run") return true } @@ -205,7 +211,7 @@ func (r *Runtime) Run() bool { } if err := (*gen).Generate(&ctx); err != nil { - fmt.Fprintln(os.Stderr, err) + fmt.Fprintln(r.ErrorWriter, err) hadErrs = true } } diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/genall/zz_generated.markerhelp.go b/vendor/sigs.k8s.io/controller-tools/pkg/genall/zz_generated.markerhelp.go index 1319397e63..cc9ae7b800 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/genall/zz_generated.markerhelp.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/genall/zz_generated.markerhelp.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/markers/zip.go b/vendor/sigs.k8s.io/controller-tools/pkg/markers/zip.go index a9b4c98af5..0ef1fb133b 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/markers/zip.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/markers/zip.go @@ -67,12 +67,22 @@ func extractDoc(node ast.Node, decl *ast.GenDecl) string { // chop off the extraneous last part outLines = outLines[:len(outLines)-1] } - // respect double-newline meaning actual newline + for i, line := range outLines { + // Trim any extranous whitespace, + // for handling /*…*/-style comments, + // which have whitespace preserved in go/ast: + line = strings.TrimSpace(line) + + // Respect that double-newline means + // actual newline: if line == "" { outLines[i] = "\n" + } else { + outLines[i] = line } } + return strings.Join(outLines, " ") } diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/rbac/zz_generated.markerhelp.go b/vendor/sigs.k8s.io/controller-tools/pkg/rbac/zz_generated.markerhelp.go index 29deffea30..0e2083a23d 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/rbac/zz_generated.markerhelp.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/rbac/zz_generated.markerhelp.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/schemapatcher/gen.go b/vendor/sigs.k8s.io/controller-tools/pkg/schemapatcher/gen.go index f9b197a595..6aec36ca6e 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/schemapatcher/gen.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/schemapatcher/gen.go @@ -23,7 +23,6 @@ import ( "gopkg.in/yaml.v3" apiext "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" - apiextlegacy "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" "k8s.io/apimachinery/pkg/api/equality" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime/schema" @@ -54,7 +53,6 @@ import ( // patches. var ( - legacyAPIExtVersion = apiextlegacy.SchemeGroupVersion.String() currentAPIExtVersion = apiext.SchemeGroupVersion.String() ) @@ -62,18 +60,8 @@ var ( // Generator patches existing CRDs with new schemata. // -// For legacy (v1beta1) single-version CRDs, it will simply replace the global schema. -// -// For legacy (v1beta1) multi-version CRDs, and any v1 CRDs, it will replace -// schemata of existing versions and *clear the schema* from any versions not -// specified in the Go code. It will *not* add new versions, or remove old -// ones. -// -// For legacy multi-version CRDs with identical schemata, it will take care of -// lifting the per-version schema up to the global schema. -// // It will generate output for each "CRD Version" (API version of the CRD type -// itself) , e.g. apiextensions/v1beta1 and apiextensions/v1) available. +// itself) , e.g. apiextensions/v1) available. type Generator struct { // ManifestsPath contains the CustomResourceDefinition YAML files. ManifestsPath string `marker:"manifests"` @@ -259,67 +247,13 @@ type partialCRD struct { CRDVersion string } -// setGlobalSchema sets the global schema for the v1beta1 apiext version in -// this set (if present, as per partialCRD.setGlobalSchema), and sets the -// versioned schemas (as per setVersionedSchemata) for the v1 version. +// setGlobalSchema sets the versioned schemas (as per setVersionedSchemata). func (e *partialCRDSet) setGlobalSchema() error { - // there's no easy way to get a "random" key from a go map :-/ - var schema apiext.JSONSchemaProps - for ver := range e.NewSchemata { - schema = e.NewSchemata[ver] - break - } for _, crdInfo := range e.CRDVersions { - switch crdInfo.CRDVersion { - case legacyAPIExtVersion: - if err := crdInfo.setGlobalSchema(schema); err != nil { - return err - } - case currentAPIExtVersion: - // just set the schemata as normal for non-legacy versions - if err := crdInfo.setVersionedSchemata(e.NewSchemata); err != nil { - return err - } - } - } - return nil -} - -// setGlobalSchema sets the global schema to one of the schemata -// for this CRD. All schemata must be identical for this to be a valid operation. -func (e *partialCRD) setGlobalSchema(newSchema apiext.JSONSchemaProps) error { - if e.CRDVersion != legacyAPIExtVersion { - // no global schema, nothing to do - return fmt.Errorf("cannot set global schema on non-legacy CRD versions") - } - schema, err := legacySchema(newSchema) - if err != nil { - return fmt.Errorf("failed to convert schema to legacy form: %w", err) - } - schemaNodeTree, err := yamlop.ToYAML(schema) - if err != nil { - return err - } - schemaNodeTree = schemaNodeTree.Content[0] // get rid of the document node - yamlop.SetStyle(schemaNodeTree, 0) // clear the style so it defaults to auto-style-choice - - if err := yamlop.SetNode(e.Yaml, *schemaNodeTree, "spec", "validation", "openAPIV3Schema"); err != nil { - return err - } - - versions, found, err := e.getVersionsNode() - if err != nil { - return err - } - if !found { - return nil - } - for i, verNode := range versions.Content { - if err := yamlop.DeleteNode(verNode, "schema"); err != nil { - return fmt.Errorf("spec.versions[%d]: %w", i, err) + if err := crdInfo.setVersionedSchemata(e.NewSchemata); err != nil { + return err } } - return nil } @@ -382,16 +316,7 @@ func (e *partialCRD) setVersionedSchemata(newSchemata map[string]apiext.JSONSche return fmt.Errorf("spec.versions[%d]: %w", i, err) } } else { - // TODO(directxman12): if this gets to be more than 2 versions, use polymorphism to clean this up - var verSchema interface{} = newSchema - if e.CRDVersion == legacyAPIExtVersion { - verSchema, err = legacySchema(newSchema) - if err != nil { - return fmt.Errorf("failed to convert schema to legacy form: %w", err) - } - } - - schemaNodeTree, err := yamlop.ToYAML(verSchema) + schemaNodeTree, err := yamlop.ToYAML(newSchema) if err != nil { return fmt.Errorf("failed to convert schema to YAML: %w", err) } @@ -433,7 +358,10 @@ func crdsFromDirectory(ctx *genall.GenerationContext, dir string) (map[schema.Gr if err := kyaml.Unmarshal(rawContent, &typeMeta); err != nil { continue } - if !isSupportedAPIExtGroupVer(typeMeta.APIVersion) || typeMeta.Kind != "CustomResourceDefinition" { + if !isSupportedAPIExtGroupVer(typeMeta.APIVersion) { + return nil, fmt.Errorf("load %q: apiVersion %q not supported", filepath.Join(dir, fileInfo.Name()), typeMeta.APIVersion) + } + if typeMeta.Kind != "CustomResourceDefinition" { continue } @@ -443,14 +371,9 @@ func crdsFromDirectory(ctx *genall.GenerationContext, dir string) (map[schema.Gr continue } groupKind := schema.GroupKind{Group: actualCRD.Spec.Group, Kind: actualCRD.Spec.Names.Kind} - var versions map[string]struct{} - if len(actualCRD.Spec.Versions) == 0 { - versions = map[string]struct{}{actualCRD.Spec.Version: {}} - } else { - versions = make(map[string]struct{}, len(actualCRD.Spec.Versions)) - for _, ver := range actualCRD.Spec.Versions { - versions[ver.Name] = struct{}{} - } + versions := make(map[string]struct{}, len(actualCRD.Spec.Versions)) + for _, ver := range actualCRD.Spec.Versions { + versions[ver.Name] = struct{}{} } // then actually unmarshal in a manner that preserves ordering, etc @@ -480,9 +403,9 @@ func crdsFromDirectory(ctx *genall.GenerationContext, dir string) (map[schema.Gr } // isSupportedAPIExtGroupVer checks if the given string-form group-version -// is one of the known apiextensions versions (v1, v1beta1). +// is one of the known apiextensions versions (v1). func isSupportedAPIExtGroupVer(groupVer string) bool { - return groupVer == currentAPIExtVersion || groupVer == legacyAPIExtVersion + return groupVer == currentAPIExtVersion } // crdIsh is a merged blob of CRD fields that looks enough like all versions of @@ -502,23 +425,5 @@ type crdIsh struct { Versions []struct { Name string `json:"name"` } `json:"versions"` - Version string `json:"version"` } `json:"spec"` } - -// legacySchema jumps through some hoops to convert a v1 schema to a v1beta1 schema. -func legacySchema(origSchema apiext.JSONSchemaProps) (apiextlegacy.JSONSchemaProps, error) { - shellCRD := apiext.CustomResourceDefinition{} - shellCRD.APIVersion = currentAPIExtVersion - shellCRD.Kind = "CustomResourceDefinition" - shellCRD.Spec.Versions = []apiext.CustomResourceDefinitionVersion{ - {Schema: &apiext.CustomResourceValidation{OpenAPIV3Schema: origSchema.DeepCopy()}}, - } - - legacyCRD, err := crdgen.AsVersion(shellCRD, apiextlegacy.SchemeGroupVersion) - if err != nil { - return apiextlegacy.JSONSchemaProps{}, err - } - - return *legacyCRD.(*apiextlegacy.CustomResourceDefinition).Spec.Validation.OpenAPIV3Schema, nil -} diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/schemapatcher/zz_generated.markerhelp.go b/vendor/sigs.k8s.io/controller-tools/pkg/schemapatcher/zz_generated.markerhelp.go index 36cc0cba8c..db9745d767 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/schemapatcher/zz_generated.markerhelp.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/schemapatcher/zz_generated.markerhelp.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -29,7 +30,7 @@ func (Generator) Help() *markers.DefinitionHelp { Category: "", DetailedHelp: markers.DetailedHelp{ Summary: "patches existing CRDs with new schemata. ", - Details: "For legacy (v1beta1) single-version CRDs, it will simply replace the global schema. \n For legacy (v1beta1) multi-version CRDs, and any v1 CRDs, it will replace schemata of existing versions and *clear the schema* from any versions not specified in the Go code. It will *not* add new versions, or remove old ones. \n For legacy multi-version CRDs with identical schemata, it will take care of lifting the per-version schema up to the global schema. \n It will generate output for each \"CRD Version\" (API version of the CRD type itself) , e.g. apiextensions/v1beta1 and apiextensions/v1) available.", + Details: "It will generate output for each \"CRD Version\" (API version of the CRD type itself) , e.g. apiextensions/v1) available.", }, FieldHelp: map[string]markers.DetailedHelp{ "ManifestsPath": { @@ -40,6 +41,10 @@ func (Generator) Help() *markers.DefinitionHelp { Summary: "specifies the maximum description length for fields in CRD's OpenAPI schema. ", Details: "0 indicates drop the description for all fields completely. n indicates limit the description to at most n characters and truncate the description to closest sentence boundary if it exceeds n characters.", }, + "GenerateEmbeddedObjectMeta": { + Summary: "specifies if any embedded ObjectMeta in the CRD should be generated", + Details: "", + }, }, } } diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/webhook/parser.go b/vendor/sigs.k8s.io/controller-tools/pkg/webhook/parser.go index 30d1360dae..f3434e1ab2 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/webhook/parser.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/webhook/parser.go @@ -36,7 +36,8 @@ import ( // The default {Mutating,Validating}WebhookConfiguration version to generate. const ( - defaultWebhookVersion = "v1" + v1 = "v1" + defaultWebhookVersion = v1 ) var ( @@ -47,7 +48,7 @@ var ( // supportedWebhookVersions returns currently supported API version of {Mutating,Validating}WebhookConfiguration. func supportedWebhookVersions() []string { - return []string{defaultWebhookVersion, "v1beta1"} + return []string{defaultWebhookVersion} } // +controllertools:marker:generateHelp:category=Webhook @@ -104,14 +105,12 @@ type Config struct { Path string // WebhookVersions specifies the target API versions of the {Mutating,Validating}WebhookConfiguration objects - // itself to generate. Defaults to v1. + // itself to generate. The only supported value is v1. Defaults to v1. WebhookVersions []string `marker:"webhookVersions,optional"` // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` // versions the Webhook expects. - // For generating v1 {Mutating,Validating}WebhookConfiguration, this is mandatory. - // For generating v1beta1 {Mutating,Validating}WebhookConfiguration, this is optional, and default to v1beta1. - AdmissionReviewVersions []string `marker:"admissionReviewVersions,optional"` + AdmissionReviewVersions []string `marker:"admissionReviewVersions"` } // verbToAPIVariant converts a marker's verb to the proper value for the API. @@ -331,9 +330,8 @@ func (Generator) Generate(ctx *genall.GenerationContext) error { versionedWebhooks := make(map[string][]interface{}, len(supportedWebhookVersions)) for _, version := range supportedWebhookVersions { if cfgs, ok := mutatingCfgs[version]; ok { - // All webhook config versions in supportedWebhookVersions have the same general form, with a few - // stricter requirements for v1. Since no conversion scheme exists for webhook configs, the v1 - // type can be used for all versioned types in this context. + // The only possible version in supportedWebhookVersions is v1, + // so use it for all versioned types in this context. objRaw := &admissionregv1.MutatingWebhookConfiguration{} objRaw.SetGroupVersionKind(schema.GroupVersionKind{ Group: admissionregv1.SchemeGroupVersion.Group, @@ -342,28 +340,24 @@ func (Generator) Generate(ctx *genall.GenerationContext) error { }) objRaw.SetName("mutating-webhook-configuration") objRaw.Webhooks = cfgs - switch version { - case admissionregv1.SchemeGroupVersion.Version: - for i := range objRaw.Webhooks { - // SideEffects is required in admissionregistration/v1, if this is not set or set to `Some` or `Known`, - // return an error - if err := checkSideEffectsForV1(objRaw.Webhooks[i].SideEffects); err != nil { - return err - } - // AdmissionReviewVersions is required in admissionregistration/v1, if this is not set, - // return an error - if len(objRaw.Webhooks[i].AdmissionReviewVersions) == 0 { - return fmt.Errorf("AdmissionReviewVersions is mandatory for v1 {Mutating,Validating}WebhookConfiguration") - } + for i := range objRaw.Webhooks { + // SideEffects is required in admissionregistration/v1, if this is not set or set to `Some` or `Known`, + // return an error + if err := checkSideEffectsForV1(objRaw.Webhooks[i].SideEffects); err != nil { + return err + } + // AdmissionReviewVersions is required in admissionregistration/v1, if this is not set, + // return an error + if len(objRaw.Webhooks[i].AdmissionReviewVersions) == 0 { + return fmt.Errorf("AdmissionReviewVersions is mandatory for v1 {Mutating,Validating}WebhookConfiguration") } } versionedWebhooks[version] = append(versionedWebhooks[version], objRaw) } if cfgs, ok := validatingCfgs[version]; ok { - // All webhook config versions in supportedWebhookVersions have the same general form, with a few - // stricter requirements for v1. Since no conversion scheme exists for webhook configs, the v1 - // type can be used for all versioned types in this context. + // The only possible version in supportedWebhookVersions is v1, + // so use it for all versioned types in this context. objRaw := &admissionregv1.ValidatingWebhookConfiguration{} objRaw.SetGroupVersionKind(schema.GroupVersionKind{ Group: admissionregv1.SchemeGroupVersion.Group, @@ -372,19 +366,16 @@ func (Generator) Generate(ctx *genall.GenerationContext) error { }) objRaw.SetName("validating-webhook-configuration") objRaw.Webhooks = cfgs - switch version { - case admissionregv1.SchemeGroupVersion.Version: - for i := range objRaw.Webhooks { - // SideEffects is required in admissionregistration/v1, if this is not set or set to `Some` or `Known`, - // return an error - if err := checkSideEffectsForV1(objRaw.Webhooks[i].SideEffects); err != nil { - return err - } - // AdmissionReviewVersions is required in admissionregistration/v1, if this is not set, - // return an error - if len(objRaw.Webhooks[i].AdmissionReviewVersions) == 0 { - return fmt.Errorf("AdmissionReviewVersions is mandatory for v1 {Mutating,Validating}WebhookConfiguration") - } + for i := range objRaw.Webhooks { + // SideEffects is required in admissionregistration/v1, if this is not set or set to `Some` or `Known`, + // return an error + if err := checkSideEffectsForV1(objRaw.Webhooks[i].SideEffects); err != nil { + return err + } + // AdmissionReviewVersions is required in admissionregistration/v1, if this is not set, + // return an error + if len(objRaw.Webhooks[i].AdmissionReviewVersions) == 0 { + return fmt.Errorf("AdmissionReviewVersions is mandatory for v1 {Mutating,Validating}WebhookConfiguration") } } versionedWebhooks[version] = append(versionedWebhooks[version], objRaw) diff --git a/vendor/sigs.k8s.io/controller-tools/pkg/webhook/zz_generated.markerhelp.go b/vendor/sigs.k8s.io/controller-tools/pkg/webhook/zz_generated.markerhelp.go index 15e9158cef..2a34608e82 100644 --- a/vendor/sigs.k8s.io/controller-tools/pkg/webhook/zz_generated.markerhelp.go +++ b/vendor/sigs.k8s.io/controller-tools/pkg/webhook/zz_generated.markerhelp.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -73,11 +74,11 @@ func (Config) Help() *markers.DefinitionHelp { Details: "", }, "WebhookVersions": { - Summary: "specifies the target API versions of the {Mutating,Validating}WebhookConfiguration objects itself to generate. Defaults to v1.", + Summary: "specifies the target API versions of the {Mutating,Validating}WebhookConfiguration objects itself to generate. The only supported value is v1. Defaults to v1.", Details: "", }, "AdmissionReviewVersions": { - Summary: "is an ordered list of preferred `AdmissionReview` versions the Webhook expects. For generating v1 {Mutating,Validating}WebhookConfiguration, this is mandatory. For generating v1beta1 {Mutating,Validating}WebhookConfiguration, this is optional, and default to v1beta1.", + Summary: "is an ordered list of preferred `AdmissionReview` versions the Webhook expects.", Details: "", }, }, diff --git a/vendor/sigs.k8s.io/json/CONTRIBUTING.md b/vendor/sigs.k8s.io/json/CONTRIBUTING.md new file mode 100644 index 0000000000..3bcd26689f --- /dev/null +++ b/vendor/sigs.k8s.io/json/CONTRIBUTING.md @@ -0,0 +1,42 @@ +# Contributing Guidelines + +Welcome to Kubernetes. We are excited about the prospect of you joining our [community](https://git.k8s.io/community)! The Kubernetes community abides by the CNCF [code of conduct](code-of-conduct.md). Here is an excerpt: + +_As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities._ + +## Criteria for adding code here + +This library adapts the stdlib `encoding/json` decoder to be compatible with +Kubernetes JSON decoding, and is not expected to actively add new features. + +It may be updated with changes from the stdlib `encoding/json` decoder. + +Any code that is added must: +* Have full unit test and benchmark coverage +* Be backward compatible with the existing exposed go API +* Have zero external dependencies +* Preserve existing benchmark performance +* Preserve compatibility with existing decoding behavior of `UnmarshalCaseSensitivePreserveInts()` or `UnmarshalStrict()` +* Avoid use of `unsafe` + +## Getting Started + +We have full documentation on how to get started contributing here: + + + +- [Contributor License Agreement](https://git.k8s.io/community/CLA.md) Kubernetes projects require that you sign a Contributor License Agreement (CLA) before we can accept your pull requests +- [Kubernetes Contributor Guide](https://git.k8s.io/community/contributors/guide) - Main contributor documentation, or you can just jump directly to the [contributing section](https://git.k8s.io/community/contributors/guide#contributing) +- [Contributor Cheat Sheet](https://git.k8s.io/community/contributors/guide/contributor-cheatsheet) - Common resources for existing developers + +## Community, discussion, contribution, and support + +You can reach the maintainers of this project via the +[sig-api-machinery mailing list / channels](https://github.com/kubernetes/community/tree/master/sig-api-machinery#contact). + +## Mentorship + +- [Mentoring Initiatives](https://git.k8s.io/community/mentoring) - We have a diverse set of mentorship programs available that are always looking for volunteers! + diff --git a/vendor/github.com/operator-framework/api/LICENSE b/vendor/sigs.k8s.io/json/LICENSE similarity index 87% rename from vendor/github.com/operator-framework/api/LICENSE rename to vendor/sigs.k8s.io/json/LICENSE index 261eeb9e9f..e5adf7f0c0 100644 --- a/vendor/github.com/operator-framework/api/LICENSE +++ b/vendor/sigs.k8s.io/json/LICENSE @@ -1,3 +1,6 @@ +Files other than internal/golang/* licensed under: + + Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ @@ -178,7 +181,7 @@ APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" + boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a @@ -186,7 +189,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright [yyyy] [name of copyright owner] + Copyright {yyyy} {name of copyright owner} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -199,3 +202,37 @@ 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. + + +------------------ + +internal/golang/* files licensed under: + + +Copyright (c) 2009 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/sigs.k8s.io/json/Makefile b/vendor/sigs.k8s.io/json/Makefile new file mode 100644 index 0000000000..07b8bfa857 --- /dev/null +++ b/vendor/sigs.k8s.io/json/Makefile @@ -0,0 +1,35 @@ +.PHONY: default build test benchmark fmt vet + +default: build + +build: + go build ./... + +test: + go test sigs.k8s.io/json/... + +benchmark: + go test sigs.k8s.io/json -bench . -benchmem + +fmt: + go mod tidy + gofmt -s -w *.go + +vet: + go vet sigs.k8s.io/json + + @echo "checking for external dependencies" + @deps=$$(go mod graph); \ + if [ -n "$${deps}" ]; then \ + echo "only stdlib dependencies allowed, found:"; \ + echo "$${deps}"; \ + exit 1; \ + fi + + @echo "checking for unsafe use" + @unsafe=$$(go list -f '{{.ImportPath}} depends on {{.Imports}}' sigs.k8s.io/json/... | grep unsafe || true); \ + if [ -n "$${unsafe}" ]; then \ + echo "no dependencies on unsafe allowed, found:"; \ + echo "$${unsafe}"; \ + exit 1; \ + fi diff --git a/vendor/sigs.k8s.io/json/OWNERS b/vendor/sigs.k8s.io/json/OWNERS new file mode 100644 index 0000000000..0fadafbddb --- /dev/null +++ b/vendor/sigs.k8s.io/json/OWNERS @@ -0,0 +1,6 @@ +# See the OWNERS docs at https://go.k8s.io/owners + +approvers: + - deads2k + - lavalamp + - liggitt diff --git a/vendor/sigs.k8s.io/json/README.md b/vendor/sigs.k8s.io/json/README.md new file mode 100644 index 0000000000..0ef8f51c21 --- /dev/null +++ b/vendor/sigs.k8s.io/json/README.md @@ -0,0 +1,40 @@ +# sigs.k8s.io/json + +[![Go Reference](https://pkg.go.dev/badge/sigs.k8s.io/json.svg)](https://pkg.go.dev/sigs.k8s.io/json) + +## Introduction + +This library is a subproject of [sig-api-machinery](https://github.com/kubernetes/community/tree/master/sig-api-machinery#json). +It provides case-sensitive, integer-preserving JSON unmarshaling functions based on `encoding/json` `Unmarshal()`. + +## Compatibility + +The `UnmarshalCaseSensitivePreserveInts()` function behaves like `encoding/json#Unmarshal()` with the following differences: + +- JSON object keys are treated case-sensitively. + Object keys must exactly match json tag names (for tagged struct fields) + or struct field names (for untagged struct fields). +- JSON integers are unmarshaled into `interface{}` fields as an `int64` instead of a + `float64` when possible, falling back to `float64` on any parse or overflow error. +- Syntax errors do not return an `encoding/json` `*SyntaxError` error. + Instead, they return an error which can be passed to `SyntaxErrorOffset()` to obtain an offset. + +## Additional capabilities + +The `UnmarshalStrict()` function decodes identically to `UnmarshalCaseSensitivePreserveInts()`, +and also returns non-fatal strict errors encountered while decoding: + +- Duplicate fields encountered +- Unknown fields encountered + +### Community, discussion, contribution, and support + +You can reach the maintainers of this project via the +[sig-api-machinery mailing list / channels](https://github.com/kubernetes/community/tree/master/sig-api-machinery#contact). + +### Code of conduct + +Participation in the Kubernetes community is governed by the [Kubernetes Code of Conduct](code-of-conduct.md). + +[owners]: https://git.k8s.io/community/contributors/guide/owners.md +[Creative Commons 4.0]: https://git.k8s.io/website/LICENSE diff --git a/vendor/sigs.k8s.io/json/SECURITY.md b/vendor/sigs.k8s.io/json/SECURITY.md new file mode 100644 index 0000000000..2083d44cdf --- /dev/null +++ b/vendor/sigs.k8s.io/json/SECURITY.md @@ -0,0 +1,22 @@ +# Security Policy + +## Security Announcements + +Join the [kubernetes-security-announce] group for security and vulnerability announcements. + +You can also subscribe to an RSS feed of the above using [this link][kubernetes-security-announce-rss]. + +## Reporting a Vulnerability + +Instructions for reporting a vulnerability can be found on the +[Kubernetes Security and Disclosure Information] page. + +## Supported Versions + +Information about supported Kubernetes versions can be found on the +[Kubernetes version and version skew support policy] page on the Kubernetes website. + +[kubernetes-security-announce]: https://groups.google.com/forum/#!forum/kubernetes-security-announce +[kubernetes-security-announce-rss]: https://groups.google.com/forum/feed/kubernetes-security-announce/msgs/rss_v2_0.xml?num=50 +[Kubernetes version and version skew support policy]: https://kubernetes.io/docs/setup/release/version-skew-policy/#supported-versions +[Kubernetes Security and Disclosure Information]: https://kubernetes.io/docs/reference/issues-security/security/#report-a-vulnerability diff --git a/vendor/sigs.k8s.io/json/SECURITY_CONTACTS b/vendor/sigs.k8s.io/json/SECURITY_CONTACTS new file mode 100644 index 0000000000..6a51db2fe8 --- /dev/null +++ b/vendor/sigs.k8s.io/json/SECURITY_CONTACTS @@ -0,0 +1,15 @@ +# Defined below are the security contacts for this repo. +# +# They are the contact point for the Product Security Committee to reach out +# to for triaging and handling of incoming issues. +# +# The below names agree to abide by the +# [Embargo Policy](https://git.k8s.io/security/private-distributors-list.md#embargo-policy) +# and will be removed and replaced if they violate that agreement. +# +# DO NOT REPORT SECURITY VULNERABILITIES DIRECTLY TO THESE NAMES, FOLLOW THE +# INSTRUCTIONS AT https://kubernetes.io/security/ + +deads2k +lavalamp +liggitt diff --git a/vendor/sigs.k8s.io/json/code-of-conduct.md b/vendor/sigs.k8s.io/json/code-of-conduct.md new file mode 100644 index 0000000000..0d15c00cf3 --- /dev/null +++ b/vendor/sigs.k8s.io/json/code-of-conduct.md @@ -0,0 +1,3 @@ +# Kubernetes Community Code of Conduct + +Please refer to our [Kubernetes Community Code of Conduct](https://git.k8s.io/community/code-of-conduct.md) diff --git a/vendor/sigs.k8s.io/json/doc.go b/vendor/sigs.k8s.io/json/doc.go new file mode 100644 index 0000000000..050eebb03e --- /dev/null +++ b/vendor/sigs.k8s.io/json/doc.go @@ -0,0 +1,17 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package json // import "sigs.k8s.io/json" diff --git a/vendor/sigs.k8s.io/json/go.mod b/vendor/sigs.k8s.io/json/go.mod new file mode 100644 index 0000000000..11cb4728cc --- /dev/null +++ b/vendor/sigs.k8s.io/json/go.mod @@ -0,0 +1,3 @@ +module sigs.k8s.io/json + +go 1.16 diff --git a/vendor/sigs.k8s.io/json/internal/golang/encoding/json/decode.go b/vendor/sigs.k8s.io/json/internal/golang/encoding/json/decode.go new file mode 100644 index 0000000000..a047d981bf --- /dev/null +++ b/vendor/sigs.k8s.io/json/internal/golang/encoding/json/decode.go @@ -0,0 +1,1402 @@ +// Copyright 2010 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Represents JSON data structure using native Go types: booleans, floats, +// strings, arrays, and maps. + +package json + +import ( + "encoding" + "encoding/base64" + "fmt" + "reflect" + "strconv" + "strings" + "unicode" + "unicode/utf16" + "unicode/utf8" +) + +// Unmarshal parses the JSON-encoded data and stores the result +// in the value pointed to by v. If v is nil or not a pointer, +// Unmarshal returns an InvalidUnmarshalError. +// +// Unmarshal uses the inverse of the encodings that +// Marshal uses, allocating maps, slices, and pointers as necessary, +// with the following additional rules: +// +// To unmarshal JSON into a pointer, Unmarshal first handles the case of +// the JSON being the JSON literal null. In that case, Unmarshal sets +// the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into +// the value pointed at by the pointer. If the pointer is nil, Unmarshal +// allocates a new value for it to point to. +// +// To unmarshal JSON into a value implementing the Unmarshaler interface, +// Unmarshal calls that value's UnmarshalJSON method, including +// when the input is a JSON null. +// Otherwise, if the value implements encoding.TextUnmarshaler +// and the input is a JSON quoted string, Unmarshal calls that value's +// UnmarshalText method with the unquoted form of the string. +// +// To unmarshal JSON into a struct, Unmarshal matches incoming object +// keys to the keys used by Marshal (either the struct field name or its tag), +// preferring an exact match but also accepting a case-insensitive match. By +// default, object keys which don't have a corresponding struct field are +// ignored (see Decoder.DisallowUnknownFields for an alternative). +// +// To unmarshal JSON into an interface value, +// Unmarshal stores one of these in the interface value: +// +// bool, for JSON booleans +// float64, for JSON numbers +// string, for JSON strings +// []interface{}, for JSON arrays +// map[string]interface{}, for JSON objects +// nil for JSON null +// +// To unmarshal a JSON array into a slice, Unmarshal resets the slice length +// to zero and then appends each element to the slice. +// As a special case, to unmarshal an empty JSON array into a slice, +// Unmarshal replaces the slice with a new empty slice. +// +// To unmarshal a JSON array into a Go array, Unmarshal decodes +// JSON array elements into corresponding Go array elements. +// If the Go array is smaller than the JSON array, +// the additional JSON array elements are discarded. +// If the JSON array is smaller than the Go array, +// the additional Go array elements are set to zero values. +// +// To unmarshal a JSON object into a map, Unmarshal first establishes a map to +// use. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal +// reuses the existing map, keeping existing entries. Unmarshal then stores +// key-value pairs from the JSON object into the map. The map's key type must +// either be any string type, an integer, implement json.Unmarshaler, or +// implement encoding.TextUnmarshaler. +// +// If a JSON value is not appropriate for a given target type, +// or if a JSON number overflows the target type, Unmarshal +// skips that field and completes the unmarshaling as best it can. +// If no more serious errors are encountered, Unmarshal returns +// an UnmarshalTypeError describing the earliest such error. In any +// case, it's not guaranteed that all the remaining fields following +// the problematic one will be unmarshaled into the target object. +// +// The JSON null value unmarshals into an interface, map, pointer, or slice +// by setting that Go value to nil. Because null is often used in JSON to mean +// ``not present,'' unmarshaling a JSON null into any other Go type has no effect +// on the value and produces no error. +// +// When unmarshaling quoted strings, invalid UTF-8 or +// invalid UTF-16 surrogate pairs are not treated as an error. +// Instead, they are replaced by the Unicode replacement +// character U+FFFD. +// +func Unmarshal(data []byte, v interface{}, opts ...UnmarshalOpt) error { + // Check for well-formedness. + // Avoids filling out half a data structure + // before discovering a JSON syntax error. + var d decodeState + + for _, opt := range opts { + opt(&d) + } + + err := checkValid(data, &d.scan) + if err != nil { + return err + } + + d.init(data) + return d.unmarshal(v) +} + +// Unmarshaler is the interface implemented by types +// that can unmarshal a JSON description of themselves. +// The input can be assumed to be a valid encoding of +// a JSON value. UnmarshalJSON must copy the JSON data +// if it wishes to retain the data after returning. +// +// By convention, to approximate the behavior of Unmarshal itself, +// Unmarshalers implement UnmarshalJSON([]byte("null")) as a no-op. +type Unmarshaler interface { + UnmarshalJSON([]byte) error +} + +/* +// An UnmarshalTypeError describes a JSON value that was +// not appropriate for a value of a specific Go type. +type UnmarshalTypeError struct { + Value string // description of JSON value - "bool", "array", "number -5" + Type reflect.Type // type of Go value it could not be assigned to + Offset int64 // error occurred after reading Offset bytes + Struct string // name of the struct type containing the field + Field string // the full path from root node to the field +} + +func (e *UnmarshalTypeError) Error() string { + if e.Struct != "" || e.Field != "" { + return "json: cannot unmarshal " + e.Value + " into Go struct field " + e.Struct + "." + e.Field + " of type " + e.Type.String() + } + return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String() +} + +// An UnmarshalFieldError describes a JSON object key that +// led to an unexported (and therefore unwritable) struct field. +// +// Deprecated: No longer used; kept for compatibility. +type UnmarshalFieldError struct { + Key string + Type reflect.Type + Field reflect.StructField +} + +func (e *UnmarshalFieldError) Error() string { + return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String() +} + +// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal. +// (The argument to Unmarshal must be a non-nil pointer.) +type InvalidUnmarshalError struct { + Type reflect.Type +} + +func (e *InvalidUnmarshalError) Error() string { + if e.Type == nil { + return "json: Unmarshal(nil)" + } + + if e.Type.Kind() != reflect.Ptr { + return "json: Unmarshal(non-pointer " + e.Type.String() + ")" + } + return "json: Unmarshal(nil " + e.Type.String() + ")" +} +*/ + +func (d *decodeState) unmarshal(v interface{}) error { + rv := reflect.ValueOf(v) + if rv.Kind() != reflect.Ptr || rv.IsNil() { + return &InvalidUnmarshalError{reflect.TypeOf(v)} + } + + d.scan.reset() + d.scanWhile(scanSkipSpace) + // We decode rv not rv.Elem because the Unmarshaler interface + // test must be applied at the top level of the value. + err := d.value(rv) + if err != nil { + return d.addErrorContext(err) + } + if d.savedError != nil { + return d.savedError + } + if len(d.savedStrictErrors) > 0 { + return &UnmarshalStrictError{Errors: d.savedStrictErrors} + } + return nil +} + +/* +// A Number represents a JSON number literal. +type Number string + +// String returns the literal text of the number. +func (n Number) String() string { return string(n) } + +// Float64 returns the number as a float64. +func (n Number) Float64() (float64, error) { + return strconv.ParseFloat(string(n), 64) +} + +// Int64 returns the number as an int64. +func (n Number) Int64() (int64, error) { + return strconv.ParseInt(string(n), 10, 64) +} +*/ + +// An errorContext provides context for type errors during decoding. +type errorContext struct { + Struct reflect.Type + FieldStack []string +} + +// decodeState represents the state while decoding a JSON value. +type decodeState struct { + data []byte + off int // next read offset in data + opcode int // last read result + scan scanner + errorContext *errorContext + savedError error + useNumber bool + disallowUnknownFields bool + + savedStrictErrors []error + seenStrictErrors map[string]struct{} + + caseSensitive bool + + preserveInts bool + + disallowDuplicateFields bool +} + +// readIndex returns the position of the last byte read. +func (d *decodeState) readIndex() int { + return d.off - 1 +} + +// phasePanicMsg is used as a panic message when we end up with something that +// shouldn't happen. It can indicate a bug in the JSON decoder, or that +// something is editing the data slice while the decoder executes. +const phasePanicMsg = "JSON decoder out of sync - data changing underfoot?" + +func (d *decodeState) init(data []byte) *decodeState { + d.data = data + d.off = 0 + d.savedError = nil + if d.errorContext != nil { + d.errorContext.Struct = nil + // Reuse the allocated space for the FieldStack slice. + d.errorContext.FieldStack = d.errorContext.FieldStack[:0] + } + return d +} + +// saveError saves the first err it is called with, +// for reporting at the end of the unmarshal. +func (d *decodeState) saveError(err error) { + if d.savedError == nil { + d.savedError = d.addErrorContext(err) + } +} + +// addErrorContext returns a new error enhanced with information from d.errorContext +func (d *decodeState) addErrorContext(err error) error { + if d.errorContext != nil && (d.errorContext.Struct != nil || len(d.errorContext.FieldStack) > 0) { + switch err := err.(type) { + case *UnmarshalTypeError: + err.Struct = d.errorContext.Struct.Name() + err.Field = strings.Join(d.errorContext.FieldStack, ".") + } + } + return err +} + +// skip scans to the end of what was started. +func (d *decodeState) skip() { + s, data, i := &d.scan, d.data, d.off + depth := len(s.parseState) + for { + op := s.step(s, data[i]) + i++ + if len(s.parseState) < depth { + d.off = i + d.opcode = op + return + } + } +} + +// scanNext processes the byte at d.data[d.off]. +func (d *decodeState) scanNext() { + if d.off < len(d.data) { + d.opcode = d.scan.step(&d.scan, d.data[d.off]) + d.off++ + } else { + d.opcode = d.scan.eof() + d.off = len(d.data) + 1 // mark processed EOF with len+1 + } +} + +// scanWhile processes bytes in d.data[d.off:] until it +// receives a scan code not equal to op. +func (d *decodeState) scanWhile(op int) { + s, data, i := &d.scan, d.data, d.off + for i < len(data) { + newOp := s.step(s, data[i]) + i++ + if newOp != op { + d.opcode = newOp + d.off = i + return + } + } + + d.off = len(data) + 1 // mark processed EOF with len+1 + d.opcode = d.scan.eof() +} + +// rescanLiteral is similar to scanWhile(scanContinue), but it specialises the +// common case where we're decoding a literal. The decoder scans the input +// twice, once for syntax errors and to check the length of the value, and the +// second to perform the decoding. +// +// Only in the second step do we use decodeState to tokenize literals, so we +// know there aren't any syntax errors. We can take advantage of that knowledge, +// and scan a literal's bytes much more quickly. +func (d *decodeState) rescanLiteral() { + data, i := d.data, d.off +Switch: + switch data[i-1] { + case '"': // string + for ; i < len(data); i++ { + switch data[i] { + case '\\': + i++ // escaped char + case '"': + i++ // tokenize the closing quote too + break Switch + } + } + case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-': // number + for ; i < len(data); i++ { + switch data[i] { + case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '.', 'e', 'E', '+', '-': + default: + break Switch + } + } + case 't': // true + i += len("rue") + case 'f': // false + i += len("alse") + case 'n': // null + i += len("ull") + } + if i < len(data) { + d.opcode = stateEndValue(&d.scan, data[i]) + } else { + d.opcode = scanEnd + } + d.off = i + 1 +} + +// value consumes a JSON value from d.data[d.off-1:], decoding into v, and +// reads the following byte ahead. If v is invalid, the value is discarded. +// The first byte of the value has been read already. +func (d *decodeState) value(v reflect.Value) error { + switch d.opcode { + default: + panic(phasePanicMsg) + + case scanBeginArray: + if v.IsValid() { + if err := d.array(v); err != nil { + return err + } + } else { + d.skip() + } + d.scanNext() + + case scanBeginObject: + if v.IsValid() { + if err := d.object(v); err != nil { + return err + } + } else { + d.skip() + } + d.scanNext() + + case scanBeginLiteral: + // All bytes inside literal return scanContinue op code. + start := d.readIndex() + d.rescanLiteral() + + if v.IsValid() { + if err := d.literalStore(d.data[start:d.readIndex()], v, false); err != nil { + return err + } + } + } + return nil +} + +type unquotedValue struct{} + +// valueQuoted is like value but decodes a +// quoted string literal or literal null into an interface value. +// If it finds anything other than a quoted string literal or null, +// valueQuoted returns unquotedValue{}. +func (d *decodeState) valueQuoted() interface{} { + switch d.opcode { + default: + panic(phasePanicMsg) + + case scanBeginArray, scanBeginObject: + d.skip() + d.scanNext() + + case scanBeginLiteral: + v := d.literalInterface() + switch v.(type) { + case nil, string: + return v + } + } + return unquotedValue{} +} + +// indirect walks down v allocating pointers as needed, +// until it gets to a non-pointer. +// If it encounters an Unmarshaler, indirect stops and returns that. +// If decodingNull is true, indirect stops at the first settable pointer so it +// can be set to nil. +func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) { + // Issue #24153 indicates that it is generally not a guaranteed property + // that you may round-trip a reflect.Value by calling Value.Addr().Elem() + // and expect the value to still be settable for values derived from + // unexported embedded struct fields. + // + // The logic below effectively does this when it first addresses the value + // (to satisfy possible pointer methods) and continues to dereference + // subsequent pointers as necessary. + // + // After the first round-trip, we set v back to the original value to + // preserve the original RW flags contained in reflect.Value. + v0 := v + haveAddr := false + + // If v is a named type and is addressable, + // start with its address, so that if the type has pointer methods, + // we find them. + if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() { + haveAddr = true + v = v.Addr() + } + for { + // Load value from interface, but only if the result will be + // usefully addressable. + if v.Kind() == reflect.Interface && !v.IsNil() { + e := v.Elem() + if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) { + haveAddr = false + v = e + continue + } + } + + if v.Kind() != reflect.Ptr { + break + } + + if decodingNull && v.CanSet() { + break + } + + // Prevent infinite loop if v is an interface pointing to its own address: + // var v interface{} + // v = &v + if v.Elem().Kind() == reflect.Interface && v.Elem().Elem() == v { + v = v.Elem() + break + } + if v.IsNil() { + v.Set(reflect.New(v.Type().Elem())) + } + if v.Type().NumMethod() > 0 && v.CanInterface() { + if u, ok := v.Interface().(Unmarshaler); ok { + return u, nil, reflect.Value{} + } + if !decodingNull { + if u, ok := v.Interface().(encoding.TextUnmarshaler); ok { + return nil, u, reflect.Value{} + } + } + } + + if haveAddr { + v = v0 // restore original value after round-trip Value.Addr().Elem() + haveAddr = false + } else { + v = v.Elem() + } + } + return nil, nil, v +} + +// array consumes an array from d.data[d.off-1:], decoding into v. +// The first byte of the array ('[') has been read already. +func (d *decodeState) array(v reflect.Value) error { + // Check for unmarshaler. + u, ut, pv := indirect(v, false) + if u != nil { + start := d.readIndex() + d.skip() + return u.UnmarshalJSON(d.data[start:d.off]) + } + if ut != nil { + d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)}) + d.skip() + return nil + } + v = pv + + // Check type of target. + switch v.Kind() { + case reflect.Interface: + if v.NumMethod() == 0 { + // Decoding into nil interface? Switch to non-reflect code. + ai := d.arrayInterface() + v.Set(reflect.ValueOf(ai)) + return nil + } + // Otherwise it's invalid. + fallthrough + default: + d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)}) + d.skip() + return nil + case reflect.Array, reflect.Slice: + break + } + + i := 0 + for { + // Look ahead for ] - can only happen on first iteration. + d.scanWhile(scanSkipSpace) + if d.opcode == scanEndArray { + break + } + + // Get element of array, growing if necessary. + if v.Kind() == reflect.Slice { + // Grow slice if necessary + if i >= v.Cap() { + newcap := v.Cap() + v.Cap()/2 + if newcap < 4 { + newcap = 4 + } + newv := reflect.MakeSlice(v.Type(), v.Len(), newcap) + reflect.Copy(newv, v) + v.Set(newv) + } + if i >= v.Len() { + v.SetLen(i + 1) + } + } + + if i < v.Len() { + // Decode into element. + if err := d.value(v.Index(i)); err != nil { + return err + } + } else { + // Ran out of fixed array: skip. + if err := d.value(reflect.Value{}); err != nil { + return err + } + } + i++ + + // Next token must be , or ]. + if d.opcode == scanSkipSpace { + d.scanWhile(scanSkipSpace) + } + if d.opcode == scanEndArray { + break + } + if d.opcode != scanArrayValue { + panic(phasePanicMsg) + } + } + + if i < v.Len() { + if v.Kind() == reflect.Array { + // Array. Zero the rest. + z := reflect.Zero(v.Type().Elem()) + for ; i < v.Len(); i++ { + v.Index(i).Set(z) + } + } else { + v.SetLen(i) + } + } + if i == 0 && v.Kind() == reflect.Slice { + v.Set(reflect.MakeSlice(v.Type(), 0, 0)) + } + return nil +} + +var nullLiteral = []byte("null") +var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem() + +// object consumes an object from d.data[d.off-1:], decoding into v. +// The first byte ('{') of the object has been read already. +func (d *decodeState) object(v reflect.Value) error { + // Check for unmarshaler. + u, ut, pv := indirect(v, false) + if u != nil { + start := d.readIndex() + d.skip() + return u.UnmarshalJSON(d.data[start:d.off]) + } + if ut != nil { + d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)}) + d.skip() + return nil + } + v = pv + t := v.Type() + + // Decoding into nil interface? Switch to non-reflect code. + if v.Kind() == reflect.Interface && v.NumMethod() == 0 { + oi := d.objectInterface() + v.Set(reflect.ValueOf(oi)) + return nil + } + + var fields structFields + var checkDuplicateField func(fieldNameIndex int, fieldName string) + + // Check type of target: + // struct or + // map[T1]T2 where T1 is string, an integer type, + // or an encoding.TextUnmarshaler + switch v.Kind() { + case reflect.Map: + // Map key must either have string kind, have an integer kind, + // or be an encoding.TextUnmarshaler. + switch t.Key().Kind() { + case reflect.String, + reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + default: + if !reflect.PtrTo(t.Key()).Implements(textUnmarshalerType) { + d.saveError(&UnmarshalTypeError{Value: "object", Type: t, Offset: int64(d.off)}) + d.skip() + return nil + } + } + if v.IsNil() { + v.Set(reflect.MakeMap(t)) + } + + if d.disallowDuplicateFields { + var seenKeys map[string]struct{} + checkDuplicateField = func(fieldNameIndex int, fieldName string) { + if seenKeys == nil { + seenKeys = map[string]struct{}{} + } + if _, seen := seenKeys[fieldName]; seen { + d.saveStrictError(fmt.Errorf("duplicate field %q", fieldName)) + } else { + seenKeys[fieldName] = struct{}{} + } + } + } + + case reflect.Struct: + fields = cachedTypeFields(t) + + if d.disallowDuplicateFields { + if len(fields.list) <= 64 { + // bitset by field index for structs with <= 64 fields + var seenKeys uint64 + checkDuplicateField = func(fieldNameIndex int, fieldName string) { + if seenKeys&(1< '9') { + if fromQuoted { + return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()) + } + panic(phasePanicMsg) + } + s := string(item) + switch v.Kind() { + default: + if v.Kind() == reflect.String && v.Type() == numberType { + // s must be a valid number, because it's + // already been tokenized. + v.SetString(s) + break + } + if fromQuoted { + return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()) + } + d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())}) + case reflect.Interface: + n, err := d.convertNumber(s) + if err != nil { + d.saveError(err) + break + } + if v.NumMethod() != 0 { + d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())}) + break + } + v.Set(reflect.ValueOf(n)) + + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + n, err := strconv.ParseInt(s, 10, 64) + if err != nil || v.OverflowInt(n) { + d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())}) + break + } + v.SetInt(n) + + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + n, err := strconv.ParseUint(s, 10, 64) + if err != nil || v.OverflowUint(n) { + d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())}) + break + } + v.SetUint(n) + + case reflect.Float32, reflect.Float64: + n, err := strconv.ParseFloat(s, v.Type().Bits()) + if err != nil || v.OverflowFloat(n) { + d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())}) + break + } + v.SetFloat(n) + } + } + return nil +} + +// The xxxInterface routines build up a value to be stored +// in an empty interface. They are not strictly necessary, +// but they avoid the weight of reflection in this common case. + +// valueInterface is like value but returns interface{} +func (d *decodeState) valueInterface() (val interface{}) { + switch d.opcode { + default: + panic(phasePanicMsg) + case scanBeginArray: + val = d.arrayInterface() + d.scanNext() + case scanBeginObject: + val = d.objectInterface() + d.scanNext() + case scanBeginLiteral: + val = d.literalInterface() + } + return +} + +// arrayInterface is like array but returns []interface{}. +func (d *decodeState) arrayInterface() []interface{} { + var v = make([]interface{}, 0) + for { + // Look ahead for ] - can only happen on first iteration. + d.scanWhile(scanSkipSpace) + if d.opcode == scanEndArray { + break + } + + v = append(v, d.valueInterface()) + + // Next token must be , or ]. + if d.opcode == scanSkipSpace { + d.scanWhile(scanSkipSpace) + } + if d.opcode == scanEndArray { + break + } + if d.opcode != scanArrayValue { + panic(phasePanicMsg) + } + } + return v +} + +// objectInterface is like object but returns map[string]interface{}. +func (d *decodeState) objectInterface() map[string]interface{} { + m := make(map[string]interface{}) + for { + // Read opening " of string key or closing }. + d.scanWhile(scanSkipSpace) + if d.opcode == scanEndObject { + // closing } - can only happen on first iteration. + break + } + if d.opcode != scanBeginLiteral { + panic(phasePanicMsg) + } + + // Read string key. + start := d.readIndex() + d.rescanLiteral() + item := d.data[start:d.readIndex()] + key, ok := unquote(item) + if !ok { + panic(phasePanicMsg) + } + + // Read : before value. + if d.opcode == scanSkipSpace { + d.scanWhile(scanSkipSpace) + } + if d.opcode != scanObjectKey { + panic(phasePanicMsg) + } + d.scanWhile(scanSkipSpace) + + if d.disallowDuplicateFields { + if _, exists := m[key]; exists { + d.saveStrictError(fmt.Errorf("duplicate field %q", key)) + } + } + + // Read value. + m[key] = d.valueInterface() + + // Next token must be , or }. + if d.opcode == scanSkipSpace { + d.scanWhile(scanSkipSpace) + } + if d.opcode == scanEndObject { + break + } + if d.opcode != scanObjectValue { + panic(phasePanicMsg) + } + } + return m +} + +// literalInterface consumes and returns a literal from d.data[d.off-1:] and +// it reads the following byte ahead. The first byte of the literal has been +// read already (that's how the caller knows it's a literal). +func (d *decodeState) literalInterface() interface{} { + // All bytes inside literal return scanContinue op code. + start := d.readIndex() + d.rescanLiteral() + + item := d.data[start:d.readIndex()] + + switch c := item[0]; c { + case 'n': // null + return nil + + case 't', 'f': // true, false + return c == 't' + + case '"': // string + s, ok := unquote(item) + if !ok { + panic(phasePanicMsg) + } + return s + + default: // number + if c != '-' && (c < '0' || c > '9') { + panic(phasePanicMsg) + } + n, err := d.convertNumber(string(item)) + if err != nil { + d.saveError(err) + } + return n + } +} + +// getu4 decodes \uXXXX from the beginning of s, returning the hex value, +// or it returns -1. +func getu4(s []byte) rune { + if len(s) < 6 || s[0] != '\\' || s[1] != 'u' { + return -1 + } + var r rune + for _, c := range s[2:6] { + switch { + case '0' <= c && c <= '9': + c = c - '0' + case 'a' <= c && c <= 'f': + c = c - 'a' + 10 + case 'A' <= c && c <= 'F': + c = c - 'A' + 10 + default: + return -1 + } + r = r*16 + rune(c) + } + return r +} + +// unquote converts a quoted JSON string literal s into an actual string t. +// The rules are different than for Go, so cannot use strconv.Unquote. +func unquote(s []byte) (t string, ok bool) { + s, ok = unquoteBytes(s) + t = string(s) + return +} + +func unquoteBytes(s []byte) (t []byte, ok bool) { + if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' { + return + } + s = s[1 : len(s)-1] + + // Check for unusual characters. If there are none, + // then no unquoting is needed, so return a slice of the + // original bytes. + r := 0 + for r < len(s) { + c := s[r] + if c == '\\' || c == '"' || c < ' ' { + break + } + if c < utf8.RuneSelf { + r++ + continue + } + rr, size := utf8.DecodeRune(s[r:]) + if rr == utf8.RuneError && size == 1 { + break + } + r += size + } + if r == len(s) { + return s, true + } + + b := make([]byte, len(s)+2*utf8.UTFMax) + w := copy(b, s[0:r]) + for r < len(s) { + // Out of room? Can only happen if s is full of + // malformed UTF-8 and we're replacing each + // byte with RuneError. + if w >= len(b)-2*utf8.UTFMax { + nb := make([]byte, (len(b)+utf8.UTFMax)*2) + copy(nb, b[0:w]) + b = nb + } + switch c := s[r]; { + case c == '\\': + r++ + if r >= len(s) { + return + } + switch s[r] { + default: + return + case '"', '\\', '/', '\'': + b[w] = s[r] + r++ + w++ + case 'b': + b[w] = '\b' + r++ + w++ + case 'f': + b[w] = '\f' + r++ + w++ + case 'n': + b[w] = '\n' + r++ + w++ + case 'r': + b[w] = '\r' + r++ + w++ + case 't': + b[w] = '\t' + r++ + w++ + case 'u': + r-- + rr := getu4(s[r:]) + if rr < 0 { + return + } + r += 6 + if utf16.IsSurrogate(rr) { + rr1 := getu4(s[r:]) + if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar { + // A valid pair; consume. + r += 6 + w += utf8.EncodeRune(b[w:], dec) + break + } + // Invalid surrogate; fall back to replacement rune. + rr = unicode.ReplacementChar + } + w += utf8.EncodeRune(b[w:], rr) + } + + // Quote, control characters are invalid. + case c == '"', c < ' ': + return + + // ASCII + case c < utf8.RuneSelf: + b[w] = c + r++ + w++ + + // Coerce to well-formed UTF-8. + default: + rr, size := utf8.DecodeRune(s[r:]) + r += size + w += utf8.EncodeRune(b[w:], rr) + } + } + return b[0:w], true +} diff --git a/vendor/sigs.k8s.io/json/internal/golang/encoding/json/encode.go b/vendor/sigs.k8s.io/json/internal/golang/encoding/json/encode.go new file mode 100644 index 0000000000..e473e615a9 --- /dev/null +++ b/vendor/sigs.k8s.io/json/internal/golang/encoding/json/encode.go @@ -0,0 +1,1419 @@ +// Copyright 2010 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package json implements encoding and decoding of JSON as defined in +// RFC 7159. The mapping between JSON and Go values is described +// in the documentation for the Marshal and Unmarshal functions. +// +// See "JSON and Go" for an introduction to this package: +// https://golang.org/doc/articles/json_and_go.html +package json + +import ( + "bytes" + "encoding" + "encoding/base64" + "fmt" + "math" + "reflect" + "sort" + "strconv" + "strings" + "sync" + "unicode" + "unicode/utf8" +) + +// Marshal returns the JSON encoding of v. +// +// Marshal traverses the value v recursively. +// If an encountered value implements the Marshaler interface +// and is not a nil pointer, Marshal calls its MarshalJSON method +// to produce JSON. If no MarshalJSON method is present but the +// value implements encoding.TextMarshaler instead, Marshal calls +// its MarshalText method and encodes the result as a JSON string. +// The nil pointer exception is not strictly necessary +// but mimics a similar, necessary exception in the behavior of +// UnmarshalJSON. +// +// Otherwise, Marshal uses the following type-dependent default encodings: +// +// Boolean values encode as JSON booleans. +// +// Floating point, integer, and Number values encode as JSON numbers. +// +// String values encode as JSON strings coerced to valid UTF-8, +// replacing invalid bytes with the Unicode replacement rune. +// So that the JSON will be safe to embed inside HTML